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

#include <e32hal.h>

#ifdef SYMBIAN_GRAPHICS_GCE

#undef __WINS__

#include "../sgeneric/scdraw.h"

#elif defined(__WINS__)

#include "_WININC.H"

#endif

//

//	CGenericDirectScreenBitmap: Implementation of generic CDirectScreenBitmap class

//

NONSHARABLE_CLASS(CGenericDirectScreenBitmap) : public CDirectScreenBitmap

	{

public:

	 CGenericDirectScreenBitmap();

	 CGenericDirectScreenBitmap(TInt aScreenNo);

	~CGenericDirectScreenBitmap();

public:

	// Pure virtual from CDirectScreenBitmap

	virtual TInt Create(const TRect& aScreenRect, TSettingsFlags aSettingsFlags);

	virtual TInt BeginUpdate(TAcceleratedBitmapInfo& aBitmapInfo);

	virtual void EndUpdate(TRequestStatus& aComplete);

	virtual void EndUpdate(const TRect& aScreenRect, TRequestStatus& aComplete);

	virtual void Close();

public:

	enum TDsbPanic

		{

		EPanicAlreadyCreated = 1,

		EPanicNotCreated     = 2,

		EPanicInvalidMode    = 3,

		EPanicOutOfBounds	 = 4,

		EPanicNotWordAligned = 5,

		EPanicInvalidRect    = 6,

		EPanicIncompleteRequest = 7,

		EPanicHandleReturnedIncorrect = 8

		};

    static void Panic(TDsbPanic aPanic);

private:

	TInt DoCreate();

#ifdef __WINS__

	TRgb ExtractRgb(TUint8* aBuffer,TInt aPixelOffset) const;

	void WinsUpdate(const TRect& aScreenRect);

#endif

private:

#ifndef __WINS__

	TInt    iVideoAddress;

#endif

#ifdef SYMBIAN_GRAPHICS_GCE

    CScreenDeviceHelper iSurfaceUpdater;

    TUidPixelFormat iPixelFormat;

#endif

	TAcceleratedBitmapInfo iBitmapInfo;

	TUint32 iSettingsFlags;

	TRect   iUpdateRect;

	TInt    iDisplayOffsetLines;

	TInt    iBytesPerPixel;

	TInt	iDisplayOffsetPixel;

	TBool   iCreated;

    TInt    iScreenNo;

    RChunk 	iChunk;

    TBool 	iHasChunk;

	};

//

// Create a new instance of a DSB

// The default screen (with number 0) will be used

EXPORT_C CDirectScreenBitmap* CDirectScreenBitmap::NewL()

	{

	CGenericDirectScreenBitmap* pDsb=new(ELeave) CGenericDirectScreenBitmap;

	return(pDsb);

	}

//

// Create a new instance of a DSB

// The screen with aScreenNo number will be used

EXPORT_C CDirectScreenBitmap* CDirectScreenBitmap::NewL(TInt aScreenNo)

    {

	CGenericDirectScreenBitmap* pDsb = new (ELeave) CGenericDirectScreenBitmap(aScreenNo);

	return pDsb;

    }

CGenericDirectScreenBitmap::CGenericDirectScreenBitmap() :

#ifndef __WINS__

	iVideoAddress(NULL),

#endif

	iBitmapInfo(),

	iSettingsFlags(ENone),

	iUpdateRect(),

	iDisplayOffsetLines(0),

	iBytesPerPixel(0),

	iDisplayOffsetPixel(0),

	iHasChunk(EFalse)

	{

    }

CGenericDirectScreenBitmap::CGenericDirectScreenBitmap(TInt aScreenNo) :

    iScreenNo(aScreenNo)

    {

    }

CGenericDirectScreenBitmap::~CGenericDirectScreenBitmap()

	{

	Close();

	}

//

// Create a DSB object using a region of the screen previously

// 'claimed' via the Window Servers Direct Screen Acceass API

//

TInt CGenericDirectScreenBitmap::Create(const TRect& aScreenRect, TSettingsFlags aSettingsFlags)

	{

	__ASSERT_ALWAYS(!iCreated, Panic(EPanicAlreadyCreated));

	__ASSERT_ALWAYS((aSettingsFlags&(EDoubleBuffer|EIncrementalUpdate)) !=

					(EDoubleBuffer|EIncrementalUpdate), Panic(EPanicInvalidMode));

    //Initialize iScreenNo - its value occupies upper 5 bits of aSettingsFlags.

    //(32 - 1) is max allowed screen number

    iScreenNo = static_cast <TUint32> ((aSettingsFlags & 0xF8000000) >> 27);

	// Find the screen dimensions from the HAL and validate

	TInt screenWidth = 0;

	TInt screenHeight = 0;

	TInt r = HAL::Get(iScreenNo, HALData::EDisplayXPixels, screenWidth);

	if (r!=KErrNone)

		{

		return r;

		}

	r = HAL::Get(iScreenNo, HALData::EDisplayYPixels,screenHeight);

	if (r!=KErrNone)

		{

		return r;

		}

	__ASSERT_ALWAYS(aScreenRect.iTl.iX >= 0 &&

	__ASSERT_ALWAYS(aScreenRect.Width() > 0 &&

					aScreenRect.Height() > 0, Panic(EPanicInvalidRect));

	iUpdateRect = aScreenRect;

	iSettingsFlags = aSettingsFlags;

	r = DoCreate();

	if(r != KErrNone)

		{

		return r;

		}

	// Check that LHS is word-aligned

	const TUint pixelStartInBytes = aScreenRect.iTl.iX*iBytesPerPixel;

	const TUint pixelEndInBytes = aScreenRect.iBr.iX*iBytesPerPixel;

	// Check the alignment

	__ASSERT_ALWAYS(!(pixelStartInBytes & 0x03), Panic(EPanicNotWordAligned));

	__ASSERT_ALWAYS(!(pixelEndInBytes & 0x03),	 Panic(EPanicNotWordAligned));

	const TUint scanlineBytes = pixelEndInBytes-pixelStartInBytes;

#ifndef __WINS__	

	iVideoAddress += pixelStartInBytes +						// X Offset

						 iUpdateRect.iTl.iY*iDisplayOffsetLines +	// Y Offset

						 iDisplayOffsetPixel;						 // Pixel (Palette) Offset

#endif 

	// Since this is a generic implementation, we only require one

	//  buffer for both incremental and double buffered mode

	iBitmapInfo.iAddress = (TUint8*)User::Alloc(scanlineBytes * iUpdateRect.Height());

	if(!iBitmapInfo.iAddress)

		return KErrNoMemory;

	iBitmapInfo.iSize			 = TSize(iUpdateRect.Width(), iUpdateRect.Height());

	iBitmapInfo.iLinePitch		 = scanlineBytes;

	iBitmapInfo.iPhysicalAddress = 0;

	// All done

	iCreated = ETrue;

	return KErrNone;

	}

#ifndef __WINS__

//

// Attempt to initialise using the HAL

//

TInt CGenericDirectScreenBitmap::DoCreate()

	{

    // For GCE, if multiple modes are supported, only one needs to be returned.

	// On the emulator, what is returned via EDisplayMode can be set via ColorDepth setting in epoc.ini

	// On the hardware, 24/32bpp color mode is returned via EDisplayMode as pre-defined. 

	TInt displayMode = 0;

	TInt r1 = HAL::Get(iScreenNo, HALData::EDisplayMode, displayMode);

	if (r1!=KErrNone)

		{

		return r1;

		}

	TInt bitsPerPixel = displayMode;

	r1 = HAL::Get(iScreenNo, HALData::EDisplayBitsPerPixel, bitsPerPixel);

	if (r1!=KErrNone)

		{

		return r1;

		}

	iBytesPerPixel = (bitsPerPixel+7) >> 3;

	// Store the important driver parameters to avoid HAL calls when drawing

	iDisplayOffsetPixel = displayMode;

	r1 = HAL::Get(iScreenNo, HALData::EDisplayOffsetToFirstPixel, iDisplayOffsetPixel);

	if (r1!=KErrNone)

		{

		return r1;

		}

	iDisplayOffsetLines = displayMode;

	r1 = HAL::Get(iScreenNo, HALData::EDisplayOffsetBetweenLines, iDisplayOffsetLines);

	if (r1!=KErrNone)

		{

		return r1;

		}

	TInt val = 0;

	r1 = HAL::Get(iScreenNo, HALData::EDisplayMemoryHandle,val);

	if (r1 == KErrNotSupported)

		{

		// EDisplayMemoryHandle is not supported, use the address instead

		r1 = HAL::Get(iScreenNo, HALData::EDisplayMemoryAddress, iVideoAddress);

		if (r1!=KErrNone)

			{

			return r1;

			}

		}

	else if (r1 == KErrNone)

		{

		// EDisplayMemoryHandle is supported, use the handle base address

		__ASSERT_ALWAYS(val != 0, Panic(EPanicHandleReturnedIncorrect));

		RChunk chunk;

		r1 = chunk.SetReturnedHandle(val);

		if (r1 != KErrNone)

			{

			return r1;

			}

		iChunk = chunk;

		r1 = iChunk.Duplicate(RThread(), EOwnerProcess);

		chunk.Close();

		if (r1 != KErrNone)

			{

			return r1;

			}

		iVideoAddress = (TInt)iChunk.Base();

		iHasChunk = ETrue;

		}

	else  

		{

		return r1;

		}

	// The HAL doesn't specify explicit dislpay modes, so we need

	// to calculate the mode using bitsPerPixel and isMono

	TBool isMono = displayMode;

	r1 = HAL::Get(iScreenNo, HALData::EDisplayIsMono, isMono);

	if (r1!=KErrNone)

		{

		return r1;   

		}

     switch(bitsPerPixel)

		{

		// EGray2, EGray4, EGray16, EColor16 not supported on the hardware

		// The generic scdv support EGray2, EGray4, EGray16, EColor16 on the emulator

		// However, the low display modes should not be used.

		case 1:

			iBitmapInfo.iPixelShift = 0;

			iBitmapInfo.iDisplayMode = EGray2;

			iBytesPerPixel = 2;

#ifdef SYMBIAN_GRAPHICS_GCE

			iPixelFormat = EUidPixelFormatUnknown;

#endif

			break;

		case 2:

			iBitmapInfo.iPixelShift = 1;

			iBitmapInfo.iDisplayMode = EGray4;

			iBytesPerPixel = 2;

#ifdef SYMBIAN_GRAPHICS_GCE

			iPixelFormat = EUidPixelFormatUnknown;

#endif

			break;

		case 4:

			iBitmapInfo.iPixelShift = 2;

			iBitmapInfo.iDisplayMode = isMono ? EGray16 : EColor16;

			iBytesPerPixel = 2;

#ifdef SYMBIAN_GRAPHICS_GCE

			iPixelFormat = EUidPixelFormatUnknown;

#endif

			break;	 

		case 8:

			iBitmapInfo.iPixelShift = 3;

			iBitmapInfo.iDisplayMode = isMono ? EGray256 : EColor256;

			iBytesPerPixel = 2;

#ifdef SYMBIAN_GRAPHICS_GCE

			iPixelFormat = EUidPixelFormatUnknown;

#endif

			break;

		case 12:

			iBitmapInfo.iPixelShift = 4;

			iBitmapInfo.iDisplayMode = EColor4K;

#ifdef SYMBIAN_GRAPHICS_GCE

			iPixelFormat = EUidPixelFormatXRGB_4444;

#endif

			break;

		case 16:

			iBitmapInfo.iPixelShift = 4;

			iBitmapInfo.iDisplayMode = EColor64K;

#ifdef SYMBIAN_GRAPHICS_GCE

			iPixelFormat = EUidPixelFormatRGB_565;

#endif

			break;

		case 24:

		case 32:

			iBitmapInfo.iPixelShift = 5;

			iBitmapInfo.iDisplayMode = EColor16MAP;

#ifdef SYMBIAN_GRAPHICS_GCE

			iPixelFormat = EUidPixelFormatARGB_8888_PRE;

			iBytesPerPixel = 4;

#endif

			break;

		default:

			return KErrNotSupported;

		}

#ifdef SYMBIAN_GRAPHICS_GCE

    TInt ret = iSurfaceUpdater.Construct(iScreenNo,iPixelFormat,displayMode);

 	if (ret != KErrNone)

 		{

 		return ret;

 		}

#endif

	return KErrNone;

	}

#endif

#ifdef __WINS__

//

// Attempt to initialise for WINS

// This is intended for use if HAL initialisation fails.

//

TInt CGenericDirectScreenBitmap::DoCreate()

	{

    RWindows* window = ::WindowHandler(iScreenNo);

    if(window)

		{

		iBitmapInfo.iDisplayMode = window->iDisplayMode;

		iDisplayOffsetLines		 = window->iEpocBitmapLinePitch;

		iDisplayOffsetPixel		 = 0;

		switch(iBitmapInfo.iDisplayMode)

			{

			case EGray2:

				iBitmapInfo.iPixelShift = 0;

				iBytesPerPixel = 1;

				break;

			case EGray4:

				iBitmapInfo.iPixelShift = 1;

				iBytesPerPixel = 1;

				break;

			case EGray16:

			case EColor16:

				iBitmapInfo.iPixelShift = 2;

				iBytesPerPixel = 1;

				break;

			case EGray256:

			case EColor256:

				iBitmapInfo.iPixelShift = 3;

				iBytesPerPixel = 1;

				break;

			case EColor4K:

			case EColor64K:

				iBitmapInfo.iPixelShift = 4;

				iBytesPerPixel = 2;

				break;

			case EColor16M:

				iBitmapInfo.iPixelShift = 5;

				iBytesPerPixel = 3;

				break;

			case ERgb:

			case EColor16MU:

			case EColor16MA:

			case EColor16MAP:

				iBitmapInfo.iPixelShift = 5;

				iBytesPerPixel = 4;

				break;

			default:

				return KErrNotSupported;

			}

		return KErrNone;

		}

	else

		{

		return KErrNoMemory;

		}

	}

#endif

//

// Begin update - aBitmapinfo returns the current bitmap

//

TInt CGenericDirectScreenBitmap::BeginUpdate(TAcceleratedBitmapInfo& aBitmapInfo)

	{

	__ASSERT_ALWAYS(iCreated, Panic(EPanicNotCreated));

	aBitmapInfo = iBitmapInfo;

	return KErrNone;

	}

#ifdef __WINS__

void CGenericDirectScreenBitmap::WinsUpdate(const TRect& aScreenRect)

	{

	const TUint dS = iBitmapInfo.iLinePitch;

	const TUint offY = aScreenRect.iTl.iY - iUpdateRect.iTl.iY;

	TUint8* pS = iBitmapInfo.iAddress + (offY*dS);

	RWindows* window = ::WindowHandler(iScreenNo);

	TInt orientation=window->Orientation();

	TRect orientedRect;

	TSize orientedSize;

	orientedSize = window->GetOrientedSize();

	orientedRect = window->GetOrientedRect(aScreenRect);

	TInt BrX = iUpdateRect.iBr.iX-1;

	TInt BrY = iUpdateRect.iBr.iY-1;

	for(TInt y=aScreenRect.iTl.iY; y < aScreenRect.iBr.iY; y++)

		{

		TRgb pixelColor;

		TInt xSource = aScreenRect.iTl.iX-iUpdateRect.iTl.iX;

		for(TInt x = aScreenRect.iTl.iX; x < aScreenRect.iBr.iX; x++)

			{

			TUint8* pD;

			switch(orientation)

				{

				case 0:

					pD = window->PixelAddress(x, y);

					break;

				case 1:

					pD = window->PixelAddress(y, BrX-x);

					break;

				case 2:

					pD = window->PixelAddress(BrX-x, BrY-y);

					break;

				case 3:

					pD = window->PixelAddress(BrY-y, x);

					break;

				default:

					break;

				}

			// Convert the user colour to RGB, as required by the WINS Emulator

			pixelColor = ExtractRgb(pS, xSource++);

			pD[0] = TUint8(pixelColor.Blue());

			pD[1] = TUint8(pixelColor.Green());

			pD[2] = TUint8(pixelColor.Red());

			}

		pS += dS;

		}

	RRegion region;

	region.AddRect(orientedRect);

	window->Update(region,orientedSize);

	region.Close();

	}

#endif

//

// End Update - Commit changes to the Frame Buffer

//

void CGenericDirectScreenBitmap::EndUpdate(TRequestStatus& aComplete)

	{

	__ASSERT_ALWAYS(iCreated, Panic(EPanicNotCreated));

	TUint8* pS = iBitmapInfo.iAddress;

	const TUint dS = iBitmapInfo.iLinePitch;

#ifdef __WINS__

	WinsUpdate(iUpdateRect);

#else