GRenderRegion Class Reference

Encapsulates rendering using Gavins routines (ie. into a bitmap). This object is created when something needs rendering using Gavins routines eg. When anti-aliasing. See RenderRegion notes for more general details of this class. This is an abstract class - see GRenderDIB or GRenderDDB for implementations. More...

#include <grndrgn.h>

Inheritance diagram for GRenderRegion:

List of all members.

Public Member Functions
	GRenderRegion ()
	GRenderRegion (DocRect ClipRegion, Matrix ConvertMatrix, FIXED16 ViewScale, UINT32 Depth, double dpi)
	Constructor for a GRenderRegion. 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.
virtual	~GRenderRegion ()
	Default Destructor for GRenderRegion Class. Frees up memory.
virtual BOOL	CopyRenderInfo (const RenderRegion &Other)
	Copies all the parameters from the render region 'Other' into this render region. This was written for the region merging code. When a new region is created, due to existing regions being split up, it should be based on the original region, with a different clipping rectangle.
virtual BOOL	AttachDevice (View *, wxDC *, Spread *=NULL, bool fOwned=false)
virtual BOOL	InitDevice ()
	Initialises the render region's connection to the device information passed in to RenderRegion::AttachDevice.
BOOL	StartRender ()
	Initialises an GRenderRegion for rendering. Sets up a bitmap and gmatrix ready for gdraw rendering.
BOOL	StopRender ()
	Stops the rendering of a GRenderRegion, saving it's current renderstate so that rendering can continue where it left off, later on. Copies the gdraw internal bitmap to its final resting place (e.g. the screen). Also tidies up windows' palette.
virtual void	SetClean (BOOL bResetChangedBounds, BOOL FillWhite)
	Informs the GRenderRegion that it should consider it's bitmap image to be clean, i.e. it's an accurate representation of what is on screen already, so there is no need to blit it. This is used in conjunction with the PaperRenderRegion to avoid unnecessary blits.
virtual BOOL	IsClean ()
void	DrawPathToOutputDevice (Path *PathToDraw, PathShape shapePath=PATHSHAPE_PATH)
	Renders a path object using gavins routines.
void	DrawRect (DocRect *RectToRender)
void	DrawDragRect (DocRect *RectToRender)
void	DrawLine (const DocCoord &StartPoint, const DocCoord &EndPoint)
void	DrawBlob (DocCoord p, BlobType type)
void	DrawPixel (const DocCoord &Point)
void	DrawCross (const DocCoord &Point, const UINT32 Size)
void	DrawBitmap (const DocCoord &Point, KernelBitmap *pBitmap)
void	DrawBitmap (const DocCoord &Point, UINT32 BitmapID, UINT32 ToolID=NULL)
void	DrawBitmap (const DocRect &rect, KernelBitmap *pBitmap)
void	DrawBitmapBlob (const DocCoord &Point, KernelBitmap *BlobShape)
void	DrawBitmapBlob (const DocCoord &Point, ResourceID resID)
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 RenderRegion::DrawFixedSystemText.
void	InitClipping ()
void	InitAttributes ()
void	SetLineAttributes ()
void	SetFillAttributes ()
void	SetOSDrawingMode ()
void	SetQualityLevel ()
	Does nothing.
void	Restore (RenderRegion *)
BOOL	RenderGradFillPath (Path *, GradFillAttribute *)
	Fills a grad filled path (linear or radial).
BOOL	RenderBitmapFill (Path *, BitmapFillAttribute *)
virtual void	SetSolidColours (BOOL SetSolid)
GDrawContext *	GetDrawContext () const
virtual WinRect	CalculateWinRect (Matrix &RenderMatrix, const DocRect &docrect, const double dpi)
	To create bitmap from wxBitmap structure. To free bitmap To convert a rectangle in Doc coordinates to a rectangle in Win coordinates taking account of the destination dpi rather than assuming screen dpi. Virtual so that it can be overriden by different render regions if so required.
virtual WinRect	CalculateWinRect (const DocRect &docrect)
void	SetDeepDIB (BOOL Value)
const RGBQUAD *	Get32BitRGBQuadData ()
UINT32	GetSizeOfRGBQuadData ()
void	SetDoCompression (BOOL bDoCompression)
void	SetDoBitmapConversion (BOOL bEnable)
DocRect	GetChangedRect ()
void	SetBitmapPointers (LPBITMAPINFO bi, LPBYTE by)
BOOL	GetBitmapPointers (LPBITMAPINFO *ppInfo, LPBYTE *ppBits, BOOL bCorrectTransparency=TRUE)
double	GetScaledPixelWidthDouble ()
void	SetSimulatePrinting (UINT32 PrintType)
virtual void	GetRenderRegionCaps (RRCaps *pCaps)
	This function allows a render region to declare what it can render and what it can not render. This base class version of the function says that it can render none of the options. If your render region can do some of these things then you should overide this function and set the appropriate flags.
virtual SlowJobResult	DrawMaskedBitmap (const DocRect &Rect, KernelBitmap *pBitmap, MaskedRenderRegion *pMask, ProgressDisplay *Progress)
	Plots the bitmap using the mask supplied. The base class implementation here does nothing.
void	SetForceBitmapSmoothing (BOOL ForceSmoothing)
BOOL	IsForcingBitmapSmoothing ()
void	SetDitherStyle8Bit (INT32 DitherStyle)
virtual void	ResetRegion (DocRect &NewClipRect)
	Resets the render region (after it has been merged), so that it no longer thinks it is banded etc. It also takes the Regions rectangle from the Current Clipping rectangle, so set this correctly before calling this function.
void	FreeOffscreenState ()
virtual void	SetOffscreen (OffscreenAttrValue *)
	Create a new bitmap into which, the subtree rooted at this attributes parent, will be rendered. Then call base version to push the current OffscreenAttr onto the context stack.
virtual void	RestoreOffscreen (OffscreenAttrValue *)
BOOL	RenderBitmapWithTransparency (Path *, BitmapFillAttribute *, BitmapTranspFillAttribute *)
	Helper function for RenderBitmapFill and SetBitmapTransparencyFill. Used to work out whether or not to smooth bitmap fills/transparencies. Helper function for RenderBitmapFill and SetBitmapTransparencyFill. Used to work out whether or not to smooth bitmap fills/transparencies. Helper function for RenderBitmapFill and SetBitmapTransparencyFill. Used to work out whether or not to smooth bitmap fills/transparencies. Helper function for RenderBitmapFill and SetBitmapTransparencyFill. Used to work out whether or not to smooth bitmap fills/transparencies. Helper function for RenderBitmapFill and SetBitmapTransparencyFill. Sets the smoothing flags using SetBitmapSmoothingFlag and SetTileFilteringFlag. These flags determine the quality of subsequent SetBitmapFill / SetTransparentBitmapFill operations. Fills a shape with a bitmap Initialises a Transparency fill. Scope: ProtectedSets up a fractal fill. Scope: ProtectedSets up a fractal transparency fill. Scope: ProtectedRenders a rectangle using gavins routines. Rectangles are not anti-aliased. Does NOTHING AT ALL as gdraw cannot do xor plotting Does NOTHING AT ALL as gdraw cannot do xor plotting Renders a line using gdraw. 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.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.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.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.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).To determine how much room is needed to plot a bit of text with GRenderRegion::DrawFixedSystemTextDraw an Arrow head on the start or end of a line. Updates the GMATRIX used for rendering. Make a Gavin Matrix out of a Kernel Matrix Sets Gavins drawing colour. He does not distinguish between line & fill colours - the caller has to do that. Sets Gavins drawing colour. He does not distinguish between line & fill colours - the caller has to do that. Allows the dithering of colours to be turned off so they look the same using GDraw as they do with the GDI.Calculates the size of a Pixel in MILLIPOINTS, based on the output DPI but IGNORES the scale factor. Calculates the size of a Pixel in MILLIPOINTS, based on the output DPI but IGNORES the scale factor. Calculates the size of a Pixel in MILLIPOINTS, based on the output DPI and current scale factor. Calculates the size of a Pixel in MILLIPOINTS, based on the output DPI and current scale factor. Returns the true scaled pixel width of this GRenderRegion, to the accuracy of a double. GetScaledPixelWidth() returns a whole number, which is highly inaccurate at high zooms - eg SPW at 6031% is usually 750 / 60.31 = 12.44ish but GetScaledPixelWidth() returns 12. This method is useful if your code needs precise conversion between millipoints and pixels.Called after the Quality setting has been changed on the region. We have to recalculate the antialiasing & flatness settings. Also used by StartRender.Gets ready to do actual rendering. In this case it does nothing. bitmap. Initialise the device specific mechanisms for this render region. IN this case the bitmap is allocated, so can fail. Determines whether a GRenderRegion can be created for rendering. A NULL return should NOT be tested with ENSURE, it is a perfectly valid return result. Slightly misleading name for historic reasons. Actually plots any depth bitmap on any device, without any special handling. Use as a fallback when the more specialist versions are not suitable.Plot high colour bitmap (16 or 32-bits) to a 256 colour device. If we let GDI do this it would take a very long time, so we convert to an intermediate bitmap first. NEW - also plots to a 16-colour device. Will ENSURE if not 16- or 256-colours.If can do PAL_INDICES, just does that, else fills in the RGB quads in the DIB and returns DIB_RGB_COLOR. Only really make sense to call on 16 or 256 colour bitmaps. Plot the DIB as fast as possible to the display surface. IMPORTANT: Only works on SCREEN devices. Plot the DIB as fast as possible to the display surface. Member function version. There is also a more general static version (which this uses). This member fn one uses the ChangedBBox for optimal blitting. Plot a bitmap to a device of the same colour depth.For the main window to get a Gavin-approved logical palette. Scope: StaticDraws a cross in the render region. The cross consists of a vertical line 'Size' millipoints high, and a horizontal line 'Size' millipoints wide.Used to know whether StrokePathToPath will fail. If we don't have GDraw, we cannot do this, if we do, we can. Scope: StaticUsed for rendering complex strokes when the native system cannot do it (e.g. GDI16). Scope: StaticInitialises GDraw for rendering into 8bpp bitmapsCalls SelectPalette for the static GDraw context and sets the palette Scope: Static publicSets up a sensible palette for error diffusion It sets 3 of the entries to black to avoid them being used Scope: Static protectedGiven a ptr to a ClipRegionAttribute, generate an appropriate GDraw clipping region and return it. Sets the flag which indicates that we are rendering to a 32bit bitmapDelete and free memory used by all clip regions which this render region has stored.Intended solely for use by the feathering and shadowing systems, both of which make use of a bitmap blurring algorithm which can sometimes return a blurred bitmap up and right by half a pixel.This function allows a GRenderRegion to declare what it can render and what it can not render. This allows us to pretend to be a simple render region when doing onscreen print previews.This function tells a GRenderRegion to simulate printing This allows us to pretend to be a simple render region when doing onscreen print previews.Plots the bitmap using the mask supplied.Plots the bitmap using the mask supplied.To get the changed rectangle so far To start a bitmap capture of whatever is subsequently rendered To stop a bitmap capture To inform the capture stack that things (transparency) have changedTo setup a direct capture if that is possible Render the current state of the capture stack into the specified bitmap (For use when rendering is interrupted) (For use when capture must be collapsed from 32BPP to 24BPP without affecting the master bitmap)Search down the Capture stack from the top or from the capture specified until we find one that owns a bitmap. The master capture at the bottom of the stack should ALWAYS own a bitmap!Render the current state of the capture stack into the specified bitmap (For use when rendering is interrupted)To connect this renderregion to a bitmap along with clipping and view transformation information (a "capture") Discover whether this transparency type can be rendered into RGBT bitmap by GDraw. (Things like stain and bleach cannot be accurately captured in the T channel of the RGBT bitmap.) Map Camelot's internal transp type to GDraw's transp type Notes: This function only understands FLAT and GRAD - it will never map a Camelot transparency type to one of GDraw's "Colour and transp" valuesTo set the bitmap pointers for the master capture only, updating both the working members and the versions stored in the master capture. To get the bitmap pointers for the master capture only. Toggles state of gdraw flag then forces a redraw. Constructor for OpGDraw operation. It is not undoable. This item is always available when GDraw is available.
virtual BOOL	IsWrappedRender () const
virtual BOOL	TranspTypeIsRGBTCompatible (UINT32 ttype) const
TransparencyEnum	MapTranspTypeToGDraw (UINT32 ttype, BOOL bGraduated) const
virtual Capture *	StartCapture (CCObject *pOwner, DocRect CaptureRect, CAPTUREINFO cinfo, BOOL bTransparent=TRUE, BOOL bCaptureBackground=FALSE, double mpPixelWidth=0, NodeRenderableInk *pDirectSupplier=NULL)
	To start a bitmap capture of whatever is subsequently rendered.
virtual BOOL	StopCapture (CCObject *pOwner, BOOL bRender=TRUE, BOOL bReleaseBitmap=FALSE, LPBITMAPINFO *plpBitmapInfo=NULL, LPBYTE *plpBits=NULL, DocRect *pCaptureRect=NULL, Matrix *pmatTransform=NULL, double *pdResolution=NULL)
	To stop a bitmap capture.
virtual BOOL	ChangeCapture (CAPTUREINFO cinfo, BOOL bTransparent=TRUE, BOOL bCaptureBackground=FALSE)
	To inform the capture stack that things (transparency) have changed.
virtual BOOL	MasterCaptureIsCurrent () const
virtual BOOL	RenderCurrentCaptureState (BOOL bStartFromMaster=FALSE)
virtual Capture *	GetTopCaptureBitmap (Capture *pFromCapture=NULL) const
virtual BOOL	TopCaptureIsDirect ()
virtual void	SetClipRegion (ClipRegionAttribute *pClipAttr, BOOL Temp)
	Set the current ClipRegion for this RenderRegion. pClipAttr contains a path, and all future rendering will occur *through* that clipping path, after it is clipped to any pre-existing clipping region.
virtual void	RestoreClipRegion (ClipRegionAttribute *pClipAttr, BOOL Temp)
	Set the current ClipRegion for this RenderRegion. pClipAttr contains a path, and all future rendering will occur *through* that clipping path, after it is clipped to any pre-existing clipping region.
void	OffsetByHalfPixel ()
virtual BOOL	GrabBitmap (DocRect *rectGrab, LPBITMAPINFO *plpBitmapInfo, LPBYTE *plpBits)
Static Public Member Functions
static BOOL	Init ()
	Initialise the render region.
static RenderRegion *	Create (DocRect ClipRegion, Matrix ConvertMatrix, FIXED16 ViewScale, RenderType, View *pView=NULL, BOOL bForce32BPP=FALSE)
static BOOL	Init (BOOL)
	Determine possibility of using gdraw routines and determine various characterisitics of the screen.
static void	DeInit ()
	Call once during termination to perform any necessary cleanup.
static BOOL	CalcBlitMode (INT32 Wanted)
static GDrawContext *	SetTempDrawContext (GDrawContext *pContext)
static GDrawContext *	GetStaticDrawContext ()
static GDrawContext *	GetStaticDrawContext (INT32 DitherType)
static INT32	GetDefaultTransparency ()
static UINT32	SetPaletteEntries (LPBITMAPINFO lpBmi, wxDC *pOutputDC=NULL)
static LPBYTE	StaticPlotBitmap (wxDC *pDC, UINT32 ColourFlag, LPBITMAPINFO lpBitmapInfo, LPBYTE lpBits, INT32 Left, INT32 Top, UINT32 Width, UINT32 Height, wxPalette *hPal, INT32, INT32)
static const LOGPALETTE *	GetRecommendedPalette ()
static BOOL	StrokePathAvailable ()
static INT32	StrokePathToPath (CONST DocCoord *IPoints, CONST BYTE FAR *ITypes, size_t ILength, DocCoord *OPoints, BYTE *OTypes, DWORD OLength, BOOL Close, DWORD LineWidth, DWORD Flattening, LineCapType LineCaps, JointType LineJoin, CONST DashType *Dash)
static void	GColInit (wxDC *, BOOL=FALSE)
static void	PaletteHasChanged ()
static void	EnsurePalette (INT32 PaletteFlag)
static LPLOGPALETTE	GetErrorDiffPalette (void)
static void	SetViewDither (INT32 dither)
static DWORD	GetMaxBitmapWidth (void)
static DWORD	GetMaxBitmapDepth (void)
static INT32	GetDefaultDPI ()
Protected Member Functions
GMATRIX	SetGavinMatrix (GMATRIX *GMatrix)
virtual GMATRIX	MakeGavinMatrix (Matrix NewRenderMatrix, DocRect ClipRect, double PixelsPerInch, BOOL bMasterCapture)
virtual double	GetPixelsPerInch ()
MILLIPOINT	CalcPixelWidth ()
double	CalcPixelWidthDouble ()
MILLIPOINT	CalcScaledPixelWidth ()
double	CalcScaledPixelWidthDouble ()
BOOL	GetTransparencyFill (TranspGradTable *, DWORD *)
virtual BOOL	DrawArrowHead (ArrowRec &ArrowToDraw, DocCoord &Centre, DocCoord &Direction)
BOOL	SetBitmapTransparencyFill (TranspFillAttribute *, DWORD *, TranspGradTable *)
BOOL	SetFractalFill (ColourFillAttribute *, DWORD *)
BOOL	SetFractalTransparencyFill (TranspFillAttribute *, DWORD *)
virtual LPBITMAPINFO	GetLPBits (INT32 Width, INT32 Height, INT32 Depth, LPBYTE *)=0
virtual void	FreeLPBits (LPBITMAPINFO, LPBYTE)=0
virtual BOOL	DisplayBits (LPBITMAPINFO lpDisplayBitmapInfo=NULL, LPBYTE lpDisplayBits=NULL)=0
virtual void	InitBmpBits ()
virtual BOOL	StartRenderAfter (GMATRIX *)
	A virtual fn in this class which can be overridden if more work on a GMatrix is required. Default version returns TRUE.
virtual BOOL	StartRenderMiddle ()
	A virtual fn in this class which can be overridden if more work on a lpBits is required. Default version returns TRUE.
virtual void	DisplayCurrentState ()
	Make a temporary bitmap, copy current GRenderRegion bitmap into it then render other offscreen state into it before blitting it to screen Notes: This routine does a lot of bitmap copying and blitting so it is much slower than just blitting the current bitmap to screen!
void	Display1to1Bitmap ()
void	DisplayLtoHBitmap ()
void	DisplayHto8Bitmap ()
void	PlotBitmap (UINT32 ColourFlag)
void	PlotBitmap (wxDC *pDC, UINT32 ColourFlag, INT32 Left, INT32 Top, UINT32 Width, UINT32 Height, wxPalette *hPal, INT32, INT32)
virtual BOOL	SetRenderToCapture (Capture *pCapture, BOOL bApplyClipRegion=FALSE, BOOL bSetBitmap=TRUE)
virtual BOOL	SetupDirectCapture (Capture *pNewCapture, NodeRenderableInk *pSupplier)
void	SetIsWrapped (BOOL flag)
const REGION *	MakeClipRegionFromClipAttr (ClipRegionAttribute *pClipAttr)
BOOL	ApplyCurrentClipRegion ()
	Have a look at the current ClipRegionAttribute and make sure we set our clipping region accordingly. Details within the method.
void	FreeStoredClipRegions ()
BOOL	IsScaledUp (FillGeometryAttribute *Fill)
BOOL	IsAt100Percent (FillGeometryAttribute *Fill)
BOOL	IsDistorted (FillGeometryAttribute *Fill)
BOOL	NeedToSmooth (FillGeometryAttribute *Fill, BOOL bAlreadyScaled)
virtual BOOL	SetSmoothingFlags (FillGeometryAttribute *Fill)
Static Protected Member Functions
static void	UpdateErrorDiffPalette (void)
Protected Attributes
GMATRIX	CurrentGMatrix
RRCaps	Caps
LPBITMAPINFO	pBitmapInfo
LPBYTE	pBits
UINT32	uBitmapDepth
UINT32	uLineSize
wxRect	WRect
wxRect	ScreenRect
double	PixelsPerInch
double	dScaledPixelWidth
wxPalette *	hPalette
wxPalette *	hPrevPalette
BOOL	LocalBitmap
BOOL	UseSolidColours
BOOL	m_bForceBitmapSmoothing
BOOL	m_bEnableConversion
BOOL	ForceInitBmpBits
INT32	DitherStyle8Bit
BOOL	HaveRenderedSomething
UINT32	m_ForcePrintingCaps
BOOL	IsWrapped
Static Protected Attributes
static GDrawContext *	pRealGD = NULL
static GDrawContext *	GD = NULL
static GDrawContext *	ErrorDiffContext = NULL
static UINT32	ClickTranspLimit = 255
	Determine how transparent rendered pixels may be before click detection will ignore them. E.g. 230 means pixels must be 90% transparent before they will be ignored.
static BOOL	HighQualityAA = FALSE
	Determine whether to use GDraw's high quality anti-aliasing mode.
static INT32	BitmapConversion = 2
	Specifies which bitmap conversion algorithm is used by GDraw when rendering bitmaps in show printer colours mode.
static BOOL	WantDoGDraw = TRUE
static UINT32	WantGDrawDepth
static BOOL	WantHighColourDirect
static BOOL	WantDeepGDraw
static INT32	WhichPalette
static INT32	WhichDither = 2
static INT32	WhichTransparency = 0
static INT32	ViewDither = 2
static BOOL	CanDoGDraw
static BOOL	CanDoPalIndices
static BOOL	CanSetPalette
static INT32	ScreenDepth
static INT32	ScreenWidth
static INT32	ScreenHeight
static INT32	LogPixelsX
static INT32	LogPixelsY
static LPRGBQUAD	Fixed256Palette
static BitmapConvertHint	ScreenHinting
static INT32	LastPaletteFlag
static RealLogPalette	ErrorDiffPalette
Private Member Functions
BOOL	SetGCol (DocColour &) const
BOOL	SetFillGCol (DocColour &) const
DocCoord	DocCoordToG (const DocCoord &DocPoint)
void	DocCoordToG (DocCoord *DocPoint)
BOOL	StrokePath (const DocCoord *, const PathVerb *, UINT32, const DocCoord *, const PathVerb *, UINT32, BOOL DrawArrows=FALSE)
	sets the immediate render flag to the value specified Sits on top of GDraw_StrokePath that calculates Joins, Caps & Width then renders via GDraw. Does dashed lines too now. Also renders ArrowHeads in needed.
Friends
class	GBrush
class	OpGDraw
class	GRenderRegionWrapper
class	ConcurrentRenderer
class	GDrawBorrower

---

Detailed Description

Encapsulates rendering using Gavins routines (ie. into a bitmap). This object is created when something needs rendering using Gavins routines eg. When anti-aliasing. See RenderRegion notes for more general details of this class. This is an abstract class - see GRenderDIB or GRenderDDB for implementations.

Author:

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

Date:

11/5/93

Definition at line 154 of file grndrgn.h.

---

Constructor & Destructor Documentation

GRenderRegion::GRenderRegion (   )

GRenderRegion::GRenderRegion (  DocRect  ClipRegion, Matrix  ConvertMatrix, FIXED16  ViewScale, UINT32  Depth, double  dpi )

Constructor for a GRenderRegion. 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. 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. Depth is bitmap depth required. dpi is the pixels-per-inch which can be zero for screen resolution. -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 850 of file grndrgn.cpp. : RenderRegion(ClipRegion, ConvertMatrix, ViewScale) { pBitmapInfo = NULL; pBits = NULL; #if USE_wxBITMAP pBitmap = NULL; pBitmapData = NULL; #endif // BitmapSize = 0; // If specified dpi is zero then use the calculated screen dpi otherwise use the specified value if (dpi == 0.0) PixelsPerInch = (double)LogPixelsX; else PixelsPerInch = dpi; ERROR3IF(PixelsPerInch < 4.0,"GRenderRegion PixelsPerInch < 4 dpi, is this good?"); hPalette = NULL; hPrevPalette = NULL; uBitmapDepth = Depth; //GAT FractalBitmap = NULL; UseSolidColours = FALSE; LocalBitmap = TRUE; // always local bitmap currently m_bEnableConversion = TRUE; dScaledPixelWidth = 0.0; if (LocalBitmap) { WRect = wxRect(0,0,0,0); // this ensure triggers up on bitmap export, so it is removed //ENSURE( (WRect.left>=0) && (WRect.top>=0), "neg wrect"); #if DEBUG_BORDER // kludge the rectangle slightly WRect.left += 2; WRect.width -= 4; WRect.top += 2; WRect.height -= 4; #endif } else ENSURE(FALSE, "Non local bitmap error"); // BG time slice should be 0.5 of a second due to blit overhead Timeslice = 500; // Set default dither type DitherStyle8Bit = WhichDither; m_DoCompression = FALSE; m_bForceBitmapSmoothing = FALSE; m_ForcePrintingCaps = FALSE; // Set the render caps up GetRenderRegionCaps(&Caps); // Ilan IsWrapped = FALSE; // Default to not forcing Init (allocation will force it anyway) ForceInitBmpBits = FALSE; RememberMe("Constructor"); }

GRenderRegion::~GRenderRegion (   )  [virtual]

Default Destructor for GRenderRegion Class. Frees up memory. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 15/5/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - GRenderRegion::FreeOffscreenState() Definition at line 934 of file grndrgn.cpp. { #ifdef RALPH #ifdef _DEBUG if(GetCurrentThreadId() == RalphDocument::GetImportingThreadID()) { TRACE( _T("Whoop Whoop... GRenderRegion::~GRenderRegion called from load thread\n")); AfxDebugBreak(); } #endif #endif if (RenderFlags.Rendering) { TRACE( _T("StopRender() was not called before destructor\n") ); StopRender(); } //GAT if (FractalBitmap) // delete FractalBitmap; // manual removal of the contents of our clip-maps. FreeStoredClipRegions(); RememberMe("Destructor"); }

---

Member Function Documentation

BOOL GRenderRegion::ApplyCurrentClipRegion (   )  [protected]

Have a look at the current ClipRegionAttribute and make sure we set our clipping region accordingly. Details within the method. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 14 April 2000 Parameters: [INPUTS]  GDraw  should have its clipping region and rectangle set so that rendering [OUTPUTS] only occurs within a region specified by the clipping path which the current ClipRegionAttribute is carrying. Returns: TRUE if successful, FALSE otherwise. Errors: ERROR3 in DEBUG if we have no valid ptr to a ClipRegionAttribute. See also: Definition at line 2392 of file grndrgn.cpp. { // return TRUE; // note that we don't bother with any clipping unless we're actually doing something // useful, eg rendering. if (!RenderFlags.Rendering) return FALSE; // This is what we do... // // 1. We keep a hash table containing clip regions, with an entry for each unique // ClipRegionAttribute, so that we do the time-consuming (I assume!) make-region // work as little as possible. // 2. If we haven't seen a ClipRegionAttribute before, then we make a region from/for // it and stick the association in the table for future look-up // 3. We apply the clip region appropriate to the current attribute. // 4. We do all the above for device clip rectangles too, which need to be re-applied // whenever a new clip region is applied. // remember the current clip region, or make a new one for the current clipattr. BOOL fSuccess = FALSE; const REGION* pClipRegion = NULL; ClipRegionAttribute* pClipAttr = RR_CLIPREGION(); ERROR3IF(pClipAttr == NULL, "Doh! NULL ClipRegionAttribute in render region!"); // if we don't have a clip-region, do a DeviceClipRectangle() with an 'infinite' rect. // this will reset GDraw's clip-rectangle to the size of its bitmap, and also // reset its clip-region to empty. if (pClipAttr->GetClipPath() == NULL) { RECT BigRect; BigRect.bottom = BigRect.left = INT32_MIN; BigRect.top = BigRect.right = INT32_MAX; fSuccess = GetDrawContext()->DeviceClipRectangle(&BigRect); } // try to look up a clip-region for this clip-attr; failing that, create a new one // and store it. else { // if (!m_ClipRegionMap.Lookup((void*)pClipAttr, ((void*&)pClipRegion))) // { // pClipRegion = MakeClipRegionFromClipAttr(pClipAttr); // m_ClipRegionMap.SetAt((void*)pClipAttr, ((void*&)pClipRegion)); // } pClipRegion = GetTopCaptureBitmap()->GetCachedClipRegion(pClipAttr); if (pClipRegion==NULL) { pClipRegion = MakeClipRegionFromClipAttr(pClipAttr); GetTopCaptureBitmap()->SetCachedClipRegion(pClipAttr, pClipRegion); } fSuccess = GetDrawContext()->ClipRegion(pClipRegion); } return fSuccess; }

virtual BOOL GRenderRegion::AttachDevice (  View *  , wxDC *  , Spread *  = NULL, bool  fOwned = false )  [virtual]

Reimplemented from RenderRegion. Reimplemented in GRenderClick, GRenderClickColour, and GRenderClickColourNoPaper.

static BOOL GRenderRegion::CalcBlitMode (  INT32  Wanted  )  [static]

MILLIPOINT GRenderRegion::CalcPixelWidth (   )  [protected, virtual]

Implements RenderRegion.

double GRenderRegion::CalcPixelWidthDouble (   )  [protected]

MILLIPOINT GRenderRegion::CalcScaledPixelWidth (   )  [protected, virtual]

Implements RenderRegion.

double GRenderRegion::CalcScaledPixelWidthDouble (   )  [protected]

WinRect GRenderRegion::CalculateWinRect (  const DocRect &  docrect  )  [virtual]

Definition at line 1525 of file grndrgn.cpp. { return CalculateWinRect(RenderMatrix, docrect, PixelsPerInch ); }

WinRect GRenderRegion::CalculateWinRect (  Matrix &  RenderMatrix, const DocRect &  docrect, const double  dpi )  [virtual]

To create bitmap from wxBitmap structure. To free bitmap To convert a rectangle in Doc coordinates to a rectangle in Win coordinates taking account of the destination dpi rather than assuming screen dpi. Virtual so that it can be overriden by different render regions if so required. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> 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, may have e anf f components changed by the call [OUTPUTS] Returns: Object containing the new rectangle coordinates. See also: OSRenderRegion::DocRectToWin; Reimplemented in PrintingMaskedRenderRegion, and GRenderBitmap. Definition at line 1508 of file grndrgn.cpp. { // lets get the Rect into screen co-ords so we can use our big screen bitmap // Use a version of OSRenderRegion::DocRectToWin that uses the actual dpi we have stored // in PixelsPerInch // Ilan // I need this to use the supplied rectangle - docrect. // Looks like previous version was a typo so I am changing it here. // Karim 07/07/2000 // I'm now changing this to actually _use_ the dpi param in its calculations. // I've checked, and I'm 99.99% certain this doesn't screw up any existing code. return OSRenderRegion::DocRectToWin( RenderMatrix, docrect, dpi ); // return OSRenderRegion::DocRectToWin( RenderMatrix, docrect, PixelsPerInch ); // return OSRenderRegion::DocRectToWin( RenderMatrix, CurrentClipRect, PixelsPerInch ); }

virtual BOOL GRenderRegion::ChangeCapture (  CAPTUREINFO  cinfo, BOOL  bTransparent = TRUE, BOOL  bCaptureBackground = FALSE )  [virtual]

To inform the capture stack that things (transparency) have changed. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 09/07/2004 Parameters: -  [INPUTS] -  [OUTPUTS] Reimplemented from RenderRegion.

BOOL GRenderRegion::CopyRenderInfo (  const RenderRegion &  Other  )  [virtual]

Copies all the parameters from the render region 'Other' into this render region. This was written for the region merging code. When a new region is created, due to existing regions being split up, it should be based on the original region, with a different clipping rectangle. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 6/4/94 Parameters: Other  - The render region to get the info out of [INPUTS] Returns: FALSE if failed, TRUE if worked. Reimplemented from RenderRegion. Definition at line 1007 of file grndrgn.cpp. { RememberMe("CopyRenderInfo"); if (!RenderRegion::CopyRenderInfo( Other )) return FALSE; ENSURE( Other.IsKindOf( CC_RUNTIME_CLASS(GRenderRegion) ) , "CopyRenderOther wrong class" ); // safe to cast now const GRenderRegion *GOther = (GRenderRegion*)&Other; // copy most of the member variables LocalBitmap = GOther->LocalBitmap; if (LocalBitmap) { // leave WRect alone ScreenRect = wxRect(0,0,0,0); } else { // (hmm, untested dubious code) WRect = GOther->WRect; ScreenRect = GOther->ScreenRect; } PixelsPerInch = GOther->PixelsPerInch; dScaledPixelWidth = GOther->dScaledPixelWidth; hPalette = GOther->hPalette; hPrevPalette = NULL; return TRUE; }

static RenderRegion* GRenderRegion::Create (  DocRect  ClipRegion, Matrix  ConvertMatrix, FIXED16  ViewScale, RenderType  , View *  pView = NULL, BOOL  bForce32BPP = FALSE )  [static]

void GRenderRegion::DeInit (  void   )  [static]

Call once during termination to perform any necessary cleanup. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 13/4/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - Scope: Static Definition at line 789 of file grndrgn.cpp. { /* if (Fixed256Palette != NULL) { CCFree(Fixed256Palette); Fixed256Palette = NULL; } */ ERROR3IF(GD != pRealGD, "GDraw context not restored in GRenderRegion::DeInit"); GD = NULL; if (pRealGD) { delete pRealGD; pRealGD = NULL; } // Clean up the DIBConvert classes DIBConvert::DeInit(); if (ErrorDiffContext != NULL) { delete ErrorDiffContext; ErrorDiffContext = NULL; } // GRenderWinG::Deinit(); // Scary critical section stuff // CriticalSection::DeInit(); // Not required for CDraw // Make sure GBrush doesn't leave any memory leaks lying around GBrush::DeinitGBrush(); }

void GRenderRegion::Display1to1Bitmap (   )  [protected]

virtual BOOL GRenderRegion::DisplayBits (  LPBITMAPINFO  lpDisplayBitmapInfo = NULL, LPBYTE  lpDisplayBits = NULL )  [protected, pure virtual]

Implemented in GRenderBitmap, GRenderClick, GRenderDIB, GRenderPrint, and GRenderWinG.

void GRenderRegion::DisplayCurrentState (   )  [protected, virtual]

Make a temporary bitmap, copy current GRenderRegion bitmap into it then render other offscreen state into it before blitting it to screen Notes: This routine does a lot of bitmap copying and blitting so it is much slower than just blitting the current bitmap to screen! Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 30/07/2005 Definition at line 1751 of file grndrgn.cpp. { // Create a temporary capture that is a copy of the master capture // (and get a copy of the bitmap) Capture* pTempCapture = new Capture(GetMasterCapture(), TRUE); if (pTempCapture) { // Point rendering at the temp capture bitmap SetRenderToCapture(pTempCapture); // Render the current capture state into the temp bitmap RenderCurrentCaptureState(); #ifdef DEBUG_ATTACH_RENDERSTATE_BMP { // Create a Kernel bitmap from the bmp data. WinBitmap* wBitmap = new WinBitmap(pTempCapture->lpBitmapInfo, pTempCapture->lpBits); KernelBitmap* OffscreenBitmap = new KernelBitmap(wBitmap,TRUE); OffscreenBitmap->AttachDebugCopyToCurrentDocument("Render State Bitmap"); wBitmap->BMBytes = ((WinBitmap*)OILBitmap::Default)->BMBytes; delete OffscreenBitmap; } #endif // Show the temp bitmap to the user DisplayBits(pTempCapture->lpBitmapInfo, pTempCapture->lpBits); // Reset rendering back to normal SetRenderToCapture(GetTopCaptureBitmap()); // Release the temp bitmap and delete the temp capture pTempCapture->FreeDIB(); delete pTempCapture; pTempCapture = NULL; } else { // Failed to craete temp bitmap // So just blit what we can... DisplayBits(); } }

void GRenderRegion::DisplayHto8Bitmap (   )  [protected]

void GRenderRegion::DisplayLtoHBitmap (   )  [protected]

void GRenderRegion::DocCoordToG (  DocCoord *  DocPoint  )  [private]

DocCoord GRenderRegion::DocCoordToG (  const DocCoord &  DocPoint  )  [private]

virtual BOOL GRenderRegion::DrawArrowHead (  ArrowRec &  ArrowToDraw, DocCoord &  Centre, DocCoord &  Direction )  [protected, virtual]

void GRenderRegion::DrawBitmap (  const DocRect &  rect, KernelBitmap *  pBitmap )

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

Implements RenderRegion. Reimplemented in MaskedRenderRegion, and PrintingMaskedRenderRegion.

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

Implements RenderRegion. Reimplemented in MaskedRenderRegion, and PrintingMaskedRenderRegion.

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

Implements RenderRegion. Reimplemented in MaskedRenderRegion. Definition at line 196 of file grndrgn.h. {}

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

Implements RenderRegion. Reimplemented in MaskedRenderRegion. Definition at line 195 of file grndrgn.h. {}

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

Implements RenderRegion. Reimplemented in MaskedRenderRegion.

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

Implements RenderRegion. Reimplemented in MaskedRenderRegion.

void GRenderRegion::DrawDragRect (  DocRect *  RectToRender  )  [virtual]

Implements RenderRegion. Reimplemented in MaskedRenderRegion.

void GRenderRegion::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 BASE CLASS METHOD IS UNSUPPORTED! DO NOT CALL IT! See OSRenderRegion for the supported versions of this method See also: OSRenderRegion::DrawFixedSystemText OSRenderRegion::GetFixedSystemTextSize Reimplemented from RenderRegion.

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

Implements RenderRegion. Reimplemented in MaskedRenderRegion, and PrintingMaskedRenderRegion.

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

Plots the bitmap using the mask supplied. The base class implementation here does nothing. 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 Progress - progress display object used when printing or exporting. Returns: Status of operation. Reimplemented from RenderRegion.

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

Renders a path object using gavins routines. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 7/12/93 Parameters: PathToDraw  is a pointer to a Path object to render [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Implements RenderRegion. Reimplemented in MaskedRenderRegion, and PrintingMaskedRenderRegion. Definition at line 2051 of file grndrgn.cpp. { // If we are not drawing complex shapes and this shape is, then return // if ((!RenderComplexShapes) && (TestForComplexShape(&Caps))) // return; // TRACEUSER( "Gerry", _T("GRenderRegion::DrawPathToOutputDevice\n")); DWORD Style = 0; TranspGradTable TranspTable; // Something to render later DocCoord* Coords; PathVerb* Verbs; UINT32 NumCoords; DocCoord* UnclippedCoords; PathVerb* UnclippedVerbs; UINT32 UnclippedNumCoords; BOOL ShouldDeleteCoords = FALSE; // Keep the unclipped path coords for arrow rendering UnclippedCoords = PathToDraw->GetCoordArray(); UnclippedVerbs = PathToDraw->GetVerbArray(); UnclippedNumCoords = PathToDraw->GetNumCoords(); ClippedPathIsValid = TRUE; // setup the fuzzy clipping rects. SetupFuzzyClipRects(); // try and clip the path before rendering it, for bigger zoom values if (TryToFuzzyClip(PathToDraw, &Coords, &Verbs, &NumCoords)) { // This may have clipped out all the points (or left just a moveto), // and in this case, it may seem pointless to continue. // but we will carry on, so that ArrowHeads get a chance to render // using the unclipped path coords. // This shouldn't be a problem, so long as anything that uses the clipped // coords, checks to make sure there are enough (more than 1). if (NumCoords < 2) { ClippedPathIsValid = FALSE; // OutputDebugString("Clipped path is too small\n"); } else { // char Str[256]; // _stprintf(Str, "Path clipped. Count=%d, Coords@%x, Verbs@%x\n",NumCoords,Coords,Verbs); // OutputDebugString(Str); /* for (INT32 i=0; i<(NumCoords-1); i++) { if (Verbs[i] == PT_BEZIERTO) { if (Coords[i] == Coords[i+3]) { ClippedPathIsValid = FALSE; // OutputDebugString("Clipped path zero length element, Ignoring it.\n"); NumCoords = 0; break; } i += 2; } else { if (Coords[i] == Coords[i+1]) { ClippedPathIsValid = FALSE; // OutputDebugString("Clipped path zero length element, Ignoring it.\n"); NumCoords = 0; break; } } } */ } // Yes, we clipped the paths alright ShouldDeleteCoords = TRUE; } else { // No Clipping here matey Coords = PathToDraw->GetCoordArray(); Verbs = PathToDraw->GetVerbArray(); NumCoords = PathToDraw->GetNumCoords(); } enum Quality::Fill FillQuality = RRQuality.GetFillQuality(); RememberMe("DrawPath"); HaveRenderedSomething = TRUE; if ( PathToDraw->IsFilled ) { BOOL ExtendedFill = FALSE; FillGeometryAttribute *pFillProvider = (FillGeometryAttribute *) CurrentAttrs[ATTR_FILLGEOMETRY].pAttr; if ( (pFillProvider->GetRuntimeClass() != CC_RUNTIME_CLASS(FlatFillAttribute)) && (FillQuality >= Quality::Graduated) ) ExtendedFill = TRUE; if ( (pFillProvider->GetRuntimeClass() == CC_RUNTIME_CLASS(BitmapFillAttribute)) && (FillQuality >= Quality::Solid) ) ExtendedFill = TRUE; if ( (pFillProvider->GetRuntimeClass() == CC_RUNTIME_CLASS(FractalFillAttribute)) && (FillQuality >= Quality::Solid) ) ExtendedFill = TRUE; if (ExtendedFill) { // VeryMono forces non-extended fill if (RenderFlags.VeryMono) { // Up until now, we always rendered everything solid black when // in 'VeryMono' mode, but now we have 'masked' bitmaps, we // need to render them (will all non-masked pixels plotted black) if (pFillProvider->GetRuntimeClass() == CC_RUNTIME_CLASS(BitmapFillAttribute)) { // Check for a masked bitmap .... KernelBitmap* pBitmap = pFillProvider->GetBitmap(); INT32 Index = 0; if (pBitmap && (pBitmap->GetTransparencyIndex(&Index) || pBitmap->GetBPP()>=32)) { // It's a masked bitmap, so we'll need to plot all // the non-masked pixels as black if (!pFillProvider->RenderFill(this, PathToDraw)) ExtendedFill = FALSE; // fail safe } else { ExtendedFill = FALSE; // Not a masked bitmap } } else { ExtendedFill = FALSE; // Not a bitmap at all } } else if (!pFillProvider->RenderFill(this, PathToDraw)) { ExtendedFill = FALSE; // fail safe } } if ( (!ExtendedFill) && (FillQuality >= Quality::Solid) ) { DocColour FlatColour = RR_FILLCOLOUR(); if (RenderFlags.VeryMono && pFillProvider->GetRuntimeClass() == CC_RUNTIME_CLASS(BitmapFillAttribute)) { // Bitmap fills will return 'No Colour' as their flat colour, // but for 'VeryMono' rendering they should be treated as black. FlatColour = COLOUR_BLACK; } if (SetFillGCol(FlatColour)) { if (!RenderFlags.VeryMono && GetTransparencyFill(&TranspTable, &Style)) { DocColour Col = RR_FILLCOLOUR(); COLORREF rgb = ConvertColourToTransScreenWord(CurrentColContext, &Col); GetDrawContext()->SetTransparency(rgb, (TransparencyEnum)(Style>>8)); } if (NumCoords > 1) { GetDrawContext()->FillPath( (POINT*)Coords, Verbs, NumCoords, (RR_WINDINGRULE()==EvenOddWinding) ? 0 : 1); } } } } if ( PathToDraw->IsStroked ) { // Should we try and draw some ArrowHeads ? BOOL DrawArrows = (RRQuality.GetLineQuality() >= Quality::FullLine) && !(RR_STARTARROW().IsNullArrow() && RR_ENDARROW().IsNullArrow()) && ArrowRec::DoesPathNeedArrowHeads(UnclippedCoords, UnclippedVerbs, UnclippedNumCoords); if ((FillQuality <= Quality::Bitmaps)) { // Just do everything in black outlines... DocColour colorBlk(COLOUR_BLACK); if ( SetGCol( colorBlk ) ) StrokePath( Coords, Verbs, NumCoords, UnclippedCoords, UnclippedVerbs, UnclippedNumCoords, DrawArrows ); } else if (RenderFlags.VeryMono) { // Just do everything in black outlines... DocColour colorBlk(COLOUR_BLACK); if ( !(RR_STROKECOLOUR().IsTransparent()) && SetGCol( colorBlk ) ) StrokePath( Coords, Verbs, NumCoords, UnclippedCoords, UnclippedVerbs, UnclippedNumCoords, DrawArrows ); } else if ( SetGCol( RR_STROKECOLOUR() ) ) { StrokePath( Coords, Verbs, NumCoords, UnclippedCoords, UnclippedVerbs, UnclippedNumCoords, DrawArrows ); } } // We drew a clipped path, so get rid of the extra clipped coords if (ShouldDeleteCoords) { delete Coords; delete Verbs; } }

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

Implements RenderRegion. Reimplemented in MaskedRenderRegion, and PrintingMaskedRenderRegion.

void GRenderRegion::DrawRect (  DocRect *  RectToRender  )  [virtual]

Implements RenderRegion. Reimplemented in MaskedRenderRegion, and PrintingMaskedRenderRegion.

static void GRenderRegion::EnsurePalette (  INT32  PaletteFlag  )  [static]

virtual void GRenderRegion::FreeLPBits (  LPBITMAPINFO  , LPBYTE  )  [protected, pure virtual]

Implemented in GRenderBitmap, GRenderBrush, GRenderClick, GRenderDIB, GRenderPrint, and GRenderWinG.

void GRenderRegion::FreeOffscreenState (   )

Definition at line 964 of file grndrgn.cpp. { // This function gets called when render regions deconstruct // It frees memory allocate to offscreen bitmaps as wella s the inital // bitmap. // NB this gets called before the attribute context stack is unwound (this happens // when ~RenderRegion calls CleanUpBeforeDestruct(RenderRegion *pRegion)) // This function frees handles the freeing of all memory allocted to bitmaps. Includes:- // 1) offscreen bmp memory - alloc'd by the Offscreen rendering system, NOT from limited mem // 2) initial bmp memory - alloc'd by virtual GetLPBits() in a derived class specific fashion // - (ie either from limited mem manager or normal heap) // // It also restores the initial rendering states' wrect, cliprect, and gmatrix variables Capture* pCapture = NULL; while (GetTopCapture()) { pCapture = GetTopCapture(); m_CaptureStack.Pop(); // If we've reached the master capture // reset the rendering variables in case this RenderRegion survives for a while if (pCapture->IsMaster()) SetRenderToCapture(pCapture, FALSE, FALSE); else pCapture->FreeDIB(); delete pCapture; } #if USE_wxBITMAP FreeWxBitmap() ; #else if ( pBitmapInfo && pBits ) { FreeLPBits( pBitmapInfo, pBits ); pBitmapInfo = NULL; pBits = NULL; } #endif }

void GRenderRegion::FreeStoredClipRegions (   )  [protected]

static void GRenderRegion::GColInit (  wxDC *  , BOOL  = FALSE )  [static]

const RGBQUAD* GRenderRegion::Get32BitRGBQuadData (   )  [inline]

Definition at line 282 of file grndrgn.h. { return (RGBQUAD*)pBits;}

BOOL GRenderRegion::GetBitmapPointers (  LPBITMAPINFO *  ppInfo, LPBYTE *  ppBits, BOOL  bCorrectTransparency = TRUE )

DocRect GRenderRegion::GetChangedRect (   )

static INT32 GRenderRegion::GetDefaultDPI (   )  [inline, static]

Definition at line 501 of file grndrgn.h. { return LogPixelsX; };

static INT32 GRenderRegion::GetDefaultTransparency (   )  [inline, static]

Definition at line 267 of file grndrgn.h. { return WhichTransparency; }

GDrawContext* GRenderRegion::GetDrawContext (   )  const [inline]

Definition at line 224 of file grndrgn.h. { return GD; };

static LPLOGPALETTE GRenderRegion::GetErrorDiffPalette (  void   )  [inline, static]

Definition at line 492 of file grndrgn.h. { return((LPLOGPALETTE)&ErrorDiffPalette); };

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

To determine how much room is needed to plot a bit of text with RenderRegion::DrawFixedSystemText. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 12/1/95 Parameters: TheText  - The string to get the rendered size of [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: THIS BASE CLASS METHOD IS UNSUPPORTED! DO NOT CALL IT! See OSRenderRegion for the supported versions of this method See also: OSRenderRegion::DrawFixedSystemText OSRenderRegion::GetFixedSystemTextSize Reimplemented from RenderRegion.

virtual LPBITMAPINFO GRenderRegion::GetLPBits (  INT32  Width, INT32  Height, INT32  Depth, LPBYTE *  )  [protected, pure virtual]

Implemented in GRenderBitmap, GRenderClick, GRenderDIB, GRenderPrint, and GRenderWinG.

static DWORD GRenderRegion::GetMaxBitmapDepth (  void   )  [static]

static DWORD GRenderRegion::GetMaxBitmapWidth (  void   )  [static]

virtual double GRenderRegion::GetPixelsPerInch (   )  [inline, protected, virtual]

Reimplemented from RenderRegion. Definition at line 304 of file grndrgn.h. {return PixelsPerInch;}

static const LOGPALETTE* GRenderRegion::GetRecommendedPalette (   )  [static]

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

This function allows a render region to declare what it can render and what it can not render. This base class version of the function says that it can render none of the options. If your render region can do some of these things then you should overide this function and set the appropriate flags. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 10/4/95 Parameters: pCaps  - the flags set for the things we are able to render [OUTPUTS] Reimplemented from RenderRegion.

double GRenderRegion::GetScaledPixelWidthDouble (   )

UINT32 GRenderRegion::GetSizeOfRGBQuadData (   )  [inline]

Definition at line 283 of file grndrgn.h. { return pBitmapInfo ? pBitmapInfo->bmiHeader.biWidth * pBitmapInfo->bmiHeader.biHeight : 0; }

static GDrawContext* GRenderRegion::GetStaticDrawContext (  INT32  DitherType  )  [inline, static]

Definition at line 254 of file grndrgn.h. { #ifdef RALPH if (GDrawAsm::GetContextForCurrentThread() != NULL) return(GDrawAsm::GetContextForCurrentThread()); #endif if ((DitherType == 0) || (DitherType == 3)) return(ErrorDiffContext); else return(GD); }

static GDrawContext* GRenderRegion::GetStaticDrawContext (   )  [inline, static]

Definition at line 244 of file grndrgn.h. { #ifdef RALPH if (GDrawAsm::GetContextForCurrentThread() != NULL) return(GDrawAsm::GetContextForCurrentThread()); #endif return GD; };

virtual Capture* GRenderRegion::GetTopCaptureBitmap (  Capture *  pFromCapture = NULL  )  const [virtual]

BOOL GRenderRegion::GetTransparencyFill (  TranspGradTable *  , DWORD *  )  [protected]

virtual BOOL GRenderRegion::GrabBitmap (  DocRect *  rectGrab, LPBITMAPINFO *  plpBitmapInfo, LPBYTE *  plpBits )  [virtual]

BOOL GRenderRegion::Init (  BOOL  bFirstTime  )  [static]

Determine possibility of using gdraw routines and determine various characterisitics of the screen. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 7/12/93 Parameters: bFirstTime  is TRUE if called during startup, or FALSE if called subsequently [INPUTS] (e.g. when screen mode changes). -  [OUTPUTS] Returns: TRUE if worked OK Errors: - Scope: Static Reimplemented in GRenderWinG. Definition at line 516 of file grndrgn.cpp. { BOOL GDrawImpossible = FALSE; // Scary critical section stuff // CriticalSection::Init(); // Not required for CDraw if (bFirstTime) { CanDoGDraw = FALSE; if (Camelot.DeclareSection( _T("DebugFlags"), 20)) { Camelot.DeclarePref( NULL, _T("UseGdraw"), &WantDoGDraw, FALSE, TRUE ); Camelot.DeclarePref( NULL, _T("GDrawDepth"), &WantGDrawDepth, 0, 32 ); // Camelot.DeclarePref( NULL, "DontUsePalette", &WantNoPalette, FALSE, TRUE ); // Camelot.DeclarePref( NULL, "BlitMode", &WantBlitMode, 0, 4 ); // Camelot.DeclarePref( NULL, "HighColourDirect", &WantHighColourDirect, 0, 1 ); // Camelot.DeclarePref( NULL, "TryWinG", &WantWinG, FALSE, TRUE ); Camelot.DeclarePref( NULL, _T("WhichDither"), &WhichDither, 0, 20 ); // Camelot.DeclarePref( NULL, "LargeGradTables", &LargeGradTables, 0, 1 ); // TransparencyType removed by Gerry (23/8/96) cos its rampant // Camelot.DeclarePref( NULL, "TransparencyType", &WhichTransparency, 0, 10 ); // Camelot.DeclarePref( NULL, "ResizeRegions", &ResizeRegions, FALSE, TRUE ); } if (Camelot.DeclareSection( _T("Screen"), 10)) { Camelot.DeclarePref( NULL, _T("ClickTranspLimit"), &ClickTranspLimit, 0, 255 ); // defaults to hardware value // RealFPU = IsMathCoprocInstalled(); // Camelot.DeclarePref( NULL, "RealFPU", &RealFPU, FALSE, TRUE ); Camelot.DeclarePref(NULL, _T("ViewDither"), &ViewDither, 0, 4); } if (Camelot.DeclareSection(_T("Rendering"), 20)) { Camelot.DeclarePref( _T("Rendering"), _T("HighQualityAA"), &HighQualityAA, FALSE, TRUE ); Camelot.DeclarePref( _T("Rendering"), _T("BitmapConversion"), &BitmapConversion, 0, 3 ); } if (pRealGD == NULL) pRealGD = new GDrawAsm(); // get permanent one // fill in default translation tables for (INT32 i=0; i<256; i++) NoTransTable[i] = i; } // Initialise the palette manager // PaletteManager::Init(); // Initialise the DIBConvert classes (don't care if it fails) DIBConvert::Init(); ::wxDisplaySize(&ScreenWidth,&ScreenHeight); ScreenDepth = ::wxDisplayDepth(); wxScreenDC dc; wxSize size = OSRenderRegion::GetFixedDCPPI(dc); PORTNOTE("other","Can't handle different DPIs, using X") LogPixelsX = size.x; LogPixelsY = size.y; //size.y; ERROR3IF(LogPixelsX != LogPixelsY, "Luke says non-square pixels are not supported"); // CanSetPalette = FALSE; // on startup lets make sure the GDraw version is OK. Must be done before any GDraw calls if (bFirstTime) { if (!pRealGD->Init()) // checks version etc { GDrawImpossible = TRUE; CanDoGDraw = FALSE; Error::SetError( _R(IDW_BADGDRAW), NULL, 0 ); InformWarning(); // tell the user his DLL is wrong Error::ClearError(); // else we won't start up } GD = pRealGD; } /* switch ( ScreenDepth ) { case 4 : ScreenHinting = CONVHINT_SCREEN4; break; case 8 : ScreenHinting = CONVHINT_SCREEN8; break; case 16 : ScreenHinting = CONVHINT_FINAL16; break; case 24 : ScreenHinting = CONVHINT_FINAL24; break; default : ScreenHinting = CONVHINT_NONE; } */ // we can set a palette if we are on a 256-colour screen and it says that we can PORTNOTE("other","GRenderRegion::Init - Removed palette code") #ifndef EXCLUDE_FROM_XARALX if ( ScreenDepth==8 && // 256 cols only !WantNoPalette // and user hasn't forbidden it ) { if (GetDeviceCaps( hdc, RASTERCAPS ) & RC_PALETTE ) CanSetPalette = TRUE; } #endif ScreenHinting = CONVHINT_NONE; // safe default value if ( ScreenDepth<=8 ) ScreenHinting = DIBUtil::CalcConvertHint(ScreenDepth,NULL); else { // work out bitmap hinting by opening tiny window in top left of screen // It is TOPMOST so that, with luck, nothing will obscure it // wxWindow tempWindow(AfxGetApp().GetTopWindow(),-1,wxPoint(0,0),wxSize(0,0),wxNO_BORDER); // tempWindow.Show(); // tempWindow.Raise(); // wxClientDC tempDC(&tempWindow); // ScreenHinting = DIBUtil::CalcConvertHint(ScreenDepth,&tempDC); wxColour colour; dc.GetPixel(0,0,&colour); ScreenHinting = DIBUtil::CalcConvertHint(ScreenDepth,&dc); dc.SetPen(wxPen(colour)); dc.DrawPoint(0,0); } if ( !GDrawImpossible && ( ScreenDepth==1 || ScreenDepth==4 || ScreenDepth==8 || // only certain depths allowed ScreenDepth==16 || ScreenDepth==24 || ScreenDepth==32 ) ) { CanDoGDraw = TRUE; /* // DIB_PAL_INDICES is not available on Win32s or Chicago // or on 256 colour fixed palette devices if (IsWin32s()) CanDoPalIndices = FALSE; else CanDoPalIndices = TRUE; */ EnsurePalette(0); // set the stack limit to 100k. Assumes stacks go backwards GD->SetStackSize(100*1024); if (ErrorDiffContext == NULL) { ErrorDiffContext = new GDrawAsm(); // get permanent one if (ErrorDiffContext) ErrorDiffContext->Init(); } /* UpdateErrorDiffPalette(); if ( (ScreenDepth==8) && !CanSetPalette ) { // if we're a 256 colour fixed palette device then we make up a default RGB table // and use that Fixed256Palette = (LPRGBQUAD) CCMalloc( sizeof(RGBQUAD) * 256 ); const LOGPALETTE* lpPal = GD->SelectPalette( 0 ); if (Fixed256Palette && lpPal) { for (INT32 i=0; i<256; i++) { Fixed256Palette[i].rgbRed = lpPal->palPalEntry[i].peRed; Fixed256Palette[i].rgbGreen = lpPal->palPalEntry[i].peGreen; Fixed256Palette[i].rgbBlue = lpPal->palPalEntry[i].peBlue; Fixed256Palette[i].rgbReserved = 0; } } // DIB_PAL_INDICES makes no sense on these devices CanDoPalIndices = FALSE; } */ } /* switch (WantBlitMode) { case 4: #if REAL_DDB // user wants badDDBs, only allow if possible if (GRenderDDB::CanDoBadDDBs()) { BlitMode = BLITMODE_BADDDB; break; } #endif // else fall through to default mode nobreak; case 0: // automatic setting using faster blits on non-NT platforms if (IsWin32NT()) BlitMode = BLITMODE_SETDIBS; else BlitMode = ( (ScreenDepth==4) || (ScreenDepth==8) ) ? BLITMODE_BITBLT : BLITMODE_STRETCH; break; case 1: BlitMode = BLITMODE_STRETCH; break; case 2: BlitMode = BLITMODE_SETDIBS; break; case 3: // use DDBs on 16- and 256-colour modes only BlitMode = ( (ScreenDepth==4) || (ScreenDepth==8) ) ? BLITMODE_BITBLT : BLITMODE_STRETCH; break; default: BlitMode = BLITMODE_STRETCH; // safest default value break; } */ // only NT can do BI_BITFIELD, Win32s and Chicago cannot. // Actually NT isn't guaranteed to support that any more //CanBiBitfield = IsWin32NT() ? TRUE : FALSE; // only NT can do 16- and 32-bit DIBs, Win32s cannot. Chicago might? // CanDoDeepDIBs = IsWin32NT() ? TRUE : FALSE; // Changed by Will, on 14/7/95, as requested by Jason. // Apparently the PlotDeepDIB routine doesn't dither correctly. // CanDoDeepDIBs = FALSE; // #if REAL_DDB && WIN16 // GRenderDDB::CanDoBadDDBs(); // #endif // init WinG if required. Saves memory if not wanted // if (WantWinG) // GRenderWinG::Init( bFirstTime ); if (!Operation::RegisterOpDescriptor( 0, _R(IDS_GDRAW), CC_RUNTIME_CLASS(OpGDraw), OPTOKEN_GDRAW, OpGDraw::GetState, 0, // help ID _R(IDBBL_GDRAWOP), 0 // bitmap ID )) return FALSE; if (!GBrush::InitGBrush( bFirstTime )) return FALSE; INT32 Flatness = INT32(MILLIPOINTS_PER_INCH/96 / 2); GD->SetFlatness( Flatness ); return TRUE; }

static BOOL GRenderRegion::Init (  void   )  [static]

Initialise the render region. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 27/05/94 Returns: TRUE if initialised ok; FALSE if not. Reimplemented from RenderRegion.

void GRenderRegion::InitAttributes (   )  [virtual]

Implements RenderRegion.

void GRenderRegion::InitBmpBits (   )  [protected, virtual]

Definition at line 1066 of file grndrgn.cpp. { ENSURE(pBits,"Call to InitBmpBits with null bits pointer!"); if(!pBits) return; LPBITMAPINFOHEADER bh = &pBitmapInfo->bmiHeader; BYTE* pSetBits = (BYTE*)pBits; BOOL UseInternalFormat = FALSE; if(m_DoCompression) { bh->biCompression=0x80000001; // needs to be set correctly for GetDrawContext()->SetBitmap() UseInternalFormat = TRUE; } // for offscreen rendering system which doesn't set m_DoCompression properly if(bh->biCompression==0x80000001) UseInternalFormat = TRUE; // ensure all bitmap memory is initialised (ie don't use the // bogus info from the bmp header dimensions) // NB this assumes that the bmp buff lpBits was allocated using AllocDIB (usually via GetLPBits() fn) UINT32 BmpSize = GetDIBBitsSize( bh ); UINT32 Index = 0; if(bh->biBitCount==32) { // 32bpp if(UseInternalFormat) { // TRACEUSER( "Gerry", _T("Initialising GRR to transparent black\n")); while(Index < BmpSize) { // initial values for using internal alpha channelled format // fully transparent black bacground pSetBits[Index++] = 0x00; pSetBits[Index++] = 0x00; pSetBits[Index++] = 0x00; pSetBits[Index++] = 0xFF; } } else { // TRACEUSER( "Gerry", _T("Initialising GRR to opaque white\n")); while(Index < BmpSize) { // fully opaque white background pSetBits[Index++] = 0xFF; pSetBits[Index++] = 0xFF; pSetBits[Index++] = 0xFF; pSetBits[Index++] = 0x00; } } } else { #if FILL_BITMAP // this is taken from the previous bmp initialisation code (ie from old StartRender()) memset( pBits, FILL_BITMAP+1, BmpSize ); #else // this is what I would expect it to be (ie white background) memset( pBits, 0xFF, BmpSize ); #endif } }

void GRenderRegion::InitClipping (   )  [virtual]

Implements RenderRegion.

virtual BOOL GRenderRegion::InitDevice (   )  [virtual]

Initialises the render region's connection to the device information passed in to RenderRegion::AttachDevice. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 27/05/94 Returns: TRUE if the device specific initialisation is completed successfully; FALSE if not. Errors: Out of memory, Internal error See also: RenderRegion::AttachDevice Reimplemented from RenderRegion. Reimplemented in GRenderPrint.

BOOL GRenderRegion::IsAt100Percent (  FillGeometryAttribute *  Fill  )  [protected]

virtual BOOL GRenderRegion::IsClean (   )  [inline, virtual]

Reimplemented from RenderRegion. Definition at line 181 of file grndrgn.h. {return !HaveRenderedSomething;}

BOOL GRenderRegion::IsDistorted (  FillGeometryAttribute *  Fill  )  [protected]

BOOL GRenderRegion::IsForcingBitmapSmoothing (   )  [inline]

Definition at line 412 of file grndrgn.h. { return m_bForceBitmapSmoothing; }

BOOL GRenderRegion::IsScaledUp (  FillGeometryAttribute *  Fill  )  [protected]

virtual BOOL GRenderRegion::IsWrappedRender (   )  const [inline, virtual]

Reimplemented from RenderRegion. Definition at line 526 of file grndrgn.h. {return IsWrapped;}

const REGION* GRenderRegion::MakeClipRegionFromClipAttr (  ClipRegionAttribute *  pClipAttr  )  [protected]

virtual GMATRIX GRenderRegion::MakeGavinMatrix (  Matrix  NewRenderMatrix, DocRect  ClipRect, double  PixelsPerInch, BOOL  bMasterCapture )  [protected, virtual]

Reimplemented in PrintingMaskedRenderRegion, and GRenderBitmap.

TransparencyEnum GRenderRegion::MapTranspTypeToGDraw (  UINT32  ttype, BOOL  bGraduated )  const

virtual BOOL GRenderRegion::MasterCaptureIsCurrent (   )  const [inline, virtual]

Reimplemented from RenderRegion. Definition at line 558 of file grndrgn.h. {return (!m_CaptureStack.Empty() && GetTopCaptureBitmap() && GetTopCaptureBitmap()->IsMaster());}

BOOL GRenderRegion::NeedToSmooth (  FillGeometryAttribute *  Fill, BOOL  bAlreadyScaled )  [protected]

void GRenderRegion::OffsetByHalfPixel (   )

static void GRenderRegion::PaletteHasChanged (   )  [static]

void GRenderRegion::PlotBitmap (  wxDC *  pDC, UINT32  ColourFlag, INT32  Left, INT32  Top, UINT32  Width, UINT32  Height, wxPalette *  hPal, INT32  , INT32  )  [protected]

void GRenderRegion::PlotBitmap (  UINT32  ColourFlag  )  [protected]

BOOL GRenderRegion::RenderBitmapFill (  Path *  , BitmapFillAttribute *  )

BOOL GRenderRegion::RenderBitmapWithTransparency (  Path *  pPath, BitmapFillAttribute *  pFill, BitmapTranspFillAttribute *  pTranspFill )

Helper function for RenderBitmapFill and SetBitmapTransparencyFill. Used to work out whether or not to smooth bitmap fills/transparencies. Helper function for RenderBitmapFill and SetBitmapTransparencyFill. Used to work out whether or not to smooth bitmap fills/transparencies. Helper function for RenderBitmapFill and SetBitmapTransparencyFill. Used to work out whether or not to smooth bitmap fills/transparencies. Helper function for RenderBitmapFill and SetBitmapTransparencyFill. Used to work out whether or not to smooth bitmap fills/transparencies. Helper function for RenderBitmapFill and SetBitmapTransparencyFill. Sets the smoothing flags using SetBitmapSmoothingFlag and SetTileFilteringFlag. These flags determine the quality of subsequent SetBitmapFill / SetTransparentBitmapFill operations. Fills a shape with a bitmap Initialises a Transparency fill. Scope: ProtectedSets up a fractal fill. Scope: ProtectedSets up a fractal transparency fill. Scope: ProtectedRenders a rectangle using gavins routines. Rectangles are not anti-aliased. Does NOTHING AT ALL as gdraw cannot do xor plotting Does NOTHING AT ALL as gdraw cannot do xor plotting Renders a line using gdraw. 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.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.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.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.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).To determine how much room is needed to plot a bit of text with GRenderRegion::DrawFixedSystemTextDraw an Arrow head on the start or end of a line. Updates the GMATRIX used for rendering. Make a Gavin Matrix out of a Kernel Matrix Sets Gavins drawing colour. He does not distinguish between line & fill colours - the caller has to do that. Sets Gavins drawing colour. He does not distinguish between line & fill colours - the caller has to do that. Allows the dithering of colours to be turned off so they look the same using GDraw as they do with the GDI.Calculates the size of a Pixel in MILLIPOINTS, based on the output DPI but IGNORES the scale factor. Calculates the size of a Pixel in MILLIPOINTS, based on the output DPI but IGNORES the scale factor. Calculates the size of a Pixel in MILLIPOINTS, based on the output DPI and current scale factor. Calculates the size of a Pixel in MILLIPOINTS, based on the output DPI and current scale factor. Returns the true scaled pixel width of this GRenderRegion, to the accuracy of a double. GetScaledPixelWidth() returns a whole number, which is highly inaccurate at high zooms - eg SPW at 6031% is usually 750 / 60.31 = 12.44ish but GetScaledPixelWidth() returns 12. This method is useful if your code needs precise conversion between millipoints and pixels.Called after the Quality setting has been changed on the region. We have to recalculate the antialiasing & flatness settings. Also used by StartRender.Gets ready to do actual rendering. In this case it does nothing. bitmap. Initialise the device specific mechanisms for this render region. IN this case the bitmap is allocated, so can fail. Determines whether a GRenderRegion can be created for rendering. A NULL return should NOT be tested with ENSURE, it is a perfectly valid return result. Slightly misleading name for historic reasons. Actually plots any depth bitmap on any device, without any special handling. Use as a fallback when the more specialist versions are not suitable.Plot high colour bitmap (16 or 32-bits) to a 256 colour device. If we let GDI do this it would take a very long time, so we convert to an intermediate bitmap first. NEW - also plots to a 16-colour device. Will ENSURE if not 16- or 256-colours.If can do PAL_INDICES, just does that, else fills in the RGB quads in the DIB and returns DIB_RGB_COLOR. Only really make sense to call on 16 or 256 colour bitmaps. Plot the DIB as fast as possible to the display surface. IMPORTANT: Only works on SCREEN devices. Plot the DIB as fast as possible to the display surface. Member function version. There is also a more general static version (which this uses). This member fn one uses the ChangedBBox for optimal blitting. Plot a bitmap to a device of the same colour depth.For the main window to get a Gavin-approved logical palette. Scope: StaticDraws a cross in the render region. The cross consists of a vertical line 'Size' millipoints high, and a horizontal line 'Size' millipoints wide.Used to know whether StrokePathToPath will fail. If we don't have GDraw, we cannot do this, if we do, we can. Scope: StaticUsed for rendering complex strokes when the native system cannot do it (e.g. GDI16). Scope: StaticInitialises GDraw for rendering into 8bpp bitmapsCalls SelectPalette for the static GDraw context and sets the palette Scope: Static publicSets up a sensible palette for error diffusion It sets 3 of the entries to black to avoid them being used Scope: Static protectedGiven a ptr to a ClipRegionAttribute, generate an appropriate GDraw clipping region and return it. Sets the flag which indicates that we are rendering to a 32bit bitmapDelete and free memory used by all clip regions which this render region has stored.Intended solely for use by the feathering and shadowing systems, both of which make use of a bitmap blurring algorithm which can sometimes return a blurred bitmap up and right by half a pixel.This function allows a GRenderRegion to declare what it can render and what it can not render. This allows us to pretend to be a simple render region when doing onscreen print previews.This function tells a GRenderRegion to simulate printing This allows us to pretend to be a simple render region when doing onscreen print previews.Plots the bitmap using the mask supplied.Plots the bitmap using the mask supplied.To get the changed rectangle so far To start a bitmap capture of whatever is subsequently rendered To stop a bitmap capture To inform the capture stack that things (transparency) have changedTo setup a direct capture if that is possible Render the current state of the capture stack into the specified bitmap (For use when rendering is interrupted) (For use when capture must be collapsed from 32BPP to 24BPP without affecting the master bitmap)Search down the Capture stack from the top or from the capture specified until we find one that owns a bitmap. The master capture at the bottom of the stack should ALWAYS own a bitmap!Render the current state of the capture stack into the specified bitmap (For use when rendering is interrupted)To connect this renderregion to a bitmap along with clipping and view transformation information (a "capture") Discover whether this transparency type can be rendered into RGBT bitmap by GDraw. (Things like stain and bleach cannot be accurately captured in the T channel of the RGBT bitmap.) Map Camelot's internal transp type to GDraw's transp type Notes: This function only understands FLAT and GRAD - it will never map a Camelot transparency type to one of GDraw's "Colour and transp" valuesTo set the bitmap pointers for the master capture only, updating both the working members and the versions stored in the master capture. To get the bitmap pointers for the master capture only. Toggles state of gdraw flag then forces a redraw. Constructor for OpGDraw operation. It is not undoable. This item is always available when GDraw is available. / } /////////////////////////////////////////////////////////////////////////////////////////// Andy Hills, 23-10-00: Helper functions for RenderBitmapFill and SetBitmapTransparencyFill /*! Author: Andy_Hills (Xara Group Ltd) <camelotdev@xara.com> Date: 23/10/00 Parameters: Fill  the bmp fill to test [INPUTS] -  [OUTPUTS] Returns: TRUE if the bitmap is scaled up (i.e. zoomed into / enlarged) Errors: - Author: Andy_Hills (Xara Group Ltd) <camelotdev@xara.com> Date: 23/10/00 Parameters: Fill  the bmp fill to test [INPUTS] -  [OUTPUTS] Returns: TRUE if the bitmap is at 100% (i.e. not zoomed in or resized) Errors: - Author: Andy_Hills (Xara Group Ltd) <camelotdev@xara.com> Date: 23/10/00 Parameters: Fill  the bmp fill to test [INPUTS] -  [OUTPUTS] Returns: TRUE if the bitmap is distorted (rotated or skewed). Errors: - Author: Andy_Hills (Xara Group Ltd) <camelotdev@xara.com> Date: 23/10/00 Parameters: Fill  the bmp fill to test [INPUTS] bAlreadyScaled TRUE if the bmp has already been scaled to the correct size (using the super-smooth scaling algorithm) -  [OUTPUTS] Returns: TRUE if the bitmap needs to be smoothed. This depends on various factors - e.g. is it at 100%? if not, has it already been scaled to 100%? is it rotated/skewed? is interpolation enabled? are we forcing interpolation? (e.g. we're rendering the shadow of a bitmap) is document-wide bitmap smoothing (options dialogue) enabled? Errors: - Author: Andy_Hills (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/00 Parameters: Fill  the bmp fill for which to set the flags [INPUTS] -  [OUTPUTS] Returns: TRUE on success. Errors: - Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 10/8/94 Parameters: PathToDraw  is a pointer to a Path object to render. Fill is the bitmap fill [INPUTS] required. -  [OUTPUTS] Returns: TRUE if understood fill type & rendered it, FALSE if not Errors: - Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 24/8/94 Parameters: pTranspTable  is a pointer to a Transparency Table to fill in. This table must [INPUTS] still exist at the time of rendering, as Gavin just keeps a pointer to it. So be careful with those Local Variables !! Style is a Pointer to the Fill style for us to update. Style  is updated to include Transparency Style. [OUTPUTS] Returns: TRUE, if a Transparent fill has been set. FALSE, means it will use the Tranparency in the Colour Fill. Notes: Added support for square, 3 and 4 point transparency (Gerry 12/8/96) Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 22/9/94 Returns: TRUE, if fill was set ok. FALSE, if failed to set the fill. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/9/94 Returns: TRUE, if transparency was set ok. FALSE, if failed to set the fractal transparency. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 7/12/93 Parameters: RectToRender  is a pointer to a rectangle to render [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 7/12/93 Parameters: RectToRender  is a pointer to a rectangle to render in EOR type mode. [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 7/12/93 Parameters: A  point and a blob type [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 7/12/93 Parameters: Two  points to render a line between [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 23/3/95 Parameters: Point  - The Coord specifying the bottom left of the Bitmap. [INPUTS] pBitmap, the KernelBitmap to plot. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 23/3/95 Parameters: Point  - The Coord specifying the bottom left of the Bitmap. [INPUTS] pBitmap, the KernelBitmap to plot. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 23/3/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. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 2/4/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 NOTE: this GRenderRegion version of the function plots with BkMode OPAQUE. See also: GRenderRegion::GetFixedSystemTextSize; GRenderRegion::SetFixedSystemTextColours Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 2/4/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: GRenderRegion::DrawFixedSystemText Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 2/4/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: GRenderRegion::DrawFixedSystemText Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 3/4/95 Parameters: An  ArrowRec defining the Arrowhead, the Centre point of the Arrow and a [INPUTS] point defining the direction of the Arrow. See also: - Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 6/4/95 Parameters: The  new GMATRIX to use. [INPUTS] Returns: The old GMATRIX that was being used. See also: GRenderRegion::MakeGavinMatrix Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> (from Will (from Phil code)) Date: ??/??/2004 Parameters: The  Kernel Matrix and cliprect to use to create the Gavin Matrix. [INPUTS] Returns: TRUE if the GMatrix was created ok. See also: GRenderRegion::SetGavinMatrix Notes: Doesn't rely on current state of CurrentClipRect like the above version Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> (Andy) Date: 15/04/94 (7/12/93) Parameters: A  DocColour object [INPUTS] -  [OUTPUTS] Returns: TRUE if not transparent, FALSE if transparent (i.e. don't bother rendering) Errors: - See also: - Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> (Andy) Date: 15/04/94 (7/12/93) Parameters: A  DocColour object [INPUTS] -  [OUTPUTS] Returns: TRUE if not transparent, FALSE if transparent (i.e. don't bother rendering) Errors: - See also: - Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 11/5/95 Parameters: TRUE  to turn off dithering of colours [INPUTS] Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 24/4/94 Returns: The size of a pixel in MILLIPOINTS See also: GetScaledPixelWidth() Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 20/02/2006 Returns: The size of a pixel in a double See also: GetScaledPixelWidth() Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 25/4/94 Returns: The size of a pixel in MILLIPOINTS See also: CalcPixelWidth() Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 20/02/2006 Returns: The size of a pixel in a double See also: CalcPixelWidthDouble() Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 25 September 2000 Notes: USE AT YOUR PERIL!!! PLEASE Note that if you mix and match GetScaledPixelWidthDouble() with GetScaledPixelWidth(), you are HIGHLY likely to run into problems. Most of Camelot uses the original GetScaledPixelWidth(), so if you do decide to use this version, watch out for any interaction problems with the rest of the App! See also: GetScaledPixelWidth(). Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 30/11/94 Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 7/12/93 Parameters: ViewToAttach  is the output view, pCDC is the destination DC, pSpread is which [INPUTS] spread we are rendering. Returns: TRUE if attached ok; FALSE if not. Errors: Same as base class. See also: RenderRegion::AttachDevice; GRenderRegion::InitDevice Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 27/05/94 Returns: TRUE if initialised ok; FALSE if not. Errors: Same as base class. See also: RenderRegion::InitDevice; GRenderRegion::AttachDevice Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 7/12/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: Pointer to a render region if we can use gdraw, else NULL (if not a screen type, or gdraw disabled, or not compatible with this machine). Errors: - See also: - Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> (based on Gavin) Date: 4/3/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> (based on Gavin) Date: 4/3/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> (based on Gavin) Date: 4/3/94 Parameters: lpBmi  will usually be lpBitmapInfo [INPUTS] -  [OUTPUTS] Returns: DIB_PAL_INDICES or DIB_RGB_COLORS Errors: Will ensure if >256 colours (then mess upon memory). Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 3/3/94 Parameters: ColourFlag  as used in SetDIBitsToDevice (e.g. DIB_RGB_COLORS). hPal must [INPUTS] already be selected into the device. Left & Top are the destination in screen coords. SourceLeft and SourceTop are the offset from logical top left of the source bitmap to be plotted. -  [OUTPUTS] Returns: - Errors: - Scope: Static Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 3/3/94 Parameters: ColourFlag  as used in SetDIBitsToDevice (e.g. DIB_RGB_COLORS). [INPUTS] -  [OUTPUTS] Returns: - Errors: - Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> (based on Gavin) Date: 4/3/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 10/3/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: A pointer to a logical palette, or NULL if the screen does not do palettes. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 25/4/94 Parameters: Point  - the centre point of the cross. [INPUTS] Size - the length of the lines used to draw the cross with. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 18/4/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if StrokePathToPath is available, FALSE if it is not. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 18/4/94 Parameters: IPoints  is the path of points to be stroked, ITypes its verb list and ILength [INPUTS] the length. OPoints, OTypes and OLength are the output path. If Close is TRUE then the path will be closed. Flattening is how flat it is required. -  [OUTPUTS] Returns: Length of resultant path. Returns -1 if errored. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> (Rewritten by Jason. Originally by AndyP) Date: 2/5/96 (30/6/94) Parameters: A  device context and whether the GDraw fn should be called regardless. If [INPUTS] hdc is NULL and Force is TRUE then the next time someone calls this it will always do a Force. -  [OUTPUTS] Actually, GColour Init is not very expensive (5 milliseconds if the palette hasn't changed) but this function is more efficient (0.5 millisecs if it hasn't changed). This function will also force a redraw of all windows if it detects that the palette has changed - this is because a palette change detected in the middle of a background redraw could leave the already-drawn areas invalid. Scope: Static public Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 3/5/96 Parameters: PaletteFlag  - value to pass to GDraw_SelectPalette. If -1 then uses the [INPUTS] correct value for the current WhichDither setting -  [OUTPUTS] Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 29/5/96 Parameters: -  [INPUTS] -  [OUTPUTS] Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 8/10/96 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: Max width of off screen bitmap supported Scope: Public See also: GDrawAsm::GetMaxBitmapDepth() Notes: This function does not require a GDraw critical section Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 8/10/96 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: Max depth of off screen bitmap supported Scope: Public See also: GDrawAsm::GetMaxBitmapWidth() Notes: This function does not require a GDraw critical section Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 10 April 2000 Parameters: pClipAttr  ptr to the ClipRegionAttribute whose path we'll base the new [INPUTS] clip region on. [OUTPUTS]  Returns: Pointer to a new GDraw clipping region, or NULL if unsuccessful for some reason. Errors: See also: Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 29/10/99 Parameters: Value  - the value to set [INPUTS] [OUTPUTS]  Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 11 April 2000 Parameters: Any  clip regions stored in this render region will be freed up, so pointers [OUTPUTS] to them will become invalid. See also: FreeClipRegionForAttr(). Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 14/08/2000 To compensate for this, the source bitmap must be rendered at an offset of half a pixel down and left. This function sets GDraw and this render region up to do that. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 23/01/2004 Parameters: pCaps  - the flags to set for the things we are able to render [OUTPUTS] Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 23/01/2004 Parameters: PrintType  - 0=Not simulating, 1=Normal printer, 2=Postscript [INPUTS] Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 23/01/2004 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 Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 17/06/2004 Parameters: rectGrab  - the rectangle to grab as a new bitmap [INPUTS] plpBitmapInfo  - address of pointer to BITMAPINFO structure [OUTPUTS] plpBits - address of pointer to bitmap data Returns: TRUE if grab worked FALSE otherwise Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 24/06/2004 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: DocRect containing changed rect so far in this RenderRegion See also: OSRenderRegion::DocRectToWin; Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 30/06/2004 Parameters: pOwnerNode  - Node in tree which "owns" this capture [INPUTS] CaptureRect - The rectangle to capture ctype - The type of capture required bTransparent - The capture could be transparent RGBT bCaptureBackground - The capture should include the state of the background dPPI - The resolution at which capture should be done pDirectSupplier - Node in tree which supplies a bitmap directly into this capture -  [OUTPUTS] Returns: TRUE if a Capture was successfully set up See also: GRenderRegion::StopCapture Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 30/06/2004 Parameters: pEndNode  - Node in tree which "owns" this capture [INPUTS] -  [OUTPUTS] Returns: TRUE if the Capture resulted in a bitmap being usefully created See also: GRenderRegion::StartCapture Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 09/07/2004 Parameters: -  [INPUTS] -  [OUTPUTS] Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 05/05/2005 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the Direct capture was setup successfully See also: GRenderRegion::StartCapture Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 12/07/2004 Parameters: -  [INPUTS] -  [OUTPUTS] Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 27/07/2004 Parameters: -  [INPUTS] -  [OUTPUTS] Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 13/07/2004 Parameters: -  [INPUTS] -  [OUTPUTS] Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 01/07/2004 Parameters: pCapture  - Pointer to capture object which is to receiev all further rendering [INPUTS] -  [OUTPUTS] Returns: TRUE if worked See also: GRenderRegion::StartCapture Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 02/02/2005 Parameters: ttype  - Camelot-style transparency type [INPUTS] -  [OUTPUTS] Returns: TRUE if the transparency type can be rendered accurately into RGBT bitmap by GDraw See also: GRenderRegion::ChangeCapture Notes: Gavin says (02/02/2005): The following are I think OK: 0,1,4,7,19,20,21,22,23,24,25,26,27 and, I think, the bevel types 34,35,36,37,38,39. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 02/02/2005 Parameters: ttype  - Camelot-style transparency type [INPUTS] -  [OUTPUTS] Returns: GDraw's TransparencyEnum Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 23/07/2004 Parameters: bi  - new BITMAPINFO pointer [INPUTS] by - new BYTES pointer -  [OUTPUTS] Returns: - See also: GRenderRegion::StartCapture Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 14/06/2005 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - See also: GRenderRegion::SetBitmapPointers Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 3/2/94 Parameters: None  [INPUTS] None  [OUTPUTS] Returns: None Errors: None Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 14/10/93 Parameters: [INPUTS]  [OUTPUTS]  Returns: Errors: None Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 14/10/93 Parameters: [INPUTS]  [OUTPUTS]  Returns: Errors: None Definition at line 3078 of file grndrgn.cpp.

virtual BOOL GRenderRegion::RenderCurrentCaptureState (  BOOL  bStartFromMaster = FALSE  )  [virtual]

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

Fills a grad filled path (linear or radial). Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 30/3/94 Parameters: PathToDraw  is a pointer to a Path object to render. Fill is the grad fill [INPUTS] required. -  [OUTPUTS] Returns: TRUE if understood fill type & rendered it, FALSE if not Errors: - Notes: Added support for square, 3 and 4 colour fills (Gerry 12/8/96) Definition at line 2471 of file grndrgn.cpp. { DWORD Style = 0; TranspGradTable TranspTable; BOOL SpecialFill = FALSE; CCRuntimeClass *FillType = Fill->GetRuntimeClass(); if (FillType == CC_RUNTIME_CLASS(RadialFillAttribute)) Style = 1; else if (FillType == CC_RUNTIME_CLASS(LinearFillAttribute)) Style = 0; else if (FillType == CC_RUNTIME_CLASS(ConicalFillAttribute)) Style = 2; else if (FillType == CC_RUNTIME_CLASS(SquareFillAttribute)) Style = 3; else if (FillType == CC_RUNTIME_CLASS(ThreeColFillAttribute)) SpecialFill = TRUE; else if (FillType == CC_RUNTIME_CLASS(FourColFillAttribute)) SpecialFill = TRUE; else { ERROR3("Unknown fill type"); return FALSE; // unknown fill type } if (uBitmapDepth == 32) { // InitTransparencyFill will setup the transparency fill if there is one if (!GetTransparencyFill(&TranspTable, &Style)) Style |= (WhichTransparency<<8); // Set the fill type of the transparency } CProfileBiasGain DiagramMapper = Fill->GetProfile (); // --- Convert ArtWorks style attribute into Gavin-style POINT A,B,C,D; DocCoord* StartPoint = Fill->GetStartPoint(); DocCoord* EndPoint = Fill->GetEndPoint(); DocCoord* EndPoint2 = Fill->GetEndPoint2(); DocCoord* EndPoint3 = Fill->GetEndPoint3(); A.x = (*StartPoint).x; A.y = (*StartPoint).y; B.x = (*EndPoint).x; B.y = (*EndPoint).y; if (EndPoint2 != NULL) { C.x = (*EndPoint2).x; C.y = (*EndPoint2).y; } if (FillType==CC_RUNTIME_CLASS(LinearFillAttribute)) { A.x = (*StartPoint).x; A.y = (*StartPoint).y; B.x = (*EndPoint2).x; B.y = (*EndPoint2).y; C.x = (*EndPoint).x; C.y = (*EndPoint).y; } else if (FillType==CC_RUNTIME_CLASS(ConicalFillAttribute)) { B.x = A.x - (B.x - A.x); B.y = A.y - (B.y - A.y); } BOOL Perspective = FALSE; // Is it a perspectivised fill ? if (Fill->IsPerspective()) { Perspective = TRUE; POINT PGram[4]; // Setup the Perspective control points if (FillType==CC_RUNTIME_CLASS(LinearFillAttribute)) { PGram[0].x = (*StartPoint).x; PGram[0].y = (*StartPoint).y; PGram[1].x = (*EndPoint2).x; PGram[1].y = (*EndPoint2).y; PGram[2].x = (*EndPoint3).x; PGram[2].y = (*EndPoint3).y; PGram[3].x = (*EndPoint).x; PGram[3].y = (*EndPoint).y; } else { PGram[0].x = A.x; PGram[0].y = A.y; PGram[1].x = B.x; PGram[1].y = B.y; PGram[2].x = (*EndPoint3).x; PGram[2].y = (*EndPoint3).y; PGram[3].x = (*EndPoint2).x; PGram[3].y = (*EndPoint2).y; } // Are the control points sensible ? // Gerry removed the pixel size test cos it makes small repeating fills go spappy if (MouldPerspective::WillBeValid(PGram)) { // We're going to plot a perspective fill, // so copy the perspective control points A.x = PGram[0].x; A.y = PGram[0].y; B.x = PGram[1].x; B.y = PGram[1].y; C.x = PGram[2].x; C.y = PGram[2].y; D.x = PGram[3].x; D.y = PGram[3].y; } else { // The mould is bad... Perspective = FALSE; } } // This needs to be allocated at the same level as the FillPath call below... GradTable Table(FALSE); INT32 Tiling = ((FillMappingAttribute*)CurrentAttrs[ATTR_FILLMAPPING].pAttr)->Repeat; if (SpecialFill) { // The fill is a fabby new one if ((FillType != CC_RUNTIME_CLASS(ThreeColFillAttribute)) && (FillType != CC_RUNTIME_CLASS(FourColFillAttribute))) { ERROR3("Unknown new fill type"); return FALSE; // unknown fill type } // Clear the bottom byte of the style cos it means something new Style = Style & 0xFFFFFF00; // If the transparency type is one of the unimplemented ones then set to zero if ((Style & 0xFF00) < 0x400) Style = (Style & 0xFF0000); // We wont do anything scary with the colours (separation/correction) // as this only renders to a GDraw bitmap PColourRGBT Result; CurrentColContext->ConvertColour(Fill->GetStartColour(), (ColourPacked *) &Result); COLORREF StartColour = RGB(Result.Red, Result.Green, Result.Blue); CurrentColContext->ConvertColour(Fill->GetEndColour(), (ColourPacked *) &Result); COLORREF EndColour = RGB(Result.Red, Result.Green, Result.Blue); CurrentColContext->ConvertColour(Fill->GetEndColour2(), (ColourPacked *) &Result); COLORREF EndColour2 = RGB(Result.Red, Result.Green, Result.Blue); if (FillType == CC_RUNTIME_CLASS(FourColFillAttribute)) CurrentColContext->ConvertColour(Fill->GetEndColour3(), (ColourPacked *) &Result); COLORREF EndColour3 = RGB(Result.Red, Result.Green, Result.Blue); /*CProfileBiasGain DefaultBiasGain; if (!(DiagramMapper == DefaultBiasGain)) { Table.BuildTable(Fill->Colour, Fill->EndColour, GetRenderView(), GetFillEffect(), DiagramMapper, LargeGradTables); GetDrawContext()->SetGraduation( Style, Table.GetTable(), &A, &B, &C ); }*/ if (FillType == CC_RUNTIME_CLASS(ThreeColFillAttribute)) { // Style & 0xFF = 0 (simple with better colours outside the mesh) // Style & 0xFF = 2 (tiled) if (Tiling == 1) // If it is a simple fill Style |= 0; // set the style to 0 else Style |= 2; // otherwise set it to 2 //CProfileBiasGain DefaultBiasGain; // default // DiagramMapper is the applied biasgain //if (DiagramMapper == DefaultBiasGain) // if the applied biasgain is the default biasgain //{ if (Perspective) GetDrawContext()->Set3WayGraduation4(Style, StartColour, EndColour, EndColour2, &A, &B, &C, &D); else GetDrawContext()->Set3WayGraduation(Style, StartColour, EndColour, EndColour2, &A, &B, &C); //} //else //{ // Table.BuildTable(Fill->Colour, Fill->EndColour, GetRenderView(), GetFillEffect(), DiagramMapper, LargeGradTables); // GetDrawContext()->Set3WayGraduation(Style, StartColour, EndColour, EndColour2, // &A, &B, &C); //} } else { // Style & 0xFF = 1 (for better colours outside the mesh) // Style & 0xFF = 2 (tiled) if (Tiling == 1) // If it is a simple fill Style |= 1; // set the style to 1 else Style |= 2; // otherwise set it to 2 // The colours in the following lines are correct!!! if (Perspective) GetDrawContext()->Set4WayGraduation4(Style, StartColour, EndColour, EndColour3, EndColour2, &A, &B, &C, &D); else GetDrawContext()->Set4WayGraduation(Style, StartColour, EndColour, EndColour3, EndColour2, &A, &B, &C); } } else { // Mark Howitt, 6/10/97. Enable the repeating fill type operation if selected #ifdef NEW_FEATURES if(Tiling == 4) Style |= 0x80; // Check to see if repeating, if so set it #endif // CGS .... // We now need to decide exactly who is going to build the table! // If the fill has the default biasgain, then we will continue to build // this in the standard fashion (i.e. let GDraw build it). // If however it does NOT, then we will build the table ourselves (with respect to // the applied biasgain) .... CProfileBiasGain DefaultBiasGain; // default // DiagramMapper is the applied biasgain if (DiagramMapper == DefaultBiasGain) // if the applied biasgain is the default biasgain { // get on and use standard rendering stuff .... ColourRamp *pColourRamp = Fill->GetColourRamp(); if (pColourRamp) { if (Tiling != 4) { Table.BuildTable(Fill->Colour, Fill->EndColour, pColourRamp, GetRenderView(), GetFillEffect(), LargeGradTables); } else { Table.BuildHighQualityRepeatTable(Fill->Colour, Fill->EndColour, pColourRamp, GetRenderView(), GetFillEffect()); } } else { if (Tiling != 4) { Table.BuildTable(Fill->Colour, Fill->EndColour, GetRenderView(), GetFillEffect(), LargeGradTables); } else { Table.BuildHighQualityRepeatTable(Fill->Colour, Fill->EndColour, NULL, GetRenderView(), GetFillEffect()); } } if (Perspective) GetDrawContext()->SetGraduation4( Style, Table.GetTable(), &A, &B, &C, &D ); else GetDrawContext()->SetGraduation( Style, Table.GetTable(), &A, &B, &C ); } else { // use our new rendering stuff that takes account of profiles .... if (Tiling != 4) { Table.BuildTable(Fill->Colour, Fill->EndColour, GetRenderView(), GetFillEffect(), DiagramMapper, LargeGradTables); GetDrawContext()->SetGraduation( Style, Table.GetTable(), &A, &B, &C ); } else { Table.BuildHighQualityRepeatTable(Fill->Colour, Fill->EndColour, GetRenderView(), GetFillEffect(), DiagramMapper); GetDrawContext()->SetGraduation( Style, Table.GetTable(), &A, &B, &C ); } GetDrawContext()->SetGraduation( Style, Table.GetTable(), &A, &B, &C ); } } // Now it is time to Draw the path, so we will Fuzzy Clip it just in case it is too big DocCoord* Coords; PathVerb* Verbs; UINT32 TotalCoords; BOOL ShouldDeleteCoords = FALSE; // try and clip the path before rendering it, for bigger zoom values if (TryToFuzzyClip(PathToDraw, &Coords, &Verbs, &TotalCoords)) { // Yes, we clipped the paths alright ShouldDeleteCoords = TRUE; } else { // No Clipping here matey Coords = PathToDraw->GetCoordArray(); Verbs = PathToDraw->GetVerbArray(); TotalCoords = PathToDraw->GetNumCoords(); } // Draw the actual path if (TotalCoords > 1) GetDrawContext()->FillPath( (POINT*)Coords, Verbs, TotalCoords, (RR_WINDINGRULE()==EvenOddWinding) ? 0 : 1 ); // Clean up if we need to if (ShouldDeleteCoords) { delete Coords; delete Verbs; } #if 0 if (0) { // debug code - plot the points GetDrawContext()->SetColour( RGB(0,0,0) ); /*DocCoord*/ POINT Path[5]; BYTE Verbs[] = { PT_MOVETO, PT_LINETO, PT_MOVETO, PT_LINETO, PT_LINETO }; /*DocCoord*/POINT D; D.x = (A.x+B.x)/2; D.y = (A.y+B.y)/2; Path[0] = A; Path[1] = B; Path[2] = A; Path[3] = C; Path[4] = D; GetDrawContext()->StrokePath( (LPPOINT)Path, Verbs, sizeof(Verbs), FALSE, 0, CAPS_ROUND, JOIN_ROUND, NULL ); } #endif return TRUE; }

void GRenderRegion::ResetRegion (  DocRect &  NewClipRect  )  [virtual]

Resets the render region (after it has been merged), so that it no longer thinks it is banded etc. It also takes the Regions rectangle from the Current Clipping rectangle, so set this correctly before calling this function. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 4/5/95 Reimplemented from RenderRegion. Definition at line 1049 of file grndrgn.cpp. { #ifdef _DEBUG // if(CurrentRenderState) // TRACEUSER( "Ilan", _T("RR (0x%x) being reset\n Context = %s (0x%x)\n Offscreen stack size = %d\n"), (DWORD)this, CurrentRenderState->Name(),(DWORD)CurrentRenderState, m_OffscreenStateStack.Size()); // TRACEUSER( "Ilan", _T("RR (0x%x) being reset\n Context = %s (0x%x)\n Offscreen stack size = %d\n"), (DWORD)this, CurrentRenderState->Name(),(DWORD)CurrentRenderState, m_CaptureStack.Size()); #endif // base class version (called below) needs initial CurrentClipRect to be correct. // FreeOffscreenState restores RR state as well as freeing offscreen bitmap memory and stacked states FreeOffscreenState(); RenderRegion::ResetRegion(NewClipRect); }

void GRenderRegion::Restore (  RenderRegion *   )

void GRenderRegion::RestoreClipRegion (  ClipRegionAttribute *  pClipAttr, BOOL  Temp )  [virtual]

Set the current ClipRegion for this RenderRegion. pClipAttr contains a path, and all future rendering will occur *through* that clipping path, after it is clipped to any pre-existing clipping region. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 26 April 2000 Parameters: pClipAttr  the ClipRegionAttribute to restore over the current [INPUTS] attribute. Temp whether the attr is temporary or not - ie if you created it on the heap, do you want it automatically deleted when it goes out of scope. The  attribute stack gets its top ClipRegionAttribute deleted & replaced [OUTPUTS] with this one, with the RR's future clipping-region set accordingly. See Also: SetClipRegion(), ClipRegionAttribute. Reimplemented from RenderRegion. Definition at line 2332 of file grndrgn.cpp. { // Karim 26/02/2001 // Once a clip-region has been restored, we no longer need to cache its associated // clipping region, so we'll free it up here. // We only freeing up the old clip-region if the incoming attr is different // from the outgoing attr, and if we can successfully remove old clip-region // from our cache. // REGION* pClipRegion = NULL; ClipRegionAttribute* pOutGoingClipAttr = RR_CLIPREGION(); ClipRegionAttribute* pInComingClipAttr = NULL; // Actually restore the incoming over the outgoing attribute in our attr-context. RenderRegion::RestoreClipRegion(pClipAttr, Temp); // Free up outgoing clip-region, now it's unneeded. pInComingClipAttr = RR_CLIPREGION(); if (pInComingClipAttr != pOutGoingClipAttr && pOutGoingClipAttr != NULL) { // if (m_ClipRegionMap.Lookup((void*)pOutGoingClipAttr, ((void*&)pClipRegion))) // { // if (m_ClipRegionMap.RemoveKey((void*)pOutGoingClipAttr)) // { // if (pClipRegion != NULL) // delete [] ((BYTE *)pClipRegion); // } // } // Normally GetTopCaptureBitmap must return a valid pointer // However RestoreClipRegion can be called when RenderRegions are being shut down Capture* pBitCapture = GetTopCaptureBitmap(); if (pBitCapture) pBitCapture->RemoveCachedClipRegion(pOutGoingClipAttr); } // Finally, adopt the new clip-attr as our clipping region. ApplyCurrentClipRegion(); }

void GRenderRegion::RestoreOffscreen (  OffscreenAttrValue *   )  [virtual]

Reimplemented from RenderRegion. Reimplemented in MaskedRenderRegion, PrintingMaskedRenderRegion, and GRenderBrush. Definition at line 3033 of file grndrgn.cpp. { if (m_ForcePrintingCaps) return; // call our base class, to update the offscreen attr stack. // this will also trigger a call to the current attr's OffscreenRenderingCompleted() method. RenderRegion::RestoreOffscreen(pAttr); }

void GRenderRegion::SetBitmapPointers (  LPBITMAPINFO  bi, LPBYTE  by )

BOOL GRenderRegion::SetBitmapTransparencyFill (  TranspFillAttribute *  , DWORD *  , TranspGradTable *  )  [protected]

void GRenderRegion::SetClean (  BOOL  bResetChangedBounds, BOOL  FillWhite )  [virtual]

Informs the GRenderRegion that it should consider it's bitmap image to be clean, i.e. it's an accurate representation of what is on screen already, so there is no need to blit it. This is used in conjunction with the PaperRenderRegion to avoid unnecessary blits. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 28/06/94 See also: RenderRegion::SetClean; PaperRenderRegion Reimplemented from RenderRegion. Reimplemented in GRenderClick. Definition at line 1812 of file grndrgn.cpp. { // Reset our rendering flag... HaveRenderedSomething = FALSE; if (bResetChangedBounds) GetDrawContext()->ClearChangedBBox(); }

void GRenderRegion::SetClipRegion (  ClipRegionAttribute *  pClipAttr, BOOL  Temp )  [virtual]

Set the current ClipRegion for this RenderRegion. pClipAttr contains a path, and all future rendering will occur *through* that clipping path, after it is clipped to any pre-existing clipping region. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 26 April 2000 Parameters: pClipAttr  the ClipRegionAttribute to set & push on the attr-stack. [INPUTS] Temp whether the attr is temporary or not - ie if you created it on the heap, do you want it automatically deleted when it goes out of scope. The  attribute stack gets this attr pushed onto it, and the current [OUTPUTS] clip region is set accordingly. See Also: RestoreClipRegion(), ClipRegionAttribute. Reimplemented from RenderRegion. Definition at line 2302 of file grndrgn.cpp. { RenderRegion::SetClipRegion(pClipAttr, Temp); ApplyCurrentClipRegion(); }

void GRenderRegion::SetDeepDIB (  BOOL  Value  )

void GRenderRegion::SetDitherStyle8Bit (  INT32  DitherStyle  )  [inline]

Definition at line 507 of file grndrgn.h. { DitherStyle8Bit = DitherStyle; };

void GRenderRegion::SetDoBitmapConversion (  BOOL  bEnable  )  [inline]

Definition at line 287 of file grndrgn.h. { m_bEnableConversion = bEnable; }

void GRenderRegion::SetDoCompression (  BOOL  bDoCompression  )  [inline]

Definition at line 285 of file grndrgn.h. { m_DoCompression = bDoCompression; }

void GRenderRegion::SetFillAttributes (   )

BOOL GRenderRegion::SetFillGCol (  DocColour &   )  const [private]

void GRenderRegion::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: THIS BASE CLASS METHOD IS UNSUPPORTED! DO NOT CALL IT! See OSRenderRegion for the supported versions of this method 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. See also: OSRenderRegion::DrawFixedSystemText Reimplemented from RenderRegion.

void GRenderRegion::SetForceBitmapSmoothing (  BOOL  ForceSmoothing  )  [inline]

Definition at line 411 of file grndrgn.h. { m_bForceBitmapSmoothing = ForceSmoothing; }

BOOL GRenderRegion::SetFractalFill (  ColourFillAttribute *  , DWORD *  )  [protected]

BOOL GRenderRegion::SetFractalTransparencyFill (  TranspFillAttribute *  , DWORD *  )  [protected]

GMATRIX GRenderRegion::SetGavinMatrix (  GMATRIX *  GMatrix  )  [protected]

BOOL GRenderRegion::SetGCol (  DocColour &   )  const [private]

void GRenderRegion::SetIsWrapped (  BOOL  flag  )  [inline, protected]

Definition at line 579 of file grndrgn.h. { IsWrapped = flag; }

void GRenderRegion::SetLineAttributes (   )

void GRenderRegion::SetOffscreen (  OffscreenAttrValue *  pAttr  )  [virtual]

Create a new bitmap into which, the subtree rooted at this attributes parent, will be rendered. Then call base version to push the current OffscreenAttr onto the context stack. Following only used by GRenderRegion version ** info pointer to bmp info struct which we will setup. bits pointer to bitmap bits which we'll setup. See also: GRenderRegion::RestoreOffscreen; GRenderRegion:: Reimplemented from RenderRegion. Reimplemented in MaskedRenderRegion, PrintingMaskedRenderRegion, and GRenderBrush. Definition at line 2835 of file grndrgn.cpp. { // Karim 23/07/2000 // Mustn't have feathering overhead for hit-testing, so // don't bother doing anything if we're a hit-test RR. if (IsHitDetect()) return; if (m_ForcePrintingCaps) return; // Save pointer to OffscreenAttr, and move current OffscreenAttr to the attr context stack RenderRegion::SetOffscreen(pAttr); }

void GRenderRegion::SetOSDrawingMode (   )  [virtual]

Implements RenderRegion.

static UINT32 GRenderRegion::SetPaletteEntries (  LPBITMAPINFO  lpBmi, wxDC *  pOutputDC = NULL )  [static]

void GRenderRegion::SetQualityLevel (  void   )  [virtual]

Does nothing. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 6/8/97 Parameters: -  [INPUTS] This used to be a pure function until we found a way of making the base class get called (due to the introduction of the path processing code) See also: RenderRegion::SetQuality Reimplemented from RenderRegion.

virtual BOOL GRenderRegion::SetRenderToCapture (  Capture *  pCapture, BOOL  bApplyClipRegion = FALSE, BOOL  bSetBitmap = TRUE )  [protected, virtual]

Reimplemented from RenderRegion.

void GRenderRegion::SetSimulatePrinting (  UINT32  PrintType  )

virtual BOOL GRenderRegion::SetSmoothingFlags (  FillGeometryAttribute *  Fill  )  [protected, virtual]

Reimplemented from RenderRegion.

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

Reimplemented from RenderRegion.

static GDrawContext* GRenderRegion::SetTempDrawContext (  GDrawContext *  pContext  )  [inline, static]

Definition at line 229 of file grndrgn.h. { // Bad things will happen if we set this to NULL if (pContext == NULL) { TRACEUSER( "Gerry", _T("******** Trying to set a NULL GDrawContext\n") ); pContext = pRealGD; } GDrawContext* pOldCon = GD; GD = pContext; // TRACEUSER( "Gerry", _T("GDraw context set to 0x%08x (prev = 0x%08x)\n"), GD, pOldCon); return(pOldCon); };

virtual BOOL GRenderRegion::SetupDirectCapture (  Capture *  pNewCapture, NodeRenderableInk *  pSupplier )  [protected, virtual]

static void GRenderRegion::SetViewDither (  INT32  dither  )  [inline, static]

Definition at line 497 of file grndrgn.h. {ViewDither = dither;};

virtual Capture* GRenderRegion::StartCapture (  CCObject *  pOwner, DocRect  CaptureRect, CAPTUREINFO  cinfo, BOOL  bTransparent = TRUE, BOOL  bCaptureBackground = FALSE, double  mpPixelWidth = 0, NodeRenderableInk *  pDirectSupplier = NULL )  [virtual]

To start a bitmap capture of whatever is subsequently rendered. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 30/06/2004 Parameters: pOwnerNode  - Node in tree which "owns" this capture [INPUTS] CaptureRect - The rectangle to capture ctype - The type of capture required bTransparent - The capture could be transparent RGBT bCaptureBackground - The capture should include the state of the background -  [OUTPUTS] Returns: TRUE if a Capture was successfully set up See also: GRenderRegion::StopCapture Reimplemented from RenderRegion.

BOOL GRenderRegion::StartRender (  void   )  [virtual]

Initialises an GRenderRegion for rendering. Sets up a bitmap and gmatrix ready for gdraw rendering. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 7/12/93 Returns: Errors: - See also: OSRenderRegion::StartRender() Reimplemented from RenderRegion. Reimplemented in MaskedRenderRegion, GRenderBitmap, GRenderClick, GRenderClickColour, and GRenderPrint. Definition at line 1145 of file grndrgn.cpp. { // Ilan // The first time StartRender get's called it allocs memory for bitmaps // However, subsequent calls are made to StartRender during background redrawing, where // rendering pauses partway through to service other messages, and then resumes later // In order to pause, StopRender is called to store a pointer to the last node rendered // and, in the case where we are not busy rendering offscreen, blit the partly completed // bitmap to screen // "AllocatedNewBmp" allows us to distinguish between initial calls to StartRender (where // GetLPBits is called to alloc new bitmaps), and 'restart' calls which don't need to alloc // any new bmps. // In the former case the bitmap must be initialised // In the later case the bitmap must only be re-initialised if m_bDoCompression is set // as in this case inplace bmp conversion will have occured in the process of transfering // the bitmap to the screen (ie during the last StopRender() call) BOOL AllocatedNewBmp = FALSE; RememberMe("StartRender"); // Call base class first if (!RenderRegion::StartRender()) return FALSE; // RenderMatrix.Dump(); // Check that Initialise hasn't been called already ENSURE(RenderFlags.Rendering == FALSE, "Initialise called whilst already rendering"); // JCF: added this check for retail builds as otherwise this ENSURE goes off after a // Crash Me Render. if (RenderFlags.Rendering != false) return FALSE; TRACEUSER("Gavin",_T("GRenderRegion::StartRender - RenderFlags.Rendering = TRUE;\n")); RenderFlags.Rendering = TRUE; // lets get the Rect into screen co-ords so we can use our big screen bitmap // Use a version of OSRenderRegion::DocRectToWin that uses the actual dpi we have stored // in PixelsPerInch //RECT Rect = OSRenderRegion::DocRectToWin( RenderMatrix, CurrentClipRect, PixelsPerInch ); // Use a virtual function so that we can now override it in some special case. // At present, we use this to try and fix pixel problems on bitmap export (GRenderBitmap) // The e and f components of RenderMatrix may be changed by the call, but only in the bitmap export case // // NB PixelsPerInch always set to 96.0 so never accurate unless at 100% zoom?! wxRect Rect; if (GetMasterCapture()) Rect = CalculateWinRect(GetMasterCapture()->CaptureMatrix, GetMasterCapture()->CaptureRect, GetMasterCapture()->dPixelsPerInch); else Rect = CalculateWinRect(RenderMatrix, CurrentClipRect, PixelsPerInch); if (LocalBitmap) { ScreenRect = wxRect(0,0,0,0); // if WRect has changed at all, we're in trouble const INT32 NewWidth = Rect.width; const INT32 OldWidth = WRect.width; const INT32 NewHeight = Rect.height; const INT32 OldHeight = WRect.height; // Its changed size and/or position, so we'll try and re-size the bitmap // If this fails, then we'll just re-allocate // NB GetNextBand() always frees the bitmap memory structs and sets them to NULL // GRenderDIB::ResizeRegion sets up new bitmap, WRect and CurrentClipRect so doesn't need this // code // What would use this code?? // Code used by ExportRender(GRenderOptPalette* pPalRegion) when rendering in strips if ( pBits!=NULL && pBitmapInfo!=NULL && (NewWidth!=OldWidth || NewHeight!=OldHeight) ) { // Make sure we are not after an empty one if (NewWidth == 0 || NewHeight == 0) return FALSE; // Sanity check ERROR3IF((NewWidth < 0 || NewHeight < 0),"GRenderRegion::StartRender got a bad rectangle (Width/Height < 0)\n"); ResetRegion(RegionRect); if (!RenderRegion::StartRender()) return FALSE; // Get a new bitmap to replace the last one #if USE_wxBITMAP pBitmapInfo = AllocWxBitmap(NewWidth,NewHeight,uBitmapDepth); #else pBitmapInfo = GetLPBits(NewWidth, NewHeight, uBitmapDepth, &pBits); #endif if (pBitmapInfo==NULL) { TRACE( _T("Growing GG failed\n")); return FALSE; } AllocatedNewBmp = TRUE; GetMasterCapture()->SetDIB(pBitmapInfo, pBits); } // set new rectangle size WRect = Rect; } else { WRect = Rect; ScreenRect = WRect; if (RenderView != NULL) { CCamView *RenderWindow = RenderView->GetConnectionToOilView(); if ( RenderWindow!=NULL && RenderWindow->GetFrame()!=NULL ) { // RenderWindow->ClientToScreen( &ScreenRect ); wxPoint tl = ScreenRect.GetTopLeft(); wxPoint br = ScreenRect.GetBottomRight(); RenderWindow->GetFrame()->ClientToScreen(tl); RenderWindow->GetFrame()->ClientToScreen(br); ScreenRect = wxRect(tl,br); } } else ERROR2(FALSE, "No render view in GRenderRegion::StartRender()"); } // Create the default, master capture... Capture* pNewMasterCapture = NULL; if (m_CaptureStack.Empty()) { ERROR2IF(pBitmapInfo!=NULL, FALSE, "How has this region got a bitmap when the capture stack is empty?"); pNewMasterCapture = new Capture(this, CAPTUREINFO(ctNESTABLE, cfMASTER | cfPIXWIDTHSCALE), RenderMatrix, CurrentClipRect, PixelsPerInch, CurrentColContext); if (pNewMasterCapture==NULL) return FALSE; m_CaptureStack.Push(pNewMasterCapture); } #ifdef _DEBUG else { // Check capture stack sanity! Capture* pDebugCapture = GetTopCaptureBitmap(); if (pDebugCapture) { ERROR3IF(pDebugCapture->CaptureRect != CurrentClipRect, "Wha?"); // ERROR3IF(!(pDebugCapture->CaptureMatrix == RenderMatrix), "Wha?"); ERROR3IF(pDebugCapture->dPixelsPerInch != PixelsPerInch, "Wha?"); } } #endif if (pBitmapInfo==NULL) { ERROR2IF(GetMasterCapture()->dPixelsPerInch!=GetPixelsPerInch(), FALSE, "Master capture has different dpi than master bitmap"); // Get a bitmap #if USE_wxBITMAP pBitmapInfo = AllocWxBitmap(WRect.width, WRect.height, uBitmapDepth); #else pBitmapInfo = GetLPBits(WRect.width, WRect.height, uBitmapDepth, &pBits); #endif if (pBitmapInfo==NULL) { ERROR3("Allocating GRenderRegion bitmap failed\n"); return FALSE; } AllocatedNewBmp = TRUE; GetMasterCapture()->SetDIB(pBitmapInfo, pBits); } #ifdef _DEBUG else { // Check capture stack sanity! ERROR3IF(GetTopCaptureBitmap()==NULL, "There must be at least ONE bitmap capture!"); } #endif // Do the middle bit if (!StartRenderMiddle()) return FALSE; // Determine the correct hinting value for the current output mode, and call gavin to // set up his offscreen bitmap. // DWORD GavinHint = DIBUtil::GetGavinBlitFormat(ScreenDepth, uBitmapDepth, ScreenHinting); // If we have just created the master capture then we should initialise the bitmap if (AllocatedNewBmp || ForceInitBmpBits) { InitBmpBits(); } // Make sure we don't Init again until something forces it ForceInitBmpBits = FALSE; // Gerry has re-written this bit so it works properly // It no longer tries to select a palette when the RenderDC doesn't exist or // doesn't support a palette if (RenderDC != NULL) { /* GAT if (ScreenDepth == 8) { // use frame windows palette if desired if (PaletteManager::UsePalette()) hPalette = *(PaletteManager::GetPalette()); } */ if (hPalette != NULL) // hPrevPalette = PaletteManager::StartPaintPalette(RenderDC->m_hDC); hPrevPalette = PaletteManager::StartPaintPalette(RenderDC); if (uBitmapDepth == 8) { // If we are not error diffusing then set the dither style if ((DitherStyle8Bit != 0) && (DitherStyle8Bit != 3)) GetDrawContext()->SetDitherStyle((DitherStyle) DitherStyle8Bit); // Stupid prototype } /* GAT if (ScreenDepth == 8) { // Whether we set a palette or not, we need this call on all 8-bit screens GRenderRegion::GColInit(RenderDC->m_hDC); } */ } // Start rendering into the current Capture... // (And always apply the clip region...) // PROBLEM: Clipping information is lost when background rendering kicks in. // // SOLUTION: (Re)apply the current clipping region whenever the render region // starts up (again). vvvv SetRenderToCapture(GetTopCaptureBitmap(), TRUE); ENSURE(pBitmapInfo && pBits, "No bitmap to render into"); // RenderMatrix.Dump(); return TRUE; }

BOOL GRenderRegion::StartRenderAfter (  GMATRIX *  GMat  )  [protected, virtual]

A virtual fn in this class which can be overridden if more work on a GMatrix is required. Default version returns TRUE. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 13/6/94 Parameters: Pointer  to a Gavin matrix which can be modified. [INPUTS] -  [OUTPUTS] Returns: TRUE if worked, FALSE is failed. Reimplemented in GRenderWinG. Definition at line 1544 of file grndrgn.cpp. { return TRUE; }

BOOL GRenderRegion::StartRenderMiddle (   )  [protected, virtual]

A virtual fn in this class which can be overridden if more work on a lpBits is required. Default version returns TRUE. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 13/6/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if worked, FALSE is failed. Definition at line 1563 of file grndrgn.cpp. { return TRUE; }

static LPBYTE GRenderRegion::StaticPlotBitmap (  wxDC *  pDC, UINT32  ColourFlag, LPBITMAPINFO  lpBitmapInfo, LPBYTE  lpBits, INT32  Left, INT32  Top, UINT32  Width, UINT32  Height, wxPalette *  hPal, INT32  , INT32  )  [static]

virtual BOOL GRenderRegion::StopCapture (  CCObject *  pOwner, BOOL  bRender = TRUE, BOOL  bReleaseBitmap = FALSE, LPBITMAPINFO *  plpBitmapInfo = NULL, LPBYTE *  plpBits = NULL, DocRect *  pCaptureRect = NULL, Matrix *  pmatTransform = NULL, double *  pdResolution = NULL )  [virtual]

To stop a bitmap capture. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 30/06/2004 Parameters: pEndNode  - Node in tree which "owns" this capture [INPUTS] -  [OUTPUTS] Returns: TRUE if the Capture resulted in a bitmap being usefully created See also: GRenderRegion::StartCapture Reimplemented from RenderRegion.

BOOL GRenderRegion::StopRender (  void   )  [virtual]

Stops the rendering of a GRenderRegion, saving it's current renderstate so that rendering can continue where it left off, later on. Copies the gdraw internal bitmap to its final resting place (e.g. the screen). Also tidies up windows' palette. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 7/12/93 Parameters: RenderState  is a Node* pointing at the current rendering node in the tree [INPUTS] -  [OUTPUTS] Returns: TRUE if something has been rendered since StartRender was called. Errors: - See also: OSRenderRegion::StopRender Implements RenderRegion. Reimplemented in GRenderPrint. Definition at line 1587 of file grndrgn.cpp. { RememberMe("StopRender"); // Remember this now before it gets cleared by SetClean // or set by the debug code below BOOL bHaveRendered = HaveRenderedSomething; #if 0 if (HaveRenderedSomething) { TRACE( _T("GRR# 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("GRR# 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_BLUE); 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"); TRACEUSER("Gavin",_T("GRenderRegion::StopRender - RenderFlags.Rendering = FALSE;\n")); RenderFlags.Rendering = FALSE; // Don't Blit if we are partway through rendering offscreen. The offscreen bitmap must only // be blitted once it is completed. Offscreen system takes care of resetting the rect which // GDraw has rendered to (ie ChangedBBox) if (pBitmapInfo) { if (MasterCaptureIsCurrent() && !TopCaptureIsDirect()) { // if we rendered something then blit, else we don't. This is handy for not // double-blitting paper areas. Could take it even further to only blit those areas // of the bitmap which have been written to. if (HaveRenderedSomething) { // Show the current rendering state on screen // No, just needs a simple blit to screen... // This is the commonest, fast case DisplayBits(); // We have updated the screen, so now we're 'clean'. SetClean(TRUE, FALSE); } } else { // We were rendering into Capture bitmaps when this Stop request // occurred so, to show current progress, we must blit the contents // of the capture stack into a copy of the master bitmap and // put that on the screen... // // Note that we CANNOT alter the master bitmap itself because when // the captures terminate properly they will again be blitted into // the master bitmap and so the master bitmap must not contain any // earlier version of the captures otherwise transparency values // would be multiplied. // if (HaveRenderedSomething) { // Make a temporary bitmap from the current state of things and display that DisplayCurrentState(); // We have updated the screen, so now we're 'clean'. SetClean(TRUE, FALSE); } } } else { if(!IsWrapped) TRACE( _T("GRenderRegion::StopRender called with no bitmap\n")); } if (hPrevPalette) PaletteManager::StopPaintPalette(RenderDC, hPrevPalette); // Clean out the Fuzzy Rectangles InnerRect.MakeEmpty(); OuterRect.MakeEmpty(); // Karim 04/05/2000 // free all of our cached clipping regions. FreeStoredClipRegions(); // Reset dither style to ordered dither on 8bpp screens if (ScreenDepth == 8) GetDrawContext()->SetDitherStyle(DITHER_GREY_ORDERED); return bHaveRendered; }

BOOL GRenderRegion::StrokePath (  const DocCoord *  Coords, const PathVerb *  Verbs, UINT32  Count, const DocCoord *  UnclippedCoords, const PathVerb *  UnclippedVerbs, UINT32  UnclippedCount, BOOL  DrawArrows = FALSE )  [private]

sets the immediate render flag to the value specified Sits on top of GDraw_StrokePath that calculates Joins, Caps & Width then renders via GDraw. Does dashed lines too now. Also renders ArrowHeads in needed. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 13/4/94 Parameters: Coords,:  list of points to draw [INPUTS] Verbs: list of path verbs Count: number of point DrawArrows: whether or not it should attempt to draw arrows on open subpaths. -  [OUTPUTS] Returns: TRUE if worked, FALSE if failed. Errors: - Scope: Private Definition at line 1864 of file grndrgn.cpp. { CapStyles Caps; JoinStyles Join; switch (RR_STARTCAP()) { case LineCapRound: Caps = CAPS_ROUND; break; case LineCapSquare: Caps = CAPS_SQUARE; break; case LineCapButt: Caps = CAPS_BUTT; break; default: ENSURE(FALSE, "Bad startcap"); Caps = CAPS_ROUND; break; } switch (RR_JOINTYPE()) { case BevelledJoin: Join = JOIN_BEVEL; break; case MitreJoin: Join = JOIN_MITER; break; case RoundJoin: Join = JOIN_ROUND; break; default: ENSURE(FALSE, "bad jointype"); Join = JOIN_ROUND; break; } BOOL StrokeOK = TRUE; // DMc updates so that arrow heads are drawn on the line not after it // 25/2/99 // make a copy of the coord array DocCoord * pCopyCoords = NULL; if (UnclippedCount != 0) { pCopyCoords = (DocCoord *)(CCMalloc(sizeof(DocCoord) * UnclippedCount)); for (UINT32 i = 0; i < UnclippedCount; i++) { pCopyCoords[i].x = UnclippedCoords[i].x; pCopyCoords[i].y = UnclippedCoords[i].y; } } BOOL bRenderedArrows = FALSE; // DMc update for arrow heads being drawn on the line not after it // 25/2/99 // Pass the Unclipped coords to the arrow rendering routine. if (DrawArrows && pCopyCoords) { bRenderedArrows = DrawPathArrowHeads((DocCoord*)pCopyCoords, (PathVerb*)UnclippedVerbs, UnclippedCount); } // We won't stroke anything, if the path has been // fuzzy clipped so much, that there are no points left if (Count > 1 && pCopyCoords) { MILLIPOINT Width = RR_LINEWIDTH(); if (RenderFlags.HitDetect) { // rendering to off-screen bitmaps means minimum 3-pixel wide lines if (Width < (ScaledPixelWidth*1)) Width = ScaledPixelWidth*1; } else if (RRQuality.GetQuality() == Quality::QualityGuideLayer) { SetDashPattern(SD_DASH1); DocColour* pCol = AttrQuality::GetColour(); if (pCol != NULL) SetGCol(*pCol); else { DocColour colorRed(COLOUR_RED); SetGCol( colorRed ); } Width = ScaledPixelWidth; DrawArrows = FALSE; } else if (RRQuality.GetLineQuality() < Quality::FullLine) { // do 0-width lines if line quality is low Width = 0; DrawArrows = FALSE; } else if (RRQuality.GetAntialiasQuality() < Quality::FullAntialias) { // if not anti-aliasing then check for lines thinner than one pixel as Gavin doesn't // render them very usefully if (Width < ScaledPixelWidth) Width = 0; } DashType* pDashRec = NULL; DashType GavinDash; if ( Width > 0 && (RRQuality.GetLineQuality() >= Quality::FullLine) && RR_DASHPATTERN().Elements > 0) { INT32 Length = RR_DASHPATTERN().Elements; // Gavin Dashes are Max of 8 elements if (Length > 8) Length = 8; // If the flag is set, then we need to scale the dash elements // according to the linewidth BOOL DoScale = RR_DASHPATTERN().ScaleWithLineWidth; FIXED16 Scale = DoScale ? (double(Width) / double(RR_DASHPATTERN().LineWidth)) : 1; GavinDash.Length = Length; GavinDash.Offset = LongMulFixed16(RR_DASHPATTERN().DashStart, Scale); for (INT32 el = 0; el < Length; el++) { // Copy each element into the Gavin Dash, scaling as we go GavinDash.Array[el] = LongMulFixed16(RR_DASHPATTERN().ElementData[el], Scale); } pDashRec = &GavinDash; } // DMc update 25/2/99 // previously : // StrokeOK = GetDrawContext()->StrokePath( (POINT*)Coords, Verbs, Count, FALSE, // Width, Caps, Join, pDashRec ); if (bRenderedArrows) { StrokeOK = GetDrawContext()->StrokePath( (POINT*)pCopyCoords, UnclippedVerbs, UnclippedCount, FALSE, Width, Caps, Join, pDashRec ); } else { StrokeOK = GetDrawContext()->StrokePath( (POINT*)Coords, Verbs, Count, FALSE, Width, Caps, Join, pDashRec ); } } if (pCopyCoords) { CCFree(pCopyCoords); pCopyCoords = NULL; } if (bRenderedArrows) return TRUE; return StrokeOK; }

static BOOL GRenderRegion::StrokePathAvailable (   )  [static]

static INT32 GRenderRegion::StrokePathToPath (  CONST DocCoord *  IPoints, CONST BYTE FAR *  ITypes, size_t  ILength, DocCoord *  OPoints, BYTE *  OTypes, DWORD  OLength, BOOL  Close, DWORD  LineWidth, DWORD  Flattening, LineCapType  LineCaps, JointType  LineJoin, CONST DashType *  Dash )  [static]

virtual BOOL GRenderRegion::TopCaptureIsDirect (   )  [inline, virtual]

Definition at line 563 of file grndrgn.h. {return (GetTopCapture() && GetTopCapture()->IsDirect());}

virtual BOOL GRenderRegion::TranspTypeIsRGBTCompatible (  UINT32  ttype  )  const [virtual]

Reimplemented from RenderRegion.

static void GRenderRegion::UpdateErrorDiffPalette (  void   )  [static, protected]

---

Friends And Related Function Documentation

friend class ConcurrentRenderer [friend]

Definition at line 162 of file grndrgn.h.

friend class GBrush [friend]

Definition at line 158 of file grndrgn.h.

friend class GDrawBorrower [friend]

Definition at line 163 of file grndrgn.h.

friend class GRenderRegionWrapper [friend]

Definition at line 161 of file grndrgn.h.

friend class OpGDraw [friend]

Definition at line 159 of file grndrgn.h.

---

Member Data Documentation

INT32 GRenderRegion::BitmapConversion = 2 [static, protected]

Specifies which bitmap conversion algorithm is used by GDraw when rendering bitmaps in show printer colours mode. Preference: BitmapConversion Section: Rendering Range: 0 - no bitmap conversion (show printer colours will render wrong) 1 - fast conversion (visible banding in deep bitmaps and cached stuff) 2 - medium conversion (best setting for general use) 3 - slow conversion (not yet implemented, most accurate but slow) Definition at line 405 of file grndrgn.h.

BOOL GRenderRegion::CanDoGDraw [static, protected]

Definition at line 439 of file grndrgn.h.

BOOL GRenderRegion::CanDoPalIndices [static, protected]

Definition at line 441 of file grndrgn.h.

BOOL GRenderRegion::CanSetPalette [static, protected]

Definition at line 442 of file grndrgn.h.

RRCaps GRenderRegion::Caps [protected]

Definition at line 311 of file grndrgn.h.

UINT32 GRenderRegion::ClickTranspLimit = 255 [static, protected]

Determine how transparent rendered pixels may be before click detection will ignore them. E.g. 230 means pixels must be 90% transparent before they will be ignored. Preference: ClickTranspLimit Section: Screen Range: 0 to 255 Definition at line 399 of file grndrgn.h.

GMATRIX GRenderRegion::CurrentGMatrix [protected]

Definition at line 300 of file grndrgn.h.

INT32 GRenderRegion::DitherStyle8Bit [protected]

Definition at line 381 of file grndrgn.h.

double GRenderRegion::dScaledPixelWidth [protected]

Definition at line 367 of file grndrgn.h.

GDrawContext * GRenderRegion::ErrorDiffContext = NULL [static, protected]

Definition at line 298 of file grndrgn.h.

RealLogPalette GRenderRegion::ErrorDiffPalette [static, protected]

Initial value: { 0x300, 256 } Definition at line 461 of file grndrgn.h.

LPRGBQUAD GRenderRegion::Fixed256Palette [static, protected]

Definition at line 455 of file grndrgn.h.

BOOL GRenderRegion::ForceInitBmpBits [protected]

Definition at line 379 of file grndrgn.h.

GDrawContext * GRenderRegion::GD = NULL [static, protected]

Definition at line 297 of file grndrgn.h.

BOOL GRenderRegion::HaveRenderedSomething [protected]

Definition at line 383 of file grndrgn.h.

BOOL GRenderRegion::HighQualityAA = FALSE [static, protected]

Determine whether to use GDraw's high quality anti-aliasing mode. Preference: HighQualityAA Section: Rendering Range: FALSE - normal Anti-aliasing TRUE - High quality Anti-aliasing Definition at line 402 of file grndrgn.h.

wxPalette* GRenderRegion::hPalette [protected]

Definition at line 369 of file grndrgn.h.

wxPalette* GRenderRegion::hPrevPalette [protected]

Definition at line 370 of file grndrgn.h.

BOOL GRenderRegion::IsWrapped [protected]

Definition at line 578 of file grndrgn.h.

INT32 GRenderRegion::LastPaletteFlag [static, protected]

Definition at line 459 of file grndrgn.h.

BOOL GRenderRegion::LocalBitmap [protected]

Definition at line 372 of file grndrgn.h.

INT32 GRenderRegion::LogPixelsX [static, protected]

Definition at line 448 of file grndrgn.h.

INT32 GRenderRegion::LogPixelsY [static, protected]

Definition at line 449 of file grndrgn.h.

BOOL GRenderRegion::m_bEnableConversion [protected]

Definition at line 378 of file grndrgn.h.

BOOL GRenderRegion::m_bForceBitmapSmoothing [protected]

Definition at line 376 of file grndrgn.h.

UINT32 GRenderRegion::m_ForcePrintingCaps [protected]

Definition at line 385 of file grndrgn.h.

LPBITMAPINFO GRenderRegion::pBitmapInfo [protected]

Definition at line 349 of file grndrgn.h.

LPBYTE GRenderRegion::pBits [protected]

Definition at line 350 of file grndrgn.h.

double GRenderRegion::PixelsPerInch [protected]

Definition at line 366 of file grndrgn.h.

GDrawContext * GRenderRegion::pRealGD = NULL [static, protected]

Definition at line 296 of file grndrgn.h.

INT32 GRenderRegion::ScreenDepth [static, protected]

Definition at line 445 of file grndrgn.h.

INT32 GRenderRegion::ScreenHeight [static, protected]

Definition at line 447 of file grndrgn.h.

BitmapConvertHint GRenderRegion::ScreenHinting [static, protected]

Definition at line 457 of file grndrgn.h.

wxRect GRenderRegion::ScreenRect [protected]

Definition at line 364 of file grndrgn.h.

INT32 GRenderRegion::ScreenWidth [static, protected]

Definition at line 446 of file grndrgn.h.

UINT32 GRenderRegion::uBitmapDepth [protected]

Definition at line 352 of file grndrgn.h.

UINT32 GRenderRegion::uLineSize [protected]

Definition at line 353 of file grndrgn.h.

BOOL GRenderRegion::UseSolidColours [protected]

Definition at line 374 of file grndrgn.h.

INT32 GRenderRegion::ViewDither = 2 [static, protected]

Definition at line 437 of file grndrgn.h.

BOOL GRenderRegion::WantDeepGDraw [static, protected]

Definition at line 432 of file grndrgn.h.

BOOL GRenderRegion::WantDoGDraw = TRUE [static, protected]

Definition at line 427 of file grndrgn.h.

UINT32 GRenderRegion::WantGDrawDepth [static, protected]

Definition at line 428 of file grndrgn.h.

BOOL GRenderRegion::WantHighColourDirect [static, protected]

Definition at line 431 of file grndrgn.h.

INT32 GRenderRegion::WhichDither = 2 [static, protected]

Definition at line 435 of file grndrgn.h.

INT32 GRenderRegion::WhichPalette [static, protected]

Definition at line 434 of file grndrgn.h.

INT32 GRenderRegion::WhichTransparency = 0 [static, protected]

Definition at line 436 of file grndrgn.h.

wxRect GRenderRegion::WRect [protected]

Definition at line 363 of file grndrgn.h.

---

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

• wxOil/grndrgn.h (r1785/r1361)
• wxOil/grndrgn.cpp (r1785/r1699)

---