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

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

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

**

** This file is part of the QtGui 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 "qtextlayout.h"

#include "qtextengine_p.h"

#include <qfont.h>

#include <qapplication.h>

#include <qpainter.h>

#include <qvarlengtharray.h>

#include <qtextformat.h>

#include <qabstracttextdocumentlayout.h>

#include "qtextdocument_p.h"

#include "qtextformat_p.h"

#include "qstyleoption.h"

#include "qpainterpath.h"

#include <limits.h>

#include <qdebug.h>

#include "qfontengine_p.h"

QT_BEGIN_NAMESPACE

#define ObjectSelectionBrush (QTextFormat::ForegroundBrush + 1)

#define SuppressText 0x5012

#define SuppressBackground 0x513

static inline QFixed leadingSpaceWidth(QTextEngine *eng, const QScriptLine &line)

{

    if (!line.hasTrailingSpaces

        || (eng->option.flags() & QTextOption::IncludeTrailingSpaces)

        || !(eng->option.alignment() & Qt::AlignRight)

        || (eng->option.textDirection() != Qt::RightToLeft))

        return QFixed();

    int pos = line.length;

    const HB_CharAttributes *attributes = eng->attributes();

    while (pos > 0 && attributes[line.from + pos - 1].whiteSpace)

        --pos;

    return eng->width(line.from + pos, line.length - pos);

}

static QFixed alignLine(QTextEngine *eng, const QScriptLine &line)

{

    QFixed x = 0;

    eng->justify(line);

    // if width is QFIXED_MAX that means we used setNumColumns() and that implicitly makes this line left aligned.

    if (!line.justified && line.width != QFIXED_MAX) {

        int align = eng->option.alignment();

        if (align & Qt::AlignJustify && eng->option.textDirection() == Qt::RightToLeft)

            align = Qt::AlignRight;

        if (align & Qt::AlignRight)

            x = line.width - (line.textWidth + leadingSpaceWidth(eng, line));

        else if (align & Qt::AlignHCenter)

            x = (line.width - line.textWidth)/2;

    }

    return x;

}

/*!

    \class QTextLayout::FormatRange

    \reentrant

    \brief The QTextLayout::FormatRange structure is used to apply extra formatting information

    for a specified area in the text layout's content.

    \sa QTextLayout::setAdditionalFormats(), QTextLayout::draw()

*/

/*!

    \variable QTextLayout::FormatRange::start

    Specifies the beginning of the format range within the text layout's text.

*/

/*!

    \variable QTextLayout::FormatRange::length

    Specifies the numer of characters the format range spans.

*/

/*!

    \variable QTextLayout::FormatRange::format

    Specifies the format to apply.

*/

/*!

    \class QTextInlineObject

    \reentrant

    \brief The QTextInlineObject class represents an inline object in

    a QTextLayout.

    \ingroup richtext-processing

    This class is only used if the text layout is used to lay out

    parts of a QTextDocument.

    The inline object has various attributes that can be set, for

    example using, setWidth(), setAscent(), and setDescent(). The

    rectangle it occupies is given by rect(), and its direction by

    isRightToLeft(). Its position in the text layout is given by at(),

    and its format is given by format().

*/

/*!

    \fn QTextInlineObject::QTextInlineObject(int i, QTextEngine *e)

    Creates a new inline object for the item at position \a i in the

    text engine \a e.

*/

/*!

    \fn QTextInlineObject::QTextInlineObject()

    \internal

*/

/*!

    \fn bool QTextInlineObject::isValid() const

    Returns true if this inline object is valid; otherwise returns

    false.

*/

/*!

    Returns the inline object's rectangle.

    \sa ascent() descent() width()

*/

QRectF QTextInlineObject::rect() const

{

    QScriptItem& si = eng->layoutData->items[itm];

    return QRectF(0, -si.ascent.toReal(), si.width.toReal(), si.height().toReal());

}

/*!

    Returns the inline object's width.

    \sa ascent() descent() rect()

*/

qreal QTextInlineObject::width() const

{

    return eng->layoutData->items[itm].width.toReal();

}

/*!

    Returns the inline object's ascent.

    \sa descent() width() rect()

*/

qreal QTextInlineObject::ascent() const

{

    return eng->layoutData->items[itm].ascent.toReal();

}

/*!

    Returns the inline object's descent.

    \sa ascent() width() rect()

*/

qreal QTextInlineObject::descent() const

{

    return eng->layoutData->items[itm].descent.toReal();

}

/*!

    Returns the inline object's total height. This is equal to

    ascent() + descent() + 1.

    \sa ascent() descent() width() rect()

*/

qreal QTextInlineObject::height() const

{

    return eng->layoutData->items[itm].height().toReal();

}

/*!

    Sets the inline object's width to \a w.

    \sa width() ascent() descent() rect()

*/

void QTextInlineObject::setWidth(qreal w)

{

    eng->layoutData->items[itm].width = QFixed::fromReal(w);

}

/*!

    Sets the inline object's ascent to \a a.

    \sa ascent() setDescent() width() rect()

*/

void QTextInlineObject::setAscent(qreal a)

{

    eng->layoutData->items[itm].ascent = QFixed::fromReal(a);

}

/*!

    Sets the inline object's decent to \a d.

    \sa descent() setAscent() width() rect()

*/

void QTextInlineObject::setDescent(qreal d)

{

    eng->layoutData->items[itm].descent = QFixed::fromReal(d);

}

/*!

  The position of the inline object within the text layout.

*/

int QTextInlineObject::textPosition() const

{

    return eng->layoutData->items[itm].position;

}

/*!

  Returns an integer describing the format of the inline object

  within the text layout.

*/

int QTextInlineObject::formatIndex() const

{

    return eng->formatIndex(&eng->layoutData->items[itm]);

}

/*!

  Returns format of the inline object within the text layout.

*/

QTextFormat QTextInlineObject::format() const

{

    if (!eng->block.docHandle())

        return QTextFormat();

    return eng->formats()->format(eng->formatIndex(&eng->layoutData->items[itm]));

}

/*!

  Returns if the object should be laid out right-to-left or left-to-right.

*/

Qt::LayoutDirection QTextInlineObject::textDirection() const

{

    return (eng->layoutData->items[itm].analysis.bidiLevel % 2 ? Qt::RightToLeft : Qt::LeftToRight);

}

/*!

    \class QTextLayout

    \reentrant

    \brief The QTextLayout class is used to lay out and paint a single

    paragraph of text.

    \ingroup richtext-processing

    It offers most features expected from a modern text layout

    engine, including Unicode compliant rendering, line breaking and

    handling of cursor positioning. It can also produce and render

    device independent layout, something that is important for WYSIWYG

    applications.

    The class has a rather low level API and unless you intend to

    implement your own text rendering for some specialized widget, you

    probably won't need to use it directly.

    QTextLayout can currently deal with plain text and rich text

    paragraphs that are part of a QTextDocument.

    QTextLayout can be used to create a sequence of QTextLine's with

    given widths and can position them independently on the screen.

    Once the layout is done, these lines can be drawn on a paint

    device.

    Here's some pseudo code that presents the layout phase:

    \snippet doc/src/snippets/code/src_gui_text_qtextlayout.cpp 0

    The text can be drawn by calling the layout's draw() function:

    \snippet doc/src/snippets/code/src_gui_text_qtextlayout.cpp 1

    The text layout's text is set in the constructor or with

    setText(). The layout can be seen as a sequence of QTextLine

    objects; use lineAt() or lineForTextPosition() to get a QTextLine,

    createLine() to create one. For a given position in the text you

    can find a valid cursor position with isValidCursorPosition(),

    nextCursorPosition(), and previousCursorPosition(). The layout

    itself can be positioned with setPosition(); it has a

    boundingRect(), and a minimumWidth() and a maximumWidth(). A text

    layout can be drawn on a painter device using draw().

*/

/*!

    \enum QTextLayout::CursorMode

    \value SkipCharacters

    \value SkipWords

*/

/*!

    \fn QTextEngine *QTextLayout::engine() const

    \internal

    Returns the text engine used to render the text layout.

*/

/*!

    Constructs an empty text layout.

    \sa setText()

*/

QTextLayout::QTextLayout()

{ d = new QTextEngine(); }

/*!

    Constructs a text layout to lay out the given \a text.

*/

QTextLayout::QTextLayout(const QString& text)

{

    d = new QTextEngine();

    d->text = text;

}

/*!

    Constructs a text layout to lay out the given \a text with the specified

    \a font.

    All the metric and layout calculations will be done in terms of

    the paint device, \a paintdevice. If \a paintdevice is 0 the

    calculations will be done in screen metrics.

*/

QTextLayout::QTextLayout(const QString& text, const QFont &font, QPaintDevice *paintdevice)

{

    QFont f(font);

    if (paintdevice)

        f = QFont(font, paintdevice);

    d = new QTextEngine((text.isNull() ? (const QString&)QString::fromLatin1("") : text), f.d.data());

}

/*!

    \internal

    Constructs a text layout to lay out the given \a block.

*/

QTextLayout::QTextLayout(const QTextBlock &block)

{

    d = new QTextEngine();

    d->block = block;

}

/*!

    Destructs the layout.

*/

QTextLayout::~QTextLayout()

{

    if (!d->stackEngine)

        delete d;

}

/*!

    Sets the layout's font to the given \a font. The layout is

    invalidated and must be laid out again.

    \sa text()

*/

void QTextLayout::setFont(const QFont &font)

{

    d->fnt = font;

}

/*!

    Returns the current font that is used for the layout, or a default

    font if none is set.

*/

QFont QTextLayout::font() const

{

    return d->font();

}

/*!

    Sets the layout's text to the given \a string. The layout is

    invalidated and must be laid out again.

    Notice that when using this QTextLayout as part of a QTextDocument this

    method will have no effect.

    \sa text()

*/

void QTextLayout::setText(const QString& string)

{

    d->invalidate();

    d->clearLineData();

    d->text = string;

}

/*!

    Returns the layout's text.

    \sa setText()

*/

QString QTextLayout::text() const

{

    return d->text;

}

/*!

  Sets the text option structure that controls the layout process to the

  given \a option.

  \sa textOption() QTextOption

*/

void QTextLayout::setTextOption(const QTextOption &option)

{

    d->option = option;

}

/*!

  Returns the current text option used to control the layout process.

  \sa setTextOption() QTextOption

*/

QTextOption QTextLayout::textOption() const

{

    return d->option;

}

/*!

    Sets the \a position and \a text of the area in the layout that is

    processed before editing occurs.

*/

void QTextLayout::setPreeditArea(int position, const QString &text)

{

    if (text.isEmpty()) {

        if (!d->specialData)

            return;

        if (d->specialData->addFormats.isEmpty()) {

            delete d->specialData;

            d->specialData = 0;

        } else {

            d->specialData->preeditText = QString();

            d->specialData->preeditPosition = -1;

        }

    } else {

        if (!d->specialData)

            d->specialData = new QTextEngine::SpecialData;

        d->specialData->preeditPosition = position;

        d->specialData->preeditText = text;

    }

    d->invalidate();

    d->clearLineData();

    if (d->block.docHandle())

        d->block.docHandle()->documentChange(d->block.position(), d->block.length());

}

/*!

    Returns the position of the area in the text layout that will be

    processed before editing occurs.

*/

int QTextLayout::preeditAreaPosition() const

{

    return d->specialData ? d->specialData->preeditPosition : -1;

}

/*!

    Returns the text that is inserted in the layout before editing occurs.

*/

QString QTextLayout::preeditAreaText() const

{

    return d->specialData ? d->specialData->preeditText : QString();

}

/*!

    Sets the additional formats supported by the text layout to \a

    formatList.

    \sa additionalFormats(), clearAdditionalFormats()

*/

void QTextLayout::setAdditionalFormats(const QList<FormatRange> &formatList)

{

    if (formatList.isEmpty()) {

        if (!d->specialData)

            return;

        if (d->specialData->preeditText.isEmpty()) {

            delete d->specialData;

            d->specialData = 0;

        } else {

            d->specialData->addFormats = formatList;

            d->specialData->addFormatIndices.clear();

        }

    } else {

        if (!d->specialData) {

            d->specialData = new QTextEngine::SpecialData;

            d->specialData->preeditPosition = -1;

        }

        d->specialData->addFormats = formatList;