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

**

** 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$

**

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

#include "q3richtext_p.h"

#ifndef QT_NO_RICHTEXT

#include "qbitmap.h"

#include "qapplication.h"

#include "q3cleanuphandler.h"

#include "qcursor.h"

#include "qdatastream.h"

#include "q3dragobject.h"

#include "qdrawutil.h"

#include "qfile.h"

#include "qfileinfo.h"

#include "qfont.h"

#include "qimage.h"

#include "qmap.h"

#include "qmime.h"

#include "q3paintdevicemetrics.h"

#include "qpainter.h"

#include "qstringlist.h"

#include "qstyle.h"

#include "qstyleoption.h"

#include "q3stylesheet.h"

#include "qtextstream.h"

#include <private/qtextengine_p.h>

#include <private/qunicodetables_p.h>

#include <stdlib.h>

#if defined(Q_WS_X11)

#include "qx11info_x11.h"

#endif

QT_BEGIN_NAMESPACE

static Q3TextCursor* richTextExportStart = 0;

static Q3TextCursor* richTextExportEnd = 0;

class Q3TextFormatCollection;

const int border_tolerance = 2;

#ifdef Q_WS_WIN

QT_BEGIN_INCLUDE_NAMESPACE

#include "qt_windows.h"

QT_END_INCLUDE_NAMESPACE

#endif

static inline bool is_printer(QPainter *p)

{

    if (!p || !p->device())

        return false;

    return p->device()->devType() == QInternal::Printer;

}

static inline int scale(int value, QPainter *painter)

{

    if (is_printer(painter)) {

        Q3PaintDeviceMetrics metrics(painter->device());

#if defined(Q_WS_X11)

        value = value * metrics.logicalDpiY() /

                QX11Info::appDpiY(painter->device()->x11Screen());

#elif defined (Q_WS_WIN)

        HDC hdc = GetDC(0);

        int gdc = GetDeviceCaps(hdc, LOGPIXELSY);

        if (gdc)

            value = value * metrics.logicalDpiY() / gdc;

        ReleaseDC(0, hdc);

#elif defined (Q_WS_MAC)

        value = value * metrics.logicalDpiY() / 75; // ##### FIXME

#elif defined (Q_WS_QWS)

        value = value * metrics.logicalDpiY() / 75;

#endif

    }

    return value;

}

static inline bool isBreakable(Q3TextString *string, int pos)

{

    if (string->at(pos).nobreak)

        return false;

    return (pos < string->length()-1 && string->at(pos+1).softBreak);

}

// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

void Q3TextCommandHistory::addCommand(Q3TextCommand *cmd)

{

    if (current < history.count() - 1) {

        QList<Q3TextCommand *> commands;

        for (int i = 0; i <= current; ++i)

            commands.insert(i, history.takeFirst());

        commands.append(cmd);

        while (!history.isEmpty())

            delete history.takeFirst();

        history = commands;

    } else {

        history.append(cmd);

    }

    if (history.count() > steps)

        delete history.takeFirst();

    else

        ++current;

}

Q3TextCursor *Q3TextCommandHistory::undo(Q3TextCursor *c)

{

    if (current > -1) {

        Q3TextCursor *c2 = history.at(current)->unexecute(c);

        --current;

        return c2;

    }

    return 0;

}

Q3TextCursor *Q3TextCommandHistory::redo(Q3TextCursor *c)

{

    if (current > -1) {

        if (current < history.count() - 1) {

            ++current;

            return history.at(current)->execute(c);

        }

    } else {

        if (history.count() > 0) {

            ++current;

            return history.at(current)->execute(c);

        }

    }

    return 0;

}

bool Q3TextCommandHistory::isUndoAvailable()

{

    return current > -1;

}

bool Q3TextCommandHistory::isRedoAvailable()

{

   return (current > -1 && current < history.count() - 1) || (current == -1 && history.count() > 0);

}

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Q3TextDeleteCommand::Q3TextDeleteCommand(Q3TextDocument *dc, int i, int idx, const QVector<Q3TextStringChar> &str,

                                        const QByteArray& oldStyleInfo)

    : Q3TextCommand(dc), id(i), index(idx), parag(0), text(str), styleInformation(oldStyleInfo)

{

    for (int j = 0; j < (int)text.size(); ++j) {

        if (text[j].format())

            text[j].format()->addRef();

    }

}

Q3TextDeleteCommand::Q3TextDeleteCommand(Q3TextParagraph *p, int idx, const QVector<Q3TextStringChar> &str)

    : Q3TextCommand(0), id(-1), index(idx), parag(p), text(str)

{

    for (int i = 0; i < (int)text.size(); ++i) {

        if (text[i].format())

            text[i].format()->addRef();

    }

}

Q3TextDeleteCommand::~Q3TextDeleteCommand()

{

    for (int i = 0; i < (int)text.size(); ++i) {

        if (text[i].format())

            text[i].format()->removeRef();

    }

    text.resize(0);

}

Q3TextCursor *Q3TextDeleteCommand::execute(Q3TextCursor *c)

{

    Q3TextParagraph *s = doc ? doc->paragAt(id) : parag;

    if (!s) {

        qWarning("can't locate parag at %d, last parag: %d", id, doc->lastParagraph()->paragId());

        return 0;

    }

    cursor.setParagraph(s);

    cursor.setIndex(index);

    int len = text.size();

    if (c)

        *c = cursor;

    if (doc) {

        doc->setSelectionStart(Q3TextDocument::Temp, cursor);

        for (int i = 0; i < len; ++i)

            cursor.gotoNextLetter();

        doc->setSelectionEnd(Q3TextDocument::Temp, cursor);

        doc->removeSelectedText(Q3TextDocument::Temp, &cursor);

        if (c)

            *c = cursor;

    } else {

        s->remove(index, len);

    }

    return c;

}

Q3TextCursor *Q3TextDeleteCommand::unexecute(Q3TextCursor *c)

{

    Q3TextParagraph *s = doc ? doc->paragAt(id) : parag;

    if (!s) {

        qWarning("can't locate parag at %d, last parag: %d", id, doc->lastParagraph()->paragId());

        return 0;

    }

    cursor.setParagraph(s);

    cursor.setIndex(index);

    QString str = Q3TextString::toString(text);

    cursor.insert(str, true, &text);

    if (c)

        *c = cursor;

    cursor.setParagraph(s);

    cursor.setIndex(index);

#ifndef QT_NO_DATASTREAM

    if (!styleInformation.isEmpty()) {

        QDataStream styleStream(&styleInformation, IO_ReadOnly);

        int num;

        styleStream >> num;

        Q3TextParagraph *p = s;

        while (num-- && p) {

            p->readStyleInformation(styleStream);

            p = p->next();

        }

    }

#endif

    s = cursor.paragraph();

    while (s) {

        s->format();

        s->setChanged(true);

        if (s == c->paragraph())

            break;

        s = s->next();

    }

    return &cursor;

}

Q3TextFormatCommand::Q3TextFormatCommand(Q3TextDocument *dc, int sid, int sidx, int eid, int eidx,

                                        const QVector<Q3TextStringChar> &old, Q3TextFormat *f, int fl)

    : Q3TextCommand(dc), startId(sid), startIndex(sidx), endId(eid), endIndex(eidx), format(f), oldFormats(old), flags(fl)

{

    format = dc->formatCollection()->format(f);

    for (int j = 0; j < (int)oldFormats.size(); ++j) {

        if (oldFormats[j].format())

            oldFormats[j].format()->addRef();

    }

}

Q3TextFormatCommand::~Q3TextFormatCommand()

{

    format->removeRef();

    for (int j = 0; j < (int)oldFormats.size(); ++j) {

        if (oldFormats[j].format())

            oldFormats[j].format()->removeRef();

    }

}

Q3TextCursor *Q3TextFormatCommand::execute(Q3TextCursor *c)

{

    Q3TextParagraph *sp = doc->paragAt(startId);

    Q3TextParagraph *ep = doc->paragAt(endId);

    if (!sp || !ep)

        return c;

    Q3TextCursor start(doc);

    start.setParagraph(sp);

    start.setIndex(startIndex);

    Q3TextCursor end(doc);

    end.setParagraph(ep);

    end.setIndex(endIndex);

    doc->setSelectionStart(Q3TextDocument::Temp, start);

    doc->setSelectionEnd(Q3TextDocument::Temp, end);

    doc->setFormat(Q3TextDocument::Temp, format, flags);

    doc->removeSelection(Q3TextDocument::Temp);

    if (endIndex == ep->length())

        end.gotoLeft();

    *c = end;

    return c;

}

Q3TextCursor *Q3TextFormatCommand::unexecute(Q3TextCursor *c)

{

    Q3TextParagraph *sp = doc->paragAt(startId);

    Q3TextParagraph *ep = doc->paragAt(endId);

    if (!sp || !ep)

        return 0;

    int idx = startIndex;

    int fIndex = 0;

    while ( fIndex < int(oldFormats.size()) ) {

        if (oldFormats.at(fIndex).c == QLatin1Char('\n')) {

            if (idx > 0) {

                if (idx < sp->length() && fIndex > 0)

                    sp->setFormat(idx, 1, oldFormats.at(fIndex - 1).format());

                if (sp == ep)

                    break;

                sp = sp->next();

                idx = 0;

            }

            fIndex++;

        }

        if (oldFormats.at(fIndex).format())

            sp->setFormat(idx, 1, oldFormats.at(fIndex).format());

        idx++;

        fIndex++;

        if (fIndex >= (int)oldFormats.size())

            break;

        if (idx >= sp->length()) {

            if (sp == ep)

                break;

            sp = sp->next();

            idx = 0;

        }

    }

    Q3TextCursor end(doc);

    end.setParagraph(ep);

    end.setIndex(endIndex);

    if (endIndex == ep->length())

        end.gotoLeft();

    *c = end;

    return c;

}

Q3TextStyleCommand::Q3TextStyleCommand(Q3TextDocument *dc, int fParag, int lParag, const QByteArray& beforeChange)

    : Q3TextCommand(dc), firstParag(fParag), lastParag(lParag), before(beforeChange)

{

    after = readStyleInformation( dc, fParag, lParag);

}

QByteArray Q3TextStyleCommand::readStyleInformation( Q3TextDocument* doc, int fParag, int lParag)

{

    QByteArray style;

#ifndef QT_NO_DATASTREAM

    Q3TextParagraph *p = doc->paragAt(fParag);

    if (!p)

        return style;

    QDataStream styleStream(&style, IO_WriteOnly);

    int num = lParag - fParag + 1;

    styleStream << num;

    while (num -- && p) {

        p->writeStyleInformation(styleStream);

        p = p->next();

    }

#endif

    return style;

}

void Q3TextStyleCommand::writeStyleInformation( Q3TextDocument* doc, int fParag, const QByteArray& style)

{

#ifndef QT_NO_DATASTREAM

    Q3TextParagraph *p = doc->paragAt(fParag);

    if (!p)

        return;

    QByteArray copy = style;

    QDataStream styleStream(&copy, IO_ReadOnly);

    int num;

    styleStream >> num;

    while (num-- && p) {

        p->readStyleInformation(styleStream);

        p = p->next();

    }

#endif

}

Q3TextCursor *Q3TextStyleCommand::execute(Q3TextCursor *c)

{

    writeStyleInformation(doc, firstParag, after);

    return c;

}

Q3TextCursor *Q3TextStyleCommand::unexecute(Q3TextCursor *c)

{

    writeStyleInformation(doc, firstParag, before);

    return c;

}

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Q3TextCursor::Q3TextCursor(Q3TextDocument *dc)

    : idx(0), tmpX(-1), ox(0), oy(0),

      valid(true)

{

    para = dc ? dc->firstParagraph() : 0;

}

Q3TextCursor::Q3TextCursor(const Q3TextCursor &c)

{

    ox = c.ox;

    oy = c.oy;

    idx = c.idx;

    para = c.para;

    tmpX = c.tmpX;

    indices = c.indices;

    paras = c.paras;

    xOffsets = c.xOffsets;

    yOffsets = c.yOffsets;

    valid = c.valid;

}

Q3TextCursor::~Q3TextCursor()

{

}

Q3TextCursor &Q3TextCursor::operator=(const Q3TextCursor &c)

{

    ox = c.ox;

    oy = c.oy;

    idx = c.idx;

    para = c.para;

    tmpX = c.tmpX;

    indices = c.indices;

    paras = c.paras;

    xOffsets = c.xOffsets;

    yOffsets = c.yOffsets;

    valid = c.valid;

    return *this;

}

bool Q3TextCursor::operator==(const Q3TextCursor &c) const

{

    return para == c.para && idx == c.idx;

}

int Q3TextCursor::totalOffsetX() const

{

    int xoff = ox;

    for (QStack<int>::ConstIterator xit = xOffsets.begin(); xit != xOffsets.end(); ++xit)

        xoff += *xit;

    return xoff;

}

int Q3TextCursor::totalOffsetY() const

{

    int yoff = oy;

    for (QStack<int>::ConstIterator yit = yOffsets.begin(); yit != yOffsets.end(); ++yit)

        yoff += *yit;

    return yoff;

}

#ifndef QT_NO_TEXTCUSTOMITEM

void Q3TextCursor::gotoIntoNested(const QPoint &globalPos)

{

    if (!para)

        return;

    Q_ASSERT(para->at(idx)->isCustom());

    push();

    ox = 0;

    int bl, y;

    para->lineHeightOfChar(idx, &bl, &y);

    oy = y + para->rect().y();

    ox = para->at(idx)->x;

    Q3TextDocument* doc = document();

    para->at(idx)->customItem()->enterAt(this, doc, para, idx, ox, oy, globalPos-QPoint(ox,oy));

}

#endif

void Q3TextCursor::invalidateNested()

{

    if (nestedDepth()) {

        QStack<Q3TextParagraph*>::Iterator it = paras.begin();

        QStack<int>::Iterator it2 = indices.begin();

        for (; it != paras.end(); ++it, ++it2) {

            if (*it == para)

                continue;

            (*it)->invalidate(0);

#ifndef QT_NO_TEXTCUSTOMITEM

            if ((*it)->at(*it2)->isCustom())

                (*it)->at(*it2)->customItem()->invalidate();

#endif

        }

    }

}

void Q3TextCursor::insert(const QString &str, bool checkNewLine, QVector<Q3TextStringChar> *formatting)

{

    tmpX = -1;