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

**

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

#include "hbdataformviewitem_p.h"

#include "hbabstractitemcontainer_p_p.h"

#include "hbdataformmodelitem_p.h"

#include "hbdataform_p.h"

#include "hbdatagroup_p.h"

#include "hbstyleoptiondataformviewitem_p.h"

#include <hbtapgesture.h>

#ifdef HB_EFFECTS

#include "hbeffect.h"

#include "hbeffectinternal_p.h"

#define HB_DATAFORMVIEWITEM_TYPE "HB_DATAFORMVIEWITEM"

#endif

/*!

    @beta

    @hbwidgets

    \class HbDataFormViewItem

    \brief HbDataFormViewItem represents an item view in HbDataForm corresponding to model item.

    Each HbDataFormModelItem added inside model is represented using HbDataFormViewItem instance.

    HbDataFormViewItem have different visualization based upon the 

    HbDataFormModelItem::DataItemType:

    - FormPageItem: This type does not have any visualization. Whatever QString is passed while

        creating HbDataFormModelItem, is added in a combo box at the top level view. User can 

        switch between different form page using this combo.

    - GroupItem: A visualization is created for this type. Visualization includes +/- icon and 

        group heading. User can expand and collapse the group by clicking any where in 

        HbDataFormViewItem of this type. Whatever QString is passed while creating

        HbDataFormModelItem for this type is set as a group heading.

    - GroupPageItem: This type does not have any visualization. Whatever QString is passed while

        creating HbDataFormModelItem, is added in a group combo box. User can switch between 

        different group page using this combo.

    - DataItems: Any type other then FormPageItem, GroupItem and GroupPageItem is treated as

        a data item. Data item can contain label, description, icon and content widget. Data items

        can not have any children. They are always placed at the leaf. Data item content widget 

        can be set using HbDataFormModelItem::ItemTypeRole, label of data items can be set using 

        HbDataFormModelItem::LabelRole, description of data item can be set using 

        HbDataFormModelItem::DescriptionRole.

    If HbDataFormViewItem represents a GroupItem then it can be expanded and collapsed. 

    If group is expanded then all the child items are shown.

    If user wants to create a custom data item then he has to derive from this class and set that

    as a prototype for HbDataForm using HbAbstractItemView::setItemPrototype API. While creating

    data for custom data items user should pass value greater than or equal to 

    DataItemType::CustomItemBase. When visualization is created and if data item type is

    custom item then createCustomWidget() is called. User has to override this API and pass the

    custom widget which he wants to show in data item. Below is the code snippet:

    \code

    //Derive a class from HbDataFormViewItem

    class DataFormCustomItem : public HbDataFormViewItem

    {

        Q_OBJECT

    public:

        DataFormCustomItem(QGraphicsItem *parent);

        ~DataFormCustomItem();

        virtual HbAbstractViewItem* createItem()

        {

            return new DataFormCustomItem(*this);

        }

    protected:

        //Override createCustomWidget API

        virtual HbWidget* createCustomWidget()

        {

            HbDataFormModelItem::DataItemType itemType = static_cast<HbDataFormModelItem::DataItemType>(

            modelIndex().data(HbDataFormModelItem::ItemTypeRole).toInt());

            switch(itemType){

                case HbDataFormModelItem::CustomItemBase:{

                    //Create widget which you want for this data item

                    HbWidget *widget = new HbWidget();

                    QGraphicsLinearLayout *layout = new QGraphicsLinearLayout(Qt::Horizontal);

                    widget->setLayout(layout);

                    HbLineEdit *button1 = new HbLineEdit();

                    layout->addItem(button1);

                    HbLabel *label = new HbLabel(QString("testing label"));

                    layout->addItem(label);

                    //Return the custom widget created

                    return widget;

                }

                //Some other cases can also be added if there are more than one custom data item

            default:

                return 0;

            }

        }

    private:

        Q_DECLARE_PRIVATE_D(d_ptr, DataFormCustomItem)

    };

    //some were is your application

    ContentWidget::ContentWidget(QGraphicsItem *parent)

    {

        HbDataForm *form = new HbDataForm();

        DataFormCustomItem *myPrototype = new DataFormCustomItem();

        form->setItemPrototype(myPrototype);

    }

    \endcode

    The signals emitted by this class are:

    \li itemShown(const QModelIndex&) This signal is emitted when ever this item becomes visible.

    Refer HbDataForm documentation for sample code.

    \sa HbDataForm, HbDataFormModel, HbDataFormModelItem

*/

/*!

    Constructs HbDataFormViewItem with given \a parent.

    \param parent parent .

 */

HbDataFormViewItem::HbDataFormViewItem(QGraphicsItem *parent):

    HbAbstractViewItem(*new HbDataFormViewItemPrivate(this), parent)

{

    Q_D(HbDataFormViewItem);

    d->q_ptr = this;

}

/*!

    Destructs the HbDataFormViewItem.

*/

HbDataFormViewItem::~HbDataFormViewItem()

{

}

/*!

    \reimp

    Creates HbDataFormViewItem. This function is called from HbAbstractItemContainer 

    when model is getting parsed for creating items. 

 */

HbAbstractViewItem* HbDataFormViewItem::createItem()

{

    return new HbDataFormViewItem(*this);

}

/*!

    \reimp

    Returns true if \a model index is supported by HbDataFormViewItem prototype, otherwise returns false.

    This function is called for every item on the prototype list (if several prototypes exist)

    until item is found, which can create view item for \a index.

    \sa HbAbstractItemView::setItemPrototype(HbAbstractViewItem *prototype)

    \sa HbAbstractItemView::setItemPrototype(const QList<HbAbstractViewItem *> &prototypes)

 */

bool HbDataFormViewItem::canSetModelIndex(const QModelIndex &index) const

{

    HbDataFormModelItem::DataItemType itemType = 

        static_cast<HbDataFormModelItem::DataItemType>(

        index.data(HbDataFormModelItem::ItemTypeRole).toInt());

    if( ( itemType >= HbDataFormModelItem::SliderItem 

        && itemType < HbDataFormModelItem::CustomItemBase ) ) {

        return true;

    } else {

        return false;

    }

}

/*!

    \reimp

    Updates child graphics items to represent current state and content stored in model. In case when 

    HbDataFormViewItem represents data item and DataItemType is set to custom item, then 

    createCustomWidget is called. User can override createCustomWidget and can pass his own

    custom widget.

    \sa createCustomWidget

*/

void HbDataFormViewItem::updateChildItems()

{

    Q_D( HbDataFormViewItem );

    d->init();

    //this will create the visualization for all standard data items

    d->createContentWidget( );

    //set the label in data iem

    QString itemLabel = d->mIndex.data( HbDataFormModelItem::LabelRole ).toString( );

    d->setLabel( itemLabel );

    // set the icon in data item

    QString icon = d->mIndex.data( Qt::DecorationRole ).toString( );

    d->setIcon( icon );

    // set the description of data item

    QString itemDescription = d->mIndex.data( HbDataFormModelItem::DescriptionRole ).toString();

    d->setDescription( itemDescription );

    //update visualization based on whether item is enabled or disabled

    HbDataFormModel* data_model = static_cast<HbDataFormModel*>(itemView()->model());

    HbDataFormModelItem *model_item = 

        static_cast<HbDataFormModelItem*>(data_model->itemFromIndex(d->mIndex));

    d->setEnabled(model_item->isEnabled());

#ifdef HB_EFFECTS

    //HbEffectInternal::add( HB_DATAFORMVIEWITEM_TYPE,"dataform_expand", "expanded" );

    //HbEffect::start( settingItem, HB_DATAFORMVIEWITEM_TYPE, "expanded" );  

#endif

    restore( );

    // Establish Signal Connections set in HbDataFormModel to th contentWidget of this item

    HbDataFormPrivate::d_ptr(

        static_cast<HbDataForm*>(d->mSharedData->mItemView))->makeConnection(

        d->mIndex.operator const QModelIndex & (),d->mContentWidget);

    //update only the background primitive

    HbStyleOptionDataFormViewItem options;

    initStyleOption(&options);

    if( d->mBackgroundItem ) {

        style()->updatePrimitive(

            d->mBackgroundItem, HbStyle::P_DataItem_background, &options );

    }

}

/*!

    \protected constructor

*/

HbDataFormViewItem::HbDataFormViewItem(HbDataFormViewItemPrivate &dd, QGraphicsItem *parent):

    HbAbstractViewItem(dd, parent)

{

    Q_D(HbDataFormViewItem);

    d->q_ptr = this;

    setProperty( "hasIcon", false );

}

/*!

    \protected constructor

*/

HbDataFormViewItem::HbDataFormViewItem(const HbDataFormViewItem &source):

    HbAbstractViewItem( *new HbDataFormViewItemPrivate(*source.d_func()), 0)

{

    Q_D(HbDataFormViewItem);

    d->q_ptr = this;

    setProperty( "hasIcon", false );

}

/*!

    \protected assignment operator

*/

HbDataFormViewItem& HbDataFormViewItem::operator=(const HbDataFormViewItem &source)

{

    Q_D(HbDataFormViewItem);

    *d = *source.d_func();

    setProperty( "hasIcon", false );

    return *this;

}

/*!

    @beta

    Restores the data from the model and assign to the widget.

    The content widget property for restoring and saving the data need to be initialized when the 

    data item is created. If model item type is custom, then application developer has to override

    this API in order to get notification when data is changed in model.

    \sa save

*/

void HbDataFormViewItem::restore()

{

    Q_D( HbDataFormViewItem );    

    if( d->mType < HbDataFormModelItem::CustomItemBase ) {

        if( d->mContentWidget ) {   

            QVariant newValue;

            QModelIndex itemIndex = modelIndex();

            QString currentProperty;

            // fetch all properties set on this model item

            QHash<QString, QVariant> properties = d->mModelItem->contentWidgetData( );

            QList <QString> propertyNames = properties.keys( );

            int upperBound = 1;

            int lowerBound = 0;

            // get the latest modified property

            QString dirtyProperty = 

                HbDataFormModelItemPrivate::d_ptr( d->mModelItem )->dirtyProperty( );

            // First time when DataItem is created load all property, at runtime load only  the modified

            // property. 

            if(  d->mSetAllProperty ) {

                upperBound = propertyNames.count() ;

                d->mSetAllProperty = false;

            } else {

                // Fetch only the last modified property

                lowerBound = propertyNames.indexOf(dirtyProperty);

                upperBound = lowerBound + 1;

            }

            if( lowerBound > -1 ) {

                for( ;lowerBound < upperBound ;lowerBound++) {

                    newValue = properties.value(propertyNames.at(lowerBound));

                    currentProperty = propertyNames.at(lowerBound);

                    if(newValue.isValid()) {                        

                        if(!d->mContentWidget) {

                            return;

                        }

                        d->mContentWidget->setProperty(currentProperty.toAscii().data(), newValue);

                    }

                }

            }

        }

    }

}

/*!

    @beta

    Saves the current data of the content widget in data item to the model.

    The property for restoring and saving the data need to be initialized when the 

    data item is created. If model item type is custom, then application developer has to override

    this API in order to save the content widget value in model.

    \sa restore

*/

void HbDataFormViewItem::save()

{

    Q_D(HbDataFormViewItem);

    if( d->mType < HbDataFormModelItem::CustomItemBase ) {

        if( d->mContentWidget ) {

            disconnect( d->mModel, SIGNAL( dataChanged( QModelIndex,QModelIndex ) ),

                d->mSharedData->mItemView, SLOT( dataChanged( QModelIndex,QModelIndex ) ) );

            d->mModelItem->setContentWidgetData(

                d->mProperty, d->mContentWidget->property(d->mProperty.toAscii( ).data( ) ) );            

            connect( d->mModel, SIGNAL( dataChanged( QModelIndex,QModelIndex ) ),

                d->mSharedData->mItemView, SLOT( dataChanged( QModelIndex,QModelIndex ) ) );

        }

    }

}

/*!

    @beta

    This is a virtual function which by default returns NULL. This function must be overridden

    in case user wants to create a data item of type custom item. The user is supposed to pass

    the widget which he wants to display in data item.

    If content widget grabs pan gesture and user wants data form to be scrollable even panning

    is done on disabled content widget then user is supposed to ungrab pan gesture when content 

    widget is disabled. And again grab pan gesture when state of content widget is changed to 

    enabled.

*/

HbWidget* HbDataFormViewItem::createCustomWidget()

{

    return 0;

}

/*!

    \reimp 

    Sets the item to either collapse or expanded state, depending on the value of \a expanded.

    The function calls setModelIndexes which inturn will make the child items visible/invisible 

    accordingly. This API is valid only if HbDataFormViewItem represents a FormPageItem, GroupItem

    or GroupPageItem.

    \sa isExpanded

*/

void HbDataFormViewItem::setExpanded(bool expanded)

{

    Q_D(HbDataFormViewItem);

    // Expansion is valid only for group ,form page and group page

    if( d->mType < HbDataFormModelItem::SliderItem ) {

        static_cast<HbDataGroup*>(this)->setExpanded(expanded);

    }  else {

        HbAbstractItemContainer *container = qobject_cast<HbAbstractItemContainer *>(

        static_cast<QGraphicsWidget *>( d->mSharedData->mItemView->contentWidget( ) ) );

        container->setItemTransientStateValue(d->mIndex, "expanded", expanded);

    }

}

/*!

    \reimp

    Returns the expanded state of item.

    \sa setExpanded

*/

bool HbDataFormViewItem::isExpanded() const

{

    Q_D( const HbDataFormViewItem);

    // Expansion is valid only for group ,form page and group page

    if( d->mType < HbDataFormModelItem::SliderItem ) {

        HbDataGroup *group = qobject_cast< HbDataGroup *>(const_cast<HbDataFormViewItem*>(this));

        if( group ) {

            return group->isExpanded();

        }

    } 

    if(d->mSharedData->mItemView) {

        HbAbstractItemContainer *container = qobject_cast<HbAbstractItemContainer *>(

            static_cast<QGraphicsWidget *>( d->mSharedData->mItemView->contentWidget( ) ) );

        if(container) {

            return container->itemTransientState(d->mIndex).value("expanded").toBool();

        }

    }

    return false;

}

/*!

    @beta

    Returns the content widget of data item. For example if data item is of type SliderItem 

    then this API will return the instance of HbSlider. If user wants to connect to some 

    signals of content widget in data item then this API can be used to fetch the instance

    of the widget. It will return the instance only if data item is visible. User can connect

    to HbDataForm::itemShown() signal and when this item is visible then he can query the 

    content widget using this API.

*/

HbWidget* HbDataFormViewItem::dataItemContentWidget()const

{

    Q_D(const HbDataFormViewItem);

    HbWidget *widget = d->mContentWidget;

    if(d->mContentWidget) {

        switch( d->mType ) {

            case HbDataFormModelItem::RadioButtonListItem:{

                widget = static_cast<HbRadioItem*>(d->mContentWidget)->createRadioButton();

            }

            break;

            case HbDataFormModelItem::MultiselectionItem:{

                widget = NULL;

            }

            break;

            case HbDataFormModelItem::ToggleValueItem:{

                widget = static_cast<HbToggleItem*>(d->mContentWidget)->contentWidget();

            }

            break;

            default:

            break;

        }

    }

    return widget;

}

/*!

    \reimp

*/

void HbDataFormViewItem::pressStateChanged(bool value, bool animate)

{

    //Since there are no effects defined for mousePressed and mouseReleased for 

    //HbDataFormViewItem we are overriding this function so that redundant effects functions are

    //not called in HbAbstractViewItem::pressStateChanged.

    Q_UNUSED(value);

    Q_UNUSED(animate);

}

/*!

    \reimp

*/

void HbDataFormViewItem::initStyleOption(HbStyleOptionDataFormViewItem *option) const

{

    Q_D( const HbDataFormViewItem );

    HbWidget::initStyleOption(option);

    option->label = d->mLabel;

    option->icon = d->mIcon;

    option->description = d->mDescription;

}

/*!

    \reimp

*/

void HbDataFormViewItem::showEvent(QShowEvent * event)

{

    Q_D( const HbDataFormViewItem );

    HbWidget::showEvent( event );

    if( d->mIndex.isValid( ) ) {

        emit itemShown( d->mIndex.operator const QModelIndex & ( ) );

    }

}

/*!

    \reimp

 */

QVariant HbDataFormViewItem::itemChange( GraphicsItemChange change, const QVariant &value )

{

    Q_D( HbDataFormViewItem );

    switch ( static_cast<HbPrivate::HbItemChangeValues>( change ) ) {

    case QGraphicsItem::ItemEnabledHasChanged: {