Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdeutils@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 1266 insertions, 0 deletions

diff --git a/ksim/library/themeloader.cpp b/ksim/library/themeloader.cpp
new file mode 100644
index 0000000..7c42dcd
--- /dev/null
+++ b/ksim/library/themeloader.cpp
@@ -0,0 +1,1266 @@
+/*  ksim - a system monitor for kde
+ *
+ *  Copyright (C) 2001  Robbie Ward <[email protected]>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#include "themeloader.h"
+#include <ksimconfig.h>
+#include "themetypes.h"
+#include "common.h"
+
+#include <qfile.h>
+#include <qstringlist.h>
+#include <qvaluevector.h>
+#include <qregexp.h>
+#include <qapplication.h>
+#include <qfileinfo.h>
+#include <qdir.h>
+#include <qimage.h>
+#include <qbitmap.h>
+
+#include <kdebug.h>
+#include <ksimpleconfig.h>
+#include <kglobalsettings.h>
+#include <kstandarddirs.h>
+#include <kglobal.h>
+
+class KSim::Theme::Private
+{
+  public:
+    Private(const QValueVector<QString> &names,
+       const QStringList &list) : fileNames(names),
+       imageTypes(list) {}
+
+    QStringList file;
+    QStringList dFile;
+    KConfig *globalReader;
+    QString altTheme;
+    QString location;
+    const QValueVector<QString> &fileNames;
+    const QStringList &imageTypes;
+    int alternative;
+    int font;
+    bool recolour;
+
+    QString readOption(const QString &entry,
+       bool useGlobal = true,
+       const QString &defValue = QString::null)
+    {
+      QString text;
+      QStringList::ConstIterator it;
+      for (it = file.begin(); it != file.end(); ++it) {
+        if ((*it).find(entry) != -1) {
+          text = QStringList::split("=", (*it))[1].stripWhiteSpace();
+        }
+      }
+
+      if (!text.isEmpty() || dFile.isEmpty())
+        return text;
+
+      QStringList::ConstIterator it2;
+      for (it2 = dFile.begin(); it2 != dFile.end(); ++it) {
+        if ((*it2).find(entry) != -1) {
+          text = QStringList::split("=", (*it2))[1].stripWhiteSpace();
+        }
+      }
+
+      if (!text.isEmpty())
+        return text;
+
+      if (!globalReader || !useGlobal)
+        return defValue;
+
+      text = globalReader->readEntry(entry, defValue);
+      return text;
+    }
+};
+
+class KSim::ThemeLoader::Private
+{
+  public:
+    QValueVector<QString> fileNames;
+    QStringList imageTypes;
+    KConfig *globalReader;
+    bool recolour;
+    QColor pixelColour;
+};
+
+bool KSim::Theme::operator==(const KSim::Theme &rhs) const
+{
+  return d == rhs.d;
+}
+
+bool KSim::Theme::operator!=(const KSim::Theme &rhs) const
+{
+  return !(operator==(rhs));
+}
+
+KSim::Theme &KSim::Theme::operator=(const KSim::Theme &rhs)
+{
+  if (*this == rhs)
+    return *this;
+
+  delete d;
+  d = rhs.d;
+  return *this;
+}
+
+KSim::Theme::~Theme()
+{
+  delete d;
+}
+
+const QString &KSim::Theme::path() const
+{
+  return d->location;
+}
+
+QString KSim::Theme::name() const
+{
+  QString name = d->location;
+  if (name.endsWith("/"))
+    name.remove(name.length() - 1, 1);
+
+  return name.remove(0, name.findRev("/") + 1);
+}
+
+QString KSim::Theme::author() const
+{
+  QString author(d->readOption("author", false));
+  return author.replace(QRegExp("\""), QString::null);
+}
+
+int KSim::Theme::fontItem() const
+{
+  return d->font;
+}
+
+int KSim::Theme::alternative() const
+{
+  return d->alternative;
+}
+
+int KSim::Theme::alternatives() const
+{
+  return d->readOption("theme_alternatives").toInt();
+}
+
+int KSim::Theme::chartWidthRef(int defValue) const
+{
+  return internalNumEntry("chart_width_ref", defValue);
+}
+
+int KSim::Theme::chartWidthMin(int defValue) const
+{
+  return internalNumEntry("chart_width_min", defValue);
+}
+
+bool KSim::Theme::scaling(bool defValue) const
+{
+  return internalNumEntry("allow_scaling", defValue);
+}
+
+int KSim::Theme::frameTopHeight(int defValue) const
+{
+  return KMIN(2, internalNumEntry("frame_top_height", defValue));
+}
+
+int KSim::Theme::frameBottomHeight(int defValue) const
+{
+  return KMIN(2, internalNumEntry("frame_bottom_height", defValue));
+}
+
+int KSim::Theme::frameLeftWidth(int defValue) const
+{
+  return KMIN(2, internalNumEntry("frame_left_width", defValue));
+}
+
+int KSim::Theme::frameRightWidth(int defValue) const
+{
+  return KMIN(2, internalNumEntry("frame_right_width", defValue));
+}
+
+QRect KSim::Theme::frameTopBorder(const QRect &defValue) const
+{
+  return internalRectEntry("frame_top_border", defValue);
+}
+
+QRect KSim::Theme::frameBottomBorder(const QRect &defValue) const
+{
+  return internalRectEntry("frame_bottom_border", defValue);
+}
+
+QRect KSim::Theme::frameLeftBorder(const QRect &defValue) const
+{
+  return internalRectEntry("frame_left_border", defValue);
+}
+
+QRect KSim::Theme::frameRightBorder(const QRect &defValue) const
+{
+  return internalRectEntry("frame_right_border", defValue);
+}
+
+QColor KSim::Theme::chartInColour(const QColor &defValue) const
+{
+  if (d->recolour)
+    return QApplication::palette().active().background();
+
+  return internalColourEntry("chart_in_color", defValue);
+}
+
+QColor KSim::Theme::chartInColourGrid(const QColor &defValue) const
+{
+  return internalColourEntry("chart_in_color_grid", defValue);
+}
+
+QColor KSim::Theme::chartOutColour(const QColor &defValue) const
+{
+  if (d->recolour)
+    return QApplication::palette().active().background();
+
+  return internalColourEntry("chart_out_color", defValue);
+}
+
+QColor KSim::Theme::chartOutColourGrid(const QColor &defValue) const
+{
+  return internalColourEntry("chart_out_color_grid", defValue);
+}
+
+bool KSim::Theme::bgGridMode(bool defValue) const
+{
+  return internalNumEntry("bg_grid_mode", defValue);
+}
+
+int KSim::Theme::rxLedX(int defValue) const
+{
+  return internalNumEntry("rx_led_x", defValue);
+}
+
+int KSim::Theme::rxLedY(int defValue) const
+{
+  return internalNumEntry("rx_led_y", defValue);
+}
+
+int KSim::Theme::txLedX(int defValue) const
+{
+  return internalNumEntry("tx_led_x", defValue);
+}
+
+int KSim::Theme::txLedY(int defValue) const
+{
+  return internalNumEntry("tx_led_y", defValue);
+}
+
+int KSim::Theme::mailFrames(int defValue) const
+{
+  return internalNumEntry("decal_mail_frames", defValue);
+}
+
+int KSim::Theme::mailDelay(int defValue) const
+{
+  return internalNumEntry("decal_mail_delay", defValue);
+}
+
+int KSim::Theme::krellSliderDepth(int defValue) const
+{
+  return internalNumEntry("krell_slider_depth", defValue);
+}
+
+int KSim::Theme::krellSliderXHot(int defValue) const
+{
+  return internalNumEntry("krell_slider_x_hot", defValue);
+}
+
+QRect KSim::Theme::sliderPanel(const QRect &defValue) const
+{
+  return internalRectEntry("bg_slider_panel_border", defValue);
+}
+
+QRect KSim::Theme::sliderMeter(const QRect &defValue) const
+{
+  return internalRectEntry("bg_slider_meter_border", defValue);
+}
+
+QRect KSim::Theme::timerBorder(const QRect &defValue) const
+{
+  return internalRectEntry("bg_timer_border", defValue);
+}
+
+QRect KSim::Theme::buttonPanelBorder(const QRect &defValue) const
+{
+  return internalRectEntry("button_panel_border", defValue);
+}
+
+QRect KSim::Theme::buttonMeterBorder(const QRect &defValue) const
+{
+  return internalRectEntry("button_meter_border", defValue);
+}
+
+QFont KSim::Theme::largeFont() const
+{
+  QString font(internalStringEntry("large_font", QString::null));
+
+  if (font.isEmpty())
+    return QApplication::font();
+
+  QFont themeFont;
+  themeFont.setRawName(font.replace(QRegExp("\""), QString::null));
+  return themeFont;
+}
+
+QFont KSim::Theme::normalFont() const
+{
+  QString font(internalStringEntry("normal_font", QString::null));
+
+  if (font.isEmpty())
+    return QApplication::font();
+
+  QFont themeFont;
+  themeFont.setRawName(font.replace(QRegExp("\""), QString::null));
+  return themeFont;
+}
+
+QFont KSim::Theme::smallFont() const
+{
+  QString font(internalStringEntry("small_font", QString::null));
+
+  if (font.isEmpty())
+    return QApplication::font();
+
+  QFont themeFont;
+  themeFont.setRawName(font.replace(QRegExp("\""), QString::null));
+  return themeFont;
+}
+
+QFont KSim::Theme::currentFont() const
+{
+  switch (fontItem()) {
+    case 0:
+      return smallFont();
+      break;
+    case 1:
+      return normalFont();
+      break;
+    case 2:
+      return largeFont();
+      break;
+    case 3:
+      return KSim::ThemeLoader::currentFont();
+      break;
+    case 4:
+      return KGlobalSettings::generalFont();
+      break;
+  }
+
+  return QFont();
+}
+
+QString KSim::Theme::meterPixmap(int type, bool useDefault) const
+{
+  QString imageFile = createType(type, d->location);
+  QString text;
+  QString file = d->fileNames[7];
+
+  QStringList::ConstIterator it;
+  for (it = d->imageTypes.begin(); it != d->imageTypes.end(); ++it) {
+    if (QFile::exists(imageFile + file + d->altTheme + "." + *it)) {
+      text = imageFile + file + d->altTheme + "." + *it;
+      break;
+    }
+    else
+    if (QFile::exists(d->location + file + d->altTheme + "." + *it)) {
+      text = d->location + file + d->altTheme + "." + *it;
+      break;
+    }
+  }
+
+  if (text.isNull() && useDefault)
+    return KSim::ThemeLoader::defaultUrl() + d->fileNames[7] + ".png";
+
+  return text;
+}
+
+QString KSim::Theme::panelPixmap(int type, bool useDefault) const
+{
+  QString imageFile = createType(type, d->location);
+  QString text;
+  QString file = d->fileNames[6];
+
+  QStringList::ConstIterator it;
+  for (it = d->imageTypes.begin(); it != d->imageTypes.end(); ++it) {
+    if (QFile::exists(imageFile + file + d->altTheme + "." + *it)) {
+      text = imageFile + file + d->altTheme + "." + *it;
+      break;
+    }
+    else
+    if (QFile::exists(d->location + file + d->altTheme + "." + *it)) {
+      text = d->location + file + d->altTheme + "." + *it;
+      break;
+    }
+  }
+
+  if (text.isNull() && useDefault)
+    return KSim::ThemeLoader::defaultUrl() + d->fileNames[6] + ".png";
+
+  return text;
+}
+
+QString KSim::Theme::ledPixmap(int type, bool useDefault) const
+{
+  QString imageFile = createType(type, d->location);
+  QString text;
+  QString file = d->fileNames[30];
+
+  QStringList::ConstIterator it;
+  for (it = d->imageTypes.begin(); it != d->imageTypes.end(); ++it) {
+    if (QFile::exists(imageFile + file + d->altTheme + "." + *it)) {
+      text = imageFile + file + d->altTheme + "." + *it;
+      break;
+    }
+    else
+    if (QFile::exists(d->location + file + d->altTheme + "." + *it)) {
+      text = d->location + file + d->altTheme + "." + *it;
+      break;
+    }
+  }
+
+  if (text.isNull() && useDefault)
+    return KSim::ThemeLoader::defaultUrl() + d->fileNames[30] + ".png";
+
+  return text;
+}
+
+QString KSim::Theme::framePixmap(int type, bool useDefault) const
+{
+  QString text;
+  QString file;
+
+  switch (type) {
+    case Types::TopFrame:
+      file = d->fileNames[0];
+      break;
+    case Types::BottomFrame:
+      file = d->fileNames[1];
+      break;
+    case Types::LeftFrame:
+      file = d->fileNames[2];
+      break;
+    case Types::RightFrame:
+      file = d->fileNames[3];
+      break;
+  }
+
+  QStringList::ConstIterator it;
+  for (it = d->imageTypes.begin(); it != d->imageTypes.end(); ++it) {
+    if (QFile::exists(d->location + file + d->altTheme + "." + *it)) {
+      text = d->location + file + d->altTheme + "." + *it;
+      break;
+    }
+  }
+
+  if (text.isNull() && useDefault) {
+    switch (type) {
+      case Types::TopFrame:
+        return KSim::ThemeLoader::defaultUrl() + d->fileNames[0] + ".png";
+        break;
+      case Types::BottomFrame:
+        return KSim::ThemeLoader::defaultUrl() + d->fileNames[1] + ".png";
+        break;
+      case Types::LeftFrame:
+        return KSim::ThemeLoader::defaultUrl() + d->fileNames[2] + ".png";
+        break;
+      case Types::RightFrame:
+        return KSim::ThemeLoader::defaultUrl() + d->fileNames[3] + ".png";
+        break;
+    }
+  }
+
+  return text;
+}
+
+QString KSim::Theme::chartPixmap(bool useDefault) const
+{
+  return loader(4, useDefault);
+}
+
+QString KSim::Theme::gridPixmap(bool useDefault) const
+{
+  return loader(5, useDefault);
+}
+
+QString KSim::Theme::krellPanelPixmap(bool useDefault) const
+{
+  return loader(14, useDefault);
+}
+
+QString KSim::Theme::krellMeterPixmap(bool useDefault) const
+{
+  return loader(15, useDefault);
+}
+
+QString KSim::Theme::krellSliderPixmap(bool useDefault) const
+{
+  return loader(16, useDefault);
+}
+
+QString KSim::Theme::dataInPixmap(bool useDefault) const
+{
+  return loader(18, useDefault);
+}
+
+QString KSim::Theme::dataOutPixmap(bool useDefault) const
+{
+  return loader(20, useDefault);
+}
+
+QString KSim::Theme::mailPixmap(bool useDefault) const
+{
+  QString imageFile = createType(KSim::Types::Mail, d->location);
+  QString text;
+  QString file = d->fileNames[25];
+
+  QStringList::ConstIterator it;
+  for (it = d->imageTypes.begin(); it != d->imageTypes.end(); ++it) {
+    if (QFile::exists(imageFile + file + d->altTheme + "." + *it)) {
+      text = imageFile + file + d->altTheme + "." + *it;
+      break;
+    }
+    else
+    if (QFile::exists(d->location + file + d->altTheme + "." + *it)) {
+      text = d->location + file + d->altTheme + "." + *it;
+      break;
+    }
+  }
+
+  if (text.isNull() && useDefault)
+    return KSim::ThemeLoader::defaultUrl()
+       + createType(KSim::Types::Mail, QString::null) + file + ".png";
+
+  return text;
+}
+
+QPixmap KSim::Theme::splitPixmap(PixmapType type, uint itemNo,
+   bool useDefault) const
+{
+  return pixmapToList(type, itemNo, useDefault)[itemNo];
+}
+
+QValueList<QPixmap> KSim::Theme::pixmapToList(PixmapType type,
+   int limitAmount, bool useDefault) const
+{
+  QImage image;
+  int xOffset = 0;
+  int yOffset = 0;
+  int depth = 0;
+
+  switch (type) {
+    case KrellPanel:
+      depth = readIntEntry("StylePanel", "*.krell_depth");
+      xOffset = readIntEntry("StylePanel", "*.krell_x_hot");
+      yOffset = readIntEntry("StylePanel", "*.krell_yoff");
+      image.load(krellPanelPixmap(useDefault));
+      kdDebug(2003) << "KSim::Theme: type = KrellPanel" << endl;
+      break;
+    case KrellMeter:
+      depth = readIntEntry("StyleMeter", "*.krell_depth");
+      xOffset = readIntEntry("StyleMeter", "*.krell_x_hot");
+      yOffset = readIntEntry("StyleMeter", "*.krell_yoff");
+      image.load(krellMeterPixmap(useDefault));
+      kdDebug(2003) << "KSim::Theme: type = KrellMeter" << endl;
+      break;
+    case KrellSlider:
+      depth = krellSliderDepth();
+      image.load(krellSliderPixmap(useDefault));
+      kdDebug(2003) << "KSim::Theme: type = KrellSlider" << endl;
+      break;
+    default:
+      return QValueList<QPixmap>();
+      break;
+  }
+
+  if (image.isNull())
+    return QValueList<QPixmap>();
+
+  QValueList<QPixmap> list;
+  int size = image.height();
+  if (depth)
+    size = image.height() / depth;
+
+  KSim::ThemeLoader::self().reColourImage(image);
+  QPixmap pixmap = image;
+  QPixmap newPixmap(image.width() - xOffset, size);
+
+  for (int i = 0; i < (depth + 1); ++i) {
+    newPixmap.fill();
+
+    if (pixmap.mask()) {
+      QBitmap mask(newPixmap.size());
+      bitBlt(&mask, 0, 0, pixmap.mask(), xOffset, yOffset,
+         image.width() - xOffset, size);
+      newPixmap.setMask(mask);
+    }
+
+    bitBlt(&newPixmap, 0, 0, &pixmap, xOffset, yOffset,
+       image.width() - xOffset, size);
+
+    list.append(newPixmap);
+
+    if (limitAmount == i)
+      break;
+  }
+
+  kdDebug(2003) << "KSim::Theme: size = " << size << endl;
+  kdDebug(2003) << "KSim::Theme: depth = " << depth << endl;
+  kdDebug(2003) << "KSim::Theme: xOffset = " << xOffset << endl;
+  kdDebug(2003) << "KSim::Theme: yOffset = " <<  xOffset << endl;
+
+  return list;
+}
+
+int KSim::Theme::transparency(const QString &itemType,
+   const QString &entry) const
+{
+  return readIntEntry(itemType, entry);
+}
+
+bool KSim::Theme::textShadow(const QString &itemType,
+   const QString &entry) const
+{
+  if (d->recolour)
+    return false;
+
+  QString shadow = readEntry(itemType, entry);
+  if (shadow.isEmpty() || shadow.findRev("none") != -1)
+    return false;
+
+  return true;
+}
+
+QColor KSim::Theme::shadowColour(const QString &itemType,
+   const QString &entry) const
+{
+  return readColourEntry(itemType, entry, 1);
+}
+
+QColor KSim::Theme::textColour(const QString &itemType,
+   const QString &entry) const
+{
+  if (d->recolour)
+    return KGlobalSettings::textColor();
+
+  return readColourEntry(itemType, entry, 0);
+}
+
+int KSim::Theme::readIntEntry(const QString &itemType,
+    const QString &entry) const
+{
+  QString entryName = itemType + " " + entry;
+  return internalNumEntry(entryName, 0);
+}
+
+QRect KSim::Theme::readRectEntry(const QString &itemType,
+   const QString &entry) const
+{
+  QString entryName = itemType + " " + entry;
+  return internalRectEntry(entryName, QRect());
+}
+
+QString KSim::Theme::readEntry(const QString &itemType,
+   const QString &entry) const
+{
+  QString entryName = itemType + " " + entry;
+  return internalStringEntry(entryName, QString::null);
+}
+
+QString KSim::Theme::readColourEntry(const QString &itemType,
+   const QString &entry, int row) const
+{
+  QString color = readEntry(itemType, entry);
+  if (color.isEmpty())
+    color = QString::fromLatin1("#ffffff #ffffff");
+
+  return QStringList::split(' ', color)[row];
+}
+
+QFont KSim::Theme::readFontEntry(const QString &itemType,
+   const QString &entry) const
+{
+  const QString &font = readEntry(itemType, entry);
+
+  // If only there was a better way of doing this
+  if (font == "small_font")
+    return smallFont();
+  else
+  if (font == "normal_font")
+    return normalFont();
+  else
+  if (font == "large_font")
+    return largeFont();
+
+  return QFont();
+}
+
+bool KSim::Theme::fontColours(int type, const QString &string, QFont &font,
+   QColor &text, QColor &shadow, bool &showShadow) const
+{
+  QString key = KSim::Types::typeToString(type, false);
+  bool repaint = false;
+
+  // set colours from the string 'key'
+  if (!readEntry(string, key + ".textcolor").isEmpty()) {
+    text= textColour(string, key + ".textcolor");
+    shadow = shadowColour(string, key + ".textcolor");
+    showShadow = textShadow(string, key + ".textcolor");
+    repaint = true;
+  }
+  else {
+    text= textColour(string, "*.textcolor");
+    shadow = shadowColour(string, "*.textcolor");
+    showShadow = textShadow(string, "*.textcolor");
+  }
+
+  // set fonts from the string 'key'
+  if (!readEntry(string, key + ".font").isEmpty()) {
+    if (KSim::ThemeLoader::currentFontItem() != 3) {
+      font = readFontEntry(string, key + ".font");
+      repaint = true;
+    }
+  }
+  else {
+    font = currentFont();
+  }
+
+  return repaint;
+}
+
+bool KSim::Theme::fontColours(const KSim::Base *const base, QFont &font,
+   QColor &text, QColor &shadow, bool &showShadow) const
+{
+  if (!base)
+    return false;
+
+  return fontColours(base->type(), base->configString(), font,
+     text, shadow, showShadow);
+}
+
+KSim::Theme::Theme()
+{
+  d = 0;
+}
+
+KSim::Theme::Theme(const QString &url, const QString &fileName, int alt,
+   const QValueVector<QString> &vector, const QStringList &list,
+   KConfig *globalReader)
+{
+  create(vector, list, globalReader);
+  init(url, fileName, alt);
+
+  KSim::Config::config()->setGroup("Misc");
+  d->recolour = KSim::Config::config()->readBoolEntry("ReColourTheme", false);
+}
+
+void KSim::Theme::create(const QValueVector<QString> &vector,
+   const QStringList &list, KConfig *globalReader)
+{
+  d = new Private(vector, list);
+  d->globalReader = globalReader;
+}
+
+void KSim::Theme::init(const QString &url, const QString &fileName, int alt)
+{
+  d->altTheme = KSim::ThemeLoader::alternativeAsString(alt);
+  d->location = url;
+  d->alternative = alt;
+  d->font = KSim::ThemeLoader::currentFontItem();
+
+  d->file = QStringList::split("\n", parseConfig(url, fileName));
+
+  if (alt != 0)
+    d->dFile = QStringList::split("\n", parseConfig(url, "gkrellmrc"));
+}
+
+void KSim::Theme::reparse(const QString &url, const QString &fileName, int alt)
+{
+  init(url, fileName, alt);
+}
+
+QString KSim::Theme::parseConfig(const QString &url,
+     const QString &fileName)
+{
+  return KSim::ThemeLoader::self().parseConfig(url, fileName);
+}
+
+QString KSim::Theme::loader(int value, bool useDefault) const
+{
+  QString text;
+  QString file = d->fileNames[value];
+
+  QStringList::ConstIterator it;
+  for (it = d->imageTypes.begin(); it != d->imageTypes.end(); ++it) {
+    if (QFile::exists(d->location + file + d->altTheme + "." + *it)) {
+      text = d->location + file + d->altTheme + "." + *it;
+      break;
+    }
+  }
+
+  if (text.isNull() && useDefault)
+    return KSim::ThemeLoader::defaultUrl() + d->fileNames[value] + ".png";
+
+  return text;
+}
+
+QString KSim::Theme::createType(int type, const QString &text) const
+{
+  if (type == Types::None)
+    return text;
+
+  return text + KSim::Types::typeToString(type);
+}
+
+void KSim::Theme::setRecolour(bool value)
+{
+  if (!d)
+    return;
+
+  d->recolour = value;
+}
+
+// Keep the ugliness here to make the rest
+// of the class readable
+int KSim::Theme::internalNumEntry(const QString &entry, int defValue) const
+{
+  return d->readOption(entry, true, QString::number(defValue)).toInt();
+}
+
+QRect KSim::Theme::internalRectEntry(const QString &entry,
+   const QRect &defValue) const
+{
+  QString rect;
+  rect += QString::number(defValue.left());
+  rect += ",";
+  rect += QString::number(defValue.top());
+  rect += ",";
+  rect += QString::number(defValue.width());
+  rect += ",";
+  rect += QString::number(defValue.height());
+
+  QStringList list = QStringList::split(",", d->readOption(entry, true, rect));
+  QRect rect2(list[0].toInt(), list[1].toInt(), list[2].toInt(), list[3].toInt());
+
+  return rect2;
+}
+
+QColor KSim::Theme::internalColourEntry(const QString &entry,
+   const QColor &defValue) const
+{
+  return d->readOption(entry, true, defValue.name());
+}
+
+QString KSim::Theme::internalStringEntry(const QString &entry,
+   const QString &defValue) const
+{
+  return d->readOption(entry, true, defValue);
+}
+
+// check if the dir is writable, if not generate the new file in the home dir
+#define KSIM_THEME_URL(url) \
+{ \
+}
+
+KSim::ThemeLoader *KSim::ThemeLoader::m_self = 0; // initialize pointer
+KSim::ThemeLoader &KSim::ThemeLoader::self()
+{
+  if (!m_self) { // is it the first call?
+    m_self = new KSim::ThemeLoader; // create sole instance
+    qAddPostRoutine(cleanup);
+  }
+
+  return *m_self; // address of sole instance
+}
+
+bool KSim::ThemeLoader::isDifferent() const
+{
+  // if the theme path, theme alternative or the
+  // specified font has changed then we should
+  // return true, else false
+
+  KSim::Config::config()->setGroup("Misc");
+  bool recolour = KSim::Config::config()->readBoolEntry("ReColourTheme", false);
+
+  return (current().path() != currentUrl()
+     || current().alternative() != currentAlternative()
+     || current().fontItem() != currentFontItem()
+     || d->recolour != recolour);
+}
+
+void KSim::ThemeLoader::reload()
+{
+  reColourItems();
+  grabColour();
+
+  if (!isDifferent())
+    return;
+
+  if (currentUrl() != defaultUrl()) {
+    if (!d->globalReader)
+      d->globalReader = new KConfig(defaultUrl() + "gkrellmrc_ksim");
+  }
+  else {
+    delete d->globalReader;
+    d->globalReader = 0;
+  }
+
+  if (m_theme.d)
+    m_theme.d->globalReader = d->globalReader;
+
+  QString fileName = QString::fromLatin1("gkrellmrc") + alternativeAsString();
+  m_theme.reparse(currentUrl(), fileName, currentAlternative());
+}
+
+const KSim::Theme &KSim::ThemeLoader::current() const
+{
+  return m_theme;
+}
+
+KSim::Theme KSim::ThemeLoader::theme(const QString &url,
+   const QString &rcFile, int alt) const
+{
+  return KSim::Theme(url, rcFile, alt, d->fileNames,
+     d->imageTypes, d->globalReader);
+}
+
+void KSim::ThemeLoader::reColourImage(QImage &image)
+{
+  if (!d->recolour || image.isNull())
+    return;
+
+  QColor color = QApplication::palette().active().background();
+  QImage output(image.width(), image.height(), 32);
+  output.setAlphaBuffer(image.hasAlphaBuffer());
+
+  Q_UINT32 r = color.red();
+  Q_UINT32 g = color.green();
+  Q_UINT32 b = color.blue();
+  Q_UINT32 *write = reinterpret_cast<Q_UINT32 *>(output.bits());
+  Q_UINT32 *read  = reinterpret_cast<Q_UINT32 *>(image.bits());
+  int size = image.width() * image.height();
+
+  for (int pos = 0; pos < size; pos++)
+  {
+    QRgb basePix = static_cast<QRgb>(*read);
+
+    // Here, we assume that source is really gray, so R=G=B=I
+    // Use blue since it's very easy to extract.
+    Q_UINT32 i = qBlue(basePix);
+
+    Q_UINT32 cr = (r * i + 128) >> 8; // Fixed point..
+    Q_UINT32 cg = (g * i + 128) >> 8;
+    Q_UINT32 cb = (b * i + 128) >> 8;
+
+    Q_UINT32 alpha = qAlpha(basePix);
+    *write = qRgba(cr, cg, cb, alpha);
+    write++;
+    read++;
+  }
+
+  image = output;
+}
+
+QString KSim::ThemeLoader::parseConfig(const QString &url,
+   const QString &fileName)
+{
+  QFile origFile(url + fileName);
+
+  if (!origFile.open(IO_ReadOnly))
+    return QString::null;
+
+  QTextStream origStream(&origFile);
+  QString text;
+  QRegExp reg("\\*"); // regexp for '*' chars
+  QRegExp number("[0-9]+");  // regexp for all numbers
+  QRegExp numbers("[0-9]+,[0-9]+,[0-9]+,[0-9]+"); // regexp for int,int,int,int
+  QRegExp minus("[a-zA-Z]+ \\- [a-zA-Z]+"); // regexp for 'someText - someText'
+  while (!origStream.atEnd()) {
+    QString line(origStream.readLine().simplifyWhiteSpace());
+
+    if (line.find(reg) == 0) // find the location of the * comments
+      // replace all * comments with # comments so KConfig doesn't complain
+      line.replace(reg, "#");
+
+    if (line.find("#") == -1) { // find the location of the string 'gkrellmms'
+      if (line.findRev("=") == -1) { // if found we check for the string '='
+        int numLoc = line.findRev(numbers);
+        if (numLoc != -1)
+          // if '=' doesn't exist we add one so KConfig doesn't complain
+          line.insert(numLoc, " = ");
+
+        numLoc = line.findRev(number);
+        if (numLoc != -1)
+          // if '=' doesn't exist we add one so KConfig doesn't complain
+          line.insert(numLoc, " = ");
+
+        numLoc = line.findRev(minus);
+        if (numLoc != -1)
+          // replace the '-' with an '=' so KConfig doesn't get confused
+          line.replace(QRegExp("-"), "=");
+      }
+    }
+
+    text.append(line).append('\n');
+  }
+
+  return text;
+}
+
+// GKrellM themes seem to be rather inconsistant
+// so the following code changes the dir structure
+// of a theme to be more consistant, but the dir structure
+// is still compliant with GKrellM.
+void KSim::ThemeLoader::parseDir(const QString &url, int alt)
+{
+  if ( !QFileInfo( url ).isWritable() && currentName() != "ksim" )
+  {
+    QString homePath = QDir::current().path();
+    homePath = locateLocal( "data", "ksim" )
+       + QString::fromLatin1( "/themes" )
+       + homePath.right( homePath.length()
+       - homePath.findRev( QRegExp( "\\/" ),
+       homePath.length() ) );
+
+    if ( !QFile::exists( homePath ) )
+      KStandardDirs::makeDir( homePath );
+
+    kdWarning() << "Cant write to current dir, setting dir to "
+       << homePath << endl;
+
+    QDir::setCurrent( homePath );
+  }
+
+  int alternatives = ++alt;
+
+  QStringList formats;
+  QStringList panels;
+  QStringList meters;
+
+  formats << "png" << "jpg" << "jpeg" << "gif" << "xpm";
+  panels << "inet" << "net" << "proc" << "cpu" << "disk";
+  meters << "mem" << "fs" << "mail" << "apm" << "uptime"
+     << "clock" << "cal" << "timer" << "host" << "swap";
+
+  QDir directory;
+  for (int i = 0; i < alternatives; ++i) {
+    QString altString = KSim::ThemeLoader::alternativeAsString(i);
+    if (alternatives == 1 || i == 0)
+      altString = QString::null;
+
+    QStringList::ConstIterator format;
+    for (format = formats.begin(); format != formats.end(); ++format) {
+      // go through the meters array and move the files to the correct dir/filename
+      QStringList::Iterator meter;
+      for (meter = meters.begin(); meter != meters.end(); ++meter) {
+        QString bgMeter = QString::fromLatin1("bg_meter_");
+        if (QFile::exists(bgMeter + (*meter) + altString + "." +  (*format))) {
+          if (KStandardDirs::makeDir(url + (*meter)))
+            directory.rename(bgMeter + (*meter) + altString + "." + (*format),
+                 (*meter) + "/bg_meter" + altString + "." + (*format));
+        }
+      }
+
+      // go through the panels array and move the files to the correct dir/filename
+      QStringList::ConstIterator panel;
+      for (panel = panels.begin(); panel != panels.end(); ++panel) {
+        QString bgPanel = QString::fromLatin1("bg_panel_");
+        if (QFile::exists(bgPanel + (*panel) + altString + "." + (*format))) {
+          if (KStandardDirs::makeDir(url + (*panel)))
+            directory.rename(bgPanel + (*panel) + altString + "." + (*format),
+                (*panel) + "/bg_panel" + altString + "." + (*format));
+        }
+      }
+
+      // fix stupid themes that have a bg_panel image in the host dir
+      QString tempFile = QString::fromLatin1("host/bg_panel");
+      if (QFile::exists(tempFile + altString + "." + (*format)))
+        directory.rename(tempFile + altString + "." + (*format), "host/bg_meter"
+           + altString + "." + (*format));
+
+      // move decal_net_leds* to the net folder to be more consistant
+      tempFile = QString::fromLatin1("decal_net_leds");
+      if (QFile::exists(tempFile + altString + "." + (*format))) {
+        if (KStandardDirs::makeDir(url + "net"))
+          directory.rename(tempFile + altString + "." + (*format),
+             "net/decal_net_leds" + altString + "." + (*format));
+      }
+    }
+  }
+}
+
+void KSim::ThemeLoader::validate()
+{
+  if (!QFile::exists(currentUrl())) {
+    KSim::Config::config()->setGroup("Theme");
+    KSim::Config::config()->writeEntry("Name", "ksim");
+    KSim::Config::config()->writeEntry("Alternative", 0);
+    KSim::Config::config()->sync();
+  }
+}
+
+void KSim::ThemeLoader::themeColours(QWidget *widget)
+{
+  widget->setEraseColor(d->pixelColour);
+}
+
+QString KSim::ThemeLoader::currentName()
+{
+  KSim::Config::config()->setGroup("Theme");
+  return KSim::Config::config()->readEntry("Name", "ksim");
+}
+
+QString KSim::ThemeLoader::currentUrl()
+{
+  KSim::Config::config()->setGroup("Theme");
+  QString folder(KSim::Config::config()->readEntry("Name"));
+  folder.prepend("ksim/themes/").append("/");
+  QString dirName(KGlobal::dirs()->findResourceDir("data", folder));
+  dirName += folder;
+
+  return dirName;
+}
+
+QString KSim::ThemeLoader::defaultUrl()
+{
+  return KGlobal::dirs()->findDirs("data", "ksim/themes/ksim").first();
+}
+
+int KSim::ThemeLoader::currentAlternative()
+{
+  KSim::Config::config()->setGroup("Theme");
+  int alternative = KSim::Config::config()->readNumEntry("Alternative");
+
+  if ( alternative > self().current().alternatives() )
+    alternative = self().current().alternatives();
+
+  return alternative;
+}
+
+QString KSim::ThemeLoader::alternativeAsString(int alt)
+{
+  int alternative = (alt == -1 ? currentAlternative() : alt);
+  return (alternative == 0 ? QString::null : QString::fromLatin1("_")
+     + QString::number(alternative));
+}
+
+QFont KSim::ThemeLoader::currentFont()
+{
+  if (currentFontItem() != 3)
+    return self().current().currentFont();
+
+  KSim::Config::config()->setGroup("Theme");
+  return KSim::Config::config()->readFontEntry("Font");
+}
+
+int KSim::ThemeLoader::currentFontItem()
+{
+  KSim::Config::config()->setGroup("Theme");
+  return KSim::Config::config()->readNumEntry("FontItem", 0);
+}
+
+KSim::ThemeLoader::ThemeLoader()
+{
+  m_self = this;
+
+  d = new Private;
+  d->imageTypes << "png" << "jpg" << "jpeg" << "xpm" << "gif";
+
+  if (currentUrl() != defaultUrl())
+    d->globalReader = new KConfig(defaultUrl() + "gkrellmrc_ksim");
+  else
+    d->globalReader = 0;
+
+  d->fileNames.resize(31);
+  d->fileNames[0] = "frame_top";
+  d->fileNames[1] = "frame_bottom";
+  d->fileNames[2] = "frame_left";
+  d->fileNames[3] = "frame_right";
+  d->fileNames[4] = "bg_chart";
+  d->fileNames[5] = "bg_grid";
+  d->fileNames[6] = "bg_panel";
+  d->fileNames[7] = "bg_meter";
+  d->fileNames[8] = "bg_slider_panel";
+  d->fileNames[9] = "bg_slider_meter";
+  d->fileNames[10] = "button_panel_in";
+  d->fileNames[11] = "button_panel_out";
+  d->fileNames[12] = "button_meter_in";
+  d->fileNames[13] = "button_meter_out";
+  d->fileNames[14] = "krell_panel";
+  d->fileNames[15] = "krell_meter";
+  d->fileNames[16] = "krell_slider";
+  d->fileNames[17] = "decal_misc";
+  d->fileNames[18] = "data_in";
+  d->fileNames[19] = "data_in_grid";
+  d->fileNames[20] = "data_out";
+  d->fileNames[21] = "data_out_grid";
+  d->fileNames[22] = "krell";
+  d->fileNames[23] = "spacer_top";
+  d->fileNames[24] = "spacer_bottom";
+  d->fileNames[25] = "decal_mail";
+  d->fileNames[26] = "krell_penguin";
+  d->fileNames[27] = "bg_volt";
+  d->fileNames[28] = "decal_timer_button";
+  d->fileNames[29] = "bg_timer";
+  d->fileNames[30] = "decal_net_leds";
+
+  m_theme.create(d->fileNames, d->imageTypes, d->globalReader);
+
+  QString fileName = QString::fromLatin1("gkrellmrc") + alternativeAsString();
+  m_theme.init(currentUrl(), fileName, currentAlternative());
+
+  reColourItems();
+  grabColour();
+}
+
+KSim::ThemeLoader::~ThemeLoader()
+{
+  delete d->globalReader;
+  delete d;
+}
+
+void KSim::ThemeLoader::cleanup()
+{
+  if (!m_self)
+    return;
+
+  delete m_self;
+  m_self = 0;
+}
+
+void KSim::ThemeLoader::reColourItems()
+{
+  KSim::Config::config()->setGroup("Misc");
+  d->recolour = KSim::Config::config()->readBoolEntry("ReColourTheme", false);
+  m_theme.setRecolour(d->recolour);
+}
+
+void KSim::ThemeLoader::grabColour()
+{
+  KSim::Config::config()->setGroup("Theme");
+  QPoint pos(2, 2);
+  pos = KSim::Config::config()->readPointEntry("PixelLocation", &pos);
+
+  QImage image(current().meterPixmap(Types::None));
+  reColourImage(image);
+  d->pixelColour = image.pixel(pos.x(), pos.y());
+}