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

**

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

#include <QMetaType>

#include <QAction>

#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),

    polishPending(false),

    themingPending(true),

    repolishOutstanding(false),

    mHandlingRepolishSynchronously(false),

    notifyScene(false),

    focusGroup(0),

    highlightExpired(false),

    backgroundItem(0),

    focusActiveItem(0),

{

    q_ptr = 0;

}

HbWidgetPrivate::~HbWidgetPrivate()

{

    if (backgroundItem) {

        delete backgroundItem;

        backgroundItem = 0;

    }

}

{

    Q_Q(HbWidget);

        backgroundPrimitiveType = type;

        }

    }

} 

/*!

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

    }

}

/*!

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

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

            focusActiveItem->hide();

        }

        return focusActiveItem;

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

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

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

        if (group) {

           highlightExpired = false;

           group->startHighlightTimer(q);

        }

    }

    }

}

/*!

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

        } else {

            QRectF widgetRect = q->boundingRect();

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

                    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.

*/

/*!