// Copyright (c) 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 "tsurfacehelper.h"

#include <w32std.h>

CSurfaceHelper* CSurfaceHelper::NewL()

	{

	CSurfaceHelper* helper = new(ELeave)CSurfaceHelper;

	CleanupStack::PushL(helper);

	helper->ConstructL();

	CleanupStack::Pop(helper);

	return helper;

	}

CSurfaceHelper::~CSurfaceHelper()

	{

	DestroySurfaces();

	iSurfaces.Close();

	iManager.Close();

	}

/**

 * Load logical device and open a surface manager

 */

void CSurfaceHelper::ConstructL()

	{

	TInt res = iManager.Open();

	if (res != KErrNone)

		{

		User::Leave(res);

		}

	}

/**

 * Create the surface with the given parameters.

 * The surface will be owned by the instance of this class  

 */

TSurfaceId CSurfaceHelper::CreateSurfaceL(const TSize& aSize, TUidPixelFormat aPixelFormat, TInt aStride, TInt aBuffers)

	{

	RSurfaceManager::TSurfaceCreationAttributesBuf bf;

	RSurfaceManager::TSurfaceCreationAttributes& b = bf();

	b.iSize.iWidth = aSize.iWidth;

	b.iSize.iHeight = aSize.iHeight;

	b.iBuffers = aBuffers;				// number of buffers in the surface

	b.iPixelFormat = aPixelFormat;

	b.iStride = aStride;		// Number of bytes between start of one line and start of next

	b.iOffsetToFirstBuffer = 0;	// way of reserving space before the surface pixel data

	b.iAlignment = 4;			// alignment, 1,2,4,8 byte aligned

	b.iContiguous = EFalse;

	b.iMappable = ETrue;

	TSurfaceId surface = TSurfaceId::CreateNullId();

	User::LeaveIfError(iManager.CreateSurface(bf, surface));

	iSurfaces.AppendL(surface);

	return surface;

	}

/**

 * Destroy all surfaces wich have been created by the instance of this class

 */

void CSurfaceHelper::DestroySurfaces()

	{

	TInt numSurfaces = iSurfaces.Count();

	for (TInt index = 0; index < numSurfaces; index++)

		{

		TSurfaceId surfaceId = iSurfaces[index];

		TInt err = iManager.CloseSurface(surfaceId);

		__ASSERT_DEBUG(err ==KErrNone, User::Panic(_L("CSurfaceHelper::DestroySurfaces"), err));

		}

	iSurfaces.Reset();

	}

/**

Fill a rectangle on the given surface.

@param aSurface		The surface to be filled.

@param aStartPos	Where to place the rectangle.

@param aSize		Size of the rectangle.

@param aColor		The colour to fill it with.

*/

void CSurfaceHelper::FillRectangleL(const TSurfaceId& aSurface, const TPoint& aStartPos, const TSize& aSize, const TRgb& aColor)

	{

	RSurfaceManager::TInfoBuf infoBuf;

	RSurfaceManager::TSurfaceInfoV01& info = infoBuf();

	User::LeaveIfError(iManager.SurfaceInfo(aSurface, infoBuf));

	TUint32 color = 0;

	if (info.iSize.iHeight<0 || info.iSize.iWidth<0 || info.iStride<0)

		{

		User::Leave(KErrCorrupt);

		}

	if (info.iSize.iHeight==0 || info.iSize.iWidth==0 || info.iStride==0)

		{

		User::Leave(KErrNotReady);

		}

	switch (info.iPixelFormat)

		{

		case EUidPixelFormatXRGB_8888:

			{

			color = aColor.Color16MU();

#ifdef ALPHA_FIX_24BIT

			color |= ((ALPHA_FIX_24BIT)&0xff)<<24;

#endif

			break;

			}

		case EUidPixelFormatARGB_8888:

			{

			color = aColor.Color16MA();

			break;

			}

		case EUidPixelFormatARGB_8888_PRE:

			{

			color = aColor.Color16MAP();

			break;

			}

		case EUidPixelFormatRGB_565:

			{

			color = aColor.Color64K();

			break;

			}

		default:

			{

			User::Leave(KErrNotSupported);

			break;

			}

		}

	RChunk chunk;

	User::LeaveIfError(iManager.MapSurface(aSurface, chunk));

	CleanupClosePushL(chunk);

	TUint8* surfacePtr = chunk.Base();

	// Check for out of bounds

	TBool validRect = ETrue;

	TInt surfaceWidth = info.iSize.iWidth;

	TInt surfaceHeight = info.iSize.iHeight;

	// Width and Height

	if ((aStartPos.iX + aSize.iWidth) > surfaceWidth)

		{

		validRect = EFalse;

		}

	if ((aStartPos.iY + aSize.iHeight) > surfaceHeight)

		{

		validRect = EFalse;

		}

	// Starting position

	if ((aStartPos.iX < 0) || (aStartPos.iY < 0))

		{

		validRect = EFalse;

		}

	if (!validRect)

		{

		User::Leave(KErrOverflow);

		}

	if (info.iPixelFormat == EUidPixelFormatRGB_565)

		{//2 bytes per pixel

		if ( info.iSize.iWidth*2>info.iStride)

			{

			User::Leave(KErrOverflow);

			}

		TInt offset;

		User::LeaveIfError(iManager.GetBufferOffset(aSurface, 0, offset));

		TUint16* ptr = reinterpret_cast<TUint16*>(surfacePtr + offset);

		// Fill the rectangle

		TInt yPos = aStartPos.iY;

		TInt xPos = aStartPos.iX;

		for (TInt yy = 0; yy < aSize.iHeight; ++yy)

			{

			ptr = reinterpret_cast<TUint16*>(surfacePtr + (yPos*info.iStride));

			for (TInt xx = 0; xx < aSize.iWidth; ++xx)

				{

				ptr[xPos] = color;

				xPos++;

				}

			xPos = aStartPos.iX;

			yPos++;

			}

		}

	else

		{

		if ( info.iSize.iWidth*4>info.iStride)

			{

			User::Leave(KErrOverflow);

			}

		TInt offset;

		User::LeaveIfError(iManager.GetBufferOffset(aSurface, 0, offset));

		TUint32* ptr = reinterpret_cast<TUint32*>(surfacePtr + offset);		

		// Fill the rectangle

		TInt yPos = aStartPos.iY;

		TInt xPos = aStartPos.iX;

		for (TInt yy = 0; yy < aSize.iHeight; ++yy)

			{

			ptr = reinterpret_cast<TUint32*>(surfacePtr+(yPos*info.iStride));

			for (TInt xx = 0; xx < aSize.iWidth; ++xx)

				{

				ptr[xPos] = color;

				xPos++;

				}

			xPos = aStartPos.iX;

			yPos++;

			}

		}

	CleanupStack::PopAndDestroy(&chunk);

	}