/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:   ?Description

*

*/

//Includes

#include <hbmainwindow.h>

#include <hggrid.h>

#include <glxmodelwrapper.h>

#include <hbpushbutton.h>

#include <HbToolBar> 

#include <HbAction>

#include <hbiconitem.h>

#include <hbicon.h>

#include <xqserviceutil.h>

#include <hbcheckbox.h>

#include <hblabel.h>

#include <QString>

#include <hbframeitem.h>

#include <hbgroupbox.h>

#include <hbparameterlengthlimiter.h>

#include <QGraphicsLinearLayout>

//User Includes

#include "glxviewids.h"

#include "glxgridview.h"

#include "glxmodelparm.h"

#include "glxcommandhandlers.hrh"

#include "glxicondefs.h"

#include "glxlocalisationstrings.h"

#include "glxsettinginterface.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "glxgridviewTraces.h"

#endif

GlxGridView::GlxGridView(HbMainWindow *window)

    : GlxView ( GLX_GRIDVIEW_ID ),

      mWindow(window),

      mModel ( NULL),

      mWidget(NULL),

      mSelectionModel(NULL),

      mModelWrapper(NULL),

      mUiOnButton(NULL),      

      mScrolling(FALSE),

      mIconItem(NULL),

      mMarkCheckBox(NULL),

      mTotalImagesCount(NULL),

      mMarkSelectHeading(NULL),

      mMarkCountLabel(NULL),

      mZeroItemLabel(NULL),

      mAlbumNameHeading(NULL),

      mMarkContainer(NULL),

      mMarkingWidget(NULL),

      mToolBar( NULL ),

      mCurrentToolBar( NULL )

{

    OstTraceFunctionEntry0( GLXGRIDVIEW_GLXGRIDVIEW_ENTRY );

    mModelWrapper = new GlxModelWrapper();

    mModelWrapper->setRoles(GlxQImageSmall);

    mIconItem = new HbIconItem(this);

    mSettings = GlxSettingInterface::instance() ;

    mUiOnButton = new HbPushButton(this);

    connect(mUiOnButton, SIGNAL(clicked(bool)), this, SLOT(uiButtonClicked(bool)));

    mUiOnButton->setGeometry(QRectF(590,0,40,40));

    mUiOnButton->setZValue(1);

    mUiOnButton->setIcon(HbIcon(GLXICON_WALL_UI_ON));

    mUiOnButton->setObjectName( "UiOn Button" );

    OstTraceFunctionExit0( GLXGRIDVIEW_GLXGRIDVIEW_EXIT );

}

void GlxGridView::activate()

{

    OstTraceFunctionEntry0( GLXGRIDVIEW_ACTIVATE_ENTRY );

    loadGridView();

	connect(mWindow, SIGNAL(orientationChanged(Qt::Orientation)), this, SLOT(orientationchanged(Qt::Orientation)),Qt::UniqueConnection);

    if(mTotalImagesCount == NULL) {

        mTotalImagesCount = new HbGroupBox(this);

        mTotalImagesCount->setObjectName( "Count" );

        mTotalImagesCount->hide();

    }

    OstTraceFunctionExit0( GLXGRIDVIEW_ACTIVATE_EXIT );

}

void GlxGridView::deActivate()

{

    OstTraceFunctionEntry0( GLXGRIDVIEW_DEACTIVATE_ENTRY );

    mScrolling = FALSE;

    if (mUiOnButton){

        mUiOnButton->hide();

    }

    if(mIconItem) {

        mIconItem->hide();

        mIconItem->resetTransform();

        mIconItem->setOpacity(0);

        mIconItem->setZValue(mIconItem->zValue()-20);

    }

    if (mTotalImagesCount) {

        mTotalImagesCount->hide();

    }

    if (mAlbumNameHeading) {

        mAlbumNameHeading->hide();

    }

    if(mZeroItemLabel) {

        mZeroItemLabel->hide();

    }

    disconnect(mWindow, SIGNAL(orientationChanged(Qt::Orientation)), this, SLOT(orientationchanged(Qt::Orientation)));

    OstTraceFunctionExit0( GLXGRIDVIEW_DEACTIVATE_EXIT );

}

void GlxGridView::initializeView( QAbstractItemModel *model, GlxView *preView )

{

    Q_UNUSED( preView )

    activate();

    setModel(model);

}

void GlxGridView::clearCurrentModel()

{

    if ( mModel ) {

        disconnect( mModel, SIGNAL( rowsInserted( QModelIndex, int, int ) ), this, SLOT( rowsInserted() ) );

        disconnect( mModel, SIGNAL( rowsRemoved( QModelIndex, int, int ) ), this, SLOT( rowsRemoved() ) );

        disconnect( mModel, SIGNAL(destroyed()), this, SLOT( clearCurrentModel() ) );

        disconnect( mModel, SIGNAL( albumTitleAvailable( QString ) ), this, SLOT( showAlbumTitle( QString ) ) );

        disconnect( mModel, SIGNAL( populated() ), this, SLOT( populated() ) );

        mModel = NULL;

    }

}

void GlxGridView::initializeNewModel()

{

    if ( mModel ) {

        connect( mModel, SIGNAL( rowsInserted( QModelIndex, int, int ) ), this, SLOT( rowsInserted() ) );

        connect( mModel, SIGNAL( rowsRemoved( QModelIndex, int, int ) ), this, SLOT( rowsRemoved() ) );

        connect( mModel, SIGNAL(destroyed()), this, SLOT( clearCurrentModel() ) );

        if ( getSubState() == ALBUM_ITEM_S ) {

            connect( mModel, SIGNAL( albumTitleAvailable( QString ) ), this, SLOT( showAlbumTitle( QString ) ) );

        }

        connect( mModel, SIGNAL( populated() ), this, SLOT( populated() ) );

    }

}

void GlxGridView::setModel( QAbstractItemModel *model )

{

    OstTraceFunctionEntry0( GLXGRIDVIEW_SETMODEL_ENTRY );

    if( model ) {

        clearCurrentModel();

        mModel = model;

        initializeNewModel();

        QVariant variantimage = mModel->data(mModel->index(0,0),GlxDefaultImage);

        if ( variantimage.isValid() && variantimage.canConvert<QImage> () ) {

            mWidget->setDefaultImage( variantimage.value<QImage>() );

        }

        mModelWrapper->setModel( mModel );

        mWidget->setModel( mModelWrapper );

        if( !mSelectionModel ) {

            mSelectionModel = new QItemSelectionModel( mModelWrapper, this );

            connect( mSelectionModel, SIGNAL( currentChanged( const QModelIndex &, const QModelIndex & ) ), this, SLOT( visibleIndexChanged( const QModelIndex &, const QModelIndex & ) ) );

            mWidget->setSelectionModel( mSelectionModel );

        }

        scrolltofocus(); // Need to do it here ?

        showItemCount();

    }

    OstTraceFunctionExit0( GLXGRIDVIEW_SETMODEL_EXIT );

}

void GlxGridView::visibleIndexChanged(const QModelIndex& current, const QModelIndex& previous)

{

    if(mScrolling)

        {

        Q_UNUSED(previous);

        if(current.row() >= 0 || current.row() < mModel->rowCount())

            {

            mModel->setData(mModel->index(0,0),current.row(),GlxVisualWindowIndex);

            }

        }

}

void GlxGridView::addToolBar( HbToolBar *toolBar )

{

    OstTraceFunctionEntry0( GLXGRIDVIEW_ADDTOOLBAR_ENTRY );

    //For album grid view, add and remove from album tool bar will be shown

    int subState = getSubState();

    if ( subState == ALBUM_ITEM_S && mWidget->selectionMode() == HgWidget::NoSelection ) {

        if ( !mToolBar ) {

            createAlbumGridToolBar();

        }

        if ( mToolBar ) {

            //remove from action will be disable if number of images in the album grid is zero.

            if ( mModel->rowCount()  ) {

                mToolBar->actions().at(0)->setEnabled( true ); //To:Do remove once selection dialog is implemented

                mToolBar->actions().at(1)->setEnabled( true );

            }

            else {

                mToolBar->actions().at(0)->setEnabled( false );

                mToolBar->actions().at(1)->setEnabled( false );

            }

            if ( mToolBar != mCurrentToolBar ) {

                takeToolBar();

                setToolBar( mToolBar );

                mCurrentToolBar = mToolBar;

            }

        }

    }

    else {

        if ( toolBar != mCurrentToolBar ) {

            takeToolBar();

            setToolBar( toolBar );

            mCurrentToolBar = toolBar;

        }

    }

    showHbItems();

    OstTraceFunctionExit0( GLXGRIDVIEW_ADDTOOLBAR_EXIT );

}

void GlxGridView::enableMarking()

{

    OstTrace0( TRACE_NORMAL, GLXGRIDVIEW_ENABLEMARKING, "GlxGridView::enableMarking" );

    mWidget->setSelectionMode(HgWidget::MultiSelection);

        mMarkingWidget = new HbWidget(this);

        mMarkContainer = new QGraphicsLinearLayout(Qt::Horizontal, 0);

        mMarkingWidget->setLayout(mMarkContainer);

        mMarkSelectHeading = new HbGroupBox(this);

        mMarkSelectHeading->setHeading(GLX_SELECT_IMAGES);

        mMarkSelectHeading->setObjectName("Select Photos");

        mMarkCountLabel = new HbLabel(mMarkingWidget);

        mMarkCountLabel->setObjectName("MarkCount");

        mMarkCountLabel->setAlignment(Qt::AlignRight | Qt::AlignVCenter);

        mMarkCheckBox = new HbCheckBox(GLX_LABEL_MARK_ALL, mMarkingWidget);

        mMarkCheckBox->setObjectName("CheckB MarkAll");

        mMarkContainer->addItem(mMarkCheckBox);

        mMarkContainer->addItem(mMarkCountLabel);        

}

void GlxGridView::disableMarking()

{

    OstTrace0( TRACE_NORMAL, GLXGRIDVIEW_DISABLEMARKING, "GlxGridView::disableMarking" );

    mWidget->setSelectionMode(HgWidget::NoSelection);

    disconnect( mWidget->selectionModel() , SIGNAL( selectionChanged(const QItemSelection &, const QItemSelection& ) ), this, SLOT( showMarkedItemCount() ) );

    disconnect(mMarkCheckBox, SIGNAL( stateChanged(int) ), this, SLOT( stateChanged(int)));

    if (mMarkSelectHeading) {

        mMarkSelectHeading->hide();

    }

    if (mMarkingWidget) {

        mMarkingWidget->hide();

    }     

    if (mMarkCheckBox) {

       mMarkCheckBox->setCheckState(Qt::Unchecked);

    }

    showHbItems();

}

void GlxGridView::stateChanged(int state)

{

    if(state)

        handleUserAction(EGlxCmdMarkAll);

    else

        handleUserAction(EGlxCmdUnMarkAll);

}

void GlxGridView::showMarkedItemCount()

{

    int count = mModel->rowCount();

    QModelIndexList indexList = mWidget->selectionModel()->selectedIndexes();

}

void GlxGridView::showItemCount()

{

    int count = 0;

    if( mModel ) {

        count = mModel->rowCount();

        QSize deviceSize = HbDeviceProfile::current().logicalSize();

        QSize screenSize = ( mWindow->orientation() == Qt::Vertical ) ? QSize( deviceSize.width(), deviceSize.height() )

                                                                       : QSize( deviceSize.height(), deviceSize.width() )  ;

        if( count ) {

            if(mZeroItemLabel) {

                mZeroItemLabel->hide();

            }

            if( isItemVisible( Hb::TitleBarItem ) ) {

                QString text;

                if(XQServiceUtil::isService()) {

                    showAlbumTitle(GLX_SELECT_IMAGE);

                }

                else if ( getSubState() == ALL_ITEM_S ) {

					if (mAlbumNameHeading) {

                    	mAlbumNameHeading->hide();

					}

                    text = HbParameterLengthLimiter(GLX_GRID_VIEW_COUNT_LABEL, count); 

                    mTotalImagesCount->setHeading ( text );

                    mTotalImagesCount->show();

                }

                else if ( getSubState() == ALBUM_ITEM_S ) {

                    mTotalImagesCount->hide();

                    QVariant variant = mModel->data(mModel->index(0,0),GlxViewTitle);

                    if (variant.toString() != NULL) {

                        showAlbumTitle(variant.toString());

                    }

                }

            }

            else {

                if (mTotalImagesCount) {

                    mTotalImagesCount->hide();

                }

                if (mAlbumNameHeading) {

                    mAlbumNameHeading->hide();

                }

            }

        }

        else {

            bool populated = FALSE;

            QVariant variant = mModel->data(mModel->index(0,0),GlxPopulated);

            if (variant.isValid() &&  variant.canConvert<bool>() )

                {

                populated = variant.value<bool>();

                }

            if(populated) {

                if (mTotalImagesCount) {

                    mTotalImagesCount->hide();

                }

                if (mAlbumNameHeading) {

                    mAlbumNameHeading->hide();

                }

                showNoImageString();

                if (getSubState() == ALBUM_ITEM_S) {

                    QVariant variant = mModel->data(mModel->index(0,0),GlxViewTitle);

                    if (variant.toString() != NULL) {

                        showAlbumTitle(variant.toString());

                    }

				}	

            }

        }

    }

}

void GlxGridView::showAlbumTitle(QString aTitle)

{

    int count = mModel->rowCount();

    QSize deviceSize = HbDeviceProfile::current().logicalSize();

    QSize screenSize = ( mWindow->orientation() == Qt::Vertical ) ? QSize( deviceSize.width(), deviceSize.height() )

                                                                   : QSize( deviceSize.height(), deviceSize.width() )  ;

    if (mAlbumNameHeading == NULL)

        {

        mAlbumNameHeading = new HbGroupBox(this);

        mAlbumNameHeading->setObjectName("Album Name");

        }

    //If fetcher service set only title text

    if ((XQServiceUtil::isService()) && isItemVisible(Hb::TitleBarItem))

        mAlbumNameHeading->setHeading(aTitle);

        mAlbumNameHeading->show();

        }

    else

        { //handle album tiltle and count display logic here

        if (isItemVisible(Hb::TitleBarItem))

            {

            mAlbumNameHeading->setHeading(text);

            mAlbumNameHeading->show();

            }

        }

}

void GlxGridView::showNoImageString()

{

    qreal chromeHeight = 0.0;

    QSize deviceSize = HbDeviceProfile::current().logicalSize();

    QSize screenSize = ( mWindow->orientation() == Qt::Vertical ) ? QSize( deviceSize.width(), deviceSize.height() )

                                                                   : QSize( deviceSize.height(), deviceSize.width() )  ;

    qreal midHeight = screenSize.height()/2;

    if (isItemVisible(Hb::TitleBarItem)) {

        style()->parameter("hb-param-widget-chrome-height", chromeHeight);

        midHeight -= chromeHeight;

    }

    if (mZeroItemLabel == NULL) {

        QString displayText(GLX_GRID_NO_IMAGE); 

        mZeroItemLabel = new HbLabel(displayText, this);

        mZeroItemLabel->setObjectName( "No Image" );

    }

    mZeroItemLabel->setGeometry(QRectF(0, midHeight - deviceSize.height()/16, screenSize.width(), 3*deviceSize.height()/32));

    mZeroItemLabel->setAlignment(Qt::AlignHCenter);

    mZeroItemLabel->show();

}

void GlxGridView::populated()

{

    QVariant variant = mModelWrapper->data(mModelWrapper->index(0,0), GlxVisualWindowIndex );

    int visualIndex = 0;

    if ( variant.isValid() &&  variant.canConvert<int> () )  {

        visualIndex = variant.value<int>();

    }

    mWidget->scrollTo(mModelWrapper->index(visualIndex,0));

    showItemCount();

}

void GlxGridView::rowsInserted()

{

    showItemCount();

    if( getSubState() == ALBUM_ITEM_S  && mToolBar ) {

        mToolBar->actions().at(0)->setEnabled( true ); //To:Do remove once selection dialog is implemented

        mToolBar->actions().at(1)->setEnabled( true );

    }

}

void GlxGridView::rowsRemoved()

{

    showItemCount(); 

    if( getSubState() == ALBUM_ITEM_S  && mModel->rowCount() == 0 && mToolBar ) {

        mToolBar->actions().at(0)->setEnabled( false ); //To:Do remove once selection dialog is implemented

        mToolBar->actions().at(1)->setEnabled( false );

    }    

}

void GlxGridView::handleToolBarAction()

{

    HbAction *action = qobject_cast<HbAction*>( sender() );

    qint32 commandId = action->data().toInt();