FCL/sf/app/photos: comparison photosgallery/viewframework/commandhandlers/commoncommandhandlers/src/glxcommandhandlernewmedia.cpp

equal deleted inserted replaced

-:9ba538e329bd
+:7d9067c6fcb1
 #include <glxcommandfactory.h>
 #include <glxcommandhandlers.hrh>
 #include <glxfetchcontextremover.h>
 #include <glxgeneraluiutilities.h>
 #include <glxpanic.h>
+#include <glxtracer.h>
 #include <glxresourceutilities.h>                // for CGlxResourceUtilities
 #include <glxsetappstate.h>
 #include <glxtextentrypopup.h>
 #include <glxuistd.h>
 #include <glxuiutilities.rsg>
 // Two-phased constructor.
 // ---------------------------------------------------------------------------
 //
 EXPORT_C CGlxCommandHandlerNewMedia* CGlxCommandHandlerNewMedia::NewL(MGlxMediaListProvider* aMediaListProvider)
 {
+TRACER("CGlxCommandHandlerNewMedia* CGlxCommandHandlerNewMedia::NewL");
 CGlxCommandHandlerNewMedia* self = new (ELeave) CGlxCommandHandlerNewMedia(aMediaListProvider);
 CleanupStack::PushL(self);
 self->ConstructL();
 CleanupStack::Pop(self);
 return self;
 // -----------------------------------------------------------------------------
 //
 void CGlxCommandHandlerNewMedia::DoHandleCommandCompleteL(TAny* /*aSessionId*/, CMPXCommand* aCommandResult,
 							TInt aError, MGlxMediaList* /*aList*/)
 	{
+TRACER("CGlxCommandHandlerNewMedia::DoHandleCommandCompleteL");
 	if (aError == KErrNone && aCommandResult && aCommandResult->IsSupported(KMPXMediaGeneralId))
 	{
 	iNewMediaId = TGlxMediaId(aCommandResult->ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId));
 	iOkToExit = EFalse; // wait for media id to be added to the list
 // (unless we are using iSchedulerWait)
 // Symbian 2nd phase constructor can leave.
 // ---------------------------------------------------------------------------
 //
 void CGlxCommandHandlerNewMedia::ConstructL()
 {
+TRACER("CGlxCommandHandlerNewMedia::ConstructL()");
 iFileNameAlreadyExists = EFalse ;
 // Load resource file
 	TParse parse;
 parse.Set(KGlxUiUtilitiesResource, &KDC_APP_RESOURCE_DIR, NULL);
 TFileName resourceFile;
 // Destructor
 // ---------------------------------------------------------------------------
 //
 EXPORT_C CGlxCommandHandlerNewMedia::~CGlxCommandHandlerNewMedia()
 {
+TRACER("CGlxCommandHandlerNewMedia::~CGlxCommandHandlerNewMedia()");
 if ( iResourceOffset )
 {
 CCoeEnv::Static()->DeleteResourceFile(iResourceOffset);
 }
 // CGlxCommandHandlerNewMedia::ExecuteLD()
 // ---------------------------------------------------------------------------
 //
 EXPORT_C TInt CGlxCommandHandlerNewMedia::ExecuteLD(TGlxMediaId& aNewMediaId)
 	{
+TRACER("CGlxCommandHandlerNewMedia::ExecuteLD");
 	CleanupStack::PushL(this);
 	iSchedulerWait = new (ELeave) CActiveSchedulerWait();
 	CGlxMpxCommandCommandHandler::ExecuteL( EGlxCmdAddMedia );
 	if (iNewMediaCreationError == KErrNone)
 // ---------------------------------------------------------------------------
 //
 CMPXCommand* CGlxCommandHandlerNewMedia::CreateCommandL(TInt /*aCommandId*/,
 MGlxMediaList& aMediaList, TBool& /*aConsume*/) const
 {
+TRACER("CGlxCommandHandlerNewMedia::CreateCommandL");
 iOkToExit = ETrue;
 CMPXCollectionPath* path = aMediaList.PathLC( NGlxListDefs::EPathParent );
 CMPXCommand* command = NULL;
 TBuf <KMaxNewMediaItemTitleLength> defaultNewMediaItemTitle;
-TitlesL(TGlxMediaId(path->Id(0)), defaultNewMediaItemTitle);
+TRAPD(error, TitlesL(TGlxMediaId(path->Id(0)), defaultNewMediaItemTitle));
+if(error != KErrNone)
+{
+iNewMediaCreationError = KErrCancel;
+CleanupStack::PopAndDestroy(path);
+return command;
+}
 HBufC* mediaPopupTitle = StringLoader::LoadLC(R_GLX_PROMPT_NAME);
 if(iFileNameAlreadyExists)
 	    {
 	    iFileNameAlreadyExists = EFalse ;
 // CGlxCommandHandlerNewMedia::HandleErrorL
 // ---------------------------------------------------------------------------
 //
 void CGlxCommandHandlerNewMedia::HandleErrorL(TInt aError)
 	{
+TRACER("CGlxCommandHandlerNewMedia::HandleErrorL");
 	if (aError == KErrAlreadyExists && iNewMediaItemTitle)
 		{
 		HBufC* info = StringLoader::LoadLC(R_GLX_NAME_ALREADY_USED, *iNewMediaItemTitle);
 		GlxGeneralUiUtilities::ShowInfoNoteL(*info, ETrue);
 		CleanupStack::PopAndDestroy(info);
 // BypassFiltersForExecute
 // -----------------------------------------------------------------------------
 //
 EXPORT_C TBool CGlxCommandHandlerNewMedia::BypassFiltersForExecute() const
 {
+TRACER("CGlxCommandHandlerNewMedia::BypassFiltersForExecute()");
 // if iSchedulerWait exists then we know the command is being executed from
 // the ExecuteLD() method and filtering is not required.
 return iSchedulerWait != NULL;
 }
 // ---------------------------------------------------------------------------
 //
 void CGlxCommandHandlerNewMedia::TitlesL(const TGlxMediaId aCollectionId, TDes& aDefaultNewMediaItemTitle) const
 	{
+TRACER("CGlxCommandHandlerNewMedia::TitlesL");
 CMPXCollectionPath* path = CMPXCollectionPath::NewL();
 CleanupStack::PushL(path);
 MGlxMediaList* rootList = MGlxMediaList::InstanceL(*path);
 CleanupClosePushL(*rootList);
 // ---------------------------------------------------------------------------
 //
 HBufC* CGlxCommandHandlerNewMedia::GenerateNewMediaItemTitleL
 (const TDesC& aDefaultNewMediaItemTitle, MGlxMediaList& aList) const
 {
+TRACER("CGlxCommandHandlerNewMedia::GenerateNewMediaItemTitleL");
 TGlxSequentialIterator iter;
 CGlxAttributeContext* attributeContext = new (ELeave) CGlxAttributeContext(&iter);
 CleanupStack::PushL(attributeContext);
 attributeContext->AddAttributeL(KMPXMediaGeneralTitle);
 aList.AddContextL(attributeContext, KGlxFetchContextPriorityBlocking);
 // SetFocusL()
 // -----------------------------------------------------------------------------
 //
 void CGlxCommandHandlerNewMedia::SetFocusL(TInt aIndex)
 {
+TRACER("CGlxCommandHandlerNewMedia::SetFocusL");
 iOkToExit = ETrue;
 MediaList().SetFocusL(NGlxListDefs::EAbsolute, aIndex);
 TryExitL(KErrNone);
 }
 // HandleItemAddedL
 // -----------------------------------------------------------------------------
 //
 EXPORT_C void CGlxCommandHandlerNewMedia::HandleItemAddedL(TInt aStartIndex, TInt aEndIndex, MGlxMediaList* aList)
 {
+TRACER("CGlxCommandHandlerNewMedia::HandleItemAddedL");
 if(aList == &MediaList() && iNewMediaId != KGlxCollectionRootId)
 {
 for (TInt i = aStartIndex; i <= aEndIndex; i++)
 {
 if (aList->Item(i).Id() == iNewMediaId)
 : CActive(KMaxTInt), iGlxCommandHandlerNewMedia(aGlxCommandHandlerNewMedia)
 // The active object has the maximum possible priority to prevent other active objects
 // running before it. (Unless they too are scheduled to run and have the maximum
 // possible priority
 {
+TRACER("CGlxCommandHandlerNewMedia::CGlxAsyncFocuser::CGlxAsyncFocuser");
 __ASSERT_DEBUG(aGlxCommandHandlerNewMedia, Panic(EGlxPanicNullPointer));
 CActiveScheduler::Add(this);
 }
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 //
 CGlxCommandHandlerNewMedia::CGlxAsyncFocuser::
 ~CGlxAsyncFocuser()
 {
+TRACER("CGlxCommandHandlerNewMedia::CGlxAsyncFocuser::~CGlxAsyncFocuser()");
 Cancel();
 }
 // -----------------------------------------------------------------------------
 // RunL
 // -----------------------------------------------------------------------------
 //
 void CGlxCommandHandlerNewMedia::CGlxAsyncFocuser::RunL()
 {
+TRACER("CGlxCommandHandlerNewMedia::CGlxAsyncFocuser::RunL()");
 iGlxCommandHandlerNewMedia->SetFocusL(iFocusIndex);
 }
 // -----------------------------------------------------------------------------
 // DoCancel
 // SetFocusL
 // -----------------------------------------------------------------------------
 //
 void CGlxCommandHandlerNewMedia::CGlxAsyncFocuser::SetFocus(TInt aIndex)
 {
+TRACER("CGlxCommandHandlerNewMedia::CGlxAsyncFocuser::SetFocus()");
 iFocusIndex = aIndex;
 TRequestStatus* requestStatus = &iStatus;
 User::RequestComplete(requestStatus,KErrNone);
 SetActive();
 }

changeset 2	7d9067c6fcb1
parent 0	4e91876724a2
child 9	6b87b143d312