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

**

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

#ifdef HB_TEXT_MEASUREMENT_UTILITY

#include "hbtextmeasurementutility_p.h"

#include "hbfeaturemanager_p.h"

#endif

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;

HbTextItemPrivate::HbTextItemPrivate () :

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

    mElideMode(Qt::ElideRight),

    mDontPrint(false),

    mDontClip(false),

    mTextDirection(Qt::LeftToRight),

    mInvalidateShownText(true),

    mOffsetPos(0,0),

    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;

        line.setLineWidth(lineWidth);

        height += leading;

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

        height += line.height();

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

            textTruncated = true;

            break;

        }

    }

    mTextLayout.endLayout();

    return textTruncated;

}

void HbTextItemPrivate::setSize(const QSizeF &newSize)

{

    Q_Q(HbTextItem);

    updateTextOption();

    QFont usedFont = q->font();

    QFontMetricsF fontMetrics(usedFont);

    const qreal lineWidth = newSize.width();

    updateTextOption();

    QString tempText(mText);

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

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

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

          || mTextLayout.boundingRect().width()>newSize.width() || textTruncated) {

            // TODO: Multiple length translations with multiline text

            doLayout(elideLayoutedText(newSize, fontMetrics),

                     lineWidth,

                     fontMetrics.leading());

        }

    }

    calculateVerticalOffset();

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

    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 textOtion = mTextLayout.textOption();

    int flags = (int)mAlignment;

    switch(textOtion.wrapMode()) {

    case QTextOption::NoWrap:

        flags |= Qt::TextSingleLine;

        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 ) > 0.01 /* 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 ) > 0.01 /* epsilon */ ) {

            mPrefHeight = desiredRect.height();

            return true;

        }

    }

    return false;

}

/*!

    @alpha

    @hbcore

    \class HbTextItem

    \brief HbTextItem is a lightweight item for showing text.

    This is mainly used as a primitive in widgets.

    It derives from HbWidgetBase so it can be layouted.

 */

/*!

    Constructor for the class with no content.

 */

HbTextItem::HbTextItem (QGraphicsItem *parent) :

    HbWidgetBase(*new HbTextItemPrivate, parent)

{

    Q_D(HbTextItem);

    d->init(parent);

}

/*!

    Constructs object with a \a text content.

 */

HbTextItem::HbTextItem (const QString &text, QGraphicsItem *parent) :

    HbWidgetBase(*new HbTextItemPrivate, parent)

{

    Q_D(HbTextItem);

    d->init(parent);

    setText(text);

}

/*

    Constructor for internal use only

 */

HbTextItem::HbTextItem (HbTextItemPrivate &dd, QGraphicsItem * parent) :

    HbWidgetBase(dd, parent)

{

    Q_D(HbTextItem);

    d->init(parent);

}

/*!

    Destructor for the class.

 */

HbTextItem::~HbTextItem ()

{

}

/*!

    Returns the text shown by object.

    \sa HbTextItem::setText()

 */

QString HbTextItem::text () const

{

    Q_D( const HbTextItem );

    return d->mText;

}

/*!

    Returns the text color used for paiting text.

    If no color was set it returns color based on theme.

    \sa HbTextItem::setTextColor()

 */

QColor HbTextItem::textColor () const

{

    Q_D( const HbTextItem );

    if (d->mColor.isValid()) { // Means user has set text color

        return d->mColor;

    }

    if (!d->mDefaultColor.isValid()) {

        d->mDefaultColor = HbColorScheme::color(KDefaultColorThemeName);

    }

    return d->mDefaultColor;

}

/*!

    Returns the text alignment. It suports vertical and horizontal alignment.

    \sa HbTextItem::setAlignment()

 */

Qt::Alignment HbTextItem::alignment () const

{

    Q_D( const HbTextItem );

    return d->mAlignment;

}

/*!

    Returns the elide mode of the text.

    This option decide how last line of text is truncated.

    \sa HbTextItem::setElideMode()

 */

Qt::TextElideMode HbTextItem::elideMode () const

{

    Q_D( const HbTextItem );

    return d->mElideMode;

}

/*!

    Sets the text into \a text.

 */

void HbTextItem::setText (const QString &text)

{

    Q_D(HbTextItem);

    QString txt( text );

#ifdef HB_TEXT_MEASUREMENT_UTILITY

    if ( HbFeatureManager::instance()->featureStatus( HbFeatureManager::TextMeasurement ) ) {

        if (text.endsWith(QChar(LOC_TEST_END))) {

            int index = text.indexOf(QChar(LOC_TEST_START));

            setProperty( HbTextMeasurementUtilityNameSpace::textIdPropertyName,  text.mid(index + 1, text.indexOf(QChar(LOC_TEST_END)) - index - 1) );

            setProperty( HbTextMeasurementUtilityNameSpace::textMaxLines, d->mMaxLines );

            txt = text.left(index);

        } else {

            setProperty( HbTextMeasurementUtilityNameSpace::textIdPropertyName,  QVariant::Invalid );

        }

    }

#endif //HB_TEXT_MEASUREMENT_UTILITY

    if (d->mText != txt) {

        d->mInvalidateShownText = true;

        bool rightToLeft = HbTextUtils::ImplicitDirectionalityIsRightToLeft(

            txt.utf16(), txt.length(), 0 );

        d->mTextDirection = rightToLeft ? Qt::RightToLeft : Qt::LeftToRight;

        prepareGeometryChange();

        d->mText = txt;

        d->mTextLayout.setCacheEnabled(KLayoutCacheLimit >= d->mText.length());

        bool onlyHorizonalSizeHintChanged = false;

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

            onlyHorizonalSizeHintChanged = true;

        }

        if ( (sizePolicy().horizontalPolicy()&QSizePolicy::IgnoreFlag) && onlyHorizonalSizeHintChanged ) {

            // suppress updageGeometry() and use the same geometry

            d->setSize( size() );

        } else {

            updateGeometry();

        }

        update();

    }

}

/*!

    Sets the text color into \a color.

    If invalid color is used color from theme will be used.

    \sa HbTextItem::textColor()

 */

void HbTextItem::setTextColor (const QColor &color)

{

    Q_D(HbTextItem);

	d->setApiProtectionFlag(HbWidgetBasePrivate::AC_TextColor, true);

    if (d->mColor != color) {

        d->mColor = color;

        update();

    }

}

/*!

    Sets the text alignment into \a alignment.

    It suports vertical and horizontal alignment.

    \sa HbTextItem::alignment()

 */

void HbTextItem::setAlignment (Qt::Alignment alignment)

{

    Q_D(HbTextItem);

	d->setApiProtectionFlag(HbWidgetBasePrivate::AC_TextAlign, true);

    alignment &= Qt::AlignVertical_Mask | Qt::AlignHorizontal_Mask;

    if (d->mAlignment != alignment) {

        prepareGeometryChange();

        d->mAlignment = alignment;

        d->updateTextOption();

        d->calculateVerticalOffset();

        update();

    }

}

/*!

    Sets the elide mode into \a elideMode.

    The elide mode determines the truncation of the last line of text

    i.e. the "..." usage

    \sa HbTextItem::elideMode()

 */

void HbTextItem::setElideMode (Qt::TextElideMode elideMode)

{

    Q_D(HbTextItem);

    if (elideMode != d->mElideMode) {

        d->mInvalidateShownText = true;

        d->mElideMode = elideMode;

        update();

    }

}

/*!

    \reimp

    Paints text

 */

void HbTextItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)

{

    Q_D(HbTextItem);

    Q_UNUSED(option);

    Q_UNUSED(widget);

     HbWidgetBase::paint(painter, option, widget);

    /* Reverted "text layouting optimization"

    if ( d->mInvalidateShownText ) {

        d->setSize( size() );

    }

    */

    if(!d->mDontPrint) {

        painter->setPen(textColor());

        d->mTextLayout.draw(painter,

                            d->mOffsetPos,

                            QVector<QTextLayout::FormatRange>(),

                            d->mDontClip?QRectF():contentsRect());

    }