00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #include <stdio.h>
00024 #include <assert.h>
00025
00026 #include <tqgroupbox.h>
00027 #include <tqlabel.h>
00028 #include <tqcheckbox.h>
00029 #include <tqlayout.h>
00030 #include <tqtooltip.h>
00031 #include <tqslider.h>
00032 #include <tqwmatrix.h>
00033
00034 #include <kapplication.h>
00035 #include <klocale.h>
00036 #include <kstandarddirs.h>
00037 #include <kiconview.h>
00038 #include <ksimpleconfig.h>
00039
00040 #include "kcarddialog.h"
00041 #include <tqpushbutton.h>
00042 #include <kdebug.h>
00043
00044 #define KCARD_DEFAULTDECK TQString::fromLatin1("deck0.png")
00045 #define KCARD_DEFAULTCARD TQString::fromLatin1("11.png")
00046 #define KCARD_DEFAULTCARDDIR TQString::fromLatin1("cards-default/")
00047
00048
00049 #define SLIDER_MIN 400
00050 #define SLIDER_MAX 3000
00051
00052
00053 #define CONF_GROUP "KCardDialog"
00054 #define CONF_RANDOMDECK TQString::fromLatin1("RandomDeck")
00055 #define CONF_DECK TQString::fromLatin1("Deck")
00056 #define CONF_CARDDIR TQString::fromLatin1("CardDir")
00057 #define CONF_RANDOMCARDDIR TQString::fromLatin1("RandomCardDir")
00058 #define CONF_USEGLOBALDECK TQString::fromLatin1("GlobalDeck")
00059 #define CONF_USEGLOBALCARDDIR TQString::fromLatin1("GlobalCardDir")
00060 #define CONF_SCALE TQString::fromLatin1("Scale")
00061
00062 #define CONF_GLOBAL_GROUP TQString::fromLatin1("KCardDialog Settings")
00063 #define CONF_GLOBAL_DECK TQString::fromLatin1("GlobalDeck")
00064 #define CONF_GLOBAL_CARDDIR TQString::fromLatin1("GlobalCardDir")
00065 #define CONF_GLOBAL_RANDOMDECK TQString::fromLatin1("GlobalRandomDeck")
00066 #define CONF_GLOBAL_RANDOMCARDDIR TQString::fromLatin1("GlobalRandomCardDir")
00067
00068
00069 class KCardDialogPrivate
00070 {
00071 public:
00072 KCardDialogPrivate()
00073 {
00074 deckLabel = 0;
00075 cardLabel = 0;
00076 deckIconView = 0;
00077 cardIconView = 0;
00078 randomDeck = 0;
00079 randomCardDir = 0;
00080 cPreview = 0;
00081 scaleSlider = 0;
00082 globalDeck = 0;
00083 globalCardDir = 0;
00084
00085 cScale = 1;
00086 }
00087
00088 TQLabel* deckLabel;
00089 TQLabel* cardLabel;
00090 KIconView* deckIconView;
00091 KIconView* cardIconView;
00092 TQCheckBox* randomDeck;
00093 TQCheckBox* randomCardDir;
00094 TQCheckBox* globalDeck;
00095 TQCheckBox* globalCardDir;
00096
00097 TQSlider* scaleSlider;
00098 TQPixmap cPreviewPix;
00099 TQLabel* cPreview;
00100
00101 TQMap<TQIconViewItem*, TQString> deckMap;
00102 TQMap<TQIconViewItem*, TQString> cardMap;
00103 TQMap<TQString, TQString> helpMap;
00104
00105
00106 KCardDialog::CardFlags cFlags;
00107 TQString cDeck;
00108 TQString cCardDir;
00109 double cScale;
00110 };
00111
00112 int KCardDialog::getCardDeck(TQString &pDeck, TQString &pCardDir, TQWidget *pParent,
00113 CardFlags pFlags, bool* pRandomDeck, bool* pRandomCardDir,
00114 double* pScale, KConfig* pConf)
00115 {
00116 KCardDialog dlg(pParent, "dlg", pFlags);
00117
00118 dlg.setDeck(pDeck);
00119 dlg.setCardDir(pCardDir);
00120
00121 dlg.setupDialog(pScale != 0);
00122 dlg.loadConfig(pConf);
00123 dlg.showRandomDeckBox(pRandomDeck != 0);
00124 dlg.showRandomCardDirBox(pRandomCardDir != 0);
00125 int result=dlg.exec();
00126 if (result==TQDialog::Accepted)
00127 {
00128
00129 pDeck=dlg.deck();
00130 pCardDir=dlg.cardDir();
00131 if (!pCardDir.isNull() && pCardDir.right(1)!=TQString::fromLatin1("/"))
00132 {
00133 pCardDir+=TQString::fromLatin1("/");
00134 }
00135 if (pRandomDeck)
00136 {
00137 *pRandomDeck = dlg.isRandomDeck();
00138 }
00139 if (pRandomCardDir)
00140 {
00141 *pRandomCardDir = dlg.isRandomCardDir();
00142 }
00143 if (pScale)
00144 {
00145 *pScale = dlg.cardScale();
00146 }
00147
00148 if (dlg.isGlobalDeck())
00149 {
00150 kdDebug(11000) << "use global deck" << endl;
00151 bool random;
00152 getGlobalDeck(pDeck, random);
00153 kdDebug(11000) << "use: " << pDeck<< endl;
00154 if (pRandomDeck)
00155 {
00156 *pRandomDeck=random;
00157 if (random)
00158 kdDebug(11000) << "use random deck" << endl;
00159 }
00160 }
00161 if (dlg.isGlobalCardDir())
00162 {
00163 kdDebug(11000) << "use global carddir" << endl;
00164 bool random;
00165 getGlobalCardDir(pCardDir, random);
00166 kdDebug(11000) << "use: " << pCardDir << endl;
00167 if (pRandomCardDir)
00168 {
00169 *pRandomCardDir=random;
00170 if (random)
00171 kdDebug(11000) << "use random carddir" << endl;
00172 }
00173 }
00174 }
00175 dlg.saveConfig(pConf);
00176 return result;
00177 }
00178
00179 void KCardDialog::getConfigCardDeck(KConfig* conf, TQString &pDeck, TQString &pCardDir, double& pScale)
00180 {
00181
00182 if (!conf) {
00183 return;
00184 }
00185 TQString origGroup = conf->group();
00186
00187 conf->setGroup(CONF_GROUP);
00188 if (conf->readBoolEntry(CONF_RANDOMDECK) || !conf->hasKey(CONF_DECK)) {
00189 pDeck = getRandomDeck();
00190 } else {
00191 pDeck = conf->readEntry(CONF_DECK);
00192 }
00193 if (conf->readBoolEntry(CONF_RANDOMCARDDIR) || !conf->hasKey(CONF_CARDDIR)) {
00194 pCardDir = getRandomCardDir();
00195 } else {
00196 pCardDir = conf->readPathEntry(CONF_CARDDIR);
00197 }
00198 pScale = conf->readDoubleNumEntry(CONF_SCALE, 1.0);
00199
00200 if (conf->readBoolEntry(CONF_USEGLOBALDECK, false)) {
00201 bool random;
00202 getGlobalDeck(pCardDir, random);
00203 if (random || pDeck.isNull() ) {
00204 pDeck = getRandomDeck();
00205 }
00206 }
00207 if (conf->readBoolEntry(CONF_USEGLOBALCARDDIR, false)) {
00208 bool random;
00209 getGlobalCardDir(pCardDir, random);
00210 if (random || pCardDir.isNull() ) {
00211 pCardDir = getRandomCardDir();
00212 }
00213 }
00214
00215 conf->setGroup(origGroup);
00216 }
00217
00218 TQString KCardDialog::getDefaultDeck()
00219 {
00220 KCardDialog::init();
00221 return locate("cards", TQString::fromLatin1("decks/") + KCARD_DEFAULTDECK);
00222 }
00223
00224 TQString KCardDialog::getDefaultCardDir()
00225 {
00226 KCardDialog::init();
00227
00228 TQString file = KCARD_DEFAULTCARDDIR + KCARD_DEFAULTCARD;
00229 return KGlobal::dirs()->findResourceDir("cards",file) + KCARD_DEFAULTCARDDIR;
00230 }
00231
00232 TQString KCardDialog::getCardPath(const TQString &carddir, int index)
00233 {
00234 KCardDialog::init();
00235
00236 TQString entry = carddir + TQString::number(index);
00237 if (KStandardDirs::exists(entry + TQString::fromLatin1(".png")))
00238 return entry + TQString::fromLatin1(".png");
00239
00240
00241 if (KStandardDirs::exists(entry + TQString::fromLatin1(".xpm")))
00242 return entry + TQString::fromLatin1(".xpm");
00243
00244 return TQString();
00245 }
00246
00247 const TQString& KCardDialog::deck() const { return d->cDeck; }
00248 void KCardDialog::setDeck(const TQString& file) { d->cDeck=file; }
00249 const TQString& KCardDialog::cardDir() const { return d->cCardDir; }
00250 void KCardDialog::setCardDir(const TQString& dir) { d->cCardDir=dir; }
00251 KCardDialog::CardFlags KCardDialog::flags() const { return d->cFlags; }
00252 double KCardDialog::cardScale() const { return d->cScale; }
00253 bool KCardDialog::isRandomDeck() const
00254 { return (d->randomDeck ? d->randomDeck->isChecked() : false); }
00255 bool KCardDialog::isRandomCardDir() const
00256 { return (d->randomCardDir ? d->randomCardDir->isChecked() : false); }
00257 bool KCardDialog::isGlobalDeck() const
00258 { return (d->globalDeck ? d->globalDeck->isChecked() : false); }
00259 bool KCardDialog::isGlobalCardDir() const
00260 { return (d->globalCardDir ? d->globalCardDir->isChecked() : false); }
00261
00262 void KCardDialog::setupDialog(bool showResizeBox)
00263 {
00264 TQHBoxLayout* topLayout = new TQHBoxLayout(plainPage(), spacingHint());
00265 TQVBoxLayout* cardLayout = new TQVBoxLayout(topLayout);
00266 TQString path, file;
00267 TQWMatrix m;
00268 m.scale(0.8,0.8);
00269
00270 setInitialSize(TQSize(600,400));
00271
00272 if (! (flags() & NoDeck))
00273 {
00274 TQHBoxLayout* layout = new TQHBoxLayout(cardLayout);
00275
00276
00277 TQGroupBox* grp1 = new TQGroupBox(1,Qt::Horizontal, i18n("Choose Backside"), plainPage());
00278 layout->addWidget(grp1);
00279
00280 d->deckIconView = new KIconView(grp1,"decks");
00281 d->deckIconView->setSpacing(8);
00282
00283
00284
00285
00286 d->deckIconView->setGridX(82);
00287 d->deckIconView->setGridY(106);
00288 d->deckIconView->setSelectionMode(TQIconView::Single);
00289 d->deckIconView->setResizeMode(TQIconView::Adjust);
00290 d->deckIconView->setMinimumWidth(360);
00291 d->deckIconView->setMinimumHeight(170);
00292 d->deckIconView->setWordWrapIconText(false);
00293 d->deckIconView->showToolTips();
00294
00295
00296 TQVBoxLayout* l = new TQVBoxLayout(layout);
00297 TQGroupBox* grp3 = new TQGroupBox(i18n("Backside"), plainPage());
00298 grp3->setFixedSize(100, 130);
00299 l->addWidget(grp3, 0, AlignTop|AlignHCenter);
00300 d->deckLabel = new TQLabel(grp3);
00301 d->deckLabel->setText(i18n("empty"));
00302 d->deckLabel->setAlignment(AlignHCenter|AlignVCenter);
00303 d->deckLabel->setGeometry(10, 20, 80, 90);
00304
00305 d->randomDeck = new TQCheckBox(plainPage());
00306 d->randomDeck->setChecked(false);
00307 connect(d->randomDeck, TQT_SIGNAL(toggled(bool)), this,
00308 TQT_SLOT(slotRandomDeckToggled(bool)));
00309 d->randomDeck->setText(i18n("Random backside"));
00310 l->addWidget(d->randomDeck, 0, AlignTop|AlignHCenter);
00311
00312 d->globalDeck = new TQCheckBox(plainPage());
00313 d->globalDeck->setChecked(false);
00314 d->globalDeck->setText(i18n("Use global backside"));
00315 l->addWidget(d->globalDeck, 0, AlignTop|AlignHCenter);
00316
00317 TQPushButton* b = new TQPushButton(i18n("Make Backside Global"), plainPage());
00318 connect(b, TQT_SIGNAL(pressed()), this, TQT_SLOT(slotSetGlobalDeck()));
00319 l->addWidget(b, 0, AlignTop|AlignHCenter);
00320
00321 connect(d->deckIconView,TQT_SIGNAL(clicked(TQIconViewItem *)),
00322 this,TQT_SLOT(slotDeckClicked(TQIconViewItem *)));
00323 }
00324
00325 if (! (flags() & NoCards))
00326 {
00327
00328 TQHBoxLayout* layout = new TQHBoxLayout(cardLayout);
00329 TQGroupBox* grp2 = new TQGroupBox(1,Qt::Horizontal, i18n("Choose Frontside"), plainPage());
00330 layout->addWidget(grp2);
00331
00332 d->cardIconView =new KIconView(grp2,"cards");
00333
00334
00335
00336
00337 d->cardIconView->setGridX(82);
00338 d->cardIconView->setGridY(106);
00339 d->cardIconView->setResizeMode(TQIconView::Adjust);
00340 d->cardIconView->setMinimumWidth(360);
00341 d->cardIconView->setMinimumHeight(170);
00342 d->cardIconView->setWordWrapIconText(false);
00343 d->cardIconView->showToolTips();
00344
00345
00346 TQVBoxLayout* l = new TQVBoxLayout(layout);
00347 TQGroupBox* grp4 = new TQGroupBox(i18n("Frontside"), plainPage());
00348 grp4->setFixedSize(100, 130);
00349 l->addWidget(grp4, 0, AlignTop|AlignHCenter);
00350 d->cardLabel = new TQLabel(grp4);
00351 d->cardLabel->setText(i18n("empty"));
00352 d->cardLabel->setAlignment(AlignHCenter|AlignVCenter);
00353 d->cardLabel->setGeometry(10, 20, 80, 90 );
00354
00355 d->randomCardDir = new TQCheckBox(plainPage());
00356 d->randomCardDir->setChecked(false);
00357 connect(d->randomCardDir, TQT_SIGNAL(toggled(bool)), this,
00358 TQT_SLOT(slotRandomCardDirToggled(bool)));
00359 d->randomCardDir->setText(i18n("Random frontside"));
00360 l->addWidget(d->randomCardDir, 0, AlignTop|AlignHCenter);
00361
00362 d->globalCardDir = new TQCheckBox(plainPage());
00363 d->globalCardDir->setChecked(false);
00364 d->globalCardDir->setText(i18n("Use global frontside"));
00365 l->addWidget(d->globalCardDir, 0, AlignTop|AlignHCenter);
00366
00367 TQPushButton* b = new TQPushButton(i18n("Make Frontside Global"), plainPage());
00368 connect(b, TQT_SIGNAL(pressed()), this, TQT_SLOT(slotSetGlobalCardDir()));
00369 l->addWidget(b, 0, AlignTop|AlignHCenter);
00370
00371 connect(d->cardIconView,TQT_SIGNAL(clicked(TQIconViewItem *)),
00372 this,TQT_SLOT(slotCardClicked(TQIconViewItem *)));
00373 }
00374
00375
00376
00377 if (! (flags() & NoDeck))
00378 {
00379 insertDeckIcons();
00380 d->deckIconView->arrangeItemsInGrid();
00381
00382
00383 if (!deck().isNull())
00384 {
00385 file=deck();
00386 TQPixmap pixmap(file);
00387 pixmap=pixmap.xForm(m);
00388 d->deckLabel->setPixmap(pixmap);
00389 TQToolTip::add(d->deckLabel,d->helpMap[file]);
00390 }
00391 }
00392
00393
00394 if (! (flags() & NoCards))
00395 {
00396 insertCardIcons();
00397 d->cardIconView->arrangeItemsInGrid();
00398
00399
00400 if (!cardDir().isNull())
00401 {
00402 file = cardDir() + KCARD_DEFAULTCARD;
00403 TQPixmap pixmap(file);
00404 pixmap = pixmap.xForm(m);
00405 d->cardLabel->setPixmap(pixmap);
00406 TQToolTip::add(d->cardLabel,d->helpMap[cardDir()]);
00407 }
00408 }
00409
00410
00411 if (showResizeBox)
00412 {
00413
00414
00415
00416
00417
00418
00419
00420
00421
00422
00423
00424
00425 TQVBoxLayout* layout = new TQVBoxLayout(topLayout);
00426 TQGroupBox* grp = new TQGroupBox(1,Qt::Horizontal, i18n("Resize Cards"), plainPage());
00427 layout->setResizeMode(TQLayout::Fixed);
00428 layout->addWidget(grp);
00429 TQWidget* box = new TQWidget(grp);
00430 TQHBoxLayout* hbox = new TQHBoxLayout(box, 0, spacingHint());
00431 TQVBoxLayout* boxLayout = new TQVBoxLayout(hbox);
00432 hbox->addStretch(0);
00433
00434 d->scaleSlider = new TQSlider(1, SLIDER_MAX, 1, (-1000+SLIDER_MIN+SLIDER_MAX),Qt::Horizontal, box);
00435 d->scaleSlider->setMinValue(SLIDER_MIN);
00436 connect(d->scaleSlider, TQT_SIGNAL(valueChanged(int)), this, TQT_SLOT(slotCardResized(int)));
00437 boxLayout->addWidget(d->scaleSlider, 0, AlignLeft);
00438
00439 TQPushButton* b = new TQPushButton(i18n("Default Size"), box);
00440 connect(b, TQT_SIGNAL(pressed()), this, TQT_SLOT(slotDefaultSize()));
00441 boxLayout->addWidget(b, 0, AlignLeft);
00442
00443 TQLabel* l = new TQLabel(i18n("Preview:"), box);
00444 boxLayout->addWidget(l);
00445 d->cPreviewPix.load(getDefaultDeck());
00446 d->cPreview = new TQLabel(box);
00447 boxLayout->addWidget(d->cPreview, 0, AlignCenter|AlignVCenter);
00448
00449 slotCardResized(d->scaleSlider->value());
00450 }
00451 }
00452
00453 void KCardDialog::insertCardIcons()
00454 {
00455 TQStringList list = KGlobal::dirs()->findAllResources("cards", "card*/index.desktop", false, true);
00456
00457 if (list.isEmpty())
00458 return;
00459
00460
00461
00462 TQWMatrix m;
00463 m.scale(0.8,0.8);
00464
00465 for (TQStringList::ConstIterator it = list.begin(); it != list.end(); ++it)
00466 {
00467 KSimpleConfig cfg(*it);
00468 cfg.setGroup(TQString::fromLatin1("KDE Backdeck"));
00469 TQString path = (*it).left((*it).findRev('/') + 1);
00470 assert(path[path.length() - 1] == '/');
00471 TQPixmap pixmap(path + cfg.readEntry("Preview", "12c.png"));
00472
00473 if (pixmap.isNull())
00474 continue;
00475
00476 TQString name=cfg.readEntry("Name", i18n("unnamed"));
00477 TQIconViewItem *item= new TQIconViewItem(d->cardIconView, name, pixmap);
00478
00479 item->setDragEnabled(false);
00480 item->setDropEnabled(false);
00481 item->setRenameEnabled(false);
00482 item->setSelectable(true);
00483
00484 d->cardMap[item] = path;
00485 d->helpMap[path] = cfg.readEntry("Comment",name);
00486 }
00487 }
00488
00489 void KCardDialog::insertDeckIcons()
00490 {
00491 TQStringList list = KGlobal::dirs()->findAllResources("cards", "decks/*.desktop", false, true);
00492 if (list.isEmpty())
00493 return;
00494
00495 TQString label;
00496
00497
00498 TQWMatrix m;
00499 m.scale(0.8,0.8);
00500
00501 for (TQStringList::ConstIterator it = list.begin(); it != list.end(); ++it)
00502 {
00503 KSimpleConfig cfg(*it);
00504 TQPixmap pixmap(getDeckName(*it));
00505 if (pixmap.isNull())
00506 continue;
00507
00508
00509
00510 cfg.setGroup(TQString::fromLatin1("KDE Cards"));
00511 TQString name=cfg.readEntry("Name", i18n("unnamed"));
00512 TQIconViewItem *item= new TQIconViewItem(d->deckIconView,name, pixmap);
00513
00514 item->setDragEnabled(false);
00515 item->setDropEnabled(false);
00516 item->setRenameEnabled(false);
00517
00518 d->deckMap[item] = getDeckName(*it);
00519 d->helpMap[d->deckMap[item]] = cfg.readEntry("Comment",name);
00520 }
00521 }
00522
00523
00524 KCardDialog::~KCardDialog()
00525 {
00526 delete d;
00527 }
00528
00529
00530
00531 KCardDialog::KCardDialog( TQWidget *parent, const char *name, CardFlags mFlags)
00532 : KDialogBase( Plain, i18n("Carddeck Selection"), Ok|Cancel, Ok, parent, name, true, true)
00533 {
00534 KCardDialog::init();
00535
00536 d = new KCardDialogPrivate;
00537 d->cFlags = mFlags;
00538 }
00539
00540 void KCardDialog::slotDeckClicked(TQIconViewItem *item)
00541 {
00542 if (item && item->pixmap())
00543 {
00544 d->deckLabel->setPixmap(* (item->pixmap()));
00545 TQToolTip::remove( d->deckLabel );
00546 TQToolTip::add(d->deckLabel,d->helpMap[d->deckMap[item]]);
00547 setDeck(d->deckMap[item]);
00548 }
00549 }
00550 void KCardDialog::slotCardClicked(TQIconViewItem *item)
00551 {
00552 if (item && item->pixmap())
00553 {
00554 d->cardLabel->setPixmap(* (item->pixmap()));
00555 TQString path = d->cardMap[item];
00556 TQToolTip::remove( d->deckLabel );
00557 TQToolTip::add(d->cardLabel,d->helpMap[path]);
00558 setCardDir(path);
00559 }
00560 }
00561
00562 TQString KCardDialog::getDeckName(const TQString &desktop)
00563 {
00564 TQString entry = desktop.left(desktop.length() - strlen(".desktop"));
00565 if (KStandardDirs::exists(entry + TQString::fromLatin1(".png")))
00566 return entry + TQString::fromLatin1(".png");
00567
00568
00569 if (KStandardDirs::exists(entry + TQString::fromLatin1(".xpm")))
00570 return entry + TQString::fromLatin1(".xpm");
00571 return TQString();
00572 }
00573
00574 TQString KCardDialog::getRandomDeck()
00575 {
00576 KCardDialog::init();
00577
00578 TQStringList list = KGlobal::dirs()->findAllResources("cards", "decks/*.desktop");
00579 if (list.isEmpty())
00580 return TQString();
00581
00582 int d = KApplication::random() % list.count();
00583 return getDeckName(*list.at(d));
00584 }
00585
00586 TQString KCardDialog::getRandomCardDir()
00587 {
00588 KCardDialog::init();
00589
00590 TQStringList list = KGlobal::dirs()->findAllResources("cards", "card*/index.desktop");
00591 if (list.isEmpty())
00592 return TQString();
00593
00594 int d = KApplication::random() % list.count();
00595 TQString entry = *list.at(d);
00596 return entry.left(entry.length() - strlen("index.desktop"));
00597 }
00598
00599 void KCardDialog::showRandomDeckBox(bool s)
00600 {
00601 if (!d->randomDeck)
00602 return;
00603
00604 if (s)
00605 d->randomDeck->show();
00606 else
00607 d->randomDeck->hide();
00608 }
00609
00610 void KCardDialog::showRandomCardDirBox(bool s)
00611 {
00612 if (!d->randomCardDir)
00613 return;
00614
00615 if (s)
00616 d->randomCardDir->show();
00617 else
00618 d->randomCardDir->hide();
00619 }
00620
00621 void KCardDialog::slotRandomDeckToggled(bool on)
00622 {
00623 if (on) {
00624 d->deckLabel->setText("random");
00625 setDeck(getRandomDeck());
00626 } else {
00627 d->deckLabel->setText("empty");
00628 setDeck(0);
00629 }
00630 }
00631
00632 void KCardDialog::slotRandomCardDirToggled(bool on)
00633 {
00634 if (on) {
00635 d->cardLabel->setText("random");
00636 setCardDir(getRandomCardDir());
00637 if (cardDir().length()>0 && cardDir().right(1)!=TQString::fromLatin1("/")) {
00638 setCardDir(cardDir() + TQString::fromLatin1("/"));
00639 }
00640 } else {
00641 d->cardLabel->setText("empty");
00642 setCardDir(0);
00643 }
00644 }
00645
00646 void KCardDialog::loadConfig(KConfig* conf)
00647 {
00648 if (!conf) {
00649 return;
00650 }
00651
00652 TQString origGroup = conf->group();
00653
00654 conf->setGroup(CONF_GROUP);
00655 if (! (flags() & NoDeck)) {
00656 if (conf->hasKey(CONF_DECK)) {
00657 setDeck(conf->readEntry(CONF_DECK));
00658 }
00659
00660 bool random = conf->readBoolEntry(CONF_RANDOMDECK, false);
00661 d->randomDeck->setChecked(random);
00662 slotRandomDeckToggled(random);
00663
00664 if (conf->hasKey(CONF_USEGLOBALDECK) && conf->readBoolEntry(CONF_USEGLOBALDECK)) {
00665 d->globalDeck->setChecked(true);
00666 } else {
00667 d->globalDeck->setChecked(false);
00668 }
00669 }
00670 if (! (flags() & NoCards)) {
00671 if (conf->hasKey(CONF_CARDDIR)) {
00672 setCardDir(conf->readPathEntry(CONF_CARDDIR));
00673 }
00674
00675 bool random = conf->readBoolEntry(CONF_RANDOMCARDDIR, false);
00676 d->randomCardDir->setChecked(random);
00677 slotRandomCardDirToggled(random);
00678
00679 if (conf->hasKey(CONF_USEGLOBALCARDDIR) && conf->readBoolEntry(CONF_USEGLOBALCARDDIR)) {
00680 d->globalCardDir->setChecked(true);
00681 } else {
00682 d->globalCardDir->setChecked(false);
00683 }
00684 }
00685
00686 d->cScale = conf->readDoubleNumEntry(CONF_SCALE, 1.0);
00687
00688 conf->setGroup(origGroup);
00689 }
00690
00691 void KCardDialog::slotCardResized(int s)
00692 {
00693 if (!d->cPreview) {
00694 return;
00695 }
00696 if (s < SLIDER_MIN || s > SLIDER_MAX) {
00697 kdError(11000) << "invalid scaling value!" << endl;
00698 return;
00699 }
00700
00701 s *= -1;
00702 s += (SLIDER_MIN + SLIDER_MAX);
00703
00704 TQWMatrix m;
00705 double scale = (double)1000/s;
00706 m.scale(scale, scale);
00707 TQPixmap pix = d->cPreviewPix.xForm(m);
00708 d->cPreview->setPixmap(pix);
00709 d->cScale = scale;
00710 }
00711
00712 void KCardDialog::slotDefaultSize()
00713 {
00714 if (!d->scaleSlider) {
00715 return;
00716 }
00717 d->scaleSlider->setValue(-1000 + SLIDER_MIN + SLIDER_MAX);
00718 }
00719
00720 void KCardDialog::saveConfig(KConfig* conf)
00721 {
00722 if (!conf) {
00723 return;
00724 }
00725 TQString origGroup = conf->group();
00726
00727 conf->setGroup(CONF_GROUP);
00728 if (! (flags() & NoDeck)) {
00729 conf->writeEntry(CONF_DECK, deck());
00730 conf->writeEntry(CONF_RANDOMDECK, isRandomDeck());
00731 conf->writeEntry(CONF_USEGLOBALDECK, d->globalDeck->isChecked());
00732 }
00733 if (! (flags() & NoCards)) {
00734 conf->writePathEntry(CONF_CARDDIR, cardDir());
00735 conf->writeEntry(CONF_RANDOMCARDDIR, isRandomCardDir());
00736 conf->writeEntry(CONF_USEGLOBALCARDDIR, d->globalCardDir->isChecked());
00737 }
00738 conf->writeEntry(CONF_SCALE, d->cScale);
00739
00740 conf->setGroup(origGroup);
00741 }
00742
00743 void KCardDialog::slotSetGlobalDeck()
00744 {
00745 KSimpleConfig* conf = new KSimpleConfig(TQString::fromLatin1("kdeglobals"), false);
00746 conf->setGroup(CONF_GLOBAL_GROUP);
00747
00748 conf->writeEntry(CONF_GLOBAL_DECK, deck());
00749 conf->writeEntry(CONF_GLOBAL_RANDOMDECK, isRandomDeck());
00750
00751 delete conf;
00752 }
00753
00754 void KCardDialog::slotSetGlobalCardDir()
00755 {
00756 KSimpleConfig* conf = new KSimpleConfig(TQString::fromLatin1("kdeglobals"), false);
00757 conf->setGroup(CONF_GLOBAL_GROUP);
00758
00759 conf->writePathEntry(CONF_GLOBAL_CARDDIR, cardDir());
00760 conf->writeEntry(CONF_GLOBAL_RANDOMCARDDIR, isRandomCardDir());
00761
00762 delete conf;
00763 }
00764
00765 void KCardDialog::getGlobalDeck(TQString& deck, bool& random)
00766 {
00767 KSimpleConfig* conf = new KSimpleConfig(TQString::fromLatin1("kdeglobals"), true);
00768 conf->setGroup(CONF_GLOBAL_GROUP);
00769
00770 if (!conf->hasKey(CONF_GLOBAL_DECK) || conf->readBoolEntry(CONF_GLOBAL_RANDOMDECK, false)) {
00771 deck = getRandomDeck();
00772 random = true;
00773 } else {
00774 deck = conf->readEntry(CONF_GLOBAL_DECK);
00775 random = conf->readBoolEntry(CONF_GLOBAL_RANDOMDECK, false);
00776 }
00777
00778 delete conf;
00779 }
00780
00781 void KCardDialog::getGlobalCardDir(TQString& dir, bool& random)
00782 {
00783 KSimpleConfig* conf = new KSimpleConfig(TQString::fromLatin1("kdeglobals"), true);
00784 conf->setGroup(CONF_GLOBAL_GROUP);
00785
00786 if (!conf->hasKey(CONF_GLOBAL_CARDDIR) || conf->readBoolEntry(CONF_GLOBAL_RANDOMCARDDIR, false)) {
00787 dir = getRandomCardDir();
00788 random = true;
00789 } else {
00790 dir = conf->readPathEntry(CONF_GLOBAL_CARDDIR);
00791 random = conf->readBoolEntry(CONF_GLOBAL_RANDOMCARDDIR, false);
00792 }
00793
00794 delete conf;
00795 }
00796
00797 void KCardDialog::init()
00798 {
00799 static bool _inited = false;
00800 if (_inited)
00801 return;
00802 KGlobal::dirs()->addResourceType("cards", KStandardDirs::kde_default("data") + TQString::fromLatin1("carddecks/"));
00803
00804 KGlobal::locale()->insertCatalogue("libkdegames");
00805 _inited = true;
00806 }
00807
00808 #include "kcarddialog.moc"