#include <kis_selection_tool_helper.h>

Public Member Functions
void	addSelectionShape (KoShape *shape, SelectionAction action=SELECTION_DEFAULT)

void	addSelectionShapes (QList< KoShape * > shapes, SelectionAction action=SELECTION_DEFAULT)

bool	canShortcutToDeselect (const QRect &rect, SelectionAction action)

bool	canShortcutToNoop (const QRect &rect, SelectionAction action)

	KisSelectionToolHelper (KisCanvas2 *canvas, const KUndo2MagicString &name)

void	selectPixelSelection (KisPixelSelectionSP selection, SelectionAction action)

void	selectPixelSelection (KisProcessingApplicator &applicator, KisPixelSelectionSP selection, SelectionAction action)

bool	tryDeselectCurrentSelection (const QRectF selectionViewRect, SelectionAction action)

SelectionMode	tryOverrideSelectionMode (KisSelectionSP activeSelection, SelectionMode currentMode, SelectionAction currentAction) const

virtual	~KisSelectionToolHelper ()

Static Public Member Functions
static QMenu *	getSelectionContextMenu (KisCanvas2 *canvas)

Private Attributes
QPointer< KisCanvas2 >	m_canvas

KisImageSP	m_image

KisLayerSP	m_layer

KUndo2MagicString	m_name

Detailed Description

XXX: Doc!

Definition at line 24 of file kis_selection_tool_helper.h.

Constructor & Destructor Documentation

◆ KisSelectionToolHelper()

KisSelectionToolHelper::KisSelectionToolHelper	(	KisCanvas2 *	canvas,
		const KUndo2MagicString &	name )

Definition at line 40 of file kis_selection_tool_helper.cpp.

        : m_canvas(canvas)
        , m_name(name)
{
    m_image = m_canvas->viewManager()->image();
}

References m_canvas, and m_image.

◆ ~KisSelectionToolHelper()

KisSelectionToolHelper::~KisSelectionToolHelper ( )

virtual

Definition at line 47 of file kis_selection_tool_helper.cpp.

48{

49}

Member Function Documentation

◆ addSelectionShape()

void KisSelectionToolHelper::addSelectionShape	(	KoShape *	shape,
		SelectionAction	action = SELECTION_DEFAULT )

Definition at line 162 of file kis_selection_tool_helper.cpp.

{
    QList<KoShape*> shapes;
    shapes.append(shape);
    addSelectionShapes(shapes, action);
}

References addSelectionShapes().

◆ addSelectionShapes()

void KisSelectionToolHelper::addSelectionShapes	(	QList< KoShape * >	shapes,
		SelectionAction	action = SELECTION_DEFAULT )

Mark the shapes that they belong to a shape selection

Definition at line 169 of file kis_selection_tool_helper.cpp.

{
    KisView *view = m_canvas->imageView();
 
    if (view->image()->wrapAroundModePermitted()) {
        view->showFloatingMessage(
            i18n("Shape selection does not fully "
                 "support wraparound mode. Please "
                 "use pixel selection instead"),
                 KisIconUtils::loadIcon("selection-info"));
    }
 
    KisProcessingApplicator applicator(view->image(),
                                       0 /* we need no automatic updates */,
                                       KisProcessingApplicator::NONE,
                                       KisImageSignalVector(),
                                       m_name);
 
    applicator.applyCommand(new LazyInitGlobalSelection(view));
 
    struct ClearPixelSelection : public KisTransactionBasedCommand {
        ClearPixelSelection(KisView *view) : m_view(view) {}
        KisView *m_view;
 
        KUndo2Command* paint() override {
 
            KisPixelSelectionSP pixelSelection = m_view->selection()->pixelSelection();
            KIS_ASSERT_RECOVER(pixelSelection) { return 0; }
 
            KisSelectionTransaction transaction(pixelSelection);
            pixelSelection->clear();
            return transaction.endAndTake();
        }
    };
 
    if (action == SELECTION_REPLACE || action == SELECTION_DEFAULT) {
        applicator.applyCommand(new ClearPixelSelection(view));
    }
 
    struct AddSelectionShape : public KisTransactionBasedCommand {
        AddSelectionShape(KisView *view, QList<KoShape*> shapes, SelectionAction action)
            : m_view(view),
              m_shapes(shapes),
              m_action(action) {}
 
        KisView *m_view;
        QList<KoShape*> m_shapes;
        SelectionAction m_action;
 
        KUndo2Command* paint() override {
            KUndo2Command *resultCommand = 0;
 
            KisSelectionSP selection = m_view->selection();
            if (selection) {
                KisShapeSelection * shapeSelection = static_cast<KisShapeSelection*>(selection->shapeSelection());
 
                if (shapeSelection ||
                        m_action == SELECTION_SUBTRACT) {
 
                    QPainterPath path1;
                    QList<KoShape*> existingShapes;
 
                    if (shapeSelection) {
                        existingShapes = shapeSelection->shapes();
 
                        path1.setFillRule(Qt::WindingFill);
                        Q_FOREACH(KoShape *shape, existingShapes) {
                            path1 += shape->absoluteTransformation().map(shape->outline());
                        }
                    } else if (m_action == SELECTION_SUBTRACT) {
                        KisImageSP image = m_view->image();
                        path1.addRect(m_view->viewConverter()->imageRectInDocumentPixels());
                    }
 
                    QPainterPath path2;
                    path2.setFillRule(Qt::WindingFill);
                    Q_FOREACH(KoShape *shape, m_shapes) {
                        path2 += shape->absoluteTransformation().map(shape->outline());
                    }
 
                    const QTransform booleanWorkaroundTransform =
                        KritaUtils::pathShapeBooleanSpaceWorkaround(m_view->image());
 
                    path1 = booleanWorkaroundTransform.map(path1);
                    path2 = booleanWorkaroundTransform.map(path2);
 
                    QPainterPath path = path2;
 
                    switch (m_action) {
                    case SELECTION_DEFAULT:
                    case SELECTION_REPLACE:
                        path = path2;
                        break;
 
                    case SELECTION_INTERSECT:
                        path = path1 & path2;
                        path = KritaUtils::tryCloseTornSubpathsAfterIntersection(path);
                        break;
                    case SELECTION_ADD:
                        path = path1 | path2;
                        break;
 
                    case SELECTION_SUBTRACT:
                        path = path1 - path2;
                        break;
                    case SELECTION_SYMMETRICDIFFERENCE:
                        path = (path1 | path2) - (path1 & path2);
                        break;
                    }
 
                    path = booleanWorkaroundTransform.inverted().map(path);
 
                    KoShape *newShape = KoPathShape::createShapeFromPainterPath(path);
                    newShape->setUserData(new KisShapeSelectionMarker);
 
                    KUndo2Command *parentCommand = new KUndo2Command();
 
                    if (!existingShapes.isEmpty()) {
                        m_view->canvasBase()->shapeController()->removeShapes(existingShapes, parentCommand);
                    }
                    m_view->canvasBase()->shapeController()->addShape(newShape, 0, parentCommand);
 
                    if (path.isEmpty()) {
                        KisCommandUtils::CompositeCommand *cmd = new KisCommandUtils::CompositeCommand();
                        cmd->addCommand(parentCommand);
                        cmd->addCommand(new KisDeselectActiveSelectionCommand(m_view->selection(), m_view->image()));
                        parentCommand = cmd;
                    }
 
                    resultCommand = parentCommand;
                } else if (m_action == SELECTION_INTERSECT) {
                    // just do nothing if there is nothing to intersect with
                    return nullptr;
                }
            }
 
            if (!resultCommand) {
                Q_FOREACH(KoShape *shape, m_shapes) {
                    if(!shape->userData()) {
                        shape->setUserData(new KisShapeSelectionMarker);
                    }
                }
 
                resultCommand = m_view->canvasBase()->shapeController()->addShapesDirect(m_shapes, 0);
            }
            return resultCommand;
        }
    };
 
    applicator.applyCommand(
        new KisGuiContextCommand(new AddSelectionShape(view, shapes, action), view));
    applicator.end();
}

References KoShape::absoluteTransformation(), KisCommandUtils::CompositeCommand::addCommand(), KisProcessingApplicator::applyCommand(), KisView::canvasBase(), KisPixelSelection::clear(), KoPathShape::createShapeFromPainterPath(), KisProcessingApplicator::end(), KisTransaction::endAndTake(), KisView::image(), KisCoordinatesConverter::imageRectInDocumentPixels(), KIS_ASSERT_RECOVER, KisIconUtils::loadIcon(), m_canvas, m_name, KisProcessingApplicator::NONE, KoShape::outline(), KritaUtils::pathShapeBooleanSpaceWorkaround(), KisSelection::pixelSelection, KisView::selection(), SELECTION_ADD, SELECTION_DEFAULT, SELECTION_INTERSECT, SELECTION_REPLACE, SELECTION_SUBTRACT, SELECTION_SYMMETRICDIFFERENCE, KoShape::setUserData(), KoCanvasBase::shapeController, KoShapeContainer::shapes(), KisSelection::shapeSelection, KisView::showFloatingMessage, KritaUtils::tryCloseTornSubpathsAfterIntersection(), KoShape::userData(), KisView::viewConverter, and KisImage::wrapAroundModePermitted().

◆ canShortcutToDeselect()

bool KisSelectionToolHelper::canShortcutToDeselect	(	const QRect &	rect,
		SelectionAction	action )

Definition at line 326 of file kis_selection_tool_helper.cpp.

{
    return rect.isEmpty() && (action == SELECTION_INTERSECT || action == SELECTION_REPLACE);
}

References SELECTION_INTERSECT, and SELECTION_REPLACE.

◆ canShortcutToNoop()

bool KisSelectionToolHelper::canShortcutToNoop	(	const QRect &	rect,
		SelectionAction	action )

Definition at line 331 of file kis_selection_tool_helper.cpp.

{
    return rect.isEmpty() && action == SELECTION_ADD;
}

References SELECTION_ADD.

◆ getSelectionContextMenu()

QMenu * KisSelectionToolHelper::getSelectionContextMenu ( KisCanvas2 * canvas )

static

Definition at line 352 of file kis_selection_tool_helper.cpp.

{
    QMenu *m_contextMenu = new QMenu();
 
    KisKActionCollection *actionCollection = canvas->viewManager()->actionCollection();
 
    m_contextMenu->addSection(i18n("Selection Actions"));
    m_contextMenu->addSeparator();
 
    m_contextMenu->addAction(actionCollection->action("select_all"));
    m_contextMenu->addAction(actionCollection->action("deselect"));
    m_contextMenu->addAction(actionCollection->action("reselect"));
    m_contextMenu->addAction(actionCollection->action("invert_selection"));
 
 
    m_contextMenu->addSeparator();
 
    m_contextMenu->addAction(actionCollection->action("cut_selection_to_new_layer"));
    m_contextMenu->addAction(actionCollection->action("copy_selection_to_new_layer"));
 
    m_contextMenu->addSeparator();
 
    KisSelectionSP selection = canvas->viewManager()->selection();
    if (selection && canvas->viewManager()->selectionEditable()) {
        m_contextMenu->addAction(actionCollection->action("edit_selection"));
 
        if (!selection->hasShapeSelection()) {
            m_contextMenu->addAction(actionCollection->action("convert_to_vector_selection"));
        } else {
            m_contextMenu->addAction(actionCollection->action("convert_to_raster_selection"));
        }
 
        m_contextMenu->addAction(actionCollection->action("convert_selection_to_shape"));
 
        QMenu *transformMenu = m_contextMenu->addMenu(i18n("Transform"));
        transformMenu->addAction(actionCollection->action("KisToolTransform"));
        transformMenu->addAction(actionCollection->action("selectionscale"));
        transformMenu->addAction(actionCollection->action("growselection"));
        transformMenu->addAction(actionCollection->action("shrinkselection"));
        transformMenu->addAction(actionCollection->action("borderselection"));
        transformMenu->addAction(actionCollection->action("smoothselection"));
        transformMenu->addAction(actionCollection->action("featherselection"));
        transformMenu->addAction(actionCollection->action("stroke_selection"));
 
        m_contextMenu->addSeparator();
    }
 
    m_contextMenu->addAction(actionCollection->action("resizeimagetoselection"));
 
    m_contextMenu->addSeparator();
 
    m_contextMenu->addAction(actionCollection->action("toggle_display_selection"));
    m_contextMenu->addAction(actionCollection->action("show-global-selection-mask"));
 
    return m_contextMenu;
}

References KisKActionCollection::action(), KisViewManager::actionCollection(), KisSelection::hasShapeSelection(), KisViewManager::selection(), KisViewManager::selectionEditable(), and KisCanvas2::viewManager().

◆ selectPixelSelection() [1/2]

void KisSelectionToolHelper::selectPixelSelection	(	KisPixelSelectionSP	selection,
		SelectionAction	action )

Definition at line 62 of file kis_selection_tool_helper.cpp.

{
    KisView* view = m_canvas->imageView();
    KisProcessingApplicator applicator(view->image(),
                                       0 /* we need no automatic updates */,
                                       KisProcessingApplicator::SUPPORTS_WRAPAROUND_MODE,
                                       KisImageSignalVector(),
                                       m_name);
 
    selectPixelSelection(applicator, selection, action);
 
    applicator.end();
 
}

References KisProcessingApplicator::end(), KisView::image(), m_canvas, m_name, selectPixelSelection(), and KisProcessingApplicator::SUPPORTS_WRAPAROUND_MODE.

◆ selectPixelSelection() [2/2]

void KisSelectionToolHelper::selectPixelSelection	(	KisProcessingApplicator &	applicator,
		KisPixelSelectionSP	selection,
		SelectionAction	action )

Definition at line 77 of file kis_selection_tool_helper.cpp.

{
 
    KisView* view = m_canvas->imageView();
 
    QPointer<KisCanvas2> canvas = m_canvas;
 
    applicator.applyCommand(new LazyInitGlobalSelection(view), KisStrokeJobData::SEQUENTIAL);
 
    struct ApplyToPixelSelection : public KisTransactionBasedCommand {
        ApplyToPixelSelection(KisView *view,
                              KisPixelSelectionSP selection,
                              SelectionAction action,
                              QPointer<KisCanvas2> canvas) : m_view(view),
                                                            m_selection(selection),
                                                            m_action(action),
                                                            m_canvas(canvas) {}
        KisView *m_view;
        KisPixelSelectionSP m_selection;
        SelectionAction m_action;
        QPointer<KisCanvas2> m_canvas;
 
        KUndo2Command* paint() override {
 
            KUndo2Command *savedCommand = 0;
            if (!m_selection->selectedExactRect().isEmpty()) {
 
                KisSelectionSP selection = m_view->selection();
                KIS_SAFE_ASSERT_RECOVER(selection) { return 0; }
 
                KisPixelSelectionSP pixelSelection = selection->pixelSelection();
                KIS_SAFE_ASSERT_RECOVER(pixelSelection) { return 0; }
 
                bool hasSelection = !pixelSelection->isEmpty();
 
                KisSelectionTransaction transaction(pixelSelection);
 
                if (!hasSelection && m_action == SELECTION_SYMMETRICDIFFERENCE) {
                    m_action = SELECTION_REPLACE;
                }
 
                if (!hasSelection && m_action == SELECTION_SUBTRACT) {
                    pixelSelection->invert();
                }
 
                pixelSelection->applySelection(m_selection, m_action);
 
                QRect dirtyRect = m_view->image()->bounds();
                if (hasSelection &&
                    m_action != SELECTION_REPLACE &&
                    m_action != SELECTION_INTERSECT &&
                    m_action != SELECTION_SYMMETRICDIFFERENCE) {
 
                    dirtyRect = m_selection->selectedRect();
                }
                m_view->selection()->updateProjection(dirtyRect);
 
                savedCommand = transaction.endAndTake();
                pixelSelection->setDirty(dirtyRect);
 
                // release resources: transaction will care about
                // undo/redo, we don't need the selection anymore
                m_selection.clear();
            }
 
            if (m_view->selection()->selectedExactRect().isEmpty()) {
                KUndo2Command *deselectCommand = new KisDeselectActiveSelectionCommand(m_view->selection(), m_view->image());
                if (savedCommand) {
                    KisCommandUtils::CompositeCommand *cmd = new KisCommandUtils::CompositeCommand();
                    cmd->addCommand(savedCommand);
                    cmd->addCommand(deselectCommand);
                    savedCommand = cmd;
                } else {
                    savedCommand = deselectCommand;
                }
            }
 
            return savedCommand;
        }
    };
 
    applicator.applyCommand(new ApplyToPixelSelection(view, selection, action, canvas), KisStrokeJobData::SEQUENTIAL);
 
}

References KisCommandUtils::CompositeCommand::addCommand(), KisProcessingApplicator::applyCommand(), KisPixelSelection::applySelection(), KisImage::bounds(), KisSharedPtr< T >::clear(), KisTransaction::endAndTake(), KisView::image(), KisPixelSelection::invert(), KisPixelSelection::isEmpty(), KIS_SAFE_ASSERT_RECOVER, m_canvas, KisSelection::pixelSelection, KisPixelSelection::selectedExactRect(), KisSelection::selectedExactRect(), KisPixelSelection::selectedRect(), KisView::selection(), SELECTION_INTERSECT, SELECTION_REPLACE, SELECTION_SUBTRACT, SELECTION_SYMMETRICDIFFERENCE, KisStrokeJobData::SEQUENTIAL, KisPaintDevice::setDirty(), and KisSelection::updateProjection().

◆ tryDeselectCurrentSelection()

bool KisSelectionToolHelper::tryDeselectCurrentSelection	(	const QRectF	selectionViewRect,
		SelectionAction	action )

Definition at line 336 of file kis_selection_tool_helper.cpp.

{
    bool result = false;
 
    if (KisAlgebra2D::maxDimension(selectionViewRect) < KisConfig(true).selectionViewSizeMinimum() &&
        (action == SELECTION_INTERSECT || action == SELECTION_SYMMETRICDIFFERENCE || action == SELECTION_REPLACE)) {
 
        // Queueing this action to ensure we avoid a race condition when unlocking the node system
        QTimer::singleShot(0, m_canvas->viewManager()->selectionManager(), SLOT(deselect()));
        result = true;
    }
 
    return result;
}

References m_canvas, KisAlgebra2D::maxDimension(), SELECTION_INTERSECT, SELECTION_REPLACE, and SELECTION_SYMMETRICDIFFERENCE.

◆ tryOverrideSelectionMode()

SelectionMode KisSelectionToolHelper::tryOverrideSelectionMode	(	KisSelectionSP	activeSelection,
		SelectionMode	currentMode,
		SelectionAction	currentAction ) const

Definition at line 409 of file kis_selection_tool_helper.cpp.

{
    if (currentAction != SELECTION_DEFAULT && currentAction != SELECTION_REPLACE) {
        if (activeSelection) {
            currentMode = activeSelection->hasShapeSelection() ? SHAPE_PROTECTION : PIXEL_SELECTION;
        }
    }
 
    return currentMode;
}

References KisSelection::hasShapeSelection(), PIXEL_SELECTION, SELECTION_DEFAULT, SELECTION_REPLACE, and SHAPE_PROTECTION.

Member Data Documentation

◆ m_canvas

QPointer<KisCanvas2> KisSelectionToolHelper::m_canvas

private

Definition at line 47 of file kis_selection_tool_helper.h.

◆ m_image

KisImageSP KisSelectionToolHelper::m_image

private

Definition at line 48 of file kis_selection_tool_helper.h.

◆ m_layer

KisLayerSP KisSelectionToolHelper::m_layer

private

Definition at line 49 of file kis_selection_tool_helper.h.

◆ m_name

KUndo2MagicString KisSelectionToolHelper::m_name

private

Definition at line 50 of file kis_selection_tool_helper.h.

The documentation for this class was generated from the following files:

libs/ui/tool/kis_selection_tool_helper.h
libs/ui/tool/kis_selection_tool_helper.cpp

Public Member Functions

Static Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ KisSelectionToolHelper()

◆ ~KisSelectionToolHelper()

Member Function Documentation

◆ addSelectionShape()

◆ addSelectionShapes()

◆ canShortcutToDeselect()

◆ canShortcutToNoop()

◆ getSelectionContextMenu()

◆ selectPixelSelection() [1/2]

◆ selectPixelSelection() [2/2]

◆ tryDeselectCurrentSelection()

◆ tryOverrideSelectionMode()

Member Data Documentation

◆ m_canvas

◆ m_image

◆ m_layer

◆ m_name