KisToolUtils Namespace Reference

Classes
struct	ColorSamplerConfig
class	StandardBrushSizes

Functions
void	bakeDefaultPixel (KisPaintDeviceSP clip, const QRect &rc)
KisImageSP	buildImageForClipboard (KisImageSP srcImage, KisNodeList nodes)
bool	clearImage (KisImageSP image, KisNodeList nodes, KisSelectionSP selection)
void	ensureClipVisible (const QRect &imageBounds, KisPaintDeviceSP clip)
KisNodeSP	findNode (KisNodeSP node, const QPoint &point, bool wholeGroup, bool editableOnly)
KisNodeList	findNodes (KisNodeSP node, const QPoint &point, bool wholeGroup, bool includeGroups, bool editableOnly)
QList< KisShapeLayerSP >	findShapeLayers (KisNodeSP root, const QPointF &point, bool editableOnly)
QString	nodeEditableMessage (KisNodeSP node, bool blockedNoIndirectPainting=false)
	nodeEditableMessage
void	recenterClip (KisPaintDeviceSP clip, const QPoint &newCenter)
bool	sampleColor (KoColor &out_color, KisPaintDeviceSP dev, const QPoint &pos, KoColor const *const blendColor, int radius, int blend, bool pure)
bool	selectShapeCrossLayer (KoCanvasBase *canvas, const QPointF &point, const QString &shapeType=QString(), bool skipCurrentShapes=true)
	selectShapeCrossLayer Tries to select a shape under the cursor regardless of which layer it is on, to do so, it will always select the layer first and then the shape.
void KRITAUI_EXPORT	setCursorPos (const QPoint &point)
QPainterPath	shapeHoverInfoCrossLayer (KoCanvasBase *canvas, const QPointF &point, QString &shapeType, bool *isHorizontal=nullptr, bool skipCurrentShapes=true)
	shapeHoverInfoCrossLayer get hover info of shapes on all layers.
void KRITAUI_EXPORT	showBrushSizeFloatingMessage (KoCanvasBase *canvas, qreal size)
void	trimDeviceForClipboard (KisImageSP image, KisPaintDeviceSP device, KisSelectionSP selection, bool makeSharpClip)

Function Documentation

bakeDefaultPixel()

void KRITAUI_EXPORT KisToolUtils::bakeDefaultPixel	(	KisPaintDeviceSP	clip,
		const QRect &	rc )

If clip has non-transparent default pixel, it will be written into pixels explicitly in the area rc. After that, the default pixel will be reset to "transparent".

Definition at line 537 of file kis_tool_utils.cpp.

    {
        if (clip->defaultPixel().opacityU8() != OPACITY_TRANSPARENT_U8) {
            KisPaintDeviceSP copy = new KisPaintDevice(clip->colorSpace());
            copy->makeCloneFromRough(clip, rc);
            KisPainter::copyAreaOptimized(rc.topLeft(), copy, clip, rc);
            clip->setDefaultPixel(KoColor::createTransparent(clip->colorSpace()));
        }
    }

References KisPaintDevice::colorSpace(), KisPainter::copyAreaOptimized(), KoColor::createTransparent(), KisPaintDevice::defaultPixel(), OPACITY_TRANSPARENT_U8, KoColor::opacityU8(), and KisPaintDevice::setDefaultPixel().

buildImageForClipboard()

KisImageSP KRITAUI_EXPORT KisToolUtils::buildImageForClipboard	(	KisImageSP	srcImage,
		KisNodeList	nodes )

Creates an image that has the same resolution and size as srcImage, which can be used as a container image for uploading nodes into clipboard.

Definition at line 507 of file kis_tool_utils.cpp.

    {
        KisImageSP clipImage = new KisImage(0, srcImage->width(), srcImage->height(), srcImage->colorSpace(), "ClipImage");
        clipImage->setResolution(srcImage->xRes(), srcImage->yRes());
        Q_FOREACH (KisNodeSP node, nodes) {
            clipImage->addNode(node, clipImage->root());
        }
 
        clipImage->refreshGraphAsync();
        clipImage->waitForDone();
 
        return clipImage;
    }

References KisNodeFacade::addNode(), KisImage::colorSpace(), KisImage::height(), KisImage::refreshGraphAsync(), KisNodeFacade::root, KisImage::setResolution(), KisImage::waitForDone(), KisImage::width(), KisImage::xRes(), and KisImage::yRes().

clearImage()

bool KRITAUI_EXPORT KisToolUtils::clearImage	(	KisImageSP	image,
		KisNodeList	nodes,
		KisSelectionSP	selection )

return true if success Clears the image. Selection is optional, use 0 to clear everything.

Definition at line 195 of file kis_tool_utils.cpp.

    {
        KisNodeList masks;
 
        Q_FOREACH (KisNodeSP node, nodes) {
            if (node->inherits("KisMask")) {
                masks.append(node);
            }
        }
 
        // To prevent deleting same layer multiple times
        KisLayerUtils::filterMergeableNodes(nodes);
        nodes.append(masks);
 
        if (nodes.isEmpty()) {
            return false;
        }
 
        KisProcessingApplicator applicator(image, 0, KisProcessingApplicator::NONE,
                                           KisImageSignalVector(), kundo2_i18n("Clear"));
 
        Q_FOREACH (KisNodeSP node, nodes) {
            KisLayerUtils::recursiveApplyNodes(node, [&applicator, selection, masks] (KisNodeSP node) {
 
                // applied on masks if selected explicitly
                if (node->inherits("KisMask") && !masks.contains(node)) {
                    return;
                }
 
                if(node->hasEditablePaintDevice()) {
                    KUndo2Command *cmd =
                        new KisCommandUtils::LambdaCommand(kundo2_i18n("Clear"),
                            [node, selection] () {
                                KisPaintDeviceSP device = node->paintDevice();
 
                                std::unique_ptr<KisCommandUtils::CompositeCommand> parentCommand(
                                    new KisCommandUtils::CompositeCommand());
 
                                KUndo2Command *autoKeyframeCommand = KisAutoKey::tryAutoCreateDuplicatedFrame(device);
                                if (autoKeyframeCommand) {
                                    parentCommand->addCommand(autoKeyframeCommand);
                                }
 
                                KisTransaction transaction(kundo2_noi18n("internal-clear-command"), device);
 
                                QRect dirtyRect;
                                if (selection) {
                                    dirtyRect = selection->selectedRect();
                                    device->clearSelection(selection);
                                } else {
                                    dirtyRect = device->extent();
                                    device->clear();
                                }
 
                                device->setDirty(dirtyRect);
                                parentCommand->addCommand(transaction.endAndTake());
 
                                return parentCommand.release();
                            });
                    applicator.applyCommand(cmd, KisStrokeJobData::CONCURRENT);
                }
            });
        }
 
        applicator.end();
 
        return true;
    }

References KisProcessingApplicator::applyCommand(), KisStrokeJobData::CONCURRENT, KisLayerUtils::filterMergeableNodes(), KisBaseNode::hasEditablePaintDevice(), kundo2_i18n(), KisProcessingApplicator::NONE, and KisLayerUtils::recursiveApplyNodes().

ensureClipVisible()

void KRITAUI_EXPORT KisToolUtils::ensureClipVisible	(	const QRect &	imageBounds,
		KisPaintDeviceSP	clip )

Make sure non-default area of the clip device is visible within image bounds

The function uses nonDefaultPixelArea() instead of exactBounds(), because the clip may have non-transparent default pixel.

Definition at line 528 of file kis_tool_utils.cpp.

    {
        const QRect clipBounds = clip->nonDefaultPixelArea();
        if (!imageBounds.intersects(clipBounds)) {
            const QPoint diff = imageBounds.center() - clipBounds.center();
            clip->moveTo(clip->offset() + diff);
        }
    }

References KisPaintDevice::moveTo(), KisPaintDevice::nonDefaultPixelArea(), and KisPaintDevice::offset().

findNode()

KisNodeSP KRITAUI_EXPORT KisToolUtils::findNode	(	KisNodeSP	node,
		const QPoint &	point,
		bool	wholeGroup,
		bool	editableOnly = true )

Recursively search a node with a non-transparent pixel

Definition at line 118 of file kis_tool_utils.cpp.

    {
        KisNodeSP foundNode = 0;
        while (node) {
            KisLayerSP layer = qobject_cast<KisLayer*>(node.data());
 
            if (!layer || !layer->isEditable()) {
                node = node->prevSibling();
                continue;
            }
 
            KoColor color(layer->projection()->colorSpace());
            layer->projection()->pixel(point.x(), point.y(), &color);
 
            KisGroupLayerSP group = dynamic_cast<KisGroupLayer*>(layer.data());
 
            if ((group && group->passThroughMode()) ||  color.opacityU8() != OPACITY_TRANSPARENT_U8) {
                if (layer->inherits("KisGroupLayer") && (!editableOnly || layer->isEditable())) {
                    // if this is a group and the pixel is transparent, don't even enter it
                    foundNode = findNode(node->lastChild(), point, wholeGroup, editableOnly);
                }
                else {
                    foundNode = !wholeGroup ? node : node->parent();
                }
 
            }
 
            if (foundNode) break;
 
            node = node->prevSibling();
        }
 
        return foundNode;
    }

References KisPaintDevice::colorSpace(), KisSharedPtr< T >::data(), findNode(), KisBaseNode::isEditable(), KisNode::lastChild(), OPACITY_TRANSPARENT_U8, KoColor::opacityU8(), KisNode::parent, KisGroupLayer::passThroughMode, KisPaintDevice::pixel(), KisNode::prevSibling(), and KisLayer::projection().

findNodes()

KisNodeList KRITAUI_EXPORT KisToolUtils::findNodes	(	KisNodeSP	node,
		const QPoint &	point,
		bool	wholeGroup,
		bool	includeGroups,
		bool	editableOnly )

Definition at line 153 of file kis_tool_utils.cpp.

    {
        KisNodeList foundNodes;
        while (node) {
            KisLayerSP layer = qobject_cast<KisLayer*>(node.data());
 
            if (!layer || !layer->isEditable()) {
                node = node->nextSibling();
                continue;
            }
 
            KoColor color(layer->projection()->colorSpace());
            layer->projection()->pixel(point.x(), point.y(), &color);
            const bool isTransparent = color.opacityU8() == OPACITY_TRANSPARENT_U8;
 
            KisGroupLayerSP group = dynamic_cast<KisGroupLayer*>(layer.data());
 
            if (group) {
                if (!isTransparent || group->passThroughMode()) {
                    foundNodes << findNodes(node->firstChild(), point, wholeGroup, includeGroups, editableOnly);
                    if (includeGroups) {
                        foundNodes << node;
                    }
                }
            } else {
                if (!isTransparent) {
                    if (wholeGroup) {
                        if (!foundNodes.contains(node->parent())) {
                            foundNodes << node->parent();
                        }
                    } else {
                        foundNodes << node;
                    }
                }
            }
 
            node = node->nextSibling();
        }
 
        return foundNodes;
    }

References KisPaintDevice::colorSpace(), KisSharedPtr< T >::data(), findNodes(), KisNode::firstChild(), KisBaseNode::isEditable(), KisNode::nextSibling(), OPACITY_TRANSPARENT_U8, KoColor::opacityU8(), KisNode::parent, KisGroupLayer::passThroughMode, KisPaintDevice::pixel(), and KisLayer::projection().

findShapeLayers()

QList< KisShapeLayerSP > KisToolUtils::findShapeLayers	(	KisNodeSP	root,
		const QPointF &	point,
		bool	editableOnly )

Definition at line 332 of file kis_tool_utils.cpp.

                                                                                                    {
        QList<KisShapeLayerSP> foundNodes;
        KisLayerUtils::recursiveApplyNodes(root, [&] (KisNodeSP node) {
            if ((node->isEditable(true) && editableOnly) || !editableOnly) {
 
                KisShapeLayerSP shapeLayer = dynamic_cast<KisShapeLayer*>(node.data());
                if (shapeLayer && shapeLayer->isEditable() && shapeLayer->shapeManager()->shapeAt(point)) {
                    foundNodes.append(shapeLayer);
                }
            }
        });
        return foundNodes;
    }

References KisBaseNode::isEditable(), and KisLayerUtils::recursiveApplyNodes().

nodeEditableMessage()

QString KRITAUI_EXPORT KisToolUtils::nodeEditableMessage	(	KisNodeSP	node,
		bool	blockedNoIndirectPainting = false )

nodeEditableMessage

Parameters

node	– active node.
blockedNoIndirectPainting	– whether editing is blocked due no-indirect painting being possible.

Returns

the message for why the node is not editable. Will return empty if it is editable after all.

Definition at line 415 of file kis_tool_utils.cpp.

    {
        QString message;
        if (!node->isEditable(true) || blockedNoIndirectPainting) {
            if (!node->visible() && node->userLocked()) {
                message = i18n("Layer is locked and invisible.");
            } else if (node->userLocked()) {
                message = i18n("Layer is locked.");
            } else if(!node->visible()) {
                message = i18n("Layer is invisible.");
            } else if (blockedNoIndirectPainting) {
                message = i18n("Layer can be painted in Wash Mode only.");
            } else {
                message = i18n("Group not editable.");
            }
        }
        return message;
    }

References KisBaseNode::isEditable(), KisBaseNode::userLocked(), and KisBaseNode::visible().

recenterClip()

void KRITAUI_EXPORT KisToolUtils::recenterClip	(	KisPaintDeviceSP	clip,
		const QPoint &	newCenter )

Moves the center of non-default area to the requested position

Definition at line 521 of file kis_tool_utils.cpp.

    {
        const QRect clipBounds = clip->nonDefaultPixelArea();
        const QPoint diff = newCenter - clipBounds.center();
        clip->moveTo(clip->offset() + diff);
    }

References KisPaintDevice::moveTo(), KisPaintDevice::nonDefaultPixelArea(), and KisPaintDevice::offset().

sampleColor()

bool KRITAUI_EXPORT KisToolUtils::sampleColor	(	KoColor &	out_color,
		KisPaintDeviceSP	dev,
		const QPoint &	pos,
		KoColor const *const	blendColor = nullptr,
		int	radius = 1,
		int	blend = 100,
		bool	pure = false )

Sample a color based on the given position on the given paint device.

out_color - Output parameter returning newly sampled color. dev - Paint device to sample from. pos - Position to sample from. blendColor - Optional color to be blended with. radius - Sampling area radius in pixels. blend - Blend percentage. 100% all sampled, 0% all blendColor. pure - Whether to bypass radius, blending, and active layer settings for pure sampling.

RETURN - Returns TRUE whenever a valid color is sampled.

Definition at line 42 of file kis_tool_utils.cpp.

    {
        KIS_ASSERT(dev);
 
        // Bugfix hack forcing pure on first sample to avoid wrong
        // format blendColor on newly initialized Krita.
        static bool firstTime = true;
        if (firstTime == true) {
            pure = true;
            firstTime = false;
        }
 
        const KoColorSpace *cs = dev->colorSpace();
        KoColor sampledColor = KoColor::createTransparent(cs);
 
        // Wrap around color sampling is supported on any paint device
        bool oldSupportsWraparound = dev->supportsWraproundMode();
        dev->setSupportsWraparoundMode(true);
 
        // Sampling radius.
        if (!pure && radius > 1) {
            QScopedPointer<KoMixColorsOp::Mixer> mixer(cs->mixColorsOp()->createMixer());
 
            QVector<const quint8*> pixels;
            const int effectiveRadius = radius - 1;
 
            const QRect sampleRect(pos.x() - effectiveRadius, pos.y() - effectiveRadius,
                                 2 * effectiveRadius + 1, 2 * effectiveRadius + 1);
            KisSequentialConstIterator it(dev, sampleRect);
 
            const int radiusSq = pow2(effectiveRadius);
 
            int nConseqPixels = it.nConseqPixels();
            while (it.nextPixels(nConseqPixels)) {
                const QPoint realPos(it.x(),  it.y());
                if (kisSquareDistance(realPos, pos) < radiusSq) {
                    mixer->accumulateAverage(it.oldRawData(), nConseqPixels);
                }
            }
 
            mixer->computeMixedColor(sampledColor.data());
 
        } else {
            dev->pixel(pos.x(), pos.y(), &sampledColor);
        }
 
        dev->setSupportsWraparoundMode(oldSupportsWraparound);
        
        // Color blending.
        if (!pure && blendColor && blend < 100) {
            //Scale from 0..100% to 0..255 range for mixOp weights.
            quint8 blendScaled = static_cast<quint8>(blend * 2.55f);
 
            const quint8 *colors[2];
            colors[0] = blendColor->data();
            colors[1] = sampledColor.data();
            qint16 weights[2];
            weights[0] = 255 - blendScaled;
            weights[1] = blendScaled;
 
            const KoMixColorsOp *mixOp = dev->colorSpace()->mixColorsOp();
            mixOp->mixColors(colors, weights, 2, sampledColor.data());
        }
 
        sampledColor.convertTo(dev->compositionSourceColorSpace());
 
        bool validColorSampled = sampledColor.opacityU8() != OPACITY_TRANSPARENT_U8;
 
        if (validColorSampled) {
            out_color = sampledColor;
        }
 
        return validColorSampled;
    }

References KisPaintDevice::colorSpace(), KisPaintDevice::compositionSourceColorSpace(), KoColor::convertTo(), KoMixColorsOp::createMixer(), KoColor::createTransparent(), KoColor::data(), KIS_ASSERT, kisSquareDistance(), KoMixColorsOp::mixColors(), KoColorSpace::mixColorsOp, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nConseqPixels(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixels(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::oldRawData(), OPACITY_TRANSPARENT_U8, KoColor::opacityU8(), KisPaintDevice::pixel(), pow2(), KisPaintDevice::setSupportsWraparoundMode(), KisPaintDevice::supportsWraproundMode(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::x(), and KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::y().

selectShapeCrossLayer()

bool KRITAUI_EXPORT KisToolUtils::selectShapeCrossLayer	(	KoCanvasBase *	canvas,
		const QPointF &	point,
		const QString &	shapeType = QString(),
		bool	skipCurrentShapes = true )

selectShapeCrossLayer Tries to select a shape under the cursor regardless of which layer it is on, to do so, it will always select the layer first and then the shape.

Parameters

canvas	– the current canvas.
point	– the point in document coordinates.
shapeType	– the required shapeId, if empty, selects any koshape.

Returns

whether a shape was successfully selected.

Definition at line 387 of file kis_tool_utils.cpp.

    {
        KisCanvas2 *canvas2 = dynamic_cast<KisCanvas2*>(canvas);
        if (!canvas2) return false;
 
        QList<KoShape*> currentShapes = canvas->shapeManager()->selection()->selectedShapes();
        QList<KisShapeLayerSP> candidates = findShapeLayers(canvas2->image()->root(), point, true);
        KisShapeLayerSP shapeLayer = candidates.isEmpty()? nullptr: candidates.last();
 
        if (shapeLayer) {
            KoShape *shape = shapeLayer->shapeManager()->shapeAt(point);
            if (shape
                    && !(currentShapes.contains(shape) && skipCurrentShapes)
                    && (shapeType.isEmpty() || shapeType == shape->shapeId())) {
                canvas2->viewManager()->nodeManager()->slotNonUiActivatedNode(shapeLayer);
                canvas2->shapeManager()->selection()->deselectAll();
                canvas2->shapeManager()->selection()->select(shape);
            } else {
                return false;
            }
        } else {
            return false;
        }
 
        return true;
    }

References KoSelection::deselectAll(), findShapeLayers(), KisCanvas2::image(), KisViewManager::nodeManager(), KisNodeFacade::root, KoSelection::select(), KoSelection::selectedShapes(), KoShapeManager::selection, KoShapeManager::shapeAt(), KoShape::shapeId(), KisShapeLayer::shapeManager(), KoCanvasBase::shapeManager(), KisCanvas2::shapeManager, KisNodeManager::slotNonUiActivatedNode(), and KisCanvas2::viewManager().

setCursorPos()

void KRITAUI_EXPORT KisToolUtils::setCursorPos

(

const QPoint &

point

)

Moves the cursor (hot spot) of the primary screen to the global screen position (x, y).

This function is provided as a replacement to QCursor::setPos which does not properly handle multiple monitors with different scale factors.

Definition at line 309 of file kis_tool_utils.cpp.

    {
        // https://bugreports.qt.io/browse/QTBUG-99009
        QScreen *screen = qApp->screenAt(point);
        if (!screen) {
            screen = qApp->primaryScreen();
        }
        QCursor::setPos(screen, point);
    }

shapeHoverInfoCrossLayer()

QPainterPath KRITAUI_EXPORT KisToolUtils::shapeHoverInfoCrossLayer	(	KoCanvasBase *	canvas,
		const QPointF &	point,
		QString &	shapeType,
		bool *	isHorizontal = nullptr,
		bool	skipCurrentShapes = true )

shapeHoverInfoCrossLayer get hover info of shapes on all layers.

Parameters

canvas	– current canvas.
point	– the point in document coordinates.
shapeType	– the shapeID of the found shape.
isHorizontal	– when this is a textShape, sets whether the writing mode is horizontal.

Returns

Definition at line 346 of file kis_tool_utils.cpp.

    {
        QPainterPath p;
        KisCanvas2 *canvas2 = dynamic_cast<KisCanvas2*>(canvas);
        if (!canvas2) return p;
 
        QList<KoShape*> currentShapes = canvas->shapeManager()->selection()->selectedShapes();
        QList<KisShapeLayerSP> candidates = findShapeLayers(canvas2->image()->root(), point, true);
        KisShapeLayerSP shapeLayer = candidates.isEmpty()? nullptr: candidates.last();
 
        if (shapeLayer) {
            KoShape *shape = shapeLayer->shapeManager()->shapeAt(point);
            if (shape && !(currentShapes.contains(shape) && skipCurrentShapes)) {
                shapeType = shape->shapeId();
                KoSvgTextShape *t = dynamic_cast<KoSvgTextShape *>(shape);
                if (t) {
                    p.addRect(t->boundingRect());
                    if (isHorizontal) {
                        *isHorizontal = t->writingMode() == KoSvgText::HorizontalTB;
                    }
                    if (!t->shapesInside().isEmpty()) {
                        QPainterPath paths;
                        Q_FOREACH(KoShape *s, t->shapesInside()) {
                            KoPathShape *path = dynamic_cast<KoPathShape *>(s);
                            if (path) {
                                paths.addPath(path->absoluteTransformation().map(path->outline()));
                            }
                        }
                        if (!paths.isEmpty()) {
                            p = paths;
                        }
                    }
                } else {
                    p = shape->absoluteTransformation().map(shape->outline());
                }
            }
        }
 
        return p;
    }

References KoShape::absoluteTransformation(), KoSvgTextShape::boundingRect(), findShapeLayers(), KoSvgText::HorizontalTB, KisCanvas2::image(), KoShape::outline(), p, KisNodeFacade::root, KoSelection::selectedShapes(), KoShapeManager::selection, KoShapeManager::shapeAt(), KoShape::shapeId(), KisShapeLayer::shapeManager(), KoCanvasBase::shapeManager(), KoSvgTextShape::shapesInside, and KoSvgTextShape::writingMode().

showBrushSizeFloatingMessage()

void KRITAUI_EXPORT KisToolUtils::showBrushSizeFloatingMessage	(	KoCanvasBase *	canvas,
		qreal	size )

Definition at line 319 of file kis_tool_utils.cpp.

    {
        KisCanvas2 *kisCanvas = dynamic_cast<KisCanvas2 *>(canvas);
        KIS_SAFE_ASSERT_RECOVER_RETURN(kisCanvas);
        kisCanvas->viewManager()->showFloatingMessage(i18n("Brush Size: %1 px", size),
                                                      QIcon(),
                                                      1000,
                                                      KisFloatingMessage::High,
                                                      Qt::AlignLeft | Qt::TextWordWrap | Qt::AlignVCenter);
    }

References KisFloatingMessage::High, KIS_SAFE_ASSERT_RECOVER_RETURN, KisViewManager::showFloatingMessage(), and KisCanvas2::viewManager().

trimDeviceForClipboard()

void KRITAUI_EXPORT KisToolUtils::trimDeviceForClipboard	(	KisImageSP	image,
		KisPaintDeviceSP	device,
		KisSelectionSP	selection,
		bool	makeSharpClip = false )

Trims the device for uploading to the clipboard

• if selection is present, then selection is baked into the device, the whole device is cropped by the selection and the default pixel is reset to "transparent
• if selection is null, then device is just cropped by the image bounds

Sharp method is an exact reverse of COMPOSITE_OVER so if you cover the cut/copied piece over its source you get an exactly the same image without any seams

Definition at line 460 of file kis_tool_utils.cpp.

    {
        KIS_SAFE_ASSERT_RECOVER_RETURN(image);
 
        QRect rc = selection ? selection->selectedExactRect() : image->bounds();
 
        const KoColorSpace *cs = device->colorSpace();
 
        if (selection) {
            // Apply selection mask.
            KisPaintDeviceSP selectionProjection = selection->projection();
            const KoColorSpace *selCs = selection->projection()->colorSpace();
 
            KisSequentialIterator layerIt(device, rc);
            KisSequentialConstIterator selectionIt(selectionProjection, rc);
 
            while (layerIt.nextPixel() && selectionIt.nextPixel()) {
 
                if (makeSharpClip) {
                    qreal dstAlpha = cs->opacityF(layerIt.rawData());
                    qreal sel = selCs->opacityF(selectionIt.oldRawData());
                    qreal newAlpha = sel * dstAlpha / (1.0 - dstAlpha + sel * dstAlpha);
                    float mask = newAlpha / dstAlpha;
 
                    cs->applyAlphaNormedFloatMask(layerIt.rawData(), &mask, 1);
                } else {
                    cs->applyAlphaU8Mask(layerIt.rawData(), selectionIt.oldRawData(), 1);
                }
            }
 
            // if we have a selection, then we should remove the rest of the image
            // and make it fully transparent
            device->setDefaultPixel(KoColor::createTransparent(device->colorSpace()));
            device->purgeDefaultPixels();
        }
 
        device->crop(rc);
    }

References KoColorSpace::applyAlphaNormedFloatMask(), KoColorSpace::applyAlphaU8Mask(), KisImage::bounds(), KisPaintDevice::colorSpace(), KoColor::createTransparent(), KisPaintDevice::crop(), KIS_SAFE_ASSERT_RECOVER_RETURN, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::oldRawData(), KoColorSpace::opacityF(), KisSelection::projection(), KisPaintDevice::purgeDefaultPixels(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), KisSelection::selectedExactRect(), and KisPaintDevice::setDefaultPixel().