MCL/sf/app/photos: comparison photosgallery/viewframework/views/metadatadialog/src/glxmetadatacontainer.cpp

equal deleted inserted replaced

-:2dac0fdba72b
+:191387a8b767
 /*
 * 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".
 #include  <glxcommandhandleraddtocontainer.h>     // For CGlxCommandHandlerAddToContainer
 #include  <glxcommandhandlers.hrh>                // for command handler id
 #include  <glxcommandfactory.h>                   //for command factory
 #include  <mpxcommandgeneraldefs.h>               // Content ID identifying general category of content provided
 #include  "mglxmetadatadialogobserver.h"
 #include  <glxtextentrypopup.h>
 #include  <glxcollectionpluginall.hrh>
 #include  <glxuistd.h>
 #include  <glxcollectionplugintags.hrh>       	  // tag collection plugin uid
 #include  <glxthumbnailattributeinfo.h>           // KGlxMediaIdThumbnail
 #include  <glxattributeretriever.h>               // CGlxAttributeReteiver
 #include  <aknQueryControl.h>
 #include  <glxdrmutility.h>                       //For launching DRM details pane
 #include  <glxgeneraluiutilities.h>               // General utilties class definition
 #include  <ExifModify.h>
 #include  <glxuiutilities.rsg>                    //For CExifModify
 #include  <mpxmediadrmdefs.h>
 #include  <glxfilterfactory.h>
 #include  <caf/manager.h>						  //For Filesystem
 // ============================ MEMBER FUNCTIONS ===============================
 // ---------------------------------------------------------
 // NewL
 // ---------------------------------------------------------
 //
 CGlxMetadataContainer* CGlxMetadataContainer::NewL( const TRect& aRect,
 MGlxMetadataDialogObserver& aDialogObserver,
 const TDesC& item,MToolbarResetObserver& aResetToolbarObs)
 	{
 	TRACER("CGlxMetadataContainer::NewL");
 	CGlxMetadataContainer* self = CGlxMetadataContainer::NewLC( aRect,
 aDialogObserver,item,aResetToolbarObs);
 	CleanupStack::Pop(self);
 	return self;
 	}
 // ---------------------------------------------------------
 // NewLC
 // ---------------------------------------------------------
 //
 CGlxMetadataContainer* CGlxMetadataContainer::NewLC( const TRect& aRect,
 													 MGlxMetadataDialogObserver&  aDialogObserver,
 													 const TDesC& aUri,MToolbarResetObserver& aResetToolbarObs)
 	{
 	TRACER("CGlxMetadataContainer::NewLC");
-	CGlxMetadataContainer* self = new(ELeave) CGlxMetadataContainer(aDialogObserver,aUri,aResetToolbarObs);
+	CGlxMetadataContainer* self = new(ELeave) CGlxMetadataContainer(aDialogObserver, aResetToolbarObs);
 	CleanupStack::PushL(self);
-	self->ConstructL( aRect);
+	self->ConstructL( aRect, aUri);
 	return self;
 	}
 // ---------------------------------------------------------
 // CGlxMetadataContainer
 // ---------------------------------------------------------
 //
 CGlxMetadataContainer::CGlxMetadataContainer(MGlxMetadataDialogObserver& aDialogObserver,
-const TDesC& aUri,MToolbarResetObserver& aResetToolbarObs)
+MToolbarResetObserver& aResetToolbarObs)
-					  :iDialogObesrver ( aDialogObserver ),iUri(aUri),iResetToolbarObs(aResetToolbarObs)
+					  :iDialogObesrver ( aDialogObserver ),iResetToolbarObs(aResetToolbarObs)
 {
 // No implementation
 }
 // ---------------------------------------------------------
 // CGlxMetadataContainer::ConstructL
 // ---------------------------------------------------------
 //
-void CGlxMetadataContainer::ConstructL( const TRect& /*aRect*/ )
+void CGlxMetadataContainer::ConstructL( const TRect& /*aRect*/ , const TDesC& aUri)
 	{
+	//media's uri
+	iUri = aUri.AllocL();
 	//Creating the RBuf texts for all the items except tags & albums
 	//which would be updated as whne the item is edited
 	iTextSetter.CreateL(KMaxFileName);
 	//RBuf text which would be updated as when a tag is edited for the item.
 	iTagSetter.CreateL(KMaxFileName);
 	//RBuf text which would be updated as when a album is edited for the item.
 	iAlbumSetter.CreateL(KMaxFileName);
 	//Create medialist filtered by uri - iUri
 	CreateMediaListForSelectedItemL();
 	//Setting the iVideo flag to EFalse initially
 	iVideo = EFalse;
 	//Setting the iMarquee flag to EFalse initially
 iMarquee = EFalse;
 //check when Remove location information is selected.
 iLocationinfo = EFalse;
-	//Creating a CGlxMetadataAsyncUpdate object
+	//Flag to indicate rename command is started
-	iAsyncRequest = CGlxMetadataAsyncUpdate::NewL(*this);
+	iRenameStarted = EFalse;
-	//Initializing to NULL
-	iModifiedUri = NULL;
-	//Flag to check if rename is completed successfully.
-	iRenameCompleted = EFalse;
 	}
 // ---------------------------------------------------------
 // ~CGlxMetadataContainer
 // ---------------------------------------------------------
 //
 CGlxMetadataContainer::~CGlxMetadataContainer()
 	{
 	TRACER("CGlxMetadataContainer::~CGlxMetadataContainer");
 	if( iItemMediaList )
 		{
 		iItemMediaList->RemoveContext(iMainListAttributecontext);
 		iItemMediaList->RemoveMediaListObserver(this);
 		iItemMediaList->Close();
 		iItemMediaList = NULL;
 		}
 if ( iTagMediaList )
 		{
 		iTagMediaList->RemoveContext(iTagContext);
 		iTagMediaList->RemoveMediaListObserver(this);
 		iTagMediaList->Close();
 		iTagMediaList = NULL;
 		}
 if ( iAlbumMediaList )
 		{
 		iAlbumMediaList->RemoveContext(iAlbumContext);
 		iAlbumMediaList->RemoveMediaListObserver(this);
 		iAlbumMediaList->Close();
 		iAlbumMediaList = NULL;
 		}
 if( iTagContext )
 		{
 delete iTagContext;
 iTagContext = NULL;
 		}
 if( iAlbumContext )
 		{
 delete iAlbumContext;
 iAlbumContext = NULL;
 		}
 if( iMainListAttributecontext )
 {
 delete iMainListAttributecontext;
 iMainListAttributecontext = NULL;
 }
 if( IsVisible() )
 	    {
 	    MakeVisible(EFalse);
 	    }
 iTextSetter.Close();
 iTagSetter.Close();
 iAlbumSetter.Close();
-if(iAsyncRequest)
-	    {
+	if(iUri)
-	delete iAsyncRequest;
+		{
-	    }
+		delete iUri;
-	if(iModifiedUri)
+		iUri = NULL;
-		{
-		delete iModifiedUri;
 		}
 	}
 //-----------------------------------------------------------------------------
 // CGlxMetadataContainer::MediaList
 //-----------------------------------------------------------------------------
 MGlxMediaList& CGlxMetadataContainer::MediaList()
 {
 //returns the active medialist.
 return *iItemMediaList;
 }
 //-----------------------------------------------------------------------------
 // CGlxMetadataContainer::CreateSettingItemL
 //-----------------------------------------------------------------------------
 CAknSettingItem* CGlxMetadataContainer::CreateSettingItemL(TInt aResourceId)
 {
 TRACER("CGlxMetadataContainer::CreateSettingItemL");
 CAknSettingItem* settingItem = NULL; // No need to push onto cleanup stack
 	iTextSetter.Zero();
 //Creating a empty Settings list box which will  be populated with metadata in handleattributeavailable
 switch(aResourceId)
 {
 case ENameItem:
 case EDateAndTimeItem:
 case EDescriptionItem:
 {
 settingItem = new (ELeave) CAknTextSettingItem(
 aResourceId, iTextSetter );
 break;
 }
 case ETagsItem:
 {
 iTagSetter.Copy(KGlxTextSetter);
 settingItem = new (ELeave) CAknTextSettingItem(
 aResourceId, iTagSetter );
 break;
 }
 case EAlbumsItem:
 {
 iAlbumSetter.Copy(KGlxTextSetter);
 settingItem = new (ELeave) CAknTextSettingItem(
 aResourceId, iAlbumSetter );
 break;
 }
 case ELocationItem:
 case ESizeItem:
 case EResolutionItem:
 {
 settingItem = new (ELeave) CAknTextSettingItem(
 aResourceId, iTextSetter );
 // CGlxMetadataContainer::HandleListboxChangesL
 //-----------------------------------------------------------------------------
 void CGlxMetadataContainer::HandleListboxChangesL()
 {
 TRACER("CGlxMetadataContainer::HandleListboxChangesL");
-if(iItemMediaList->Count() == 0)
+//dont Edit Item's details if medialist is empty
+//OR Rename command is in progress
+if(iItemMediaList->Count() == 0 || iRenameStarted)
 	{
+		GLX_LOG_INFO("MediaList empty or Rename command started");
 	return;
 	}
 TInt index = ListBox()->CurrentItemIndex();
 switch(index)
 {
 case ENameItem:
 case EDescriptionItem:
 {
 SetNameDescriptionL(index);
 break;
 }
 case ETagsItem:
 			{
 			//Set the focus of the item
 			iItemMediaList->SetFocusL(NGlxListDefs::EAbsolute,0);
 			//Launch add to container commandhandler via dialog observer.
 			iDialogObesrver.AddTagL();
 			break;
 			}
 case EAlbumsItem:
 			{
 			//Set the focus of the item
 			iItemMediaList->SetFocusL(NGlxListDefs::EAbsolute,0);
 			//Launch add to container commandhandler via dialog observer.
 			iDialogObesrver.AddAlbumL();
 			break;
 			}
 		case ELocationItem:
 			{
 			// Get the Media Item
 			const TGlxMedia& media = iItemMediaList->Item(0);
 			// Test to see if the Coordinate is Present
 			TCoordinate coordinate;
 			if( !media.GetCoordinate(coordinate) )
 				{
 				HBufC *noLocationBuf = StringLoader::LoadLC(R_GLX_METADATA_NOTE_INFO_NO_LOCATION);
 				break;
 				}
 			}
 case ElicenseItem:
 			{
-			//Create DRM utility
+		    const TGlxMedia& item = iItemMediaList->Item(0);
-			CGlxDRMUtility* drmUtility = CGlxDRMUtility::InstanceL();
+		    if( item.IsDrmProtected())
-			CleanupClosePushL(*drmUtility);
+		        {
-			drmUtility->ShowDRMDetailsPaneL(iItemMediaList->Item(0).Uri());
+//Create DRM utility
-			CleanupStack::PopAndDestroy(drmUtility);
+CGlxDRMUtility* drmUtility = CGlxDRMUtility::InstanceL();
-			}
+CleanupClosePushL(*drmUtility);
+drmUtility->ShowDRMDetailsPaneL(item.Uri());
+CleanupStack::PopAndDestroy(drmUtility);
+			    }
+			}
 			break;
 default:
 			{
 			break;
 			}
 }
 }
 //-----------------------------------------------------------------------------
 // CGlxMetadataContainer::CreateMediaListForSelectedItemL
 //-----------------------------------------------------------------------------
-void CGlxMetadataContainer::CreateMediaListForSelectedItemL(TBool aIsRename)
+void CGlxMetadataContainer::CreateMediaListForSelectedItemL( )
 {
 TRACER("CGlxMetadataContainer::CreateMediaListForSelectedItemL");
 //create the collection path for the medialist to be created
 CMPXCollectionPath* path = CMPXCollectionPath::NewL();
 CleanupStack::PushL( path );
 //set the all collection path as the details dialog can be launched from any of the grid views and filter with URI
 path->AppendL(KGlxCollectionPluginAllImplementationUid);
 //create the filter with the URI
-CMPXFilter* filter = NULL;
+CMPXFilter* filter = TGlxFilterFactory::CreateURIFilterL(*iUri);
-if(aIsRename)
+	CleanupStack::PushL( filter );
-	    {
+//create the medialist
-	    //create the filter with the modified URI after Rename happens
+iItemMediaList = MGlxMediaList::InstanceL(*path,TGlxHierarchyId(KMediaListId),filter);
-	    filter = TGlxFilterFactory::CreateURIFilterL(iModifiedUri->Des());
-	    }
-	else
-		{
-		filter  = TGlxFilterFactory::CreateURIFilterL(iUri);
-		}
-CleanupStack::PushL( filter );
-//create the medialist
-iItemMediaList = MGlxMediaList::InstanceL(*path,TGlxHierarchyId(KMediaListId),filter);
 //Add the attributes which are required to be displayed.
 iMainListAttributecontext = new (ELeave) CGlxAttributeContext(&iSelectionIterator);
 iMainListAttributecontext->AddAttributeL(KMPXMediaDrmProtected);
 iMainListAttributecontext->AddAttributeL(KMPXMediaGeneralCategory);
 iMainListAttributecontext->AddAttributeL(KMPXMediaGeneralSize);
 //Viewdetails option will be availble only for the license item
 //Delete option will be available only for the location item
 aMenuPane->SetItemDimmed(KGlxViewBoundMenuCommandId,IsLicenseItem());
 //location info will be enabled if the item has a location info
 		aMenuPane->SetItemDimmed(KGlxDeleteBoundMenuCommandId,IsLocationItem());
-aMenuPane->SetItemDimmed(EGlxCmdAiwShowMap,IsLocationItem());
+		// Show on Map is no longer part of requirements and should not be shown in the
+		// options menu. When show on map has to come back, replace the 'ETrue' below with
+		// the function IsLocationItem.
+aMenuPane->SetItemDimmed(EGlxCmdAiwShowMap,ETrue);
 }
 }
 // ----------------------------------------------------------------------------
 //get the item handcle to be modified
 CAknSettingItem* settingsitem = (*SettingItemArray())[aItem];
 HBufC* textBuf = HBufC::NewLC( KMaxMediaPopupTitleLength );
 (textBuf->Des()).Copy((settingsitem->SettingTextL()));
 TPtr textPtr = textBuf->Des();
+//Remove preceeding & trailing spaces
+textPtr.Trim();
 TBuf<KMaxMediaPopupTitleLength> titleText(*textBuf);
 HBufC *buf = NULL;
 if(aItem == ENameItem)
 {
 buf = StringLoader::LoadLC(R_GLX_METADATA_VIEW_TITLE_NSERIES);
 //action upon selecting ok from the editor
 if ( popup->ExecuteLD() == EEikBidOk )
 		{
 		if(0 != (titleText.Compare(*textBuf)))
 			{
+			TFileName fileName = ParseFileName(*textBuf);
+			//check If filename already exists
 			if ((aItem == ENameItem) &&
-					(BaflUtils::FileExists(ControlEnv()->FsSession(), ParseFileName(*textBuf))))
+					(BaflUtils::FileExists(ControlEnv()->FsSession(), fileName)))
 				{
 				//if changed title is same as existing one then showing the already use popup to user
 				HBufC* info = StringLoader::LoadLC(R_GLX_NAME_ALREADY_USED, *textBuf);
 				GlxGeneralUiUtilities::ShowInfoNoteL(*info, ETrue);
 				CleanupStack::PopAndDestroy(info);
 				//Modify the MDS and setting list only if the entry is different from previous Item value
 iTextSetter.Zero();
 				iTextSetter.Copy(*textBuf);
 				EditItemL(aItem,EFalse);
 				iItemMediaList->SetFocusL(NGlxListDefs::EAbsolute,0);//set focus to first item
-				CMPXCollectionPath* path = iItemMediaList->PathLC();
-				CMPXCommand* command = NULL;
-				//Create the glx command based on the item
 				if(aItem == ENameItem)
 					{
-					command = TGlxCommandFactory::RenameCommandLC(settingsitem->SettingTextL(),
+					//indicate Rename command is started
-					                                                  *path);
+					iRenameStarted = ETrue;
+					//set Setting List Box to Dimmed status
+					SetDimmed(iRenameStarted);
+					const TGlxMedia& media = iItemMediaList->Item(0);
+					ContentAccess::CManager *manager = ContentAccess::CManager::NewL();
+					CleanupStack::PushL(manager);
+					HBufC* modifiedName = fileName.AllocLC();
+					//rename the media
+					TInt error = manager->RenameFile(media.Uri(), *modifiedName);
+					if(KErrNone == error)
+						{
+						//Redundant call But needed in case FileSystem is too slow
+						//to notify MDS for updating title.
+						//Create the glx command for updating Title in MDS
+						CMPXCollectionPath* path = iItemMediaList->PathLC();
+						CMPXCommand* command = TGlxCommandFactory::RenameCommandLC(
+								settingsitem->SettingTextL(), *path);
+						command->SetTObjectValueL<TAny*> (
+								KMPXCommandGeneralSessionId,
+								static_cast<TAny*> (this));
+						//issue command to the medialist which further
+						//calls data source to update MDS
+						iItemMediaList->CommandL(*command);
+						CleanupStack::PopAndDestroy(command);
+						CleanupStack::PopAndDestroy(path);
+						}
+					else
+						{
+						//Renaming commmand failed
+						iRenameStarted = EFalse;
+						//reset Setting Items to undim status
+						SetDimmed(iRenameStarted);
+						//Reset the EName Settings field
+						iTextSetter.Zero();
+						iTextSetter.Copy(media.Title());
+						EditItemL(ENameItem,EFalse);
+						User::LeaveIfError(error);
+						}
+					CleanupStack::PopAndDestroy(modifiedName);
+					CleanupStack::PopAndDestroy(manager);
 					}
 				else
 					{
-					command = TGlxCommandFactory::SetDescriptionCommandLC(settingsitem->SettingTextL(),
+					//Create the glx command for changing description
-					                                          *path);
+					CMPXCollectionPath* path = iItemMediaList->PathLC();
+					CMPXCommand* command =
+							TGlxCommandFactory::SetDescriptionCommandLC(
+									settingsitem->SettingTextL(), *path);
+					command->SetTObjectValueL<TAny*> (
+							KMPXCommandGeneralSessionId,
+							static_cast<TAny*> (this));
+					//issue command to the medialist which further
+					//calls data source to update MDS
+					iItemMediaList->CommandL(*command);
+					CleanupStack::PopAndDestroy(command);
+					CleanupStack::PopAndDestroy(path);
 					}
-				command->SetTObjectValueL<TAny*>(KMPXCommandGeneralSessionId, static_cast<TAny*>(this));
-				//issue command to the medialist which further calls data source to update MDS
-				iItemMediaList->CommandL(*command);
-				CleanupStack::PopAndDestroy(command);
-				CleanupStack::PopAndDestroy(path);
 				}
 			}
 		}
 CleanupStack::PopAndDestroy( textBuf );
 for (TInt i = aAttributes.Count() - 1; i >= 0; i--)
 {
 //set attributes to the items in the container
 SetAttributesL(aAttributes[i]);
 }
-if (iRenameCompleted)
-{
+//Here following 2 cases are handled:-
-iRenameCompleted = EFalse;
+//1) Rename from Photos application or Post-Capture view
-iAvkonAppUi->ProcessCommandL(EGlxCmdRenameCompleted);
+//- HandleAttributeavailable - new title & new uri at same time.
-}
+//May come twice here since Redundant Rename CMD sent to MDS.
+//2) Rename from Filemanager.
+//- HandleAttributeavailable - new title & new uri at same time.
+//Check if media's uri(i.e 'aModifiedUri') is different from 'iUri'
+//i.e media is Renamed then Refesh Media list.
+TMPXAttribute uriAttrib(KMPXMediaGeneralUri);
+TIdentityRelation< TMPXAttribute > match ( &TMPXAttribute::Match );
+TInt index = aAttributes.Find(uriAttrib, match);
+if (KErrNotFound != index)
+	{
+	HBufC* modifiedUri = NULL;
+			TGlxMedia item = iItemMediaList->Item(0);
+			//Create the string convertor instance
+			CGlxUStringConverter* stringConverter = CGlxUStringConverter::NewL();
+			CleanupStack::PushL(stringConverter);
+			//fetch media uri
+			stringConverter->AsStringL(item,aAttributes[index],0, modifiedUri );
+			CleanupStack::PopAndDestroy(stringConverter);
+			//Check if media item was renamed
+			if (modifiedUri && modifiedUri->Compare(*iUri) != 0)
+				{
+				//Set rename command as started since
+				//Rename is also possible from File Manager
+				iRenameStarted = ETrue;
+				CleanupStack::PushL(modifiedUri);
+				RefreshMediaListL(*modifiedUri);
+				CleanupStack::PopAndDestroy(modifiedUri);
+				}
+			}
 }
 TMPXAttribute titleAttrib(KMPXMediaGeneralTitle);
 TIdentityRelation< TMPXAttribute > match ( &TMPXAttribute::Match );
 if(iItemMediaList->Count())
 			{
 			TGlxMedia item = iItemMediaList->Item(0);
 			CGlxUStringConverter* stringConverter = CGlxUStringConverter::NewL();
 			CleanupStack::PushL(stringConverter );
-			for(TInt index = 0; index <= ElicenseItem ; index++)
+			for(TInt index = 0; index <= EDurationItem ; index++)
 				{
 				HBufC* string = NULL;
 iTextSetter.Zero();
 				if(index == ESizeItem)
 				CleanupStack::PushL( string );
 				EditItemL(index,EFalse);
 				CleanupStack::PopAndDestroy(string );
 				}
 			CleanupStack::PopAndDestroy(stringConverter );
-			}
+			//Reopening Media list is completed
+			//& Rename Command is also completed
+			if(iRenameStarted)
+				{
+				iRenameStarted = EFalse;
+				//reset Setting Items to undimmed status
+				SetDimmed(iRenameStarted);
+				iAvkonAppUi->ProcessCommandL(EGlxCmdRenameCompleted);
+				}
+			}
 }
 }
 // ----------------------------------------------------------------------------
 // EnableMarqueingL
 // ----------------------------------------------------------------------------
 //
 void CGlxMetadataContainer::HandleCommandCompleteL(TAny* aSessionId,
 CMPXCommand* aCommandResult, TInt aError, MGlxMediaList* aList)
 {
 TRACER("CGlxMetadataContainer::HandleCommandCompleteL()");
-//To rename the uri in File System
+//Callback from MDS when rename the Title
 if(aError == KErrNone)
 		{
 		if(aList == iItemMediaList && aCommandResult->IsSupported(KMPXMediaGeneralTitle))
 			{
-			iItemMediaList->SetFocusL(NGlxListDefs::EAbsolute,0);
+			GLX_LOG_INFO("RenameCMD to MDS completed");
-			const TGlxMedia& media = iItemMediaList->Item(0);
+			//Since RenameCommand to MDS is redundant and FileSystem has
-			ContentAccess::CManager *manager = ContentAccess::CManager::NewL();
+			//already renamed the file, so there is no need to do anything here
-			CleanupStack::PushL(manager);
+			}
-			TFileName fileName = ParseFileName(iTextSetter);
+		}
-			if(iModifiedUri)
-				{
-				delete iModifiedUri;
-				iModifiedUri = NULL;
-				}
-			iModifiedUri = fileName.AllocL();
-			iTextSetter.Zero();
-			TInt error = manager->RenameFile(media.Uri(), iModifiedUri->Des());
-			if(error == KErrNone)
-				{
-				iAsyncRequest->CompleteSelf();
-				}
-			else
-				{
-				User::LeaveIfError(error);
-				}
-			CleanupStack::PopAndDestroy(manager);
-			}
-		}
 //To update the location information once the delete operation is successful.
 if(aList == iItemMediaList && iLocationinfo
 && static_cast<TAny*>( this ) == aSessionId)
 		{
 		TGlxMedia media = iItemMediaList->Item(0) ;
 	return destinationFileName;
 	}
 // ---------------------------------------------------------------------------
-// Create new MediaList with modified FileName.
+// Refresh MediaList with modified FileName.
 // ---------------------------------------------------------------------------
-void CGlxMetadataContainer::RefreshMediaListL()
+void CGlxMetadataContainer::RefreshMediaListL(const TDesC& aModifiedUri)
 	{
+	//Refresh media list since media is renamed
 TRACER("CGlxMetadataContainer::RefreshMediaList()");
-if (iItemMediaList)
+if (iUri)
-{
+		{
-iItemMediaList->RemoveContext(iMainListAttributecontext);
+		delete iUri;
-iItemMediaList->RemoveMediaListObserver(this);
+		iUri = NULL;
-iItemMediaList->Close();
+		}
-iItemMediaList = NULL;
+	//always points to current media name
-if (iMainListAttributecontext)
+	iUri = aModifiedUri.AllocL();
-{
+	CMPXFilter* filter = TGlxFilterFactory::CreateURIFilterL(*iUri);
-delete iMainListAttributecontext;
+	CleanupStack::PushL(filter);
-iMainListAttributecontext = NULL;
-}
+	//Update media list's filter
-CreateMediaListForSelectedItemL(ETrue);
+	iItemMediaList->SetFilterL(filter);
-}
+	CleanupStack::PopAndDestroy(filter);
-iRenameCompleted = ETrue;
+}
-}
-// ---------------------------------------------------------------------------
-// Completes the active object causing a call from the active scheduler to RunL()
-// ---------------------------------------------------------------------------
-//
-void CGlxMetadataAsyncUpdate::CompleteSelf()
-{
-TRACER("CGlxMetadataAsyncUpdate::CompleteSelf");
-TRequestStatus* status=&iStatus;
-User::RequestComplete(status, KErrNone);
-SetActive();
-}
-// -----------------------------------------------------------------------------
-// RunL
-// -----------------------------------------------------------------------------
-//
-void CGlxMetadataAsyncUpdate::RunL()
-{
-TRACER("CGlxMetadataAsyncUpdate::RunL");
-if(iStatus.Int() == KErrNone)
-	{
-	iObserver.RefreshMediaListL();
-	}
-}
-// -----------------------------------------------------------------------------
-// DoCancel
-// -----------------------------------------------------------------------------
-//
-void CGlxMetadataAsyncUpdate::DoCancel()
-{
-TRACER("CGlxMetadataAsyncUpdate::DoCancel");
-// No need to do anything
-}
-// ---------------------------------------------------------
-// NewL
-// ---------------------------------------------------------
-//
-CGlxMetadataAsyncUpdate* CGlxMetadataAsyncUpdate::NewL(CGlxMetadataContainer& aObserver)
-	{
-	TRACER("CGlxMetadataAsyncUpdate::NewL");
-	CGlxMetadataAsyncUpdate* self = CGlxMetadataAsyncUpdate::NewLC(aObserver);
-	CleanupStack::Pop(self);
-	return self;
-	}
-// ---------------------------------------------------------
-// NewLC
-// ---------------------------------------------------------
-//
-CGlxMetadataAsyncUpdate* CGlxMetadataAsyncUpdate::NewLC(CGlxMetadataContainer& aObserver)
-	{
-	TRACER("CGlxMetadataAsyncUpdate::NewLC");
-	CGlxMetadataAsyncUpdate* self = new(ELeave) CGlxMetadataAsyncUpdate(aObserver);
-	CleanupStack::PushL(self);
-	return self;
-	}
-// ---------------------------------------------------------
-// Constructor
-// ---------------------------------------------------------
-//
-CGlxMetadataAsyncUpdate::CGlxMetadataAsyncUpdate(CGlxMetadataContainer& aObserver):
-								CActive(EPriorityStandard),iObserver(aObserver)
-{
-TRACER("CGlxMetadataAsyncUpdate::CGlxMetadataAsyncUpdate()");
-CActiveScheduler::Add(this);
-}
-// ---------------------------------------------------------
-// Destructor
-// ---------------------------------------------------------
-//
-CGlxMetadataAsyncUpdate::~CGlxMetadataAsyncUpdate()
-	{
-	TRACER("CGlxMetadataAsyncUpdate::~CGlxMetadataAsyncUpdate");
-	Cancel();
-	}
 //End of file

branch	RCL_3
changeset 15	191387a8b767
parent 14	2dac0fdba72b
child 17	a60acebbbd9d