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

**

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

#include "hbwidget_p.h"

#include "hbfocusgroup_p.h"

#include "hbevent.h"

#include "hbinstance.h"

#include "hbstyleparameters.h"

#include "hbgraphicsscene.h"

#include "hbgraphicsscene_p.h"

#include "hbdeviceprofile.h"

#include "hbspaceritem_p.h"

#include <QCoreApplication>

#include <QMetaType>

#include <QAction>

#include <QDebug>

#include <QDynamicPropertyChangeEvent>

#include <QGraphicsLayout>

#include <QInputContext>

#ifdef HB_TESTABILITY

/*!

    \internal

 */

static void testabilitySignalEnabledChange(bool enabled, void *param)

{

    HbWidget *widget = static_cast<HbWidget *>(param);

    if (widget) {

        // We need ItemTransformChanged notifications which must be enabled

        // manually by setting the ItemSendsGeometryChanges flag.

        // However this should only be done when the testability signal gets

        // enabled because it causes perf regression.

        widget->setFlag(QGraphicsItem::ItemSendsGeometryChanges, enabled);

    }

}

#endif //HB_TESTABILITY

HbWidgetPrivate::HbWidgetPrivate()

  : HbWidgetBasePrivate(),

    style(0),

    backgroundPrimitiveType(HbStyle::P_None),

    polished(false),

    polishPending(false),

    themingPending(true),

    repolishOutstanding(false),

    notifyScene(false),

    pluginBaseId(0),

    focusGroup(0),

    focusActiveType(HbStyle::P_None),

    focusResidualType(HbStyle::P_None),

    highlightExpired(false),

    backgroundItem(0),

    focusActiveItem(0),

    focusResidualItem(0)

{

    q_ptr = 0;

#ifdef HB_TESTABILITY 

	testabilitySignal = new HbTestabilitySignal_p();

#endif //HB_TESTABILITY 

}

HbWidgetPrivate::~HbWidgetPrivate()

{

    if (backgroundItem) {

        delete backgroundItem;

        backgroundItem = 0;

    }

    // need to delete the hash values

    QList<QGraphicsLayoutItem *> deletedSpacers = mSpacers.values();

    mSpacers.clear();

    qDeleteAll( deletedSpacers );            

}

/*!

    Creates a new spacer item with the given \a name.

    Returns a pointer to the newly created spacer item. Widget keeps the ownership.

*/

QGraphicsLayoutItem *HbWidgetPrivate::createSpacerItem( const QString &name )

{

#ifndef Q_OS_SYMBIAN

    Q_ASSERT( !name.isEmpty() );

    // check in desktop environments that the item does not exist already

    Q_ASSERT( !mSpacers.contains( name ) );

#endif

    HbSpacerItem *newSpacer = new HbSpacerItem();

    mSpacers.insert( name, newSpacer );

    return newSpacer;

}

/*

    \deprecated HbWidget::setBackgroundItem(HbStyle::Primitive, int)

    is deprecated. Use HbWidget::setBackgroundItem(QGraphicsItem *item, int zValue) instead.

    Creates background item to the widget from style primitive.

    Creates a new background item to the widget and the reparents it to

    be child of the widget. Also Z-value of the background item will be 

    changed to zValue. By default the zValue is -1, which should be 

    behind other widget content. Background item will be always resized 

    to be same size as the widgets bounding rect. 

    If type is HbStyle::P_None, the background item will be removed from

    widget.

    Previously set background item will be deleted.

 */

void HbWidget::setBackgroundItem(HbStyle::Primitive type, int zValue)

{

    Q_D(HbWidget);

    if(type!=d->backgroundPrimitiveType || type == HbStyle::P_None) {

        if (d->backgroundItem) {

            delete d->backgroundItem;

            d->backgroundItem = 0;

        }

        d->backgroundPrimitiveType = type;

        d->backgroundItem = style()->createPrimitive(d->backgroundPrimitiveType, const_cast<HbWidget*>(this));

        if(d->backgroundItem) {

            d->backgroundItem->setParentItem(this);

        }

        updatePrimitives();

    }

    if(d->backgroundItem && zValue != d->backgroundItem->zValue()) {

        d->backgroundItem->setZValue(zValue);

    }

}

/*

    Sets background item to the widget.

    The item will be reparented to be child of the widget. Also Z-value 

    of the background item will be changed to be zValue. By default the 

    zValue is -1, which should be  behind other widget content. 

    Background item will be always resized to be same size as widgets 

    bounding rect. If background item is widget, the size will 

    be changed with setGeometry to allow e.g. maintaining aspect ratio of 

    images. If item is not widget, the size will be changed with 

    transformations. 

    If item is 0, the background item will be removed from the widget.

    Previously set background item will be deleted.

 */

void HbWidget::setBackgroundItem(QGraphicsItem *item, int zValue)

{

    Q_D(HbWidget);

    if(d->backgroundItem) {

        delete d->backgroundItem;

        d->backgroundItem = 0;

    }

    d->backgroundPrimitiveType = HbStyle::P_None;

    d->backgroundItem = item;

    if(d->backgroundItem) {

        d->backgroundItem->setParentItem(this);

        d->backgroundItem->setZValue(zValue);

        d->updateBackgroundItemSize();

    }

}

/*

    Returns background item. 0 is returned if there isn't background

    item in the widget.

 */

QGraphicsItem *HbWidget::backgroundItem() const

{

    Q_D( const HbWidget );

    return d->backgroundItem;

}

/*

    Returns focusItem primitive items.

    Focus primitive is created if has not been created already.

 */

QGraphicsItem *HbWidgetPrivate::focusPrimitive(HbWidget::FocusHighlight highlightType) const

{

    Q_Q(const HbWidget);

    if (highlightType == HbWidget::FocusHighlightActive) {

        if (!focusActiveItem && focusActiveType != HbStyle::P_None) {

            focusActiveItem = q->style()->createPrimitive(

                                focusActiveType, const_cast<HbWidget*>(q));

            focusActiveItem->hide();

        }

        return focusActiveItem;

    } else if (highlightType == HbWidget::FocusHighlightResidual) {

        if (!focusResidualItem && focusResidualType != HbStyle::P_None) {

            focusResidualItem = q->style()->createPrimitive(

                                focusResidualType, const_cast<HbWidget*>(q));

            focusResidualItem->hide();

        }

        return focusResidualItem;

    }

    return 0;

}

/*

    Hides or shows focus primitive depending on the focus state of the widget.

*/

void HbWidgetPrivate::focusChangeEvent(HbWidget::FocusHighlight focusHighlight)

{

    Q_Q(HbWidget);

    bool activeHighlight(false);

    bool residualHighlight(false);

    HbFocusGroup *group = getFocusGroup();

    // Do not show focus if there is focus group and the flag is NeverOn.

    if (group && (group->focusParameters() == HbFocusGroup::NeverOn)) {

        return;

    }

    if (group) {

        group->stopHighlightTimer(q);

        }

    if (focusHighlight == HbWidget::FocusHighlightActive) {

        activeHighlight = true;

        if (group) {

           highlightExpired = false;

           group->startHighlightTimer(q);

        }

    } else if (focusHighlight == HbWidget::FocusHighlightResidual) {

        residualHighlight = true;

    }

    if (focusActiveItem) {

        focusActiveItem->setVisible(activeHighlight);

        focusActiveItem->update();         

    }

    if (focusResidualItem) {

        focusResidualItem->setVisible(residualHighlight);

        focusResidualItem->update();

    }

}

/*

    Find closest parent with focus group and update the focused child.

*/

void HbWidgetPrivate::updateCurrentFocusChild()

{

    Q_Q(HbWidget);

    HbFocusGroup *group = getFocusGroup();

    if (group) {

        group->updateCurrentFocusChild(q);

    }

}

/*

    Find and return the closest parent with focus group if any. If propagate

    is true then the closest parent with focus group and children is accepted as

    valid focus group e.g. used for a widget which has the key for changing the 

    focus mode set only.

*/

HbFocusGroup *HbWidgetPrivate::getFocusGroup(bool propagate) const {

    Q_Q(const HbWidget);

    HbFocusGroup *group(0);

    const QGraphicsItem* item(q);

    bool stop(false);

    const QGraphicsWidget *w = static_cast<const QGraphicsWidget *>(item);

    while (!stop && w) {

        const HbWidget* widget = qobject_cast<const HbWidget *>(w);

        if (widget)  {

            group = widget->d_func()->focusGroup;

            if (!propagate) {

                stop = true;

            }

            if (group && !stop) {

                stop = group->isChildrenRegistered();

            }

            if (!stop) {

                w = w->parentWidget();

            }

        } else {

            break;

        };

    }

    return (group) ? group : 0;

}

/*

    Set focus to child widget depending on the set focus delegation

    policy. 

*/

bool HbWidgetPrivate::delegateFocus(QFocusEvent *event) const

{

    return (focusGroup) ? focusGroup->delegateFocus(event) : false;

}

void HbWidgetPrivate::updateBackgroundItemSize()

{

    Q_Q(HbWidget);

    if(backgroundItem) {

        if(backgroundItem->isWidget()) {

            static_cast<QGraphicsWidget*>(backgroundItem)->setGeometry(q->boundingRect());

        } else {

            QRectF widgetRect = q->boundingRect();

            QRectF backgroundRect = backgroundItem->boundingRect();

            if(backgroundRect.width() != 0 && backgroundRect.height() != 0) {

                backgroundItem->setTransform(

                    QTransform().scale(widgetRect.width()/backgroundRect.width(), 

                                       widgetRect.height()/backgroundRect.height()));

            }

        }

    }

}

/*

    Test if some item in our parent hierarchy has

    the Hb::InputMethodNeutral flag set.

*/

bool HbWidgetPrivate::isInputMethodNeutral()

{

    Q_Q(HbWidget);

    // Test the widget itself...

    if(q->testAttribute(Hb::InputMethodNeutral)) {

        return true;

    }

    // and then all parents

    QGraphicsWidget* i = q->parentWidget();

    while(i) {

        HbWidget* w = qobject_cast<HbWidget *>(i);

        if(w && w->testAttribute(Hb::InputMethodNeutral)) {

            return true;

        }

        i = i->parentWidget();

    }

    return false;

}

/*!

    \class HbWidget

    \brief HbWidget is a base for all Hb widgets. It contains common functionality

    for widgets and offers virtual methods to be overridden in derived widgets.

    Currently HbWidget offers the following functionality:

        - Accessing style primitives

        - Accessing font specification property

        - Accessing platform style object and setting widget specific style

        - Handling focus in/out events (to support proper focus management)                   

*/

/*!

    \enum HbWidget::FocusDelegation

    Defines focus delegation policy for the focus group. Focus is delegated to child widgets

    according to the policy.

    \sa setFocusDelegation() focusDelagation()

*/

/*!

    \var HbWidget::FocusDelegationNone

    Focus is not delegated to child widgets. Instead the focus group itself has the focus.

*/

/*!

    \var HbWidget::FocusDelegationFirstChild

    Focus is delegated to first widget in the focus chain. Direction does not effect this.

*/

/*!

    \var HbWidget::FocusDelegationLastChild

    Focus is delegated to last widget in the focus chain. Direction does not effect this.

*/

/*!

    \var HbWidget::FocusDelegationBasedOnDirection

    Focus is given to first widget in focus chain, when focus movement is to next widget,

    and to last widget, when focus movement is to previous widget.

*/

/*!

    \var HbWidget::FocusDelegationFocusedChild

    Focus is given to the widget which was focused when focus group lost the focus

*/

/*!

    \enum HbWidget::FocusMode

    Focus group has focus mode attribute that can be used in situations where it would

    be impossible to determine whether focus should be moved from widget or should the

    widget handle the event.

    \sa setFocusMode() focusMode()

*/

/*!

    \var HbWidget::FocusModeNormal

    In normal mode only the focus change is performed, event is not passed to widget.

*/

/*!

    \var HbWidget::FocusModeEdit

    In edit mode event is passed to widget and the focus change is performed if widget

    did not accept the event.

*/

/*!

    \enum HbWidget::FocusHighlight

    Defines the highlight for the widget.

    \sa setFocusHighlight() focusHighlight()

*/

/*!

    \var HbWidget::FocusHighlightNone

    No focus highlight set for the widget. If active or residual highlight have alraedy been set,

    then FocusHightlightNone removes both highlights.

*/

/*!

    \var HbWidget::FocusHighlightActive

    Defines the active highlight for the widget.

*/

/*!

    \var HbWidget::FocusHighlightResidual

    Defines the residual highlight for the widget.

*/

/*!

    \fn int HbWidget::type() const

    Reimplemented from QGraphicsItem::type().

 */

/*!

    Constructs a widget with the parent item and window flags.

    This constructor creates a new HbWidgetPrivate instance and installs it to the widget.

*/

HbWidget::HbWidget( QGraphicsItem *parent, Qt::WindowFlags wFlags ):

    HbWidgetBase( *new HbWidgetPrivate, parent, wFlags )

{

    Q_D( HbWidget );

    d->q_ptr = this;

#ifdef HB_TESTABILITY 

	if(d->testabilitySignal) {

		d->testabilitySignal->setParent(this);

		d->testabilitySignal->notifySignalEnabled(testabilitySignalEnabledChange, this);

	}

#endif //HB_TESTABILITY

}

/*!

    Constructs a widget with the given private object, parent item and window flags.

    The given HbWidgetPrivate instance is installed in the widget and deleted in its destructor.

*/

HbWidget::HbWidget(HbWidgetPrivate &dd, QGraphicsItem *parent, Qt::WindowFlags wFlags):

    HbWidgetBase( dd, parent, wFlags )

{

    Q_D( HbWidget );

    d->q_ptr = this;

#ifdef HB_TESTABILITY 

	if (d->testabilitySignal) {

		d->testabilitySignal->setParent(this);

		d->testabilitySignal->notifySignalEnabled(testabilitySignalEnabledChange, this);

	}

#endif //HB_TESTABILITY

}

/*!

 Destroys the widget.

*/

HbWidget::~HbWidget()

{

}

/*! 

    FocusIn event hadler.

 */

void HbWidget::focusInEvent(QFocusEvent *event)

{

    Q_UNUSED( event );

    Q_D(HbWidget);

    // Return if focus is delegated

    if (d->delegateFocus(event)) {

        return;

    }

    if (d->focusPrimitive(HbWidget::FocusHighlightActive)) {

        d->focusChangeEvent(HbWidget::FocusHighlightActive);

    }

    d->updateCurrentFocusChild();

    if (parentWidget()) {

        // It is must to notify parent widget that child widget has got focus

        //Start of snippet 1

        HbEvent event1( HbEvent::ChildFocusIn);

        QCoreApplication::sendEvent( parentWidget(), &event1 );        

        //End of snippet 1

    }

#if QT_VERSION >= 0x040600