/****************************************************************************

**

** Copyright (C) 1992-2007 Trolltech ASA. All rights reserved.

**

** This file is part of the Qt3Support module of the Qt Toolkit.

**

** This file may be used under the terms of the GNU General Public

** License version 2.0 as published by the Free Software Foundation

** and appearing in the file LICENSE.GPL included in the packaging of

** this file.  Please review the following information to ensure GNU

** General Public Licensing requirements will be met:

** http://trolltech.com/products/qt/licenses/licensing/opensource/

**

** If you are unsure which license is appropriate for your use, please

** review the following information:

** http://trolltech.com/products/qt/licenses/licensing/licensingoverview

** or contact the sales department at sales@trolltech.com.

**

** In addition, as a special exception, Trolltech gives you certain

** additional rights. These rights are described in the Trolltech GPL

** Exception version 1.0, which can be found at

** http://www.trolltech.com/products/qt/gplexception/ and in the file

** GPL_EXCEPTION.txt in this package.

**

** In addition, as a special exception, Trolltech, as the sole copyright

** holder for Qt Designer, grants users of the Qt/Eclipse Integration

** plug-in the right for the Qt/Eclipse Integration to link to

** functionality provided by Qt Designer and its related libraries.

**

** Trolltech reserves all rights not expressly granted herein.

** 

** Trolltech ASA (c) 2007

**

** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE

** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

**

****************************************************************************/

#ifndef Q3RICHTEXT_P_H

#define Q3RICHTEXT_P_H

//

//  W A R N I N G

//  -------------

//

// This file is not part of the Qt API.  It exists for the convenience

// of a number of Qt sources files.  This header file may change from

// version to version without notice, or even be removed.

//

// We mean it.

//

#include "QtGui/qapplication.h"

#include "QtGui/qcolor.h"

#include "QtCore/qhash.h"

#include "QtGui/qfont.h"

#include "QtGui/qfontmetrics.h"

#include "QtGui/qlayout.h"

#include "QtCore/qmap.h"

#include "QtCore/qvector.h"

#include "QtCore/qstack.h"

#include "QtCore/qlist.h"

#include "QtCore/qobject.h"

#include "QtGui/qpainter.h"

#include "QtGui/qpixmap.h"

#include "QtCore/qrect.h"

#include "QtCore/qsize.h"

#include "QtCore/qstring.h"

#include "QtCore/qstringlist.h"

#include "Qt3Support/q3stylesheet.h"

#include "Qt3Support/q3mimefactory.h"

#ifndef QT_NO_RICHTEXT

class Q3TextDocument;

class Q3TextString;

class Q3TextPreProcessor;

class Q3TextFormat;

class Q3TextCursor;

class Q3TextParagraph;

class Q3TextFormatter;

class Q3TextIndent;

class Q3TextFormatCollection;

class Q3StyleSheetItem;

#ifndef QT_NO_TEXTCUSTOMITEM

class Q3TextCustomItem;

#endif

class Q3TextFlow;

struct QBidiContext;

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

class Q_COMPAT_EXPORT Q3TextStringChar

{

    friend class Q3TextString;

public:

    // this is never called, initialize variables in Q3TextString::insert()!!!

    Q3TextStringChar() : nobreak(false), lineStart(0), type(Regular) {p.format=0;}

    ~Q3TextStringChar();

    struct CustomData

    {

        Q3TextFormat *format;

#ifndef QT_NO_TEXTCUSTOMITEM

        Q3TextCustomItem *custom;

#endif

        QString anchorName;

        QString anchorHref;

    };

    enum Type { Regular=0, Custom=1, Anchor=2, CustomAnchor=3 };

    QChar c;

    // this is the same struct as in qtextengine_p.h. Don't change!

    uchar softBreak      :1;     // Potential linebreak point

    uchar whiteSpace     :1;     // A unicode whitespace character, except NBSP, ZWNBSP

    uchar charStop       :1;     // Valid cursor position (for left/right arrow)

    uchar nobreak        :1;

    uchar lineStart : 1;

    uchar /*Type*/ type : 2;

    uchar bidiLevel       :7;

    uchar rightToLeft : 1;

    int x;

    union {

        Q3TextFormat* format;

        CustomData* custom;

    } p;

    int height() const;

    int ascent() const;

    int descent() const;

    bool isCustom() const { return (type & Custom) != 0; }

    Q3TextFormat *format() const;

#ifndef QT_NO_TEXTCUSTOMITEM

    Q3TextCustomItem *customItem() const;

#endif

    void setFormat(Q3TextFormat *f);

#ifndef QT_NO_TEXTCUSTOMITEM

    void setCustomItem(Q3TextCustomItem *i);

#endif

#ifndef QT_NO_TEXTCUSTOMITEM

    void loseCustomItem();

#endif

    bool isAnchor() const { return (type & Anchor) != 0; }

    bool isLink() const { return isAnchor() && p.custom->anchorHref.count(); }

    QString anchorName() const;

    QString anchorHref() const;

    void setAnchor(const QString& name, const QString& href);

    Q3TextStringChar(const Q3TextStringChar &) {

        Q_ASSERT(false);

    }

private:

    Q3TextStringChar &operator=(const Q3TextStringChar &) {

        //abort();

        return *this;

    }

    friend class Q3TextParagraph;

};

Q_DECLARE_TYPEINFO(Q3TextStringChar, Q_PRIMITIVE_TYPE);

class Q_COMPAT_EXPORT Q3TextString

{

public:

    Q3TextString();

    Q3TextString(const Q3TextString &s);

    virtual ~Q3TextString();

    static QString toString(const QVector<Q3TextStringChar> &data);

    QString toString() const;

    inline Q3TextStringChar &at(int i) const {

        return const_cast<Q3TextString *>(this)->data[i];

    }

    inline int length() const { return data.size(); }

    int width(int idx) const;

    void insert(int index, const QString &s, Q3TextFormat *f);

    void insert(int index, const QChar *unicode, int len, Q3TextFormat *f);

    void insert(int index, Q3TextStringChar *c, bool doAddRefFormat = false);

    void truncate(int index);

    void remove(int index, int len);

    void clear();

    void setFormat(int index, Q3TextFormat *f, bool useCollection);

    void setBidi(bool b) { bidi = b; }

    bool isBidi() const;

    bool isRightToLeft() const;

    QChar::Direction direction() const;

    void setDirection(QChar::Direction dr) { rightToLeft = (dr == QChar::DirR); bidiDirty = true; }

    QVector<Q3TextStringChar> rawData() const { return data; }

    void operator=(const QString &s) { clear(); insert(0, s, 0); }

    void operator+=(const QString &s) { insert(length(), s, 0); }

    void prepend(const QString &s) { insert(0, s, 0); }

    int appendParagraphs( Q3TextParagraph *start, Q3TextParagraph *end );

    // return next and previous valid cursor positions.

    bool validCursorPosition(int idx);

    int nextCursorPosition(int idx);

    int previousCursorPosition(int idx);

private:

    void checkBidi() const;

    QVector<Q3TextStringChar> data;

    QString stringCache;

    uint bidiDirty : 1;

    uint bidi : 1; // true when the paragraph has right to left characters

    uint rightToLeft : 1;

};

inline bool Q3TextString::isBidi() const

{

    if (bidiDirty)

        checkBidi();

    return bidi;

}

inline bool Q3TextString::isRightToLeft() const

{

    if (bidiDirty)

        checkBidi();

    return rightToLeft;

}

inline QString Q3TextString::toString() const

{

    if (bidiDirty)

        checkBidi();

    return stringCache;

}

inline QChar::Direction Q3TextString::direction() const

{

    return rightToLeft ? QChar::DirR : QChar::DirL;

}

inline int Q3TextString::nextCursorPosition(int next)

{

    if (bidiDirty)

        checkBidi();

    const Q3TextStringChar *c = data.data();

    int len = length();

    if (next < len - 1) {

        next++;

        while (next < len - 1 && !c[next].charStop)

            next++;

    }

    return next;

}

inline int Q3TextString::previousCursorPosition(int prev)

{

    if (bidiDirty)

        checkBidi();

    const Q3TextStringChar *c = data.data();

    if (prev) {

        prev--;

        while (prev && !c[prev].charStop)

            prev--;

    }

    return prev;

}

inline bool Q3TextString::validCursorPosition(int idx)

{

    if (bidiDirty)

        checkBidi();

    return (at(idx).charStop);

}

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

class Q_COMPAT_EXPORT Q3TextCursor

{

public:

    Q3TextCursor(Q3TextDocument * = 0);

    Q3TextCursor(const Q3TextCursor &c);

    Q3TextCursor &operator=(const Q3TextCursor &c);

    virtual ~Q3TextCursor();

    bool operator==(const Q3TextCursor &c) const;

    bool operator!=(const Q3TextCursor &c) const { return !(*this == c); }

    inline Q3TextParagraph *paragraph() const { return para; }

    Q3TextDocument *document() const;

    int index() const;

    void gotoPosition(Q3TextParagraph* p, int index = 0);

    void setIndex(int index) { gotoPosition(paragraph(), index); }

    void setParagraph(Q3TextParagraph*p) { gotoPosition(p, 0); }

    void gotoLeft();

    void gotoRight();

    void gotoNextLetter();

    void gotoPreviousLetter();

    void gotoUp();

    void gotoDown();

    void gotoLineEnd();

    void gotoLineStart();

    void gotoHome();

    void gotoEnd();

    void gotoPageUp(int visibleHeight);

    void gotoPageDown(int visibleHeight);

    void gotoNextWord(bool onlySpace = false);

    void gotoPreviousWord(bool onlySpace = false);

    void gotoWordLeft();

    void gotoWordRight();

    void insert(const QString &s, bool checkNewLine, QVector<Q3TextStringChar> *formatting = 0);

    void splitAndInsertEmptyParagraph(bool ind = true, bool updateIds = true);

    bool remove();

    bool removePreviousChar();

    void indent();

    bool atParagStart();

    bool atParagEnd();

    int x() const; // x in current paragraph

    int y() const; // y in current paragraph

    int globalX() const;

    int globalY() const;

    Q3TextParagraph *topParagraph() const { return paras.isEmpty() ? para : paras.first(); }

    int offsetX() const { return ox; } // inner document  offset

    int offsetY() const { return oy; } // inner document offset

    int totalOffsetX() const; // total document offset

    int totalOffsetY() const; // total document offset

    bool place(const QPoint &pos, Q3TextParagraph *s) { return place(pos, s, false); }

    bool place(const QPoint &pos, Q3TextParagraph *s, bool link);

    void restoreState();

    int nestedDepth() const { return (int)indices.count(); } //### size_t/int cast

    void oneUp() { if (!indices.isEmpty()) pop(); }

    void setValid(bool b) { valid = b; }

    bool isValid() const { return valid; }

    void fixCursorPosition();

private:

    enum Operation { EnterBegin, EnterEnd, Next, Prev, Up, Down };

    void push();

    void pop();

    bool processNesting(Operation op);

    void invalidateNested();

    void gotoIntoNested(const QPoint &globalPos);

    Q3TextParagraph *para;

    int idx, tmpX;

    int ox, oy;

    QStack<int> indices;

    QStack<Q3TextParagraph*> paras;

    QStack<int> xOffsets;

    QStack<int> yOffsets;

    uint valid : 1;

};

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

class Q_COMPAT_EXPORT Q3TextCommand

{

public:

    enum Commands { Invalid, Insert, Delete, Format, Style };

    Q3TextCommand(Q3TextDocument *dc) : doc(dc), cursor(dc) {}

    virtual ~Q3TextCommand();

    virtual Commands type() const;

    virtual Q3TextCursor *execute(Q3TextCursor *c) = 0;

    virtual Q3TextCursor *unexecute(Q3TextCursor *c) = 0;

protected:

    Q3TextDocument *doc;

    Q3TextCursor cursor;

};

class Q_COMPAT_EXPORT Q3TextCommandHistory

{

public:

    Q3TextCommandHistory(int s) : current(-1), steps(s) {  }

    virtual ~Q3TextCommandHistory(); // ### why is it virtual?

    void clear();

    void addCommand(Q3TextCommand *cmd);

    Q3TextCursor *undo(Q3TextCursor *c);

    Q3TextCursor *redo(Q3TextCursor *c);

    bool isUndoAvailable();

    bool isRedoAvailable();

    void setUndoDepth(int depth) { steps = depth; }

    int undoDepth() const { return steps; }

    int historySize() const { return history.count(); }

    int currentPosition() const { return current; }

private:

    QList<Q3TextCommand *> history;

    int current, steps;

};

inline Q3TextCommandHistory::~Q3TextCommandHistory()

{

    clear();

}

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

#ifndef QT_NO_TEXTCUSTOMITEM

class Q_COMPAT_EXPORT Q3TextCustomItem

{

public:

    Q3TextCustomItem(Q3TextDocument *p)

        :  xpos(0), ypos(-1), width(-1), height(0), parent(p)

    {}

    virtual ~Q3TextCustomItem();

    virtual void draw(QPainter* p, int x, int y, int cx, int cy, int cw, int ch,

                      const QPalette &pal, bool selected) = 0;

    virtual void adjustToPainter(QPainter*);

    enum Placement { PlaceInline = 0, PlaceLeft, PlaceRight };

    virtual Placement placement() const;

    bool placeInline() { return placement() == PlaceInline; }

    virtual bool ownLine() const;

    virtual void resize(int nwidth);

    virtual void invalidate();

    virtual int ascent() const { return height; }

    virtual bool isNested() const;

    virtual int minimumWidth() const;

    virtual QString richText() const;

    int xpos; // used for floating items

    int ypos; // used for floating items

    int width;

    int height;

    QRect geometry() const { return QRect(xpos, ypos, width, height); }

    virtual bool enter(Q3TextCursor *, Q3TextDocument *&doc, Q3TextParagraph *&parag, int &idx, int &ox, int &oy, bool atEnd = false);

    virtual bool enterAt(Q3TextCursor *, Q3TextDocument *&doc, Q3TextParagraph *&parag, int &idx, int &ox, int &oy, const QPoint &);

    virtual bool next(Q3TextCursor *, Q3TextDocument *&doc, Q3TextParagraph *&parag, int &idx, int &ox, int &oy);

    virtual bool prev(Q3TextCursor *, Q3TextDocument *&doc, Q3TextParagraph *&parag, int &idx, int &ox, int &oy);

    virtual bool down(Q3TextCursor *, Q3TextDocument *&doc, Q3TextParagraph *&parag, int &idx, int &ox, int &oy);

    virtual bool up(Q3TextCursor *, Q3TextDocument *&doc, Q3TextParagraph *&parag, int &idx, int &ox, int &oy);

    void setParagraph(Q3TextParagraph *p) { parag = p; }

    Q3TextParagraph *paragraph() const { return parag; }

    Q3TextDocument *parent;

    Q3TextParagraph *parag;

    virtual void pageBreak(int  y, Q3TextFlow* flow);

};

#endif

#ifndef QT_NO_TEXTCUSTOMITEM

class Q_COMPAT_EXPORT Q3TextImage : public Q3TextCustomItem

{

public:

    Q3TextImage(Q3TextDocument *p, const QMap<QString, QString> &attr, const QString& context,

                Q3MimeSourceFactory &factory);

    virtual ~Q3TextImage();

    Placement placement() const { return place; }

    void adjustToPainter(QPainter*);

    int minimumWidth() const { return width; }

    QString richText() const;

    void draw(QPainter* p, int x, int y, int cx, int cy, int cw, int ch,

               const QPalette &pal, bool selected);

private:

    QRegion* reg;

    QPixmap pm;

    Placement place;

    int tmpwidth, tmpheight;

    QMap<QString, QString> attributes;

    QString imgId;

};

#endif

#ifndef QT_NO_TEXTCUSTOMITEM

class Q_COMPAT_EXPORT Q3TextHorizontalLine : public Q3TextCustomItem

{

public:

    Q3TextHorizontalLine(Q3TextDocument *p, const QMap<QString, QString> &attr, const QString& context,

                         Q3MimeSourceFactory &factory);

    virtual ~Q3TextHorizontalLine();

    void adjustToPainter(QPainter*);

    void draw(QPainter* p, int x, int y, int cx, int cy, int cw, int ch,

              const QPalette &pal, bool selected);

    QString richText() const;

    bool ownLine() const { return true; }

private:

    int tmpheight;

    QColor color;

    bool shade;

};

#endif

class Q_COMPAT_EXPORT Q3TextFlow

{

    friend class Q3TextDocument;

#ifndef QT_NO_TEXTCUSTOMITEM

    friend class Q3TextTableCell;

#endif

public:

    Q3TextFlow();

    virtual ~Q3TextFlow();

    virtual void setWidth(int width);

    int width() const;

    virtual void setPageSize(int ps);

    int pageSize() const { return pagesize; }

    virtual int adjustLMargin(int yp, int h, int margin, int space);

    virtual int adjustRMargin(int yp, int h, int margin, int space);

#ifndef QT_NO_TEXTCUSTOMITEM

    virtual void registerFloatingItem(Q3TextCustomItem* item);

    virtual void unregisterFloatingItem(Q3TextCustomItem* item);

#endif

    virtual QRect boundingRect() const;

    virtual void drawFloatingItems(QPainter* p, int cx, int cy, int cw, int ch,

                                   const QPalette &pal, bool selected);

    virtual int adjustFlow(int  y, int w, int h); // adjusts y according to the defined pagesize. Returns the shift.

    virtual bool isEmpty();

    void clear();

private:

    int w;

    int pagesize;

#ifndef QT_NO_TEXTCUSTOMITEM

    QList<Q3TextCustomItem *> leftItems;

    QList<Q3TextCustomItem *> rightItems;

#endif

};

inline int Q3TextFlow::width() const { return w; }

#ifndef QT_NO_TEXTCUSTOMITEM

class Q3TextTable;

class Q_COMPAT_EXPORT Q3TextTableCell : public QLayoutItem

{

    friend class Q3TextTable;

public:

    Q3TextTableCell(Q3TextTable* table,

                    int row, int column,

                    const QMap<QString, QString> &attr,

                    const Q3StyleSheetItem* style,

                    const Q3TextFormat& fmt, const QString& context,

                    Q3MimeSourceFactory &factory, Q3StyleSheet *sheet, const QString& doc);

    virtual ~Q3TextTableCell();

    QSize sizeHint() const ;

    QSize minimumSize() const ;

    QSize maximumSize() const ;

    Qt::Orientations expandingDirections() const;

    bool isEmpty() const;

    void setGeometry(const QRect&) ;

    QRect geometry() const;

    bool hasHeightForWidth() const;

    int heightForWidth(int) const;

    void adjustToPainter(QPainter*);

    int row() const { return row_; }

    int column() const { return col_; }

    int rowspan() const { return rowspan_; }

    int colspan() const { return colspan_; }

    int stretch() const { return stretch_; }

    Q3TextDocument* richText()  const { return richtext; }

    Q3TextTable* table() const { return parent; }

    void draw(QPainter* p, int x, int y, int cx, int cy, int cw, int ch,

               const QPalette &cg, bool selected);

    QBrush *backGround() const { return background; }

    virtual void invalidate();

    int verticalAlignmentOffset() const;

    int horizontalAlignmentOffset() const;

private:

    QRect geom;

    Q3TextTable* parent;

    Q3TextDocument* richtext;

    int row_;

    int col_;

    int rowspan_;

    int colspan_;

    int stretch_;

    int maxw;

    int minw;

    bool hasFixedWidth;

    QBrush *background;

    int cached_width;

    int cached_sizehint;

    QMap<QString, QString> attributes;

    int align;

};

#endif

#ifndef QT_NO_TEXTCUSTOMITEM

class Q_COMPAT_EXPORT Q3TextTable: public Q3TextCustomItem

{

    friend class Q3TextTableCell;

public:

    Q3TextTable(Q3TextDocument *p, const QMap<QString, QString> &attr);

    virtual ~Q3TextTable();

    void adjustToPainter(QPainter *p);

    void pageBreak(int  y, Q3TextFlow* flow);

    void draw(QPainter* p, int x, int y, int cx, int cy, int cw, int ch,

               const QPalette &pal, bool selected);

    bool noErase() const { return true; }

    bool ownLine() const { return true; }

    Placement placement() const { return place; }

    bool isNested() const { return true; }

    void resize(int nwidth);

    virtual void invalidate();

    virtual bool enter(Q3TextCursor *c, Q3TextDocument *&doc, Q3TextParagraph *&parag, int &idx, int &ox, int &oy, bool atEnd = false);

    virtual bool enterAt(Q3TextCursor *c, Q3TextDocument *&doc, Q3TextParagraph *&parag, int &idx, int &ox, int &oy, const QPoint &pos);

    virtual bool next(Q3TextCursor *c, Q3TextDocument *&doc, Q3TextParagraph *&parag, int &idx, int &ox, int &oy);

    virtual bool prev(Q3TextCursor *c, Q3TextDocument *&doc, Q3TextParagraph *&parag, int &idx, int &ox, int &oy);

    virtual bool down(Q3TextCursor *c, Q3TextDocument *&doc, Q3TextParagraph *&parag, int &idx, int &ox, int &oy);

    virtual bool up(Q3TextCursor *c, Q3TextDocument *&doc, Q3TextParagraph *&parag, int &idx, int &ox, int &oy);

    QString richText() const;

    int minimumWidth() const;

    QList<Q3TextTableCell *> tableCells() const { return cells; }

    bool isStretching() const { return stretch; }

private:

    void format(int w);

    void addCell(Q3TextTableCell* cell);

private:

    QGridLayout* layout;

    QList<Q3TextTableCell *> cells;

    int cachewidth;

    int fixwidth;

    int cellpadding;

    int cellspacing;

    int border;

    int outerborder;

    int stretch;

    int innerborder;

    int us_cp, us_ib, us_b, us_ob, us_cs;

    int us_fixwidth;

    QMap<QString, QString> attributes;

    QMap<Q3TextCursor*, int> currCell;

    Placement place;

    void adjustCells(int y , int shift);

    int pageBreakFor;

};

#endif

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

#ifndef QT_NO_TEXTCUSTOMITEM

class Q3TextTableCell;

class Q3TextParagraph;

#endif

struct Q_COMPAT_EXPORT Q3TextDocumentSelection

{

    Q3TextCursor startCursor, endCursor;

    bool swapped;

    Q_DUMMY_COMPARISON_OPERATOR(Q3TextDocumentSelection)

};

class Q_COMPAT_EXPORT Q3TextDocument : public QObject

{

    Q_OBJECT

#ifndef QT_NO_TEXTCUSTOMITEM

    friend class Q3TextTableCell;

#endif

    friend class Q3TextCursor;

    friend class Q3TextEdit;

    friend class Q3TextParagraph;

public:

    enum SelectionIds {

        Standard = 0,

        Temp = 32000 // This selection must not be drawn, it's used e.g. by undo/redo to

        // remove multiple lines with removeSelectedText()

    };

    Q3TextDocument(Q3TextDocument *p);

    virtual ~Q3TextDocument();

    Q3TextDocument *parent() const { return par; }

    Q3TextParagraph *parentParagraph() const { return parentPar; }

    void setText(const QString &text, const QString &context);

    QMap<QString, QString> attributes() const { return attribs; }

    void setAttributes(const QMap<QString, QString> &attr) { attribs = attr; }

    QString text() const;

    QString text(int parag) const;

    QString originalText() const;

    int x() const;

    int y() const;

    int width() const;

    int widthUsed() const;

    int visibleWidth() const;

    int height() const;

    void setWidth(int w);

    int minimumWidth() const;

    bool setMinimumWidth(int needed, int used = -1, Q3TextParagraph *parag = 0);

    void setY(int y);

    int leftMargin() const;

    void setLeftMargin(int lm);

    int rightMargin() const;

    void setRightMargin(int rm);

    Q3TextParagraph *firstParagraph() const;

    Q3TextParagraph *lastParagraph() const;

    void setFirstParagraph(Q3TextParagraph *p);

    void setLastParagraph(Q3TextParagraph *p);

    void invalidate();

    void setPreProcessor(Q3TextPreProcessor *sh);

    Q3TextPreProcessor *preProcessor() const;

    void setFormatter(Q3TextFormatter *f);

    Q3TextFormatter *formatter() const;

    void setIndent(Q3TextIndent *i);

    Q3TextIndent *indent() const;

    QColor selectionColor(int id) const;

    QColor selectionTextColor(int id) const;

    bool hasSelectionTextColor(int id) const;

    void setSelectionColor(int id, const QColor &c);

    void setSelectionTextColor(int id, const QColor &b);

    bool hasSelection(int id, bool visible = false) const;

    void setSelectionStart(int id, const Q3TextCursor &cursor);

    bool setSelectionEnd(int id, const Q3TextCursor &cursor);

    void selectAll(int id);

    bool removeSelection(int id);

    void selectionStart(int id, int &paragId, int &index);

    Q3TextCursor selectionStartCursor(int id);

    Q3TextCursor selectionEndCursor(int id);

    void selectionEnd(int id, int &paragId, int &index);

    void setFormat(int id, Q3TextFormat *f, int flags);

    int numSelections() const { return nSelections; }

    void addSelection(int id);

    QString selectedText(int id, bool asRichText = false) const;

    void removeSelectedText(int id, Q3TextCursor *cursor);

    void indentSelection(int id);

    Q3TextParagraph *paragAt(int i) const;

    void addCommand(Q3TextCommand *cmd);

    Q3TextCursor *undo(Q3TextCursor *c = 0);

    Q3TextCursor *redo(Q3TextCursor *c  = 0);

    Q3TextCommandHistory *commands() const { return commandHistory; }

    Q3TextFormatCollection *formatCollection() const;

    bool find(Q3TextCursor &cursor, const QString &expr, bool cs, bool wo, bool forward);

    void setTextFormat(Qt::TextFormat f);

    Qt::TextFormat textFormat() const;

    bool inSelection(int selId, const QPoint &pos) const;

    Q3StyleSheet *styleSheet() const { return sheet_; }

#ifndef QT_NO_MIME

    Q3MimeSourceFactory *mimeSourceFactory() const { return factory_; }

#endif

    QString context() const { return contxt; }

    void setStyleSheet(Q3StyleSheet *s);

    void setDefaultFormat(const QFont &font, const QColor &color);

#ifndef QT_NO_MIME

    void setMimeSourceFactory(Q3MimeSourceFactory *f) { if (f) factory_ = f; }

#endif

    void setContext(const QString &c) { if (!c.isEmpty()) contxt = c; }

    void setUnderlineLinks(bool b);

    bool underlineLinks() const { return underlLinks; }

    void setPaper(QBrush *brush) { if (backBrush) delete backBrush; backBrush = brush; }

    QBrush *paper() const { return backBrush; }

    void doLayout(QPainter *p, int w);

    void draw(QPainter *p, const QRect& rect, const QPalette &pal, const QBrush *paper = 0);

    void drawParagraph(QPainter *p, Q3TextParagraph *parag, int cx, int cy, int cw, int ch,

                    QPixmap *&doubleBuffer, const QPalette &pal,

                    bool drawCursor, Q3TextCursor *cursor, bool resetChanged = true);

    Q3TextParagraph *draw(QPainter *p, int cx, int cy, int cw, int ch, const QPalette &pal,

                      bool onlyChanged = false, bool drawCursor = false, Q3TextCursor *cursor = 0,

                      bool resetChanged = true);

#ifndef QT_NO_TEXTCUSTOMITEM

    static Q3TextCustomItem* tag(Q3StyleSheet *sheet, const QString& name,

                                 const QMap<QString, QString> &attr,

                                 const QString& context,

                                 const Q3MimeSourceFactory& factory,

                                 bool emptyTag, Q3TextDocument *doc);

#endif

#ifndef QT_NO_TEXTCUSTOMITEM

    void registerCustomItem(Q3TextCustomItem *i, Q3TextParagraph *p);

    void unregisterCustomItem(Q3TextCustomItem *i, Q3TextParagraph *p);

#endif

    void setFlow(Q3TextFlow *f);

    void takeFlow();

    Q3TextFlow *flow() const { return flow_; }

    bool isPageBreakEnabled() const { return pages; }

    void setPageBreakEnabled(bool b) { pages = b; }

    void setUseFormatCollection(bool b) { useFC = b; }

    bool useFormatCollection() const { return useFC; }

#ifndef QT_NO_TEXTCUSTOMITEM

    Q3TextTableCell *tableCell() const { return tc; }

    void setTableCell(Q3TextTableCell *c) { tc = c; }

#endif

    void setPlainText(const QString &text);

    void setRichText(const QString &text, const QString &context, const Q3TextFormat *initialFormat = 0);

    QString richText() const;

    QString plainText() const;

    bool focusNextPrevChild(bool next);

    int alignment() const;

    void setAlignment(int a);

    int *tabArray() const;

    int tabStopWidth() const;

    void setTabArray(int *a);

    void setTabStops(int tw);

    void setUndoDepth(int depth) { commandHistory->setUndoDepth(depth); }

    int undoDepth() const { return commandHistory->undoDepth(); }

    int length() const;

    void clear(bool createEmptyParag = false);

    virtual Q3TextParagraph *createParagraph(Q3TextDocument *, Q3TextParagraph *pr = 0, Q3TextParagraph *nx = 0, bool updateIds = true);

    void insertChild(Q3TextDocument *dc) { childList.append(dc); }

    void removeChild(Q3TextDocument *dc) { childList.removeAll(dc); }

    QList<Q3TextDocument *> children() const { return childList; }

    bool hasFocusParagraph() const;

    QString focusHref() const;

    QString focusName() const;

    void invalidateOriginalText() { oTextValid = false; oText = QLatin1String(""); }

Q_SIGNALS:

    void minimumWidthChanged(int);

private:

    Q_DISABLE_COPY(Q3TextDocument)

    void init();

    QPixmap *bufferPixmap(const QSize &s);

    // HTML parser

    bool hasPrefix(const QChar* doc, int length, int pos, QChar c);

    bool hasPrefix(const QChar* doc, int length, int pos, const QString& s);

#ifndef QT_NO_TEXTCUSTOMITEM

    Q3TextCustomItem* parseTable(const QMap<QString, QString> &attr, const Q3TextFormat &fmt,

                                 const QChar* doc, int length, int& pos, Q3TextParagraph *curpar);

#endif

    bool eatSpace(const QChar* doc, int length, int& pos, bool includeNbsp = false);

    bool eat(const QChar* doc, int length, int& pos, QChar c);

    QString parseOpenTag(const QChar* doc, int length, int& pos, QMap<QString, QString> &attr, bool& emptyTag);

    QString parseCloseTag(const QChar* doc, int length, int& pos);

    QChar parseHTMLSpecialChar(const QChar* doc, int length, int& pos);

    QString parseWord(const QChar* doc, int length, int& pos, bool lower = true);

    QChar parseChar(const QChar* doc, int length, int& pos, Q3StyleSheetItem::WhiteSpaceMode wsm);

    void setRichTextInternal(const QString &text, Q3TextCursor* cursor = 0, const Q3TextFormat *initialFormat = 0);

    void setRichTextMarginsInternal(QList< QVector<Q3StyleSheetItem *> *>& styles, Q3TextParagraph* stylesPar);

    struct Q_COMPAT_EXPORT Focus {

        Q3TextParagraph *parag;

        int start, len;

        QString href;

        QString name;

    };

    int cx, cy, cw, vw;

    Q3TextParagraph *fParag, *lParag;

    Q3TextPreProcessor *pProcessor;

    struct SelectionColor {

        QColor background;

        QColor text;

    };

    QMap<int, SelectionColor> selectionColors;

    QMap<int, Q3TextDocumentSelection> selections;

    Q3TextCommandHistory *commandHistory;

    Q3TextFormatter *pFormatter;

    Q3TextIndent *indenter;

    Q3TextFormatCollection *fCollection;

    Qt::TextFormat txtFormat;

    uint preferRichText : 1;

    uint pages : 1;

    uint useFC : 1;

    uint withoutDoubleBuffer : 1;

    uint underlLinks : 1;

    uint nextDoubleBuffered : 1;

    uint oTextValid : 1;

    uint mightHaveCustomItems : 1;

    int align;

    int nSelections;

    Q3TextFlow *flow_;

    Q3TextDocument *par;

    Q3TextParagraph *parentPar;

#ifndef QT_NO_TEXTCUSTOMITEM

    Q3TextTableCell *tc;

#endif

    QBrush *backBrush;

    QPixmap *buf_pixmap;

    Focus focusIndicator;

    int minw;

    int wused;

    int leftmargin;

    int rightmargin;

    Q3TextParagraph *minwParag, *curParag;

    Q3StyleSheet* sheet_;

#ifndef QT_NO_MIME

    Q3MimeSourceFactory* factory_;

#endif

    QString contxt;

    QMap<QString, QString> attribs;

    int *tArray;

    int tStopWidth;

    int uDepth;

    QString oText;

    QList<Q3TextDocument *> childList;

    QColor linkColor, bodyText;

    double scaleFontsFactor;

    short list_tm,list_bm, list_lm, li_tm, li_bm, par_tm, par_bm;

};

// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

class Q_COMPAT_EXPORT Q3TextDeleteCommand : public Q3TextCommand

{

public:

    Q3TextDeleteCommand(Q3TextDocument *dc, int i, int idx, const QVector<Q3TextStringChar> &str,

                        const QByteArray& oldStyle);

    Q3TextDeleteCommand(Q3TextParagraph *p, int idx, const QVector<Q3TextStringChar> &str);

    virtual ~Q3TextDeleteCommand();

    Commands type() const { return Delete; }

    Q3TextCursor *execute(Q3TextCursor *c);

    Q3TextCursor *unexecute(Q3TextCursor *c);

protected:

    int id, index;

    Q3TextParagraph *parag;

    QVector<Q3TextStringChar> text;

    QByteArray styleInformation;

};

class Q_COMPAT_EXPORT Q3TextInsertCommand : public Q3TextDeleteCommand

{

public:

    Q3TextInsertCommand(Q3TextDocument *dc, int i, int idx, const QVector<Q3TextStringChar> &str,

                        const QByteArray& oldStyleInfo)

        : Q3TextDeleteCommand(dc, i, idx, str, oldStyleInfo) {}

    Q3TextInsertCommand(Q3TextParagraph *p, int idx, const QVector<Q3TextStringChar> &str)

        : Q3TextDeleteCommand(p, idx, str) {}

    virtual ~Q3TextInsertCommand() {}

    Commands type() const { return Insert; }

    Q3TextCursor *execute(Q3TextCursor *c) { return Q3TextDeleteCommand::unexecute(c); }

    Q3TextCursor *unexecute(Q3TextCursor *c) { return Q3TextDeleteCommand::execute(c); }

};

class Q_COMPAT_EXPORT Q3TextFormatCommand : public Q3TextCommand

{

public:

    Q3TextFormatCommand(Q3TextDocument *dc, int sid, int sidx, int eid, int eidx, const QVector<Q3TextStringChar> &old, Q3TextFormat *f, int fl);

    virtual ~Q3TextFormatCommand();

    Commands type() const { return Format; }

    Q3TextCursor *execute(Q3TextCursor *c);

    Q3TextCursor *unexecute(Q3TextCursor *c);

protected:

    int startId, startIndex, endId, endIndex;

    Q3TextFormat *format;

    QVector<Q3TextStringChar> oldFormats;

    int flags;

};

class Q_COMPAT_EXPORT Q3TextStyleCommand : public Q3TextCommand

{

public:

    Q3TextStyleCommand(Q3TextDocument *dc, int fParag, int lParag, const QByteArray& beforeChange );

    virtual ~Q3TextStyleCommand() {}

    Commands type() const { return Style; }

    Q3TextCursor *execute(Q3TextCursor *c);

    Q3TextCursor *unexecute(Q3TextCursor *c);

    static QByteArray readStyleInformation( Q3TextDocument* dc, int fParag, int lParag);

    static void writeStyleInformation( Q3TextDocument* dc, int fParag, const QByteArray& style);

private:

    int firstParag, lastParag;

    QByteArray before;

    QByteArray after;

};

// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

struct Q_COMPAT_EXPORT Q3TextParagraphSelection

{

    int start, end;

    Q_DUMMY_COMPARISON_OPERATOR(Q3TextParagraphSelection)

};

struct Q_COMPAT_EXPORT QTextLineStart

{

    QTextLineStart() : y(0), baseLine(0), h(0)

    {  }

    QTextLineStart(int y_, int bl, int h_) : y(y_), baseLine(bl), h(h_),

        w(0)

    {  }

public:

    int y, baseLine, h;

    int w;

};

class Q_COMPAT_EXPORT Q3TextParagraphData

{

public:

    Q3TextParagraphData() {}

    virtual ~Q3TextParagraphData();

    virtual void join(Q3TextParagraphData *);

};

class Q3TextParagraphPseudoDocument;

class Q3SyntaxHighlighter;

class Q_COMPAT_EXPORT Q3TextParagraph

{

    friend class Q3TextDocument;

    friend class Q3TextCursor;

    friend class Q3SyntaxHighlighter;

public:

    Q3TextParagraph(Q3TextDocument *dc, Q3TextParagraph *pr = 0, Q3TextParagraph *nx = 0, bool updateIds = true);

    ~Q3TextParagraph();

    Q3TextString *string() const;

    Q3TextStringChar *at(int i) const; // maybe remove later

    int leftGap() const;

    int length() const; // maybe remove later

    void setListStyle(Q3StyleSheetItem::ListStyle ls) { lstyle = ls; changed = true; }

    Q3StyleSheetItem::ListStyle listStyle() const { return (Q3StyleSheetItem::ListStyle)lstyle; }

    void setListItem(bool li);

    bool isListItem() const { return litem; }

    void setListValue(int v) { list_val = v; }

    int listValue() const { return list_val > 0 ? list_val : -1; }

    void setListDepth(int depth);

    int listDepth() const { return ldepth; }

//     void setFormat(Q3TextFormat *fm);

//     Q3TextFormat *paragFormat() const;

    inline Q3TextDocument *document() const {

        if (hasdoc) return (Q3TextDocument*) docOrPseudo;

        return 0;