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