SvgCreateTextStrategy Class Reference

#include <SvgCreateTextStrategy.h>

Inheritance diagram for SvgCreateTextStrategy:

Public Member Functions
void	cancelInteraction () override
KUndo2Command *	createCommand () override
bool	draggingInlineSize ()
void	finishInteraction (Qt::KeyboardModifiers modifiers) override
void	handleMouseMove (const QPointF &mouseLocation, Qt::KeyboardModifiers modifiers) override
bool	hasWrappingShape ()
void	paint (QPainter &painter, const KoViewConverter &converter) override
	SvgCreateTextStrategy (SvgTextTool *tool, const QPointF &clicked, KoShape *shape=nullptr)
	~SvgCreateTextStrategy () override=default
Public Member Functions inherited from KoInteractionStrategy
	KoInteractionStrategy (KoToolBase *parent)
	constructor
KoToolBase *	tool () const
virtual	~KoInteractionStrategy ()
	Destructor.

Private Attributes
QPointF	m_dragEnd
QPointF	m_dragStart
KoShape *	m_flowShape
QSizeF	m_minSizeInline
Qt::KeyboardModifiers	m_modifiers

Additional Inherited Members
Protected Member Functions inherited from KoInteractionStrategy
uint	decorationThickness () const
uint	grabSensitivity () const
	Convenience function to get the global grab sensitivity.
uint	handleRadius () const
	Convenience function to get the global handle radius.
	KoInteractionStrategy (KoInteractionStrategyPrivate &)
	constructor
Protected Attributes inherited from KoInteractionStrategy
KoInteractionStrategyPrivate *	d_ptr

Detailed Description

Definition at line 20 of file SvgCreateTextStrategy.h.

Constructor & Destructor Documentation

SvgCreateTextStrategy()

SvgCreateTextStrategy::SvgCreateTextStrategy	(	SvgTextTool *	tool,
		const QPointF &	clicked,
		KoShape *	shape = nullptr )

Definition at line 34 of file SvgCreateTextStrategy.cpp.

    : KoInteractionStrategy(tool)
    , m_dragStart(clicked)
    , m_dragEnd(clicked)
    , m_flowShape(shape)
{
    KoSvgTextProperties properties = tool->propertiesForNewText();
    properties.inheritFrom(KoSvgTextProperties::defaultProperties(), true);
    const KoSvgText::FontMetrics fontMetrics = properties.metrics(true);
    const qreal ftMultiplier = properties.fontSize().value / fontMetrics.fontSize;
    const double lineHeight = (fontMetrics.lineGap+fontMetrics.ascender+fontMetrics.descender)*ftMultiplier;
    m_minSizeInline = {lineHeight, lineHeight};
}

References KoSvgText::FontMetrics::ascender, KoSvgTextProperties::defaultProperties(), KoSvgText::FontMetrics::descender, KoSvgText::FontMetrics::fontSize, KoSvgTextProperties::fontSize(), KoSvgTextProperties::inheritFrom(), KoSvgText::FontMetrics::lineGap, m_minSizeInline, KoSvgTextProperties::metrics(), KoInteractionStrategy::tool(), and KoSvgText::CssLengthPercentage::value.

~SvgCreateTextStrategy()

SvgCreateTextStrategy::~SvgCreateTextStrategy ( )

overridedefault

Member Function Documentation

cancelInteraction()

void SvgCreateTextStrategy::cancelInteraction ( )

overridevirtual

This method will undo frames based interactions by calling createCommand() and unexecuting that.

Reimplemented from KoInteractionStrategy.

Definition at line 210 of file SvgCreateTextStrategy.cpp.

{
    tool()->canvas()->snapGuide()->reset();
    const QRectF updateRect = QRectF(m_dragStart, m_dragEnd).normalized();
    tool()->canvas()->updateCanvas(updateRect);
}

References KoToolBase::canvas(), m_dragEnd, m_dragStart, KoSnapGuide::reset(), KoCanvasBase::snapGuide, KoInteractionStrategy::tool(), and KoCanvasBase::updateCanvas().

createCommand()

KUndo2Command * SvgCreateTextStrategy::createCommand ( )

overridevirtual

For interactions that are undo-able this method should be implemented to return such a command. Implementations should return 0 otherwise.

Returns

a command, or 0.

Properties don't write their fills/strokes to svg, so we need to set those manually.

Implements KoInteractionStrategy.

Definition at line 67 of file SvgCreateTextStrategy.cpp.

{
    SvgTextTool *const tool = qobject_cast<SvgTextTool *>(this->tool());
 
    QRectF rectangle = QRectF(m_dragStart, m_dragEnd).normalized();
 
    KoSvgTextProperties properties = tool->propertiesForNewText();
    KoSvgTextProperties resolvedProperties = properties;
    resolvedProperties.inheritFrom(KoSvgTextProperties::defaultProperties(), true);
 
    const KoSvgText::FontMetrics fontMetrics = properties.metrics(true);
    const qreal ftMultiplier = resolvedProperties.fontSize().value / fontMetrics.fontSize;
    double ascender = fontMetrics.ascender;
    ascender += fontMetrics.lineGap/2;
    ascender *= ftMultiplier;
    const double lineHeight = m_minSizeInline.width();
    const KoSvgText::WritingMode writingMode = KoSvgText::WritingMode(properties.propertyOrDefault(KoSvgTextProperties::WritingModeId).toInt());
 
    bool unwrappedText = m_modifiers.testFlag(Qt::ControlModifier) || m_flowShape;
    if (rectangle.width() < m_minSizeInline.width() && rectangle.height() < m_minSizeInline.height()) {
        unwrappedText = true;
    }
    if (!unwrappedText) {
        KoSvgText::AutoValue val;
        val.isAuto = false;
        val.customValue = writingMode == KoSvgText::HorizontalTB? rectangle.width(): rectangle.height();
        properties.setProperty(KoSvgTextProperties::InlineSizeId, QVariant::fromValue(val));
    } else {
        // We explicitely remove the inline size, because it could've been inside the properties by a different method.
        properties.removeProperty(KoSvgTextProperties::InlineSizeId);
    }
    if (writingMode != KoSvgText::HorizontalTB) {
        properties.setProperty(KoSvgTextProperties::TextOrientationId, KoSvgText::OrientationUpright);
    }
    // Ensure white space is set to pre-wrap if unspecified.
    if (!properties.hasProperty(KoSvgTextProperties::TextCollapseId)) {
        properties.setProperty(KoSvgTextProperties::TextCollapseId, KoSvgText::Preserve);
    }
    if (!properties.hasProperty(KoSvgTextProperties::TextWrapId)) {
        properties.setProperty(KoSvgTextProperties::TextWrapId, KoSvgText::Wrap);
    }
 
    KoShapeFactoryBase *factory = KoShapeRegistry::instance()->value("KoSvgTextShapeID");
    KoProperties *params = new KoProperties();//Fill these with "svgText", "defs" and "shapeRect"
    params->setProperty("defs", QVariant(tool->generateDefs(properties)));
 
    QPointF origin = rectangle.topLeft();
 
    {
        const KoSvgText::TextAnchor halign = KoSvgText::TextAnchor(properties.propertyOrDefault(KoSvgTextProperties::TextAnchorId).toInt());
        const bool isRtl = KoSvgText::Direction(properties.propertyOrDefault(KoSvgTextProperties::DirectionId).toInt()) == KoSvgText::DirectionRightToLeft;
 
        if (writingMode == KoSvgText::HorizontalTB) {
            origin.setY(rectangle.top() + ascender);
            if (halign == KoSvgText::AnchorMiddle) {
                origin.setX(rectangle.center().x());
            } else if ((halign == KoSvgText::AnchorEnd && !isRtl) || (halign == KoSvgText::AnchorStart && isRtl)) {
                origin.setX(rectangle.right());
            }
        } else {
            if (writingMode == KoSvgText::VerticalRL) {
                origin.setX(rectangle.right() - (lineHeight*0.5));
            } else {
                origin.setX(rectangle.left() + (lineHeight*0.5));
            }
 
            if (halign == KoSvgText::AnchorMiddle) {
                origin.setY(rectangle.center().y());
            } else if (halign == KoSvgText::AnchorEnd) {
                origin.setY(rectangle.bottom());
            }
        }
    }
    if (!rectangle.contains(origin) && unwrappedText) {
        origin = writingMode == KoSvgText::HorizontalTB? QPointF(origin.x(), rectangle.bottom()): QPointF(rectangle.center().x(), origin.y());
    }
    params->setProperty("shapeRect", QVariant(rectangle));
    params->setProperty("origin", QVariant(origin));
 
    KoSvgTextShape *textShape = dynamic_cast<KoSvgTextShape *>(factory->createShape( params, tool->canvas()->shapeController()->resourceManager()));
 
    if (properties.hasProperty(KoSvgTextProperties::FillId)) {
        textShape->setBackground(properties.background());
    }
    if (properties.hasProperty(KoSvgTextProperties::StrokeId)) {
        textShape->setStroke(properties.stroke());
    }
 
    KUndo2Command *parentCommand = new KUndo2Command();
 
    new KoKeepShapesSelectedCommand(tool->koSelection()->selectedShapes(), {}, tool->canvas()->selectedShapesProxy(), false, parentCommand);
 
    KoShapeContainer* parent = tool->canvas()->shapeController()->documentBase()->createParentForShapes({textShape}, false, parentCommand);
    KUndo2Command *cmd = tool->canvas()->shapeController()->addShape(textShape, parent, parentCommand);
 
    parentCommand->setText(cmd->text());
 
    if (m_flowShape) {
        textShape->setPosition(m_flowShape->absolutePosition(KoFlake::TopLeft));
 
        KoPathShape *path = dynamic_cast<KoPathShape*>(m_flowShape);
        KoPathSegment segment;
        if(path) {
            segment = path->segmentAtPoint(m_dragStart, tool->handleGrabRect(m_dragStart));
        }
        if (segment.isValid()) {
            int pos = textShape->posForIndex(textShape->plainText().size());
            new KoSvgTextSetTextPathOnRangeCommand(textShape, m_flowShape, 0, pos, parentCommand);
 
            KoSvgText::TextOnPathInfo info;
            const qreal grab = tool->grabSensitivityInPt();
            QList<KoPathSegment> segments = path->segmentsAt(path->outlineRect().adjusted(-grab, -grab, grab, grab));
            Q_FOREACH(KoPathSegment s, segments) {
                if (s == segment) {
                    info.startOffset += (segment.nearestPoint(path->documentToShape(m_dragStart))*segment.length());
                    break;
                }
                info.startOffset += s.length();
                qDebug() << info.startOffset << s.length();
            }
            new KoSvgTextPathInfoChangeCommand(textShape, 2, info, parentCommand);
        } else {
            new KoSvgTextAddShapeCommand(textShape, m_flowShape, true, parentCommand);
        }
    }
 
    {
        KoSelectedShapesProxy *finalSelectionProxy = tool->canvas()->selectedShapesProxy();
        if (parent) {
            KisShapeLayer *layer = dynamic_cast<KisShapeLayer *>(parent);
            if (layer) {
                finalSelectionProxy = layer->selectedShapesProxy();
            }
        }
        new KoKeepShapesSelectedCommand({}, {textShape}, finalSelectionProxy, true, parentCommand);
    }
 
    tool->canvas()->snapGuide()->reset();
 
    return parentCommand;
}

References KoShape::absolutePosition(), KoSvgText::AnchorEnd, KoSvgText::AnchorMiddle, KoSvgText::AnchorStart, KoSvgText::FontMetrics::ascender, KoSvgTextProperties::background(), KoToolBase::canvas(), KoShapeFactoryBase::createShape(), KoSvgText::AutoValue::customValue, KoSvgTextProperties::defaultProperties(), KoSvgTextProperties::DirectionId, KoSvgText::DirectionRightToLeft, KoSvgTextProperties::FillId, KoSvgText::FontMetrics::fontSize, KoSvgTextProperties::fontSize(), KoToolBase::handleGrabRect(), KoSvgTextProperties::hasProperty(), KoSvgText::HorizontalTB, KoSvgTextProperties::inheritFrom(), KoSvgTextProperties::InlineSizeId, KoShapeRegistry::instance(), KoSvgText::AutoValue::isAuto, KoPathSegment::isValid(), KoPathSegment::length(), KoSvgText::FontMetrics::lineGap, m_dragEnd, m_dragStart, m_flowShape, m_minSizeInline, m_modifiers, KoSvgTextProperties::metrics(), KoPathSegment::nearestPoint(), KoSvgText::OrientationUpright, KoSvgTextShape::plainText, KoSvgTextShape::posForIndex(), KoSvgText::Preserve, KoSvgTextProperties::propertyOrDefault(), KoSvgTextProperties::removeProperty(), KoSnapGuide::reset(), KisShapeLayer::selectedShapesProxy(), KoCanvasBase::selectedShapesProxy(), KoSvgTextShape::setBackground(), KoShape::setPosition(), KoProperties::setProperty(), KoSvgTextProperties::setProperty(), KoSvgTextShape::setStroke(), KUndo2Command::setText(), KoCanvasBase::shapeController, KoCanvasBase::snapGuide, KoSvgText::TextOnPathInfo::startOffset, KoSvgTextProperties::stroke(), KoSvgTextProperties::StrokeId, KUndo2Command::text(), KoSvgTextProperties::TextAnchorId, KoSvgTextProperties::TextCollapseId, KoSvgTextProperties::TextOrientationId, KoSvgTextProperties::TextWrapId, KoInteractionStrategy::tool(), KoFlake::TopLeft, KoSvgText::CssLengthPercentage::value, KoGenericRegistry< T >::value(), KoSvgText::VerticalRL, KoSvgText::Wrap, and KoSvgTextProperties::WritingModeId.

draggingInlineSize()

bool SvgCreateTextStrategy::draggingInlineSize

(

)

Definition at line 222 of file SvgCreateTextStrategy.cpp.

{
    QRectF rectangle = QRectF(m_dragStart, m_dragEnd).normalized();
    return (rectangle.width() >= m_minSizeInline.width() || rectangle.height() >= m_minSizeInline.height()) && !m_modifiers.testFlag(Qt::ControlModifier);
}

References m_dragEnd, m_dragStart, m_minSizeInline, and m_modifiers.

finishInteraction()

void SvgCreateTextStrategy::finishInteraction ( Qt::KeyboardModifiers modifiers )

overridevirtual

Override to make final changes to the data on the end of an interaction.

Implements KoInteractionStrategy.

Definition at line 217 of file SvgCreateTextStrategy.cpp.

{
    m_modifiers = modifiers;
}

References m_modifiers.

handleMouseMove()

void SvgCreateTextStrategy::handleMouseMove ( const QPointF & mouseLocation, Qt::KeyboardModifiers modifiers )

overridevirtual

Extending classes should implement this method to update the selectedShapes based on the new mouse position.

Parameters

mouseLocation	the new location in pt
modifiers	OR-ed set of keys pressed.

Implements KoInteractionStrategy.

Definition at line 59 of file SvgCreateTextStrategy.cpp.

{
    m_dragEnd = this->tool()->canvas()->snapGuide()->snap(mouseLocation, modifiers);
    m_modifiers = modifiers;
    const QRectF updateRect = QRectF(m_dragStart, m_dragEnd).normalized();
    tool()->canvas()->updateCanvas(kisGrowRect(updateRect, 100));
}

References KoToolBase::canvas(), kisGrowRect(), m_dragEnd, m_dragStart, m_modifiers, KoSnapGuide::snap(), KoCanvasBase::snapGuide, KoInteractionStrategy::tool(), and KoCanvasBase::updateCanvas().

hasWrappingShape()

bool SvgCreateTextStrategy::hasWrappingShape

(

)

Definition at line 228 of file SvgCreateTextStrategy.cpp.

{
    return (m_flowShape)? true: false;
}

References m_flowShape.

paint()

void SvgCreateTextStrategy::paint ( QPainter & painter, const KoViewConverter & converter )

overridevirtual

Reimplement this if the action needs to draw a "blob" on the canvas; that is, a transient decoration like a rubber band.

Reimplemented from KoInteractionStrategy.

Definition at line 48 of file SvgCreateTextStrategy.cpp.

{
    const QTransform originalPainterTransform = painter.transform();
    painter.setTransform(converter.documentToView(), true);
    KisHandlePainterHelper handlePainter(&painter, originalPainterTransform, 0.0, decorationThickness());
 
    const QPolygonF poly(QRectF(m_dragStart, m_dragEnd));
    handlePainter.setHandleStyle(KisHandleStyle::primarySelection());
    handlePainter.drawRubberLine(poly);
}

References KoInteractionStrategy::decorationThickness(), KoViewConverter::documentToView(), KisHandlePainterHelper::drawRubberLine(), m_dragEnd, m_dragStart, KisHandleStyle::primarySelection(), and KisHandlePainterHelper::setHandleStyle().

Member Data Documentation

m_dragEnd

QPointF SvgCreateTextStrategy::m_dragEnd

private

Definition at line 37 of file SvgCreateTextStrategy.h.

m_dragStart

QPointF SvgCreateTextStrategy::m_dragStart

private

Definition at line 36 of file SvgCreateTextStrategy.h.

m_flowShape

KoShape* SvgCreateTextStrategy::m_flowShape

private

Definition at line 39 of file SvgCreateTextStrategy.h.

m_minSizeInline

QSizeF SvgCreateTextStrategy::m_minSizeInline

private

Definition at line 38 of file SvgCreateTextStrategy.h.

m_modifiers

Qt::KeyboardModifiers SvgCreateTextStrategy::m_modifiers

private

Definition at line 40 of file SvgCreateTextStrategy.h.

---

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

• plugins/tools/svgtexttool/SvgCreateTextStrategy.h
• plugins/tools/svgtexttool/SvgCreateTextStrategy.cpp