home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / qt3_emx.zip / include / private / qrichtext_p.h < prev    next >
C/C++ Source or Header  |  2001-10-11  |  58KB  |  2,178 lines
  1. /****************************************************************************
  2. ** $Id:  qt/qrichtext_p.h   3.0.0   edited Sep 30 17:14 $
  3. **
  4. ** Definition of internal rich text classes
  5. **
  6. ** Created : 990124
  7. **
  8. ** Copyright (C) 1999-2000 Trolltech AS.  All rights reserved.
  9. **
  10. ** This file is part of the kernel module of the Qt GUI Toolkit.
  11. **
  12. ** This file may be distributed under the terms of the Q Public License
  13. ** as defined by Trolltech AS of Norway and appearing in the file
  14. ** LICENSE.QPL included in the packaging of this file.
  15. **
  16. ** This file may be distributed and/or modified under the terms of the
  17. ** GNU General Public License version 2 as published by the Free Software
  18. ** Foundation and appearing in the file LICENSE.GPL included in the
  19. ** packaging of this file.
  20. **
  21. ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
  22. ** licenses may use this file in accordance with the Qt Commercial License
  23. ** Agreement provided with the Software.
  24. **
  25. ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  26. ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  27. **
  28. ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
  29. **   information about Qt Commercial License Agreements.
  30. ** See http://www.trolltech.com/qpl/ for QPL licensing information.
  31. ** See http://www.trolltech.com/gpl/ for GPL licensing information.
  32. **
  33. ** Contact info@trolltech.com if any conditions of this licensing are
  34. ** not clear to you.
  35. **
  36. **********************************************************************/
  37.  
  38. #ifndef QRICHTEXT_P_H
  39. #define QRICHTEXT_P_H
  40.  
  41. //
  42. //  W A R N I N G
  43. //  -------------
  44. //
  45. // This file is not part of the Qt API.  It exists for the convenience
  46. // of a number of Qt sources files.  This header file may change from
  47. // version to version without notice, or even be removed.
  48. //
  49. // We mean it.
  50. //
  51. //
  52.  
  53. #ifndef QT_H
  54. #include "qstring.h"
  55. #include "qptrlist.h"
  56. #include "qrect.h"
  57. #include "qfontmetrics.h"
  58. #include "qintdict.h"
  59. #include "qmap.h"
  60. #include "qstringlist.h"
  61. #include "qfont.h"
  62. #include "qcolor.h"
  63. #include "qsize.h"
  64. #include "qvaluelist.h"
  65. #include "qvaluestack.h"
  66. #include "qobject.h"
  67. #include "qdict.h"
  68. #include "qtextstream.h"
  69. #include "qpixmap.h"
  70. #include "qstylesheet.h"
  71. #include "qptrvector.h"
  72. #include "qpainter.h"
  73. #include "qlayout.h"
  74. #include "qobject.h"
  75. #include "private/qcomplextext_p.h"
  76. #include "qapplication.h"
  77. #include <limits.h>
  78. #endif // QT_H
  79.  
  80. #ifndef QT_NO_RICHTEXT
  81.  
  82. //#define DEBUG_COLLECTION
  83.  
  84. class QTextDocument;
  85. class QTextString;
  86. class QTextPreProcessor;
  87. class QTextFormat;
  88. class QTextCursor;
  89. class QTextParag;
  90. class QTextFormatter;
  91. class QTextIndent;
  92. class QTextFormatCollection;
  93. class QStyleSheetItem;
  94. class QTextCustomItem;
  95. class QTextFlow;
  96. struct QBidiContext;
  97.  
  98. // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  99.  
  100. class Q_EXPORT QTextStringChar
  101. {
  102.     friend class QTextString;
  103.  
  104. public:
  105.     // this is never called, initialize variables in QTextString::insert()!!!
  106.     QTextStringChar() : lineStart( 0 ), type( Regular ), startOfRun( 0 ) {d.format=0;}
  107.     ~QTextStringChar();
  108.  
  109.     QChar c;
  110.     enum Type { Regular, Custom, Mark, Shaped };
  111.     uint lineStart : 1;
  112.     uint rightToLeft : 1;
  113.     uint hasCursor : 1;
  114.     uint canBreak : 1;
  115.     Type type : 2;
  116.     uint startOfRun : 1;
  117.  
  118.     int x;
  119.     int height() const;
  120.     int ascent() const;
  121.     int descent() const;
  122.     bool isCustom() const { return type == Custom; }
  123.     QTextFormat *format() const;
  124.     QTextCustomItem *customItem() const;
  125.     void setFormat( QTextFormat *f );
  126.     void setCustomItem( QTextCustomItem *i );
  127.     QTextStringChar *clone() const;
  128.     struct CustomData
  129.     {
  130.     QTextFormat *format;
  131.     QTextCustomItem *custom;
  132.     };
  133.  
  134.     void loseCustomItem()
  135.     {
  136.     if ( isCustom() ) {
  137.         QTextFormat *f = d.custom->format;
  138.         d.custom->custom = 0;
  139.         delete d.custom;
  140.         type = Regular;
  141.         d.format = f;
  142.     }
  143.     }
  144.  
  145.      struct MarkData
  146.     {
  147.     QTextFormat *format;
  148.     short xoff; // x offset for painting the Mark
  149.     short yoff; // y offset for painting the Mark
  150.     };
  151.  
  152.     struct ShapedData
  153.     {
  154.     QTextFormat *format;
  155.     QChar shapedGlyph;
  156.     };
  157.  
  158.     union {
  159.     QTextFormat* format;
  160.     CustomData* custom;
  161.     MarkData *mark;
  162.     ShapedData *shaped;
  163.     } d;
  164.  
  165. private:
  166.     QTextStringChar &operator=( const QTextStringChar & ) {
  167.     //abort();
  168.     return *this;
  169.     }
  170.     friend class QComplexText;
  171.     friend class QTextParag;
  172. };
  173.  
  174. #if defined(Q_TEMPLATEDLL)
  175. // MOC_SKIP_BEGIN
  176. template class Q_EXPORT QMemArray<QTextStringChar>;
  177. // MOC_SKIP_END
  178. #endif
  179.  
  180. class Q_EXPORT QTextString
  181. {
  182. public:
  183.  
  184.     QTextString();
  185.     QTextString( const QTextString &s );
  186.     virtual ~QTextString();
  187.  
  188.     QString toString() const;
  189.     static QString toString( const QMemArray<QTextStringChar> &data );
  190.     QString toReverseString() const;
  191.  
  192.     QTextStringChar &at( int i ) const;
  193.     int length() const;
  194.  
  195.     int width( int idx ) const;
  196.  
  197.     void insert( int index, const QString &s, QTextFormat *f );
  198.     void insert( int index, QTextStringChar *c );
  199.     void truncate( int index );
  200.     void remove( int index, int len );
  201.     void clear();
  202.  
  203.     void setFormat( int index, QTextFormat *f, bool useCollection );
  204.  
  205.     void setTextChanged( bool b ) { textChanged = b; }
  206.     void setBidi( bool b ) { bidi = b; }
  207.     bool isTextChanged() const { return textChanged; }
  208.     bool isBidi() const;
  209.     bool isRightToLeft() const;
  210.     void setRightToLeft( bool rtl ) { rightToLeft = rtl; }
  211.  
  212.     QMemArray<QTextStringChar> subString( int start = 0, int len = 0xFFFFFF ) const;
  213.     QMemArray<QTextStringChar> rawData() const { return data; }
  214.  
  215.     void operator=( const QString &s ) { clear(); insert( 0, s, 0 ); }
  216.     void operator+=( const QString &s );
  217.     void prepend( const QString &s ) { insert( 0, s, 0 ); }
  218.  
  219. private:
  220.     void checkBidi() const;
  221.     
  222.     QMemArray<QTextStringChar> data;
  223.     uint textChanged : 1;
  224.     uint bidi : 1; // true when the paragraph has right to left characters
  225.     uint rightToLeft : 1; // true if the basic direction of the paragraph is right to left.
  226. };
  227.  
  228. inline bool QTextString::isBidi() const
  229. {
  230.     if ( textChanged )
  231.     checkBidi();
  232.     return bidi;
  233. }
  234.  
  235. inline bool QTextString::isRightToLeft() const
  236. {
  237.     return rightToLeft;
  238. }
  239.  
  240. // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  241.  
  242. #if defined(Q_TEMPLATEDLL)
  243. // MOC_SKIP_BEGIN
  244. template class Q_EXPORT QValueStack<int>;
  245. template class Q_EXPORT QValueStack<QTextParag*>;
  246. template class Q_EXPORT QValueStack<bool>;
  247. // MOC_SKIP_END
  248. #endif
  249.  
  250. class Q_EXPORT QTextCursor
  251. {
  252. public:
  253.     QTextCursor( QTextDocument *d );
  254.     QTextCursor();
  255.     QTextCursor( const QTextCursor &c );
  256.     QTextCursor &operator=( const QTextCursor &c );
  257.     virtual ~QTextCursor() {}
  258.  
  259.     bool operator==( const QTextCursor &c ) const;
  260.     bool operator!=( const QTextCursor &c ) const { return !(*this == c); }
  261.  
  262.     QTextDocument *document() const { return doc; }
  263.     void setDocument( QTextDocument *d );
  264.  
  265.     QTextParag *parag() const;
  266.     int index() const;
  267.     void setParag( QTextParag *s, bool restore = TRUE );
  268.  
  269.     void gotoLeft();
  270.     void gotoRight();
  271.     void gotoUp();
  272.     void gotoDown();
  273.     void gotoLineEnd();
  274.     void gotoLineStart();
  275.     void gotoHome();
  276.     void gotoEnd();
  277.     void gotoPageUp( int visibleHeight );
  278.     void gotoPageDown( int visibleHeight );
  279.     void gotoWordLeft();
  280.     void gotoWordRight();
  281.  
  282.     void insert( const QString &s, bool checkNewLine, QMemArray<QTextStringChar> *formatting = 0 );
  283.     void splitAndInsertEmptyParag( bool ind = TRUE, bool updateIds = TRUE );
  284.     bool remove();
  285.     void killLine();
  286.     void indent();
  287.  
  288.     bool atParagStart();
  289.     bool atParagEnd();
  290.  
  291.     void setIndex( int i, bool restore = TRUE );
  292.  
  293.     void checkIndex();
  294.  
  295.     int offsetX() const { return ox; }
  296.     int offsetY() const { return oy; }
  297.  
  298.     QTextParag *topParag() const { return parags.isEmpty() ? string : parags.first(); }
  299.     int totalOffsetX() const;
  300.     int totalOffsetY() const;
  301.  
  302.     bool place( const QPoint &pos, QTextParag *s );
  303.     void restoreState();
  304.  
  305.     int x() const;
  306.     int y() const;
  307.  
  308.     int nestedDepth() const { return (int)indices.count(); } //### size_t/int cast
  309.  
  310. private:
  311.     enum Operation { EnterBegin, EnterEnd, Next, Prev, Up, Down };
  312.  
  313.     void push();
  314.     void pop();
  315.     void processNesting( Operation op );
  316.     void invalidateNested();
  317.     void gotoIntoNested( const QPoint &globalPos );
  318.  
  319.     QTextParag *string;
  320.     QTextDocument *doc;
  321.     int idx, tmpIndex;
  322.     int ox, oy;
  323.     QValueStack<int> indices;
  324.     QValueStack<QTextParag*> parags;
  325.     QValueStack<int> xOffsets;
  326.     QValueStack<int> yOffsets;
  327.     QValueStack<bool> nestedStack;
  328.     bool nested;
  329.  
  330. };
  331.  
  332. // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  333.  
  334. class Q_EXPORT QTextCommand
  335. {
  336. public:
  337.     enum Commands { Invalid, Insert, Delete, Format, Alignment, ParagType };
  338.  
  339.     QTextCommand( QTextDocument *d ) : doc( d ), cursor( d ) {}
  340.     virtual ~QTextCommand();
  341.  
  342.     virtual Commands type() const;
  343.  
  344.     virtual QTextCursor *execute( QTextCursor *c ) = 0;
  345.     virtual QTextCursor *unexecute( QTextCursor *c ) = 0;
  346.  
  347. protected:
  348.     QTextDocument *doc;
  349.     QTextCursor cursor;
  350.  
  351. };
  352.  
  353. #if defined(Q_TEMPLATEDLL)
  354. // MOC_SKIP_BEGIN
  355. template class Q_EXPORT QPtrList<QTextCommand>;
  356. // MOC_SKIP_END
  357. #endif
  358.  
  359. class Q_EXPORT QTextCommandHistory
  360. {
  361. public:
  362.     QTextCommandHistory( int s ) : current( -1 ), steps( s ) { history.setAutoDelete( TRUE ); }
  363.     virtual ~QTextCommandHistory() { clear(); }
  364.  
  365.     void clear() { history.clear(); current = -1; }
  366.  
  367.     void addCommand( QTextCommand *cmd );
  368.     QTextCursor *undo( QTextCursor *c );
  369.     QTextCursor *redo( QTextCursor *c );
  370.  
  371.     bool isUndoAvailable();
  372.     bool isRedoAvailable();
  373.  
  374.     void setUndoDepth( int d ) { steps = d; }
  375.     int undoDepth() const { return steps; }
  376.  
  377.     int historySize() const { return history.count(); }
  378.     int currentPosition() const { return current; }
  379.  
  380. private:
  381.     QPtrList<QTextCommand> history;
  382.     int current, steps;
  383.  
  384. };
  385.  
  386. // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  387.  
  388. class Q_EXPORT QTextCustomItem
  389. {
  390. public:
  391.     QTextCustomItem( QTextDocument *p )
  392.     :  xpos(0), ypos(-1), width(-1), height(0), parent( p )
  393.     {}
  394.     virtual ~QTextCustomItem();
  395.     virtual void draw(QPainter* p, int x, int y, int cx, int cy, int cw, int ch, const QColorGroup& cg, bool selected ) = 0;
  396.  
  397.     virtual void setPainter( QPainter*, bool adjust );
  398.  
  399.     enum Placement { PlaceInline = 0, PlaceLeft, PlaceRight };
  400.     virtual Placement placement() const;
  401.     bool placeInline() { return placement() == PlaceInline; }
  402.  
  403.     virtual bool ownLine() const;
  404.     virtual void resize( QPainter*, int nwidth );
  405.     virtual void invalidate();
  406.     virtual int ascent() const { return height; }
  407.  
  408.     virtual bool isNested() const;
  409.     virtual int minimumWidth() const;
  410.     virtual int widthHint() const;
  411.  
  412.     virtual QString richText() const;
  413.  
  414.     int xpos; // used for floating items
  415.     int ypos; // used for floating items
  416.     int width;
  417.     int height;
  418.  
  419.     QRect geometry() const { return QRect( xpos, ypos, width, height ); }
  420.  
  421.     virtual bool enter( QTextCursor *, QTextDocument *&doc, QTextParag *¶g, int &idx, int &ox, int &oy, bool atEnd = FALSE );
  422.     virtual bool enterAt( QTextCursor *, QTextDocument *&doc, QTextParag *¶g, int &idx, int &ox, int &oy, const QPoint & );
  423.     virtual bool next( QTextCursor *, QTextDocument *&doc, QTextParag *¶g, int &idx, int &ox, int &oy );
  424.     virtual bool prev( QTextCursor *, QTextDocument *&doc, QTextParag *¶g, int &idx, int &ox, int &oy );
  425.     virtual bool down( QTextCursor *, QTextDocument *&doc, QTextParag *¶g, int &idx, int &ox, int &oy );
  426.     virtual bool up( QTextCursor *, QTextDocument *&doc, QTextParag *¶g, int &idx, int &ox, int &oy );
  427.  
  428.     void setParagraph( QTextParag *p ) { parag = p; }
  429.     QTextParag *paragrapth() const { return parag; }
  430.  
  431.     QTextDocument *parent;
  432.     QTextParag *parag;
  433.  
  434.     virtual void pageBreak( int  y, QTextFlow* flow );
  435. };
  436.  
  437. #if defined(Q_TEMPLATEDLL)
  438. // MOC_SKIP_BEGIN
  439. template class Q_EXPORT QMap<QString, QString>;
  440. // MOC_SKIP_END
  441. #endif
  442.  
  443. class Q_EXPORT QTextImage : public QTextCustomItem
  444. {
  445. public:
  446.     QTextImage( QTextDocument *p, const QMap<QString, QString> &attr, const QString& context,
  447.         QMimeSourceFactory &factory );
  448.     virtual ~QTextImage();
  449.  
  450.     Placement placement() const { return place; }
  451.     void setPainter( QPainter*, bool );
  452.     int widthHint() const { return width; }
  453.     int minimumWidth() const { return width; }
  454.  
  455.     QString richText() const;
  456.  
  457.     void draw( QPainter* p, int x, int y, int cx, int cy, int cw, int ch, const QColorGroup& cg, bool selected );
  458.  
  459. private:
  460.     QRegion* reg;
  461.     QPixmap pm;
  462.     Placement place;
  463.     int tmpwidth, tmpheight;
  464.     QMap<QString, QString> attributes;
  465.     QString imgId;
  466.  
  467. };
  468.  
  469. class Q_EXPORT QTextHorizontalLine : public QTextCustomItem
  470. {
  471. public:
  472.     QTextHorizontalLine( QTextDocument *p, const QMap<QString, QString> &attr, const QString& context,
  473.              QMimeSourceFactory &factory );
  474.     virtual ~QTextHorizontalLine();
  475.  
  476.     void setPainter( QPainter*, bool );
  477.     void draw(QPainter* p, int x, int y, int cx, int cy, int cw, int ch, const QColorGroup& cg, bool selected );
  478.     QString richText() const;
  479.  
  480.     bool ownLine() const { return TRUE; }
  481.  
  482. private:
  483.     int tmpheight;
  484.     QColor color;
  485.  
  486. };
  487.  
  488. #if defined(Q_TEMPLATEDLL)
  489. // MOC_SKIP_BEGIN
  490. template class Q_EXPORT QPtrList<QTextCustomItem>;
  491. // MOC_SKIP_END
  492. #endif
  493.  
  494. class Q_EXPORT QTextFlow
  495. {
  496.     friend class QTextDocument;
  497.     friend class QTextTableCell;
  498.  
  499. public:
  500.     QTextFlow();
  501.     virtual ~QTextFlow();
  502.  
  503.     virtual void setWidth( int width );
  504.     int width() const;
  505.  
  506.     virtual void setPageSize( int ps );
  507.     int pageSize() const { return pagesize; }
  508.  
  509.     virtual int adjustLMargin( int yp, int h, int margin, int space );
  510.     virtual int adjustRMargin( int yp, int h, int margin, int space );
  511.  
  512.     virtual void registerFloatingItem( QTextCustomItem* item );
  513.     virtual void unregisterFloatingItem( QTextCustomItem* item );
  514.     virtual QRect boundingRect() const;
  515.     virtual void drawFloatingItems(QPainter* p, int cx, int cy, int cw, int ch, const QColorGroup& cg, bool selected );
  516.  
  517.     virtual int adjustFlow( int  y, int w, int h ); // adjusts y according to the defined pagesize. Returns the shift.
  518.  
  519.     virtual bool isEmpty();
  520.  
  521.     void clear();
  522.  
  523. private:
  524.     int w;
  525.     int pagesize;
  526.  
  527.     QPtrList<QTextCustomItem> leftItems;
  528.     QPtrList<QTextCustomItem> rightItems;
  529.  
  530. };
  531.  
  532. inline int QTextFlow::width() const { return w; }
  533.  
  534. class QTextTable;
  535.  
  536. class Q_EXPORT QTextTableCell : public QLayoutItem
  537. {
  538.     friend class QTextTable;
  539.  
  540. public:
  541.     QTextTableCell( QTextTable* table,
  542.             int row, int column,
  543.             const QMap<QString, QString> &attr,
  544.             const QStyleSheetItem* style,
  545.             const QTextFormat& fmt, const QString& context,
  546.             QMimeSourceFactory &factory, QStyleSheet *sheet, const QString& doc );
  547.     QTextTableCell( QTextTable* table, int row, int column );
  548.     virtual ~QTextTableCell();
  549.  
  550.     QSize sizeHint() const ;
  551.     QSize minimumSize() const ;
  552.     QSize maximumSize() const ;
  553.     QSizePolicy::ExpandData expanding() const;
  554.     bool isEmpty() const;
  555.     void setGeometry( const QRect& ) ;
  556.     QRect geometry() const;
  557.  
  558.     bool hasHeightForWidth() const;
  559.     int heightForWidth( int ) const;
  560.  
  561.     void setPainter( QPainter*, bool );
  562.  
  563.     int row() const { return row_; }
  564.     int column() const { return col_; }
  565.     int rowspan() const { return rowspan_; }
  566.     int colspan() const { return colspan_; }
  567.     int stretch() const { return stretch_; }
  568.  
  569.     QTextDocument* richText()  const { return richtext; }
  570.     QTextTable* table() const { return parent; }
  571.  
  572.     void draw( int x, int y, int cx, int cy, int cw, int ch, const QColorGroup& cg, bool selected );
  573.  
  574.     QBrush *backGround() const { return background; }
  575.     virtual void invalidate();
  576.  
  577.     int verticalAlignmentOffset() const;
  578.     int horizontalAlignmentOffset() const;
  579.  
  580. private:
  581.     QPainter* painter() const;
  582.     QRect geom;
  583.     QTextTable* parent;
  584.     QTextDocument* richtext;
  585.     int row_;
  586.     int col_;
  587.     int rowspan_;
  588.     int colspan_;
  589.     int stretch_;
  590.     int maxw;
  591.     int minw;
  592.     bool hasFixedWidth;
  593.     QBrush *background;
  594.     int cached_width;
  595.     int cached_sizehint;
  596.     QMap<QString, QString> attributes;
  597.     int align;
  598. };
  599.  
  600. #if defined(Q_TEMPLATEDLL)
  601. // MOC_SKIP_BEGIN
  602. template class Q_EXPORT QPtrList<QTextTableCell>;
  603. template class Q_EXPORT QMap<QTextCursor*, int>;
  604. // MOC_SKIP_END
  605. #endif
  606.  
  607. class Q_EXPORT QTextTable: public QTextCustomItem
  608. {
  609.     friend class QTextTableCell;
  610.  
  611. public:
  612.     QTextTable( QTextDocument *p, const QMap<QString, QString> &attr );
  613.     virtual ~QTextTable();
  614.  
  615.     void setPainter( QPainter *p, bool adjust );
  616.     void pageBreak( int  y, QTextFlow* flow );
  617.     void draw( QPainter* p, int x, int y, int cx, int cy, int cw, int ch,
  618.            const QColorGroup& cg, bool selected );
  619.  
  620.     bool noErase() const { return TRUE; }
  621.     bool ownLine() const { return TRUE; }
  622.     Placement placement() const { return place; }
  623.     bool isNested() const { return TRUE; }
  624.     void resize( QPainter*, int nwidth );
  625.     virtual void invalidate();
  626.     QString anchorAt( QPainter* p, int x, int y );
  627.  
  628.     virtual bool enter( QTextCursor *c, QTextDocument *&doc, QTextParag *¶g, int &idx, int &ox, int &oy, bool atEnd = FALSE );
  629.     virtual bool enterAt( QTextCursor *c, QTextDocument *&doc, QTextParag *¶g, int &idx, int &ox, int &oy, const QPoint &pos );
  630.     virtual bool next( QTextCursor *c, QTextDocument *&doc, QTextParag *¶g, int &idx, int &ox, int &oy );
  631.     virtual bool prev( QTextCursor *c, QTextDocument *&doc, QTextParag *¶g, int &idx, int &ox, int &oy );
  632.     virtual bool down( QTextCursor *c, QTextDocument *&doc, QTextParag *¶g, int &idx, int &ox, int &oy );
  633.     virtual bool up( QTextCursor *c, QTextDocument *&doc, QTextParag *¶g, int &idx, int &ox, int &oy );
  634.  
  635.     QString richText() const;
  636.  
  637.     int minimumWidth() const { return layout ? layout->minimumSize().width() : 0; }
  638.     int widthHint() const { return ( layout ? layout->sizeHint().width() : 0 ) + 2 * outerborder; }
  639.  
  640.     QPtrList<QTextTableCell> tableCells() const { return cells; }
  641.  
  642.     QRect geometry() const { return layout ? layout->geometry() : QRect(); }
  643.     bool isStretching() const { return stretch; }
  644.  
  645. private:
  646.     void format( int &w );
  647.     void addCell( QTextTableCell* cell );
  648.  
  649. private:
  650.     QGridLayout* layout;
  651.     QPtrList<QTextTableCell> cells;
  652.     QPainter* painter;
  653.     int cachewidth;
  654.     int fixwidth;
  655.     int cellpadding;
  656.     int cellspacing;
  657.     int border;
  658.     int outerborder;
  659.     int stretch;
  660.     int innerborder;
  661.     int us_cp, us_ib, us_b, us_ob, us_cs;
  662.     QMap<QString, QString> attributes;
  663.     QMap<QTextCursor*, int> currCell;
  664.     Placement place;
  665.     void adjustCells( int y , int shift );
  666.     int pageBreakFor;
  667. };
  668.  
  669. // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  670.  
  671. class QTextTableCell;
  672. class QTextParag;
  673.  
  674. struct Q_EXPORT QTextDocumentSelection
  675. {
  676.     QTextCursor startCursor, endCursor;
  677.     bool swapped;
  678. };
  679.  
  680. #if defined(Q_TEMPLATEDLL)
  681. // MOC_SKIP_BEGIN
  682. template class Q_EXPORT QMap<int, QColor>;
  683. template class Q_EXPORT QMap<int, bool>;
  684. template class Q_EXPORT QMap<int, QTextDocumentSelection>;
  685. template class Q_EXPORT QPtrList<QTextDocument>;
  686. // MOC_SKIP_END
  687. #endif
  688.  
  689. class Q_EXPORT QTextDocument : public QObject
  690. {
  691.     Q_OBJECT
  692.  
  693.     friend class QTextTableCell;
  694.     friend class QTextCursor;
  695.     friend class QTextEdit;
  696.     friend class QTextParag;
  697.  
  698. public:
  699.     enum SelectionIds {
  700.     Standard = 0,
  701.     Temp = 32000 // This selection must not be drawn, it's used e.g. by undo/redo to
  702.     // remove multiple lines with removeSelectedText()
  703.     };
  704.  
  705.     QTextDocument( QTextDocument *p );
  706.     QTextDocument( QTextDocument *d, QTextFormatCollection *f );
  707.     virtual ~QTextDocument();
  708.  
  709.     QTextDocument *parent() const { return par; }
  710.     QTextParag *parentParag() const { return parParag; }
  711.  
  712.     void setText( const QString &text, const QString &context );
  713.     QMap<QString, QString> attributes() const { return attribs; }
  714.     void setAttributes( const QMap<QString, QString> &attr ) { attribs = attr; }
  715.  
  716.     QString text() const;
  717.     QString text( int parag ) const;
  718.     QString originalText() const;
  719.  
  720.     int x() const;
  721.     int y() const;
  722.     int width() const;
  723.     int widthUsed() const;
  724.     int visibleWidth() const;
  725.     int height() const;
  726.     void setWidth( int w );
  727.     int minimumWidth() const;
  728.     bool setMinimumWidth( int w, QTextParag *parag );
  729.  
  730.     void setY( int y );
  731.     int leftMargin() const;
  732.     void setLeftMargin( int lm );
  733.     int rightMargin() const;
  734.     void setRightMargin( int rm );
  735.  
  736.     QTextParag *firstParag() const;
  737.     QTextParag *lastParag() const;
  738.     void setFirstParag( QTextParag *p );
  739.     void setLastParag( QTextParag *p );
  740.  
  741.     void invalidate();
  742.  
  743.     void setPreProcessor( QTextPreProcessor *sh );
  744.     QTextPreProcessor *preProcessor() const;
  745.  
  746.     void setFormatter( QTextFormatter *f );
  747.     QTextFormatter *formatter() const;
  748.  
  749.     void setIndent( QTextIndent *i );
  750.     QTextIndent *indent() const;
  751.  
  752.     QColor selectionColor( int id ) const;
  753.     bool invertSelectionText( int id ) const;
  754.     void setSelectionColor( int id, const QColor &c );
  755.     void setInvertSelectionText( int id, bool b );
  756.     bool hasSelection( int id, bool visible = FALSE ) const;
  757.     void setSelectionStart( int id, QTextCursor *cursor );
  758.     bool setSelectionEnd( int id, QTextCursor *cursor );
  759.     void selectAll( int id );
  760.     bool removeSelection( int id );
  761.     void selectionStart( int id, int ¶gId, int &index );
  762.     QTextCursor selectionStartCursor( int id );
  763.     QTextCursor selectionEndCursor( int id );
  764.     void selectionEnd( int id, int ¶gId, int &index );
  765.     void setFormat( int id, QTextFormat *f, int flags );
  766.     QTextParag *selectionStart( int id );
  767.     QTextParag *selectionEnd( int id );
  768.     int numSelections() const { return nSelections; }
  769.     void addSelection( int id );
  770.  
  771.     QString selectedText( int id, bool withCustom = TRUE ) const;
  772.     void copySelectedText( int id );
  773.     void removeSelectedText( int id, QTextCursor *cursor );
  774.     void indentSelection( int id );
  775.  
  776.     QTextParag *paragAt( int i ) const;
  777.  
  778.     void addCommand( QTextCommand *cmd );
  779.     QTextCursor *undo( QTextCursor *c = 0 );
  780.     QTextCursor *redo( QTextCursor *c  = 0 );
  781.     QTextCommandHistory *commands() const { return commandHistory; }
  782.  
  783.     QTextFormatCollection *formatCollection() const;
  784.  
  785.     bool find( const QString &expr, bool cs, bool wo, bool forward, int *parag, int *index, QTextCursor *cursor );
  786.  
  787.     void setTextFormat( Qt::TextFormat f );
  788.     Qt::TextFormat textFormat() const;
  789.  
  790.     bool inSelection( int selId, const QPoint &pos ) const;
  791.  
  792.     QStyleSheet *styleSheet() const { return sheet_; }
  793.     QMimeSourceFactory *mimeSourceFactory() const { return factory_; }
  794.     QString context() const { return contxt; }
  795.  
  796.     void setStyleSheet( QStyleSheet *s );
  797.     void updateStyles();
  798.     void updateFontSizes( int base );
  799.     void updateFontAttributes( const QFont &f, const QFont &old );
  800.     void setMimeSourceFactory( QMimeSourceFactory *f ) { if ( f ) factory_ = f; }
  801.     void setContext( const QString &c ) { if ( !c.isEmpty() ) contxt = c; }
  802.  
  803.     void setUnderlineLinks( bool b ) { underlLinks = b; }
  804.     bool underlineLinks() const { return underlLinks; }
  805.  
  806.     void setPaper( QBrush *brush ) { if ( backBrush ) delete backBrush; backBrush = brush; }
  807.     QBrush *paper() const { return backBrush; }
  808.  
  809.     void doLayout( QPainter *p, int w );
  810.     void draw( QPainter *p, const QRect& rect, const QColorGroup &cg, const QBrush *paper = 0 );
  811.     void drawParag( QPainter *p, QTextParag *parag, int cx, int cy, int cw, int ch,
  812.             QPixmap *&doubleBuffer, const QColorGroup &cg,
  813.             bool drawCursor, QTextCursor *cursor, bool resetChanged = TRUE );
  814.     QTextParag *draw( QPainter *p, int cx, int cy, int cw, int ch, const QColorGroup &cg,
  815.               bool onlyChanged = FALSE, bool drawCursor = FALSE, QTextCursor *cursor = 0,
  816.               bool resetChanged = TRUE );
  817.  
  818.     void setDefaultFont( const QFont &f );
  819.  
  820.     void registerCustomItem( QTextCustomItem *i, QTextParag *p );
  821.     void unregisterCustomItem( QTextCustomItem *i, QTextParag *p );
  822.  
  823.     void setFlow( QTextFlow *f );
  824.     void takeFlow();
  825.     QTextFlow *flow() const { return flow_; }
  826.     bool isPageBreakEnabled() const { return pages; }
  827.     void setPageBreakEnabled( bool b ) { pages = b; }
  828.  
  829.     void setUseFormatCollection( bool b ) { useFC = b; }
  830.     bool useFormatCollection() const { return useFC; }
  831.  
  832.     QTextTableCell *tableCell() const { return tc; }
  833.     void setTableCell( QTextTableCell *c ) { tc = c; }
  834.  
  835.     void setPlainText( const QString &text );
  836.     void setRichText( const QString &text, const QString &context );
  837.     QString richText( QTextParag *p = 0 ) const;
  838.     QString plainText( QTextParag *p = 0 ) const;
  839.  
  840.     bool focusNextPrevChild( bool next );
  841.  
  842.     int alignment() const;
  843.     void setAlignment( int a );
  844.  
  845.     int *tabArray() const;
  846.     int tabStopWidth() const;
  847.     void setTabArray( int *a );
  848.     void setTabStops( int tw );
  849.  
  850.     void setUndoDepth( int d ) { commandHistory->setUndoDepth( d ); }
  851.     int undoDepth() const { return commandHistory->undoDepth(); }
  852.  
  853.     int length() const;
  854.     void clear( bool createEmptyParag = FALSE );
  855.  
  856.     virtual QTextParag *createParag( QTextDocument *d, QTextParag *pr = 0, QTextParag *nx = 0, bool updateIds = TRUE );
  857.     void insertChild( QObject *o ) { QObject::insertChild( o ); }
  858.     void removeChild( QObject *o ) { QObject::removeChild( o ); }
  859.     void insertChild( QTextDocument *d ) { childList.append( d ); }
  860.     void removeChild( QTextDocument *d ) { childList.removeRef( d ); }
  861.     QPtrList<QTextDocument> children() const { return childList; }
  862.  
  863.     void setAddMargins( bool b ) { addMargs = b; }
  864.     int addMargins() const { return addMargs; }
  865.  
  866.     bool hasFocusParagraph() const;
  867.     QString focusHref() const;
  868.  
  869.     void invalidateOriginalText() { oTextValid = FALSE; }
  870.  
  871. signals:
  872.     void minimumWidthChanged( int );
  873.  
  874. private:
  875.     void init();
  876.     QPixmap *bufferPixmap( const QSize &s );
  877.     // HTML parser
  878.     bool hasPrefix(const QString& doc, int pos, QChar c);
  879.     bool hasPrefix(const QString& doc, int pos, const QString& s);
  880.     QTextCustomItem* parseTable( const QMap<QString, QString> &attr, const QTextFormat &fmt, const QString &doc, int& pos, QTextParag *curpar );
  881.     bool eatSpace(const QString& doc, int& pos, bool includeNbsp = FALSE );
  882.     bool eat(const QString& doc, int& pos, QChar c);
  883.     QString parseOpenTag(const QString& doc, int& pos, QMap<QString, QString> &attr, bool& emptyTag);
  884.     QString parseCloseTag( const QString& doc, int& pos );
  885.     QChar parseHTMLSpecialChar(const QString& doc, int& pos);
  886.     QString parseWord(const QString& doc, int& pos, bool lower = TRUE);
  887.     QChar parseChar(const QString& doc, int& pos, QStyleSheetItem::WhiteSpaceMode wsm );
  888.     void setRichTextInternal( const QString &text );
  889.  
  890. private:
  891.     struct Q_EXPORT Focus {
  892.     QTextParag *parag;
  893.     int start, len;
  894.     QString href;
  895.     };
  896.  
  897.     int cx, cy, cw, vw;
  898.     QTextParag *fParag, *lParag;
  899.     QTextPreProcessor *pProcessor;
  900.     QMap<int, QColor> selectionColors;
  901.     QMap<int, QTextDocumentSelection> selections;
  902.     QMap<int, bool> selectionText;
  903.     QTextCommandHistory *commandHistory;
  904.     QTextFormatter *pFormatter;
  905.     QTextIndent *indenter;
  906.     QTextFormatCollection *fCollection;
  907.     Qt::TextFormat txtFormat;
  908.     bool preferRichText : 1;
  909.     bool pages : 1;
  910.     bool useFC : 1;
  911.     bool withoutDoubleBuffer : 1;
  912.     bool underlLinks : 1;
  913.     bool nextDoubleBuffered : 1;
  914.     bool addMargs : 1;
  915.     bool oTextValid : 1;
  916.     int nSelections;
  917.     QTextFlow *flow_;
  918.     QPtrList<QTextCustomItem> customItems;
  919.     QTextDocument *par;
  920.     QTextParag *parParag;
  921.     QTextTableCell *tc;
  922.     QTextCursor *tmpCursor;
  923.     QBrush *backBrush;
  924.     QPixmap *buf_pixmap;
  925.     Focus focusIndicator;
  926.     int minw;
  927.     int leftmargin;
  928.     int rightmargin;
  929.     QTextParag *minwParag;
  930.     QStyleSheet* sheet_;
  931.     QMimeSourceFactory* factory_;
  932.     QString contxt;
  933.     QMap<QString, QString> attribs;
  934.     int align;
  935.     int *tArray;
  936.     int tStopWidth;
  937.     int uDepth;
  938.     QString oText;
  939.     QPtrList<QTextDocument> childList;
  940.     QColor linkColor;
  941.  
  942. };
  943.  
  944. // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  945.  
  946.  
  947. class Q_EXPORT QTextDeleteCommand : public QTextCommand
  948. {
  949. public:
  950.     QTextDeleteCommand( QTextDocument *d, int i, int idx, const QMemArray<QTextStringChar> &str,
  951.             const QValueList< QPtrVector<QStyleSheetItem> > &os,
  952.             const QValueList<QStyleSheetItem::ListStyle> &ols,
  953.             const QMemArray<int> &oas );
  954.     QTextDeleteCommand( QTextParag *p, int idx, const QMemArray<QTextStringChar> &str );
  955.     virtual ~QTextDeleteCommand();
  956.  
  957.     Commands type() const { return Delete; }
  958.     QTextCursor *execute( QTextCursor *c );
  959.     QTextCursor *unexecute( QTextCursor *c );
  960.  
  961. protected:
  962.     int id, index;
  963.     QTextParag *parag;
  964.     QMemArray<QTextStringChar> text;
  965.     QValueList< QPtrVector<QStyleSheetItem> > oldStyles;
  966.     QValueList<QStyleSheetItem::ListStyle> oldListStyles;
  967.     QMemArray<int> oldAligns;
  968.  
  969. };
  970.  
  971. class Q_EXPORT QTextInsertCommand : public QTextDeleteCommand
  972. {
  973. public:
  974.     QTextInsertCommand( QTextDocument *d, int i, int idx, const QMemArray<QTextStringChar> &str,
  975.             const QValueList< QPtrVector<QStyleSheetItem> > &os,
  976.             const QValueList<QStyleSheetItem::ListStyle> &ols,
  977.             const QMemArray<int> &oas )
  978.     : QTextDeleteCommand( d, i, idx, str, os, ols, oas ) {}
  979.     QTextInsertCommand( QTextParag *p, int idx, const QMemArray<QTextStringChar> &str )
  980.     : QTextDeleteCommand( p, idx, str ) {}
  981.     virtual ~QTextInsertCommand() {}
  982.  
  983.     Commands type() const { return Insert; }
  984.     QTextCursor *execute( QTextCursor *c ) { return QTextDeleteCommand::unexecute( c ); }
  985.     QTextCursor *unexecute( QTextCursor *c ) { return QTextDeleteCommand::execute( c ); }
  986.  
  987. };
  988.  
  989. class Q_EXPORT QTextFormatCommand : public QTextCommand
  990. {
  991. public:
  992.     QTextFormatCommand( QTextDocument *d, int sid, int sidx, int eid, int eidx, const QMemArray<QTextStringChar> &old, QTextFormat *f, int fl );
  993.     virtual ~QTextFormatCommand();
  994.  
  995.     Commands type() const { return Format; }
  996.     QTextCursor *execute( QTextCursor *c );
  997.     QTextCursor *unexecute( QTextCursor *c );
  998.  
  999. protected:
  1000.     int startId, startIndex, endId, endIndex;
  1001.     QTextFormat *format;
  1002.     QMemArray<QTextStringChar> oldFormats;
  1003.     int flags;
  1004.  
  1005. };
  1006.  
  1007. class Q_EXPORT QTextAlignmentCommand : public QTextCommand
  1008. {
  1009. public:
  1010.     QTextAlignmentCommand( QTextDocument *d, int fParag, int lParag, int na, const QMemArray<int> &oa );
  1011.     virtual ~QTextAlignmentCommand() {}
  1012.  
  1013.     Commands type() const { return Alignment; }
  1014.     QTextCursor *execute( QTextCursor *c );
  1015.     QTextCursor *unexecute( QTextCursor *c );
  1016.  
  1017. private:
  1018.     int firstParag, lastParag;
  1019.     int newAlign;
  1020.     QMemArray<int> oldAligns;
  1021.  
  1022. };
  1023.  
  1024. class Q_EXPORT QTextParagTypeCommand : public QTextCommand
  1025. {
  1026. public:
  1027.     QTextParagTypeCommand( QTextDocument *d, int fParag, int lParag, bool l,
  1028.                QStyleSheetItem::ListStyle s, const QValueList< QPtrVector<QStyleSheetItem> > &os,
  1029.                const QValueList<QStyleSheetItem::ListStyle> &ols );
  1030.     virtual ~QTextParagTypeCommand() {}
  1031.  
  1032.     Commands type() const { return ParagType; }
  1033.     QTextCursor *execute( QTextCursor *c );
  1034.     QTextCursor *unexecute( QTextCursor *c );
  1035.  
  1036. private:
  1037.     int firstParag, lastParag;
  1038.     bool list;
  1039.     QStyleSheetItem::ListStyle listStyle;
  1040.     QValueList< QPtrVector<QStyleSheetItem> > oldStyles;
  1041.     QValueList<QStyleSheetItem::ListStyle> oldListStyles;
  1042.  
  1043. };
  1044.  
  1045. // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1046.  
  1047. struct Q_EXPORT QTextParagSelection
  1048. {
  1049.     int start, end;
  1050. };
  1051.  
  1052. struct Q_EXPORT QTextParagLineStart
  1053. {
  1054.     QTextParagLineStart() : y( 0 ), baseLine( 0 ), h( 0 )
  1055. #ifndef QT_NO_COMPLEXTEXT
  1056.     , bidicontext( 0 )
  1057. #endif
  1058.     {  }
  1059.     QTextParagLineStart( ushort y_, ushort bl, ushort h_ ) : y( y_ ), baseLine( bl ), h( h_ ),
  1060.     w( 0 )
  1061. #ifndef QT_NO_COMPLEXTEXT
  1062.     , bidicontext( 0 )
  1063. #endif
  1064.     {  }
  1065. #ifndef QT_NO_COMPLEXTEXT
  1066.     QTextParagLineStart( QBidiContext *c, QBidiStatus s ) : y(0), baseLine(0), h(0),
  1067.     status( s ), bidicontext( c ) { if ( bidicontext ) bidicontext->ref(); }
  1068. #endif
  1069.  
  1070.     virtual ~QTextParagLineStart()
  1071.     {
  1072. #ifndef QT_NO_COMPLEXTEXT
  1073.     if ( bidicontext && bidicontext->deref() )
  1074.         delete bidicontext;
  1075. #endif
  1076.     }
  1077.  
  1078. #ifndef QT_NO_COMPLEXTEXT
  1079.     void setContext( QBidiContext *c ) {
  1080.     if ( c == bidicontext )
  1081.         return;
  1082.     if ( bidicontext && bidicontext->deref() )
  1083.         delete bidicontext;
  1084.     bidicontext = c;
  1085.     if ( bidicontext )
  1086.         bidicontext->ref();
  1087.     }
  1088.     QBidiContext *context() const { return bidicontext; }
  1089. #endif
  1090.  
  1091. public:
  1092.     ushort y, baseLine, h;
  1093. #ifndef QT_NO_COMPLEXTEXT
  1094.     QBidiStatus status;
  1095. #endif
  1096.     int w;
  1097.  
  1098. private:
  1099. #ifndef QT_NO_COMPLEXTEXT
  1100.     QBidiContext *bidicontext;
  1101. #endif
  1102. };
  1103.  
  1104. #if defined(Q_TEMPLATEDLL)
  1105. // MOC_SKIP_BEGIN
  1106. template class Q_EXPORT QMap<int, QTextParagSelection>;
  1107. template class Q_EXPORT QMap<int, QTextParagLineStart*>;
  1108. // MOC_SKIP_END
  1109. #endif
  1110.  
  1111. class Q_EXPORT QTextParagData
  1112. {
  1113. public:
  1114.     QTextParagData() {}
  1115.     virtual ~QTextParagData();
  1116.     virtual void join( QTextParagData * );
  1117. };
  1118.  
  1119. class Q_EXPORT QTextParag
  1120. {
  1121.     friend class QTextDocument;
  1122.     friend class QTextCursor;
  1123.  
  1124. public:
  1125.     QTextParag( QTextDocument *d, QTextParag *pr = 0, QTextParag *nx = 0, bool updateIds = TRUE );
  1126.     virtual ~QTextParag();
  1127.  
  1128.     QTextString *string() const;
  1129.     QTextStringChar *at( int i ) const; // maybe remove later
  1130.     int leftGap() const;
  1131.     int length() const; // maybe remove later
  1132.  
  1133.     void setListStyle( QStyleSheetItem::ListStyle ls );
  1134.     QStyleSheetItem::ListStyle listStyle() const;
  1135.     void setListValue( int v ) { list_val = v; }
  1136.     int listValue() const { return list_val; }
  1137.  
  1138.     void setList( bool b, int listStyle );
  1139.     void incDepth();
  1140.     void decDepth();
  1141.     int listDepth() const;
  1142.  
  1143.     void setFormat( QTextFormat *fm );
  1144.     QTextFormat *paragFormat() const;
  1145.  
  1146.     QTextDocument *document() const;
  1147.  
  1148.     QRect rect() const;
  1149.     void setHeight( int h ) { r.setHeight( h ); }
  1150.     void show();
  1151.     void hide();
  1152.     bool isVisible() const { return visible; }
  1153.  
  1154.     QTextParag *prev() const;
  1155.     QTextParag *next() const;
  1156.     void setPrev( QTextParag *s );
  1157.     void setNext( QTextParag *s );
  1158.  
  1159.     void insert( int index, const QString &s );
  1160.     void append( const QString &s, bool reallyAtEnd = FALSE );
  1161.     void truncate( int index );
  1162.     void remove( int index, int len );
  1163.     void join( QTextParag *s );
  1164.  
  1165.     void invalidate( int chr );
  1166.  
  1167.     void move( int &dy );
  1168.     void format( int start = -1, bool doMove = TRUE );
  1169.  
  1170.     bool isValid() const;
  1171.     bool hasChanged() const;
  1172.     void setChanged( bool b, bool recursive = FALSE );
  1173.  
  1174.     int lineHeightOfChar( int i, int *bl = 0, int *y = 0 ) const;
  1175.     QTextStringChar *lineStartOfChar( int i, int *index = 0, int *line = 0 ) const;
  1176.     int lines() const;
  1177.     QTextStringChar *lineStartOfLine( int line, int *index = 0 ) const;
  1178.     int lineY( int l ) const;
  1179.     int lineBaseLine( int l ) const;
  1180.     int lineHeight( int l ) const;
  1181.     void lineInfo( int l, int &y, int &h, int &bl ) const;
  1182.  
  1183.     void setSelection( int id, int start, int end );
  1184.     void removeSelection( int id );
  1185.     int selectionStart( int id ) const;
  1186.     int selectionEnd( int id ) const;
  1187.     bool hasSelection( int id ) const;
  1188.     bool hasAnySelection() const;
  1189.     bool fullSelected( int id ) const;
  1190.  
  1191.     void setEndState( int s );
  1192.     int endState() const;
  1193.  
  1194.     void setParagId( int i );
  1195.     int paragId() const;
  1196.  
  1197.     bool firstPreProcess() const;
  1198.     void setFirstPreProcess( bool b );
  1199.  
  1200.     void indent( int *oldIndent = 0, int *newIndent = 0 );
  1201.  
  1202.     void setExtraData( QTextParagData *data );
  1203.     QTextParagData *extraData() const;
  1204.  
  1205.     QMap<int, QTextParagLineStart*> &lineStartList();
  1206.  
  1207.     void setFormat( int index, int len, QTextFormat *f, bool useCollection = TRUE, int flags = -1 );
  1208.  
  1209.     void setAlignment( int a );
  1210.     int alignment() const;
  1211.  
  1212.     virtual void paint( QPainter &painter, const QColorGroup &cg, QTextCursor *cursor = 0, bool drawSelections = FALSE,
  1213.             int clipx = -1, int clipy = -1, int clipw = -1, int cliph = -1 );
  1214.  
  1215.     void setStyleSheetItems( const QPtrVector<QStyleSheetItem> &vec );
  1216.     QPtrVector<QStyleSheetItem> styleSheetItems() const;
  1217.     QStyleSheetItem *style() const;
  1218.  
  1219.     virtual int topMargin() const;
  1220.     virtual int bottomMargin() const;
  1221.     virtual int leftMargin() const;
  1222.     virtual int firstLineMargin() const;
  1223.     virtual int rightMargin() const;
  1224.     virtual int lineSpacing() const;
  1225.  
  1226.     int numberOfSubParagraph() const;
  1227.     void registerFloatingItem( QTextCustomItem *i );
  1228.     void unregisterFloatingItem( QTextCustomItem *i );
  1229.  
  1230.     void setFullWidth( bool b ) { fullWidth = b; }
  1231.     bool isFullWidth() const { return fullWidth; }
  1232.  
  1233.     QTextTableCell *tableCell() const { return tc; }
  1234.     void setTableCell( QTextTableCell *c ) { tc = c; }
  1235.  
  1236.     void addCustomItem();
  1237.     void removeCustomItem();
  1238.     int customItems() const;
  1239.  
  1240.     QBrush *background() const;
  1241.  
  1242.     void setDocumentRect( const QRect &r );
  1243.     int documentWidth() const;
  1244.     int documentVisibleWidth() const;
  1245.     int documentX() const;
  1246.     int documentY() const;
  1247.     QTextFormatCollection *formatCollection() const;
  1248.     void setFormatter( QTextFormatter *f );
  1249.     QTextFormatter *formatter() const;
  1250.     int minimumWidth() const;
  1251.  
  1252.     virtual int nextTab( int i, int x );
  1253.     int *tabArray() const;
  1254.     void setTabArray( int *a );
  1255.     void setTabStops( int tw );
  1256.  
  1257.     void setPainter( QPainter *p, bool adjust  );
  1258.     QPainter *painter() const { return pntr; }
  1259.  
  1260.     void setNewLinesAllowed( bool b );
  1261.     bool isNewLinesAllowed() const;
  1262.  
  1263.     QString richText() const;
  1264.  
  1265.     void addCommand( QTextCommand *cmd );
  1266.     QTextCursor *undo( QTextCursor *c = 0 );
  1267.     QTextCursor *redo( QTextCursor *c  = 0 );
  1268.     QTextCommandHistory *commands() const { return commandHistory; }
  1269.     virtual void copyParagData( QTextParag *parag );
  1270.  
  1271.     void setBreakable( bool b ) { breakable = b; }
  1272.     bool isBreakable() const { return breakable; }
  1273.  
  1274.     void setBackgroundColor( const QColor &c );
  1275.     QColor *backgroundColor() const { return bgcol; }
  1276.     void clearBackgroundColor();
  1277.  
  1278.     bool isLineBreak() const { return isBr; }
  1279.  
  1280.     void setMovedDown( bool b ) { movedDown = b; }
  1281.     bool wasMovedDown() const { return movedDown; }
  1282.  
  1283.     void setDirection( QChar::Direction d );
  1284.     QChar::Direction direction() const;
  1285.     
  1286. protected:
  1287.     virtual void drawLabel( QPainter* p, int x, int y, int w, int h, int base, const QColorGroup& cg );
  1288.     virtual void drawParagString( QPainter &painter, const QString &str, int start, int len, int startX,
  1289.                   int lastY, int baseLine, int bw, int h, bool drawSelections,
  1290.                   QTextFormat *lastFormat, int i, const QMemArray<int> &selectionStarts,
  1291.                   const QMemArray<int> &selectionEnds, const QColorGroup &cg, bool rightToLeft  );
  1292.  
  1293. private:
  1294.  
  1295.     QMap<int, QTextParagLineStart*> lineStarts;
  1296.     int invalid;
  1297.     QRect r;
  1298.     QTextParag *p, *n;
  1299.     QTextDocument *doc;
  1300.     uint changed : 1;
  1301.     uint firstFormat : 1;
  1302.     uint firstPProcess : 1;
  1303.     uint needPreProcess : 1;
  1304.     uint fullWidth : 1;
  1305.     uint newLinesAllowed : 1;
  1306.     uint lastInFrame : 1;
  1307.     uint visible : 1;
  1308.     uint breakable : 1;
  1309.     uint isBr : 1;
  1310.     uint movedDown : 1;
  1311.     QMap<int, QTextParagSelection> selections;
  1312.     int state, id;
  1313.     QTextString *str;
  1314.     int align;
  1315.     QPtrVector<QStyleSheetItem> styleSheetItemsVec;
  1316.     QStyleSheetItem::ListStyle listS;
  1317.     int numSubParag;
  1318.     int tm, bm, lm, rm, flm;
  1319.     QTextFormat *defFormat;
  1320.     QPtrList<QTextCustomItem> floatingItems;
  1321.     QTextTableCell *tc;
  1322.     int numCustomItems;
  1323.     QRect docRect;
  1324.     QTextFormatter *pFormatter;
  1325.     int *tArray;
  1326.     int tabStopWidth;
  1327.     QTextParagData *eData;
  1328.     QPainter *pntr;
  1329.     QTextCommandHistory *commandHistory;
  1330.     int list_val;
  1331.     QColor *bgcol;
  1332.  
  1333. };
  1334.  
  1335. // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1336.  
  1337. class Q_EXPORT QTextFormatter
  1338. {
  1339. public:
  1340.     QTextFormatter();
  1341.     virtual ~QTextFormatter();
  1342.  
  1343.     virtual int format( QTextDocument *doc, QTextParag *parag, int start, const QMap<int, QTextParagLineStart*> &oldLineStarts ) = 0;
  1344.     virtual int formatVertically( QTextDocument* doc, QTextParag* parag );
  1345.  
  1346.     bool isWrapEnabled( QTextParag *p ) const { if ( !wrapEnabled ) return FALSE; if ( p && !p->isBreakable() ) return FALSE; return TRUE;}
  1347.     int wrapAtColumn() const { return wrapColumn;}
  1348.     virtual void setWrapEnabled( bool b );
  1349.     virtual void setWrapAtColumn( int c );
  1350.     virtual void setAllowBreakInWords( bool b ) { biw = b; }
  1351.     bool allowBreakInWords() const { return biw; }
  1352.  
  1353. protected:
  1354.     virtual QTextParagLineStart *formatLine( QTextParag *parag, QTextString *string, QTextParagLineStart *line, QTextStringChar *start,
  1355.                            QTextStringChar *last, int align = Qt::AlignAuto, int space = 0 );
  1356. #ifndef QT_NO_COMPLEXTEXT
  1357.     virtual QTextParagLineStart *bidiReorderLine( QTextParag *parag, QTextString *string, QTextParagLineStart *line, QTextStringChar *start,
  1358.                             QTextStringChar *last, int align, int space );
  1359. #endif
  1360.     virtual bool isBreakable( QTextString *string, int pos ) const;
  1361.     void insertLineStart( QTextParag *parag, int index, QTextParagLineStart *ls );
  1362.  
  1363. private:
  1364.     bool wrapEnabled;
  1365.     int wrapColumn;
  1366.     bool biw;
  1367.  
  1368. #ifdef HAVE_THAI_BREAKS
  1369.     static QCString *thaiCache;
  1370.     static QTextString *cachedString;
  1371.     static ThBreakIterator *thaiIt;
  1372. #endif
  1373. };
  1374.  
  1375. // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1376.  
  1377. class Q_EXPORT QTextFormatterBreakInWords : public QTextFormatter
  1378. {
  1379. public:
  1380.     QTextFormatterBreakInWords();
  1381.     virtual ~QTextFormatterBreakInWords() {}
  1382.  
  1383.     int format( QTextDocument *doc, QTextParag *parag, int start, const QMap<int, QTextParagLineStart*> &oldLineStarts );
  1384.  
  1385. };
  1386.  
  1387. // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1388.  
  1389. class Q_EXPORT QTextFormatterBreakWords : public QTextFormatter
  1390. {
  1391. public:
  1392.     QTextFormatterBreakWords();
  1393.     virtual ~QTextFormatterBreakWords() {}
  1394.  
  1395.     int format( QTextDocument *doc, QTextParag *parag, int start, const QMap<int, QTextParagLineStart*> &oldLineStarts );
  1396.  
  1397. };
  1398.  
  1399. // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1400.  
  1401. class Q_EXPORT QTextIndent
  1402. {
  1403. public:
  1404.     QTextIndent();
  1405.     virtual ~QTextIndent() {}
  1406.  
  1407.     virtual void indent( QTextDocument *doc, QTextParag *parag, int *oldIndent = 0, int *newIndent = 0 ) = 0;
  1408.  
  1409. };
  1410.  
  1411. // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1412.  
  1413. class Q_EXPORT QTextPreProcessor
  1414. {
  1415. public:
  1416.     enum Ids {
  1417.     Standard = 0
  1418.     };
  1419.  
  1420.     QTextPreProcessor();
  1421.     virtual ~QTextPreProcessor() {}
  1422.  
  1423.     virtual void process( QTextDocument *doc, QTextParag *, int, bool = TRUE ) = 0;
  1424.     virtual QTextFormat *format( int id ) = 0;
  1425.  
  1426. };
  1427.  
  1428. // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1429.  
  1430. class Q_EXPORT QTextFormat
  1431. {
  1432.     friend class QTextFormatCollection;
  1433.     friend class QTextDocument;
  1434.  
  1435. public:
  1436.     enum Flags {
  1437.     NoFlags,
  1438.     Bold = 1,
  1439.     Italic = 2,
  1440.     Underline = 4,
  1441.     Family = 8,
  1442.     Size = 16,
  1443.     Color = 32,
  1444.     Misspelled = 64,
  1445.     VAlign = 128,
  1446.     Font = Bold | Italic | Underline | Family | Size,
  1447.     Format = Font | Color | Misspelled | VAlign
  1448.     };
  1449.  
  1450.     enum VerticalAlignment { AlignNormal, AlignSubScript, AlignSuperScript };
  1451.  
  1452.     QTextFormat();
  1453.     virtual ~QTextFormat() {}
  1454.  
  1455.     QTextFormat( const QStyleSheetItem *s );
  1456.     QTextFormat( const QFont &f, const QColor &c, QTextFormatCollection *parent = 0 );
  1457.     QTextFormat( const QTextFormat &fm );
  1458.     QTextFormat makeTextFormat( const QStyleSheetItem *style, const QMap<QString,QString>& attr ) const;
  1459.     QTextFormat& operator=( const QTextFormat &fm );
  1460.     QColor color() const;
  1461.     QFont font() const;
  1462.     bool isMisspelled() const;
  1463.     VerticalAlignment vAlign() const;
  1464.     int minLeftBearing() const;
  1465.     int minRightBearing() const;
  1466.     int width( const QChar &c ) const;
  1467.     int width( const QString &str, int pos ) const;
  1468.     int height() const;
  1469.     int ascent() const;
  1470.     int descent() const;
  1471.     QString anchorHref() const;
  1472.     QString anchorName() const;
  1473.     bool isAnchor() const;
  1474.     bool useLinkColor() const;
  1475.  
  1476.     void setBold( bool b );
  1477.     void setItalic( bool b );
  1478.     void setUnderline( bool b );
  1479.     void setFamily( const QString &f );
  1480.     void setPointSize( int s );
  1481.     void setFont( const QFont &f );
  1482.     void setColor( const QColor &c );
  1483.     void setMisspelled( bool b );
  1484.     void setVAlign( VerticalAlignment a );
  1485.  
  1486.     bool operator==( const QTextFormat &f ) const;
  1487.     QTextFormatCollection *parent() const;
  1488.     QString key() const;
  1489.  
  1490.     static QString getKey( const QFont &f, const QColor &c, bool misspelled, const QString &lhref, const QString &lnm, VerticalAlignment vAlign );
  1491.  
  1492.     void addRef();
  1493.     void removeRef();
  1494.  
  1495.     QString makeFormatChangeTags( QTextFormat *f ) const;
  1496.     QString makeFormatEndTags() const;
  1497.  
  1498.     void setPainter( QPainter *p );
  1499.     void updateStyle();
  1500.     void updateStyleFlags();
  1501.     void setStyle( const QString &s );
  1502.     QString styleName() const { return style; }
  1503.  
  1504.     int changed() const { return different; }
  1505.  
  1506. protected:
  1507.     virtual void generateKey();
  1508.  
  1509. private:
  1510.     void update();
  1511.  
  1512. private:
  1513.     QFont fn;
  1514.     QColor col;
  1515.     QFontMetrics fm;
  1516.     uint missp : 1;
  1517.     uint linkColor : 1;
  1518.     int leftBearing, rightBearing;
  1519.     VerticalAlignment ha;
  1520.     uchar widths[ 256 ];
  1521.     int hei, asc, dsc;
  1522.     QTextFormatCollection *collection;
  1523.     int ref;
  1524.     QString k;
  1525.     int logicalFontSize;
  1526.     int stdPointSize;
  1527.     QString anchor_href;
  1528.     QString anchor_name;
  1529.     QPainter *painter;
  1530.     QString style;
  1531.     int different;
  1532.  
  1533. };
  1534.  
  1535. // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1536.  
  1537. #if defined(Q_TEMPLATEDLL)
  1538. // MOC_SKIP_BEGIN
  1539. template class Q_EXPORT QDict<QTextFormat>;
  1540. // MOC_SKIP_END
  1541. #endif
  1542.  
  1543. class Q_EXPORT QTextFormatCollection
  1544. {
  1545.     friend class QTextDocument;
  1546.     friend class QTextFormat;
  1547.  
  1548. public:
  1549.     QTextFormatCollection();
  1550.     virtual ~QTextFormatCollection();
  1551.  
  1552.     void setDefaultFormat( QTextFormat *f );
  1553.     QTextFormat *defaultFormat() const;
  1554.     virtual QTextFormat *format( QTextFormat *f );
  1555.     virtual QTextFormat *format( QTextFormat *of, QTextFormat *nf, int flags );
  1556.     virtual QTextFormat *format( const QFont &f, const QColor &c );
  1557.     virtual void remove( QTextFormat *f );
  1558.     virtual QTextFormat *createFormat( const QTextFormat &f ) { return new QTextFormat( f ); }
  1559.     virtual QTextFormat *createFormat( const QFont &f, const QColor &c ) { return new QTextFormat( f, c, this ); }
  1560.     void debug();
  1561.  
  1562.     void setPainter( QPainter *p );
  1563.     QStyleSheet *styleSheet() const { return sheet; }
  1564.     void setStyleSheet( QStyleSheet *s ) { sheet = s; }
  1565.     void updateStyles();
  1566.     void updateFontSizes( int base );
  1567.     void updateFontAttributes( const QFont &f, const QFont &old );
  1568.     QDict<QTextFormat> dict() const { return cKey; }
  1569.  
  1570. private:
  1571.     QTextFormat *defFormat, *lastFormat, *cachedFormat;
  1572.     QDict<QTextFormat> cKey;
  1573.     QTextFormat *cres;
  1574.     QFont cfont;
  1575.     QColor ccol;
  1576.     QString kof, knf;
  1577.     int cflags;
  1578.     QStyleSheet *sheet;
  1579.  
  1580. };
  1581.  
  1582. // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1583.  
  1584. inline int QTextString::length() const
  1585. {
  1586.     return data.size();
  1587. }
  1588.  
  1589. inline void QTextString::operator+=( const QString &s )
  1590. {
  1591.     insert( length(), s, 0 );
  1592. }
  1593.  
  1594. inline int QTextParag::length() const
  1595. {
  1596.     return str->length();
  1597. }
  1598.  
  1599. inline QRect QTextParag::rect() const
  1600. {
  1601.     return r;
  1602. }
  1603.  
  1604. inline QTextParag *QTextCursor::parag() const
  1605. {
  1606.     return string;
  1607. }
  1608.  
  1609. inline int QTextCursor::index() const
  1610. {
  1611.     return idx;
  1612. }
  1613.  
  1614. inline void QTextCursor::setIndex( int i, bool restore )
  1615. {
  1616.     if ( restore )
  1617.     restoreState();
  1618.     if ( i >= string->length() ) {
  1619. #if defined(QT_CHECK_RANGE)
  1620.     qWarning( "QTextCursor::setIndex: %d out of range", i );
  1621. #endif
  1622.     i = string->length() - 1;
  1623.     }
  1624.  
  1625.     tmpIndex = -1;
  1626.     idx = i;
  1627. }
  1628.  
  1629. inline void QTextCursor::setParag( QTextParag *s, bool restore )
  1630. {
  1631.     if ( restore )
  1632.     restoreState();
  1633.     idx = 0;
  1634.     string = s;
  1635.     tmpIndex = -1;
  1636. }
  1637.  
  1638. inline void QTextCursor::checkIndex()
  1639. {
  1640.     if ( idx >= string->length() )
  1641.     idx = string->length() - 1;
  1642. }
  1643.  
  1644. // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1645.  
  1646. inline int QTextDocument::x() const
  1647. {
  1648.     return cx;
  1649. }
  1650.  
  1651. inline int QTextDocument::y() const
  1652. {
  1653.     return cy;
  1654. }
  1655.  
  1656. inline int QTextDocument::width() const
  1657. {
  1658.     return QMAX( cw, flow_->width() );
  1659. }
  1660.  
  1661. inline int QTextDocument::visibleWidth() const
  1662. {
  1663.     return vw;
  1664. }
  1665.  
  1666. inline QTextParag *QTextDocument::firstParag() const
  1667. {
  1668.     return fParag;
  1669. }
  1670.  
  1671. inline QTextParag *QTextDocument::lastParag() const
  1672. {
  1673.     return lParag;
  1674. }
  1675.  
  1676. inline void QTextDocument::setFirstParag( QTextParag *p )
  1677. {
  1678.     fParag = p;
  1679. }
  1680.  
  1681. inline void QTextDocument::setLastParag( QTextParag *p )
  1682. {
  1683.     lParag = p;
  1684. }
  1685.  
  1686. inline void QTextDocument::setWidth( int w )
  1687. {
  1688.     cw = QMAX( w, minw );
  1689.     flow_->setWidth( cw );
  1690.     vw = w;
  1691. }
  1692.  
  1693. inline int QTextDocument::minimumWidth() const
  1694. {
  1695.     return minw;
  1696. }
  1697.  
  1698. inline void QTextDocument::setY( int y )
  1699. {
  1700.     cy = y;
  1701. }
  1702.  
  1703. inline int QTextDocument::leftMargin() const
  1704. {
  1705.     return leftmargin;
  1706. }
  1707.  
  1708. inline void QTextDocument::setLeftMargin( int lm )
  1709. {
  1710.     leftmargin = lm;
  1711. }
  1712.  
  1713. inline int QTextDocument::rightMargin() const
  1714. {
  1715.     return rightmargin;
  1716. }
  1717.  
  1718. inline void QTextDocument::setRightMargin( int rm )
  1719. {
  1720.     rightmargin = rm;
  1721. }
  1722.  
  1723. inline QTextPreProcessor *QTextDocument::preProcessor() const
  1724. {
  1725.     return pProcessor;
  1726. }
  1727.  
  1728. inline void QTextDocument::setPreProcessor( QTextPreProcessor * sh )
  1729. {
  1730.     pProcessor = sh;
  1731. }
  1732.  
  1733. inline void QTextDocument::setFormatter( QTextFormatter *f )
  1734. {
  1735.     delete pFormatter;
  1736.     pFormatter = f;
  1737. }
  1738.  
  1739. inline QTextFormatter *QTextDocument::formatter() const
  1740. {
  1741.     return pFormatter;
  1742. }
  1743.  
  1744. inline void QTextDocument::setIndent( QTextIndent *i )
  1745. {
  1746.     indenter = i;
  1747. }
  1748.  
  1749. inline QTextIndent *QTextDocument::indent() const
  1750. {
  1751.     return indenter;
  1752. }
  1753.  
  1754. inline QColor QTextDocument::selectionColor( int id ) const
  1755. {
  1756.     return selectionColors[ id ];
  1757. }
  1758.  
  1759. inline bool QTextDocument::invertSelectionText( int id ) const
  1760. {
  1761.     return selectionText[ id ];
  1762. }
  1763.  
  1764. inline void QTextDocument::setSelectionColor( int id, const QColor &c )
  1765. {
  1766.     selectionColors[ id ] = c;
  1767. }
  1768.  
  1769. inline void QTextDocument::setInvertSelectionText( int id, bool b )
  1770. {
  1771.     selectionText[ id ] = b;
  1772. }
  1773.  
  1774. inline QTextFormatCollection *QTextDocument::formatCollection() const
  1775. {
  1776.     return fCollection;
  1777. }
  1778.  
  1779. inline int QTextDocument::alignment() const
  1780. {
  1781.     return align;
  1782. }
  1783.  
  1784. inline void QTextDocument::setAlignment( int a )
  1785. {
  1786.     align = a;
  1787. }
  1788.  
  1789. inline int *QTextDocument::tabArray() const
  1790. {
  1791.     return tArray;
  1792. }
  1793.  
  1794. inline int QTextDocument::tabStopWidth() const
  1795. {
  1796.     return tStopWidth;
  1797. }
  1798.  
  1799. inline void QTextDocument::setTabArray( int *a )
  1800. {
  1801.     tArray = a;
  1802. }
  1803.  
  1804. inline void QTextDocument::setTabStops( int tw )
  1805. {
  1806.     tStopWidth = tw;
  1807. }
  1808.  
  1809. inline QString QTextDocument::originalText() const
  1810. {
  1811.     if ( oTextValid )
  1812.     return oText;
  1813.     return text();
  1814. }
  1815.  
  1816. inline void QTextDocument::setFlow( QTextFlow *f )
  1817. {
  1818.     if ( flow_ )
  1819.     delete flow_;
  1820.     flow_ = f;
  1821. }
  1822.  
  1823. inline void QTextDocument::takeFlow()
  1824. {
  1825.     flow_ = 0;
  1826. }
  1827.  
  1828. // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1829.  
  1830. inline QColor QTextFormat::color() const
  1831. {
  1832.     return col;
  1833. }
  1834.  
  1835. inline QFont QTextFormat::font() const
  1836. {
  1837.     return fn;
  1838. }
  1839.  
  1840. inline bool QTextFormat::isMisspelled() const
  1841. {
  1842.     return missp;
  1843. }
  1844.  
  1845. inline QTextFormat::VerticalAlignment QTextFormat::vAlign() const
  1846. {
  1847.     return ha;
  1848. }
  1849.  
  1850. inline bool QTextFormat::operator==( const QTextFormat &f ) const
  1851. {
  1852.     return k == f.k;
  1853. }
  1854.  
  1855. inline QTextFormatCollection *QTextFormat::parent() const
  1856. {
  1857.     return collection;
  1858. }
  1859.  
  1860. inline void QTextFormat::addRef()
  1861. {
  1862.     ref++;
  1863. #ifdef DEBUG_COLLECTION
  1864.     qDebug( "add ref of '%s' to %d (%p)", k.latin1(), ref, this );
  1865. #endif
  1866. }
  1867.  
  1868. inline void QTextFormat::removeRef()
  1869. {
  1870.     ref--;
  1871.     if ( !collection )
  1872.     return;
  1873.     if ( this == collection->defFormat )
  1874.     return;
  1875. #ifdef DEBUG_COLLECTION
  1876.     qDebug( "remove ref of '%s' to %d (%p)", k.latin1(), ref, this );
  1877. #endif
  1878.     if ( ref == 0 )
  1879.     collection->remove( this );
  1880. }
  1881.  
  1882. inline QString QTextFormat::key() const
  1883. {
  1884.     return k;
  1885. }
  1886.  
  1887. inline QString QTextFormat::anchorHref() const
  1888. {
  1889.     return anchor_href;
  1890. }
  1891.  
  1892. inline QString QTextFormat::anchorName() const
  1893. {
  1894.     return anchor_name;
  1895. }
  1896.  
  1897. inline bool QTextFormat::isAnchor() const
  1898. {
  1899.     return !anchor_href.isEmpty()  || !anchor_name.isEmpty();
  1900. }
  1901.  
  1902. inline bool QTextFormat::useLinkColor() const
  1903. {
  1904.     return linkColor;
  1905. }
  1906.  
  1907. inline void QTextFormat::setStyle( const QString &s )
  1908. {
  1909.     style = s;
  1910.     updateStyleFlags();
  1911. }
  1912.  
  1913. // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1914.  
  1915. inline QTextStringChar &QTextString::at( int i ) const
  1916. {
  1917.     return data[ i ];
  1918. }
  1919.  
  1920. inline QString QTextString::toString() const
  1921. {
  1922.     return toString( data );
  1923. }
  1924.  
  1925. // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1926.  
  1927. inline QTextStringChar *QTextParag::at( int i ) const
  1928. {
  1929.     return &str->at( i );
  1930. }
  1931.  
  1932. inline bool QTextParag::isValid() const
  1933. {
  1934.     return invalid == -1;
  1935. }
  1936.  
  1937. inline bool QTextParag::hasChanged() const
  1938. {
  1939.     return changed;
  1940. }
  1941.  
  1942. inline void QTextParag::setChanged( bool b, bool recursive )
  1943. {
  1944.     changed = b;
  1945.     if ( recursive ) {
  1946.     if ( doc && doc->parentParag() )
  1947.         doc->parentParag()->setChanged( b, recursive );
  1948.     }
  1949. }
  1950.  
  1951. inline void QTextParag::setBackgroundColor( const QColor & c )
  1952. {
  1953.     delete bgcol;
  1954.     bgcol = new QColor( c );
  1955.     setChanged( TRUE );
  1956. }
  1957.  
  1958. inline void QTextParag::clearBackgroundColor()
  1959. {
  1960.     delete bgcol; bgcol = 0; setChanged( TRUE );
  1961. }
  1962.  
  1963. inline void QTextParag::append( const QString &s, bool reallyAtEnd )
  1964. {
  1965.     if ( reallyAtEnd )
  1966.     insert( str->length(), s );
  1967.     else
  1968.     insert( QMAX( str->length() - 1, 0 ), s );
  1969. }
  1970.  
  1971. inline QTextParag *QTextParag::prev() const
  1972. {
  1973.     return p;
  1974. }
  1975.  
  1976. inline QTextParag *QTextParag::next() const
  1977. {
  1978.     return n;
  1979. }
  1980.  
  1981. inline bool QTextParag::hasAnySelection() const
  1982. {
  1983.     return !selections.isEmpty();
  1984. }
  1985.  
  1986. inline void QTextParag::setEndState( int s )
  1987. {
  1988.     if ( s == state )
  1989.     return;
  1990.     state = s;
  1991. }
  1992.  
  1993. inline int QTextParag::endState() const
  1994. {
  1995.     return state;
  1996. }
  1997.  
  1998. inline void QTextParag::setParagId( int i )
  1999. {
  2000.     id = i;
  2001. }
  2002.  
  2003. inline int QTextParag::paragId() const
  2004. {
  2005.     if ( id == -1 )
  2006.     qWarning( "invalid parag id!!!!!!!! (%p)", (void*)this );
  2007.     return id;
  2008. }
  2009.  
  2010. inline bool QTextParag::firstPreProcess() const
  2011. {
  2012.     return firstPProcess;
  2013. }
  2014.  
  2015. inline void QTextParag::setFirstPreProcess( bool b )
  2016. {
  2017.     firstPProcess = b;
  2018. }
  2019.  
  2020. inline QMap<int, QTextParagLineStart*> &QTextParag::lineStartList()
  2021. {
  2022.     return lineStarts;
  2023. }
  2024.  
  2025. inline QTextString *QTextParag::string() const
  2026. {
  2027.     return str;
  2028. }
  2029.  
  2030. inline QTextDocument *QTextParag::document() const
  2031. {
  2032.     return doc;
  2033. }
  2034.  
  2035. inline void QTextParag::setAlignment( int a )
  2036. {
  2037.     if ( a == align )
  2038.     return;
  2039.     align = a;
  2040.     invalidate( 0 );
  2041. }
  2042.  
  2043. inline void QTextParag::setListStyle( QStyleSheetItem::ListStyle ls )
  2044. {
  2045.     listS = ls;
  2046.     invalidate( 0 );
  2047. }
  2048.  
  2049. inline QStyleSheetItem::ListStyle QTextParag::listStyle() const
  2050. {
  2051.     return listS;
  2052. }
  2053.  
  2054. inline QTextFormat *QTextParag::paragFormat() const
  2055. {
  2056.     return defFormat;
  2057. }
  2058.  
  2059. inline void QTextParag::registerFloatingItem( QTextCustomItem *i )
  2060. {
  2061.     floatingItems.append( i );
  2062. }
  2063.  
  2064. inline void QTextParag::unregisterFloatingItem( QTextCustomItem *i )
  2065. {
  2066.     floatingItems.removeRef( i );
  2067. }
  2068.  
  2069. inline void QTextParag::addCustomItem()
  2070. {
  2071.     numCustomItems++;
  2072. }
  2073.  
  2074. inline void QTextParag::removeCustomItem()
  2075. {
  2076.     numCustomItems--;
  2077. }
  2078.  
  2079. inline int QTextParag::customItems() const
  2080. {
  2081.     return numCustomItems;
  2082. }
  2083.  
  2084. inline QBrush *QTextParag::background() const
  2085. {
  2086.     return tc ? tc->backGround() : 0;
  2087. }
  2088.  
  2089.  
  2090. inline void QTextParag::setDocumentRect( const QRect &r )
  2091. {
  2092.     docRect = r;
  2093. }
  2094.  
  2095. inline int QTextParag::documentWidth() const
  2096. {
  2097.     return doc ? doc->width() : docRect.width();
  2098. }
  2099.  
  2100. inline int QTextParag::documentVisibleWidth() const
  2101. {
  2102.     return doc ? doc->visibleWidth() : docRect.width();
  2103. }
  2104.  
  2105. inline int QTextParag::documentX() const
  2106. {
  2107.     return doc ? doc->x() : docRect.x();
  2108. }
  2109.  
  2110. inline int QTextParag::documentY() const
  2111. {
  2112.     return doc ? doc->y() : docRect.y();
  2113. }
  2114.  
  2115. inline void QTextParag::setExtraData( QTextParagData *data )
  2116. {
  2117.     eData = data;
  2118. }
  2119.  
  2120. inline QTextParagData *QTextParag::extraData() const
  2121. {
  2122.     return eData;
  2123. }
  2124.  
  2125. inline void QTextParag::setNewLinesAllowed( bool b )
  2126. {
  2127.     newLinesAllowed = b;
  2128. }
  2129.  
  2130. inline bool QTextParag::isNewLinesAllowed() const
  2131. {
  2132.     return newLinesAllowed;
  2133. }
  2134.  
  2135. // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2136.  
  2137. inline void QTextFormatCollection::setDefaultFormat( QTextFormat *f )
  2138. {
  2139.     defFormat = f;
  2140. }
  2141.  
  2142. inline QTextFormat *QTextFormatCollection::defaultFormat() const
  2143. {
  2144.     return defFormat;
  2145. }
  2146.  
  2147. // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2148.  
  2149. inline QTextFormat *QTextStringChar::format() const
  2150. {
  2151.     return (type == Regular) ? d.format : d.custom->format;
  2152. }
  2153.  
  2154.  
  2155. inline QTextCustomItem *QTextStringChar::customItem() const
  2156. {
  2157.     return isCustom() ? d.custom->custom : 0;
  2158. }
  2159.  
  2160. inline int QTextStringChar::height() const
  2161. {
  2162.     return !isCustom() ? format()->height() : ( customItem()->placement() == QTextCustomItem::PlaceInline ? customItem()->height : 0 );
  2163. }
  2164.  
  2165. inline int QTextStringChar::ascent() const
  2166. {
  2167.     return !isCustom() ? format()->ascent() : ( customItem()->placement() == QTextCustomItem::PlaceInline ? customItem()->ascent() : 0 );
  2168. }
  2169.  
  2170. inline int QTextStringChar::descent() const
  2171. {
  2172.     return !isCustom() ? format()->descent() : 0;
  2173. }
  2174.  
  2175. #endif //QT_NO_RICHTEXT
  2176.  
  2177. #endif
  2178.