/*

* 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 <manualvideoeditor.rsg>

#include <videoeditoruicomponents.mbg>

#include <eikbtgpc.h>

#include <vedvideoclipinfo.h>

#include <coemain.h>

#include <eikenv.h>

#include <aknsbasicbackgroundcontrolcontext.h> 

#include <aknsdrawutils.h> 

#include <aknsdatacontext.h> 

#include <stringloader.h>

#include <aknnotewrappers.h> 

#include <pathinfo.h> 

#include <eikprogi.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <aknlayoutscalable_apps.cdl.h>

// User includes

#include "VeiAppUi.h"

#include "VeiCutterBar.h"

#include "VeiCutVideoContainer.h"

#include "VeiCutVideoView.h"

#include "veitextdisplay.h"

#include "VideoEditorHelp.hlp.hrh"  // Topic contexts (literals)

#include "VideoEditorCommon.h"

#include "VideoEditorUtils.h"

#include "VeiErrorUi.h"

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

void CleanupRarray( TAny* object )

    {

    (( RImageTypeDescriptionArray*)object)->ResetAndDestroy();

    }

CVeiCutVideoContainer* CVeiCutVideoContainer::NewL( const TRect& aRect, CVeiCutVideoView& aView, CVeiErrorUI& aErrorUI )

    {

    CVeiCutVideoContainer* self = CVeiCutVideoContainer::NewLC( aRect, aView, aErrorUI );

    CleanupStack::Pop( self );

    return self;

    }

CVeiCutVideoContainer* CVeiCutVideoContainer::NewLC( const TRect& aRect, CVeiCutVideoView& aView, CVeiErrorUI& aErrorUI )

    {

    CVeiCutVideoContainer* self = new (ELeave) CVeiCutVideoContainer( aRect, aView, aErrorUI );

    CleanupStack::PushL( self );

    self->ConstructL( aRect, aView, aErrorUI );

    return self;

    }

void CVeiCutVideoContainer::ConstructL( const TRect& aRect, CVeiCutVideoView& /*aView*/, CVeiErrorUI& /*aErrorUI*/ )

    {

    LOG(KVideoEditorLogFile, "CVeiCutVideoContainer::ConstructL: in");

    CreateWindowL();

    iInternalVolume = 0;

    iState = EStateInitializing;

    iFrameReady = EFalse;

    iPlayOrPlayMarked = EFalse;

    iSeekPos = TTimeIntervalMicroSeconds( 0 );

    iSeeking = EFalse;

    iCutVideoBar = CVeiCutterBar::NewL( this );

    iConverter = CVeiImageConverter::NewL( this );

    iTakeSnapshot = EFalse;

    iVideoDisplay = CVeiVideoDisplay::NewL( iDisplayRect, this, *this );

    iCutTimeDisplay = CVeiTextDisplay::NewL( iCutTimeDisplayRect, this );

    TFileName mbmPath( VideoEditorUtils::IconFileNameAndPath(KVideoEditorUiComponentsIconFileId) ); 

    AknIconUtils::CreateIconL( iPauseBitmap, iPauseBitmapMask,

            mbmPath, EMbmVideoeditoruicomponentsQgn_prop_ve_pause, 

            EMbmVideoeditoruicomponentsQgn_prop_ve_pause_mask );

    SetRect( aRect );

    iBgContext = CAknsBasicBackgroundControlContext::NewL( KAknsIIDQsnBgAreaMain, Rect(), EFalse );

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

    EnableDragEvents();

    ActivateL();

    LOG(KVideoEditorLogFile, "CVeiCutVideoContainer::ConstructL: out");

    }

CVeiCutVideoContainer::CVeiCutVideoContainer( const TRect& /*aRect*/, CVeiCutVideoView& aView, CVeiErrorUI& aErrorUI ):iView( aView ), iErrorUI( aErrorUI )

    {

    }

CVeiCutVideoContainer::~CVeiCutVideoContainer()

    {

    if ( iCutVideoBar )

        {

        delete iCutVideoBar;

        }

    if ( iBgContext )

        {

        delete iBgContext;

        }

    if ( iVideoDisplay )

        {

        delete iVideoDisplay;

        }

    if ( iCutTimeDisplay )

        {

        delete iCutTimeDisplay;

        }

    if ( iVideoClipInfo )

        {

        delete iVideoClipInfo;

        iVideoClipInfo = NULL;

        }

    if ( iConverter )

        {

        iConverter->Cancel();

        delete iConverter;

        }

    if ( iVideoBarTimer )

        {

        iVideoBarTimer->Cancel();

        delete iVideoBarTimer;

        }

    if ( iProgressDialog )

        {

        delete iProgressDialog;

        iProgressDialog = NULL;

        }

    if ( iSaveToFileName )

        {

        delete iSaveToFileName;

        iSaveToFileName = NULL;

        }

    delete iPauseBitmap;

    delete iPauseBitmapMask;

    delete iRemConTarget;

    delete iCallBackSaveSnapshot;

    delete iCallBackTakeSnapshot;

    }

void CVeiCutVideoContainer::DialogDismissedL( TInt aButtonId )

    {

    if ( aButtonId == -1 )

        { // when pressing cancel button.

        CancelSnapshotSave();

        }

    iTakeSnapshot = EFalse;

    }

void CVeiCutVideoContainer::SizeChanged()

    {

    LOG(KVideoEditorLogFile, "CVeiCutVideoContainer::SizeChanged(): In");

	TSize videoScreenSize;

    TRect rect( Rect() ); 

	if ( iBgContext )

		{

		iBgContext->SetRect( rect );

		}

	LOGFMT2(KVideoEditorLogFile, "CVeiCutVideoContainer::SizeChanged(): Rect(): %d,%d", rect.iBr.iX, rect.iBr.iY);

	// Scissor icon

	TAknLayoutRect scissorsIconLayout;

	scissorsIconLayout.LayoutRect(Rect(),AknLayoutScalable_Apps::main_vded_pane_g1());

	iCutVideoBar->SetComponentRect(CVeiCutterBar::EScissorsIcon, scissorsIconLayout.Rect());

	// Progress bar

	TAknLayoutRect progressBarLayout; 

	progressBarLayout.LayoutRect(Rect(),AknLayoutScalable_Apps::vded_slider_pane());

	iCutVideoBar->SetComponentRect(CVeiCutterBar::EProgressBar, progressBarLayout.Rect());

	// left end of the slider when that part is unselected

	TAknLayoutRect sliderLeftEndLayout;

	sliderLeftEndLayout.LayoutRect( progressBarLayout.Rect(),AknLayoutScalable_Apps::vded_slider_pane_g3() );

	iCutVideoBar->SetComponentRect( CVeiCutterBar::ESliderLeftEndIcon, sliderLeftEndLayout.Rect() );

	// middle part of the slider when that part is unselected	

	TAknLayoutRect sliderMiddleLayout;

	sliderMiddleLayout.LayoutRect(progressBarLayout.Rect(),AknLayoutScalable_Apps::vded_slider_pane_g5());

	iCutVideoBar->SetComponentRect( CVeiCutterBar::ESliderMiddleIcon, sliderMiddleLayout.Rect() );		

	// right end of the slider when that part is unselected

	TAknLayoutRect sliderRightEndLayout;

	sliderRightEndLayout.LayoutRect(progressBarLayout.Rect(),AknLayoutScalable_Apps::vded_slider_pane_g4());

	iCutVideoBar->SetComponentRect( CVeiCutterBar::ESliderRightEndIcon, sliderRightEndLayout.Rect() );	

	// left end of the cut selection slider 

	TAknLayoutRect sliderSelectedLeftEndLayout;

	sliderSelectedLeftEndLayout.LayoutRect(progressBarLayout.Rect(),AknLayoutScalable_Apps::vded_slider_pane_g3());

	iCutVideoBar->SetComponentRect( CVeiCutterBar::ESliderSelectedLeftEndIcon, sliderSelectedLeftEndLayout.Rect() );

	// middle part of the cut selection slider 

	TAknLayoutRect sliderSelectedMiddleLayout;

	sliderSelectedMiddleLayout.LayoutRect(progressBarLayout.Rect(),AknLayoutScalable_Apps::vded_slider_pane_g5());

	iCutVideoBar->SetComponentRect( CVeiCutterBar::ESliderSelectedMiddleIcon, sliderSelectedMiddleLayout.Rect() );		

	// right end of the cut selection slider 

	TAknLayoutRect sliderSelectedRightEndLayout;

	sliderSelectedRightEndLayout.LayoutRect(progressBarLayout.Rect(),AknLayoutScalable_Apps::vded_slider_pane_g4());

	iCutVideoBar->SetComponentRect( CVeiCutterBar::ESliderSelectedRightEndIcon, sliderSelectedRightEndLayout.Rect() ); 

    // playhead

    TAknLayoutRect playheadLayout;

	playheadLayout.LayoutRect(progressBarLayout.Rect(),AknLayoutScalable_Apps::vded_slider_pane_g1());

	iCutVideoBar->SetComponentRect( CVeiCutterBar::EPlayheadIcon, playheadLayout.Rect() ); 

    // left/right border of cut selection slider

    TAknLayoutRect cutAreaBorderLayout;

	cutAreaBorderLayout.LayoutRect(progressBarLayout.Rect(),AknLayoutScalable_Apps::vded_slider_pane_g2());

	iCutVideoBar->SetComponentRect( CVeiCutterBar::ECutAreaBorderIcon, cutAreaBorderLayout.Rect() ); 

	// Start cut time text

	TAknLayoutText startTimeTextLayout;

	startTimeTextLayout.LayoutText(rect, AknLayoutScalable_Apps::main_vded_pane_t1() );

	iCutTimeDisplay->SetComponentRect(CVeiTextDisplay::EStartTimeText, startTimeTextLayout.TextRect());

	// End cut time text

	TAknLayoutText endTimeTextLayout;

	endTimeTextLayout.LayoutText(rect, AknLayoutScalable_Apps::main_vded_pane_t2() );

	iCutTimeDisplay->SetComponentRect(CVeiTextDisplay::EEndTimeText, endTimeTextLayout.TextRect());

	// Start cut time icon

	TAknLayoutRect startTimeIconLayout;

	startTimeIconLayout.LayoutRect(rect, AknLayoutScalable_Apps::main_vded_pane_g2() );

	iCutTimeDisplay->SetComponentRect(CVeiTextDisplay::EStartTimeIcon, startTimeIconLayout.Rect());

	// End cut time icon

	TAknLayoutRect endTimeIconLayout;

	endTimeIconLayout.LayoutRect(rect, AknLayoutScalable_Apps::main_vded_pane_g3() );

	iCutTimeDisplay->SetComponentRect(CVeiTextDisplay::EEndTimeIcon, endTimeIconLayout.Rect());

	// Pause icon

	// Video Display	

	TAknLayoutRect videoDisplayLayout;

	videoDisplayLayout.LayoutRect(Rect(),AknLayoutScalable_Apps::vded_video_pane());

	iVideoDisplay->SetRect(videoDisplayLayout.Rect());

	iDisplayRect = videoDisplayLayout.Rect();	

	iIconDisplayRect = videoDisplayLayout.Rect();

	LOGFMT2(KVideoEditorLogFile, "CVeiCutVideoContainer::SizeChanged(): iDisplayRect: %d,%d", iDisplayRect.iBr.iX, iDisplayRect.iBr.iY);

	//CVeiCutterBar

	// : Change this when LAF data is ready

	TPoint cutBarTl = TPoint(STATIC_CAST( TInt, rect.iBr.iX*0.0114 ),

		STATIC_CAST( TInt, rect.iBr.iY*0.875 ) );

	TSize cutBarSize = TSize(STATIC_CAST( TInt, rect.iBr.iX*0.9773 ),

		STATIC_CAST( TInt, rect.iBr.iY*0.0973 ) );

	TRect cutBarRect( cutBarTl, cutBarSize );

	iCutVideoBar->SetRect( cutBarRect );

	//CVeiTextDisplay

	// : Change this when LAF data is ready

	TPoint cutTimeDisplayTl = TPoint(cutBarTl.iX,

		STATIC_CAST( TInt, rect.iBr.iY*0.757 ) );

	TSize cutTimeDisplaySize = TSize(cutBarSize.iWidth,

		STATIC_CAST( TInt, rect.iBr.iY*0.0903 ) );

	iCutTimeDisplayRect = TRect( cutTimeDisplayTl, cutTimeDisplaySize );

	iCutTimeDisplay->SetRect( iCutTimeDisplayRect );

	iCutTimeDisplay->SetLayout( CVeiTextDisplay::ECutInCutOut );

	TInt iconWidth = STATIC_CAST( TInt, rect.iBr.iX * 0.07954545455 );

	AknIconUtils::SetSize( iPauseBitmap, TSize(iconWidth,iconWidth), EAspectRatioNotPreserved );

    LOG(KVideoEditorLogFile, "CVeiCutVideoContainer::SizeChanged(): Out");

    }

TTypeUid::Ptr CVeiCutVideoContainer::MopSupplyObject( TTypeUid aId )

    {

    if ( aId.iUid == MAknsControlContext::ETypeId && iBgContext )

        {

        return MAknsControlContext::SupplyMopObject( aId, iBgContext );

        }

    return CCoeControl::MopSupplyObject( aId );

    }

TInt CVeiCutVideoContainer::CountComponentControls() const

    {

    return 3; 

    }

CCoeControl* CVeiCutVideoContainer::ComponentControl( TInt aIndex ) const

    {

    switch ( aIndex )

        {

        case 0:

            return iCutVideoBar;

        case 1:

            return iVideoDisplay;

        case 2:

            return iCutTimeDisplay;

        default:

            return NULL;

        }

    }

void CVeiCutVideoContainer::Draw( const TRect& aRect ) const

    {

    CWindowGc& gc = SystemGc();

    // draw skin background

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    MAknsControlContext* cc = AknsDrawUtils::ControlContext( this );    

    AknsDrawUtils::Background( skin, cc, this, gc, aRect );

    if ( EStatePaused == iState )

        {       

        TPoint pauseIconTl = TPoint( iIconDisplayRect.iTl.iX - STATIC_CAST( TInt, Rect().iBr.iX*0.105),

            iIconDisplayRect.iTl.iY + STATIC_CAST( TInt, Rect().iBr.iY*0.178 ));

        gc.BitBltMasked( pauseIconTl, iPauseBitmap, 

            TRect( TPoint(0,0), iPauseBitmap->SizeInPixels() ), 

            iPauseBitmapMask, EFalse );

        }

    }

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

// CVeiCutVideoContainer::GetHelpContext(...) const

//

// Gets the control's help context. Associates the control with a particular

// Help file and topic in a context sensitive application.

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

//

void CVeiCutVideoContainer::GetHelpContext( TCoeHelpContext& aContext ) const

    {

    LOG(KVideoEditorLogFile, "CVeiCutVideoContainer::GetHelpContext(): In");

    // Set UID of the CS Help file (same as application UID).

    aContext.iMajor = KUidVideoEditor;

    // Set the context/topic.

    aContext.iContext = KVED_HLP_CUT_VIDEO_VIEW;

    LOG(KVideoEditorLogFile, "CVeiCutVideoContainer::GetHelpContext(): Out");

    }

void CVeiCutVideoContainer::HandleControlEventL(

    CCoeControl* /*aControl*/,TCoeEvent /*aEventType*/)

    {

    }

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

// CVeiCutVideoContainer::HandlePointerEventL

// From CCoeControl

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

//		

void CVeiCutVideoContainer::HandlePointerEventL( const TPointerEvent& aPointerEvent )

	{

	LOG( KVideoEditorLogFile, "CVeiCutVideoContainer::HandlePointerEventL(): In" );

	if( AknLayoutUtils::PenEnabled() && iCutVideoBar )

		{

		CCoeControl::HandlePointerEventL( aPointerEvent );

		switch( aPointerEvent.iType )

			{

			case TPointerEvent::EButton1Down:

				{

				iIsMarkDrag = EFalse;

				iIsMarkTapped = EFalse;

				TRect startMarkRect = iCutVideoBar->StartMarkRect();

				TRect endMarkRect = iCutVideoBar->EndMarkRect();				

				// check if the pen goes down inside the start mark

				if (startMarkRect.Contains(aPointerEvent.iPosition)) 

					{

					iIsMarkTapped = ETrue;

					iTappedMark = EStartMark;

					}

				// check if the pen goes down inside the end mark	

				else if (endMarkRect.Contains(aPointerEvent.iPosition))

					{

					iIsMarkTapped = ETrue;

					iTappedMark = EEndMark;

					}					

				TRect progressBarRect(iCutVideoBar->ProgressBarRect());	

				// check if the pen goes down inside the progress bar				

				if( progressBarRect.Contains( aPointerEvent.iPosition ) )

					{

					iIsMarkDrag = EFalse;					

					}

				break;

				}

			case TPointerEvent::EDrag:

				{

				TRect progressBarRect(iCutVideoBar->ProgressBarRect());

				if ( progressBarRect.Contains( aPointerEvent.iPosition ) )

				{

					if (iIsMarkTapped)

						{

						iIsMarkDrag = ETrue;

						HandleProgressBarTouchL( progressBarRect, 

												 aPointerEvent.iPosition.iX,

												 ETrue,

												 iTappedMark );

						}

					else 

						{

						HandleProgressBarTouchL( progressBarRect, 

												 aPointerEvent.iPosition.iX,

												 EFalse);

						}

				}

				break;		

				}

			case TPointerEvent::EButton1Up:

				{

				// pen up event is handled if it wasn't dragged

				if (!iIsMarkDrag)

					{

					TRect progressBarRect(iCutVideoBar->ProgressBarRect());					

					// Check if pressed position is in progress bar's rect

					if( progressBarRect.Contains( aPointerEvent.iPosition ) )

						{

						HandleProgressBarTouchL( progressBarRect, 

											 aPointerEvent.iPosition.iX,

											 EFalse);

						}

					}

				break;

				}		

			default:

				{

				break;	

				}	

			}

		}	

	LOG( KVideoEditorLogFile, "CVeiCutVideoContainer::HandlePointerEventL(): Out" );		

	}

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

// CVeiCutVideoContainer::HandleProgressBarTouchL

// 

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

//	

void CVeiCutVideoContainer::HandleProgressBarTouchL( TRect aPBRect, 

												 TInt aPressedPoint,

												 TBool aDragMarks,

												 CVeiCutVideoContainer::TCutMark aCutMark )

	{

	if (( AknLayoutUtils::PenEnabled() ) && ( iState!=EStateInitializing ))

		{	

		LOG(KVideoEditorLogFile, "CVeiCutVideoContainer::HandleProgressBarTouchL(): In");

		if ( iState == EStatePlaying )		

			{

			StopL();	

			}

		// Progress Bar start and end points, and length

		TInt pbEndPoint( aPBRect.iBr.iX );

		TInt pbStartPoint = ( aPBRect.iTl.iX );		

		TInt totalPBLength( pbEndPoint - pbStartPoint );

		// calculate the time position from the tapped progress bar coordinates 

		TTimeIntervalMicroSeconds newPosition( 

										( ( aPressedPoint - pbStartPoint ) * 

							  			iVideoClipInfo->Duration().Int64() ) / 

							  			totalPBLength );

		// move cut marks

		if (aDragMarks)

		{

			// check that the start mark doesn't go past the end mark

			// and not to the beginning			

			if ((aCutMark == EStartMark) && 

			    (newPosition.Int64() > 0) &&

				(aPressedPoint < iCutVideoBar->EndMarkPoint() - 2*iCutVideoBar->EndMarkRect().Width()))

				{				

				iView.MoveStartOrEndMarkL(newPosition, EStartMark);				

				iCutVideoBar->SetInPoint( newPosition	);

				iCutTimeDisplay->SetCutIn( newPosition );

				}

			// check that the end mark doesn't go before the start mark	

			// and not too close to the beginning			

			else if ((aCutMark == EEndMark) && 

				(newPosition.Int64() >= KMinCutVideoLength) &&			

				(aPressedPoint > iCutVideoBar->StartMarkPoint() + 2*iCutVideoBar->StartMarkRect().Width()))

				{				

				iView.MoveStartOrEndMarkL(newPosition, EEndMark);				

				iCutVideoBar->SetOutPoint( newPosition	);

				iCutTimeDisplay->SetCutOut( newPosition );

				}

		}

		// move playhead

		else if (( newPosition != iLastPosition ) && !aDragMarks)

			{

			iLastPosition = newPosition;

			iSeekPos = TTimeIntervalMicroSeconds( newPosition );

			iCutVideoBar->SetCurrentPoint(( static_cast<TInt32>(iSeekPos.Int64() / 1000) ));

			iVideoDisplay->SetPositionL( iSeekPos );