--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/profilesservices/MediaFileList/Src/mediafiledialog.cpp Wed Sep 01 12:20:44 2010 +0100
@@ -0,0 +1,3332 @@
+/*
+* Copyright (c) 2007 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: Class of Mediafiledialog. UI control of mediafilelist
+*
+*/
+
+
+
+
+// INCLUDE FILES
+
+#include "mediafiledialog.h"
+#include "mediafiledialogutils.h"
+#include "mediafilelist.h"
+#include "mediafilehandler.h"
+#include "mediafilelistdebug.h"
+#include "mediafileprotection.h"
+#include "mediafilevideopreviewdialog.h"
+#include "mediafiletest.h" // test code
+
+#include <eikclbd.h> // for CColumnListBoxData
+#include <coecobs.h> // MCoeControlObserver
+#include <AknUtils.h> // AknTextUtils AknFind
+#include <AknIconArray.h> // for GulArray
+#include <AknWaitDialog.h>
+#include <textresolver.h>
+#include <StringLoader.h>
+#include <akninputblock.h> // CAknInputBlock
+#include <mmferrors.h>
+// search field
+#include <aknselectionlist.h> // AknSelectionList.cpp
+#include <aknsfld.h> // CAknSearchField
+#include <eikcapc.h> // CEikCaptionedControl
+
+#include <aknconsts.h> // KAvkonBitmapFile, KAvkonVariatedBitmapsFile
+#include <AknsConstants.h> // icon constants
+#include <aknmemorycardui.mbg> // memory card icon
+#include <avkon.mbg>
+
+#include <avkon.loc>
+#include <mediafilelist.rsg>
+#include <mediafilelist.mbg>
+#include <data_caging_path_literals.hrh> // KDC_APP_RESOURCE_DIR
+#include <touchfeedback.h> // For MTouchFeedback
+
+
+
+
+
+/******************************************************************************
+ * class CMediaFileDialog
+ ******************************************************************************/
+
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::NewL
+//
+// -----------------------------------------------------------------------------
+CMediaFileDialog* CMediaFileDialog::NewL()
+ {
+ FLOG( _L("CMediaFileDialog::NewL START") );
+
+ CMediaFileDialog* self = new (ELeave) CMediaFileDialog();
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+
+ FLOG( _L("CMediaFileDialog::NewL END") );
+ return self;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::CMediaFileDialog
+//
+// -----------------------------------------------------------------------------
+//
+CMediaFileDialog::CMediaFileDialog()
+ {
+ FLOG( _L("CMediaFileDialog::CMediaFileDialog START") );
+
+ iResourceFileId = KErrNotFound;
+ iForeGround = ETrue;
+ iDatabaseOpen = EFalse;
+ iPeninputActive = EFalse;
+
+ iNullItemFileTypeOne = KErrNotFound;
+ iNullItemFileTypeTwo = KErrNotFound;
+ iDialogTitle = KNullDesC;
+ iIsDoubleClicked = EFalse;
+
+ FLOG( _L("CMediaFileDialog::CMediaFileDialog END") );
+ }
+
+
+// ----------------------------------------------------------------------------
+// Destructor
+//
+// ----------------------------------------------------------------------------
+//
+CMediaFileDialog::~CMediaFileDialog()
+ {
+ FLOG( _L("CMediaFileDialog::~CMediaFileDialog START") );
+
+ if ( iResourceFileId != KErrNotFound )
+ {
+ CEikonEnv::Static()->DeleteResourceFile( iResourceFileId );
+ }
+
+ delete iStatusPaneHandler;
+ delete iMFListHandler;
+ delete iMediaFileHandler;
+ delete iState;
+
+ delete iFindCtrl;
+ delete iCaller;
+ delete iSearchCaller;
+
+ delete iAudioPreviewHandler;
+ delete iVideoPreviewHandler;
+
+ delete iNullItemFileNameOne;
+ delete iNullItemFileNameTwo;
+
+ if ( iAvkonAppUi )
+ {
+ iAvkonAppUi->RemoveFromStack(this);
+ }
+
+ CCoeEnv::Static()->RemoveForegroundObserver( *this );
+
+ if ( iPopupNote )
+ {
+ iPopupNote->HideInfoPopupNote();
+ delete iPopupNote;
+ }
+
+ delete iWaitNote;
+ if ( AknLayoutUtils::PenEnabled() )
+ {
+ iPeninputServer.RemovePenUiActivationHandler();
+ iPeninputServer.Close();
+ }
+
+ delete iIdle;
+
+ delete iProtectionHandler;
+
+ delete iInputBlock;
+
+#ifdef _DEBUG
+ delete iTest; // test code
+#endif
+
+ FLOG( _L("CMediaFileDialog::~CMediaFileDialog END") );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::ConstructL
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::ConstructL()
+ {
+ FLOG( _L("CMediaFileDialog::ConstructL START") );
+
+ iResourceFileId = TMFDialogUtil::AddResFileL();
+
+ CCoeEnv* coeEnv = CCoeEnv::Static();
+ coeEnv->AddForegroundObserverL( *this );
+
+ CAknDialog::ConstructL( R_MEDIA_FILE_DIALOG_MENU );
+
+ if ( iMenuBar )
+ {
+ iMenuBar->SetContextMenuTitleResourceId(
+ R_MEDIA_FILE_DIALOG_CONTEXT_MENU );
+ }
+
+ // get previous title so it can be restored
+ iStatusPaneHandler = CStatusPaneHandler::NewL( iAvkonAppUi );
+ iStatusPaneHandler->StoreOriginalTitleL();
+
+ iMediaFileHandler = CMediaFileHandler::NewL();
+ iMediaFileHandler->SetObserver( this );
+
+ iState = CMediaFileDialogState::NewL();
+
+#ifndef RD_VIDEO_AS_RINGING_TONE
+ iState->HideRootFolder( EEFolderVideos, ETrue,
+ KNullDesC, KErrNotFound );
+
+ iMediaFileHandler->SetAttrL( CMediaFileList::EAttrExcludeFolder, CMediaFileList::EFolderVideos );
+#endif
+
+ iMFListHandler = CMFListHandler::NewL();
+ iMFListHandler->SetObserver( this );
+
+ iCaller = CMFActiveCaller::NewL( this );
+ iSearchCaller = CMFActiveCaller::NewL( this );
+
+ iAudioPreviewHandler = CMFAudioPreviewHandler::NewL();
+ iVideoPreviewHandler = CMFVideoPreviewHandler::NewL();
+
+ iAudioPreviewHandler->SetObserver( this );
+
+ iPopupNote = CAknInfoPopupNoteController::NewL();
+
+ iWaitNote = CMediaFileWaitNote::NewL( this );
+
+ if ( AknLayoutUtils::PenEnabled() )
+ {
+ User::LeaveIfError( iPeninputServer.Connect() );
+ iPeninputServer.AddPenUiActivationHandler( this, EPluginInputModeAll );
+ }
+
+ iProtectionHandler = CMFProtectionHandler::NewL();
+
+#ifdef _DEBUG
+ iTest = CMFDialogTest::NewL( this ); // test code
+#endif
+
+ FLOG( _L("CMediaFileDialog::ConstructL END") );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::ShowDialogL
+//
+// -----------------------------------------------------------------------------
+TBool CMediaFileDialog::ShowDialogL( TDes* aFileName, TInt* aNullItem,
+ TInt* aInfo, TDes* aDesInfo )
+ {
+ __ASSERT_ALWAYS( aFileName, Panic( KErrGeneral ) );
+ __ASSERT_ALWAYS( aNullItem, Panic( KErrGeneral ) );
+
+ iFileName = aFileName;
+
+ iNullItem = aNullItem;
+ *iNullItem = KErrNotFound;
+
+ iInfo = aInfo;
+ iDesInfo = aDesInfo;
+
+ TBool ret = ExecuteLD( R_MEDIA_FILE_DIALOG );
+
+ return ret;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::SetAttrL
+//
+// -----------------------------------------------------------------------------
+void CMediaFileDialog::SetAttrL( TInt aAttr, TInt aValue )
+ {
+ iAudioPreviewHandler->SetAttrL( aAttr, aValue );
+ iVideoPreviewHandler->SetAttrL( aAttr, aValue );
+ iMediaFileHandler->SetAttrL( aAttr, aValue );
+ iProtectionHandler->SetAttrL( aAttr, aValue );
+
+ if ( aAttr == CMediaFileList::EAttrExcludeFolder )
+ {
+ if ( aValue == CMediaFileList::EFolderDownload )
+ {
+ iState->HideRootFolder( EEFolderDownload, ETrue,
+ KNullDesC, KErrNotFound );
+ }
+ if ( aValue == CMediaFileList::EFolderVideos )
+ {
+ iState->HideRootFolder( EEFolderVideos, ETrue,
+ KNullDesC, KErrNotFound );
+ }
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::SetAttrL
+//
+// -----------------------------------------------------------------------------
+void CMediaFileDialog::SetAttrL( TInt aAttr, const TDesC& aValue )
+ {
+ iAudioPreviewHandler->SetAttrL( aAttr, aValue );
+ iVideoPreviewHandler->SetAttrL( aAttr, aValue );
+ iMediaFileHandler->SetAttrL( aAttr, aValue );
+ iProtectionHandler->SetAttrL( aAttr, aValue );
+
+ if ( aAttr == CMediaFileList::EAttrTitle )
+ {
+ TMFDialogUtil::StrCopy( iDialogTitle, aValue );
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::SetAttrL
+//
+// -----------------------------------------------------------------------------
+void CMediaFileDialog::SetAttrL( TInt aAttr, TAny* aValue )
+ {
+ iAudioPreviewHandler->SetAttrL( aAttr, aValue );
+ iVideoPreviewHandler->SetAttrL( aAttr, aValue );
+ iMediaFileHandler->SetAttrL( aAttr, aValue );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::SetNullItemL
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::SetNullItemL( const TDesC& aText,
+ const TDesC& aMediaFile,
+ TInt aMediaFileType, TInt aIconId )
+ {
+ TInt iconId = EEIconEmpty;
+ if ( aIconId == CMediaFileList::ENullItemIconDefaultTone )
+ {
+ iconId = EEIconTone;
+ }
+ else if ( aIconId == CMediaFileList::ENullItemIconOff )
+ {
+ iconId = EEIconNullItemOff;
+ }
+
+ TInt mediaType = CMediaFileList::EMediaFileTypeAudio;
+ if ( aMediaFileType == CMediaFileList::EMediaFileTypeVideo )
+ {
+ mediaType = CMediaFileList::EMediaFileTypeVideo;
+ }
+
+
+ if ( !iNullItemFileNameOne )
+ {
+ iNullItemFileNameOne = aMediaFile.AllocL();
+ iNullItemFileTypeOne = mediaType;
+
+ iState->EnableNullItemL( EEFolderNullItemOne, aText, iconId );
+ }
+ else if ( !iNullItemFileNameTwo )
+ {
+ iNullItemFileNameTwo = aMediaFile.AllocL();
+ iNullItemFileTypeTwo = mediaType;
+
+ iState->EnableNullItemL( EEFolderNullItemTwo, aText, iconId );
+ }
+ else
+ {
+ User::Leave( KErrNotSupported ); // two null items supported
+ }
+ }
+
+
+
+//------------------------------------------------------------------------------
+// CMediaFileDialog::ActivateL
+//
+// Called by system when dialog is activated.
+//------------------------------------------------------------------------------
+//
+void CMediaFileDialog::ActivateL()
+ {
+ CAknDialog::ActivateL();
+
+ // this cannot be in ConstructL which is executed before dialog is launched
+ iAvkonAppUi->AddToStackL( this );
+ AknFind::HandleFixedFindSizeChanged( this, iListBox, FindBox() );
+ DrawNow();
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::PreLayoutDynInitL
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::PreLayoutDynInitL()
+ {
+ const TInt KFindBoxLength = 20;
+
+ iListBox = (CAknSingleGraphicStyleListBox*) (ControlOrNull(1));
+ iListBox->DisableSingleClick(ETrue);
+ __ASSERT_ALWAYS( iListBox, TMFDialogUtil::Panic( KErrGeneral ) );
+
+ iListBox->Model()->SetItemTextArray( iMFListHandler );
+ iListBox->Model()->SetOwnershipType( ELbmDoesNotOwnItemArray );
+
+ iListBox->SetListBoxObserver( this );
+ iListBox->CreateScrollBarFrameL( ETrue );
+ iListBox->ScrollBarFrame()->SetScrollBarVisibilityL(
+ CEikScrollBarFrame::EOn, CEikScrollBarFrame::EAuto );
+
+ iListBox->SetContainerWindowL( *this );
+
+ SetIconsL();
+
+ iListBox->ItemDrawer()->ColumnData()->EnableMarqueeL( ETrue );
+
+
+ iState->Init();
+
+ if ( iDialogTitle.Length() > 0 )
+ {
+ iStatusPaneHandler->SetTitleL( iDialogTitle );
+ }
+ else
+ {
+ iStatusPaneHandler->SetTitleL( R_QTN_MEDIA_FILE_DIALOG_TITLE );
+ }
+ iStatusPaneHandler->SetNaviPaneTitleL( KNullDesC );
+
+
+ //
+ // create find box. NOTE: findbox functionality is quite complex and
+ // is implemented by copy pasting code from other apps.
+ //
+
+ CFindControl* control = ( CFindControl* )ControlOrNull( EFindControl );
+ if ( control )
+ {
+ CAknSearchField::TSearchFieldStyle flags = CAknSearchField::EFixed;
+ control->iFind = CAknSearchField::NewL(
+ *control, flags, 0, KFindBoxLength );
+ //control->iFind = searchField;
+ control->SetContainerWindowL( *this );
+ CEikEdwin& edwin = control->iFind->Editor();
+ control->iFind->AddAdaptiveSearchTextObserverL( this );
+ }
+
+ if ( FindBox() )
+ {
+ CAknFilteredTextListBoxModel* model =
+ STATIC_CAST( CAknFilteredTextListBoxModel*, iListBox->Model() );
+
+ FindBox()->MakeVisible( EFalse );
+ }
+
+
+ UpdateListBoxL();
+
+ DrawDeferred();
+ }
+
+
+//------------------------------------------------------------------------------
+// CMediaFileDialog::ProcessCommandL
+//
+// Handle commands from menu. NOTE: Current implemntation does not use menu.
+// Menu handling code is here for (possible) future use.
+//------------------------------------------------------------------------------
+//
+void CMediaFileDialog::ProcessCommandL( TInt aCommandId )
+ {
+ HideMenu();
+
+ switch (aCommandId)
+ {
+ case EAknCmdHelp:
+ {
+ break;
+ }
+
+ case EAknSoftkeySelect:
+ {
+ TBool ret = HandleOKL( EAttrSelect );
+ if ( ret )
+ {
+ TryExitL( EEikCmdExit );
+ }
+ break;
+ }
+
+ case EAknSoftkeyView:
+ {
+ PreviewL( CMediaFileList::EMediaFileTypeVideo );
+ break;
+ }
+ case EAknCmdOpen:
+ {
+ HandleOKL( EAttrOpen );
+ break;
+ }
+
+ case EAknCmdExit:
+ case EEikCmdExit:
+ {
+ // close dialog and exit calling application
+ iAvkonAppUi->ProcessCommandL( EAknCmdExit );
+ break;
+ }
+
+ default:
+ break;
+ }
+ }
+
+
+//------------------------------------------------------------------------------
+// CMediaFileDialog::OkToExitL
+//
+// Hanlde commands from cba.
+//------------------------------------------------------------------------------
+//
+TBool CMediaFileDialog::OkToExitL(TInt aButtonId)
+ {
+ if ( aButtonId == EEikBidCancel )
+ {
+ return ETrue; // close dialog
+ }
+
+ if ( aButtonId == EEikBidOk )
+ {
+ TBool ret = HandleOKL( EAttrSelect );
+ return ret;
+ }
+
+ if ( aButtonId == EAknSoftkeyBack )
+ {
+ if ( !HandleBackL() )
+ {
+#ifdef _DEBUG
+ // start test code
+ TInt currentIndex = CurrentItemListIndex();
+ if ( iState->FolderId( currentIndex ) == EEFolderRecordings )
+ {
+ if ( !iTest->TestL( 0 ) )
+ {
+ return ETrue; // test canceled
+ }
+ return EFalse; // test accepted
+ }
+ // end test code
+#endif
+
+ return ETrue; // Back pressed in top level folder
+ }
+
+ return EFalse; // leave dialog open
+ }
+
+ if ( aButtonId == EAknSoftkeyContextOptions )
+ {
+ ShowContextMenuL( R_MEDIA_FILE_DIALOG_CONTEXT_MENU );
+ return EFalse;
+ }
+
+ if ( aButtonId == EAknSoftkeyOpen )
+ {
+ TBool ret = HandleOKL( EAttrOpen );
+ return ret;
+ }
+
+ if ( aButtonId == EAknSoftkeySelect )
+ {
+ TBool ret = HandleOKL( EAttrSelect );
+ return ret;
+ }
+
+ if ( aButtonId == EAknSoftkeyView )
+ {
+ PreviewL( CMediaFileList::EMediaFileTypeVideo );
+ return EFalse;
+ }
+
+ if ( aButtonId == EAknSoftkeyEmpty )
+ {
+ return EFalse;
+ }
+
+ return CAknDialog::OkToExitL( aButtonId );
+ }
+
+
+// ----------------------------------------------------------------------------
+// CMediaFileDialog::OfferKeyEventL
+//
+// ----------------------------------------------------------------------------
+//
+TKeyResponse CMediaFileDialog::OfferKeyEventL(const TKeyEvent& aKeyEvent,
+ TEventCode aType)
+ {
+
+ iIsDoubleClicked = EFalse;
+ // must pass escape event to dialog - findbox and listbox "eat" escape events
+ TKeyResponse res = EKeyWasNotConsumed;
+ if ( aType == EEventKey && aKeyEvent.iCode == EKeyEscape )
+ {
+ res = CAknDialog::OfferKeyEventL( aKeyEvent, aType );
+ }
+ if ( res == EKeyWasConsumed )
+ {
+ return res;
+ }
+
+
+ TBool backSpace = EFalse;
+
+ if (aType == EEventKey)
+ {
+ switch (aKeyEvent.iCode)
+ {
+ case EKeyEnter:
+ {
+ break;
+ }
+ case EKeyUpArrow:
+ case EKeyDownArrow:
+ {
+ TInt itemCount = iListBox->Model()->NumberOfItems();
+ if ( itemCount == 1 )
+ {
+ PreviewL( CMediaFileList::EMediaFileTypeAudio );
+ }
+ break;
+ }
+
+ case EKeyLeftArrow:
+ {
+ if (FindBox() && FindBox()->IsVisible()
+ && FindBox()->TextLength() != 0)
+ {
+ FindBoxCursorMoveL( 0 );
+ res = EKeyWasConsumed;
+ }
+ else
+ {
+ HandleBackL();
+ return EKeyWasConsumed;
+ }
+ break;
+ }
+
+ case EKeyRightArrow:
+ {
+ if (FindBox() && FindBox()->IsVisible()
+ && FindBox()->TextLength() != 0)
+ {
+ FindBoxCursorMoveL( 1 );
+ res = EKeyWasConsumed;
+ }
+ else
+ {
+ HandleOKL( EAttrOpen );
+ return EKeyWasConsumed;
+ }
+ break;
+ }
+
+ case EKeyBackspace:
+ {
+ backSpace = ETrue;
+ break;
+ }
+
+ default:
+ {
+ break;
+ }
+ }
+
+ if ( FindBox() && FindBox()->IsVisible() )
+ {
+ res = FindBox()->OfferKeyEventL( aKeyEvent, aType );
+
+ if ( backSpace && FindBox()->TextLength() == 0 &&
+ ( iState->CurrentFolder() == EEFolderSearch ||
+ iState->CurrentFolder() == EEFolderSearchMusic ) && !iPeninputActive )
+ {
+ // user cleared search field - go back to main view
+ HandleBackL();
+ return EKeyWasConsumed;
+ }
+ }
+ }
+
+
+ if ( res == EKeyWasNotConsumed )
+ {
+ res = CAknDialog::OfferKeyEventL( aKeyEvent, aType);
+ }
+ return res;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::FindBoxCursorMoveL( TInt aType )
+//
+// NOTE: This function is used to move the cursor of the find box.
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::FindBoxCursorMoveL( TInt aType )
+ {
+ if ( FindBox() && FindBox()->IsVisible() )
+ {
+ TInt pos = FindBox()->Editor().CursorPos();
+ TInt textLength = FindBox()->Editor().TextLength();
+ if ( aType == 0 )//left
+ {
+ pos = pos - 1;
+ if ( pos < 0 )
+ {
+ pos = textLength;
+ }
+ }
+ else if ( aType == 1 )
+ {
+ pos = pos + 1;
+ if ( pos > textLength )
+ {
+ pos = 0;
+ }
+ }
+ else
+ {
+ pos = textLength;
+ }
+ FindBox()->Editor().SetCursorPosL( pos ,EFalse );
+ }
+ }
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::SetSizeAndPosition (from CAknDialog)
+//
+// NOTE: This code is copy paste from elsewhere.
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::SetSizeAndPosition( const TSize& /*aSize*/ )
+ {
+ TRect mainPane;
+ AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, mainPane );
+
+ SetRect( mainPane );
+
+ if ( FindBox() && FindBox()->IsVisible() )
+ {
+ AknFind::HandleFixedFindSizeChanged( this, iListBox, FindBox() );
+ }
+
+ Line( ESelectionListControl)->SetRect( iListBox->Rect() );
+ if ( FindBox() )
+ {
+ Line( EFindControl )->SetRect( iListBox->Rect() );
+ }
+ }
+
+
+// ----------------------------------------------------------------------------
+// CMediaFileDialog::HandleResourceChange
+//
+// ----------------------------------------------------------------------------
+//
+void CMediaFileDialog::HandleResourceChange(TInt aType)
+ {
+ if ( aType == KEikDynamicLayoutVariantSwitch )
+ {
+ // handle change in layout orientation
+ CAknDialog::HandleResourceChange( aType );
+ if ( FindBox() && FindBox()->IsVisible() )
+ {
+ AknFind::HandleFixedFindSizeChanged( this, iListBox, FindBox() );
+ }
+ return;
+ }
+
+ if (aType == KAknsMessageSkinChange)
+ {
+ TRAP_IGNORE( SetIconsL() );
+ }
+
+ CCoeControl::HandleResourceChange( aType );
+ }
+
+
+//------------------------------------------------------------------------------
+// CMediaFileDialog::DynInitMenuPaneL
+//
+// Called by system before menu is shown. NOTE: Menu currently not used.
+//------------------------------------------------------------------------------
+//
+void CMediaFileDialog::DynInitMenuPaneL(TInt aResourceID, CEikMenuPane* aMenuPane )
+ {
+ TInt menu1 = R_MEDIA_FILE_DIALOG_MENU_PANE;
+ TInt menu2 = R_MEDIA_FILE_DIALOG_CONTEXT_MENU_PANE;
+
+ if ( aResourceID != menu1 && aResourceID != menu2 )
+ {
+ return; // not one of our menus
+ }
+
+ TInt itemCount = iListBox->Model()->NumberOfItems();
+ TInt currentIndex = iListBox->CurrentItemIndex();
+ TInt folderId = iState->FolderId( currentIndex );
+ TInt currentFolderId = iState->CurrentFolder();
+
+
+ // context menu only used in video folder
+ if ( aResourceID == R_MEDIA_FILE_DIALOG_CONTEXT_MENU_PANE )
+ {
+ if ( itemCount == 0 )
+ {
+ // folder is empty
+ DeleteMenuItem( aMenuPane, EAknSoftkeySelect );
+ DeleteMenuItem( aMenuPane, EAknSoftkeyView );
+ }
+ return;
+ }
+
+
+ if ( itemCount == 0 )
+ {
+ // list has no items
+ DeleteMenuItem( aMenuPane, EAknCmdOpen );
+ DeleteMenuItem( aMenuPane, EAknSoftkeySelect );
+ DeleteMenuItem( aMenuPane, EAknSoftkeyView );
+ return;
+ }
+
+ if ( folderId == EEFolderDownload || folderId == EEFolderNullItemOne ||
+ folderId == EEFolderNullItemTwo )
+ {
+ // selected item is null item
+ DeleteMenuItem( aMenuPane, EAknCmdOpen );
+ DeleteMenuItem( aMenuPane, EAknSoftkeyView );
+ }
+ else if ( folderId != KErrNotFound )
+ {
+ // selected item is folder
+ DeleteMenuItem( aMenuPane, EAknSoftkeySelect );
+ DeleteMenuItem( aMenuPane, EAknSoftkeyView );
+ }
+ else
+ {
+ // selected item is file
+ if ( iState->CurrentFolder() == EEFolderVideos )
+ {
+ DeleteMenuItem( aMenuPane, EAknCmdOpen );
+ }
+ else if ( iState->CurrentFolder() == EEFolderSearch )
+ {
+ DeleteMenuItem( aMenuPane, EAknCmdOpen );
+
+ if ( !IsVideoFile( currentIndex ) )
+ {
+ DeleteMenuItem( aMenuPane, EAknSoftkeyView );
+ }
+ }
+ else
+ {
+ DeleteMenuItem( aMenuPane, EAknCmdOpen );
+ DeleteMenuItem( aMenuPane, EAknSoftkeyView );
+ }
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CMediaFileDialog::CountComponentControls
+//
+// Gets the number of controls contained in a compound control.
+// ---------------------------------------------------------------------------
+//
+TInt CMediaFileDialog::CountComponentControls() const
+ {
+ TInt newitems = 0;
+ if ( FindBox() )
+ {
+ newitems++;
+ }
+ return CAknDialog::CountComponentControls() + newitems;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CMediaFileDialog::CountComponentControls
+//
+// ---------------------------------------------------------------------------
+//
+CCoeControl* CMediaFileDialog::ComponentControl( TInt aIndex ) const
+ {
+ if ( aIndex == CAknDialog::CountComponentControls() )
+ {
+ return FindBox();
+ }
+ return CAknDialog::ComponentControl( aIndex );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::FindBox
+//
+// -----------------------------------------------------------------------------
+//
+CAknSearchField* CMediaFileDialog::FindBox() const
+ {
+ CFindControl* control = ( CFindControl* )ControlOrNull( EFindControl );
+ if ( control )
+ {
+ return control->iFind;
+ }
+ else
+ {
+ return NULL;
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CMediaFileDialog::ResetFindBoxL
+//
+// ---------------------------------------------------------------------------
+//
+void CMediaFileDialog::ResetFindBoxL()
+ {
+ if ( !FindBox() )
+ {
+ return;
+ }
+
+ CAknFilteredTextListBoxModel* model =
+ STATIC_CAST( CAknFilteredTextListBoxModel*, iListBox->Model() );
+ CAknListBoxFilterItems* filter = model->Filter();
+ TInt currentFolder = iState->CurrentFolder();
+
+ // reset find box
+ if ( filter )
+ {
+ filter->ResetFilteringL();
+ filter->SetObserver( NULL );
+ model->RemoveFilter();
+
+ // CreateFilterL sets CAknSearchField to observe filter
+ // (CAknListBoxFilterItems) but RemoveFilter does not remove observer
+ FindBox()->SetObserver( NULL );
+ }
+
+ if (FindBox()->TextLength() > 0 && (currentFolder != EEFolderSearch
+ && currentFolder != EEFolderSearchMusic))
+ {
+ FindBox()->SetSearchTextL( KNullDesC );
+ }
+
+
+ // show/hide find box
+ if ( iState->FindBoxNeeded() )
+ {
+ if ( currentFolder != EEFolderSearch &&
+ currentFolder != EEFolderSearchMusic &&
+ currentFolder != EEFolderRoot &&
+ currentFolder != EEFolderMusic )
+ {
+ // normal find only finds matches from listbox item texts
+ model->CreateFilterL( iListBox, FindBox() );
+ filter = model->Filter();
+ filter->ResetFilteringL();
+ filter->SetObserver( this ); // MCoeControlObserver
+ }
+ else
+ {
+ // search and root folders have custom find that makes
+ // database search
+ FindBox()->SetObserver( this ); // MCoeControlObserver
+ }
+// if ( currentFolder == EEFolderSearch ||
+// currentFolder == EEFolderSearchMusic )
+// {
+// FindBox()->SetSearchTextL( iSearchText );
+// }
+
+ FindBox()->MakeVisible( ETrue );
+ }
+ else
+ {
+ FindBox()->MakeVisible( EFalse );
+ }
+
+ TSize size;
+ SetSizeAndPosition( size );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::CreateCustomControlL (from CAknDialog)
+//
+// Create find control.
+// -----------------------------------------------------------------------------
+//
+SEikControlInfo CMediaFileDialog::CreateCustomControlL( TInt aControlType )
+ {
+ if ( aControlType != EAknCtSelectionListPopupFind &&
+ aControlType != EAknCtSelectionListFixedFind )
+ {
+ SEikControlInfo info;
+ info.iControl = NULL;
+ info.iFlags = 0;
+ info.iTrailerTextId = 0;
+ return info;
+ }
+
+ CCoeControl* findControl = NULL;
+ findControl = new (ELeave) CFindControl;
+
+ SEikControlInfo info;
+ info.iControl = findControl;
+ info.iFlags = 0;
+ info.iTrailerTextId = 0;
+ return info;
+ }
+
+
+// ----------------------------------------------------------------------------
+// CMediaFileDialog::SetIconsL
+//
+// ----------------------------------------------------------------------------
+//
+void CMediaFileDialog::SetIconsL()
+ {
+ _LIT( KBitmapFile, "mediafilelist.mbm" );
+
+
+ if ( !iListBox )
+ {
+ return;
+ }
+
+ TMFDialogUtil::SetIconFileNameL( KBitmapFile, iIconFileName );
+
+ CArrayPtr<CGulIcon>* icons = new (ELeave) CAknIconArray(1);
+ CleanupStack::PushL( icons );
+
+
+ //
+ // NOTE: append order must match TMediaFileListIcons
+ //
+
+ // music item icon
+ icons->AppendL( IconL( KAknsIIDQgnIndiAiNtMusic, iIconFileName,
+ EMbmMediafilelistQgn_indi_ai_nt_music,
+ EMbmMediafilelistQgn_indi_ai_nt_music_mask ) );
+
+ // tone item icon, default tone icon
+ icons->AppendL( IconL( KAknsIIDQgnPropMupAudio, iIconFileName,
+ EMbmMediafilelistQgn_prop_mup_audio,
+ EMbmMediafilelistQgn_prop_mup_audio_mask ) );
+
+ // video item icon
+ icons->AppendL( IconL( KAknsIIDQgnPropFmgrFileVideo, iIconFileName,
+ EMbmMediafilelistQgn_prop_fmgr_file_video,
+ EMbmMediafilelistQgn_prop_fmgr_file_video_mask ) );
+
+ // recording item icon
+ icons->AppendL( IconL( KAknsIIDQgnPropFmgrFileVoicerec, iIconFileName,
+ EMbmMediafilelistQgn_prop_fmgr_file_voicerec,
+ EMbmMediafilelistQgn_prop_fmgr_file_voicerec_mask ) );
+
+ // artist icon
+ icons->AppendL( IconL( KAknsIIDQgnPropMupArtist, iIconFileName,
+ EMbmMediafilelistQgn_prop_mup_artist,
+ EMbmMediafilelistQgn_prop_mup_artist_mask ) );
+
+ // album icon
+ icons->AppendL( IconL( KAknsIIDQgnPropMupAlbum, iIconFileName,
+ EMbmMediafilelistQgn_prop_mup_album,
+ EMbmMediafilelistQgn_prop_mup_album_mask ) );
+
+ // genre icon
+ icons->AppendL( IconL( KAknsIIDQgnPropMupGenre, iIconFileName,
+ EMbmMediafilelistQgn_prop_mup_genre,
+ EMbmMediafilelistQgn_prop_mup_genre_mask ) );
+
+ // composer icon
+ icons->AppendL( IconL( KAknsIIDQgnPropMupComposer, iIconFileName,
+ EMbmMediafilelistQgn_prop_mup_composer,
+ EMbmMediafilelistQgn_prop_mup_composer_mask ) );
+
+ // folder icon (tones, music, videos, recordings, all music, artist,
+ // album, genre, composer, artist all)
+ icons->AppendL( IconL( KAknsIIDQgnPropFolderSmall, iIconFileName,
+ EMbmMediafilelistQgn_prop_folder_small,
+ EMbmMediafilelistQgn_prop_folder_small_mask ) );
+
+ // unknown folder icon
+ icons->AppendL( IconL( KAknsIIDQgnPropMceUnknownRead, iIconFileName,
+ EMbmMediafilelistQgn_prop_mce_unknown_read,
+ EMbmMediafilelistQgn_prop_mce_unknown_read ) );
+
+ // download item icon (null item)
+ icons->AppendL( IconL( KAknsIIDQgnPropLinkEmbdSmall, iIconFileName,
+ EMbmMediafilelistQgn_prop_link_embd_small,
+ EMbmMediafilelistQgn_prop_link_embd_small_mask ) );
+
+ // off item icon (null item)
+ icons->AppendL( IconL( KAknsIIDQgnPropSmlSyncOff, iIconFileName,
+ EMbmMediafilelistQgn_prop_sml_sync_off,
+ EMbmMediafilelistQgn_prop_sml_sync_off_mask ) );
+
+ // memory card icon
+ icons->AppendL( IconL( KAknsIIDQgnIndiMmcAdd, iIconFileName,
+ EMbmMediafilelistQgn_indi_mmc_add,
+ EMbmMediafilelistQgn_indi_mmc_add_mask, EAknsCIQsnIconColorsCG13 ) );
+
+ // mass storage icon
+ icons->AppendL( IconL( KAknsIIDQgnPropLinkEmbdSmall, iIconFileName,
+ EMbmMediafilelistQgn_indi_fmgr_ms_add,
+ EMbmMediafilelistQgn_indi_fmgr_ms_add_mask,EAknsCIQsnIconColorsCG13 ) );
+
+ // empty icon
+ icons->AppendL( IconL( KAknsIIDQgnPropEmpty, KAvkonBitmapFile,
+ EMbmAvkonQgn_prop_empty,
+ EMbmAvkonQgn_prop_empty_mask ) );
+
+ // delete old icons
+ CArrayPtr<CGulIcon>* arr = iListBox->ItemDrawer()->ColumnData()->IconArray();
+ if ( arr )
+ {
+ arr->ResetAndDestroy();
+ delete arr;
+ arr = NULL;
+ }
+
+ iListBox->ItemDrawer()->ColumnData()->SetIconArray( icons );
+ CleanupStack::Pop( icons );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::IconL
+//
+// -----------------------------------------------------------------------------
+//
+CGulIcon* CMediaFileDialog::IconL(TAknsItemID aId, const TDesC& aFileName,
+ TInt aFileIndex, TInt aFileMaskIndex)
+ {
+ CGulIcon* icon = AknsUtils::CreateGulIconL(AknsUtils::SkinInstance(), aId,
+ aFileName, aFileIndex, aFileMaskIndex);
+ return icon;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::IconL
+// For MMC icon and Mass Storage icon
+// -----------------------------------------------------------------------------
+//
+CGulIcon* CMediaFileDialog::IconL(TAknsItemID aId, const TDesC& aFileName,
+ TInt aFileIndex, TInt aFileMaskIndex, TAknsQsnIconColorsIndex colorIndex)
+ {
+ TRgb defaultColour(KRgbBlack);
+ CFbsBitmap* bmap = NULL;
+ CFbsBitmap* mask = NULL;
+
+ AknsUtils::GetCachedColor(AknsUtils::SkinInstance(), defaultColour, KAknsIIDQsnIconColors,
+ colorIndex);
+ AknsUtils::CreateColorIconLC(AknsUtils::SkinInstance(), KAknsIIDQgnIndiMmcAdd,
+ KAknsIIDQsnIconColors, colorIndex, bmap, mask,
+ aFileName, aFileIndex, aFileMaskIndex, defaultColour);
+
+ CGulIcon* icon = CGulIcon::NewL(bmap, mask);
+ icon->SetBitmapsOwnedExternally(EFalse);
+ CleanupStack::Pop(2);
+ return icon;
+ }
+
+
+// ----------------------------------------------------------------------------
+// CMediaFileDialog::ShowContextMenuL
+//
+// ----------------------------------------------------------------------------
+//
+void CMediaFileDialog::ShowContextMenuL( TInt /*aResource*/ )
+ {
+ // Switch to Context specific options menu,
+ if ( iMenuBar )
+ {
+ TRAP_IGNORE( iMenuBar->TryDisplayContextMenuBarL() );
+ }
+ }
+
+
+//------------------------------------------------------------------------------
+// CMediaFileDialog::HandleBackL
+//
+//------------------------------------------------------------------------------
+//
+TBool CMediaFileDialog::HandleBackL()
+ {
+ TInt err = KErrNone;
+ TBool ret = ETrue;
+
+ TRAP( err, ret = DoHandleBackL() );
+
+ if ( err != KErrNone )
+ {
+ FLOG( _L("### CMediaFileDialog::HandleBackL (%d) ###"), err );
+
+ ResetDialogL( err );
+ return ETrue;
+ }
+
+ return ret;
+ }
+
+
+//------------------------------------------------------------------------------
+// CMediaFileDialog::DoHandleBackL
+//
+//------------------------------------------------------------------------------
+//
+TBool CMediaFileDialog::DoHandleBackL()
+ {
+ if ( iState->CurrentFolder() == EEFolderRoot )
+ {
+ // return EFalse only when called from root folder
+ return EFalse;
+ }
+
+ if ( !iMediaFileHandler->QueryReady() )
+ {
+ FLOG( _L("### CMediaFileDialog::DoHandleBackL: query in progress ###") );
+ return ETrue; // query in progress
+ }
+
+ TInt folderId = iState->NextFolderUp();
+ TInt currentIndex = CurrentItemListIndex();
+
+ iState->SetQueryInfo( folderId, KNullDesC, currentIndex, EEQueryUp );
+ QueryL( folderId );
+
+ return ETrue;
+ }
+
+
+//------------------------------------------------------------------------------
+// CMediaFileDialog::HandleOKL
+//
+//------------------------------------------------------------------------------
+//
+TBool CMediaFileDialog::HandleOKL( TInt aAttr )
+ {
+ TInt err = KErrNone;
+ TBool ret = EFalse;
+
+ TRAP( err, ret = DoHandleOKL( aAttr ) );
+
+ if ( err != KErrNone )
+ {
+ FLOG( _L("### CMediaFileDialog::HandleOKL (%d) ###"), err );
+
+ ResetDialogL( err );
+ return EFalse;
+ }
+
+ return ret;
+ }
+
+
+//------------------------------------------------------------------------------
+// CMediaFileDialog::DoHandleOKL
+//
+// Selects file or opens folder. If file is selected (ie dialog can
+// be closed) return value is ETrue.
+//------------------------------------------------------------------------------
+//
+TBool CMediaFileDialog::DoHandleOKL( TInt aAttr )
+ {
+ if ( !iMediaFileHandler->QueryReady() )
+ {
+ FLOG( _L("### CMediaFileDialog::DoHandleOKL: query in progress ###") );
+ return EFalse; // query in progress
+ }
+
+ TInt currentIndex = CurrentItemListIndex();
+ if ( currentIndex == KErrNotFound )
+ {
+ return EFalse; // empty folder
+ }
+
+ TBool isPersistent = EFalse;
+ TInt iconId = EEIconEmpty;
+ TInt folderId = KErrNotFound;
+ iState->GetFolderInfo( currentIndex, folderId, iBuf,
+ isPersistent, iconId );
+
+ if ( folderId == EEFolderDownload || folderId == EEFolderNullItemOne ||
+ folderId == EEFolderNullItemTwo || folderId == KErrNotFound )
+ {
+ if ( aAttr == EAttrOpen )
+ {
+ return EFalse; // these can only be selected, not opened
+ }
+ }
+
+
+ if ( folderId == EEFolderDownload )
+ {
+ *iNullItem = 0;
+ // user selected 'Download' item - launch browser
+ CWebBrowserLauncher* launcher = CWebBrowserLauncher::NewLC();
+ launcher->LaunchBrowserL();
+ CleanupStack::PopAndDestroy( launcher );
+ return EFalse;
+ }
+
+ if ( folderId == EEFolderNullItemOne )
+ {
+ if ( iNullItemFileNameOne )
+ {
+ TMFDialogUtil::StrCopy( *iFileName, *iNullItemFileNameOne );
+ }
+ *iNullItem = 1;
+ return ETrue;
+ }
+
+ if ( folderId == EEFolderNullItemTwo )
+ {
+ if ( iNullItemFileNameTwo )
+ {
+ TMFDialogUtil::StrCopy( *iFileName, *iNullItemFileNameTwo );
+ }
+ *iNullItem = 2;
+ return ETrue;
+ }
+
+ if ( folderId == KErrNotFound )
+ {
+ // user has selected some media file
+ GetSelectedItemFileName( currentIndex, iBuf );
+
+ // protection check not done when item is double checked
+ // if ( aAttr != EAttrDoubleClicked )
+ if (!ifilevalid)
+ {
+ iFileisvalid = iProtectionHandler->IsFileValid( iBuf,
+ CMFProtectionHandler::ESelect );
+ ifilevalid=ETrue;
+ }
+
+ if ( !iFileisvalid)
+ {
+ ifilevalid=EFalse;
+ }
+ if ( iFileisvalid )
+ {
+ TMFDialogUtil::StrCopy( *iFileName, iBuf );
+ }
+
+ return iFileisvalid; // ret is ETrue is selected file's drm is OK
+ }
+
+
+ if ( folderId != KErrNotFound && aAttr != EAttrSelect )
+ {
+ // Request vibra feedback when open the folder.
+ MTouchFeedback* feedback = MTouchFeedback::Instance();
+ if ( feedback )
+ {
+ TTouchLogicalFeedback logicalType = ETouchFeedbackList;
+ TTouchFeedbackType type = ETouchFeedbackVibra;
+ feedback->InstantFeedback( this, logicalType, type, TPointerEvent() );
+ }
+
+ iBuf = KNullDesC;
+ // selected list item is folder
+ if ( !isPersistent )
+ {
+ // read non-persistent folder text from database
+ GetListItemText( currentIndex, iBuf );
+ }
+
+ iState->SetQueryInfo( folderId, iBuf, currentIndex, EEQueryDown );
+ QueryL( folderId );
+ }
+
+ return EFalse;
+ }
+
+
+//------------------------------------------------------------------------------
+// CMediaFileDialog::SearchL
+//
+//------------------------------------------------------------------------------
+//
+void CMediaFileDialog::SearchL()
+ {
+ TInt err = KErrNone;
+
+ TRAP( err, DoSearchL() );
+
+ if ( err != KErrNone )
+ {
+ ResetDialogL( err );
+ }
+ }
+
+
+//------------------------------------------------------------------------------
+// CMediaFileDialog::DoSearchL
+//
+//------------------------------------------------------------------------------
+//
+void CMediaFileDialog::DoSearchL()
+ {
+ if ( !FindBox() )
+ {
+ return;
+ }
+
+ if ( iPeninputActive)
+ {
+ return;
+ }
+ if ( !iMediaFileHandler->QueryReady() )
+ {
+ FLOG( _L("### CMediaFileDialog::DoSearchL: query in progress ###") );
+ return; // query in progress
+ }
+
+ TInt currentFolder = iState->CurrentFolder();
+
+ if ( FindBox()->TextLength() == 0 )
+ {
+ return;
+ }
+ FindBox()->GetSearchText( iSearchText );
+
+ _LIT(KSpecialChar, "%");
+ _LIT(KReplaceChar, "\\%" );
+ TBuf<10> buf;
+ buf.Copy( KSpecialChar );
+ TInt position = iSearchText.FindF( buf );
+ if ( position != KErrNotFound )
+ {
+ buf.Copy( KReplaceChar );
+ iSearchText.Replace( position,1,buf );
+ }
+
+
+ if ( currentFolder == EEFolderRoot || currentFolder == EEFolderSearch )
+ {
+ TInt currentIndex = iListBox->CurrentItemIndex();
+ iState->SetQueryInfo( EEFolderSearch, KNullDesC, currentIndex, EEQueryDown );
+
+ QueryL( EEFolderSearch );
+ }
+ else if ( currentFolder == EEFolderMusic || currentFolder == EEFolderSearchMusic )
+ {
+ TInt currentIndex = iListBox->CurrentItemIndex();
+ iState->SetQueryInfo( EEFolderSearchMusic, KNullDesC, currentIndex, EEQueryDown );
+
+ QueryL( EEFolderSearchMusic );
+ }
+ }
+
+
+//------------------------------------------------------------------------------
+// CMediaFileDialog::ResetDialogL
+//
+//------------------------------------------------------------------------------
+//
+void CMediaFileDialog::ResetDialogL( TInt aError)
+ {
+ iMediaFileHandler->EnableObserverCall( EFalse );
+ iMediaFileHandler->CancelQuery();
+ iMediaFileHandler->EnableObserverCall( ETrue );
+
+ iState->Init();
+ UpdateListBoxL();
+
+ if ( aError != KErrNone )
+ {
+ ShowErrorNoteL( aError );
+ }
+ }
+
+
+//------------------------------------------------------------------------------
+// CMediaFileDialog::QueryL
+//
+//------------------------------------------------------------------------------
+//
+void CMediaFileDialog::QueryL( TInt aFolderId, TBool aDatabaseChanged )
+ {
+ if ( !iMediaFileHandler->QueryReady() || !iDatabaseOpen )
+ {
+ FLOG( _L("### CMediaFileDialog::QueryL: query in progress ###") );
+ return;
+ }
+
+ iMediaFileHandler->EnableObserverCall( ETrue );
+
+ TInt folderId = aFolderId;
+
+ iMediaFileHandler->SetQueryId( folderId );
+
+ if ( folderId == EEFolderAllMusic )
+ {
+ iMediaFileHandler->QueryMusicL( 0 );
+ }
+
+ else if ( folderId == EEFolderVideos )
+ {
+ iMediaFileHandler->QueryVideosL( 0 );
+ }
+
+ else if ( folderId == EEFolderArtistRoot ||
+ folderId == EEFolderAlbumRoot ||
+ folderId == EEFolderGenreRoot ||
+ folderId == EEFolderComposerRoot )
+ {
+ if ( iState->UnknownCount( folderId ) == KErrNotFound )
+ {
+ TInt attr = MapAttribute( folderId );
+ iMediaFileHandler->QueryMusicUnknownCountL( attr );
+ }
+ else
+ {
+ TInt attr = MapAttribute( folderId );
+ iMediaFileHandler->QueryAttributeValuesL( attr );
+ }
+ }
+
+ else if ( folderId == EEFolderAlbum || folderId == EEFolderGenre ||
+ folderId == EEFolderComposer )
+ {
+ TInt attr = MapAttribute( folderId );
+ iState->GetText( folderId, iBuf );
+ iMediaFileHandler->QueryMusicL( attr, iBuf );
+ }
+
+ else if ( folderId == EEFolderArtistUnknown || folderId == EEFolderAlbumUnknown ||
+ folderId == EEFolderGenreUnknown ||folderId == EEFolderComposerUnknown )
+ {
+ TInt attr = MapAttribute( folderId );
+ iMediaFileHandler->QueryMusicUnknownL( attr );
+ }
+
+ else if ( folderId == EEFolderArtist )
+ {
+ iState->GetText( EEFolderArtist, iBuf );
+ iMediaFileHandler->QueryArtistL( CMediaFileHandler::EQueryArtist,
+ iBuf, KNullDesC, aDatabaseChanged );
+ }
+
+ else if ( folderId == EEFolderArtistAll )
+ {
+ iState->GetText( EEFolderArtist, iBuf );
+ iMediaFileHandler->QueryArtistL( CMediaFileHandler::EQueryArtistAll,
+ iBuf, KNullDesC, aDatabaseChanged );
+ }
+
+ else if ( folderId == EEFolderArtistAlbum )
+ {
+ TBuf<KBufSize128> buf;
+ iState->GetText( EEFolderArtistAlbum, buf );
+ iState->GetText( EEFolderArtist, iBuf );
+ iMediaFileHandler->QueryArtistL( CMediaFileHandler::EQueryArtistAlbum,
+ iBuf, buf, aDatabaseChanged );
+ }
+
+ else if ( folderId == EEFolderArtistAlbumUnknown )
+ {
+ iState->GetText( EEFolderArtist, iBuf );
+ iMediaFileHandler->QueryArtistL( CMediaFileHandler::EQueryArtistUnknown,
+ iBuf, KNullDesC, aDatabaseChanged );
+ }
+
+ else if ( folderId == EEFolderTones )
+ {
+ //iMediaFileHandler->QueryTonesL( 0 );
+ iMediaFileHandler->QueryDefaultTonesL( 0 );
+ ShowWaitNoteL( EFalse );
+ }
+
+ else if ( folderId == EEFolderRecordings )
+ {
+ iMediaFileHandler->QueryRecordingsL( 0 );
+ }
+
+ else if ( folderId == EEFolderSearch )
+ {
+ if ( iSearchText.Length() > 0 )
+ {
+ iMediaFileHandler->SearchL( iSearchText );
+ }
+ else
+ {
+ iMediaFileHandler->QueryEmptyL();
+ }
+ }
+ else if ( folderId == EEFolderSearchMusic )
+ {
+ if ( iSearchText.Length() > 0 )
+ {
+ iMediaFileHandler->SearchAudioL( iSearchText );
+ }
+ else
+ {
+ iMediaFileHandler->QueryEmptyL();
+ }
+ }
+ else
+ {
+ // make empty query
+ iMediaFileHandler->QueryEmptyL();
+ }
+
+ if ( !iMediaFileHandler->QueryReady()
+ && aFolderId != EEFolderRoot && aFolderId != EEFolderMusic )
+ {
+ // query is running - show wait note with delay. wait note is
+ // removed in HandleMFEventL
+ ShowWaitNoteL( aDatabaseChanged );
+ }
+
+#ifdef _DEBUG
+ iTest->SetTime();
+#endif
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::MapAttribute
+//
+// -----------------------------------------------------------------------------
+//
+TInt CMediaFileDialog::MapAttribute( TInt aFolderId )
+ {
+ TInt attr = KErrNotFound;
+
+ switch ( aFolderId )
+ {
+ case EEFolderArtistRoot:
+ case EEFolderArtist:
+ case EEFolderArtistUnknown:
+ {
+ attr = CMediaFileHandler::EAttrArtist;
+ break;
+ }
+ case EEFolderAlbumRoot:
+ case EEFolderAlbum:
+ case EEFolderAlbumUnknown:
+ {
+ attr = CMediaFileHandler::EAttrAlbum;
+ break;
+ }
+ case EEFolderGenreRoot:
+ case EEFolderGenre:
+ case EEFolderGenreUnknown:
+ {
+ attr = CMediaFileHandler::EAttrGenre;
+ break;
+ }
+ case EEFolderComposerRoot:
+ case EEFolderComposer:
+ case EEFolderComposerUnknown:
+ {
+ attr = CMediaFileHandler::EAttrComposer;
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+
+ return attr;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::ShowDetailsPopupL
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::ShowDetailsPopupL()
+ {
+ if ( !iMediaFileHandler->QueryReady() )
+ {
+ return; // query in progress
+ }
+
+ TInt currentIndex = CurrentItemListIndex();
+ TInt folderId = iState->CurrentFolder();
+
+ if ( folderId != EEFolderSearch && folderId != EEFolderSearchMusic )
+ {
+ return;
+ }
+ if ( currentIndex < 0 )
+ {
+ return;
+ }
+
+ TInt id = iMediaFileHandler->Attribute( currentIndex,
+ CMediaFileHandler::EAttrMediaFileId,
+ iState->CurrentFolder() );
+ if ( id == KErrNotFound )
+ {
+ return;
+ }
+
+ TInt mediaType = iMediaFileHandler->Attribute( currentIndex,
+ CMediaFileHandler::EAttrMediaType,
+ iState->CurrentFolder() );
+
+ TInt storageType = iMediaFileHandler->Attribute( currentIndex,
+ CMediaFileHandler::EAttrStorageType,
+ iState->CurrentFolder() );
+
+ CMediaFileData* data = NULL;
+
+ if ( storageType == CMediaFileHandler::ERomStorage )
+ {
+ if ( mediaType == CMediaFileHandler::EMediaTypeTone )
+ {
+ data = iMediaFileHandler->RomMediaFileDataL( id , CMediaFileHandler::EMediaTypeTone );
+ }
+ if ( mediaType == CMediaFileHandler::EMediaTypeVideo )
+ {
+ data = iMediaFileHandler->RomMediaFileDataL( id , CMediaFileHandler::EMediaTypeVideo );
+ }
+ }
+ else
+ {
+ data = iMediaFileHandler->ReadMediaFileDataL( id );
+ }
+
+ CleanupStack::PushL( data );
+ if ( data )
+ {
+ GetPopupText( data, iPopupText );
+ }
+
+ CleanupStack::PopAndDestroy( data );
+
+ if ( iPopupText.Length() > 0 )
+ {
+ ShowPopupNoteL( iPopupText );
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::GetPopupText
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::GetPopupText( CMediaFileData* aData, TDes& aText )
+ {
+ TBuf<KBufSize64> searchText;
+ TBuf<KBufSize64> attributeName;
+
+ aText = KNullDesC;
+
+ if ( FindBox()->TextLength() >= KBufSize64 )
+ {
+ return;
+ }
+ FindBox()->GetSearchText( searchText );
+
+ aData->GetAttr( CMediaFileHandler::EAttrSongName, aText );
+ if ( MatchFound( aText, searchText ) )
+ {
+ aText = KNullDesC;
+ return;
+ }
+
+ aData->GetAttr( CMediaFileHandler::EAttrArtist, aText );
+ if ( MatchFound( aText, searchText ) )
+ {
+ StringLoader::Load( attributeName, R_QTN_PREVIEW_POPUP_ARTIST );
+ aText.Insert( 0, attributeName );
+ return;
+ }
+
+ aData->GetAttr( CMediaFileHandler::EAttrAlbum, aText );
+ if ( MatchFound( aText, searchText ) )
+ {
+ StringLoader::Load( attributeName, R_QTN_PREVIEW_POPUP_ALBUM );
+ aText.Insert( 0, attributeName );
+ return;
+ }
+
+ aData->GetAttr( CMediaFileHandler::EAttrGenre, aText );
+ if ( MatchFound( aText, searchText ) )
+ {
+ StringLoader::Load( attributeName, R_QTN_PREVIEW_POPUP_GENRE );
+ aText.Insert( 0, attributeName );
+ return;
+ }
+
+ aData->GetAttr( CMediaFileHandler::EAttrComposer, aText );
+ if ( MatchFound( aText, searchText ) )
+ {
+ StringLoader::Load( attributeName, R_QTN_PREVIEW_POPUP_COMPOSER );
+ aText.Insert( 0, attributeName );
+ return;
+ }
+
+ aText = KNullDesC;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::MatchFound
+//
+// -----------------------------------------------------------------------------
+//
+TBool CMediaFileDialog::MatchFound( const TDesC& aAttribute,
+ const TDesC& aText )
+ {
+ _LIT( KSpace, " " );
+
+ if ( aText.Length() >= KBufSize64 )
+ {
+ return EFalse; // too long search text
+ }
+
+ if ( aAttribute.FindC( aText ) == 0 )
+ {
+ // match found from the beginning of the first word
+ return ETrue;
+ }
+
+ TBuf<KBufSize64> buf;
+ buf = aText;
+ buf.Insert( 0, KSpace );
+
+ if ( aAttribute.FindC( buf ) != KErrNotFound )
+ {
+ // match found from the beginning of the word
+ return ETrue;
+ }
+
+ return EFalse;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::PreviewL
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::PreviewL( TInt aMediaType )
+ {
+ //FLOG( _L("CMediaFileDialog::PreviewL START") );
+
+ if ( !iMediaFileHandler->QueryReady() )
+ {
+ FLOG( _L("### CMediaFileDialog::PreviewL: query in progress ###") );
+ return; // query in progress
+ }
+
+ if ( !iForeGround )
+ {
+ return; // dialog is not visible
+ }
+
+ TInt currentIndex = CurrentItemListIndex();
+ if ( currentIndex == KErrNotFound )
+ {
+ return; // list is empty
+ }
+
+ TInt folderId = iState->FolderId( currentIndex );
+ if ( folderId == EEFolderNullItemOne || folderId == EEFolderNullItemTwo )
+ {
+ PreviewNullItemL( folderId );
+ return;
+ }
+
+ if ( folderId != KErrNotFound )
+ {
+ return; // focused list item is folder
+ }
+
+
+ if ( iState->CurrentFolder() == EEFolderVideos &&
+ aMediaType != CMediaFileList::EMediaFileTypeVideo )
+ {
+ return;
+ }
+
+ GetSelectedItemFileName( currentIndex, iBuf );
+ if ( iBuf.Length() == 0 )
+ {
+ return;
+ }
+
+
+ if ( iState->CurrentFolder() == EEFolderSearch )
+ {
+ if ( IsVideoFile( currentIndex ) )
+ {
+ return; // search folder may contain videos - no automatic preview
+ }
+ }
+
+ if ( !iProtectionHandler->IsFileValid( iBuf, CMFProtectionHandler::EPlay ) )
+ {
+ return;
+ }
+
+ if ( aMediaType == CMediaFileList::EMediaFileTypeVideo )
+ {
+ PreviewVideoL( iBuf );
+ return;
+ }
+
+ iAudioPreviewHandler->SetAttrL( TMFDialogUtil::EAttrFileName, iBuf );
+ iAudioPreviewHandler->PlayL();
+
+ //FLOG( _L("CMediaFileDialog::PreviewL END") );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::PreviewVideoL
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::PreviewVideoL( const TDesC& aFileName )
+ {
+ if ( !iProtectionHandler->IsVideoValid( aFileName, CMFProtectionHandler::EPlay ) )
+ {
+ return;
+ }
+
+ // in case "Beep once" one audio beep is played before showing video
+ TInt type = iAudioPreviewHandler->Attr( CMediaFileList::EAttrRingingType );
+ if ( type == CMFPreviewHandlerBase::ERingingTypeBeepOnce )
+ {
+ iAudioPreviewHandler->SetAttrL( TMFDialogUtil::EAttrFileName, aFileName );
+ iAudioPreviewHandler->PlayL();
+ }
+
+ iVideoPreviewHandler->SetAttrL( TMFDialogUtil::EAttrFileName, aFileName );
+ TInt err = KErrNone;
+ if ( iVideoPreviewDlg && iVideoPreviewHandler->IsPlaying() )
+ {
+ iVideoPreviewDlg->CloseDialogL();
+ iVideoPreviewDlg = NULL;
+ }
+ iVideoPreviewDlg = CVideoPreviewDialog::NewL( iVideoPreviewHandler );
+ TBool ret = iVideoPreviewDlg->ShowDialogLD( &err );
+
+ if ( err != KErrNone )
+ {
+ FLOG( _L("### CVideoPreviewDialog::ShowDialogLD (%d) ###"), err );
+ }
+
+ ShowPreviewErrorNoteL( err, CMediaFileHandler::EMediaTypeVideo );
+
+ if ( ret )
+ {
+ CloseDialogWithDelayL();
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::PreviewLNullItemL
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::PreviewNullItemL( TInt aFolderId )
+ {
+ HBufC* fileName = NULL;
+ TInt fileType = KErrNotFound;
+
+ if ( aFolderId == EEFolderNullItemOne )
+ {
+ fileType = iNullItemFileTypeOne;
+ fileName = iNullItemFileNameOne;
+ }
+ if ( aFolderId == EEFolderNullItemTwo )
+ {
+ fileType = iNullItemFileTypeTwo;
+ fileName = iNullItemFileNameTwo;
+ }
+
+ if ( fileType != CMediaFileList::EMediaFileTypeAudio &&
+ fileType != CMediaFileList::EMediaFileTypeVideo )
+ {
+ return;
+ }
+ if ( !fileName )
+ {
+ return;
+ }
+
+ if ( fileType == CMediaFileList::EMediaFileTypeAudio )
+ {
+ iAudioPreviewHandler->SetAttrL( TMFDialogUtil::EAttrFileName, *fileName );
+ iAudioPreviewHandler->PlayL();
+ }
+ if ( fileType == CMediaFileList::EMediaFileTypeVideo )
+ {
+ // null item file type cannot be video
+ }
+ }
+
+
+//------------------------------------------------------------------------------
+// CMediaFileDialog::CancelPreview
+//
+//------------------------------------------------------------------------------
+//
+void CMediaFileDialog::CancelPreview()
+ {
+ iAudioPreviewHandler->Stop();
+ iCaller->Cancel();
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::StartPreviewWithDelay
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::StartPreviewWithDelay()
+ {
+ const TInt KOneSecond = 1000;
+
+ iAudioPreviewHandler->Stop();
+
+ // automatic preview starts after delay. see HandleActiveCallL.
+ iCaller->Start( EAttrPreview, KOneSecond );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::StartSearchWithDelay
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::StartSearchWithDelay()
+ {
+ if ( iPeninputActive )
+ {
+ // search does not start automatically in pen input mode
+ return;
+ }
+
+ const TInt KOneSecond = 1000;
+
+ // search starts after delay. see HandleActiveCallL.
+ iSearchCaller->Start( EAttrSearch, KOneSecond );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::StartRomScan()
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::StartRomScan()
+ {
+ delete iIdle;
+ iIdle = NULL;
+ iIdle = CIdle::NewL( CActive::EPriorityIdle );
+
+ if ( iIdle )
+ {
+ iIdle->Start( TCallBack( StartRomScaning, iMediaFileHandler ) );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::StartRomScaning()
+//
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediaFileDialog::StartRomScaning( TAny* aInstance )
+ {
+ CMediaFileHandler* handler = static_cast<CMediaFileHandler*> ( aInstance );
+ handler->StartRomScaning( CMediaFileHandler::EQueryTone );
+ return 0;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::IsVideoFile
+//
+// -----------------------------------------------------------------------------
+//
+TBool CMediaFileDialog::IsVideoFile( TInt aCurrentIndex )
+ {
+ if ( aCurrentIndex < 0 )
+ {
+ return EFalse;
+ }
+
+ TInt current = iState->CurrentFolder();
+
+ if ( current == EEFolderVideos )
+ {
+ return ETrue;
+ }
+
+ if ( current != EEFolderSearch )
+ {
+ return EFalse;
+ }
+
+ TInt mediaType = iMediaFileHandler->Attribute( aCurrentIndex,
+ CMediaFileHandler::EAttrMediaType,
+ current );
+
+ if ( mediaType == CMediaFileHandler::EMediaTypeVideo )
+ {
+ return ETrue;
+ }
+
+ return EFalse;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::IsValidVideoFileL
+//
+// -----------------------------------------------------------------------------
+//
+TBool CMediaFileDialog::IsValidVideoFileL( TInt aCurrentIndex, TInt aIntention )
+ {
+ TBuf<KBufSize128> buf;
+
+ if ( !IsVideoFile( aCurrentIndex ) )
+ {
+ return EFalse;
+ }
+
+ CMFProtectionHandler::TIntention intention;
+ if ( aIntention == CMFProtectionHandler::EPlay )
+ {
+ intention = CMFProtectionHandler::EPlay;
+ }
+ else
+ {
+ intention = CMFProtectionHandler::ESelect;
+ }
+ GetSelectedItemFileName( aCurrentIndex, buf );
+
+ if ( iProtectionHandler->IsVideoValid( buf, intention ) )
+ {
+ return ETrue;
+ }
+ return EFalse;
+ }
+
+
+
+// ----------------------------------------------------------------------------
+// CMediaFileDialog::UpdateListBoxL
+//
+// Update listbox contents (currently open folder items).
+// ----------------------------------------------------------------------------
+//
+void CMediaFileDialog::UpdateListBoxL( TBool aRestFindBox )
+ {
+ // prevent flickering during listbox update. ResetFindBoxL seems
+ // to draw listbox many times
+ iListBox->MakeVisible( EFalse );
+
+ TRAP_IGNORE( DoUpdateListBoxL( aRestFindBox ) );
+
+ iListBox->MakeVisible( ETrue );
+ }
+
+// ----------------------------------------------------------------------------
+// CMediaFileDialog::FilterInvalidFiles
+//
+// Filters the invalid files from media file handler
+// invalid files = rights expired DRM Protected files and no right files
+// ----------------------------------------------------------------------------
+//
+void CMediaFileDialog::FilterInvalidFiles()
+ {
+ TInt count = iMediaFileHandler->ResultCount();
+
+ for ( TInt idx = 0; idx < count; )
+ {
+ // check the validity
+ GetSelectedItemFileName( idx, iBuf );
+ if ( iProtectionHandler->IsFlieDRMExpired( iBuf ) )
+ {
+ // remove the item from handler in case of invalid file
+ iMediaFileHandler->Remove( idx );
+
+ // if an item was removed from handler, the idx will not
+ // be changed and the count will be decreased one. after
+ // recalculate the count, the next item will be checked in next loop.
+ count = iMediaFileHandler->ResultCount();
+ }
+ else
+ {
+ // just increase the idx in case of valid file
+ idx++;
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CMediaFileDialog::DoUpdateListBoxL
+//
+// Update listbox contents (currently open folder items).
+// ----------------------------------------------------------------------------
+//
+void CMediaFileDialog::DoUpdateListBoxL( TBool aRestFindBox )
+ {
+ // filter the invalid files to avoid showing in the list box
+ FilterInvalidFiles();
+ iState->SetUnknownFolderPosition( iMediaFileHandler->ResultCount() );
+
+ // check current item index in case media file database has changed
+ CheckListboxIndex();
+ if ( aRestFindBox )
+ {
+ ResetFindBoxL();
+ iListBox->HandleItemAdditionL();
+ }
+
+ TInt index = iState->CurrentItemIndex();
+ if ( index >= 0 && index < iListBox->Model()->NumberOfItems() )
+ {
+ iListBox->SetCurrentItemIndex( index );
+ }
+ else
+ {
+ iListBox->SetCurrentItemIndex( 0 );
+ }
+
+ TBuf<KBufSize128> buf;
+ if ( iState->CurrentFolder() == EEFolderSearch ||
+ iState->CurrentFolder() == EEFolderSearchMusic )
+ {
+ TInt count = iListBox->Model()->NumberOfItems();
+ iState->GetSearchTitle( buf, count );
+ }
+ else
+ {
+ iState->GetTitle( iState->CurrentFolder(), buf );
+//#ifdef _DEBUG
+ TInt folder = iState->CurrentFolder();
+ if ( iState->FindBoxNeeded() && folder != EEFolderMusic &&
+ folder != EEFolderRoot )
+ {
+ TBuf<KBufSize128> buf2( buf );
+ TInt count = iListBox->Model()->NumberOfItems();
+ buf.Format( _L("%S (%d)"), &buf2, count );
+ }
+//#endif
+ }
+
+ AknTextUtils::DisplayTextLanguageSpecificNumberConversion( buf );
+ iStatusPaneHandler->SetNaviPaneTitle( buf );
+
+ UpdateCbaL( 0 );
+
+ DrawNow();
+
+ if ( iState->QueryDirection() != EEQueryUpdate )
+ {
+ CancelPreview();
+ }
+
+ ShowDetailsPopupL(); // for search view info popup
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::UpdateCbaL
+//
+// Update cba. NOTE: Commented code (menu cba) is for (possible) future use.
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::UpdateCbaL( TInt /*aAttr*/ )
+ {
+ TInt itemCount = iListBox->Model()->NumberOfItems();
+ TInt currentIndex = CurrentItemListIndex();
+ TInt folderId = iState->FolderId( currentIndex );
+ TInt currentFolderId = iState->CurrentFolder();
+
+
+ CEikButtonGroupContainer& cba = ButtonGroupContainer(); // from eikbtgpc.h
+
+
+ // Videos folder
+ if ( currentFolderId == EEFolderVideos )
+ {
+ if ( itemCount == 0 )
+ {
+ cba.SetCommandSetL( R_AVKON_SOFTKEYS_BACK );
+ //cba.SetCommandSetL( R_AVKON_SOFTKEYS_OPTIONS_BACK );
+ }
+ else
+ {
+ if ( IsValidVideoFileL( currentIndex, CMFProtectionHandler::EPlay ) )
+ {
+ cba.SetCommandSetL( R_MEDIA_FILE_DIALOG_CBA_PREVIEW_SELECT_BACK );
+ }
+ else
+ {
+ cba.SetCommandSetL( R_MEDIA_FILE_DIALOG_CBA_SELECT_SELECT_BACK );
+ }
+
+ //cba.SetCommandSetL( R_MEDIA_FILE_DIALOG_CBA_OPTIONS_CONTEXT_BACK );
+ }
+ return;
+ }
+
+
+ // Search folder
+ if ( currentFolderId == EEFolderSearch ||
+ currentFolderId == EEFolderSearchMusic )
+ {
+ if ( itemCount == 0 )
+ {
+ cba.SetCommandSetL( R_AVKON_SOFTKEYS_BACK );
+ // cba.SetCommandSetL( R_AVKON_SOFTKEYS_OPTIONS_BACK );
+ }
+ else
+ {
+ if ( IsValidVideoFileL( currentIndex, CMFProtectionHandler::EPlay ) )
+ {
+ cba.SetCommandSetL( R_MEDIA_FILE_DIALOG_CBA_PREVIEW_SELECT_BACK );
+ }
+ else
+ {
+ cba.SetCommandSetL( R_MEDIA_FILE_DIALOG_CBA_SELECT_SELECT_BACK );
+ }
+ //cba.SetCommandSetL( R_MEDIA_FILE_DIALOG_CBA_OPTIONS_SELECT_BACK );
+ }
+ return;
+ }
+
+
+ // Root folder
+ if ( currentFolderId == EEFolderRoot )
+ {
+ if ( folderId == EEFolderDownload || folderId == EEFolderNullItemOne ||
+ folderId == EEFolderNullItemTwo )
+ {
+ //cba.SetCommandSetL( R_MEDIA_FILE_DIALOG_CBA_OPTIONS_SELECT_BACK );
+ cba.SetCommandSetL( R_MEDIA_FILE_DIALOG_CBA_SELECT_SELECT_BACK );
+ }
+ else
+ {
+ //cba.SetCommandSetL( R_MEDIA_FILE_DIALOG_CBA_OPTIONS_OPEN_BACK );
+ cba.SetCommandSetL( R_MEDIA_FILE_DIALOG_CBA_OPEN_OPEN_BACK );
+ }
+ return;
+ }
+
+
+ // other folders
+ if ( itemCount == 0 )
+ {
+ // folder is empty
+ cba.SetCommandSetL( R_AVKON_SOFTKEYS_BACK );
+ //cba.SetCommandSetL( R_AVKON_SOFTKEYS_OPTIONS_BACK );
+ }
+ else if ( folderId != KErrNotFound )
+ {
+ // list items are folders
+ cba.SetCommandSetL( R_MEDIA_FILE_DIALOG_CBA_OPEN_OPEN_BACK );
+ //cba.SetCommandSetL( R_MEDIA_FILE_DIALOG_CBA_OPTIONS_OPEN_BACK );
+ }
+ else
+ {
+ // list items are files
+ cba.SetCommandSetL( R_MEDIA_FILE_DIALOG_CBA_SELECT_SELECT_BACK );
+ //cba.SetCommandSetL( R_MEDIA_FILE_DIALOG_CBA_OPTIONS_SELECT_BACK );
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::Panic
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::Panic( TInt aReason )
+ {
+ _LIT( KPanicCategory, "CMediaFileDialog" );
+
+ User::Panic( KPanicCategory, aReason );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::ShowErrorNoteL
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::ShowErrorNoteL( TInt aError )
+ {
+ TInt err = aError;
+
+ if ( err == KErrNone )
+ {
+ return;
+ }
+
+ iBuf = KNullDesC;
+ CTextResolver* tr = CTextResolver::NewLC();
+ iBuf = tr->ResolveErrorString( err, CTextResolver::ECtxNoCtxNoSeparator );
+ CleanupStack::PopAndDestroy( tr );
+
+ if ( iBuf.Length() > 0 )
+ {
+ TMFDialogUtil::ShowErrorNoteL( iBuf );
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::ShowPreviewErrorNoteL
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::ShowPreviewErrorNoteL( TInt aError, TInt aMediaType )
+ {
+ TInt err = KErrNone;
+
+ if ( aError == KErrNoMemory || aError == KErrDiskFull )
+ {
+ CTextResolver* tr = CTextResolver::NewLC();
+ iBuf = tr->ResolveErrorString( aError, CTextResolver::ECtxNoCtxNoSeparator );
+ CleanupStack::PopAndDestroy( tr );
+ err = aError;
+ }
+ else if ( aError == KErrNotSupported || aError == KErrCorrupt ||aError == KErrMMPartialPlayback)
+ {
+ if ( aMediaType == CMediaFileHandler::EMediaTypeVideo )
+ {
+ StringLoader::Load( iBuf, R_QTN_INFO_CLIP_FORMAT_ERROR );
+ }
+ else
+ {
+ StringLoader::Load( iBuf, R_QTN_INFO_FILE_FORMAT_ERROR );
+ }
+ err = aError;
+ }
+
+ if ( err == KErrNone )
+ {
+ return;
+ }
+
+#ifdef _DEBUG
+ TMFDialogUtil::ShowErrorNoteL( iBuf, aError );
+#else
+ TMFDialogUtil::ShowErrorNoteL( iBuf );
+#endif
+
+ }
+
+
+//------------------------------------------------------------------------------
+// CMediaFileDialog::ShowWaitNoteL
+//
+//------------------------------------------------------------------------------
+//
+void CMediaFileDialog::ShowWaitNoteL( TBool aDatabaseChanged )
+ {
+ TBuf<KBufSize128> buf;
+
+ if ( aDatabaseChanged )
+ {
+ StringLoader::Load( buf, R_QTN_WAIT_NOTE_UPDATE );
+ //buf = _L("Refreshing");
+ }
+ else if ( iState->QueryFolder() == EEFolderSearch ||
+ iState->QueryFolder() == EEFolderSearchMusic )
+ {
+ StringLoader::Load( buf, R_QTN_WAIT_NOTE_SEARCH );
+ }
+ else
+ {
+ StringLoader::Load( buf, R_QTN_WAIT_NOTE_OPEN );
+ }
+
+ iWaitNote->LaunchL( buf );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::DeleteMenuItem
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::DeleteMenuItem( CEikMenuPane* aMenuPane, TInt aCommandId )
+ {
+ TInt pos = KErrNotFound;
+ if ( aMenuPane->MenuItemExists( aCommandId, pos ) )
+ {
+ aMenuPane->DeleteMenuItem( aCommandId );
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::ShowPopupNote
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::ShowPopupNoteL( const TDesC& aText )
+ {
+ const TInt KPopupDisplayTime = 3*1000;
+ const TInt KPopupDelayTime = 500;
+
+ iPopupNote->SetTextL( aText );
+ iPopupNote->SetTimeDelayBeforeShow( KPopupDelayTime );
+ iPopupNote->SetTimePopupInView( KPopupDisplayTime );
+ iPopupNote->ShowInfoPopupNote();
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::CurrentItemListIndex
+//
+// -----------------------------------------------------------------------------
+//
+TInt CMediaFileDialog::CurrentItemListIndex()
+ {
+ TInt itemCount = iListBox->Model()->NumberOfItems();
+ TInt currentIndex = iListBox->CurrentItemIndex();
+
+ if ( itemCount == 0 || currentIndex < 0 )
+ {
+ return KErrNotFound; // list or find box is empty
+ }
+
+ // convert from findbox index into original list index
+ if ( FindBox() && FindBox()->IsVisible() )
+ {
+ TInt tempIndex = currentIndex;
+ CAknFilteredTextListBoxModel* model =
+ STATIC_CAST(CAknFilteredTextListBoxModel*, iListBox->Model());
+
+ if ( model->Filter() )
+ {
+ currentIndex = model->Filter()->FilteredItemIndex( tempIndex );
+ }
+ }
+
+ return currentIndex;
+ }
+
+
+//------------------------------------------------------------------------------
+// CMediaFileDialog::GetSelectedItemFileName
+//
+//------------------------------------------------------------------------------
+//
+void CMediaFileDialog::GetSelectedItemFileName( TInt aListboxIndex, TDes& aFileName )
+ {
+ aFileName = KNullDesC;
+
+ __ASSERT_DEBUG( iState->QueryNeeded(), Panic( KErrGeneral ) );
+
+ TInt id = iState->CurrentFolder();
+
+ // read selected list item text from metadata
+ TInt extraIndexes = iState->LeadingPersistentFolderCount();
+ TInt queryIndex = aListboxIndex - extraIndexes;
+
+ iMediaFileHandler->GetAttribute( queryIndex, CMediaFileHandler::EAttrFullName,
+ aFileName, id );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::ConstructListboxItem
+//
+// -----------------------------------------------------------------------------
+//
+TPtrC CMediaFileDialog::ConstructListboxItem( TInt aListboxIndex )
+ {
+ _LIT( KFormat2, "%d\t%S\t%d" );
+
+ TBool isPersistent = EFalse;
+ TInt mediaTypeIcon = EEIconEmpty;
+ TInt storageTypeIcon = EEIconEmpty;
+ TInt folderId = KErrNotFound;
+ iState->GetFolderInfo( aListboxIndex, folderId, iListboxItemText1,
+ isPersistent, mediaTypeIcon );
+ if ( folderId != KErrNotFound )
+ {
+ if ( !isPersistent )
+ {
+ GetListItemText( aListboxIndex, iListboxItemText1 );
+ }
+ }
+ else
+ {
+ GetListItemText( aListboxIndex, iListboxItemText1 );
+ mediaTypeIcon = MediaTypeIcon( aListboxIndex );
+ storageTypeIcon = StorageTypeIcon( aListboxIndex );
+ }
+
+ iListboxItemText2.Format( KFormat2, mediaTypeIcon, &iListboxItemText1, storageTypeIcon );
+ return iListboxItemText2;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::MediaTypeIcon
+//
+// -----------------------------------------------------------------------------
+//
+TInt CMediaFileDialog::MediaTypeIcon( TInt aListboxIndex )
+ {
+ if ( aListboxIndex < 0 )
+ {
+ return EEIconEmpty;
+ }
+
+ TInt mediaType = iMediaFileHandler->Attribute( aListboxIndex,
+ CMediaFileHandler::EAttrMediaType,
+ iState->CurrentFolder() );
+
+ TInt iconId = EEIconMusic;
+ if ( mediaType == CMediaFileHandler::EMediaTypeTone )
+ {
+ iconId = EEIconTone;
+ }
+ else if ( mediaType == CMediaFileHandler::EMediaTypeVideo )
+ {
+ iconId = EEIconVideo;
+ }
+ else if ( mediaType == CMediaFileHandler::EMediaTypeRecording )
+ {
+ iconId = EEIconRecording;
+ }
+
+ return iconId;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::StorageTypeIcon
+//
+// -----------------------------------------------------------------------------
+//
+TInt CMediaFileDialog::StorageTypeIcon( TInt aListboxIndex )
+ {
+ if ( aListboxIndex < 0 )
+ {
+ return EEIconEmpty;
+ }
+
+ TInt storageType = iMediaFileHandler->Attribute( aListboxIndex,
+ CMediaFileHandler::EAttrStorageType,
+ iState->CurrentFolder() );
+ TInt iconId = EEIconEmpty;
+ if ( storageType == CMediaFileHandler::EMassStorage )
+ {
+ iconId = EEIconMassStorage;
+ }
+
+ if ( storageType == CMediaFileHandler::EMemoryCard )
+ {
+ iconId = EEIconMemoryCard;
+ }
+
+ return iconId;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::GetListItemText
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::GetListItemText( TInt aListboxIndex, TDes& aText )
+ {
+ __ASSERT_DEBUG( iState->QueryNeeded(), Panic( KErrGeneral ) );
+
+ TInt id = iState->CurrentFolder();
+
+ // read selected list item text from metadata
+ TInt extraIndexes = iState->LeadingPersistentFolderCount();
+ TInt queryIndex = aListboxIndex - extraIndexes;
+
+ iMediaFileHandler->GetAttribute( queryIndex,
+ CMediaFileHandler::EAttrSongName, aText, id );
+ }
+
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::ListboxItemCount (from CMFListHandlerObserver)
+//
+// -----------------------------------------------------------------------------
+//
+TInt CMediaFileDialog::ListboxItemCount()
+ {
+ TInt count1 = iState->PersistentFolderCount();
+ TInt count2 = 0;
+
+ if ( iState->QueryNeeded() )
+ {
+ count2 = iMediaFileHandler->ResultCount();
+ }
+ return count1 + count2;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::HandleMFEventL (from MMediaFileHandlerObserver)
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::HandleMFEventL( TInt aEvent, TInt aError )
+ {
+ //
+ // handle cancel button
+ //
+ if ( aEvent == MMediaFileHandlerObserver::EQueryCanceled )
+ {
+ iWaitNote->CancelProgressDialogL();
+ iSearchText = KNullDesC;
+ UpdateListBoxL();
+ return;
+ }
+
+ //
+ // handle error
+ //
+ if ( aError != KErrNone )
+ {
+ iWaitNote->CancelProgressDialogL();
+ ResetDialogL( aError );
+
+ FLOG( _L("### CMediaFileDialog::HandleMFEventL (%d) ###"), aError );
+ return;
+ }
+
+
+ if ( aEvent != MMediaFileHandlerObserver::EUnknownQueryComplete )
+ {
+ // unknown query is always followed by another query
+ iWaitNote->CancelProgressDialogL();
+ }
+
+
+ if ( aEvent == MMediaFileHandlerObserver::EUnknownQueryComplete )
+ {
+ TInt count = iMediaFileHandler->ResultCount();
+ TInt folderId = iState->QueryFolder();
+ iState->SetUnknownCount( folderId, count );
+
+ TInt err = KErrNone;
+ TRAP( err, QueryL( folderId ) );
+ if ( err != KErrNone )
+ {
+ iWaitNote->CancelProgressDialogL();
+ User::Leave( err );
+ }
+ }
+
+ if ( aEvent == MMediaFileHandlerObserver::EQueryComplete )
+ {
+ // query was successful - update dialog state
+ iState->SetStateAfterQuery();
+
+ TInt count = iMediaFileHandler->ResultCount();
+
+ if ( iState->CurrentFolder() == EEFolderArtist )
+ {
+ TInt count = iMediaFileHandler->UnknownArtistCount();
+ iState->SetUnknownCount( EEFolderArtist, count );
+ }
+ iState->HideUnknownFolders();
+ UpdateListBoxL();
+
+#ifdef _DEBUG
+ iTest->PrintTimeL( _L("query took") ); // test code
+#endif
+ }
+
+ if ( aEvent == MMediaFileHandlerObserver::EMediaFileChanged )
+ {
+ HandleMediaFileChanged();
+ }
+
+ if ( aEvent == MMediaFileHandlerObserver::EScanRomComplete )
+ {
+ iWaitNote->CancelProgressDialogL();
+ }
+
+ if ( aEvent == MMediaFileHandlerObserver::EInitComplete )
+ {
+ iDatabaseOpen = ETrue;
+
+ StartRomScan();
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::HandleMediaFileChanged
+//
+// Handle situation where file system changes and media files are added /
+// removed. This function makes a query to update current folder and
+// stores name or id of the currently selected item. Current item info
+// is needed to restore current item after query.
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::HandleMediaFileChanged()
+ {
+ // query is ongoing - ignore this file change event
+ if ( !iMediaFileHandler->QueryReady() )
+ {
+ FLOG( _L("### CMediaFileDialog::HandleMediaFileChanged: query in progress ###") );
+ return;
+ }
+
+ iState->ResetUnknownCount();
+ TMFCurrentItemInfo& info = iState->CurrentItemInfo();
+ info.Reset();
+ info.iIndexCheckNeeded = ETrue; // set to false when dialog is opened
+
+ TInt currentFolder = iState->CurrentFolder();
+ TInt currentIndex = CurrentItemListIndex();
+
+ TBool isPersistent = EFalse;
+ TInt iconId = EEIconEmpty;
+ TInt id = KErrNotFound;
+ TBuf<KBufSize64> buf;
+ iState->GetFolderInfo( currentIndex, id, buf,
+ isPersistent, iconId );
+ if ( id == KErrNotFound )
+ {
+ // get media file id
+ info.iMediaFileId = iMediaFileHandler->Attribute( currentIndex,
+ CMediaFileHandler::EAttrMediaFileId, currentFolder );
+ }
+ else if ( !isPersistent )
+ {
+ // get non-persistent folder name (eg some album name)
+ GetListItemText( currentIndex, info.iFolderText );
+ }
+ else
+ {
+ // get persistent folder id (eg "Unknown" folder)
+ info.iFolderId = id;
+ }
+
+ info.iItemIndex = currentIndex;
+
+ iState->SetQueryInfo( 0, KNullDesC, 0, EEQueryUpdate );
+
+ TBool databaseChanged = ETrue;
+ QueryL( currentFolder, databaseChanged );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::CheckListboxIndex
+//
+// Check that current item selection is correct. Function is used in case
+// file system has changed (media files added / removed.
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::CheckListboxIndex()
+ {
+ TMFCurrentItemInfo& info = iState->CurrentItemInfo();
+ if ( !info.iIndexCheckNeeded )
+ {
+ return;
+ }
+
+ TInt direction = iState->QueryDirection();
+ TInt newListIndex = KErrNotFound;
+
+ if ( direction == EEQueryUp )
+ {
+ FLOG( _L("query up") );
+ TInt prevId = iState->PreviousFolderId();
+ TInt listIndex = iState->ListIndex( prevId );
+ if ( !iState->IsPersistent( prevId ) )
+ {
+ iState->GetText( prevId, info.iFolderText );
+ TInt num = iState->LeadingPersistentFolderCount();
+ newListIndex = iMediaFileHandler->ItemIndex(
+ info.iFolderText, listIndex );
+ iState->SetCurrentItemIndex( newListIndex + num );
+ }
+ else
+ {
+ iState->SetCurrentItemIndex( listIndex );
+ }
+ }
+
+ if ( direction == EEQueryUpdate )
+ {
+ if ( info.iMediaFileId != KErrNotFound )
+ {
+ newListIndex = iMediaFileHandler->ItemIndex(
+ info.iMediaFileId, info.iItemIndex );
+ }
+ else if ( info.iFolderText.Length() > 0 )
+ {
+ newListIndex = iMediaFileHandler->ItemIndex(
+ info.iFolderText, info.iItemIndex );
+ TInt num = iState->LeadingPersistentFolderCount();
+ newListIndex = newListIndex + num;
+ }
+ else if ( info.iFolderId != KErrNotFound )
+ {
+ newListIndex = iState->ListIndex( info.iFolderId );
+ }
+
+ iState->SetCurrentItemIndex( newListIndex );
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::HandlePreviewEventL (from MPreviewHandlerObserver)
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::HandlePreviewEventL( TInt aEvent, TInt aError )
+ {
+ if ( aEvent == MPreviewHandlerObserver::EAudioPreviewComplete )
+ {
+ ShowPreviewErrorNoteL( aError, CMediaFileHandler::EMediaTypeMusic );
+ }
+
+ if ( aEvent == MPreviewHandlerObserver::EVideoPreviewComplete )
+ {
+ ShowPreviewErrorNoteL( aError, CMediaFileHandler::EMediaTypeVideo );
+ }
+
+ if ( aEvent == MPreviewHandlerObserver::EPreviewError )
+ {
+ FLOG( _L("### CMediaFileDialog::HandlePreviewEventL (%d) ###"), aError );
+
+ ShowPreviewErrorNoteL( aError, CMediaFileHandler::EMediaTypeMusic );
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::HandleLosingForeground (from MCoeForegroundObserver)
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::HandleLosingForeground()
+ {
+ iForeGround = EFalse;
+ //Record the current item info
+ if ( iState && iListBox)
+ {
+ iState->SetCurrentItemIndex( CurrentItemListIndex() );
+ }
+
+ CancelPreview();
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::HandleGainingForeground (from MCoeForegroundObserver)
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::HandleGainingForeground()
+ {
+ iForeGround = ETrue;
+ if ( iListBox )
+ {
+ UpdateListBoxL( EFalse );
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::HandleControlEventL (from MCoeControlObserver)
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::HandleControlEventL( CCoeControl* aControl,
+ TCoeEvent aEventType )
+ {
+ TInt currentFolderId = iState->CurrentFolder();
+
+ if ( aEventType == EEventStateChanged )
+ {
+ CancelPreview();
+ if ( aControl == iListBox )
+ {
+ if ( currentFolderId == EEFolderRoot ||
+ currentFolderId == EEFolderSearch ||
+ currentFolderId == EEFolderVideos )
+ {
+ UpdateCbaL( 0 ); // only these folders need dynamic cba update
+ }
+ StartPreviewWithDelay();
+ ShowDetailsPopupL(); // show search details in Search view
+
+ // forward listbox state change events to this control's
+ // observers
+ ReportEventL( MCoeControlObserver::EEventStateChanged );
+ }
+
+ if ( FindBox() && aControl == FindBox() )
+ {
+ User::InfoPrint(_L("find box event arrived"));
+
+ // this event is received when user enters or deletes
+ // chars in find box. Backspace key in empty find box does not
+ // generate this event.
+
+ if ( currentFolderId == EEFolderSearch ||
+ currentFolderId == EEFolderRoot ||
+ currentFolderId == EEFolderMusic ||
+ currentFolderId == EEFolderSearchMusic )
+ {
+ StartSearchWithDelay();
+ return;
+ }
+
+ // StartPreviewWithDelay();
+
+ UpdateCbaL( 0 );
+
+//#ifdef _DEBUG
+ TBuf<KBufSize128> buf;
+ iState->GetTitle( iState->CurrentFolder(), buf );
+ TBuf<KBufSize128> buf2( buf );
+ TInt count = iListBox->Model()->NumberOfItems();
+ buf.Format( _L("%S (%d)"), &buf2, count );
+ iStatusPaneHandler->SetNaviPaneTitle( buf );
+//#endif
+
+ // Forward listbox state change events to this control's
+ // observers
+ ReportEventL( MCoeControlObserver::EEventStateChanged );
+ }
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::HandleWaitNoteL (from MMediaFileWaitNoteObserver)
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::HandleWaitNoteL( TInt /*aButtonId*/ )
+ {
+ iMediaFileHandler->CancelQuery();
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::AdaptiveSearchTextChanged (from MAdaptiveSearchTextObserver)
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::AdaptiveSearchTextChanged( CAknSearchField* /*aSearchField*/ )
+ {
+ // not used
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::OnPeninputUiDeactivated
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::OnPeninputUiDeactivated()
+ {
+ iPeninputActive = EFalse;
+
+ if ( FindBox()->TextLength() == 0 &&
+ ( iState->CurrentFolder() == EEFolderSearch ||
+ iState->CurrentFolder() == EEFolderSearchMusic ) )
+ {
+ HandleBackL();
+ }
+ else
+ {
+ // search starts immediately after user closes pen input
+ TRAP_IGNORE( StartSearchWithDelay() );
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::OnPeninputUiActivated
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::OnPeninputUiActivated()
+ {
+ iPeninputActive = ETrue;
+ CancelPreview();
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::HandleListBoxEventL (from MEikListBoxObserver)
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::HandleListBoxEventL( CEikListBox* /*aListBox*/,
+ TListBoxEvent aEventType )
+ {
+ TInt current = iState->CurrentFolder();
+ if ( aEventType == EEventPenDownOnItem)
+ {
+ iListBox->View()->ItemDrawer()->SetFlags( CListItemDrawer::EPressedDownState );
+ return;
+ }
+
+ if ( aEventType == EEventItemClicked )
+ {
+ iIsDoubleClicked = EFalse;
+ if ( current != KErrNotFound )
+ {
+ HandleOKL( EAttrOpen ); // open folder item
+ }
+ return;
+ }
+
+ if ( aEventType == EEventItemDoubleClicked || aEventType == EEventEnterKeyPressed )
+ {
+ iIsDoubleClicked = ETrue;
+ TBool closeDialog = HandleOKL( EAttrDoubleClicked );
+
+ if ( closeDialog )
+ {
+ // close after short delay (dialog cannot be closed from this function)
+ CloseDialogWithDelayL();
+ }
+ }
+ if ( aEventType == EEventItemDraggingActioned )
+ {
+ UpdateCbaL( KErrNone );
+ DrawNow();
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::CloseDialogWithDelayL
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::CloseDialogWithDelayL()
+ {
+ delete iIdle;
+ iIdle = NULL;
+ iIdle = CIdle::NewL( CActive::EPriorityIdle );
+
+ if ( iIdle )
+ {
+ iIdle->Start( TCallBack( CloseDialog, this ) );
+ }
+ delete iInputBlock;
+ iInputBlock = NULL;
+ iInputBlock = CAknInputBlock::NewLC();
+ CleanupStack::Pop( iInputBlock );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::CloseDialog
+//
+// -----------------------------------------------------------------------------
+//
+TInt CMediaFileDialog::CloseDialog( TAny *aObj )
+ {
+ CMediaFileDialog *dlg = (CMediaFileDialog*) aObj;
+ delete dlg->iInputBlock;
+ dlg->iInputBlock = NULL;
+
+ TRAP_IGNORE( dlg->TryExitL( EAknSoftkeyOk ) );
+
+ return 0;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediaFileDialog::HandleActiveCallL (from MMFActiveCallerObserver)
+//
+// -----------------------------------------------------------------------------
+//
+void CMediaFileDialog::HandleActiveCallL( TInt aCallId )
+ {
+ if ( aCallId == EAttrPreview )
+ {
+ //double click the item of the listbox to select the tones, do not preview it.
+ if ( iIsDoubleClicked )
+ {
+ iIsDoubleClicked = EFalse;
+ }
+ else
+ {
+ // start preview after delay
+ PreviewL( CMediaFileList::EMediaFileTypeAudio );
+ }
+ }
+
+ if ( aCallId == EAttrSearch )
+ {
+ // start search after delay
+ SearchL();
+ }
+ }
+
+
+
+
+/******************************************************************************
+ * class CMFListHandler
+ ******************************************************************************/
+
+// -----------------------------------------------------------------------------
+// CMFListHandler::NewL
+//
+// -----------------------------------------------------------------------------
+//
+CMFListHandler* CMFListHandler::NewL()
+ {
+ CMFListHandler* self = new (ELeave) CMFListHandler();
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMFListHandler::~CMFListHandler
+//
+// -----------------------------------------------------------------------------
+//
+CMFListHandler::~CMFListHandler()
+ {
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMFListHandler::ConstructL
+//
+// -----------------------------------------------------------------------------
+//
+void CMFListHandler::ConstructL( void )
+ {
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMFListHandler::CMFListHandler
+//
+// -----------------------------------------------------------------------------
+//
+CMFListHandler::CMFListHandler()
+ {
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMFListHandler::SetObserver
+//
+// -----------------------------------------------------------------------------
+//
+void CMFListHandler::SetObserver( CMFListHandlerObserver* aObserver )
+ {
+ iObserver = aObserver;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMFListHandler::MdcaCount (from MDesCArray)
+//
+// -----------------------------------------------------------------------------
+//
+TInt CMFListHandler::MdcaCount() const
+ {
+ return iObserver->ListboxItemCount();
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMFListHandler::MdcaPoint (from MDesCArray)
+//
+// CEikListBox calls this function just before it draws list box item.
+// -----------------------------------------------------------------------------
+//
+TPtrC16 CMFListHandler::MdcaPoint( TInt aIndex ) const
+ {
+ return iObserver->ConstructListboxItem( aIndex );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMFListHandler::Panic
+//
+// -----------------------------------------------------------------------------
+//
+void CMFListHandler::Panic( TInt aReason )
+ {
+ _LIT( KPanicCategory, "CMFListHandler" );
+
+ User::Panic( KPanicCategory, aReason );
+ }
+
+
+
+
+
+
+
+
+// End of File