diff --git a/plugins/paintops/libpaintop/kis_brush_chooser.h b/plugins/paintops/libpaintop/kis_brush_chooser.h
index a61958e68b..7610e5385c 100644
--- a/plugins/paintops/libpaintop/kis_brush_chooser.h
+++ b/plugins/paintops/libpaintop/kis_brush_chooser.h
@@ -1,86 +1,86 @@
 /*
  *  Copyright (c) 2004 Adrian Page <adrian@pagenet.plus.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_PREDEFINED_BRUSH_CHOOSER_H_
 #define KIS_PREDEFINED_BRUSH_CHOOSER_H_
 
 #include <QLabel>
 #include <kis_brush.h>
 #include <QScroller>
 
 #include "kritapaintop_export.h"
 #include "ui_wdgpredefinedbrushchooser.h"
 
 
 
 
 class KisDoubleSliderSpinBox;
 class QLabel;
 class QCheckBox;
 
 class KisDoubleSliderSpinBox;
 class KisSpacingSelectionWidget;
 class KisCustomBrushWidget;
 class KisClipboardBrushWidget;
 class KoResourceItemChooser;
 class KoResource;
 
 
-class PAINTOP_EXPORT KisPredefinedBrushChooser : public QWidget, Ui::WdgPredefinedBrushChooser
+class PAINTOP_EXPORT KisPredefinedBrushChooser : public QWidget, public Ui::WdgPredefinedBrushChooser
 {
 
     Q_OBJECT
 
 public:
     KisPredefinedBrushChooser(QWidget *parent = 0, const char *name = 0);
     ~KisPredefinedBrushChooser() override;
 
     KisBrushSP brush() {
         return m_brush;
     };
 
     void setBrush(KisBrushSP brush);
     void setBrushSize(qreal xPixels, qreal yPixels);
     void setImage(KisImageWSP image);
 
 private Q_SLOTS:
 
     void slotResetBrush();
     void slotSetItemSize(qreal);
     void slotSetItemRotation(qreal);
     void slotSpacingChanged();
     void slotSetItemUseColorAsMask(bool);
     void slotOpenStampBrush();
     void slotOpenClipboardBrush();
     void slotImportNewBrushResource();
     void slotDeleteBrushResource();
     void slotNewPredefinedBrush(KoResource *);
     void updateBrushTip(KoResource *, bool isChangingBrushPresets = false);
 
 Q_SIGNALS:
 
     void sigBrushChanged();
 
 private:
     KisBrushSP m_brush;
     KoResourceItemChooser* m_itemChooser;
     KisImageWSP m_image;
     KisCustomBrushWidget* m_stampBrushWidget;
     KisClipboardBrushWidget* m_clipboardBrushWidget;
 };
 
 #endif // KIS_PREDEFINED_BRUSH_CHOOSER_H_
diff --git a/plugins/paintops/libpaintop/kis_brush_selection_widget.cpp b/plugins/paintops/libpaintop/kis_brush_selection_widget.cpp
index 0d0f2cdb03..69df6db7a0 100644
--- a/plugins/paintops/libpaintop/kis_brush_selection_widget.cpp
+++ b/plugins/paintops/libpaintop/kis_brush_selection_widget.cpp
@@ -1,360 +1,389 @@
 /*
  *  Copyright (c) 2008 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2014 Mohit Goyal    <mohit.bits2011@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_brush_selection_widget.h"
 #include <QLayout>
 #include <QTabWidget>
 #include <QFrame>
 #include <QImage>
 #include <QPainter>
 #include <QBrush>
 #include <QColor>
 #include <QToolButton>
 #include <QButtonGroup>
 
 #include <klocalizedstring.h>
 
 #include <widgets/kis_preset_chooser.h>
 #include <kis_image.h>
 #include <kis_fixed_paint_device.h>
 
 #include "kis_brush.h"
 #include "kis_auto_brush.h"
 #include "kis_imagepipe_brush.h"
 #include "kis_brush_chooser.h"
 #include "kis_auto_brush_widget.h"
 #include "kis_custom_brush_widget.h"
 #include "kis_clipboard_brush_widget.h"
 #include "kis_text_brush_chooser.h"
 
 KisBrushSelectionWidget::KisBrushSelectionWidget(QWidget * parent)
     : QWidget(parent), m_currentBrushWidget(0)
 {
     uiWdgBrushChooser.setupUi(this);
 
     m_buttonGroup = new QButtonGroup(this);
     m_buttonGroup->setExclusive(true);
 
     m_layout = new QGridLayout(uiWdgBrushChooser.settingsFrame);
     m_autoBrushWidget = new KisAutoBrushWidget(this, "autobrush");
     connect(m_autoBrushWidget, SIGNAL(sigBrushChanged()), SIGNAL(sigBrushChanged()));
+    connect(m_autoBrushWidget->inputRadius, SIGNAL(valueChanged(qreal)), SLOT(refreshAutoPrecision(qreal)));
     addChooser(i18n("Auto"), m_autoBrushWidget, AUTOBRUSH, KoGroupButton::GroupLeft);
 
     m_predefinedBrushWidget = new KisPredefinedBrushChooser(this);
     connect(m_predefinedBrushWidget, SIGNAL(sigBrushChanged()), SIGNAL(sigBrushChanged()));
+    connect(m_predefinedBrushWidget->brushSizeSpinBox, SIGNAL(valueChanged(qreal)), SLOT(refreshAutoPrecision(qreal)));
     addChooser(i18n("Predefined"), m_predefinedBrushWidget, PREDEFINEDBRUSH, KoGroupButton::GroupCenter);
 
     m_textBrushWidget = new KisTextBrushChooser(this, "textbrush", i18n("Text"));
     connect(m_textBrushWidget, SIGNAL(sigBrushChanged()), SIGNAL(sigBrushChanged()));
+    connect(m_textBrushWidget, SIGNAL(fontSizeChanged(qreal)), SLOT(refreshAutoPrecision(qreal)));
     addChooser(i18n("Text"), m_textBrushWidget, TEXTBRUSH, KoGroupButton::GroupRight);
 
     connect(m_buttonGroup, SIGNAL(buttonClicked(int)), this, SLOT(buttonClicked(int)));
 
     Q_FOREACH (QWidget * widget, m_chooserMap.values()) {
         m_mininmumSize = m_mininmumSize.expandedTo(widget->sizeHint());
     }
 
     setCurrentWidget(m_autoBrushWidget);
 
     uiWdgBrushChooser.sliderPrecision->setRange(1, 5);
     uiWdgBrushChooser.sliderPrecision->setSingleStep(1);
     uiWdgBrushChooser.sliderPrecision->setPageStep(1);
     connect(uiWdgBrushChooser.sliderPrecision, SIGNAL(valueChanged(int)), SLOT(precisionChanged(int)));
     connect(uiWdgBrushChooser.autoPrecisionCheckBox, SIGNAL(stateChanged(int)), SLOT(setAutoPrecisionEnabled(int)));
     connect(uiWdgBrushChooser.deltaValueSpinBox, SIGNAL(valueChanged(double)), SLOT(setDeltaValue(double)));
     connect(uiWdgBrushChooser.sizeToStartFromSpinBox, SIGNAL(valueChanged(double)), SLOT(setSizeToStartFrom(double)));
     uiWdgBrushChooser.sliderPrecision->setValue(4);
     setPrecisionEnabled(false);
     uiWdgBrushChooser.label->setVisible(false);
     uiWdgBrushChooser.label_2->setVisible(false);
     uiWdgBrushChooser.deltaValueSpinBox->setVisible(false);
     uiWdgBrushChooser.sizeToStartFromSpinBox->setVisible(false);
     uiWdgBrushChooser.lblPrecisionValue->setVisible(false);
     uiWdgBrushChooser.label ->setToolTip(i18n("Use to set the size from which the Automatic Precision Setting should begin. \nThe Precision will remain 5 before this value."));
     uiWdgBrushChooser.label_2 ->setToolTip(i18n("Use to set the interval at which the Automatic Precision will change. \nThe Precision will decrease as brush size increases."));
 
     m_presetIsValid = true;
 }
 
 
 KisBrushSelectionWidget::~KisBrushSelectionWidget()
 {
 }
 
 KisBrushSP KisBrushSelectionWidget::brush() const
 {
     KisBrushSP theBrush;
     switch (m_buttonGroup->checkedId()) {
     case AUTOBRUSH:
         theBrush = m_autoBrushWidget->brush();
         break;
     case PREDEFINEDBRUSH:
         theBrush = m_predefinedBrushWidget->brush();
         break;
     case TEXTBRUSH:
         theBrush = m_textBrushWidget->brush();
         break;
     default:
         ;
     }
     // Fallback to auto brush if no brush selected
     // Can happen if there is no predefined brush found
     if (!theBrush)
         theBrush = m_autoBrushWidget->brush();
 
     return theBrush;
 
 }
 
+void KisBrushSelectionWidget::updatePrecisionByType(int id)
+{
+    switch (id) {
+    case AUTOBRUSH:
+        refreshAutoPrecision(m_autoBrushWidget->inputRadius->value());
+        break;
+    case PREDEFINEDBRUSH:
+        refreshAutoPrecision(m_predefinedBrushWidget->brushSizeSpinBox->value());
+        break;
+    case TEXTBRUSH:
+        refreshAutoPrecision(m_textBrushWidget->fontInfo().pixelSize());
+        break;
+    default:
+        ;
+    }
+}
+
 
 void KisBrushSelectionWidget::setAutoBrush(bool on)
 {
     m_buttonGroup->button(AUTOBRUSH)->setVisible(on);
 }
 
 void KisBrushSelectionWidget::setPredefinedBrushes(bool on)
 {
     m_buttonGroup->button(PREDEFINEDBRUSH)->setVisible(on);
 }
 
 void KisBrushSelectionWidget::setCustomBrush(bool on)
 {
     m_buttonGroup->button(CUSTOMBRUSH)->setVisible(on);
 }
 
 void KisBrushSelectionWidget::setClipboardBrush(bool on)
 {
     m_buttonGroup->button(CLIPBOARDBRUSH)->setVisible(on);
 }
 
 void KisBrushSelectionWidget::setTextBrush(bool on)
 {
     m_buttonGroup->button(TEXTBRUSH)->setVisible(on);
 }
 
 void KisBrushSelectionWidget::setImage(KisImageWSP image)
 {
     m_predefinedBrushWidget->setImage(image);
 }
 
 void KisBrushSelectionWidget::setCurrentBrush(KisBrushSP brush)
 {
     if (!brush) {
         return;
     }
     // XXX: clever code have brush plugins know their configuration
     //      pane, so we don't have to have this if statement and
     //      have an extensible set of brush types
     if (dynamic_cast<KisAutoBrush*>(brush.data())) {
         setCurrentWidget(m_autoBrushWidget);
         m_autoBrushWidget->setBrush(brush);
     }
     else if (dynamic_cast<KisTextBrush*>(brush.data())) {
         setCurrentWidget(m_textBrushWidget);
         m_textBrushWidget->setBrush(brush);
     }
     else {
         setCurrentWidget(m_predefinedBrushWidget);
         m_predefinedBrushWidget->setBrush(brush);
     }
 
 }
 
 void KisBrushSelectionWidget::buttonClicked(int id)
 {
     setCurrentWidget(m_chooserMap[id]);
+    updatePrecisionByType(id);
     emit sigBrushChanged();
 }
 
 void KisBrushSelectionWidget::precisionChanged(int value)
 {
     QString toolTip;
 
     switch (value) {
     case 1:
         toolTip =
             i18n("Precision Level 1 (fastest)\n"
                  "Subpixel precision: disabled\n"
                  "Brush size precision: 5%\n"
                  "\n"
                  "Optimal for very big brushes");
         break;
     case 2:
         toolTip =
             i18n("Precision Level 2\n"
                  "Subpixel precision: disabled\n"
                  "Brush size precision: 1%\n"
                  "\n"
                  "Optimal for big brushes");
         break;
     case 3:
         toolTip =
             i18n("Precision Level 3\n"
                  "Subpixel precision: disabled\n"
                  "Brush size precision: exact");
         break;
     case 4:
         toolTip =
             i18n("Precision Level 4 (optimal)\n"
                  "Subpixel precision: 50%\n"
                  "Brush size precision: exact\n"
                  "\n"
                  "Gives up to 50% better performance in comparison to Level 5");
         break;
     case 5:
         toolTip =
             i18n("Precision Level 5 (best quality)\n"
                  "Subpixel precision: exact\n"
                  "Brush size precision: exact\n"
                  "\n"
                  "The slowest performance. Best quality.");
         break;
     }
     uiWdgBrushChooser.sliderPrecision->blockSignals(true);
     uiWdgBrushChooser.sliderPrecision->setValue(value);
     uiWdgBrushChooser.sliderPrecision->blockSignals(false);
     uiWdgBrushChooser.sliderPrecision->setToolTip(toolTip);
     m_precisionOption.setPrecisionLevel(value);
     emit sigPrecisionChanged();
 }
 
 void KisBrushSelectionWidget::writeOptionSetting(KisPropertiesConfigurationSP settings) const
 {
     m_precisionOption.writeOptionSetting(settings);
 }
 
 void KisBrushSelectionWidget::readOptionSetting(const KisPropertiesConfigurationSP setting)
 {
     m_precisionOption.readOptionSetting(setting);
     uiWdgBrushChooser.sliderPrecision->setValue(m_precisionOption.precisionLevel());
     uiWdgBrushChooser.autoPrecisionCheckBox->setChecked(m_precisionOption.autoPrecisionEnabled());
     uiWdgBrushChooser.deltaValueSpinBox ->setValue(m_precisionOption.deltaValue());
     uiWdgBrushChooser.sizeToStartFromSpinBox ->setValue(m_precisionOption.sizeToStartFrom());
 }
 
 void KisBrushSelectionWidget::setPrecisionEnabled(bool value)
 {
     uiWdgBrushChooser.sliderPrecision->setVisible(value);
     uiWdgBrushChooser.lblPrecision->setVisible(value);
 }
 
 void KisBrushSelectionWidget::hideOptions(const QStringList &options)
 {
     Q_FOREACH(const QString &option, options) {
         QStringList l = option.split("/");
         if (l.count() != 2) {
             continue;
         }
         QObject *o = 0;
         if (l[0] == "KisAutoBrushWidget") {
             o = m_autoBrushWidget->findChild<QObject*>(l[1]);
         }
         else if (l[0] == "KisBrushChooser") {
             o = m_predefinedBrushWidget->findChild<QObject*>(l[1]);
         }
         else if (l[0] == "KisTextBrushChooser") {
             o = m_textBrushWidget->findChild<QObject*>(l[1]);
         }
         else {
             qWarning() << "KisBrushSelectionWidget: Invalid option given to disable:" << option;
         }
 
         if (o) {
             QWidget *w = qobject_cast<QWidget*>(o);
             if (w) {
                 w->setVisible(false);
             }
             o = 0;
         }
     }
 }
 
 void KisBrushSelectionWidget::setCurrentWidget(QWidget* widget)
 {
     if (widget == m_currentBrushWidget) return;
 
     if (m_currentBrushWidget) {
         m_layout->removeWidget(m_currentBrushWidget);
         m_currentBrushWidget->setParent(this);
         m_currentBrushWidget->hide();
     }
     widget->setMinimumSize(m_mininmumSize);
 
     m_currentBrushWidget = widget;
     m_layout->addWidget(widget);
 
     m_currentBrushWidget->show();
     m_buttonGroup->button(m_chooserMap.key(widget))->setChecked(true);
 
     m_presetIsValid = (m_buttonGroup->checkedId() != CUSTOMBRUSH);
 }
 
 void KisBrushSelectionWidget::addChooser(const QString& text, QWidget* widget, int id, KoGroupButton::GroupPosition pos)
 {
     KoGroupButton * button = new KoGroupButton(this);
     button->setGroupPosition(pos);
     button->setText(text);
     button->setAutoRaise(false);
     button->setCheckable(true);
     uiWdgBrushChooser.brushChooserButtonLayout->addWidget(button);
 
     m_buttonGroup->addButton(button, id);
     m_chooserMap[m_buttonGroup->id(button)] = widget;
     widget->hide();
 }
+
 void KisBrushSelectionWidget::setAutoPrecisionEnabled(int value)
 {
     m_precisionOption.setAutoPrecisionEnabled(value);
-    if(m_precisionOption.autoPrecisionEnabled())
-    {
-        m_precisionOption.setAutoPrecision(brush()->width());
+    if (m_precisionOption.autoPrecisionEnabled()) {
+        m_precisionOption.setAutoPrecision(brush()->userEffectiveSize());
         setPrecisionEnabled(false);
         precisionChanged(m_precisionOption.precisionLevel());
         uiWdgBrushChooser.label->setVisible(true);
         uiWdgBrushChooser.label_2->setVisible(true);
         uiWdgBrushChooser.deltaValueSpinBox->setVisible(true);
         uiWdgBrushChooser.sizeToStartFromSpinBox->setVisible(true);
         uiWdgBrushChooser.lblPrecisionValue->setVisible(true);
-        uiWdgBrushChooser.lblPrecisionValue->setText("Precision:"+QString::number(m_precisionOption.precisionLevel()));
+        uiWdgBrushChooser.lblPrecisionValue->setText(i18n("Precision: %1", m_precisionOption.precisionLevel()));
 
-    }
-    else
-    {
+    } else {
         setPrecisionEnabled(true);
         uiWdgBrushChooser.label->setVisible(false);
         uiWdgBrushChooser.label_2->setVisible(false);
         uiWdgBrushChooser.deltaValueSpinBox->setVisible(false);
         uiWdgBrushChooser.sizeToStartFromSpinBox->setVisible(false);
         uiWdgBrushChooser.lblPrecisionValue->setVisible(false);
     }
     emit sigPrecisionChanged();
 }
+
+void KisBrushSelectionWidget::refreshAutoPrecision(qreal value)
+{
+    if (m_precisionOption.autoPrecisionEnabled() && value > 0) {
+        m_precisionOption.setAutoPrecision(value);
+        precisionChanged(m_precisionOption.precisionLevel());
+        uiWdgBrushChooser.lblPrecisionValue->setText(i18n("Precision: %1", m_precisionOption.precisionLevel()));
+    }
+}
+
 void KisBrushSelectionWidget::setSizeToStartFrom(double value)
 {
     m_precisionOption.setSizeToStartFrom(value);
     emit sigPrecisionChanged();
 }
 
 void KisBrushSelectionWidget::setDeltaValue(double value)
 {
     m_precisionOption.setDeltaValue(value);
     emit sigPrecisionChanged();
 
 }
 
 #include "moc_kis_brush_selection_widget.cpp"
diff --git a/plugins/paintops/libpaintop/kis_brush_selection_widget.h b/plugins/paintops/libpaintop/kis_brush_selection_widget.h
index ce345ba01b..e83b303ede 100644
--- a/plugins/paintops/libpaintop/kis_brush_selection_widget.h
+++ b/plugins/paintops/libpaintop/kis_brush_selection_widget.h
@@ -1,117 +1,119 @@
 /*
  *  Copyright (c) 2008 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2014 Mohit Goyal    <mohit.bits2011@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_BRUSH_SELECTION_WIDGET_H
 #define KIS_BRUSH_SELECTION_WIDGET_H
 
 #include <QWidget>
 
 #include <KoGroupButton.h>
 
 #include <kis_properties_configuration.h>
 #include <kis_brush.h>
 
 #include "kis_precision_option.h"
 #include "ui_wdgbrushchooser.h"
 
 class KisAutoBrushWidget;
 class KisPredefinedBrushChooser;
 class KisTextBrushChooser;
 class KisCustomBrushWidget;
 class KisClipboardBrushWidget;
 class KisBrush;
 
 
 /**
  * Compound widget that collects all the various brush selection widgets.
  */
 class PAINTOP_EXPORT KisBrushSelectionWidget : public QWidget
 {
     Q_OBJECT
 
 public:
     KisBrushSelectionWidget(QWidget * parent = 0);
 
     ~KisBrushSelectionWidget() override;
 
     KisBrushSP brush() const;
 
     void setAutoBrush(bool on);
     void setPredefinedBrushes(bool on);
     void setCustomBrush(bool on);
     void setClipboardBrush(bool on);
     void setTextBrush(bool on);
 
     void setImage(KisImageWSP image);
 
     void setCurrentBrush(KisBrushSP brush);
 
     bool presetIsValid() {
         return m_presetIsValid;
     }
 
     void writeOptionSetting(KisPropertiesConfigurationSP settings) const;
     void readOptionSetting(const KisPropertiesConfigurationSP setting);
 
     void setPrecisionEnabled(bool value);
     bool autoPrecisionEnabled();
 
     void hideOptions(const QStringList &options);
 
 Q_SIGNALS:
 
     void sigBrushChanged();
     void sigPrecisionChanged();
 
 private Q_SLOTS:
     void buttonClicked(int id);
     void precisionChanged(int value);
     void setAutoPrecisionEnabled(int value);
+    void refreshAutoPrecision(qreal value);
     void setSizeToStartFrom(double value);
     void setDeltaValue(double value);
 
 private:
     void setCurrentWidget(QWidget * widget);
     void addChooser(const QString & text, QWidget * widget, int id, KoGroupButton::GroupPosition pos);
+    void updatePrecisionByType(int id);
 
 private:
     enum Type {
         AUTOBRUSH,
         PREDEFINEDBRUSH,
         CUSTOMBRUSH,
         TEXTBRUSH,
         CLIPBOARDBRUSH
     };
 
     bool m_presetIsValid;
 
     Ui_WdgBrushChooser uiWdgBrushChooser;
     QGridLayout * m_layout;
     QWidget * m_currentBrushWidget;
     QHash<int, QWidget*> m_chooserMap;
     QButtonGroup * m_buttonGroup;
     QSize m_mininmumSize;
 
     KisAutoBrushWidget * m_autoBrushWidget;
     KisPredefinedBrushChooser * m_predefinedBrushWidget;
     KisTextBrushChooser * m_textBrushWidget;
 
     KisPrecisionOption m_precisionOption;
 };
 
 #endif
diff --git a/plugins/paintops/libpaintop/kis_dab_cache_base.cpp b/plugins/paintops/libpaintop/kis_dab_cache_base.cpp
index 9fb631abae..5775cae282 100644
--- a/plugins/paintops/libpaintop/kis_dab_cache_base.cpp
+++ b/plugins/paintops/libpaintop/kis_dab_cache_base.cpp
@@ -1,280 +1,286 @@
 /*
  *  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_dab_cache_base.h"
 
 #include <KoColor.h>
 #include "kis_color_source.h"
 #include "kis_paint_device.h"
 #include "kis_brush.h"
 #include <kis_pressure_mirror_option.h>
 #include <kis_pressure_sharpness_option.h>
 #include <kis_texture_option.h>
 #include <kis_precision_option.h>
 #include <kis_fixed_paint_device.h>
 #include <brushengine/kis_paintop.h>
 
 #include <kundo2command.h>
 
 struct PrecisionValues {
     qreal angle;
     qreal sizeFrac;
     qreal subPixel;
     qreal softnessFactor;
 };
 
 const qreal eps = 1e-6;
 static const PrecisionValues precisionLevels[] = {
     {M_PI / 180, 0.05,   1, 0.01},
     {M_PI / 180, 0.01,   1, 0.01},
     {M_PI / 180,    0,   1, 0.01},
     {M_PI / 180,    0, 0.5, 0.01},
     {eps,         0, eps,  eps}
 };
 
 struct KisDabCacheBase::SavedDabParameters {
     KoColor color;
     qreal angle;
     int width;
     int height;
     qreal subPixelX;
     qreal subPixelY;
     qreal softnessFactor;
     int index;
     MirrorProperties mirrorProperties;
 
     bool compare(const SavedDabParameters &rhs, int precisionLevel) const {
         const PrecisionValues &prec = precisionLevels[precisionLevel];
 
         return color == rhs.color &&
                qAbs(angle - rhs.angle) <= prec.angle &&
                qAbs(width - rhs.width) <= (int)(prec.sizeFrac * width) &&
                qAbs(height - rhs.height) <= (int)(prec.sizeFrac * height) &&
                qAbs(subPixelX - rhs.subPixelX) <= prec.subPixel &&
                qAbs(subPixelY - rhs.subPixelY) <= prec.subPixel &&
                qAbs(softnessFactor - rhs.softnessFactor) <= prec.softnessFactor &&
                index == rhs.index &&
                mirrorProperties.horizontalMirror == rhs.mirrorProperties.horizontalMirror &&
                mirrorProperties.verticalMirror == rhs.mirrorProperties.verticalMirror;
     }
 };
 
 struct KisDabCacheBase::Private {
 
     Private()
         : mirrorOption(0),
           precisionOption(0),
           subPixelPrecisionDisabled(false)
     {}
 
     KisPressureMirrorOption *mirrorOption;
     KisPrecisionOption *precisionOption;
     bool subPixelPrecisionDisabled;
 
     SavedDabParameters lastSavedDabParameters;
 
     static qreal positiveFraction(qreal x);
 };
 
 
 
 KisDabCacheBase::KisDabCacheBase()
     : m_d(new Private())
 {
 }
 
 KisDabCacheBase::~KisDabCacheBase()
 {
     delete m_d;
 }
 
 void KisDabCacheBase::setMirrorPostprocessing(KisPressureMirrorOption *option)
 {
     m_d->mirrorOption = option;
 }
 
 void KisDabCacheBase::setPrecisionOption(KisPrecisionOption *option)
 {
     m_d->precisionOption = option;
 }
 
 void KisDabCacheBase::disableSubpixelPrecision()
 {
     m_d->subPixelPrecisionDisabled = true;
 }
 
 inline KisDabCacheBase::SavedDabParameters
 KisDabCacheBase::getDabParameters(KisBrushSP brush,
                               const KoColor& color,
                               KisDabShape const& shape,
                               const KisPaintInformation& info,
                               double subPixelX, double subPixelY,
                               qreal softnessFactor,
                               MirrorProperties mirrorProperties)
 {
     SavedDabParameters params;
 
     params.color = color;
     params.angle = shape.rotation();
     params.width = brush->maskWidth(shape, subPixelX, subPixelY, info);
     params.height = brush->maskHeight(shape, subPixelX, subPixelY, info);
     params.subPixelX = subPixelX;
     params.subPixelY = subPixelY;
     params.softnessFactor = softnessFactor;
     params.index = brush->brushIndex(info);
     params.mirrorProperties = mirrorProperties;
 
     return params;
 }
 
 bool KisDabCacheBase::needSeparateOriginal(KisTextureProperties *textureOption,
                                            KisPressureSharpnessOption *sharpnessOption) const
 {
     return (textureOption && textureOption->m_enabled) ||
            (sharpnessOption && sharpnessOption->isChecked());
 }
 
 struct KisDabCacheBase::DabPosition {
     DabPosition(const QRect &_rect,
                 const QPointF &_subPixel,
                 qreal _realAngle)
         : rect(_rect),
           subPixel(_subPixel),
           realAngle(_realAngle) {
     }
 
     QRect rect;
     QPointF subPixel;
     qreal realAngle;
 };
 
 qreal KisDabCacheBase::Private::positiveFraction(qreal x) {
     qint32 unused = 0;
     qreal fraction = 0.0;
     KisPaintOp::splitCoordinate(x, &unused, &fraction);
 
     return fraction;
 }
 
 inline
 KisDabCacheBase::DabPosition
 KisDabCacheBase::calculateDabRect(KisBrushSP brush,
                                   const QPointF &cursorPoint,
                                   KisDabShape shape,
                                   const KisPaintInformation& info,
                                   const MirrorProperties &mirrorProperties,
                                   KisPressureSharpnessOption *sharpnessOption)
 {
     qint32 x = 0, y = 0;
     qreal subPixelX = 0.0, subPixelY = 0.0;
 
     if (mirrorProperties.coordinateSystemFlipped) {
         shape = KisDabShape(shape.scale(), shape.ratio(), 2 * M_PI - shape.rotation());
     }
 
     QPointF hotSpot = brush->hotSpot(shape, info);
     QPointF pt = cursorPoint - hotSpot;
 
     if (sharpnessOption) {
         sharpnessOption->apply(info, pt, x, y, subPixelX, subPixelY);
     }
     else {
         KisPaintOp::splitCoordinate(pt.x(), &x, &subPixelX);
         KisPaintOp::splitCoordinate(pt.y(), &y, &subPixelY);
     }
 
     if (m_d->subPixelPrecisionDisabled) {
         subPixelX = 0;
         subPixelY = 0;
     }
 
     if (qIsNaN(subPixelX)) {
         subPixelX = 0;
     }
 
     if (qIsNaN(subPixelY)) {
         subPixelY = 0;
     }
 
     int width = brush->maskWidth(shape, subPixelX, subPixelY, info);
     int height = brush->maskHeight(shape, subPixelX, subPixelY, info);
 
     if (mirrorProperties.horizontalMirror) {
         subPixelX = Private::positiveFraction(-(cursorPoint.x() + hotSpot.x()));
         width = brush->maskWidth(shape, subPixelX, subPixelY, info);
         x = qRound(cursorPoint.x() + subPixelX + hotSpot.x()) - width;
     }
 
     if (mirrorProperties.verticalMirror) {
         subPixelY = Private::positiveFraction(-(cursorPoint.y() + hotSpot.y()));
         height = brush->maskHeight(shape, subPixelX, subPixelY, info);
         y = qRound(cursorPoint.y() + subPixelY + hotSpot.y()) - height;
     }
 
     return DabPosition(QRect(x, y, width, height),
                        QPointF(subPixelX, subPixelY),
                        shape.rotation());
 }
 
 void KisDabCacheBase::fetchDabGenerationInfo(bool hasDabInCache,
                                              KisDabCacheUtils::DabRenderingResources *resources,
                                              const KisDabCacheUtils::DabRequestInfo &request,
                                              KisDabCacheUtils::DabGenerationInfo *di,
                                              bool *shouldUseCache)
 {
     di->info = request.info;
     di->softnessFactor = request.softnessFactor;
 
     if (m_d->mirrorOption) {
         di->mirrorProperties = m_d->mirrorOption->apply(request.info);
     }
 
     DabPosition position = calculateDabRect(resources->brush,
                                             request.cursorPoint,
                                             request.shape,
                                             request.info,
                                             di->mirrorProperties,
                                             resources->sharpnessOption.data());
     di->shape = KisDabShape(request.shape.scale(), request.shape.ratio(), position.realAngle);
     di->dstDabRect = position.rect;
     di->subPixel = position.subPixel;
 
     di->solidColorFill = !resources->colorSource || resources->colorSource->isUniformColor();
     di->paintColor = resources->colorSource && resources->colorSource->isUniformColor() ?
                 resources->colorSource->uniformColor() : request.color;
 
     SavedDabParameters newParams = getDabParameters(resources->brush,
                                                     di->paintColor,
                                                     di->shape,
                                                     di->info,
                                                     di->subPixel.x(),
                                                     di->subPixel.y(),
                                                     di->softnessFactor,
                                                     di->mirrorProperties);
 
-    const int precisionLevel = m_d->precisionOption ? m_d->precisionOption->precisionLevel() - 1 : 3;
+    int precisionLevel = 3;
+    if (m_d->precisionOption) {
+        if (m_d->precisionOption->autoPrecisionEnabled()) {
+            m_d->precisionOption->setAutoPrecision(resources->brush->userEffectiveSize());
+        }
+        precisionLevel = m_d->precisionOption->precisionLevel() - 1;
+    }
     *shouldUseCache = hasDabInCache && di->solidColorFill &&
             newParams.compare(m_d->lastSavedDabParameters, precisionLevel);
 
     if (!*shouldUseCache) {
         m_d->lastSavedDabParameters = newParams;
     }
 
     di->needsPostprocessing = needSeparateOriginal(resources->textureOption.data(), resources->sharpnessOption.data());
 }
 
diff --git a/plugins/paintops/libpaintop/kis_text_brush_chooser.cpp b/plugins/paintops/libpaintop/kis_text_brush_chooser.cpp
index 03e40df7c5..0c830a9702 100644
--- a/plugins/paintops/libpaintop/kis_text_brush_chooser.cpp
+++ b/plugins/paintops/libpaintop/kis_text_brush_chooser.cpp
@@ -1,104 +1,105 @@
 /*
  *  Copyright (c) 2004 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 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.
  */
 
 #include "kis_text_brush_chooser.h"
 
 #include <QSpinBox>
 #include <QCheckBox>
 #include <QLabel>
 #include <QPixmap>
 #include <QLineEdit>
 #include <QString>
 #include <QFontDialog>
 
 #define showSlider(input) input->setRange(input->minimum(), input->maximum())
 
 KisTextBrushChooser::KisTextBrushChooser(QWidget *parent, const char* name, const QString& caption)
     : QWidget(parent)
     , m_textBrush(new KisTextBrush())
 {
     setObjectName(name);
     setupUi(this);
 
     setWindowTitle(caption);
     connect((QObject*)lineEdit, SIGNAL(textChanged(QString)), this, SLOT(rebuildTextBrush()));
     connect((QObject*)bnFont, SIGNAL(clicked()), this, SLOT(getFont()));
     connect(pipeModeChbox, SIGNAL(toggled(bool)), this, SLOT(rebuildTextBrush()));
     m_font = font();
     inputSpacing->setRange(0.0, 10, 2);
     inputSpacing->setValue(0.1);
     rebuildTextBrush();
     connect(inputSpacing, SIGNAL(valueChanged(qreal)), this, SLOT(rebuildTextBrush()));
 }
 
 
 void KisTextBrushChooser::getFont()
 {
     bool ok = false;
     QFont f = QFontDialog::getFont(&ok, m_font);
     if (ok) {
         m_font = f;
         rebuildTextBrush();
     }
 }
 
 void KisTextBrushChooser::rebuildTextBrush()
 {
     pipeModeChbox->setEnabled(!lineEdit->text().isEmpty());
     if (lineEdit->text().isEmpty()) {
         pipeModeChbox->setChecked(false);
     }
 
     lblFont->setText(QString(m_font.family() + ", %1").arg(m_font.pointSize()));
     lblFont->setFont(m_font);
 
     KisTextBrush* textBrush = dynamic_cast<KisTextBrush*>(m_textBrush.data());
     textBrush->setFont(m_font);
     textBrush->setText(lineEdit->text());
     textBrush->setPipeMode(pipeModeChbox->isChecked());
     textBrush->setSpacing(inputSpacing->value());
     textBrush->updateBrush();
 
     emit sigBrushChanged();
+    emit fontSizeChanged(m_font.pointSize());
 }
 
 void KisTextBrushChooser::setBrush(KisBrushSP brush)
 {
     bool b;
 
     m_textBrush = brush;
 
     KisTextBrush *textBrush = dynamic_cast<KisTextBrush*>(brush.data());
 
     m_font = textBrush->font();
 
     // we want to set all the gui widgets without triggering any signals
     // (and thus calling rebuildTextBrush)
     b = lineEdit->blockSignals(true);
     lineEdit->setText(textBrush->text());
     lineEdit->blockSignals(b);
 
     b = pipeModeChbox->blockSignals(true);
     pipeModeChbox->setChecked(textBrush->pipeMode());
     pipeModeChbox->blockSignals(b);
 
     // trigger rebuildTextBrush on the last change
     inputSpacing->setValue(textBrush->spacing());
 }
 
diff --git a/plugins/paintops/libpaintop/kis_text_brush_chooser.h b/plugins/paintops/libpaintop/kis_text_brush_chooser.h
index e12141bc22..7b47b3c59c 100644
--- a/plugins/paintops/libpaintop/kis_text_brush_chooser.h
+++ b/plugins/paintops/libpaintop/kis_text_brush_chooser.h
@@ -1,52 +1,53 @@
 /*
   *  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_TEXT_BRUSH_CHOOSER_H_
 #define _KIS_TEXT_BRUSH_CHOOSER_H_
 
 #include "ui_wdgtextbrush.h"
 
 #include <kis_text_brush.h>
 
 class KisTextBrushChooser : public QWidget, public Ui::KisWdgTextBrush
 {
     Q_OBJECT
 
 public:
 
     KisTextBrushChooser(QWidget *parent, const char* name, const QString& caption);
 
     KisBrushSP brush() {
         return m_textBrush;
     }
 
     void setBrush(KisBrushSP brush);
 
 private Q_SLOTS:
     void rebuildTextBrush();
     void getFont();
 
 Q_SIGNALS:
     void sigBrushChanged();
+    void fontSizeChanged(qreal);
 
 private:
     KisBrushSP m_textBrush;
     QFont m_font;
 };
 
 #endif