karambainterface.cpp

Go to the documentation of this file.

/*
 * 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 "karambainterface.h"
#include "karambainterface.moc"

#include "karamba.h"
#include "karambaapp.h"
#include "lineparser.h"
#include "showdesktop.h"
#include "karambamanager.h"

#include <QGraphicsScene>
#include <QNetworkInterface>
#include <QTimer>
#include <QDomDocument>
#include <QFileInfo>
#include <QDesktopWidget>
#include <QGraphicsProxyWidget>
#include <QGraphicsView>

#include <KMenu>
#include <KDebug>
#include <KConfigGroup>
#include <KService>
#include <KServiceGroup>
#include <KLocale>
#include <KMessageBox>
#include <KCmdLineArgs>
#include <KAboutData>
#include <KIconLoader>

class KarambaInterface::Private
{
    public:
        Karamba *karamba;

        Kross::Action *action;

        Private(Karamba *k) : karamba(k), action(0) {}
};

KarambaInterface::KarambaInterface(Karamba *k)
    : QObject()
    , d(new Private(k))
{
    setObjectName( QLatin1String("karamba" ));
}

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

void KarambaInterface::startInterpreter()
{
    d->action->trigger();
    if( d->action->hadError() ) {
        const QString err = QString("%1\n\n%2").arg(d->action->errorMessage()).arg(d->action->errorTrace());
        d->karamba->emitError(err);
    }
}

bool KarambaInterface::initInterpreter()
{
    const ThemeFile &theme = d->karamba->theme();

    // Get the theme path
    QDir scriptDir;
    if (theme.isZipTheme()) {
        scriptDir = theme.extractArchive();
    } else {
        scriptDir = theme.path();
    }

    QString interpreter = Kross::Manager::self().interpreternameForFile(theme.scriptModule());
    if (interpreter.isEmpty()) {
        KMessageBox::sorry(0, i18n(
                "SuperKaramba cannot continue to run this theme."
                "One or more of the required components of the Kross scripting architecture is not installed. "
                "Please consult this theme's documentation and install the necessary Kross components."),
                i18n("Please install additional Kross components"));
        return false;
    }

    // Set up Interpreter
    QFileInfo fi(scriptDir, theme.scriptModule());
    if (fi.exists() && !interpreter.isEmpty()) {
        QString scriptFile = fi.absoluteFilePath();

        // the Kross::Action is our script container.
        d->action = new Kross::Action(this, scriptFile, fi.dir());

        // set the name of the interpreter that should be used for the
        // scripting code. This could be e.g. 'python' or 'ruby'.
        d->action->setInterpreter(interpreter);

        // publish this instance, so that scripts are able to access it with e.g.
        // import karamba or require 'karamba' depending on the chosen scripting
        // language.
        d->action->addObject(this, "karamba", Kross::ChildrenInterface::AutoConnectSignals);

        // If the karamba QObject has a child named "PlasmaApplet" publish that child
        // as well. This is used in the SuperKaramba Plasma Applet skapplet to pass
        // an own reference to an SuperKarambaAppletAdaptor instance to the script.
        if( QObject* appletadaptor = d->karamba->findChild<QObject*>("PlasmaApplet") ) {
            d->action->addObject(appletadaptor);
        }

        // this is for backward-compatibility and needed cause the prev python
        // implementation does provide the current path within the sys.path and
        // some scripts are using it to do custom stuff. So, while the preferred
        // way is now to use karamba.getThemePath() we still maintain support to
        // the old behaviour.
        if (interpreter == "python") {
            d->action->setCode(QString(
                "import karamba, sys\n"
                "sys.path.insert(0, karamba.getThemePath())\n"
                "sys.path.insert(0, '')\n"
                "execfile(\"%1\", globals(), locals())\n"
            ).arg(scriptFile).toLatin1());
        } else {
            d->action->setFile(scriptFile);
        }

        kDebug() << "Using " << interpreter << " script: " << scriptFile ;

        return true;
    }

    return false;
}

// Testing functions -----------------------

bool KarambaInterface::checkKaramba(const Karamba *k) const
{
    if (!k) {
        kWarning() << "Widget pointer was 0" ;
        return false;
    }

    if (!KarambaManager::self()->checkKaramba(k)) {
        kWarning() << "Widget " << (long)k << " invalid" ;
        return false;
    }

    return true;
}

bool KarambaInterface::checkMeter(const Karamba *k, const Meter *m, const QString &type) const
{
    if (!m) {
        kWarning() << "Meter pointer was 0";
        return false;
    }

    if (!k->hasMeter(m)) {
        kWarning() << "Widget does not have meter" << (long)m;
        return false;
    }

    if (!m->inherits(type.toAscii().data())) {
        kWarning() << "Meter is not of type" << type;
        return false;
    }

    return true;
}

bool KarambaInterface::checkKarambaAndMeter(const Karamba *k, const Meter *m, const QString &type)
    const
{
    return checkKaramba(k) && checkMeter(k, m, type);
}

QVariantList KarambaInterface::getMeterMinMax(const Karamba *k, const Meter *m, const QString &type)
    const
{
    if (!checkKarambaAndMeter(k, m, type)) {
        return QVariantList();
    }

    QVariantList ret;
    ret << m->getMax();
    ret << m->getMin();
    return ret;
}

QVariantList KarambaInterface::getMeterSize(const Karamba *k, const Meter *m, const QString &type)
    const
{
    if (!checkKarambaAndMeter(k, m, type)) {
        return QVariantList();
    }

    QVariantList list;
    list << QVariant::fromValue(m->getWidth());
    list << QVariant::fromValue(m->getHeight());
    return list;
}

QVariantList KarambaInterface::getMeterPos(const Karamba *k, const Meter *m, const QString &type)
    const
{
    if (!checkKarambaAndMeter(k, m, type)) {
        return QVariantList();
    }

    QVariantList ret;
    ret << QVariant::fromValue(m->getX());
    ret << QVariant::fromValue(m->getY());
    return ret;
}

QString KarambaInterface::getMeterSensor(const Karamba *k, const Meter *m, const QString &type)
    const
{
    if (!checkKarambaAndMeter(k, m, type)) {
        return QString();
    }

    return k->getSensor(m);

}

int KarambaInterface::getMeterValue(const Karamba *k, const Meter *m, const QString &type) const
{
    if (!checkKarambaAndMeter(k, m, type)) {
        return 0;
    }

    return m->getValue();
}

QObject* KarambaInterface::getThemeMeter(const Karamba *k, const QString &meter, const QString
        &type) const
{
    if (!checkKaramba(k)) {
        return 0;
    }

    QGraphicsItem *item;
    QList<QGraphicsItem*> list = ((QGraphicsItemGroup*)k)->children();
    foreach(item, list) {
        Meter *m = (Meter*)item;
        if (m->objectName() == meter) {
            if (checkMeter(k, m, type)) {
                return m;
            }
        }
    }

    return 0;
}

bool KarambaInterface::hideMeter(const Karamba *k, Meter *m, const QString &type) const
{
    if (!checkKarambaAndMeter(k, m, type)) {
        return false;
    }

    m->hide();

    return true;
}

bool KarambaInterface::moveMeter(const Karamba *k, Meter *m, const QString &type, int x, int y)
    const
{
    if (!checkKarambaAndMeter(k, m, type)) {
        return false;
    }

    k->moveMeter(m, x, y);

    return true;
}

bool KarambaInterface::resizeMeter(const Karamba *k, Meter *m, const QString &type, int width, int
        height) const
{
    if (!checkKarambaAndMeter(k, m, type)) {
        return false;
    }

    m->setSize(m->getX(), m->getY(), width, height);

    return true;
}

bool KarambaInterface::setMeterMinMax(const Karamba *k, Meter *m, const QString &type, int min, int max)
    const
{
    if (!checkKarambaAndMeter(k, m, type)) {
        return false;
    }

    m->setMin(min);
    m->setMax(max);

    return true;
}

bool KarambaInterface::setMeterSensor(Karamba *k, Meter *m, const QString &type,
        const QString &sensor) const
{
    if (!checkKarambaAndMeter(k, m, type)) {
        return false;
    }

    k->setSensor(LineParser(sensor), m);

    return true;
}

QObject* KarambaInterface::setMeterValue(const Karamba *k, Meter *m, const QString &type, int value)
    const
{
    if (!checkKarambaAndMeter(k, m, type)) {
        return 0;
    }

    m->setValue(value);

    return m;
}

bool KarambaInterface::showMeter(const Karamba *k, Meter *m, const QString &type) const
{
    if (!checkKarambaAndMeter(k, m, type)) {
        return false;
    }

    m->show();

    return true;
}

bool KarambaInterface::setMeterColor(const Karamba *k, Meter *m, const QString &type, int red, int
        green, int blue, int alpha) const
{
    if (!checkKarambaAndMeter(k, m, type)) {
        return false;
    }

    m->setColor(QColor(red, green, blue, alpha));

    return true;
}

QVariantList KarambaInterface::getMeterColor(const Karamba *k, const Meter *m, const QString &type)
    const
{
    if (!checkKarambaAndMeter(k, m, type)) {
        return QVariantList();
    }

    QColor color = m->getColor();

    QVariantList ret;
    ret << color.red();
    ret << color.green();
    ret << color.blue();
    ret << color.alpha();

    return ret;
}

QString KarambaInterface::getMeterStringValue(const Karamba *k, const Meter *m, const QString &type)
    const
{
    if (!checkKarambaAndMeter(k, m, type)) {
        return QString();
    }

    return m->getStringValue();
}

QObject* KarambaInterface::setMeterStringValue(const Karamba *k, Meter *m, const QString &type,
        const QString &value) const
{
    if (!checkKarambaAndMeter(k, m, type)) {
        return 0;
    }

    m->setValue(value);

    return m;
}


// Calls to scripts ----------------------
void KarambaInterface::callInitWidget(Karamba *k)
{
    emit initWidget(k);
}

void KarambaInterface::callWidgetUpdated(Karamba *k)
{
    emit widgetUpdated(k);
}

void KarambaInterface::callWidgetClosed(Karamba *k)
{
    emit widgetClosed(k);
}

void KarambaInterface::callMenuOptionChanged(Karamba *k, const QString &key, bool value)
{
    emit menuOptionChanged(k, key, value);
}

void KarambaInterface::callMenuItemClicked(Karamba* k, KMenu* menu, QAction *id)
{
    emit menuItemClicked(k, menu, id);
}

void KarambaInterface::callActiveTaskChanged(Karamba *k, Task* t)
{
    emit activeTaskChanged(k, t);
}

void KarambaInterface::callTaskAdded(Karamba *k, Task *t)
{
    emit taskAdded(k, t);
}

void KarambaInterface::callTaskRemoved(Karamba *k, Task *t)
{
    emit taskRemoved(k, t);
}

void KarambaInterface::callStartupAdded(Karamba *k, Startup *t)
{
    emit startupAdded(k, t);
}

void KarambaInterface::callStartupRemoved(Karamba *k, Startup *t)
{
    emit startupRemoved(k, t);
}

void KarambaInterface::callCommandFinished(Karamba *k, int pid)
{
    emit commandFinished(k, pid);
}

void KarambaInterface::callCommandOutput(Karamba *k, int pid, char* buffer)
{
    emit commandOutput(k, pid, QString(buffer));
}

void KarambaInterface::callItemDropped(Karamba *k, const QString &text, int x, int y)
{
    emit itemDropped(k, text, x, y);
}

void KarambaInterface::callMeterClicked(Karamba *k, Meter *m, int button)
{
    emit meterClicked(k, m, button);
}

void KarambaInterface::callMeterClicked(Karamba *k, const QString &str, int button)
{
    emit meterClicked(k, str, button);
}

void KarambaInterface::callWidgetClicked(Karamba *k, int x, int y, int button)
{
    emit widgetClicked(k, x, y, button);
}

void KarambaInterface::callDesktopChanged(Karamba *k, int desktop)
{
    emit desktopChanged(k, desktop);
}

void KarambaInterface::callWidgetMouseMoved(Karamba *k, int x, int y, int button)
{
    emit widgetMouseMoved(k, x, y, button);
}

void KarambaInterface::callKeyPressed(Karamba *k, Meter *meter, const QString &key)
{
    emit keyPressed(k, meter, key);
}

void KarambaInterface::callThemeNotify(Karamba *k, const QString &sender, const QString &data)
{
    emit themeNotify(k, sender, data);
}

void KarambaInterface::callWallpaperChanged(Karamba *k, int desktop)
{
    emit wallpaperChanged(k, desktop);
}


// Calls from scripts --------------------

QObject* KarambaInterface::createBar(Karamba* k, int x, int y, int w, int h, const QString &path)
    const
{
    if (!checkKaramba(k)) {
        return NULL;
    }

    Bar *tmp = new Bar(k, x, y, w, h);
    tmp->setImage(path);
    tmp->setValue(50);
    k->addToGroup(tmp);

    return tmp;
}

bool KarambaInterface::deleteBar(Karamba *k, Bar *bar) const
{
    if (!checkKarambaAndMeter(k, bar, "Bar")) {
        return false;
    }

    return k->removeMeter(bar);
}

bool KarambaInterface::setBarMinMax(const Karamba *k, Bar *bar, int min, int max) const
{
    return setMeterMinMax(k, bar, "Bar", min, max);
}

QVariantList KarambaInterface::getBarMinMax(const Karamba *k, const Bar *bar) const
{
    return getMeterMinMax(k, bar, "Bar");
}

bool KarambaInterface::moveBar(const Karamba *k, Bar *bar, int x, int y) const
{
    return moveMeter(k, bar, "Bar", x, y);
}

QVariantList KarambaInterface::getBarPos(const Karamba *k, const Bar *bar) const
{
    return getMeterPos(k, bar, "Bar");
}

bool KarambaInterface::setBarSensor(Karamba *k, Bar *bar, const QString &sensor) const
{
    return setMeterSensor(k, bar, "Bar", sensor);
}

QString KarambaInterface::getBarSensor(const Karamba *k, const Bar *bar) const
{
    return getMeterSensor(k, bar, "Bar");
}

bool KarambaInterface::resizeBar(const Karamba *k, Bar *bar, int width, int height) const
{
    return resizeMeter(k, bar, "Bar", width, height);
}

QVariantList KarambaInterface::getBarSize(const Karamba *k, const Bar *bar) const
{
    return getMeterSize(k, bar, "Bar");
}

QObject* KarambaInterface::setBarValue(const Karamba *k, Bar *bar, int value) const
{
    return setMeterValue(k, bar, "Bar", value);
}

int KarambaInterface::getBarValue(const Karamba *k, const Bar *bar) const
{
    return getMeterValue(k, bar, "Bar");
}

QObject* KarambaInterface::getThemeBar(const Karamba *k, const QString &meter) const
{
    return getThemeMeter(k, meter, "Bar");
}

bool KarambaInterface::hideBar(const Karamba *k, Bar *bar) const
{
    return hideMeter(k, bar, "Bar");
}

bool KarambaInterface::showBar(const Karamba *k, Bar *bar) const
{
    return showMeter(k, bar, "Bar");
}

bool KarambaInterface::setBarVertical(const Karamba *k, Bar *bar, bool vert) const
{
    if (!checkKarambaAndMeter(k, bar, "Bar")) {
        return false;
    }

    bar->setVertical(vert);
    return true;
}

bool KarambaInterface::getBarVertical(const Karamba *k, const Bar *bar) const
{
    if (!checkKarambaAndMeter(k, bar, "Bar")) {
        return false;
    }

    return bar->getVertical();
}

bool KarambaInterface::setBarImage(const Karamba *k, Bar *bar, const QString &image) const
{
    if (!checkKarambaAndMeter(k, bar, "Bar")) {
        return false;
    }

    return bar->setImage(image);
}

QString KarambaInterface::getBarImage(const Karamba *k, const Bar *bar) const
{
    if (!checkKarambaAndMeter(k, bar, "Bar")) {
        return QString();
    }

    return bar->getImage();
}




QObject* KarambaInterface::createGraph(Karamba* k, int x, int y, int w, int h, int points) const
{
    if (!checkKaramba(k)) {
        return NULL;
    }

    Graph *tmp = new Graph(k, x, y, w, h, points);
    k->addToGroup(tmp);

    return tmp;
}

bool KarambaInterface::deleteGraph(Karamba *k, Graph *graph) const
{
    if (!checkKarambaAndMeter(k, graph, "Graph")) {
        return false;
    }

    return k->removeMeter(graph);
}

bool KarambaInterface::setGraphMinMax(const Karamba *k, Graph *graph, int min, int max) const
{
    return setMeterMinMax(k, graph, "Graph", min, max);
}

QVariantList KarambaInterface::getGraphMinMax(const Karamba *k, const Graph *graph) const
{
    return getMeterMinMax(k, graph, "Graph");
}

bool KarambaInterface::moveGraph(const Karamba *k, Graph *graph, int x, int y) const
{
    return moveMeter(k, graph, "Graph", x, y);
}

QVariantList KarambaInterface::getGraphPos(const Karamba *k, const Graph *graph) const
{
    return getMeterPos(k, graph, "Graph");
}

bool KarambaInterface::setGraphSensor(Karamba *k, Graph *graph, const QString &sensor) const
{
    return setMeterSensor(k, graph, "Graph", sensor);
}

QString KarambaInterface::getGraphSensor(const Karamba *k, const Graph *graph) const
{
    return getMeterSensor(k, graph, "Graph");
}

bool KarambaInterface::resizeGraph(const Karamba *k, Graph *graph, int width, int height) const
{
    return resizeMeter(k, graph, "Graph", width, height);
}

QVariantList KarambaInterface::getGraphSize(const Karamba *k, const Graph *graph) const
{
    return getMeterSize(k, graph, "Graph");
}

QObject* KarambaInterface::setGraphValue(const Karamba *k, Graph *graph, int value) const
{
    return setMeterValue(k, graph, "Graph", value);
}

int KarambaInterface::getGraphValue(const Karamba *k, const Graph *graph) const
{
    return getMeterValue(k, graph, "Graph");
}

QObject* KarambaInterface::getThemeGraph(const Karamba *k, const QString &meter) const
{
    return getThemeMeter(k, meter, "Graph");
}

bool KarambaInterface::hideGraph(const Karamba *k, Graph *graph) const
{
    return hideMeter(k, graph, "Graph");
}

bool KarambaInterface::showGraph(const Karamba *k, Graph *graph) const
{
    return showMeter(k, graph, "Graph");
}

bool KarambaInterface::setGraphColor(const Karamba *k, Graph *graph, int red, int green, int blue, int alpha)
    const
{
    return setMeterColor(k, graph, "Graph", red, green, blue, alpha);
}

QVariantList KarambaInterface::getGraphColor(const Karamba *k, const Graph *graph) const
{
    return getMeterColor(k, graph, "Graph");
}

bool KarambaInterface::setGraphFillColor(const Karamba *k, Graph *graph, int red, int green, int blue, int alpha)
    const
{
  if (!checkKarambaAndMeter(k, graph, "Graph")) {
    return false;
  }

  graph->setFillColor(QColor(red, green, blue, alpha));
  return true;
}

QVariantList KarambaInterface::getGraphFillColor(const Karamba *k, const Graph *graph) const
{
     if (!checkKarambaAndMeter(k, graph, "Graph")) {
        return QVariantList();
      }

      QColor color = graph->getFillColor();

      QVariantList ret;
      ret << color.red();
      ret << color.green();
      ret << color.blue();
      ret << color.alpha();

      return ret;
}

QString KarambaInterface::getGraphScroll(const Karamba *k, const Graph *graph) const
{
  if (!checkKarambaAndMeter(k, graph, "Graph")) {
    return QString();
  }

  return graph->getScrollDirection();
}

bool KarambaInterface::setGraphScroll(const Karamba *k, Graph *graph, const QString &scroll) const
{
  if (!checkKarambaAndMeter(k, graph, "Graph")) {
    return false;
  }

  graph->setScrollDirection(scroll);
  return true;
}

QString KarambaInterface::getGraphPlot(const Karamba *k, const Graph *graph) const
{
  if (!checkKarambaAndMeter(k, graph, "Graph")) {
    return QString();
  }

  return graph->getPlotDirection();
}

bool KarambaInterface::setGraphPlot(const Karamba *k, Graph *graph, const QString &plot) const
{
  if (!checkKarambaAndMeter(k, graph, "Graph")) {
    return false;
  }

  graph->setPlotDirection(plot);
  return true;
}

bool KarambaInterface::getGraphShouldFill(const Karamba *k, const Graph *graph) const
{
  if (!checkKarambaAndMeter(k, graph, "Graph")) {
    return false;
  }

  return graph->shouldFill();
}

bool KarambaInterface::setGraphShouldFill(const Karamba *k, Graph *graph, bool shouldFill) const
{
  if (!checkKarambaAndMeter(k, graph, "Graph")) {
    return false;
  }

  graph->shouldFill(shouldFill);
  return true;
}

QObject* KarambaInterface::createImage(Karamba* k, int x, int y, const QString &image) const
{
    if (!checkKaramba(k)) {
        return NULL;
    }

    ImageLabel *tmp = new ImageLabel(k, x, y, 0, 0);
    tmp->setValue(image);

    k->setSensor(LineParser(image), tmp);

    k->addToGroup(tmp);

    return tmp;
}

QObject* KarambaInterface::createEmptyImage(Karamba* k, int x, int y, int w, int h) const
{
    if (!checkKaramba(k)) {
        return NULL;
    }

    ImageLabel *tmp = new ImageLabel(k, x, y, w, h);

    k->addToGroup(tmp);

    return tmp;
}

bool KarambaInterface::deleteImage(Karamba *k, ImageLabel *image) const
{
    if (!checkKarambaAndMeter(k, image, "ImageLabel")) {
        return false;
    }

    return k->removeMeter(image);
}

bool KarambaInterface::moveImage(Karamba *k, ImageLabel *image, int x, int y) const
{
    return moveMeter(k, image, "ImageLabel", x, y);
}

QVariantList KarambaInterface::getImagePos(const Karamba *k, const ImageLabel *image) const
{
    return getMeterPos(k, image, "ImageLabel");
}

bool KarambaInterface::setImageSensor(Karamba *k, ImageLabel *image,
        const QString &sensor) const
{
    return setMeterSensor(k, image, "ImageLabel", sensor);
}

QString KarambaInterface::getImageSensor(const Karamba *k, const ImageLabel *image) const
{
    return getMeterSensor(k, image, "ImageLabel");
}

bool KarambaInterface::resizeImage(const Karamba *k, ImageLabel *image, int width, int height) const
{
    if (!checkKarambaAndMeter(k, image, "ImageLabel")) {
        return false;
    }

    k->scaleImageLabel(image, width, height);

    return true;
}

QVariantList KarambaInterface::getImageSize(const Karamba *k, const ImageLabel *image) const
{
    return getMeterSize(k, image, "ImageLabel");
}

QObject* KarambaInterface::setImagePath(const Karamba *k, ImageLabel *image, const QString &path)
    const
{
    return setMeterStringValue(k, image, "ImageLabel", path);
}

QString KarambaInterface::getImagePath(const Karamba *k, const ImageLabel *image) const
{
    return getMeterStringValue(k, image, "ImageLabel");
}

QObject* KarambaInterface::getThemeImage(const Karamba *k, const QString &meter) const
{
    return getThemeMeter(k, meter, "ImageLabel");
}

bool KarambaInterface::hideImage(const Karamba *k, ImageLabel *image) const
{
    return hideMeter(k, image, "ImageLabel");
}

bool KarambaInterface::showImage(const Karamba *k, ImageLabel *image) const
{
    return showMeter(k, image, "ImageLabel");
}

bool KarambaInterface::addImageTooltip(const Karamba *k, ImageLabel *image, const QString &text)
    const
{
    if (!checkKarambaAndMeter(k, image, "ImageLabel")) {
        return false;
    }

    image->setTooltip(text);

    return true;
}

bool KarambaInterface::changeImageChannelIntensity(const Karamba *k, ImageLabel *image, double
        ratio, const QString &channel, int ms) const
{
    if (!checkKarambaAndMeter(k, image, "ImageLabel")) {
        return false;
    }

    image->channelIntensity(ratio, channel, ms);

    return true;
}

bool KarambaInterface::changeImageIntensity(const Karamba *k, ImageLabel *image, double ratio, int
        ms) const
{
    if (!checkKarambaAndMeter(k, image, "ImageLabel")) {
        return false;
    }

    image->intensity(ratio, ms);

    return true;
}

bool KarambaInterface::changeImageToGray(const Karamba *k, ImageLabel *image, int ms) const
{
    if (!checkKarambaAndMeter(k, image, "ImageLabel")) {
        return false;
    }

    image->toGray(ms);

    return true;
}

bool KarambaInterface::changeImageAlpha(const Karamba *k, ImageLabel *image, int a, int r, int g, int b, int ms) const
{
    if (!checkKarambaAndMeter(k, image, "ImageLabel")) {
        return false;
    }

    image->toAlpha(QColor(r, g, b), a, ms);

    return true;
}

QObject* KarambaInterface::createBackgroundImage(Karamba *k, int x, int y, const QString &imagePath)
    const
{
    if (!checkKaramba(k)) {
        return 0;
    }

    ImageLabel *tmp = new ImageLabel(k, x, y, 0, 0);
    tmp->setValue(imagePath);
    tmp->setBackground(true);
    tmp->setZValue(-1);

    k->setSensor(LineParser(imagePath), tmp);

    k->addToGroup(tmp);

    return tmp;
}

QObject* KarambaInterface::createTaskIcon(Karamba *k, int x, int y, int ctask) const
{
    if (!checkKaramba(k)) {
        return NULL;
    }

    QList<Task::TaskPtr> tasks = TaskManager::self()->tasks().values();
    Task::TaskPtr task;
    Task::TaskPtr currTask;
    foreach(task, tasks) {
        if ((long)task.data() == (long)ctask) {
            //task found
            currTask = task;
            break;
        }
    }

    if (currTask.isNull()) {
        return 0;
    }

    //retrieve the QPixmap that represents this image
    QPixmap iconPixmap = KWindowSystem::icon(currTask->window());

    ImageLabel *tmp = new ImageLabel(k, x, y, 0, 0);
    tmp->setValue(iconPixmap);

    k->addToGroup(tmp);

    return tmp;
}

int KarambaInterface::getImageHeight(const Karamba *k, const ImageLabel *image) const
{
    if (!checkKarambaAndMeter(k, image, "ImageLabel")) {
        return -1;
    }

    return image->getHeight();
}

int KarambaInterface::getImageWidth(const Karamba *k, const ImageLabel *image) const
{
    if (!checkKarambaAndMeter(k, image, "ImageLabel")) {
        return -1;
    }

    return image->getWidth();
}

bool KarambaInterface::removeImageEffects(const Karamba *k, ImageLabel *image) const
{
    if (!checkKarambaAndMeter(k, image, "ImageLabel")) {
        return false;
    }

    image->removeEffects();

    return true;
}

bool KarambaInterface::removeImageTransformations(const Karamba *k, ImageLabel *image) const
{
    if (!checkKarambaAndMeter(k, image, "ImageLabel")) {
        return false;
    }

    image->removeImageTransformations();

    return true;
}

bool KarambaInterface::resizeImageSmooth(Karamba *k, ImageLabel *image, int width, int height)
    const
{
    if (!checkKarambaAndMeter(k, image, "ImageLabel")) {
        return false;
    }

    k->scaleImageLabel(image, width, height);

    return true;
}

bool KarambaInterface::rotateImage(const Karamba *k, ImageLabel *image, int deg) const
{
    if (!checkKarambaAndMeter(k, image, "ImageLabel")) {
        return false;
    }

    image->rotate(deg);

    return true;
}

bool KarambaInterface::setPixel(Karamba *k, ImageLabel *image, int x, int y, int r, int g, int b, int a)
{
    if (!checkKarambaAndMeter(k, image, "ImageLabel")) {
        return false;
    }

    image->setPixel(QPoint(x, y), QColor(r,g,b,a));

    return true;
}

bool KarambaInterface::changeImageAnimation(Karamba *k, ImageLabel *image, bool enable) const
{
    if (!checkKarambaAndMeter(k, image, "ImageLabel")) {
        return false;
    }

    return image->enableAnimation(enable);
}

bool KarambaInterface::getImageAnimation(Karamba *k, ImageLabel *image) const
{
    if (!checkKarambaAndMeter(k, image, "ImageLabel")) {
        return false;
    }

    return image->animationEnabled();
}

bool KarambaInterface::setImageElement(Karamba* k, ImageLabel *image, const QString &element) const
{
    if (!checkKarambaAndMeter(k, image, "ImageLabel")) {
        return false;
    }

    return image->drawElement(element);
}

bool KarambaInterface::setImageElementAll(Karamba* k, ImageLabel *image) const
{
    if (!checkKarambaAndMeter(k, image, "ImageLabel")) {
        return false;
    }

    return image->drawElement(QString());
}

QString KarambaInterface::getImageElement(Karamba *k, ImageLabel *image) const
{
    if (!checkKarambaAndMeter(k, image, "ImageLabel")) {
        return QString();
    }

    return image->elementDrawn();
}






bool KarambaInterface::addMenuConfigOption(Karamba *k, const QString &key, const QString &name)
    const
{
    if (!checkKaramba(k)) {
        return false;
    }

    k->addMenuConfigOption(key, name);

    return true;
}

QVariant KarambaInterface::readConfigEntry(const Karamba *k, const QString &key) const
{
    if (!checkKaramba(k)) {
        return QString();
    }

    QString type = k->getConfig()->group("types").readEntry(key, QString());
    QVariant def(QVariant::nameToType(type.toAscii().data()));

    return k->getConfig()->group("theme").readEntry(key, def);
}

bool KarambaInterface::readMenuConfigOption(const Karamba *k, const QString &key) const
{
    if (!checkKaramba(k)) {
        return false;
    }

    return k->readMenuConfigOption(key);
}

bool KarambaInterface::setMenuConfigOption(Karamba *k, const QString &key, bool value) const
{
    if (!checkKaramba(k)) {
        return false;
    }

    return k->setMenuConfigOption(key, value);
}

bool KarambaInterface::writeConfigEntry(const Karamba *k, const QString &key, const QVariant &value)
    const
{
    if (!checkKaramba(k)) {
        return false;
    }

    k->getConfig()->group("theme").writeEntry(key, value);

    k->getConfig()->group("types").writeEntry(key, QString(QVariant::typeToName(value.type())));

    return true;
}






QObject* KarambaInterface::createInputBox(Karamba* k, int x, int y, int w, int h, const QString
        &text) const
{
    if (!checkKaramba(k)) {
        return NULL;
    }

    Input *tmp = new Input(k, x, y, w, h);
    tmp->setValue(text);
    tmp->setTextProps(k->getDefaultTextProps());

    k->addToGroup(tmp);

    k->makeActive();

    return tmp;
}

bool KarambaInterface::deleteInputBox(Karamba *k, Input *input) const
{
    if (!checkKarambaAndMeter(k, input, "Input")) {
        return false;
    }

    k->makePassive();

    return k->removeMeter(input);
}

bool KarambaInterface::moveInputBox(Karamba *k, Input *input, int x, int y) const
{
    return moveMeter(k, input, "Input", x, y);
}

QVariantList KarambaInterface::getInputBoxPos(const Karamba *k, const Input *input) const
{
    return getMeterPos(k, input, "Input");
}

bool KarambaInterface::resizeInputBox(const Karamba *k, Input *input, int width, int height) const
{
    return resizeMeter(k, input, "Input", width, height);
}

QVariantList KarambaInterface::getInputBoxSize(const Karamba *k, const Input *input) const
{
    return getMeterSize(k, input, "Input");
}

QObject* KarambaInterface::changeInputBox(const Karamba *k, Input *input, const QString &text) const
{
    return setMeterStringValue(k, input, "Input", text);
}

QString KarambaInterface::getInputBoxValue(const Karamba *k, const Input *input) const
{
    return getMeterStringValue(k, input, "Input");
}

QObject* KarambaInterface::getThemeInputBox(const Karamba *k, const QString &meter) const
{
    return getThemeMeter(k, meter, "Input");
}

bool KarambaInterface::hideInputBox(const Karamba *k, Input *input) const
{
    return hideMeter(k, input, "Input");
}

bool KarambaInterface::showInputBox(const Karamba *k, Input *input) const
{
    return showMeter(k, input, "Input");
}

bool KarambaInterface::changeInputBoxFont(const Karamba *k, Input *input, const QString &font) const
{
    if (!checkKarambaAndMeter(k, input, "Input")) {
        return false;
    }

    input->setFont(font);

    return true;
}

QString KarambaInterface::getInputBoxFont(const Karamba *k, const Input *input) const
{
    if (!checkKarambaAndMeter(k, input, "Input")) {
        return QString();
    }

    return input->getFont();
}

bool KarambaInterface::changeInputBoxFontColor(const Karamba *k, Input *input, int red, int green,
        int blue, int alpha) const
{
    if (!checkKarambaAndMeter(k, input, "Input")) {
        return false;
    }

    input->setFontColor(QColor(red, green, blue, alpha));
    return true;
}

QVariantList KarambaInterface::getInputBoxFontColor(const Karamba *k, const Input *input) const
{
    if (!checkKarambaAndMeter(k, input, "Input")) {
        return QVariantList();
    }

    QVariantList ret;

    QColor color = input->getFontColor();
    ret << color.red();
    ret << color.green();
    ret << color.blue();
    ret << color.alpha();

    return ret;
}

bool KarambaInterface::changeInputBoxSelectionColor(const Karamba *k, Input *input, int red,
        int green, int blue, int alpha) const
{
    if (!checkKarambaAndMeter(k, input, "Input")) {
        return false;
    }

    input->setSelectionColor(QColor(red, green, blue, alpha));
    return true;
}

QVariantList KarambaInterface::getInputBoxSelectionColor(const Karamba *k, const Input *input) const
{
    if (!checkKarambaAndMeter(k, input, "Input")) {
        return QVariantList();
    }

    QVariantList ret;

    QColor color = input->getSelectionColor();
    ret << color.red();
    ret << color.green();
    ret << color.blue();
    ret << color.alpha();

    return ret;
}

bool KarambaInterface::changeInputBoxBackgroundColor(const Karamba *k, Input *input, int red, int
        green, int blue, int alpha) const
{
    if (!checkKarambaAndMeter(k, input, "Input")) {
        return false;
    }

    input->setBGColor(QColor(red, green, blue, alpha));

    return true;
}

QVariantList KarambaInterface::getInputBoxBackgroundColor(const Karamba *k, const Input *input)
    const
{
    if (!checkKarambaAndMeter(k, input, "Input")) {
        return QVariantList();
    }

    QVariantList ret;

    QColor color = input->getBGColor();
    ret << color.red();
    ret << color.green();
    ret << color.blue();
    ret << color.alpha();

    return ret;
}

bool KarambaInterface::changeInputBoxFrameColor(const Karamba *k, Input *input, int red, int green,
        int blue, int alpha) const
{
    if (!checkKarambaAndMeter(k, input, "Input"))
        return false;

    input->setColor(QColor(red, green, blue, alpha));
    return true;
}

QVariantList KarambaInterface::getInputBoxFrameColor(const Karamba *k, const Input *input) const
{
    if (!checkKarambaAndMeter(k, input, "Input")) {
        return QVariantList();
    }

    QVariantList ret;

    QColor color = input->getColor();
    ret << color.red();
    ret << color.green();
    ret << color.blue();
    ret << color.alpha();

    return ret;
}

bool KarambaInterface::changeInputBoxSelectedTextColor(const Karamba *k, Input *input, int red, int
        green, int blue, int alpha) const
{
    if (!checkKarambaAndMeter(k, input, "Input")) {
        return false;
    }

    input->setSelectedTextColor(QColor(red, green, blue, alpha));

    return true;
}

QVariantList KarambaInterface::getInputBoxSelectedTextColor(const Karamba *k, const Input *input)
    const
{
    if (!checkKarambaAndMeter(k, input, "Input")) {
        return QVariantList();
    }

    QVariantList ret;

    QColor color = input->getSelectedTextColor();
    ret << color.red();
    ret << color.green();
    ret << color.blue();
    ret << color.alpha();

    return ret;
}

bool KarambaInterface::changeInputBoxFontSize(const Karamba *k, Input *input, int size) const
{
    if (!checkKarambaAndMeter(k, input, "Input")) {
        return false;
    }

    input->setFontSize(size);
    return true;
}

int KarambaInterface::getInputBoxFontSize(const Karamba *k, const Input *input) const
{
    if (!checkKarambaAndMeter(k, input, "Input")) {
        return 0;
    }

    return input->getFontSize();
}

bool KarambaInterface::setInputFocus(const Karamba *k, Input *input) const
{
    if (!checkKarambaAndMeter(k, input, "Input")) {
        return false;
    }

    input->setInputFocus();
    return true;
}

bool KarambaInterface::clearInputFocus(const Karamba *k, Input *input) const
{
    if (!checkKarambaAndMeter(k, input, "Input"))
        return false;

    input->clearInputFocus();
    return true;
}

QObject* KarambaInterface::getInputFocus(const Karamba *k) const
{
    if (!checkKaramba(k)) {
        return 0;
    }

    QGraphicsItem *focusItem = k->getScene()->focusItem();
    return dynamic_cast<Input*>(focusItem);
}

int KarambaInterface::getInputBoxTextWidth(const Karamba *k, Input *input) const
{
    if (!checkKarambaAndMeter(k, input, "Input")) {
        return 0;
    }

    return input->getTextWidth();
}

bool KarambaInterface::changeInputBoxSelection(const Karamba *k, Input *input, int start, int length) const
{
    if (!checkKarambaAndMeter(k, input, "Input")) {
        return false;
    }

    input->setSelection(start, length);

    return true;
}

QVariantList KarambaInterface::getInputBoxSelection(const Karamba *k, Input *input) const
{
    if (!checkKarambaAndMeter(k, input, "Input")) {
        return QVariantList();
    }

    QVariantList ret;

    QTextLayout::FormatRange selection = input->getSelection();
    ret << selection.start;
    ret << selection.length;

    return ret;
}

bool KarambaInterface::clearInputBoxSelection(const Karamba *k, Input *input) const
{
    if (!checkKarambaAndMeter(k, input, "Input")) {
        return false;
    }

    input->clearSelection();

    return true;
}




//
// Helper function for menu API.
// It can not be called from scripts.
//
bool KarambaInterface::menuExists(const Karamba* k, const KMenu* menu) const
{
    return k->popupMenuExisting(menu);
}


QObject* KarambaInterface::addMenuItem(Karamba *k, KMenu *menu, const QString &text, const
        QString &icon) const
{
    if (!checkKaramba(k)) {
        return 0;
    }

    QAction *action = 0;
    if (menuExists(k, menu)) {
        action = k->addMenuItem(menu, text, icon);
    }

    return action;
}

QObject* KarambaInterface::addMenuSeparator(Karamba *k, KMenu *menu) const
{
    if (!checkKaramba(k)) {
        return 0;
    }

    QAction *sep = 0;
    if (menuExists(k, menu)) {
        sep = menu->addSeparator();
    }

    return sep;
}

QObject* KarambaInterface::createMenu(Karamba *k) const
{
    if (!checkKaramba(k)) {
        return 0;
    }

    return k->addPopupMenu();
}

bool KarambaInterface::deleteMenu(Karamba *k, KMenu *menu) const
{
    if (!checkKaramba(k)) {
        return false;
    }

    if (menuExists(k, menu)) {
        k->deletePopupMenu(menu);
        return true;
    }

    return false;
}


bool KarambaInterface::popupMenu(const Karamba *k, KMenu *menu, int x, int y) const
{
    if (!checkKaramba(k)) {
        return false;
    }

    if (menuExists(k, menu)) {
        k->popupMenu(menu, QPoint(x, y));
        return true;
    }

    return false;
}

bool KarambaInterface::removeMenuItem(Karamba *k, KMenu *menu, QAction *action) const
{
    if (!checkKaramba(k)) {
        return false;
    }

    if (menuExists(k, menu)) {
        k->deleteMenuItem(action);
        return true;
    }

    return false;
}






bool KarambaInterface::acceptDrops(Karamba *k) const
{
    if (!checkKaramba(k)) {
        return false;
    }

    k->setAcceptDrops(true);

    return true;
}

bool KarambaInterface::attachClickArea(const Karamba *k, Meter *m,
    const QString &leftButton, const QString &middleButton, const QString &rightButton) const
{
    if (!checkKaramba(k)) {
        return false;
    }

    if (ImageLabel* image = dynamic_cast<ImageLabel*>(m)) {
        image->attachClickArea(leftButton, middleButton, rightButton);
        image->allowClick(true);
    } else if (TextLabel* text = dynamic_cast<TextLabel*>(m)) {
        text->attachClickArea(leftButton, middleButton, rightButton);
        text->allowClick(true);
    } else {
        return false;
    }

    return true;
}

bool KarambaInterface::callTheme(Karamba *k, const QString &theme, const QString &info) const
{
    if (!checkKaramba(k)) {
        return false;
    }

    return k->sendDataToTheme(theme, info);
}

bool KarambaInterface::changeInterval(Karamba *k, int interval) const
{
    if (!checkKaramba(k)) {
        return false;
    }

    k->changeInterval(interval);

    return true;
}

int KarambaInterface::execute(const QString &command) const
{
    return KRun::runCommand(command,0L);
}

QObject* KarambaInterface::createClickArea(Karamba *k, int x, int y, int width, int height,
        const QString &onClick) const
{
    if (!checkKaramba(k)) {
        return 0;
    }

    ClickArea *tmp = new ClickArea(k, false, x, y, width, height);
    tmp->setOnClick(onClick);

    k->addToGroup(tmp);

    return tmp;
}

bool KarambaInterface::removeClickArea(Karamba *k, ClickArea *area) const
{
    if (!checkKarambaAndMeter(k, area, "ClickArea")) {
        return false;
    }

    k->removeMeter(area);

    return true;
}

QObject* KarambaInterface::createServiceClickArea(Karamba *k, int x, int y, int width, int height,
        const QString &name, const QString &exec, const QString &icon) const
{
    if (!checkKaramba(k)) {
        return 0;
    }

    ClickArea *tmp = new ClickArea(k, false, x, y, width, height);
    tmp->setServiceOnClick(name, exec, icon);

    k->addToGroup(tmp);

    return tmp;
}

int KarambaInterface::executeInteractive(Karamba *k, const QStringList &command)
{
    if (!checkKaramba(k)) {
        return 0;
    }

    K3Process *process = new K3Process;
    k->setProcess(process);
    *process << command;

    connect(process,
                          SIGNAL(processExited(K3Process*)),
                          k,
                          SLOT(processExited(K3Process*)));

    connect(process,
                          SIGNAL(receivedStdout(K3Process*,char*,int)),
                          k,
                          SLOT(receivedStdout(K3Process*,char*,int)));

    process->start(K3Process::NotifyOnExit, K3Process::Stdout);

    return process->pid();
}

QString KarambaInterface::getIp(const Karamba *k, const QString &interface) const
{
    if (!checkKaramba(k)) {
        return QString();
    }

    QNetworkInterface iface = QNetworkInterface::interfaceFromName(interface);
    if (iface.isValid()) {
        QNetworkInterface::InterfaceFlags flags = iface.flags();
        if (flags & QNetworkInterface::IsUp) {
            QList<QNetworkAddressEntry> list = iface.addressEntries();
            if (list.count() > 0) {
                return list[0].ip().toString();
            } else {
                return "Error";
            }
        } else {
            return "Disconnected";
        }
    } else {
        return "Error";
    }
}

int KarambaInterface::getNumberOfDesktops(const Karamba *k) const
{
    if (!checkKaramba(k)) {
        return 0;
    }

    return k->getNumberOfDesktops();
}

QString KarambaInterface::getPrettyThemeName(const Karamba *k) const
{
    if (!checkKaramba(k)) {
        return QString();
    }

    return k->prettyName();
}

QVariantList KarambaInterface::getServiceGroups(const QString &path) const
{
    QVariantList ret;

    KServiceGroup::Ptr root = KServiceGroup::group(path);

    if (!root || !root->isValid())
        return ret;

    KServiceGroup::List sl = root->entries(true, true, true, false);
    QStringList suppressGenericNames = root->suppressGenericNames();

    KServiceGroup::List::ConstIterator it = sl.constBegin();
    for (; it != sl.constEnd(); ++it) {
        KSycocaEntry *e = (KSycocaEntry*)(*it).data();

        QVariant subItem;
        if (e->isType(KST_KServiceGroup)) {
            KServiceGroup::Ptr g(static_cast<KServiceGroup *>(e));
            KServiceGroup::Ptr subMenuRoot = KServiceGroup::group(g->relPath());
            if (subMenuRoot->childCount() == 0 || g->name().at(0) == '.') {
                continue;
            }

            QVariantList typeMap;

            QMap<QString, QVariant> map;
            map["caption"] = g->caption();
            map["comment"] = g->comment();
            map["icon"] = g->icon();
            map["relpath"] = g->relPath();

            typeMap << 0;
            typeMap << QVariant(map);

            subItem = QVariant(typeMap);
        } else if (e->isType(KST_KService)) {
            KService::Ptr g(static_cast<KService *>(e));

            QVariantList typeMap;

            QMap<QString, QVariant> map;
            map["exec"] = g->exec();
            map["menuid"] = g->menuId();
            map["name"] = g->name();
            map["path"] = g->path();
            map["icon"] = g->icon();
            map["library"] = g->library();
            map["comment"] = g->comment();
            map["type"] = g->isApplication() ? "Application" : "Service";
            map["genericname"] = g->genericName();

            typeMap << 1;
            typeMap << QVariant(map);

            subItem = QVariant(typeMap);
        }

        if (subItem.isValid()) {
            ret << subItem;
        }
    }

    return ret;
}

QString KarambaInterface::getThemePath(const Karamba *k) const
{
    if (!k) {
         k = d->karamba;
    }

    if (!checkKaramba(k)) {
        return QString();
    }

    return k->theme().path();
}

double KarambaInterface::getUpdateTime(const Karamba *k) const
{
    if (!checkKaramba(k)) {
        return 0;
    }

    return k->getUpdateTime();
}

bool KarambaInterface::setUpdateTime(Karamba *k, double updateTime) const
{
    if (!checkKaramba(k)) {
        return false;
    }

    k->setUpdateTime(updateTime);

    return true;
}

bool KarambaInterface::hide(Karamba *k) const
{
    if (!checkKaramba(k)) {
        return false;
    }

    k->hide();

    return true;
}

bool KarambaInterface::show(Karamba *k) const
{
    if (!checkKaramba(k)) {
        return false;
    }

    k->show();

    return true;
}

QString KarambaInterface::language(const Karamba *k) const
{
    if (!checkKaramba(k)) {
        return QString();
    }

    return k->theme().locale()->language();
}

bool KarambaInterface::managementPopup(const Karamba *k) const
{
    if (!checkKaramba(k)) {
        return false;
    }

    k->popupGlobalMenu();

    return true;
}

Karamba* KarambaInterface::openNamedTheme(const QString &themePath, const QString &themeName,
        bool subTheme) const
{
    Q_UNUSED(themeName);

    Karamba *newTheme = 0;
    QFileInfo file(themePath);

    if (file.exists()) {
        Karamba *k = KarambaManager::self()->getKaramba(themeName);
        if (!k) {
            newTheme = new Karamba(KUrl(themePath), 0, -1, subTheme);
        }
    }
    return newTheme;
}

Karamba* KarambaInterface::openTheme(const QString &themePath) const
{
    Karamba *newTheme = 0;
    QFileInfo file(themePath);

    if (file.exists()) {
        newTheme = new Karamba(KUrl(themePath));
    }

    return newTheme;
}

QString KarambaInterface::readThemeFile(const Karamba *k, const QString &file) const
{
    if (!checkKaramba(k)) {
        return QString();
    }

    return k->theme().readThemeFile(file);
}

bool KarambaInterface::reloadTheme(Karamba *k) const
{
    if (!checkKaramba(k)) {
        return false;
    }

    k->reloadConfig();

    return true;
}

bool KarambaInterface::run(const QString &appName, const QString &command, const QString &icon,
        const QStringList &arguments)
{
    KService service(appName, command, icon);

    KRun::run(service, arguments, 0);

    return true;
}

QString KarambaInterface::getIncomingData(const Karamba *k) const
{
    if (!checkKaramba(k)) {
        return QString();
    }

    return k->retrieveReceivedData();
}

// Is the theme path or the pretty name required?
bool KarambaInterface::setIncomingData(Karamba *k, const QString &prettyThemeName, const QString &data)
    const
{
    if (!checkKaramba(k)) {
        return false;
    }

    return k->sendData(prettyThemeName, data);
}

bool KarambaInterface::toggleShowDesktop(const Karamba *k) const
{
    if (!checkKaramba(k)) {
        return false;
    }

    ShowDesktop::self()->toggle();

    return true;
}

bool KarambaInterface::translateAll(const Karamba *k, int x, int y) const
{
    if (!checkKaramba(k)) {
        return false;
    }

    QList<QGraphicsItem*> items = ((QGraphicsItemGroup*)k)->children();

    foreach(QGraphicsItem *item, items) {
        Meter *meter = dynamic_cast<Meter*>(item);
        if (meter)
            meter->setSize(meter->getX() + x,
                           meter->getY() + y,
                           meter->getWidth(),
                           meter->getHeight());
    }

    return true;
}

QString KarambaInterface::userLanguage(const Karamba *k) const
{
    if (!checkKaramba(k)) {
        return QString();
    }

    return KGlobal::locale()->language();
}

QStringList KarambaInterface::userLanguages(const Karamba *k) const
{
    if (!checkKaramba(k)) {
        return QStringList();
    }

    return KGlobal::locale()->languageList();
}

bool KarambaInterface::setWantRightButton(Karamba *k, bool enable) const
{
    if (!checkKaramba(k)) {
        return false;
    }

    k->setWantRightButton(enable);

    return true;
}

QStringList KarambaInterface::version() const
{
    QStringList version;

    version << KCmdLineArgs::aboutData()->version();
    version << "0.1";

    return version;
}

QVariantList KarambaInterface::desktopSize() const
{
    QVariantList ret;

    QRect screenSize = QApplication::desktop()->screenGeometry();
    ret << screenSize.width();
    ret << screenSize.height();

    return ret;
}

QString KarambaInterface::getIconByName(const QString &icon, int size) const
{
    return KIconLoader::global()->iconPath(icon, -size);
}

QString KarambaInterface::getExecutingApplication() const
{
    return QApplication::applicationName();
}





QObject* KarambaInterface::createRichText(Karamba* k, const QString &text, bool underline) const
{
    if (!checkKaramba(k)) {
        return NULL;
    }

    RichTextLabel *tmp = new RichTextLabel(k);
    tmp->setText(text, underline);
    tmp->setTextProps(k->getDefaultTextProps());

    k->addToGroup(tmp);

    return tmp;
}

bool KarambaInterface::deleteRichText(Karamba *k, RichTextLabel *label) const
{
    if (!checkKarambaAndMeter(k, label, "RichTextLabel")) {
        return false;
    }

    return k->removeMeter(label);
}

bool KarambaInterface::moveRichText(Karamba *k, RichTextLabel *label, int x, int y) const
{
    return moveMeter(k, label, "RichTextLabel", x, y);
}

QVariantList KarambaInterface::getRichTextPos(const Karamba *k, const RichTextLabel *label) const
{
    return getMeterPos(k, label, "RichTextLabel");
}

bool KarambaInterface::resizeRichText(const Karamba *k, RichTextLabel *label, int width, int height)
    const
{
    return resizeMeter(k, label, "RichTextLabel", width, height);
}

bool KarambaInterface::setRichTextWidth(const Karamba *k, RichTextLabel *label, int width) const
{
    if (!checkKarambaAndMeter(k, label, "RichTextLabel")) {
        return false;
    }

    label->setWidth(width);

    return true;
}

QVariantList KarambaInterface::getRichTextSize(const Karamba *k, const RichTextLabel *label) const
{
    return getMeterSize(k, label, "RichTextLabel");
}

QObject* KarambaInterface::changeRichText(const Karamba *k, RichTextLabel *label, const QString
        &text) const
{
    return setMeterStringValue(k, label, "RichTextLabel", text);
}

QString KarambaInterface::getRichTextValue(const Karamba *k, const RichTextLabel *label) const
{
    return getMeterStringValue(k, label, "RichTextLabel");
}

QObject* KarambaInterface::getThemeRichText(const Karamba *k, const QString &meter) const
{
    return getThemeMeter(k, meter, "RichTextLabel");
}

bool KarambaInterface::hideRichText(const Karamba *k, RichTextLabel *label) const
{
    return hideMeter(k, label, "RichTextLabel");
}

bool KarambaInterface::showRichText(const Karamba *k, RichTextLabel *label) const
{
    return showMeter(k, label, "RichTextLabel");
}

bool KarambaInterface::changeRichTextFont(const Karamba *k, RichTextLabel *label, const QString
        &font) const
{
    if (!checkKarambaAndMeter(k, label, "RichTextLabel")) {
        return false;
    }

    label->setFont(font);
    return true;
}

QString KarambaInterface::getRichTextFont(const Karamba *k, const RichTextLabel *label) const
{
    if (!checkKarambaAndMeter(k, label, "RichTextLabel")) {
        return QString();
    }

    return label->getFont();
}

bool KarambaInterface::changeRichTextSize(const Karamba *k, RichTextLabel *label, int size) const
{
    if (!checkKarambaAndMeter(k, label, "RichTextLabel")) {
        return false;
    }

    label->setFontSize(size);

    return true;
}

int KarambaInterface::getRichTextFontSize(const Karamba *k, const RichTextLabel *label) const
{
    if (!checkKarambaAndMeter(k, label, "RichTextLabel")) {
        return 0;
    }

    return label->getFontSize();
}

bool KarambaInterface::setRichTextSensor(Karamba *k, RichTextLabel *label, const QString &sensor)
    const
{
    return setMeterSensor(k, label, "RichTextLabel", sensor);
}

QString KarambaInterface::getRichTextSensor(const Karamba *k, const RichTextLabel *label) const
{
    return getMeterSensor(k, label, "RichTextLabel");
}




QObject* KarambaInterface::createSystray(const Karamba *k, int x, int y, int w, int h) const
{
    Q_UNUSED(x);
    Q_UNUSED(y);
    Q_UNUSED(w);
    Q_UNUSED(h);

    if (!checkKaramba(k)) {
        return 0;
    }

    static bool firstMessage = false;

    if (!firstMessage) {
        kWarning() << "Call to \"createSystray\" not available in this version of SuperKaramba" ;
        firstMessage = true;
    }

    return 0;
}

int KarambaInterface::getCurrentWindowCount(const Karamba *k) const
{
    if (!checkKaramba(k)) {
        return -1;
    }

    static bool firstMessage = false;

    if (!firstMessage) {
        kWarning() << "Call to \"getCurrentWindowCount\" not available in this version of SuperKaramba" ;
        firstMessage = true;
    }

    return -1;
}

bool KarambaInterface::hideSystray(const Karamba *k) const
{
    if (!checkKaramba(k)) {
        return false;
    }

    static bool firstMessage = false;

    if (!firstMessage) {
        kWarning() << "Call to \"hideSystray\" not available in this version of SuperKaramba" ;
        firstMessage = true;
    }

    return false;
}

bool KarambaInterface::moveSystray(const Karamba *k, int x, int y, int w, int h) const
{
    Q_UNUSED(x);
    Q_UNUSED(y);
    Q_UNUSED(w);
    Q_UNUSED(h);

    if (!checkKaramba(k)) {
        return false;
    }

    static bool firstMessage = false;

    if (!firstMessage) {
        kWarning() << "Call to \"moveSystray\" not available in this version of SuperKaramba" ;
        firstMessage = true;
    }

    return false;
}

bool KarambaInterface::showSystray(const Karamba *k) const
{
    if (!checkKaramba(k)) {
        return false;
    }

    static bool firstMessage = false;

    if (!firstMessage) {
        kWarning() << "Call to \"showSystray\" not available in this version of SuperKaramba" ;
        firstMessage = true;
    }

    return false;
}

bool KarambaInterface::updateSystrayLayout(const Karamba *k) const
{
    if (!checkKaramba(k)) {
        return false;
    }

    static bool firstMessage = false;

    if (!firstMessage) {
        kWarning() << "Call to \"updateSystrayLayout\" not available in this version of SuperKaramba" ;
        firstMessage = true;
    }

    return false;
}

bool KarambaInterface::getSystraySize(const Karamba *k) const
{
    if (!checkKaramba(k)) {
        return false;
    }

    static bool firstMessage = false;

    if (!firstMessage) {
        kWarning() << "Call to \"getSystraySize\" not available in this version of SuperKaramba" ;
        firstMessage = true;
    }

    return false;
}



QVariantList KarambaInterface::getStartupInfo(const Karamba *k, const Startup *startup)
    const
{
    if (!checkKaramba(k)) {
        return QVariantList();
    }

    QVariantList ret;

    ret << startup->text();
    ret << startup->icon();
    ret << startup->bin();
    ret << qVariantFromValue((QObject*)startup);

    return ret;
}

QVariantList KarambaInterface::getStartupList(const Karamba *k) const
{
    if (!checkKaramba(k)) {
        return QVariantList();
    }

    QVariantList ret;

    Startup::List startupList = TaskManager::self()->startups();
    foreach (Startup::StartupPtr startup, startupList) {
        ret << qVariantFromValue((QObject*)startup.data());
    }

    return ret;
}

QVariantList KarambaInterface::getTaskInfo(const Karamba *k, Task* task) const
{
    if (!checkKaramba(k)) {
        return QVariantList();
    }

    QVariantList ret;

    ret << task->name();
    ret << task->info().iconName();
    ret << task->className();
    ret << task->desktop();
    ret << task->isMaximized();
    ret << task->isIconified();
    ret << task->isShaded();
    ret << task->isActive();
    ret << qVariantFromValue((QObject*)task);

    return ret;
}

QVariantList KarambaInterface::getTaskList(const Karamba *k) const
{
    if (!checkKaramba(k)) {
        return QVariantList();
    }

    QVariantList ret;

    QList<Task::TaskPtr> taskList = TaskManager::self()->tasks().values();

    foreach(const Task::TaskPtr &task, taskList) {
        ret << qVariantFromValue((QObject*)task.data());
    }

    return ret;
}

QStringList KarambaInterface::getTaskNames(const Karamba *k) const
{
    if (!checkKaramba(k)) {
        return QStringList();
    }

    QStringList ret;

    QList<Task::TaskPtr> taskList = TaskManager::self()->tasks().values();

    foreach(const Task::TaskPtr &task, taskList) {
        ret << task->name();
    }

    return ret;
}

bool KarambaInterface::performTaskAction(const Karamba *k, Task* task, int action)
    const
{
    if (!checkKaramba(k)) {
        return false;
    }

    switch (action) {
        case 1:
            task->setMaximized(true);
            break;

        case 2:
            task->restore();
            break;

        case 3:
            task->setIconified(true);
            break;

        case 4:
            task->close();
            break;

        case 5:
            task->activate();
            break;

        case 6:
            task->raise();
            break;

        case 7:
            task->lower();
            break;

        case 8:
            task->activateRaiseOrIconify();
            break;

        case 9:
            task->toggleAlwaysOnTop();
            break;

        case 10:
            task->toggleShaded();
            break;

        default:
            kWarning() << "You are trying to perform an invalid "
                    << "action in performTaskAction" << endl;
            return false;

    }

    return true;
}




QObject* KarambaInterface::createText(Karamba* k, int x, int y, int width, int height, const QString
        &text) const
{
    if (!checkKaramba(k)) {
        return NULL;
    }

    TextLabel *tmp = new TextLabel(k, x, y, width, height);
    tmp->setValue(text);
    tmp->setTextProps(k->getDefaultTextProps());

    k->addToGroup(tmp);

    return tmp;
}

bool KarambaInterface::deleteText(Karamba *k, TextLabel *text) const
{
    if (!checkKarambaAndMeter(k, text, "TextLabel")) {
        return false;
    }

    return k->removeMeter(text);
}

bool KarambaInterface::moveText(Karamba *k, TextLabel *text, int x, int y) const
{
    return moveMeter(k, text, "TextLabel", x, y);
}

QVariantList KarambaInterface::getTextPos(const Karamba *k, const TextLabel *text) const
{
    return getMeterPos(k, text, "TextLabel");
}

bool KarambaInterface::setTextSensor(Karamba *k, TextLabel *text, const QString &sensor) const
{
    return setMeterSensor(k, text, "TextLabel", sensor);
}

QString KarambaInterface::getTextSensor(const Karamba *k, const TextLabel *text) const
{
    return getMeterSensor(k, text, "TextLabel");
}

bool KarambaInterface::resizeText(const Karamba *k, TextLabel *text, int width, int height) const
{
    return resizeMeter(k, text, "TextLabel", width, height);
}

QVariantList KarambaInterface::getTextSize(const Karamba *k, const TextLabel *text) const
{
    return getMeterSize(k, text, "TextLabel");
}

QObject* KarambaInterface::getThemeText(const Karamba *k, const QString &meter) const
{
    return getThemeMeter(k, meter, "TextLabel");
}

bool KarambaInterface::hideText(const Karamba *k, TextLabel *text) const
{
    return hideMeter(k, text, "TextLabel");
}

bool KarambaInterface::showText(const Karamba *k, TextLabel *text) const
{
    return showMeter(k, text, "TextLabel");
}

QObject* KarambaInterface::changeText(const Karamba *k, TextLabel *label, const QString &text) const
{
    return setMeterStringValue(k, label, "TextLabel", text);
}

QString KarambaInterface::getTextValue(const Karamba *k, const TextLabel *label) const
{
    return getMeterStringValue(k, label, "TextLabel");
}

bool KarambaInterface::changeTextShadow(const Karamba *k, TextLabel *label, int shadow) const
{
    if (!checkKarambaAndMeter(k, label, "TextLabel")) {
        return false;
    }

    label->setShadow(shadow);
    return true;
}

int KarambaInterface::getTextShadow(const Karamba *k, const TextLabel *text) const
{
    if (!checkKarambaAndMeter(k, text, "TextLabel")) {
        return -1;
    }

    return text->getShadow();
}

bool KarambaInterface::changeTextFont(const Karamba *k, TextLabel *text, const QString &font) const
{
    if (!checkKarambaAndMeter(k, text, "TextLabel")) {
        return false;
    }

    text->setFont(font);

    return true;
}

QString KarambaInterface::getTextFont(const Karamba *k, const TextLabel *text) const
{
    if (!checkKarambaAndMeter(k, text, "TextLabel")) {
        return QString();
    }

    return text->getFont();
}

bool KarambaInterface::changeTextColor(const Karamba *k, TextLabel *text, int red, int green, int
        blue, int alpha) const
{
    return setMeterColor(k, text, "TextLabel", red, green, blue, alpha);
}

QVariantList KarambaInterface::getTextColor(const Karamba *k, const TextLabel *text) const
{
    return getMeterColor(k, text, "TextLabel");
}

bool KarambaInterface::changeTextSize(const Karamba *k, TextLabel *text, int size) const
{
    if (!checkKarambaAndMeter(k, text, "TextLabel")) {
        return false;
    }

    text->setFontSize(size);

    return true;
}

int KarambaInterface::getTextFontSize(const Karamba *k, const TextLabel *text) const
{
    if (!checkKarambaAndMeter(k, text, "TextLabel")) {
        return -1;
    }

    return text->getFontSize();
}

QString KarambaInterface::getTextAlign(const Karamba *k, const TextLabel *text) const
{
    if (!checkKarambaAndMeter(k, text, "TextLabel")) {
        return QString();
    }

    return text->getAlignment();
}

bool KarambaInterface::setTextAlign(const Karamba *k, TextLabel *text, const QString &alignment)
    const
{
    if (!checkKarambaAndMeter(k, text, "TextLabel")) {
        return false;
    }

    text->setAlignment(alignment);

    return true;
}

bool KarambaInterface::setTextScroll(const Karamba *k, TextLabel *text, const QString &type, int x,
        int y, int gap, int pause) const
{
    if (!checkKarambaAndMeter(k, text, "TextLabel")) {
        return false;
    }

    text->setScroll(type, QPoint(x, y), gap, pause);

    return true;
}

int KarambaInterface::getTextTextWidth(const Karamba *k, const TextLabel *text) const
{
    if (!checkKarambaAndMeter(k, text, "TextLabel")) {
        return -1;
    }

    return text->getTextWidth();
}





bool KarambaInterface::createWidgetMask(const Karamba *k, const QString &mask) const
{
    Q_UNUSED(k);
    Q_UNUSED(mask);

    return true;
}

QVariantList KarambaInterface::getWidgetPosition(const Karamba *k) const
{
    if (!checkKaramba(k)) {
        return QVariantList();
    }

    QPoint pos = k->getPosition();

    QVariantList ret;
    ret << pos.x();
    ret << pos.y();

    return ret;
}

bool KarambaInterface::moveWidget(Karamba *k, int x, int y) const
{
    if (!checkKaramba(k)) {
        return false;
    }

    k->moveToPos(QPoint(x, y));

    return true;
}

bool KarambaInterface::redrawWidget(Karamba *k) const
{
    if (!checkKaramba(k))
        return false;

    k->redrawWidget();

    return true;
}

bool KarambaInterface::redrawWidgetBackground(const Karamba *k) const
{
    Q_UNUSED(k);

    return true;
}

bool KarambaInterface::resizeWidget(Karamba *k, int width, int height) const
{
    if (!checkKaramba(k)) {
        return false;
    }

    k->resizeTo(width, height);

    return true;
}

bool KarambaInterface::toggleWidgetRedraw(const Karamba *k, bool enable) const
{
    Q_UNUSED(k);
    Q_UNUSED(enable);

    return true;
}

QObject* KarambaInterface::getPlasmaSensor(Karamba *k, const QString& engine, const QString& source)
{
    if (!checkKaramba(k)) {
        return 0;
    }
    return k->getPlasmaSensor(engine, source);
}

QObject* KarambaInterface::createCanvasWidget(Karamba *k, QWidget* widget)
{
    if (!checkKaramba(k)) {
        return 0;
    }
    QGraphicsProxyWidget* proxy = k->getScene()->addWidget(widget);
    proxy->setGeometry(k->boundingRect());
    proxy->setVisible(true);
    return proxy;
}

bool KarambaInterface::moveCanvasWidget(Karamba *k, QObject* canvaswidget, int x, int y, int w, int h)
{
    QGraphicsProxyWidget* proxy = dynamic_cast<QGraphicsProxyWidget*>(canvaswidget);
    if (!checkKaramba(k) || !proxy) {
        return false;
    }
    proxy->setGeometry(QRectF(x, y, w, h));
    return true;
}