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