// Copyright (c) 1997-2009 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:

//

#include <barsread.h>

#include <eikenv.h>

#include <eikinfo.h>

#include <techview/eikon.rsg>

#include <eikpriv.rsg>

#include <Mda\Client\Video.h>

#include "tvideo.h"

#include <hal.h> // for screen size info

#include <hal_data.h>

const TInt KVideoMinZoomFactor = -3;

const TInt KVideoMaxZoomFactor = 0;

// #define __USE_PURE_SCALING // fine scaling scales to 1/2, 1/4 and 1/8 - check non-universal scaling

//

//  CVideoAppUi

//

void CVideoAppUi::ConstructL()

    {

	CEikAppUi::ConstructL();

    iAppView = new(ELeave) CVideoAppView;

    iAppView->ConstructL(ClientRect());

	AddToStackL(iAppView);

	// find out the twips per pixel ratios for use on resizing.

	TSize displayPixels, displayTwips;

	User::LeaveIfError(HAL::Get(HALData::EDisplayXPixels, displayPixels.iWidth));

	User::LeaveIfError(HAL::Get(HALData::EDisplayYPixels, displayPixels.iHeight));

	User::LeaveIfError(HAL::Get(HALData::EDisplayXTwips, displayTwips.iWidth));

	User::LeaveIfError(HAL::Get(HALData::EDisplayYTwips, displayTwips.iHeight));

	iDisplayXTwipsPerPixel = TReal(displayTwips.iWidth) / displayPixels.iWidth;

	iDisplayYTwipsPerPixel = TReal(displayTwips.iHeight) / displayPixels.iHeight;

	ASSERT(iDisplayXTwipsPerPixel>0 && iDisplayXTwipsPerPixel>0);

	::new(&iFrame) CWsBitmap(CEikonEnv::Static()->WsSession());

	::new(&iMask) CWsBitmap(CEikonEnv::Static()->WsSession());

	iAppView->iBitmap = &iFrame;

	iAppView->iMask = &iMask;

	iLoadUtil = CMdaImageFileToBitmapUtility::NewL(*this,NULL);

	iSaveUtil = CMdaImageBitmapToFileUtility::NewL(*this,NULL);

	iRotator = CMdaBitmapRotator::NewL();

	iScaler = CMdaBitmapScaler::NewL();

	iBackgroundColor = KRgbWhite.Color16();

	iSaveInfo.iType = 2;

	iSaveInfo.iBpp = 6;

	iSaveInfo.iColor = ETrue;

	iSaveInfo.iQualityFactor = 40;

	iSaveInfo.iSampling = 2;

	}

CVideoAppUi::~CVideoAppUi()

	{

	iFrame.Reset();

	iMask.Reset();

	if (iAppView)

		{

		RemoveFromStack(iAppView);

		delete iAppView;

		}

	delete iLoadUtil;

	delete iSaveUtil;

	delete iRotator;

	delete iScaler;

	}

TKeyResponse CVideoAppUi::HandleKeyEventL(const TKeyEvent& aKeyEvent,TEventCode /*aType*/)

	{

	TKeyResponse ret = EKeyWasConsumed;

	switch (aKeyEvent.iCode)

		{

	case EKeyLeftArrow:

		iAppView->Move(TPoint(16,0));

		break;

	case EKeyRightArrow:

		iAppView->Move(TPoint(-16,0));

		break;

	case EKeyUpArrow:

		iAppView->Move(TPoint(0,16));

		break;

	case EKeyDownArrow:

		iAppView->Move(TPoint(0,-16));

		break;

	case EKeyEscape:

		iLoadUtil->Cancel();

		iSaveUtil->Cancel();

		CEikonEnv::Static()->BusyMsgCancel();

		CEikonEnv::Static()->InfoMsg(_L("Cancelled"));

		iState = EIdle;

		break;

	default:

		ret = EKeyWasNotConsumed;

		break;

		}

	return ret;

	}

void CVideoAppUi::HandleCommandL(TInt aCommand)

	{

	switch (aCommand)

		{

	case EVideoCmdOpenFile:

		OpenFileL(EFileTypeUnknown);

		break;

	case EVideoCmdOpenOpaFile:

		OpenFileL(EFileTypeOta);

		break;

	case EVideoCmdOpenWbmpFile:

		OpenFileL(EFileTypeWbmp);

		break;

	case EVideoCmdSaveAs:

		SaveAsL();

		break;

	case EVideoCmdMask:

		if (iMask.Handle())

			{

			CEikonEnv::Static()->InfoMsg(_L("Mask reset"));

			iMask.Reset();

			}

		else

			{

			CEikonEnv::Static()->InfoMsg(_L("Mask enabled"));

			User::LeaveIfError(iMask.Create(TSize(0,0),EGray256));

			}

		break;

	case EVideoCmdZoomIn:

		iZoomFactor++;

		if (iZoomFactor > KVideoMaxZoomFactor)

			iZoomFactor = KVideoMinZoomFactor;

		iAppView->Clear();

		LoadFileL();

		break;

	case EVideoCmdZoomOut:

		iZoomFactor--;

		if (iZoomFactor < KVideoMinZoomFactor)

			iZoomFactor = KVideoMaxZoomFactor;

		iAppView->Clear();

		LoadFileL();

		break;

	case EVideoCmdFineZoomIn:

		ZoomFrameL(ETrue);

		break;

	case EVideoCmdFineZoomOut:

		ZoomFrameL(EFalse);

		break;

	case EVideoCmdDisplayMode:

		DisplayModeL();

		break;

	case EVideoCmdBackgroundColor:

		BackgroundColorL();

		break;

	case EVideoCmdPlay:

		if (iState == EPlaying || iState == ELoading)

			CEikonEnv::Static()->InfoMsg(_L("Busy..."));

		else

			PlayClipL();

		break;

	case EVideoCmdStream:

		iEikonEnv->InfoMsg(R_VIDEO_NOT_SUPPORTED);

		break;

	case EVideoCmdRefresh:

		LoadFileL();

		break;

	case EVideoCmdExtractFrame:

		ExtractFrameL();

		break;

	case EVideoCmdFrameInfo:

		iEikonEnv->InfoMsg(R_VIDEO_NOT_SUPPORTED);

		break;

	case EVideoCmdRotateClockwise:

		FrameRotateL(ETrue);

		break;

	case EVideoCmdRotateAntiClockwise:

		FrameRotateL(EFalse);

		break;

	case EVideoCmdFlip:

		FrameFlipL();

		break;

	case EVideoCmdTest:

		iEikonEnv->InfoMsg(R_VIDEO_NOT_SUPPORTED);

		break;

	case EEikCmdExit:

/*		if (iLoadUtil)

			{

			iLoadUtil->Close();

			delete iLoadUtil;

			iLoadUtil = NULL;

			}

*/

		Exit();

		break;

	default:

		iEikonEnv->InfoMsg(R_VIDEO_TBUF_NOT_FOUND);

		}

	}

TBool CVideoAppUi::ProcessCommandParametersL(TApaCommand aCommand,TFileName& aDocumentName,const TDesC8& aTail)

	{

	switch (aCommand)

		{

	case EApaCommandOpen:

		iLoadFileName.iName = aDocumentName;

		break;

	case EApaCommandCreate:

	case EApaCommandRun:

		break;

	case EApaCommandBackground:

	default:

		break;

		}

	return CEikAppUi::ProcessCommandParametersL(aCommand,aDocumentName,aTail);

	}

void CVideoAppUi::OpenFileL(TFileType aFileType)

	{

	if (iLoadFileName.iName.Length() < 4)

		iLoadFileName.iName = _L("c:\\");

	CEikDialog* dialog = new(ELeave) CEikFileOpenDialog(&iLoadFileName.iName);

	if (!dialog->ExecuteLD(R_EIK_DIALOG_FILE_OPEN))

		return;

	iLastFileType = aFileType;

	LoadFileL();

	}

void CVideoAppUi::LoadFileL()

	{

	if (iLoadFileName.iName.Length() < 4)

		return;

	iLoadUtil->Cancel();

	iAppView->Clear();

	iFrameNumber = 0;

	iTime.HomeTime();

	TMdaClipFormat* format;

	switch (iLastFileType)

		{

		case EFileTypeOta:

			format = &iOtaFormat;

			break;

		case EFileTypeWbmp:

			format = &iWbmpFormat;

			break;

		default:

			format = NULL;

		}

	STATIC_CAST(CMdaImageFileToBitmapUtility*,iLoadUtil)->OpenL(iLoadFileName.iName, format);

	CEikonEnv::Static()->BusyMsgL(_L("Loading..."));

	iState = EPlaying;

	}

void CVideoAppUi::ExtractFrameL()

	{

	if (iLoadFileName.iName.Length() < 4)

		return;

	TInt frameCount = iLoadUtil->FrameCount();

	iFrameNumber -= 1; // return to the previous one we looked at

	if (iFrameNumber < 0 || iFrameNumber >= frameCount)

		iFrameNumber = 0;

	CEikDialog* dialog = new(ELeave) CVideoCurrentFrameDialog(iFrameNumber,frameCount);

	if (!dialog->ExecuteLD(R_VIDEO_FRAME_DIALOG))

		return;

	iState = ELoading;

	MiuoOpenComplete(KErrNone);

	}

void CVideoAppUi::PlayClipL()

	{

	iAppView->Clear();

	iFrameNumber = 0;

	iTime.HomeTime();

	iState = EPlaying;

	MiuoOpenComplete(KErrNone);

	}

void CVideoAppUi::SaveAsL()

	{

	if (iSaveFileName.iName.Length() < 4)

		iSaveFileName.iName = _L("c:\\");

	CEikDialog* dialog = new(ELeave) CVideoSaveAsDialog(&iSaveFileName.iName,iSaveInfo);

	if (!dialog->ExecuteLD(R_VIDEO_FILE_SAVEAS_DIALOG))

		return;

	CEikonEnv::Static()->FsSession().Delete(iSaveFileName.iName);

	TMdaClipFormat* format = NULL;

	TMdaPackage* codec = NULL;

	switch (iSaveInfo.iType)

		{

	case 0:

		format = &iBmpFormat;

		switch (iSaveInfo.iBpp)

			{

		case 0:		codec = &iBmp1BppCodec;		break;

		case 2:		codec = &iBmp4BppCodec;		break;

		case 3:		codec = &iBmp8BppCodec;		break;

		case 6:		codec = &iBmp24BppCodec;	break;

		default:	User::Invariant();			break;

			}

		break;

	case 1:

		format = &iGifFormat;

		codec = &iGifCodec;

		break;

	case 2:

		if (!iSaveInfo.iColor)

			iJfifFormat.iSettings.iSampleScheme = TMdaJpgSettings::EMonochrome;

		else

			iJfifFormat.iSettings.iSampleScheme = TMdaJpgSettings::TColorSampling(3 - iSaveInfo.iSampling);

		iJfifFormat.iSettings.iQualityFactor = iSaveInfo.iQualityFactor;

		format = &iJfifFormat;

		break;

	case 3:

		switch (iSaveInfo.iBpp)

			{

		case 0:		iMbmFormat.iDisplayMode = EGray2;		break;

		case 1:		iMbmFormat.iDisplayMode = EGray4;		break;

		case 2:		iMbmFormat.iDisplayMode = iSaveInfo.iColor ? EColor16 : EGray16;	break;

		case 3:		iMbmFormat.iDisplayMode = iSaveInfo.iColor ? EColor256 : EGray256;	break;

		case 4:		iMbmFormat.iDisplayMode = EColor4K;		break;

		case 5:		iMbmFormat.iDisplayMode = EColor64K;	break;

		case 6:		iMbmFormat.iDisplayMode = EColor16M;	break;

		case 7:		iMbmFormat.iDisplayMode = EColor16MU;	break;

		default:	User::Invariant();						break;

			}

		format = &iMbmFormat;

		break;

		}

	CEikonEnv::Static()->BusyMsgL(_L("Saving..."));

	STATIC_CAST(CMdaImageBitmapToFileUtility*,iSaveUtil)->CreateL(iSaveFileName.iName,format,codec,NULL);

	}

void CVideoAppUi::DisplayModeL()

	{

	TDisplayMode displayMode = iAppView->Window().DisplayMode();

	CEikDialog* dialog = new(ELeave) CVideoDisplayModeDialog(displayMode);

	if (dialog->ExecuteLD(R_VIDEO_DISPLAY_MODE_DIALOG))

		{

		if (iFrame.Handle() != 0 && iFrame.SizeInPixels() != TSize(0,0))

			ResizeFrameL(iFrame.SizeInPixels(), displayMode);

		iAppView->Window().SetRequiredDisplayMode(displayMode);

		iAppView->Refresh();

		}

	}

void CVideoAppUi::BackgroundColorL()

	{

	CEikDialog* dialog = new(ELeave) CVideoBackgroundColorDialog(iBackgroundColor);

	if (dialog->ExecuteLD(R_VIDEO_BACKGROUND_COLOR_DIALOG))

		{

		if (iBackgroundColor == KRgbWhite.Color16())

			iAppView->Window().SetBackgroundColor();

		else

			iAppView->Window().SetBackgroundColor(TRgb::Color16(iBackgroundColor));

		iAppView->Clear();

		iAppView->Refresh();

		}

	}

void CVideoAppUi::FrameRotateL(TBool aClockwise)

	{

	CMdaBitmapRotator::TRotationAngle angle = aClockwise ?

			CMdaBitmapRotator::ERotation90DegreesClockwise :

			CMdaBitmapRotator::ERotation270DegreesClockwise;

	iMask.Reset();

	iRotator->RotateL(*this,iFrame,angle);

	}

void CVideoAppUi::FrameFlipL()

	{

	iMask.Reset();

	iRotator->RotateL(*this,iFrame,CMdaBitmapRotator::ERotation180DegreesClockwise);

	}

void CVideoAppUi::ZoomFrameL(TBool aZoomIn)

	{

	TSize size(iFrame.SizeInPixels());

	const TSize adjust(size.iWidth / 10,size.iHeight / 10);

	if (aZoomIn)

		size += adjust;

	else

		size -= adjust;

	iLoadUtil->Cancel();

	iAppView->Clear();

	TFrameInfo frameInfo;

	iLoadUtil->FrameInfo(iFrameNumber-1,frameInfo);

	if (!(frameInfo.iFlags&TFrameInfo::EFullyScaleable))

		iScaler->ScaleL(*this,iFrame,size);

	else

		{

		SetFrameSizeAndPosL(frameInfo.iFrameCoordsInPixels,size); 

		if (!(frameInfo.iFlags&TFrameInfo::ECanDither))

			{

			iFrame.Reset();

			User::LeaveIfError(iFrame.Create(TSize(0,0),EColor64K)); // We will dither later

			}

		if (iFrame.SizeInPixels() != size)

			{

			User::LeaveIfError(iFrame.Resize(TSize(0,0)));

			User::LeaveIfError(iFrame.Resize(size));

			}

		if (iMask.Handle() && iMask.SizeInPixels() != size)

			{

			User::LeaveIfError(iMask.Resize(TSize(0,0)));

			User::LeaveIfError(iMask.Resize(size));

			}

		if (iMask.Handle())

			iLoadUtil->ConvertL(iFrame,iMask,iFrameNumber-1); // jf 3/12/01. -1 because iFrameNumber is incremented on open

		else

			iLoadUtil->ConvertL(iFrame,iFrameNumber-1);

		iState = ELoading; // jf 4/12 was EPlaying but that made it do other frames too

		}

	}

// ResizeFrameL creates a new frame with the given size and mode, but will

// keep the original data - stretched if req. Arguably overkill if the size

// does not change

void CVideoAppUi::ResizeFrameL(const TSize& aNewSize, TDisplayMode aNewMode)

	{

	// create a new bitmap with these params

	CFbsBitmap* newFrame = new (ELeave) CWsBitmap(iCoeEnv->WsSession());

	CleanupStack::PushL(newFrame);

	User::LeaveIfError(newFrame->Create(aNewSize, aNewMode));

	// now create BitmapDevice and bitGc so we can modify it

	CFbsBitmapDevice* bmDevice = CFbsBitmapDevice::NewL(newFrame);

	CleanupStack::PushL(bmDevice);

	CFbsBitGc* bmGc = CFbsBitGc::NewL();

	CleanupStack::PushL(bmGc);

	bmGc->Activate(bmDevice);

	// finally we have to set the SizeInTwips of the two bitmaps, so we can use DrawBitmap

	TSize size = iFrame.SizeInPixels();

	size.iWidth = TInt (size.iWidth * iDisplayXTwipsPerPixel + 0.5);

	size.iHeight = TInt (size.iHeight * iDisplayYTwipsPerPixel + 0.5);

	iFrame.SetSizeInTwips(size);

	size = newFrame->SizeInPixels();

	size.iWidth = TInt (size.iWidth * iDisplayXTwipsPerPixel + 0.5);

	size.iHeight = TInt (size.iHeight * iDisplayYTwipsPerPixel + 0.5);

	newFrame->SetSizeInTwips(size);

	bmGc->DrawBitmap(TPoint(0,0), &iFrame); // resize iFrame to newFrame

	CleanupStack::PopAndDestroy(2); // bmGc and bmDevice

	iFrame.Reset(); // lose original bitmap

	iFrame.Duplicate(newFrame->Handle()); // just swap the bitmap handles

	newFrame->Reset();

	CleanupStack::PopAndDestroy(); // newFrame

	}

void CVideoAppUi::MiuoCreateComplete(TInt aError)

	{

	if (aError)

		iEikonEnv->HandleError(aError);

	else

		{

		TRAPD(err, HandleMiuoCreateCompleteL());

		if (err != KErrNone)

			iEikonEnv->HandleError(err);

		}

	}

void CVideoAppUi::HandleMiuoCreateCompleteL()

	{

	iSaveUtil->ConvertL(iFrame,0);

	}

void CVideoAppUi::MiuoOpenComplete(TInt aError)

	{

	if (aError)

		iEikonEnv->HandleError(aError);

	else

		{

		TRAPD(err, HandleMiuoOpenCompleteL());

		if (err != KErrNone)

			iEikonEnv->HandleError(err);

		}

	}