1.cpp

Go to the documentation of this file.

/*
    This file is part of the KDE games library

    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.
*/

#include "kcarddialog.h"
#include "ui_kgamecardselector.h"

#include <QMatrix>
#include <QPixmap>
#include <QListWidget>
#include <QListWidgetItem>
#include <QFileInfo>
#include <QDir>

#include <klocale.h>
#include <kstandarddirs.h>
#include <krandom.h>
#include <kconfig.h>

#include <kdebug.h>

// KConfig entries
#define CONF_GROUP "KCardDialog"
#define CONF_RANDOMDECK QString::fromLatin1("RandomDeck")
#define CONF_DECK "Deck"
#define CONF_CARDDIR QString::fromLatin1("CardDir")
#define CONF_RANDOMCARDDIR QString::fromLatin1("RandomCardDir")
#define CONF_USEGLOBALDECK QString::fromLatin1("GlobalDeck")
#define CONF_USEGLOBALCARDDIR QString::fromLatin1("GlobalCardDir")
#define CONF_SCALE QString::fromLatin1("Scale")

#define CONF_GLOBAL_GROUP QString::fromLatin1("KCardDialog Settings")
#define CONF_GLOBAL_DECK "GlobalDeck"
#define CONF_GLOBAL_CARDDIR QString::fromLatin1("GlobalCardDir")
#define CONF_GLOBAL_RANDOMDECK QString::fromLatin1("GlobalRandomDeck")
#define CONF_GLOBAL_RANDOMCARDDIR QString::fromLatin1("GlobalRandomCardDir")



class KCardInfo
{
  public:

   QString name;
   QString comment;
   QString path;
   QString back;
   QPixmap preview;
   QString svgfile;
   QSizeF size;
   bool isDefault;
};

class KCardDialogPrivate
{
  public:

    KCardDialogPrivate()
    {
       // Set default values
       useSVGOnly = false;
       usePNGOnly = false;
       useLocking = true;
    }

    bool filterOutCard(const KCardInfo& v)
    {
      if (usePNGOnly && !v.svgfile.isNull()) return true;
      if (useSVGOnly && v.svgfile.isNull()) return true;
      return false;
    }

    Ui::KGameCardSelectorBase ui;
    bool useSVGOnly;
    bool usePNGOnly;
    bool useLocking;
    QString currentDeck;
    QString currentCard;
};

class KCardDialogStatic
{
  public:
    QMap<QString, KCardInfo> cardInfo;
    QMap<QString, KCardInfo> deckInfo;
    QString defaultDeck;
    QString defaultCard;

    bool filterOutCard(const KCardInfo& v, bool useSVGOnly, bool usePNGOnly)
    {
      if (usePNGOnly && !v.svgfile.isNull()) return true;
      if (useSVGOnly && v.svgfile.isNull()) return true;
      return false;
    }
};

static KCardDialogStatic ds;

// Create the dialog
KCardDialog::KCardDialog(QWidget *parent, bool pAllowSVG, bool pAllowPNG, bool pLock)
           : KDialog( parent ), d( new KCardDialogPrivate )
{
        setCaption(i18n("Carddeck Selection"));
        setButtons(Ok|Cancel);
        setDefaultButton(Ok);
        setModal(true);
        showButtonSeparator(true);
        KCardDialog::init();
        adjustSize();
}

KCardDialog::~KCardDialog()
{
 delete d;
}


int KCardDialog::getCardDeck(QString &pFrontName,
                             QString &pBackName,
                             QWidget *pParent,
                             bool pAllowSVG,
                             bool pAllowPNG,
                             bool pLock, 
                             bool pRandom 
                             )
{
  KCardDialog::init();


  // If random cards we need no dialog (KDE 3.x compatibility)
  if (pRandom)
  {
    pFrontName = randomCardName();
    pBackName  = randomDeckName();
    return QDialog::Accepted;
  }

  KCardDialog dlg(pParent, pAllowSVG, pAllowPNG, pLock);
  Ui::KGameCardSelectorBase* ui = &dlg.d->ui;

  kDebug() << "LOCK = " << pLock;

  QWidget widget(&dlg);
  ui->setupUi(&widget);
  dlg.setMainWidget(&widget);
  dlg.insertCardIcons();
  dlg.insertDeckIcons();

  dlg.d->useLocking = pLock;
  if (dlg.d->useLocking) ui->checkBoxLock->setCheckState(Qt::Checked);

  // Game does not allow fixed sized cards
  if (!pAllowPNG)
  {
    ui->checkBoxPNG->setEnabled(false);
    ui->checkBoxPNG->setCheckState(Qt::Unchecked);
    dlg.d->usePNGOnly = false;
  }
  // Game does not allow scaled cards
  if (!pAllowSVG)
  {
    ui->checkBoxSVG->setEnabled(false);
    ui->checkBoxSVG->setCheckState(Qt::Unchecked);
    dlg.d->useSVGOnly = false;
  }
  // Defaults
  if (dlg.d->useSVGOnly)
  { 
    ui->checkBoxSVG->setCheckState(Qt::Checked);
  }
  if (dlg.d->usePNGOnly)
  { 
    ui->checkBoxPNG->setCheckState(Qt::Checked);
  }

  // Set current cards in preview
  if (!pFrontName.isNull()) dlg.d->currentCard = pFrontName;
  else dlg.d->currentCard = dlg.defaultCardName(pAllowSVG, pAllowPNG);
  if (!pBackName.isNull()) dlg.d->currentDeck = pBackName;
  else dlg.d->currentDeck = dlg.defaultDeckName(pAllowSVG, pAllowPNG);

  dlg.updateFront(dlg.d->currentCard);
  dlg.updateBack(dlg.d->currentDeck);

  // Game wants locked backsides?
  ui->backList->setEnabled(!dlg.d->useLocking);
  
  connect(ui->frontList, SIGNAL(currentItemChanged( QListWidgetItem * , QListWidgetItem * )),
          &dlg, SLOT(updateFront(QListWidgetItem * , QListWidgetItem * )));
  connect(ui->backList, SIGNAL(currentItemChanged( QListWidgetItem * , QListWidgetItem * )),
          &dlg, SLOT(updateBack(QListWidgetItem * , QListWidgetItem * )));
  connect(ui->checkBoxLock, SIGNAL(stateChanged(int)), &dlg, SLOT(updateLocking(int)));
  connect(ui->checkBoxSVG, SIGNAL(stateChanged(int)), &dlg, SLOT(updateSVG(int)));
  connect(ui->checkBoxPNG, SIGNAL(stateChanged(int)), &dlg, SLOT(updatePNG(int)));

  // dlg.setupDialog(pScale != 0);

  kDebug() << "DEFAULT DECK: " << dlg.defaultDeckName(pAllowSVG, pAllowPNG);
  kDebug() << "DEFAULT CARD: " << dlg.defaultCardName(pAllowSVG, pAllowPNG);
  kDebug() << "RANDOM DECK: " << dlg.randomDeckName(pAllowSVG, pAllowPNG);
  kDebug() << "RANDOM CARD: " << dlg.randomCardName(pAllowSVG, pAllowPNG);

  //dlg.loadConfig(pConf);
  int result=dlg.exec();
  if (result==QDialog::Accepted)
  {
    pFrontName = dlg.d->currentCard;
    pBackName = dlg.d->currentDeck;
  }
  //dlg.saveConfig(pConf);
  return result;
}

/*
void KCardDialog::getConfigCardDeck(KConfig* conf, QString &pDeck, QString &pCardDir, double& pScale)
{
// TODO check for global cards/decks!!!!
 if (!conf) {
        return;
 }
 KConfigGroup cg(conf, CONF_GROUP);

 if (cg.readEntry(CONF_RANDOMDECK,false) || !cg.hasKey(CONF_DECK)) {
        pDeck = getRandomDeck();
 } else {
        pDeck = cg.readEntry(CONF_DECK);
 }
 if (cg.readEntry(CONF_RANDOMCARDDIR,false) || !cg.hasKey(CONF_CARDDIR)) {
        pCardDir = getRandomCardDir();
 } else {
        pCardDir = cg.readPathEntry(CONF_CARDDIR);
 }
 pScale = cg.readEntry(CONF_SCALE, 1.0);

}
 */


QString KCardDialog::deckName() const
{
  return d->currentDeck; 
}

QString KCardDialog::cardName() const
{ 
  return d->currentCard; 
}


void KCardDialog::readFronts()
{
    // Empty data
    ds.cardInfo.clear();

    QStringList svg;
    // Add SVG card sets
    svg = KGlobal::dirs()->findAllResources("cards", "svg*/index.desktop", KStandardDirs::NoDuplicates);
    QStringList list = svg+KGlobal::dirs()->findAllResources("cards", "card*/index.desktop", KStandardDirs::NoDuplicates);

    if (list.isEmpty()) return;

    for (QStringList::ConstIterator it = list.begin(); it != list.end(); ++it)
    {
        KConfig cfg(*it, KConfig::OnlyLocal);
        KConfigGroup cfgcg(&cfg, "KDE Backdeck");
        QString path = (*it).left((*it).lastIndexOf('/') + 1);
        Q_ASSERT(path[path.length() - 1] == '/');
        QPixmap pixmap(path + cfgcg.readEntry("Preview", "12c.png"));

        if (pixmap.isNull()) continue;

        QString name = cfgcg.readEntry("Name", i18n("unnamed"));
        KCardInfo info;
        info.name         = name;
        info.comment      = cfgcg.readEntry("Comment",i18n("KDE card deck"));
        info.preview      = pixmap; 
        info.path         = path;
        info.back         = cfgcg.readEntry("Back",QString());
        info.size         = cfgcg.readEntry("BackSize", QSizeF(pixmap.size()));
        info.isDefault    = cfgcg.readEntry("Default", false);

        QString svg    = cfgcg.readEntry("SVG", QString());
        if (!svg.isNull())
        {
          QFileInfo svgInfo(QDir(path), svg);
          info.svgfile = svgInfo.filePath();
        }
        else
        {
          info.svgfile = QString();
        }
        //kDebug() << name << " card svg " << info.svgfile;

        ds.cardInfo[name] = info;

    }
}


void KCardDialog::insertCardIcons()
{
    // Prevent empty preview
    if (d->useSVGOnly && !isSVGCard(d->currentCard)) updateFront(defaultCardName(!d->usePNGOnly, !d->useSVGOnly));
    if (d->usePNGOnly && isSVGCard(d->currentCard)) updateFront(defaultCardName(!d->usePNGOnly, !d->useSVGOnly));

    // Clear GUI
    d->ui.frontList->clear();

    // Rebuild list
    QSize itemSize;
    QMapIterator<QString, KCardInfo> it(ds.cardInfo);
    while (it.hasNext())
    {
        it.next();
        KCardInfo v = it.value();
        // Show only SVG files?
        if (d->filterOutCard(v)) continue;

        QPixmap previewPixmap = v.preview.scaled(QSize(32,43), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);

        QListWidgetItem *item = new QListWidgetItem(v.name, d->ui.frontList);
        item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);
        item->setToolTip(v.name);
        item->setData(Qt::DecorationRole, previewPixmap);
        itemSize = itemSize.expandedTo(previewPixmap.size());
    }
    d->ui.frontList->setIconSize(itemSize);
}

void KCardDialog::updateFront(QListWidgetItem* current , QListWidgetItem* /*last*/)
{
  kDebug() << " updateFront p= " << current;
  if (current != 0) updateFront(current->text());
}

void KCardDialog::updateFront(QString item)
{
  kDebug() << " updateFront to " << item;
  // Clear item?
  if (item.isNull())
  {
    d->ui.frontPreview->setPixmap(QPixmap());
    d->ui.cardName->setText(QString());
    d->ui.cardDescription->setText(QString());
  }
  else
  {
    KCardInfo info = ds.cardInfo[item];
    QFont font;
    font.setBold(true);
    d->ui.cardName->setText(info.name);
    d->ui.cardName->setFont(font);
    kDebug() << " back" << info.back;

    d->ui.cardDescription->setText(info.comment);
    QPixmap pixmap= info.preview;
    if (pixmap.height() > d->ui.frontPreview->height())
      pixmap = pixmap.scaledToHeight(d->ui.frontPreview->height(), Qt::SmoothTransformation);
    if (pixmap.width() > d->ui.frontPreview->width())
      pixmap = pixmap.scaledToWidth(d->ui.frontPreview->width(), Qt::SmoothTransformation);
    d->ui.frontPreview->setPixmap(pixmap);

    // Lock front and back side?
    if (d->useLocking && !info.back.isNull())
    {
      kDebug() << "LOCK BACK";
      updateBack(info.back);
    }
    else if (d->useLocking)
    {
      // QMap<QString, KCardInfo>::const_iterator it = d->deckInfo.constBegin();
      QString name = defaultDeckName(!d->usePNGOnly, !d->useSVGOnly);
      kDebug() << "LOCK BACK without back to "<<name;
      updateBack(name);
    }
  }
  d->currentCard = item;
}

QString KCardDialog::getDefaultCardDir(bool pAllowSVG, bool pAllowPNG)
{
  KCardDialog::init();
  QString name = defaultCardName(pAllowSVG, pAllowPNG);
  return cardDir(name);
}
QString KCardDialog::getDefaultDeck(bool pAllowSVG, bool pAllowPNG)
{
  KCardDialog::init();
  QString name = defaultDeckName(pAllowSVG, pAllowPNG);
  return deckFilename(name);
}

QString KCardDialog::defaultCardName(bool pAllowSVG, bool pAllowPNG)
{
  KCardDialog::init();
  kDebug() << "defaultCardName " << pAllowSVG <<", "<<pAllowPNG;
  QString noDefault;
  // Count filtered cards
  QMapIterator<QString, KCardInfo> it(ds.cardInfo);
  while (it.hasNext())
  {
      it.next();
      KCardInfo v = it.value();
      // Filter
      if (ds.filterOutCard(v, !pAllowPNG, !pAllowSVG)) continue;
      if (v.isDefault) return v.name;
      // Collect any deck if no default is stored
      noDefault = v.name;
  }
  if (noDefault.isNull()) kError() << "Could not find default card name";
  return noDefault;
}
QString KCardDialog::defaultDeckName(bool pAllowSVG, bool pAllowPNG)
{
  KCardDialog::init();
  kDebug() << "defaultDeckName " << pAllowSVG <<", "<<pAllowPNG;
  QString noDefault;
  // Count filtered cards
  QMapIterator<QString, KCardInfo> it(ds.deckInfo);
  while (it.hasNext())
  {
      it.next();
      KCardInfo v = it.value();
      // Filter
      if (ds.filterOutCard(v, !pAllowPNG, !pAllowSVG)) continue;
      if (v.isDefault) 
      {
        return v.name;
      }
      // Collect any deck if no default is stored
      noDefault = v.name;
  }
  if (noDefault.isNull()) kError() << "Could not find default deck name";
  return noDefault;
}


QString KCardDialog::randomCardName(bool pAllowSVG, bool pAllowPNG)
{
  KCardDialog::init();
  // Collect matching items
  QStringList list;

  // Count filtered cards
  QMapIterator<QString, KCardInfo> it(ds.cardInfo);
  while (it.hasNext())
  {
      it.next();
      KCardInfo v = it.value();
      // Filter
      if (ds.filterOutCard(v, !pAllowPNG, !pAllowSVG)) continue;
      list.append(v.name);
  }

  // Draw random one
  int d = KRandom::random() % list.count();
  return list.at(d);
}

QString KCardDialog::randomDeckName(bool pAllowSVG, bool pAllowPNG)
{
  KCardDialog::init();
  // Collect matching items
  QStringList list;

  // Count filtered cards
  QMapIterator<QString, KCardInfo> it(ds.deckInfo);
  while (it.hasNext())
  {
      it.next();
      KCardInfo v = it.value();
      // Filter
      if (ds.filterOutCard(v, !pAllowPNG, !pAllowSVG)) continue;
      list.append(v.name);
  }

  // Draw random one
  int d = KRandom::random() % list.count();
  return list.at(d);
}

void KCardDialog::updateLocking(int state)
{
  kDebug() <<" updateLocking";
  if (state == Qt::Checked)
  {
    d->useLocking = true;
    // Update previews
    updateFront(d->currentCard);
  }
  else
  {
    d->useLocking = false;
  }
  d->ui.backList->setEnabled(!d->useLocking);
}

void KCardDialog::updateSVG(int state)
{
  kDebug() <<" updateSVG";
  if (state == Qt::Checked)
  {
    d->useSVGOnly = true;
  }
  else
  {
    d->useSVGOnly = false;
  }
  //Prevent filtering out everything
  if (d->usePNGOnly && d->useSVGOnly)
  { 
    d->usePNGOnly = false;
    d->ui.checkBoxPNG->setCheckState(Qt::Unchecked);
  }
  insertCardIcons();
  insertDeckIcons();
}

void KCardDialog::updatePNG(int state)
{
  kDebug() <<" updatePNG";
  if (state == Qt::Checked)
  {
    d->usePNGOnly = true;
  }
  else
  {
    d->usePNGOnly = false;
  }
  //Prevent filtering out everything
  if (d->usePNGOnly && d->useSVGOnly)
  { 
    d->useSVGOnly = false;
    d->ui.checkBoxSVG->setCheckState(Qt::Unchecked);
  }
  insertCardIcons();
  insertDeckIcons();
}


void KCardDialog::updateBack(QListWidgetItem* current , QListWidgetItem* /*last*/)
{
  kDebug() <<"updateBack back p="<<current;
  if (current != 0) updateBack(current->text());
}

void KCardDialog::updateBack(QString item)
{
  kDebug() << " updateBack to" << item;
  if (item.isNull())
  {
    d->ui.backPreview->setPixmap(QPixmap());
  }
  else
  {
    KCardInfo info = ds.deckInfo[item];
    QPixmap pixmap= info.preview;
    if (pixmap.height() > d->ui.backPreview->height())
      pixmap = pixmap.scaledToHeight(d->ui.backPreview->height(), Qt::SmoothTransformation);
    if (pixmap.width() > d->ui.backPreview->width())
      pixmap = pixmap.scaledToWidth(d->ui.backPreview->width(), Qt::SmoothTransformation);
    d->ui.backPreview->setPixmap(pixmap);
  }
  d->currentDeck = item;
}

void KCardDialog::insertDeckIcons()
{
    // Prevent empty preview
    if (d->useSVGOnly && !isSVGDeck(d->currentDeck)) updateBack(defaultDeckName(!d->usePNGOnly, !d->useSVGOnly));
    if (d->usePNGOnly && isSVGDeck(d->currentDeck)) updateBack(defaultDeckName(!d->usePNGOnly, !d->useSVGOnly));
    kDebug() << "insert deck " << d->useSVGOnly <<  !isSVGDeck(d->currentDeck) << d->usePNGOnly;

    // Clear GUI
    d->ui.backList->clear();

    // Rebuild list
    QSize itemSize;
    QMapIterator<QString, KCardInfo> it(ds.deckInfo);
    while (it.hasNext())
    {
        it.next();
        KCardInfo v = it.value();
        // Show only SVG files?
        if (d->filterOutCard(v)) continue;
        QPixmap previewPixmap = v.preview.scaled(QSize(32,43), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);

        QString name = v.name;
        QListWidgetItem *item = new QListWidgetItem(name, d->ui.backList);
        item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);
        item->setToolTip(name);
        item->setData(Qt::DecorationRole, previewPixmap);
        itemSize = itemSize.expandedTo(previewPixmap.size());
    }
    d->ui.backList->setIconSize(itemSize);
}

void KCardDialog::readBacks()
{
    // Empty data
    ds.deckInfo.clear();

    QStringList list = KGlobal::dirs()->findAllResources("cards", "decks/*.desktop", KStandardDirs::NoDuplicates);
    if (list.isEmpty()) return;

    for (QStringList::ConstIterator it = list.begin(); it != list.end(); ++it)
    {
        KConfig cfg(*it, KConfig::OnlyLocal);
        QString path = (*it).left((*it).lastIndexOf('/') + 1);
        Q_ASSERT(path[path.length() - 1] == '/');
        QPixmap pixmap(getDeckFileNameFromIndex(*it));
        if (pixmap.isNull()) continue;
        //pixmap = pixmap.scaledToWidth(72, Qt::SmoothTransformation);
        QPixmap previewPixmap = pixmap.scaled(QSize(32,43), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);

        KConfigGroup cfgcg(&cfg, "KDE Cards");
        QString name = cfgcg.readEntry("Name", i18n("unnamed"));

        KCardInfo info;
        info.name         = name;
        info.path         = getDeckFileNameFromIndex(*it);
        info.comment      = cfgcg.readEntry("Comment",i18n("KDE card deck"));
        info.preview      = pixmap; 
        info.size         = cfgcg.readEntry("Size", QSizeF(pixmap.size()));
        info.isDefault    = cfgcg.readEntry("Default", false);

        QString svg    = cfgcg.readEntry("SVG", QString());
        if (!svg.isNull())
        {
          QFileInfo svgInfo(QDir(path), svg);
          info.svgfile = svgInfo.filePath();
        }
        else
        {
          info.svgfile = QString();
        }
        //kDebug() << name << " deck svg " << info.svgfile;
        ds.deckInfo[name] = info;
    }
}




QString KCardDialog::getDeckFileNameFromIndex(const QString &desktop)
{
    QString entry = desktop.left(desktop.length() - strlen(".desktop"));
    if (KStandardDirs::exists(entry + QString::fromLatin1(".png")))
        return entry + QString::fromLatin1(".png");

    // rather theoretical
    if (KStandardDirs::exists(entry + QString::fromLatin1(".xpm")))
        return entry + QString::fromLatin1(".xpm");
    return QString();
}


void KCardDialog::loadConfig(KConfig* conf)
{
 if (!conf) {
        return;
 }

 KConfigGroup cg(conf, CONF_GROUP);

 /*
 if (! (flags() & NoDeck)) {
        if (cg.hasKey(CONF_DECK)) {
                setDeck(cg.readEntry(CONF_DECK));
        }

        bool random = cg.readEntry(CONF_RANDOMDECK, false);
        d->randomDeck->setChecked(random);

        if (cg.hasKey(CONF_USEGLOBALDECK) && cg.readEntry(CONF_USEGLOBALDECK,false)) {
                d->globalDeck->setChecked(true);
        } else {
                d->globalDeck->setChecked(false);
        }
 }
 if (! (flags() & NoCards)) {
        if (cg.hasKey(CONF_CARDDIR)) {
                setCardDir(cg.readPathEntry(CONF_CARDDIR));
        }

        bool random = cg.readEntry(CONF_RANDOMCARDDIR, false);
        d->randomCardDir->setChecked(random);

        if (cg.hasKey(CONF_USEGLOBALCARDDIR) && cg.readEntry(CONF_USEGLOBALCARDDIR,false)) {
                d->globalCardDir->setChecked(true);
        } else {
                d->globalCardDir->setChecked(false);
        }
 }

 d->cScale = cg.readEntry(CONF_SCALE, 1.0);
 */
}


void KCardDialog::saveConfig(KConfig* conf)
{
 if (!conf) {
        return;
 }
 /*
 KConfigGroup cg(conf, CONF_GROUP);
 if (! (flags() & NoDeck)) {
        cg.writeEntry(CONF_DECK, deck());
        cg.writeEntry(CONF_RANDOMDECK, isRandomDeck());
        cg.writeEntry(CONF_USEGLOBALDECK, d->globalDeck->isChecked());
 }
 if (! (flags() & NoCards)) {
        cg.writePathEntry(CONF_CARDDIR, cardDir());
        cg.writeEntry(CONF_RANDOMCARDDIR, isRandomCardDir());
        cg.writeEntry(CONF_USEGLOBALCARDDIR, d->globalCardDir->isChecked());
 }
 cg.writeEntry(CONF_SCALE, d->cScale);
 */
}


void KCardDialog::init()
{
    static bool _inited = false;
    if (_inited) return;
    _inited = true;

    KGlobal::dirs()->addResourceType("cards", "data", "carddecks/");
    KGlobal::locale()->insertCatalog("libkdegames");
    readFronts();
    readBacks();
}

// Retrieve the SVG file belonging to the given card back deck.
QString KCardDialog::deckSVGFilePath(const QString& name)
{
  KCardDialog::init();
  if (!ds.deckInfo.contains(name)) return QString();
  KCardInfo v = ds.deckInfo.value(name);
  return v.svgfile;
}

// Retrieve the SVG file belonging to the given card fronts.
QString KCardDialog::cardSVGFilePath(const QString& name)
{
  KCardDialog::init();
  if (!ds.cardInfo.contains(name)) return QString();
  KCardInfo v = ds.cardInfo.value(name);
  return v.svgfile;
}

// Retrieve the PNG file belonging to the given card back deck.
QString KCardDialog::deckFilename(const QString& name)
{
  KCardDialog::init();
  if (!ds.deckInfo.contains(name)) return QString();
  KCardInfo v = ds.deckInfo.value(name);
  return v.path;
}

// Retrieve the directory belonging to the given card fronts.
QString KCardDialog::cardDir(const QString& name)
{
  KCardDialog::init();
  if (!ds.cardInfo.contains(name)) return QString();
  KCardInfo v = ds.cardInfo.value(name);
  return v.path;
}

// Check whether a card set is SVG
bool KCardDialog::isSVGCard(const QString& name)
{
  KCardDialog::init();
  if (!ds.cardInfo.contains(name)) return false;
  KCardInfo v = ds.cardInfo.value(name);
  return !v.svgfile.isNull();
}

// Check whether a card deck is SVG
bool KCardDialog::isSVGDeck(const QString& name)
{
  KCardDialog::init();
  if (!ds.deckInfo.contains(name)) return false;
  KCardInfo v = ds.deckInfo.value(name);
  return !v.svgfile.isNull();
}

#include "kcarddialog.moc"

---