/****************************************************************************

**

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt3Support module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#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"

QT_BEGIN_NAMESPACE

#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) { dir = dr; 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;

    uint dir : 5;

};

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 *&parag, int &idx, int &ox, int &oy, bool atEnd = false);

    virtual bool enterAt(Q3TextCursor *, Q3TextDocument *&doc, Q3TextParagraph *&parag, int &idx, int &ox, int &oy, const QPoint &);

    virtual bool next(Q3TextCursor *, Q3TextDocument *&doc, Q3TextParagraph *&parag, int &idx, int &ox, int &oy);

    virtual bool prev(Q3TextCursor *, Q3TextDocument *&doc, Q3TextParagraph *&parag, int &idx, int &ox, int &oy);

    virtual bool down(Q3TextCursor *, Q3TextDocument *&doc, Q3TextParagraph *&parag, int &idx, int &ox, int &oy);

    virtual bool up(Q3TextCursor *, Q3TextDocument *&doc, Q3TextParagraph *&parag, 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*);