Mercurial Mercurial > oss > FCL > sf > app > photos / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
ui/commandhandlers/commandhandlerbase/src/glxmpxcommandhandler.cpp
changeset 69 45459746d5e8
parent 62 36d93b4dc635
equal deleted inserted replaced
65:ccee5c4b0de4 69:45459746d5e8 
    40 #endif
 
    40 #endif
 
    41 
    41 
    42 #include <hbaction.h>
 
    42 #include <hbaction.h>
 
    43 
    43 
    44 GlxMpxCommandHandler::GlxMpxCommandHandler() :
 
    44 GlxMpxCommandHandler::GlxMpxCommandHandler() :
 
    45     iProgressComplete(EFalse)
 
    45     iProgressComplete(EFalse),iIsCmdActive(EFalse)
 
    46     {
 
    46     {
 
    47     OstTraceFunctionEntry0( GLXMPXCOMMANDHANDLER_GLXMPXCOMMANDHANDLER_ENTRY );
 
    47     OstTraceFunctionEntry0( GLXMPXCOMMANDHANDLER_GLXMPXCOMMANDHANDLER_ENTRY );
 
    48     iMediaList = NULL;
 
    48     iMediaList = NULL;
 
    49     OstTraceFunctionExit0( GLXMPXCOMMANDHANDLER_GLXMPXCOMMANDHANDLER_EXIT );
 
    49     OstTraceFunctionExit0( GLXMPXCOMMANDHANDLER_GLXMPXCOMMANDHANDLER_EXIT );
 
    50     }
 
    50     }
 
    65     {
 
    65     {
 
    66     OstTraceFunctionEntry0( GLXMPXCOMMANDHANDLER_EXECUTECOMMAND_ENTRY );
 
    66     OstTraceFunctionEntry0( GLXMPXCOMMANDHANDLER_EXECUTECOMMAND_ENTRY );
 
    67     Q_UNUSED(indexList);
 
    67     Q_UNUSED(indexList);
 
    68     int aHierarchyId = 0;
 
    68     int aHierarchyId = 0;
 
    69     TGlxFilterItemType aFilterType = EGlxFilterImage;
 
    69     TGlxFilterItemType aFilterType = EGlxFilterImage;
 
    70 
    70     if (!iIsCmdActive)
 
    71     if (collectionId != KGlxAlbumsMediaId)
 
    71          {
 
    72         {
 
    72         if (collectionId != KGlxAlbumsMediaId)
 
    73         OstTrace0( TRACE_NORMAL, DUP2_GLXMPXCOMMANDHANDLER_EXECUTECOMMAND, "GlxMpxCommandHandler::executeCommand::CreateMediaListL" );
 
    73             {
 
    74         CreateMediaListL(collectionId, aHierarchyId, aFilterType);
 
    74             OstTrace0( TRACE_NORMAL, DUP2_GLXMPXCOMMANDHANDLER_EXECUTECOMMAND, "GlxMpxCommandHandler::executeCommand::CreateMediaListL" );
 
    75         }
 
    75             CreateMediaListL(collectionId, aHierarchyId, aFilterType);
 
    76     else
 
    76             }
 
    77         {
 
    77         else
 
    78         OstTrace0( TRACE_NORMAL, DUP3_GLXMPXCOMMANDHANDLER_EXECUTECOMMAND, "GlxMpxCommandHandler::executeCommand::CreateMediaListAlbumItemL" );
 
    78             {
 
    79         //for creating Medial List for Albums Media path Items
 
    79             OstTrace0( TRACE_NORMAL, DUP3_GLXMPXCOMMANDHANDLER_EXECUTECOMMAND, "GlxMpxCommandHandler::executeCommand::CreateMediaListAlbumItemL" );
 
    80         CreateMediaListAlbumItemL(collectionId, aHierarchyId, aFilterType);
 
    80             //for creating Medial List for Albums Media path Items
 
    81         }
 
    81             CreateMediaListAlbumItemL(collectionId, aHierarchyId, aFilterType);
 
    82 
    82             }
 
    83     TBool consume = ETrue;
 
    83 
    84     iProgressComplete = EFalse;
 
    84         TBool consume = ETrue;
 
    85     mProgressDialog = NULL;
 
    85         iProgressComplete = EFalse;
 
    86     //Execute Command 
    86         mProgressDialog = NULL;
 
    87     DoExecuteCommandL(commandId, *iMediaList, consume);
 
    87         //Execute Command 
    88     mCommandId = commandId;
 
    88         DoExecuteCommandL(commandId, *iMediaList, consume);
 
    89     ConfirmationNoteL(*iMediaList);
 
    89         mCommandId = commandId;
 
       
    90         ConfirmationNoteL(*iMediaList);
 
       
    91         }
 
    90     OstTraceFunctionExit0( GLXMPXCOMMANDHANDLER_EXECUTECOMMAND_EXIT );
 
    92     OstTraceFunctionExit0( GLXMPXCOMMANDHANDLER_EXECUTECOMMAND_EXIT );
 
    91     }
 
    93     }
 
    92 
    94 
    93 void GlxMpxCommandHandler::executeMpxCommand(bool execute)
 
    95 void GlxMpxCommandHandler::executeMpxCommand(bool execute)
 
    94     {
 
    96     {
 
    95     if(execute && !iMediaList->IsCommandActive())            
    97     if(iMediaList)
 
    96         {
 
    98         {
 
    97         TBool consume = ETrue;
 
    99         if (execute && !iMediaList->IsCommandActive())
 
    98         CMPXCommand* command = CreateCommandL(mCommandId, *iMediaList, consume);
 
       
    99         if (command)
 
       
   100             {
 
   100             {
 
   101             command->SetTObjectValueL<TAny*> (KMPXCommandGeneralSessionId,
 
   101             TBool consume = ETrue;
 
   102                     static_cast<TAny*> (this));
 
   102             CMPXCommand* command = CreateCommandL(mCommandId, *iMediaList,
 
   103             iMediaList->AddMediaListObserverL(this);
 
   103                     consume);
 
   104             iMediaList->CommandL(*command);
 
   104             if (command)
 
   105             
       
   106             if(iMediaList->SelectionCount() > 1)
 
       
   107                 {
 
   105                 {
 
   108                  ProgressNoteL(mCommandId);
 
   106                 command->SetTObjectValueL<TAny*> (
 
       
   107                         KMPXCommandGeneralSessionId,
 
       
   108                         static_cast<TAny*> (this));
 
       
   109                 iMediaList->AddMediaListObserverL(this);
 
       
   110                 iMediaList->CommandL(*command);
 
       
   111 
       
   112                 if (iMediaList->SelectionCount() > 1)
 
       
   113                     {
 
       
   114                     ProgressNoteL(mCommandId);
 
       
   115                     }
 
   109                 }
 
   116                 }
 
   110             }
 
   117             }
 
   111         }
 
   118         else //command cancelled,so unmark all items
 
   112     else //command cancelled,so unmark all items
 
   119             {
 
   113         {
 
   120             MGlxMediaList::UnmarkAllL(*iMediaList);
 
   114         MGlxMediaList::UnmarkAllL(*iMediaList);
 
   121             }
 
   115         }
 
   122         }
 
   116     
       
   117     }
 
   123     }
 
   118 
   124 
   119 // ---------------------------------------------------------------------------
 
   125 // ---------------------------------------------------------------------------
 
   120 // CreateMediaListL()
 
   126 // CreateMediaListL()
 
   121 // Creates a collection path
 
   127 // Creates a collection path
 
   293 //	
   299 //	
   294 void GlxMpxCommandHandler::HandleCommandCompleteL(TAny* aSessionId,
 
   300 void GlxMpxCommandHandler::HandleCommandCompleteL(TAny* aSessionId,
 
   295         CMPXCommand* aCommandResult, TInt aError, MGlxMediaList* aList)
 
   301         CMPXCommand* aCommandResult, TInt aError, MGlxMediaList* aList)
 
   296     {
 
   302     {
 
   297     OstTraceFunctionEntry0( GLXMPXCOMMANDHANDLER_HANDLECOMMANDCOMPLETEL_ENTRY );
 
   303     OstTraceFunctionEntry0( GLXMPXCOMMANDHANDLER_HANDLECOMMANDCOMPLETEL_ENTRY );
 
   298     MGlxMediaList::UnmarkAllL(*iMediaList);
 
   304     if(iMediaList)
 
   299 
   305         {
 
   300     DoHandleCommandCompleteL(aSessionId, aCommandResult, aError, aList);
 
   306         MGlxMediaList::UnmarkAllL(*iMediaList);
 
   301     iProgressComplete = ETrue;
 
   307 
   302     TryExitL(aError);
 
   308         DoHandleCommandCompleteL(aSessionId, aCommandResult, aError, aList);
 
       
   309         iProgressComplete = ETrue;
 
       
   310         TryExitL(aError);
 
       
   311         }
 
   303     OstTraceFunctionExit0( GLXMPXCOMMANDHANDLER_HANDLECOMMANDCOMPLETEL_EXIT );
 
   312     OstTraceFunctionExit0( GLXMPXCOMMANDHANDLER_HANDLECOMMANDCOMPLETEL_EXIT );
 
   304     }
 
   313     }
 
   305 
   314 
   306 // -----------------------------------------------------------------------------
 
   315 // -----------------------------------------------------------------------------
 
   307 // HandleError
 
   316 // HandleError
 
   347     OstTraceFunctionEntry0( GLXMPXCOMMANDHANDLER_TRYEXITL_ENTRY );
 
   356     OstTraceFunctionEntry0( GLXMPXCOMMANDHANDLER_TRYEXITL_ENTRY );
 
   348     if (KErrNone != aErrorCode)
 
   357     if (KErrNone != aErrorCode)
 
   349         {
 
   358         {
 
   350         // @todo error received. Close progress note 
   359         // @todo error received. Close progress note 
   351         DismissProgressNoteL();
 
   360         DismissProgressNoteL();
 
   352         MGlxMediaList::UnmarkAllL(*iMediaList);
 
   361         if(iMediaList)
 
   353         iMediaList->RemoveMediaListObserver(this);
 
   362             {
 
   354         iMediaList->Close();
 
   363             MGlxMediaList::UnmarkAllL(*iMediaList);
 
   355         iMediaList = NULL;
 
   364             iMediaList->RemoveMediaListObserver(this);
 
       
   365             iMediaList->Close();
 
       
   366             iMediaList = NULL;
 
       
   367             }
 
   356         // handle error
 
   368         // handle error
 
   357         HandleErrorL(aErrorCode);
 
   369         HandleErrorL(aErrorCode);
 
   358         }
 
   370         }
 
   359     else if (iProgressComplete)
 
   371     else if (iProgressComplete)
 
   360         {
 
   372         {
 
   363         iMediaList->Close();
 
   375         iMediaList->Close();
 
   364         iMediaList = NULL;
 
   376         iMediaList = NULL;
 
   365         CompletionNoteL();
 
   377         CompletionNoteL();
 
   366         iProgressComplete = EFalse;
 
   378         iProgressComplete = EFalse;
 
   367         }
 
   379         }
 
       
   380     iIsCmdActive = EFalse;
 
   368     OstTraceFunctionExit0( GLXMPXCOMMANDHANDLER_TRYEXITL_EXIT );
 
   381     OstTraceFunctionExit0( GLXMPXCOMMANDHANDLER_TRYEXITL_EXIT );
 
   369     }
 
   382     }
 
   370 
   383 
   371 // -----------------------------------------------------------------------------
 
   384 // -----------------------------------------------------------------------------
 
   372 // Default implementation shows an error note
 
   385 // Default implementation shows an error note
 
   416     }
 
   429     }
 
   417 
   430 
   418 void GlxMpxCommandHandler::ConfirmationNoteL(MGlxMediaList& aMediaList)
 
   431 void GlxMpxCommandHandler::ConfirmationNoteL(MGlxMediaList& aMediaList)
 
   419     {
 
   432     {
 
   420 	TInt selectionCount = aMediaList.SelectionCount();
 
   433 	TInt selectionCount = aMediaList.SelectionCount();
 
   421 
   434 	iIsCmdActive = ETrue;
 
   422     // If media list is not empty, treat focused item as selected
 
   435     // If media list is not empty, treat focused item as selected
 
   423     // At this point can assume that the command was disabled 
   436     // At this point can assume that the command was disabled 
   424     // if static items were not supported	
   437     // if static items were not supported	
   425 	if ( selectionCount == 0  )
 
   438 	if ( selectionCount == 0  )
 
   426 		{
 
   439 		{
 
   507         }
 
   520         }
 
   508     else
 
   521     else
 
   509         {
 
   522         {
 
   510         // Cancellation is done.
 
   523         // Cancellation is done.
 
   511         executeMpxCommand(false);
 
   524         executeMpxCommand(false);
 
       
   525         iIsCmdActive = EFalse;
 
   512         }
 
   526         }
 
   513     }
 
   527     }
 
   514 
   528 
   515 
   529 
   516 QString GlxMpxCommandHandler::ConfirmationTextL(bool /*multiSelection */) const
 
   530 QString GlxMpxCommandHandler::ConfirmationTextL(bool /*multiSelection */) const
FCL/sf/app/photos