kis_tool_freehand.cc

Go to the documentation of this file.

/*
 *  kis_tool_freehand.cc - part of Krita
 *
 *  SPDX-FileCopyrightText: 2003-2007 Boudewijn Rempt <boud@valdyas.org>
 *  SPDX-FileCopyrightText: 2004 Bart Coppens <kde@bartcoppens.be>
 *  SPDX-FileCopyrightText: 2007, 2008, 2010 Cyrille Berger <cberger@cberger.net>
 *  SPDX-FileCopyrightText: 2009 Lukáš Tvrdý <lukast.dev@gmail.com>
 *  SPDX-FileCopyrightText: 2026 Ayanami Kaine <personal@ayanamikaine.com>
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 */
 
#include "kis_tool_freehand.h"
#include <optional>
#include <QPainter>
#include <QRect>
#include <QThreadPool>
#include <QApplication>
#include <QScreen>
 
#include <Eigen/Core>
 
#include <kis_icon.h>
#include <KoPointerEvent.h>
#include <KoViewConverter.h>
#include <KoCanvasController.h>
 
//pop up palette
#include <kis_canvas_resource_provider.h>
 
// Krita/image
#include <kis_layer.h>
#include <kis_paint_layer.h>
#include <kis_painter.h>
#include <brushengine/kis_paintop.h>
#include <kis_selection.h>
#include <brushengine/kis_paintop_preset.h>
#include <brushengine/KisOptimizedBrushOutline.h>
 
 
// Krita/ui
#include "kis_abstract_perspective_grid.h"
#include "kis_config.h"
#include "kis_config_notifier.h"
#include "kis_image_config.h"
#include "canvas/kis_canvas2.h"
#include "kis_cursor.h"
#include <KisViewManager.h>
#include <kis_painting_assistants_decoration.h>
#include "kis_painting_information_builder.h"
#include "kis_tool_freehand_helper.h"
#include "strokes/freehand_stroke.h"
#include "kis_tool_utils.h"
 
using namespace std::placeholders; // For _1 placeholder
 
namespace {
bool snapsTemporaryStraightRuler(const KisTemporaryPaintConstraint &constraint,
                                 Qt::KeyboardModifiers modifiers)
{
    return constraint.interactionMode() == KisTemporaryPaintConstraint::InteractionMode::SnapToAngle ||
        modifiers.testFlag(Qt::ShiftModifier);
}
 
bool hasLockedValidTemporaryStraightRuler(const std::optional<KisTemporaryPaintConstraint> &constraint)
{
    return constraint && constraint->isLocked() && constraint->hasValidLine();
}
}
 
 
KisToolFreehand::KisToolFreehand(KoCanvasBase * canvas, const QCursor & cursor,
                                 const KUndo2MagicString &transactionText, bool useSavedSmoothing)
    : KisToolPaint(canvas, cursor),
      m_brushResizeCompressor(200, std::bind(&KisToolFreehand::slotDoResizeBrush, this, _1))
{
 
    setSupportOutline(true);
    updateMaskSyntheticEventsFromTouch();
    connect(KisConfigNotifier::instance(), SIGNAL(touchPaintingChanged()),
            SLOT(updateMaskSyntheticEventsFromTouch()));
 
    m_infoBuilder = new KisToolFreehandPaintingInformationBuilder(this);
    m_helper = new KisToolFreehandHelper(m_infoBuilder, canvas->resourceManager(), transactionText,
                                         new KisSmoothingOptions(useSavedSmoothing));
 
    connect(m_helper, SIGNAL(requestExplicitUpdateOutline()), SLOT(explicitUpdateOutline()));
 
    connect(qobject_cast<KisCanvas2*>(canvas)->viewManager(), SIGNAL(brushOutlineToggled()), SLOT(explicitUpdateOutline()));
 
    KisCanvasResourceProvider *provider = qobject_cast<KisCanvas2*>(canvas)->viewManager()->canvasResourceProvider();
 
    connect(provider, SIGNAL(sigEffectiveCompositeOpChanged()), SLOT(explicitUpdateOutline()));
    connect(provider, SIGNAL(sigEffectiveCompositeOpChanged()), SLOT(resetCursorStyle()));
    connect(provider, SIGNAL(sigPaintOpPresetChanged(KisPaintOpPresetSP)), SLOT(explicitUpdateOutline()));
    connect(provider, SIGNAL(sigPaintOpPresetChanged(KisPaintOpPresetSP)), SLOT(resetCursorStyle()));
 
    KisPaintingAssistantsDecorationSP decoration = qobject_cast<KisCanvas2*>(canvas)->paintingAssistantsDecoration();
    connect(decoration.data(), SIGNAL(temporaryConstraintAvailabilityChanged()), SLOT(explicitUpdateOutline()));
    connect(decoration.data(), SIGNAL(temporaryConstraintAvailabilityChanged()), SLOT(resetCursorStyle()));
}
 
KisToolFreehand::~KisToolFreehand()
{
    delete m_helper;
    delete m_infoBuilder;
}
 
void KisToolFreehand::mouseMoveEvent(KoPointerEvent *event)
{
    m_helper->cursorMoved(convertToPixelCoord(event));
 
    if (temporaryStraightRulerActive()) {
        if (mode() == HOVER_MODE) {
            updateTemporaryStraightRulerPreview(event->point, event->modifiers());
            requestUpdateOutline(temporaryStraightRulerOutlinePosition(event->point), event);
        }
    } else {
        KisToolPaint::mouseMoveEvent(event);
    }
}
 
KisSmoothingOptionsSP KisToolFreehand::smoothingOptions() const
{
    return m_helper->smoothingOptions();
}
 
void KisToolFreehand::resetCursorStyle()
{
    if (temporaryStraightRulerActive()) {
        useCursor(KisCursor::loadWithSize("cursor-cross-full.svg", 31, 31));
        return;
    }
 
    KisConfig cfg(true);
 
    bool useSeparateEraserCursor = cfg.separateEraserCursor() && isEraser();
 
    switch (useSeparateEraserCursor ? cfg.eraserCursorStyle() : cfg.newCursorStyle()) {
    case CURSOR_STYLE_NO_CURSOR:
        useCursor(KisCursor::blankCursor());
        break;
    case CURSOR_STYLE_POINTER:
        useCursor(KisCursor::arrowCursor());
        break;
    case CURSOR_STYLE_SMALL_ROUND:
        useCursor(KisCursor::roundCursor());
        break;
    case CURSOR_STYLE_CROSSHAIR:
        useCursor(KisCursor::crossCursor());
        break;
    case CURSOR_STYLE_TRIANGLE_RIGHTHANDED:
        useCursor(KisCursor::triangleRightHandedCursor());
        break;
    case CURSOR_STYLE_TRIANGLE_LEFTHANDED:
        useCursor(KisCursor::triangleLeftHandedCursor());
        break;
    case CURSOR_STYLE_BLACK_PIXEL:
        useCursor(KisCursor::pixelBlackCursor());
        break;
    case CURSOR_STYLE_WHITE_PIXEL:
        useCursor(KisCursor::pixelWhiteCursor());
        break;
    case CURSOR_STYLE_ERASER:
        useCursor(KisCursor::eraserCursor());
        break;
    case CURSOR_STYLE_TOOLICON:
    default:
        KisToolPaint::resetCursorStyle();
        break;
    }
}
 
KisPaintingInformationBuilder* KisToolFreehand::paintingInformationBuilder() const
{
    return m_infoBuilder;
}
 
void KisToolFreehand::resetHelper(KisToolFreehandHelper *helper)
{
    delete m_helper;
    m_helper = helper;
}
 
bool KisToolFreehand::supportsPaintingAssistants() const
{
    return true;
}
 
int KisToolFreehand::flags() const
{
    return KisTool::FLAG_USES_CUSTOM_COMPOSITEOP|KisTool::FLAG_USES_CUSTOM_PRESET
           |KisTool::FLAG_USES_CUSTOM_SIZE;
}
 
void KisToolFreehand::activate(const QSet<KoShape*> &shapes)
{
    KisToolPaint::activate(shapes);
}
 
void KisToolFreehand::deactivate()
{
    if (mode() == PAINT_MODE) {
        endStroke();
        setMode(KisTool::HOVER_MODE);
    }
    if (KisCanvas2 *canvas2 = dynamic_cast<KisCanvas2*>(canvas())) {
        if (canvas2->paintingAssistantsDecoration()) {
            canvas2->paintingAssistantsDecoration()->setTemporaryConstraint(std::nullopt);
        }
    }
    KisToolPaint::deactivate();
}
 
bool KisToolFreehand::temporaryStraightRulerActive() const
{
    KisCanvas2 *canvas2 = dynamic_cast<KisCanvas2*>(canvas());
    return canvas2 &&
        canvas2->paintingAssistantsDecoration() &&
        canvas2->paintingAssistantsDecoration()->temporaryConstraint().has_value();
}
 
QPointF KisToolFreehand::temporaryStraightRulerOutlinePosition(const QPointF &documentPoint)
{
    KisCanvas2 *canvas2 = dynamic_cast<KisCanvas2*>(canvas());
    if (!canvas2 ||
        !canvas2->paintingAssistantsDecoration() ||
        !hasLockedValidTemporaryStraightRuler(canvas2->paintingAssistantsDecoration()->temporaryConstraint())) {
 
        return documentPoint;
    }
 
    return adjustPosition(documentPoint, documentPoint);
}
 
void KisToolFreehand::updateTemporaryStraightRulerPreview(const QPointF &documentPoint, Qt::KeyboardModifiers modifiers)
{
    KisCanvas2 *canvas2 = dynamic_cast<KisCanvas2*>(canvas());
    if (!canvas2 || !canvas2->paintingAssistantsDecoration()) {
        return;
    }
 
    std::optional<KisTemporaryPaintConstraint> constraint =
        canvas2->paintingAssistantsDecoration()->temporaryConstraint();
 
    if (!constraint || constraint->isLocked()) {
        return;
    }
 
    if (!constraint->hasLine()) {
        constraint->beginLine(documentPoint);
    } else {
        constraint->updateLine(documentPoint, snapsTemporaryStraightRuler(*constraint, modifiers));
    }
 
    canvas2->paintingAssistantsDecoration()->setTemporaryConstraint(constraint);
}
 
void KisToolFreehand::lockTemporaryStraightRuler(const QPointF &documentPoint, Qt::KeyboardModifiers modifiers)
{
    KisCanvas2 *canvas2 = dynamic_cast<KisCanvas2*>(canvas());
    if (!canvas2 || !canvas2->paintingAssistantsDecoration()) {
        return;
    }
 
    std::optional<KisTemporaryPaintConstraint> constraint =
        canvas2->paintingAssistantsDecoration()->temporaryConstraint();
 
    if (!constraint) {
        return;
    }
 
    if (!constraint->hasLine()) {
        return;
    }
 
    if (!constraint->isLocked()) {
        constraint->updateLine(documentPoint, snapsTemporaryStraightRuler(*constraint, modifiers));
    }
 
    if (constraint->hasValidLine()) {
        constraint->setLocked(true);
    } else {
        const KisTemporaryPaintConstraint::InteractionMode interactionMode = constraint->interactionMode();
        constraint = KisTemporaryPaintConstraint();
        constraint->setInteractionMode(interactionMode);
    }
 
    canvas2->paintingAssistantsDecoration()->setTemporaryConstraint(constraint);
}
 
void KisToolFreehand::initStroke(KoPointerEvent *event)
{
    m_helper->initPaint(event,
                        convertToPixelCoord(event),
                        image(),
                        currentNode(),
                        image().data());
}
 
void KisToolFreehand::doStroke(KoPointerEvent *event)
{
    m_helper->paintEvent(event);
}
 
void KisToolFreehand::endStroke()
{
    m_helper->endPaint();
    bool paintOpIgnoredEvent = currentPaintOpPreset()->settings()->mouseReleaseEvent();
    Q_UNUSED(paintOpIgnoredEvent);
}
 
bool KisToolFreehand::primaryActionSupportsHiResEvents() const
{
    return true;
}
 
void KisToolFreehand::beginPrimaryAction(KoPointerEvent *event)
{
    // FIXME: workaround for the Duplicate Op
    trySampleByPaintOp(event, SampleFgImage);
 
    lockTemporaryStraightRuler(event->point, event->modifiers());
 
    requestUpdateOutline(temporaryStraightRulerOutlinePosition(event->point), event);
 
    NodePaintAbility paintability = nodePaintAbility();
    // XXX: move this to KisTool and make it work properly for clone layers: for clone layers, the shape paint tools don't work either
    if (!nodeEditable() || paintability != PAINT) {
        if (paintability == KisToolPaint::VECTOR || paintability == KisToolPaint::CLONE){
            KisCanvas2 * kiscanvas = static_cast<KisCanvas2*>(canvas());
            QString message = i18n("The brush tool cannot paint on this layer.  Please select a paint layer or mask.");
            kiscanvas->viewManager()->showFloatingMessage(message, koIcon("object-locked"));
        }
        else if (paintability == MYPAINTBRUSH_UNPAINTABLE) {
            KisCanvas2 * kiscanvas = static_cast<KisCanvas2*>(canvas());
            QString message = i18n("The MyPaint Brush Engine is not available for this colorspace");
            kiscanvas->viewManager()->showFloatingMessage(message, koIcon("object-locked"));
        }
        event->ignore();
 
        return;
    }
 
    KIS_SAFE_ASSERT_RECOVER_RETURN(!m_helper->isRunning());
 
    setMode(KisTool::PAINT_MODE);
 
    KisCanvas2 *canvas2 = dynamic_cast<KisCanvas2 *>(canvas());
    if (canvas2) {
        canvas2->viewManager()->disableControls();
    }
 
    initStroke(event);
}
 
void KisToolFreehand::continuePrimaryAction(KoPointerEvent *event)
{
    CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
 
    requestUpdateOutline(temporaryStraightRulerOutlinePosition(event->point), event);
 
    doStroke(event);
}
 
void KisToolFreehand::endPrimaryAction(KoPointerEvent *event)
{
    Q_UNUSED(event);
    CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
 
    endStroke();
 
    if (m_assistant && static_cast<KisCanvas2*>(canvas())->paintingAssistantsDecoration()) {
        static_cast<KisCanvas2*>(canvas())->paintingAssistantsDecoration()->endStroke();
    }
 
    KisCanvas2 *canvas2 = dynamic_cast<KisCanvas2 *>(canvas());
    if (canvas2) {
        canvas2->viewManager()->enableControls();
    }
 
    setMode(KisTool::HOVER_MODE);
}
 
bool KisToolFreehand::trySampleByPaintOp(KoPointerEvent *event, AlternateAction action)
{
    if (action != SampleFgNode && action != SampleFgImage) return false;
 
    QPointF pos = adjustPosition(event->point, event->point);
    qreal perspective = calculatePerspective(pos);
    if (!currentPaintOpPreset()) {
        return false;
    }
    KisPaintInformation info(convertToPixelCoord(event->point),
                             m_infoBuilder->pressureToCurve(event->pressure()),
                             event->xTilt(), event->yTilt(),
                             event->rotation(),
                             event->tangentialPressure(),
                             perspective, 0, 0);
    info.setRandomSource(new KisRandomSource());
    info.setPerStrokeRandomSource(new KisPerStrokeRandomSource());
 
    bool paintOpIgnoredEvent = currentPaintOpPreset()->settings()->mousePressEvent(info,
                                                                                   event->modifiers(),
                                                                                   currentNode());
    // DuplicateOP during the sampling of new source point (origin)
    // is the only paintop that returns "false" here
    return !paintOpIgnoredEvent;
}
 
void KisToolFreehand::activateAlternateAction(AlternateAction action)
{
    if (action != ChangeSize && action != ChangeSizeSnap) {
        KisToolPaint::activateAlternateAction(action);
        return;
    }
 
    useCursor(KisCursor::blankCursor());
    setOutlineVisible(true);
}
 
void KisToolFreehand::deactivateAlternateAction(AlternateAction action)
{
    if (action != ChangeSize && action != ChangeSizeSnap) {
        KisToolPaint::deactivateAlternateAction(action);
        return;
    }
 
    resetCursorStyle();
    setOutlineVisible(false);
}
 
void KisToolFreehand::beginAlternateAction(KoPointerEvent *event, AlternateAction action)
{
    if (trySampleByPaintOp(event, action)) {
        m_paintopBasedSamplingInAction = true;
        return;
    }
 
    if (action != ChangeSize && action != ChangeSizeSnap) {
        KisToolPaint::beginAlternateAction(event, action);
        return;
    }
 
    setMode(GESTURE_MODE);
    m_initialGestureDocPoint = event->point;
    m_initialGestureGlobalPoint = event->globalPos();
 
    m_lastDocumentPoint = event->point;
    m_lastPaintOpSize = currentPaintOpPreset()->settings()->paintOpSize();
 
    m_beginAlternateActionEvent = event->deepCopyEvent();
    requestUpdateOutline(m_initialGestureDocPoint, &m_beginAlternateActionEvent->event);
}
 
void KisToolFreehand::continueAlternateAction(KoPointerEvent *event, AlternateAction action)
{
    if (trySampleByPaintOp(event, action) || m_paintopBasedSamplingInAction) return;
 
    if (action != ChangeSize && action != ChangeSizeSnap) {
        KisToolPaint::continueAlternateAction(event, action);
        return;
    }
 
    QPointF lastWidgetPosition = convertDocumentToWidget(m_lastDocumentPoint);
    QPointF actualWidgetPosition = convertDocumentToWidget(event->point);
 
    QPointF offset = actualWidgetPosition - lastWidgetPosition;
 
    KisCanvas2 *canvas2 = dynamic_cast<KisCanvas2 *>(canvas());
    KIS_SAFE_ASSERT_RECOVER_RETURN(canvas2);
    QRect screenRect = QGuiApplication::primaryScreen()->availableVirtualGeometry();
 
    qreal scaleX = 0;
    qreal scaleY = 0;
    canvas2->coordinatesConverter()->imageScale(&scaleX, &scaleY);
 
    const qreal maxBrushSize = KisImageConfig(true).maxBrushSize();
    const qreal effectiveMaxDragSize = 0.5 * screenRect.width();
    const qreal effectiveMaxBrushSize = qMin(maxBrushSize, effectiveMaxDragSize / scaleX);
 
    const qreal scaleCoeff = effectiveMaxBrushSize / effectiveMaxDragSize;
    const qreal sizeDiff = scaleCoeff * offset.x() ;
 
    if (qAbs(sizeDiff) > 0.01) {
        KisPaintOpSettingsSP settings = currentPaintOpPreset()->settings();
 
        qreal newSize = m_lastPaintOpSize + sizeDiff;
 
        if (action == ChangeSizeSnap) {
            newSize = qMax(qRound(newSize), 1);
        }
 
        newSize = qBound(0.01, newSize, maxBrushSize);
 
        settings->setPaintOpSize(newSize);
 
        requestUpdateOutline(
            m_initialGestureDocPoint,
            m_beginAlternateActionEvent.has_value() ? &m_beginAlternateActionEvent->event : nullptr);
        //m_brushResizeCompressor.start(newSize);
 
        m_lastDocumentPoint = event->point;
        m_lastPaintOpSize = newSize;
    }
}
 
void KisToolFreehand::endAlternateAction(KoPointerEvent *event, AlternateAction action)
{
    if (trySampleByPaintOp(event, action) || m_paintopBasedSamplingInAction) {
        m_paintopBasedSamplingInAction = false;
        return;
    }
 
    if (action != ChangeSize && action != ChangeSizeSnap) {
        KisToolPaint::endAlternateAction(event, action);
        return;
    }
 
    KisToolUtils::setCursorPos(m_initialGestureGlobalPoint);
    requestUpdateOutline(m_initialGestureDocPoint, 0);
 
    setMode(HOVER_MODE);
 
    m_beginAlternateActionEvent.reset();
}
 
bool KisToolFreehand::wantsAutoScroll() const
{
    return false;
}
 
void KisToolFreehand::setAssistant(bool assistant)
{
    m_assistant = assistant;
}
 
void KisToolFreehand::setOnlyOneAssistantSnap(bool assistant)
{
    m_only_one_assistant = assistant;
}
 
void KisToolFreehand::setSnapEraser(bool assistant)
{
    m_eraser_snapping = assistant;
}
 
void KisToolFreehand::slotDoResizeBrush(qreal newSize)
{
    KisPaintOpSettingsSP settings = currentPaintOpPreset()->settings();
 
    settings->setPaintOpSize(newSize);
    requestUpdateOutline(m_initialGestureDocPoint, 0);
 
}
 
QPointF KisToolFreehand::adjustPosition(const QPointF& point, const QPointF& strokeBegin)
{
    KisCanvas2* c = static_cast<KisCanvas2*>(canvas());
    if (!c || !c->paintingAssistantsDecoration()) {
        return point;
    }
 
    if (hasLockedValidTemporaryStraightRuler(c->paintingAssistantsDecoration()->temporaryConstraint())) {
        c->paintingAssistantsDecoration()->setEraserSnap(m_eraser_snapping);
        QPointF ap = c->paintingAssistantsDecoration()->adjustPosition(point, strokeBegin);
        c->paintingAssistantsDecoration()->setAdjustedBrushPosition(ap);
        return ap;
    }
 
    if (m_assistant) {
        c->paintingAssistantsDecoration()->setOnlyOneAssistantSnap(m_only_one_assistant);
        c->paintingAssistantsDecoration()->setEraserSnap(m_eraser_snapping);
        QPointF ap = c->paintingAssistantsDecoration()->adjustPosition(point, strokeBegin);
        QPointF fp = (1.0 - m_magnetism) * point + m_magnetism * ap;
        // Report the final position back to the assistant so the guides
        // can follow the brush
        c->paintingAssistantsDecoration()->setAdjustedBrushPosition(fp);
        return fp;
    }
    return point;
}
 
qreal KisToolFreehand::calculatePerspective(const QPointF &documentPoint)
{
    qreal perspective = 1.0;
    Q_FOREACH (const KisPaintingAssistantSP assistant, static_cast<KisCanvas2*>(canvas())->paintingAssistantsDecoration()->assistants()) {
        QPointer<KisAbstractPerspectiveGrid> grid = dynamic_cast<KisAbstractPerspectiveGrid*>(assistant.data());
        if (grid && grid->isActive() && grid->contains(documentPoint)) {
            perspective = grid->distance(documentPoint);
            break;
        }
    }
    return perspective;
}
 
void KisToolFreehand::updateMaskSyntheticEventsFromTouch()
{
    setMaskSyntheticEvents(KisConfig(true).disableTouchOnCanvas());
}
 
void KisToolFreehand::explicitUpdateOutline()
{
    requestUpdateOutline(m_outlineDocPoint, 0);
}
 
KisOptimizedBrushOutline KisToolFreehand::getOutlinePath(const QPointF &documentPos,
                                             const KoPointerEvent *event,
                                             KisPaintOpSettings::OutlineMode outlineMode)
{
    if (temporaryStraightRulerActive()) {
        return KisOptimizedBrushOutline();
    }
 
    if (currentPaintOpPreset())
        return m_helper->paintOpOutline(convertToPixelCoord(documentPos),
                                        event,
                                        currentPaintOpPreset()->settings(),
                                        outlineMode);
    else
        return KisOptimizedBrushOutline();
}