/*

* Copyright (c) 2010 Ixonos Plc.

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the "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:

* Ixonos Plc

*

* Description: 

*

*/

// INCLUDE FILES

// System includes

#include <aknviewappui.h>

#include <avkon.hrh>

#include <manualvideoeditor.rsg>

#include <VedAudioClipInfo.h>

#include <akntitle.h> 

#include <barsread.h>

#include <stringloader.h> 

#include <aknnotewrappers.h>

#include <aknquerydialog.h>

#include <aknnavide.h>

#include <eikbtgpc.h>

#include <eikmenub.h>

#include <eikmenup.h>

#include <eikprogi.h>

#include <apparc.h>

#include <aknselectionlist.h>

//User includes

#include "VeiAppUi.h"

#include "VeiCutAudioView.h"

#include "VeiCutAudioContainer.h" 

#include "ManualVideoEditor.hrh"

#include "VeiTimeLabelNavi.h"

#include "VideoEditorCommon.h"

#include "VeiVideoEditorSettings.h"

#include "VeiErrorUi.h"

CVeiCutAudioView* CVeiCutAudioView::NewL()

    {

    CVeiCutAudioView* self = CVeiCutAudioView::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

CVeiCutAudioView* CVeiCutAudioView::NewLC()

    {

    CVeiCutAudioView* self = new (ELeave) CVeiCutAudioView();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

CVeiCutAudioView::CVeiCutAudioView()

    {

    }

void CVeiCutAudioView::ConstructL()

    {

    BaseConstructL( R_VEI_CUT_AUDIO_VIEW );

    CEikStatusPane* sp = StatusPane();

    iNaviPane = (CAknNavigationControlContainer*) sp->ControlL(

            TUid::Uid(EEikStatusPaneUidNavi));

    iTimeNavi = CreateTimeLabelNaviL();

    iTimeNavi->SetMopParent( this );

    iVolumeNavi = iNaviPane->CreateVolumeIndicatorL(

            R_AVKON_NAVI_PANE_VOLUME_INDICATOR );

    iErrorUI = CVeiErrorUI::NewL( *iCoeEnv );   

    iTimeUpdater = CPeriodic::NewL( CActive::EPriorityLow );

    iVolumeHider = CPeriodic::NewL( CActive::EPriorityLow );

    }

// ---------------------------------------------------------

// CVeiCutAudioView::~CVeiCutAudioView()

// ?implementation_description

// ---------------------------------------------------------

//

CVeiCutAudioView::~CVeiCutAudioView()

    {

    if ( iContainer )

        {

        AppUi()->RemoveFromViewStack( *this, iContainer );

        delete iContainer;

        iContainer = 0;

        }

    if ( iTimeUpdater )

        {

        iTimeUpdater->Cancel();

        delete iTimeUpdater;

        }

    if ( iVolumeHider )

        {

        iVolumeHider->Cancel();

        delete iVolumeHider;

        }

    if ( iErrorUI )

        {

        delete iErrorUI;

        }

    delete iVolumeNavi;

    delete iTimeNavi;

    delete iCallBack;

    }

void CVeiCutAudioView::DynInitMenuPaneL( TInt aResourceId,CEikMenuPane* aMenuPane )

    {

    TInt state = iContainer->State();

    if (aResourceId == R_VEI_CUT_VIDEO_VIEW_MENU_CLEAR_MARKS)

        {

        // delet in, out, in & out as necessary.

        if (iMovie->AudioClipCutInTime(iIndex) <= TTimeIntervalMicroSeconds(0)) 

            {

            aMenuPane->SetItemDimmed(EVeiCmdCutVideoViewClearMarksIn, ETrue);

            }

        if (iMovie->AudioClipCutOutTime(iIndex) >= iMovie->AudioClipInfo(iIndex)->Duration() ) 

            {

            aMenuPane->SetItemDimmed(EVeiCmdCutVideoViewClearMarksOut, ETrue);

            }

        if (!((iMovie->AudioClipCutOutTime(iIndex) < iMovie->AudioClipInfo(iIndex)->Duration())

            && (iMovie->AudioClipCutInTime(iIndex) > TTimeIntervalMicroSeconds(0))))

            {

            aMenuPane->SetItemDimmed(EVeiCmdCutVideoViewClearMarksInOut, ETrue);

            }

        }

    if ( aResourceId == R_VEI_CUT_VIDEO_VIEW_MENU )

        {

        aMenuPane->SetItemDimmed( EVeiCmdCutVideoTakeSnapshot, ETrue );

        if ( iPopupMenuOpened != EFalse )

            {

            aMenuPane->SetItemDimmed( EVeiCmdCutVideoViewClearMarks, ETrue );

            aMenuPane->SetItemDimmed( EVeiCmdCutVideoViewHelp, ETrue );

            }

        if ( ( iMovie->AudioClipCutInTime( iIndex ) == TTimeIntervalMicroSeconds( 0 ) && 

            iMovie->AudioClipCutOutTime( iIndex ) == iMovie->AudioClipInfo( iIndex )->Duration() ) )

            {

            aMenuPane->DeleteMenuItem( EVeiCmdCutVideoViewPlayMarked );

            }

        if ( state != CVeiCutAudioContainer::EStatePlayingMenuOpen && 

            state != CVeiCutAudioContainer::EStatePaused )

            {

            aMenuPane->DeleteMenuItem( EVeiCmdCutVideoViewContinue );

            }

        if ( ( state == CVeiCutAudioContainer::EStateStopped ) ||

             ( state == CVeiCutAudioContainer::EStateStoppedInitial ) )

            {

            aMenuPane->DeleteMenuItem( EVeiCmdCutVideoViewStop );

            }

        if ( ( iMovie->AudioClipCutOutTime( iIndex ) >= iMovie->AudioClipInfo( iIndex )->Duration() ) &&

            ( iMovie->AudioClipCutInTime( iIndex ) <= TTimeIntervalMicroSeconds( 0 ) ) ) 

            {

            aMenuPane->SetItemDimmed( EVeiCmdCutVideoViewClearMarks, ETrue );

            }

        if ( state == CVeiCutAudioContainer::EStatePaused )

            {

            aMenuPane->SetItemDimmed( EVeiCmdCutVideoViewPlay, ETrue  );

            }

        if ( state == CVeiCutAudioContainer::EStateStoppedInitial )

            {

            //aMenuPane->SetItemDimmed( EVeiCmdCutVideoViewMarkIn, ETrue );

            //aMenuPane->SetItemDimmed( EVeiCmdCutVideoViewMarkOut, ETrue );    

            }

        }

    if ( aResourceId != R_VEI_CUT_VIDEO_VIEW_MENU )

        return;

    if ( ( state != CVeiCutAudioContainer::EStateStopped ) && 

        ( state != CVeiCutAudioContainer::EStateStoppedInitial ) &&

        ( state != CVeiCutAudioContainer::EStatePaused ) )

        {

        aMenuPane->SetItemDimmed( EVeiCmdCutVideoViewPlay, ETrue  );

        aMenuPane->SetItemDimmed( EVeiCmdCutVideoViewMarkIn, ETrue  );

        aMenuPane->SetItemDimmed( EVeiCmdCutVideoViewMarkOut, ETrue  ); 

        }

    else

        {

        if ( iContainer->PlaybackPositionL() <= iMovie->AudioClipCutInTime( iIndex ) )

            {

            aMenuPane->SetItemDimmed( EVeiCmdCutVideoViewMarkOut, ETrue );  

            }

        else 

            {

            if ( iContainer->PlaybackPositionL() >= iMovie->AudioClipCutOutTime( iIndex ) )

                {

                aMenuPane->SetItemDimmed( EVeiCmdCutVideoViewMarkIn, ETrue );

                }

            }

        }

    }

TUid CVeiCutAudioView::Id() const

    {

    return TUid::Uid( EVeiCutAudioView );

    }

void CVeiCutAudioView::HandleCommandL(TInt aCommand)

    {   

    switch ( aCommand )

        {

        case EAknSoftkeyOk:

            {

            iPopupMenuOpened = ETrue;

            if (iContainer->State() == CVeiCutAudioContainer::EStatePlaying) 

                {

                PausePreviewL();

                iContainer->SetStateL(CVeiCutAudioContainer::EStatePlayingMenuOpen);

                }

            MenuBar()->TryDisplayMenuBarL();

            if (iContainer->State() == CVeiCutAudioContainer::EStatePlayingMenuOpen) 

                {

                iContainer->SetStateL(CVeiCutAudioContainer::EStatePaused);

                }

            iPopupMenuOpened = EFalse;

            break;

            }       

        case EVeiCmdCutVideoViewDone:

        case EVeiCmdCutVideoViewBack:

        case EAknSoftkeyBack:

            {

            iContainer->CloseStreamL();

            StopNaviPaneUpdateL();

            // Activate Edit Video view

            AppUi()->ActivateLocalViewL( TUid::Uid(EVeiEditVideoView) );

            break;

            }

        case EVeiCmdCutVideoViewMarkIn:

            {

            MarkInL();

            break;

            }

        case EVeiCmdCutVideoViewMarkOut:

            {

            MarkOutL();

            break;

            }

        case EVeiCmdCutVideoViewClearMarksInOut:

            {

            ClearInOutL( ETrue, ETrue );

            break;

            }

        case EVeiCmdCutVideoViewClearMarksIn:

            {

            ClearInOutL( ETrue, EFalse );

            break;

            }

        case EVeiCmdCutVideoViewClearMarksOut:

            {

            ClearInOutL( EFalse, ETrue );

            break;

            }

        case EVeiCmdCutVideoViewPlayMarked:

            {

            STATIC_CAST( CVeiTimeLabelNavi*, iTimeNavi->DecoratedControl() )->

                SetPauseIconVisibilityL( EFalse );

            PlayMarkedL();

            break;

            }

        case EVeiCmdCutVideoViewPlay:

            {

            STATIC_CAST( CVeiTimeLabelNavi*, iTimeNavi->DecoratedControl() )->

                SetPauseIconVisibilityL( EFalse );

            iNaviPane->PushL( *iTimeNavi );

            PlayPreviewL();

            break;

            }

        case EVeiCmdCutVideoViewStop:

            {

            STATIC_CAST( CVeiTimeLabelNavi*, iTimeNavi->DecoratedControl() )->

                SetPauseIconVisibilityL( EFalse );

            iNaviPane->PushL( *iTimeNavi );

            iContainer->StopL();

            StopNaviPaneUpdateL();

            break;

            }

        case EVeiCmdCutVideoViewContinue:

            {

            STATIC_CAST( CVeiTimeLabelNavi*, iTimeNavi->DecoratedControl() )->

                SetPauseIconVisibilityL( EFalse );

            iNaviPane->PushL( *iTimeNavi );

            PlayPreviewL();

            break;

            }

        case EVeiCmdCutVideoVolumeDown:

            {

            if ( !iAudioMuted )

                {

                VolumeDownL();

                }

            break;

            }

        case EVeiCmdCutVideoVolumeUp:

            {

            if ( !iAudioMuted )

                {

                VolumeUpL();    

                }

            break;

            }

        //

        // Options->Help

        //

        case EVeiCmdCutVideoViewHelp:

            {

            // CS Help launching is handled in Video Editor's AppUi.

            AppUi()->HandleCommandL( EVeiCmdCutVideoViewHelp );

            break;

            }

        default:

            {

            AppUi()->HandleCommandL( aCommand );

            break;

            }

        }

    }

void CVeiCutAudioView::DoActivateL(

   const TVwsViewId& /*aPrevViewId*/,TUid /*aCustomMessageId*/,

   const TDesC8& /*aCustomMessage*/)

    {

    if (!iContainer)

        {

        iContainer = CVeiCutAudioContainer::NewL( AppUi()->ClientRect(), *this, *iErrorUI );

        iContainer->SetMopParent( this );

        AppUi()->AddToStackL( *this, iContainer );

        }

    CEikStatusPane *statusPane = ( ( CAknAppUi* )iEikonEnv->EikAppUi() )->StatusPane(); 

    CAknTitlePane* titlePane = (CAknTitlePane*) statusPane->ControlL( TUid::Uid( EEikStatusPaneUidTitle ) );

    TResourceReader reader1;

    iCoeEnv->CreateResourceReaderLC( reader1, R_VEI_CUTAUDIO_VIEW_TITLE_NAME );

    titlePane->SetFromResourceL( reader1 );

    CleanupStack::PopAndDestroy(); //reader1

    iNaviPane->PushL( *iTimeNavi );

    iAudioMuted = EFalse;

    STATIC_CAST( CVeiTimeLabelNavi*, iTimeNavi->DecoratedControl())->

        SetVolumeIconVisibilityL( ETrue );

    STATIC_CAST( CVeiTimeLabelNavi*, iTimeNavi->DecoratedControl() )->

            SetPauseIconVisibilityL( EFalse );

    iContainer->SetInTimeL( iMovie->AudioClipCutInTime( iIndex ) );

    iContainer->SetOutTimeL( iMovie->AudioClipCutOutTime( iIndex ) );

    iContainer->SetDuration( iMovie->AudioClipInfo( iIndex )->Duration() );

    // <testing>

/*  TTimeIntervalMicroSeconds time1 = iMovie->AudioClipInfo( iIndex )->Duration();

    TTimeIntervalMicroSeconds time2 = iMovie->AudioClipCutInTime( iIndex );

    TTimeIntervalMicroSeconds time3 = iMovie->AudioClipCutOutTime( iIndex );    

    TTimeIntervalMicroSeconds time4 = iMovie->AudioClipStartTime( iIndex );

    TTimeIntervalMicroSeconds time5 = iMovie->AudioClipEndTime( iIndex );

    TTimeIntervalMicroSeconds time6 = iMovie->AudioClipEditedDuration( iIndex );

    TTimeIntervalMicroSeconds time7(time3.Int64() - time2.Int64());

    TTimeIntervalMicroSeconds time8(time5.Int64() - time4.Int64());

*/  // </testing>

    // Start processing the file asynchronously. This is needed because

    // CVeiCutAudioContainer::OpenAudioFileL launches a progress dialog.

    // If it is called syncronously the previous view deactivation has 

    // not completed, and view shutter dismisses the progress dialog...

    if (! iCallBack)

        {       

        TCallBack cb (CVeiCutAudioView::AsyncOpenAudioFile, this);

        iCallBack = new (ELeave) CAsyncCallBack(cb, CActive::EPriorityStandard);

        }

    iCallBack->CallBack();

    iOriginalCutInTime = iMovie->AudioClipCutInTime( iIndex );

    DrawTimeNaviL();

    iErrorNmb = 0;      

    }

// ---------------------------------------------------------

// CVeiCutAudioView::AsyncOpenAudioFile

// ?implementation_description

// ---------------------------------------------------------

//

TInt CVeiCutAudioView::AsyncOpenAudioFile(TAny* aThis)

    {

    LOG( KVideoEditorLogFile, "CVeiCutAudioView::AsyncOpenAudioFile");

    // In the asynchronous version, trap the rest of the functions 

    // to make sure that the caller's TRequestStatus is always 

    // completed, also in case of failures.

    CVeiCutAudioView* view = static_cast<CVeiCutAudioView*>(aThis);

    TRAPD(err, view->OpenAudioFileL() );

    if (err)

        {

        // Display error message here, otherwise it would be quietly ignored.

        TBuf<256> unused;

        view->AppUi()->HandleError(err, SExtendedError(), unused, unused);

        }

    return err;

    }

// ---------------------------------------------------------

// CVeiCutAudioView::OpenAudioFileL()

// ?implementation_description

// ---------------------------------------------------------

//

void CVeiCutAudioView::OpenAudioFileL()

    {

    TFileName audioClipFileName = iMovie->AudioClipInfo( iIndex )->FileName();

    iContainer->OpenAudioFileL( audioClipFileName );

    }

// ---------------------------------------------------------

// CVeiCutAudioView::DoDeactivate()

// ?implementation_description

// ---------------------------------------------------------

//

void CVeiCutAudioView::DoDeactivate()

   {  

    iNaviPane->Pop( iVolumeNavi );

    if ( iTimeUpdater )

        {

        iTimeUpdater->Cancel();

        }

    if ( iVolumeHider )

        {

        iVolumeHider->Cancel();

        }

    if ( iContainer )

        {

        iNaviPane->Pop( iTimeNavi );

        AppUi()->RemoveFromViewStack( *this, iContainer );

        delete iContainer;

        iContainer = NULL;

        }

    }

void CVeiCutAudioView::SetVideoClipAndIndex( CVedMovie& aVideoClip, TInt aIndex )

    {

    iMovie = &aVideoClip;

    iIndex = aIndex;

    }

void CVeiCutAudioView::PlayPreviewL()

    {

    iPlayMarked = EFalse;

    StartNaviPaneUpdateL();

    iContainer->PlayL();

    }

void CVeiCutAudioView::PausePreviewL()

    {

    STATIC_CAST( CVeiTimeLabelNavi*, iTimeNavi->DecoratedControl() )->

        SetPauseIconVisibilityL( ETrue );

    StopNaviPaneUpdateL();

    iContainer->PauseL();

    }

void CVeiCutAudioView::UpdateCBAL(TInt aState)

    {

    switch (aState)

        {

        case CVeiCutAudioContainer::EStateInitializing:

        case CVeiCutAudioContainer::EStateOpening:

            {

            Cba()->SetCommandSetL(R_AVKON_SOFTKEYS_EMPTY); 

            break;

            }

        case CVeiCutAudioContainer::EStateStoppedInitial:

            {           

            if ( ( iMovie->AudioClipCutInTime( iIndex ) == TTimeIntervalMicroSeconds( 0 ) ) &&

                 ( iMovie->AudioClipCutOutTime( iIndex ) == iMovie->AudioClipInfo(iIndex)->Duration() ) )

                {       

                Cba()->SetCommandSetL(R_AVKON_SOFTKEYS_OPTIONS_BACK);   

                }

            else

                {                                                               

                Cba()->SetCommandSetL(R_VEI_SOFTKEYS_OPTIONS_DONE);             

                }

            break;          

            }

        case CVeiCutAudioContainer::EStatePaused:

        case CVeiCutAudioContainer::EStateStopped:

            {

            if ( ( iMovie->AudioClipCutInTime( iIndex ) == TTimeIntervalMicroSeconds( 0 ) ) &&

                 ( iMovie->AudioClipCutOutTime( iIndex ) == iMovie->AudioClipInfo(iIndex)->Duration() ) )