/*

* 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

*

*/

#include <glxviewmanager.h>

#include <glxview.h>

#include "glxicondefs.h" //Contains the icon names/Ids

#include <glxviewsfactory.h>

#include <glxeffectengine.h>

#include <hbmainwindow.h>

#include <glxexternalutility.h>

#include <glxloggerenabler.h>

#include <glxmenumanager.h>

#include <glxcommandhandlers.hrh>

#include <glxplugincommandid.hrh>

#include "glxlocalisationstrings.h"

#include <hbaction.h>

#include <hbtoolbar.h>

#include <hbmenu.h>

#include <QDebug>

#include <hbstyleloader.h>

#include <hbprogressdialog.h>

#include <QItemSelectionModel>

#include <glxmainwindoweventfilter.h>

#include <xqsettingsmanager.h>

#include <xqsettingskey.h>

#include <glxviewids.h>

#include "glxmodelroles.h"

GlxViewManager::GlxViewManager() 

    : mBackAction( NULL ), 

      mMenuManager( NULL ), 

      mEffectEngine( NULL ), 

      mViewToolBar( NULL ), 

      mMarkingToolBar( NULL ), 

      mSelectionModel ( NULL ),

      mProgressDialog( NULL )

{

    qDebug("GlxViewManager::GlxViewManager() ");

    //check the case when application launch through some other application (view plugin)

    mMainWindow = GlxExternalUtility::instance()->getMainWindow();

    if(mMainWindow == NULL)	{

        mMainWindow = new HbMainWindow();

    }

    connect(mMainWindow, SIGNAL( viewReady() ), this, SLOT( handleReadyView() ));

    //Without this Zoom Does not work

    mWindowEventFilter = new GlxMainWindowEventFilter;

    mMainWindow->scene()->installEventFilter(mWindowEventFilter);

    mMainWindow->viewport()->setAttribute(Qt::WA_AcceptTouchEvents);

    mMainWindow->viewport()->grabGesture(Qt::PinchGesture);

    HbStyleLoader::registerFilePath(":/data/photos.css");

}

void GlxViewManager::handleReadyView()

{

    emit actionTriggered( EGlxCmdSetupItem );

    disconnect( mMainWindow, SIGNAL( viewReady() ), this, SLOT( handleReadyView() ) );

}

void GlxViewManager::setupItems( )

{

    addBackSoftKeyAction();    

    addConnection();

}

void GlxViewManager::launchApplication(qint32 id, QAbstractItemModel *model)

{

    mModel = model;

    mMenuManager = new GlxMenuManager( mMainWindow );  //menu manager should be created before view.

    mMenuManager->setModel( mModel );

    mView = resolveView( id );

    createToolBar();

    /* We are showing the toolBar before activating the 

     * view. This is done to avoid the animation effect seen otherwise 

     * when the tool bar comes up.

     * 

     * If animation Effect is not removed, it leads to flickering effect 

     * since we are creating a new tool bar..although a fake tool bar was 

     * already created on the splashscreen

     * 

     */

    mView->activate();

    mView->setModel( mModel );

    //visibility of tool bar dependes of view internal state so add the toolbar after setting model

    mView->addToolBar( mViewToolBar ); 

    mMainWindow->setCurrentView( mView, false );

    mMainWindow->showFullScreen();

}

void GlxViewManager::handleMenuAction(qint32 commandId)

{

    emit actionTriggered(commandId);

}

void GlxViewManager::handleAction()

{

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

    action->setChecked( TRUE );

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

    emit actionTriggered(commandId);

}

void GlxViewManager::addBackSoftKeyAction ( )

{

    qDebug("GlxViewManager::addBackSoftKeyAction ");

    //create the back soft key action and set the data

    mBackAction = new HbAction( Hb::BackNaviAction, this );

    mBackAction->setData( EGlxCmdBack );

    mBackAction->setObjectName( "App Back" );

    mView->setNavigationAction( mBackAction );

}

Qt::Orientation GlxViewManager::orientation() const

{

    return mMainWindow->orientation();

}

void GlxViewManager::launchView( qint32 id, QAbstractItemModel *model )

{

    qDebug( "GlxViewManager::launchView Id = %d ", id );

    mModel = model;

    deActivateView();

    mMenuManager->setModel( mModel ); //set the model to get the item type info and row count info

    mView = resolveView( id );

    activateView();

}

void GlxViewManager::launchView (qint32 id, QAbstractItemModel *model, GlxEffect effect, GlxViewEffect viewEffect)

{

    qDebug("GlxViewManager::launchView Id = %d effect %d view effect %d", id, effect, viewEffect);

    //In the case of no animation is play during the view transition just call launch view and return

    if ( viewEffect == NO_VIEW ) {

        return launchView(id, model);

    }

    //create and registered the effect

    if ( mEffectEngine == NULL ) { 

        mEffectEngine = new GlxEffectEngine();

        mEffectEngine->registerTransitionEffect();

        connect( mEffectEngine, SIGNAL( effectFinished() ), this, SLOT( effectFinished() ), Qt::QueuedConnection );

    }

    QList< QGraphicsItem * > itemList;

    QGraphicsItem *item = NULL;

    itemList.clear();

    //partially clean the view so that animation run smoothly

    GlxView *curr_view = (GlxView *) mMainWindow->currentView();

    curr_view->resetView();

    mMenuManager->setModel( model ); //set the model to get the item type info and row count info

    mView = resolveView(id);

    //partially initialise the view so that animation run smoothly

    mView->initializeView( model, curr_view );

    mModel = model; 

    if ( viewEffect == CURRENT_VIEW || viewEffect == BOTH_VIEW ) { 

        item = curr_view->getAnimationItem(effect);

        if ( item ) {

            itemList.append(item);

            item = NULL;

        }

    }

    if ( viewEffect == LAUNCH_VIEW || viewEffect == BOTH_VIEW ) {

        item = mView->getAnimationItem(effect);

        if ( item ) {

            //increase the z value and show the view to shown the view animation

            mView->setZValue(curr_view->zValue() + 2);

            mView->show();

            item->show();        

            itemList.append(item);

        }

    }

    if ( effect == GRID_TO_FULLSCREEN ) {

        mViewToolBar->setZValue( item->zValue() - 5 );

    }

    //error check

    if ( itemList.count() > 0 ) {

        mEffectEngine->runEffect(itemList, effect);

        mMainWindow->grabMouse();

    }

    else {

        deActivateView();

        activateView();       

    }    

}

void GlxViewManager::launchProgressDialog( int maxValue )

{

    if ( maxValue <= 0 ) {

        // TNM return the some error code ( negative value ) until it populated the count

		// To show progress dialog 10 is chossen

	     maxValue = 10;

    }

    if ( mProgressDialog == NULL ) {

        mProgressDialog = new HbProgressDialog( HbProgressDialog::ProgressDialog );

        mProgressDialog->actions().at(0)->disconnect( SIGNAL( triggered() ) );

        connect ( mProgressDialog->actions().at(0), SIGNAL( triggered() ), this, SLOT( hideProgressDialog() ) );

        mProgressDialog->setMinimum( 0 );

    }

    mProgressDialog->setMaximum( maxValue );

    mProgressDialog->setProgressValue( 0 );

    mProgressDialog->setModal( true );

    mProgressDialog->actions().at(0)->setText( GLX_BUTTON_HIDE );

    mProgressDialog->open();

}

void GlxViewManager::hideProgressDialog( )

{

    mMainWindow->lower();

}

void GlxViewManager::updateProgressDialog( int currentValue )

{

    static int i = 0;

    HbIcon icon;

    User::ResetInactivityTime();  

    QString text( GLX_REFRESHING );

    if ( mProgressDialog ) {

        i = ++i % 10;

        icon = HbIcon( QString( ":/data/Wait/qgn_graf_ring_wait_%1.svg" ).arg( i + 1, 2, 10, QChar( '0' ) ) );

        mProgressDialog->setIcon(icon);

        int max = mProgressDialog->maximum() ;

        if ( currentValue > max ) {

            mProgressDialog->setMaximum( currentValue );

            max = currentValue ;

        }

        if ( currentValue < 0 ) {

            mProgressDialog->setText( text ); 

            mProgressDialog->setProgressValue( 0 );

            mProgressDialog->setProgressDialogType( HbProgressDialog::WaitDialog );

        }

        else {

            int value = max - currentValue;

            mProgressDialog->setProgressValue( value );

            text.append( QString( "\n  %1 " ).arg( currentValue ) );

            mProgressDialog->setText( text );

            mProgressDialog->setProgressDialogType( HbProgressDialog::ProgressDialog );

        }

    }

}

//to be called only when the photos plugin was activated by external means

void GlxViewManager::deactivateCurrentView()

{

    GlxView *curr_view = (GlxView *) mMainWindow->currentView();

    if ( curr_view ) {

        curr_view->deActivate() ;

    }

}

void GlxViewManager::updateToolBarIcon(int id)

{

    QString path;

    int toolBarActionId = (int) GLX_ALL_ACTION_ID;

    int count = mActionList.count();

    qDebug("GlxViewManager::updateToolBarIcon() action ID list %d count %d", id, count);

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

        qDebug("GlxViewManager::updateToolBarIcon() toolBarActionId %d value %d", toolBarActionId, ( id & toolBarActionId ) );

        //check and get the icon path

        if ( ( id & toolBarActionId ) == toolBarActionId ) {

            mActionList[i]->setChecked(TRUE);                        

        }

        else {

            mActionList[i]->setChecked(FALSE);

        }

        //to get it the next action id to verify it is selecter or not

        toolBarActionId = toolBarActionId << 1; 

    }

}

void GlxViewManager::checkMarked()

{

    qDebug("GlxViewManager::checkMarked");

    QModelIndexList selectedModelIndex = mSelectionModel->selectedIndexes();

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

        if( mMarkingActionList.at(i)->data()==EGlxCmdSelect) {

       	    bool noSelection=selectedModelIndex.empty();

            mMarkingActionList.at(i)->setDisabled(noSelection);

            break;

        }

    }

}

{

    GlxView *view = findView ( viewId );

    qDebug("GlxViewManager::enterMarkingMode view ID %d", viewId);

        createMarkingModeToolBar(); //Marking mode tool bar is different from normal mode tool bar

    }

    if ( view ) { 

        view->enableMarking();

        view->takeToolBar();

        view->addToolBar(mMarkingToolBar);

        mSelectionModel = view->getSelectionModel();

        if(mSelectionModel) 

        {

            connect(mSelectionModel, SIGNAL(selectionChanged(const QItemSelection &, const QItemSelection& ) ), this, SLOT(checkMarked()));

            checkMarked();

        }

    }

    qDebug("GlxViewManager::enterMarkingMode view ID %d exit", viewId);

}

{

    GlxView *view = findView ( viewId );

    qDebug("GlxViewManager::exitMarkingMode view ID %d", viewId);

    if ( view ) { 

        view->disableMarking(); 

        view->takeToolBar();

        view->addToolBar(mViewToolBar);

        if(mSelectionModel)

        {

            disconnect(mSelectionModel, SIGNAL(selectionChanged(const QItemSelection &, const QItemSelection& ) ), this, SLOT(checkMarked()));

        }

    }

    qDebug("GlxViewManager::exitMarkingMode view ID %d exit", viewId);

}

void GlxViewManager::handleUserAction(qint32 viewId, qint32 commandId)

{

    GlxView *view = findView ( viewId );

    qDebug("GlxViewManager::handleUserAction view ID %d command id %d", viewId, commandId);

    if ( view ) { 

        view->handleUserAction(commandId);

    }    

}

QItemSelectionModel *  GlxViewManager::getSelectionModel(qint32 viewId) 

{ 

    GlxView *view = findView ( viewId );

    if ( view ) { 

        return view->getSelectionModel();

    }

    return NULL;

}

void GlxViewManager::setModel( QAbstractItemModel *model )

{

    if ( mView ) {

        mView->setModel( model ) ;

    }

    if ( mMenuManager ) {

        mMenuManager->setModel( model );

    }    

}

GlxView * GlxViewManager::resolveView( qint32 id )

{

    qDebug("GlxViewManager::resolveView %d", id );

    GlxView *view = findView ( id );

    if ( view ) {

        return view ;

    }

    view = GlxViewsFactory::createView( id, mMainWindow );

    if ( view ) {

        connect ( view, SIGNAL( actionTriggered( qint32 ) ), this, SLOT( actionProcess( qint32 ) ), Qt::QueuedConnection );

        connect ( view, SIGNAL( itemSpecificMenuTriggered( qint32, QPointF ) ), this, SLOT( itemSpecificMenuTriggered( qint32, QPointF ) ), Qt::QueuedConnection );

        mViewList.append( view );

        mMainWindow->addView( view );

        mMenuManager->addMenu( id, view->menu() );

        if ( mBackAction ) {

            view->setNavigationAction( mBackAction );

        }

    }

    return view;

}

void GlxViewManager::itemSpecificMenuTriggered(qint32 viewId,QPointF pos)

{

    mMenuManager->ShowItemSpecificMenu(viewId,pos);

}

void GlxViewManager::cancelTimer()

{

    emit externalCommand(EGlxPluginCmdUserActivity);

}

void GlxViewManager::effectFinished( )

{

    qDebug("GlxViewManager::EffectFinished");

    mMainWindow->releaseMouse();

    deActivateView();

    activateView(); 

}

GlxView * GlxViewManager::findView(qint32 id)

{

    qDebug("GlxViewManager::findView Id = %d ", id);

    int count = mViewList.count();

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

        if ( mViewList.at(i)->compare(id) ) {

            return mViewList.at(i);

        }

    }

    return NULL;

}

void GlxViewManager::deActivateView()

{

    qDebug("GlxViewManager::deActivateCurrentView()");

    GlxView *view = (GlxView *) mMainWindow->currentView();

    if ( view ){

        view->deActivate() ;

    }

    if (mView && view) {

        mView->setZValue(view->zValue());

    }

}

void GlxViewManager::activateView()

{

    qDebug("GlxViewManager::activateView()");

    mView->activate();

    mView->show();

    mView->setModel( mModel );

    //visibility of tool bar dependes of view internal state so add the toolbar after setting model

    mView->addToolBar( mViewToolBar );

    mMainWindow->setCurrentView(mView, false);

    mMainWindow->showFullScreen(); 

}

void GlxViewManager::createActions()

{

    qDebug("GlxViewManager::createActions() " );

    mActionList.clear();  

    int curSubstate = getSubState();    

    //create the All tool bar button action

    HbAction* allAction = new HbAction( this );

    if( curSubstate == FETCHER_ITEM_S ) {

        allAction->setData( EGlxCmdFetcherAllGridOpen );

    }else{

        allAction->setData( EGlxCmdAllGridOpen );

    }

    mActionList.append( allAction );    

    allAction->setIcon( HbIcon( GLXICON_ALL ) ) ;

    allAction->setObjectName( "All Action" );

    //create the Album tool bar button action

    HbAction* albumAction = new HbAction( this );

    if( curSubstate == FETCHER_ITEM_S ) {

        albumAction->setData( EGlxCmdFetcherAlbumListOpen );

    }else{

        albumAction->setData( EGlxCmdAlbumListOpen );

    }

    mActionList.append( albumAction );

    albumAction->setIcon( HbIcon( GLXICON_ALBUMS ) ) ;

    albumAction->setObjectName( "Album Action" );

	//in case of fetcher no need to create other actions

	if( curSubstate == FETCHER_ITEM_S ) {

		return;

		}	

    //create the album tool bar button action

    HbAction* cameraAction = new HbAction( this );