diff --git a/plugins/paintops/experiment/kis_experiment_paintop.cpp b/plugins/paintops/experiment/kis_experiment_paintop.cpp
index ea0efb2532..88c738243f 100644
--- a/plugins/paintops/experiment/kis_experiment_paintop.cpp
+++ b/plugins/paintops/experiment/kis_experiment_paintop.cpp
@@ -1,342 +1,358 @@
 /*
  *  Copyright (c) 2010-2011 Lukáš Tvrdý <lukast.dev@gmail.com>
  *  Copyright (c) 2012 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_experiment_paintop.h"
 #include "kis_experiment_paintop_settings.h"
 
 #include <cmath>
 
 #include <KoCompositeOpRegistry.h>
 
 #include <kis_debug.h>
 
 #include <kis_paint_device.h>
 #include <kis_painter.h>
 #include <kis_image.h>
 #include <kis_spacing_information.h>
 #include <krita_utils.h>
 
 
 KisExperimentPaintOp::KisExperimentPaintOp(const KisPaintOpSettingsSP settings, KisPainter *painter, KisNodeSP node, KisImageSP image)
     : KisPaintOp(painter)
 {
     Q_UNUSED(image);
     Q_UNUSED(node);
 
     m_firstRun = true;
 
     m_experimentOption.readOptionSetting(settings);
 
     m_displaceEnabled = m_experimentOption.isDisplacementEnabled;
     m_displaceCoeff = (m_experimentOption.displacement * 0.01 * 14) + 1; // 1..15 [7 default according alchemy]
 
     m_speedEnabled = m_experimentOption.isSpeedEnabled;
     m_speedMultiplier = (m_experimentOption.speed * 0.01 * 35); // 0..35 [15 default according alchemy]
     m_smoothingEnabled = m_experimentOption.isSmoothingEnabled;
     m_smoothingThreshold = m_experimentOption.smoothing;
 
     m_useMirroring = painter->hasMirroring();
     m_windingFill = m_experimentOption.windingFill;
     m_hardEdge = m_experimentOption.hardEdge;
 
+    //Sets the brush to pattern or foregroundColor
+    if (m_experimentOption.fillType == ExperimentFillType::Pattern) {
+        m_fillStyle = KisPainter::FillStylePattern;
+    } else {
+        m_fillStyle = KisPainter::FillStyleForegroundColor;
+    }
+
+    // Mirror options set with appropriate color, pattern, and fillStyle
     if (m_useMirroring) {
-        m_originalDevice = source()->createCompositionSourceDevice();
+        m_originalDevice = source()->createCompositionSourceDevice();        
         m_originalPainter = new KisPainter(m_originalDevice);
         m_originalPainter->setCompositeOp(COMPOSITE_COPY);
         m_originalPainter->setPaintColor(painter->paintColor());
-        m_originalPainter->setFillStyle(KisPainter::FillStyleForegroundColor);
+        m_originalPainter->setPattern(painter->pattern());        
+        m_originalPainter->setFillStyle(m_fillStyle);
+
+
+
+
     }
     else {
         m_originalPainter = 0;
     }
 }
 
 KisExperimentPaintOp::~KisExperimentPaintOp()
 {
     delete m_originalPainter;
 }
 
 void KisExperimentPaintOp::paintRegion(const QRegion &changedRegion)
 {
     if (m_windingFill) {
         m_path.setFillRule(Qt::WindingFill);
     }
 
     if (m_useMirroring) {
         m_originalPainter->setAntiAliasPolygonFill(!m_hardEdge);
 
         Q_FOREACH (const QRect & rect, changedRegion.rects()) {
             m_originalPainter->fillPainterPath(m_path, rect);
             painter()->renderDabWithMirroringNonIncremental(rect, m_originalDevice);
+
         }
     }
     else {
-        painter()->setFillStyle(KisPainter::FillStyleForegroundColor);
+        //Sets options when mirror is not selected
+        painter()->setFillStyle(m_fillStyle);
+
         painter()->setCompositeOp(COMPOSITE_COPY);
         painter()->setAntiAliasPolygonFill(!m_hardEdge);
 
         Q_FOREACH (const QRect & rect, changedRegion.rects()) {
             painter()->fillPainterPath(m_path, rect);
         }
     }
 }
 
 QPointF KisExperimentPaintOp::speedCorrectedPosition(const KisPaintInformation& pi1,
         const KisPaintInformation& pi2)
 {
     const qreal fadeFactor = 0.6;
 
     QPointF diff = pi2.pos() - pi1.pos();
     qreal realLength = sqrt(diff.x() * diff.x() + diff.y() * diff.y());
 
     if (realLength < 0.1) return pi2.pos();
 
     qreal coeff = 0.5 * realLength * m_speedMultiplier;
     m_savedSpeedCoeff = fadeFactor * m_savedSpeedCoeff + (1 - fadeFactor) * coeff;
     QPointF newPoint = pi1.pos() + diff * m_savedSpeedCoeff / realLength;
     m_savedSpeedPoint = fadeFactor * m_savedSpeedPoint + (1 - fadeFactor) * newPoint;
 
     return m_savedSpeedPoint;
 }
 
 void KisExperimentPaintOp::paintLine(const KisPaintInformation &pi1, const KisPaintInformation &pi2, KisDistanceInformation *currentDistance)
 {
     Q_UNUSED(currentDistance);
     if (!painter()) return;
 
     if (m_firstRun) {
         m_firstRun = false;
 
         m_path.moveTo(pi1.pos());
         m_path.lineTo(pi2.pos());
 
         m_center = pi1.pos();
 
         m_savedUpdateDistance = 0;
         m_lastPaintTime = 0;
 
         m_savedSpeedCoeff = 0;
         m_savedSpeedPoint = m_center;
 
         m_savedSmoothingDistance = 0;
         m_savedSmoothingPoint = m_center;
 
     }
     else {
 
         const QPointF pos1 = pi1.pos();
         QPointF pos2 = pi2.pos();
 
         if (m_speedEnabled) {
             pos2 = speedCorrectedPosition(pi1, pi2);
         }
 
         int length = (pos2 - pos1).manhattanLength();
         m_savedUpdateDistance += length;
 
         if (m_smoothingEnabled) {
             m_savedSmoothingDistance += length;
 
             if (m_savedSmoothingDistance > m_smoothingThreshold) {
                 QPointF pt = (m_savedSmoothingPoint + pos2) * 0.5;
 
                 // for updates approximate curve with two lines
                 m_savedPoints << m_path.currentPosition();
                 m_savedPoints << m_savedSmoothingPoint;
                 m_savedPoints << m_savedSmoothingPoint;
                 m_savedPoints << pt;
 
                 m_path.quadTo(m_savedSmoothingPoint, pt);
                 m_savedSmoothingPoint = pos2;
 
                 m_savedSmoothingDistance = 0;
             }
         }
         else {
             m_path.lineTo(pos2);
             m_savedPoints << pos1;
             m_savedPoints << pos2;
         }
 
         if (m_displaceEnabled) {
             if (m_path.elementCount() % 16 == 0) {
                 QRectF bounds = m_path.boundingRect();
                 m_path = applyDisplace(m_path, m_displaceCoeff - length);
                 bounds |= m_path.boundingRect();
 
                 qreal threshold = simplifyThreshold(bounds);
                 m_path = KritaUtils::trySimplifyPath(m_path, threshold);
             }
             else {
                 m_path = applyDisplace(m_path, m_displaceCoeff - length);
             }
         }
 
         /**
          * Refresh rate at least 25fps
          */
         const int timeThreshold = 40;
         const int elapsedTime = pi2.currentTime() - m_lastPaintTime;
 
         QRect pathBounds = m_path.boundingRect().toRect();
         int distanceMetric = qMax(pathBounds.width(), pathBounds.height());
 
         if (elapsedTime > timeThreshold ||
                 (!m_displaceEnabled &&
                  m_savedUpdateDistance > distanceMetric / 8)) {
 
             if (m_displaceEnabled) {
                 /**
                  * Rendering the path with diff'ed rects is up to two
                  * times more efficient for really huge shapes (tested
                  * on 2000+ px shapes), however for smaller ones doing
                  * paths arithmetics eats too much time. That's why we
                  * choose the method on the base of the size of the
                  * shape.
                  */
                 const int pathSizeThreshold = 128;
 
                 QRegion changedRegion;
                 if (distanceMetric < pathSizeThreshold) {
 
                     QRectF changedRect = m_path.boundingRect().toRect() |
                                          m_lastPaintedPath.boundingRect().toRect();
                     changedRect.adjust(-1, -1, 1, 1);
 
                     changedRegion = changedRect.toRect();
                 }
                 else {
                     QPainterPath diff1 = m_path - m_lastPaintedPath;
                     QPainterPath diff2 = m_lastPaintedPath - m_path;
 
                     changedRegion = KritaUtils::splitPath(diff1 | diff2);
                 }
 
                 paintRegion(changedRegion);
                 m_lastPaintedPath = m_path;
             }
             else if (!m_savedPoints.isEmpty()) {
                 QRegion changedRegion = KritaUtils::splitTriangles(m_center, m_savedPoints);
                 paintRegion(changedRegion);
             }
 
             m_savedPoints.clear();
             m_savedUpdateDistance = 0;
             m_lastPaintTime = pi2.currentTime();
         }
     }
 }
 
 
 KisSpacingInformation KisExperimentPaintOp::paintAt(const KisPaintInformation& info)
 {
     return updateSpacingImpl(info);
 }
 
 KisSpacingInformation KisExperimentPaintOp::updateSpacingImpl(const KisPaintInformation &info) const
 {
     Q_UNUSED(info);
     return KisSpacingInformation(1.0);
 }
 
 bool tryMergePoints(QPainterPath &path,
                     const QPointF &startPoint,
                     const QPointF &endPoint,
                     qreal &distance,
                     qreal distanceThreshold,
                     bool lastSegment)
 {
     qreal length = (endPoint - startPoint).manhattanLength();
 
     if (lastSegment || length > distanceThreshold) {
         if (distance != 0) {
             path.lineTo(startPoint);
         }
         distance = 0;
         return false;
     }
 
     distance += length;
 
     if (distance > distanceThreshold) {
         path.lineTo(endPoint);
         distance = 0;
     }
 
     return true;
 }
 
 qreal KisExperimentPaintOp::simplifyThreshold(const QRectF &bounds)
 {
     qreal maxDimension = qMax(bounds.width(), bounds.height());
     return qMax(0.01 * maxDimension, 1.0);
 }
 
 QPointF KisExperimentPaintOp::getAngle(const QPointF& p1, const QPointF& p2, qreal distance)
 {
     QPointF diff = p1 - p2;
     qreal realLength = sqrt(diff.x() * diff.x() + diff.y() * diff.y());
     return realLength > 0.5 ? p1 + diff * distance / realLength : p1;
 }
 
 QPainterPath KisExperimentPaintOp::applyDisplace(const QPainterPath& path, int speed)
 {
     QPointF lastPoint = path.currentPosition();
 
     QPainterPath newPath;
     int count = path.elementCount();
     int curveElementCounter = 0;
     QPointF ctrl1;
     QPointF ctrl2;
     QPointF endPoint;
     for (int i = 0; i < count; i++) {
         QPainterPath::Element e = path.elementAt(i);
         switch (e.type) {
         case QPainterPath::MoveToElement: {
             newPath.moveTo(getAngle(QPointF(e.x, e.y), lastPoint, speed));
             break;
         }
         case QPainterPath::LineToElement: {
             newPath.lineTo(getAngle(QPointF(e.x, e.y), lastPoint, speed));
             break;
         }
         case QPainterPath::CurveToElement: {
             curveElementCounter = 0;
             endPoint = getAngle(QPointF(e.x, e.y), lastPoint, speed);
             break;
         }
         case QPainterPath::CurveToDataElement: {
             curveElementCounter++;
 
             if (curveElementCounter == 1) {
                 ctrl1 = getAngle(QPointF(e.x, e.y), lastPoint, speed);
             }
             else if (curveElementCounter == 2) {
                 ctrl2 = getAngle(QPointF(e.x, e.y), lastPoint, speed);
                 newPath.cubicTo(ctrl1, ctrl2, endPoint);
             }
             break;
         }
         }
 
     }// for
 
     return newPath;
 }
 
diff --git a/plugins/paintops/experiment/kis_experiment_paintop.h b/plugins/paintops/experiment/kis_experiment_paintop.h
index 6a36ac46da..7f146ffe9b 100644
--- a/plugins/paintops/experiment/kis_experiment_paintop.h
+++ b/plugins/paintops/experiment/kis_experiment_paintop.h
@@ -1,90 +1,94 @@
 /*
  *  Copyright (c) 2010-2011 Lukáš Tvrdý <lukast.dev@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.
  */
 
 #ifndef KIS_EXPERIMENT_PAINTOP_H_
 #define KIS_EXPERIMENT_PAINTOP_H_
 
 #include <klocalizedstring.h>
 #include <brushengine/kis_paintop.h>
 #include <kis_types.h>
 
 #include "kis_experiment_paintop_settings.h"
 #include "kis_experimentop_option.h"
 
+#include <kis_painter.h>
+
 class QPointF;
 class KisPainter;
 
 class KisExperimentPaintOp : public KisPaintOp
 {
 
 public:
 
     KisExperimentPaintOp(const KisPaintOpSettingsSP settings, KisPainter *painter, KisNodeSP node, KisImageSP image);
     ~KisExperimentPaintOp() override;
 
     void paintLine(const KisPaintInformation& pi1, const KisPaintInformation& pi2, KisDistanceInformation *currentDistance) override;
 
 protected:
     KisSpacingInformation paintAt(const KisPaintInformation& info) override;
 
     KisSpacingInformation updateSpacingImpl(const KisPaintInformation &info) const override;
 
 private:
     void paintRegion(const QRegion &changedRegion);
     QPointF speedCorrectedPosition(const KisPaintInformation& pi1,
                                    const KisPaintInformation& pi2);
 
 
     static qreal simplifyThreshold(const QRectF &bounds);
     static QPointF getAngle(const QPointF& p1, const QPointF& p2, qreal distance);
     static QPainterPath applyDisplace(const QPainterPath& path, int speed);
 
 
     bool m_displaceEnabled;
     int m_displaceCoeff;
     QPainterPath m_lastPaintedPath;
 
     bool m_windingFill;
     bool m_hardEdge;
 
     bool m_speedEnabled;
     int m_speedMultiplier;
     qreal m_savedSpeedCoeff;
     QPointF m_savedSpeedPoint;
 
     bool m_smoothingEnabled;
     int m_smoothingThreshold;
     QPointF m_savedSmoothingPoint;
     int m_savedSmoothingDistance;
 
     int m_savedUpdateDistance;
     QVector<QPointF> m_savedPoints;
     int m_lastPaintTime;
 
     bool m_firstRun;
     QPointF m_center;
 
     QPainterPath m_path;
     ExperimentOption m_experimentOption;
 
     bool m_useMirroring;
     KisPainter *m_originalPainter;
     KisPaintDeviceSP m_originalDevice;
+
+    KisPainter::FillStyle m_fillStyle;
 };
 
 #endif // KIS_EXPERIMENT_PAINTOP_H_
diff --git a/plugins/paintops/experiment/kis_experimentop_option.cpp b/plugins/paintops/experiment/kis_experimentop_option.cpp
index ca0a41c397..d31869c984 100644
--- a/plugins/paintops/experiment/kis_experimentop_option.cpp
+++ b/plugins/paintops/experiment/kis_experimentop_option.cpp
@@ -1,135 +1,152 @@
 /*
  *  Copyright (c) 2010 Lukáš Tvrdý <lukast.dev@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_experimentop_option.h"
 #include <klocalizedstring.h>
 
 #include <brushengine/kis_paintop_lod_limitations.h>
 
 #include "ui_wdgexperimentoptions.h"
 
 class KisExperimentOpOptionsWidget: public QWidget, public Ui::WdgExperimentOptions
 {
 public:
     KisExperimentOpOptionsWidget(QWidget *parent = 0)
         : QWidget(parent) {
         setupUi(this);
 
         speed->setRange(0.0, 100.0, 0);
         speed->setSuffix(QChar(Qt::Key_Percent));
         speed->setValue(42.0);
         speed->setSingleStep(1.0);
 
         smoothThreshold->setRange(0.0, 100.0, 0);
         smoothThreshold->setSuffix(i18n(" px"));
         smoothThreshold->setValue(20.0);
         smoothThreshold->setSingleStep(1.0);
 
         displaceStrength->setRange(0.0, 100.0, 0);
         displaceStrength->setSuffix(QChar(Qt::Key_Percent));
         displaceStrength->setValue(42.0);
         displaceStrength->setSingleStep(1.0);
     }
 };
 
 KisExperimentOpOption::KisExperimentOpOption()
     : KisPaintOpOption(KisPaintOpOption::GENERAL, false)
 {
     setObjectName("KisExperimentOpOption");
 
     m_checkable = false;
     m_options = new KisExperimentOpOptionsWidget();
 
     connect(m_options->displaceCHBox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
     connect(m_options->displaceStrength, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
     connect(m_options->speedCHBox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
     connect(m_options->speed, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
     connect(m_options->smoothCHBox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
     connect(m_options->smoothThreshold, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
 
     connect(m_options->displaceStrength, SIGNAL(valueChanged(qreal)), SLOT(enableDisplacement(qreal)));
     connect(m_options->speed, SIGNAL(valueChanged(qreal)), SLOT(enableSpeed(qreal)));
     connect(m_options->smoothThreshold, SIGNAL(valueChanged(qreal)), SLOT(enableSmooth(qreal)));
 
     connect(m_options->windingFillCHBox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
     connect(m_options->hardEdgeCHBox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
+
+    connect(m_options->patternButton, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
+    connect(m_options->solidColorButton, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
+
     setConfigurationPage(m_options);
 }
 
 KisExperimentOpOption::~KisExperimentOpOption()
 {
     delete m_options;
 }
 
 void KisExperimentOpOption::writeOptionSetting(KisPropertiesConfigurationSP setting) const
 {
     ExperimentOption op;
 
     op.isDisplacementEnabled = m_options->displaceCHBox->isChecked();
     op.displacement = m_options->displaceStrength->value();
     op.isSpeedEnabled = m_options->speedCHBox->isChecked();
     op.speed = m_options->speed->value();
     op.isSmoothingEnabled = m_options->smoothCHBox->isChecked();
     op.smoothing = m_options->smoothThreshold->value();
     op.windingFill = m_options->windingFillCHBox->isChecked();
     op.hardEdge = m_options->hardEdgeCHBox->isChecked();
 
+    if (m_options->patternButton->isChecked()) {
+        op.fillType = ExperimentFillType::Pattern;
+    } else {
+        op.fillType = ExperimentFillType::SolidColor;
+    }
+
     op.writeOptionSetting(setting);
 }
 
 void KisExperimentOpOption::readOptionSetting(const KisPropertiesConfigurationSP setting)
 {
     ExperimentOption op;
     op.readOptionSetting(setting);
 
     m_options->displaceStrength->setValue(op.displacement);
     m_options->speed->setValue(op.speed);
     m_options->smoothThreshold->setValue(op.smoothing);
     m_options->windingFillCHBox->setChecked(op.windingFill);
     m_options->hardEdgeCHBox->setChecked(op.hardEdge);
 
     m_options->speedCHBox->setChecked(op.isSpeedEnabled);
     m_options->smoothCHBox->setChecked(op.isSmoothingEnabled);
     m_options->displaceCHBox->setChecked(op.isDisplacementEnabled);
+
+
+    if (op.fillType == ExperimentFillType::Pattern) {
+        m_options->patternButton->setChecked(true);
+    } else {
+        m_options->solidColorButton->setChecked(true);
+    }
 }
 
 inline void enableCheckBox(QCheckBox *checkBox, qreal sliderValue)
 {
     checkBox->setChecked(sliderValue > 0);
 }
 
 void KisExperimentOpOption::enableSpeed(qreal value)
 {
     enableCheckBox(m_options->speedCHBox, value);
 }
 
 void KisExperimentOpOption::enableSmooth(qreal value)
 {
     enableCheckBox(m_options->smoothCHBox, value);
 }
 
 void KisExperimentOpOption::enableDisplacement(qreal value)
 {
     enableCheckBox(m_options->displaceCHBox, value);
 }
 
 void KisExperimentOpOption::lodLimitations(KisPaintopLodLimitations *l) const
 {
     if (m_options->displaceCHBox->isChecked()) {
         l->blockers << KoID("experiment-displacement", i18nc("PaintOp instant preview limitation", "Displacement Option"));
     }
 }
diff --git a/plugins/paintops/experiment/kis_experimentop_option.h b/plugins/paintops/experiment/kis_experimentop_option.h
index 3de4897c69..77e437594d 100644
--- a/plugins/paintops/experiment/kis_experimentop_option.h
+++ b/plugins/paintops/experiment/kis_experimentop_option.h
@@ -1,98 +1,107 @@
 /*
  *  Copyright (c) 2010 Lukáš Tvrdý <lukast.dev@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.
  */
 #ifndef KIS_EXPERIMENTOP_OPTION_H
 #define KIS_EXPERIMENTOP_OPTION_H
 
 #include <kis_paintop_option.h>
 class KisPaintopLodLimitations;
 
 const QString EXPERIMENT_DISPLACEMENT_ENABLED = "Experiment/displacementEnabled";
 const QString EXPERIMENT_DISPLACEMENT_VALUE = "Experiment/displacement";
 const QString EXPERIMENT_SMOOTHING_ENABLED = "Experiment/smoothing";
 const QString EXPERIMENT_SMOOTHING_VALUE = "Experiment/smoothingValue";
 const QString EXPERIMENT_SPEED_ENABLED = "Experiment/speedEnabled";
 const QString EXPERIMENT_SPEED_VALUE = "Experiment/speed";
 const QString EXPERIMENT_WINDING_FILL = "Experiment/windingFill";
 const QString EXPERIMENT_HARD_EDGE = "Experiment/hardEdge";
+const QString EXPERIMENT_FILL_TYPE = "Experiment/fillType";
 
 
+enum ExperimentFillType {
+    SolidColor,
+    Pattern
+};
+
 
 class KisExperimentOpOptionsWidget;
 
 class KisExperimentOpOption : public KisPaintOpOption
 {
     Q_OBJECT
 public:
     KisExperimentOpOption();
     ~KisExperimentOpOption() override;
 
     void writeOptionSetting(KisPropertiesConfigurationSP setting) const override;
     void readOptionSetting(const KisPropertiesConfigurationSP setting) override;
 
     void lodLimitations(KisPaintopLodLimitations *l) const override;
 
 private Q_SLOTS:
     void enableSpeed(qreal value);
     void enableSmooth(qreal value);
     void enableDisplacement(qreal value);
 
 private:
     KisExperimentOpOptionsWidget * m_options;
 
 };
 
 class ExperimentOption
 {
 
 public:
     bool isDisplacementEnabled;
     qreal displacement;
     bool isSpeedEnabled;
     qreal speed;
     bool isSmoothingEnabled;
     qreal smoothing;
     bool windingFill;
     bool hardEdge;
+    ExperimentFillType fillType;
 
     void readOptionSetting(const KisPropertiesConfigurationSP setting) {
         isDisplacementEnabled = setting->getBool(EXPERIMENT_DISPLACEMENT_ENABLED);
         displacement = setting->getDouble(EXPERIMENT_DISPLACEMENT_VALUE, 50.0);
         isSpeedEnabled = setting->getBool(EXPERIMENT_SPEED_ENABLED);
         speed = setting->getDouble(EXPERIMENT_SPEED_VALUE, 50.0);
         isSmoothingEnabled = setting->getBool(EXPERIMENT_SMOOTHING_ENABLED);
         smoothing = setting->getDouble(EXPERIMENT_SMOOTHING_VALUE, 20.0);
         windingFill = setting->getBool(EXPERIMENT_WINDING_FILL);
         hardEdge = setting->getBool(EXPERIMENT_HARD_EDGE);
+        fillType = (ExperimentFillType)setting->getInt(EXPERIMENT_FILL_TYPE, 0); // default to solid color
     }
 
     void writeOptionSetting(KisPropertiesConfigurationSP setting) const {
         setting->setProperty(EXPERIMENT_DISPLACEMENT_ENABLED, isDisplacementEnabled);
         setting->setProperty(EXPERIMENT_DISPLACEMENT_VALUE, displacement);
         setting->setProperty(EXPERIMENT_SPEED_ENABLED, isSpeedEnabled);
         setting->setProperty(EXPERIMENT_SPEED_VALUE, speed);
         setting->setProperty(EXPERIMENT_SMOOTHING_ENABLED, isSmoothingEnabled);
         setting->setProperty(EXPERIMENT_SMOOTHING_VALUE, smoothing);
         setting->setProperty(EXPERIMENT_WINDING_FILL, windingFill);
         setting->setProperty(EXPERIMENT_HARD_EDGE, hardEdge);
+        setting->setProperty(EXPERIMENT_FILL_TYPE, fillType);
     }
 
 
 
 };
 
 #endif
diff --git a/plugins/paintops/experiment/wdgexperimentoptions.ui b/plugins/paintops/experiment/wdgexperimentoptions.ui
index e0c6e0b803..16bf0080ac 100644
--- a/plugins/paintops/experiment/wdgexperimentoptions.ui
+++ b/plugins/paintops/experiment/wdgexperimentoptions.ui
@@ -1,150 +1,194 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgExperimentOptions</class>
  <widget class="QWidget" name="WdgExperimentOptions">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>425</width>
-    <height>328</height>
+    <width>500</width>
+    <height>317</height>
    </rect>
   </property>
   <property name="sizePolicy">
-   <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+   <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
     <horstretch>255</horstretch>
     <verstretch>255</verstretch>
    </sizepolicy>
   </property>
   <property name="minimumSize">
    <size>
-    <width>425</width>
+    <width>500</width>
     <height>290</height>
    </size>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout_2">
    <item>
     <widget class="QLabel" name="label_2">
      <property name="text">
       <string>Shape creation:</string>
      </property>
     </widget>
    </item>
    <item>
     <layout class="QFormLayout" name="formLayout">
      <property name="sizeConstraint">
       <enum>QLayout::SetMaximumSize</enum>
      </property>
      <property name="fieldGrowthPolicy">
       <enum>QFormLayout::ExpandingFieldsGrow</enum>
      </property>
      <property name="labelAlignment">
       <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter</set>
      </property>
-     <item row="0" column="0">
-      <widget class="QCheckBox" name="speedCHBox">
+     <item row="0" column="1">
+      <widget class="KisDoubleSliderSpinBox" name="speed" native="true">
        <property name="sizePolicy">
-        <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
+        <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
-       <property name="text">
-        <string>Speed</string>
-       </property>
       </widget>
      </item>
-     <item row="0" column="1">
-      <widget class="KisDoubleSliderSpinBox" name="speed">
+     <item row="1" column="1">
+      <widget class="KisDoubleSliderSpinBox" name="smoothThreshold" native="true">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
       </widget>
      </item>
      <item row="1" column="0">
       <widget class="QCheckBox" name="smoothCHBox">
        <property name="text">
         <string comment="Noun for an experiment brush shape smoothness">Smooth</string>
        </property>
       </widget>
      </item>
-     <item row="1" column="1">
-      <widget class="KisDoubleSliderSpinBox" name="smoothThreshold">
+     <item row="0" column="0">
+      <widget class="QCheckBox" name="speedCHBox">
        <property name="sizePolicy">
-        <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
+        <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
+       <property name="text">
+        <string>Speed</string>
+       </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <widget class="QLabel" name="lblPostprocessing">
      <property name="text">
       <string>Post-processing</string>
      </property>
     </widget>
    </item>
    <item>
     <layout class="QHBoxLayout" name="displaceLayout" stretch="0,1">
      <item>
       <widget class="QCheckBox" name="displaceCHBox">
        <property name="text">
         <string>Displace</string>
        </property>
       </widget>
      </item>
      <item>
-      <widget class="KisDoubleSliderSpinBox" name="displaceStrength"/>
+      <widget class="KisDoubleSliderSpinBox" name="displaceStrength" native="true"/>
      </item>
     </layout>
    </item>
    <item>
     <layout class="QHBoxLayout" name="fillLayout" stretch="0,1">
      <item>
       <widget class="QCheckBox" name="windingFillCHBox">
        <property name="text">
         <string>Winding fill</string>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QCheckBox" name="hardEdgeCHBox">
        <property name="text">
         <string>Hard edge</string>
        </property>
       </widget>
      </item>
     </layout>
    </item>
+   <item>
+    <widget class="QGroupBox" name="fillStylGroupBox">
+     <property name="minimumSize">
+      <size>
+       <width>0</width>
+       <height>90</height>
+      </size>
+     </property>
+     <property name="title">
+      <string>Fill Style</string>
+     </property>
+     <property name="flat">
+      <bool>false</bool>
+     </property>
+     <property name="checkable">
+      <bool>false</bool>
+     </property>
+     <layout class="QVBoxLayout" name="verticalLayout">
+      <property name="spacing">
+       <number>5</number>
+      </property>
+      <property name="leftMargin">
+       <number>5</number>
+      </property>
+      <item>
+       <widget class="QRadioButton" name="solidColorButton">
+        <property name="text">
+         <string>Foreground Color</string>
+        </property>
+        <property name="checked">
+         <bool>true</bool>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QRadioButton" name="patternButton">
+        <property name="text">
+         <string>Global Pattern</string>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </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>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KisDoubleSliderSpinBox</class>
    <extends>QWidget</extends>
    <header>kis_slider_spin_box.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>