diff -r ea65f74e6de4 -r 8e5f6eea9c9f ui/viewmanagement/statehandler/src/glxstatemanager.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/ui/viewmanagement/statehandler/src/glxstatemanager.cpp	Tue Aug 31 15:14:51 2010 +0300
@@ -0,0 +1,819 @@
+/*
+* 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
+#include <QApplication>
+#include <QDebug>
+#include <QItemSelectionModel>
+#include <hbnotificationdialog.h>
+#include <QProcess>
+#include <hbinstance.h>
+#include <HbActivityManager.h>
+#include <hbapplication.h>
+
+//user includes
+#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 "glxslideshowsettingsstate.h"
+#include "glxslideshowstate.h"
+#include "glxtnobserver.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 "glxactionhandler.h"
+#include "glxcommandhandlers.hrh"
+#include "glxplugincommandid.hrh"
+#include "glxlog.h"
+#include "glxtracer.h"
+#include <glximageviewermanager.h>
+
+GlxStateManager::GlxStateManager() 
+    : mAllMediaModel( NULL ), 
+      mAlbumGridMediaModel( NULL ),
+      mAlbumMediaModel( NULL ),
+      mImageviewerMediaModel( NULL ), 
+      mCurrentModel( NULL ), 
+      mCurrentState( NULL ), 
+      mActionHandler( NULL ),
+      mTNObserver ( NULL ),
+      isProgressbarRunning ( false )
+{
+    qDebug("GlxStateManager::GlxStateManager");
+    PERFORMANCE_ADV ( d1, "view manager creation time") {
+        mViewManager = new GlxViewManager();
+    }
+    mTNObserver = new GlxTNObserver();
+    
+    connect ( this, SIGNAL( setupItemsSignal() ), this, SLOT( setupItems() ), Qt::QueuedConnection );
+    connect ( mViewManager, SIGNAL(actionTriggered( qint32 )), this, SLOT(actionTriggered( qint32 )), Qt::QueuedConnection );
+    connect ( mTNObserver, SIGNAL( leftTNCount( int ) ), this, SLOT( updateTNProgress( int ) ) );
+    connect ( qobject_cast<HbApplication*>(qApp), SIGNAL (aboutToQuit()), this, SLOT(saveData()));
+	//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,indexList);
+    return TRUE;
+}
+
+bool GlxStateManager::eventFilter(QObject *obj, QEvent *event)
+{
+    TRACER("GlxStateManager::eventFilter() ");
+    GLX_LOG_INFO1("GlxStateManager::eventFilter() %d event type", event->type());
+    
+    if ( event->type() ==  QEvent::ApplicationActivate ) {
+        mTNObserver->startTNMDaemon();
+    }
+    if ( event->type() ==  QEvent::ApplicationDeactivate ) {
+        mTNObserver->stopTNMDaemon();
+    }
+    return QObject::eventFilter(obj, event);
+}
+
+void GlxStateManager::launchFetcher()
+{
+    qDebug("GlxStateManager::launchFetcher");
+    mCurrentState = createState(GLX_GRIDVIEW_ID);
+    mCurrentState->setState(FETCHER_ITEM_S);
+    
+    createModel(GLX_GRIDVIEW_ID);
+    mViewManager->launchApplication( GLX_GRIDVIEW_ID, mCurrentModel);
+}
+
+void GlxStateManager::launchApplication()
+{
+    qDebug("GlxStateManager::launchApplication");   
+    bool activitySuccess = false;  
+    //To:Do use it in future once performance code is removed nextState(GLX_GRIDVIEW_ID, ALL_ITEM_S)
+    HbApplication* app = qobject_cast<HbApplication*>(qApp);
+    if(app->activateReason() == Hb::ActivationReasonActivity) {
+        activitySuccess = launchActivity();
+    }
+    
+    if( !activitySuccess ) { 
+        mCurrentState = createState( GLX_GRIDVIEW_ID );
+        mCurrentState->setState( ALL_ITEM_S );
+       
+        int leftCount = mTNObserver->getTNLeftCount() ;
+        if (  leftCount > 0  ) {
+            mViewManager->launchApplication( GLX_GRIDVIEW_ID, mCurrentModel );
+            launchProgressDialog();
+        }
+        else {
+            createModel( GLX_GRIDVIEW_ID );
+            mViewManager->launchApplication( GLX_GRIDVIEW_ID, mCurrentModel );
+        }    
+        mTNObserver->startTNObserving() ; 
+    }
+    
+    HbActivityManager* activityManager = app->activityManager();
+    bool ok = activityManager->removeActivity("PhotosMainView");
+    if ( !ok )
+    {
+         qDebug("launchapplication::Remove activity failed" );
+    } 
+}
+
+bool GlxStateManager::launchActivity()
+{
+    HbApplication* app = qobject_cast<HbApplication*>(qApp);
+    bool ok = app->activityManager()->waitActivity();
+    if ( !ok )
+    {
+        qDebug("subscribing to activity manager failed" );
+    }
+    QVariant data = app->activityManager()->activityData( "PhotosMainView" );
+    QByteArray serializedModel = data.toByteArray();
+    QDataStream stream(&serializedModel, QIODevice::ReadOnly);
+    
+    //Fetch the data from the activity Manager
+    stream >> mSaveActivity;  
+    qint32 stateId = mSaveActivity.value("ID");
+    mCurrentState = createState(stateId);
+    mCurrentState->setState( mSaveActivity.value("InternalState") );
+    createModel( stateId);
+	/*Model might not be populated yet to set the visibleWindowIndex right away.
+	*So, let us store the visible index as a temporary Variable, so that  visible Window Index 
+	*is set once the model is populated.
+    */
+    mCurrentModel->setData(QModelIndex(), mSaveActivity.value("VisibleIndex") , GlxTempVisualWindowIndex );
+    mViewManager->launchApplication(stateId, mCurrentModel); 
+    return true;
+}
+
+void GlxStateManager::launchFromExternal()
+{
+    qDebug("GlxStateManager::launchFromExternal");
+    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);
+	setupItems();
+}
+
+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();
+    switch( mSaveActivity.value( "ID" ) ){
+        case GLX_LISTVIEW_ID:
+            mViewManager->updateToolBarIcon(GLX_ALBUM_ACTION_ID);
+            break;
+            
+        case GLX_GRIDVIEW_ID:
+        default:
+            mViewManager->updateToolBarIcon(GLX_ALL_ACTION_ID);
+    }
+}
+
+void GlxStateManager::updateTNProgress( int count)
+{    
+    TRACER("GlxStateManager::updateTNProgress() ");
+    // this is case when progress bar is not showing
+    // in the case of rename of an image or capture the single item
+    // it is also launching the progress bar, to avoid this scenario add the check of count more than 5
+    if ( mCurrentModel && ( count > 5  ) ) { 
+         goBack( GLX_GRIDVIEW_ID, ALL_ITEM_S ) ;
+         cleanAllModel();
+         launchProgressDialog();
+    }
+    
+    if ( isProgressbarRunning ){
+        if ( count == 0 ) {
+            vanishProgressDialog();
+        }
+        else {
+            mViewManager->updateProgressDialog( count );
+        }
+    }   
+}
+
+void GlxStateManager::thumbnailPopulated()
+{
+    mViewManager->setModel( mCurrentModel );
+    isProgressbarRunning = false;
+    mViewManager->updateProgressDialog( 0 );  
+    disconnect ( mCurrentModel, SIGNAL( thumbnailPopulated() ), this, SLOT( thumbnailPopulated() ) );
+}
+
+void GlxStateManager::saveData()
+{
+    if( (mCurrentState->id() == GLX_GRIDVIEW_ID && mCurrentState->state() == ALL_ITEM_S) || mCurrentState->id() == GLX_LISTVIEW_ID ) {
+        mSaveActivity.insert("ID",mCurrentState->id()); 
+        mSaveActivity.insert("InternalState",mCurrentState->state());
+        if(mCurrentModel) {
+            QVariant variant = mCurrentModel->data( mCurrentModel->index(0,0), GlxVisualWindowIndex );
+            if ( variant.isValid() &&  variant.canConvert<int> () ) {
+                mSaveActivity.insert("VisibleIndex",variant.value<int>());
+            }
+ 		}
+ 		else {
+ 			mSaveActivity.insert("VisibleIndex",0);
+ 		}
+    
+        HbActivityManager* activityManager = qobject_cast<HbApplication*>(qApp)->activityManager();
+        QVariantHash metadata;
+        HbMainWindow *window = hbInstance->allMainWindows().first();
+        metadata.insert("screenshot", QPixmap::grabWidget(window, window->rect()));
+        
+        QByteArray serializedModel;
+        QDataStream stream(&serializedModel, QIODevice::WriteOnly | QIODevice::Append);
+        stream << mSaveActivity;
+        
+        bool ok = activityManager->addActivity("PhotosMainView", serializedModel, metadata);
+        if ( !ok )
+        {
+            qDebug("SaveData::Add activity failed" );
+        }
+    }
+}
+
+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
+        saveImage(); // save image if it is in private folder
+        exitApplication() ;
+        return ;
+    }
+    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::saveImage()
+    {
+    CGlxImageViewerManager *imageViewerInstance = CGlxImageViewerManager::InstanceL();
+    if(imageViewerInstance->IsPrivate())
+        {
+        HBufC* imagePath = imageViewerInstance->ImageUri();
+		QString srcPath = QString::fromUtf16(imagePath->Des().Ptr(),imagePath->Length());
+		QString imageName = srcPath.section('\\', -1);
+		QString imagesFolderPath("c:/data/images/");
+		QString destPath;
+		destPath.append(imagesFolderPath);
+		destPath.append(imageName);
+		int cnt = 1;
+		qDebug() << "GlxStateManager::saveImage path before while = "<< destPath;
+		while(!QFile::copy(srcPath,destPath))
+			{
+			QString filename = imageName.section('.', 0,0);
+			QString ext = imageName.section('.', -1);
+			destPath.clear();
+			destPath = imagesFolderPath + filename + QString::number(cnt) + "." + ext;
+			qDebug() << "GlxStateManager::saveImage path = "<< destPath;
+			cnt++;
+			}
+        }
+    imageViewerInstance->Close();
+    }
+	
+void GlxStateManager::goBack(qint32 stateId, int internalState)
+{
+    qDebug("GlxStateManager::goBack()");
+    
+    //if current state and it internal state is same then no need to do any thing
+    if ( mCurrentState->id() == stateId  && mCurrentState->state() == internalState ) {
+        return ;
+    }
+    
+    GlxState *state = mCurrentState;
+    
+    while ( mCurrentState ) {
+        if ( mCurrentState->id() == stateId  && mCurrentState->state() == internalState ) {
+            break ;           
+        }
+        
+        mCurrentState = mCurrentState->previousState(); // set pervious state to the current state
+        delete state; //delete the current state
+        state = mCurrentState;    
+    }
+    
+    //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()
+{
+    TRACER("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
+    }
+}
+
+void GlxStateManager::cleanAllModel()
+{
+    TRACER("GlxStateManager::cleanAllModel() ");
+    delete mAllMediaModel ;
+    mAllMediaModel = NULL ;
+    delete mAlbumMediaModel ; 
+    mAlbumMediaModel = NULL ;
+    delete mAlbumGridMediaModel ;
+    mAlbumGridMediaModel = NULL ;
+    delete mImageviewerMediaModel ;
+    mImageviewerMediaModel = NULL ;
+    mCurrentModel = NULL ;
+}
+
+void GlxStateManager::launchProgressDialog()
+{
+    TRACER("GlxStateManager::launchProgressDialog() ");
+    
+    QCoreApplication::instance()->installEventFilter( this );
+    if ( isProgressbarRunning ) {
+        mViewManager->updateProgressDialog( mTNObserver->getTNLeftCount() );
+    }
+    else {
+        mViewManager->launchProgressDialog( mTNObserver->getTNLeftCount() );
+    }
+    isProgressbarRunning = true ;
+}
+
+void GlxStateManager::vanishProgressDialog()
+{
+    TRACER("GlxStateManager::vanishProgressDialog() ");
+    QCoreApplication::instance()->removeEventFilter( this );
+    createModel( mCurrentState->id() );
+    connect ( mCurrentModel, SIGNAL( thumbnailPopulated() ), this, SLOT( thumbnailPopulated() ) );
+}
+
+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( this, mCurrentState );
+        
+    case GLX_DETAILSVIEW_ID:
+        return new GlxDetailState( mCurrentState );
+        
+    case GLX_SLIDESHOWVIEW_ID :
+        return new GlxSlideShowState( this, mCurrentState );
+    case GLX_SLIDESHOWSETTINGSVIEW_ID :
+        return new GlxSlideShowSettingsState(this, mCurrentState );
+    	
+    default :
+        return NULL;		
+    } 
+}
+
+void GlxStateManager::createModel(qint32 stateId, NavigationDir dir)
+{
+    switch( stateId ) {
+    case GLX_GRIDVIEW_ID :
+        createGridModel( mCurrentState->state(), dir );
+        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;
+        mCollectionId = KGlxCollectionPluginAlbumsImplementationUid;
+        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);
+            mCollectionId = KGlxCollectionPluginImageViewerImplementationUid;
+		}
+        else if ( mCurrentState->state() == EXTERNAL_S) {
+            if(!mAllMediaModel) {
+                GlxModelParm modelParm (KGlxCollectionPluginAllImplementationUid, 0);
+                mCurrentModel = mAllMediaModel = new GlxMediaModel (modelParm);
+            }
+            else {
+                mCurrentModel = mAllMediaModel;
+            }
+            mCollectionId = KGlxCollectionPluginAllImplementationUid;
+        }
+		setFullScreenContext();
+        break;
+        
+    case GLX_DETAILSVIEW_ID :
+        setFullScreenContext();
+        break;
+        
+    case GLX_SLIDESHOWVIEW_ID :
+        if ( mCurrentState->state() == SLIDESHOW_ALBUM_ITEM_S ) {
+            GlxModelParm modelParm ( KGlxAlbumsMediaId , 0);
+            mCurrentModel = mAlbumGridMediaModel = new GlxMediaModel( modelParm );
+        }
+        setFullScreenContext();
+        break;
+    	    	
+    default :
+        break;
+    }
+    mCurrentModel->setData( QModelIndex(), mCurrentState->state(), GlxSubStateRole );
+}
+
+void GlxStateManager::createGridModel(int internalState, NavigationDir dir)
+{
+    GlxModelParm modelParm;
+    GlxContextMode mode;
+    
+    if ( mViewManager->orientation() == Qt::Horizontal ) {
+        mode = GlxContextLsGrid ;
+    }
+    else {
+        mode = GlxContextPtGrid ;
+    }
+    
+    switch( internalState) {
+    case ALL_ITEM_S :
+	case FETCHER_ITEM_S:
+        if ( mAllMediaModel == NULL ) {
+            modelParm.setCollection( KGlxCollectionPluginAllImplementationUid );
+            modelParm.setDepth(0);
+            modelParm.setContextMode( mode ) ;
+            mAllMediaModel = new GlxMediaModel( modelParm );
+        }
+        mCollectionId = KGlxCollectionPluginAllImplementationUid;
+        mCurrentModel = mAllMediaModel;
+        mViewManager->updateToolBarIcon(GLX_ALL_ACTION_ID);
+        break;
+        
+    case ALBUM_ITEM_S :
+    case FETCHER_ALBUM_ITEM_S :    
+        if ( dir != BACKWARD_DIR ) { 
+            modelParm.setCollection( KGlxAlbumsMediaId );
+            modelParm.setDepth(0);
+            modelParm.setContextMode( mode ) ;
+            mAlbumGridMediaModel = new GlxMediaModel( modelParm );
+        }               
+        mCollectionId = KGlxAlbumsMediaId;
+        mCurrentModel = mAlbumGridMediaModel ;
+        mViewManager->updateToolBarIcon(NO_ACTION_ID);
+        break;
+    
+    default :
+        break;
+    }
+    
+    mCurrentModel->setData(QModelIndex(), (int)mode, GlxContextRole );
+}
+
+void GlxStateManager::setFullScreenContext()
+{
+    if ( mViewManager->orientation() == Qt::Horizontal || mCurrentState->id() == GLX_SLIDESHOWVIEW_ID ) {
+        mCurrentModel->setData(QModelIndex(), (int)GlxContextLsFs, GlxContextRole );
+    }
+    else {
+        mCurrentModel->setData(QModelIndex(), (int)GlxContextPtFs, GlxContextRole );
+    }    
+}
+
+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 EGlxCmdFetcherAllGridOpen :
+        changeState( GLX_GRIDVIEW_ID, FETCHER_ITEM_S );
+        id = EGlxCmdHandled;
+        break;
+    	
+    case EGlxCmdAlbumListOpen:
+        changeState( GLX_LISTVIEW_ID, -1 );
+        id = EGlxCmdHandled;
+        break;
+    case EGlxCmdFetcherAlbumListOpen:
+        changeState( GLX_LISTVIEW_ID, FETCHER_ALBUM_S );
+        id = EGlxCmdHandled;
+        break;
+        
+    case EGlxCmdAlbumGridOpen:
+        nextState( GLX_GRIDVIEW_ID, ALBUM_ITEM_S );
+        id = EGlxCmdHandled;
+        break;
+    case EGlxCmdFetcherAlbumGridOpen:
+        nextState( GLX_GRIDVIEW_ID, FETCHER_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 EGlxCmdSlideshowSettings:
+        nextState(GLX_SLIDESHOWSETTINGSVIEW_ID,-1 );
+        id = EGlxCmdHandled;
+        break;
+        
+    case EGlxCmdDetailsOpen:
+        qDebug("GlxStateManager::eventHandler EGlxCmdDetailsOpen");
+        nextState( GLX_DETAILSVIEW_ID, -1 );
+        id = EGlxCmdHandled;
+        break;
+        
+    case EGlxCmdEmptyData : {
+        GlxState *tmpState = mCurrentState ;
+        while ( tmpState->id() != GLX_GRIDVIEW_ID ) {
+            tmpState = tmpState->previousState() ;
+        }
+        
+        goBack( GLX_GRIDVIEW_ID, tmpState->state() );
+        id = EGlxCmdHandled;
+        break;
+    }
+    	
+    case EGlxCmdBack :
+    case EGlxCmdSlideShowBack :
+    	previousState();
+    	id = EGlxCmdHandled;
+    	break;
+    	
+    case EGlxCmdCameraOpen:
+		{
+		QProcess::startDetached(QString("cxui.exe"));
+		id = EGlxCmdHandled;
+		}
+        break;	
+        
+    case EGlxCmdOviOpen:
+		{
+		HbNotificationDialog::launchDialog("Not Implemented");
+        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 :
+   case EGlxCmd3DEffectOn :
+   case EGlxCmd3DEffectOff :
+   case EGlxCmdPlayBackAnim :
+       mViewManager->handleUserAction( mCurrentState->id(), id );
+       id = EGlxCmdHandled;
+       break;
+       
+   case EGlxCmdSetupItem :
+       emit setupItemsSignal();
+       break;
+   
+   case EGlxCmdFetcherSelect: 
+       {
+       QModelIndex selectedIndex = mCurrentModel->index(mCurrentModel->data(mCurrentModel->index(0,0),GlxFocusIndexRole).value<int>(),0);
+       emit gridItemSelected(selectedIndex,*mCurrentModel);
+       id = EGlxCmdHandled;
+       }
+       break;
+       
+   default :
+        mActionHandler->handleAction(id,mCollectionId);
+    	break;
+    }	
+}
+
+void GlxStateManager::exitApplication()
+{
+    
+    
+    //To:Do memory cleanup
+        QApplication::quit();
+     
+}
+
+GlxStateManager::~GlxStateManager()
+{
+    qDebug("GlxStateManager::~GlxStateManager");
+    cleanAllModel();
+    mSaveActivity.clear();
+    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 )) );
+    disconnect ( mTNObserver, SIGNAL( leftTNCount( int ) ), this, SLOT( updateTNProgress( int ) ) );
+    disconnect ( this, SIGNAL( setupItemsSignal() ), this, SLOT( setupItems() ) );
+    disconnect ( qobject_cast<HbApplication*>(qApp), SIGNAL (aboutToQuit()), this, SLOT(saveData()));
+    
+    delete mTNObserver;
+    delete mViewManager; 
+    qDebug("GlxStateManager::~GlxStateManager delete view manager");
+    
+    GlxState *tmp;   
+    while (mCurrentState) {
+        tmp = mCurrentState;
+        mCurrentState = mCurrentState->previousState();
+        delete tmp;        
+    }
+    
+    qDebug("GlxStateManager::~GlxStateManager Exit");
+}
+
+void GlxStateManager::cleanupExternal()
+{
+    qDebug("GlxStateManager::cleanupExternal");
+    mViewManager->deactivateCurrentView();
+    GlxMediaModel *glxModel = dynamic_cast<GlxMediaModel *>(mCurrentModel);
+    if(glxModel) {
+		glxModel->clearExternalItems();  
+	}
+}