Test conversion to TQt3 from Qt3 8c6fc1f8e35fd264dd01c582ca5e7549b32ab731

1 files changed, 2141 insertions, 0 deletions

diff --git a/src/kernel/qrichtext_p.h b/src/kernel/qrichtext_p.h
new file mode 100644
index 000000000..b203044af
--- /dev/null
+++ b/src/kernel/qrichtext_p.h
@@ -0,0 +1,2141 @@
+/****************************************************************************
+**
+** Definition of internal rich text classes
+**
+** Created : 990124
+**
+** Copyright (C) 1999-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the kernel module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing retquirements 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.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef TQRICHTEXT_P_H
+#define TQRICHTEXT_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the TQt API.  It exists for the convenience
+// of a number of TQt sources files.  This header file may change from
+// version to version without notice, or even be removed.
+//
+// We mean it.
+//
+//
+
+#ifndef QT_H
+#include "qstring.h"
+#include "qptrlist.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 "qpixmap.h"
+#include "qstylesheet.h"
+#include "qptrvector.h"
+#include "qpainter.h"
+#include "qlayout.h"
+#include "qobject.h"
+#include "qapplication.h"
+#endif // QT_H
+
+#ifndef QT_NO_RICHTEXT
+
+class TQTextDocument;
+class TQTextString;
+class TQTextPreProcessor;
+class TQTextFormat;
+class TQTextCursor;
+class TQTextParagraph;
+class TQTextFormatter;
+class TQTextIndent;
+class TQTextFormatCollection;
+class TQStyleSheetItem;
+#ifndef QT_NO_TEXTCUSTOMITEM
+class TQTextCustomItem;
+#endif
+class TQTextFlow;
+struct TQBidiContext;
+
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+class Q_EXPORT TQTextStringChar
+{
+    friend class TQTextString;
+
+public:
+    // this is never called, initialize variables in TQTextString::insert()!!!
+    TQTextStringChar() : nobreak(FALSE), lineStart( 0 ), type( Regular ) {d.format=0;}
+    ~TQTextStringChar();
+
+    struct CustomData
+    {
+	TQTextFormat *format;
+#ifndef QT_NO_TEXTCUSTOMITEM
+	TQTextCustomItem *custom;
+#endif
+	TQString anchorName;
+	TQString anchorHref;
+    };
+    enum Type { Regular=0, Custom=1, Anchor=2, CustomAnchor=3 };
+
+    TQChar 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 wordStop       :1;     // Valid cursor position (for ctrl + left/right arrow)
+    uchar nobreak        :1;
+
+    uchar lineStart : 1;
+    uchar /*Type*/ type : 2;
+    uchar bidiLevel       :7;
+    uchar rightToLeft : 1;
+
+    int x;
+    union {
+	TQTextFormat* format;
+	CustomData* custom;
+    } d;
+
+
+    int height() const;
+    int ascent() const;
+    int descent() const;
+    bool isCustom() const { return (type & Custom) != 0; }
+    TQTextFormat *format() const;
+#ifndef QT_NO_TEXTCUSTOMITEM
+    TQTextCustomItem *customItem() const;
+#endif
+    void setFormat( TQTextFormat *f );
+#ifndef QT_NO_TEXTCUSTOMITEM
+    void setCustomItem( TQTextCustomItem *i );
+#endif
+
+#ifndef QT_NO_TEXTCUSTOMITEM
+    void loseCustomItem();
+#endif
+
+
+    bool isAnchor() const { return ( type & Anchor) != 0; }
+    bool isLink() const { return isAnchor() && !!d.custom->anchorHref; }
+    TQString anchorName() const;
+    TQString anchorHref() const;
+    void setAnchor( const TQString& name, const TQString& href );
+
+private:
+    TQTextStringChar &operator=( const TQTextStringChar & ) {
+	//abort();
+	return *this;
+    }
+    TQTextStringChar( const TQTextStringChar & ) {
+    }
+    friend class TQTextParagraph;
+};
+
+#if defined(Q_TEMPLATEDLL)
+// MOC_SKIP_BEGIN
+Q_TEMPLATE_EXTERN template class Q_EXPORT TQMemArray<TQTextStringChar>;
+// MOC_SKIP_END
+#endif
+
+class Q_EXPORT TQTextString
+{
+public:
+
+    TQTextString();
+    TQTextString( const TQTextString &s );
+    virtual ~TQTextString();
+
+    static TQString toString( const TQMemArray<TQTextStringChar> &data );
+    TQString toString() const;
+
+    inline TQTextStringChar &at( int i ) const { return data[ i ]; }
+    inline int length() const { return data.size(); }
+
+    int width( int idx ) const;
+
+    void insert( int index, const TQString &s, TQTextFormat *f );
+    void insert( int index, const TQChar *unicode, int len, TQTextFormat *f );
+    void insert( int index, TQTextStringChar *c, bool doAddRefFormat = FALSE );
+    void truncate( int index );
+    void remove( int index, int len );
+    void clear();
+
+    void setFormat( int index, TQTextFormat *f, bool useCollection );
+
+    void setBidi( bool b ) { bidi = b; }
+    bool isBidi() const;
+    bool isRightToLeft() const;
+    TQChar::Direction direction() const;
+    void setDirection( TQChar::Direction d ) { dir = d; bidiDirty = TRUE; }
+
+    TQMemArray<TQTextStringChar> rawData() const { return data.copy(); }
+
+    void operator=( const TQString &s ) { clear(); insert( 0, s, 0 ); }
+    void operator+=( const TQString &s ) { insert( length(), s, 0 ); }
+    void prepend( const TQString &s ) { insert( 0, s, 0 ); }
+    int appendParagraphs( TQTextParagraph *start, TQTextParagraph *end );
+
+    // return next and previous valid cursor positions.
+    bool validCursorPosition( int idx );
+    int nextCursorPosition( int idx );
+    int previousCursorPosition( int idx );
+
+private:
+    void checkBidi() const;
+
+    TQMemArray<TQTextStringChar> data;
+    TQString stringCache;
+    uint bidiDirty : 1;
+    uint bidi : 1; // true when the paragraph has right to left characters
+    uint rightToLeft : 1;
+    uint dir : 5;
+};
+
+inline bool TQTextString::isBidi() const
+{
+    if ( bidiDirty )
+	checkBidi();
+    return bidi;
+}
+
+inline bool TQTextString::isRightToLeft() const
+{
+    if ( bidiDirty )
+	checkBidi();
+    return rightToLeft;
+}
+
+inline TQString TQTextString::toString() const
+{
+    if(bidiDirty)
+        checkBidi();
+    return stringCache;
+}
+
+inline TQChar::Direction TQTextString::direction() const
+{
+    return (TQChar::Direction) dir;
+}
+
+inline int TQTextString::nextCursorPosition( int next )
+{
+    if ( bidiDirty )
+	checkBidi();
+
+    const TQTextStringChar *c = data.data();
+    int len = length();
+
+    if ( next < len - 1 ) {
+	next++;
+	while ( next < len - 1 && !c[next].charStop )
+	    next++;
+    }
+    return next;
+}
+
+inline int TQTextString::previousCursorPosition( int prev )
+{
+    if ( bidiDirty )
+	checkBidi();
+
+    const TQTextStringChar *c = data.data();
+
+    if ( prev ) {
+	prev--;
+	while ( prev && !c[prev].charStop )
+	    prev--;
+    }
+    return prev;
+}
+
+inline bool TQTextString::validCursorPosition( int idx )
+{
+    if ( bidiDirty )
+	checkBidi();
+
+    return (at( idx ).charStop);
+}
+
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+#if defined(Q_TEMPLATEDLL)
+// MOC_SKIP_BEGIN
+Q_TEMPLATE_EXTERN template class Q_EXPORT TQValueStack<int>;
+Q_TEMPLATE_EXTERN template class Q_EXPORT TQValueStack<TQTextParagraph*>;
+Q_TEMPLATE_EXTERN template class Q_EXPORT TQValueStack<bool>;
+// MOC_SKIP_END
+#endif
+
+class Q_EXPORT TQTextCursor
+{
+public:
+    TQTextCursor( TQTextDocument *d = 0 );
+    TQTextCursor( const TQTextCursor &c );
+    TQTextCursor &operator=( const TQTextCursor &c );
+    virtual ~TQTextCursor() {}
+
+    bool operator==( const TQTextCursor &c ) const;
+    bool operator!=( const TQTextCursor &c ) const { return !(*this == c); }
+
+    inline TQTextParagraph *paragraph() const { return para; }
+
+    TQTextDocument *document() const;
+    int index() const;
+
+    void gotoPosition( TQTextParagraph* p, int index = 0);
+    void setIndex( int index ) { gotoPosition(paragraph(), index ); }
+    void setParagraph( TQTextParagraph*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 TQString &s, bool checkNewLine, TQMemArray<TQTextStringChar> *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;
+
+    TQTextParagraph *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 TQPoint &pos, TQTextParagraph *s ) { return place( pos, s, FALSE ); }
+    bool place( const TQPoint &pos, TQTextParagraph *s, bool link ) { return place( pos, s, link, TRUE, TRUE ); }
+    bool place( const TQPoint &pos, TQTextParagraph *s, bool link, bool loosePlacing, bool matchBetweenCharacters );
+    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 TQPoint &globalPos );
+
+    TQTextParagraph *para;
+    int idx, tmpX;
+    int ox, oy;
+    TQValueStack<int> indices;
+    TQValueStack<TQTextParagraph*> paras;
+    TQValueStack<int> xOffsets;
+    TQValueStack<int> yOffsets;
+    uint valid : 1;
+
+};
+
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+class Q_EXPORT TQTextCommand
+{
+public:
+    enum Commands { Invalid, Insert, Delete, Format, Style };
+
+    TQTextCommand( TQTextDocument *d ) : doc( d ), cursor( d ) {}
+    virtual ~TQTextCommand();
+
+    virtual Commands type() const;
+
+    virtual TQTextCursor *execute( TQTextCursor *c ) = 0;
+    virtual TQTextCursor *unexecute( TQTextCursor *c ) = 0;
+
+protected:
+    TQTextDocument *doc;
+    TQTextCursor cursor;
+
+};
+
+#if defined(Q_TEMPLATEDLL)
+// MOC_SKIP_BEGIN
+Q_TEMPLATE_EXTERN template class Q_EXPORT TQPtrList<TQTextCommand>;
+// MOC_SKIP_END
+#endif
+
+class Q_EXPORT TQTextCommandHistory
+{
+public:
+    TQTextCommandHistory( int s ) : current( -1 ), steps( s ) { history.setAutoDelete( TRUE ); }
+    virtual ~TQTextCommandHistory();
+
+    void clear() { history.clear(); current = -1; }
+
+    void addCommand( TQTextCommand *cmd );
+    TQTextCursor *undo( TQTextCursor *c );
+    TQTextCursor *redo( TQTextCursor *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:
+    TQPtrList<TQTextCommand> history;
+    int current, steps;
+
+};
+
+inline TQTextCommandHistory::~TQTextCommandHistory()
+{
+    clear();
+}
+
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+#ifndef QT_NO_TEXTCUSTOMITEM
+class Q_EXPORT TQTextCustomItem
+{
+public:
+    TQTextCustomItem( TQTextDocument *p )
+	:  xpos(0), ypos(-1), width(-1), height(0), parent( p )
+    {}
+    virtual ~TQTextCustomItem();
+    virtual void draw(TQPainter* p, int x, int y, int cx, int cy, int cw, int ch, const TQColorGroup& cg, bool selected ) = 0;
+
+    virtual void adjustToPainter( TQPainter* );
+
+    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 TQString richText() const;
+
+    int xpos; // used for floating items
+    int ypos; // used for floating items
+    int width;
+    int height;
+
+    TQRect geometry() const { return TQRect( xpos, ypos, width, height ); }
+
+    virtual bool enter( TQTextCursor *, TQTextDocument *&doc, TQTextParagraph *&parag, int &idx, int &ox, int &oy, bool atEnd = FALSE );
+    virtual bool enterAt( TQTextCursor *, TQTextDocument *&doc, TQTextParagraph *&parag, int &idx, int &ox, int &oy, const TQPoint & );
+    virtual bool next( TQTextCursor *, TQTextDocument *&doc, TQTextParagraph *&parag, int &idx, int &ox, int &oy );
+    virtual bool prev( TQTextCursor *, TQTextDocument *&doc, TQTextParagraph *&parag, int &idx, int &ox, int &oy );
+    virtual bool down( TQTextCursor *, TQTextDocument *&doc, TQTextParagraph *&parag, int &idx, int &ox, int &oy );
+    virtual bool up( TQTextCursor *, TQTextDocument *&doc, TQTextParagraph *&parag, int &idx, int &ox, int &oy );
+
+    virtual void setParagraph( TQTextParagraph *p ) { parag = p; }
+    TQTextParagraph *paragraph() const { return parag; }
+
+    TQTextDocument *parent;
+    TQTextParagraph *parag;
+
+    virtual void pageBreak( int  y, TQTextFlow* flow );
+};
+#endif
+
+#if defined(Q_TEMPLATEDLL)
+// MOC_SKIP_BEGIN
+//Q_TEMPLATE_EXTERN template class Q_EXPORT TQMap<TQString, TQString>;
+// MOC_SKIP_END
+#endif
+
+#ifndef QT_NO_TEXTCUSTOMITEM
+class Q_EXPORT TQTextImage : public TQTextCustomItem
+{
+public:
+    TQTextImage( TQTextDocument *p, const TQMap<TQString, TQString> &attr, const TQString& context,
+		TQMimeSourceFactory &factory );
+    virtual ~TQTextImage();
+
+    Placement placement() const { return place; }
+    void adjustToPainter( TQPainter* );
+    int minimumWidth() const { return width; }
+
+    TQString richText() const;
+
+    void draw( TQPainter* p, int x, int y, int cx, int cy, int cw, int ch, const TQColorGroup& cg, bool selected );
+
+private:
+    TQRegion* reg;
+    TQPixmap pm;
+    Placement place;
+    int tmpwidth, tmpheight;
+    TQMap<TQString, TQString> attributes;
+    TQString imgId;
+
+};
+#endif
+
+#ifndef QT_NO_TEXTCUSTOMITEM
+class Q_EXPORT TQTextHorizontalLine : public TQTextCustomItem
+{
+public:
+    TQTextHorizontalLine( TQTextDocument *p, const TQMap<TQString, TQString> &attr, const TQString& context,
+			 TQMimeSourceFactory &factory );
+    virtual ~TQTextHorizontalLine();
+
+    void adjustToPainter( TQPainter* );
+    void draw(TQPainter* p, int x, int y, int cx, int cy, int cw, int ch, const TQColorGroup& cg, bool selected );
+    TQString richText() const;
+
+    bool ownLine() const { return TRUE; }
+
+private:
+    int tmpheight;
+    TQColor color;
+    bool shade;
+
+};
+#endif
+
+#ifndef QT_NO_TEXTCUSTOMITEM
+#if defined(Q_TEMPLATEDLL)
+// MOC_SKIP_BEGIN
+Q_TEMPLATE_EXTERN template class Q_EXPORT TQPtrList<TQTextCustomItem>;
+// MOC_SKIP_END
+#endif
+#endif
+
+class Q_EXPORT TQTextFlow
+{
+    friend class TQTextDocument;
+#ifndef QT_NO_TEXTCUSTOMITEM
+    friend class TQTextTableCell;
+#endif
+
+public:
+    TQTextFlow();
+    virtual ~TQTextFlow();
+
+    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( TQTextCustomItem* item );
+    virtual void unregisterFloatingItem( TQTextCustomItem* item );
+#endif
+    virtual TQRect boundingRect() const;
+    virtual void drawFloatingItems(TQPainter* p, int cx, int cy, int cw, int ch, const TQColorGroup& 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;
+
+#ifndef QT_NO_TEXTCUSTOMITEM
+    TQPtrList<TQTextCustomItem> leftItems;
+    TQPtrList<TQTextCustomItem> rightItems;
+#endif
+};
+
+inline int TQTextFlow::width() const { return w; }
+
+#ifndef QT_NO_TEXTCUSTOMITEM
+class TQTextTable;
+
+class Q_EXPORT TQTextTableCell : public TQLayoutItem
+{
+    friend class TQTextTable;
+
+public:
+    TQTextTableCell( TQTextTable* table,
+		    int row, int column,
+		    const TQMap<TQString, TQString> &attr,
+		    const TQStyleSheetItem* style,
+		    const TQTextFormat& fmt, const TQString& context,
+		    TQMimeSourceFactory &factory, TQStyleSheet *sheet, const TQString& doc );
+    virtual ~TQTextTableCell();
+
+    TQSize sizeHint() const ;
+    TQSize minimumSize() const ;
+    TQSize maximumSize() const ;
+    TQSizePolicy::ExpandData expanding() const;
+    bool isEmpty() const;
+    void setGeometry( const TQRect& ) ;
+    TQRect geometry() const;
+
+    bool hasHeightForWidth() const;
+    int heightForWidth( int ) const;
+
+    void adjustToPainter( TQPainter* );
+
+    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_; }
+
+    TQTextDocument* richText()  const { return richtext; }
+    TQTextTable* table() const { return parent; }
+
+    void draw( TQPainter* p, int x, int y, int cx, int cy, int cw, int ch, const TQColorGroup& cg, bool selected );
+
+    TQBrush *backGround() const { return background; }
+    virtual void invalidate();
+
+    int verticalAlignmentOffset() const;
+    int horizontalAlignmentOffset() const;
+
+private:
+    TQRect geom;
+    TQTextTable* parent;
+    TQTextDocument* richtext;
+    int row_;
+    int col_;
+    int rowspan_;
+    int colspan_;
+    int stretch_;
+    int maxw;
+    int minw;
+    bool hasFixedWidth;
+    TQBrush *background;
+    int cached_width;
+    int cached_sizehint;
+    TQMap<TQString, TQString> attributes;
+    int align;
+};
+#endif
+
+#if defined(Q_TEMPLATEDLL)
+// MOC_SKIP_BEGIN
+Q_TEMPLATE_EXTERN template class Q_EXPORT TQPtrList<TQTextTableCell>;
+Q_TEMPLATE_EXTERN template class Q_EXPORT TQMap<TQTextCursor*, int>;
+// MOC_SKIP_END
+#endif
+
+#ifndef QT_NO_TEXTCUSTOMITEM
+class Q_EXPORT TQTextTable: public TQTextCustomItem
+{
+    friend class TQTextTableCell;
+
+public:
+    TQTextTable( TQTextDocument *p, const TQMap<TQString, TQString> &attr );
+    virtual ~TQTextTable();
+
+    void adjustToPainter( TQPainter *p );
+    void pageBreak( int  y, TQTextFlow* flow );
+    void draw( TQPainter* p, int x, int y, int cx, int cy, int cw, int ch,
+	       const TQColorGroup& 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( TQTextCursor *c, TQTextDocument *&doc, TQTextParagraph *&parag, int &idx, int &ox, int &oy, bool atEnd = FALSE );
+    virtual bool enterAt( TQTextCursor *c, TQTextDocument *&doc, TQTextParagraph *&parag, int &idx, int &ox, int &oy, const TQPoint &pos );
+    virtual bool next( TQTextCursor *c, TQTextDocument *&doc, TQTextParagraph *&parag, int &idx, int &ox, int &oy );
+    virtual bool prev( TQTextCursor *c, TQTextDocument *&doc, TQTextParagraph *&parag, int &idx, int &ox, int &oy );
+    virtual bool down( TQTextCursor *c, TQTextDocument *&doc, TQTextParagraph *&parag, int &idx, int &ox, int &oy );
+    virtual bool up( TQTextCursor *c, TQTextDocument *&doc, TQTextParagraph *&parag, int &idx, int &ox, int &oy );
+
+    TQString richText() const;
+
+    int minimumWidth() const;
+
+    TQPtrList<TQTextTableCell> tableCells() const { return cells; }
+
+    bool isStretching() const { return stretch; }
+    void setParagraph(TQTextParagraph *p);
+
+private:
+    void format( int w );
+    void addCell( TQTextTableCell* cell );
+
+private:
+    TQGridLayout* layout;
+    TQPtrList<TQTextTableCell> 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;
+    TQMap<TQString, TQString> attributes;
+    TQMap<TQTextCursor*, int> currCell;
+    Placement place;
+    void adjustCells( int y , int shift );
+    int pageBreakFor;
+};
+#endif
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+#ifndef QT_NO_TEXTCUSTOMITEM
+class TQTextTableCell;
+class TQTextParagraph;
+#endif
+
+struct Q_EXPORT TQTextDocumentSelection
+{
+    TQTextCursor startCursor, endCursor;
+    bool swapped;
+    Q_DUMMY_COMPARISON_OPERATOR(TQTextDocumentSelection)
+};
+
+#if defined(Q_TEMPLATEDLL)
+// MOC_SKIP_BEGIN
+Q_TEMPLATE_EXTERN template class Q_EXPORT TQMap<int, TQColor>;
+//Q_TEMPLATE_EXTERN template class Q_EXPORT TQMap<int, bool>;
+Q_TEMPLATE_EXTERN template class Q_EXPORT TQMap<int, TQTextDocumentSelection>;
+Q_TEMPLATE_EXTERN template class Q_EXPORT TQPtrList<TQTextDocument>;
+// MOC_SKIP_END
+#endif
+
+class Q_EXPORT TQTextDocument : public TQObject
+{
+    Q_OBJECT
+
+#ifndef QT_NO_TEXTCUSTOMITEM
+    friend class TQTextTableCell;
+#endif
+    friend class TQTextCursor;
+    friend class TQTextEdit;
+    friend class TQTextParagraph;
+    friend class TQTextTable;
+
+public:
+    enum SelectionIds {
+	Standard = 0,
+	IMSelectionText		= 31998,
+	IMCompositionText	= 31999, // this must be higher!
+	Temp = 32000 // This selection must not be drawn, it's used e.g. by undo/redo to
+	// remove multiple lines with removeSelectedText()
+    };
+
+    TQTextDocument( TQTextDocument *p );
+    virtual ~TQTextDocument();
+
+    TQTextDocument *parent() const { return par; }
+    TQTextParagraph *parentParagraph() const { return parentPar; }
+
+    void setText( const TQString &text, const TQString &context );
+    TQMap<TQString, TQString> attributes() const { return attribs; }
+    void setAttributes( const TQMap<TQString, TQString> &attr ) { attribs = attr; }
+
+    TQString text() const;
+    TQString text( int parag ) const;
+    TQString 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, TQTextParagraph *parag = 0 );
+
+    void setY( int y );
+    int leftMargin() const;
+    void setLeftMargin( int lm );
+    int rightMargin() const;
+    void setRightMargin( int rm );
+
+    TQTextParagraph *firstParagraph() const;
+    TQTextParagraph *lastParagraph() const;
+    void setFirstParagraph( TQTextParagraph *p );
+    void setLastParagraph( TQTextParagraph *p );
+
+    void invalidate();
+
+    void setPreProcessor( TQTextPreProcessor *sh );
+    TQTextPreProcessor *preProcessor() const;
+
+    void setFormatter( TQTextFormatter *f );
+    TQTextFormatter *formatter() const;
+
+    void setIndent( TQTextIndent *i );
+    TQTextIndent *indent() const;
+
+    TQColor selectionColor( int id ) const;
+    bool invertSelectionText( int id ) const;
+    void setSelectionColor( int id, const TQColor &c );
+    void setInvertSelectionText( int id, bool b );
+    bool hasSelection( int id, bool visible = FALSE ) const;
+    void setSelectionStart( int id, const TQTextCursor &cursor );
+    bool setSelectionEnd( int id, const TQTextCursor &cursor );
+    void selectAll( int id );
+    bool removeSelection( int id );
+    void selectionStart( int id, int &paragId, int &index );
+    TQTextCursor selectionStartCursor( int id );
+    TQTextCursor selectionEndCursor( int id );
+    void selectionEnd( int id, int &paragId, int &index );
+    void setFormat( int id, TQTextFormat *f, int flags );
+    int numSelections() const { return nSelections; }
+    void addSelection( int id );
+
+    TQString selectedText( int id, bool asRichText = FALSE ) const;
+    void removeSelectedText( int id, TQTextCursor *cursor );
+    void indentSelection( int id );
+
+    TQTextParagraph *paragAt( int i ) const;
+
+    void addCommand( TQTextCommand *cmd );
+    TQTextCursor *undo( TQTextCursor *c = 0 );
+    TQTextCursor *redo( TQTextCursor *c  = 0 );
+    TQTextCommandHistory *commands() const { return commandHistory; }
+
+    TQTextFormatCollection *formatCollection() const;
+
+    bool find( TQTextCursor &cursor, const TQString &expr, bool cs, bool wo, bool forward);
+
+    void setTextFormat( TQt::TextFormat f );
+    TQt::TextFormat textFormat() const;
+
+    bool inSelection( int selId, const TQPoint &pos ) const;
+
+    TQStyleSheet *styleSheet() const { return sheet_; }
+#ifndef QT_NO_MIME
+    TQMimeSourceFactory *mimeSourceFactory() const { return factory_; }
+#endif
+    TQString context() const { return contxt; }
+
+    void setStyleSheet( TQStyleSheet *s );
+    void setDefaultFormat( const TQFont &font, const TQColor &color );
+#ifndef QT_NO_MIME
+    void setMimeSourceFactory( TQMimeSourceFactory *f ) { if ( f ) factory_ = f; }
+#endif
+    void setContext( const TQString &c ) { if ( !c.isEmpty() ) contxt = c; }
+
+    void setUnderlineLinks( bool b );
+    bool underlineLinks() const { return underlLinks; }
+
+    void setPaper( TQBrush *brush ) { if ( backBrush ) delete backBrush; backBrush = brush; }
+    TQBrush *paper() const { return backBrush; }
+
+    void doLayout( TQPainter *p, int w );
+    void draw( TQPainter *p, const TQRect& rect, const TQColorGroup &cg, const TQBrush *paper = 0 );
+    bool useDoubleBuffer( TQTextParagraph *parag, TQPainter *p );
+
+    void drawParagraph( TQPainter *p, TQTextParagraph *parag, int cx, int cy, int cw, int ch,
+		    TQPixmap *&doubleBuffer, const TQColorGroup &cg,
+		    bool drawCursor, TQTextCursor *cursor, bool resetChanged = TRUE );
+    TQTextParagraph *draw( TQPainter *p, int cx, int cy, int cw, int ch, const TQColorGroup &cg,
+		      bool onlyChanged = FALSE, bool drawCursor = FALSE, TQTextCursor *cursor = 0,
+		      bool resetChanged = TRUE );
+
+#ifndef QT_NO_TEXTCUSTOMITEM
+    void registerCustomItem( TQTextCustomItem *i, TQTextParagraph *p );
+    void unregisterCustomItem( TQTextCustomItem *i, TQTextParagraph *p );
+#endif
+
+    void setFlow( TQTextFlow *f );
+    void takeFlow();
+    TQTextFlow *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
+    TQTextTableCell *tableCell() const { return tc; }
+    void setTableCell( TQTextTableCell *c ) { tc = c; }
+#endif
+
+    void setPlainText( const TQString &text );
+    void setRichText( const TQString &text, const TQString &context, const TQTextFormat *initialFormat = 0 );
+    TQString richText() const;
+    TQString 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 d ) { commandHistory->setUndoDepth( d ); }
+    int undoDepth() const { return commandHistory->undoDepth(); }
+
+    int length() const;
+    void clear( bool createEmptyParag = FALSE );
+
+    virtual TQTextParagraph *createParagraph( TQTextDocument *d, TQTextParagraph *pr = 0, TQTextParagraph *nx = 0, bool updateIds = TRUE );
+    void insertChild( TQObject *o ) { TQObject::insertChild( o ); }
+    void removeChild( TQObject *o ) { TQObject::removeChild( o ); }
+    void insertChild( TQTextDocument *d ) { childList.append( d ); }
+    void removeChild( TQTextDocument *d ) { childList.removeRef( d ); }
+    TQPtrList<TQTextDocument> children() const { return childList; }
+
+    bool hasFocusParagraph() const;
+    TQString focusHref() const;
+    TQString focusName() const;
+
+    void invalidateOriginalText() { oTextValid = FALSE; oText = ""; }
+
+signals:
+    void minimumWidthChanged( int );
+
+private:
+    void init();
+    TQPixmap *bufferPixmap( const TQSize &s );
+    // HTML parser
+    bool hasPrefix(const TQChar* doc, int length, int pos, TQChar c);
+    bool hasPrefix(const TQChar* doc, int length, int pos, const TQString& s);
+#ifndef QT_NO_TEXTCUSTOMITEM
+    TQTextCustomItem* parseTable( const TQMap<TQString, TQString> &attr, const TQTextFormat &fmt,
+				 const TQChar* doc, int length, int& pos, TQTextParagraph *curpar );
+#endif
+    bool eatSpace(const TQChar* doc, int length, int& pos, bool includeNbsp = FALSE );
+    bool eat(const TQChar* doc, int length, int& pos, TQChar c);
+    TQString parseOpenTag(const TQChar* doc, int length, int& pos, TQMap<TQString, TQString> &attr, bool& emptyTag);
+    TQString parseCloseTag( const TQChar* doc, int length, int& pos );
+    TQChar parseHTMLSpecialChar(const TQChar* doc, int length, int& pos);
+    TQString parseWord(const TQChar* doc, int length, int& pos, bool lower = TRUE);
+    TQChar parseChar(const TQChar* doc, int length, int& pos, TQStyleSheetItem::WhiteSpaceMode wsm );
+    void setRichTextInternal( const TQString &text, TQTextCursor* cursor = 0, const TQTextFormat *initialFormat = 0 );
+    void setRichTextMarginsInternal( TQPtrList< TQPtrVector<TQStyleSheetItem> >& styles, TQTextParagraph* stylesPar );
+
+private:
+    struct Q_EXPORT Focus {
+	TQTextParagraph *parag;
+	int start, len;
+	TQString href;
+	TQString name;
+    };
+
+    int cx, cy, cw, vw;
+    TQTextParagraph *fParag, *lParag;
+    TQTextPreProcessor *pProcessor;
+    TQMap<int, TQColor> selectionColors;
+    TQMap<int, TQTextDocumentSelection> selections;
+    TQMap<int, bool> selectionText;
+    TQTextCommandHistory *commandHistory;
+    TQTextFormatter *pFormatter;
+    TQTextIndent *indenter;
+    TQTextFormatCollection *fCollection;
+    TQt::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;
+    TQTextFlow *flow_;
+    TQTextDocument *par;
+    TQTextParagraph *parentPar;
+#ifndef QT_NO_TEXTCUSTOMITEM
+    TQTextTableCell *tc;
+#endif
+    TQBrush *backBrush;
+    TQPixmap *buf_pixmap;
+    Focus focusIndicator;
+    int minw;
+    int wused;
+    int leftmargin;
+    int rightmargin;
+    TQTextParagraph *minwParag, *curParag;
+    TQStyleSheet* sheet_;
+#ifndef QT_NO_MIME
+    TQMimeSourceFactory* factory_;
+#endif
+    TQString contxt;
+    TQMap<TQString, TQString> attribs;
+    int *tArray;
+    int tStopWidth;
+    int uDepth;
+    TQString oText;
+    TQPtrList<TQTextDocument> childList;
+    TQColor linkColor, bodyText;
+    double scaleFontsFactor;
+
+    short list_tm,list_bm, list_lm, li_tm, li_bm, par_tm, par_bm;
+#if defined(Q_DISABLE_COPY) // Disabled copy constructor and operator=
+    TQTextDocument( const TQTextDocument & );
+    TQTextDocument &operator=( const TQTextDocument & );
+#endif
+};
+
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+
+class Q_EXPORT TQTextDeleteCommand : public TQTextCommand
+{
+public:
+    TQTextDeleteCommand( TQTextDocument *d, int i, int idx, const TQMemArray<TQTextStringChar> &str,
+			const TQByteArray& oldStyle );
+    TQTextDeleteCommand( TQTextParagraph *p, int idx, const TQMemArray<TQTextStringChar> &str );
+    virtual ~TQTextDeleteCommand();
+
+    Commands type() const { return Delete; }
+    TQTextCursor *execute( TQTextCursor *c );
+    TQTextCursor *unexecute( TQTextCursor *c );
+
+protected:
+    int id, index;
+    TQTextParagraph *parag;
+    TQMemArray<TQTextStringChar> text;
+    TQByteArray styleInformation;
+
+};
+
+class Q_EXPORT TQTextInsertCommand : public TQTextDeleteCommand
+{
+public:
+    TQTextInsertCommand( TQTextDocument *d, int i, int idx, const TQMemArray<TQTextStringChar> &str,
+			const TQByteArray& oldStyleInfo )
+	: TQTextDeleteCommand( d, i, idx, str, oldStyleInfo ) {}
+    TQTextInsertCommand( TQTextParagraph *p, int idx, const TQMemArray<TQTextStringChar> &str )
+	: TQTextDeleteCommand( p, idx, str ) {}
+    virtual ~TQTextInsertCommand() {}
+
+    Commands type() const { return Insert; }
+    TQTextCursor *execute( TQTextCursor *c ) { return TQTextDeleteCommand::unexecute( c ); }
+    TQTextCursor *unexecute( TQTextCursor *c ) { return TQTextDeleteCommand::execute( c ); }
+
+};
+
+class Q_EXPORT TQTextFormatCommand : public TQTextCommand
+{
+public:
+    TQTextFormatCommand( TQTextDocument *d, int sid, int sidx, int eid, int eidx, const TQMemArray<TQTextStringChar> &old, TQTextFormat *f, int fl );
+    virtual ~TQTextFormatCommand();
+
+    Commands type() const { return Format; }
+    TQTextCursor *execute( TQTextCursor *c );
+    TQTextCursor *unexecute( TQTextCursor *c );
+
+protected:
+    int startId, startIndex, endId, endIndex;
+    TQTextFormat *format;
+    TQMemArray<TQTextStringChar> oldFormats;
+    int flags;
+
+};
+
+class Q_EXPORT TQTextStyleCommand : public TQTextCommand
+{
+public:
+    TQTextStyleCommand( TQTextDocument *d, int fParag, int lParag, const TQByteArray& beforeChange  );
+    virtual ~TQTextStyleCommand() {}
+
+    Commands type() const { return Style; }
+    TQTextCursor *execute( TQTextCursor *c );
+    TQTextCursor *unexecute( TQTextCursor *c );
+
+    static TQByteArray readStyleInformation(  TQTextDocument* d, int fParag, int lParag );
+    static void writeStyleInformation(  TQTextDocument* d, int fParag, const TQByteArray& style );
+
+private:
+    int firstParag, lastParag;
+    TQByteArray before;
+    TQByteArray after;
+};
+
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+struct Q_EXPORT TQTextParagraphSelection
+{
+    TQTextParagraphSelection() : start(0), end(0) { }
+    int start, end;
+    Q_DUMMY_COMPARISON_OPERATOR(TQTextParagraphSelection)
+};
+
+struct Q_EXPORT TQTextLineStart
+{
+    TQTextLineStart() : y( 0 ), baseLine( 0 ), h( 0 )
+    {  }
+    TQTextLineStart( int y_, int bl, int h_ ) : y( y_ ), baseLine( bl ), h( h_ ),
+	w( 0 )
+    {  }
+
+public:
+    int y, baseLine, h;
+    int w;
+};
+
+#if defined(Q_TEMPLATEDLL)
+// MOC_SKIP_BEGIN
+Q_TEMPLATE_EXTERN template class Q_EXPORT TQMap<int, TQTextParagraphSelection>;
+Q_TEMPLATE_EXTERN template class Q_EXPORT TQMap<int, TQTextLineStart*>;
+// MOC_SKIP_END
+#endif
+
+class Q_EXPORT TQTextParagraphData
+{
+public:
+    TQTextParagraphData() {}
+    virtual ~TQTextParagraphData();
+    virtual void join( TQTextParagraphData * );
+};
+
+class TQTextParagraphPseudoDocument;
+
+class TQSyntaxHighlighter;
+
+class Q_EXPORT TQTextParagraph
+{
+    friend class TQTextDocument;
+    friend class TQTextCursor;
+    friend class TQSyntaxHighlighter;
+
+public:
+    TQTextParagraph( TQTextDocument *d, TQTextParagraph *pr = 0, TQTextParagraph *nx = 0, bool updateIds = TRUE );
+    ~TQTextParagraph();
+
+    TQTextString *string() const;
+    TQTextStringChar *at( int i ) const; // maybe remove later
+    int leftGap() const;
+    int length() const; // maybe remove later
+
+    void setListStyle( TQStyleSheetItem::ListStyle ls ) { lstyle = ls; changed = TRUE; }
+    TQStyleSheetItem::ListStyle listStyle() const { return (TQStyleSheetItem::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( TQTextFormat *fm );
+//     TQTextFormat *paragFormat() const;
+
+    inline TQTextDocument *document() const {
+	if (hasdoc) return (TQTextDocument*) docOrPseudo;
+	return 0;
+    }
+    TQTextParagraphPseudoDocument *pseudoDocument() const;
+
+    TQRect rect() const;
+    void setHeight( int h ) { r.setHeight( h ); }
+    void show();
+    void hide();
+    bool isVisible() const { return visible; }
+
+    TQTextParagraph *prev() const;
+    TQTextParagraph *next() const;
+    void setPrev( TQTextParagraph *s );
+    void setNext( TQTextParagraph *s );
+
+    void insert( int index, const TQString &s );
+    void insert( int index, const TQChar *unicode, int len );
+    void append( const TQString &s, bool reallyAtEnd = FALSE );
+    void truncate( int index );
+    void remove( int index, int len );
+    void join( TQTextParagraph *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;
+    TQTextStringChar *lineStartOfChar( int i, int *index = 0, int *line = 0 ) const;
+    int lines() const;
+    TQTextStringChar *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( TQTextParagraphData *data );
+    TQTextParagraphData *extraData() const;
+
+    TQMap<int, TQTextLineStart*> &lineStartList();
+
+    void setFormat( int index, int len, TQTextFormat *f, bool useCollection = TRUE, int flags = -1 );
+
+    void setAlignment( int a );
+    int alignment() const;
+
+    void paint( TQPainter &painter, const TQColorGroup &cg, TQTextCursor *cursor = 0, bool drawSelections = FALSE,
+			int clipx = -1, int clipy = -1, int clipw = -1, int cliph = -1 );
+
+    int topMargin() const;
+    int bottomMargin() const;
+    int leftMargin() const;
+    int firstLineMargin() const;
+    int rightMargin() const;
+    int lineSpacing() const;
+
+#ifndef QT_NO_TEXTCUSTOMITEM
+    void registerFloatingItem( TQTextCustomItem *i );
+    void unregisterFloatingItem( TQTextCustomItem *i );
+#endif
+
+    void setFullWidth( bool b ) { fullWidth = b; }
+    bool isFullWidth() const { return fullWidth; }
+
+#ifndef QT_NO_TEXTCUSTOMITEM
+    TQTextTableCell *tableCell() const;
+#endif
+
+    TQBrush *background() const;
+
+    int documentWidth() const;
+    int documentVisibleWidth() const;
+    int documentX() const;
+    int documentY() const;
+    TQTextFormatCollection *formatCollection() const;
+    TQTextFormatter *formatter() const;
+
+    int nextTab( int i, int x );
+    int *tabArray() const;
+    void setTabArray( int *a );
+    void setTabStops( int tw );
+
+    void adjustToPainter( TQPainter *p );
+
+    void setNewLinesAllowed( bool b );
+    bool isNewLinesAllowed() const;
+
+    TQString richText() const;
+
+    void addCommand( TQTextCommand *cmd );
+    TQTextCursor *undo( TQTextCursor *c = 0 );
+    TQTextCursor *redo( TQTextCursor *c  = 0 );
+    TQTextCommandHistory *commands() const;
+    void copyParagData( TQTextParagraph *parag );
+
+    void setBreakable( bool b ) { breakable = b; }
+    bool isBreakable() const { return breakable; }
+
+    void setBackgroundColor( const TQColor &c );
+    TQColor *backgroundColor() const { return bgcol; }
+    void clearBackgroundColor();
+
+    void setMovedDown( bool b ) { movedDown = b; }
+    bool wasMovedDown() const { return movedDown; }
+
+    void setDirection( TQChar::Direction d );
+    TQChar::Direction direction() const;
+    void setPaintDevice( TQPaintDevice *pd ) { paintdevice = pd; }
+
+    void readStyleInformation( TQDataStream& stream );
+    void writeStyleInformation( TQDataStream& stream ) const;
+
+protected:
+    void setColorForSelection( TQColor &c, TQPainter &p, const TQColorGroup& cg, int selection );
+    void drawLabel( TQPainter* p, int x, int y, int w, int h, int base, const TQColorGroup& cg );
+    void drawString( TQPainter &painter, const TQString &str, int start, int len, int xstart,
+			     int y, int baseLine, int w, int h, bool drawSelections, int fullSelectionWidth,
+			     TQTextStringChar *formatChar, const TQColorGroup& cg,
+			     bool rightToLeft );
+
+private:
+    TQMap<int, TQTextParagraphSelection> &selections() const;
+#ifndef QT_NO_TEXTCUSTOMITEM
+    TQPtrList<TQTextCustomItem> &floatingItems() const;
+#endif
+    TQBrush backgroundBrush( const TQColorGroup&cg ) { if ( bgcol ) return *bgcol; return cg.brush( TQColorGroup::Base ); }
+    void invalidateStyleCache();
+
+    TQMap<int, TQTextLineStart*> lineStarts;
+    TQRect r;
+    TQTextParagraph *p, *n;
+    void *docOrPseudo;
+    uint changed : 1;
+    uint firstFormat : 1;
+    uint firstPProcess : 1;
+    uint needPreProcess : 1;
+    uint fullWidth : 1;
+    uint lastInFrame : 1;
+    uint visible : 1;
+    uint breakable : 1;
+    uint movedDown : 1;
+    uint mightHaveCustomItems : 1;
+    uint hasdoc : 1;
+    uint litem : 1; // whether the paragraph is a list item
+    uint rtext : 1; // whether the paragraph needs rich text margin
+    int align : 4;
+    uint /*TQStyleSheetItem::ListStyle*/ lstyle : 4;
+    int invalid;
+    int state, id;
+    TQTextString *str;
+    TQMap<int, TQTextParagraphSelection> *mSelections;
+#ifndef QT_NO_TEXTCUSTOMITEM
+    TQPtrList<TQTextCustomItem> *mFloatingItems;
+#endif
+    short utm, ubm, ulm, urm, uflm, ulinespacing;
+    short tabStopWidth;
+    int minwidth;
+    int *tArray;
+    TQTextParagraphData *eData;
+    short list_val;
+    ushort ldepth;
+    TQColor *bgcol;
+    TQPaintDevice *paintdevice;
+};
+
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+class Q_EXPORT TQTextFormatter
+{
+public:
+    TQTextFormatter();
+    virtual ~TQTextFormatter();
+
+    virtual int format( TQTextDocument *doc, TQTextParagraph *parag, int start, const TQMap<int, TQTextLineStart*> &oldLineStarts ) = 0;
+    virtual int formatVertically( TQTextDocument* doc, TQTextParagraph* parag );
+
+    bool isWrapEnabled( TQTextParagraph *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 TQTextLineStart *formatLine( TQTextParagraph *parag, TQTextString *string, TQTextLineStart *line, TQTextStringChar *start,
+					       TQTextStringChar *last, int align = TQt::AlignAuto, int space = 0 );
+#ifndef QT_NO_COMPLEXTEXT
+    virtual TQTextLineStart *bidiReorderLine( TQTextParagraph *parag, TQTextString *string, TQTextLineStart *line, TQTextStringChar *start,
+						    TQTextStringChar *last, int align, int space );
+#endif
+    void insertLineStart( TQTextParagraph *parag, int index, TQTextLineStart *ls );
+
+    int thisminw;
+    int thiswused;
+
+private:
+    bool wrapEnabled;
+    int wrapColumn;
+    bool biw;
+
+#ifdef HAVE_THAI_BREAKS
+    static TQCString *thaiCache;
+    static TQTextString *cachedString;
+    static ThBreakIterator *thaiIt;
+#endif
+};
+
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+class Q_EXPORT TQTextFormatterBreakInWords : public TQTextFormatter
+{
+public:
+    TQTextFormatterBreakInWords();
+    virtual ~TQTextFormatterBreakInWords() {}
+
+    int format( TQTextDocument *doc, TQTextParagraph *parag, int start, const TQMap<int, TQTextLineStart*> &oldLineStarts );
+
+};
+
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+class Q_EXPORT TQTextFormatterBreakWords : public TQTextFormatter
+{
+public:
+    TQTextFormatterBreakWords();
+    virtual ~TQTextFormatterBreakWords() {}
+
+    int format( TQTextDocument *doc, TQTextParagraph *parag, int start, const TQMap<int, TQTextLineStart*> &oldLineStarts );
+
+};
+
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+class Q_EXPORT TQTextIndent
+{
+public:
+    TQTextIndent();
+    virtual ~TQTextIndent() {}
+
+    virtual void indent( TQTextDocument *doc, TQTextParagraph *parag, int *oldIndent = 0, int *newIndent = 0 ) = 0;
+
+};
+
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+class Q_EXPORT TQTextPreProcessor
+{
+public:
+    enum Ids {
+	Standard = 0
+    };
+
+    TQTextPreProcessor();
+    virtual ~TQTextPreProcessor() {}
+
+    virtual void process( TQTextDocument *doc, TQTextParagraph *, int, bool = TRUE ) = 0;
+    virtual TQTextFormat *format( int id ) = 0;
+
+};
+
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+class Q_EXPORT TQTextFormat
+{
+    friend class TQTextFormatCollection;
+    friend class TQTextDocument;
+
+public:
+    enum Flags {
+	NoFlags,
+	Bold = 1,
+	Italic = 2,
+	Underline = 4,
+	Family = 8,
+	Size = 16,
+	Color = 32,
+	Misspelled = 64,
+	VAlign = 128,
+	StrikeOut= 256,
+	Font = Bold | Italic | Underline | Family | Size | StrikeOut,
+	Format = Font | Color | Misspelled | VAlign
+    };
+
+    enum VerticalAlignment { AlignNormal, AlignSuperScript, AlignSubScript };
+
+    TQTextFormat();
+    virtual ~TQTextFormat();
+
+    TQTextFormat( const TQStyleSheetItem *s );
+    TQTextFormat( const TQFont &f, const TQColor &c, TQTextFormatCollection *parent = 0 );
+    TQTextFormat( const TQTextFormat &fm );
+    TQTextFormat makeTextFormat( const TQStyleSheetItem *style, const TQMap<TQString,TQString>& attr, double scaleFontsFactor ) const;
+    TQTextFormat& operator=( const TQTextFormat &fm );
+    TQColor color() const;
+    TQFont font() const;
+    TQFontMetrics fontMetrics() const { return fm; }
+    bool isMisspelled() const;
+    VerticalAlignment vAlign() const;
+    int minLeftBearing() const;
+    int minRightBearing() const;
+    int width( const TQChar &c ) const;
+    int width( const TQString &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 setStrikeOut( bool b );
+    void setFamily( const TQString &f );
+    void setPointSize( int s );
+    void setFont( const TQFont &f );
+    void setColor( const TQColor &c );
+    void setMisspelled( bool b );
+    void setVAlign( VerticalAlignment a );
+
+    bool operator==( const TQTextFormat &f ) const;
+    TQTextFormatCollection *parent() const;
+    const TQString &key() const;
+
+    static TQString getKey( const TQFont &f, const TQColor &c, bool misspelled, VerticalAlignment vAlign );
+
+    void addRef();
+    void removeRef();
+
+    TQString makeFormatChangeTags( TQTextFormat* defaultFormat, TQTextFormat *f, const TQString& oldAnchorHref, const TQString& anchorHref ) const;
+    TQString makeFormatEndTags( TQTextFormat* defaultFormat, const TQString& anchorHref ) const;
+
+    static void setPainter( TQPainter *p );
+    static TQPainter* painter();
+
+    bool fontSizesInPixels() { return usePixelSizes; }
+
+protected:
+    virtual void generateKey();
+
+private:
+    void update();
+    static void applyFont( const TQFont &f );
+
+private:
+    TQFont fn;
+    TQColor col;
+    TQFontMetrics fm;
+    uint missp : 1;
+    uint linkColor : 1;
+    uint usePixelSizes : 1;
+    int leftBearing, rightBearing;
+    VerticalAlignment ha;
+    uchar widths[ 256 ];
+    int hei, asc, dsc;
+    TQTextFormatCollection *collection;
+    int ref;
+    TQString k;
+    int logicalFontSize;
+    int stdSize;
+    static TQPainter *pntr;
+    static TQFontMetrics *pntr_fm;
+    static int pntr_asc;
+    static int pntr_hei;
+    static int pntr_ldg;
+    static int pntr_dsc;
+
+};
+
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+#if defined(Q_TEMPLATEDLL)
+// MOC_SKIP_BEGIN
+Q_TEMPLATE_EXTERN template class Q_EXPORT TQDict<TQTextFormat>;
+// MOC_SKIP_END
+#endif
+
+class Q_EXPORT TQTextFormatCollection
+{
+    friend class TQTextDocument;
+    friend class TQTextFormat;
+
+public:
+    TQTextFormatCollection();
+    virtual ~TQTextFormatCollection();
+
+    void setDefaultFormat( TQTextFormat *f );
+    TQTextFormat *defaultFormat() const;
+    virtual TQTextFormat *format( TQTextFormat *f );
+    virtual TQTextFormat *format( TQTextFormat *of, TQTextFormat *nf, int flags );
+    virtual TQTextFormat *format( const TQFont &f, const TQColor &c );
+    virtual void remove( TQTextFormat *f );
+    virtual TQTextFormat *createFormat( const TQTextFormat &f ) { return new TQTextFormat( f ); }
+    virtual TQTextFormat *createFormat( const TQFont &f, const TQColor &c ) { return new TQTextFormat( f, c, this ); }
+
+    void updateDefaultFormat( const TQFont &font, const TQColor &c, TQStyleSheet *sheet );
+
+    TQPaintDevice *paintDevice() const { return paintdevice; }
+    void setPaintDevice( TQPaintDevice * );
+
+private:
+    void updateKeys();
+
+private:
+    TQTextFormat *defFormat, *lastFormat, *cachedFormat;
+    TQDict<TQTextFormat> cKey;
+    TQTextFormat *cres;
+    TQFont cfont;
+    TQColor ccol;
+    TQString kof, knf;
+    int cflags;
+
+    TQPaintDevice *paintdevice;
+};
+
+class Q_EXPORT TQTextParagraphPseudoDocument
+{
+public:
+    TQTextParagraphPseudoDocument();
+    ~TQTextParagraphPseudoDocument();
+    TQRect docRect;
+    TQTextFormatter *pFormatter;
+    TQTextCommandHistory *commandHistory;
+    int minw;
+    int wused;
+    TQTextFormatCollection collection;
+};
+
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+inline int TQTextParagraph::length() const
+{
+    return str->length();
+}
+
+inline TQRect TQTextParagraph::rect() const
+{
+    return r;
+}
+
+inline int TQTextCursor::index() const
+{
+    return idx;
+}
+
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+inline int TQTextDocument::x() const
+{
+    return cx;
+}
+
+inline int TQTextDocument::y() const
+{
+    return cy;
+}
+
+inline int TQTextDocument::width() const
+{
+    return TQMAX( cw, flow_->width() );
+}
+
+inline int TQTextDocument::visibleWidth() const
+{
+    return vw;
+}
+
+inline TQTextParagraph *TQTextDocument::firstParagraph() const
+{
+    return fParag;
+}
+
+inline TQTextParagraph *TQTextDocument::lastParagraph() const
+{
+    return lParag;
+}
+
+inline void TQTextDocument::setFirstParagraph( TQTextParagraph *p )
+{
+    fParag = p;
+}
+
+inline void TQTextDocument::setLastParagraph( TQTextParagraph *p )
+{
+    lParag = p;
+}
+
+inline void TQTextDocument::setWidth( int w )
+{
+    cw = TQMAX( w, minw );
+    flow_->setWidth( cw );
+    vw = w;
+}
+
+inline int TQTextDocument::minimumWidth() const
+{
+    return minw;
+}
+
+inline void TQTextDocument::setY( int y )
+{
+    cy = y;
+}
+
+inline int TQTextDocument::leftMargin() const
+{
+    return leftmargin;
+}
+
+inline void TQTextDocument::setLeftMargin( int lm )
+{
+    leftmargin = lm;
+}
+
+inline int TQTextDocument::rightMargin() const
+{
+    return rightmargin;
+}
+
+inline void TQTextDocument::setRightMargin( int rm )
+{
+    rightmargin = rm;
+}
+
+inline TQTextPreProcessor *TQTextDocument::preProcessor() const
+{
+    return pProcessor;
+}
+
+inline void TQTextDocument::setPreProcessor( TQTextPreProcessor * sh )
+{
+    pProcessor = sh;
+}
+
+inline void TQTextDocument::setFormatter( TQTextFormatter *f )
+{
+    delete pFormatter;
+    pFormatter = f;
+}
+
+inline TQTextFormatter *TQTextDocument::formatter() const
+{
+    return pFormatter;
+}
+
+inline void TQTextDocument::setIndent( TQTextIndent *i )
+{
+    indenter = i;
+}
+
+inline TQTextIndent *TQTextDocument::indent() const
+{
+    return indenter;
+}
+
+inline TQColor TQTextDocument::selectionColor( int id ) const
+{
+    return selectionColors[ id ];
+}
+
+inline bool TQTextDocument::invertSelectionText( int id ) const
+{
+    return selectionText[ id ];
+}
+
+inline void TQTextDocument::setSelectionColor( int id, const TQColor &c )
+{
+    selectionColors[ id ] = c;
+}
+
+inline void TQTextDocument::setInvertSelectionText( int id, bool b )
+{
+    selectionText[ id ] = b;
+}
+
+inline TQTextFormatCollection *TQTextDocument::formatCollection() const
+{
+    return fCollection;
+}
+
+inline int TQTextDocument::alignment() const
+{
+    return align;
+}
+
+inline void TQTextDocument::setAlignment( int a )
+{
+    align = a;
+}
+
+inline int *TQTextDocument::tabArray() const
+{
+    return tArray;
+}
+
+inline int TQTextDocument::tabStopWidth() const
+{
+    return tStopWidth;
+}
+
+inline void TQTextDocument::setTabArray( int *a )
+{
+    tArray = a;
+}
+
+inline void TQTextDocument::setTabStops( int tw )
+{
+    tStopWidth = tw;
+}
+
+inline TQString TQTextDocument::originalText() const
+{
+    if ( oTextValid )
+	return oText;
+    return text();
+}
+
+inline void TQTextDocument::setFlow( TQTextFlow *f )
+{
+    if ( flow_ )
+	delete flow_;
+    flow_ = f;
+}
+
+inline void TQTextDocument::takeFlow()
+{
+    flow_ = 0;
+}
+
+inline bool TQTextDocument::useDoubleBuffer( TQTextParagraph *parag, TQPainter *p )
+{
+    return ( !parag->document()->parent() || parag->document()->nextDoubleBuffered ) &&
+	( !p || !p->device() || p->device()->devType() != TQInternal::Printer );
+}
+
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+inline TQColor TQTextFormat::color() const
+{
+    return col;
+}
+
+inline TQFont TQTextFormat::font() const
+{
+    return fn;
+}
+
+inline bool TQTextFormat::isMisspelled() const
+{
+    return missp;
+}
+
+inline TQTextFormat::VerticalAlignment TQTextFormat::vAlign() const
+{
+    return ha;
+}
+
+inline bool TQTextFormat::operator==( const TQTextFormat &f ) const
+{
+    return k == f.k;
+}
+
+inline TQTextFormatCollection *TQTextFormat::parent() const
+{
+    return collection;
+}
+
+inline void TQTextFormat::addRef()
+{
+    ref++;
+}
+
+inline void TQTextFormat::removeRef()
+{
+    ref--;
+    if ( !collection )
+	return;
+    if ( this == collection->defFormat )
+	return;
+    if ( ref == 0 )
+	collection->remove( this );
+}
+
+inline const TQString &TQTextFormat::key() const
+{
+    return k;
+}
+
+inline bool TQTextFormat::useLinkColor() const
+{
+    return linkColor;
+}
+
+inline TQTextStringChar *TQTextParagraph::at( int i ) const
+{
+    return &str->at( i );
+}
+
+inline bool TQTextParagraph::isValid() const
+{
+    return invalid == -1;
+}
+
+inline bool TQTextParagraph::hasChanged() const
+{
+    return changed;
+}
+
+inline void TQTextParagraph::setBackgroundColor( const TQColor & c )
+{
+    delete bgcol;
+    bgcol = new TQColor( c );
+    setChanged( TRUE );
+}
+
+inline void TQTextParagraph::clearBackgroundColor()
+{
+    delete bgcol; bgcol = 0; setChanged( TRUE );
+}
+
+inline void TQTextParagraph::append( const TQString &s, bool reallyAtEnd )
+{
+    if ( reallyAtEnd )
+	insert( str->length(), s );
+    else
+	insert( TQMAX( str->length() - 1, 0 ), s );
+}
+
+inline TQTextParagraph *TQTextParagraph::prev() const
+{
+    return p;
+}
+
+inline TQTextParagraph *TQTextParagraph::next() const
+{
+    return n;
+}
+
+inline bool TQTextParagraph::hasAnySelection() const
+{
+    return mSelections ? !selections().isEmpty() : FALSE;
+}
+
+inline void TQTextParagraph::setEndState( int s )
+{
+    if ( s == state )
+	return;
+    state = s;
+}
+
+inline int TQTextParagraph::endState() const
+{
+    return state;
+}
+
+inline void TQTextParagraph::setParagId( int i )
+{
+    id = i;
+}
+
+inline int TQTextParagraph::paragId() const
+{
+    if ( id == -1 )
+	qWarning( "invalid parag id!!!!!!!! (%p)", (void*)this );
+    return id;
+}
+
+inline bool TQTextParagraph::firstPreProcess() const
+{
+    return firstPProcess;
+}
+
+inline void TQTextParagraph::setFirstPreProcess( bool b )
+{
+    firstPProcess = b;
+}
+
+inline TQMap<int, TQTextLineStart*> &TQTextParagraph::lineStartList()
+{
+    return lineStarts;
+}
+
+inline TQTextString *TQTextParagraph::string() const
+{
+    return str;
+}
+
+inline TQTextParagraphPseudoDocument *TQTextParagraph::pseudoDocument() const
+{
+    if ( hasdoc )
+	return 0;
+    return (TQTextParagraphPseudoDocument*) docOrPseudo;
+}
+
+
+#ifndef QT_NO_TEXTCUSTOMITEM
+inline TQTextTableCell *TQTextParagraph::tableCell() const
+{
+    return hasdoc ? document()->tableCell () : 0;
+}
+#endif
+
+inline TQTextCommandHistory *TQTextParagraph::commands() const
+{
+    return hasdoc ? document()->commands() : pseudoDocument()->commandHistory;
+}
+
+
+inline int TQTextParagraph::alignment() const
+{
+    return align;
+}
+
+#ifndef QT_NO_TEXTCUSTOMITEM
+inline void TQTextParagraph::registerFloatingItem( TQTextCustomItem *i )
+{
+    floatingItems().append( i );
+}
+
+inline void TQTextParagraph::unregisterFloatingItem( TQTextCustomItem *i )
+{
+    floatingItems().removeRef( i );
+}
+#endif
+
+inline TQBrush *TQTextParagraph::background() const
+{
+#ifndef QT_NO_TEXTCUSTOMITEM
+    return tableCell() ? tableCell()->backGround() : 0;
+#else
+    return 0;
+#endif
+}
+
+inline int TQTextParagraph::documentWidth() const
+{
+    return hasdoc ? document()->width() : pseudoDocument()->docRect.width();
+}
+
+inline int TQTextParagraph::documentVisibleWidth() const
+{
+    return hasdoc ? document()->visibleWidth() : pseudoDocument()->docRect.width();
+}
+
+inline int TQTextParagraph::documentX() const
+{
+    return hasdoc ? document()->x() : pseudoDocument()->docRect.x();
+}
+
+inline int TQTextParagraph::documentY() const
+{
+    return hasdoc ? document()->y() : pseudoDocument()->docRect.y();
+}
+
+inline void TQTextParagraph::setExtraData( TQTextParagraphData *data )
+{
+    eData = data;
+}
+
+inline TQTextParagraphData *TQTextParagraph::extraData() const
+{
+    return eData;
+}
+
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+inline void TQTextFormatCollection::setDefaultFormat( TQTextFormat *f )
+{
+    defFormat = f;
+}
+
+inline TQTextFormat *TQTextFormatCollection::defaultFormat() const
+{
+    return defFormat;
+}
+
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+inline TQTextFormat *TQTextStringChar::format() const
+{
+    return (type == Regular) ? d.format : d.custom->format;
+}
+
+
+#ifndef QT_NO_TEXTCUSTOMITEM
+inline TQTextCustomItem *TQTextStringChar::customItem() const
+{
+    return isCustom() ? d.custom->custom : 0;
+}
+#endif
+
+inline int TQTextStringChar::height() const
+{
+#ifndef QT_NO_TEXTCUSTOMITEM
+    return !isCustom() ? format()->height() : ( customItem()->placement() == TQTextCustomItem::PlaceInline ? customItem()->height : 0 );
+#else
+    return format()->height();
+#endif
+}
+
+inline int TQTextStringChar::ascent() const
+{
+#ifndef QT_NO_TEXTCUSTOMITEM
+    return !isCustom() ? format()->ascent() : ( customItem()->placement() == TQTextCustomItem::PlaceInline ? customItem()->ascent() : 0 );
+#else
+    return format()->ascent();
+#endif
+}
+
+inline int TQTextStringChar::descent() const
+{
+#ifndef QT_NO_TEXTCUSTOMITEM
+    return !isCustom() ? format()->descent() : 0;
+#else
+    return format()->descent();
+#endif
+}
+
+#endif //QT_NO_RICHTEXT
+
+#endif