// 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 <bidi.h>

#include <eikenv.h>

#include <techview/eikchlst.h>

#include <techview/eikinfo.h>

#include <techview/eikmenup.h>

#include <e32math.h>

#include <badesca.h>

#include <techview/eikon.rsg>	

#include <eikpriv.rsg>

#include <techview/eiktxlbx.h>

#include <techview/eikmfne.h>

#include <techview/eiktxlbm.h>

#include <iclexif.h>

#include <icl/icl_uids.hrh>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <icl/icl_uids_const.hrh>

#include <icl/icl_uids_def.hrh>

#endif

#include "TImageViewer.h"

const TInt KVideoMinZoomFactor = -3;

const TInt KVideoMaxZoomFactor = 0;

const TInt KDefaultStreamDelay = 1000000; // 1s. Used when streaming non-animated

const TInt KDefaultFolderDelay = 2000000; // 2s. Used when playing a folder

const TInt KButtonMoveIncr = 16;

const TInt KScaleFactor = 10;

const TInt KInfoBufferSize = 1024;

_LIT(KDefPath, "C:\\");

const TInt KShortestPossiblePath=4;

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

#define __CLEAR_BITMAPS_FIRST // for debugging purposes, get TImageViewer to clear bitmaps prior to

							  // decode conversion. Really the codecs should do this, but...

inline TBool IsMngImage(const CImageDecoder* aDecoder)

	{

	TUid type, subtype;

	aDecoder->ImageType(0, type, subtype);

	return (type.iUid==KMngMimeTypeUidValue);

	}

inline TBool HasMoreMngFrames(const CImageDecoder* aDecoder)

	{

	const TFrameInfo& info=aDecoder->FrameInfo(0);

	return (info.iFlags & TFrameInfo::EMngMoreFramesToDecode);

	}

CPluginInfoArray* CPluginInfoArray::NewL()

	{

	CPluginInfoArray* self = new (ELeave) CPluginInfoArray;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CPluginInfoArray::ConstructL()

	{

	RefreshPluginListL();

	}

CPluginInfoArray::CPluginInfoArray()

	{

	}

void CPluginInfoArray::Reset()

	{

	iPluginArray.ResetAndDestroy();

	}

void CPluginInfoArray::RefreshPluginListL()

	{

	Reset();

	CImageEncoder::GetImageTypesL(iPluginArray);

	}

CPluginInfoArray::~CPluginInfoArray()

	{

	Reset();

	}

TInt CPluginInfoArray::MdcaCount() const

	{

	return iPluginArray.Count();

	}

TPtrC CPluginInfoArray::MdcaPoint(TInt aIndex) const

	{

	return iPluginArray[aIndex]->Description(); 

	}

TUid CPluginInfoArray::ImageType(TInt aIndex)

	{

	return iPluginArray[aIndex]->ImageType(); 

	}

TUid CPluginInfoArray::SubType(TInt aIndex)

	{

	return iPluginArray[aIndex]->SubType(); 

	}

// CFrameInfoDialog

class CFrameInfoDialog : public CEikDialog

	{

public:

	CFrameInfoDialog(const TDesC& aPropertiesText, const TDesC& aImageCommentText, const TDesC& aFrameCommentText);

protected:

	void PreLayoutDynInitL();

private:

	const TDesC& iPropertiesText;

	const TDesC& iImageCommentText;

	const TDesC& iFrameCommentText;

	};

CFrameInfoDialog::CFrameInfoDialog(const TDesC& aPropertiesText, const TDesC& aImageCommentText, const TDesC& aFrameCommentText)

	: iPropertiesText(aPropertiesText), iImageCommentText(aImageCommentText), iFrameCommentText(aFrameCommentText)

	{

	}

void CFrameInfoDialog::PreLayoutDynInitL()

	{

	// Grab each Edwin and set the text.

	CEikEdwin* page = STATIC_CAST(CEikEdwin*, Control(EFramePropertiesPage));

	page->SetTextL(&iPropertiesText);

	page = STATIC_CAST(CEikEdwin*, Control(EImageCommentsPage));

	page->SetTextL(&iImageCommentText);

	page = STATIC_CAST(CEikEdwin*, Control(EFrameCommentsPage));

	page->SetTextL(&iFrameCommentText);

	}

//

// CVideoWalker

//

class CVideoWalker : public CActive

	{

public:

	static CVideoWalker* NewL(CVideoAppUi* aAppUi);

	~CVideoWalker();

	TRequestStatus& ActiveStatus();

	void SelfComplete(TInt aError);

protected:

	CVideoWalker(CVideoAppUi* aAppUi);

	// from CActive

	void RunL();

	void DoCancel();

protected:

	CVideoAppUi* const iAppUi; // not owned

	};

//

//  CVideoAppUi

//

CVideoAppUi::CVideoAppUi():

	iStreamBuffer(NULL,0,0)

	{

	iDecoderOptions = (CImageDecoder::EAllowGeneratedMask | CImageDecoder::EPreferFastDecode);

	}

void CVideoAppUi::ConstructL()

    {

	CEikAppUi::ConstructL();

    iAppView = CVideoAppView::NewL(ClientRect());

	::new(&iFrame) CWsBitmap(iEikonEnv->WsSession());

	::new(&iMask) CWsBitmap(iEikonEnv->WsSession());

	iRotator = CBitmapRotator::NewL();

	iScaler = CBitmapScaler::NewL();

	iBackgroundColor = KRgbWhite.Color16();

	iAppView->SetBackgroundColor(TRgb::Color16(iBackgroundColor), ENoDrawNow);

	iWalker = CVideoWalker::NewL(this);

	User::LeaveIfError(iTimer.CreateLocal());

	iStreamGen = CVideoWalker::NewL(this);

	User::LeaveIfError(iStreamTimer.CreateLocal());

	// Note iStreamSeed deliberated left as 0 to give consistent behaviour

	iSaveInfo.iImageTypeUid = KImageTypeJPGUid;

	iSaveInfo.iBpp = 6;

	iSaveInfo.iColor = ETrue;

	iSaveInfo.iQualityFactor = 40;

	iSaveInfo.iSampling = 2;

	iUseNativeDisplayMode = ETrue;

	iScalingCoefficient = 1; // Full size

	}

CVideoAppUi::~CVideoAppUi()

	{

	Cancel();

	iFrame.Reset();

	iMask.Reset();

	if (iAppView)

		{

		RemoveFromStack(iAppView);

		delete iAppView;

		}

	delete iFrameImageData;

	delete iLoadUtil;

	delete iSaveUtil;

	delete iRotator;

	delete iScaler;

	delete iWalker;

	iTimer.Close();

	iStreamTimer.Close();

	delete iStreamGen;

	User::Free(REINTERPRET_CAST(TAny*,CONST_CAST(TUint8*, iStreamBuffer.Ptr())));

	delete iDir;

	iOperations.Close();

	}

void CVideoAppUi::Cancel()

	{

	if (iWalker)

		iWalker->Cancel(); // if active will callback on DoCancel()

	if (iStreamGen)

		iStreamGen->Cancel();

	iState = EIdle;

	}

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

	{

	TKeyResponse ret = EKeyWasConsumed;

	if (aType!=EEventKey)

		return ret;

	TUint code = aKeyEvent.iCode;

	switch (code)

		{

	case EKeyLeftArrow:

	case EKeyRightArrow:

	case EKeyUpArrow:

	case EKeyDownArrow:

		{

		if ( aKeyEvent.iModifiers & EModifierShift )

			{

			// update crop region

			UpdateClippingRect(code);

			}

		else

			{

			TPoint moveBy;

			switch (code)

				{

			case EKeyLeftArrow:

				moveBy.SetXY(KButtonMoveIncr,0);

				break;

			case EKeyRightArrow:

				moveBy.SetXY(-KButtonMoveIncr,0);

				break;

			case EKeyUpArrow:

				moveBy.SetXY(0,KButtonMoveIncr);

				break;

			case EKeyDownArrow:

				moveBy.SetXY(0,-KButtonMoveIncr);

				break;

				}

			iAppView->MoveBy(moveBy);

			}

		}

		break;

	case EKeyEscape:

		Cancel();

		ASSERT(iState==EIdle);

		iEikonEnv->BusyMsgCancel();

		iEikonEnv->InfoMsg(_L("Cancelled"));

		break;

	default:

		ret = EKeyWasNotConsumed;

		break;

		}

	return ret;

	}

void CVideoAppUi::HandleCommandL(TInt aCommand)

	{

	switch (aCommand)

		{

	case EVideoCmdOpenFile:

		OpenFileL(EFileTypeUnknown);

		break;

	case EVideoCmdOpenOtaFile:

		OpenFileL(EFileTypeOta);

		break;

	case EVideoCmdOpenWbmpFile:

		OpenFileL(EFileTypeWbmp);

		break;

	case EVideoCmdOpenFolder:

		OpenFolderL();

		break;

	case EVideoCmdSaveAs:

		SaveAsL();

		break;

	case EVideoCmdMask:

		iDisableMask = ! iDisableMask;

		if (iDisableMask)

			{

			iEikonEnv->InfoMsg(_L("Mask reset"));

			}

		else

			{

			iEikonEnv->InfoMsg(_L("Mask enabled"));

			}

		if (iMask.Handle() && iDisableMask)

			{

			iMask.Reset();

			}

		else if (iMask.Handle()==0 && !iDisableMask)

			{

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

			}

		break;

	case EVideoCmdZoomIn:

		iZoomFactor++;

		if (iZoomFactor > KVideoMaxZoomFactor)

			iZoomFactor = KVideoMinZoomFactor;

		if ( iUseExtensions )

			{

			iScalingCoefficient = iZoomFactor - 1;

			}

		LoadFileL();

		break;

	case EVideoCmdZoomOut:

		iZoomFactor--;

		if (iZoomFactor < KVideoMinZoomFactor)

			iZoomFactor = KVideoMaxZoomFactor;

		if ( iUseExtensions )

			{

			iScalingCoefficient = iZoomFactor - 1;

			}

		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)

			iEikonEnv->InfoMsg(_L("Busy..."));

		else

			PlayClipL();

		break;

	case EVideoCmdStream:

		StreamPlayL(EFileTypeUnknown);

		break;

	case EVideoCmdOtaStream:

		StreamPlayL(EFileTypeOta);

		break;

	case EVideoCmdWbmpStream:

		StreamPlayL(EFileTypeWbmp);

		break;

	case EVideoCmdDecoderOptions:

		DecoderOptionsL();

		break;

	case EVideoCmdExtension:

		ExtensionOptionsL();

		break;

	case EVideoCmdUseExtensions:

	    iUseExtensions = !iUseExtensions;

		break;

	case EVideoCmdRefresh:

		LoadFileL();

		break;

	case EVideoCmdExtractFrame:

		ExtractFrameL();

		break;

	case EVideoCmdExtractStreamedFrame:

		StreamPlayL(EFileTypeUnknown, ETrue);

		break;

	case EVideoCmdFrameInfo:

		FrameInfoL(); 

		break;

	case EVideoCmdRotateClockwise:

		FrameRotateL(ETrue);

		break;

	case EVideoCmdRotateAntiClockwise:

		FrameRotateL(EFalse);

		break;

	case EVideoCmdMirrorHorizontalAxis:

		FrameMirrorL(ETrue);

		break;

	case EVideoCmdMirrorVerticalAxis:

		FrameMirrorL(EFalse);

		break;

	case EEikCmdExit:

		Exit();

		break;

	default:

		iEikonEnv->InfoMsg(R_VIDEO_UNKNOWN);

		break;

		}

	}

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

	{

	switch (aCommand)

		{

	case EApaCommandOpen:

		iLoadFileName = aDocumentName;

		break;

	case EApaCommandCreate:

	case EApaCommandRun:

		break;

	case EApaCommandBackground:

	default:

		break;

		}

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

	}

void CVideoAppUi::OpenFileL(TFileType aFileType)

	{

	if (iLoadFileName.Length() < KShortestPossiblePath)

		iLoadFileName = KDefPath;

	Cancel();

	delete iLoadUtil; iLoadUtil = NULL;

	TInt title;

	switch (aFileType)

		{

		default:

			title = 0;

			break;

		case EFileTypeWbmp:

			title = R_VIDEO_OPEN_WBMP;

			break;

		case EFileTypeOta:

			title = R_VIDEO_OPEN_OTA;

			break;

		}

	CEikDialog* dialog = new(ELeave) CEikFileOpenDialog(&iLoadFileName, title);

	if (!dialog->ExecuteLD(R_EIK_DIALOG_FILE_OPEN))

		return;

	iLastFileType = aFileType;

	iOpeningFolder = EFalse;

	LoadFileL();

	}

void CVideoAppUi::OpenFolderL()

	{

	Cancel();

	if (iLoadFileName.Length() < KShortestPossiblePath)

		iLoadFileName = KDefPath;

	TFileName folderName = iLoadFileName;

	CEikDialog* dialog = new(ELeave) CEikFileOpenDialog(&folderName, R_VIDEO_SELECT_FOLDER);

	if (!dialog->ExecuteLD(R_EIK_DIALOG_FILE_OPEN))

		return;

	iLastFileType = EFileTypeUnknown;

	iOpeningFolder = ETrue;

	LoadFolderL(folderName);

	}

void CVideoAppUi::DecoderOptionsL()

	{

	CEikDialog* dialog = new(ELeave) CDecoderOptionsDialog(iDecoderOptions);

	dialog->ExecuteLD(R_VIDEO_DECODER_OPTIONS_DIALOG);

	}

void CVideoAppUi::ExtensionOptionsL()

	{

	CEikDialog* dialog = new(ELeave) CExtensionOptionsDialog(iClippingRect,

															 iOperations,

															 iScalingCoefficient,

															 iScalingQuality,

															 iLockAspectRatio);

	TInt buttonPressed = dialog->ExecuteLD(R_VIDEO_DECODER_EXTENSION_DIALOG);

	if ( buttonPressed == EEikBidOk && iLoadUtil )

		{

		// re-convert the image e.g. if clipping rect has changed

		LoadFileL();

		}

	}

void CVideoAppUi::LoadFileL()

	{

	Cancel();