qtextdocument_p.h

Go to the documentation of this file.

// 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
 
#ifndef QTEXTDOCUMENT_P_H
#define QTEXTDOCUMENT_P_H
 
//
//  W A R N I N G
//  -------------
//
// This file is not part of the Qt API.  It exists purely as an
// implementation detail.  This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
 
#include <QtGui/private/qtguiglobal_p.h>
#include "QtGui/qtextcursor.h"
#include "QtGui/qtextdocument.h"
#include "QtGui/qtextlayout.h"
#include "QtGui/qtextobject.h"
#include "QtGui/qtextoption.h"
 
#include "QtCore/qlist.h"
#include "QtCore/qmap.h"
#include "QtCore/qset.h"
#include "QtCore/qstring.h"
#include "QtCore/qurl.h"
#include "QtCore/qvariant.h"
 
#if QT_CONFIG(cssparser)
#include "private/qcssparser_p.h"
#endif
#include "private/qfragmentmap_p.h"
#include "private/qobject_p.h"
#include "private/qtextformat_p.h"
 
// #define QT_QMAP_DEBUG
 
#ifdef QT_QMAP_DEBUG
#include <iostream>
#endif
 
QT_BEGIN_NAMESPACE
 
class QTextFormatCollection;
class QTextFormat;
class QTextBlockFormat;
class QTextCursorPrivate;
class QAbstractTextDocumentLayout;
class QTextDocument;
class QTextFrame;
 
#define QTextBeginningOfFrame QChar(u'\xfdd0')
#define QTextEndOfFrame QChar(u'\xfdd1')
 
class QTextFragmentData : public QFragment<>
{
public:
    inline void initialize() {}
    inline void invalidate() const {}
    inline void free() {}
    int stringPosition;
    int format;
};
 
class QTextBlockData : public QFragment<3>
{
public:
    inline void initialize()
        { layout = nullptr; userData = nullptr; userState = -1; revision = 0; hidden = 0; }
    void invalidate() const;
    inline void free()
    { delete layout; layout = nullptr; delete userData; userData = nullptr; }
 
    mutable int format;
    // ##### probably store a QTextEngine * here!
    mutable QTextLayout *layout;
    mutable QTextBlockUserData *userData;
    mutable int userState;
    mutable signed int revision : 31;
    mutable uint hidden : 1;
};
 
 
class QAbstractUndoItem;
 
class QTextUndoCommand
{
public:
    enum Command {
        Inserted = 0,
        Removed = 1,
        CharFormatChanged = 2,
        BlockFormatChanged = 3,
        BlockInserted = 4,
        BlockRemoved = 5,
        BlockAdded = 6,
        BlockDeleted = 7,
        GroupFormatChange = 8,
        CursorMoved = 9,
        Custom = 256
    };
    enum Operation {
        KeepCursor = 0,
        MoveCursor = 1
    };
    quint16 command;
    uint block_part : 1; // all commands that are part of an undo block (including the first and the last one) have this set to 1
    uint block_end : 1; // the last command in an undo block has this set to 1.
    uint block_padding : 6; // padding since block used to be a quint8
    quint8 operation;
    int format;
    quint32 strPos;
    quint32 pos;
    union {
        int blockFormat;
        quint32 length;
        QAbstractUndoItem *custom;
        int objectIndex;
    };
    quint32 revision;
 
    bool tryMerge(const QTextUndoCommand &other);
};
Q_DECLARE_TYPEINFO(QTextUndoCommand, Q_PRIMITIVE_TYPE);
 
class Q_GUI_EXPORT QTextDocumentPrivate : public QObjectPrivate
{
    Q_DECLARE_PUBLIC(QTextDocument)
public:
    typedef QFragmentMap<QTextFragmentData> FragmentMap;
    typedef FragmentMap::ConstIterator FragmentIterator;
    typedef QFragmentMap<QTextBlockData> BlockMap;
 
    QTextDocumentPrivate();
    ~QTextDocumentPrivate();
 
    void init();
    void clear();
 
    void setLayout(QAbstractTextDocumentLayout *layout);
 
    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(QChar blockSeparator, int pos, int blockFormat, int charFormat,
                     QTextUndoCommand::Operation op = QTextUndoCommand::MoveCursor);
 
    void move(int from, int to, int length, QTextUndoCommand::Operation = QTextUndoCommand::MoveCursor);
    void remove(int pos, int length, QTextUndoCommand::Operation = QTextUndoCommand::MoveCursor);
 
    void aboutToRemoveCell(int cursorFrom, int cursorEnd);
 
    QTextFrame *insertFrame(int start, int end, const QTextFrameFormat &format);
    void removeFrame(QTextFrame *frame);
 
    enum FormatChangeMode { MergeFormat, SetFormat, SetFormatAndPreserveObjectIndices };
 
    void setCharFormat(int pos, int length, const QTextCharFormat &newFormat, FormatChangeMode mode = SetFormat);
    void setBlockFormat(const QTextBlock &from, const QTextBlock &to,
                        const QTextBlockFormat &newFormat, FormatChangeMode mode = SetFormat);
 
    void emitUndoAvailable(bool available);
    void emitRedoAvailable(bool available);
 
    int undoRedo(bool undo);
    inline void undo() { undoRedo(true); }
    inline void redo() { undoRedo(false); }
    void appendUndoItem(QAbstractUndoItem *);
    inline void beginEditBlock() { if (0 == editBlock++) ++revision; }
    void joinPreviousEditBlock();
    void endEditBlock();
    void finishEdit();
    inline bool isInEditBlock() const { return editBlock; }
    void enableUndoRedo(bool enable);
    inline bool isUndoRedoEnabled() const { return undoEnabled; }
 
    inline bool isUndoAvailable() const { return undoEnabled && undoState > 0; }
    inline bool isRedoAvailable() const { return undoEnabled && undoState < undoStack.size(); }
 
    inline int availableUndoSteps() const { return undoEnabled ? undoState : 0; }
    inline int availableRedoSteps() const { return undoEnabled ? qMax(undoStack.size() - undoState - 1, 0) : 0; }
 
    inline QString buffer() const { return text; }
    QString plainText() const;
    inline int length() const { return fragments.length(); }
 
    inline QTextFormatCollection *formatCollection() { return &formats; }
    inline const QTextFormatCollection *formatCollection() const { return &formats; }
    inline QAbstractTextDocumentLayout *layout() const { return lout; }
 
    inline FragmentIterator find(int pos) const { return fragments.find(pos); }
    inline FragmentIterator begin() const { return fragments.begin(); }
    inline FragmentIterator end() const { return fragments.end(); }
 
    inline QTextBlock blocksBegin() const { return QTextBlock(const_cast<QTextDocumentPrivate *>(this), blocks.firstNode()); }
    inline QTextBlock blocksEnd() const { return QTextBlock(const_cast<QTextDocumentPrivate *>(this), 0); }
    inline QTextBlock blocksFind(int pos) const { return QTextBlock(const_cast<QTextDocumentPrivate *>(this), blocks.findNode(pos)); }
    int blockCharFormatIndex(int node) const;
 
    inline int numBlocks() const { return blocks.numNodes(); }
 
    const BlockMap &blockMap() const { return blocks; }
    const FragmentMap &fragmentMap() const { return fragments; }
    BlockMap &blockMap() { return blocks; }
    FragmentMap &fragmentMap() { return fragments; }
 
    static const QTextBlockData *block(const QTextBlock &it) { return it.p->blocks.fragment(it.n); }
 
    int nextCursorPosition(int position, QTextLayout::CursorMode mode) const;
    int previousCursorPosition(int position, QTextLayout::CursorMode mode) const;
    int leftCursorPosition(int position) const;
    int rightCursorPosition(int position) const;
 
    void changeObjectFormat(QTextObject *group, int format);
 
    void setModified(bool m);
    inline bool isModified() const { return modified; }
 
    inline QFont defaultFont() const { return formats.defaultFont(); }
    inline void setDefaultFont(const QFont &f) { formats.setDefaultFont(f); }
 
    void clearUndoRedoStacks(QTextDocument::Stacks stacksToClear, bool emitSignals = false);
 
private:
    bool split(int pos);
    bool unite(uint f);
 
    void insert_string(int pos, uint strPos, uint length, int format, QTextUndoCommand::Operation op);
    int insert_block(int pos, uint strPos, int format, int blockformat, QTextUndoCommand::Operation op, int command);
    int remove_string(int pos, uint length, QTextUndoCommand::Operation op);
    int remove_block(int pos, int *blockformat, int command, QTextUndoCommand::Operation op);
 
    void insert_frame(QTextFrame *f);
    void scan_frames(int pos, int charsRemoved, int charsAdded);
    static void clearFrame(QTextFrame *f);
 
    void adjustDocumentChangesAndCursors(int from, int addedOrRemoved, QTextUndoCommand::Operation op);
 
    bool wasUndoAvailable;
    bool wasRedoAvailable;
 
public:
    void documentChange(int from, int length);
 
    void addCursor(QTextCursorPrivate *c);
    void removeCursor(QTextCursorPrivate *c);
 
    QTextFrame *frameAt(int pos) const;
    QTextFrame *rootFrame() const;
 
    QTextObject *objectForIndex(int objectIndex) const;
    QTextObject *objectForFormat(int formatIndex) const;
    QTextObject *objectForFormat(const QTextFormat &f) const;
 
    QTextObject *createObject(const QTextFormat &newFormat, int objectIndex = -1);
    void deleteObject(QTextObject *object);
 
    QTextDocument *document() { return q_func(); }
    const QTextDocument *document() const { return q_func(); }
 
    bool ensureMaximumBlockCount();
 
    static inline const QTextDocumentPrivate *get(const QTextDocument *document)
    {
        return document->d_func();
    }
 
    static inline QTextDocumentPrivate *get(QTextDocument *document)
    {
        return document->d_func();
    }
 
    static inline QTextDocumentPrivate *get(QTextBlock &block)
    {
        return block.p;
    }
 
    static inline const QTextDocumentPrivate *get(const QTextBlock &block)
    {
        return block.p;
    }
 
    static inline QTextDocumentPrivate *get(QTextObject *object)
    {
        return get(object->document());
    }
 
    static inline const QTextDocumentPrivate *get(const QTextObject *object)
    {
        return get(object->document());
    }
 
    bool canLayout() const { return layoutEnabled && !pageSize.isNull(); }
 
private:
    QTextDocumentPrivate(const QTextDocumentPrivate& m);
    QTextDocumentPrivate& operator= (const QTextDocumentPrivate& m);
 
    void appendUndoItem(const QTextUndoCommand &c);
 
    void contentsChanged();
 
    void compressPieceTable();
 
    QString text;
    uint unreachableCharacterCount;
 
    QList<QTextUndoCommand> undoStack;
    bool undoEnabled;
    int undoState;
    int revision;
    // position in undo stack of the last setModified(false) call
    int modifiedState;
    bool modified;
 
    int editBlock;
    int editBlockCursorPosition;
    int docChangeFrom;
    int docChangeOldLength;
    int docChangeLength;
    bool framesDirty;
 
    QTextFormatCollection formats;
    mutable QTextFrame *rtFrame;
    QAbstractTextDocumentLayout *lout;
    FragmentMap fragments;
    BlockMap blocks;
    int initialBlockCharFormatIndex;
 
    QSet<QTextCursorPrivate *> cursors;
    QMap<int, QTextObject *> objects;
    QMap<QUrl, QVariant> resources;
    QMap<QUrl, QVariant> cachedResources;
    QTextDocument::ResourceProvider resourceProvider;
    QString defaultStyleSheet;
 
    int lastBlockCount;
 
public:
    bool inContentsChange;
    bool layoutEnabled = true;
    QTextOption defaultTextOption;
    Qt::CursorMoveStyle defaultCursorMoveStyle;
#ifndef QT_NO_CSSPARSER
    QCss::StyleSheet parsedDefaultStyleSheet;
#endif
    int maximumBlockCount;
    uint needsEnsureMaximumBlockCount : 1;
    uint blockCursorAdjustment : 1;
    QSizeF pageSize;
    QString title;
    QString url;
    QString cssMedia;
    qreal indentWidth;
    qreal documentMargin;
    QUrl baseUrl;
 
    void mergeCachedResources(const QTextDocumentPrivate *priv);
 
    friend struct QTextHtmlParserNode;
    friend class QTextHtmlExporter;
    friend class QTextCursor;
};
 
class QTextTable;
class QTextHtmlExporter
{
public:
    QTextHtmlExporter(const QTextDocument *_doc);
 
    enum ExportMode {
        ExportEntireDocument,
        ExportFragment
    };
 
    QString toHtml(ExportMode mode = ExportEntireDocument);
 
private:
    enum StyleMode { EmitStyleTag, OmitStyleTag };
    enum FrameType { TextFrame, TableFrame, RootFrame };
 
    void emitFrame(const QTextFrame::Iterator &frameIt);
    void emitTextFrame(const QTextFrame *frame);
    void emitBlock(const QTextBlock &block);
    void emitTable(const QTextTable *table);
    void emitFragment(const QTextFragment &fragment);
 
    void emitBlockAttributes(const QTextBlock &block);
    bool emitCharFormatStyle(const QTextCharFormat &format);
    void emitTextLength(const char *attribute, const QTextLength &length);
    void emitAlignment(Qt::Alignment alignment);
    void emitFloatStyle(QTextFrameFormat::Position pos, StyleMode mode = EmitStyleTag);
    void emitMargins(const QString &top, const QString &bottom, const QString &left, const QString &right);
    void emitAttribute(const char *attribute, const QString &value);
    void emitFrameStyle(const QTextFrameFormat &format, FrameType frameType);
    void emitBorderStyle(QTextFrameFormat::BorderStyle style);
    void emitPageBreakPolicy(QTextFormat::PageBreakFlags policy);
 
    void emitFontFamily(const QStringList &families);
 
    void emitBackgroundAttribute(const QTextFormat &format);
    QString findUrlForImage(const QTextDocument *doc, qint64 cacheKey, bool isPixmap);
 
    QString html;
    QTextCharFormat defaultCharFormat;
    const QTextDocument *doc;
    bool fragmentMarkers;
    QStringList closingTags;
};
 
QT_END_NAMESPACE
 
#endif // QTEXTDOCUMENT_P_H