diff -r 000000000000 -r 5d03bc08d59c graphicsdeviceinterface/bitgdi/sbit/MAIN.CPP
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graphicsdeviceinterface/bitgdi/sbit/MAIN.CPP	Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,1194 @@
+// Copyright (c) 1997-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 <bitstd.h>
+#include <bitdev.h>
+#include <bitdraw.h>
+#include <bitdrawscaling.h>
+#include <bitdrawinterfaceid.h>
+#include "BITPANIC.H"
+#include <s32mem.h>
+#include <shapeinfo.h>
+#include "bitgcextradata.h"
+
+
+#define KDefaultShadowColor KRgbGray
+
+//CFbsBitGc streams - version numbers.
+//Add new version numbers here. A reason of adding new version numbers may be adding new 
+//CFbsBitGc data members, which may have to be externalized/internalized. When that happens:
+//1.Put a new enum item (like EFbsBitGc_Ver01) with a version number, which is greater than
+//  the last version number, which was used. 
+//2.Comment the new enum item.
+//3.Update KFbsBitGc_VerNo value to be the last enum item value.
+//4.Update InternalizeL/ExternalizeL methods after adding the new version number.
+//  For example: If a new member is added to the class - TInt iSmth, when InternalizeL
+//  is called to operate on older archive, iSmth member won't be in the archive!
+//  So, in InternalizeL, there should be a check, something like:
+//	TUint16 archiveVerNo = 0;
+//	aReadStream >> archiveVerNo;
+//  .......................
+//  if(archiveVerNo < EFbsBitGc_Ver03)   //EFbsBitGc_Ver03 has been added, when iSmth has been added
+//		{
+//      //Do nothing - iSmth is not in the archive
+//      //Initialize it with some default value
+//      iSmth = KDefVal;
+//		}
+//	else
+//		{
+//		aReadStream >> iSmth;
+//		}
+enum
+	{
+	EFbsBitGc_Ver01 = 1, //Base version number, when InternalizeL/ExternalizeL were added
+	EFbsBitGc_Ver02 = 2, //Supports InternalizeL/ExternalizeL for ShadowColor. 
+	};
+LOCAL_D const TUint16 KFbsBitGc_VerNo = EFbsBitGc_Ver02;
+
+// Global panic functions
+
+void Panic(TBitgdiPanic aPanicCode)
+	{
+	_LIT(KBitgdiPanicCategory,"BITGDI");
+	User::Panic(KBitgdiPanicCategory,aPanicCode);
+	}
+
+_LIT(KBITGDIPanicDesc1,"BitGdi internal Panic %S, in file %S @ line %i");
+_LIT(KBITGDIPanicDesc2,"Assert condition = \"%S\"");
+_LIT(KBITGDIPanicDesc3, "BitGdi internal Invariant, in file %S @ line %i");
+
+void PanicWithInfo(TBitgdiPanic aPanic, const TDesC& aFileName, const TDesC& aPanicName, TInt aLine)
+	{
+	TBuf<256> buf;
+	buf.Format(KBITGDIPanicDesc1, &aPanicName, &aFileName, aLine);
+	RDebug::Print(buf);
+	Panic(aPanic);
+	}
+
+void PanicWithCondAndInfo(TBitgdiPanic aPanic, const TDesC& aCondition, const TDesC& aFileName, const TDesC& aPanicName, TInt aLine)
+	{
+	TBuf<256> buf;
+	buf.Format(KBITGDIPanicDesc1, &aPanicName, &aFileName, aLine);
+	RDebug::Print(buf);
+
+	buf.Format(KBITGDIPanicDesc2, &aCondition);
+	RDebug::Print(buf);
+	Panic(aPanic);
+	}
+	
+void InvariantWithCondAndInfo(const TDesC& aCondition, const TDesC& aFileName, TInt aLine)
+	{
+	TBuf<256> buf;
+	buf.Format(KBITGDIPanicDesc3, &aFileName, aLine);
+	RDebug::Print(buf);
+	
+	buf.Format(KBITGDIPanicDesc2, &aCondition);
+	RDebug::Print(buf);
+	User::Invariant();
+	}
+
+
+//
+// CFbsBitGc
+//
+
+
+/** Factory function for creating a CFbsBitGc object
+The object is then ready for a call to Activate().
+@return A pointer to the newly created object. */
+EXPORT_C CFbsBitGc* CFbsBitGc::NewL()
+	{
+	CFbsBitGc* bitGc = new(ELeave) CFbsBitGc;
+	CleanupStack::PushL(bitGc);
+	bitGc->iFbsBitGcExtraData = new(ELeave) CFbsBitGcExtraData;
+	CleanupStack::Pop(bitGc);
+	return bitGc;
+	}
+
+CFbsBitGc::CFbsBitGc():
+	CBitmapContext(),
+	iBrushBitmap(),
+	iBrushUsed(EFalse),
+	iBrushColor(KRgbWhite),
+	iBrushOrigin(TPoint(0,0)),
+	iBrushStyle(ENullBrush),
+	iClipRect(TRect(0,0,0,0)),
+	iDefaultRegion(),
+	iDefaultRegionPtr(NULL),
+	iUserClipRect(TRect(0,0,0,0)),
+	iDevice(NULL),
+	iDitherOrigin(TPoint(0,0)),
+	iDotLength(0),
+	iDotMask(0),
+	iDotParam(0),
+	iDotDirection(1),
+	iDrawMode(EDrawModePEN),
+	iFont(),
+	iCharJustExcess(0),
+	iCharJustNum(0),
+	iWordJustExcess(0),
+	iWordJustNum(0),
+	iLastPrintPosition(TPoint(0,0)),
+	iLinePosition(TPoint(0,0)),
+	iOrigin(TPoint(0,0)),
+	iPenColor(KRgbBlack),
+	iPenStyle(ESolidPen),
+	iPenSize(TSize(1,1)),
+	iShadowMode(CFbsDrawDevice::ENoShadow),
+	iAutoUpdateJustification(ETrue),
+	iFadeBlackMap(128),
+	iFadeWhiteMap(255),
+	iStrikethrough(EStrikethroughOff),
+	iUnderline(EUnderlineOff),
+	iUserDisplayMode(ENone)
+	{}
+
+
+/** Frees all resources owned by the object. */
+EXPORT_C CFbsBitGc::~CFbsBitGc()
+	{
+	Reset();
+	iBrushBitmap.Reset();
+	iClippingRegion.Close();
+	delete iFbsBitGcExtraData;
+	}
+
+/** Sets the object to draw to a particular device
+@param aDevice The target device. */
+EXPORT_C void CFbsBitGc::Activate(CFbsDevice* aDevice)
+	{
+	if (!aDevice)
+		return;
+	iDevice = aDevice;
+	TRect deviceRect;
+	iDevice->iDrawDevice->GetDrawRect(deviceRect);
+	iDefaultRegion.Clear();
+	iDefaultRegion.AddRect(deviceRect);
+	iDefaultRegionPtr = &iDefaultRegion;
+	iUserClipRect = deviceRect;
+	iDrawnTo.SetWidth(0);
+	iDrawnTo.SetHeight(0);
+	iAutoUpdateJustification = ETrue;
+	}
+
+/** Sets the object to draw to a particular device but doesn't 'use up' 
+justification settings when drawing text.
+This is similar to Activate().
+@param aDevice The target device. */
+EXPORT_C void CFbsBitGc::ActivateNoJustAutoUpdate(CFbsDevice* aDevice)
+	{
+	Activate(aDevice);
+	iAutoUpdateJustification = EFalse;
+	}
+
+void CFbsBitGc::SetupDevice() const
+	{
+	CFbsDrawDevice* drawDevice = iDevice->iDrawDevice;
+	drawDevice->SetDitherOrigin(iDitherOrigin);
+	drawDevice->SetShadowMode(CFbsDrawDevice::TShadowMode(iShadowMode));
+	drawDevice->SetFadingParameters(iFadeBlackMap,iFadeWhiteMap);
+	drawDevice->SetUserDisplayMode(iUserDisplayMode);
+	}
+
+void CFbsBitGc::CheckDevice() const
+	{
+	BG_ASSERT_ALWAYS(iDevice,EBitgdiPanicNoDevicePresent);
+	}
+
+TBool CFbsBitGc::CheckDevice(const TRect& aRect) const
+	{
+	BG_ASSERT_ALWAYS(iDevice,EBitgdiPanicNoDevicePresent);
+
+	return aRect.IsEmpty();
+	}
+
+/** Externalizes an object of this class to a write stream.
+It is important that the brush bitmap of the GC is maintained between calls
+to externalize and internalize.  The brush bitmap handle is externalized,
+not the bitmap data.  This is done for performance.
+
+@param aWriteStream Stream to which the object should be externalized.
+@internalAll */
+EXPORT_C void CFbsBitGc::ExternalizeL(RWriteStream& aWriteStream)
+	{
+	aWriteStream << KFbsBitGc_VerNo;
+	TInt bitmapHandle=iBrushBitmap.Handle();
+	aWriteStream.WriteInt32L(bitmapHandle);
+	iBrushColor.ExternalizeL(aWriteStream);
+	aWriteStream.WriteInt8L(iBrushUsed);
+	aWriteStream << iBrushOrigin;
+	aWriteStream.WriteUint8L(iBrushStyle);
+	aWriteStream << iDitherOrigin;
+	aWriteStream << iUserClipRect;
+	aWriteStream << iDrawnTo;
+	aWriteStream.WriteUint32L(iDotLength);
+	aWriteStream.WriteUint32L(iDotMask);
+	aWriteStream.WriteUint32L(iDotParam);
+	aWriteStream.WriteUint32L(iDotDirection); 
+	aWriteStream.WriteUint8L(iDrawMode); 
+	aWriteStream.WriteUint32L(iCharJustExcess);
+	aWriteStream.WriteUint32L(iCharJustNum);
+	aWriteStream.WriteUint32L(iWordJustExcess);
+	aWriteStream.WriteUint32L(iWordJustNum);
+	aWriteStream << iLastPrintPosition;
+	aWriteStream << iLinePosition;
+	aWriteStream << iOrigin; 
+	iPenColor.ExternalizeL(aWriteStream); 
+	aWriteStream.WriteUint8L(iPenStyle);   
+	aWriteStream << iPenSize;
+	aWriteStream << iShadowMode;
+	aWriteStream << iAutoUpdateJustification;
+	aWriteStream << iFadeBlackMap;
+	aWriteStream << iFadeWhiteMap;
+	aWriteStream.WriteUint8L(iStrikethrough); 
+	aWriteStream.WriteUint8L(iUnderline);
+
+	const TFontSpec fontSpec=iFont.FontSpecInTwips();
+	fontSpec.ExternalizeL(aWriteStream);
+
+	aWriteStream.WriteUint8L(iUserDisplayMode);
+	iFbsBitGcExtraData->ShadowColor().ExternalizeL(aWriteStream);
+	}
+
+/** Internalizes an object of this class from a read stream.
+It is important that the brush bitmap of the GC is maintained between calls
+to externalize and internalize.  The brush bitmap handle is internalized,
+not the bitmap data.
+
+@param aReadStream Stream from which the object is to be internalized.
+@internalAll */
+EXPORT_C void CFbsBitGc::InternalizeL(RReadStream& aReadStream)
+	{
+	TUint16 archiveVerNo = 0;
+	aReadStream >> archiveVerNo;
+	TInt bitmapHandle=aReadStream.ReadInt32L();
+	if (bitmapHandle)
+		{
+		UseBrushPattern(bitmapHandle);
+		}
+	iBrushColor.InternalizeL(aReadStream);
+	iBrushUsed=aReadStream.ReadInt8L();
+	aReadStream >> iBrushOrigin;
+	iBrushStyle=(TBrushStyle)aReadStream.ReadUint8L();
+	aReadStream >> iDitherOrigin;
+	aReadStream >> iUserClipRect;
+	aReadStream >> iDrawnTo;
+	iDotLength=aReadStream.ReadUint32L();
+	iDotMask=aReadStream.ReadUint32L();
+	iDotParam=aReadStream.ReadUint32L();
+	iDotDirection=aReadStream.ReadUint32L(); 
+	iDrawMode=(TDrawMode)aReadStream.ReadUint8L(); 
+	iCharJustExcess=aReadStream.ReadUint32L();
+	iCharJustNum=aReadStream.ReadUint32L();
+	iWordJustExcess=aReadStream.ReadUint32L();
+	iWordJustNum=aReadStream.ReadUint32L();
+	aReadStream >> iLastPrintPosition;
+	aReadStream >> iLinePosition;
+	aReadStream >> iOrigin; 
+	iPenColor.InternalizeL(aReadStream); 
+	iPenStyle=(TPenStyle)aReadStream.ReadUint8L();   
+	aReadStream >> iPenSize;
+	SetPenSize(iPenSize);
+	aReadStream >> iShadowMode;
+	aReadStream >> iAutoUpdateJustification;
+	aReadStream >> iFadeBlackMap;
+	aReadStream >> iFadeWhiteMap;
+	iStrikethrough=(TFontStrikethrough)aReadStream.ReadUint8L(); 
+	iUnderline=(TFontUnderline)aReadStream.ReadUint8L();
+	TFontSpec fontSpec;
+	fontSpec.InternalizeL(aReadStream);
+	if (fontSpec.iHeight != 0)
+		{
+		CFbsFont* font = NULL;
+		User::LeaveIfError(iDevice->GetNearestFontToDesignHeightInTwips(font,fontSpec));
+		TInt err = iFont.Duplicate(font->Handle());
+		iDevice->ReleaseFont(font);
+		User::LeaveIfError(err);
+		UseFont(iFont.Handle());
+		}
+	iUserDisplayMode=(TDisplayMode)aReadStream.ReadUint8L();
+	if(archiveVerNo < EFbsBitGc_Ver02)  //Without shadowcolor
+		{
+		//Initialize it with the default value
+		iFbsBitGcExtraData->SetShadowColor(KDefaultShadowColor);
+		}
+	else  //With shadowcolor
+		{
+		TRgb shadowColor;
+		shadowColor.InternalizeL(aReadStream);
+		iFbsBitGcExtraData->SetShadowColor(shadowColor);	
+		}
+	}
+
+/** Copies all settings from the specified bitmap graphics context.
+@param aGc The bitmap graphics context whose settings are to be copied. */
+EXPORT_C void CFbsBitGc::CopySettings(const CFbsBitGc& aGc)
+	{
+	iBrushColor = aGc.iBrushColor;
+	iBrushUsed = aGc.iBrushUsed;
+	iBrushOrigin = aGc.iBrushOrigin;
+	iBrushStyle = aGc.iBrushStyle;
+	iDefaultRegionPtr = aGc.iDefaultRegionPtr;
+	iDitherOrigin = aGc.iDitherOrigin;
+	iDotLength = aGc.iDotLength;
+	iDotMask = aGc.iDotMask;
+	iDotParam = aGc.iDotParam;
+	iDotDirection = aGc.iDotDirection;
+	iDrawMode = aGc.iDrawMode;
+	iCharJustExcess = aGc.iCharJustExcess;
+	iCharJustNum = aGc.iCharJustNum;
+	iWordJustExcess = aGc.iWordJustExcess;
+	iWordJustNum = aGc.iWordJustNum;
+	iLastPrintPosition = aGc.iLastPrintPosition;
+	iLinePosition = aGc.iLinePosition;
+	iOrigin = aGc.iOrigin;
+	iPenColor = aGc.iPenColor;
+	iPenStyle = aGc.iPenStyle;
+	SetPenSize(aGc.iPenSize);
+	iShadowMode = aGc.iShadowMode;
+	iStrikethrough = aGc.iStrikethrough;
+	iUnderline = aGc.iUnderline;
+	iUserDisplayMode = aGc.iUserDisplayMode;
+	if(aGc.iFont.Handle())
+		UseFont(aGc.iFont.Handle());
+	if(aGc.iBrushBitmap.Handle())
+		UseBrushPattern(aGc.iBrushBitmap.Handle());
+	iFbsBitGcExtraData->SetShadowColor(aGc.iFbsBitGcExtraData->ShadowColor());
+	}
+
+/** Gets a pointer to the graphics device for the graphics context.
+The graphics device is the device currently being drawn to. 
+The function provides a concrete implementation of the pure virtual function 
+CGraphicsContext::Device(). The function behaviour is the same as documented 
+in that class. 
+@see CGraphicsContext::Device() */
+EXPORT_C CGraphicsDevice* CFbsBitGc::Device() const
+	{
+	return iDevice;
+	}
+
+/** Discards a non-built-in brush pattern.
+The function provides a concrete implementation of the pure virtual function 
+CGraphicsContext::DiscardBrushPattern(). The function behaviour is the same 
+as documented in that class. 
+@see CGraphicsContext::DiscardBrushPattern() */
+EXPORT_C void CFbsBitGc::DiscardBrushPattern()
+	{
+	iBrushBitmap.Reset();
+	iBrushUsed = EFalse;
+	if (iBrushStyle == EPatternedBrush)
+		iBrushStyle = ENullBrush;
+	}
+
+/** Discards a selected device font.
+The function provides a concrete implementation of the pure virtual function 
+CGraphicsContext::DiscardFont(). The function behaviour is the same as documented 
+in that class. 
+@see CGraphicsContext::DiscardFont() */
+EXPORT_C void CFbsBitGc::DiscardFont()
+	{
+	iFont.Reset();
+	}
+
+/** Maps pixels in the specified rectangle.
+The function tries to match the colour of a pixel with one of the RGB values 
+in an array of RGB pairs. If there is a match, the colour is changed to the 
+value specified in the other RGB in the RGB pair.
+@param aRect The rectangle in which pixels are to be mapped.
+@param aColors A pointer to a set of RGB pairs. 
+@param aNumPairs The number of pairs 
+@param aMapForwards ETrue, mapping is done from the first RGB to the second 
+RGB in the pair; EFalse, mapping is done from the second RGB to the first 
+RGB in the pair. */
+EXPORT_C void CFbsBitGc::MapColors(const TRect& aRect,
+								   const TRgb* aColors,
+								   TInt aNumPairs,
+								   TBool aMapForwards)
+	{
+	if (CheckDevice(aRect) || !aColors)
+		return;
+
+	TRect rcpy(aRect);
+	rcpy.Move(iOrigin);
+	AddRect(rcpy);
+	if (UserClipRect(rcpy))
+		return;
+
+	SetupDevice();
+	iDevice->DrawingBegin();
+
+	CFbsDrawDevice* drawDevice = iDevice->iDrawDevice;
+
+#if defined(_DEBUG)
+	TRect deviceRect;
+	drawDevice->GetDrawRect(deviceRect);
+#endif
+
+	const TInt limit = iDefaultRegionPtr->Count();
+	for (TInt count = 0; count < limit; count++)
+		{
+		iClipRect = (*iDefaultRegionPtr)[count];
+		if (!iClipRect.Intersects(rcpy))
+			continue;
+
+		iClipRect.Intersection(rcpy);
+
+		BG_ASSERT_DEBUG(iClipRect.iTl.iX >= deviceRect.iTl.iX, EBitgdiPanicOutOfBounds);
+		BG_ASSERT_DEBUG(iClipRect.iTl.iY >= deviceRect.iTl.iY, EBitgdiPanicOutOfBounds);
+		BG_ASSERT_DEBUG(iClipRect.iBr.iX <= deviceRect.iBr.iX, EBitgdiPanicOutOfBounds);
+		BG_ASSERT_DEBUG(iClipRect.iBr.iY <= deviceRect.iBr.iY, EBitgdiPanicOutOfBounds);
+
+		drawDevice->MapColors(iClipRect,aColors,aNumPairs,aMapForwards);
+		drawDevice->UpdateRegion(iClipRect);
+		}
+
+	iDevice->DrawingEnd();
+	}
+
+/** Sets the internal drawing position relative to the co-ordinate origin.
+A subsequent call to DrawLineTo() or DrawLineBy() uses the new drawing point
+as the start point for the line drawn.The function provides a concrete
+implementation of the pure virtual function CGraphicsContext::MoveTo(). 
+The function behaviour is the same as documented in that class. */
+EXPORT_C void CFbsBitGc::MoveTo(const TPoint& aPoint)
+    {
+	iLinePosition = aPoint;
+	}
+
+/** Sets the drawing point relative to the current co-ordinates.
+The function provides a concrete implementation of the pure virtual
+function CGraphicsContext::MoveBy(). The function behaviour 
+is the same as documented in that class. */
+EXPORT_C void CFbsBitGc::MoveBy(const TPoint& aVector)
+   {
+	iLinePosition += aVector;
+	}
+
+/** Resets the graphics context to its default settings.
+The function provides a concrete implementation of the pure virtual function 
+CGraphicsContext::Reset(). The function behaviour is the same as documented 
+in that class. 
+@see CGraphicsContext::Reset() */
+EXPORT_C void CFbsBitGc::Reset()
+	{
+	iDefaultRegionPtr = &iDefaultRegion;
+	if (iDefaultRegion.Count() == 0)
+		iUserClipRect = TRect(0,0,0,0);
+	else
+		iUserClipRect = iDefaultRegion[0];
+	iLastPrintPosition.SetXY(0,0);
+	if(iFbsBitGcExtraData)
+		{
+		iFbsBitGcExtraData->Reset();	
+		}
+	iPenColor = KRgbBlack;
+	iPenStyle = ESolidPen;
+	iPenSize.SetSize(1,1);
+	iDrawMode = EDrawModePEN;
+	iFont.Reset();
+	iLinePosition.SetXY(0,0);
+	iOrigin.SetXY(0,0);
+	iBrushUsed = EFalse;
+	iBrushColor = KRgbWhite;
+	iBrushOrigin.SetXY(0,0);
+	iBrushStyle = ENullBrush;
+	iCharJustExcess = 0;
+	iCharJustNum = 0;
+	iWordJustExcess = 0;
+	iWordJustNum = 0;
+	iDitherOrigin.SetXY(0,0);
+	iDotLength = 0;
+	iDotMask = 0;
+	iDotParam = 0;
+	iDotDirection = 1;
+	iShadowMode = CFbsDrawDevice::ENoShadow;
+	iStrikethrough = EStrikethroughOff;
+	iUnderline = EUnderlineOff;
+	iUserDisplayMode = ENone;
+	}
+
+/** Needs to be called if the device is resized.
+This only applies to devices of type CFbsBitmapDevice. */
+EXPORT_C void CFbsBitGc::Resized()
+	{
+	CheckDevice();
+
+	TRect deviceRect;
+	iDevice->iDrawDevice->GetDrawRect(deviceRect);
+	iUserClipRect = deviceRect;
+	iDefaultRegion.Clear();
+	iDefaultRegion.AddRect(deviceRect);
+	iDefaultRegionPtr = &iDefaultRegion;
+
+	if (deviceRect.Contains(iLastPrintPosition))
+		iLastPrintPosition.SetXY(0,0);
+	if (deviceRect.Contains(iLinePosition))
+		iLinePosition.SetXY(0,0);
+	if (deviceRect.Contains(iOrigin))
+		iOrigin.SetXY(0,0);
+	if (deviceRect.Contains(iBrushOrigin))
+		iBrushOrigin.SetXY(0,0);
+	}
+
+/**Returns current setting of brush color.
+@internalAll*/ 
+EXPORT_C TRgb CFbsBitGc::BrushColor()
+	{
+	return iBrushColor; 
+	}
+
+/** Sets the brush pattern origin.
+The function provides a concrete implementation of the pure virtual
+function CGraphicsContext::SetBrushOrigin(). The function
+behaviour is the same as documented in that class. */
+EXPORT_C void CFbsBitGc::SetBrushOrigin(const TPoint& origin)
+    {
+	iBrushOrigin = origin;
+	}
+
+/**Sets the brush colour.
+The function provides a concrete implementation of the pure virtual
+function CGraphicsContext::SetBrushColor(). The function
+behaviour is the same as documented in that class. */ 
+EXPORT_C void CFbsBitGc::SetBrushColor(const TRgb& aColor)
+    {
+	iBrushColor = aColor;
+	}
+
+/** Sets the brush style.
+The function provides a concrete implementation of the pure virtual
+function CGraphicsContext::SetBrushStyle(). The function
+behaviour is the same as documented in that class. */
+EXPORT_C void CFbsBitGc::SetBrushStyle(TBrushStyle aStyle)
+{
+	iBrushStyle = aStyle;
+	}
+
+
+/** Sets the dither origin.
+This is only useful for modes that do dithering. If the display is scrolled 
+an odd number of pixels then the (2x2) dither pattern will not match up for 
+new drawing unless this is called.
+@param aPoint The dither origin. */
+EXPORT_C void CFbsBitGc::SetDitherOrigin(const TPoint& aPoint)
+	{
+	iDitherOrigin = iOrigin + aPoint;
+	}
+
+/** Sets the character justification.
+The function provides a concrete implementation of the pure virtual
+function CGraphicsContext::SetCharJustification(). The
+function behaviour is the same as documented in that class. */
+EXPORT_C void CFbsBitGc::SetCharJustification(TInt aExcessWidth,TInt aNumChars)
+   {
+	if (aExcessWidth == 0 || aNumChars <= 0)
+		{
+		iCharJustExcess = 0;
+		iCharJustNum = 0;
+		}
+	else
+		{
+		iCharJustExcess = aExcessWidth;
+		iCharJustNum = aNumChars;
+		}
+	}
+
+/** Sets the clipping rectangle. 
+This function provides a concrete implementation of the pure virtual function
+CGraphicsContext::SetClippingRect(). The function behaviour is the same as 
+documented in that class.  
+@see CGraphicsContext::SetClippingRect() */
+EXPORT_C void CFbsBitGc::SetClippingRect(const TRect& aRect)
+    {
+	CheckDevice();
+
+	TRect deviceRect;
+	iDevice->iDrawDevice->GetDrawRect(deviceRect);
+	iUserClipRect = deviceRect;
+	iUserClipRect.Intersection(TRect(aRect.iTl + iOrigin,aRect.iBr + iOrigin));
+	}
+
+/** Cancels clipping rectangle and region. */
+EXPORT_C void CFbsBitGc::CancelClipping()
+	{
+	CancelClippingRect();
+	CancelClippingRegion();
+	}
+
+/** Cancels any clipping rectangle.
+Clipping reverts to the full device area, the default.
+The function provides a concrete implementation of the pure virtual function 
+CGraphicsContext::CancelClippingRect(). The function behaviour is the same 
+as documented in that class. 
+@see CGraphicsContext::CancelClippingRect() */
+EXPORT_C void CFbsBitGc::CancelClippingRect()
+	{
+	if (iDefaultRegion.Count() == 0)
+		iUserClipRect = TRect(0,0,0,0);
+	else
+		iUserClipRect = iDefaultRegion[0];
+	}
+
+/** Cancels the clipping region. */
+EXPORT_C void CFbsBitGc::CancelClippingRegion()
+	{
+	iDefaultRegionPtr = &iDefaultRegion;
+	}
+
+/** Sets the word justification.
+The function provides a concrete implementation of the pure virtual
+function CGraphicsContext::SetWordJustification(). The
+function behaviour is the same as documented in that class. */
+EXPORT_C void CFbsBitGc::SetWordJustification(TInt aExcessWidth,TInt aNumGaps)
+   {
+	if (aExcessWidth <= 0 || aNumGaps <= 0)
+		{
+		iWordJustExcess = 0;
+		iWordJustNum = 0;
+		}
+	else
+		{
+		iWordJustExcess = aExcessWidth;
+		iWordJustNum = aNumGaps;
+		}
+	}
+
+/** Sets a clipping region by storing a pointer to the TRegion parameter.
+This function provides a concrete implementation of the pure virtual
+function CGraphicsContext::SetClippingRegion(). The function behaviour is the 
+same as documented in that class.
+@panic BITGDI 10 if aRegion is invalid or if aRegion is not contained by the 
+device area. */
+EXPORT_C void CFbsBitGc::SetClippingRegion(const TRegion* aRegion)
+	{
+	if (!aRegion)
+		{
+		iDefaultRegionPtr = &iDefaultRegion;
+		return;
+		}
+
+	BG_ASSERT_ALWAYS(!aRegion->CheckError(),EBitgdiPanicInvalidRegion);
+	BG_ASSERT_ALWAYS(aRegion->IsContainedBy(iDefaultRegion.BoundingRect()),EBitgdiPanicInvalidRegion);
+	
+	iDefaultRegionPtr = aRegion;
+	}
+
+/** Sets a clipping region by storing a copy of the TRegion parameter.
+@param aRegion The clipping region to be stored and used. aRegion must be valid and bounded withing the iDefaultRegion.
+@return KErrNone if successful; KErrArgument if aRegion is invalid, KErrMemory if the region could not be allocated.
+@see CGraphicsContext::SetClippingRegion().
+*/
+EXPORT_C TInt CFbsBitGc::SetClippingRegion(const TRegion& aRegion)
+	{
+		if (aRegion.CheckError() || !aRegion.IsContainedBy(iDefaultRegion.BoundingRect()))
+			return KErrArgument;
+					
+		iClippingRegion.Copy(aRegion);
+		if (iClippingRegion.CheckError())		
+			return KErrNoMemory;
+		
+		iDefaultRegionPtr = &iClippingRegion;
+	
+		return KErrNone;
+	}
+
+/** Sets the drawing mode.
+This affects the colour that is actually drawn, because it defines the way 
+that the current screen colour logically combines with the current pen colour 
+and brush colour.
+The function provides a concrete implementation of the pure virtual function 
+CGraphicsContext::SetDrawMode(). The function behaviour is the same as documented 
+in that class. 
+@see CGraphicsContext::SetDrawMode() */
+EXPORT_C void CFbsBitGc::SetDrawMode(CGraphicsContext::TDrawMode aDrawMode)
+	{
+	iDrawMode = aDrawMode;
+	}
+
+/**Returns current setting of pen color.
+@internalAll*/ 
+EXPORT_C TRgb CFbsBitGc::PenColor()
+	{
+	return iPenColor; 
+	}
+
+/** Sets the position of the co-ordinate origin.
+All subsequent drawing operations are then done relative to this
+origin.The function provides a concrete implementation of the pure
+virtual function CGraphicsContext::SetOrigin(). The
+function behaviour is the same as documented in that class. */
+EXPORT_C void CFbsBitGc::SetOrigin(const TPoint& aPoint)
+{
+	iDitherOrigin -= iOrigin;
+	iOrigin = aPoint;
+	iDitherOrigin += iOrigin;
+	}
+
+/** Sets the pen colour.
+The function provides a concrete implementation of the pure virtual
+function CGraphicsContext::SetPenColor(). The function
+behaviour is the same as documented in that class. */
+EXPORT_C void CFbsBitGc::SetPenColor(const TRgb& aColor)
+    {
+	iPenColor = aColor;
+	}
+
+
+/** Sets the line drawing style for the pen. 
+The function provides a concrete implementation of the pure virtual function 
+CGraphicsContext::SetPenStyle(). The function behaviour is the same as documented 
+in that class. 
+@see CGraphicsContext::SetPenStyle() */
+EXPORT_C void CFbsBitGc::SetPenStyle(TPenStyle aStyle)
+	{
+	iPenStyle = aStyle;
+
+	switch(iPenStyle)
+		{
+	case ENullPen:
+		iDotMask=0;
+		iDotLength=0;
+		break;
+	case EDottedPen:
+		iDotMask=1;
+		iDotLength=4;
+		break;
+	case EDashedPen:
+		iDotMask=7;
+		iDotLength=6;
+		break;
+	case EDotDashPen:
+		iDotMask=113;
+		iDotLength=10;
+		break;
+	case EDotDotDashPen:
+		iDotMask=1809;
+		iDotLength=14;
+		break;
+	default:
+		iDotMask=1;
+		iDotLength=1;
+		break;
+		};
+
+	iDotParam=0;
+	}
+
+/** Sets the line drawing size for the pen.
+The function provides a concrete implementation of the pure virtual
+function CGraphicsContext::SetPenSize(). The function
+behaviour is the same as documented in that class. */ 
+EXPORT_C void CFbsBitGc::SetPenSize(const TSize& aSize)
+    {
+	iPenSize.SetSize(Abs(aSize.iWidth),Abs(aSize.iHeight));
+
+	const TSize maxsize = iDevice->iDrawDevice->SizeInPixels();
+
+	iPenSize.iWidth = Min(iPenSize.iWidth,maxsize.iWidth << 1);
+	iPenSize.iHeight = Min(iPenSize.iHeight,maxsize.iHeight << 1);
+
+	if (iPenSize.iWidth || iPenSize.iHeight)
+		PenAllocate();
+	else
+		{
+		iFbsBitGcExtraData->ResetPenArray();
+		}
+
+	iDotParam = 0;
+	}
+
+/** Simulates another graphics mode.
+Some devices running in some modes can simulate other modes (EGray16 will 
+do EGray4 and EGray2, EGray4 will do EGray2).
+@param aDisplayMode The display mode to be set. */
+EXPORT_C void CFbsBitGc::SetUserDisplayMode(TDisplayMode aDisplayMode)
+	{
+	if(aDisplayMode==iDevice->DisplayMode())
+		aDisplayMode = ENone;
+	iUserDisplayMode = aDisplayMode;
+	}
+
+/** Sets the underline style for all subsequently drawn text.
+The function provides a concrete implementation of the pure virtual
+function CGraphicsContext::SetUnderlineStyle(). The
+function behaviour is the same as documented in that class. */
+EXPORT_C void CFbsBitGc::SetUnderlineStyle(TFontUnderline aUnderlineStyle)
+    {
+	iUnderline = aUnderlineStyle;
+	}
+
+/** Sets the strikethrough style for all subsequently drawn text.
+The function provides a concrete implementation of the pure virtual
+function CGraphicsContext::SetStrikethroughStyle(). The
+function behaviour is the same as documented in that class. */
+EXPORT_C void CFbsBitGc::SetStrikethroughStyle(TFontStrikethrough aStrikethroughStyle)
+    {
+	iStrikethrough = aStrikethroughStyle;
+	}
+
+/** Sets the shadow mode on or off.
+@param aShadowMode ETrue, shadow mode is on; EFalse, shadow mode is off. EFalse 
+is the default. */
+EXPORT_C void CFbsBitGc::SetShadowMode(TBool aShadowMode)
+	{
+	if (aShadowMode)
+		iShadowMode |= CFbsDrawDevice::EShadow;
+	else
+		iShadowMode &= ~CFbsDrawDevice::EShadow;
+	}
+
+/** Sets whether the graphics context is faded.
+The function provides a concrete implementation of the pure virtual
+function CBitmapContext::SetFaded(). The function
+behaviour is the same as documented in that class.
+*/
+EXPORT_C void CFbsBitGc::SetFaded(TBool aFadeMode)
+    {
+	if (aFadeMode)
+		iShadowMode |= CFbsDrawDevice::EFade;
+	else
+		iShadowMode &= ~CFbsDrawDevice::EFade;
+	}
+
+/** Set fading parameters.
+The function provides a concrete implementation of the pure virtual
+function CBitmapContext::SetFadingParameters(). The
+function behaviour is the same as documented in that class.
+*/
+EXPORT_C void CFbsBitGc::SetFadingParameters(TUint8 aBlackMap,TUint8 aWhiteMap)
+    {
+	iFadeBlackMap = aBlackMap;
+	iFadeWhiteMap = aWhiteMap;
+	}
+
+/** Gets the orientations supported.
+@param aOrientation[4] An array of four TBool values. Each entry in this 
+array corresponds to successive values of the TGraphicsOrientation enum.
+If the first array entry has an EFrue value, then the normal orientation
+is supported; if the second entry array has an ETrue value, 
+then a 90 degree orientation is supported etc. */	
+EXPORT_C void CFbsBitGc::OrientationsAvailable(TBool aOrientation[4])
+    {
+	if (iDevice)
+		{
+		iDevice->iDrawDevice->OrientationsAvailable(aOrientation);
+		}
+	else
+		{
+		aOrientation[EGraphicsOrientationNormal] = EFalse;
+		aOrientation[EGraphicsOrientationRotated90] = EFalse;
+		aOrientation[EGraphicsOrientationRotated180] = EFalse;
+		aOrientation[EGraphicsOrientationRotated270] = EFalse;
+		}
+	}
+
+/** Sets the orientation.
+@param aOrientation The required orientation
+@return ETrue, if the requested orientation is supported; EFalse, otherwise. */
+EXPORT_C TBool CFbsBitGc::SetOrientation(TGraphicsOrientation aOrientation)
+	{
+	if (!iDevice)
+		return EFalse;
+
+	TBool ret = iDevice->SetOrientation(aOrientation);
+	if(ret)
+		{
+		TRect deviceRect;
+		iDevice->iDrawDevice->GetDrawRect(deviceRect);
+		iDefaultRegion.Clear();
+		iDefaultRegion.AddRect(deviceRect);
+		iUserClipRect = deviceRect;
+		iDrawnTo.SetRect(0,0,0,0);
+		}
+
+	return ret;
+	}
+
+/** Sets the specified bitmap to be used as the brush pattern.
+@param aBitmap The bitmap.*/
+EXPORT_C void CFbsBitGc::UseBrushPattern(const CFbsBitmap* aBitmap)
+	{
+	BG_ASSERT_ALWAYS(aBitmap != NULL,EBitgdiPanicInvalidBitmap);
+	
+	TInt brushResult = UseBrushPattern(((CFbsBitmap*)aBitmap)->Handle());
+	BG_ASSERT_ALWAYS(brushResult == KErrNone,EBitgdiPanicInvalidBitmap);
+	}
+
+/** Sets the specified bitmap to be used as the brush pattern.
+@param aFbsBitmapHandle The handle number of the bitmap.
+@return KErrNone, if successful; otherwise another of the other system wide 
+error codes. */
+EXPORT_C TInt CFbsBitGc::UseBrushPattern(TInt aFbsBitmapHandle)
+	{
+	BG_ASSERT_ALWAYS(aFbsBitmapHandle,EBitgdiPanicInvalidBitmap);
+
+	iBrushUsed = ETrue;
+	if (iBrushBitmap.Handle() == aFbsBitmapHandle)
+		return KErrNone;
+
+	TInt ret = iBrushBitmap.Duplicate(aFbsBitmapHandle);
+	if (ret != KErrNone)
+		iBrushUsed = EFalse;
+
+	return ret;
+	}
+
+/** Selects the device font, identified by handle number, to be used for text drawing.
+Notes:
+When the font is no longer required, use DiscardFont() to free up the memory 
+used. If UseFont() is used again without using DiscardFont() then the previous 
+font is discarded automatically.
+If no font has been selected, and an attempt is made to draw text with DrawText(), 
+then a panic occurs.
+@param aFontHandle A handle number for a device font. 
+@return The duplicate handle number for the device font.
+@see CFont */
+EXPORT_C void CFbsBitGc::UseFont(const CFont* aFont)
+	{
+	BG_ASSERT_ALWAYS(aFont != NULL,EBitgdiPanicInvalidFont);
+	BG_ASSERT_ALWAYS(aFont->TypeUid() == KCFbsFontUid,EBitgdiPanicInvalidFont);
+
+	TInt fontResult = UseFont(((CFbsBitGcFont*)aFont)->Handle());
+	BG_ASSERT_ALWAYS(fontResult == KErrNone,EBitgdiPanicInvalidFont);
+	}
+
+/** Selects the device font, identified by handle, to be used for
+text drawing.
+Notes:When the font is no longer required, use DiscardFont() to free up the memory used.
+If UseFont() is used again without using DiscardFont() then the previous font is 
+discarded automatically.If no font has been selected, and an attempt is made to
+draw text with DrawText(), then a panic occurs.
+@param aFbsFontHandle A handle for a device font.
+@return  The result of CFbsFont::Duplicate(). */
+EXPORT_C TInt CFbsBitGc::UseFont(TInt aFbsFontHandle)
+   {
+	BG_ASSERT_ALWAYS(aFbsFontHandle,EBitgdiPanicInvalidFont);
+
+	if (iFont.Handle() == aFbsFontHandle)
+		return KErrNone;
+
+	return iFont.Duplicate(aFbsFontHandle);
+	}
+
+/** Selects a device font for text drawing but does not take a copy. 
+The original must not be destroyed until UseFont(), UseFontNoDuplicate(), 
+DiscardFont() or the destructor is called.
+@param aFont A pointer to the font to be used. */
+EXPORT_C void CFbsBitGc::UseFontNoDuplicate(const CFbsBitGcFont* aFont)
+	{
+	DiscardFont();
+
+	BG_ASSERT_ALWAYS(aFont->TypeUid() == KCFbsFontUid,EBitgdiPanicInvalidFont);
+
+	if (aFont->Handle() == NULL)
+		return;
+
+	iFont = *aFont;
+	}
+
+/** Tests whether a brush pattern is being used.
+@return ETrue, if a brush pattern is being used; EFalse, otherwise. */
+EXPORT_C TBool CFbsBitGc::IsBrushPatternUsed() const
+	{
+	return iBrushUsed;
+	}
+
+/** Tests whether a font is used.
+@return ETrue, if a font is being used; EFalse, otherwise. */
+EXPORT_C TBool CFbsBitGc::IsFontUsed() const
+	{
+	if (iFont.Handle())
+		return ETrue;
+
+	return EFalse;
+	}
+
+TBool CFbsBitGc::UserClipRect(TRect& aRect)
+	{
+	if (!aRect.Intersects(iUserClipRect))
+		return ETrue;
+
+	aRect.Intersection(iUserClipRect);
+
+	return EFalse;
+	}
+
+/** Fetches the bounding rectangle of all drawing done since this function was last 
+called.
+@param aRect The bounding rectangle. */
+EXPORT_C void CFbsBitGc::RectDrawnTo(TRect& aRect)
+	{
+	aRect = iDrawnTo;
+	iDrawnTo.SetRect(0,0,0,0);
+	}
+
+/** Updates the justification settings.
+This function assumes that ActivateNoJustAutoUpdate() has been used.
+@param aText The text for which justification is to be adjusted. */
+EXPORT_C void CFbsBitGc::UpdateJustification(const TDesC& aText)
+	{
+	TTextParameters* param = NULL;
+	UpdateJustification(aText,param);
+	}
+
+/** Updates the justification for vertical text.
+@param aText The text for which justification is to be adjusted.
+@param aUp ETrue, if text is to be justified upwards;EFalse, if text is to 
+be justified downwards. */
+EXPORT_C void CFbsBitGc::UpdateJustificationVertical(const TDesC& aText, TBool aUp)
+	{
+	TTextParameters* param = NULL;
+	UpdateJustificationVertical(aText,param,aUp);
+	}
+
+/** Updates the justification settings.
+This function assumes that ActivateNoJustAutoUpdate() has been used.
+@param aText The text for which justification is to be adjusted. */
+EXPORT_C void CFbsBitGc::UpdateJustification(const TDesC& aText,const TTextParameters* aParam)
+	{
+	if ((iCharJustNum < 1 || iCharJustExcess == 0) && (iWordJustNum < 1 || iWordJustExcess < 1))
+		return;
+
+	TInt length = aText.Length();
+	CFont::TPositionParam param;
+	param.iText.Set(aText);		// Set the start of the string
+	if (aParam)
+		{
+		length = aParam->iEnd;
+		param.iPosInText = aParam->iStart;
+		}
+	TInt excess = 0;
+	TInt glyphs = 0;
+	RShapeInfo shapeInfo;
+	for (TInt count = 0; count < length; count++)
+		{
+		if (iCharJustNum > 0 && iCharJustExcess != 0)
+			excess += CGraphicsContext::JustificationInPixels(iCharJustExcess, iCharJustNum);
+		if (iWordJustNum > 0 && iWordJustExcess > 0 && aText[count] == ' ')
+			excess += CGraphicsContext::JustificationInPixels(iWordJustExcess, iWordJustNum);
+
+		if (iCharJustNum < glyphs + length - count)	// there's at least 1 combined glyph to come
+			{
+			// otherwise we can skip this slow bit and just increment
+			if (iFont.GetCharacterPosition2(param, shapeInfo))
+				count = param.iPosInText - 1;	// -1 'cos it gets incremented anyway
+			}
+		glyphs++;
+		}
+	if(shapeInfo.IsOpen())
+			shapeInfo.Close();
+
+	iLastPrintPosition.iX += excess;
+	}
+
+/** Updates the justification for vertical text.
+@param aText The text for which justification is to be adjusted.
+@param aUp ETrue, if text is to be justified upwards;EFalse, if text is to 
+be justified downwards. */
+EXPORT_C void CFbsBitGc::UpdateJustificationVertical(const TDesC& aText,const TTextParameters* aParam,TBool aUp)
+	{
+	if ((iCharJustNum < 1 || iCharJustExcess == 0) && (iWordJustNum < 1 || iWordJustExcess < 1))
+		return;
+
+	TInt length = aText.Length();
+	CFont::TPositionParam param;
+	param.iText.Set(aText);		// Set the start of the string
+	if (aParam)
+		{
+		length = aParam->iEnd;
+		param.iPosInText = aParam->iStart;
+		}
+	TInt excess=0;
+	TInt glyphs = 0;
+	RShapeInfo shapeInfo;
+	for (TInt count = 0; count < length; count++)
+		{
+		if (iCharJustNum > 0 && iCharJustExcess != 0)
+			excess += CGraphicsContext::JustificationInPixels(iCharJustExcess, iCharJustNum);
+		if (iWordJustNum > 0 && iWordJustExcess > 0 && aText[count] == ' ')
+			excess += CGraphicsContext::JustificationInPixels(iWordJustExcess, iWordJustNum);
+		if (iCharJustNum < glyphs + length - count)	// there's at least 1 combined glyph to come
+			{
+			// otherwise we can skip this slow bit and just increment
+			if (iFont.GetCharacterPosition2(param, shapeInfo))
+				count = param.iPosInText - 1;	// -1 'cos it gets incremented anyway
+			}
+		glyphs++;
+		}
+	if (shapeInfo.IsOpen())
+		shapeInfo.Close();
+
+	if (aUp)
+		iLastPrintPosition.iY -= excess;
+	else
+		iLastPrintPosition.iY += excess;
+	}
+void CFbsBitGc::AddRect(const TRect& aRect)
+	{
+	if (iDrawnTo.IsEmpty())
+		iDrawnTo = aRect;
+	else if (!aRect.IsEmpty())
+		iDrawnTo.BoundingRect(aRect);
+	}
+
+CFbsBitGcExtraData::CFbsBitGcExtraData()
+	{
+	iShadowColor = KDefaultShadowColor;	//default shadow color
+	}
+
+CFbsBitGcExtraData::~CFbsBitGcExtraData()
+	{
+	delete[] iPenArray;
+	}
+
+void CFbsBitGcExtraData::Reset()
+	{
+	SetShadowColor(KDefaultShadowColor);
+	ResetPenArray();
+	}
+
+#define ORIENTATION_TO_CAP(orientation)	(1 << (TInt)orientation)
+
+CGraphicsAccelerator* CFbsBitGc::GraphicsAccelerator()
+	{
+	CGraphicsAccelerator* ga = iDevice->GraphicsAccelerator();
+	if(!ga)
+		return NULL;
+
+	const TGraphicsAcceleratorCaps* caps = ga->Capabilities();
+ 	//iReserved[0] specifies the supported rendering orientations. 
+ 	//Existing variable name is used to avoid SC break since it is an array.
+ 	const TUint orientationCaps = caps->iReserved[0]; 	
+ 	const TGraphicsOrientation orientation = iDevice->Orientation();
+ 	if(iDevice->iScreenDevice 
+ 	&& ((orientationCaps == 0 && orientation !=EGraphicsOrientationNormal)
+ 	|| ((ORIENTATION_TO_CAP(orientation) & orientationCaps) ==0)))
+		return NULL;
+
+	if(iUserDisplayMode!=ENone)
+		return NULL;
+
+	return ga;
+	}
+
+/** Replace target device but keep the current state
+
+@param aDevice The target device
+@internalComponent
+*/
+EXPORT_C void CFbsBitGc::ChangeDevice(CFbsDevice* aDevice)
+	{
+	iDevice = aDevice;
+	}