--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/photosgallery/viewframework/commandhandlers/commoncommandhandlers/src/glxcommandhandlernewmedia.cpp Wed Sep 01 12:33:26 2010 +0100
@@ -0,0 +1,541 @@
+/*
+* Copyright (c) 2008-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: Delete command handler
+*
+*/
+
+
+
+
+/**
+ * @internal reviewed 06/06/2007 by Dave Schofield
+ */
+
+#include "glxcommandhandlernewmedia.h"
+
+#include <AknUtils.h>
+#include <badesca.h>
+#include <bautils.h>
+#include <glxattributecontext.h>
+#include <glxattributeretriever.h>
+#include <glxcollectiongeneraldefs.h>
+#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>
+#include <mglxmedialist.h>
+#include <mpxcollectionpath.h>
+#include <mpxcommonframeworkdefs.h>
+#include <StringLoader.h>
+#include <glxmediageneraldefs.h> // for KMaxMediaPopupTextLength
+#include <data_caging_path_literals.hrh>
+#include <glxuiutilities.rsg>
+#include <e32const.h> //For TDigitType
+
+const TInt KMaxNumberLength = 10;
+
+_LIT(KOpenBracket, "(");
+_LIT(KCloseBracket, ")");
+_LIT(KFileNameFormatString, "(%+02u)");
+
+// ---------------------------------------------------------------------------
+// Two-phased constructor.
+// ---------------------------------------------------------------------------
+//
+EXPORT_C CGlxCommandHandlerNewMedia* CGlxCommandHandlerNewMedia::NewL(
+ MGlxMediaListProvider* aMediaListProvider, const TDesC& aFileName)
+ {
+ TRACER("CGlxCommandHandlerNewMedia* CGlxCommandHandlerNewMedia::NewL");
+ CGlxCommandHandlerNewMedia* self = new (ELeave) CGlxCommandHandlerNewMedia(
+ aMediaListProvider);
+ CleanupStack::PushL(self);
+ self->ConstructL(aFileName);
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+// ---------------------------------------------------------------------------
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// ---------------------------------------------------------------------------
+//
+CGlxCommandHandlerNewMedia::CGlxCommandHandlerNewMedia(MGlxMediaListProvider* aMediaListProvider)
+ : CGlxMpxCommandCommandHandler(aMediaListProvider)
+ {
+ // Don't do anything.
+ }
+
+// -----------------------------------------------------------------------------
+// CGlxCommandHandlerNewMedia::DoHandleCommandCompleteL
+// -----------------------------------------------------------------------------
+//
+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)
+ }
+
+ if (iSchedulerWait && aError != KErrAlreadyExists )
+ {
+ // if iSchedulerWait exists then we know the command is being executed from
+ // the ExecuteLD() method.
+ iNewMediaCreationError = aError;
+ iSchedulerWait->AsyncStop();
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CGlxCommandHandlerNewMedia::OkToExit
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CGlxCommandHandlerNewMedia::OkToExit() const
+ {
+ return iOkToExit;
+ }
+
+// ---------------------------------------------------------------------------
+// Symbian 2nd phase constructor can leave.
+// ---------------------------------------------------------------------------
+//
+void CGlxCommandHandlerNewMedia::ConstructL(const TDesC& aFileName)
+ {
+ TRACER("CGlxCommandHandlerNewMedia::ConstructL()");
+ iFileNameAlreadyExists = EFalse;
+
+ iResourceOffset = CCoeEnv::Static()->AddResourceFileL(aFileName);
+
+ iAsyncFocuser = new (ELeave) CGlxAsyncFocuser(this);
+ // Add supported command
+ TCommandInfo info(EGlxCmdAddMedia);
+ // Filter out static items
+ AddCommandL(info);
+ }
+
+// ---------------------------------------------------------------------------
+// Destructor
+// ---------------------------------------------------------------------------
+//
+EXPORT_C CGlxCommandHandlerNewMedia::~CGlxCommandHandlerNewMedia()
+ {
+ TRACER("CGlxCommandHandlerNewMedia::~CGlxCommandHandlerNewMedia()");
+ if ( iResourceOffset )
+ {
+ CCoeEnv::Static()->DeleteResourceFile(iResourceOffset);
+ }
+
+ delete iSchedulerWait;
+ delete iAsyncFocuser;
+ delete iNewMediaItemTitle;
+ }
+
+// ---------------------------------------------------------------------------
+// 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)
+ {
+ // The user pressed OK on the dialog. We need to wait for DoHandleCommandComplete()
+ iSchedulerWait->Start();
+
+ if (iNewMediaCreationError == KErrNone)
+ {
+ aNewMediaId = iNewMediaId;
+ }
+ }
+
+ TInt error = iNewMediaCreationError;
+ CleanupStack::PopAndDestroy(this);
+ return error;
+ }
+
+// ---------------------------------------------------------------------------
+// Create an add to container command
+// ---------------------------------------------------------------------------
+//
+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 <KMaxMediaPopupTextLength> 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 ;
+ }
+ else
+ {
+ delete iNewMediaItemTitle;
+ iNewMediaItemTitle = NULL;
+ iNewMediaItemTitle = GenerateNewMediaItemTitleL(defaultNewMediaItemTitle, aMediaList);
+ }
+ TPtr newMediaItemTitleDes = iNewMediaItemTitle->Des();
+
+ CGlxTextEntryPopup* dialog = CGlxTextEntryPopup::NewL(*mediaPopupTitle, newMediaItemTitleDes);
+ if(dialog->ExecuteLD() == EEikBidOk)
+ {
+ command = TGlxCommandFactory::AddContainerCommandLC(*iNewMediaItemTitle, path->Id(0));
+ CleanupStack::Pop(command);
+ }
+ else
+ {
+ iNewMediaCreationError = KErrCancel;
+ }
+
+ CleanupStack::PopAndDestroy(mediaPopupTitle);
+ CleanupStack::PopAndDestroy(path);
+ return command;
+ }
+
+
+// ---------------------------------------------------------------------------
+// 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);
+ iFileNameAlreadyExists = ETrue ;
+ // As the new Item name already existing , re-execute the command to show entry pop-up
+ CGlxMpxCommandCommandHandler::ExecuteL( EGlxCmdAddMedia );
+ if (iSchedulerWait && iNewMediaCreationError == KErrCancel )
+ {
+ // if iSchedulerWait exists then we know the command is being executed from
+ // the ExecuteLD() method.
+ // Stop the schedulerwait loop if dialog is cancelled after starting the schedulerwait loop
+ iSchedulerWait->AsyncStop();
+ }
+ }
+ else
+ {
+ // Use default error handler
+ CGlxMpxCommandCommandHandler::HandleErrorL(aError);
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// 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;
+ }
+
+
+// ---------------------------------------------------------------------------
+// TitlesL fetches the 'media popup title' and 'default new media item title'
+// from the collection.
+// ---------------------------------------------------------------------------
+//
+
+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);
+
+ TGlxSpecificIdIterator iter(KGlxIdSpaceIdRoot, aCollectionId);
+ CGlxAttributeContext* attributeContext =
+ new (ELeave) CGlxAttributeContext(&iter);
+ CleanupStack::PushL(attributeContext);
+ attributeContext->AddAttributeL(
+ KGlxMediaCollectionPluginSpecificDefaultMediaTitle);
+ rootList->AddContextL(attributeContext, KGlxFetchContextPriorityBlocking);
+
+ TGlxFetchContextRemover contextRemover(attributeContext, *rootList);
+ // put to cleanupstack as cleanupstack is emptied before stack objects
+ // are deleted
+ CleanupClosePushL(contextRemover);
+ User::LeaveIfError(GlxAttributeRetriever::RetrieveL(*attributeContext,
+ *rootList, ETrue));
+ // context off the list
+ CleanupStack::PopAndDestroy(&contextRemover);
+
+ TInt index = rootList->Index(KGlxIdSpaceIdRoot, aCollectionId);
+
+ __ASSERT_DEBUG(index != KErrNotFound, Panic(EGlxPanicRequiredItemNotFound));
+
+ TGlxMedia item = rootList->Item(index);
+
+ const CGlxMedia* media = item.Properties();
+ if (media)
+ {
+ aDefaultNewMediaItemTitle.Copy(media->ValueText(
+ KGlxMediaCollectionPluginSpecificDefaultMediaTitle).Left(
+ KMaxMediaPopupTextLength));
+ }
+
+ CleanupStack::PopAndDestroy(attributeContext);
+ CleanupStack::PopAndDestroy(rootList);
+ CleanupStack::PopAndDestroy(path);
+ }
+
+// ---------------------------------------------------------------------------
+// TitlesL fetches the 'media popup title' and 'default new media item title'
+// from the collection.
+// ---------------------------------------------------------------------------
+//
+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);
+ TGlxFetchContextRemover contextRemover(attributeContext, aList);
+ // put to cleanupstack as cleanupstack is emptied before stack objects
+ // are deleted
+ CleanupClosePushL(contextRemover);
+ User::LeaveIfError(GlxAttributeRetriever::RetrieveL(*attributeContext,
+ aList, EFalse));
+ // context off the list
+ CleanupStack::PopAndDestroy(&contextRemover);
+ CleanupStack::PopAndDestroy(attributeContext);
+
+ RArray<TInt> numbers;
+ CleanupClosePushL(numbers);
+
+ TInt count = aList.Count();
+ for (TInt i = 0; i < count; i++)
+ {
+ TGlxMedia item = aList.Item(i);
+ const CGlxMedia* media = item.Properties();
+ if (media)
+ {
+ const TDesC& title = media->ValueText(KMPXMediaGeneralTitle);
+
+ TInt length = aDefaultNewMediaItemTitle.Length();
+ if (title.Left(length).Compare(aDefaultNewMediaItemTitle) == 0)
+ {
+ if (length == title.Length())
+ {
+ numbers.InsertInOrderL(0); // special case
+ }
+ else if (title.Length() > length + KOpenBracket().Length()
+ + KCloseBracket().Length())
+ {
+ TInt pos = length;
+ length = KOpenBracket().Length();
+
+ if (title.Mid(pos, length).Compare(KOpenBracket) == 0
+ && title.Right(KCloseBracket().Length()).Compare(
+ KCloseBracket) == 0)
+ {
+ pos += length;
+ length = title.Length() - pos
+ - KCloseBracket().Length();
+ if (length > 0)
+ {
+ HBufC* num = title.Mid(pos, length).AllocLC();
+ TPtr numPtr = num->Des();
+ //Change to Western numeric for determining next numeral
+ AknTextUtils::ConvertDigitsTo(numPtr,EDigitTypeWestern);
+ TLex lex(numPtr);
+ TInt val = 0;
+ if (lex.Val(val) == KErrNone)
+ {
+ numbers.InsertInOrderL(val);
+ }
+ CleanupStack::PopAndDestroy(num);
+ }
+ }
+ }
+
+ }
+ }
+ }
+
+ TInt nextNumber = 0;
+ count = numbers.Count();
+ for (TInt i = 0; i < count; i++)
+ {
+ if (numbers[i] == nextNumber)
+ {
+ nextNumber++;
+ }
+ else
+ {
+ break;
+ }
+ }
+
+ CleanupStack::PopAndDestroy(&numbers);
+
+ TInt defaultTitleLength = aDefaultNewMediaItemTitle.Length()
+ + KFileNameFormatString().Length() + KCloseBracket().Length()
+ + KMaxNumberLength;
+ // If the default title length is bigger than KMaxMediaPopupTextLength,
+ // make sure we allocate enough space for it.
+ TInt titleLength = defaultTitleLength > KMaxMediaPopupTextLength ?
+ defaultTitleLength
+ : KMaxMediaPopupTextLength;
+ HBufC* newMediaItemTitle = HBufC::NewL(titleLength);
+ TPtr newMediaItemTitleDes = newMediaItemTitle->Des();
+ newMediaItemTitleDes.Append(aDefaultNewMediaItemTitle);
+
+ if (nextNumber > 0)
+ {
+ newMediaItemTitleDes.AppendFormat(KFileNameFormatString, nextNumber);
+ //Change numeric according to current input language here
+ AknTextUtils::ConvertDigitsTo(newMediaItemTitleDes,
+ AknTextUtils::TextEditorDigitType());
+ }
+ else
+ {
+ // 0 is a special case, return "New Media", not "New Media (0)"
+ }
+
+ return newMediaItemTitle;
+ }
+
+// -----------------------------------------------------------------------------
+// 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)
+ {
+ // calls CGlxCommandHandlerNewMedia::SetFocusL asynchronously
+ iAsyncFocuser->SetFocus(i);
+ break;
+ }
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// Constructor
+// -----------------------------------------------------------------------------
+//
+CGlxCommandHandlerNewMedia::CGlxAsyncFocuser::
+ CGlxAsyncFocuser(CGlxCommandHandlerNewMedia* aGlxCommandHandlerNewMedia)
+ : 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);
+ }
+
+// -----------------------------------------------------------------------------
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CGlxCommandHandlerNewMedia::CGlxAsyncFocuser::
+ ~CGlxAsyncFocuser()
+ {
+ TRACER("CGlxCommandHandlerNewMedia::CGlxAsyncFocuser::~CGlxAsyncFocuser()");
+ Cancel();
+ }
+
+// -----------------------------------------------------------------------------
+// RunL
+// -----------------------------------------------------------------------------
+//
+void CGlxCommandHandlerNewMedia::CGlxAsyncFocuser::RunL()
+ {
+ TRACER("CGlxCommandHandlerNewMedia::CGlxAsyncFocuser::RunL()");
+ iGlxCommandHandlerNewMedia->SetFocusL(iFocusIndex);
+ }
+
+// -----------------------------------------------------------------------------
+// DoCancel
+// -----------------------------------------------------------------------------
+//
+void CGlxCommandHandlerNewMedia::CGlxAsyncFocuser::DoCancel()
+ {
+ // No need to do anything
+ // CActive::Cancel() will wait for the request to complete
+ }
+
+// -----------------------------------------------------------------------------
+// SetFocusL
+// -----------------------------------------------------------------------------
+//
+void CGlxCommandHandlerNewMedia::CGlxAsyncFocuser::SetFocus(TInt aIndex)
+ {
+ TRACER("CGlxCommandHandlerNewMedia::CGlxAsyncFocuser::SetFocus()");
+ iFocusIndex = aIndex;
+ TRequestStatus* requestStatus = &iStatus;
+ User::RequestComplete(requestStatus,KErrNone);
+ SetActive();
+ }