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