/*

* Copyright (c) 2005-2008 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: 

*

*/

/**

 @file

 @test

 @internalComponent - Internal Symbian test code 

*/

/**

This test depends on the following environment:

==========================================================================

== Required step - Install Xvid codec

==========================================================================

Note that these drivers are distributed under the GNU GENERAL PUBLIC LICENSE.

** Go to:

http://developer.symbian.com/wiki/display/pub/Open+source+projects

and get the XviD source zip:

http://developer.symbian.com/wiki/download/attachments/1154/xvid.zip

** Unzip this file and build the source in 

xvidhwdevice\group

xvidpu\group

==========================================================================

== Required step - Running on emulator - Modify epoc.ini and wsini.ini

==========================================================================

** Update your epoc.ini so that GCE is enabled. Add:

...

SYMBIAN_GRAPHICS_USE_GCE ON

SYMBIAN_BASE_USE_GCE ON

...

** Update your wsini.ini so that the following is present:

...

WINDOWMODE COLOR16MAP

KEYCLICKPLUGIN KeyClickRef

TRANSPARENCY

CHROMAKEYCOLOR 0xFFFF00FF

...

==========================================================================

== Required step - Running on hardware - Buildrom command

==========================================================================

** When building the rom, make sure you use the following flags

 buildrom 

 	<options> 

 	-DSYMBIAN_BASE_USE_GCE 

 	-DSYMBIAN_GRAPHICS_USE_GCE 

 	-DUSE_24BPP_DISPLAY_VARIANT

 	<further options/flags>

 	videoplay.iby

 	<further oby/iby files>

	 the xvid video drivers being installed in the runtime environment.

*/

#include "tuiandvideo.h"

#include <mmf/common/mmferrors.h>

#ifdef __WINS__

_LIT(KDefaultDirName, "c:\\videoplay\\");

#else

_LIT(KDefaultDirName, "e:\\videoplay\\");

#endif

_LIT(KDefaultFileExt, "*.avi");

_LIT(KDefaultFile, "skiing2.avi");

const TTimeIntervalMicroSeconds KTapTimeOut(300*1000);

const TTimeIntervalMicroSeconds32 KIdleTimeOut(1*1000*1000);

const TTimeIntervalMicroSeconds32 KPlayTimeOut(2*1000*1000);

const TTimeIntervalMicroSeconds32 KButtonTimeOut(2*1000*1000);

_LIT(KVideoAppBitmapsFile, "z:\\resource\\apps\\videoplay2.mbm");

//From videoplay.hrh

enum TTestCommands

    {

    ETestCmdOpen = 1000,

    ETestCmdStop,

    ETestCmdPlayFile

    };

//UIBench test step commands

enum TTestStepCommand

	{

    ETestCmdInitialised = 0,

    ETestCmdPlay,

    ETestCmdPause,

    ETestCmdBounce,

    ETestCmdJump,

    ETestCmdStill,

    ETestCmdExit

    };

// From videoplay.mbg

enum TMbmVideoplay

	{

	EMbmVideoplayBackground,

	EMbmVideoplayBackground_mask,

	};

/**

A command handler to act as an interface through which to drive the test.

@param aController	View controller, in the classic sense of MVC. This object

					is used to drive the test.

*/

CCommandSink::CCommandSink (CTestAppView* aTestView) :

	CActive(EPriorityStandard),

	iTestView (aTestView)

	{

	CActiveScheduler::Add(this);

	iStatus = KRequestPending;

 	SetActive();

	}

void CCommandSink::DoCancel()

	{

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status, KErrNone);

	}

CCommandSink::~CCommandSink()

	{

	Cancel();

	}

void CCommandSink::Init(RThread* aTargetThread, TRequestStatus* aTargetStatus)

	{

	iTargetThread = aTargetThread;

	iTargetStatus = aTargetStatus;

	}

/**

Signals the control thread (target) with a command. There must be a protocol between the

controller and the control (the test thread) in terms of communication of command 

signals. 

*/

void CCommandSink::RunL ()

	{

	switch (iStatus.Int())

		{

		case ETestCmdPlay:

			iTestView->PlayVideo();

			break;

		case ETestCmdPause:

			iTestView->PauseVideo();

			break;

		case ETestCmdBounce:

		case ETestCmdJump:

		case ETestCmdStill:

			iTestView->SetRunMode(iStatus.Int());

			break;

		}

	iStatus = KRequestPending;

 	SetActive();

	}

CTUiAndVideo::CTUiAndVideo()

	{

	SetTestStepName(KTUiAndVideo);

	}

void CTUiAndVideo::IssueCommand (TUint aCommand)

	{

	TRequestStatus* targetStatus = iAppUi->CommandSink();

	ConeThread()->RequestComplete(targetStatus, aCommand);

	}

void CTUiAndVideo::StepState (TUint aNextState, TUint aPause)

	{

	User::After(aPause);

	TRequestStatus* testState = &iTestState;

	User::RequestComplete (testState, aNextState);

	}

/**

   @SYMTestCaseID GRAPHICS-UI-BENCH-XXXX

   @SYMTestCaseDesc Put description here

   @SYMTestActions Put description here

   @SYMTestExpectedResults Put description here

*/

TVerdict CTUiAndVideo::doTestStepL()

	{

	iProfiler->InitResults();

	StepState(ETestCmdInitialised, 0);

	TBool continueTest = ETrue;

	while (continueTest)

		{

		User::WaitForRequest(iTestState);

		switch (iTestState.Int())

			{

			case ETestCmdInitialised:

				User::After(5000000);

			case ETestCmdPlay:

				IssueCommand(ETestCmdPlay);

				StepState(ETestCmdBounce, 5000000);

				break;

			case ETestCmdPause:

				break;

			case ETestCmdBounce:

				IssueCommand(ETestCmdBounce);

				StepState(ETestCmdJump, 15000000);

				break;

			case ETestCmdJump:

				IssueCommand(ETestCmdJump);

				StepState(ETestCmdExit, 15000000);

			case ETestCmdExit:

				continueTest = EFalse;

				break;

			default:

				continueTest = EFalse;

				RDebug::Printf("Invalid test state!");

			}

		}

	return TestStepResult();

	}

/**

Runs on test thread.

*/

void CTUiAndVideo::InitUIL(CCoeEnv* aCoeEnv)

	{

	iAppUi = new CTUiAndVideoAppUi();

   	iAppUi->ConstructL(iTestState);

   	aCoeEnv->SetAppUi(iAppUi);

  	}

//############################################################################################################

//############################################################################################################

//############################################################################################################

//############################################################################################################

//************************************************************************************************************

// Application UI implementation

// -- most control logic is here

//************************************************************************************************************

void SetCenter(TRect& aRect, const TPoint& aCenterPoint)

	{

	const TSize size = aRect.Size();

	const TPoint pos(aCenterPoint-TSize(size.iWidth/2,size.iHeight/2).AsPoint());

	aRect.SetRect(pos, size);

	}

void CTUiAndVideoAppUi::ConstructL(TRequestStatus /*iCommandSource*/)

	{

	BaseConstructL(ENoAppResourceFile);

	// Calculate the size of the application window

	// Make the player square, slightly (one 16th) smaller than 

	// the smallest side of the screen

	TRect rect (0, 0, 300, 150);

	TRect screenRect = iCoeEnv->ScreenDevice()->SizeInPixels();

	SetCenter(rect, screenRect.Center());	// Center the rect on the screen

	// Create the application view

	iAppView = CTestAppView::NewL(rect);

	AddToStackL(iAppView);

   	iCommandSink = new (ELeave) CCommandSink(iAppView);

	// Enable iIdleTimer to make the app return to foreground after a set delay

	iIdleTimer = CPeriodic::NewL(CActive::EPriorityStandard);

	// iUIMover moves the UI around the display.

	iUIMover   = CPeriodic::NewL(CActive::EPriorityStandard);

	iUIMover->Start(KIdleTimeOut, 50000, TCallBack(UIMoverCallBack, this));

	// Enable iPlayTimer to make the video pause a little while before starting playing again

	iPlayTimer = CPeriodic::NewL(CActive::EPriorityStandard);	

	iAppView->SetPos(&rect.iTl);

	iAppView->ActivateL();

	iAppView->DrawNow();

	// Load default video clip	

	if (KErrNone == PopulateDirFilesL(KDefaultDirName))

		{

		OpenSelectedFileL(KDefaultFile);

		}

	}

TRequestStatus* CTUiAndVideoAppUi::CommandSink ()

	{

	return &(iCommandSink->iStatus);

	}

CTUiAndVideoAppUi::~CTUiAndVideoAppUi()

	{

	if(iAppView)

		{

		RemoveFromStack(iAppView);

		delete iAppView;

		}

	delete iCommandSink;

	delete iIdleTimer;

	delete iUIMover;

	delete iPlayTimer;

	delete iLoadingPlayer;

	delete iDirList;

	}

TInt CTUiAndVideoAppUi::UIMoverCallBack(TAny* aSelf)

	{

	CTUiAndVideoAppUi* self = static_cast<CTUiAndVideoAppUi*>(aSelf);

	self->SetPos();

	return KErrNone;

	}

void CTUiAndVideoAppUi::SetPos()

	{

	iAppView->SetPos(NULL);

	}

TInt CTUiAndVideoAppUi::PopulateDirFilesL(const TDesC& aDir)

	{

	// Load files in default folder

	RFs fs;

	User::LeaveIfError(fs.Connect());

	// Get the file list, sorted by name - Only with KDefaultFileExt

	TFileName dir(aDir);

	dir.Append(KDefaultFileExt);

	delete iDirList;

	iDirList = NULL;

	TInt err = fs.GetDir(dir, KEntryAttMaskSupported, ESortByName, iDirList);

	fs.Close();

	if ((err == KErrPathNotFound) || (err == KErrNone && iDirList->Count()==0))

		{

		LogError(KNullDesC, _L("Default clip not found!"));

		return KErrNotFound;

		}

	__ASSERT_DEBUG(err==KErrNone, User::Panic(_L("PopulateDirFiles"), err));

	// set the current file with the current folder (for the time being)

	iCurrentFile.Zero();

	iCurrentFile.Append(aDir);

	return KErrNone;

	}

void CTUiAndVideoAppUi::OpenSelectedFileL(const TDesC& aFile)

	{

	__ASSERT_DEBUG(iDirList, User::Panic(_L("iDirList"), 0));

	TBool defaultFound = EFalse;

	for (iCurrentIndex=0; iCurrentIndex < iDirList->Count(); iCurrentIndex++)

		{

 		TFileName fileName = (*iDirList)[iCurrentIndex].iName;

 		if (fileName.Compare(aFile) ==0)

 			{

 			defaultFound = ETrue;

			break;

			}

		}

	if (!defaultFound)

		{

		// To avoid linking with eikcore.lib

		//iEikonEnv->InfoMsg(_L("Default file not found..."));

		iCurrentIndex = 0; // if no default, pick the first movie on the list

		}

	iCurrentFile.Append((*iDirList)[iCurrentIndex].iName);

	// play the selected file.

	HandleCommandL(ETestCmdOpen);

	}

TInt CTUiAndVideoAppUi::PlayNextFileL()

	{

	__ASSERT_DEBUG(iDirList, User::Panic(_L("iDirList"), 0));

	if (iCurrentIndex == (iDirList->Count()-1))

		{

		return KErrNotFound;

		}

	iCurrentIndex++;

	TParse file;

	file.Set(iCurrentFile, NULL, NULL);

	iCurrentFile = file.DriveAndPath();

	iCurrentFile.Append((*iDirList)[iCurrentIndex].iName);

	HandleCommandL(ETestCmdOpen);

	return KErrNone;

	}

TInt CTUiAndVideoAppUi::PlayPreviousFileL()

	{

	__ASSERT_DEBUG(iDirList, User::Panic(_L("iDirList"), 0));

	if (iCurrentIndex == 0)

		{

		return KErrNotFound;

		}

	iCurrentIndex--;

	TParse file;

	file.Set(iCurrentFile, NULL, NULL);

	iCurrentFile = file.DriveAndPath();

	iCurrentFile.Append((*iDirList)[iCurrentIndex].iName);

	HandleCommandL(ETestCmdOpen);

	return KErrNone;

	}

void CTUiAndVideoAppUi::LogError(const TDesC& /* aFileName */, const TDesC& /* aErrorMsg */)

	{

	// TODO: Fix this logging strategy.  Printf uses C-like pointers, not Symbian

	// descriptors

	//RDebug::Printf("Error: %s %s", aFileName, aErrorMsg);

	if(iAppView)

		iAppView->DisableVideo();

	}

void CTUiAndVideoAppUi::HandleForegroundEventL(TBool aForeground)

	{

	if(!aForeground && iIdleTimer)

		{

		if(!iIdleTimer->IsActive())

			iIdleTimer->Start(KIdleTimeOut, 0, TCallBack(BackgroundCallBack, this) );

		}

	}

TInt CTUiAndVideoAppUi::BackgroundCallBack(TAny* aSelf)

	{

	CTUiAndVideoAppUi* self = static_cast<CTUiAndVideoAppUi*>(aSelf);

	self->BringToForeground();

	return KErrNone;

	}

void CTUiAndVideoAppUi::BringToForeground()

	{

	iIdleTimer->Cancel();

	const TInt err = iCoeEnv->WsSession().SetWindowGroupOrdinalPosition(iCoeEnv->RootWin().Identifier(), 0);

	}

TInt CTUiAndVideoAppUi::PlayTimerCallBack(TAny* aSelf)

	{

	CTUiAndVideoAppUi* self = static_cast<CTUiAndVideoAppUi*>(aSelf);

	self->iPlayTimer->Cancel();

	self->iAppView->PlayVideo();

	self->iInitialised = ETrue;

	return KErrNone;

	}

void CTUiAndVideoAppUi::HandleCommandL(TInt aCommand)

	{

	switch (aCommand)

		{

		case ETestCmdOpen: // Open and prepare

			{

			iAppView->DisableVideo();

			if(iLoadingPlayer)

				{

				iLoadingPlayer->RemoveDisplayWindow(const_cast<RWindow&>(iAppView->TheWindow()));

				iLoadingPlayer->Close();

				delete iLoadingPlayer;

				iLoadingPlayer = NULL;

				}	

			iLoadingPlayer = CVideoPlayerUtility2::NewL(*this, EMdaPriorityNormal, EMdaPriorityPreferenceNone);

			iLoadingPlayer->OpenFileL(iCurrentFile);

			break;

			}

		case ETestCmdPlay: // Start playback

			iAppView->PlayVideo();

			break;

		case ETestCmdStop: // Stop playback

			iAppView->StopVideo();

			break;

		case ETestCmdPlayFile:

			break;

		case EEikCmdExit: // Exit

			if(iLoadingPlayer)

				iLoadingPlayer->RemoveDisplayWindow(const_cast<RWindow&>(iAppView->TheWindow()));

//			Exit();

			break;

		}

	}

// Video player utility callback: open complete

void CTUiAndVideoAppUi::MvpuoOpenComplete(TInt aError)

	{

	if (aError == KErrNone )

		{

		iLoadingPlayer->Prepare();

		}

	else if(aError == KErrNotFound)

		LogError(iCurrentFile, _L("Clip not found!"));

	else if(aError == KErrNotReady)

		LogError(iCurrentFile, _L("Clip not ready!"));

	else if(aError == KErrNotSupported)

		LogError(iCurrentFile, _L("Clip format not supported!"));

	else

		{

		User::Panic(_L("MvpuoOpen"), aError);

		}

	}

// Video player utility callback: prepare complete

void CTUiAndVideoAppUi::MvpuoPrepareComplete(TInt aError)

	{

	switch ( aError )

		{

		case KErrNone:

			{

			TBuf<256> loadingMsg(_L("Loading "));

			TParse file;

			file.Set(iCurrentFile, NULL, NULL);

			loadingMsg.Append(file.Name());

			TRAPD(err, iLoadingPlayer->AddDisplayWindowL(iEikonEnv->WsSession(), *iEikonEnv->ScreenDevice(), iAppView->TheWindow()));

			if(err == KErrInUse)

				LogError(iCurrentFile, _L("Window Display in use!"));

			else if(err == KErrNotReady)

				LogError(iCurrentFile, _L("Window Display not ready!"));

			else if(err)

				User::Panic(_L("PrepareComplete1"), err);

			iAppView->EnableVideo(iLoadingPlayer);

			}

			break;

		case KErrMMPartialPlayback:

			LogError(iCurrentFile, _L("Partial playback"));

			break;

		default:

			User::Panic(_L("Prepare"), aError);

		}

	}

// Video player utility callback, not used

void CTUiAndVideoAppUi::MvpuoFrameReady(CFbsBitmap& /*aFrame*/, TInt aError)

	{

	User::Panic(_L("FrameReady"), aError);

	}

// Video player utility callback: play complete (error or EOF)

void CTUiAndVideoAppUi::MvpuoPlayComplete(TInt aError)

	{

	iAppView->PlayComplete(aError);

	if (aError == KErrNone)

		{

		if(iPlayTimer && !iPlayTimer->IsActive())

			iPlayTimer->Start(KPlayTimeOut, 0, TCallBack(PlayTimerCallBack, this));

		}

	else if(aError == KErrNotSupported) 

		LogError(iCurrentFile, _L("Clip format not supported!"));

	else if(aError == KErrTooBig)

		LogError(iCurrentFile, _L("The clip is too big!"));

	else if(aError == KErrNoMemory)

		LogError(KNullDesC, _L("Out of memory. Likely memory leak!"));

	else if(aError == KErrNotReady)

		LogError(KNullDesC, _L("Clip not ready. Removed MMC?!"));

	else if (aError)

		User::Panic(_L("PlayComplete"), aError);

	}

//  Video player utility callback: event (not used?)

void CTUiAndVideoAppUi::MvpuoEvent(const TMMFEvent& aEvent)

	{

	User::Panic(_L("Event"), aEvent.iErrorCode);

	}

//************************************************************************************************************

// View implementation

// -- draws the display

//************************************************************************************************************

CTestAppView* CTestAppView::NewL(const TRect& aRect)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aRect);

	CleanupStack::Pop();

	return self;

	}

CTestAppView::~CTestAppView()

	{

	if(iCurrentPlayer)

		{

		iCurrentPlayer->RemoveDisplayWindow(TheWindow());

		iCurrentPlayer->Close();

		delete iCurrentPlayer;

		}

	delete iBkgrdImage;

	delete iBkgrdMask;

	}

CTestAppView::CTestAppView() :

	iIncrement (2, 2),

	iDirection (1, 1)

	{

	}

RWindow& CTestAppView::TheWindow()

	{

	__ASSERT_ALWAYS(iVideoPane, User::Panic(_L("TheWindow"), 0));	

	return iVideoPane->TheWindow();

	}

void CTestAppView::ConstructL(const TRect& aWindowedRect)

	{

	iWindowedViewRect = aWindowedRect;	// The rect used when the view is not full-screen

	CreateWindowL();

	EnableWindowTransparency();

	EnableDragEvents();

	Window().SetPointerGrab(ETrue);

	InitComponentArrayL();

	iVideoPane = new (ELeave) CVideoPane();

	Components().AppendLC(iVideoPane, KVideoControlID);

	iVideoPane->ConstructL(*this);

	CleanupStack::Pop(iVideoPane);

	SetRect(iWindowedViewRect);

	iBkgrdImage = new(ELeave) CFbsBitmap;

	User::LeaveIfError(iBkgrdImage->Load(KVideoAppBitmapsFile, EMbmVideoplayBackground));

	iBkgrdMask = new(ELeave) CFbsBitmap;

	User::LeaveIfError(iBkgrdMask->Load(KVideoAppBitmapsFile, EMbmVideoplayBackground_mask));

	ActivateL();

	}

void CTestAppView::SizeChanged() 

	{

	const TRect reservedVideoRect = VideoPaneRect();

	const TRect usedVideoRect = VideoPaneRect();

	if(iVideoPane)

		{

		iVideoPane->BlackoutPane();

		iVideoPane->SetRect(reservedVideoRect);

		if(iCurrentPlayer)

			SetVideoSize(*iCurrentPlayer);

		}

	}

/**

Sets the size and stretch characteristics of the video.

*/

void CTestAppView::SetVideoSize(CVideoPlayerUtility2& aVideo) const

	{

	const TRect videoRect(iVideoPane->Rect());

	CTUiAndVideoAppUi* myAppUi = dynamic_cast<CTUiAndVideoAppUi *>(iCoeEnv->AppUi());

	TRAPD(err, aVideo.SetWindowClipRectL(TheWindow(), videoRect));

	if(err == KErrArgument)

		myAppUi->LogError(KNullDesC, _L("Clip rect not within window!"));

	else if(err == KErrNotReady)

		myAppUi->LogError(KNullDesC, _L("Video not ready!"));

	else if(err)

		User::Panic(_L("SetVideoSize2"), err);

#if 1	

	TRAP(err, aVideo.SetAutoScaleL(TheWindow(), EAutoScaleStretch));

	if(err == KErrNotFound)

		myAppUi->LogError(KNullDesC, _L("Window not added to iLoadingPlayer!"));

	else if(err == KErrNotReady)

		myAppUi->LogError(KNullDesC, _L("Controller not been opened!"));

	else if(err)

		User::Panic(_L("SetVideoSize2"), err);

#endif

	iVideoPane->SetVideoUseRect(VideoPaneRect());

	}

/**

@return The rect of the video pane, relative to the view.

*/ 

TRect CTestAppView::VideoPaneRect() const

	{

	TRect result = Rect();

	// Make the video screen rect 10% smaller than the whole app window

	result.Shrink(result.Width()/10, result.Height()/10);

	return result;

	}

void CTestAppView::HandlePointerEventL(const TPointerEvent& aPointerEvent)

	{

	// call base class to dispatch any possible child events first

	// except we don't want to enter into a loop if this method has alraedy been

	// called from the video child control....

	if (!iVideoPane->IsVideoPanePointerEvent())

		CCoeControl::HandlePointerEventL(aPointerEvent);

	if(aPointerEvent.iType == TPointerEvent::EButton1Down)

		{

		// get the position (we may need to get the parent's if event came from video child control)

		iPointerDownPos = iVideoPane->IsVideoPanePointerEvent() ? aPointerEvent.iParentPosition : aPointerEvent.iPosition;

		TTime now;

		now.UniversalTime();

#if 0

		if(now.MicroSecondsFrom(iPointerDownTime) < KTapTimeOut)	// If quick double-tap

			{

			IgnoreEventsUntilNextPointerUp();

			ToggleViewSize();

			}

#endif

		iPointerDownTime.UniversalTime();

		}

	else if(aPointerEvent.iType == TPointerEvent::EDrag)

		{

		// Set new position relative to the amount of movement with pointer down event

		TPoint newPos = (iVideoPane->IsVideoPanePointerEvent() ? aPointerEvent.iParentPosition : aPointerEvent.iPosition) - iPointerDownPos;

		if(newPos != TPoint())

			SetPosition(Position()+newPos);

		}

	}

TKeyResponse CTestAppView::OfferKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType)

	{

	if(aType == EEventKey)

		{

		switch(aKeyEvent.iCode)

			{

			case EKeyEscape:

			// To avoid linking with eikcore.lib

			//if(iEikonEnv->QueryWinL(_L("Exit?"), _L("Sure you want to exit?")))

				{

				iEikonEnv->EikAppUi()->HandleCommandL(EEikCmdExit); 

				return EKeyWasConsumed;

				}

			case EKeyLeftArrow:

				PlayPrevious();

				return EKeyWasConsumed;

			case EKeyRightArrow:

				PlayNext();

				return EKeyWasConsumed;

			case EKeySpace:

				if (iIsPlaying)

					PauseVideo();

				else

					PlayVideo();

				return EKeyWasConsumed;

			case EKeyEnter:

				iRunMode = ETestCmdStill; 

				return EKeyWasConsumed;

			case EKeyTab:

				return EKeyWasConsumed;

			default:

				break;	

			}

		}

	return EKeyWasNotConsumed;	

	}

void CTestAppView::Draw(const TRect& /*aRect*/) const

	{

	CWindowGc& gc = SystemGc();

	// Fill the window solid

	gc.SetDrawMode(CGraphicsContext::EDrawModePEN);

	gc.SetBrushStyle(CGraphicsContext::ENullBrush);

	gc.DrawBitmapMasked(Rect(), iBkgrdImage, iBkgrdImage->SizeInPixels(), iBkgrdMask, EFalse);

	}

void CTestAppView::HandleControlEventL(CCoeControl */*aControl*/, TCoeEvent /*aEventType*/)

	{

	return;

	}

// Enable video

void CTestAppView::EnableVideo(CVideoPlayerUtility2*& aPlayer)

	{

	if(iCurrentPlayer)

		{

		iCurrentPlayer->RemoveDisplayWindow(TheWindow());

		iCurrentPlayer->Close();

		delete iCurrentPlayer;

		}	

	iCurrentPlayer = aPlayer;

	aPlayer = NULL;	// Take ownership

	const TSize oldSize = iNativeVideoSize;

	iCurrentPlayer->VideoFrameSizeL(iNativeVideoSize);

	SetVideoSize(*iCurrentPlayer);

	if (oldSize!=iNativeVideoSize)

		SizeChanged();

#if 0 

	// Was getting a crash at startup on the emulator...not sure why.

	// Not currently a requirement.

#ifdef SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT

	if (iCurrentPlayer->SubtitlesAvailable())

		{

		iCurrentPlayer->EnableSubtitlesL();

		iVideoPane->EnableSubtitle(iCurrentPlayer);

		}

#endif		

#endif

	PlayVideo();

	}

// Disable video

void CTestAppView::DisableVideo()

	{

	iVideoPane->BlackoutPane();

	PauseVideo();	// Stop playing

	if(iCurrentPlayer)

		{

		iCurrentPlayer->RemoveDisplayWindow(TheWindow());

		iCurrentPlayer->Close();

		delete iCurrentPlayer;

		}	

	iVideoPane->EnableSubtitle(NULL);

	iCurrentPlayer = NULL;

 	iNativeVideoSize = TSize();

	}

void CTestAppView::SetRunMode (TUint32 aMode)

	{

	iRunMode = aMode;

	}

void CTestAppView::PlayVideo()

	{

	if(iCurrentPlayer && !iIsPlaying)

		{

		iCurrentPlayer->Play();

		iIsPlaying = ETrue;

		}

	else

		iIsPlaying	= EFalse;	// Can't play if there's no player

	UpdateButtonState();

	DrawNow();

	}

void CTestAppView::PauseVideo()

	{

	if(iCurrentPlayer && iIsPlaying)

		{

		TRAPD(err, iCurrentPlayer->PauseL());

		if(err)

			iCurrentPlayer->Stop();

		}

	iIsPlaying = EFalse;	

	UpdateButtonState();

	DrawNow();

	}

void CTestAppView::StopVideo()

	{

	if(iCurrentPlayer && iIsPlaying)

		{

		iCurrentPlayer->Stop();

		iIsPlaying = EFalse;

		}

	else

		iIsPlaying	= ETrue;	// Can't play if there's no player

	UpdateButtonState();

	DrawNow();

	}

void CTestAppView::PlayComplete(TInt /*aError*/)

	{

	iIsPlaying	= EFalse;

	UpdateButtonState();

	DrawNow();

	}

void CTestAppView::PlayPrevious()

	{

	CTUiAndVideoAppUi* myAppUi = dynamic_cast<CTUiAndVideoAppUi *>(iCoeEnv->AppUi());

	if (myAppUi->PlayPreviousFileL() != KErrNone)

		{

		// To avoid linking with eikcore.lib

		//EikonEnv->InfoMsg(_L("First clip"));

		}

	}

void CTestAppView::PlayNext()

	{

	CTUiAndVideoAppUi* myAppUi = dynamic_cast<CTUiAndVideoAppUi*>(iCoeEnv->AppUi());

	if (myAppUi->PlayNextFileL() != KErrNone)

		{

		// To avoid linking with eikcore.lib

		//iEikonEnv->InfoMsg(_L("Last clip"));

		}

	}

void CTestAppView::UpdateButtonState()

	{

	}

/**

Calculate and set the position of the video UI. If iAutoPosition is zero then this

method is a no-op. 

*/

void CTestAppView::SetPos(TPoint* aPos)

	{

	if (!aPos)

		{

		TRect screenRect = iCoeEnv->ScreenDevice()->SizeInPixels();

		TSize currentSize = Size();

		TPoint currentPos = Position();

		switch (iRunMode)

			{

			case (ETestCmdBounce):

				{

				if ((currentPos.iX + (currentSize.iWidth >> 1)) > screenRect.iBr.iX)

					iDirection.iX = -1;

				if ((currentPos.iY + (currentSize.iHeight >> 1)) > screenRect.iBr.iY)

					iDirection.iY = -1;

				if ((currentPos.iX + (currentSize.iWidth >> 1)) < 0)

					iDirection.iX = 1;

				if ((currentPos.iY + (currentSize.iHeight >> 1)) < 0)

					iDirection.iY = 1;

				iVidPos.iX += iIncrement.iX* iDirection.iX;

				iVidPos.iY += iIncrement.iY * iDirection.iY;

				break;

				}

			case (ETestCmdJump):

				{

				iVidPos.iX = Math::Random() % 100;//(screenRect.iBr.iX + (currentSize.iWidth >> 1));

				iVidPos.iY = Math::Random() % 100;//(screenRect.iBr.iY + (currentSize.iHeight >> 1));

				break;

				}

			default:

				{} // Do nothing.			

			}

		}

	else

		{

		iVidPos = *aPos;

		}

	SetPosition(iVidPos);

	}

//************************************************************************************************************

//** CVideoPane class - place 'video' window.

//************************************************************************************************************

/**

This controll is used so that the video is not rendered onto transparency.  

*/

CVideoPane::~CVideoPane()

	{

	}

CVideoPane::CVideoPane()

	{

	}

void CVideoPane::ConstructL(CCoeControl& aParent)

	{

	CreateWindowL(&aParent);

	EnableDragEvents();

	Window().SetPointerGrab(ETrue);

	}