// Copyright (c) 1994-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:

// Shells for window server graphics class

// 

//

#include <e32std.h>

#include <graphics/wsdrawresource.h>

#include "../SERVER/w32cmd.h"

#include "CLIENT.H"

#include "w32comm.h"

#include "graphicsresourcewrapper.h"

#include <graphics/gdi/gdiconsts.h>

#include <graphics/gdi/gdistructs.h>

#include "graphics/windowserverconstants.h"

#define KDefaultShadowColor KRgbGray

enum {EPolygonMaxHeaderSize=sizeof(TWsCmdHeader)+sizeof(TWsGcCmdSegmentedDrawPolygonData)};

//

// class CWindowGc::CPimpl

//

NONSHARABLE_STRUCT(CWindowGc::CPimpl): public CBase, public MWsDrawResource

/** @internalComponent @released */

	{

public:

	enum TStateType

	    {

	    EStateBrushColor           = 1<<0,

	    EStateBrushStyle           = 1<<1,

	    EStatePenColor             = 1<<2,

	    EStatePenStyle             = 1<<3,

	    EStatePenSize              = 1<<4,           

	    EStateDrawMode             = 1<<5,

	    EStateClippingRect         = 1<<6,

        EStateUnderlineStyle       = 1<<7,

        EStateStrikethroughStyle   = 1<<8,

        EStateWordJustification    = 1<<9,

        EStateCharJustification    = 1<<10,

	    };

	CPimpl(CWindowGc& aGc);

	void WriteAnyPendingStateChanges();

	void ResetPendingState();

	void StorePendingStateChange(TStateType aState, const TAny* aValue);

	TUint32 GetState() const {return iPendingState;}

	void CancelPendingClippingRect();

	~CPimpl();

public: //from MWsDrawResource

	void DrawResource(const TPoint& aPos, const RWsDrawableSource& aSource, CWindowGc::TGraphicsRotation aRotation=CWindowGc::EGraphicsRotationNone)

		{

		iGc.DrawResource(aPos, aSource, aRotation);

		}

	void DrawResource(const TRect& aDestRect, const RWsDrawableSource& aSource, CWindowGc::TGraphicsRotation aRotation=CWindowGc::EGraphicsRotationNone)

		{

		iGc.DrawResource(aDestRect, aSource, aRotation);

		}

	void DrawResource(const TRect& aDestRect, const RWsDrawableSource& aSource, const TRect& aSrcRect, CWindowGc::TGraphicsRotation aRotation=CWindowGc::EGraphicsRotationNone)

		{

		iGc.DrawResource(aDestRect, aSource, aSrcRect, aRotation);

		}

	void DrawResource(const TRect& aDestRect, const RWsDrawableSource& aSource, const TDesC8& aParam)

		{

		iGc.DrawResource(aDestRect, aSource, aParam);

		}

public:

	CWindowGc& iGc;

	CFbsFont* iFont;

	TRgb iShadowColor;

    TBool iForceWrite;

    TBool iClippingRectSet;

private:

    TUint32 iPendingState;

    // Pending state - used to store requested state changes not yet written to wserv

    TRgb iPendingBrushColor;

	TBrushStyle iPendingBrushStyle;

    TRgb iPendingPenColor;

    TPenStyle iPendingPenStyle;

    TSize iPendingPenSize;

    TDrawMode iPendingDrawMode;

    TRect iPendingClippingRect;

    TFontUnderline iPendingUnderlineStyle;

    TFontStrikethrough iPendingStrikethroughStyle;

    TWsGcCmdSetJustification iPendingWordJustification;

    TWsGcCmdSetJustification iPendingCharJustification;

    // Current state - values that have actually been written to wserv

    TRgb iCurrentBrushColor;

	TBrushStyle iCurrentBrushStyle;

    TRgb iCurrentPenColor;

    TPenStyle iCurrentPenStyle;

    TSize iCurrentPenSize;

    TDrawMode iCurrentDrawMode;

    TFontUnderline iCurrentUnderlineStyle;

    TFontStrikethrough iCurrentStrikethroughStyle;

    TWsGcCmdSetJustification iCurrentWordJustification;

    TWsGcCmdSetJustification iCurrentCharJustification;

	};

CWindowGc::CPimpl::CPimpl(CWindowGc& aGc)

	: iGc(aGc), iFont(NULL), iShadowColor(KDefaultShadowColor)

	{

	ResetPendingState();

	}

CWindowGc::CPimpl::~CPimpl()

	{

	iFont = NULL;

	}

void CWindowGc::CPimpl::CancelPendingClippingRect()

    {

    iPendingState &= ~EStateClippingRect;

    }

void CWindowGc::CPimpl::WriteAnyPendingStateChanges()

    {

    if (iPendingState == 0)

        return;

    if (iPendingState & EStateDrawMode)

        {

        if (iPendingDrawMode != iCurrentDrawMode)

            {

            iGc.WriteInt(iPendingDrawMode,EWsGcOpSetDrawMode);

            iCurrentDrawMode = iPendingDrawMode;

            }

        }

    if (iPendingState & EStateBrushStyle)

        {

        if (iPendingBrushStyle != iCurrentBrushStyle)

            {

            iGc.WriteInt(iPendingBrushStyle,EWsGcOpSetBrushStyle);

            iCurrentBrushStyle = iPendingBrushStyle;

            }

        }

    if (iPendingState & EStateBrushColor)

        {

        // Brush colour optimisation more conservative (than for other state changes) because server-side code modifies it without client's knowledge

        if (iPendingBrushColor != iCurrentBrushColor || iForceWrite)

            {

            iGc.WriteInt(iPendingBrushColor.Internal(),EWsGcOpSetBrushColor);

            iCurrentBrushColor = iPendingBrushColor;

            iForceWrite = EFalse;

            }

        }

    if (iPendingState & EStatePenStyle)

        {

        if (iPendingPenStyle != iCurrentPenStyle)

            {

            iGc.WriteInt(iPendingPenStyle,EWsGcOpSetPenStyle);

            iCurrentPenStyle = iPendingPenStyle;   

            }

        }

    if (iPendingState & EStatePenColor)

        {

        if (iPendingPenColor != iCurrentPenColor)

            {

            iGc.WriteInt(iPendingPenColor.Internal(),EWsGcOpSetPenColor);

            iCurrentPenColor = iPendingPenColor;            

            }

        }

    if (iPendingState & EStateClippingRect)

        {

        iGc.WriteRect(iPendingClippingRect,EWsGcOpSetClippingRect);

        iClippingRectSet = ETrue;

        }

    if (iPendingState & EStateUnderlineStyle)

        {

        if (iPendingUnderlineStyle != iCurrentUnderlineStyle)

            {

            iGc.WriteInt(iPendingUnderlineStyle,EWsGcOpSetUnderlineStyle);

            iCurrentUnderlineStyle = iPendingUnderlineStyle;            

            }

        }

    if (iPendingState & EStateStrikethroughStyle)

        {

        if (iPendingStrikethroughStyle != iCurrentStrikethroughStyle)

            {

            iGc.WriteInt(iPendingStrikethroughStyle,EWsGcOpSetStrikethroughStyle);

            iCurrentStrikethroughStyle = iPendingStrikethroughStyle;

            }

        }

    if (iPendingState & EStatePenSize)

        {

        if (iPendingPenSize != iCurrentPenSize)

            {

            iGc.WriteSize(iPendingPenSize,EWsGcOpSetPenSize);

            iCurrentPenSize = iPendingPenSize;

            }

        }    

    if (iPendingState & EStateWordJustification)

        {

        if (iPendingWordJustification.excessWidth != iCurrentWordJustification.excessWidth

            || iPendingWordJustification.numGaps != iCurrentWordJustification.numGaps)

            {

            iGc.Write(&iPendingWordJustification,sizeof(iPendingWordJustification),EWsGcOpSetWordJustification);

            iCurrentWordJustification = iPendingWordJustification;

            }

        }    

    if (iPendingState & EStateCharJustification)

        {

        if (iPendingCharJustification.excessWidth != iCurrentCharJustification.excessWidth

            || iPendingCharJustification.numGaps != iCurrentCharJustification.numGaps)

            {

            iGc.Write(&iPendingCharJustification,sizeof(iPendingCharJustification),EWsGcOpSetCharJustification);

            iCurrentCharJustification = iPendingCharJustification;

            }

        }    

    iPendingState = 0;

    }

void CWindowGc::CPimpl::ResetPendingState()

    {

    // This function should only be called from CWindowGc::Reset()

    iForceWrite = EFalse;

    iPendingState = 0;

    iClippingRectSet = EFalse;

    // The following default values are the same as those used by CFbsBitGc::Reset()

    iPendingBrushColor = KRgbWhite;

    iPendingBrushStyle = CGraphicsContext::ENullBrush;

    iPendingPenColor = KRgbBlack;

    iPendingPenStyle = CGraphicsContext::ESolidPen;

    iPendingPenSize = TSize(1,1);

    iPendingDrawMode = CGraphicsContext::EDrawModePEN;

    iPendingUnderlineStyle = EUnderlineOff;    

    iPendingStrikethroughStyle = EStrikethroughOff;

    iPendingWordJustification.excessWidth = 0;

    iPendingWordJustification.numGaps = 0;

    iPendingCharJustification.excessWidth = 0;

    iPendingCharJustification.numGaps = 0;

    iCurrentBrushColor = iPendingBrushColor;

    iCurrentBrushStyle = iPendingBrushStyle;

    iCurrentPenColor = iPendingPenColor;

    iCurrentPenStyle = iPendingPenStyle;

    iCurrentPenSize = iPendingPenSize;    

    iCurrentDrawMode = iPendingDrawMode;

    iCurrentUnderlineStyle = iPendingUnderlineStyle;

    iCurrentStrikethroughStyle = iPendingStrikethroughStyle;

    iCurrentWordJustification.excessWidth = iPendingWordJustification.excessWidth;

    iCurrentWordJustification.numGaps = iPendingWordJustification.numGaps;

    iCurrentCharJustification.excessWidth = iPendingCharJustification.excessWidth;

    iCurrentCharJustification.numGaps = iPendingCharJustification.numGaps;

    }

void CWindowGc::CPimpl::StorePendingStateChange(TStateType aState, const TAny* aValue)

    {

    switch (aState)

        {

        case EStateBrushColor:

            iPendingState |= EStateBrushColor;

            iPendingBrushColor = *((TRgb*)(aValue));

            break;

        case EStateBrushStyle:

            iPendingState|=EStateBrushStyle;

            iPendingBrushStyle = *((TBrushStyle*)(aValue));

            break;

        case EStatePenColor:

            iPendingState|=EStatePenColor;

            iPendingPenColor = *((TRgb*)(aValue));

            break;

        case EStatePenStyle:

            iPendingState|=EStatePenStyle;

            iPendingPenStyle = *((TPenStyle*)(aValue));

            break;

        case EStateDrawMode:

            iPendingState|=EStateDrawMode;

            iPendingDrawMode = *((TDrawMode*)(aValue));

            break;

        case EStateClippingRect:

            iPendingState|=EStateClippingRect;

            iPendingClippingRect = *((TRect*)(aValue));

            break;

        case EStateUnderlineStyle:

            iPendingState|=EStateUnderlineStyle;

            iPendingUnderlineStyle = *((TFontUnderline*)(aValue));

            break;

        case EStateStrikethroughStyle:

            iPendingState|=EStateStrikethroughStyle;

            iPendingStrikethroughStyle= *((TFontStrikethrough*)(aValue));

            break;

        case EStatePenSize:

            iPendingState|=EStatePenSize;

            iPendingPenSize = *((TSize*)(aValue));

            break;

        case EStateWordJustification:

            iPendingState|=EStateWordJustification;

            iPendingWordJustification = *((TWsGcCmdSetJustification*)(aValue));

            break;

        case EStateCharJustification:

            iPendingState|=EStateCharJustification;

            iPendingCharJustification = *((TWsGcCmdSetJustification*)(aValue));

            break;

        default:

            break;

        }

    }

//

// class CWindowGc

//

EXPORT_C CWindowGc::CWindowGc(CWsScreenDevice *aDevice) : MWsClientClass(aDevice->iBuffer), iPimpl(NULL), iDevice(aDevice)

/** Constructor which creates, but does not initialise a graphics context. 

@param aDevice Any screen device owned by the same session. Its life time 

should be at least as long as the gc itself. 

@see CWsScreenDevice::CreateContext() */

	{}

EXPORT_C CWindowGc::~CWindowGc()

/** Destructor. */

	{

	if (iBuffer && iWsHandle)

		Write(EWsGcOpFree);

	delete iPimpl;

	}

void CWindowGc::WriteTextCommand(TAny *cmd, TInt len,const TDesC &aBuf,TInt opcode,TInt opcodePtr) const

	{

	if ((aBuf.Size()+len)>(TInt)(iBuffer->BufferSize()-sizeof(TWsCmdHeader)))

		{

		WriteReplyByProvidingRemoteReadAccess(cmd,len,&aBuf,opcodePtr);

		}

	else

		{

		Write(cmd,len,aBuf.Ptr(),aBuf.Size(),opcode);

		}

	}

void CWindowGc::WriteTextCommand(TAny *cmd, TInt len,const TDesC8 &aBuf,TInt opcode,TInt opcodePtr) const

	{

	if ((aBuf.Size()+len)>(TInt)(iBuffer->BufferSize()-sizeof(TWsCmdHeader)))

		{

		WriteReplyByProvidingRemoteReadAccess(cmd,len,&aBuf,opcodePtr);

		}

	else

		{

		Write(cmd,len,aBuf.Ptr(),aBuf.Size(),opcode);

		}

	}	

EXPORT_C TInt CWindowGc::Construct()

/** Completes construction. 

@return KErrNone if successful, otherwise a leave error. 

@panic TW32Panic 17 in debug builds if called on an already constructed object.

This function always causes a flush of the window server buffer. */

	{

	__ASSERT_DEBUG(iWsHandle == KNullHandle, Panic(EW32PanicGraphicDoubleConstruction));

	iPimpl = new CPimpl(*this);

	if (!iPimpl)

		return KErrNoMemory;

	TInt ret;

	if ((ret=iBuffer->WriteReplyWs(EWsClOpCreateGc))<0)

		return(ret);

	iWsHandle=ret;

	return(KErrNone);

	}

EXPORT_C void CWindowGc::Activate(RDrawableWindow &aDevice)

/** Activates the context for a given window and updates iDevice with the pointer to the screen device of the screen on which aDevice is found.  

When drawing is complete, the code using the context should call Deactivate(). 

Draw methods invoked after an Activate() will affect the window specified. 

A graphics context can only be active for one window at a time. A panic occurs 

if a draw function is called before calling this function, or if Activate() 

is called twice without an intervening Deactivate().

@param aWindow The window for which the graphics context is to be activated. */

	{

	TUint devicePointer = WriteReplyInt(aDevice.WsHandle(),EWsGcOpActivate);

	iDevice = (CWsScreenDevice*)devicePointer;

	iPimpl->iForceWrite = ETrue; // needed because brush colour set to window background colour in CWsGc::Activate

	}

EXPORT_C void CWindowGc::Deactivate()

/** Frees the graphics context to be used with another window. 

This method should be called when the application has completed drawing to 

the window. */

	{

	iPimpl->ResetPendingState(); // needed because server-side state is reset on deactivation

	Write(EWsGcOpDeactivate);

	iPimpl->iFont=NULL;

	iPimpl->iShadowColor = KDefaultShadowColor;

	}

//====================Functions from GDI.H===============================

EXPORT_C CGraphicsDevice* CWindowGc::Device() const

/** Returns a pointer to the device, more specifically a CWsScreenDevice, for the screen that the WindowGc was last activated on.

If the WindowGc has not been activated at all, it then returns the device that was passed to its constructor.

The user should be careful when calling this function since it can return the screen device of any screen in the system.

Hence, the return value of this function will be useful only if the user is aware of how the WindowGc was used before this function is called.

@return A pointer to the device for the screen that the WindowGc was last activated on or the device passed at construction*/

	{

	return(iDevice);

	}

EXPORT_C void CWindowGc::SetOrigin(const TPoint &aPoint)

/** Sets the position of the co-ordinate origin. 

All subsequent drawing operations are then done relative to this origin. The 

default origin is (0,0), the top left corner of the window.

@param aPoint A point for the origin, default (0,0). 

@see CGraphicsContext::SetOrigin() */

	{

	if ( iPimpl->GetState() & CPimpl::EStateClippingRect )

	    {

	    iPimpl->WriteAnyPendingStateChanges();

	    }

	WritePoint(aPoint,EWsGcOpSetOrigin);

	}

EXPORT_C void CWindowGc::SetClippingRect(const TRect& aRect)

/** Sets a clipping rectangle.

Graphics drawn to the window are clipped, so that only items which fall within 

the rectangle are displayed. 

Note that clipping is additive. If a clipping region has been set using SetClippingRegion() 

then clipping will be to the intersection of that region and this rectangle.

@param aRect The clipping rectangle in window co-ordinates. Note that this rectangle is 

tranformed by the current drawing co-ordinate origin before it is used. 

The co-ordinate origin is set using SetOrigin().

@see SetClippingRegion() */

	{

    TRect rect(aRect);

    iPimpl->StorePendingStateChange(CPimpl::EStateClippingRect, &rect);

	}

EXPORT_C void CWindowGc::CancelClippingRect()

/** Cancels the clipping rectangle. 

@see SetClippingRect() */

	{

	if (iPimpl->GetState() & CPimpl::EStateClippingRect)

	    {

	    iPimpl->CancelPendingClippingRect();

	    }

	if (iPimpl->iClippingRectSet)

	    {

        Write(EWsGcOpCancelClippingRect);

	    }

	iPimpl->iClippingRectSet = EFalse;

	}

EXPORT_C TInt CWindowGc::SetClippingRegion(const TRegion &aRegion)

/** Sets the clipping region.

Drawing is always clipped to the visible area of a window. The region specified 

by this function is in addition to that area.

This function always causes a flush of the window server buffer.

@param aRegion The new clipping region in window co-ordinates 

as used in SetClippingRect(). The clipping region is transformed by the current 

drawing origin before use.

@return KErrNone if successful, KErrNoMemory if there is insufficient memory 

to create the region on the server side, otherwise another error code. 

@see SetClippingRect() */

	{

	const TInt regionCount=aRegion.Count();

	TPtrC8 ptrRect(reinterpret_cast<const TUint8*>(aRegion.RectangleList()),regionCount*sizeof(TRect));

	return(WriteReplyByProvidingRemoteReadAccess(&regionCount,sizeof(regionCount),&ptrRect,EWsGcOpSetClippingRegion));

	}

EXPORT_C void CWindowGc::CancelClippingRegion()

/** Cancels the current clipping region. */

	{

	Write(EWsGcOpCancelClippingRegion);

	}

EXPORT_C void CWindowGc::SetDrawMode(TDrawMode aDrawingMode)

/** 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. 

There are 13 drawing modes (see CGraphicsContext::TDrawMode enum), each giving 

different logical combinations of pen, brush and screen colours. Each mode 

is produced by ORing together different combinations of seven drawing mode 

components (see CGraphicsContext::TDrawModeComponents enum).

The three most important modes are TDrawMode::EDrawModePEN, TDrawMode::EDrawModeNOTSCREEN 

and TDrawMode::EDrawModeXOR. The default drawing mode is TDrawMode::EDrawModePEN.

The drawing mode is over-ridden for line and shape drawing functions when 

a wide pen line has been selected. It is forced to TDrawMode::EDrawModePEN. 

This is to prevent undesired effects at line joins (vertexes).

Notes:

TDrawMode::EDrawModeAND gives a "colour filter" effect. For example:

ANDing with white gives the original colour 

ANDing with black gives black 

TDrawMode::EDrawModeOR gives a "colour boost" effect. For example:

ORing with black gives the original colour 

ORing with white gives white 

TDrawMode::EDrawModeXOR gives an "Exclusive OR" effect. For example:

white XOR black gives white 

white XOR white gives black 

black XOR black gives black

@param aDrawingMode A drawing mode. 

@see CGraphicsContext::SetDrawMode() */

	{

    iPimpl->StorePendingStateChange(CPimpl::EStateDrawMode, &aDrawingMode);

	}

EXPORT_C void CWindowGc::UseFont(const CFont *aFont)

/** Sets this context's font.

The font is used for text drawing. If the font is already in the font and 

bitmap server's memory the GDI will share that copy.

Note that this function must be called prior to drawing text or the calling 

thread will panic.

@param aFont A device font. 

@see CGraphicsContext::UseFont() */

	{

	if (iPimpl->iFont!=(CFbsFont *)aFont)

		{

		iPimpl->iFont=(CFbsFont *)aFont;

		WriteInt(iPimpl->iFont->Handle(),EWsGcOpUseFont);

		}

	}

EXPORT_C void CWindowGc::DiscardFont()

/** Discards a font. 

This frees up the memory used (if the font is not being shared with some other 

process).

Note that if no font is in use when this function is called, then there is no effect.

@see CGraphicsContext::DiscardFont() */

	{

	Write(EWsGcOpDiscardFont);

	iPimpl->iFont=NULL;

	}

EXPORT_C void CWindowGc::SetUnderlineStyle(TFontUnderline aUnderlineStyle)

/** Sets the underline style for all subsequently drawn text.

@param aUnderlineStyle The underline style: either on or off.

@see CGraphicsContext::SetUnderlineStyle() */

	{

    iPimpl->StorePendingStateChange(CPimpl::EStateUnderlineStyle, &aUnderlineStyle);	

	}

EXPORT_C void CWindowGc::SetStrikethroughStyle(TFontStrikethrough aStrikethroughStyle)

/** Sets the strikethrough style for all subsequently drawn text.

@param aStrikethroughStyle The strikethrough style: either on or off. 

@see CGraphicsContext::SetStrikethroughStyle() */

	{

	iPimpl->StorePendingStateChange(CPimpl::EStateStrikethroughStyle, &aStrikethroughStyle);

	}

void CWindowGc::SetJustification(TInt aExcessWidth,TInt aNumGaps, TInt aOpcode)

	{

	TWsGcCmdSetJustification justification;

	justification.excessWidth=aExcessWidth;

	justification.numGaps=aNumGaps;

	if (aOpcode == EWsGcOpSetWordJustification)

	    {

        iPimpl->StorePendingStateChange(CPimpl::EStateWordJustification, &justification);

	    }

	else if (aOpcode == EWsGcOpSetCharJustification)

	    {

        iPimpl->StorePendingStateChange(CPimpl::EStateCharJustification, &justification);

	    }

	}

EXPORT_C void CWindowGc::SetWordJustification(TInt aExcessWidth,TInt aNumGaps)

/** Sets word justification.

This function is particularly useful for doing WYSIWYG underlining or strikethrough, 

as it ensures that the lines extend correctly into the gaps between words. It is not 

intended for regular use by developers.

@param aExcessWidth The excess width (in pixels) to be distributed between 

the specified number of gaps (starting immediately) 

@param aNumGaps The number of gaps between words 

@see CGraphicsContext::SetWordJustification() */

	{

	SetJustification(aExcessWidth, aNumGaps, EWsGcOpSetWordJustification);

	}

EXPORT_C void CWindowGc::SetCharJustification(TInt aExcessWidth,TInt aNumChars)

/** Sets the character justification.

This function is used primarily to get accurate WYSIWYG, and is not intended 

for regular use by developers.

The text line that is to be justified has a certain number of characters (this 

includes the spaces between the words). It also has a distance (in pixels) 

between the end of the last word and the actual end of the line (right hand 

margin, usually). These excess width pixels are distributed amongst all the 

characters, increasing the gaps between them, to achieve full justification 

of the text line.

This function is particularly useful for WYSIWYG underlining or strikethrough, 

as it ensures that the lines extend into the gaps between characters.

See CGraphicsContext::SetCharJustification() for more information.

@param aExcessWidth The excess width (in pixels) to be distributed between 

the specified number of characters. 

@param aNumChars The number of characters involved 

@see CGraphicsContext::SetCharJustification() */

	{

	SetJustification(aExcessWidth, aNumChars, EWsGcOpSetCharJustification);

	}

EXPORT_C void CWindowGc::SetPenColor(const TRgb &aColor)

/** Sets the pen colour.

The effective pen colour depends on the drawing mode (see SetDrawMode()).

The default pen colour is black.

@param aColor The RGB colour for the pen. 

@see CGraphicsContext::SetPenColor() */

	{

	TRgb color = aColor;

    iPimpl->StorePendingStateChange(CPimpl::EStatePenColor, &color);

	}

EXPORT_C void CWindowGc::SetPenStyle(TPenStyle aPenStyle)

/** Sets the line drawing style for the pen. 

The pen is used when drawing lines and for the outline of filled shapes. There 

are 6 pen styles (see CGraphicsContext::TPenStyle enum). If no pen style is 

set, the default is TPenStyle::ESolidPen.

To use a pen style, its full context must be given, e.g. for a null pen: CGraphicsContext::TPenStyle::ENullPen.

@param aPenStyle A pen style. 

@see CGraphicsContext::SetPenStyle() */

	{

	iPimpl->StorePendingStateChange(CPimpl::EStatePenStyle, &aPenStyle);

	}

EXPORT_C void CWindowGc::SetPenSize(const TSize& aSize)

/** Sets the line drawing size for the pen.

Lines of size greater than one pixel are drawn with rounded ends that extend 

beyond the end points, (as if the line is drawn using a circular pen tip of 

the specified size). Rounded ends of lines drawn with a wide pen are always 

drawn in TDrawMode::EDrawModePEN mode, overriding whatever mode has been set 

using SetDrawMode().

@param aSize A line size, the default being 1 pixel. 

@see CGraphicsContext::SetPenSize() */

	{

	TSize size(aSize);

	iPimpl->StorePendingStateChange(CPimpl::EStatePenSize, &size);

	}

EXPORT_C void CWindowGc::SetBrushColor(const TRgb &aColor)

/** Sets the brush colour. 

The effective brush colour depends on the drawing mode (see SetDrawMode()). 

If no brush colour has been set, it defaults to white. However the default 

brush style is null, so when drawing to a window, the default appears to be 

the window's background colour.

@param aColor The RGB colour for the brush. 

@see CGraphicsContext::SetBrushColor() */

	{

	TRgb color = aColor;

    iPimpl->StorePendingStateChange(CPimpl::EStateBrushColor, &color);

	}

EXPORT_C void CWindowGc::SetBrushStyle(TBrushStyle aBrushStyle)

/** Sets the line drawing style for the brush.

The GDI provides ten brush styles, including six built-in hatching patterns 

(see CGraphicsContext::TBrushStyle).

Use TBrushStyle::ENullBrush to draw the outline of a fillable shape on its 

own, without filling.

If the TBrushStyle::EPatternedBrush style is set, but no bitmap pattern has 

been selected using UseBrushPattern(), then the brush defaults to TBrushStyle::ENullBrush.

Hatching lines are done in the current brush colour, set using SetBrushColor(). 

Hatching can be overlaid on other graphics. The hatching pattern starts at 

the brush origin, set using SetBrushOrigin().

@param aBrushStyle The brush style. 

@see CGraphicsContext::SetBrushStyle() */

	{

	iPimpl->StorePendingStateChange(CPimpl::EStateBrushStyle, &aBrushStyle);

	}

EXPORT_C void CWindowGc::SetBrushOrigin(const TPoint &aOrigin)

/** Sets the brush pattern origin. 

This specifies the position of the pixel in the top left corner of a reference 

pattern tile, (in absolute device co-ordinates). Other copies of the pattern 

tile are then drawn around the reference one. Thus the brush origin can be 

set as the top left corner of a shape.

The brush pattern may be a built-in style (see SetBrushStyle()), or a bitmap. 

To use a bitmap, the brush must have a pattern set (see UseBrushPattern()) 

and the brush style must be set to TBrushStyle::EPatternedBrush.

Notes:

If SetBrushOrigin() is not used, then the origin defaults to (0,0).

This brush origin remains in effect for all fillable shapes drawn subsequently, 

until a new brush origin is set. Shapes can thus be considered as windows 

onto a continuous pattern field (covering the whole clipping region of a screen 

device, or the whole device area of a printer).

@param aOrigin The origin point for the brush. 

@see CGraphicsContext::SetBrushOrigin() */

	{

	WritePoint(aOrigin,EWsGcOpSetBrushOrigin);

	}

EXPORT_C void CWindowGc::UseBrushPattern(const CFbsBitmap *aDevice)

/** Sets the brush pattern to the specified bitmap. 

For the brush to actually use the bitmap, TBrushStyle::EPatternedBrush must 

be used to set the brush style (see SetBrushStyle()). When the brush pattern 

is no longer required, use DiscardBrushPattern() to free up the memory used, 

(if the bitmap is not being shared). If UseBrushPattern() is used again without 

using DiscardBrushPattern() then the previous pattern is discarded automatically.

Notes:

When loading a bitmap, the GDI checks to see if the bitmap is already in memory. 

If the bitmap is already there, then that copy is shared.

The brush does not need to have a pattern set at all. There are several built-in 

hatching patterns, which can be selected using SetBrushStyle().

@param aDevice A bitmap pattern for the brush 

@see CGraphicsContext::UseBrushPattern() */

	{

	WriteInt(aDevice->Handle(),EWsGcOpUseBrushPattern);

	AddToBitmapArray(aDevice->Handle());

	}

EXPORT_C void CWindowGc::DiscardBrushPattern()

/** Discards a non-built-in brush pattern. 

This frees up the memory used for the bitmap, if it is not being shared by 

another process.

If no brush pattern has been set when this function is called, it has no effect.

@see CGraphicsContext::DiscardBrushPattern() */

	{

	Write(EWsGcOpDiscardBrushPattern);

	}

EXPORT_C void CWindowGc::Plot(const TPoint &aPoint)

/** Draws a single point. 

The point is drawn with the current pen settings using the current drawing 

mode.

Note: if the pen size is greater than one pixel, a filled circle of the current 

pen colour is drawn, with the pen size as the diameter and the plotted point 

as the centre. If the pen size is an even number of pixels, the extra pixels 

are drawn below and to the right of the centre. See SetPenSize().

@param aPoint The point to be drawn. 

@see CGraphicsContext::Plot() */

	{

	iPimpl->WriteAnyPendingStateChanges();

	WritePoint(aPoint,EWsGcOpPlot);

	}

EXPORT_C void CWindowGc::DrawLine(const TPoint &aPoint1,const TPoint &aPoint2)

/** Draws a straight line between two points.

@param aPoint1 The point at the start of the line. 

@param aPoint2 The point at the end of the line. 

@see CGraphicsContext::DrawLine() */

	{

	iPimpl->WriteAnyPendingStateChanges();

	TWsGcCmdDrawLine drawLine(aPoint1,aPoint2);

	Write(&drawLine,sizeof(drawLine),EWsGcOpDrawLine);

	}

EXPORT_C void CWindowGc::MoveTo(const TPoint &aPoint)

/** Moves the internal drawing position relative to the co-ordinate origin, without 

drawing a line.

A subsequent call to DrawLineTo() or DrawLineBy() will then use the new internal 

drawing position as the start point for the line drawn.

Notes:

The operations DrawLine(), DrawLineTo(), DrawLineBy() and DrawPolyline() also 

change the internal drawing position to the last point of the drawn line(s).

The internal drawing position is set to the co-ordinate origin if no drawing 

or moving operations have yet taken place.

@param aPoint The point to move the internal drawing position to. 

@see CGraphicsContext::MoveTo()

@see CGraphicsContext::MoveBy() */

	{

	WritePoint(aPoint,EWsGcOpMoveTo);

	}

EXPORT_C void CWindowGc::MoveBy(const TPoint &aPoint)

/** Moves the internal drawing position by a vector, without drawing a line.

The internal drawing position is moved relative to its current co-ordinates.

@param aPoint The vector to move the internal drawing position by. 

@see CGraphicsContext::MoveBy()

@see CGraphicsContext::MoveTo() */

	{

	WritePoint(aPoint,EWsGcOpMoveBy);

	}

EXPORT_C void CWindowGc::DrawLineTo(const TPoint &aPoint)

/** Draws a straight line from the current internal drawing position to a point.

@param aPoint The point at the end of the line. 

@see CGraphicsContext::DrawLineTo() */

	{

	iPimpl->WriteAnyPendingStateChanges();

	WritePoint(aPoint,EWsGcOpDrawTo);

	}

EXPORT_C void CWindowGc::DrawLineBy(const TPoint &aPoint)

/** Draws a straight line relative to the current internal drawing position, using 

a vector.

The start point of the line is the current internal drawing position. The 

vector aVector is added to the internal drawing position to give the end point 

of the line

@param aPoint The vector to add to the current internal drawing position, 

giving the end point of the line. 

@see CGraphicsContext::DrawLineBy() */

	{

	iPimpl->WriteAnyPendingStateChanges();

	WritePoint(aPoint,EWsGcOpDrawBy);

	}

void CWindowGc::doDrawPolyLine(const CArrayFix<TPoint> *aPointArray, const TPoint* aPointList,TInt aNumPoints)

	{

	TWsGcOpcodes opcode=EWsGcOpDrawPolyLine;

	TWsGcCmdDrawPolyLine polyLine;

	TInt maxBufLen=(iBuffer->BufferSize()-sizeof(TWsCmdHeader)-sizeof(polyLine))/sizeof(TPoint);

	TInt sent=0;

	while(sent<aNumPoints)

		{

		TInt availableLen;

		const TPoint *ptr;

		if (aPointArray)

			{

			ptr=&(*aPointArray)[sent];

			availableLen=aPointArray->End(sent)-ptr;

			}

		else

			{

			ptr=aPointList+sent;

			availableLen=aNumPoints-sent;

			}

		polyLine.numPoints=Min(availableLen,maxBufLen);

		sent+=polyLine.numPoints;

		polyLine.more=(sent!=aNumPoints);

		Write(&polyLine,sizeof(polyLine),ptr,polyLine.numPoints*sizeof(TPoint),opcode);

		polyLine.last=ptr[polyLine.numPoints-1];

		opcode=EWsGcOpDrawPolyLineContinued;

		} 

	}

EXPORT_C void CWindowGc::DrawPolyLine(const TPoint* aPointList,TInt aNumPoints)

/** Draws a polyline using points in a list. 

A polyline is a series of concatenated straight lines joining a set of points.

@param aPointList Pointer to a list of points on the polyline. 

@param aNumPoints The number of points in the point list. 

@see CGraphicsContext::DrawPolyLine() */

	{

	iPimpl->WriteAnyPendingStateChanges();

	doDrawPolyLine(NULL,aPointList,aNumPoints);

	}

EXPORT_C void CWindowGc::DrawPolyLine(const CArrayFix<TPoint> *aPointArray)

/** Draws a polyline using points in an array. 

A polyline is a series of concatenated straight lines joining a set of points.

@param aPointArray An array containing the points on the polyline. 

@see CGraphicsContext::DrawPolyLine() */

	{

   	iPimpl->WriteAnyPendingStateChanges();

	doDrawPolyLine(aPointArray,NULL,aPointArray->Count());

	}

TInt CWindowGc::doDrawPolygon(const CArrayFix<TPoint> *aPointArray,const TPoint* aPointList,TInt aNumPoints,TFillRule aFillRule)

	{

	if (aNumPoints<=0)

		return(KErrNone);

	TWsGcCmdSegmentedDrawPolygonData polyData;

	polyData.index=0;

	TInt maxBufLen=(iBuffer->BufferSize()-EPolygonMaxHeaderSize)/sizeof(TPoint);

	FOREVER

		{

		const TPoint *ptr;

		TInt availableLen;

		if (aPointArray)

			{

			ptr=&(*aPointArray)[polyData.index];

			availableLen=aPointArray->End(polyData.index)-ptr;

			}

		else

			{

			ptr=aPointList+polyData.index;

			availableLen=aNumPoints-polyData.index;

			}

		polyData.numPoints=Min(availableLen,maxBufLen);

		if (polyData.index==0)	// First time around

			{

			if (polyData.numPoints==aNumPoints)	// Can it be done in one go?

				{

				TWsGcCmdDrawPolygon drawPolygon;

				drawPolygon.numPoints=aNumPoints;

				drawPolygon.fillRule=aFillRule;

				Write(&drawPolygon,sizeof(drawPolygon),ptr,aNumPoints*sizeof(TPoint),EWsGcOpDrawPolygon);

				break;

				}

			TWsGcCmdStartSegmentedDrawPolygon start;

			start.totalNumPoints=aNumPoints;

			TInt err=WriteReply(&start,sizeof(start),EWsGcOpStartSegmentedDrawPolygon);

			if (err!=KErrNone)

				return(err);

			}

		Write(&polyData,sizeof(polyData),ptr,polyData.numPoints*sizeof(TPoint),EWsGcOpSegmentedDrawPolygonData);