summaryrefslogtreecommitdiffstats
path: root/libtdegames/kcarddialog.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'libtdegames/kcarddialog.cpp')
-rw-r--r--libtdegames/kcarddialog.cpp808
1 files changed, 808 insertions, 0 deletions
diff --git a/libtdegames/kcarddialog.cpp b/libtdegames/kcarddialog.cpp
new file mode 100644
index 00000000..fc73de22
--- /dev/null
+++ b/libtdegames/kcarddialog.cpp
@@ -0,0 +1,808 @@
+/*
+ This file is part of the KDE games library
+ Copyright (C) 2000 Martin Heni (martin@heni-online.de)
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License version 2 as published by the Free Software Foundation.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+/*
+ $Id$
+*/
+
+#include <stdio.h>
+#include <assert.h>
+
+#include <tqgroupbox.h>
+#include <tqlabel.h>
+#include <tqcheckbox.h>
+#include <tqlayout.h>
+#include <tqtooltip.h>
+#include <tqslider.h>
+#include <tqwmatrix.h>
+
+#include <kapplication.h>
+#include <klocale.h>
+#include <kstandarddirs.h>
+#include <kiconview.h>
+#include <ksimpleconfig.h>
+
+#include "kcarddialog.h"
+#include <tqpushbutton.h>
+#include <kdebug.h>
+
+#define KCARD_DEFAULTDECK TQString::tqfromLatin1("deck0.png")
+#define KCARD_DEFAULTCARD TQString::tqfromLatin1("11.png")
+#define KCARD_DEFAULTCARDDIR TQString::tqfromLatin1("cards-default/")
+
+// values for the resize slider
+#define SLIDER_MIN 400
+#define SLIDER_MAX 3000
+
+// KConfig entries
+#define CONF_GROUP "KCardDialog"
+#define CONF_RANDOMDECK TQString::tqfromLatin1("RandomDeck")
+#define CONF_DECK TQString::tqfromLatin1("Deck")
+#define CONF_CARDDIR TQString::tqfromLatin1("CardDir")
+#define CONF_RANDOMCARDDIR TQString::tqfromLatin1("RandomCardDir")
+#define CONF_USEGLOBALDECK TQString::tqfromLatin1("GlobalDeck")
+#define CONF_USEGLOBALCARDDIR TQString::tqfromLatin1("GlobalCardDir")
+#define CONF_SCALE TQString::tqfromLatin1("Scale")
+
+#define CONF_GLOBAL_GROUP TQString::tqfromLatin1("KCardDialog Settings")
+#define CONF_GLOBAL_DECK TQString::tqfromLatin1("GlobalDeck")
+#define CONF_GLOBAL_CARDDIR TQString::tqfromLatin1("GlobalCardDir")
+#define CONF_GLOBAL_RANDOMDECK TQString::tqfromLatin1("GlobalRandomDeck")
+#define CONF_GLOBAL_RANDOMCARDDIR TQString::tqfromLatin1("GlobalRandomCardDir")
+
+
+class KCardDialogPrivate
+{
+public:
+ KCardDialogPrivate()
+ {
+ deckLabel = 0;
+ cardLabel = 0;
+ deckIconView = 0;
+ cardIconView = 0;
+ randomDeck = 0;
+ randomCardDir = 0;
+ cPreview = 0;
+ scaleSlider = 0;
+ globalDeck = 0;
+ globalCardDir = 0;
+
+ cScale = 1;
+ }
+
+ TQLabel* deckLabel;
+ TQLabel* cardLabel;
+ KIconView* deckIconView;
+ KIconView* cardIconView;
+ TQCheckBox* randomDeck;
+ TQCheckBox* randomCardDir;
+ TQCheckBox* globalDeck;
+ TQCheckBox* globalCardDir;
+
+ TQSlider* scaleSlider;
+ TQPixmap cPreviewPix;
+ TQLabel* cPreview;
+
+ TQMap<TQIconViewItem*, TQString> deckMap;
+ TQMap<TQIconViewItem*, TQString> cardMap;
+ TQMap<TQString, TQString> helpMap;
+
+ //set query variables
+ KCardDialog::CardFlags cFlags;
+ TQString cDeck;
+ TQString cCardDir;
+ double cScale;
+};
+
+int KCardDialog::getCardDeck(TQString &pDeck, TQString &pCardDir, TQWidget *pParent,
+ CardFlags pFlags, bool* pRandomDeck, bool* pRandomCardDir,
+ double* pScale, KConfig* pConf)
+{
+ KCardDialog dlg(pParent, "dlg", pFlags);
+
+ dlg.setDeck(pDeck);
+ dlg.setCardDir(pCardDir);
+
+ dlg.setupDialog(pScale != 0);
+ dlg.loadConfig(pConf);
+ dlg.showRandomDeckBox(pRandomDeck != 0);
+ dlg.showRandomCardDirBox(pRandomCardDir != 0);
+ int result=dlg.exec();
+ if (result==TQDialog::Accepted)
+ {
+ // TODO check for global cards/decks!!!!
+ pDeck=dlg.deck();
+ pCardDir=dlg.cardDir();
+ if (!pCardDir.isNull() && pCardDir.right(1)!=TQString::tqfromLatin1("/"))
+ {
+ pCardDir+=TQString::tqfromLatin1("/");
+ }
+ if (pRandomDeck)
+ {
+ *pRandomDeck = dlg.isRandomDeck();
+ }
+ if (pRandomCardDir)
+ {
+ *pRandomCardDir = dlg.isRandomCardDir();
+ }
+ if (pScale)
+ {
+ *pScale = dlg.cardScale();
+ }
+
+ if (dlg.isGlobalDeck())
+ {
+ kdDebug(11000) << "use global deck" << endl;
+ bool random;
+ getGlobalDeck(pDeck, random);
+ kdDebug(11000) << "use: " << pDeck<< endl;
+ if (pRandomDeck)
+ {
+ *pRandomDeck=random;
+ if (random)
+ kdDebug(11000) << "use random deck" << endl;
+ }
+ }
+ if (dlg.isGlobalCardDir())
+ {
+ kdDebug(11000) << "use global carddir" << endl;
+ bool random;
+ getGlobalCardDir(pCardDir, random);
+ kdDebug(11000) << "use: " << pCardDir << endl;
+ if (pRandomCardDir)
+ {
+ *pRandomCardDir=random;
+ if (random)
+ kdDebug(11000) << "use random carddir" << endl;
+ }
+ }
+ }
+ dlg.saveConfig(pConf);
+ return result;
+}
+
+void KCardDialog::getConfigCardDeck(KConfig* conf, TQString &pDeck, TQString &pCardDir, double& pScale)
+{
+// TODO check for global cards/decks!!!!
+ if (!conf) {
+ return;
+ }
+ TQString origGroup = conf->group();
+
+ conf->setGroup(CONF_GROUP);
+ if (conf->readBoolEntry(CONF_RANDOMDECK) || !conf->hasKey(CONF_DECK)) {
+ pDeck = getRandomDeck();
+ } else {
+ pDeck = conf->readEntry(CONF_DECK);
+ }
+ if (conf->readBoolEntry(CONF_RANDOMCARDDIR) || !conf->hasKey(CONF_CARDDIR)) {
+ pCardDir = getRandomCardDir();
+ } else {
+ pCardDir = conf->readPathEntry(CONF_CARDDIR);
+ }
+ pScale = conf->readDoubleNumEntry(CONF_SCALE, 1.0);
+
+ if (conf->readBoolEntry(CONF_USEGLOBALDECK, false)) {
+ bool random;
+ getGlobalDeck(pCardDir, random);
+ if (random || pDeck.isNull() ) {
+ pDeck = getRandomDeck();
+ }
+ }
+ if (conf->readBoolEntry(CONF_USEGLOBALCARDDIR, false)) {
+ bool random;
+ getGlobalCardDir(pCardDir, random);
+ if (random || pCardDir.isNull() ) {
+ pCardDir = getRandomCardDir();
+ }
+ }
+
+ conf->setGroup(origGroup);
+}
+
+TQString KCardDialog::getDefaultDeck()
+{
+ KCardDialog::init();
+ return locate("cards", TQString::tqfromLatin1("decks/") + KCARD_DEFAULTDECK);
+}
+
+TQString KCardDialog::getDefaultCardDir()
+{
+ KCardDialog::init();
+
+ TQString file = KCARD_DEFAULTCARDDIR + KCARD_DEFAULTCARD;
+ return KGlobal::dirs()->findResourceDir("cards",file) + KCARD_DEFAULTCARDDIR;
+}
+
+TQString KCardDialog::getCardPath(const TQString &carddir, int index)
+{
+ KCardDialog::init();
+
+ TQString entry = carddir + TQString::number(index);
+ if (KStandardDirs::exists(entry + TQString::tqfromLatin1(".png")))
+ return entry + TQString::tqfromLatin1(".png");
+
+ // rather theoretical
+ if (KStandardDirs::exists(entry + TQString::tqfromLatin1(".xpm")))
+ return entry + TQString::tqfromLatin1(".xpm");
+
+ return TQString();
+}
+
+const TQString& KCardDialog::deck() const { return d->cDeck; }
+void KCardDialog::setDeck(const TQString& file) { d->cDeck=file; }
+const TQString& KCardDialog::cardDir() const { return d->cCardDir; }
+void KCardDialog::setCardDir(const TQString& dir) { d->cCardDir=dir; }
+KCardDialog::CardFlags KCardDialog::flags() const { return d->cFlags; }
+double KCardDialog::cardScale() const { return d->cScale; }
+bool KCardDialog::isRandomDeck() const
+{ return (d->randomDeck ? d->randomDeck->isChecked() : false); }
+bool KCardDialog::isRandomCardDir() const
+{ return (d->randomCardDir ? d->randomCardDir->isChecked() : false); }
+bool KCardDialog::isGlobalDeck() const
+{ return (d->globalDeck ? d->globalDeck->isChecked() : false); }
+bool KCardDialog::isGlobalCardDir() const
+{ return (d->globalCardDir ? d->globalCardDir->isChecked() : false); }
+
+void KCardDialog::setupDialog(bool showResizeBox)
+{
+ TQHBoxLayout* topLayout = new TQHBoxLayout(plainPage(), spacingHint());
+ TQVBoxLayout* cardLayout = new TQVBoxLayout(topLayout);
+ TQString path, file;
+ TQWMatrix m;
+ m.scale(0.8,0.8);
+
+ setInitialSize(TQSize(600,400));
+
+ if (! (flags() & NoDeck))
+ {
+ TQHBoxLayout* tqlayout = new TQHBoxLayout(cardLayout);
+
+ // Deck iconview
+ TQGroupBox* grp1 = new TQGroupBox(1,Qt::Horizontal, i18n("Choose Backside"), plainPage());
+ tqlayout->addWidget(grp1);
+
+ d->deckIconView = new KIconView(grp1,"decks");
+ d->deckIconView->setSpacing(8);
+ /*
+ deckIconView->setGridX(-1);
+ deckIconView->setGridY(50);
+ */
+ d->deckIconView->setGridX(82);
+ d->deckIconView->setGridY(106);
+ d->deckIconView->setSelectionMode(TQIconView::Single);
+ d->deckIconView->setResizeMode(TQIconView::Adjust);
+ d->deckIconView->setMinimumWidth(360);
+ d->deckIconView->setMinimumHeight(170);
+ d->deckIconView->setWordWrapIconText(false);
+ d->deckIconView->showToolTips();
+
+ // deck select
+ TQVBoxLayout* l = new TQVBoxLayout(tqlayout);
+ TQGroupBox* grp3 = new TQGroupBox(i18n("Backside"), plainPage());
+ grp3->setFixedSize(100, 130);
+ l->addWidget(grp3, 0, AlignTop|AlignHCenter);
+ d->deckLabel = new TQLabel(grp3);
+ d->deckLabel->setText(i18n("empty"));
+ d->deckLabel->tqsetAlignment(AlignHCenter|AlignVCenter);
+ d->deckLabel->setGeometry(10, 20, 80, 90);
+
+ d->randomDeck = new TQCheckBox(plainPage());
+ d->randomDeck->setChecked(false);
+ connect(d->randomDeck, TQT_SIGNAL(toggled(bool)), this,
+ TQT_SLOT(slotRandomDeckToggled(bool)));
+ d->randomDeck->setText(i18n("Random backside"));
+ l->addWidget(d->randomDeck, 0, AlignTop|AlignHCenter);
+
+ d->globalDeck = new TQCheckBox(plainPage());
+ d->globalDeck->setChecked(false);
+ d->globalDeck->setText(i18n("Use global backside"));
+ l->addWidget(d->globalDeck, 0, AlignTop|AlignHCenter);
+
+ TQPushButton* b = new TQPushButton(i18n("Make Backside Global"), plainPage());
+ connect(b, TQT_SIGNAL(pressed()), this, TQT_SLOT(slotSetGlobalDeck()));
+ l->addWidget(b, 0, AlignTop|AlignHCenter);
+
+ connect(d->deckIconView,TQT_SIGNAL(clicked(TQIconViewItem *)),
+ this,TQT_SLOT(slotDeckClicked(TQIconViewItem *)));
+ }
+
+ if (! (flags() & NoCards))
+ {
+ // Cards iconview
+ TQHBoxLayout* tqlayout = new TQHBoxLayout(cardLayout);
+ TQGroupBox* grp2 = new TQGroupBox(1,Qt::Horizontal, i18n("Choose Frontside"), plainPage());
+ tqlayout->addWidget(grp2);
+
+ d->cardIconView =new KIconView(grp2,"cards");
+ /*
+ cardIconView->setGridX(36);
+ cardIconView->setGridY(50);
+ */
+ d->cardIconView->setGridX(82);
+ d->cardIconView->setGridY(106);
+ d->cardIconView->setResizeMode(TQIconView::Adjust);
+ d->cardIconView->setMinimumWidth(360);
+ d->cardIconView->setMinimumHeight(170);
+ d->cardIconView->setWordWrapIconText(false);
+ d->cardIconView->showToolTips();
+
+ // Card select
+ TQVBoxLayout* l = new TQVBoxLayout(tqlayout);
+ TQGroupBox* grp4 = new TQGroupBox(i18n("Frontside"), plainPage());
+ grp4->setFixedSize(100, 130);
+ l->addWidget(grp4, 0, AlignTop|AlignHCenter);
+ d->cardLabel = new TQLabel(grp4);
+ d->cardLabel->setText(i18n("empty"));
+ d->cardLabel->tqsetAlignment(AlignHCenter|AlignVCenter);
+ d->cardLabel->setGeometry(10, 20, 80, 90 );
+
+ d->randomCardDir = new TQCheckBox(plainPage());
+ d->randomCardDir->setChecked(false);
+ connect(d->randomCardDir, TQT_SIGNAL(toggled(bool)), this,
+ TQT_SLOT(slotRandomCardDirToggled(bool)));
+ d->randomCardDir->setText(i18n("Random frontside"));
+ l->addWidget(d->randomCardDir, 0, AlignTop|AlignHCenter);
+
+ d->globalCardDir = new TQCheckBox(plainPage());
+ d->globalCardDir->setChecked(false);
+ d->globalCardDir->setText(i18n("Use global frontside"));
+ l->addWidget(d->globalCardDir, 0, AlignTop|AlignHCenter);
+
+ TQPushButton* b = new TQPushButton(i18n("Make Frontside Global"), plainPage());
+ connect(b, TQT_SIGNAL(pressed()), this, TQT_SLOT(slotSetGlobalCardDir()));
+ l->addWidget(b, 0, AlignTop|AlignHCenter);
+
+ connect(d->cardIconView,TQT_SIGNAL(clicked(TQIconViewItem *)),
+ this,TQT_SLOT(slotCardClicked(TQIconViewItem *)));
+ }
+
+ // Insert deck icons
+ // First find the default or alternate path
+ if (! (flags() & NoDeck))
+ {
+ insertDeckIcons();
+ d->deckIconView->arrangeItemsInGrid();
+
+ // Set default icons if given
+ if (!deck().isNull())
+ {
+ file=deck();
+ TQPixmap pixmap(file);
+ pixmap=pixmap.xForm(m);
+ d->deckLabel->setPixmap(pixmap);
+ TQToolTip::add(d->deckLabel,d->helpMap[file]);
+ }
+ }
+
+ // Insert card icons
+ if (! (flags() & NoCards))
+ {
+ insertCardIcons();
+ d->cardIconView->arrangeItemsInGrid();
+
+ // Set default icons if given
+ if (!cardDir().isNull())
+ {
+ file = cardDir() + KCARD_DEFAULTCARD;
+ TQPixmap pixmap(file);
+ pixmap = pixmap.xForm(m);
+ d->cardLabel->setPixmap(pixmap);
+ TQToolTip::add(d->cardLabel,d->helpMap[cardDir()]);
+ }
+ }
+
+ // insert resize box
+ if (showResizeBox)
+ {
+ // this part is a little bit...tricky.
+ // i'm sure there is a cleaner way but i cannot find it.
+ // whenever the pixmap is resized (aka scaled) the box is resized, too. This
+ // leads to an always resizing dialog which is *very* ugly. i worked around
+ // this by using a TQWidget which is the only child widget of the group box.
+ // The other widget are managed inside this TQWidget - a stretch area on the
+ // right ensures that the KIconViews are not resized...
+
+ // note that the dialog is still resized if you you scale the pixmap very
+ // large. This is desired behaviour as i don't want to make the box even
+ // larger but i want the complete pixmap to be displayed. the dialog is not
+ // resized if you make the pixmap smaller again.
+ TQVBoxLayout* tqlayout = new TQVBoxLayout(topLayout);
+ TQGroupBox* grp = new TQGroupBox(1,Qt::Horizontal, i18n("Resize Cards"), plainPage());
+ tqlayout->setResizeMode(TQLayout::Fixed);
+ tqlayout->addWidget(grp);
+ TQWidget* box = new TQWidget(grp);
+ TQHBoxLayout* hbox = new TQHBoxLayout(box, 0, spacingHint());
+ TQVBoxLayout* boxLayout = new TQVBoxLayout(hbox);
+ hbox->addStretch(0);
+
+ d->scaleSlider = new TQSlider(1, SLIDER_MAX, 1, (-1000+SLIDER_MIN+SLIDER_MAX),Qt::Horizontal, box);
+ d->scaleSlider->setMinValue(SLIDER_MIN);
+ connect(d->scaleSlider, TQT_SIGNAL(valueChanged(int)), this, TQT_SLOT(slotCardResized(int)));
+ boxLayout->addWidget(d->scaleSlider, 0, AlignLeft);
+
+ TQPushButton* b = new TQPushButton(i18n("Default Size"), box);
+ connect(b, TQT_SIGNAL(pressed()), this, TQT_SLOT(slotDefaultSize()));
+ boxLayout->addWidget(b, 0, AlignLeft);
+
+ TQLabel* l = new TQLabel(i18n("Preview:"), box);
+ boxLayout->addWidget(l);
+ d->cPreviewPix.load(getDefaultDeck());
+ d->cPreview = new TQLabel(box);
+ boxLayout->addWidget(d->cPreview, 0, AlignCenter|AlignVCenter);
+
+ slotCardResized(d->scaleSlider->value());
+ }
+}
+
+void KCardDialog::insertCardIcons()
+{
+ TQStringList list = KGlobal::dirs()->findAllResources("cards", "card*/index.desktop", false, true);
+ // kdDebug(11000) << "insert " << list.count() << endl;
+ if (list.isEmpty())
+ return;
+
+ // We shrink the icons a little
+ //
+ TQWMatrix m;
+ m.scale(0.8,0.8);
+
+ for (TQStringList::ConstIterator it = list.begin(); it != list.end(); ++it)
+ {
+ KSimpleConfig cfg(*it);
+ cfg.setGroup(TQString::tqfromLatin1("KDE Backdeck"));
+ TQString path = (*it).left((*it).findRev('/') + 1);
+ assert(path[path.length() - 1] == '/');
+ TQPixmap pixmap(path + cfg.readEntry("Preview", "12c.png"));
+
+ if (pixmap.isNull())
+ continue;
+
+ TQString name=cfg.readEntry("Name", i18n("unnamed"));
+ TQIconViewItem *item= new TQIconViewItem(d->cardIconView, name, pixmap);
+
+ item->setDragEnabled(false);
+ item->setDropEnabled(false);
+ item->setRenameEnabled(false);
+ item->setSelectable(true);
+
+ d->cardMap[item] = path;
+ d->helpMap[path] = cfg.readEntry("Comment",name);
+ }
+}
+
+void KCardDialog::insertDeckIcons()
+{
+ TQStringList list = KGlobal::dirs()->findAllResources("cards", "decks/*.desktop", false, true);
+ if (list.isEmpty())
+ return;
+
+ TQString label;
+
+ // We shrink the icons a little
+ TQWMatrix m;
+ m.scale(0.8,0.8);
+
+ for (TQStringList::ConstIterator it = list.begin(); it != list.end(); ++it)
+ {
+ KSimpleConfig cfg(*it);
+ TQPixmap pixmap(getDeckName(*it));
+ if (pixmap.isNull())
+ continue;
+
+ // pixmap=pixmap.xForm(m);
+
+ cfg.setGroup(TQString::tqfromLatin1("KDE Cards"));
+ TQString name=cfg.readEntry("Name", i18n("unnamed"));
+ TQIconViewItem *item= new TQIconViewItem(d->deckIconView,name, pixmap);
+
+ item->setDragEnabled(false);
+ item->setDropEnabled(false);
+ item->setRenameEnabled(false);
+
+ d->deckMap[item] = getDeckName(*it);
+ d->helpMap[d->deckMap[item]] = cfg.readEntry("Comment",name);
+ }
+}
+
+
+KCardDialog::~KCardDialog()
+{
+ delete d;
+}
+
+
+// Create the dialog
+KCardDialog::KCardDialog( TQWidget *parent, const char *name, CardFlags mFlags)
+ : KDialogBase( Plain, i18n("Carddeck Selection"), Ok|Cancel, Ok, parent, name, true, true)
+{
+ KCardDialog::init();
+
+ d = new KCardDialogPrivate;
+ d->cFlags = mFlags;
+}
+
+void KCardDialog::slotDeckClicked(TQIconViewItem *item)
+{
+ if (item && item->pixmap())
+ {
+ d->deckLabel->setPixmap(* (item->pixmap()));
+ TQToolTip::remove( d->deckLabel );
+ TQToolTip::add(d->deckLabel,d->helpMap[d->deckMap[item]]);
+ setDeck(d->deckMap[item]);
+ }
+}
+void KCardDialog::slotCardClicked(TQIconViewItem *item)
+{
+ if (item && item->pixmap())
+ {
+ d->cardLabel->setPixmap(* (item->pixmap()));
+ TQString path = d->cardMap[item];
+ TQToolTip::remove( d->deckLabel );
+ TQToolTip::add(d->cardLabel,d->helpMap[path]);
+ setCardDir(path);
+ }
+}
+
+TQString KCardDialog::getDeckName(const TQString &desktop)
+{
+ TQString entry = desktop.left(desktop.length() - strlen(".desktop"));
+ if (KStandardDirs::exists(entry + TQString::tqfromLatin1(".png")))
+ return entry + TQString::tqfromLatin1(".png");
+
+ // rather theoretical
+ if (KStandardDirs::exists(entry + TQString::tqfromLatin1(".xpm")))
+ return entry + TQString::tqfromLatin1(".xpm");
+ return TQString();
+}
+
+TQString KCardDialog::getRandomDeck()
+{
+ KCardDialog::init();
+
+ TQStringList list = KGlobal::dirs()->findAllResources("cards", "decks/*.desktop");
+ if (list.isEmpty())
+ return TQString();
+
+ int d = KApplication::random() % list.count();
+ return getDeckName(*list.at(d));
+}
+
+TQString KCardDialog::getRandomCardDir()
+{
+ KCardDialog::init();
+
+ TQStringList list = KGlobal::dirs()->findAllResources("cards", "card*/index.desktop");
+ if (list.isEmpty())
+ return TQString();
+
+ int d = KApplication::random() % list.count();
+ TQString entry = *list.at(d);
+ return entry.left(entry.length() - strlen("index.desktop"));
+}
+
+void KCardDialog::showRandomDeckBox(bool s)
+{
+ if (!d->randomDeck)
+ return;
+
+ if (s)
+ d->randomDeck->show();
+ else
+ d->randomDeck->hide();
+}
+
+void KCardDialog::showRandomCardDirBox(bool s)
+{
+ if (!d->randomCardDir)
+ return;
+
+ if (s)
+ d->randomCardDir->show();
+ else
+ d->randomCardDir->hide();
+}
+
+void KCardDialog::slotRandomDeckToggled(bool on)
+{
+ if (on) {
+ d->deckLabel->setText("random");
+ setDeck(getRandomDeck());
+ } else {
+ d->deckLabel->setText("empty");
+ setDeck(0);
+ }
+}
+
+void KCardDialog::slotRandomCardDirToggled(bool on)
+{
+ if (on) {
+ d->cardLabel->setText("random");
+ setCardDir(getRandomCardDir());
+ if (cardDir().length()>0 && cardDir().right(1)!=TQString::tqfromLatin1("/")) {
+ setCardDir(cardDir() + TQString::tqfromLatin1("/"));
+ }
+ } else {
+ d->cardLabel->setText("empty");
+ setCardDir(0);
+ }
+}
+
+void KCardDialog::loadConfig(KConfig* conf)
+{
+ if (!conf) {
+ return;
+ }
+
+ TQString origGroup = conf->group();
+
+ conf->setGroup(CONF_GROUP);
+ if (! (flags() & NoDeck)) {
+ if (conf->hasKey(CONF_DECK)) {
+ setDeck(conf->readEntry(CONF_DECK));
+ }
+
+ bool random = conf->readBoolEntry(CONF_RANDOMDECK, false);
+ d->randomDeck->setChecked(random);
+ slotRandomDeckToggled(random);
+
+ if (conf->hasKey(CONF_USEGLOBALDECK) && conf->readBoolEntry(CONF_USEGLOBALDECK)) {
+ d->globalDeck->setChecked(true);
+ } else {
+ d->globalDeck->setChecked(false);
+ }
+ }
+ if (! (flags() & NoCards)) {
+ if (conf->hasKey(CONF_CARDDIR)) {
+ setCardDir(conf->readPathEntry(CONF_CARDDIR));
+ }
+
+ bool random = conf->readBoolEntry(CONF_RANDOMCARDDIR, false);
+ d->randomCardDir->setChecked(random);
+ slotRandomCardDirToggled(random);
+
+ if (conf->hasKey(CONF_USEGLOBALCARDDIR) && conf->readBoolEntry(CONF_USEGLOBALCARDDIR)) {
+ d->globalCardDir->setChecked(true);
+ } else {
+ d->globalCardDir->setChecked(false);
+ }
+ }
+
+ d->cScale = conf->readDoubleNumEntry(CONF_SCALE, 1.0);
+
+ conf->setGroup(origGroup);
+}
+
+void KCardDialog::slotCardResized(int s)
+{
+ if (!d->cPreview) {
+ return;
+ }
+ if (s < SLIDER_MIN || s > SLIDER_MAX) {
+ kdError(11000) << "invalid scaling value!" << endl;
+ return;
+ }
+
+ s *= -1;
+ s += (SLIDER_MIN + SLIDER_MAX);
+
+ TQWMatrix m;
+ double scale = (double)1000/s;
+ m.scale(scale, scale);
+ TQPixmap pix = d->cPreviewPix.xForm(m);
+ d->cPreview->setPixmap(pix);
+ d->cScale = scale;
+}
+
+void KCardDialog::slotDefaultSize()
+{
+ if (!d->scaleSlider) {
+ return;
+ }
+ d->scaleSlider->setValue(-1000 + SLIDER_MIN + SLIDER_MAX);
+}
+
+void KCardDialog::saveConfig(KConfig* conf)
+{
+ if (!conf) {
+ return;
+ }
+ TQString origGroup = conf->group();
+
+ conf->setGroup(CONF_GROUP);
+ if (! (flags() & NoDeck)) {
+ conf->writeEntry(CONF_DECK, deck());
+ conf->writeEntry(CONF_RANDOMDECK, isRandomDeck());
+ conf->writeEntry(CONF_USEGLOBALDECK, d->globalDeck->isChecked());
+ }
+ if (! (flags() & NoCards)) {
+ conf->writePathEntry(CONF_CARDDIR, cardDir());
+ conf->writeEntry(CONF_RANDOMCARDDIR, isRandomCardDir());
+ conf->writeEntry(CONF_USEGLOBALCARDDIR, d->globalCardDir->isChecked());
+ }
+ conf->writeEntry(CONF_SCALE, d->cScale);
+
+ conf->setGroup(origGroup);
+}
+
+void KCardDialog::slotSetGlobalDeck()
+{
+ KSimpleConfig* conf = new KSimpleConfig(TQString::tqfromLatin1("kdeglobals"), false);
+ conf->setGroup(CONF_GLOBAL_GROUP);
+
+ conf->writeEntry(CONF_GLOBAL_DECK, deck());
+ conf->writeEntry(CONF_GLOBAL_RANDOMDECK, isRandomDeck());
+
+ delete conf;
+}
+
+void KCardDialog::slotSetGlobalCardDir()
+{
+ KSimpleConfig* conf = new KSimpleConfig(TQString::tqfromLatin1("kdeglobals"), false);
+ conf->setGroup(CONF_GLOBAL_GROUP);
+
+ conf->writePathEntry(CONF_GLOBAL_CARDDIR, cardDir());
+ conf->writeEntry(CONF_GLOBAL_RANDOMCARDDIR, isRandomCardDir());
+
+ delete conf;
+}
+
+void KCardDialog::getGlobalDeck(TQString& deck, bool& random)
+{
+ KSimpleConfig* conf = new KSimpleConfig(TQString::tqfromLatin1("kdeglobals"), true);
+ conf->setGroup(CONF_GLOBAL_GROUP);
+
+ if (!conf->hasKey(CONF_GLOBAL_DECK) || conf->readBoolEntry(CONF_GLOBAL_RANDOMDECK, false)) {
+ deck = getRandomDeck();
+ random = true;
+ } else {
+ deck = conf->readEntry(CONF_GLOBAL_DECK);
+ random = conf->readBoolEntry(CONF_GLOBAL_RANDOMDECK, false);
+ }
+
+ delete conf;
+}
+
+void KCardDialog::getGlobalCardDir(TQString& dir, bool& random)
+{
+ KSimpleConfig* conf = new KSimpleConfig(TQString::tqfromLatin1("kdeglobals"), true);
+ conf->setGroup(CONF_GLOBAL_GROUP);
+
+ if (!conf->hasKey(CONF_GLOBAL_CARDDIR) || conf->readBoolEntry(CONF_GLOBAL_RANDOMCARDDIR, false)) {
+ dir = getRandomCardDir();
+ random = true;
+ } else {
+ dir = conf->readPathEntry(CONF_GLOBAL_CARDDIR);
+ random = conf->readBoolEntry(CONF_GLOBAL_RANDOMCARDDIR, false);
+ }
+
+ delete conf;
+}
+
+void KCardDialog::init()
+{
+ static bool _inited = false;
+ if (_inited)
+ return;
+ KGlobal::dirs()->addResourceType("cards", KStandardDirs::kde_default("data") + TQString::tqfromLatin1("carddecks/"));
+
+ KGlobal::locale()->insertCatalogue("libtdegames");
+ _inited = true;
+}
+
+#include "kcarddialog.moc"