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

**

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

** All rights reserved.

** Contact: Nokia Corporation (developer.feedback@nokia.com)

**

** This file is part of the HbCore module of the UI Extensions for Mobile.

**

** GNU Lesser General Public License Usage

** 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 developer.feedback@nokia.com.

**

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

#include "hbtextitem.h"

#include "hbtextitem_p.h"

#include "hbstyle.h"

#include "hbtextutils_p.h"

#include "hbcolorscheme.h"

#include "hbevent.h"

#include <QTextLayout>

#include <QGraphicsSceneResizeEvent>

#include <QPainter>

#include <QTextOption>

#include <QApplication>

#ifdef HB_TEXT_MEASUREMENT_UTILITY

#include "hbtextmeasurementutility_r_p.h"

#include "hbfeaturemanager_r.h"

#endif

// #define HB_TEXT_ITEM_LOGS

#define EPSILON 0.01

#ifdef HB_TEXT_ITEM_LOGS

#   include <QDebug>

const int KMaxLogedTextLength = 30;

#endif // HB_TEXT_ITEM_LOGS

bool HbTextItemPrivate::outlinesEnabled = false;

static const QString KDefaultColorThemeName = "qtc_view_normal";

const qreal MinimumWidth = 5.0; // minimum width if there is some text.

const int KLayoutCacheLimit = 64;

const qreal KFadeTolerance = 1.0;

HbTextItemPrivate::HbTextItemPrivate () :

    mAlignment(Qt::AlignLeft | Qt::AlignVCenter),

    mElideMode(Qt::ElideNone),

    mInvalidateShownText(true),

    mOffsetPos(0,0),

    mPaintFaded(false),

    mFadeLengthX(30),

    mFadeLengthY(15),

    mMinLines(1),

    mMaxLines(0),

    mMinWidthForAdjust(-1),

    mMaxWidthForAdjust(-1),

    mDefaultHeight(-1),

    mUpdateColor(true),

    mEventPosted(false),

    inConstructor(1)

{

}

void HbTextItemPrivate::init(QGraphicsItem *)

{

    Q_Q(HbTextItem);

    inConstructor = 1;

    q->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);

    q->setFlag(QGraphicsItem::ItemClipsToShape, false);

    q->setFlag(QGraphicsItem::ItemIsSelectable, false);

    q->setFlag(QGraphicsItem::ItemIsFocusable,  false);

    QTextOption textOption = mTextLayout.textOption();

    textOption.setWrapMode(QTextOption::WordWrap);

    mTextLayout.setTextOption(textOption);

    mTextLayout.setCacheEnabled(true);

    mTextLayout.setFont(q->font());

    inConstructor = 0;

}

void HbTextItemPrivate::clear()

{

    // no implementation needed

}

bool HbTextItemPrivate::doLayout(const QString& text, const qreal lineWidth, qreal lineSpacing)

{

    bool textTruncated = false;

    mTextLayout.setText(text);

    qreal yLinePos = 0;

    mTextLayout.beginLayout();

    while (1) {

        QTextLine line = mTextLayout.createLine();

        if (!line.isValid())

            break;

        line.setLineWidth(lineWidth);

        line.setPosition(QPointF(0, yLinePos));

        if( ( mMaxLines > 0 ) && ( mTextLayout.lineCount() >= mMaxLines ) ) {

            textTruncated = (line.textStart()+line.textLength() < text.length());

            break;

        }

        yLinePos += lineSpacing;

    }

    mTextLayout.endLayout();

    return textTruncated;

}

void HbTextItemPrivate::rebuildTextLayout(const QSizeF &newSize)

{

    QFontMetricsF fontMetrics(mTextLayout.font());

    const qreal lineWidth = qRound( newSize.width() + 0.5 ); // round up to integer

    updateTextOption();

    QString tempText(mText);

    if(tempText.indexOf('\n')>=0) {

        // to prevent creation of deep copy if replace has no effect

        tempText.replace('\n', QChar::LineSeparator);

    }

    // Need to call elidedText explicitly to enable multiple length translations.

    tempText = fontMetrics.elidedText(tempText, Qt::ElideNone, lineWidth);

    bool textTruncated = doLayout(tempText, lineWidth, fontMetrics.lineSpacing());

    if(mElideMode!=Qt::ElideNone && !tempText.isEmpty()) {

        if( ( mTextLayout.boundingRect().height() - newSize.height() > EPSILON ) ||

            ( mTextLayout.boundingRect().width() - lineWidth > EPSILON ) ||

              textTruncated) {

            // TODO: Multiple length translations with multiline text

            doLayout(elideLayoutedText(newSize, fontMetrics),

                     lineWidth,

                     fontMetrics.lineSpacing());

        }

    }

    calculateVerticalOffset();

    mBoundingRect = layoutBoundingRect();

    calculateFadeRects();

    // build of text layout is completed

    mInvalidateShownText = false;

}

/*

    finds index of last line before given Y coordinate

    It is a binary search.

 */

int HbTextItemPrivate::findIndexOfLastLineBeforeY(qreal y) const

{

    int i=0,j=mTextLayout.lineCount();

    if( ( mMaxLines > 0 ) && ( mMaxLines < j ) ){

        j = mMaxLines;

    }

    while(i!=j) {

        int k = (i+j)>>1;

        if(mTextLayout.lineAt(k).naturalTextRect().bottom()>y) {

            j=k;

        } else {

            if(i==k) {

                break;

            }

            i=k;

        }

    }

    return i;

}

qreal HbTextItemPrivate::respectHeightLimits(qreal height) const

{

    QFontMetricsF metrics(mTextLayout.font());

    Q_ASSERT(mMinLines>0);

    qreal minHeight = metrics.lineSpacing()*mMinLines - metrics.leading();

    if (height<minHeight) {

        height=minHeight;

    }

    if (mMaxLines>0) {

        qreal maxHeight = metrics.lineSpacing()*mMaxLines - metrics.leading();

        if (height>maxHeight) {

            height=maxHeight;

        }

    }

    return height;

}

QString HbTextItemPrivate::elideLayoutedText(const QSizeF& size, const QFontMetricsF& metrics) const

{

    int lastVisibleLine =findIndexOfLastLineBeforeY(size.height());

    QTextLine lastLine = mTextLayout.lineAt(lastVisibleLine);

    // all visible lines without last visible line

    QString textToElide = mTextLayout.text();

    QString elidedText = textToElide.left(lastLine.textStart());

    if(!elidedText.isEmpty() && !elidedText.endsWith(QChar::LineSeparator)) {

        // needed to prevent to move "..." to line before last line

        elidedText.append(QChar::LineSeparator);

    }

    int n = lastLine.textLength();

    if(textToElide.at(lastLine.textStart()+n-1)!=QChar::LineSeparator) {

        n = -1;

    }

    elidedText.append(metrics.elidedText(textToElide.mid(lastLine.textStart(), n),

                                         mElideMode, size.width(),textFlagsFromTextOption()));

    return elidedText;

}

void HbTextItemPrivate::updateTextOption()

{

    Q_Q(HbTextItem);

    QTextOption textOpt = mTextLayout.textOption();

    textOpt.setAlignment(QStyle::visualAlignment(q->layoutDirection(), q->alignment()));

    textOpt.setTextDirection(q->layoutDirection());

    mTextLayout.setTextOption(textOpt);

}

void HbTextItemPrivate::calculateVerticalOffset()

{

    Q_Q(HbTextItem);

    mOffsetPos.setY(0);

    Qt::Alignment align = q->alignment();

    if(!align.testFlag(Qt::AlignTop) && (align & Qt::AlignVertical_Mask)!=0 ) {

        int index = mTextLayout.lineCount()-1;

        if(index>=0) {

            qreal diff = q->size().height();

            diff -= mTextLayout.lineAt(index).rect().bottom();

            if(align & Qt::AlignVCenter) {

                diff *=(qreal)0.5;

            }

            if(diff>=0 || mElideMode==Qt::ElideNone) {

                mOffsetPos.setY(diff);

            }

        }

    }

}

int HbTextItemPrivate::textFlagsFromTextOption() const

{

    QTextOption textOption = mTextLayout.textOption();

    int flags = (int)mAlignment;

    switch(textOption.wrapMode()) {

    case QTextOption::NoWrap:

        break;

    case QTextOption::WordWrap:

        flags |= Qt::TextWordWrap;

        break;

    case QTextOption::ManualWrap:

        break;

    case QTextOption::WrapAnywhere:

        flags |= Qt::TextWrapAnywhere;

        break;

    case QTextOption::WrapAtWordBoundaryOrAnywhere:

        flags |= Qt::TextWordWrap | Qt::TextWrapAnywhere;

        break;

    }

    if(q_ptr->flags().testFlag(QGraphicsItem::ItemClipsToShape)) {

        flags |= Qt::TextDontClip;

    }

    if(!q_ptr->isVisible()) { // or ItemHasNoContents?

        flags |= Qt::TextDontPrint;

    }

    return flags;

}

/*

    This method check spatial case of calculating sizeHint.

    By default preferredSize (sizeHint(Qt::PreferredSize)) returns size of text

    which has lots of free space and it is not wrapped.

    After size of HbTextItem is set (width is know) there can be situation

    that text has less available width then required.

    In such cases when text wrapping is available preferred height of HbTextItem

    should be recalculated to take wrapped text into account.

 */

bool HbTextItemPrivate::isAdjustHightNeeded(qreal newWidth,

                                            qreal prefHeight,

                                            qreal minHeight,

                                            qreal maxHeight)

{

#ifdef HB_TEXT_ITEM_LOGS

    qDebug() << "isAdjustHightNeeded for: " << q_ptr->objectName()

            << " text=" << mText.left(KMaxLogedTextLength)

            << " adjusted=" << mAdjustedSize

            << " prefHeight=" << prefHeight

            << " minHeight=" << minHeight

            << " lastConstraint=" << mLastConstraint

            << " " << mTextLayout.font();

#endif // HB_TEXT_ITEM_LOGS

    // first check if wrapping of text is not active

    QTextOption::WrapMode wrapMode = mTextLayout.textOption().wrapMode();

    if (wrapMode==QTextOption::NoWrap

        || wrapMode==QTextOption::ManualWrap) {

        return false;

    }

    // preferred height was set from outside of this class so there is mo reson to adjust it

    if (mLastConstraint.height()>0) {

        return false;

    }

    // check if line count is fixed

    if (mMaxLines == mMinLines) {

        return false;

    }

    // check if adjusted size has been already calculated

    // new width is bigger then last estimated range of same height

    if ((mMaxWidthForAdjust>=newWidth

         // new width is smaller then last estimated range of same height

         && newWidth>=mMinWidthForAdjust)) {

        return false;

    }

    if (!mAdjustedSize.isValid()) {

        // this means that preferred size is set outside of class by setPreferredSize

        // so sizeHint(Qt::Preferredsize) was not called and size adjustment is useless

        return false;

    }

    // if preconditions are met test if current hight is enough

    const QFontMetricsF metrics(mTextLayout.font());

    // heavy calculation: check if text fits in current size and cache result

    QSizeF newAdjust = metrics.boundingRect(QRectF(0, 0, newWidth, QWIDGETSIZE_MAX),

                                            textFlagsFromTextOption(),

                                            mText).size();

    if (qFuzzyCompare(newAdjust.height(), mAdjustedSize.height())) {

        // height is same as last time update range of same height

        mMaxWidthForAdjust = qMax(mMaxWidthForAdjust, newWidth);

        mMinWidthForAdjust = qMin(mMinWidthForAdjust, newWidth);

        // and don't update geometry

        return false;

    }

    // new height was calculated create new range for which

    // current mAdjustedSize.height is valid

    mMaxWidthForAdjust = newWidth;

    mMinWidthForAdjust = newAdjust.width();

    // store new hieght, don't change width

    mAdjustedSize.setHeight(newAdjust.height());

    Q_ASSERT_X(mLastConstraint.width()>0 || mAdjustedSize.width()>=newAdjust.width(),

               "HbTextItemPrivate::isAdjustHightNeeded",

               QString("Fail for string: \"%1\"").arg(mText).toAscii().data());

    if (qFuzzyCompare(qBound(minHeight,

                             respectHeightLimits(mAdjustedSize.height()),

                             maxHeight),

                      prefHeight)) {

        // updateGeometry has no effect

        return false;

    }

    // all conditions for calling updateGeometry are meet

    return true;

}

void HbTextItemPrivate::clearAdjustedSizeCache()

{

    // clear cache of size

    mMinWidthForAdjust = -1;

    mMaxWidthForAdjust = -1;

    mAdjustedSize.setHeight(-1);

}

QSizeF HbTextItemPrivate::calculatePrefferedSize(const QSizeF& constraint) const

{

    const QFontMetricsF metrics(mTextLayout.font());

    if (mAdjustedSize.isValid() && constraint == mLastConstraint) {

        // return cached value, see more in:

        //      - HbTextItemPrivate::isAdjustHightNeeded

        //      - HbTextItem::resizeEvent

#ifdef HB_TEXT_ITEM_LOGS

        qDebug() << "HbTextItemPrivate::calculatePrefferedSize: returning cached value: " << mAdjustedSize

                << " font:" << mTextLayout.font()

                << " text:" << mText.left(KMaxLogedTextLength);

#endif

        return mAdjustedSize;

    }

    mLastConstraint = constraint;

    QSizeF maxSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX);

    if(constraint.width()>0) {

        maxSize.setWidth(constraint.width());

    }

    if(constraint.height()>0) {

        maxSize.setHeight(constraint.height());

    }

    QSizeF size = metrics.boundingRect(QRectF(QPointF(),maxSize),

                                       textFlagsFromTextOption(),

                                       mText).size();

    mAdjustedSize = size;

    mDefaultHeight = size.height();

    mMinWidthForAdjust = size.width();

    mMaxWidthForAdjust = maxSize.width();

#ifdef HB_TEXT_ITEM_LOGS

        qDebug() << "HbTextItemPrivate::calculatePrefferedSize:"

                << " text: " << mText.left(KMaxLogedTextLength)

                << " returnSize: " << mAdjustedSize

                << " constraint: "  << constraint

                << " font: " << mTextLayout.font();

#endif

    return size;

}

bool HbTextItemPrivate::fadeNeeded(const QRectF& contentRect) const

{

    return (mFadeLengthX!=0 || mFadeLengthY!=0)

            && !contentRect.contains(

                    mBoundingRect.adjusted(KFadeTolerance,

                                                  KFadeTolerance,

                                                  -KFadeTolerance,

                                                  -KFadeTolerance));

}

void HbTextItemPrivate::setupGradient(QLinearGradient *gradient, QColor color)

{

    gradient->setColorAt(1.0, color);

    color.setAlpha(color.alpha()>>2); // 1/4 of initial opacity

    gradient->setColorAt(0.5, color); // middle color to improve feeling of fade effect

    color.setAlpha(0); // fully transparent

    gradient->setColorAt(0.0, color);

}

void HbTextItemPrivate::calculateFadeRects()

{

    Q_Q(const HbTextItem);

    const QRectF contentRect = q->contentsRect();

    mFadeToRect = contentRect;

    mFadeFromRect = contentRect;

    if(mFadeLengthX>0) {

        mFadeFromRect.moveLeft(mFadeLengthX);

        mFadeFromRect.setRight(contentRect.right()-mFadeLengthX);

        if(mFadeFromRect.width()<0) {

            mFadeFromRect.moveLeft(mFadeFromRect.center().x());

            mFadeFromRect.setWidth(0.0);

        }

    } else {

        mFadeToRect.moveLeft(mFadeLengthX);

        mFadeToRect.setRight(contentRect.right()-mFadeLengthX);

    }

    if(mFadeLengthY>0) { // TODO: alternative direction

        mFadeFromRect.moveTop(mFadeLengthY);

        mFadeFromRect.setBottom(contentRect.bottom()-mFadeLengthY);

        if(mFadeFromRect.height()<0) {

            mFadeFromRect.moveTop(mFadeFromRect.center().y());

            mFadeFromRect.setHeight(0.0);

        }

    } else {

        mFadeToRect.moveTop(mFadeLengthY);

        mFadeToRect.setBottom(contentRect.bottom()-mFadeLengthY);

    }

    qreal dx,dy;

    dx = mFadeFromRect.left() - mFadeToRect.left();

    dy = mFadeFromRect.top()  - mFadeToRect.top();

    if(dx!=0 || dy!=0) {

        // corner gradient vectors