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 <qgroupbox.h>
00027 #include <qlabel.h>
00028 #include <qcheckbox.h>
00029 #include <qlayout.h>
00030 #include <qtooltip.h>
00031 #include <qslider.h>
00032 #include <qwmatrix.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 <qpushbutton.h>
00042 #include <kdebug.h>
00043
00044 #define KCARD_DEFAULTDECK QString::fromLatin1("deck0.png")
00045 #define KCARD_DEFAULTCARD QString::fromLatin1("11.png")
00046 #define KCARD_DEFAULTCARDDIR QString::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 QString::fromLatin1("RandomDeck")
00055 #define CONF_DECK QString::fromLatin1("Deck")
00056 #define CONF_CARDDIR QString::fromLatin1("CardDir")
00057 #define CONF_RANDOMCARDDIR QString::fromLatin1("RandomCardDir")
00058 #define CONF_USEGLOBALDECK QString::fromLatin1("GlobalDeck")
00059 #define CONF_USEGLOBALCARDDIR QString::fromLatin1("GlobalCardDir")
00060 #define CONF_SCALE QString::fromLatin1("Scale")
00061
00062 #define CONF_GLOBAL_GROUP QString::fromLatin1("KCardDialog Settings")
00063 #define CONF_GLOBAL_DECK QString::fromLatin1("GlobalDeck")
00064 #define CONF_GLOBAL_CARDDIR QString::fromLatin1("GlobalCardDir")
00065 #define CONF_GLOBAL_RANDOMDECK QString::fromLatin1("GlobalRandomDeck")
00066 #define CONF_GLOBAL_RANDOMCARDDIR QString::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 QLabel* deckLabel;
00089 QLabel* cardLabel;
00090 KIconView* deckIconView;
00091 KIconView* cardIconView;
00092 QCheckBox* randomDeck;
00093 QCheckBox* randomCardDir;
00094 QCheckBox* globalDeck;
00095 QCheckBox* globalCardDir;
00096
00097 QSlider* scaleSlider;
00098 QPixmap cPreviewPix;
00099 QLabel* cPreview;
00100
00101 QMap<QIconViewItem*, QString> deckMap;
00102 QMap<QIconViewItem*, QString> cardMap;
00103 QMap<QString, QString> helpMap;
00104
00105
00106 KCardDialog::CardFlags cFlags;
00107 QString cDeck;
00108 QString cCardDir;
00109 double cScale;
00110 };
00111
00112 int KCardDialog::getCardDeck(QString &pDeck, QString &pCardDir, QWidget *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==QDialog::Accepted)
00127 {
00128
00129 pDeck=dlg.deck();
00130 pCardDir=dlg.cardDir();
00131 if (!pCardDir.isNull() && pCardDir.right(1)!=QString::fromLatin1("/"))
00132 {
00133 pCardDir+=QString::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, QString &pDeck, QString &pCardDir, double& pScale)
00180 {
00181
00182 if (!conf) {
00183 return;
00184 }
00185 QString 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 QString KCardDialog::getDefaultDeck()
00219 {
00220 KCardDialog::init();
00221 return locate("cards", QString::fromLatin1("decks/") + KCARD_DEFAULTDECK);
00222 }
00223
00224 QString KCardDialog::getDefaultCardDir()
00225 {
00226 KCardDialog::init();
00227
00228 QString file = KCARD_DEFAULTCARDDIR + KCARD_DEFAULTCARD;
00229 return KGlobal::dirs()->findResourceDir("cards",file) + KCARD_DEFAULTCARDDIR;
00230 }
00231
00232 QString KCardDialog::getCardPath(const QString &carddir, int index)
00233 {
00234 KCardDialog::init();
00235
00236 QString entry = carddir + QString::number(index);
00237 if (KStandardDirs::exists(entry + QString::fromLatin1(".png")))
00238 return entry + QString::fromLatin1(".png");
00239
00240
00241 if (KStandardDirs::exists(entry + QString::fromLatin1(".xpm")))
00242 return entry + QString::fromLatin1(".xpm");
00243
00244 return QString::null;
00245 }
00246
00247 const QString& KCardDialog::deck() const { return d->cDeck; }
00248 void KCardDialog::setDeck(const QString& file) { d->cDeck=file; }
00249 const QString& KCardDialog::cardDir() const { return d->cCardDir; }
00250 void KCardDialog::setCardDir(const QString& 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 QHBoxLayout* topLayout = new QHBoxLayout(plainPage(), spacingHint());
00265 QVBoxLayout* cardLayout = new QVBoxLayout(topLayout);
00266 QString path, file;
00267 QWMatrix m;
00268 m.scale(0.8,0.8);
00269
00270 setInitialSize(QSize(600,400));
00271
00272 if (! (flags() & NoDeck))
00273 {
00274 QHBoxLayout* layout = new QHBoxLayout(cardLayout);
00275
00276
00277 QGroupBox* grp1 = new QGroupBox(1, 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(QIconView::Single);
00289 d->deckIconView->setResizeMode(QIconView::Adjust);
00290 d->deckIconView->setMinimumWidth(360);
00291 d->deckIconView->setMinimumHeight(170);
00292 d->deckIconView->setWordWrapIconText(false);
00293 d->deckIconView->showToolTips();
00294
00295
00296 QVBoxLayout* l = new QVBoxLayout(layout);
00297 QGroupBox* grp3 = new QGroupBox(i18n("Backside"), plainPage());
00298 grp3->setFixedSize(100, 130);
00299 l->addWidget(grp3, 0, AlignTop|AlignHCenter);
00300 d->deckLabel = new QLabel(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 QCheckBox(plainPage());
00306 d->randomDeck->setChecked(false);
00307 connect(d->randomDeck, SIGNAL(toggled(bool)), this,
00308 SLOT(slotRandomDeckToggled(bool)));
00309 d->randomDeck->setText(i18n("Random backside"));
00310 l->addWidget(d->randomDeck, 0, AlignTop|AlignHCenter);
00311
00312 d->globalDeck = new QCheckBox(plainPage());
00313 d->globalDeck->setChecked(false);
00314 d->globalDeck->setText(i18n("Use global backside"));
00315 l->addWidget(d->globalDeck, 0, AlignTop|AlignHCenter);
00316
00317 QPushButton* b = new QPushButton(i18n("Make Backside Global"), plainPage());
00318 connect(b, SIGNAL(pressed()), this, SLOT(slotSetGlobalDeck()));
00319 l->addWidget(b, 0, AlignTop|AlignHCenter);
00320
00321 connect(d->deckIconView,SIGNAL(clicked(QIconViewItem *)),
00322 this,SLOT(slotDeckClicked(QIconViewItem *)));
00323 }
00324
00325 if (! (flags() & NoCards))
00326 {
00327
00328 QHBoxLayout* layout = new QHBoxLayout(cardLayout);
00329 QGroupBox* grp2 = new QGroupBox(1, 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(QIconView::Adjust);
00340 d->cardIconView->setMinimumWidth(360);
00341 d->cardIconView->setMinimumHeight(170);
00342 d->cardIconView->setWordWrapIconText(false);
00343 d->cardIconView->showToolTips();
00344
00345
00346 QVBoxLayout* l = new QVBoxLayout(layout);
00347 QGroupBox* grp4 = new QGroupBox(i18n("Frontside"), plainPage());
00348 grp4->setFixedSize(100, 130);
00349 l->addWidget(grp4, 0, AlignTop|AlignHCenter);
00350 d->cardLabel = new QLabel(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 QCheckBox(plainPage());
00356 d->randomCardDir->setChecked(false);
00357 connect(d->randomCardDir, SIGNAL(toggled(bool)), this,
00358 SLOT(slotRandomCardDirToggled(bool)));
00359 d->randomCardDir->setText(i18n("Random frontside"));
00360 l->addWidget(d->randomCardDir, 0, AlignTop|AlignHCenter);
00361
00362 d->globalCardDir = new QCheckBox(plainPage());
00363 d->globalCardDir->setChecked(false);
00364 d->globalCardDir->setText(i18n("Use global frontside"));
00365 l->addWidget(d->globalCardDir, 0, AlignTop|AlignHCenter);
00366
00367 QPushButton* b = new QPushButton(i18n("Make Frontside Global"), plainPage());
00368 connect(b, SIGNAL(pressed()), this, SLOT(slotSetGlobalCardDir()));
00369 l->addWidget(b, 0, AlignTop|AlignHCenter);
00370
00371 connect(d->cardIconView,SIGNAL(clicked(QIconViewItem *)),
00372 this,SLOT(slotCardClicked(QIconViewItem *)));
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 QPixmap pixmap(file);
00387 pixmap=pixmap.xForm(m);
00388 d->deckLabel->setPixmap(pixmap);
00389 QToolTip::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 QPixmap pixmap(file);
00404 pixmap = pixmap.xForm(m);
00405 d->cardLabel->setPixmap(pixmap);
00406 QToolTip::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 QVBoxLayout* layout = new QVBoxLayout(topLayout);
00426 QGroupBox* grp = new QGroupBox(1, Horizontal, i18n("Resize Cards"), plainPage());
00427 layout->setResizeMode(QLayout::Fixed);
00428 layout->addWidget(grp);
00429 QWidget* box = new QWidget(grp);
00430 QHBoxLayout* hbox = new QHBoxLayout(box, 0, spacingHint());
00431 QVBoxLayout* boxLayout = new QVBoxLayout(hbox);
00432 hbox->addStretch(0);
00433
00434 d->scaleSlider = new QSlider(1, SLIDER_MAX, 1, (-1000+SLIDER_MIN+SLIDER_MAX), Horizontal, box);
00435 d->scaleSlider->setMinValue(SLIDER_MIN);
00436 connect(d->scaleSlider, SIGNAL(valueChanged(int)), this, SLOT(slotCardResized(int)));
00437 boxLayout->addWidget(d->scaleSlider, 0, AlignLeft);
00438
00439 QPushButton* b = new QPushButton(i18n("Default Size"), box);
00440 connect(b, SIGNAL(pressed()), this, SLOT(slotDefaultSize()));
00441 boxLayout->addWidget(b, 0, AlignLeft);
00442
00443 QLabel* l = new QLabel(i18n("Preview:"), box);
00444 boxLayout->addWidget(l);
00445 d->cPreviewPix.load(getDefaultDeck());
00446 d->cPreview = new QLabel(box);
00447 boxLayout->addWidget(d->cPreview, 0, AlignCenter|AlignVCenter);
00448
00449 slotCardResized(d->scaleSlider->value());
00450 }
00451 }
00452
00453 void KCardDialog::insertCardIcons()
00454 {
00455 QStringList list = KGlobal::dirs()->findAllResources("cards", "card*/index.desktop", false, true);
00456
00457 if (list.isEmpty())
00458 return;
00459
00460
00461
00462 QWMatrix m;
00463 m.scale(0.8,0.8);
00464
00465 for (QStringList::ConstIterator it = list.begin(); it != list.end(); ++it)
00466 {
00467 KSimpleConfig cfg(*it);
00468 cfg.setGroup(QString::fromLatin1("KDE Backdeck"));
00469 QString path = (*it).left((*it).findRev('/') + 1);
00470 assert(path[path.length() - 1] == '/');
00471 QPixmap pixmap(path + cfg.readEntry("Preview", "12c.png"));
00472
00473 if (pixmap.isNull())
00474 continue;
00475
00476 QString name=cfg.readEntry("Name", i18n("unnamed"));
00477 QIconViewItem *item= new QIconViewItem(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 QStringList list = KGlobal::dirs()->findAllResources("cards", "decks/*.desktop", false, true);
00492 if (list.isEmpty())
00493 return;
00494
00495 QString label;
00496
00497
00498 QWMatrix m;
00499 m.scale(0.8,0.8);
00500
00501 for (QStringList::ConstIterator it = list.begin(); it != list.end(); ++it)
00502 {
00503 KSimpleConfig cfg(*it);
00504 QPixmap pixmap(getDeckName(*it));
00505 if (pixmap.isNull())
00506 continue;
00507
00508
00509
00510 cfg.setGroup(QString::fromLatin1("KDE Cards"));
00511 QString name=cfg.readEntry("Name", i18n("unnamed"));
00512 QIconViewItem *item= new QIconViewItem(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( QWidget *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(QIconViewItem *item)
00541 {
00542 if (item && item->pixmap())
00543 {
00544 d->deckLabel->setPixmap(* (item->pixmap()));
00545 QToolTip::remove( d->deckLabel );
00546 QToolTip::add(d->deckLabel,d->helpMap[d->deckMap[item]]);
00547 setDeck(d->deckMap[item]);
00548 }
00549 }
00550 void KCardDialog::slotCardClicked(QIconViewItem *item)
00551 {
00552 if (item && item->pixmap())
00553 {
00554 d->cardLabel->setPixmap(* (item->pixmap()));
00555 QString path = d->cardMap[item];
00556 QToolTip::remove( d->deckLabel );
00557 QToolTip::add(d->cardLabel,d->helpMap[path]);
00558 setCardDir(path);
00559 }
00560 }
00561
00562 QString KCardDialog::getDeckName(const QString &desktop)
00563 {
00564 QString entry = desktop.left(desktop.length() - strlen(".desktop"));
00565 if (KStandardDirs::exists(entry + QString::fromLatin1(".png")))
00566 return entry + QString::fromLatin1(".png");
00567
00568
00569 if (KStandardDirs::exists(entry + QString::fromLatin1(".xpm")))
00570 return entry + QString::fromLatin1(".xpm");
00571 return QString::null;
00572 }
00573
00574 QString KCardDialog::getRandomDeck()
00575 {
00576 KCardDialog::init();
00577
00578 QStringList list = KGlobal::dirs()->findAllResources("cards", "decks/*.desktop");
00579 if (list.isEmpty())
00580 return QString::null;
00581
00582 int d = KApplication::random() % list.count();
00583 return getDeckName(*list.at(d));
00584 }
00585
00586 QString KCardDialog::getRandomCardDir()
00587 {
00588 KCardDialog::init();
00589
00590 QStringList list = KGlobal::dirs()->findAllResources("cards", "card*/index.desktop");
00591 if (list.isEmpty())
00592 return QString::null;
00593
00594 int d = KApplication::random() % list.count();
00595 QString 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)!=QString::fromLatin1("/")) {
00638 setCardDir(cardDir() + QString::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 QString 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 QWMatrix m;
00705 double scale = (double)1000/s;
00706 m.scale(scale, scale);
00707 QPixmap 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 QString 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(QString::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(QString::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(QString& deck, bool& random)
00766 {
00767 KSimpleConfig* conf = new KSimpleConfig(QString::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(QString& dir, bool& random)
00782 {
00783 KSimpleConfig* conf = new KSimpleConfig(QString::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") + QString::fromLatin1("carddecks/"));
00803
00804 KGlobal::locale()->insertCatalogue("libkdegames");
00805 _inited = true;
00806 }
00807
00808 #include "kcarddialog.moc"