diff --git a/krita/image/kis_layer.cc b/krita/image/kis_layer.cc
index 4d60c9d902..29876007c5 100644
--- a/krita/image/kis_layer.cc
+++ b/krita/image/kis_layer.cc
@@ -1,785 +1,795 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2005 C. Boemann <cbo@boemann.dk>
  *  Copyright (c) 2009 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_layer.h"
 
 
 #include <klocale.h>
 #include <QImage>
 #include <QBitArray>
 #include <QStack>
 #include <QMutex>
 #include <QMutexLocker>
 
 #include <KoIcon.h>
 #include <KoProperties.h>
 #include <KoCompositeOpRegistry.h>
 #include <KoColorSpace.h>
 
 #include "kis_debug.h"
 #include "kis_image.h"
 
 #include "kis_painter.h"
 #include "kis_mask.h"
 #include "kis_effect_mask.h"
 #include "kis_selection_mask.h"
 #include "kis_meta_data_store.h"
 #include "kis_selection.h"
 #include "kis_paint_layer.h"
 
 #include "kis_clone_layer.h"
 
 #include "kis_psd_layer_style.h"
 #include "kis_layer_projection_plane.h"
 #include "layerstyles/kis_layer_style_projection_plane.h"
 
 
 class KisSafeProjection {
 public:
     KisPaintDeviceSP getDeviceLazy(KisPaintDeviceSP prototype) {
         QMutexLocker locker(&m_lock);
 
         if (!m_reusablePaintDevice) {
             m_reusablePaintDevice = new KisPaintDevice(*prototype);
         }
         if(!m_projection ||
            !(*m_projection->colorSpace() == *prototype->colorSpace())) {
             m_projection = m_reusablePaintDevice;
             m_projection->makeCloneFromRough(prototype, prototype->extent());
         }
 
         return m_projection;
     }
 
     void freeDevice() {
         QMutexLocker locker(&m_lock);
         m_projection = 0;
         if(m_reusablePaintDevice) {
             m_reusablePaintDevice->clear();
         }
     }
 
 private:
     QMutex m_lock;
     KisPaintDeviceSP m_projection;
     KisPaintDeviceSP m_reusablePaintDevice;
 };
 
 class KisCloneLayersList {
 public:
     void addClone(KisCloneLayerWSP cloneLayer) {
         m_clonesList.append(cloneLayer);
     }
 
     void removeClone(KisCloneLayerWSP cloneLayer) {
         m_clonesList.removeOne(cloneLayer);
     }
 
     void setDirty(const QRect &rect) {
         foreach(KisCloneLayerWSP clone, m_clonesList) {
             clone->setDirtyOriginal(rect);
         }
     }
 
     const QList<KisCloneLayerWSP> registeredClones() const {
         return m_clonesList;
     }
 
     bool hasClones() const {
         return !m_clonesList.isEmpty();
     }
 
 private:
     QList<KisCloneLayerWSP> m_clonesList;
 };
 
 struct KisLayer::Private
 {
     KisImageWSP image;
     QBitArray channelFlags;
     KisMetaData::Store* metaDataStore;
     KisSafeProjection safeProjection;
     KisCloneLayersList clonesList;
 
     KisPSDLayerStyleSP layerStyle;
     KisAbstractProjectionPlaneSP layerStyleProjectionPlane;
 
     KisAbstractProjectionPlaneSP projectionPlane;
 };
 
 
 KisLayer::KisLayer(KisImageWSP image, const QString &name, quint8 opacity)
         : KisNode()
         , m_d(new Private)
 {
     setName(name);
     setOpacity(opacity);
     m_d->image = image;
     m_d->metaDataStore = new KisMetaData::Store();
     m_d->projectionPlane = toQShared(new KisLayerProjectionPlane(this));
 }
 
 KisLayer::KisLayer(const KisLayer& rhs)
         : KisNode(rhs)
         , m_d(new Private())
 {
     if (this != &rhs) {
         m_d->image = rhs.m_d->image;
         m_d->metaDataStore = new KisMetaData::Store(*rhs.m_d->metaDataStore);
 
         setName(rhs.name());
         m_d->projectionPlane = toQShared(new KisLayerProjectionPlane(this));
 
         if (rhs.m_d->layerStyle) {
             setLayerStyle(rhs.m_d->layerStyle->clone());
         }
     }
 }
 
 KisLayer::~KisLayer()
 {
     delete m_d->metaDataStore;
     delete m_d;
 }
 
 const KoColorSpace * KisLayer::colorSpace() const
 {
     if (m_d->image)
         return m_d->image->colorSpace();
     return 0;
 }
 
 const KoCompositeOp * KisLayer::compositeOp() const
 {
     /**
      * FIXME: This function duplicates the same function from
      * KisMask. We can't move it to KisBaseNode as it doesn't
      * know anything about parent() method of KisNode
      * Please think it over...
      */
 
     KisNodeSP parentNode = parent();
     if (!parentNode) return 0;
 
     if (!parentNode->colorSpace()) return 0;
     const KoCompositeOp* op = parentNode->colorSpace()->compositeOp(compositeOpId());
     return op ? op : parentNode->colorSpace()->compositeOp(COMPOSITE_OVER);
 }
 
 KisPSDLayerStyleSP KisLayer::layerStyle() const
 {
     return m_d->layerStyle;
 }
 
 void KisLayer::setLayerStyle(KisPSDLayerStyleSP layerStyle)
 {
     if (layerStyle) {
         m_d->layerStyle = layerStyle;
 
         KisAbstractProjectionPlaneSP plane = !layerStyle->isEmpty() ?
             KisAbstractProjectionPlaneSP(new KisLayerStyleProjectionPlane(this)) :
             KisAbstractProjectionPlaneSP(0);
 
         m_d->layerStyleProjectionPlane = plane;
     } else {
         m_d->layerStyleProjectionPlane.clear();
         m_d->layerStyle.clear();
     }
 }
 
 KisDocumentSectionModel::PropertyList KisLayer::sectionModelProperties() const
 {
     KisDocumentSectionModel::PropertyList l = KisBaseNode::sectionModelProperties();
     l << KisDocumentSectionModel::Property(i18n("Opacity"), i18n("%1%", percentOpacity()));
 
     if (compositeOp()) {
         l << KisDocumentSectionModel::Property(i18n("Composite Mode"), compositeOp()->description());
     }
 
+    if (m_d->layerStyle && !m_d->layerStyle->isEmpty()) {
+        l << KisDocumentSectionModel::Property(i18n("Layer Style"), koIcon("layer-style-enabled"), koIcon("layer-style-disabled"), m_d->layerStyle->isEnabled());
+    }
+
     l << KisDocumentSectionModel::Property(i18n("Inherit Alpha"), koIcon("transparency-disabled"), koIcon("transparency-enabled"), alphaChannelDisabled());
 
     return l;
 }
 
 void KisLayer::setSectionModelProperties(const KisDocumentSectionModel::PropertyList &properties)
 {
     KisBaseNode::setSectionModelProperties(properties);
 
     foreach (const KisDocumentSectionModel::Property &property, properties) {
         if (property.name == i18n("Inherit Alpha")) {
             disableAlphaChannel(property.state.toBool());
         }
+
+        if (property.name == i18n("Layer Style")) {
+            if (m_d->layerStyle) {
+                m_d->layerStyle->setEnabled(property.state.toBool());
+            }
+        }
     }
 }
 
 void KisLayer::disableAlphaChannel(bool disable)
 {
     QBitArray newChannelFlags = m_d->channelFlags;
 
     if(newChannelFlags.isEmpty())
         newChannelFlags = colorSpace()->channelFlags(true, true);
 
     if(disable)
         newChannelFlags &= colorSpace()->channelFlags(true, false);
     else
         newChannelFlags |= colorSpace()->channelFlags(false, true);
 
     setChannelFlags(newChannelFlags);
 }
 
 bool KisLayer::alphaChannelDisabled() const
 {
     QBitArray flags = colorSpace()->channelFlags(false, true) & m_d->channelFlags;
     return flags.count(true) == 0 && !m_d->channelFlags.isEmpty();
 }
 
 
 void KisLayer::setChannelFlags(const QBitArray & channelFlags)
 {
     Q_ASSERT(channelFlags.isEmpty() ||((quint32)channelFlags.count() == colorSpace()->channelCount()));
 
     if (!channelFlags.isEmpty() &&
         channelFlags == QBitArray(channelFlags.size(), true)) {
 
         m_d->channelFlags.clear();
     } else {
         m_d->channelFlags = channelFlags;
     }
 }
 
 QBitArray & KisLayer::channelFlags() const
 {
     return m_d->channelFlags;
 }
 
 bool KisLayer::temporary() const
 {
     return nodeProperties().boolProperty("temporary", false);
 }
 
 void KisLayer::setTemporary(bool t)
 {
     nodeProperties().setProperty("temporary", t);
 }
 
 KisImageWSP KisLayer::image() const
 {
     return m_d->image;
 }
 
 void KisLayer::setImage(KisImageWSP image)
 {
     m_d->image = image;
     for (uint i = 0; i < childCount(); ++i) {
         // Only layers know about the image
         KisLayer * layer = dynamic_cast<KisLayer*>(at(i).data());
         if (layer)
             layer->setImage(image);
     }
 }
 
 KisLayerSP KisLayer::createMergedLayer(KisLayerSP prevLayer)
 {
     KisImageWSP my_image = image();
 
     QRect layerProjectionExtent = this->projection()->extent();
     QRect prevLayerProjectionExtent = prevLayer->projection()->extent();
     bool alphaDisabled = this->alphaChannelDisabled();
     bool prevAlphaDisabled = prevLayer->alphaChannelDisabled();
 
     KisPaintDeviceSP mergedDevice;
 
     if (this->compositeOpId() != prevLayer->compositeOpId() || prevLayer->opacity() != OPACITY_OPAQUE_U8) {
 
         mergedDevice = new KisPaintDevice(this->colorSpace(), "merged");
         KisPainter gc(mergedDevice);
 
         //Copy the pixels of previous layer with their actual alpha value
         prevLayer->disableAlphaChannel(false);
 
         gc.setChannelFlags(prevLayer->channelFlags());
         gc.setCompositeOp(mergedDevice->colorSpace()->compositeOp(prevLayer->compositeOpId()));
         gc.setOpacity(prevLayer->opacity());
 
         gc.bitBlt(prevLayerProjectionExtent.topLeft(), prevLayer->projection(), prevLayerProjectionExtent);
 
         //Restore the previous prevLayer disableAlpha status for correct undo/redo
         prevLayer->disableAlphaChannel(prevAlphaDisabled);
 
         //Paint the pixels of the current layer, using their actual alpha value
         if (alphaDisabled == prevAlphaDisabled) {
             this->disableAlphaChannel(false);
         }
         gc.setChannelFlags(this->channelFlags());
         gc.setCompositeOp(mergedDevice->colorSpace()->compositeOp(this->compositeOpId()));
         gc.setOpacity(this->opacity());
 
         gc.bitBlt(layerProjectionExtent.topLeft(), this->projection(), layerProjectionExtent);
 
         //Restore the layer disableAlpha status for correct undo/redo
         this->disableAlphaChannel(alphaDisabled);
     }
     else {
         //Copy prevLayer
         my_image->lock();
         mergedDevice = new KisPaintDevice(*prevLayer->projection());
         my_image->unlock();
 
         //Paint layer on the copy
         KisPainter gc(mergedDevice);
         if (alphaDisabled == prevAlphaDisabled) {
             this->disableAlphaChannel(false);
         }
         gc.setChannelFlags(this->channelFlags());
         gc.setCompositeOp(mergedDevice->colorSpace()->compositeOp(this->compositeOpId()));
         gc.setOpacity(this->opacity());
 
         gc.bitBlt(layerProjectionExtent.topLeft(), this->projection(), layerProjectionExtent);
 
         //Restore the layer disableAlpha status for correct undo/redo
         this->disableAlphaChannel(alphaDisabled);
     }
 
     return new KisPaintLayer(my_image, prevLayer->name(), OPACITY_OPAQUE_U8, mergedDevice);
 }
 
 void KisLayer::registerClone(KisCloneLayerWSP clone)
 {
     m_d->clonesList.addClone(clone);
 }
 
 void KisLayer::unregisterClone(KisCloneLayerWSP clone)
 {
     m_d->clonesList.removeClone(clone);
 }
 
 const QList<KisCloneLayerWSP> KisLayer::registeredClones() const
 {
     return m_d->clonesList.registeredClones();
 }
 
 bool KisLayer::hasClones() const
 {
     return m_d->clonesList.hasClones();
 }
 
 void KisLayer::updateClones(const QRect &rect)
 {
     m_d->clonesList.setDirty(rect);
 }
 
 KisSelectionMaskSP KisLayer::selectionMask() const
 {
     KoProperties properties;
     properties.setProperty("active", true);
     QList<KisNodeSP> masks = childNodes(QStringList("KisSelectionMask"), properties);
 
     // return the first visible mask
     foreach (KisNodeSP mask, masks) {
         if (mask->visible()) {
             return dynamic_cast<KisSelectionMask*>(mask.data());
         }
     }
     return 0;
 }
 
 KisSelectionSP KisLayer::selection() const
 {
     if (selectionMask()) {
         return selectionMask()->selection();
     }
     else if (m_d->image) {
         return m_d->image->globalSelection();
     }
     else {
         return 0;
     }
 }
 
 ///////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////
 
 QList<KisEffectMaskSP> KisLayer::effectMasks(KisNodeSP lastNode) const
 {
     QList<KisEffectMaskSP> masks;
 
     if (childCount() > 0) {
         KoProperties properties;
         properties.setProperty("visible", true);
         QList<KisNodeSP> nodes = childNodes(QStringList("KisEffectMask"), properties);
 
         foreach(const KisNodeSP& node,  nodes) {
             if (node == lastNode) break;
 
             KisEffectMaskSP mask = dynamic_cast<KisEffectMask*>(const_cast<KisNode*>(node.data()));
             if (mask)
                 masks.append(mask);
         }
     }
     return masks;
 }
 
 bool KisLayer::hasEffectMasks() const
 {
     if (childCount() == 0) return false;
 
     KisNodeSP node = firstChild();
     while (node) {
         if (node->inherits("KisEffectMask") && node->visible()) {
             return true;
         }
         node = node->nextSibling();
     }
 
     return false;
 }
 
 QRect KisLayer::masksChangeRect(const QList<KisEffectMaskSP> &masks,
                                 const QRect &requestedRect,
                                 bool &rectVariesFlag) const
 {
     rectVariesFlag = false;
 
     QRect prevChangeRect = requestedRect;
 
     /**
      * We set default value of the change rect for the case
      * when there is no mask at all
      */
     QRect changeRect = requestedRect;
 
     foreach(const KisEffectMaskSP& mask, masks) {
         changeRect = mask->changeRect(prevChangeRect);
 
         if (changeRect != prevChangeRect)
             rectVariesFlag = true;
 
         prevChangeRect = changeRect;
     }
 
     return changeRect;
 }
 
 QRect KisLayer::masksNeedRect(const QList<KisEffectMaskSP> &masks,
                               const QRect &changeRect,
                               QStack<QRect> &applyRects,
                               bool &rectVariesFlag) const
 {
     rectVariesFlag = false;
 
     QRect prevNeedRect = changeRect;
     QRect needRect;
 
     for (qint32 i = masks.size() - 1; i >= 0; i--) {
         applyRects.push(prevNeedRect);
 
         needRect = masks[i]->needRect(prevNeedRect);
 
         if (prevNeedRect != needRect)
             rectVariesFlag = true;
 
         prevNeedRect = needRect;
     }
 
     return needRect;
 }
 
 KisNode::PositionToFilthy calculatePositionToFilthy(KisNodeSP nodeInQuestion,
                                            KisNodeSP filthy,
                                            KisNodeSP parent)
 {
     if (parent == filthy || parent != filthy->parent()) {
         return KisNode::N_ABOVE_FILTHY;
     }
 
     if (nodeInQuestion == filthy) {
         return KisNode::N_FILTHY;
     }
 
     KisNodeSP node = nodeInQuestion->prevSibling();
     while (node) {
         if (node == filthy) {
             return KisNode::N_ABOVE_FILTHY;
         }
         node = node->prevSibling();
     }
 
     return KisNode::N_BELOW_FILTHY;
 }
 
 QRect KisLayer::applyMasks(const KisPaintDeviceSP source,
                            KisPaintDeviceSP destination,
                            const QRect &requestedRect,
                            KisNodeSP filthyNode,
                            KisNodeSP lastNode) const
 {
     Q_ASSERT(source);
     Q_ASSERT(destination);
 
     QList<KisEffectMaskSP> masks = effectMasks(lastNode);
     QRect changeRect;
     QRect needRect;
 
     if (masks.isEmpty()) {
         changeRect = requestedRect;
         if (source != destination) {
             copyOriginalToProjection(source, destination, requestedRect);
         }
     } else {
         QStack<QRect> applyRects;
         bool changeRectVaries;
         bool needRectVaries;
 
         /**
          * FIXME: Assume that varying of the changeRect has already
          * been taken into account while preparing walkers
          */
         changeRectVaries = false;
         changeRect = requestedRect;
         //changeRect = masksChangeRect(masks, requestedRect,
         //                             changeRectVaries);
 
         needRect = masksNeedRect(masks, changeRect,
                                  applyRects, needRectVaries);
 
         if (!changeRectVaries && !needRectVaries) {
             /**
              * A bit of optimization:
              * All filters will read/write exactly from/to the requested
              * rect so we needn't create temporary paint device,
              * just apply it onto destination
              */
             Q_ASSERT(needRect == requestedRect);
 
             if (source != destination) {
                 copyOriginalToProjection(source, destination, needRect);
             }
 
             foreach(const KisEffectMaskSP& mask, masks) {
                 const QRect maskApplyRect = applyRects.pop();
                 const QRect maskNeedRect =
                     applyRects.isEmpty() ? needRect : applyRects.top();
 
                 PositionToFilthy maskPosition = calculatePositionToFilthy(mask, filthyNode, const_cast<KisLayer*>(this));
                 mask->apply(destination, maskApplyRect, maskNeedRect, maskPosition);
             }
             Q_ASSERT(applyRects.isEmpty());
         } else {
             /**
              * We can't eliminate additional copy-op
              * as filters' behaviour may be quite insane here,
              * so let them work on their own paintDevice =)
              */
 
             KisPaintDeviceSP tempDevice = new KisPaintDevice(colorSpace());
             tempDevice->prepareClone(source);
             copyOriginalToProjection(source, tempDevice, needRect);
 
             QRect maskApplyRect = applyRects.pop();
             QRect maskNeedRect = needRect;
 
             foreach(const KisEffectMaskSP& mask, masks) {
                 PositionToFilthy maskPosition = calculatePositionToFilthy(mask, filthyNode, const_cast<KisLayer*>(this));
                 mask->apply(tempDevice, maskApplyRect, maskNeedRect, maskPosition);
 
                 if (!applyRects.isEmpty()) {
                     maskNeedRect = maskApplyRect;
                     maskApplyRect = applyRects.pop();
                 }
             }
             Q_ASSERT(applyRects.isEmpty());
 
             KisPainter::copyAreaOptimized(changeRect.topLeft(), tempDevice, destination, changeRect);
         }
     }
 
     return changeRect;
 }
 
 QRect KisLayer::updateProjection(const QRect& rect, KisNodeSP filthyNode)
 {
     QRect updatedRect = rect;
     KisPaintDeviceSP originalDevice = original();
     if (!rect.isValid() ||
             !visible() ||
             !originalDevice) return QRect();
 
     if (!needProjection() && !hasEffectMasks()) {
         m_d->safeProjection.freeDevice();
     } else {
 
         if (!updatedRect.isEmpty()) {
             KisPaintDeviceSP projection =
                 m_d->safeProjection.getDeviceLazy(originalDevice);
 
             updatedRect = applyMasks(originalDevice, projection,
                                      updatedRect, filthyNode, 0);
         }
     }
 
     return updatedRect;
 }
 
 QRect KisLayer::partialChangeRect(KisNodeSP lastNode, const QRect& rect)
 {
     bool changeRectVaries = false;
     QRect changeRect = outgoingChangeRect(rect);
     changeRect = masksChangeRect(effectMasks(lastNode), changeRect,
                                  changeRectVaries);
 
     return changeRect;
 }
 
 /**
  * \p rect is a dirty rect in layer's original() coordinates!
  */
 void KisLayer::buildProjectionUpToNode(KisPaintDeviceSP projection, KisNodeSP lastNode, const QRect& rect)
 {
     QRect changeRect = partialChangeRect(lastNode, rect);
 
     KisPaintDeviceSP originalDevice = original();
 
     KIS_ASSERT_RECOVER_RETURN(needProjection() || hasEffectMasks());
 
     if (!changeRect.isEmpty()) {
         applyMasks(originalDevice, projection,
                    changeRect, this, lastNode);
     }
 }
 
 bool KisLayer::needProjection() const
 {
     return false;
 }
 
 void KisLayer::copyOriginalToProjection(const KisPaintDeviceSP original,
                                         KisPaintDeviceSP projection,
                                         const QRect& rect) const
 {
     KisPainter::copyAreaOptimized(rect.topLeft(), original, projection, rect);
 }
 
 KisAbstractProjectionPlaneSP KisLayer::projectionPlane() const
 {
     return m_d->layerStyleProjectionPlane ?
         m_d->layerStyleProjectionPlane : m_d->projectionPlane;
 }
 
 KisAbstractProjectionPlaneSP KisLayer::internalProjectionPlane() const
 {
     return m_d->projectionPlane;
 }
 
 KisPaintDeviceSP KisLayer::projection() const
 {
     KisPaintDeviceSP originalDevice = original();
 
     return needProjection() || hasEffectMasks() ?
         m_d->safeProjection.getDeviceLazy(originalDevice) : originalDevice;
 }
 
 QRect KisLayer::changeRect(const QRect &rect, PositionToFilthy pos) const
 {
     QRect changeRect = rect;
     changeRect = incomingChangeRect(changeRect);
 
     if(pos == KisNode::N_FILTHY) {
         bool changeRectVaries;
         changeRect = outgoingChangeRect(changeRect);
         changeRect = masksChangeRect(effectMasks(), changeRect, changeRectVaries);
     }
 
     // TODO: string comparizon: optimize!
     if (pos != KisNode::N_FILTHY &&
         pos != KisNode::N_FILTHY_PROJECTION &&
         compositeOpId() != COMPOSITE_COPY) {
 
         changeRect |= rect;
     }
 
     return changeRect;
 }
 
 QRect KisLayer::incomingChangeRect(const QRect &rect) const
 {
     return rect;
 }
 
 QRect KisLayer::outgoingChangeRect(const QRect &rect) const
 {
     return rect;
 }
 
 QImage KisLayer::createThumbnail(qint32 w, qint32 h)
 {
     KisPaintDeviceSP originalDevice = original();
 
     return originalDevice ?
            originalDevice->createThumbnail(w, h,
                                            KoColorConversionTransformation::InternalRenderingIntent,
                                            KoColorConversionTransformation::InternalConversionFlags) : QImage();
 }
 
 qint32 KisLayer::x() const
 {
     KisPaintDeviceSP originalDevice = original();
     return originalDevice ? originalDevice->x() : 0;
 }
 qint32 KisLayer::y() const
 {
     KisPaintDeviceSP originalDevice = original();
     return originalDevice ? originalDevice->y() : 0;
 }
 void KisLayer::setX(qint32 x)
 {
     KisPaintDeviceSP originalDevice = original();
     if (originalDevice)
         originalDevice->setX(x);
 }
 void KisLayer::setY(qint32 y)
 {
     KisPaintDeviceSP originalDevice = original();
     if (originalDevice)
         originalDevice->setY(y);
 }
 
 QRect KisLayer::extent() const
 {
     KisPaintDeviceSP originalDevice = original();
     return originalDevice ? originalDevice->extent() : QRect();
 }
 
 QRect KisLayer::exactBounds() const
 {
     KisPaintDeviceSP originalDevice = original();
     return originalDevice ? originalDevice->exactBounds() : QRect();
 }
 
 KisLayerSP KisLayer::parentLayer() const
 {
     return dynamic_cast<KisLayer*>(parent().data());
 }
 
 KisMetaData::Store* KisLayer::metaData()
 {
     return m_d->metaDataStore;
 }
 
 #include "kis_layer.moc"
diff --git a/krita/image/kis_psd_layer_style.cpp b/krita/image/kis_psd_layer_style.cpp
index 5d9c499ca4..81c4ca4865 100644
--- a/krita/image/kis_psd_layer_style.cpp
+++ b/krita/image/kis_psd_layer_style.cpp
@@ -1,292 +1,297 @@
 /*
  *  Copyright (c) 2014 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "kis_psd_layer_style.h"
 
 #include <QIODevice>
 #include <QUuid>
 
 #include <psd.h>
 #include <psd_utils.h>
 
 #include <klocale.h>
 
 #include "kis_global.h"
 
 
 struct KisPSDLayerStyle::Private
 {
     Private()
         : version(-1)
-        , effects_count(0)
-        , visible(false)
+        , effectEnabled(true)
     {}
 
     Private(const Private &rhs)
         : name(rhs.name),
           uuid(rhs.uuid),
           version(rhs.version),
-          effects_count(rhs.effects_count),
-          visible(rhs.visible),
+          effectEnabled(rhs.effectEnabled),
           context(rhs.context),
           drop_shadow(rhs.drop_shadow),
           inner_shadow(rhs.inner_shadow),
           outer_glow(rhs.outer_glow),
           inner_glow(rhs.inner_glow),
           bevel_emboss(rhs.bevel_emboss),
           satin(rhs.satin),
           color_overlay(rhs.color_overlay),
           gradient_overlay(rhs.gradient_overlay),
           pattern_overlay(rhs.pattern_overlay),
           stroke(rhs.stroke)
     {}
 
     Private operator=(const Private &rhs)
     {
         if (this != &rhs) {
             name = rhs.name;
             uuid = rhs.uuid;
             version = rhs.version;
-            effects_count = rhs.effects_count;
-            visible = rhs.visible;
+            effectEnabled = rhs.effectEnabled;
             context = rhs.context;
             drop_shadow = rhs.drop_shadow;
             inner_shadow = rhs.inner_shadow;
             outer_glow = rhs.outer_glow;
             inner_glow = rhs.inner_glow;
             bevel_emboss = rhs.bevel_emboss;
             satin = rhs.satin;
             color_overlay = rhs.color_overlay;
             gradient_overlay = rhs.gradient_overlay;
             pattern_overlay = rhs.pattern_overlay;
             stroke = rhs.stroke;
         }
 
         return *this;
     }
 
     QString name;
     QUuid uuid;
     quint16 version;
-    quint8 effects_count; // Effects count: may be 6 (for the 6 effects in Photoshop 5 and 6) or 7 (for Photoshop 7.0)
-    bool visible; // common state info, visible: always true
+    bool effectEnabled;
     psd_layer_effects_context context;
     psd_layer_effects_drop_shadow drop_shadow;
     psd_layer_effects_inner_shadow inner_shadow;
     psd_layer_effects_outer_glow outer_glow;
     psd_layer_effects_inner_glow inner_glow;
     psd_layer_effects_bevel_emboss bevel_emboss;
     psd_layer_effects_satin satin;
     psd_layer_effects_color_overlay color_overlay;
     psd_layer_effects_gradient_overlay gradient_overlay;
     psd_layer_effects_pattern_overlay pattern_overlay;
     psd_layer_effects_stroke stroke;
 };
 
 KisPSDLayerStyle::KisPSDLayerStyle()
     : d(new Private())
 {
     d->name = i18n("Unnamed");
     d->version = 7;
-    d->visible = true;
 }
 
 KisPSDLayerStyle::~KisPSDLayerStyle()
 {
     delete d;
 }
 
 KisPSDLayerStyle::KisPSDLayerStyle(const KisPSDLayerStyle &rhs)
     : d(new Private(*rhs.d))
 {
 }
 
 KisPSDLayerStyle KisPSDLayerStyle::operator=(const KisPSDLayerStyle &rhs)
 {
     if (this != &rhs) {
         *d = *rhs.d;
     }
     return *this;
 }
 
+bool KisPSDLayerStyle::isEnabled() const
+{
+    return d->effectEnabled;
+}
+
+void KisPSDLayerStyle::setEnabled(bool value)
+{
+    d->effectEnabled = value;
+}
+
 KisPSDLayerStyleSP KisPSDLayerStyle::clone() const
 {
     return toQShared(new KisPSDLayerStyle(*this));
 }
 
 void KisPSDLayerStyle::clear()
 {
     *d = Private();
 }
 
 bool KisPSDLayerStyle::isEmpty() const
 {
     return !(d->drop_shadow.effectEnabled() ||
              d->inner_shadow.effectEnabled() ||
              d->outer_glow.effectEnabled() ||
              d->inner_glow.effectEnabled() ||
              d->bevel_emboss.effectEnabled() ||
              d->satin.effectEnabled() ||
              d->color_overlay.effectEnabled() ||
              d->gradient_overlay.effectEnabled() ||
              d->pattern_overlay.effectEnabled() ||
              d->stroke.effectEnabled());
 }
 
 QString KisPSDLayerStyle::name() const
 {
     return d->name;
 }
 
 void KisPSDLayerStyle::setName(const QString &value)
 {
     d->name = value;
 }
 
 QUuid KisPSDLayerStyle::uuid() const
 {
     if (d->uuid.isNull()) {
         d->uuid = QUuid::createUuid();
     }
 
     return d->uuid;
 }
 
 void KisPSDLayerStyle::setUuid(const QUuid &value) const
 {
     d->uuid = value;
 }
 
 QString KisPSDLayerStyle::psdUuid() const
 {
     return uuid().toString().mid(1, 36);
 }
 
 void KisPSDLayerStyle::setPsdUuid(const QString &value) const
 {
     setUuid(QUuid(QString("{%1}").arg(value)));
 }
 
 const psd_layer_effects_context* KisPSDLayerStyle::context() const
 {
     return &d->context;
 }
 
 const psd_layer_effects_drop_shadow* KisPSDLayerStyle::dropShadow() const
 {
     return &d->drop_shadow;
 }
 
 const psd_layer_effects_inner_shadow* KisPSDLayerStyle::innerShadow() const
 {
     return &d->inner_shadow;
 }
 
 const psd_layer_effects_outer_glow* KisPSDLayerStyle::outerGlow() const
 {
     return &d->outer_glow;
 }
 
 const psd_layer_effects_inner_glow* KisPSDLayerStyle::innerGlow() const
 {
     return &d->inner_glow;
 }
 
 const psd_layer_effects_satin* KisPSDLayerStyle::satin() const
 {
     return &d->satin;
 }
 
 const psd_layer_effects_color_overlay* KisPSDLayerStyle::colorOverlay() const
 {
     return &d->color_overlay;
 }
 
 const psd_layer_effects_gradient_overlay* KisPSDLayerStyle::gradientOverlay() const
 {
     return &d->gradient_overlay;
 }
 
 const psd_layer_effects_pattern_overlay* KisPSDLayerStyle::patternOverlay() const
 {
     return &d->pattern_overlay;
 }
 
 const psd_layer_effects_stroke* KisPSDLayerStyle::stroke() const
 {
     return &d->stroke;
 }
 
 const psd_layer_effects_bevel_emboss* KisPSDLayerStyle::bevelAndEmboss() const
 {
     return &d->bevel_emboss;
 }
 
 psd_layer_effects_context* KisPSDLayerStyle::context()
 {
     return &d->context;
 }
 
 psd_layer_effects_drop_shadow* KisPSDLayerStyle::dropShadow()
 {
     return &d->drop_shadow;
 }
 
 psd_layer_effects_inner_shadow* KisPSDLayerStyle::innerShadow()
 {
     return &d->inner_shadow;
 }
 
 psd_layer_effects_outer_glow* KisPSDLayerStyle::outerGlow()
 {
     return &d->outer_glow;
 }
 
 psd_layer_effects_inner_glow* KisPSDLayerStyle::innerGlow()
 {
     return &d->inner_glow;
 }
 
 psd_layer_effects_satin* KisPSDLayerStyle::satin()
 {
     return &d->satin;
 }
 
 psd_layer_effects_color_overlay* KisPSDLayerStyle::colorOverlay()
 {
     return &d->color_overlay;
 }
 
 psd_layer_effects_gradient_overlay* KisPSDLayerStyle::gradientOverlay()
 {
     return &d->gradient_overlay;
 }
 
 psd_layer_effects_pattern_overlay* KisPSDLayerStyle::patternOverlay()
 {
     return &d->pattern_overlay;
 }
 
 psd_layer_effects_stroke* KisPSDLayerStyle::stroke()
 {
     return &d->stroke;
 }
 
 psd_layer_effects_bevel_emboss* KisPSDLayerStyle::bevelAndEmboss()
 {
     return &d->bevel_emboss;
 }
diff --git a/krita/image/kis_psd_layer_style.h b/krita/image/kis_psd_layer_style.h
index 78c3107787..07215df3dc 100644
--- a/krita/image/kis_psd_layer_style.h
+++ b/krita/image/kis_psd_layer_style.h
@@ -1,95 +1,98 @@
 /*
  *  Copyright (c) 2014 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef KIS_PSD_LAYER_STYLE_H
 #define KIS_PSD_LAYER_STYLE_H
 
 class QIODevice;
 struct QUuid;
 
 #include <QVector>
 
 #include <psd.h>
 
 #include "kis_types.h"
 #include "krita_export.h"
 
 
 /**
  * @brief The KisPSDLayerStyle class implements loading, saving and applying
  * the PSD layer effects.
  *
  * See http://www.tonton-pixel.com/Photoshop%20Additional%20File%20Formats/styles-file-format.html
  *
  */
 class KRITAIMAGE_EXPORT KisPSDLayerStyle
 {
 
 public:
     explicit KisPSDLayerStyle();
     virtual ~KisPSDLayerStyle();
     KisPSDLayerStyle(const KisPSDLayerStyle& rhs);
     KisPSDLayerStyle operator=(const KisPSDLayerStyle& rhs);
 
     KisPSDLayerStyleSP clone() const;
 
     void clear();
 
     QString name() const;
     void setName(const QString &value);
 
     QUuid uuid() const;
     void setUuid(const QUuid &value) const;
 
     QString psdUuid() const;
     void setPsdUuid(const QString &value) const;
 
     /**
      * \return true if all the styles are disabled
      */
     bool isEmpty() const;
 
+    bool isEnabled() const;
+    void setEnabled(bool value);
+
     const psd_layer_effects_context* context() const;
     const psd_layer_effects_drop_shadow* dropShadow() const;
     const psd_layer_effects_inner_shadow* innerShadow() const;
     const psd_layer_effects_outer_glow* outerGlow() const;
     const psd_layer_effects_inner_glow* innerGlow() const;
     const psd_layer_effects_satin* satin() const;
     const psd_layer_effects_color_overlay* colorOverlay() const;
     const psd_layer_effects_gradient_overlay* gradientOverlay() const;
     const psd_layer_effects_pattern_overlay* patternOverlay() const;
     const psd_layer_effects_stroke* stroke() const;
     const psd_layer_effects_bevel_emboss* bevelAndEmboss() const;
 
     psd_layer_effects_context* context();
     psd_layer_effects_drop_shadow* dropShadow();
     psd_layer_effects_inner_shadow* innerShadow();
     psd_layer_effects_outer_glow* outerGlow();
     psd_layer_effects_inner_glow* innerGlow();
     psd_layer_effects_satin* satin();
     psd_layer_effects_color_overlay* colorOverlay();
     psd_layer_effects_gradient_overlay* gradientOverlay();
     psd_layer_effects_pattern_overlay* patternOverlay();
     psd_layer_effects_stroke* stroke();
     psd_layer_effects_bevel_emboss* bevelAndEmboss();
 
 private:
     struct Private;
     Private * const d;
 };
 
 #endif // KIS_PSD_LAYER_STYLE_H
diff --git a/krita/image/layerstyles/kis_layer_style_projection_plane.cpp b/krita/image/layerstyles/kis_layer_style_projection_plane.cpp
index 1ab226632b..b6ccf32203 100644
--- a/krita/image/layerstyles/kis_layer_style_projection_plane.cpp
+++ b/krita/image/layerstyles/kis_layer_style_projection_plane.cpp
@@ -1,202 +1,212 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_layer_style_projection_plane.h"
 
 #include "kis_layer_style_filter_projection_plane.h"
 #include "kis_psd_layer_style.h"
 
 #include "kis_ls_drop_shadow_filter.h"
 #include "kis_ls_satin_filter.h"
 #include "kis_ls_overlay_filter.h"
 #include "kis_ls_stroke_filter.h"
 #include "kis_ls_bevel_emboss_filter.h"
 
 
 struct KisLayerStyleProjectionPlane::Private
 {
     KisAbstractProjectionPlaneWSP sourceProjectionPlane;
 
     QVector<KisAbstractProjectionPlaneSP> stylesBefore;
     QVector<KisAbstractProjectionPlaneSP> stylesAfter;
 
+    KisPSDLayerStyleSP style;
 };
 
 KisLayerStyleProjectionPlane::KisLayerStyleProjectionPlane(KisLayer *sourceLayer)
     : m_d(new Private)
 {
     KisPSDLayerStyleSP style = sourceLayer->layerStyle();
 
     KIS_ASSERT_RECOVER(style) {
         style = toQShared(new KisPSDLayerStyle());
     }
 
     init(sourceLayer, style);
 }
 
 // for testing purposes only!
 KisLayerStyleProjectionPlane::KisLayerStyleProjectionPlane(KisLayer *sourceLayer, KisPSDLayerStyleSP layerStyle)
     : m_d(new Private)
 {
     init(sourceLayer, layerStyle);
 }
 
 void KisLayerStyleProjectionPlane::init(KisLayer *sourceLayer, KisPSDLayerStyleSP style)
 {
     m_d->sourceProjectionPlane = sourceLayer->internalProjectionPlane();
+    m_d->style = style;
 
     {
         KisLayerStyleFilterProjectionPlane *dropShadow =
             new KisLayerStyleFilterProjectionPlane(sourceLayer);
         dropShadow->setStyle(new KisLsDropShadowFilter(KisLsDropShadowFilter::DropShadow), style);
         m_d->stylesBefore << toQShared(dropShadow);
     }
 
     {
         KisLayerStyleFilterProjectionPlane *innerShadow =
             new KisLayerStyleFilterProjectionPlane(sourceLayer);
         innerShadow->setStyle(new KisLsDropShadowFilter(KisLsDropShadowFilter::InnerShadow), style);
         m_d->stylesAfter << toQShared(innerShadow);
     }
 
     {
         KisLayerStyleFilterProjectionPlane *outerGlow =
             new KisLayerStyleFilterProjectionPlane(sourceLayer);
         outerGlow->setStyle(new KisLsDropShadowFilter(KisLsDropShadowFilter::OuterGlow), style);
         m_d->stylesAfter << toQShared(outerGlow);
     }
 
     {
         KisLayerStyleFilterProjectionPlane *innerGlow =
             new KisLayerStyleFilterProjectionPlane(sourceLayer);
         innerGlow->setStyle(new KisLsDropShadowFilter(KisLsDropShadowFilter::InnerGlow), style);
         m_d->stylesAfter << toQShared(innerGlow);
     }
 
     {
         KisLayerStyleFilterProjectionPlane *satin =
             new KisLayerStyleFilterProjectionPlane(sourceLayer);
         satin->setStyle(new KisLsSatinFilter(), style);
         m_d->stylesAfter << toQShared(satin);
     }
 
     {
         KisLayerStyleFilterProjectionPlane *colorOverlay =
             new KisLayerStyleFilterProjectionPlane(sourceLayer);
         colorOverlay->setStyle(new KisLsOverlayFilter(KisLsOverlayFilter::Color), style);
         m_d->stylesAfter << toQShared(colorOverlay);
     }
 
     {
         KisLayerStyleFilterProjectionPlane *gradientOverlay =
             new KisLayerStyleFilterProjectionPlane(sourceLayer);
         gradientOverlay->setStyle(new KisLsOverlayFilter(KisLsOverlayFilter::Gradient), style);
         m_d->stylesAfter << toQShared(gradientOverlay);
     }
 
     {
         KisLayerStyleFilterProjectionPlane *patternOverlay =
             new KisLayerStyleFilterProjectionPlane(sourceLayer);
         patternOverlay->setStyle(new KisLsOverlayFilter(KisLsOverlayFilter::Pattern), style);
         m_d->stylesAfter << toQShared(patternOverlay);
     }
 
     {
         KisLayerStyleFilterProjectionPlane *stroke =
             new KisLayerStyleFilterProjectionPlane(sourceLayer);
         stroke->setStyle(new KisLsStrokeFilter(), style);
         m_d->stylesAfter << toQShared(stroke);
     }
 
     {
         KisLayerStyleFilterProjectionPlane *bevelEmboss =
             new KisLayerStyleFilterProjectionPlane(sourceLayer);
         bevelEmboss->setStyle(new KisLsBevelEmbossFilter(), style);
         m_d->stylesAfter << toQShared(bevelEmboss);
     }
 }
 
 KisLayerStyleProjectionPlane::~KisLayerStyleProjectionPlane()
 {
 }
 
 KisAbstractProjectionPlaneSP KisLayerStyleProjectionPlane::factoryObject(KisLayer *sourceLayer)
 {
     return toQShared(new KisLayerStyleProjectionPlane(sourceLayer));
 }
 
 QRect KisLayerStyleProjectionPlane::recalculate(const QRect& rect, KisNodeSP filthyNode)
 {
     KisAbstractProjectionPlaneSP sourcePlane = m_d->sourceProjectionPlane.toStrongRef();
     return sourcePlane->recalculate(rect, filthyNode);
 }
 
 void KisLayerStyleProjectionPlane::apply(KisPainter *painter, const QRect &rect)
 {
     KisAbstractProjectionPlaneSP sourcePlane = m_d->sourceProjectionPlane.toStrongRef();
 
-    foreach (const KisAbstractProjectionPlaneSP plane, m_d->stylesBefore) {
-        plane->apply(painter, rect);
-    }
+    if (m_d->style->isEnabled()) {
+        foreach (const KisAbstractProjectionPlaneSP plane, m_d->stylesBefore) {
+            plane->apply(painter, rect);
+        }
 
-    sourcePlane->apply(painter, rect);
+        sourcePlane->apply(painter, rect);
 
-    foreach (const KisAbstractProjectionPlaneSP plane, m_d->stylesAfter) {
-        plane->apply(painter, rect);
+        foreach (const KisAbstractProjectionPlaneSP plane, m_d->stylesAfter) {
+            plane->apply(painter, rect);
+        }
+    } else {
+        sourcePlane->apply(painter, rect);
     }
 }
 
 QRect KisLayerStyleProjectionPlane::needRect(const QRect &rect, KisLayer::PositionToFilthy pos) const
 {
     KisAbstractProjectionPlaneSP sourcePlane = m_d->sourceProjectionPlane.toStrongRef();
     return sourcePlane->needRect(rect, pos);
 }
 
 QRect KisLayerStyleProjectionPlane::changeRect(const QRect &rect, KisLayer::PositionToFilthy pos) const
 {
     KisAbstractProjectionPlaneSP sourcePlane = m_d->sourceProjectionPlane.toStrongRef();
     QRect layerChangeRect = sourcePlane->changeRect(rect, pos);
     QRect changeRect = layerChangeRect;
 
-    foreach (const KisAbstractProjectionPlaneSP plane, m_d->stylesBefore) {
-        changeRect |= plane->changeRect(layerChangeRect, KisLayer::N_ABOVE_FILTHY);
-    }
+    if (m_d->style->isEnabled()) {
+        foreach (const KisAbstractProjectionPlaneSP plane, m_d->stylesBefore) {
+            changeRect |= plane->changeRect(layerChangeRect, KisLayer::N_ABOVE_FILTHY);
+        }
 
-    foreach (const KisAbstractProjectionPlaneSP plane, m_d->stylesAfter) {
-        changeRect |= plane->changeRect(layerChangeRect, KisLayer::N_ABOVE_FILTHY);
+        foreach (const KisAbstractProjectionPlaneSP plane, m_d->stylesAfter) {
+            changeRect |= plane->changeRect(layerChangeRect, KisLayer::N_ABOVE_FILTHY);
+        }
     }
 
     return changeRect;
 }
 
 QRect KisLayerStyleProjectionPlane::accessRect(const QRect &rect, KisLayer::PositionToFilthy pos) const
 {
     KisAbstractProjectionPlaneSP sourcePlane = m_d->sourceProjectionPlane.toStrongRef();
     QRect accessRect = sourcePlane->accessRect(rect, pos);
 
-    foreach (const KisAbstractProjectionPlaneSP plane, m_d->stylesBefore) {
-        accessRect |= plane->accessRect(rect, KisLayer::N_ABOVE_FILTHY);
-    }
+    if (m_d->style->isEnabled()) {
+        foreach (const KisAbstractProjectionPlaneSP plane, m_d->stylesBefore) {
+            accessRect |= plane->accessRect(rect, KisLayer::N_ABOVE_FILTHY);
+        }
 
-    foreach (const KisAbstractProjectionPlaneSP plane, m_d->stylesAfter) {
-        accessRect |= plane->accessRect(rect, KisLayer::N_ABOVE_FILTHY);
+        foreach (const KisAbstractProjectionPlaneSP plane, m_d->stylesAfter) {
+            accessRect |= plane->accessRect(rect, KisLayer::N_ABOVE_FILTHY);
+        }
     }
 
     return accessRect;
 }
 
diff --git a/krita/pics/CMakeLists.txt b/krita/pics/CMakeLists.txt
index 1f26afea8e..5ca6b3cb8a 100644
--- a/krita/pics/CMakeLists.txt
+++ b/krita/pics/CMakeLists.txt
@@ -1,147 +1,149 @@
 install(FILES  
 AboutKrita.png
 addlayer.png
 addtofolder.png
 arrow-down.png
 arrow-right.png
 arrowdown.png
 arrowupblr.png
 broken-preset.png
 deletelayer.png
 delete.png
 eraser-toggle.png
 duplicatelayer.png
 folder.png
 height_icon.png
 height.png
 hi16-add_dialog.png
 hi16-palette_library.png
 icon-kritasketch-256.png
 landscape.png
 linked.png
 linked2.png
 local_selection_active.png
 local_selection_inactive.png
 locked.png
 newlayer.png
 novisible.png
 offset_horizontal.png
 offset_vertical.png
 paintop_presets_disabled.png
 paintop_settings_01.png
 paintop_settings_02.png
 paintop_settings_disabled.png
 portrait.png
 ratio_icon.png
 removefromfolder.png
 reload_preset.png
 selection_add.png
 selection_exclude.png
 selection_intersect.png
 selection_replace.png
 selection_subtract.png
 select_pixel.png
 select_shape.png
 shade.png
 shear_horizontal.png
 shear_vertical.png
 sidebaricon.png
 tablet.png
 tool_screenshot.png
 transparency-disabled.png
 transparency-enabled.png
 transparency-locked.png
 transparency-unlocked.png
 passthrough-enabled.png
 passthrough-disabled.png
+layer-style-enabled.png
+layer-style-disabled.png
 unlinked.png
 unlocked.png
 visible.png
 white128-krita.png
 white16-krita.png
 white22-krita.png
 white256-krita.png
 white32-krita.png
 white48-krita.png
 white64-krita.png
 width_icon.png
 width.png
 workspace-chooser.png
 onionA.png
 onionB.png
 mirrorAxis-HorizontalMove.png
 mirrorAxis-VerticalMove.png
 
 
 dark_select.png
 dark_pattern.png
 dark_calligraphy.png
 dark_format-fill-color.png
 dark_addlayer.png
 dark_deletelayer.png
 dark_duplicatelayer.png
 dark_arrowdown.png
 dark_arrowupblr.png
 dark_addtofolder.png
 dark_removefromfolder.png
 dark_properties.png
 dark_selection-mode_ants.png
 dark_selection-mode_invisible.png
 dark_selection-mode_mask.png
 dark_symmetry-horizontal.png
 dark_symmetry-vertical.png
 dark_krita_tool_editpath.png
 
 
 light_select.png
 light_pattern.png
 light_calligraphy.png
 light_format-fill-color.png
 light_addlayer.png
 light_deletelayer.png
 light_duplicatelayer.png
 light_arrowdown.png
 light_arrowupblr.png
 light_addtofolder.png
 light_removefromfolder.png
 light_properties.png
 light_selection-mode_ants.png
 light_selection-mode_invisible.png
 light_selection-mode_mask.png
 light_symmetry-vertical.png
 light_symmetry-horizontal.png
 light_krita_tool_editpath.png
 
 
 
 tool_transform/dark_transform_icons_cage.png
 tool_transform/dark_transform_icons_liquify_erase.png
 tool_transform/dark_transform_icons_liquify_main.png
 tool_transform/dark_transform_icons_liquify_move.png
 tool_transform/dark_transform_icons_liquify_offset.png
 tool_transform/dark_transform_icons_liquify_resize.png
 tool_transform/dark_transform_icons_liquify_rotate.png
 tool_transform/dark_transform_icons_liquify_rotateCCW.png
 tool_transform/dark_transform_icons_main.png
 tool_transform/dark_transform_icons_perspective.png
 tool_transform/dark_transform_icons_warp.png
 tool_transform/dark_transform_icons_penPressure.png
 
 tool_transform/light_transform_icons_cage.png
 tool_transform/light_transform_icons_liquify_erase.png
 tool_transform/light_transform_icons_liquify_main.png
 tool_transform/light_transform_icons_liquify_move.png
 tool_transform/light_transform_icons_liquify_offset.png
 tool_transform/light_transform_icons_liquify_resize.png
 tool_transform/light_transform_icons_liquify_rotate.png
 tool_transform/light_transform_icons_liquify_rotateCCW.png
 tool_transform/light_transform_icons_main.png
 tool_transform/light_transform_icons_perspective.png
 tool_transform/light_transform_icons_warp.png
 tool_transform/light_transform_icons_penPressure.png
 
 DESTINATION ${DATA_INSTALL_DIR}/krita/pics)
 
 add_subdirectory(app)
 
 
diff --git a/krita/pics/layer-style-disabled.png b/krita/pics/layer-style-disabled.png
new file mode 100644
index 0000000000..fc9ecdacfd
Binary files /dev/null and b/krita/pics/layer-style-disabled.png differ
diff --git a/krita/pics/layer-style-enabled.png b/krita/pics/layer-style-enabled.png
new file mode 100644
index 0000000000..87cfc5ce40
Binary files /dev/null and b/krita/pics/layer-style-enabled.png differ
diff --git a/krita/plugins/extensions/dockers/defaultdockers/kis_layer_box.cpp b/krita/plugins/extensions/dockers/defaultdockers/kis_layer_box.cpp
index 36155fad7e..e89acddcd5 100644
--- a/krita/plugins/extensions/dockers/defaultdockers/kis_layer_box.cpp
+++ b/krita/plugins/extensions/dockers/defaultdockers/kis_layer_box.cpp
@@ -1,794 +1,796 @@
 /*
  *  kis_layer_box.cc - part of Krita aka Krayon aka KimageShop
  *
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (C) 2006 Gábor Lehel <illissius@gmail.com>
  *  Copyright (C) 2007 Thomas Zander <zander@kde.org>
  *  Copyright (C) 2007 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2011 José Luis Vergara <pentalis@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_layer_box.h"
 
 
 #include <QToolButton>
 #include <QLayout>
 #include <QMouseEvent>
 #include <QPainter>
 #include <QPoint>
 #include <QRect>
 #include <QString>
 #include <QToolTip>
 #include <QWidget>
 #include <QComboBox>
 #include <QCheckBox>
 #include <QVBoxLayout>
 #include <QPixmap>
 #include <QList>
 #include <QVector>
 #include <QLabel>
 
 #include <kis_debug.h>
 #include <kmenu.h>
 #include <klocale.h>
 
 #include <KoIcon.h>
 #include <KisDocumentSectionView.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOpRegistry.h>
 #include <KisDocument.h>
 
 #include <kis_types.h>
 #include <kis_image.h>
 #include <kis_paint_device.h>
 #include <kis_layer.h>
 #include <kis_group_layer.h>
 #include <kis_mask.h>
 #include <kis_node.h>
 #include <kis_composite_ops_model.h>
 
 #include "kis_action.h"
 #include "kis_action_manager.h"
 #include "widgets/kis_cmb_composite.h"
 #include "widgets/kis_slider_spin_box.h"
 #include "KisViewManager.h"
 #include "kis_node_manager.h"
 #include "kis_node_model.h"
 #include "canvas/kis_canvas2.h"
 #include "KisDocument.h"
 #include "kis_dummies_facade_base.h"
 #include "kis_shape_controller.h"
 #include "kis_selection_mask.h"
 #include "kis_config.h"
 #include "KisView.h"
 
 #include "ui_wdglayerbox.h"
 
 class ButtonAction : public KisAction
 {
 public:
     ButtonAction(QAbstractButton* button, const KIcon& icon, const QString& text, QObject* parent)
         : KisAction(icon, text, parent)
         , m_button(button)
     {
         connect(m_button, SIGNAL(clicked()), this, SLOT(trigger()));
     }
 
     ButtonAction(QAbstractButton* button, QObject* parent) : KisAction(parent) , m_button(button)
     {
         connect(m_button, SIGNAL(clicked()), this, SLOT(trigger()));
     }
 
     virtual void setActionEnabled(bool enabled) {
         KisAction::setActionEnabled(enabled);
         m_button->setEnabled(enabled);
     }
 private:
     QAbstractButton* m_button;
 };
 
 inline void KisLayerBox::connectActionToButton(KisViewManager* view, QAbstractButton *button, const QString &id)
 {
     Q_ASSERT(view);
     KisAction *action = view->actionManager()->actionByName(id);
 
     connect(button, SIGNAL(clicked()), action, SLOT(trigger()));
     connect(action, SIGNAL(sigEnableSlaves(bool)), button, SLOT(setEnabled(bool)));
 }
 
 inline void KisLayerBox::addActionToMenu(QMenu *menu, const QString &id)
 {
     Q_ASSERT(m_canvas);
     menu->addAction(m_canvas->viewManager()->actionManager()->actionByName(id));
 }
 
 KisLayerBox::KisLayerBox()
         : QDockWidget(i18n("Layers"))
         , m_canvas(0)
         , m_wdgLayerBox(new Ui_WdgLayerBox)
 {
     KisConfig cfg;
 
     setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
 
     QWidget* mainWidget = new QWidget(this);
     setWidget(mainWidget);
     m_opacityDelayTimer.setSingleShot(true);
 
     m_wdgLayerBox->setupUi(mainWidget);
 
     m_wdgLayerBox->listLayers->setDefaultDropAction(Qt::MoveAction);
     m_wdgLayerBox->listLayers->setSelectionMode(QAbstractItemView::ExtendedSelection);
     m_wdgLayerBox->listLayers->setVerticalScrollMode(QAbstractItemView::ScrollPerItem);
     m_wdgLayerBox->listLayers->setSelectionBehavior(QAbstractItemView::SelectRows);
 
     connect(m_wdgLayerBox->listLayers, SIGNAL(contextMenuRequested(const QPoint&, const QModelIndex&)),
             this, SLOT(slotContextMenuRequested(const QPoint&, const QModelIndex&)));
     connect(m_wdgLayerBox->listLayers, SIGNAL(collapsed(const QModelIndex&)), SLOT(slotCollapsed(const QModelIndex &)));
     connect(m_wdgLayerBox->listLayers, SIGNAL(expanded(const QModelIndex&)), SLOT(slotExpanded(const QModelIndex &)));
     connect(m_wdgLayerBox->listLayers, SIGNAL(selectionChanged(const QModelIndexList&)), SLOT(selectionChanged(const QModelIndexList&)));
 
     m_viewModeMenu = new KMenu(this);
     QActionGroup *group = new QActionGroup(this);
     QList<QAction*> actions;
 
     actions << m_viewModeMenu->addAction(koIcon("view-list-text"),
                                          i18n("Minimal View"), this, SLOT(slotMinimalView()));
     actions << m_viewModeMenu->addAction(koIcon("view-list-details"),
                                          i18n("Detailed View"), this, SLOT(slotDetailedView()));
     actions << m_viewModeMenu->addAction(koIcon("view-preview"),
                                          i18n("Thumbnail View"), this, SLOT(slotThumbnailView()));
 
     for (int i = 0, n = actions.count(); i < n; ++i) {
         actions[i]->setCheckable(true);
         actions[i]->setActionGroup(group);
     }
 
     m_wdgLayerBox->bnAdd->setIcon(themedIcon("addlayer"));
 
     m_wdgLayerBox->bnViewMode->setMenu(m_viewModeMenu);
     m_wdgLayerBox->bnViewMode->setPopupMode(QToolButton::InstantPopup);
     m_wdgLayerBox->bnViewMode->setIcon(koIcon("view-choose"));
     m_wdgLayerBox->bnViewMode->setText(i18n("View mode"));
 
     m_wdgLayerBox->bnDelete->setIcon(themedIcon("deletelayer"));
     m_wdgLayerBox->bnDelete->setIconSize(QSize(22, 22));
 
     m_wdgLayerBox->bnRaise->setEnabled(false);
     m_wdgLayerBox->bnRaise->setIcon(themedIcon("arrowupblr"));
     m_wdgLayerBox->bnRaise->setIconSize(QSize(22, 22));
 
     m_wdgLayerBox->bnLower->setEnabled(false);
     m_wdgLayerBox->bnLower->setIcon(themedIcon("arrowdown"));
     m_wdgLayerBox->bnLower->setIconSize(QSize(22, 22));
 
     m_wdgLayerBox->bnLeft->setEnabled(true);
     m_wdgLayerBox->bnLeft->setIcon(themedIcon("removefromfolder"));
     m_wdgLayerBox->bnLeft->setIconSize(QSize(22, 22));
 
     m_wdgLayerBox->bnRight->setEnabled(true);
     m_wdgLayerBox->bnRight->setIcon(themedIcon("addtofolder"));
     m_wdgLayerBox->bnRight->setIconSize(QSize(22, 22));
 
     m_wdgLayerBox->bnProperties->setIcon(themedIcon("properties"));
     m_wdgLayerBox->bnProperties->setIconSize(QSize(22, 22));
 
     m_wdgLayerBox->bnDuplicate->setIcon(themedIcon("duplicatelayer"));
     m_wdgLayerBox->bnDuplicate->setIconSize(QSize(22, 22));
 
     m_removeAction  = new ButtonAction(m_wdgLayerBox->bnDelete, themedIcon("deletelayer"), i18n("&Remove Layer"), this);
     m_removeAction->setActivationFlags(KisAction::ACTIVE_NODE);
     m_removeAction->setActivationConditions(KisAction::ACTIVE_NODE_EDITABLE);
     m_removeAction->setObjectName("remove_layer");
     connect(m_removeAction, SIGNAL(triggered()), this, SLOT(slotRmClicked()));
     m_actions.append(m_removeAction);
 
     KisAction* action  = new ButtonAction(m_wdgLayerBox->bnLeft, this);
     action->setText(i18n("Move Layer Left"));
     action->setActivationFlags(KisAction::ACTIVE_NODE);
     action->setActivationConditions(KisAction::ACTIVE_NODE_EDITABLE);
     action->setObjectName("move_layer_left");
     connect(action, SIGNAL(triggered()), this, SLOT(slotLeftClicked()));
     m_actions.append(action);
 
     action  = new ButtonAction(m_wdgLayerBox->bnRight, this);
     action->setText(i18n("Move Layer Right"));
     action->setActivationFlags(KisAction::ACTIVE_NODE);
     action->setActivationConditions(KisAction::ACTIVE_NODE_EDITABLE);
     action->setObjectName("move_layer_right");
     connect(action, SIGNAL(triggered()), this, SLOT(slotRightClicked()));
     m_actions.append(action);
 
     m_propertiesAction  = new ButtonAction(m_wdgLayerBox->bnProperties, themedIcon("properties"), i18n("&Properties..."),this);
     m_propertiesAction->setActivationFlags(KisAction::ACTIVE_NODE);
     m_propertiesAction->setActivationConditions(KisAction::ACTIVE_NODE_EDITABLE);
     m_propertiesAction->setObjectName("layer_properties");
     connect(m_propertiesAction, SIGNAL(triggered()), this, SLOT(slotPropertiesClicked()));
     m_actions.append(m_propertiesAction);
 
     // NOTE: this is _not_ a mistake. The layerbox shows the layers in the reverse order
     connect(m_wdgLayerBox->bnRaise, SIGNAL(clicked()), SLOT(slotLowerClicked()));
     connect(m_wdgLayerBox->bnLower, SIGNAL(clicked()), SLOT(slotRaiseClicked()));
     // END NOTE
 
     if (cfg.sliderLabels()) {
         m_wdgLayerBox->opacityLabel->hide();
         m_wdgLayerBox->doubleOpacity->setPrefix(QString("%1:  ").arg(i18n("Opacity")));
     }
     m_wdgLayerBox->doubleOpacity->setRange(0, 100, 0);
     m_wdgLayerBox->doubleOpacity->setSuffix("%");
 
     connect(m_wdgLayerBox->doubleOpacity, SIGNAL(valueChanged(qreal)), SLOT(slotOpacitySliderMoved(qreal)));
     connect(&m_opacityDelayTimer, SIGNAL(timeout()), SLOT(slotOpacityChanged()));
 
     connect(m_wdgLayerBox->cmbComposite, SIGNAL(activated(int)), SLOT(slotCompositeOpChanged(int)));
 
     m_selectOpaque = new KisAction(i18n("&Select Opaque"), this);
     m_selectOpaque->setActivationFlags(KisAction::ACTIVE_DEVICE);
     m_selectOpaque->setActivationConditions(KisAction::SELECTION_EDITABLE);
     m_selectOpaque->setObjectName("select_opaque");
     connect(m_selectOpaque, SIGNAL(triggered(bool)), this, SLOT(slotSelectOpaque()));
     m_actions.append(m_selectOpaque);
 
     m_newLayerMenu = new KMenu(this);
     m_wdgLayerBox->bnAdd->setMenu(m_newLayerMenu);
     m_wdgLayerBox->bnAdd->setPopupMode(QToolButton::MenuButtonPopup);
 
     m_nodeModel = new KisNodeModel(this);
 
     /**
      * Connect model updateUI() to enable/disable controls.
      * Note: nodeActivated() is connected separately in setImage(), because
      *       it needs particular order of calls: first the connection to the
      *       node manager should be called, then updateUI()
      */
     connect(m_nodeModel, SIGNAL(rowsInserted(const QModelIndex&, int, int)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(rowsRemoved(const QModelIndex&, int, int)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(rowsMoved(const QModelIndex&, int, int, const QModelIndex&, int)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(modelReset()), SLOT(updateUI()));
 
     KisAction *showGlobalSelectionMask = new KisAction(i18n("&Show Global Selection Mask"), this);
     showGlobalSelectionMask->setObjectName("show-global-selection-mask");
     showGlobalSelectionMask->setToolTip(i18nc("@info:tooltip", "Shows global selection as a usual selection mask in <interface>Layers</interface> docker"));
     showGlobalSelectionMask->setCheckable(true);
     connect(showGlobalSelectionMask, SIGNAL(triggered(bool)), SLOT(slotEditGlobalSelection(bool)));
     m_actions.append(showGlobalSelectionMask);
 
     showGlobalSelectionMask->setChecked(cfg.showGlobalSelection());
 
     m_wdgLayerBox->listLayers->setModel(m_nodeModel);
 }
 
 KisLayerBox::~KisLayerBox()
 {
     delete m_wdgLayerBox;
 }
 
 
 void expandNodesRecursively(KisNodeSP root, QPointer<KisNodeModel> nodeModel, KisDocumentSectionView *sectionView)
 {
     if (!root) return;
     if (nodeModel.isNull()) return;
     if (!sectionView) return;
 
     sectionView->blockSignals(true);
 
     KisNodeSP node = root->firstChild();
     while (node) {
         QModelIndex idx = nodeModel->indexFromNode(node);
         if (idx.isValid()) {
             if (node->collapsed()) {
                 sectionView->collapse(idx);
             }
         }
         if (node->childCount() > 0) {
             expandNodesRecursively(node, nodeModel, sectionView);
         }
         node = node->nextSibling();
     }
     sectionView->blockSignals(false);
 }
 
 void KisLayerBox::setMainWindow(KisViewManager* kisview)
 {
     m_nodeManager = kisview->nodeManager();
 
 
     foreach(KisAction *action, m_actions) {
         kisview->actionManager()->
             addAction(action->objectName(),
                       action);
     }
 
     connectActionToButton(kisview, m_wdgLayerBox->bnAdd, "add_new_paint_layer");
     connectActionToButton(kisview, m_wdgLayerBox->bnDuplicate, "duplicatelayer");
 }
 
 void KisLayerBox::setCanvas(KoCanvasBase *canvas)
 {
     setEnabled(canvas != 0);
     if (m_canvas) {
         m_canvas->disconnectCanvasObserver(this);
         m_nodeModel->setDummiesFacade(0, 0, 0);
 
         disconnect(m_image, 0, this, 0);
         disconnect(m_nodeManager, 0, this, 0);
         disconnect(m_nodeModel, 0, m_nodeManager, 0);
         disconnect(m_nodeModel, SIGNAL(nodeActivated(KisNodeSP)), this, SLOT(updateUI()));
     }
 
     m_canvas = dynamic_cast<KisCanvas2*>(canvas);
 
     if (m_canvas) {
         m_image = m_canvas->image();
 
         connect(m_image, SIGNAL(sigImageUpdated(QRect)), SLOT(updateThumbnail()));
 
         KisDocument* doc = static_cast<KisDocument*>(m_canvas->imageView()->document());
         KisShapeController *kritaShapeController = dynamic_cast<KisShapeController*>(doc->shapeController());
         KisDummiesFacadeBase *kritaDummiesFacade = static_cast<KisDummiesFacadeBase*>(kritaShapeController);
         m_nodeModel->setDummiesFacade(kritaDummiesFacade, m_image, kritaShapeController);
 
         connect(m_image, SIGNAL(sigAboutToBeDeleted()), SLOT(notifyImageDeleted()));
         connect(m_image, SIGNAL(sigNodeCollapsedChanged()), SLOT(slotNodeCollapsedChanged()));
 
         // cold start
         if (m_nodeManager) {
             setCurrentNode(m_nodeManager->activeNode());
         }
         else {
             setCurrentNode(m_canvas->imageView()->currentNode());
         }
 
         // Connection KisNodeManager -> KisLayerBox
         connect(m_nodeManager, SIGNAL(sigUiNeedChangeActiveNode(KisNodeSP)), this, SLOT(setCurrentNode(KisNodeSP)));
 
         // Connection KisLayerBox -> KisNodeManager
         // The order of these connections is important! See comment in the ctor
         connect(m_nodeModel, SIGNAL(nodeActivated(KisNodeSP)), m_nodeManager, SLOT(slotUiActivatedNode(KisNodeSP)));
         connect(m_nodeModel, SIGNAL(nodeActivated(KisNodeSP)), SLOT(updateUI()));
 
         // Connection KisLayerBox -> KisNodeManager (isolate layer)
         connect(m_nodeModel, SIGNAL(toggleIsolateActiveNode()), m_nodeManager, SLOT(toggleIsolateActiveNode()));
 
         // Node manipulation methods are forwarded to the node manager
         connect(m_nodeModel, SIGNAL(requestAddNode(KisNodeSP, KisNodeSP, KisNodeSP)),
                 m_nodeManager, SLOT(addNodeDirect(KisNodeSP, KisNodeSP, KisNodeSP)));
         connect(m_nodeModel, SIGNAL(requestMoveNode(KisNodeSP, KisNodeSP, KisNodeSP)),
                 m_nodeManager, SLOT(moveNodeDirect(KisNodeSP, KisNodeSP, KisNodeSP)));
 
         m_wdgLayerBox->listLayers->expandAll();
         expandNodesRecursively(m_image->rootLayer(), m_nodeModel, m_wdgLayerBox->listLayers);
         m_wdgLayerBox->listLayers->scrollTo(m_wdgLayerBox->listLayers->currentIndex());
 
         addActionToMenu(m_newLayerMenu, "add_new_paint_layer");
         addActionToMenu(m_newLayerMenu, "add_new_group_layer");
         addActionToMenu(m_newLayerMenu, "add_new_clone_layer");
         addActionToMenu(m_newLayerMenu, "add_new_shape_layer");
         addActionToMenu(m_newLayerMenu, "add_new_adjustment_layer");
         addActionToMenu(m_newLayerMenu, "add_new_fill_layer");
         addActionToMenu(m_newLayerMenu, "add_new_file_layer");
         m_newLayerMenu->addSeparator();
         addActionToMenu(m_newLayerMenu, "add_new_transparency_mask");
         addActionToMenu(m_newLayerMenu, "add_new_filter_mask");
         addActionToMenu(m_newLayerMenu, "add_new_transform_mask");
         addActionToMenu(m_newLayerMenu, "add_new_selection_mask");
     }
 
 }
 
 
 void KisLayerBox::unsetCanvas()
 {
     setEnabled(false);
     if (m_canvas) {
         m_newLayerMenu->clear();
     }
     setCanvas(0);
     m_nodeManager->setSelectedNodes(QList<KisNodeSP>());
 }
 
 void KisLayerBox::notifyImageDeleted()
 {
     setCanvas(0);
     m_nodeManager->setSelectedNodes(QList<KisNodeSP>());
 }
 
 void KisLayerBox::updateUI()
 {
     if (!m_canvas) return;
     if (!m_nodeManager) return;
 
     KisNodeSP activeNode = m_nodeManager->activeNode();
 
     m_wdgLayerBox->bnRaise->setEnabled(activeNode && activeNode->isEditable(false) && (activeNode->nextSibling()
                                        || (activeNode->parent() && activeNode->parent() != m_image->root())));
     m_wdgLayerBox->bnLower->setEnabled(activeNode && activeNode->isEditable(false) && (activeNode->prevSibling()
                                        || (activeNode->parent() && activeNode->parent() != m_image->root())));
 
     m_wdgLayerBox->doubleOpacity->setEnabled(activeNode && activeNode->isEditable(false));
 
     m_wdgLayerBox->cmbComposite->setEnabled(activeNode && activeNode->isEditable(false));
 
     if (activeNode) {
         if (m_nodeManager->activePaintDevice()) {
             slotFillCompositeOps(m_nodeManager->activeColorSpace());
         } else {
             slotFillCompositeOps(m_image->colorSpace());
         }
 
         if (activeNode->inherits("KisMask")) {
             m_wdgLayerBox->cmbComposite->setEnabled(false);
             m_wdgLayerBox->doubleOpacity->setEnabled(false);
         } else if (activeNode->inherits("KisLayer")) {
             m_wdgLayerBox->doubleOpacity->setEnabled(true);
 
             KisLayerSP l = qobject_cast<KisLayer*>(activeNode.data());
             slotSetOpacity(l->opacity() * 100.0 / 255);
 
             const KoCompositeOp* compositeOp = l->compositeOp();
             if (compositeOp) {
                 slotSetCompositeOp(compositeOp);
             } else {
                 m_wdgLayerBox->cmbComposite->setEnabled(false);
             }
 
             const KisGroupLayer *group = qobject_cast<const KisGroupLayer*>(activeNode.data());
             bool compositeSelectionActive = !(group && group->passThroughMode());
 
             m_wdgLayerBox->cmbComposite->setEnabled(compositeSelectionActive);
         }
     }
 }
 
 
 /**
  * This method is callen *only* when non-GUI code requested the
  * change of the current node
  */
 void KisLayerBox::setCurrentNode(KisNodeSP node)
 {
     QModelIndex index = node ? m_nodeModel->indexFromNode(node) : QModelIndex();
 
     m_wdgLayerBox->listLayers->selectionModel()->setCurrentIndex(index, QItemSelectionModel::ClearAndSelect);
     updateUI();
 }
 
 void KisLayerBox::slotSetCompositeOp(const KoCompositeOp* compositeOp)
 {
     KoID opId = KoCompositeOpRegistry::instance().getKoID(compositeOp->id());
 
     m_wdgLayerBox->cmbComposite->blockSignals(true);
     m_wdgLayerBox->cmbComposite->selectCompositeOp(opId);
     m_wdgLayerBox->cmbComposite->blockSignals(false);
 }
 
 void KisLayerBox::slotFillCompositeOps(const KoColorSpace* colorSpace)
 {
     m_wdgLayerBox->cmbComposite->validate(colorSpace);
 }
 
 // range: 0-100
 void KisLayerBox::slotSetOpacity(double opacity)
 {
     Q_ASSERT(opacity >= 0 && opacity <= 100);
     m_wdgLayerBox->doubleOpacity->blockSignals(true);
     m_wdgLayerBox->doubleOpacity->setValue(opacity);
     m_wdgLayerBox->doubleOpacity->blockSignals(false);
 }
 
 void KisLayerBox::slotContextMenuRequested(const QPoint &pos, const QModelIndex &index)
 {
     QMenu menu;
 
     if (index.isValid()) {
         menu.addAction(m_propertiesAction);
+        addActionToMenu(&menu, "layer_style");
+
         menu.addSeparator();
         menu.addAction(m_removeAction);
 
         addActionToMenu(&menu, "duplicatelayer");
         addActionToMenu(&menu, "flatten_image");
         addActionToMenu(&menu, "flatten_layer");
 
         // TODO: missing icon "edit-merge"
         QAction* mergeLayerDown = menu.addAction(i18n("&Merge with Layer Below"), this, SLOT(slotMergeLayer()));
         if (!index.sibling(index.row() + 1, 0).isValid()) mergeLayerDown->setEnabled(false);
         menu.addSeparator();
 
         QMenu *convertToMenu = menu.addMenu(i18n("&Convert"));
         addActionToMenu(convertToMenu, "convert_to_paint_layer");
         addActionToMenu(convertToMenu, "convert_to_transparency_mask");
         addActionToMenu(convertToMenu, "convert_to_filter_mask");
         addActionToMenu(convertToMenu, "convert_to_selection_mask");
 
         QMenu *splitAlphaMenu = menu.addMenu(i18n("S&plit Alpha"));
         addActionToMenu(splitAlphaMenu, "split_alpha_into_mask");
         addActionToMenu(splitAlphaMenu, "split_alpha_write");
         addActionToMenu(splitAlphaMenu, "split_alpha_save_merged");
 
         KisNodeSP node = m_nodeModel->nodeFromIndex(index);
         if (node && !node->inherits("KisTransformMask")) {
             addActionToMenu(&menu, "isolate_layer");
         }
     }
     menu.addSeparator();
     addActionToMenu(&menu, "add_new_transparency_mask");
     addActionToMenu(&menu, "add_new_filter_mask");
     addActionToMenu(&menu, "add_new_transform_mask");
     addActionToMenu(&menu, "add_new_selection_mask");
     menu.addSeparator();
     menu.addAction(m_selectOpaque);
     menu.exec(pos);
 }
 
 void KisLayerBox::slotMergeLayer()
 {
     if (!m_canvas) return;
     m_nodeManager->mergeLayerDown();
 }
 
 void KisLayerBox::slotMinimalView()
 {
     m_wdgLayerBox->listLayers->setDisplayMode(KisDocumentSectionView::MinimalMode);
 }
 
 void KisLayerBox::slotDetailedView()
 {
     m_wdgLayerBox->listLayers->setDisplayMode(KisDocumentSectionView::DetailedMode);
 }
 
 void KisLayerBox::slotThumbnailView()
 {
     m_wdgLayerBox->listLayers->setDisplayMode(KisDocumentSectionView::ThumbnailMode);
 }
 
 void KisLayerBox::slotRmClicked()
 {
     if (!m_canvas) return;
     m_nodeManager->removeNode();
 }
 
 void KisLayerBox::slotRaiseClicked()
 {
     if (!m_canvas) return;
     KisNodeSP node = m_nodeManager->activeNode();
     KisNodeSP parent = node->parent();
     KisNodeSP grandParent = parent->parent();
 
     if (!m_nodeManager->activeNode()->prevSibling()) {
         if (!grandParent) return;
         if (!grandParent->parent() && node->inherits("KisMask")) return;
         m_nodeManager->moveNodeAt(node, grandParent, grandParent->index(parent));
     } else {
         m_nodeManager->raiseNode();
     }
 }
 
 void KisLayerBox::slotLowerClicked()
 {
     if (!m_canvas) return;
     KisNodeSP node = m_nodeManager->activeNode();
     KisNodeSP parent = node->parent();
     KisNodeSP grandParent = parent->parent();
 
     if (!m_nodeManager->activeNode()->nextSibling()) {
         if (!grandParent) return;
         if (!grandParent->parent() && node->inherits("KisMask")) return;
         m_nodeManager->moveNodeAt(node, grandParent, grandParent->index(parent) + 1);
     }
     else {
         m_nodeManager->lowerNode();
     }
 }
 
 void KisLayerBox::slotLeftClicked()
 {
     if (!m_canvas) return;
     foreach(KisNodeSP node, m_nodeManager->selectedNodes()) {
         KisNodeSP parent = node->parent();
         KisNodeSP grandParent = parent->parent();
         quint16 nodeIndex = parent->index(node);
 
         if (!grandParent) continue;
         if (!grandParent->parent() && node->inherits("KisMask")) continue;
 
         if (nodeIndex <= parent->childCount() / 2) {
             m_nodeManager->moveNodeAt(node, grandParent, grandParent->index(parent));
         }
         else {
             m_nodeManager->moveNodeAt(node, grandParent, grandParent->index(parent) + 1);
         }
     }
 }
 
 void KisLayerBox::slotRightClicked()
 {
     if (!m_canvas) return;
 
     foreach(KisNodeSP node, m_nodeManager->selectedNodes()) {
         KisNodeSP parent = m_nodeManager->activeNode()->parent();
         KisNodeSP newParent;
         int nodeIndex = parent->index(node);
         int indexAbove = nodeIndex + 1;
         int indexBelow = nodeIndex - 1;
 
         if (parent->at(indexBelow) && parent->at(indexBelow)->allowAsChild(node)) {
             newParent = parent->at(indexBelow);
             m_nodeManager->moveNodeAt(node, newParent, newParent->childCount());
         }
         else if (parent->at(indexAbove) && parent->at(indexAbove)->allowAsChild(node)) {
             newParent = parent->at(indexAbove);
             m_nodeManager->moveNodeAt(node, newParent, 0);
         }
     }
 }
 
 void KisLayerBox::slotPropertiesClicked()
 {
     if (!m_canvas) return;
     if (KisNodeSP active = m_nodeManager->activeNode()) {
         m_nodeManager->nodeProperties(active);
     }
 }
 
 void KisLayerBox::slotCompositeOpChanged(int index)
 {
     Q_UNUSED(index);
     if (!m_canvas) return;
 
     QString compositeOp = m_wdgLayerBox->cmbComposite->selectedCompositeOp().id();
     m_nodeManager->nodeCompositeOpChanged(m_nodeManager->activeColorSpace()->compositeOp(compositeOp));
 }
 
 void KisLayerBox::slotOpacityChanged()
 {
     if (!m_canvas) return;
     m_nodeManager->nodeOpacityChanged(m_newOpacity, true);
 }
 
 void KisLayerBox::slotOpacitySliderMoved(qreal opacity)
 {
     m_newOpacity = opacity;
     m_opacityDelayTimer.start(200);
 }
 
 void KisLayerBox::slotCollapsed(const QModelIndex &index)
 {
     KisNodeSP node = m_nodeModel->nodeFromIndex(index);
     if (node) {
         node->setCollapsed(true);
     }
 }
 
 void KisLayerBox::slotExpanded(const QModelIndex &index)
 {
     KisNodeSP node = m_nodeModel->nodeFromIndex(index);
     if (node) {
         node->setCollapsed(false);
     }
 }
 
 void KisLayerBox::slotSelectOpaque()
 {
     if (!m_canvas) return;
     QAction *action = m_canvas->viewManager()->actionManager()->actionByName("selectopaque");
     if (action) {
         action->trigger();
     }
 }
 
 void KisLayerBox::slotNodeCollapsedChanged()
 {
     m_wdgLayerBox->listLayers->expandAll();
     expandNodesRecursively(m_image->rootLayer(), m_nodeModel, m_wdgLayerBox->listLayers);
 }
 
 inline bool isSelectionMask(KisNodeSP node)
 {
     return dynamic_cast<KisSelectionMask*>(node.data());
 }
 
 KisNodeSP KisLayerBox::findNonHidableNode(KisNodeSP startNode)
 {
     if (isSelectionMask(startNode) &&
         startNode->parent() &&
         !startNode->parent()->parent()) {
 
 
         KisNodeSP node = startNode->prevSibling();
         while (node && isSelectionMask(node)) {
             node = node->prevSibling();
         }
 
         if (!node) {
             node = startNode->nextSibling();
             while (node && isSelectionMask(node)) {
                 node = node->nextSibling();
             }
         }
 
         if (!node) {
             node = m_image->root()->lastChild();
             while (node && isSelectionMask(node)) {
                 node = node->prevSibling();
             }
         }
 
         KIS_ASSERT_RECOVER_NOOP(node && "cannot activate any node!");
         startNode = node;
     }
 
     return startNode;
 }
 
 void KisLayerBox::slotEditGlobalSelection(bool showSelections)
 {
     KisNodeSP lastActiveNode = m_nodeManager->activeNode();
     KisNodeSP activateNode = lastActiveNode;
 
     if (!showSelections) {
         activateNode = findNonHidableNode(activateNode);
     }
 
     m_nodeModel->setShowGlobalSelection(showSelections);
 
     if (showSelections) {
         KisNodeSP newMask = m_image->rootLayer()->selectionMask();
         if (newMask) {
             activateNode = newMask;
         }
     }
 
     if (activateNode) {
         if (lastActiveNode != activateNode) {
             m_nodeManager->slotNonUiActivatedNode(activateNode);
         } else {
             setCurrentNode(lastActiveNode);
         }
     }
 }
 
 void KisLayerBox::selectionChanged(const QModelIndexList selection)
 {
     if (!m_nodeManager) return;
 
     if (selection.isEmpty() && m_nodeManager->activeNode()) {
         m_wdgLayerBox->listLayers->selectionModel()->
             setCurrentIndex(
                 m_nodeModel->indexFromNode(m_nodeManager->activeNode()),
                 QItemSelectionModel::ClearAndSelect);
         return;
     }
 
 
     QList<KisNodeSP> selectedNodes;
     foreach(const QModelIndex &idx, selection) {
         selectedNodes << m_nodeModel->nodeFromIndex(idx);
     }
 
 
     m_nodeManager->setSelectedNodes(selectedNodes);
     updateUI();
 }
 
 void KisLayerBox::updateThumbnail()
 {
     m_wdgLayerBox->listLayers->updateNode(m_wdgLayerBox->listLayers->currentIndex());
 }
 
 #include "kis_layer_box.moc"
diff --git a/krita/ui/dialogs/kis_dlg_layer_style.cpp b/krita/ui/dialogs/kis_dlg_layer_style.cpp
index e7520809e9..01653394c9 100644
--- a/krita/ui/dialogs/kis_dlg_layer_style.cpp
+++ b/krita/ui/dialogs/kis_dlg_layer_style.cpp
@@ -1,1365 +1,1381 @@
 /*
  *  Copyright (c) 2014 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "kis_dlg_layer_style.h"
 
 #include <QWidget>
 #include <QStackedWidget>
 #include <QTreeWidget>
 #include <QListWidget>
 #include <QListWidgetItem>
 #include <QComboBox>
 #include <QDial>
 #include <QCheckBox>
 #include <QSpinBox>
 #include <QUuid>
 #include <QInputDialog>
 
 
 #include <KoColorPopupButton.h>
 #include <KoResourceServerProvider.h>
 
 #include "kis_config.h"
 #include "kis_cmb_contour.h"
 #include "kis_cmb_gradient.h"
 #include "kis_resource_server_provider.h"
 #include "kis_psd_layer_style_resource.h"
 #include "kis_psd_layer_style.h"
 
 #include "kis_signals_blocker.h"
 #include "kis_signal_compressor.h"
 #include "kis_canvas_resource_provider.h"
 
 #include <KoFileDialog.h>
 
 
 
 KoAbstractGradient* fetchGradientLazy(KoAbstractGradient *gradient,
                                       KisCanvasResourceProvider *resourceProvider)
 {
     if (!gradient) {
         gradient = resourceProvider->currentGradient();
     }
     return gradient;
 }
 
 KisDlgLayerStyle::KisDlgLayerStyle(KisPSDLayerStyleSP layerStyle, KisCanvasResourceProvider *resourceProvider, QWidget *parent)
     : KDialog(parent)
     , m_layerStyle(layerStyle)
     , m_initialLayerStyle(layerStyle->clone())
     , m_isSwitchingPredefinedStyle(false)
     , m_sanityLayerStyleDirty(false)
 {
     setCaption(i18n("Layer Styles"));
     setButtons(Ok | Cancel);
     setDefaultButton(Ok);
 
     m_configChangedCompressor =
         new KisSignalCompressor(1000, KisSignalCompressor::POSTPONE, this);
     connect(m_configChangedCompressor, SIGNAL(timeout()), SIGNAL(configChanged()));
 
     QWidget *page = new QWidget(this);
     wdgLayerStyles.setupUi(page);
     setMainWidget(page);
 
     connect(wdgLayerStyles.lstStyleSelector, SIGNAL(itemChanged(QListWidgetItem*)), SLOT(notifyGuiConfigChanged()));
 
     m_stylesSelector = new StylesSelector(this);
     connect(m_stylesSelector, SIGNAL(styleSelected(KisPSDLayerStyleSP)), SLOT(notifyPredefinedStyleSelected(KisPSDLayerStyleSP)));
     wdgLayerStyles.stylesStack->addWidget(m_stylesSelector);
 
     m_blendingOptions = new BlendingOptions(this);
     wdgLayerStyles.stylesStack->addWidget(m_blendingOptions);
 
     m_dropShadow = new DropShadow(DropShadow::DropShadowMode, this);
     wdgLayerStyles.stylesStack->addWidget(m_dropShadow);
     connect(m_dropShadow, SIGNAL(configChanged()), SLOT(notifyGuiConfigChanged()));
 
     m_innerShadow = new DropShadow(DropShadow::InnerShadowMode, this);
     wdgLayerStyles.stylesStack->addWidget(m_innerShadow);
     connect(m_innerShadow, SIGNAL(configChanged()), SLOT(notifyGuiConfigChanged()));
 
     m_outerGlow = new InnerGlow(InnerGlow::OuterGlowMode, resourceProvider, this);
     wdgLayerStyles.stylesStack->addWidget(m_outerGlow);
     connect(m_outerGlow, SIGNAL(configChanged()), SLOT(notifyGuiConfigChanged()));
 
     m_innerGlow = new InnerGlow(InnerGlow::InnerGlowMode, resourceProvider, this);
     wdgLayerStyles.stylesStack->addWidget(m_innerGlow);
     connect(m_innerGlow, SIGNAL(configChanged()), SLOT(notifyGuiConfigChanged()));
 
     m_contour = new Contour(this);
     m_texture = new Texture(this);
     m_bevelAndEmboss = new BevelAndEmboss(m_contour, m_texture, this);
 
     wdgLayerStyles.stylesStack->addWidget(m_bevelAndEmboss);
     wdgLayerStyles.stylesStack->addWidget(m_contour);
     wdgLayerStyles.stylesStack->addWidget(m_texture);
 
     connect(m_bevelAndEmboss, SIGNAL(configChanged()), SLOT(notifyGuiConfigChanged()));
 
     m_satin = new Satin(this);
     wdgLayerStyles.stylesStack->addWidget(m_satin);
     connect(m_satin, SIGNAL(configChanged()), SLOT(notifyGuiConfigChanged()));
 
     m_colorOverlay = new ColorOverlay(this);
     wdgLayerStyles.stylesStack->addWidget(m_colorOverlay);
     connect(m_colorOverlay, SIGNAL(configChanged()), SLOT(notifyGuiConfigChanged()));
 
     m_gradientOverlay = new GradientOverlay(resourceProvider, this);
     wdgLayerStyles.stylesStack->addWidget(m_gradientOverlay);
     connect(m_gradientOverlay, SIGNAL(configChanged()), SLOT(notifyGuiConfigChanged()));
 
     m_patternOverlay = new PatternOverlay(this);
     wdgLayerStyles.stylesStack->addWidget(m_patternOverlay);
     connect(m_patternOverlay, SIGNAL(configChanged()), SLOT(notifyGuiConfigChanged()));
 
     m_stroke = new Stroke(resourceProvider, this);
     wdgLayerStyles.stylesStack->addWidget(m_stroke);
     connect(m_stroke, SIGNAL(configChanged()), SLOT(notifyGuiConfigChanged()));
 
     KisConfig cfg;
     wdgLayerStyles.stylesStack->setCurrentIndex(cfg.readEntry("KisDlgLayerStyle::current", 1));
     wdgLayerStyles.lstStyleSelector->setCurrentRow(cfg.readEntry("KisDlgLayerStyle::current", 1));
 
     connect(wdgLayerStyles.lstStyleSelector,
             SIGNAL(currentItemChanged(QListWidgetItem*,QListWidgetItem*)),
              this, SLOT(changePage(QListWidgetItem*,QListWidgetItem*)));
 
     notifyPredefinedStyleSelected(layerStyle);
 
     connect(wdgLayerStyles.btnNewStyle, SIGNAL(clicked()), SLOT(slotNewStyle()));
     connect(wdgLayerStyles.btnLoadStyle, SIGNAL(clicked()), SLOT(slotLoadStyle()));
     connect(wdgLayerStyles.btnSaveStyle, SIGNAL(clicked()), SLOT(slotSaveStyle()));
 
+    connect(wdgLayerStyles.chkMasterFxSwitch, SIGNAL(toggled(bool)), SLOT(slotMasterFxSwitchChanged(bool)));
+
     connect(this, SIGNAL(accepted()), SLOT(slotNotifyOnAccept()));
     connect(this, SIGNAL(rejected()), SLOT(slotNotifyOnReject()));
 }
 
 KisDlgLayerStyle::~KisDlgLayerStyle()
 {
 }
 
+void KisDlgLayerStyle::slotMasterFxSwitchChanged(bool value)
+{
+    wdgLayerStyles.lstStyleSelector->setEnabled(value);
+    wdgLayerStyles.stylesStack->setEnabled(value);
+    wdgLayerStyles.btnNewStyle->setEnabled(value);
+    wdgLayerStyles.btnLoadStyle->setEnabled(value);
+    wdgLayerStyles.btnSaveStyle->setEnabled(value);
+    notifyGuiConfigChanged();
+}
+
 void KisDlgLayerStyle::notifyGuiConfigChanged()
 {
     if (m_isSwitchingPredefinedStyle) return;
 
     m_configChangedCompressor->start();
     m_layerStyle->setUuid(QUuid::createUuid());
     m_sanityLayerStyleDirty = true;
 
     m_stylesSelector->notifyExternalStyleChanged(m_layerStyle->name(), m_layerStyle->uuid());
 }
 
 void KisDlgLayerStyle::notifyPredefinedStyleSelected(KisPSDLayerStyleSP style)
 {
     m_isSwitchingPredefinedStyle = true;
     setStyle(style);
     m_isSwitchingPredefinedStyle = false;
     m_configChangedCompressor->start();
 }
 
 
 void KisDlgLayerStyle::slotNotifyOnAccept()
 {
     if (m_configChangedCompressor->isActive()) {
         m_configChangedCompressor->stop();
         emit configChanged();
     }
 }
 
 void KisDlgLayerStyle::slotNotifyOnReject()
 {
     notifyPredefinedStyleSelected(m_initialLayerStyle);
 
     m_configChangedCompressor->stop();
     emit configChanged();
 }
 
 bool checkCustomNameAvailable(const QString &name)
 {
     const QString customName = "CustomStyles.asl";
 
     KoResourceServer<KisPSDLayerStyleCollectionResource> *server = KisResourceServerProvider::instance()->layerStyleCollectionServer();
 
     KoResource *resource = server->resourceByName(customName);
     if (!resource) return true;
 
     KisPSDLayerStyleCollectionResource *collection = dynamic_cast<KisPSDLayerStyleCollectionResource*>(resource);
 
     foreach(KisPSDLayerStyleSP style, collection->layerStyles()) {
         if (style->name() == name) {
             return false;
         }
     }
 
     return true;
 }
 
 QString selectAvailableStyleName(const QString &name)
 {
     QString finalName = name;
     if (checkCustomNameAvailable(finalName)) {
         return finalName;
     }
 
     int i = 0;
 
     do {
         finalName = QString("%1%2").arg(name).arg(i++);
     } while (!checkCustomNameAvailable(finalName));
 
     return finalName;
 }
 
 void KisDlgLayerStyle::slotNewStyle()
 {
     QString styleName =
         QInputDialog::getText(this,
                               i18nc("@title:window", "Enter new style name"),
                               i18nc("@label:textbox", "Name:"),
                               QLineEdit::Normal, i18nc("Default name for a new style", "New Style"));
 
     KisPSDLayerStyleSP style = this->style();
     style->setName(selectAvailableStyleName(styleName));
 
     m_stylesSelector->addNewStyle(style->clone());
 }
 
 void KisDlgLayerStyle::slotLoadStyle()
 {
     QString filename; // default value?
 
     KoFileDialog dialog(this, KoFileDialog::OpenFile, "krita/layerstyle");
     dialog.setCaption(i18n("Select ASL file"));
     //dialog.setDefaultDir(QDir::cleanPath(filename));
     dialog.setNameFilter(i18n("Layer style library (*.asl)"));
     filename = dialog.url();
 
     m_stylesSelector->loadCollection(filename);
     wdgLayerStyles.lstStyleSelector->setCurrentRow(0);
 }
 
 void KisDlgLayerStyle::slotSaveStyle()
 {
     QString filename; // default value?
 
     KoFileDialog dialog(this, KoFileDialog::SaveFile, "krita/layerstyle");
     dialog.setCaption(i18n("Select ASL file"));
     //dialog.setDefaultDir(QDir::cleanPath(filename));
     dialog.setNameFilter(i18n("Layer style configuration (*.asl)"));
     filename = dialog.url();
 
     QScopedPointer<KisPSDLayerStyleCollectionResource> collection(
         new KisPSDLayerStyleCollectionResource(filename));
 
     KisPSDLayerStyleSP newStyle = style()->clone();
     newStyle->setName(QFileInfo(filename).baseName());
 
     KisPSDLayerStyleCollectionResource::StylesVector vector = collection->layerStyles();
     vector << newStyle;
     collection->setLayerStyles(vector);
     collection->save();
 }
 
 void KisDlgLayerStyle::changePage(QListWidgetItem *current, QListWidgetItem *previous)
 {
     if (!current) {
         current = previous;
     }
     wdgLayerStyles.stylesStack->setCurrentIndex(wdgLayerStyles.lstStyleSelector->row(current));
 }
 
 void KisDlgLayerStyle::setStyle(KisPSDLayerStyleSP style)
 {
     *m_layerStyle = *style;
     m_sanityLayerStyleDirty = false;
 
     m_stylesSelector->notifyExternalStyleChanged(m_layerStyle->name(), m_layerStyle->uuid());
 
     QListWidgetItem *item;
     item = wdgLayerStyles.lstStyleSelector->item(2);
     item->setCheckState(m_layerStyle->dropShadow()->effectEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(3);
     item->setCheckState(m_layerStyle->innerShadow()->effectEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(4);
     item->setCheckState(m_layerStyle->outerGlow()->effectEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(5);
     item->setCheckState(m_layerStyle->innerGlow()->effectEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(6);
     item->setCheckState(m_layerStyle->bevelAndEmboss()->effectEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(7);
     item->setCheckState(m_layerStyle->bevelAndEmboss()->contourEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(8);
     item->setCheckState(m_layerStyle->bevelAndEmboss()->textureEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(9);
     item->setCheckState(m_layerStyle->satin()->effectEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(10);
     item->setCheckState(m_layerStyle->colorOverlay()->effectEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(11);
     item->setCheckState(m_layerStyle->gradientOverlay()->effectEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(12);
     item->setCheckState(m_layerStyle->patternOverlay()->effectEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(13);
     item->setCheckState(m_layerStyle->stroke()->effectEnabled() ? Qt::Checked : Qt::Unchecked);
 
     m_dropShadow->setShadow(m_layerStyle->dropShadow());
     m_innerShadow->setShadow(m_layerStyle->innerShadow());
     m_outerGlow->setConfig(m_layerStyle->outerGlow());
     m_innerGlow->setConfig(m_layerStyle->innerGlow());
     m_bevelAndEmboss->setBevelAndEmboss(m_layerStyle->bevelAndEmboss());
     m_satin->setSatin(m_layerStyle->satin());
     m_colorOverlay->setColorOverlay(m_layerStyle->colorOverlay());
     m_gradientOverlay->setGradientOverlay(m_layerStyle->gradientOverlay());
     m_patternOverlay->setPatternOverlay(m_layerStyle->patternOverlay());
     m_stroke->setStroke(m_layerStyle->stroke());
 
+    wdgLayerStyles.chkMasterFxSwitch->setChecked(m_layerStyle->isEnabled());
+    slotMasterFxSwitchChanged(m_layerStyle->isEnabled());
 }
 
 KisPSDLayerStyleSP KisDlgLayerStyle::style() const
 {
+    m_layerStyle->setEnabled(wdgLayerStyles.chkMasterFxSwitch->isChecked());
+
     m_layerStyle->dropShadow()->setEffectEnabled(wdgLayerStyles.lstStyleSelector->item(2)->checkState() == Qt::Checked);
     m_layerStyle->innerShadow()->setEffectEnabled(wdgLayerStyles.lstStyleSelector->item(3)->checkState() == Qt::Checked);
     m_layerStyle->outerGlow()->setEffectEnabled(wdgLayerStyles.lstStyleSelector->item(4)->checkState() == Qt::Checked);
     m_layerStyle->innerGlow()->setEffectEnabled(wdgLayerStyles.lstStyleSelector->item(5)->checkState() == Qt::Checked);
     m_layerStyle->bevelAndEmboss()->setEffectEnabled(wdgLayerStyles.lstStyleSelector->item(6)->checkState() == Qt::Checked);
     m_layerStyle->bevelAndEmboss()->setContourEnabled(wdgLayerStyles.lstStyleSelector->item(7)->checkState() == Qt::Checked);
     m_layerStyle->bevelAndEmboss()->setTextureEnabled(wdgLayerStyles.lstStyleSelector->item(8)->checkState() == Qt::Checked);
     m_layerStyle->satin()->setEffectEnabled(wdgLayerStyles.lstStyleSelector->item(9)->checkState() == Qt::Checked);
     m_layerStyle->colorOverlay()->setEffectEnabled(wdgLayerStyles.lstStyleSelector->item(10)->checkState() == Qt::Checked);
     m_layerStyle->gradientOverlay()->setEffectEnabled(wdgLayerStyles.lstStyleSelector->item(11)->checkState() == Qt::Checked);
     m_layerStyle->patternOverlay()->setEffectEnabled(wdgLayerStyles.lstStyleSelector->item(12)->checkState() == Qt::Checked);
     m_layerStyle->stroke()->setEffectEnabled(wdgLayerStyles.lstStyleSelector->item(13)->checkState() == Qt::Checked);
 
 
     m_dropShadow->fetchShadow(m_layerStyle->dropShadow());
     m_innerShadow->fetchShadow(m_layerStyle->innerShadow());
     m_outerGlow->fetchConfig(m_layerStyle->outerGlow());
     m_innerGlow->fetchConfig(m_layerStyle->innerGlow());
     m_bevelAndEmboss->fetchBevelAndEmboss(m_layerStyle->bevelAndEmboss());
     m_satin->fetchSatin(m_layerStyle->satin());
     m_colorOverlay->fetchColorOverlay(m_layerStyle->colorOverlay());
     m_gradientOverlay->fetchGradientOverlay(m_layerStyle->gradientOverlay());
     m_patternOverlay->fetchPatternOverlay(m_layerStyle->patternOverlay());
     m_stroke->fetchStroke(m_layerStyle->stroke());
 
     m_sanityLayerStyleDirty = false;
     m_stylesSelector->notifyExternalStyleChanged(m_layerStyle->name(), m_layerStyle->uuid());
 
     return m_layerStyle;
 }
 
 /********************************************************************/
 /***** Styles Selector **********************************************/
 /********************************************************************/
 
 class StyleItem : public QListWidgetItem {
 public:
     StyleItem(KisPSDLayerStyleSP style)
         : QListWidgetItem(style->name())
         , m_style(style)
     {
     }
 
 public:
     KisPSDLayerStyleSP m_style;
 };
 
 
 StylesSelector::StylesSelector(QWidget *parent)
     : QWidget(parent)
 {
     ui.setupUi(this);
 
     connect(ui.cmbStyleCollections, SIGNAL(activated(QString)), this, SLOT(loadStyles(QString)));
     connect(ui.listStyles, SIGNAL(currentItemChanged(QListWidgetItem*,QListWidgetItem*)), this, SLOT(selectStyle(QListWidgetItem*,QListWidgetItem*)));
 
     refillCollections();
 
     if (ui.cmbStyleCollections->count()) {
         ui.cmbStyleCollections->setCurrentIndex(0);
         loadStyles(ui.cmbStyleCollections->currentText());
     }
 }
 
 void StylesSelector::refillCollections()
 {
     QString previousCollection = ui.cmbStyleCollections->currentText();
 
     ui.cmbStyleCollections->clear();
     foreach(KoResource *res, KisResourceServerProvider::instance()->layerStyleCollectionServer()->resources()) {
         ui.cmbStyleCollections->addItem(res->name());
     }
 
     if (!previousCollection.isEmpty()) {
         KisSignalsBlocker blocker(this);
 
         int index = ui.cmbStyleCollections->findText(previousCollection);
         ui.cmbStyleCollections->setCurrentIndex(index);
     }
 }
 
 void StylesSelector::notifyExternalStyleChanged(const QString &name, const QUuid &uuid)
 {
     int currentIndex = -1;
 
     for (int i = 0; i < ui.listStyles->count(); i++ ) {
         StyleItem *item = dynamic_cast<StyleItem*>(ui.listStyles->item(i));
 
         QString itemName = item->m_style->name();
 
         if (itemName == name) {
             bool isDirty = item->m_style->uuid() != uuid;
 
             if (isDirty) {
                 itemName += "*";
             }
 
             currentIndex = i;
         }
 
         item->setText(itemName);
     }
 
     ui.listStyles->setCurrentRow(currentIndex);
 }
 
 void StylesSelector::loadStyles(const QString &name)
 {
     ui.listStyles->clear();
     KoResource *res = KisResourceServerProvider::instance()->layerStyleCollectionServer()->resourceByName(name);
     KisPSDLayerStyleCollectionResource *collection = dynamic_cast<KisPSDLayerStyleCollectionResource*>(res);
     if (collection) {
         foreach(KisPSDLayerStyleSP style, collection->layerStyles()) {
             // XXX: also use the preview image, when we have one
             ui.listStyles->addItem(new StyleItem(style));
         }
     }
 }
 
 void StylesSelector::selectStyle(QListWidgetItem *current, QListWidgetItem* /*previous*/)
 {
     StyleItem *item = dynamic_cast<StyleItem*>(current);
     if (item) {
         emit styleSelected(item->m_style);
     }
 }
 
 void StylesSelector::loadCollection(const QString &fileName)
 {
     if (!QFileInfo(fileName).exists()) {
         qWarning() << "Loaded style collection doesn't exist!";
         return;
     }
 
     KisPSDLayerStyleCollectionResource *collection =
         new KisPSDLayerStyleCollectionResource(fileName);
 
     collection->load();
 
     KoResourceServer<KisPSDLayerStyleCollectionResource> *server = KisResourceServerProvider::instance()->layerStyleCollectionServer();
     collection->setFilename(server->saveLocation() + QDir::separator() + collection->name());
     server->addResource(collection);
 
     refillCollections();
 
     int index = ui.cmbStyleCollections->findText(collection->name());
     ui.cmbStyleCollections->setCurrentIndex(index);
     loadStyles(collection->name());
 }
 
 void StylesSelector::addNewStyle(KisPSDLayerStyleSP style)
 {
     KoResourceServer<KisPSDLayerStyleCollectionResource> *server = KisResourceServerProvider::instance()->layerStyleCollectionServer();
 
     // NOTE: not translatable, since it is a key!
     const QString customName = "CustomStyles.asl";
     const QString saveLocation = server->saveLocation();
     const QString fullFilename = saveLocation + customName;
 
     KoResource *resource = server->resourceByName(customName);
     KisPSDLayerStyleCollectionResource *collection = 0;
 
     if (!resource) {
         collection = new KisPSDLayerStyleCollectionResource("");
         collection->setName(customName);
         collection->setFilename(fullFilename);
 
         KisPSDLayerStyleCollectionResource::StylesVector vector;
         vector << style;
         collection->setLayerStyles(vector);
 
         server->addResource(collection);
     } else {
         collection = dynamic_cast<KisPSDLayerStyleCollectionResource*>(resource);
 
         KisPSDLayerStyleCollectionResource::StylesVector vector;
         vector = collection->layerStyles();
         vector << style;
         collection->setLayerStyles(vector);
         collection->save();
     }
 
     refillCollections();
 
     // select in gui
 
     int index = ui.cmbStyleCollections->findText(customName);
     KIS_ASSERT_RECOVER_RETURN(index >= 0);
     ui.cmbStyleCollections->setCurrentIndex(index);
 
     loadStyles(customName);
 
     notifyExternalStyleChanged(style->name(), style->uuid());
 }
 
 /********************************************************************/
 /***** Bevel and Emboss *********************************************/
 /********************************************************************/
 
 BevelAndEmboss::BevelAndEmboss(Contour *contour, Texture *texture, QWidget *parent)
     : QWidget(parent)
     , m_contour(contour)
     , m_texture(texture)
 {
     ui.setupUi(this);
 
     // Structure
     ui.intDepth->setRange(0, 100);
     ui.intDepth->setSuffix(" %");
 
     ui.intSize->setRange(0, 250);
     ui.intSize->setSuffix(" px");
 
     ui.intSoften->setRange(0, 18);
     ui.intSoften->setSuffix(" px");
 
     connect(ui.cmbStyle, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.cmbTechnique, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.intDepth, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.cmbDirection, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.intSize, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intSoften, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     // Shading
     ui.intOpacity->setRange(0, 100);
     ui.intOpacity->setSuffix(" %");
 
     ui.intOpacity2->setRange(0, 100);
     ui.intOpacity2->setSuffix(" %");
 
     connect(ui.dialAngle, SIGNAL(valueChanged(int)), SLOT(slotDialAngleChanged(int)));
     connect(ui.intAngle, SIGNAL(valueChanged(int)), SLOT(slotIntAngleChanged(int)));
     connect(ui.chkUseGlobalLight, SIGNAL(toggled(bool)), ui.dialAngle, SLOT(setDisabled(bool)));
     connect(ui.chkUseGlobalLight, SIGNAL(toggled(bool)), ui.intAngle, SLOT(setDisabled(bool)));
 
     connect(ui.dialAngle, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intAngle, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.chkUseGlobalLight, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.intAltitude, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.cmbContour, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.chkAntiAliased, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.cmbHighlightMode, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.bnHighlightColor, SIGNAL(changed(QColor)), SIGNAL(configChanged()));
     connect(ui.intOpacity, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.cmbShadowMode, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.bnShadowColor, SIGNAL(changed(QColor)), SIGNAL(configChanged()));
     connect(ui.intOpacity2, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));;
 
     // Contour
     m_contour->ui.intRange->setRange(0, 100);
     m_contour->ui.intRange->setSuffix(" %");
 
     connect(m_contour->ui.cmbContour, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(m_contour->ui.chkAntiAliased, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(m_contour->ui.intRange, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     // Texture
     m_texture->ui.intScale->setRange(0, 100);
     m_texture->ui.intScale->setSuffix(" %");
 
     m_texture->ui.intDepth->setRange(-1000, 1000);
     m_texture->ui.intDepth->setSuffix(" %");
 
     connect(m_texture->ui.patternChooser, SIGNAL(resourceSelected(KoResource*)), SIGNAL(configChanged()));
     connect(m_texture->ui.intScale, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(m_texture->ui.intDepth, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(m_texture->ui.chkInvert, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(m_texture->ui.chkLinkWithLayer, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
 }
 
 void BevelAndEmboss::setBevelAndEmboss(const psd_layer_effects_bevel_emboss *bevelAndEmboss)
 {
     ui.cmbStyle->setCurrentIndex((int)bevelAndEmboss->style());
     ui.cmbTechnique->setCurrentIndex((int)bevelAndEmboss->technique());
     ui.intDepth->setValue(bevelAndEmboss->depth());
     ui.cmbDirection->setCurrentIndex((int)bevelAndEmboss->direction());
     ui.intSize->setValue(bevelAndEmboss->size());
     ui.intSoften->setValue(bevelAndEmboss->soften());
 
     ui.dialAngle->setValue(bevelAndEmboss->angle());
     ui.intAngle->setValue(bevelAndEmboss->angle());
     ui.intAltitude->setValue(bevelAndEmboss->altitude());
     // FIXME: curve editing
     // ui.cmbContour;
     ui.chkAntiAliased->setChecked(bevelAndEmboss->glossAntiAliased());
     ui.cmbHighlightMode->selectCompositeOp(KoID(bevelAndEmboss->highlightBlendMode()));
     ui.bnHighlightColor->setColor(bevelAndEmboss->highlightColor());
     ui.intOpacity->setValue(bevelAndEmboss->highlightOpacity());
     ui.cmbShadowMode->selectCompositeOp(KoID(bevelAndEmboss->shadowBlendMode()));
     ui.bnShadowColor->setColor(bevelAndEmboss->shadowColor());
     ui.intOpacity2->setValue(bevelAndEmboss->shadowOpacity());
 
     // FIXME: curve editing
     // m_contour->ui.cmbContour;
     m_contour->ui.chkAntiAliased->setChecked(bevelAndEmboss->antiAliased());
     m_contour->ui.intRange->setValue(bevelAndEmboss->contourRange());
 
     m_texture->ui.patternChooser->setCurrentPattern(bevelAndEmboss->texturePattern());
     m_texture->ui.intScale->setValue(bevelAndEmboss->textureScale());
     m_texture->ui.intDepth->setValue(bevelAndEmboss->textureDepth());
     m_texture->ui.chkInvert->setChecked(bevelAndEmboss->textureInvert());
     m_texture->ui.chkLinkWithLayer->setChecked(bevelAndEmboss->textureAlignWithLayer());
 }
 
 void BevelAndEmboss::fetchBevelAndEmboss(psd_layer_effects_bevel_emboss *bevelAndEmboss) const
 {
     bevelAndEmboss->setStyle((psd_bevel_style)ui.cmbStyle->currentIndex());
     bevelAndEmboss->setTechnique((psd_technique_type)ui.cmbTechnique->currentIndex());
     bevelAndEmboss->setDepth(ui.intDepth->value());
     bevelAndEmboss->setDirection((psd_direction)ui.cmbDirection->currentIndex());
     bevelAndEmboss->setSize(ui.intSize->value());
     bevelAndEmboss->setSoften(ui.intSoften->value());
 
     bevelAndEmboss->setAngle(ui.dialAngle->value());
     bevelAndEmboss->setAltitude(ui.intAltitude->value());
     bevelAndEmboss->setGlossAntiAliased(ui.chkAntiAliased->isChecked());
     bevelAndEmboss->setHighlightBlendMode(ui.cmbHighlightMode->selectedCompositeOp().id());
     bevelAndEmboss->setHighlightColor(ui.bnHighlightColor->color());
     bevelAndEmboss->setHighlightOpacity(ui.intOpacity->value());
     bevelAndEmboss->setShadowBlendMode(ui.cmbShadowMode->selectedCompositeOp().id());
     bevelAndEmboss->setShadowColor(ui.bnShadowColor->color());
     bevelAndEmboss->setShadowOpacity(ui.intOpacity2->value());
 
     // FIXME: curve editing
     bevelAndEmboss->setAntiAliased(m_contour->ui.chkAntiAliased->isChecked());
     bevelAndEmboss->setContourRange(m_contour->ui.intRange->value());
 
     bevelAndEmboss->setTexturePattern(static_cast<KoPattern*>(m_texture->ui.patternChooser->currentResource()));
     bevelAndEmboss->setTextureScale(m_texture->ui.intScale->value());
     bevelAndEmboss->setTextureDepth(m_texture->ui.intDepth->value());
     bevelAndEmboss->setTextureInvert(m_texture->ui.chkInvert->isChecked());
     bevelAndEmboss->setTextureAlignWithLayer(m_texture->ui.chkLinkWithLayer->isChecked());
 }
 
 void BevelAndEmboss::slotDialAngleChanged(int value)
 {
     KisSignalsBlocker b(ui.intAngle);
     ui.intAngle->setValue(value);
 }
 
 void BevelAndEmboss::slotIntAngleChanged(int value)
 {
     KisSignalsBlocker b(ui.dialAngle);
     ui.dialAngle->setValue(value);
 }
 
 /********************************************************************/
 /***** Texture          *********************************************/
 /********************************************************************/
 
 Texture::Texture(QWidget *parent)
     : QWidget(parent)
 {
     ui.setupUi(this);
 }
 
 /********************************************************************/
 /***** Contour          *********************************************/
 /********************************************************************/
 
 Contour::Contour(QWidget *parent)
     : QWidget(parent)
 {
     ui.setupUi(this);
 }
 
 
 /********************************************************************/
 /***** Blending Options *********************************************/
 /********************************************************************/
 
 BlendingOptions::BlendingOptions(QWidget *parent)
     : QWidget(parent)
 {
     ui.setupUi(this);
 
     // FIXME: Blend options are not implemented yet
     ui.grpBlendingOptions->setTitle(QString("%1 (%2)").arg(ui.grpBlendingOptions->title()).arg(i18n("Not Implemented Yet")));
     ui.grpBlendingOptions->setEnabled(false);
 
 }
 
 
 /********************************************************************/
 /***** Color Overlay    *********************************************/
 /********************************************************************/
 
 
 ColorOverlay::ColorOverlay(QWidget *parent)
     : QWidget(parent)
 {
     ui.setupUi(this);
 
     ui.intOpacity->setRange(0, 100);
     ui.intOpacity->setSuffix(" %");
 
     connect(ui.cmbCompositeOp, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.intOpacity, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.bnColor, SIGNAL(changed(QColor)), SIGNAL(configChanged()));
 }
 
 void ColorOverlay::setColorOverlay(const psd_layer_effects_color_overlay *colorOverlay)
 {
     ui.cmbCompositeOp->selectCompositeOp(KoID(colorOverlay->blendMode()));
     ui.intOpacity->setValue(colorOverlay->opacity());
     ui.bnColor->setColor(colorOverlay->color());
 }
 
 void ColorOverlay::fetchColorOverlay(psd_layer_effects_color_overlay *colorOverlay) const
 {
     colorOverlay->setBlendMode(ui.cmbCompositeOp->selectedCompositeOp().id());
     colorOverlay->setOpacity(ui.intOpacity->value());
     colorOverlay->setColor(ui.bnColor->color());
 }
 
 
 /********************************************************************/
 /***** Drop Shadow **************************************************/
 /********************************************************************/
 
 DropShadow::DropShadow(Mode mode, QWidget *parent)
     : QWidget(parent),
       m_mode(mode)
 {
     ui.setupUi(this);
 
     ui.intOpacity->setRange(0, 100);
     ui.intOpacity->setSuffix(" %");
 
     ui.intDistance->setRange(0, 30000);
     ui.intDistance->setSuffix(" px");
 
     ui.intSpread->setRange(0, 100);
     ui.intSpread->setSuffix(" %");
 
     ui.intSize->setRange(0, 250);
     ui.intSize->setSuffix(" px");
 
     ui.intNoise->setRange(0, 100);
     ui.intNoise->setSuffix(" %");
 
     connect(ui.dialAngle, SIGNAL(valueChanged(int)), SLOT(slotDialAngleChanged(int)));
     connect(ui.intAngle, SIGNAL(valueChanged(int)), SLOT(slotIntAngleChanged(int)));
     connect(ui.chkUseGlobalLight, SIGNAL(toggled(bool)), ui.dialAngle, SLOT(setDisabled(bool)));
     connect(ui.chkUseGlobalLight, SIGNAL(toggled(bool)), ui.intAngle, SLOT(setDisabled(bool)));
 
     // connect everything to configChanged() signal
     connect(ui.cmbCompositeOp, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.intOpacity, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.bnColor, SIGNAL(changed(QColor)), SIGNAL(configChanged()));
 
     connect(ui.dialAngle, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intAngle, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.chkUseGlobalLight, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
 
     connect(ui.intDistance, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intSpread, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intSize, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     connect(ui.cmbContour, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.chkAntiAliased, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.intNoise, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     connect(ui.chkLayerKnocksOutDropShadow, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
 
     if (m_mode == InnerShadowMode) {
         ui.chkLayerKnocksOutDropShadow->setVisible(false);
         ui.grpMain->setTitle(i18n("Inner Shadow"));
         ui.lblSpread->setText(i18n("Choke"));
     }
 }
 
 void DropShadow::slotDialAngleChanged(int value)
 {
     KisSignalsBlocker b(ui.intAngle);
     ui.intAngle->setValue(value);
 }
 
 void DropShadow::slotIntAngleChanged(int value)
 {
     KisSignalsBlocker b(ui.dialAngle);
     ui.dialAngle->setValue(value);
 }
 
 void DropShadow::setShadow(const psd_layer_effects_shadow_common *shadow)
 {
     ui.cmbCompositeOp->selectCompositeOp(KoID(shadow->blendMode()));
     ui.intOpacity->setValue(shadow->opacity());
     ui.bnColor->setColor(shadow->color());
 
     ui.dialAngle->setValue(shadow->angle());
     ui.intAngle->setValue(shadow->angle());
     ui.chkUseGlobalLight->setChecked(shadow->useGlobalLight());
 
     ui.intDistance->setValue(shadow->distance());
     ui.intSpread->setValue(shadow->spread());
     ui.intSize->setValue(shadow->size());
 
     // FIXME: curve editing
     // ui.cmbContour;
     ui.chkAntiAliased->setChecked(shadow->antiAliased());
 
     ui.intNoise->setValue(shadow->noise());
 
     if (m_mode == DropShadowMode) {
         const psd_layer_effects_drop_shadow *realDropShadow = dynamic_cast<const psd_layer_effects_drop_shadow*>(shadow);
         KIS_ASSERT_RECOVER_NOOP(realDropShadow);
 
         ui.chkLayerKnocksOutDropShadow->setChecked(shadow->knocksOut());
     }
 }
 
 void DropShadow::fetchShadow(psd_layer_effects_shadow_common *shadow) const
 {
     shadow->setBlendMode(ui.cmbCompositeOp->selectedCompositeOp().id());
     shadow->setOpacity(ui.intOpacity->value());
     shadow->setColor(ui.bnColor->color());
 
     shadow->setAngle(ui.dialAngle->value());
     shadow->setUseGlobalLight(ui.chkUseGlobalLight->isChecked());
 
     shadow->setDistance(ui.intDistance->value());
     shadow->setSpread(ui.intSpread->value());
     shadow->setSize(ui.intSize->value());
 
     // FIXME: curve editing
     // ui.cmbContour;
     shadow->setAntiAliased(ui.chkAntiAliased->isChecked());
     shadow->setNoise(ui.intNoise->value());
 
     if (m_mode == DropShadowMode) {
         psd_layer_effects_drop_shadow *realDropShadow = dynamic_cast<psd_layer_effects_drop_shadow*>(shadow);
         KIS_ASSERT_RECOVER_NOOP(realDropShadow);
 
         realDropShadow->setKnocksOut(ui.chkLayerKnocksOutDropShadow->isChecked());
     }
 }
 
 class GradientPointerConverter
 {
 public:
     static KoAbstractGradientSP resourceToStyle(KoAbstractGradient *gradient) {
         return gradient ? KoAbstractGradientSP(gradient->clone()) : KoAbstractGradientSP();
     }
 
     static KoAbstractGradient* styleToResource(KoAbstractGradientSP gradient) {
         if (!gradient) return 0;
 
         KoResourceServer<KoAbstractGradient> *server = KoResourceServerProvider::instance()->gradientServer();
         KoAbstractGradient *resource = server->resourceByMD5(gradient->md5());
 
         if (!resource) {
             KoAbstractGradient *clone = gradient->clone();
             clone->setName(findAvailableName(gradient->name()));
             server->addResource(clone, false);
             resource = clone;
         }
 
         return resource;
     }
 
 private:
     static QString findAvailableName(const QString &name) {
         KoResourceServer<KoAbstractGradient> *server = KoResourceServerProvider::instance()->gradientServer();
         QString newName = name;
         int i = 0;
 
         while (server->resourceByName(newName)) {
             newName = QString("%1%2").arg(name).arg(i++);
         }
 
         return newName;
     }
 };
 
 /********************************************************************/
 /***** Gradient Overlay *********************************************/
 /********************************************************************/
 
 GradientOverlay::GradientOverlay(KisCanvasResourceProvider *resourceProvider, QWidget *parent)
     : QWidget(parent),
       m_resourceProvider(resourceProvider)
 {
     ui.setupUi(this);
 
     ui.intOpacity->setRange(0, 100);
     ui.intOpacity->setSuffix(" %");
 
     ui.intScale->setRange(0, 100);
     ui.intScale->setSuffix(" %");
 
     connect(ui.dialAngle, SIGNAL(valueChanged(int)), SLOT(slotDialAngleChanged(int)));
     connect(ui.intAngle, SIGNAL(valueChanged(int)), SLOT(slotIntAngleChanged(int)));
 
     connect(ui.cmbCompositeOp, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.intOpacity, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.cmbGradient, SIGNAL(gradientChanged(KoAbstractGradient*)), SIGNAL(configChanged()));
     connect(ui.chkReverse, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.cmbStyle, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.chkAlignWithLayer, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.dialAngle, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intAngle, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intScale, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 }
 
 void GradientOverlay::setGradientOverlay(const psd_layer_effects_gradient_overlay *config)
 {
     ui.cmbCompositeOp->selectCompositeOp(KoID(config->blendMode()));
     ui.intOpacity->setValue(config->opacity());
 
     KoAbstractGradient *gradient = fetchGradientLazy(
         GradientPointerConverter::styleToResource(config->gradient()), m_resourceProvider);
 
     if (gradient) {
         ui.cmbGradient->setGradient(gradient);
     }
 
     ui.chkReverse->setChecked(config->antiAliased());
     ui.cmbStyle->setCurrentIndex((int)config->style());
     ui.chkAlignWithLayer->setCheckable(config->alignWithLayer());
     ui.dialAngle->setValue(config->angle());
     ui.intAngle->setValue(config->angle());
     ui.intScale->setValue(config->scale());
 }
 
 void GradientOverlay::fetchGradientOverlay(psd_layer_effects_gradient_overlay *config) const
 {
     config->setBlendMode(ui.cmbCompositeOp->selectedCompositeOp().id());
     config->setOpacity(ui.intOpacity->value());
     config->setGradient(GradientPointerConverter::resourceToStyle(ui.cmbGradient->gradient()));
     config->setReverse(ui.chkReverse->isChecked());
     config->setStyle((psd_gradient_style)ui.cmbStyle->currentIndex());
     config->setAlignWithLayer(ui.chkAlignWithLayer->isChecked());
     config->setAngle(ui.dialAngle->value());
     config->setScale(ui.intScale->value());
 }
 
 void GradientOverlay::slotDialAngleChanged(int value)
 {
     KisSignalsBlocker b(ui.intAngle);
     ui.intAngle->setValue(value);
 }
 
 void GradientOverlay::slotIntAngleChanged(int value)
 {
     KisSignalsBlocker b(ui.dialAngle);
     ui.dialAngle->setValue(value);
 }
 
 /********************************************************************/
 /***** Innner Glow      *********************************************/
 /********************************************************************/
 
 InnerGlow::InnerGlow(Mode mode, KisCanvasResourceProvider *resourceProvider, QWidget *parent)
     : QWidget(parent),
       m_mode(mode),
       m_resourceProvider(resourceProvider)
 {
     ui.setupUi(this);
 
     ui.intOpacity->setRange(0, 100);
     ui.intOpacity->setSuffix(" %");
 
     ui.intNoise->setRange(0, 100);
     ui.intNoise->setSuffix(" %");
 
     ui.intChoke->setRange(0, 100);
     ui.intChoke->setSuffix(" %");
 
     ui.intSize->setRange(0, 250);
     ui.intSize->setSuffix(" px");
 
     ui.intRange->setRange(0, 100);
     ui.intRange->setSuffix(" %");
 
     ui.intJitter->setRange(0, 100);
     ui.intJitter->setSuffix(" %");
 
     connect(ui.cmbCompositeOp, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.intOpacity, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intNoise, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     connect(ui.radioColor, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.bnColor, SIGNAL(changed(QColor)), SIGNAL(configChanged()));
     connect(ui.radioGradient, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.cmbGradient, SIGNAL(gradientChanged(KoAbstractGradient*)), SIGNAL(configChanged()));
 
     connect(ui.cmbTechnique, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.cmbSource, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.intChoke, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intSize, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     connect(ui.cmbContour, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.chkAntiAliased, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.intRange, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intJitter, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     if (m_mode == OuterGlowMode) {
         ui.cmbSource->hide();
         ui.lblSource->hide();
         ui.lblChoke->setText(i18nc("layer styles parameter", "Spread"));
     }
 
 }
 
 void InnerGlow::setConfig(const psd_layer_effects_glow_common *config)
 {
     ui.cmbCompositeOp->selectCompositeOp(KoID(config->blendMode()));
     ui.intOpacity->setValue(config->opacity());
     ui.intNoise->setValue(config->noise());
 
     ui.radioColor->setChecked(config->fillType() == psd_fill_solid_color);
     ui.bnColor->setColor(config->color());
     ui.radioGradient->setChecked(config->fillType() == psd_fill_gradient);
 
     KoAbstractGradient *gradient = fetchGradientLazy(
         GradientPointerConverter::styleToResource(config->gradient()), m_resourceProvider);
 
     if (gradient) {
         ui.cmbGradient->setGradient(gradient);
     }
 
     ui.cmbTechnique->setCurrentIndex((int)config->technique());
     ui.intChoke->setValue(config->spread());
     ui.intSize->setValue(config->size());
 
     if (m_mode == InnerGlowMode) {
         const psd_layer_effects_inner_glow *iglow =
             dynamic_cast<const psd_layer_effects_inner_glow *>(config);
         KIS_ASSERT_RECOVER_RETURN(iglow);
 
         ui.cmbSource->setCurrentIndex(iglow->source() == psd_glow_edge);
     }
 
     // FIXME: Curve editing
     //ui.cmbContour;
 
     ui.chkAntiAliased->setChecked(config->antiAliased());
     ui.intRange->setValue(config->range());
     ui.intJitter->setValue(config->jitter());
 }
 
 void InnerGlow::fetchConfig(psd_layer_effects_glow_common *config) const
 {
     config->setBlendMode(ui.cmbCompositeOp->selectedCompositeOp().id());
     config->setOpacity(ui.intOpacity->value());
     config->setNoise(ui.intNoise->value());
 
     if (ui.radioColor->isChecked()) {
         config->setFillType(psd_fill_solid_color);
     }
     else {
         config->setFillType(psd_fill_gradient);
     }
 
     config->setColor(ui.bnColor->color());
     config->setGradient(GradientPointerConverter::resourceToStyle(ui.cmbGradient->gradient()));
     config->setTechnique((psd_technique_type)ui.cmbTechnique->currentIndex());
     config->setSpread(ui.intChoke->value());
     config->setSize(ui.intSize->value());
 
     if (m_mode == InnerGlowMode) {
         psd_layer_effects_inner_glow *iglow =
             dynamic_cast<psd_layer_effects_inner_glow *>(config);
         KIS_ASSERT_RECOVER_RETURN(iglow);
 
         iglow->setSource((psd_glow_source)ui.cmbSource->currentIndex());
     }
 
     // FIXME: Curve editing
     //ui.cmbContour;
 
     config->setAntiAliased(ui.chkAntiAliased->isChecked());
     config->setRange(ui.intRange->value());
     config->setJitter(ui.intJitter->value());
 }
 
 
 /********************************************************************/
 /***** Pattern Overlay  *********************************************/
 /********************************************************************/
 
 
 PatternOverlay::PatternOverlay(QWidget *parent)
     : QWidget(parent)
 {
     ui.setupUi(this);
 
     ui.intOpacity->setRange(0, 100);
     ui.intOpacity->setSuffix(" %");
 
     ui.intScale->setRange(0, 100);
     ui.intScale->setSuffix(" %");
 
     connect(ui.cmbCompositeOp, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.intOpacity, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.patternChooser, SIGNAL(resourceSelected(KoResource*)), SIGNAL(configChanged()));
     connect(ui.chkLinkWithLayer, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.intScale, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 }
 
 void PatternOverlay::setPatternOverlay(const psd_layer_effects_pattern_overlay *pattern)
 {
     ui.cmbCompositeOp->selectCompositeOp(KoID(pattern->blendMode()));
     ui.intOpacity->setValue(pattern->opacity());
     ui.patternChooser->setCurrentPattern(pattern->pattern());
     ui.chkLinkWithLayer->setChecked(pattern->alignWithLayer());
     ui.intScale->setValue(pattern->scale());
 }
 
 void PatternOverlay::fetchPatternOverlay(psd_layer_effects_pattern_overlay *pattern) const
 {
     pattern->setBlendMode(ui.cmbCompositeOp->selectedCompositeOp().id());
     pattern->setOpacity(ui.intOpacity->value());
     pattern->setPattern(static_cast<KoPattern*>(ui.patternChooser->currentResource()));
     pattern->setAlignWithLayer(ui.chkLinkWithLayer->isChecked());
     pattern->setScale(ui.intScale->value());
 }
 
 /********************************************************************/
 /***** Satin            *********************************************/
 /********************************************************************/
 
 
 Satin::Satin(QWidget *parent)
     : QWidget(parent)
 {
     ui.setupUi(this);
 
     ui.intOpacity->setRange(0, 100);
     ui.intOpacity->setSuffix(" %");
 
     ui.intDistance->setRange(0, 250);
     ui.intDistance->setSuffix(" px");
 
     ui.intSize->setRange(0, 250);
     ui.intSize->setSuffix(" px");
 
     connect(ui.dialAngle, SIGNAL(valueChanged(int)), SLOT(slotDialAngleChanged(int)));
     connect(ui.intAngle, SIGNAL(valueChanged(int)), SLOT(slotIntAngleChanged(int)));
 
     connect(ui.cmbCompositeOp, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.bnColor, SIGNAL(changed(QColor)), SIGNAL(configChanged()));
     connect(ui.intOpacity, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     connect(ui.dialAngle, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intAngle, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intDistance, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intSize, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     connect(ui.cmbContour, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.chkAntiAliased, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.chkInvert, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
 
 }
 
 void Satin::slotDialAngleChanged(int value)
 {
     KisSignalsBlocker b(ui.intAngle);
     ui.intAngle->setValue(value);
 }
 
 void Satin::slotIntAngleChanged(int value)
 {
     KisSignalsBlocker b(ui.dialAngle);
     ui.dialAngle->setValue(value);
 }
 
 void Satin::setSatin(const psd_layer_effects_satin *satin)
 {
     ui.cmbCompositeOp->selectCompositeOp(KoID(satin->blendMode()));
     ui.bnColor->setColor(satin->color());
     ui.intOpacity->setValue(satin->opacity());
 
     ui.dialAngle->setValue(satin->angle());
     ui.intAngle->setValue(satin->angle());
 
     ui.intDistance->setValue(satin->distance());
     ui.intSize->setValue(satin->size());
 
     // FIXME: Curve editing
     //ui.cmbContour;
 
     ui.chkAntiAliased->setChecked(satin->antiAliased());
     ui.chkInvert->setChecked(satin->invert());
 
 }
 
 void Satin::fetchSatin(psd_layer_effects_satin *satin) const
 {
     satin->setBlendMode(ui.cmbCompositeOp->selectedCompositeOp().id());
     satin->setOpacity(ui.intOpacity->value());
     satin->setColor(ui.bnColor->color());
 
     satin->setAngle(ui.dialAngle->value());
 
     satin->setDistance(ui.intDistance->value());
     satin->setSize(ui.intSize->value());
 
     // FIXME: curve editing
     // ui.cmbContour;
     satin->setAntiAliased(ui.chkAntiAliased->isChecked());
     satin->setInvert(ui.chkInvert->isChecked());
 }
 
 /********************************************************************/
 /***** Stroke           *********************************************/
 /********************************************************************/
 
 Stroke::Stroke(KisCanvasResourceProvider *resourceProvider, QWidget *parent)
     : QWidget(parent),
       m_resourceProvider(resourceProvider)
 {
     ui.setupUi(this);
 
     ui.intSize->setRange(0, 250);
     ui.intSize->setSuffix(" px");
 
     ui.intOpacity->setRange(0, 100);
     ui.intOpacity->setSuffix(" %");
 
     ui.intScale->setRange(0, 100);
     ui.intScale->setSuffix(" %");
 
     ui.intScale_2->setRange(0, 100);
     ui.intScale_2->setSuffix(" %");
 
     connect(ui.cmbFillType, SIGNAL(currentIndexChanged(int)), ui.fillStack, SLOT(setCurrentIndex(int)));
 
     connect(ui.intSize, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.cmbPosition, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.cmbCompositeOp, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.intOpacity, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     connect(ui.cmbFillType, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
 
     connect(ui.bnColor, SIGNAL(changed(QColor)), SIGNAL(configChanged()));
 
     connect(ui.cmbGradient, SIGNAL(gradientChanged(KoAbstractGradient*)), SIGNAL(configChanged()));
     connect(ui.chkReverse, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.cmbStyle, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.chkAlignWithLayer, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.dialAngle, SIGNAL(valueChanged(int)), SLOT(slotDialAngleChanged(int)));
     connect(ui.intAngle, SIGNAL(valueChanged(int)), SLOT(slotIntAngleChanged(int)));
     connect(ui.intScale, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     connect(ui.patternChooser, SIGNAL(resourceSelected(KoResource*)), SIGNAL(configChanged()));
     connect(ui.chkLinkWithLayer, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.intScale_2, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     // cold initialization
     ui.fillStack->setCurrentIndex(ui.cmbFillType->currentIndex());
 }
 
 void Stroke::slotDialAngleChanged(int value)
 {
     KisSignalsBlocker b(ui.intAngle);
     ui.intAngle->setValue(value);
 }
 
 void Stroke::slotIntAngleChanged(int value)
 {
     KisSignalsBlocker b(ui.dialAngle);
     ui.dialAngle->setValue(value);
 }
 
 
 void Stroke::setStroke(const psd_layer_effects_stroke *stroke)
 {
 
     ui.intSize->setValue(stroke->size());
     ui.cmbPosition->setCurrentIndex((int)stroke->position());
     ui.cmbCompositeOp->selectCompositeOp(KoID(stroke->blendMode()));
     ui.intOpacity->setValue(stroke->opacity());
 
     ui.cmbFillType->setCurrentIndex((int)stroke->fillType());
 
     ui.bnColor->setColor(stroke->color());
 
     KoAbstractGradient *gradient =
         fetchGradientLazy(GradientPointerConverter::styleToResource(stroke->gradient()), m_resourceProvider);
 
     if (gradient) {
         ui.cmbGradient->setGradient(gradient);
     }
 
     ui.chkReverse->setChecked(stroke->antiAliased());
     ui.cmbStyle->setCurrentIndex((int)stroke->style());
     ui.chkAlignWithLayer->setCheckable(stroke->alignWithLayer());
     ui.dialAngle->setValue(stroke->angle());
     ui.intAngle->setValue(stroke->angle());
     ui.intScale->setValue(stroke->scale());
 
     ui.patternChooser->setCurrentPattern(stroke->pattern());
     ui.chkLinkWithLayer->setChecked(stroke->alignWithLayer());
     ui.intScale_2->setValue(stroke->scale());
 
 }
 
 void Stroke::fetchStroke(psd_layer_effects_stroke *stroke) const
 {
     stroke->setSize(ui.intSize->value());
     stroke->setPosition((psd_stroke_position)ui.cmbPosition->currentIndex());
     stroke->setBlendMode(ui.cmbCompositeOp->selectedCompositeOp().id());
     stroke->setOpacity(ui.intOpacity->value());
 
     stroke->setFillType((psd_fill_type)ui.cmbFillType->currentIndex());
 
     stroke->setColor(ui.bnColor->color());
 
     stroke->setGradient(GradientPointerConverter::resourceToStyle(ui.cmbGradient->gradient()));
     stroke->setReverse(ui.chkReverse->isChecked());
     stroke->setStyle((psd_gradient_style)ui.cmbStyle->currentIndex());
     stroke->setAlignWithLayer(ui.chkAlignWithLayer->isChecked());
     stroke->setAngle(ui.dialAngle->value());
     stroke->setScale(ui.intScale->value());
 
     stroke->setPattern(static_cast<KoPattern*>(ui.patternChooser->currentResource()));
     stroke->setAlignWithLayer(ui.chkLinkWithLayer->isChecked());
     stroke->setScale(ui.intScale->value());
 }
diff --git a/krita/ui/dialogs/kis_dlg_layer_style.h b/krita/ui/dialogs/kis_dlg_layer_style.h
index bc030be3f0..c8db32d99b 100644
--- a/krita/ui/dialogs/kis_dlg_layer_style.h
+++ b/krita/ui/dialogs/kis_dlg_layer_style.h
@@ -1,314 +1,316 @@
 /*
  *  Copyright (c) 2014 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef KIS_DLG_LAYER_STYLE_H
 #define KIS_DLG_LAYER_STYLE_H
 
 #include <QUuid>
 
 #include <kdialog.h>
 
 #include "kis_types.h"
 
 #include <psd.h>
 
 #include "ui_wdglayerstyles.h"
 #include "ui_wdgBevelAndEmboss.h"
 #include "ui_wdgblendingoptions.h"
 #include "ui_WdgColorOverlay.h"
 #include "ui_wdgContour.h"
 #include "ui_wdgdropshadow.h"
 #include "ui_WdgGradientOverlay.h"
 #include "ui_wdgInnerGlow.h"
 #include "ui_WdgPatternOverlay.h"
 #include "ui_WdgSatin.h"
 #include "ui_WdgStroke.h"
 #include "ui_wdgstylesselector.h"
 #include "ui_wdgTexture.h"
 
 class QListWidgetItem;
 class KisPSDLayerStyle;
 class KisSignalCompressor;
 class KisCanvasResourceProvider;
 
 
 
 class Contour : public QWidget {
     Q_OBJECT
 public:
     Contour(QWidget *parent);
     Ui::WdgContour ui;
 };
 
 
 class Texture : public QWidget {
     Q_OBJECT
 public:
     Texture(QWidget *parent);
     Ui::WdgTexture ui;
 };
 
 
 class BevelAndEmboss : public QWidget {
     Q_OBJECT
 public:
     BevelAndEmboss(Contour *contour, Texture *texture, QWidget *parent);
     void setBevelAndEmboss(const psd_layer_effects_bevel_emboss *bevelAndEmboss);
     void fetchBevelAndEmboss(psd_layer_effects_bevel_emboss *bevelAndEmboss) const;
 
 private Q_SLOTS:
     void slotDialAngleChanged(int value);
     void slotIntAngleChanged(int value);
 
 Q_SIGNALS:
     void configChanged();
 
 private:
     Contour *m_contour;
     Texture *m_texture;
     Ui::WdgBevelAndEmboss ui;
 };
 
 class BlendingOptions : public QWidget {
     Q_OBJECT
 public:
     BlendingOptions(QWidget *parent);
 Q_SIGNALS:
     void configChanged();
 
 private:
     Ui::WdgBlendingOptions ui;
 };
 
 
 class ColorOverlay : public QWidget {
     Q_OBJECT
 public:
     ColorOverlay(QWidget *parent);
     void setColorOverlay(const psd_layer_effects_color_overlay *colorOverlay);
     void fetchColorOverlay(psd_layer_effects_color_overlay *colorOverlay) const;
 
 Q_SIGNALS:
     void configChanged();
 
 private:
     Ui::WdgColorOverlay ui;
 };
 
 
 class DropShadow : public QWidget {
     Q_OBJECT
 
 public:
     enum Mode {
         DropShadowMode,
         InnerShadowMode
     };
 
 public:
     DropShadow(Mode mode, QWidget *parent);
     void setShadow(const psd_layer_effects_shadow_common *shadow);
     void fetchShadow(psd_layer_effects_shadow_common *shadow) const;
 
 private Q_SLOTS:
     void slotDialAngleChanged(int value);
     void slotIntAngleChanged(int value);
 
 Q_SIGNALS:
     void configChanged();
 
 private:
     Ui::WdgDropShadow ui;
     Mode m_mode;
 };
 
 class GradientOverlay : public QWidget {
     Q_OBJECT
 public:
     GradientOverlay(KisCanvasResourceProvider *resourceProvider, QWidget *parent);
     void setGradientOverlay(const psd_layer_effects_gradient_overlay *gradient);
     void fetchGradientOverlay(psd_layer_effects_gradient_overlay *gradient) const;
 
 private Q_SLOTS:
     void slotDialAngleChanged(int value);
     void slotIntAngleChanged(int value);
 
 Q_SIGNALS:
     void configChanged();
 
 private:
     Ui::WdgGradientOverlay ui;
     KisCanvasResourceProvider *m_resourceProvider;
 };
 
 class InnerGlow : public QWidget {
     Q_OBJECT
 public:
     enum Mode {
         InnerGlowMode = 0,
         OuterGlowMode
     };
 
 public:
     InnerGlow(Mode mode, KisCanvasResourceProvider *resourceProvider, QWidget *parent);
     void setConfig(const psd_layer_effects_glow_common *innerGlow);
     void fetchConfig(psd_layer_effects_glow_common *innerGlow) const;
 
 Q_SIGNALS:
     void configChanged();
 
 private:
     Ui::WdgInnerGlow ui;
     Mode m_mode;
     KisCanvasResourceProvider *m_resourceProvider;
 };
 
 class PatternOverlay : public QWidget {
     Q_OBJECT
 public:
     PatternOverlay(QWidget *parent);
     void setPatternOverlay(const psd_layer_effects_pattern_overlay *pattern);
     void fetchPatternOverlay(psd_layer_effects_pattern_overlay *pattern) const;
 
 Q_SIGNALS:
     void configChanged();
 
 private:
     Ui::WdgPatternOverlay ui;
 };
 
 class Satin : public QWidget {
     Q_OBJECT
 public:
     Satin(QWidget *parent);
     void setSatin(const psd_layer_effects_satin *satin);
     void fetchSatin(psd_layer_effects_satin *satin) const;
 
 private Q_SLOTS:
     void slotDialAngleChanged(int value);
     void slotIntAngleChanged(int value);
 
 Q_SIGNALS:
     void configChanged();
 
 private:
     Ui::WdgSatin ui;
 };
 
 class Stroke : public QWidget {
     Q_OBJECT
 public:
     Stroke(KisCanvasResourceProvider *resourceProvider, QWidget *parent);
     void setStroke(const psd_layer_effects_stroke *stroke);
     void fetchStroke(psd_layer_effects_stroke *stroke) const;
 
 private Q_SLOTS:
     void slotDialAngleChanged(int value);
     void slotIntAngleChanged(int value);
 
 Q_SIGNALS:
     void configChanged();
 
 private:
     Ui::WdgStroke ui;
     KisCanvasResourceProvider *m_resourceProvider;
 };
 
 class StylesSelector : public QWidget {
     Q_OBJECT
 public:
     StylesSelector(QWidget *parent);
 
     void notifyExternalStyleChanged(const QString &name, const QUuid &uuid);
 
     void addNewStyle(KisPSDLayerStyleSP style);
     void loadCollection(const QString &fileName);
 
 private slots:
     void loadStyles(const QString &name);
     void selectStyle(QListWidgetItem *previous, QListWidgetItem* current);
 signals:
     void styleSelected(KisPSDLayerStyleSP style);
 
 private:
     void refillCollections();
 
 private:
     Ui::WdgStylesSelector ui;
 };
 
 class KisDlgLayerStyle : public KDialog
 {
     Q_OBJECT
 public:
     explicit KisDlgLayerStyle(KisPSDLayerStyleSP layerStyle, KisCanvasResourceProvider *resourceProvider, QWidget *parent = 0);
     ~KisDlgLayerStyle();
 
     KisPSDLayerStyleSP style() const;
 
 signals:
     void configChanged();
 
 public slots:
+    void slotMasterFxSwitchChanged(bool value);
+
     void notifyGuiConfigChanged();
     void notifyPredefinedStyleSelected(KisPSDLayerStyleSP style);
 
     void changePage(QListWidgetItem *, QListWidgetItem*);
 
     void slotNotifyOnAccept();
     void slotNotifyOnReject();
 
     // Sets all the widgets to the contents of the given style
     void setStyle(KisPSDLayerStyleSP style);
 
     void slotLoadStyle();
     void slotSaveStyle();
     void slotNewStyle();
 
 private:
 
     KisPSDLayerStyleSP m_layerStyle;
     KisPSDLayerStyleSP m_initialLayerStyle;
 
     Ui::WdgStylesDialog wdgLayerStyles;
 
     BevelAndEmboss *m_bevelAndEmboss;
     BlendingOptions *m_blendingOptions;
     ColorOverlay *m_colorOverlay;
     Contour *m_contour;
     DropShadow *m_dropShadow;
     GradientOverlay *m_gradientOverlay;
     InnerGlow *m_innerGlow;
     DropShadow *m_innerShadow;
     InnerGlow *m_outerGlow;
     PatternOverlay * m_patternOverlay;
     Satin *m_satin;
     Stroke *m_stroke;
     StylesSelector *m_stylesSelector;
     Texture *m_texture;
 
     KisSignalCompressor *m_configChangedCompressor;
     bool m_isSwitchingPredefinedStyle;
 
     /**
      * Used for debugging purposes only to track if m_layerStyle is in
      * sync with what is stored in the GUI
      */
     mutable bool m_sanityLayerStyleDirty;
 };
 
 #endif // KIS_DLG_LAYER_STYLE_H
diff --git a/krita/ui/kis_asl_layer_style_serializer.cpp b/krita/ui/kis_asl_layer_style_serializer.cpp
index dbf354bed5..7fb7e070e6 100644
--- a/krita/ui/kis_asl_layer_style_serializer.cpp
+++ b/krita/ui/kis_asl_layer_style_serializer.cpp
@@ -1,1237 +1,1239 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_asl_layer_style_serializer.h"
 
 #include <boost/function.hpp>
 #include <boost/bind.hpp>
 
 #include <QDomDocument>
 
 #include <KoResourceServerProvider.h>
 #include <KoAbstractGradient.h>
 #include <KoSegmentGradient.h>
 #include <KoStopGradient.h>
 #include <KoPattern.h>
 
 #include "kis_dom_utils.h"
 
 
 #include "psd.h"
 #include "kis_global.h"
 #include "kis_psd_layer_style.h"
 
 #include "asl/kis_asl_reader.h"
 #include "asl/kis_asl_xml_parser.h"
 #include "asl/kis_asl_callback_object_catcher.h"
 #include "asl/kis_asl_writer_utils.h"
 
 #include "asl/kis_asl_xml_writer.h"
 #include "asl/kis_asl_writer.h"
 
 
 KisAslLayerStyleSerializer::KisAslLayerStyleSerializer()
 {
 }
 
 KisAslLayerStyleSerializer::~KisAslLayerStyleSerializer()
 {
 }
 
 QVector<KisPSDLayerStyleSP> KisAslLayerStyleSerializer::styles() const
 {
     return m_stylesVector;
 }
 
 void KisAslLayerStyleSerializer::setStyles(const QVector<KisPSDLayerStyleSP> &styles)
 {
     m_stylesVector = styles;
 }
 
 QString compositeOpToBlendMode(const QString &compositeOp)
 {
     QString mode = "Nrml";
 
     if (compositeOp == COMPOSITE_OVER) {
         mode = "Nrml";
     } else if (compositeOp == COMPOSITE_DISSOLVE) {
         mode = "Dslv";
     } else if (compositeOp == COMPOSITE_DARKEN) {
         mode = "Drkn";
     } else if (compositeOp == COMPOSITE_MULT) {
         mode = "Mltp";
     } else if (compositeOp == COMPOSITE_BURN) {
         mode = "CBrn";
     } else if (compositeOp == COMPOSITE_LINEAR_BURN) {
         mode = "linearBurn";
     } else if (compositeOp == COMPOSITE_DARKER_COLOR) {
         mode = "darkerColor";
     } else if (compositeOp == COMPOSITE_LIGHTEN) {
         mode = "Lghn";
     } else if (compositeOp == COMPOSITE_SCREEN) {
         mode = "Scrn";
     } else if (compositeOp == COMPOSITE_DODGE) {
         mode = "CDdg";
     } else if (compositeOp == COMPOSITE_LINEAR_DODGE) {
         mode = "linearDodge";
     } else if (compositeOp == COMPOSITE_LIGHTER_COLOR) {
         mode = "lighterColor";
     } else if (compositeOp == COMPOSITE_OVERLAY) {
         mode = "Ovrl";
     } else if (compositeOp == COMPOSITE_SOFT_LIGHT_PHOTOSHOP) {
         mode = "SftL";
     } else if (compositeOp == COMPOSITE_HARD_LIGHT) {
         mode = "HrdL";
     } else if (compositeOp == COMPOSITE_VIVID_LIGHT) {
         mode = "vividLight";
     } else if (compositeOp == COMPOSITE_LINEAR_LIGHT) {
         mode = "linearLight";
     } else if (compositeOp == COMPOSITE_PIN_LIGHT) {
         mode = "pinLight";
     } else if (compositeOp == COMPOSITE_HARD_MIX) {
         mode = "hardMix";
     } else if (compositeOp == COMPOSITE_DIFF) {
         mode = "Dfrn";
     } else if (compositeOp == COMPOSITE_EXCLUSION) {
         mode = "Xclu";
     } else if (compositeOp == COMPOSITE_SUBTRACT) {
         mode = "Sbtr";
     } else if (compositeOp == COMPOSITE_DIVIDE) {
         mode = "divide";
     } else if (compositeOp == COMPOSITE_HUE) {
         mode = "H   ";
     } else if (compositeOp == COMPOSITE_SATURATION) {
         mode = "Strt";
     } else if (compositeOp == COMPOSITE_COLOR) {
         mode = "Clr ";
     } else if (compositeOp == COMPOSITE_LUMINIZE) {
         mode = "Lmns";
     } else {
         qDebug() << "Unknown composite op:" << mode << "Returning \"Nrml\"!";
     }
 
     return mode;
 }
 
 QString techniqueToString(psd_technique_type technique, const QString &typeId)
 {
     QString result = "SfBL";
 
     switch (technique) {
     case psd_technique_softer:
         result = "SfBL";
         break;
     case psd_technique_precise:
         result = "PrBL";
         break;
     case psd_technique_slope_limit:
         result = "Slmt";
         break;
     }
 
     if (typeId == "BETE" && technique == psd_technique_slope_limit) {
         qWarning() << "WARNING: techniqueToString: invalid technique type!" << ppVar(technique) << ppVar(typeId);
     }
 
     return result;
 }
 
 QString bevelStyleToString(psd_bevel_style style)
 {
     QString result = "OtrB";
 
     switch (style) {
     case psd_bevel_outer_bevel:
         result = "OtrB";
         break;
     case psd_bevel_inner_bevel:
         result = "InrB";
         break;
     case psd_bevel_emboss:
         result = "Embs";
         break;
     case psd_bevel_pillow_emboss:
         result = "PlEb";
         break;
     case psd_bevel_stroke_emboss:
         result = "strokeEmboss";
         break;
     }
 
     return result;
 }
 
 QString gradientTypeToString(psd_gradient_style style)
 {
     QString result = "Lnr ";
 
     switch (style) {
     case psd_gradient_style_linear:
         result = "Lnr ";
         break;
     case psd_gradient_style_radial:
         result = "Rdl ";
         break;
     case psd_gradient_style_angle:
         result = "Angl";
         break;
     case psd_gradient_style_reflected:
         result = "Rflc";
         break;
     case psd_gradient_style_diamond:
         result = "Dmnd";
         break;
     }
 
     return result;
 }
 
 QString strokePositionToString(psd_stroke_position position)
 {
     QString result = "OutF";
 
     switch (position) {
     case psd_stroke_outside:
         result = "OutF";
         break;
     case psd_stroke_inside:
         result = "InsF";
         break;
     case psd_stroke_center:
         result = "CtrF";
         break;
     }
 
     return result;
 }
 
 QString strokeFillTypeToString(psd_fill_type position)
 {
     QString result = "SClr";
 
     switch (position) {
     case psd_fill_solid_color:
         result = "SClr";
         break;
     case psd_fill_gradient:
         result = "GrFl";
         break;
     case psd_fill_pattern:
         result = "Ptrn";
         break;
     }
 
     return result;
 }
 
 QVector<KoPattern*> KisAslLayerStyleSerializer::fetchAllPatterns(KisPSDLayerStyle *style) const
 {
     QVector <KoPattern*> allPatterns;
 
     if (style->patternOverlay()->effectEnabled()) {
         allPatterns << style->patternOverlay()->pattern();
     }
 
     if (style->stroke()->effectEnabled() &&
         style->stroke()->fillType() == psd_fill_pattern) {
 
         allPatterns << style->stroke()->pattern();
     }
 
     if(style->bevelAndEmboss()->effectEnabled() &&
        style->bevelAndEmboss()->textureEnabled()) {
 
         allPatterns << style->bevelAndEmboss()->texturePattern();
     }
 
     return allPatterns;
 }
 
 QString fetchPatternUuidSafe(KoPattern *pattern, QHash<KoPattern*, QString> patternToUuid)
 {
     if (patternToUuid.contains(pattern)) {
         return patternToUuid[pattern];
     } else {
         qWarning() << "WARNING: the pattern is not present in the Uuid map!";
         return "invalid-uuid";
     }
 }
 
 QDomDocument KisAslLayerStyleSerializer::formXmlDocument() const
 {
     KIS_ASSERT_RECOVER(!m_stylesVector.isEmpty()) { return QDomDocument(); }
 
     QVector<KoPattern*> allPatterns;
 
     foreach (KisPSDLayerStyleSP style, m_stylesVector) {
         allPatterns += fetchAllPatterns(style.data());
     }
 
     QHash<KoPattern*, QString> patternToUuidMap;
 
     KisAslXmlWriter w;
 
     if (!allPatterns.isEmpty()) {
         w.enterList("Patterns");
 
         foreach (KoPattern *pattern, allPatterns) {
             if (pattern) {
                 if (!patternToUuidMap.contains(pattern)) {
                     QString uuid = w.writePattern("", pattern);
                     patternToUuidMap.insert(pattern, uuid);
                 }
             } else {
                 qWarning() << "WARNING: KisAslLayerStyleSerializer::saveToDevice: saved pattern is null!";
             }
         }
 
         w.leaveList();
     }
 
     foreach (KisPSDLayerStyleSP style, m_stylesVector) {
 
         w.enterDescriptor("", "", "null");
         w.writeText("Nm  ", style->name());
         w.writeText("Idnt", style->psdUuid());
         w.leaveDescriptor();
 
         w.enterDescriptor("", "", "Styl");
 
         w.enterDescriptor("documentMode", "", "documentMode");
         w.leaveDescriptor();
 
         w.enterDescriptor("Lefx", "", "Lefx");
 
         w.writeUnitFloat("Scl ", "#Prc", 100);
-        w.writeBoolean("masterFXSwitch", true);
+        w.writeBoolean("masterFXSwitch", style->isEnabled());
 
 
         // Drop Shadow
         const psd_layer_effects_drop_shadow *dropShadow = style->dropShadow();
         if (dropShadow->effectEnabled()) {
             w.enterDescriptor("DrSh", "", "DrSh");
 
             w.writeBoolean("enab", dropShadow->effectEnabled());
             w.writeEnum("Md  ", "BlnM", compositeOpToBlendMode(dropShadow->blendMode()));
             w.writeColor("Clr ", dropShadow->color());
 
             w.writeUnitFloat("Opct", "#Prc", dropShadow->opacity());
             w.writeBoolean("uglg", dropShadow->useGlobalLight());
             w.writeUnitFloat("lagl", "#Ang", dropShadow->angle());
             w.writeUnitFloat("Dstn", "#Pxl", dropShadow->distance());
             w.writeUnitFloat("Ckmt", "#Pxl", dropShadow->spread());
             w.writeUnitFloat("blur", "#Pxl", dropShadow->size());
             w.writeUnitFloat("Nose", "#Prc", dropShadow->noise());
 
             w.writeBoolean("AntA", dropShadow->antiAliased());
 
             // FIXME: save curves
             w.writeCurve("TrnS",
                          "Linear",
                          QVector<QPointF>() << QPointF() << QPointF(255, 255));
 
             w.writeBoolean("layerConceals", dropShadow->knocksOut());
             w.leaveDescriptor();
         }
 
         // Inner Shadow
         const psd_layer_effects_inner_shadow *innerShadow = style->innerShadow();
         if (innerShadow->effectEnabled()) {
             w.enterDescriptor("IrSh", "", "IrSh");
 
             w.writeBoolean("enab", innerShadow->effectEnabled());
             w.writeEnum("Md  ", "BlnM", compositeOpToBlendMode(innerShadow->blendMode()));
             w.writeColor("Clr ", innerShadow->color());
 
             w.writeUnitFloat("Opct", "#Prc", innerShadow->opacity());
             w.writeBoolean("uglg", innerShadow->useGlobalLight());
             w.writeUnitFloat("lagl", "#Ang", innerShadow->angle());
             w.writeUnitFloat("Dstn", "#Pxl", innerShadow->distance());
             w.writeUnitFloat("Ckmt", "#Pxl", innerShadow->spread());
             w.writeUnitFloat("blur", "#Pxl", innerShadow->size());
             w.writeUnitFloat("Nose", "#Prc", innerShadow->noise());
 
             w.writeBoolean("AntA", innerShadow->antiAliased());
 
             // FIXME: save curves
             w.writeCurve("TrnS",
                          "Linear",
                          QVector<QPointF>() << QPointF() << QPointF(255, 255));
 
             w.leaveDescriptor();
         }
 
         // Outer Glow
         const psd_layer_effects_outer_glow *outerGlow = style->outerGlow();
         if (outerGlow->effectEnabled()) {
             w.enterDescriptor("OrGl", "", "OrGl");
 
             w.writeBoolean("enab", outerGlow->effectEnabled());
             w.writeEnum("Md  ", "BlnM", compositeOpToBlendMode(outerGlow->blendMode()));
 
 
             if (outerGlow->fillType() == psd_fill_gradient && outerGlow->gradient()) {
                 KoSegmentGradient *segmentGradient = dynamic_cast<KoSegmentGradient*>(outerGlow->gradient().data());
                 KoStopGradient *stopGradient = dynamic_cast<KoStopGradient*>(outerGlow->gradient().data());
 
                 if (segmentGradient) {
                     w.writeSegmentGradient("Grad", segmentGradient);
                 } else if (stopGradient) {
                     w.writeStopGradient("Grad", stopGradient);
                 } else {
                     qWarning() << "WARNING: OG: Unknown gradient type!";
                     w.writeColor("Clr ", outerGlow->color());
                 }
 
             } else {
                 w.writeColor("Clr ", outerGlow->color());
             }
 
             w.writeUnitFloat("Opct", "#Prc", outerGlow->opacity());
 
             w.writeEnum("GlwT", "BETE", techniqueToString(outerGlow->technique(), "BETE"));
 
             w.writeUnitFloat("Ckmt", "#Pxl", outerGlow->spread());
             w.writeUnitFloat("blur", "#Pxl", outerGlow->size());
             w.writeUnitFloat("Nose", "#Prc", outerGlow->noise());
 
             w.writeUnitFloat("ShdN", "#Prc", outerGlow->jitter());
 
             w.writeBoolean("AntA", outerGlow->antiAliased());
 
             // FIXME: save curves
             w.writeCurve("TrnS",
                          "Linear",
                          QVector<QPointF>() << QPointF() << QPointF(255, 255));
 
             w.writeUnitFloat("Inpr", "#Prc", outerGlow->range());
 
             w.leaveDescriptor();
         }
 
         // Inner Glow
         const psd_layer_effects_inner_glow *innerGlow = style->innerGlow();
         if (innerGlow->effectEnabled()) {
             w.enterDescriptor("IrGl", "", "IrGl");
 
             w.writeBoolean("enab", innerGlow->effectEnabled());
             w.writeEnum("Md  ", "BlnM", compositeOpToBlendMode(innerGlow->blendMode()));
 
 
             if (innerGlow->fillType() == psd_fill_gradient && innerGlow->gradient()) {
                 KoSegmentGradient *segmentGradient = dynamic_cast<KoSegmentGradient*>(innerGlow->gradient().data());
                 KoStopGradient *stopGradient = dynamic_cast<KoStopGradient*>(innerGlow->gradient().data());
 
                 if (segmentGradient) {
                     w.writeSegmentGradient("Grad", segmentGradient);
                 } else if (stopGradient) {
                     w.writeStopGradient("Grad", stopGradient);
                 } else {
                     qWarning() << "WARNING: IG: Unknown gradient type!";
                     w.writeColor("Clr ", innerGlow->color());
                 }
 
             } else {
                 w.writeColor("Clr ", innerGlow->color());
             }
 
             w.writeUnitFloat("Opct", "#Prc", innerGlow->opacity());
 
             w.writeEnum("GlwT", "BETE", techniqueToString(innerGlow->technique(), "BETE"));
 
             w.writeUnitFloat("Ckmt", "#Pxl", innerGlow->spread());
             w.writeUnitFloat("blur", "#Pxl", innerGlow->size());
 
             // NOTE: order is swapped in ASL!
             w.writeUnitFloat("ShdN", "#Prc", innerGlow->jitter());
             w.writeUnitFloat("Nose", "#Prc", innerGlow->noise());
 
             w.writeBoolean("AntA", innerGlow->antiAliased());
 
             w.writeEnum("glwS", "IGSr", innerGlow->source() == psd_glow_center ? "SrcC" : "SrcE");
 
             // FIXME: save curves
             w.writeCurve("TrnS",
                          "Linear",
                          QVector<QPointF>() << QPointF() << QPointF(255, 255));
 
             w.writeUnitFloat("Inpr", "#Prc", innerGlow->range());
 
             w.leaveDescriptor();
         }
 
         // Bevel and Emboss
         const psd_layer_effects_bevel_emboss *bevelAndEmboss = style->bevelAndEmboss();
         if (bevelAndEmboss->effectEnabled()) {
             w.enterDescriptor("ebbl", "", "ebbl");
 
             w.writeBoolean("enab", bevelAndEmboss->effectEnabled());
 
             w.writeEnum("hglM", "BlnM", compositeOpToBlendMode(bevelAndEmboss->highlightBlendMode()));
             w.writeColor("hglC", bevelAndEmboss->highlightColor());
             w.writeUnitFloat("hglO", "#Prc", bevelAndEmboss->highlightOpacity());
 
             w.writeEnum("sdwM", "BlnM", compositeOpToBlendMode(bevelAndEmboss->shadowBlendMode()));
             w.writeColor("sdwC", bevelAndEmboss->shadowColor());
             w.writeUnitFloat("sdwO", "#Prc", bevelAndEmboss->shadowOpacity());
 
             w.writeEnum("bvlT", "bvlT", techniqueToString(bevelAndEmboss->technique(), "bvlT"));
             w.writeEnum("bvlS", "BESl", bevelStyleToString(bevelAndEmboss->style()));
 
             w.writeBoolean("uglg", bevelAndEmboss->useGlobalLight());
             w.writeUnitFloat("lagl", "#Ang", bevelAndEmboss->angle());
             w.writeUnitFloat("Lald", "#Ang", bevelAndEmboss->altitude());
 
             w.writeUnitFloat("srgR", "#Prc", bevelAndEmboss->depth());
             w.writeUnitFloat("blur", "#Pxl", bevelAndEmboss->size());
             w.writeEnum("bvlD", "BESs", bevelAndEmboss->direction() == psd_direction_up ? "In  " : "Out ");
 
             // FIXME: save curves
             w.writeCurve("TrnS",
                          "Linear",
                          QVector<QPointF>() << QPointF() << QPointF(255, 255));
 
             w.writeBoolean("antialiasGloss", bevelAndEmboss->glossAntiAliased());
 
             w.writeUnitFloat("Sftn", "#Pxl", bevelAndEmboss->soften());
 
             if (bevelAndEmboss->contourEnabled()) {
                 w.writeBoolean("useShape", bevelAndEmboss->contourEnabled());
 
                 // FIXME: save curves
                 w.writeCurve("MpgS",
                              "Linear",
                              QVector<QPointF>() << QPointF() << QPointF(255, 255));
 
                 w.writeBoolean("AntA", bevelAndEmboss->antiAliased());
                 w.writeUnitFloat("Inpr", "#Prc", bevelAndEmboss->contourRange());
             }
 
             w.writeBoolean("useTexture", bevelAndEmboss->textureEnabled());
 
             if (bevelAndEmboss->textureEnabled()) {
                 w.writeBoolean("InvT", bevelAndEmboss->textureInvert());
                 w.writeBoolean("Algn", bevelAndEmboss->textureAlignWithLayer());
                 w.writeUnitFloat("Scl ", "#Prc", bevelAndEmboss->textureScale());
                 w.writeUnitFloat("textureDepth ", "#Prc", bevelAndEmboss->textureDepth());
                 w.writePatternRef("Ptrn", bevelAndEmboss->texturePattern(), fetchPatternUuidSafe(bevelAndEmboss->texturePattern(), patternToUuidMap));
                 w.writePhasePoint("phase", bevelAndEmboss->texturePhase());
             }
 
             w.leaveDescriptor();
         }
 
         // Satin
         const psd_layer_effects_satin *satin = style->satin();
         if (satin->effectEnabled()) {
             w.enterDescriptor("ChFX", "", "ChFX");
 
             w.writeBoolean("enab", satin->effectEnabled());
             w.writeEnum("Md  ", "BlnM", compositeOpToBlendMode(satin->blendMode()));
             w.writeColor("Clr ", satin->color());
 
             w.writeBoolean("AntA", satin->antiAliased());
             w.writeBoolean("Invr", satin->invert());
             w.writeUnitFloat("Opct", "#Prc", satin->opacity());
             w.writeUnitFloat("lagl", "#Ang", satin->angle());
             w.writeUnitFloat("Dstn", "#Pxl", satin->distance());
             w.writeUnitFloat("blur", "#Pxl", satin->size());
 
             // FIXME: save curves
             w.writeCurve("MpgS",
                          "Linear",
                          QVector<QPointF>() << QPointF() << QPointF(255, 255));
 
             w.leaveDescriptor();
         }
 
         const psd_layer_effects_color_overlay *colorOverlay = style->colorOverlay();
         if (colorOverlay->effectEnabled()) {
             w.enterDescriptor("SoFi", "", "SoFi");
 
             w.writeBoolean("enab", colorOverlay->effectEnabled());
             w.writeEnum("Md  ", "BlnM", compositeOpToBlendMode(colorOverlay->blendMode()));
             w.writeUnitFloat("Opct", "#Prc", colorOverlay->opacity());
             w.writeColor("Clr ", colorOverlay->color());
 
             w.leaveDescriptor();
         }
 
         // Gradient Overlay
         const psd_layer_effects_gradient_overlay *gradientOverlay = style->gradientOverlay();
         KoSegmentGradient *segmentGradient = dynamic_cast<KoSegmentGradient*>(gradientOverlay->gradient().data());
         KoStopGradient *stopGradient = dynamic_cast<KoStopGradient*>(gradientOverlay->gradient().data());
 
         if (gradientOverlay->effectEnabled() && (segmentGradient || stopGradient)) {
             w.enterDescriptor("GrFl", "", "GrFl");
 
             w.writeBoolean("enab", gradientOverlay->effectEnabled());
             w.writeEnum("Md  ", "BlnM", compositeOpToBlendMode(gradientOverlay->blendMode()));
             w.writeUnitFloat("Opct", "#Prc", gradientOverlay->opacity());
 
             if (segmentGradient) {
                 w.writeSegmentGradient("Grad", segmentGradient);
             } else if (stopGradient) {
                 w.writeStopGradient("Grad", stopGradient);
             }
 
             w.writeUnitFloat("Angl", "#Ang", gradientOverlay->angle());
 
             w.writeEnum("Type", "GrdT", gradientTypeToString(gradientOverlay->style()));
 
             w.writeBoolean("Rvrs", gradientOverlay->reverse());
             w.writeBoolean("Algn", gradientOverlay->alignWithLayer());
             w.writeUnitFloat("Scl ", "#Prc", gradientOverlay->scale());
 
             w.writeOffsetPoint("Ofst", gradientOverlay->gradientOffset());
 
             // FIXME: Krita doesn't support dithering
             w.writeBoolean("Dthr", true/*gradientOverlay->dither()*/);
 
             w.leaveDescriptor();
         }
 
         // Pattern Overlay
         const psd_layer_effects_pattern_overlay *patternOverlay = style->patternOverlay();
         if (patternOverlay->effectEnabled()) {
             w.enterDescriptor("patternFill", "", "patternFill");
 
             w.writeBoolean("enab", patternOverlay->effectEnabled());
             w.writeEnum("Md  ", "BlnM", compositeOpToBlendMode(patternOverlay->blendMode()));
             w.writeUnitFloat("Opct", "#Prc", patternOverlay->opacity());
 
             w.writePatternRef("Ptrn", patternOverlay->pattern(), fetchPatternUuidSafe(patternOverlay->pattern(), patternToUuidMap));
 
             w.writeUnitFloat("Scl ", "#Prc", patternOverlay->scale());
             w.writeBoolean("Algn", patternOverlay->alignWithLayer());
             w.writePhasePoint("phase", patternOverlay->patternPhase());
 
             w.leaveDescriptor();
         }
 
         const psd_layer_effects_stroke *stroke = style->stroke();
         if (stroke->effectEnabled()) {
             w.enterDescriptor("FrFX", "", "FrFX");
 
             w.writeBoolean("enab", stroke->effectEnabled());
 
             w.writeEnum("Styl", "FStl", strokePositionToString(stroke->position()));
             w.writeEnum("PntT", "FrFl", strokeFillTypeToString(stroke->fillType()));
 
             w.writeEnum("Md  ", "BlnM", compositeOpToBlendMode(stroke->blendMode()));
             w.writeUnitFloat("Opct", "#Prc", stroke->opacity());
 
             w.writeUnitFloat("Sz  ", "#Pxl", stroke->size());
 
             if (stroke->fillType() == psd_fill_solid_color) {
                 w.writeColor("Clr ", stroke->color());
             } else if (stroke->fillType() == psd_fill_gradient) {
                 KoSegmentGradient *segmentGradient = dynamic_cast<KoSegmentGradient*>(stroke->gradient().data());
                 KoStopGradient *stopGradient = dynamic_cast<KoStopGradient*>(stroke->gradient().data());
 
                 if (segmentGradient) {
                     w.writeSegmentGradient("Grad", segmentGradient);
                 } else if (stopGradient) {
                     w.writeStopGradient("Grad", stopGradient);
                 } else {
                     qWarning() << "WARNING: Stroke: Unknown gradient type!";
                     w.writeColor("Clr ", stroke->color());
                 }
 
                 w.writeUnitFloat("Angl", "#Ang", stroke->angle());
                 w.writeEnum("Type", "GrdT", gradientTypeToString(stroke->style()));
 
                 w.writeBoolean("Rvrs", stroke->reverse());
                 w.writeUnitFloat("Scl ", "#Prc", stroke->scale());
                 w.writeBoolean("Algn", stroke->alignWithLayer());
                 w.writeOffsetPoint("Ofst", stroke->gradientOffset());
 
                 // FIXME: Krita doesn't support dithering
                 w.writeBoolean("Dthr", true/*stroke->dither()*/);
 
             } else if (stroke->fillType() == psd_fill_pattern) {
                 w.writePatternRef("Ptrn", stroke->pattern(), fetchPatternUuidSafe(stroke->pattern(), patternToUuidMap));
                 w.writeUnitFloat("Scl ", "#Prc", stroke->scale());
                 w.writeBoolean("Lnkd", stroke->alignWithLayer());
                 w.writePhasePoint("phase", stroke->patternPhase());
             }
 
             w.leaveDescriptor();
         }
 
         w.leaveDescriptor();
         w.leaveDescriptor();
     }
 
     return w.document();
 }
 
 inline QDomNode findNodeByClassId(const QString &classId, QDomNode parent) {
     return KisDomUtils::findElementByAttibute(parent, "node", "classId", classId);
 }
 
 void replaceAllChildren(QDomNode src, QDomNode dst)
 {
     QDomNode node;
 
     do {
         node = dst.lastChild();
         dst.removeChild(node);
 
     } while(!node.isNull());
 
 
     node = src.firstChild();
     while(!node.isNull()) {
         dst.appendChild(node);
         node = src.firstChild();
     }
 
     src.parentNode().removeChild(src);
 }
 
 QDomDocument KisAslLayerStyleSerializer::formPsdXmlDocument() const
 {
     QDomDocument doc = formXmlDocument();
 
     QDomNode nullNode = findNodeByClassId("null", doc.documentElement());
     QDomNode stylNode = findNodeByClassId("Styl", doc.documentElement());
     QDomNode lefxNode = findNodeByClassId("Lefx", stylNode);
 
     replaceAllChildren(lefxNode, nullNode);
 
     return doc;
 }
 
 void KisAslLayerStyleSerializer::saveToDevice(QIODevice *device)
 {
     QDomDocument doc = formXmlDocument();
     if (doc.isNull()) return ;
 
     KisAslWriter writer;
     writer.writeFile(device, doc);
 }
 
 void convertAndSetBlendMode(const QString &mode,
                             boost::function<void (const QString &)> setBlendMode)
 {
     QString compositeOp = COMPOSITE_OVER;
 
     if (mode == "Nrml") {
         compositeOp = COMPOSITE_OVER;
     } else if (mode == "Dslv") {
         compositeOp = COMPOSITE_DISSOLVE;
     } else if (mode == "Drkn") {
         compositeOp = COMPOSITE_DARKEN;
     } else if (mode == "Mltp") {
         compositeOp = COMPOSITE_MULT;
     } else if (mode == "CBrn") {
         compositeOp = COMPOSITE_BURN;
     } else if (mode == "linearBurn") {
         compositeOp = COMPOSITE_LINEAR_BURN;
     } else if (mode == "darkerColor") {
         compositeOp = COMPOSITE_DARKER_COLOR;
     } else if (mode == "Lghn") {
         compositeOp = COMPOSITE_LIGHTEN;
     } else if (mode == "Scrn") {
         compositeOp = COMPOSITE_SCREEN;
     } else if (mode == "CDdg") {
         compositeOp = COMPOSITE_DODGE;
     } else if (mode == "linearDodge") {
         compositeOp = COMPOSITE_LINEAR_DODGE;
     } else if (mode == "lighterColor") {
         compositeOp = COMPOSITE_LIGHTER_COLOR;
     } else if (mode == "Ovrl") {
         compositeOp = COMPOSITE_OVERLAY;
     } else if (mode == "SftL") {
         compositeOp = COMPOSITE_SOFT_LIGHT_PHOTOSHOP;
     } else if (mode == "HrdL") {
         compositeOp = COMPOSITE_HARD_LIGHT;
     } else if (mode == "vividLight") {
         compositeOp = COMPOSITE_VIVID_LIGHT;
     } else if (mode == "linearLight") {
         compositeOp = COMPOSITE_LINEAR_LIGHT;
     } else if (mode == "pinLight") {
         compositeOp = COMPOSITE_PIN_LIGHT;
     } else if (mode == "hardMix") {
         compositeOp = COMPOSITE_HARD_MIX;
     } else if (mode == "Dfrn") {
         compositeOp = COMPOSITE_DIFF;
     } else if (mode == "Xclu") {
         compositeOp = COMPOSITE_EXCLUSION;
     } else if (mode == "Sbtr") {
         compositeOp = COMPOSITE_SUBTRACT;
     } else if (mode == "divide") {
         compositeOp = COMPOSITE_DIVIDE;
     } else if (mode == "H   ") {
         compositeOp = COMPOSITE_HUE;
     } else if (mode == "Strt") {
         compositeOp = COMPOSITE_SATURATION;
     } else if (mode == "Clr ") {
         compositeOp = COMPOSITE_COLOR;
     } else if (mode == "Lmns") {
         compositeOp = COMPOSITE_LUMINIZE;
     } else {
         qDebug() << "Unknown blending mode:" << mode << "Returning COMPOSITE_OVER!";
     }
 
     setBlendMode(compositeOp);
 }
 
 void convertAndSetCurve(const QString &name,
                         const QVector<QPointF> &points,
                         boost::function<void (const quint8*)> setCurveLookupTable)
 {
     Q_UNUSED(name);
     Q_UNUSED(points);
     Q_UNUSED(setCurveLookupTable);
 
     qWarning() << "convertAndSetBlendMode:" << "Curve conversion is not implemented yet";
 }
 
 template <typename T>
 void convertAndSetEnum(const QString &value,
                        const QMap<QString, T> map,
                        boost::function<void (T)> setMappedValue)
 {
     setMappedValue(map[value]);
 }
 
 inline QString _prepaddr(const QString &pref, const QString &addr) {
     return pref + addr;
 }
 
 #define CONN_TEXT_RADDR(addr, method, object, type) m_catcher.subscribeText(addr, boost::bind(&type::method, object, _1))
 #define CONN_COLOR(addr, method, object, type, prefix) m_catcher.subscribeColor(_prepaddr(prefix, addr), boost::bind(&type::method, object, _1))
 #define CONN_UNITF(addr, unit, method, object, type, prefix) m_catcher.subscribeUnitFloat(_prepaddr(prefix, addr), unit, boost::bind(&type::method, object, _1))
 #define CONN_BOOL(addr, method, object, type, prefix) m_catcher.subscribeBoolean(_prepaddr(prefix, addr), boost::bind(&type::method, object, _1))
 
 #define CONN_POINT(addr, method, object, type, prefix) m_catcher.subscribePoint(_prepaddr(prefix, addr), boost::bind(&type::method, object, _1))
 
 #define CONN_COMPOSITE_OP(addr, method, object, type, prefix)                   \
     {                                                                   \
         boost::function<void (const QString&)> setter =                 \
             boost::bind(&type::method, object, _1);                     \
         m_catcher.subscribeEnum(_prepaddr(prefix, addr), "BlnM", boost::bind(convertAndSetBlendMode, _1, setter)); \
     }
 
 #define CONN_CURVE(addr, method, object, type, prefix)                          \
     {                                                                   \
         boost::function<void (const quint8*)> setter =                  \
             boost::bind(&type::method, object, _1);                     \
         m_catcher.subscribeCurve(_prepaddr(prefix, addr), boost::bind(convertAndSetCurve, _1, _2, setter)); \
     }
 
 #define CONN_ENUM(addr, tag, method, map, mapped_type, object, type, prefix)                       \
     {                                                                   \
         boost::function<void (mapped_type)> setter =                  \
             boost::bind(&type::method, object, _1);                     \
         m_catcher.subscribeEnum(_prepaddr(prefix, addr), tag, boost::bind(convertAndSetEnum<mapped_type>, _1, map, setter)); \
     }
 
 #define CONN_GRADIENT(addr, method, object, type, prefix)                      \
     {                                                                  \
         m_catcher.subscribeGradient(_prepaddr(prefix, addr), boost::bind(&type::method, object, _1)); \
     }
 
 #define CONN_PATTERN(addr, method, object, type, prefix)                       \
     {                                                                  \
         boost::function<void (KoPattern*)> setter =    \
             boost::bind(&type::method, object, _1);                     \
         m_catcher.subscribePatternRef(_prepaddr(prefix, addr), boost::bind(&KisAslLayerStyleSerializer::assignPatternObject, this, _1, _2, setter)); \
     }
 
 void KisAslLayerStyleSerializer::registerPatternObject(const KoPattern *pattern) {
     QString uuid = KisAslWriterUtils::getPatternUuidLazy(pattern);
 
     if (m_patternsStore.contains(uuid)) {
         qWarning() << "WARNING: ASL style contains a duplicated pattern!" << ppVar(pattern->name()) << ppVar(m_patternsStore[uuid]->name());
     } else {
         KoResourceServer<KoPattern> *server = KoResourceServerProvider::instance()->patternServer();
         KoPattern *patternToAdd = server->resourceByMD5(pattern->md5());
 
         if (!patternToAdd) {
             patternToAdd = pattern->clone();
             server->addResource(patternToAdd, false);
         }
 
         m_patternsStore.insert(uuid, patternToAdd);
     }
 }
 
 void KisAslLayerStyleSerializer::assignPatternObject(const QString &patternUuid,
                                                      const QString &patternName,
                                                      boost::function<void (KoPattern *)> setPattern)
 {
     Q_UNUSED(patternName);
 
     KoPattern *pattern = m_patternsStore[patternUuid];
 
     if (!pattern) {
         qWarning() << "WARNING: ASL style contains inexistent pattern reference!";
 
         QImage dumbImage(32, 32, QImage::Format_ARGB32);
         dumbImage.fill(Qt::red);
         KoPattern *dumbPattern = new KoPattern(dumbImage, "invalid", "");
         registerPatternObject(dumbPattern);
         pattern = dumbPattern;
     }
 
     setPattern(pattern);
 }
 
 class FillStylesCorrector {
 public:
 
     static void correct(KisPSDLayerStyle *style) {
         correctWithoutPattern(style->outerGlow());
         correctWithoutPattern(style->innerGlow());
         correctWithPattern(style->stroke());
     }
 
 private:
 
     template <class T>
     static void correctWithPattern(T *config) {
         if (config->pattern()) {
             config->setFillType(psd_fill_pattern);
         } else if (config->gradient()) {
             config->setFillType(psd_fill_gradient);
         } else {
             config->setFillType(psd_fill_solid_color);
         }
     }
 
     template <class T>
     static void correctWithoutPattern(T *config) {
         if (config->gradient()) {
             config->setFillType(psd_fill_gradient);
         } else {
             config->setFillType(psd_fill_solid_color);
         }
     }
 };
 
 void KisAslLayerStyleSerializer::connectCatcherToStyle(KisPSDLayerStyle *style, const QString &prefix)
 {
     CONN_TEXT_RADDR("/null/Nm  ", setName, style, KisPSDLayerStyle);
     CONN_TEXT_RADDR("/null/Idnt", setPsdUuid, style, KisPSDLayerStyle);
 
+    CONN_BOOL("/masterFXSwitch", setEnabled, style, KisPSDLayerStyle, prefix);
+
     psd_layer_effects_drop_shadow *dropShadow = style->dropShadow();
 
     CONN_COMPOSITE_OP("/DrSh/Md  ", setBlendMode, dropShadow, psd_layer_effects_drop_shadow, prefix);
     CONN_COLOR("/DrSh/Clr ", setColor, dropShadow, psd_layer_effects_drop_shadow, prefix);
     CONN_UNITF("/DrSh/Opct", "#Prc", setOpacity, dropShadow, psd_layer_effects_drop_shadow, prefix);
     CONN_UNITF("/DrSh/lagl", "#Ang", setAngle, dropShadow, psd_layer_effects_drop_shadow, prefix);
     CONN_UNITF("/DrSh/Dstn", "#Pxl", setDistance, dropShadow, psd_layer_effects_drop_shadow, prefix);
     CONN_UNITF("/DrSh/Ckmt", "#Pxl", setSpread, dropShadow, psd_layer_effects_drop_shadow, prefix);
     CONN_UNITF("/DrSh/blur", "#Pxl", setSize, dropShadow, psd_layer_effects_drop_shadow, prefix);
     CONN_UNITF("/DrSh/Nose", "#Prc", setNoise, dropShadow, psd_layer_effects_drop_shadow, prefix);
     CONN_BOOL("/DrSh/enab", setEffectEnabled, dropShadow, psd_layer_effects_drop_shadow, prefix);
     CONN_BOOL("/DrSh/uglg", setUseGlobalLight, dropShadow, psd_layer_effects_drop_shadow, prefix);
     CONN_BOOL("/DrSh/AntA", setAntiAliased, dropShadow, psd_layer_effects_drop_shadow, prefix);
     CONN_BOOL("/DrSh/layerConceals", setKnocksOut, dropShadow, psd_layer_effects_drop_shadow, prefix);
     CONN_CURVE("/DrSh/TrnS", setContourLookupTable, dropShadow, psd_layer_effects_drop_shadow, prefix);
 
     psd_layer_effects_inner_shadow *innerShadow = style->innerShadow();
 
     CONN_COMPOSITE_OP("/IrSh/Md  ", setBlendMode, innerShadow, psd_layer_effects_inner_shadow, prefix);
     CONN_COLOR("/IrSh/Clr ", setColor, innerShadow, psd_layer_effects_inner_shadow, prefix);
     CONN_UNITF("/IrSh/Opct", "#Prc", setOpacity, innerShadow, psd_layer_effects_inner_shadow, prefix);
     CONN_UNITF("/IrSh/lagl", "#Ang", setAngle, innerShadow, psd_layer_effects_inner_shadow, prefix);
     CONN_UNITF("/IrSh/Dstn", "#Pxl", setDistance, innerShadow, psd_layer_effects_inner_shadow, prefix);
     CONN_UNITF("/IrSh/Ckmt", "#Pxl", setSpread, innerShadow, psd_layer_effects_inner_shadow, prefix);
     CONN_UNITF("/IrSh/blur", "#Pxl", setSize, innerShadow, psd_layer_effects_inner_shadow, prefix);
     CONN_UNITF("/IrSh/Nose", "#Prc", setNoise, innerShadow, psd_layer_effects_inner_shadow, prefix);
     CONN_BOOL("/IrSh/enab", setEffectEnabled, innerShadow, psd_layer_effects_inner_shadow, prefix);
     CONN_BOOL("/IrSh/uglg", setUseGlobalLight, innerShadow, psd_layer_effects_inner_shadow, prefix);
     CONN_BOOL("/IrSh/AntA", setAntiAliased, innerShadow, psd_layer_effects_inner_shadow, prefix);
     CONN_CURVE("/IrSh/TrnS", setContourLookupTable, innerShadow, psd_layer_effects_inner_shadow, prefix);
 
     psd_layer_effects_outer_glow *outerGlow = style->outerGlow();
 
     CONN_COMPOSITE_OP("/OrGl/Md  ", setBlendMode, outerGlow, psd_layer_effects_outer_glow, prefix);
     CONN_COLOR("/OrGl/Clr ", setColor, outerGlow, psd_layer_effects_outer_glow, prefix);
     CONN_UNITF("/OrGl/Opct", "#Prc", setOpacity, outerGlow, psd_layer_effects_outer_glow, prefix);
     CONN_UNITF("/OrGl/Ckmt", "#Pxl", setSpread, outerGlow, psd_layer_effects_outer_glow, prefix);
     CONN_UNITF("/OrGl/blur", "#Pxl", setSize, outerGlow, psd_layer_effects_outer_glow, prefix);
     CONN_UNITF("/OrGl/Nose", "#Prc", setNoise, outerGlow, psd_layer_effects_outer_glow, prefix);
     CONN_BOOL("/OrGl/enab", setEffectEnabled, outerGlow, psd_layer_effects_outer_glow, prefix);
     CONN_BOOL("/OrGl/AntA", setAntiAliased, outerGlow, psd_layer_effects_outer_glow, prefix);
     CONN_CURVE("/OrGl/TrnS", setContourLookupTable, outerGlow, psd_layer_effects_outer_glow, prefix);
 
     QMap<QString, psd_technique_type> fillTechniqueMap;
     fillTechniqueMap.insert("PrBL", psd_technique_precise);
     fillTechniqueMap.insert("SfBL", psd_technique_softer);
     CONN_ENUM("/OrGl/GlwT", "BETE", setTechnique, fillTechniqueMap, psd_technique_type, outerGlow, psd_layer_effects_outer_glow, prefix);
 
     CONN_GRADIENT("/OrGl/Grad", setGradient, outerGlow, psd_layer_effects_outer_glow, prefix);
 
     CONN_UNITF("/OrGl/Inpr", "#Prc", setRange, outerGlow, psd_layer_effects_outer_glow, prefix);
     CONN_UNITF("/OrGl/ShdN", "#Prc", setJitter, outerGlow, psd_layer_effects_outer_glow, prefix);
 
 
     psd_layer_effects_inner_glow *innerGlow = style->innerGlow();
 
     CONN_COMPOSITE_OP("/IrGl/Md  ", setBlendMode, innerGlow, psd_layer_effects_inner_glow, prefix);
     CONN_COLOR("/IrGl/Clr ", setColor, innerGlow, psd_layer_effects_inner_glow, prefix);
     CONN_UNITF("/IrGl/Opct", "#Prc", setOpacity, innerGlow, psd_layer_effects_inner_glow, prefix);
     CONN_UNITF("/IrGl/Ckmt", "#Pxl", setSpread, innerGlow, psd_layer_effects_inner_glow, prefix);
     CONN_UNITF("/IrGl/blur", "#Pxl", setSize, innerGlow, psd_layer_effects_inner_glow, prefix);
     CONN_UNITF("/IrGl/Nose", "#Prc", setNoise, innerGlow, psd_layer_effects_inner_glow, prefix);
     CONN_BOOL("/IrGl/enab", setEffectEnabled, innerGlow, psd_layer_effects_inner_glow, prefix);
     CONN_BOOL("/IrGl/AntA", setAntiAliased, innerGlow, psd_layer_effects_inner_glow, prefix);
     CONN_CURVE("/IrGl/TrnS", setContourLookupTable, innerGlow, psd_layer_effects_inner_glow, prefix);
 
     CONN_ENUM("/IrGl/GlwT", "BETE", setTechnique, fillTechniqueMap, psd_technique_type, innerGlow, psd_layer_effects_inner_glow, prefix);
 
     CONN_GRADIENT("/IrGl/Grad", setGradient, innerGlow, psd_layer_effects_inner_glow, prefix);
 
     CONN_UNITF("/IrGl/Inpr", "#Prc", setRange, innerGlow, psd_layer_effects_inner_glow, prefix);
     CONN_UNITF("/IrGl/ShdN", "#Prc", setJitter, innerGlow, psd_layer_effects_inner_glow, prefix);
 
     QMap<QString, psd_glow_source> glowSourceMap;
     glowSourceMap.insert("SrcC", psd_glow_center);
     glowSourceMap.insert("SrcE", psd_glow_edge);
     CONN_ENUM("/IrGl/glwS", "IGSr", setSource, glowSourceMap, psd_glow_source, innerGlow, psd_layer_effects_inner_glow, prefix);
 
 
     psd_layer_effects_satin *satin = style->satin();
 
     CONN_COMPOSITE_OP("/ChFX/Md  ", setBlendMode, satin, psd_layer_effects_satin, prefix);
     CONN_COLOR("/ChFX/Clr ", setColor, satin, psd_layer_effects_satin, prefix);
 
     CONN_UNITF("/ChFX/Opct", "#Prc", setOpacity, satin, psd_layer_effects_satin, prefix);
     CONN_UNITF("/ChFX/lagl", "#Ang", setAngle, satin, psd_layer_effects_satin, prefix);
     CONN_UNITF("/ChFX/Dstn", "#Pxl", setDistance, satin, psd_layer_effects_satin, prefix);
     CONN_UNITF("/ChFX/blur", "#Pxl", setSize, satin, psd_layer_effects_satin, prefix);
 
     CONN_BOOL("/ChFX/enab", setEffectEnabled, satin, psd_layer_effects_satin, prefix);
     CONN_BOOL("/ChFX/AntA", setAntiAliased, satin, psd_layer_effects_satin, prefix);
     CONN_BOOL("/ChFX/Invr", setInvert, satin, psd_layer_effects_satin, prefix);
     CONN_CURVE("/ChFX/MpgS", setContourLookupTable, satin, psd_layer_effects_satin, prefix);
 
     psd_layer_effects_color_overlay *colorOverlay = style->colorOverlay();
 
     CONN_COMPOSITE_OP("/SoFi/Md  ", setBlendMode, colorOverlay, psd_layer_effects_color_overlay, prefix);
     CONN_COLOR("/SoFi/Clr ", setColor, colorOverlay, psd_layer_effects_color_overlay, prefix);
     CONN_UNITF("/SoFi/Opct", "#Prc", setOpacity, colorOverlay, psd_layer_effects_color_overlay, prefix);
     CONN_BOOL("/SoFi/enab", setEffectEnabled, colorOverlay, psd_layer_effects_color_overlay, prefix);
 
     psd_layer_effects_gradient_overlay *gradientOverlay = style->gradientOverlay();
 
     CONN_COMPOSITE_OP("/GrFl/Md  ", setBlendMode, gradientOverlay, psd_layer_effects_gradient_overlay, prefix);
     CONN_UNITF("/GrFl/Opct", "#Prc", setOpacity, gradientOverlay, psd_layer_effects_gradient_overlay, prefix);
     CONN_UNITF("/GrFl/Scl ", "#Prc", setScale, gradientOverlay, psd_layer_effects_gradient_overlay, prefix);
     CONN_UNITF("/GrFl/Angl", "#Ang", setAngle, gradientOverlay, psd_layer_effects_gradient_overlay, prefix);
     CONN_BOOL("/GrFl/enab", setEffectEnabled, gradientOverlay, psd_layer_effects_gradient_overlay, prefix);
     // CONN_BOOL("/GrFl/Dthr", setDitherNotImplemented, gradientOverlay, psd_layer_effects_gradient_overlay, prefix);
     CONN_BOOL("/GrFl/Rvrs", setReverse, gradientOverlay, psd_layer_effects_gradient_overlay, prefix);
     CONN_BOOL("/GrFl/Algn", setAlignWithLayer, gradientOverlay, psd_layer_effects_gradient_overlay, prefix);
     CONN_POINT("/GrFl/Ofst", setGradientOffset, gradientOverlay, psd_layer_effects_gradient_overlay, prefix);
     CONN_GRADIENT("/GrFl/Grad", setGradient, gradientOverlay, psd_layer_effects_gradient_overlay, prefix);
 
 
     QMap<QString, psd_gradient_style> gradientStyleMap;
     gradientStyleMap.insert("Lnr ", psd_gradient_style_linear);
     gradientStyleMap.insert("Rdl ", psd_gradient_style_radial);
     gradientStyleMap.insert("Angl", psd_gradient_style_angle);
     gradientStyleMap.insert("Rflc", psd_gradient_style_reflected);
     gradientStyleMap.insert("Dmnd", psd_gradient_style_diamond);
     CONN_ENUM("/GrFl/Type", "GrdT", setStyle, gradientStyleMap, psd_gradient_style, gradientOverlay, psd_layer_effects_gradient_overlay, prefix);
 
     psd_layer_effects_pattern_overlay *patternOverlay = style->patternOverlay();
 
     CONN_BOOL("/patternFill/enab", setEffectEnabled, patternOverlay, psd_layer_effects_pattern_overlay, prefix);
     CONN_COMPOSITE_OP("/patternFill/Md  ", setBlendMode, patternOverlay, psd_layer_effects_pattern_overlay, prefix);
     CONN_UNITF("/patternFill/Opct", "#Prc", setOpacity, patternOverlay, psd_layer_effects_pattern_overlay, prefix);
     CONN_PATTERN("/patternFill/Ptrn", setPattern, patternOverlay, psd_layer_effects_pattern_overlay, prefix);
     CONN_UNITF("/patternFill/Scl ", "#Prc", setScale, patternOverlay, psd_layer_effects_pattern_overlay, prefix);
     CONN_BOOL("/patternFill/Algn", setAlignWithLayer, patternOverlay, psd_layer_effects_pattern_overlay, prefix);
     CONN_POINT("/patternFill/phase", setPatternPhase, patternOverlay, psd_layer_effects_pattern_overlay, prefix);
 
     psd_layer_effects_stroke *stroke = style->stroke();
 
     CONN_COMPOSITE_OP("/FrFX/Md  ", setBlendMode, stroke, psd_layer_effects_stroke, prefix);
     CONN_BOOL("/FrFX/enab", setEffectEnabled, stroke, psd_layer_effects_stroke, prefix);
     CONN_UNITF("/FrFX/Opct", "#Prc", setOpacity, stroke, psd_layer_effects_stroke, prefix);
     CONN_UNITF("/FrFX/Sz  ", "#Pxl", setSize, stroke, psd_layer_effects_stroke, prefix);
 
     QMap<QString, psd_stroke_position> strokeStyleMap;
     strokeStyleMap.insert("OutF", psd_stroke_outside);
     strokeStyleMap.insert("InsF", psd_stroke_inside);
     strokeStyleMap.insert("CtrF", psd_stroke_center);
     CONN_ENUM("/FrFX/Styl", "FStl", setPosition, strokeStyleMap, psd_stroke_position, stroke, psd_layer_effects_stroke, prefix);
 
     QMap<QString, psd_fill_type> strokeFillType;
     strokeFillType.insert("SClr", psd_fill_solid_color);
     strokeFillType.insert("GrFl", psd_fill_gradient);
     strokeFillType.insert("Ptrn", psd_fill_pattern);
     CONN_ENUM("/FrFX/PntT", "FrFl", setFillType, strokeFillType, psd_fill_type, stroke, psd_layer_effects_stroke, prefix);
 
     // Color type
     CONN_COLOR("/FrFX/Clr ", setColor, stroke, psd_layer_effects_stroke, prefix);
 
     // Gradient Type
     CONN_GRADIENT("/FrFX/Grad", setGradient, stroke, psd_layer_effects_stroke, prefix);
     CONN_UNITF("/FrFX/Angl", "#Ang", setAngle, stroke, psd_layer_effects_stroke, prefix);
     CONN_UNITF("/FrFX/Scl ", "#Prc", setScale, stroke, psd_layer_effects_stroke, prefix);
     CONN_ENUM("/FrFX/Type", "GrdT", setStyle, gradientStyleMap, psd_gradient_style, stroke, psd_layer_effects_stroke, prefix);
     CONN_BOOL("/FrFX/Rvrs", setReverse, stroke, psd_layer_effects_stroke, prefix);
     CONN_BOOL("/FrFX/Algn", setAlignWithLayer, stroke, psd_layer_effects_stroke, prefix);
     CONN_POINT("/FrFX/Ofst", setGradientOffset, stroke, psd_layer_effects_stroke, prefix);
     // CONN_BOOL("/FrFX/Dthr", setDitherNotImplemented, stroke, psd_layer_effects_stroke, prefix);
 
     // Pattern type
 
     CONN_PATTERN("/FrFX/Ptrn", setPattern, stroke, psd_layer_effects_stroke, prefix);
     CONN_BOOL("/FrFX/Lnkd", setAlignWithLayer, stroke, psd_layer_effects_stroke, prefix); // yes, we share the params...
     CONN_POINT("/FrFX/phase", setPatternPhase, stroke, psd_layer_effects_stroke, prefix);
 
 
     psd_layer_effects_bevel_emboss *bevelAndEmboss = style->bevelAndEmboss();
 
     CONN_BOOL("/ebbl/enab", setEffectEnabled, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
 
     CONN_COMPOSITE_OP("/ebbl/hglM", setHighlightBlendMode, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
     CONN_COLOR("/ebbl/hglC", setHighlightColor, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
     CONN_UNITF("/ebbl/hglO", "#Prc", setHighlightOpacity, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
 
     CONN_COMPOSITE_OP("/ebbl/sdwM", setShadowBlendMode, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
     CONN_COLOR("/ebbl/sdwC", setShadowColor, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
     CONN_UNITF("/ebbl/sdwO", "#Prc", setShadowOpacity, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
 
     QMap<QString, psd_technique_type> bevelTechniqueMap;
     bevelTechniqueMap.insert("PrBL", psd_technique_precise);
     bevelTechniqueMap.insert("SfBL", psd_technique_softer);
     bevelTechniqueMap.insert("Slmt", psd_technique_slope_limit);
     CONN_ENUM("/ebbl/bvlT", "bvlT", setTechnique, bevelTechniqueMap, psd_technique_type, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
 
     QMap<QString, psd_bevel_style> bevelStyleMap;
     bevelStyleMap.insert("OtrB", psd_bevel_outer_bevel);
     bevelStyleMap.insert("InrB", psd_bevel_inner_bevel);
     bevelStyleMap.insert("Embs", psd_bevel_emboss);
     bevelStyleMap.insert("PlEb", psd_bevel_pillow_emboss);
     bevelStyleMap.insert("strokeEmboss", psd_bevel_stroke_emboss);
     CONN_ENUM("/ebbl/bvlS", "BESl", setStyle, bevelStyleMap, psd_bevel_style, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
 
     CONN_BOOL("/ebbl/uglg", setUseGlobalLight, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
 
     CONN_UNITF("/ebbl/lagl", "#Ang", setAngle, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
     CONN_UNITF("/ebbl/Lald", "#Ang", setAltitude, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
 
     CONN_UNITF("/ebbl/srgR", "#Prc", setDepth, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
 
     CONN_UNITF("/ebbl/blur", "#Pxl", setSize, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
 
 
     QMap<QString, psd_direction> bevelDirectionMap;
     bevelDirectionMap.insert("In  ", psd_direction_up);
     bevelDirectionMap.insert("Out ", psd_direction_down);
     CONN_ENUM("/ebbl/bvlD", "BESs", setDirection, bevelDirectionMap, psd_direction, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
 
     CONN_CURVE("/ebbl/TrnS", setContourLookupTable, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
 
     CONN_BOOL("/ebbl/antialiasGloss", setGlossAntiAliased, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
 
     CONN_UNITF("/ebbl/Sftn", "#Pxl", setSoften, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
 
     // Use shape mode
 
     CONN_BOOL("/ebbl/useShape", setContourEnabled, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
     CONN_CURVE("/ebbl/MpgS", setGlossContourLookupTable, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
     CONN_BOOL("/ebbl/AntA", setAntiAliased, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
     CONN_UNITF("/ebbl/Inpr", "#Prc", setContourRange, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
 
     // Use texture mode
 
     CONN_BOOL("/ebbl/useTexture", setTextureEnabled, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
     CONN_BOOL("/ebbl/InvT", setTextureInvert, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
     CONN_BOOL("/ebbl/Algn", setTextureAlignWithLayer, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
     CONN_UNITF("/ebbl/Scl ", "#Prc", setTextureScale, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
     CONN_UNITF("/ebbl/textureDepth", "#Prc", setTextureDepth, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
     CONN_PATTERN("/ebbl/Ptrn", setTexturePattern, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
     CONN_POINT("/ebbl/phase", setTexturePhase, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
 }
 
 void KisAslLayerStyleSerializer::newStyleStarted(bool isPsdStructure)
 {
     m_stylesVector.append(toQShared(new KisPSDLayerStyle()));
     KisPSDLayerStyle *currentStyle = m_stylesVector.last().data();
 
     psd_layer_effects_context *context = currentStyle->context();
     context->global_angle = 0;
     context->keep_original = 0;
 
     QString prefix = isPsdStructure ? "/null" : "/Styl/Lefx";
     connectCatcherToStyle(currentStyle, prefix);
 }
 
 void KisAslLayerStyleSerializer::readFromDevice(QIODevice *device)
 {
     m_stylesVector.clear();
 
     m_catcher.subscribePattern("/Patterns/KisPattern", boost::bind(&KisAslLayerStyleSerializer::registerPatternObject, this, _1));
     m_catcher.subscribeNewStyleStarted(boost::bind(&KisAslLayerStyleSerializer::newStyleStarted, this, false));
 
     KisAslReader reader;
     QDomDocument doc = reader.readFile(device);
 
     //qDebug() << ppVar(doc.toString());
 
     //KisAslObjectCatcher c2;
     KisAslXmlParser parser;
     parser.parseXML(doc, m_catcher);
 
     // correct all the layer styles
     foreach(KisPSDLayerStyleSP style, m_stylesVector) {
         FillStylesCorrector::correct(style.data());
     }
 }
 
 void KisAslLayerStyleSerializer::registerPSDPattern(const QDomDocument &doc)
 {
     KisAslCallbackObjectCatcher catcher;
     catcher.subscribePattern("/Patterns/KisPattern", boost::bind(&KisAslLayerStyleSerializer::registerPatternObject, this, _1));
 
     //KisAslObjectCatcher c2;
     KisAslXmlParser parser;
     parser.parseXML(doc, catcher);
 }
 
 void KisAslLayerStyleSerializer::readFromPSDXML(const QDomDocument &doc)
 {
     // The caller prepares the document using th efollowing code
     //
     // KisAslReader reader;
     // QDomDocument doc = reader.readLfx2PsdSection(device);
 
     m_stylesVector.clear();
 
     //m_catcher.subscribePattern("/Patterns/KisPattern", boost::bind(&KisAslLayerStyleSerializer::registerPatternObject, this, _1));
     m_catcher.subscribeNewStyleStarted(boost::bind(&KisAslLayerStyleSerializer::newStyleStarted, this, true));
 
     //KisAslObjectCatcher c2;
     KisAslXmlParser parser;
     parser.parseXML(doc, m_catcher);
 
     // correct all the layer styles
     foreach(KisPSDLayerStyleSP style, m_stylesVector) {
         FillStylesCorrector::correct(style.data());
     }
 }
diff --git a/krita/ui/layerstyles/wdglayerstyles.ui b/krita/ui/layerstyles/wdglayerstyles.ui
index 638094cf2f..20cb1ff17c 100644
--- a/krita/ui/layerstyles/wdglayerstyles.ui
+++ b/krita/ui/layerstyles/wdglayerstyles.ui
@@ -1,192 +1,206 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgStylesDialog</class>
  <widget class="QWidget" name="WdgStylesDialog">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>473</width>
     <height>335</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Form</string>
   </property>
   <layout class="QHBoxLayout" name="horizontalLayout">
    <item>
-    <widget class="QListWidget" name="lstStyleSelector">
+    <layout class="QVBoxLayout" name="verticalLayout_2">
      <item>
-      <property name="text">
-       <string>Styles</string>
-      </property>
-     </item>
-     <item>
-      <property name="text">
-       <string>Blending Options</string>
-      </property>
-     </item>
-     <item>
-      <property name="text">
-       <string>Drop Shadow</string>
-      </property>
-      <property name="checkState">
-       <enum>Unchecked</enum>
-      </property>
-     </item>
-     <item>
-      <property name="text">
-       <string>Inner Shadow</string>
-      </property>
-      <property name="checkState">
-       <enum>Unchecked</enum>
-      </property>
-     </item>
-     <item>
-      <property name="text">
-       <string>Outer Glow</string>
-      </property>
-      <property name="checkState">
-       <enum>Unchecked</enum>
-      </property>
-     </item>
-     <item>
-      <property name="text">
-       <string>Inner Glow</string>
-      </property>
-      <property name="checkState">
-       <enum>Unchecked</enum>
-      </property>
-     </item>
-     <item>
-      <property name="text">
-       <string>Bevel and Emboss</string>
-      </property>
-      <property name="checkState">
-       <enum>Unchecked</enum>
-      </property>
-     </item>
-     <item>
-      <property name="text">
-       <string>Contour</string>
-      </property>
-      <property name="checkState">
-       <enum>Unchecked</enum>
-      </property>
-     </item>
-     <item>
-      <property name="text">
-       <string>Texture</string>
-      </property>
-      <property name="checkState">
-       <enum>Unchecked</enum>
-      </property>
-     </item>
-     <item>
-      <property name="text">
-       <string>Satin</string>
-      </property>
-      <property name="checkState">
-       <enum>Unchecked</enum>
-      </property>
-     </item>
-     <item>
-      <property name="text">
-       <string>Color Overlay</string>
-      </property>
-      <property name="checkState">
-       <enum>Unchecked</enum>
-      </property>
-     </item>
-     <item>
-      <property name="text">
-       <string>Gradient Overlay</string>
-      </property>
-      <property name="checkState">
-       <enum>Unchecked</enum>
-      </property>
-     </item>
-     <item>
-      <property name="text">
-       <string>Pattern Overlay</string>
-      </property>
-      <property name="checkState">
-       <enum>Unchecked</enum>
-      </property>
+      <widget class="QCheckBox" name="chkMasterFxSwitch">
+       <property name="text">
+        <string>Enable Effects</string>
+       </property>
+       <property name="checked">
+        <bool>true</bool>
+       </property>
+      </widget>
      </item>
      <item>
-      <property name="text">
-       <string>Stroke</string>
-      </property>
-      <property name="checkState">
-       <enum>Unchecked</enum>
-      </property>
+      <widget class="QListWidget" name="lstStyleSelector">
+       <item>
+        <property name="text">
+         <string>Styles</string>
+        </property>
+       </item>
+       <item>
+        <property name="text">
+         <string>Blending Options</string>
+        </property>
+       </item>
+       <item>
+        <property name="text">
+         <string>Drop Shadow</string>
+        </property>
+        <property name="checkState">
+         <enum>Unchecked</enum>
+        </property>
+       </item>
+       <item>
+        <property name="text">
+         <string>Inner Shadow</string>
+        </property>
+        <property name="checkState">
+         <enum>Unchecked</enum>
+        </property>
+       </item>
+       <item>
+        <property name="text">
+         <string>Outer Glow</string>
+        </property>
+        <property name="checkState">
+         <enum>Unchecked</enum>
+        </property>
+       </item>
+       <item>
+        <property name="text">
+         <string>Inner Glow</string>
+        </property>
+        <property name="checkState">
+         <enum>Unchecked</enum>
+        </property>
+       </item>
+       <item>
+        <property name="text">
+         <string>Bevel and Emboss</string>
+        </property>
+        <property name="checkState">
+         <enum>Unchecked</enum>
+        </property>
+       </item>
+       <item>
+        <property name="text">
+         <string>Contour</string>
+        </property>
+        <property name="checkState">
+         <enum>Unchecked</enum>
+        </property>
+       </item>
+       <item>
+        <property name="text">
+         <string>Texture</string>
+        </property>
+        <property name="checkState">
+         <enum>Unchecked</enum>
+        </property>
+       </item>
+       <item>
+        <property name="text">
+         <string>Satin</string>
+        </property>
+        <property name="checkState">
+         <enum>Unchecked</enum>
+        </property>
+       </item>
+       <item>
+        <property name="text">
+         <string>Color Overlay</string>
+        </property>
+        <property name="checkState">
+         <enum>Unchecked</enum>
+        </property>
+       </item>
+       <item>
+        <property name="text">
+         <string>Gradient Overlay</string>
+        </property>
+        <property name="checkState">
+         <enum>Unchecked</enum>
+        </property>
+       </item>
+       <item>
+        <property name="text">
+         <string>Pattern Overlay</string>
+        </property>
+        <property name="checkState">
+         <enum>Unchecked</enum>
+        </property>
+       </item>
+       <item>
+        <property name="text">
+         <string>Stroke</string>
+        </property>
+        <property name="checkState">
+         <enum>Unchecked</enum>
+        </property>
+       </item>
+      </widget>
      </item>
-    </widget>
+    </layout>
    </item>
    <item>
     <widget class="QStackedWidget" name="stylesStack"/>
    </item>
    <item>
     <layout class="QVBoxLayout" name="verticalLayout">
      <item>
       <widget class="QPushButton" name="btnNewStyle">
        <property name="text">
         <string>Ne&amp;w...</string>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QPushButton" name="btnLoadStyle">
        <property name="text">
         <string>&amp;Import...</string>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QPushButton" name="btnSaveStyle">
        <property name="text">
         <string>&amp;Export...</string>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QCheckBox" name="chkPreview">
        <property name="text">
         <string>Pre&amp;view</string>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QLabel" name="lblPreview">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
         <string/>
        </property>
       </widget>
      </item>
      <item>
       <spacer name="verticalSpacer">
        <property name="orientation">
         <enum>Qt::Vertical</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>20</width>
          <height>40</height>
         </size>
        </property>
       </spacer>
      </item>
     </layout>
    </item>
   </layout>
  </widget>
  <resources/>
  <connections/>
 </ui>