KisToolUtils Namespace Reference

Classes
struct	ColorSamplerConfig

Functions
bool	clearImage (KisImageSP image, KisNodeList nodes, KisSelectionSP selection)
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)
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.

Function Documentation

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 193 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();
 
                                QScopedPointer<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.take();
                            });
                    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().

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 116 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 151 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 319 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().

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 40 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 372 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 307 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 333 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 && isHorizontal) {
                    p.addRect(t->boundingRect());
                    *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(t->absoluteTransformation().map(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().