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

**

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

#include "hbdataformmodel.h"

#include "hbdataform_p.h"

#include "hbdataformheadingwidget_p.h"

#include "hbdatagroup_p.h"

#include "hbdataformmodelitem_p.h"

#include "hbdatagroup_p_p.h"

#include <hbslider.h>

#include <hbcheckbox.h>

#include <hblistwidget.h>

#include <hblabel.h>

#include <hblineedit.h>

#include <hbradiobuttonlist.h>

#include <hbcombobox.h>

#include <hbselectiondialog.h>

#include <hbpushbutton.h>

#include <hbaction.h>

#include <QGraphicsLinearLayout>

#include <QCoreApplication>

#ifdef HB_GESTURE_FW

#include <hbtapgesture.h>

#endif

#define MAX_INLINE_ITEM_COUNT 3

HbToggleItem::HbToggleItem( QGraphicsItem* parent ): HbWidget( parent )

{

    // Toggle item uses button as the content widget and toggles the text when item is clicked

    mViewItem = static_cast<HbDataFormViewItem*>( parent );

    mButton = new HbPushButton( );

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

    layout->addItem( mButton );

    setLayout( layout );

    QObject::connect( mButton, SIGNAL( clicked( ) ), this, SLOT( toggleValue( ) ) );

    mModel = static_cast<HbDataFormModel*>(

            HbDataFormViewItemPrivate::d_ptr( mViewItem )->mSharedData->mItemView->model( ) );

    mModelItem = static_cast<HbDataFormModelItem*>(

            mModel->itemFromIndex( mViewItem->modelIndex( ) ) );

    QObject::connect(this,SIGNAL(valueChanged(QPersistentModelIndex, QVariant)),mViewItem, 

        SIGNAL(itemModified(QPersistentModelIndex, QVariant)));

}

HbToggleItem::~HbToggleItem()

{

}

/* This function is evoked when Dynamic property is set on HbToggleItem , 

then corresponding property will be set on  HbPushButton */

bool HbToggleItem::event( QEvent * e )

{

    switch( e->type() ){

        case QEvent::DynamicPropertyChange:{

                QDynamicPropertyChangeEvent *changeEvent = 

                    static_cast<QDynamicPropertyChangeEvent*>( e );

                QString name = changeEvent->propertyName().data();

                // Do not set AdditionalText on HbPushButton 

                if( name != "additionalText" ) {

                    mButton->setProperty( changeEvent->propertyName().data(), 

                        property(changeEvent->propertyName().data()) );

                }

                break;

            }

        default:

            break;

    }

    HbWidget::event( e );

    return false;

}

HbWidget* HbToggleItem::contentWidget() const

{

    return mButton;

}

void HbToggleItem::toggleValue()

{   

    // Toggle's the text and additionalText in HbDataFormModelItem and set the corresponding text 

    // as the text of HbPushButton

    QString additionalTxt = 

        mModelItem->contentWidgetData( QString("additionalText") ).toString();

    QString txt = mModelItem->contentWidgetData(QString("text")).toString();

    mModelItem->setContentWidgetData( QString("text"), additionalTxt );

    emit valueChanged(mViewItem->modelIndex(), additionalTxt);

    // HbPushButton will not be updated with Additional Text when modelChanged signal is emitted

    mModelItem->setContentWidgetData( QString("additionalText"), txt );

}

/*  

    HbToggleItem holds a HbLabel and an HbRadioButtonList internally and toggles these 

    widget as the contentwidget when user clicks the contentwidget area .

 */

HbRadioItem::HbRadioItem( QGraphicsItem* parent ):

    HbWidget( parent ),

    mRadioButtonList( 0 ),

    mButton(0), 

    mDialog(0),

    layout(0),

    mSelected(-1)

{

    mViewItem = static_cast<HbDataFormViewItem*>( parent );

    mModel = static_cast<HbDataFormModel*>(

            HbDataFormViewItemPrivate::d_ptr(mViewItem)->mSharedData->mItemView->model());

    mModelItem = static_cast<HbDataFormModelItem*>(

            mModel->itemFromIndex(mViewItem->modelIndex()));

    QString displayMode = mModelItem->contentWidgetData(QString("displayMode")).toString();

    // set displayMode to automatic if not already set by application

    if(displayMode.isEmpty()) {

        mModelItem->setContentWidgetData(QString("displayMode"), "automatic");

    }

    QObject::connect(this,SIGNAL(valueChanged(QPersistentModelIndex, QVariant)),mViewItem, 

        SIGNAL(itemModified(QPersistentModelIndex, QVariant)));

    if(!layout) {

        layout = new QGraphicsLinearLayout( Qt::Vertical );

    }

    setLayout( layout );

}

HbRadioItem::~HbRadioItem()

{

}

HbWidget* HbRadioItem::createRadioButton()

{

    // If not created create and set properties and return the widget

    if(!mRadioButtonList) {

        mRadioButtonList = new HbRadioButtonList();      

        mRadioButtonList->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred));

        //mRadioButtonList->setClampingStyle(HbScrollArea::StrictClamping);

        mRadioButtonList->setItems( mItems );

        if( mSelected != -1 ) {

            mRadioButtonList->setSelected( mSelected );

        }

        // model need to be updated when selection changes

        // in popup case this connection will be removed since model will be updated 

        // only when dialog closed

        QObject::connect( mRadioButtonList, SIGNAL(itemSelected(int)), 

            this, SLOT(updateModel(int)) );

    }

    return mRadioButtonList;

}

/*  This function is evoked when Dynamic property is set on HbRadioItem , then 

    corresponding property will be set on  HbRadioButtonList

*/

bool HbRadioItem::event( QEvent * e )

{

    switch( e->type() ){

        case QEvent::DynamicPropertyChange: {

                QDynamicPropertyChangeEvent *changeEvent = 

                    static_cast<QDynamicPropertyChangeEvent*>( e );

                QString dynamicPropertyName = changeEvent->propertyName().data();

                if( mRadioButtonList ) {

                    //Set the property on radiobutton list if already created 

                    mRadioButtonList->setProperty( 

                        changeEvent->propertyName().data() ,

                        property( changeEvent->propertyName().data()) );

                }

                if( dynamicPropertyName == "items" || dynamicPropertyName == "displayMode" ) {

                    // store the items locally

                    mItems = property("items").toStringList();

                    // in case of automatic, displayMode (embedded, automatic or popup) will change 

                    // if new items are populated or mode should be changed if mode is set

                    //  explicitly by application at runtime

                    changeMode();

                } else if(dynamicPropertyName == "selected") {

                    // store the new selection 

                    mSelected = property("selected").toInt();

                    // fine tune the new selection if it goes beyond range. This happens when new

                    // items are populated or selection index is changed by application in to the model

                    // which can be out of range

                    resetSelection();

                    selectItem();

                }

                break;

            }

        default:

            break;

    }

    HbWidget::event(e);

    return false;

}

void HbRadioItem::makeEmbedded()

{

    // button need to be deleted when mode is changed from popup to embedded

    if(mButton) {

        layout->removeItem(mButton);

        delete mButton;

        mButton = 0;

    }

    createRadioButton();

    layout->addItem(mRadioButtonList);

    mRadioButtonList->setScrollDirections(0);

}

void HbRadioItem::makePopup()

{

    if(mRadioButtonList) {

        layout->removeItem(mRadioButtonList);

        // RadioButton will not be shown unless button is clicked so delete it

        delete mRadioButtonList;

        mRadioButtonList = 0;

    }

    initilizeButton();

}

void HbRadioItem::resetSelection()

{

    if((mItems.count() > 0 && mSelected == -1) || 

        (mItems.count() > 0 && (mItems.count() <= mSelected ))) {

        // if selection is beyond range then set it to 0. 

        // This happens when new items are populated and 

        // application does not set selection explicitly

        mSelected = 0;

    } else if(mItems.count() == 0) {

        mSelected = -1;

    }

}

/*

changeMode() will change the mode of visualization( embedded, automatic and popup) depending

on the number of items in case of automatic mode or change it to correspoding if not automatic.

In popup the selected item will be displayed as the text of the button otherwise RadioButtonList

is placed inline.

*/

void HbRadioItem::changeMode()

{

    QString displayMode = mModelItem->contentWidgetData(QString("displayMode")).toString();

    if(displayMode == "embedded") {

        makeEmbedded();

    } else if(displayMode == "popup") {

        makePopup();

    }

    else if(displayMode == "automatic") {

        if(mItems.count() <= MAX_INLINE_ITEM_COUNT  && mItems.count() > 0  ) {

            makeEmbedded();

        } else if(mItems.count() >= MAX_INLINE_ITEM_COUNT){

            makePopup();

        }

    }

    resetSelection();

    selectItem();

}

void HbRadioItem::selectItem()

{

    //Set Text if button is valid

    if(mSelected != -1) {

        if(mButton ) {

            mButton->setText(mItems.at(mSelected));

        } 

        // change selection of radiobutton list

        if(mRadioButtonList && mRadioButtonList->selected() != mSelected) {

            mRadioButtonList->setSelected(mSelected);

        }

    } else if( mButton ) {

        // clear the text on the button if items are cleared 

        mButton->setText(QString(""));

    }

}

void HbRadioItem::initilizeButton()

{

    if(!mButton) {

        mButton = new HbPushButton();

        mButton->setTextAlignment(Qt::AlignLeft);

        QObject::connect(mButton, SIGNAL(clicked()), this, SLOT(buttonClicked()));

        layout->addItem( mButton ); 

    }

}

void HbRadioItem::buttonClicked()

{

    if(mItems.count() > 0) {

        if(!mRadioButtonList) {

            createRadioButton();

        } 

        mRadioButtonList->setScrollDirections(Qt::Vertical);

        QObject::disconnect( mRadioButtonList, SIGNAL(itemSelected(int)), 

            this, SLOT(updateModel(int)) );

        selectItem();

        mDialog = new HbDialog();

        mDialog->setTimeout(HbPopup::NoTimeout);    

        mDialog->setAttribute(Qt::WA_DeleteOnClose);

        mDialog->setContentWidget(mRadioButtonList);    

        mDialog->addAction(new HbAction(QString("Ok")));

        mDialog->addAction(new HbAction(QString("Cancel")));

        mDialog->open(this,SLOT(dialogClosed(HbAction*)));  

        mRadioButtonList->setSelected(mSelected);

    }

}

void HbRadioItem::updateModel( int index )

{

    mSelected = index;

    emit valueChanged(mViewItem->modelIndex(), mItems.at(index));

    // Disconnect modelchanged signal since visualization is already updated by user

    // so if not disconnected , this will trigger visualization change again

    disconnect( mModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)),

                  HbDataFormViewItemPrivate::d_ptr(mViewItem)->mSharedData->mItemView, 

                  SLOT( dataChanged(QModelIndex,QModelIndex)) );

    //update the model

    mModelItem->setContentWidgetData("selected", mSelected);

    // establish the connection back

    connect( mModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)),

                  HbDataFormViewItemPrivate::d_ptr(mViewItem)->mSharedData->mItemView, 

                  SLOT( dataChanged(QModelIndex,QModelIndex)) );

    // select the item . The selection is already stored in to the model above

    selectItem();

}

void HbRadioItem::dialogClosed(HbAction* action)

{

        // store the selected item to model

        updateModel(mRadioButtonList->selected());        

    }

    // dont change selection incase of "Cancel" button click .

    mRadioButtonList = 0;

    mDialog = 0;

}

HbMultiSelectionItem::HbMultiSelectionItem( QGraphicsItem* parent ):

    HbWidget(parent),

    mSelectionDialog(0),

    mButton(0),

    mMultiListWidget(0)

{

    // Create label by default . RadioButtonList is created created at runtime 

    // when clicked on the item        

    mViewItem = static_cast<HbDataFormViewItem*>(parent);

    layout = new QGraphicsLinearLayout(Qt::Horizontal);

    setLayout(layout);

    mModel = static_cast<HbDataFormModel*>(

            HbDataFormViewItemPrivate::d_ptr(mViewItem)->mSharedData->mItemView->model());

    mModelItem = static_cast<HbDataFormModelItem*>(

            mModel->itemFromIndex(mViewItem->modelIndex()));    

    // set displayMode to automatic if not already set by application

    QString displayMode = mModelItem->contentWidgetData(QString("displayMode")).toString();

    if(displayMode.isEmpty()) {

        mModelItem->setContentWidgetData(QString("displayMode"), "automatic");

    }

    QObject::connect(this,SIGNAL(valueChanged(QPersistentModelIndex, QVariant)),

        mViewItem, SIGNAL(itemModified(QPersistentModelIndex, QVariant)));

}

HbMultiSelectionItem::~HbMultiSelectionItem()

{

}

void HbMultiSelectionItem::makeSelection()

{

    QItemSelectionModel *model = 0;

    if(mMultiListWidget) {// embedded case

        // get selection model

        model = mMultiListWidget->selectionModel();

        if(model) {

            // disconnect so that the visualization does not get changed when selction 

            // model changes

            QObject::disconnect(model, 

                SIGNAL(selectionChanged( const QItemSelection , const QItemSelection  )), 

                this, SLOT(updateModel( const QItemSelection , const QItemSelection  )));

            model->clearSelection();

            for( int i = 0; i < mSelectedItems.count() ; i++ ) {

                model->select( model->model()->index(mSelectedItems.at( i ).toInt(),0),

                    QItemSelectionModel::Select);

            }

            QObject::connect(model, 

                SIGNAL(selectionChanged( const QItemSelection , const QItemSelection  )), 

                this, SLOT(updateModel( const QItemSelection , const QItemSelection  )));

        }

    } else if(mButton) { // update text on button

        QString newValue("");

        // create sting to be set on button

        for ( int i = 0; i < mSelectedItems.count() ; i++ ) {

            int selectionindex = mSelectedItems.at( i ).toInt();

            if( selectionindex< mItems.count()) {

                if( i > 0) {// dont add ; in the starting of the string

                    newValue.append( ";" );

                }

                newValue.append( mItems.at( mSelectedItems.at( i ).toInt() ) );

            } 

        }

        mButton->setText( newValue );

    }

}

void HbMultiSelectionItem::makeEmbedded()

{

    // delete button if displaymode change has happened at runtime 

    if(mButton){

        layout->removeItem(mButton);

        delete mButton;

        mButton = 0;

    }

    // create ListWidget if not yet created 

    if(!mMultiListWidget) {

        mMultiListWidget = new HbListWidget();

        layout->addItem(mMultiListWidget);

    }

    mMultiListWidget->setSelectionMode(HbAbstractItemView::MultiSelection);

    mMultiListWidget->clear();

    // update the listwidget with new items

    for (int index = 0; index < mItems.count(); ++index) {

        mMultiListWidget->addItem(mItems.at(index));

    }

    mMultiListWidget->setScrollDirections(0);

}

void HbMultiSelectionItem::makePopup()

{

    // Delete ListWidget if mode change happened at runtime from embedded to popup

    if(mMultiListWidget) {

        layout->removeItem(mMultiListWidget);

        delete mMultiListWidget;

        mMultiListWidget = 0;

    }

    // create button since we need to display selected item on button

    // and popup will be launched when button is clicked

    if(!mButton) {

        mButton = new HbPushButton();

        mButton->setTextAlignment(Qt::AlignLeft);

        layout->addItem(mButton);

    }

}

void HbMultiSelectionItem::changeMode()

{

    QString displayMode = mModelItem->contentWidgetData(QString("displayMode")).toString();

    if((mItems.count() <= MAX_INLINE_ITEM_COUNT && displayMode == "automatic") || 

        displayMode == "embedded" ) {

        makeEmbedded();

    } else{

        makePopup();

    }

    makeSelection();

}

bool HbMultiSelectionItem::event( QEvent * e )

{

    switch( e->type() ) {

        case QEvent::DynamicPropertyChange: {

                QDynamicPropertyChangeEvent *eve = static_cast<QDynamicPropertyChangeEvent*>( e );

                QString dynamicPropertyName = eve->propertyName( ).data( );                

                if ( dynamicPropertyName == "items" || dynamicPropertyName == "displayMode" ) {

                    int prevCount = mItems.count();

                    mItems.clear();

                    mItems = property("items").toStringList();

                    if ( mItems.count() != prevCount || dynamicPropertyName == "displayMode") {

                        changeMode();

                    }