diff --git a/libs/ui/widgets/kis_curve_widget.cpp b/libs/ui/widgets/kis_curve_widget.cpp
index 036bc959c8..73ea367f2c 100644
--- a/libs/ui/widgets/kis_curve_widget.cpp
+++ b/libs/ui/widgets/kis_curve_widget.cpp
@@ -1,502 +1,507 @@
 /*
  *  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 min, int max)
 {
     d->m_intIn = in;
     d->m_intOut = out;
 
     if (!d->m_intIn || !d->m_intOut)
         return;
 
     d->m_inOutMin = min;
     d->m_inOutMax = max;
 
     d->m_intIn->setRange(d->m_inOutMin, d->m_inOutMax);
     d->m_intOut->setRange(d->m_inOutMin, d->m_inOutMax);
 
 
     connect(d->m_intIn, SIGNAL(valueChanged(int)), this, SLOT(inOutChanged(int)));
     connect(d->m_intOut, SIGNAL(valueChanged(int)), this, SLOT(inOutChanged(int)));
     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()));
     pt.setY(d->io2sp(d->m_intOut->value()));
 
     if (d->jumpOverExistingPoints(pt, d->m_grab_point_index)) {
         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];
 
 
     d->m_intIn->blockSignals(true);
     d->m_intOut->blockSignals(true);
 
     d->m_intIn->setValue(d->sp2io(pt.x()));
     d->m_intOut->setValue(d->sp2io(pt.y()));
 
     d->m_intIn->blockSignals(false);
     d->m_intOut->blockSignals(false);
 
     d->setCurveModified();
 }
 
 
 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);
 
     QPalette appPalette = QApplication::palette();
 
     // 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);
 
     // fill with color to show widget bounds
      p.fillRect(rect(), appPalette.color(QPalette::Base));
 
     //  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;
     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();
 
             if (i == d->m_grab_point_index) {
                 p.setPen(QPen(appPalette.color(QPalette::Text), 6, Qt::SolidLine));
                 p.drawEllipse(QRectF(curveX * wWidth - 2,
                                      wHeight - 2 - curveY * wHeight, 4, 4));
             } else {
                 p.setPen(QPen(appPalette.color(QPalette::Text), 2, Qt::SolidLine));
                 p.drawEllipse(QRectF(curveX * wWidth - 3,
                                      wHeight - 3 - curveY * wHeight, 6, 6));
             }
         }
     }
 
     // add border around widget to help contain everything
     QPainterPath widgetBoundsPath;
     widgetBoundsPath.addRect(rect());
     p.strokePath(widgetBoundsPath, appPalette.color(QPalette::Text));
 }
 
 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();
 }
 
 void KisCurveWidget::leaveEvent(QEvent *)
 {
 }
 
diff --git a/plugins/filters/colorsfilters/kis_perchannel_filter.cpp b/plugins/filters/colorsfilters/kis_perchannel_filter.cpp
index 5957eabf59..fb776d4de5 100644
--- a/plugins/filters/colorsfilters/kis_perchannel_filter.cpp
+++ b/plugins/filters/colorsfilters/kis_perchannel_filter.cpp
@@ -1,631 +1,638 @@
 /*
  * This file is part of Krita
  *
  * Copyright (c) 2005 C. Boemann <cbo@boemann.dk>
  *
  *  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_perchannel_filter.h"
 
 #include <Qt>
 #include <QLayout>
 #include <QPixmap>
 #include <QPainter>
 #include <QLabel>
 #include <QComboBox>
 #include <QDomDocument>
 #include <QHBoxLayout>
 
 #include "KoChannelInfo.h"
 #include "KoBasicHistogramProducers.h"
 #include "KoColorModelStandardIds.h"
 #include "KoColorSpace.h"
 #include "KoColorTransformation.h"
 #include "KoCompositeColorTransformation.h"
 #include "KoCompositeOp.h"
 #include "KoID.h"
 
 #include "kis_signals_blocker.h"
 
 #include "kis_bookmarked_configuration_manager.h"
 #include "kis_config_widget.h"
 #include <filter/kis_filter_configuration.h>
 #include <kis_selection.h>
 #include <kis_paint_device.h>
 #include <kis_processing_information.h>
 
 #include "kis_histogram.h"
 #include "kis_painter.h"
 #include "widgets/kis_curve_widget.h"
 
 QVector<VirtualChannelInfo> getVirtualChannels(const KoColorSpace *cs)
 {
     const bool supportsLightness =
         cs->colorModelId() != LABAColorModelID &&
         cs->colorModelId() != GrayAColorModelID &&
         cs->colorModelId() != GrayColorModelID &&
         cs->colorModelId() != AlphaColorModelID;
 
     QVector<VirtualChannelInfo> vchannels;
 
     QList<KoChannelInfo *> sortedChannels =
         KoChannelInfo::displayOrderSorted(cs->channels());
 
     if (supportsLightness) {
         vchannels << VirtualChannelInfo(VirtualChannelInfo::ALL_COLORS, -1, 0, cs);
     }
 
     Q_FOREACH (KoChannelInfo *channel, sortedChannels) {
         int pixelIndex = KoChannelInfo::displayPositionToChannelIndex(channel->displayPosition(), sortedChannels);
         vchannels << VirtualChannelInfo(VirtualChannelInfo::REAL, pixelIndex, channel, cs);
     }
 
     if (supportsLightness) {
         vchannels << VirtualChannelInfo(VirtualChannelInfo::LIGHTNESS, -1, 0, cs);
     }
 
     return vchannels;
 }
 
 KisPerChannelConfigWidget::KisPerChannelConfigWidget(QWidget * parent, KisPaintDeviceSP dev, Qt::WindowFlags f)
         : KisConfigWidget(parent, f), m_histogram(0)
 {
     Q_ASSERT(dev);
     m_page = new WdgPerChannel(this);
 
     QHBoxLayout * layout = new QHBoxLayout(this);
     Q_CHECK_PTR(layout);
     layout->setContentsMargins(0,0,0,0);
     layout->addWidget(m_page);
 
     m_dev = dev;
     m_activeVChannel = 0;
     const KoColorSpace *targetColorSpace = dev->compositionSourceColorSpace();
 
     // fill in the channel chooser, in the display order, but store the pixel index as well.
 
     m_virtualChannels = getVirtualChannels(targetColorSpace);
     const int virtualChannelCount = m_virtualChannels.size();
 
     KisPerChannelFilterConfiguration::initDefaultCurves(m_curves,
                                                         virtualChannelCount);
     for (int i = 0; i < virtualChannelCount; i++) {
         const VirtualChannelInfo &info = m_virtualChannels[i];
 
         m_page->cmbChannel->addItem(info.name(), info.pixelIndex());
         m_curves[i].setName(info.name());
     }
 
     connect(m_page->cmbChannel, SIGNAL(activated(int)), this, SLOT(setActiveChannel(int)));
     connect((QObject*)(m_page->chkLogarithmic), SIGNAL(toggled(bool)), this, SLOT(logHistView()));
-
+    connect((QObject*)(m_page->resetButton), SIGNAL(clicked()), this, SLOT(resetCurve()));
 
     // create the horizontal and vertical gradient labels
     m_page->hgradient->setPixmap(createGradient(Qt::Horizontal));
     m_page->vgradient->setPixmap(createGradient(Qt::Vertical));
 
     // init histogram calculator
     QList<QString> keys =
         KoHistogramProducerFactoryRegistry::instance()->keysCompatibleWith(targetColorSpace);
 
     if(keys.size() > 0) {
         KoHistogramProducerFactory *hpf;
         hpf = KoHistogramProducerFactoryRegistry::instance()->get(keys.at(0));
     m_histogram = new KisHistogram(m_dev, m_dev->exactBounds(), hpf->generate(), LINEAR);
     }
 
     connect(m_page->curveWidget, SIGNAL(modified()), this, SIGNAL(sigConfigurationItemChanged()));
 
     m_page->curveWidget->setupInOutControls(m_page->intIn, m_page->intOut, 0, 100);
 
     {
         KisSignalsBlocker b(m_page->curveWidget);
         m_page->curveWidget->setCurve(m_curves[0]);
         setActiveChannel(0);
     }
 }
 
 KisPerChannelConfigWidget::~KisPerChannelConfigWidget()
 {
     delete m_histogram;
 }
 
 inline QPixmap KisPerChannelConfigWidget::createGradient(Qt::Orientation orient /*, int invert (not used yet) */)
 {
     int width;
     int height;
     int *i, inc, col;
     int x = 0, y = 0;
 
     if (orient == Qt::Horizontal) {
         i = &x; inc = 1; col = 0;
         width = 256; height = 1;
     } else {
         i = &y; inc = -1; col = 255;
         width = 1; height = 256;
     }
 
     QPixmap gradientpix(width, height);
     QPainter p(&gradientpix);
     p.setPen(QPen(QColor(0, 0, 0), 1, Qt::SolidLine));
     for (; *i < 256; (*i)++, col += inc) {
         p.setPen(QColor(col, col, col));
         p.drawPoint(x, y);
     }
     return gradientpix;
 }
 
 inline QPixmap KisPerChannelConfigWidget::getHistogram()
 {
     int i;
     int height = 256;
     QPixmap pix(256, height);
 
     bool logarithmic = m_page->chkLogarithmic->isChecked();
 
     if (logarithmic)
         m_histogram->setHistogramType(LOGARITHMIC);
     else
         m_histogram->setHistogramType(LINEAR);
 
 
     QPalette appPalette = QApplication::palette();
 
     pix.fill(QColor(appPalette.color(QPalette::Base)));
 
     QPainter p(&pix);
     p.setPen(QColor(appPalette.color(QPalette::Text)));
     p.save();
     p.setOpacity(0.2);
 
     const VirtualChannelInfo &info = m_virtualChannels[m_activeVChannel];
 
+
     if (m_histogram && info.type() == VirtualChannelInfo::REAL)
     {
         m_histogram->setChannel(info.pixelIndex());
 
         double highest = (double)m_histogram->calculations().getHighest();
+
         qint32 bins = m_histogram->producer()->numberOfBins();
 
         if (m_histogram->getHistogramType() == LINEAR) {
             double factor = (double)height / highest;
             for (i = 0; i < bins; ++i) {
                 p.drawLine(i, height, i, height - int(m_histogram->getValue(i) * factor));
             }
         } else {
             double factor = (double)height / (double)log(highest);
             for (i = 0; i < bins; ++i) {
                 p.drawLine(i, height, i, height - int(log((double)m_histogram->getValue(i)) * factor));
             }
         }
     }
 
     p.restore();
 
     return pix;
 }
 
 #define BITS_PER_BYTE 8
 #define pwr2(p) (1<<p)
 
 void KisPerChannelConfigWidget::setActiveChannel(int ch)
 {
     m_curves[m_activeVChannel] = m_page->curveWidget->curve();
 
     m_activeVChannel = ch;
     m_page->curveWidget->setCurve(m_curves[m_activeVChannel]);
     m_page->curveWidget->setPixmap(getHistogram());
     m_page->cmbChannel->setCurrentIndex(m_activeVChannel);
 
 
     // Getting range accepted by channel
     VirtualChannelInfo &currentVChannel = m_virtualChannels[m_activeVChannel];
 
     KoChannelInfo::enumChannelValueType valueType = currentVChannel.valueType();
 
     int order = BITS_PER_BYTE * currentVChannel.channelSize();
     int maxValue = pwr2(order);
     int min;
     int max;
 
     m_page->curveWidget->dropInOutControls();
 
     switch (valueType) {
     case KoChannelInfo::UINT8:
     case KoChannelInfo::UINT16:
     case KoChannelInfo::UINT32:
         m_shift = 0;
         m_scale = double(maxValue);
         min = 0;
         max = maxValue - 1;
         break;
     case KoChannelInfo::INT8:
     case KoChannelInfo::INT16:
         m_shift = 0.5;
         m_scale = double(maxValue);
         min = -maxValue / 2;
         max = maxValue / 2 - 1;
         break;
     case KoChannelInfo::FLOAT16:
     case KoChannelInfo::FLOAT32:
     case KoChannelInfo::FLOAT64:
     default:
         m_shift = 0;
         m_scale = 100.0;
         //Hack Alert: should be changed to float
         min = 0;
         max = 100;
         break;
     }
 
     m_page->curveWidget->setupInOutControls(m_page->intIn, m_page->intOut, min, max);
 }
 
 
 KisPropertiesConfigurationSP  KisPerChannelConfigWidget::configuration() const
 {
     int numChannels = m_virtualChannels.size();
     KisPropertiesConfigurationSP cfg = new KisPerChannelFilterConfiguration(numChannels);
 
     KIS_ASSERT_RECOVER(m_activeVChannel < m_curves.size()) { return cfg; }
 
     m_curves[m_activeVChannel] = m_page->curveWidget->curve();
     static_cast<KisPerChannelFilterConfiguration*>(cfg.data())->setCurves(m_curves);
 
     return cfg;
 }
 
 void KisPerChannelConfigWidget::setConfiguration(const KisPropertiesConfigurationSP  config)
 {
     const KisPerChannelFilterConfiguration * cfg = dynamic_cast<const KisPerChannelFilterConfiguration *>(config.data());
     if (!cfg)
         return;
 
     if (cfg->curves().size() == 0) {
         /**
          * HACK ALERT: our configuration factory generates
          * default configuration with nTransfers==0.
          * Catching it here. Just reset all the transfers.
          */
 
         const int virtualChannelCount = m_virtualChannels.size();
         KisPerChannelFilterConfiguration::initDefaultCurves(m_curves,
                                                             virtualChannelCount);
 
         for (int i = 0; i < virtualChannelCount; i++) {
             const VirtualChannelInfo &info = m_virtualChannels[i];
             m_curves[i].setName(info.name());
         }
 
     } else if (cfg->curves().size() != int(m_virtualChannels.size())) {
         warnKrita << "WARNING: trying to load a curve with incorrect  number of channels!";
         warnKrita << "WARNING:   expected:" << m_virtualChannels.size();
         warnKrita << "WARNING:        got:" << cfg->curves().size();
         return;
     } else {
         for (int ch = 0; ch < cfg->curves().size(); ch++)
             m_curves[ch] = cfg->curves()[ch];
     }
 
     // HACK: we save the previous curve in setActiveChannel, so just copy it
     m_page->curveWidget->setCurve(m_curves[m_activeVChannel]);
 
     setActiveChannel(0);
 }
 
 
 KisPerChannelFilterConfiguration::KisPerChannelFilterConfiguration(int nCh)
         : KisColorTransformationConfiguration("perchannel", 1)
 {
     initDefaultCurves(m_curves, nCh);
     updateTransfers();
 }
 
 KisPerChannelFilterConfiguration::~KisPerChannelFilterConfiguration()
 {
 }
 
 bool KisPerChannelFilterConfiguration::isCompatible(const KisPaintDeviceSP dev) const
 {
     return (int)dev->compositionSourceColorSpace()->channelCount() == m_curves.size();
 }
 
 void KisPerChannelFilterConfiguration::setCurves(QList<KisCubicCurve> &curves)
 {
     m_curves.clear();
     m_curves = curves;
 
     updateTransfers();
 }
 
 void KisPerChannelFilterConfiguration::initDefaultCurves(QList<KisCubicCurve> &curves, int nCh)
 {
     curves.clear();
     for (int i = 0; i < nCh; i++) {
         curves.append(KisCubicCurve());
     }
 }
 
 void KisPerChannelFilterConfiguration::updateTransfers()
 {
     m_transfers.resize(m_curves.size());
     for (int i = 0; i < m_curves.size(); i++) {
         m_transfers[i] = m_curves[i].uint16Transfer();
     }
 }
 
 const QVector<QVector<quint16> >&
 KisPerChannelFilterConfiguration::transfers() const
 {
     return m_transfers;
 }
 
 const QList<KisCubicCurve>&
 KisPerChannelFilterConfiguration::curves() const
 {
     return m_curves;
 }
 
 void KisPerChannelFilterConfiguration::fromLegacyXML(const QDomElement& root)
 {
     fromXML(root);
 }
 
 void KisPerChannelFilterConfiguration::fromXML(const QDomElement& root)
 {
     QList<KisCubicCurve> curves;
     quint16 numTransfers = 0;
     int version;
     version  = root.attribute("version").toInt();
 
     QDomElement e = root.firstChild().toElement();
     QString attributeName;
     KisCubicCurve curve;
     quint16 index;
     while (!e.isNull()) {
         if ((attributeName = e.attribute("name")) == "nTransfers") {
             numTransfers = e.text().toUShort();
         } else {
             QRegExp rx("curve(\\d+)");
             if (rx.indexIn(attributeName, 0) != -1) {
 
                 index = rx.cap(1).toUShort();
                 index = qMin(index, quint16(curves.count()));
 
                 if (!e.text().isEmpty()) {
                     curve.fromString(e.text());
                 }
                 curves.insert(index, curve);
             }
         }
         e = e.nextSiblingElement();
     }
 
     //prepend empty curves for the brightness contrast filter.
     if(getString("legacy") == "brightnesscontrast") {
         if (getString("colorModel") == LABAColorModelID.id()) {
             curves.append(KisCubicCurve());
             curves.append(KisCubicCurve());
             curves.append(KisCubicCurve());
         } else {
             int extraChannels = 5;
             if (getString("colorModel") == CMYKAColorModelID.id()) {
                 extraChannels = 6;
             } else if (getString("colorModel") == GrayAColorModelID.id()) {
                 extraChannels = 0;
             }
             for(int c = 0; c < extraChannels; c ++) {
                 curves.insert(0, KisCubicCurve());
             }
         }
     }
     if (!numTransfers)
         return;
 
     setVersion(version);
     setCurves(curves);
 }
 
 /**
  * Inherited from KisPropertiesConfiguration
  */
 //void KisPerChannelFilterConfiguration::fromXML(const QString& s)
 
 void addParamNode(QDomDocument& doc,
                   QDomElement& root,
                   const QString &name,
                   const QString &value)
 {
     QDomText text = doc.createTextNode(value);
     QDomElement t = doc.createElement("param");
     t.setAttribute("name", name);
     t.appendChild(text);
     root.appendChild(t);
 }
 
 void KisPerChannelFilterConfiguration::toXML(QDomDocument& doc, QDomElement& root) const
 {
     /**
      * <params version=1>
      *       <param name="nTransfers">3</param>
      *       <param name="curve0">0,0;0.5,0.5;1,1;</param>
      *       <param name="curve1">0,0;1,1;</param>
      *       <param name="curve2">0,0;1,1;</param>
      * </params>
      */
 
     root.setAttribute("version", version());
 
     QDomText text;
     QDomElement t;
 
     addParamNode(doc, root, "nTransfers", QString::number(m_curves.size()));
 
     KisCubicCurve curve;
     QString paramName;
 
     for (int i = 0; i < m_curves.size(); ++i) {
         QString name = QLatin1String("curve") + QString::number(i);
         QString value = m_curves[i].toString();
 
         addParamNode(doc, root, name, value);
     }
 }
 
 /**
  * Inherited from KisPropertiesConfiguration
  */
 //QString KisPerChannelFilterConfiguration::toXML()
 
 
 KisPerChannelFilter::KisPerChannelFilter() : KisColorTransformationFilter(id(), categoryAdjust(), i18n("&Color Adjustment curves..."))
 {
     setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M));
     setSupportsPainting(true);
     setColorSpaceIndependence(TO_LAB16);
 }
 
 KisConfigWidget * KisPerChannelFilter::createConfigurationWidget(QWidget *parent, const KisPaintDeviceSP dev) const
 {
     return new KisPerChannelConfigWidget(parent, dev);
 }
 
 KisFilterConfigurationSP  KisPerChannelFilter::factoryConfiguration() const
 {
     return new KisPerChannelFilterConfiguration(0);
 }
 
 KoColorTransformation* KisPerChannelFilter::createTransformation(const KoColorSpace* cs, const KisFilterConfigurationSP config) const
 {
     const KisPerChannelFilterConfiguration* configBC =
         dynamic_cast<const KisPerChannelFilterConfiguration*>(config.data()); // Somehow, this shouldn't happen
     Q_ASSERT(configBC);
 
     const QVector<QVector<quint16> > &originalTransfers = configBC->transfers();
     const QList<KisCubicCurve> &originalCurves = configBC->curves();
 
     /**
      * TODO: What about the order of channels? (DK)
      *
      * Virtual channels are sorted in display order, does Lcms accepts
      * transforms in display order? Why on Earth it works?! Is it
      * documented anywhere?
      */
     const QVector<VirtualChannelInfo> virtualChannels = getVirtualChannels(cs);
 
     if (originalTransfers.size() != int(virtualChannels.size())) {
         // We got an illegal number of colorchannels :(
         return 0;
     }
 
     bool colorsNull = true;
     bool lightnessNull = true;
     bool allColorsNull = true;
     int alphaIndexInReal = -1;
 
     QVector<QVector<quint16> > realTransfers;
     QVector<quint16> lightnessTransfer;
     QVector<quint16> allColorsTransfer;
 
     for (int i = 0; i < virtualChannels.size(); i++) {
         if (virtualChannels[i].type() == VirtualChannelInfo::REAL) {
             realTransfers << originalTransfers[i];
 
             if (virtualChannels[i].isAlpha()) {
                 alphaIndexInReal = realTransfers.size() - 1;
             }
 
             if (colorsNull && !originalCurves[i].isNull()) {
                 colorsNull = false;
             }
         } else if (virtualChannels[i].type() == VirtualChannelInfo::LIGHTNESS) {
             KIS_ASSERT_RECOVER_NOOP(lightnessTransfer.isEmpty());
             lightnessTransfer = originalTransfers[i];
 
             if (lightnessNull && !originalCurves[i].isNull()) {
                 lightnessNull = false;
             }
         } else if (virtualChannels[i].type() == VirtualChannelInfo::ALL_COLORS) {
             KIS_ASSERT_RECOVER_NOOP(allColorsTransfer.isEmpty());
             allColorsTransfer = originalTransfers[i];
 
             if (allColorsNull && !originalCurves[i].isNull()) {
                 allColorsNull = false;
             }
         }
     }
 
     KoColorTransformation *lightnessTransform = 0;
     KoColorTransformation *allColorsTransform = 0;
     KoColorTransformation *colorTransform = 0;
 
     if (!colorsNull) {
         const quint16** transfers = new const quint16*[realTransfers.size()];
         for(int i = 0; i < realTransfers.size(); ++i) {
             transfers[i] = realTransfers[i].constData();
 
             /**
              * createPerChannelAdjustment() expects alpha channel to
              * be the last channel in the list, so just it here
              */
             KIS_ASSERT_RECOVER_NOOP(i != alphaIndexInReal ||
                                     alphaIndexInReal == (realTransfers.size() - 1));
         }
 
         colorTransform = cs->createPerChannelAdjustment(transfers);
         delete [] transfers;
     }
 
     if (!lightnessNull) {
         lightnessTransform = cs->createBrightnessContrastAdjustment(lightnessTransfer.constData());
     }
 
     if (!allColorsNull) {
         const quint16** allColorsTransfers = new const quint16*[realTransfers.size()];
         for(int i = 0; i < realTransfers.size(); ++i) {
             allColorsTransfers[i] = (i != alphaIndexInReal) ?
                 allColorsTransfer.constData() : 0;
 
             /**
              * createPerChannelAdjustment() expects alpha channel to
              * be the last channel in the list, so just it here
              */
             KIS_ASSERT_RECOVER_NOOP(i != alphaIndexInReal ||
                                     alphaIndexInReal == (realTransfers.size() - 1));
         }
 
         allColorsTransform = cs->createPerChannelAdjustment(allColorsTransfers);
         delete[] allColorsTransfers;
     }
 
     QVector<KoColorTransformation*> allTransforms;
     allTransforms << colorTransform;
     allTransforms << allColorsTransform;
     allTransforms << lightnessTransform;
 
     return KoCompositeColorTransformation::createOptimizedCompositeTransform(allTransforms);
 }
 
 bool KisPerChannelFilter::needsTransparentPixels(const KisFilterConfigurationSP config, const KoColorSpace *cs) const
 {
     Q_UNUSED(config);
     return cs->colorModelId() == AlphaColorModelID;
 }
 
 void KisPerChannelConfigWidget::logHistView()
 {
     m_page->curveWidget->setPixmap(getHistogram());
 }
+
+void KisPerChannelConfigWidget::resetCurve()
+{
+        m_page->curveWidget->reset();
+}
diff --git a/plugins/filters/colorsfilters/kis_perchannel_filter.h b/plugins/filters/colorsfilters/kis_perchannel_filter.h
index 044d618621..3d6c6503e9 100644
--- a/plugins/filters/colorsfilters/kis_perchannel_filter.h
+++ b/plugins/filters/colorsfilters/kis_perchannel_filter.h
@@ -1,136 +1,139 @@
 /*
  * This file is part of Krita
  *
  * Copyright (c) 2004 Cyrille Berger <cberger@cberger.net>
  *
  *  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_PERCHANNEL_FILTER_H_
 #define _KIS_PERCHANNEL_FILTER_H_
 
 #include <QPair>
 #include <QList>
 
 #include <filter/kis_color_transformation_filter.h>
 #include <filter/kis_color_transformation_configuration.h>
 #include <kis_config_widget.h>
 #include <kis_paint_device.h>
 #include "ui_wdg_perchannel.h"
 
 #include "virtual_channel_info.h"
 
 
 class WdgPerChannel : public QWidget, public Ui::WdgPerChannel
 {
     Q_OBJECT
 
 public:
     WdgPerChannel(QWidget *parent) : QWidget(parent) {
         setupUi(this);
     }
 };
 
 class KisPerChannelFilterConfiguration
         : public KisColorTransformationConfiguration
 {
 public:
     KisPerChannelFilterConfiguration(int n);
     ~KisPerChannelFilterConfiguration() override;
 
     using KisFilterConfiguration::fromXML;
     using KisFilterConfiguration::toXML;
     using KisFilterConfiguration::fromLegacyXML;
 
     void fromLegacyXML(const QDomElement& root) override;
 
     void fromXML(const QDomElement& e) override;
     void toXML(QDomDocument& doc, QDomElement& root) const override;
 
     void setCurves(QList<KisCubicCurve> &curves) override;
     static inline void initDefaultCurves(QList<KisCubicCurve> &curves, int nCh);
     bool isCompatible(const KisPaintDeviceSP) const override;
 
     const QVector<QVector<quint16> >& transfers() const;
     const QList<KisCubicCurve>& curves() const override;
 private:
     QList<KisCubicCurve> m_curves;
 
 private:
     void updateTransfers();
 private:
     QVector<QVector<quint16> > m_transfers;
 };
 
 
 /**
  * This class is generic for filters that affect channel separately
  */
 class KisPerChannelFilter
         : public KisColorTransformationFilter
 {
 public:
     KisPerChannelFilter();
 public:
     KisConfigWidget * createConfigurationWidget(QWidget* parent, const KisPaintDeviceSP dev) const override;
     KisFilterConfigurationSP  factoryConfiguration() const override;
 
     KoColorTransformation* createTransformation(const KoColorSpace* cs, const KisFilterConfigurationSP config) const override;
 
     bool needsTransparentPixels(const KisFilterConfigurationSP config, const KoColorSpace *cs) const override;
 
     static inline KoID id() {
         return KoID("perchannel", i18n("Color Adjustment"));
     }
 private:
 };
 
 class KisPerChannelConfigWidget : public KisConfigWidget
 {
     Q_OBJECT
 
 public:
     KisPerChannelConfigWidget(QWidget * parent, KisPaintDeviceSP dev, Qt::WindowFlags f = 0);
     ~KisPerChannelConfigWidget() override;
 
     void setConfiguration(const KisPropertiesConfigurationSP config) override;
     KisPropertiesConfigurationSP  configuration() const override;
 
 private Q_SLOTS:
     virtual void setActiveChannel(int ch);
     void logHistView();
+    void resetCurve();
+
 
 private:
 
     QVector<VirtualChannelInfo> m_virtualChannels;
     int m_activeVChannel;
 
 
     // private routines
     inline QPixmap getHistogram();
     inline QPixmap createGradient(Qt::Orientation orient /*, int invert (not used now) */);
 
     // members
     WdgPerChannel * m_page;
     KisPaintDeviceSP m_dev;
     KisHistogram *m_histogram;
     mutable QList<KisCubicCurve> m_curves;
 
     // scales for displaying color numbers
     double m_scale;
     double m_shift;
+    bool checkReset;
 };
 
 #endif
diff --git a/plugins/filters/colorsfilters/wdg_perchannel.ui b/plugins/filters/colorsfilters/wdg_perchannel.ui
index f4a695585d..8587d1637b 100644
--- a/plugins/filters/colorsfilters/wdg_perchannel.ui
+++ b/plugins/filters/colorsfilters/wdg_perchannel.ui
@@ -1,358 +1,401 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgPerChannel</class>
  <widget class="QWidget" name="WdgPerChannel">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>317</width>
-    <height>396</height>
+    <width>376</width>
+    <height>384</height>
    </rect>
   </property>
+  <property name="sizePolicy">
+   <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+    <horstretch>0</horstretch>
+    <verstretch>0</verstretch>
+   </sizepolicy>
+  </property>
   <property name="windowTitle">
    <string>BrightnessCon</string>
   </property>
   <layout class="QGridLayout" name="gridLayout_2">
    <property name="leftMargin">
     <number>0</number>
    </property>
    <property name="topMargin">
     <number>0</number>
    </property>
    <property name="rightMargin">
     <number>0</number>
    </property>
    <property name="bottomMargin">
     <number>0</number>
    </property>
    <property name="horizontalSpacing">
     <number>0</number>
    </property>
    <property name="verticalSpacing">
     <number>6</number>
    </property>
    <item row="3" column="1" colspan="2">
+    <layout class="QGridLayout" name="gridLayout" columnstretch="1,2,1">
+     <property name="sizeConstraint">
+      <enum>QLayout::SetFixedSize</enum>
+     </property>
+     <item row="0" column="0">
+      <widget class="QLabel" name="labelIn">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="minimumSize">
+        <size>
+         <width>0</width>
+         <height>0</height>
+        </size>
+       </property>
+       <property name="maximumSize">
+        <size>
+         <width>16777215</width>
+         <height>16777215</height>
+        </size>
+       </property>
+       <property name="text">
+        <string>         Input:</string>
+       </property>
+       <property name="alignment">
+        <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+       </property>
+      </widget>
+     </item>
+     <item row="2" column="2">
+      <widget class="KisIntParseSpinBox" name="intOut">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+      </widget>
+     </item>
+     <item row="2" column="0">
+      <widget class="QLabel" name="labelOut">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="text">
+        <string>         Output:</string>
+       </property>
+       <property name="alignment">
+        <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+       </property>
+      </widget>
+     </item>
+     <item row="0" column="2">
+      <widget class="KisIntParseSpinBox" name="intIn">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+      </widget>
+     </item>
+     <item row="0" column="1">
+      <spacer name="horizontalSpacer_2">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Expanding" vsizetype="Minimum">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="orientation">
+        <enum>Qt::Horizontal</enum>
+       </property>
+       <property name="sizeType">
+        <enum>QSizePolicy::Expanding</enum>
+       </property>
+       <property name="sizeHint" stdset="0">
+        <size>
+         <width>20</width>
+         <height>20</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
+    </layout>
+   </item>
+   <item row="4" column="1" colspan="2">
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeType">
-      <enum>QSizePolicy::MinimumExpanding</enum>
+      <enum>QSizePolicy::Fixed</enum>
+     </property>
+     <property name="sizeHint" stdset="0">
+      <size>
+       <width>10</width>
+       <height>10</height>
+      </size>
+     </property>
+    </spacer>
+   </item>
+   <item row="1" column="0">
+    <spacer name="horizontalSpacer">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="sizeType">
+      <enum>QSizePolicy::Fixed</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
-       <width>9</width>
-       <height>9</height>
+       <width>20</width>
+       <height>20</height>
+      </size>
+     </property>
+    </spacer>
+   </item>
+   <item row="1" column="3">
+    <spacer name="horizontalSpacer_3">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="sizeType">
+      <enum>QSizePolicy::Fixed</enum>
+     </property>
+     <property name="sizeHint" stdset="0">
+      <size>
+       <width>20</width>
+       <height>20</height>
       </size>
      </property>
     </spacer>
    </item>
    <item row="1" column="1" colspan="2">
-    <layout class="QGridLayout" name="grid2">
+    <layout class="QGridLayout" name="grid2" rowstretch="0,0" columnstretch="0,0">
      <property name="sizeConstraint">
       <enum>QLayout::SetDefaultConstraint</enum>
      </property>
      <property name="spacing">
       <number>0</number>
      </property>
      <item row="0" column="1">
       <widget class="QFrame" name="frame3">
        <property name="sizePolicy">
-        <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+        <sizepolicy hsizetype="Ignored" vsizetype="Ignored">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="minimumSize">
         <size>
          <width>256</width>
          <height>256</height>
         </size>
        </property>
        <property name="maximumSize">
         <size>
-         <width>256</width>
-         <height>256</height>
+         <width>16777215</width>
+         <height>16777215</height>
         </size>
        </property>
        <property name="frameShape">
         <enum>QFrame::Panel</enum>
        </property>
        <property name="frameShadow">
         <enum>QFrame::Sunken</enum>
        </property>
        <layout class="QVBoxLayout">
         <property name="spacing">
          <number>0</number>
         </property>
         <property name="leftMargin">
          <number>0</number>
         </property>
         <property name="topMargin">
          <number>0</number>
         </property>
         <property name="rightMargin">
          <number>0</number>
         </property>
         <property name="bottomMargin">
          <number>0</number>
         </property>
         <item>
          <widget class="KisCurveWidget" name="curveWidget" native="true">
           <property name="sizePolicy">
-           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
-            <horstretch>0</horstretch>
+           <sizepolicy hsizetype="MinimumExpanding" vsizetype="MinimumExpanding">
+            <horstretch>1</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="minimumSize">
            <size>
             <width>256</width>
             <height>256</height>
            </size>
           </property>
           <property name="maximumSize">
            <size>
-            <width>256</width>
-            <height>256</height>
+            <width>16777215</width>
+            <height>16777215</height>
            </size>
           </property>
          </widget>
         </item>
        </layout>
       </widget>
      </item>
      <item row="1" column="1">
       <widget class="QLabel" name="hgradient">
        <property name="sizePolicy">
-        <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
-         <horstretch>0</horstretch>
+        <sizepolicy hsizetype="Ignored" vsizetype="Fixed">
+         <horstretch>1</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="minimumSize">
         <size>
          <width>256</width>
          <height>20</height>
         </size>
        </property>
        <property name="maximumSize">
         <size>
-         <width>256</width>
+         <width>16777215</width>
          <height>20</height>
         </size>
        </property>
        <property name="frameShape">
         <enum>QFrame::Panel</enum>
        </property>
        <property name="frameShadow">
         <enum>QFrame::Sunken</enum>
        </property>
        <property name="scaledContents">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item row="0" column="0">
       <widget class="QLabel" name="vgradient">
        <property name="sizePolicy">
-        <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+        <sizepolicy hsizetype="Fixed" vsizetype="Ignored">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="minimumSize">
         <size>
          <width>20</width>
          <height>256</height>
         </size>
        </property>
        <property name="maximumSize">
         <size>
          <width>20</width>
-         <height>256</height>
+         <height>16777215</height>
         </size>
        </property>
        <property name="frameShape">
         <enum>QFrame::Panel</enum>
        </property>
        <property name="frameShadow">
         <enum>QFrame::Sunken</enum>
        </property>
        <property name="scaledContents">
         <bool>true</bool>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item row="0" column="1" colspan="2">
-    <layout class="QHBoxLayout">
+    <layout class="QHBoxLayout" stretch="1,2,2,1,0">
+     <property name="spacing">
+      <number>6</number>
+     </property>
      <item>
       <widget class="QLabel" name="textLabel1">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Maximum" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
         <string>Channel:</string>
        </property>
        <property name="alignment">
         <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QComboBox" name="cmbChannel"/>
      </item>
      <item>
       <spacer name="horizontalSpacer_4">
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>10</width>
          <height>10</height>
         </size>
        </property>
       </spacer>
      </item>
      <item>
       <widget class="QCheckBox" name="chkLogarithmic">
        <property name="text">
         <string>Logarithmic</string>
        </property>
       </widget>
      </item>
-    </layout>
-   </item>
-   <item row="1" column="0">
-    <spacer name="horizontalSpacer">
-     <property name="orientation">
-      <enum>Qt::Horizontal</enum>
-     </property>
-     <property name="sizeHint" stdset="0">
-      <size>
-       <width>1</width>
-       <height>20</height>
-      </size>
-     </property>
-    </spacer>
-   </item>
-   <item row="2" column="1" colspan="2">
-    <layout class="QGridLayout" name="gridLayout">
-     <item row="2" column="1">
-      <widget class="KisIntParseSpinBox" name="intOut">
-       <property name="sizePolicy">
-        <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
-         <horstretch>0</horstretch>
-         <verstretch>0</verstretch>
-        </sizepolicy>
-       </property>
-      </widget>
-     </item>
-     <item row="2" column="2">
-      <spacer name="horizontalSpacer_2">
-       <property name="sizePolicy">
-        <sizepolicy hsizetype="MinimumExpanding" vsizetype="Minimum">
-         <horstretch>0</horstretch>
-         <verstretch>0</verstretch>
-        </sizepolicy>
-       </property>
-       <property name="orientation">
-        <enum>Qt::Horizontal</enum>
-       </property>
-       <property name="sizeType">
-        <enum>QSizePolicy::MinimumExpanding</enum>
-       </property>
-       <property name="sizeHint" stdset="0">
-        <size>
-         <width>20</width>
-         <height>20</height>
-        </size>
-       </property>
-      </spacer>
-     </item>
-     <item row="2" column="0">
-      <widget class="QLabel" name="labelOut">
-       <property name="sizePolicy">
-        <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
-         <horstretch>0</horstretch>
-         <verstretch>0</verstretch>
-        </sizepolicy>
-       </property>
-       <property name="text">
-        <string>Output:</string>
-       </property>
-       <property name="alignment">
-        <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
-       </property>
-      </widget>
-     </item>
-     <item row="0" column="1">
-      <widget class="KisIntParseSpinBox" name="intIn">
-       <property name="sizePolicy">
-        <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
-         <horstretch>0</horstretch>
-         <verstretch>0</verstretch>
-        </sizepolicy>
-       </property>
-      </widget>
-     </item>
-     <item row="0" column="0">
-      <widget class="QLabel" name="labelIn">
+     <item>
+      <widget class="QPushButton" name="resetButton">
        <property name="sizePolicy">
-        <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+        <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
-        <string>Input:</string>
-       </property>
-       <property name="alignment">
-        <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+        <string>Reset</string>
        </property>
       </widget>
      </item>
     </layout>
    </item>
-   <item row="1" column="3">
-    <spacer name="horizontalSpacer_3">
-     <property name="orientation">
-      <enum>Qt::Horizontal</enum>
-     </property>
-     <property name="sizeHint" stdset="0">
-      <size>
-       <width>1</width>
-       <height>20</height>
-      </size>
-     </property>
-    </spacer>
-   </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KisIntParseSpinBox</class>
    <extends>QSpinBox</extends>
    <header>kis_int_parse_spin_box.h</header>
   </customwidget>
   <customwidget>
    <class>KisCurveWidget</class>
    <extends></extends>
    <header>widgets/kis_curve_widget.h</header>
   </customwidget>
  </customwidgets>
  <tabstops>
   <tabstop>cmbChannel</tabstop>
   <tabstop>intIn</tabstop>
   <tabstop>intOut</tabstop>
  </tabstops>
  <resources/>
  <connections/>
 </ui>