// 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 <graphics/gdi/gdiconsts.h>

#include <graphics/gdi/gdistructs.h>

NONSHARABLE_STRUCT(CWindowGc::CPimpl): public CBase

/** @internalComponent @released */

	{

	friend class CWindowGc;

	CPimpl();

	CFbsFont *iFont;

	};

CWindowGc::CPimpl::CPimpl() : iFont(NULL)

	{

	}

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

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;

	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;

	}

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

	{

	Write(EWsGcOpDeactivate);

	iPimpl->iFont=NULL;

	}

//====================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() */

	{

	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. 

@see SetClippingRegion() */

	{

	WriteRect(aRect,EWsGcOpSetClippingRect);

	}

EXPORT_C void CWindowGc::CancelClippingRect()

/** Cancels the clipping rectangle. 

@see SetClippingRect() */

	{

	Write(EWsGcOpCancelClippingRect);

	}

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 aClippingRegion New clipping region. 

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

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

	{

	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() */

	{

	WriteInt(aDrawingMode,EWsGcOpSetDrawMode);

	}

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() */

	{

	WriteInt(aUnderlineStyle,EWsGcOpSetUnderlineStyle);

	}

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() */

	{

	WriteInt(aStrikethroughStyle,EWsGcOpSetStrikethroughStyle);

	}

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

	{

	TWsGcCmdSetJustification justification;

	justification.excessWidth=aExcessWidth;

	justification.numGaps=aNumGaps;

	Write(&justification,sizeof(justification),aOpcode);

	}

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() */

	{

	WriteInt(aColor.Internal(),EWsGcOpSetPenColor);

	}

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() */

	{

	WriteInt(aPenStyle,EWsGcOpSetPenStyle);

	}

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() */

	{

	WriteSize(aSize,EWsGcOpSetPenSize);

	}

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() */

	{

	WriteInt(aColor.Internal(),EWsGcOpSetBrushColor);

	}

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() */

	{

	WriteInt(aBrushStyle,EWsGcOpSetBrushStyle);

	}

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() */

	{

	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() */

	{

	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.