#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 }

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

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	slotShapeSelectionChanged ()
	selectionChanged called when the canvas selection is changed.

void	slotTextEditorClosed ()

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	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.

Private Member Functions
qreal	grabSensitivityInPt () const

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

QScopedPointer< KisSignalMapper >	m_textTypeSignalsMapper

Friends
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 32 of file SvgTextTool.h.

Member Enumeration Documentation

◆ DragMode

enum class SvgTextTool::DragMode

strongprivate

Enumerator
None
Create
Select
InlineSizeHandle
Move

Definition at line 177 of file SvgTextTool.h.

                        {
        None = 0,
        Create,
        Select,
        InlineSizeHandle,
        Move,
    };

◆ HighlightItem

enum class SvgTextTool::HighlightItem

strongprivate

Enumerator
None
InlineSizeStartHandle
InlineSizeEndHandle
MoveBorder

Definition at line 184 of file SvgTextTool.h.

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

Constructor & Destructor Documentation

◆ SvgTextTool()

SvgTextTool::SvgTextTool ( KoCanvasBase * canvas )

explicit

Definition at line 90 of file SvgTextTool.cpp.

    : KoToolBase(canvas)
    , m_textCursor(canvas)
    , m_optionManager(new SvgTextToolOptionsManager(this))
{
     // TODO: figure out whether we should use system config for this, Windows and GTK have values for it, but Qt and MacOS don't(?).
    int cursorFlashLimit = 5000;
    m_textCursor.setCaretSetting(QApplication::style()->pixelMetric(QStyle::PM_TextCursorWidth)
                                 , qApp->cursorFlashTime()
                                 , cursorFlashLimit);
    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"
    };
    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));
    const QMap<QString, int> convertActions {
        {"text_type_preformatted", KoSvgTextShape::PreformattedText},
        {"text_type_inline_wrap", KoSvgTextShape::InlineWrap},
        {"text_type_pre_positioned", KoSvgTextShape::PrePositionedText}
    };
    Q_FOREACH(const QString name, convertActions.keys()) {
        QAction *a = action(name);
        connect(a, SIGNAL(triggered()), m_textTypeSignalsMapper.data(), SLOT(map()));
        m_textTypeSignalsMapper->setMapping(a, convertActions.value(name));
    }
 
    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(), connect(), 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_textTypeSignalsMapper, SvgTextShortCuts::possibleActions(), KoSvgTextShape::PreformattedText, KoSvgTextShape::PrePositionedText, SvgTextCursor::registerPropertyAction(), SvgTextCursor::setCaretSetting(), showGlyphPalette(), and slotUpdateCursorDecoration().

◆ ~SvgTextTool()

SvgTextTool::~SvgTextTool ( )

override

Definition at line 146 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 156 of file SvgTextTool.cpp.

{
    KoToolBase::activate(shapes);
    m_canvasConnections.addConnection(canvas()->selectedShapesProxy(), SIGNAL(selectionChanged()), this, SLOT(slotShapeSelectionChanged()));
 
    const KisCanvas2 *canvas2 = qobject_cast<const KisCanvas2 *>(this->canvas());
    if (canvas2) {
        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)));
 
    useCursor(m_base_cursor);
    slotShapeSelectionChanged();
 
    repaintDecorations();
}

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

◆ copy()

void SvgTextTool::copy ( ) const

overridevirtual

reimplemented from superclass

Reimplemented from KoToolBase.

Definition at line 449 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 214 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->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->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(), connect(), KisQQuickWidget::connectMinimumHeightToRootObject(), debugEnabled(), KisMainWindow::dockWidget(), m_optionManager, KisViewManager::mainWindow(), SvgTextToolOptionsManager::openTextPropertiesDocker(), showEditor(), showGlyphPalette(), slotConvertType(), slotTextTypeUpdated(), slotUpdateTextPasteBehaviour(), slotUpdateVisualCursor(), and KisCanvas2::viewManager().

◆ deactivate()

void SvgTextTool::deactivate ( )

overridevirtual

reimplemented from KoToolBase

Reimplemented from KoToolBase.

Definition at line 178 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);
 
    m_hoveredShapeHighlightRect = QPainterPath();
 
    repaintDecorations();
}

References KoToolBase::canvas(), KisSignalAutoConnectionsStore::clear(), KoToolBase::deactivate(), m_canvasConnections, m_hoveredShapeHighlightRect, m_textCursor, m_textTypeSignalsMapper, 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 562 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();
 
    return rect;
}

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

◆ deleteSelection()

void SvgTextTool::deleteSelection ( )

overridevirtual

reimplemented from superclass

Reimplemented from KoToolBase.

Definition at line 454 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 476 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 936 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 942 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 361 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 974 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 464 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 209 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 200 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 345 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);
}

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 907 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 924 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();
    } else {
        event->ignore();
    }
}

References m_interactionStrategy, and m_lastMousePos.

◆ koSelection()

KoSelection * SvgTextTool::koSelection ( ) const

protected

Definition at line 259 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 948 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 760 of file SvgTextTool.cpp.

{
    m_lastMousePos = event->point;
    m_hoveredShapeHighlightRect = QPainterPath();
 
 
    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()) {
                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);
            }
        }
        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();
 
            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));
        QPainterPath hoverPath = KisToolUtils::shapeHoverInfoCrossLayer(canvas(), event->point, shapeType, &isHorizontal);
        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) {
            if (!hoveredShape->shapesInside().isEmpty()) {
                QPainterPath paths;
                Q_FOREACH(KoShape *s, hoveredShape->shapesInside()) {
                    KoPathShape *path = dynamic_cast<KoPathShape *>(s);
                    if (path) {
                        paths.addPath(hoveredShape->absoluteTransformation().map(path->absoluteTransformation().map(path->outline())));
                    }
                }
                if (!paths.isEmpty()) {
                    m_hoveredShapeHighlightRect = paths;
                }
            } else {
                m_hoveredShapeHighlightRect.addRect(hoveredShape->boundingRect());
            }
            if (hoveredShape->writingMode() == KoSvgText::HorizontalTB) {
                cursor = m_ibeam_horizontal;
            } else {
                cursor = m_ibeam_vertical;
            }
        } 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;
            }
        }
#if 0
           else if(m_highlightItem == HighlightItem::None) {
            KoPathShape *shape = dynamic_cast<KoPathShape *>(canvas()->shapeManager()->shapeAt(event->point));
            if (shape) {
                if (shape->subpathCount() > 0) {
                    if (shape->isClosedSubpath(0)) {
                        cursor = m_text_in_shape;
                    }
                }
                KoPathSegment segment = segmentAtPoint(event->point, shape, handleGrabRect(event->point));
                if (segment.isValid()) {
                    cursor = m_text_on_path;
                }
                m_hoveredShapeHighlightRect.addPath(shape->absoluteTransformation().map(shape->outline()));
            } else {
                m_hoveredShapeHighlightRect = QPainterPath();
            }
        }
#endif
        useCursor(cursor);
        event->ignore();
    }
 
    repaintDecorations();
}

References KoShape::absoluteTransformation(), KoSvgTextShape::boundingRect(), KoToolBase::canvas(), Create, KoToolBase::cursor(), SvgCreateTextStrategy::draggingInlineSize(), grabSensitivityInPt(), KoToolBase::handleGrabRect(), KoSvgText::HorizontalTB, InlineSizeEndHandle, InlineSizeStartHandle, KoPathShape::isClosedSubpath(), 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, KoPointerEvent::modifiers(), MoveBorder, None, KoPathShape::outline(), KoSvgTextShape::outlineRect(), KoPointerEvent::point, KoToolBase::repaintDecorations(), Select, selectedShape(), KoShapeManager::shapeAt(), KisToolUtils::shapeHoverInfoCrossLayer(), KoCanvasBase::shapeManager(), KoSvgTextShape::shapesInside, KoPathShape::subpathCount(), KoToolBase::useCursor(), KoSvgTextShape::writingMode(), and writingMode().

◆ mousePressEvent()

void SvgTextTool::mousePressEvent ( KoPointerEvent * event )

overridevirtual

reimplemented from KoToolBase

Implements KoToolBase.

Definition at line 678 of file SvgTextTool.cpp.

{
    KoSvgTextShape *selectedShape = this->selectedShape();
 
    if (selectedShape) {
        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));
    QString shapeType;
    QPainterPath hoverPath = KisToolUtils::shapeHoverInfoCrossLayer(canvas(), event->point, shapeType);
    bool crossLayerPossible = !hoverPath.isEmpty() && shapeType == KoSvgTextShape_SHAPEID;
 
    if (!selectedShape && !hoveredShape && !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));
        m_dragging = DragMode::Select;
        event->accept();
    } else if (crossLayerPossible) {
        if (KisToolUtils::selectShapeCrossLayer(canvas(), event->point, KoSvgTextShape_SHAPEID)) {
            m_interactionStrategy.reset(new SvgSelectTextStrategy(this, &m_textCursor, event->point));
            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(), InlineSizeEndHandle, InlineSizeHandle, InlineSizeStartHandle, KoSvgTextShape_SHAPEID, m_dragging, m_highlightItem, m_hoveredShapeHighlightRect, m_interactionStrategy, m_textCursor, KoPointerEvent::modifiers(), Move, MoveBorder, KoPointerEvent::point, KoToolBase::repaintDecorations(), KoSelection::select(), Select, selectedShape(), KoShapeManager::selection, KisToolUtils::selectShapeCrossLayer(), KoShapeManager::shapeAt(), KisToolUtils::shapeHoverInfoCrossLayer(), KoCanvasBase::shapeManager(), KoSnapGuide::snap(), KoCanvasBase::snapGuide, and SvgCreateTextStrategy.

◆ mouseReleaseEvent()

void SvgTextTool::mouseReleaseEvent ( KoPointerEvent * event )

overridevirtual

reimplemented from KoToolBase

Implements KoToolBase.

Definition at line 885 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_dragging = DragMode::None;
        event->accept();
    } else {
        useCursor(m_base_cursor);
    }
    event->accept();
}

References KoCanvasBase::addCommand(), KoToolBase::canvas(), m_base_cursor, m_dragging, m_interactionStrategy, m_strategyAddingCommand, KoPointerEvent::modifiers(), None, Select, and KoToolBase::useCursor().

◆ mouseTripleClickEvent()

void SvgTextTool::mouseTripleClickEvent ( KoPointerEvent * event )

overridevirtual

reimplemented from KoToolBase

Reimplemented from KoToolBase.

Definition at line 963 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().

◆ paint()

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

overridevirtual

reimplemented from KoToolBase

Implements KoToolBase.

Definition at line 589 of file SvgTextTool.cpp.

{
    if (!isActivated()) return;
 
    if (m_dragging == DragMode::Create) {
        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) {
            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);
    }
 
    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());
    }
    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, KoToolBase::isActivated(), length(), m_dragging, m_highlightItem, m_hoveredShapeHighlightRect, m_interactionStrategy, m_optionManager, m_textCursor, Move, MoveBorder, KoSvgTextShape::outlineRect(), KoSnapGuide::paint(), KoSvgTextShape::paintDebug(), SvgTextCursor::paintDecorations(), KisHandleStyle::partiallyHighlightedPrimaryHandles(), KisHandleStyle::primarySelection(), KisHandleStyle::secondarySelection(), selectedShape(), KisHandlePainterHelper::setHandleStyle(), KoCanvasBase::snapGuide, KoCanvasBase::viewConverter(), and KoViewConverter::viewToDocumentX().

◆ paste()

bool SvgTextTool::paste ( )

overridevirtual

reimplemented from superclass

Reimplemented from KoToolBase.

Definition at line 459 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 195 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 376 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 501 of file SvgTextTool.cpp.

502{

508}

◆ 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 486 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);
        } else if (isInTextMode()) {
            canvas()->shapeManager()->selection()->deselectAll();
        }
    }
}

References KoToolBase::canvas(), KoSelection::deselectAll(), KoToolBase::isActivated(), SvgTextCursor::isAddingCommand, KoToolBase::isInTextMode(), m_dragging, m_interactionStrategy, m_strategyAddingCommand, m_textCursor, None, KoShapeManager::selection, KoCanvasBase::shapeManager(), 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 469 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 267 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 481 of file SvgTextTool.cpp.

{
    return &m_textCursor;
}

References m_textCursor.

◆ showEditor

void SvgTextTool::showEditor ( )

privateslot

Definition at line 280 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)));
        connect(m_editor, SIGNAL(textEditorClosed()), SLOT(slotTextEditorClosed()));
 
        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 connect(), m_editor, selectedShape(), slotTextEditorClosed(), and textUpdated().

◆ showGlyphPalette

void SvgTextTool::showGlyphPalette ( )

privateslot

showGlyphPalette Shows the glyph palette dialog.

Definition at line 313 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 connect(), insertRichText(), m_glyphPalette, m_textCursor, KoToolBase::selectionChanged(), and updateGlyphPalette().

◆ slotConvertType

void SvgTextTool::slotConvertType ( int index )

privateslot

slotConvertType

Parameters

index

Definition at line 517 of file SvgTextTool.cpp.

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

References KoCanvasBase::addCommand(), KoToolBase::canvas(), KisCommandUtils::FlipFlopCommand::FINALIZING, SvgTextCursor::getPos(), KisCommandUtils::FlipFlopCommand::INITIALIZING, m_textCursor, selectedShape(), KoCanvasBase::selectedShapesProxy(), KUndo2Command::setText(), and slotTextTypeUpdated().

◆ slotShapeSelectionChanged

void SvgTextTool::slotShapeSelectionChanged ( )

privateslot

selectionChanged called when the canvas selection is changed.

Definition at line 411 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);
        if (shape) {
            setTextMode(true);
        } else {
            setTextMode(false);
        }
    }
    slotTextTypeUpdated();
}

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

◆ slotTextEditorClosed

void SvgTextTool::slotTextEditorClosed ( )

privateslot

Definition at line 354 of file SvgTextTool.cpp.

{
    // change tools to the shape selection tool when we close the text editor to allow moving and further editing of the object.
    // most of the time when we edit text, the shape selection tool is where we left off anyway
    KoToolManager::instance()->switchToolRequested("InteractionTool");
}

References KoToolManager::instance(), and KoToolManager::switchToolRequested().

◆ slotTextTypeUpdated

void SvgTextTool::slotTextTypeUpdated ( )

privateslot

slotTextTypeUpdated Update the text type in the tool options.

Definition at line 541 of file SvgTextTool.cpp.

{
    KoSvgTextShape *shape = selectedShape();
    if (m_optionManager) {
        if (shape) {
            m_optionManager->convertToTextType(int(shape->textType()));
            action("text_type_preformatted")->setEnabled(true);
            action("text_type_pre_positioned")->setEnabled(true);
            action("text_type_inline_wrap")->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);
            action("text_type_preformatted")->setEnabled(false);
            action("text_type_pre_positioned")->setEnabled(false);
            action("text_type_inline_wrap")->setEnabled(false);
        }
    }
}

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

◆ 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 510 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 536 of file SvgTextTool.cpp.

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

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

◆ slotUpdateVisualCursor

void SvgTextTool::slotUpdateVisualCursor ( )

privateslot

slotUpdateVisualCursor update the visual cursor mode on the text cursor.

Definition at line 531 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 307 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 330 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.

◆ writingMode()

KoSvgText::WritingMode SvgTextTool::writingMode ( ) const

private

Definition at line 980 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

◆ SvgCreateTextStrategy

friend class SvgCreateTextStrategy

friend

Definition at line 36 of file SvgTextTool.h.

Member Data Documentation

◆ m_base_cursor

QCursor SvgTextTool::m_base_cursor

private

Definition at line 208 of file SvgTextTool.h.

◆ m_canvasConnections

KisSignalAutoConnectionsStore SvgTextTool::m_canvasConnections

private

Definition at line 204 of file SvgTextTool.h.

◆ m_dragging

DragMode SvgTextTool::m_dragging {DragMode::None}

private

Definition at line 195 of file SvgTextTool.h.

195{DragMode::None};

◆ m_editor

QPointer<SvgTextEditor> SvgTextTool::m_editor

private

Definition at line 192 of file SvgTextTool.h.

◆ m_glyphPalette

QPointer<GlyphPaletteDialog> SvgTextTool::m_glyphPalette

private

Definition at line 193 of file SvgTextTool.h.

◆ m_highlightItem

HighlightItem SvgTextTool::m_highlightItem {HighlightItem::None}

private

Definition at line 197 of file SvgTextTool.h.

197{HighlightItem::None};

◆ m_hoveredShapeHighlightRect

QPainterPath SvgTextTool::m_hoveredShapeHighlightRect

private

Definition at line 206 of file SvgTextTool.h.

◆ m_ibeam_horizontal

QCursor SvgTextTool::m_ibeam_horizontal

private

Definition at line 214 of file SvgTextTool.h.

◆ m_ibeam_horizontal_done

QCursor SvgTextTool::m_ibeam_horizontal_done

private

Definition at line 215 of file SvgTextTool.h.

◆ m_ibeam_vertical

QCursor SvgTextTool::m_ibeam_vertical

private

Definition at line 213 of file SvgTextTool.h.

◆ m_interactionStrategy

std::unique_ptr<KoInteractionStrategy> SvgTextTool::m_interactionStrategy

private

Definition at line 196 of file SvgTextTool.h.

◆ m_lastMousePos

QPointF SvgTextTool::m_lastMousePos

private

Definition at line 194 of file SvgTextTool.h.

◆ m_optionManager

QScopedPointer<SvgTextToolOptionsManager> SvgTextTool::m_optionManager

private

Definition at line 191 of file SvgTextTool.h.

◆ m_strategyAddingCommand

bool SvgTextTool::m_strategyAddingCommand {false}

private

Definition at line 198 of file SvgTextTool.h.

198{false};

◆ m_text_in_shape

QCursor SvgTextTool::m_text_in_shape

private

Definition at line 212 of file SvgTextTool.h.

◆ m_text_inline_horizontal

QCursor SvgTextTool::m_text_inline_horizontal

private

Definition at line 209 of file SvgTextTool.h.

◆ m_text_inline_vertical

QCursor SvgTextTool::m_text_inline_vertical

private

Definition at line 210 of file SvgTextTool.h.

◆ m_text_on_path

QCursor SvgTextTool::m_text_on_path

private

Definition at line 211 of file SvgTextTool.h.

◆ m_textCursor

SvgTextCursor SvgTextTool::m_textCursor

private

Definition at line 203 of file SvgTextTool.h.

◆ m_textTypeSignalsMapper

QScopedPointer<KisSignalMapper> SvgTextTool::m_textTypeSignalsMapper

private

Definition at line 200 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()

◆ copy()

◆ createOptionWidget()

◆ deactivate()

◆ decorationsRect()

◆ deleteSelection()

◆ deselect()

◆ focusInEvent()

◆ focusOutEvent()

◆ generateDefs

◆ grabSensitivityInPt()

◆ hasSelection()

◆ inputMethodEvent()

◆ inputMethodQuery()

◆ insertRichText

◆ keyPressEvent()

◆ keyReleaseEvent()

◆ koSelection()

◆ mouseDoubleClickEvent()

◆ mouseMoveEvent()

◆ mousePressEvent()

◆ mouseReleaseEvent()

◆ mouseTripleClickEvent()

◆ paint()

◆ paste()

◆ popupWidget()

◆ propertiesForNewText

◆ requestStrokeCancellation()

◆ requestStrokeEnd()

◆ selectAll()

◆ selectedShape()

◆ selection()

◆ showEditor

◆ showGlyphPalette

◆ slotConvertType

◆ slotShapeSelectionChanged

◆ slotTextEditorClosed

◆ slotTextTypeUpdated

◆ slotUpdateCursorDecoration

◆ slotUpdateTextPasteBehaviour

◆ slotUpdateVisualCursor

◆ textUpdated

◆ updateGlyphPalette

◆ writingMode()

Friends And Related Symbol Documentation

◆ 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

◆ m_optionManager

◆ m_strategyAddingCommand

◆ m_text_in_shape

◆ m_text_inline_horizontal

◆ m_text_inline_vertical