#include <qtextcontrol_p_p.h>

Inheritance diagram for QTextControlPrivate:

Public Functions
void	_q_copyLink ()

void	_q_deleteSelected ()

void	_q_documentLayoutChanged ()

void	_q_emitCursorPosChanged (const QTextCursor &someCursor)

void	_q_setCursorAfterUndoRedo (int undoPosition, int charsAdded, int charsRemoved)

void	_q_updateBlock (const QTextBlock &)

void	_q_updateCurrentCharFormatAndSelection ()

void	activateLinkUnderCursor (QString href=QString())

QString	anchorForCursor (const QTextCursor &anchor) const

void	append (const QString &text, Qt::TextFormat format=Qt::AutoText)

void	contextMenuEvent (const QPoint &screenPos, const QPointF &docPos, QWidget *contextWidget)

void	createAutoBulletList ()

bool	cursorMoveKeyEvent (QKeyEvent *e)

QRectF	cursorRectPlusUnicodeDirectionMarkers (const QTextCursor &cursor) const

bool	dragEnterEvent (QEvent e, const QMimeData mimeData)

void	dragLeaveEvent ()

bool	dragMoveEvent (QEvent e, const QMimeData mimeData, const QPointF &pos)

bool	dropEvent (const QMimeData mimeData, const QPointF &pos, Qt::DropAction dropAction, QWidget source)

void	extendBlockwiseSelection (int suggestedNewPosition)

void	extendWordwiseSelection (int suggestedNewPosition, qreal mouseXPosition)

void	focusEvent (QFocusEvent *e)

void	gotoNextTableCell ()

void	gotoPreviousTableCell ()

void	indent ()

void	init (Qt::TextFormat format=Qt::RichText, const QString &text=QString(), QTextDocument *document=0)

QInputContext *	inputContext ()

void	inputMethodEvent (QInputMethodEvent *)

void	keyPressEvent (QKeyEvent *e)

void	mouseDoubleClickEvent (QEvent *e, Qt::MouseButton button, const QPointF &pos, Qt::KeyboardModifiers modifiers, Qt::MouseButtons buttons, const QPoint &globalPos)

void	mouseMoveEvent (QEvent *e, Qt::MouseButton button, const QPointF &pos, Qt::KeyboardModifiers modifiers, Qt::MouseButtons buttons, const QPoint &globalPos)

void	mousePressEvent (QEvent *e, Qt::MouseButton button, const QPointF &pos, Qt::KeyboardModifiers modifiers, Qt::MouseButtons buttons, const QPoint &globalPos)

void	mouseReleaseEvent (QEvent *e, Qt::MouseButton button, const QPointF &pos, Qt::KeyboardModifiers modifiers, Qt::MouseButtons buttons, const QPoint &globalPos)

void	outdent ()

void	paste (const QMimeData *source)

	QTextControlPrivate ()

QRectF	rectForPosition (int position) const

void	repaintCursor ()

void	repaintOldAndNewSelection (const QTextCursor &oldSelection)

void	repaintSelection ()

void	selectionChanged (bool forceEmitSelectionChanged=false)

QRectF	selectionRect (const QTextCursor &cursor) const

QRectF	selectionRect () const

bool	sendMouseEventToInputContext (QEvent *e, QEvent::Type eventType, Qt::MouseButton button, const QPointF &pos, Qt::KeyboardModifiers modifiers, Qt::MouseButtons buttons, const QPoint &globalPos)

void	setBlinkingCursorEnabled (bool enable)

void	setClipboardSelection ()

void	setContent (Qt::TextFormat format=Qt::RichText, const QString &text=QString(), QTextDocument *document=0)

void	setCursorPosition (const QPointF &pos)

void	setCursorPosition (int pos, QTextCursor::MoveMode mode=QTextCursor::MoveAnchor)

void	showToolTip (const QPoint &globalPos, const QPointF &pos, QWidget *contextWidget)

void	startDrag ()

void	updateCurrentCharFormat ()

Public Functions inherited from QObjectPrivate
void	_q_reregisterTimers (void *pointer)

void	addConnection (int signal, Connection *c)

void	cleanConnectionLists ()

void	connectNotify (const char *signal)

void	deleteChildren ()

void	disconnectNotify (const char *signal)

bool	isSender (const QObject receiver, const char signal) const

bool	isSignalConnected (uint signalIdx) const
	Returns true if the signal with index signal_index from object sender is connected. More...

void	moveToThread_helper ()

	QObjectPrivate (int version=QObjectPrivateVersion)

QObjectList	receiverList (const char *signal) const

QObjectList	senderList () const

void	setParent_helper (QObject *)

void	setThreadData_helper (QThreadData currentData, QThreadData targetData)

int	signalIndex (const char *signalName) const
	Returns the signal index used in the internal connectionLists vector. More...

virtual	~QObjectPrivate ()

Public Functions inherited from QObjectData
virtual	~QObjectData ()=0

Public Variables
bool	acceptRichText

QString	anchorOnMousePress

QPointer< QWidget >	contextWidget

QTextCursor	cursor

QBasicTimer	cursorBlinkTimer

bool	cursorIsFocusIndicator

bool	cursorOn

QTextCursor	dndFeedbackCursor

QTextDocument *	doc

bool	dragEnabled

QPoint	dragStartPos

QVector< QAbstractTextDocumentLayout::Selection >	extraSelections

bool	hadSelectionOnMousePress

bool	hasFocus

bool	hideCursor

QString	highlightedAnchor

bool	ignoreAutomaticScrollbarAdjustement

bool	ignoreUnusedNavigationEvents

Qt::TextInteractionFlags	interactionFlags

bool	isEnabled

QTextCharFormat	lastCharFormat

bool	lastSelectionState

QString	linkToCopy

bool	mightStartDrag

bool	mousePressed

bool	openExternalLinks

bool	overwriteMode

QPalette	palette

int	preeditCursor

QTextCursor	selectedBlockOnTrippleClick

QTextCursor	selectedWordOnDoubleClick

QPointF	trippleClickPoint

QBasicTimer	trippleClickTimer

bool	wordSelectionEnabled

Public Variables inherited from QObjectPrivate
union {
QObject * currentChildBeingDeleted

QAbstractDeclarativeData * declarativeData

};

quint32	connectedSignals [2]

QObjectConnectionListVector *	connectionLists

Sender *	currentSender

QList< QPointer< QObject > >	eventFilters

ExtraData *	extraData

QString	objectName

Connection *	senders

QAtomicPointer< QtSharedPointer::ExternalRefCountData >	sharedRefcount

QThreadData *	threadData

void *	unused

Public Variables inherited from QObjectData
uint	blockSig: 1

QObjectList	children

uint	hasGuards: 1

uint	inEventHandler: 1

uint	inThreadChangeEvent: 1

uint	isWidget: 1

QMetaObject *	metaObject

uint	ownObjectName: 1

QObject *	parent

uint	pendTimer: 1

int	postedEvents

QObject *	q_ptr

uint	receiveChildEvents: 1

uint	sendChildEvents: 1

uint	unused: 22

uint	wasDeleted: 1

Additional Inherited Members
Public Types inherited from QObjectPrivate
typedef void(*	StaticMetaCallFunction) (QObject , QMetaObject::Call, int, void *)

Static Public Functions inherited from QObjectPrivate
static void	clearGuards (QObject *)

static QObjectPrivate *	get (QObject *o)

static void	resetCurrentSender (QObject receiver, Sender currentSender, Sender *previousSender)

static Sender *	setCurrentSender (QObject receiver, Sender sender)

static void	signalSignature (const QMetaMethod &signal, QVarLengthArray< char > *result)

Detailed Description

Definition at line 72 of file qtextcontrol_p_p.h.

Constructors and Destructors

◆ QTextControlPrivate()

QTextControlPrivate::QTextControlPrivate ( )

Definition at line 117 of file qtextcontrol.cpp.

     : doc(0), cursorOn(false), cursorIsFocusIndicator(false),
       interactionFlags(Qt::TextEditorInteraction),
       dragEnabled(true),
 #ifndef QT_NO_DRAGANDDROP
       mousePressed(false), mightStartDrag(false),
 #endif
       lastSelectionState(false), ignoreAutomaticScrollbarAdjustement(false),
       overwriteMode(false),
       acceptRichText(true),
       preeditCursor(0), hideCursor(false),
       hasFocus(false),
 #ifdef QT_KEYPAD_NAVIGATION
       hasEditFocus(false),
 #endif
       isEnabled(true),
       hadSelectionOnMousePress(false),
       ignoreUnusedNavigationEvents(false),
       openExternalLinks(false),
       wordSelectionEnabled(false)
 {}

Functions

◆ _q_copyLink()

void QTextControlPrivate::_q_copyLink ( )

Definition at line 3050 of file qtextcontrol.cpp.

 {
 #ifndef QT_NO_CLIPBOARD
     QMimeData *md = new QMimeData;
     md->setText(linkToCopy);
     QApplication::clipboard()->setMimeData(md);
 #endif
 }

◆ _q_deleteSelected()

void QTextControlPrivate::_q_deleteSelected ( )

Definition at line 756 of file qtextcontrol.cpp.

Referenced by repaintSelection().

 {
     if (!(interactionFlags & Qt::TextEditable) || !cursor.hasSelection())
         return;
     cursor.removeSelectedText();
 }

◆ _q_documentLayoutChanged()

void QTextControlPrivate::_q_documentLayoutChanged ( )

Definition at line 628 of file qtextcontrol.cpp.

Referenced by setContent().

 {
     Q_Q(QTextControl);
     QAbstractTextDocumentLayout *layout = doc->documentLayout();
     QObject::connect(layout, SIGNAL(update(QRectF)), q, SIGNAL(updateRequest(QRectF)));
     QObject::connect(layout, SIGNAL(updateBlock(QTextBlock)), q, SLOT(_q_updateBlock(QTextBlock)));
     QObject::connect(layout, SIGNAL(documentSizeChanged(QSizeF)), q, SIGNAL(documentSizeChanged(QSizeF)));
 
 }

◆ _q_emitCursorPosChanged()

void QTextControlPrivate::_q_emitCursorPosChanged ( const QTextCursor & someCursor )

Definition at line 619 of file qtextcontrol.cpp.

Referenced by repaintSelection(), and setContent().

 {
     Q_Q(QTextControl);
     if (someCursor.isCopyOf(cursor)) {
         emit q->cursorPositionChanged();
         emit q->microFocusChanged();
     }
 }

◆ _q_setCursorAfterUndoRedo()

void QTextControlPrivate::_q_setCursorAfterUndoRedo	(	int	undoPosition,
		int	charsAdded,
		int	charsRemoved
	)

Referenced by repaintSelection().

◆ _q_updateBlock()

void QTextControlPrivate::_q_updateBlock ( const QTextBlock & block )

Definition at line 1339 of file qtextcontrol.cpp.

Referenced by _q_documentLayoutChanged().

 {
     Q_Q(QTextControl);
     QRectF br = q->blockBoundingRect(block);
     br.setRight(qreal(INT_MAX)); // the block might have shrunk
     emit q->updateRequest(br);
 }

◆ _q_updateCurrentCharFormatAndSelection()

void QTextControlPrivate::_q_updateCurrentCharFormatAndSelection ( )

Definition at line 601 of file qtextcontrol.cpp.

Referenced by repaintSelection(), and setContent().

 {
     updateCurrentCharFormat();
     selectionChanged();
 }

◆ activateLinkUnderCursor()

void QTextControlPrivate::activateLinkUnderCursor ( QString href = QString() )

Definition at line 2675 of file qtextcontrol.cpp.

Referenced by selectionRect().

 {
     QTextCursor oldCursor = cursor;
 
     if (href.isEmpty()) {
         QTextCursor tmp = cursor;
         if (tmp.selectionStart() != tmp.position())
             tmp.setPosition(tmp.selectionStart());
         tmp.movePosition(QTextCursor::NextCharacter);
         href = tmp.charFormat().anchorHref();
     }
     if (href.isEmpty())
         return;
 
     if (!cursor.hasSelection()) {
         QTextBlock block = cursor.block();
         const int cursorPos = cursor.position();
 
         QTextBlock::Iterator it = block.begin();
         QTextBlock::Iterator linkFragment;
 
         for (; !it.atEnd(); ++it) {
             QTextFragment fragment = it.fragment();
             const int fragmentPos = fragment.position();
             if (fragmentPos <= cursorPos &&
                 fragmentPos + fragment.length() > cursorPos) {
                 linkFragment = it;
                 break;
             }
         }
 
         if (!linkFragment.atEnd()) {
             it = linkFragment;
             cursor.setPosition(it.fragment().position());
             if (it != block.begin()) {
                 do {
                     --it;
                     QTextFragment fragment = it.fragment();
                     if (fragment.charFormat().anchorHref() != href)
                         break;
                     cursor.setPosition(fragment.position());
                 } while (it != block.begin());
             }
 
             for (it = linkFragment; !it.atEnd(); ++it) {
                 QTextFragment fragment = it.fragment();
                 if (fragment.charFormat().anchorHref() != href)
                     break;
                 cursor.setPosition(fragment.position() + fragment.length(), QTextCursor::KeepAnchor);
             }
         }
     }
 
     if (hasFocus) {
         cursorIsFocusIndicator = true;
     } else {
         cursorIsFocusIndicator = false;
         cursor.clearSelection();
     }
     repaintOldAndNewSelection(oldCursor);
 
 #ifndef QT_NO_DESKTOPSERVICES
     if (openExternalLinks)
         QDesktopServices::openUrl(href);
     else
 #endif
         emit q_func()->linkActivated(href);
 }

◆ anchorForCursor()

QString QTextControlPrivate::anchorForCursor ( const QTextCursor & anchor ) const

Definition at line 2066 of file qtextcontrol.cpp.

Referenced by selectionRect().

 {
     if (anchorCursor.hasSelection()) {
         QTextCursor cursor = anchorCursor;
         if (cursor.selectionStart() != cursor.position())
             cursor.setPosition(cursor.selectionStart());
         cursor.movePosition(QTextCursor::NextCharacter);
         QTextCharFormat fmt = cursor.charFormat();
         if (fmt.isAnchor() && fmt.hasProperty(QTextFormat::AnchorHref))
             return fmt.stringProperty(QTextFormat::AnchorHref);
     }
     return QString();
 }

◆ append()

void QTextControlPrivate::append	(	const QString &	text,
		Qt::TextFormat	format = `Qt::AutoText`
	)

Definition at line 2916 of file qtextcontrol.cpp.

Referenced by selectionRect().

 {
     QTextCursor tmp(doc);
     tmp.beginEditBlock();
     tmp.movePosition(QTextCursor::End);
 
     if (!doc->isEmpty())
         tmp.insertBlock(cursor.blockFormat(), cursor.charFormat());
     else
         tmp.setCharFormat(cursor.charFormat());
 
     // preserve the char format
     QTextCharFormat oldCharFormat = cursor.charFormat();
 
 #ifndef QT_NO_TEXTHTMLPARSER
     if (format == Qt::RichText || (format == Qt::AutoText && Qt::mightBeRichText(text))) {
         tmp.insertHtml(text);
     } else {
         tmp.insertText(text);
     }
 #else
     tmp.insertText(text);
 #endif // QT_NO_TEXTHTMLPARSER
     if (!cursor.hasSelection())
         cursor.setCharFormat(oldCharFormat);
 
     tmp.endEditBlock();
 }

◆ contextMenuEvent()

void QTextControlPrivate::contextMenuEvent	(	const QPoint &	screenPos,
		const QPointF &	docPos,
		QWidget *	contextWidget
	)

Definition at line 1843 of file qtextcontrol.cpp.

Referenced by selectionRect().

 {
 #ifdef QT_NO_CONTEXTMENU
     Q_UNUSED(screenPos);
     Q_UNUSED(docPos);
     Q_UNUSED(contextWidget);
 #else
     Q_Q(QTextControl);
     if (!hasFocus)
         return;
     QMenu *menu = q->createStandardContextMenu(docPos, contextWidget);
     if (!menu)
         return;
     menu->setAttribute(Qt::WA_DeleteOnClose);
     menu->popup(screenPos);
 #endif
 }

◆ createAutoBulletList()

void QTextControlPrivate::createAutoBulletList ( )

Definition at line 389 of file qtextcontrol.cpp.

 {
     cursor.beginEditBlock();
 
     QTextBlockFormat blockFmt = cursor.blockFormat();
 
     QTextListFormat listFmt;
     listFmt.setStyle(QTextListFormat::ListDisc);
     listFmt.setIndent(blockFmt.indent() + 1);
 
     blockFmt.setIndent(0);
     cursor.setBlockFormat(blockFmt);
 
     cursor.createList(listFmt);
 
     cursor.endEditBlock();
 }

◆ cursorMoveKeyEvent()

bool QTextControlPrivate::cursorMoveKeyEvent ( QKeyEvent * e )

Definition at line 139 of file qtextcontrol.cpp.

 {
 #ifdef QT_NO_SHORTCUT
     Q_UNUSED(e);
 #endif
 
     Q_Q(QTextControl);
     if (cursor.isNull())
         return false;
 
     const QTextCursor oldSelection = cursor;
     const int oldCursorPos = cursor.position();
 
     QTextCursor::MoveMode mode = QTextCursor::MoveAnchor;
     QTextCursor::MoveOperation op = QTextCursor::NoMove;
 
     if (false) {
     }
 #ifndef QT_NO_SHORTCUT
     if (e == QKeySequence::MoveToNextChar) {
             op = QTextCursor::Right;
     }
     else if (e == QKeySequence::MoveToPreviousChar) {
             op = QTextCursor::Left;
     }
     else if (e == QKeySequence::SelectNextChar) {
            op = QTextCursor::Right;
            mode = QTextCursor::KeepAnchor;
     }
     else if (e == QKeySequence::SelectPreviousChar) {
             op = QTextCursor::Left;
             mode = QTextCursor::KeepAnchor;
     }
     else if (e == QKeySequence::SelectNextWord) {
             op = QTextCursor::WordRight;
             mode = QTextCursor::KeepAnchor;
     }
     else if (e == QKeySequence::SelectPreviousWord) {
             op = QTextCursor::WordLeft;
             mode = QTextCursor::KeepAnchor;
     }
     else if (e == QKeySequence::SelectStartOfLine) {
             op = QTextCursor::StartOfLine;
             mode = QTextCursor::KeepAnchor;
     }
     else if (e == QKeySequence::SelectEndOfLine) {
             op = QTextCursor::EndOfLine;
             mode = QTextCursor::KeepAnchor;
     }
     else if (e == QKeySequence::SelectStartOfBlock) {
             op = QTextCursor::StartOfBlock;
             mode = QTextCursor::KeepAnchor;
     }
     else if (e == QKeySequence::SelectEndOfBlock) {
             op = QTextCursor::EndOfBlock;
             mode = QTextCursor::KeepAnchor;
     }
     else if (e == QKeySequence::SelectStartOfDocument) {
             op = QTextCursor::Start;
             mode = QTextCursor::KeepAnchor;
     }
     else if (e == QKeySequence::SelectEndOfDocument) {
             op = QTextCursor::End;
             mode = QTextCursor::KeepAnchor;
     }
     else if (e == QKeySequence::SelectPreviousLine) {
             op = QTextCursor::Up;
             mode = QTextCursor::KeepAnchor;
     }
     else if (e == QKeySequence::SelectNextLine) {
             op = QTextCursor::Down;
             mode = QTextCursor::KeepAnchor;
             {
                 QTextBlock block = cursor.block();
                 QTextLine line = currentTextLine(cursor);
                 if (!block.next().isValid()
                     && line.isValid()
                     && line.lineNumber() == block.layout()->lineCount() - 1)
                     op = QTextCursor::End;
             }
     }
     else if (e == QKeySequence::MoveToNextWord) {
             op = QTextCursor::WordRight;
     }
     else if (e == QKeySequence::MoveToPreviousWord) {
             op = QTextCursor::WordLeft;
     }
     else if (e == QKeySequence::MoveToEndOfBlock) {
             op = QTextCursor::EndOfBlock;
     }
     else if (e == QKeySequence::MoveToStartOfBlock) {
             op = QTextCursor::StartOfBlock;
     }
     else if (e == QKeySequence::MoveToNextLine) {
             op = QTextCursor::Down;
     }
     else if (e == QKeySequence::MoveToPreviousLine) {
             op = QTextCursor::Up;
     }
     else if (e == QKeySequence::MoveToPreviousLine) {
             op = QTextCursor::Up;
     }
     else if (e == QKeySequence::MoveToStartOfLine) {
             op = QTextCursor::StartOfLine;
     }
     else if (e == QKeySequence::MoveToEndOfLine) {
             op = QTextCursor::EndOfLine;
     }
     else if (e == QKeySequence::MoveToStartOfDocument) {
             op = QTextCursor::Start;
     }
     else if (e == QKeySequence::MoveToEndOfDocument) {
             op = QTextCursor::End;
     }
 #endif // QT_NO_SHORTCUT
     else {
         return false;
     }
 
 // Except for pageup and pagedown, Mac OS X has very different behavior, we don't do it all, but
 // here's the breakdown:
 // Shift still works as an anchor, but only one of the other keys can be down Ctrl (Command),
 // Alt (Option), or Meta (Control).
 // Command/Control + Left/Right -- Move to left or right of the line
 //                 + Up/Down -- Move to top bottom of the file. (Control doesn't move the cursor)
 // Option + Left/Right -- Move one word Left/right.
 //        + Up/Down  -- Begin/End of Paragraph.
 // Home/End Top/Bottom of file. (usually don't move the cursor, but will select)
 
     bool visualNavigation = cursor.visualNavigation();
     cursor.setVisualNavigation(true);
     const bool moved = cursor.movePosition(op, mode);
     cursor.setVisualNavigation(visualNavigation);
     q->ensureCursorVisible();
 
     bool ignoreNavigationEvents = ignoreUnusedNavigationEvents;
     bool isNavigationEvent = e->key() == Qt::Key_Up || e->key() == Qt::Key_Down;
 
 #ifdef QT_KEYPAD_NAVIGATION
     ignoreNavigationEvents = ignoreNavigationEvents || QApplication::keypadNavigationEnabled();
     isNavigationEvent = isNavigationEvent ||
                         (QApplication::navigationMode() == Qt::NavigationModeKeypadDirectional
                          && (e->key() == Qt::Key_Left || e->key() == Qt::Key_Right));
 #else
     isNavigationEvent = isNavigationEvent || e->key() == Qt::Key_Left || e->key() == Qt::Key_Right;
 #endif
 
     if (moved) {
         if (cursor.position() != oldCursorPos)
             emit q->cursorPositionChanged();
         emit q->microFocusChanged();
     } else if (ignoreNavigationEvents && isNavigationEvent && oldSelection.anchor() == cursor.anchor()) {
         return false;
     }
 
     selectionChanged(/*forceEmitSelectionChanged =*/(mode == QTextCursor::KeepAnchor));
 
     repaintOldAndNewSelection(oldSelection);
 
     return true;
 }

◆ cursorRectPlusUnicodeDirectionMarkers()

QRectF QTextControlPrivate::cursorRectPlusUnicodeDirectionMarkers ( const QTextCursor & cursor ) const

Definition at line 2215 of file qtextcontrol.cpp.

Referenced by repaintCursor(), repaintOldAndNewSelection(), and repaintSelection().

 {
     if (cursor.isNull())
         return QRectF();
 
     return rectForPosition(cursor.position()).adjusted(-4, 0, 4, 0);
 }

◆ dragEnterEvent()

bool QTextControlPrivate::dragEnterEvent	(	QEvent *	e,
		const QMimeData *	mimeData
	)

Definition at line 1861 of file qtextcontrol.cpp.

Referenced by selectionRect().

 {
     Q_Q(QTextControl);
     if (!(interactionFlags & Qt::TextEditable) || !q->canInsertFromMimeData(mimeData)) {
         e->ignore();
         return false;
     }
 
     dndFeedbackCursor = QTextCursor();
 
     return true; // accept proposed action
 }

◆ dragLeaveEvent()

void QTextControlPrivate::dragLeaveEvent ( )

Definition at line 1874 of file qtextcontrol.cpp.

Referenced by selectionRect().

 {
     Q_Q(QTextControl);
 
     const QRectF crect = q->cursorRect(dndFeedbackCursor);
     dndFeedbackCursor = QTextCursor();
 
     if (crect.isValid())
         emit q->updateRequest(crect);
 }

◆ dragMoveEvent()

bool QTextControlPrivate::dragMoveEvent	(	QEvent *	e,
		const QMimeData *	mimeData,
		const QPointF &	pos
	)

Definition at line 1885 of file qtextcontrol.cpp.

Referenced by selectionRect().

 {
     Q_Q(QTextControl);
     if (!(interactionFlags & Qt::TextEditable) || !q->canInsertFromMimeData(mimeData)) {
         e->ignore();
         return false;
     }
 
     const int cursorPos = q->hitTest(pos, Qt::FuzzyHit);
     if (cursorPos != -1) {
         QRectF crect = q->cursorRect(dndFeedbackCursor);
         if (crect.isValid())
             emit q->updateRequest(crect);
 
         dndFeedbackCursor = cursor;
         dndFeedbackCursor.setPosition(cursorPos);
 
         crect = q->cursorRect(dndFeedbackCursor);
         emit q->updateRequest(crect);
     }
 
     return true; // accept proposed action
 }

◆ dropEvent()

bool QTextControlPrivate::dropEvent	(	const QMimeData *	mimeData,
		const QPointF &	pos,
		Qt::DropAction	dropAction,
		QWidget *	source
	)

Definition at line 1909 of file qtextcontrol.cpp.

Referenced by selectionRect().

 {
     Q_Q(QTextControl);
     dndFeedbackCursor = QTextCursor();
 
     if (!(interactionFlags & Qt::TextEditable) || !q->canInsertFromMimeData(mimeData))
         return false;
 
     repaintSelection();
 
     QTextCursor insertionCursor = q->cursorForPosition(pos);
     insertionCursor.beginEditBlock();
 
     if (dropAction == Qt::MoveAction && source == contextWidget)
         cursor.removeSelectedText();
 
     cursor = insertionCursor;
     q->insertFromMimeData(mimeData);
     insertionCursor.endEditBlock();
     q->ensureCursorVisible();
     return true; // accept proposed action
 }

◆ extendBlockwiseSelection()

void QTextControlPrivate::extendBlockwiseSelection ( int suggestedNewPosition )

Definition at line 726 of file qtextcontrol.cpp.

Referenced by repaintSelection().

 {
     Q_Q(QTextControl);
 
     // if inside the initial selected line keep that
     if (suggestedNewPosition >= selectedBlockOnTrippleClick.selectionStart()
         && suggestedNewPosition <= selectedBlockOnTrippleClick.selectionEnd()) {
         q->setTextCursor(selectedBlockOnTrippleClick);
         return;
     }
 
     if (suggestedNewPosition < selectedBlockOnTrippleClick.position()) {
         cursor.setPosition(selectedBlockOnTrippleClick.selectionEnd());
         cursor.setPosition(suggestedNewPosition, QTextCursor::KeepAnchor);
         cursor.movePosition(QTextCursor::StartOfBlock, QTextCursor::KeepAnchor);
     } else {
         cursor.setPosition(selectedBlockOnTrippleClick.selectionStart());
         cursor.setPosition(suggestedNewPosition, QTextCursor::KeepAnchor);
         cursor.movePosition(QTextCursor::EndOfBlock, QTextCursor::KeepAnchor);
         cursor.movePosition(QTextCursor::NextCharacter, QTextCursor::KeepAnchor);
     }
 
     if (interactionFlags & Qt::TextSelectableByMouse) {
 #ifndef QT_NO_CLIPBOARD
         setClipboardSelection();
 #endif
         selectionChanged(true);
     }
 }

◆ extendWordwiseSelection()

void QTextControlPrivate::extendWordwiseSelection	(	int	suggestedNewPosition,
		qreal	mouseXPosition
	)

Definition at line 652 of file qtextcontrol.cpp.

Referenced by repaintSelection().

 {
     Q_Q(QTextControl);
 
     // if inside the initial selected word keep that
     if (suggestedNewPosition >= selectedWordOnDoubleClick.selectionStart()
         && suggestedNewPosition <= selectedWordOnDoubleClick.selectionEnd()) {
         q->setTextCursor(selectedWordOnDoubleClick);
         return;
     }
 
     QTextCursor curs = selectedWordOnDoubleClick;
     curs.setPosition(suggestedNewPosition, QTextCursor::KeepAnchor);
 
     if (!curs.movePosition(QTextCursor::StartOfWord))
         return;
     const int wordStartPos = curs.position();
 
     const int blockPos = curs.block().position();
     const QPointF blockCoordinates = q->blockBoundingRect(curs.block()).topLeft();
 
     QTextLine line = currentTextLine(curs);
     if (!line.isValid())
         return;
 
     const qreal wordStartX = line.cursorToX(curs.position() - blockPos) + blockCoordinates.x();
 
     if (!curs.movePosition(QTextCursor::EndOfWord))
         return;
     const int wordEndPos = curs.position();
 
     const QTextLine otherLine = currentTextLine(curs);
     if (otherLine.textStart() != line.textStart()
         || wordEndPos == wordStartPos)
         return;
 
     const qreal wordEndX = line.cursorToX(curs.position() - blockPos) + blockCoordinates.x();
 
     if (!wordSelectionEnabled && (mouseXPosition < wordStartX || mouseXPosition > wordEndX))
         return;
 
     if (wordSelectionEnabled) {
         if (suggestedNewPosition < selectedWordOnDoubleClick.position()) {
             cursor.setPosition(selectedWordOnDoubleClick.selectionEnd());
             setCursorPosition(wordStartPos, QTextCursor::KeepAnchor);
         } else {
             cursor.setPosition(selectedWordOnDoubleClick.selectionStart());
             setCursorPosition(wordEndPos, QTextCursor::KeepAnchor);
         }
     } else {
         // keep the already selected word even when moving to the left
         // (#39164)
         if (suggestedNewPosition < selectedWordOnDoubleClick.position())
             cursor.setPosition(selectedWordOnDoubleClick.selectionEnd());
         else
             cursor.setPosition(selectedWordOnDoubleClick.selectionStart());
 
         const qreal differenceToStart = mouseXPosition - wordStartX;
         const qreal differenceToEnd = wordEndX - mouseXPosition;
 
         if (differenceToStart < differenceToEnd)
             setCursorPosition(wordStartPos, QTextCursor::KeepAnchor);
         else
             setCursorPosition(wordEndPos, QTextCursor::KeepAnchor);
     }
 
     if (interactionFlags & Qt::TextSelectableByMouse) {
 #ifndef QT_NO_CLIPBOARD
         setClipboardSelection();
 #endif
         selectionChanged(true);
     }
 }

◆ focusEvent()

void QTextControlPrivate::focusEvent ( QFocusEvent * e )

Definition at line 2037 of file qtextcontrol.cpp.

Referenced by selectionRect().

 {
     Q_Q(QTextControl);
     emit q->updateRequest(q->selectionRect());
     if (e->gotFocus()) {
 #ifdef QT_KEYPAD_NAVIGATION
         if (!QApplication::keypadNavigationEnabled() || (hasEditFocus && (e->reason() == Qt::PopupFocusReason
 #ifdef Q_OS_SYMBIAN
             || e->reason() == Qt::ActiveWindowFocusReason
 #endif
             ))) {
 #endif
             setBlinkingCursorEnabled(interactionFlags & (Qt::TextEditable | Qt::TextSelectableByKeyboard));
 #ifdef QT_KEYPAD_NAVIGATION
         }
 #endif
     } else {
         setBlinkingCursorEnabled(false);
 
         if (cursorIsFocusIndicator
             && e->reason() != Qt::ActiveWindowFocusReason
             && e->reason() != Qt::PopupFocusReason
             && cursor.hasSelection()) {
             cursor.clearSelection();
         }
     }
     hasFocus = e->gotFocus();
 }

◆ gotoNextTableCell()

void QTextControlPrivate::gotoNextTableCell ( )

Definition at line 351 of file qtextcontrol.cpp.

 {
     QTextTable *table = cursor.currentTable();
     QTextTableCell cell = table->cellAt(cursor);
 
     int newColumn = cell.column() + cell.columnSpan();
     int newRow = cell.row();
 
     if (newColumn >= table->columns()) {
         newColumn = 0;
         ++newRow;
         if (newRow >= table->rows())
             table->insertRows(table->rows(), 1);
     }
 
     cell = table->cellAt(newRow, newColumn);
     cursor = cell.firstCursorPosition();
 }

◆ gotoPreviousTableCell()

void QTextControlPrivate::gotoPreviousTableCell ( )

Definition at line 370 of file qtextcontrol.cpp.

 {
     QTextTable *table = cursor.currentTable();
     QTextTableCell cell = table->cellAt(cursor);
 
     int newColumn = cell.column() - 1;
     int newRow = cell.row();
 
     if (newColumn < 0) {
         newColumn = table->columns() - 1;
         --newRow;
         if (newRow < 0)
             return;
     }
 
     cell = table->cellAt(newRow, newColumn);
     cursor = cell.firstCursorPosition();
 }

◆ indent()

void QTextControlPrivate::indent ( )

Definition at line 314 of file qtextcontrol.cpp.

 {
     QTextBlockFormat blockFmt = cursor.blockFormat();
 
     QTextList *list = cursor.currentList();
     if (!list) {
         QTextBlockFormat modifier;
         modifier.setIndent(blockFmt.indent() + 1);
         cursor.mergeBlockFormat(modifier);
     } else {
         QTextListFormat format = list->format();
         format.setIndent(format.indent() + 1);
 
         if (list->itemNumber(cursor.block()) == 1)
             list->setFormat(format);
         else
             cursor.createList(format);
     }
 }

◆ init()

void QTextControlPrivate::init	(	Qt::TextFormat	format = `Qt::RichText`,
		const QString &	text = `QString()`,
		QTextDocument *	document = `0`
	)

Definition at line 407 of file qtextcontrol.cpp.

 {
     setContent(format, text, document);
 
     doc->setUndoRedoEnabled(interactionFlags & Qt::TextEditable);
 }

◆ inputContext()

QInputContext * QTextControlPrivate::inputContext ( )

Definition at line 3060 of file qtextcontrol.cpp.

Referenced by selectionRect().

 {
     QInputContext *ctx = contextWidget->inputContext();
     if (!ctx && contextWidget->parentWidget())
         ctx = contextWidget->parentWidget()->inputContext();
     return ctx;
 }

◆ inputMethodEvent()

void QTextControlPrivate::inputMethodEvent ( QInputMethodEvent * e )

Definition at line 1932 of file qtextcontrol.cpp.

Referenced by selectionRect().

 {
     Q_Q(QTextControl);
     if (!(interactionFlags & Qt::TextEditable) || cursor.isNull()) {
         e->ignore();
         return;
     }
     bool isGettingInput = !e->commitString().isEmpty()
             || e->preeditString() != cursor.block().layout()->preeditAreaText()
             || e->replacementLength() > 0;
 
     cursor.beginEditBlock();
     if (isGettingInput) {
         cursor.removeSelectedText();
     }
 
     // insert commit string
     if (!e->commitString().isEmpty() || e->replacementLength()) {
         QTextCursor c = cursor;
         c.setPosition(c.position() + e->replacementStart());
         c.setPosition(c.position() + e->replacementLength(), QTextCursor::KeepAnchor);
         c.insertText(e->commitString());
     }
 
     for (int i = 0; i < e->attributes().size(); ++i) {
         const QInputMethodEvent::Attribute &a = e->attributes().at(i);
         if (a.type == QInputMethodEvent::Selection) {
             QTextCursor oldCursor = cursor;
             int blockStart = a.start + cursor.block().position();
             cursor.setPosition(blockStart, QTextCursor::MoveAnchor);
             cursor.setPosition(blockStart + a.length, QTextCursor::KeepAnchor);
             q->ensureCursorVisible();
             repaintOldAndNewSelection(oldCursor);
         }
     }
 
     QTextBlock block = cursor.block();
     QTextLayout *layout = block.layout();
     if (isGettingInput)
         layout->setPreeditArea(cursor.position() - block.position(), e->preeditString());
     QList<QTextLayout::FormatRange> overrides;
     const int oldPreeditCursor = preeditCursor;
     preeditCursor = e->preeditString().length();
     hideCursor = false;
     for (int i = 0; i < e->attributes().size(); ++i) {
         const QInputMethodEvent::Attribute &a = e->attributes().at(i);
         if (a.type == QInputMethodEvent::Cursor) {
             preeditCursor = a.start;
             hideCursor = !a.length;
         } else if (a.type == QInputMethodEvent::TextFormat) {
             QTextCharFormat f = qvariant_cast<QTextFormat>(a.value).toCharFormat();
             if (f.isValid()) {
                 if (f.background().color().alphaF() == 1 && f.background().style() == Qt::SolidPattern) {
                     f.setForeground(f.background().color());
                     f.setBackground(Qt::transparent);
                     f.setUnderlineStyle(QTextCharFormat::SingleUnderline);
                     f.setFontUnderline(true);
                 }
                 QTextLayout::FormatRange o;
                 o.start = a.start + cursor.position() - block.position();
                 o.length = a.length;
                 o.format = f;
                 overrides.append(o);
             }
         }
     }
     layout->setAdditionalFormats(overrides);
     cursor.endEditBlock();
     if (cursor.d)
         cursor.d->setX();
     if (oldPreeditCursor != preeditCursor)
         emit q->microFocusChanged();
 }

◆ keyPressEvent()

void QTextControlPrivate::keyPressEvent ( QKeyEvent * e )

Definition at line 1166 of file qtextcontrol.cpp.

Referenced by selectionRect().

 {
     Q_Q(QTextControl);
 #ifndef QT_NO_SHORTCUT
     if (e == QKeySequence::SelectAll) {
             e->accept();
             q->selectAll();
             return;
     }
 #ifndef QT_NO_CLIPBOARD
     else if (e == QKeySequence::Copy) {
             e->accept();
             q->copy();
             return;
     }
 #endif
 #endif // QT_NO_SHORTCUT
 
     if (interactionFlags & Qt::TextSelectableByKeyboard
         && cursorMoveKeyEvent(e))
         goto accept;
 
     if (interactionFlags & Qt::LinksAccessibleByKeyboard) {
         if ((e->key() == Qt::Key_Return
              || e->key() == Qt::Key_Enter
 #ifdef QT_KEYPAD_NAVIGATION
              || e->key() == Qt::Key_Select
 #endif
              )
             && cursor.hasSelection()) {
 
             e->accept();
             activateLinkUnderCursor();
             return;
         }
     }
 
     if (!(interactionFlags & Qt::TextEditable)) {
         e->ignore();
         return;
     }
 
     if (e->key() == Qt::Key_Direction_L || e->key() == Qt::Key_Direction_R) {
         QTextBlockFormat fmt;
         fmt.setLayoutDirection((e->key() == Qt::Key_Direction_L) ? Qt::LeftToRight : Qt::RightToLeft);
         cursor.mergeBlockFormat(fmt);
         goto accept;
     }
 
     // schedule a repaint of the region of the cursor, as when we move it we
     // want to make sure the old cursor disappears (not noticeable when moving
     // only a few pixels but noticeable when jumping between cells in tables for
     // example)
     repaintSelection();
 
     if (e->key() == Qt::Key_Backspace && !(e->modifiers() & ~Qt::ShiftModifier)) {
         QTextBlockFormat blockFmt = cursor.blockFormat();
         QTextList *list = cursor.currentList();
         if (list && cursor.atBlockStart() && !cursor.hasSelection()) {
             list->remove(cursor.block());
         } else if (cursor.atBlockStart() && blockFmt.indent() > 0) {
             blockFmt.setIndent(blockFmt.indent() - 1);
             cursor.setBlockFormat(blockFmt);
         } else {
             QTextCursor localCursor = cursor;
             localCursor.deletePreviousChar();
         }
         goto accept;
     }
 #ifndef QT_NO_SHORTCUT
       else if (e == QKeySequence::InsertParagraphSeparator) {
         cursor.insertBlock();
         e->accept();
         goto accept;
     } else if (e == QKeySequence::InsertLineSeparator) {
         cursor.insertText(QString(QChar::LineSeparator));
         e->accept();
         goto accept;
     }
 #endif
     if (false) {
     }
 #ifndef QT_NO_SHORTCUT
     else if (e == QKeySequence::Undo) {
             q->undo();
     }
     else if (e == QKeySequence::Redo) {
            q->redo();
     }
 #ifndef QT_NO_CLIPBOARD
     else if (e == QKeySequence::Cut) {
            q->cut();
     }
     else if (e == QKeySequence::Paste) {
         QClipboard::Mode mode = QClipboard::Clipboard;
 #ifdef Q_WS_X11
         if (e->modifiers() == (Qt::CTRL | Qt::SHIFT) && e->key() == Qt::Key_Insert)
             mode = QClipboard::Selection;
 #endif
         q->paste(mode);
     }
 #endif
     else if (e == QKeySequence::Delete) {
         QTextCursor localCursor = cursor;
         localCursor.deleteChar();
     }
     else if (e == QKeySequence::DeleteEndOfWord) {
         if (!cursor.hasSelection())
             cursor.movePosition(QTextCursor::NextWord, QTextCursor::KeepAnchor);
         cursor.removeSelectedText();
     }
     else if (e == QKeySequence::DeleteStartOfWord) {
         if (!cursor.hasSelection())
             cursor.movePosition(QTextCursor::PreviousWord, QTextCursor::KeepAnchor);
         cursor.removeSelectedText();
     }
     else if (e == QKeySequence::DeleteEndOfLine) {
         QTextBlock block = cursor.block();
         if (cursor.position() == block.position() + block.length() - 2)
             cursor.movePosition(QTextCursor::Right, QTextCursor::KeepAnchor);
         else
             cursor.movePosition(QTextCursor::EndOfBlock, QTextCursor::KeepAnchor);
         cursor.removeSelectedText();
     }
 #endif // QT_NO_SHORTCUT
     else {
         goto process;
     }
     goto accept;
 
 process:
     {
         QString text = e->text();
         if (!text.isEmpty() && (text.at(0).isPrint() || text.at(0) == QLatin1Char('\t'))) {
             if (overwriteMode
                 // no need to call deleteChar() if we have a selection, insertText
                 // does it already
                 && !cursor.hasSelection()
                 && !cursor.atBlockEnd())
                 cursor.deleteChar();
 
             cursor.insertText(text);
             selectionChanged();
         } else {
             e->ignore();
             return;
         }
     }
 
  accept:
 
     e->accept();
     cursorOn = true;
 
     q->ensureCursorVisible();
 
     updateCurrentCharFormat();
 }

◆ mouseDoubleClickEvent()

void QTextControlPrivate::mouseDoubleClickEvent	(	QEvent *	e,
		Qt::MouseButton	button,
		const QPointF &	pos,
		Qt::KeyboardModifiers	modifiers,
		Qt::MouseButtons	buttons,
		const QPoint &	globalPos
	)

Definition at line 1761 of file qtextcontrol.cpp.

Referenced by selectionRect().

 {
     Q_Q(QTextControl);
 
     if (sendMouseEventToInputContext(
             e, QEvent::MouseButtonDblClick, button, pos, modifiers, buttons, globalPos)) {
         return;
     }
 
     if (button != Qt::LeftButton
         || !(interactionFlags & Qt::TextSelectableByMouse)) {
         e->ignore();
         return;
     }
 
 #ifndef QT_NO_DRAGANDDROP
     mightStartDrag = false;
 #endif
     const QTextCursor oldSelection = cursor;
     setCursorPosition(pos);
     QTextLine line = currentTextLine(cursor);
     bool doEmit = false;
     if (line.isValid() && line.textLength()) {
         cursor.select(QTextCursor::WordUnderCursor);
         doEmit = true;
     }
     repaintOldAndNewSelection(oldSelection);
 
     cursorIsFocusIndicator = false;
     selectedWordOnDoubleClick = cursor;
 
     trippleClickPoint = pos;
     trippleClickTimer.start(QApplication::doubleClickInterval(), q);
     if (doEmit) {
         selectionChanged();
 #ifndef QT_NO_CLIPBOARD
         setClipboardSelection();
 #endif
         emit q->cursorPositionChanged();
     }
 }

◆ mouseMoveEvent()

void QTextControlPrivate::mouseMoveEvent	(	QEvent *	e,
		Qt::MouseButton	button,
		const QPointF &	pos,
		Qt::KeyboardModifiers	modifiers,
		Qt::MouseButtons	buttons,
		const QPoint &	globalPos
	)

Definition at line 1612 of file qtextcontrol.cpp.

Referenced by selectionRect().

 {
     Q_Q(QTextControl);
 
     if (sendMouseEventToInputContext(
             e, QEvent::MouseMove, button, mousePos, modifiers, buttons, globalPos)) {
         return;
     }
 
     if (interactionFlags & Qt::LinksAccessibleByMouse) {
         QString anchor = q->anchorAt(mousePos);
         if (anchor != highlightedAnchor) {
             highlightedAnchor = anchor;
             emit q->linkHovered(anchor);
         }
     }
 
     if (!(buttons & Qt::LeftButton))
         return;
 
     const bool editable = interactionFlags & Qt::TextEditable;
 
     if (!(mousePressed
           || editable
           || mightStartDrag
           || selectedWordOnDoubleClick.hasSelection()
           || selectedBlockOnTrippleClick.hasSelection()))
         return;
 
     const QTextCursor oldSelection = cursor;
     const int oldCursorPos = cursor.position();
 
     if (mightStartDrag) {
         if ((mousePos.toPoint() - dragStartPos).manhattanLength() > QApplication::startDragDistance())
             startDrag();
         return;
     }
 
     const qreal mouseX = qreal(mousePos.x());
 
     int newCursorPos = q->hitTest(mousePos, Qt::FuzzyHit);
     if (newCursorPos == -1)
         return;
 
     if (mousePressed && wordSelectionEnabled && !selectedWordOnDoubleClick.hasSelection()) {
         selectedWordOnDoubleClick = cursor;
         selectedWordOnDoubleClick.select(QTextCursor::WordUnderCursor);
     }
 
     if (selectedBlockOnTrippleClick.hasSelection())
         extendBlockwiseSelection(newCursorPos);
     else if (selectedWordOnDoubleClick.hasSelection())
         extendWordwiseSelection(newCursorPos, mouseX);
     else if (mousePressed)
         setCursorPosition(newCursorPos, QTextCursor::KeepAnchor);
 
     if (interactionFlags & Qt::TextEditable) {
         // don't call ensureVisible for the visible cursor to avoid jumping
         // scrollbars. the autoscrolling ensures smooth scrolling if necessary.
         //q->ensureCursorVisible();
         if (cursor.position() != oldCursorPos)
             emit q->cursorPositionChanged();
         _q_updateCurrentCharFormatAndSelection();
 #ifndef QT_NO_IM
         if (contextWidget) {
             if (QInputContext *ic = inputContext()) {
                 ic->update();
             }
         }
 #endif //QT_NO_IM
     } else {
         //emit q->visibilityRequest(QRectF(mousePos, QSizeF(1, 1)));
         if (cursor.position() != oldCursorPos) {
             emit q->cursorPositionChanged();
             emit q->microFocusChanged();
         }
     }
     selectionChanged(true);
     repaintOldAndNewSelection(oldSelection);
 }

◆ mousePressEvent()

void QTextControlPrivate::mousePressEvent	(	QEvent *	e,
		Qt::MouseButton	button,
		const QPointF &	pos,
		Qt::KeyboardModifiers	modifiers,
		Qt::MouseButtons	buttons,
		const QPoint &	globalPos
	)

Definition at line 1513 of file qtextcontrol.cpp.

Referenced by selectionRect().

 {
     Q_Q(QTextControl);
 
     if (sendMouseEventToInputContext(
             e, QEvent::MouseButtonPress, button, pos, modifiers, buttons, globalPos)) {
         return;
     }
 
     if (interactionFlags & Qt::LinksAccessibleByMouse) {
         anchorOnMousePress = q->anchorAt(pos);
 
         if (cursorIsFocusIndicator) {
             cursorIsFocusIndicator = false;
             repaintSelection();
             cursor.clearSelection();
         }
     }
     if (!(button & Qt::LeftButton) ||
         !((interactionFlags & Qt::TextSelectableByMouse) || (interactionFlags & Qt::TextEditable))) {
             e->ignore();
             return;
     }
 
     cursorIsFocusIndicator = false;
     const QTextCursor oldSelection = cursor;
     const int oldCursorPos = cursor.position();
 
     mousePressed = (interactionFlags & Qt::TextSelectableByMouse);
 #ifndef QT_NO_DRAGANDDROP
     mightStartDrag = false;
 #endif
 
     if (trippleClickTimer.isActive()
         && ((pos - trippleClickPoint).toPoint().manhattanLength() < QApplication::startDragDistance())) {
 
         cursor.movePosition(QTextCursor::StartOfBlock);
         cursor.movePosition(QTextCursor::EndOfBlock, QTextCursor::KeepAnchor);
         cursor.movePosition(QTextCursor::NextCharacter, QTextCursor::KeepAnchor);
         selectedBlockOnTrippleClick = cursor;
 
         anchorOnMousePress = QString();
 
         trippleClickTimer.stop();
     } else {
         int cursorPos = q->hitTest(pos, Qt::FuzzyHit);
         if (cursorPos == -1) {
             e->ignore();
             return;
         }
 
         if (modifiers == Qt::ShiftModifier && (interactionFlags & Qt::TextSelectableByMouse)) {
             if (wordSelectionEnabled && !selectedWordOnDoubleClick.hasSelection()) {
                 selectedWordOnDoubleClick = cursor;
                 selectedWordOnDoubleClick.select(QTextCursor::WordUnderCursor);
             }
 
             if (selectedBlockOnTrippleClick.hasSelection())
                 extendBlockwiseSelection(cursorPos);
             else if (selectedWordOnDoubleClick.hasSelection())
                 extendWordwiseSelection(cursorPos, pos.x());
             else if (!wordSelectionEnabled)
                 setCursorPosition(cursorPos, QTextCursor::KeepAnchor);
         } else {
 
             if (dragEnabled
                 && cursor.hasSelection()
                 && !cursorIsFocusIndicator
                 && cursorPos >= cursor.selectionStart()
                 && cursorPos <= cursor.selectionEnd()
                 && q->hitTest(pos, Qt::ExactHit) != -1) {
 #ifndef QT_NO_DRAGANDDROP
                 mightStartDrag = true;
                 dragStartPos = pos.toPoint();
 #endif
                 return;
             }
 
             setCursorPosition(cursorPos);
         }
     }
 
     if (interactionFlags & Qt::TextEditable) {
         q->ensureCursorVisible();
         if (cursor.position() != oldCursorPos)
             emit q->cursorPositionChanged();
         _q_updateCurrentCharFormatAndSelection();
     } else {
         if (cursor.position() != oldCursorPos) {
             emit q->cursorPositionChanged();
             emit q->microFocusChanged();
         }
         selectionChanged();
     }
     repaintOldAndNewSelection(oldSelection);
     hadSelectionOnMousePress = cursor.hasSelection();
 }

◆ mouseReleaseEvent()

void QTextControlPrivate::mouseReleaseEvent	(	QEvent *	e,
		Qt::MouseButton	button,
		const QPointF &	pos,
		Qt::KeyboardModifiers	modifiers,
		Qt::MouseButtons	buttons,
		const QPoint &	globalPos
	)

Definition at line 1694 of file qtextcontrol.cpp.

Referenced by selectionRect().

 {
     Q_Q(QTextControl);
 
     if (sendMouseEventToInputContext(
             e, QEvent::MouseButtonRelease, button, pos, modifiers, buttons, globalPos)) {
         return;
     }
 
     const QTextCursor oldSelection = cursor;
     const int oldCursorPos = cursor.position();
 
 #ifndef QT_NO_DRAGANDDROP
     if (mightStartDrag && (button & Qt::LeftButton)) {
         mousePressed = false;
         setCursorPosition(pos);
         cursor.clearSelection();
         selectionChanged();
     }
 #endif
     if (mousePressed) {
         mousePressed = false;
 #ifndef QT_NO_CLIPBOARD
         setClipboardSelection();
         selectionChanged(true);
     } else if (button == Qt::MidButton
                && (interactionFlags & Qt::TextEditable)
                && QApplication::clipboard()->supportsSelection()) {
         setCursorPosition(pos);
         const QMimeData *md = QApplication::clipboard()->mimeData(QClipboard::Selection);
         if (md)
             q->insertFromMimeData(md);
 #endif
     }
 
     repaintOldAndNewSelection(oldSelection);
 
     if (cursor.position() != oldCursorPos) {
         emit q->cursorPositionChanged();
         emit q->microFocusChanged();
     }
 
     if (interactionFlags & Qt::LinksAccessibleByMouse) {
         if (!(button & Qt::LeftButton))
             return;
 
         const QString anchor = q->anchorAt(pos);
 
         if (anchor.isEmpty())
             return;
 
         if (!cursor.hasSelection()
             || (anchor == anchorOnMousePress && hadSelectionOnMousePress)) {
 
             const int anchorPos = q->hitTest(pos, Qt::ExactHit);
             if (anchorPos != -1) {
                 cursor.setPosition(anchorPos);
 
                 QString anchor = anchorOnMousePress;
                 anchorOnMousePress = QString();
                 activateLinkUnderCursor(anchor);
             }
         }
     }
 }

◆ outdent()

void QTextControlPrivate::outdent ( )

Definition at line 334 of file qtextcontrol.cpp.

 {
     QTextBlockFormat blockFmt = cursor.blockFormat();
 
     QTextList *list = cursor.currentList();
 
     if (!list) {
         QTextBlockFormat modifier;
         modifier.setIndent(blockFmt.indent() - 1);
         cursor.mergeBlockFormat(modifier);
     } else {
         QTextListFormat listFmt = list->format();
         listFmt.setIndent(listFmt.indent() - 1);
         list->setFormat(listFmt);
     }
 }

◆ paste()

void QTextControlPrivate::paste ( const QMimeData * source )

◆ rectForPosition()

QRectF QTextControlPrivate::rectForPosition ( int position ) const

Definition at line 1347 of file qtextcontrol.cpp.

Referenced by repaintSelection().

 {
     Q_Q(const QTextControl);
     const QTextBlock block = doc->findBlock(position);
     if (!block.isValid())
         return QRectF();
     const QAbstractTextDocumentLayout *docLayout = doc->documentLayout();
     const QTextLayout *layout = block.layout();
     const QPointF layoutPos = q->blockBoundingRect(block).topLeft();
     int relativePos = position - block.position();
     if (preeditCursor != 0) {
         int preeditPos = layout->preeditAreaPosition();
         if (relativePos == preeditPos)
             relativePos += preeditCursor;
         else if (relativePos > preeditPos)
             relativePos += layout->preeditAreaText().length();
     }
     QTextLine line = layout->lineForTextPosition(relativePos);
 
     int cursorWidth;
     {
         bool ok = false;
 #ifndef QT_NO_PROPERTIES
         cursorWidth = docLayout->property("cursorWidth").toInt(&ok);
 #endif
         if (!ok)
             cursorWidth = 1;
     }
 
     QRectF r;
 
     if (line.isValid()) {
         qreal x = line.cursorToX(relativePos);
         qreal w = 0;
         if (overwriteMode) {
             if (relativePos < line.textLength() - line.textStart())
                 w = line.cursorToX(relativePos + 1) - x;
             else
                 w = QFontMetrics(block.layout()->font()).width(QLatin1Char(' ')); // in sync with QTextLine::draw()
         }
         r = QRectF(layoutPos.x() + x, layoutPos.y() + line.y(),
                    cursorWidth + w, line.height());
     } else {
         r = QRectF(layoutPos.x(), layoutPos.y(), cursorWidth, 10); // #### correct height
     }
 
     return r;
 }

◆ repaintCursor()

void QTextControlPrivate::repaintCursor ( )

Definition at line 547 of file qtextcontrol.cpp.

Referenced by setBlinkingCursorEnabled().

 {
     Q_Q(QTextControl);
     emit q->updateRequest(cursorRectPlusUnicodeDirectionMarkers(cursor));
 }

◆ repaintOldAndNewSelection()

void QTextControlPrivate::repaintOldAndNewSelection ( const QTextCursor & oldSelection )

Definition at line 553 of file qtextcontrol.cpp.

Referenced by cursorMoveKeyEvent(), and repaintSelection().

 {
     Q_Q(QTextControl);
     if (cursor.hasSelection()
         && oldSelection.hasSelection()
         && cursor.currentFrame() == oldSelection.currentFrame()
         && !cursor.hasComplexSelection()
         && !oldSelection.hasComplexSelection()
         && cursor.anchor() == oldSelection.anchor()
         ) {
         QTextCursor differenceSelection(doc);
         differenceSelection.setPosition(oldSelection.position());
         differenceSelection.setPosition(cursor.position(), QTextCursor::KeepAnchor);
         emit q->updateRequest(q->selectionRect(differenceSelection));
     } else {
         if (!oldSelection.isNull())
             emit q->updateRequest(q->selectionRect(oldSelection) | cursorRectPlusUnicodeDirectionMarkers(oldSelection));
         emit q->updateRequest(q->selectionRect() | cursorRectPlusUnicodeDirectionMarkers(cursor));
     }
 }

◆ repaintSelection()

void QTextControlPrivate::repaintSelection ( )

inline

Definition at line 102 of file qtextcontrol_p_p.h.

103 { repaintOldAndNewSelection(QTextCursor()); }

QTextCursor

The QTextCursor class offers an API to access and modify QTextDocuments.

Definition: qtextcursor.h:70

QTextControlPrivate::repaintOldAndNewSelection

void repaintOldAndNewSelection(const QTextCursor &oldSelection)

Definition: qtextcontrol.cpp:553

◆ selectionChanged()

void QTextControlPrivate::selectionChanged ( bool forceEmitSelectionChanged = false )

Definition at line 574 of file qtextcontrol.cpp.

Referenced by _q_updateCurrentCharFormatAndSelection(), cursorMoveKeyEvent(), extendBlockwiseSelection(), extendWordwiseSelection(), and repaintSelection().

 {
     Q_Q(QTextControl);
     if (forceEmitSelectionChanged) {
         emit q->selectionChanged();
 #ifndef QT_NO_ACCESSIBILITY
         if (q->parent())
             QAccessible::updateAccessibility(q->parent(), 0, QAccessible::TextSelectionChanged);
 #endif
     }
 
     bool current = cursor.hasSelection();
     if (current == lastSelectionState)
         return;
 
     lastSelectionState = current;
     emit q->copyAvailable(current);
     if (!forceEmitSelectionChanged) {
         emit q->selectionChanged();
 #ifndef QT_NO_ACCESSIBILITY
         if (q->parent())
             QAccessible::updateAccessibility(q->parent(), 0, QAccessible::TextSelectionChanged);
 #endif
     }
     emit q->microFocusChanged();
 }

◆ selectionRect() [1/2]

QRectF QTextControlPrivate::selectionRect ( const QTextCursor & cursor ) const

◆ selectionRect() [2/2]

QRectF QTextControlPrivate::selectionRect ( ) const

inline

Definition at line 128 of file qtextcontrol_p_p.h.

Referenced by repaintSelection().

129 { return selectionRect(this->cursor); }

QTextControlPrivate::cursor

QTextCursor cursor

Definition: qtextcontrol_p_p.h:179

QTextControlPrivate::selectionRect

QRectF selectionRect() const

Definition: qtextcontrol_p_p.h:128

◆ sendMouseEventToInputContext()

bool QTextControlPrivate::sendMouseEventToInputContext	(	QEvent *	e,
		QEvent::Type	eventType,
		Qt::MouseButton	button,
		const QPointF &	pos,
		Qt::KeyboardModifiers	modifiers,
		Qt::MouseButtons	buttons,
		const QPoint &	globalPos
	)

Definition at line 1804 of file qtextcontrol.cpp.

Referenced by selectionRect().

 {
 #if !defined(QT_NO_IM)
     Q_Q(QTextControl);
 
     QTextLayout *layout = cursor.block().layout();
     if (contextWidget && layout && !layout->preeditAreaText().isEmpty()) {
         QInputContext *ctx = inputContext();
         int cursorPos = q->hitTest(pos, Qt::FuzzyHit) - cursor.position();
 
         if (cursorPos < 0 || cursorPos > layout->preeditAreaText().length()) {
             cursorPos = -1;
             // don't send move events outside the preedit area
             if (eventType == QEvent::MouseMove)
                 return true;
         }
         if (ctx) {
             QMouseEvent ev(eventType, contextWidget->mapFromGlobal(globalPos), globalPos,
                            button, buttons, modifiers);
             ctx->mouseHandler(cursorPos, &ev);
             e->setAccepted(ev.isAccepted());
         }
         if (!layout->preeditAreaText().isEmpty())
             return true;
     }
 #else
     Q_UNUSED(e);
     Q_UNUSED(eventType);
     Q_UNUSED(button);
     Q_UNUSED(pos);
     Q_UNUSED(modifiers);
     Q_UNUSED(buttons);
     Q_UNUSED(globalPos);
 #endif
     return false;
 }

◆ setBlinkingCursorEnabled()

void QTextControlPrivate::setBlinkingCursorEnabled ( bool enable )

Definition at line 638 of file qtextcontrol.cpp.

Referenced by repaintSelection().

 {
     Q_Q(QTextControl);
 
     if (enable && QApplication::cursorFlashTime() > 0)
         cursorBlinkTimer.start(QApplication::cursorFlashTime() / 2, q);
     else
         cursorBlinkTimer.stop();
 
     cursorOn = enable;
 
     repaintCursor();
 }

◆ setClipboardSelection()

void QTextControlPrivate::setClipboardSelection ( )

Definition at line 608 of file qtextcontrol.cpp.

Referenced by extendBlockwiseSelection(), extendWordwiseSelection(), and repaintSelection().

 {
     QClipboard *clipboard = QApplication::clipboard();
     if (!cursor.hasSelection() || !clipboard->supportsSelection())
         return;
     Q_Q(QTextControl);
     QMimeData *data = q->createMimeDataFromSelection();
     clipboard->setMimeData(data, QClipboard::Selection);
 }

◆ setContent()

void QTextControlPrivate::setContent	(	Qt::TextFormat	format = `Qt::RichText`,
		const QString &	text = `QString()`,
		QTextDocument *	document = `0`
	)

Definition at line 414 of file qtextcontrol.cpp.

Referenced by init().

 {
     Q_Q(QTextControl);
 
     // for use when called from setPlainText. we may want to re-use the currently
     // set char format then.
     const QTextCharFormat charFormatForInsertion = cursor.charFormat();
 
     bool clearDocument = true;
     if (!doc) {
         if (document) {
             doc = document;
             clearDocument = false;
         } else {
             palette = QApplication::palette("QTextControl");
             doc = new QTextDocument(q);
         }
         _q_documentLayoutChanged();
         cursor = QTextCursor(doc);
 
 // ####        doc->documentLayout()->setPaintDevice(viewport);
 
         QObject::connect(doc, SIGNAL(contentsChanged()), q, SLOT(_q_updateCurrentCharFormatAndSelection()));
         QObject::connect(doc, SIGNAL(cursorPositionChanged(QTextCursor)), q, SLOT(_q_emitCursorPosChanged(QTextCursor)));
         QObject::connect(doc, SIGNAL(documentLayoutChanged()), q, SLOT(_q_documentLayoutChanged()));
 
         // convenience signal forwards
         QObject::connect(doc, SIGNAL(undoAvailable(bool)), q, SIGNAL(undoAvailable(bool)));
         QObject::connect(doc, SIGNAL(redoAvailable(bool)), q, SIGNAL(redoAvailable(bool)));
         QObject::connect(doc, SIGNAL(modificationChanged(bool)), q, SIGNAL(modificationChanged(bool)));
         QObject::connect(doc, SIGNAL(blockCountChanged(int)), q, SIGNAL(blockCountChanged(int)));
     }
 
     bool previousUndoRedoState = doc->isUndoRedoEnabled();
     if (!document)
         doc->setUndoRedoEnabled(false);
 
     //Saving the index save some time.
     static int contentsChangedIndex = QTextDocument::staticMetaObject.indexOfSignal("contentsChanged()");
     static int textChangedIndex = QTextControl::staticMetaObject.indexOfSignal("textChanged()");
     // avoid multiple textChanged() signals being emitted
     QMetaObject::disconnect(doc, contentsChangedIndex, q, textChangedIndex);
 
     if (!text.isEmpty()) {
         // clear 'our' cursor for insertion to prevent
         // the emission of the cursorPositionChanged() signal.
         // instead we emit it only once at the end instead of
         // at the end of the document after loading and when
         // positioning the cursor again to the start of the
         // document.
         cursor = QTextCursor();
         if (format == Qt::PlainText) {
             QTextCursor formatCursor(doc);
             // put the setPlainText and the setCharFormat into one edit block,
             // so that the syntax highlight triggers only /once/ for the entire
             // document, not twice.
             formatCursor.beginEditBlock();
             doc->setPlainText(text);
             doc->setUndoRedoEnabled(false);
             formatCursor.select(QTextCursor::Document);
             formatCursor.setCharFormat(charFormatForInsertion);
             formatCursor.endEditBlock();
         } else {
 #ifndef QT_NO_TEXTHTMLPARSER
             doc->setHtml(text);
 #else
             doc->setPlainText(text);
 #endif
             doc->setUndoRedoEnabled(false);
         }
         cursor = QTextCursor(doc);
     } else if (clearDocument) {
         doc->clear();
     }
     cursor.setCharFormat(charFormatForInsertion);
 
     QMetaObject::connect(doc, contentsChangedIndex, q, textChangedIndex);
     emit q->textChanged();
     if (!document)
         doc->setUndoRedoEnabled(previousUndoRedoState);
     _q_updateCurrentCharFormatAndSelection();
     if (!document)
         doc->setModified(false);
 
     q->ensureCursorVisible();
     emit q->cursorPositionChanged();
 }

◆ setCursorPosition() [1/2]

void QTextControlPrivate::setCursorPosition ( const QPointF & pos )

Definition at line 528 of file qtextcontrol.cpp.

Referenced by extendWordwiseSelection().

 {
     Q_Q(QTextControl);
     const int cursorPos = q->hitTest(pos, Qt::FuzzyHit);
     if (cursorPos == -1)
         return;
     cursor.setPosition(cursorPos);
 }

◆ setCursorPosition() [2/2]

void QTextControlPrivate::setCursorPosition	(	int	pos,
		QTextCursor::MoveMode	mode = `QTextCursor::MoveAnchor`
	)

Definition at line 537 of file qtextcontrol.cpp.

 {
     cursor.setPosition(pos, mode);
 
     if (mode != QTextCursor::KeepAnchor) {
         selectedWordOnDoubleClick = QTextCursor();
         selectedBlockOnTrippleClick = QTextCursor();
     }
 }

◆ showToolTip()

void QTextControlPrivate::showToolTip	(	const QPoint &	globalPos,
		const QPointF &	pos,
		QWidget *	contextWidget
	)

Definition at line 2745 of file qtextcontrol.cpp.

Referenced by selectionRect().

 {
     const QString toolTip = q_func()->cursorForPosition(pos).charFormat().toolTip();
     if (toolTip.isEmpty())
         return;
     QToolTip::showText(globalPos, toolTip, contextWidget);
 }

◆ startDrag()

void QTextControlPrivate::startDrag ( )

Definition at line 502 of file qtextcontrol.cpp.

 {
 #ifndef QT_NO_DRAGANDDROP
     Q_Q(QTextControl);
     mousePressed = false;
     if (!contextWidget)
         return;
     QMimeData *data = q->createMimeDataFromSelection();
 
     QDrag *drag = new QDrag(contextWidget);
     drag->setMimeData(data);
 
     Qt::DropActions actions = Qt::CopyAction;
     Qt::DropAction action;
     if (interactionFlags & Qt::TextEditable) {
         actions |= Qt::MoveAction;
         action = drag->exec(actions, Qt::MoveAction);
     } else {
         action = drag->exec(actions, Qt::CopyAction);
     }
 
     if (action == Qt::MoveAction && drag->target() != contextWidget)
         cursor.removeSelectedText();
 #endif
 }

◆ updateCurrentCharFormat()

void QTextControlPrivate::updateCurrentCharFormat ( )

Definition at line 301 of file qtextcontrol.cpp.

Referenced by _q_updateCurrentCharFormatAndSelection().

 {
     Q_Q(QTextControl);
 
     QTextCharFormat fmt = cursor.charFormat();
     if (fmt == lastCharFormat)
         return;
     lastCharFormat = fmt;
 
     emit q->currentCharFormatChanged(fmt);
     emit q->microFocusChanged();
 }

Properties

◆ acceptRichText

bool QTextControlPrivate::acceptRichText

Definition at line 207 of file qtextcontrol_p_p.h.

◆ anchorOnMousePress

QString QTextControlPrivate::anchorOnMousePress

Definition at line 222 of file qtextcontrol_p_p.h.

◆ contextWidget

QPointer<QWidget> QTextControlPrivate::contextWidget

Definition at line 197 of file qtextcontrol_p_p.h.

Referenced by selectionRect(), and startDrag().

◆ cursor

QTextCursor QTextControlPrivate::cursor

◆ cursorBlinkTimer

QBasicTimer QTextControlPrivate::cursorBlinkTimer

Definition at line 187 of file qtextcontrol_p_p.h.

Referenced by setBlinkingCursorEnabled().

◆ cursorIsFocusIndicator

bool QTextControlPrivate::cursorIsFocusIndicator

Definition at line 180 of file qtextcontrol_p_p.h.

◆ cursorOn

bool QTextControlPrivate::cursorOn

Definition at line 178 of file qtextcontrol_p_p.h.

Referenced by setBlinkingCursorEnabled().

◆ dndFeedbackCursor

QTextCursor QTextControlPrivate::dndFeedbackCursor

Definition at line 183 of file qtextcontrol_p_p.h.

◆ doc

QTextDocument* QTextControlPrivate::doc

Definition at line 177 of file qtextcontrol_p_p.h.

Referenced by _q_documentLayoutChanged(), init(), repaintOldAndNewSelection(), and setContent().

◆ dragEnabled

bool QTextControlPrivate::dragEnabled

Definition at line 191 of file qtextcontrol_p_p.h.

◆ dragStartPos

QPoint QTextControlPrivate::dragStartPos

Definition at line 196 of file qtextcontrol_p_p.h.

◆ extraSelections

QVector<QAbstractTextDocumentLayout::Selection> QTextControlPrivate::extraSelections

Definition at line 212 of file qtextcontrol_p_p.h.

◆ hadSelectionOnMousePress

bool QTextControlPrivate::hadSelectionOnMousePress

Definition at line 223 of file qtextcontrol_p_p.h.

◆ hasFocus

bool QTextControlPrivate::hasFocus

Definition at line 215 of file qtextcontrol_p_p.h.

◆ hideCursor

bool QTextControlPrivate::hideCursor

Definition at line 210 of file qtextcontrol_p_p.h.

◆ highlightedAnchor

QString QTextControlPrivate::highlightedAnchor

Definition at line 221 of file qtextcontrol_p_p.h.

◆ ignoreAutomaticScrollbarAdjustement

bool QTextControlPrivate::ignoreAutomaticScrollbarAdjustement

Definition at line 201 of file qtextcontrol_p_p.h.

◆ ignoreUnusedNavigationEvents

bool QTextControlPrivate::ignoreUnusedNavigationEvents

Definition at line 225 of file qtextcontrol_p_p.h.

Referenced by cursorMoveKeyEvent().

◆ interactionFlags

Qt::TextInteractionFlags QTextControlPrivate::interactionFlags

Definition at line 185 of file qtextcontrol_p_p.h.

Referenced by _q_deleteSelected(), extendBlockwiseSelection(), extendWordwiseSelection(), init(), and startDrag().

◆ isEnabled

bool QTextControlPrivate::isEnabled

Definition at line 219 of file qtextcontrol_p_p.h.

◆ lastCharFormat

QTextCharFormat QTextControlPrivate::lastCharFormat

Definition at line 181 of file qtextcontrol_p_p.h.

Referenced by updateCurrentCharFormat().

◆ lastSelectionState

bool QTextControlPrivate::lastSelectionState

Definition at line 199 of file qtextcontrol_p_p.h.

Referenced by selectionChanged().

◆ linkToCopy

QString QTextControlPrivate::linkToCopy

Definition at line 230 of file qtextcontrol_p_p.h.

◆ mightStartDrag

bool QTextControlPrivate::mightStartDrag

Definition at line 195 of file qtextcontrol_p_p.h.

◆ mousePressed

bool QTextControlPrivate::mousePressed

Definition at line 193 of file qtextcontrol_p_p.h.

Referenced by startDrag().

◆ openExternalLinks

bool QTextControlPrivate::openExternalLinks

Definition at line 226 of file qtextcontrol_p_p.h.

◆ overwriteMode

bool QTextControlPrivate::overwriteMode

Definition at line 206 of file qtextcontrol_p_p.h.

◆ palette

QPalette QTextControlPrivate::palette

Definition at line 214 of file qtextcontrol_p_p.h.

Referenced by setContent().

◆ preeditCursor

int QTextControlPrivate::preeditCursor

Definition at line 209 of file qtextcontrol_p_p.h.

◆ selectedBlockOnTrippleClick

QTextCursor QTextControlPrivate::selectedBlockOnTrippleClick

Definition at line 204 of file qtextcontrol_p_p.h.

Referenced by extendBlockwiseSelection(), and setCursorPosition().

◆ selectedWordOnDoubleClick

QTextCursor QTextControlPrivate::selectedWordOnDoubleClick

Definition at line 203 of file qtextcontrol_p_p.h.

Referenced by extendWordwiseSelection(), and setCursorPosition().

◆ trippleClickPoint

QPointF QTextControlPrivate::trippleClickPoint

Definition at line 189 of file qtextcontrol_p_p.h.

◆ trippleClickTimer

QBasicTimer QTextControlPrivate::trippleClickTimer

Definition at line 188 of file qtextcontrol_p_p.h.

◆ wordSelectionEnabled

bool QTextControlPrivate::wordSelectionEnabled

Definition at line 228 of file qtextcontrol_p_p.h.

Referenced by extendWordwiseSelection().

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

/src/gui/text/qtextcontrol_p_p.h
/src/gui/text/qtextcontrol.cpp

Public Functions

Public Variables

Additional Inherited Members

Detailed Description

Constructors and Destructors

◆ QTextControlPrivate()

Functions

◆ _q_copyLink()

◆ _q_deleteSelected()

◆ _q_documentLayoutChanged()

◆ _q_emitCursorPosChanged()

◆ _q_setCursorAfterUndoRedo()

◆ _q_updateBlock()

◆ _q_updateCurrentCharFormatAndSelection()

◆ activateLinkUnderCursor()

◆ anchorForCursor()

◆ append()

◆ contextMenuEvent()

◆ createAutoBulletList()

◆ cursorMoveKeyEvent()

◆ cursorRectPlusUnicodeDirectionMarkers()

◆ dragEnterEvent()

◆ dragLeaveEvent()

◆ dragMoveEvent()

◆ dropEvent()

◆ extendBlockwiseSelection()

◆ extendWordwiseSelection()

◆ focusEvent()

◆ gotoNextTableCell()

◆ gotoPreviousTableCell()

◆ indent()

◆ init()

◆ inputContext()

◆ inputMethodEvent()

◆ keyPressEvent()

◆ mouseDoubleClickEvent()

◆ mouseMoveEvent()

◆ mousePressEvent()

◆ mouseReleaseEvent()

◆ outdent()

◆ paste()

◆ rectForPosition()

◆ repaintCursor()

◆ repaintOldAndNewSelection()

◆ repaintSelection()

◆ selectionChanged()

◆ selectionRect() [1/2]

◆ selectionRect() [2/2]

◆ sendMouseEventToInputContext()

◆ setBlinkingCursorEnabled()

◆ setClipboardSelection()

◆ setContent()

◆ setCursorPosition() [1/2]

◆ setCursorPosition() [2/2]

◆ showToolTip()

◆ startDrag()

◆ updateCurrentCharFormat()

Properties

◆ acceptRichText

◆ anchorOnMousePress

◆ contextWidget

◆ cursor

◆ cursorBlinkTimer

◆ cursorIsFocusIndicator

◆ cursorOn

◆ dndFeedbackCursor

◆ doc

◆ dragEnabled

◆ dragStartPos

◆ extraSelections

◆ hadSelectionOnMousePress

◆ hasFocus

◆ hideCursor

◆ highlightedAnchor

◆ ignoreAutomaticScrollbarAdjustement

◆ ignoreUnusedNavigationEvents

◆ interactionFlags

◆ isEnabled

◆ lastCharFormat

◆ lastSelectionState