SvgTextCursor Class Reference

The SvgTextCursor class. More...

#include <SvgTextCursor.h>

Inheritance diagram for SvgTextCursor:

Classes
class	InputQueryUpdateBlocker

Public Types
enum	MoveMode {   MoveNone , MoveLeft , MoveRight , MoveUp ,   MoveDown , MoveNextChar , MovePreviousChar , MoveNextLine ,   MovePreviousLine , MoveWordLeft , MoveWordRight , MoveWordEnd ,   MoveWordStart , MoveLineStart , MoveLineEnd , ParagraphStart ,   ParagraphEnd }
enum	TypeSettingModeHandle {   NoHandle , StartPos , EndPos , BaselineShift ,   Ascender , Descender , LineHeightTop , LineHeightBottom ,   BaselineAlphabetic , BaselineIdeographic , BaselineMiddle , BaselineHanging ,   BaselineMathematical , BaselineCentral }
	Handles used by type setting mode. More...

Signals
void	selectionChanged ()
	Sents an update selection was changed.
void	sigOpenGlyphPalette ()
	Called by actions, tells the parent tool to open the glyph palette.
void	updateCursorDecoration (QRectF updateRect)
	Sents an update to the parent tool to update it's decorations.

Public Member Functions
void	copy () const
	copy copies plain text into the clipboard between anchor and pos.
QPair< KoSvgTextProperties, KoSvgTextProperties >	currentTextProperties () const
	currentTextProperties
QCursor	cursorTypeForTypeSetting () const
	Return appropriate typeSetting cursor;.
void	deselectText ()
	Deselect all text. This effectively makes anchor the same as pos.
void	focusIn ()
	Turns on blinking cursor.
void	focusOut ()
	Stops blinking cursor.
int	getAnchor ()
	Get the current selection anchor. This is the same as position, unless there's a selection.
int	getPos ()
	Get the current position.
QString	handleName (TypeSettingModeHandle handle) const
	handleName
bool	hasSelection () override
	return true if the tool currently has something selected that can be copied or deleted.
void	inputMethodEvent (QInputMethodEvent *event)
	Process an input method event. This is used by IME like virtual keyboards.
QVariant	inputMethodQuery (Qt::InputMethodQuery query) const
	Process an input method query and return the requested result.
void	insertRichText (KoSvgTextShape *insert, bool inheritPropertiesIfPossible=false)
	Insert rich text at getPos();.
void	insertText (QString text)
	Insert text at getPos()
bool	isAddingCommand () const
	the cursor is currently adding a command
void	keyPressEvent (QKeyEvent *event)
	Handle the cursor-related key events.
void	mergePropertiesIntoSelection (const KoSvgTextProperties props, const QSet< KoSvgTextProperties::PropertyId > removeProperties=QSet< KoSvgTextProperties::PropertyId >(), bool paragraphOnly=false, bool selectWord=false)
	mergePropertiesIntoSelection Within Krita's SVG/CSS text system, it is possible to apply incomplete properties to a whole range. In that case, only the existing properties are applied. Properties can also be removed this way.
void	moveCursor (MoveMode mode, bool moveAnchor=true)
	Move the cursor, and, if you don't want a selection, move the anchor.
void	notifyCursorPosChanged (int pos, int anchor) override
void	notifyMarkupChanged () override
void	notifyShapeChanged (KoShape::ChangeType type, KoShape *shape) override
void	paintDecorations (QPainter &gc, QColor selectionColor, int decorationThickness=1, qreal handleRadius=5.0, KisHandlePalette handlePalette=KisHandlePalette())
	Paint all decorations and blinkingcursors.
bool	paste ()
	paste pastes plain text in the clipboard at pos. Uses pasteRichTextByDefault to determine whether to try and paste rich text.
int	posForTypeSettingHandleAndRect (const TypeSettingModeHandle handle, const QRectF regionOfInterest)
	posForHandleAndRect Returns the closest cursor position for a given region and typesetting handle. Used by the type setting mode to find the relevant metrics to scale.
QList< KoSvgTextProperties >	propertiesForRange () const
	propertiesForRange
QList< KoSvgTextProperties >	propertiesForShape () const
	propertiesForShape
bool	registerPropertyAction (QAction *action, const QString &name)
	Register an action.
void	removeLastCodePoint ()
	removeLastCodePoint Special function to remove the last code point. Triggered by backspace. This is distinct from remove text, as some clusters have multiple code points, but it is generally expected backspace deletes the codepoints while delete with selection deletes the whole cluster.
void	removeSelection ()
	removeSelection if there's a selection, creates a text-removal command.
void	removeText (MoveMode first, MoveMode second)
	removeText remove text relative to the current position. This will move the cursor according to the move modes and then remove the text between the two positions.
void	setCaretSetting (int cursorWidth=1, int cursorFlash=1000, int cursorFlashLimit=5000, bool drawCursorInAdditionToSelection=false)
	setCaretSetting Set the caret settings for the cursor. Qt has some standard functionality associated, which we pass via this.
bool	setDominantBaselineFromHandle (const TypeSettingModeHandle handle)
	setDominantBaselineFromHandle Set the dominant baseline from a given handle.
void	setDrawTypeSettingHandle (bool draw)
void	setPasteRichTextByDefault (const bool pasteRichText=true)
	setPasteRichText
void	setPos (int pos, int anchor)
	Set the pos and the anchor.
void	setPosToPoint (QPointF point, bool moveAnchor=true)
	Set the pos from a point. This currently does a search inside the text shape.
void	setShape (KoSvgTextShape *textShape)
	setShape
void	setTypeSettingHandleHovered (TypeSettingModeHandle hovered=TypeSettingModeHandle::NoHandle)
	Set a given typesetting handle as hovered, so it will be drawn as such.
void	setTypeSettingModeActive (bool activate)
	Set type setting mode active.
void	setVisualMode (const bool visualMode=true)
	setVisualMode set whether the navigation mode is visual or logical. This right now primarily affects Bidirectional text.
KoSvgTextShape *	shape () const
	Get the current text shape.
	SvgTextCursor (KoCanvasBase *canvas)
KoSvgTextPropertiesInterface *	textPropertyInterface ()
TypeSettingModeHandle	typeSettingHandleAtPos (const QRectF regionOfInterest)
	Get typeSettingMode handle for text;.
void	updateModifiers (const Qt::KeyboardModifiers modifiers)
void	updateTypeSettingDecorFromShape ()
	Update the type setting decorations.
	~SvgTextCursor ()
Public Member Functions inherited from Private
	Private (KisCanvas2 *c)
Public Member Functions inherited from KoToolSelection
	KoToolSelection (QObject *parent=0)
	~KoToolSelection () override
Public Member Functions inherited from KoSvgTextShape::TextCursorChangeListener
void	notifyShapeChanged (ChangeType type, KoShape *shape) override
Public Member Functions inherited from KoShape::ShapeChangeListener
virtual	~ShapeChangeListener ()

Public Attributes
QList< QAction * >	actions
int	anchor = 0
QLineF	anchorCaret
int	anchorIndex = 0
bool	blockQueryUpdates = false
	Block qApp->inputMethod->update(), enabled during the inputmethod event flow.
KoCanvasBase *	canvas
QLineF	cursorCaret
QColor	cursorColor
QTimer	cursorFlash
QTimer	cursorFlashLimit
QPainterPath	cursorShape
bool	cursorVisible = false
int	cursorWidth = 1
bool	drawCursorInAdditionToSelection = false
bool	drawTypeSettingHandle = true
qreal	handleRadius = 7
bool	hasFocus = false
SvgTextCursor::TypeSettingModeHandle	hoveredTypeSettingHandle = SvgTextCursor::NoHandle
QPainterPath	IMEDecoration
	The decorations for the current preedit string.
SvgTextCursorPropertyInterface *	interface {nullptr}
bool	isAddingCommand = false
Qt::KeyboardModifiers	lastKnownModifiers
QRectF	oldCursorRect
QRectF	oldIMEDecorationRect
	Update Rectangle of previous decoration.
QRectF	oldSelectionRect
QRectF	oldTypeSettingRect
bool	pasteRichText = true
int	pos = 0
int	posIndex = 0
SvgTextInsertCommand *	preEditCommand {nullptr}
	PreEdit string as an command provided by the input method.
int	preEditLength = -1
	Length of the preEditString.
int	preEditStart = -1
	Start of the preEdit string as a cursor pos.
KisAcyclicSignalConnector	resourceManagerAcyclicConnector
QPainterPath	selection
KoSvgTextShape *	shape {nullptr}
QVector< IMEDecorationInfo >	styleMap
	Decoration info (underlines) for the preEdit string to differentiate it from regular text.
TypeSettingDecorInfo	typeSettingDecor
bool	typeSettingMode = false
bool	visualNavigation = true
Public Attributes inherited from Private
KisCanvas2 *	canvas
int	displayedFrame
int	intendedFrame

Private Slots
void	blinkCursor ()
	Called by timer, toggles the text cursor visible or invisible.
void	canvasResourceChanged (int key, const QVariant &value)
	Called when the canvas resources (foreground/background) change.
void	clearFormattingAction ()
	Called by the clear formatting action.
bool	pastePlainText ()
	pastePlainText Explicitely paste plaintext at pos.
bool	pasteRichText ()
	pasteRichText
void	propertyAction ()
	Called by the actions to execute a property change based on their data.
void	removeTransformsFromRange ()
	removeTransformsFromRange Called by actions to remove svg character transforms from range.
void	stopBlinkCursor ()
	Called by timer, stops the text blinking animation.
void	updateCanvasResources ()
	Update the canvas resources with fore and background color.
void	updateInputMethodItemTransform ()

Private Member Functions
bool	acceptableInput (const QKeyEvent *event) const
	More or less copied from bool QInputControl::isAcceptableInput(const QKeyEvent *event) const.
void	addCommandToUndoAdapter (KUndo2Command *cmd)
	Adds a command to the canvas of the parent tool.
void	commitIMEPreEdit ()
int	moveModeResult (const MoveMode mode, int &pos, bool visual=false) const
	Processes a move action, returns the input.
SvgTextRemoveCommand *	removeSelectionImpl (bool allowCleanUp, KUndo2Command *parent=0)
	removeSelection if there's a selection, creates a text-removal command.
void	updateCursor (bool firstUpdate=false)
	update the cursor shape. First update will block ensuring the canvas is visible so setShape won't cause this.
void	updateIMEDecoration ()
void	updateSelection ()
void	updateTypeSettingDecoration ()

Private Attributes
const QScopedPointer< Private >	d

Detailed Description

The SvgTextCursor class.

This class handles cursor movement and text editing operations.

It acts as the KoToolSelection for SvgTextTool, allowing it to integrate with the basic KoToolBase functionality for copy, cut paste and clear.

A selection is defined as the anchor being different from the cursor position, with the move operation accepting whether you want to shift the cursor position.

It is also a shape listener to allow the textcursor to update itself whenever the corresponding text shape changes.

Note for Android: to get a debug view of where the text input is at the operating system level, you can set an environment variable:

qputenv("KRITA_ANDROID_EDIT_TEXT_DEBUG_DRAW", "1")

Definition at line 156 of file SvgTextCursor.cpp.

Member Enumeration Documentation

MoveMode

enum SvgTextCursor::MoveMode

Enumerator
MoveNone
MoveLeft
MoveRight
MoveUp
MoveDown
MoveNextChar
MovePreviousChar
MoveNextLine
MovePreviousLine
MoveWordLeft
MoveWordRight
MoveWordEnd
MoveWordStart
MoveLineStart
MoveLineEnd
ParagraphStart
ParagraphEnd

Definition at line 55 of file SvgTextCursor.h.

                  {
        MoveNone,
        MoveLeft,
        MoveRight,
        MoveUp,
        MoveDown,
        MoveNextChar,
        MovePreviousChar,
        MoveNextLine,
        MovePreviousLine,
        MoveWordLeft,
        MoveWordRight,
        MoveWordEnd,
        MoveWordStart,
        MoveLineStart,
        MoveLineEnd,
        ParagraphStart,
        ParagraphEnd,
    };

TypeSettingModeHandle

enum SvgTextCursor::TypeSettingModeHandle

Handles used by type setting mode.

Enumerator
NoHandle
StartPos
EndPos
BaselineShift	The text properties handles.
Ascender
Descender
LineHeightTop
LineHeightBottom
BaselineAlphabetic	Baselines.
BaselineIdeographic
BaselineMiddle
BaselineHanging
BaselineMathematical
BaselineCentral

Definition at line 76 of file SvgTextCursor.h.

                               {
        NoHandle,
        StartPos,
        EndPos,
 
        BaselineShift,
        Ascender,
        Descender,
        LineHeightTop,
        LineHeightBottom,
 
        BaselineAlphabetic,
        BaselineIdeographic,
        BaselineMiddle,
        BaselineHanging,
        BaselineMathematical,
        BaselineCentral
    };

Constructor & Destructor Documentation

SvgTextCursor()

SvgTextCursor::SvgTextCursor ( KoCanvasBase * canvas )

explicit

Definition at line 252 of file SvgTextCursor.cpp.

                                                 :
    d(new Private)
{
    d->canvas = canvas;
    d->interface = new SvgTextCursorPropertyInterface(this);
    if (d->canvas->canvasController()) {
        // Mockcanvas in the tests has no canvas controller.
        connect(d->canvas->canvasController()->proxyObject, SIGNAL(sizeChanged(QSize)), this, SLOT(updateInputMethodItemTransform()));
        connect(d->canvas->canvasController()->proxyObject,
                SIGNAL(moveDocumentOffset(QPointF, QPointF)),
                this,
                SLOT(updateInputMethodItemTransform()));
        connect(d->canvas->canvasController()->proxyObject,
                SIGNAL(effectiveZoomChanged(qreal)),
                this,
                SLOT(updateInputMethodItemTransform()));
        connect(d->canvas->canvasController()->proxyObject,
                SIGNAL(documentRotationChanged(qreal)),
                this,
                SLOT(updateInputMethodItemTransform()));
        connect(d->canvas->canvasController()->proxyObject,
                SIGNAL(documentMirrorStatusChanged(bool, bool)),
                this,
                SLOT(updateInputMethodItemTransform()));
        d->resourceManagerAcyclicConnector.connectBackwardResourcePair(
                    d->canvas->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)),
                    this, SLOT(canvasResourceChanged(int,QVariant)));
        d->resourceManagerAcyclicConnector.connectForwardVoid(d->interface, SIGNAL(textCharacterSelectionChanged()), this, SLOT(updateCanvasResources()));
    }
 
}

References canvas, canvasResourceChanged(), d, updateCanvasResources(), and updateInputMethodItemTransform().

~SvgTextCursor()

SvgTextCursor::~SvgTextCursor

(

)

Definition at line 284 of file SvgTextCursor.cpp.

{
    commitIMEPreEdit();
    d->cursorFlash.stop();
    d->cursorFlashLimit.stop();
    d->shape = nullptr;
}

References commitIMEPreEdit(), and d.

Member Function Documentation

acceptableInput()

bool SvgTextCursor::acceptableInput ( const QKeyEvent * event ) const

private

More or less copied from bool QInputControl::isAcceptableInput(const QKeyEvent *event) const.

Tests whether the current keyboard input can be printed as text, or is probably a shortcut. This is so that various keyboard events, like print don't get inserted as text.

Definition at line 2103 of file SvgTextCursor.cpp.

{
    const QString text = event->text();
    if (text.isEmpty())
        return false;
    const QChar c = text.at(0);
    // Formatting characters such as ZWNJ, ZWJ, RLM, etc. This needs to go before the
    // next test, since CTRL+SHIFT is sometimes used to input it on Windows.
    if (c.category() == QChar::Other_Format)
        return true;
    // QTBUG-35734: ignore Ctrl/Ctrl+Shift; accept only AltGr (Alt+Ctrl) on German keyboards
    if (event->modifiers() == Qt::ControlModifier
            || event->modifiers() == (Qt::ShiftModifier | Qt::ControlModifier)) {
        return false;
    }
    if (c.isPrint())
        return true;
    if (c.category() == QChar::Other_PrivateUse)
        return true;
    if (c == QLatin1Char('\t'))
        return true;
    return false;
}

addCommandToUndoAdapter()

void SvgTextCursor::addCommandToUndoAdapter ( KUndo2Command * cmd )

private

Adds a command to the canvas of the parent tool.

Definition at line 2017 of file SvgTextCursor.cpp.

{
    if (d->canvas) {
        if (cmd) {
            d->isAddingCommand = true;
            d->canvas->addCommand(cmd);
            d->isAddingCommand = false;
        }
    }
}

References d.

blinkCursor

void SvgTextCursor::blinkCursor ( )

privateslot

Called by timer, toggles the text cursor visible or invisible.

Definition at line 1277 of file SvgTextCursor.cpp.

{
    if (d->shape) {
        Q_EMIT updateCursorDecoration(d->shape->shapeToDocument(d->cursorShape.boundingRect()) | d->oldCursorRect);
        d->cursorVisible = !d->cursorVisible;
    }
}

References d, and updateCursorDecoration().

canvasResourceChanged

void SvgTextCursor::canvasResourceChanged ( int key, const QVariant & value )

privateslot

Called when the canvas resources (foreground/background) change.

Definition at line 1323 of file SvgTextCursor.cpp.

{
    if (!d->shape || (key != KoCanvasResource::ForegroundColor && key != KoCanvasResource::BackgroundColor))
        return;
 
    KoSvgTextProperties props;
    KoSvgTextProperties shapeProps = hasSelection()? d->shape->propertiesForPos(qMin(d->pos, d->anchor), true): d->shape->textProperties();
    if (key == KoCanvasResource::ForegroundColor) {
        QSharedPointer<KoShapeBackground> bg(new KoColorBackground(value.value<KoColor>().toQColor()));
        if (!bg->compareTo(shapeProps.background().data())
                || !shapeProps.hasProperty(KoSvgTextProperties::FillId)) {
            props.setProperty(KoSvgTextProperties::FillId,
                              QVariant::fromValue(KoSvgText::BackgroundProperty(bg)));
        }
    } else if (key == KoCanvasResource::BackgroundColor) {
        QSharedPointer<KoShapeStroke> stroke(new KoShapeStroke());
        if (shapeProps.hasProperty(KoSvgTextProperties::StrokeId)) {
            KoShapeStrokeSP shapeStroke = qSharedPointerDynamicCast<KoShapeStroke>(shapeProps.stroke());
            if (shapeStroke->isVisible()) {
                stroke.reset(new KoShapeStroke(*shapeStroke));
            }
        }
        stroke->setColor(value.value<KoColor>().toQColor());
        if (!stroke->compareFillTo(shapeProps.stroke().data()) || !shapeProps.hasProperty(KoSvgTextProperties::StrokeId)) {
            props.setProperty(KoSvgTextProperties::StrokeId,
                              QVariant::fromValue(KoSvgText::StrokeProperty(stroke)));
        }
    }
    if (!props.isEmpty()) {
        mergePropertiesIntoSelection(props, QSet<KoSvgTextProperties::PropertyId>(), !hasSelection());
    }
}

References KoSvgTextProperties::background(), KoCanvasResource::BackgroundColor, d, KoSvgTextProperties::FillId, KoCanvasResource::ForegroundColor, KoSvgTextProperties::hasProperty(), hasSelection(), KoSvgTextProperties::isEmpty(), mergePropertiesIntoSelection(), KoSvgTextProperties::setProperty(), KoSvgTextProperties::stroke(), KoSvgTextProperties::StrokeId, KoColor::toQColor(), and value().

clearFormattingAction

void SvgTextCursor::clearFormattingAction ( )

privateslot

Called by the clear formatting action.

Definition at line 1367 of file SvgTextCursor.cpp.

{
    KoSvgTextProperties props;
 
    QSet<KoSvgTextProperties::PropertyId> ids;
 
    for (int i = 0; i < int(KoSvgTextProperties::LastPropertyId); i++) {
        ids.insert(KoSvgTextProperties::PropertyId(i));
    }
 
    mergePropertiesIntoSelection(props, ids);
}

References KoSvgTextProperties::LastPropertyId, and mergePropertiesIntoSelection().

commitIMEPreEdit()

void SvgTextCursor::commitIMEPreEdit ( )

private

This applies any running IME interactions, used when the shape is deselected halfways through an IME interaction.

Definition at line 2127 of file SvgTextCursor.cpp.

{
    if (!d->preEditCommand) {
        return;
    }
 
    qApp->inputMethod()->commit();
 
    if (!d->preEditCommand) {
        return;
    }
 
    d->preEditCommand->undo();
    d->preEditCommand = nullptr;
    d->preEditStart = -1;
    d->preEditLength = 0;
    updateIMEDecoration();
    updateCursor();
}

References d, updateCursor(), and updateIMEDecoration().

copy()

void SvgTextCursor::copy

(

)

const

copy copies plain text into the clipboard between anchor and pos.

Definition at line 738 of file SvgTextCursor.cpp.

{
    if (d->shape) {
        int start = d->shape->indexForPos(qMin(d->anchor, d->pos));
        int length = d->shape->indexForPos(qMax(d->anchor, d->pos)) - start;
        QString copied = d->shape->plainText().mid(start, length);
        std::unique_ptr<KoSvgTextShape> copy = d->shape->copyRange(start, length);
        QClipboard *cb = QApplication::clipboard();
 
        if (copy) {
            KoSvgTextShapeMarkupConverter converter(copy.get());
            QString svg;
            QString styles;
            QString html;
            QMimeData *svgData = new QMimeData();
            if (converter.convertToSvg(&svg, &styles)) {
                QString svgDoc = QString("<svg xmlns=\"http://www.w3.org/2000/svg\" version=\"2.0\">%1\n%2</svg>").arg(styles).arg(svg);
                svgData->setData(QLatin1String("image/svg+xml"), svgDoc.toUtf8());
            }
            svgData->setText(copied);
            if (converter.convertToHtml(&html))
                svgData->setHtml(html);
            cb->setMimeData(svgData);
        } else {
            cb->setText(copied);
        }
 
    }
}

References KoSvgTextShapeMarkupConverter::convertToHtml(), KoSvgTextShapeMarkupConverter::convertToSvg(), d, and length().

currentTextProperties()

QPair< KoSvgTextProperties, KoSvgTextProperties > SvgTextCursor::currentTextProperties

(

)

const

currentTextProperties

Returns

a qpair, where the first is the properties without inheritance, and the second, with inheritance.

Definition at line 676 of file SvgTextCursor.cpp.

{
    if (d->shape) {
        return QPair<KoSvgTextProperties, KoSvgTextProperties>(d->shape->propertiesForPos(d->pos), d->shape->propertiesForPos(d->pos, true));
    }
    return QPair<KoSvgTextProperties, KoSvgTextProperties>();
}

References d.

cursorTypeForTypeSetting()

QCursor SvgTextCursor::cursorTypeForTypeSetting

(

)

const

Return appropriate typeSetting cursor;.

Definition at line 456 of file SvgTextCursor.cpp.

{
    if (d->hoveredTypeSettingHandle == StartPos ||
            d->hoveredTypeSettingHandle == StartPos ||
            d->typeSettingDecor.testBaselines(d->lastKnownModifiers)) {
        return Qt::ArrowCursor;
    } else if (d->shape) {
        return (d->shape->writingMode() == KoSvgText::HorizontalTB)? Qt::SizeVerCursor: Qt::SizeHorCursor;
    }
    return Qt::ArrowCursor;
}

References d, KoSvgText::HorizontalTB, and StartPos.

deselectText()

void SvgTextCursor::deselectText

(

)

Deselect all text. This effectively makes anchor the same as pos.

Definition at line 830 of file SvgTextCursor.cpp.

{
    setPos(d->pos, d->pos);
}

References d, and setPos().

focusIn()

void SvgTextCursor::focusIn

(

)

Turns on blinking cursor.

Definition at line 1664 of file SvgTextCursor.cpp.

{
    d->cursorFlash.start();
    d->cursorFlashLimit.start();
    d->cursorVisible = false;
    d->hasFocus = true;
    blinkCursor();
}

References blinkCursor(), and d.

focusOut()

void SvgTextCursor::focusOut

(

)

Stops blinking cursor.

Definition at line 1673 of file SvgTextCursor.cpp.

{
    d->hasFocus = false;
    stopBlinkCursor();
}

References d, and stopBlinkCursor().

getAnchor()

int SvgTextCursor::getAnchor

(

)

Get the current selection anchor. This is the same as position, unless there's a selection.

Definition at line 352 of file SvgTextCursor.cpp.

{
    return d->anchor;
}

References d.

getPos()

int SvgTextCursor::getPos

(

)

Get the current position.

Definition at line 347 of file SvgTextCursor.cpp.

{
    return d->pos;
}

References d.

handleName()

QString SvgTextCursor::handleName

(

TypeSettingModeHandle

handle

)

const

handleName

Returns

translated name of a given handle.

Definition at line 468 of file SvgTextCursor.cpp.

{
    bool baseline = d->typeSettingDecor.testBaselines(d->lastKnownModifiers);
    if (handle == Ascender) {
        if (baseline) {
            return i18nc("Type setting mode line name", "Text Top");
        } else {
            return i18nc("Type setting mode line name", "Font Size");
        }
    } else if (handle == Descender) {
        if (baseline) {
            return i18nc("Type setting mode line name", "Text Bottom");
        } else {
            return i18nc("Type setting mode line name", "Font Size");
        }
    } else if (handle == BaselineAlphabetic) {
        return i18nc("Type setting mode line name", "Alphabetic");
    } else if (handle == BaselineIdeographic) {
        return i18nc("Type setting mode line name", "Ideographic");
    } else if (handle == BaselineHanging) {
        return i18nc("Type setting mode line name", "Hanging");
    } else if (handle == BaselineMiddle) {
        return i18nc("Type setting mode line name", "Middle");
    } else if (handle == BaselineMathematical) {
        return i18nc("Type setting mode line name", "Mathematical");
    } else if (handle == BaselineCentral) {
        return i18nc("Type setting mode line name", "Central");
    } else if (handle == LineHeightTop || handle == LineHeightBottom) {
        return i18nc("Type setting mode line name", "Line Height");
    } else if (handle == BaselineShift) {
        if (baseline) {
            return i18nc("Type setting mode line name", "Current Baseline");
        } else {
            return i18nc("Type setting mode line name", "Baseline Shift");
        }
    } else {
        return QString();
    }
}

References Ascender, BaselineAlphabetic, BaselineCentral, BaselineHanging, BaselineIdeographic, BaselineMathematical, BaselineMiddle, BaselineShift, d, Descender, LineHeightBottom, and LineHeightTop.

hasSelection()

bool SvgTextCursor::hasSelection ( )

overridevirtual

return true if the tool currently has something selected that can be copied or deleted.

Reimplemented from KoToolSelection.

Definition at line 1380 of file SvgTextCursor.cpp.

{
    return d->pos != d->anchor;
}

References d.

inputMethodEvent()

void SvgTextCursor::inputMethodEvent

(

QInputMethodEvent *

event

)

Process an input method event. This is used by IME like virtual keyboards.

Definition at line 1074 of file SvgTextCursor.cpp.

{
    dbgTools << "Commit:"<< event->commitString() << "predit:"<< event->preeditString();
    dbgTools << "Replacement:"<< event->replacementStart() << event->replacementLength();
 
    QRectF updateRect = d->shape? d->shape->boundingRect(): QRectF();
    SvgTextShapeManagerBlocker blocker(d->canvas->shapeManager());
 
    bool isGettingInput = !event->commitString().isEmpty() || !event->preeditString().isEmpty()
                || event->replacementLength() > 0;
 
    // Remove previous preedit string.
    if (d->preEditCommand) {
        d->preEditCommand->undo();
        d->preEditCommand = 0;
        d->preEditStart = -1;
        d->preEditLength = -1;
        updateRect |= d->shape? d->shape->boundingRect(): QRectF();
    }
 
    if (!d->shape || !isGettingInput) {
        blocker.unlock();
        d->canvas->shapeManager()->update(updateRect);
        event->ignore();
        return;
    }
 
    Private::InputQueryUpdateBlocker inputQueryUpdateBlocker(d);
 
    // remove the selection if any.
    addCommandToUndoAdapter(removeSelectionImpl(false));
 
    // set the text insertion pos to replacement start and also remove replacement length, if any.
    int originalPos = d->pos;
    int index = d->shape->indexForPos(d->pos) + event->replacementStart();
    d->pos = d->shape->posForIndex(index);
    if (event->replacementLength() > 0) {
        SvgTextRemoveCommand *cmd = new SvgTextRemoveCommand(d->shape,
                                                             index + event->replacementLength(),
                                                             originalPos,
                                                             d->anchor,
                                                             event->replacementLength(),
                                                             false);
        addCommandToUndoAdapter(cmd);
    }
 
    // add the commit string, if any.
    if (!event->commitString().isEmpty()) {
        insertText(event->commitString());
    }
 
    // set the selection...
    Q_FOREACH(const QInputMethodEvent::Attribute attribute, event->attributes()) {
        if (attribute.type == QInputMethodEvent::Selection) {
            d->pos = d->shape->posForIndex(attribute.start);
            int index = d->shape->indexForPos(d->pos);
            d->anchor = d->shape->posForIndex(index + attribute.length);
        }
    }
 
 
    // insert a preedit string, if any.
    if (!event->preeditString().isEmpty()) {
        int index = d->shape->indexForPos(d->pos);
        d->preEditCommand = new SvgTextInsertCommand(d->shape, d->pos, d->anchor, event->preeditString());
        d->preEditCommand->redo();
        d->preEditLength = event->preeditString().size();
        d->preEditStart = d->shape->posForIndex(index, true);
    } else {
        d->preEditCommand = 0;
    }
 
    // Apply the cursor offset for the preedit.
    QVector<IMEDecorationInfo> styleMap;
    Q_FOREACH(const QInputMethodEvent::Attribute attribute, event->attributes()) {
        dbgTools << "attribute: "<< attribute.type << "start: " << attribute.start
                 << "length: " << attribute.length << "val: " << attribute.value;
        // Text Format is about setting the look of the preedit string, and there can be multiple per event
        // we primarily interpret the underline. When a background color is set, we increase the underline
        // thickness, as that's what is actually supposed to happen according to the comments in the
        // platform input contexts for both macOS and Windows.
 
        if (attribute.type == QInputMethodEvent::TextFormat) {
            QVariant val = attribute.value;
            QTextCharFormat form = val.value<QTextFormat>().toCharFormat();
 
            if (attribute.length == 0 || attribute.start < 0 || !attribute.value.isValid()) {
                continue;
            }
 
            int positionA = -1;
            int positionB = -1;
            if (!styleMap.isEmpty()) {
                for (int i = 0; i < styleMap.size(); i++) {
                    if (attribute.start >= styleMap.at(i).start
                            && attribute.start < styleMap.at(i).start + styleMap.at(i).length) {
                        positionA = i;
                    }
                    if (attribute.start + attribute.length > styleMap.at(i).start
                            && attribute.start + attribute.length <= styleMap.at(i).start + styleMap.at(i).length) {
                        positionB = i;
                    }
                }
 
                if (positionA > -1 && positionA == positionB) {
                    IMEDecorationInfo decoration1 = styleMap.at(positionA);
                    IMEDecorationInfo decoration2 = decoration1;
                    IMEDecorationInfo decoration3 = decoration1;
                    decoration3.start = (attribute.start+attribute.length);
                    decoration3.length = (decoration1.start + decoration1.length) - decoration3.start;
                    decoration1.length = attribute.start - decoration1.start;
                    decoration2.start = attribute.start;
                    decoration2.length = attribute.length;
                    if (decoration1.length > 0) {
                        styleMap[positionA] = decoration1;
                        if (decoration2.length > 0) {
                            positionA += 1;
                            styleMap.insert(positionA, decoration2);
                        }
                    } else {
                        styleMap[positionA] = decoration2;
                    }
                    if (decoration3.length > 0) {
                        styleMap.insert(positionA + 1, decoration3);
                    }
                } else if (positionA > -1 && positionB > -1
                           && positionA != positionB) {
                    IMEDecorationInfo decoration1 = styleMap.at(positionA);
                    IMEDecorationInfo decoration2 = decoration1;
                    IMEDecorationInfo decoration3 = styleMap.at(positionB);
                    IMEDecorationInfo decoration4 = decoration3;
                    decoration2.length = (decoration1.start + decoration1.length) - attribute.start;
                    decoration1.length =  attribute.start - decoration1.start;
                    decoration2.start  =  attribute.start;
 
                    decoration4.start = (attribute.start+attribute.length);
                    decoration3.length = (decoration3.start + decoration3.length) - decoration4.start;
                    decoration3.length = decoration4.start - decoration3.start;
                    if (decoration1.length > 0) {
                        styleMap[positionA] = decoration1;
                        if (decoration2.length > 0) {
                            positionA += 1;
                            styleMap.insert(positionA, decoration2);
                        }
                    } else {
                        styleMap[positionA] = decoration2;
                    }
 
                    if (decoration3.length > 0) {
                        styleMap[positionB] = decoration3;
                        if (decoration4.length > 0) {
                            styleMap.insert(positionB + 1, decoration4);
                        }
                    } else {
                        styleMap[positionB] = decoration4;
                    }
                }
            }
 
            if (positionA > -1 && !styleMap.isEmpty()) {
 
                for(int i = positionA; i <= positionB; i++) {
                    IMEDecorationInfo decoration = styleMap.at(i);
                    decoration.setDecorationFromQTextCharFormat(form);
                    styleMap[i] = decoration;
                }
 
            } else {
                IMEDecorationInfo decoration;
                decoration.start = attribute.start;
                decoration.length = attribute.length;
                decoration.setDecorationFromQTextCharFormat(form);
                styleMap.append(decoration);
            }
 
        // QInputMethodEvent::Language is about setting the locale on the given  preedit string, which is not possible yet.
        // QInputMethodEvent::Ruby is supposedly ruby info for the preedit string, but none of the platform integrations
        // actually implement this at time of writing, and it may have been something from a previous live of Qt's.
        } else if (attribute.type == QInputMethodEvent::Cursor) {
            if (d->preEditStart < 0) {
                d->anchor = d->pos;
            } else {
                int index = d->shape->indexForPos(d->preEditStart);
                d->pos = d->shape->posForIndex(index + attribute.start);
                d->anchor = d->pos;
            }
 
            // attribute value is the cursor color, and should be used to paint the cursor.
            // attribute length is about whether the cursor should be visible at all...
        }
    }
 
    blocker.unlock();
    updateRect |= d->shape->boundingRect();
    // TODO: replace with KoShapeBulkActionLock
    d->shape->updateAbsolute(updateRect);
    d->styleMap = styleMap;
    updateIMEDecoration();
    updateSelection();
    updateCursor();
    event->accept();
}

References addCommandToUndoAdapter(), d, dbgTools, insertText(), IMEDecorationInfo::length, removeSelectionImpl(), IMEDecorationInfo::setDecorationFromQTextCharFormat(), IMEDecorationInfo::start, styleMap, updateCursor(), updateIMEDecoration(), and updateSelection().

inputMethodQuery()

QVariant SvgTextCursor::inputMethodQuery

(

Qt::InputMethodQuery

query

)

const

Process an input method query and return the requested result.

Definition at line 946 of file SvgTextCursor.cpp.

{
    dbgTools << "receiving inputmethod query" << query;
 
    // Because we set the input item transform to be shape->document->view->widget->window,
    // the coordinates here should be in shape coordinates.
    switch(query) {
    case Qt::ImEnabled:
        return d->shape? true: false;
        break;
    case Qt::ImCursorRectangle:
        // The platform integration will always define the cursor as the 'left side' handle.
        if (d->shape) {
            QPointF caret1(d->cursorCaret.p1());
            QPointF caret2(d->cursorCaret.p2());
 
 
            QRectF rect = QRectF(caret1, caret2).normalized();
            if (!rect.isValid()) {
                if (rect.height() < 1) {
                    rect.adjust(0, -1, 0, 0);
                }
                if (rect.width() < 1) {
                    rect.adjust(0, 0, 1, 0);
                }
 
            }
            return rect.toAlignedRect();
        }
        break;
    case Qt::ImAnchorRectangle:
        // The platform integration will always define the anchor as the 'right side' handle.
        if (d->shape) {
            QPointF caret1(d->anchorCaret.p1());
            QPointF caret2(d->anchorCaret.p2());
            QRectF rect = QRectF(caret1, caret2).normalized();
            if (rect.isEmpty()) {
                if (rect.height() < 1) {
                    rect.adjust(0, -1, 0, 0);
                }
                if (rect.width() < 1) {
                    rect = rect.adjusted(-1, 0, 0, 0).normalized();
                }
            }
            return rect.toAlignedRect();
        }
        break;
    //case Qt::ImFont: // not sure what this is used for, but we cannot sent out without access to properties.
    case Qt::ImAbsolutePosition:
    case Qt::ImCursorPosition:
        if (d->shape) {
            return d->shape->indexForPos(d->pos);
        }
        break;
    case Qt::ImSurroundingText:
        if (d->shape) {
            QString surroundingText = d->shape->plainText();
            int preEditIndex = d->preEditCommand? d->shape->indexForPos(d->preEditStart): 0;
            surroundingText.remove(preEditIndex, d->preEditLength);
            return surroundingText;
        }
        break;
    case Qt::ImCurrentSelection:
        if (d->shape) {
            QString surroundingText = d->shape->plainText();
            int preEditIndex = d->preEditCommand? d->shape->indexForPos(d->preEditStart): 0;
            surroundingText.remove(preEditIndex, d->preEditLength);
            int start = d->shape->indexForPos(qMin(d->anchor, d->pos));
            int length = d->shape->indexForPos(qMax(d->anchor, d->pos)) - start;
            return surroundingText.mid(start, length);
        }
        break;
    case Qt::ImTextBeforeCursor:
        if (d->shape) {
            int start = d->shape->indexForPos(d->pos);
            QString surroundingText = d->shape->plainText();
            int preEditIndex = d->preEditCommand? d->shape->indexForPos(d->preEditStart): 0;
            surroundingText.remove(preEditIndex, d->preEditLength);
            return surroundingText.left(start);
        }
        break;
    case Qt::ImTextAfterCursor:
        if (d->shape) {
            int start = d->shape->indexForPos(d->pos);
            QString surroundingText = d->shape->plainText();
            int preEditIndex = d->preEditCommand? d->shape->indexForPos(d->preEditStart): 0;
            surroundingText.remove(preEditIndex, d->preEditLength);
            return surroundingText.right(start);
        }
        break;
    case Qt::ImMaximumTextLength:
        return QVariant(); // infinite text length!
        break;
    case Qt::ImAnchorPosition:
        if (d->shape) {
            return d->shape->indexForPos(d->anchor);
        }
        break;
    case Qt::ImHints:
        // It would be great to use Qt::ImhNoTextHandles or Qt::ImhNoEditMenu,
        // but neither are implemented for anything but web platform integration
        return Qt::ImhMultiLine;
        break;
    // case Qt::ImPreferredLanguage: // requires access to properties.
#if defined(Q_OS_ANDROID) && KRITA_QT_HAS_ANDROID_INPUT_PLATFORM_DATA_SOFT_INPUT_ADJUST_NOTHING
    case Qt::ImPlatformData:
        // Platform-specific data. Qt normally only uses this on iOS, but we
        // have a patch that allows us to control the keyboard pan behavior.
        // Normally it pans the application window up if the text area would end
        // up underneath the keyboard, but that's silly for the on-canvas text
        // input because the location can be changed by panning the canvas. And
        // if you do that while the keyboard is up, you end up with the whole
        // window panned up for no reason until you dismiss and re-show it, so
        // better to just do nothing in the first place and let the user pan.
        return Qt::ANDROID_INPUT_PLATFORM_DATA_SOFT_INPUT_ADJUST_NOTHING;
#endif
    case Qt::ImEnterKeyType:
        if (d->shape) {
            return Qt::EnterKeyDefault; // because input method hint is always multiline, this will show a return key.
        }
        break;
    // case Qt::ImInputItemClipRectangle // whether the input item is clipped?
    default:
        return QVariant();
    }
    return QVariant();
}

References d, dbgTools, and length().

insertRichText()

void SvgTextCursor::insertRichText	(	KoSvgTextShape *	insert,
		bool	inheritPropertiesIfPossible = false )

Insert rich text at getPos();.

Definition at line 624 of file SvgTextCursor.cpp.

{
    if (d->shape) {
        //KUndo2Command *parentCmd = new KUndo2Command;
        if (hasSelection()) {
            SvgTextRemoveCommand *removeCmd = removeSelectionImpl(false);
            addCommandToUndoAdapter(removeCmd);
        }
 
        SvgTextInsertRichCommand *cmd = new SvgTextInsertRichCommand(d->shape, insert, d->pos, d->anchor, inheritPropertiesIfPossible);
        addCommandToUndoAdapter(cmd);
 
    }
}

References addCommandToUndoAdapter(), KoShape::anchor(), d, hasSelection(), and removeSelectionImpl().

insertText()

void SvgTextCursor::insertText

(

QString

text

)

Insert text at getPos()

Definition at line 608 of file SvgTextCursor.cpp.

{
 
    if (d->shape) {
        //KUndo2Command *parentCmd = new KUndo2Command;
        if (hasSelection()) {
            SvgTextRemoveCommand *removeCmd = removeSelectionImpl(false);
            addCommandToUndoAdapter(removeCmd);
        }
 
        SvgTextInsertCommand *insertCmd = new SvgTextInsertCommand(d->shape, d->pos, d->anchor, text);
        addCommandToUndoAdapter(insertCmd);
 
    }
}

References addCommandToUndoAdapter(), d, hasSelection(), and removeSelectionImpl().

isAddingCommand()

bool SvgTextCursor::isAddingCommand

(

)

const

the cursor is currently adding a command

keyPressEvent()

void SvgTextCursor::keyPressEvent

(

QKeyEvent *

event

)

Handle the cursor-related key events.

Definition at line 1417 of file SvgTextCursor.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(d->shape);
 
    updateModifiers(event->modifiers());
 
    if (d->preEditCommand) {
        //MacOS will keep sending keyboard events during IME handling.
        event->accept();
        return;
    }
 
    bool select = event->modifiers().testFlag(Qt::ShiftModifier);
 
    if (!((Qt::ControlModifier | Qt::AltModifier | Qt::MetaModifier) & event->modifiers())) {
 
        switch (event->key()) {
        case Qt::Key_Right:
            moveCursor(SvgTextCursor::MoveRight, !select);
            event->accept();
            break;
        case Qt::Key_Left:
            moveCursor(SvgTextCursor::MoveLeft, !select);
            event->accept();
            break;
        case Qt::Key_Up:
            moveCursor(SvgTextCursor::MoveUp, !select);
            event->accept();
            break;
        case Qt::Key_Down:
            moveCursor(SvgTextCursor::MoveDown, !select);
            event->accept();
            break;
        case Qt::Key_Delete:
            removeText(MoveNone, MoveNextChar);
            event->accept();
            break;
        case Qt::Key_Backspace:
            removeLastCodePoint();
            event->accept();
            break;
        case Qt::Key_Return:
        case Qt::Key_Enter:
            insertText("\n");
            event->accept();
            break;
        default:
            event->ignore();
        }
 
        if (event->isAccepted()) {
            return;
        }
    }
    if (acceptableInput(event)) {
        insertText(event->text());
        event->accept();
        return;
    }
 
    KoSvgTextProperties props = d->shape->textProperties();
 
    KoSvgText::WritingMode mode = KoSvgText::WritingMode(props.propertyOrDefault(KoSvgTextProperties::WritingModeId).toInt());
    KoSvgText::Direction direction = KoSvgText::Direction(props.propertyOrDefault(KoSvgTextProperties::DirectionId).toInt());
 
    // Qt's keysequence stuff doesn't handle vertical, so to test all the standard keyboard shortcuts as if it did,
    // we reinterpret the direction keys according to direction and writing mode, and test against that.
 
    int newKey = event->key();
 
    if (direction == KoSvgText::DirectionRightToLeft) {
        switch (newKey) {
        case Qt::Key_Left:
            newKey = Qt::Key_Right;
            break;
        case Qt::Key_Right:
            newKey = Qt::Key_Left;
            break;
        default:
            break;
        }
    }
 
    if (mode == KoSvgText::VerticalRL) {
        switch (newKey) {
        case Qt::Key_Left:
            newKey = Qt::Key_Down;
            break;
        case Qt::Key_Right:
            newKey = Qt::Key_Up;
            break;
        case Qt::Key_Up:
            newKey = Qt::Key_Left;
            break;
        case Qt::Key_Down:
            newKey = Qt::Key_Right;
            break;
        default:
            break;
        }
    } else if (mode == KoSvgText::VerticalRL) {
        switch (newKey) {
        case Qt::Key_Left:
            newKey = Qt::Key_Up;
            break;
        case Qt::Key_Right:
            newKey = Qt::Key_Down;
            break;
        case Qt::Key_Up:
            newKey = Qt::Key_Left;
            break;
        case Qt::Key_Down:
            newKey = Qt::Key_Right;
            break;
        default:
            break;
        }
    }
 
    QKeySequence testSequence(event->modifiers() | newKey);
 
 
    // Note for future, when we have format changing actions:
    // We'll need to test format change actions before the standard
    // keys, as one of the standard keys for deleting a line is ctrl+u
    // which would probably be expected to do underline before deleting.
 
    Q_FOREACH(QAction *action, d->actions) {
        if (action->shortcut() == testSequence) {
            event->accept();
            action->trigger();
            return;
        }
    }
 
    // This first set is already tested above, however, if they still
    // match, then it's one of the extra sequences for MacOs, which
    // seem to be purely logical, instead of the visual set we tested
    // above.
    if (testSequence == QKeySequence::MoveToNextChar) {
        moveCursor(SvgTextCursor::MoveNextChar, true);
        event->accept();
    } else if (testSequence == QKeySequence::SelectNextChar) {
        moveCursor(SvgTextCursor::MoveNextChar, false);
        event->accept();
    } else if (testSequence == QKeySequence::MoveToPreviousChar) {
        moveCursor(SvgTextCursor::MovePreviousChar, true);
        event->accept();
    } else if (testSequence == QKeySequence::SelectPreviousChar) {
        moveCursor(SvgTextCursor::MovePreviousChar, false);
        event->accept();
    } else if (testSequence == QKeySequence::MoveToNextLine) {
        moveCursor(SvgTextCursor::MoveNextLine, true);
        event->accept();
    } else if (testSequence == QKeySequence::SelectNextLine) {
        moveCursor(SvgTextCursor::MoveNextLine, false);
        event->accept();
    } else if (testSequence == QKeySequence::MoveToPreviousLine) {
        moveCursor(SvgTextCursor::MovePreviousLine, true);
        event->accept();
    } else if (testSequence == QKeySequence::SelectPreviousLine) {
        moveCursor(SvgTextCursor::MovePreviousLine, false);
        event->accept();
 
    } else if (testSequence == QKeySequence::MoveToNextWord) {
        moveCursor(SvgTextCursor::MoveWordEnd, true);
        event->accept();
    } else if (testSequence == QKeySequence::SelectNextWord) {
        moveCursor(SvgTextCursor::MoveWordEnd, false);
        event->accept();
    } else if (testSequence == QKeySequence::MoveToPreviousWord) {
        moveCursor(SvgTextCursor::MoveWordStart, true);
        event->accept();
    } else if (testSequence == QKeySequence::SelectPreviousWord) {
        moveCursor(SvgTextCursor::MoveWordStart, false);
        event->accept();
 
    } else if (testSequence == QKeySequence::MoveToStartOfLine) {
        moveCursor(SvgTextCursor::MoveLineStart, true);
        event->accept();
    } else if (testSequence == QKeySequence::SelectStartOfLine) {
        moveCursor(SvgTextCursor::MoveLineStart, false);
        event->accept();
    } else if (testSequence == QKeySequence::MoveToEndOfLine) {
        moveCursor(SvgTextCursor::MoveLineEnd, true);
        event->accept();
    } else if (testSequence == QKeySequence::SelectEndOfLine) {
        moveCursor(SvgTextCursor::MoveLineEnd, false);
        event->accept();
 
    } else if (testSequence == QKeySequence::MoveToStartOfBlock
               || testSequence == QKeySequence::MoveToStartOfDocument) {
        moveCursor(SvgTextCursor::ParagraphStart, true);
        event->accept();
    } else if (testSequence == QKeySequence::SelectStartOfBlock
               || testSequence == QKeySequence::SelectStartOfDocument) {
        moveCursor(SvgTextCursor::ParagraphStart, false);
        event->accept();
 
    } else if (testSequence == QKeySequence::MoveToEndOfBlock
               || testSequence == QKeySequence::MoveToEndOfDocument) {
        moveCursor(SvgTextCursor::ParagraphEnd, true);
        event->accept();
    } else if (testSequence == QKeySequence::SelectEndOfBlock
               || testSequence == QKeySequence::SelectEndOfDocument) {
        moveCursor(SvgTextCursor::ParagraphEnd, false);
        event->accept();
 
    }else if (testSequence == QKeySequence::DeleteStartOfWord) {
        removeText(MoveWordStart, MoveNone);
        event->accept();
    } else if (testSequence == QKeySequence::DeleteEndOfWord) {
        removeText(MoveNone, MoveWordEnd);
        event->accept();
    } else if (testSequence == QKeySequence::DeleteEndOfLine) {
        removeText(MoveNone, MoveLineEnd);
        event->accept();
    } else if (testSequence == QKeySequence::DeleteCompleteLine) {
        removeText(MoveLineStart, MoveLineEnd);
        event->accept();
    } else if (testSequence == QKeySequence::Backspace) {
        removeLastCodePoint();
        event->accept();
    } else if (testSequence == QKeySequence::Delete) {
        removeText(MoveNone, MoveNextChar);
        event->accept();
 
    } else if (testSequence == QKeySequence::InsertLineSeparator
               || testSequence == QKeySequence::InsertParagraphSeparator) {
        insertText("\n");
        event->accept();
    } else {
        event->ignore();
    }
}

References acceptableInput(), d, KoSvgTextProperties::DirectionId, KoSvgText::DirectionRightToLeft, insertText(), KIS_SAFE_ASSERT_RECOVER_RETURN, moveCursor(), MoveDown, MoveLeft, MoveLineEnd, MoveLineStart, MoveNextChar, MoveNextLine, MoveNone, MovePreviousChar, MovePreviousLine, MoveRight, MoveUp, MoveWordEnd, MoveWordStart, ParagraphEnd, ParagraphStart, KoSvgTextProperties::propertyOrDefault(), removeLastCodePoint(), removeText(), updateModifiers(), KoSvgText::VerticalRL, and KoSvgTextProperties::WritingModeId.

mergePropertiesIntoSelection()

void SvgTextCursor::mergePropertiesIntoSelection	(	const KoSvgTextProperties	props,
		const QSet< KoSvgTextProperties::PropertyId >	removeProperties = QSet<KoSvgTextProperties::PropertyId>(),
		bool	paragraphOnly = false,
		bool	selectWord = false )

mergePropertiesIntoSelection Within Krita's SVG/CSS text system, it is possible to apply incomplete properties to a whole range. In that case, only the existing properties are applied. Properties can also be removed this way.

Parameters

props	– properties to apply.
removeProperties	– properties to be removed.
paragraphOnly	– whether to apply to the paragraph.
selectWord	– whether to select the word if there's no selection.

Definition at line 700 of file SvgTextCursor.cpp.

{
    if (d->shape) {
        int start = -1;
        int end = -1;
        if (!paragraphOnly) {
            start = d->pos;
            end = d->anchor;
        }
        if (selectWord && d->pos == d->anchor) {
            const int finalPos = d->shape->posForIndex(d->shape->plainText().size());
            start = qBound(0, moveModeResult(MoveWordStart, d->pos, d->visualNavigation), finalPos);
            end = qBound(0, moveModeResult(MoveWordEnd, d->pos, d->visualNavigation), finalPos);
        }
        KUndo2Command *cmd = new SvgTextMergePropertiesRangeCommand(d->shape, props, start, end, removeProperties);
        addCommandToUndoAdapter(cmd);
    }
}

References addCommandToUndoAdapter(), d, moveModeResult(), MoveWordEnd, and MoveWordStart.

moveCursor()

void SvgTextCursor::moveCursor	(	MoveMode	mode,
		bool	moveAnchor = true )

Move the cursor, and, if you don't want a selection, move the anchor.

Definition at line 593 of file SvgTextCursor.cpp.

{
    if (d->shape) {
 
        const int finalPos = d->shape->posForIndex(d->shape->plainText().size());
        d->pos = qBound(0, moveModeResult(mode, d->pos, d->visualNavigation), finalPos);
 
        if (moveAnchor) {
            d->anchor = d->pos;
        }
        updateSelection();
        updateCursor();
    }
}

References d, moveModeResult(), updateCursor(), and updateSelection().

moveModeResult()

int SvgTextCursor::moveModeResult ( const MoveMode mode, int & pos, bool visual = false ) const

private

Processes a move action, returns the input.

Definition at line 2028 of file SvgTextCursor.cpp.

{
    int newPos = pos;
    switch (mode) {
        case MoveNone:
        break;
    case MoveLeft:
        newPos = d->shape->posLeft(pos, visual);
        break;
    case MoveRight:
        newPos = d->shape->posRight(pos, visual);
        break;
    case MoveUp:
        newPos = d->shape->posUp(pos, visual);
        break;
    case MoveDown:
        newPos = d->shape->posDown(pos, visual);
        break;
    case MovePreviousChar:
        newPos = d->shape->previousIndex(pos);
        break;
    case MoveNextChar:
        newPos = d->shape->nextIndex(pos);
        break;
    case MovePreviousLine:
        newPos = d->shape->previousLine(pos);
        break;
    case MoveNextLine:
        newPos = d->shape->nextLine(pos);
        break;
    case MoveWordLeft:
        newPos = d->shape->wordLeft(pos, visual);
        if (newPos == pos) {
            newPos = d->shape->posLeft(pos, visual);
            newPos = d->shape->wordLeft(newPos, visual);
        }
        break;
    case MoveWordRight:
        newPos = d->shape->wordRight(pos, visual);
        if (newPos == pos) {
            newPos = d->shape->posRight(pos, visual);
            newPos = d->shape->wordRight(newPos, visual);
        }
        break;
    case MoveWordStart:
        newPos = d->shape->wordStart(pos);
        if (newPos == pos) {
            newPos = d->shape->previousIndex(pos);
            newPos = d->shape->wordStart(newPos);
        }
        break;
    case MoveWordEnd:
        newPos = d->shape->wordEnd(pos);
        if (newPos == pos) {
            newPos = d->shape->nextIndex(pos);
            newPos = d->shape->wordEnd(newPos);
        }
        break;
    case MoveLineStart:
        newPos = d->shape->lineStart(pos);
        break;
    case MoveLineEnd:
        newPos = d->shape->lineEnd(pos);
        break;
    case ParagraphStart:
        newPos = 0;
        break;
    case ParagraphEnd:
        newPos = d->shape->posForIndex(d->shape->plainText().size());
        break;
    }
    return newPos;
}

References d, MoveDown, MoveLeft, MoveLineEnd, MoveLineStart, MoveNextChar, MoveNextLine, MoveNone, MovePreviousChar, MovePreviousLine, MoveRight, MoveUp, MoveWordEnd, MoveWordLeft, MoveWordRight, MoveWordStart, ParagraphEnd, ParagraphStart, and pos.

notifyCursorPosChanged()

void SvgTextCursor::notifyCursorPosChanged ( int pos, int anchor )

overridevirtual

TextCursorChangeListener reimplementation, this allows undo commands to update the cursor without having the cursor owned by the command.

Implements KoSvgTextShape::TextCursorChangeListener.

Definition at line 1398 of file SvgTextCursor.cpp.

{
    Private::InputQueryUpdateBlocker inputQueryUpdateBlocker(d);
    d->pos = pos;
    d->anchor = anchor;
    updateCursor();
    updateSelection();
    updateTypeSettingDecoration();
}

References anchor, d, pos, updateCursor(), updateSelection(), and updateTypeSettingDecoration().

notifyMarkupChanged()

void SvgTextCursor::notifyMarkupChanged ( )

overridevirtual

Implements KoSvgTextShape::TextCursorChangeListener.

Definition at line 1408 of file SvgTextCursor.cpp.

{
    d->interface->emitSelectionChange();
    d->interface->emitCharacterSelectionChange();
    updateCursor();
    updateSelection();
    updateTypeSettingDecoration();
}

References d, updateCursor(), updateSelection(), and updateTypeSettingDecoration().

notifyShapeChanged()

void SvgTextCursor::notifyShapeChanged ( KoShape::ChangeType type, KoShape * shape )

overridevirtual

ShapeChangeListener reimplementation. This will update the cursor position when the shape was updated.

Implements KoShape::ShapeChangeListener.

Definition at line 1385 of file SvgTextCursor.cpp.

{
    Q_UNUSED(type);
    Q_UNUSED(shape);
    Private::InputQueryUpdateBlocker inputQueryUpdateBlocker(d);
    d->pos = d->shape->posForIndex(d->posIndex);
    d->anchor = d->shape->posForIndex(d->anchorIndex);
    updateCursor(true);
    updateSelection();
    updateInputMethodItemTransform();
    updateTypeSettingDecoration();
}

References d, shape, updateCursor(), updateInputMethodItemTransform(), updateSelection(), and updateTypeSettingDecoration().

paintDecorations()

void SvgTextCursor::paintDecorations	(	QPainter &	gc,
		QColor	selectionColor,
		int	decorationThickness = 1,
		qreal	handleRadius = 5.0,
		KisHandlePalette	handlePalette = KisHandlePalette() )

Paint all decorations and blinkingcursors.

Definition at line 844 of file SvgTextCursor.cpp.

{
    if (d->shape) {
        gc.save();
        gc.setTransform(d->shape->absoluteTransformation(), true);
 
        if (d->pos != d->anchor && !d->typeSettingMode) {
            gc.save();
            gc.setOpacity(0.5);
            QBrush brush(selectionColor);
            gc.fillPath(d->selection, brush);
            gc.restore();
        }
 
        if ( (d->drawCursorInAdditionToSelection || d->pos == d->anchor)
                && d->cursorVisible) {
            QPen pen;
            pen.setCosmetic(true);
            QColor c = d->cursorColor.isValid()? d->cursorColor: Qt::black;
            pen.setColor(bgColorForCaret(c, handlePalette));
            pen.setWidth((d->cursorWidth + 2) * decorationThickness);
            gc.setPen(pen);
            gc.drawPath(d->cursorShape);
            pen.setColor(d->canvas->displayRendererInterface()->convertColorToDisplayColorSpace(KoColor(c, KoColorSpaceRegistry::instance()->rgb8())) );
            pen.setWidth(d->cursorWidth * decorationThickness);
            gc.setPen(pen);
            gc.drawPath(d->cursorShape);
 
        }
 
        if (d->preEditCommand) {
            gc.save();
            QBrush brush(selectionColor);
            gc.setOpacity(0.5);
            gc.fillPath(d->IMEDecoration, brush);
            gc.restore();
        }
        if (d->typeSettingMode && d->drawTypeSettingHandle) {
            d->handleRadius = handleRadius;
            QTransform painterTf = gc.transform();
            KisHandlePainterHelper helper(&gc, handleRadius, decorationThickness);
            const KisHandleStyle highlight = KisHandleStyle::partiallyHighlightedPrimaryHandles(handlePalette);
            const KisHandleStyle regular = KisHandleStyle::secondarySelection(handlePalette);
 
            QMap<SvgTextCursor::TypeSettingModeHandle, QPainterPath> paths
                    = d->typeSettingDecor.testBaselines(d->lastKnownModifiers)? d->typeSettingDecor.baselines: d->typeSettingDecor.paths;
            QMap<SvgTextCursor::TypeSettingModeHandle, QPainterPath> parentPaths
                    = d->typeSettingDecor.testBaselines(d->lastKnownModifiers)? d->typeSettingDecor.parentBaselines: d->typeSettingDecor.parentPaths;
            Q_FOREACH(SvgTextCursor::TypeSettingModeHandle handle, paths.keys()) {
                const QPainterPath p = paths.value(handle);
                const QPainterPath parent = parentPaths.value(handle);
                if (d->hoveredTypeSettingHandle == handle) {
                    helper.setHandleStyle(highlight);
                    helper.drawPath(parent);
                    helper.drawPath(p);
                } else {
                    gc.save();
                    QPen pen(selectionColor, decorationThickness, handle == BaselineShift? Qt::SolidLine: Qt::DashLine);
                    pen.setCosmetic(true);
                    gc.setPen(pen);
                    gc.setOpacity(0.5);
                    gc.drawPath(painterTf.map(parent));
                    gc.drawPath(painterTf.map(p));
                    gc.restore();
                }
                gc.save();
                QPen pen(selectionColor, decorationThickness, Qt::SolidLine);
                pen.setCosmetic(true);
                gc.setPen(pen);
                gc.setOpacity(0.5);
                gc.drawPath(painterTf.map(d->typeSettingDecor.edges));
                gc.restore();
            }
 
            if (d->typeSettingDecor.handlesEnabled) {
                helper.setHandleStyle(d->hoveredTypeSettingHandle == EndPos? highlight: regular);
                helper.drawHandleCircle(d->typeSettingDecor.handles.second);
                helper.setHandleStyle(d->hoveredTypeSettingHandle == StartPos? highlight: regular);
                helper.drawHandleRect(d->typeSettingDecor.handles.first);
            }
            QString name = handleName(d->hoveredTypeSettingHandle);
            if (!name.isEmpty()) {
                QPainterPath textP;
                // When we're drawing on opengl, there's no anti-aliasing, so we should have full hinting for readabiltiy.
                QFont font = gc.font();
                font.setHintingPreference(QFont::PreferFullHinting);
                textP.addText(painterTf.map(d->typeSettingDecor.closestBaselinePoint).toPoint(), font, name);
                gc.save();
                QPen pen(bgColorForCaret(selectionColor, handlePalette, 255));
                pen.setCosmetic(true);
                pen.setWidth(decorationThickness);
                gc.setPen(pen);
                gc.drawPath(textP);
                gc.fillPath(textP, QBrush(selectionColor));
                gc.restore();
            }
 
        }
        gc.restore();
    }
}

References BaselineShift, bgColorForCaret(), d, KisHandlePainterHelper::drawHandleCircle(), KisHandlePainterHelper::drawHandleRect(), KisHandlePainterHelper::drawPath(), EndPos, handleName(), handleRadius, KoColorSpaceRegistry::instance(), p, KisHandleStyle::partiallyHighlightedPrimaryHandles(), KisHandleStyle::secondarySelection(), KisHandlePainterHelper::setHandleStyle(), and StartPos.

paste()

bool SvgTextCursor::paste

(

)

paste pastes plain text in the clipboard at pos. Uses pasteRichTextByDefault to determine whether to try and paste rich text.

Returns

true when successfull.

Definition at line 768 of file SvgTextCursor.cpp.

{
    bool success = d->pasteRichText? pasteRichText(): pastePlainText();
    return success;
}

References d, pastePlainText(), and pasteRichText.

pastePlainText

bool SvgTextCursor::pastePlainText ( )

privateslot

pastePlainText Explicitely paste plaintext at pos.

Returns

true when successfull.

Definition at line 810 of file SvgTextCursor.cpp.

{
    bool success = false;
    QClipboard *cb = QApplication::clipboard();
    const QMimeData *mimeData = cb->mimeData();
    if (mimeData->hasText()) {
        insertText(mimeData->text());
        success = true;
    }
    return success;
}

References insertText().

pasteRichText

bool SvgTextCursor::pasteRichText ( )

privateslot

pasteRichText

Returns

try to paste rich text at pos.

posForTypeSettingHandleAndRect()

int SvgTextCursor::posForTypeSettingHandleAndRect	(	const TypeSettingModeHandle	handle,
		const QRectF	regionOfInterest )

posForHandleAndRect Returns the closest cursor position for a given region and typesetting handle. Used by the type setting mode to find the relevant metrics to scale.

Returns

cursor pos closest.

Definition at line 555 of file SvgTextCursor.cpp.

{
    if (!d->shape) return 0;
 
    QList<KoSvgTextCharacterInfo> infos =
            d->shape->getPositionsAndRotationsForRange(d->pos, d->anchor);
    if (infos.size() < 1) return 0;
 
    const QRectF roi = d->shape->documentToShape(regionOfInterest);
 
    for (auto it = infos.begin(); it != infos.end(); it++) {
        const int currentPos = (d->pos == d->anchor)? -1 :d->shape->posForIndex(it->logicalIndex);
        const KoSvgTextProperties props = d->shape->propertiesForPos(currentPos, true);
        KoSvgText::LineHeightInfo lineHeight = props.propertyOrDefault(KoSvgTextProperties::LineHeightId).value<KoSvgText::LineHeightInfo>();
 
        KoSvgText::FontMetrics metrics = (d->pos == d->anchor)? props.metrics(true, true): it->metrics;
        const bool isHorizontal = d->shape->writingMode() == KoSvgText::HorizontalTB;
 
        const qreal scaleMetrics = props.fontSize().value/qreal(metrics.fontSize);
        const int lineGap = lineHeight.isNormal? metrics.lineGap: (lineHeight.length.value/scaleMetrics)-(metrics.ascender-metrics.descender);
 
        QTransform t = QTransform::fromTranslate(it->finalPos.x(), it->finalPos.y());
        t.rotate(it->rotateDeg);
 
        const QMap<SvgTextCursor::TypeSettingModeHandle, int> types
                = typeSettingBaselinesFromMetrics(metrics, lineGap, isHorizontal);
 
        const int metric = types.value(handle);
        QPointF offset = isHorizontal? QPointF(0, -(metric*scaleMetrics)): QPointF(metric*scaleMetrics, 0);
        QLineF line = t.map(QLineF(offset, offset+it->advance));
        if (KisAlgebra2D::intersectLineRect(line, roi.toAlignedRect(), false)) return d->shape->posForIndex(it->logicalIndex);
    }
 
    return 0;
}

References d, KoSvgTextProperties::fontSize(), KoSvgText::HorizontalTB, KisAlgebra2D::intersectLineRect(), KoSvgText::LineHeightInfo::isNormal, KoSvgText::LineHeightInfo::length, KoSvgTextProperties::LineHeightId, KoSvgTextProperties::metrics(), KoSvgTextProperties::propertyOrDefault(), typeSettingBaselinesFromMetrics(), and KoSvgText::CssLengthPercentage::value.

propertiesForRange()

QList< KoSvgTextProperties > SvgTextCursor::propertiesForRange

(

)

const

propertiesForRange

Returns

properties for the current range defined by the cursor pos and anchor.

Definition at line 684 of file SvgTextCursor.cpp.

{
    if (!d->shape) return QList<KoSvgTextProperties>();
    int start = -1;
    int end = -1;
    start = qMin(d->pos, d->anchor);
    end = qMax(d->pos, d->anchor);
    return d->shape->propertiesForRange(start, end);
}

References d.

propertiesForShape()

QList< KoSvgTextProperties > SvgTextCursor::propertiesForShape

(

)

const

propertiesForShape

Returns

properties for the current shape.

Definition at line 694 of file SvgTextCursor.cpp.

{
    if (!d->shape) return QList<KoSvgTextProperties>();
    return {d->shape->propertiesForRange(-1, -1)};
}

References d.

propertyAction

void SvgTextCursor::propertyAction ( )

privateslot

Called by the actions to execute a property change based on their data.

Definition at line 1356 of file SvgTextCursor.cpp.

{
    QAction *action = dynamic_cast<QAction*>(QObject::sender());
    if (!action || !d->shape) return;
 
    const QList<KoSvgTextProperties> p = d->shape->propertiesForRange(qMin(d->pos, d->anchor), qMax(d->pos, d->anchor));
    KoSvgTextProperties properties = SvgTextShortCuts::getModifiedProperties(action, p);
    if (properties.isEmpty()) return;
    mergePropertiesIntoSelection(properties);
}

References d, SvgTextShortCuts::getModifiedProperties(), KoSvgTextProperties::isEmpty(), mergePropertiesIntoSelection(), and p.

registerPropertyAction()

bool SvgTextCursor::registerPropertyAction	(	QAction *	action,
		const QString &	name )

Register an action.

Definition at line 1679 of file SvgTextCursor.cpp.

{
    if (SvgTextShortCuts::configureAction(action, name)) {
        d->actions.append(action);
        connect(action, SIGNAL(triggered(bool)), this, SLOT(propertyAction()));
        return true;
    } else if (name == "svg_insert_special_character") {
        d->actions.append(action);
        connect(action, SIGNAL(triggered(bool)), this, SIGNAL(sigOpenGlyphPalette()));
        return true;
    } else if (name == "svg_paste_rich_text") {
        d->actions.append(action);
        connect(action, SIGNAL(triggered(bool)), this, SLOT(pasteRichText()));
        return true;
    } else if (name == "svg_paste_plain_text") {
        d->actions.append(action);
        connect(action, SIGNAL(triggered(bool)), this, SLOT(pastePlainText()));
        return true;
    } else if (name == "svg_remove_transforms_from_range") {
        d->actions.append(action);
        connect(action, SIGNAL(triggered(bool)), this, SLOT(removeTransformsFromRange()));
        return true;
    } else if (name == "svg_clear_formatting") {
        d->actions.append(action);
        connect(action, SIGNAL(triggered(bool)), this, SLOT(clearFormattingAction()));
        return true;
    } else if (action) {
        d->actions.append(action);
        return true;
    }
    return false;
}

References clearFormattingAction(), SvgTextShortCuts::configureAction(), d, pastePlainText(), pasteRichText, propertyAction(), removeTransformsFromRange(), and sigOpenGlyphPalette().

removeLastCodePoint()

void SvgTextCursor::removeLastCodePoint

(

)

removeLastCodePoint Special function to remove the last code point. Triggered by backspace. This is distinct from remove text, as some clusters have multiple code points, but it is generally expected backspace deletes the codepoints while delete with selection deletes the whole cluster.

Definition at line 661 of file SvgTextCursor.cpp.

{
    if (d->shape) {
        SvgTextRemoveCommand *removeCmd;
        if (hasSelection()) {
            removeCmd = removeSelectionImpl(true);
            addCommandToUndoAdapter(removeCmd);
        } else {
            int lastIndex = d->shape->indexForPos(d->pos);
            removeCmd = new SvgTextRemoveCommand(d->shape, lastIndex, d->pos, d->anchor, 1, true);
            addCommandToUndoAdapter(removeCmd);
        }
    }
}

References addCommandToUndoAdapter(), d, hasSelection(), and removeSelectionImpl().

removeSelection()

void SvgTextCursor::removeSelection

(

)

removeSelection if there's a selection, creates a text-removal command.

Parameters

parent

Returns

the text-removal command, if possible, if there's no selection or shape, it'll return 0;

Definition at line 719 of file SvgTextCursor.cpp.

{
    KUndo2Command *removeCmd = removeSelectionImpl(true);
    addCommandToUndoAdapter(removeCmd);
}

References addCommandToUndoAdapter(), and removeSelectionImpl().

removeSelectionImpl()

SvgTextRemoveCommand * SvgTextCursor::removeSelectionImpl ( bool allowCleanUp, KUndo2Command * parent = 0 )

private

removeSelection if there's a selection, creates a text-removal command.

Parameters

parent

Returns

the text-removal command, if possible, if there's no selection or shape, it'll return 0;

Definition at line 725 of file SvgTextCursor.cpp.

{
    SvgTextRemoveCommand *removeCmd = nullptr;
    if (d->shape) {
        if (d->anchor != d->pos) {
            int end = d->shape->indexForPos(qMax(d->anchor, d->pos));
            int length = d->shape->indexForPos(qMax(d->anchor, d->pos)) - d->shape->indexForPos(qMin(d->anchor, d->pos));
            removeCmd = new SvgTextRemoveCommand(d->shape, end, d->pos, d->anchor, length, allowCleanUp, parent);
        }
    }
    return removeCmd;
}

References d, and length().

removeText()

void SvgTextCursor::removeText	(	SvgTextCursor::MoveMode	first,
		SvgTextCursor::MoveMode	second )

removeText remove text relative to the current position. This will move the cursor according to the move modes and then remove the text between the two positions.

Parameters

first	how the cursor should move to get to the start position.
second	how the cursor should move to get to the end position.

Definition at line 639 of file SvgTextCursor.cpp.

{
    if (d->shape) {
        SvgTextRemoveCommand *removeCmd;
        if (hasSelection()) {
            removeCmd = removeSelectionImpl(true);
            addCommandToUndoAdapter(removeCmd);
        } else {
            int posA = moveModeResult(first, d->pos, d->visualNavigation);
            int posB = moveModeResult(second, d->pos, d->visualNavigation);
 
            int posStart = qMin(posA, posB);
            int posEnd = qMax(posA, posB);
            int indexEnd = d->shape->indexForPos(posEnd);
            int length = indexEnd - d->shape->indexForPos(posStart);
 
            removeCmd = new SvgTextRemoveCommand(d->shape, indexEnd, d->pos, d->anchor, length, true);
            addCommandToUndoAdapter(removeCmd);
        }
    }
}

References addCommandToUndoAdapter(), d, hasSelection(), length(), moveModeResult(), and removeSelectionImpl().

removeTransformsFromRange

void SvgTextCursor::removeTransformsFromRange ( )

privateslot

removeTransformsFromRange Called by actions to remove svg character transforms from range.

Definition at line 822 of file SvgTextCursor.cpp.

{
    if (d->shape) {
        KUndo2Command *cmd = new SvgTextRemoveTransformsFromRange(d->shape, d->pos, d->anchor);
        addCommandToUndoAdapter(cmd);
    }
}

References addCommandToUndoAdapter(), and d.

selectionChanged

void SvgTextCursor::selectionChanged ( )

signal

Sents an update selection was changed.

setCaretSetting()

void SvgTextCursor::setCaretSetting	(	int	cursorWidth = 1,
		int	cursorFlash = 1000,
		int	cursorFlashLimit = 5000,
		bool	drawCursorInAdditionToSelection = false )

setCaretSetting Set the caret settings for the cursor. Qt has some standard functionality associated, which we pass via this.

Parameters

cursorWidth	- Cursor width from the style.
cursorFlash	- the total time it takes for a cursor to hide reapear.
cursorFlashLimit	- maximum amount of time a cursor is allowed to flash.

Definition at line 321 of file SvgTextCursor.cpp.

{
    d->cursorFlash.setInterval(cursorFlash/2);
    d->cursorFlashLimit.setInterval(cursorFlashLimit);
    d->cursorWidth = cursorWidth;
    d->drawCursorInAdditionToSelection = drawCursorInAdditionToSelection;
    connect(&d->cursorFlash, SIGNAL(timeout()), this, SLOT(blinkCursor()));
    connect(&d->cursorFlashLimit, SIGNAL(timeout()), this, SLOT(stopBlinkCursor()));
}

References blinkCursor(), cursorFlash, cursorFlashLimit, cursorWidth, d, drawCursorInAdditionToSelection, and stopBlinkCursor().

setDominantBaselineFromHandle()

bool SvgTextCursor::setDominantBaselineFromHandle

(

const TypeSettingModeHandle

handle

)

setDominantBaselineFromHandle Set the dominant baseline from a given handle.

Returns

true if dominant baseline was set, false if the handle doesn't correspond to a baseline.

Definition at line 508 of file SvgTextCursor.cpp.

{
    if (handle == NoHandle) return false;
    if (!d->typeSettingDecor.testBaselines(d->lastKnownModifiers)) return false;
    KoSvgText::Baseline baseline = KoSvgText::BaselineAuto;
    if (handle == Ascender) {
        baseline = KoSvgText::BaselineTextTop;
    } else if (handle == Descender) {
        baseline = KoSvgText::BaselineTextBottom;
    } else if (handle == BaselineAlphabetic) {
        baseline = KoSvgText::BaselineAlphabetic;
    } else if (handle == BaselineIdeographic) {
        baseline = KoSvgText::BaselineIdeographic;
    } else if (handle == BaselineHanging) {
        baseline = KoSvgText::BaselineHanging;
    } else if (handle == BaselineMiddle) {
        baseline = KoSvgText::BaselineMiddle;
    } else if (handle == BaselineMathematical) {
        baseline = KoSvgText::BaselineMathematical;
    } else if (handle == BaselineCentral) {
        baseline = KoSvgText::BaselineCentral;
    } else {
        return false;
    }
    KoSvgTextProperties props;
    props.setProperty(KoSvgTextProperties::DominantBaselineId, QVariant::fromValue(baseline));
    props.setProperty(KoSvgTextProperties::AlignmentBaselineId, QVariant::fromValue(baseline));
    mergePropertiesIntoSelection(props);
    return true;
}

References KoSvgTextProperties::AlignmentBaselineId, Ascender, KoSvgText::BaselineAlphabetic, BaselineAlphabetic, KoSvgText::BaselineAuto, KoSvgText::BaselineCentral, BaselineCentral, KoSvgText::BaselineHanging, BaselineHanging, KoSvgText::BaselineIdeographic, BaselineIdeographic, KoSvgText::BaselineMathematical, BaselineMathematical, KoSvgText::BaselineMiddle, BaselineMiddle, KoSvgText::BaselineTextBottom, KoSvgText::BaselineTextTop, d, Descender, KoSvgTextProperties::DominantBaselineId, mergePropertiesIntoSelection(), NoHandle, and KoSvgTextProperties::setProperty().

setDrawTypeSettingHandle()

void SvgTextCursor::setDrawTypeSettingHandle

(

bool

draw

)

Whether to draw the type setting handles. Turned off when the typesetting strategy is active to give artists more control.

Definition at line 442 of file SvgTextCursor.cpp.

{
    d->drawTypeSettingHandle = draw;
}

References d.

setPasteRichTextByDefault()

void SvgTextCursor::setPasteRichTextByDefault

(

const bool

pasteRichText = true

)

setPasteRichText

Parameters

pasteRichText

– whether to paste rich text when possible.

Definition at line 336 of file SvgTextCursor.cpp.

{
    d->pasteRichText = pasteRichText;
}

References d, and pasteRichText.

setPos()

void SvgTextCursor::setPos	(	int	pos,
		int	anchor )

Set the pos and the anchor.

Definition at line 357 of file SvgTextCursor.cpp.

{
    Private::InputQueryUpdateBlocker inputQueryUpdateBlocker(d);
    d->pos = pos;
    d->anchor = anchor;
    updateCursor();
    updateSelection();
}

References anchor, d, pos, updateCursor(), and updateSelection().

setPosToPoint()

void SvgTextCursor::setPosToPoint	(	QPointF	point,
		bool	moveAnchor = true )

Set the pos from a point. This currently does a search inside the text shape.

Definition at line 366 of file SvgTextCursor.cpp.

{
    if (d->shape) {
        Private::InputQueryUpdateBlocker inputQueryUpdateBlocker(d);
        int pos = d->shape->posForPointLineSensitive(d->shape->documentToShape(point));
        if (d->preEditCommand) {
            int start = d->shape->indexForPos(d->preEditStart);
            int end = start + d->preEditLength;
            int posIndex = d->shape->indexForPos(pos);
            if (posIndex > start && posIndex <= end) {
                qApp->inputMethod()->invokeAction(QInputMethod::Click, posIndex - start);
                return;
            } else {
                commitIMEPreEdit();
            }
        }
 
        const int finalPos = d->shape->posForIndex(d->shape->plainText().size());
        d->pos = qBound(0, pos, finalPos);
        if (moveAnchor || d->anchor < 0 || d->anchor > finalPos) {
            d->anchor = d->pos;
        }
        updateCursor();
        updateSelection();
    }
}

References commitIMEPreEdit(), d, pos, posIndex, updateCursor(), and updateSelection().

setShape()

void SvgTextCursor::setShape

(

KoSvgTextShape *

textShape

)

setShape

Parameters

textShape

KoSvgTextShape to set, is allowed to be a nullptr, the cursor just won't do anything.

Definition at line 297 of file SvgTextCursor.cpp.

{
    Private::InputQueryUpdateBlocker inputQueryUpdateBlocker(d);
    inputQueryUpdateBlocker.setChangeVisibility(true);
 
    if (d->shape) {
        commitIMEPreEdit();
        d->shape->removeShapeChangeListener(this);
    }
    d->shape = textShape;
    if (d->shape) {
        d->shape->addShapeChangeListener(this);
        updateInputMethodItemTransform();
        d->pos = d->shape->posForIndex(d->shape->plainText().size());
        updateTypeSettingDecorFromShape();
    } else {
        d->pos = 0;
    }
    d->anchor = 0;
    updateCursor(true);
    updateSelection();
    d->interface->emitSelectionChange();
}

References KoShape::addShapeChangeListener(), commitIMEPreEdit(), d, updateCursor(), updateInputMethodItemTransform(), updateSelection(), and updateTypeSettingDecorFromShape().

setTypeSettingHandleHovered()

void SvgTextCursor::setTypeSettingHandleHovered

(

TypeSettingModeHandle

hovered = TypeSettingModeHandle::NoHandle

)

Set a given typesetting handle as hovered, so it will be drawn as such.

Definition at line 437 of file SvgTextCursor.cpp.

{
    d->hoveredTypeSettingHandle = hovered;
}

References d.

setTypeSettingModeActive()

void SvgTextCursor::setTypeSettingModeActive

(

bool

activate

)

Set type setting mode active.

Definition at line 341 of file SvgTextCursor.cpp.

{
    d->typeSettingMode = activate;
    updateTypeSettingDecoration();
}

References d, and updateTypeSettingDecoration().

setVisualMode()

void SvgTextCursor::setVisualMode

(

const bool

visualMode = true

)

setVisualMode set whether the navigation mode is visual or logical. This right now primarily affects Bidirectional text.

Parameters

mode	whether to turn off visual mode.

Definition at line 331 of file SvgTextCursor.cpp.

{
    d->visualNavigation = visualMode;
}

References d.

shape()

KoSvgTextShape * SvgTextCursor::shape

(

)

const

Get the current text shape.

Returns

KoSvgTextShape *

sigOpenGlyphPalette

void SvgTextCursor::sigOpenGlyphPalette ( )

signal

Called by actions, tells the parent tool to open the glyph palette.

stopBlinkCursor

void SvgTextCursor::stopBlinkCursor ( )

privateslot

Called by timer, stops the text blinking animation.

Definition at line 1285 of file SvgTextCursor.cpp.

{
    d->cursorFlash.stop();
    d->cursorFlashLimit.stop();
    d->cursorVisible = true;
    if (d->shape) {
        Q_EMIT updateCursorDecoration(d->shape->shapeToDocument(d->cursorShape.boundingRect()) | d->oldCursorRect);
    }
}

References d, and updateCursorDecoration().

textPropertyInterface()

KoSvgTextPropertiesInterface * SvgTextCursor::textPropertyInterface

(

)

The text properties interface. This is how the text properties docker communicates with the text tool.

Definition at line 1712 of file SvgTextCursor.cpp.

{
    return d->interface;
}

References d.

typeSettingHandleAtPos()

SvgTextCursor::TypeSettingModeHandle SvgTextCursor::typeSettingHandleAtPos

(

const QRectF

regionOfInterest

)

Get typeSettingMode handle for text;.

Definition at line 393 of file SvgTextCursor.cpp.

{
    SvgTextCursor::TypeSettingModeHandle handle = SvgTextCursor::NoHandle;
 
    if (!(d->typeSettingMode && d->shape && d->canvas)) return handle;
 
    const QRectF roiInShape = d->shape->absoluteTransformation().inverted().mapRect(regionOfInterest);
 
    if (d->typeSettingDecor.handlesEnabled) {
        if (roiInShape.contains(d->typeSettingDecor.handles.first)) {
            handle = SvgTextCursor::StartPos;
        } else if (roiInShape.contains(d->typeSettingDecor.handles.second)) {
            handle = SvgTextCursor::EndPos;
        }
    }
    if (handle != NoHandle) return handle;
    if (!d->typeSettingDecor.boundingRect(d->handleRadius).intersects(roiInShape)) return handle;
 
    qreal closest = std::numeric_limits<qreal>::max();
    QMap<SvgTextCursor::TypeSettingModeHandle, QPainterPath> paths
            = d->typeSettingDecor.testBaselines(d->lastKnownModifiers)? d->typeSettingDecor.baselines: d->typeSettingDecor.paths;
    Q_FOREACH (const SvgTextCursor::TypeSettingModeHandle baseline, paths.keys()) {
        const QPainterPath path = paths.value(baseline);
        if (!path.intersects(roiInShape)) continue;
 
        const QList<QPolygonF> polys = path.toSubpathPolygons();
        Q_FOREACH(const QPolygonF poly, polys) {
            if (poly.size() < 2) continue;
            for (int i = 1; i < poly.size(); i++) {
                QLineF l(poly.at(i-1), poly.at(i));
                qreal distance = kisDistanceToLine(roiInShape.center(), l);
                if (distance < closest) {
                    handle = baseline;
                    closest = distance;
                    d->typeSettingDecor.closestBaselinePoint =
                            kisProjectOnVector(l.p2() - l.p1(), roiInShape.center() - l.p1()) + l.p1();
                }
            }
        }
    }
 
    return handle;
}

References d, distance(), EndPos, kisDistanceToLine(), kisProjectOnVector(), NoHandle, and StartPos.

updateCanvasResources

void SvgTextCursor::updateCanvasResources ( )

privateslot

Update the canvas resources with fore and background color.

Definition at line 2147 of file SvgTextCursor.cpp.

{
    // Only update canvas resources when there's no selection.
    // This relies on Krita not setting anything on the text when there's no selection.
    if (d->shape && d->canvas->resourceManager() && d->pos == d->anchor) {
        KoSvgTextProperties props = hasSelection()? d->shape->propertiesForPos(qMin(d->pos, d->anchor), true): d->shape->textProperties();
        KoColorBackground *bg = dynamic_cast<KoColorBackground *>(props.background().data());
        if (bg && props.hasProperty(KoSvgTextProperties::FillId)) {
            KoColor c;
            c.fromQColor(bg->color());
            c.setOpacity(1.0);
            if (c != d->canvas->resourceManager()->foregroundColor()) {
                d->canvas->resourceManager()->setForegroundColor(c);
            }
        }
        KoShapeStroke *stroke = dynamic_cast<KoShapeStroke *>(props.stroke().data());
        if (stroke && stroke->isVisible() && stroke->color().isValid() && props.hasProperty(KoSvgTextProperties::StrokeId)) {
            KoColor c;
            c.fromQColor(stroke->color());
            c.setOpacity(1.0);
            if (c != d->canvas->resourceManager()->backgroundColor()) {
                d->canvas->resourceManager()->setBackgroundColor(c);
            }
        }
 
        Q_FOREACH (QAction *action, d->actions) {
            // Blocking signals so that we don't get a toggle action while evaluating the checked-ness.
            action->blockSignals(true);
            const QList<KoSvgTextProperties> r = d->shape->propertiesForRange(qMin(d->pos, d->anchor), qMax(d->pos, d->anchor), true);
            if (action->isCheckable() && SvgTextShortCuts::possibleActions().contains(action->objectName())) {
                const bool checked = SvgTextShortCuts::actionEnabled(action, r);
                if (action->isChecked() != checked) {
                    action->setChecked(checked);
                }
            }
            action->blockSignals(false);
        }
    }
}

References SvgTextShortCuts::actionEnabled(), KoSvgTextProperties::background(), KoColorBackground::color(), KoShapeStroke::color, d, KoSvgTextProperties::FillId, KoColor::fromQColor(), KoSvgTextProperties::hasProperty(), hasSelection(), KoShapeStroke::isVisible(), SvgTextShortCuts::possibleActions(), KoColor::setOpacity(), KoSvgTextProperties::stroke(), and KoSvgTextProperties::StrokeId.

updateCursor()

void SvgTextCursor::updateCursor ( bool firstUpdate = false )

private

update the cursor shape. First update will block ensuring the canvas is visible so setShape won't cause this.

Definition at line 1717 of file SvgTextCursor.cpp.

{
    if (d->shape) {
        d->oldCursorRect = d->shape->shapeToDocument(d->cursorShape.boundingRect());
        d->posIndex = d->shape->indexForPos(d->pos);
        d->anchorIndex = d->shape->indexForPos(d->anchor);
        emit selectionChanged();
        updateTypeSettingDecoration();
    }
    d->cursorColor = QColor();
    d->cursorShape = d->shape? d->shape->cursorForPos(d->pos, d->cursorCaret, d->cursorColor): QPainterPath();
 
    if (!d->blockQueryUpdates) {
        qApp->inputMethod()->update(Qt::ImQueryInput);
    }
    d->interface->emitCharacterSelectionChange();
    if (!(d->canvas->canvasWidget() && d->canvas->canvasController())) {
        // Mockcanvas in the tests has neither.
        return;
    }
    if (d->shape && !firstUpdate) {
        QRectF rect = d->shape->shapeToDocument(d->cursorShape.boundingRect());
        d->canvas->canvasController()->ensureVisibleDoc(rect, false);
    }
    if (d->canvas->canvasWidget()->hasFocus()) {
        d->cursorFlash.start();
        d->cursorFlashLimit.start();
        d->cursorVisible = false;
        blinkCursor();
    }
}

References blinkCursor(), d, selectionChanged(), and updateTypeSettingDecoration().

updateCursorDecoration

void SvgTextCursor::updateCursorDecoration ( QRectF updateRect )

signal

Sents an update to the parent tool to update it's decorations.

updateIMEDecoration()

void SvgTextCursor::updateIMEDecoration ( )

private

Definition at line 1763 of file SvgTextCursor.cpp.

{
    if (d->shape) {
        d->oldIMEDecorationRect = d->shape->shapeToDocument(d->IMEDecoration.boundingRect());
        KoSvgText::TextDecorations decor;
        decor.setFlag(KoSvgText::DecorationUnderline, true);
        d->IMEDecoration = QPainterPath();
        if (d->preEditCommand) {
            Q_FOREACH(const IMEDecorationInfo info,  d->styleMap) {
 
                int startIndex = d->shape->indexForPos(d->preEditStart) + info.start;
                int endIndex = startIndex + info.length;
                qreal minimum = d->canvas->viewToDocument(QPointF(1, 1)).x();
                d->IMEDecoration.addPath(d->shape->underlines(d->shape->posForIndex(startIndex),
                                                              d->shape->posForIndex(endIndex),
                                                              info.decor,
                                                              info.style,
                                                              minimum,
                                                              info.thick));
                d->IMEDecoration.setFillRule(Qt::WindingFill);
            }
        }
 
        Q_EMIT updateCursorDecoration(d->shape->shapeToDocument(d->IMEDecoration.boundingRect()) | d->oldIMEDecorationRect);
    }
}

References d, IMEDecorationInfo::decor, KoSvgText::DecorationUnderline, IMEDecorationInfo::length, IMEDecorationInfo::start, IMEDecorationInfo::style, IMEDecorationInfo::thick, and updateCursorDecoration().

updateInputMethodItemTransform

void SvgTextCursor::updateInputMethodItemTransform ( )

privateslot

Definition at line 1295 of file SvgTextCursor.cpp.

{
    // Mockcanvas in the tests has no window.
    if (!d->canvas->canvasWidget()) {
        return;
    }
    QPoint pos = d->canvas->canvasWidget()->mapTo(d->canvas->canvasWidget()->window(), QPoint());
    QTransform widgetToWindow = QTransform::fromTranslate(pos.x(), pos.y());
    QTransform inputItemTransform = widgetToWindow;
    QRectF inputRect = d->canvas->canvasWidget()->geometry();
    if (d->shape) {
        inputRect = d->shape->outlineRect().normalized();
        QTransform shapeTransform = d->shape->absoluteTransformation();
        QTransform docToView = d->canvas->viewConverter()->documentToView();
        QTransform viewToWidget = d->canvas->viewConverter()->viewToWidget();
        inputItemTransform = shapeTransform * docToView * viewToWidget * widgetToWindow;
        // Only mess with IME if we're actually the thing being typed at.
        if (d->hasFocus) {
            QInputMethod *inputMethod = QGuiApplication::inputMethod();
            inputMethod->setInputItemTransform(inputItemTransform);
            inputMethod->setInputItemRectangle(inputRect);
            if (!d->blockQueryUpdates) {
                inputMethod->update(Qt::ImQueryInput);
            }
        }
    }
}

References d, and pos.

updateModifiers()

void SvgTextCursor::updateModifiers

(

const Qt::KeyboardModifiers

modifiers

)

Definition at line 1653 of file SvgTextCursor.cpp.

{
    d->lastKnownModifiers = modifiers;
    updateTypeSettingDecoration();
}

References d, and updateTypeSettingDecoration().

updateSelection()

void SvgTextCursor::updateSelection ( )

private

Definition at line 1749 of file SvgTextCursor.cpp.

{
    if (d->shape) {
        d->oldSelectionRect = d->shape->shapeToDocument(d->selection.boundingRect());
        d->shape->cursorForPos(d->anchor, d->anchorCaret, d->cursorColor);
        d->selection = d->shape->selectionBoxes(d->pos, d->anchor);
        Q_EMIT updateCursorDecoration(d->shape->shapeToDocument(d->selection.boundingRect()) | d->oldSelectionRect);
 
        if (!d->blockQueryUpdates) {
            QGuiApplication::inputMethod()->update(Qt::ImQueryInput);
        }
    }
}

References d, and updateCursorDecoration().

updateTypeSettingDecoration()

void SvgTextCursor::updateTypeSettingDecoration ( )

private

This adds the start and end decoration...

This could be better but requires better nodeindex retrieval...

Split up baselines into paths and baselines.

Definition at line 1853 of file SvgTextCursor.cpp.

{
    QRectF updateRect;
    if (d->shape && d->typeSettingMode) {
 
        QList<KoSvgTextCharacterInfo> infos =
                d->shape->getPositionsAndRotationsForRange(d->pos, d->anchor);
        if (infos.size() < 1) return;
 
        const bool rtl = infos.first().rtl;
 
        KoSvgTextCharacterInfo first = infos.first();
        KoSvgTextCharacterInfo last = infos.last();
        if (infos.size() > 1) {
            std::sort(infos.begin(), infos.end(), KoSvgTextCharacterInfo::visualLessThan);
            for (auto it = infos.begin(); it != infos.end(); it++) {
                if (it->visualIndex >= 0) {
                    first = *it;
                    break;
                }
            }
            for (auto it = infos.rbegin(); it != infos.rend(); it++) {
                if (it->visualIndex >= 0) {
                    last = *it;
                    break;
                }
            }
        }
 
        QTransform t = QTransform::fromTranslate(last.finalPos.x(), last.finalPos.y());
        t.rotate(last.rotateDeg);
        last.finalPos = t.map(last.advance);
 
        d->typeSettingDecor.handles.first = rtl? last.finalPos: first.finalPos;
        d->typeSettingDecor.handles.second = rtl? first.finalPos: last.finalPos;
 
        //Start collecting the metrics decoration...
        d->typeSettingDecor.paths = QMap<SvgTextCursor::TypeSettingModeHandle, QPainterPath>();
        d->typeSettingDecor.baselines = QMap<SvgTextCursor::TypeSettingModeHandle, QPainterPath>();
        d->typeSettingDecor.edges = QPainterPath();
        d->typeSettingDecor.parentPaths = QMap<SvgTextCursor::TypeSettingModeHandle, QPainterPath>();
        d->typeSettingDecor.parentBaselines = QMap<SvgTextCursor::TypeSettingModeHandle, QPainterPath>();
        QList<KoSvgTextCharacterInfo> metricInfos = infos;
        if (d->pos == d->anchor) {
            metricInfos = d->shape->getPositionsAndRotationsForRange(0, d->shape->posForIndex(d->shape->plainText().size()));
        }
        const bool isHorizontal = d->shape->writingMode() == KoSvgText::HorizontalTB;
        const int minPos = qMin(d->pos, d->anchor);
        const int maxPos = qMax(d->pos, d->anchor);
        const int endPos = d->shape->posForIndex(d->shape->plainText().size());
 
        if (minPos > 0 || maxPos < endPos) {
            const KoSvgTextProperties props = d->shape->textProperties();
            KoSvgText::LineHeightInfo lineHeight = props.propertyOrDefault(KoSvgTextProperties::LineHeightId).value<KoSvgText::LineHeightInfo>();
            KoSvgText::FontMetrics metrics = props.metrics(true, true);
            const qreal scaleMetrics = props.fontSize().value/qreal(metrics.fontSize);
            const int lineGap = calcLineHeight(lineHeight, metrics, scaleMetrics);
 
            const QMap<SvgTextCursor::TypeSettingModeHandle, int> types
                    = typeSettingBaselinesFromMetrics(metrics, lineGap, isHorizontal);
 
            QList<KoSvgTextCharacterInfo> parentInfos;
            QList<int> positions;
            positions << 0;
            positions << qMax(0, minPos-1);
            positions << maxPos;
            positions << endPos;
 
            Q_FOREACH(const int pos, positions) {
                QList<KoSvgTextCharacterInfo> info =
                        d->shape->getPositionsAndRotationsForRange(pos, pos);
                parentInfos.append(info.first());
            }
 
            QPointF drawOffset = isHorizontal? QPointF(d->handleRadius*2, 0): QPointF(0, d->handleRadius*2);
            if (d->canvas) {
                drawOffset = d->canvas->viewConverter()->viewToDocument().map(drawOffset);
            }
            bool toggleOffset = rtl;
 
            for (auto it = parentInfos.begin(); it != parentInfos.end(); it++) {
                const bool currentIsMin = (d->shape->posForIndex(it->logicalIndex) == minPos);
                const bool currentIsMax = (d->shape->posForIndex(it->logicalIndex) == maxPos);
 
                if ((currentIsMin && minPos == 0) || (currentIsMax && maxPos == endPos)) {
                    toggleOffset = !toggleOffset;
                    continue;
                }
 
                const QPointF finalPos = toggleOffset? it->finalPos + (it->advance - drawOffset): it->finalPos;
                const QPointF advance = drawOffset;
 
                const QTransform t = posAndRotateTransform(finalPos, it->rotateDeg);
 
                Q_FOREACH(SvgTextCursor::TypeSettingModeHandle handle, types.keys()) {
                    const int metric = types.value(handle);
                    processBaseline(handle, metric, isHorizontal, t, scaleMetrics, advance, d->typeSettingDecor.parentBaselines);
                }
 
                {
                    if (currentIsMin && minPos == maxPos && !toggleOffset) {
                        toggleOffset = !toggleOffset;
                        continue;
                    }
                    const QPointF advance = toggleOffset? it->advance: QPointF();
                    const QTransform t = posAndRotateTransform(it->finalPos, it->rotateDeg);
                    processEdges(t, types, isHorizontal, scaleMetrics, advance, d->typeSettingDecor.edges);
                }
 
                toggleOffset = !toggleOffset;
            }
        }
 
        bool toggleOffset = false; // MetricInfos are visually-ordered.
        for (auto it = metricInfos.begin(); it != metricInfos.end(); it++) {
            const int currentPos = (d->pos == d->anchor)? -1 :d->shape->posForIndex(it->logicalIndex);
 
            KoSvgTextProperties props = d->shape->propertiesForPos(currentPos, true);
            KoSvgText::LineHeightInfo lineHeight = props.propertyOrDefault(KoSvgTextProperties::LineHeightId).value<KoSvgText::LineHeightInfo>();
            KoSvgText::FontMetrics propMetrics = props.metrics(true, true);
 
            KoSvgText::FontMetrics metrics = (d->pos == d->anchor)? propMetrics :it->metrics;
 
            const qreal scaleMetrics = props.fontSize().value/qreal(metrics.fontSize);
            const int lineGap = calcLineHeight(lineHeight, metrics, scaleMetrics);
 
            const QTransform t = posAndRotateTransform(it->finalPos, it->rotateDeg);
 
            const QMap<SvgTextCursor::TypeSettingModeHandle, int> types
                    = typeSettingBaselinesFromMetrics(metrics, lineGap, isHorizontal);
 
            Q_FOREACH(SvgTextCursor::TypeSettingModeHandle handle, types.keys()) {
                const int metric = types.value(handle);
                processBaseline(handle, metric, isHorizontal, t, scaleMetrics, it->advance, d->typeSettingDecor.baselines);
            }
            if ((currentPos == minPos || currentPos+1 == maxPos) && minPos != maxPos) {
                const QPointF advance = toggleOffset? it->advance: QPointF();
                toggleOffset = !toggleOffset;
                processEdges(t, types, isHorizontal, scaleMetrics, advance, d->typeSettingDecor.edges);
            }
        }
 
        const QList<SvgTextCursor::TypeSettingModeHandle> nonBaselines = {
            LineHeightTop, Ascender, BaselineShift, Descender, LineHeightBottom
        };
        Q_FOREACH(SvgTextCursor::TypeSettingModeHandle handle, nonBaselines) {
            d->typeSettingDecor.paths.insert(handle, d->typeSettingDecor.baselines.value(handle));
            d->typeSettingDecor.parentPaths.insert(handle,  d->typeSettingDecor.parentBaselines.value(handle));
        }
        d->typeSettingDecor.baselines.remove(LineHeightTop);
        d->typeSettingDecor.baselines.remove(LineHeightBottom);
        d->typeSettingDecor.parentBaselines.remove(LineHeightTop);
        d->typeSettingDecor.parentBaselines.remove(LineHeightBottom);
 
        updateRect = d->shape->shapeToDocument(d->typeSettingDecor.boundingRect(d->handleRadius));
    }
    updateTypeSettingDecorFromShape(); // To remove the text-in-path nodes..
    Q_EMIT updateCursorDecoration(updateRect | d->oldTypeSettingRect);
    d->oldTypeSettingRect = updateRect;
}

References KoSvgTextCharacterInfo::advance, Ascender, BaselineShift, calcLineHeight(), d, Descender, KoSvgTextCharacterInfo::finalPos, KoSvgText::FontMetrics::fontSize, KoSvgTextProperties::fontSize(), KoSvgText::HorizontalTB, LineHeightBottom, KoSvgTextProperties::LineHeightId, LineHeightTop, KoSvgTextProperties::metrics(), pos, posAndRotateTransform(), processBaseline(), processEdges(), KoSvgTextProperties::propertyOrDefault(), KoSvgTextCharacterInfo::rotateDeg, typeSettingBaselinesFromMetrics(), updateCursorDecoration(), updateTypeSettingDecorFromShape(), KoSvgText::CssLengthPercentage::value, and KoSvgTextCharacterInfo::visualLessThan().

updateTypeSettingDecorFromShape()

void SvgTextCursor::updateTypeSettingDecorFromShape

(

)

Update the type setting decorations.

Definition at line 447 of file SvgTextCursor.cpp.

{
    if (d->shape) {
        d->typeSettingDecor.handlesEnabled = ((d->shape->textType() == KoSvgTextShape::PreformattedText
                                              || d->shape->textType() == KoSvgTextShape::PrePositionedText)
                                              && !(d->shape->topLevelNodeForPos(d->pos).textPath()));
    }
}

References d, KoSvgTextShape::PreformattedText, and KoSvgTextShape::PrePositionedText.

Member Data Documentation

actions

QList<QAction*> SvgTextCursor::actions

Definition at line 247 of file SvgTextCursor.cpp.

anchor

int SvgTextCursor::anchor = 0

Definition at line 202 of file SvgTextCursor.cpp.

anchorCaret

QLineF SvgTextCursor::anchorCaret

Definition at line 214 of file SvgTextCursor.cpp.

anchorIndex

int SvgTextCursor::anchorIndex = 0

Definition at line 223 of file SvgTextCursor.cpp.

blockQueryUpdates

bool SvgTextCursor::blockQueryUpdates = false

Block qApp->inputMethod->update(), enabled during the inputmethod event flow.

Definition at line 243 of file SvgTextCursor.cpp.

canvas

KoCanvasBase* SvgTextCursor::canvas

Definition at line 199 of file SvgTextCursor.cpp.

cursorCaret

QLineF SvgTextCursor::cursorCaret

Definition at line 213 of file SvgTextCursor.cpp.

cursorColor

QColor SvgTextCursor::cursorColor

Definition at line 211 of file SvgTextCursor.cpp.

cursorFlash

QTimer SvgTextCursor::cursorFlash

Definition at line 205 of file SvgTextCursor.cpp.

cursorFlashLimit

QTimer SvgTextCursor::cursorFlashLimit

Definition at line 206 of file SvgTextCursor.cpp.

cursorShape

QPainterPath SvgTextCursor::cursorShape

Definition at line 210 of file SvgTextCursor.cpp.

cursorVisible

bool SvgTextCursor::cursorVisible = false

Definition at line 207 of file SvgTextCursor.cpp.

cursorWidth

int SvgTextCursor::cursorWidth = 1

Definition at line 215 of file SvgTextCursor.cpp.

d

const QScopedPointer<Private> SvgTextCursor::d

private

Definition at line 394 of file SvgTextCursor.h.

drawCursorInAdditionToSelection

bool SvgTextCursor::drawCursorInAdditionToSelection = false

Definition at line 216 of file SvgTextCursor.cpp.

drawTypeSettingHandle

bool SvgTextCursor::drawTypeSettingHandle = true

Definition at line 232 of file SvgTextCursor.cpp.

handleRadius

qreal SvgTextCursor::handleRadius = 7

Definition at line 233 of file SvgTextCursor.cpp.

hasFocus

bool SvgTextCursor::hasFocus = false

Definition at line 208 of file SvgTextCursor.cpp.

hoveredTypeSettingHandle

SvgTextCursor::TypeSettingModeHandle SvgTextCursor::hoveredTypeSettingHandle = SvgTextCursor::NoHandle

Definition at line 231 of file SvgTextCursor.cpp.

IMEDecoration

QPainterPath SvgTextCursor::IMEDecoration

The decorations for the current preedit string.

Definition at line 241 of file SvgTextCursor.cpp.

interface

SvgTextCursorPropertyInterface* SvgTextCursor::interface {nullptr}

Definition at line 245 of file SvgTextCursor.cpp.

{nullptr};

isAddingCommand

bool SvgTextCursor::isAddingCommand = false

Definition at line 200 of file SvgTextCursor.cpp.

lastKnownModifiers

Qt::KeyboardModifiers SvgTextCursor::lastKnownModifiers

Definition at line 228 of file SvgTextCursor.cpp.

oldCursorRect

QRectF SvgTextCursor::oldCursorRect

Definition at line 212 of file SvgTextCursor.cpp.

oldIMEDecorationRect

QRectF SvgTextCursor::oldIMEDecorationRect

Update Rectangle of previous decoration.

Definition at line 242 of file SvgTextCursor.cpp.

oldSelectionRect

QRectF SvgTextCursor::oldSelectionRect

Definition at line 218 of file SvgTextCursor.cpp.

oldTypeSettingRect

QRectF SvgTextCursor::oldTypeSettingRect

Definition at line 234 of file SvgTextCursor.cpp.

pasteRichText

bool SvgTextCursor::pasteRichText = true

Definition at line 226 of file SvgTextCursor.cpp.

pos

int SvgTextCursor::pos = 0

Definition at line 201 of file SvgTextCursor.cpp.

posIndex

int SvgTextCursor::posIndex = 0

Definition at line 222 of file SvgTextCursor.cpp.

preEditCommand

SvgTextInsertCommand* SvgTextCursor::preEditCommand {nullptr}

PreEdit string as an command provided by the input method.

Definition at line 237 of file SvgTextCursor.cpp.

{nullptr}; 

preEditLength

int SvgTextCursor::preEditLength = -1

Length of the preEditString.

Definition at line 239 of file SvgTextCursor.cpp.

preEditStart

int SvgTextCursor::preEditStart = -1

Start of the preEdit string as a cursor pos.

Definition at line 238 of file SvgTextCursor.cpp.

resourceManagerAcyclicConnector

KisAcyclicSignalConnector SvgTextCursor::resourceManagerAcyclicConnector

Definition at line 249 of file SvgTextCursor.cpp.

selection

QPainterPath SvgTextCursor::selection

Definition at line 217 of file SvgTextCursor.cpp.

shape

KoSvgTextShape * SvgTextCursor::shape {nullptr}

Definition at line 203 of file SvgTextCursor.cpp.

{nullptr};

styleMap

QVector<IMEDecorationInfo> SvgTextCursor::styleMap

Decoration info (underlines) for the preEdit string to differentiate it from regular text.

Definition at line 240 of file SvgTextCursor.cpp.

typeSettingDecor

TypeSettingDecorInfo SvgTextCursor::typeSettingDecor

Definition at line 235 of file SvgTextCursor.cpp.

typeSettingMode

bool SvgTextCursor::typeSettingMode = false

Definition at line 230 of file SvgTextCursor.cpp.

visualNavigation

bool SvgTextCursor::visualNavigation = true

Definition at line 225 of file SvgTextCursor.cpp.

---

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

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