opie-write first draft

1 files changed, 2158 insertions, 0 deletions

diff --git a/noncore/apps/opie-write/qrichtext_p.h b/noncore/apps/opie-write/qrichtext_p.h
new file mode 100644
index 0000000..94ce913
--- a/dev/null
+++ b/noncore/apps/opie-write/qrichtext_p.h
@@ -0,0 +1,2158 @@
+/****************************************************************************
+** $Id$
+**
+** Definition of internal rich text classes
+**
+** Created : 990124
+**
+** Copyright (C) 1999-2000 Trolltech AS.  All rights reserved.
+**
+** This file is part of the kernel module of the Qt GUI Toolkit.
+**
+** This file may be distributed under the terms of the Q Public License
+** as defined by Trolltech AS of Norway and appearing in the file
+** LICENSE.QPL included in the packaging of this file.
+**
+** This file may be distributed and/or modified under the terms of the
+** GNU General Public License version 2 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.
+**
+** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
+** licenses may use this file in accordance with the Qt Commercial License
+** Agreement provided with the Software.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
+**   information about Qt Commercial License Agreements.
+** See http://www.trolltech.com/qpl/ for QPL licensing information.
+** See http://www.trolltech.com/gpl/ for GPL licensing information.
+**
+** Contact info@trolltech.com if any conditions of this licensing are
+** not clear to you.
+**
+**********************************************************************/
+
+#ifndef QRICHTEXT_P_H
+#define QRICHTEXT_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.
+//
+//
+
+#ifndef QT_H
+#include "qt3namespace.h"
+#include "qstring.h"
+#include "qlist.h"
+#include "qrect.h"
+#include "qfontmetrics.h"
+#include "qintdict.h"
+#include "qmap.h"
+#include "qstringlist.h"
+#include "qfont.h"
+#include "qcolor.h"
+#include "qsize.h"
+#include "qvaluelist.h"
+#include "qvaluestack.h"
+#include "qobject.h"
+#include "qdict.h"
+#include "qtextstream.h"
+#include "qpixmap.h"
+#include "qstylesheet.h"
+#include "qvector.h"
+#include "qpainter.h"
+#include "qlayout.h"
+#include "qobject.h"
+#include "qcomplextext_p.h"
+#include "qapplication.h"
+#include <limits.h>
+#endif // QT_H
+
+//#define DEBUG_COLLECTION
+
+namespace Qt3 {
+
+class QTextDocument;
+class QTextString;
+class QTextPreProcessor;
+class QTextFormat;
+class QTextCursor;
+class QTextParag;
+class QTextFormatter;
+class QTextIndent;
+class QTextFormatCollection;
+class QStyleSheetItem;
+class QTextCustomItem;
+class QTextFlow;
+struct QBidiContext;
+
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+class Q_EXPORT QTextStringChar
+{
+    friend class QTextString;
+
+public:
+    // this is never called, initialize variables in QTextString::insert()!!!
+    QTextStringChar() : lineStart( 0 ), type( Regular ), startOfRun( 0 ) {d.format=0;}
+    ~QTextStringChar();
+
+    QChar c;
+    enum Type { Regular=0, Custom=1, Anchor=2, CustomAnchor=3 };
+    uint lineStart : 1;
+    uint rightToLeft : 1;
+    uint hasCursor : 1;
+    uint canBreak : 1;
+    Type type : 2;
+    uint startOfRun : 1;
+
+    int x;
+    int height() const;
+    int ascent() const;
+    int descent() const;
+    bool isCustom() const { return (type & Custom) != 0; }
+    QTextFormat *format() const;
+    QTextCustomItem *customItem() const;
+    void setFormat( QTextFormat *f );
+    void setCustomItem( QTextCustomItem *i );
+    QTextStringChar *clone() const;
+    struct CustomData
+    {
+        QTextFormat *format;
+        QTextCustomItem *custom;
+        QString anchorName;
+        QString anchorHref;
+    };
+
+    void loseCustomItem();
+
+    union {
+        QTextFormat* format;
+        CustomData* custom;
+    } d;
+
+    bool isAnchor() const { return ( type & Anchor) != 0; }
+    QString anchorName() const;
+    QString anchorHref() const;
+    void setAnchor( const QString& name, const QString& href );
+
+private:
+    QTextStringChar &operator=( const QTextStringChar & ) {
+        //abort();
+        return *this;
+    }
+    friend class QComplexText;
+    friend class QTextParag;
+};
+
+#if defined(Q_TEMPLATEDLL)
+// MOC_SKIP_BEGIN
+template class Q_EXPORT QMemArray<QTextStringChar>;
+// MOC_SKIP_END
+#endif
+
+class Q_EXPORT QTextString
+{
+public:
+
+    QTextString();
+    QTextString( const QTextString &s );
+    virtual ~QTextString();
+
+    static QString toString( const QMemArray<QTextStringChar> &data );
+    QString toString() const;
+
+    QTextStringChar &at( int i ) const;
+    int length() const;
+
+    int width( int idx ) const;
+
+    void insert( int index, const QString &s, QTextFormat *f );
+    void insert( int index, QTextStringChar *c );
+    void truncate( int index );
+    void remove( int index, int len );
+    void clear();
+
+    void setFormat( int index, QTextFormat *f, bool useCollection );
+
+    void setBidi( bool b ) { bidi = b; }
+    bool isBidi() const;
+    bool isRightToLeft() const;
+    QChar::Direction direction() const;
+    void setDirection( QChar::Direction d ) { dir = d; bidiDirty = TRUE; }
+
+    QMemArray<QTextStringChar> subString( int start = 0, int len = 0xFFFFFF ) const;
+    QMemArray<QTextStringChar> rawData() const { return data; }
+
+    void operator=( const QString &s ) { clear(); insert( 0, s, 0 ); }
+    void operator+=( const QString &s );
+    void prepend( const QString &s ) { insert( 0, s, 0 ); }
+
+private:
+    void checkBidi() const;
+
+    QMemArray<QTextStringChar> data;
+    uint bidiDirty : 1;
+    uint bidi : 1; // true when the paragraph has right to left characters
+    uint rightToLeft : 1;
+    uint dir : 5;
+};
+
+inline bool QTextString::isBidi() const
+{
+    if ( bidiDirty )
+        checkBidi();
+    return bidi;
+}
+
+inline bool QTextString::isRightToLeft() const
+{
+    if ( bidiDirty )
+        checkBidi();
+    return rightToLeft;
+}
+
+inline QChar::Direction QTextString::direction() const
+{
+    return (QChar::Direction) dir;
+}
+
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+#if defined(Q_TEMPLATEDLL)
+// MOC_SKIP_BEGIN
+template class Q_EXPORT QValueStack<int>;
+template class Q_EXPORT QValueStack<QTextParag*>;
+template class Q_EXPORT QValueStack<bool>;
+// MOC_SKIP_END
+#endif
+
+class Q_EXPORT QTextCursor
+{
+public:
+    QTextCursor( QTextDocument *d );
+    QTextCursor();
+    QTextCursor( const QTextCursor &c );
+    QTextCursor &operator=( const QTextCursor &c );
+    virtual ~QTextCursor() {}
+
+    bool operator==( const QTextCursor &c ) const;
+    bool operator!=( const QTextCursor &c ) const { return !(*this == c); }
+
+    QTextDocument *document() const { return doc; }
+    void setDocument( QTextDocument *d );
+
+    QTextParag *parag() const;
+    int index() const;
+    void setParag( QTextParag *s, bool restore = TRUE );
+
+    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();
+    void gotoPreviousWord();
+    void gotoWordLeft();
+    void gotoWordRight();
+
+    void insert( const QString &s, bool checkNewLine, QMemArray<QTextStringChar> *formatting = 0 );
+    void splitAndInsertEmptyParag( bool ind = TRUE, bool updateIds = TRUE );
+    bool remove();
+    void killLine();
+    void indent();
+
+    bool atParagStart();
+    bool atParagEnd();
+
+    void setIndex( int i, bool restore = TRUE );
+
+    void checkIndex();
+
+    int offsetX() const { return ox; }
+    int offsetY() const { return oy; }
+
+    QTextParag *topParag() const { return parags.isEmpty() ? string : parags.first(); }
+    int totalOffsetX() const;
+    int totalOffsetY() const;
+
+    bool place( const QPoint &pos, QTextParag *s ) { return place( pos, s, FALSE ); }
+    bool place( const QPoint &pos, QTextParag *s, bool link );
+    void restoreState();
+
+    int x() const;
+    int y() const;
+
+    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; }
+
+private:
+    enum Operation { EnterBegin, EnterEnd, Next, Prev, Up, Down };
+
+    void push();
+    void pop();
+    void processNesting( Operation op );
+    void invalidateNested();
+    void gotoIntoNested( const QPoint &globalPos );
+
+    QTextParag *string;
+    QTextDocument *doc;
+    int idx, tmpIndex;
+    int ox, oy;
+    QValueStack<int> indices;
+    QValueStack<QTextParag*> parags;
+    QValueStack<int> xOffsets;
+    QValueStack<int> yOffsets;
+    QValueStack<bool> nestedStack;
+    uint nested : 1;
+    uint valid : 1;
+
+};
+
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+class Q_EXPORT QTextCommand
+{
+public:
+    enum Commands { Invalid, Insert, Delete, Format, Alignment, ParagType };
+
+    QTextCommand( QTextDocument *d ) : doc( d ), cursor( d ) {}
+    virtual ~QTextCommand();
+
+    virtual Commands type() const;
+
+    virtual QTextCursor *execute( QTextCursor *c ) = 0;
+    virtual QTextCursor *unexecute( QTextCursor *c ) = 0;
+
+protected:
+    QTextDocument *doc;
+    QTextCursor cursor;
+
+};
+
+#if defined(Q_TEMPLATEDLL)
+// MOC_SKIP_BEGIN
+template class Q_EXPORT QPtrList<QTextCommand>;
+// MOC_SKIP_END
+#endif
+
+class Q_EXPORT QTextCommandHistory
+{
+public:
+    QTextCommandHistory( int s ) : current( -1 ), steps( s ) { history.setAutoDelete( TRUE ); }
+    virtual ~QTextCommandHistory();
+
+    void clear() { history.clear(); current = -1; }
+
+    void addCommand( QTextCommand *cmd );
+    QTextCursor *undo( QTextCursor *c );
+    QTextCursor *redo( QTextCursor *c );
+
+    bool isUndoAvailable();
+    bool isRedoAvailable();
+
+    void setUndoDepth( int d ) { steps = d; }
+    int undoDepth() const { return steps; }
+
+    int historySize() const { return history.count(); }
+    int currentPosition() const { return current; }
+
+private:
+    QPtrList<QTextCommand> history;
+    int current, steps;
+
+};
+
+inline QTextCommandHistory::~QTextCommandHistory()
+{
+    clear();
+}
+
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+class Q_EXPORT QTextCustomItem
+{
+public:
+    QTextCustomItem( QTextDocument *p )
+        :  xpos(0), ypos(-1), width(-1), height(0), parent( p )
+    {}
+    virtual ~QTextCustomItem();
+    virtual void draw(QPainter* p, int x, int y, int cx, int cy, int cw, int ch, const QColorGroup& cg, 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( QTextCursor *, QTextDocument *&doc, QTextParag *&parag, int &idx, int &ox, int &oy, bool atEnd = FALSE );
+    virtual bool enterAt( QTextCursor *, QTextDocument *&doc, QTextParag *&parag, int &idx, int &ox, int &oy, const QPoint & );
+    virtual bool next( QTextCursor *, QTextDocument *&doc, QTextParag *&parag, int &idx, int &ox, int &oy );
+    virtual bool prev( QTextCursor *, QTextDocument *&doc, QTextParag *&parag, int &idx, int &ox, int &oy );
+    virtual bool down( QTextCursor *, QTextDocument *&doc, QTextParag *&parag, int &idx, int &ox, int &oy );
+    virtual bool up( QTextCursor *, QTextDocument *&doc, QTextParag *&parag, int &idx, int &ox, int &oy );
+
+    void setParagraph( QTextParag *p ) { parag = p; }
+    QTextParag *paragrapth() const { return parag; }
+
+    QTextDocument *parent;
+    QTextParag *parag;
+
+    virtual void pageBreak( int  y, QTextFlow* flow );
+};
+
+#if defined(Q_TEMPLATEDLL)
+// MOC_SKIP_BEGIN
+template class Q_EXPORT QMap<QString, QString>;
+// MOC_SKIP_END
+#endif
+
+class Q_EXPORT QTextImage : public QTextCustomItem
+{
+public:
+    QTextImage( QTextDocument *p, const QMap<QString, QString> &attr, const QString& context,
+                QMimeSourceFactory &factory );
+    virtual ~QTextImage();
+
+    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 QColorGroup& cg, bool selected );
+
+private:
+    QRegion* reg;
+    QPixmap pm;
+    Placement place;
+    int tmpwidth, tmpheight;
+    QMap<QString, QString> attributes;
+    QString imgId;
+
+};
+
+class Q_EXPORT QTextHorizontalLine : public QTextCustomItem
+{
+public:
+    QTextHorizontalLine( QTextDocument *p, const QMap<QString, QString> &attr, const QString& context,
+                         QMimeSourceFactory &factory );
+    virtual ~QTextHorizontalLine();
+
+    void adjustToPainter( QPainter* );
+    void draw(QPainter* p, int x, int y, int cx, int cy, int cw, int ch, const QColorGroup& cg, bool selected );
+    QString richText() const;
+
+    bool ownLine() const { return TRUE; }
+
+private:
+    int tmpheight;
+    QColor color;
+
+};
+
+#if defined(Q_TEMPLATEDLL)
+// MOC_SKIP_BEGIN
+template class Q_EXPORT QPtrList<QTextCustomItem>;
+// MOC_SKIP_END
+#endif
+
+class Q_EXPORT QTextFlow
+{
+    friend class QTextDocument;
+    friend class QTextTableCell;
+
+public:
+    QTextFlow();
+    virtual ~QTextFlow();
+
+    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 );
+
+    virtual void registerFloatingItem( QTextCustomItem* item );
+    virtual void unregisterFloatingItem( QTextCustomItem* item );
+    virtual QRect boundingRect() const;
+    virtual void drawFloatingItems(QPainter* p, int cx, int cy, int cw, int ch, const QColorGroup& cg, 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;
+
+    QPtrList<QTextCustomItem> leftItems;
+    QPtrList<QTextCustomItem> rightItems;
+
+};
+
+inline int QTextFlow::width() const { return w; }
+
+class QTextTable;
+
+class Q_EXPORT QTextTableCell : public QLayoutItem
+{
+    friend class QTextTable;
+
+public:
+    QTextTableCell( QTextTable* table,
+                    int row, int column,
+                    const QMap<QString, QString> &attr,
+                    const QStyleSheetItem* style,
+                    const QTextFormat& fmt, const QString& context,
+                    QMimeSourceFactory &factory, QStyleSheet *sheet, const QString& doc );
+    QTextTableCell( QTextTable* table, int row, int column );
+    virtual ~QTextTableCell();
+
+    QSize sizeHint() const ;
+    QSize minimumSize() const ;
+    QSize maximumSize() const ;
+    QSizePolicy::ExpandData expanding() 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_; }
+
+    QTextDocument* richText()  const { return richtext; }
+    QTextTable* table() const { return parent; }
+
+    void draw( QPainter* p, int x, int y, int cx, int cy, int cw, int ch, const QColorGroup& cg, bool selected );
+
+    QBrush *backGround() const { return background; }
+    virtual void invalidate();
+
+    int verticalAlignmentOffset() const;
+    int horizontalAlignmentOffset() const;
+
+private:
+    QRect geom;
+    QTextTable* parent;
+    QTextDocument* 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;
+};
+
+#if defined(Q_TEMPLATEDLL)
+// MOC_SKIP_BEGIN
+template class Q_EXPORT QPtrList<QTextTableCell>;
+template class Q_EXPORT QMap<QTextCursor*, int>;
+// MOC_SKIP_END
+#endif
+
+class Q_EXPORT QTextTable: public QTextCustomItem
+{
+    friend class QTextTableCell;
+
+public:
+    QTextTable( QTextDocument *p, const QMap<QString, QString> &attr );
+    virtual ~QTextTable();
+
+    void adjustToPainter( QPainter *p );
+    void pageBreak( int  y, QTextFlow* flow );
+    void draw( QPainter* p, int x, int y, int cx, int cy, int cw, int ch,
+               const QColorGroup& cg, 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( QTextCursor *c, QTextDocument *&doc, QTextParag *&parag, int &idx, int &ox, int &oy, bool atEnd = FALSE );
+    virtual bool enterAt( QTextCursor *c, QTextDocument *&doc, QTextParag *&parag, int &idx, int &ox, int &oy, const QPoint &pos );
+    virtual bool next( QTextCursor *c, QTextDocument *&doc, QTextParag *&parag, int &idx, int &ox, int &oy );
+    virtual bool prev( QTextCursor *c, QTextDocument *&doc, QTextParag *&parag, int &idx, int &ox, int &oy );
+    virtual bool down( QTextCursor *c, QTextDocument *&doc, QTextParag *&parag, int &idx, int &ox, int &oy );
+    virtual bool up( QTextCursor *c, QTextDocument *&doc, QTextParag *&parag, int &idx, int &ox, int &oy );
+
+    QString richText() const;
+
+    int minimumWidth() const;
+
+    QPtrList<QTextTableCell> tableCells() const { return cells; }
+
+    bool isStretching() const { return stretch; }
+
+private:
+    void format( int w );
+    void addCell( QTextTableCell* cell );
+
+private:
+    QGridLayout* layout;
+    QPtrList<QTextTableCell> 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;
+    QMap<QString, QString> attributes;
+    QMap<QTextCursor*, int> currCell;
+    Placement place;
+    void adjustCells( int y , int shift );
+    int pageBreakFor;
+};
+
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+class QTextTableCell;
+class QTextParag;
+
+struct Q_EXPORT QTextDocumentSelection
+{
+    QTextCursor startCursor, endCursor;
+    bool swapped;
+};
+
+#if defined(Q_TEMPLATEDLL)
+// MOC_SKIP_BEGIN
+template class Q_EXPORT QMap<int, QColor>;
+template class Q_EXPORT QMap<int, bool>;
+template class Q_EXPORT QMap<int, QTextDocumentSelection>;
+template class Q_EXPORT QPtrList<QTextDocument>;
+// MOC_SKIP_END
+#endif
+
+class Q_EXPORT QTextDocument : public QObject
+{
+    Q_OBJECT
+
+    friend class QTextTableCell;
+    friend class QTextCursor;
+    friend class QTextEdit;
+    friend class QTextParag;
+
+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()
+    };
+
+    QTextDocument( QTextDocument *p );
+    QTextDocument( QTextDocument *d, QTextFormatCollection *f );
+    virtual ~QTextDocument();
+
+    QTextDocument *parent() const { return par; }
+    QTextParag *parentParag() const { return parParag; }
+
+    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, QTextParag *parag = 0 );
+
+    void setY( int y );
+    int leftMargin() const;
+    void setLeftMargin( int lm );
+    int rightMargin() const;
+    void setRightMargin( int rm );
+
+    QTextParag *firstParag() const;
+    QTextParag *lastParag() const;
+    void setFirstParag( QTextParag *p );
+    void setLastParag( QTextParag *p );
+
+    void invalidate();
+
+    void setPreProcessor( QTextPreProcessor *sh );
+    QTextPreProcessor *preProcessor() const;
+
+    void setFormatter( QTextFormatter *f );
+    QTextFormatter *formatter() const;
+
+    void setIndent( QTextIndent *i );
+    QTextIndent *indent() const;
+
+    QColor selectionColor( int id ) const;
+    bool invertSelectionText( int id ) const;
+    void setSelectionColor( int id, const QColor &c );
+    void setInvertSelectionText( int id, bool b );
+    bool hasSelection( int id, bool visible = FALSE ) const;
+    void setSelectionStart( int id, QTextCursor *cursor );
+    bool setSelectionEnd( int id, QTextCursor *cursor );
+    void selectAll( int id );
+    bool removeSelection( int id );
+    void selectionStart( int id, int &paragId, int &index );
+    QTextCursor selectionStartCursor( int id );
+    QTextCursor selectionEndCursor( int id );
+    void selectionEnd( int id, int &paragId, int &index );
+    void setFormat( int id, QTextFormat *f, int flags );
+    QTextParag *selectionStart( int id );
+    QTextParag *selectionEnd( int id );
+    int numSelections() const { return nSelections; }
+    void addSelection( int id );
+
+    QString selectedText( int id, bool withCustom = TRUE ) const;
+    void copySelectedText( int id );
+    void removeSelectedText( int id, QTextCursor *cursor );
+    void indentSelection( int id );
+
+    QTextParag *paragAt( int i ) const;
+
+    void addCommand( QTextCommand *cmd );
+    QTextCursor *undo( QTextCursor *c = 0 );
+    QTextCursor *redo( QTextCursor *c  = 0 );
+    QTextCommandHistory *commands() const { return commandHistory; }
+
+    QTextFormatCollection *formatCollection() const;
+
+    bool find( const QString &expr, bool cs, bool wo, bool forward, int *parag, int *index, QTextCursor *cursor );
+
+    void setTextFormat( Qt::TextFormat f );
+    Qt::TextFormat textFormat() const;
+
+    bool inSelection( int selId, const QPoint &pos ) const;
+
+    QStyleSheet *styleSheet() const { return sheet_; }
+    QMimeSourceFactory *mimeSourceFactory() const { return factory_; }
+    QString context() const { return contxt; }
+
+    void setStyleSheet( QStyleSheet *s );
+    void updateStyles();
+    void updateFontSizes( int base, bool usePixels );
+    void updateFontAttributes( const QFont &f, const QFont &old );
+    void setMimeSourceFactory( QMimeSourceFactory *f ) { if ( f ) factory_ = f; }
+    void setContext( const QString &c ) { if ( !c.isEmpty() ) contxt = c; }
+
+    void setUnderlineLinks( bool b ) { underlLinks = 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 QColorGroup &cg, const QBrush *paper = 0 );
+    void drawParag( QPainter *p, QTextParag *parag, int cx, int cy, int cw, int ch,
+                    QPixmap *&doubleBuffer, const QColorGroup &cg,
+                    bool drawCursor, QTextCursor *cursor, bool resetChanged = TRUE );
+    QTextParag *draw( QPainter *p, int cx, int cy, int cw, int ch, const QColorGroup &cg,
+                      bool onlyChanged = FALSE, bool drawCursor = FALSE, QTextCursor *cursor = 0,
+                      bool resetChanged = TRUE );
+
+    void setDefaultFont( const QFont &f );
+
+    void registerCustomItem( QTextCustomItem *i, QTextParag *p );
+    void unregisterCustomItem( QTextCustomItem *i, QTextParag *p );
+
+    void setFlow( QTextFlow *f );
+    void takeFlow();
+    QTextFlow *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; }
+
+    QTextTableCell *tableCell() const { return tc; }
+    void setTableCell( QTextTableCell *c ) { tc = c; }
+
+    void setPlainText( const QString &text );
+    void setRichText( const QString &text, const QString &context );
+    QString richText( QTextParag *p = 0 ) const;
+    QString plainText( QTextParag *p = 0 ) 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 d ) { commandHistory->setUndoDepth( d ); }
+    int undoDepth() const { return commandHistory->undoDepth(); }
+
+    int length() const;
+    void clear( bool createEmptyParag = FALSE );
+
+    virtual QTextParag *createParag( QTextDocument *d, QTextParag *pr = 0, QTextParag *nx = 0, bool updateIds = TRUE );
+    void insertChild( QObject *o ) { QObject::insertChild( o ); }
+    void removeChild( QObject *o ) { QObject::removeChild( o ); }
+    void insertChild( QTextDocument *d ) { childList.append( d ); }
+    void removeChild( QTextDocument *d ) { childList.removeRef( d ); }
+    QPtrList<QTextDocument> children() const { return childList; }
+
+    void setAddMargins( bool b ) { addMargs = b; }
+    int addMargins() const { return addMargs; }
+
+    bool hasFocusParagraph() const;
+    QString focusHref() const;
+
+    void invalidateOriginalText() { oTextValid = FALSE; oText = ""; }
+
+signals:
+    void minimumWidthChanged( int );
+
+private:
+    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);
+    QTextCustomItem* parseTable( const QMap<QString, QString> &attr, const QTextFormat &fmt,
+                                 const QChar* doc, int length, int& pos, QTextParag *curpar );
+    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, QStyleSheetItem::WhiteSpaceMode wsm );
+    void setRichTextInternal( const QString &text );
+
+private:
+    struct Q_EXPORT Focus {
+        QTextParag *parag;
+        int start, len;
+        QString href;
+    };
+
+    int cx, cy, cw, vw;
+    QTextParag *fParag, *lParag;
+    QTextPreProcessor *pProcessor;
+    QMap<int, QColor> selectionColors;
+    QMap<int, QTextDocumentSelection> selections;
+    QMap<int, bool> selectionText;
+    QTextCommandHistory *commandHistory;
+    QTextFormatter *pFormatter;
+    QTextIndent *indenter;
+    QTextFormatCollection *fCollection;
+    Qt::TextFormat txtFormat;
+    uint preferRichText : 1;
+    uint pages : 1;
+    uint useFC : 1;
+    uint withoutDoubleBuffer : 1;
+    uint underlLinks : 1;
+    uint nextDoubleBuffered : 1;
+    uint addMargs : 1;
+    uint oTextValid : 1;
+    uint mightHaveCustomItems : 1;
+    int align;
+    int nSelections;
+    QTextFlow *flow_;
+    QTextDocument *par;
+    QTextParag *parParag;
+    QTextTableCell *tc;
+    QTextCursor *tmpCursor;
+    QBrush *backBrush;
+    QPixmap *buf_pixmap;
+    Focus focusIndicator;
+    int minw;
+    int wused;
+    int leftmargin;
+    int rightmargin;
+    QTextParag *minwParag, *curParag;
+    QStyleSheet* sheet_;
+    QMimeSourceFactory* factory_;
+    QString contxt;
+    QMap<QString, QString> attribs;
+    int *tArray;
+    int tStopWidth;
+    int uDepth;
+    QString oText;
+    QPtrList<QTextDocument> childList;
+    QColor linkColor;
+
+};
+
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+
+class Q_EXPORT QTextDeleteCommand : public QTextCommand
+{
+public:
+    QTextDeleteCommand( QTextDocument *d, int i, int idx, const QMemArray<QTextStringChar> &str,
+                        const QValueList< QPtrVector<QStyleSheetItem> > &os,
+                        const QValueList<QStyleSheetItem::ListStyle> &ols,
+                        const QMemArray<int> &oas );
+    QTextDeleteCommand( QTextParag *p, int idx, const QMemArray<QTextStringChar> &str );
+    virtual ~QTextDeleteCommand();
+
+    Commands type() const { return Delete; }
+    QTextCursor *execute( QTextCursor *c );
+    QTextCursor *unexecute( QTextCursor *c );
+
+protected:
+    int id, index;
+    QTextParag *parag;
+    QMemArray<QTextStringChar> text;
+    QValueList< QPtrVector<QStyleSheetItem> > oldStyles;
+    QValueList<QStyleSheetItem::ListStyle> oldListStyles;
+    QMemArray<int> oldAligns;
+
+};
+
+class Q_EXPORT QTextInsertCommand : public QTextDeleteCommand
+{
+public:
+    QTextInsertCommand( QTextDocument *d, int i, int idx, const QMemArray<QTextStringChar> &str,
+                        const QValueList< QPtrVector<QStyleSheetItem> > &os,
+                        const QValueList<QStyleSheetItem::ListStyle> &ols,
+                        const QMemArray<int> &oas )
+        : QTextDeleteCommand( d, i, idx, str, os, ols, oas ) {}
+    QTextInsertCommand( QTextParag *p, int idx, const QMemArray<QTextStringChar> &str )
+        : QTextDeleteCommand( p, idx, str ) {}
+    virtual ~QTextInsertCommand() {}
+
+    Commands type() const { return Insert; }
+    QTextCursor *execute( QTextCursor *c ) { return QTextDeleteCommand::unexecute( c ); }
+    QTextCursor *unexecute( QTextCursor *c ) { return QTextDeleteCommand::execute( c ); }
+
+};
+
+class Q_EXPORT QTextFormatCommand : public QTextCommand
+{
+public:
+    QTextFormatCommand( QTextDocument *d, int sid, int sidx, int eid, int eidx, const QMemArray<QTextStringChar> &old, QTextFormat *f, int fl );
+    virtual ~QTextFormatCommand();
+
+    Commands type() const { return Format; }
+    QTextCursor *execute( QTextCursor *c );
+    QTextCursor *unexecute( QTextCursor *c );
+
+protected:
+    int startId, startIndex, endId, endIndex;
+    QTextFormat *format;
+    QMemArray<QTextStringChar> oldFormats;
+    int flags;
+
+};
+
+class Q_EXPORT QTextAlignmentCommand : public QTextCommand
+{
+public:
+    QTextAlignmentCommand( QTextDocument *d, int fParag, int lParag, int na, const QMemArray<int> &oa );
+    virtual ~QTextAlignmentCommand() {}
+
+    Commands type() const { return Alignment; }
+    QTextCursor *execute( QTextCursor *c );
+    QTextCursor *unexecute( QTextCursor *c );
+
+private:
+    int firstParag, lastParag;
+    int newAlign;
+    QMemArray<int> oldAligns;
+
+};
+
+class Q_EXPORT QTextParagTypeCommand : public QTextCommand
+{
+public:
+    QTextParagTypeCommand( QTextDocument *d, int fParag, int lParag, bool l,
+                           QStyleSheetItem::ListStyle s, const QValueList< QPtrVector<QStyleSheetItem> > &os,
+                           const QValueList<QStyleSheetItem::ListStyle> &ols );
+    virtual ~QTextParagTypeCommand() {}
+
+    Commands type() const { return ParagType; }
+    QTextCursor *execute( QTextCursor *c );
+    QTextCursor *unexecute( QTextCursor *c );
+
+private:
+    int firstParag, lastParag;
+    bool list;
+    QStyleSheetItem::ListStyle listStyle;
+    QValueList< QPtrVector<QStyleSheetItem> > oldStyles;
+    QValueList<QStyleSheetItem::ListStyle> oldListStyles;
+
+};
+
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+struct Q_EXPORT QTextParagSelection
+{
+    int start, end;
+};
+
+struct Q_EXPORT QTextParagLineStart
+{
+    QTextParagLineStart() : y( 0 ), baseLine( 0 ), h( 0 )
+#ifndef QT_NO_COMPLEXTEXT
+        , bidicontext( 0 )
+#endif
+    {  }
+    QTextParagLineStart( ushort y_, ushort bl, ushort h_ ) : y( y_ ), baseLine( bl ), h( h_ ),
+        w( 0 )
+#ifndef QT_NO_COMPLEXTEXT
+        , bidicontext( 0 )
+#endif
+    {  }
+#ifndef QT_NO_COMPLEXTEXT
+    QTextParagLineStart( QBidiContext *c, QBidiStatus s ) : y(0), baseLine(0), h(0),
+        status( s ), bidicontext( c ) { if ( bidicontext ) bidicontext->ref(); }
+#endif
+
+    virtual ~QTextParagLineStart()
+    {
+#ifndef QT_NO_COMPLEXTEXT
+        if ( bidicontext && bidicontext->deref() )
+            delete bidicontext;
+#endif
+    }
+
+#ifndef QT_NO_COMPLEXTEXT
+    void setContext( QBidiContext *c ) {
+        if ( c == bidicontext )
+            return;
+        if ( bidicontext && bidicontext->deref() )
+            delete bidicontext;
+        bidicontext = c;
+        if ( bidicontext )
+            bidicontext->ref();
+    }
+    QBidiContext *context() const { return bidicontext; }
+#endif
+
+public:
+    ushort y, baseLine, h;
+#ifndef QT_NO_COMPLEXTEXT
+    QBidiStatus status;
+#endif
+    int w;
+
+private:
+#ifndef QT_NO_COMPLEXTEXT
+    QBidiContext *bidicontext;
+#endif
+};
+
+#if defined(Q_TEMPLATEDLL)
+// MOC_SKIP_BEGIN
+template class Q_EXPORT QMap<int, QTextParagSelection>;
+template class Q_EXPORT QMap<int, QTextParagLineStart*>;
+// MOC_SKIP_END
+#endif
+
+class Q_EXPORT QTextParagData
+{
+public:
+    QTextParagData() {}
+    virtual ~QTextParagData();
+    virtual void join( QTextParagData * );
+};
+
+class Q_EXPORT QTextParagPseudoDocument
+{
+public:
+    QTextParagPseudoDocument();
+    ~QTextParagPseudoDocument();
+    QRect docRect;
+    QTextFormatter *pFormatter;
+    QTextCommandHistory *commandHistory;
+    int minw;
+    int wused;
+};
+
+//nase
+class Q_EXPORT QTextParag
+{
+    friend class QTextDocument;
+    friend class QTextCursor;
+
+public:
+    QTextParag( QTextDocument *d, QTextParag *pr = 0, QTextParag *nx = 0, bool updateIds = TRUE );
+    virtual ~QTextParag();
+
+    QTextString *string() const;
+    QTextStringChar *at( int i ) const; // maybe remove later
+    int leftGap() const;
+    int length() const; // maybe remove later
+
+    void setListStyle( QStyleSheetItem::ListStyle ls );
+    QStyleSheetItem::ListStyle listStyle() const;
+    void setListValue( int v ) { list_val = v; }
+    int listValue() const { return list_val; }
+
+    void setList( bool b, int listStyle );
+    void incDepth();
+    void decDepth();
+    int listDepth() const;
+
+    void setFormat( QTextFormat *fm );
+    QTextFormat *paragFormat() const;
+
+    QTextDocument *document() const;
+    QTextParagPseudoDocument *pseudoDocument() const;
+
+    QRect rect() const;
+    void setHeight( int h ) { r.setHeight( h ); }
+    void show();
+    void hide();
+    bool isVisible() const { return visible; }
+
+    QTextParag *prev() const;
+    QTextParag *next() const;
+    void setPrev( QTextParag *s );
+    void setNext( QTextParag *s );
+
+    void insert( int index, const QString &s );
+    void append( const QString &s, bool reallyAtEnd = FALSE );
+    void truncate( int index );
+    void remove( int index, int len );
+    void join( QTextParag *s );
+
+    void invalidate( int chr );
+
+    void move( int &dy );
+    void format( int start = -1, bool doMove = TRUE );
+
+    bool isValid() const;
+    bool hasChanged() const;
+    void setChanged( bool b, bool recursive = FALSE );
+
+    int lineHeightOfChar( int i, int *bl = 0, int *y = 0 ) const;
+    QTextStringChar *lineStartOfChar( int i, int *index = 0, int *line = 0 ) const;
+    int lines() const;
+    QTextStringChar *lineStartOfLine( int line, int *index = 0 ) const;
+    int lineY( int l ) const;
+    int lineBaseLine( int l ) const;
+    int lineHeight( int l ) const;
+    void lineInfo( int l, int &y, int &h, int &bl ) const;
+
+    void setSelection( int id, int start, int end );
+    void removeSelection( int id );
+    int selectionStart( int id ) const;
+    int selectionEnd( int id ) const;
+    bool hasSelection( int id ) const;
+    bool hasAnySelection() const;
+    bool fullSelected( int id ) const;
+
+    void setEndState( int s );
+    int endState() const;
+
+    void setParagId( int i );
+    int paragId() const;
+
+    bool firstPreProcess() const;
+    void setFirstPreProcess( bool b );
+
+    void indent( int *oldIndent = 0, int *newIndent = 0 );
+
+    void setExtraData( QTextParagData *data );
+    QTextParagData *extraData() const;
+
+    QMap<int, QTextParagLineStart*> &lineStartList();
+
+    void setFormat( int index, int len, QTextFormat *f, bool useCollection = TRUE, int flags = -1 );
+
+    void setAlignment( int a );
+    int alignment() const;
+
+    virtual void paint( QPainter &painter, const QColorGroup &cg, QTextCursor *cursor = 0, bool drawSelections = FALSE,
+                        int clipx = -1, int clipy = -1, int clipw = -1, int cliph = -1 );
+
+    void setStyleSheetItems( const QPtrVector<QStyleSheetItem> &vec );
+    QPtrVector<QStyleSheetItem> styleSheetItems() const;
+    QStyleSheetItem *style() const;
+
+    virtual int topMargin() const;
+    virtual int bottomMargin() const;
+    virtual int leftMargin() const;
+    virtual int firstLineMargin() const;
+    virtual int rightMargin() const;
+    virtual int lineSpacing() const;
+
+    int numberOfSubParagraph() const;
+    void registerFloatingItem( QTextCustomItem *i );
+    void unregisterFloatingItem( QTextCustomItem *i );
+
+    void setFullWidth( bool b ) { fullWidth = b; }
+    bool isFullWidth() const { return fullWidth; }
+
+    QTextTableCell *tableCell() const;
+
+    QBrush *background() const;
+
+    int documentWidth() const;
+    int documentVisibleWidth() const;
+    int documentX() const;
+    int documentY() const;
+    QTextFormatCollection *formatCollection() const;
+    QTextFormatter *formatter() const;
+
+    virtual int nextTab( int i, int x );
+    int *tabArray() const;
+    void setTabArray( int *a );
+    void setTabStops( int tw );
+
+    void adjustToPainter( QPainter *p );
+
+    void setNewLinesAllowed( bool b );
+    bool isNewLinesAllowed() const;
+
+    QString richText() const;
+
+    void addCommand( QTextCommand *cmd );
+    QTextCursor *undo( QTextCursor *c = 0 );
+    QTextCursor *redo( QTextCursor *c  = 0 );
+    QTextCommandHistory *commands() const;
+    virtual void copyParagData( QTextParag *parag );
+
+    void setBreakable( bool b ) { breakable = b; }
+    bool isBreakable() const { return breakable; }
+
+    void setBackgroundColor( const QColor &c );
+    QColor *backgroundColor() const { return bgcol; }
+    void clearBackgroundColor();
+
+    bool isLineBreak() const { return isBr; }
+
+    void setMovedDown( bool b ) { movedDown = b; }
+    bool wasMovedDown() const { return movedDown; }
+
+    void setDirection( QChar::Direction d );
+    QChar::Direction direction() const;
+
+protected:
+    virtual void drawLabel( QPainter* p, int x, int y, int w, int h, int base, const QColorGroup& cg );
+    virtual void drawParagString( QPainter &painter, const QString &str, int start, int len, int startX,
+                                  int lastY, int baseLine, int bw, int h, bool drawSelections,
+                                  QTextStringChar *formatChar, int i, const QMemArray<int> &selectionStarts,
+                                  const QMemArray<int> &selectionEnds, const QColorGroup &cg, bool rightToLeft  );
+
+private:
+    QMap<int, QTextParagSelection> &selections() const;
+    QPtrVector<QStyleSheetItem> &styleSheetItemsVec() const;
+    QPtrList<QTextCustomItem> &floatingItems() const;
+
+    QMap<int, QTextParagLineStart*> lineStarts;
+    int invalid;
+    QRect r;
+    QTextParag *p, *n;
+    void *docOrPseudo;
+    uint changed : 1;
+    uint firstFormat : 1;
+    uint firstPProcess : 1;
+    uint needPreProcess : 1;
+    uint fullWidth : 1;
+    uint newLinesAllowed : 1;
+    uint lastInFrame : 1;
+    uint visible : 1;
+    uint breakable : 1;
+    uint isBr : 1;
+    uint movedDown : 1;
+    uint mightHaveCustomItems : 1;
+    uint hasdoc : 1;
+    int align : 4;
+    int state, id;
+    QTextString *str;
+    QMap<int, QTextParagSelection> *mSelections;
+    QPtrVector<QStyleSheetItem> *mStyleSheetItemsVec;
+    QPtrList<QTextCustomItem> *mFloatingItems;
+    QStyleSheetItem::ListStyle listS;
+    int numSubParag;
+    int tm, bm, lm, rm, flm;
+    QTextFormat *defFormat;
+    int *tArray;
+    int tabStopWidth;
+    QTextParagData *eData;
+    int list_val;
+    QColor *bgcol;
+
+};
+
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+class Q_EXPORT QTextFormatter
+{
+public:
+    QTextFormatter();
+    virtual ~QTextFormatter();
+
+    virtual int format( QTextDocument *doc, QTextParag *parag, int start, const QMap<int, QTextParagLineStart*> &oldLineStarts ) = 0;
+    virtual int formatVertically( QTextDocument* doc, QTextParag* parag );
+
+    bool isWrapEnabled( QTextParag *p ) const { if ( !wrapEnabled ) return FALSE; if ( p && !p->isBreakable() ) return FALSE; return TRUE;}
+    int wrapAtColumn() const { return wrapColumn;}
+    virtual void setWrapEnabled( bool b );
+    virtual void setWrapAtColumn( int c );
+    virtual void setAllowBreakInWords( bool b ) { biw = b; }
+    bool allowBreakInWords() const { return biw; }
+
+    int minimumWidth() const { return thisminw; }
+    int widthUsed() const { return thiswused; }
+
+protected:
+    virtual QTextParagLineStart *formatLine( QTextParag *parag, QTextString *string, QTextParagLineStart *line, QTextStringChar *start,
+                                               QTextStringChar *last, int align = Qt3::AlignAuto, int space = 0 );
+#ifndef QT_NO_COMPLEXTEXT
+    virtual QTextParagLineStart *bidiReorderLine( QTextParag *parag, QTextString *string, QTextParagLineStart *line, QTextStringChar *start,
+                                                    QTextStringChar *last, int align, int space );
+#endif
+    virtual bool isBreakable( QTextString *string, int pos ) const;
+    void insertLineStart( QTextParag *parag, int index, QTextParagLineStart *ls );
+
+    int thisminw;
+    int thiswused;
+
+private:
+    bool wrapEnabled;
+    int wrapColumn;
+    bool biw;
+
+#ifdef HAVE_THAI_BREAKS
+    static QCString *thaiCache;
+    static QTextString *cachedString;
+    static ThBreakIterator *thaiIt;
+#endif
+};
+
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+class Q_EXPORT QTextFormatterBreakInWords : public QTextFormatter
+{
+public:
+    QTextFormatterBreakInWords();
+    virtual ~QTextFormatterBreakInWords() {}
+
+    int format( QTextDocument *doc, QTextParag *parag, int start, const QMap<int, QTextParagLineStart*> &oldLineStarts );
+
+};
+
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+class Q_EXPORT QTextFormatterBreakWords : public QTextFormatter
+{
+public:
+    QTextFormatterBreakWords();
+    virtual ~QTextFormatterBreakWords() {}
+
+    int format( QTextDocument *doc, QTextParag *parag, int start, const QMap<int, QTextParagLineStart*> &oldLineStarts );
+
+};
+
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+class Q_EXPORT QTextIndent
+{
+public:
+    QTextIndent();
+    virtual ~QTextIndent() {}
+
+    virtual void indent( QTextDocument *doc, QTextParag *parag, int *oldIndent = 0, int *newIndent = 0 ) = 0;
+
+};
+
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+class Q_EXPORT QTextPreProcessor
+{
+public:
+    enum Ids {
+        Standard = 0
+    };
+
+    QTextPreProcessor();
+    virtual ~QTextPreProcessor() {}
+
+    virtual void process( QTextDocument *doc, QTextParag *, int, bool = TRUE ) = 0;
+    virtual QTextFormat *format( int id ) = 0;
+
+};
+
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+class Q_EXPORT QTextFormat
+{
+    friend class QTextFormatCollection;
+    friend class QTextDocument;
+
+public:
+    enum Flags {
+        NoFlags,
+        Bold = 1,
+        Italic = 2,
+        Underline = 4,
+        Family = 8,
+        Size = 16,
+        Color = 32,
+        Misspelled = 64,
+        VAlign = 128,
+        Font = Bold | Italic | Underline | Family | Size,
+        Format = Font | Color | Misspelled | VAlign
+    };
+
+    enum VerticalAlignment { AlignNormal, AlignSuperScript, AlignSubScript };
+
+    QTextFormat();
+    virtual ~QTextFormat();
+
+    QTextFormat( const QStyleSheetItem *s );
+    QTextFormat( const QFont &f, const QColor &c, QTextFormatCollection *parent = 0 );
+    QTextFormat( const QTextFormat &fm );
+    QTextFormat makeTextFormat( const QStyleSheetItem *style, const QMap<QString,QString>& attr ) const;
+    QTextFormat& operator=( const QTextFormat &fm );
+    QColor color() const;
+    QFont font() const;
+    bool isMisspelled() const;
+    VerticalAlignment vAlign() const;
+    int minLeftBearing() const;
+    int minRightBearing() const;
+    int width( const QChar &c ) const;
+    int width( const QString &str, int pos ) const;
+    int height() const;
+    int ascent() const;
+    int descent() const;
+    int leading() const;
+    bool useLinkColor() const;
+
+    void setBold( bool b );
+    void setItalic( bool b );
+    void setUnderline( bool b );
+    void setFamily( const QString &f );
+    void setPointSize( int s );
+    void setFont( const QFont &f );
+    void setColor( const QColor &c );
+    void setMisspelled( bool b );
+    void setVAlign( VerticalAlignment a );
+
+    bool operator==( const QTextFormat &f ) const;
+    QTextFormatCollection *parent() const;
+    QString key() const;
+
+    static QString getKey( const QFont &f, const QColor &c, bool misspelled, VerticalAlignment vAlign );
+
+    void addRef();
+    void removeRef();
+
+    QString makeFormatChangeTags( QTextFormat *f, const QString& oldAnchorHref, const QString& anchorHref ) const;
+    QString makeFormatEndTags( const QString& anchorHref ) const;
+
+    static void setPainter( QPainter *p );
+    static QPainter* painter();
+    void updateStyle();
+    void updateStyleFlags();
+    void setStyle( const QString &s );
+    QString styleName() const { return style; }
+
+    int changed() const { return different; }
+    bool fontSizesInPixels() { return usePixelSizes; }
+
+protected:
+    virtual void generateKey();
+
+private:
+    void update();
+
+private:
+    QFont fn;
+    QColor col;
+    QFontMetrics fm;
+    uint missp : 1;
+    uint linkColor : 1;
+    uint usePixelSizes : 1;
+    int leftBearing, rightBearing;
+    VerticalAlignment ha;
+    uchar widths[ 256 ];
+    int hei, asc, dsc;
+    QTextFormatCollection *collection;
+    int ref;
+    QString k;
+    int logicalFontSize;
+    int stdSize;
+    static QPainter *pntr;
+    QString style;
+    int different;
+
+};
+
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+#if defined(Q_TEMPLATEDLL)
+// MOC_SKIP_BEGIN
+template class Q_EXPORT QDict<QTextFormat>;
+// MOC_SKIP_END
+#endif
+
+class Q_EXPORT QTextFormatCollection
+{
+    friend class QTextDocument;
+    friend class QTextFormat;
+
+public:
+    QTextFormatCollection();
+    virtual ~QTextFormatCollection();
+
+    void setDefaultFormat( QTextFormat *f );
+    QTextFormat *defaultFormat() const;
+    virtual QTextFormat *format( QTextFormat *f );
+    virtual QTextFormat *format( QTextFormat *of, QTextFormat *nf, int flags );
+    virtual QTextFormat *format( const QFont &f, const QColor &c );
+    virtual void remove( QTextFormat *f );
+    virtual QTextFormat *createFormat( const QTextFormat &f ) { return new QTextFormat( f ); }
+    virtual QTextFormat *createFormat( const QFont &f, const QColor &c ) { return new QTextFormat( f, c, this ); }
+    void debug();
+
+    QStyleSheet *styleSheet() const { return sheet; }
+    void setStyleSheet( QStyleSheet *s ) { sheet = s; }
+    void updateStyles();
+    void updateFontSizes( int base, bool usePixels );
+    void updateFontAttributes( const QFont &f, const QFont &old );
+    QDict<QTextFormat> dict() const { return cKey; }
+
+private:
+    void updateKeys();
+
+private:
+    QTextFormat *defFormat, *lastFormat, *cachedFormat;
+    QDict<QTextFormat> cKey;
+    QTextFormat *cres;
+    QFont cfont;
+    QColor ccol;
+    QString kof, knf;
+    int cflags;
+    QStyleSheet *sheet;
+
+};
+
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+inline int QTextString::length() const
+{
+    return data.size();
+}
+
+inline void QTextString::operator+=( const QString &s )
+{
+    insert( length(), s, 0 );
+}
+
+inline int QTextParag::length() const
+{
+    return str->length();
+}
+
+inline QRect QTextParag::rect() const
+{
+    return r;
+}
+
+inline QTextParag *QTextCursor::parag() const
+{
+    return string;
+}
+
+inline int QTextCursor::index() const
+{
+    return idx;
+}
+
+inline void QTextCursor::setIndex( int i, bool restore )
+{
+    if ( restore )
+        restoreState();
+    if ( i < 0 || i >= string->length() ) {
+#if defined(QT_CHECK_RANGE)
+        qWarning( "QTextCursor::setIndex: %d out of range", i );
+#endif
+        i = i < 0 ? 0 : string->length() - 1;
+    }
+
+    tmpIndex = -1;
+    idx = i;
+}
+
+inline void QTextCursor::setParag( QTextParag *s, bool restore )
+{
+    if ( restore )
+        restoreState();
+    idx = 0;
+    string = s;
+    tmpIndex = -1;
+}
+
+inline void QTextCursor::checkIndex()
+{
+    if ( idx >= string->length() )
+        idx = string->length() - 1;
+}
+
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+inline int QTextDocument::x() const
+{
+    return cx;
+}
+
+inline int QTextDocument::y() const
+{
+    return cy;
+}
+
+inline int QTextDocument::width() const
+{
+    return QMAX( cw, flow_->width() );
+}
+
+inline int QTextDocument::visibleWidth() const
+{
+    return vw;
+}
+
+inline QTextParag *QTextDocument::firstParag() const
+{
+    return fParag;
+}
+
+inline QTextParag *QTextDocument::lastParag() const
+{
+    return lParag;
+}
+
+inline void QTextDocument::setFirstParag( QTextParag *p )
+{
+    fParag = p;
+}
+
+inline void QTextDocument::setLastParag( QTextParag *p )
+{
+    lParag = p;
+}
+
+inline void QTextDocument::setWidth( int w )
+{
+    cw = QMAX( w, minw );
+    flow_->setWidth( cw );
+    vw = w;
+}
+
+inline int QTextDocument::minimumWidth() const
+{
+    return minw;
+}
+
+inline void QTextDocument::setY( int y )
+{
+    cy = y;
+}
+
+inline int QTextDocument::leftMargin() const
+{
+    return leftmargin;
+}
+
+inline void QTextDocument::setLeftMargin( int lm )
+{
+    leftmargin = lm;
+}
+
+inline int QTextDocument::rightMargin() const
+{
+    return rightmargin;
+}
+
+inline void QTextDocument::setRightMargin( int rm )
+{
+    rightmargin = rm;
+}
+
+inline QTextPreProcessor *QTextDocument::preProcessor() const
+{
+    return pProcessor;
+}
+
+inline void QTextDocument::setPreProcessor( QTextPreProcessor * sh )
+{
+    pProcessor = sh;
+}
+
+inline void QTextDocument::setFormatter( QTextFormatter *f )
+{
+    delete pFormatter;
+    pFormatter = f;
+}
+
+inline QTextFormatter *QTextDocument::formatter() const
+{
+    return pFormatter;
+}
+
+inline void QTextDocument::setIndent( QTextIndent *i )
+{
+    indenter = i;
+}
+
+inline QTextIndent *QTextDocument::indent() const
+{
+    return indenter;
+}
+
+inline QColor QTextDocument::selectionColor( int id ) const
+{
+    return selectionColors[ id ];
+}
+
+inline bool QTextDocument::invertSelectionText( int id ) const
+{
+    return selectionText[ id ];
+}
+
+inline void QTextDocument::setSelectionColor( int id, const QColor &c )
+{
+    selectionColors[ id ] = c;
+}
+
+inline void QTextDocument::setInvertSelectionText( int id, bool b )
+{
+    selectionText[ id ] = b;
+}
+
+inline QTextFormatCollection *QTextDocument::formatCollection() const
+{
+    return fCollection;
+}
+
+inline int QTextDocument::alignment() const
+{
+    return align;
+}
+
+inline void QTextDocument::setAlignment( int a )
+{
+    align = a;
+}
+
+inline int *QTextDocument::tabArray() const
+{
+    return tArray;
+}
+
+inline int QTextDocument::tabStopWidth() const
+{
+    return tStopWidth;
+}
+
+inline void QTextDocument::setTabArray( int *a )
+{
+    tArray = a;
+}
+
+inline void QTextDocument::setTabStops( int tw )
+{
+    tStopWidth = tw;
+}
+
+inline QString QTextDocument::originalText() const
+{
+    if ( oTextValid )
+        return oText;
+    return text();
+}
+
+inline void QTextDocument::setFlow( QTextFlow *f )
+{
+    if ( flow_ )
+        delete flow_;
+    flow_ = f;
+}
+
+inline void QTextDocument::takeFlow()
+{
+    flow_ = 0;
+}
+
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+inline QColor QTextFormat::color() const
+{
+    return col;
+}
+
+inline QFont QTextFormat::font() const
+{
+    return fn;
+}
+
+inline bool QTextFormat::isMisspelled() const
+{
+    return missp;
+}
+
+inline QTextFormat::VerticalAlignment QTextFormat::vAlign() const
+{
+    return ha;
+}
+
+inline bool QTextFormat::operator==( const QTextFormat &f ) const
+{
+    return k == f.k;
+}
+
+inline QTextFormatCollection *QTextFormat::parent() const
+{
+    return collection;
+}
+
+inline void QTextFormat::addRef()
+{
+    ref++;
+#ifdef DEBUG_COLLECTION
+    qDebug( "add ref of '%s' to %d (%p)", k.latin1(), ref, this );
+#endif
+}
+
+inline void QTextFormat::removeRef()
+{
+    ref--;
+    if ( !collection )
+        return;
+    if ( this == collection->defFormat )
+        return;
+#ifdef DEBUG_COLLECTION
+    qDebug( "remove ref of '%s' to %d (%p)", k.latin1(), ref, this );
+#endif
+    if ( ref == 0 )
+        collection->remove( this );
+}
+
+inline QString QTextFormat::key() const
+{
+    return k;
+}
+
+inline bool QTextFormat::useLinkColor() const
+{
+    return linkColor;
+}
+
+inline void QTextFormat::setStyle( const QString &s )
+{
+    style = s;
+    updateStyleFlags();
+}
+
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+inline QTextStringChar &QTextString::at( int i ) const
+{
+    return data[ i ];
+}
+
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+inline QTextStringChar *QTextParag::at( int i ) const
+{
+    return &str->at( i );
+}
+
+inline bool QTextParag::isValid() const
+{
+    return invalid == -1;
+}
+
+inline bool QTextParag::hasChanged() const
+{
+    return changed;
+}
+
+inline void QTextParag::setBackgroundColor( const QColor & c )
+{
+    delete bgcol;
+    bgcol = new QColor( c );
+    setChanged( TRUE );
+}
+
+inline void QTextParag::clearBackgroundColor()
+{
+    delete bgcol; bgcol = 0; setChanged( TRUE );
+}
+
+inline void QTextParag::append( const QString &s, bool reallyAtEnd )
+{
+    if ( reallyAtEnd )
+        insert( str->length(), s );
+    else
+        insert( QMAX( str->length() - 1, 0 ), s );
+}
+
+inline QTextParag *QTextParag::prev() const
+{
+    return p;
+}
+
+inline QTextParag *QTextParag::next() const
+{
+    return n;
+}
+
+inline bool QTextParag::hasAnySelection() const
+{
+    return mSelections ? !selections().isEmpty() : FALSE;
+}
+
+inline void QTextParag::setEndState( int s )
+{
+    if ( s == state )
+        return;
+    state = s;
+}
+
+inline int QTextParag::endState() const
+{
+    return state;
+}
+
+inline void QTextParag::setParagId( int i )
+{
+    id = i;
+}
+
+inline int QTextParag::paragId() const
+{
+    if ( id == -1 )
+        qWarning( "invalid parag id!!!!!!!! (%p)", (void*)this );
+    return id;
+}
+
+inline bool QTextParag::firstPreProcess() const
+{
+    return firstPProcess;
+}
+
+inline void QTextParag::setFirstPreProcess( bool b )
+{
+    firstPProcess = b;
+}
+
+inline QMap<int, QTextParagLineStart*> &QTextParag::lineStartList()
+{
+    return lineStarts;
+}
+
+inline QTextString *QTextParag::string() const
+{
+    return str;
+}
+
+inline QTextDocument *QTextParag::document() const
+{
+    if ( hasdoc )
+        return (QTextDocument*) docOrPseudo;
+    return 0;
+}
+
+inline QTextParagPseudoDocument *QTextParag::pseudoDocument() const
+{
+    if ( hasdoc )
+        return 0;
+    return (QTextParagPseudoDocument*) docOrPseudo;
+}
+
+
+inline QTextTableCell *QTextParag::tableCell() const
+{
+    return hasdoc ? document()->tableCell () : 0;
+}
+
+inline QTextCommandHistory *QTextParag::commands() const
+{
+    return hasdoc ? document()->commands() : pseudoDocument()->commandHistory;
+}
+
+
+inline void QTextParag::setAlignment( int a )
+{
+    if ( a == (int)align )
+        return;
+    align = a;
+    invalidate( 0 );
+}
+
+inline void QTextParag::setListStyle( QStyleSheetItem::ListStyle ls )
+{
+    listS = ls;
+    invalidate( 0 );
+}
+
+inline QStyleSheetItem::ListStyle QTextParag::listStyle() const
+{
+    return listS;
+}
+
+inline QTextFormat *QTextParag::paragFormat() const
+{
+    return defFormat;
+}
+
+inline void QTextParag::registerFloatingItem( QTextCustomItem *i )
+{
+    floatingItems().append( i );
+}
+
+inline void QTextParag::unregisterFloatingItem( QTextCustomItem *i )
+{
+    floatingItems().removeRef( i );
+}
+
+inline QBrush *QTextParag::background() const
+{
+    return tableCell() ? tableCell()->backGround() : 0;
+}
+
+inline int QTextParag::documentWidth() const
+{
+    return hasdoc ? document()->width() : pseudoDocument()->docRect.width();
+}
+
+inline int QTextParag::documentVisibleWidth() const
+{
+    return hasdoc ? document()->visibleWidth() : pseudoDocument()->docRect.width();
+}
+
+inline int QTextParag::documentX() const
+{
+    return hasdoc ? document()->x() : pseudoDocument()->docRect.x();
+}
+
+inline int QTextParag::documentY() const
+{
+    return hasdoc ? document()->y() : pseudoDocument()->docRect.y();
+}
+
+inline void QTextParag::setExtraData( QTextParagData *data )
+{
+    eData = data;
+}
+
+inline QTextParagData *QTextParag::extraData() const
+{
+    return eData;
+}
+
+inline void QTextParag::setNewLinesAllowed( bool b )
+{
+    newLinesAllowed = b;
+}
+
+inline bool QTextParag::isNewLinesAllowed() const
+{
+    return newLinesAllowed;
+}
+
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+inline void QTextFormatCollection::setDefaultFormat( QTextFormat *f )
+{
+    defFormat = f;
+}
+
+inline QTextFormat *QTextFormatCollection::defaultFormat() const
+{
+    return defFormat;
+}
+
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+inline QTextFormat *QTextStringChar::format() const
+{
+    return (type == Regular) ? d.format : d.custom->format;
+}
+
+
+inline QTextCustomItem *QTextStringChar::customItem() const
+{
+    return isCustom() ? d.custom->custom : 0;
+}
+
+inline int QTextStringChar::height() const
+{
+    return !isCustom() ? format()->height() : ( customItem()->placement() == QTextCustomItem::PlaceInline ? customItem()->height : 0 );
+}
+
+inline int QTextStringChar::ascent() const
+{
+    return !isCustom() ? format()->ascent() : ( customItem()->placement() == QTextCustomItem::PlaceInline ? customItem()->ascent() : 0 );
+}
+
+inline int QTextStringChar::descent() const
+{
+    return !isCustom() ? format()->descent() : 0;
+}
+
+} // namespace Qt3
+
+#endif