/**************************************************************************** ** ** 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 requirements will be met: ** http://trolltech.com/products/qt/licenses/licensing/opensource/. ** If you are unsure which license is appropriate for your use, please ** review the following information: ** http://trolltech.com/products/qt/licenses/licensing/licensingoverview ** or contact the sales department at sales@trolltech.com. ** ** 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 "ntqstring.h" #include "ntqptrlist.h" #include "ntqrect.h" #include "ntqfontmetrics.h" #include "ntqintdict.h" #include "ntqmap.h" #include "ntqstringlist.h" #include "ntqfont.h" #include "ntqcolor.h" #include "ntqsize.h" #include "ntqvaluelist.h" #include "ntqvaluestack.h" #include "ntqobject.h" #include "ntqdict.h" #include "ntqpixmap.h" #include "ntqstylesheet.h" #include "ntqptrvector.h" #include "ntqpainter.h" #include "ntqlayout.h" #include "ntqobject.h" #include "ntqapplication.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; // MOC_SKIP_END #endif class Q_EXPORT TQTextString { public: TQTextString(); TQTextString( const TQTextString &s ); virtual ~TQTextString(); static TQString toString( const TQMemArray &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 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 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; Q_TEMPLATE_EXTERN template class Q_EXPORT TQValueStack; Q_TEMPLATE_EXTERN template class Q_EXPORT TQValueStack; // 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 *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 indices; TQValueStack paras; TQValueStack xOffsets; TQValueStack 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; // 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 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 *¶g, int &idx, int &ox, int &oy, bool atEnd = FALSE ); virtual bool enterAt( TQTextCursor *, TQTextDocument *&doc, TQTextParagraph *¶g, int &idx, int &ox, int &oy, const TQPoint & ); virtual bool next( TQTextCursor *, TQTextDocument *&doc, TQTextParagraph *¶g, int &idx, int &ox, int &oy ); virtual bool prev( TQTextCursor *, TQTextDocument *&doc, TQTextParagraph *¶g, int &idx, int &ox, int &oy ); virtual bool down( TQTextCursor *, TQTextDocument *&doc, TQTextParagraph *¶g, int &idx, int &ox, int &oy ); virtual bool up( TQTextCursor *, TQTextDocument *&doc, TQTextParagraph *¶g, 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; // MOC_SKIP_END #endif #ifndef QT_NO_TEXTCUSTOMITEM class Q_EXPORT TQTextImage : public TQTextCustomItem { public: TQTextImage( TQTextDocument *p, const TQMap &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 attributes; TQString imgId; }; #endif #ifndef QT_NO_TEXTCUSTOMITEM class Q_EXPORT TQTextHorizontalLine : public TQTextCustomItem { public: TQTextHorizontalLine( TQTextDocument *p, const TQMap &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; // 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 leftItems; TQPtrList 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 &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 attributes; int align; }; #endif #if defined(Q_TEMPLATEDLL) // MOC_SKIP_BEGIN Q_TEMPLATE_EXTERN template class Q_EXPORT TQPtrList; Q_TEMPLATE_EXTERN template class Q_EXPORT TQMap; // MOC_SKIP_END #endif #ifndef QT_NO_TEXTCUSTOMITEM class Q_EXPORT TQTextTable: public TQTextCustomItem { friend class TQTextTableCell; public: TQTextTable( TQTextDocument *p, const TQMap &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 *¶g, int &idx, int &ox, int &oy, bool atEnd = FALSE ); virtual bool enterAt( TQTextCursor *c, TQTextDocument *&doc, TQTextParagraph *¶g, int &idx, int &ox, int &oy, const TQPoint &pos ); virtual bool next( TQTextCursor *c, TQTextDocument *&doc, TQTextParagraph *¶g, int &idx, int &ox, int &oy ); virtual bool prev( TQTextCursor *c, TQTextDocument *&doc, TQTextParagraph *¶g, int &idx, int &ox, int &oy ); virtual bool down( TQTextCursor *c, TQTextDocument *&doc, TQTextParagraph *¶g, int &idx, int &ox, int &oy ); virtual bool up( TQTextCursor *c, TQTextDocument *&doc, TQTextParagraph *¶g, int &idx, int &ox, int &oy ); TQString richText() const; int minimumWidth() const; TQPtrList 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 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 attributes; TQMap 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; //Q_TEMPLATE_EXTERN template class Q_EXPORT TQMap; Q_TEMPLATE_EXTERN template class Q_EXPORT TQMap; Q_TEMPLATE_EXTERN template class Q_EXPORT TQPtrList; // MOC_SKIP_END #endif class Q_EXPORT TQTextDocument : public TQObject { TQ_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 attributes() const { return attribs; } void setAttributes( const TQMap &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 ¶gId, int &index ); TQTextCursor selectionStartCursor( int id ); TQTextCursor selectionEndCursor( int id ); void selectionEnd( int id, int ¶gId, 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 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 &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 &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 >& 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 selectionColors; TQMap selections; TQMap 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 attribs; int *tArray; int tStopWidth; int uDepth; TQString oText; TQPtrList childList; TQColor linkColor, bodyText; double scaleFontsFactor; short list_tm,list_bm, list_lm, li_tm, li_bm, par_tm, par_bm; #if defined(TQ_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 &str, const TQByteArray& oldStyle ); TQTextDeleteCommand( TQTextParagraph *p, int idx, const TQMemArray &str ); virtual ~TQTextDeleteCommand(); Commands type() const { return Delete; } TQTextCursor *execute( TQTextCursor *c ); TQTextCursor *unexecute( TQTextCursor *c ); protected: int id, index; TQTextParagraph *parag; TQMemArray text; TQByteArray styleInformation; }; class Q_EXPORT TQTextInsertCommand : public TQTextDeleteCommand { public: TQTextInsertCommand( TQTextDocument *d, int i, int idx, const TQMemArray &str, const TQByteArray& oldStyleInfo ) : TQTextDeleteCommand( d, i, idx, str, oldStyleInfo ) {} TQTextInsertCommand( TQTextParagraph *p, int idx, const TQMemArray &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 &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 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; Q_TEMPLATE_EXTERN template class Q_EXPORT TQMap; // 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 &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 &selections() const; #ifndef QT_NO_TEXTCUSTOMITEM TQPtrList &floatingItems() const; #endif TQBrush backgroundBrush( const TQColorGroup&cg ) { if ( bgcol ) return *bgcol; return cg.brush( TQColorGroup::Base ); } void invalidateStyleCache(); TQMap 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 *mSelections; #ifndef QT_NO_TEXTCUSTOMITEM TQPtrList *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 &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 &oldLineStarts ); }; // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ class Q_EXPORT TQTextFormatterBreakWords : public TQTextFormatter { public: TQTextFormatterBreakWords(); virtual ~TQTextFormatterBreakWords() {} int format( TQTextDocument *doc, TQTextParagraph *parag, int start, const TQMap &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& 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; // 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 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 &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