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

**

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

#include "hbdatagroupheadingwidget_p.h"

#include "hbdataform_p.h"

#include "hbstyleoptiondatagroup_p.h"

#include "hbabstractitemcontainer_p_p.h"

#include <hbcombobox.h>

#include <hbdataformmodel.h>

#include <QStringListModel>

#include <QCoreApplication>

HbDataGroupPrivate::HbDataGroupPrivate( HbDataGroup* item ):

    HbDataFormViewItemPrivate( item ),

    mPageCombo( 0 ),

    mGroupHeading( 0 ),

    mPageComboBackgroundItem( 0 )

{

}

HbDataGroupPrivate::HbDataGroupPrivate( const HbDataGroupPrivate &source ):

    HbDataFormViewItemPrivate( source ),

    mPageCombo( source.mPageCombo ),

    mGroupHeading( source.mGroupHeading ),

    mPageComboBackgroundItem( source.mPageComboBackgroundItem )

{

}

HbDataGroupPrivate::~HbDataGroupPrivate( )

{

}

void HbDataGroupPrivate::init( )

{   

}

bool HbDataGroupPrivate::setExpanded( bool expanded )

{

    Q_Q(HbDataGroup);

    HbAbstractItemContainer *container = 0;

    HbDataFormModelItem::DataItemType itemType = 

            static_cast<HbDataFormModelItem::DataItemType>(

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

    //emit activated signal for newly expanded group page

    if(expanded && (itemType == HbDataFormModelItem::GroupPageItem || 

        itemType == HbDataFormModelItem::FormPageItem)) {

        q->emitActivated(q->modelIndex());

    }

    if(mSharedData->mItemView) {

        container = qobject_cast<HbAbstractItemContainer *>(

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

        if(container->itemTransientState(mIndex).value("expanded")  == expanded || !mSharedData->mItemView) {

            return true;

        }    

        // expand function sets correct expansion itemstate for this item and its children

        changeExpansionState(expanded);

        // if some one exlicitly calls setExpanded for data group then primitives needs to be updated.

        if(itemType == HbDataFormModelItem::GroupItem){

            if(mPageCombo) {

                if(expanded) {

                    HbStyle::setItemName(mPageCombo,"dataGroup_Combo");

                    HbStyle::setItemName(mPageComboBackgroundItem,"dataGroup_ComboBackground");

                } else {

                    HbStyle::setItemName(mPageCombo,"");

                    HbStyle::setItemName(mPageComboBackgroundItem,"");

                    q->setProperty("groupPage", "");

                    mPageString.clear();

                    delete mPageCombo;

                    mPageCombo = 0;

                    delete mPageComboBackgroundItem;

                    mPageComboBackgroundItem = 0;

                    q->repolish();

                }

            }

        }

        // setModelIndexes will be create or delete items according to the 

        // itemTransient state set using expand function call above

        container->setModelIndexes(mIndex.operator const QModelIndex & ());

    }

    q->updatePrimitives();

    return true;

}

void HbDataGroupPrivate::setEnabled( bool enabled )

{

    Q_Q(HbDataGroup);

    QGraphicsItem::GraphicsItemFlags itemFlags = q->flags( );

    Qt::ItemFlags indexFlags = mIndex.flags( );

    if ( indexFlags & Qt::ItemIsEnabled ) {

        if ( !( itemFlags & QGraphicsItem::ItemIsFocusable ) ) {

            itemFlags |= QGraphicsItem::ItemIsFocusable;

            q->setFocusPolicy( q->prototype( )->focusPolicy( ) );

            q->setProperty( "state", "normal" );

            q->setEnabled( true );

            q->grabGesture( Qt::TapGesture );

        }

    } else {

        if ( itemFlags & QGraphicsItem::ItemIsFocusable ) {

            itemFlags &= ~QGraphicsItem::ItemIsFocusable;

            q->setFocusPolicy( Qt::NoFocus );

            q->setProperty( "state", "disabled" );

            q->setEnabled( false );

            q->ungrabGesture( Qt::TapGesture );

        }

    }

    if( mGroupHeading ) {

        mGroupHeading->setEnabled(enabled);

        mGroupHeading->updatePrimitives();

    }

}

// This function gets called  for group item or for grouppage item . It returs the corresponding page index .

// The relevance of this function is when some items are inserted before group page inside a group.

// returns -1 if not valid index.

int HbDataGroupPrivate::pageIndex(const QModelIndex &index) const 

{

    const Q_Q(HbDataGroup);

    int pageIndex = -1;

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

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

    // Make sure that the child is groupPage type and current item is group.

    if( (indexType == HbDataFormModelItem::GroupPageItem) || (indexType == HbDataFormModelItem::FormPageItem) ) {

        HbDataFormModelItem *modelItem = 

            static_cast<HbDataFormModel*>((q->itemView())->model())->itemFromIndex(

                q->modelIndex( ));

        HbDataFormModelItem *groupModelItem = 0;

        // get the group modelItem pointer depending upon the type

        if( modelItem->type() == HbDataFormModelItem::GroupItem ) {

            groupModelItem = modelItem;

        } else if( modelItem->type() == HbDataFormModelItem::GroupPageItem ) {

            groupModelItem = modelItem->parent();

        } else if (modelItem->type() == HbDataFormModelItem::FormPageItem ) {

            groupModelItem = static_cast<HbDataFormModel*>(q->itemView()->model())->invisibleRootItem();

        }

        int childCount = groupModelItem->childCount();

        for( int i = 0; i < childCount; i++) {

            HbDataFormModelItem *child = groupModelItem->childAt(i);

            if( (child->type() == HbDataFormModelItem::GroupPageItem ) || (child->type() == HbDataFormModelItem::FormPageItem)) {

                pageIndex ++;

                // get the index of groupPage

                QModelIndex childIndex = static_cast<HbDataFormModel*>(q->itemView()->model())->indexFromItem(child);

                if(childIndex == index) {

                    break;// we got the page index

                }

            }        

        }

    }

    return pageIndex;

}

QModelIndex HbDataGroupPrivate::pageModelIndex(int index) const 

{

    const Q_Q(HbDataGroup);

    int pageIndex = -1;

    QModelIndex modelIndex;

    // Make sure that the child is groupPage type and current item is group.

    if( index >= 0) {

        HbDataFormModelItem *modelItem = 

            static_cast<HbDataFormModel*>((q->itemView())->model())->itemFromIndex(

                q->modelIndex( ));

        HbDataFormModelItem *groupModelItem = 0;

        // get the group modelItem pointer depending upon the type

        if( modelItem->type() == HbDataFormModelItem::GroupItem ) {

            groupModelItem = modelItem;

        } else if( modelItem->type() == HbDataFormModelItem::GroupPageItem ) {

            groupModelItem = modelItem->parent();

        }

        int childCount = groupModelItem->childCount();

        for( int i = 0; i < childCount; i++) {

            HbDataFormModelItem *child = groupModelItem->childAt(i);

            if( child->type() == HbDataFormModelItem::GroupPageItem ) {

                pageIndex ++;

                // get the index of groupPage

                if(pageIndex == index) {

                modelIndex = static_cast<HbDataFormModel*>(q->itemView()->model())->indexFromItem(child);

                break; 

                }

            }        

        }

    }

    return modelIndex;

}

void HbDataGroupPrivate::changeExpansionState( bool expanded )

{

    Q_Q(HbDataGroup);

    // get container for setting item state

    HbAbstractItemContainer *container = qobject_cast<HbAbstractItemContainer *>(

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

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

            ( mIndex.operator const QModelIndex & ( )).data( HbDataFormModelItem::ItemTypeRole).toInt( ) );

   if(container->itemTransientState(mIndex).value( "expanded" ) == expanded ) {

        return;

    }

    if( !expanded ) {

        if( mGroupHeading ) {

            mGroupHeading->mExpanded = false;

        }

    } else { //expand

        // here we are checking only for HbDataGroup since for HbDataFormPage expansion will happen through 

        // setModelIndexes. For group we need to expand the current active grouppage . 

        if(itemType == HbDataFormModelItem::GroupItem){

            int page = activePage();

            if(page != -1) {

                QModelIndex groupPageIndex = pageModelIndex(page);

                if(groupPageIndex.isValid()) {                    

                    // set transient state for group page so that when it gets created then its  

                    // child items are also created

                    container->setItemTransientStateValue(groupPageIndex, "expanded", true);

                    q->emitActivated(groupPageIndex);                   

                }

            }

            if (mGroupHeading )  {

                mGroupHeading->mExpanded = true;

            }

        }

    }

    // save the item state for this item. All the cild item state are saved above

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

}

/*QString HbDataGroupPrivate::groupPage() const

{   

    return mPageString;

}

*/

void HbDataGroupPrivate::setGroupPage( const QString &page ) 

{

   Q_Q(HbDataGroup);

    if( !mPageCombo ) {

        // This is the first groupPgae getting added so create the combobox to add the page

        mPageCombo = new HbComboBox( q );

        mPageString = ' ';

        q->setProperty("groupPage", page);

        HbStyle::setItemName(mPageCombo,"dataGroup_Combo");   

        if ( !mPageComboBackgroundItem) {

            mPageComboBackgroundItem = HbStylePrivate::createPrimitive(HbStylePrivate::P_DataGroupComboBackground, q);

            HbStyle::setItemName(mPageComboBackgroundItem,"dataGroup_ComboBackground");

        }

        q->repolish();

    }

    // disconnecting to avoid pagechanged signal when setting group.

    QObject::disconnect(mPageCombo,SIGNAL(currentIndexChanged(int)),

            q,SLOT(pageChanged(int)));

    QStringList list  = mPageCombo->items();    

    if(!list.contains(page)) {

        mPageCombo->addItem(page);        

        mPageString = page; 

    }

    int pageIndex = activePage();

    if(pageIndex!= -1) {

        mPageCombo->setCurrentIndex(pageIndex);

    }

    QObject::connect(mPageCombo,SIGNAL(currentIndexChanged(int)),

            q ,SLOT(pageChanged(int)));

}

void HbDataGroupPrivate::removeGroupPage(const QString &page)

{    

    if(mPageCombo) {

        // if we are removing the last page then set current page as 0

        if( mPageCombo->findText(page) + 1 == mPageCombo->count()) {

            mPageCombo->setCurrentIndex(0);

        } else {// set next page as the currrent page

            mPageCombo->setCurrentIndex(mPageCombo->findText(page) + 1);

        }

        // remove the text from ombobox

        mPageCombo->removeItem(mPageCombo->findText(page));

    }

}

/*

int HbDataGroupPrivate::pageChanged(const QModelIndex &modelIndex)

{

}*/

int HbDataGroupPrivate::activePage( )

{

    Q_Q( HbDataGroup );

    // Here we need to find which page has the itemTransientState  true, 

    // which in turn will be the active page. If no page is set as true , then

    // make the 0th page as expanded ie itemTransientState as true

    // This function can be called from Group or GroupPage items 

    QModelIndex groupIndex ;    

    HbDataFormModelItem *modelItem = 

        static_cast<HbDataFormModel*>((q->itemView())->model())->itemFromIndex(

            q->modelIndex( ));

    HbDataFormModelItem *groupModelItem = 0;

    // get the group modelItem pointer depending upon the type

    if( modelItem->type() == HbDataFormModelItem::GroupItem ) {

        groupModelItem = modelItem;

    } else if( modelItem->type() == HbDataFormModelItem::GroupPageItem ) {

        groupModelItem = modelItem->parent();

    }

    int childCount = groupModelItem->childCount();

    //int activePage = 0;

    // get container for setting item state

    HbAbstractItemContainer *container = qobject_cast<HbAbstractItemContainer *>(

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

    int currentPage = -1; 

    bool somePageExpanded = false;

    for( int i = 0; i < childCount; i++) {

        // Make sure that the child is groupPage type.

        HbDataFormModelItem *child = groupModelItem->childAt(i);

        if( child->type() == HbDataFormModelItem::GroupPageItem ) {

            // Here we are not using i as the page index since there can other types of children in the same level

            // so need a seperate variable for this 

            currentPage ++;

            // get the index of groupPage

            QModelIndex pageIndex = static_cast<HbDataFormModel*>(q->itemView()->model())->indexFromItem(child);

            if(container->itemTransientState(pageIndex).value("expanded").toBool()) {

                somePageExpanded = true;

                break;

            }

        }        

    }

    if(!somePageExpanded && currentPage != -1) {// This means pages are present and no page is expanded so expand first page

        currentPage = 0;

    }

    return currentPage;

}

void HbDataGroupPrivate::setHeading( const QString &heading )

{ 

    Q_Q( HbDataGroup );

    mGroupHeading->mHeading = heading;

    mGroupHeading->createPrimitives( );    

    q->updatePrimitives( );

}

QString HbDataGroupPrivate::heading() const

{    

    return mGroupHeading->mHeading;

}

HbDataGroup::HbDataGroup(QGraphicsItem *parent)

    :HbDataFormViewItem(* new HbDataGroupPrivate( this ), parent)

{    

}

HbDataGroup::HbDataGroup(const HbDataGroup &source):

    HbDataFormViewItem( *new HbDataGroupPrivate(*source.d_func()), 0)

{

    Q_D(HbDataGroup);

    d->q_ptr = this;

    d->init( );   

}

HbDataGroup::~HbDataGroup()

{

}

void HbDataGroup::initStyleOption(HbStyleOptionDataGroup *option)

{

    //Q_D(HbDataGroup);

    HbWidget::initStyleOption(option);

}

void HbDataGroup::setDescription( const QString &description )

{

    Q_D( HbDataGroup );

    d->mGroupHeading->mDescription = description;

    d->mGroupHeading->createPrimitives( );    

    d->mGroupHeading->updatePrimitives( );

}

QString HbDataGroup::description() const

{

    Q_D(const HbDataGroup);

    return d->mGroupHeading->mDescription;

}

bool HbDataGroup::setExpanded( bool expanded )

{

    Q_D(HbDataGroup);

    if(d->mSharedData->mItemView){

        HbDataFormModelItem *modelItem = static_cast<HbDataFormModel*>(

                    d->mSharedData->mItemView->model())->itemFromIndex(modelIndex());

        HbDataFormModelItem::DataItemType contentWidgetType =

            static_cast<HbDataFormModelItem::DataItemType>(

            (d->mIndex.data(HbDataFormModelItem::ItemTypeRole)).toInt());

        if( contentWidgetType == HbDataFormModelItem::GroupItem ) {

            d->setExpanded(expanded);

        } else if (contentWidgetType == HbDataFormModelItem::GroupPageItem) {

            //We need to change even the combobox state also so call pageChanged fuction

            if(modelItem) {

                int page = d->pageIndex(d->mIndex);

                if(page != -1) {

                    if(!expanded) {

                        QModelIndex parentIndex = d->mIndex.parent();

                        HbDataGroup *parentGroup =

                        static_cast<HbDataGroup *>(d->mSharedData->mItemView->itemByIndex(parentIndex));

                        if(parentGroup && HbDataGroupPrivate::d_ptr(parentGroup)->mPageCombo) {

                            if(HbDataGroupPrivate::d_ptr(parentGroup)->mPageCombo->count() > (page + 1) ) {

                                HbDataGroupPrivate::d_ptr(parentGroup)->mPageCombo->setCurrentIndex(page + 1);

                                //parentGroup->pageChanged(0);

                            } else {

                                HbDataGroupPrivate::d_ptr(parentGroup)->mPageCombo->setCurrentIndex(0);

                                //parentGroup->pageChanged(1);

                            }

                        }

                    } else {

                        pageChanged(page);

                    }

                }

            }

        } else if(contentWidgetType == HbDataFormModelItem::FormPageItem) {

            if(modelItem) {

                int formPageIndex = d->pageIndex(d->mIndex);

                if( formPageIndex!= -1) {

                    HbDataFormPrivate::d_ptr(

                    static_cast<HbDataForm*>(d->mSharedData->mItemView))->_q_page_changed(formPageIndex);

                }

            }

        }

        return true;

    } else {

        return false;

    }   

}

bool HbDataGroup::isExpanded() const

{

    Q_D(const HbDataGroup);

    HbDataFormModelItem::DataItemType contentWidgetType =

        static_cast<HbDataFormModelItem::DataItemType>(

        (d->mIndex.data(HbDataFormModelItem::ItemTypeRole)).toInt());

    if( contentWidgetType < HbDataFormModelItem::SliderItem ) {

        HbAbstractItemContainer *container = qobject_cast<HbAbstractItemContainer *>(

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

        if(container) {

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

        }

    }