diff --git a/libs/libkis/Document.cpp b/libs/libkis/Document.cpp
index 925dc5fbbc..0ac51c59eb 100644
--- a/libs/libkis/Document.cpp
+++ b/libs/libkis/Document.cpp
@@ -1,461 +1,462 @@
 /*
  *  Copyright (c) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "Document.h"
 #include <QPointer>
 #include <QUrl>
 #include <QDomDocument>
 
 #include <KoColorSpaceConstants.h>
 #include <KoXmlReader.h>
 #include <KisDocument.h>
 #include <kis_image.h>
 #include <KisPart.h>
 #include <kis_paint_device.h>
 #include <KisMainWindow.h>
 #include <kis_node_manager.h>
 #include <kis_node_selection_adapter.h>
 #include <KisViewManager.h>
 #include <kis_file_layer.h>
 #include <kis_adjustment_layer.h>
 #include <kis_mask.h>
 #include <kis_clone_layer.h>
 #include <kis_group_layer.h>
 #include <kis_filter_mask.h>
 #include <kis_transform_mask.h>
 #include <kis_transparency_mask.h>
 #include <kis_selection_mask.h>
 #include <kis_effect_mask.h>
 #include <kis_paint_layer.h>
 #include <kis_generator_layer.h>
 #include <kis_shape_layer.h>
 #include <kis_filter_configuration.h>
 #include <kis_selection.h>
 
 #include <KoColorSpace.h>
 #include <KoColorProfile.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorConversionTransformation.h>
 #include <KoDocumentInfo.h>
 
 #include <InfoObject.h>
 #include <Node.h>
 #include <Selection.h>
 
 struct Document::Private {
     Private() {}
     QPointer<KisDocument> document;
     bool ownsDocument {false};
 };
 
 Document::Document(KisDocument *document, bool ownsDocument, QObject *parent)
     : QObject(parent)
     , d(new Private)
 {
     d->document = document;
     d->ownsDocument = ownsDocument;
 }
 
 Document::~Document()
 {
     qDebug() << "Document" << this << "deleted";
     if (d->ownsDocument) {
         KisPart::instance()->removeDocument(d->document);
         delete d->document;
     }
 
     delete d;
 }
 
 bool Document::batchmode() const
 {
     if (!d->document) return false;
     return d->document->fileBatchMode();
 }
 
 void Document::setBatchmode(bool value)
 {
     if (!d->document) return;
     d->document->setFileBatchMode(value);
 }
 
 Node *Document::activeNode() const
 {
     QList<KisNodeSP> activeNodes;
     Q_FOREACH(QPointer<KisView> view, KisPart::instance()->views()) {
         if (view && view->document() == d->document) {
             activeNodes << view->currentNode();
         }
     }
     if (activeNodes.size() > 0) {
         return new Node(d->document->image(), activeNodes.first());
     }
     return new Node(d->document->image(), d->document->image()->root()->firstChild());
 }
 
 void Document::setActiveNode(Node* value)
 {
     if (!value->node()) return;
     KisMainWindow *mainWin = KisPart::instance()->currentMainwindow();
     if (!mainWin) return;
     KisViewManager *viewManager = mainWin->viewManager();
     if (!viewManager) return;
     KisNodeManager *nodeManager = viewManager->nodeManager();
     if (!nodeManager) return;
     KisNodeSelectionAdapter *selectionAdapter = nodeManager->nodeSelectionAdapter();
     if (!selectionAdapter) return;
     selectionAdapter->setActiveNode(value->node());
 
 }
 
 
 QString Document::colorDepth() const
 {
     if (!d->document) return "";
     return d->document->image()->colorSpace()->colorDepthId().id();
 }
 
 QString Document::colorModel() const
 {
     if (!d->document) return "";
     return d->document->image()->colorSpace()->colorModelId().id();
 }
 
 QString Document::colorProfile() const
 {
     if (!d->document) return "";
     return d->document->image()->colorSpace()->profile()->name();
 }
 
 bool Document::setColorProfile(const QString &value)
 {
     if (!d->document) return false;
     if (!d->document->image()) return false;
     const KoColorProfile *profile = KoColorSpaceRegistry::instance()->profileByName(value);
     if (!profile) return false;
     d->document->image()->lock();
     bool retval = d->document->image()->assignImageProfile(profile);
     d->document->image()->unlock();
     d->document->image()->setModified();
     d->document->image()->initialRefreshGraph();
     return retval;
 }
 
 bool Document::setColorSpace(const QString &colorModel, const QString &colorDepth, const QString &colorProfile)
 {
     if (!d->document) return false;
     if (!d->document->image()) return false;
     const KoColorSpace *colorSpace = KoColorSpaceRegistry::instance()->colorSpace(colorModel, colorDepth, colorProfile);
     if (!colorSpace) return false;
     d->document->image()->lock();
     d->document->image()->convertImageColorSpace(colorSpace,
                                                  KoColorConversionTransformation::IntentPerceptual,
                                                  KoColorConversionTransformation::HighQuality | KoColorConversionTransformation::NoOptimization);
     d->document->image()->unlock();
     d->document->image()->setModified();
     d->document->image()->initialRefreshGraph();
     return true;
 }
 
 
 QString Document::documentInfo() const
 {
     QDomDocument doc = KisDocument::createDomDocument("document-info"
                                                       /*DTD name*/, "document-info" /*tag name*/, "1.1");
     doc = d->document->documentInfo()->save(doc);
     return doc.toString();
 }
 
 void Document::setDocumentInfo(const QString &document)
 {
     KoXmlDocument doc = KoXmlDocument(true);
     QString errorMsg;
     int errorLine, errorColumn;
     doc.setContent(document, &errorMsg, &errorLine, &errorColumn);
     d->document->documentInfo()->load(doc);
 }
 
 QString Document::fileName() const
 {
     if (!d->document) return QString::null;
     return d->document->url().toLocalFile();
 }
 
 void Document::setFileName(QString value)
 {
     if (!d->document) return;
     d->document->setUrl(QUrl::fromLocalFile(value));
 }
 
 
 int Document::height() const
 {
     if (!d->document) return 0;
     KisImageSP image = d->document->image();
     if (!image) return 0;
     return image->height();
 }
 
 void Document::setHeight(int value)
 {
     if (!d->document) return;
     KisImageSP image = d->document->image();
     if (!image) return;
     QRect rc = image->bounds();
     rc.setHeight(value);
     image->resizeImage(rc);
 }
 
 
 QString Document::name() const
 {
     if (!d->document) return "";
     return d->document->documentInfo()->aboutInfo("title");
 }
 
 void Document::setName(QString value)
 {
     if (!d->document) return;
     d->document->documentInfo()->setAboutInfo("title", value);
 }
 
 
 int Document::resolution() const
 {
     if (!d->document) return 0;
     KisImageSP image = d->document->image();
     if (!image) return 0;
 
     return qRound(d->document->image()->xRes() * 72);
 }
 
 void Document::setResolution(int value)
 {
     if (!d->document) return;
     KisImageSP image = d->document->image();
     if (!image) return;
 
     d->document->image()->setResolution(value / 72.0, value / 72.0);
 }
 
 
 Node *Document::rootNode() const
 {
     if (!d->document) return 0;
     KisImageSP image = d->document->image();
     if (!image) return 0;
 
     return new Node(image, image->root());
 }
 
 Selection *Document::selection() const
 {
     if (!d->document) return 0;
     if (!d->document->image()) return 0;
     if (!d->document->image()->globalSelection()) return 0;
     return new Selection(d->document->image()->globalSelection());
 }
 
 void Document::setSelection(Selection* value)
 {
     if (!d->document) return;
     if (!d->document->image()) return;
     d->document->image()->setGlobalSelection(value->selection());
 }
 
 
 int Document::width() const
 {
     if (!d->document) return 0;
     KisImageSP image = d->document->image();
     if (!image) return 0;
     return image->width();
 }
 
 void Document::setWidth(int value)
 {
     if (!d->document) return;
     KisImageSP image = d->document->image();
     if (!image) return;
     QRect rc = image->bounds();
     rc.setWidth(value);
     image->resizeImage(rc);
 }
 
 double Document::xRes() const
 {
     if (!d->document) return 0.0;
     if (!d->document->image()) return 0.0;
     return d->document->image()->xRes();
 }
 
 void Document::setXRes(double xRes) const
 {
     if (!d->document) return;
     if (!d->document->image()) return;
     d->document->image()->setResolution(xRes, d->document->image()->yRes());
 }
 
 double Document::yRes() const
 {
     if (!d->document) return 0.0;
     if (!d->document->image()) return 0.0;
     return d->document->image()->yRes();
 }
 
 void Document::setyRes(double yRes) const
 {
     if (!d->document) return;
     if (!d->document->image()) return;
     d->document->image()->setResolution(d->document->image()->xRes(), yRes);
 }
 
 
 QByteArray Document::pixelData(int x, int y, int w, int h) const
 {
     QByteArray ba;
 
     if (!d->document) return ba;
     KisImageSP image = d->document->image();
     if (!image) return ba;
 
     KisPaintDeviceSP dev = image->projection();
     quint8 *data = new quint8[w * h * dev->pixelSize()];
     dev->readBytes(data, x, y, w, h);
     ba = QByteArray((const char*)data, (int)(w * h * dev->pixelSize()));
     delete[] data;
     return ba;
 }
 
 bool Document::close()
 {
     if (d->ownsDocument) {
         KisPart::instance()->removeDocument(d->document);
 
     }
     bool retval = d->document->closeUrl(false);
     if (d->ownsDocument) {
         delete d->document;
     }
     return retval;
 }
 
 void Document::crop(int x, int y, int w, int h)
 {
     if (!d->document) return;
     KisImageSP image = d->document->image();
     if (!image) return;
     QRect rc(x, y, w, h);
     image->cropImage(rc);
 }
 
 bool Document::exportImage(const QString &filename, const InfoObject &exportConfiguration)
 {
     if (!d->document) return false;
     return d->document->exportDocument(QUrl::fromLocalFile(filename));
 }
 
 void Document::flatten()
 {
     if (!d->document) return;
     if (!d->document->image()) return;
     d->document->image()->lock();
     d->document->image()->flatten();
     d->document->image()->unlock();
     d->document->image()->setModified();
     d->document->image()->initialRefreshGraph();
 }
 
 void Document::resizeImage(int w, int h)
 {
     if (!d->document) return;
     KisImageSP image = d->document->image();
     if (!image) return;
     QRect rc = image->bounds();
     rc.setWidth(w);
     rc.setHeight(h);
     image->resizeImage(rc);
 }
 
 bool Document::save()
 {
     if (!d->document) return false;
     return d->document->save();
 }
 
 bool Document::saveAs(const QString &filename)
 {
     if (!d->document) return false;
     return d->document->saveAs(QUrl::fromLocalFile(filename));
 }
 
 void Document::openView()
 {
+    // UNIMPLEMENTED
 }
 
 Node* Document::createNode(const QString &name, const QString &nodeType)
 {
     if (!d->document) return 0;
     if (!d->document->image()) return 0;
     KisImageSP image = d->document->image();
 
     Node *node = 0;
 
     if (nodeType == "paintlayer") {
         node = new Node(image, new KisPaintLayer(image, name, OPACITY_OPAQUE_U8));
     }
     else if (nodeType == "grouplayer") {
         node = new Node(image, new KisGroupLayer(image, name, OPACITY_OPAQUE_U8));
     }
     else if (nodeType == "filelayer") {
         node = new Node(image, new KisFileLayer(image, name, OPACITY_OPAQUE_U8));
     }
     else if (nodeType == "filterlayer") {
         node = new Node(image, new KisAdjustmentLayer(image, name, 0, 0));
     }
     else if (nodeType == "filllayer") {
         node = new Node(image, new KisGeneratorLayer(image, name, 0, 0));
     }
     else if (nodeType == "clonelayer") {
         node = new Node(image, new KisCloneLayer(0, image, name, OPACITY_OPAQUE_U8));
     }
     else if (nodeType == "vectorlayer") {
         node = new Node(image, new KisShapeLayer(d->document->shapeController(), image, name, OPACITY_OPAQUE_U8));
     }
     else if (nodeType == "transparencymask") {
         node = new Node(image, new KisTransparencyMask());
     }
     else if (nodeType == "filtermask") {
         node = new Node(image, new KisFilterMask());
     }
     else if (nodeType == "transformmask") {
         node = new Node(image, new KisTransformMask());
     }
     else if (nodeType == "localselectionmask") {
         node = new Node(image, new KisSelectionMask(image));
     }
 
     return node;
 }
 
 QPointer<KisDocument> Document::document() const
 {
     return d->document;
 }
 
 
 
diff --git a/libs/libkis/Generator.cpp b/libs/libkis/Generator.cpp
index 267cb78d98..747e0c2515 100644
--- a/libs/libkis/Generator.cpp
+++ b/libs/libkis/Generator.cpp
@@ -1,53 +1,53 @@
 /*
  *  Copyright (c) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "Generator.h"
 
 struct Generator::Private {
     Private() {}
 };
 
 Generator::Generator(QObject *parent) 
     : QObject(parent)
     , d(new Private)
 {
 }
 
 Generator::~Generator() 
 {
     delete d;
 }
 
 InfoObject* Generator::configuration() const
 {
+    // UNIMPLEMENTED
     return 0;
 }
 
 void Generator::setConfiguration(InfoObject* value)
 {
+    // UNIMPLEMENTED
 }
 
-
-
-
 Node* Generator::createNode()
 {
+    // UNIMPLEMENTED
     return 0;
 }
 
 
 
diff --git a/libs/libkis/Krita.cpp b/libs/libkis/Krita.cpp
index 2aab1360ff..5e410e3a8b 100644
--- a/libs/libkis/Krita.cpp
+++ b/libs/libkis/Krita.cpp
@@ -1,356 +1,358 @@
 /*
  *  Copyright (c) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "Krita.h"
 
 #include <QPointer>
 #include <QVariant>
 
 #include <kis_generator_registry.h>
 #include <kis_generator.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorProfile.h>
 #include <KoColorSpace.h>
 #include <KoDockRegistry.h>
 #include <KoColorSpaceEngine.h>
 #include <KoColorModelStandardIds.h>
 
 #include <kactioncollection.h>
 #include <KisPart.h>
 #include <KisMainWindow.h>
 #include <KisDocument.h>
 #include <kis_image.h>
 #include <kis_action.h>
 #include <kis_script_manager.h>
 #include <KisViewManager.h>
 #include <KritaVersionWrapper.h>
 #include <kis_filter_registry.h>
 #include <kis_filter.h>
 #include <kis_filter_configuration.h>
 #include <kis_properties_configuration.h>
 
 #include "View.h"
 #include "Document.h"
 #include "Window.h"
 #include "ViewExtension.h"
 #include "DockWidgetFactoryBase.h"
 #include "Filter.h"
 #include "InfoObject.h"
 #include "Generator.h"
 
 Krita* Krita::s_instance = 0;
 
 struct Krita::Private {
     Private() {}
     QList<ViewExtension*> viewExtensions;
     bool batchMode {false};
     Notifier *notifier{new Notifier()};
 };
 
 Krita::Krita(QObject *parent)
     : QObject(parent)
     , d(new Private)
 {
     qRegisterMetaType<Notifier*>();
 }
 
 Krita::~Krita()
 {
     qDeleteAll(d->viewExtensions);
     delete d->notifier;
     delete d;
 }
 
 QList<Action *> Krita::actions() const
 {
     QList<Action*> actionList;
     KisMainWindow *mainWindow = KisPart::instance()->currentMainwindow();
     if (!mainWindow) {
         return actionList;
     }
     KActionCollection *actionCollection = mainWindow->actionCollection();
     Q_FOREACH(QAction *action, actionCollection->actions()) {
         actionList << new Action(action->objectName(), action);
     }
     return actionList;
 }
 
 Action *Krita::action(const QString &name) const
 {
     KisMainWindow *mainWindow = KisPart::instance()->currentMainwindow();
     if (!mainWindow) {
         return 0;
     }
     KActionCollection *actionCollection = mainWindow->actionCollection();
     QAction *action = actionCollection->action(name);
     if (action) {
         return new Action(name, action);
     }
     return 0;
 }
 
 Document* Krita::activeDocument() const
 {
     KisMainWindow *mainWindow = KisPart::instance()->currentMainwindow();
     if (!mainWindow) {
         return 0;
     }
     KisView *view = mainWindow->activeView();
     if (!view) {
         return 0;
     }
     KisDocument *document = view->document();
     return new Document(document);
 }
 
 void Krita::setActiveDocument(Document* value)
 {
     Q_FOREACH(KisView *view, KisPart::instance()->views()) {
         if (view->document() == value->document().data()) {
             view->activateWindow();
             break;
         }
     }
 }
 
 bool Krita::batchmode() const
 {
     return d->batchMode;
 }
 
 void Krita::setBatchmode(bool value)
 {
     d->batchMode = value;
 }
 
 
 QList<Document *> Krita::documents() const
 {
     QList<Document *> ret;
     foreach(QPointer<KisDocument> doc, KisPart::instance()->documents()) {
         ret << new Document(doc);
     }
     return ret;
 }
 
 QStringList Krita::filters() const
 {
     QStringList ls = KisFilterRegistry::instance()->keys();
     qSort(ls);
     return ls;
 }
 
 Filter *Krita::filter(const QString &name) const
 {
     if (!filters().contains(name)) return 0;
 
     Filter *filter = new Filter();
     filter->setName(name);
     KisFilterSP f = KisFilterRegistry::instance()->value(name);
     KisFilterConfigurationSP fc = f->defaultConfiguration(0);
     InfoObject *info = new InfoObject(fc);
     filter->setConfiguration(info);
     return filter;
 }
 
 QStringList Krita::generators() const
 {
     QStringList ls = KisGeneratorRegistry::instance()->keys();
     qSort(ls);
     return ls;
 }
 
 Generator *Krita::generator(const QString &name) const
 {
+    // UNIMPLEMENTED
     if (!generators().contains(name)) return 0;
 
     Generator *generator = new Generator();
 //    generator->setName(name);
 //    KisGeneratorSP f = KisGeneratorRegistry::instance()->value(name);
 //    KisGeneratorConfigurationSP fc = f->defaultConfiguration(0);
 //    InfoObject *info = new InfoObject(fc);
 //    generator->setConfiguration(info);
     return generator;
 }
 
 QStringList Krita::profiles(const QString &colorModel, const QString &colorDepth) const
 {
     QSet<QString> profileNames;
     QString id = KoColorSpaceRegistry::instance()->colorSpaceId(colorModel, colorDepth);
     QList<const KoColorProfile *> profiles = KoColorSpaceRegistry::instance()->profilesFor(id);
     Q_FOREACH(const KoColorProfile *profile, profiles) {
         profileNames << profile->name();
     }
     return profileNames.toList();
 }
 
 bool Krita::addProfile(const QString &profilePath)
 {
     KoColorSpaceEngine *iccEngine = KoColorSpaceEngineRegistry::instance()->get("icc");
     return iccEngine->addProfile(profilePath);
 }
 
 Notifier* Krita::notifier() const
 {
     return d->notifier;
 }
 
 QString Krita::version() const
 {
     return KritaVersionWrapper::versionString(true);
 }
 
 QList<View *> Krita::views() const
 {
     QList<View *> ret;
     foreach(QPointer<KisView> view, KisPart::instance()->views()) {
         ret << new View(view);
     }
     return ret;
 }
 
 Window *Krita::activeWindow() const
 {
     KisMainWindow *mainWindow = KisPart::instance()->currentMainwindow();
     if (!mainWindow) {
         return 0;
     }
     return new Window(mainWindow);
 }
 
 QList<Window*>  Krita::windows() const
 {
     QList<Window*> ret;
     foreach(QPointer<KisMainWindow> mainWin, KisPart::instance()->mainWindows()) {
         ret << new Window(mainWin);
     }
     return ret;
-
 }
 
 QList<Resource *> Krita::resources() const
 {
+    // UNIMPLEMENTED
     return QList<Resource *> ();
 }
 
 void Krita::setResources(QList<Resource *> value)
 {
-
+    // UNIMPLEMENTED
 }
 
 void Krita::addDockWidget(DockWidget *dockWidget)
 {
+    // UNIMPLEMENTED
 }
 
 bool Krita::closeApplication()
 {
     qDebug() << "closeApplication called";
     return false;
 }
 
 Document* Krita::createDocument(int width, int height, const QString &name, const QString &colorModel, const QString &colorDepth, const QString &profile)
 {
     KisDocument *document = KisPart::instance()->createDocument();
     KisPart::instance()->addDocument(document);
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->colorSpace(colorModel, colorDepth, profile);
     Q_ASSERT(cs);
 
     QColor qc(Qt::white);
     qc.setAlpha(0);
     KoColor bgColor(qc, cs);
 
     if (!document->newImage(name, width, height, cs, bgColor, true, 1, "", 100.0)) {
         qDebug() << "Could not create a new image";
         return 0;
     }
 
     Q_ASSERT(document->image());
     qDebug() << document->image()->objectName();
 
     return new Document(document, true);
 }
 
 Document* Krita::openDocument(const QString &filename)
 {
     KisDocument *document = KisPart::instance()->createDocument();
     KisPart::instance()->addDocument(document);
     document->openUrl(QUrl::fromLocalFile(filename), KisDocument::OPEN_URL_FLAG_DO_NOT_ADD_TO_RECENT_FILES);
     return new Document(document);
 }
 
 Window* Krita::openWindow()
 {
     KisMainWindow *mw = KisPart::instance()->createMainWindow();
     return new Window(mw);
 }
 
 
 Action *Krita::createAction(const QString &text)
 {
     KisAction *action = new KisAction(text, this);
     KisPart::instance()->addScriptAction(action);
     return new Action(action->objectName(), action);
 }
 
 void Krita::addViewExtension(ViewExtension* viewExtension)
 {
     d->viewExtensions.append(viewExtension);
 }
 
 QList< ViewExtension* > Krita::viewExtensions()
 {
     return d->viewExtensions;
 }
 
 void Krita::addDockWidgetFactory(DockWidgetFactoryBase* factory)
 {
     KoDockRegistry::instance()->add(factory);
 }
 
 Krita* Krita::instance()
 {
     if (!s_instance)
     {
         s_instance = new Krita;
     }
     return s_instance;
 }
 
 /**
  * Scripter.fromVariant(variant)
  * variant is a QVariant
  * returns instance of QObject-subclass
  *
  * This is a helper method for PyQt because PyQt cannot cast a variant to a QObject or QWidget
  */
 QObject *Krita::fromVariant(const QVariant& v)
 {
 
     if (v.canConvert< QWidget* >())
     {
         QObject* obj = qvariant_cast< QWidget* >(v);
         return obj;
     }
     else if (v.canConvert< QObject* >())
     {
         QObject* obj = qvariant_cast< QObject* >(v);
         return obj;
     }
     else
         return 0;
 }
 
diff --git a/libs/libkis/Node.cpp b/libs/libkis/Node.cpp
index 37ee6761ca..7134ce8a15 100644
--- a/libs/libkis/Node.cpp
+++ b/libs/libkis/Node.cpp
@@ -1,428 +1,457 @@
 /*
  *  Copyright (c) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include <QUrl>
 #include <QScopedPointer>
 
 #include <KoColorSpace.h>
 
 #include <KisDocument.h>
 #include <KisMimeDatabase.h>
 #include <KisPart.h>
 #include <kis_image.h>
 #include <kis_types.h>
 #include <kis_node.h>
 #include <kis_paint_layer.h>
 #include <kis_group_layer.h>
 #include <kis_layer.h>
 
 #include "Krita.h"
 #include "Node.h"
 #include "Channel.h"
 #include "Generator.h"
 #include "Filter.h"
 #include "Transformation.h"
 #include "Selection.h"
 
 
 struct Node::Private {
     Private() {}
     KisImageSP image;
     KisNodeSP node;
 };
 
 Node::Node(KisImageSP image, KisNodeSP node, QObject *parent)
     : QObject(parent)
     , d(new Private)
 {
     d->image = image;
     d->node = node;
 }
 
 Node::~Node()
 {
     delete d;
 }
 
 bool Node::alphaLocked() const
 {
     if (!d->node) return false;
     KisPaintLayerSP paintLayer = qobject_cast<KisPaintLayer*>(d->node.data());
     if (paintLayer) {
         return paintLayer->alphaLocked();
     }
     return false;
 }
 
 void Node::setAlphaLocked(bool value)
 {
     if (!d->node) return;
     KisPaintLayerSP paintLayer = qobject_cast<KisPaintLayer*>(d->node.data());
     if (paintLayer) {
         paintLayer->setAlphaLocked(value);
     }
 }
 
 
 QString Node::blendingMode() const
 {
     if (!d->node) return QString();
 
     return d->node->compositeOpId();
 }
 
 void Node::setBlendingMode(QString value)
 {
     if (!d->node) return;
     d->node->setCompositeOpId(value);
 }
 
 
 QList<Channel*> Node::channels() const
 {
     QList<Channel*> channels;
 
     if (!d->node) return channels;
     if (!d->node->inherits("KisLayer")) return channels;
 
     Q_FOREACH(KoChannelInfo *info, d->node->colorSpace()->channels()) {
         Channel *channel = new Channel(d->node, info);
         channels << channel;
     }
 
     return channels;
 }
 
 QList<Node*> Node::childNodes() const
 {
     QList<Node*> nodes;
     if (d->node) {
         int childCount = d->node->childCount();
         for (int i = 0; i < childCount; ++i) {
             nodes << new Node(d->image, d->node->at(i));
         }
     }
     return nodes;
 }
 
 void Node::setChildNodes(QList<Node*> value)
 {
+    // UNIMPLEMENTED
     if (!d->node) return;
 }
 
 
 
 QString Node::colorLabel() const
 {
+    // UNIMPLEMENTED
     if (!d->node) return QString();
     return QString();
 }
 
 void Node::setColorLabel(QString value)
 {
+    // UNIMPLEMENTED
     if (!d->node) return;
 }
 
 QString Node::colorDepth() const
 {
+    // UNIMPLEMENTED
     if (!d->node) return "";
     return d->node->colorSpace()->colorDepthId().id();
 }
 
-
-
 QString Node::colorModel() const
 {
+    // UNIMPLEMENTED
     if (!d->node) return "";
     return d->node->colorSpace()->colorModelId().id();
 }
 
 
 QString Node::colorProfile() const
 {
+    // UNIMPLEMENTED
     if (!d->node) return "";
     return d->node->colorSpace()->profile()->name();
 }
 
 void Node::setColorProfile(const QString &colorProfile)
 {
-
+    // UNIMPLEMENTED
 }
 
 void Node::setColorSpace(const QString &colorModel, const QString &colorDepth, const QString &colorProfile)
 {
-
+    // UNIMPLEMENTED
 }
 
 
 bool Node::inheritAlpha() const
 {
+    // UNIMPLEMENTED
     if (!d->node) return false;
     return false;
 }
 
 void Node::setInheritAlpha(bool value)
 {
+    // UNIMPLEMENTED
     if (!d->node) return;
 }
 
 
 bool Node::locked() const
 {
+    // UNIMPLEMENTED
     if (!d->node) return false;
     return false;
 }
 
 void Node::setLocked(bool value)
 {
+    // UNIMPLEMENTED
     if (!d->node) return;
 }
 
 
 QString Node::name() const
 {
     if (!d->node) return QString();
     return d->node->name();
 }
 
 void Node::setName(QString value)
 {
+    // UNIMPLEMENTED
     if (!d->node) return;
 }
 
 
 int Node::opacity() const
 {
     if (!d->node) return 0;
     return d->node->opacity();
 }
 
 void Node::setOpacity(int value)
 {
     if (!d->node) return;
     d->node->setOpacity(value);
 }
 
 
 Node* Node::parentNode() const
 {
+    // UNIMPLEMENTED
     if (!d->node) return 0;
     return 0;
 }
 
 void Node::setParentNode(Node* value)
 {
+    // UNIMPLEMENTED
     if (!d->node) return;
 }
 
 
 QString Node::type() const
 {
+    // UNIMPLEMENTED
     if (!d->node) return QString();
     return QString();
 }
 
 void Node::setType(QString value)
 {
+    // UNIMPLEMENTED
     if (!d->node) return;
 }
 
 
 bool Node::visible() const
 {
+    // UNIMPLEMENTED
     if (!d->node) return false;
     return false;
 }
 
 void Node::setVisible(bool value)
 {
+    // UNIMPLEMENTED
     if (!d->node) return;
 }
 
 
 InfoObject* Node::metaDataInfo() const
 {
+    // UNIMPLEMENTED
     if (!d->node) return 0;
     return 0;
 }
 
 void Node::setMetaDataInfo(InfoObject* value)
 {
+    // UNIMPLEMENTED
     if (!d->node) return;
 }
 
 
 Generator* Node::generator() const
 {
+    // UNIMPLEMENTED
     if (!d->node) return 0;
     return 0;
 }
 
 void Node::setGenerator(Generator* value)
 {
+    // UNIMPLEMENTED
     if (!d->node) return;
 }
 
 
 Filter* Node::filter() const
 {
+    // UNIMPLEMENTED
     if (!d->node) return 0;
     return 0;
 }
 
 void Node::setFilter(Filter* value)
 {
+    // UNIMPLEMENTED
     if (!d->node) return;
 }
 
 
 Transformation* Node::transformation() const
 {
+    // UNIMPLEMENTED
     if (!d->node) return 0;
     return 0;
 }
 
 void Node::setTransformation(Transformation* value)
 {
+    // UNIMPLEMENTED
     if (!d->node) return;
 }
 
 QString Node::fileName() const
 {
+    // UNIMPLEMENTED
     if (!d->node) return QString();
     return QString();
 }
 
 void Node::setFileName(QString value)
 {
+    // UNIMPLEMENTED
     if (!d->node) return;
 }
 
 QByteArray Node::pixelData(int x, int y, int w, int h) const
 {
     QByteArray ba;
 
     if (!d->node) return ba;
 
     KisPaintDeviceSP dev = d->node->paintDevice();
     if (!dev) return ba;
 
     quint8 *data = new quint8[w * h * dev->pixelSize()];
     dev->readBytes(data, x, y, w, h);
     ba = QByteArray((const char*)data, (int)(w * h * dev->pixelSize()));
     delete[] data;
 
     return ba;
 }
 
 
 QByteArray Node::projectionPixelData(int x, int y, int w, int h) const
 {
     QByteArray ba;
 
     if (!d->node) return ba;
 
     KisPaintDeviceSP dev = d->node->projection();
     quint8 *data = new quint8[w * h * dev->pixelSize()];
     dev->readBytes(data, x, y, w, h);
     ba = QByteArray((const char*)data, (int)(w * h * dev->pixelSize()));
     delete[] data;
 
     return ba;
 }
 
 void Node::setPixelData(QByteArray value, int x, int y, int w, int h)
 {
     if (!d->node) return;
     KisPaintDeviceSP dev = d->node->paintDevice();
     if (!dev) return;
     dev->writeBytes((const quint8*)value.constData(), x, y, w, h);
 }
 
 QRect Node::bounds() const
 {
     if (!d->node) return QRect();
     return d->node->exactBounds();
 }
 
 void Node::move(int x, int y)
 {
+    // UNIMPLEMENTED
     if (!d->node) return;
 }
 
 void Node::moveToParent(Node *parent)
 {
+    // UNIMPLEMENTED
     if (!d->node) return;
 }
 
 void Node::remove()
 {
+    // UNIMPLEMENTED
     if (!d->node) return;
 }
 
 Node* Node::duplicate()
 {
+    // UNIMPLEMENTED
     if (!d->node) return 0;
     return 0;
 }
 
 bool Node::save(const QString &filename, double xRes, double yRes)
 {
     if (!d->node) return false;
     if (filename.isEmpty()) return false;
 
     KisPaintDeviceSP projection = d->node->projection();
     QRect bounds = d->node->exactBounds();
 
     QString mimefilter = KisMimeDatabase::mimeTypeForFile(filename);;
     QScopedPointer<KisDocument> doc(KisPart::instance()->createDocument());
 
     KisImageSP dst = new KisImage(doc->createUndoStore(),
                                   bounds.width(),
                                   bounds.height(),
                                   projection->compositionSourceColorSpace(),
                                   d->node->name());
     dst->setResolution(xRes, yRes);
     doc->setFileBatchMode(Krita::instance()->batchmode());
     doc->setCurrentImage(dst);
     KisPaintLayer* paintLayer = new KisPaintLayer(dst, "paint device", d->node->opacity());
     paintLayer->paintDevice()->makeCloneFrom(projection, bounds);
     dst->addNode(paintLayer, dst->rootLayer(), KisLayerSP(0));
     dst->initialRefreshGraph();
     doc->setOutputMimeType(mimefilter.toLatin1());
 
     bool r = doc->exportDocument(QUrl::fromLocalFile(filename));
     if (!r) {
         qWarning() << doc->errorMessage();
     }
     return r;
 }
 
 KisPaintDeviceSP Node::paintDevice() const
 {
     return d->node->paintDevice();
 }
 
 KisImageSP Node::image() const
 {
     return d->image;
 }
 
 KisNodeSP Node::node() const
 {
     return d->node;
 }
diff --git a/libs/libkis/Resource.cpp b/libs/libkis/Resource.cpp
index ecb998984e..266b9da0df 100644
--- a/libs/libkis/Resource.cpp
+++ b/libs/libkis/Resource.cpp
@@ -1,68 +1,74 @@
 /*
  *  Copyright (c) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "Resource.h"
 
 struct Resource::Private {
     Private() {}
 };
 
 Resource::Resource(QObject *parent) 
     : QObject(parent)
     , d(new Private)
 {
 }
 
 Resource::~Resource() 
 {
     delete d;
 }
 
 QString Resource::type() const
 {
+    // UNIMPLEMENTED
     return QString();
 }
 
 void Resource::setType(QString value)
 {
+    // UNIMPLEMENTED
 }
 
 
 QString Resource::name() const
 {
+    // UNIMPLEMENTED
     return QString();
 }
 
 void Resource::setName(QString value)
 {
+    // UNIMPLEMENTED
 }
 
 
 QString Resource::filename() const
 {
+    // UNIMPLEMENTED
     return QString();
 }
 
 void Resource::setFilename(QString value)
 {
+    // UNIMPLEMENTED
 }
 
 
 
 
 
 
diff --git a/libs/libkis/Selection.cpp b/libs/libkis/Selection.cpp
index 20ab69dfe6..00c8885cff 100644
--- a/libs/libkis/Selection.cpp
+++ b/libs/libkis/Selection.cpp
@@ -1,236 +1,241 @@
 /*
  *  Copyright (c) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "Selection.h"
 
 #include <kis_selection.h>
 #include <kis_pixel_selection.h>
 #include <kis_paint_device.h>
 #include <kis_selection_filters.h>
 
 #include <QByteArray>
 
 #include <Node.h>
 
 struct Selection::Private {
     Private() {}
     KisSelectionSP selection;
 };
 
 Selection::Selection(KisSelectionSP selection, QObject *parent)
     : QObject(parent)
     , d(new Private)
 {
     d->selection = selection;
 }
 
 
 Selection::Selection(QObject *parent) 
     : QObject(parent)
     , d(new Private)
 {
     d->selection = new KisSelection();
 }
 
 Selection::~Selection() 
 {
     delete d;
 }
 
 int Selection::width() const
 {
     if (!d->selection) return 0;
     return d->selection->selectedExactRect().width();
 }
 
 int Selection::height() const
 {
     if (!d->selection) return 0;
     return d->selection->selectedExactRect().height();
 }
 
 int Selection::x() const
 {
     if (!d->selection) return 0;
     return d->selection->x();
 }
 
 int Selection::y() const
 {
     if (!d->selection) return 0;
-    return 0;
+    return d->selection->y();
 }
 
 void Selection::move(int x, int y)
 {
     if (!d->selection) return;
+    d->selection->pixelSelection()->moveTo(QPoint(x, y));
 }
 
 
 void Selection::clear()
 {
     if (!d->selection) return;
     d->selection->clear();
 }
 
 void Selection::contract(int value)
 {
+    if (!d->selection) return;
+    d->selection->pixelSelection()->select(QRect(x(), y(), w - value, h - value));
 }
 
 void Selection::cut(Node* node)
 {
+    // UNIMPLEMENTED
 }
 
 void Selection::paste(Node *source, Node *destination)
 {
+    // UNIMPLEMENTED
 }
 
 void Selection::erode()
 {
     if (!d->selection) return;
     KisErodeSelectionFilter esf;
     QRect rc = esf.changeRect(d->selection->selectedExactRect());
     esf.process(d->selection->pixelSelection(), rc);
 }
 
 void Selection::dilate()
 {
     if (!d->selection) return;
     KisDilateSelectionFilter dsf;
     QRect rc = dsf.changeRect(d->selection->selectedExactRect());
     dsf.process(d->selection->pixelSelection(), rc);
 }
 
 void Selection::border(int xRadius, int yRadius)
 {
     if (!d->selection) return;
     KisBorderSelectionFilter sf(xRadius, yRadius);
     QRect rc = sf.changeRect(d->selection->selectedExactRect());
     sf.process(d->selection->pixelSelection(), rc);
 }
 
 void Selection::feather(int radius)
 {
     if (!d->selection) return;
     KisFeatherSelectionFilter fsf(radius);
     QRect rc = fsf.changeRect(d->selection->selectedExactRect());
     fsf.process(d->selection->pixelSelection(), rc);
 }
 
 void Selection::grow(int xradius, int yradius)
 {
     if (!d->selection) return;
     KisGrowSelectionFilter gsf(xradius, yradius);
     QRect rc = gsf.changeRect(d->selection->selectedExactRect());
     gsf.process(d->selection->pixelSelection(), rc);
 }
 
 
 void Selection::shrink(int xRadius, int yRadius, bool edgeLock)
 {
     if (!d->selection) return;
     KisShrinkSelectionFilter sf(xRadius, yRadius, edgeLock);
     QRect rc = sf.changeRect(d->selection->selectedExactRect());
     sf.process(d->selection->pixelSelection(), rc);
 }
 
 void Selection::smooth()
 {
     if (!d->selection) return;
     KisSmoothSelectionFilter sf;
     QRect rc = sf.changeRect(d->selection->selectedExactRect());
     sf.process(d->selection->pixelSelection(), rc);
 }
 
 
 void Selection::invert()
 {
     if (!d->selection) return;
     KisInvertSelectionFilter sf;
     QRect rc = sf.changeRect(d->selection->selectedExactRect());
     sf.process(d->selection->pixelSelection(), rc);
 }
 
 void Selection::resize(int w, int h)
 {
     if (!d->selection) return;
     d->selection->pixelSelection()->select(QRect(x(), y(), w, h));
 }
 
 void Selection::select(int x, int y, int w, int h, int value)
 {
     if (!d->selection) return;
     d->selection->pixelSelection()->select(QRect(x, y, w, h), value);
 }
 
 void Selection::selectAll(Node *node, int value)
 {
     if (!d->selection) return;
     d->selection->pixelSelection()->select(node->node()->exactBounds(), value);
 }
 
 void Selection::replace(Selection *selection)
 {
     if (!d->selection) return;
     d->selection->pixelSelection()->applySelection(selection->selection()->pixelSelection(), SELECTION_REPLACE);
 }
 
 void Selection::add(Selection *selection)
 {
     if (!d->selection) return;
     d->selection->pixelSelection()->applySelection(selection->selection()->pixelSelection(), SELECTION_ADD);
 }
 
 void Selection::subtract(Selection *selection)
 {
     if (!d->selection) return;
     d->selection->pixelSelection()->applySelection(selection->selection()->pixelSelection(), SELECTION_SUBTRACT);
 }
 
 void Selection::intersect(Selection *selection)
 {
     if (!d->selection) return;
     d->selection->pixelSelection()->applySelection(selection->selection()->pixelSelection(), SELECTION_INTERSECT);
 }
 
 
 QByteArray Selection::pixelData(int x, int y, int w, int h) const
 {
     QByteArray ba;
     if (!d->selection) return ba;
     KisPaintDeviceSP dev = d->selection->projection();
     quint8 *data = new quint8[w * h];
     dev->readBytes(data, x, y, w, h);
     ba = QByteArray((const char*)data, (int)(w * h));
     delete[] data;
     return ba;
 }
 
 void Selection::setPixelData(QByteArray value, int x, int y, int w, int h)
 {
     if (!d->selection) return;
     KisPixelSelectionSP dev = d->selection->pixelSelection();
     if (!dev) return;
     dev->writeBytes((const quint8*)value.constData(), x, y, w, h);
 }
 
 KisSelectionSP Selection::selection() const
 {
     return d->selection;
 }
 
 
diff --git a/libs/libkis/Transformation.cpp b/libs/libkis/Transformation.cpp
index f250ac9090..5c51f62885 100644
--- a/libs/libkis/Transformation.cpp
+++ b/libs/libkis/Transformation.cpp
@@ -1,48 +1,50 @@
 /*
  *  Copyright (c) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "Transformation.h"
 
 struct Transformation::Private {
     Private() {}
 };
 
 Transformation::Transformation(QObject *parent) 
     : QObject(parent)
     , d(new Private)
 {
 }
 
 Transformation::~Transformation() 
 {
     delete d;
 }
 
 QString Transformation::definition() const
 {
+    // UNIMPLEMENTED
     return QString();
 }
 
 void Transformation::setDefinition(QString value)
 {
+    // UNIMPLEMENTED
 }