OSRenderRegion Class Reference

Encapsulates rendering using the OS. (GDI, RiscOS, etc). This object is created when something needs rendering using the OS calls instead of Gavins routines. This will be ALL THE TIME for the moment. See RenderRegion notes for more general details of this class. More...

#include <osrndrgn.h>

Inheritance diagram for OSRenderRegion:

List of all members.

Public Member Functions
	~OSRenderRegion ()
	Default Destructor for OSRenderRegion Class.
	OSRenderRegion (const OSRenderRegion &other)
	Copy Constructor for OSRenderRegion. Constructs an OSRenderRegion that is a copy of another. Calls RenderRegion copy constructor to make a copy of the current ContextStack.
virtual BOOL	AttachDevice (View *, wxDC *, Spread *SpreadToAttach=NULL, bool fOwned=false)
	Attach an OSRenderRegion to a particular device context. This merely remembers the information - the real work is done by [OS]RenderRegion::InitDevice().
virtual BOOL	InitDevice ()
	Initialise the device specific mechanisms for this render region.
BOOL	StartRender ()
	Initialises an OSRenderRegion for rendering.
BOOL	StopRender ()
	Stops the rendering of a OSRenderRegion, saving it's current renderstate so that rendering can continue where it left off, later on. If the RenderState passed is NULL then the RenderRegion will be unlinked from the list and will then delete itself.
virtual void	SetSolidColours (BOOL SetSolid)
	Allows the dithering of colours to be turned off so they look the same using GDraw as they do with the GDI. In OSRenderRegions, this causes any attached GBrush technology to drop into/out of solid colour mode.
void	DrawPathToOutputDevice (Path *PathToDraw, PathShape shapePath=PATHSHAPE_PATH)
	Renders a path object to the GDI.
void	DrawRect (DocRect *PathToDraw)
	Renders a rectangle using Ploygon instead of Rectangle. Used for BodgeRectangles devices whi cannot render rectangles correctly. Should really only be used when no fill brush has been set as solid ones with XORing on don't render correctly.Renders a Rectangle to the GDI.
void	DrawDragRect (DocRect *PathToDraw)
	Renders a Rectangle to the GDI . Used to claim "without shifting it about" bit it does adjust it now for the differences in rendering models.
virtual void	DrawDragBounds (DocRect *RectToRender)
	Used to draw a "rectangle" to screen (for dragging). However, the corners of the rectangle are passed through the current rendering matrix, so the rect may well be rotated or skewed by the time it reaches the screen.
virtual void	DrawDashLine (const DocCoord &StartPoint, const DocCoord &EndPoint)
	Draws a dashed line between the two points. Uses the technology from DrawDragBounds().
void	DrawLine (const DocCoord &StartPoint, const DocCoord &EndPoint)
	Renders a Line to the GDI.
void	DrawPixel (const DocCoord &Point)
	Plot a single pixel in a render region.
void	DrawCross (const DocCoord &Point, const UINT32 Size)
	Draws a cross in the render region. The cross consists of a vertical line 'Size' millipoints high, and a horizontal line 'Size' millipoints wide.
void	DrawBlob (DocCoord p, BlobType type)
	Draw a blob. This is the type of blob that appear round objects to show that they have been selected.
void	DrawBitmap (const DocCoord &Point, KernelBitmap *pBitmap)
	Draws an un-scaled Bitmap. Use this for drawing Icons for dialogue boxes etc. The Bitmap can be any size, but will be plotted unscaled. Note that 'Point' specifies where the bottom left of the bitmap will be.
void	DrawBitmap (const DocCoord &Point, UINT32 BitmapID, UINT32 ToolID=NULL)
	Draws an un-scaled Bitmap. Use this for drawing Icons for dialogue boxes etc. The Bitmap can be any size, but will be plotted unscaled. Note that 'Point' specifies where the bottom left of the bitmap will be.
BOOL	DrawTransformedBitmap (NodeBitmap *pNodeBitmap)
void	DrawBitmapBlob (const DocCoord &Point, KernelBitmap *BlobShape)
	Draws a Bitmap Blob. It is used for drawing more complex blob shapes, like 'rotation' arrows etc. The Bitmap can be any size, but must be Monochrome. Black pixels are transparent. White pixels will EOR. Note that 'Point' currently specifies where the centre of the bitmap will be.
void	DrawBitmapBlob (const DocCoord &Point, ResourceID resID)
virtual SlowJobResult	DrawMaskedBitmap (const DocRect &Rect, KernelBitmap *pBitmap, MaskedRenderRegion *pMask, ProgressDisplay *Progress)
	Plots the bitmap using the mask supplied.
void	DrawFixedSystemText (StringBase *TheText, DocRect &BoundsRect, UINT32 uFormat=DEFAULT_TEXT_FORMATTING)
	To draw simple text, using the default host-operating-system font. The size and style of this font are decided by the host OS (or oil code) and cannot be set in any way. To determine how much space is needed to display a string with this method, see the SeeAlso.
void	SetFixedSystemTextColours (DocColour *TextCol, DocColour *Background)
	To set the text and background colour(s) for any FixedSystem text rendered in this render region in the future (within the current rendering pass).
void	GetFixedSystemTextSize (StringBase *TheText, DocRect *BoundsRect, double *atDpi=NULL)
	To determine how much room is needed to plot a bit of text with OSRenderRegion::DrawFixedSystemText.
BOOL	RenderGradFillPath (Path *, GradFillAttribute *)
	Render grad fills to GDI devices using whatever means available. Scope: Public.
BOOL	RenderBitmapFill (Path *, BitmapFillAttribute *)
	Render bitmap fills clipped through a path. BODGED to simple plot the bitmap. Scope: Public.
virtual BOOL	RenderChar (WCHAR ch, Matrix *pMatrix)
	Render a character, using the specified transform and current attributes in the render region.
BOOL	StrokeProperly (Path *const )
virtual void	GetRenderRegionCaps (RRCaps *pCaps)
	This function is used to help determine what an individual render region is capable of. A render can mark the things it can not render (eg transparancy) so that a more complex rendering of these parts of the document can be done.
Static Public Member Functions
static RenderRegion *	Create (DocRect ClipRegion, Matrix ConvertMatrix, FIXED16 ViewScale, RenderType rType, View *pView=NULL, BOOL UseOSRendering=FALSE, BOOL bForce32BPP=FALSE)
	Creates an RenderRegion, allowing a invalid rectangle to be specified. The matrix passed is used to convert Document coords into device coords, taking into account scaling, scroll offsets etc. This function should be used to create all RenderRegions - it chooses the best RenderRegion subclass to use depending on the host environment. (e.g. on NT it chooses an OSRenderRegion that can use Win32 GDI calls).
static BOOL	Init ()
	To be called during startup. Reads preferences. Scope: Static.
static void	FlushEORCache (void)
	Flushes the EOR colour cache. Currently called when screen mode changes Scope: Public.
static wxSize	GetFixedDCPPI (wxDC &dc)
	Fix up crazy wxWindows screen DPI calculation.
static void	GetBlobRect (FIXED16, const DocCoord &BlobPoint, BlobType bType, DocRect *pResult)
	To determine the DocRect of a blob without access to a render region.
static WinRect	DocRectToWin (View *pView, const Matrix &RenderMatrix, const DocRect &docrect, INT32 leftshift, INT32 topshift, INT32 rightshift, INT32 bottomshift, BOOL MightClip=FALSE)
	To convert a rectangle in Doc coordinates to a rectangle in Win coordinates. Scope: Static.
static WinRect	DocRectToWin (const Matrix &RenderMatrix, const DocRect &docrect, const double dpi)
	To convert a rectangle in Doc coordinates to a rectangle in Win coordinates taking account of the destination dpi rather than assuming screen dpi as the above form does. Does not need the extra parameters that the above uses. INT32 dpi changed to double dpi (12/12/95) to improve the range of values allowed at the < 1000dpi settings that we will be using. Scope: Static.
static WinRect	BitmapDocRectToWin (Matrix &RenderMatrix, const DocRect &docrect, const double dpi)
	To convert a rectangle in Doc coordinates to a rectangle in Win coordinates taking account of the destination dpi rather than assuming screen dpi as the above form does. Same as above but tries to create the rectangle better to try and help pixel problems. Scope: Static.
static BOOL	CalculateGavinOffsetsWinRect (const Matrix &RenderMatrix, const DocRect &DRect, const double dpi, GMATRIX *GMat, BOOL bCentralise, double *pdXCentralAdjust, double *pdYCentralAdjust)
	To add in the offsets to the Gavin matrix. This is used when exporting bitmaps. There used to a lot of pixel alignements problems whereby on a rectangle with line colour of say 0.5pt width, you would seemingly randomly loose one or more of the lines on the exported bitmap. This is an attempt to fix this for the bitmap export case only, as other render regions have their own problems and perculiarities.
static DocRect	WinRectToDoc (const Matrix &RenderMatrix, const WinRect &WRect, const double dpi)
	To convert a rectangle in Windows coordinates to a rectangle in Document (spread) coordinates taking account of the destination dpi. Does not need the extra parameters that the above uses. Scope: Static.
static MILLIPOINT	GetHitTestRadius (DocView *pDocView)
	Allows user to adjust the sensitivity of hit-testing.
Static Public Attributes
static BOOL	DoBetterLines
Protected Member Functions
virtual SlowJobResult	DrawSeparatedMaskedBitmap (const DocRect &Rect, KernelBitmap *pBitmap, MaskedRenderRegion *pMask, ProgressDisplay *Progress)
	Plots the bitmap using the mask supplied. The bitmap is colour separated according to the current ColourPlate settings, and output (a scanline at a time) in an 8bpp greyscale format.
	OSRenderRegion (DocRect ClipRegion, Matrix ConvertMatrix, FIXED16 ViewScale=1)
	Constructor for OSRenderRegion, allowing a invalid rectangle to be specified. The matrix passed is used to convert Document coords into device coords, taking into account scaling, scroll offsets etc. All RFlags values default to FALSE. The creator should set them.
void	InitClipping ()
	Creates a Windows CRgn object from the DocRect passed in the constructor. The CRgn is set as the current clipping region during reendering. Scope: Private.
void	DeInitClipping ()
	Destroys the GDI clipping region object, and unsets the clipping region for our DC.
void	InitAttributes ()
	Sets up a default GDI pen and brush for rendering, and calculates the Brush origin for aligned fill patterns. Scope: Private.
void	DeInitAttributes ()
	Deletes the GDI pen and brush objects.
void	SetLineAttributes (ChangeLineAttrType Type=CHANGELINEATTR_ALL)
	When a line attribute is changed, this functions is called to create a new pen to mirror the new attribute value. Scope: Private.
void	SetFillAttributes (ChangeAttrType Type=CHANGEATTR_ALL)
	When a fill attribute is changed, this functions is called to create a new brush to mirror the new attribute value. Scope: Private.
void	SetOSDrawingMode ()
	Sets the current drawing mode. Scope: Private.
void	SetQualityLevel ()
	Called when Quality level changes. We do nothing currently.
Coord	DocCoordToOS256 (const DocCoord &DocPoint)
	Converts a DocCoord to a OS256 Coord. Used during rendering.
WinCoord	DocCoordToWin (const DocCoord &DocPoint)
	Converts a DocCoord to a WinCoord. Used during rendering.
WinRect	DocRectToWin (const DocRect &docrect, INT32 leftshift, INT32 topshift, INT32 rightshift, INT32 bottomshift, BOOL MightClip=FALSE)
BOOL	RenderRadialFill (Path *PathToDraw, RadialFillAttribute *Fill)
	Renders the path with a gradient fill.
BOOL	RenderLinearFill (Path *PathToDraw, LinearFillAttribute *Fill)
	Renders the path with a gradient fill.
BOOL	RenderConicalFill (Path *PathToDraw, ConicalFillAttribute *Fill)
	Renders the path with a gradient fill.
BOOL	RenderSquareFill (Path *PathToDraw, SquareFillAttribute *Fill)
	Renders the path with a gradient fill.
BOOL	RenderThreeColFill (Path *PathToDraw, ThreeColFillAttribute *Fill)
	Renders a three colour gradient fill to a Windows DC.
BOOL	RenderFourColFill (Path *PathToDraw, FourColFillAttribute *Fill)
	Renders a four colour gradient fill to a Windows DC. This is done by breaking the fill up into a large number of tiles, and then applying these with the colour at that point of the fill. This is in common with the other fills, and much of the code in this function has been derived from the other fill rendering functions.
void	CreateNewPen ()
	Creates a new Pen, based on the current line attributes. Scope: Private.
void	SelectNewPen ()
void	CreateNewBrush ()
	Creates a new Brush, based on the current fill attributes. Scope: Private.
void	SelectNewBrush ()
	Selects RenderBrush while setting its new origin. A common operation that is in its own function to cope with things such as metafiles which cannot do this. Scope: Private.
BOOL	SelectNewFont (WORD Typeface, BOOL Bold, BOOL Italic, MILLIPOINT Width, MILLIPOINT Height, ANGLE Rotation)
	Selects the specified font into the DC. Performs clever stuff to cache the font so that subsequent requests for the same font don't cause anything to happen.
void	MakeDashType (DashRec &, DashType *)
void	RenderPath32 (Path *DrawPath)
	Renders a path using Win32 GDI. Causes an ENSURE on Win16 as should never be called. Scope: Private.
void	RenderPath (Path *DrawPath)
	Renders a path to the GDI. Can recurse in the case of arrow heads. Scope: Private.
BOOL	RawRenderPath32 (Path *const )
BOOL	RawRenderPath (DocCoord *const, PathVerb *const, INT32 NumCoords, INT32 *PolyCount, INT32 *Count, INT32 Flatness=0, INT32 *pActualFlatness=NULL)
	Low level primitive for rendering paths without GDI32. Note that PointArray should be freed by the caller upon completion.
BOOL	SetClipToPathTemporary (Path *const)
	To set a complex clip path. This clip is pretty temporary and should be reset afterwards using OSClipRegion before anything much else is done.
BOOL	Bezier (INT32 Px0, INT32 Py0, INT32 Px1, INT32 Py1, INT32 Px2, INT32 Py2, INT32 Px3, INT32 Py3, INT32 Flatness)
	Flattens bezier path into an array of POINTS (for polyline). Scope: Private.
BOOL	Split (INT32 Px0, INT32 Py0, INT32 Px1, INT32 Py1, INT32 Px2, INT32 Py2, INT32 Px3, INT32 Py3, INT32 Flatness)
	Splits a bezier curve into two halves, and flattens each half. Scope: Private.
INT32	CalcPathFlattening ()
	Adjust the bezier curve flattening according to the resolution of the destination device and the view scale. Scope: Private.
INT32	MPtoLP (MILLIPOINT MPtoConvert)
	Converts a value in MilliPoints into a GDI Logical value. IT ASSUMES A MM_TEXT MAPPING MODE AT PRESENT. Scope: Private.
wxColour	CalcEORColour (DocColour &Wanted, COLORREF=RGB(255, 255, 255))
	To calculate correct colours when draing in EOR mode. Intended to be called by OSRenderRegion code only (normally SetxxxColur).
void	CalcLogBrush (wxBrush *, DocColour &)
	To calculate a brush object given a Colour. Normally used for brushes to fill things.
wxPoint	FindBitmapOrigin (DocCoord Centre, INT32 Width, INT32 Height)
	Finds the windows origin to plot a bitmap at, so that it's centre will be at the DocCoord specified.
MILLIPOINT	CalcScaledPixelWidth ()
	Calculates the size of a Pixel in MILLIPOINTS, based on the output DPI and current scale factor.
MILLIPOINT	CalcPixelWidth ()
	Calculates the size of a Pixel in MILLIPOINTS, based on the output DPI but IGNORES the scale factor.
void	GetValidPen ()
void	GetValidBrush ()
Static Protected Member Functions
static MILLIPOINT	CalcDistance (DocCoord a, DocCoord b)
static void	MakeEllipticalPath (Path *pPath, DocCoord Parallel[4])
Protected Attributes
struct {
BOOL   Metafile: 1
BOOL   ValidPen: 1
BOOL   ValidBrush: 1
BOOL   UsePalette: 1
}	RFlags
wxRegion *	OSClipRegion
wxPalette *	OldPalette
GBrush	GDrawBrush
INT32	InsertPos
FIXED16	PixelScale
INT32	nFillStyle
INT32	CurrentPen
INT32	CurrentBrush
wxPen	RenderPen [2]
wxBrush	RenderBrush [2]
wxFont *	OldFont
OSRRFontInfo	FontInfo
wxPoint	NewBrushOrg
RRCaps	Caps
BYTE *	SepTables
Static Protected Attributes
static INT32	HitTestRadius = 3
	Allows the user to determine how close a mouse click can be to an object before the object is hit-tested successfully. Measured in pixels. Defaults to 3.
static wxPoint	PointArray [8192]
static EORCacheClass	EORCache

---

Detailed Description

Encapsulates rendering using the OS. (GDI, RiscOS, etc). This object is created when something needs rendering using the OS calls instead of Gavins routines. This will be ALL THE TIME for the moment. See RenderRegion notes for more general details of this class.

Author:

Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>

Date:

11/5/93

Definition at line 177 of file osrndrgn.h.

---

Constructor & Destructor Documentation

OSRenderRegion::~OSRenderRegion (   )

Default Destructor for OSRenderRegion Class. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 15/5/93 Definition at line 590 of file osrndrgn.cpp. { if (RenderFlags.Rendering) { TRACE( _T("StopRender() was not called before destructor\n") ); StopRender(); } // A bug used to cause OSClipRegion to be left undeleted when a clipping rect was set // externally. This check is here just to make sure it doesn't creep back !! ENSURE(OSClipRegion == NULL, "Clip Region wasn't deleted"); if (SepTables != NULL) { CCFree(SepTables); SepTables = NULL; } }

OSRenderRegion::OSRenderRegion (  const OSRenderRegion &  other  )

Copy Constructor for OSRenderRegion. Constructs an OSRenderRegion that is a copy of another. Calls RenderRegion copy constructor to make a copy of the current ContextStack. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 15/7/93 Parameters: An  OSRenderRegion to copy [INPUTS] See also: RenderRegion(const RenderRegion &other) Definition at line 557 of file osrndrgn.cpp. : RenderRegion(other) { // We assume that the RenderRegion being copied is not curently rendering. CurrentPen = 0; CurrentBrush = 0; // OldBrush = NULL; // OldPen = NULL; OldFont = NULL; OSClipRegion = NULL; OldPalette = NULL; FontInfo.pRenderFont = NULL; FontInfo.pOldFont = NULL; RFlags = other.RFlags; // Set the render caps up GetRenderRegionCaps(&Caps); // Initialise the SepTables pointer SepTables = NULL; }

OSRenderRegion::OSRenderRegion (  DocRect  ClipRect, Matrix  ConvertMatrix, FIXED16  ViewScale = 1 )  [protected]

Constructor for OSRenderRegion, allowing a invalid rectangle to be specified. The matrix passed is used to convert Document coords into device coords, taking into account scaling, scroll offsets etc. All RFlags values default to FALSE. The creator should set them. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 11/5/93 Parameters: ClipRect  is a DocRect defining the invalid rectangle to be rendered. [INPUTS] ConvertMatrix is a Matrix for converting Doc coords to OS coords. ViewScale is the scale factor of the view, used to calculate how much to flatten paths etc. Definition at line 513 of file osrndrgn.cpp. : RenderRegion(ClipRect, ConvertMatrix, ViewScale) { CurrentPen = 0; CurrentBrush = 0; // OldBrush = NULL; // OldPen = NULL; OldFont = NULL; OSClipRegion = NULL; OldPalette = NULL; FontInfo.pRenderFont = NULL; FontInfo.pOldFont = NULL; RFlags.Metafile = FALSE; // RFlags.GDI32 = FALSE; RFlags.ValidPen = FALSE; RFlags.ValidBrush = FALSE; RFlags.UsePalette = FALSE; // We don't bother rendering paper for OSRenderRegions cos it's already been done by the // PaperRenderRegion IsPaperRendered = TRUE; // Set the render caps up GetRenderRegionCaps(&Caps); // Initialise the SepTables pointer SepTables = NULL; }

---

Member Function Documentation

BOOL OSRenderRegion::AttachDevice (  View *  ViewToAttach, wxDC *  DCToAttach, Spread *  SpreadToAttach = NULL, bool  fOwned = false )  [virtual]

Attach an OSRenderRegion to a particular device context. This merely remembers the information - the real work is done by [OS]RenderRegion::InitDevice(). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 27/05/94 Parameters: A  View ptr ,CDC ptr and Spread ptr to attach to the RenderRegion [INPUTS] Returns: TRUE if the device is attached successfully; FALSE if not. Errors: Same as base class. See also: OSRenderRegion::InitDevice; RenderRegion::InitDevice Reimplemented from RenderRegion. Definition at line 628 of file osrndrgn.cpp. { // Call the base class first if (!RenderRegion::AttachDevice( ViewToAttach, DCToAttach, SpreadToAttach, fOwned )) return FALSE; ENSURE(RenderDC != NULL,"Attempted to attach Invalid DC to RenderRegion"); // If it is a PrinterDC then set our flag to say we are Printing RenderFlags.Printing = CCDC::ConvertFromNativeDC(RenderDC)->IsPrinting(); // All ok return TRUE; }

BOOL OSRenderRegion::Bezier (  INT32  Px0, INT32  Py0, INT32  Px1, INT32  Py1, INT32  Px2, INT32  Py2, INT32  Px3, INT32  Py3, INT32  Flatness )  [protected]

Flattens bezier path into an array of POINTS (for polyline). Scope: Private. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 25/6/93 Parameters: Many  INT32s - These are the x and y coords of the 4 bezier control points [INPUTS] Flatness - the flatness of the curve Returns: TRUE if bezier was successfully flattened to specified flatness; FALSE if buffer overflow occurred Definition at line 3047 of file osrndrgn.cpp. { // We can't cope with negative flatness, so return if it is if (!(Flatness > 0)) return FALSE; INT32 diff; INT32 dx0 = (Px1*3 - Px0*2 - Px3); dx0 = dx0 < 0 ? -dx0 : dx0; INT32 dy0 = (Py1*3 - Py0*2 - Py3); dy0 = dy0 < 0 ? -dy0 : dy0; // Get the line's distance from the curve if (dx0 >= dy0) diff = 3*dx0 + dy0; else diff = dx0 + 3*dy0; // Is the straight line close enough to the curve ? if (diff > Flatness) { // Not close enough so split it into two and recurse for each half return Split(Px0,Py0, Px1,Py1, Px2,Py2, Px3,Py3, Flatness); } INT32 dx1 = (Px2*3 - Px0 - Px3*2); dx1 = dx1 < 0 ? -dx1 : dx1; INT32 dy1 = (Py2*3 - Py0 - Py3*2); dy1 = dy1 < 0 ? -dy1 : dy1; // Get the line's distance from the curve if (dx1 >= dy1) diff = 3*dx1 + dy1; else diff = dx1 + 3*dy1; // Is the straight line close enough to the curve ? if (diff > Flatness) { // Not close enough so split it into two and recurse for each half return Split(Px0,Py0, Px1,Py1, Px2,Py2, Px3,Py3, Flatness); } if (InsertPos >= SIZEOF_POLYLINE_BUFFER) return FALSE; // stop storing points // Line is now close enough so put it into our array PointArray[InsertPos].x = INT32((Px3+128)/256); PointArray[InsertPos].y = INT32((Py3+128)/256); InsertPos++; // Successfully flattened return TRUE; }

WinRect OSRenderRegion::BitmapDocRectToWin (  Matrix &  RenderMatrix, const DocRect &  DRect, const double  dpi )  [static]

To convert a rectangle in Doc coordinates to a rectangle in Win coordinates taking account of the destination dpi rather than assuming screen dpi as the above form does. Same as above but tries to create the rectangle better to try and help pixel problems. Scope: Static. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> and Gavin Date: 4/10/96 Parameters: DocRect  is a rectangle on document co-ords. [INPUTS] dpi is the resolution of the device we are rendering to Returns: Object containing the new rectangle coordinates. Definition at line 4081 of file osrndrgn.cpp. { // This is a version from Gavin, which should improve things OilRect OilRec; OilRec.lo.x = MatrixCalc( RenderMatrix.a, DRect.lo.x, RenderMatrix.c, DRect.lo.y ) + RenderMatrix.e; OilRec.lo.y = MatrixCalc( RenderMatrix.b, DRect.lo.x, RenderMatrix.d, DRect.lo.y ) + RenderMatrix.f; OilRec.hi.x = MatrixCalc( RenderMatrix.a, DRect.hi.x, RenderMatrix.c, DRect.hi.y ) + RenderMatrix.e; OilRec.hi.y = MatrixCalc( RenderMatrix.b, DRect.hi.x, RenderMatrix.d, DRect.hi.y ) + RenderMatrix.f; if (OilRec.lo.x > OilRec.hi.x) { MILLIPOINT Temp = OilRec.lo.x; OilRec.lo.x = OilRec.hi.x; OilRec.hi.x = Temp; } if (OilRec.lo.y > OilRec.hi.y) { MILLIPOINT Temp = OilRec.lo.y; OilRec.lo.y = OilRec.hi.y; OilRec.hi.y = Temp; } OilCoord OilSize(OilRec.hi.x-OilRec.lo.x, OilRec.hi.y-OilRec.lo.y); #if 0 // // Note that this relies on ToWin performing the calculation // +round(X*dpi/72000), -round(Y*dpi/72000) // WinCoord WinSize = OilSize.ToWin(dpi) ; // This negates the Y. #else // // The following performs the same calculation as ToWin. Doing it here ensures // that the subsequent calculation of NewOilSize will be compatible. // WinCoord WinSize( +(INT32)floor(OilSize.x*dpi/72000.0+0.5), -(INT32)floor(OilSize.y*dpi/72000.0+0.5) ) ; #endif // This should be the bitmap size. // // WinSize should now be the size of the export bitmap. // NewRenderMatrix.x and NewRenderMatrix.y should be the e and f // components of the new render matrix. // OilCoord OilLo = OilCoord(OilRec.lo.x,OilRec.lo.y); WinCoord WinLo = OilLo.ToWin(dpi); WinRect WinRectangle; WinRectangle.x = WinLo.x; WinRectangle.y = WinLo.y + WinSize.y; WinRectangle.width = WinLo.x + WinSize.x-WinRectangle.x; WinRectangle.height = WinLo.y-WinRectangle.y; return WinRectangle; }

MILLIPOINT OSRenderRegion::CalcDistance (  DocCoord  a, DocCoord  b )  [static, protected]

Definition at line 4758 of file osrndrgn.cpp. { const double Width = (double) a.x - b.x; const double Height = (double) a.y - b.y; double Diag = Width * Width + Height * Height; const INT32 Distance = (INT32) sqrt(Diag); return Distance; }

wxColour OSRenderRegion::CalcEORColour (  DocColour &  Wanted, COLORREF  Background = RGB(255,255,255) )  [protected]

To calculate correct colours when draing in EOR mode. Intended to be called by OSRenderRegion code only (normally SetxxxColur). Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 19/11/93 Parameters: Wanted  is the colour that is finally required. Background is the colour you [INPUTS] are assumed to be drawing onto. Returns: The RGB value such that value XOR Background = Wanted (approx). Errors: If cannot calculate for some reason, returns Background, which works if Wanted is black. Scope: Protected Definition at line 971 of file osrndrgn.cpp. { // This routine caches the last EOR colour it calculated so that we don't create // a bitmap every time we e.g. draw a selection blob. INT32 R,G,B; Wanted.GetRGBValue(&R,&G,&B); return wxColour( GetRValue(Background)^R, GetGValue(Background)^G, GetBValue(Background)^B ); /* if (EORCache.Valid && (EORCache.SourceColour == Wanted)) return(EORCache.EORColour); COLORREF Result; INT32 Red, Green, Blue; Wanted.GetRGBValue(&Red, &Green, &Blue); if (RFlags.UsePalette) { // a palette device has to be quite different - get palette indices and XOR // them together, then return that as a palette index const UINT32 BGIndex = PaletteManager::GetPalette()->GetNearestPaletteIndex( Background ); const UINT32 FGIndex = PaletteManager::GetPalette()->GetNearestPaletteIndex( RGB(Red,Green,Blue) ); Result = PALETTEINDEX( BGIndex ^ FGIndex ); } else { // non-palette devices we XOR into a little bitmap to work it out CBitmap Tiny, *OldBitmap; CDC MemDC; BOOL bStatus; bStatus = MemDC.CreateCompatibleDC( RenderDC ); ENSURE(bStatus, "cant create comp DC"); bStatus = Tiny.CreateCompatibleBitmap( RenderDC, 1, 1 ); // make a tiny bitmap // compatible with screen // so colours OK ENSURE(bStatus, "cant create Tiny bitmap"); OldBitmap = MemDC.SelectObject( &Tiny ); if (OldBitmap == NULL) { ENSURE(FALSE, "Cant select tiny bitmap"); return RGB(255,255,255); // return WHITE } MemDC.SetPixel( 0,0, Background ); MemDC.SetROP2( R2_XORPEN ); // into XOR mode MemDC.SetPixel( 0,0, RGB(Red, Green, Blue) ); Result = MemDC.GetPixel( 0,0 ); ENSURE( Result!=0xFFFFFFFF, "GetPixel failed"); //TRACE( _T("Converted %d.%d.%d to %d.%d.%d\n"), Wanted.Red, Wanted.Green, Wanted.Blue, // GetRValue(Result), GetGValue(Result), GetBValue(Result) ); MemDC.SelectObject( OldBitmap ); // restore normality // automatic destruction of HDC and Bitmaps will occur naturally } // Cache this result EORCache.SourceColour = Wanted; EORCache.EORColour = Result; EORCache.Valid = TRUE; return Result; */ }

void OSRenderRegion::CalcLogBrush (  wxBrush *  lpBrush, DocColour &  Col )  [protected]

To calculate a brush object given a Colour. Normally used for brushes to fill things. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 13/4/94 Parameters: lpBrush  will be filled with a LOGBRUSH. [INPUTS] Col is used to calculate said brush. Returns: - Errors: - Scope: Protected Definition at line 1088 of file osrndrgn.cpp. { if (Col.IsTransparent()) { lpBrush->SetColour(*wxBLACK); lpBrush->SetStyle(wxTRANSPARENT); } else { // VeryMono devices have everything that is not transparent as Black if (RenderFlags.VeryMono) // Unless the quality says don't fill!!! if (RRQuality.GetFillQuality() <= Quality::NoFill) { lpBrush->SetColour(*wxBLACK); lpBrush->SetStyle(wxTRANSPARENT); } else { lpBrush->SetStyle(wxSOLID); lpBrush->SetColour(*wxBLACK); } else if (DrawingMode != DM_EORPEN) { if (GDrawBrush.Available()) GDrawBrush.GetLogBrush( CurrentColContext, Col, lpBrush ); else { INT32 R,G,B; Col.GetRGBValue(&R, &G, &B); lpBrush->SetStyle(wxSOLID); lpBrush->SetColour(R, G, B); } } else { lpBrush->SetStyle(wxSOLID); lpBrush->SetColour(CalcEORColour(Col)); } } }

INT32 OSRenderRegion::CalcPathFlattening (   )  [protected]

Adjust the bezier curve flattening according to the resolution of the destination device and the view scale. Scope: Private. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/93 Returns: The max distance the lines can be away from the curve in MILLIPOINTS Definition at line 3181 of file osrndrgn.cpp. { MILLIPOINT PixelWidth = GetScaledPixelWidth(); // The width of a pixel in DocCoords INT32 Accuracy = PixelWidth/8; // Accurate to 1/8 of a pixel return max(Accuracy, INT32(10)); // Ensure the value is greater than 10 MILLPOINTS // to avoid stack overflows. }

MILLIPOINT OSRenderRegion::CalcPixelWidth (  void   )  [protected, virtual]

Calculates the size of a Pixel in MILLIPOINTS, based on the output DPI but IGNORES the scale factor. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 26/7/93 Returns: The size of a pixel in MILLIPOINTS See also: GetScaledPixelWidth() Implements RenderRegion. Definition at line 3248 of file osrndrgn.cpp. { PORTNOTE("other","Can't handle different DPIs, using X") return MILLIPOINT(double(72000) / double(OSRenderRegion::GetFixedDCPPI(*RenderDC).x)); // x }

MILLIPOINT OSRenderRegion::CalcScaledPixelWidth (  void   )  [protected, virtual]

Calculates the size of a Pixel in MILLIPOINTS, based on the output DPI and current scale factor. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 19/7/93 Returns: The size of a pixel in MILLIPOINTS See also: CalcPixelWidth() Implements RenderRegion. Definition at line 3223 of file osrndrgn.cpp. { // return (RenderView->GetPixelWidth() / ScaleFactor).MakeLong(); return (MILLIPOINT)( (RenderView->GetPixelWidth().MakeDouble() / ScaleFactor.MakeDouble()) + 0.5 ); /* return MILLIPOINT(double(72000) / (double(RenderDC->GetDeviceCaps(LOGPIXELSX)) * ScaleFactor.MakeDouble())); */ }

BOOL OSRenderRegion::CalculateGavinOffsetsWinRect (  const Matrix &  RenderMatrix, const DocRect &  DRect, const double  dpi, GMATRIX *  GMat, BOOL  bCentralise, double *  pdXCentralAdjust, double *  pdYCentralAdjust )  [static]

To add in the offsets to the Gavin matrix. This is used when exporting bitmaps. There used to a lot of pixel alignements problems whereby on a rectangle with line colour of say 0.5pt width, you would seemingly randomly loose one or more of the lines on the exported bitmap. This is an attempt to fix this for the bitmap export case only, as other render regions have their own problems and perculiarities. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> and Gavin Date: 4/10/96 Parameters: DocRect  is a rectangle on document co-ords. [INPUTS] dpi is the resolution of the device we are rendering to RenderMatrix is the rendering matrix An  updated version of the Gavin matrix [OUTPUTS] Returns: Object containing the new rectangle coordinates. See also: OSRenderRegion::DocRectToWin; Definition at line 4166 of file osrndrgn.cpp. { OilRect OilRec ; OilRec.lo.x = MatrixCalc( RenderMatrix.a, DRect.lo.x, RenderMatrix.c, DRect.lo.y ) + RenderMatrix.e ; OilRec.lo.y = MatrixCalc( RenderMatrix.b, DRect.lo.x, RenderMatrix.d, DRect.lo.y ) + RenderMatrix.f ; OilRec.hi.x = MatrixCalc( RenderMatrix.a, DRect.hi.x, RenderMatrix.c, DRect.hi.y ) + RenderMatrix.e ; OilRec.hi.y = MatrixCalc( RenderMatrix.b, DRect.hi.x, RenderMatrix.d, DRect.hi.y ) + RenderMatrix.f ; if (OilRec.lo.x > OilRec.hi.x) { MILLIPOINT Temp = OilRec.lo.x ; OilRec.lo.x = OilRec.hi.x ; OilRec.hi.x = Temp ; } if (OilRec.lo.y > OilRec.hi.y) { MILLIPOINT Temp = OilRec.lo.y ; OilRec.lo.y = OilRec.hi.y ; OilRec.hi.y = Temp ; } OilCoord OilSize( OilRec.hi.x-OilRec.lo.x, OilRec.hi.y-OilRec.lo.y ) ; /* double OilXOffset = (NewOilSize.x-OilSize.x)/2.0-OilRec.lo.x ; double OilYOffset = (NewOilSize.y-OilSize.y)/2.0-OilRec.lo.y ; double Scale = (dpi/72000.0)*(1<<16)*(1<<FX) ; double WinXOffset = OilXOffset*Scale ; double WinYOffset = OilYOffset*Scale ; */ double Scale = (dpi/72000.0)*(1<<16)*(1<<FX) ; double WinXOffset = -OilRec.lo.x * Scale; double WinYOffset = -OilRec.lo.y * Scale; if (bCentralise) { // // The following performs the same calculation as ToWin. Doing it here ensures // that the subsequent calculation of NewOilSize will be compatible. // WinCoord WinSize( +(INT32)floor(OilSize.x*dpi/72000.0+0.5), -(INT32)floor(OilSize.y*dpi/72000.0+0.5) ) ; OilCoord NewOilSize( +(INT32)floor(WinSize.x*72000.0/dpi+0.5), -(INT32)floor(WinSize.y*72000.0/dpi+0.5) ) ; if (pdXCentralAdjust) *pdXCentralAdjust = ((NewOilSize.x-OilSize.x)/2.0) * Scale; if (pdYCentralAdjust) *pdYCentralAdjust = ((NewOilSize.y-OilSize.y)/2.0) * Scale; } // Adjust offsets either by calculated value or supplied value if (pdXCentralAdjust) WinXOffset += *pdXCentralAdjust; if (pdYCentralAdjust) WinYOffset += *pdYCentralAdjust; // // The matrix is modified so that the drawing is centred within the export bitmap. // GMat->CX = MakeXLong(WinXOffset) ; GMat->CY = MakeXLong(WinYOffset) ; return TRUE; }

RenderRegion * OSRenderRegion::Create (  DocRect  ClipRect, Matrix  ConvertMatrix, FIXED16  ViewScale, RenderType  rType, View *  pView = NULL, BOOL  UseOSRendering = FALSE, BOOL  bForce32BPP = FALSE )  [static]

Creates an RenderRegion, allowing a invalid rectangle to be specified. The matrix passed is used to convert Document coords into device coords, taking into account scaling, scroll offsets etc. This function should be used to create all RenderRegions - it chooses the best RenderRegion subclass to use depending on the host environment. (e.g. on NT it chooses an OSRenderRegion that can use Win32 GDI calls). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 16/9/93 Parameters: ClipRect  - a DocRect defining the invalid rectangle to be rendered. [INPUTS] ConvertMatrix - a Matrix for converting Doc coords to OS coords. ViewScale - the scale factor of the view, used to calculate how much to flatten paths etc. rType - helps the choice of 32-bit rendering etc. pView - The View (if any) for which the RenderRegion is to be used UseOSRendering - TRUE to force the system to give you an OSRenderRegion, rather than diverting this call to really give you a GRenderRegion if GDraw is enabled (used by kernel-rendered dialogues which don't want transparency/grad fills, etc, and wish to render simple FixedSystem text) Definition at line 349 of file osrndrgn.cpp. { // const bool bCanDo32 = true; /* GAT BOOL bCanDo32 = FALSE; #if WIN32 if ( IsWin32NT() || IsWin32c() ) { // Running on 32-bit GDI - use special NT-only Win32 GDI functions for those devices that // make sense. Currently only 16-bit Metafiles are not done using 32-bit GDI // so that paths are manually flattened. if (rType != RENDERTYPE_METAFILE16) bCanDo32 = TRUE; } #endif */ OSRenderRegion *pOS = NULL; if (rType == RENDERTYPE_MONOBITMAP || rType == RENDERTYPE_COLOURBITMAP || rType == RENDERTYPE_HITDETECT) { RenderRegion *pRender = OSRenderBitmap::Create(ClipRect, ConvertMatrix, ViewScale, rType); if (pRender) { // if its not a OSRenderRegion, then return it directly, otherwise fall through // to set the flags on it if (!pRender->IsKindOf( CC_RUNTIME_CLASS(OSRenderRegion) )) return pRender; pOS = (OSRenderRegion*) pRender; } } else if (rType == RENDERTYPE_SCREENPAPER) { // Special render region for paper rendering. // TRACE(_T("Creating SCREENPAPER region (%d, %d) - (%d, %d)\n"), ClipRect.lo.x, ClipRect.lo.y, ClipRect.hi.x, ClipRect.hi.y); pOS = new PaperRenderRegion(ClipRect, ConvertMatrix, ViewScale); } else if ((rType == RENDERTYPE_PRINTER) || (rType == RENDERTYPE_PRINTER_PS)) { #ifndef STANDALONE // Work out what kind of printer region to get - find document's print control info. Document *pDoc = pView->GetDoc(); ERROR3IF(pDoc == NULL, "No document attached to view when printing!"); if (pDoc != NULL) { // Get print information for this document. PrintComponent *pPrint = (PrintComponent *) pDoc->GetDocComponent(CC_RUNTIME_CLASS(PrintComponent)); ERROR2IF(pPrint == NULL, NULL, "Unable to find PrintComponent in document."); PrintControl *pPrintControl = pPrint->GetPrintControl(); ERROR2IF(pPrintControl == NULL, NULL, "Unable to find PrintControl object in document component."); PrintMethodType PrintType = pPrintControl->GetPrintMethod(); // Work out whether or not to use straight Gavin bitmap for printing if ((PrintType == PRINTMETHOD_AABITMAP) || (PrintType == PRINTMETHOD_BITMAP)) { // GDraw - use GRenderPrint region. return GRenderRegion::Create(ClipRect, ConvertMatrix, ViewScale, rType, pView); } } // Is this a PostScript printer? if (rType == RENDERTYPE_PRINTER_PS) { // Yes - make a PostScript render region return new PrintPSRenderRegion(ClipRect, ConvertMatrix, ViewScale); } #endif // If we get here, then we should use normal OS rendering. // TRACE(_T("Creating PRINTER region (%d, %d) - (%d, %d) OSRenderRegion\n"), ClipRect.lo.x, ClipRect.lo.y, ClipRect.hi.x, ClipRect.hi.y); return new OSRenderRegion(ClipRect, ConvertMatrix, ViewScale); } else { // Always try for a GRenderRegion first - unless the caller specifically asked for // the OSRenderRegion, the whole OSRenderRegion, and nothing but the OSRenderRegion. // (But by default, we'll give 'em a GRenderRegion if we can) if ((!UseOSRendering) && (rType != RENDERTYPE_PRINTER)) { RenderRegion *pRender; pRender = GRenderRegion::Create(ClipRect, ConvertMatrix, ViewScale, rType, pView, bForce32BPP); if (pRender) return pRender; } // if failed, use normal ones // TRACE(_T("Creating OTHER region (%d, %d) - (%d, %d) OSRenderRegion\n"), ClipRect.lo.x, ClipRect.lo.y, ClipRect.hi.x, ClipRect.hi.y); pOS = new OSRenderRegion(ClipRect, ConvertMatrix, ViewScale); } if (!pOS) return NULL; // if call failed // created a new one OK - must set RFlags suitably if ( (rType == RENDERTYPE_METAFILE16) || (rType == RENDERTYPE_METAFILE32) ) pOS -> RFlags.Metafile = TRUE; // mark metafiles correctly // (this fn is a friend so can get to it) if (rType == RENDERTYPE_MONOBITMAP) { pOS -> RenderFlags.VeryMono = TRUE; } if (rType == RENDERTYPE_HITDETECT) { pOS -> RenderFlags.VeryMono = FALSE; pOS -> RenderFlags.HitDetect = TRUE; pOS -> m_DoCompression = TRUE; } if (rType == RENDERTYPE_COLOURBITMAP) { pOS -> RenderFlags.VeryMono = FALSE; pOS -> m_DoCompression = TRUE; } if ( (rType == RENDERTYPE_SCREEN) || (rType == RENDERTYPE_SCREENPAPER) || (rType == RENDERTYPE_SCREENXOR) ) { // if going to the screen, might have a palette selected if (WantGDIPalette && PaletteManager::UsePalette()) pOS->RFlags.UsePalette = TRUE; } // pOS->RFlags.GDI32 = bCanDo32; return pOS; }

void OSRenderRegion::CreateNewBrush (   )  [protected]

Creates a new Brush, based on the current fill attributes. Scope: Private. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/93 Definition at line 1272 of file osrndrgn.cpp. { if (RRQuality.GetFillQuality() <= Quality::NoFill ) { RenderBrush[CurrentBrush].SetColour(*wxBLACK); RenderBrush[CurrentBrush].SetStyle(wxTRANSPARENT); } else CalcLogBrush( &RenderBrush[CurrentBrush], RR_FILLCOLOUR() ); }

void OSRenderRegion::CreateNewPen (   )  [protected]

Creates a new Pen, based on the current line attributes. Scope: Private. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/93 Definition at line 1141 of file osrndrgn.cpp. { BOOL EmptyPen = RR_STROKECOLOUR().IsTransparent(); const enum Quality::Line LineQuality = RRQuality.GetLineQuality(); // if no filling going on then must have a pen if ( RRQuality.GetFillQuality() <= Quality::NoFill ) EmptyPen = FALSE; if ( // RFlags.GDI32 && // must be GDI32 !RenderFlags.VeryMono && // not to bitmaps (special colour rules) !RenderFlags.bImmediateRender && // not when immediate (XORing messes up) (LineQuality >= Quality::FullLine) && // not on simple lines !EmptyPen // not on NULL pens (over complex) ) { // Windows version would have used brush calculation to set pen properties // CalcLogBrush( &Brush, RR_STROKECOLOUR() ); INT32 PenWidth = MPtoLP(RR_LINEWIDTH()); if (IsPrinting()) { // Make sure we don't user single pixel width pens as they won't dither. if (PenWidth < 2) PenWidth = 2; } INT32 R,G,B; RR_STROKECOLOUR().GetRGBValue(&R,&G,&B); RenderPen[CurrentPen] = wxPen(wxColour(R,G,B), PenWidth, wxSOLID); // work out pen type switch (RR_STARTCAP()) { case LineCapRound: RenderPen[CurrentPen].SetCap(wxCAP_ROUND); break; case LineCapSquare: RenderPen[CurrentPen].SetCap(wxCAP_PROJECTING); break; case LineCapButt: RenderPen[CurrentPen].SetCap(wxCAP_BUTT); break; default: ENSURE(FALSE, "Bad startcap"); break; } switch (RR_JOINTYPE()) { case BevelledJoin: RenderPen[CurrentPen].SetJoin(wxJOIN_BEVEL); break; case MitreJoin: RenderPen[CurrentPen].SetJoin(wxJOIN_MITER); break; case RoundJoin: RenderPen[CurrentPen].SetJoin(wxJOIN_ROUND); break; default: ENSURE(FALSE, "bad jointype"); break; } return ; } // fall through to use old-fashioned 16-bit GDI pen creation if failed if (EmptyPen) RenderPen[CurrentPen] = wxPen(*wxTRANSPARENT_PEN); else { INT32 PenWidth = MPtoLP(RR_LINEWIDTH()); if (RR_LINEWIDTH()==0 || LineQuality < Quality::FullLine) PenWidth = 0; else { MILLIPOINT LineWidth = RR_LINEWIDTH(); if ((RenderFlags.VeryMono || RenderFlags.HitDetect) && LineWidth < GetScaledPixelWidth()) PenWidth = MPtoLP(GetScaledPixelWidth()); } wxColour Colour(0,0,0); if (RenderFlags.VeryMono || LineQuality < Quality::ThinLine) Colour = *wxBLACK; else if (DrawingMode==DM_EORPEN) Colour = CalcEORColour(RR_STROKECOLOUR()); else { INT32 R,G,B; RR_STROKECOLOUR().GetRGBValue(&R,&G,&B); Colour = wxColour(R, G, B); } RenderPen[CurrentPen] = wxPen(Colour, PenWidth, wxSOLID); } }

void OSRenderRegion::DeInitAttributes (   )  [protected]

Deletes the GDI pen and brush objects. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 21/01/94 Definition at line 871 of file osrndrgn.cpp. { // Get rid of pen and/or brush if we used them. /* if (OldPen != NULL) { //ENSURE(OldPen->m_hObject != NULL, "NULL object selected!"); RenderDC->SetPen(*OldPen); } if (OldBrush != NULL) { //ENSURE(OldBrush->m_hObject != NULL, "NULL object selected!"); RenderDC->SetBrush(*OldBrush); } */ // Deselect the FixedSystem font from the DC if (OldFont != NULL) { RenderDC->SetFont(*OldFont); OldFont = NULL; } // Deselect the normal rendering font from the DC if (FontInfo.pRenderFont != NULL) { RenderDC->SetFont(*FontInfo.pOldFont); FontInfo.pOldFont = NULL; delete FontInfo.pRenderFont; FontInfo.pRenderFont = NULL; } }

void OSRenderRegion::DeInitClipping (   )  [protected]

Destroys the GDI clipping region object, and unsets the clipping region for our DC. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 21/01/94 Definition at line 770 of file osrndrgn.cpp. { delete OSClipRegion; // Delete the CRgn OSClipRegion = NULL; // unset the Clipping Region if (!RFlags.Metafile) RenderDC->DestroyClippingRegion(); }

Coord OSRenderRegion::DocCoordToOS256 (  const DocCoord &  DocPoint  )  [protected]

Converts a DocCoord to a OS256 Coord. Used during rendering. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 5/8/93 Parameters: Matrix  elements and pixel scale. [INPUTS] Returns: A WinCoord Definition at line 3819 of file osrndrgn.cpp. { OilCoord OilPoint; OilPoint.x = MatrixCalc( RenderMatrix.a, DocPoint.x, RenderMatrix.c, DocPoint.y) + RenderMatrix.e; OilPoint.y = MatrixCalc( RenderMatrix.b, DocPoint.x, RenderMatrix.d, DocPoint.y) + RenderMatrix.f; // This was f1 Coord OS256Point; FIXED16 PixelWidth = RenderView->GetPixelWidth(); OS256Point.x = MPtoOS256(OilPoint.x, PixelWidth); // OS256Point.y = -(MPtoOS256(OilPoint.y, PixelWidth) + 256); // Above line commented out by Phil, 11/2/97 // The above "+256" is spurious (see comments for OilCoordToWin) // Fixes a nasty printing bug. OS256Point.y = -(MPtoOS256(OilPoint.y, PixelWidth)); return OS256Point; }

WinCoord OSRenderRegion::DocCoordToWin (  const DocCoord &  DocPoint  )  [protected]

Converts a DocCoord to a WinCoord. Used during rendering. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 5/8/93 Parameters: Matrix  elements and pixel scale. [INPUTS] Returns: A WinCoord Definition at line 3794 of file osrndrgn.cpp. { OilCoord OilPoint; OilPoint.x = MatrixCalc( RenderMatrix.a, DocPoint.x, RenderMatrix.c, DocPoint.y) + RenderMatrix.e; OilPoint.y = MatrixCalc( RenderMatrix.b, DocPoint.x, RenderMatrix.d, DocPoint.y) + RenderMatrix.f; // This was F1 return OilPoint.ToWin(RenderView); }

WinRect OSRenderRegion::DocRectToWin (  const DocRect &  docrect, INT32  leftshift, INT32  topshift, INT32  rightshift, INT32  bottomshift, BOOL  MightClip = FALSE )  [inline, protected]

Definition at line 307 of file osrndrgn.h. { return DocRectToWin(RenderView, RenderMatrix, docrect, leftshift, topshift, rightshift, bottomshift, MightClip ); }

WinRect OSRenderRegion::DocRectToWin (  const Matrix &  RenderMatrix, const DocRect &  DRect, const double  dpi )  [static]

To convert a rectangle in Doc coordinates to a rectangle in Win coordinates taking account of the destination dpi rather than assuming screen dpi as the above form does. Does not need the extra parameters that the above uses. INT32 dpi changed to double dpi (12/12/95) to improve the range of values allowed at the < 1000dpi settings that we will be using. Scope: Static. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 30/11/94 Parameters: DocRect  is a rectangle on document co-ords. [INPUTS] dpi is the resolution of the device we are rendering to Returns: Object containing the new rectangle coordinates. Definition at line 3951 of file osrndrgn.cpp. { WinRect WinRect; OilCoord OilLo; OilCoord OilHi; OilLo.x = MatrixCalc( RenderMatrix.a, DRect.lo.x, RenderMatrix.c, DRect.lo.y ) + RenderMatrix.e; OilLo.y = MatrixCalc( RenderMatrix.b, DRect.lo.x, RenderMatrix.d, DRect.lo.y ) + RenderMatrix.f; // This was f1 OilHi.x = MatrixCalc( RenderMatrix.a, DRect.hi.x, RenderMatrix.c, DRect.hi.y ) + RenderMatrix.e; OilHi.y = MatrixCalc( RenderMatrix.b, DRect.hi.x, RenderMatrix.d, DRect.hi.y ) + RenderMatrix.f; // this was f1 // RenderMatrix can involve a rotation (but only multiples of 90 degrees), so we swap // the corners here if necessary MILLIPOINT Temp; if (OilLo.x > OilHi.x) { Temp = OilLo.x; OilLo.x = OilHi.x; OilHi.x = Temp; } if (OilLo.y > OilHi.y) { Temp = OilLo.y; OilLo.y = OilHi.y; OilHi.y = Temp; } WinCoord WinLo; WinCoord WinHi; WinLo = OilLo.ToWin(dpi); WinHi = OilHi.ToWin(dpi); WinRect.x = WinLo.x; WinRect.y = WinHi.y; WinRect.width = WinHi.x-WinRect.x; WinRect.height = WinLo.y-WinRect.y; return WinRect; }

WinRect OSRenderRegion::DocRectToWin (  View *  pView, const Matrix &  RenderMatrix, const DocRect &  DRect, INT32  leftshift, INT32  topshift, INT32  rightshift, INT32  bottomshift, BOOL  MightClip = FALSE )  [static]

To convert a rectangle in Doc coordinates to a rectangle in Win coordinates. Scope: Static. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 8/8/93 Parameters: pView  - the view to convert in. [INPUTS] DocRect is a rectangle on document co-ords. The various shift parameters allow the resulting rectangle to be moved about a little, to allow for different rendering models etc. If MightClip is TRUE then the rectangle is clipped to fit within 16-bit GDI constraints, if running on 16-bit GDI. Returns: Object containing the new rectangle coordinates. Definition at line 3864 of file osrndrgn.cpp. { WinRect WinRect; // Don't do ERROR2 as this is in redraw code. ERROR3IF(pView == NULL, "NULL view in OSRenderRegion::DocRectToWin()"); OilCoord OilLo; OilCoord OilHi; OilLo.x = MatrixCalc( RenderMatrix.a, DRect.lo.x, RenderMatrix.c, DRect.lo.y ) + RenderMatrix.e; OilLo.y = MatrixCalc( RenderMatrix.b, DRect.lo.x, RenderMatrix.d, DRect.lo.y ) + RenderMatrix.f; // This was f1 OilHi.x = MatrixCalc( RenderMatrix.a, DRect.hi.x, RenderMatrix.c, DRect.hi.y ) + RenderMatrix.e; OilHi.y = MatrixCalc( RenderMatrix.b, DRect.hi.x, RenderMatrix.d, DRect.hi.y ) + RenderMatrix.f; // this was f1 // RenderMatrix can involve a rotation (but only multiples of 90 degrees), so we swap // the corners here if necessary MILLIPOINT Temp; if (OilLo.x > OilHi.x) { Temp = OilLo.x; OilLo.x = OilHi.x; OilHi.x = Temp; } if (OilLo.y > OilHi.y) { Temp = OilLo.y; OilLo.y = OilHi.y; OilHi.y = Temp; } WinCoord WinLo; WinCoord WinHi; WinLo = OilLo.ToWin(pView); WinHi = OilHi.ToWin(pView); WinRect.x = WinLo.x + leftshift; WinRect.y = WinHi.y + topshift; WinRect.width = WinHi.x + rightshift -WinRect.x; WinRect.height = WinLo.y + bottomshift-WinRect.y; PORTNOTE("other", "Check this use of WIN32") if ( MightClip //#if WIN32 // && IsWin32s() //#endif ) { // assume MM_TEXT, clip to limits without being too close else we might effect // the actual rendering (e.g. if a line crosses the clip rect boundary) wxRect MaxRect(-100, -100, 32100, 32100 ); WinRect.Intersect(MaxRect); } return WinRect; }

void OSRenderRegion::DrawBitmap (  const DocCoord &  Point, UINT32  BitmapID, UINT32  ToolID = NULL )  [virtual]

Draws an un-scaled Bitmap. Use this for drawing Icons for dialogue boxes etc. The Bitmap can be any size, but will be plotted unscaled. Note that 'Point' specifies where the bottom left of the bitmap will be. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 7/2/95 Parameters: Point  - The Coord specifying the bottom left of the Bitmap. [INPUTS] BitmapID, the resource ID of the bitmap to plot. ToolID, the optional ToolID of the tool containing the Bitmap resource. Implements RenderRegion. Definition at line 3396 of file osrndrgn.cpp. { // If we are not drawing complex shapes and this shape is, then return if ((!RenderComplexShapes) && (TestForComplexShape(&Caps))) return; wxBitmap * pBitmap=CamArtProvider::Get()->FindBitmap((ResourceID)BitmapID); if (!pBitmap) return; // Extract the Width and Height // INT32 Width = pBitmap->GetWidth(); INT32 Height = pBitmap->GetHeight(); // Convert the DocCoord into a windows coord wxPoint Origin = DocCoordToWin(Point); Origin.y = Origin.y - Height; // Translate bottom left to top left RenderDC->DrawBitmap(*pBitmap, Origin.x, Origin.y, TRUE); }

void OSRenderRegion::DrawBitmap (  const DocCoord &  Point, KernelBitmap *  pBitmap )  [virtual]

Draws an un-scaled Bitmap. Use this for drawing Icons for dialogue boxes etc. The Bitmap can be any size, but will be plotted unscaled. Note that 'Point' specifies where the bottom left of the bitmap will be. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 7/2/95 Parameters: Point  - The Coord specifying the bottom left of the Bitmap. [INPUTS] pBitmap, the KernelBitmap to plot. Implements RenderRegion. Definition at line 3299 of file osrndrgn.cpp. { PORTNOTETRACE("other","OSRenderRegion::DrawBitmap - do nothing"); #ifndef EXCLUDE_FROM_XARALX // If we are not drawing complex shapes and this shape is, then return if ((!RenderComplexShapes) && (TestForComplexShape(&Caps))) return; // Is there a Bitmap ?? if (pBitmap == NULL || pBitmap->ActualBitmap == NULL) { ERROR3("NULL Bitmap passed to DrawBitmap"); return; } // Get the 'Actual' windows Bitmap WinBitmap *WinBM = (WinBitmap*)pBitmap->ActualBitmap; // Is it valid ? if ( (WinBM->BMInfo==NULL) || (WinBM->BMBytes==NULL) ) return; // if not valid // Remember the Size of the Bitmap (in pixels) INT32 Width = WinBM->GetWidth(); INT32 Height = WinBM->GetHeight(); // Convert the DocCoord into a windows coord POINT Origin = DocCoordToWin(Point); Origin.y = Origin.y - Height; // Translate bottom left to top left CDC MemDC; // Create a memory DC based on this render region MemDC.CreateCompatibleDC(RenderDC); CBitmap Bitmap; // Create a CBitmap the same size as our one Bitmap.CreateCompatibleBitmap(RenderDC, Width, Height); // Select the CBitmap into the memory DC so that we have // a blank bitmap to copy into CBitmap* OldBmp = MemDC.SelectObject(&Bitmap); if (OldBmp == NULL) { TRACE( _T("Couldn't select Bitmap into CDC in DrawBitmap\n")); return; } // Now copy the Bits from our Kernel Bitmap into the Memory DC SetDIBitsToDevice( MemDC.m_hDC, 0,0, Width, Height, 0,0, 0, Height, WinBM->BMBytes, WinBM->BMInfo, DIB_RGB_COLORS ); // Copy the Bitmap onto this render region RenderDC->BitBlt( Origin.x, Origin.y, Width, Height, &MemDC, 0,0, SRCCOPY ); // Unselect the bitmap and delete it MemDC.SelectObject(OldBmp); Bitmap.DeleteObject(); #endif }

void OSRenderRegion::DrawBitmapBlob (  const DocCoord &  Point, ResourceID  resID )  [virtual]

Implements RenderRegion. Definition at line 3591 of file osrndrgn.cpp. { wxBitmap *pBitmap = (CamArtProvider::Get())->FindBitmap( resID ); if( NULL == pBitmap ) { TRACE( _T("wxBitmap failed to create in DrawBitmapBlob\n")); return; } // Extract the Width and Height INT32 Width = pBitmap->GetWidth(); INT32 Height = pBitmap->GetHeight(); // Convert the DocCoord into a windows coord wxPoint Origin = FindBitmapOrigin(Point, Width, Height); // EOR the bitmap onto this render region wxMemoryDC memDc; memDc.SelectObject( *pBitmap ); RenderDC->Blit( Origin.x, Origin.y, Width, Height, &memDc, 0, 0, wxXOR ); }

void OSRenderRegion::DrawBitmapBlob (  const DocCoord &  Point, KernelBitmap *  BlobShape )  [virtual]

Draws a Bitmap Blob. It is used for drawing more complex blob shapes, like 'rotation' arrows etc. The Bitmap can be any size, but must be Monochrome. Black pixels are transparent. White pixels will EOR. Note that 'Point' currently specifies where the centre of the bitmap will be. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 31/8/94 Parameters: Point  - The Coord specifying the centre of the Blob. [INPUTS] BlobShape - A Kernel Bitmap describing the Shape of the Blob. This is assumed to be a simple Monochrome Bitmap. See also: KernelBitmap Implements RenderRegion. Definition at line 3499 of file osrndrgn.cpp. { PORTNOTETRACE("other","OSRenderRegion::DrawBitmapBlob - do nothing"); #ifndef EXCLUDE_FROM_XARALX ENSURE(BlobShape != NULL, "NULL Bitmap passed to DrawBitmapBlob"); // Is there a Bitmap ?? if (BlobShape->ActualBitmap == NULL) return; // if no bitmap // Get the 'Actual' windows Bitmap WinBitmap *WinBM = (WinBitmap*)BlobShape->ActualBitmap; // Is it valid ? if ( (WinBM->BMInfo==NULL) || (WinBM->BMBytes==NULL) ) return; // if not valid // Remember the Size of the Bitmap (in pixels) INT32 Width = WinBM->BMInfo->bmiHeader.biWidth; INT32 Height = WinBM->BMInfo->bmiHeader.biHeight; // Convert the DocCoord into a windows coord POINT Origin = FindBitmapOrigin(Point, Width, Height); CDC MemDC; // Create a memory DC based on this render region MemDC.CreateCompatibleDC(RenderDC); CBitmap Bitmap; // Create a CBitmap the same size as our one Bitmap.CreateCompatibleBitmap(RenderDC, Width, Height); // Select the CBitmap into the memory DC so that we have // a blank bitmap to copy into CBitmap* OldBmp = MemDC.SelectObject(&Bitmap); if (OldBmp == NULL) { TRACE( _T("Couldn't select Bitmap into CDC in DrawBitmapBlob\n")); return; } // Now copy the Bits from our Kernel Bitmap into // the Memory DC SetDIBitsToDevice( MemDC.m_hDC, 0,0, Width, Height, 0,0, 0, Height, WinBM->BMBytes, WinBM->BMInfo, DIB_RGB_COLORS ); // EOR the Bitmap onto this render region RenderDC->BitBlt( Origin.x, Origin.y, Width, Height, &MemDC, 0,0, SRCINVERT ); // Unselect the bitmap and delete it MemDC.SelectObject(OldBmp); Bitmap.DeleteObject(); #endif }

void OSRenderRegion::DrawBlob (  DocCoord  p, BlobType  type )  [virtual]

Draw a blob. This is the type of blob that appear round objects to show that they have been selected. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 23/8/93 Parameters: p  - The Coord of the point to draw a blob over [INPUTS] type - the Type of Blob to draw. It can be either BT_SELECTED for a Selected point or BT_UNSELECTED for an unselected point See also: BlobType Implements RenderRegion. Definition at line 3269 of file osrndrgn.cpp. { DocRect MyBlob; GetBlobRect( ScaleFactor, p, type, &MyBlob); // I do not need to set the colour of the rect as that // should be done before this function is called // Draw Drag Rect draws a rect without shifting the sides about, so it is what // we need. DrawDragRect( &MyBlob ); }

void OSRenderRegion::DrawCross (  const DocCoord &  Point, const UINT32  Size )  [virtual]

Draws a cross in the render region. The cross consists of a vertical line 'Size' millipoints high, and a horizontal line 'Size' millipoints wide. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 21/02/94 Parameters: Point  - the centre point of the cross. [INPUTS] Size - the length of the lines used to draw the cross with. Implements RenderRegion. Definition at line 2137 of file osrndrgn.cpp. { GetValidPen(); const MILLIPOINT Length = Size * ScaledPixelWidth; // Work out cross coordinates in documenty coords DocCoord Coords[3]; Coords[0] = Point; Coords[1].x = Point.x - Length; Coords[1].y = Point.y - Length; Coords[2].x = Point.x + Length + ScaledPixelWidth; Coords[2].y = Point.y + Length + ScaledPixelWidth; // Convert to window coordinates wxPoint Points[3]; Points[0] = DocCoordToWin(Coords[0]); Points[1] = DocCoordToWin(Coords[1]); Points[2] = DocCoordToWin(Coords[2]); // Draw the horizontal line RenderDC->DrawLine(Points[1].x,Points[0].y,Points[2].x,Points[0].y); // Draw the vertical line RenderDC->DrawLine(Points[0].x,Points[1].y,Points[0].x,Points[2].y); }

void OSRenderRegion::DrawDashLine (  const DocCoord &  StartPoint, const DocCoord &  EndPoint )  [virtual]

Draws a dashed line between the two points. Uses the technology from DrawDragBounds(). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 10/10/95 Parameters: StartPoint  - start of the line [INPUTS] EndPoint - end of the line See also: OSRenderRegion::DrawDragBounds() Reimplemented from RenderRegion. Definition at line 2042 of file osrndrgn.cpp. { INT32 OurOldBkMode = RenderDC->GetBackgroundMode() ; INT32 OurOldDrawingMode = RenderDC->GetLogicalFunction(); wxPen OurOldPen = RenderDC->GetPen() ; wxPen DotPen(CalcEORColour(RR_STROKECOLOUR()),1,wxDOT); RenderDC->SetPen(DotPen); RenderDC->SetBackgroundMode(wxTRANSPARENT); RenderDC->SetLogicalFunction(wxXOR); // Now, render the line WinCoord StartPt = DocCoordToWin(StartPoint); WinCoord EndPt = DocCoordToWin(EndPoint ); RenderDC->DrawLine(StartPt,EndPt); // And restore the previous GDI settings RenderDC->SetLogicalFunction(OurOldDrawingMode); RenderDC->SetBackgroundMode(OurOldBkMode); RenderDC->SetPen(OurOldPen); }

void OSRenderRegion::DrawDragBounds (  DocRect *  RectToRender  )  [virtual]

Used to draw a "rectangle" to screen (for dragging). However, the corners of the rectangle are passed through the current rendering matrix, so the rect may well be rotated or skewed by the time it reaches the screen. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 16/5/95 Parameters: RectToRender  - The bounding rectangle we wish to render. [INPUTS] The rectangle is never filled, and will be stroked in XOR mode, using the current line colour. (i.e. only line colour needs to be set before calling this method, and it'll *always* be XOR'd regardless of other settings) This is used for XOR dragging of selected objects as they are skewed, rotated, translated, etc Notes: DO NOT confuse this method with DrawDragRect (which will draw a rectangle without skew or rotation) See also: OSRenderRegion::DrawDragRect; RenderRegion::DrawDragBounds; Range::RenderXOROutlinesOn Reimplemented from RenderRegion. Definition at line 1998 of file osrndrgn.cpp. { INT32 OurOldBkMode = RenderDC->GetBackgroundMode() ; INT32 OurOldDrawingMode = RenderDC->GetLogicalFunction(); wxPen OurOldPen = RenderDC->GetPen() ; wxPen DotPen(CalcEORColour(RR_STROKECOLOUR()),1,wxDOT); RenderDC->SetPen(DotPen); RenderDC->SetBackgroundMode(wxTRANSPARENT); RenderDC->SetLogicalFunction(wxXOR); // Now, render the 4 lines, converting the corners of the rectangle with the // current rendering matrix WinCoord Points[5]; Points[0] = Points[4] = DocCoordToWin(RectToRender->lo); Points[1] = DocCoordToWin(DocCoord(RectToRender->lo.x, RectToRender->hi.y)); Points[2] = DocCoordToWin(RectToRender->hi); Points[3] = DocCoordToWin(DocCoord(RectToRender->hi.x, RectToRender->lo.y)); // And close the shape RenderDC->DrawLines(5,Points); // And restore the previous GDI settings RenderDC->SetLogicalFunction(OurOldDrawingMode); RenderDC->SetBackgroundMode(OurOldBkMode); RenderDC->SetPen(OurOldPen); }

void OSRenderRegion::DrawDragRect (  DocRect *  RectToDraw  )  [virtual]

Renders a Rectangle to the GDI . Used to claim "without shifting it about" bit it does adjust it now for the differences in rendering models. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 26/5/93 Parameters: RectToDraw  is a pointer to a DocRect object to render [INPUTS] See also: OSRenderRegion::DrawPath() Implements RenderRegion. Definition at line 1944 of file osrndrgn.cpp. { GetValidPen(); GetValidBrush(); // NOTE // Sometimes the PasteBoard and Page rects are dissapearing at high zoom. // This seems to be because of the GDI 16 bit limit being exceeded. // We need to check for the overflow, or clip the rects ourselves. WinRect Rect = DocRectToWin(*RectToDraw, 0,0,0,0); // for some reason, all flavours of GDI can screw up when asked to render zero-width/ // height rectangles when in XOR mode, as it often leaves little pixels behind. Our fix // for this is to simply not render anything if zero width or height in EOR mode if ( DrawingMode != DM_EORPEN || // if not EOR then always ( Rect.width !=1 && // else must have width Rect.height!=1 // and height ) ) RenderDC->DrawRectangle(Rect); // Draw the Rectangle }

void OSRenderRegion::DrawFixedSystemText (  StringBase *  TheText, DocRect &  BoundsRect, UINT32  uFormat = DEFAULT_TEXT_FORMATTING )  [virtual]

To draw simple text, using the default host-operating-system font. The size and style of this font are decided by the host OS (or oil code) and cannot be set in any way. To determine how much space is needed to display a string with this method, see the SeeAlso. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 12/1/95 Parameters: TheText  - The string to render [INPUTS] BoundsRect - Determines where the text is to be plotted. The text will also be clipped within this bounding rectangle if it exceeds the available space. Notes: This method is intended solely for the use of kernel-rendered dialogues, such as SuperGalleries, which need to display simple text information. It should not be confused with document rendering of arbitrary text paths etc. Currently, the text is drawn in a default manner (left justified and centered vertically; one line of text only (no word-wrap onto subsequent lines), etc) Do not use special characters such as tab/newline -their effect is undefined See also: OSRenderRegion::GetFixedSystemTextSize; OSRenderRegion::SetFixedSystemTextColours Reimplemented from RenderRegion. Definition at line 2196 of file osrndrgn.cpp. { wxString Text = (wxString)(TCHAR *)(*TheText); wxRect Rect(0,0,0,0); wxFont SaveFont=RenderDC->GetFont(); wxFont FixedFont = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT); FixedFont.SetPointSize(8); RenderDC->SetFont(FixedFont); wxDC * pDC = RenderDC; wxSize DPI = GetFixedDCPPI(*pDC); INT32 XDPI = DPI.GetWidth(); INT32 YDPI = DPI.GetHeight(); INT32 LineHeight = RenderDC->GetCharHeight(); if (uFormat & FORMAT_CALCRECT) // just calculate the rect needed to draw the text and return { // This won't actually draw the text, instead it returns a rectangle in 'Rect' // LineHeight = RenderDC->DrawText((TCHAR *) (*TheText), -1, &Rect, uFormat); wxCoord w, h; RenderDC->GetTextExtent(Text, &w, &h); Rect = wxRect(0, 0, w, h); if(XDPI == 0 || YDPI == 0 || LineHeight == 0) { ERROR3("Can not calculate text size"); BoundsRect = DocRect(0, 0, 0, 0); RenderDC->SetFont(SaveFont); return; } // For some reason, Rect.bottom and Rect.top seem to be incorrect, so we have // to use the returned LineHeight value BoundsRect = DocRect(0, 0, (INT32)(((double)Rect.width * IN_MP_VAL) / XDPI), (INT32)(((double)LineHeight * IN_MP_VAL) / YDPI) ); RenderDC->SetFont(SaveFont); return; } // We plot using the TOP of the rectangle supplied (that's the highest DocCoord // but we need to center it (i.e. reduce the value DocRect brect=BoundsRect; brect.hi.y -= ((brect.hi.y-brect.lo.y)-(INT32)(((double)LineHeight * IN_MP_VAL) / YDPI))/2; Rect = DocRectToWin(brect, 0,0,0,0, TRUE); // Rect = DocRectToWin(BoundsRect, 0,-1,1,0, TRUE); // Small 'fix' - If we DrawRect the 'BoundsRect' then windows draws the text 1 pixel // further to the right than the rectangle. This just ensures that the text is always // clipped inside the rectangle rather than outside (at worst, a pixel too far inside) if (Rect.width>0) // Still a valid rectangle? { // Rect.x--; // wxWidgets seems to corrupt the current brush here, which we need to preserve wxBrush SaveBrush=RenderDC->GetBrush(); INT32 SaveBackgroundMode=RenderDC->GetBackgroundMode(); // Draw the text RenderDC->SetBackgroundMode(wxTRANSPARENT); RenderDC->DrawText(Text, Rect.GetLeft(), Rect.GetTop()); // Restore the brush. First we have to ensure SetBrush really works. This is // because the GTK brush is corrupted whilst the wxWidgets one is still right. // So we have to select a different brush or wxWidgets will skip the call // that would otherwise fix the GTK brush - wxWidgets bug #148096 RenderDC->SetBackgroundMode(SaveBackgroundMode); RenderDC->SetBrush(*wxTRANSPARENT_BRUSH); RenderDC->SetBrush(wxNullBrush); RenderDC->SetBrush(SaveBrush); // LineHeight = RenderDC->DrawText((TCHAR *) (*TheText), -1, &Rect, uFormat); // ENSURE(LineHeight > 0, "OSRenderRegion::DrawFixedSystemText failed"); } RenderDC->SetFont(SaveFont); }

void OSRenderRegion::DrawLine (  const DocCoord &  StartPoint, const DocCoord &  EndPoint )  [virtual]

Renders a Line to the GDI. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 11/6/93 Parameters: StartPoint  is the Inclusive start coordinate. [INPUTS] EndPoint is thw Exclusive end coordinate. See also: OSRenderRegion::DrawPath(); OSRenderRegion::DrawRect() Implements RenderRegion. Definition at line 2077 of file osrndrgn.cpp. { // If we are not drawing complex shapes and this shape is, then return if ((!RenderComplexShapes) && (TestForComplexShape(&Caps))) return; GetValidPen(); GetValidBrush(); const UINT32 LINEVERTICES = 2; wxPoint LinePoints[LINEVERTICES]; LinePoints[0] = DocCoordToWin(StartPoint); //LinePoints[0].y--; LinePoints[1] = DocCoordToWin(EndPoint); //LinePoints[1].y--; RenderDC->DrawLine(LinePoints[0],LinePoints[1]); // Draw the Line #if 0 if (!StartArrow.IsNull) DrawLineArrow(StartArrow, StartPoint, EndPoint); if (!EndArrow.IsNull) DrawLineArrow(EndArrow, EndPoint, StartPoint); #endif }

SlowJobResult OSRenderRegion::DrawMaskedBitmap (  const DocRect &  Rect, KernelBitmap *  pBitmap, MaskedRenderRegion *  pMask, ProgressDisplay *  Progress )  [virtual]

Plots the bitmap using the mask supplied. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 20/4/95 Parameters: Point  - the position to plot the bitmap [INPUTS] pBitmap - The bitmap that needs plotting pMask - The mask render region to use to indicate which bits of pBitmap needs to be plotted Reimplemented from RenderRegion. Definition at line 6513 of file osrndrgn.cpp. { PORTNOTETRACE("other","OSRenderRegion::DrawMaskedBitmap - do nothing"); #if !defined(STANDALONE) && !defined(EXCLUDE_FROM_XARALX) if (RenderView->GetColourPlate() != NULL && !RenderView->GetColourPlate()->IsDisabled()) { // We're colour separating. Indirect this call to the separation variant of this code // (see below) return(DrawSeparatedMaskedBitmap(Rect, pBitmap, pMask, Progress)); } // Make sure the world is in one piece if ((pBitmap==NULL) || (pMask==NULL)) return SLOWJOB_FAILURE; // If mask coverage is 0% we do not need to do anything. The TRUE param indicates // that we don't care about exact coverage, which makes it return as soon as it realises // that there are pixel(s) that we'll have to plot if (pMask->FindCoverage(TRUE) == 0) return SLOWJOB_SUCCESS; // Guess we will need to be doing something... if (pBitmap->ActualBitmap == NULL) return SLOWJOB_FAILURE; // Get the 'Actual' windows Bitmap WinBitmap *WinBM = (WinBitmap*)pBitmap->ActualBitmap; // Is it valid ? if ((WinBM->BMInfo==NULL) || (WinBM->BMBytes==NULL)) return SLOWJOB_FAILURE; // Remember the Size of the Bitmap (in pixels) INT32 Width = WinBM->GetWidth(); INT32 Height = WinBM->GetHeight(); if ((Width == 0) || (Height == 0)) // Error - bitmap has no dimension return SLOWJOB_FAILURE; // Convert the bitmap from a 32bpp bitmap to a 24bpp bitmap INT32 BitmapDepth = WinBM->GetBPP(); if (BitmapDepth == 32) { // Can't plot 32bpp bitmaps to GDI as 16-bit GDI doesn't understand them, // so we convert to 24bpp bitmap in-situ and render that... // How many bytes to a source scanline? const INT32 ScanlineBytes = WinBM->GetScanlineSize(); // How many bytes to a destination scanline const INT32 DestlineBytes = DIBUtil::ScanlineSize(Width, 24); // Now convert the bitmap in-situ LPBYTE OriginalBuffer = WinBM->BMBytes; LPBYTE ConvertedBuffer = WinBM->BMBytes; for (INT32 i=0; i<Height; i++) { DIBUtil::Convert32to24(Width, OriginalBuffer, ConvertedBuffer); OriginalBuffer += ScanlineBytes; ConvertedBuffer += DestlineBytes; } // Update bitmap info to show it is now a 24bpp bitmap... WinBM->BMInfo->bmiHeader.biSizeImage = DestlineBytes * Height; WinBM->BMInfo->bmiHeader.biBitCount = 24; BitmapDepth = 24; } // make sure we have a 24bpp bitmap ERROR3IF(BitmapDepth!=24, "Non 24bpp bitmap found in DrawMaskedBitmap"); // Work out the coords to blit to, taking into acount the differnt dpis of the // source and destination bitmaps. INT32 SrcDpi = pMask->FindMaskDpi(); INT32 DestDpi = SrcDpi; if (RenderDC!=NULL) DestDpi = RenderDC->GetDeviceCaps(LOGPIXELSY); // Work out the ratio between to two double Ratio = DestDpi; Ratio = Ratio/SrcDpi; // Convert the DocCoord into a windows coord DocRect ClipRect = pMask->GetClipRect(); WinRect WinClipRect = DocRectToWin(RenderMatrix, ClipRect, DestDpi); POINT Origin; Origin.x = WinClipRect.left; Origin.y = WinClipRect.bottom; // Inform progress object how high this band is if (PrintMonitor::PrintMaskType==PrintMonitor::MASK_MASKED) { if (Progress!=NULL) Progress->StartBitmapPhaseBand(Height); } // We need to create a tempory bitmap that we use to render each scan line LPBITMAPINFO TempBitmapInfo = NULL; LPBYTE TempBitmapBytes = NULL; // Get some memory for a tempory bmp 1 pixel high TempBitmapInfo = AllocDIB(Width, 1, BitmapDepth, &TempBitmapBytes); if (TempBitmapInfo==NULL) return SLOWJOB_FAILURE; // How many bytes to a destination scanline INT32 ScanLineBytes = DIBUtil::ScanlineSize(Width, BitmapDepth); INT32 BytesPerPixel = 3; // Now convert the bitmap in-situ LPBYTE SrcBuffer = WinBM->BMBytes; LPBYTE DestBuffer = TempBitmapBytes; // Set the blit mode INT32 OldMode = SetStretchBltMode(RenderDC->GetSafeHdc(), HALFTONE);//COLORONCOLOR); // Must call SetBrushOrgEx() after setting the stretchblt mode // to HALFTONE (see Win32 SDK docs). POINT OldOrg; SetBrushOrgEx(RenderDC->m_hDC, 0, 0, &OldOrg); // Now copy the Bits from our Kernel Bitmap into the Memory DC - either we can // do this as a masked blit (a scan line at a time), or in one go. // We do the masked blit under NT, or if the preference has been over-ridden by the user. if (PrintMonitor::PrintMaskType!=PrintMonitor::MASK_SIMPLE) { MaskRegion MaskInfo; pMask->GetFirstMaskRegion(&MaskInfo); while (MaskInfo.Length!=0) { // Calculate the source buffer address from the x and y position SrcBuffer = WinBM->BMBytes; SrcBuffer += ScanLineBytes * MaskInfo.y; SrcBuffer += MaskInfo.x*BytesPerPixel; INT32 RegionWidth = MaskInfo.Length; // Update bitmap info to show the new scan line size TempBitmapInfo->bmiHeader.biWidth = RegionWidth; TempBitmapInfo->bmiHeader.biSizeImage = (RegionWidth*BytesPerPixel); memcpy(DestBuffer, SrcBuffer, RegionWidth*BytesPerPixel); // Work out the coords of the destination rectangle INT32 DestX = Origin.x + INT32(ceil(MaskInfo.x*Ratio)); INT32 DestY = Origin.y - INT32(ceil((MaskInfo.y+1)*Ratio)); INT32 DestWidth = INT32(ceil(RegionWidth*Ratio)); INT32 DestHeight = INT32(ceil(1*Ratio)); // Blit the data to the screen StretchDIBits( RenderDC->GetSafeHdc(), DestX, DestY, DestWidth, DestHeight, 0, 0, RegionWidth, 1, TempBitmapBytes, TempBitmapInfo, DIB_RGB_COLORS, SRCCOPY); // Update the progress display if necessary. if (PrintMonitor::PrintMaskType==PrintMonitor::MASK_MASKED) { if ((Progress!=NULL) && (!Progress->BitmapPhaseBandRenderedTo(MaskInfo.y))) { // Put the blit mode back as it was SetStretchBltMode(RenderDC->GetSafeHdc(), OldMode); SetBrushOrgEx(RenderDC->m_hDC, OldOrg.x, OldOrg.y, NULL); // Free up the tempory DIB I made FreeDIB(TempBitmapInfo, TempBitmapBytes); return SLOWJOB_USERABORT; } } // Find the next bit of scan line to plot pMask->GetNextMaskRegion(&MaskInfo); } } else { // Blit in one go... // Work out the coords of the destination rectangle INT32 DestX = Origin.x; INT32 DestY = Origin.y - INT32(ceil(Height * Ratio)); INT32 DestWidth = INT32(ceil(Width * Ratio)); INT32 DestHeight = INT32(ceil(Height * Ratio)); // Blit the data to the screen StretchDIBits( RenderDC->GetSafeHdc(), DestX, DestY, DestWidth, DestHeight, 0, 0, Width, Height, WinBM->BMBytes, WinBM->BMInfo, DIB_RGB_COLORS, SRCCOPY); // Update the progress display if necessary. if ((Progress!=NULL) && (!Progress->BitmapPhaseBandRenderedTo(Height))) { // Put the blit mode back as it was SetStretchBltMode(RenderDC->GetSafeHdc(), OldMode); SetBrushOrgEx(RenderDC->m_hDC, OldOrg.x, OldOrg.y, NULL); // Free up the tempory DIB I made FreeDIB(TempBitmapInfo, TempBitmapBytes); return SLOWJOB_USERABORT; } } // Put the blit mode back as it was SetStretchBltMode(RenderDC->GetSafeHdc(), OldMode); SetBrushOrgEx(RenderDC->m_hDC, OldOrg.x, OldOrg.y, NULL); // Update bitmap info to what it was before we started TempBitmapInfo->bmiHeader.biSizeImage = (Width*3); TempBitmapInfo->bmiHeader.biWidth = Width; // Free up the tempory DIB I made FreeDIB(TempBitmapInfo, TempBitmapBytes); #endif // All ok return SLOWJOB_SUCCESS; }

void OSRenderRegion::DrawPathToOutputDevice (  Path *  PathToDraw, PathShape  shapePath = PATHSHAPE_PATH )  [virtual]

Renders a path object to the GDI. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 26/5/93 Parameters: PathToDraw  is a pointer to a Path object to render [INPUTS] See also: OSRenderRegion::DrawRect() Implements RenderRegion. Definition at line 1808 of file osrndrgn.cpp. { // If we are not drawing complex shapes and this shape is, then return if ((!RenderComplexShapes) && (TestForComplexShape(&Caps))) return; // We want to draw it, so get pens and brushs GetValidPen(); GetValidBrush(); // and draw the path RenderPath(PathToDraw); // Render the Path // draw the arrow heads on to it. DrawPathArrowHeads(NORMALPATH(PathToDraw)); }

void OSRenderRegion::DrawPixel (  const DocCoord &  Point  )  [virtual]

Plot a single pixel in a render region. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 21/02/94 Parameters: Point  - the coordinate to plot the point at. [INPUTS] Implements RenderRegion. Definition at line 2112 of file osrndrgn.cpp. { wxPoint LinePoint = DocCoordToWin(Point); // RenderDC->SetPixel(LinePoint, // ConvertColourToScreenWord(CurrentColContext, &RR_STROKECOLOUR())); INT32 R,G,B; RR_STROKECOLOUR().GetRGBValue(&R,&G,&B); RenderDC->SetPen(wxColour(R,G,B)); RenderDC->DrawPoint(LinePoint); }

void OSRenderRegion::DrawRect (  DocRect *  RectToRend  )  [virtual]

Renders a rectangle using Ploygon instead of Rectangle. Used for BodgeRectangles devices whi cannot render rectangles correctly. Should really only be used when no fill brush has been set as solid ones with XORing on don't render correctly.Renders a Rectangle to the GDI. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 26/5/93 Parameters: RectToDraw  is a pointer to a DocRect object to render [INPUTS] See also: OSRenderRegion::DrawPath() Implements RenderRegion. Definition at line 1871 of file osrndrgn.cpp. { // If we are not drawing complex shapes and this shape is, then return if ((!RenderComplexShapes) && (TestForComplexShape(&Caps))) return; GetValidPen(); GetValidBrush(); // TRACEUSER("Gavin",_T("RectToRend : %08x %08x %08x %08x"), // RectToRend->lo.x,RectToRend->lo.y,RectToRend->hi.x,RectToRend->hi.y); // TRACEUSER("Gavin",_T("CurrentClipRect : %08x %08x %08x %08x"), // CurrentClipRect.lo.x,CurrentClipRect.lo.y,CurrentClipRect.hi.x,CurrentClipRect.hi.y); // First see if the rect intersects with the clip rect if (!RectToRend->IsIntersectedWith(CurrentClipRect)) return; // OK, it intersects, but we should try to clip it with the inner rect DocRect DrawRect = RectToRend->Intersection(InnerRect); // TRACEUSER("Gavin",_T("DrawRect : %08x %08x %08x %08x *"), // DrawRect.lo.x,DrawRect.lo.y,DrawRect.hi.x,DrawRect.hi.y); // NOTE // Sometimes the PasteBoard and Page rects are dissapearing at high zoom. // This seems to be because of the GDI 16 bit limit being exceeded. // We need to check for the overflow, or clip the rects ourselves. Hence the // TRUE args on the end of DocRectToWin WinRect Rect; // Ok, all the Fuzzy clipping has been taken care of, now convert and draw the rectangle we have left /* if (BodgeRectangles) { // if using Ploygon to draw rectangles, no bodging of co-ords is required at all // (as you would expect) */ Rect = DocRectToWin(DrawRect, 0,0,0,0, TRUE); /* } else if (RR_STROKECOLOUR().IsTransparent()) { Rect = DocRectToWin(DrawRect, 0,0,1,1, TRUE); } else { Rect = DocRectToWin(DrawRect, 0,-1,1,0, TRUE); } BOOL RectOK; // Draw the Rectangle if (BodgeRectangles) { RectOK = SlowRectangle(RenderDC, Rect); ENSURE(RectOK,"CDC::Rectangle failed in DrawRect"); } else */ RenderDC->DrawRectangle(Rect); }

SlowJobResult OSRenderRegion::DrawSeparatedMaskedBitmap (  const DocRect &  Rect, KernelBitmap *  pBitmap, MaskedRenderRegion *  pMask, ProgressDisplay *  Progress )  [protected, virtual]

Plots the bitmap using the mask supplied. The bitmap is colour separated according to the current ColourPlate settings, and output (a scanline at a time) in an 8bpp greyscale format. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 11/7/96 Parameters: Point  - the position to plot the bitmap [INPUTS] pBitmap - The bitmap that needs plotting pMask - The mask render region to use to indicate which bits of pBitmap needs to be plotted Progress - The progress object to be kept informed of progress Notes: This function is autoamtically called by DrawMaskedBitmap() if it is called while we are rendering a colour separation plate. It is essentially a copy of DrawMaskedBitmap which has been rejigged to colour separate the bitmap. Definition at line 6769 of file osrndrgn.cpp. { PORTNOTETRACE("other","OSRenderRegion::DrawSeparatedMaskedBitmap - do nothing"); #ifndef EXCLUDE_FROM_XARALX #ifndef STANDALONE SlowJobResult Result = SLOWJOB_SUCCESS; // Make sure the world is in one piece if ((pBitmap==NULL) || (pMask==NULL)) return SLOWJOB_FAILURE; // If mask coverage is 0% we do not need to do anything. The TRUE param indicates // that we don't care about exact coverage, which makes it return as soon as it realises // that there are pixel(s) that we'll have to plot if (pMask->FindCoverage(TRUE) == 0) return SLOWJOB_SUCCESS; // Get the 'Actual' windows Bitmap WinBitmap *WinBM = (WinBitmap*)pBitmap->ActualBitmap; // Is it valid ? if (WinBM == NULL || WinBM->BMInfo == NULL || WinBM->BMBytes == NULL) return SLOWJOB_FAILURE; // We're colour separating, so make sure we've got some sep tables to work with. // We cache them once we've used them. I would do this sort of set-up in StartRender // but of course all the derived classes just override that behaviour and we're stuffed if (SepTables == NULL && RenderView->GetColourPlate() != NULL) { ColourContextCMYK *cc = (ColourContextCMYK *)RenderView->GetColourContext(COLOURMODEL_CMYK); if (cc != NULL) { SepTables = (BYTE *) CCMalloc(5 * 256 * sizeof(BYTE)); if (SepTables != NULL) { if (!cc->GetProfileTables(SepTables)) { CCFree(SepTables); SepTables = NULL; } } } ERROR3IF(SepTables == NULL, "Can't generate separation tables in OSRenderRegion"); if (SepTables == NULL) return(SLOWJOB_FAILURE); } // Remember the Size of the Bitmap (in pixels) INT32 Width = WinBM->GetWidth(); INT32 Height = WinBM->GetHeight(); INT32 BitmapDepth = WinBM->GetBPP(); if (Width == 0 || Height == 0) return SLOWJOB_FAILURE; // Work out the coords to blit to, taking into acount the differnt dpis of the // source and destination bitmaps. INT32 SrcDpi = pMask->FindMaskDpi(); INT32 DestDpi = SrcDpi; if (RenderDC!=NULL) DestDpi = RenderDC->GetDeviceCaps(LOGPIXELSY); // Work out the ratio between to two double Ratio = DestDpi; Ratio = Ratio/SrcDpi; // Convert the DocCoord into a windows coord DocRect ClipRect = pMask->GetClipRect(); WinRect WinClipRect = DocRectToWin(RenderMatrix, ClipRect, DestDpi); POINT Origin; Origin.x = WinClipRect.left; Origin.y = WinClipRect.bottom; // Inform progress object how high this band is if (PrintMonitor::PrintMaskType==PrintMonitor::MASK_MASKED) { if (Progress!=NULL) Progress->StartBitmapPhaseBand(Height); } // Allocate a 32bpp scanline buffer Pixel32bpp *pScanline = (Pixel32bpp *) CCMalloc(Width * sizeof(Pixel32bpp)); if (pScanline == NULL) return(SLOWJOB_FAILURE); // Create a bitmap header structure to use with our temporary scanline. As all output data // will be 8bpp, we set the header up as an 8bpp bitmap. LPBITMAPINFO pScanlineInfo = AllocDIB(Width, 1, 8, NULL); if (pScanlineInfo == NULL) return SLOWJOB_FAILURE; // Set up a simple greyscale palette for the bitmap for (INT32 i = 0; i < 256; i++) { pScanlineInfo->bmiColors[i].rgbRed = pScanlineInfo->bmiColors[i].rgbGreen = pScanlineInfo->bmiColors[i].rgbBlue = i; pScanlineInfo->bmiColors[i].rgbReserved = 0; } // Set the blit mode INT32 OldMode = SetStretchBltMode(RenderDC->GetSafeHdc(), HALFTONE);//COLORONCOLOR); // Must call SetBrushOrgEx() after setting the stretchblt mode // to HALFTONE (see Win32 SDK docs). POINT OldOrg; SetBrushOrgEx(RenderDC->m_hDC, 0, 0, &OldOrg); ColourContext *OutputContext = RenderView->GetColourContext(COLOURMODEL_RGBT); ERROR3IF(OutputContext == NULL, "Where's me RGB colour context gone then?"); // Now copy the Bits from our Kernel Bitmap into the Memory DC // as a masked blit (a scan line at a time, so we can colour separate it) MaskRegion MaskInfo; pMask->GetFirstMaskRegion(&MaskInfo); while (MaskInfo.Length != 0) { // Update bitmap info to show the new scan line size pScanlineInfo->bmiHeader.biWidth = MaskInfo.Length; pScanlineInfo->bmiHeader.biSizeImage = MaskInfo.Length * sizeof(BYTE); // Read out the scanline into our pScanline buffer, converting it to a generic // 32bpp format as we go. This is WinBM->GetScanline32bpp(MaskInfo.y, TRUE, pScanline); // Now colour separate it. We only bother separating the unmasked portion of the scanline // which we place back in the left end of the scanline WinBM->ColourSeparateScanline32to8(OutputContext, SepTables, (BYTE *) pScanline, // Output buffer (shared!) pScanline + MaskInfo.x, // Input buffer - !pointer arithmetic! MaskInfo.Length); // Work out the coords of the destination rectangle const INT32 DestX = Origin.x + INT32(ceil(MaskInfo.x * Ratio)); const INT32 DestY = Origin.y - INT32(ceil((MaskInfo.y + 1) * Ratio)); const INT32 DestWidth = INT32(ceil(MaskInfo.Length * Ratio)); const INT32 DestHeight = INT32(ceil(1 * Ratio)); // Blit the data to the screen StretchDIBits( RenderDC->GetSafeHdc(), DestX, DestY, DestWidth, DestHeight, 0, 0, MaskInfo.Length, 1, (BYTE *) pScanline, pScanlineInfo, DIB_RGB_COLORS, SRCCOPY); // Update the progress display if necessary. if (PrintMonitor::PrintMaskType == PrintMonitor::MASK_MASKED && Progress != NULL && !Progress->BitmapPhaseBandRenderedTo(MaskInfo.y)) { Result = SLOWJOB_USERABORT; break; // User aborted, so quit rendering, and return USERABORT } // Find the next bit of scan line to plot pMask->GetNextMaskRegion(&MaskInfo); } // Put the blit mode back as it was SetStretchBltMode(RenderDC->GetSafeHdc(), OldMode); SetBrushOrgEx(RenderDC->m_hDC, OldOrg.x, OldOrg.y, NULL); // Free up the tempory DIB I made FreeDIB(pScanlineInfo, NULL); CCFree(pScanline); return(Result); #else return SLOWJOB_FAILURE; #endif #else return SLOWJOB_SUCCESS; #endif }

BOOL OSRenderRegion::DrawTransformedBitmap (  NodeBitmap *  pNodeBitmap  )  [virtual]

Reimplemented from RenderRegion. Definition at line 3419 of file osrndrgn.cpp. { // If we are not printing, then we'll always render as a bitmap fill // (eg. Gallery items). if (IsPrinting()) { // If we are not drawing complex shapes and this shape is, then return if ((!RenderComplexShapes) && (TestForComplexShape(&Caps))) return TRUE; if ((!RenderComplexShapes) && (pNodeBitmap->NeedsTransparency())) return TRUE; // If we've not got a valid colour plate or it is disabled if (CurrentColContext->GetColourPlate() == NULL || CurrentColContext->GetColourPlate()->IsDisabled()) { // If it is a simple rectangular shape then // we can use GDI to render it if (pNodeBitmap->HasSimpleOrientation(this)) { // Get hold of the coord array for the bitmap. DocCoord *Coords = pNodeBitmap->InkPath.GetCoordArray(); // Work out where to render the bitmap on the device context - find top left corner OilCoord TopLeft(Coords[0].x, Coords[0].y); RenderMatrix.transform(&TopLeft); WinCoord DestTopLeft = TopLeft.ToWin(RenderView); // Find required size of bitmap on device context. MILLIPOINT Width = Coords[1].x - Coords[0].x; MILLIPOINT Height = Coords[0].y - Coords[3].y; FIXED16 fxPixelSize = 0; RenderView->GetScaledPixelSize(&fxPixelSize, &fxPixelSize); double dPixelSize = fxPixelSize.MakeDouble(); INT32 DestWidth = (INT32) ((((double) Width) / dPixelSize) + 0.5); INT32 DestHeight = (INT32) ((((double) Height) / dPixelSize) + 0.5); // Get handle to bitmap (must be a WinBitmap as we are in winoil!) CWxBitmap *WxBM = (CWxBitmap *) pNodeBitmap->GetBitmap()->ActualBitmap; wxImage *pwxImage=WxBM->MakewxImage(DestWidth, DestHeight); if (pwxImage) { wxBitmap TheBitmap(*pwxImage); RenderDC->DrawBitmap(TheBitmap, DestTopLeft.x, DestTopLeft.y, TRUE); delete pwxImage; } } } } // We can't do arbitrarily transformed bitmaps - use a bitmap fill. RenderComplexShapes = TRUE; BOOL bOk = RenderRegion::DrawTransformedBitmap(pNodeBitmap); RenderComplexShapes = FALSE; return bOk; }

wxPoint OSRenderRegion::FindBitmapOrigin (  DocCoord  Centre, INT32  Width, INT32  Height )  [protected]

Finds the windows origin to plot a bitmap at, so that it's centre will be at the DocCoord specified. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 1/9/94 Parameters: Centre  - The DocCoord specifying the centre of the Bitmap. [INPUTS] Width & Height of the bitmap in Pixels. Rewritten 20/06/95 by Phil: This routine now uses high-res coords until the final return command so that the centre of the bitmap can be matched to the centre of the pixel at the specified point. This allows these bitmap plots to be centered accurately using the same rules as thin lines and grid points. Karim 11/09/2000 This method no longer uses GetScaledPixelWidth() or an integer pixel size, as these are inaccurate at high magnifications. Instead, it calculates its own floating-point pixel width, and converts to integer arithmetic as late as possible, for max. accuracy. Scope: Protected See also: - Definition at line 3640 of file osrndrgn.cpp. { DocCoord Origin; double PelSize; DocView *pDocView = DocView::GetSelected(); ERROR3IF(pDocView == NULL, "OSRenderRegion::FindBitmapOrigin() when no view is selected!"); if (pDocView) PelSize = (pDocView->GetPixelWidth() / pDocView->GetViewScale()).MakeDouble(); else PelSize = 750; // Subract half the Width and Height Origin.x = Centre.x - (MILLIPOINT)(0.5 + (((double)Width * PelSize)/2)); Origin.y = Centre.y + (MILLIPOINT)(0.5 + (((double)Height * PelSize)/2)); return DocCoordToWin(Origin); }

void OSRenderRegion::FlushEORCache (  void   )  [static]

Flushes the EOR colour cache. Currently called when screen mode changes Scope: Public. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 29/5/95 Parameters: -  [INPUTS] Returns: - Definition at line 1065 of file osrndrgn.cpp. { EORCache.Valid = FALSE; }

void OSRenderRegion::GetBlobRect (  FIXED16  Scale, const DocCoord &  BlobPoint, BlobType  bType, DocRect *  pResult )  [static]

To determine the DocRect of a blob without access to a render region. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 14/11/93 Parameters: Scale  - scale of view, normally DocView->GetViewScale() [INPUTS] BlobPoint - The Coord of the centre of the blob bType - the Type of Blob to draw. It can be either BT_SELECTED for a Selected point or BT_UNSELECTED for an unselected point or BT_CLICKME for the click rectangle or BT_SELECTEDLARGEST for the larger of the two selected options. pResult  - pointer to DocRect that will contain result [OUTPUTS] Karim 22/05/2000 - added BT_CLIPVIEW blobtype, which lets me return the correct size for ClipView ToolObject blobs. See also: BlobType Scope: Public Definition at line 3681 of file osrndrgn.cpp. { // ideally we would call GetScaledPixelWidth(), but that is a member fn of // OSRenderRegion as we don't have a render region, so we do similar code but // here instead. (Andy's understanding is that this only works for square pixels BTW) // Note from Tim: this function is a problem because it used to use the now defunct // OilCoord::PixelWidth() - hence we need to get a view from somewhere. We assume // that the selected DocView is a safe view to use because: // (a) Hopefully we only draw blobs into the selected view // (b) All DocViews will share the same pixel size... until we port to the Mac(!) MILLIPOINT BlobSize; DocView *pDocView = DocView::GetSelected(); ERROR3IF(pDocView == NULL, "OSRenderRegion::GetBlobRect() when no view is selected!"); // Karim 22/06/2000 - we're gonna use a double instead. Not much accuracy // is needed for PelSize, but a MILLIPOINT gives us far too little! // const MILLIPOINT PelSize = (pDocView->GetPixelWidth() / Scale).MakeLong(); const double PelSize = (pDocView->GetPixelWidth() / Scale).MakeDouble(); // All of the sizes extracted by this Switch statement are RADII. // So, for the blob to be centered correctly, the diameter of the blob will be // PIXEL_DIAMETER = 2 * RADIUS + 1 Pixel!!!!! // switch (bType) { case BT_UNSELECTED: BlobSize = (MILLIPOINT)((double)UnSelectedBlobSize * PelSize); break; case BT_SELECTED: BlobSize = (MILLIPOINT)((double)SelectedBlobSize * PelSize); break; case BT_CLICKME: BlobSize = (MILLIPOINT)((double)HitTestRadius * PelSize); break; case BT_SELECTEDLARGEST: BlobSize = max( (MILLIPOINT)((double)UnSelectedBlobSize * PelSize), (MILLIPOINT)((double)SelectedBlobSize * PelSize) ); break; case BT_MSTAGEFILLUNSELECTED: BlobSize = (MILLIPOINT)((double)MultiStageUnSelectedBlobSize * PelSize); break; case BT_MSTAGEFILLSELECTED: BlobSize = (MILLIPOINT)((double)MultiStageSelectedBlobSize * PelSize); break; case BT_MSTAGESELECTEDLARGEST: BlobSize = max( (MILLIPOINT)((double)MultiStageSelectedBlobSize * PelSize), (MILLIPOINT)((double)MultiStageUnSelectedBlobSize * PelSize) ); break; case BT_CLIPVIEW: BlobSize = (MILLIPOINT)((double)ClipViewBlobSize * PelSize); break; default: ENSURE( FALSE, "GetBlobRect() was called with an invalid BlobType" ); BlobSize = 0; // so we get an empty rectangle break; } // Build the rectangle of the appropriate size and centre it on the DocCoord given pResult->lo.x = BlobPoint.x - BlobSize - (MILLIPOINT)(PelSize/2.0); pResult->lo.y = BlobPoint.y - BlobSize - (MILLIPOINT)(PelSize/2.0); pResult->hi.x = BlobPoint.x + BlobSize + (MILLIPOINT)(PelSize/2.0); pResult->hi.y = BlobPoint.y + BlobSize + (MILLIPOINT)(PelSize/2.0); }

wxSize OSRenderRegion::GetFixedDCPPI (  wxDC &  DC  )  [static]

Fix up crazy wxWindows screen DPI calculation. Author: Alex Bligh Date: 07/01/2006 Returns: DPI in both directions as a wxSize Notes: wxWindows REALLY tries to calculate the screen DPI. By that I mean it takes the width and depth of the screen (as specified somehow to gdk by the user) in millimeters, and then divides by the pixels. Camelot needs a fixed view of the world, so on any system 100% is the same number of pixels. We use a FIXED 96dpi on Windows & Linux and, presently, on the Mac too so that documents look identical on all platforms (render same area of pixels so that comparative timings make sense). Returns: Errors: - See also: wxDC::GetPPI Definition at line 7283 of file osrndrgn.cpp. { // Set system defaults PORTNOTE("MacPort", "We should allow the user to configure this value on the mac, maybe on all platforms") #ifdef __WXMAC__ wxSize PPI(96,96); #else wxSize PPI(96,96); #endif // If it's not a Screen DC or a PaintDC we MIGHT just believe it! if (! ( DC.IsKindOf(CLASSINFO(wxScreenDC)) || DC.IsKindOf(CLASSINFO(wxPaintDC)) )) PPI=DC.GetPPI(); return PPI; }

void OSRenderRegion::GetFixedSystemTextSize (  StringBase *  TheText, DocRect *  BoundsRect, double *  atDpi = NULL )  [virtual]

To determine how much room is needed to plot a bit of text with OSRenderRegion::DrawFixedSystemText. Author: Richard_Millican (Xara Group Ltd) <camelotdev@xara.com> Date: 16/3/95 Parameters: TheText  - The string to obtain the rendered size from [INPUTS] BoundsRect  - Returned with the size of the rectangle needed to display [OUTPUTS] said text string. This rect always has one corner at (0,0) Returns: - Notes: If for any reason the call fails, an origin based rectangle with zero height and width will be returned. See also: OSRenderRegion::DrawFixedSystemText Reimplemented from RenderRegion. Definition at line 2359 of file osrndrgn.cpp. { wxString Text = (wxString)(TCHAR *)(*TheText); ERROR3IF(TheText == NULL, "OSRenderRegion::GetFixedSystemTextSize given a null text pointer"); ERROR3IF(BoundsRect == NULL, "OSRenderRegion::GetFixedSystemTextSize given a null bounds rect pointer"); if(TheText == NULL || BoundsRect == NULL) return; wxFont SaveFont=RenderDC->GetFont(); wxFont FixedFont = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT); FixedFont.SetPointSize(8); RenderDC->SetFont(FixedFont); INT32 LineHeight = 0; // This won't actually draw the text, instead it returns a rectangle in 'Rect' // LineHeight = RenderDC->DrawText((TCHAR *) (*TheText), -1, &Rect, uFormat); LineHeight = RenderDC->GetCharHeight(); wxCoord w, h; RenderDC->GetTextExtent(Text, &w, &h); wxRect Rect(0, 0, w, h); RenderDC->SetFont(SaveFont); wxDC * pDC = RenderDC; wxSize DPI = GetFixedDCPPI(*pDC); INT32 XDPI = DPI.GetWidth(); INT32 YDPI = DPI.GetHeight(); if(XDPI == 0 || YDPI == 0 || LineHeight == 0) { ERROR3("Can not calculate text size"); *BoundsRect = DocRect(0, 0, 0, 0); return; } // For some reason, Rect.bottom and Rect.top seem to be incorrect, so we have // to use the returned LineHeight value *BoundsRect = DocRect(0, 0, (INT32)(((double)Rect.width * IN_MP_VAL) / XDPI), (INT32)(((double)LineHeight * IN_MP_VAL) / YDPI) ); return; }

MILLIPOINT OSRenderRegion::GetHitTestRadius (  DocView *  pDocView  )  [static]

Allows user to adjust the sensitivity of hit-testing. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 13/6/94 Parameters: The  DocView that we are doing hit-testing in. [INPUTS] -  [OUTPUTS] Returns: The hit-test sensitivity measured in millipoints. An object with given document coordinates is considered to be clicked upon if it lies within this radius of the click position. Errors: - See also: OSRenderRegion::GetBlobRect; NodeRenderableInk::FindFirstAtPoint Definition at line 3772 of file osrndrgn.cpp. { FIXED16 fxViewScale = pDocView->GetViewScale(); FIXED16 fxPelSize = ((FIXED16) HitTestRadius) * pDocView->GetPixelWidth(); return (MILLIPOINT) (fxPelSize / fxViewScale).MakeLong(); }

void OSRenderRegion::GetRenderRegionCaps (  RRCaps *  pCaps  )  [virtual]

This function is used to help determine what an individual render region is capable of. A render can mark the things it can not render (eg transparancy) so that a more complex rendering of these parts of the document can be done. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 21/4/95 Parameters: pCaps  - the render region marks all the things it can not do into the pCaps [OUTPUTS] param Reimplemented from RenderRegion. Definition at line 6479 of file osrndrgn.cpp. { // Start off by saying I can't do anything pCaps->CanDoNothing(); // but actually I can do these things pCaps->GradFills = TRUE; pCaps->LineAttrs = TRUE; pCaps->ArrowHeads = TRUE; pCaps->DashPatterns = TRUE; // We only try simple bitmaps with GDI if printing pCaps->SimpleBitmaps = IsPrinting(); // pCaps->CanDoAll(); }

void OSRenderRegion::GetValidBrush (   )  [protected]

Definition at line 1334 of file osrndrgn.cpp. { if (!RFlags.ValidBrush) SelectNewBrush(); }

void OSRenderRegion::GetValidPen (   )  [protected]

Definition at line 1328 of file osrndrgn.cpp. { if (!RFlags.ValidPen) SelectNewPen(); }

BOOL OSRenderRegion::Init (  void   )  [static]

To be called during startup. Reads preferences. Scope: Static. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 11/3/94 Parameters: -  [INPUTS] Returns: TRUE if worked, FALSE if didnt (cannot fail at present) Reimplemented from RenderRegion. Definition at line 270 of file osrndrgn.cpp. { if (Camelot.DeclareSection(TEXT("DisplayKludges"), 10)) { Camelot.DeclarePref( NULL, TEXT("SlowRectangles"), &BodgeRectangles, FALSE, TRUE ); } if (Camelot.DeclareSection(TEXT("Printing"), 10)) { Camelot.DeclarePref( NULL, TEXT("PrintRotatedTextAsShapes"), &PrintRotatedTextAsPaths, FALSE, TRUE ); } if (Camelot.DeclareSection(TEXT("Screen"), 10)) { Camelot.DeclarePref(NULL, TEXT("GDIPalette"), &WantGDIPalette, FALSE, TRUE ); Camelot.DeclarePref(NULL, TEXT("BetterLines"), &WantBetterLines, 0, 2 ); switch (WantBetterLines) { case 0: DoBetterLines = TRUE; break; case 1: DoBetterLines = TRUE; break; case 2: DoBetterLines = FALSE; break; } } if (Camelot.DeclareSection(TEXT("Mouse"), 10)) { Camelot.DeclarePref(NULL, TEXT("HitTestRadius"), &HitTestRadius, 0, 10); } return TRUE; }

void OSRenderRegion::InitAttributes (  void   )  [protected, virtual]

Sets up a default GDI pen and brush for rendering, and calculates the Brush origin for aligned fill patterns. Scope: Private. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/93 Implements RenderRegion. Definition at line 792 of file osrndrgn.cpp. { CurrentPen = 0; CurrentBrush = 0; // OldBrush = NULL; // OldPen = NULL; OldFont = NULL; if (!RFlags.Metafile) { // Set the default font (intended for kernel-rendered dialogues) // Don't bother for metafiles (because we can't read text from them anyhow) PORTNOTE("other","OSRenderRegion::InitAttributes - removed setting of default font"); #if !defined(EXCLUDE_FROM_XARALX) wxFont* FixedSystemFont = FontFactory::GetCFont(STOCKFONT_RNDRGNFIXEDTEXT); if (FixedSystemFont != NULL) OldFont = RenderDC->SetFont(*FixedSystemFont); #endif } SetOSDrawingMode(); SetLineAttributes(); // Create a default Pen SetFillAttributes(); // Create a default Brush if (!RFlags.Metafile) { // Metafiles don't need brush origin calculations // Now we calculate the Origin for the Brush fill pattern, so that fill patterns // are always aligned as we scroll around the page. // (First we get the Origin of the Document in DocCoords) // Actually, at Jim's suggestion Andy now bases this on (0,0). DocCoord DocOrigin; DocOrigin.x = 0; //was MinDocCoord+0x20000; DocOrigin.y = 0; //was MaxDocCoord-0x20000; // f1 = f; // Then we transform it into OSCoords WinCoord OSOrigin; OSOrigin = DocCoordToWin(DocOrigin); // when running on some machine combinations, we need to further adjust the point // relative to the screen. The only combination that works is a 32-bit version // running on NT. Everyone else has to fix it up. PORTNOTE("other", "Check this"); // if (IsWin32s()) { if (RenderView) { // Get the OIL window and get it to do the conversion for us. CCamView* RenderWindow = RenderView->GetConnectionToOilView(); if ( RenderWindow!=NULL && RenderWindow->GetFrame()!=NULL ) RenderWindow->GetFrame()->ClientToScreen(OSOrigin); // In galleries, RenderView used to be NULL, so this code was never called. // This has changed, so suddenly this ensure was going off. Now it won't. //else // ERROR2RAW("No render window in OSRenderRegion::InitAttributes()"); } } // The Brush Origin is set to a value between 0 and 7 calculated from the position of the // transformed origin. NewBrushOrg.x = OSOrigin.x & 7; NewBrushOrg.y = OSOrigin.y & 7; } }

void OSRenderRegion::InitClipping (  void   )  [protected, virtual]

Creates a Windows CRgn object from the DocRect passed in the constructor. The CRgn is set as the current clipping region during reendering. Scope: Private. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 02/6/93 Implements RenderRegion. Definition at line 726 of file osrndrgn.cpp. { // OLD COMMENT and CODE: // Windows rects are slightly differnt to DocView rects so we expand them by 1 pixel //WinRect OSClipRect = DocRectToWin(CurrentClipRect, 0,0,1,1); // now the seemingly spurious 1,1s have been removed as they are indeed spurious WinRect OSClipRect = DocRectToWin(CurrentClipRect, 0,0,0,0); // ENSURE(OSClipRect.top >= 0, "Blobby!"); // This line commented out by Alex, to fix Bugzilla #991, per Neil, Gavin // ERROR3IF((OSClipRect.x < 0) || (OSClipRect.y < 0), "OSRenderRegion::InitClipping bad clip"); // we can't clip within a metafile, but we can set the origin & extent based on it // if (RFlags.Metafile) // { // RenderDC->SetWindowOrg( OSClipRect.x, OSClipRect.y ); // RenderDC->SetWindowExt( OSClipRect.width, OSClipRect.height ); // } // else { delete OSClipRegion; // This will be NULL if no previous CRgn defined. OSClipRegion = new wxRegion(OSClipRect); ENSURE(OSClipRegion != NULL,"'new' failed when creating OSClipRegion"); // Set the Clipping Region if (OSClipRegion) RenderDC->SetClippingRegion(*OSClipRegion); } }

BOOL OSRenderRegion::InitDevice (   )  [virtual]

Initialise the device specific mechanisms for this render region. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 27/05/94 Returns: TRUE if the device context is initialised ok; FALSE if not. Errors: Same as base class. See also: RenderRegion::InitDevice Reimplemented from RenderRegion. Reimplemented in PaperRenderRegion. Definition at line 656 of file osrndrgn.cpp. { // Call base class if (!RenderRegion::InitDevice()) return FALSE; // Get the HDC so we can reconstruct the CDC later. // DCHandle = RenderDC->GetSafeHdc(); // Ignore any error from GBrush initialisation - we can live without GBrush. // However, we only want GBrush on the screen thanks if (IsPrinting()) { // if we don't do this, bitmaps printed at the same DPI as the printer come // out wrong on NT drivers // Note: although this is claimed to be a Win32s-compatible function, // GDI16 generates an error for it (invalid value 4) // Note2: The MFC version of this function looks like the 16-bit API call, // so we call the API directly here //::SetStretchBltMode( RenderDC->m_hDC, HALFTONE ); } else { GDrawBrush.Init( RenderDC ); } // Find out what grad fill quality to use. PrintControl *pPrintControl = RenderView->GetPrintControl(); PrintFillQuality FillQuality; if (pPrintControl != NULL) FillQuality = pPrintControl->GetFillQuality(); else FillQuality = PRINTFILLQUALITY_MEDIUM; switch (FillQuality) { case PRINTFILLQUALITY_LOW: GradFillQuality = 2; break; case PRINTFILLQUALITY_HIGH: GradFillQuality = 0; break; case PRINTFILLQUALITY_MEDIUM: default: GradFillQuality = 1; break; } // All ok return TRUE; }

void OSRenderRegion::MakeDashType (  DashRec &  , DashType *  )  [protected]

Definition at line 2829 of file osrndrgn.cpp. { INT32 Length = KernelDash.Elements; if (Length > 8) Length = 8; GavinDash->Length = Length; GavinDash->Offset = KernelDash.DashStart; for (INT32 el = 0; el < Length; el++) { GavinDash->Array[el] = KernelDash.ElementData[el]; } }

void OSRenderRegion::MakeEllipticalPath (  Path *  pPath, DocCoord  Parallel[4] )  [static, protected]

Definition at line 4767 of file osrndrgn.cpp. { // Get an array to put the 12 different coords needed to specify an ellipse DocCoord NewCoords[12]; // Calculate the 3 coordinates along each side of the parallelogram NodeEllipse::CalcEllipseEdge(Parallel[0], Parallel[1], &NewCoords[11], &NewCoords[0], &NewCoords[1]); NodeEllipse::CalcEllipseEdge(Parallel[1], Parallel[2], &NewCoords[2], &NewCoords[3], &NewCoords[4]); NodeEllipse::CalcEllipseEdge(Parallel[2], Parallel[3], &NewCoords[5], &NewCoords[6], &NewCoords[7]); NodeEllipse::CalcEllipseEdge(Parallel[3], Parallel[0], &NewCoords[8], &NewCoords[9], &NewCoords[10]); // build a path pPath->ClearPath(); pPath->FindStartOfPath(); // Start at bottom left corner PathFlags NewFlags; NewFlags.IsRotate = TRUE; pPath->InsertMoveTo(NewCoords[0], &NewFlags); pPath->InsertCurveTo(NewCoords[1], NewCoords[2], NewCoords[3], &NewFlags); pPath->InsertCurveTo(NewCoords[4], NewCoords[5], NewCoords[6], &NewFlags); pPath->InsertCurveTo(NewCoords[7], NewCoords[8], NewCoords[9], &NewFlags); pPath->InsertCurveTo(NewCoords[10], NewCoords[11], NewCoords[0], &NewFlags); // Close the path properly pPath->CloseSubPath(); }

INT32 OSRenderRegion::MPtoLP (  MILLIPOINT  MPtoConvert  )  [protected]

Converts a value in MilliPoints into a GDI Logical value. IT ASSUMES A MM_TEXT MAPPING MODE AT PRESENT. Scope: Private. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 28/5/93 Parameters: MPtoConvert  is a value in MILLIPOINTS [INPUTS] Returns: The size in logical units Definition at line 3204 of file osrndrgn.cpp. { MILLIPOINT PixelWidth = GetScaledPixelWidth(); return INT32(MPtoConvert/PixelWidth); // Note this assumes MM_TEXT mapping mode }

INT32 OSRenderRegion::RawRenderPath (  DocCoord * const  Coords, PathVerb * const  Verbs, INT32  NumCoords, INT32 *  PolyCounts, INT32 *  ResCount, INT32  Flatness = 0, INT32 *  pActualFlatness = NULL )  [protected]

Low level primitive for rendering paths without GDI32. Note that PointArray should be freed by the caller upon completion. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 20/4/94 Parameters: A  path to be drawn (in DocCoords). [INPUTS] Flatness - the value to use when flattening a curve. pActualFlatness - if the caller wants to know what flatness was eventually reached while flattening the path, it passes in a pointer here to be filled in. If the path could not be flattened, this contains the last flatness level that was tried before giving up. PolyCounts  must point to an array of MAX_POLYGONS ints which will be filled [OUTPUTS] in with a list of polygon sizes (can be just 1 big if ResCount is NULL). ResCount will be updated with the number of polygons. If it is NULL then the routine returns after the end of the first sub-path has been found. The points calculated from this will be in the PointArray variable. Returns: Number of points read, 0 if failed (e.g. not enough memory or too complex). Errors: - Scope: Private See also: RawRenderPath32 Definition at line 2438 of file osrndrgn.cpp. { // Flatness less than 0 will screw up, so let's ignore it if (Flatness < 0) return 0; // We have to manually flatten the beziers in the curve and decide when to draw them. INT32 MaxFlatness; // Decide how flat we are going to make this curve, if the caller has not specified if (Flatness == 0) { // (Tim says: these figures are a bit arbitrary, especially the MaxFlatness ones) if (RFlags.Metafile) { #if !defined(EXCLUDE_FROM_RALPH) && !defined(EXCLUDE_FROM_XARALX) // If this is a Metafile view then go and find out the flatness if (RenderView->IS_KIND_OF(MetafileView)) Flatness = ((MetafileView*)RenderView)->GetMetafileFlatness(); else #endif Flatness = 512; } else { Flatness = CalcPathFlattening(); } } MaxFlatness = Flatness * 8; // The number of polygons found so far INT32 Count = 0; // The number of points that have been placed in complete polygons INT32 PointsSoFar = 0; // Position we are reading points from INT32 ReadPos = 0; // Flatten curve until it works or flatness becomes too inaccurate. BOOL Worked = FALSE; while (!Worked && (Flatness <= MaxFlatness) &&(Flatness > 0)) { // Position we are adding points at InsertPos = 0; ReadPos = 0; Count = 0; PointsSoFar = 0; Worked = TRUE; BOOL KeepGoing = TRUE; // loop through the whole path while ( KeepGoing && (ReadPos < NumCoords) && Worked ) { if ( InsertPos >= SIZEOF_POLYLINE_BUFFER ) { // this check is enough for those times when CurrentPoint is simply incrememented, // but is insufficient when it is increased by more than one, so additional checks // are needed elsewhere TRACE( _T("Path too complex to flatten\n")); InsertPos = 0; Worked = FALSE; break; } // Find out the type of element that we are over (after the close flag has been removed) Coord P[4]; INT32 OldInsertPos; switch ( (Verbs[ReadPos]) & (~PT_CLOSEFIGURE) ) { case PT_MOVETO: // This represents the start of a new polygon, so finish the last one if (InsertPos>0) { // We have put points into the polygon, so this is not the first one PolyCounts[Count] = InsertPos - PointsSoFar; // Keep tabs on how many points have been put in polygons so far PointsSoFar = InsertPos; // Count the number of polygons Count++; // Make sure its not too many if (Count == MAX_POLYGONS) { TRACE( _T("Too many polygons in path to render\n") ); InsertPos = 0; Worked = FALSE; break; } if (ResCount==NULL) { // sub-path has ended, stop the loop now KeepGoing = FALSE; break; } } // Put the MoveTo into the point array PointArray[InsertPos] = DocCoordToWin(Coords[ReadPos]); InsertPos++; ReadPos++; break; case PT_LINETO: // Put the LineTo into the point array PointArray[InsertPos] = DocCoordToWin(Coords[ReadPos]); InsertPos++; ReadPos++; break; case PT_BEZIERTO: // If this point is a bezier, then the next 2 points should be beziers to ENSURE((Verbs[ReadPos+1]) & (~PT_CLOSEFIGURE), "Bezier found with 1 point"); ENSURE((Verbs[ReadPos+2]) & (~PT_CLOSEFIGURE), "Bezier found with 2 points"); // Make sure that this is not at the start of the path ENSURE(ReadPos>0, "Broken path found while flattening" ); OldInsertPos = InsertPos; // Flatten the bezier out P[0] = DocCoordToOS256(Coords[ReadPos-1]); P[1] = DocCoordToOS256(Coords[ReadPos]); P[2] = DocCoordToOS256(Coords[ReadPos+1]); P[3] = DocCoordToOS256(Coords[ReadPos+2]); if (!Bezier(P[0].x,P[0].y, P[1].x,P[1].y, P[2].x,P[2].y, P[3].x,P[3].y, Flatness)) { // Not enough room to flatten bezier. Worked = FALSE; break; } // If the curve was already flat then check to see if the curve was a vertical // or horizontal line. If it was then ensure the coords are the same to avoid kinks. if (InsertPos == OldInsertPos+1) { if (Coords[ReadPos-1].x == Coords[ReadPos+2].x) PointArray[OldInsertPos].x = PointArray[OldInsertPos-1].x; if (Coords[ReadPos-1].y == Coords[ReadPos+2].y) PointArray[OldInsertPos].y = PointArray[OldInsertPos-1].y; } // Update the positions and break // InsertPos is updated by the bezier functions as the number of points // that they add depends on the curve ReadPos+=3; break; default: ENSURE( FALSE, "We found a Path Element that does not exist!" ); break; } if (ResCount==NULL) { // caller wants sub-paths, better check for close markers if (Verbs[ReadPos-1] & PT_CLOSEFIGURE) KeepGoing = FALSE; } } // Increase flatness in case we need to try again. Flatness *= 2; } if (!Worked) { // oops - didn't work } // complete the information about the last polygon in the list else if (InsertPos>0) { PolyCounts[Count] = InsertPos - PointsSoFar; Count++; if (ResCount) *ResCount = Count; } else { if (ResCount) *ResCount = 0; else { ENSURE(FALSE, "strange short path"); Worked = FALSE; // don't use incomplete data } } // Tell the caller what flatness we used if necessary if (pActualFlatness != NULL) *pActualFlatness = Flatness; // return value is number of verb/coord pairs read. return Worked ? ReadPos : 0; }

BOOL OSRenderRegion::RawRenderPath32 (  Path *  const  )  [protected]

Definition at line 6347 of file osrndrgn.cpp. { PORTNOTETRACE("other","OSRenderRegion::RawRenderPath32 - do nothing"); #ifndef EXCLUDE_FROM_XARALX BOOL Worked; // Find out some details about the path and fail if it is not valid INT32 NumCoords = DrawPath->GetNumCoords(); ENSURE(NumCoords>0, "Tried to draw a path with no elements in it in OSRenderRegion::RawRenderPath32"); if (NumCoords==0) return FALSE; // Find out about the coords DocCoord* Coords = DrawPath->GetCoordArray(); // ideally this would be new POINT[NumCoords] but it can't be because that throws an exception POINT* NTCoords = (POINT*)CCMalloc( sizeof(POINT)*NumCoords ); if (NTCoords==NULL) { TRACE( _T("No memory to convert curve\n") ); return FALSE; } // Convert the points to windows coords for (INT32 i=0; i<NumCoords; i++) NTCoords[i] = DocCoordToWin(Coords[i]); // render them Worked = BeginPath( RenderDC ); if (Worked) { Worked = NewPolyDraw( NTCoords, DrawPath->GetVerbArray(), NumCoords ); if (Worked) Worked = EndPath( RenderDC ); } CCFree( NTCoords ); if (!Worked) TRACE( _T("Raw render32 failed")); return Worked; #else ENSURE(FALSE, "Raw32 cannot work on win16"); return FALSE; #endif }

BOOL OSRenderRegion::RenderBitmapFill (  Path *  PathToDraw, BitmapFillAttribute *  Fill )

Render bitmap fills clipped through a path. BODGED to simple plot the bitmap. Scope: Public. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 10/8/94 Parameters: A  path to render and a bitmap fill attribute. [INPUTS] -  [OUTPUTS] Returns: Errors: - TRUE if worked, FALSE if failed. Definition at line 4321 of file osrndrgn.cpp. { if (Fill->GetBitmap() == NULL || Fill->GetBitmap()->ActualBitmap == NULL) return FALSE; // if no bitmap // if rendering to a bitmap, return FALSE so it is rendered solid. Test should be in // caller code in RenderBitmapFillAttribute but here is OK for now. if ((RenderFlags.VeryMono) || (RFlags.Metafile)) return FALSE; ENSURE( Fill->GetBitmap()->ActualBitmap->IsKindOf( CC_RUNTIME_CLASS( CWxBitmap ) ), "Strange bitmapfill"); // Since the GDI cannot cope with anything other than very simple bitmaps, // we will get GDraw to render the bitmap into a screen compatible DIB, and // then get the GDI to plot that GDrawContext* GD = GRenderRegion::GetStaticDrawContext(); CWxBitmap *WxBM = NULL; CWxBitmap *OrigWxBM = NULL; const INT32 bpp = Fill->GetBitmap()->GetBPP(); BYTE *pGreyTable = NULL; if (Fill->GetStartColour() != NULL && Fill->GetEndColour() != NULL) { // The bitmap is contoned ... so we need to use the greyscale version WxBM = (CWxBitmap*)Fill->GetBitmap()->GetGreyscaleVersion(); if (WxBM == NULL && bpp == 8) { // Aha, we're gunna do some clever palette jiggery pokery pGreyTable = Fill->GetBitmap()->ActualBitmap->GetGreyscaleTable(); } } // Now make sure that if the WinBitmap is 32 that we RENDER it into a tempory FULLY TRANSPARENT WHITE BMP. // This stops the CONVERT function later on stripping the alpha channel off producing solid, non-transparent // coloured objects on black black backgrounds! - MarkH 20/7/99. if (WxBM == NULL) { if (bpp != 32) { WxBM = (CWxBitmap*)Fill->GetBitmap()->ActualBitmap; } else { WxBM = (CWxBitmap*)CBMPBits::RenderBMPFillAttrToTransparentWhiteRect(Fill); } } if (!WxBM) // we really should check this pointer! { return (FALSE); } if( (WxBM->BMInfo==NULL) || (WxBM->BMBytes==NULL) ) return FALSE; // Work out what Tempory bitmap we need // Note we are forcing the bitmap to be a horizontal rectangular bitmap, // as the GDI can't cope with rotating them wxPoint BottomLeft = DocCoordToWin( Fill->StartPoint ); wxPoint BottomRight = DocCoordToWin( Fill->EndPoint ); wxPoint TopLeft = DocCoordToWin( Fill->EndPoint2 ); INT32 DestWidth = BottomRight.x - BottomLeft.x; INT32 DestHeight = BottomLeft.y - TopLeft.y; if (DestWidth==0 || DestHeight==0) { return TRUE; } if (IsPrinting()) { if (CurrentColContext->GetColourPlate() == NULL || CurrentColContext->GetColourPlate()->IsDisabled()) { PORTNOTE("other", "No StretchDIBits call in OSRenderRegion::RenderBitmapFill") #ifndef EXCLUDE_FROM_XARALX // going to a printer? - let its driver stretch it about etc const LPBITMAPINFO bmInfo = WxBM->BMInfo; #if 1 // this is the correct legit code const BOOL SendDirectToPrinter = true; #else // test code const BOOL SendDirectToPrinter = RFlags.Metafile; // only metafiles #endif if (SendDirectToPrinter) { // pass bitmap straight to driver. Might have to band this call // up on low-capacity machines at some point. Also does this for // metafiles too. StretchDIBits( RenderDC->m_hDC, BottomLeft.x, TopLeft.y, // dest XY DestWidth, DestHeight, // dest WH 0,0, // source 0,0 bmInfo->bmiHeader.biWidth, // source W bmInfo->bmiHeader.biHeight, // source H WinBM->BMBytes, bmInfo, DIB_RGB_COLORS, SRCCOPY ); return TRUE; } #endif // if 16- or 32-bit, leave for later. We get Gavin to scale it to an output bitmap // then PlotDeepDIB it. Sadly, this requires serious amounts of RAM, so is prone // to failure. The solution would be a ScaleDeepDIB call, like PlotDeepDIB but // that can scale appropriately. Such a function would then be called here, avoiding // the need for a huge intermediate bitmap } } // Setup a default matrix (we'll do everything in pixel-speak) GMATRIX GMatrix; GMatrix.AX = 1<<(16 + FX); GMatrix.AY = 0; GMatrix.BX = 0; GMatrix.BY = 1<<(16 + FX); GMatrix.CX = 0; GMatrix.CY = 0; // Create a Tempory bitmap compatible with the output device LPBITMAPINFO TempInfo; LPBYTE TempBits; INT32 DeviceDepth; if (IsPrinting()) { // if printing, always convert to 24-bit (which as Gavin can't do 24- means 32-bit) // as all drivers can handle those (source bitmap only 16- or 32-bit anyway) DeviceDepth = 32; } else { PORTNOTE("other", "Assume 24 bit output device in OSRenderRegion::RenderBitmapFill") #ifndef EXCLUDE_FROM_XARALX DeviceDepth = GetDeviceCaps( RenderDC->m_hDC, BITSPIXEL ) * GetDeviceCaps( RenderDC->m_hDC, PLANES ); #else DeviceDepth=24; // assume true colour #endif if (DeviceDepth ==24) DeviceDepth = 32; // GDraw cannot plot to 24-bit bitmaps } TempInfo = AllocDIB(DestWidth, DestHeight, DeviceDepth, &TempBits); if (TempInfo==NULL) { TRACEALL( _T("Out of memory during OSRenderRegion::RenderBitmapFill") ); return FALSE; } // We may need to get a palette for the DIB. UINT32 DIBPal = DIB_RGB_COLORS; if (DeviceDepth <= 8) // We only need a palette for 256 colours or less. { DIBPal = GRenderRegion::SetPaletteEntries( TempInfo, RenderDC ); } // Setup GDraw with our Tempory Bitmap and Identity Matrix GD->SetupBitmap(TempInfo->bmiHeader.biWidth, TempInfo->bmiHeader.biHeight, TempInfo->bmiHeader.biBitCount, TempBits ); GD->SetMatrix( &GMatrix ); COLORREF DefaultColour = 0xFFFFFFFF; // --- Colour-correct and/or Contone the bitmap as necessary RGBQUAD *Palette = NULL; // Do the colour correction. This may produce a new pointer in Palette or BitmapBits, // which we should CCFree() when we are done with it - see the end of this function ColourCorrectBitmap(Fill, WxBM->BMInfo, &Palette); // Now see if we need to muck around with the palette for the contoning if (pGreyTable != NULL) { ERROR3IF(bpp != 8, "Greytable should only be here when rendering an 8bpp bitmap"); RGBQUAD *OldPalette = Palette; // Create a new palette Palette = (RGBQUAD *) CCMalloc(256 * sizeof(RGBQUAD)); if (Palette == NULL) { ERROR3("No memory for palette"); return FALSE; } // Copy the entries from the contone palette into the new one, // using the Grey table as a guide for (INT32 i=0; i<256; i++) { Palette[i] = OldPalette[pGreyTable[i]]; } if (OldPalette != WxBM->BMInfo->bmiColors) CCFree(OldPalette); // Don't need the contone palette any more } // If we didn't create a temporary palette, then we'll use the original bitmap if (Palette == NULL) Palette = WxBM->BMInfo->bmiColors; // Search for a transparent colour setting the Style flags if necessary... if (bpp <= 8) { INT32 NumCols; switch (bpp) { case 1: NumCols = 2; break; case 2: NumCols = 4; break; case 4: NumCols = 16; break; case 8: NumCols = 256; break; default: NumCols = 256; break; } for (INT32 i=0; i<NumCols; i++) { if (Palette[i].rgbReserved == 0xFF) { RGBQUAD* TempPalette = (RGBQUAD*)CCMalloc(NumCols * sizeof(RGBQUAD)); if (TempPalette) { // We'll use a copy of the palette ... memcpy(TempPalette, Palette, NumCols*sizeof(RGBQUAD)); // so we can force this entry to be white TempPalette[i].rgbRed = 0xFF; TempPalette[i].rgbGreen = 0xFF; TempPalette[i].rgbBlue = 0xFF; Palette = TempPalette; break; } } } } // Now set the bitmap fill POINT PGram[3]; PGram[0].x = 0; PGram[0].y = 0; PGram[1].x = DestWidth; PGram[1].y = 0; PGram[2].x = 0; PGram[2].y = DestHeight; DWORD Style = 1; BOOL bDoBitmapFill = TRUE; BYTE* pSepTables = NULL; BGR *pCyanSepTable = NULL; BGR *pMagentaSepTable = NULL; BGR *pYellowSepTable = NULL; BGR *pBlackSepTable = NULL; BYTE *pUnderColourRemovalTable = NULL; BYTE *pBlackGenerationTable = NULL; CWxBitmap* pNewBitmap = NULL; PORTNOTE("other", "No colour separation OSRenderRegion::RenderBitmapFill") #ifndef EXCLUDE_FROM_XARALX // --- Add Separation Style bits as approriate to the current colour separation mode if (bpp > 8) // Only needed for deep bitmaps { // If we've got a valid colour plate and it is a composite preview if (CurrentColContext->GetColourPlate() != NULL && !CurrentColContext->GetColourPlate()->IsDisabled()) { if (CurrentColContext->GetColourPlate()->GetType() == COLOURPLATE_COMPOSITE) { // Fall through (shouldn't be used at the moment) } else if (CurrentColContext->GetColourPlate()->GetType() == COLOURPLATE_SPOT) { GD->SetColour(0xFFFFFF); bDoBitmapFill = FALSE; } else if (CurrentColContext->GetColourPlate()->GetType() != COLOURPLATE_NONE) { // Create a colour separated copy of the bitmap and render that instead pSepTables = (BYTE *) CCMalloc(5 * 256 * sizeof(BYTE)); if (pSepTables != NULL) { XaraCMS* lpCMSMan = GetApplication()->GetCMSManager(); String_256 PrintProfile; if (lpCMSMan) lpCMSMan->GetPrinterProfile(&PrintProfile); ColourContextCMYK *cc = new ColourContextCMYK(RenderView, &PrintProfile); if (cc->GetProfileTables(pSepTables)) { // Make a copy of the bitmap pNewBitmap = (CWxBitmap*)WxBM->MakeSeparatedCopy(RenderView->GetColourPlate(), pSepTables); OrigWxBM = WxBM; // Save original bitmap pointer WxBM = pNewBitmap; // Use this bitmap instead } delete cc; } } } } #endif // Set the context to the default values GD->SetDefaultBitmapParameters(); GD->SetTileSmoothingFlag(TRUE/*FALSE*/); GD->SetTileFilteringFlag(TRUE/*FALSE*/); if (bDoBitmapFill) { GD->SetBitmapFill( &(WxBM->BMInfo->bmiHeader), WxBM->BMBytes, Style, PGram, DefaultColour, Palette, NULL, NULL, NULL, NULL, 0 ); } // Now plot a filled rectangle RECT BmpRect; BmpRect.left = 0; BmpRect.top = DestHeight; BmpRect.right = DestWidth; BmpRect.bottom = 0; GD->FillRectangle(&BmpRect); if (IsPrinting()) { // we are going to the printer. We had a 16- or 32-bit DIB which we have now converted // into a 32-bit one, so send it out // PlotDeepDIB ends up doing a SetDIBitsToDevice in 24-bit slices DIBUtil::PlotDeepDIB( RenderDC, TempInfo, TempBits, BottomLeft.x, TopLeft.y, DestWidth,DestHeight, 0,0, CONVHINT_PRINTER ); } else { // get the HPALETTE to pass to the plot bitmap call - crucial for quality Win32s DDB plotting wxPalette * hPal = NULL; if (RFlags.UsePalette) hPal = PaletteManager::GetPalette(); // Finally call PlotBitmap, to render the DIB using the GDI. // If the screen cannot cope with the depth of the bitmap, it will be converted // for us. Isn't PlotBitmap wonderful? GRenderRegion::StaticPlotBitmap( RenderDC, DIBPal, TempInfo, TempBits, BottomLeft.x, TopLeft.y, DestWidth, DestHeight, hPal, 0,0 ); } FreeDIB(TempInfo, TempBits); if (pNewBitmap) { WxBM = OrigWxBM; delete pNewBitmap; } // Free any memory used for colour-corrected bitmap palettes. // If this pointer doesn't point at the original palette, then it has // been temporarily allocated by ColourCorrectBitmap, above. if (Palette != WxBM->BMInfo->bmiColors) CCFree(Palette); if (pSepTables) { GD->SetSeparationTables(); // Defaults to setting everything to NULL CCFree(pSepTables); } if (pCyanSepTable) CCFree(pCyanSepTable); if (pMagentaSepTable) CCFree(pMagentaSepTable); if (pYellowSepTable) CCFree(pYellowSepTable); if (pBlackSepTable) CCFree(pBlackSepTable); if (pUnderColourRemovalTable) CCFree(pUnderColourRemovalTable); if (pBlackGenerationTable) CCFree(pBlackGenerationTable); return TRUE; }

BOOL OSRenderRegion::RenderChar (  WCHAR  ch, Matrix *  pMatrix )  [virtual]

Render a character, using the specified transform and current attributes in the render region. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/4/95 Parameters: ch  - unicode value of char [INPUTS] pMatrix - matrix specifying transforms to place char correctly in document Returns: FALSE if fails Reimplemented from RenderRegion. Definition at line 6963 of file osrndrgn.cpp. { PORTNOTETRACE("text","OSRenderRegion::RenderChar - do nothing"); #ifndef EXCLUDE_FROM_XARALX // If it is stroked or not simple flat fill, or not a standard ASCII character then we // must do this as paths. Graham 8/8/96: And now UNICODE works too. BOOL FlatFill = IS_A(CurrentAttrs[ATTR_FILLGEOMETRY].pAttr, FlatFillAttribute); if (!FlatFill || !RR_STROKECOLOUR().IsTransparent() || (FlatFill & RR_FILLCOLOUR().IsTransparent())) return RenderRegion::RenderChar(ch, pMatrix); if (IsPrinting()) { // Check for emulsion down printing, GDI cannot render text backwards PrintControl *pPrintCtl; View *pView = GetRenderView(); if (pView && (pPrintCtl=pView->GetPrintControl())) { if (pPrintCtl->GetTypesetInfo()->PrintEmulsionDown()) return RenderRegion::RenderChar(ch, pMatrix); } } // get overall matrix - attribute matrix concatenated with given matrix if supplied Matrix matrix; if (GetCharAttributeMatrix(&matrix)==FALSE) return NULL; if (pMatrix) matrix*=*pMatrix; // Can we do this using a GDI font? // We can if the matrix only specifies scaling and translation FIXED16 abcd[4]; INT32 ef[2]; matrix.GetComponents(abcd, ef); // GDI can't do y-axis flips, so we do it as shapes if this is detected (and x-axis // flips, for consistency). if ((abcd[0] < FIXED16(0)) || (abcd[3] < FIXED16(0))) { // Flipped in one or both axes - render as a path. return RenderRegion::RenderChar(ch, pMatrix); } // Work out how complex the transformation is. FIXED16 ScaleX = 0; FIXED16 ScaleY = 0; ANGLE Rotation = 0; ANGLE Shear = 0; if ((abcd[1] == FIXED16(0)) && (abcd[2] == FIXED16(0)) && (abcd[0] >= FIXED16(0)) && (abcd[3] >= FIXED16(0))) { // Simple scaling transformation. ScaleX = abcd[0]; ScaleY = abcd[3]; Rotation = FIXED16(0); Shear = FIXED16(0); } else { // Decompose the matrix to find out how complex it is. // Pass in NULL for translation as we already know it is in 'ef'. FIXED16 Aspect; BOOL Result = matrix.Decompose(&ScaleY, &Aspect, &Rotation, &Shear, NULL); if (!Result || (Shear != FIXED16(0))) // Either there was a problem, or the character is sheared, in which case // we can't do it with GDI. return RenderRegion::RenderChar(ch, pMatrix); // Set up the ScaleX based on the aspect ratio ScaleX = ScaleY * Aspect; } // Check for sideways printing - if the render matrix has rotation, then we are // printing at 270 degrees rotation, so adjust the rotation accordingly. FIXED16 RenderABCD[4]; INT32 RenderEF[2]; RenderMatrix.GetComponents(RenderABCD, RenderEF); if ((RenderABCD[1] != FIXED16(0)) || (RenderABCD[2] != FIXED16(0))) // Rotate by 270 degrees (angle is in radians) Rotation += FIXED16(1.5 * PI); // Work out required width and height of the font MILLIPOINT ReferenceSize = TextManager::GetDefaultHeight(); MILLIPOINT Width = ReferenceSize * ScaleX; MILLIPOINT Height = ReferenceSize * ScaleY; if (!SelectNewFont(RR_TXTFONTTYPEFACE(), RR_TXTBOLD(), RR_TXTITALIC(), Width, Height, Rotation)) { // Could not select font (maybe because device can't rotate fonts) return RenderRegion::RenderChar(ch, pMatrix); } // First, set up the text attributes that are not encoded in the font. UINT32 OldTextAlign = RenderDC->SetTextAlign(TA_BASELINE); INT32 OldBKMode = RenderDC->SetBkMode(TRANSPARENT); COLORREF OldTextColor = RenderDC->SetTextColor(ConvertColourToScreenWord(CurrentColContext, &RR_FILLCOLOUR())); // Render the character in the specified position DocCoord DocPos(ef[0], ef[1]); WinCoord WinPos = DocCoordToWin(DocPos); // Graham 5/8/96: "ch" is presently in UNICODE or ASCII // We need to convert it over to MBCS to deal with Japanese strings //So convert ch, which is of form WCHAR, over to a MBCS UINT32 character index UINT32 uiCharNumber = UnicodeManager::UnicodeToMultiByte(ch); //Now we want to put that UINT32 value into an array of char ready to pass to //RenderDC->TextOut. We do this using UnicodeManager::DecomposeMultiBytes BYTE bCharArray[2]; UnicodeManager::DecomposeMultiBytes(uiCharNumber, &bCharArray[0], &bCharArray[1]); //Now, is the character in bCharArray one or two bytes long? //If it is one byte long, the first byte in bCharArray will be zero. if (bCharArray[0]==0) //It's a standard ASCII character, one byte long //So pass that character (bCharArray[1]) to the TextOut function. //The last parameter in text out is the number of bytes - in this case 1. RenderDC->TextOut(WinPos.x, WinPos.y, (CHAR*) &bCharArray[1], 1); else //The character is two bytes long (that is, it's a foreign character) //So we pass bCharArray[0] to TextOut and tell TextOut that it should //use two bytes from that address. We do this by setting the last //parameter to 2. RenderDC->TextOut(WinPos.x, WinPos.y, (CHAR*) &bCharArray[0], 2); // Clean up text attributes RenderDC->SetTextAlign(OldTextAlign); RenderDC->SetBkMode(OldBKMode); RenderDC->SetTextColor(OldTextColor); #elif !defined(DISABLE_TEXT_RENDERING) return RenderRegion::RenderChar(ch, pMatrix); #endif return TRUE; }

BOOL OSRenderRegion::RenderConicalFill (  Path *  PathToDraw, ConicalFillAttribute *  Fill )  [protected]

Renders the path with a gradient fill. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com>? Rik? Tim? Date: ? Parameters: PathToDraw  - A pointer to the path to be rendered. [INPUTS] Fill - A pointer to the radial fill applied. Returns: TRUE - Success. FALSE - An error occured. Definition at line 5542 of file osrndrgn.cpp. { GradFillMethodType RenderMethod = GF_USE_GDICLIPPING; // First, we need to find out the minimum radius of the circle we can // plot and still fill the entire shape. // To do this we find the maxiumum distance between the start point and all four // corners of the bounding box. DocRect BoundsRect = PathToDraw->GetBoundingRect(); DocCoord TestPoint = BoundsRect.lo; INT32 Radius = CalcDistance(Fill->StartPoint, TestPoint); TestPoint.x = BoundsRect.hi.x; INT32 NewRadius = CalcDistance(Fill->StartPoint, TestPoint); Radius = max(Radius, NewRadius); TestPoint = BoundsRect.hi; NewRadius = CalcDistance(Fill->StartPoint, TestPoint); Radius = max(Radius, NewRadius); TestPoint.x = BoundsRect.lo.x; NewRadius = CalcDistance(Fill->StartPoint, TestPoint); Radius = max(Radius, NewRadius); // Radius now holds the minimum radius we can use. // We want to change the rendering context, so we save it. SaveContext(); // No stroking while rendering the fill. SetLineColour(COLOUR_TRANS); // Use device pixel size to work out how many steps to do. FIXED16 PixelSize = 0; GetRenderView()->GetScaledPixelSize(&PixelSize,&PixelSize); INT32 FillSteps = (INT32) ((Radius * 2 * PI) / PixelSize.MakeDouble()); // Do a slice every 4 pixels (arbitrary!) FillSteps /= 4; // Also base it on distance between colours EFFECTTYPE EffectType = GetFillEffect(); FillSteps = min(ColDifference(Fill->Colour, Fill->EndColour, IsPrinting() ? 24 : 8, // Colour depth EffectType), FillSteps); // Limit fill steps to a maximum FillSteps = min( FillSteps, INT32(MAX_FILL_STEPS) ); // Use global Quality setting FillSteps = FillSteps / (1 << GradFillQuality); // Note that with a conical fill we fade from the start colour to the end colour // and then back to the start colour, so we only need half as many fill steps as you // might think. FillSteps /= 2; // Limit to minimum of 10 steps FillSteps = max(FillSteps, 10); // Work out what flatness and accuracy to use for Gavin's clipping functions. // Gavin recommends 1/2 pixel for flattening, and 1/4 pixel for tolerance // (but these were kind of off the top of his head - Tim). // PS. It seems we need maximum tolerance (i.e. 0) for accurate grad-fill rendering. INT32 ClipFlatness = PixelSize.MakeLong() / 16; INT32 ClipTolerance = 0; RGBQUAD ColourSteps[MAX_FILL_STEPS]; GradTable32::BuildGraduatedPalette(Fill->Colour, Fill->EndColour, GetRenderView(), EffectType, FillSteps, ColourSteps); // If we are rendering into a metafile, clip the path ourselves if (RFlags.Metafile) { RenderMethod = GF_USE_GAVINCLIPPING; } else { if (!SetClipToPathTemporary(PathToDraw)) { // Can't use clipping - fall back to EOR. RenderMethod = GF_USE_GDIEOR; } } INT32 RenderCount = 1; if (RenderMethod == GF_USE_GDIEOR) { SetDrawingMode(DM_EORDITHER); RenderCount = 2; } DocColour TempFillColour; while (RenderCount > 0) { COLORREF CurrentCol = RGB(ColourSteps[FillSteps - 1].rgbRed, ColourSteps[FillSteps - 1].rgbGreen, ColourSteps[FillSteps - 1].rgbBlue); // Put the RGB value back into a DocColour so we can set it as the fill colour. We set it // as non-separable, as it will have already been colour-separated by BuildGraduatedPalette TempFillColour.SetRGBValue(ColourSteps[FillSteps - 1].rgbRed, ColourSteps[FillSteps - 1].rgbGreen, ColourSteps[FillSteps - 1].rgbBlue); TempFillColour.SetSeparable(FALSE); SetFillColour(TempFillColour); GetValidBrush(); GetValidPen(); // This is the path we will use to create conical fills. Path ConicalFill; ConicalFill.Initialise(12,12); // This is the path we use for all clipped rendering. Path ClippedPath; ClippedPath.Initialise(12, 12); double FillAngle = atan2((double)(Fill->EndPoint.x - Fill->StartPoint.x), (double)(Fill->EndPoint.y - Fill->StartPoint.y)); double AngleInc = PI / FillSteps; // Actually (2 * PI) / (2 * FillSteps) TestPoint.x = Fill->StartPoint.x + (INT32) (((double) Radius) * sin(FillAngle)); TestPoint.y = Fill->StartPoint.y + (INT32) (((double) Radius) * cos(FillAngle)); // Now render the fill using radiating triangles. INT32 FillInc = -1; // NB. This loop is unusual because we loop from FillSteps down to 0 and back // up to FillSteps - because that's how conical fills work. for (INT32 i = FillSteps - 1; i <= FillSteps; i += FillInc) { ConicalFill.ClearPath(); ConicalFill.FindStartOfPath(); // Create a triangle PathFlags NewFlags; NewFlags.IsRotate = TRUE; ConicalFill.InsertMoveTo(Fill->StartPoint, &NewFlags); ConicalFill.InsertLineTo(TestPoint, &NewFlags); FillAngle += AngleInc; TestPoint.x = Fill->StartPoint.x + (INT32) (((double) Radius) * sin(FillAngle)); TestPoint.y = Fill->StartPoint.y + (INT32) (((double) Radius) * cos(FillAngle)); ConicalFill.InsertLineTo(TestPoint, &NewFlags); // Close the path properly ConicalFill.CloseSubPath(); ConicalFill.IsFilled = TRUE; if (RenderMethod != GF_USE_GAVINCLIPPING) { RenderPath(&ConicalFill); } else { PathToDraw->ClipPathToPath(ConicalFill, &ClippedPath, 2, ClipTolerance, ClipFlatness, ClipFlatness); ClippedPath.IsFilled = TRUE; RenderPath(&ClippedPath); } // decrement loop counter here so that the next colour can be calculated if (i <= 0) // We need to start going the other way! FillInc = 1; // Calculate next brush if (i != FillSteps) { const COLORREF NewFill = RGB(ColourSteps[i].rgbRed, ColourSteps[i].rgbGreen, ColourSteps[i].rgbBlue); if (NewFill != CurrentCol) { // colour changed, make new brush CurrentCol = NewFill; // Put the RGB value back into a DocColour so we can set it as the fill colour. We set it // as non-separable, as it will have already been colour-separated by BuildGraduatedPalette TempFillColour.SetRGBValue(ColourSteps[i].rgbRed, ColourSteps[i].rgbGreen, ColourSteps[i].rgbBlue); TempFillColour.SetSeparable(FALSE); SetFillColour(TempFillColour); GetValidBrush(); GetValidPen(); } } } if ((RenderMethod == GF_USE_GDIEOR) && (RenderCount > 1)) { // Render the path in white SetDrawingMode(DM_COPYPEN); SetFillColour(COLOUR_BLACK); SetLineColour(COLOUR_TRANS); GetValidBrush(); GetValidPen(); RenderPath(PathToDraw); // Set back to mode required for grad fill rendering SetDrawingMode(DM_EORDITHER); } RenderCount--; } // now tidy up RestoreContext(); GetValidBrush(); GetValidPen(); // Lose the clipping region if we are using one. if (RenderMethod == GF_USE_GDICLIPPING) RenderDC->SetClippingRegion(*OSClipRegion); return TRUE; }

BOOL OSRenderRegion::RenderFourColFill (  Path *  PathToDraw, FourColFillAttribute *  Fill )  [protected]

Renders a four colour gradient fill to a Windows DC. This is done by breaking the fill up into a large number of tiles, and then applying these with the colour at that point of the fill. This is in common with the other fills, and much of the code in this function has been derived from the other fill rendering functions. Author: Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com> Date: 7/6/00 Parameters: PathToDraw  - A pointer to the path to be rendered. [INPUTS] Fill - A pointer to the radial fill applied. Returns: TRUE - Success. FALSE - An error occured. Definition at line 6079 of file osrndrgn.cpp. { // Create a linear fill attribute. LinearFillAttribute LinearFill; // Set it up. LinearFill.SetStartPoint ( Fill->GetStartPoint () ); LinearFill.SetEndPoint ( Fill->GetEndPoint3 () ); LinearFill.SetStartColour ( Fill->GetStartColour () ); LinearFill.SetEndColour ( Fill->GetEndColour3 () ); // Export the fill as a two colour linear fill. RenderLinearFill ( PathToDraw, &LinearFill ); // Graeme (11-6-00) - Mark has asked me to drop everything, and concentrate on getting a // Photoshop file format export / import filter going. As a consequence, I'm expected to // drop everything, and follow his commands, and so I've replacing this partially // complete four colour fill function with a call to the linear fill rendering function. // Normally I'd remove a piece of commented out code, but in this case I'm leaving it in // so that either I can get back to it later, or someone else can fix it. // // At the present time, all the function needs is some way of extending the fill pattern // out to the edges of the space being filled. There might be some way of spoofing this // using a linear gradient fill, and some kind of clipping region, or just rolling your // own code, and putting it in here. /* DocCoord HeightVector = Fill->EndPoint - Fill->StartPoint; DocCoord WidthVector = Fill->EndPoint2 - Fill->StartPoint; INT32 FillHeight = CalcDistance ( Fill->StartPoint, Fill->EndPoint ); INT32 FillWidth = CalcDistance ( Fill->StartPoint, Fill->EndPoint2 ); INT32 HeightSteps = 0; INT32 WidthSteps = 0; INT32 HeightColDiff = 0; INT32 WidthColDiff = 0; FIXED16 PixelSize = 0; GradFillMethodType RenderMethod = GF_USE_GDICLIPPING; EFFECTTYPE EffectType = GetFillEffect(); INT32 ClipFlatness = 0; INT32 ClipTolerance = 0; INT32 RenderCount = 1; RGBQUAD StartColours [MAX_FILL_STEPS]; RGBQUAD EndColours [MAX_FILL_STEPS]; DocCoord RowOffsets [MAX_FILL_STEPS + 1]; DocCoord ColumnOffsets [MAX_FILL_STEPS + 1]; // We want to change the rendering context, so we save it. SaveContext (); // No stroking while rendering the fill. SetLineColour ( COLOUR_TRANS ); // Use device pixel size to work out how many steps to do. GetRenderView ()->GetScaledPixelSize ( &PixelSize, &PixelSize ); // Calculate the number of steps to be made for the fill in each direction, making a // slice every four pixels. HeightSteps = FillHeight / ( PixelSize.MakeLong () * 4); WidthSteps = FillWidth / ( PixelSize.MakeLong () * 4); // Calculate the distance between colours. HeightColDiff = min ( ColDifference ( Fill->Colour, Fill->EndColour, IsPrinting () ? 24 : 8, EffectType ), ColDifference ( Fill->EndColour2, Fill->EndColour3, IsPrinting () ? 24 : 8, EffectType ) ); WidthColDiff = min ( ColDifference ( Fill->Colour, Fill->EndColour2, IsPrinting () ? 24 : 8, EffectType ), ColDifference ( Fill->EndColour, Fill->EndColour3, IsPrinting () ? 24 : 8, EffectType ) ); // Use the number of discrete steps between colours, and the number of slices to // determine just how many colours are needed. HeightSteps = min ( HeightSteps, HeightColDiff ); WidthSteps = min ( WidthSteps, WidthColDiff ); // Limit fill steps to a maximum value. HeightSteps = min ( HeightSteps, MAX_FILL_STEPS ); WidthSteps = min ( WidthSteps, MAX_FILL_STEPS ); // Use global Quality setting. HeightSteps = max ( HeightSteps / (1 << GradFillQuality), 10 ); WidthSteps = max ( WidthSteps / (1 << GradFillQuality), 10 ); // Work out what flatness and accuracy to use for Gavin's clipping functions. // Gavin recommends 1/2 pixel for flattening, and 1/4 pixel for tolerance. // (But these were kind of off the top of his head - Tim). // PS. It seems we need maximum tolerance (i.e. 0) for accurate grad-fill rendering. ClipFlatness = PixelSize.MakeLong () / 16; // Build the gradient table. In the other gradient fills, they call the // GradTable32::BuildGraduatedPalette () function. Unfortunately I need to operate // in two dimensions... // The first thing to do is to get a pair of gradient tables to act as the start and // end colours for each row of the fill. GradTable32::BuildGraduatedPalette ( Fill->Colour, Fill->EndColour, GetRenderView (), EffectType, HeightSteps, StartColours ); GradTable32::BuildGraduatedPalette ( Fill->EndColour2, Fill->EndColour3, GetRenderView (), EffectType, HeightSteps, EndColours ); // If we are rendering into a metafile, clip the path ourselves. if ( RFlags.Metafile ) { RenderMethod = GF_USE_GAVINCLIPPING; } else { if ( !SetClipToPathTemporary ( PathToDraw ) ) { // Can't use clipping - fall back to EOR. RenderMethod = GF_USE_GDIEOR; } } // Set the drawing mode up. if ( RenderMethod == GF_USE_GDIEOR ) { SetDrawingMode ( DM_EORDITHER ); RenderCount = 2; } // Pre-calculate the vectors between the various rows of tiles. for ( INT32 i = 0; i <= HeightSteps; i++ ) { DocCoord Temp ( ( HeightVector.x * i ) / HeightSteps, ( HeightVector.y * i ) / HeightSteps); RowOffsets [i] = Temp + Fill->StartPoint; } // And between the various columns of tiles. for ( INT32 j = 0; j <= WidthSteps; j++ ) { ColumnOffsets [j] = DocCoord ( ( WidthVector.x * j ) / HeightSteps, ( WidthVector.y * j ) / HeightSteps ); } // Create the fill pattern. while ( RenderCount > 0 ) { // Loop through the colour table, and create the necessary tiles to emulate the fill. for ( INT32 y = 0; y < HeightSteps; y++ ) { RGBQUAD RowColours [MAX_FILL_STEPS]; DocColour FirstColour; DocColour LastColour; DocCoord TileHeight = RowOffsets [y+1] - RowOffsets [y]; // Initialise the start and end colours with values from the RGB quad. I need to // do this because the BuildGraduatePalette method only takes DocColors, and only // returns RGBQuads. FirstColour.SetRGBValue ( StartColours [y].rgbRed, StartColours [y].rgbGreen, StartColours [y].rgbBlue ); LastColour.SetRGBValue ( EndColours [y].rgbRed, EndColours [y].rgbGreen, EndColours [y].rgbBlue ); // Create a new palette for this row of the fill. GradTable32::BuildGraduatedPalette ( FirstColour, LastColour, GetRenderView (), EffectType, WidthSteps, RowColours ); // Now write out the row. for ( INT32 x = 0; x < WidthSteps; x++ ) { // Create the path for the tile to be rendered. Path TilePath; PathFlags TileFlags; DocColour FillColour; // Initialise the path. TilePath.Initialise ( 12, 12 ); // Set up the path. TilePath.InsertMoveTo ( RowOffsets [y] + ColumnOffsets [x], &TileFlags ); TilePath.InsertLineTo ( RowOffsets [y+1] + ColumnOffsets [x], &TileFlags ); TilePath.InsertLineTo ( RowOffsets [y+1] + ColumnOffsets [x+1], &TileFlags ); TilePath.InsertLineTo ( RowOffsets [y] + ColumnOffsets [x+1], &TileFlags ); // Mark the path as closed and filled. TilePath.CloseSubPath (); TilePath.IsFilled = TRUE; // Set up the fill colour. FillColour.SetRGBValue ( RowColours [x].rgbRed, RowColours [x].rgbGreen, RowColours [x].rgbBlue ); FillColour.SetSeparable ( FALSE ); // Set it as the rendering colour. SetFillColour ( FillColour ); GetValidBrush (); GetValidPen (); // And write it out. if ( RenderMethod != GF_USE_GAVINCLIPPING ) { RenderPath ( &TilePath ); } else { // Create a new path. Path ClippedPath; // Initialise the path. ClippedPath.Initialise ( 12, 12 ); // Clip the tile path to the drawing path to ensure that it fits into the // shape being rendered. PathToDraw->ClipPathToPath ( TilePath, &ClippedPath, 2, ClipTolerance, ClipFlatness, ClipFlatness); // Set the IsFilled flag. ClippedPath.IsFilled = TRUE; // And render the path. RenderPath ( &ClippedPath ); } } } // This comes at the end of the rendering loop. if ( ( RenderMethod == GF_USE_GDIEOR ) && ( RenderCount > 1 ) ) { // Render the path in white SetDrawingMode ( DM_COPYPEN ); SetFillColour ( COLOUR_BLACK ); SetLineColour ( COLOUR_TRANS ); GetValidBrush (); GetValidPen (); RenderPath ( PathToDraw ); // Set back to mode required for grad fill rendering SetDrawingMode ( DM_EORDITHER ); } RenderCount--; } // Restore the original rendering state. RestoreContext (); GetValidBrush (); GetValidPen (); // Lose the clipping region if we are using one. if ( RenderMethod == GF_USE_GDICLIPPING ) RenderDC->SelectClipRgn ( OSClipRegion ); */ // Success. return TRUE; }

BOOL OSRenderRegion::RenderGradFillPath (  Path *  PathToDraw, GradFillAttribute *  Fill )

Render grad fills to GDI devices using whatever means available. Scope: Public. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 19/4/94 Parameters: A  path to render and a fill attribute. [INPUTS] -  [OUTPUTS] Returns: Errors: - TRUE if worked, FALSE if failed. Definition at line 4810 of file osrndrgn.cpp. { CCRuntimeClass *FillType = Fill->GetRuntimeClass(); if (FillType == CC_RUNTIME_CLASS(RadialFillAttribute)) return RenderRadialFill(PathToDraw, (RadialFillAttribute *) Fill); else if (FillType == CC_RUNTIME_CLASS(LinearFillAttribute)) return RenderLinearFill(PathToDraw, (LinearFillAttribute *) Fill); else if (FillType == CC_RUNTIME_CLASS(ConicalFillAttribute)) return RenderConicalFill(PathToDraw, (ConicalFillAttribute *) Fill); else if (FillType == CC_RUNTIME_CLASS(SquareFillAttribute)) return RenderSquareFill(PathToDraw, (SquareFillAttribute *) Fill); else if (FillType == CC_RUNTIME_CLASS(FourColFillAttribute)) return RenderFourColFill(PathToDraw, (FourColFillAttribute *) Fill); else return FALSE; }

BOOL OSRenderRegion::RenderLinearFill (  Path *  PathToDraw, LinearFillAttribute *  Fill )  [protected]

Renders the path with a gradient fill. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com>? Rik? Tim? Date: ? Parameters: PathToDraw  - A pointer to the path to be rendered. [INPUTS] Fill - A pointer to the radial fill applied. Returns: TRUE - Success. FALSE - An error occured. Definition at line 5183 of file osrndrgn.cpp. { GradFillMethodType RenderMethod = GF_USE_GDICLIPPING; // First, we need to find out the minimum width of rectangles we can // plot and still fill the entire shape. // To do this we find the maxiumum distance between the start point and all four // corners of the bounding box. // NB. This actually gives us *half* the minimum width we need. DocRect BoundsRect = PathToDraw->GetBoundingRect(); DocCoord TestPoint = BoundsRect.lo; INT32 Distance = CalcDistance(Fill->StartPoint, TestPoint); TestPoint.x = BoundsRect.hi.x; INT32 NewDistance = CalcDistance(Fill->StartPoint, TestPoint); Distance = max(Distance, NewDistance); TestPoint = BoundsRect.hi; NewDistance = CalcDistance(Fill->StartPoint, TestPoint); Distance = max(Distance, NewDistance); TestPoint.x = BoundsRect.lo.x; NewDistance = CalcDistance(Fill->StartPoint, TestPoint); Distance = max(Distance, NewDistance); // Distance now holds the minimum distance either side of the line that we should // render. // We want to change the rendering context, so we save it. SaveContext(); // No stroking while rendering the fill. SetLineColour(COLOUR_TRANS); // Use device pixel size to work out how many steps to do. FIXED16 PixelSize = 0; GetRenderView()->GetScaledPixelSize(&PixelSize,&PixelSize); // Work out how long the fill arrow is in millipoints. INT32 FillLength = CalcDistance(Fill->StartPoint, Fill->EndPoint); // Do a slice every 4 pixels (arbitrary!) INT32 FillSteps = (INT32) ((FillLength / PixelSize.MakeDouble()) / 4); // Also base it on distance between colours EFFECTTYPE EffectType = GetFillEffect(); FillSteps = min(ColDifference(Fill->Colour, Fill->EndColour, IsPrinting() ? 24 : 8, // Colour depth EffectType), FillSteps); // Limit fill steps to a maximum FillSteps = min( FillSteps, INT32(MAX_FILL_STEPS) ); // Use global Quality setting FillSteps = FillSteps / (1 << GradFillQuality); FillSteps = max(FillSteps, 10); // Work out what flatness and accuracy to use for Gavin's clipping functions. // Gavin recommends 1/2 pixel for flattening, and 1/4 pixel for tolerance // (but these were kind of off the top of his head - Tim). // PS. It seems we need maximum tolerance (i.e. 0) for accurate grad-fill rendering. INT32 ClipFlatness = PixelSize.MakeLong() / 16; INT32 ClipTolerance = 0; RGBQUAD ColourSteps[MAX_FILL_STEPS]; GradTable32::BuildGraduatedPalette(Fill->Colour, Fill->EndColour, GetRenderView(), EffectType, FillSteps, ColourSteps); INT32 RenderCount = 1; // If we are rendering into a metafile, clip the path ourselves if (RFlags.Metafile) { RenderMethod = GF_USE_GAVINCLIPPING; } else { if (!SetClipToPathTemporary(PathToDraw)) { // Can't use clipping - fall back to EOR. RenderMethod = GF_USE_GDIEOR; SetDrawingMode(DM_EORDITHER); RenderCount = 2; } } DocColour TempFillColour; while (RenderCount > 0) { COLORREF CurrentCol = RGB(ColourSteps[0].rgbRed, ColourSteps[0].rgbGreen, ColourSteps[0].rgbBlue); // Put the RGB value back into a DocColour so we can set it as the fill colour. We set it // as non-separable, as it will have already been colour-separated by BuildGraduatedPalette TempFillColour.SetRGBValue(ColourSteps[0].rgbRed, ColourSteps[0].rgbGreen, ColourSteps[0].rgbBlue); TempFillColour.SetSeparable(FALSE); SetFillColour(TempFillColour); GetValidBrush(); GetValidPen(); // This is the path we will use to create linear fills. Path LinearFill; LinearFill.Initialise(12,12); // This is the path we use for all clipped rendering. Path ClippedPath; ClippedPath.Initialise(12, 12); // Work out differences in x and y coords for fill arrow. double FillStepX = ((double) (Fill->EndPoint.x - Fill->StartPoint.x)) / (double) FillSteps; double FillStepY = ((double) (Fill->EndPoint.y - Fill->StartPoint.y)) / (double) FillSteps; double FillAngle = atan2((double)(Fill->EndPoint.x - Fill->StartPoint.x), (double)(Fill->EndPoint.y - Fill->StartPoint.y)); // Used to find perpendicular angles. const double HalfPI = PI/2.0; DocCoord FillPoint = Fill->StartPoint; DocCoord RectPoint[2]; // Find first two corners of rectangle RectPoint[0].x = FillPoint.x + (INT32) (((double) Distance) * sin(FillAngle - HalfPI)); RectPoint[0].y = FillPoint.y + (INT32) (((double) Distance) * cos(FillAngle - HalfPI)); RectPoint[1].x = FillPoint.x + (INT32) (((double) Distance) * sin(FillAngle + HalfPI)); RectPoint[1].y = FillPoint.y + (INT32) (((double) Distance) * cos(FillAngle + HalfPI)); // Do the start colour shape - we need to find out how far we need // to extend beyond the fill arrow. TestPoint = BoundsRect.lo; INT32 LastDistance = CalcDistance(Fill->EndPoint, TestPoint); TestPoint.x = BoundsRect.hi.x; NewDistance = CalcDistance(Fill->EndPoint, TestPoint); LastDistance = max(LastDistance, NewDistance); TestPoint = BoundsRect.hi; NewDistance = CalcDistance(Fill->EndPoint, TestPoint); LastDistance = max(LastDistance, NewDistance); TestPoint.x = BoundsRect.lo.x; NewDistance = CalcDistance(Fill->EndPoint, TestPoint); LastDistance = max(LastDistance, NewDistance); // Make the last (big) rectangle. LinearFill.ClearPath(); LinearFill.FindStartOfPath(); // Create a rectangle PathFlags NewFlags; NewFlags.IsRotate = TRUE; // Insert first two corners of rectangle. LinearFill.InsertMoveTo(RectPoint[0], &NewFlags); LinearFill.InsertLineTo(RectPoint[1], &NewFlags); // Move past the fill arrow far enough to cover last bit of shape. FillPoint.x = Fill->EndPoint.x - (MILLIPOINT) (LastDistance * sin(FillAngle)); FillPoint.y = Fill->EndPoint.y - (MILLIPOINT) (LastDistance * cos(FillAngle)); // Find other two corners of rectangle. DocCoord EndPoint[2]; EndPoint[0].x = FillPoint.x + (INT32) (((double) Distance) * sin(FillAngle - HalfPI)); EndPoint[0].y = FillPoint.y + (INT32) (((double) Distance) * cos(FillAngle - HalfPI)); EndPoint[1].x = FillPoint.x + (INT32) (((double) Distance) * sin(FillAngle + HalfPI)); EndPoint[1].y = FillPoint.y + (INT32) (((double) Distance) * cos(FillAngle + HalfPI)); // Insert last two corners of rectangle. LinearFill.InsertLineTo(EndPoint[1], &NewFlags); LinearFill.InsertLineTo(EndPoint[0], &NewFlags); // Close the path properly LinearFill.CloseSubPath(); LinearFill.IsFilled = TRUE; if (RenderMethod != GF_USE_GAVINCLIPPING) { RenderPath(&LinearFill); } else { PathToDraw->ClipPathToPath(LinearFill, &ClippedPath, 2, ClipTolerance, ClipFlatness, ClipFlatness); ClippedPath.IsFilled = TRUE; RenderPath(&ClippedPath); } // Now render the fill using rectangles. for (INT32 i = 0; i < FillSteps;) { LinearFill.ClearPath(); LinearFill.FindStartOfPath(); // Create a rectangle PathFlags NewFlags; NewFlags.IsRotate = TRUE; // Insert first two corners of rectangle. LinearFill.InsertMoveTo(RectPoint[0], &NewFlags); LinearFill.InsertLineTo(RectPoint[1], &NewFlags); // increment loop counter here so that the next colour can be calculated i++; // Move along the arrow one step FillPoint.x = Fill->StartPoint.x + (MILLIPOINT) (i * FillStepX); FillPoint.y = Fill->StartPoint.y + (MILLIPOINT) (i * FillStepY); // Find other two corners of rectangle. RectPoint[0].x = FillPoint.x + (INT32) (((double) Distance) * sin(FillAngle - HalfPI)); RectPoint[0].y = FillPoint.y + (INT32) (((double) Distance) * cos(FillAngle - HalfPI)); RectPoint[1].x = FillPoint.x + (INT32) (((double) Distance) * sin(FillAngle + HalfPI)); RectPoint[1].y = FillPoint.y + (INT32) (((double) Distance) * cos(FillAngle + HalfPI)); // Insert last two corners of rectangle. LinearFill.InsertLineTo(RectPoint[1], &NewFlags); LinearFill.InsertLineTo(RectPoint[0], &NewFlags); // Close the path properly LinearFill.CloseSubPath(); LinearFill.IsFilled = TRUE; if (RenderMethod != GF_USE_GAVINCLIPPING) { RenderPath(&LinearFill); } else { PathToDraw->ClipPathToPath(LinearFill, &ClippedPath, 2, ClipTolerance, ClipFlatness, ClipFlatness); ClippedPath.IsFilled = TRUE; RenderPath(&ClippedPath); } if (i != FillSteps) { // Calculate next brush const COLORREF NewFill = RGB(ColourSteps[i].rgbRed, ColourSteps[i].rgbGreen, ColourSteps[i].rgbBlue); if (NewFill != CurrentCol) { // colour changed, make new brush CurrentCol = NewFill; // Put the RGB value back into a DocColour so we can set it as the fill colour. We set it // as non-separable, as it will have already been colour-separated by BuildGraduatedPalette TempFillColour.SetRGBValue(ColourSteps[i].rgbRed, ColourSteps[i].rgbGreen, ColourSteps[i].rgbBlue); TempFillColour.SetSeparable(FALSE); SetFillColour(TempFillColour); GetValidBrush(); GetValidPen(); } } } // Do the end colour shape - we need to find out how far we need // to extend beyond the fill arrow. TestPoint = BoundsRect.lo; LastDistance = CalcDistance(Fill->EndPoint, TestPoint); TestPoint.x = BoundsRect.hi.x; NewDistance = CalcDistance(Fill->EndPoint, TestPoint); LastDistance = max(LastDistance, NewDistance); TestPoint = BoundsRect.hi; NewDistance = CalcDistance(Fill->EndPoint, TestPoint); LastDistance = max(LastDistance, NewDistance); TestPoint.x = BoundsRect.lo.x; NewDistance = CalcDistance(Fill->EndPoint, TestPoint); LastDistance = max(LastDistance, NewDistance); // Make the last (big) rectangle. LinearFill.ClearPath(); LinearFill.FindStartOfPath(); // Create a rectangle NewFlags.IsRotate = TRUE; // Insert first two corners of rectangle. LinearFill.InsertMoveTo(RectPoint[0], &NewFlags); LinearFill.InsertLineTo(RectPoint[1], &NewFlags); // Move past the fill arrow far enough to cover last bit of shape. FillPoint.x = Fill->EndPoint.x + (MILLIPOINT) (LastDistance * sin(FillAngle)); FillPoint.y = Fill->EndPoint.y + (MILLIPOINT) (LastDistance * cos(FillAngle)); // Find other two corners of rectangle. RectPoint[0].x = FillPoint.x + (INT32) (((double) Distance) * sin(FillAngle - HalfPI)); RectPoint[0].y = FillPoint.y + (INT32) (((double) Distance) * cos(FillAngle - HalfPI)); RectPoint[1].x = FillPoint.x + (INT32) (((double) Distance) * sin(FillAngle + HalfPI)); RectPoint[1].y = FillPoint.y + (INT32) (((double) Distance) * cos(FillAngle + HalfPI)); // Insert last two corners of rectangle. LinearFill.InsertLineTo(RectPoint[1], &NewFlags); LinearFill.InsertLineTo(RectPoint[0], &NewFlags); // Close the path properly LinearFill.CloseSubPath(); LinearFill.IsFilled = TRUE; if (RenderMethod != GF_USE_GAVINCLIPPING) { RenderPath(&LinearFill); } else { PathToDraw->ClipPathToPath(LinearFill, &ClippedPath, 2, ClipTolerance, ClipFlatness, ClipFlatness); ClippedPath.IsFilled = TRUE; RenderPath(&ClippedPath); } if ((RenderMethod == GF_USE_GDIEOR) && (RenderCount > 1)) { // Render the path in white SetDrawingMode(DM_COPYPEN); SetFillColour(COLOUR_BLACK); SetLineColour(COLOUR_TRANS); GetValidBrush(); GetValidPen(); RenderPath(PathToDraw); // Set back to mode required for grad fill rendering SetDrawingMode(DM_EORDITHER); } RenderCount--; } // now tidy up RestoreContext(); GetValidBrush(); GetValidPen(); // Lose the clipping region if we are using one. if (RenderMethod == GF_USE_GDICLIPPING) RenderDC->SetClippingRegion(*OSClipRegion); return TRUE; }

void OSRenderRegion::RenderPath (  Path *  DrawPath  )  [protected]

Renders a path to the GDI. Can recurse in the case of arrow heads. Scope: Private. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 28/6/93 Definition at line 2856 of file osrndrgn.cpp. { /* 26/9/94. Will. Changed RFlag test, because of problems with NT bezier flattening. if (RFlags.GDI32 && (RR_DASHPATTERN().Elements == 0)) { RenderPath32( DrawPath ); return; } */ // Flags to indicate whether fill-providers or stroke-providers have filled or stroke // the path yet. BOOL ExtendedFill = FALSE; // If this is not a simple fill, set the flag to indicate this. FillGeometryAttribute *pFillProvider = (FillGeometryAttribute *) CurrentAttrs[ATTR_FILLGEOMETRY].pAttr; if (pFillProvider->GetRuntimeClass() != CC_RUNTIME_CLASS(FlatFillAttribute)) ExtendedFill = TRUE; // we can't do fancy fills if quality is low if (RRQuality.GetFillQuality() < Quality::Graduated) ExtendedFill = FALSE; // // We ought to check for stroke-providers in here, when the great day comes that // we actually have them... // // DY - 27/11/2000 The Great Day has arrived!!! If we have an AttrStrokeType // AND an AttrVariableWidth then we don't want Gavin to mess with our line widths BOOL StrokeProvided = FALSE; StrokeTypeAttrValue* pStroke = (StrokeTypeAttrValue*) GetCurrentAttribute(ATTR_STROKETYPE); VariableWidthAttrValue* pVarWidth = (VariableWidthAttrValue*) GetCurrentAttribute(ATTR_VARWIDTH); if (pVarWidth && pStroke) { // Test that these attrs are active and not just defaults that don't do anything if (pStroke->GetPathProcessor() != NULL && pVarWidth->GetWidthFunction() != NULL) StrokeProvided = TRUE; } // Get the fill provider to fill the path - if it can't handle this sort of render // region, then we fill the path for it. if (ExtendedFill) { if (!pFillProvider->RenderFill(this, DrawPath)) // Unable to render fill for this render region - default to simple fill. ExtendedFill = FALSE; } wxPen NewPen,OldPen; // can ge get Gavin to manually flatten the path? Is it worth it? // Note that if we have already had a stroke provided (above then we don't want Gavin, // and we also don't want GDI having a go either BOOL ManualStroke = !StrokeProvided; if (ManualStroke) ManualStroke = GRenderRegion::StrokePathAvailable(); if (ManualStroke) { // is it worth it for this line? Must be wider than 1 pixel and high enough quality // First, is it disabled? if (!DoBetterLines) { ManualStroke = FALSE; } // We have to stroke for Dash patterns else if ((RR_DASHPATTERN().Elements != 0) && (RR_LINEWIDTH() > 0)) { // Keep manual stroke as being TRUE... } else { INT32 dpLineWidth = MPtoLP(RR_LINEWIDTH()); // If no 32-bit GDI then we have to stroke via Gavin if the line is wider than // a few device pixels, because 16-bit GDI can't do end-caps/joins for toffee. if (dpLineWidth > 0) //(!RFlags.GDI32 && (dpLineWidth > 3)) { // Keep manual stroke as being TRUE... } // Don't bother with 0-width lines, or for very thin lines else if ((RR_LINEWIDTH() == 0) || (dpLineWidth <= 3)) { ManualStroke = FALSE; } else if (RR_STROKECOLOUR().IsTransparent() || // if no line, don't bother (RRQuality.GetLineQuality() < Quality::FullLine) // if low quality, don't bother ) { ManualStroke = FALSE; } } } if (ManualStroke || StrokeProvided) { // if we're going to use Gavin for path stroking, or a stroke attribute has // already stroked the path then better stop GDI from outlining // the Polygons // NewPen.CreateStockObject( NULL_PEN ); OldPen = RenderDC->GetPen(); // AMB thinks (15-Mar-05) the following will cause problems, because wx on GTK doesn't // like drawing with the NULL pen. Use a transparent pen instead // RenderDC->SetPen(wxNullPen); RenderDC->SetPen(*wxTRANSPARENT_PEN); } INT32 Count; // An array of the number of points in each polygon INT32 PolyCounts[MAX_POLYGONS]; // Use default flattening INT32 Flatness = 0; // In all, we reduce flattening 8 times before giving up (arbitrary number) INT32 Attempts = 8; BOOL Worked = FALSE; // Keep flattening until it works (or we have tried 8 times) while (!Worked && (Attempts > 0)) { Worked = RawRenderPath( NORMALPATH(DrawPath), PolyCounts, &Count, Flatness, &Flatness ); Attempts--; } if (Worked) { if (Count) { #ifndef _MAC if (DrawPath->IsFilled && !ExtendedFill) RenderDC->DrawPolyPolygon(Count,PolyCounts,PointArray,0,0,nFillStyle); else #endif { // render the little sub-paths. Win16 doesn't have Polypolyline wxPoint* PointList = PointArray; INT32 *CountList = PolyCounts; INT32 count; while (Count--) { count = *CountList++; RenderDC->DrawLines(count,PointList); PointList += count; } } } } else { TRACE( _T("Unable to flatten path into out buffer\n")); } // Let Gavin have a go at the lines now if (ManualStroke) { StrokeProperly( DrawPath ); RenderDC->SetPen( OldPen ); } }

void OSRenderRegion::RenderPath32 (  Path *  DrawPath  )  [protected]

Renders a path using Win32 GDI. Causes an ENSURE on Win16 as should never be called. Scope: Private. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 16/9/93 Definition at line 6409 of file osrndrgn.cpp. { PORTNOTETRACE("other","OSRenderRegion::RenderPath32 - do nothing"); #ifndef EXCLUDE_FROM_XARALX const wxDC* dc = RenderDC; // Flags to indicate whether fill-providers or stroke-providers have filled or stroked // the path yet. BOOL ExtendedFill = FALSE; // If this is not a simple fill, set the flag to indicate this. FillGeometryAttribute *pFillProvider = (FillGeometryAttribute *) CurrentAttrs[ATTR_FILLGEOMETRY].pAttr; if (pFillProvider->GetRuntimeClass() != CC_RUNTIME_CLASS(FlatFillAttribute)) ExtendedFill = TRUE; // low quality displays can't do fancy fills if (RRQuality.GetFillQuality() < Quality::Graduated) ExtendedFill = FALSE; // // We ought to check for stroke-providers in here, when the great day comes that // we actually have them... // // Get the fill provider to fill the path - if it can't handle this sort of render // region, then we fill the path for it. if (ExtendedFill) { if (!pFillProvider->RenderFill(this, DrawPath)) // Unable to render fill for this render region - default to simple fill. ExtendedFill = FALSE; } // actually do the rendering BOOL Result = RawRenderPath32( DrawPath ); if (!Result) { TRACE( _T("RawRenderPath failed")); return; } // Draw it either filled or not. // NB. If the fill-provider has already filled this path then we don't bother. if (DrawPath->IsFilled && !ExtendedFill) StrokeAndFillPath( dc ); else StrokePath( dc ); #endif }

BOOL OSRenderRegion::RenderRadialFill (  Path *  PathToDraw, RadialFillAttribute *  Fill )  [protected]

Renders the path with a gradient fill. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com>? Rik? Tim? Date: ? Parameters: PathToDraw  - A pointer to the path to be rendered. [INPUTS] Fill - A pointer to the radial fill applied. Returns: TRUE - Success. FALSE - An error occured. Definition at line 4936 of file osrndrgn.cpp. { GradFillMethodType RenderMethod = GF_USE_GDICLIPPING; INT32 Radius1 = CalcDistance(Fill->StartPoint, Fill->EndPoint); INT32 Radius2 = CalcDistance(Fill->StartPoint, Fill->EndPoint2); // We want to change the rendering context, so we save it. SaveContext(); // No stroking while rendering the fill. SetLineColour(COLOUR_TRANS); // Use device pixel size to work out how many steps to do. FIXED16 PixelSize = 0; GetRenderView()->GetScaledPixelSize(&PixelSize,&PixelSize); INT32 FillSteps = INT32( max( Radius1, Radius2 ) / PixelSize.MakeDouble() ); // Do a slice every 4 pixels (arbitrary!) FillSteps /= 4; // Also base it on distance between colours EFFECTTYPE EffectType = GetFillEffect(); FillSteps = min(ColDifference(Fill->Colour, Fill->EndColour, IsPrinting() ? 24 : 8, // Colour depth EffectType ), FillSteps); // Limit fill steps to a maximum FillSteps = min(FillSteps, INT32(MAX_FILL_STEPS)); // Use global Quality setting FillSteps = FillSteps / (1 << GradFillQuality); FillSteps = max(FillSteps, 10); // Work out what flatness and accuracy to use for Gavin's clipping functions. // Gavin recommends 1/2 pixel for flattening, and 1/4 pixel for tolerance // (but these were kind of off the top of his head - Tim). // PS. It seems we need maximum tolerance (i.e. 0) for accurate grad-fill rendering. INT32 ClipFlatness = PixelSize.MakeLong() / 16; INT32 ClipTolerance = 0; RGBQUAD ColourSteps[MAX_FILL_STEPS]; GradTable32::BuildGraduatedPalette(Fill->Colour, Fill->EndColour, GetRenderView(), EffectType, FillSteps, ColourSteps); // If we are rendering into a metafile, clip the path ourselves if (RFlags.Metafile) { RenderMethod = GF_USE_GAVINCLIPPING; } else { if (!SetClipToPathTemporary(PathToDraw)) { // Can't use clipping - fall back to EOR. RenderMethod = GF_USE_GDIEOR; } } INT32 RenderCount = 1; if (RenderMethod == GF_USE_GDIEOR) { SetDrawingMode(DM_EORDITHER); RenderCount = 2; } DocColour TempFillColour; while (RenderCount > 0) { COLORREF CurrentCol = RGB(ColourSteps[FillSteps - 1].rgbRed, ColourSteps[FillSteps - 1].rgbGreen, ColourSteps[FillSteps - 1].rgbBlue); // Put the RGB value back into a DocColour so we can set it as the fill colour. We set it // as non-separable, as it will have already been colour-separated by BuildGraduatedPalette TempFillColour.SetRGBValue(ColourSteps[FillSteps - 1].rgbRed, ColourSteps[FillSteps - 1].rgbGreen, ColourSteps[FillSteps - 1].rgbBlue); TempFillColour.SetSeparable(FALSE); SetFillColour(TempFillColour); GetValidBrush(); GetValidPen(); // First, fill in whole path with end colour //RenderPath(PathToDraw); Path PreviousPath; PreviousPath.Initialise(PathToDraw->GetNumCoords() + 2, 12); PreviousPath.CopyPathDataFrom(PathToDraw); // Work out relative positions of start and end points. DocCoord Steps[2]; Steps[0].x = Fill->StartPoint.x - Fill->EndPoint.x; Steps[0].y = Fill->StartPoint.y - Fill->EndPoint.y; Steps[1].x = Fill->StartPoint.x - Fill->EndPoint2.x; Steps[1].y = Fill->StartPoint.y - Fill->EndPoint2.y; // Construct the parallelogram that describes the biggest ellipse. // (If I could draw a picture here, I would!) DocCoord Parallel[4]; Parallel[0].x = Fill->StartPoint.x + (Steps[0].x + Steps[1].x); Parallel[0].y = Fill->StartPoint.y + (Steps[0].y + Steps[1].y); Parallel[1].x = Fill->StartPoint.x + (Steps[0].x - Steps[1].x); Parallel[1].y = Fill->StartPoint.y + (Steps[0].y - Steps[1].y); Parallel[2].x = Fill->StartPoint.x - (Steps[0].x + Steps[1].x); Parallel[2].y = Fill->StartPoint.y - (Steps[0].y + Steps[1].y); Parallel[3].x = Fill->StartPoint.x + (Steps[1].x - Steps[0].x); Parallel[3].y = Fill->StartPoint.y + (Steps[1].y - Steps[0].y); // Now convert the steps into the steps we should use to adjust the // parallelogram after each fill step Steps[0].x /= (FillSteps + 1); Steps[0].y /= (FillSteps + 1); Steps[1].x /= (FillSteps + 1); Steps[1].y /= (FillSteps + 1); // This are the paths we will use to create radial fills. Path RadialFill; RadialFill.Initialise(50,12); Path EllipsePath; EllipsePath.Initialise(15,12); // This is the path we use for all clipped rendering. Path ClippedPath; ClippedPath.Initialise(12, 12); // Now render the fill using concentric ellipses, starting with the biggest. for (INT32 i = FillSteps; i > 0;) { MakeEllipticalPath(&EllipsePath, Parallel); EllipsePath.IsFilled = TRUE; // Use this and the previous path to make an elliptical disc. RadialFill.ClearPath(FALSE); RadialFill.MakeSpaceInPath(PreviousPath.GetNumCoords() + EllipsePath.GetNumCoords() + 2); RadialFill.CopyPathDataFrom(&PreviousPath); RadialFill.IsFilled = TRUE; if (i > 1) { // For all except the last step, make a complex path (which is // usually an elliptical disc). ERROR2IF(!RadialFill.MergeTwoPaths(EllipsePath), FALSE, "could not merge paths"); } // Remember the elliptical path for next time PreviousPath.ClearPath(FALSE); PreviousPath.MakeSpaceInPath(EllipsePath.GetNumCoords() + 2); PreviousPath.CopyPathDataFrom(&EllipsePath); if (RenderMethod != GF_USE_GAVINCLIPPING) { RenderPath(&RadialFill); } else { PathToDraw->ClipPathToPath(RadialFill, &ClippedPath, 2, ClipTolerance, ClipFlatness, ClipFlatness); ClippedPath.IsFilled = TRUE; RenderPath(&ClippedPath); } // decrement loop counter here so that the next colour can be calculated i--; if (i > 0) { // Calculate next brush (except at the end of the loop) const COLORREF NewFill = RGB(ColourSteps[i].rgbRed, ColourSteps[i].rgbGreen, ColourSteps[i].rgbBlue); if (NewFill != CurrentCol) { // colour changed, make new brush CurrentCol = NewFill; // Put the RGB value back into a DocColour so we can set it as the fill colour. We set it // as non-separable, as it will have already been colour-separated by BuildGraduatedPalette TempFillColour.SetRGBValue(ColourSteps[i].rgbRed, ColourSteps[i].rgbGreen, ColourSteps[i].rgbBlue); TempFillColour.SetSeparable(FALSE); SetFillColour(TempFillColour); GetValidBrush(); GetValidPen(); } // Reduce size of paralleogram Parallel[0].x -= (Steps[0].x + Steps[1].x); Parallel[0].y -= (Steps[0].y + Steps[1].y); Parallel[1].x -= (Steps[0].x - Steps[1].x); Parallel[1].y -= (Steps[0].y - Steps[1].y); Parallel[2].x += (Steps[0].x + Steps[1].x); Parallel[2].y += (Steps[0].y + Steps[1].y); Parallel[3].x -= (Steps[1].x - Steps[0].x); Parallel[3].y -= (Steps[1].y - Steps[0].y); } } if ((RenderMethod == GF_USE_GDIEOR) && (RenderCount > 1)) { // Render the path in white SetDrawingMode(DM_COPYPEN); SetFillColour(COLOUR_BLACK); SetLineColour(COLOUR_TRANS); GetValidBrush(); GetValidPen(); RenderPath(PathToDraw); // Set back to mode required for grad fill rendering SetDrawingMode(DM_EORDITHER); } RenderCount--; } // now tidy up RestoreContext(); GetValidBrush(); GetValidPen(); // Lose the clipping region if we are using one. if (RenderMethod == GF_USE_GDICLIPPING) RenderDC->SetClippingRegion( *OSClipRegion ); return TRUE; }

BOOL OSRenderRegion::RenderSquareFill (  Path *  PathToDraw, SquareFillAttribute *  Fill )  [protected]

Renders the path with a gradient fill. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com>? Rik? Tim? Date: ? Parameters: PathToDraw  - A pointer to the path to be rendered. [INPUTS] Fill - A pointer to the radial fill applied. Returns: TRUE - Success. FALSE - An error occured. Definition at line 5782 of file osrndrgn.cpp. { GradFillMethodType RenderMethod = GF_USE_GDICLIPPING; INT32 Radius1 = CalcDistance(Fill->StartPoint, Fill->EndPoint); INT32 Radius2 = CalcDistance(Fill->StartPoint, Fill->EndPoint2); // We want to change the rendering context, so we save it. SaveContext(); // No stroking while rendering the fill. SetLineColour(COLOUR_TRANS); // Use device pixel size to work out how many steps to do. FIXED16 PixelSize = 0; GetRenderView()->GetScaledPixelSize(&PixelSize,&PixelSize); INT32 FillSteps = (INT32) (max(Radius1, Radius2) / PixelSize.MakeDouble()); // Do a slice every 4 pixels (arbitrary!) FillSteps /= 4; // Also base it on distance between colours EFFECTTYPE EffectType = GetFillEffect(); FillSteps = min(ColDifference(Fill->Colour, Fill->EndColour, IsPrinting() ? 24 : 8, // Colour depth EffectType), FillSteps); // Limit fill steps to a maximum FillSteps = min( FillSteps, INT32(MAX_FILL_STEPS) ); // Use global Quality setting FillSteps = FillSteps / (1 << GradFillQuality); FillSteps = max(FillSteps, 10); // Work out what flatness and accuracy to use for Gavin's clipping functions. // Gavin recommends 1/2 pixel for flattening, and 1/4 pixel for tolerance // (but these were kind of off the top of his head - Tim). // PS. It seems we need maximum tolerance (i.e. 0) for accurate grad-fill rendering. INT32 ClipFlatness = PixelSize.MakeLong() / 16; INT32 ClipTolerance = 0; RGBQUAD ColourSteps[MAX_FILL_STEPS]; GradTable32::BuildGraduatedPalette(Fill->Colour, Fill->EndColour, GetRenderView(), EffectType, FillSteps, ColourSteps); // If we are rendering into a metafile, clip the path ourselves if (RFlags.Metafile) { RenderMethod = GF_USE_GAVINCLIPPING; } else { if (!SetClipToPathTemporary(PathToDraw)) { // Can't use clipping - fall back to EOR. RenderMethod = GF_USE_GDIEOR; } } INT32 RenderCount = 1; if (RenderMethod == GF_USE_GDIEOR) { SetDrawingMode(DM_EORDITHER); RenderCount = 2; } DocColour TempFillColour; while (RenderCount > 0) { COLORREF CurrentCol = RGB(ColourSteps[FillSteps - 1].rgbRed, ColourSteps[FillSteps - 1].rgbGreen, ColourSteps[FillSteps - 1].rgbBlue); // Put the RGB value back into a DocColour so we can set it as the fill colour. We set it // as non-separable, as it will have already been colour-separated by BuildGraduatedPalette TempFillColour.SetRGBValue(ColourSteps[FillSteps - 1].rgbRed, ColourSteps[FillSteps - 1].rgbGreen, ColourSteps[FillSteps - 1].rgbBlue); TempFillColour.SetSeparable(FALSE); SetFillColour(TempFillColour); GetValidBrush(); GetValidPen(); // First, fill in whole path with end colour //RenderPath(PathToDraw); Path PreviousPath; PreviousPath.Initialise(PathToDraw->GetNumCoords() + 2, 12); PreviousPath.CopyPathDataFrom(PathToDraw); // Work out relative positions of start and end points. DocCoord Steps[2]; Steps[0].x = Fill->StartPoint.x - Fill->EndPoint.x; Steps[0].y = Fill->StartPoint.y - Fill->EndPoint.y; Steps[1].x = Fill->StartPoint.x - Fill->EndPoint2.x; Steps[1].y = Fill->StartPoint.y - Fill->EndPoint2.y; // Construct the parallelogram that describes the extent of the fill DocCoord Parallel[4]; Parallel[0].x = Fill->StartPoint.x + (Steps[0].x + Steps[1].x); Parallel[0].y = Fill->StartPoint.y + (Steps[0].y + Steps[1].y); Parallel[1].x = Fill->StartPoint.x + (Steps[0].x - Steps[1].x); Parallel[1].y = Fill->StartPoint.y + (Steps[0].y - Steps[1].y); Parallel[2].x = Fill->StartPoint.x - (Steps[0].x + Steps[1].x); Parallel[2].y = Fill->StartPoint.y - (Steps[0].y + Steps[1].y); Parallel[3].x = Fill->StartPoint.x + (Steps[1].x - Steps[0].x); Parallel[3].y = Fill->StartPoint.y + (Steps[1].y - Steps[0].y); // Now convert the steps into the steps we should use to adjust the // parallelogram after each fill step Steps[0].x /= (FillSteps + 1); Steps[0].y /= (FillSteps + 1); Steps[1].x /= (FillSteps + 1); Steps[1].y /= (FillSteps + 1); // These are the paths we will use to create square fills. Path SquareFill; SquareFill.Initialise(50,12); Path ParallelogramPath; ParallelogramPath.Initialise(15,12); // This is the path we use for all clipped rendering. Path ClippedPath; ClippedPath.Initialise(12, 12); // Now render the fill using concentric parallelograms, starting with the biggest. for (INT32 i = FillSteps; i > 0;) { // build a path ParallelogramPath.ClearPath(); ParallelogramPath.FindStartOfPath(); ParallelogramPath.InsertMoveTo(Parallel[0]); ParallelogramPath.InsertLineTo(Parallel[1]); ParallelogramPath.InsertLineTo(Parallel[2]); ParallelogramPath.InsertLineTo(Parallel[3]); ParallelogramPath.InsertLineTo(Parallel[0]); ParallelogramPath.IsFilled = TRUE; // Use this and the previous path to make a parallelogram shaped 'washer' SquareFill.ClearPath(FALSE); SquareFill.MakeSpaceInPath(PreviousPath.GetNumCoords() + ParallelogramPath.GetNumCoords() + 2); SquareFill.CopyPathDataFrom(&PreviousPath); SquareFill.IsFilled = TRUE; if (i > 1) { // For all except the last step, make a complex path (which is // usually a parallelogram). ERROR2IF(!SquareFill.MergeTwoPaths(ParallelogramPath), FALSE, "could not merge paths"); } // Remember the parallelogram path for next time PreviousPath.ClearPath(FALSE); PreviousPath.MakeSpaceInPath(ParallelogramPath.GetNumCoords() + 2); PreviousPath.CopyPathDataFrom(&ParallelogramPath); if (RenderMethod != GF_USE_GAVINCLIPPING) { RenderPath(&SquareFill); } else { PathToDraw->ClipPathToPath(SquareFill, &ClippedPath, 2, ClipTolerance, ClipFlatness, ClipFlatness); ClippedPath.IsFilled = TRUE; RenderPath(&ClippedPath); } // decrement loop counter here so that the next colour can be calculated i--; if (i > 0) { // Calculate next brush (except at the end of the loop) const COLORREF NewFill = RGB(ColourSteps[i].rgbRed, ColourSteps[i].rgbGreen, ColourSteps[i].rgbBlue); if (NewFill != CurrentCol) { // colour changed, make new brush CurrentCol = NewFill; // Put the RGB value back into a DocColour so we can set it as the fill colour. We set it // as non-separable, as it will have already been colour-separated by BuildGraduatedPalette TempFillColour.SetRGBValue(ColourSteps[i].rgbRed, ColourSteps[i].rgbGreen, ColourSteps[i].rgbBlue); TempFillColour.SetSeparable(FALSE); SetFillColour(TempFillColour); GetValidBrush(); GetValidPen(); } // Reduce size of paralleogram Parallel[0].x -= (Steps[0].x + Steps[1].x); Parallel[0].y -= (Steps[0].y + Steps[1].y); Parallel[1].x -= (Steps[0].x - Steps[1].x); Parallel[1].y -= (Steps[0].y - Steps[1].y); Parallel[2].x += (Steps[0].x + Steps[1].x); Parallel[2].y += (Steps[0].y + Steps[1].y); Parallel[3].x -= (Steps[1].x - Steps[0].x); Parallel[3].y -= (Steps[1].y - Steps[0].y); } } if ((RenderMethod == GF_USE_GDIEOR) && (RenderCount > 1)) { // Render the path in white SetDrawingMode(DM_COPYPEN); SetFillColour(COLOUR_BLACK); SetLineColour(COLOUR_TRANS); GetValidBrush(); GetValidPen(); RenderPath(PathToDraw); // Set back to mode required for grad fill rendering SetDrawingMode(DM_EORDITHER); } RenderCount--; } // now tidy up RestoreContext(); GetValidBrush(); GetValidPen(); // Lose the clipping region if we are using one. if (RenderMethod == GF_USE_GDICLIPPING) RenderDC->SetClippingRegion(*OSClipRegion); return TRUE; }

BOOL OSRenderRegion::RenderThreeColFill (  Path *  PathToDraw, ThreeColFillAttribute *  Fill )  [protected]

Renders a three colour gradient fill to a Windows DC. Author: Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com> Date: 7/6/00 Parameters: PathToDraw  - A pointer to the path to be rendered. [INPUTS] Fill - A pointer to the radial fill applied. Returns: TRUE - Success. FALSE - An error occured. Definition at line 6035 of file osrndrgn.cpp. { // Create a new end point for the fill. DocCoord EndPoint ( *( Fill->GetEndPoint () ) + *( Fill->GetEndPoint2 () ) - *( Fill->GetStartPoint () ) ); DocColour EndColour; LinearFillAttribute LinearFill; // Mix the two end colours together to make a blend suitable for the end point. EndColour.Mix ( Fill->GetEndColour (), Fill->GetEndColour2 (), 0.5f, NULL, FALSE, NULL ); // Set up the fill attribute. LinearFill.SetStartPoint ( Fill->GetStartPoint () ); LinearFill.SetEndPoint ( &EndPoint ); LinearFill.SetStartColour ( Fill->GetStartColour () ); LinearFill.SetEndColour ( &EndColour ); // Export the fill as a two colour linear fill. RenderLinearFill ( PathToDraw, &LinearFill ); return TRUE; }

void OSRenderRegion::SelectNewBrush (   )  [protected]

Selects RenderBrush while setting its new origin. A common operation that is in its own function to cope with things such as metafiles which cannot do this. Scope: Private. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 15/10/93 Definition at line 1295 of file osrndrgn.cpp. { // Swap brushes CurrentBrush = 1 - CurrentBrush; // Make the new brush CreateNewBrush(); // Set up the brush origin if (!RFlags.Metafile) { // RenderBrush[CurrentBrush]->UnrealizeObject(); // this fn will assert if done on a metafile PORTNOTE("other","OSRenderRegion::SelectNewBrush - removed setting of brush origin"); #if !defined(EXCLUDE_FROM_XARALX) RenderDC->SetBrushOrg(NewBrushOrg); #endif } // And select the new brush RenderDC->SetBrush(RenderBrush[CurrentBrush]); // Set winding rule as required if (RR_WINDINGRULE() == EvenOddWinding) nFillStyle = wxODDEVEN_RULE; else nFillStyle = wxWINDING_RULE; // We've now got a valid brush RFlags.ValidBrush = TRUE; }

BOOL OSRenderRegion::SelectNewFont (  WORD  Typeface, BOOL  Bold, BOOL  Italic, MILLIPOINT  Width, MILLIPOINT  Height, ANGLE  Rotation )  [protected]

Selects the specified font into the DC. Performs clever stuff to cache the font so that subsequent requests for the same font don't cause anything to happen. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 05/28/95 Parameters: Details  of the font to select. [INPUTS] NB. Width is not the actual width; it expresses the aspect ratio required. So, e.g. if Width == Height/2 then the aspect ratio is 50%, and so on. Returns: TRUE if the font was selected ok; FALSE if not. Definition at line 1359 of file osrndrgn.cpp. { PORTNOTETRACE("text","OSRenderRegion::SelectNewFont - do nothing"); #ifndef EXCLUDE_FROM_XARALX // Check to see if it is cached if ((FontInfo.pRenderFont != NULL) && (FontInfo.Typeface == Typeface) && (FontInfo.Bold == Bold) && (FontInfo.Italic == Italic) && (FontInfo.Width == Width) && (FontInfo.Height == Height) && (FontInfo.Rotation == Rotation)) { // It is the same as the currently selected/cached font TRACEUSER( "Tim", _T("Using the cached font\n")); return TRUE; } // Is it rotated, and if so, can this DC do rotated fonts? if (Rotation != FIXED16(0)) { // Don't use GetDeviceCaps to ask printers about their capabilities! // It tells lies. // Even Worse - many printers claim to be unable to render rotated // text, when they are actually perfectly cpaable of doing so! // // So, to maintain compatibility with previous versions just test // a Preference here and if it's set return FALSE like 1.5 and all // previous versions did. if (PrintRotatedTextAsPaths) return FALSE; } TRACEUSER( "Tim", _T("Font cache invalid - generating font to use\n")); // Not the cached font - ok, deselect and delete the cached font. if (FontInfo.pOldFont != NULL) { RenderDC->SelectObject(FontInfo.pOldFont); FontInfo.pOldFont = NULL; } if (FontInfo.pRenderFont != NULL) { delete FontInfo.pRenderFont; FontInfo.pRenderFont = NULL; } ENUMLOGFONT *pEnumLogFont = FONTMANAGER->GetEnumLogFont(Typeface); if (pEnumLogFont == NULL) // Error return FALSE; // Create the font and select it into the DC TRY { FontInfo.pRenderFont = new wxFont; } CATCH (CMemoryException, e) { return FALSE; } END_CATCH // Work out the font weight - bold or normal? INT32 FontWeight = Bold ? FW_BOLD : FW_NORMAL; // Work out how big the font is, in logical pixels FIXED16 fxPixWidth = 0; FIXED16 fxPixHeight = 0; // if (RFlags.Metafile) // { // Metafile - don't care about the view scale // RenderView->GetPixelSize(&fxPixWidth, &fxPixHeight); // } // else // { RenderView->GetScaledPixelSize(&fxPixWidth, &fxPixHeight); // } INT32 FontWidth = (INT32) (Width / fxPixWidth.MakeDouble()); INT32 FontHeight = (INT32) (Height / fxPixHeight.MakeDouble()); if (FontHeight == FontWidth) { // Aspect ratio is 100% - use width of 0, and the GDI font engine gives us 100% // ratio automatically FontWidth = 0; } else { // Aspect ratio is not 100% - we need to do some clever stuff to work out // how wide we want the font to be. Because fonts are generally much taller // than they are wide, we can't just pass in FontWidth directly - we must // transform it to the correct width. // BODGETEXT: ideally, we should use a NEWTEXTMETRIC structure here, to work out // the correct width, but this involves calling EnumLogFontFamily() or // whatever, which is too slow. As the text code caches the LOGFONT // for each font, it could also cache the NEWTEXTMETRIC structure, // which this routine could then use. // Having said all that, this code seems to work! // Indeed the font manager code to cache the LOGFONTS could also // cache the NEWTEXTMETRIC structures (or the TEXTMETRIC structures // since NEWTEXTMETRIC structures only exist for TrueType fonts.) // But at the moment it doesn't - the whole of the font system // needs thinking through and rewriting. // ach - 15/08/96 // Create the font - the first time is to find out how wide the characters are, // so we can scale the width correctly. (So we give a width of 0 to get the normal // width for the given height) // (We do it at 100 units high so we get decent accuracy for the aspect ratio.) if (FontInfo.pRenderFont->CreateFont(-100, 0, 0, 0, FontWeight, Italic, FALSE, FALSE, DEFAULT_CHARSET, OUT_TT_PRECIS, CLIP_TT_ALWAYS, PROOF_QUALITY, DEFAULT_PITCH | FF_DONTCARE, pEnumLogFont->elfLogFont.lfFaceName) == 0) { // Unable to select the font. delete FontInfo.pRenderFont; FontInfo.pRenderFont = NULL; return FALSE; } // Used to hold information about the font TEXTMETRIC Metrics; if (TRUE) //RFlags.Metafile) { // Metafile - we need to use the screen DC to do this wxDC* pDesktopDC = CWnd::GetDesktopWindow()->GetDC(); // Get the metrics FontInfo.pOldFont = pDesktopDC->SetFont(FontInfo.pRenderFont); pDesktopDC->GetTextMetrics(&Metrics); // Select old font back into screen DC pDesktopDC->SetFont(FontInfo.pOldFont); CWnd::GetDesktopWindow()->ReleaseDC(pDesktopDC); } else { // Normal rendering - use the DC as we can use 'Getxxx' functions on it // because it is not a metafile DC. FontInfo.pOldFont = RenderDC->SelectObject(FontInfo.pRenderFont); // Get the metrics RenderDC->GetTextMetrics(&Metrics); // Select old font back into screen DC RenderDC->SelectObject(FontInfo.pOldFont); } // Scale the width by the font's aspect ratio: // ActualWidth = (RealWidth / Height) * Width FontWidth = MulDiv(Metrics.tmAveCharWidth, FontWidth, 100); // Delete the font delete FontInfo.pRenderFont; // Create the 'proper' font and select it into the DC TRY { FontInfo.pRenderFont = new CFont; } CATCH (CMemoryException, e) { return FALSE; } END_CATCH } // Work out the rotation of the font, in tenths of degrees. INT32 lfRotation; if (Rotation == FIXED16(0)) lfRotation = 0; else lfRotation = (INT32) ( (Rotation.MakeDouble() * 360.0 * 10.0) / (2 * PI) ); // Create the font with the correct width if (FontInfo.pRenderFont->CreateFont(-FontHeight, FontWidth, lfRotation, 0, FontWeight, Italic, FALSE, FALSE, DEFAULT_CHARSET, OUT_TT_PRECIS, CLIP_TT_ALWAYS, PROOF_QUALITY, DEFAULT_PITCH | FF_DONTCARE, pEnumLogFont->elfLogFont.lfFaceName) == 0) { // Unable to select the font - probably because device cannot rotate fonts // arbitrarily. delete FontInfo.pRenderFont; FontInfo.pRenderFont = NULL; return FALSE; } // Select the real font into the DC. FontInfo.pOldFont = RenderDC->SetFont(FontInfo.pRenderFont); // Validate the cache FontInfo.Typeface = Typeface; FontInfo.Bold = Bold; FontInfo.Italic = Italic; FontInfo.Width = Width; FontInfo.Height = Height; FontInfo.Rotation = Rotation; #endif // Font created and selected ok return TRUE; }

void OSRenderRegion::SelectNewPen (   )  [protected]

Definition at line 1247 of file osrndrgn.cpp. { // Swap pens CurrentPen = 1 - CurrentPen; // Create and select the new pen CreateNewPen(); RenderDC->SetPen(RenderPen[CurrentPen]); RFlags.ValidPen = TRUE; }

BOOL OSRenderRegion::SetClipToPathTemporary (  Path * const  PathToDraw  )  [protected]

To set a complex clip path. This clip is pretty temporary and should be reset afterwards using OSClipRegion before anything much else is done. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 20/4/94 Parameters: A  path to be clipped to (in DocCoords). [INPUTS] -  [OUTPUTS] Returns: TRUE if worked, FALSE if failed (e.g. not enough memory or cannot do it). Errors: - Scope: Private Definition at line 2666 of file osrndrgn.cpp. { PORTNOTETRACE("other","OSRenderRegion::SetClipToPathTemporary - do nothing"); #ifndef EXCLUDE_FROM_XARALX BOOL Worked; Worked = RawRenderPath32( PathToDraw ); if (Worked) { // Worked = ::SelectClipPath( RenderDC, RGN_AND ); if (!Worked) TRACE( _T("SelectClipPath failed")); } else TRACE( _T("RawPath32 failed in Clip")); return Worked; #else return FALSE; #endif }

void OSRenderRegion::SetFillAttributes (  ChangeAttrType  Type = CHANGEATTR_ALL  )  [protected, virtual]

When a fill attribute is changed, this functions is called to create a new brush to mirror the new attribute value. Scope: Private. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/93 Parameters: Ignored  for OSRenderRegion. [INPUTS] Reimplemented from RenderRegion. Definition at line 935 of file osrndrgn.cpp. { RFlags.ValidBrush = FALSE; }

void OSRenderRegion::SetFixedSystemTextColours (  DocColour *  TextCol, DocColour *  Background )  [virtual]

To set the text and background colour(s) for any FixedSystem text rendered in this render region in the future (within the current rendering pass). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 12/1/95 Parameters: TextCol  - The foreground (text) colour (may be NULL) [INPUTS] Background - The background colour (may be NULL) Notes: If either of the colours is passed in as a NULL pointer, that colour will not be set, and will remain at the previous setting. Note that these values are passed directly to the host OS at the point of calling, so you must call this method every time the colour is changed (i.e. don't rely on just changing the DocColours that you passed in originally, as they aren't remembered in any way). Note also that if you call DrawFixedSystemText without a prior call to this method, the colours used are undefined. The colour chosen may not exactly match the colour requested - under Windows, for example, the nearest solid (non-dithered) colour to that requested will be used. Thus, it is best to stick to 'simple' colour schemes. This method may or may not affect some other rendering processes (for example, under Windows, plotting of bitmaps may be affected by the settings used here...) See also: OSRenderRegion::DrawFixedSystemText Reimplemented from RenderRegion. Definition at line 2317 of file osrndrgn.cpp. { if (TextCol != NULL) { COLORREF Clr = ConvertColourToScreenWord(CurrentColContext, TextCol); RenderDC->SetTextForeground(Clr); } if (Background != NULL) { COLORREF Clr = ConvertColourToScreenWord(CurrentColContext, Background); RenderDC->SetTextBackground(Clr); } }

void OSRenderRegion::SetLineAttributes (  ChangeLineAttrType  Type = CHANGELINEATTR_ALL  )  [protected, virtual]

When a line attribute is changed, this functions is called to create a new pen to mirror the new attribute value. Scope: Private. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/93 Reimplemented from RenderRegion. Definition at line 917 of file osrndrgn.cpp. { RFlags.ValidPen = FALSE; }

void OSRenderRegion::SetOSDrawingMode (  void   )  [protected, virtual]

Sets the current drawing mode. Scope: Private. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/93 Implements RenderRegion. Definition at line 1584 of file osrndrgn.cpp. { // Set ROP2 code accordingly. switch (DrawingMode) { case DM_COPYPEN: if (!RenderDC->IsKindOf(CLASSINFO(wxPostScriptDC))) // ignore for PS as it is the only option and RenderDC->SetLogicalFunction(wxCOPY);// it asserts (ridiculous but true) break; case DM_EORPEN: case DM_EORDITHER: // Same as EORPEN, except we want the brush to be set to what we ask for, // and not messed about with, so we use this enum value instead. // The ROP2 code is the same as we use for DM_EORPEN - it is CalcLogBrush() // that behaves differently with DM_EORDITHER. RenderDC->SetLogicalFunction(wxXOR); break; default: ERROR3("Bad drawing mode in OSRenderRegion::SetOSDrawingMode()"); } // When we change the ROP2 code, we also have to recreate the pen and brush objects, // otherwise we don't get an awful lot happening. This was found out by trial and // error, and not by any of Microsoft's manuals telling us this...(Tim) SetLineAttributes(); SetFillAttributes(); }

void OSRenderRegion::SetQualityLevel (  void   )  [protected, virtual]

Called when Quality level changes. We do nothing currently. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 24/4/93 Reimplemented from RenderRegion. Definition at line 950 of file osrndrgn.cpp. { }

void OSRenderRegion::SetSolidColours (  BOOL  SetSolid  )  [virtual]

Allows the dithering of colours to be turned off so they look the same using GDraw as they do with the GDI. In OSRenderRegions, this causes any attached GBrush technology to drop into/out of solid colour mode. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 16/5/95 Parameters: SetSolid  - TRUE to turn off dithering of colours [INPUTS] Reimplemented from RenderRegion. Definition at line 1788 of file osrndrgn.cpp. { if (GDrawBrush.Available()) GDrawBrush.SetSolidColours(SetSolid); }

BOOL OSRenderRegion::Split (  INT32  Px0, INT32  Py0, INT32  Px1, INT32  Py1, INT32  Px2, INT32  Py2, INT32  Px3, INT32  Py3, INT32  Flatness )  [protected]

Splits a bezier curve into two halves, and flattens each half. Scope: Private. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 25/6/93 Parameters: Many  INT32s - These are the x and y coords for the 4 control points of [INPUTS] a bezier Flatness - the flatness of the curve Returns: TRUE if bezier was successfully split and flattened to specified flatness; FALSE if buffer overflow occurred Definition at line 3126 of file osrndrgn.cpp. { // Calculate the first half of the curve INT32 lx0 = Px0; INT32 ly0 = Py0; INT32 lx1 = (Px0 + Px1)/2; INT32 ly1 = (Py0 + Py1)/2; INT32 lx2 = (Px0 + 2*Px1 + Px2)/4; INT32 ly2 = (Py0 + 2*Py1 + Py2)/4; INT32 lx3 = (Px0 + 3*Px1 + 3*Px2 + Px3)/8; INT32 ly3 = (Py0 + 3*Py1 + 3*Py2 + Py3)/8; // Calculate the second half of the curve INT32 rx0 = lx3; INT32 ry0 = ly3; INT32 rx1 = (Px1 + 2*Px2 + Px3)/4; INT32 ry1 = (Py1 + 2*Py2 + Py3)/4; INT32 rx2 = (Px2 + Px3)/2; INT32 ry2 = (Py2 + Py3)/2; INT32 rx3 = Px3; INT32 ry3 = Py3; if (InsertPos >= SIZEOF_POLYLINE_BUFFER) return FALSE; // stop recursion when buffer fills // Recurse for first half of curve if (!Bezier(lx0,ly0, lx1,ly1, lx2,ly2, lx3,ly3, Flatness)) // Failure - buffer overflow return FALSE; if (InsertPos >= SIZEOF_POLYLINE_BUFFER) return FALSE; // stop recursion when buffer fills // Recurse for second half of curve return Bezier(rx0,ry0, rx1,ry1, rx2,ry2, rx3,ry3, Flatness); }

BOOL OSRenderRegion::StartRender (  void   )  [virtual]

Initialises an OSRenderRegion for rendering. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 11/5/93 See also: OSRenderRegion::StopRender() Reimplemented from RenderRegion. Definition at line 1624 of file osrndrgn.cpp. { // Call base class first if (!RenderRegion::StartRender()) return FALSE; ENSURE(RenderDC != NULL,"StartRender Called when DC was Invalid"); // Check that Initialise hasn't been called already ENSURE(RenderFlags.Rendering == FALSE, "Initialise called whilst already rendering"); TRACEUSER("Gavin",_T("OSRenderRegion::StartRender - RenderFlags.Rendering = TRUE;\n")); RenderFlags.Rendering = TRUE; PixelScale = RenderView->GetPixelWidth(); InitClipping(); InitAttributes(); if (RFlags.UsePalette) OldPalette = PaletteManager::StartPaintPalette(RenderDC); GDrawBrush.Start(); #if defined(_DEBUG) && defined(__WXMSW__) // **** DEBUG BODGE - Make GDI redraw everything immediately // instead of buffering stuff, so we can see exactly when stuff goes wrong GdiSetBatchLimit(1); #endif return TRUE; }

BOOL OSRenderRegion::StopRender (  void   )  [virtual]

Stops the rendering of a OSRenderRegion, saving it's current renderstate so that rendering can continue where it left off, later on. If the RenderState passed is NULL then the RenderRegion will be unlinked from the list and will then delete itself. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 11/5/93 Parameters: RenderState  is a Node* pointing at the current rendering node in the tree, [INPUTS] or NULL if all objects rendered. See also: OSRenderRegion::StartRender() Implements RenderRegion. Definition at line 1672 of file osrndrgn.cpp. { // ************************************************************ // Some Debug code to plot the clipping rectangle #if 0 { TRACE( _T("OSRR# DebugClipRect = (%d, %d) - (%d, %d)\n"), CurrentClipRect.lo.x, CurrentClipRect.lo.y, CurrentClipRect.hi.x, CurrentClipRect.hi.y); DocRect TempRect(CurrentClipRect); TempRect.Inflate(-GetScaledPixelWidth()); TRACE( _T("OSRR# Filling = (%d, %d) - (%d, %d)\n"), TempRect.lo.x, TempRect.lo.y, TempRect.hi.x, TempRect.hi.y); Path ClipPath; ClipPath.Initialise(); ClipPath.CreatePathFromDocRect(&TempRect); SaveContext(); SetLineColour(COLOUR_TRANS); SetFillColour(COLOUR_RED); DrawPath(&ClipPath); RestoreContext(); } #endif #if 0 { SaveContext(); SetLineColour(COLOUR_TRANS); SetFillColour(COLOUR_BLUE); DocRect SmallRect(750, 750, 1500, 1500); Path ThePath; ThePath.Initialise(); ThePath.CreatePathFromDocRect(&SmallRect); DrawPath(&ThePath); ThePath.Translate(50, 1500); DrawPath(&ThePath); ThePath.Translate(50, 1500); DrawPath(&ThePath); ThePath.Translate(50, 1500); DrawPath(&ThePath); ThePath.Translate(50, 1500); DrawPath(&ThePath); ThePath.Translate(50, 1500); DrawPath(&ThePath); ThePath.Translate(50, 1500); DrawPath(&ThePath); ThePath.Translate(50, 1500); DrawPath(&ThePath); ThePath.Translate(50, 1500); DrawPath(&ThePath); ThePath.Translate(50, 1500); DrawPath(&ThePath); ThePath.Translate(50, 1500); DrawPath(&ThePath); ThePath.Translate(50, 1500); DrawPath(&ThePath); ThePath.Translate(50, 1500); DrawPath(&ThePath); ThePath.Translate(50, 1500); DrawPath(&ThePath); ThePath.Translate(50, 1500); DrawPath(&ThePath); ThePath.Translate(50, 1500); DrawPath(&ThePath); RestoreContext(); } #endif // ************************************************************ // Check that Initialise was called ENSURE(RenderFlags.Rendering, "DeInitialise called before Initialise"); DeInitClipping(); DeInitAttributes(); if (OldPalette) { PaletteManager::StopPaintPalette(RenderDC, OldPalette); OldPalette = NULL; } // Clean out the Fuzzy Rectangles InnerRect.MakeEmpty(); OuterRect.MakeEmpty(); TRACEUSER("Gavin",_T("OSRenderRegion::StopRender - RenderFlags.Rendering = FALSE;\n")); RenderFlags.Rendering = FALSE; GDrawBrush.Stop(); if (SepTables != NULL) { CCFree(SepTables); SepTables = NULL; } return TRUE; }

BOOL OSRenderRegion::StrokeProperly (  Path *  const  )

Definition at line 2700 of file osrndrgn.cpp. { const INT32 Flatten = ScaledPixelWidth/2; DashType* pDashRec = NULL; DashType GavinDash; // Don't do it if we have transparent stroke colour DocColour Col = RR_STROKECOLOUR(); if (Col.IsTransparent()) return TRUE; // Don't do dash patten if there isn't one, or if the line has zero width. if ((RR_DASHPATTERN().Elements == 0) || (RR_LINEWIDTH() == 0)) { // No dash pattern pDashRec = &GavinDash; MakeDashType(RR_DASHPATTERN(), pDashRec); } else { // Dash pattern - convert to Gavin-ness... MILLIPOINT Width = RR_LINEWIDTH(); DashRec &DashPattern = RR_DASHPATTERN(); if ((RRQuality.GetLineQuality() >= Quality::FullLine) && DashPattern.Elements > 0) { INT32 Length = DashPattern.Elements; if (Length > 8) Length = 8; BOOL DoScale = DashPattern.ScaleWithLineWidth; FIXED16 Scale = DoScale ? (double(Width) / double(DashPattern.LineWidth)) : 1; GavinDash.Length = Length; GavinDash.Offset = LongMulFixed16(DashPattern.DashStart, Scale); for (INT32 el = 0; el < Length; el++) { GavinDash.Array[el] = LongMulFixed16(DashPattern.ElementData[el], Scale); } pDashRec = &GavinDash; } } INT32 Result = GRenderRegion::StrokePathToPath( DrawPath->GetCoordArray(), DrawPath->GetVerbArray(), DrawPath->GetNumCoords(), ConvPoints, ConvVerbs, sizeof(ConvVerbs), FALSE, RR_LINEWIDTH(), Flatten, RR_STARTCAP(), RR_JOINTYPE(), pDashRec ); if (Result>0) { // Gavin has converted to another path - lets flatten & render that // switch filling colour to lines wxBrush NewBrush; #if TEST_MANUAL_LINES // for debugging, lets have a nice red pen and no fill NewBrush.CreateStockObject( NULL_BRUSH ); wxPen DPen(wxBLACK,0); wxPen DOldPen = GetPen(); RenderDC->SetPen( &DPen ); #else // no quality checks here cos we only do this for high quality // LOGBRUSH BrushType; // CalcLogBrush( &BrushType, RR_STROKECOLOUR() ); // NewBrush.CreateBrushIndirect( &BrushType ); CalcLogBrush(&NewBrush,RR_STROKECOLOUR()); #endif wxBrush OldBrush = RenderDC->GetBrush(); RenderDC->SetBrush(NewBrush); // we whip through Gavin's sub-paths manually so we are less likely to // run out of memory when flattening them. It also stops PolyPolygon from // rampantly filling them wrongly. The PointArray will be allocated the first // time and we leave it alone INT32 PathSizeLeft = Result; // items in Gavins path DocCoord* PathSoFar = ConvPoints; PathVerb* VerbSoFar = ConvVerbs; INT32 PolySize; // size of this chunk while (PathSizeLeft > 0) { // flatten little sub-path INT32 Read = RawRenderPath( PathSoFar, VerbSoFar, PathSizeLeft, &PolySize, NULL ); if (Read) { // (We don't bother to try again if GDI fails, as it is extremely unlikely as // we are only doing small Gavin sub-paths from the path stroking routines). RenderDC->DrawPolygon(PolySize,PointArray,0,0,nFillStyle); // render it PathSoFar += Read; // inc pointers etc VerbSoFar += Read; PathSizeLeft -= Read; ENSURE(PathSizeLeft>=0, "Path backwards too far"); } else { TRACE( _T("RawRenderPath failed\n")); break; // stop as we don't know how far to continue } } RenderDC->SetBrush( OldBrush ); #if TEST_MANUAL_LINES RenderDC->SetPen( DOldPen ); DPen.DeleteObject(); #endif return TRUE; } else if (Result<0) { return FALSE; // as Gavin couldn't do it } else return TRUE; // no points is not an error }

DocRect OSRenderRegion::WinRectToDoc (  const Matrix &  RenderMatrix, const WinRect &  WRect, const double  dpi )  [static]

To convert a rectangle in Windows coordinates to a rectangle in Document (spread) coordinates taking account of the destination dpi. Does not need the extra parameters that the above uses. Scope: Static. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 31/08/2004 Parameters: WinRect  is a rectangle in Windows co-ords. [INPUTS] dpi is the resolution of the device we are rendering to Returns: Object containing the new rectangle coordinates. Definition at line 4016 of file osrndrgn.cpp. { DocRect dr; WinCoord WinLo(WRect.x, WRect.GetBottomEx()); WinCoord WinHi(WRect.GetRightEx(), WRect.y); OilCoord OilLo = OilCoord( LongMulFixed16(WinLo.x, 72000L / dpi), -LongMulFixed16(WinLo.y, 72000L / dpi) ); OilCoord OilHi = OilCoord( LongMulFixed16(WinHi.x, 72000L / dpi), -LongMulFixed16(WinHi.y, 72000L / dpi) ); Matrix inv = RenderMatrix.Inverse(); dr.lo.x = MatrixCalc( inv.a, OilLo.x, inv.c, OilLo.y ) + inv.e; dr.lo.y = MatrixCalc( inv.b, OilLo.x, inv.d, OilLo.y ) + inv.f; dr.hi.x = MatrixCalc( inv.a, OilHi.x, inv.c, OilHi.y ) + inv.e; dr.hi.y = MatrixCalc( inv.b, OilHi.x, inv.d, OilHi.y ) + inv.f; // RenderMatrix can involve a rotation (but only multiples of 90 degrees), so we swap // the corners here if necessary MILLIPOINT Temp; if (dr.lo.x > dr.hi.x) { Temp = dr.lo.x; dr.lo.x = dr.hi.x; dr.hi.x = Temp; } if (dr.lo.y > dr.hi.y) { Temp = dr.lo.y; dr.lo.y = dr.hi.y; dr.hi.y = Temp; } return dr; }

---

Member Data Documentation

RRCaps OSRenderRegion::Caps [protected]

Definition at line 420 of file osrndrgn.h.

INT32 OSRenderRegion::CurrentBrush [protected]

Definition at line 407 of file osrndrgn.h.

INT32 OSRenderRegion::CurrentPen [protected]

Definition at line 406 of file osrndrgn.h.

BOOL OSRenderRegion::DoBetterLines [static]

Definition at line 274 of file osrndrgn.h.

EORCacheClass OSRenderRegion::EORCache [static, protected]

Definition at line 396 of file osrndrgn.h.

OSRRFontInfo OSRenderRegion::FontInfo [protected]

Definition at line 414 of file osrndrgn.h.

GBrush OSRenderRegion::GDrawBrush [protected]

Definition at line 386 of file osrndrgn.h.

INT32 OSRenderRegion::HitTestRadius = 3 [static, protected]

Allows the user to determine how close a mouse click can be to an object before the object is hit-tested successfully. Measured in pixels. Defaults to 3. Preference: HitTestRadius Section: Mouse Range: 0 to 10 Definition at line 285 of file osrndrgn.h.

INT32 OSRenderRegion::InsertPos [protected]

Definition at line 398 of file osrndrgn.h.

BOOL OSRenderRegion::Metafile [protected]

Definition at line 375 of file osrndrgn.h.

wxPoint OSRenderRegion::NewBrushOrg [protected]

Definition at line 417 of file osrndrgn.h.

INT32 OSRenderRegion::nFillStyle [protected]

Definition at line 403 of file osrndrgn.h.

wxFont* OSRenderRegion::OldFont [protected]

Definition at line 412 of file osrndrgn.h.

wxPalette* OSRenderRegion::OldPalette [protected]

Definition at line 384 of file osrndrgn.h.

wxRegion* OSRenderRegion::OSClipRegion [protected]

Definition at line 383 of file osrndrgn.h.

FIXED16 OSRenderRegion::PixelScale [protected]

Definition at line 401 of file osrndrgn.h.

wxPoint OSRenderRegion::PointArray [static, protected]

Definition at line 393 of file osrndrgn.h.

wxBrush OSRenderRegion::RenderBrush[2] [protected]

Definition at line 409 of file osrndrgn.h.

wxPen OSRenderRegion::RenderPen[2] [protected]

Definition at line 408 of file osrndrgn.h.

struct { ... } OSRenderRegion::RFlags [protected]

BYTE* OSRenderRegion::SepTables [protected]

Definition at line 423 of file osrndrgn.h.

BOOL OSRenderRegion::UsePalette [protected]

Definition at line 379 of file osrndrgn.h.

BOOL OSRenderRegion::ValidBrush [protected]

Definition at line 378 of file osrndrgn.h.

BOOL OSRenderRegion::ValidPen [protected]

Definition at line 377 of file osrndrgn.h.

---

The documentation for this class was generated from the following files:

• wxOil/osrndrgn.h (r1785/r1282)
• wxOil/osrndrgn.cpp (r1785/r1571)

---