2095 lines
57 KiB
C++
2095 lines
57 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 1992-2007 Trolltech ASA. All rights reserved.
|
|
**
|
|
** This file is part of the Qt3Support module of the Qt Toolkit.
|
|
**
|
|
** This file may be used under the terms of the GNU General Public
|
|
** License version 2.0 as published by the Free Software Foundation
|
|
** and appearing in the file LICENSE.GPL included in the packaging of
|
|
** this file. 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.
|
|
**
|
|
** In addition, as a special exception, Trolltech gives you certain
|
|
** additional rights. These rights are described in the Trolltech GPL
|
|
** Exception version 1.0, which can be found at
|
|
** http://www.trolltech.com/products/qt/gplexception/ and in the file
|
|
** GPL_EXCEPTION.txt in this package.
|
|
**
|
|
** In addition, as a special exception, Trolltech, as the sole copyright
|
|
** holder for Qt Designer, grants users of the Qt/Eclipse Integration
|
|
** plug-in the right for the Qt/Eclipse Integration to link to
|
|
** functionality provided by Qt Designer and its related libraries.
|
|
**
|
|
** Trolltech reserves all rights not expressly granted herein.
|
|
**
|
|
** Trolltech ASA (c) 2007
|
|
**
|
|
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
|
|
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
|
**
|
|
****************************************************************************/
|
|
|
|
#ifndef Q3RICHTEXT_P_H
|
|
#define Q3RICHTEXT_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.
|
|
//
|
|
|
|
#include "QtGui/qapplication.h"
|
|
#include "QtGui/qcolor.h"
|
|
#include "QtCore/qhash.h"
|
|
#include "QtGui/qfont.h"
|
|
#include "QtGui/qfontmetrics.h"
|
|
#include "QtGui/qlayout.h"
|
|
#include "QtCore/qmap.h"
|
|
#include "QtCore/qvector.h"
|
|
#include "QtCore/qstack.h"
|
|
#include "QtCore/qlist.h"
|
|
#include "QtCore/qobject.h"
|
|
#include "QtGui/qpainter.h"
|
|
#include "QtGui/qpixmap.h"
|
|
#include "QtCore/qrect.h"
|
|
#include "QtCore/qsize.h"
|
|
#include "QtCore/qstring.h"
|
|
#include "QtCore/qstringlist.h"
|
|
#include "Qt3Support/q3stylesheet.h"
|
|
#include "Qt3Support/q3mimefactory.h"
|
|
|
|
#ifndef QT_NO_RICHTEXT
|
|
|
|
class Q3TextDocument;
|
|
class Q3TextString;
|
|
class Q3TextPreProcessor;
|
|
class Q3TextFormat;
|
|
class Q3TextCursor;
|
|
class Q3TextParagraph;
|
|
class Q3TextFormatter;
|
|
class Q3TextIndent;
|
|
class Q3TextFormatCollection;
|
|
class Q3StyleSheetItem;
|
|
#ifndef QT_NO_TEXTCUSTOMITEM
|
|
class Q3TextCustomItem;
|
|
#endif
|
|
class Q3TextFlow;
|
|
struct QBidiContext;
|
|
|
|
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
class Q_COMPAT_EXPORT Q3TextStringChar
|
|
{
|
|
friend class Q3TextString;
|
|
|
|
public:
|
|
// this is never called, initialize variables in Q3TextString::insert()!!!
|
|
Q3TextStringChar() : nobreak(false), lineStart(0), type(Regular) {p.format=0;}
|
|
~Q3TextStringChar();
|
|
|
|
struct CustomData
|
|
{
|
|
Q3TextFormat *format;
|
|
#ifndef QT_NO_TEXTCUSTOMITEM
|
|
Q3TextCustomItem *custom;
|
|
#endif
|
|
QString anchorName;
|
|
QString anchorHref;
|
|
};
|
|
enum Type { Regular=0, Custom=1, Anchor=2, CustomAnchor=3 };
|
|
|
|
QChar 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 nobreak :1;
|
|
|
|
uchar lineStart : 1;
|
|
uchar /*Type*/ type : 2;
|
|
uchar bidiLevel :7;
|
|
uchar rightToLeft : 1;
|
|
|
|
int x;
|
|
union {
|
|
Q3TextFormat* format;
|
|
CustomData* custom;
|
|
} p;
|
|
|
|
|
|
int height() const;
|
|
int ascent() const;
|
|
int descent() const;
|
|
bool isCustom() const { return (type & Custom) != 0; }
|
|
Q3TextFormat *format() const;
|
|
#ifndef QT_NO_TEXTCUSTOMITEM
|
|
Q3TextCustomItem *customItem() const;
|
|
#endif
|
|
void setFormat(Q3TextFormat *f);
|
|
#ifndef QT_NO_TEXTCUSTOMITEM
|
|
void setCustomItem(Q3TextCustomItem *i);
|
|
#endif
|
|
|
|
#ifndef QT_NO_TEXTCUSTOMITEM
|
|
void loseCustomItem();
|
|
#endif
|
|
|
|
|
|
bool isAnchor() const { return (type & Anchor) != 0; }
|
|
bool isLink() const { return isAnchor() && p.custom->anchorHref.count(); }
|
|
QString anchorName() const;
|
|
QString anchorHref() const;
|
|
void setAnchor(const QString& name, const QString& href);
|
|
|
|
Q3TextStringChar(const Q3TextStringChar &) {
|
|
Q_ASSERT(false);
|
|
}
|
|
private:
|
|
Q3TextStringChar &operator=(const Q3TextStringChar &) {
|
|
//abort();
|
|
return *this;
|
|
}
|
|
friend class Q3TextParagraph;
|
|
};
|
|
|
|
Q_DECLARE_TYPEINFO(Q3TextStringChar, Q_PRIMITIVE_TYPE);
|
|
|
|
class Q_COMPAT_EXPORT Q3TextString
|
|
{
|
|
public:
|
|
|
|
Q3TextString();
|
|
Q3TextString(const Q3TextString &s);
|
|
virtual ~Q3TextString();
|
|
|
|
static QString toString(const QVector<Q3TextStringChar> &data);
|
|
QString toString() const;
|
|
|
|
inline Q3TextStringChar &at(int i) const {
|
|
return const_cast<Q3TextString *>(this)->data[i];
|
|
}
|
|
inline int length() const { return data.size(); }
|
|
|
|
int width(int idx) const;
|
|
|
|
void insert(int index, const QString &s, Q3TextFormat *f);
|
|
void insert(int index, const QChar *unicode, int len, Q3TextFormat *f);
|
|
void insert(int index, Q3TextStringChar *c, bool doAddRefFormat = false);
|
|
void truncate(int index);
|
|
void remove(int index, int len);
|
|
void clear();
|
|
|
|
void setFormat(int index, Q3TextFormat *f, bool useCollection);
|
|
|
|
void setBidi(bool b) { bidi = b; }
|
|
bool isBidi() const;
|
|
bool isRightToLeft() const;
|
|
QChar::Direction direction() const;
|
|
void setDirection(QChar::Direction dr) { rightToLeft = (dr == QChar::DirR); bidiDirty = true; }
|
|
|
|
QVector<Q3TextStringChar> rawData() const { return data; }
|
|
|
|
void operator=(const QString &s) { clear(); insert(0, s, 0); }
|
|
void operator+=(const QString &s) { insert(length(), s, 0); }
|
|
void prepend(const QString &s) { insert(0, s, 0); }
|
|
int appendParagraphs( Q3TextParagraph *start, Q3TextParagraph *end );
|
|
|
|
// return next and previous valid cursor positions.
|
|
bool validCursorPosition(int idx);
|
|
int nextCursorPosition(int idx);
|
|
int previousCursorPosition(int idx);
|
|
|
|
private:
|
|
void checkBidi() const;
|
|
|
|
QVector<Q3TextStringChar> data;
|
|
QString stringCache;
|
|
uint bidiDirty : 1;
|
|
uint bidi : 1; // true when the paragraph has right to left characters
|
|
uint rightToLeft : 1;
|
|
};
|
|
|
|
inline bool Q3TextString::isBidi() const
|
|
{
|
|
if (bidiDirty)
|
|
checkBidi();
|
|
return bidi;
|
|
}
|
|
|
|
inline bool Q3TextString::isRightToLeft() const
|
|
{
|
|
if (bidiDirty)
|
|
checkBidi();
|
|
return rightToLeft;
|
|
}
|
|
|
|
inline QString Q3TextString::toString() const
|
|
{
|
|
if (bidiDirty)
|
|
checkBidi();
|
|
return stringCache;
|
|
}
|
|
|
|
inline QChar::Direction Q3TextString::direction() const
|
|
{
|
|
return rightToLeft ? QChar::DirR : QChar::DirL;
|
|
}
|
|
|
|
inline int Q3TextString::nextCursorPosition(int next)
|
|
{
|
|
if (bidiDirty)
|
|
checkBidi();
|
|
|
|
const Q3TextStringChar *c = data.data();
|
|
int len = length();
|
|
|
|
if (next < len - 1) {
|
|
next++;
|
|
while (next < len - 1 && !c[next].charStop)
|
|
next++;
|
|
}
|
|
return next;
|
|
}
|
|
|
|
inline int Q3TextString::previousCursorPosition(int prev)
|
|
{
|
|
if (bidiDirty)
|
|
checkBidi();
|
|
|
|
const Q3TextStringChar *c = data.data();
|
|
|
|
if (prev) {
|
|
prev--;
|
|
while (prev && !c[prev].charStop)
|
|
prev--;
|
|
}
|
|
return prev;
|
|
}
|
|
|
|
inline bool Q3TextString::validCursorPosition(int idx)
|
|
{
|
|
if (bidiDirty)
|
|
checkBidi();
|
|
|
|
return (at(idx).charStop);
|
|
}
|
|
|
|
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
class Q_COMPAT_EXPORT Q3TextCursor
|
|
{
|
|
public:
|
|
Q3TextCursor(Q3TextDocument * = 0);
|
|
Q3TextCursor(const Q3TextCursor &c);
|
|
Q3TextCursor &operator=(const Q3TextCursor &c);
|
|
virtual ~Q3TextCursor();
|
|
|
|
bool operator==(const Q3TextCursor &c) const;
|
|
bool operator!=(const Q3TextCursor &c) const { return !(*this == c); }
|
|
|
|
inline Q3TextParagraph *paragraph() const { return para; }
|
|
|
|
Q3TextDocument *document() const;
|
|
int index() const;
|
|
|
|
void gotoPosition(Q3TextParagraph* p, int index = 0);
|
|
void setIndex(int index) { gotoPosition(paragraph(), index); }
|
|
void setParagraph(Q3TextParagraph*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 QString &s, bool checkNewLine, QVector<Q3TextStringChar> *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;
|
|
|
|
Q3TextParagraph *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 QPoint &pos, Q3TextParagraph *s) { return place(pos, s, false); }
|
|
bool place(const QPoint &pos, Q3TextParagraph *s, bool link);
|
|
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 QPoint &globalPos);
|
|
|
|
Q3TextParagraph *para;
|
|
int idx, tmpX;
|
|
int ox, oy;
|
|
QStack<int> indices;
|
|
QStack<Q3TextParagraph*> paras;
|
|
QStack<int> xOffsets;
|
|
QStack<int> yOffsets;
|
|
uint valid : 1;
|
|
|
|
};
|
|
|
|
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
class Q_COMPAT_EXPORT Q3TextCommand
|
|
{
|
|
public:
|
|
enum Commands { Invalid, Insert, Delete, Format, Style };
|
|
|
|
Q3TextCommand(Q3TextDocument *dc) : doc(dc), cursor(dc) {}
|
|
virtual ~Q3TextCommand();
|
|
|
|
virtual Commands type() const;
|
|
|
|
virtual Q3TextCursor *execute(Q3TextCursor *c) = 0;
|
|
virtual Q3TextCursor *unexecute(Q3TextCursor *c) = 0;
|
|
|
|
protected:
|
|
Q3TextDocument *doc;
|
|
Q3TextCursor cursor;
|
|
|
|
};
|
|
|
|
class Q_COMPAT_EXPORT Q3TextCommandHistory
|
|
{
|
|
public:
|
|
Q3TextCommandHistory(int s) : current(-1), steps(s) { }
|
|
virtual ~Q3TextCommandHistory(); // ### why is it virtual?
|
|
|
|
void clear();
|
|
|
|
void addCommand(Q3TextCommand *cmd);
|
|
Q3TextCursor *undo(Q3TextCursor *c);
|
|
Q3TextCursor *redo(Q3TextCursor *c);
|
|
|
|
bool isUndoAvailable();
|
|
bool isRedoAvailable();
|
|
|
|
void setUndoDepth(int depth) { steps = depth; }
|
|
int undoDepth() const { return steps; }
|
|
|
|
int historySize() const { return history.count(); }
|
|
int currentPosition() const { return current; }
|
|
|
|
private:
|
|
QList<Q3TextCommand *> history;
|
|
int current, steps;
|
|
};
|
|
|
|
inline Q3TextCommandHistory::~Q3TextCommandHistory()
|
|
{
|
|
clear();
|
|
}
|
|
|
|
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
#ifndef QT_NO_TEXTCUSTOMITEM
|
|
class Q_COMPAT_EXPORT Q3TextCustomItem
|
|
{
|
|
public:
|
|
Q3TextCustomItem(Q3TextDocument *p)
|
|
: xpos(0), ypos(-1), width(-1), height(0), parent(p)
|
|
{}
|
|
virtual ~Q3TextCustomItem();
|
|
virtual void draw(QPainter* p, int x, int y, int cx, int cy, int cw, int ch,
|
|
const QPalette &pal, 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(Q3TextCursor *, Q3TextDocument *&doc, Q3TextParagraph *¶g, int &idx, int &ox, int &oy, bool atEnd = false);
|
|
virtual bool enterAt(Q3TextCursor *, Q3TextDocument *&doc, Q3TextParagraph *¶g, int &idx, int &ox, int &oy, const QPoint &);
|
|
virtual bool next(Q3TextCursor *, Q3TextDocument *&doc, Q3TextParagraph *¶g, int &idx, int &ox, int &oy);
|
|
virtual bool prev(Q3TextCursor *, Q3TextDocument *&doc, Q3TextParagraph *¶g, int &idx, int &ox, int &oy);
|
|
virtual bool down(Q3TextCursor *, Q3TextDocument *&doc, Q3TextParagraph *¶g, int &idx, int &ox, int &oy);
|
|
virtual bool up(Q3TextCursor *, Q3TextDocument *&doc, Q3TextParagraph *¶g, int &idx, int &ox, int &oy);
|
|
|
|
void setParagraph(Q3TextParagraph *p) { parag = p; }
|
|
Q3TextParagraph *paragraph() const { return parag; }
|
|
|
|
Q3TextDocument *parent;
|
|
Q3TextParagraph *parag;
|
|
|
|
virtual void pageBreak(int y, Q3TextFlow* flow);
|
|
};
|
|
#endif
|
|
|
|
|
|
#ifndef QT_NO_TEXTCUSTOMITEM
|
|
class Q_COMPAT_EXPORT Q3TextImage : public Q3TextCustomItem
|
|
{
|
|
public:
|
|
Q3TextImage(Q3TextDocument *p, const QMap<QString, QString> &attr, const QString& context,
|
|
Q3MimeSourceFactory &factory);
|
|
virtual ~Q3TextImage();
|
|
|
|
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 QPalette &pal, bool selected);
|
|
|
|
private:
|
|
QRegion* reg;
|
|
QPixmap pm;
|
|
Placement place;
|
|
int tmpwidth, tmpheight;
|
|
QMap<QString, QString> attributes;
|
|
QString imgId;
|
|
|
|
};
|
|
#endif
|
|
|
|
#ifndef QT_NO_TEXTCUSTOMITEM
|
|
class Q_COMPAT_EXPORT Q3TextHorizontalLine : public Q3TextCustomItem
|
|
{
|
|
public:
|
|
Q3TextHorizontalLine(Q3TextDocument *p, const QMap<QString, QString> &attr, const QString& context,
|
|
Q3MimeSourceFactory &factory);
|
|
virtual ~Q3TextHorizontalLine();
|
|
|
|
void adjustToPainter(QPainter*);
|
|
void draw(QPainter* p, int x, int y, int cx, int cy, int cw, int ch,
|
|
const QPalette &pal, bool selected);
|
|
QString richText() const;
|
|
|
|
bool ownLine() const { return true; }
|
|
|
|
private:
|
|
int tmpheight;
|
|
QColor color;
|
|
bool shade;
|
|
|
|
};
|
|
#endif
|
|
|
|
class Q_COMPAT_EXPORT Q3TextFlow
|
|
{
|
|
friend class Q3TextDocument;
|
|
#ifndef QT_NO_TEXTCUSTOMITEM
|
|
friend class Q3TextTableCell;
|
|
#endif
|
|
|
|
public:
|
|
Q3TextFlow();
|
|
virtual ~Q3TextFlow();
|
|
|
|
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(Q3TextCustomItem* item);
|
|
virtual void unregisterFloatingItem(Q3TextCustomItem* item);
|
|
#endif
|
|
virtual QRect boundingRect() const;
|
|
virtual void drawFloatingItems(QPainter* p, int cx, int cy, int cw, int ch,
|
|
const QPalette &pal, 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
|
|
QList<Q3TextCustomItem *> leftItems;
|
|
QList<Q3TextCustomItem *> rightItems;
|
|
#endif
|
|
};
|
|
|
|
inline int Q3TextFlow::width() const { return w; }
|
|
|
|
#ifndef QT_NO_TEXTCUSTOMITEM
|
|
class Q3TextTable;
|
|
|
|
class Q_COMPAT_EXPORT Q3TextTableCell : public QLayoutItem
|
|
{
|
|
friend class Q3TextTable;
|
|
|
|
public:
|
|
Q3TextTableCell(Q3TextTable* table,
|
|
int row, int column,
|
|
const QMap<QString, QString> &attr,
|
|
const Q3StyleSheetItem* style,
|
|
const Q3TextFormat& fmt, const QString& context,
|
|
Q3MimeSourceFactory &factory, Q3StyleSheet *sheet, const QString& doc);
|
|
virtual ~Q3TextTableCell();
|
|
|
|
QSize sizeHint() const ;
|
|
QSize minimumSize() const ;
|
|
QSize maximumSize() const ;
|
|
Qt::Orientations expandingDirections() 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_; }
|
|
|
|
Q3TextDocument* richText() const { return richtext; }
|
|
Q3TextTable* table() const { return parent; }
|
|
|
|
void draw(QPainter* p, int x, int y, int cx, int cy, int cw, int ch,
|
|
const QPalette &cg, bool selected);
|
|
|
|
QBrush *backGround() const { return background; }
|
|
virtual void invalidate();
|
|
|
|
int verticalAlignmentOffset() const;
|
|
int horizontalAlignmentOffset() const;
|
|
|
|
private:
|
|
QRect geom;
|
|
Q3TextTable* parent;
|
|
Q3TextDocument* 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;
|
|
};
|
|
#endif
|
|
|
|
|
|
#ifndef QT_NO_TEXTCUSTOMITEM
|
|
class Q_COMPAT_EXPORT Q3TextTable: public Q3TextCustomItem
|
|
{
|
|
friend class Q3TextTableCell;
|
|
|
|
public:
|
|
Q3TextTable(Q3TextDocument *p, const QMap<QString, QString> &attr);
|
|
virtual ~Q3TextTable();
|
|
|
|
void adjustToPainter(QPainter *p);
|
|
void pageBreak(int y, Q3TextFlow* flow);
|
|
void draw(QPainter* p, int x, int y, int cx, int cy, int cw, int ch,
|
|
const QPalette &pal, 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(Q3TextCursor *c, Q3TextDocument *&doc, Q3TextParagraph *¶g, int &idx, int &ox, int &oy, bool atEnd = false);
|
|
virtual bool enterAt(Q3TextCursor *c, Q3TextDocument *&doc, Q3TextParagraph *¶g, int &idx, int &ox, int &oy, const QPoint &pos);
|
|
virtual bool next(Q3TextCursor *c, Q3TextDocument *&doc, Q3TextParagraph *¶g, int &idx, int &ox, int &oy);
|
|
virtual bool prev(Q3TextCursor *c, Q3TextDocument *&doc, Q3TextParagraph *¶g, int &idx, int &ox, int &oy);
|
|
virtual bool down(Q3TextCursor *c, Q3TextDocument *&doc, Q3TextParagraph *¶g, int &idx, int &ox, int &oy);
|
|
virtual bool up(Q3TextCursor *c, Q3TextDocument *&doc, Q3TextParagraph *¶g, int &idx, int &ox, int &oy);
|
|
|
|
QString richText() const;
|
|
|
|
int minimumWidth() const;
|
|
|
|
QList<Q3TextTableCell *> tableCells() const { return cells; }
|
|
|
|
bool isStretching() const { return stretch; }
|
|
|
|
private:
|
|
void format(int w);
|
|
void addCell(Q3TextTableCell* cell);
|
|
|
|
private:
|
|
QGridLayout* layout;
|
|
QList<Q3TextTableCell *> 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;
|
|
QMap<QString, QString> attributes;
|
|
QMap<Q3TextCursor*, int> currCell;
|
|
Placement place;
|
|
void adjustCells(int y , int shift);
|
|
int pageBreakFor;
|
|
};
|
|
#endif
|
|
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
#ifndef QT_NO_TEXTCUSTOMITEM
|
|
class Q3TextTableCell;
|
|
class Q3TextParagraph;
|
|
#endif
|
|
|
|
struct Q_COMPAT_EXPORT Q3TextDocumentSelection
|
|
{
|
|
Q3TextCursor startCursor, endCursor;
|
|
bool swapped;
|
|
Q_DUMMY_COMPARISON_OPERATOR(Q3TextDocumentSelection)
|
|
};
|
|
|
|
class Q_COMPAT_EXPORT Q3TextDocument : public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
#ifndef QT_NO_TEXTCUSTOMITEM
|
|
friend class Q3TextTableCell;
|
|
#endif
|
|
friend class Q3TextCursor;
|
|
friend class Q3TextEdit;
|
|
friend class Q3TextParagraph;
|
|
|
|
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()
|
|
};
|
|
|
|
Q3TextDocument(Q3TextDocument *p);
|
|
virtual ~Q3TextDocument();
|
|
|
|
Q3TextDocument *parent() const { return par; }
|
|
Q3TextParagraph *parentParagraph() const { return parentPar; }
|
|
|
|
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, Q3TextParagraph *parag = 0);
|
|
|
|
void setY(int y);
|
|
int leftMargin() const;
|
|
void setLeftMargin(int lm);
|
|
int rightMargin() const;
|
|
void setRightMargin(int rm);
|
|
|
|
Q3TextParagraph *firstParagraph() const;
|
|
Q3TextParagraph *lastParagraph() const;
|
|
void setFirstParagraph(Q3TextParagraph *p);
|
|
void setLastParagraph(Q3TextParagraph *p);
|
|
|
|
void invalidate();
|
|
|
|
void setPreProcessor(Q3TextPreProcessor *sh);
|
|
Q3TextPreProcessor *preProcessor() const;
|
|
|
|
void setFormatter(Q3TextFormatter *f);
|
|
Q3TextFormatter *formatter() const;
|
|
|
|
void setIndent(Q3TextIndent *i);
|
|
Q3TextIndent *indent() const;
|
|
|
|
QColor selectionColor(int id) const;
|
|
QColor selectionTextColor(int id) const;
|
|
bool hasSelectionTextColor(int id) const;
|
|
void setSelectionColor(int id, const QColor &c);
|
|
void setSelectionTextColor(int id, const QColor &b);
|
|
bool hasSelection(int id, bool visible = false) const;
|
|
void setSelectionStart(int id, const Q3TextCursor &cursor);
|
|
bool setSelectionEnd(int id, const Q3TextCursor &cursor);
|
|
void selectAll(int id);
|
|
bool removeSelection(int id);
|
|
void selectionStart(int id, int ¶gId, int &index);
|
|
Q3TextCursor selectionStartCursor(int id);
|
|
Q3TextCursor selectionEndCursor(int id);
|
|
void selectionEnd(int id, int ¶gId, int &index);
|
|
void setFormat(int id, Q3TextFormat *f, int flags);
|
|
int numSelections() const { return nSelections; }
|
|
void addSelection(int id);
|
|
|
|
QString selectedText(int id, bool asRichText = false) const;
|
|
void removeSelectedText(int id, Q3TextCursor *cursor);
|
|
void indentSelection(int id);
|
|
|
|
Q3TextParagraph *paragAt(int i) const;
|
|
|
|
void addCommand(Q3TextCommand *cmd);
|
|
Q3TextCursor *undo(Q3TextCursor *c = 0);
|
|
Q3TextCursor *redo(Q3TextCursor *c = 0);
|
|
Q3TextCommandHistory *commands() const { return commandHistory; }
|
|
|
|
Q3TextFormatCollection *formatCollection() const;
|
|
|
|
bool find(Q3TextCursor &cursor, const QString &expr, bool cs, bool wo, bool forward);
|
|
|
|
void setTextFormat(Qt::TextFormat f);
|
|
Qt::TextFormat textFormat() const;
|
|
|
|
bool inSelection(int selId, const QPoint &pos) const;
|
|
|
|
Q3StyleSheet *styleSheet() const { return sheet_; }
|
|
#ifndef QT_NO_MIME
|
|
Q3MimeSourceFactory *mimeSourceFactory() const { return factory_; }
|
|
#endif
|
|
QString context() const { return contxt; }
|
|
|
|
void setStyleSheet(Q3StyleSheet *s);
|
|
void setDefaultFormat(const QFont &font, const QColor &color);
|
|
#ifndef QT_NO_MIME
|
|
void setMimeSourceFactory(Q3MimeSourceFactory *f) { if (f) factory_ = f; }
|
|
#endif
|
|
void setContext(const QString &c) { if (!c.isEmpty()) contxt = c; }
|
|
|
|
void setUnderlineLinks(bool 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 QPalette &pal, const QBrush *paper = 0);
|
|
|
|
void drawParagraph(QPainter *p, Q3TextParagraph *parag, int cx, int cy, int cw, int ch,
|
|
QPixmap *&doubleBuffer, const QPalette &pal,
|
|
bool drawCursor, Q3TextCursor *cursor, bool resetChanged = true);
|
|
Q3TextParagraph *draw(QPainter *p, int cx, int cy, int cw, int ch, const QPalette &pal,
|
|
bool onlyChanged = false, bool drawCursor = false, Q3TextCursor *cursor = 0,
|
|
bool resetChanged = true);
|
|
|
|
#ifndef QT_NO_TEXTCUSTOMITEM
|
|
static Q3TextCustomItem* tag(Q3StyleSheet *sheet, const QString& name,
|
|
const QMap<QString, QString> &attr,
|
|
const QString& context,
|
|
const Q3MimeSourceFactory& factory,
|
|
bool emptyTag, Q3TextDocument *doc);
|
|
#endif
|
|
|
|
#ifndef QT_NO_TEXTCUSTOMITEM
|
|
void registerCustomItem(Q3TextCustomItem *i, Q3TextParagraph *p);
|
|
void unregisterCustomItem(Q3TextCustomItem *i, Q3TextParagraph *p);
|
|
#endif
|
|
|
|
void setFlow(Q3TextFlow *f);
|
|
void takeFlow();
|
|
Q3TextFlow *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
|
|
Q3TextTableCell *tableCell() const { return tc; }
|
|
void setTableCell(Q3TextTableCell *c) { tc = c; }
|
|
#endif
|
|
|
|
void setPlainText(const QString &text);
|
|
void setRichText(const QString &text, const QString &context, const Q3TextFormat *initialFormat = 0);
|
|
QString richText() const;
|
|
QString 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 depth) { commandHistory->setUndoDepth(depth); }
|
|
int undoDepth() const { return commandHistory->undoDepth(); }
|
|
|
|
int length() const;
|
|
void clear(bool createEmptyParag = false);
|
|
|
|
virtual Q3TextParagraph *createParagraph(Q3TextDocument *, Q3TextParagraph *pr = 0, Q3TextParagraph *nx = 0, bool updateIds = true);
|
|
void insertChild(Q3TextDocument *dc) { childList.append(dc); }
|
|
void removeChild(Q3TextDocument *dc) { childList.removeAll(dc); }
|
|
QList<Q3TextDocument *> children() const { return childList; }
|
|
|
|
bool hasFocusParagraph() const;
|
|
QString focusHref() const;
|
|
QString focusName() const;
|
|
|
|
void invalidateOriginalText() { oTextValid = false; oText = QLatin1String(""); }
|
|
|
|
Q_SIGNALS:
|
|
void minimumWidthChanged(int);
|
|
|
|
private:
|
|
Q_DISABLE_COPY(Q3TextDocument)
|
|
|
|
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);
|
|
#ifndef QT_NO_TEXTCUSTOMITEM
|
|
Q3TextCustomItem* parseTable(const QMap<QString, QString> &attr, const Q3TextFormat &fmt,
|
|
const QChar* doc, int length, int& pos, Q3TextParagraph *curpar);
|
|
#endif
|
|
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, Q3StyleSheetItem::WhiteSpaceMode wsm);
|
|
void setRichTextInternal(const QString &text, Q3TextCursor* cursor = 0, const Q3TextFormat *initialFormat = 0);
|
|
void setRichTextMarginsInternal(QList< QVector<Q3StyleSheetItem *> *>& styles, Q3TextParagraph* stylesPar);
|
|
|
|
struct Q_COMPAT_EXPORT Focus {
|
|
Q3TextParagraph *parag;
|
|
int start, len;
|
|
QString href;
|
|
QString name;
|
|
};
|
|
|
|
int cx, cy, cw, vw;
|
|
Q3TextParagraph *fParag, *lParag;
|
|
Q3TextPreProcessor *pProcessor;
|
|
struct SelectionColor {
|
|
QColor background;
|
|
QColor text;
|
|
};
|
|
QMap<int, SelectionColor> selectionColors;
|
|
QMap<int, Q3TextDocumentSelection> selections;
|
|
Q3TextCommandHistory *commandHistory;
|
|
Q3TextFormatter *pFormatter;
|
|
Q3TextIndent *indenter;
|
|
Q3TextFormatCollection *fCollection;
|
|
Qt::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;
|
|
Q3TextFlow *flow_;
|
|
Q3TextDocument *par;
|
|
Q3TextParagraph *parentPar;
|
|
#ifndef QT_NO_TEXTCUSTOMITEM
|
|
Q3TextTableCell *tc;
|
|
#endif
|
|
QBrush *backBrush;
|
|
QPixmap *buf_pixmap;
|
|
Focus focusIndicator;
|
|
int minw;
|
|
int wused;
|
|
int leftmargin;
|
|
int rightmargin;
|
|
Q3TextParagraph *minwParag, *curParag;
|
|
Q3StyleSheet* sheet_;
|
|
#ifndef QT_NO_MIME
|
|
Q3MimeSourceFactory* factory_;
|
|
#endif
|
|
QString contxt;
|
|
QMap<QString, QString> attribs;
|
|
int *tArray;
|
|
int tStopWidth;
|
|
int uDepth;
|
|
QString oText;
|
|
QList<Q3TextDocument *> childList;
|
|
QColor linkColor, bodyText;
|
|
double scaleFontsFactor;
|
|
|
|
short list_tm,list_bm, list_lm, li_tm, li_bm, par_tm, par_bm;
|
|
};
|
|
|
|
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
class Q_COMPAT_EXPORT Q3TextDeleteCommand : public Q3TextCommand
|
|
{
|
|
public:
|
|
Q3TextDeleteCommand(Q3TextDocument *dc, int i, int idx, const QVector<Q3TextStringChar> &str,
|
|
const QByteArray& oldStyle);
|
|
Q3TextDeleteCommand(Q3TextParagraph *p, int idx, const QVector<Q3TextStringChar> &str);
|
|
virtual ~Q3TextDeleteCommand();
|
|
|
|
Commands type() const { return Delete; }
|
|
Q3TextCursor *execute(Q3TextCursor *c);
|
|
Q3TextCursor *unexecute(Q3TextCursor *c);
|
|
|
|
protected:
|
|
int id, index;
|
|
Q3TextParagraph *parag;
|
|
QVector<Q3TextStringChar> text;
|
|
QByteArray styleInformation;
|
|
|
|
};
|
|
|
|
class Q_COMPAT_EXPORT Q3TextInsertCommand : public Q3TextDeleteCommand
|
|
{
|
|
public:
|
|
Q3TextInsertCommand(Q3TextDocument *dc, int i, int idx, const QVector<Q3TextStringChar> &str,
|
|
const QByteArray& oldStyleInfo)
|
|
: Q3TextDeleteCommand(dc, i, idx, str, oldStyleInfo) {}
|
|
Q3TextInsertCommand(Q3TextParagraph *p, int idx, const QVector<Q3TextStringChar> &str)
|
|
: Q3TextDeleteCommand(p, idx, str) {}
|
|
virtual ~Q3TextInsertCommand() {}
|
|
|
|
Commands type() const { return Insert; }
|
|
Q3TextCursor *execute(Q3TextCursor *c) { return Q3TextDeleteCommand::unexecute(c); }
|
|
Q3TextCursor *unexecute(Q3TextCursor *c) { return Q3TextDeleteCommand::execute(c); }
|
|
|
|
};
|
|
|
|
class Q_COMPAT_EXPORT Q3TextFormatCommand : public Q3TextCommand
|
|
{
|
|
public:
|
|
Q3TextFormatCommand(Q3TextDocument *dc, int sid, int sidx, int eid, int eidx, const QVector<Q3TextStringChar> &old, Q3TextFormat *f, int fl);
|
|
virtual ~Q3TextFormatCommand();
|
|
|
|
Commands type() const { return Format; }
|
|
Q3TextCursor *execute(Q3TextCursor *c);
|
|
Q3TextCursor *unexecute(Q3TextCursor *c);
|
|
|
|
protected:
|
|
int startId, startIndex, endId, endIndex;
|
|
Q3TextFormat *format;
|
|
QVector<Q3TextStringChar> oldFormats;
|
|
int flags;
|
|
|
|
};
|
|
|
|
class Q_COMPAT_EXPORT Q3TextStyleCommand : public Q3TextCommand
|
|
{
|
|
public:
|
|
Q3TextStyleCommand(Q3TextDocument *dc, int fParag, int lParag, const QByteArray& beforeChange );
|
|
virtual ~Q3TextStyleCommand() {}
|
|
|
|
Commands type() const { return Style; }
|
|
Q3TextCursor *execute(Q3TextCursor *c);
|
|
Q3TextCursor *unexecute(Q3TextCursor *c);
|
|
|
|
static QByteArray readStyleInformation( Q3TextDocument* dc, int fParag, int lParag);
|
|
static void writeStyleInformation( Q3TextDocument* dc, int fParag, const QByteArray& style);
|
|
|
|
private:
|
|
int firstParag, lastParag;
|
|
QByteArray before;
|
|
QByteArray after;
|
|
};
|
|
|
|
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
struct Q_COMPAT_EXPORT Q3TextParagraphSelection
|
|
{
|
|
int start, end;
|
|
Q_DUMMY_COMPARISON_OPERATOR(Q3TextParagraphSelection)
|
|
};
|
|
|
|
struct Q_COMPAT_EXPORT QTextLineStart
|
|
{
|
|
QTextLineStart() : y(0), baseLine(0), h(0)
|
|
{ }
|
|
QTextLineStart(int y_, int bl, int h_) : y(y_), baseLine(bl), h(h_),
|
|
w(0)
|
|
{ }
|
|
|
|
public:
|
|
int y, baseLine, h;
|
|
int w;
|
|
};
|
|
|
|
class Q_COMPAT_EXPORT Q3TextParagraphData
|
|
{
|
|
public:
|
|
Q3TextParagraphData() {}
|
|
virtual ~Q3TextParagraphData();
|
|
virtual void join(Q3TextParagraphData *);
|
|
};
|
|
|
|
class Q3TextParagraphPseudoDocument;
|
|
|
|
class Q3SyntaxHighlighter;
|
|
|
|
class Q_COMPAT_EXPORT Q3TextParagraph
|
|
{
|
|
friend class Q3TextDocument;
|
|
friend class Q3TextCursor;
|
|
friend class Q3SyntaxHighlighter;
|
|
|
|
public:
|
|
Q3TextParagraph(Q3TextDocument *dc, Q3TextParagraph *pr = 0, Q3TextParagraph *nx = 0, bool updateIds = true);
|
|
~Q3TextParagraph();
|
|
|
|
Q3TextString *string() const;
|
|
Q3TextStringChar *at(int i) const; // maybe remove later
|
|
int leftGap() const;
|
|
int length() const; // maybe remove later
|
|
|
|
void setListStyle(Q3StyleSheetItem::ListStyle ls) { lstyle = ls; changed = true; }
|
|
Q3StyleSheetItem::ListStyle listStyle() const { return (Q3StyleSheetItem::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(Q3TextFormat *fm);
|
|
// Q3TextFormat *paragFormat() const;
|
|
|
|
inline Q3TextDocument *document() const {
|
|
if (hasdoc) return (Q3TextDocument*) docOrPseudo;
|
|
return 0;
|
|
}
|
|
Q3TextParagraphPseudoDocument *pseudoDocument() const;
|
|
|
|
QRect rect() const;
|
|
void setHeight(int h) { r.setHeight(h); }
|
|
void show();
|
|
void hide();
|
|
bool isVisible() const { return visible; }
|
|
|
|
Q3TextParagraph *prev() const;
|
|
Q3TextParagraph *next() const;
|
|
void setPrev(Q3TextParagraph *s);
|
|
void setNext(Q3TextParagraph *s);
|
|
|
|
void insert(int index, const QString &s);
|
|
void insert(int index, const QChar *unicode, int len);
|
|
void append(const QString &s, bool reallyAtEnd = false);
|
|
void truncate(int index);
|
|
void remove(int index, int len);
|
|
void join(Q3TextParagraph *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;
|
|
Q3TextStringChar *lineStartOfChar(int i, int *index = 0, int *line = 0) const;
|
|
int lines() const;
|
|
Q3TextStringChar *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(Q3TextParagraphData *data);
|
|
Q3TextParagraphData *extraData() const;
|
|
|
|
QMap<int, QTextLineStart*> &lineStartList();
|
|
|
|
void setFormat(int index, int len, Q3TextFormat *f, bool useCollection = true, int flags = -1);
|
|
|
|
void setAlignment(int a);
|
|
int alignment() const;
|
|
|
|
void paint(QPainter &painter, const QPalette &pal, Q3TextCursor *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(Q3TextCustomItem *i);
|
|
void unregisterFloatingItem(Q3TextCustomItem *i);
|
|
#endif
|
|
|
|
void setFullWidth(bool b) { fullWidth = b; }
|
|
bool isFullWidth() const { return fullWidth; }
|
|
|
|
#ifndef QT_NO_TEXTCUSTOMITEM
|
|
Q3TextTableCell *tableCell() const;
|
|
#endif
|
|
|
|
QBrush *background() const;
|
|
|
|
int documentWidth() const;
|
|
int documentVisibleWidth() const;
|
|
int documentX() const;
|
|
int documentY() const;
|
|
Q3TextFormatCollection *formatCollection() const;
|
|
Q3TextFormatter *formatter() const;
|
|
|
|
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(Q3TextCommand *cmd);
|
|
Q3TextCursor *undo(Q3TextCursor *c = 0);
|
|
Q3TextCursor *redo(Q3TextCursor *c = 0);
|
|
Q3TextCommandHistory *commands() const;
|
|
void copyParagData(Q3TextParagraph *parag);
|
|
|
|
void setBreakable(bool b) { breakable = b; }
|
|
bool isBreakable() const { return breakable; }
|
|
|
|
void setBackgroundColor(const QColor &c);
|
|
QColor *backgroundColor() const { return bgcol; }
|
|
void clearBackgroundColor();
|
|
|
|
void setMovedDown(bool b) { movedDown = b; }
|
|
bool wasMovedDown() const { return movedDown; }
|
|
|
|
void setDirection(QChar::Direction);
|
|
QChar::Direction direction() const;
|
|
void setPaintDevice(QPaintDevice *pd) { paintdevice = pd; }
|
|
|
|
void readStyleInformation(QDataStream& stream);
|
|
void writeStyleInformation(QDataStream& stream) const;
|
|
|
|
protected:
|
|
void setColorForSelection(QColor &c, QPainter &p, const QPalette &pal, int selection);
|
|
void drawLabel(QPainter* p, int x, int y, int w, int h, int base, const QPalette &pal);
|
|
void drawString(QPainter &painter, const QString &str, int start, int len, int xstart,
|
|
int y, int baseLine, int w, int h, bool drawSelections, int fullSelectionWidth,
|
|
Q3TextStringChar *formatChar, const QPalette &pal,
|
|
bool rightToLeft);
|
|
|
|
private:
|
|
QMap<int, Q3TextParagraphSelection> &selections() const;
|
|
#ifndef QT_NO_TEXTCUSTOMITEM
|
|
QList<Q3TextCustomItem *> &floatingItems() const;
|
|
#endif
|
|
inline QBrush backgroundBrush(const QPalette &pal) {
|
|
if (bgcol)
|
|
return *bgcol;
|
|
return pal.brush(QPalette::Base);
|
|
}
|
|
void invalidateStyleCache();
|
|
|
|
QMap<int, QTextLineStart*> lineStarts;
|
|
QRect r;
|
|
Q3TextParagraph *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
|
|
signed int align : 5;
|
|
uint /*Q3StyleSheetItem::ListStyle*/ lstyle : 4;
|
|
int invalid;
|
|
int state, id;
|
|
Q3TextString *str;
|
|
QMap<int, Q3TextParagraphSelection> *mSelections;
|
|
#ifndef QT_NO_TEXTCUSTOMITEM
|
|
QList<Q3TextCustomItem *> *mFloatingItems;
|
|
#endif
|
|
short utm, ubm, ulm, urm, uflm, ulinespacing;
|
|
short tabStopWidth, minwidth;
|
|
int *tArray;
|
|
Q3TextParagraphData *eData;
|
|
short list_val;
|
|
ushort ldepth;
|
|
QColor *bgcol;
|
|
QPaintDevice *paintdevice;
|
|
};
|
|
|
|
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
class Q_COMPAT_EXPORT Q3TextFormatter
|
|
{
|
|
public:
|
|
Q3TextFormatter();
|
|
virtual ~Q3TextFormatter();
|
|
|
|
virtual int format(Q3TextDocument *doc, Q3TextParagraph *parag, int start, const QMap<int, QTextLineStart*> &oldLineStarts) = 0;
|
|
virtual int formatVertically(Q3TextDocument* doc, Q3TextParagraph* parag);
|
|
|
|
bool isWrapEnabled(Q3TextParagraph *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 QTextLineStart *formatLine(Q3TextParagraph *parag, Q3TextString *string, QTextLineStart *line, Q3TextStringChar *start,
|
|
Q3TextStringChar *last, int align = Qt::AlignAuto, int space = 0);
|
|
#ifndef QT_NO_COMPLEXTEXT
|
|
virtual QTextLineStart *bidiReorderLine(Q3TextParagraph *parag, Q3TextString *string, QTextLineStart *line, Q3TextStringChar *start,
|
|
Q3TextStringChar *last, int align, int space);
|
|
#endif
|
|
void insertLineStart(Q3TextParagraph *parag, int index, QTextLineStart *ls);
|
|
|
|
int thisminw;
|
|
int thiswused;
|
|
|
|
private:
|
|
bool wrapEnabled;
|
|
int wrapColumn;
|
|
bool biw;
|
|
};
|
|
|
|
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
class Q_COMPAT_EXPORT Q3TextFormatterBreakInWords : public Q3TextFormatter
|
|
{
|
|
public:
|
|
Q3TextFormatterBreakInWords();
|
|
virtual ~Q3TextFormatterBreakInWords() {}
|
|
|
|
int format(Q3TextDocument *doc, Q3TextParagraph *parag, int start, const QMap<int, QTextLineStart*> &oldLineStarts);
|
|
|
|
};
|
|
|
|
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
class Q_COMPAT_EXPORT Q3TextFormatterBreakWords : public Q3TextFormatter
|
|
{
|
|
public:
|
|
Q3TextFormatterBreakWords();
|
|
virtual ~Q3TextFormatterBreakWords() {}
|
|
|
|
int format(Q3TextDocument *doc, Q3TextParagraph *parag, int start, const QMap<int, QTextLineStart*> &oldLineStarts);
|
|
|
|
};
|
|
|
|
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
class Q_COMPAT_EXPORT Q3TextIndent
|
|
{
|
|
public:
|
|
Q3TextIndent();
|
|
virtual ~Q3TextIndent() {}
|
|
|
|
virtual void indent(Q3TextDocument *doc, Q3TextParagraph *parag, int *oldIndent = 0, int *newIndent = 0) = 0;
|
|
|
|
};
|
|
|
|
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
class Q_COMPAT_EXPORT Q3TextPreProcessor
|
|
{
|
|
public:
|
|
enum Ids {
|
|
Standard = 0
|
|
};
|
|
|
|
Q3TextPreProcessor();
|
|
virtual ~Q3TextPreProcessor() {}
|
|
|
|
virtual void process(Q3TextDocument *doc, Q3TextParagraph *, int, bool = true) = 0;
|
|
virtual Q3TextFormat *format(int id) = 0;
|
|
|
|
};
|
|
|
|
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
class Q_COMPAT_EXPORT Q3TextFormat
|
|
{
|
|
friend class Q3TextFormatCollection;
|
|
friend class Q3TextDocument;
|
|
|
|
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 };
|
|
|
|
Q3TextFormat();
|
|
virtual ~Q3TextFormat();
|
|
|
|
Q3TextFormat(const Q3StyleSheetItem *s);
|
|
Q3TextFormat(const QFont &f, const QColor &c, Q3TextFormatCollection *parent = 0);
|
|
Q3TextFormat(const Q3TextFormat &fm);
|
|
Q3TextFormat makeTextFormat(const Q3StyleSheetItem *style, const QMap<QString,QString>& attr, double scaleFontsFactor) const;
|
|
Q3TextFormat& operator=(const Q3TextFormat &fm);
|
|
QColor color() const;
|
|
QFont font() const;
|
|
QFontMetrics fontMetrics() const { return fm; }
|
|
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 setStrikeOut(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 Q3TextFormat &f) const;
|
|
Q3TextFormatCollection *parent() const;
|
|
const QString &key() const;
|
|
|
|
static QString getKey(const QFont &f, const QColor &c, bool misspelled, VerticalAlignment vAlign);
|
|
|
|
void addRef();
|
|
void removeRef();
|
|
|
|
QString makeFormatChangeTags(Q3TextFormat* defaultFormat, Q3TextFormat *f, const QString& oldAnchorHref, const QString& anchorHref) const;
|
|
QString makeFormatEndTags(Q3TextFormat* defaultFormat, const QString& anchorHref) const;
|
|
|
|
static void setPainter(QPainter *p);
|
|
static QPainter* painter();
|
|
|
|
bool fontSizesInPixels() { return usePixelSizes; }
|
|
|
|
protected:
|
|
virtual void generateKey();
|
|
|
|
private:
|
|
void update();
|
|
static void applyFont(const QFont &f);
|
|
|
|
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;
|
|
Q3TextFormatCollection *collection;
|
|
int ref;
|
|
QString k;
|
|
int logicalFontSize;
|
|
int stdSize;
|
|
static QPainter *pntr;
|
|
static QFontMetrics *pntr_fm;
|
|
static int pntr_asc;
|
|
static int pntr_hei;
|
|
static int pntr_ldg;
|
|
static int pntr_dsc;
|
|
|
|
};
|
|
|
|
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
class Q_COMPAT_EXPORT Q3TextFormatCollection
|
|
{
|
|
friend class Q3TextDocument;
|
|
friend class Q3TextFormat;
|
|
|
|
public:
|
|
Q3TextFormatCollection();
|
|
virtual ~Q3TextFormatCollection();
|
|
|
|
void setDefaultFormat(Q3TextFormat *f);
|
|
Q3TextFormat *defaultFormat() const;
|
|
virtual Q3TextFormat *format(Q3TextFormat *f);
|
|
virtual Q3TextFormat *format(Q3TextFormat *of, Q3TextFormat *nf, int flags);
|
|
virtual Q3TextFormat *format(const QFont &f, const QColor &c);
|
|
virtual void remove(Q3TextFormat *f);
|
|
virtual Q3TextFormat *createFormat(const Q3TextFormat &f) { return new Q3TextFormat(f); }
|
|
virtual Q3TextFormat *createFormat(const QFont &f, const QColor &c) { return new Q3TextFormat(f, c, this); }
|
|
|
|
void updateDefaultFormat(const QFont &font, const QColor &c, Q3StyleSheet *sheet);
|
|
|
|
QPaintDevice *paintDevice() const { return paintdevice; }
|
|
void setPaintDevice(QPaintDevice *);
|
|
|
|
private:
|
|
void updateKeys();
|
|
|
|
private:
|
|
Q3TextFormat *defFormat, *lastFormat, *cachedFormat;
|
|
QHash<QString, Q3TextFormat *> cKey;
|
|
Q3TextFormat *cres;
|
|
QFont cfont;
|
|
QColor ccol;
|
|
QString kof, knf;
|
|
int cflags;
|
|
|
|
QPaintDevice *paintdevice;
|
|
};
|
|
|
|
class Q_COMPAT_EXPORT Q3TextParagraphPseudoDocument
|
|
{
|
|
public:
|
|
Q3TextParagraphPseudoDocument();
|
|
~Q3TextParagraphPseudoDocument();
|
|
QRect docRect;
|
|
Q3TextFormatter *pFormatter;
|
|
Q3TextCommandHistory *commandHistory;
|
|
int minw;
|
|
int wused;
|
|
Q3TextFormatCollection collection;
|
|
};
|
|
|
|
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
inline int Q3TextParagraph::length() const
|
|
{
|
|
return str->length();
|
|
}
|
|
|
|
inline QRect Q3TextParagraph::rect() const
|
|
{
|
|
return r;
|
|
}
|
|
|
|
inline int Q3TextCursor::index() const
|
|
{
|
|
return idx;
|
|
}
|
|
|
|
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
inline int Q3TextDocument::x() const
|
|
{
|
|
return cx;
|
|
}
|
|
|
|
inline int Q3TextDocument::y() const
|
|
{
|
|
return cy;
|
|
}
|
|
|
|
inline int Q3TextDocument::width() const
|
|
{
|
|
return qMax(cw, flow_->width());
|
|
}
|
|
|
|
inline int Q3TextDocument::visibleWidth() const
|
|
{
|
|
return vw;
|
|
}
|
|
|
|
inline Q3TextParagraph *Q3TextDocument::firstParagraph() const
|
|
{
|
|
return fParag;
|
|
}
|
|
|
|
inline Q3TextParagraph *Q3TextDocument::lastParagraph() const
|
|
{
|
|
return lParag;
|
|
}
|
|
|
|
inline void Q3TextDocument::setFirstParagraph(Q3TextParagraph *p)
|
|
{
|
|
fParag = p;
|
|
}
|
|
|
|
inline void Q3TextDocument::setLastParagraph(Q3TextParagraph *p)
|
|
{
|
|
lParag = p;
|
|
}
|
|
|
|
inline void Q3TextDocument::setWidth(int w)
|
|
{
|
|
cw = qMax(w, minw);
|
|
flow_->setWidth(cw);
|
|
vw = w;
|
|
}
|
|
|
|
inline int Q3TextDocument::minimumWidth() const
|
|
{
|
|
return minw;
|
|
}
|
|
|
|
inline void Q3TextDocument::setY(int y)
|
|
{
|
|
cy = y;
|
|
}
|
|
|
|
inline int Q3TextDocument::leftMargin() const
|
|
{
|
|
return leftmargin;
|
|
}
|
|
|
|
inline void Q3TextDocument::setLeftMargin(int lm)
|
|
{
|
|
leftmargin = lm;
|
|
}
|
|
|
|
inline int Q3TextDocument::rightMargin() const
|
|
{
|
|
return rightmargin;
|
|
}
|
|
|
|
inline void Q3TextDocument::setRightMargin(int rm)
|
|
{
|
|
rightmargin = rm;
|
|
}
|
|
|
|
inline Q3TextPreProcessor *Q3TextDocument::preProcessor() const
|
|
{
|
|
return pProcessor;
|
|
}
|
|
|
|
inline void Q3TextDocument::setPreProcessor(Q3TextPreProcessor * sh)
|
|
{
|
|
pProcessor = sh;
|
|
}
|
|
|
|
inline void Q3TextDocument::setFormatter(Q3TextFormatter *f)
|
|
{
|
|
delete pFormatter;
|
|
pFormatter = f;
|
|
}
|
|
|
|
inline Q3TextFormatter *Q3TextDocument::formatter() const
|
|
{
|
|
return pFormatter;
|
|
}
|
|
|
|
inline void Q3TextDocument::setIndent(Q3TextIndent *i)
|
|
{
|
|
indenter = i;
|
|
}
|
|
|
|
inline Q3TextIndent *Q3TextDocument::indent() const
|
|
{
|
|
return indenter;
|
|
}
|
|
|
|
inline QColor Q3TextDocument::selectionColor(int id) const
|
|
{
|
|
const Q3TextDocument *p = this;
|
|
while (p->par)
|
|
p = p->par;
|
|
return p->selectionColors[id].background;
|
|
}
|
|
|
|
inline QColor Q3TextDocument::selectionTextColor(int id) const
|
|
{
|
|
const Q3TextDocument *p = this;
|
|
while (p->par)
|
|
p = p->par;
|
|
return p->selectionColors[id].text;
|
|
}
|
|
|
|
inline bool Q3TextDocument::hasSelectionTextColor(int id) const
|
|
{
|
|
const Q3TextDocument *p = this;
|
|
while (p->par)
|
|
p = p->par;
|
|
return p->selectionColors.contains(id);
|
|
}
|
|
|
|
inline void Q3TextDocument::setSelectionColor(int id, const QColor &c)
|
|
{
|
|
Q3TextDocument *p = this;
|
|
while (p->par)
|
|
p = p->par;
|
|
p->selectionColors[id].background = c;
|
|
}
|
|
|
|
inline void Q3TextDocument::setSelectionTextColor(int id, const QColor &c)
|
|
{
|
|
Q3TextDocument *p = this;
|
|
while (p->par)
|
|
p = p->par;
|
|
p->selectionColors[id].text = c;
|
|
}
|
|
|
|
inline Q3TextFormatCollection *Q3TextDocument::formatCollection() const
|
|
{
|
|
return fCollection;
|
|
}
|
|
|
|
inline int Q3TextDocument::alignment() const
|
|
{
|
|
return align;
|
|
}
|
|
|
|
inline void Q3TextDocument::setAlignment(int a)
|
|
{
|
|
align = a;
|
|
}
|
|
|
|
inline int *Q3TextDocument::tabArray() const
|
|
{
|
|
return tArray;
|
|
}
|
|
|
|
inline int Q3TextDocument::tabStopWidth() const
|
|
{
|
|
return tStopWidth;
|
|
}
|
|
|
|
inline void Q3TextDocument::setTabArray(int *a)
|
|
{
|
|
tArray = a;
|
|
}
|
|
|
|
inline void Q3TextDocument::setTabStops(int tw)
|
|
{
|
|
tStopWidth = tw;
|
|
}
|
|
|
|
inline QString Q3TextDocument::originalText() const
|
|
{
|
|
if (oTextValid)
|
|
return oText;
|
|
return text();
|
|
}
|
|
|
|
inline void Q3TextDocument::setFlow(Q3TextFlow *f)
|
|
{
|
|
if (flow_)
|
|
delete flow_;
|
|
flow_ = f;
|
|
}
|
|
|
|
inline void Q3TextDocument::takeFlow()
|
|
{
|
|
flow_ = 0;
|
|
}
|
|
|
|
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
inline QColor Q3TextFormat::color() const
|
|
{
|
|
return col;
|
|
}
|
|
|
|
inline QFont Q3TextFormat::font() const
|
|
{
|
|
return fn;
|
|
}
|
|
|
|
inline bool Q3TextFormat::isMisspelled() const
|
|
{
|
|
return missp;
|
|
}
|
|
|
|
inline Q3TextFormat::VerticalAlignment Q3TextFormat::vAlign() const
|
|
{
|
|
return ha;
|
|
}
|
|
|
|
inline bool Q3TextFormat::operator==(const Q3TextFormat &f) const
|
|
{
|
|
return k == f.k;
|
|
}
|
|
|
|
inline Q3TextFormatCollection *Q3TextFormat::parent() const
|
|
{
|
|
return collection;
|
|
}
|
|
|
|
inline void Q3TextFormat::addRef()
|
|
{
|
|
ref++;
|
|
}
|
|
|
|
inline void Q3TextFormat::removeRef()
|
|
{
|
|
ref--;
|
|
if (!collection)
|
|
return;
|
|
if (this == collection->defFormat)
|
|
return;
|
|
if (ref == 0)
|
|
collection->remove(this);
|
|
}
|
|
|
|
inline const QString &Q3TextFormat::key() const
|
|
{
|
|
return k;
|
|
}
|
|
|
|
inline bool Q3TextFormat::useLinkColor() const
|
|
{
|
|
return linkColor;
|
|
}
|
|
|
|
inline Q3TextStringChar *Q3TextParagraph::at(int i) const
|
|
{
|
|
return &str->at(i);
|
|
}
|
|
|
|
inline bool Q3TextParagraph::isValid() const
|
|
{
|
|
return invalid == -1;
|
|
}
|
|
|
|
inline bool Q3TextParagraph::hasChanged() const
|
|
{
|
|
return changed;
|
|
}
|
|
|
|
inline void Q3TextParagraph::setBackgroundColor(const QColor & c)
|
|
{
|
|
delete bgcol;
|
|
bgcol = new QColor(c);
|
|
setChanged(true);
|
|
}
|
|
|
|
inline void Q3TextParagraph::clearBackgroundColor()
|
|
{
|
|
delete bgcol; bgcol = 0; setChanged(true);
|
|
}
|
|
|
|
inline void Q3TextParagraph::append(const QString &s, bool reallyAtEnd)
|
|
{
|
|
if (reallyAtEnd) {
|
|
insert(str->length(), s);
|
|
} else {
|
|
int str_end = str->length() - 1;
|
|
insert(str_end > 0 ? str_end : 0, s);
|
|
}
|
|
}
|
|
|
|
inline Q3TextParagraph *Q3TextParagraph::prev() const
|
|
{
|
|
return p;
|
|
}
|
|
|
|
inline Q3TextParagraph *Q3TextParagraph::next() const
|
|
{
|
|
return n;
|
|
}
|
|
|
|
inline bool Q3TextParagraph::hasAnySelection() const
|
|
{
|
|
return mSelections ? !selections().isEmpty() : false;
|
|
}
|
|
|
|
inline void Q3TextParagraph::setEndState(int s)
|
|
{
|
|
if (s == state)
|
|
return;
|
|
state = s;
|
|
}
|
|
|
|
inline int Q3TextParagraph::endState() const
|
|
{
|
|
return state;
|
|
}
|
|
|
|
inline void Q3TextParagraph::setParagId(int i)
|
|
{
|
|
id = i;
|
|
}
|
|
|
|
inline int Q3TextParagraph::paragId() const
|
|
{
|
|
if (id == -1)
|
|
qWarning("invalid parag id!!!!!!!! (%p)", (void*)this);
|
|
return id;
|
|
}
|
|
|
|
inline bool Q3TextParagraph::firstPreProcess() const
|
|
{
|
|
return firstPProcess;
|
|
}
|
|
|
|
inline void Q3TextParagraph::setFirstPreProcess(bool b)
|
|
{
|
|
firstPProcess = b;
|
|
}
|
|
|
|
inline QMap<int, QTextLineStart*> &Q3TextParagraph::lineStartList()
|
|
{
|
|
return lineStarts;
|
|
}
|
|
|
|
inline Q3TextString *Q3TextParagraph::string() const
|
|
{
|
|
return str;
|
|
}
|
|
|
|
inline Q3TextParagraphPseudoDocument *Q3TextParagraph::pseudoDocument() const
|
|
{
|
|
if (hasdoc)
|
|
return 0;
|
|
return (Q3TextParagraphPseudoDocument*) docOrPseudo;
|
|
}
|
|
|
|
|
|
#ifndef QT_NO_TEXTCUSTOMITEM
|
|
inline Q3TextTableCell *Q3TextParagraph::tableCell() const
|
|
{
|
|
return hasdoc ? document()->tableCell () : 0;
|
|
}
|
|
#endif
|
|
|
|
inline Q3TextCommandHistory *Q3TextParagraph::commands() const
|
|
{
|
|
return hasdoc ? document()->commands() : pseudoDocument()->commandHistory;
|
|
}
|
|
|
|
|
|
inline int Q3TextParagraph::alignment() const
|
|
{
|
|
return align;
|
|
}
|
|
|
|
#ifndef QT_NO_TEXTCUSTOMITEM
|
|
inline void Q3TextParagraph::registerFloatingItem(Q3TextCustomItem *i)
|
|
{
|
|
floatingItems().append(i);
|
|
}
|
|
|
|
inline void Q3TextParagraph::unregisterFloatingItem(Q3TextCustomItem *i)
|
|
{
|
|
floatingItems().removeAll(i);
|
|
}
|
|
#endif
|
|
|
|
inline QBrush *Q3TextParagraph::background() const
|
|
{
|
|
#ifndef QT_NO_TEXTCUSTOMITEM
|
|
return tableCell() ? tableCell()->backGround() : 0;
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
inline int Q3TextParagraph::documentWidth() const
|
|
{
|
|
return hasdoc ? document()->width() : pseudoDocument()->docRect.width();
|
|
}
|
|
|
|
inline int Q3TextParagraph::documentVisibleWidth() const
|
|
{
|
|
return hasdoc ? document()->visibleWidth() : pseudoDocument()->docRect.width();
|
|
}
|
|
|
|
inline int Q3TextParagraph::documentX() const
|
|
{
|
|
return hasdoc ? document()->x() : pseudoDocument()->docRect.x();
|
|
}
|
|
|
|
inline int Q3TextParagraph::documentY() const
|
|
{
|
|
return hasdoc ? document()->y() : pseudoDocument()->docRect.y();
|
|
}
|
|
|
|
inline void Q3TextParagraph::setExtraData(Q3TextParagraphData *data)
|
|
{
|
|
eData = data;
|
|
}
|
|
|
|
inline Q3TextParagraphData *Q3TextParagraph::extraData() const
|
|
{
|
|
return eData;
|
|
}
|
|
|
|
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
inline void Q3TextFormatCollection::setDefaultFormat(Q3TextFormat *f)
|
|
{
|
|
defFormat = f;
|
|
}
|
|
|
|
inline Q3TextFormat *Q3TextFormatCollection::defaultFormat() const
|
|
{
|
|
return defFormat;
|
|
}
|
|
|
|
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
inline Q3TextFormat *Q3TextStringChar::format() const
|
|
{
|
|
return (type == Regular) ? p.format : p.custom->format;
|
|
}
|
|
|
|
|
|
#ifndef QT_NO_TEXTCUSTOMITEM
|
|
inline Q3TextCustomItem *Q3TextStringChar::customItem() const
|
|
{
|
|
return isCustom() ? p.custom->custom : 0;
|
|
}
|
|
#endif
|
|
|
|
inline int Q3TextStringChar::height() const
|
|
{
|
|
#ifndef QT_NO_TEXTCUSTOMITEM
|
|
return !isCustom() ? format()->height() : (customItem()->placement() == Q3TextCustomItem::PlaceInline ? customItem()->height : 0);
|
|
#else
|
|
return format()->height();
|
|
#endif
|
|
}
|
|
|
|
inline int Q3TextStringChar::ascent() const
|
|
{
|
|
#ifndef QT_NO_TEXTCUSTOMITEM
|
|
return !isCustom() ? format()->ascent() : (customItem()->placement() == Q3TextCustomItem::PlaceInline ? customItem()->ascent() : 0);
|
|
#else
|
|
return format()->ascent();
|
|
#endif
|
|
}
|
|
|
|
inline int Q3TextStringChar::descent() const
|
|
{
|
|
#ifndef QT_NO_TEXTCUSTOMITEM
|
|
return !isCustom() ? format()->descent() : 0;
|
|
#else
|
|
return format()->descent();
|
|
#endif
|
|
}
|
|
|
|
#endif // QT_NO_RICHTEXT
|
|
|
|
#endif // Q3RICHTEXT_P_H
|