1 // Copyright (c) 1994-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Shells for window server graphics class

    15 // 

    16 //

    17 

    18 #include <e32std.h>

    19 #include <graphics/wsdrawresource.h>

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

    21 #include "CLIENT.H"

    22 #include "w32comm.h"

    23 #include <graphics/gdi/gdiconsts.h>

    24 #include <graphics/gdi/gdistructs.h>

    25 

    26 NONSHARABLE_STRUCT(CWindowGc::CPimpl): public CBase

    27 /** @internalComponent @released */

    28 	{

    29 	friend class CWindowGc;

    30 

    31 	CPimpl();

    32 	CFbsFont *iFont;

    33 	};

    34 

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

    36 	{

    37 	}

    38 

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

    40 

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

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

    43 

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

    45 should be at least as long as the gc itself. 

    46 @see CWsScreenDevice::CreateContext() */

    47 	{}

    48 

    49 EXPORT_C CWindowGc::~CWindowGc()

    50 /** Destructor. */

    51 	{

    52 	if (iBuffer && iWsHandle)

    53 		Write(EWsGcOpFree);

    54 	delete iPimpl;

    55 	}

    56 

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

    58 	{

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

    60 		{

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

    62 		}

    63 	else

    64 		{

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

    66 		}

    67 	}

    68 

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

    70 	{

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

    72 		{

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

    74 		}

    75 	else

    76 		{

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

    78 		}

    79 	}	

    80 	

    81 EXPORT_C TInt CWindowGc::Construct()

    82 /** Completes construction. 

    83 

    84 @return KErrNone if successful, otherwise a leave error. 

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

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

    87 	{

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

    89 	iPimpl = new CPimpl;

    90 	if (!iPimpl)

    91 		return KErrNoMemory;

    92 	TInt ret;

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

    94 		return(ret);

    95 	iWsHandle=ret;

    96 	return(KErrNone);

    97 	}

    98 

    99 EXPORT_C void CWindowGc::Activate(RDrawableWindow &aDevice)

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

   101 

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

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

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

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

   106 is called twice without an intervening Deactivate().

   107 

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

   109 	{

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

   111 	iDevice = (CWsScreenDevice*)devicePointer;

   112 	}

   113 

   114 EXPORT_C void CWindowGc::Deactivate()

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

   116 

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

   118 the window. */

   119 	{

   120 	Write(EWsGcOpDeactivate);

   121 	iPimpl->iFont=NULL;

   122 	}

   123 

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

   125 

   126 EXPORT_C CGraphicsDevice* CWindowGc::Device() const

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

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

   129 

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

   131 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.

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

   133 	{

   134 	return(iDevice);

   135 	}

   136 

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

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

   139 

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

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

   142 

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

   144 @see CGraphicsContext::SetOrigin() */

   145 	{

   146 	WritePoint(aPoint,EWsGcOpSetOrigin);

   147 	}

   148 

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

   150 /** Sets a clipping rectangle.

   151 

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

   153 the rectangle are displayed. 

   154 

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

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

   157 

   158 @param aRect The clipping rectangle. 

   159 @see SetClippingRegion() */

   160 	{

   161 	WriteRect(aRect,EWsGcOpSetClippingRect);

   162 	}

   163 

   164 EXPORT_C void CWindowGc::CancelClippingRect()

   165 /** Cancels the clipping rectangle. 

   166 

   167 @see SetClippingRect() */

   168 	{

   169 	Write(EWsGcOpCancelClippingRect);

   170 	}

   171 

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

   173 /** Sets the clipping region.

   174 

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

   176 by this function is in addition to that area.

   177 

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

   179 

   180 @param aClippingRegion New clipping region. 

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

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

   183 	{

   184 	const TInt regionCount=aRegion.Count();

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

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

   187 	}

   188 

   189 EXPORT_C void CWindowGc::CancelClippingRegion()

   190 /** Cancels the current clipping region. */

   191 	{

   192 	Write(EWsGcOpCancelClippingRegion);

   193 	}

   194 

   195 EXPORT_C void CWindowGc::SetDrawMode(TDrawMode aDrawingMode)

   196 /** Sets the drawing mode. 

   197 

   198 This affects the colour that is actually drawn, because it defines the way 

   199 that the current screen colour logically combines with the current pen colour 

   200 and brush colour. 

   201 

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

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

   204 is produced by ORing together different combinations of seven drawing mode 

   205 components (see CGraphicsContext::TDrawModeComponents enum).

   206 

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

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

   209 

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

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

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

   213 

   214 Notes:

   215 

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

   217 

   218 ANDing with white gives the original colour 

   219 

   220 ANDing with black gives black 

   221 

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

   223 

   224 ORing with black gives the original colour 

   225 

   226 ORing with white gives white 

   227 

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

   229 

   230 white XOR black gives white 

   231 

   232 white XOR white gives black 

   233 

   234 black XOR black gives black

   235 

   236 @param aDrawingMode A drawing mode. 

   237 @see CGraphicsContext::SetDrawMode() */

   238 	{

   239 	WriteInt(aDrawingMode,EWsGcOpSetDrawMode);

   240 	}

   241 

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

   243 /** Sets this context's font.

   244 

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

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

   247 

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

   249 thread will panic.

   250 

   251 @param aFont A device font. 

   252 @see CGraphicsContext::UseFont() */

   253 	{

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

   255 		{

   256 		iPimpl->iFont=(CFbsFont *)aFont;

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

   258 		}

   259 	}

   260 

   261 EXPORT_C void CWindowGc::DiscardFont()

   262 /** Discards a font. 

   263 

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

   265 process).

   266 

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

   268 

   269 @see CGraphicsContext::DiscardFont() */

   270 	{

   271 	Write(EWsGcOpDiscardFont);

   272 	iPimpl->iFont=NULL;

   273 	}

   274 

   275 EXPORT_C void CWindowGc::SetUnderlineStyle(TFontUnderline aUnderlineStyle)

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

   277 

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

   279 @see CGraphicsContext::SetUnderlineStyle() */

   280 	{

   281 	WriteInt(aUnderlineStyle,EWsGcOpSetUnderlineStyle);

   282 	}

   283 

   284 EXPORT_C void CWindowGc::SetStrikethroughStyle(TFontStrikethrough aStrikethroughStyle)

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

   286 

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

   288 @see CGraphicsContext::SetStrikethroughStyle() */

   289 	{

   290 	WriteInt(aStrikethroughStyle,EWsGcOpSetStrikethroughStyle);

   291 	}

   292 

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

   294 	{

   295 	TWsGcCmdSetJustification justification;

   296 

   297 	justification.excessWidth=aExcessWidth;

   298 	justification.numGaps=aNumGaps;

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

   300 	}

   301 

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

   303 /** Sets word justification.

   304 

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

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

   307 intended for regular use by developers.

   308 

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

   310 the specified number of gaps (starting immediately) 

   311 @param aNumGaps The number of gaps between words 

   312 @see CGraphicsContext::SetWordJustification() */

   313 	{

   314 	SetJustification(aExcessWidth, aNumGaps, EWsGcOpSetWordJustification);

   315 	}

   316 

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

   318 /** Sets the character justification.

   319 

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

   321 for regular use by developers.

   322 

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

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

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

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

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

   328 of the text line.

   329 

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

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

   332 

   333 See CGraphicsContext::SetCharJustification() for more information.

   334 

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

   336 the specified number of characters. 

   337 @param aNumChars The number of characters involved 

   338 @see CGraphicsContext::SetCharJustification() */

   339 	{

   340 	SetJustification(aExcessWidth, aNumChars, EWsGcOpSetCharJustification);

   341 	}

   342 

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

   344 /** Sets the pen colour.

   345 

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

   347 

   348 The default pen colour is black.

   349 

   350 @param aColor The RGB colour for the pen. 

   351 @see CGraphicsContext::SetPenColor() */

   352 	{

   353 	WriteInt(aColor.Internal(),EWsGcOpSetPenColor);

   354 	}

   355 

   356 EXPORT_C void CWindowGc::SetPenStyle(TPenStyle aPenStyle)

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

   358 

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

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

   361 set, the default is TPenStyle::ESolidPen.

   362 

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

   364 

   365 @param aPenStyle A pen style. 

   366 @see CGraphicsContext::SetPenStyle() */

   367 	{

   368 	WriteInt(aPenStyle,EWsGcOpSetPenStyle);

   369 	}

   370 

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

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

   373 

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

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

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

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

   378 using SetDrawMode().

   379 

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

   381 @see CGraphicsContext::SetPenSize() */

   382 	{

   383 	WriteSize(aSize,EWsGcOpSetPenSize);

   384 	}

   385 

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

   387 /** Sets the brush colour. 

   388 

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

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

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

   392 the window's background colour.

   393 

   394 @param aColor The RGB colour for the brush. 

   395 @see CGraphicsContext::SetBrushColor() */

   396 	{

   397 	WriteInt(aColor.Internal(),EWsGcOpSetBrushColor);

   398 	}

   399 

   400 EXPORT_C void CWindowGc::SetBrushStyle(TBrushStyle aBrushStyle)

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

   402 

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

   404 (see CGraphicsContext::TBrushStyle).

   405 

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

   407 own, without filling.

   408 

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

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

   411 

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

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

   414 the brush origin, set using SetBrushOrigin().

   415 

   416 @param aBrushStyle The brush style. 

   417 @see CGraphicsContext::SetBrushStyle() */

   418 	{

   419 	WriteInt(aBrushStyle,EWsGcOpSetBrushStyle);

   420 	}

   421 

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

   423 /** Sets the brush pattern origin. 

   424 

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

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

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

   428 set as the top left corner of a shape.

   429 

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

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

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

   433 

   434 Notes:

   435 

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

   437 

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

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

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

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

   442 

   443 @param aOrigin The origin point for the brush. 

   444 @see CGraphicsContext::SetBrushOrigin() */

   445 	{

   446 	WritePoint(aOrigin,EWsGcOpSetBrushOrigin);

   447 	}

   448 

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

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

   451 

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

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

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

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

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

   457 

   458 Notes:

   459 

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

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

   462 

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

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

   465 

   466 @param aDevice A bitmap pattern for the brush 

   467 @see CGraphicsContext::UseBrushPattern() */

   468 	{

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

   470 	AddToBitmapArray(aDevice->Handle());

   471 	}

   472 

   473 EXPORT_C void CWindowGc::DiscardBrushPattern()

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

   475 

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

   477 another process.

   478 

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

   480 

   481 @see CGraphicsContext::DiscardBrushPattern() */

   482 	{

   483 	Write(EWsGcOpDiscardBrushPattern);

   484 	}

   485 

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

   487 /** Draws a single point. 

   488 

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

   490 mode.

   491 

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

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

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

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

   496 

   497 @param aPoint The point to be drawn. 

   498 @see CGraphicsContext::Plot() */

   499 	{

   500 	WritePoint(aPoint,EWsGcOpPlot);

   501 	}

   502 

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

   504 /** Draws a straight line between two points.

   505 

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

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

   508 @see CGraphicsContext::DrawLine() */

   509 	{

   510 	TWsGcCmdDrawLine drawLine(aPoint1,aPoint2);

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

   512 	}

   513 

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

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

   516 drawing a line.

   517 

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

   519 drawing position as the start point for the line drawn.

   520 

   521 Notes:

   522 

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

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

   525 

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

   527 or moving operations have yet taken place.

   528 

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

   530 @see CGraphicsContext::MoveTo()

   531 @see CGraphicsContext::MoveBy() */

   532 	{

   533 	WritePoint(aPoint,EWsGcOpMoveTo);

   534 	}

   535 

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

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

   538 

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

   540 

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

   542 @see CGraphicsContext::MoveBy()

   543 @see CGraphicsContext::MoveTo() */

   544 	{

   545 	WritePoint(aPoint,EWsGcOpMoveBy);

   546 	}

   547 

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

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

   550 

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

   552 @see CGraphicsContext::DrawLineTo() */

   553 	{

   554 	WritePoint(aPoint,EWsGcOpDrawTo);

   555 	}

   556 

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

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

   559 a vector.

   560 

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

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

   563 of the line

   564 

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

   566 giving the end point of the line. 

   567 @see CGraphicsContext::DrawLineBy() */

   568 	{

   569 	WritePoint(aPoint,EWsGcOpDrawBy);

   570 	}

   571 

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

   573 	{

   574 	TWsGcOpcodes opcode=EWsGcOpDrawPolyLine;

   575 	TWsGcCmdDrawPolyLine polyLine;

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

   577 	TInt sent=0;

   578 	while(sent<aNumPoints)

   579 		{

   580 		TInt availableLen;

   581 		const TPoint *ptr;

   582 		if (aPointArray)

   583 			{

   584 			ptr=&(*aPointArray)[sent];

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

   586 			}

   587 		else

   588 			{

   589 			ptr=aPointList+sent;

   590 			availableLen=aNumPoints-sent;

   591 			}

   592 		polyLine.numPoints=Min(availableLen,maxBufLen);

   593 		sent+=polyLine.numPoints;

   594 		polyLine.more=(sent!=aNumPoints);

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

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

   597 		opcode=EWsGcOpDrawPolyLineContinued;

   598 		} 

   599 	}

   600 

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

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

   603 

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

   605 

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

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

   608 @see CGraphicsContext::DrawPolyLine() */

   609 	{

   610 	doDrawPolyLine(NULL,aPointList,aNumPoints);

   611 	}

   612 

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

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

   615 

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

   617 

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

   619 @see CGraphicsContext::DrawPolyLine() */

   620 	{

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

   622 	}

   623 

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

   625 	{

   626 	if (aNumPoints<=0)

   627 		return(KErrNone);

   628 	TWsGcCmdSegmentedDrawPolygonData polyData;

   629 	polyData.index=0;

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

   631 	FOREVER

   632 		{

   633 		const TPoint *ptr;

   634 		TInt availableLen;

   635 		if (aPointArray)

   636 			{

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

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

   639 			}

   640 		else

   641 			{

   642 			ptr=aPointList+polyData.index;

   643 			availableLen=aNumPoints-polyData.index;

   644 			}

   645 		polyData.numPoints=Min(availableLen,maxBufLen);

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

   647 			{

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

   649 				{

   650 				TWsGcCmdDrawPolygon drawPolygon;

   651 				drawPolygon.numPoints=aNumPoints;

   652 				drawPolygon.fillRule=aFillRule;

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

   654 				break;

   655 				}

   656 			TWsGcCmdStartSegmentedDrawPolygon start;

   657 			start.totalNumPoints=aNumPoints;

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

   659 			if (err!=KErrNone)

   660 				return(err);

   661 			}

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

   663 		polyData.index+=polyData.numPoints;

   664 		if (polyData.index==aNumPoints)

   665 			{

   666 			TWsGcCmdDrawSegmentedPolygon draw;

   667 			draw.fillRule=aFillRule;

   668 			Write(&draw,sizeof(draw),EWsGcOpDrawSegmentedPolygon);

   669 			break;

   670 			}

   671 		}

   672 	return(KErrNone);

   673 	}

   674 

   675 EXPORT_C TInt CWindowGc::DrawPolygon(const TPoint* aPointList,TInt aNumPoints,TFillRule aFillRule)

   676 /** Draws and fills a polygon using points defined in a list.

   677 

   678 The first TPoint in the list defines the start of the first side of the polygon. 

   679 The second TPoint defines the second vertex (the end point of the first side 

   680 and the start point of the second side) and so on. The final side of the polygon 

   681 is drawn using the last TPoint from the array or list, and the line drawn 

   682 to the start point of the first side.

   683 

   684 Self-crossing polygons can be filled according to one of two rules, TFillRule::EAlternate 

   685 (the default), or TFillRule::EWinding. To explain the difference between these 

   686 rules, the concept of a winding number needs to be introduced. The area outside 

   687 any of the loops of the polygon has a winding number of zero, and is never 

   688 filled. An inside a loop which is bounded by an area with winding number 0 

   689 has a winding number of 1. If an area is within a loop that is bounded by 

   690 an area with winding number 1, e.g. a loop within a loop, has a winding number 

   691 of 2, and so on.

   692 

   693 The filling of a polygon proceeds according to this algorithm:

   694 

   695 If aFillRule is TFillRule::EAlternate (default) and it has an odd winding 

   696 number, then fill the surrounding area.

   697 

   698 If aFillRule is TFillRule::EWinding and it has a winding number greater than 

   699 zero, then fill the surrounding area.

   700 

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

   702 

   703 @param aPointList Pointer to a list of points, specifying the vertices of 

   704 the polygon. 

   705 @param aNumPoints The number of points in the vertex list 

   706 @param aFillRule Either TFillRule::EAlternate (the default) or TFillRule::EWinding. 

   707 @return KErrNone if successful, otherwise another of the system-wide error 

   708 codes. 

   709 @see CGraphicsContext::DrawPolygon() */

   710 	{

   711 	return(doDrawPolygon(NULL,aPointList,aNumPoints,aFillRule));

   712 	}

   713 

   714 EXPORT_C TInt CWindowGc::DrawPolygon(const CArrayFix<TPoint> *aPointArray,TFillRule aFillRule)

   715 /** Draws and fills a polygon using points defined in an array.

   716 

   717 The first TPoint in the array defines the start of the first side of the polygon. 

   718 The second TPoint defines the second vertex (the end point of the first side 

   719 and the start point of the second side) and so on. The final side of the polygon 

   720 is drawn using the last TPoint from the array or list, and the line drawn 

   721 to the start point of the first side.

   722 

   723 Self-crossing polygons can be filled according to one of two rules, TFillRule::EAlternate 

   724 (the default), or TFillRule::EWinding. To explain the difference between these 

   725 rules, the concept of a winding number needs to be introduced. The area outside 

   726 any of the loops of the polygon has a winding number of zero, and is never 

   727 filled. An inside a loop which is bounded by an area with winding number 0 

   728 has a winding number of 1. If an area is within a loop that is bounded by 

   729 an area with winding number 1, e.g. a loop within a loop, has a winding number 

   730 of 2, and so on.

   731 

   732 The filling of a polygon proceeds according to this algorithm:

   733 

   734 If aFillRule is TFillRule::EAlternate (default) and it has an odd winding 

   735 number, then fill the surrounding area.

   736 

   737 If aFillRule is TFillRule::EWinding and it has a winding number greater than 

   738 zero, then fill the surrounding area.

   739 

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

   741 

   742 @param aPointArray An array of points, specifying the vertices of the polygon. 

   743 @param aFillRule Either TFillRule::EAlternate (the default) or TFillRule::EWinding. 

   744 @return KErrNone if successful, otherwise another of the system-wide error 

   745 codes. 

   746 @see CGraphicsContext::DrawPolygon() */

   747 	{

   748 	return(doDrawPolygon(aPointArray,NULL,aPointArray->Count(),aFillRule));

   749 	}

   750 

   751 void CWindowGc::DrawArcOrPie(const TRect &aRect,const TPoint &aStart,const TPoint &aEnd, TInt aOpcode)

   752 	{

   753 	TWsGcCmdDrawArcOrPie cmd(aRect,aStart,aEnd);

   754 	Write(&cmd,sizeof(cmd),aOpcode);

   755 	}

   756 

   757 EXPORT_C void CWindowGc::DrawArc(const TRect &aRect,const TPoint &aStart,const TPoint &aEnd)

   758 /** Draws an arc (a portion of an ellipse).

   759 

   760 The point aStart is used to define one end of a line from the geometric centre 

   761 of the ellipse. The point of intersection between this line and the ellipse 

   762 defines the start point of the arc. The point aEnd is used to define one end 

   763 of a second line from the geometric centre of the ellipse. The point of intersection 

   764 between this line and the ellipse defines the end point of the arc. The pixels 

   765 at both the start point and the end point are drawn.

   766 

   767 The arc itself is the segment of the ellipse in an anti-clockwise direction 

   768 from the start point to the end point.

   769 

   770 Notes

   771 

   772 A rectangle is used in the construction of the ellipse of which the arc is 

   773 a segment. This rectangle is passed as an argument of type TRect.

   774 

   775 A wide line arc is drawn with the pixels distributed either side of a true 

   776 ellipse, in such a way that the outer edge of the line would touch the edge 

   777 of the construction rectangle. In other words, the ellipse used to construct 

   778 it is slightly smaller than that for a single pixel line size.

   779 

   780 If aStart or aEnd are the ellipse centre then the line that defines the start/end 

   781 of the arc defaults to one extending vertically above the centre point.

   782 

   783 If aStart and aEnd are the same point, or points on the same line through 

   784 the ellipse centre then a complete unfilled ellipse is drawn.

   785 

   786 Line drawing is subject to pen colour, width and style and draw mode

   787 

   788 @param aRect The rectangle in which to draw the ellipse (of which the arc is 

   789 a segment).

   790 @param aStart A point to define the start of the arc.

   791 @param aEnd A point to define the end of the arc.

   792 @see CGraphicsContext::DrawArc() */

   793 	{

   794 	DrawArcOrPie(aRect,aStart,aEnd,EWsGcOpDrawArc);

   795 	}

   796 

   797 EXPORT_C void CWindowGc::DrawPie(const TRect &aRect,const TPoint &aStart,const TPoint &aEnd)

   798 /** Draws and fills a pie-shaped slice of an ellipse.

   799 

   800 Outlines are subject to the current pen colour, width, style and draw mode. 

   801 Set the pen to ENullPen for no outline. The fill is subject to brush style 

   802 (colour, hash or pattern), the origin and the current drawing mode. Set the 

   803 brush to ENullBrush for no fill.

   804 

   805 The point aStart is used to define one end of a line to the centre of the 

   806 ellipse. The point of intersection between this line and the ellipse defines 

   807 the start point of the arc bounding the pie slice. The point aEnd is used 

   808 to define one end of a second line to the centre of the ellipse. The point 

   809 of intersection between this line and the ellipse defines the end point of 

   810 the arc bounding the pie slice. The pixels at the end point are not drawn.

   811 

   812 The pie slice itself is the area bounded by: the arc of the ellipse in an 

   813 anticlockwise direction from the start point to the end point; the straight 

   814 line from the start point from the geometric centre of the ellipse; the 

   815 straight line from the end point from the geometric centre of the ellipse.

   816 

   817 The line drawn by the pen goes inside the rectangle given by the aRect argument.

   818 

   819 Notes:

   820 

   821 A rectangle is used in the construction of the pie slice. This rectangle is 

   822 passed as an argument of type TRect. The curved edge of the pie slice is an 

   823 arc of an ellipse constructed within the rectangle.

   824 

   825 A wide line edged pie slice has the arc drawn with the pixels distributed 

   826 either side of a true ellipse. This is done in such a way that the outer edge 

   827 of the line would touch the edge of the construction rectangle. In other words, 

   828 the ellipse used to construct it is slightly smaller than that for a single 

   829 pixel line size.

   830 

   831 If aStart or aEnd are the ellipse centre then the line that defines the start/end 

   832 of the arc defaults to one extending vertically above the centre point.

   833 

   834 If aStart and aEnd are the same point, or points on the same line through 

   835 the ellipse centre then a complete filled ellipse is drawn. A line is also 

   836 drawn from the edge to the ellipse centre.

   837 

   838 @param aRect A rectangle in which to draw the ellipse bounding the pie slice 

   839 @param aStart A point to define the start of the pie slice 

   840 @param aEnd A point to define the end of the pie slice 

   841 @see CGraphicsContext::DrawPie() */

   842 	{

   843 	DrawArcOrPie(aRect,aStart,aEnd,EWsGcOpDrawPie);

   844 	}

   845 

   846 EXPORT_C void CWindowGc::DrawEllipse(const TRect &aRect)

   847 /** Draws and fills an ellipse.

   848 

   849 The ellipse is drawn inside the rectangle defined by the aRect argument. Any 

   850 TRect that has odd pixel dimensions, has the bottom right corner trimmed to 

   851 give even pixel dimensions before the ellipse is constructed.

   852 

   853 The column and row of pixels containing the bottom right co-ordinate of the 

   854 aRect argument are not part of the rectangle.

   855 

   856 Note: a wide outline ellipse is drawn with the pixels distributed either side of 

   857 a true ellipse, in such a way that the outer edge of the line touches the 

   858 edge of the construction rectangle. In other words, the ellipse used to construct 

   859 it is smaller than that for a single pixel line size.

   860 

   861 @param aRect The rectangle in which to draw the ellipse 

   862 @see CGraphicsContext::DrawEllipse() */

   863 	{

   864 	WriteRect(aRect,EWsGcOpDrawEllipse);

   865 	}

   866 

   867 EXPORT_C void CWindowGc::DrawRect(const TRect &aRect)

   868 /** Draws and fills a rectangle. 

   869 

   870 The rectangle's border is drawn with the pen, and it is filled using the brush.

   871 

   872 @param aRect The rectangle to be drawn. 

   873 @see CGraphicsContext::DrawRect() */

   874 	{

   875 	WriteRect(aRect,EWsGcOpDrawRect);

   876 	}

   877 

   878 EXPORT_C void CWindowGc::DrawRoundRect(const TRect &aRect,const TSize &aEllipse)

   879 /** Draws and fills a rectangle with rounded corners.

   880 

   881 The rounded corners are each constructed as an arc of an ellipse. The dimensions 

   882 of each corner (corner size and corner height) are given by aEllipse. See 

   883 DrawArc() for a description of arc construction.

   884 

   885 The line drawn by the pen (if any) goes inside the rectangle given by the 

   886 TRect argument.

   887 

   888 Notes:

   889 

   890 Dotted and dashed pen styles cannot be used for the outline of a rounded rectangle.

   891 

   892 If either corner size dimension is greater than half the corresponding rectangle 

   893 length, the corner size dimension is reduced to half the rectangle size.

   894 

   895 @param aRect The rectangle to be drawn. 

   896 @param aEllipse The dimensions of each corner. 

   897 @see CGraphicsContext::DrawRoundRect() */

   898 	{

   899 	TWsGcCmdDrawRoundRect drawRoundRect(aRect,aEllipse);

   900 	Write(&drawRoundRect,sizeof(drawRoundRect),EWsGcOpDrawRoundRect);

   901 	}

   902 

   903 EXPORT_C void CWindowGc::DrawBitmap(const TPoint &aTopLeft, const CFbsBitmap *aDevice)

   904 /** Draws a bitmap at a specified point. 

   905 

   906 The function does a compress/stretch based on its internally stored size in 

   907 twips. Note that if the twips value of the bitmap is not set then nothing 

   908 is drawn (this is the default situation).

   909 

   910 Windows that store their redraw commands will only store drawing position and a handle to bitmaps 

   911 that are drawn in it. The bitmap handle is just a pointer to the bitmap in the FBSERV heap. 

   912 At some point later WSERV may need to draw that window again and it will just replay the 

   913 stored commands including the draw bitmap.  However, if the client has changed the content of the bitmap,

   914 WSERV will effectively draw a different bitmap when it replays the commands.

   915 

   916 Note: this member function uses the bitmap's size in twips and does a stretch/compress 

   917 blit using a linear DDA.

   918 

   919 @param aTopLeft The point where the top left pixel of the bitmap is to be 

   920 drawn 

   921 @param aDevice The source bitmap. 

   922 @see CGraphicsContext::DrawBitmap() */

   923 	{

   924 	TWsGcCmdDrawBitmap drawBitmap(aTopLeft,aDevice->Handle());

   925 	Write(&drawBitmap,sizeof(drawBitmap),EWsGcOpDrawBitmap);

   926 	AddToBitmapArray(aDevice->Handle());

   927 	}

   928 

   929 EXPORT_C void CWindowGc::DrawBitmap(const TRect &aDestRect, const CFbsBitmap *aDevice)

   930 /** Draws a bitmap in a rectangle.

   931 

   932 The bitmap is compressed/stretched to fit the specified rectangle. Note that 

   933 if the twips value of the bitmap is not set then nothing is drawn (this is 

   934 the default situation).

   935 

   936 Windows that store their redraw commands will only store drawing position and a handle to bitmaps 

   937 that are drawn in it. The bitmap handle is just a pointer to the bitmap in the FBSERV heap. 

   938 At some point later WSERV may need to draw that window again and it will just replay the 

   939 stored commands including the draw bitmap.  However, if the client has changed the content of the bitmap,

   940 WSERV will effectively draw a different bitmap when it replays the commands.

   941 

   942 Notes: this member function uses the bitmap's size in pixels and does a stretch/compress 

   943 blit using a linear DDA.

   944 

   945 @param aDestRect The rectangle within which the bitmap is to be drawn. 

   946 @param aDevice The source bitmap. 

   947 @see CGraphicsContext::DrawBitmap() */

   948 	{

   949 	TWsGcCmdDrawBitmap2 drawBitmap(aDestRect,aDevice->Handle());

   950 	Write(&drawBitmap,sizeof(drawBitmap),EWsGcOpDrawBitmap2);

   951 	AddToBitmapArray(aDevice->Handle());

   952 	}

   953 

   954 EXPORT_C void CWindowGc::DrawBitmap(const TRect &aDestRect, const CFbsBitmap *aDevice, const TRect &aSourceRect)

   955 /** Draws a specified rectangle from a bitmap into another rectangle.

   956 

   957 The function compresses/stretches the specified rectangle from the bitmap 

   958 to fit the destination rectangle. Note that if the twips value of the bitmap 

   959 is not set then nothing is drawn (this is the default situation).

   960 

   961 Windows that store their redraw commands will only store drawing position and a handle to bitmaps 

   962 that are drawn in it. The bitmap handle is just a pointer to the bitmap in the FBSERV heap. 

   963 At some point later WSERV may need to draw that window again and it will just replay the 

   964 stored commands including the draw bitmap. However, if the client has changed the content of the bitmap,

   965 WSERV will effectively draw a different bitmap when it replays the commands.

   966 

   967 Note: this member function uses rectangle sizes in pixels and does a stretch/compress 

   968 blit using a linear DDA.

   969 

   970 @param aDestRect The rectangle within which the bitmap is to be drawn. 

   971 @param aDevice A source bitmap. 

   972 @param aSourceRect The rectangle in the source bitmap that is copied to the 

   973 destination rectangle. 

   974 @see CGraphicsContext::DrawBitmap() */

   975 	{

   976 	TWsGcCmdDrawBitmap3 drawBitmap(aDestRect,aDevice->Handle(),aSourceRect);

   977 	Write(&drawBitmap,sizeof(drawBitmap),EWsGcOpDrawBitmap3);

   978 	AddToBitmapArray(aDevice->Handle());

   979 	}

   980 

   981 /** Draws a specified rectangle from a bitmap and its mask into another rectangle.

   982 

   983 The function compresses/stretches the specified rectangle from the bitmap 

   984 to fit the destination rectangle. 

   985 The mask bitmap can be used as either a positive or negative mask. Masked 

   986 pixels are not mapped to the destination rectangle.

   987 

   988 A black and white (binary) mask bitmap is used. With aInvertMask=EFalse, black 

   989 pixels in the mask bitmap stop corresponding pixels in the source bitmap from 

   990 being transferred to the destination rectangle. With aInvertMask=ETrue, white 

   991 pixels in the mask bitmap stop corresponding pixels in the source bitmap from 

   992 being transferred to the destination rectangle.

   993 

   994 If mask bitmap's display mode is EColor256, the function does AplhaBlending

   995 and ignores aInvertMask parameter.

   996 

   997 Windows that store their redraw commands will only store drawing position and a handle to bitmaps 

   998 that are drawn in it. The bitmap handle is just a pointer to the bitmap in the FBSERV heap. 

   999 At some point later WSERV may need to draw that window again and it will just replay the 

  1000 stored commands including the draw bitmap.  However, if the client has changed the content of the bitmap,

  1001 WSERV will effectively draw a different bitmap when it replays the commands.

  1002 

  1003 Note: this member function uses rectangle sizes in pixels and does a stretch/compress 

  1004 blit using a linear DDA.

  1005 

  1006 @param aDestRect The rectangle within which the masked bitmap is to be drawn. 

  1007 @param aBitmap A source bitmap. 

  1008 @param aSourceRect The rectangle in the source bitmap that is copied to the 

  1009 destination rectangle.

  1010 @param aMaskBitmap A mask bitmap. 

  1011 @param aInvertMask If false, a source pixel that is masked by a black pixel 

  1012 is not transferred to the destination rectangle. If true, then a source pixel 

  1013 that is masked by a white pixel is not transferred to the destination rectangle. */

  1014 EXPORT_C void CWindowGc::DrawBitmapMasked(const TRect& aDestRect, const CFbsBitmap* aBitmap, const TRect& aSourceRect, const CFbsBitmap* aMaskBitmap, TBool aInvertMask)

  1015 	{

  1016 	TWsGcCmdDrawBitmapMasked drawBitmap(aDestRect,aBitmap->Handle(),aSourceRect,aMaskBitmap->Handle(),aInvertMask);

  1017 	Write(&drawBitmap,sizeof(drawBitmap),EWsGcOpDrawBitmapMasked);

  1018 	AddToBitmapArray(aBitmap->Handle());

  1019 	AddToBitmapArray(aMaskBitmap->Handle());

  1020 	}

  1021 

  1022 EXPORT_C void CWindowGc::DrawBitmapMasked(const TRect& aDestRect, const CWsBitmap* aBitmap, const TRect& aSourceRect, const CWsBitmap* aMaskBitmap, TBool aInvertMask)

  1023 /** Draws a specified rectangle from a wserv bitmap and its mask into 

  1024 another rectangle.

  1025 

  1026 The function compresses/stretches the specified rectangle from the bitmap 

  1027 to fit the destination rectangle. 

  1028 The mask bitmap can be used as either a positive or negative mask. Masked 

  1029 pixels are not mapped to the destination rectangle.

  1030 

  1031 A black and white (binary) mask bitmap is used. With aInvertMask=EFalse, black 

  1032 pixels in the mask bitmap stop corresponding pixels in the source bitmap from 

  1033 being transferred to the destination rectangle. With aInvertMask=ETrue, white 

  1034 pixels in the mask bitmap stop corresponding pixels in the source bitmap from 

  1035 being transferred to the destination rectangle.

  1036 

  1037 If mask bitmap's display mode is EColor256, the function does AplhaBlending

  1038 and ignores aInvertMask parameter.

  1039 

  1040 Windows that store their redraw commands will only store drawing position and a handle to bitmaps 

  1041 that are drawn in it. The bitmap handle is just a pointer to the bitmap in the FBSERV heap. 

  1042 At some point later WSERV may need to draw that window again and it will just replay the 

  1043 stored commands including the draw bitmap.  However, if the client has changed the content of the bitmap,

  1044 WSERV will effectively draw a different bitmap when it replays the commands.

  1045 

  1046 Note: this member function uses rectangle sizes in pixels and does a stretch/compress 

  1047 blit using a linear DDA.

  1048 

  1049 @param aDestRect The rectangle within which the masked bitmap is to be drawn. 

  1050 @param aBitmap A source wserv bitmap. 

  1051 @param aSourceRect The rectangle in the source bitmap that is copied to the 

  1052 destination rectangle.

  1053 @param aMaskBitmap A mask wserv bitmap. 

  1054 @param aInvertMask If false, a source pixel that is masked by a black pixel 

  1055 is not transferred to the destination rectangle. If true, then a source pixel 

  1056 that is masked by a white pixel is not transferred to the destination rectangle. */

  1057 	{

  1058 	TWsGcCmdDrawBitmapMasked drawBitmap(aDestRect,aBitmap->WsHandle(),aSourceRect,aMaskBitmap->WsHandle(),aInvertMask);

  1059 	Write(&drawBitmap,sizeof(drawBitmap),EWsGcOpWsDrawBitmapMasked);

  1060 	AddToBitmapArray(aBitmap->Handle());

  1061 	AddToBitmapArray(aMaskBitmap->Handle());

  1062 	}

  1063 EXPORT_C void CWindowGc::DrawText(const TDesC &aBuf, const TPoint &aPos)

  1064 /** Draws horizontal text with no surrounding box. 

  1065 

  1066 The appearance of the text is subject to the drawing mode, the font, pen colour, 

  1067 word justification and character justification. 

  1068 

  1069 A panic occurs if this function is called when there is no font: see UseFont().

  1070 

  1071 @param aBuf The string to write. 

  1072 @param aPos The point specifying the position of the baseline at the left 

  1073 end of the text.

  1074 @see CGraphicsContext::DrawText() */

  1075 	{

  1076 	TWsGcCmdDrawText printText(aPos,aBuf.Length());

  1077 	WriteTextCommand(&printText,sizeof(printText),aBuf,EWsGcOpDrawText,EWsGcOpDrawTextPtr);

  1078 	}

  1079 

  1080 EXPORT_C void CWindowGc::DrawText(const TDesC &aBuf,const TRect &aBox,TInt aBaselineOffset,TTextAlign aHoriz,TInt aLeftMrg)

  1081 /** Draws horizontal text within a cleared box.

  1082 

  1083 The appearance of the text is subject to the drawing mode, the font, pen colour, 

  1084 word justification and character justification. It is also subject to the 

  1085 background brush (set brush to ENullBrush for no effect on background).

  1086 

  1087 A panic occurs if this function is called when there is no font: see UseFont().

  1088 

  1089 Note: the text is clipped to the box. You must ensure that the specified string 

  1090 is not too large.

  1091 

  1092 @param aBuf The text to write.

  1093 @param aBox The box to draw the text in. 

  1094 @param aBaselineOffset An offset from the top of the box to the text baseline. 

  1095 Note that the baseline is the line on which letters sit, for instance below r, s, t, and 

  1096 above the tail of q, and y. 

  1097 @param aHoriz The text alignment mode (default is left, rather than centre 

  1098 or right). 

  1099 @param aLeftMrg The left margin for left-aligned text, or the right margin 

  1100 for right-aligned text (default is zero). 

  1101 @see CGraphicsContext::DrawText() */

  1102 	{

  1103 	if (aBuf.Size()<(TInt)(iBuffer->BufferSize()-sizeof(TWsCmdHeader)-sizeof(TWsGcCmdBoxTextOptimised2))) 

  1104 		{

  1105 		if (aHoriz==ELeft && aLeftMrg==0)

  1106 			{

  1107 			TWsGcCmdBoxTextOptimised1 boxTextOpt1(aBox,aBaselineOffset,aBuf.Length());

  1108 			Write(&boxTextOpt1,sizeof(boxTextOpt1),aBuf.Ptr(),aBuf.Size(),EWsGcOpDrawBoxTextOptimised1);

  1109 			}

  1110 		else

  1111 			{

  1112 			TWsGcCmdBoxTextOptimised2 boxTextOpt2(aBox,aBaselineOffset,aHoriz,aLeftMrg,aBuf.Length());

  1113 			Write(&boxTextOpt2,sizeof(boxTextOpt2),aBuf.Ptr(),aBuf.Size(),EWsGcOpDrawBoxTextOptimised2);

  1114 			}

  1115 		}

  1116 	else

  1117 		{

  1118 		TWsGcCmdBoxText boxText(aBox,aBaselineOffset,aHoriz,aLeftMrg,aBuf.Length(),iPimpl->iFont->TextWidthInPixels(aBuf));

  1119 		WriteTextCommand(&boxText,sizeof(boxText),aBuf,EWsGcOpDrawBoxText,EWsGcOpDrawBoxTextPtr);

  1120 		}

  1121 	}

  1122 

  1123 EXPORT_C void CWindowGc::DrawTextVertical(const TDesC& aText,const TPoint& aPos,TBool aUp)

  1124 /** Draws vertical text in the specified direction.

  1125 

  1126 A panic occurs if this function is called when there is no font: see UseFont().

  1127 

  1128 @param aText The text to be drawn. 

  1129 @param aPos Point of origin of the text baseline. 

  1130 @param aUp Direction. ETrue for up, EFalse for down. */

  1131 	{

  1132 	TWsGcCmdDrawTextVertical printText(aPos,aText.Length(),aUp);

  1133 	WriteTextCommand(&printText,sizeof(printText),aText,EWsGcOpDrawTextVertical,EWsGcOpDrawTextVerticalPtr);

  1134 	}

  1135