#include <SvgTextTool.h>

Inheritance diagram for SvgTextTool:

Public Member Functions
void	activate (const QSet< KoShape * > &shapes) override
	reimplemented from KoToolBase

void	copy () const override
	reimplemented from superclass

void	deactivate () override
	reimplemented from KoToolBase

QRectF	decorationsRect () const override
	reimplemented from KoToolBase

void	deleteSelection () override
	reimplemented from superclass

void	deselect () override
	deselect the tool should clear the selection if it has one.

void	focusInEvent (QFocusEvent *event) override

void	focusOutEvent (QFocusEvent *event) override

bool	hasSelection () override
	reimplemented from superclass

void	inputMethodEvent (QInputMethodEvent *event) override

QVariant	inputMethodQuery (Qt::InputMethodQuery query) const override

void	keyPressEvent (QKeyEvent *event) override

void	keyReleaseEvent (QKeyEvent *event) override

void	mouseDoubleClickEvent (KoPointerEvent *event) override
	reimplemented from superclass

void	mouseMoveEvent (KoPointerEvent *event) override
	reimplemented from KoToolBase

void	mousePressEvent (KoPointerEvent *event) override
	reimplemented from KoToolBase

void	mouseReleaseEvent (KoPointerEvent *event) override
	reimplemented from KoToolBase

void	mouseTripleClickEvent (KoPointerEvent *event) override
	reimplemented from KoToolBase

void	paint (QPainter &gc, const KoViewConverter &converter) override
	reimplemented from KoToolBase

bool	paste () override
	reimplemented from superclass

KisPopupWidgetInterface *	popupWidget () override

void	requestStrokeCancellation () override

void	requestStrokeEnd () override

bool	selectAll () override
	selectAll select all data the tool can select.

KoToolSelection *	selection () override
	reimplemented from superclass

	SvgTextTool (KoCanvasBase *canvas)

	~SvgTextTool () override

Public Member Functions inherited from KoToolBase
QAction *	action (const QString &name) const

KoCanvasBase *	canvas () const
	Returns the canvas the tool is working on.

QCursor	cursor () const
	return the last emitted cursor

virtual void	customMoveEvent (KoPointerEvent *event)

virtual void	customPressEvent (KoPointerEvent *event)

virtual void	customReleaseEvent (KoPointerEvent *event)

virtual void	cut ()

int	decorationThickness () const
	decorationThickness The minimum thickness for tool decoration lines, this is derived from the screen magnification, thus the HiDPI settings. Note: to use this effectively, also set the pen to isCosmetic(true);

virtual void	dragLeaveEvent (QDragLeaveEvent *event)

virtual void	dragMoveEvent (QDragMoveEvent *event, const QPointF &point)

virtual void	dropEvent (QDropEvent *event, const QPointF &point)

virtual void	explicitUserStrokeEndRequest ()
	explicitUserStrokeEndRequest is called by the input manager when the user presses Enter key or any equivalent. This callback comes before requestStrokeEnd(), which comes from a different source.

KoToolFactoryBase *	factory () const

bool	isInTextMode () const

bool	isOpacityPresetMode () const

	KoToolBase (KoCanvasBase *canvas)

bool	maskSyntheticEvents () const

QList< QPointer< QWidget > >	optionWidgets ()

virtual QMenu *	popupActionsMenu ()

Q_INVOKABLE QString	toolId () const

virtual bool	wantsAutoScroll () const

	~KoToolBase () override

Protected Member Functions
virtual QWidget *	createOptionWidget () override
	reimplemented from KoToolBase

KoSelection *	koSelection () const

KoSvgTextShape *	selectedShape () const

Protected Member Functions inherited from KoToolBase
virtual QList< QPointer< QWidget > >	createOptionWidgets ()

int	grabSensitivity () const
	Convenience function to get the current grab sensitivity.

qreal	handleDocRadius () const

QRectF	handleGrabRect (const QPointF &position) const

QRectF	handlePaintRect (const QPointF &position) const

int	handleRadius () const
	Convenience function to get the current handle radius.

bool	isActivated () const

	KoToolBase (KoToolBasePrivate &dd)

KoPointerEvent *	lastDeliveredPointerEvent () const

void	setAbstractResource (KoAbstractCanvasResourceInterfaceSP abstractResource)

void	setConverter (KoDerivedResourceConverterSP converter)

void	setIsOpacityPresetMode (bool value)

void	setMaskSyntheticEvents (bool value)

void	setTextMode (bool value)

QHash< int, KoAbstractCanvasResourceInterfaceSP >	toolAbstractResources ()

QHash< int, KoDerivedResourceConverterSP >	toolConverters ()

void	useCursor (const QCursor &cursor)

Private Types
enum class	DragMode { None = 0 , Create , Select , InlineSizeHandle , Move , TextPathHandle , InShapeOffset , TypeSetting }

enum class	HighlightItem { None = 0 , InlineSizeStartHandle , InlineSizeEndHandle , MoveBorder , TypeSettingHandle }

Private Slots
QString	generateDefs (const KoSvgTextProperties &properties=KoSvgTextProperties())
	generateDefs This generates a defs section with the appropriate css and css strings assigned.

void	insertRichText (KoSvgTextShape *richText, bool replaceLastGlyph=false)
	insertRichText Insert a rich text shape, used by the glyph palette..

KoSvgTextProperties	propertiesForNewText () const
	propertiesForNewText get the text properties that should be used for new text.

void	showEditor ()

void	showGlyphPalette ()
	showGlyphPalette Shows the glyph palette dialog.

void	slotConvertType (int index)
	slotConvertType

void	slotMoveTextSelection (int index)
	slotMoveTextSelection Move the start of the selection in typesetting mode by image 1 pix.

void	slotShapeSelectionChanged ()
	selectionChanged called when the canvas selection is changed.

void	slotTextTypeUpdated ()
	slotTextTypeUpdated Update the text type in the tool options.

void	slotUpdateCursorDecoration (QRectF updateRect)
	updateCursor update the canvas decorations in a particular update rect for the text cursor.

void	slotUpdateTextPasteBehaviour ()
	slotUpdateTextPasteBehaviour update the default text paste behaviour.

void	slotUpdateTypeSettingMode ()
	slotUpdateTypeSettingMode Enable typesetting mode from the tool options.

void	slotUpdateVisualCursor ()
	slotUpdateVisualCursor update the visual cursor mode on the text cursor.

void	textUpdated (KoSvgTextShape *shape, const QString &svg, const QString &defs)

void	updateGlyphPalette ()
	updateGlyphPalette update the glyph palette dialog from the current selection.

void	updateTextPathHelper ()

Private Member Functions
void	addMappedAction (KisSignalMapper mapper, const QString &actionName, const int value, QActionGroup group=nullptr)

qreal	grabSensitivityInPt () const

bool	nodeEditable ()
	nodeEditable

KoSvgText::WritingMode	writingMode () const

Private Attributes
QCursor	m_base_cursor

KisSignalAutoConnectionsStore	m_canvasConnections

DragMode	m_dragging {DragMode::None}

QPointer< SvgTextEditor >	m_editor

QPointer< GlyphPaletteDialog >	m_glyphPalette

HighlightItem	m_highlightItem {HighlightItem::None}

QPainterPath	m_hoveredShapeHighlightRect

QCursor	m_ibeam_horizontal

QCursor	m_ibeam_horizontal_done

QCursor	m_ibeam_vertical

std::unique_ptr< KoInteractionStrategy >	m_interactionStrategy

QPointF	m_lastMousePos

QScopedPointer< SvgTextToolOptionsManager >	m_optionManager

bool	m_strategyAddingCommand {false}

QCursor	m_text_in_shape

QCursor	m_text_inline_horizontal

QCursor	m_text_inline_vertical

QCursor	m_text_on_path

SvgTextCursor	m_textCursor

SvgTextOnPathDecorationHelper	m_textOnPathHelper

QScopedPointer< KoSvgTextShapeOutlineHelper >	m_textOutlineHelper

QScopedPointer< KisSignalMapper >	m_textTypeSignalsMapper

QScopedPointer< KisSignalMapper >	m_typeSettingMovementMapper

Friends
class	SvgChangeTextPathInfoStrategy

class	SvgCreateTextStrategy

Additional Inherited Members
Public Slots inherited from KoToolBase
virtual void	canvasResourceChanged (int key, const QVariant &res)

virtual void	documentResourceChanged (int key, const QVariant &res)

virtual void	repaintDecorations ()

virtual void	requestRedoDuringStroke ()

virtual void	requestUndoDuringStroke ()

void	setStatusText (const QString &statusText)

void	updateOptionsWidgetIcons ()

Signals inherited from KoToolBase
void	activateTool (const QString &id)

void	cursorChanged (const QCursor &cursor)

void	selectionChanged (bool hasSelection)

void	statusTextChanged (const QString &statusText)

void	textModeChanged (bool inTextMode)

Protected Attributes inherited from KoToolBase
KoToolBasePrivate *	d_ptr

Detailed Description

Definition at line 35 of file SvgTextTool.h.

Member Enumeration Documentation

◆ DragMode

enum class SvgTextTool::DragMode

strongprivate

Enumerator
None
Create
Select
InlineSizeHandle
Move
TextPathHandle
InShapeOffset
TypeSetting

Definition at line 204 of file SvgTextTool.h.

                        {
        None = 0,
        Create,
        Select,
        InlineSizeHandle,
        Move,
        TextPathHandle,
        InShapeOffset,
        TypeSetting,
    };

◆ HighlightItem

enum class SvgTextTool::HighlightItem

strongprivate

Enumerator
None
InlineSizeStartHandle
InlineSizeEndHandle
MoveBorder
TypeSettingHandle

Definition at line 214 of file SvgTextTool.h.

                             {
        None = 0,
        InlineSizeStartHandle,
        InlineSizeEndHandle,
        MoveBorder,
        TypeSettingHandle,
    };

Constructor & Destructor Documentation

◆ SvgTextTool()

SvgTextTool::SvgTextTool ( KoCanvasBase * canvas )

explicit

Definition at line 100 of file SvgTextTool.cpp.

    : KoToolBase(canvas)
    , m_optionManager(new SvgTextToolOptionsManager(this))
    , m_textCursor(canvas)
    , m_textOutlineHelper(new KoSvgTextShapeOutlineHelper(canvas))
{
     // TODO: figure out whether we should use system config for this, Windows and GTK have values for it, but Qt and MacOS don't(?).
    const int cursorFlashLimit = 5000;
    const bool enableCursorWithSelection = QApplication::style()->styleHint(QStyle::SH_BlinkCursorWhenTextSelected);
    m_textCursor.setCaretSetting(QApplication::style()->pixelMetric(QStyle::PM_TextCursorWidth)
                                 , qApp->cursorFlashTime()
                                 , cursorFlashLimit
                                 , enableCursorWithSelection);
    connect(&m_textCursor, SIGNAL(updateCursorDecoration(QRectF)), this, SLOT(slotUpdateCursorDecoration(QRectF)));
 
    Q_FOREACH(const QString name, SvgTextShortCuts::possibleActions()) {
        QAction *a = action(name);
        if(m_textCursor.registerPropertyAction(a, name)) {
            dbgTools << "registered" << name << a->shortcut();
        }
    }
 
    const QStringList extraActions = {
        "svg_insert_special_character",
        "svg_paste_rich_text",
        "svg_paste_plain_text",
        "svg_remove_transforms_from_range",
        "svg_clear_formatting"
    };
    connect(&m_textCursor, SIGNAL(sigOpenGlyphPalette()), this, SLOT(showGlyphPalette()));
    Q_FOREACH (const QString name, extraActions) {
        QAction *a = action(name);
        if (a) {
            if(!m_textCursor.registerPropertyAction(a, name)) {
                qWarning() << "could not register" << name << a->shortcut();
            }
        }
    }
 
    m_textTypeSignalsMapper.reset(new KisSignalMapper(this));
    QActionGroup *textTypeActions = new QActionGroup(this);
    addMappedAction(m_textTypeSignalsMapper.data(), "text_type_preformatted", KoSvgTextShape::PreformattedText, textTypeActions);
    addMappedAction(m_textTypeSignalsMapper.data(), "text_type_inline_wrap", KoSvgTextShape::InlineWrap, textTypeActions);
    addMappedAction(m_textTypeSignalsMapper.data(), "text_type_pre_positioned", KoSvgTextShape::PrePositionedText, textTypeActions);
 
    m_typeSettingMovementMapper.reset(new KisSignalMapper(this));
    QActionGroup *typeSettingActions = new QActionGroup(this);
    addMappedAction(m_typeSettingMovementMapper.data(), "svg_type_setting_move_selection_start_down_1_px", Qt::Key_Down, typeSettingActions);
    addMappedAction(m_typeSettingMovementMapper.data(), "svg_type_setting_move_selection_start_up_1_px", Qt::Key_Up, typeSettingActions);
    addMappedAction(m_typeSettingMovementMapper.data(), "svg_type_setting_move_selection_start_left_1_px", Qt::Key_Left, typeSettingActions);
    addMappedAction(m_typeSettingMovementMapper.data(), "svg_type_setting_move_selection_start_right_1_px", Qt::Key_Right, typeSettingActions);
 
    m_textOutlineHelper->setDrawBoundingRect(false);
    m_textOutlineHelper->setDrawTextWrappingArea(true);
 
    connect(&m_textCursor, SIGNAL(selectionChanged()), this, SLOT(updateTextPathHelper()));
 
    m_base_cursor = QCursor(QPixmap(":/tool_text_basic.xpm"), 7, 7);
    m_text_inline_horizontal = QCursor(QPixmap(":/tool_text_inline_horizontal.xpm"), 7, 7);
    m_text_inline_vertical = QCursor(QPixmap(":/tool_text_inline_vertical.xpm"), 7, 7);
    m_text_on_path = QCursor(QPixmap(":/tool_text_on_path.xpm"), 7, 7);
    m_text_in_shape = QCursor(QPixmap(":/tool_text_in_shape.xpm"), 7, 7);
    m_ibeam_horizontal = QCursor(QPixmap(":/tool_text_i_beam_horizontal.xpm"), 11, 11);
    m_ibeam_vertical = QCursor(QPixmap(":/tool_text_i_beam_vertical.xpm"), 11, 11);
    m_ibeam_horizontal_done = QCursor(QPixmap(":/tool_text_i_beam_horizontal_done.xpm"), 5, 11);
}

References KoToolBase::action(), addMappedAction(), dbgTools, KoSvgTextShape::InlineWrap, m_base_cursor, m_ibeam_horizontal, m_ibeam_horizontal_done, m_ibeam_vertical, m_text_in_shape, m_text_inline_horizontal, m_text_inline_vertical, m_text_on_path, m_textCursor, m_textOutlineHelper, m_textTypeSignalsMapper, m_typeSettingMovementMapper, SvgTextShortCuts::possibleActions(), KoSvgTextShape::PreformattedText, KoSvgTextShape::PrePositionedText, SvgTextCursor::registerPropertyAction(), KoToolBase::selectionChanged(), SvgTextCursor::setCaretSetting(), showGlyphPalette(), slotUpdateCursorDecoration(), and updateTextPathHelper().

◆ ~SvgTextTool()

SvgTextTool::~SvgTextTool ( )

override

Definition at line 167 of file SvgTextTool.cpp.

{
    if(m_editor) {
        m_editor->close();
    }
    if(m_glyphPalette) {
        m_glyphPalette->close();
    }
}

References m_editor, and m_glyphPalette.

Member Function Documentation

◆ activate()

void SvgTextTool::activate ( const QSet< KoShape * > & shapes )

overridevirtual

reimplemented from KoToolBase

Reimplemented from KoToolBase.

Definition at line 177 of file SvgTextTool.cpp.

{
    KoToolBase::activate(shapes);
    m_canvasConnections.addConnection(canvas()->selectedShapesProxy(), SIGNAL(selectionChanged()), this, SLOT(slotShapeSelectionChanged()));
 
    KisCanvas2 *canvas2 = qobject_cast<KisCanvas2 *>(this->canvas());
    if (canvas2) {
        canvas2->setCurrentShapeManagerOwnerShape(nullptr);
        canvas2->viewManager()->textPropertyManager()->setTextPropertiesInterface(m_textCursor.textPropertyInterface());
        QDockWidget *docker = canvas2->viewManager()->mainWindow()->dockWidget("TextProperties");
        if (docker && m_optionManager) {
            m_optionManager->setTextPropertiesOpen(docker->isVisible());
        }
    }
 
    connect(m_textTypeSignalsMapper.data(), SIGNAL(mapped(int)), this, SLOT(slotConvertType(int)));
    connect(m_typeSettingMovementMapper.data(), SIGNAL(mapped(int)), this, SLOT(slotMoveTextSelection(int)));
 
    useCursor(m_base_cursor);
    slotShapeSelectionChanged();
 
    repaintDecorations();
}

References KoToolBase::activate(), KisSignalAutoConnectionsStore::addConnection(), KoToolBase::canvas(), KisMainWindow::dockWidget(), m_base_cursor, m_canvasConnections, m_optionManager, m_textCursor, m_textTypeSignalsMapper, m_typeSettingMovementMapper, KisViewManager::mainWindow(), KoToolBase::repaintDecorations(), KoToolBase::selectionChanged(), KisCanvas2::setCurrentShapeManagerOwnerShape(), KisTextPropertiesManager::setTextPropertiesInterface(), slotConvertType(), slotMoveTextSelection(), slotShapeSelectionChanged(), SvgTextCursor::textPropertyInterface(), KisViewManager::textPropertyManager(), KoToolBase::useCursor(), and KisCanvas2::viewManager().

◆ addMappedAction()

void SvgTextTool::addMappedAction	(	KisSignalMapper *	mapper,
		const QString &	actionName,
		const int	value,
		QActionGroup *	group = nullptr )

private

Definition at line 1137 of file SvgTextTool.cpp.

{
    QAction *a = action(actionName);
    if (a) {
        connect(a, SIGNAL(triggered()), mapper, SLOT(map()));
        mapper->setMapping(a, value);
        m_textCursor.registerPropertyAction(a, actionName);
        if (group && !a->actionGroup()) {
            group->addAction(a);
        }
    }
}

References KoToolBase::action(), m_textCursor, SvgTextCursor::registerPropertyAction(), KisSignalMapper::setMapping(), and value().

◆ copy()

void SvgTextTool::copy ( ) const

overridevirtual

reimplemented from superclass

Reimplemented from KoToolBase.

Definition at line 473 of file SvgTextTool.cpp.

{
    m_textCursor.copy();
}

References SvgTextCursor::copy(), and m_textCursor.

◆ createOptionWidget()

QWidget * SvgTextTool::createOptionWidget ( )

overrideprotectedvirtual

reimplemented from KoToolBase

Reimplemented from KoToolBase.

Definition at line 238 of file SvgTextTool.cpp.

{
    KisQQuickWidget *optionWidget = new KisQQuickWidget();
    optionWidget->setMinimumWidth(100);
    optionWidget->setMinimumHeight(100);
 
    optionWidget->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
    optionWidget->setSource(QUrl("qrc:/SvgTextToolOptions.qml"));
 
    m_optionManager->optionsModel()->setConfigName(this->toolId());
    m_optionManager->setShowDebug(debugEnabled());
    if (optionWidget->errors().isEmpty()) {
        optionWidget->rootObject()->setProperty("manager", QVariant::fromValue(m_optionManager.data()));
        optionWidget->connectMinimumHeightToRootObject();
    } else {
        qWarning() << optionWidget->errors();
    }
 
 
    connect(m_optionManager.data(), SIGNAL(openTextEditor()), SLOT(showEditor()));
    connect(m_optionManager.data(), SIGNAL(openGlyphPalette()), SLOT(showGlyphPalette()));
 
    connect(m_optionManager.data(), SIGNAL(convertTextType(int)), SLOT(slotConvertType(int)));
    connect(m_optionManager.data(), SIGNAL(typeSettingModeChanged()), SLOT(slotUpdateTypeSettingMode()));
    connect(m_optionManager->optionsModel(), SIGNAL(useVisualBidiCursorChanged(bool)), this, SLOT(slotUpdateVisualCursor()));
    connect(m_optionManager->optionsModel(), SIGNAL(pasteRichtTextByDefaultChanged(bool)), this, SLOT(slotUpdateTextPasteBehaviour()));
    const KisCanvas2 *canvas2 = qobject_cast<const KisCanvas2 *>(this->canvas());
    if (canvas2 && canvas2->viewManager()->mainWindow()) {
        QDockWidget *docker = canvas2->viewManager()->mainWindow()->dockWidget("TextProperties");
        m_optionManager->setShowTextPropertyButton((docker));
        if (docker) {
            optionWidget->setPalette(docker->palette());
            m_optionManager->setTextPropertiesOpen(docker->isVisible());
            connect(m_optionManager.data(), &SvgTextToolOptionsManager::openTextPropertiesDocker, [docker](){
                        docker->setVisible(!docker->isVisible());
                    });
            // Once we have docker toggling actions, we should revisit this.
        }
    }
    slotUpdateVisualCursor();
    slotUpdateTextPasteBehaviour();
    slotTextTypeUpdated();
 
 
    return optionWidget;
}

References KoToolBase::canvas(), KisQQuickWidget::connectMinimumHeightToRootObject(), debugEnabled(), KisMainWindow::dockWidget(), m_optionManager, KisViewManager::mainWindow(), SvgTextToolOptionsManager::openTextPropertiesDocker(), showEditor(), showGlyphPalette(), slotConvertType(), slotTextTypeUpdated(), slotUpdateTextPasteBehaviour(), slotUpdateTypeSettingMode(), slotUpdateVisualCursor(), KoToolBase::toolId(), and KisCanvas2::viewManager().

◆ deactivate()

void SvgTextTool::deactivate ( )

overridevirtual

reimplemented from KoToolBase

Reimplemented from KoToolBase.

Definition at line 201 of file SvgTextTool.cpp.

{
    KoToolBase::deactivate();
    m_canvasConnections.clear();
    m_textCursor.setShape(nullptr);
    const KisCanvas2 *canvas2 = qobject_cast<const KisCanvas2 *>(this->canvas());
    if (canvas2) {
        canvas2->viewManager()->textPropertyManager()->setTextPropertiesInterface(nullptr);
    }
    // Exiting text editing mode is handled by requestStrokeEnd
    disconnect(m_textTypeSignalsMapper.data(), 0, this, 0);
    disconnect(m_typeSettingMovementMapper.data(), 0, this, 0);
 
    m_hoveredShapeHighlightRect = QPainterPath();
 
    repaintDecorations();
}

References KoToolBase::canvas(), KisSignalAutoConnectionsStore::clear(), KoToolBase::deactivate(), m_canvasConnections, m_hoveredShapeHighlightRect, m_textCursor, m_textTypeSignalsMapper, m_typeSettingMovementMapper, KoToolBase::repaintDecorations(), SvgTextCursor::setShape(), KisTextPropertiesManager::setTextPropertiesInterface(), KisViewManager::textPropertyManager(), and KisCanvas2::viewManager().

◆ decorationsRect()

QRectF SvgTextTool::decorationsRect ( ) const

overridevirtual

reimplemented from KoToolBase

Reimplemented from KoToolBase.

Definition at line 652 of file SvgTextTool.cpp.

{
    QRectF rect;
    KoSvgTextShape *const shape = selectedShape();
    if (shape) {
        rect |= shape->boundingRect();
 
        const QPointF anchor = shape->absoluteTransformation().map(QPointF());
        rect |= kisGrowRect(QRectF(anchor, anchor), handleRadius());
 
        qreal pxlToPt = canvas()->viewConverter()->viewToDocumentX(1.0);
        qreal length = (INLINE_SIZE_DASHES_PATTERN_A + INLINE_SIZE_DASHES_PATTERN_B) * INLINE_SIZE_DASHES_PATTERN_LENGTH;
 
        if (std::optional<InlineSizeInfo> info = InlineSizeInfo::fromShape(shape, length * pxlToPt)) {
            rect |= kisGrowRect(info->boundingRect(), handleRadius() * 2);
        }
 
        if (canvas()->snapGuide()->isSnapping()) {
            rect |= canvas()->snapGuide()->boundingRect();
        }
    }
 
    rect |= m_hoveredShapeHighlightRect.boundingRect();
 
    rect |= m_textOutlineHelper->decorationRect();
    rect |= m_textOnPathHelper.decorationRect(canvas()->viewConverter()->documentToView());
 
    return rect;
}

References KoShape::absoluteTransformation(), KoSnapGuide::boundingRect(), KoSvgTextShape::boundingRect(), KoToolBase::canvas(), SvgTextOnPathDecorationHelper::decorationRect(), KoToolBase::handleRadius(), INLINE_SIZE_DASHES_PATTERN_A, INLINE_SIZE_DASHES_PATTERN_B, INLINE_SIZE_DASHES_PATTERN_LENGTH, kisGrowRect(), length(), m_hoveredShapeHighlightRect, m_textOnPathHelper, m_textOutlineHelper, selectedShape(), KoCanvasBase::snapGuide, KoCanvasBase::viewConverter(), and KoViewConverter::viewToDocumentX().

◆ deleteSelection()

void SvgTextTool::deleteSelection ( )

overridevirtual

reimplemented from superclass

Reimplemented from KoToolBase.

Definition at line 478 of file SvgTextTool.cpp.

{
    m_textCursor.removeSelection();
}

References m_textCursor, and SvgTextCursor::removeSelection().

◆ deselect()

void SvgTextTool::deselect ( )

overridevirtual

deselect the tool should clear the selection if it has one.

Reimplemented from KoToolBase.

Definition at line 500 of file SvgTextTool.cpp.

{
    m_textCursor.deselectText();
}

References SvgTextCursor::deselectText(), and m_textCursor.

◆ focusInEvent()

void SvgTextTool::focusInEvent ( QFocusEvent * event )

overridevirtual

This passes on the focusInEven from the canvas widget, which can be used to activate animating decorations (like a cursor blink effect in the text tool).

Reimplemented from KoToolBase.

Definition at line 1087 of file SvgTextTool.cpp.

{
    m_textCursor.focusIn();
    event->accept();
}

References SvgTextCursor::focusIn(), and m_textCursor.

◆ focusOutEvent()

void SvgTextTool::focusOutEvent ( QFocusEvent * event )

overridevirtual

This passes on the focusInEven from the canvas widget, which can be used to deactivate animating decorations (like a cursor blink effect in the text tool).

Reimplemented from KoToolBase.

Definition at line 1093 of file SvgTextTool.cpp.

{
    m_textCursor.focusOut();
    event->accept();
}

References SvgTextCursor::focusOut(), and m_textCursor.

◆ generateDefs

QString SvgTextTool::generateDefs ( const KoSvgTextProperties & properties = KoSvgTextProperties() )

privateslot

generateDefs This generates a defs section with the appropriate css and css strings assigned.

Definition at line 384 of file SvgTextTool.cpp.

{
    QStringList propStrings;
    QMap<QString, QString> paraProps = properties.convertParagraphProperties();
    for (auto it = paraProps.constBegin(); it != paraProps.constEnd(); it++) {
        propStrings.append(QString("%1: %2;").arg(it.key()).arg(it.value()));
    }
    paraProps = properties.convertToSvgTextAttributes();
    for (auto it = paraProps.constBegin(); it != paraProps.constEnd(); it++) {
        propStrings.append(QString("%1: %2;").arg(it.key()).arg(it.value()));
    }
 
    return QString("<defs>\n <style>\n  text {\n   %1\n  }\n </style>\n</defs>").arg(propStrings.join("\n   "));
}

References KoSvgTextProperties::convertParagraphProperties(), and KoSvgTextProperties::convertToSvgTextAttributes().

◆ grabSensitivityInPt()

qreal SvgTextTool::grabSensitivityInPt ( ) const

private

Definition at line 1125 of file SvgTextTool.cpp.

{
    const int sensitivity = grabSensitivity();
    return canvas()->viewConverter()->viewToDocumentX(sensitivity);
}

References KoToolBase::canvas(), KoToolBase::grabSensitivity(), KoCanvasBase::viewConverter(), and KoViewConverter::viewToDocumentX().

◆ hasSelection()

bool SvgTextTool::hasSelection ( )

overridevirtual

reimplemented from superclass

Reimplemented from KoToolBase.

Definition at line 488 of file SvgTextTool.cpp.

{
    return m_textCursor.hasSelection();
}

References SvgTextCursor::hasSelection(), and m_textCursor.

◆ inputMethodEvent()

void SvgTextTool::inputMethodEvent ( QInputMethodEvent * event )

overridevirtual

Text entry of complex text, like CJK, can be made more interactive if a tool implements this and the InputMethodQuery() methods. Reimplementing this only provides the user with a more responsive text experience, since the default implementation forwards the typed text as key pressed events.

Parameters

event the input method event.

Reimplemented from KoToolBase.

Definition at line 233 of file SvgTextTool.cpp.

{
    m_textCursor.inputMethodEvent(event);
}

References SvgTextCursor::inputMethodEvent(), and m_textCursor.

◆ inputMethodQuery()

QVariant SvgTextTool::inputMethodQuery ( Qt::InputMethodQuery query ) const

overridevirtual

This method is used to query a set of properties of the tool to be able to support complex input method operations as support for surrounding text and reconversions. Default implementation returns simple defaults, for tools that want to provide a more responsive text entry experience for CJK languages it would be good to reimplement.

Parameters

query	specifies which property is queried.
converter	the view converter for the current canvas.

Reimplemented from KoToolBase.

Definition at line 224 of file SvgTextTool.cpp.

{
    if (canvas()) {
        return m_textCursor.inputMethodQuery(query);
    } else {
        return KoToolBase::inputMethodQuery(query);
    }
}

References KoToolBase::canvas(), KoToolBase::inputMethodQuery(), SvgTextCursor::inputMethodQuery(), and m_textCursor.

◆ insertRichText

void SvgTextTool::insertRichText	(	KoSvgTextShape *	richText,
		bool	replaceLastGlyph = false )

privateslot

insertRichText Insert a rich text shape, used by the glyph palette..

Parameters

richText	– rich text shape.
replaceLastGlyph	– whether to replace the last glyph or to fully insert.

Definition at line 375 of file SvgTextTool.cpp.

{
    if (replaceLastGlyph) {
        m_textCursor.setPos(m_textCursor.getPos(), m_textCursor.getPos());
        m_textCursor.moveCursor(m_textCursor.getPos() == 0? SvgTextCursor::MoveNextChar : SvgTextCursor::MovePreviousChar, false);
    }
    m_textCursor.insertRichText(richText, true);
}

References SvgTextCursor::getPos(), SvgTextCursor::insertRichText(), m_textCursor, SvgTextCursor::moveCursor(), SvgTextCursor::MoveNextChar, SvgTextCursor::MovePreviousChar, and SvgTextCursor::setPos().

◆ keyPressEvent()

void SvgTextTool::keyPressEvent ( QKeyEvent * event )

overridevirtual

Called when a key is pressed. Implementors should call event->ignore() if they do not actually use the event. Default implementation ignores this event.

Parameters

event state and reason of this key press

Reimplemented from KoToolBase.

Definition at line 1057 of file SvgTextTool.cpp.

{
    if (m_interactionStrategy
            && (event->key() == Qt::Key_Control || event->key() == Qt::Key_Alt || event->key() == Qt::Key_Shift
                || event->key() == Qt::Key_Meta)) {
        m_interactionStrategy->handleMouseMove(m_lastMousePos, event->modifiers());
        event->accept();
        return;
    } else if (event->key() == Qt::Key_Escape) {
        requestStrokeEnd();
    } else if (selectedShape()) {
        m_textCursor.keyPressEvent(event);
    }
 
    event->ignore();
}

References SvgTextCursor::keyPressEvent(), m_interactionStrategy, m_lastMousePos, m_textCursor, requestStrokeEnd(), and selectedShape().

◆ keyReleaseEvent()

void SvgTextTool::keyReleaseEvent ( QKeyEvent * event )

overridevirtual

Called when a key is released Implementors should call event->ignore() if they do not actually use the event. Default implementation ignores this event.

Parameters

event state and reason of this key release

Reimplemented from KoToolBase.

Definition at line 1074 of file SvgTextTool.cpp.

{
    m_textCursor.updateModifiers(event->modifiers());
    if (m_interactionStrategy
            && (event->key() == Qt::Key_Control || event->key() == Qt::Key_Alt || event->key() == Qt::Key_Shift
                || event->key() == Qt::Key_Meta)) {
        m_interactionStrategy->handleMouseMove(m_lastMousePos, event->modifiers());
        event->accept();
    } else {
        event->ignore();
    }
}

References m_interactionStrategy, m_lastMousePos, m_textCursor, and SvgTextCursor::updateModifiers().

◆ koSelection()

KoSelection * SvgTextTool::koSelection ( ) const

protected

Definition at line 285 of file SvgTextTool.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(canvas(), 0);
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(canvas()->selectedShapesProxy(), 0);
 
    return canvas()->selectedShapesProxy()->selection();
}

References KoToolBase::canvas(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, KoCanvasBase::selectedShapesProxy(), and KoSelectedShapesProxy::selection().

◆ mouseDoubleClickEvent()

void SvgTextTool::mouseDoubleClickEvent ( KoPointerEvent * event )

overridevirtual

reimplemented from superclass

Reimplemented from KoToolBase.

Definition at line 1099 of file SvgTextTool.cpp.

{
    if (canvas()->shapeManager()->shapeAt(event->point) != selectedShape()) {
        event->ignore(); // allow the event to be used by another
        return;
    } else {
        m_textCursor.setPosToPoint(event->point, true);
        m_textCursor.moveCursor(SvgTextCursor::MoveWordLeft, true);
        m_textCursor.moveCursor(SvgTextCursor::MoveWordRight, false);
    }
    const QRectF updateRect = std::exchange(m_hoveredShapeHighlightRect, QPainterPath()).boundingRect();
    canvas()->updateCanvas(kisGrowRect(updateRect, 100));
    event->accept();
}

References KoToolBase::canvas(), kisGrowRect(), m_hoveredShapeHighlightRect, m_textCursor, SvgTextCursor::moveCursor(), SvgTextCursor::MoveWordLeft, SvgTextCursor::MoveWordRight, KoPointerEvent::point, selectedShape(), SvgTextCursor::setPosToPoint(), and KoCanvasBase::updateCanvas().

◆ mouseMoveEvent()

void SvgTextTool::mouseMoveEvent ( KoPointerEvent * event )

overridevirtual

reimplemented from KoToolBase

Implements KoToolBase.

Definition at line 906 of file SvgTextTool.cpp.

{
    m_lastMousePos = event->point;
    m_hoveredShapeHighlightRect = QPainterPath();
    m_textCursor.updateModifiers(event->modifiers());
 
    if (m_interactionStrategy) {
        m_interactionStrategy->handleMouseMove(event->point, event->modifiers());
        if (m_dragging == DragMode::Create) {
            SvgCreateTextStrategy *c = dynamic_cast<SvgCreateTextStrategy*>(m_interactionStrategy.get());
            if (c && c->draggingInlineSize() && !c->hasWrappingShape()) {
                if (this->writingMode() == KoSvgText::HorizontalTB) {
                    useCursor(m_text_inline_horizontal);
                } else {
                    useCursor(m_text_inline_vertical);
                }
            } else {
                useCursor(m_base_cursor);
            }
        } else if (m_dragging == DragMode::Select && this->selectedShape()) {
            KoSvgTextShape *const selectedShape = this->selectedShape();
            // Todo: replace with something a little less hacky.
            if (selectedShape->writingMode() == KoSvgText::HorizontalTB) {
                useCursor(m_ibeam_horizontal);
            } else {
                useCursor(m_ibeam_vertical);
            }
        } else if (m_dragging != DragMode::InShapeOffset) {
            useCursor(Qt::ArrowCursor);
        }
        event->accept();
    } else {
        m_highlightItem = HighlightItem::None;
 
        KoSvgTextShape *const selectedShape = this->selectedShape();
        QCursor cursor = m_base_cursor;
        if (selectedShape) {
            cursor = m_ibeam_horizontal_done;
            const qreal sensitivity = grabSensitivityInPt();
 
            SvgTextCursor::TypeSettingModeHandle handle = m_textCursor.typeSettingHandleAtPos(handleGrabRect(event->point));
            m_textCursor.setTypeSettingHandleHovered(handle);
            if (handle != SvgTextCursor::NoHandle) {
                cursor = m_textCursor.cursorTypeForTypeSetting();
                m_highlightItem = HighlightItem::TypeSettingHandle;
            }
 
            if (m_highlightItem == HighlightItem::None) {
                if (std::optional<InlineSizeInfo> info = InlineSizeInfo::fromShape(selectedShape)) {
                    const QPolygonF zone = info->endLineGrabRect(sensitivity);
                    const QPolygonF startZone = info->startLineGrabRect(sensitivity);
                    if (zone.containsPoint(event->point, Qt::OddEvenFill)) {
                        m_highlightItem = HighlightItem::InlineSizeEndHandle;
                        cursor = lineToCursor(info->baselineLine(), canvas());
                    } else if (startZone.containsPoint(event->point, Qt::OddEvenFill)){
                        m_highlightItem = HighlightItem::InlineSizeStartHandle;
                        cursor = lineToCursor(info->baselineLine(), canvas());
                    }
                }
            }
 
            if (m_highlightItem == HighlightItem::None) {
                const QPolygonF textOutline = selectedShape->absoluteTransformation().map(selectedShape->outlineRect());
                const QPolygonF moveBorderRegion = selectedShape->absoluteTransformation().map(kisGrowRect(selectedShape->outlineRect(),
                                                                                                           sensitivity * 2));
                if (moveBorderRegion.containsPoint(event->point, Qt::OddEvenFill) && !textOutline.containsPoint(event->point, Qt::OddEvenFill)) {
                    m_highlightItem = HighlightItem::MoveBorder;
                    cursor = Qt::SizeAllCursor;
                }
            }
        }
 
        QString shapeType;
        bool isHorizontal = true;
        const KoSvgTextShape *hoveredShape = dynamic_cast<KoSvgTextShape *>(canvas()->shapeManager()->shapeAt(event->point));
        const KoPathShape *hoveredFlowShape = dynamic_cast<KoPathShape *>(canvas()->shapeManager()->shapeAt(event->point));
        QPainterPath hoverPath = KisToolUtils::shapeHoverInfoCrossLayer(canvas(), event->point, shapeType, &isHorizontal);
 
        bool textAreasHovered = false;
        if (m_textOnPathHelper.hitTest(event->point, canvas()->viewConverter()->viewToDocument()) ) {
            cursor = Qt::ArrowCursor;
        } else if(std::optional<QPointF> offsetVector = SvgChangeTextPaddingMarginStrategy::hitTest(selectedShape, event->point, grabSensitivityInPt())) {
            cursor = lineToCursor(QLineF(QPointF(0, 0), offsetVector.value()).normalVector(), canvas());
            textAreasHovered = true;
        } else if (selectedShape && selectedShape == hoveredShape && m_highlightItem == HighlightItem::None) {
            if (selectedShape->writingMode() == KoSvgText::HorizontalTB) {
                cursor = m_ibeam_horizontal;
            } else {
                cursor = m_ibeam_vertical;
            }
        } else if (hoveredShape && m_highlightItem == HighlightItem::None) {
            if (!hoveredShape->textWrappingAreas().isEmpty()) {
                Q_FOREACH(QPainterPath path, hoveredShape->textWrappingAreas()) {
                    m_hoveredShapeHighlightRect.addPath(hoveredShape->absoluteTransformation().map(path));
                }
            } else {
                m_hoveredShapeHighlightRect.addRect(hoveredShape->boundingRect());
            }
            if (hoveredShape->writingMode() == KoSvgText::HorizontalTB) {
                cursor = m_ibeam_horizontal;
            } else {
                cursor = m_ibeam_vertical;
            }
        } else if (hoveredFlowShape) {
            m_hoveredShapeHighlightRect.addPath(hoveredFlowShape->absoluteTransformation().map(hoveredFlowShape->outline()));
            if (hoveredFlowShape->segmentAtPoint(event->point, handleGrabRect(event->point)).isValid()) {
                cursor = m_text_on_path;
            } else {
                cursor = m_text_in_shape;
            }
        } else if (!hoverPath.isEmpty() && shapeType == KoSvgTextShape_SHAPEID && m_highlightItem == HighlightItem::None) {
            m_hoveredShapeHighlightRect = hoverPath;
            if (isHorizontal) {
                cursor = m_ibeam_horizontal;
            } else {
                cursor = m_ibeam_vertical;
            }
        }
        m_textOutlineHelper->setTextAreasHovered(textAreasHovered);
        useCursor(cursor);
        event->ignore();
    }
 
    repaintDecorations();
}

References KoShape::absoluteTransformation(), KoSvgTextShape::boundingRect(), KoToolBase::canvas(), Create, KoToolBase::cursor(), SvgTextCursor::cursorTypeForTypeSetting(), SvgCreateTextStrategy::draggingInlineSize(), grabSensitivityInPt(), KoToolBase::handleGrabRect(), SvgCreateTextStrategy::hasWrappingShape(), SvgChangeTextPaddingMarginStrategy::hitTest(), SvgTextOnPathDecorationHelper::hitTest(), KoSvgText::HorizontalTB, InlineSizeEndHandle, InlineSizeStartHandle, InShapeOffset, KoPathSegment::isValid(), kisGrowRect(), KoSvgTextShape_SHAPEID, lineToCursor(), m_base_cursor, m_dragging, m_highlightItem, m_hoveredShapeHighlightRect, m_ibeam_horizontal, m_ibeam_horizontal_done, m_ibeam_vertical, m_interactionStrategy, m_lastMousePos, m_text_in_shape, m_text_inline_horizontal, m_text_inline_vertical, m_text_on_path, m_textCursor, m_textOnPathHelper, m_textOutlineHelper, KoPointerEvent::modifiers(), MoveBorder, SvgTextCursor::NoHandle, None, KoPathShape::outline(), KoSvgTextShape::outlineRect(), KoPointerEvent::point, KoToolBase::repaintDecorations(), KoPathShape::segmentAtPoint(), Select, selectedShape(), SvgTextCursor::setTypeSettingHandleHovered(), KoShapeManager::shapeAt(), KisToolUtils::shapeHoverInfoCrossLayer(), KoCanvasBase::shapeManager(), KoSvgTextShape::textWrappingAreas(), TypeSettingHandle, SvgTextCursor::typeSettingHandleAtPos(), SvgTextCursor::updateModifiers(), KoToolBase::useCursor(), KoSvgTextShape::writingMode(), and writingMode().

◆ mousePressEvent()

void SvgTextTool::mousePressEvent ( KoPointerEvent * event )

overridevirtual

reimplemented from KoToolBase

Implements KoToolBase.

Definition at line 776 of file SvgTextTool.cpp.

{
    // When using touch drawing, we only ever receive move events after the
    // finger has pressed down. We have to issue an artificial move here so that
    // the tool's state is updated properly to handle the press.
    if (event->isTouchEvent()) {
        mouseMoveEvent(event);
    }
 
    if (!nodeEditable()) {
        event->accept();
        return;
    }
 
    KoSvgTextShape *selectedShape = this->selectedShape();
 
    if (selectedShape) {
        if (m_textOutlineHelper->contourModeButtonHovered(event->point)) {
            m_textOutlineHelper->toggleTextContourMode(selectedShape);
            event->accept();
            KoToolManager::instance()->switchToolRequested("InteractionTool");
            return;
        }
 
        if (m_highlightItem == HighlightItem::TypeSettingHandle) {
            SvgTextCursor::TypeSettingModeHandle handle = m_textCursor.typeSettingHandleAtPos(handleGrabRect(event->point));
            if (handle != SvgTextCursor::NoHandle) {
                if (!m_textCursor.setDominantBaselineFromHandle(handle)) {
                    m_interactionStrategy.reset(new SvgTextTypeSettingStrategy(this, selectedShape, &m_textCursor, handleGrabRect(event->point), event->modifiers()));
                    m_dragging = DragMode::TypeSetting;
                    m_textCursor.setDrawTypeSettingHandle(false);
                }
                event->accept();
                return;
            }
        } else if (SvgChangeTextPaddingMarginStrategy::hitTest(selectedShape, event->point, grabSensitivityInPt())) {
            m_interactionStrategy.reset(new SvgChangeTextPaddingMarginStrategy(this, selectedShape, event->point));
            m_dragging = DragMode::InShapeOffset;
            m_textOutlineHelper->setDrawTextWrappingArea(false);
            event->accept();
            return;
        } else if (m_textOnPathHelper.hitTest(event->point, canvas()->viewConverter()->viewToDocument())) {
            m_interactionStrategy.reset(new SvgChangeTextPathInfoStrategy(this, selectedShape, event->point, m_textCursor.getPos()));
            m_dragging = DragMode::TextPathHandle;
            m_textOnPathHelper.setStrategyActive(true);
            event->accept();
            return;
        } else if (m_highlightItem == HighlightItem::MoveBorder) {
            m_interactionStrategy.reset(new SvgMoveTextStrategy(this, selectedShape, event->point));
            m_dragging = DragMode::Move;
            event->accept();
            return;
        } else if (m_highlightItem == HighlightItem::InlineSizeEndHandle) {
            m_interactionStrategy.reset(new SvgInlineSizeChangeStrategy(this, selectedShape, event->point, false));
            m_dragging = DragMode::InlineSizeHandle;
            event->accept();
            return;
        }  else if (m_highlightItem == HighlightItem::InlineSizeStartHandle) {
            m_interactionStrategy.reset(new SvgInlineSizeChangeStrategy(this, selectedShape, event->point, true));
            m_dragging = DragMode::InlineSizeHandle;
            event->accept();
            return;
        }
    }
 
    KoSvgTextShape *hoveredShape = dynamic_cast<KoSvgTextShape *>(canvas()->shapeManager()->shapeAt(event->point));
    KoPathShape *hoveredFlowShape = dynamic_cast<KoPathShape *>(canvas()->shapeManager()->shapeAt(event->point));
    QString shapeType;
    QPainterPath hoverPath = KisToolUtils::shapeHoverInfoCrossLayer(canvas(), event->point, shapeType);
    bool crossLayerPossible = !hoverPath.isEmpty() && shapeType == KoSvgTextShape_SHAPEID;
 
    if (!selectedShape && !hoveredShape && !hoveredFlowShape && !crossLayerPossible) {
        QPointF point = canvas()->snapGuide()->snap(event->point, event->modifiers());
        m_interactionStrategy.reset(new SvgCreateTextStrategy(this, point));
        m_dragging = DragMode::Create;
        event->accept();
    } else if (hoveredShape) {
        if (hoveredShape != selectedShape) {
            canvas()->shapeManager()->selection()->deselectAll();
            canvas()->shapeManager()->selection()->select(hoveredShape);
            m_hoveredShapeHighlightRect = QPainterPath();
        }
        m_interactionStrategy.reset(new SvgSelectTextStrategy(this, &m_textCursor, event->point, event->modifiers()));
        m_dragging = DragMode::Select;
        event->accept();
    } else if (hoveredFlowShape) {
        QPointF point = canvas()->snapGuide()->snap(event->point, event->modifiers());
        m_interactionStrategy.reset(new SvgCreateTextStrategy(this, point, hoveredFlowShape));
        m_dragging = DragMode::Create;
        event->accept();
    } else if (crossLayerPossible) {
        if (KisToolUtils::selectShapeCrossLayer(canvas(), event->point, KoSvgTextShape_SHAPEID)) {
            m_interactionStrategy.reset(new SvgSelectTextStrategy(this, &m_textCursor, event->point, event->modifiers()));
            m_dragging = DragMode::Select;
            m_hoveredShapeHighlightRect = QPainterPath();
        } else {
            canvas()->shapeManager()->selection()->deselectAll();
        }
        event->accept();
    } else { // if there's a selected shape but no hovered shape...
        canvas()->shapeManager()->selection()->deselectAll();
        event->accept();
    }
 
    repaintDecorations();
}

References KoToolBase::canvas(), Create, KoSelection::deselectAll(), SvgTextCursor::getPos(), grabSensitivityInPt(), KoToolBase::handleGrabRect(), SvgChangeTextPaddingMarginStrategy::hitTest(), SvgTextOnPathDecorationHelper::hitTest(), InlineSizeEndHandle, InlineSizeHandle, InlineSizeStartHandle, InShapeOffset, KoToolManager::instance(), KoPointerEvent::isTouchEvent(), KoSvgTextShape_SHAPEID, m_dragging, m_highlightItem, m_hoveredShapeHighlightRect, m_interactionStrategy, m_textCursor, m_textOnPathHelper, m_textOutlineHelper, KoPointerEvent::modifiers(), mouseMoveEvent(), Move, MoveBorder, nodeEditable(), SvgTextCursor::NoHandle, KoPointerEvent::point, KoToolBase::repaintDecorations(), KoSelection::select(), Select, selectedShape(), KoShapeManager::selection, KisToolUtils::selectShapeCrossLayer(), SvgTextCursor::setDominantBaselineFromHandle(), SvgTextCursor::setDrawTypeSettingHandle(), SvgTextOnPathDecorationHelper::setStrategyActive(), KoShapeManager::shapeAt(), KisToolUtils::shapeHoverInfoCrossLayer(), KoCanvasBase::shapeManager(), KoSnapGuide::snap(), KoCanvasBase::snapGuide, SvgChangeTextPathInfoStrategy, SvgCreateTextStrategy, KoToolManager::switchToolRequested(), TextPathHandle, TypeSetting, TypeSettingHandle, and SvgTextCursor::typeSettingHandleAtPos().

◆ mouseReleaseEvent()

void SvgTextTool::mouseReleaseEvent ( KoPointerEvent * event )

overridevirtual

reimplemented from KoToolBase

Implements KoToolBase.

Definition at line 1032 of file SvgTextTool.cpp.

{
    if (m_interactionStrategy) {
        m_interactionStrategy->finishInteraction(event->modifiers());
        KUndo2Command *const command = m_interactionStrategy->createCommand();
        if (command) {
            m_strategyAddingCommand = true;
            canvas()->addCommand(command);
            m_strategyAddingCommand = false;
        }
        m_interactionStrategy = nullptr;
        if (m_dragging != DragMode::Select) {
            useCursor(m_base_cursor);
        }
        m_textOnPathHelper.setStrategyActive(false);
        m_textOutlineHelper->setDrawTextWrappingArea(true);
        m_dragging = DragMode::None;
        m_textCursor.setDrawTypeSettingHandle(true);
        event->accept();
    } else {
        useCursor(m_base_cursor);
    }
    event->accept();
}

References KoCanvasBase::addCommand(), KoToolBase::canvas(), m_base_cursor, m_dragging, m_interactionStrategy, m_strategyAddingCommand, m_textCursor, m_textOnPathHelper, m_textOutlineHelper, KoPointerEvent::modifiers(), None, Select, SvgTextCursor::setDrawTypeSettingHandle(), SvgTextOnPathDecorationHelper::setStrategyActive(), and KoToolBase::useCursor().

◆ mouseTripleClickEvent()

void SvgTextTool::mouseTripleClickEvent ( KoPointerEvent * event )

overridevirtual

reimplemented from KoToolBase

Reimplemented from KoToolBase.

Definition at line 1114 of file SvgTextTool.cpp.

{
    if (canvas()->shapeManager()->shapeAt(event->point) == selectedShape()) {
        // TODO: Consider whether we want to use sentence based selection instead:
        // QTextBoundaryFinder allows us to find sentences if necessary.
        m_textCursor.moveCursor(SvgTextCursor::ParagraphStart, true);
        m_textCursor.moveCursor(SvgTextCursor::ParagraphEnd, false);
        event->accept();
    }
}

References KoToolBase::canvas(), m_textCursor, SvgTextCursor::moveCursor(), SvgTextCursor::ParagraphEnd, SvgTextCursor::ParagraphStart, KoPointerEvent::point, and selectedShape().

◆ nodeEditable()

bool SvgTextTool::nodeEditable ( )

private

nodeEditable

See also: nodeEditable in KisTool.

Returns: whether the current Node is editable. If not, it'll display an oncanvas message.

Definition at line 638 of file SvgTextTool.cpp.

{
    KisNodeSP node = canvas()->resourceManager()->resource(KoCanvasResource::CurrentKritaNode).value<KisNodeWSP>();
    if (!node->isEditable(true)) {
        KisCanvas2 * kiscanvas = static_cast<KisCanvas2*>(canvas());
        if (kiscanvas) {
            QString message = KisToolUtils::nodeEditableMessage(node);
            kiscanvas->viewManager()->showFloatingMessage(message, KisIconUtils::loadIcon("object-locked"));
        }
        return false;
    }
    return true;
}

References KoToolBase::canvas(), KoCanvasResource::CurrentKritaNode, KisBaseNode::isEditable(), KisIconUtils::loadIcon(), KisToolUtils::nodeEditableMessage(), KoCanvasBase::resourceManager, KisViewManager::showFloatingMessage(), and KisCanvas2::viewManager().

◆ paint()

void SvgTextTool::paint	(	QPainter &	gc,
		const KoViewConverter &	converter )

overridevirtual

reimplemented from KoToolBase

Implements KoToolBase.

Definition at line 682 of file SvgTextTool.cpp.

{
    if (!isActivated()) return;
 
    if (m_dragging == DragMode::Create || m_dragging == DragMode::InShapeOffset) {
        m_interactionStrategy->paint(gc, converter);
    }
 
    KoSvgTextShape *shape = selectedShape();
    if (shape) {
        KisHandlePainterHelper handlePainter =
            KoShape::createHandlePainterHelperView(&gc, shape, converter, handleRadius(), decorationThickness());
 
        if (m_dragging != DragMode::InlineSizeHandle && m_dragging != DragMode::Move && m_dragging != DragMode::TypeSetting) {
            handlePainter.setHandleStyle(KisHandleStyle::primarySelection());
            QPainterPath path;
            path.addRect(shape->outlineRect());
            handlePainter.drawPath(path);
        }
 
        qreal pxlToPt = canvas()->viewConverter()->viewToDocumentX(1.0);
        qreal length = (INLINE_SIZE_DASHES_PATTERN_A + INLINE_SIZE_DASHES_PATTERN_B) * INLINE_SIZE_DASHES_PATTERN_LENGTH;
        if (std::optional<InlineSizeInfo> info = InlineSizeInfo::fromShape(shape, length * pxlToPt)) {
            handlePainter.setHandleStyle(KisHandleStyle::secondarySelection());
            handlePainter.drawConnectionLine(info->baselineLineLocal());
 
            if (m_highlightItem == HighlightItem::InlineSizeStartHandle) {
                handlePainter.setHandleStyle(m_dragging == DragMode::InlineSizeHandle? KisHandleStyle::partiallyHighlightedPrimaryHandles()
                                                                                     : KisHandleStyle::highlightedPrimaryHandles());
            }
            QVector<qreal> dashPattern = {INLINE_SIZE_DASHES_PATTERN_A, INLINE_SIZE_DASHES_PATTERN_B};
            handlePainter.drawHandleLine(info->startLineLocal());
            handlePainter.drawHandleLine(info->startLineDashes(), INLINE_SIZE_HANDLE_THICKNESS, dashPattern, INLINE_SIZE_DASHES_PATTERN_A);
 
            handlePainter.setHandleStyle(KisHandleStyle::secondarySelection());
            if (m_highlightItem == HighlightItem::InlineSizeEndHandle) {
                handlePainter.setHandleStyle(m_dragging == DragMode::InlineSizeHandle? KisHandleStyle::partiallyHighlightedPrimaryHandles()
                                                                                     : KisHandleStyle::highlightedPrimaryHandles());
            }
            handlePainter.drawHandleLine(info->endLineLocal());
            handlePainter.drawHandleLine(info->endLineDashes(), INLINE_SIZE_HANDLE_THICKNESS, dashPattern, INLINE_SIZE_DASHES_PATTERN_A);
        }
 
        if (m_highlightItem == HighlightItem::MoveBorder) {
            handlePainter.setHandleStyle(KisHandleStyle::highlightedPrimaryHandles());
        } else {
            handlePainter.setHandleStyle(KisHandleStyle::primarySelection());
        }
        handlePainter.drawHandleCircle(QPointF(), KoToolBase::handleRadius() * 0.75);
    }
 
    m_textOutlineHelper->setDecorationThickness(decorationThickness());
    m_textOutlineHelper->setHandleRadius(handleRadius());
    m_textOutlineHelper->paint(&gc, converter);
    m_textOnPathHelper.setDecorationThickness(decorationThickness());
    m_textOnPathHelper.setHandleRadius(handleRadius());
    m_textOnPathHelper.paint(&gc, converter);
    gc.setTransform(converter.documentToView(), true);
    {
        KisHandlePainterHelper handlePainter(&gc, handleRadius(), decorationThickness());
        if (!m_hoveredShapeHighlightRect.isEmpty()) {
            handlePainter.setHandleStyle(KisHandleStyle::highlightedPrimaryHandlesWithSolidOutline());
            QPainterPath path;
            path.addPath(m_hoveredShapeHighlightRect);
            handlePainter.drawPath(path);
        }
    }
    if (shape) {
        m_textCursor.paintDecorations(gc, qApp->palette().color(QPalette::Highlight), decorationThickness(), handleRadius());
    }
    if (m_interactionStrategy) {
        gc.save();
        canvas()->snapGuide()->paint(gc, converter);
        gc.restore();
    }
 
    // Paint debug outline
    if (debugEnabled() && shape) {
        gc.save();
        using Element = KoSvgTextShape::DebugElement;
        KoSvgTextShape::DebugElements el{};
        if (m_optionManager->showCharacterDebug()) {
            el |= Element::CharBbox;
        }
        if (m_optionManager->showLineDebug()) {
            el |= Element::LineBox;
        }
 
        gc.setTransform(shape->absoluteTransformation(), true);
        shape->paintDebug(gc, el);
        gc.restore();
    }
}

References KoShape::absoluteTransformation(), KoToolBase::canvas(), Create, KoShape::createHandlePainterHelperView(), debugEnabled(), KoToolBase::decorationThickness(), KoViewConverter::documentToView(), KisHandlePainterHelper::drawConnectionLine(), KisHandlePainterHelper::drawHandleCircle(), KisHandlePainterHelper::drawHandleLine(), KisHandlePainterHelper::drawPath(), KoToolBase::handleRadius(), KisHandleStyle::highlightedPrimaryHandles(), KisHandleStyle::highlightedPrimaryHandlesWithSolidOutline(), INLINE_SIZE_DASHES_PATTERN_A, INLINE_SIZE_DASHES_PATTERN_B, INLINE_SIZE_DASHES_PATTERN_LENGTH, INLINE_SIZE_HANDLE_THICKNESS, InlineSizeEndHandle, InlineSizeHandle, InlineSizeStartHandle, InShapeOffset, KoToolBase::isActivated(), length(), m_dragging, m_highlightItem, m_hoveredShapeHighlightRect, m_interactionStrategy, m_optionManager, m_textCursor, m_textOnPathHelper, m_textOutlineHelper, Move, MoveBorder, KoSvgTextShape::outlineRect(), KoSnapGuide::paint(), SvgTextOnPathDecorationHelper::paint(), KoSvgTextShape::paintDebug(), SvgTextCursor::paintDecorations(), KisHandleStyle::partiallyHighlightedPrimaryHandles(), KisHandleStyle::primarySelection(), KisHandleStyle::secondarySelection(), selectedShape(), SvgTextOnPathDecorationHelper::setDecorationThickness(), SvgTextOnPathDecorationHelper::setHandleRadius(), KisHandlePainterHelper::setHandleStyle(), KoCanvasBase::snapGuide, TypeSetting, KoCanvasBase::viewConverter(), and KoViewConverter::viewToDocumentX().

◆ paste()

bool SvgTextTool::paste ( )

overridevirtual

reimplemented from superclass

Reimplemented from KoToolBase.

Definition at line 483 of file SvgTextTool.cpp.

{
    return m_textCursor.paste();
}

References m_textCursor, and SvgTextCursor::paste().

◆ popupWidget()

KisPopupWidgetInterface * SvgTextTool::popupWidget ( )

overridevirtual

Returns: a widget with useful controls to be popped up on top of the canvas. Will not be called if popupActionsMenu() does not return null.

Reimplemented from KoToolBase.

Definition at line 219 of file SvgTextTool.cpp.

{
    return nullptr;
}

◆ propertiesForNewText

KoSvgTextProperties SvgTextTool::propertiesForNewText ( ) const

privateslot

propertiesForNewText get the text properties that should be used for new text.

Definition at line 399 of file SvgTextTool.cpp.

{
    const bool useCurrent = m_optionManager->optionsModel()->useCurrentTextProperties();
    const QString presetName = m_optionManager->optionsModel()->cssStylePresetName();
 
    KoSvgTextProperties props;
    if (useCurrent || presetName.isEmpty()) {
        KoSvgTextPropertyData textData = canvas()->resourceManager()->resource(KoCanvasResource::SvgTextPropertyData).value<KoSvgTextPropertyData>();
        props = textData.commonProperties;
    } else {
        KisAllResourcesModel *model = KisResourceModelProvider::resourceModel(ResourceType::CssStyles);
        QVector<KoResourceSP> res = model->resourcesForName(presetName);
        if (res.first()) {
            KoCssStylePresetSP style = res.first().staticCast<KoCssStylePreset>();
            qreal dpi = 72;
            KisCanvas2 *canvas2 = qobject_cast<KisCanvas2 *>(this->canvas());
            if (canvas2) {
                dpi = canvas2->image()->xRes() * 72.0;
            }
            if (style) {
                props = style->properties(dpi, true);
            }
        }
    }
 
    QColor fontColor = (canvas()->resourceManager()->isUsingOtherColor()
                ? canvas()->resourceManager()->backgroundColor()
                : canvas()->resourceManager()->foregroundColor()).toQColor();
    QSharedPointer<KoColorBackground> bg(new KoColorBackground());
    bg->setColor(fontColor);
    KoSvgText::BackgroundProperty bgProp(bg);
    props.setProperty(KoSvgTextProperties::FillId, QVariant::fromValue(bgProp));
    return props;
}

References KoToolBase::canvas(), KoSvgTextPropertyData::commonProperties, ResourceType::CssStyles, KoSvgTextProperties::FillId, KisCanvas2::image(), m_optionManager, KoCanvasBase::resourceManager, KisResourceModelProvider::resourceModel(), KisAllResourcesModel::resourcesForName(), KoSvgTextProperties::setProperty(), KoCanvasResource::SvgTextPropertyData, and KisImage::xRes().

◆ requestStrokeCancellation()

void SvgTextTool::requestStrokeCancellation ( )

overridevirtual

Called when the user requested the cancellation of the current stroke. If you tool supports cancelling, override this method and do the needed work there

Doing nothing, since these signals come on undo/redo actions in the mainland undo stack, which we manipulate while editing text

Reimplemented from KoToolBase.

Definition at line 524 of file SvgTextTool.cpp.

525{

531}

◆ requestStrokeEnd()

void SvgTextTool::requestStrokeEnd ( )

overridevirtual

Called when the image decided that the stroke should better be ended. If you tool supports long strokes, override this method and do the needed work there

Reimplemented from KoToolBase.

Definition at line 510 of file SvgTextTool.cpp.

{
    if (!isActivated()) return;
    if (!m_textCursor.isAddingCommand() && !m_strategyAddingCommand) {
        if (m_interactionStrategy) {
            m_dragging = DragMode::None;
            m_interactionStrategy->cancelInteraction();
            m_interactionStrategy = nullptr;
            useCursor(Qt::ArrowCursor);
            m_textOnPathHelper.setStrategyActive(false);
        }
    }
}

References KoToolBase::isActivated(), SvgTextCursor::isAddingCommand, m_dragging, m_interactionStrategy, m_strategyAddingCommand, m_textCursor, m_textOnPathHelper, None, SvgTextOnPathDecorationHelper::setStrategyActive(), and KoToolBase::useCursor().

◆ selectAll()

bool SvgTextTool::selectAll ( )

overridevirtual

selectAll select all data the tool can select.

Returns: true if something happened, false if nothing happened.

Reimplemented from KoToolBase.

Definition at line 493 of file SvgTextTool.cpp.

{
    m_textCursor.moveCursor(SvgTextCursor::ParagraphStart, true);
    m_textCursor.moveCursor(SvgTextCursor::ParagraphEnd, false);
    return true;
}

References m_textCursor, SvgTextCursor::moveCursor(), SvgTextCursor::ParagraphEnd, and SvgTextCursor::ParagraphStart.

◆ selectedShape()

KoSvgTextShape * SvgTextTool::selectedShape ( ) const

protected

Definition at line 293 of file SvgTextTool.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(canvas(), 0);
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(canvas()->selectedShapesProxy(), 0);
 
    QList<KoShape*> shapes = koSelection()->selectedEditableShapes();
    if (shapes.isEmpty()) return 0;
 
    KoSvgTextShape *textShape = dynamic_cast<KoSvgTextShape*>(shapes.first());
 
    return textShape;
}

References KoToolBase::canvas(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, koSelection(), and KoSelection::selectedEditableShapes().

◆ selection()

KoToolSelection * SvgTextTool::selection ( )

overridevirtual

reimplemented from superclass

Reimplemented from KoToolBase.

Definition at line 505 of file SvgTextTool.cpp.

{
    return &m_textCursor;
}

References m_textCursor.

◆ showEditor

void SvgTextTool::showEditor ( )

privateslot

Definition at line 306 of file SvgTextTool.cpp.

{
    KoSvgTextShape *shape = selectedShape();
    if (!shape) return;
 
    if (!m_editor) {
        m_editor = new SvgTextEditor(QApplication::activeWindow());
        m_editor->setWindowTitle(i18nc("@title:window", "Krita - Edit Text"));
        m_editor->setWindowModality(Qt::ApplicationModal);
        m_editor->setAttribute( Qt::WA_QuitOnClose, false );
 
        connect(m_editor, SIGNAL(textUpdated(KoSvgTextShape*,QString,QString)), SLOT(textUpdated(KoSvgTextShape*,QString,QString)));
 
        m_editor->activateWindow(); // raise on creation only
    }
    if (!m_editor->isVisible()) {
        m_editor->setInitialShape(shape);
#ifdef Q_OS_ANDROID
        // for window manager
        m_editor->setWindowFlags(Qt::Dialog);
        m_editor->menuBar()->setNativeMenuBar(false);
#endif
        m_editor->show();
    }
}

References m_editor, selectedShape(), and textUpdated().

◆ showGlyphPalette

void SvgTextTool::showGlyphPalette ( )

privateslot

showGlyphPalette Shows the glyph palette dialog.

Definition at line 338 of file SvgTextTool.cpp.

{
    if (!m_glyphPalette) {
        m_glyphPalette = new GlyphPaletteDialog(QApplication::activeWindow());
        m_glyphPalette->setAttribute( Qt::WA_QuitOnClose, false );
 
        connect(&m_textCursor, SIGNAL(selectionChanged()), this, SLOT(updateGlyphPalette()));
        connect(m_glyphPalette, SIGNAL(signalInsertRichText(KoSvgTextShape*, bool)), this, SLOT(insertRichText(KoSvgTextShape*, bool)));
 
        m_glyphPalette->activateWindow();
    }
    if (!m_glyphPalette->isVisible()) {
        m_glyphPalette->show();
        updateGlyphPalette();
    }
}

References insertRichText(), m_glyphPalette, m_textCursor, KoToolBase::selectionChanged(), and updateGlyphPalette().

◆ slotConvertType

void SvgTextTool::slotConvertType ( int index )

privateslot

slotConvertType

Parameters

index

Definition at line 540 of file SvgTextTool.cpp.

                                           {
    KoSvgTextShape *shape = selectedShape();
    if (shape) {
        if (index == shape->textType()) return;
        KoSvgTextShape::TextType type = KoSvgTextShape::TextType(index);
        KUndo2Command *parentCommand = new KUndo2Command();
        new KoKeepShapesSelectedCommand({shape}, {}, canvas()->selectedShapesProxy(),
                                        KisCommandUtils::FlipFlopCommand::State::INITIALIZING, parentCommand);
        KoSvgConvertTextTypeCommand *cmd = new KoSvgConvertTextTypeCommand(shape, type, m_textCursor.getPos(), parentCommand);
        parentCommand->setText(cmd->text());
        KoSvgTextRemoveShapeCommand::removeContourShapesFromFlow(shape, parentCommand, shape->textType() == KoSvgTextShape::TextInShape, type == KoSvgTextShape::InlineWrap);
        new KoKeepShapesSelectedCommand({}, {shape}, canvas()->selectedShapesProxy(),
                                        KisCommandUtils::FlipFlopCommand::State::FINALIZING, parentCommand);
        canvas()->addCommand(parentCommand);
        slotTextTypeUpdated();
    }
}

References KoCanvasBase::addCommand(), KoToolBase::canvas(), KisCommandUtils::FlipFlopCommand::FINALIZING, SvgTextCursor::getPos(), KisCommandUtils::FlipFlopCommand::INITIALIZING, KoSvgTextShape::InlineWrap, m_textCursor, KoSvgTextRemoveShapeCommand::removeContourShapesFromFlow(), selectedShape(), KoCanvasBase::selectedShapesProxy(), KUndo2Command::setText(), slotTextTypeUpdated(), KoSvgTextShape::TextInShape, and KoSvgTextShape::textType().

◆ slotMoveTextSelection

void SvgTextTool::slotMoveTextSelection ( int index )

privateslot

slotMoveTextSelection Move the start of the selection in typesetting mode by image 1 pix.

Parameters

index – Qt key for a direction.

Definition at line 603 of file SvgTextTool.cpp.

{
    KoSvgTextShape *shape = selectedShape();
    if (!shape) return;
    QPointF offset;
    // test type setting mode.
    if (index == Qt::Key_Down) {
        offset = QPointF(0, 1);
    } else if (index == Qt::Key_Up) {
        offset = QPointF(0, -1);
    } else if (index == Qt::Key_Right) {
        offset = QPointF(-1, 0);
    } else if (index == Qt::Key_Left) {
        offset = QPointF(1, 0);
    } else {
        return;
    }
    const KisCanvas2 *canvas2 = qobject_cast<const KisCanvas2 *>(this->canvas());
    if (canvas2) {
        offset = canvas2->coordinatesConverter()->imageToDocumentTransform().map(offset);
    }
    KUndo2Command *parentCommand = new KUndo2Command();
    new KoKeepShapesSelectedCommand({selectedShape()}, {}, canvas()->selectedShapesProxy(), KisCommandUtils::FlipFlopCommand::State::INITIALIZING, parentCommand);
    KUndo2Command *cmd = new SvgTextChangeTransformsOnRange(shape, m_textCursor.getPos(), m_textCursor.getAnchor(), offset, SvgTextChangeTransformsOnRange::OffsetAll, true, parentCommand);
    new KoKeepShapesSelectedCommand({}, {selectedShape()}, canvas()->selectedShapesProxy(), KisCommandUtils::FlipFlopCommand::State::FINALIZING, parentCommand);
    parentCommand->setText(cmd->text());
    canvas()->addCommand(parentCommand);
}

References KoCanvasBase::addCommand(), KoToolBase::canvas(), KisCanvas2::coordinatesConverter, KisCommandUtils::FlipFlopCommand::FINALIZING, SvgTextCursor::getAnchor(), SvgTextCursor::getPos(), KisCoordinatesConverter::imageToDocumentTransform(), KisCommandUtils::FlipFlopCommand::INITIALIZING, m_textCursor, SvgTextChangeTransformsOnRange::OffsetAll, selectedShape(), KoCanvasBase::selectedShapesProxy(), and KUndo2Command::setText().

◆ slotShapeSelectionChanged

void SvgTextTool::slotShapeSelectionChanged ( )

privateslot

selectionChanged called when the canvas selection is changed.

Definition at line 434 of file SvgTextTool.cpp.

{
    QList<KoShape *> shapes = koSelection()->selectedEditableShapes();
    if (shapes.size() == 1) {
        KoSvgTextShape *textShape = selectedShape();
        if (!textShape) {
            koSelection()->deselectAll();
            return;
        }
    } else if (shapes.size() > 1) {
        KoSvgTextShape *foundTextShape = nullptr;
 
        Q_FOREACH (KoShape *shape, shapes) {
            KoSvgTextShape *textShape = dynamic_cast<KoSvgTextShape*>(shape);
            if (textShape) {
                foundTextShape = textShape;
                break;
            }
        }
 
        koSelection()->deselectAll();
        if (foundTextShape) {
            koSelection()->select(foundTextShape);
        }
        return;
    }
    KoSvgTextShape *const shape = selectedShape();
    if (shape != m_textCursor.shape()) {
        m_textCursor.setShape(shape);
        m_textOnPathHelper.setShape(shape);
        if (shape) {
            setTextMode(true);
        } else {
            setTextMode(false);
        }
    }
    slotTextTypeUpdated();
}

References KoSelection::deselectAll(), koSelection(), m_textCursor, m_textOnPathHelper, KoSelection::select(), KoSelection::selectedEditableShapes(), selectedShape(), SvgTextOnPathDecorationHelper::setShape(), SvgTextCursor::setShape(), KoToolBase::setTextMode(), SvgTextCursor::shape, and slotTextTypeUpdated().

◆ slotTextTypeUpdated

void SvgTextTool::slotTextTypeUpdated ( )

privateslot

slotTextTypeUpdated Update the text type in the tool options.

Definition at line 568 of file SvgTextTool.cpp.

{
    KoSvgTextShape *shape = selectedShape();
    QActionGroup *typeConvertGroup = action("text_type_preformatted")->actionGroup();
    if (typeConvertGroup) {
        typeConvertGroup->setExclusive(true);
        Q_FOREACH (QAction *a, typeConvertGroup->actions()) {
            a->setCheckable(true);
        }
    }
    if (m_optionManager) {
        if (shape) {
            m_optionManager->convertToTextType(int(shape->textType()));
            if (typeConvertGroup) {
                typeConvertGroup->setEnabled(true);
            }
            action("text_type_preformatted")->setChecked(shape->textType() == KoSvgTextShape::PreformattedText);
            action("text_type_pre_positioned")->setChecked(shape->textType() == KoSvgTextShape::PrePositionedText);
            action("text_type_inline_wrap")->setChecked(shape->textType() == KoSvgTextShape::InlineWrap);
 
        } else {
            m_optionManager->convertToTextType(-1);
            if (typeConvertGroup) {
                typeConvertGroup->setEnabled(false);
            }
        }
        const bool enableTypeSetting = (m_optionManager->typeSettingMode() && shape && (shape->textType() == KoSvgTextShape::PreformattedText ||shape->textType() == KoSvgTextShape::PrePositionedText));
        QActionGroup *svgTypeSettingGroup = action("svg_type_setting_move_selection_start_down_1_px")->actionGroup();
        if (svgTypeSettingGroup) {
            svgTypeSettingGroup->setEnabled(enableTypeSetting);
        }
        m_textCursor.updateTypeSettingDecorFromShape();
    }
}

References KoToolBase::action(), KoSvgTextShape::InlineWrap, m_optionManager, m_textCursor, KoSvgTextShape::PreformattedText, KoSvgTextShape::PrePositionedText, selectedShape(), KoSvgTextShape::textType(), and SvgTextCursor::updateTypeSettingDecorFromShape().

◆ slotUpdateCursorDecoration

void SvgTextTool::slotUpdateCursorDecoration ( QRectF updateRect )

privateslot

updateCursor update the canvas decorations in a particular update rect for the text cursor.

Parameters

updateRect the rect to update in.

Definition at line 533 of file SvgTextTool.cpp.

{
    if (canvas()) {
        canvas()->updateCanvas(updateRect);
    }
}

References KoToolBase::canvas(), and KoCanvasBase::updateCanvas().

◆ slotUpdateTextPasteBehaviour

void SvgTextTool::slotUpdateTextPasteBehaviour ( )

privateslot

slotUpdateTextPasteBehaviour update the default text paste behaviour.

Definition at line 563 of file SvgTextTool.cpp.

{
    m_textCursor.setPasteRichTextByDefault(m_optionManager->optionsModel()->pasteRichtTextByDefault());
}

References m_optionManager, m_textCursor, and SvgTextCursor::setPasteRichTextByDefault().

◆ slotUpdateTypeSettingMode

void SvgTextTool::slotUpdateTypeSettingMode ( )

privateslot

slotUpdateTypeSettingMode Enable typesetting mode from the tool options.

Definition at line 632 of file SvgTextTool.cpp.

{
    m_textCursor.setTypeSettingModeActive(m_optionManager->typeSettingMode());
    slotTextTypeUpdated();
}

References m_optionManager, m_textCursor, SvgTextCursor::setTypeSettingModeActive(), and slotTextTypeUpdated().

◆ slotUpdateVisualCursor

void SvgTextTool::slotUpdateVisualCursor ( )

privateslot

slotUpdateVisualCursor update the visual cursor mode on the text cursor.

Definition at line 558 of file SvgTextTool.cpp.

{
    m_textCursor.setVisualMode(m_optionManager->optionsModel()->useVisualBidiCursor());
}

References m_optionManager, m_textCursor, and SvgTextCursor::setVisualMode().

◆ textUpdated

void SvgTextTool::textUpdated	(	KoSvgTextShape *	shape,
		const QString &	svg,
		const QString &	defs )

privateslot

Definition at line 332 of file SvgTextTool.cpp.

{
    SvgTextChangeCommand *cmd = new SvgTextChangeCommand(shape, svg, defs);
    canvas()->addCommand(cmd);
}

References KoCanvasBase::addCommand(), and KoToolBase::canvas().

◆ updateGlyphPalette

void SvgTextTool::updateGlyphPalette ( )

privateslot

updateGlyphPalette update the glyph palette dialog from the current selection.

Definition at line 355 of file SvgTextTool.cpp.

{
    if (m_glyphPalette && m_glyphPalette->isVisible()) {
        QString grapheme = QString();
        if (m_textCursor.shape()) {
            int pos = m_textCursor.getPos();
            int pos2 = pos > 0? m_textCursor.shape()->posLeft(pos, false): m_textCursor.shape()->posRight(pos, false);
            int start = m_textCursor.shape()->indexForPos(qMin(pos, pos2));
            int end   = m_textCursor.shape()->indexForPos(qMax(pos, pos2));
            grapheme = m_textCursor.shape()->plainText().mid(start, end-start);
        }
        m_glyphPalette->setGlyphModelFromProperties(m_textCursor.currentTextProperties(), grapheme);
    }
}

References SvgTextCursor::currentTextProperties(), SvgTextCursor::getPos(), KoSvgTextShape::indexForPos(), m_glyphPalette, m_textCursor, KoSvgTextShape::plainText, KoSvgTextShape::posLeft(), KoSvgTextShape::posRight(), and SvgTextCursor::shape.

◆ updateTextPathHelper

void SvgTextTool::updateTextPathHelper ( )

privateslot

Definition at line 370 of file SvgTextTool.cpp.

{
    m_textOnPathHelper.setPos(m_textCursor.getPos());
}

References SvgTextCursor::getPos(), m_textCursor, m_textOnPathHelper, and SvgTextOnPathDecorationHelper::setPos().

◆ writingMode()

KoSvgText::WritingMode SvgTextTool::writingMode ( ) const

private

Definition at line 1131 of file SvgTextTool.cpp.

{
    KoSvgTextProperties props = propertiesForNewText();
    return KoSvgText::WritingMode(props.propertyOrDefault(KoSvgTextProperties::WritingModeId).toInt());
}

References propertiesForNewText(), KoSvgTextProperties::propertyOrDefault(), and KoSvgTextProperties::WritingModeId.

Friends And Related Symbol Documentation

◆ SvgChangeTextPathInfoStrategy

friend class SvgChangeTextPathInfoStrategy

friend

Definition at line 40 of file SvgTextTool.h.

◆ SvgCreateTextStrategy

friend class SvgCreateTextStrategy

friend

Definition at line 39 of file SvgTextTool.h.

Member Data Documentation

◆ m_base_cursor

QCursor SvgTextTool::m_base_cursor

private

Definition at line 242 of file SvgTextTool.h.

◆ m_canvasConnections

KisSignalAutoConnectionsStore SvgTextTool::m_canvasConnections

private

Definition at line 238 of file SvgTextTool.h.

◆ m_dragging

DragMode SvgTextTool::m_dragging {DragMode::None}

private

Definition at line 226 of file SvgTextTool.h.

226{DragMode::None};

◆ m_editor

QPointer<SvgTextEditor> SvgTextTool::m_editor

private

Definition at line 223 of file SvgTextTool.h.

◆ m_glyphPalette

QPointer<GlyphPaletteDialog> SvgTextTool::m_glyphPalette

private

Definition at line 224 of file SvgTextTool.h.

◆ m_highlightItem

HighlightItem SvgTextTool::m_highlightItem {HighlightItem::None}

private

Definition at line 228 of file SvgTextTool.h.

228{HighlightItem::None};

◆ m_hoveredShapeHighlightRect

QPainterPath SvgTextTool::m_hoveredShapeHighlightRect

private

Definition at line 240 of file SvgTextTool.h.

◆ m_ibeam_horizontal

QCursor SvgTextTool::m_ibeam_horizontal

private

Definition at line 248 of file SvgTextTool.h.

◆ m_ibeam_horizontal_done

QCursor SvgTextTool::m_ibeam_horizontal_done

private

Definition at line 249 of file SvgTextTool.h.

◆ m_ibeam_vertical

QCursor SvgTextTool::m_ibeam_vertical

private

Definition at line 247 of file SvgTextTool.h.

◆ m_interactionStrategy

std::unique_ptr<KoInteractionStrategy> SvgTextTool::m_interactionStrategy

private

Definition at line 227 of file SvgTextTool.h.

◆ m_lastMousePos

QPointF SvgTextTool::m_lastMousePos

private

Definition at line 225 of file SvgTextTool.h.

◆ m_optionManager

QScopedPointer<SvgTextToolOptionsManager> SvgTextTool::m_optionManager

private

Definition at line 222 of file SvgTextTool.h.

◆ m_strategyAddingCommand

bool SvgTextTool::m_strategyAddingCommand {false}

private

Definition at line 229 of file SvgTextTool.h.

229{false};

◆ m_text_in_shape

QCursor SvgTextTool::m_text_in_shape

private

Definition at line 246 of file SvgTextTool.h.

◆ m_text_inline_horizontal

QCursor SvgTextTool::m_text_inline_horizontal

private

Definition at line 243 of file SvgTextTool.h.

◆ m_text_inline_vertical

QCursor SvgTextTool::m_text_inline_vertical

private

Definition at line 244 of file SvgTextTool.h.

◆ m_text_on_path

QCursor SvgTextTool::m_text_on_path

private

Definition at line 245 of file SvgTextTool.h.

◆ m_textCursor

SvgTextCursor SvgTextTool::m_textCursor

private

Definition at line 235 of file SvgTextTool.h.

◆ m_textOnPathHelper

SvgTextOnPathDecorationHelper SvgTextTool::m_textOnPathHelper

private

Definition at line 236 of file SvgTextTool.h.

◆ m_textOutlineHelper

QScopedPointer<KoSvgTextShapeOutlineHelper> SvgTextTool::m_textOutlineHelper

private

Definition at line 237 of file SvgTextTool.h.

◆ m_textTypeSignalsMapper

QScopedPointer<KisSignalMapper> SvgTextTool::m_textTypeSignalsMapper

private

Definition at line 231 of file SvgTextTool.h.

◆ m_typeSettingMovementMapper

QScopedPointer<KisSignalMapper> SvgTextTool::m_typeSettingMovementMapper

private

Definition at line 232 of file SvgTextTool.h.

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

plugins/tools/svgtexttool/SvgTextTool.h
plugins/tools/svgtexttool/SvgTextTool.cpp

Public Member Functions

Protected Member Functions

Private Types

Private Slots

Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ DragMode

◆ HighlightItem

Constructor & Destructor Documentation

◆ SvgTextTool()

◆ ~SvgTextTool()

Member Function Documentation

◆ activate()

◆ addMappedAction()

◆ copy()

◆ createOptionWidget()

◆ deactivate()

◆ decorationsRect()

◆ deleteSelection()

◆ deselect()

◆ focusInEvent()

◆ focusOutEvent()

◆ generateDefs

◆ grabSensitivityInPt()

◆ hasSelection()

◆ inputMethodEvent()

◆ inputMethodQuery()

◆ insertRichText

◆ keyPressEvent()

◆ keyReleaseEvent()

◆ koSelection()

◆ mouseDoubleClickEvent()

◆ mouseMoveEvent()

◆ mousePressEvent()

◆ mouseReleaseEvent()

◆ mouseTripleClickEvent()

◆ nodeEditable()

◆ paint()

◆ paste()

◆ popupWidget()

◆ propertiesForNewText

◆ requestStrokeCancellation()

◆ requestStrokeEnd()

◆ selectAll()

◆ selectedShape()

◆ selection()

◆ showEditor

◆ showGlyphPalette

◆ slotConvertType

◆ slotMoveTextSelection

◆ slotShapeSelectionChanged

◆ slotTextTypeUpdated

◆ slotUpdateCursorDecoration

◆ slotUpdateTextPasteBehaviour

◆ slotUpdateTypeSettingMode

◆ slotUpdateVisualCursor

◆ textUpdated

◆ updateGlyphPalette

◆ updateTextPathHelper

◆ writingMode()

Friends And Related Symbol Documentation

◆ SvgChangeTextPathInfoStrategy

◆ SvgCreateTextStrategy

Member Data Documentation

◆ m_base_cursor

◆ m_canvasConnections

◆ m_dragging

◆ m_editor

◆ m_glyphPalette

◆ m_highlightItem

◆ m_hoveredShapeHighlightRect

◆ m_ibeam_horizontal

◆ m_ibeam_horizontal_done

◆ m_ibeam_vertical

◆ m_interactionStrategy

◆ m_lastMousePos