// 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 "EnhanceFunctionality.h"

#include "AdvancedSettings.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <ecam/cameraoverlayconst.h>

#endif

CCamHistogram* CCamHistogram::NewL(CCamUnitTestPlugin& aOwner)

	{

	CCamHistogram* self = new (ELeave) CCamHistogram(aOwner);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CCamHistogram::ConstructL()

	{

	iHistograms = new (ELeave) CArrayFixFlat<CHistogram*>(1);

	}

CCamHistogram::CCamHistogram(CCamUnitTestPlugin& aOwner):iOwner(aOwner)

	{

	}

CCamHistogram::~CCamHistogram()

	{

	if(iHistograms != NULL)

		{

		TInt i=0;

		TInt count = iHistograms->Count();

		while(i<count)

			{

			delete iHistograms->At(i);

			i++;

			}

		iHistograms->Reset();

		delete iHistograms;

		iHistograms = NULL;

		}

	}

TUint32 CCamHistogram::SupportedHistograms()

	{

	return CCamera::CCameraHistogram::ELuminance;

	}

TUint CCamHistogram::PrepareHistogramL(CCamera::CCameraHistogram::THistogramType aType)

	{

	CHistogram* histogram = CHistogram::NewL(EFalse, aType, TPoint(0,0), TSize(0,0), TRgb(0));

	iHistograms->AppendL(histogram);

	TInt temp = iHistograms->Count();

	return --temp;

	}

TUint CCamHistogram::PrepareDSAHistogramL(CCamera::CCameraHistogram::THistogramType aType, const TPoint& aPosition, const TSize& aSize, const TRgb& aColor)

	{

	CHistogram* histogram = CHistogram::NewL(ETrue, aType, aPosition, aSize, aColor);

	iHistograms->AppendL(histogram);

	TInt temp = iHistograms->Count();

	return --temp;

	}

void CCamHistogram::StartHistogramL(TUint aHistHandle)

	{

	iHistograms->At(aHistHandle)->iActive = ETrue;

	if(iHistograms->At(aHistHandle)->iDSA == EFalse)

		{

		TUid myuid;

		myuid.iUid = KUidECamEventHistogramUidValue;

		iOwner.Notify(myuid,0);	

		}

	}

void CCamHistogram::StopHistogramL(TUint aHistHandle)

	{

	iHistograms->At(aHistHandle)->iActive = EFalse;

	}

void CCamHistogram::DestroyHistogramL(TUint aHistHandle)

	{

	delete iHistograms->At(aHistHandle);

	iHistograms->Delete(aHistHandle);

	}

void CCamHistogram::Release()

	{

	delete this;

	}

void CCamHistogram::GetActiveHistogramsL(RArray<TUint>& /*aActiveHistograms*/)

	{

	//Not implemented

	}

void CCamHistogram::UpdateDSAHistogramPropertiesL(TUint aHistHandle, const TPoint& aPosition, const TSize& aSize, const TRgb& aColor)

	{

	iHistograms->At(aHistHandle)->iPosition = aPosition;

	iHistograms->At(aHistHandle)->iSize = aSize;

	iHistograms->At(aHistHandle)->iColor = aColor;

	}

void CCamHistogram::GetDSAHistogramPropertiesL(TUint aHistHandle, TPoint& aPosition, TSize& aSize, TRgb& aColor)

	{

	aPosition = iHistograms->At(aHistHandle)->iPosition;

	aSize = iHistograms->At(aHistHandle)->iSize;

	aColor = iHistograms->At(aHistHandle)->iColor;

	}

MHistogramBuffer& CCamHistogram::HistogramDataL()

	{

	// not implemented

	TInt a = 10;

	return reinterpret_cast<MHistogramBuffer&> (a);

	}

MHistogramBuffer& CCamHistogram::HistogramDataL(TUint /*aHistHandle*/)

	{

	// not implemented

	TInt a = 10;

	return reinterpret_cast<MHistogramBuffer&> (a);

	}

/**

* Defination for CHistogram Class 

*/

CCamHistogram::CHistogram * CCamHistogram::CHistogram::NewL(TBool aDSA, CCamera::CCameraHistogram::THistogramType aType, TPoint aPosition, TSize aSize, TRgb aColor)

	{

	return new (ELeave) CCamHistogram::CHistogram(aDSA , aType, aPosition, aSize, aColor);

	}

CCamHistogram::CHistogram::CHistogram(TBool aDSA, CCamera::CCameraHistogram::THistogramType /*aType*/, TPoint aPosition, TSize aSize, TRgb aColor):iDSA(aDSA),iPosition(aPosition),iSize(aSize),iColor(aColor)

	{

	}

CCamHistogram::CHistogram::~CHistogram()

	{

	}

/**

*	For Snapshot

*///-----------------------------------------------------------------------------------

CCamSnapshot* CCamSnapshot::NewL(CCamUnitTestPlugin& aOwner)

	{

	return new (ELeave) CCamSnapshot(aOwner);

	}

CCamSnapshot::~CCamSnapshot()

	{

	}

CCamSnapshot::CCamSnapshot(CCamUnitTestPlugin& aOwner):iOwner(aOwner)

	{

	}

TUint32 CCamSnapshot::SupportedFormats()

	{

	// Dummy implementation : Nothing to implement

	return CCamera::EFormatJpeg;

	}

void CCamSnapshot::PrepareSnapshotL(CCamera::TFormat aFormat, const TPoint& aPosition, const TSize& aSize, const TRgb& aBgColor, TBool aMaintainAspectRatio)

	{

	// Dummy implementation : 

	iFormat = aFormat;

	iPos = aPosition;

	iSize = aSize;

	iBgColor = aBgColor;

	iAspRatio = aMaintainAspectRatio;

	}

void CCamSnapshot::PrepareSnapshotL(CCamera::TFormat aFormat, const TSize& aSize, TBool aMaintainAspectRatio)	

	{

	iFormat = aFormat;

	iSize = aSize;

	iAspRatio = aMaintainAspectRatio;

	}

TBool CCamSnapshot::IsSnapshotActive() const

	{

	// Dummy implementation :

	return iActive;

	}

void CCamSnapshot::StartSnapshot()

	{

	// Dummy implementation 

	iActive = ETrue;

	TUid myuid;

	myuid.iUid = KUidECamEventSnapshotUidValue;

	iOwner.Notify(myuid,0);

	}

void CCamSnapshot::StopSnapshot()

	{

	// Dummy implementation 

	iActive = EFalse;

	}

MCameraBuffer& CCamSnapshot::SnapshotDataL(RArray<TInt>& aFrameIndexOrder)

	{

	// Dummy implementation :

	aFrameIndexOrder.Append(1);

	TInt temp = 10;

	return reinterpret_cast <MCameraBuffer&> (temp);

	}

void CCamSnapshot::SetBgColorL(const TRgb& aBgColor)

	{

	iBgColor = aBgColor;

	if(iBgColor != aBgColor)

		{

		User::Leave(KErrNotSupported);

		}

	}

void CCamSnapshot::SetPositionL(const TPoint& aPosition)

	{

	iPos = aPosition;

	if(iPos != aPosition)

		{

		User::Leave(KErrNotSupported);

		}

	}

void CCamSnapshot::Release()

	{

	delete this;

	}

/**

*	For Overlay

*/// -----------------------------------------------------------------------------------

CCamOverlay* CCamOverlay::NewL(CCamUnitTestPlugin& aOwner)

	{

	CDataGlobal* globalData = static_cast <CDataGlobal*> (Dll::Tls());

	if(!globalData)

		{

		globalData = new (ELeave) CDataGlobal;

		CleanupStack::PushL(globalData);

		globalData->iReferenceCount = 0;

		globalData->iCamOverlay = new (ELeave) CCamOverlay(aOwner);

		CleanupStack::PushL(globalData->iCamOverlay);

		globalData->iCamOverlay->ConstructL();

    	globalData->iCamOverlay->iRefCount = 1;

    	CleanupStack::Pop(globalData->iCamOverlay);

		TInt error = Dll::SetTls(globalData);

		if (error)

			{

			delete globalData->iCamOverlay;

			User::Leave(error);

			}

		CleanupStack::Pop(globalData);

		return static_cast <CCamOverlay*> (globalData->iCamOverlay);

		}

	else

		{

		CCamOverlay* self = globalData->iCamOverlay;

		globalData->iReferenceCount++;

		self->iRefCount = globalData->iReferenceCount + 1;

		if (globalData->iReferenceCount == 1 )

			{

			delete globalData;

			Dll::FreeTls();

			}

		else

			{

			TInt error = Dll::SetTls(globalData);

			if (error)

				{

				delete globalData->iCamOverlay;

				User::Leave(error);

				}

			}

		return static_cast <CCamOverlay*> (self);		

		}

	}

void CCamOverlay::ConstructL()

	{

	iOverlays = new (ELeave) CArrayFixFlat<COverlay*>(1);

	}

CCamOverlay::CCamOverlay(CCamUnitTestPlugin& aOwner):iOwner(aOwner)

	{

	}

CCamOverlay::~CCamOverlay()

	{

	Dll::FreeTls();

	// Dummy implementation 

	if(iOverlays != NULL)

		{

		TInt i=0;

		TInt count = iOverlays->Count();

		while(i<count)

			{

			delete iOverlays->At(i);

			i++;

			}

		iOverlays->Reset();

		delete iOverlays;

		iOverlays = NULL;

		}

	}

void CCamOverlay::Release()

	{

	iRefCount--; 

	if(!iRefCount)

		{

		delete this;

		}

	}

TUint CCamOverlay::CreateOverlayL(const CCamera::CCameraOverlay::TOverlayParameters& aParameters, CFbsBitmap* aBitmap)

	{

	// Dummy implementation 

	if((aParameters.Size() != sizeof(CCamera::CCameraOverlay::TOverlayParameters )) ||

		aParameters.Version() != KECamOverlayParametersCurrentVersion)

		{

		User::Leave(KErrNotSupported);

		}

	COverlay* overlay = COverlay::NewL(aParameters, aBitmap);

	overlay->iZOrderReverse = 100 - aParameters.iZOrder;

	iOverlays->AppendL(overlay);

	TInt temp = iOverlays->Count();

	return --temp;

	}

void CCamOverlay::SetOverlayBitmapL(TUint aOverlayHandleRef, const CFbsBitmap* aBitmap)

	{

	// Dummy implementation 

	iOverlays->At(aOverlayHandleRef)->iBitmap = const_cast<CFbsBitmap*> (aBitmap);

	}

void CCamOverlay::GetOverlayBitmapL(TUint aOverlayHandleRef, CFbsBitmap* aBitmap)

	{

	// Dummy implementation 

	TSize size = aBitmap->SizeInPixels();

	TDisplayMode dispMode = aBitmap->DisplayMode();

	User::LeaveIfError(aBitmap->Duplicate(iOverlays->At(aOverlayHandleRef)->iBitmap->Handle()));

	size = aBitmap->SizeInPixels();

	dispMode = aBitmap->DisplayMode();

	}

void CCamOverlay::GetOverlayParametersL(TUint aOverlayHandle, CCamera::CCameraOverlay::TOverlayParameters& aInfo)

	{

	// Dummy implementation 

	aInfo.iCurrentModes	=	iOverlays->At(aOverlayHandle)->iOverlayParms.iCurrentModes;

	aInfo.iCurrentTypes	=	iOverlays->At(aOverlayHandle)->iOverlayParms.iCurrentTypes;

	aInfo.iAlphaValue	=	iOverlays->At(aOverlayHandle)->iOverlayParms.iAlphaValue;

	aInfo.iPosition		=	iOverlays->At(aOverlayHandle)->iOverlayParms.iPosition;

	aInfo.iZOrder		=	iOverlays->At(aOverlayHandle)->iOverlayParms.iZOrder;

	}

void CCamOverlay::SetOverlayParametersL(TUint aOverlayHandle, const CCamera::CCameraOverlay::TOverlayParameters& aParameters)

	{

	// Dummy implementation 

	iOverlays->At(aOverlayHandle)->iOverlayParms.iCurrentModes 	= aParameters.iCurrentModes;

	iOverlays->At(aOverlayHandle)->iOverlayParms.iCurrentTypes 	= aParameters.iCurrentTypes;

	iOverlays->At(aOverlayHandle)->iOverlayParms.iAlphaValue 	= aParameters.iAlphaValue;

	iOverlays->At(aOverlayHandle)->iOverlayParms.iPosition 		= aParameters.iPosition;

	iOverlays->At(aOverlayHandle)->iOverlayParms.iZOrder 		= aParameters.iZOrder;

	iOverlays->At(aOverlayHandle)->iZOrderReverse = 100 - aParameters.iZOrder;

	}

void CCamOverlay::ReleaseOverlay(TUint aOverlayHandle)

	{

	// Dummy implementation

	delete iOverlays->At(aOverlayHandle);

	iOverlays->Delete(aOverlayHandle);

	}

void CCamOverlay::GetOverlaySupport(CCamera::CCameraOverlay::TOverlaySupportInfo& aInfo)

	{

	// Dummy implementation 

	if((aInfo.Size() != sizeof(CCamera::CCameraOverlay::TOverlaySupportInfo )) ||

		aInfo.Version() != KECamOverlaySupportInfoCurrentVersion)

		{

		User::Leave(KErrNotSupported);

		}

	aInfo.iSupportedModes = (CCamera::CCameraOverlay::EModeStillImageBurst << 1) - 1;

	aInfo.iSupportedTypes = 1;

	aInfo.iPerPlane = CCamera::CCameraOverlay::EBinary;

	aInfo.iPerPixel = CCamera::CCameraOverlay::EBinary;

	aInfo.iCanOverlap = EFalse;

	}

void CCamOverlay::GetAllOverlaysInZOrderL(RArray<TUint>& /*aOverlayHandles*/)

	{

	// Dummy implementation 

	}

void CCamOverlay::SetAllOverlaysInZOrderL(const RArray<TUint>& /*aOverlayHandles*/)

	{

	// Dummy implementation 

	}

void CCamOverlay::SetModifiableOverlayBitmapL(TUint aOverlayHandle, CFbsBitmap* aBitmap)

	{

	// Dummy implementation 

	iOverlays->At(aOverlayHandle)->iBitmap = aBitmap;

	}

void CCamOverlay::GetAllOverlaysInZOrderL(CCamera::CCameraOverlay::TOverlayCameraMode aOverlayCameraMode, TInt aViewFinderHandle, RArray<TUint>& aOverlayHandles) const

	{

	// Dummy implementation

	RArray<TInt> overlayFiltered;

	aOverlayHandles.Reset();

	// filter overlays for 'aOverlayCameraMode' and aViewFinderHandle (if applicable)

	for(TInt index=0; index<iOverlays->Count(); index++)

		{

		if(iOverlays->At(index)->iOverlayParms.iCurrentModes & aOverlayCameraMode)

			{

			if(aOverlayCameraMode == CCamera::CCameraOverlay::EModeDirectViewfinder || aOverlayCameraMode == CCamera::CCameraOverlay::EModeClientViewfinder)

				{

				if(iOverlays->At(index)->iOverlayParms.iViewFinderHandle == aViewFinderHandle)

					{

					overlayFiltered.AppendL(index);

					}

				}

			else

				{

				overlayFiltered.AppendL(index);	

				}

			}

		}

	TUint zOrderMax = 0;

	TInt maxZOrderHandle =0;

	while(overlayFiltered.Count())	

		{

		zOrderMax = 0;

		maxZOrderHandle =0;

		//find out max Zorder and the handle of the overlay which has this max z-order

		for(TInt index=0; index<overlayFiltered.Count(); index++)

			{

			if(iOverlays->At(index)->iOverlayParms.iZOrder > zOrderMax)

				{

				zOrderMax = iOverlays->At(index)->iOverlayParms.iZOrder;

				maxZOrderHandle = index;

				}

			}

		aOverlayHandles.AppendL(maxZOrderHandle);

		overlayFiltered.Remove(maxZOrderHandle);

		}

	overlayFiltered.Close()	;

	}

void CCamOverlay::SetAllOverlaysInZOrderL(CCamera::CCameraOverlay::TOverlayCameraMode aOverlayCameraMode, TInt aViewFinderHandle, const RArray<TUint>& aOverlayHandles)

	{

	//boundary checking

	TBool available = EFalse;

	TInt overlayIndex;

	for(TInt index=0; index<iOverlays->Count(); index++)

		{

		if(iOverlays->At(index)->iOverlayParms.iCurrentModes & aOverlayCameraMode)

			{

			if(aOverlayCameraMode == CCamera::CCameraOverlay::EModeDirectViewfinder || aOverlayCameraMode == CCamera::CCameraOverlay::EModeClientViewfinder)

				{

				if(iOverlays->At(index)->iOverlayParms.iViewFinderHandle == aViewFinderHandle)

					{

					available = ETrue;

					}

				}

			else

				{

				available = ETrue;	

				}

			}

		overlayIndex = aOverlayHandles.Find(index);	

		if(available)

			{

			if(overlayIndex == KErrNotFound)

				{

				User::Leave(KErrArgument);

				}

			}

		else

			{

			if(overlayIndex != KErrNotFound)

				{

				User::Leave(KErrArgument);

				}	

			}

		}// boundary checking complete

	//provide Z order values to aOverlayHandles

	TUint decZorder = 100;

	for(TInt index =0; index<aOverlayHandles.Count(); index++ )

		{

		iOverlays->At(aOverlayHandles[index])->iOverlayParms.iZOrder = decZorder;

		iOverlays->At(aOverlayHandles[index])->iZOrderReverse = 100 - decZorder;

		decZorder--;

		}

	//setting the overlays in z-order

	TInt offset = _FOFF(CCamOverlay::COverlay, iZOrderReverse);

	TKeyArrayFix key(offset, ECmpTUint);

	User::LeaveIfError(iOverlays->Sort(key));

	}

/**

* Defination for COverlay Class 

*/

CCamOverlay::COverlay* CCamOverlay::COverlay::NewL(const CCamera::CCameraOverlay::TOverlayParameters& aParameters, CFbsBitmap* aBitmap)

	{

	CCamOverlay::COverlay* self = new (ELeave) CCamOverlay::COverlay(aParameters, aBitmap);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CCamOverlay::COverlay::ConstructL()

	{

	}

CCamOverlay::COverlay::COverlay(const CCamera::CCameraOverlay::TOverlayParameters& aParameters, CFbsBitmap* aBitmap):iOverlayParms(aParameters), iBitmap(aBitmap)

	{

	}

CCamOverlay::COverlay::~COverlay ()

	{

	}