• Skip to content
• Skip to link menu

KDE 4.0 API Reference

• KDE API Reference
• kdeutils

• Sitemap
• Contact Us

 

superkaramba

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 <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("karamba");
}

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

void KarambaInterface::startInterpreter()
{
    d->action->trigger();
}

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");
}





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;
}