diff --git a/libs/ui/widgets/kis_curve_widget.cpp b/libs/ui/widgets/kis_curve_widget.cpp
index ae6592771c..623d11a572 100644
--- a/libs/ui/widgets/kis_curve_widget.cpp
+++ b/libs/ui/widgets/kis_curve_widget.cpp
@@ -1,535 +1,535 @@
 /*
  *  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.
  */
 
 
 // C++ includes.
 
 #include <cmath>
 #include <cstdlib>
 
 // Qt includes.
 
 #include <QPixmap>
 #include <QPainter>
 #include <QPoint>
 #include <QPen>
 #include <QEvent>
 #include <QRect>
 #include <QFont>
 #include <QFontMetrics>
 #include <QMouseEvent>
 #include <QKeyEvent>
 #include <QPaintEvent>
 #include <QList>
 #include <QApplication>
 
 #include <QSpinBox>
 
 // KDE includes.
 
 #include <kis_debug.h>
 #include <kis_config.h>
 #include <klocalizedstring.h>
 
 // Local includes.
 
 #include "widgets/kis_curve_widget.h"
 
 
 #define bounds(x,a,b) (x<a ? a : (x>b ? b :x))
 #define MOUSE_AWAY_THRES 15
 #define POINT_AREA       1E-4
 #define CURVE_AREA       1E-4
 
 #include "kis_curve_widget_p.h"
 
 KisCurveWidget::KisCurveWidget(QWidget *parent, Qt::WindowFlags f)
         : QWidget(parent, f), d(new KisCurveWidget::Private(this))
 {
     setObjectName("KisCurveWidget");
     d->m_grab_point_index = -1;
     d->m_readOnlyMode   = false;
     d->m_guideVisible   = false;
     d->m_pixmapDirty = true;
     d->m_pixmapCache = 0;
     d->setState(ST_NORMAL);
 
     d->m_intIn = 0;
     d->m_intOut = 0;
 
     setMouseTracking(true);
     setAutoFillBackground(false);
     setAttribute(Qt::WA_OpaquePaintEvent);
     setMinimumSize(150, 50);
     setMaximumSize(250, 250);
 
     d->setCurveModified();
 
     setFocusPolicy(Qt::StrongFocus);
 }
 
 KisCurveWidget::~KisCurveWidget()
 {
     delete d->m_pixmapCache;
     delete d;
 }
 
 void KisCurveWidget::setupInOutControls(QSpinBox *in, QSpinBox *out, int inMin, int inMax, int outMin, int outMax)
 {
     d->m_intIn = in;
     d->m_intOut = out;
 
     if (!d->m_intIn || !d->m_intOut)
         return;
 
     d->m_inMin = inMin;
     d->m_inMax = inMax;
     d->m_outMin = outMin;
     d->m_outMax = outMax;
 
     int realInMin = qMin(inMin, inMax); // tilt elevation has range (90, 0), which QSpinBox can't handle
     int realInMax = qMax(inMin, inMax);
 
     d->m_intIn->setRange(realInMin, realInMax);
     d->m_intOut->setRange(d->m_outMin, d->m_outMax);
 
     connect(d->m_intIn, SIGNAL(valueChanged(int)), this, SLOT(inOutChanged(int)), Qt::UniqueConnection);
     connect(d->m_intOut, SIGNAL(valueChanged(int)), this, SLOT(inOutChanged(int)), Qt::UniqueConnection);
 
     d->syncIOControls();
 
 }
 void KisCurveWidget::dropInOutControls()
 {
     if (!d->m_intIn || !d->m_intOut)
         return;
 
     disconnect(d->m_intIn, SIGNAL(valueChanged(int)), this, SLOT(inOutChanged(int)));
     disconnect(d->m_intOut, SIGNAL(valueChanged(int)), this, SLOT(inOutChanged(int)));
 
     d->m_intIn = d->m_intOut = 0;
 
 }
 
 void KisCurveWidget::inOutChanged(int)
 {
     QPointF pt;
 
     Q_ASSERT(d->m_grab_point_index >= 0);
 
     pt.setX(d->io2sp(d->m_intIn->value(), d->m_inMin, d->m_inMax));
     pt.setY(d->io2sp(d->m_intOut->value(), d->m_outMin, d->m_outMax));
 
     bool newPoint = false;
     if (d->jumpOverExistingPoints(pt, d->m_grab_point_index)) {
         newPoint = true;
 
         d->m_curve.setPoint(d->m_grab_point_index, pt);
         d->m_grab_point_index = d->m_curve.points().indexOf(pt);
         emit pointSelectedChanged();
     } else {
         pt = d->m_curve.points()[d->m_grab_point_index];
     }
 
     if (!newPoint) {
         // if there is a new Point, no point in rewriting values in spinboxes
 
         d->m_intIn->blockSignals(true);
         d->m_intOut->blockSignals(true);
 
         d->m_intIn->setValue(d->sp2io(pt.x(), d->m_inMin, d->m_inMax));
         d->m_intOut->setValue(d->sp2io(pt.y(), d->m_outMin, d->m_outMax));
 
         d->m_intIn->blockSignals(false);
         d->m_intOut->blockSignals(false);
     }
 
     d->setCurveModified(false);
 }
 
 
 void KisCurveWidget::reset(void)
 {
     d->m_grab_point_index = -1;
     emit pointSelectedChanged();
     d->m_guideVisible = false;
 
     //remove total - 2 points.
     while (d->m_curve.points().count() - 2 ) {
         d->m_curve.removePoint(d->m_curve.points().count() - 2);
     }
 
     d->setCurveModified();
 }
 
 void KisCurveWidget::setCurveGuide(const QColor & color)
 {
     d->m_guideVisible = true;
     d->m_colorGuide   = color;
 
 }
 
 void KisCurveWidget::setPixmap(const QPixmap & pix)
 {
     d->m_pix = pix;
     d->m_pixmapDirty = true;
     d->setCurveRepaint();
 }
 
 QPixmap KisCurveWidget::getPixmap()
 {
     return d->m_pix;
 }
 
 void KisCurveWidget::setBasePixmap(const QPixmap &pix)
 {
     d->m_pixmapBase = pix;
 }
 
 QPixmap KisCurveWidget::getBasePixmap()
 {
     return d->m_pixmapBase;
 }
 
 bool KisCurveWidget::pointSelected() const
 {
     return d->m_grab_point_index > 0 && d->m_grab_point_index < d->m_curve.points().count() - 1;
 }
 
 void KisCurveWidget::keyPressEvent(QKeyEvent *e)
 {
     if (e->key() == Qt::Key_Delete || e->key() == Qt::Key_Backspace) {
         if (d->m_grab_point_index > 0 && d->m_grab_point_index < d->m_curve.points().count() - 1) {
             //x() find closest point to get focus afterwards
             double grab_point_x = d->m_curve.points()[d->m_grab_point_index].x();
 
             int left_of_grab_point_index = d->m_grab_point_index - 1;
             int right_of_grab_point_index = d->m_grab_point_index + 1;
             int new_grab_point_index;
 
             if (fabs(d->m_curve.points()[left_of_grab_point_index].x() - grab_point_x) <
                     fabs(d->m_curve.points()[right_of_grab_point_index].x() - grab_point_x)) {
                 new_grab_point_index = left_of_grab_point_index;
             } else {
                 new_grab_point_index = d->m_grab_point_index;
             }
             d->m_curve.removePoint(d->m_grab_point_index);
             d->m_grab_point_index = new_grab_point_index;
             emit pointSelectedChanged();
             setCursor(Qt::ArrowCursor);
             d->setState(ST_NORMAL);
         }
         e->accept();
         d->setCurveModified();
     } else if (e->key() == Qt::Key_Escape && d->state() != ST_NORMAL) {
         d->m_curve.setPoint(d->m_grab_point_index, QPointF(d->m_grabOriginalX, d->m_grabOriginalY) );
         setCursor(Qt::ArrowCursor);
         d->setState(ST_NORMAL);
 
         e->accept();
         d->setCurveModified();
     } else if ((e->key() == Qt::Key_A || e->key() == Qt::Key_Insert) && d->state() == ST_NORMAL) {
         /* FIXME: Lets user choose the hotkeys */
         addPointInTheMiddle();
         e->accept();
     } else
         QWidget::keyPressEvent(e);
 }
 
 void KisCurveWidget::addPointInTheMiddle()
 {
     QPointF pt(0.5, d->m_curve.value(0.5));
 
     if (!d->jumpOverExistingPoints(pt, -1))
         return;
 
     d->m_grab_point_index = d->m_curve.addPoint(pt);
     emit pointSelectedChanged();
 
     if (d->m_intIn)
         d->m_intIn->setFocus(Qt::TabFocusReason);
     d->setCurveModified();
 }
 
 void KisCurveWidget::resizeEvent(QResizeEvent *e)
 {
     d->m_pixmapDirty = true;
     QWidget::resizeEvent(e);
 }
 
 void KisCurveWidget::paintEvent(QPaintEvent *)
 {
     int    wWidth = width() - 1;
     int    wHeight = height() - 1;
 
 
     QPainter p(this);
 
     // Antialiasing is not a good idea here, because
     // the grid will drift one pixel to any side due to rounding of int
     // FIXME: let's user tell the last word (in config)
     //p.setRenderHint(QPainter::Antialiasing);
      QPalette appPalette = QApplication::palette();
      p.fillRect(rect(), appPalette.color(QPalette::Base)); // clear out previous paint call results
 
      // make the entire widget grayed out if it is disabled
      if (!this->isEnabled()) {
         p.setOpacity(0.2);
      }
 
 
 
     //  draw background
     if (!d->m_pix.isNull()) {
         if (d->m_pixmapDirty || !d->m_pixmapCache) {
             delete d->m_pixmapCache;
             d->m_pixmapCache = new QPixmap(width(), height());
             QPainter cachePainter(d->m_pixmapCache);
 
             cachePainter.scale(1.0*width() / d->m_pix.width(), 1.0*height() / d->m_pix.height());
             cachePainter.drawPixmap(0, 0, d->m_pix);
             d->m_pixmapDirty = false;
         }
         p.drawPixmap(0, 0, *d->m_pixmapCache);
     }
 
     d->drawGrid(p, wWidth, wHeight);
 
     KisConfig cfg(true);
     if (cfg.antialiasCurves()) {
         p.setRenderHint(QPainter::Antialiasing);
     }
 
     // Draw curve.
     double curY;
     double normalizedX;
     int x;
 
     QPolygonF poly;
 
     p.setPen(QPen(appPalette.color(QPalette::Text), 2, Qt::SolidLine));
     for (x = 0 ; x < wWidth ; x++) {
         normalizedX = double(x) / wWidth;
         curY = wHeight - d->m_curve.value(normalizedX) * wHeight;
 
         /**
          * Keep in mind that QLineF rounds doubles
          * to ints mathematically, not just rounds down
          * like in C
          */
         poly.append(QPointF(x, curY));
     }
     poly.append(QPointF(x, wHeight - d->m_curve.value(1.0) * wHeight));
     p.drawPolyline(poly);
 
     QPainterPath fillCurvePath;
     QPolygonF fillPoly = poly;
     fillPoly.append(QPoint(rect().width(), rect().height()));
     fillPoly.append(QPointF(0,rect().height()));
 
     // add a couple points to the edges so it fills in below always
 
     QColor fillColor = appPalette.color(QPalette::Text);
     fillColor.setAlphaF(0.2);
 
     fillCurvePath.addPolygon(fillPoly);
     p.fillPath(fillCurvePath, fillColor);
 
 
 
     // Drawing curve handles.
     double curveX;
     double curveY;
     if (!d->m_readOnlyMode) {
         for (int i = 0; i < d->m_curve.points().count(); ++i) {
             curveX = d->m_curve.points().at(i).x();
             curveY = d->m_curve.points().at(i).y();
 
             int handleSize = 12; // how big should control points be (diamater size)
 
             if (i == d->m_grab_point_index) {
                 // active point is slightly more "bold"
                 p.setPen(QPen(appPalette.color(QPalette::Text), 4, Qt::SolidLine));
                 p.drawEllipse(QRectF(curveX * wWidth - (handleSize*0.5),
                                      wHeight - (handleSize*0.5) - curveY * wHeight,
                                      handleSize,
                                      handleSize));
             } else {
                 p.setPen(QPen(appPalette.color(QPalette::Text), 2, Qt::SolidLine));
                 p.drawEllipse(QRectF(curveX * wWidth - (handleSize*0.5),
                                      wHeight - (handleSize*0.5) - curveY * wHeight,
                                      handleSize,
                                      handleSize));
             }
         }
     }
 
     // add border around widget to help contain everything
     QPainterPath widgetBoundsPath;
     widgetBoundsPath.addRect(rect());
     p.strokePath(widgetBoundsPath, appPalette.color(QPalette::Text));
 
 
     p.setOpacity(1.0); // reset to 1.0 in case we were drawing a disabled widget before
 }
 
 void KisCurveWidget::mousePressEvent(QMouseEvent * e)
 {
     if (d->m_readOnlyMode) return;
 
     if (e->button() != Qt::LeftButton)
         return;
 
     double x = e->pos().x() / (double)(width() - 1);
     double y = 1.0 - e->pos().y() / (double)(height() - 1);
 
 
 
     int closest_point_index = d->nearestPointInRange(QPointF(x, y), width(), height());
     if (closest_point_index < 0) {
         QPointF newPoint(x, y);
         if (!d->jumpOverExistingPoints(newPoint, -1))
             return;
         d->m_grab_point_index = d->m_curve.addPoint(newPoint);
         emit pointSelectedChanged();
     } else {
         d->m_grab_point_index = closest_point_index;
         emit pointSelectedChanged();
     }
 
     d->m_grabOriginalX = d->m_curve.points()[d->m_grab_point_index].x();
     d->m_grabOriginalY = d->m_curve.points()[d->m_grab_point_index].y();
     d->m_grabOffsetX = d->m_curve.points()[d->m_grab_point_index].x() - x;
     d->m_grabOffsetY = d->m_curve.points()[d->m_grab_point_index].y() - y;
     d->m_curve.setPoint(d->m_grab_point_index, QPointF(x + d->m_grabOffsetX, y + d->m_grabOffsetY));
 
     d->m_draggedAwayPointIndex = -1;
     d->setState(ST_DRAG);
 
 
     d->setCurveModified();
 }
 
 
 void KisCurveWidget::mouseReleaseEvent(QMouseEvent *e)
 {
     if (d->m_readOnlyMode) return;
 
     if (e->button() != Qt::LeftButton)
         return;
 
     setCursor(Qt::ArrowCursor);
     d->setState(ST_NORMAL);
 
     d->setCurveModified();
 }
 
 
 void KisCurveWidget::mouseMoveEvent(QMouseEvent * e)
 {
     if (d->m_readOnlyMode) return;
 
     double x = e->pos().x() / (double)(width() - 1);
     double y = 1.0 - e->pos().y() / (double)(height() - 1);
 
     if (d->state() == ST_NORMAL) { // If no point is selected set the cursor shape if on top
         int nearestPointIndex = d->nearestPointInRange(QPointF(x, y), width(), height());
 
         if (nearestPointIndex < 0)
             setCursor(Qt::ArrowCursor);
         else
             setCursor(Qt::CrossCursor);
     } else { // Else, drag the selected point
         bool crossedHoriz = e->pos().x() - width() > MOUSE_AWAY_THRES ||
                             e->pos().x() < -MOUSE_AWAY_THRES;
         bool crossedVert =  e->pos().y() - height() > MOUSE_AWAY_THRES ||
                             e->pos().y() < -MOUSE_AWAY_THRES;
 
         bool removePoint = (crossedHoriz || crossedVert);
 
         if (!removePoint && d->m_draggedAwayPointIndex >= 0) {
             // point is no longer dragged away so reinsert it
             QPointF newPoint(d->m_draggedAwayPoint);
             d->m_grab_point_index = d->m_curve.addPoint(newPoint);
             d->m_draggedAwayPointIndex = -1;
         }
 
         if (removePoint &&
                 (d->m_draggedAwayPointIndex >= 0))
             return;
 
 
         setCursor(Qt::CrossCursor);
 
         x += d->m_grabOffsetX;
         y += d->m_grabOffsetY;
 
         double leftX;
         double rightX;
         if (d->m_grab_point_index == 0) {
             leftX = 0.0;
             if (d->m_curve.points().count() > 1)
                 rightX = d->m_curve.points()[d->m_grab_point_index + 1].x() - POINT_AREA;
             else
                 rightX = 1.0;
         } else if (d->m_grab_point_index == d->m_curve.points().count() - 1) {
             leftX = d->m_curve.points()[d->m_grab_point_index - 1].x() + POINT_AREA;
             rightX = 1.0;
         } else {
             Q_ASSERT(d->m_grab_point_index > 0 && d->m_grab_point_index < d->m_curve.points().count() - 1);
 
             // the 1E-4 addition so we can grab the dot later.
             leftX = d->m_curve.points()[d->m_grab_point_index - 1].x() + POINT_AREA;
             rightX = d->m_curve.points()[d->m_grab_point_index + 1].x() - POINT_AREA;
         }
 
         x = bounds(x, leftX, rightX);
         y = bounds(y, 0., 1.);
 
         d->m_curve.setPoint(d->m_grab_point_index, QPointF(x, y));
 
         if (removePoint && d->m_curve.points().count() > 2) {
             d->m_draggedAwayPoint = d->m_curve.points()[d->m_grab_point_index];
             d->m_draggedAwayPointIndex = d->m_grab_point_index;
             d->m_curve.removePoint(d->m_grab_point_index);
             d->m_grab_point_index = bounds(d->m_grab_point_index, 0, d->m_curve.points().count() - 1);
             emit pointSelectedChanged();
         }
 
         d->setCurveModified();
     }
 }
 
 KisCubicCurve KisCurveWidget::curve()
 {
     return d->m_curve;
 }
 
 void KisCurveWidget::setCurve(KisCubicCurve inlist)
 {
     d->m_curve = inlist;
     d->m_grab_point_index = qBound(0, d->m_grab_point_index, d->m_curve.points().count() - 1);
-    emit pointSelectedChanged();
     d->setCurveModified();
+    emit pointSelectedChanged();
 }
 
 void KisCurveWidget::leaveEvent(QEvent *)
 {
 }
 
diff --git a/plugins/paintops/libpaintop/kis_curve_option_widget.cpp b/plugins/paintops/libpaintop/kis_curve_option_widget.cpp
index d474fe0376..66d41decdb 100644
--- a/plugins/paintops/libpaintop/kis_curve_option_widget.cpp
+++ b/plugins/paintops/libpaintop/kis_curve_option_widget.cpp
@@ -1,324 +1,340 @@
 /* This file is part of the KDE project
  * Copyright (C) 2008 Boudewijn Rempt <boud@valdyas.org>
  * Copyright (C) 2009 Sven Langkamp   <sven.langkamp@gmail.com>
  * Copyright (C) 2011 Silvio Heinrich <plassy@web.de>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "kis_curve_option_widget.h"
 
 #include "ui_wdgcurveoption.h"
 #include "widgets/kis_curve_widget.h"
 #include "kis_dynamic_sensor.h"
 #include "kis_global.h"
 #include "kis_curve_option.h"
 #include "kis_signals_blocker.h"
 #include "kis_icon_utils.h"
 
 inline void setLabel(QLabel* label, const KisCurveLabel& curve_label)
 {
     if (curve_label.icon().isNull()) {
         label->setText(curve_label.name());
     }
     else {
         label->setPixmap(QPixmap::fromImage(curve_label.icon()));
     }
 }
 
 KisCurveOptionWidget::KisCurveOptionWidget(KisCurveOption* curveOption, const QString &minLabel, const QString &maxLabel, bool hideSlider)
     : KisPaintOpOption(curveOption->category(), curveOption->isChecked())
     , m_widget(new QWidget)
     , m_curveOptionWidget(new Ui_WdgCurveOption())
     , m_curveOption(curveOption)
 {
     setObjectName("KisCurveOptionWidget");
 
     m_curveOptionWidget->setupUi(m_widget);
     setConfigurationPage(m_widget);
 
     m_curveOptionWidget->sensorSelector->setCurveOption(curveOption);
 
     updateSensorCurveLabels(m_curveOptionWidget->sensorSelector->currentHighlighted());
     updateCurve(m_curveOptionWidget->sensorSelector->currentHighlighted());
 
-    connect(m_curveOptionWidget->curveWidget, SIGNAL(modified()), this, SLOT(transferCurve()));
+    connect(m_curveOptionWidget->curveWidget, SIGNAL(modified()), this, SLOT(slotModified()));
     connect(m_curveOptionWidget->sensorSelector, SIGNAL(parametersChanged()), SLOT(emitSettingChanged()));
     connect(m_curveOptionWidget->sensorSelector, SIGNAL(parametersChanged()), SLOT(updateLabelsOfCurrentSensor()));
     connect(m_curveOptionWidget->sensorSelector, SIGNAL(highlightedSensorChanged(KisDynamicSensorSP)), SLOT(updateSensorCurveLabels(KisDynamicSensorSP)));
     connect(m_curveOptionWidget->sensorSelector, SIGNAL(highlightedSensorChanged(KisDynamicSensorSP)), SLOT(updateCurve(KisDynamicSensorSP)));
-    connect(m_curveOptionWidget->checkBoxUseSameCurve, SIGNAL(stateChanged(int)), SLOT(transferCurve()));
+    connect(m_curveOptionWidget->checkBoxUseSameCurve, SIGNAL(stateChanged(int)), SLOT(slotStateChanged()));
 
 
     // set all the icons for the curve preset shapes
     updateThemedIcons();
 
     // various curve preset buttons with predefined curves
     connect(m_curveOptionWidget->linearCurveButton, SIGNAL(clicked(bool)), this, SLOT(changeCurveLinear()));
     connect(m_curveOptionWidget->revLinearButton, SIGNAL(clicked(bool)), this, SLOT(changeCurveReverseLinear()));
     connect(m_curveOptionWidget->jCurveButton, SIGNAL(clicked(bool)), this, SLOT(changeCurveJShape()));
     connect(m_curveOptionWidget->lCurveButton, SIGNAL(clicked(bool)), this, SLOT(changeCurveLShape()));
     connect(m_curveOptionWidget->sCurveButton, SIGNAL(clicked(bool)), this, SLOT(changeCurveSShape()));
     connect(m_curveOptionWidget->reverseSCurveButton, SIGNAL(clicked(bool)), this, SLOT(changeCurveReverseSShape()));
     connect(m_curveOptionWidget->uCurveButton, SIGNAL(clicked(bool)), this, SLOT(changeCurveUShape()));
     connect(m_curveOptionWidget->revUCurveButton, SIGNAL(clicked(bool)), this, SLOT(changeCurveArchShape()));
 
 
     m_curveOptionWidget->label_ymin->setText(minLabel);
     m_curveOptionWidget->label_ymax->setText(maxLabel);
 
     // strength settings is shown as 0-100%
     m_curveOptionWidget->strengthSlider->setRange(curveOption->minValue()*100, curveOption->maxValue()*100, 0);
     m_curveOptionWidget->strengthSlider->setValue(curveOption->value()*100);
     m_curveOptionWidget->strengthSlider->setPrefix(i18n("Strength: "));
     m_curveOptionWidget->strengthSlider->setSuffix(i18n("%"));
 
 
     if (hideSlider) {
          m_curveOptionWidget->strengthSlider->hide();
     }
 
     connect(m_curveOptionWidget->checkBoxUseCurve, SIGNAL(stateChanged(int))  , SLOT(updateValues()));
     connect(m_curveOptionWidget->curveMode, SIGNAL(currentIndexChanged(int)), SLOT(updateMode()));
     connect(m_curveOptionWidget->strengthSlider, SIGNAL(valueChanged(qreal)), SLOT(updateValues()));
 }
 
 KisCurveOptionWidget::~KisCurveOptionWidget()
 {
     delete m_curveOption;
     delete m_curveOptionWidget;
 }
 
 void KisCurveOptionWidget::writeOptionSetting(KisPropertiesConfigurationSP setting) const
 {
     m_curveOption->writeOptionSetting(setting);
 }
 
 void KisCurveOptionWidget::readOptionSetting(const KisPropertiesConfigurationSP setting)
 {
     //setting->dump();
 
     m_curveOption->readOptionSetting(setting);
 
     m_curveOptionWidget->checkBoxUseCurve->setChecked(m_curveOption->isCurveUsed());
     m_curveOptionWidget->strengthSlider->setValue(m_curveOption->value()*100);
     m_curveOptionWidget->checkBoxUseSameCurve->setChecked(m_curveOption->isSameCurveUsed());
     m_curveOptionWidget->curveMode->setCurrentIndex(m_curveOption->getCurveMode());
 
     disableWidgets(!m_curveOption->isCurveUsed());
 
     m_curveOptionWidget->sensorSelector->reload();
     m_curveOptionWidget->sensorSelector->setCurrent(m_curveOption->activeSensors().first());
     updateSensorCurveLabels(m_curveOptionWidget->sensorSelector->currentHighlighted());
     updateCurve(m_curveOptionWidget->sensorSelector->currentHighlighted());
+
+    if (m_curveOption->isSameCurveUsed()) {
+        // make sure the curve is transfered to all sensors to avoid updating from a wrong curve later
+        transferCurve();
+    }
 }
 
 void KisCurveOptionWidget::lodLimitations(KisPaintopLodLimitations *l) const
 {
     m_curveOption->lodLimitations(l);
 }
 
 bool KisCurveOptionWidget::isCheckable() const
 {
     return m_curveOption->isCheckable();
 }
 
 bool KisCurveOptionWidget::isChecked() const
 {
     return m_curveOption->isChecked();
 }
 
 void KisCurveOptionWidget::setChecked(bool checked)
 {
     m_curveOption->setChecked(checked);
 }
 
 KisCurveOption* KisCurveOptionWidget::curveOption()
 {
     return m_curveOption;
 }
 
 QWidget* KisCurveOptionWidget::curveWidget()
 {
     return m_widget;
 }
 
+void KisCurveOptionWidget::slotModified()
+{
+    transferCurve();
+}
+
+void KisCurveOptionWidget::slotStateChanged()
+{
+    transferCurve();
+}
+
+
 void KisCurveOptionWidget::transferCurve()
 {
     m_curveOptionWidget->sensorSelector->setCurrentCurve(m_curveOptionWidget->curveWidget->curve(), m_curveOptionWidget->checkBoxUseSameCurve->isChecked());
     emitSettingChanged();
 }
 
 void KisCurveOptionWidget::updateSensorCurveLabels(KisDynamicSensorSP sensor)
 {
     if (sensor) {
         m_curveOptionWidget->label_xmin->setText(KisDynamicSensor::minimumLabel(sensor->sensorType()));
         m_curveOptionWidget->label_xmax->setText(KisDynamicSensor::maximumLabel(sensor->sensorType(), sensor->length()));
 
         int inMinValue = KisDynamicSensor::minimumValue(sensor->sensorType());
         int inMaxValue = KisDynamicSensor::maximumValue(sensor->sensorType(), sensor->length());
         QString inSuffix = KisDynamicSensor::valueSuffix(sensor->sensorType());
 
         int outMinValue = m_curveOption->intMinValue();
         int outMaxValue = m_curveOption->intMaxValue();
         QString outSuffix = m_curveOption->valueSuffix();
 
         m_curveOptionWidget->intIn->setSuffix(inSuffix);
         m_curveOptionWidget->intOut->setSuffix(outSuffix);
 
         m_curveOptionWidget->curveWidget->setupInOutControls(m_curveOptionWidget->intIn,m_curveOptionWidget->intOut,
                                                          inMinValue,inMaxValue,outMinValue,outMaxValue);
     }
 }
 
 void KisCurveOptionWidget::updateCurve(KisDynamicSensorSP sensor)
 {
     if (sensor) {
         bool blockSignal = m_curveOptionWidget->curveWidget->blockSignals(true);
         m_curveOptionWidget->curveWidget->setCurve(sensor->curve());
         m_curveOptionWidget->curveWidget->blockSignals(blockSignal);
     }
 }
 
 void KisCurveOptionWidget::updateLabelsOfCurrentSensor()
 {
     updateSensorCurveLabels(m_curveOptionWidget->sensorSelector->currentHighlighted());
     updateCurve(m_curveOptionWidget->sensorSelector->currentHighlighted());
 }
 
 void KisCurveOptionWidget::updateValues()
 {
     m_curveOption->setValue(m_curveOptionWidget->strengthSlider->value()/100.0); // convert back to 0-1 for data
     m_curveOption->setCurveUsed(m_curveOptionWidget->checkBoxUseCurve->isChecked());
     disableWidgets(!m_curveOptionWidget->checkBoxUseCurve->isChecked());
     emitSettingChanged();
 }
 
 void KisCurveOptionWidget::updateMode()
 {
     m_curveOption->setCurveMode(m_curveOptionWidget->curveMode->currentIndex());
     emitSettingChanged();
 }
 
 void KisCurveOptionWidget::changeCurveLinear()
 {
     QList<QPointF> points;
     points.push_back(QPointF(0,0));
     points.push_back(QPointF(1,1));
     m_curveOptionWidget->curveWidget->setCurve(KisCubicCurve(points));
 }
 
 void KisCurveOptionWidget::changeCurveReverseLinear()
 {
         QList<QPointF> points;
         points.push_back(QPointF(0,1));
         points.push_back(QPointF(1,0));
         m_curveOptionWidget->curveWidget->setCurve(KisCubicCurve(points));
 }
 
 void KisCurveOptionWidget::changeCurveSShape()
 {
         QList<QPointF> points;
         points.push_back(QPointF(0,0));
         points.push_back(QPointF(0.25,0.1));
         points.push_back(QPointF(0.75,0.9));
         points.push_back(QPointF(1, 1));
         m_curveOptionWidget->curveWidget->setCurve(KisCubicCurve(points));
 }
 
 
 void KisCurveOptionWidget::changeCurveReverseSShape()
 {
         QList<QPointF> points;
         points.push_back(QPointF(0,1));
         points.push_back(QPointF(0.25,0.9));
         points.push_back(QPointF(0.75,0.1));
         points.push_back(QPointF(1,0));
         m_curveOptionWidget->curveWidget->setCurve(KisCubicCurve(points));
 }
 
 void KisCurveOptionWidget::changeCurveJShape()
 {
     QList<QPointF> points;
     points.push_back(QPointF(0,0));
     points.push_back(QPointF(0.35,0.1));
     points.push_back(QPointF(1,1));
     m_curveOptionWidget->curveWidget->setCurve(KisCubicCurve(points));
 }
 
 void KisCurveOptionWidget::changeCurveLShape()
 {
     QList<QPointF> points;
     points.push_back(QPointF(0,1));
     points.push_back(QPointF(0.25,0.48));
     points.push_back(QPointF(1,0));
     m_curveOptionWidget->curveWidget->setCurve(KisCubicCurve(points));
 }
 
 void KisCurveOptionWidget::changeCurveUShape()
 {
     QList<QPointF> points;
     points.push_back(QPointF(0,1));
     points.push_back(QPointF(0.5,0));
     points.push_back(QPointF(1,1));
     m_curveOptionWidget->curveWidget->setCurve(KisCubicCurve(points));
 }
 
 void KisCurveOptionWidget::changeCurveArchShape()
 {
     QList<QPointF> points;
     points.push_back(QPointF(0,0));
     points.push_back(QPointF(0.5,1));
     points.push_back(QPointF(1,0));
     m_curveOptionWidget->curveWidget->setCurve(KisCubicCurve(points));
 }
 
 
 
 
 void KisCurveOptionWidget::disableWidgets(bool disable)
 {
     m_curveOptionWidget->checkBoxUseSameCurve->setDisabled(disable);
     m_curveOptionWidget->curveWidget->setDisabled(disable);
     m_curveOptionWidget->sensorSelector->setDisabled(disable);
     m_curveOptionWidget->label_xmax->setDisabled(disable);
     m_curveOptionWidget->label_xmin->setDisabled(disable);
     m_curveOptionWidget->label_ymax->setDisabled(disable);
     m_curveOptionWidget->label_ymin->setDisabled(disable);
 
 }
 
 
 void KisCurveOptionWidget::updateThemedIcons()
 {
     // set all the icons for the curve preset shapes
     m_curveOptionWidget->linearCurveButton->setIcon(KisIconUtils::loadIcon("curve-preset-linear"));
     m_curveOptionWidget->revLinearButton->setIcon(KisIconUtils::loadIcon("curve-preset-linear-reverse"));
     m_curveOptionWidget->jCurveButton->setIcon(KisIconUtils::loadIcon("curve-preset-j"));
     m_curveOptionWidget->lCurveButton->setIcon(KisIconUtils::loadIcon("curve-preset-l"));
     m_curveOptionWidget->sCurveButton->setIcon(KisIconUtils::loadIcon("curve-preset-s"));
     m_curveOptionWidget->reverseSCurveButton->setIcon(KisIconUtils::loadIcon("curve-preset-s-reverse"));
     m_curveOptionWidget->uCurveButton->setIcon(KisIconUtils::loadIcon("curve-preset-u"));
     m_curveOptionWidget->revUCurveButton->setIcon(KisIconUtils::loadIcon("curve-preset-arch"));
 
     // this helps make the checkboxes show themselves on the dark color themes
     QPalette pal = m_curveOptionWidget->sensorSelector->palette();
     QPalette newPalette = pal;
     newPalette.setColor(QPalette::Active, QPalette::Background, pal.text().color() );
     m_curveOptionWidget->sensorSelector->setPalette(newPalette);
 
 }
 
diff --git a/plugins/paintops/libpaintop/kis_curve_option_widget.h b/plugins/paintops/libpaintop/kis_curve_option_widget.h
index eae9d1be19..e5ba4a2ccc 100644
--- a/plugins/paintops/libpaintop/kis_curve_option_widget.h
+++ b/plugins/paintops/libpaintop/kis_curve_option_widget.h
@@ -1,84 +1,87 @@
 /* This file is part of the KDE project
  * Copyright (C) 2008 Boudewijn Rempt <boud@valdyas.org>
  * Copyright (C) 2009 Sven Langkamp   <sven.langkamp@gmail.com>
  * Copyright (C) 2011 Silvio Heinrich <plassy@web.de>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_CURVE_OPTION_WIDGET_H
 #define KIS_CURVE_OPTION_WIDGET_H
 
 #include <kis_paintop_option.h>
 
 class Ui_WdgCurveOption;
 class KisCurveOption;
 class QComboBox;
 
 #include <kis_dynamic_sensor.h>
 
 class PAINTOP_EXPORT KisCurveOptionWidget : public KisPaintOpOption
 {
     Q_OBJECT
 public:
     KisCurveOptionWidget(KisCurveOption* curveOption, const QString &minLabel, const QString &maxLabel, bool hideSlider = false);
     ~KisCurveOptionWidget() override;
 
     void writeOptionSetting(KisPropertiesConfigurationSP setting) const override;
     void readOptionSetting(const KisPropertiesConfigurationSP setting) override;
     void lodLimitations(KisPaintopLodLimitations *l) const override;
 
     bool isCheckable() const override;
     bool isChecked() const override;
     void setChecked(bool checked) override;
     void show();
 
 protected:
 
     KisCurveOption* curveOption();
     QWidget* curveWidget();
 
 private Q_SLOTS:
 
+    void slotModified();
+    void slotStateChanged();
+
     void transferCurve();
     void updateSensorCurveLabels(KisDynamicSensorSP sensor);
     void updateCurve(KisDynamicSensorSP sensor);
     void updateValues();
     void updateMode();
     void updateLabelsOfCurrentSensor();
     void disableWidgets(bool disable);
     void updateThemedIcons();
 
 
     // curve shape preset buttons
     void changeCurveLinear();
     void changeCurveReverseLinear();
     void changeCurveSShape();
     void changeCurveReverseSShape();
     void changeCurveJShape();
     void changeCurveLShape();
     void changeCurveUShape();
     void changeCurveArchShape();
 
 
 private:
     QWidget* m_widget;
     Ui_WdgCurveOption* m_curveOptionWidget;
     QComboBox* m_curveMode;
     KisCurveOption* m_curveOption;
 };
 
 #endif // KIS_CURVE_OPTION_WIDGET_H