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

**

** 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_p.h"

#include "hbfeaturemanager_r.h"

#endif

// #define HB_TEXT_ITEM_LOGS

#define EPSILON 0.01

#ifdef HB_TEXT_ITEM_LOGS

#   include <QDebug>

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

{

}

void HbTextItemPrivate::init(QGraphicsItem *)

{

    Q_Q(HbTextItem);

    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());

}

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();

    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;

}

{

    QFontMetricsF metrics(mTextLayout.font());

    Q_ASSERT(mMinLines>0);

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

    }

    if (mMaxLines>0) {

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

        }

    }

}

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;

}

 */

{

#ifdef HB_TEXT_ITEM_LOGS

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

            << " adjusted=" << mAdjustedSize

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

    }

    // 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

        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

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

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

        // and don't update geometry

        return false;

    }

    // new height was calculated create new range for which

    // current mAdjustedSize.height is valid

    mMinWidthForAdjust = newAdjust.width();

    mAdjustedSize.setHeight(newAdjust.height());

               "HbTextItemPrivate::isAdjustHightNeeded",

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

        // 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());

        // return cached value, see more in:

        //      - HbTextItemPrivate::isAdjustHightNeeded

        //      - HbTextItem::resizeEvent

        return mAdjustedSize;

    }

    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();

    return size;

}

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

{

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

            && !contentRect.contains(

                    layoutBoundingRect().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

        qreal scale = dx*dy/(dx*dx+dy*dy);

        mCornerFadeX = dy*scale;

        mCornerFadeY = dx*scale;

    } else {