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

#include <bitdrawinterfaceid.h>

#include <bmalphablend.h>

/**

@see MDirectGdiEngine::SetFont()

*/

void CSwDirectGdiEngine::SetFont(TUint32 /*aFontId*/)

	{

	// Do nothing.

	// The SW adapter doesn't need the font ID to index a separate font cache because it uses the standard one.

	}

/**

@see MDirectGdiEngine::ResetFont()

*/

void CSwDirectGdiEngine::ResetFont()

	{

	}

/**

@see MDirectGdiEngine::SetTextShadowColor()

*/

void CSwDirectGdiEngine::SetTextShadowColor(const TRgb& aColor)

	{	

	iTextShadowColor = aColor;

	}

/**

@see MDirectGdiEngine::BeginDrawGlyph()

*/

void CSwDirectGdiEngine::BeginDrawGlyph()

	{

	}

/**

@see MDirectGdiEngine::DrawGlyph()

@panic DGDIAdapter 56, if an invalid glyph bitmap type is passed in.

*/

void CSwDirectGdiEngine::DrawGlyph(const TPoint& aScrPos, const TChar /*aChar*/, const TUint8* aGlyphImage,

								   const TGlyphBitmapType aGlyphBitmapType, const TSize& aGlyphImageSize,

								   const TRect& aScrClipRect, const DirectGdi::TGraphicsRotation aRotation)

	{

	TPoint pos=aScrPos;

	pos+=iDrawOrigin;

	TRect clipRect=aScrClipRect;

	clipRect.iTl+=iDrawOrigin;

	clipRect.iBr+=iDrawOrigin;

	TRect regionRect(0, 0, 0, 0);

	TInt numRects = iDefaultRegionPtr->Count();

	for (TInt count = 0; count < numRects; count++)

		{

		// Do the clip rects intersect?

		regionRect = (*iDefaultRegionPtr)[count];

		if (!regionRect.Intersects(clipRect))

			{

			// Nothing to draw

			continue;

			}

		// Clip to intersection of two clip rects

		regionRect.Intersection(clipRect);

		if (aRotation == DirectGdi::EGraphicsRotationNone)	// Horizontal text

			{

			// Do the glyph and the clip rect intersect?

			TRect glyphRect(pos, aGlyphImageSize);

			if (!regionRect.Intersects(glyphRect))

				{

				// Nothing to draw

				continue;

				}

			// Clip to intersection with glyph bitmap 

			regionRect.Intersection(glyphRect);

			switch (aGlyphBitmapType)

				{

				case EMonochromeGlyphBitmap:

					{

					DrawBitmapGlyph(pos, aGlyphImage, aGlyphImageSize, regionRect);

					break;

					}

				case EAntiAliasedGlyphBitmap:

					{

					DrawAntiAliasedGlyph(pos, aGlyphImage, aGlyphImageSize, regionRect);

					break;

					}

				case EFourColourBlendGlyphBitmap:

					{

					DrawFourColourGlyph(pos, aGlyphImage, aGlyphImageSize, regionRect);

					break;

					}

				default:

					GRAPHICS_PANIC_ALWAYS(EDirectGdiPanicInvalidGlyphBitmapType);

				}

			}

		else	// Vertical text

			{

			/*

			// Do the glyph and the clip rect intersect?

			TRect glyphRect(aPos, aGlyphImageSize);

			if (!regionRect.Intersects(glyphRect))

				{

				// Nothing to draw

				continue;

				}

			// Clip to intersection with glyph bitmap 

			regionRect.Intersection(glyphRect);

			*/

			switch (aGlyphBitmapType)

				{

				case EMonochromeGlyphBitmap:

					{

					DrawRotatedBitmapGlyph(pos, aGlyphImage, aGlyphImageSize, regionRect, aRotation);

					break;

					}

				case EAntiAliasedGlyphBitmap:

					{

					DrawRotatedAntiAliasedGlyph(pos, aGlyphImage, aGlyphImageSize, regionRect, aRotation);

					break;

					}

				case EFourColourBlendGlyphBitmap:

					{

					DrawRotatedFourColourGlyph(pos, aGlyphImage, aGlyphImageSize, regionRect, aRotation);

					break;

					}

				default:

					GRAPHICS_PANIC_ALWAYS(EDirectGdiPanicInvalidGlyphBitmapType);

				}

			}

		// Now display it

		iDrawDevice->UpdateRegion(regionRect);

		}

	}

/**

@see MDirectGdiEngine::EndDrawGlyph()

*/

void CSwDirectGdiEngine::EndDrawGlyph()

	{

	}

/**

Draw a bitmap glyph.

@param	aPos			Position to start drawing gyph.

@param	aGlyphImage		Pointer to the glyph image data.

@param	aGlyphImageSize	Glyph image size.

@param	aClipRect		Clipping rect.

*/

void CSwDirectGdiEngine::DrawBitmapGlyph(const TPoint& aPos, const TUint8* aGlyphImage,

										 const TSize& aGlyphImageSize, const TRect& aClipRect)

	{

	// aChar parameter not needed because SW implementation uses the default glyph cache

	// therefore does not need aChar to index its own local cache

	/*

	Divert if the character is large.

	Large is defined as wider than 30 bits (a scan line won't fit in a TInt32)

	or greater than 32 bits high (because that's the current array size - could be changed).

	*/

	TInt dataHeight = aGlyphImageSize.iHeight;

	TInt dataLength = aGlyphImageSize.iWidth;

	if (dataLength > 30 || dataHeight > 32)

		{

		DrawLargeBitmapGlyph(aPos, aGlyphImage, aGlyphImageSize, aClipRect);

		return;

		}

	TInt bitIndex = 0;

	TInt16 repeatCount = 0;

	TUint32 binaryData[32];

	TUint32* binaryDataPtr = binaryData;

	TUint32* binaryDataPtrLimit;

	for (TInt glyphLine = 0; glyphLine < dataHeight; glyphLine += repeatCount) // for lines in the glyph bitmap

		{

		repeatCount = Load16(aGlyphImage + (bitIndex >> 3));

		repeatCount >>= bitIndex & 7;

		TInt multiLineFlag = repeatCount & 1;

		repeatCount >>= 1;

		repeatCount &= 0xf;

		bitIndex += 5;

		binaryDataPtrLimit = binaryData + glyphLine + repeatCount;

		if (multiLineFlag)

			{

			while (binaryDataPtr < binaryDataPtrLimit)

				{

				TInt glyphDataOffsetPtr = TInt(aGlyphImage) + (bitIndex >> 3);

				TUint32* glyphDataWord = (TUint32*)(glyphDataOffsetPtr & ~3);

				TInt bitShift = bitIndex & 7;

				bitShift += (glyphDataOffsetPtr & 3) << 3;

				*binaryDataPtr = (*glyphDataWord++) >> bitShift;

				if (bitShift)

					{

					*binaryDataPtr |= (*glyphDataWord << (32 - bitShift));

					}

				bitIndex += dataLength;

				binaryDataPtr++;

				}

			}

		else

			{

			TInt glyphDataOffsetPtr = TInt(aGlyphImage) + (bitIndex >> 3);

			TUint32* glyphDataWord = (TUint32*)(glyphDataOffsetPtr & ~3);

			TInt bitShift = bitIndex & 7;

			bitShift += (glyphDataOffsetPtr & 3) << 3;

			TUint32 data = (*glyphDataWord++) >> bitShift;

			if (bitShift)

				{

				data |= (*glyphDataWord << (32 - bitShift));

				}

			while (binaryDataPtr < binaryDataPtrLimit)

				{

				*binaryDataPtr++ = data;

				}

			bitIndex += dataLength;

			}

		}

	TPoint topLeft(aPos);

	binaryDataPtr = ClipBinaryArray(binaryData, binaryData + dataHeight, dataLength, dataHeight, topLeft, aClipRect);

	if ((dataLength > 0) && (dataHeight > 0))

		{

		iDrawDevice->WriteBinary(topLeft.iX, topLeft.iY, binaryDataPtr, dataLength, dataHeight, iPenColor, GcDrawMode(iDrawMode) );

		}

	}

/**

Draw a large bitmap glyph.

@param	aPos			Position to start drawing gyph.

@param	aGlyphImage		Pointer to the glyph image data.

@param	aGlyphImageSize	Glyph image size.

@param	aClipRect		Clipping rect.

*/

void CSwDirectGdiEngine::DrawLargeBitmapGlyph(const TPoint& aPos, const TUint8* aGlyphImage,

											 const TSize& aGlyphImageSize, const TRect& aClipRect)

	{

	TPoint printPos(aPos);

	const TInt dataLength = aGlyphImageSize.iWidth;

	const TInt dataHeight = aGlyphImageSize.iHeight;

	TInt bitIndex = 0;

	TInt16 repeatCount = 0;

	TUint32* scanLineBuffer = iDrawDevice->ScanLineBuffer();

	const TInt scanLineWords = (iDrawDevice->ScanLineBytes()) << 3;

	for (TInt glyphLine = 0; glyphLine < dataHeight; glyphLine += repeatCount) // for lines in the glyph bitmap

		{

		repeatCount = Load16(aGlyphImage + (bitIndex >> 3));

		repeatCount >>= bitIndex & 7;

		const TInt multiLineFlag = repeatCount & 1;

		repeatCount >>= 1;

		repeatCount &= 0xf;

		bitIndex += 5;

		if (multiLineFlag)

			{

			for (TInt currentLine = 0; currentLine < repeatCount; currentLine++)

				{

				CopyCharLine(scanLineBuffer, scanLineWords, aGlyphImage + (bitIndex >> 3), bitIndex & 7, dataLength);

				OutputCharLineMultiplied(printPos, scanLineBuffer, dataLength, 1, aClipRect);

				bitIndex += dataLength;

				printPos.iY++;

				}

			}

		else

			{

			CopyCharLine(scanLineBuffer, scanLineWords, aGlyphImage + (bitIndex >> 3), bitIndex & 7, dataLength);

			OutputCharLineMultiplied(printPos, scanLineBuffer, dataLength, repeatCount, aClipRect);

			printPos.iY += repeatCount;

			bitIndex += dataLength;

			}

		}

	}

/**

*/

void CSwDirectGdiEngine::CopyCharLine(TUint32* aBinaryDataPtr, TInt aBufferWords, const TUint8* aData, TInt aBitShift, TInt aCharWidth)

	{

	aBitShift &= 7;

	TInt wordsToCopy = (aCharWidth + 31) >> 5;

	if (wordsToCopy > aBufferWords)

		{

		wordsToCopy = aBufferWords;

		}

	TUint32* ptrLimit = aBinaryDataPtr + wordsToCopy;

	TUint32* dataWord = (TUint32*)(TInt(aData) & ~3);

	aBitShift += (TInt(aData) - TInt(dataWord)) << 3;

	while (aBinaryDataPtr < ptrLimit)

		{

		*aBinaryDataPtr = *dataWord++;

		*aBinaryDataPtr >>= aBitShift;

		if (aBitShift)

			{

			*aBinaryDataPtr |= (*dataWord << (32 - aBitShift));

			}

		aBinaryDataPtr++;

		}

	}

/**

*/

void CSwDirectGdiEngine::OutputCharLineMultiplied(TPoint aPrintPos, TUint32* aBuffer, TInt aDataLength, TInt aNum, const TRect& aClipRect)

	{

	if (aDataLength <= 0)

		{

		return;

		}

	TInt bufferWords = (aDataLength + 31) >> 5;

	TUint32* bufferLimit = aBuffer + bufferWords;

	if (aPrintPos.iX < aClipRect.iTl.iX)

		{

		TInt pixelExcess = aClipRect.iTl.iX - aPrintPos.iX;

		while (pixelExcess >= 32)

			{

			aBuffer++;

			bufferWords--;

			aDataLength -= 32;

			pixelExcess -= 32;

			}

		if (aDataLength <= 0)

			{

			return;

			}

		if (pixelExcess > 0)

			{

			TInt shiftUp = 32 - pixelExcess;

			TUint32* bufferPtr = aBuffer;

			while (bufferPtr < bufferLimit)

				{

				*bufferPtr >>= pixelExcess;

				if (bufferPtr < bufferLimit - 1)

					{

					*bufferPtr |= (*(bufferPtr + 1) << shiftUp);

					}

				bufferPtr++;

				}

			aDataLength -= pixelExcess;

			if (aDataLength <= 0)

				{

				return;

				}

			}

		aPrintPos.iX = aClipRect.iTl.iX;

		}

	if (aPrintPos.iX + aDataLength > aClipRect.iBr.iX)

		{

		TInt pixelExcess = aPrintPos.iX + aDataLength - aClipRect.iBr.iX;

		aDataLength -= pixelExcess;

		if (aDataLength <= 0)

			{

			return;

			}

		}

	while (aNum > 0)

		{

		if ((aPrintPos.iY >= aClipRect.iTl.iY) && (aPrintPos.iY < aClipRect.iBr.iY))

			{

			iDrawDevice->WriteBinaryLine(aPrintPos.iX, aPrintPos.iY, aBuffer, aDataLength, iPenColor, GcDrawMode(iDrawMode));

			}

		aPrintPos.iY++;

		aNum--;

		}

	}

/**

Draw a rotated bitmap glyph.

@param	aPos			Position to start drawing glyph after rotation has been applied.

@param	aGlyphImage		Pointer to the glyph image data.

@param	aGlyphImageSize	Glyph image size.

@param	aClipRect		Clipping rect.

@param	aRotation		Rotation specifying how the glyph will be drawn.

*/

void CSwDirectGdiEngine::DrawRotatedBitmapGlyph(const TPoint& aPos, const TUint8* aGlyphImage,

												const TSize& aGlyphImageSize, const TRect& aClipRect, const DirectGdi::TGraphicsRotation aRotation)

	{

	TPoint printPos(aPos);

	TInt dataLength = aGlyphImageSize.iWidth;

	TInt dataHeight = aGlyphImageSize.iHeight;

	TInt bitIndex = 0;

	TInt16 repeatCount = 0;

	TInt direction = (aRotation == DirectGdi::EGraphicsRotation270) ? 1 : -1;

	TUint32* scanLineBuffer = iDrawDevice->ScanLineBuffer();

	TInt scanLineWords = (iDrawDevice->ScanLineBytes()) << 3;

	for (TInt glyphLine = 0; glyphLine < dataHeight; glyphLine += repeatCount) // for lines in the glyph bitmap...

		{

		repeatCount = Load16(aGlyphImage + (bitIndex >> 3));

		repeatCount >>= bitIndex & 7;

		TInt multiLineFlag = repeatCount & 1;

		repeatCount >>= 1;

		repeatCount &= 0xf;

		bitIndex += 5;

		TInt signedRepeatCount = repeatCount * direction;

		if (multiLineFlag)

			{

			for (TInt currentLine = 0; currentLine < repeatCount; currentLine++)

				{

				CopyCharLine(scanLineBuffer, scanLineWords, aGlyphImage + (bitIndex >> 3), bitIndex & 7, dataLength);

				OutputCharLineVertical(printPos, scanLineBuffer, dataLength, 1, direction, aClipRect);

				bitIndex += dataLength;

				printPos.iX += direction;

				}

			}

		else

			{

			CopyCharLine(scanLineBuffer,scanLineWords, aGlyphImage + (bitIndex >> 3), bitIndex & 7, dataLength);

			OutputCharLineVertical(printPos, scanLineBuffer, dataLength, repeatCount, direction, aClipRect);

			printPos.iX += signedRepeatCount;

			bitIndex += dataLength;

			}

		}

	}

/**

*/

void CSwDirectGdiEngine::OutputCharLineVertical(TPoint aPrintPos, TUint32* aBuffer, TInt aDataLength,

												TInt aNum, TInt aDirection, const TRect& aClipRect)

	{

//	const DirectGdi::TGraphicsRotation rotation = aUp ? DirectGdi::EGraphicsRotation270 : DirectGdi::EGraphicsRotation90;

//	TInt direction = (aRotation == DirectGdi::EGraphicsRotation270) ? 1 : -1;

	if (aDataLength <= 0)

		{

		return;

		}

	TInt bufferWords = (aDataLength + 31) >> 5;

	TUint32* bufferLimit = aBuffer + bufferWords;

	if (aDirection == 1)

		{

		if (aPrintPos.iY >= aClipRect.iBr.iY)

			{

			TInt pixelExcess = aPrintPos.iY - aClipRect.iBr.iY + 1;

			while (pixelExcess >= 32)

				{

				aBuffer++;

				aDataLength -= 32;

				pixelExcess -= 32;

				}

			if (aDataLength <= 0)

				{

				return;

				}

			if (pixelExcess > 0)

				{

				TInt shiftUp = 32 - pixelExcess;

				TUint32* bufferPtr = aBuffer;

				while (bufferPtr < bufferLimit)

					{

					*bufferPtr >>= pixelExcess;

					if (bufferPtr < bufferLimit - 1)

						*bufferPtr |= (*(bufferPtr + 1) << shiftUp);

					bufferPtr++;

					}

				aDataLength -= pixelExcess;

				if (aDataLength <= 0)

					{

					return;

					}

				}

			aPrintPos.iY = aClipRect.iBr.iY - 1;

			}

		if ((aPrintPos.iY - aDataLength) < (aClipRect.iTl.iY - 1))

			{

			TInt pixelExcess = aClipRect.iTl.iY - 1 - aPrintPos.iY + aDataLength;

			aDataLength -= pixelExcess;

			if (aDataLength <= 0)

				{

				return;

				}

			}

		}

	else

		{

		if (aPrintPos.iY < aClipRect.iTl.iY)

			{

			TInt pixelExcess = aClipRect.iTl.iY - aPrintPos.iY;

			while (pixelExcess >= 32)

				{

				aBuffer++;

				aDataLength -= 32;

				pixelExcess -= 32;

				}

			if (aDataLength <= 0)

				{

				return;

				}

			if (pixelExcess > 0)

				{

				TInt shiftup = 32 - pixelExcess;

				TUint32* bufferptr = aBuffer;

				while (bufferptr < bufferLimit)

					{

					*bufferptr >>= pixelExcess;

					if (bufferptr < bufferLimit - 1)

						*bufferptr |= (*(bufferptr + 1) << shiftup);

					bufferptr++;

					}

				aDataLength -= pixelExcess;

				if (aDataLength <= 0)

					{

					return;

					}

				}

			aPrintPos.iY = aClipRect.iTl.iY;

			}

		if (aPrintPos.iY + aDataLength > aClipRect.iBr.iY)