• Skip to content
• Skip to link menu

KDE 4.0 API Reference

• KDE API Reference
• kdeutils

• Sitemap
• Contact Us

 

superkaramba

karamba.cpp

Go to the documentation of this file.

/*
 * Copyright (C) 2003-2004 Adam Geitgey <adam@rootnode.org>
 * Copyright (C) 2003 Hans Karlsson <karlsson.h@home.se>
 * Copyright (C) 2004,2005 Luke Kenneth Casson Leighton <lkcl@lkcl.net>
 * Copyright (c) 2005 Ryan Nickell <p0z3r@earthlink.net>
 * Copyright (c) 2007 Alexander Wiedenbruch <mail@wiedenbruch.de>
 *
 * This file is part of SuperKaramba.
 *
 *  SuperKaramba 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.
 *
 *  SuperKaramba 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 SuperKaramba; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 ****************************************************************************/

#include "karamba.h"
#include "karamba.moc"

#include <QGraphicsView>
#include <QGraphicsScene>
#include <QStack>
#include <QDesktopWidget>
#include <QApplication>
#include <QX11Info>
#include <QBitmap>
#include <QSignalMapper>

#include <KDebug>
#include <KWindowSystem>
#include <KIcon>
#include <KLocale>
#include <KDirWatch>
#include <KMenu>
#include <KConfig>
#include <KToggleAction>
#include <KCmdLineArgs>

#include "config-superkaramba.h"

#include "karambamanager.h"

#include "meters/textfield.h"
#include "meters/richtextlabel.h"
#include "meters/bar.h"
#include "meters/graph.h"
#include "meters/textlabel.h"
#include "meters/input.h"
#include "meters/imagelabel.h"
#include "meters/clickarea.h"
#include "meters/clickmap.h"

#include "sensors/sensor.h"
#include "sensors/mem.h"
#include "sensors/disk.h"
#include "sensors/network.h"
#include "sensors/date.h"
#include "sensors/program.h"
#include "sensors/sensorparams.h"
#include "sensors/textfile.h"
#include "sensors/rss.h"
#include "sensors/uptime.h"
#include "sensors/lmsensor.h"
#include "sensors/cpu.h"

#ifdef PLASMASENSOR_ENABLED
    #include "sensors/plasmaengine.h"
#endif

#include "python/karamba.h"

#include "karambaapp.h"
#include "systemtray.h"
#include "karambainterface.h"
#include "mainwidget.h"
#include "lineparser.h"
#include "themelocale.h"
#include "superkarambasettings.h"

extern "C" {
    KDE_EXPORT QGraphicsItemGroup* startKaramba(const KUrl &theme, QGraphicsView *view)
    {
        return new Karamba(theme, view);
    }
}

class Karamba::Private
{
    public:
        ThemeFile theme;
        QGraphicsScene *scene;
        QGraphicsView *view;

        KWindowSystem *KWinModule;

        bool useKross;
#ifdef PYTHON_INCLUDE_PATH
        KarambaPython *python;
#endif
        KarambaInterface *interface;

        bool foundKaramba;
        bool onTop;
        bool managed;

        NETWinInfo *info;

        QRect size;

        u_int desktop;

        u_int interval;

        char tempUnit;

        TextField *defaultTextField;

        int scaleStep;
        bool showMenu;

        QList<Sensor*> sensorList;
        QMap<QString, Sensor*> sensorMap;

        KMenu *popupMenu;
        KToggleAction *toggleLocked;
        KAction* reloadTheme;
        KMenu *themeConfMenu;
        KMenu *toDesktopMenu;
        KMenu *globalMenu;

        QTimer stepTimer;

        QSignalMapper *signalMapperConfig;
        QSignalMapper *signalMapperDesktop;

        KConfig *config;

        int instance;

        QList<KMenu*> menuList;

        QString prettyName;

        QString storedData;

        double updateTime;

        bool wantRightButton;

        QPoint mouseClickPos;

        bool globalView;

        bool subTheme;

        QPoint themeCenter;

        QGraphicsItemAnimation *animation;
        QTimeLine *timer;

        //OrgKdeKdesktopBackgroundInterface* backgroundInterface;

        bool useFancyEffects;
        bool useAntialiasing;

        bool errorInInit;

        K3Process *currProcess;
        Systemtray *systray;

        Private(QGraphicsView *view, int instance, bool subTheme) :
            scene(view ? view->scene() : 0),
            view(view),
            KWinModule(0),
            useKross(true),
#ifdef PYTHON_INCLUDE_PATH
            python(0),
#endif
            interface(0),
            foundKaramba(false),
            onTop(false),
            managed(false),
            info(0),
            desktop(0),
            interval(0),
            tempUnit('C'),
            defaultTextField(0),
            scaleStep(-1),
            showMenu(false),
            popupMenu(0),
            toggleLocked(0),
            reloadTheme(0),
            themeConfMenu(0),
            toDesktopMenu(0),
            globalMenu(0),
            signalMapperConfig(0),
            signalMapperDesktop(0),
            config(0),
            instance(instance),
            storedData(""),
            wantRightButton(false),
            globalView(view ? true : false),
            subTheme(subTheme),
            animation(0),
            timer(0),
            //backgroundInterface(0),
            useFancyEffects(true),
            useAntialiasing(true),
            errorInInit(false),
            currProcess(0),
            systray(0)
        {
        }

        ~Private()
        {
            delete config;

            delete info;

#ifdef PYTHON_INCLUDE_PATH
            if (python) {
                delete python;
            }
#endif

            if (interface) {
                delete interface;
            }

            qDeleteAll(sensorList);
            sensorList.clear();

            delete toDesktopMenu;
            delete themeConfMenu,
            delete toggleLocked;
            delete reloadTheme;
            delete popupMenu;

            delete animation;
            delete timer;

            //delete backgroundInterface;

            if (!globalView) {
                delete view;
                delete scene;
            }

            delete currProcess;
            delete systray;
        }
};

Karamba::Karamba(const KUrl &themeFile, QGraphicsView *view, int instance, bool subTheme, const QPoint &startPos, bool reload)
        : QObject(),
        QGraphicsItemGroup(0, view ? view->scene() : 0),
        d(new Private(view, instance, subTheme))
{
    if (!d->globalView) {
        #ifdef PYTHON_INCLUDE_PATH
        KCmdLineArgs *args = KCmdLineArgs::parsedArgs();
        if (args->isSet("usefallback")) {
            d->useKross = false;
        }
        #endif
    }

    QString environment = getenv("SK_FANCY");
    if (!environment.compare("false", Qt::CaseInsensitive)) {
        d->useFancyEffects = false;
    }

    environment = getenv("SK_AA");
    if (!environment.compare("false", Qt::CaseInsensitive)) {
        d->useAntialiasing = false;
    }

    if (!d->globalView) {
        d->scene = new QGraphicsScene;
        d->scene->addItem(this);
        d->view = new MainWidget(d->scene);

        if (d->useAntialiasing) {
            d->view->setRenderHints(QPainter::Antialiasing |
                               QPainter::SmoothPixmapTransform);
        }

        d->scene->setItemIndexMethod(QGraphicsScene::NoIndex);

        d->view->show();
    }

    hide();

    if (!d->globalView) {
        d->view->setViewportUpdateMode(QGraphicsView::SmartViewportUpdate);
    }

    if (!d->theme.set(themeFile)) {
        kDebug() << "Could not load theme file" ;
        d->errorInInit = true;
        QTimer::singleShot(0, this, SLOT(startKaramba()));
        return;
    }

    KDirWatch *dirWatch = KDirWatch::self();
    connect(dirWatch, SIGNAL(dirty(const QString &)),
            SLOT(slotFileChanged(const QString &)));

    if (!dirWatch->contains(d->theme.file()))
        dirWatch->addFile(d->theme.file());

    if (!d->theme.isZipTheme() && d->theme.scriptModuleExists()) {
        QString scriptFile = d->theme.path() + '/' + d->theme.scriptModule();
        if (!dirWatch->contains(scriptFile))
            dirWatch->addFile(scriptFile);
    }

    if (d->prettyName.isEmpty())
        d->prettyName = QString("%1 - %2").arg(d->theme.name()).arg(d->instance);

    setObjectName("karamba - " + d->prettyName);

    if (!d->globalView) {
        d->info = new NETWinInfo(QX11Info::display(), d->view->winId(),
                            QX11Info::appRootWindow(), NET::WMState);
    }

    d->defaultTextField = new TextField();

    d->KWinModule = KWindowSystem::self();
    connect(d->KWinModule, SIGNAL(currentDesktopChanged(int)), this,
            SLOT(currentDesktopChanged(int)));
//TODO port it
    
#if 0
    d->backgroundInterface = new org::kde::kdesktop::Background("org.kde.kdesktop", "/Background", QDBusConnection::sessionBus());
    connect(d->backgroundInterface, SIGNAL(backgroundChanged(int)), this,
            SLOT(currentWallpaperChanged(int)));
#endif
    setAcceptsHoverEvents(true);

    // Setup of the Task Manager Callbacks
    connect(TaskManager::self(), SIGNAL(activeTaskChanged(Task::TaskPtr)), this,
            SLOT(activeTaskChanged(Task::TaskPtr)));
    connect(TaskManager::self(), SIGNAL(taskAdded(Task::TaskPtr)), this,
            SLOT(taskAdded(Task::TaskPtr)));
    connect(TaskManager::self(), SIGNAL(taskRemoved(Task::TaskPtr)), this,
            SLOT(taskRemoved(Task::TaskPtr)));
    connect(TaskManager::self(), SIGNAL(startupAdded(Startup::StartupPtr)), this,
            SLOT(startupAdded(Startup::StartupPtr)));
    connect(TaskManager::self(), SIGNAL(startupRemoved(Startup::StartupPtr)), this,
            SLOT(startupRemoved(Startup::StartupPtr)));

    d->signalMapperConfig = new QSignalMapper(this);
    connect(d->signalMapperConfig, SIGNAL(mapped(QObject*)), this,
            SLOT(slotToggleConfigOption(QObject*)));

    d->signalMapperDesktop = new QSignalMapper(this);
    connect(d->signalMapperDesktop, SIGNAL(mapped(int)), this,
            SLOT(slotDesktopChanged(int)));

    preparePopupMenu();

    parseConfig();

    QString instanceString;
    if (d->instance > 1)
        instanceString = QString("-%1").arg(d->instance);

    QString cfg = QDir::home().absolutePath() + "/.superkaramba/"
                  + d->theme.id() + instanceString + ".rc";
    kDebug() << cfg ;

    QFile themeConfigFile(cfg);
    // Tests if config file Exists
    if (!QFileInfo(themeConfigFile).exists()) {
        // Create config file
        themeConfigFile.open(QIODevice::ReadWrite);
        themeConfigFile.close();
    }

    d->config = new KConfig(cfg, KConfig::NoGlobals);

    // Karamba specific Config Entries
    KConfigGroup cg(d->config, "internal");
    bool locked = d->toggleLocked->isChecked();
    locked = cg.readEntry("lockedPosition", locked);
    d->toggleLocked->setChecked(locked);

    int desktop = 0;
    desktop = cg.readEntry("desktop", desktop);
    if (desktop > d->KWinModule->numberOfDesktops()) {
        desktop = 0;
    }

    slotDesktopChanged(desktop);

    cg = KConfigGroup(d->config, "theme");
    if (cg.hasKey("widgetPosX") && cg.hasKey("widgetPosY")) {
        int xpos = cg.readEntry("widgetPosX", 0);
        int ypos = cg.readEntry("widgetPosY", 0);

        if (xpos < 0)
            xpos = 0;
        if (ypos < 0)
            ypos = 0;

        if (startPos.isNull()) {
            moveToPos(QPoint(xpos, ypos));
        }
    }

    if (!startPos.isNull()) {
        moveToPos(startPos - d->themeCenter);

        d->toggleLocked->setChecked(false);
    }

    if (!d->globalView && !reload && d->useFancyEffects) {
        d->timer = new QTimeLine(1000);
        d->timer->setFrameRange(0, 1000);

        d->animation = new QGraphicsItemAnimation;
        d->animation->setItem(this);
        d->animation->setTimeLine(d->timer);

        // Use 201 here because 200.0/200.0 < 1 => theme is still scaled
        for (int i = 0; i < 201; i++) {
            d->animation->setScaleAt(i / 200.0, 1 / 200.0 * i, 1 / 200.0 * i);
            QPointF animPos(
                boundingRect().width()/2*(1-d->animation->verticalScaleAt(i / 200.0)),
                boundingRect().height()/2*(1-d->animation->horizontalScaleAt(i / 200.0))
            );
                d->animation->setPosAt(i / 200.0, animPos);
        }

        d->timer->start();
    }

    QTimer::singleShot(0, this, SLOT(startKaramba()));

    if (!(d->onTop || d->managed) && !d->globalView) {
        KWindowSystem::setState(d->view->winId(), NET::KeepBelow);
        KWindowSystem::lowerWindow(d->view->winId());
    }
}

Karamba::~Karamba()
{
    if (d->toggleLocked) // may NULL e.g. if "Could not load theme file"
        writeConfigData();

    d->scene->removeItem(this);

    delete d;
}

void Karamba::startKaramba()
{
    if (d->errorInInit) {
        deleteLater();
        return;
    }

    KarambaManager::self()->addKaramba(this);

    if (d->theme.scriptModuleExists()) {
        kDebug() << "Loading script module: " << d->theme.scriptModule() ;

        d->stepTimer.setSingleShot(true);

        if (!d->useKross) {
#ifdef PYTHON_INCLUDE_PATH
            d->python = new KarambaPython(d->theme, false);

            d->python->initWidget(this);
#endif
        } else {
            d->interface = new KarambaInterface(this);
            bool interpreterStarted = d->interface->initInterpreter();

            if (!interpreterStarted) {
                delete d->interface;
                d->interface = 0;
            } else {
                d->interface->startInterpreter();
                d->interface->callInitWidget(this);
            }
        }

        update();

        connect(&d->stepTimer, SIGNAL(timeout()), SLOT(step()));
        d->stepTimer.start(d->interval);
    }

    show();
}

QString Karamba::prettyName() const
{
    return d->prettyName;
}

void Karamba::setPrettyName(const QString &prettyThemeName)
{
    d->prettyName = prettyThemeName;
}

void Karamba::step()
{
    d->stepTimer.start(d->interval);

#ifdef PYTHON_INCLUDE_PATH
    if (d->python)
        d->python->widgetUpdated(this);
#endif

    if (d->interface)
        d->interface->callWidgetUpdated(this);

    update();
}

void Karamba::redrawWidget()
{
    // Force the event loop to process the update() calls
    // QCoreApplication::processEvents();
}

bool Karamba::parseConfig()
{
    //qDebug("karamba::parseConfig");
    bool passive = true;

    if (d->theme.open()) {
        QStack<QPoint> offsetStack;
        LineParser lineParser;
        int x = 0;
        int y = 0;
        int w = 0;
        int h = 0;

        offsetStack.push(QPoint(0, 0));

        while (d->theme.nextLine(lineParser)) {
            x = lineParser.getInt("X") + offsetStack.top().x();
            y = lineParser.getInt("Y") + offsetStack.top().y();
            w = lineParser.getInt("W");
            h = lineParser.getInt("H");

            if (lineParser.meter() == "KARAMBA" && !d->foundKaramba) {
                d->toggleLocked->setChecked(lineParser.getBoolean("LOCKED"));

                x = (x < 0) ? 0 : x;
                y = (y < 0) ? 0 : y;

                if (w == 0 ||  h == 0) {
                    w = 300;
                    h = 300;
                }

                // Store the center of the theme,
                // so it can be centered when a user
                // drags it from the theme dialog.
                d->themeCenter = QPoint(w/2, h/2);

                setFixedSize(w, h);
                if (!d->globalView) {
                    d->view->setFixedSize(w + 5, h + 5);
                }

                if (lineParser.getBoolean("RIGHT")) {
                    QDesktopWidget *d = QApplication::desktop();
                    x = d->width() - w;
                } else if (lineParser.getBoolean("LEFT")) {
                    x = 0;
                }

                if (lineParser.getBoolean("BOTTOM")) {
                    QDesktopWidget *d = QApplication::desktop();
                    y = d->height() - h;
                } else if (lineParser.getBoolean("TOP")) {
                    y = 0;
                }

                moveToPos(QPoint(x, y));

                if (lineParser.getBoolean("ONTOP")) {
                    d->onTop = true;
                    if (!d->globalView) {
                        KWindowSystem::setState(d->view->winId(), NET::StaysOnTop);
                   }
                }

                if (lineParser.getBoolean("MANAGED")) {
                    d->managed = true;
                    if (!d->globalView) {
                        Qt::WindowFlags flags = Qt::Dialog;
                        flags & Qt::WA_DeleteOnClose;
                        d->view->setWindowFlags(flags);
                        d->view->show();
                    }
                } else {
                    if (!d->globalView) {
                        d->info->setState(NETWinInfo::SkipTaskbar
                                     | NETWinInfo::SkipPager, NETWinInfo::SkipTaskbar
                                     | NETWinInfo::SkipPager);
                    }
                    if (d->onTop && !d->globalView) {
                        KWindowSystem::setState(d->view->winId(), NET::KeepAbove);
                    }
                }

                if (lineParser.getBoolean("ONALLDESKTOPS")) {
                    d->desktop = 200; // ugly
                }

                bool dfound = false;
                //int desktop = lineParser.getInt("DESKTOP", line, dfound);
                if (dfound && !d->globalView) {
                    d->info->setDesktop(dfound);
                }

                if (lineParser.getBoolean("TOPBAR")) {
                    if (!d->globalView) {
                        KWindowSystem::setStrut(d->view->winId(), 0, 0, h, 0);
                        d->view->move(x, 0);
                    } else {
                        moveToPos(QPoint(x, 0));
                    }

                    d->toggleLocked->setChecked(true);
                    d->toggleLocked->setEnabled(false);
                }

                if (lineParser.getBoolean("BOTTOMBAR")) {
                    int dh = QApplication::desktop()->height();
                    if (d->globalView) {
                        moveToPos(QPoint(x, dh - h));
                    } else {
                        KWindowSystem::setStrut(d->view->winId(), 0, 0, 0, h);
                        d->view->move(x, dh - h);
                    }
                    d->toggleLocked->setChecked(true);
                    d->toggleLocked->setEnabled(false);
                }

                if (lineParser.getBoolean("RIGHTBAR")) {
                    int dw = QApplication::desktop()->width();
                    if (d->globalView) {
                        moveToPos(QPoint(dw - w, y));
                    } else {
                        KWindowSystem::setStrut(d->view->winId(), 0, w, 0, 0);
                        d->view->move(dw - w, y);
                    }
                    d->toggleLocked->setChecked(true);
                    d->toggleLocked->setEnabled(false);
                }

                if (lineParser.getBoolean("LEFTBAR")) {
                    if (d->globalView) {
                        moveToPos(QPoint(0, y));
                    } else {
                        KWindowSystem::setStrut(d->view->winId(), w, 0, 0, 0);
                        d->view->move(0, y);
                    }
                    d->toggleLocked->setChecked( true );
                    d->toggleLocked->setEnabled(false);
                }

                if (d->globalView)
                    setFlag(QGraphicsItem::ItemIsMovable,
                            d->toggleLocked->isChecked());


                /* Masking gone
                QString path = lineParser.getString("MASK");

                QFileInfo info(path);
                QString absPath;
                QBitmap bmMask;
                QByteArray ba;
                if( info.isRelative() )
                {
                  absPath = d->theme.path();
                  absPath.append(path);
                  ba = d->theme.readThemeFile(path);
                }
                else
                {
                  absPath = path;
                  ba = d->theme.readThemeFile(info.fileName());
                }
                if(d->theme.isZipTheme())
                {
                  bmMask.loadFromData(ba);
                }
                else
                {
                  bmMask.load(absPath);
                }
                d->view->setMask(bmMask);
                */

                d->interval = lineParser.getInt("INTERVAL");
                d->interval = (d->interval == 0) ? 1000 : d->interval;

                QString temp = lineParser.getString("TEMPUNIT", "C").toUpper();
                d->tempUnit = temp.at(0).toAscii();
                d->foundKaramba = true;
            }

            if (lineParser.meter() == "THEME") {
                QString path = lineParser.getString("PATH");
                QFileInfo info(path);
                if (info.isRelative())
                    path = d->theme.path() + '/' + path;

                new Karamba(path/*, d->view, d->scene*/);
            }

            if (lineParser.meter() == "<GROUP>") {
                int offsetX = offsetStack.top().x();
                int offsetY = offsetStack.top().y();
                offsetStack.push(QPoint(offsetX + lineParser.getInt("X"),
                                        offsetY + lineParser.getInt("Y")));
            }

            if (lineParser.meter() == "</GROUP>") {
                offsetStack.pop();
            }

            if (lineParser.meter() == "CLICKAREA") {
                if (!d->globalView) {
                    d->view->setInteractive(true);
                }

                bool preview = lineParser.getBoolean("PREVIEW");
                ClickArea *tmp = new ClickArea(this, preview, x, y, w, h);
                tmp->setOnClick(lineParser.getString("ONCLICK"));


                setSensor(lineParser, (Meter*)tmp);
            }

            if (lineParser.meter() == "SENSOR=PROGRAM") {
                setSensor(lineParser, 0);
            }

            if (lineParser.meter() == "IMAGE") {
                QString file = lineParser.getString("PATH");
                QString file_roll = lineParser.getString("PATHROLL");
                int xon = lineParser.getInt("XROLL");
                int yon = lineParser.getInt("YROLL");
                QString tiptext = lineParser.getString("TOOLTIP");
                QString name = lineParser.getString("NAME");
                bool bg = lineParser.getBoolean("BACKGROUND");
                xon = (xon <= 0) ? x : xon;
                yon = (yon <= 0) ? y : yon;

                ImageLabel *tmp = new ImageLabel(this, x, y, 0, 0);
                tmp->setValue(file);

                if (!file_roll.isEmpty())
                    tmp->parseImages(file, file_roll, x, y, xon, yon);

                tmp->setBackground(bg);

                if (!name.isEmpty())
                    tmp->setObjectName(name);

                if (!tiptext.isEmpty())
                    tmp->setTooltip(tiptext);

                setSensor(lineParser, (Meter*)tmp);
            }

            if (lineParser.meter() == "DEFAULTFONT") {
                delete d->defaultTextField;
                d->defaultTextField = new TextField();

                d->defaultTextField->setColor(lineParser.getColor("COLOR",
                                             QColor("black")));
                d->defaultTextField->setBGColor(lineParser.getColor("BGCOLOR",
                                               QColor("white")));
                d->defaultTextField->setFont(lineParser.getString("FONT", "Helvetica"));
                d->defaultTextField->setFontSize(lineParser.getInt("FONTSIZE", 12));
                d->defaultTextField->setAlignment(lineParser.getString("ALIGN",
                                                 "LEFT"));
                d->defaultTextField->setFixedPitch(lineParser.getBoolean("FIXEDPITCH",
                                                  false));
                d->defaultTextField->setShadow(lineParser.getInt("SHADOW", 0));
            }

            if (lineParser.meter() == "TEXT" ||
                    lineParser.meter() == "CLICKMAP" ||
                    lineParser.meter() == "RICHTEXT" ||
                    lineParser.meter() == "INPUT") {
                TextField defTxt;

                if (d->defaultTextField)
                    defTxt = *d->defaultTextField;

                TextField* tmpText = new TextField();

                tmpText->setColor(lineParser.getColor("COLOR", defTxt.getColor()));
                tmpText->setBGColor(lineParser.getColor("BGCOLOR",
                                                        defTxt.getBGColor()));
                tmpText->setFont(lineParser.getString("FONT", defTxt.getFont()));
                tmpText->setFontSize(lineParser.getInt("FONTSIZE",
                                                       defTxt.getFontSize()));
                tmpText->setAlignment(lineParser.getString("ALIGN",
                                      defTxt.getAlignmentAsString()));
                tmpText->setFixedPitch(lineParser.getInt("FIXEDPITCH",
                                       defTxt.getFixedPitch()));

                tmpText->setShadow(lineParser.getInt("SHADOW", defTxt.getShadow()));

                // Now handle the specifics
                if (lineParser.meter() == "TEXT") {
                    TextLabel *tmp = new TextLabel(this, x, y, w, h);
                    tmp->setValue(
                        d->theme.locale()->translate(lineParser.getString("VALUE")));
                    tmp->setTextProps(tmpText);

                    QString name = lineParser.getString("NAME");
                    if (!name.isEmpty())
                        tmp->setObjectName(name);

                    setSensor(lineParser, (Meter*)tmp);
                }

                if (lineParser.meter() == "CLICKMAP") {
                    if (!d->globalView) {
                        d->view->setInteractive(true);
                    }

                    ClickMap *tmp = new ClickMap(this, x, y, w, h);
                    tmp->setTextProps(tmpText);

                    setSensor(lineParser, (Meter*)tmp);
                    // set all params
                    //clickList -> append(tmp);
                    //meterList->append( tmp );

                }

                if (lineParser.meter() == "RICHTEXT") {
                    RichTextLabel *tmp = new RichTextLabel(this, x, y, w, h);

                    bool dUl = lineParser.getBoolean("UNDERLINE");

                    tmp->setText(
                        d->theme.locale()->translate(lineParser.getString("VALUE")), dUl);
                    tmp->setTextProps(tmpText);
//          tmp->setWidth(w);
//          tmp->setHeight(h);

                    QString name = lineParser.getString("NAME");
                    if (!name.isEmpty())
                        tmp->setObjectName(name);

                    setSensor(lineParser, (Meter*)tmp);
                    //clickList->append(tmp);
                    //meterList->append(tmp);
                }

                if (lineParser.meter() == "INPUT") {
                    Input *tmp = new Input(this, x, y, w, h);

                    QString name = lineParser.getString("NAME");
                    //if (!name.isEmpty())
                    //tmp->setObjectName(name);

                    tmp->setTextProps(tmpText);
                    tmp->setValue(
                        d->theme.locale()->translate(lineParser.getString("VALUE")));

                    //meterList->append(tmp);
                    passive = false;
                }

                delete tmpText;
            }

            if (lineParser.meter() == "BAR") {
                Bar *tmp = new Bar(this, x, y, w, h);

                tmp->setImage(lineParser.getString("PATH"));
                tmp->setVertical(lineParser.getBoolean("VERTICAL"));
                tmp->setMax(lineParser.getInt("MAX", 100));
                tmp->setMin(lineParser.getInt("MIN", 0));
                tmp->setValue(lineParser.getInt("VALUE"));

                QString name = lineParser.getString("NAME");
                if (!name.isEmpty())
                    tmp->setObjectName(name);

                setSensor(lineParser, (Meter*)tmp);
                //meterList->append(tmp);
            }

            if (lineParser.meter() == "GRAPH") {
                int points = lineParser.getInt("POINTS");

                Graph *tmp = new Graph(this, x, y, w, h, points);
                tmp->setMax(lineParser.getInt("MAX", 100));
                tmp->setMin(lineParser.getInt("MIN", 0));
                QString name = lineParser.getString("NAME");
                if (!name.isEmpty())
                    tmp->setObjectName(name);

                tmp->setColor(lineParser.getColor("COLOR"));

                setSensor(lineParser, (Graph*)tmp);
                //meterList->append(tmp);
            }
        }

        if (passive && !d->managed && !d->onTop && !d->globalView) {
            KWindowSystem::setType(d->view->winId(), NET::Dock);
            KWindowSystem::setState(d->view->winId(), NET::KeepBelow);
        }

        d->theme.close();
    }
    //qDebug("parseConfig ok: %d", foundKaramba);
    if (!d->foundKaramba) {
        //  interval = initKaramba( "", 0, 0, 0, 0 );
        //   this->close(true);
        //delete this;
        return false;
    } else {
        return true;
    }
}

void Karamba::makeActive()
{
    if (!d->globalView) {
        KWindowSystem::setType(d->view->winId(), NET::Normal);
        KWindowSystem::setState(d->view->winId(), NET::Modal);
    }
}

void Karamba::makePassive()
{
    if (d->managed) {
        return;
    }

    QList<QGraphicsItem*> items = QGraphicsItemGroup::children();
    foreach (QGraphicsItem* item, items) {
        if (dynamic_cast<Input*>(item) != 0) {
            return;
        }
    }

    if (!d->globalView) {
        KWindowSystem::setType(d->view->winId(), NET::Dock);
        KWindowSystem::setState(d->view->winId(), NET::KeepBelow);
    }
}

TextField* Karamba::getDefaultTextProps()
{
    return d->defaultTextField;
}

QString Karamba::findSensorFromMap(const Sensor* sensor) const
{
    //qDebug("karamba::findSensorFromMap");
    QMap<QString, Sensor*>::ConstIterator it;
    QMap<QString, Sensor*>::ConstIterator end(d->sensorMap.end());
    for (it = d->sensorMap.begin(); it != end; ++it) {
        if (it.value() == sensor)
            return it.key();
    }
    return "";
}

Sensor *Karamba::findSensorFromList(const Meter* meter) const
{
    foreach(Sensor *sensor, d->sensorList) {
        if (sensor->hasMeter(meter))
            return sensor;
    }

    return 0;
}

void Karamba::deleteMeterFromSensors(Meter* meter)
{
    //qDebug("karamba::deleteMeterFromSensors");
    Sensor* sensor = findSensorFromList(meter);

    if (sensor) {
        sensor->deleteMeter(meter);
        if (sensor->isEmpty()) {
            QString s = findSensorFromMap(sensor);
            d->sensorMap.remove(s);
            d->sensorList.removeAll(sensor);
            delete sensor;
        }
    }
}

QString Karamba::getSensor(const Meter* meter) const
{
    Sensor* sensor = findSensorFromList(meter);

    if (sensor)
        return findSensorFromMap(sensor);

    return QString();
}

bool Karamba::removeMeter(Meter* meter)
{
    QList<QGraphicsItem*> items = QGraphicsItemGroup::children();

    if (items.contains(meter)) {
        deleteMeterFromSensors(meter);
        delete meter;
        return true;
    } else
        return false;
}

void Karamba::setSensor(const LineParser& lineParser, Meter* meter)
{
    Sensor* sensor = 0;

    deleteMeterFromSensors(meter);

    QString sens = lineParser.getString("SENSOR").toUpper();

    if (sens == "CPU") {
        QString cpuNbr = lineParser.getString("CPU");
        sensor = d->sensorMap["CPU"+cpuNbr];

        if (sensor == 0) {
            int interval = lineParser.getInt("INTERVAL");
            interval = (interval == 0) ? 1000 : interval;
            sensor = (d->sensorMap["CPU" + cpuNbr] = new CPUSensor(cpuNbr, interval));
            d->sensorList.append(sensor);
        }

        SensorParams *sp = new SensorParams(meter);
        sp->addParam("FORMAT",
                     d->theme.locale()->translate(lineParser.getString("FORMAT")));

        sp->addParam("DECIMALS", lineParser.getString("DECIMALS"));

        sensor->addMeter(sp);
        sensor->setMaxValue(sp);
    }

    if (sens == "MEMORY") {
        sensor = d->sensorMap["MEMORY"];
        if (sensor == 0) {
            int interval = lineParser.getInt("INTERVAL");
            interval = (interval == 0) ? 3000 : interval;
            sensor = (d->sensorMap["MEMORY"] = new MemSensor(interval));
            d->sensorList.append(sensor);
        }

        SensorParams *sp = new SensorParams(meter);
        sp->addParam("FORMAT",
                     d->theme.locale()->translate(lineParser.getString("FORMAT")));

        sensor->addMeter(sp);
        sensor->setMaxValue(sp);
    }

    if (sens == "DISK") {
        sensor = d->sensorMap["DISK"];

        if (sensor == 0) {
            int interval = lineParser.getInt("INTERVAL");
            interval = (interval == 0) ? 5000 : interval;
            sensor = (d->sensorMap["DISK"] = new DiskSensor(interval));
            d->sensorList.append(sensor);
        }
        // meter->setMax( ((DiskSensor*)sensor)->getTotalSpace(mntPt)/1024 );
        SensorParams *sp = new SensorParams(meter);
        QString mntPt = lineParser.getString("MOUNTPOINT");
        if (mntPt.isEmpty()) {
            mntPt = "/";
        }
        // remove any trailing '/' from mount points in the .theme config, our
        // mntMap doesn't like trailing '/'s for matching in DiskSensor
        if (mntPt.length() > 1 && mntPt.endsWith('/')) {
            mntPt.remove(mntPt.length() - 1, 1);
        }
        sp->addParam("MOUNTPOINT", mntPt);
        sp->addParam("FORMAT",
                     d->theme.locale()->translate(lineParser.getString("FORMAT")));
        sensor->addMeter(sp);
        sensor->setMaxValue(sp);
    }

    if (sens == "NETWORK") {
        int interval = lineParser.getInt("INTERVAL");
        interval = (interval == 0) ? 2000 : interval;
        QString device = lineParser.getString("DEVICE");
        sensor = d->sensorMap["NETWORK"+device];

        if (sensor == 0) {
            sensor = (d->sensorMap["NETWORK"+device] =
                          new NetworkSensor(device, interval));
            d->sensorList.append(sensor);
        }

        SensorParams *sp = new SensorParams(meter);
        sp->addParam("FORMAT",
                     d->theme.locale()->translate(lineParser.getString("FORMAT")));

        sp->addParam("DECIMALS", lineParser.getString("DECIMALS"));
        sensor->addMeter(sp);
    }

    if (sens == "UPTIME") {
        sensor = d->sensorMap[