QTextDocumentPrivate Class Reference

#include <qtextdocument_p.h>

Inheritance diagram for QTextDocumentPrivate:

Public Types
typedef QFragmentMap< QTextBlockData >	BlockMap
enum	FormatChangeMode { MergeFormat, SetFormat, SetFormatAndPreserveObjectIndices }
typedef FragmentMap::ConstIterator	FragmentIterator
typedef QFragmentMap< QTextFragmentData >	FragmentMap
Public Types inherited from QObjectPrivate
typedef void(*	StaticMetaCallFunction) (QObject *, QMetaObject::Call, int, void **)

Public Functions
void	aboutToRemoveCell (int cursorFrom, int cursorEnd)
	This method is called from QTextTable when it is about to remove a table-cell to allow cursors to update their selection. More...
void	addCursor (QTextCursorPrivate *c)
void	appendUndoItem (QAbstractUndoItem *)
	Appends a custom undo item to the undo stack. More...
int	availableRedoSteps () const
int	availableUndoSteps () const
FragmentIterator	begin () const
void	beginEditBlock ()
int	blockCharFormatIndex (int node) const
const BlockMap &	blockMap () const
BlockMap &	blockMap ()
QTextBlock	blocksBegin () const
QTextBlock	blocksEnd () const
QTextBlock	blocksFind (int pos) const
QString	buffer () const
void	changeObjectFormat (QTextObject *group, int format)
void	clear ()
void	clearUndoRedoStacks (QTextDocument::Stacks stacksToClear, bool emitSignals=false)
QTextObject *	createObject (const QTextFormat &newFormat, int objectIndex=-1)
QFont	defaultFont () const
void	deleteObject (QTextObject *object)
QTextDocument *	document ()
const QTextDocument *	document () const
void	documentChange (int from, int length)
void	emitRedoAvailable (bool available)
void	emitUndoAvailable (bool available)
void	enableUndoRedo (bool enable)
FragmentIterator	end () const
void	endEditBlock ()
bool	ensureMaximumBlockCount ()
FragmentIterator	find (int pos) const
void	finishEdit ()
QTextFormatCollection *	formatCollection ()
const QTextFormatCollection *	formatCollection () const
const FragmentMap &	fragmentMap () const
FragmentMap &	fragmentMap ()
QTextFrame *	frameAt (int pos) const
void	init ()
void	insert (int pos, const QString &text, int format)
void	insert (int pos, int strPos, int strLength, int format)
int	insertBlock (int pos, int blockFormat, int charFormat, QTextUndoCommand::Operation=QTextUndoCommand::MoveCursor)
int	insertBlock (const QChar &blockSeparator, int pos, int blockFormat, int charFormat, QTextUndoCommand::Operation op=QTextUndoCommand::MoveCursor)
QTextFrame *	insertFrame (int start, int end, const QTextFrameFormat &format)
bool	isInEditBlock () const
bool	isModified () const
bool	isRedoAvailable () const
bool	isUndoAvailable () const
bool	isUndoRedoEnabled () const
void	joinPreviousEditBlock ()
QAbstractTextDocumentLayout *	layout () const
int	leftCursorPosition (int position) const
int	length () const
void	mergeCachedResources (const QTextDocumentPrivate *priv)
void	move (int from, int to, int length, QTextUndoCommand::Operation=QTextUndoCommand::MoveCursor)
int	nextCursorPosition (int position, QTextLayout::CursorMode mode) const
int	numBlocks () const
QTextObject *	objectForFormat (int formatIndex) const
QTextObject *	objectForFormat (const QTextFormat &f) const
QTextObject *	objectForIndex (int objectIndex) const
QString	plainText () const
int	previousCursorPosition (int position, QTextLayout::CursorMode mode) const
	QTextDocumentPrivate ()
void	redo ()
void	remove (int pos, int length, QTextUndoCommand::Operation=QTextUndoCommand::MoveCursor)
void	removeCursor (QTextCursorPrivate *c)
void	removeFrame (QTextFrame *frame)
int	rightCursorPosition (int position) const
QTextFrame *	rootFrame () const
void	setBlockFormat (const QTextBlock &from, const QTextBlock &to, const QTextBlockFormat &newFormat, FormatChangeMode mode=SetFormat)
void	setCharFormat (int pos, int length, const QTextCharFormat &newFormat, FormatChangeMode mode=SetFormat)
void	setDefaultFont (const QFont &f)
void	setLayout (QAbstractTextDocumentLayout *layout)
void	setModified (bool m)
void	undo ()
int	undoRedo (bool undo)
	~QTextDocumentPrivate ()
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

Static Public Functions
static const QTextBlockData *	block (const QTextBlock &it)
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)

Public Variables
uint	blockCursorAdjustment: 1
Qt::CursorMoveStyle	defaultCursorMoveStyle
QTextOption	defaultTextOption
qreal	documentMargin
uint	inContentsChange: 1
qreal	indentWidth
int	maximumBlockCount
uint	needsEnsureMaximumBlockCount: 1
QSizeF	pageSize
QCss::StyleSheet	parsedDefaultStyleSheet
QString	title
QString	url
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

Private Functions
void	adjustDocumentChangesAndCursors (int from, int addedOrRemoved, QTextUndoCommand::Operation op)
void	appendUndoItem (const QTextUndoCommand &c)
void	compressPieceTable ()
void	contentsChanged ()
int	insert_block (int pos, uint strPos, int format, int blockformat, QTextUndoCommand::Operation op, int command)
void	insert_frame (QTextFrame *f)
void	insert_string (int pos, uint strPos, uint length, int format, QTextUndoCommand::Operation op)
QTextDocumentPrivate &	operator= (const QTextDocumentPrivate &m)
	QTextDocumentPrivate (const QTextDocumentPrivate &m)
int	remove_block (int pos, int *blockformat, int command, QTextUndoCommand::Operation op)
int	remove_string (int pos, uint length, QTextUndoCommand::Operation op)
void	scan_frames (int pos, int charsRemoved, int charsAdded)
bool	split (int pos)
bool	unite (uint f)

Static Private Functions
static void	clearFrame (QTextFrame *f)

Properties
BlockMap	blocks
QMap< QUrl, QVariant >	cachedResources
QList< QTextCursorPrivate * >	cursors
QString	defaultStyleSheet
int	docChangeFrom
int	docChangeLength
int	docChangeOldLength
int	editBlock
int	editBlockCursorPosition
QTextFormatCollection	formats
FragmentMap	fragments
bool	framesDirty
int	initialBlockCharFormatIndex
int	lastBlockCount
QAbstractTextDocumentLayout *	lout
bool	modified
int	modifiedState
QMap< int, QTextObject * >	objects
QMap< QUrl, QVariant >	resources
int	revision
QTextFrame *	rtFrame
QString	text
bool	undoEnabled
QVector< QTextUndoCommand >	undoStack
int	undoState
uint	unreachableCharacterCount
bool	wasRedoAvailable
bool	wasUndoAvailable

Friends
class	QTextCursor
class	QTextHtmlExporter

Detailed Description

Definition at line 163 of file qtextdocument_p.h.

Typedefs

BlockMap

typedef QFragmentMap<QTextBlockData> QTextDocumentPrivate::BlockMap

Definition at line 169 of file qtextdocument_p.h.

FragmentIterator

typedef FragmentMap::ConstIterator QTextDocumentPrivate::FragmentIterator

Definition at line 168 of file qtextdocument_p.h.

FragmentMap

typedef QFragmentMap<QTextFragmentData> QTextDocumentPrivate::FragmentMap

Definition at line 167 of file qtextdocument_p.h.

Enumerations

FormatChangeMode

enum QTextDocumentPrivate::FormatChangeMode

Enumerator
MergeFormat
SetFormat
SetFormatAndPreserveObjectIndices

Definition at line 193 of file qtextdocument_p.h.

{ MergeFormat, SetFormat, SetFormatAndPreserveObjectIndices };

Constructors and Destructors

QTextDocumentPrivate() [1/2]

QTextDocumentPrivate::QTextDocumentPrivate

(

)

Definition at line 185 of file qtextdocument_p.cpp.

    : wasUndoAvailable(false),
    wasRedoAvailable(false),
    docChangeOldLength(0),
    docChangeLength(0),
    framesDirty(true),
    rtFrame(0),
    initialBlockCharFormatIndex(-1) // set correctly later in init()
{
    editBlock = 0;
    editBlockCursorPosition = -1;
    docChangeFrom = -1;

    undoState = 0;
    revision = -1; // init() inserts a block, bringing it to 0

    lout = 0;

    modified = false;
    modifiedState = 0;

    undoEnabled = true;
    inContentsChange = false;
    blockCursorAdjustment = false;

    defaultTextOption.setTabStop(80); // same as in qtextengine.cpp
    defaultTextOption.setWrapMode(QTextOption::WrapAtWordBoundaryOrAnywhere);
    defaultCursorMoveStyle = Qt::LogicalMoveStyle;

    indentWidth = 40;
    documentMargin = 4;

    maximumBlockCount = 0;
    needsEnsureMaximumBlockCount = false;
    unreachableCharacterCount = 0;
    lastBlockCount = 0;
}

~QTextDocumentPrivate()

QTextDocumentPrivate::~QTextDocumentPrivate

(

)

Definition at line 290 of file qtextdocument_p.cpp.

{
    foreach (QTextCursorPrivate *curs, cursors)
        curs->priv = 0;
    cursors.clear();
    undoState = 0;
    undoEnabled = true;
    clearUndoRedoStacks(QTextDocument::RedoStack);
}

QTextDocumentPrivate() [2/2]

QTextDocumentPrivate::QTextDocumentPrivate ( const QTextDocumentPrivate &  m )

private

Functions

aboutToRemoveCell()

void QTextDocumentPrivate::aboutToRemoveCell	(	int	cursorFrom,
		int	cursorEnd
	)

This method is called from QTextTable when it is about to remove a table-cell to allow cursors to update their selection.

Definition at line 1733 of file qtextdocument_p.cpp.

Referenced by QTextTable::removeColumns(), and QTextTable::removeRows().

{
    Q_ASSERT(from <= to);
    foreach (QTextCursorPrivate *curs, cursors)
        curs->aboutToRemoveCell(from, to);
}

addCursor()

void QTextDocumentPrivate::addCursor ( QTextCursorPrivate *  c )

inline

Definition at line 282 of file qtextdocument_p.h.

Referenced by QTextCursorPrivate::QTextCursorPrivate().

{ cursors.append(c); }

adjustDocumentChangesAndCursors()

void QTextDocumentPrivate::adjustDocumentChangesAndCursors ( int  from, int  addedOrRemoved, QTextUndoCommand::Operation  op  )

private

Definition at line 1281 of file qtextdocument_p.cpp.

Referenced by insert_block(), insert_string(), remove_block(), and remove_string().

{
    if (!editBlock)
        ++revision;

    if (blockCursorAdjustment)  {
        ; // postpone, will be called again from QTextDocumentPrivate::remove()
    } else {
        foreach (QTextCursorPrivate *curs, cursors) {
            if (curs->adjustPosition(from, addedOrRemoved, op) == QTextCursorPrivate::CursorMoved) {
                curs->changed = true;
            }
        }
    }

//     qDebug("QTextDocumentPrivate::adjustDocumentChanges: from=%d,addedOrRemoved=%d", from, addedOrRemoved);
    if (docChangeFrom < 0) {
        docChangeFrom = from;
        if (addedOrRemoved > 0) {
            docChangeOldLength = 0;
            docChangeLength = addedOrRemoved;
        } else {
            docChangeOldLength = -addedOrRemoved;
            docChangeLength = 0;
        }
//         qDebug("adjustDocumentChanges:");
//         qDebug("    -> %d %d %d", docChangeFrom, docChangeOldLength, docChangeLength);
        return;
    }

    // have to merge the new change with the already existing one.
    int added = qMax(0, addedOrRemoved);
    int removed = qMax(0, -addedOrRemoved);

    int diff = 0;
    if(from + removed < docChangeFrom)
        diff = docChangeFrom - from - removed;
    else if(from > docChangeFrom + docChangeLength)
        diff = from - (docChangeFrom + docChangeLength);

    int overlap_start = qMax(from, docChangeFrom);
    int overlap_end = qMin(from + removed, docChangeFrom + docChangeLength);
    int removedInside = qMax(0, overlap_end - overlap_start);
    removed -= removedInside;

//     qDebug("adjustDocumentChanges: from=%d, addedOrRemoved=%d, diff=%d, removedInside=%d", from, addedOrRemoved, diff, removedInside);
    docChangeFrom = qMin(docChangeFrom, from);
    docChangeOldLength += removed + diff;
    docChangeLength += added - removedInside + diff;
//     qDebug("    -> %d %d %d", docChangeFrom, docChangeOldLength, docChangeLength);

}

appendUndoItem() [1/2]

void QTextDocumentPrivate::appendUndoItem

(

QAbstractUndoItem *

item

)

Appends a custom undo item to the undo stack.

Definition at line 1037 of file qtextdocument_p.cpp.

Referenced by changeObjectFormat(), insert(), insertBlock(), move(), setBlockFormat(), and setCharFormat().

{
    if (!undoEnabled) {
        delete item;
        return;
    }

    QTextUndoCommand c;
    c.command = QTextUndoCommand::Custom;
    c.block_part = editBlock != 0;
    c.block_end = 0;
    c.operation = QTextUndoCommand::MoveCursor;
    c.format = 0;
    c.strPos = 0;
    c.pos = 0;
    c.blockFormat = 0;

    c.custom = item;
    appendUndoItem(c);
}

appendUndoItem() [2/2]

void QTextDocumentPrivate::appendUndoItem ( const QTextUndoCommand &  c )

private

Definition at line 1058 of file qtextdocument_p.cpp.

{
    PMDEBUG("appendUndoItem, command=%d enabled=%d", c.command, undoEnabled);
    if (!undoEnabled)
        return;
    if (undoState < undoStack.size())
        clearUndoRedoStacks(QTextDocument::RedoStack);

    if (editBlock != 0 && editBlockCursorPosition >= 0) { // we had a beginEditBlock() with a cursor position
        if (c.pos != (quint32) editBlockCursorPosition) { // and that cursor position is different from the command
            // generate a CursorMoved undo item
            QT_INIT_TEXTUNDOCOMMAND(cc, QTextUndoCommand::CursorMoved, true, QTextUndoCommand::MoveCursor,
                                    0, 0, editBlockCursorPosition, 0, 0);
            undoStack.append(cc);
            undoState++;
            editBlockCursorPosition = -1;
        }
    }


    if (!undoStack.isEmpty() && modified) {
        QTextUndoCommand &last = undoStack[undoState - 1];

        if ( (last.block_part && c.block_part && !last.block_end) // part of the same block => can merge
            || (!c.block_part && !last.block_part)) {  // two single undo items => can merge

            if (last.tryMerge(c))
                return;
        }
    }
    if (modifiedState > undoState)
        modifiedState = -1;
    undoStack.append(c);
    undoState++;
    emitUndoAvailable(true);
    emitRedoAvailable(false);

    if (!c.block_part)
        emit document()->undoCommandAdded();
}

availableRedoSteps()

int QTextDocumentPrivate::availableRedoSteps ( ) const

inline

Definition at line 218 of file qtextdocument_p.h.

{ return undoEnabled ? qMax(undoStack.size() - undoState - 1, 0) : 0; }

availableUndoSteps()

int QTextDocumentPrivate::availableUndoSteps ( ) const

inline

Definition at line 217 of file qtextdocument_p.h.

{ return undoEnabled ? undoState : 0; }

begin()

FragmentIterator QTextDocumentPrivate::begin ( ) const

inline

Definition at line 229 of file qtextdocument_p.h.

Referenced by plainText(), scan_frames(), and QTextOdfWriter::writeAll().

{ return fragments.begin(); }

beginEditBlock()

void QTextDocumentPrivate::beginEditBlock ( )

inline

Definition at line 206 of file qtextdocument_p.h.

Referenced by QTextCursor::beginEditBlock(), changeObjectFormat(), QTextCursorPrivate::clearCells(), QTextTablePrivate::createTable(), ensureMaximumBlockCount(), QTextDocumentFragmentPrivate::insert(), insertBlock(), QTextCursor::insertBlock(), QTextTable::insertColumns(), QTextCursor::insertFragment(), insertFrame(), QTextCursor::insertImage(), QTextTable::insertRows(), QTextCursor::insertText(), joinPreviousEditBlock(), QTextTable::mergeCells(), QTextDocumentFragmentPrivate::QTextDocumentFragmentPrivate(), QTextCursorPrivate::remove(), QTextTable::removeColumns(), removeFrame(), QTextTable::removeRows(), QTextCursor::removeSelectedText(), QTextCursorPrivate::setBlockCharFormat(), QTextCursorPrivate::setBlockFormat(), setBlockFormat(), QTextCursorPrivate::setCharFormat(), setCharFormat(), QTextTable::splitCell(), and undoRedo().

{ if (0 == editBlock++) ++revision; }

block()

static const QTextBlockData* QTextDocumentPrivate::block ( const QTextBlock &  it )

inlinestatic

Definition at line 244 of file qtextdocument_p.h.

Referenced by setBlockFormat(), setCharFormat(), and undoRedo().

{ return it.p->blocks.fragment(it.n); }

blockCharFormatIndex()

int QTextDocumentPrivate::blockCharFormatIndex

(

int

node

)

const

Definition at line 1351 of file qtextdocument_p.cpp.

Referenced by QTextCursor::charFormat().

{
    int pos = blocks.position(node);
    if (pos == 0)
        return initialBlockCharFormatIndex;

    return fragments.find(pos - 1)->format;
}

blockMap() [1/2]

const BlockMap& QTextDocumentPrivate::blockMap ( ) const

inline

Definition at line 239 of file qtextdocument_p.h.

Referenced by QTextTableCell::begin(), QTextFrame::begin(), QTextCursorPrivate::block(), QTextCursor::charFormat(), QTextTableCell::end(), QTextFrame::end(), QTextDocumentLayoutPrivate::frameIteratorForTextPosition(), QTextFrame::iterator::operator++(), QTextFrame::iterator::operator--(), QTextTable::splitCell(), and QTextOdfWriter::writeAll().

{ return blocks; }

blockMap() [2/2]

BlockMap& QTextDocumentPrivate::blockMap ( )

inline

Definition at line 241 of file qtextdocument_p.h.

{ return blocks; }

blocksBegin()

QTextBlock QTextDocumentPrivate::blocksBegin ( ) const

inline

Definition at line 232 of file qtextdocument_p.h.

Referenced by QTextCopyHelper::appendFragment(), and QTextCursorPrivate::movePosition().

{ return QTextBlock(const_cast<QTextDocumentPrivate *>(this), blocks.firstNode()); }

blocksEnd()

QTextBlock QTextDocumentPrivate::blocksEnd ( ) const

inline

Definition at line 233 of file qtextdocument_p.h.

Referenced by QTextCursorPrivate::movePosition().

{ return QTextBlock(const_cast<QTextDocumentPrivate *>(this), 0); }

blocksFind()

QTextBlock QTextDocumentPrivate::blocksFind ( int  pos ) const

inline

Definition at line 234 of file qtextdocument_p.h.

Referenced by QTextCopyHelper::appendFragment(), QTextCopyHelper::copy(), leftCursorPosition(), QTextCursorPrivate::movePosition(), nextCursorPosition(), previousCursorPosition(), rightCursorPosition(), setBlockCharFormatHelper(), QTextCursorPrivate::setBlockFormat(), setCharFormat(), and undoRedo().

{ return QTextBlock(const_cast<QTextDocumentPrivate *>(this), blocks.findNode(pos)); }

buffer()

QString QTextDocumentPrivate::buffer ( ) const

inline

Definition at line 220 of file qtextdocument_p.h.

Referenced by QTextCursor::deletePreviousChar(), QTextHtmlExporter::emitBlock(), QTextFrame::iterator::operator++(), QTextFrame::iterator::operator--(), and QTextCursor::selectedText().

{ return text; }

changeObjectFormat()

void QTextDocumentPrivate::changeObjectFormat	(	QTextObject *	group,
		int	format
	)

Definition at line 1401 of file qtextdocument_p.cpp.

Referenced by undoRedo().

{
    beginEditBlock();
    int objectIndex = obj->objectIndex();
    int oldFormatIndex = formats.objectFormatIndex(objectIndex);
    formats.setObjectFormatIndex(objectIndex, format);

    QTextBlockGroup *b = qobject_cast<QTextBlockGroup *>(obj);
    if (b) {
        b->d_func()->markBlocksDirty();
    }
    QTextFrame *f = qobject_cast<QTextFrame *>(obj);
    if (f)
        documentChange(f->firstPosition(), f->lastPosition() - f->firstPosition());

    QT_INIT_TEXTUNDOCOMMAND(c, QTextUndoCommand::GroupFormatChange, (editBlock != 0), QTextUndoCommand::MoveCursor, oldFormatIndex,
                            0, 0, obj->d_func()->objectIndex, 0);
    appendUndoItem(c);

    endEditBlock();
}

clear()

void QTextDocumentPrivate::clear

(

)

Definition at line 236 of file qtextdocument_p.cpp.

{
    Q_Q(QTextDocument);

    foreach (QTextCursorPrivate *curs, cursors) {
        curs->setPosition(0);
        curs->currentCharFormat = -1;
        curs->anchor = 0;
        curs->adjusted_anchor = 0;
    }

    QList<QTextCursorPrivate *>oldCursors = cursors;
    QT_TRY{
        cursors.clear();

        QMap<int, QTextObject *>::Iterator objectIt = objects.begin();
        while (objectIt != objects.end()) {
            if (*objectIt != rtFrame) {
                delete *objectIt;
                objectIt = objects.erase(objectIt);
            } else {
                ++objectIt;
            }
        }
        // also clear out the remaining root frame pointer
        // (we're going to delete the object further down)
        objects.clear();

        title.clear();
        clearUndoRedoStacks(QTextDocument::UndoAndRedoStacks);
        text = QString();
        unreachableCharacterCount = 0;
        modifiedState = 0;
        modified = false;
        formats = QTextFormatCollection();
        int len = fragments.length();
        fragments.clear();
        blocks.clear();
        cachedResources.clear();
        delete rtFrame;
        rtFrame = 0;
        init();
        cursors = oldCursors;
        inContentsChange = true;
        q->contentsChange(0, len, 0);
        inContentsChange = false;
        if (lout)
            lout->documentChanged(0, len, 0);
    } QT_CATCH(...) {
        cursors = oldCursors; // at least recover the cursors
        QT_RETHROW;
    }
}

clearFrame()

void QTextDocumentPrivate::clearFrame ( QTextFrame *  f )

staticprivate

Definition at line 1464 of file qtextdocument_p.cpp.

Referenced by scan_frames().

{
    for (int i = 0; i < f->d_func()->childFrames.count(); ++i)
        clearFrame(f->d_func()->childFrames.at(i));
    f->d_func()->childFrames.clear();
    f->d_func()->parentFrame = 0;
}

clearUndoRedoStacks()

void QTextDocumentPrivate::clearUndoRedoStacks	(	QTextDocument::Stacks	stacksToClear,
		bool	emitSignals = false
	)

Definition at line 1099 of file qtextdocument_p.cpp.

Referenced by appendUndoItem(), clear(), enableUndoRedo(), and ~QTextDocumentPrivate().

{
    bool undoCommandsAvailable = undoState != 0;
    bool redoCommandsAvailable = undoState != undoStack.size();
    if (stacksToClear == QTextDocument::UndoStack && undoCommandsAvailable) {
        for (int i = 0; i < undoState; ++i) {
            QTextUndoCommand c = undoStack[undoState];
            if (c.command & QTextUndoCommand::Custom)
                delete c.custom;
        }
        undoStack.remove(0, undoState);
        undoStack.resize(undoStack.size() - undoState);
        undoState = 0;
        if (emitSignals)
            emitUndoAvailable(false);
    } else if (stacksToClear == QTextDocument::RedoStack
               && redoCommandsAvailable) {
        for (int i = undoState; i < undoStack.size(); ++i) {
            QTextUndoCommand c = undoStack[i];
            if (c.command & QTextUndoCommand::Custom)
                delete c.custom;
        }
        undoStack.resize(undoState);
        if (emitSignals)
            emitRedoAvailable(false);
    } else if (stacksToClear == QTextDocument::UndoAndRedoStacks
               && !undoStack.isEmpty()) {
        for (int i = 0; i < undoStack.size(); ++i) {
            QTextUndoCommand c = undoStack[i];
            if (c.command & QTextUndoCommand::Custom)
                delete c.custom;
        }
        undoState = 0;
        undoStack.resize(0);
        if (emitSignals && undoCommandsAvailable)
            emitUndoAvailable(false);
        if (emitSignals && redoCommandsAvailable)
            emitRedoAvailable(false);
    }
}

compressPieceTable()

void QTextDocumentPrivate::compressPieceTable ( )

private

Definition at line 1657 of file qtextdocument_p.cpp.

Referenced by enableUndoRedo(), ensureMaximumBlockCount(), and finishEdit().

{
    if (undoEnabled)
        return;

    const uint garbageCollectionThreshold = 96 * 1024; // bytes

    //qDebug() << "unreachable bytes:" << unreachableCharacterCount * sizeof(QChar) << " -- limit" << garbageCollectionThreshold << "text size =" << text.size() << "capacity:" << text.capacity();

    bool compressTable = unreachableCharacterCount * sizeof(QChar) > garbageCollectionThreshold
                         && text.size() >= text.capacity() * 0.9;
    if (!compressTable)
        return;

    QString newText;
    newText.resize(text.size());
    QChar *newTextPtr = newText.data();
    int newLen = 0;

    for (FragmentMap::Iterator it = fragments.begin(); !it.atEnd(); ++it) {
        memcpy(newTextPtr, text.constData() + it->stringPosition, it->size_array[0] * sizeof(QChar));
        it->stringPosition = newLen;
        newTextPtr += it->size_array[0];
        newLen += it->size_array[0];
    }

    newText.resize(newLen);
    newText.squeeze();
    //qDebug() << "removed" << text.size() - newText.size() << "characters";
    text = newText;
    unreachableCharacterCount = 0;
}

contentsChanged()

void QTextDocumentPrivate::contentsChanged ( )

private

Definition at line 1642 of file qtextdocument_p.cpp.

Referenced by finishEdit().

{
    Q_Q(QTextDocument);
    if (editBlock)
        return;

    bool m = undoEnabled ? (modifiedState != undoState) : true;
    if (modified != m) {
        modified = m;
        emit q->modificationChanged(modified);
    }

    emit q->contentsChanged();
}

createObject()

QTextObject * QTextDocumentPrivate::createObject	(	const QTextFormat &	newFormat,
		int	objectIndex = -1
	)

Definition at line 1623 of file qtextdocument_p.cpp.

Referenced by QTextCursor::createList(), QTextTablePrivate::createTable(), insertFrame(), QTextCursor::insertImage(), objectForIndex(), and rootFrame().

{
    QTextObject *obj = document()->createObject(f);

    if (obj) {
        obj->d_func()->objectIndex = objectIndex == -1 ? formats.createObjectIndex(f) : objectIndex;
        objects[obj->d_func()->objectIndex] = obj;
    }

    return obj;
}

defaultFont()

QFont QTextDocumentPrivate::defaultFont ( ) const

inline

Definition at line 256 of file qtextdocument_p.h.

{ return formats.defaultFont(); }

deleteObject()

void QTextDocumentPrivate::deleteObject

(

QTextObject *

object

)

Definition at line 1635 of file qtextdocument_p.cpp.

Referenced by QTextBlockGroup::blockRemoved().

{
    const int objIdx = object->d_func()->objectIndex;
    objects.remove(objIdx);
    delete object;
}

document() [1/2]

QTextDocument* QTextDocumentPrivate::document ( )

inline

Definition at line 295 of file qtextdocument_p.h.

Referenced by appendUndoItem(), createObject(), QTextCursor::document(), endEditBlock(), QTextCursor::insertHtml(), and QTextCursor::insertImage().

{ return q_func(); }

document() [2/2]

const QTextDocument* QTextDocumentPrivate::document ( ) const

inline

Definition at line 296 of file qtextdocument_p.h.

{ return q_func(); }

documentChange()

void QTextDocumentPrivate::documentChange	(	int	from,
		int	length
	)

Definition at line 1257 of file qtextdocument_p.cpp.

Referenced by changeObjectFormat(), setBlockFormat(), setCharFormat(), and undoRedo().

{
//     qDebug("QTextDocumentPrivate::documentChange: from=%d,length=%d", from, length);
    if (docChangeFrom < 0) {
        docChangeFrom = from;
        docChangeOldLength = length;
        docChangeLength = length;
        return;
    }
    int start = qMin(from, docChangeFrom);
    int end = qMax(from + length, docChangeFrom + docChangeLength);
    int diff = qMax(0, end - start - docChangeLength);
    docChangeFrom = start;
    docChangeOldLength += diff;
    docChangeLength += diff;
}

emitRedoAvailable()

void QTextDocumentPrivate::emitRedoAvailable

(

bool

available

)

Definition at line 1150 of file qtextdocument_p.cpp.

Referenced by appendUndoItem(), clearUndoRedoStacks(), enableUndoRedo(), and undoRedo().

{
    if (available != wasRedoAvailable) {
        Q_Q(QTextDocument);
        emit q->redoAvailable(available);
        wasRedoAvailable = available;
    }
}

emitUndoAvailable()

void QTextDocumentPrivate::emitUndoAvailable

(

bool

available

)

Definition at line 1141 of file qtextdocument_p.cpp.

Referenced by appendUndoItem(), clearUndoRedoStacks(), enableUndoRedo(), and undoRedo().

{
    if (available != wasUndoAvailable) {
        Q_Q(QTextDocument);
        emit q->undoAvailable(available);
        wasUndoAvailable = available;
    }
}

enableUndoRedo()

void QTextDocumentPrivate::enableUndoRedo

(

bool

enable

)

Definition at line 1159 of file qtextdocument_p.cpp.

{
    if (enable && maximumBlockCount > 0)
        return;

    if (!enable) {
        undoState = 0;
        clearUndoRedoStacks(QTextDocument::RedoStack);
        emitUndoAvailable(false);
        emitRedoAvailable(false);
    }
    modifiedState = modified ? -1 : undoState;
    undoEnabled = enable;
    if (!undoEnabled)
        compressPieceTable();
}

end()

FragmentIterator QTextDocumentPrivate::end ( ) const

inline

Definition at line 230 of file qtextdocument_p.h.

Referenced by documentChange(), insert_frame(), move(), nextCursorPosition(), plainText(), removeFrame(), scan_frames(), setBlockFormat(), and QTextOdfWriter::writeAll().

{ return fragments.end(); }

endEditBlock()

void QTextDocumentPrivate::endEditBlock

(

)

Definition at line 1184 of file qtextdocument_p.cpp.

Referenced by changeObjectFormat(), QTextCursorPrivate::clearCells(), QTextTablePrivate::createTable(), QTextCursor::endEditBlock(), ensureMaximumBlockCount(), QTextDocumentFragmentPrivate::insert(), insertBlock(), QTextCursor::insertBlock(), QTextTable::insertColumns(), QTextCursor::insertFragment(), insertFrame(), QTextCursor::insertImage(), QTextTable::insertRows(), QTextCursor::insertText(), QTextTable::mergeCells(), QTextDocumentFragmentPrivate::QTextDocumentFragmentPrivate(), QTextCursorPrivate::remove(), QTextTable::removeColumns(), removeFrame(), QTextTable::removeRows(), QTextCursor::removeSelectedText(), QTextCursorPrivate::setBlockCharFormat(), QTextCursorPrivate::setBlockFormat(), setBlockFormat(), QTextCursorPrivate::setCharFormat(), setCharFormat(), QTextTable::splitCell(), and undoRedo().

{
    Q_ASSERT(editBlock > 0);
    if (--editBlock)
        return;

    if (undoEnabled && undoState > 0) {
        const bool wasBlocking = !undoStack[undoState - 1].block_end;
        if (undoStack[undoState - 1].block_part) {
            undoStack[undoState - 1].block_end = true;
            if (wasBlocking)
                emit document()->undoCommandAdded();
        }
    }

    editBlockCursorPosition = -1;

    finishEdit();
}

ensureMaximumBlockCount()

bool QTextDocumentPrivate::ensureMaximumBlockCount

(

)

Definition at line 1705 of file qtextdocument_p.cpp.

Referenced by finishEdit().

{
    if (maximumBlockCount <= 0)
        return false;
    if (blocks.numNodes() <= maximumBlockCount)
        return false;

    beginEditBlock();

    const int blocksToRemove = blocks.numNodes() - maximumBlockCount;
    QTextCursor cursor(this, 0);
    cursor.movePosition(QTextCursor::NextBlock, QTextCursor::KeepAnchor, blocksToRemove);

    unreachableCharacterCount += cursor.selectionEnd() - cursor.selectionStart();

    // preserve the char format of the paragraph that is to become the new first one
    QTextCharFormat charFmt = cursor.blockCharFormat();
    cursor.removeSelectedText();
    cursor.setBlockCharFormat(charFmt);

    endEditBlock();

    compressPieceTable();

    return true;
}

find()

FragmentIterator QTextDocumentPrivate::find ( int  pos ) const

inline

Definition at line 228 of file qtextdocument_p.h.

Referenced by QAbstractTextDocumentLayout::anchorAt(), QPlainTextEdit::anchorAt(), QTextCopyHelper::appendFragment(), QTextCursorPrivate::canDelete(), QTextCursor::charFormat(), QTextCursor::deletePreviousChar(), QTextHtmlExporter::emitBlock(), QAbstractTextDocumentLayout::format(), QAbstractTextDocumentLayout::formatIndex(), QTextEngine::formatIndex(), getText(), insertFrame(), move(), QTextFrame::iterator::operator++(), QTextFrame::iterator::operator--(), and undoRedo().

{ return fragments.find(pos); }

finishEdit()

void QTextDocumentPrivate::finishEdit

(

)

Definition at line 1204 of file qtextdocument_p.cpp.

Referenced by endEditBlock(), insert(), move(), QTextCursorPrivate::remove(), and remove().

{
    Q_Q(QTextDocument);

    if (editBlock)
        return;

    if (framesDirty)
        scan_frames(docChangeFrom, docChangeOldLength, docChangeLength);

    if (lout && docChangeFrom >= 0) {
        if (!inContentsChange) {
            inContentsChange = true;
            emit q->contentsChange(docChangeFrom, docChangeOldLength, docChangeLength);
            inContentsChange = false;
        }
        lout->documentChanged(docChangeFrom, docChangeOldLength, docChangeLength);
    }

    docChangeFrom = -1;

    if (needsEnsureMaximumBlockCount) {
        needsEnsureMaximumBlockCount = false;
        if (ensureMaximumBlockCount()) {
            // if ensureMaximumBlockCount() returns true
            // it will have called endEditBlock() and
            // compressPieceTable() itself, so we return here
            // to prevent getting two contentsChanged emits
            return;
        }
    }

    QList<QTextCursor> changedCursors;
    foreach (QTextCursorPrivate *curs, cursors) {
        if (curs->changed) {
            curs->changed = false;
            changedCursors.append(QTextCursor(curs));
        }
    }
    foreach (const QTextCursor &cursor, changedCursors)
        emit q->cursorPositionChanged(cursor);

    contentsChanged();

    if (blocks.numNodes() != lastBlockCount) {
        lastBlockCount = blocks.numNodes();
        emit q->blockCountChanged(lastBlockCount);
    }

    if (!undoEnabled && unreachableCharacterCount)
        compressPieceTable();
}

formatCollection() [1/2]

QTextFormatCollection* QTextDocumentPrivate::formatCollection ( )

inline

Definition at line 224 of file qtextdocument_p.h.

Referenced by QAbstractTextDocumentLayout::anchorAt(), QPlainTextEdit::anchorAt(), QTextCopyHelper::appendFragment(), QTextCursorPrivate::canDelete(), QTextCursor::charFormat(), QTextCopyHelper::convertFormat(), QTextCopyHelper::convertFormatIndex(), QTextCopyHelper::copy(), QTextTablePrivate::createTable(), QTextTableCell::format(), QAbstractTextDocumentLayout::format(), QTextCursorPrivate::insertBlock(), QTextTable::insertColumns(), QTextCursor::insertImage(), QTextTable::insertRows(), QTextCursor::insertText(), QTextTable::mergeCells(), QTextCursor::mergeCharFormat(), QTextTable::removeColumns(), QTextTable::removeRows(), QTextCursor::setCharFormat(), QTextTableCell::setFormat(), QTextTable::splitCell(), and QTextTablePrivate::update().

{ return &formats; }

formatCollection() [2/2]

const QTextFormatCollection* QTextDocumentPrivate::formatCollection ( ) const

inline

Definition at line 225 of file qtextdocument_p.h.

{ return &formats; }

fragmentMap() [1/2]

const FragmentMap& QTextDocumentPrivate::fragmentMap ( ) const

inline

Definition at line 240 of file qtextdocument_p.h.

Referenced by QTextTableCell::firstPosition(), QTextTable::insertColumns(), QTextTable::insertRows(), QTextTableCell::lastPosition(), QTextTable::mergeCells(), QTextTable::removeColumns(), QTextTable::removeRows(), QTextTable::rowEnd(), QTextTable::rowStart(), QTextTableCell::setFormat(), QTextTable::splitCell(), QTextTableCell::tableCellFormatIndex(), and QTextTablePrivate::update().

{ return fragments; }

fragmentMap() [2/2]

FragmentMap& QTextDocumentPrivate::fragmentMap ( )

inline

Definition at line 242 of file qtextdocument_p.h.

{ return fragments; }

frameAt()

QTextFrame * QTextDocumentPrivate::frameAt

(

int

pos

)

const

Definition at line 1452 of file qtextdocument_p.cpp.

Referenced by QTextCursorPrivate::aboutToRemoveCell(), QTextCursorPrivate::adjustCursor(), QTextCursorPrivate::complexSelectionTable(), QTextCursor::currentFrame(), QTextCursor::currentTable(), QTextDocumentLayoutPrivate::frameIteratorForTextPosition(), insert_frame(), insertFrame(), move(), QTextCursorPrivate::movePosition(), and QTextCursorPrivate::selectedTableCells().

{
    QTextFrame *f = rootFrame();

    while (1) {
        QTextFrame *c = findChildFrame(f, pos);
        if (!c)
            return f;
        f = c;
    }
}

init()

void QTextDocumentPrivate::init

(

)

Definition at line 223 of file qtextdocument_p.cpp.

Referenced by clear().

{
    framesDirty = false;

    bool undoState = undoEnabled;
    undoEnabled = false;
    initialBlockCharFormatIndex = formats.indexForFormat(QTextCharFormat());
    insertBlock(0, formats.indexForFormat(QTextBlockFormat()), formats.indexForFormat(QTextCharFormat()));
    undoEnabled = undoState;
    modified = false;
    modifiedState = 0;
}

insert() [1/2]

void QTextDocumentPrivate::insert	(	int	pos,
		const QString &	text,
		int	format
	)

Definition at line 476 of file qtextdocument_p.cpp.

Referenced by QTextCopyHelper::appendFragment(), QTextCursor::insertImage(), and QTextCursor::insertText().

{
    if (str.size() == 0)
        return;

    Q_ASSERT(noBlockInString(str));

    int strPos = text.length();
    text.append(str);
    insert(pos, strPos, str.length(), format);
}

insert() [2/2]

void QTextDocumentPrivate::insert	(	int	pos,
		int	strPos,
		int	strLength,
		int	format
	)

Definition at line 453 of file qtextdocument_p.cpp.

{
    if (strLength <= 0)
        return;

    Q_ASSERT(pos >= 0 && pos < fragments.length());
    Q_ASSERT(formats.format(format).isCharFormat());

    insert_string(pos, strPos, strLength, format, QTextUndoCommand::MoveCursor);
    if (undoEnabled) {
        int b = blocks.findNode(pos);
        QTextBlockData *B = blocks.fragment(b);

        QT_INIT_TEXTUNDOCOMMAND(c, QTextUndoCommand::Inserted, (editBlock != 0),
                                QTextUndoCommand::MoveCursor, format, strPos, pos, strLength,
                                B->revision);
        appendUndoItem(c);
        B->revision = revision;
        Q_ASSERT(undoState == undoStack.size());
    }
    finishEdit();
}

insert_block()

int QTextDocumentPrivate::insert_block ( int  pos, uint  strPos, int  format, int  blockformat, QTextUndoCommand::Operation  op, int  command  )

private

Definition at line 350 of file qtextdocument_p.cpp.

Referenced by insertBlock(), move(), and undoRedo().

{
    split(pos);
    uint x = fragments.insert_single(pos, 1);
    QTextFragmentData *X = fragments.fragment(x);
    X->format = format;
    X->stringPosition = strPos;
    // no need trying to unite, since paragraph separators are always in a fragment of their own

    Q_ASSERT(isValidBlockSeparator(text.at(strPos)));
    Q_ASSERT(blocks.length()+1 == fragments.length());

    int block_pos = pos;
    if (blocks.length() && command == QTextUndoCommand::BlockRemoved)
        ++block_pos;
    int size = 1;
    int n = blocks.findNode(block_pos);
    int key = n ? blocks.position(n) : blocks.length();

    Q_ASSERT(n || (!n && block_pos == blocks.length()));
    if (key != block_pos) {
        Q_ASSERT(key < block_pos);
        int oldSize = blocks.size(n);
        blocks.setSize(n, block_pos-key);
        size += oldSize - (block_pos-key);
    }
    int b = blocks.insert_single(block_pos, size);
    QTextBlockData *B = blocks.fragment(b);
    B->format = blockFormat;

    Q_ASSERT(blocks.length() == fragments.length());

    QTextBlockGroup *group = qobject_cast<QTextBlockGroup *>(objectForFormat(blockFormat));
    if (group)
        group->blockInserted(QTextBlock(this, b));

    QTextFrame *frame = qobject_cast<QTextFrame *>(objectForFormat(formats.format(format)));
    if (frame) {
        frame->d_func()->fragmentAdded(text.at(strPos), x);
        framesDirty = true;
    }

    adjustDocumentChangesAndCursors(pos, 1, op);
    return x;
}

insert_frame()

void QTextDocumentPrivate::insert_frame ( QTextFrame *  f )

private

Definition at line 1517 of file qtextdocument_p.cpp.

Referenced by insertFrame().

{
    int start = f->firstPosition();
    int end = f->lastPosition();
    QTextFrame *parent = frameAt(start-1);
    Q_ASSERT(parent == frameAt(end+1));

    if (start != end) {
        // iterator over the parent and move all children contained in my frame to myself
        for (int i = 0; i < parent->d_func()->childFrames.size(); ++i) {
            QTextFrame *c = parent->d_func()->childFrames.at(i);
            if (start < c->firstPosition() && end > c->lastPosition()) {
                parent->d_func()->childFrames.removeAt(i);
                f->d_func()->childFrames.append(c);
                c->d_func()->parentFrame = f;
            }
        }
    }
    // insert at the correct position
    int i = 0;
    for (; i < parent->d_func()->childFrames.size(); ++i) {
        QTextFrame *c = parent->d_func()->childFrames.at(i);
        if (c->firstPosition() > end)
            break;
    }
    parent->d_func()->childFrames.insert(i, f);
    f->d_func()->parentFrame = parent;
}

insert_string()

void QTextDocumentPrivate::insert_string ( int  pos, uint  strPos, uint  length, int  format, QTextUndoCommand::Operation  op  )

private

Definition at line 322 of file qtextdocument_p.cpp.

Referenced by insert(), move(), and undoRedo().

{
    // ##### optimize when only appending to the fragment!
    Q_ASSERT(noBlockInString(text.mid(strPos, length)));

    split(pos);
    uint x = fragments.insert_single(pos, length);
    QTextFragmentData *X = fragments.fragment(x);
    X->format = format;
    X->stringPosition = strPos;
    uint w = fragments.previous(x);
    if (w)
        unite(w);

    int b = blocks.findNode(pos);
    blocks.setSize(b, blocks.size(b)+length);

    Q_ASSERT(blocks.length() == fragments.length());

    QTextFrame *frame = qobject_cast<QTextFrame *>(objectForFormat(format));
    if (frame) {
        frame->d_func()->fragmentAdded(text.at(strPos), x);
        framesDirty = true;
    }

    adjustDocumentChangesAndCursors(pos, length, op);
}

insertBlock() [1/2]

int QTextDocumentPrivate::insertBlock	(	int	pos,
		int	blockFormat,
		int	charFormat,
		QTextUndoCommand::Operation	op = QTextUndoCommand::MoveCursor
	)

Definition at line 448 of file qtextdocument_p.cpp.

Referenced by QTextCopyHelper::appendFragment(), QTextCopyHelper::copy(), QTextTablePrivate::createTable(), init(), QTextCursorPrivate::insertBlock(), QTextTable::insertColumns(), insertFrame(), QTextTable::insertRows(), and QTextTable::splitCell().

{
    return insertBlock(QChar::ParagraphSeparator, pos, blockFormat, charFormat, op);
}

insertBlock() [2/2]

int QTextDocumentPrivate::insertBlock	(	const QChar &	blockSeparator,
		int	pos,
		int	blockFormat,
		int	charFormat,
		QTextUndoCommand::Operation	op = QTextUndoCommand::MoveCursor
	)

Definition at line 396 of file qtextdocument_p.cpp.

{
    Q_ASSERT(formats.format(blockFormat).isBlockFormat());
    Q_ASSERT(formats.format(charFormat).isCharFormat());
    Q_ASSERT(pos >= 0 && (pos < fragments.length() || (pos == 0 && fragments.length() == 0)));
    Q_ASSERT(isValidBlockSeparator(blockSeparator));

    beginEditBlock();

    int strPos = text.length();
    text.append(blockSeparator);

    int ob = blocks.findNode(pos);
    bool atBlockEnd = true;
    bool atBlockStart = true;
    int oldRevision = 0;
    if (ob) {
        atBlockEnd = (pos - blocks.position(ob) == blocks.size(ob)-1);
        atBlockStart = ((int)blocks.position(ob) == pos);
        oldRevision = blocks.fragment(ob)->revision;
    }

    const int fragment = insert_block(pos, strPos, charFormat, blockFormat, op, QTextUndoCommand::BlockRemoved);

    Q_ASSERT(blocks.length() == fragments.length());

    int b = blocks.findNode(pos);
    QTextBlockData *B = blocks.fragment(b);

    QT_INIT_TEXTUNDOCOMMAND(c, QTextUndoCommand::BlockInserted, (editBlock != 0),
                            op, charFormat, strPos, pos, blockFormat,
                            B->revision);

    appendUndoItem(c);
    Q_ASSERT(undoState == undoStack.size());

    // update revision numbers of the modified blocks.
    B->revision = (atBlockEnd && !atBlockStart)? oldRevision : revision;
    b = blocks.next(b);
    if (b) {
        B = blocks.fragment(b);
        B->revision = atBlockStart ? oldRevision : revision;
    }

    if (formats.charFormat(charFormat).objectIndex() == -1)
        needsEnsureMaximumBlockCount = true;

    endEditBlock();
    return fragment;
}

insertFrame()

QTextFrame * QTextDocumentPrivate::insertFrame	(	int	start,
		int	end,
		const QTextFrameFormat &	format
	)

Definition at line 1546 of file qtextdocument_p.cpp.

Referenced by QTextCursor::insertFrame().

{
    Q_ASSERT(start >= 0 && start < length());
    Q_ASSERT(end >= 0 && end < length());
    Q_ASSERT(start <= end || end == -1);

    if (start != end && frameAt(start) != frameAt(end))
        return 0;

    beginEditBlock();

    QTextFrame *frame = qobject_cast<QTextFrame *>(createObject(format));
    Q_ASSERT(frame);

    // #### using the default block and char format below might be wrong
    int idx = formats.indexForFormat(QTextBlockFormat());
    QTextCharFormat cfmt;
    cfmt.setObjectIndex(frame->objectIndex());
    int charIdx = formats.indexForFormat(cfmt);

    insertBlock(QTextBeginningOfFrame, start, idx, charIdx, QTextUndoCommand::MoveCursor);
    insertBlock(QTextEndOfFrame, ++end, idx, charIdx, QTextUndoCommand::KeepCursor);

    frame->d_func()->fragment_start = find(start).n;
    frame->d_func()->fragment_end = find(end).n;

    insert_frame(frame);

    endEditBlock();

    return frame;
}

isInEditBlock()

bool QTextDocumentPrivate::isInEditBlock ( ) const

inline

Definition at line 210 of file qtextdocument_p.h.

Referenced by QTextCursorPrivate::movePosition(), and QTextCursorPrivate::setX().

{ return editBlock; }

isModified()

bool QTextDocumentPrivate::isModified ( ) const

inline

Definition at line 254 of file qtextdocument_p.h.

Referenced by QTextDocument::isModified().

{ return modified; }

isRedoAvailable()

bool QTextDocumentPrivate::isRedoAvailable ( ) const

inline

Definition at line 215 of file qtextdocument_p.h.

Referenced by undoRedo().

{ return undoEnabled && undoState < undoStack.size(); }

isUndoAvailable()

bool QTextDocumentPrivate::isUndoAvailable ( ) const

inline

Definition at line 214 of file qtextdocument_p.h.

Referenced by undoRedo().

{ return undoEnabled && undoState > 0; }

isUndoRedoEnabled()

bool QTextDocumentPrivate::isUndoRedoEnabled ( ) const

inline

Definition at line 212 of file qtextdocument_p.h.

{ return undoEnabled; }

joinPreviousEditBlock()

void QTextDocumentPrivate::joinPreviousEditBlock

(

)

Definition at line 1176 of file qtextdocument_p.cpp.

Referenced by QTextCursor::joinPreviousEditBlock().

{
    beginEditBlock();

    if (undoEnabled && undoState)
        undoStack[undoState - 1].block_end = false;
}

layout()

QAbstractTextDocumentLayout* QTextDocumentPrivate::layout ( ) const

inline

Definition at line 226 of file qtextdocument_p.h.

Referenced by QTextCursorPrivate::blockLayout(), QTextEngine::calculateTabWidth(), QTextEngine::font(), QTextEngine::fontEngine(), QScriptLine::setDefaultHeight(), and setLayout().

{ return lout; }

leftCursorPosition()

int QTextDocumentPrivate::leftCursorPosition

(

int

position

)

const

Definition at line 1387 of file qtextdocument_p.cpp.

Referenced by QTextCursorPrivate::movePosition().

{
    QTextBlock it = blocksFind(position);
    int start = it.position();
    return it.layout()->leftCursorPosition(position-start) + start;
}

length()

int QTextDocumentPrivate::length ( ) const

inline

Definition at line 222 of file qtextdocument_p.h.

Referenced by QTextCursor::atEnd(), documentChange(), QTextHtmlExporter::emitBlock(), insert_string(), insertFrame(), QTextDocumentFragment::isEmpty(), QTextDocumentLayoutPrivate::layoutFlow(), QTextCursorPrivate::movePosition(), nextCursorPosition(), plainText(), QSyntaxHighlighterPrivate::reformatBlocks(), remove_string(), setCharFormat(), setLayout(), QTextCursor::setPosition(), QTextHtmlExporter::toHtml(), and undoRedo().

{ return fragments.length(); }

mergeCachedResources()

void QTextDocumentPrivate::mergeCachedResources

(

const QTextDocumentPrivate *

priv

)

Definition at line 2946 of file qtextdocument.cpp.

Referenced by QTextCursor::insertFragment(), and QTextDocumentFragmentPrivate::QTextDocumentFragmentPrivate().

{
    if (!priv)
        return;

    cachedResources.unite(priv->cachedResources);
}

move()

void QTextDocumentPrivate::move	(	int	from,
		int	to,
		int	length,
		QTextUndoCommand::Operation	op = QTextUndoCommand::MoveCursor
	)

Definition at line 578 of file qtextdocument_p.cpp.

Referenced by QTextTable::mergeCells(), and remove().

{
    Q_ASSERT(to <= fragments.length() && to <= pos);
    Q_ASSERT(pos >= 0 && pos+length <= fragments.length());
    Q_ASSERT(blocks.length() == fragments.length());

    if (pos == to)
        return;

    const bool needsInsert = to != -1;

#if !defined(QT_NO_DEBUG)
    const bool startAndEndInSameFrame = (frameAt(pos) == frameAt(pos + length - 1));

    const bool endIsEndOfChildFrame = (isAncestorFrame(frameAt(pos), frameAt(pos + length - 1))
                                       && text.at(find(pos + length - 1)->stringPosition) == QTextEndOfFrame);

    const bool startIsStartOfFrameAndEndIsEndOfFrameWithCommonParent
               = (text.at(find(pos)->stringPosition) == QTextBeginningOfFrame
                  && text.at(find(pos + length - 1)->stringPosition) == QTextEndOfFrame
                  && frameAt(pos)->parentFrame() == frameAt(pos + length - 1)->parentFrame());

    const bool isFirstTableCell = (qobject_cast<QTextTable *>(frameAt(pos + length - 1))
                                  && frameAt(pos + length - 1)->parentFrame() == frameAt(pos));

    Q_ASSERT(startAndEndInSameFrame || endIsEndOfChildFrame || startIsStartOfFrameAndEndIsEndOfFrameWithCommonParent || isFirstTableCell);
#endif

    split(pos);
    split(pos+length);

    uint dst = needsInsert ? fragments.findNode(to) : 0;
    uint dstKey = needsInsert ? fragments.position(dst) : 0;

    uint x = fragments.findNode(pos);
    uint end = fragments.findNode(pos+length);

    uint w = 0;
    while (x != end) {
        uint n = fragments.next(x);

        uint key = fragments.position(x);
        uint b = blocks.findNode(key+1);
        QTextBlockData *B = blocks.fragment(b);
        int blockRevision = B->revision;

        QTextFragmentData *X = fragments.fragment(x);
        QT_INIT_TEXTUNDOCOMMAND(c, QTextUndoCommand::Removed, (editBlock != 0),
                                op, X->format, X->stringPosition, key, X->size_array[0],
                                blockRevision);
        QT_INIT_TEXTUNDOCOMMAND(cInsert, QTextUndoCommand::Inserted, (editBlock != 0),
                                op, X->format, X->stringPosition, dstKey, X->size_array[0],
                                blockRevision);

        if (key+1 != blocks.position(b)) {
//      qDebug("remove_string from %d length %d", key, X->size_array[0]);
            Q_ASSERT(noBlockInString(text.mid(X->stringPosition, X->size_array[0])));
            w = remove_string(key, X->size_array[0], op);

            if (needsInsert) {
                insert_string(dstKey, X->stringPosition, X->size_array[0], X->format, op);
                dstKey += X->size_array[0];
            }
        } else {
//      qDebug("remove_block at %d", key);
            Q_ASSERT(X->size_array[0] == 1 && isValidBlockSeparator(text.at(X->stringPosition)));
            b = blocks.previous(b);
            B = 0;
            c.command = blocks.size(b) == 1 ? QTextUndoCommand::BlockDeleted : QTextUndoCommand::BlockRemoved;
            w = remove_block(key, &c.blockFormat, QTextUndoCommand::BlockAdded, op);

            if (needsInsert) {
                insert_block(dstKey++, X->stringPosition, X->format, c.blockFormat, op, QTextUndoCommand::BlockRemoved);
                cInsert.command = blocks.size(b) == 1 ? QTextUndoCommand::BlockAdded : QTextUndoCommand::BlockInserted;
                cInsert.blockFormat = c.blockFormat;
            }
        }
        appendUndoItem(c);
        if (B)
            B->revision = revision;
        x = n;

        if (needsInsert)
            appendUndoItem(cInsert);
    }
    if (w)
        unite(w);

    Q_ASSERT(blocks.length() == fragments.length());

    if (!blockCursorAdjustment)
        finishEdit();
}

nextCursorPosition()

int QTextDocumentPrivate::nextCursorPosition	(	int	position,
		QTextLayout::CursorMode	mode
	)		const

Definition at line 1360 of file qtextdocument_p.cpp.

Referenced by QTextCursor::deleteChar(), and QTextCursorPrivate::movePosition().

{
    if (position == length()-1)
        return position;

    QTextBlock it = blocksFind(position);
    int start = it.position();
    int end = start + it.length() - 1;
    if (position == end)
        return end + 1;

    return it.layout()->nextCursorPosition(position-start, mode) + start;
}

numBlocks()

int QTextDocumentPrivate::numBlocks ( ) const

inline

Definition at line 237 of file qtextdocument_p.h.

{ return blocks.numNodes(); }

objectForFormat() [1/2]

QTextObject * QTextDocumentPrivate::objectForFormat

(

int

formatIndex

)

const

Definition at line 1612 of file qtextdocument_p.cpp.

Referenced by QTextCursor::currentList(), insert_block(), insert_string(), QTextFrame::iterator::operator++(), QTextFrame::iterator::operator--(), remove_block(), remove_string(), scan_frames(), setBlockFormat(), and undoRedo().

{
    int objectIndex = formats.format(formatIndex).objectIndex();
    return objectForIndex(objectIndex);
}

objectForFormat() [2/2]

QTextObject * QTextDocumentPrivate::objectForFormat

(

const QTextFormat &

f

)

const

Definition at line 1618 of file qtextdocument_p.cpp.

{
    return objectForIndex(f.objectIndex());
}

objectForIndex()

QTextObject * QTextDocumentPrivate::objectForIndex

(

int

objectIndex

)

const

Definition at line 1598 of file qtextdocument_p.cpp.

Referenced by objectForFormat(), and undoRedo().

{
    if (objectIndex < 0)
        return 0;

    QTextObject *object = objects.value(objectIndex, 0);
    if (!object) {
        QTextDocumentPrivate *that = const_cast<QTextDocumentPrivate *>(this);
        QTextFormat fmt = formats.objectFormat(objectIndex);
        object = that->createObject(fmt, objectIndex);
    }
    return object;
}

operator=()

QTextDocumentPrivate& QTextDocumentPrivate::operator= ( const QTextDocumentPrivate &  m )

private

plainText()

QString QTextDocumentPrivate::plainText

(

)

const

Definition at line 1335 of file qtextdocument_p.cpp.

{
    QString result;
    result.resize(length());
    const QChar *text_unicode = text.unicode();
    QChar *data = result.data();
    for (QTextDocumentPrivate::FragmentIterator it = begin(); it != end(); ++it) {
        const QTextFragmentData *f = *it;
        ::memcpy(data, text_unicode + f->stringPosition, f->size_array[0] * sizeof(QChar));
        data += f->size_array[0];
    }
    // remove trailing block separator
    result.chop(1);
    return result;
}

previousCursorPosition()

int QTextDocumentPrivate::previousCursorPosition	(	int	position,
		QTextLayout::CursorMode	mode
	)		const

Definition at line 1374 of file qtextdocument_p.cpp.

Referenced by QTextCursorPrivate::movePosition().

{
    if (position == 0)
        return position;

    QTextBlock it = blocksFind(position);
    int start = it.position();
    if (position == start)
        return start - 1;

    return it.layout()->previousCursorPosition(position-start, mode) + start;
}

redo()

void QTextDocumentPrivate::redo ( )

inline

Definition at line 204 of file qtextdocument_p.h.

{ undoRedo(false); }

remove()

void QTextDocumentPrivate::remove	(	int	pos,
		int	length,
		QTextUndoCommand::Operation	op = QTextUndoCommand::MoveCursor
	)

Definition at line 672 of file qtextdocument_p.cpp.

Referenced by QTextCursorPrivate::clearCells(), QTextTable::mergeCells(), QTextCursorPrivate::remove(), QTextTable::removeColumns(), and QTextTable::removeRows().

{
    if (length == 0)
        return;
    blockCursorAdjustment = true;
    move(pos, -1, length, op);
    blockCursorAdjustment = false;
    foreach (QTextCursorPrivate *curs, cursors) {
        if (curs->adjustPosition(pos, -length, op) == QTextCursorPrivate::CursorMoved) {
            curs->changed = true;
        }
    }
    finishEdit();
}

remove_block()

int QTextDocumentPrivate::remove_block ( int  pos, int *  blockformat, int  command, QTextUndoCommand::Operation  op  )

private

Definition at line 519 of file qtextdocument_p.cpp.

Referenced by move(), and undoRedo().

{
    Q_ASSERT(pos >= 0);
    Q_ASSERT(blocks.length() == fragments.length());
    Q_ASSERT(blocks.length() > pos);

    int b = blocks.findNode(pos);
    uint x = fragments.findNode(pos);

    Q_ASSERT(x && (int)fragments.position(x) == pos);
    Q_ASSERT(fragments.size(x) == 1);
    Q_ASSERT(isValidBlockSeparator(text.at(fragments.fragment(x)->stringPosition)));
    Q_ASSERT(b);

    if (blocks.size(b) == 1 && command == QTextUndoCommand::BlockAdded) {
    Q_ASSERT((int)blocks.position(b) == pos);
//      qDebug("removing empty block");
    // empty block remove the block itself
    } else {
    // non empty block, merge with next one into this block
//      qDebug("merging block with next");
    int n = blocks.next(b);
    Q_ASSERT((int)blocks.position(n) == pos + 1);
    blocks.setSize(b, blocks.size(b) + blocks.size(n) - 1);
        blocks.fragment(b)->userState = blocks.fragment(n)->userState;
    b = n;
    }
    *blockFormat = blocks.fragment(b)->format;

    QTextBlockGroup *group = qobject_cast<QTextBlockGroup *>(objectForFormat(blocks.fragment(b)->format));
    if (group)
        group->blockRemoved(QTextBlock(this, b));

    QTextFrame *frame = qobject_cast<QTextFrame *>(objectForFormat(fragments.fragment(x)->format));
    if (frame) {
        frame->d_func()->fragmentRemoved(text.at(fragments.fragment(x)->stringPosition), x);
        framesDirty = true;
    }

    blocks.erase_single(b);
    const int w = fragments.erase_single(x);

    adjustDocumentChangesAndCursors(pos, -1, op);

    return w;
}

remove_string()

int QTextDocumentPrivate::remove_string ( int  pos, uint  length, QTextUndoCommand::Operation  op  )

private

Definition at line 488 of file qtextdocument_p.cpp.

Referenced by move().

{
    Q_ASSERT(pos >= 0);
    Q_ASSERT(blocks.length() == fragments.length());
    Q_ASSERT(blocks.length() >= pos+(int)length);

    int b = blocks.findNode(pos);
    uint x = fragments.findNode(pos);

    Q_ASSERT(blocks.size(b) > length);
    Q_ASSERT(x && fragments.position(x) == (uint)pos && fragments.size(x) == length);
    Q_ASSERT(noBlockInString(text.mid(fragments.fragment(x)->stringPosition, length)));

    blocks.setSize(b, blocks.size(b)-length);

    QTextFrame *frame = qobject_cast<QTextFrame *>(objectForFormat(fragments.fragment(x)->format));
    if (frame) {
        frame->d_func()->fragmentRemoved(text.at(fragments.fragment(x)->stringPosition), x);
        framesDirty = true;
    }

    const int w = fragments.erase_single(x);

    if (!undoEnabled)
        unreachableCharacterCount += length;

    adjustDocumentChangesAndCursors(pos, -int(length), op);

    return w;
}

removeCursor()

void QTextDocumentPrivate::removeCursor ( QTextCursorPrivate *  c )

inline

Definition at line 283 of file qtextdocument_p.h.

Referenced by QTextCursorPrivate::~QTextCursorPrivate().

{ cursors.removeAll(c); }

removeFrame()

void QTextDocumentPrivate::removeFrame

(

QTextFrame *

frame

)

Definition at line 1579 of file qtextdocument_p.cpp.

{
    QTextFrame *parent = frame->d_func()->parentFrame;
    if (!parent)
        return;

    int start = frame->firstPosition();
    int end = frame->lastPosition();
    Q_ASSERT(end >= start);

    beginEditBlock();

    // remove already removes the frames from the tree
    remove(end, 1);
    remove(start-1, 1);

    endEditBlock();
}

rightCursorPosition()

int QTextDocumentPrivate::rightCursorPosition

(

int

position

)

const

Definition at line 1394 of file qtextdocument_p.cpp.

Referenced by QTextCursorPrivate::movePosition().

{
    QTextBlock it = blocksFind(position);
    int start = it.position();
    return it.layout()->rightCursorPosition(position-start) + start;
}

rootFrame()

QTextFrame * QTextDocumentPrivate::rootFrame

(

)

const

Definition at line 1442 of file qtextdocument_p.cpp.

Referenced by QTextDocumentLayoutPrivate::drawFrame(), frameAt(), QTextDocumentLayoutPrivate::frameIteratorForTextPosition(), QTextDocumentLayoutPrivate::hitTest(), and scan_frames().

{
    if (!rtFrame) {
        QTextFrameFormat defaultRootFrameFormat;
        defaultRootFrameFormat.setMargin(documentMargin);
        rtFrame = qobject_cast<QTextFrame *>(const_cast<QTextDocumentPrivate *>(this)->createObject(defaultRootFrameFormat));
    }
    return rtFrame;
}

scan_frames()

void QTextDocumentPrivate::scan_frames ( int  pos, int  charsRemoved, int  charsAdded  )

private

Definition at line 1472 of file qtextdocument_p.cpp.

Referenced by finishEdit().

{
    // ###### optimize
    Q_UNUSED(pos);
    Q_UNUSED(charsRemoved);
    Q_UNUSED(charsAdded);

    QTextFrame *f = rootFrame();
    clearFrame(f);

    for (FragmentIterator it = begin(); it != end(); ++it) {
        // QTextFormat fmt = formats.format(it->format);
        QTextFrame *frame = qobject_cast<QTextFrame *>(objectForFormat(it->format));
        if (!frame)
            continue;

        Q_ASSERT(it.size() == 1);
        QChar ch = text.at(it->stringPosition);

        if (ch == QTextBeginningOfFrame) {
            if (f != frame) {
                // f == frame happens for tables
                Q_ASSERT(frame->d_func()->fragment_start == it.n || frame->d_func()->fragment_start == 0);
                frame->d_func()->parentFrame = f;
                f->d_func()->childFrames.append(frame);
                f = frame;
            }
        } else if (ch == QTextEndOfFrame) {
            Q_ASSERT(f == frame);
            Q_ASSERT(frame->d_func()->fragment_end == it.n || frame->d_func()->fragment_end == 0);
            f = frame->d_func()->parentFrame;
        } else if (ch == QChar::ObjectReplacementCharacter) {
            Q_ASSERT(f != frame);
            Q_ASSERT(frame->d_func()->fragment_start == it.n || frame->d_func()->fragment_start == 0);
            Q_ASSERT(frame->d_func()->fragment_end == it.n || frame->d_func()->fragment_end == 0);
            frame->d_func()->parentFrame = f;
            f->d_func()->childFrames.append(frame);
        } else {
            Q_ASSERT(false);
        }
    }
    Q_ASSERT(f == rtFrame);
    framesDirty = false;
}

setBlockFormat()

void QTextDocumentPrivate::setBlockFormat	(	const QTextBlock &	from,
		const QTextBlock &	to,
		const QTextBlockFormat &	newFormat,
		FormatChangeMode	mode = SetFormat
	)

Definition at line 779 of file qtextdocument_p.cpp.

Referenced by QTextList::add(), QTextCopyHelper::appendFragment(), QTextList::remove(), and QTextCursorPrivate::setBlockFormat().

{
    beginEditBlock();

    Q_ASSERT(mode != SetFormatAndPreserveObjectIndices); // only implemented for setCharFormat

    Q_ASSERT(newFormat.isValid());

    int newFormatIdx = -1;
    if (mode == SetFormat)
        newFormatIdx = formats.indexForFormat(newFormat);
    QTextBlockGroup *group = qobject_cast<QTextBlockGroup *>(objectForFormat(newFormat));

    QTextBlock it = from;
    QTextBlock end = to;
    if (end.isValid())
    end = end.next();

    for (; it != end; it = it.next()) {
        int oldFormat = block(it)->format;
        QTextBlockFormat format = formats.blockFormat(oldFormat);
        QTextBlockGroup *oldGroup = qobject_cast<QTextBlockGroup *>(objectForFormat(format));
        if (mode == MergeFormat) {
            format.merge(newFormat);
            newFormatIdx = formats.indexForFormat(format);
            group = qobject_cast<QTextBlockGroup *>(objectForFormat(format));
        }
        block(it)->format = newFormatIdx;

        block(it)->invalidate();

        QT_INIT_TEXTUNDOCOMMAND(c, QTextUndoCommand::BlockFormatChanged, true, QTextUndoCommand::MoveCursor, oldFormat,
                                0, it.position(), 1, 0);
        appendUndoItem(c);

        if (group != oldGroup) {
            if (oldGroup)
                oldGroup->blockRemoved(it);
            if (group)
                group->blockInserted(it);
        } else if (group) {
        group->blockFormatChanged(it);
    }
    }

    documentChange(from.position(), to.position() + to.length() - from.position());

    endEditBlock();
}

setCharFormat()

void QTextDocumentPrivate::setCharFormat	(	int	pos,
		int	length,
		const QTextCharFormat &	newFormat,
		FormatChangeMode	mode = SetFormat
	)

Definition at line 687 of file qtextdocument_p.cpp.

Referenced by QTextCopyHelper::appendFragment(), QTextTable::insertColumns(), QTextTable::insertRows(), QTextTable::mergeCells(), QTextTable::removeColumns(), QTextTable::removeRows(), setBlockCharFormatHelper(), QTextCursorPrivate::setCharFormat(), QTextTableCell::setFormat(), QTextTable::splitCell(), and undoRedo().

{
    beginEditBlock();

    Q_ASSERT(newFormat.isValid());

    int newFormatIdx = -1;
    if (mode == SetFormatAndPreserveObjectIndices) {
        QTextCharFormat cleanFormat = newFormat;
        cleanFormat.clearProperty(QTextFormat::ObjectIndex);
        newFormatIdx = formats.indexForFormat(cleanFormat);
    } else if (mode == SetFormat) {
        newFormatIdx = formats.indexForFormat(newFormat);
    }

    if (pos == -1) {
        if (mode == MergeFormat) {
            QTextFormat format = formats.format(initialBlockCharFormatIndex);
            format.merge(newFormat);
            initialBlockCharFormatIndex = formats.indexForFormat(format);
        } else if (mode == SetFormatAndPreserveObjectIndices
                   && formats.format(initialBlockCharFormatIndex).objectIndex() != -1) {
            QTextCharFormat f = newFormat;
            f.setObjectIndex(formats.format(initialBlockCharFormatIndex).objectIndex());
            initialBlockCharFormatIndex = formats.indexForFormat(f);
        } else {
            initialBlockCharFormatIndex = newFormatIdx;
        }

        ++pos;
        --length;
    }

    const int startPos = pos;
    const int endPos = pos + length;

    split(startPos);
    split(endPos);

    while (pos < endPos) {
        FragmentMap::Iterator it = fragments.find(pos);
        Q_ASSERT(!it.atEnd());

        QTextFragmentData *fragment = it.value();

        Q_ASSERT(formats.format(fragment->format).type() == QTextFormat::CharFormat);

        int offset = pos - it.position();
        int length = qMin(endPos - pos, int(fragment->size_array[0] - offset));
        int oldFormat = fragment->format;

        if (mode == MergeFormat) {
            QTextFormat format = formats.format(fragment->format);
            format.merge(newFormat);
            fragment->format = formats.indexForFormat(format);
        } else if (mode == SetFormatAndPreserveObjectIndices
                   && formats.format(oldFormat).objectIndex() != -1) {
            QTextCharFormat f = newFormat;
            f.setObjectIndex(formats.format(oldFormat).objectIndex());
            fragment->format = formats.indexForFormat(f);
        } else {
            fragment->format = newFormatIdx;
        }

        QT_INIT_TEXTUNDOCOMMAND(c, QTextUndoCommand::CharFormatChanged, true, QTextUndoCommand::MoveCursor, oldFormat,
                                0, pos, length, 0);
        appendUndoItem(c);

        pos += length;
        Q_ASSERT(pos == (int)(it.position() + fragment->size_array[0]) || pos >= endPos);
    }

    int n = fragments.findNode(startPos - 1);
    if (n)
        unite(n);

    n = fragments.findNode(endPos);
    if (n)
        unite(n);

    QTextBlock blockIt = blocksFind(startPos);
    QTextBlock endIt = blocksFind(endPos);
    if (endIt.isValid())
        endIt = endIt.next();
    for (; blockIt.isValid() && blockIt != endIt; blockIt = blockIt.next())
        QTextDocumentPrivate::block(blockIt)->invalidate();

    documentChange(startPos, length);

    endEditBlock();
}

setDefaultFont()

void QTextDocumentPrivate::setDefaultFont ( const QFont &  f )

inline

Definition at line 257 of file qtextdocument_p.h.

Referenced by QTextDocument::clone().

{ formats.setDefaultFont(f); }

setLayout()

void QTextDocumentPrivate::setLayout

(

QAbstractTextDocumentLayout *

layout

)

Definition at line 300 of file qtextdocument_p.cpp.

{
    Q_Q(QTextDocument);
    if (lout == layout)
        return;
    const bool firstLayout = !lout;
    delete lout;
    lout = layout;

    if (!firstLayout)
        for (BlockMap::Iterator it = blocks.begin(); !it.atEnd(); ++it)
            it->free();

    emit q->documentLayoutChanged();
    inContentsChange = true;
    emit q->contentsChange(0, 0, length());
    inContentsChange = false;
    if (lout)
        lout->documentChanged(0, 0, length());
}

setModified()

void QTextDocumentPrivate::setModified

(

bool

m

)

Definition at line 1690 of file qtextdocument_p.cpp.

Referenced by QTextDocument::setModified().

{
    Q_Q(QTextDocument);
    if (m == modified)
        return;

    modified = m;
    if (!modified)
        modifiedState = undoState;
    else
        modifiedState = -1;

    emit q->modificationChanged(modified);
}

split()

bool QTextDocumentPrivate::split ( int  pos )

private

Definition at line 831 of file qtextdocument_p.cpp.

Referenced by insert_block(), insert_string(), move(), and setCharFormat().

{
    uint x = fragments.findNode(pos);
    if (x) {
        int k = fragments.position(x);
//          qDebug("found fragment with key %d, size_left=%d, size=%d to split at %d",
//                k, (*it)->size_left[0], (*it)->size_array[0], pos);
        if (k != pos) {
            Q_ASSERT(k <= pos);
            // need to resize the first fragment and add a new one
            QTextFragmentData *X = fragments.fragment(x);
            int oldsize = X->size_array[0];
            fragments.setSize(x, pos-k);
            uint n = fragments.insert_single(pos, oldsize-(pos-k));
            X = fragments.fragment(x);
            QTextFragmentData *N = fragments.fragment(n);
            N->stringPosition = X->stringPosition + pos-k;
            N->format = X->format;
            return true;
        }
    }
    return false;
}

undo()

void QTextDocumentPrivate::undo ( )

inline

Definition at line 203 of file qtextdocument_p.h.

{ undoRedo(true); }

undoRedo()

int QTextDocumentPrivate::undoRedo

(

bool

undo

)

Definition at line 877 of file qtextdocument_p.cpp.

{
    PMDEBUG("%s, undoState=%d, undoStack size=%d", undo ? "undo:" : "redo:", undoState, undoStack.size());
    if (!undoEnabled || (undo && undoState == 0) || (!undo && undoState == undoStack.size()))
        return -1;

    undoEnabled = false;
    beginEditBlock();
    int editPos = -1;
    int editLength = -1;
    while (1) {
        if (undo)
            --undoState;
        QTextUndoCommand &c = undoStack[undoState];
        int resetBlockRevision = c.pos;

    switch(c.command) {
        case QTextUndoCommand::Inserted:
            remove(c.pos, c.length, (QTextUndoCommand::Operation)c.operation);
            PMDEBUG("   erase: from %d, length %d", c.pos, c.length);
            c.command = QTextUndoCommand::Removed;
            editPos = c.pos;
            editLength = 0;
        break;
        case QTextUndoCommand::Removed:
            PMDEBUG("   insert: format %d (from %d, length %d, strpos=%d)", c.format, c.pos, c.length, c.strPos);
            insert_string(c.pos, c.strPos, c.length, c.format, (QTextUndoCommand::Operation)c.operation);
            c.command = QTextUndoCommand::Inserted;
            if (editPos != (int)c.pos)
                editLength = 0;
            editPos = c.pos;
            editLength += c.length;
        break;
    case QTextUndoCommand::BlockInserted:
    case QTextUndoCommand::BlockAdded:
            remove_block(c.pos, &c.blockFormat, c.command, (QTextUndoCommand::Operation)c.operation);
            PMDEBUG("   blockremove: from %d", c.pos);
        if (c.command == QTextUndoCommand::BlockInserted)
        c.command = QTextUndoCommand::BlockRemoved;
        else
        c.command = QTextUndoCommand::BlockDeleted;
            editPos = c.pos;
            editLength = 0;
        break;
    case QTextUndoCommand::BlockRemoved:
    case QTextUndoCommand::BlockDeleted:
            PMDEBUG("   blockinsert: charformat %d blockformat %d (pos %d, strpos=%d)", c.format, c.blockFormat, c.pos, c.strPos);
            insert_block(c.pos, c.strPos, c.format, c.blockFormat, (QTextUndoCommand::Operation)c.operation, c.command);
            resetBlockRevision += 1;
        if (c.command == QTextUndoCommand::BlockRemoved)
        c.command = QTextUndoCommand::BlockInserted;
        else
        c.command = QTextUndoCommand::BlockAdded;
            if (editPos != (int)c.pos)
                editLength = 0;
            editPos = c.pos;
            editLength += 1;
        break;
    case QTextUndoCommand::CharFormatChanged: {
            resetBlockRevision = -1; // ## TODO
            PMDEBUG("   charFormat: format %d (from %d, length %d)", c.format, c.pos, c.length);
            FragmentIterator it = find(c.pos);
            Q_ASSERT(!it.atEnd());

            int oldFormat = it.value()->format;
            setCharFormat(c.pos, c.length, formats.charFormat(c.format));
            c.format = oldFormat;
            if (editPos != (int)c.pos)
                editLength = 0;
            editPos = c.pos;
            editLength += c.length;
        break;
    }
    case QTextUndoCommand::BlockFormatChanged: {
            resetBlockRevision = -1; // ## TODO
            PMDEBUG("   blockformat: format %d pos %d", c.format, c.pos);
            QTextBlock it = blocksFind(c.pos);
            Q_ASSERT(it.isValid());

            int oldFormat = block(it)->format;
            block(it)->format = c.format;
            QTextBlockGroup *oldGroup = qobject_cast<QTextBlockGroup *>(objectForFormat(formats.blockFormat(oldFormat)));
            QTextBlockGroup *group = qobject_cast<QTextBlockGroup *>(objectForFormat(formats.blockFormat(c.format)));
            c.format = oldFormat;
            if (group != oldGroup) {
                if (oldGroup)
                    oldGroup->blockRemoved(it);
                if (group)
                    group->blockInserted(it);
            } else if (group) {
                group->blockFormatChanged(it);
            }
            documentChange(it.position(), it.length());
            editPos = -1;
        break;
    }
    case QTextUndoCommand::GroupFormatChange: {
            resetBlockRevision = -1; // ## TODO
            PMDEBUG("   group format change");
            QTextObject *object = objectForIndex(c.objectIndex);
            int oldFormat = formats.objectFormatIndex(c.objectIndex);
            changeObjectFormat(object, c.format);
            c.format = oldFormat;
            editPos = -1;
        break;
    }
        case QTextUndoCommand::CursorMoved:
            editPos = c.pos;
            editLength = 0;
            break;
    case QTextUndoCommand::Custom:
            resetBlockRevision = -1; // ## TODO
            if (undo)
                c.custom->undo();
            else
                c.custom->redo();
            editPos = -1;
        break;
    default:
        Q_ASSERT(false);
        }

        if (resetBlockRevision >= 0) {
            int b = blocks.findNode(resetBlockRevision);
            QTextBlockData *B = blocks.fragment(b);
            B->revision = c.revision;
        }

        if (!undo)
            ++undoState;

        bool inBlock = (
                undoState > 0
                && undoState < undoStack.size()
                && undoStack[undoState].block_part
                && undoStack[undoState-1].block_part
                && !undoStack[undoState-1].block_end
                );
        if (!inBlock)
            break;
    }
    undoEnabled = true;

    int newCursorPos = -1;

    if (editPos >=0)
        newCursorPos = editPos + editLength;
    else if (docChangeFrom >= 0)
        newCursorPos= qMin(docChangeFrom + docChangeLength, length() - 1);

    endEditBlock();
    emitUndoAvailable(isUndoAvailable());
    emitRedoAvailable(isRedoAvailable());

    return newCursorPos;
}

unite()

bool QTextDocumentPrivate::unite ( uint  f )

private

Definition at line 855 of file qtextdocument_p.cpp.

Referenced by insert_string(), move(), and setCharFormat().

{
    uint n = fragments.next(f);
    if (!n)
        return false;

    QTextFragmentData *ff = fragments.fragment(f);
    QTextFragmentData *nf = fragments.fragment(n);

    if (nf->format == ff->format && (ff->stringPosition + (int)ff->size_array[0] == nf->stringPosition)) {
        if (isValidBlockSeparator(text.at(ff->stringPosition))
            || isValidBlockSeparator(text.at(nf->stringPosition)))
            return false;

        fragments.setSize(f, ff->size_array[0] + nf->size_array[0]);
        fragments.erase_single(n);
        return true;
    }
    return false;
}

Friends and Related Functions

QTextCursor

friend class QTextCursor

friend

Definition at line 362 of file qtextdocument_p.h.

Referenced by finishEdit().

QTextHtmlExporter

friend class QTextHtmlExporter

friend

Definition at line 361 of file qtextdocument_p.h.

Properties

blockCursorAdjustment

uint QTextDocumentPrivate::blockCursorAdjustment

Definition at line 352 of file qtextdocument_p.h.

Referenced by adjustDocumentChangesAndCursors(), move(), QTextDocumentPrivate(), and remove().

blocks

BlockMap QTextDocumentPrivate::blocks

private

Definition at line 332 of file qtextdocument_p.h.

Referenced by block(), blockCharFormatIndex(), clear(), ensureMaximumBlockCount(), finishEdit(), insert(), insert_block(), insert_string(), insertBlock(), move(), remove_block(), remove_string(), setLayout(), and undoRedo().

cachedResources

QMap<QUrl, QVariant> QTextDocumentPrivate::cachedResources

private

Definition at line 338 of file qtextdocument_p.h.

Referenced by clear(), QTextDocument::clone(), QTextHtmlExporter::findUrlForImage(), and mergeCachedResources().

cursors

QList<QTextCursorPrivate *> QTextDocumentPrivate::cursors

private

Definition at line 335 of file qtextdocument_p.h.

Referenced by aboutToRemoveCell(), adjustDocumentChangesAndCursors(), clear(), finishEdit(), remove(), and ~QTextDocumentPrivate().

defaultCursorMoveStyle

Qt::CursorMoveStyle QTextDocumentPrivate::defaultCursorMoveStyle

Definition at line 345 of file qtextdocument_p.h.

Referenced by QTextCursorPrivate::movePosition(), QTextDocumentPrivate(), and QTextEngine::visualCursorMovement().

defaultStyleSheet

QString QTextDocumentPrivate::defaultStyleSheet

private

Definition at line 339 of file qtextdocument_p.h.

Referenced by QTextDocument::clone().

defaultTextOption

QTextOption QTextDocumentPrivate::defaultTextOption

Definition at line 344 of file qtextdocument_p.h.

Referenced by QTextDocument::clone(), QTextDocumentLayoutPrivate::layoutBlock(), QTextDocumentLayoutPrivate::layoutTable(), and QTextDocumentPrivate().

docChangeFrom

int QTextDocumentPrivate::docChangeFrom

private

Definition at line 323 of file qtextdocument_p.h.

Referenced by adjustDocumentChangesAndCursors(), documentChange(), finishEdit(), QTextDocumentPrivate(), and undoRedo().

docChangeLength

int QTextDocumentPrivate::docChangeLength

private

Definition at line 325 of file qtextdocument_p.h.

Referenced by adjustDocumentChangesAndCursors(), documentChange(), finishEdit(), and undoRedo().

docChangeOldLength

int QTextDocumentPrivate::docChangeOldLength

private

Definition at line 324 of file qtextdocument_p.h.

Referenced by adjustDocumentChangesAndCursors(), documentChange(), and finishEdit().

documentMargin

qreal QTextDocumentPrivate::documentMargin

Definition at line 357 of file qtextdocument_p.h.

Referenced by QTextDocumentPrivate(), and rootFrame().

editBlock

int QTextDocumentPrivate::editBlock

private

Definition at line 321 of file qtextdocument_p.h.

Referenced by adjustDocumentChangesAndCursors(), appendUndoItem(), QTextCursor::beginEditBlock(), changeObjectFormat(), contentsChanged(), endEditBlock(), finishEdit(), insert(), insertBlock(), move(), and QTextDocumentPrivate().

editBlockCursorPosition

int QTextDocumentPrivate::editBlockCursorPosition

private

Definition at line 322 of file qtextdocument_p.h.

Referenced by appendUndoItem(), QTextCursor::beginEditBlock(), endEditBlock(), and QTextDocumentPrivate().

formats

QTextFormatCollection QTextDocumentPrivate::formats

private

Definition at line 328 of file qtextdocument_p.h.

Referenced by changeObjectFormat(), clear(), createObject(), init(), insert(), insert_block(), insertBlock(), insertFrame(), objectForFormat(), objectForIndex(), setBlockFormat(), setCharFormat(), and undoRedo().

fragments

FragmentMap QTextDocumentPrivate::fragments

private

Definition at line 331 of file qtextdocument_p.h.

Referenced by blockCharFormatIndex(), clear(), compressPieceTable(), insert(), insert_block(), insert_string(), insertBlock(), move(), remove_block(), remove_string(), setCharFormat(), split(), and unite().

framesDirty

bool QTextDocumentPrivate::framesDirty

private

Definition at line 326 of file qtextdocument_p.h.

Referenced by finishEdit(), init(), insert_block(), insert_string(), remove_block(), remove_string(), and scan_frames().

inContentsChange

uint QTextDocumentPrivate::inContentsChange

Definition at line 351 of file qtextdocument_p.h.

Referenced by clear(), finishEdit(), QTextDocumentPrivate(), and setLayout().

indentWidth

qreal QTextDocumentPrivate::indentWidth

Definition at line 356 of file qtextdocument_p.h.

Referenced by QTextDocument::clone(), and QTextDocumentPrivate().

initialBlockCharFormatIndex

int QTextDocumentPrivate::initialBlockCharFormatIndex

private

Definition at line 333 of file qtextdocument_p.h.

Referenced by blockCharFormatIndex(), init(), and setCharFormat().

lastBlockCount

int QTextDocumentPrivate::lastBlockCount

private

Definition at line 341 of file qtextdocument_p.h.

Referenced by finishEdit(), and QTextDocumentPrivate().

lout

QAbstractTextDocumentLayout* QTextDocumentPrivate::lout

private

Definition at line 330 of file qtextdocument_p.h.

Referenced by clear(), finishEdit(), QTextDocumentPrivate(), and setLayout().

maximumBlockCount

int QTextDocumentPrivate::maximumBlockCount

Definition at line 349 of file qtextdocument_p.h.

Referenced by enableUndoRedo(), ensureMaximumBlockCount(), and QTextDocumentPrivate().

modified

bool QTextDocumentPrivate::modified

private

Definition at line 319 of file qtextdocument_p.h.

Referenced by appendUndoItem(), clear(), contentsChanged(), enableUndoRedo(), init(), QTextDocumentPrivate(), and setModified().

modifiedState

int QTextDocumentPrivate::modifiedState

private

Definition at line 318 of file qtextdocument_p.h.

Referenced by appendUndoItem(), clear(), contentsChanged(), enableUndoRedo(), init(), QTextDocumentPrivate(), and setModified().

needsEnsureMaximumBlockCount

uint QTextDocumentPrivate::needsEnsureMaximumBlockCount

Definition at line 350 of file qtextdocument_p.h.

Referenced by finishEdit(), insertBlock(), and QTextDocumentPrivate().

objects

QMap<int, QTextObject *> QTextDocumentPrivate::objects

private

Definition at line 336 of file qtextdocument_p.h.

Referenced by clear(), createObject(), deleteObject(), and objectForIndex().

pageSize

QSizeF QTextDocumentPrivate::pageSize

Definition at line 353 of file qtextdocument_p.h.

Referenced by QTextDocument::clone().

parsedDefaultStyleSheet

QCss::StyleSheet QTextDocumentPrivate::parsedDefaultStyleSheet

Definition at line 347 of file qtextdocument_p.h.

Referenced by QTextDocument::clone().

resources

QMap<QUrl, QVariant> QTextDocumentPrivate::resources

private

Definition at line 337 of file qtextdocument_p.h.

Referenced by QTextDocument::clone().

revision

int QTextDocumentPrivate::revision

private

Definition at line 316 of file qtextdocument_p.h.

Referenced by adjustDocumentChangesAndCursors(), insert(), insertBlock(), move(), and QTextDocumentPrivate().

rtFrame

QTextFrame* QTextDocumentPrivate::rtFrame

mutableprivate

Definition at line 329 of file qtextdocument_p.h.

Referenced by clear(), rootFrame(), and scan_frames().

text

QString QTextDocumentPrivate::text

private

Definition at line 310 of file qtextdocument_p.h.

Referenced by clear(), compressPieceTable(), insert(), insert_block(), insert_string(), insertBlock(), QTextCursor::insertText(), move(), plainText(), remove_block(), remove_string(), scan_frames(), and unite().

title

QString QTextDocumentPrivate::title

Definition at line 354 of file qtextdocument_p.h.

Referenced by clear(), and QTextDocument::clone().

undoEnabled

bool QTextDocumentPrivate::undoEnabled

private

Definition at line 314 of file qtextdocument_p.h.

Referenced by appendUndoItem(), compressPieceTable(), contentsChanged(), enableUndoRedo(), endEditBlock(), finishEdit(), init(), insert(), joinPreviousEditBlock(), QTextDocumentPrivate(), remove_string(), undoRedo(), and ~QTextDocumentPrivate().

undoStack

QVector<QTextUndoCommand> QTextDocumentPrivate::undoStack

private

Definition at line 313 of file qtextdocument_p.h.

Referenced by appendUndoItem(), clearUndoRedoStacks(), endEditBlock(), insert(), insertBlock(), joinPreviousEditBlock(), and undoRedo().

undoState

int QTextDocumentPrivate::undoState

private

Definition at line 315 of file qtextdocument_p.h.

Referenced by appendUndoItem(), clearUndoRedoStacks(), contentsChanged(), enableUndoRedo(), endEditBlock(), init(), insert(), insertBlock(), joinPreviousEditBlock(), QTextDocumentPrivate(), setModified(), undoRedo(), and ~QTextDocumentPrivate().

unreachableCharacterCount

uint QTextDocumentPrivate::unreachableCharacterCount

private

Definition at line 311 of file qtextdocument_p.h.

Referenced by clear(), compressPieceTable(), ensureMaximumBlockCount(), finishEdit(), QTextDocumentPrivate(), and remove_string().

url

QString QTextDocumentPrivate::url

Definition at line 355 of file qtextdocument_p.h.

Referenced by QTextDocument::clone().

wasRedoAvailable

bool QTextDocumentPrivate::wasRedoAvailable

private

Definition at line 277 of file qtextdocument_p.h.

Referenced by emitRedoAvailable().

wasUndoAvailable

bool QTextDocumentPrivate::wasUndoAvailable

private

Definition at line 276 of file qtextdocument_p.h.

Referenced by emitUndoAvailable().

---

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

• /src/gui/text/qtextdocument_p.h
• /src/gui/text/qtextdocument.cpp
• /src/gui/text/qtextdocument_p.cpp