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

**

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

#include "hbstyleparameters.h"

#include "hbgraphicsscene.h"

#include "hbgraphicsscene_p.h"

#include "hbdeviceprofile.h"

#include "hbtapgesture.h"

#include "hbnamespace_p.h"

#include "hbstyle_p.h"

#include <QCoreApplication>

#include <QMetaType>

#include <QAction>

#include <QDebug>

#include <QDynamicPropertyChangeEvent>

#include <QGraphicsLayout>

#include <QInputContext>

/*!

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

    }

}

HbWidgetPrivate::HbWidgetPrivate()

  : HbWidgetBasePrivate(),

    style(0),

    backgroundPrimitiveType(HbStylePrivate::P_None),

    polished(0),

    polishPending(false),

    themingPending(true),

    repolishOutstanding(false),

    mHandlingRepolishSynchronously(false),

    notifyScene(false),

    focusGroup(0),

    focusActiveType(HbStylePrivate::P_None),

    focusResidualType(HbStylePrivate::P_None),

    highlightExpired(false),

    backgroundItem(0),

    focusActiveItem(0),

    focusResidualItem(0)

{

    q_ptr = 0;

    testabilitySignal = new HbTestabilitySignal_p();

}

void HbWidgetPrivate::init()

{

    Q_Q(HbWidget);

    q->setAttribute(Hb::Widget, true);

    if (testabilitySignal) {

        testabilitySignal->setParent(q);

        testabilitySignal->notifySignalEnabled(testabilitySignalEnabledChange, q);

    }

}

HbWidgetPrivate::~HbWidgetPrivate()

{

    if (backgroundItem) {

        delete backgroundItem;

        backgroundItem = 0;

    }

}

void HbWidgetPrivate::setBackgroundItem(HbStylePrivate::Primitive type, int zValue)

{

    Q_Q(HbWidget);

    if(type!=backgroundPrimitiveType || type == HbStylePrivate::P_None) {

        if (backgroundItem) {

            delete backgroundItem;

            backgroundItem = 0;

        }

        backgroundPrimitiveType = type;

        backgroundItem = HbStylePrivate::createPrimitive(backgroundPrimitiveType, const_cast<HbWidget*>(q));

        if(backgroundItem) {

            backgroundItem->setParentItem(q);

        }

    q->updatePrimitives();

}

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

        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 = HbStylePrivate::P_None;

    d->backgroundItem = item;

    if(d->backgroundItem) {

        d->backgroundItem->setParentItem(this);

        d->backgroundItem->setZValue(zValue);

        d->updateBackgroundItemSize();

    }

    updatePrimitives();

}

/*!

    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 != HbStylePrivate::P_None) {

            focusActiveItem = HbStylePrivate::createPrimitive(

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

            focusActiveItem->hide();

        }

        return focusActiveItem;

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

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

            focusResidualItem = HbStylePrivate::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()));

            }

        }

    }

}

/*!

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

    d->init();

}

/*!

    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;

    d->init();

}

/*!

 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

    }

}

/*! 

    FocusOut event hadler.

 */

void HbWidget::focusOutEvent( QFocusEvent *event )

{

    Q_UNUSED( event );

    Q_D(HbWidget);

    // Hide focus highlight.

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

        d->focusChangeEvent(HbWidget::FocusHighlightResidual);

    } else {

        d->focusChangeEvent(HbWidget::FocusHighlightNone);

    }

    if ( parentWidget() ) {

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

        HbEvent event1( HbEvent::ChildFocusOut);

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

    }

}

/*!

    \reimp

 */

void HbWidget::resizeEvent(QGraphicsSceneResizeEvent *event)

{

    Q_D(HbWidget);

    HbWidgetBase::resizeEvent(event);

    d->updateBackgroundItemSize();

}

/*!

    Sets a custom style for the widget. 

    When a new style is set for the widget the widget's primitives need to recreated and primitives and layout updated.

    In order for the style change to work each widget needs to override recreatePrimitives() method and recreate the

    primitives. 

    \param style Custom style for the widget, note that the ownership is not transferred

*/

void HbWidget::setStyle( HbStyle *style )

{

    Q_D( HbWidget );

    d->style = style;

    recreatePrimitives();

    repolish();

    updatePrimitives();

}

/*!

    As a default returns the hbInstance's platform style. If style is set using

    the setStyle then the set style is returned.

*/

HbStyle *HbWidget::style() const

{

    Q_D( const HbWidget );

    if( d->style )