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

**

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

#include "hbrichtextitem_p.h"

#include "hbtextutils_p.h"

#include "hbcolorscheme.h"

#include "hbevent.h"

#include <QTextDocument>

#include <QStyle>

#include <QGraphicsSceneResizeEvent>

#include <QTextBlock>

#include <QTextLayout>

#include <QPainter>

#include <QAbstractTextDocumentLayout>

#include <QApplication>

#include <QWidget>

#include <QStyleOptionGraphicsItem>

const qreal KMinimumRichTextWidth = 6.0;

static const QString KDefaultColorThemeName = "qtc_view_normal";

HbRichTextItemPrivate::HbRichTextItemPrivate() :

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

        mRtf(0)

{

}

HbRichTextItemPrivate::~HbRichTextItemPrivate()

{

}

/*

 * private constructor

 */

void HbRichTextItemPrivate::init()

{

    Q_Q(HbRichTextItem);

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

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

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

    mRtf = new QTextDocument(q);

    mRtf->setDocumentMargin(0.0); // no margins needed

    mTextOption.setWrapMode(QTextOption::NoWrap);

    mRtf->setDefaultTextOption(mTextOption);

    mRtf->setDefaultFont(q->font());

}

void HbRichTextItemPrivate::clear()

{

}

void HbRichTextItemPrivate::setDocumentWidth(qreal newWidth)

{

    if (!qFuzzyCompare(mRtf->textWidth(), newWidth)) {

        mRtf->setTextWidth(newWidth);

        calculateOffset();

    }

}

// #define HB_RICH_TEXT_ITEM_ALWAS_SHOW_FIRST_LINE

void HbRichTextItemPrivate::calculateOffset()

{

    Q_Q(HbRichTextItem);

    qreal diff;

    Qt::Alignment align = mTextOption.alignment();

    if (align.testFlag(Qt::AlignTop)) {

        diff = 0.0;

    } else {

        diff = q->geometry().height() - mRtf->size().height();

        if (!align.testFlag(Qt::AlignBottom)) {

            // default align Qt::AlignVCenter if no flags are set

            diff*=0.5;

        }

    }

#ifdef HB_RICH_TEXT_ITEM_ALWAS_SHOW_FIRST_LINE

    diff = qMax(diff, (qreal)0.0);

#endif

    if (diff!=mOffset.y()) {

        mOffset.setY(diff);

        q->prepareGeometryChange();

    }

}

QSizeF HbRichTextItemPrivate::minimumSizeHint(const QSizeF &/*constraint*/) const

{

    QSizeF result(KMinimumRichTextWidth, 0);

    QTextBlock textBlock = mRtf->begin();

    if (textBlock.isValid() && textBlock.layout()->lineCount() > 0) {

        QTextLine line = textBlock.layout()->lineAt(0);

        result.setHeight(line.height());

    } else {

        QFontMetricsF metrics(mRtf->defaultFont());

        result.setHeight(metrics.height());

    }

    qreal doubleDocMargin = mRtf->documentMargin() * (qreal)2.0;

    result.rheight() += doubleDocMargin;

    result.rwidth() += doubleDocMargin;

    return result;

}

void HbRichTextItemPrivate::clearPrefSizeCache()

{

    mPrefSize.setWidth(-1);

    mMinWidthForAdjust = QWIDGETSIZE_MAX;

    mMaxWidthForAdjust = -1;

}

QSizeF HbRichTextItemPrivate::preferredSizeHint(const QSizeF &constraint) const

{

    if (mPrefSizeConstraint==constraint && mPrefSize.isValid()) {

        return mPrefSize;

    }

    mPrefSizeConstraint=constraint;

    QSizeF result;

    if (constraint.width()<=0) {

        mRtf->setTextWidth(QWIDGETSIZE_MAX);

    } else {

        QTextOption::WrapMode wrapMode = mTextOption.wrapMode();

        // optimization when there is no automatic wrap there is no reason

        // to setTextWidth with width constraint (width measure is not needed)

        if (wrapMode!=QTextOption::NoWrap

            && wrapMode!=QTextOption::ManualWrap) {

            mRtf->setTextWidth(constraint.width());

        }

    }

    result = mRtf->size();

    mMaxWidthForAdjust = result.width();

    result.setWidth(mRtf->idealWidth());

    mMinWidthForAdjust = result.width();

    mDefaultPrefHeight = result.height();

    mPrefSize = result;

    return result;

}

bool HbRichTextItemPrivate::isAdjustHeightNeeded(qreal newWidth,

                                                 qreal prefHeight,

                                                 qreal minHeight,

                                                 qreal maxHeight)

{

    // first check if wrapping of text is not active

    QTextOption::WrapMode wrapMode = mTextOption.wrapMode();

    if (wrapMode==QTextOption::NoWrap

        || wrapMode==QTextOption::ManualWrap) {

        return false;

    }

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

    if (mPrefSizeConstraint.height()>0) {

        return false;

    }

    // check if adjusted size has been already calculated

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

    if ((mMaxWidthForAdjust>=newWidth

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

         && newWidth>=mMinWidthForAdjust)) {

        return false;

    }

    if (!mPrefSize.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;

    }

    // new text width was set in setGeometry here it is not needed

    Q_ASSERT_X(qFuzzyCompare(mRtf->textWidth(), newWidth),

               "HbRichTextItemPrivate::isAdjustHeightNeeded",

               QString("mRtf->textWidth()=%1, newWidth=%2")

                    .arg(mRtf->textWidth())

                    .arg(newWidth).toAscii().data());

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

    QSizeF newAdjust = mRtf->size();

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

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

        mMaxWidthForAdjust = qMax(mMaxWidthForAdjust, newWidth);

        mMinWidthForAdjust = qMin(mMinWidthForAdjust, newWidth);

        return false;

    }

    // new height was calculated create new range for which

    // current mPrefSize.height is valid

    mMaxWidthForAdjust = newWidth;

    mMinWidthForAdjust = mRtf->idealWidth();

    // store new height, don't change width

    mPrefSize.setHeight(newAdjust.height());

    Q_ASSERT_X(mPrefSizeConstraint.width()>0 || mPrefSize.width()>=mMinWidthForAdjust,

               "HbRichTextItemPrivate::isAdjustHeightNeeded",

               QString("Fail for (%1<%2) string: \"%3\"")

               .arg(mPrefSize.width())

               .arg(mMinWidthForAdjust)

               .arg(mText).toAscii().data());

    if (qFuzzyCompare(qBound(minHeight, mPrefSize.height(), maxHeight),

                      prefHeight)) {

        // updateGeometry has no effect

        return false;

    }

    // all conditions for calling updateGeometry are meet

    return true;

}

/*

    returns true if updateGeometry is needed

 */

bool HbRichTextItemPrivate::restoreDefaultHeightHint()

{

    if (mPrefSizeConstraint.height()>0) {

        return false;

    }

    if (mPrefSizeConstraint.width()>0) {

        clearPrefSizeCache();

        return true;

    }

    if (mPrefSize.height()==mDefaultPrefHeight) {

        return true;

    }

    mPrefSize.setHeight(mDefaultPrefHeight);

    mMinWidthForAdjust = mPrefSize.width();

    mMaxWidthForAdjust = QWIDGETSIZE_MAX;

    return true;

}

/*!

  @proto

  @hbcore

 \class HbRichTextItem

 \brief HbRichTextItem is a item for showing formatted text.

 This is mainly used as a primitive in widgets.

 It derives from HbWidgetBase so it can be layouted.

 */

/*!

    Constructor for the class.

 */

HbRichTextItem::HbRichTextItem(QGraphicsItem *parent) :

        HbWidgetBase(*new HbRichTextItemPrivate, parent)

{

    Q_D(HbRichTextItem);

    d->init();

}

/*!

    Constructor which set content using \a html format.

 */

HbRichTextItem::HbRichTextItem(const QString &html, QGraphicsItem *parent) :

        HbWidgetBase(*new HbRichTextItemPrivate, parent)

{

    Q_D(HbRichTextItem);

    d->init();

    setText(html);

}

/*

    Constructor for internal use only

 */

HbRichTextItem::HbRichTextItem(HbRichTextItemPrivate &dd, QGraphicsItem *parent) :

        HbWidgetBase(dd, parent)

{

    Q_D(HbRichTextItem);

    d->init();

}

/*!

    Destructor for the class.

 */

HbRichTextItem::~HbRichTextItem()

{

    Q_D(HbRichTextItem);

    d->clear();

}

/*!

    Sets the \a text in html format.

    \sa HbRichTextItem::text()

 */

void HbRichTextItem::setText(const QString &text)

{

    Q_D(HbRichTextItem);

    if (d->mText != text) {

        d->mText = text;

        d->mRtf->setHtml(text);

        d->clearPrefSizeCache();

        updateGeometry();

    }

}

/*!

    Returns the text in html format.

    \sa HbRichTextItem::setText()

 */

QString HbRichTextItem::text() const

{

    Q_D(const HbRichTextItem);

    return d->mText;

}

/*!

    Sets \a alignment for the text from Qt::Alignment enumeration.

    \sa HbRichTextItem::alignment()

 */

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

{

    Q_D(HbRichTextItem);

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

    if (d->mTextOption.alignment()!=alignment) {

        prepareGeometryChange();

        d->mTextOption.setAlignment(alignment);

        d->mRtf->setDefaultTextOption(d->mTextOption);

        d->calculateOffset();

        update();

    }

}

/*!

    Returns alignment for the text from Qt::Alignment enumeration.

    \sa HbRichTextItem::setAlignment()

 */

Qt::Alignment HbRichTextItem::alignment() const

{

    Q_D(const HbRichTextItem);

    return d->mTextOption.alignment();

}

/*!

    \reimp

 */

void HbRichTextItem::paint(QPainter *painter, 

                           const QStyleOptionGraphicsItem *option,

                           QWidget *widget)

{

    Q_UNUSED(widget);

    Q_D(HbRichTextItem);

    painter->translate(d->mOffset);

    QAbstractTextDocumentLayout::PaintContext context;

    context.clip = option->exposedRect;

    context.palette.setColor(QPalette::Text, textDefaultColor());

    d->mRtf->documentLayout()->draw(painter, context);

    painter->translate(-d->mOffset);

}

/*!

    \reimp

    Sets new position and relayouts text according to new size.

 */

void HbRichTextItem::setGeometry(const QRectF & rect)

{

    Q_D(HbRichTextItem);

    HbWidgetBase::setGeometry(rect);

    // this call is needed since there is possible scenario

    // when size was not changed after updateGeometry and sizeHint calls

    d->setDocumentWidth(size().width());

    if (parentLayoutItem() && parentLayoutItem()->isLayout()) {

        // rect.size can't be used here since size can be limited inside of

        // called method HbWidgetBase::setGeometry(rect) so size is used which

        // holds current size

        if (d->isAdjustHeightNeeded(size().width(),

                                    preferredHeight(),

                                    minimumHeight(),

                                    maximumHeight())) {

            updateGeometry();

            return;

        }

    }

}

/*!

    \reimp

 */

QRectF HbRichTextItem::boundingRect () const

{

    Q_D(const HbRichTextItem);

    QRectF result(d->mRtf->documentLayout()->frameBoundingRect(d->mRtf->rootFrame()));

    result.translate(d->mOffset);

    if (flags().testFlag(QGraphicsItem::ItemClipsToShape)) {

        // clip

        result = result.intersect(contentsRect());

    }

    return result;

}

/*!

    \reimp

    Relayouts text according to new size.

 */

void HbRichTextItem::resizeEvent(QGraphicsSceneResizeEvent * /*event*/)

{

    Q_D(HbRichTextItem);

    d->setDocumentWidth(size().width());

    d->calculateOffset();

}

/*!

    \reimp

    This implementation detects layout direction changes, font changes and theme changes.

 */

void HbRichTextItem::changeEvent(QEvent *event)

{

    Q_D(HbRichTextItem);

    switch(event->type()) {

    case QEvent::LayoutDirectionChange: {

            prepareGeometryChange();

            d->mTextOption.setTextDirection(layoutDirection());

            d->mRtf->setDefaultTextOption(d->mTextOption);

            update();

        }

        break;

    case QEvent::FontChange: {

            d->mRtf->setDefaultFont(font());

            d->clearPrefSizeCache();

            updateGeometry();

        }

        break;

    default:

        // Listens theme changed event so that item size hint is

        // update when physical font is changed.

        if (event->type() == HbEvent::ThemeChanged) {

            Q_D(HbRichTextItem);

            d->mDefaultColor = QColor();

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

                update();

            }

        }

    }

    HbWidgetBase::changeEvent(event);

}

/*!