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

#include "_WININC.H"

#include <bitdrawinterfaceid.h>

#if defined(SYMBIAN_GRAPHICS_GCE)

#include <surface.h>

#endif //SYMBIAN_GRAPHICS_GCE

template <class T> CScreenDevice<T>::~CScreenDevice()

	{

	iUpdateRegion.Close();

	iWindowInUse.Close();

	RWindows::ReleaseWindow(iScreenNo);

	}

/**

Constructs the CScreenDevice<T> object.

@param aScreenNo Screen number. It will be used in HAL::Get() calls.

@param aHwnd Windows OS - window handle.

@param aSize Screen size

@return System-wide error codes, KErrNone if the construction was successfull.

*/

template <class T> TInt CScreenDevice<T>::ConstructScreen(TInt aScreenNo, TAny* aHwnd,const TSize& aSize)

	{

    iScreenNo = aScreenNo;

	TInt ret = Construct(aSize);

	if (ret != KErrNone)

		return ret;

	if (aSize.iWidth < aSize.iHeight)

		{

		TInt bpp = BitsPerPixel(iDispMode);

		delete[] iScanLineBuffer;

		TInt scanLineWords = ((iSize.iHeight * bpp) + 31) / 32;

		iScanLineBuffer = (TUint32*)(User::Heap().Alloc(scanLineWords * 4));

		if (!iScanLineBuffer)

			return KErrNoMemory;

		}

	iWindow = RWindows::GetWindow(iScreenNo, aHwnd,aSize);

	if (iWindow == NULL)

		return KErrNoMemory;

	SetBits(iWindow->EpocBitmapBits());

    //Some explanations about iWindowInUse semaphore.

    //On the Emulator, a single Windows OS window can be shared between many Symbian OS

    //screen devices. iWindowInUse semaphore is used to help to determine the moment,

    //when the related Windows OS window can be destroyed safely. Because it is a named

    //semaphore, it will be created once by the first client (Symbian OS screen device)

    //and opened (reference counted) by the every next client (Symbian OS screen device).

    //In the CScreenDevice<T>'s deastructor iWindowInUse semaphore will be closed 

    //(its reference counter gets decremented). When its value reaches zero, the Symbian OS

    //will destroy the semaphore. This action will be detected by the RWindows::ReleaseWindow()'s

    //implementation and the related Windows OS window will be destroyed.

    TBuf<32> screenSemaphoreName;

    ::CreateScreenSemaphoreName(iScreenNo, screenSemaphoreName);

	ret = iWindowInUse.CreateGlobal(screenSemaphoreName,0,EOwnerThread);

	if (ret == KErrAlreadyExists)

        {

		iWindowInUse.OpenGlobal(screenSemaphoreName,EOwnerThread);

        }

	return KErrNone;

	}

template <class T> TInt CScreenDevice<T>::HorzTwipsPerThousandPixels() const

	{

	if (iSize.iWidth==0)

		return(0);

	TInt twips = 0;

	HAL::Get(iScreenNo, HALData::EDisplayXTwips,twips);

	return twips * 1000 / iSize.iWidth;

	}

template <class T> TInt CScreenDevice<T>::VertTwipsPerThousandPixels() const

	{

	if (iSize.iHeight==0)

		return(0);

	TInt twips = 0;

	HAL::Get(iScreenNo, HALData::EDisplayYTwips,twips);

	return twips * 1000 / iSize.iHeight;

	}

template <class T> void CScreenDevice<T>::OrientationsAvailable(TBool aOrientation[4])

	{

	aOrientation[EOrientationNormal] = ETrue;

	aOrientation[EOrientationRotated90] = ETrue;

	aOrientation[EOrientationRotated180] = ETrue;

	aOrientation[EOrientationRotated270] = ETrue;

	}

template <class T> void CScreenDevice<T>::SetDisplayMode(CFbsDrawDevice* aDrawDevice)

	{

	iUpdateRegion.Clear();

	SetOrientation(static_cast<CFbsDrawDevice::TOrientation>(iWindow->Orientation()));

	CopyOldSettings(aDrawDevice);

	InitScreen();

	}

template <class T> void CScreenDevice<T>::SetAutoUpdate(TBool aAutoUpdate)

	{

	iAutoUpdate = aAutoUpdate;

	}

template <class T> void CScreenDevice<T>::SetScreenOrientation(TInt aOrientation)

	{

	Update();

	TEmulatorFlip flip = EEmulatorFlipRestore;

	switch (aOrientation)

		{

	case 0: // Already set

		break;

	case 1:

		flip = EEmulatorFlipLeft;

		break;

	case 2:

		flip = EEmulatorFlipInvert;

		break;

	case 3:

		flip = EEmulatorFlipRight;

		break;

	default:

		ASSERT(0);

		break;

		}

	EmulatorFlip(flip, iScreenNo);

	iWindow->SetOrientation(aOrientation);

	}

//

// Update the screen with the update region.

//

template <class T> void CScreenDevice<T>::Update()

	{

	if (iUpdateRegion.IsEmpty())

		return;

	UpdateScreen(iUpdateRegion);

	iUpdateRegion.Clear();

	}

//

// Update the screen with the union of the update and specified regions.

// aRegion - logical coordinates

template <class T> void CScreenDevice<T>::Update(const TRegion& aRegion)

	{

	if(!aRegion.IsEmpty() && !aRegion.CheckError())

		{

		if(iScalingOff && iOriginIsZero)

			{

			iUpdateRegion.Union(aRegion);

			}

		else

			{

			register TInt rcCnt = aRegion.Count();

			RRegion physRegion(rcCnt);

			register TInt originX = iOrigin.iX;

			register TInt originY = iOrigin.iY;

			register TInt factorX = iScalingSettings.iFactorX;

			register TInt factorY = iScalingSettings.iFactorY;

			for(register TInt i=0;i<rcCnt;++i)

				{

				const TRect& logRect = aRegion[i];

				TRect physRect; 

				physRect.iTl.iX = ::Log2Phys(logRect.iTl.iX, originX, factorX, iSize.iWidth);

				physRect.iTl.iY = ::Log2Phys(logRect.iTl.iY, originY, factorY, iSize.iHeight);

				physRect.iBr.iX = ::RBtmLog2Phys(logRect.iBr.iX, originX, factorX, iSize.iWidth);

				physRect.iBr.iY = ::RBtmLog2Phys(logRect.iBr.iY, originY, factorY, iSize.iHeight);

				//The next statement sometimes have to allocate a block of memory and may

				//fail setting RRegion's internal error flag. But there is nothing we can do.

				physRegion.AddRect(physRect);

				}

			iUpdateRegion.Union(physRegion);

			physRegion.Close();

			}

		}

	Update();

	}

//

// Update the update region.

// aRect - logical coordinates

template <class T> void CScreenDevice<T>::UpdateRegion(const TRect& aRect)

	{

	register TInt originX = iOrigin.iX;

	register TInt originY = iOrigin.iY;

	register TInt factorX = iScalingSettings.iFactorX;

	register TInt factorY = iScalingSettings.iFactorY;

	TRect physRect; 

	physRect.iTl.iX = ::Log2Phys(aRect.iTl.iX, originX, factorX, iSize.iWidth);

	physRect.iTl.iY = ::Log2Phys(aRect.iTl.iY, originY, factorY, iSize.iHeight);

	physRect.iBr.iX = ::RBtmLog2Phys(aRect.iBr.iX, originX, factorX, iSize.iWidth);

	physRect.iBr.iY = ::RBtmLog2Phys(aRect.iBr.iY, originY, factorY, iSize.iHeight);

	physRect.Normalize();

	iUpdateRegion.AddRect(physRect);

	if(iUpdateRegion.Count() >= 10)

		{

		iUpdateRegion.AddRect(iUpdateRegion.BoundingRect());

		}

	if(iAutoUpdate)

		{

		Update();

		}

	}

template <class T> void CScreenDevice<T>::UpdateScreen(const TRegion& aRegion)

	{

	if (aRegion.CheckError())

		UpdateRect(iSize);

	else

		for(TInt count = 0; count < aRegion.Count(); count++)

			UpdateRect(aRegion[count]);

	iWindow->Update(aRegion,iSize);

	}

template <class T> TUint8* CScreenDevice<T>::WinPixelAddress(TInt aX,TInt aY) const

	{

	return iWindow->PixelAddress(aX,aY);

	}