diff -r f7f0874bfe7d -r 74c9f037fd5d ui/viewmanagement/statehandler/src/glxstatemanager.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/ui/viewmanagement/statehandler/src/glxstatemanager.cpp	Fri Mar 19 09:28:59 2010 +0200
@@ -0,0 +1,547 @@
+/*
+* 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 <glxstatemanager.h>
+#include <glxviewmanager.h>
+#include <glxviewids.h>
+#include <glxmediamodel.h>
+#include <glxgridstate.h>
+#include <glxliststate.h>
+#include <glxfullscreenstate.h>
+#include <glxdetailstate.h>
+#include <glxslideshowstate.h>
+#include <glxmodelparm.h>
+#include <glxcollectionpluginall.hrh>
+#include <glxcollectionplugincamera.hrh>
+#include <glxcollectionpluginalbums.hrh>
+#include <glxcollectionpluginimageviewer.hrh>
+#include <glxexternalutility.h>
+#include <glxalbummodel.h>
+#include <glxloggerenabler.h>
+#include <glxmediaid.h>
+#include "processhandler.h"
+#include <glxactionhandler.h>
+#include <glxcommandhandlers.hrh>
+#include <QApplication>
+#include <glxplugincommandid.hrh>
+#include <QDebug>
+#include <QItemSelectionModel>
+#include <hbmessagebox.h>
+
+GlxStateManager::GlxStateManager() : mAllMediaModel(NULL), mAlbumGridMediaModel(NULL),
+            mAlbumMediaModel(NULL),mImageviewerMediaModel(NULL), mCurrentModel (NULL), mCurrentState (NULL), mActionHandler (NULL)
+{
+    qDebug("GlxStateManager::GlxStateManager");
+    PERFORMANCE_ADV ( d1, "view manager creation time") {
+        mViewManager = new GlxViewManager();
+    }
+    connect ( this, SIGNAL( setupItemsSignal() ), this, SLOT( setupItems() ), Qt::QueuedConnection );
+    connect ( mViewManager, SIGNAL(actionTriggered(qint32 )), this, SLOT(actionTriggered(qint32 )) );
+	//TO:DO TBD through exception when it is null
+}
+
+void GlxStateManager::enterMarkingMode()
+{
+    mViewManager->enterMarkingMode(mCurrentState->id());
+}
+
+void GlxStateManager::exitMarkingMode()
+{
+    mViewManager->exitMarkingMode(mCurrentState->id());
+}
+
+bool GlxStateManager::executeCommand(qint32 commandId)
+{
+    qDebug( "GlxStateManager::executeCommand() : command ID %d", commandId);
+    QItemSelectionModel * selectionModel = mViewManager->getSelectionModel(mCurrentState->id());
+    if ( selectionModel == NULL )
+        return FALSE;
+    
+    QModelIndexList indexList = selectionModel->selectedIndexes();
+    //if no item is selected then do nothing
+    if (indexList.count() == 0) 
+        return FALSE;
+    
+    for ( int i = 0; i < indexList.count(); i++) {
+        qDebug( "GlxGridView::doneAction() : index %d", indexList[i].row());            
+        mCurrentModel->setData( indexList[i], indexList[i].row(), GlxSelectedIndexRole );
+    }
+    mActionHandler->handleAction(commandId, mCollectionId);
+    return TRUE;
+}
+
+void GlxStateManager::launchApplication()
+{
+   qDebug("GlxStateManager::launchApplication");   
+   //To:Do use it in future once performance code is removed nextState(GLX_GRIDVIEW_ID, ALL_ITEM_S)
+   
+   mCurrentState = createState(GLX_GRIDVIEW_ID);
+   mCurrentState->setState(ALL_ITEM_S);
+   
+   PERFORMANCE_ADV ( d1, "Media model creation time" ) {
+       createModel(GLX_GRIDVIEW_ID);
+   }
+   
+   PERFORMANCE_ADV ( d2, "Grid View Launch time" ) {
+       mViewManager->launchApplication( GLX_GRIDVIEW_ID, mCurrentModel);
+   }   
+}
+
+void GlxStateManager::launchFromExternal()
+{
+    qDebug("GlxStateManager::launchApplication");
+    mCurrentState = createState(GLX_FULLSCREENVIEW_ID);
+    mCurrentState->setState(IMAGEVIEWER_S);
+    
+    createModel(GLX_FULLSCREENVIEW_ID);
+    mCurrentModel->setData( mCurrentModel->index(0,0), 0, GlxFocusIndexRole );
+    mViewManager->launchApplication( GLX_FULLSCREENVIEW_ID, mCurrentModel);
+    //todo remove state dependency from view manager
+	mViewManager->setupItems(IMAGEVIEWER_S);
+}
+
+void GlxStateManager::actionTriggered(qint32 id)
+{
+    qDebug("GlxStateManager::actionTriggered action ID = %d", id);
+    mCurrentState->eventHandler(id);
+    if (id != EGlxCmdHandled ) {
+        eventHandler(id);
+    }
+}
+
+void GlxStateManager::setupItems()
+{    
+    qDebug("GlxStateManager::setupItems()");
+    mActionHandler = new GlxActionHandler();
+    connect ( mViewManager, SIGNAL(externalCommand(int )), this, SIGNAL(externalCommand(int )) );
+    mViewManager->setupItems();
+    mViewManager->updateToolBarIcon(GLX_ALL_ACTION_ID);
+}
+
+void GlxStateManager::nextState(qint32 state, int internalState)
+{
+    qDebug("GlxStateManager::nextState next state = %u", state);
+    GlxEffect effect = NO_EFFECT ;
+    GlxViewEffect viewEffect = NO_VIEW ;
+    
+    PERFORMANCE ( d1, State Creation Time ) {
+        mCurrentState = createState(state); //create a new state
+        mCurrentState->setState(internalState); 
+    }
+    
+    createModel(state); //model should created after the internal state was set.
+    
+    PERFORMANCE ( d2, view launch time ) {
+        mCurrentState->setTranstionParameter( FORWARD_DIR, effect, viewEffect); // to run the transtion effect
+        if ( viewEffect == NO_VIEW ) {
+            mViewManager->launchView( state, mCurrentModel );
+        }
+        else {
+            mViewManager->launchView( state, mCurrentModel, effect, viewEffect);
+        }
+    }
+}
+
+void GlxStateManager::previousState()
+{
+    qDebug("GlxStateManager::previousState");
+    GlxEffect effect = NO_EFFECT ;
+    GlxViewEffect viewEffect = NO_VIEW ;
+
+    GlxState *state = mCurrentState; // To delete the current state later  
+
+    if ( mCurrentState->previousState() == NULL ) { //In the case only one state in stack then exit from the application
+        exitApplication() ;
+        mCurrentState = NULL;
+    }
+    else {
+        //effect parameter should be set here other wise there is no way to know from where it come from
+        mCurrentState->setTranstionParameter( BACKWARD_DIR, effect, viewEffect);
+        mCurrentState = mCurrentState->previousState(); //get the pervious state
+        createModel( mCurrentState->id(), BACKWARD_DIR ); 
+
+        if ( viewEffect == NO_VIEW ) {
+            mViewManager->launchView( mCurrentState->id(), mCurrentModel );
+        }
+        else {
+            mViewManager->launchView( mCurrentState->id(), mCurrentModel, effect, viewEffect);
+        }
+    }
+    delete state;
+}
+   
+void GlxStateManager::goBack(qint32 stateId, int internalState)
+{
+    qDebug("GlxStateManager::goBack()");
+    GlxState *state = mCurrentState;
+    
+    do {
+        mCurrentState = mCurrentState->previousState(); // set pervious state to the current state
+        delete state; //delete the current state
+        state = mCurrentState;
+    }
+    while ( mCurrentState && mCurrentState->id() != stateId ); //check, cuurent state is a new state
+    
+    //case when new state is not hierarchy then create a new state
+    if ( mCurrentState == NULL ) {
+        mCurrentState = createState(stateId);
+        mCurrentState->setState( internalState );
+    }   
+    
+    qDebug("GlxStateManager::goBack() state %u", mCurrentState);
+    createModel( mCurrentState->id() ); //model should created after the internal state was set.
+    mViewManager->launchView( mCurrentState->id(), mCurrentModel );   
+}
+
+void GlxStateManager::changeState(qint32 stateId, int internalState)
+{
+    qDebug("GlxStateManager::changeState %d", stateId);	
+    
+    GlxState *state = mCurrentState;
+    GlxEffect effect = NO_EFFECT ;
+    GlxViewEffect viewEffect = NO_VIEW ;
+
+    mCurrentState = mCurrentState->previousState();//pervious state of current state become the pervious state of new state 
+    
+    mCurrentState = createState(stateId);
+    mCurrentState->setState( internalState );
+    createModel( stateId ); //model should created after the internal state was set.
+    
+    mCurrentState->setTranstionParameter( NO_DIR, effect, viewEffect); //set the transition parameter    
+    if ( viewEffect == NO_VIEW ) {
+        mViewManager->launchView( mCurrentState->id(), mCurrentModel );
+    }
+    else {
+        mViewManager->launchView( mCurrentState->id(), mCurrentModel, effect, viewEffect);
+    }
+    delete state;
+}
+
+void GlxStateManager::removeCurrentModel()
+{
+    if ( mCurrentModel == mAllMediaModel ) {
+        qDebug("GlxStateManager::removeCurrentModel() remove all media model");	
+        delete mAllMediaModel ;
+        mAllMediaModel = NULL ;
+        mCurrentModel = NULL ;
+    }
+    else if ( mCurrentModel == mAlbumGridMediaModel ) {
+        qDebug("GlxStateManager::removeCurrentModel() remove album grid media model");	
+        delete mAlbumGridMediaModel ;
+        mAlbumGridMediaModel = NULL ;
+        mCurrentModel = NULL ;
+    }
+    else if ( mCurrentModel == mAlbumMediaModel ) {
+        qDebug("GlxStateManager::removeCurrentModel() remove  model");	
+        delete mAlbumMediaModel ;
+        mAlbumMediaModel = NULL ;
+        mCurrentModel = NULL ;
+    }
+    else {
+    	qDebug("GlxStateManager::removeCurrentModel() do nothing");
+    	//do nothing
+    }
+}
+
+GlxState * GlxStateManager::createState(qint32 stateId)
+{
+    qDebug("GlxStateManager::createState state id = %d", stateId);
+    
+    switch( stateId ) {    
+    case GLX_GRIDVIEW_ID :
+        return new GlxGridState( this, mCurrentState );
+        
+    case GLX_LISTVIEW_ID :
+        return new GlxListState( mCurrentState );    	
+    	
+    case GLX_FULLSCREENVIEW_ID :
+        return new GlxFullScreenState( mCurrentState );
+        
+    case GLX_DETAILSVIEW_ID:
+        return new GlxDetailState( mCurrentState );
+        
+    case GLX_SLIDESHOWVIEW_ID :
+        return new GlxSlideShowState( this, mCurrentState );
+    	
+    default :
+        return NULL;		
+    } 
+}
+
+void GlxStateManager::createModel(qint32 stateId, NavigationDir dir)
+{
+    switch( stateId ) {
+    case GLX_GRIDVIEW_ID :
+        createGridModel( mCurrentState->state(), dir );
+        mCurrentModel->setData(QModelIndex(), (int)GlxContextGrid, GlxContextRole );
+        break;
+
+    case GLX_LISTVIEW_ID :
+    	//To:Do change the code when integrate the album list model
+        if (mAlbumMediaModel == NULL) {
+            GlxModelParm modelParm (KGlxCollectionPluginAlbumsImplementationUid, 0);
+            mAlbumMediaModel = new GlxAlbumModel (modelParm);
+        }
+        mCurrentModel = mAlbumMediaModel;
+        mCurrentModel->setData(QModelIndex(), (int)GlxContextPtList, GlxContextRole );
+        mViewManager->updateToolBarIcon(GLX_ALBUM_ACTION_ID);
+        break;
+        
+    case GLX_FULLSCREENVIEW_ID :
+		if ( mCurrentState->state() == IMAGEVIEWER_S) {
+                GlxModelParm modelParm (KGlxCollectionPluginImageViewerImplementationUid, 0);
+                mCurrentModel = mImageviewerMediaModel = new GlxMediaModel (modelParm);
+		}
+        else if ( mCurrentState->state() == EXTERNAL_S) {
+            if(!mAllMediaModel) {
+                GlxModelParm modelParm (KGlxCollectionPluginAllImplementationUid, 0);
+                mCurrentModel = mAllMediaModel = new GlxMediaModel (modelParm);
+            }
+            else {
+                mCurrentModel = mAllMediaModel;
+            }
+        mCollectionId = KGlxCollectionPluginAllImplementationUid;
+        }
+        if ( mViewManager->orientation() == Qt::Horizontal ) {
+            mCurrentModel->setData(QModelIndex(), (int)GlxContextLsFs, GlxContextRole );
+        }
+        else {
+            mCurrentModel->setData(QModelIndex(), (int)GlxContextPtFs, GlxContextRole );
+        }
+        break;
+        
+    case GLX_DETAILSVIEW_ID :
+        if ( mViewManager->orientation() == Qt::Horizontal ) {
+            mCurrentModel->setData(QModelIndex(), (int)GlxContextLsFs, GlxContextRole );
+        }
+        else {
+            mCurrentModel->setData(QModelIndex(), (int)GlxContextPtFs, GlxContextRole );
+        }
+        break;
+        
+    case GLX_SLIDESHOWVIEW_ID :
+        if ( mCurrentState->state() == ALBUM_ITEM_S ) {
+            GlxModelParm modelParm ( KGlxAlbumsMediaId , 0);
+            mCurrentModel = mAlbumGridMediaModel = new GlxMediaModel( modelParm );
+        }
+        if ( mViewManager->orientation() == Qt::Horizontal ) {
+            mCurrentModel->setData(QModelIndex(), (int)GlxContextLsFs, GlxContextRole );
+        }
+        else {
+            mCurrentModel->setData(QModelIndex(), (int)GlxContextPtFs, GlxContextRole );
+        }
+        break;
+    	    	
+    default :
+        break;
+    }
+}
+
+void GlxStateManager::createGridModel(int internalState, NavigationDir dir)
+{
+    GlxModelParm modelParm;
+    
+    switch( internalState) {
+    case ALL_ITEM_S :
+        if ( mAllMediaModel == NULL ) {
+            modelParm.setCollection( KGlxCollectionPluginAllImplementationUid );
+            modelParm.setDepth(0);
+            mAllMediaModel = new GlxMediaModel( modelParm );
+        }
+        mCollectionId = KGlxCollectionPluginAllImplementationUid;
+        mCurrentModel = mAllMediaModel;
+        mViewManager->updateToolBarIcon(GLX_ALL_ACTION_ID);
+        break;
+        
+    case ALBUM_ITEM_S :
+        if ( dir != BACKWARD_DIR ) { 
+            modelParm.setCollection( KGlxAlbumsMediaId );
+            modelParm.setDepth(0); 
+            mAlbumGridMediaModel = new GlxMediaModel( modelParm );
+        }               
+        mCollectionId = KGlxAlbumsMediaId;
+        mCurrentModel = mAlbumGridMediaModel ;
+        mViewManager->updateToolBarIcon(NO_ACTION_ID);
+        break;
+    
+    default :
+        break;
+    }
+}
+
+void GlxStateManager::eventHandler(qint32 &id)
+{
+    qDebug("GlxStateManager::eventHandler action id = %d", id);
+    switch(id) {
+    case EGlxCmdAllGridOpen :
+        changeState( GLX_GRIDVIEW_ID, ALL_ITEM_S );
+        id = EGlxCmdHandled;
+        break;
+    	
+    case EGlxCmdAlbumListOpen:
+        changeState( GLX_LISTVIEW_ID, -1 );
+        id = EGlxCmdHandled;
+        break;
+    	
+    case EGlxCmdAlbumGridOpen:
+        nextState( GLX_GRIDVIEW_ID, ALBUM_ITEM_S );
+        id = EGlxCmdHandled;
+        break;
+      
+    case EGlxCmdFirstSlideshow :
+        //play the slide show with first item
+        mCurrentModel->setData( mCurrentModel->index(0, 0), 0, GlxFocusIndexRole );
+        nextState( GLX_SLIDESHOWVIEW_ID, SLIDESHOW_GRID_ITEM_S );
+        id = EGlxCmdHandled;
+        break;
+        
+    case EGlxCmdSelectSlideshow:
+        //play the slide show with selected item
+        nextState( GLX_SLIDESHOWVIEW_ID, SLIDESHOW_GRID_ITEM_S );
+        id = EGlxCmdHandled;
+        break;
+        
+    case EGlxCmdAlbumSlideShow:
+        //play the slide show for a album
+        nextState( GLX_SLIDESHOWVIEW_ID, SLIDESHOW_ALBUM_ITEM_S );
+        id = EGlxCmdHandled;
+        break;
+        
+    case EGlxCmdDetailsOpen:
+        qDebug("GlxStateManager::eventHandler EGlxCmdDetailsOpen");
+        nextState( GLX_DETAILSVIEW_ID, -1 );
+        id = EGlxCmdHandled;
+        break;
+        
+    case EGlxCmdEmptyData :
+        goBack(GLX_GRIDVIEW_ID, NO_GRID_S);
+        id = EGlxCmdHandled;
+        break;
+    	
+    case EGlxCmdBack :
+    	previousState();
+    	id = EGlxCmdHandled;
+    	break;
+    	
+    /*case EGlxCmdCameraOpen:
+		{
+        ProcessHandler*  processHandler = new ProcessHandler(this);
+        processHandler->StartCameraApp();
+        id = EGlxCmdHandled;
+		}
+        break;	*/
+    case EGlxCmdOviOpen:
+		{
+		HbMessageBox box(HbMessageBox::MessageTypeInformation);
+		box.setText("Not Implemented");
+		box.exec();
+        id = EGlxCmdHandled;
+		}
+        break;	
+    
+   case EGlxCmdDelete :
+		{
+        GlxExternalData* externalItems = GlxExternalUtility::instance()->getExternalData();
+        if(externalItems){
+            QVariant variant = mCurrentModel->data( mCurrentModel->index(0,0), GlxFocusIndexRole );    
+            if ( variant.isValid() &&  variant.canConvert<int> () ) {
+                int selIndex = variant.value<int>(); 
+                int externalDataCount = externalItems->count();
+                if(selIndex < externalDataCount){
+                    GlxInterfaceParams tmp = externalItems->value(selIndex);
+                    tmp.isSelected = true;
+                    externalItems->replace(selIndex,tmp);
+                    emit externalCommand(EGlxPluginCmdDelete);
+                    return;
+                }
+            }
+        }
+        mActionHandler->handleAction(id,mCollectionId);
+		}
+        break;
+        
+   case EGlxCmdMarkAll:
+   case EGlxCmdUnMarkAll:
+       mViewManager->handleUserAction(mCurrentState->id(), id);
+       id = EGlxCmdHandled;
+       break;
+   case EGlxCmdRotate:
+       mViewManager->handleUserAction(mCurrentState->id(), id);
+	   //Disable Rotate CH mActionHandler->handleAction(id,mCollectionId);
+       id = EGlxCmdHandled;
+       break;    
+       
+   case EGlxCmdSend:
+       {
+       mViewManager->handleUserAction(mCurrentState->id(), id);
+       id = EGlxCmdHandled;
+       }
+       break;
+       
+   case EGlxCmdSetupItem :
+       emit setupItemsSignal();
+       break;
+       
+    default :
+        mActionHandler->handleAction(id,mCollectionId);
+    	break;
+    }	
+}
+
+void GlxStateManager::exitApplication()
+{
+    if ( mCurrentState->id( ) == GLX_FULLSCREENVIEW_ID && mCurrentState->state() == EXTERNAL_S ) {
+        emit externalCommand(EGlxPluginCmdBack);
+    }
+    else {
+    //To:Do memory cleanup
+        QApplication::quit();
+    }    
+}
+
+GlxStateManager::~GlxStateManager()
+{
+    qDebug("GlxStateManager::~GlxStateManager");
+    delete mAllMediaModel;
+    delete mAlbumMediaModel;
+    delete mAlbumGridMediaModel;
+	
+    delete mActionHandler;
+    qDebug("GlxStateManager::~GlxStateManager delete Model");
+    
+    disconnect ( mViewManager, SIGNAL(actionTriggered(qint32 )), this, SLOT(actionTriggered(qint32 )) );
+    disconnect ( mViewManager, SIGNAL(externalCommand(int )), this, SIGNAL(externalCommand(int )) );
+    delete mViewManager; 
+    qDebug("GlxStateManager::~GlxStateManager delete view manager");
+    delete mImageviewerMediaModel;
+    GlxState *tmp;   
+    while (mCurrentState) {
+        tmp = mCurrentState;
+        mCurrentState = mCurrentState->previousState();
+        delete tmp;        
+    }
+    disconnect ( this, SIGNAL( setupItemsSignal() ), this, SLOT( setupItems() ) );
+    qDebug("GlxStateManager::~GlxStateManager Exit");
+}
+
+void GlxStateManager::cleanupExternal()
+{
+    qDebug("GlxStateManager::cleanupExternal");
+    mViewManager->deactivateCurrentView();
+    GlxMediaModel *glxModel = dynamic_cast<GlxMediaModel *>(mCurrentModel);
+    glxModel->clearExternalItems();  
+}