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

// Windows headers...

#define UNICODE

#pragma warning( disable : 4201 )

#define WIN32_LEAN_AND_MEAN

#define NOSERVICE

#include <windows.h>

#include <windowsx.h>

#pragma warning( default : 4201 )

#include "_WININC.H"

LOCAL_D const TGraphicsAcceleratorCaps HardwareAcceleratorCapabilities = 

	{

	sizeof(TGraphicsAcceleratorCaps),							//TInt iStructureSize;	// The size of this class

	1,															//TInt iVersion;		// == 1 to specify current API

	0,															//Tint iVendorUid;		// Optional ID

	1<<EColor256,												//iDisplayModes;

	0,															//iClipping;

	TGraphicsAcceleratorCaps::EMaskBitmapMatchingDisplayMode,	//iMaskType;

	0,															//iTransparency;

	0,															//iAlphaChannel;

	TGraphicsAcceleratorCaps::EAlphaBitmapGray256,				//iAlphaBitmap;

	(TUint)TGraphicsAcceleratorCaps::EPatternSizeAny,			//iPatternSizes;

	TGraphicsAcceleratorCaps::EPatternMatchingDisplayMode,		//iPattern;

	0,															//iPolygon;

	{TGraphicsAcceleratorCaps::EOrientationCapNormal,0,0,0}		//iReserved[0] is used for supported orientations, iReserved[1]-iReserved[3] are reserved;

	};

//

// CHardwareGraphicsAccelerator

//

/** 

Allocates and constructs an instance of a derived class and initialises its 

capabilities.

@param aBitmap The hardware bitmap for the accelerator to draw to.

@return Pointer to the initialised graphics accelerator object.

@see TGraphicsAcceleratorCaps::iDisplayModes 

@leave KErrNoMemory There is no memory to allocate the graphics accelerator

       KErrNotSupported There is no graphics accelerator supporting the display mode given by the bitmap parameter

*/

EXPORT_C CHardwareGraphicsAccelerator* CHardwareGraphicsAccelerator::NewL(RHardwareBitmap aBitmap)

	{

	TAcceleratedBitmapInfo hwBitmapInfo;

	aBitmap.GetInfo(hwBitmapInfo);

	switch(hwBitmapInfo.iDisplayMode)

		{

		case EColor256:

			return CColor256HardwareGraphicsAccelerator::NewL(aBitmap);

		default:

			User::Leave(KErrNotSupported);

			return NULL;

		}

	}

/** 

Gets the generic capabilities of the accelerator, including which display modes 

are supported for the bitmap passed to NewL().

Generic capabilities apply to all hardware graphics accelerators on the device. 

The function is static, so it can be used to find out the capabilities of 

graphics accelerators before deciding on whether or not to create one.

The CGraphicsAccelerator::Capabilities() function provides information about 

the capabilities of a particular graphics accelerator.

As capabilities may vary depending on the display mode of a bitmap, this method 

should indicate as supported any features which are only available in some 

display modes.

@return Generic capabilities for hardware graphics accelerators. 

*/

EXPORT_C const TGraphicsAcceleratorCaps* CHardwareGraphicsAccelerator::GenericCapabilities()

	{

	return &HardwareAcceleratorCapabilities;

	}

//

// CColor256HardwareGraphicsAccelerator

//

CColor256HardwareGraphicsAccelerator* CColor256HardwareGraphicsAccelerator::NewL(RHardwareBitmap aBitmap)

	{

	CColor256HardwareGraphicsAccelerator* self = new (ELeave) CColor256HardwareGraphicsAccelerator;

	CleanupStack::PushL(self);

	self->ConstructL(aBitmap);

	CleanupStack::Pop();

	return(self);

	}

void CColor256HardwareGraphicsAccelerator::ConstructL(RHardwareBitmap aBitmap)

	{

	CHardwareGraphicsAcceleratorBase::ConstructL(aBitmap);

	iCaps = &HardwareAcceleratorCapabilities; // We only do Color256

 	//Some explanations about "-aBitmap.iHandle - 1" expression.

    //Before "Multiple screens" update aBitmap.iHandle with value -1 meant that the related

    //RHardwareBitmap object is a screen bitmap. Positive aBitmap.iHandle values - it was

    //an in-memory RHardwareBitmap object.

    //After "Multiple screens" update, the meaning of aBitmap.iHandle's value is:

    // - Positive value - in-memory hardware bitmap;

    // - Negative value - screen number: "-1" - screen 0, "-2" - screen 1, "-3" - screen 2, ...;

    if (aBitmap.iHandle < 0)

    	{

    	iScreenNo = -aBitmap.iHandle - 1;	

	    }

  	}

TUint32 CColor256HardwareGraphicsAccelerator::FillValue(TRgb aColor)

	{

	TUint32 value = aColor.Color256();

	value |= value<<8;

	value |= value<<16;

	return value;

	}

void CColor256HardwareGraphicsAccelerator::DoUpdateScreen(const TRect& aRect)

	{

	TInt lx = aRect.iTl.iX & ~3;

	TInt rx = (aRect.iBr.iX + 3) & ~3;

	TUint8* srcePtr = iBitmapInfo.iAddress+iBitmapInfo.iLinePitch*aRect.iTl.iY+lx;

	TUint8* srcePtrLimit = srcePtr + rx - lx;

	TInt linePitch = iBitmapInfo.iLinePitch;

    RWindows* window = ::WindowHandler(iScreenNo);

	for(TInt row = aRect.iTl.iY; row < aRect.iBr.iY; row++)

		{

		TUint8* tempSrcePtr = srcePtr;

		TUint8* destPixel = window->PixelAddress(lx,row);

		TRgb pixelColor;

		if(window->iPalette)

			{

			while (tempSrcePtr < srcePtrLimit)

				{

				pixelColor = window->iPalette[*tempSrcePtr++];

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

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

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

				destPixel += 3;

				}

			}

		else

			{

			while (tempSrcePtr < srcePtrLimit)

				{

				pixelColor = TRgb::Color256(*tempSrcePtr++);

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

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

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

				destPixel += 3;

				}

			}

		srcePtr += linePitch;

		srcePtrLimit += linePitch;

		}

	RRegion region;

	region.AddRect(aRect);

	window->Update(region,window->iEpocBitmapSize);

	region.Close();

	}

void CColor256HardwareGraphicsAccelerator::DoFillRect(const TRect& aRect,TUint32 aFillValue)

	{

	//Lock();

	TUint32* ptr = (TUint32*)iBitmapInfo.iAddress;

	TUint32* ptrLimit;

	TUint32 leftMask;

	TUint32 rightMask;

	TInt ptrPitch;

	TInt pitch;

	TInt height;

	{

	TInt yStart = aRect.iTl.iY;

	TInt yEnd = aRect.iBr.iY;

	if(yStart<0)

		goto error;

	if(yStart>=yEnd)

		goto error;

	if(yEnd>iBitmapInfo.iSize.iHeight)

		goto error;

	ptr = (TUint32*)((TUint8*)ptr+yStart*iBitmapInfo.iLinePitch);

	height = yEnd-yStart;

	}

	{

	TInt xStart = aRect.iTl.iX;

	TInt xEnd = aRect.iBr.iX;

	if(xStart<0)

		goto error;

	if(xStart>=xEnd)

		goto error;

	if(xEnd>iBitmapInfo.iSize.iWidth)

		goto error;

	xStart <<= iBitmapInfo.iPixelShift;

	xEnd <<= iBitmapInfo.iPixelShift;

	leftMask = ~((1<<(xStart&0x1F))-1);

	rightMask = (1<<(xEnd&0x1F))-1;

	xStart >>= 5;

	xEnd = (xEnd-1)>>5;

	ptrLimit = ptr+xEnd;

	ptr += xStart;

	pitch = iBitmapInfo.iLinePitch;

	ptrPitch = pitch-((TInt)ptrLimit-(TInt)ptr);

	}

	if((ptr==ptrLimit) && (leftMask!=0xFFFFFFFF)) // all pixels in a line are in the same word

		{

		if((leftMask != 0) && (rightMask !=0))

			leftMask &= rightMask;

		else if(rightMask != 0)

				leftMask = rightMask;

		aFillValue &= leftMask;

		do

			{

			TUint32 pixels = *ptr;

			pixels &= ~ leftMask;

			pixels |= aFillValue;

			*(ptr) = pixels;

			ptr = (TUint32*)((TUint8*)ptr+ptrPitch);

			}

		while(--height);

		}

	else if((leftMask==0xFFFFFFFF)&&(rightMask==0)) // all pixels in a line fit into whole words

		{

		do

			{

			while(ptr<ptrLimit)

				*(ptr++) = aFillValue;

			*ptr = aFillValue;

			ptr = (TUint32*)((TUint8*)ptr+ptrPitch);

			ptrLimit = (TUint32*)((TUint8*)ptrLimit+pitch);

			}

		while(--height);

		}

	else if(leftMask==0xFFFFFFFF) // first pixel starts on a word boundary but last doesn't

		{

		do

			{

			while(ptr<ptrLimit) 

				*(ptr++) = aFillValue;

			TUint32 pixels = *ptr;

			pixels &= ~ rightMask;

			pixels |= aFillValue&rightMask;

			*ptr = pixels;

			ptr = (TUint32*)((TUint8*)ptr+ptrPitch);

			ptrLimit = (TUint32*)((TUint8*)ptrLimit+pitch);

			}

		while(--height);

		}

	else if(rightMask==0) // last pixel lies on a word boundary but first doesn't

		{

		do

			{

			TUint32 pixels = *ptr;

			pixels &= ~ leftMask;

			pixels |= aFillValue&leftMask;

			*(ptr++) = pixels;

			while(ptr<ptrLimit)

				*(ptr++) = aFillValue;

			*ptr = aFillValue;

			ptr = (TUint32*)((TUint8*)ptr+ptrPitch);

			ptrLimit = (TUint32*)((TUint8*)ptrLimit+pitch);

			}

		while(--height);

		}

	else // both last and first pixels in a line don't lie on a word boundary

		{

		do

			{

			TUint32 pixels = *ptr;

			pixels &= ~ leftMask;

			pixels |= aFillValue&leftMask;

			*(ptr++) = pixels;

			while(ptr<ptrLimit)

				*(ptr++) = aFillValue;

			pixels = *ptr;

			pixels &= ~ rightMask;

			pixels |= aFillValue&rightMask;

			*ptr = pixels;

			ptr = (TUint32*)((TUint8*)ptr+ptrPitch);

			ptrLimit = (TUint32*)((TUint8*)ptrLimit+pitch);

			}

		while(--height);

		}

	//Unlock();

	return;

error:

//	Unlock();

	GraphicsAcceleratorPanic(EGraphicsAcceleratorAttemptedDrawOutsideBitmap);

	}

TInt CColor256HardwareGraphicsAccelerator::DoFilledRectWithPattern(const TRect& aRect,TGopFillPattern aPattern)

	{

	if(aPattern.iBitmap.Type() != TAcceleratedBitmapSpec::EHardwareBitmap)

		return KErrNotSupported;

	TInt handle = aPattern.iBitmap.Handle();

	RHardwareBitmap aBitmap(handle);

	TAcceleratedBitmapInfo patternBitmapInfo;

	aBitmap.GetInfo(patternBitmapInfo);

    if(patternBitmapInfo.iDisplayMode != EColor256)

		return KErrNotSupported;

	//point to the first pixel of a row

	TUint8* ptrPattern8 = (TUint8*)patternBitmapInfo.iAddress;

	//point to the last pixels of a row

	TUint8* ptrLimitPattern8 = ptrPattern8 + (patternBitmapInfo.iSize.iWidth - 1);

	//current pixel to copy

	TUint8* ptrCurrentPixelPattern8 = ptrPattern8;

	TInt pitchPattern = patternBitmapInfo.iLinePitch;

	//point to the last pixel of the pattern bitmap

    TUint8* ptrEndPattern8 = ptrLimitPattern8 + pitchPattern * (patternBitmapInfo.iSize.iHeight - 1);

	TInt xOffsetPattern = 0;

	TInt difOrigins = 0;

	TUint8* ptr8 = (TUint8*)iBitmapInfo.iAddress;

	TUint8* ptrLimit8;

	TInt ptrPitch;

	TInt pitch;

	TInt height;

	{

	TInt yStart = aRect.iTl.iY;

	TInt yEnd = aRect.iBr.iY;

	if(yStart<0)

		goto error;

	if(yStart>=yEnd)

		goto error;

	if(yEnd>iBitmapInfo.iSize.iHeight)

		goto error;

	ptr8 = ptr8+yStart*iBitmapInfo.iLinePitch;

	height = yEnd-yStart;

	}

	{

	TInt xStart = aRect.iTl.iX;

	TInt xEnd = aRect.iBr.iX;

	if(xStart<0)

		goto error;

	if(xStart>=xEnd)

		goto error;

	if(xEnd>iBitmapInfo.iSize.iWidth)

		goto error;

	ptrLimit8 = ptr8 + xEnd;

	ptr8 += xStart;

	pitch = iBitmapInfo.iLinePitch;

	ptrPitch = pitch-((TInt)ptrLimit8-(TInt)ptr8);

	}

	difOrigins = (aRect.iTl.iX - aPattern.iOrigin.iX) % patternBitmapInfo.iSize.iWidth;

    if(difOrigins < 0)

		{

		ptrCurrentPixelPattern8 = ptrLimitPattern8 + difOrigins + 1;

		xOffsetPattern = patternBitmapInfo.iSize.iWidth + difOrigins;

		}

	if(difOrigins > 0)

		{

		ptrCurrentPixelPattern8 = ptrPattern8 + difOrigins;

		xOffsetPattern = difOrigins;

		}

	difOrigins = (aRect.iTl.iY - aPattern.iOrigin.iY) % patternBitmapInfo.iSize.iHeight;

    if(difOrigins < 0)

		{

		TInt totalPitch = pitchPattern*(patternBitmapInfo.iSize.iHeight + difOrigins);

		ptrCurrentPixelPattern8 += totalPitch;

		ptrPattern8 += totalPitch ;

		ptrLimitPattern8 += totalPitch;

		}

	if(difOrigins > 0)

		{

		TInt totalPitch = (pitchPattern * (difOrigins));

		ptrCurrentPixelPattern8 += totalPitch;

		ptrPattern8 += totalPitch;

		ptrLimitPattern8 += totalPitch;

		}

	do

		{

		while(ptr8<ptrLimit8)

			{

			if(ptrCurrentPixelPattern8 == ptrLimitPattern8)

				{

				*ptr8 = *ptrCurrentPixelPattern8;

				ptr8++;

				ptrCurrentPixelPattern8 = ptrPattern8;

				}

			else

				*(ptr8++) = *(ptrCurrentPixelPattern8++);

			} 

			//check if on the last row

			if(ptrLimitPattern8 == ptrEndPattern8)

				{

				ptrPattern8 = (TUint8*)patternBitmapInfo.iAddress;

				ptrLimitPattern8 = ptrPattern8 + patternBitmapInfo.iSize.iWidth - 1;

                ptrCurrentPixelPattern8 = ptrPattern8 + xOffsetPattern;

				}

			else

				{

				ptrPattern8 += pitchPattern;

				ptrLimitPattern8 += pitchPattern;

                ptrCurrentPixelPattern8 = ptrPattern8 + xOffsetPattern;

				}

		ptr8 = ptr8+ptrPitch;

		ptrLimit8= ptrLimit8+pitch;

		}

	while(--height);

	return KErrNone;

error:

	GraphicsAcceleratorPanic(EGraphicsAcceleratorAttemptedDrawOutsideBitmap);

	return KErrNone; // Will not be executed but prevents compiler warnings

	}

void CColor256HardwareGraphicsAccelerator::DoInvertRect(const TRect& aRect)

	{

	//Lock();

	TUint32* ptr = (TUint32*)iBitmapInfo.iAddress;

	TUint32* ptrLimit;

	TUint32 leftMask;

	TUint32 rightMask;

	TInt ptrPitch;

	TInt pitch;

	TInt height;

	{

	TInt yStart = aRect.iTl.iY;

	TInt yEnd = aRect.iBr.iY;

	if(yStart<0)

		goto error;

	if(yStart>=yEnd)

		goto error;

	if(yEnd>iBitmapInfo.iSize.iHeight)

		goto error;

	ptr = (TUint32*)((TUint8*)ptr+yStart*iBitmapInfo.iLinePitch);

	height = yEnd-yStart;

	}

	{

	TInt xStart = aRect.iTl.iX;

	TInt xEnd = aRect.iBr.iX;

	if(xStart<0)

		goto error;

	if(xStart>=xEnd)

		goto error;

	if(xEnd>iBitmapInfo.iSize.iWidth)

		goto error;

	xStart <<= iBitmapInfo.iPixelShift;

	xEnd <<= iBitmapInfo.iPixelShift;

	leftMask = ~((1<<(xStart&0x1F))-1);

	rightMask = (1<<(xEnd&0x1F))-1;

	xStart >>= 5;

	xEnd = (xEnd-1)>>5;

	ptrLimit = ptr+xEnd;

	ptr += xStart;

	pitch = iBitmapInfo.iLinePitch;

	ptrPitch = pitch-((TInt)ptrLimit-(TInt)ptr);

	}

	TUint32 pixelsInverted;

	if((ptr==ptrLimit) && (leftMask!=0xFFFFFFFF)) // all pixels in a line are in the same word

		{

		if((leftMask != 0) && (rightMask !=0))

			leftMask &= rightMask;

		else if(rightMask != 0)

				leftMask = rightMask;

		do

			{

			TUint32 pixels = *ptr;

			pixelsInverted = ~ pixels;