KoFlake Namespace Reference

Enumerations
enum	AnchorPosition {   TopLeft , Top , TopRight , Left ,   Center , Right , BottomLeft , Bottom ,   BottomRight , NoAnchor , NumAnchorPositions }
enum	CanvasResource { HotPosition = 1410100299 }
enum	CoordinateSystem { UserSpaceOnUse , ObjectBoundingBox }
enum	FillType {   None , Solid , Gradient , Pattern ,   MeshGradient }
enum	FillVariant { Fill , StrokeFill }
enum	MarkerPosition { StartMarker , MidMarker , EndMarker }
enum	SelectionHandle {   TopMiddleHandle , TopRightHandle , RightMiddleHandle , BottomRightHandle ,   BottomMiddleHandle , BottomLeftHandle , LeftMiddleHandle , TopLeftHandle ,   NoHandle }
	Enum determining which handle is meant, used in KoInteractionTool. More...
enum	SelectionType { FullSelection , StrippedSelection , TopLevelSelection }
	the selection type for KoSelection::selectedObjects() More...
enum	ShapeSelection { Selected , Unselected , NextUnselected , ShapeOnTop }
enum	StyleType { Background , Foreground }

Functions
KRITAFLAKE_EXPORT QPointF	anchorToPoint (AnchorPosition anchor, const QRectF rect, bool *valid=0)
KRITAFLAKE_EXPORT QGradient *	cloneGradient (const QGradient *gradient)
	clones the given gradient
template<class Policy >
bool	compareShapePropertiesEqual (const QList< KoShape * > shapes)
template<class Policy >
bool	compareShapePropertiesEqual (const QList< KoShape * > shapes, const Policy &policy)
CoordinateSystem	coordinatesFromString (const QString &value, CoordinateSystem defaultValue)
QString	coordinateToString (CoordinateSystem value)
KRITAFLAKE_EXPORT QGradient *	mergeGradient (const QGradient *coordsSource, const QGradient *fillSource)
template<typename ModifyFunction >
auto	modifyShapesStrokes (QList< KoShape * > shapes, ModifyFunction modifyFunction) -> decltype(modifyFunction(KoShapeStrokeSP()),(KUndo2Command *)(0))
KRITAFLAKE_EXPORT void	resizeShape (KoShape *shape, qreal scaleX, qreal scaleY, const QPointF &absoluteStillPoint, bool useGlobalMode)
KRITAFLAKE_EXPORT void	resizeShapeCommon (KoShape *shape, qreal scaleX, qreal scaleY, const QPointF &absoluteStillPoint, bool useGlobalMode, bool usePostScaling, const QTransform &postScalingCoveringTransform)
KRITAFLAKE_EXPORT void	scaleShape (KoShape *shape, qreal scaleX, qreal scaleY, const QPointF &absoluteStillPoint, const QTransform &postScalingCoveringTransform)
KRITAFLAKE_EXPORT void	scaleShapeGlobal (KoShape *shape, qreal scaleX, qreal scaleY, const QPointF &absoluteStillPoint)
KRITAFLAKE_EXPORT Qt::Orientation	significantScaleOrientation (qreal scaleX, qreal scaleY)
KRITAFLAKE_EXPORT QPointF	toAbsolute (const QPointF &relative, const QSizeF &size)
KRITAFLAKE_EXPORT QPointF	toRelative (const QPointF &absolute, const QSizeF &size)

Detailed Description

Flake reference

Enumeration Type Documentation

AnchorPosition

enum KoFlake::AnchorPosition

Enumerator
TopLeft
Top
TopRight
Left
Center
Right
BottomLeft
Bottom
BottomRight
NoAnchor
NumAnchorPositions

Definition at line 85 of file KoFlake.h.

                        {
        TopLeft,
        Top,
        TopRight,
        Left,
        Center,
        Right,
        BottomLeft,
        Bottom,
        BottomRight,
        NoAnchor,
        NumAnchorPositions
    };

CanvasResource

enum KoFlake::CanvasResource

Enumerator
HotPosition

Definition at line 101 of file KoFlake.h.

                        {
        HotPosition = 1410100299
    };

CoordinateSystem

enum KoFlake::CoordinateSystem

Enumerator
UserSpaceOnUse
ObjectBoundingBox

Definition at line 14 of file KoFlakeCoordinateSystem.h.

                      {
    UserSpaceOnUse,
    ObjectBoundingBox
};

FillType

enum KoFlake::FillType

Enumerator
None
Solid
Gradient
Pattern
MeshGradient

Definition at line 33 of file KoFlake.h.

                  {
        None,
        Solid,
        Gradient,
        Pattern,
        MeshGradient
    };

FillVariant

enum KoFlake::FillVariant

Enumerator
Fill
StrokeFill

Definition at line 28 of file KoFlake.h.

                     {
        Fill,
        StrokeFill
    };

MarkerPosition

enum KoFlake::MarkerPosition

Enumerator
StartMarker
MidMarker
EndMarker

Definition at line 41 of file KoFlake.h.

                        {
        StartMarker,
        MidMarker,
        EndMarker
    };

SelectionHandle

enum KoFlake::SelectionHandle

Enum determining which handle is meant, used in KoInteractionTool.

Enumerator
TopMiddleHandle	The handle that is at the top - center of a selection.
TopRightHandle	The handle that is at the top - right of a selection.
RightMiddleHandle	The handle that is at the right - center of a selection.
BottomRightHandle	The handle that is at the bottom right of a selection.
BottomMiddleHandle	The handle that is at the bottom center of a selection.
BottomLeftHandle	The handle that is at the bottom left of a selection.
LeftMiddleHandle	The handle that is at the left center of a selection.
TopLeftHandle	The handle that is at the top left of a selection.
NoHandle	Value to indicate no handle.

Definition at line 55 of file KoFlake.h.

                         {
        TopMiddleHandle,    
        TopRightHandle,     
        RightMiddleHandle,  
        BottomRightHandle,  
        BottomMiddleHandle, 
        BottomLeftHandle,   
        LeftMiddleHandle,   
        TopLeftHandle,      
        NoHandle            
    };

SelectionType

enum KoFlake::SelectionType

the selection type for KoSelection::selectedObjects()

Enumerator
FullSelection	Create a list of all user-shapes in the selection. This excludes KoShapeGroup grouping objects that may be selected.
StrippedSelection	Create a stripped list, without children if the container is also in the list.
TopLevelSelection	Create a list, much like the StrippedSelection, but have the KoShapeGroup instead of all of its children if one is selected.

Definition at line 48 of file KoFlake.h.

                       {
        FullSelection,      
        StrippedSelection,  
        TopLevelSelection   
    };

ShapeSelection

enum KoFlake::ShapeSelection

Used to change the behavior of KoShapeManager::shapeAt()

Enumerator
Selected	return the first selected with the highest z-ordering (i.e. on top).
Unselected	return the first unselected on top.
NextUnselected	return the first unselected directly under a selected shape, or the top most one if nothing is selected.
ShapeOnTop	return the shape highest z-ordering, regardless of selection.

Definition at line 70 of file KoFlake.h.

                        {
        Selected,   
        Unselected, 
        NextUnselected, 
        ShapeOnTop  
    };

StyleType

enum KoFlake::StyleType

Used to see which style type is active

Enumerator
Background	the background / fill style is active
Foreground	the foreground / stroke style is active

Definition at line 80 of file KoFlake.h.

                   {
        Background, 
        Foreground  
    };

Function Documentation

anchorToPoint()

QPointF KoFlake::anchorToPoint	(	AnchorPosition	anchor,
		const QRectF	rect,
		bool *	valid = 0 )

Definition at line 329 of file KoFlake.cpp.

{
    static QVector<QPointF> anchorTable;
 
    if (anchorTable.isEmpty()) {
        anchorTable << QPointF(0.0,0.0);
        anchorTable << QPointF(0.5,0.0);
        anchorTable << QPointF(1.0,0.0);
 
        anchorTable << QPointF(0.0,0.5);
        anchorTable << QPointF(0.5,0.5);
        anchorTable << QPointF(1.0,0.5);
 
        anchorTable << QPointF(0.0,1.0);
        anchorTable << QPointF(0.5,1.0);
        anchorTable << QPointF(1.0,1.0);
    }
 
    if (valid)
        *valid = false;
 
    switch(anchor)
    {
        case AnchorPosition::TopLeft:
        case AnchorPosition::Top:
        case AnchorPosition::TopRight:
        case AnchorPosition::Left:
        case AnchorPosition::Center:
        case AnchorPosition::Right:
        case AnchorPosition::BottomLeft:
        case AnchorPosition::Bottom:
        case AnchorPosition::BottomRight:
            if (valid)
                *valid = true;
            return KisAlgebra2D::relativeToAbsolute(anchorTable[int(anchor)], rect);
        default:
            KIS_SAFE_ASSERT_RECOVER_NOOP(anchor >= AnchorPosition::TopLeft && anchor < AnchorPosition::NumAnchorPositions);
            return rect.topLeft();
    }
}

References KIS_SAFE_ASSERT_RECOVER_NOOP, and KisAlgebra2D::relativeToAbsolute().

cloneGradient()

QGradient * KoFlake::cloneGradient

(

const QGradient *

gradient

)

clones the given gradient

Definition at line 17 of file KoFlake.cpp.

{
    if (! gradient)
        return 0;
 
    QGradient *clone = 0;
 
    switch (gradient->type()) {
    case QGradient::LinearGradient:
    {
        const QLinearGradient *lg = static_cast<const QLinearGradient*>(gradient);
        clone = new QLinearGradient(lg->start(), lg->finalStop());
        break;
    }
    case QGradient::RadialGradient:
    {
        const QRadialGradient *rg = static_cast<const QRadialGradient*>(gradient);
        clone = new QRadialGradient(rg->center(), rg->radius(), rg->focalPoint());
        break;
    }
    case QGradient::ConicalGradient:
    {
        const QConicalGradient *cg = static_cast<const QConicalGradient*>(gradient);
        clone = new QConicalGradient(cg->center(), cg->angle());
        break;
    }
    default:
        return 0;
    }
 
    clone->setCoordinateMode(gradient->coordinateMode());
    clone->setSpread(gradient->spread());
    clone->setStops(gradient->stops());
 
    return clone;
}

compareShapePropertiesEqual() [1/2]

template<class Policy >

bool KoFlake::compareShapePropertiesEqual

(

const QList< KoShape * >

shapes

)

Definition at line 71 of file KoFlakeUtils.h.

{
    return compareShapePropertiesEqual<Policy>(shapes, Policy());
}

compareShapePropertiesEqual() [2/2]

template<class Policy >

bool KoFlake::compareShapePropertiesEqual	(	const QList< KoShape * >	shapes,
		const Policy &	policy )

Definition at line 47 of file KoFlakeUtils.h.

{
    if (shapes.size() == 1) return true;
 
    typename Policy::PointerType bg =
            policy.getProperty(shapes.first());
 
    Q_FOREACH (KoShape *shape, shapes) {
        typename Policy::PointerType otherBg = policy.getProperty(shape);
 
        if (
            !(
                (!bg && !otherBg) ||
                (bg && otherBg && policy.compareTo(bg, otherBg))
                )) {
 
            return false;
        }
    }
 
    return true;
}

coordinatesFromString()

CoordinateSystem KoFlake::coordinatesFromString ( const QString & value, CoordinateSystem defaultValue )

inline

Definition at line 19 of file KoFlakeCoordinateSystem.h.

{
    CoordinateSystem result = defaultValue;
 
    if (value == "userSpaceOnUse") {
        result = UserSpaceOnUse;
    } else if (value == "objectBoundingBox") {
        result = ObjectBoundingBox;
    }
 
    return result;
}

References ObjectBoundingBox, UserSpaceOnUse, and value().

coordinateToString()

QString KoFlake::coordinateToString ( CoordinateSystem value )

inline

Definition at line 32 of file KoFlakeCoordinateSystem.h.

{
    return
        value == ObjectBoundingBox?
        "objectBoundingBox" :
        "userSpaceOnUse";
}

References ObjectBoundingBox, and value().

mergeGradient()

QGradient * KoFlake::mergeGradient	(	const QGradient *	coordsSource,
		const QGradient *	fillSource )

Definition at line 54 of file KoFlake.cpp.

{
    QPointF start;
    QPointF end;
    QPointF focalPoint;
 
    switch (coordsSource->type()) {
    case QGradient::LinearGradient: {
        const QLinearGradient *lg = static_cast<const QLinearGradient*>(coordsSource);
        start = lg->start();
        focalPoint = start;
        end = lg->finalStop();
        break;
    }
    case QGradient::RadialGradient: {
        const QRadialGradient *rg = static_cast<const QRadialGradient*>(coordsSource);
        start = rg->center();
        end = start + QPointF(rg->radius(), 0);
        focalPoint = rg->focalPoint();
        break;
    }
    case QGradient::ConicalGradient: {
        const QConicalGradient *cg = static_cast<const QConicalGradient*>(coordsSource);
 
        start = cg->center();
        focalPoint = start;
 
        QLineF l (start, start + QPointF(1.0, 0));
        l.setAngle(cg->angle());
        end = l.p2();
        break;
    }
    default:
        return 0;
    }
 
    QGradient *clone = 0;
 
    switch (fillSource->type()) {
    case QGradient::LinearGradient:
        clone = new QLinearGradient(start, end);
        break;
    case QGradient::RadialGradient:
        clone = new QRadialGradient(start, kisDistance(start, end), focalPoint);
        break;
    case QGradient::ConicalGradient: {
        QLineF l(start, end);
        clone = new QConicalGradient(l.p1(), l.angle());
        break;
    }
    default:
        return 0;
    }
 
    clone->setCoordinateMode(fillSource->coordinateMode());
    clone->setSpread(fillSource->spread());
    clone->setStops(fillSource->stops());
 
    return clone;
}

References kisDistance().

modifyShapesStrokes()

template<typename ModifyFunction >

auto KoFlake::modifyShapesStrokes	(	QList< KoShape * >	shapes,
		ModifyFunction	modifyFunction ) -> decltype(modifyFunction(KoShapeStrokeSP()), (KUndo2Command*)(0))

Definition at line 21 of file KoFlakeUtils.h.

    {
        if (shapes.isEmpty()) return 0;
 
        QList<KoShapeStrokeModelSP> newStrokes;
 
        Q_FOREACH(KoShape *shape, shapes) {
            KoShapeStrokeSP shapeStroke = shape->stroke() ?
                qSharedPointerDynamicCast<KoShapeStroke>(shape->stroke()) :
                KoShapeStrokeSP();
 
            KoShapeStrokeSP newStroke =
                toQShared(shapeStroke ?
                              new KoShapeStroke(*shapeStroke) :
                              new KoShapeStroke());
 
            modifyFunction(newStroke);
 
            newStrokes << newStroke;
        }
 
        return new KoShapeStrokeCommand(shapes, newStrokes);
}

References KoShape::stroke(), and toQShared().

resizeShape()

void KoFlake::resizeShape	(	KoShape *	shape,
		qreal	scaleX,
		qreal	scaleY,
		const QPointF &	absoluteStillPoint,
		bool	useGlobalMode )

The basic idea of such global scaling:

1) We choose two the most distant points of the original outline rect 2) Calculate their expected position if transformed using uniformGlobalTransform 3) NOTE1: we do not transform the entire shape using uniformGlobalTransform, because it will cause massive shearing. We transform only two points and adjust other points using dumb scaling. 4) NOTE2: given that scale transform is much more simpler than uniformGlobalTransform, we cannot guarantee equivalent changes on both globalScaleX and globalScaleY at the same time. We can guarantee only one of them. Therefore we select the most "important" axis and guarantee scale along it. The scale along the other direction is not controlled. 5) After we have the two most distant points, we can just calculate the scale by dividing difference between their expected and original positions. This formula can be derived from equation:

localPoint_i * ScaleMatrix = localPoint_i * UniformGlobalTransform = expectedPoint_i

NOTE: when resizing a shape we expect top-left corner in parent's coordinates to keep it's position.

Definition at line 209 of file KoFlake.cpp.

{
    using namespace KisAlgebra2D;
 
    if (useGlobalMode) {
        const QTransform scale = QTransform::fromScale(scaleX, scaleY);
        const QTransform uniformGlobalTransform =
                shape->absoluteTransformation() *
                scale *
                shape->absoluteTransformation().inverted();
 
        const QRectF rect = shape->outlineRect();
 
        // choose the most significant scale direction
        Qt::Orientation significantOrientation = significantScaleOrientation(scaleX, scaleY);
 
        std::function<qreal(const QPointF&)> dimension;
 
        if (significantOrientation == Qt::Horizontal) {
            dimension = [] (const QPointF &pt) {
                return pt.x();
            };
 
        } else {
            dimension = [] (const QPointF &pt) {
                return pt.y();
            };
        }
 
        // find min and max points (in absolute coordinates),
        // by default use top-left and bottom-right
        QPolygonF localPoints(rect);
        QPolygonF globalPoints = shape->absoluteTransformation().map(localPoints);
 
        int minPointIndex = 0;
        int maxPointIndex = 2;
 
        findMinMaxPoints(globalPoints, &minPointIndex, &maxPointIndex, dimension);
 
        // calculate the scale using the extremum points
        const QPointF minPoint = localPoints[minPointIndex];
        const QPointF maxPoint = localPoints[maxPointIndex];
 
        const QPointF minPointExpected = uniformGlobalTransform.map(minPoint);
        const QPointF maxPointExpected = uniformGlobalTransform.map(maxPoint);
 
        scaleX = getScaleByPointsPair(minPoint.x(), maxPoint.x(),
                                      minPointExpected.x(), maxPointExpected.x());
        scaleY = getScaleByPointsPair(minPoint.y(), maxPoint.y(),
                                      minPointExpected.y(), maxPointExpected.y());
    }
 
    const QSizeF oldSize(shape->size());
    const QSizeF newSize(oldSize.width() * qAbs(scaleX), oldSize.height() * qAbs(scaleY));
 
    const QTransform mirrorTransform = QTransform::fromScale(signPZ(scaleX), signPZ(scaleY));
 
    shape->setSize(newSize);
 
    QPointF localStillPoint = shape->absoluteTransformation().inverted().map(absoluteStillPoint);
    const QTransform localStillPointOffset = QTransform::fromTranslate(-localStillPoint.x(), -localStillPoint.y());
    const QSizeF realNewSize = shape->size();
 
    const QTransform realResizeTransform =
        QTransform::fromScale(oldSize.width() > 0 ? realNewSize.width() / oldSize.width() : 1.0,
                              oldSize.height() > 0 ? realNewSize.height() / oldSize.height() : 1.0);
 
    shape->setTransformation(realResizeTransform.inverted() *
                             localStillPointOffset *
                             realResizeTransform *
                             mirrorTransform *
                             localStillPointOffset.inverted() *
                             shape->transformation()
                             );
}

References KoShape::absoluteTransformation(), KoShape::outlineRect(), KoShape::setSize(), KoShape::setTransformation(), significantScaleOrientation(), KoShape::size(), and KoShape::transformation().

resizeShapeCommon()

void KoFlake::resizeShapeCommon	(	KoShape *	shape,
		qreal	scaleX,
		qreal	scaleY,
		const QPointF &	absoluteStillPoint,
		bool	useGlobalMode,
		bool	usePostScaling,
		const QTransform &	postScalingCoveringTransform )

Definition at line 313 of file KoFlake.cpp.

{
    if (usePostScaling) {
        if (!useGlobalMode) {
            scaleShape(shape, scaleX, scaleY, absoluteStillPoint, postScalingCoveringTransform);
        } else {
            scaleShapeGlobal(shape, scaleX, scaleY, absoluteStillPoint);
        }
    } else {
        resizeShape(shape, scaleX, scaleY, absoluteStillPoint, useGlobalMode);
    }
}

References resizeShape(), scaleShape(), and scaleShapeGlobal().

scaleShape()

void KoFlake::scaleShape	(	KoShape *	shape,
		qreal	scaleX,
		qreal	scaleY,
		const QPointF &	absoluteStillPoint,
		const QTransform &	postScalingCoveringTransform )

Definition at line 176 of file KoFlake.cpp.

{
    const QTransform scale = QTransform::fromScale(scaleX, scaleY);
    QPointF localStillPoint = postScalingCoveringTransform.inverted().map(absoluteStillPoint);
    const QTransform localStillPointOffset = QTransform::fromTranslate(-localStillPoint.x(), -localStillPoint.y());
 
    shape->setTransformation( shape->transformation() *
                postScalingCoveringTransform.inverted() *
                localStillPointOffset *
                scale *
                localStillPointOffset.inverted() *
                postScalingCoveringTransform);
}

References KoShape::setTransformation(), and KoShape::transformation().

scaleShapeGlobal()

void KoFlake::scaleShapeGlobal	(	KoShape *	shape,
		qreal	scaleX,
		qreal	scaleY,
		const QPointF &	absoluteStillPoint )

Definition at line 192 of file KoFlake.cpp.

{
    const QTransform scale = QTransform::fromScale(scaleX, scaleY);
    const QTransform absoluteStillPointOffset = QTransform::fromTranslate(-absoluteStillPoint.x(), -absoluteStillPoint.y());
 
    const QTransform uniformGlobalTransform =
            shape->absoluteTransformation() *
            absoluteStillPointOffset *
            scale *
            absoluteStillPointOffset.inverted() *
            shape->absoluteTransformation().inverted() *
            shape->transformation();
 
    shape->setTransformation(uniformGlobalTransform);
}

References KoShape::absoluteTransformation(), KoShape::setTransformation(), and KoShape::transformation().

significantScaleOrientation()

Qt::Orientation KoFlake::significantScaleOrientation	(	qreal	scaleX,
		qreal	scaleY )

Definition at line 168 of file KoFlake.cpp.

{
    const qreal scaleXDeviation = qAbs(1.0 - scaleX);
    const qreal scaleYDeviation = qAbs(1.0 - scaleY);
 
    return scaleXDeviation > scaleYDeviation ? Qt::Horizontal : Qt::Vertical;
}

toAbsolute()

QPointF KoFlake::toAbsolute	(	const QPointF &	relative,
		const QSizeF &	size )

Convert relative size to absolute size

Parameters

relative	relative position
size	for which the absolute position needs to be calculated

Returns

absolute position

Definition at line 121 of file KoFlake.cpp.

{
    return QPointF(relative.x() * size.width(), relative.y() * size.height());
}

toRelative()

QPointF KoFlake::toRelative	(	const QPointF &	absolute,
		const QSizeF &	size )

Convert absolute to relative position

Parameters

absolute	absolute position
size	for which the relative position needs to be calculated

Returns

relative position

Definition at line 115 of file KoFlake.cpp.

{
    return QPointF(size.width() == 0 ? 0: absolute.x() / size.width(),
                   size.height() == 0 ? 0: absolute.y() / size.height());
}