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

**

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

#endif

#define EPSILON 0.01

bool HbTextItemPrivate::outlinesEnabled = false;

static const QString KDefaultColorThemeName = "qtc_view_normal";

const int MinimumWidth = 5; // 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),

    mDontPrint(false),

    mDontClip(false),

    mInvalidateShownText(true),

    mOffsetPos(0,0),

    mPaintFaded(false),

    mFadeLengthX(30),

    mFadeLengthY(15),

    mPrefHeight(0),

    mMinLines(0),

    mMaxLines(0),

    mNeedToAdjustSizeHint(false),

    mUpdateColor(true)

{

}

void HbTextItemPrivate::init(QGraphicsItem *)

{

    Q_Q(HbTextItem);

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

    q->setFlag(QGraphicsItem::ItemClipsToShape, !mDontClip);

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

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

    QTextOption textOption = mTextLayout.textOption();

    textOption.setWrapMode(QTextOption::WordWrap);

    mTextLayout.setTextOption(textOption);

    mTextLayout.setCacheEnabled(true);

}

void HbTextItemPrivate::clear()

{

    // no implementation needed

}

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

{

    bool textTruncated = false;

    mInvalidateShownText = false;

    mTextLayout.setText(text);

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

    qreal height = 0;

    mTextLayout.beginLayout();

    while (1) {

        QTextLine line = mTextLayout.createLine();

        if (!line.isValid())

            break;

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

            textTruncated = true;

            break;

        }

        line.setLineWidth(lineWidth);

        height += leading;

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

        height += line.height();

    }

    mTextLayout.endLayout();

    if( textTruncated ) {

        mTextLayout.setText(text);

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

        qreal height = 0;

        mTextLayout.beginLayout();

        while ( mTextLayout.lineCount() < mMaxLines ) {

            QTextLine line = mTextLayout.createLine();

            line.setLineWidth(lineWidth);

            height += leading;

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

            height += line.height();

        }

        mTextLayout.endLayout();

    }

    return textTruncated;

}

void HbTextItemPrivate::setSize(const QSizeF &newSize)

{

    Q_Q(HbTextItem);

    QFont usedFont = q->font();

    QFontMetricsF fontMetrics(usedFont);

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

    }

    // function does the layout only when needed

    mTextLayout.setFont(usedFont);

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

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

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

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

        }

    }

    calculateVerticalOffset();

    calculateFadeRects();

    q->update();

}

/*

    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;

}

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(mDontClip)  flags |= Qt::TextDontClip;

    if(mDontPrint) flags |= Qt::TextDontPrint;

    return flags;

}

bool HbTextItemPrivate::adjustSizeHint()

{

    Q_Q( HbTextItem );

    mNeedToAdjustSizeHint = false;

    if ( !(q->sizePolicy().verticalPolicy()&QSizePolicy::IgnoreFlag) ) {

        // only calculated if the vertical sizeHint is taken into account

        const QFontMetricsF metrics(q->font());

        if ( mMinLines > 0 && (mMinLines == mMaxLines) ) {

            // if the number of lines if fixed: optimize

            const qreal newPrefHeight = ( metrics.height() + metrics.leading() ) * mMinLines - metrics.leading();

            if( qAbs( mPrefHeight - newPrefHeight ) > EPSILON ) {

                mPrefHeight = newPrefHeight;

                return true;

            }

            return false;

        }

        QSizeF currSize = q->size();

        // do the heavy calculation

        QRectF desiredRect = metrics.boundingRect( QRectF( 0, 0 , currSize.width(), QWIDGETSIZE_MAX ), textFlagsFromTextOption(), mText );

        if( qAbs( desiredRect.height() - mPrefHeight ) > EPSILON ) {

            mPrefHeight = desiredRect.height();

            return true;

        }

    }

    return false;

}

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 {

        mCornerFadeX = 1;

        mCornerFadeY = 0;

    }

    mPaintFaded = fadeNeeded(contentRect);

}

/*

    This work-around is needed since there is a problem with pen transformations

    in hardware Open VG renderer. This problem occurs only on s60 hardware.

    On platforms: Linux, Windows and S60 emulator there is no such problem.

    Below flag detects platform which have this problem to activate work-around.

 */

#if defined(Q_WS_S60) && defined(Q_BIG_ENDIAN)

#   warning Work-around is active in fade effect of HbTextItem (see comment)

#   define HB_FADE_EFFECT_WORKAROUND_ON_PHONE

#endif

inline void HbTextItemPrivate::setPainterPen(QPainter *painter,

                         const QPen& pen,

                         const QPointF& lineBegin)

{

#ifdef HB_FADE_EFFECT_WORKAROUND_ON_PHONE

    const QGradient *gradient = pen.brush().gradient();

    if (!gradient || gradient->type()!=QGradient::LinearGradient) {

        painter->setPen(pen);

        return;

    }

    const QLinearGradient* linGrad = static_cast<const QLinearGradient*>(gradient);

    QLinearGradient newGrad(*linGrad);

    newGrad.setStart(newGrad.start()-lineBegin);

    newGrad.setFinalStop(newGrad.finalStop()-lineBegin);

    QBrush newBrush(newGrad);

    QPen newPen;

    newPen.setBrush(newBrush);

    painter->setPen(newPen);

#else

    Q_UNUSED(painter)

    Q_UNUSED(pen)

    Q_UNUSED(lineBegin)

#endif // HB_FADE_EFFECT_WORKAROUND_ON_PHONE

}

/*

    This method paint each line in tree pieces.

    In each piece uses different pen.

    When fade effect is not needed on some end centerPen is used.

 */

int HbTextItemPrivate::paintFaded(QPainter *painter,

                                  int firstItemToPaint,

                                  const QPen& leftPen,

                                  const QPen& centerPen,

                                  const QPen& rightPen,

                                  const QRectF& area ) const

{

    Q_Q(const HbTextItem);

    const int n = mTextLayout.lineCount();

    const qreal leftBorder = q->contentsRect().left()-KFadeTolerance;

    const qreal rightBorder = q->contentsRect().right()+KFadeTolerance;

    QRectF leftRect(area);

    leftRect.setRight(mFadeFromRect.left());

    QRectF centerRect(area);

    centerRect.moveLeft(leftRect.right());

    centerRect.setRight(mFadeFromRect.right());

    QRectF rightRect(area);

    rightRect.setLeft(centerRect.right());

    qreal maxY = area.bottom();

    for(int i=firstItemToPaint; i<n; ++i) {

        QTextLine line = mTextLayout.lineAt(i);

        QRectF lineRect = line.naturalTextRect();

        lineRect.translate(mOffsetPos);

#ifdef HB_FADE_EFFECT_WORKAROUND_ON_PHONE

        const QPointF gradientOffset(

                QPointF(lineRect.left(),

                        lineRect.top()+line.ascent())

                );

#endif // HB_FADE_EFFECT_WORKAROUND_ON_PHONE

        QRectF currentCenter(centerRect);

        if(lineRect.top()>maxY) {

            // stop painting line by line

            return i; // current line won't be painted at all

        }

        if(lineRect.left()<leftBorder) {

#ifdef HB_FADE_EFFECT_WORKAROUND_ON_PHONE

            setPainterPen(painter, leftPen, gradientOffset);

#else

            painter->setPen(leftPen);

#endif

            painter->setClipRect(leftRect);

            line.draw(painter, mOffsetPos);

        } else {

            // no fade on this end so extend currentCenter

            currentCenter.setLeft(leftRect.left());

        }

        if(lineRect.right()>rightBorder) {

#ifdef HB_FADE_EFFECT_WORKAROUND_ON_PHONE

            setPainterPen(painter, rightPen, gradientOffset);

#else

            painter->setPen(rightPen);

#endif

            painter->setClipRect(rightRect);

            line.draw(painter, mOffsetPos);

        } else {

            // no fade on this end so extend currentCenter

            currentCenter.setRight(rightRect.right());

        }

        if(currentCenter.width()>0) {

#ifdef HB_FADE_EFFECT_WORKAROUND_ON_PHONE

            setPainterPen(painter, centerPen, gradientOffset);

#else

            painter->setPen(centerPen);

#endif

            painter->setClipRect(currentCenter);

            line.draw(painter, mOffsetPos);

        }

        if(lineRect.bottom()>maxY) {

            // stop painting line by line

            return i; // current line has been painted partially

        }

    } // for loop

    return n;

} // paintFaded()