// Copyright (C) 2016 The Qt Company Ltd.

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

#include <private/qtools_p.h>

#include <qdebug.h>

#include <qscopedvaluerollback.h>

#include "qtextdocument_p.h"

#include "qtextdocument.h"

#include <qtextformat.h>

#include "qtextformat_p.h"

#include "qtextobject_p.h"

#include "qtextcursor.h"

#include "qtextimagehandler_p.h"

#include "qtextcursor_p.h"

#include "qtextdocumentlayout_p.h"

#include "qtexttable.h"

#include "qtextengine_p.h"

#include <QtCore/q20utility.h>

#include <stdlib.h>

QT_BEGIN_NAMESPACE

#define PMDEBUG if(0) qDebug

// The VxWorks DIAB compiler crashes when initializing the anonymous union with { a7 }

#if !defined(Q_CC_DIAB)

#  define QT_INIT_TEXTUNDOCOMMAND(c, a1, a2, a3, a4, a5, a6, a7, a8) \

          QTextUndoCommand c = { a1, a2, 0, 0, quint8(a3), a4, quint32(a5), quint32(a6), { int(a7) }, quint32(a8) }

#else

#  define QT_INIT_TEXTUNDOCOMMAND(c, a1, a2, a3, a4, a5, a6, a7, a8) \

          QTextUndoCommand c = { a1, a2, 0, 0, a3, a4, a5, a6 }; c.blockFormat = a7; c.revision = a8

#endif

/*

  Structure of a document:

  DOCUMENT :== FRAME_CONTENTS

  FRAME :== START_OF_FRAME  FRAME_CONTENTS END_OF_FRAME

  FRAME_CONTENTS = LIST_OF_BLOCKS ((FRAME | TABLE) LIST_OF_BLOCKS)*

  TABLE :== (START_OF_FRAME TABLE_CELL)+ END_OF_FRAME

  TABLE_CELL = FRAME_CONTENTS

  LIST_OF_BLOCKS :== (BLOCK END_OF_PARA)* BLOCK

  BLOCK :== (FRAGMENT)*

  FRAGMENT :== String of characters

  END_OF_PARA :== 0x2029 # Paragraph separator in Unicode

  START_OF_FRAME :== 0xfdd0

  END_OF_FRAME := 0xfdd1

  Note also that LIST_OF_BLOCKS can be empty. Nevertheless, there is

  at least one valid cursor position there where you could start

  typing. The block format is in this case determined by the last

  END_OF_PARA/START_OF_FRAME/END_OF_FRAME (see below).

  Lists are not in here, as they are treated specially. A list is just

  a collection of (not necessarily connected) blocks, that share the

  same objectIndex() in the format that refers to the list format and

  object.

  The above does not clearly note where formats are. Here's

  how it looks currently:

  FRAGMENT: one charFormat associated

  END_OF_PARA: one charFormat, and a blockFormat for the _next_ block.

  START_OF_FRAME: one char format, and a blockFormat (for the next

  block). The format associated with the objectIndex() of the

  charFormat decides whether this is a frame or table and its

  properties

  END_OF_FRAME: one charFormat and a blockFormat (for the next

  block). The object() of the charFormat is the same as for the

  corresponding START_OF_BLOCK.

  The document is independent of the layout with certain restrictions:

  * Cursor movement (esp. up and down) depend on the layout.

  * You cannot have more than one layout, as the layout data of QTextObjects

    is stored in the text object itself.

*/

void QTextBlockData::invalidate() const

{

    if (layout)

        layout->engine()->invalidate();

}

static bool isValidBlockSeparator(QChar ch)

{

    return ch == QChar::ParagraphSeparator

        || ch == QTextBeginningOfFrame

        || ch == QTextEndOfFrame;

}

static bool noBlockInString(QStringView str)

{

    return !str.contains(QChar::ParagraphSeparator)

        && !str.contains(QTextBeginningOfFrame)

        && !str.contains(QTextEndOfFrame);

}

bool QTextUndoCommand::tryMerge(const QTextUndoCommand &other)

{

    if (command != other.command)

        return false;

    if (command == Inserted

        && (pos + length == other.pos)

        && (strPos + length == other.strPos)

        && format == other.format) {

        length += other.length;

        return true;

    }

    // removal to the 'right' using 'Delete' key

    if (command == Removed

        && pos == other.pos

        && (strPos + length == other.strPos)

        && format == other.format) {

        length += other.length;

        return true;

    }

    // removal to the 'left' using 'Backspace'

    if (command == Removed

        && (other.pos + other.length == pos)

        && (other.strPos + other.length == strPos)

        && (format == other.format)) {

        int l = length;

        (*this) = other;

        length += l;

        return true;

    }

    return false;

}

QTextDocumentPrivate::QTextDocumentPrivate()

    : wasUndoAvailable(false),

    wasRedoAvailable(false),

    docChangeOldLength(0),

    docChangeLength(0),

    framesDirty(true),

    rtFrame(nullptr),

    initialBlockCharFormatIndex(-1), // set correctly later in init()

    resourceProvider(nullptr),

    cssMedia(QStringLiteral("screen"))

{

    editBlock = 0;

    editBlockCursorPosition = -1;

    docChangeFrom = -1;

    undoState = 0;

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

    lout = nullptr;

    modified = false;

    modifiedState = 0;

    undoEnabled = true;

    inContentsChange = false;

    blockCursorAdjustment = false;

    defaultTextOption.setTabStopDistance(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;

}

void QTextDocumentPrivate::init()

{

    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;

    qRegisterMetaType<QTextDocument *>();

}

void QTextDocumentPrivate::clear()

{

    Q_Q(QTextDocument);

    QVarLengthArray<QTextCursor, 4> changedCursors;

    for (QTextCursorPrivate *curs : std::as_const(cursors)) {

        if (!editBlock && curs->position != 0)

            changedCursors.append(QTextCursor(curs));

        curs->setPosition(0);

        curs->currentCharFormat = -1;

        curs->anchor = 0;

        curs->adjusted_anchor = 0;

    }

    QSet<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.clear();

        int len = fragments.length();

        fragments.clear();

        blocks.clear();

        cachedResources.clear();

        delete rtFrame;

        rtFrame = nullptr;

        init();

        cursors = oldCursors;

        {

            QScopedValueRollback<bool> bg(inContentsChange, true);

            emit q->contentsChange(0, len, 0);

        }

        if (lout)

            lout->documentChanged(0, len, 0);

    } QT_CATCH(...) {

        cursors = oldCursors; // at least recover the cursors

        QT_RETHROW;

    }

    for (const QTextCursor &cursor : std::as_const(changedCursors))

        emit q->cursorPositionChanged(cursor);

}

QTextDocumentPrivate::~QTextDocumentPrivate()

{

    for (QTextCursorPrivate *curs : std::as_const(cursors))

        curs->priv = nullptr;

    cursors.clear();

    undoState = 0;

    undoEnabled = true;

    clearUndoRedoStacks(QTextDocument::RedoStack);

}

void QTextDocumentPrivate::setLayout(QAbstractTextDocumentLayout *layout)

{

    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();

    {

        QScopedValueRollback<bool> bg(inContentsChange, true);

        emit q->contentsChange(0, 0, length());

    }

    if (lout)

        lout->documentChanged(0, 0, length());

}

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

{

    // ##### optimize when only appending to the fragment!

    Q_ASSERT(noBlockInString(QStringView{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);

}

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

{

    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 || 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));

        if (command != QTextUndoCommand::BlockDeleted) {

            docChangeOldLength--;

            docChangeLength--;

        }

    }

    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;

}

int QTextDocumentPrivate::insertBlock(QChar blockSeparator,

                                  int pos, int blockFormat, int charFormat, QTextUndoCommand::Operation op)

{

    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.size();

    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;

}

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

{

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

}

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

{

    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();

}

void QTextDocumentPrivate::insert(int pos, QStringView str, int format)

{

    if (str.size() == 0)

        return;

    Q_ASSERT(noBlockInString(str));

    int strPos = text.size();

    text.append(str);

    insert(pos, strPos, str.size(), format);

}

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

{

    Q_ASSERT(pos >= 0);

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

    Q_ASSERT(q20::cmp_greater_equal(blocks.length(), pos+length));

    int b = blocks.findNode(pos);

    uint x = fragments.findNode(pos);

    Q_ASSERT(blocks.size(b) > length);

    Q_ASSERT(x && q20::cmp_equal(fragments.position(x), pos) && fragments.size(x) == length);

    Q_ASSERT(noBlockInString(QStringView{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;

}

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

{

    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;

}

#if !defined(QT_NO_DEBUG)

static bool isAncestorFrame(QTextFrame *possibleAncestor, QTextFrame *child)

{

    while (child) {

        if (child == possibleAncestor)

            return true;

        child = child->parentFrame();

    }

    return false;

}

#endif

void QTextDocumentPrivate::move(int pos, int to, int length, QTextUndoCommand::Operation op)

{

    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(QStringView{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 = nullptr;

            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();

}

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

{

    if (length == 0)

        return;

    blockCursorAdjustment = true;

    move(pos, -1, length, op);

    blockCursorAdjustment = false;

    for (QTextCursorPrivate *curs : std::as_const(cursors)) {

        if (curs->adjustPosition(pos, -length, op) == QTextCursorPrivate::CursorMoved) {

            curs->changed = true;

        }

    }

    finishEdit();

}

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

{

    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(q20::cmp_equal(pos, (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();

}

void QTextDocumentPrivate::setBlockFormat(const QTextBlock &from, const QTextBlock &to,

                                          const QTextBlockFormat &newFormat, FormatChangeMode mode)

{

    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();

}

bool QTextDocumentPrivate::split(int pos)

{

    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;

}

bool QTextDocumentPrivate::unite(uint f)

{

    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;

}

int QTextDocumentPrivate::undoRedo(bool undo)

{

    PMDEBUG("%s, undoState=%d, undoStack size=%d", undo ? "undo:" : "redo:", undoState, int(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: