diff -r 8e5f6eea9c9f -r 5b3385a43d68 photosgallery/viewframework/commandhandlers/commoncommandhandlers/src/glxmediaselectionpopup.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/photosgallery/viewframework/commandhandlers/commoncommandhandlers/src/glxmediaselectionpopup.cpp Wed Sep 01 12:33:26 2010 +0100 @@ -0,0 +1,959 @@ +/* +* 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: Generic selection popup class +* +*/ + + +/** + * @internal reviewed 06/06/2007 by Dave Schofield + * @internal reviewed 13/07/2007 by Aki Vanhatalo + */ +// INCLUDE FILES + +#include "glxmediaselectionpopup.h" + +#include // for KDC_APP_RESOURCE_DIR + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // for CGlxResourceUtilities +#include +#include +#include +#include +#include +#include + +#include "glxcommandhandlernewmedia.h" + +_LIT(KUnselectedIconIndex, "1\t"); +_LIT(KAlbumIconIndex, "2\t"); +_LIT(KBlankIconIndex, "3\t"); // No icon + +_LIT(KGlxCommonCommandHandlerResource, "glxcommoncommandhandlers.rsc"); + +const TInt KMediaSelectionPopupMediaListHierarchyId = 0x2000A77A; +const TInt KIconArrayGranularity = 2; +const TInt KNewItemId = 12345; + +// --------------------------------------------------------------------------- +// Constructor +// --------------------------------------------------------------------------- +// +EXPORT_C CGlxMediaListAdaptor::CGlxMediaListAdaptor( + const MGlxMediaList* aMediaList, TBool aMultiSelection) : + iMediaList(aMediaList), iMultiSelection(aMultiSelection), + iStaticItemSelected(EFalse) + { + } + +// --------------------------------------------------------------------------- +// CGlxMediaListAdaptor::SetEnabled() +// --------------------------------------------------------------------------- +// +void CGlxMediaListAdaptor::SetEnabled(TBool aEnabled) + { + TRACER("CGlxMediaListAdaptor::SetEnabled"); + iEnabled = aEnabled; + } + +// --------------------------------------------------------------------------- +// CGlxMediaListAdaptor::MediaList() +// --------------------------------------------------------------------------- +// +const MGlxMediaList* CGlxMediaListAdaptor::MediaList() + { + TRACER("CGlxMediaListAdaptor::MediaList"); + return iMediaList; + } + +// --------------------------------------------------------------------------- +// CGlxMediaListAdaptor::MultiSelectionEnabled() +// --------------------------------------------------------------------------- +// +TBool CGlxMediaListAdaptor::MultiSelectionEnabled() + { + return iMultiSelection; + } + +// --------------------------------------------------------------------------- +// CGlxMediaListAdaptor::MdcaCount() +// --------------------------------------------------------------------------- +// +EXPORT_C TInt CGlxMediaListAdaptor::MdcaCount() const + { + TRACER("CGlxMediaListAdaptor::MdcaCount"); + __ASSERT_DEBUG(iMediaList, Panic(EGlxPanicNullPointer)); + if (iEnabled) + { + return iMediaList->Count(); + } + else + { + return 0; + } + } + +// --------------------------------------------------------------------------- +// CGlxMediaListAdaptor::MdcaPoint() +// --------------------------------------------------------------------------- +// +EXPORT_C TPtrC CGlxMediaListAdaptor::MdcaPoint(TInt aIndex) const + { + TRACER("CGlxMediaListAdaptor::MdcaPoint"); + const TGlxMedia& item = iMediaList->Item(aIndex); + + TPtrC title = item.Title(); + if (item.IsStatic() || title.Length() == 0) + { + // The item is a static item or the item's title length is 0 + iCurrentTitleString = KBlankIconIndex; + } + else + { + if (iMultiSelection) + { + iCurrentTitleString = KUnselectedIconIndex; + } + else + { + iCurrentTitleString = KAlbumIconIndex; + } + } + + // iCurrentTitleString contains a tab character + iCurrentTitleString.Append(title.Left(KMaxTitleStringLength + - iCurrentTitleString.Length())); + + return TPtrC(iCurrentTitleString); + } + +// --------------------------------------------------------------------------- +// CGlxMediaListAdaptor::IsStaticItemSelected +// --------------------------------------------------------------------------- +TBool CGlxMediaListAdaptor::IsStaticItemSelected() + { + TRACER("CGlxMediaListAdaptor::IsStaticItemSelected"); + return iStaticItemSelected; + } + +// --------------------------------------------------------------------------- +// CGlxMediaListAdaptor::SetStaticItemSelected +// --------------------------------------------------------------------------- +void CGlxMediaListAdaptor::SetStaticItemSelected(TBool aSelected) + { + TRACER("CGlxMediaListAdaptor::SetStaticItemSelected"); + iStaticItemSelected = aSelected; + } + +//--------------------------------------------------------------------------- +// CGlxSingleGraphicPopupMenuStyleList::NewL +//--------------------------------------------------------------------------- +CGlxSingleGraphicPopupMenuStyleList* CGlxSingleGraphicPopupMenuStyleList::NewL( + CEikListBox* aListBox, TInt aCbaResource, + AknPopupLayouts::TAknPopupLayouts aType) + { + TRACER("CGlxSingleGraphicPopupMenuStyleList::NewL"); + + CGlxSingleGraphicPopupMenuStyleList* self = + new (ELeave) CGlxSingleGraphicPopupMenuStyleList; + CleanupStack::PushL(self); + self->ConstructL(aListBox, aCbaResource, aType); + CleanupStack::Pop(self); + return self; + } + +// --------------------------------------------------------------------------- +// CGlxSingleGraphicPopupMenuStyleList::HandleListBoxEventL() +// --------------------------------------------------------------------------- +// +void CGlxSingleGraphicPopupMenuStyleList::HandleListBoxEventL( + CEikListBox *aListBox, TListBoxEvent aEventType) + { + TRACER("CGlxSingleGraphicPopupMenuStyleList::HandleListBoxEventL"); + + CAknSingleGraphicPopupMenuStyleListBox* listBox = + static_cast (aListBox); + + CGlxMediaListAdaptor + * mediaListAdaptor = + static_cast (listBox->Model()->ItemTextArray()); + + TBool staticItemSelected = EFalse; + TInt currItemIndx = listBox->View()->CurrentItemIndex(); + GLX_LOG_INFO1("Glx Pop-up listbox - HandleListBoxEventL() currItemIndx=%d", + currItemIndx); + + switch (aEventType) + { + case EEventItemClicked: + case EEventItemSingleClicked: + { + if (mediaListAdaptor->MultiSelectionEnabled() && currItemIndx + >= 0) + { + const TGlxMedia& item = mediaListAdaptor->MediaList()->Item( + currItemIndx); + + //Check if media item is user-defined or static + staticItemSelected = item.IsStatic(); + mediaListAdaptor->SetStaticItemSelected(staticItemSelected); + if (!staticItemSelected) + { + //Mark or UnMark the user-defined item + TBool isMarked = listBox->View()->ItemIsSelected( + currItemIndx); + (isMarked == (TBool) ETrue) ? (listBox->View()->DeselectItem( + currItemIndx)) + : (listBox->View()->SelectItemL(currItemIndx)); + } + + //Show Command Set based on selected items + TInt selectCount = + listBox->View()->SelectionIndexes()->Count(); + CEikButtonGroupContainer* cbaContainer = + ButtonGroupContainer(); + //Show 'OK' only if a static item or more than + //1 user-defined item is selected + if (staticItemSelected || selectCount) + { + cbaContainer->SetCommandSetL(R_GLX_SOFTKEYS_OK_CANCEL); + } + else + { + cbaContainer->SetCommandSetL(R_AVKON_SOFTKEYS_CANCEL); + } + cbaContainer->DrawDeferred(); + + } + listBox->DrawDeferred(); + + //Forward for default processing, if static item is selected(i.e. For Tags) + //or if List Box's Multiple selection is Disabled(i.e. For Albums) + if (staticItemSelected + || (!mediaListAdaptor->MultiSelectionEnabled())) + { + CAknPopupList::HandleListBoxEventL(aListBox, aEventType); + } + + //After Scrolling, then Select "New Tag" i.e Static item is selected + if (staticItemSelected) + { + ProcessCommandL(EAknSoftkeyOk); + } + + break; + } + case EEventEnterKeyPressed: + { + // Check for multiselection is disbaled(i.e. for Albums) + // and valid index + if (!(mediaListAdaptor->MultiSelectionEnabled()) && currItemIndx + >= 0) + { + //Set if its a static item + const TGlxMedia& item = mediaListAdaptor->MediaList()->Item( + currItemIndx); + mediaListAdaptor->SetStaticItemSelected(item.IsStatic()); + } + CAknPopupList::HandleListBoxEventL(aListBox, aEventType); + break; + } + default: + { + CAknPopupList::HandleListBoxEventL(aListBox, aEventType); + break; + } + } + } + +// --------------------------------------------------------------------------- +// CGlxSingleGraphicPopupMenuStyleList::HandlePointerEventL() +// --------------------------------------------------------------------------- +// +void CGlxSingleGraphicPopupMenuStyleList::HandlePointerEventL( + const TPointerEvent& aPointerEvent) + { + TRACER("CGlxSingleGraphicPopupMenuStyleList::HandlePointerEventL"); + + CAknSingleGraphicPopupMenuStyleListBox* listBox = + static_cast (ListBox()); + CGlxMediaListAdaptor + * mediaListAdaptor = + static_cast (listBox->Model()->ItemTextArray()); + + //Check for MultipleSelection is Disbaled + if ( !(mediaListAdaptor->MultiSelectionEnabled()) ) + { + //checking if the index has changed & has valid item available + TInt changedItemIndex = KErrNotFound; + TBool isItemAvailable = listBox->View()->XYPosToItemIndex( + aPointerEvent.iPosition, changedItemIndex); + if(isItemAvailable) + { + //Check if Selected item is static + const TGlxMedia& item = mediaListAdaptor->MediaList()->Item( + changedItemIndex); + mediaListAdaptor->SetStaticItemSelected( item.IsStatic() ); + } + } + //Forward for default processing + CAknPopupList::HandlePointerEventL( aPointerEvent); + } + +// --------------------------------------------------------------------------- +// CGlxSingleGraphicPopupMenuStyleListBox::OfferKeyEventL +// --------------------------------------------------------------------------- +// +TKeyResponse CGlxSingleGraphicPopupMenuStyleListBox::OfferKeyEventL( + const TKeyEvent& aKeyEvent, TEventCode aType) + { + TRACER("CGlxSingleGraphicPopupMenuStyleListBox::OfferKeyEventL"); + + //Based on the selected item index, disable the MultipleSelection flag + //to stop the flickering of 'marked box', when Highlighted 'New Tag' is selected. + CGlxMediaListAdaptor* mediaListAdaptor = + static_cast (Model()->ItemTextArray()); + TInt currItemIndx = View()->CurrentItemIndex(); + GLX_LOG_INFO1("Glx Pop-up listbox - OfferKeyEventL(1) currItemIndx=%d", + currItemIndx); + + if (mediaListAdaptor->MultiSelectionEnabled() && currItemIndx >= 0) + { + const TGlxMedia& oldItem = mediaListAdaptor->MediaList()->Item( + currItemIndx); + if (oldItem.IsStatic()) + { + iListBoxFlags &= (~EMultipleSelection); // turn off multiple selection + } + else + { + iListBoxFlags |= EMultipleSelection; // turn on multiple selection + } + } + + //Forward for default processing + TKeyResponse response = + CAknSingleGraphicPopupMenuStyleListBox::OfferKeyEventL(aKeyEvent, + aType); + + currItemIndx = View()->CurrentItemIndex(); + GLX_LOG_INFO1("Glx Pop-up listbox - OfferKeyEventL(2) currItemIndx=%d", + currItemIndx); + //Check if 'Enter'/'Ok' key was consumed for 'MultipleSelection' List Box i.e for Tags + if ((response == EKeyWasConsumed) && ((aKeyEvent.iCode == EKeyEnter) + || (aKeyEvent.iCode == EKeyOK)) + && mediaListAdaptor->MultiSelectionEnabled() && currItemIndx >= 0) + { + //current selected item + const TGlxMedia& item = mediaListAdaptor->MediaList()->Item( + currItemIndx); + TBool staticItemSelected = item.IsStatic(); + mediaListAdaptor->SetStaticItemSelected(staticItemSelected); + + TInt selectCount = View()->SelectionIndexes()->Count(); + CEikButtonGroupContainer* cbaContainer = + CEikButtonGroupContainer::Current(); + //Check if selected Item is static or other item is selected + if (staticItemSelected || selectCount) + { + cbaContainer->SetCommandSetL(R_GLX_SOFTKEYS_OK_CANCEL); + } + //no item is selected + else + { + cbaContainer->SetCommandSetL(R_AVKON_SOFTKEYS_CANCEL); + } + cbaContainer->DrawDeferred(); + + //Enter Key is Pressed and Static Item is selected + if (staticItemSelected) + { + //Report 'Enter' key is pressed to ListBox observers + ReportListBoxEventL(MEikListBoxObserver::EEventEnterKeyPressed); + } + } + + return response; + } + +// --------------------------------------------------------------------------- +// Constructor +// --------------------------------------------------------------------------- +// +EXPORT_C CGlxMediaSelectionPopup::CGlxMediaSelectionPopup() : + CActive(EPriorityStandard) + { + TRACER("GlxMediaSelectionPopup::CGlxMediaSelectionPopup"); + CActiveScheduler::Add(this); + } + +// --------------------------------------------------------------------------- +// CGlxMediaSelectionPopup::RunL() +// --------------------------------------------------------------------------- +// +void CGlxMediaSelectionPopup::RunL() + { + TRACER("CGlxMediaSelectionPopup::RunL"); + // The media list adaptor is enabled after the popup list is invoked + // to ensure that the popup list is laid out correctly. + iMediaListAdaptor->SetEnabled(ETrue); + AddNewMediaCreationItemL(); + } + +// --------------------------------------------------------------------------- +// CGlxMediaSelectionPopup::DoCancel() +// --------------------------------------------------------------------------- +// +void CGlxMediaSelectionPopup::DoCancel() + { + // no implementation required + } + +// --------------------------------------------------------------------------- +// CGlxMediaSelectionPopup::ExecuteLD() +// --------------------------------------------------------------------------- +// +EXPORT_C CMPXCollectionPath* CGlxMediaSelectionPopup::ExecuteLD( + CMPXCollectionPath& aPath, TBool& aAccepted, TBool aMultiSelection, + TBool aEnableContainerCreation, CMPXFilter* aFilter) + { + TRACER("CGlxMediaSelectionPopup::ExecuteLD"); + CleanupStack::PushL(this); // if something leaves delete 'this' object + + iEnableContainerCreation = aEnableContainerCreation; + + iCollectionId = TGlxMediaId(aPath.Id(0)); + + FetchTitlesL(); + + iMediaList = MGlxMediaList::InstanceL(aPath, + KMediaSelectionPopupMediaListHierarchyId, aFilter); + + iMediaList->AddMediaListObserverL(this); + + iMediaListAdaptor = new (ELeave) CGlxMediaListAdaptor(iMediaList, + aMultiSelection); + + SetupAttributeContextL(); + + AddResourceFileL(); + ConstructPopupListL(aMultiSelection); + InitIconsL(); + + CompleteSelf(); // This will cause RunL() to be called by the active scheduler. + + // Invoke the dialog. + // The media list adaptor MdcaCount() method must return 0 at this point in order + // for the popup to be displayed correctly. If MdcaCount() returns 1 then the popup will contain only + // a single row. + // iPopupList->ExecuteLD() starts a nested active scheduler so acvtive objects will be executed before + // iPopupList->ExecuteLD() completes. + aAccepted = iPopupList->ExecuteLD(); + + if (iListBox->CurrentItemIndex() < 0) + { + // There is no current item therefore there is nothing to select + // Fix for error ID: ERBS-7BSKFV Application crashes if user attempts to add a tag when in full screen view. + aAccepted = EFalse; + } + + iMediaList->RemoveMediaListObserver(this); // We no longer require any callbacks from the media list + + + CMPXCollectionPath* path = NULL; + if (aAccepted) + { + + //Check if a static item is selected + if (iMediaListAdaptor->IsStaticItemSelected()) + { + TFileName uiutilitiesrscfile; + uiutilitiesrscfile.Append( + CGlxResourceUtilities::GetUiUtilitiesResourceFilenameL()); + CGlxCommandHandlerNewMedia* commandHandlerNewMedia = + CGlxCommandHandlerNewMedia::NewL(this,uiutilitiesrscfile); + TGlxMediaId newMediaId; + TInt error = commandHandlerNewMedia->ExecuteLD(newMediaId); + if (error == KErrNone) + { + path = CMPXCollectionPath::NewL(aPath); + CleanupStack::PopAndDestroy(this); + CleanupStack::PushL(path); + path->AppendL(newMediaId.Value()); + CleanupStack::Pop(path); + } + else if (error == KErrCancel) + { + // The user has cancelled the popup list + aAccepted = EFalse; + CleanupStack::PopAndDestroy(this); + } + else + { + // The error is neither KErrNone or KErrCancel, leave. + User::Leave(error); + } + + } + else + { + iMediaList->SetFocusL(NGlxListDefs::EAbsolute, + iListBox->CurrentItemIndex()); + + const CListBoxView::CSelectionIndexArray* selectionIndices = + iListBox->SelectionIndexes(); + + TInt count = selectionIndices->Count(); + for (TInt i = 0; i < count; i++) + { + iMediaList->SetSelectedL(selectionIndices->At(i), ETrue); + } + + path = iMediaList->PathLC(NGlxListDefs::EPathFocusOrSelection); + CleanupStack::Pop(path); + CleanupStack::PopAndDestroy(this); + } + } + else + { + CleanupStack::PopAndDestroy(this); + } + + return path; + } + +// --------------------------------------------------------------------------- +// CGlxMediaSelectionPopup::ListBoxItemsChanged() +// --------------------------------------------------------------------------- +// +void CGlxMediaSelectionPopup::ListBoxItemsChanged(CEikListBox* /*aListBox*/) + { + // Don't do anything. + } + +// ----------------------------------------------------------------------------- +// Destructor +// ----------------------------------------------------------------------------- +// +CGlxMediaSelectionPopup::~CGlxMediaSelectionPopup() + { + TRACER("CGlxMediaSelectionPopup::~CGlxMediaSelectionPopup"); + Cancel(); + + delete iMediaListAdaptor; + delete iListBox; + + if (iResourceOffset) + { + CCoeEnv::Static()->DeleteResourceFile(iResourceOffset); + } + + if (iMediaList) + { + if (iAttributeContext) + { + iMediaList->RemoveContext(iAttributeContext); + } + iMediaList->RemoveMediaListObserver(this); // This is required in case ExecuteLD() left. + + iMediaList->Close(); + } + + delete iAttributeContext; + delete iSelectMediaPopupTitle; + delete iNewMediaItemTitle; + } + +// ----------------------------------------------------------------------------- +// CGlxMediaSelectionPopup::HandleItemAddedL() +// ----------------------------------------------------------------------------- +// +void CGlxMediaSelectionPopup::HandleItemAddedL(TInt aStartIndex, + TInt aEndIndex, MGlxMediaList* aList) + { + TRACER("CGlxMediaSelectionPopup::HandleItemAddedL"); + // The call to HandleItemAdditionL() should be deferred if all of the new items + // don't have title attributes as unnecessary calls to HandleItemAdditionL will + // cause the dialog to flicker. + if (iListBox) + { + TBool handleItemAdditionRequired = EFalse; + for (TInt i = aStartIndex; i <= aEndIndex; i++) + { + TGlxMedia item = aList->Item(i); + if (item.Title().Length() > 0) + // The title length is greater than 0, i.e. there is a title. + { + handleItemAdditionRequired = ETrue; + break; + } + } + + if (handleItemAdditionRequired) + { + iListBox->HandleItemAdditionL(); + } + else + { + iHandleItemAdditionRequired = ETrue; // defer the call until we have title attributes + } + } + + CGlxUiUtility* uiUtility = CGlxUiUtility::UtilityL(); + CleanupClosePushL(*uiUtility); + if ((iMediaListAdaptor && !iMediaListAdaptor->MultiSelectionEnabled()) + || !uiUtility->IsPenSupported()) + { + CEikButtonGroupContainer* cbaContainer = + iPopupList->ButtonGroupContainer(); + cbaContainer->SetCommandSetL(R_GLX_SOFTKEYS_OK_CANCEL); + cbaContainer->DrawDeferred(); + } + CleanupStack::PopAndDestroy(uiUtility); + + ///@todo if required: update the existing selection when items are added + } + +// ----------------------------------------------------------------------------- +// CGlxMediaSelectionPopup::HandleMediaL() +// ----------------------------------------------------------------------------- +// +void CGlxMediaSelectionPopup::HandleMediaL(TInt /*aListIndex*/, + MGlxMediaList* /*aList*/) + { + // Don't do anything. + } + +// ----------------------------------------------------------------------------- +// CGlxMediaSelectionPopup::HandleItemRemovedL() +// ----------------------------------------------------------------------------- +// +void CGlxMediaSelectionPopup::HandleItemRemovedL(TInt /*aStartIndex*/, + TInt /*aEndIndex*/, MGlxMediaList* /*aList*/) + { + TRACER("CGlxMediaSelectionPopup::HandleItemRemovedL"); + if (iListBox) + { + iListBox->HandleItemRemovalL(); + } + } + +// ----------------------------------------------------------------------------- +// CGlxMediaSelectionPopup::HandleItemModifiedL() +// ----------------------------------------------------------------------------- +// +void CGlxMediaSelectionPopup::HandleItemModifiedL( + const RArray& aItemIndexes, MGlxMediaList* /*aList*/) + { + TRACER("CGlxMediaSelectionPopup::HandleItemModifiedL"); + if (iListBox) + { + for (TInt i = 0; i < aItemIndexes.Count(); i++) + { + if (IsListBoxItemVisible(aItemIndexes[i])) + { + iListBox->RedrawItem(aItemIndexes[i]); + } + } + } + } + +// ----------------------------------------------------------------------------- +// CGlxMediaSelectionPopup::HandleAttributesAvailableL() +// ----------------------------------------------------------------------------- +// +void CGlxMediaSelectionPopup::HandleAttributesAvailableL(TInt aItemIndex, + const RArray& /*aAttributes*/, MGlxMediaList* /*aList*/) + { + TRACER("CGlxMediaSelectionPopup::HandleAttributesAvailableL"); + if (iListBox) + { + if (iHandleItemAdditionRequired) + { + iListBox->HandleItemAdditionL(); + iHandleItemAdditionRequired = EFalse; + } + if (IsListBoxItemVisible(aItemIndex)) + { + iListBox->RedrawItem(aItemIndex); + } + } + } + +// ----------------------------------------------------------------------------- +// CGlxMediaSelectionPopup::HandleFocusChangedL() +// ----------------------------------------------------------------------------- +// +void CGlxMediaSelectionPopup::HandleFocusChangedL( + NGlxListDefs::TFocusChangeType /*aType*/, TInt /*aNewIndex*/, + TInt /*aOldIndex*/, MGlxMediaList* /*aList*/) + { + // Don't do anything. + } + +// ----------------------------------------------------------------------------- +// CGlxMediaSelectionPopup::HandleItemSelectedL() +// ----------------------------------------------------------------------------- +// +void CGlxMediaSelectionPopup::HandleItemSelectedL(TInt /*aIndex*/, + TBool /*aSelected*/, MGlxMediaList* /*aList*/) + { + // Don't do anything. + } + +// ----------------------------------------------------------------------------- +// CGlxMediaSelectionPopup::HandleMessageL() +// ----------------------------------------------------------------------------- +// +void CGlxMediaSelectionPopup::HandleMessageL(const CMPXMessage& /*aMessage*/, + MGlxMediaList* /*aList*/) + { + // Don't do anything. + } + +// ----------------------------------------------------------------------------- +// CGlxMediaSelectionPopup::HandleError() +// ----------------------------------------------------------------------------- +// +void CGlxMediaSelectionPopup::HandleError(TInt /*aError*/) + { + ///@todo implement + } + +// ----------------------------------------------------------------------------- +// CGlxMediaSelectionPopup::MediaList() +// ----------------------------------------------------------------------------- +// +MGlxMediaList& CGlxMediaSelectionPopup::MediaList() + { + // Provides a media list to CGlxCommandHandlerNewMedia + return *iMediaList; + } + +// ----------------------------------------------------------------------------- +// CGlxMediaSelectionPopup::AddResourceFileL() +// ----------------------------------------------------------------------------- +// +void CGlxMediaSelectionPopup::AddResourceFileL() + { + TRACER("CGlxMediaSelectionPopup::AddResourceFileL"); + // Load resource + TParse parse; + parse.Set(KGlxCommonCommandHandlerResource, &KDC_APP_RESOURCE_DIR, NULL); + TFileName resourceFile; + resourceFile.Append(parse.FullName()); + CGlxResourceUtilities::GetResourceFilenameL(resourceFile); + iResourceOffset = CCoeEnv::Static()->AddResourceFileL(resourceFile); + } + +// ----------------------------------------------------------------------------- +// CGlxMediaSelectionPopup::SetupAttributeContextL() +// ----------------------------------------------------------------------------- +// +void CGlxMediaSelectionPopup::SetupAttributeContextL() + { + TRACER("CGlxMediaSelectionPopup::SetupAttributeContextL"); + iAttributeContext = new (ELeave) CGlxAttributeContext(&iIterator); + iAttributeContext->AddAttributeL(KMPXMediaGeneralTitle); + iMediaList->AddContextL(iAttributeContext, KGlxFetchContextPriorityLow); + } + +// ----------------------------------------------------------------------------- +// CGlxMediaSelectionPopup::SetupAttributeContextL() +// ----------------------------------------------------------------------------- +// +void CGlxMediaSelectionPopup::InitIconsL() + { + TRACER("CGlxMediaSelectionPopup::InitIconsL"); + CAknIconArray* iconArray = new (ELeave) CAknIconArray( + KIconArrayGranularity); + CleanupStack::PushL(iconArray); + + // Sets graphics as ListBox icon. + iListBox->ItemDrawer()->ColumnData()->SetIconArray(iconArray); + + CleanupStack::Pop(iconArray); // iconArray + + ///@todo use mgallery icons when available + MAknsSkinInstance* skin = AknsUtils::SkinInstance(); + CGulIcon* icon = + AknsUtils::CreateGulIconL(skin, KAknsIIDQgnPropCheckboxOn, + KAvkonBitmapFile, EMbmAvkonQgn_prop_checkbox_on, + EMbmAvkonQgn_prop_checkbox_on_mask); + CleanupStack::PushL(icon); + iconArray->AppendL(icon); + CleanupStack::Pop(icon); + + icon = AknsUtils::CreateGulIconL(skin, KAknsIIDQgnPropCheckboxOff, + KAvkonBitmapFile, EMbmAvkonQgn_prop_checkbox_off, + EMbmAvkonQgn_prop_checkbox_off_mask); + CleanupStack::PushL(icon); + iconArray->AppendL(icon); + CleanupStack::Pop(icon); + + iconArray->AppendFromResourceL(R_GLX_ALBUM_SELECTION_ICONS); + + ///@todo Find a more elegant way of not painting an icon. + CFbsBitmap* bitmap = new (ELeave) CFbsBitmap; + CleanupStack::PushL(bitmap); + icon = CGulIcon::NewL(bitmap); + CleanupStack::Pop(bitmap); + CleanupStack::PushL(icon); + iconArray->AppendL(icon); + CleanupStack::Pop(icon); + } + +// ----------------------------------------------------------------------------- +// CGlxMediaSelectionPopup::AddNewMediaCreationItemL() +// ----------------------------------------------------------------------------- +// +void CGlxMediaSelectionPopup::AddNewMediaCreationItemL() + { + TRACER("CGlxMediaSelectionPopup::AddNewMediaCreationItemL"); + if (iEnableContainerCreation) + { + CGlxMedia* newMediaCreationStaticItem = new (ELeave) CGlxMedia( + TGlxMediaId(KNewItemId)); + CleanupStack::PushL(newMediaCreationStaticItem); + __ASSERT_DEBUG(iNewMediaItemTitle, Panic(EGlxPanicNullPointer)); + newMediaCreationStaticItem->SetTextValueL(KMPXMediaGeneralTitle, + *iNewMediaItemTitle); + iMediaList->AddStaticItemL(newMediaCreationStaticItem, + NGlxListDefs::EInsertFirst); + CleanupStack::Pop(newMediaCreationStaticItem); + } + } + +// ----------------------------------------------------------------------------- +// CGlxMediaSelectionPopup::CompleteSelf() +// ----------------------------------------------------------------------------- +// +void CGlxMediaSelectionPopup::CompleteSelf() + { + TRACER("CGlxMediaSelectionPopup::CompleteSelf"); + TRequestStatus* status = &iStatus; + User::RequestComplete(status, KErrNone); + SetActive(); + } + +// ----------------------------------------------------------------------------- +// CGlxMediaSelectionPopup::FetchTitlesL() +// ----------------------------------------------------------------------------- +// +void CGlxMediaSelectionPopup::FetchTitlesL() + { + TRACER("CGlxMediaSelectionPopup::FetchTitlesL"); + CMPXCollectionPath* path = CMPXCollectionPath::NewL(); + CleanupStack::PushL(path); + + MGlxMediaList* rootList = MGlxMediaList::InstanceL(*path); + CleanupClosePushL(*rootList); + + TGlxSpecificIdIterator iter(KGlxIdSpaceIdRoot, iCollectionId); + CGlxAttributeContext* attributeContext = + new (ELeave) CGlxAttributeContext(&iter); + CleanupStack::PushL(attributeContext); + attributeContext->AddAttributeL( + KGlxMediaCollectionPluginSpecificNewMediaItemTitle); + attributeContext->AddAttributeL( + KGlxMediaCollectionPluginSpecificSelectMediaPopupTitle); + rootList->AddContextL(attributeContext, KGlxFetchContextPriorityBlocking); + + // TGlxContextRemover will remove the context when it goes out of scope + // Used here to avoid a trap and still have safe cleanup + TGlxFetchContextRemover contextRemover(attributeContext, *rootList); + CleanupClosePushL(contextRemover); + User::LeaveIfError(GlxAttributeRetriever::RetrieveL(*attributeContext, + *rootList, EFalse)); + // context off the list + CleanupStack::PopAndDestroy(&contextRemover); + + TInt index = rootList->Index(KGlxIdSpaceIdRoot, iCollectionId); + + __ASSERT_DEBUG(index> KErrNotFound, Panic(EGlxPanicRequiredItemNotFound)); + TGlxMedia item = rootList->Item(index); + + const CGlxMedia* media = item.Properties(); + if (media) + { + iNewMediaItemTitle = media->ValueText( + KGlxMediaCollectionPluginSpecificNewMediaItemTitle).AllocL(); + iSelectMediaPopupTitle + = media->ValueText( + KGlxMediaCollectionPluginSpecificSelectMediaPopupTitle).AllocL(); + } + + CleanupStack::PopAndDestroy(attributeContext); + CleanupStack::PopAndDestroy(rootList); + CleanupStack::PopAndDestroy(path); + } + +// ----------------------------------------------------------------------------- +// CGlxMediaSelectionPopup::ConstructPopupListL() +// ----------------------------------------------------------------------------- +// +void CGlxMediaSelectionPopup::ConstructPopupListL(TBool aMultiSelection) + { + TRACER("CGlxMediaSelectionPopup::ConstructPopupListL"); + // create the list box + iListBox = new (ELeave) CGlxSingleGraphicPopupMenuStyleListBox; + + // create the popup list + iPopupList = CGlxSingleGraphicPopupMenuStyleList::NewL( iListBox, R_AVKON_SOFTKEYS_CANCEL) ; + + // set the title of the popup + __ASSERT_DEBUG(iSelectMediaPopupTitle, Panic(EGlxPanicNullPointer)); + + iPopupList->SetTitleL(*iSelectMediaPopupTitle); + + iListBox ->ConstructL(iPopupList, + aMultiSelection + ? EAknListBoxMultiselectionList + : EAknListBoxMenuList); + iListBox->CreateScrollBarFrameL(); + iListBox->ScrollBarFrame()->SetScrollBarVisibilityL( + CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto); + // create the listbox model + iListBox->Model()->SetItemTextArray(iMediaListAdaptor); + iListBox->View()->CalcBottomItemIndex(); + iListBox->Model()->SetOwnershipType(ELbmDoesNotOwnItemArray); + + //set 'iPopupList' as List Box observer + iListBox->SetListBoxObserver(iPopupList); + } + +//----------------------------------------------------------------------------- +// CGlxMediaSelectionPopup::IsListBoxItemVisible +//----------------------------------------------------------------------------- +TBool CGlxMediaSelectionPopup::IsListBoxItemVisible(TInt aIndex) + { + TRACER("CGlxMediaSelectionPopup::IsListBoxItemVisible"); + return iListBox && (iListBox->TopItemIndex() <= aIndex && + aIndex <= iListBox->BottomItemIndex()); + }