--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/photosgallery/controllers/fetcher/src/glxfetchercontainer.cpp Thu Dec 17 08:45:44 2009 +0200
@@ -0,0 +1,778 @@
+/*
+* 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: Container for Fecther Dialog
+*
+*/
+
+
+
+
+// System includes
+#include <avkon.rsg>
+#include <AknUtils.h> // For AknLayoutUtils to calculate rect
+#include <data_caging_path_literals.hrh> // KDC_APP_RESOURCE_DIR
+#include <StringLoader.h> // For Empty text reading from resource
+#include <akntitle.h> // Title Pane
+
+#include <mpxcollectionutility.h> // Mpx Collection path for medialist craetion
+#include <gulicon.h> // Gul Icon
+#include <ganes/HgItem.h> // HG Item
+#include <ganes/HgGrid.h> // Hg Grid Widget
+#include <AknsBasicBackgroundControlContext.h> // Background Context
+
+#include <glxuistd.h> // KGlxFetchontextPriorityNormal and KGlxIconsFilename
+#include <glxcollectionpluginall.hrh> // All item collection plugin id
+#include <glxfilterfactory.h> // For Filters required in Medilaits
+#include <glxresourceutilities.h> // for CGlxResourceUtilities
+#include <glxfetcherdialog.rsg> // FOR GETTING Dialog ID AND RESOURCE ID
+#include <glxattributecontext.h> // TMPXAttribute
+#include <glxattributeretriever.h> // CGlxAttributeRetriever
+#include <glxfetchcontextremover.h> // TGlxfetchContextRemover
+#include <glxuiutility.h> // AknIconUtils and EikStatusPane
+#include <glxtracer.h> // For Tracer logs
+#include <glxlog.h> // Glx Logger
+#include <glxgridviewmlobserver.h> // Medialistobserver for HgGrid
+#include <glxthumbnailcontext.h> // Thumbnailcontext for HgGrid
+#include <glxicons.mbg> // Glx Icons for HgGrid
+#include <mglxmedialist.h> // MGlxMediaList, CMPXCollectionPath
+#include <glxcommandhandlers.hrh> // For EGlxCmdEndMultiplemarking and EGlxCmdStartMultiplemarking
+#include <glxthumbnailattributeinfo.h> // KGlxMediaIdThumbnail
+#include <glxerrormanager.h>
+#include <glxdrmutility.h> // DRM utility class to provide DRM-related functionality
+
+// User includes
+#include "glxfetchercontainer.h"
+#include "mglxeventobserver.h"
+#include "glxfetcher.hrh"
+#include "glxfetchercommandhandler.h"
+
+const TInt KPadding(7);
+const TInt KNoOfPages(4);
+const TInt KBufferTreshold(1);
+const TInt KItemsPerPage(18);
+const TInt KBufferSize(KNoOfPages * KItemsPerPage);
+const TInt KBufferTresholdSize(KBufferTreshold * KItemsPerPage);
+
+//-----------------------------------------------------------------------------
+// Two-phased constructor.
+//-----------------------------------------------------------------------------
+CGlxFetcherContainer* CGlxFetcherContainer::NewL(
+ TGlxFilterItemType aFilterType, const TDesC& aTitle,
+ MGlxEventObserver& aEventObserver, TBool aMultiSelectionEnabled )
+ {
+ TRACER("CGlxFetcherContainer::NewL");
+ CGlxFetcherContainer* self =
+ new( ELeave ) CGlxFetcherContainer( aFilterType ,aTitle,
+ aEventObserver, aMultiSelectionEnabled);
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+//-----------------------------------------------------------------------------
+// C++ default constructor.
+//-----------------------------------------------------------------------------
+CGlxFetcherContainer::CGlxFetcherContainer(
+ TGlxFilterItemType aFilterType ,const TDesC& aTitle,
+ MGlxEventObserver& aEventObserver, TBool aMultiSelectionEnabled )
+ : iFilterType( aFilterType ),
+ iTitle( aTitle ),iEventObserver(aEventObserver),
+ iMultiSelectionEnabled(aMultiSelectionEnabled)
+ {
+ TRACER("CGlxFetcherContainer::CGlxFetcherContainer");
+ // No implementation required
+ }
+
+// ---------------------------------------------------------------------------
+// ConstructL()
+// ---------------------------------------------------------------------------
+void CGlxFetcherContainer::ConstructL()
+ {
+ TRACER("CGlxFetcherContainer::ConstructL");
+ iBgContext = CAknsBasicBackgroundControlContext::NewL(
+ KAknsIIDQsnBgAreaMain, Rect(), EFalse );
+ iUiUtility = CGlxUiUtility::UtilityL();
+ iGridIconSize = iUiUtility->GetGridIconSize();
+
+ // For DRM Utility
+ iDRMUtility = CGlxDRMUtility::InstanceL();
+ iIsFileAttached = EFalse;
+ }
+
+//-----------------------------------------------------------------------------
+// Destructor
+//-----------------------------------------------------------------------------
+CGlxFetcherContainer::~CGlxFetcherContainer()
+ {
+ TRACER("CGlxFetcherContainer::~CGlxFetcherContainer");
+ if (iDRMUtility)
+ {
+ iDRMUtility->Close();
+ }
+ delete iBgContext;
+ delete iPreviousTitle;
+ delete iFetcherCommandHandler;
+ delete iGlxGridMLObserver;
+ if (iHgGrid)
+ {
+ iHgGrid->SetFocus(EFalse);
+ delete iHgGrid;
+ iHgGrid = NULL;
+ }
+ if (iMediaList)
+ {
+ iMediaList->RemoveContext(iThumbnailContext);
+ delete iThumbnailContext;
+ iMediaList->Close();
+ }
+ if (iUiUtility)
+ {
+ iUiUtility->Close() ;
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CreateAndDisplayGridL
+// ---------------------------------------------------------------------------
+//
+void CGlxFetcherContainer::CreateAndDisplayGridL()
+ {
+ TRACER("CGlxFetcherContainer::CreateAndDisplayGridL");
+ //Create Medialist
+ CreateMediaListL();
+
+ // Create the control here
+ CreateHgGridWidgetL();
+
+ CreateGridMediaListObserverL();
+
+ CreateEmptyDisplayL( iFilterType );
+
+ // If multiple image selection is allowed, then set marking flag on grid widget.
+ if(iMultiSelectionEnabled)
+ {
+ // Fetcher CommandHandler must be created after creating the medialist
+ iFetcherCommandHandler = CGlxFetcherCommandHandler::NewL( this , this );
+
+ iHgGrid->SetFlags( CHgScroller::EHgScrollerSelectionMode );
+ iMultipleMarkNotStarted = EFalse;
+ }
+ }
+// ---------------------------------------------------------------------------
+// CreateEmptyDisplayL
+// Displays the empty string if no items in grid with respect to item selected.
+// ---------------------------------------------------------------------------
+//
+void CGlxFetcherContainer::CreateEmptyDisplayL( TGlxFilterItemType aFilterType )
+ {
+ TRACER("CGlxFetcherContainer::CreateEmptyDisplayL");
+ if (aFilterType == EGlxFilterImage)
+ {
+ HBufC* emptyText =
+ StringLoader::LoadLC(R_FETCHER_EMPTY_VIEW_TEXT_IMAGE);
+ iHgGrid->SetEmptyTextL(*emptyText);
+ CleanupStack::PopAndDestroy(emptyText);
+ }
+ else if (aFilterType == EGlxFilterVideo)
+ {
+ HBufC* emptyText =
+ StringLoader::LoadLC(R_FETCHER_EMPTY_VIEW_TEXT_VIDEO);
+ iHgGrid->SetEmptyTextL(*emptyText);
+ CleanupStack::PopAndDestroy(emptyText);
+ }
+ }
+// ---------------------------------------------------------------------------
+// CreateMediaListL()
+// Creates a collection path
+// Create a filter as requested filtertype
+// Creates the medialist
+// ---------------------------------------------------------------------------
+void CGlxFetcherContainer::CreateMediaListL()
+ {
+ TRACER("CGlxFetcherContainer::CreateMediaListL");
+
+ // Create path to the list of images and videos
+ CMPXCollectionPath* path = CMPXCollectionPath::NewL();
+ CleanupStack::PushL( path );
+ path->AppendL(KGlxCollectionPluginAllImplementationUid); // All item collection plugin
+
+ // Create filter to filter out either images or videos
+ GLX_LOG_INFO1("CGlxFetcherContainer::MediaListL - Filter Type = %d",iFilterType);
+ CMPXFilter* filter = TGlxFilterFactory::CreateItemTypeFilterL(iFilterType);
+ CleanupStack::PushL(filter);
+
+ // Create the media list
+ iMediaList = MGlxMediaList::InstanceL( *path,
+ TGlxHierarchyId(KGlxFetcherDllUid), filter );
+ CleanupStack::PopAndDestroy( filter );
+
+ GLX_LOG_INFO1("CGlxFetcherContainer::MediaListL - Path level = %d",
+ path->Levels());
+
+ CleanupStack::PopAndDestroy( path );
+ }
+// ---------------------------------------------------------------------------
+// CreateHgGridWidgetL
+// ---------------------------------------------------------------------------
+//
+void CGlxFetcherContainer::CreateHgGridWidgetL()
+ {
+ TRACER("CGlxFetcherContainer::CreateHgGridWidgetL");
+ //Setting the Title
+ SetTitleL( iTitle);
+
+ iThumbnailContext = CGlxThumbnailContext::NewL( &iBlockyIterator ); // set the thumbnail context
+ iThumbnailContext->SetDefaultSpec( iUiUtility->GetGridIconSize().iWidth,
+ iUiUtility->GetGridIconSize().iHeight );
+
+ CGlxDefaultAttributeContext* attrContext = CGlxDefaultAttributeContext::NewL();
+ CleanupStack::PushL(attrContext);
+ attrContext->AddAttributeL(KMPXMediaGeneralCount);
+ attrContext->SetRangeOffsets(KItemsPerPage, KItemsPerPage);
+ iMediaList->AddContextL(attrContext, KGlxFetchContextPriorityGridViewVisibleThumbnail);
+ User::LeaveIfError(GlxAttributeRetriever::RetrieveL(*attrContext,*iMediaList,EFalse));
+ iMediaList->RemoveContext(attrContext);
+ CleanupStack::PopAndDestroy( attrContext );
+ iMediaList->AddContextL(iThumbnailContext, KGlxFetchContextPriorityNormal );
+
+ if (!iHgGrid)
+ {
+ TRect rect;
+ AknLayoutUtils::LayoutMetricsRect (AknLayoutUtils::EMainPane, rect);
+ TSize iconSize (iUiUtility->GetGridIconSize().iWidth - (2*KPadding),
+ iUiUtility->GetGridIconSize().iHeight -(2*KPadding));
+ TFileName resFile(KDC_APP_BITMAP_DIR);
+ resFile.Append(KGlxIconsFilename);
+ CFbsBitmap* bitmap = AknIconUtils::CreateIconL(resFile,
+ EMbmGlxiconsQgn_prop_image_notcreated);
+ AknIconUtils::SetSize(bitmap, iconSize);
+
+ // Create Hg grid object
+ iHgGrid = CHgGrid::NewL (
+ rect,
+ iMediaList->Count(),
+ CGulIcon::NewL(bitmap) );
+ }
+ iHgGrid->SetSelectedIndex(iMediaList->FocusIndex());
+ // Setting to MopParent to update background skin
+ iHgGrid->SetMopParent(this);
+ // Setting Selction observer for getting callback on key event change
+ iHgGrid->SetSelectionObserver(*this);
+ // This Displays the scrollbar at the opening of the Grid view
+ iHgGrid->SetScrollBarTypeL(CHgScroller::EHgScrollerTimeStrip );
+ // Enable Buffer support
+ iHgGrid->EnableScrollBufferL(*this, KBufferSize, KBufferTresholdSize);
+ // Enable Marking support
+ iHgGrid->SetMarkingObserver(*this);
+
+ iHgGrid->SetFocus(ETrue);
+ }
+
+// ---------------------------------------------------------------------------
+// CreateGridMediaListObserverL
+// ---------------------------------------------------------------------------
+//
+void CGlxFetcherContainer::CreateGridMediaListObserverL()
+ {
+ iGlxGridMLObserver = CGlxGridViewMLObserver::NewL(*iMediaList , iHgGrid);
+ }
+
+// ---------------------------------------------------------------------------
+// BufferPositionChanged
+// ---------------------------------------------------------------------------
+//
+void CGlxFetcherContainer::Request(TInt aRequestStart, TInt aRequestEnd,
+ THgScrollDirection /*aDirection*/)
+ {
+ TRACER("CGlxFetcherContainer::Request()");
+ RequestL(aRequestStart, aRequestEnd);
+ }
+// ---------------------------------------------------------------------------
+// RequestL
+// ---------------------------------------------------------------------------
+//
+void CGlxFetcherContainer::RequestL(TInt aRequestStart, TInt aRequestEnd)
+ {
+ TRACER("CGlxFetcherContainer::RequestL()");
+ TInt mediaCount = iMediaList->Count();
+
+ aRequestStart = (aRequestStart<0 ? 0 : aRequestStart) ;
+ aRequestEnd = (aRequestEnd>=mediaCount? mediaCount : aRequestEnd);
+
+ if (aRequestEnd - aRequestStart)
+ {
+ TInt visIndex = iHgGrid->FirstIndexOnScreen();
+ if (visIndex < 0)
+ {
+ visIndex = 0;
+ }
+
+ else if (visIndex >= mediaCount)
+ {
+ visIndex = mediaCount-1;
+ }
+
+ GLX_LOG_INFO1("CGlxGridViewImp::Request - SetVisibleWindowIndex "
+ "visIndex(%d)", visIndex);
+ iMediaList->SetVisibleWindowIndexL(visIndex);
+ }
+ for (TInt i=aRequestStart; i<= aRequestEnd; i++)
+ {
+ SetIconsL(i);
+ TInt firstIndex = iHgGrid->FirstIndexOnScreen();
+ TInt lastOnScreen = firstIndex + iHgGrid->ItemsOnScreen() - 1;
+ if (i >= firstIndex && i <= lastOnScreen)
+ {
+ GLX_LOG_INFO1("CGlxGridViewImp::Request - RefreshScreen i(%d)", i);
+ iHgGrid->RefreshScreen(i);
+ }
+ }
+ }
+// ---------------------------------------------------------------------------
+// SetIcons
+// ---------------------------------------------------------------------------
+//
+void CGlxFetcherContainer::SetIconsL(TInt aIndex)
+ {
+ TRACER("CGlxFetcherContainer::SetIconsL()");
+ const TGlxMedia& item = iMediaList->Item(aIndex);
+ TMPXAttribute thumbnailAttribute(KGlxMediaIdThumbnail,
+ GlxFullThumbnailAttributeId( ETrue, iGridIconSize.iWidth,
+ iGridIconSize.iHeight ) );
+
+ TFileName resFile(KDC_APP_BITMAP_DIR);
+ resFile.Append(KGlxIconsFilename);
+ TIconInfo icon;
+ TInt tnError = GlxErrorManager::HasAttributeErrorL(
+ item.Properties(), KGlxMediaIdThumbnail );
+
+ const CGlxThumbnailAttribute* value = item.ThumbnailAttribute( thumbnailAttribute );
+ if (value)
+ {
+ CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;
+ bitmap->Duplicate( value->iBitmap->Handle());
+ iHgGrid->ItemL(aIndex).SetIcon(CGulIcon::NewL(bitmap));
+ GLX_LOG_INFO1("### CGlxGridViewImp::Request value-Index is %d",aIndex);
+ }
+ else if (item.GetIconInfo(icon))
+ {
+ GLX_LOG_INFO1("CGlxGridViewImp::Request - icon(%d)", aIndex);
+ CFbsBitmap* bitmap = AknIconUtils::CreateIconL(icon.bmpfile, icon.bitmapId);
+ AknIconUtils::SetSize(bitmap, CHgGrid::PreferredImageSize());
+ iHgGrid->ItemL(aIndex).SetIcon(CGulIcon::NewL(bitmap));
+ GLX_LOG_INFO1("### CGlxGridViewImp::Request GetIconInfo-Index is %d",aIndex);
+ }
+ else if ( KErrNone != tnError && KErrNotSupported != tnError )
+ {
+ GLX_LOG_INFO2("CGlxGridViewImp::Request - image_corrupted tnError(%d), "
+ "i(%d)", tnError, aIndex);
+ CFbsBitmap* bitmap = AknIconUtils::CreateIconL(resFile,
+ EMbmGlxiconsQgn_prop_image_corrupted);
+ AknIconUtils::SetSize(bitmap, CHgGrid::PreferredImageSize());
+ iHgGrid->ItemL(aIndex).SetIcon(CGulIcon::NewL(bitmap));
+ }
+
+ if (item.IsDrmProtected())
+ {
+ const TDesC& uri = item.Uri();
+ if( uri.Length() > 0)
+ {
+ if(iDRMUtility->IsForwardLockedL(uri))
+ {
+ iHgGrid->ItemL(aIndex).SetFlags(
+ CHgItem::EHgItemFlagsDrmRightsValid);
+ }
+ else
+ {
+ TMPXGeneralCategory cat = item.Category();
+ TBool checkViewRights = (cat==EMPXImage);
+
+ if(iDRMUtility->CheckOpenRightsL(uri, checkViewRights))
+ {
+ iHgGrid->ItemL(aIndex).SetFlags(
+ CHgItem::EHgItemFlagsDrmRightsValid);
+ }
+ else
+ {
+ iHgGrid->ItemL(aIndex).SetFlags(
+ CHgItem::EHgItemFlagsDrmRightsExpired);
+ }
+ }
+ }
+ }
+ TTime time(0);
+ if (item.GetDate(time))
+ {
+ iHgGrid->ItemL(aIndex).SetTime(time);
+ }
+
+ if (item.Category() == EMPXVideo)
+ {
+ iHgGrid->ItemL(aIndex).SetFlags(CHgItem::EHgItemFlagsVideo);
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// Release
+// ---------------------------------------------------------------------------
+//
+void CGlxFetcherContainer::Release(TInt /*aReleaseStart*/, TInt /*aReleaseEnd*/)
+ {
+ TRACER("CGlxFetcherContainer::Release()");
+ // This has to do nothing on default
+ }
+
+// ---------------------------------------------------------------------------
+// HandleSelect
+// ---------------------------------------------------------------------------
+//
+void CGlxFetcherContainer::HandleSelectL( TInt aIndex )
+ {
+ TRACER("CGlxGridViewImp::HandleSelect()");
+ // Make sure that the Selection Index is inside medialist count
+ if (aIndex <iMediaList->Count() && aIndex >=0)
+ {
+ // Setting the focus of the medialist
+ iMediaList->SetFocusL(NGlxListDefs::EAbsolute, aIndex);
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// HandleOpen
+// ---------------------------------------------------------------------------
+//
+void CGlxFetcherContainer::HandleOpenL( TInt aIndex )
+ {
+ TRACER("CGlxGridViewImp::HandleOpen()");
+ // Make sure that the Selection Index is inside medialist count
+ if (aIndex <iMediaList->Count() && aIndex >=0)
+ {
+ //ignore multiple tap events for single selection cases
+ //if file has already been selected
+ if(!iMultiSelectionEnabled && !iIsFileAttached)
+ {
+ iEventObserver.HandleDoubleTapEventL(EAknSoftkeySelect);
+ }
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// HandleMarkingL
+// ---------------------------------------------------------------------------
+//
+void CGlxFetcherContainer::HandleMarkingL( TInt aIndex, TBool/* aMarked*/ )
+ {
+ TRACER("CGlxGridViewImp::HandleMarkingL()");
+ HandleMultipleMarkingL(aIndex);
+ }
+
+// ---------------------------------------------------------------------------
+// HandleMultipleMarkingL
+// ---------------------------------------------------------------------------
+//
+void CGlxFetcherContainer::HandleMultipleMarkingL(TInt aIndex )
+ {
+ TRACER("CGlxGridViewImp::HandleMultipleMarkingL()");
+ if(iMediaList->IsSelected(aIndex))
+ {
+ if(iHgGrid)
+ {
+ if(iMultiSelectionEnabled)
+ {
+ iFetcherCommandHandler->DoExecuteL(EAknCmdUnmark, MediaList());
+ }
+ }
+ }
+ else
+ {
+ if(iHgGrid)
+ {
+ if(iUiUtility->IsPenSupported())
+ {
+ //This is required for the touch because here when we select
+ //we do not get the event for mark in processcommandL
+ //of FetcherDialog. So we explicitly send the event to ourselves
+ //to mark the item.
+ if (!iMultipleMarkNotStarted)
+ {
+ DoExecuteL(EAknCmdMark);
+ }
+ }
+ if(iMultiSelectionEnabled)
+ {
+ iFetcherCommandHandler->DoExecuteL(EAknCmdMark, MediaList());
+ }
+ }
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// DoExecuteL()
+// ---------------------------------------------------------------------------
+TBool CGlxFetcherContainer::DoExecuteL(TInt aCommandId)
+ {
+ TRACER("CGlxFetcherContainer::DoExecuteL");
+
+ TBool retVal = EFalse;
+ /*
+ * fix for EBYU-7UV4MW-- when user presses selection key
+ * very fast that time if hggrid is not created and we are trying to
+ * access hghgrid for marking it is giving crash. So need to chk if
+ * hggrid id created or not.same will also happen if media list is
+ * not created
+ */
+ if(!iHgGrid || !iMediaList)
+ {
+ return retVal;
+ }
+
+ TInt focusIndex = iMediaList->FocusIndex();
+
+ switch(aCommandId)
+ {
+ case EAknCmdMark:
+ case EAknMarkAll:
+ case EGlxCmdStartMultipleMarking:
+ {
+ //@ fix for ELWU-7RA7NX
+ if (iMultiSelectionEnabled )
+ {
+ if (!iMultipleMarkNotStarted)
+ {
+ //This will start multiple marking and not mark any items
+ iFetcherCommandHandler->DoExecuteL(EAknCmdMark, MediaList());
+ iMultipleMarkNotStarted = ETrue ;
+ }
+ //@ Mark in HG Grid
+ iHgGrid->Mark(focusIndex);
+ iHgGrid->RefreshScreen(focusIndex);
+
+ }
+ retVal = ETrue;
+ break;
+ }
+ case EAknCmdUnmark:
+ case EAknUnmarkAll:
+ {
+ //@ fix for ELWU-7RA7NX
+ if (iMultiSelectionEnabled)
+ {
+ //@ UnMark in HG Grid
+ iHgGrid->UnMark(focusIndex);
+ iHgGrid->RefreshScreen(focusIndex);
+ }
+
+ if( iMediaList->SelectionCount() <= 0 )
+ {
+ iMultipleMarkNotStarted = EFalse;
+ }
+ retVal = ETrue;
+ break;
+ }
+ case EGlxCmdEndMultipleMarking:
+ {
+ iHgGrid->ClearFlags( CHgScroller::EHgScrollerSelectionMode );
+ iFetcherCommandHandler->DoExecuteL(aCommandId, MediaList());
+ }
+ retVal = ETrue;
+ break;
+ default:
+ break;
+ }
+ return retVal;
+ }
+
+
+// -----------------------------------------------------------------------------
+// Retrieve Uris
+// -----------------------------------------------------------------------------
+TBool CGlxFetcherContainer::RetrieveUrisL( CDesCArray& aSelectedFiles, TBool& aFetchUri)
+ {
+ TRACER("CGlxFetcherContainer::RetrieveUrisL");
+ // check that the medialist is really constructed
+ // we can get this call while MGlxMediaList::InstanceL has not yet returned
+ // as it starts a new asynch wait loop and during that it is possible
+ // to send key events to the dialog.
+ if( !iMediaList || !iHgGrid )
+ {
+ aFetchUri = EFalse;
+ iIsFileAttached = EFalse;
+ return iIsFileAttached;
+ }
+ //To Block call to HandleDoubleTapEventL() when control is in RetrieveUrisL()
+ iIsFileAttached = ETrue;
+ GLX_LOG_INFO1("CGlxFetcherContainer::RetrieveUrisL() Medialist count is %d",
+ iMediaList->Count());
+ TGlxSelectionIterator iterator;
+ CGlxAttributeContext* context = new (ELeave) CGlxAttributeContext( &iterator );
+ CleanupStack::PushL( context );
+
+ // Configure the context to retrieve the URI attribute
+ context->AddAttributeL( KMPXMediaGeneralUri );
+
+ iMediaList->AddContextL( context, KGlxFetchContextPriorityBlocking );
+
+ // Create remover object to remove the context from the list
+ // even if a leave occurs
+ TGlxFetchContextRemover remover( context, *iMediaList );
+ // put to cleanupstack as cleanupstack is emptied before stack objects
+ // are deleted
+ CleanupClosePushL( remover );
+ // block until all content retrieved (shows progress note)
+ TInt error = GlxAttributeRetriever::RetrieveL( *context,
+ *iMediaList, ETrue ) ;
+ GLX_LOG_INFO1("CGlxFetcherContainer::RetrieveUrisL() Error %d", error);
+ // context off the list
+ CleanupStack::PopAndDestroy( &remover );
+ GLX_LOG_INFO1("CGlxFetcherContainer::RetrieveUrisL() Medialist count after GlxAttributeRetriever is %d",
+ iMediaList->Count());
+
+ // if error or if medialist count is 0 then do not proceed further with the iterator.
+ if (error == KErrNone && iMediaList->Count() !=0)
+ {
+ GLX_LOG_INFO1("CGlxFetcherContainer::RetrieveUrisL() inside loop and medialist count is %d",
+ iMediaList->Count());
+ // Add all selected items to client's array
+ iterator.SetToFirst( iMediaList );
+ TInt index = KErrNotFound;
+ while ( KErrNotFound != (index = iterator++) )
+ {
+ const TDesC& uri = iMediaList->Item( index ).Uri();
+ if( uri != KNullDesC )
+ {
+ aSelectedFiles.AppendL( uri );
+ iIsFileAttached = ETrue;
+ }
+ else
+ {
+ iIsFileAttached = EFalse;
+ }
+ }
+ }
+ CleanupStack::PopAndDestroy( context );
+ // Set the Fetch uri value as false, as it could be a drm image and calling
+ // application might not allow that to be selected, thus fetcher could be launched again.
+ aFetchUri = EFalse;
+ return iIsFileAttached;
+ }
+
+//-----------------------------------------------------------------------------
+// CGlxFetcherContainer::OfferKeyEventL
+//-----------------------------------------------------------------------------
+TKeyResponse CGlxFetcherContainer::OfferKeyEventL(
+ const TKeyEvent& aKeyEvent,TEventCode aType )
+ {
+ TRACER("CGlxFetcherContainer::OfferKeyEventL");
+ return iHgGrid->OfferKeyEventL(aKeyEvent,aType);
+ }
+
+// ---------------------------------------------------------------------------
+// SetTitleL()
+// ---------------------------------------------------------------------------
+void CGlxFetcherContainer::SetTitleL(const TDesC& aTitleText)
+ {
+ TRACER("CGlxFetcherContainer::SetTitleL");
+ CEikStatusPane* statusPane = iEikonEnv->AppUiFactory()->StatusPane();
+ CleanupStack::PushL(statusPane);
+ CAknTitlePane* titlePane = ( CAknTitlePane* )statusPane->ControlL(
+ TUid::Uid( EEikStatusPaneUidTitle ));
+ CleanupStack::PushL(titlePane);
+ // To Store Title and to make sure, Previous Title is only stored once
+ if (!iPreviousTitle)
+ {
+ iPreviousTitle = titlePane->Text()->AllocL();
+ }
+
+ // Set the required Title
+ titlePane->SetTextL( aTitleText );
+ CleanupStack::Pop(titlePane);
+ CleanupStack::Pop(statusPane);
+ }
+
+// ---------------------------------------------------------------------------
+// SetPreviousTitleL()
+// ---------------------------------------------------------------------------
+void CGlxFetcherContainer::SetPreviousTitleL()
+ {
+ TRACER("CGlxFetcherContainer::SetPreviousTitleL");
+ CEikStatusPane* prevStatusPane = iEikonEnv->AppUiFactory()->StatusPane();
+ CleanupStack::PushL(prevStatusPane);
+ CAknTitlePane* prevTitlePane = ( CAknTitlePane* )prevStatusPane->ControlL(
+ TUid::Uid( EEikStatusPaneUidTitle ));
+ CleanupStack::PushL(prevTitlePane);
+
+ // Restore the Title back of the Calling Application
+ prevTitlePane->SetTextL( *iPreviousTitle );
+ CleanupStack::Pop(prevTitlePane);
+ CleanupStack::Pop(prevStatusPane);
+ }
+
+// -----------------------------------------------------------------------------
+// UpdateTitle
+// -----------------------------------------------------------------------------
+//
+void CGlxFetcherContainer::UpdateTitleL()
+ {
+ TRACER("CGlxFetcherContainer::UpdateTitleL");
+ SetTitleL( iTitle);
+ }
+
+// -----------------------------------------------------------------------------
+// MediaList
+// -----------------------------------------------------------------------------
+//
+MGlxMediaList& CGlxFetcherContainer::MediaList()
+ {
+ TRACER("CGlxFetcherContainer::MediaList");
+ return *iMediaList;
+ }
+
+// -----------------------------------------------------------------------------
+// HandleSizeChange
+// -----------------------------------------------------------------------------
+//
+void CGlxFetcherContainer::HandleSizeChangeL ( )
+ {
+ TRACER("CGlxFetcherContainer::HandleSizeChangeL");
+ SetTitleL(iTitle);
+ TRect rect;
+ if(iHgGrid)
+ {
+ AknLayoutUtils::LayoutMetricsRect (AknLayoutUtils::EMainPane, rect);
+ iHgGrid->InitScreenL(rect);
+ }
+ if ( iBgContext )
+ {
+ AknLayoutUtils::LayoutMetricsRect (AknLayoutUtils::EApplicationWindow, rect);
+ iBgContext->SetRect( rect );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// MopSupplyObject
+// -----------------------------------------------------------------------------
+//
+TTypeUid::Ptr CGlxFetcherContainer::MopSupplyObject(TTypeUid aId)
+ {
+ TRACER("CGlxFetcherContainer::MopSupplyObject");
+ if (iBgContext)
+ {
+ return MAknsControlContext::SupplyMopObject(aId, iBgContext );
+ }
+ return CCoeControl::MopSupplyObject(aId);
+ }
+
+//END OF FILE