videocollection/hgmyvideos/src/vcxhgmyvideosvideolistimpl.cpp
author Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
Mon, 21 Jun 2010 15:43:03 +0300
branchRCL_3
changeset 45 baf439b22ddd
parent 23 8f0df5c82986
child 53 2d690156cf8f
permissions -rw-r--r--
Revision: 201023 Kit: 2010125

/*
* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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:      Implementation of UI functionality for video list.*
*/




// INCLUDE FILES
#include <StringLoader.h>
#include <aknnotewrappers.h>
#include <centralrepository.h>
#include <AknsUtils.h>
#include <AknUtils.h>
#include <aknlayoutscalable_avkon.cdl.h>
#include <bautils.h>  
#include <gulicon.h>
#include <fbs.h>

#include <sendui.h>
#include <SendUiConsts.h>
#include <CMessageData.h>
#include <MessagingDomainCRKeys.h>

#include <ganes/HgScroller.h>
#include <ganes/HgDoubleGraphicList.h>
#include <AknWaitDialog.h> 

#include <vcxhgmyvideos.rsg>
#include <vcxhgmyvideosicons.mbg>
#include <vcxmyvideosdefs.h>
#include <myvideosindicator.h>
#include "IptvDebug.h"

#include <mpxplaybackutility.h>
#include <mpxviewutility.h>
#include <mpxcommandgeneraldefs.h>

#include "vcxhgmyvideosvideolistimpl.h"
#include "vcxhgmyvideosvideomodelhandler.h"
#include "vcxhgmyvideosmodel.h"
#include "vcxhgmyvideosmainview.h"
#include "vcxhgmyvideoscollectionclient.h"
#include "vcxhgmyvideos.hrh"
#include "vcxhgmyvideosvideocopier.h"
#include "vcxhgmyvideospanics.h"
#include "vcxhgmyvideosupnpinterface.h"
#ifdef RD_VIDEO_AS_RINGING_TONE
#include "vcxhgmyvideosaiwmenuhandler.h"
#endif

_LIT( KVcxHgMyVideosMifFile, "\\resource\\apps\\vcxhgmyvideosicons.mif" );

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::NewL()
// -----------------------------------------------------------------------------
//
CVcxHgMyVideosVideoListImpl* CVcxHgMyVideosVideoListImpl::NewL(
        CVcxHgMyVideosModel& aModel,
        CVcxHgMyVideosMainView& aView,
        CHgScroller& aScroller )
    {
    CVcxHgMyVideosVideoListImpl* self = 
        CVcxHgMyVideosVideoListImpl::NewLC( aModel, aView, aScroller );
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::NewLC()
// -----------------------------------------------------------------------------
//
CVcxHgMyVideosVideoListImpl* CVcxHgMyVideosVideoListImpl::NewLC(
        CVcxHgMyVideosModel& aModel,
        CVcxHgMyVideosMainView& aView,
        CHgScroller& aScroller )
    {
    CVcxHgMyVideosVideoListImpl* self = 
        new (ELeave) CVcxHgMyVideosVideoListImpl( aModel, aView, aScroller );
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }
    
// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::CVcxHgMyVideosVideoListImpl()
// -----------------------------------------------------------------------------
//
CVcxHgMyVideosVideoListImpl::CVcxHgMyVideosVideoListImpl( 
        CVcxHgMyVideosModel& aModel,
        CVcxHgMyVideosMainView& aView,
        CHgScroller& aScroller )
  : CVcxHgMyVideosListBase( aModel, aView, aScroller )
#ifdef RD_VIDEO_AS_RINGING_TONE
    , iAiwMenuHandler( NULL )
#endif
    {
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::ConstructL()
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoListImpl::ConstructL()
    {
    CVcxHgMyVideosListBase::ConstructL();

    iVideoModel = CVcxHgMyVideosVideoModelHandler::NewL( 
                      *this, iModel, iView, *iScroller );

    iVideoCopier = CVcxHgMyVideosVideoCopier::NewL( *this, *iVideoModel, iModel );
    
    iUPnP = CVcxHgMyVideosUPnPInterface::NewL( this );
    
    CFbsBitmap* bitmap( NULL );
    CFbsBitmap* mask( NULL );
    CGulIcon* defaultIcon( NULL );
    
    // Create default icon for Hg list.
    AknsUtils::CreateIconLC( AknsUtils::SkinInstance(), 
                             KAknsIIDQgnPropMtvProgClip,
                             bitmap,
                             mask,
                             KVcxHgMyVideosMifFile,
                             EMbmVcxhgmyvideosiconsQgn_prop_mtv_prog_clip,
                             EMbmVcxhgmyvideosiconsQgn_prop_mtv_prog_clip_mask );
    
    TInt error( KErrNone );
    error = AknIconUtils::SetSize( bitmap, 
                                   CHgDoubleGraphicList::PreferredImageSize(), 
                                   EAspectRatioPreservedAndUnusedSpaceRemoved );
    User::LeaveIfError( error );
    
    error = AknIconUtils::SetSize( mask, 
                                   CHgDoubleGraphicList::PreferredImageSize(), 
                                   EAspectRatioPreservedAndUnusedSpaceRemoved );
    User::LeaveIfError( error );
    
    // Ownership of bitmap and mask is transferred to icon.
    defaultIcon = CGulIcon::NewL( bitmap, mask );
    CleanupStack::Pop( 2 ); // bitmap and mask
    
    CleanupStack::PushL( defaultIcon );
             
    // Ownership of icon is transferred.
    iScroller->SetDefaultIconL( defaultIcon );
    CleanupStack::Pop( defaultIcon );
    
    CGulIcon* ind = iVideoModel->VideoIndicator().VideoOverlayIndicatorL();
    if ( ind )
        {
        CleanupStack::PushL( ind );
        // Ownership of the icon is transferred
        static_cast<CHgDoubleGraphicList*>( iScroller )->SetIconOverlayIndicator( ind );
        CleanupStack::Pop( ind );
        }
    
    iScroller->SetMarkingObserver( *this );
    iScroller->SetSelectionObserver( *this );
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::~CVcxHgMyVideosVideoListImpl()
// -----------------------------------------------------------------------------
//
CVcxHgMyVideosVideoListImpl::~CVcxHgMyVideosVideoListImpl()
    {
    CloseDeleteWaitNote();
    delete iUPnP;
    delete iVideoCopier;
    delete iVideoModel;
    delete iSendUi;
#ifdef RD_VIDEO_AS_RINGING_TONE
    delete iAiwMenuHandler;
#endif
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::DoListActivateL()
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoListImpl::DoListActivateL( TInt aIndex )
    {
    TInt index = aIndex;
    TInt currentIndex = iVideoModel->CurrentCategoryIndex();
    index = ( ( index != KErrNotFound ) ? index : currentIndex );
    index = ( ( index != KErrNotFound ) ? index : 0 );

    iVideoModel->UpdateVideoListL( index );
    
    iVideoModel->DoModelActivateL();
    CVcxHgMyVideosListBase::DoListActivateL( index );
    if ( index != currentIndex )
        {
        // Prevents old list from flickering
        iScroller->DrawNow();
        }
    iScroller->SetFocus( ETrue );
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::DoListDeactivate()
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoListImpl::DoListDeactivate()
    {
    CVcxHgMyVideosListBase::DoListDeactivate();
    iVideoModel->DoModelDeactivate();
    iScroller->SetFocus( EFalse );
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::VideoModel()
// -----------------------------------------------------------------------------
//
CVcxHgMyVideosVideoModelHandler& CVcxHgMyVideosVideoListImpl::VideoModel()
    {
    return *iVideoModel;
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::UPnPInterface()
// -----------------------------------------------------------------------------
//
CVcxHgMyVideosUPnPInterface& CVcxHgMyVideosVideoListImpl::UPnPInterface()
    {
    return *iUPnP;
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::HandleSelectL()
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoListImpl::HandleSelectL( TInt /*aIndex*/ )
    {
	iView.DynInitMskL();
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::HandleOpenL()
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoListImpl::HandleOpenL( TInt /*aIndex*/ )
    {
    // Reset the visible selection of the list.
    iScroller->DrawDeferred();
    
    if ( iModel.TouchSupport() )
        {    
        PlayCurrentVideoL();
        }
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::HandleMarkingL()
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoListImpl::HandleMarkingL( TInt /*aIndex*/, TBool /*aMarked*/ )
    {    
    iView.DynInitMskL();
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::Highlight()
// -----------------------------------------------------------------------------
//
TInt CVcxHgMyVideosVideoListImpl::Highlight()
    {
    return iVideoModel->Highlight();
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::GetOperationTargetIndexesL()
// Returns the index(es) of videos that should be the target for user's 
// operation.
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoListImpl::GetOperationTargetIndexesL( 
        RArray<TInt>& aOperationTargets )
    {
    iVideoModel->MarkedVideosL( aOperationTargets );

    if ( aOperationTargets.Count() == 0 )
        {
        TInt highlight = Highlight();
        if ( highlight == KErrNotFound )
            {
            User::Leave( KErrNotFound );
            }

        aOperationTargets.AppendL( highlight );
        }
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::PlayCurrentVideoL()
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoListImpl::PlayCurrentVideoL()
    {
    PlayVideoL();
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::DeleteVideosL()
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoListImpl::DeleteVideosL()
    {
    IPTVLOGSTRING_LOW_LEVEL( "MPX My Videos UI # CVcxHgMyVideosVideoListImpl::DeleteVideosL()" );
    RArray<TInt> operationTargetIndexes;
	RArray<TInt> operationTargetIds;
    CleanupClosePushL( operationTargetIndexes );
    CleanupClosePushL( operationTargetIds );
    
    GetOperationTargetIndexesL( operationTargetIndexes );
    OperationTargetsToMpxIdsL( operationTargetIndexes, operationTargetIds );

    if ( ConfirmDeleteVideosL( operationTargetIndexes.Count(),
                               iVideoModel->GetVideoName( operationTargetIds[0] ) ) )
        {
        HandleMarkCommandL( EVcxHgMyVideosCmdUnmarkAll );

        // Wait note is closed in destructor (CloseDeleteWaitNote()), 
        // in DialogDismissedL() or in VideoDeletionCompletedL().
        OpenDeleteWaitNoteL();

        TRAPD( err, iVideoModel->DeleteVideosL( operationTargetIds ) );
        
        if( err != KErrNone )
            {
            CloseDeleteWaitNote();
            }
        }

    CleanupStack::PopAndDestroy( &operationTargetIds );
    CleanupStack::PopAndDestroy( &operationTargetIndexes );
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::ConfirmDeleteVideosL()
// -----------------------------------------------------------------------------
//
TBool CVcxHgMyVideosVideoListImpl::ConfirmDeleteVideosL( TInt aTargetCount,
                                                         const TDesC& aTargetName )
    {
    HBufC* text = NULL;

    if ( aTargetCount == 1 )
        {
        text = StringLoader::LoadLC( R_VCXHGMYVIDEOS_QUERY_COMMON_CONF_DELETE, aTargetName );
        }
    else if ( aTargetCount > 1 )
        {
        text = StringLoader::LoadLC( R_VCXHGMYVIDEOS_FLDR_DEL_ITEMS_QUERY, aTargetCount );
        }

    if ( text )
        {
        CAknQueryDialog* dlg = CAknQueryDialog::NewL();

        TInt result = dlg->ExecuteLD( R_VCXHGMYVIDEOS_DELETE_CONFIRMATION_QUERY, *text );
        CleanupStack::PopAndDestroy( text );

        if ( result == EAknSoftkeyYes || result == EAknSoftkeyOk )
            {
            return ETrue;
            }
        }

    return EFalse;
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::OpenDeleteWaitNoteL()
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoListImpl::OpenDeleteWaitNoteL()
    {
    CloseDeleteWaitNote();

    iDeleteWaitDialog = new (ELeave) 
            CAknWaitDialog( ( REINTERPRET_CAST( CEikDialog**, &iDeleteWaitDialog ) ), ETrue );
    iDeleteWaitDialog->SetCallback( this );
    iDeleteWaitDialog->ExecuteLD( R_VCXHGMYVIDEOS_DELETING_WAIT_NOTE );
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::CloseDeleteWaitNote()
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoListImpl::CloseDeleteWaitNote()
    {
    if ( iDeleteWaitDialog )
        {
        TRAPD( error, iDeleteWaitDialog->ProcessFinishedL() );
        if ( error != KErrNone )
            {
            delete iDeleteWaitDialog;
            }
        iDeleteWaitDialog = NULL;
        }
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::CommandComplete()
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoListImpl::CommandComplete( TInt /*aStatusCode*/ )
    {
    // status larger than KErrNone does not require any attention.
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::DialogDismissedL()
// Callback about (delete) wait note dismissal.
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoListImpl::DialogDismissedL( TInt aButtonId )
    {
    if ( aButtonId == EAknSoftkeyCancel )
        {
        iModel.CollectionClient().CancelDeleteVideosL();
        }
    
    iDeleteWaitDialog = NULL;
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::VideoDeletionCompletedL()
// -----------------------------------------------------------------------------
// 
void CVcxHgMyVideosVideoListImpl::VideoDeletionCompletedL( TInt aFailedCount,
                                                           const TDesC& aFailedName )
    {
    CloseDeleteWaitNote();

    if ( aFailedCount > 0 )
        {
        HBufC* text = NULL;

        if ( aFailedCount == 1 )
            {
            text = StringLoader::LoadLC( R_VCXHGMYVIDEOS_FLDR_CANT_DELETE_FILE_OPEN, aFailedName );
            }
        else
            {
            text = StringLoader::LoadLC( R_VCXHGMYVIDEOS_CANT_DELETE_ITEMS );
            }

        CAknErrorNote* note = new ( ELeave ) CAknErrorNote( ETrue );
        note->ExecuteLD( *text );
        CleanupStack::PopAndDestroy( text );  
        }    
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::PlayVideoL()
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoListImpl::PlayVideoL()
    {
    RArray<TInt> operationTargets;
    CleanupClosePushL( operationTargets );
    
    GetOperationTargetIndexesL( operationTargets );
    HandleMarkCommandL( EVcxHgMyVideosCmdUnmarkAll );
    
    // Currently only play one video
    // Need to handle multiply selected videos
    for ( TInt i = operationTargets.Count() - 1; i >= 0; i-- )
        {
        if( !iUPnP->IsStarted() )
            {
            iVideoModel->PlayVideoL( operationTargets[i] );

            iModel.SetAppState( CVcxHgMyVideosModel::EVcxMyVideosAppStatePlayer );
            }
        else // UPnP started
            {
            TInt err(KErrNone); 
            
            err = iUPnP->ShowVideo( iVideoModel->GetVideoUri( operationTargets[0] ) );

            if( err != KErrNone )
                {
                // some general upnp framework error, 
                // call stop to deallocate
                iUPnP->Stop();
                }
            }        
        break;
        }
    
    CleanupStack::PopAndDestroy( &operationTargets );
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::HandleSortCommandL()
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoListImpl::HandleSortCommandL( TInt aSortCommand )
    {
    TVcxMyVideosSortingOrder currentOrder = iModel.VideolistSortOrderL();
    TVcxMyVideosSortingOrder wantedOrder( EVcxMyVideosSortingNone );
        
    switch ( aSortCommand )
        {
        case EVcxHgMyVideosCmdSortByDate:
            {
            wantedOrder = EVcxMyVideosSortingCreationDate;
            break;
            }
        case EVcxHgMyVideosCmdSortByName:
            {
            wantedOrder = EVcxMyVideosSortingName;
            break;
            }            
        case EVcxHgMyVideosCmdSortBySize:
            {
            wantedOrder = EVcxMyVideosSortingSize;
            break;
            }
        default:
            {
            User::Leave( KErrNotSupported );
            break;
            }
        }

    if ( currentOrder != wantedOrder )
        {
        iModel.SetVideolistSortOrderL( wantedOrder );
        iVideoModel->ResortVideoListL();
        }
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::ShowMarkMenuItemsL()
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoListImpl::ShowMarkMenuItemsL( 
        TBool& aShowMarkSubmenu,
        TBool& showStartMarking,
        TBool& showEndMarking, 
        TBool& aShowMarkAll,
        TBool& aShowUnmarkAll )
    {
    RArray<TInt> markedVideos;
    CleanupClosePushL( markedVideos );
    
    iVideoModel->MarkedVideosL( markedVideos );
    
    TInt count = iVideoModel->VideoCount();
    TInt highlight = Highlight();

    // Set menu visibility information.
    TBool markingMode( IsMarking() );
    showStartMarking = !markingMode;
    showEndMarking = markingMode;
    aShowMarkAll = ( ( count > 0 ) && ( markedVideos.Count() < count ) );
    aShowUnmarkAll = ( ( count > 0 ) && ( markedVideos.Count() > 0 ) );
    aShowMarkSubmenu = ( showStartMarking || showEndMarking || aShowMarkAll || aShowUnmarkAll );
    
    CleanupStack::PopAndDestroy( &markedVideos );
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::HandleMarkCommandL()
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoListImpl::HandleMarkCommandL( TInt aMarkCommand )
    {
    IPTVLOGSTRING_LOW_LEVEL( "MPX My Videos UI # CVcxHgMyVideosVideoListImpl::HandleMarkCommandL()" );
    
    switch ( aMarkCommand )
        {
        case EVcxHgMyVideosCmdToggleMultipleMarking:
            {
            StartMarkingMode();
            break;
            }
        case EVcxHgMyVideosCmdStopMarking:
            {
            iVideoModel->HandleMarkCommandL( EVcxHgMyVideosCmdUnmarkAll );
            EndMarkingMode();
            break;
            }
        case EVcxHgMyVideosCmdMark:
        case EVcxHgMyVideosCmdMarkAll:
            {
            iVideoModel->HandleMarkCommandL( aMarkCommand );
            StartMarkingMode();
            break;
            }
        case EVcxHgMyVideosCmdUnmark:
        case EVcxHgMyVideosCmdUnmarkAll:
            {
            iVideoModel->HandleMarkCommandL( aMarkCommand );
            EndMarkingMode();
            break;
            }
        case EVcxHgMyVideosCmdMarkContext:
            {
            iVideoModel->HandleMarkCommandL( EVcxHgMyVideosCmdMark );
            StartMarkingMode();
            break;
            }
        default:
            break;
        }
    
    iView.DynInitMskL();
    iView.DynInitRskL();
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::HandleMoveOrCopyCommandL() 
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoListImpl::HandleMoveOrCopyCommandL( TBool aCopy )
    {
    RArray<TInt> operationTargetIndexes;
	RArray<TInt> operationTargetIds;
    CleanupClosePushL( operationTargetIndexes );
    CleanupClosePushL( operationTargetIds );
    
    GetOperationTargetIndexesL( operationTargetIndexes );
    OperationTargetsToMpxIdsL( operationTargetIndexes, operationTargetIds );
    
    HandleMarkCommandL( EVcxHgMyVideosCmdUnmarkAll );
    iVideoCopier->MoveOrCopyL( operationTargetIds, aCopy );
    
    CleanupStack::PopAndDestroy( &operationTargetIds );
    CleanupStack::PopAndDestroy( &operationTargetIndexes );
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::VideoMoveOrCopyCompletedL()
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoListImpl::VideoMoveOrCopyCompletedL( TInt aFailedCount,
                                                             const TDesC& aFailedName )
    {
    iVideoCopier->VideoMoveOrCopyCompletedL( aFailedCount, aFailedName );
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::ShowResumeStartsFromBeginningNoteL() 
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoListImpl::ShowResumeStartsFromBeginningNoteL()
    {
    HBufC* text = StringLoader::LoadLC( R_VCXHGMYVIDEOS_RESUME_NOT_POSSIBLE );
    CAknInformationNote* note = new( ELeave ) CAknInformationNote( ETrue );
    note->ExecuteLD( *text );
    CleanupStack::PopAndDestroy( text );     
    }

// ------------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::DynInitMenuPaneL()
// ------------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoListImpl::DynInitMenuPaneL( TInt aResourceId,
                                                    CEikMenuPane* aMenuPane )
    {
#ifdef RD_VIDEO_AS_RINGING_TONE
    if ( AiwMenuHandlerL()->TryHandleSubmenuL( aMenuPane ) )
        {
        // Submenu was initialized by Aiw
        return;
        }
#endif

    if ( aResourceId == R_VCXHGMYVIDEOS_MAINVIEW_MENU )
        {
        // Check if list has videos marked
        RArray<TInt> markedVideos;
        CleanupClosePushL( markedVideos );
        iVideoModel->MarkedVideosL( markedVideos );
        TBool videosMarked = ( markedVideos.Count() > 0 );
        CleanupStack::PopAndDestroy( &markedVideos );

        TInt highlight = Highlight();
        TInt count = iVideoModel->VideoCount();

        // Show play menuitem for non-touch
        if ( ! iModel.TouchSupport() )
            {
            TBool showPlay = ( !videosMarked && ( highlight >= 0 ) && ( count > 0 ) );
            aMenuPane->SetItemDimmed( EVcxHgMyVideosCmdPlay, ! showPlay );
            }

        if ( count > 0 )
            {
            // Video details.
            TBool showVideoDetails = ( !videosMarked && highlight >= 0 );
            aMenuPane->SetItemDimmed( EVcxHgMyVideosCmdVideoDetails, !showVideoDetails );

            // UPnP menu item. Item's behaviour follows video details item.
            if ( showVideoDetails && iUPnP->IsApplicable() )
                {
                if ( iUPnP->IsStarted() )
                    {
                    aMenuPane->SetItemDimmed( EVcxHgMyVideosCmdStopShowViaHomenet, EFalse);
                    }
                else
                    {
                    aMenuPane->SetItemDimmed( EVcxHgMyVideosCmdShowViaHomenet, EFalse );
                    }
                }

            // Move, copy, delete
            DynInitMenuPaneFileOperationsL( aMenuPane, videosMarked );

            // Send item
            if ( highlight >= 0 || videosMarked )
                {
                AddSendItemToMenuPaneL( aMenuPane );
                }

#ifdef RD_VIDEO_AS_RINGING_TONE
            // Assign (use as) menu item
            if ( !videosMarked && highlight >= 0 )
                {
                aMenuPane->SetItemDimmed( EVcxHgMyVideosCmdAiwAssign, EFalse );
                }
            else
                {
                // Hide Assign (use as) menu item
                aMenuPane->SetItemDimmed( EVcxHgMyVideosCmdAiwAssign, ETrue );
                }
#endif

            // Marking submenu
            // Show "Mark/Unmark" only if there are videos in the list
            aMenuPane->SetItemDimmed( EVcxHgMyVideosCmdMarkUnmarkSubMenu, EFalse);
            }

        // "Sort by" submenu
        if( count == 0 )
            {
            // Dont show "Sort by" if list is empty.
            aMenuPane->SetItemDimmed( EVcxHgMyVideosCmdSortSubMenu, ETrue );
            }

        // Hide "Settings" menu item
        aMenuPane->SetItemDimmed( EVcxHgMyVideosCmdOpenSettings, ETrue );
        }

#ifdef RD_VIDEO_AS_RINGING_TONE
    else if ( aResourceId == R_VCXHGMYVIDEOS_USE_AS_SUBMENU )
        {
        RArray<TInt> operationTargets;
        CleanupClosePushL( operationTargets );

        GetOperationTargetIndexesL( operationTargets );
        if ( operationTargets.Count() > 0 )
            {
            HBufC* videoUri = iVideoModel->GetVideoUri( operationTargets[0] ).AllocLC();
            if ( videoUri->Length() 
                    && BaflUtils::FileExists( iModel.FileServerSessionL(), *videoUri ) )
                {
                AiwMenuHandlerL()->InitializeMenuPaneL(
                        aResourceId,
                        aMenuPane,
                        *videoUri,
                        KNullDesC );    //mime type
                }
            CleanupStack::PopAndDestroy( videoUri );
            }
        CleanupStack::PopAndDestroy( &operationTargets );
        }
#endif    
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::SetEmptyListTextL()
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoListImpl::SetEmptyListTextL()
    {
    CVcxHgMyVideosListBase::SetEmptyListTextByResourceL( R_VCXHGMYVIDEOS_OPENING_VIDEOS );
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::SetTitleTextL()
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoListImpl::SetTitleTextL( TInt aIndex )
    {
    switch ( aIndex )
        {
        case KVcxMvcCategoryIdAll:
            CVcxHgMyVideosListBase::SetTitleTextByResourceL( R_VCXHGMYVIDEOS_ALL_VIDEOS_TITLE );
            break;
        case KVcxMvcCategoryIdDownloads:
            CVcxHgMyVideosListBase::SetTitleTextByResourceL( R_VCXHGMYVIDEOS_DOWNLOADS_TITLE );
            break;
        case KVcxMvcCategoryIdCaptured:
            CVcxHgMyVideosListBase::SetTitleTextByResourceL( R_VCXHGMYVIDEOS_CAPTURED_TITLE );
            break;
        case KVcxMvcCategoryIdOther:
            CVcxHgMyVideosListBase::SetTitleTextByResourceL( R_VCXHGMYVIDEOS_OTHER_TITLE );
            break;
        default:
            {
            IPTVLOGSTRING_LOW_LEVEL(
                "MPX My Videos UI # ...VideoListImpl::SetTitleTextL() Unexpected category!" );
            }
            break;
        }
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::GetMskResourceL()
// -----------------------------------------------------------------------------
//
TInt CVcxHgMyVideosVideoListImpl::GetMskResourceL()
    {
    RArray<TInt> markedVideos;
    CleanupClosePushL( markedVideos );
    
    iVideoModel->MarkedVideosL( markedVideos );
    TInt highlight = Highlight();
    TInt count = iVideoModel->VideoCount();

    TBool showPlay = ( ( markedVideos.Count() == 0 ) && ( highlight >= 0 ) && ( count > 0 ) );
    
    CleanupStack::PopAndDestroy( &markedVideos );
    
    if ( showPlay )
        {
        return R_VCXHGMYVIDEOS_MSK_PLAY;
        }
    else if ( count == 0 )
        {
        return R_VCXHGMYVIDEOS_MSK_NOTHING;
        }
    else
        {
        return R_VCXHGMYVIDEOS_MSK_CONTEXTMENU;
        }
    }

// ---------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::StartMarkingMode()
// ---------------------------------------------------------------------------
//  
void CVcxHgMyVideosVideoListImpl::StartMarkingMode()
    {
    IPTVLOGSTRING2_LOW_LEVEL( "MPX My Videos UI # CVcxHgMyVideosVideoListImpl::StartMarkingMode() IsMarking = %d", IsMarking() );
    
    // Start multiple marking mode
    if ( iModel.TouchSupport() )
        {
        iScroller->SetFlags( CHgScroller::EHgScrollerSelectionMode );
        }
    }

// ---------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::EndMarkingMode()
// ---------------------------------------------------------------------------
//  
void CVcxHgMyVideosVideoListImpl::EndMarkingMode()
    {
    IPTVLOGSTRING2_LOW_LEVEL( "MPX My Videos UI # CVcxHgMyVideosVideoListImpl::EndMarkingMode() IsMarking = %d", IsMarking() );

    // End multiple marking mode
    iScroller->ClearFlags( CHgScroller::EHgScrollerSelectionMode );
    }

// ---------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::HandleSendL()
// ---------------------------------------------------------------------------
//  
void CVcxHgMyVideosVideoListImpl::HandleSendL()
    {
    IPTVLOGSTRING_LOW_LEVEL( "CVcxHgMyVideosVideoListImpl::HandleSendL() ENTER" );

    // Create message and disabled transports filter
    CMessageData* message = CMessageData::NewLC();
    CArrayFixFlat< TUid >* mtmFilter = new( ELeave ) CArrayFixFlat< TUid >( 1 );
    CleanupStack::PushL( mtmFilter );

    if ( MessagingConfL() & KMuiuEmailDisabledInMultimedia )
        {
        IPTVLOGSTRING_LOW_LEVEL( "CVcxHgMyVideosVideoListImpl::HandleSendL() send via email disabled" );
        // Send via email disabled in CenRep, add to filter to disable
        mtmFilter->AppendL( KSenduiMtmSmtpUid );
        mtmFilter->AppendL( KSenduiMtmSyncMLEmailUid );
        }

    // Get the selected video(s) and attach
    RArray<TInt> operationTargets;
    CleanupClosePushL( operationTargets );
    
    GetOperationTargetIndexesL( operationTargets );
    TInt64 attachmentsTotalSize( 0 );

    IPTVLOGSTRING2_LOW_LEVEL( "CVcxHgMyVideosVideoListImpl::HandleSendL() targets count: %d", operationTargets.Count() );
    for ( TInt i = 0; i < operationTargets.Count(); i++ )
        {
        HBufC* videoUri = iVideoModel->GetVideoUri( operationTargets[i] ).AllocLC();
        TInt64 videoSize = iVideoModel->GetVideoSize( operationTargets[i] );

        IPTVLOGSTRING3_LOW_LEVEL( "CVcxHgMyVideosVideoListImpl::HandleSendL() file: %S (%ld bytes)", videoUri, videoSize );

        // Attach file to message
        if ( videoUri->Length() > 0 && videoSize > 0 )
            {
            message->AppendAttachmentL( *videoUri );
            attachmentsTotalSize += videoSize;
            }

        CleanupStack::PopAndDestroy( videoUri );
        }

    // Send message if it has attachment(s)
    TSendingCapabilities capabilities( 0, attachmentsTotalSize, TSendingCapabilities::ESupportsAttachments );
    if ( message->AttachmentArray().MdcaCount() > 0 )
        {
        IPTVLOGSTRING_LOW_LEVEL( "CVcxHgMyVideosVideoListImpl::HandleSendL() send message" );
        SendUiL()->ShowQueryAndSendL( message, capabilities, mtmFilter, KNullUid, EFalse );
        HandleMarkCommandL( EVcxHgMyVideosCmdUnmarkAll );
        }

    CleanupStack::PopAndDestroy( &operationTargets );
    CleanupStack::PopAndDestroy( mtmFilter );
    CleanupStack::PopAndDestroy( message );

    IPTVLOGSTRING_LOW_LEVEL( "CVcxHgMyVideosVideoListImpl::HandleSendL() EXIT" );
    }

// ---------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::MessagingConfL()
// ---------------------------------------------------------------------------
//
TInt CVcxHgMyVideosVideoListImpl::MessagingConfL()
    {
    IPTVLOGSTRING_LOW_LEVEL( "CVcxHgMyVideosVideoListImpl::MessagingConfL()" );
    TInt messagingConf;
    CRepository* cenrep = CRepository::NewL( KCRUidMuiuMessagingConfiguration );
    TInt cenrepErr( cenrep->Get( KMuiuSendUiConfiguration, messagingConf ) );
    delete cenrep;
    User::LeaveIfError( cenrepErr );
    return messagingConf;
    }

// ---------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::SendUi()
// ---------------------------------------------------------------------------
//
CSendUi* CVcxHgMyVideosVideoListImpl::SendUiL()
    {
    if ( !iSendUi )
        {
        iSendUi = CSendUi::NewL();
        }
    return iSendUi;
    }

#ifdef RD_VIDEO_AS_RINGING_TONE
// ---------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::TryHandleAiwCommandL()
// ---------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoListImpl::TryHandleAiwCommandL( TInt aCommand )
    {
    if ( AiwMenuHandlerL()->IsAiwCommand( aCommand ) )
        {
        // Call AIW service handler
        RArray<TInt> operationTargets;
        CleanupClosePushL( operationTargets );
        
        GetOperationTargetIndexesL( operationTargets );
        if ( operationTargets.Count() > 0 )
            {
            HBufC* videoUri = iVideoModel->GetVideoUri( operationTargets[0] ).AllocLC();
            if ( videoUri->Length() )
                {
                AiwMenuHandlerL()->HandleAiwCommandL(
                        aCommand,
                        *videoUri,
                        KNullDesC );    //mime type
                }
            CleanupStack::PopAndDestroy( videoUri );
            }
        CleanupStack::PopAndDestroy( &operationTargets );
        }
    }
#endif

// ---------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::IsMarking()
// ---------------------------------------------------------------------------
//
TBool CVcxHgMyVideosVideoListImpl::IsMarking()
    {
    TBool ret( EFalse );
    
    if( iScroller->Flags() & CHgScroller::EHgScrollerSelectionMode )
        {
        ret = ETrue;
        }
    return ret;
    }

#ifdef RD_VIDEO_AS_RINGING_TONE
// ---------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::AiwMenuHandlerL()
// ---------------------------------------------------------------------------
//
CHgMyVideosAiwMenuHandler* CVcxHgMyVideosVideoListImpl::AiwMenuHandlerL()
    {
    if ( !iAiwMenuHandler )
        {
        iAiwMenuHandler = new (ELeave) CHgMyVideosAiwMenuHandler();
        iAiwMenuHandler->AttachMenuL( R_VCXHGMYVIDEOS_USE_AS_SUBMENU );
        }
    return iAiwMenuHandler;
    }
#endif

// ---------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::OperationTargetsToMpxIdsL()
// ---------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoListImpl::OperationTargetsToMpxIdsL( 
                                       RArray<TInt>& aOperationTargetIndexes,  
                                       RArray<TInt>& aOperationTargetIds )
    {
    for ( TInt i = 0; i < aOperationTargetIndexes.Count(); i++ )
        {
		if ( iVideoModel->GetVideoId( aOperationTargetIndexes[i] ) != KErrNotFound )
            {
            aOperationTargetIds.Append( iVideoModel->GetVideoId( aOperationTargetIndexes[i] ) );
            }
        }
    }

// ---------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::AddSendItemToMenuPaneL()
// ---------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoListImpl::AddSendItemToMenuPaneL( 
        CEikMenuPane* aMenuPane )
    {
    IPTVLOGSTRING_LOW_LEVEL( "CVcxHgMyVideosVideoListImpl::AddSendItemToMenuPaneL() enter" );
    // Get total size of the videos that we're about to send
    RArray<TInt> operationTargets;
    CleanupClosePushL( operationTargets );

    GetOperationTargetIndexesL( operationTargets );
    TInt64 attachmentsTotalSize( 0 );
    for ( TInt i = 0; i < operationTargets.Count(); i++ )
        {
        attachmentsTotalSize += iVideoModel->GetVideoSize( operationTargets[i] );
        }

    IPTVLOGSTRING3_LOW_LEVEL( "CVcxHgMyVideosVideoListImpl::AddSendItemToMenuPaneL() %d files with total size %ld", operationTargets.Count(), attachmentsTotalSize );

    // SendUi uses TInt for size, hide Send menu item for over 2GB attachments
    if ( attachmentsTotalSize > 0 && attachmentsTotalSize < KMaxTInt )
        {
        // Find place for Send menu item on top of "Use as" (Assign) or Sort submenu
        TInt sendItemIndex = 0;
#ifdef RD_VIDEO_AS_RINGING_TONE
        aMenuPane->ItemAndPos( EVcxHgMyVideosCmdAiwAssign, sendItemIndex );
#else
        aMenuPane->ItemAndPos( EVcxHgMyVideosCmdSortSubMenu, sendItemIndex );
#endif
        // Add Send item to context menu
        TSendingCapabilities capabilities(
            0,
            attachmentsTotalSize,
            TSendingCapabilities::ESupportsAttachments );
        SendUiL()->AddSendMenuItemL(
                *aMenuPane,
                sendItemIndex,
                EVcxHgMyVideosCmdSend,
                capabilities );
        aMenuPane->SetItemSpecific( EVcxHgMyVideosCmdSend, ETrue );
        // The Send item also needs to be flagged as a list query.
        CEikMenuPaneItem::SData& itemData = aMenuPane->ItemData( EVcxHgMyVideosCmdSend );
        itemData.iFlags |= EEikMenuItemSpecificListQuery;
        }
    CleanupStack::PopAndDestroy( &operationTargets );
    IPTVLOGSTRING_LOW_LEVEL( "CVcxHgMyVideosVideoListImpl::AddSendItemToMenuPaneL() return" );
    }

// ---------------------------------------------------------------------------
// CVcxHgMyVideosVideoListImpl::DynInitMenuPaneFileOperationsL()
// ---------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoListImpl::DynInitMenuPaneFileOperationsL(
        CEikMenuPane* aMenuPane,
        TBool aItemsMarked )
    {
    // Delete
    TBool showDelete = ( ( Highlight() >= 0 ) || aItemsMarked );

    // Move and copy
    RArray<TInt> operationTargets;
    CleanupClosePushL( operationTargets );

    TRAPD( error, GetOperationTargetIndexesL( operationTargets ) );

    TBool showMoveAndCopySubmenu( EFalse );
    TBool showCopy( EFalse );
    TBool showMove( EFalse );

    if ( error == KErrNone )
        {
        iVideoCopier->ShowMenuItemsL( operationTargets,
                                      showMoveAndCopySubmenu,
                                      showCopy,
                                      showMove );
        }

    aMenuPane->SetItemDimmed( EVcxHgMyVideosCmdCopy, !showCopy );
    aMenuPane->SetItemDimmed( EVcxHgMyVideosCmdMove, !showMove );
    aMenuPane->SetItemDimmed( EVcxHgMyVideosCmdDelete, !showDelete );

    CleanupStack::PopAndDestroy( &operationTargets );
    }