// Copyright (c) 2005-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 <bitmaptransforms.h>

#include <icl/imagedisplayplugin.h>

#include <icl/geniclimagedisplayext.h>

#include "plugininfoarray.h"

#include "TImageDisplayAppView.h"

#include "TImageDisplayDlgs.h"

#include "TImageDisplay.h"

const TInt KVideoMinZoomFactor = -3;

const TInt KVideoMaxZoomFactor = 3;

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

const TInt KButtonMoveIncr = 16;

const TInt KInfoBufferSize = 1024;

const TInt KNoRotation=-1;

const TInt KAutoRotate=(1<<16);

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

const TInt KShortestPossiblePath=4;

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

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

CPluginInfoArray* CPluginInfoArray::NewL()

	{

	CPluginInfoArray* self;

	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);

protected:

	void PreLayoutDynInitL();

private:

	const TDesC& iPropertiesText;

	};

CFrameInfoDialog::CFrameInfoDialog(const TDesC& aPropertiesText)

	: iPropertiesText(aPropertiesText)

	{

	}

void CFrameInfoDialog::PreLayoutDynInitL()

	{

	// Grab each Edwin and set the text.

	CEikEdwin* page = static_cast<CEikEdwin*>(Control(EFramePropertiesPage));

	page->SetTextL(&iPropertiesText);

	}

//

// CVideoWalker

//

class CVideoWalker : public CActive

	{

public:

	static CVideoWalker* NewL(CImgDisplAppUi* aAppUi);

	~CVideoWalker();

	TRequestStatus& ActiveStatus();

	void SelfComplete(TInt aError);

protected:

	CVideoWalker(CImgDisplAppUi* aAppUi);

	// from CActive

	void RunL();

	void DoCancel();

protected:

	CImgDisplAppUi*const iAppUi; // not owned

	};

//

//  CImgDisplAppUi

//

CImgDisplAppUi::CImgDisplAppUi():

			iRotationAngle(KNoRotation),

			iDrmIntent(ContentAccess::EPeek),

			iScalingQuality(CBitmapScaler::EMinimumQuality)

	{

	}

void CImgDisplAppUi::ConstructL()

    {

	CEikAppUi::ConstructL();

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

	iBackgroundColor = KRgbWhite.Color16();

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

	iWalker = CVideoWalker::NewL(this);

	User::LeaveIfError(iTimer.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;

	}

CImgDisplAppUi::~CImgDisplAppUi()

	{

	Cancel();

	if (iAppView)

		{

		RemoveFromStack(iAppView);

		delete iAppView;

		}

	delete iFrameImageData;

	delete iSaveUtil;

	delete iImageDisplay;

	delete iWalker;

	iTimer.Close();

	delete iDir;

	}

void CImgDisplAppUi::Cancel()

	{

	if (iWalker)

		{

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

		}

	iState = EIdle;

	}

TKeyResponse CImgDisplAppUi::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:

		{

		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 CImgDisplAppUi::HandleCommandL(TInt aCommand)

	{

	switch (aCommand)

		{

	case EVideoCmdOpenFile:

		OpenFileL(EFileTypeUnknown);

		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"));

			}

		break;

	case EVideoCmdToggleFrameDump:

		iDumpFrames = !iDumpFrames;

		if (iDumpFrames)

			{

			iEikonEnv->InfoMsg(_L("Frame dump is ON"));

			}

		else

			{

			iEikonEnv->InfoMsg(_L("Frame dump is OFF"));

			}

		break;

	case EVideoCmdDrmParams:

		DrmParamsL();

		break;

	case EVideoCmdClipRectParams:

		ClipRectParamsL();

		break;

	case EVideoCmdDecodeThumbnail:

		iUseThumbnail = !iUseThumbnail;

		LoadFileL();

		break;

	case EVideoCmdPauseAfterEachFrame:

		iPauseAfterEachFrame = !iPauseAfterEachFrame;

		if (iPauseAfterEachFrame)

			{

			iEikonEnv->InfoMsg(_L("Pause after each frame is ON"));

			}

		else

			{

			iEikonEnv->InfoMsg(_L("Pause after each frame is OFF"));

			}

		break;

	case EVideoCmdScalingQuality:

		ScalingQualityL();

		break;

	case EVideoCmdZoomIn:

		iZoomFactor++;

		if (iZoomFactor > KVideoMaxZoomFactor)

			iZoomFactor = KVideoMinZoomFactor;

		LoadFileL();

		break;

	case EVideoCmdZoomOut:

		iZoomFactor--;

		if (iZoomFactor < KVideoMinZoomFactor)

			iZoomFactor = KVideoMaxZoomFactor;

		LoadFileL();

		break;

	case EVideoCmdResetZoom:

		iZoomFactor=0;

		LoadFileL();

		break;

	case EVideoCmdDisplayMode:

		DisplayModeL();

		break;

	case EVideoCmdMaxReduction:

		MaxReductionL();

		break;

	case EVideoCmdBackgroundColor:

		BackgroundColorL();

		break;

	case EVideoCmdPlay:

		if (iState == ELoading)

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

		else

			PlayClipL();

		break;

	case EVideoCmdPause:

		Pause();

		break;

	case EVideoCmdRefresh:

		LoadFileL();

		break;

	case EVideoCmdExtractFrame:

		ExtractFrameL();

		break;

	case EVideoCmdFrameInfo:

		FrameInfoL(); 

		break;

	case EVideoCmdRotateClockwise:

		FrameRotateL(ETrue);

		LoadFileL();

		break;

	case EVideoCmdRotateAntiClockwise:

		FrameRotateL(EFalse);

		LoadFileL();

		break;

	case EVideoCmdFlipVertical:

		FrameFlipL(ETrue);

		LoadFileL();

		break;

	case EVideoCmdFlipHorizontal:

		FrameFlipL(EFalse);

		LoadFileL();

		break;

	case EVideoCmdAutoRotate:

		AutoRotateL();

		LoadFileL();

		break;

	case EEikCmdExit:

		Exit();

		break;

	default:

		iEikonEnv->InfoMsg(R_VIDEO_UNKNOWN);

		break;

		}

	}

TBool CImgDisplAppUi::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 CImgDisplAppUi::OpenFileL(TFileType aFileType)

	{

	if (iLoadFileName.Length() < KShortestPossiblePath)

		{

		iLoadFileName = KDefPath;

		}

	Cancel();

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

	if (!dialog->ExecuteLD(R_EIK_DIALOG_FILE_OPEN))

		{

		return;

		}

	iLastFileType = aFileType;

	iOpeningFolder = EFalse;

	LoadFileL();

	}

void CImgDisplAppUi::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 CImgDisplAppUi::LoadFileL()

	{

	if (iLoadFileName.Length() < KShortestPossiblePath)

		{

		return;

		}

	Cancel();

	TInt error=KErrNone;

	if (iImageDisplay==NULL)

		{

		TRAP(error,iImageDisplay = CImageDisplay::NewL(*this, iCoeEnv->FsSession()));

		}

	else

		{

		iImageDisplay->Reset();

		}

	iFrameNumber = 0;

	if (error!=KErrNone)

		{

		iEikonEnv->HandleError(error);

		iAppView->Reset(EDrawNow); // ensure we redraw whole screen - replace previous cross if required

		return;

		}

	HandleNewlyOpenedImageL();

	StartFrameOpen(EPlaying);

	}

void CImgDisplAppUi::LoadFolderL(const TDesC& aDirName)

	{

	delete iDir; iDir = NULL;

	TParsePtrC parse(aDirName);

	iDirName = parse.DriveAndPath();

	iEikonEnv->FsSession().GetDir(iDirName, 0, 0, iDir);

	if (iDir->Count()==0)

		{

		iEikonEnv->InfoMsg(R_VIDEO_EMPTY_FOLDER);

		return;

		}

	iDirIndex = 0; 

	OpenNextFolderEntry();

	}

void CImgDisplAppUi::OpenNextFolderEntry()

	{

	if (iDirIndex >= iDir->Count())

		{

		// end of processing - so stop

		iEikonEnv->BusyMsgCancel();

		Cancel(); 

		iState = EIdle;

		return;

		}

	const TEntry& entry = (*iDir)[iDirIndex];

	iLoadFileName.Copy(iDirName);

	iLoadFileName.Append(entry.iName);

	TRAPD(error, LoadFileL());

	if (error==KErrNone)

		iEikonEnv->InfoMsg(entry.iName);

	else

		{

		TBuf<64> errorMsg;

		errorMsg.Format(_L("%S - error %d"), &entry.iName, error);

		iEikonEnv->InfoMsg(errorMsg);

		LoadFolderWait();

		}

	}