#include "fullcolorbrushtool.h"

// TnzTools includes

#include "tools/tool.h"

#include "tools/cursors.h"

#include "tools/toolutils.h"

#include "tools/toolhandle.h"

#include "tools/tooloptions.h"

#include "mypainttoonzbrush.h"

// TnzQt includes

#include "toonzqt/dvdialog.h"

// TnzLib includes

#include "toonz/tpalettehandle.h"

#include "toonz/txsheethandle.h"

#include "toonz/txshlevelhandle.h"

#include "toonz/tobjecthandle.h"

#include "toonz/tframehandle.h"

#include "toonz/ttileset.h"

#include "toonz/ttilesaver.h"

#include "toonz/strokegenerator.h"

#include "toonz/tstageobject.h"

#include "toonz/palettecontroller.h"

#include "toonz/mypaintbrushstyle.h"

#include "toonz/preferences.h"

// TnzCore includes

#include "tgl.h"

#include "tproperty.h"

#include "trasterimage.h"

#include "tenv.h"

#include "tpalette.h"

#include "trop.h"

#include "tstream.h"

#include "tstroke.h"

#include "timagecache.h"

#include "tpixelutils.h"

// Qt includes

#include <qcoreapplication>  // Qt translation support</qcoreapplication>

//----------------------------------------------------------------------------------

TEnv::IntVar FullcolorBrushMinSize("FullcolorBrushMinSize", 1);

TEnv::IntVar FullcolorBrushMaxSize("FullcolorBrushMaxSize", 5);

TEnv::IntVar FullcolorPressureSensitivity("FullcolorPressureSensitivity", 1);

TEnv::DoubleVar FullcolorBrushHardness("FullcolorBrushHardness", 100);

TEnv::DoubleVar FullcolorMinOpacity("FullcolorMinOpacity", 100);

TEnv::DoubleVar FullcolorMaxOpacity("FullcolorMaxOpacity", 100);

TEnv::DoubleVar FullcolorModifierSize("FullcolorModifierSize", 0);

TEnv::DoubleVar FullcolorModifierOpacity("FullcolorModifierOpacity", 100);

TEnv::IntVar FullcolorModifierEraser("FullcolorModifierEraser", 0);

TEnv::IntVar FullcolorModifierLockAlpha("FullcolorModifierLockAlpha", 0);

TEnv::IntVar FullcolorAssistants("FullcolorAssistants", 0);

TEnv::StringVar FullcolorBrushPreset("FullcolorBrushPreset", "<custom>");</custom>

//----------------------------------------------------------------------------------

#define CUSTOM_WSTR L"<custom>"</custom>

//----------------------------------------------------------------------------------

namespace {

class FullColorBrushUndo final : public ToolUtils::TFullColorRasterUndo {

  TPoint m_offset;

  QString m_id;

public:

  FullColorBrushUndo(TTileSetFullColor *tileSet, TXshSimpleLevel *level,

                     const TFrameId &frameId, bool isFrameCreated,

                     const TRasterP &ras, const TPoint &offset)

      : ToolUtils::TFullColorRasterUndo(tileSet, level, frameId, isFrameCreated,

                                        false, 0)

      , m_offset(offset) {

    static int counter = 0;

    m_id = QString("FullColorBrushUndo") + QString::number(counter++);

    TImageCache::instance()->add(m_id.toStdString(), TRasterImageP(ras));

  }

  ~FullColorBrushUndo() { TImageCache::instance()->remove(m_id); }

  void redo() const override {

    insertLevelAndFrameIfNeeded();

    TRasterImageP image = getImage();

    TRasterP ras        = image->getRaster();

    TRasterImageP srcImg =

        TImageCache::instance()->get(m_id.toStdString(), false);

    ras->copy(srcImg->getRaster(), m_offset);

    TTool::getApplication()->getCurrentXsheet()->notifyXsheetChanged();

    notifyImageChanged();

  }

  int getSize() const override {

    return sizeof(*this) + ToolUtils::TFullColorRasterUndo::getSize();

  }

  QString getToolName() override { return QString("Raster Brush Tool"); }

  int getHistoryType() override { return HistoryType::BrushTool; }

};

}  // namespace

//************************************************************************

//    FullColor Brush Tool implementation

//************************************************************************

FullColorBrushTool::FullColorBrushTool(std::string name)

    : TTool(name)

    , m_thickness("Size", 1, 1000, 1, 5, false)

    , m_pressure("Pressure", true)

    , m_opacity("Opacity", 0, 100, 100, 100, true)

    , m_hardness("Hardness:", 0, 100, 100)

    , m_modifierSize("ModifierSize", -3, 3, 0, true)

    , m_modifierOpacity("ModifierOpacity", 0, 100, 100, true)

    , m_modifierEraser("ModifierEraser", false)

    , m_modifierLockAlpha("Lock Alpha", false)

    , m_assistants("Assistants", true)

    , m_preset("Preset:")

    , m_enabledPressure(false)

    , m_minCursorThick(0)

    , m_maxCursorThick(0)

    , m_tileSet(0)

    , m_tileSaver(0)

    , m_notifier(0)

    , m_presetsLoaded(false)

    , m_firstTime(true)

    , m_started(false) {

  bind(TTool::RasterImage | TTool::EmptyTarget);

  m_thickness.setNonLinearSlider();

  m_prop.bind(m_thickness);

  m_prop.bind(m_hardness);

  m_prop.bind(m_opacity);

  m_prop.bind(m_modifierSize);

  m_prop.bind(m_modifierOpacity);

  m_prop.bind(m_modifierEraser);

  m_prop.bind(m_modifierLockAlpha);

  m_prop.bind(m_pressure);

  m_prop.bind(m_assistants);

  m_prop.bind(m_preset);

  m_inputmanager.setHandler(this);

#ifndef NDEBUG

  m_modifierTest = new TModifierTest(5, 40);

#endif

  m_modifierLine         = new TModifierLine();

  m_modifierTangents     = new TModifierTangents();

  m_modifierAssistants   = new TModifierAssistants();

  m_modifierSegmentation = new TModifierSegmentation();

  m_inputmanager.addModifier(

      TInputModifierP(m_modifierAssistants.getPointer()));

  m_thickness.setNonLinearSlider();

  m_preset.setId("BrushPreset");

  m_modifierEraser.setId("RasterEraser");

  m_modifierLockAlpha.setId("LockAlpha");

  m_pressure.setId("PressureSensitivity");

}

//---------------------------------------------------------------------------------------------------

ToolOptionsBox *FullColorBrushTool::createOptionsBox() {

  TPaletteHandle *currPalette =

      TTool::getApplication()->getPaletteController()->getCurrentLevelPalette();

  ToolHandle *currTool = TTool::getApplication()->getCurrentTool();

  return new BrushToolOptionsBox(0, this, currPalette, currTool);

}

//---------------------------------------------------------------------------------------------------

void FullColorBrushTool::onCanvasSizeChanged() {

  onDeactivate();

  setWorkAndBackupImages();

}

//---------------------------------------------------------------------------------------------------

void FullColorBrushTool::onColorStyleChanged() {

  getApplication()->getCurrentTool()->notifyToolChanged();

}

//---------------------------------------------------------------------------------------------------

void FullColorBrushTool::updateTranslation() {

  m_thickness.setQStringName(tr("Size"));

  m_pressure.setQStringName(tr("Pressure"));

  m_opacity.setQStringName(tr("Opacity"));

  m_hardness.setQStringName(tr("Hardness:"));

  m_preset.setQStringName(tr("Preset:"));

  m_modifierSize.setQStringName(tr("Size"));

  m_modifierOpacity.setQStringName(tr("Opacity"));

  m_modifierEraser.setQStringName(tr("Eraser"));

  m_modifierLockAlpha.setQStringName(tr("Lock Alpha"));

  m_assistants.setQStringName(tr("Assistants"));

}

//---------------------------------------------------------------------------------------------------

void FullColorBrushTool::onActivate() {

  if (!m_notifier) m_notifier = new FullColorBrushToolNotifier(this);

  m_notifier->onActivate();

  updateCurrentStyle();

  if (m_firstTime) {

    m_firstTime = false;

    std::wstring wpreset =

        QString::fromStdString(FullcolorBrushPreset.getValue()).toStdWString();

    if (wpreset != CUSTOM_WSTR) {

      initPresets();

      if (!m_preset.isValue(wpreset)) wpreset = CUSTOM_WSTR;

      m_preset.setValue(wpreset);

      FullcolorBrushPreset = m_preset.getValueAsString();

      loadPreset();

    } else

      loadLastBrush();

  }

  setWorkAndBackupImages();

  onColorStyleChanged();

}

//--------------------------------------------------------------------------------------------------

void FullColorBrushTool::onDeactivate() {

  if (m_notifier) m_notifier->onDeactivate();

  m_inputmanager.finishTracks();

  m_workRaster = TRaster32P();

  m_backUpRas  = TRasterP();

}

//--------------------------------------------------------------------------------------------------

void FullColorBrushTool::updateWorkAndBackupRasters(const TRect &rect) {

  if (rect.isEmpty()) return;

  TRasterImageP ri = TImageP(getImage(false, 1));

  if (!ri) return;

  TRasterP ras = ri->getRaster();

  const int denominator = 8;

  TRect enlargedRect    = rect + m_lastRect;

  int dx                = (enlargedRect.getLx() - 1) / denominator + 1;

  int dy                = (enlargedRect.getLy() - 1) / denominator + 1;

  if (m_lastRect.isEmpty()) {

    enlargedRect.x0 -= dx;

    enlargedRect.y0 -= dy;

    enlargedRect.x1 += dx;

    enlargedRect.y1 += dy;

    TRect _rect = enlargedRect * ras->getBounds();

    if (_rect.isEmpty()) return;

    m_workRaster->extract(_rect)->copy(ras->extract(_rect));

    m_backUpRas->extract(_rect)->copy(ras->extract(_rect));

  } else {

    if (enlargedRect.x0 < m_lastRect.x0) enlargedRect.x0 -= dx;

    if (enlargedRect.y0 < m_lastRect.y0) enlargedRect.y0 -= dy;

    if (enlargedRect.x1 > m_lastRect.x1) enlargedRect.x1 += dx;

    if (enlargedRect.y1 > m_lastRect.y1) enlargedRect.y1 += dy;

    TRect _rect = enlargedRect * ras->getBounds();

    if (_rect.isEmpty()) return;

    TRect _lastRect    = m_lastRect * ras->getBounds();

    QList<trect> rects = ToolUtils::splitRect(_rect, _lastRect);</trect>

    for (int i = 0; i < rects.size(); i++) {

      m_workRaster->extract(rects[i])->copy(ras->extract(rects[i]));

      m_backUpRas->extract(rects[i])->copy(ras->extract(rects[i]));

    }

  }

  m_lastRect = enlargedRect;

}

//--------------------------------------------------------------------------------------------------

bool FullColorBrushTool::askRead(const TRect &rect) { return askWrite(rect); }

//--------------------------------------------------------------------------------------------------

bool FullColorBrushTool::askWrite(const TRect &rect) {

  if (rect.isEmpty()) return true;

  m_strokeRect += rect;

  m_strokeSegmentRect += rect;

  updateWorkAndBackupRasters(rect);

  m_tileSaver->save(rect);

  return true;

}

//--------------------------------------------------------------------------------------------------

bool FullColorBrushTool::preLeftButtonDown() {

  m_modifierAssistants->drawOnly = !FullcolorAssistants;

  m_inputmanager.drawPreview     = false;  //! m_modifierAssistants->drawOnly;

  m_inputmanager.clearModifiers();

  m_inputmanager.addModifier(TInputModifierP(m_modifierTangents.getPointer()));

  m_inputmanager.addModifier(

      TInputModifierP(m_modifierAssistants.getPointer()));

  m_inputmanager.addModifier(

      TInputModifierP(m_modifierSegmentation.getPointer()));

#ifndef NDEBUG

  m_inputmanager.addModifier(TInputModifierP(m_modifierTest.getPointer()));

#endif

  touchImage();

  if (m_isFrameCreated) {

    setWorkAndBackupImages();

    // When the xsheet frame is selected, whole viewer will be updated from

    // SceneViewer::onXsheetChanged() on adding a new frame.

    // We need to take care of a case when the level frame is selected.

    if (m_application->getCurrentFrame()->isEditingLevel()) invalidate();

  }

  return true;

}

//---------------------------------------------------------------------------------------------------

void FullColorBrushTool::handleMouseEvent(MouseEventType type,

                                          const TPointD &pos,

                                          const TMouseEvent &e) {

  TTimerTicks t = TToolTimer::ticks();

  bool alt      = e.getModifiersMask() & TMouseEvent::ALT_KEY;

  bool shift    = e.getModifiersMask() & TMouseEvent::SHIFT_KEY;

  bool control  = e.getModifiersMask() & TMouseEvent::CTRL_KEY;

  if (shift && type == ME_DOWN && e.button() == Qt::LeftButton && !m_started) {

    m_modifierAssistants->drawOnly = true;

    m_inputmanager.clearModifiers();

    m_inputmanager.addModifier(TInputModifierP(m_modifierLine.getPointer()));

    m_inputmanager.addModifier(

        TInputModifierP(m_modifierAssistants.getPointer()));

    m_inputmanager.addModifier(

        TInputModifierP(m_modifierSegmentation.getPointer()));

    m_inputmanager.drawPreview = true;

  }

  if (alt != m_inputmanager.state.isKeyPressed(TKey::alt))

    m_inputmanager.keyEvent(alt, TKey::alt, t, nullptr);

  if (shift != m_inputmanager.state.isKeyPressed(TKey::shift))

    m_inputmanager.keyEvent(shift, TKey::shift, t, nullptr);

  if (control != m_inputmanager.state.isKeyPressed(TKey::control))

    m_inputmanager.keyEvent(control, TKey::control, t, nullptr);

  if (type == ME_MOVE) {

    THoverList hovers(1, pos);

    m_inputmanager.hoverEvent(hovers);

  } else {

    m_inputmanager.trackEvent(e.isTablet(), 0, pos,

                              e.isTablet() ? &e.m_pressure : nullptr, nullptr,

                              type == ME_UP, t);

    m_inputmanager.processTracks();

  }

}

//---------------------------------------------------------------------------------------------------

void FullColorBrushTool::leftButtonDown(const TPointD &pos,

                                        const TMouseEvent &e) {

  handleMouseEvent(ME_DOWN, pos, e);

}

void FullColorBrushTool::leftButtonDrag(const TPointD &pos,

                                        const TMouseEvent &e) {

  handleMouseEvent(ME_DRAG, pos, e);

}

void FullColorBrushTool::leftButtonUp(const TPointD &pos,

                                      const TMouseEvent &e) {

  handleMouseEvent(ME_UP, pos, e);

}

void FullColorBrushTool::mouseMove(const TPointD &pos, const TMouseEvent &e) {

  handleMouseEvent(ME_MOVE, pos, e);

}

//---------------------------------------------------------------------------------------------------------------

void FullColorBrushTool::inputMouseMove(const TPointD &position,

                                        const TInputState &state) {

  struct Locals {

    FullColorBrushTool *m_this;

    void notify(TProperty &prop) {

      m_this->onPropertyChanged(prop.getName());

      TTool::getApplication()->getCurrentTool()->notifyToolChanged();

    }

    void addMinMax(TIntPairProperty &prop, double add) {

      const TIntPairProperty::Range &range = prop.getRange();

      TIntPairProperty::Value value = prop.getValue();

      value.second =

          tcrop<double>(value.second + add, range.first, range.second);</double>

      value.first = tcrop<double>(value.first + add, range.first, range.second);</double>

      prop.setValue(value);

      notify(prop);

    }

    void addMinMaxSeparate(TIntPairProperty &prop, double min, double max) {

      if (min == 0.0 && max == 0.0) return;

      const TIntPairProperty::Range &range = prop.getRange();

      TIntPairProperty::Value value = prop.getValue();

      value.first += min;

      value.second += max;

      if (value.first > value.second) value.first = value.second;

      value.first = tcrop<double>(value.first, range.first, range.second);</double>

      value.second = tcrop<double>(value.second, range.first, range.second);</double>

      prop.setValue(value);

      notify(prop);

    }

    void add(TDoubleProperty &prop, double x) {

      if (x == 0.0) return;

      const TDoubleProperty::Range &range = prop.getRange();

      double value =

          tcrop<double>(prop.getValue() + x, range.first, range.second);</double>

      prop.setValue(value);

      notify(prop);

    }

  } locals = {this};

  if (state.isKeyPressed(TKey::control) && state.isKeyPressed(TKey::alt)) {

    const TPointD &diff = position - m_mousePos;

    if (getBrushStyle()) {

      locals.add(m_modifierSize, 0.01 * diff.x);

    } else {

      locals.addMinMaxSeparate(m_thickness, int(diff.x / 2), int(diff.y / 2));

    }

  } else {

    m_brushPos = position;

  }

  m_mousePos = position;

  invalidate();

}

//-------------------------------------------------------------------------------------------------------------

void FullColorBrushTool::inputSetBusy(bool busy) {

  if (m_started == busy) return;

  if (busy) {

    // begin paint

    TRasterImageP ri = (TRasterImageP)getImage(true);

    if (!ri) ri = (TRasterImageP)touchImage();

    if (!ri) return;

    TRasterP ras = ri->getRaster();

    if (!(m_workRaster && m_backUpRas)) setWorkAndBackupImages();

    m_workRaster->lock();

    m_tileSet   = new TTileSetFullColor(ras->getSize());

    m_tileSaver = new TTileSaverFullColor(ras, m_tileSet);

    // update color here since the current style might be switched

    // with numpad shortcut keys

    updateCurrentStyle();

  } else {

    // end paint

    if (TRasterImageP ri = (TRasterImageP)getImage(true)) {

      TRasterP ras = ri->getRaster();

      m_lastRect.empty();

      m_workRaster->unlock();

      if (m_tileSet->getTileCount() > 0) {

        delete m_tileSaver;

        TTool::Application *app   = TTool::getApplication();

        TXshLevel *level          = app->getCurrentLevel()->getLevel();

        TXshSimpleLevelP simLevel = level->getSimpleLevel();

        TFrameId frameId          = getCurrentFid();

        TRasterP subras           = ras->extract(m_strokeRect)->clone();

        TUndoManager::manager()->add(new FullColorBrushUndo(

            m_tileSet, simLevel.getPointer(), frameId, m_isFrameCreated, subras,

            m_strokeRect.getP00()));

      }

      notifyImageChanged();

      m_strokeRect.empty();

    }

  }

  m_started = busy;

}

//-------------------------------------------------------------------------------------------------------------

void FullColorBrushTool::inputPaintTrackPoint(const TTrackPoint &point,

                                              const TTrack &track,

                                              bool firstTrack) {

  // get raster

  if (!m_started || !getViewer()) return;

  TRasterImageP ri = (TRasterImageP)getImage(true);

  if (!ri) return;

  TRasterP ras      = ri->getRaster();

  TPointD rasCenter = ras->getCenterD();

  // init brush

  TrackHandler *handler;

  if (track.size() == track.pointsAdded && !track.toolHandler && m_workRaster) {

    mypaint::Brush mypaintBrush;

    applyToonzBrushSettings(mypaintBrush);

    handler = new TrackHandler(m_workRaster, *this, mypaintBrush);

    handler->brush.beginStroke();

    track.toolHandler = handler;

  }

  handler = dynamic_cast<trackhandler *="">(track.toolHandler.getPointer());</trackhandler>

  if (!handler) return;

  // paint stroke

  m_strokeSegmentRect.empty();

  handler->brush.strokeTo(point.position + rasCenter,

                          m_enabledPressure ? point.pressure : 0.5, point.tilt,

                          point.time - track.previous().time);

  if (track.pointsAdded == 1 && track.finished()) handler->brush.endStroke();

  // update affected area

  TRect updateRect = m_strokeSegmentRect * ras->getBounds();

  if (!updateRect.isEmpty())

    ras->extract(updateRect)->copy(m_workRaster->extract(updateRect));

  TRectD invalidateRect = convert(m_strokeSegmentRect) - rasCenter;

  if (firstTrack) {

    TPointD thickOffset(m_maxCursorThick * 0.5, m_maxCursorThick * 0.5);

    invalidateRect +=

        TRectD(m_brushPos - thickOffset, m_brushPos + thickOffset);

    invalidateRect +=

        TRectD(point.position - thickOffset, point.position + thickOffset);

    m_brushPos = m_mousePos = point.position;

  }

  invalidate(invalidateRect.enlarge(2.0));

}

//-------------------------------------------------------------------------------------------------------------

void FullColorBrushTool::inputInvalidateRect(const TRectD &bounds) {

  invalidate(bounds);

}

//-------------------------------------------------------------------------------------------------------------

void FullColorBrushTool::draw() {

  if (TRasterImageP ri = TRasterImageP(getImage(false))) {

    // If toggled off, don't draw brush outline

    if (!Preferences::instance()->isCursorOutlineEnabled()) return;

    TRasterP ras = ri->getRaster();

    double alpha       = 1.0;

    double alphaRadius = 3.0;

    double pixelSize   = sqrt(tglGetPixelSize2());

    // circles with lesser radius looks more bold

    // to avoid these effect we'll reduce alpha for small radiuses

    double minX     = m_minCursorThick / (alphaRadius * pixelSize);

    double maxX     = m_maxCursorThick / (alphaRadius * pixelSize);

    double minAlpha = alpha * (1.0 - 1.0 / (1.0 + minX));

    double maxAlpha = alpha * (1.0 - 1.0 / (1.0 + maxX));

    glPushAttrib(GL_ALL_ATTRIB_BITS);

    tglEnableBlending();

    tglEnableLineSmooth(true, 0.5);

    if (m_minCursorThick < m_maxCursorThick - pixelSize) {

      glColor4d(1.0, 1.0, 1.0, minAlpha);

      tglDrawCircle(m_brushPos, (m_minCursorThick + 1) * 0.5 - pixelSize);

      glColor4d(0.0, 0.0, 0.0, minAlpha);

      tglDrawCircle(m_brushPos, (m_minCursorThick + 1) * 0.5);

    }

    glColor4d(1.0, 1.0, 1.0, maxAlpha);

    tglDrawCircle(m_brushPos, (m_maxCursorThick + 1) * 0.5 - pixelSize);

    glColor4d(0.0, 0.0, 0.0, maxAlpha);

    tglDrawCircle(m_brushPos, (m_maxCursorThick + 1) * 0.5);

    glPopAttrib();

  }

  m_inputmanager.draw();

}

//--------------------------------------------------------------------------------------------------------------

void FullColorBrushTool::onEnter() { updateCurrentStyle(); }

//----------------------------------------------------------------------------------------------------------

void FullColorBrushTool::onLeave() {

  m_minCursorThick = 0;

  m_maxCursorThick = 0;

}

//----------------------------------------------------------------------------------------------------------

TPropertyGroup *FullColorBrushTool::getProperties(int targetType) {

  if (!m_presetsLoaded) initPresets();

  return &m_prop;

}

//----------------------------------------------------------------------------------------------------------

void FullColorBrushTool::onImageChanged() { setWorkAndBackupImages(); }

//----------------------------------------------------------------------------------------------------------

void FullColorBrushTool::setWorkAndBackupImages() {

  TRasterImageP ri = (TRasterImageP)getImage(false, 1);

  if (!ri) return;

  TRasterP ras   = ri->getRaster();

  TDimension dim = ras->getSize();

  if (!m_workRaster || m_workRaster->getLx() != dim.lx ||

      m_workRaster->getLy() != dim.ly)

    m_workRaster = TRaster32P(dim);

  if (!m_backUpRas || m_backUpRas->getLx() != dim.lx ||

      m_backUpRas->getLy() != dim.ly ||

      m_backUpRas->getPixelSize() != ras->getPixelSize())

    m_backUpRas = ras->create(dim.lx, dim.ly);

  m_strokeRect.empty();

  m_lastRect.empty();

}

//------------------------------------------------------------------

bool FullColorBrushTool::onPropertyChanged(std::string propertyName) {

  if (m_propertyUpdating) return true;

  updateCurrentStyle();

  if (propertyName == "Preset:") {

    if (m_preset.getValue() != CUSTOM_WSTR)

      loadPreset();

    else  // Chose <custom>, go back to last saved brush settings</custom>

      loadLastBrush();

    FullcolorBrushPreset = m_preset.getValueAsString();

    m_propertyUpdating   = true;

    getApplication()->getCurrentTool()->notifyToolChanged();

    m_propertyUpdating = false;

    return true;

  }

  FullcolorBrushMinSize        = m_thickness.getValue().first;

  FullcolorBrushMaxSize        = m_thickness.getValue().second;

  FullcolorPressureSensitivity = m_pressure.getValue();

  FullcolorBrushHardness       = m_hardness.getValue();

  FullcolorMinOpacity          = m_opacity.getValue().first;

  FullcolorMaxOpacity          = m_opacity.getValue().second;

  FullcolorModifierSize        = m_modifierSize.getValue();

  FullcolorModifierOpacity     = m_modifierOpacity.getValue();

  FullcolorModifierEraser      = m_modifierEraser.getValue() ? 1 : 0;

  FullcolorModifierLockAlpha   = m_modifierLockAlpha.getValue() ? 1 : 0;

  FullcolorAssistants          = m_assistants.getValue() ? 1 : 0;

  if (m_preset.getValue() != CUSTOM_WSTR) {

    m_preset.setValue(CUSTOM_WSTR);

    FullcolorBrushPreset = m_preset.getValueAsString();

    m_propertyUpdating   = true;

    getApplication()->getCurrentTool()->notifyToolChanged();

    m_propertyUpdating = false;

  }

  return true;

}

//------------------------------------------------------------------

void FullColorBrushTool::initPresets() {

  if (!m_presetsLoaded) {

    // If necessary, load the presets from file

    m_presetsLoaded = true;

    m_presetsManager.load(TEnv::getConfigDir() + "brush_raster.txt");

  }

  // Rebuild the presets property entries

  const std::set<brushdata> &presets = m_presetsManager.presets();</brushdata>

  m_preset.deleteAllValues();

  m_preset.addValue(CUSTOM_WSTR);

  m_preset.setItemUIName(CUSTOM_WSTR, tr("<custom>"));</custom>

  std::set<brushdata>::const_iterator it, end = presets.end();</brushdata>

  for (it = presets.begin(); it != end; ++it) m_preset.addValue(it->m_name);

}

//----------------------------------------------------------------------------------------------------------

void FullColorBrushTool::loadPreset() {

  const std::set<brushdata> &presets = m_presetsManager.presets();</brushdata>

  std::set<brushdata>::const_iterator it;</brushdata>

  it = presets.find(BrushData(m_preset.getValue()));

  if (it == presets.end()) return;

  const BrushData &preset = *it;

  try  // Don't bother with RangeErrors

  {

    m_thickness.setValue(TIntPairProperty::Value(std::max((int)preset.m_min, 1),

                                                 (int)preset.m_max));

    m_hardness.setValue(preset.m_hardness, true);

    m_opacity.setValue(

        TDoublePairProperty::Value(preset.m_opacityMin, preset.m_opacityMax));

    m_pressure.setValue(preset.m_pressure);

    m_modifierSize.setValue(preset.m_modifierSize);

    m_modifierOpacity.setValue(preset.m_modifierOpacity);

    m_modifierEraser.setValue(preset.m_modifierEraser);

    m_modifierLockAlpha.setValue(preset.m_modifierLockAlpha);

    m_assistants.setValue(preset.m_assistants);

  } catch (...) {

  }

}

//------------------------------------------------------------------

void FullColorBrushTool::addPreset(QString name) {

  // Build the preset

  BrushData preset(name.toStdWString());

  preset.m_min               = m_thickness.getValue().first;

  preset.m_max               = m_thickness.getValue().second;

  preset.m_hardness          = m_hardness.getValue();

  preset.m_opacityMin        = m_opacity.getValue().first;

  preset.m_opacityMax        = m_opacity.getValue().second;

  preset.m_pressure          = m_pressure.getValue();

  preset.m_modifierSize      = m_modifierSize.getValue();

  preset.m_modifierOpacity   = m_modifierOpacity.getValue();

  preset.m_modifierEraser    = m_modifierEraser.getValue();

  preset.m_modifierLockAlpha = m_modifierLockAlpha.getValue();

  preset.m_assistants        = m_assistants.getValue();

  // Pass the preset to the manager

  m_presetsManager.addPreset(preset);

  // Reinitialize the associated preset enum

  initPresets();

  // Set the value to the specified one

  m_preset.setValue(preset.m_name);

  FullcolorBrushPreset = m_preset.getValueAsString();

}

//------------------------------------------------------------------

void FullColorBrushTool::removePreset() {

  std::wstring name(m_preset.getValue());

  if (name == CUSTOM_WSTR) return;

  m_presetsManager.removePreset(name);

  initPresets();

  // No parameter change, and set the preset value to custom

  m_preset.setValue(CUSTOM_WSTR);

  FullcolorBrushPreset = m_preset.getValueAsString();

}

//------------------------------------------------------------------

void FullColorBrushTool::loadLastBrush() {

  m_thickness.setValue(

      TIntPairProperty::Value(FullcolorBrushMinSize, FullcolorBrushMaxSize));

  m_pressure.setValue(FullcolorPressureSensitivity ? 1 : 0);

  m_opacity.setValue(

      TDoublePairProperty::Value(FullcolorMinOpacity, FullcolorMaxOpacity));

  m_hardness.setValue(FullcolorBrushHardness);

  m_modifierSize.setValue(FullcolorModifierSize);

  m_modifierOpacity.setValue(FullcolorModifierOpacity);

  m_modifierEraser.setValue(FullcolorModifierEraser ? true : false);

  m_modifierLockAlpha.setValue(FullcolorModifierLockAlpha ? true : false);

  m_assistants.setValue(FullcolorAssistants ? true : false);

}

//------------------------------------------------------------------

void FullColorBrushTool::updateCurrentStyle() {

  m_currentColor = TPixel32::Black;

  if (TTool::Application *app = getApplication()) {

    if (app->getCurrentObject()->isSpline()) {

      m_currentColor = TPixel32::Red;

    } else if (TPalette *plt = app->getCurrentPalette()->getPalette()) {

      int style               = app->getCurrentLevelStyleIndex();

      TColorStyle *colorStyle = plt->getStyle(style);

      m_currentColor          = colorStyle->getMainColor();

    }

  }

  int prevMinCursorThick = m_minCursorThick;

  int prevMaxCursorThick = m_maxCursorThick;

  m_enabledPressure = m_pressure.getValue();

  if (TMyPaintBrushStyle *brushStyle = getBrushStyle()) {

    double radiusLog = brushStyle->getBrush().getBaseValue(

                           MYPAINT_BRUSH_SETTING_RADIUS_LOGARITHMIC) +

                       m_modifierSize.getValue() * log(2.0);

    double radius    = exp(radiusLog);

    m_minCursorThick = m_maxCursorThick = (int)round(2.0 * radius);

  } else {

    m_minCursorThick = std::max(m_thickness.getValue().first, 1);

    m_maxCursorThick =

        std::max(m_thickness.getValue().second, m_minCursorThick);

    if (!m_enabledPressure) m_minCursorThick = m_maxCursorThick;