Fixed "extra qualification" syntax errors.
// 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)
{
TInt pixelExcess = aPrintPos.iY + aDataLength - aClipRect.iBr.iY;
aDataLength -= pixelExcess;
if (aDataLength <= 0)
{
return;
}
}
}
CGraphicsContext::TDrawMode drawMode = GcDrawMode(iDrawMode);
while (aNum > 0)
{
if ((aPrintPos.iX >= aClipRect.iTl.iX) && (aPrintPos.iX < aClipRect.iBr.iX))
iDrawDevice->WriteBinaryLineVertical(aPrintPos.iX, aPrintPos.iY, aBuffer, aDataLength, iPenColor, drawMode, (aDirection == 1));
aPrintPos.iX += aDirection;
aNum--;
}
}
/**
Draw an antialiased 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::DrawAntiAliasedGlyph(const TPoint& aPos, const TUint8* aGlyphImage,
const TSize& aGlyphImageSize, const TRect& aClipRect)
{
const TInt topRow = Max(0, aClipRect.iTl.iY - aPos.iY);
const TInt bottomRow = Min(aGlyphImageSize.iHeight, aClipRect.iBr.iY - aPos.iY);
const TInt leftCol = Max(0, aClipRect.iTl.iX - aPos.iX);
const TInt rightCol = Min(aGlyphImageSize.iWidth, aClipRect.iBr.iX - aPos.iX);
const TUint8* p = aGlyphImage + (topRow * aGlyphImageSize.iWidth) + leftCol;
const TInt x = aPos.iX + leftCol;
TInt y = aPos.iY + topRow;
const TInt cols = rightCol - leftCol;
for (TInt row = topRow; row < bottomRow; row++, p += aGlyphImageSize.iWidth, y++)
{
iDrawDevice->WriteRgbAlphaMulti(x, y, cols, iPenColor, p);
}
}
/**
Draw a rotated antialiased glyph.
@param aPos Position to start drawing gyph 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::DrawRotatedAntiAliasedGlyph(const TPoint& aPos, const TUint8* aGlyphImage,
const TSize& aGlyphImageSize, const TRect& aClipRect, const DirectGdi::TGraphicsRotation aRotation)
{
const int KBufferSize = 32;
TUint8 maskBuffer[KBufferSize];
int topRow = 0;
int bottomRow = 0;
int leftCol = 0;
int rightCol = 0;
const TUint32 penColor = iPenColor.Internal();
const TUint32 brushColor = iBrushColor.Internal();
if (aRotation == DirectGdi::EGraphicsRotation270)
{
topRow = Max(0, aClipRect.iTl.iX - aPos.iX);
bottomRow = Min(aGlyphImageSize.iHeight, aClipRect.iBr.iX - aPos.iX);
leftCol = Max(0, aPos.iY - aClipRect.iBr.iY + 1);
rightCol = Min(aGlyphImageSize.iWidth, aPos.iY - aClipRect.iTl.iY + 1);
TInt y = aPos.iY - (rightCol - 1);
for (TInt col = rightCol - 1; col >= leftCol; col--, y++)
{
TInt x = aPos.iX + topRow;
for (TInt row = topRow; row < bottomRow; row += KBufferSize, x += KBufferSize)
{
TInt length = KBufferSize;
if (length > bottomRow - row)
{
length = bottomRow - row;
}
const TUint8* p = aGlyphImage + row * aGlyphImageSize.iWidth + col;
for (TInt i = 0; i < length; i++, p += aGlyphImageSize.iWidth)
{
maskBuffer[i] = *p;
}
iDrawDevice->WriteRgbAlphaMulti(x, y, length, iPenColor, maskBuffer);
}
}
}
else
{
topRow = Max(0, aPos.iX - aClipRect.iBr.iX + 1);
bottomRow = Min(aGlyphImageSize.iHeight, aPos.iX - aClipRect.iTl.iX + 1);
leftCol = Max(0, aClipRect.iTl.iY - aPos.iY);
rightCol = Min(aGlyphImageSize.iWidth, aClipRect.iBr.iY - aPos.iY);
int y = aPos.iY + leftCol;
for (TInt col = leftCol; col < rightCol; col++, y++)
{
TInt x = aPos.iX - (bottomRow - 1);
for (TInt row = bottomRow; row > topRow; row -= KBufferSize, x += KBufferSize)
{
int length = KBufferSize;
if (length > row - topRow)
length = row - topRow;
const TUint8* p = aGlyphImage + (row - 1) * aGlyphImageSize.iWidth + col;
for (TInt i = 0; i < length; i++, p -= aGlyphImageSize.iWidth)
{
maskBuffer[i] = *p;
}
iDrawDevice->WriteRgbAlphaMulti(x, y, length, iPenColor, maskBuffer);
}
}
}
}
/**
Draw a four colour 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::DrawFourColourGlyph(const TPoint& aPos, const TUint8* aGlyphImage,
const TSize& aGlyphImageSize, const TRect& aClipRect)
{
const TInt topRow = Max(0, aClipRect.iTl.iY - aPos.iY);
const TInt bottomRow = Min(aGlyphImageSize.iHeight, aClipRect.iBr.iY - aPos.iY);
const TInt leftCol = Max(0, aClipRect.iTl.iX - aPos.iX);
const TInt rightCol = Min(aGlyphImageSize.iWidth, aClipRect.iBr.iX - aPos.iX);
const TUint8* p = aGlyphImage + (topRow * aGlyphImageSize.iWidth) + leftCol;
const TInt x = aPos.iX + leftCol;
TInt y = aPos.iY + topRow;
const TInt cols = rightCol - leftCol;
const TUint32 penColor = iPenColor.Internal();
const TUint32 shadowColor = iTextShadowColor.Internal();
const TUint32 brushColor = iBrushColor.Internal();
MOutlineAndShadowBlend* outlineAndShadow = NULL;
const TInt err = iDrawDevice->GetInterface(KOutlineAndShadowInterfaceID, reinterpret_cast <TAny*&> (outlineAndShadow));
if (err == KErrNone)
{
//There is a support for the interface with KOutlineAndShadowInterface id.
for (TInt row = topRow; row < bottomRow; row++, p += aGlyphImageSize.iWidth, y++)
{
outlineAndShadow->WriteRgbOutlineAndShadow(x, y, cols, penColor, shadowColor, brushColor, p);
}
}
else
{
// Assert if MOutlineAndShadowBlend interface is not implemented
GRAPHICS_ASSERT_DEBUG(outlineAndShadow, EDirectGdiPanicInvalidInterfaceHandle);
}
}
/**
Draw a rotated four colour glyph.
@param aPos Position to start drawing gyph 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::DrawRotatedFourColourGlyph(const TPoint& aPos, const TUint8* aGlyphImage, const TSize& aGlyphImageSize,
const TRect& aClipRect, const DirectGdi::TGraphicsRotation aRotation)
{
const int KBufferSize = 32;
TUint8 maskBuffer[KBufferSize];
int topRow = 0;
int bottomRow = 0;
int leftCol = 0;
int rightCol = 0;
const TUint32 penColor = iPenColor.Internal();
const TUint32 shadowColor = iTextShadowColor.Internal();
const TUint32 brushColor = iBrushColor.Internal();
MOutlineAndShadowBlend* outlineAndShadow = NULL;
TInt err = iDrawDevice->GetInterface(KOutlineAndShadowInterfaceID, reinterpret_cast <TAny*&> (outlineAndShadow));
if(err != KErrNone)
{
// Assert if MOutlineAndShadowBlend interface is not implemented
GRAPHICS_ASSERT_DEBUG(outlineAndShadow, EDirectGdiPanicInvalidInterfaceHandle);
}
if (aRotation == DirectGdi::EGraphicsRotation270)
{
topRow = Max(0, aClipRect.iTl.iX - aPos.iX);
bottomRow = Min(aGlyphImageSize.iHeight, aClipRect.iBr.iX - aPos.iX);
leftCol = Max(0, aPos.iY - aClipRect.iBr.iY + 1);
rightCol = Min(aGlyphImageSize.iWidth, aPos.iY - aClipRect.iTl.iY + 1);
TInt y = aPos.iY - (rightCol - 1);
for (TInt col = rightCol - 1; col >= leftCol; col--, y++)
{
TInt x = aPos.iX + topRow;
for (TInt row = topRow; row < bottomRow; row += KBufferSize, x += KBufferSize)
{
TInt length = KBufferSize;
if (length > bottomRow - row)
{
length = bottomRow - row;
}
const TUint8* p = aGlyphImage + row * aGlyphImageSize.iWidth + col;
for (TInt i = 0; i < length; i++, p += aGlyphImageSize.iWidth)
{
maskBuffer[i] = *p;
}
//There is a support for the interface with KOutlineAndShadowInterface id.
outlineAndShadow->WriteRgbOutlineAndShadow(x, y, length, penColor, shadowColor, brushColor, maskBuffer);
}
}
}
else
{
topRow = Max(0, aPos.iX - aClipRect.iBr.iX + 1);
bottomRow = Min(aGlyphImageSize.iHeight, aPos.iX - aClipRect.iTl.iX + 1);
leftCol = Max(0, aClipRect.iTl.iY - aPos.iY);
rightCol = Min(aGlyphImageSize.iWidth, aClipRect.iBr.iY - aPos.iY);
int y = aPos.iY + leftCol;
for (TInt col = leftCol; col < rightCol; col++, y++)
{
TInt x = aPos.iX - (bottomRow - 1);
for (TInt row = bottomRow; row > topRow; row -= KBufferSize, x += KBufferSize)
{
int length = KBufferSize;
if (length > row - topRow)
length = row - topRow;
const TUint8* p = aGlyphImage + (row - 1) * aGlyphImageSize.iWidth + col;
for (TInt i = 0; i < length; i++, p -= aGlyphImageSize.iWidth)
{
maskBuffer[i] = *p;
}
//There is a support for the interface with KOutlineAndShadowInterface id.
outlineAndShadow->WriteRgbOutlineAndShadow(x, y, length, penColor, shadowColor, brushColor, maskBuffer);
}
}
}
}
/**
Helper function to clip the array to the clip rect.
@param aArray Start of array of data to be clipped.
@param aArrayLimit End of array of data to be clipped.
@param aDataWd Length of data.
@param aDataHt Height of data.
@param aPos Position to start drawing from.
@param aClipRect Rectangle to clip data array to.
@return Pointer to array of clipped data.
*/
TUint32* CSwDirectGdiEngine::ClipBinaryArray(TUint32* aArray, TUint32* aArrayLimit, TInt& aDataWd, TInt& aDataHt, TPoint& aPos, const TRect& aClipRect)
{
TUint32* arrayPtr = aArray;
TInt clipDiff = aClipRect.iTl.iX - aPos.iX;
if (clipDiff > 0)
{
while (arrayPtr < aArrayLimit)
{
*arrayPtr++ >>= clipDiff;
}
aDataWd -= clipDiff;
aPos.iX = aClipRect.iTl.iX;
arrayPtr = aArray;
}
if ((aPos.iX + aDataWd > aClipRect.iBr.iX) && (aDataWd > 0))
{
aDataWd = aClipRect.iBr.iX - aPos.iX;
}
clipDiff = aClipRect.iTl.iY - aPos.iY;
if (clipDiff > 0)
{
aDataHt -= clipDiff;
arrayPtr += clipDiff;
aPos.iY = aClipRect.iTl.iY;
}
if (((aPos.iY + aDataHt) > (aClipRect.iBr.iY)) && (aDataHt > 0))
{
aDataHt = aClipRect.iBr.iY - aPos.iY;
}
return arrayPtr;
}