RenderRegion Class Reference

THIS IS AN ABSTRACT CLASS. Don't try to create a RenderRegion itself, but rather create one of it's derived classes. A RenderRegion object is created when an area of the screen/printer (or any destination) has become invalid and needs to be redrawn. It 'lives' for as long as that region is still invalid. It is also used for e.g. exporting files or in smart click detection. Background rendering and region merging is achieved by using a List of Render Region objects. When a new region becomes invalid, a RenderRegion is created and added to that list. If the rendering is interrupted before it is complete, then it will continue again when the OnIdle routine scans through the list of RenderRegions. RenderRegions can also be created at other times for Immediate rendering. To use a RenderRegion, create an OSRenderRegion or a GRenderRegion depending on the method of rendering required, then Attach a DC and CWnd to the region to specify the Render destination. Next call InitRender which will return the RenderRegions previous render state if it had been interrupted or Null if it has just been created. You can then set attributes, Save/Restore them, and Render objects. When rendering is complete, call ExitRender passing the current render state. More...

#include <rndrgn.h>

Inheritance diagram for RenderRegion:

List of all members.

Public Member Functions
	RenderRegion ()
	Used by the RectTool to suspend background redrawing. Used by DocView::CanContinue Default Constructor for RenderRegion Class.
	RenderRegion (DocRect ClipRect, Matrix ConvertMatrix, FIXED16 ViewScale)
	Constructor for a RenderRegion, allowing a invalid rectangle to be specified. The matrix passed is used to convert Document coords into device coords, taking into account scaling, scroll offsets etc.
	RenderRegion (const RenderRegion &other)
	Copy Constructor for RenderRegion. This conctructs a RenderRegion based on another. This involves copying all the current attributes and also making a copy of the ContextStack.
virtual	~RenderRegion ()
	Default Destructor for RenderRegion Class. Releases any memory claimed for the ContextStack.
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 *, CNativeDC *, Spread *SpreadToAttach=NULL, bool fOwned=false)
virtual BOOL	AttachDevice (View *, CCDC *, Spread *SpreadToAttach=NULL, bool fOwned=false)
	Attaches View, wxDC and Spread pointers to the RenderRegion. The View is used to for general rendering purposes. The wxDC is the device that we are rendering to. We extract the HDC from this and store it so we can recreate another wxDC object for background rendering. The Spread is just stored for external referance and is used to continue rendering during BackGnd redraw.
virtual BOOL	InitDevice ()
	Initialises the render region's connection to the device information passed in to RenderRegion::AttachDevice.
virtual BOOL	ImmediateRender ()
	Used to Draw something immediately.
virtual Node *	GetBackmostChangedNode ()
virtual void	SetBackmostChangedNode (Node *pInvalidNode)
virtual void	ClearBackmostChangedNode (Node *pNode)
virtual BOOL	RenderBits (LPBITMAPINFO lpBitmapInfo, LPBYTE lpBits, DocRect rect, BOOL bForceNoTransp=TRUE, Node *pEffectsOwner=NULL)
	To blit one bitmap defined by a DocRect into the current RenderRegion.
virtual BOOL	RenderBits (LPBITMAPINFO lpBitmapInfo, LPBYTE lpBits, DocCoord *pCoords, INT32 numcoords, BOOL bForceNoTransp=TRUE, Node *pEffectsOwner=NULL)
	To blit one bitmap defined by a DocRect into the current RenderRegion.
virtual BOOL	RenderBits (KernelBitmap *pkBitmap, DocCoord *pCoords, INT32 numcoords, BOOL bForceNoTransp, Node *pEffectsOwner)
	To blit one bitmap defined by a DocRect into the current RenderRegion.
virtual INT64	GetTotalCount ()
virtual INT64	GetStoredCount ()
virtual void	SetStoredCount (INT64 llcount)
virtual void	SetMatrix (Matrix &)
	This can be used to set the RenderRegions transform matrix to the given matrix. This should really be used with care!
Matrix	GetMatrix ()
virtual Matrix	ConcatenateMatrix (Matrix &)
	This can be used to add a transform in to the render regions transformation matrix. The function performs the following matrix operation :- MonoOn RenderMatrix = NewMatrix * RenderMatrix; MonoOff.
virtual BOOL	StartRender ()
	Initialises the device attachment, if we haven't already done so for this render region. This is so that we can have a two-stage attachment of a device to a render region. This allows us to create render regions very quickly, which makes background rendering more efficient as quite often we will just throw them away without ever needing a proper connection to the device context.
virtual BOOL	StopRender ()=0
virtual void	SetClean (BOOL bResetChangedBounds, BOOL FillWhite)
	Virtual function used to inform render region that defers update that it should set its render state to be 'clean', i.e. if no more rendering occurs then it need not update the device. This is used for render regions such as GRenderRegions, where we render the paper using the host OS graphics primitives, but we have to render the paper into the GRenderRegion too, otherwise we will get garbage. Equally though, we don't want the GRenderRegion to do a potentially slow blit if all it is going to draw is some paper. It also allows the 'changed box' to be reset, so if we only have a small object on the page, then only the area containing the object is updated using a blit. The default implementation of this function does nothing - most render regions won't need to over-ride this null behaviour.
virtual BOOL	IsClean ()
virtual BOOL	CloseDown ()
	Base class declaration of the CloseDown function. It allows the CloseDown functions in the EPS and CMX filters to be virtual over-rides, which means that I don't need the IsKindOfs cluttering up the rendering loops.
virtual void	ConditionalSuicide (void)
	Causes the object to commit suicide. This is to get around using a few if IS_A calls elsewhere in Camelot.
Node *	GetRenderState ()
	Returns the Current Render State of the RenderRegion, which is a pointer to the next Node to render. If NULL then it is not currently rendering.
void	SetRenderState (Node *RenderState)
SubRenderContext *	GetSubRenderState ()
void	SetSubRenderState (SubRenderContext *SubRenderState)
BOOL	IsSubRenderStateLocked (void) const
void	LockSubRenderState (BOOL Lock)
CNativeDC *	GetRenderDC ()
INT32	GetTimeslice () const
void	DefaultRender (BOOL bForceImmediate=FALSE)
	Calls the attatched view to render itself. This is used to continue rendering into a suspended RenderRegion.
View *	GetRenderView ()
Spread *	GetRenderSpread ()
BOOL	IsPrinting ()
BOOL	IsRendering ()
BOOL	IsVeryMono ()
BOOL	IsHitDetect () const
BOOL	IsUsingSmoothedBitmaps ()
void	SetUsingSmoothedBitmaps (BOOL set)
void	SaveContext ()
void	RestoreContext ()
virtual BOOL	SaveAttribute (UINT32 Index, AttributeValue *pAttr, BOOL Temp)
	Saves the current attribute on the attribute context stack, and installs the given attribute as the new attribute. If the attribute object is temporary, then it is deleted when the attribute is popped off the stack. See RenderRegion::RestoreAttribute.
void	RestoreAttribute (UINT32 Index, AttributeValue *pAttr, BOOL Temp)
	Restore the given attribute to the current attribute array. This is called when the rendering context stack is popped - the current attribute is ousted (and deleted if it is a temporary object), and the given one is installed in its place.
virtual BOOL	WantsGrids ()
	This function is designed to help with the rendering of grids, as they are not always wanted (eg xara eps). If your class of render region does not want grids to appear, then overide this function and get it to return FALSE. The default behaviour is to return TRUE, which will allow grids to render if they want to.
void	SetBackgroundColour (DocColour &Colour)
	Sets the value of mBackground colour, which is used whenever the program needs to know what the background colour of a file is.
virtual void	DrawPath (Path *PathToRender, PathProcessor *pCaller=NULL, PathShape psThis=PATHSHAPE_PATH)
	Renders a path (main entry-point). May start a binary-recursive rendering pipeline off by calling any active path processors to do their stuff.
PathProcessor *	GetFirstPathProcessor (void)
void	PushPathProcessor (PathProcessor *pProcessor)
	Adds a PathProcessor to the rendering PathProcessor stack.
void	PopPathProcessor (void)
	Pops a PathProcessor from the top of the rendering PathProcessor stack.
void	EnableAllBrushPathProcessors (BOOL Enable)
	Enables or disables all the brush path processors on the stack.
virtual void	DrawPathToOutputDevice (Path *PathToRender, PathShape shapePath=PATHSHAPE_PATH)=0
virtual void	DrawRect (DocRect *RectToRender)=0
virtual void	DrawDragRect (DocRect *RectToRender)=0
virtual void	DrawDragBounds (DocRect *RectToRender)
	Used to draw a "rectangle" to screen (for dragging). However, the corners of the rectangle are passed through the current rendering matrix, so the rect may well be rotated or skewed by the time it reaches the screen.
virtual void	DrawDashLine (const DocCoord &StartPoint, const DocCoord &EndPoint)
	Draws a dashed line between the two points. Uses the technology from DrawDragBounds().
virtual void	DrawLine (const DocCoord &StartPoint, const DocCoord &EndPoint)=0
virtual void	DrawPixel (const DocCoord &Point)=0
virtual void	DrawBlob (DocCoord p, BlobType type)=0
virtual void	DrawCross (const DocCoord &Point, const UINT32 Size)=0
virtual void	DrawBitmap (const DocCoord &Point, KernelBitmap *pBitmap)=0
virtual void	DrawBitmap (const DocCoord &Point, UINT32 BitmapID, UINT32 ToolID=0)=0
virtual BOOL	DrawTransformedBitmap (NodeBitmap *pNodeBitmap)
virtual void	DrawBitmapBlob (const DocCoord &Point, KernelBitmap *BlobShape)=0
virtual void	DrawBitmapBlob (const DocCoord &Point, ResourceID resID)=0
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.
virtual void	DrawFixedSystemText (StringBase *TheText, DocRect &BoundsRect, UINT32 uFormat=0x00000020|0x00000800|0x00000004)
	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.
virtual 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).
virtual 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.
virtual BOOL	DrawPathArrowHeads (DocCoord *Coords, PathVerb *Verbs, INT32 NumCoords)
	Draws arrows heads on the start or end of an open path, according to the current ArrowHead Attributes.
virtual BOOL	DrawArrowHead (ArrowRec &ArrowToDraw, DocCoord &Centre, DocCoord &Direction, DocCoord *RetnCentre=NULL)
	Draw an Arrow head on the start or end of a line.
virtual void	DrawPixelRect (DocRect *RectToRender)
	To try and plot a single pixel rectangle outline. It does this by using filled rectangles rather than just drawing the line itself. This is required because although GDI and GDraw fills can be made to match up, their outlines can't (at the time of writing). Assumes fill colour and line colour have already been set up along with a line width, usually assumed to be zero which means plot single-pixel lines. Usually, the fill colour is set to be the required line colour and the line colour is set to be transparent (COLOUR_TRANS).
virtual void	DrawPixelLine (const DocCoord &StartPoint, const DocCoord &EndPoint)
	To try and plot a single pixel line. It does this by using a filled rectangle rather than just drawing the line itself. This is required because although GDI and GDraw fills can be made to match up, their outlines can't (at the time of writing). Assumes fill colour and line colour have already been set up along with a line width, usually assumed to be zero which means plot single-pixel lines. Usually, the fill colour is set to be the required line colour and the line colour is set to be transparent (COLOUR_TRANS).
virtual void	SetLineColour (StrokeColourAttribute *, BOOL Temp)
	Set the current line colour according to an AttributeValue object, pushing the current line colour onto the context stack.
virtual void	SetLineOverprint (OverprintLineAttrValue *, BOOL Temp)
	Set the line overprint state, pushing the current "overprint line" attribute onto the context stack.
virtual void	SetLineTransp (StrokeTranspAttribute *, BOOL Temp)
	Set the current line colour according to an AttributeValue object, pushing the current line colour onto the context stack.
virtual void	SetStrokeType (StrokeTypeAttrValue *, BOOL Temp)
	Set the current Stroke Type according to an AttributeValue object, pushing the current Stroke Type onto the context stack.
virtual void	SetVariableWidth (VariableWidthAttrValue *, BOOL Temp)
	Set the current VariableWidth according to an AttributeValue object, pushing the current VariableWidth onto the context stack.
virtual void	SetFillGeometry (ColourFillAttribute *, BOOL Temp)
	Set the current fill type according to an AttributeValue object, pushing the current fill type onto the context stack.
virtual void	SetFillMapping (FillMappingAttribute *, BOOL Temp)
	Set the current fill type according to an AttributeValue object, pushing the current fill type onto the context stack.
virtual void	SetFillEffect (FillEffectAttribute *, BOOL Temp)
	Set the current fill type according to an AttributeValue object, pushing the current fill type onto the context stack.
virtual void	SetFillOverprint (OverprintFillAttrValue *, BOOL Temp)
	Set the fill overprint state, pushing the current "overprint fill" attribute onto the context stack.
virtual void	SetTranspFillGeometry (TranspFillAttribute *, BOOL Temp)
	Set the current fill type according to an AttributeValue object, pushing the current fill type onto the context stack.
virtual void	SetTranspFillMapping (TranspFillMappingAttribute *, BOOL Temp)
	Set the current fill type according to an AttributeValue object, pushing the current fill type onto the context stack.
virtual void	SetPrintOnAllPlates (PrintOnAllPlatesAttrValue *, BOOL Temp)
	Set the PrintOnAllPlates state, pushing the current "print on all plates" attribute onto the context stack.
virtual void	SetLineWidth (LineWidthAttribute *, BOOL Temp)
	Set the current line width according to an AttributeValue object, pushing the current linewidth onto the context stack.
virtual void	SetStartCap (StartCapAttribute *, BOOL Temp)
	Set the current Line Cap according to an AttributeValue object, pushing the current LineCap the context stack.
virtual void	SetStartArrow (StartArrowAttribute *, BOOL Temp)
	Set the current StartArrow according to an AttributeValue object, pushing the current StartArrow the context stack.
virtual void	SetEndArrow (EndArrowAttribute *, BOOL Temp)
	Set the current EndArrow according to an AttributeValue object, pushing the current EndArrow the context stack.
virtual void	SetJoinType (JoinTypeAttribute *, BOOL Temp)
	Set the current JoinType according to an AttributeValue object, pushing the current JoinType the context stack.
virtual void	SetMitreLimit (MitreLimitAttribute *, BOOL Temp)
	Set the current MitreLimit according to an AttributeValue object, pushing the current MitreLimit the context stack.
virtual void	SetDashPattern (DashPatternAttribute *, BOOL Temp)
	Set the current dash pattern according to an AttributeValue object, pushing the current dash pattern onto the context stack.
virtual void	SetWindingRule (WindingRuleAttribute *, BOOL Temp)
	Set the current winding rule according to an AttributeValue object, pushing the current winding rule onto the context stack.
virtual void	SetDrawingMode (DrawingModeAttribute *, BOOL Temp)
	Set the current drawing mode according to an AttributeValue object, pushing the current drawing mode onto the context stack.
virtual void	SetQuality (QualityAttribute *, BOOL Temp)
	Set the current display quality according to an AttributeValue object, pushing the current quality onto the context stack.
virtual void	SetWebAddress (WebAddressAttribute *, BOOL Temp)
	Set the current WebAddress.
virtual void	SetTxtFontTypeface (TxtFontTypefaceAttribute *, BOOL Temp)
	Set the current Text Font Typeface according to an AttributeValue object, pushing the current Font Typeface onto the context stack.
virtual void	SetTxtBold (TxtBoldAttribute *, BOOL Temp)
	Set the current Text Boldness according to an AttributeValue object, pushing the current Boldness onto the context stack.
virtual void	SetTxtUnderline (TxtUnderlineAttribute *, BOOL Temp)
	Set the current Text Underline state according to an AttributeValue object, pushing the current Underline state onto the context stack.
virtual void	SetTxtItalic (TxtItalicAttribute *, BOOL Temp)
	Set the current Text Italicness according to an AttributeValue object, pushing the current Italicness onto the context stack.
virtual void	SetTxtAspectRatio (TxtAspectRatioAttribute *, BOOL Temp)
	Set the current Text Aspect Ratio according to an AttributeValue object, pushing the current Aspect Ratio onto the context stack.
virtual void	SetTxtJustification (TxtJustificationAttribute *, BOOL Temp)
	Set the current Text Justification according to an AttributeValue object, pushing the current Justification onto the context stack.
virtual void	SetTxtTracking (TxtTrackingAttribute *, BOOL Temp)
	Set the current Text Tracking according to an AttributeValue object, pushing the current Tracking onto the context stack.
virtual void	SetTxtFontSize (TxtFontSizeAttribute *, BOOL Temp)
	Set the current Font Size according to an AttributeValue object, pushing the current font size state onto the context stack.
virtual void	SetTxtScript (TxtScriptAttribute *, BOOL Temp)
	Set the current Text Script according to an AttributeValue object, pushing the current Script onto the context stack.
virtual void	SetTxtBaseLine (TxtBaseLineAttribute *, BOOL Temp)
	Set the current Text BaseLine according to an AttributeValue object, pushing the current BaseLine onto the context stack.
virtual void	SetTxtLineSpace (TxtLineSpaceAttribute *, BOOL Temp)
	Set the current Text LineSpace according to an AttributeValue object, pushing the current LineSpace onto the context stack.
virtual void	SetTxtLeftMargin (TxtLeftMarginAttribute *, BOOL Temp)
	See other Set/Restore routines above.
virtual void	SetTxtRightMargin (TxtRightMarginAttribute *, BOOL Temp)
virtual void	SetTxtFirstIndent (TxtFirstIndentAttribute *, BOOL Temp)
virtual void	SetTxtRuler (TxtRulerAttribute *, BOOL Temp)
virtual void	SetSolidColours (BOOL SetSolid)
void	SetLineColour (DocColour &NewLineColour)
	Set the line colour to a specific colour, pushing the current line colour onto the context stack.
void	SetLineColour (StockColour NewLineColour)
	Set the line colour to a specific colour, pushing the current line colour onto the context stack.
void	SetFillColour (DocColour &NewFillColour)
	Set the fill colour to a specific colour, pushing the current fill colour onto the context stack.
void	SetFillColour (StockColour NewFillColour)
	Set the fill colour to a specific colour, pushing the current fill colour onto the context stack.
void	SetLineWidth (MILLIPOINT NewLineWidth)
	Set the line width to a specific size, pushing the current line width onto the context stack.
void	SetStartCap (LineCapType NewStartCap)
	Set the current Line Cap according to an AttributeValue object, pushing the current LineCap the context stack.
void	SetStartArrow (StockArrow NewStartArrow)
	Set the current StartArrow according to an AttributeValue object, pushing the current Arrow the context stack.
void	SetEndArrow (StockArrow NewEndArrow)
	Set the current EndArrow according to an AttributeValue object, pushing the current Arrow the context stack.
void	SetStartArrow (ArrowRec &NewStartArrow)
	Set the current StartArrow according to an AttributeValue object, pushing the current Arrow the context stack.
void	SetEndArrow (ArrowRec &NewEndArrow)
	Set the current EndArrow according to an AttributeValue object, pushing the current Arrow the context stack.
void	SetJoinType (JointType NewJoinType)
	Set the current JoinType according to an AttributeValue object, pushing the current JoinType the context stack.
void	SetMitreLimit (MILLIPOINT NewMitreLimit)
	Set the current MitreLimit according to an AttributeValue object, pushing the current Arrow the context stack.
void	SetDashPattern (DashRec &NewDashPattern)
	Set the dash pattern, pushing the current dash pattern onto the context stack.
void	SetDashPattern (StockDash NewDashPattern)
	Set the dash pattern, pushing the current dash pattern onto the context stack.
void	SetWindingRule (WindingType NewWindingRule)
	Set the winding rule, pushing the current winding rule onto the context stack.
void	SetDrawingMode (DrawModeType NewDrawingType)
	Set the drawing mode, pushing the current drawing mode onto the context stack.
void	SetDefaultQuality ()
	Set the quality attribute to the default setting, pushing the current quality level onto the context stack.
void	SetDeviceDashPattern (DashRec &NewDashPattern)
	Set the dash pattern, pushing the current dash pattern onto the context stack.
void	SetDeviceDashPattern (StockDash NewDashPattern)
	Set the dash pattern, pushing the current dash pattern onto the context stack.
virtual void	SetOffscreen (OffscreenAttrValue *pAttr)
	Uses attribute stacking to offscreen rendering system notified when offscreen bitmap has been rendered (ie occurs when subtree is finished rendering and attributes are being restored).
virtual void	SetClipRegion (ClipRegionAttribute *, BOOL Temp)
	Set this render-region's current clipping region. See also: ClipRegionAttribute::Render(), RenderRegion::RestoreClipRegion().
virtual CCachedBitmap	GrabBitmap (DocRect rectGrab)
virtual void	RestoreLineColour (StrokeColourAttribute *, BOOL)
	Get rid of the current line colour, and restore the specified line colour value.
virtual void	RestoreLineOverprint (OverprintLineAttrValue *, BOOL)
	Restore the previous Line Overprint state, popping the previous state from the rendering stack.
virtual void	RestoreLineTransp (StrokeTranspAttribute *, BOOL)
	Get rid of the current line colour, and restore the specified line colour value.
virtual void	RestoreStrokeType (StrokeTypeAttrValue *, BOOL)
	Get rid of the current stroke type, and restore the specified stroke type.
virtual void	RestoreVariableWidth (VariableWidthAttrValue *, BOOL)
	Get rid of the current VariableWidth, and restore the specified VariableWidth.
virtual void	RestoreFillGeometry (ColourFillAttribute *, BOOL)
	Get rid of the current fill type, and restore the specified fill type.
virtual void	RestoreFillMapping (FillMappingAttribute *, BOOL)
	Get rid of the current fill type, and restore the specified fill type.
virtual void	RestoreFillOverprint (OverprintFillAttrValue *, BOOL)
	Restore the previous Fill Overprint state, popping the previous state from the rendering stack.
virtual void	RestoreTranspFillGeometry (TranspFillAttribute *, BOOL)
	Get rid of the current fill type, and restore the specified fill type.
virtual void	RestoreTranspFillMapping (TranspFillMappingAttribute *, BOOL)
	Get rid of the current fill type, and restore the specified fill type.
virtual void	RestoreFillEffect (FillEffectAttribute *, BOOL)
	Get rid of the current fill type, and restore the specified fill type.
virtual void	RestoreLineWidth (LineWidthAttribute *, BOOL)
	Get rid of the current line width, and restore the specified line width.
virtual void	RestoreDrawingMode (DrawingModeAttribute *, BOOL)
	Get rid of the current drawing mode, and restore the specified drawing mode.
virtual void	RestoreWindingRule (WindingRuleAttribute *, BOOL)
	Get rid of the current winding rule, and restore the specified winding rule.
virtual void	RestoreStartCap (StartCapAttribute *, BOOL)
	Get rid of the current start cap, and restore the specified one.
virtual void	RestoreJoinType (JoinTypeAttribute *, BOOL)
	Get rid of the current JoinType, and restore the specified one.
virtual void	RestoreQuality (QualityAttribute *, BOOL)
	Get rid of the current quality level, and restore the specified quality level.
virtual void	RestoreDashPattern (DashPatternAttribute *, BOOL)
	Get rid of the current dash pattern, and restore the specified one.
virtual void	RestoreStartArrow (StartArrowAttribute *, BOOL)
	Get rid of the current StartArrow, and restore the specified one.
virtual void	RestoreEndArrow (EndArrowAttribute *, BOOL)
	Get rid of the current EndArrow, and restore the specified one.
virtual void	RestoreMitreLimit (MitreLimitAttribute *, BOOL)
	Get rid of the current MitreLimit, and restore the specified one.
virtual void	RestoreWebAddress (WebAddressAttribute *, BOOL)
	Restore the Web Address.
virtual void	RestorePrintOnAllPlates (PrintOnAllPlatesAttrValue *, BOOL)
	Restore the previous print-on-all-plates state, popping the previous state from the rendering stack.
void	RestoreTxtFontTypeface (TxtFontTypefaceAttribute *, BOOL)
	Get rid of the current Text Font Typeface, and restore the specified Typeface value.
void	RestoreTxtBold (TxtBoldAttribute *, BOOL)
	Get rid of the current Text Boldness, and restore the specified Boldness value.
void	RestoreTxtUnderline (TxtUnderlineAttribute *, BOOL)
	Get rid of the current Text underline state, and restore the specified underline value.
void	RestoreTxtItalic (TxtItalicAttribute *, BOOL)
	Get rid of the current Text Italicness, and restore the specified Italicness value.
void	RestoreTxtAspectRatio (TxtAspectRatioAttribute *, BOOL)
	Get rid of the current Text Aspect Ratio, and restore the specified Aspect Ratio value.
void	RestoreTxtJustification (TxtJustificationAttribute *, BOOL)
	Get rid of the current Text Justification, and restore the specified Justification value.
void	RestoreTxtTracking (TxtTrackingAttribute *, BOOL)
	Get rid of the current Text Tracking, and restore the specified Tracking value.
void	RestoreTxtFontSize (TxtFontSizeAttribute *, BOOL)
	Get rid of the current font size, and restore the specified font size.
void	RestoreTxtScript (TxtScriptAttribute *, BOOL)
	Get rid of the current Text Script, and restore the specified Script value.
void	RestoreTxtBaseLine (TxtBaseLineAttribute *, BOOL)
	Get rid of the current Text BaseLine, and restore the specified BaseLine value.
void	RestoreTxtLineSpace (TxtLineSpaceAttribute *, BOOL)
	Get rid of the current Text LineSpace, and restore the specified LineSpace value.
void	RestoreTxtLeftMargin (TxtLeftMarginAttribute *, BOOL)
void	RestoreTxtRightMargin (TxtRightMarginAttribute *, BOOL)
void	RestoreTxtFirstIndent (TxtFirstIndentAttribute *, BOOL)
void	RestoreTxtRuler (TxtRulerAttribute *, BOOL)
virtual void	RestoreOffscreen (OffscreenAttrValue *)
virtual void	RestoreClipRegion (ClipRegionAttribute *, BOOL)
	Restore this render-region's current clipping region, using the attribute supplied. See also: ClipRegionAttribute::Restore(), RenderRegion::SetClipRegion().
AttributeValue *	GetCurrentAttribute (UINT32 Index)
	Get a pointer to one of the render region's current attributes. The index indicates which kind of attribute should be returned.
OffscreenAttrValue *	GetCurrentOffscreenAttr ()
virtual BOOL	CheckOffscreenBounds ()
void	SetClipRect (DocRect &NewClipRect, BOOL ReCalcContextNode=FALSE)
	Sets the Clipping rectangle of the Render Region. Calls InitClipping() to acually set the clip region in an OS specific way.
DocRect	GetClipRect ()
	Returns the clipping rectangle of the Render Region.
MILLIPOINT	GetPixelWidth ()
MILLIPOINT	GetScaledPixelWidth ()
virtual double	GetPixelsPerInch ()
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.
BOOL	SetRenderComplexShapes (BOOL NewState)
	This function sets the state of the flag RenderComplexShapes. This flag is used by some classes of render region to decide what shapes to draw. If the flag is TRUE, then all shapes will be drawn that are asked to be drawn. If it is FALSE, only the shapes that are not considered to be complex by the render region will rendered. OSRenderRegions use this, as they can be used as part of the 3 phase rendering system that needs to render only specific nodes.
BOOL	TestForComplexShape (RRCaps *pCaps)
	This function is called whenever someone calls one of the primitive render functions in a ScanningRenderRegion. This takes a look at all the attributes (and anything else it might need to) to see if this represents a complex shape or not. If it is a complex shape, all the internal data members of the render region are updated accordingly. This function makes use of the RRCaps object that was set with the SetHostRRCaps() function to see what things the Host render region considers to be complex.
EFFECTTYPE	GetFillEffect ()
	Decide what type of colour fade to use. Scope: Public.
void	SetFilter (Filter *pFilter)
Filter *	GetFilter ()
virtual void	ResizeRegion (DocRect &NewClipRect)
	Called when a Region is changed in size (eg. clipped to the client area).
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.
virtual BOOL	SetFirstBand ()
	This function gives the render region a chance to see if it want to do some banding or not. If it decides it does, then this function will set it all up ready to start. It should be called before StartRender.
virtual BOOL	GetNextBand ()
	This function goes and sets up the next band in the render region ready for rendering and returns TRUE if it went OK. If there are no more bands to render then the function returns FALSE.
DocRect	GetRegionRect ()
	This function returns the size of the whole render region. Note that this may be different from the Clip rect. If the region is banded, then the Clip rect will hold the rect of the band that is being rendered, while the RegionRect will always hold the rect the whole region.
BOOL	IsBanded ()
	To find out if the render region is banded.
BOOL	CanBeMerged ()
	This is used to help simplify the merging code with banded region. A banded render region at the start of one of its bands looks similar to a render region that has done no rendering yet, and may be merged. This function allows banded regions to stop themselves from being merged after they have started rendering into their first band.
BOOL	ResetColourContext ()
ColourContext *	GetColourContext ()
virtual void	ResetRender ()
	Reset the rendering state of this region.
virtual BOOL	RenderChar (WCHAR ch, Matrix *pMatrix)
	Render a character, using the specified transform and current attributes in the render region.
virtual BOOL	WriteNewLine (void)
	Writes in a new-line token if necessary. In this class, it's just a stub function that's over-ridden in the derived classes.
Path *	CreateCharPath (WCHAR ch, Matrix *pMatrix=NULL)
	Create a path of the specified char, using the specified transform and current attributes in the render region Note: The caller is resposible for initialising the path's flags if required.
BOOL	GetAttrdCharBounds (DocRect *pRect, WCHAR ch)
	Get the bounding box of the specified char (from a cache) and apply the required transform depending on attributes (this is a character relative rect!).
BOOL	GetCharAttributeMatrix (Matrix *pAttrMatrix)
	calc attribute matrix based on FontSize, AspectRatio and Script attributes
void	ColourCorrectBitmap (BitmapFillAttribute *Fill, BITMAPINFO *Info, RGBQUAD **Palette)
	Applies colour correction and/or contoning to a paletted bitmap being plotted.
BOOL	RenderTree (Node *pRoot, BOOL bTimeSlice=TRUE, BOOL bClip=TRUE, RenderCallback *pCallback=NULL)
	To render a specified subtree in this RenderRegion. The dominating factor in this routine is that it renders the document with as little time overhead as possible. Obviously, this is mainly down to RenderRegions and the tree scanning routines working fast but we can do a bit to help.
BOOL	RenderTreeCanContinue ()
	Decide whether we can continue to render in RenderTree.
BOOL	RenderTreeNoCache (Node *pRoot)
	Renders a subtree with cacheing disabled.
virtual BOOL	IsWrappedRender () const
virtual BOOL	TranspTypeIsRGBTCompatible (UINT32 ttype) const
virtual BOOL	SetSmoothingFlags (FillGeometryAttribute *Fill)
virtual BOOL	RenderPaperAsInk ()
void	SetImmediateRender (BOOL SetVal)
BOOL	GetImmediateRender () const
void	SetForceMixTransparency (BOOL bForceMix)
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 INT32	GetCaptureDepth ()
virtual BOOL	MasterCaptureIsCurrent () const
virtual Capture *	GetTopCapture () const
virtual Capture *	GetMasterCapture () const
virtual BOOL	LockedTransparentCaptures () const
	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!
Static Public Member Functions
static BOOL	Init ()
	Initialise the render region.
static BOOL	InitPrefs ()
	Initialises the RenderRegions preferences from the preference file. This is called once as Camelot starts up.
Public Attributes
DrawModeType	DrawingMode
BOOL	IsWaitingForRAM
BOOL	IsLastBand
BOOL	NeedsOSPaper
BOOL	RenderOSPaper
BOOL	IsPaperRendered
BOOL	IsInkRenderStarted
Quality	RRQuality
BOOL	m_DoCompression
Protected Member Functions
virtual BOOL	SetRenderToCapture (Capture *pCapture, BOOL ApplyClipRegion, BOOL bSetBitmap)
StrokeColourAttribute *	PrepareLineColour (StrokeColourAttribute *SourceAttr=NULL)
	This function is used to allow 3 special attributes to function correctly. => Overprint line, Overprint fill, and Print on all plates.
ColourFillAttribute *	PrepareFillGeometry (ColourFillAttribute *SourceAttr=NULL)
	This function is used to allow 3 special attributes to function correctly. => Overprint line, Overprint fill, and Print on all plates.
virtual void	InitClipping ()=0
virtual void	InitAttributes ()=0
virtual void	SetLineAttributes (ChangeLineAttrType=CHANGELINEATTR_ALL)
	Inform the render region that an aspect of the path stroking attributes has changed. The base class version just updates the RenderRegion member variable StrokeFlags to reflect which aspects of the stroke attributes have become invalid. Derived render regions can either call the base class or just implement whatever methods they need for keeping track of these changes - or a combination of the two, of course. Some render regions (e.g. GRenderRegions) don't need to do anything about this at all as all attributes are invoked whenever anything is rendered. If this is the case, then this should be over-ridden to have a NULL implementation because this will improve rendering speed.
virtual void	SetFillAttributes (ChangeAttrType Type=CHANGEATTR_ALL)
	Inform the render region that an aspect of the path filling attributes has changed. The base class version just updates the RenderRegion member variable FillFlags to reflect which aspects of the fill attributes have become invalid. Derived render regions can either call the base class or just implement whatever methods they need for keeping track of these changes - or a combination of the two, of course. Some render regions (e.g. GRenderRegions) don't need to do anything about this at all as all attributes are invoked whenever anything is rendered. If this is the case, then this should be over-ridden to have a NULL implementation because this will improve rendering speed.
virtual void	SetTextAttributes (ChangeFillAttrType Type=CHANGEFILLATTR_ALL)
	Inform the render region that an aspect of the path filling attributes has changed. The base class version just updates the RenderRegion member variable FillFlags to reflect which aspects of the fill attributes have become invalid. Derived render regions can either call the base class or just implement whatever methods they need for keeping track of these changes - or a combination of the two, of course. Some render regions (e.g. GRenderRegions) don't need to do anything about this at all as all attributes are invoked whenever anything is rendered. If this is the case, then this should be over-ridden to have a NULL implementation because this will improve rendering speed.
virtual BOOL	RenderNode (Node *pNode, Node *pRunToNode, RenderCallback *pCallback)
	Wrap up the common stuff that's done to every node we render Render a single node and find out whether we should suspend rendering at this point Helper function for RenderTree.
virtual void	SetOSDrawingMode ()=0
virtual void	SetQualityLevel ()
	Does nothing.
virtual MILLIPOINT	CalcPixelWidth ()=0
virtual MILLIPOINT	CalcScaledPixelWidth ()=0
BOOL	TryToFuzzyClip (Path *pPath, DocCoord **pNewCoords, PathVerb **pNewVerbs, UINT32 *NewNumCoords)
	This function works out if clipping is needed (based on scale factor etc) and tries to clip the paths. If it works it will return TRUE, meaning that you should only try to draw that path info found in pNewCoords etc. If FALSE is returned pNewCoords etc will all be NULL. If this function returns TRUE it will have allocated memory to put the new coords and verbs in. It will be your responsibility to delete this memory after you have rendered the path.
void	SetupFuzzyClipRects ()
	Sets up the fuzzy clipping rects, basing them on the CurrentClipRect. Don't ask me what they're used for - I'm just moving some useful code into a function :o).
BOOL	CopyCurrentAttributes (const RenderRegion &)
	Copy the current attribute array of another render region into this render region. The copying is intelligent; i.e. if the other array contains 'temporary' objects, then it will copy them, so two render regions don't try to delete the same object when their destructor is called.
Protected Attributes
StackT< Capture * >	m_CaptureStack
DocColour	mBackgroundColour
DocRect	InnerRect
DocRect	OuterRect
BOOL	RenderComplexShapes
INT64	m_countTotal
INT64	m_countStored
CCAPI RenderRegion::FlagBlock	RenderFlags
RenderRegion::_StrokeFlags	StrokeFlags
RenderRegion::_FillFlags	FillFlags
RenderRegion::_TextFlags	TextFlags
Matrix	RenderMatrix
DocRect	CurrentClipRect
ColourContext *	CurrentColContext
View *	RenderView
CNativeDC *	RenderDC
Spread *	RenderSpread
bool	m_fOwned
Node *	CurrentRenderState
SubRenderContext *	CurrentSubRenderState
BOOL	SubRenderStateLocked
FIXED16	ScaleFactor
AttributeEntry *	CurrentAttrs
INT32	NumCurrentAttrs
OffscreenAttrValue *	CurrentOffscreenAttr
INT32	Timeslice
BOOL	m_bRenderTreeTimeSlice
MonotonicTime	m_timeRenderTreeStartTime
MILLIPOINT	PixelWidth
MILLIPOINT	ScaledPixelWidth
RenderStack	TheStack
DocRect	RegionRect
BOOL	IsRegionBanded
BOOL	CanRegionBeMerged
Node *	m_pBackmostChangedNode
BOOL	IsBeingReset
Filter *	m_pFilter
BOOL	m_bForceMix
Static Protected Attributes
static UINT32	SelectedBlobSize = 3
	The number represents the size of the blobs on the control points of selected objects. The Selected Blob Size is the size of the blobs when they have been clicked on.
static UINT32	UnSelectedBlobSize = 2
	The number represents the size of the blobs on the control points of selected objects. The UnSelected Blob Size is the size of the blobs when the object is selected, but none of its control points have been clicked on (and are not themselves selected).
static UINT32	MultiStageSelectedBlobSize = 4
static UINT32	MultiStageUnSelectedBlobSize = 3
static UINT32	ClipViewBlobSize = 8
	This number represents the size of the ClipView's special selection blobs. These blobs are only visible on selected ClipView groups when using the selector tool, and are used to select different sections of the group.
Private Attributes
PathProcessor *	PathProcessorStack
Classes
struct	_FillFlags
struct	_StrokeFlags
struct	_TextFlags
struct	FlagBlock

---

Detailed Description

THIS IS AN ABSTRACT CLASS. Don't try to create a RenderRegion itself, but rather create one of it's derived classes. A RenderRegion object is created when an area of the screen/printer (or any destination) has become invalid and needs to be redrawn. It 'lives' for as long as that region is still invalid. It is also used for e.g. exporting files or in smart click detection. Background rendering and region merging is achieved by using a List of Render Region objects. When a new region becomes invalid, a RenderRegion is created and added to that list. If the rendering is interrupted before it is complete, then it will continue again when the OnIdle routine scans through the list of RenderRegions. RenderRegions can also be created at other times for Immediate rendering. To use a RenderRegion, create an OSRenderRegion or a GRenderRegion depending on the method of rendering required, then Attach a DC and CWnd to the region to specify the Render destination. Next call InitRender which will return the RenderRegions previous render state if it had been interrupted or Null if it has just been created. You can then set attributes, Save/Restore them, and Render objects. When rendering is complete, call ExitRender passing the current render state.

Author:

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

Date:

11/5/93

See also:

class OSRenderRegion; class GRenderRegion

Definition at line 373 of file rndrgn.h.

---

Constructor & Destructor Documentation

RenderRegion::RenderRegion (   )

Used by the RectTool to suspend background redrawing. Used by DocView::CanContinue Default Constructor for RenderRegion Class. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 11/5/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 309 of file rndrgn.cpp. { NumCurrentAttrs = 0; CurrentAttrs = NULL; // By default try to render everything RenderComplexShapes = TRUE; TRACEUSER("Gavin",_T("RenderRegion::RenderRegion - RenderFlags.Rendering = FALSE;\n")); RenderFlags.Printing = FALSE; RenderFlags.Rendering = FALSE; RenderFlags.StackClaimed = FALSE; RenderFlags.ValidDevice = FALSE; RenderFlags.bImmediateRender = FALSE; RenderFlags.VeryMono = FALSE; RenderFlags.SmoothedBitmaps = FALSE; RenderFlags.HitDetect = FALSE; // All fill attributes are invalid to start with. FillFlags.ValidGeometry = FALSE; FillFlags.ValidEffect = FALSE; FillFlags.ValidMapping = FALSE; FillFlags.ValidTransGeometry = FALSE; FillFlags.ValidTransEffect = FALSE; FillFlags.ValidTransMapping = FALSE; StrokeFlags.ValidStrokeColour = FALSE; StrokeFlags.ValidStrokeTransp = FALSE; StrokeFlags.ValidLineWidth = FALSE; StrokeFlags.ValidJoinType = FALSE; StrokeFlags.ValidDashPattern = FALSE; StrokeFlags.ValidLineCap = FALSE; StrokeFlags.ValidStartArrow = FALSE; StrokeFlags.ValidEndArrow = FALSE; StrokeFlags.ValidMitreLimit = FALSE; NeedsOSPaper = TRUE; DrawingMode = DM_COPYPEN; CurrentColContext = NULL; // Now setup the render state CurrentRenderState = NULL; CurrentSubRenderState = NULL; SubRenderStateLocked = FALSE; // Set the Fuzzy Clipping Rects to something InnerRect.MakeEmpty(); OuterRect.MakeEmpty(); // Set up vars to do with banded rendering RegionRect.MakeEmpty(); IsRegionBanded = FALSE; CanRegionBeMerged = TRUE; IsWaitingForRAM = FALSE; IsLastBand = TRUE; IsBeingReset = FALSE; IsInkRenderStarted = FALSE; IsPaperRendered = FALSE; PathProcessorStack = NULL; // MarkH 23/7/99 - New Flag to wether or not to use the GDraw BiCompression Field! m_DoCompression = FALSE; m_pFilter = NULL; m_pBackmostChangedNode = NULL; m_timeRenderTreeStartTime.Sample(); m_bRenderTreeTimeSlice = FALSE; m_countTotal = 0; m_countStored = 0; RenderDC = NULL; m_fOwned = FALSE; ScaleFactor = FIXED16(1); m_bForceMix = FALSE; // double m_dboostm = 1.0; // double m_dboostc = 0.0; #ifdef _DEBUG m_CurrentContextLevel = 0; m_TraceOutContextLevels = FALSE; // m_TraceOutContextLevels = TRUE; #endif }

RenderRegion::RenderRegion (  DocRect  ClipRect, Matrix  ConvertMatrix, FIXED16  ViewScale )

Constructor for a RenderRegion, allowing a invalid rectangle to be specified. The matrix passed is used to convert Document coords into device coords, taking into account scaling, scroll offsets etc. 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. -  [OUTPUTS] Returns: - Errors: - See also: OSRenderRegion::OSRenderRegion() Definition at line 418 of file rndrgn.cpp. { NumCurrentAttrs = 0; CurrentAttrs = NULL; // By default try to render everything RenderComplexShapes = TRUE; CurrentClipRect = ClipRect; RenderMatrix = ConvertMatrix; // TRACE( _T("RR ClipRect = (%d, %d) - (%d, %d)\n"), ClipRect.lo.x, ClipRect.lo.y, ClipRect.hi.x, ClipRect.hi.y); // RenderMatrix.Dump(); ScaleFactor = ViewScale; RenderView = NULL; RenderDC = NULL; m_fOwned = FALSE; TRACEUSER("Gavin",_T("RenderRegion::RenderRegion - RenderFlags.Rendering = FALSE;\n")); RenderFlags.Printing = FALSE; RenderFlags.Rendering = FALSE; RenderFlags.StackClaimed = FALSE; RenderFlags.ValidDevice = FALSE; RenderFlags.bImmediateRender = FALSE; RenderFlags.VeryMono = FALSE; RenderFlags.SmoothedBitmaps = FALSE; RenderFlags.HitDetect = FALSE; DrawingMode = DM_COPYPEN; CurrentColContext = NULL; PixelWidth = 1; ScaledPixelWidth = 1; // Now setup the render state CurrentRenderState = NULL; CurrentSubRenderState = NULL; SubRenderStateLocked = FALSE; NeedsOSPaper = TRUE; // No paper has been rendered yet IsPaperRendered = FALSE; IsInkRenderStarted = FALSE; Timeslice = 100; // 0.1 of a second // Set the Fuzzy Clipping Rects to something InnerRect.MakeEmpty(); OuterRect.MakeEmpty(); // Set up vars to do with banded rendering RegionRect = ClipRect; IsRegionBanded = FALSE; CanRegionBeMerged = TRUE; IsWaitingForRAM = FALSE; IsLastBand = TRUE; // Ilan IsBeingReset = FALSE; PathProcessorStack = NULL; m_pFilter = NULL; m_pBackmostChangedNode = NULL; m_timeRenderTreeStartTime.Sample(); m_bRenderTreeTimeSlice = FALSE; m_countTotal = 0; m_countStored = 0; m_bForceMix = FALSE; #ifdef _DEBUG m_CurrentContextLevel = 0; m_TraceOutContextLevels = FALSE; // m_TraceOutContextLevels = TRUE; #endif }

RenderRegion::RenderRegion (  const RenderRegion &  other  )

Copy Constructor for RenderRegion. This conctructs a RenderRegion based on another. This involves copying all the current attributes and also making a copy of the ContextStack. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 15/7/93 Parameters: The  RenderRegion to copy [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 518 of file rndrgn.cpp. { PathProcessorStack = NULL; // We don't copy the PPStack - that's done as attrs are copied CurrentClipRect = other.CurrentClipRect; RenderComplexShapes = other.RenderComplexShapes; RenderMatrix = other.RenderMatrix; ScaleFactor = other.ScaleFactor; RenderView = other.RenderView; RenderDC = other.RenderDC; m_fOwned = other.m_fOwned; // DCHandle = other.DCHandle; RenderFlags = other.RenderFlags; RenderSpread = other.RenderSpread; CurrentColContext = other.CurrentColContext; PixelWidth = other.PixelWidth; ScaledPixelWidth = other.ScaledPixelWidth; Timeslice = other.Timeslice; RRQuality = other.RRQuality; NeedsOSPaper = other.NeedsOSPaper; // No paper has been rendered yet IsPaperRendered = other.IsPaperRendered; IsInkRenderStarted = other.IsInkRenderStarted; // Now setup the render state CurrentRenderState = other.CurrentRenderState; // CurrentSubRenderState = other.CurrentSubRenderState; CurrentSubRenderState = NULL; SubRenderStateLocked = FALSE; // Copy the current attributes NumCurrentAttrs = 0; // We're constructing, so we have no current attrs yet CurrentAttrs = NULL; if (!CopyCurrentAttributes(other)) { // Unable to copy the current attributes ENSURE(FALSE, "Unable to copy current attributes"); InformError(); return; } // Now make a copy of the ContextSatck if (!TheStack.Copy(&other.TheStack, this)) { // Unable to copy the render stack ENSURE(FALSE, "Unable to copy Rendering stack"); InformError(); return; } DrawingMode = other.DrawingMode; // Set the Fuzzy Clipping Rects to something InnerRect = other.InnerRect; OuterRect = other.OuterRect; // Set up vars to do with banded rendering RegionRect = other.RegionRect; IsRegionBanded = other.IsRegionBanded; CanRegionBeMerged = other.CanRegionBeMerged; IsWaitingForRAM = other.IsWaitingForRAM; IsLastBand = other.IsLastBand; // Ilan IsBeingReset = FALSE; m_pFilter = other.m_pFilter; m_pBackmostChangedNode = other.m_pBackmostChangedNode; m_timeRenderTreeStartTime = other.m_timeRenderTreeStartTime; m_bRenderTreeTimeSlice = other.m_bRenderTreeTimeSlice; m_countTotal = other.m_countTotal; m_countStored = other.m_countStored; m_bForceMix = other.m_bForceMix; #ifdef _DEBUG m_CurrentContextLevel = 0; m_TraceOutContextLevels = FALSE; // m_TraceOutContextLevels = TRUE; #endif }

RenderRegion::~RenderRegion (   )  [virtual]

Default Destructor for RenderRegion Class. Releases any memory claimed for the ContextStack. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 15/5/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: OSRenderRegion::~OSRenderRegion() Definition at line 644 of file rndrgn.cpp. { // Ilan IsBeingReset = TRUE; // Get rid of any stacked Captures Capture* pCapture = GetTopCapture(); while (pCapture) { ENSURE(!pCapture->OwnsBitmap(), "Capture unexpectedly owns bitmap in RenderRegion::ResetRegion"); m_CaptureStack.Pop(); //TRACEUSER( "Phil", _T("~RenderRegion Pop/Delete Capture\n")); if (pCapture->IsMaster()) { SetRenderToCapture(pCapture, FALSE, FALSE); } else { pCapture->FreeDIB(); } delete pCapture; pCapture = GetTopCapture(); } if( m_fOwned ) { delete RenderDC; RenderDC = NULL; } // Webster - markn 15/8/97 // This has been taken out of Webster builds as it can cause fatal access violations with Paper render regions. // It is new path processor code that not's totally bug-free, and as path processors are not used in Webster, // it can be safely taken out. // Now taken out via new VECTOR_STROKING flag Neville 2/10/97 #ifdef VECTOR_STROKING // Ask the RenderStack to pop all attributes off itself. This gives them a chance // to clean up properly (remove PathProcessors etc). TheStack.CleanUpBeforeDestruct(this); #endif // VECTOR_STROKING // Nearly always non-NULL, but e.g. PaperRenderRegions will have deleted // their attributes before we get here so we check (and hence don't GPF!) if (CurrentAttrs != NULL) { for (INT32 i = 0; i < NumCurrentAttrs; i++) { // WEBSTER - markn 16/7/97 // This hides a bug in the text tool, which won't go off if you don't use Path processors // The bug - // create a multi-line paragraph text object // Select all and apply -5 base line shift // Change to a large font // Change the font // Change the text size // Should go bang // // I have no idea what the problem is (I'd fix it if I knew), and don't have time to spend on it. // Should be looked into though... // Now taken out via new VECTOR_STROKING flag Neville 2/10/97 #ifdef VECTOR_STROKING // Tell the attribute that it's being chucked out of scope // CurrentAttrs[i].pAttr->GoingOutOfScope(this); #endif // VECTOR_STROKING // And delete it if it's a temporary attr if (CurrentAttrs[i].Temp) { CC_ASSERT_VALID(CurrentAttrs[i].pAttr); delete CurrentAttrs[i].pAttr; } } // We've finished with this array of attributes now CCFree(CurrentAttrs); } if (CurrentSubRenderState != NULL) delete CurrentSubRenderState; if (PathProcessorStack != NULL) { // ERROR3("RenderRegion destructed while PathProcessors still active"); while (PathProcessorStack != NULL) PopPathProcessor(); } }

---

Member Function Documentation

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

Attaches View, wxDC and Spread pointers to the RenderRegion. The View is used to for general rendering purposes. The wxDC is the device that we are rendering to. We extract the HDC from this and store it so we can recreate another wxDC object for background rendering. The Spread is just stored for external referance and is used to continue rendering during BackGnd redraw. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 11/5/93 Parameters: A  View ptr ,wxDC ptr and Spread ptr to attach to the RenderRegion. [INPUTS] The View pointer must not be NULL! Returns: TRUE if attached successfully; FALSE if not. NB. This function should be called before doing anything else in the AttachDevice() function of a derived class. Returns: Errors: If ViewToAttach is NULL => ERROR2 See also: RenderRegion::InitDevice Definition at line 863 of file rndrgn.cpp. { return AttachDevice(ViewToAttach, DCToAttach->GetDC(), SpreadToAttach, fOwned); }

BOOL RenderRegion::AttachDevice (  View *  , CNativeDC *  , Spread *  SpreadToAttach = NULL, bool  fOwned = false )  [virtual]

Reimplemented in CMXRenderRegion, EPSRenderRegion, GRenderClick, GRenderClickColour, GRenderClickColourNoPaper, GRenderRegion, and OSRenderRegion. Definition at line 869 of file rndrgn.cpp. { RenderSpread = SpreadToAttach; RenderView = ViewToAttach; RenderDC = DCToAttach; m_fOwned = fOwned; ERROR2IF(ViewToAttach == NULL, FALSE, "NULL View passed to RenderRegion::AttachDevice()!"); // Find which view the render region is to be rendering to if (RenderView != NULL) { // We have a render window - calculate the pixel sizes. PixelWidth = CalcPixelWidth(); ScaledPixelWidth = CalcScaledPixelWidth(); } else if (IS_KIND_OF(OSRenderRegion)) { // Only do this for OSRenderRegions because they can be used to // render into dialogs (GRenderRegions have their own system // of pixel size). PixelWidth = CalcPixelWidth(); ScaledPixelWidth = CalcScaledPixelWidth(); } // No ink rendering yet. CurrentRenderState = NULL; CurrentSubRenderState = NULL; SubRenderStateLocked = FALSE; // Initialise drawing mode. DrawingMode = DM_COPYPEN; // All ok return TRUE; }

virtual MILLIPOINT RenderRegion::CalcPixelWidth (   )  [protected, pure virtual]

Implemented in AIEPSGradientScanRenderRegion, ImagemapRenderRegion, FormatRegion, ScanningRenderRegion, VectorFileRenderRegion, XPFRenderRegion, GRenderRegion, and OSRenderRegion.

virtual MILLIPOINT RenderRegion::CalcScaledPixelWidth (   )  [protected, pure virtual]

Implemented in AIEPSGradientScanRenderRegion, ImagemapRenderRegion, FormatRegion, ScanningRenderRegion, VectorFileRenderRegion, XPFRenderRegion, GRenderRegion, and OSRenderRegion.

BOOL RenderRegion::CanBeMerged (   )

This is used to help simplify the merging code with banded region. A banded render region at the start of one of its bands looks similar to a render region that has done no rendering yet, and may be merged. This function allows banded regions to stop themselves from being merged after they have started rendering into their first band. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 20/3/95 Returns: TRUE if this render region can be merged now. FALSE if it should not be merged. Definition at line 6416 of file rndrgn.cpp. { // If we have started rendering ink, then we can not merge if (IsInkRenderStarted) return FALSE; // if we have not, then we may be between bands in a banded render region return CanRegionBeMerged; }

BOOL RenderRegion::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 in GRenderRegion. Definition at line 7549 of file rndrgn.cpp. { // If there's a current RGBT capture active and we are changing to a non-transparent capture // Then mark that Capture as no longer being transparent // Blit whatever we have so far into the parent bitmap // Tell all enclosing captures (further up the stack) that they can no longer be transparent // either Capture* pCurrentCapture = GetTopCapture(); if (pCurrentCapture==NULL) return FALSE; if (pCurrentCapture->IsMaster()) { ENSURE(m_CaptureStack.Size()==1, "Master Capture not bottom capture in ChangeCapture"); return FALSE; } return TRUE; }

virtual BOOL RenderRegion::CheckOffscreenBounds (   )  [inline, virtual]

Reimplemented in ScanningRenderRegion, and XPFRenderRegion. Definition at line 660 of file rndrgn.h. { return(TRUE); }

void RenderRegion::ClearBackmostChangedNode (  Node *  pNode  )  [virtual]

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 10/08/2004 Parameters: -  [INPUTS] -  [OUTPUTS] Definition at line 7372 of file rndrgn.cpp. { if (pNode && (pNode == m_pBackmostChangedNode || pNode->IsNodeInSubtree(m_pBackmostChangedNode))) { m_pBackmostChangedNode = pNode->FindParentSpread(); } }

BOOL RenderRegion::CloseDown (   )  [virtual]

Base class declaration of the CloseDown function. It allows the CloseDown functions in the EPS and CMX filters to be virtual over-rides, which means that I don't need the IsKindOfs cluttering up the rendering loops. Author: Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com> Date: 24/02/00 Parameters: None.  [INPUTS] Returns: TRUE. See also: RenderRegion::AttachDevice; RenderRegion::InitDevice Reimplemented in PrintPSRenderRegion, and EPSRenderRegion. Definition at line 1232 of file rndrgn.cpp. { return TRUE; }

void RenderRegion::ColourCorrectBitmap (  BitmapFillAttribute *  Fill, BITMAPINFO *  Info, RGBQUAD **  Palette )

Applies colour correction and/or contoning to a paletted bitmap being plotted. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 1/6/96 Parameters: Fill  - NULL, or a pointer to a BFA which describes how this bitmap should [INPUTS] be contoned Info - The bitmap info header Palette - Must point to a (RGBQUAD *) which we can fill in (see outputs) Parameters: Palette  - Will be returned NULL if you should use the original bitmap's [OUTPUTS] palette, else is a pointer to a CCMalloc'd block of memory containing a colour corrected RGBQUAD palette to use instead -in which case you MUST CCFree() the new block when you've finished plotting the bitmap. Contoning and colour-correction of <=8bpp images is achieved by replacing the original palette with a corrected version. This means that even colour separation can be achieved on <=8bpp with this function. Images of more than 8bpp cannot be contoned. Images of more than 8bpp should be colour corrected by setting GDraw up to do colour correction on the fly (GD->SetBitmapConversionTable). This function thus takes a bitmap, and returns a pointer to the palette to be plot it with - if this pointer differs from the original one, it is then your responsibility to CCFree() the returned block to release the temporary memory. Definition at line 6837 of file rndrgn.cpp. { ERROR3IF(Info == NULL || Palette == NULL, "illegal NULL params"); *Palette = NULL; // Set up a suitable return default // --- If a fill was passed in, check if this is a contoned bitmap // If it is, we just provide a colour-corrected contone palette and return if (Fill != NULL && Fill->GetStartColour() != NULL && Fill->GetEndColour() != NULL) { *Palette = (RGBQUAD *) CCMalloc(256 * sizeof(RGBQUAD)); if (*Palette == NULL) { ERROR3("No memory for palette"); return; } GradTable32::BuildGraduatedPalette(*Fill->GetStartColour(), *Fill->GetEndColour(), GetRenderView(), GetFillEffect(), 256, *Palette, Fill->GetProfile()); return; } // --- If it's a paletted bitmap, then we just colour-correct the palette if (Info->bmiHeader.biBitCount <= 8) { // Not contoned, but should we colour-correct? if (CurrentColContext->GetColourPlate() != NULL && !CurrentColContext->GetColourPlate()->IsDisabled()) { *Palette = (RGBQUAD *) CCMalloc(256 * sizeof(RGBQUAD)); if (*Palette == NULL) { ERROR3("No memory for palette"); return; } RGBQUAD *OldPal = Info->bmiColors; DocColour temp; PColourRGBT Converted; for (DWORD i = 0; i < Info->bmiHeader.biClrUsed; i++) { temp.SetRGBValue(OldPal[i].rgbRed, OldPal[i].rgbGreen, OldPal[i].rgbBlue); CurrentColContext->ConvertColour(&temp, (ColourPacked *) &Converted); (*Palette)[i].rgbRed = Converted.Red; (*Palette)[i].rgbGreen = Converted.Green; (*Palette)[i].rgbBlue = Converted.Blue; (*Palette)[i].rgbReserved = OldPal[i].rgbReserved; } } return; } }

Matrix RenderRegion::ConcatenateMatrix (  Matrix &  NewMatrix  )  [virtual]

This can be used to add a transform in to the render regions transformation matrix. The function performs the following matrix operation :- MonoOn RenderMatrix = NewMatrix * RenderMatrix; MonoOff. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 26/10/93 Parameters: NewMatrix  - The Matrix that will be combined with the current [INPUTS] RenderMatrix in the RenderRegion Returns: The old RenderRegion Matrix See also: RenderRegion::SetMatrix Definition at line 1324 of file rndrgn.cpp. { // Need to remember the old matrix so we can return it Matrix Temp = RenderMatrix; // Add a transform to the matrix we already have RenderMatrix = NewMatrix * RenderMatrix; // return the old matrix to the caller return Temp; }

void RenderRegion::ConditionalSuicide (  void   )  [virtual]

Causes the object to commit suicide. This is to get around using a few if IS_A calls elsewhere in Camelot. Author: Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com> Date: 24/2/00 Parameters: -  [INPUTS] Returns: - Reimplemented in CamelotEPSRenderRegion, NativeRenderRegion, and PrintPSRenderRegion. Definition at line 1250 of file rndrgn.cpp. { // Yes, this is a legal C++ expression. Just don't attempt to call this object again. delete this; }

BOOL RenderRegion::CopyCurrentAttributes (  const RenderRegion &  Other  )  [protected]

Copy the current attribute array of another render region into this render region. The copying is intelligent; i.e. if the other array contains 'temporary' objects, then it will copy them, so two render regions don't try to delete the same object when their destructor is called. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 12/04/94 Parameters: Other  - the render region to copy from. [INPUTS] Returns: TRUE if the current attributes are copied ok; FALSE if not. Errors: Out of memory. Definition at line 1818 of file rndrgn.cpp. { // If the source render region has no attributes, this is ok, as we may // be cloning it before it has started rendering (attributes only get set up when // some rendering is done). if (Other.CurrentAttrs == NULL) { // No attributes - nothing to do. CurrentAttrs = NULL; NumCurrentAttrs = 0; return TRUE; } // Allocate a current attributes block. NumCurrentAttrs = Other.NumCurrentAttrs; ENSURE(NumCurrentAttrs != 0, "Mismatched attribute stack in CopyCurrentAttributes"); INT32 AttrBlkSize = sizeof(AttributeEntry) * NumCurrentAttrs; CurrentAttrs = (AttributeEntry *) CCMalloc(AttrBlkSize); if (CurrentAttrs == NULL) return FALSE; // Copy the current attribute values across memcpy(CurrentAttrs, Other.CurrentAttrs, AttrBlkSize); // We must take copies of any temporary objects to avoid multiple deletion problems. for (INT32 i = 0; i < NumCurrentAttrs; i++) { if (CurrentAttrs[i].Temp) { // Get the runtime class info on this object CCRuntimeClass *pCCRuntimeClass = CurrentAttrs[i].pAttr->GetRuntimeClass(); // Create another object of the same type AttributeValue *pNewAttr = (AttributeValue *) pCCRuntimeClass->CreateObject(); if (pNewAttr == NULL) { // Failed to create object - quit with error, but first ensure that all // the rest of the attributes are marked as non-temporary. // Otherwise the destructor will attempt to delete objects that belong // to the other render region. for (INT32 j = i; j < NumCurrentAttrs; j++) CurrentAttrs[j].Temp = FALSE; return FALSE; } // Object created ok - get the object to copy its contents across. pNewAttr->SimpleCopy(CurrentAttrs[i].pAttr); // Place this attribute in the array CurrentAttrs[i].pAttr = pNewAttr; } } // It all worked return TRUE; }

BOOL RenderRegion::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 in GRenderRegion. Definition at line 754 of file rndrgn.cpp. { // We're writing over our render info with the other RndRgn's settings, so we must vape // all of our PathProcessors (if there are any, which probably there shouldn't be) while (PathProcessorStack != NULL) PopPathProcessor(); // Copy params to do with the rendering CurrentClipRect = Other.CurrentClipRect; RenderMatrix = Other.RenderMatrix; ScaleFactor = Other.ScaleFactor; RenderSpread = Other.RenderSpread; DrawingMode = Other.DrawingMode; CurrentColContext = Other.CurrentColContext; RenderComplexShapes = Other.RenderComplexShapes; // Copy params to do with the window we are rendering into RenderView = Other.RenderView; RenderDC = Other.RenderDC; // DCHandle = Other.DCHandle; // Copy the flags RenderFlags = Other.RenderFlags; // Copy the pixel width info PixelWidth = Other.PixelWidth; ScaledPixelWidth = Other.ScaledPixelWidth; // Copy the rendered state IsPaperRendered = Other.IsPaperRendered; IsInkRenderStarted = Other.IsInkRenderStarted; NeedsOSPaper = Other.NeedsOSPaper; Timeslice = Other.Timeslice; RRQuality = Other.RRQuality; // Copy the node to render CurrentRenderState = Other.CurrentRenderState; CurrentSubRenderState = NULL; SubRenderStateLocked = FALSE; // Copy the current attributes if (!CopyCurrentAttributes(Other)) { // Unable to copy the current attributes ENSURE(FALSE, "Unable to copy current attributes"); InformError(); return FALSE; } // Now make a copy of the ContextSatck // Actually don't, or you get some attributes left from this render region at the bottom /* if (!TheStack.Copy(&Other.TheStack, this)) { // Unable to copy the render stack ENSURE(FALSE, "Unable to copy Rendering stack"); InformError(); return FALSE; } */ DrawingMode = Other.DrawingMode; // Set the Fuzzy Clipping Rects to something InnerRect = Other.InnerRect; OuterRect = Other.OuterRect; // Set up vars to do with banded rendering RegionRect = Other.RegionRect; IsRegionBanded = Other.IsRegionBanded; CanRegionBeMerged = Other.CanRegionBeMerged; IsLastBand = Other.IsLastBand; // this is critical to make sure InitDevice gets called on the next StartRender RenderFlags.ValidDevice = FALSE; return TRUE; }

Path * RenderRegion::CreateCharPath (  WCHAR  ch, Matrix *  pMatrix = NULL )

Create a path of the specified char, using the specified transform and current attributes in the render region Note: The caller is resposible for initialising the path's flags if required. Author: Ed_Cornes (Xara Group Ltd) <camelotdev@xara.com> Date: 19/3/95 Parameters: ch  - unicode value of char [INPUTS] pMatrix - possible matrix to transform char to correct place in doc Returns: pointer to new path (else NULL if fails) Definition at line 6119 of file rndrgn.cpp. { // get overall matrix - attribute matrix concatenated with given matrix if supplied Matrix matrix; if (GetCharAttributeMatrix(&matrix)==FALSE) return NULL; if (pMatrix) matrix*=*pMatrix; // create the default char path CharDescription CharDesc(ch, RR_TXTFONTTYPEFACE(), RR_TXTBOLD(), RR_TXTITALIC()); Path* pPath=FontCache::CreateDefaultCharPath(CharDesc); if (pPath==NULL) return NULL; // apply overall matrix to path INT32 points=pPath->GetNumCoords(); DocCoord* pCoords=pPath->GetCoordArray(); BOOL ok=(pCoords!=NULL); if (ok) matrix.transform((Coord*)pCoords, points); // if not OK, delete path and set return value to NULL if (!ok) { delete pPath; pPath=NULL; } return pPath; }

void RenderRegion::DefaultRender (  BOOL  bForceImmediate = FALSE  )

Calls the attatched view to render itself. This is used to continue rendering into a suspended RenderRegion. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 9/7/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 1128 of file rndrgn.cpp. { ENSURE(RenderView != NULL,"RenderRegion::DefaultRender called with invalid RenderView"); if (RenderView) { RenderView->AllocateDC(); RenderDC = RenderView->GetRenderDC(); if (RenderDC) { View * pView = RenderView; // as ContinueRenderView can delete the RenderRegion (i.e. "this"). RenderView->SetCurrent(); (RenderView->GetDoc())->SetCurrent(); RenderView->ContinueRenderView(this, RenderSpread, TRUE, TRUE, bForceImmediate); // This MUST pair with AllocateDC pView->DoneWithDC(); // hint that we might like to drop this DC so a fresh one will be created } else { // This error causes a recursive error condition so I'll just TRACE for now // Error::SetError(_R(IDT_INTERNAL_ERROR), 0); // InformError(); TRACE(_T("Failed to get a DC for rendering in RenderRegion::DefaultRender\n")); } } }

BOOL RenderRegion::DrawArrowHead (  ArrowRec &  ArrowToDraw, DocCoord &  Centre, DocCoord &  Direction, DocCoord *  RetnCentre = NULL )  [virtual]

Draw an Arrow head on the start or end of a line. 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: - Definition at line 5477 of file rndrgn.cpp. { // Get a matrix to transform the Arrow Trans2DMatrix Trans; ArrowToDraw.GetArrowMatrix(Centre, Direction, RR_LINEWIDTH(), &Trans); // Get the current Render Matrix, and merge the arrow head // matrix with it. // Matrix NewRenderMatrix = Trans.GetMatrix(); // NewRenderMatrix *= RenderMatrix; Path* TransPath = new Path(); if (TransPath == NULL) return FALSE; BOOL ok = TransPath->Initialise(ArrowToDraw.ArrowShape->GetNumCoords()); if (ok) ok = TransPath->CopyPathDataFrom(ArrowToDraw.ArrowShape); if (!ok) { // Tidy up if we failed delete TransPath; return FALSE; } // calculate the start point of the arrow & put it into RetnCentre DocCoord Base; ArrowToDraw.GetArrowBase(&Base); Trans.Transform(&Base, 1); if (RetnCentre) { *RetnCentre = Base; } Trans.Transform(TransPath->GetCoordArray(), TransPath->GetNumCoords() ); SaveContext(); // We have to change the Line and Fill colours // First make sure we don't try and draw Arrows on our Arrow heads !!! BOOL OldStartArrowState = RR_STARTARROW().IsNull; BOOL OldEndArrowState = RR_ENDARROW().IsNull; RR_STARTARROW().IsNull = TRUE; RR_ENDARROW().IsNull = TRUE; // Set the fill colour to the line colour and the line colour to transparent SetFillColour(RR_STROKECOLOUR()); SetLineColour(COLOUR_TRANS); // Now set the Fill transparency to be a flat transparency, the // same as the current line transparency. FlatTranspFillAttribute* pAttr = new FlatTranspFillAttribute; pAttr->SetStartTransp(RR_STROKETRANSP()->GetStartTransp()); pAttr->SetTranspType(RR_STROKETRANSP()->GetTranspType()); SetTranspFillGeometry(pAttr, TRUE); // Make sure the Arrow Path is valid. // ArrowToDraw.ArrowShape->IsFilled = TRUE; // ArrowToDraw.ArrowShape->IsStroked = FALSE; TransPath->IsFilled = TRUE; TransPath->IsStroked = FALSE; // Draw the Arrow head // DrawPath(ArrowToDraw.ArrowShape); DrawPath(TransPath); RR_STARTARROW().IsNull = OldStartArrowState; RR_ENDARROW().IsNull = OldEndArrowState; RestoreContext(); // Get our Attributes Back. // Restore the old Rendering Matrix delete TransPath; return TRUE; }

virtual void RenderRegion::DrawBitmap (  const DocCoord &  Point, UINT32  BitmapID, UINT32  ToolID = 0 )  [pure virtual]

Implemented in AIEPSGradientScanRenderRegion, ImagemapRenderRegion, MaskedRenderRegion, FormatRegion, PrintingMaskedRenderRegion, ScanningRenderRegion, VectorFileRenderRegion, XPFRenderRegion, GRenderRegion, and OSRenderRegion.

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

Implemented in AIEPSGradientScanRenderRegion, ImagemapRenderRegion, MaskedRenderRegion, FormatRegion, PrintingMaskedRenderRegion, ScanningRenderRegion, VectorFileRenderRegion, XPFRenderRegion, GRenderRegion, and OSRenderRegion.

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

Implemented in AIEPSGradientScanRenderRegion, ImagemapRenderRegion, MaskedRenderRegion, FormatRegion, ScanningRenderRegion, VectorFileRenderRegion, XPFRenderRegion, GRenderRegion, and OSRenderRegion.

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

Implemented in AIEPSGradientScanRenderRegion, ImagemapRenderRegion, MaskedRenderRegion, FormatRegion, ScanningRenderRegion, VectorFileRenderRegion, XPFRenderRegion, GRenderRegion, and OSRenderRegion.

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

Implemented in AIEPSGradientScanRenderRegion, ImagemapRenderRegion, MaskedRenderRegion, FormatRegion, ScanningRenderRegion, VectorFileRenderRegion, XPFRenderRegion, GRenderRegion, and OSRenderRegion.

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

Implemented in AIEPSGradientScanRenderRegion, ImagemapRenderRegion, MaskedRenderRegion, FormatRegion, ScanningRenderRegion, VectorFileRenderRegion, XPFRenderRegion, GRenderRegion, and OSRenderRegion.

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

Draws a dashed line between the two points. Uses the technology from DrawDragBounds(). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 10/10/95 Parameters: StartPoint  - start of the line [INPUTS] EndPoint - end of the line NOTE: This is the base class implementation that only partially works. Only designed to work correctly in OSRenderRegions See also: OSRenderRegion::DrawDashLine() Reimplemented in OSRenderRegion. Definition at line 5748 of file rndrgn.cpp. { Path ThePath; ThePath.Initialise(12, 12); ThePath.FindStartOfPath(); ThePath.InsertMoveTo(StartPoint); ThePath.InsertLineTo(EndPoint); ThePath.IsFilled = FALSE; DrawPath(&ThePath); }

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

Used to draw a "rectangle" to screen (for dragging). However, the corners of the rectangle are passed through the current rendering matrix, so the rect may well be rotated or skewed by the time it reaches the screen. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 16/5/95 Parameters: RectToRender  - The bounding rectangle we wish to render. [INPUTS] Notes: DO NOT confuse this method with DrawDragRect (which will draw a rectangle without skew or rotation) OSRenderRegions override this method to provide dotted-line redraw of the bounds (note: Not a dash-pattern, a simple on/off pixel dottyness). Note that OSRenderRegions CALL THIS METHOD to actually draw the path, so taqke care if changing this function. See also: OSRenderRegion::DrawDragRect; OSRenderRegion::DrawDragBounds; Range::RenderXOROutlinesOn Reimplemented in OSRenderRegion. Definition at line 5714 of file rndrgn.cpp. { Path SquarePath; SquarePath.Initialise(12, 12); SquarePath.FindStartOfPath(); SquarePath.InsertMoveTo(RectToRender->lo); SquarePath.InsertLineTo(DocCoord(RectToRender->hi.x, RectToRender->lo.y)); SquarePath.InsertLineTo(RectToRender->hi); SquarePath.InsertLineTo(DocCoord(RectToRender->lo.x, RectToRender->hi.y)); SquarePath.InsertLineTo(RectToRender->lo); SquarePath.IsFilled = FALSE; DrawPath(&SquarePath); }

virtual void RenderRegion::DrawDragRect (  DocRect *  RectToRender  )  [pure virtual]

Implemented in AIEPSGradientScanRenderRegion, ImagemapRenderRegion, MaskedRenderRegion, FormatRegion, ScanningRenderRegion, VectorFileRenderRegion, XPFRenderRegion, GRenderRegion, and OSRenderRegion.

void RenderRegion::DrawFixedSystemText (  StringBase *  TheText, DocRect &  BoundsRect, UINT32  uFormat = 0x00000020 | 0x00000800 | 0x00000004 )  [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 in FormatRegion, GRenderRegion, and OSRenderRegion. Definition at line 5052 of file rndrgn.cpp. { ERROR2RAW("Attempt to call unsupported RenderRegion::DrawFixedSystemText method"); }

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

Implemented in AIEPSGradientScanRenderRegion, ImagemapRenderRegion, MaskedRenderRegion, FormatRegion, PrintingMaskedRenderRegion, ScanningRenderRegion, VectorFileRenderRegion, XPFRenderRegion, GRenderRegion, and OSRenderRegion.

SlowJobResult RenderRegion::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 in CamelotEPSRenderRegion, GRenderRegion, and OSRenderRegion. Definition at line 6750 of file rndrgn.cpp. { return SLOWJOB_SUCCESS; }

void RenderRegion::DrawPath (  Path *  pPath, PathProcessor *  pCaller = NULL, PathShape  shapePath = PATHSHAPE_PATH )  [virtual]

Renders a path (main entry-point). May start a binary-recursive rendering pipeline off by calling any active path processors to do their stuff. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 19/12/96 Parameters: pPath  - Points to the path to be rendered [INPUTS] pCaller - NULL, or if you're calling this from a path processor, pass your 'this' pointer in here to support the recursion shapePath - (Graham 14/4/97) A tag which describes what shape the path is. For example, if shapeThis=PATHSHAPE_RECTANGLE, then RenderRegions that want to treat rectangles differently can do so. Ideally we should replace this so that rectangles are rendered by calling the DrawRect function, circles by calling the DrawCircle function, and so on. See also: RenderRegion::DrawPathToOutputDevice Definition at line 5158 of file rndrgn.cpp. { ERROR3IF(pPath == NULL, "Illegal NULL param"); PathProcessor *pNextProcessor = NULL; if (pCaller == NULL) { pNextProcessor = PathProcessorStack; // First call } else { pNextProcessor = pCaller->GetNextProcessor(); // Recursive call } // see if any of our processors actually do anything while (pNextProcessor != NULL && (!pNextProcessor->DoesActuallyDoAnything(this))) { pNextProcessor = pNextProcessor->GetNextProcessor(); } // we seem to be getting problems with two path processor brushes on the stack // if we blend between a brush and a bevel if (pNextProcessor != NULL && pCaller != NULL && pNextProcessor->IsAPathProcessorBrush() && pCaller->IsAPathProcessorBrush()) { BrushHandle ThisHandle = ((PathProcessorBrush*)pCaller)->GetBrushDefinitionHandle(); BrushHandle NextHandle = ((PathProcessorBrush*)pNextProcessor)->GetBrushDefinitionHandle(); if (NextHandle == ThisHandle) pNextProcessor = NULL; } // If we found another PathProcessor to call, recursively call it if (pNextProcessor != NULL) { // Does the processor change both fill & stroke independently? if (pNextProcessor->WillChangeFillAndStrokeSeparately()) { // Remember current path settings - we have to poke it directly // to be efficient about changing it. BOOL WasFilled = pPath->IsFilled; BOOL WasStroked = pPath->IsStroked; // Call the PathProcessor to only fill the path, if it is filled. // There's a hideous special case in here for non-contoned bitmaps (which have a // fill colour of TRANSPARENT! Arrrrgh!) if (WasFilled && (!RR_FILLCOLOUR().IsTransparent() || ((ColourFillAttribute *) CurrentAttrs[ATTR_FILLGEOMETRY].pAttr)->IsABitmapFill() ) ) { pPath->IsStroked = FALSE; pPath->IsFilled = TRUE; pNextProcessor->ProcessPath(pPath, this, shapePath); } // And then call it again to only stroke the path if (WasStroked && !RR_STROKECOLOUR().IsTransparent()) { pPath->IsStroked = TRUE; pPath->IsFilled = FALSE; pNextProcessor->ProcessPath(pPath, this, shapePath); } // Restore previous path settings pPath->IsFilled = WasFilled; pPath->IsStroked = WasStroked; return; } // It can be passed through as a single path pNextProcessor->ProcessPath(pPath, this, shapePath); return; } // We have now called any active path processors, so simply output the final // path to the output device //Graham 14/4/97: Also pass along the PathShape parameter to let the renderregion //know if the path is a special shape DrawPathToOutputDevice(pPath, shapePath); }

BOOL RenderRegion::DrawPathArrowHeads (  DocCoord *  Coords, PathVerb *  Verbs, INT32  NumCoords )  [virtual]

Draws arrows heads on the start or end of an open path, according to the current ArrowHead Attributes. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 3/4/95 Parameters: The  path to render the arrow heads onto. [INPUTS] See also: - Definition at line 5380 of file rndrgn.cpp. { BOOL ArrowRendered = FALSE; if (!RR_STARTARROW().IsNullArrow()) { INT32 PathIndex = 0; DocCoord ArrowCentre; DocCoord ArrowDirection; DocCoord ArrowBase; // Find the first position of an ArrowHead BOOL GotPos = ArrowRec::GetFirstArrowPos(TRUE, Coords, Verbs, NumCoords, &PathIndex, &ArrowCentre, &ArrowDirection); while (GotPos) { DrawArrowHead(RR_STARTARROW(), ArrowCentre, ArrowDirection, &ArrowBase); // DMc Update 25/2/99 so that arrows are drawn on the path - not after it ! // find the coord which caused the arrow to be drawn BOOL bFound = FALSE; INT32 i; for (i = PathIndex - 1 ; i >= 0 && !bFound; i--) { if (Verbs[i] == PT_MOVETO) { bFound = TRUE; } } if (bFound && !(RR_STARTARROW().m_bExtendPath)) { // move the coord in the path back by arrow size Coords[i+1].x = ArrowBase.x; Coords[i+1].y = ArrowBase.y; } ArrowRendered = TRUE; // Find the next Arrow position (if there are any more subpaths) GotPos = ArrowRec::GetNextArrowPos(TRUE, Coords, Verbs, NumCoords, &PathIndex, &ArrowCentre, &ArrowDirection); } } if (!RR_ENDARROW().IsNullArrow()) { INT32 PathIndex = 0; DocCoord ArrowCentre; DocCoord ArrowDirection; DocCoord ArrowBase; // Find the first position of an ArrowHead BOOL GotPos = ArrowRec::GetFirstArrowPos(FALSE, Coords, Verbs, NumCoords, &PathIndex, &ArrowCentre, &ArrowDirection); while (GotPos) { DrawArrowHead(RR_ENDARROW(), ArrowCentre, ArrowDirection, &ArrowBase); // move the coordinate on the path if (!(RR_ENDARROW().m_bExtendPath)) { Coords[PathIndex-1].x = ArrowBase.x; Coords[PathIndex-1].y = ArrowBase.y; } ArrowRendered = TRUE; // Find the next Arrow position (if there are any more subpaths) GotPos = ArrowRec::GetNextArrowPos(FALSE, Coords, Verbs, NumCoords, &PathIndex, &ArrowCentre, &ArrowDirection); } } return ArrowRendered; }

virtual void RenderRegion::DrawPathToOutputDevice (  Path *  PathToRender, PathShape  shapePath = PATHSHAPE_PATH )  [pure virtual]

Implemented in AIEPSGradientScanRenderRegion, CamelotEPSRenderRegion, CMXRenderRegion, ImagemapRenderRegion, MaskedRenderRegion, FormatRegion, PrintingMaskedRenderRegion, EPSRenderRegion, ScanningRenderRegion, FlashRenderRegion, XPFRenderRegion, GRenderRegion, and OSRenderRegion.

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

Implemented in AIEPSGradientScanRenderRegion, ImagemapRenderRegion, MaskedRenderRegion, FormatRegion, PrintingMaskedRenderRegion, ScanningRenderRegion, VectorFileRenderRegion, XPFRenderRegion, GRenderRegion, and OSRenderRegion.

void RenderRegion::DrawPixelLine (  const DocCoord &  StartPoint, const DocCoord &  EndPoint )  [virtual]

To try and plot a single pixel line. It does this by using a filled rectangle rather than just drawing the line itself. This is required because although GDI and GDraw fills can be made to match up, their outlines can't (at the time of writing). Assumes fill colour and line colour have already been set up along with a line width, usually assumed to be zero which means plot single-pixel lines. Usually, the fill colour is set to be the required line colour and the line colour is set to be transparent (COLOUR_TRANS). Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 18/1/95 Parameters: StartPoint  - The starting point to render from. [INPUTS] EndPoint - The end point to render to. -  [OUTPUTS] Returns: - See also: OSRenderRegion::DrawLine; GRenderRegion::DrawLine; RenderRegion::DrawPixelRect; Reimplemented in FormatRegion. Definition at line 5845 of file rndrgn.cpp. { // Below is some conditional code. // The correct code is directly below in the IF clause and just in fact calls the standard // DrawLine call. // The bodged version is the code in the ELSE clause and renders the single pixel line // using a filled rectangle. This is required because although GDI and GDraw fills // can be made to match up, their outlines can't (at the time of writing). // // By the way, Gavin says, it's faster to plot four upright rects than to stroke a path // to become the outline of the page!!! // #if 0 DrawLine(StartPoint, EndPoint); #else // Get the scaled pixel size for the view FIXED16 ScaledPixelWidth, ScaledPixelHeight; RenderView->GetScaledPixelSize(&ScaledPixelWidth, &ScaledPixelHeight); // Draw the line DocRect VertRect(StartPoint.x, StartPoint.y, EndPoint.x + ScaledPixelWidth.MakeLong(), EndPoint.y + ScaledPixelHeight.MakeLong()); DrawRect(&VertRect); #endif }

void RenderRegion::DrawPixelRect (  DocRect *  RectToRender  )  [virtual]

To try and plot a single pixel rectangle outline. It does this by using filled rectangles rather than just drawing the line itself. This is required because although GDI and GDraw fills can be made to match up, their outlines can't (at the time of writing). Assumes fill colour and line colour have already been set up along with a line width, usually assumed to be zero which means plot single-pixel lines. Usually, the fill colour is set to be the required line colour and the line colour is set to be transparent (COLOUR_TRANS). Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 18/1/95 Parameters: RectToRender  - The rectangle we wish to render. [INPUTS] -  [OUTPUTS] Returns: - See also: OSRenderRegion::DrawRect; GRenderRegion::DrawRect; RenderRegion::DrawPixelLine; Reimplemented in FormatRegion. Definition at line 5782 of file rndrgn.cpp. { // Below is some conditional code. // The correct code is directly below in the IF clause and just in fact calls the standard // DrawRect call. // The bodged version is the code in the ELSE clause and renders the single pixel outline // using filled rectangles. This is required because although GDI and GDraw fills // can be made to match up, their outlines can't (at the time of writing). // // By the way, Gavin says, it's faster to plot four upright rects than to stroke a path // to become the outline of the page!!! // #if 0 // Draw that page rectangle using the standard call DrawRect(RectToRender); #else // Get the scaled pixel size for the view FIXED16 ScaledPixelWidth, ScaledPixelHeight; RenderView->GetScaledPixelSize(&ScaledPixelWidth, &ScaledPixelHeight); // Draw a rectangle using 4 filled rectangles. DocRect VertRect(RectToRender->lo.x, RectToRender->lo.y, RectToRender->lo.x + ScaledPixelWidth.MakeLong(), RectToRender->hi.y + ScaledPixelHeight.MakeLong()); DrawRect(&VertRect); // Left VertRect.Translate(RectToRender->Width(),0); DrawRect(&VertRect); // Right DocRect HorzRect(RectToRender->lo.x, RectToRender->lo.y, RectToRender->hi.x, RectToRender->lo.y + ScaledPixelHeight.MakeLong()); DrawRect(&HorzRect); // Bottom HorzRect.Translate(0,RectToRender->Height()); DrawRect(&HorzRect); // Top #endif }

virtual void RenderRegion::DrawRect (  DocRect *  RectToRender  )  [pure virtual]

Implemented in AIEPSGradientScanRenderRegion, ImagemapRenderRegion, MaskedRenderRegion, FormatRegion, PrintingMaskedRenderRegion, ScanningRenderRegion, VectorFileRenderRegion, XPFRenderRegion, GRenderRegion, and OSRenderRegion.

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

Reimplemented in CamelotEPSRenderRegion, MaskedRenderRegion, PrintingMaskedRenderRegion, ScanningRenderRegion, XPFRenderRegion, and OSRenderRegion. Definition at line 5560 of file rndrgn.cpp. { // If we are not drawing complex shapes and this shape is, then return RRCaps Caps; GetRenderRegionCaps(&Caps); if ((!RenderComplexShapes) && (TestForComplexShape(&Caps))) return TRUE; if ((!RenderComplexShapes) && (pNodeBitmap->NeedsTransparency())) return TRUE; KernelBitmap* pkBitmap = pNodeBitmap->GetBitmap(); if (pkBitmap==NULL || pkBitmap->GetWidth()==0 || pkBitmap->GetHeight()==0) return TRUE; // By default, we can't do arbitrarily transformed bitmaps - use a bitmap fill. SaveContext(); // No lines on the rectangle SetLineColour(COLOUR_TRANS); SetLineWidth(0); if (RRQuality.GetFillQuality() == Quality::Bitmaps) { // The quality is set to show Bitmaps, with everything else in outline // mode, so we'll fake this by temorarily setting the quality to 'Solid' // just while we render this node. Quality NewQuality; NewQuality.SetQuality(31); // Force solid fills while we render this node QualityAttribute* pQualityAttr = new QualityAttribute(NewQuality); SetQuality(pQualityAttr, TRUE); } // Simple bitmap fill which fills the whole shape BitmapFillAttribute *pBitmapAttr = new BitmapFillAttribute; pBitmapAttr->GetBitmapRef()->SetBitmap(pNodeBitmap->GetBitmap()); if (IsVeryMono() && !pNodeBitmap->NeedsTransparency()) { // VeryMono, so plot as black (unless it's a masked bitmap) DocColour ColBlack = COLOUR_BLACK; pBitmapAttr->SetStartColour(&ColBlack); } // (ChrisG - 7/11/00) Removed as the CanBeContoned bool is not supported. // This default value was stopping derived render regions from overriding // this function, so almost all bitmaps were drawn by this code... // Err no ChrisG the header file used to be CanBeContoned = TRUE // so we DO RUN THIS CODE all the time ie all bitmaps CAN be contoned (sjk 19/11/00) else // if(CanBeContoned) { if (pNodeBitmap->GetStartColour()) pBitmapAttr->SetStartColour(pNodeBitmap->GetStartColour()); if (pNodeBitmap->GetEndColour()) pBitmapAttr->SetEndColour(pNodeBitmap->GetEndColour()); } DocCoord *Coords = pNodeBitmap->InkPath.GetCoordArray(); pBitmapAttr->StartPoint = Coords[3]; pBitmapAttr->EndPoint = Coords[2]; pBitmapAttr->EndPoint2 = Coords[0]; // Set bitmap attribute, and get the render region to throw it away when it's finished // with (hence the TRUE parameter). SetFillGeometry(pBitmapAttr, TRUE); // Set the mapping to have no repeat, otherwise we get artifacts at the edges when // anti-aliasing is enabled (see bug 1391). FillMappingLinearAttribute *pNoRepeatAttr = new FillMappingLinearAttribute; // Repeat value of '3' means 'repeat inverted' (there are no symbolic names for // these repeat values - shout at Will if you want some!). // pNoRepeatAttr->Repeat = 3; pNoRepeatAttr->Repeat = 0; // Set mapping attribute, and get the render region to throw it away when it's finished // with (hence the TRUE parameter). SetFillMapping(pNoRepeatAttr, TRUE); // Draw the bitmap by rendering a bitmap filled path. pNodeBitmap->InkPath.IsFilled = TRUE; DrawPath(&pNodeBitmap->InkPath); RestoreContext(); // All done return TRUE; }

void RenderRegion::EnableAllBrushPathProcessors (  BOOL  Enable  )

Enables or disables all the brush path processors on the stack. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 20/12/96 Parameters: Enable  - whether we wish to enable the processors or not [INPUTS] Definition at line 5355 of file rndrgn.cpp. { PathProcessor* pPP = PathProcessorStack; while (pPP != NULL) { if (pPP->IsAPathProcessorBrush()) pPP->SetDisabled(!Enable); pPP = pPP->GetNextProcessor(); } }

BOOL RenderRegion::GetAttrdCharBounds (  DocRect *  pBounds, WCHAR  ch )

Get the bounding box of the specified char (from a cache) and apply the required transform depending on attributes (this is a character relative rect!). Author: Ed_Cornes (Xara Group Ltd) <camelotdev@xara.com> Date: 19/3/95 Parameters: ch  - unicode value of char [INPUTS] pRect  - bounding box of char in doc [OUTPUTS] Returns: FALSE if fails Definition at line 6084 of file rndrgn.cpp. { ERROR2IF(pBounds==NULL,FALSE,"RenderRegion::GetAttrdCharBounds() - pBounds==NULL"); // get defualt bounds from cache CharDescription CharDesc(ch, RR_TXTFONTTYPEFACE(), RR_TXTBOLD(), RR_TXTITALIC()); BOOL ok = FontCache::GetBounds(pBounds,CharDesc); // get and apply attribute matrix to bounds Matrix matrix; if (ok) ok = GetCharAttributeMatrix(&matrix); if (ok) ok = matrix.TransformBounds(pBounds); // transform inaccuracies cause empty rects to become non-empty // so for very small ones to be empty (ok as rect char relative) if (ok && pBounds->Width()<3 && pBounds->Height()<3) pBounds->MakeEmpty(); return ok; }

virtual Node* RenderRegion::GetBackmostChangedNode (   )  [inline, virtual]

Definition at line 398 of file rndrgn.h. { return m_pBackmostChangedNode; }

virtual INT32 RenderRegion::GetCaptureDepth (   )  [inline, virtual]

Definition at line 759 of file rndrgn.h. {return m_CaptureStack.Size();}

BOOL RenderRegion::GetCharAttributeMatrix (  Matrix *  pAttrMatrix  )

calc attribute matrix based on FontSize, AspectRatio and Script attributes Author: Ed_Cornes (Xara Group Ltd) <camelotdev@xara.com> Date: 20/3/95 Parameters: pAttrMatrix  - [OUTPUTS] Returns: FALSE if fails Definition at line 6161 of file rndrgn.cpp. { ERROR2IF(pAttrMatrix==NULL,FALSE,"RenderRegion::GetCharAttributeMatrix() - pAttrMatrix==NULL"); TxtScriptAttribute* pScriptAttr=RR_TXTSCRIPT(); ERROR2IF(pScriptAttr==NULL,FALSE,"RenderRegion::GetCharAttributeMatrix() - pScriptAttr==NULL"); MILLIPOINT FontSize = RR_TXTFONTSIZE(); MILLIPOINT OffsetY = XLONG(FontSize) * pScriptAttr->Offset; FIXED16 fScaleY = pScriptAttr->Size * Div32By32(FontSize, TextManager::GetDefaultHeight()); FIXED16 fScaleX = fScaleY * RR_TXTASPECTRATIO(); *pAttrMatrix = Matrix(fScaleX,0,0,fScaleY,0,OffsetY); return TRUE; }

DocRect RenderRegion::GetClipRect (   )

Returns the clipping rectangle of the Render Region. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 26/5/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: A DocRect describing the tightest bounding box around the clipping region Errors: - See also: RenderRegion::SetClipRect(); RenderRegion::RenderRegion() Definition at line 1405 of file rndrgn.cpp. { return CurrentClipRect; }

ColourContext * RenderRegion::GetColourContext (   )

Definition at line 1031 of file rndrgn.cpp. { return(CurrentColContext); }

AttributeValue * RenderRegion::GetCurrentAttribute (  UINT32  Index  )

Get a pointer to one of the render region's current attributes. The index indicates which kind of attribute should be returned. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 7/2/95 Parameters: Index  - the ID of the attribute to be examined. [INPUTS] Returns: Pointer to the current attribute of the type requested; NULL if the index is out of range. Definition at line 5889 of file rndrgn.cpp. { // Make sure this is a valid attribute index ID if (Index < (UINT32)NumCurrentAttrs) return CurrentAttrs[Index].pAttr; // Illegal index - return error return NULL; }

OffscreenAttrValue* RenderRegion::GetCurrentOffscreenAttr (   )  [inline]

Definition at line 658 of file rndrgn.h. { return(CurrentOffscreenAttr); }

EFFECTTYPE RenderRegion::GetFillEffect (   )

Decide what type of colour fade to use. Scope: Public. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 24/8/94 Returns: TRUE, if should use HSV fades. FALSE, if should use RGB fades. Definition at line 5666 of file rndrgn.cpp. { // Get the current Fill Effect FillEffectAttribute* FillEffect = RR_FILLEFFECT(); // What kind of fill effect is this ? CCRuntimeClass* Effect = FillEffect->GetRuntimeClass(); if (Effect == CC_RUNTIME_CLASS(FillEffectFadeAttribute)) return EFFECT_RGB; // Use RGB space if (Effect == CC_RUNTIME_CLASS(FillEffectRainbowAttribute)) return EFFECT_HSV_SHORT; // Use HSV short path if (Effect == CC_RUNTIME_CLASS(FillEffectAltRainbowAttribute)) return EFFECT_HSV_LONG; // Use HSV INT32 path return EFFECT_RGB; // Default to RGB space }

Filter* RenderRegion::GetFilter (   )  [inline]

Definition at line 683 of file rndrgn.h. {return m_pFilter;}

PathProcessor* RenderRegion::GetFirstPathProcessor (  void   )  [inline]

Definition at line 485 of file rndrgn.h. { return(PathProcessorStack); };

void RenderRegion::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 in FormatRegion, GRenderRegion, and OSRenderRegion. Definition at line 5120 of file rndrgn.cpp. { if (BoundsRect != NULL) *BoundsRect = DocRect(0,0,0,0); ERROR2RAW("Attempt to call unsupported RenderRegion::GetFixedSystemTextSize method"); }

BOOL RenderRegion::GetImmediateRender (   )  const [inline]

Definition at line 729 of file rndrgn.h. {return RenderFlags.bImmediateRender;}

virtual Capture* RenderRegion::GetMasterCapture (   )  const [inline, virtual]

Definition at line 762 of file rndrgn.h. {return m_CaptureStack.Empty() ? NULL : m_CaptureStack.Bottom();}

Matrix RenderRegion::GetMatrix (   )  [inline]

Definition at line 412 of file rndrgn.h. { return RenderMatrix; }

BOOL RenderRegion::GetNextBand (   )  [virtual]

This function goes and sets up the next band in the render region ready for rendering and returns TRUE if it went OK. If there are no more bands to render then the function returns FALSE. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 20/3/95 Returns: TRUE if another band is ready to be rendered, FALSE if there were no more bands to render in this region. Errors: Causes an error if it can not get the next render region ready. See also: RenderRegion::IsBanded Reimplemented in GRenderBitmap, GRenderOptPalette, GRenderClick, GRenderDIB, and GRenderPrint. Definition at line 6376 of file rndrgn.cpp. { // No more bands here return FALSE; }

virtual double RenderRegion::GetPixelsPerInch (   )  [inline, virtual]

Reimplemented in ScanningRenderRegion, XPFRenderRegion, and GRenderRegion. Definition at line 669 of file rndrgn.h. { return 72000.0/ScaledPixelWidth; }

MILLIPOINT RenderRegion::GetPixelWidth (   )  [inline]

Definition at line 667 of file rndrgn.h. { return PixelWidth; }

DocRect RenderRegion::GetRegionRect (   )

This function returns the size of the whole render region. Note that this may be different from the Clip rect. If the region is banded, then the Clip rect will hold the rect of the band that is being rendered, while the RegionRect will always hold the rect the whole region. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 20/3/95 Returns: The rect of the actual region. Definition at line 6192 of file rndrgn.cpp. { return RegionRect; }

CNativeDC* RenderRegion::GetRenderDC (   )  [inline]

Definition at line 446 of file rndrgn.h. { return RenderDC; }

void RenderRegion::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 in CamelotEPSRenderRegion, CMXRenderRegion, ImagemapRenderRegion, NativeRenderRegion, EPSRenderRegion, ScanningRenderRegion, XPFRenderRegion, GRenderRegion, and OSRenderRegion. Definition at line 6442 of file rndrgn.cpp. { // by default, render regions can do Everything pCaps->CanDoAll(); }

Spread* RenderRegion::GetRenderSpread (   )  [inline]

Definition at line 452 of file rndrgn.h. { return RenderSpread; }

Node * RenderRegion::GetRenderState (   )

Returns the Current Render State of the RenderRegion, which is a pointer to the next Node to render. If NULL then it is not currently rendering. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 12/7/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: A Ptr to a Node (or NULL if idle). Errors: - See also: - Definition at line 1053 of file rndrgn.cpp. { return CurrentRenderState; }

View* RenderRegion::GetRenderView (   )  [inline]

Definition at line 451 of file rndrgn.h. { return RenderView; }

MILLIPOINT RenderRegion::GetScaledPixelWidth (   )  [inline]

Definition at line 668 of file rndrgn.h. { return ScaledPixelWidth; }

virtual INT64 RenderRegion::GetStoredCount (   )  [inline, virtual]

Definition at line 407 of file rndrgn.h. {return m_countStored;}

SubRenderContext* RenderRegion::GetSubRenderState (   )  [inline]

Definition at line 433 of file rndrgn.h. { return CurrentSubRenderState; }

INT32 RenderRegion::GetTimeslice (   )  const [inline]

Definition at line 447 of file rndrgn.h. { return Timeslice; }

virtual Capture* RenderRegion::GetTopCapture (   )  const [inline, virtual]

Definition at line 761 of file rndrgn.h. {return m_CaptureStack.Empty() ? NULL : m_CaptureStack.Top();}

virtual INT64 RenderRegion::GetTotalCount (   )  [inline, virtual]

Definition at line 406 of file rndrgn.h. {return m_countTotal;}

virtual CCachedBitmap RenderRegion::GrabBitmap (  DocRect  rectGrab  )  [inline, virtual]

Definition at line 605 of file rndrgn.h. {return CCachedBitmap();}

BOOL RenderRegion::ImmediateRender (   )  [virtual]

Used to Draw something immediately. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 26/7/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if current clip rect is within view (ie whether to render or not). Errors: - See also: - Reimplemented in GRenderClick. Definition at line 1073 of file rndrgn.cpp. { RenderFlags.bImmediateRender = TRUE; if (!StartRender()) return FALSE; // Immediate render regions default to 0 line-width because they usually want to // render drag blobs etc which should be only one pixel wide. SetLineWidth(0); // Immediate render is usually used for blob rendering // normally we use the default quality, but we mustn't do that on hit-detection bitmaps // else they render outlined shapes as solid (See GRenderClick classes) SetDefaultQuality(); //SetStartCap(LineCapButt); //SetJoinType(RoundJoin); return TRUE; }

BOOL RenderRegion::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 SimpleCCObject. Reimplemented in ImagemapRenderRegion, EPSRenderRegion, VectorFileRenderRegion, GRenderRegion, and OSRenderRegion. Definition at line 623 of file rndrgn.cpp. { return TRUE; }

virtual void RenderRegion::InitAttributes (   )  [protected, pure virtual]

Implemented in AIEPSGradientScanRenderRegion, ImagemapRenderRegion, FormatRegion, ScanningRenderRegion, VectorFileRenderRegion, XPFRenderRegion, GRenderRegion, and OSRenderRegion.

virtual void RenderRegion::InitClipping (   )  [protected, pure virtual]

Implemented in AIEPSGradientScanRenderRegion, ImagemapRenderRegion, FormatRegion, ScanningRenderRegion, VectorFileRenderRegion, XPFRenderRegion, GRenderRegion, and OSRenderRegion.

BOOL RenderRegion::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 in CMXRenderRegion, PrintPSRenderRegion, EPSRenderRegion, GRenderPrint, GRenderRegion, OSRenderRegion, and PaperRenderRegion. Definition at line 922 of file rndrgn.cpp. { // Find this documents default colour context for the screen (RGB) if (RenderView != NULL) { // Find a colour context for the View we're rendering. This will automatically find // a suitable local, document, or global context for us to use CurrentColContext = RenderView->GetColourContext(COLOURMODEL_RGBT); if (CurrentColContext == NULL) // should never be a problem! { DiagnosticFn( _T("InitDevice:"), _T("No colour context") ); ERROR(_R(IDT_INTERNAL_ERROR), FALSE); } } else { ERROR3("View is NULL in RenderRegion::InitDevice()"); return FALSE; } // If this region has been reset, then we may already have // a CurrentAttrs array that needs to be de-allocated. if (CurrentAttrs != NULL) { // Release any temporary objects used by the 'current attribute' array. for (INT32 i = 0; i < NumCurrentAttrs; i++) { if (CurrentAttrs[i].Temp) { CC_ASSERT_VALID(CurrentAttrs[i].pAttr); delete CurrentAttrs[i].pAttr; } } // We've finished with this array of attributes now CCFree(CurrentAttrs); NumCurrentAttrs = 0; } // Set up the attributes for this device. CurrentAttrs = AttributeManager::GetDefaultAttributes(); if (CurrentAttrs == NULL) { NumCurrentAttrs = 0; return FALSE; } // Find out how many attributes there are. NumCurrentAttrs = AttributeManager::GetNumAttributes(); // Render all non-NULL attributes. for (INT32 i = 0; i < NumCurrentAttrs; i++) { if (CurrentAttrs[i].pAttr != NULL && CurrentAttrs[i].pAttr->CanBeRenderedDirectly()) CurrentAttrs[i].pAttr->Render(this); } // Ilan // Initialise the current offscreen pointer with a placeholder // this ensures that there is a default value which can be shifted to TheStack // so that the Restore() function gets called to to signal when the offscreen // bitmap rendering process has completed // NB ATTR_FEATHER used, but any offscreen attr with a conventional Restore() function would do // NB2 don't need to free mem as it is a pointer to the default val CurrentOffscreenAttr = (OffscreenAttrValue*) AttributeManager::GetDefaultAttributeVal(ATTR_FEATHER); // Override the quality attribute according to the View's setting. // Don't bother if there is no DocView - e.g. it's a render region that is used // to export a file. if (RenderView != NULL) { // Create a new quality attribute and install it. QualityAttribute *pAttr = new QualityAttribute(RenderView->RenderQuality); ENSURE(pAttr != NULL, "No memory for quality attribute to be created"); if (pAttr == NULL) return FALSE; // TRUE => Temp; delete this attribute when it is popped off the stack. SetQuality(pAttr, TRUE); } // Everything completed ok return TRUE; }

BOOL RenderRegion::InitPrefs (   )  [static]

Initialises the RenderRegions preferences from the preference file. This is called once as Camelot starts up. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 22/9/93 Returns: TRUE if the Preference section was created ok Definition at line 244 of file rndrgn.cpp. { Camelot.DeclareSection( _T("Selection Blob Sizes"), 2 ); Camelot.DeclarePref( _T("Selection Blob Sizes"), _T("Selected Blobs"), &SelectedBlobSize, 1, 30 ); Camelot.DeclarePref( _T("Selection Blob Sizes"), _T("UnSelected Blobs"), &UnSelectedBlobSize, 1, 30 ); Camelot.DeclarePref( _T("Selection Blob Sizes"), _T("Multi Stage Selected Blobs"), &MultiStageSelectedBlobSize, 1, 30 ); Camelot.DeclarePref( _T("Selection Blob Sizes"), _T("Multi Stage UnSelected Blobs"), &MultiStageUnSelectedBlobSize, 1, 30 ); return TRUE; }

BOOL RenderRegion::IsBanded (   )

To find out if the render region is banded. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 20/3/95 Returns: TRUE if this render region is banded Definition at line 6394 of file rndrgn.cpp. { return IsRegionBanded; }

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

Reimplemented in GRenderRegion. Definition at line 421 of file rndrgn.h. {return FALSE;}

BOOL RenderRegion::IsHitDetect (   )  const [inline]

Definition at line 457 of file rndrgn.h. { return RenderFlags.VeryMono || RenderFlags.HitDetect; }

BOOL RenderRegion::IsPrinting (   )  [inline]

Definition at line 453 of file rndrgn.h. { return RenderFlags.Printing; }

BOOL RenderRegion::IsRendering (   )  [inline]

Definition at line 454 of file rndrgn.h. { return RenderFlags.Rendering; }

BOOL RenderRegion::IsSubRenderStateLocked (  void   )  const [inline]

Definition at line 442 of file rndrgn.h. { return(SubRenderStateLocked); };

BOOL RenderRegion::IsUsingSmoothedBitmaps (   )  [inline]

Definition at line 459 of file rndrgn.h. { return RenderFlags.SmoothedBitmaps; }

BOOL RenderRegion::IsVeryMono (   )  [inline]

Definition at line 456 of file rndrgn.h. { return RenderFlags.VeryMono; }

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

Reimplemented in GRenderRegion. Definition at line 717 of file rndrgn.h. {return FALSE;}

BOOL RenderRegion::LockedTransparentCaptures (   )  const [virtual]

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! Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 07/08/2005 Parameters: -  [INPUTS] -  [OUTPUTS] Definition at line 7588 of file rndrgn.cpp. { const ListT<Capture*>* pList = m_CaptureStack.GetListT(); Capture* pCapture = NULL; ListT<Capture*>::ConstIterator it = pList->End(); INT32 nListSize = pList->Size(); INT32 i=0; for (i=0; i < nListSize; i++) { pCapture = *(--it); if (pCapture->OwnsBitmap() && pCapture->IsTransparent() && (pCapture->IsMaster() || pCapture->info.caFlags.LockedTransparent) ) return TRUE; } return FALSE; }

void RenderRegion::LockSubRenderState (  BOOL  Lock  )  [inline]

Definition at line 443 of file rndrgn.h. { SubRenderStateLocked = Lock; };

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

Reimplemented in GRenderRegion. Definition at line 760 of file rndrgn.h. {return (!m_CaptureStack.Empty() && GetTopCapture() && GetTopCapture()->IsMaster());}

void RenderRegion::PopPathProcessor (  void   )

Pops a PathProcessor from the top of the rendering PathProcessor stack. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 20/12/96 Notes: The PathProcessor is deleted after being popped. See also: PathProcessor; RenderRegion::PushPathProcessor Definition at line 5314 of file rndrgn.cpp. { #if _DEBUG // BLOCK { PathProcessor *pPP = PathProcessorStack; while (pPP != NULL) { // TRACEUSER( "Jason", _T(" ")); // More indent for each processor on the stack pPP = pPP->GetNextProcessor(); } // TRACEUSER( "Jason", _T("<< PopPathProcessor %x\n"), PathProcessorStack); } #endif PathProcessor *TOS = PathProcessorStack; if (TOS != NULL) { PathProcessorStack = TOS->GetNextProcessor(); // Link TOS to 2nd processor in chain TOS->SetNextProcessor(NULL); // And make the popped one "clean" // Finally, delete the path processor delete TOS; } }

ColourFillAttribute * RenderRegion::PrepareFillGeometry (  ColourFillAttribute *  SourceAttr = NULL  )  [protected]

This function is used to allow 3 special attributes to function correctly. => Overprint line, Overprint fill, and Print on all plates. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 30/7/96 Parameters: SourceAttr  - NULL (to copy the current rendering fill attribute), [INPUTS] or the attribute to be "prepared". Returns: NULL if the given attribute needs not be changed before it is stacked, or points to a new attribute which should be stacked in place of the given one. Note that it is up to the caller to delete the new attribute (so when stacking it, you should set the "Temp" flag) These attributes are specil in that they act as modifiers to the current stroke and fill attributes - they convert active colours into either no-colour, or a special greyscale value. This is achieved by the following 2 steps: (1) Whenever a colour attribute is stacked, it is possibly replaced by a copy which has been modified with respect to the current states of the 3 Imagesetting attributes. (2) Whenever an Imagesetting attribute is stacked, the current line and/or fill attributes are copied (if necessary) in order to "apply" the new attribute effects to the current rendering colours. This function takes the appropriate attribute and determines if it needs to be changed. If it does, a new, replacement, attribute is created and returned, which the caller should use in place of the Notes: This function has one other purpose: It fixes bogus graduated fills. A no-colour to no-colour grad fill is (strangely) rendered as a solid black fill, so this methid will convert these silly attributes into flat no-colour fills. See also: RenderRegion::SetFillGeometry; RenderRegion::SetLineColour Definition at line 2062 of file rndrgn.cpp. { // --- Make sure we've got a source attribute to play with if (SourceAttr == NULL) // No provided attribute, so use the current fill attr SourceAttr = (ColourFillAttribute *) CurrentAttrs[ATTR_FILLGEOMETRY].pAttr; if (SourceAttr == NULL) // No attribute to modify return(NULL); // --- Find the source colours. DocColour *StartCol = SourceAttr->GetStartColour(); if (StartCol == NULL) // Bitmap fills may be NULL - we leave them be return(NULL); DocColour *EndCol = SourceAttr->GetEndColour(); // Note: May be NULL if it's a flat fill ColourFillAttribute *NewAttr = NULL; // --- Check for bogus grad fills // A no-colour to no-colour grad fill renders as solid black, so we always convert this // into a simple no-colour flat fill if (EndCol != NULL && StartCol->IsTransparent() && EndCol->IsTransparent()) { NewAttr = new FlatFillAttribute(*StartCol); return(NewAttr); } // --- Check for bitmap fills // We can't change the colours for PrintOnAllPlates because when printing these are rendered to // a masked render region, and then get colour-separated (doh!) // We can't render bitmaps with overprint, as we can't do a "transparent" colour in an // arbitrarily transformed bitmap // if (SourceAttr->IsKindOf(CC_RUNTIME_CLASS(BitmapFillAttribute))) if (SourceAttr->IsAKindOfBitmapFill()) return(NULL); // --- Check for the PrintOnAllPlates attribute if ( ((PrintOnAllPlatesAttrValue *) CurrentAttrs[ATTR_PRINTONALLPLATES].pAttr)->IsPrintOnAllPlatesOn() ) { BOOL HaveNewStartCol = FALSE; BOOL HaveNewEndCol = FALSE; DocColour NewStartCol; DocColour NewEndCol; // Get a global default CMYK colour context ColourContextGreyT *cc = (ColourContextGreyT *) ColourManager::GetColourContext(COLOURMODEL_GREYT); ERROR3IF(cc == NULL, "No default Greyscale colour context?!"); BOOL bNegate = FALSE; ColourPlateType Plate = COLOURPLATE_KEY; if (RenderView && RenderView->GetColourPlate()) { bNegate = RenderView->GetColourPlate()->IsNegative(); if (!RenderView->GetColourPlate()->IsMonochrome()) Plate = RenderView->GetColourPlate()->GetType(); } // Apply POAP to the start colour, if the colour will be affected if (!StartCol->IsTransparent() && StartCol->IsSeparable()) { // The print on all plates attribute is set, so we convert this into a pre-separated // Key greyscale DocColour, overriding overprint etc. First get it as a greyscale: PColourGreyT GreyDef; cc->ConvertColour(StartCol, (ColourPacked *) &GreyDef); // Then create a new CMYK colour with the grey-level in the required component PColourCMYK ColDef = {0, 0, 0, 0}; BYTE InkVal = bNegate ? GreyDef.Intensity : 255 - GreyDef.Intensity; switch (Plate) { case COLOURPLATE_CYAN: ColDef.Cyan = InkVal; break; case COLOURPLATE_MAGENTA: ColDef.Magenta = InkVal; break; case COLOURPLATE_YELLOW: ColDef.Yellow = InkVal; break; default: // This handles normal and composite as well as mono, key and spot plates ColDef.Key = InkVal; break; } NewStartCol.SetCMYKValue(&ColDef); // Set the new start colour to the CMYK value NewStartCol.SetSeparable(FALSE); // And set it non-separable HaveNewStartCol = TRUE; // Flag the fact that it's changed } // Apply POAP to the end colour (if any), if the colour will be affected if (EndCol != NULL && !EndCol->IsTransparent() && EndCol->IsSeparable()) { // The print on all plates attribute is set, so we convert this into a pre-separated // Key greyscale DocColour, overriding overprint etc. First get it as a greyscale: PColourGreyT GreyDef; cc->ConvertColour(EndCol, (ColourPacked *) &GreyDef); // Then create a new CMYK colour with the grey-level in the required component PColourCMYK ColDef = {0, 0, 0, 0}; BYTE InkVal = bNegate ? GreyDef.Intensity : 255 - GreyDef.Intensity; switch (Plate) { case COLOURPLATE_CYAN: ColDef.Cyan = InkVal; break; case COLOURPLATE_MAGENTA: ColDef.Magenta = InkVal; break; case COLOURPLATE_YELLOW: ColDef.Yellow = InkVal; break; default: // This handles normal and composite as well as mono, key and spot plates ColDef.Key = InkVal; break; } NewEndCol.SetCMYKValue(&ColDef); // Set the new start colour to the CMYK value NewEndCol.SetSeparable(FALSE); // And set it non-separable HaveNewEndCol = TRUE; // Flag the fact that it's changed } // Have we changed either colour? If so, create a new attribute and return it if (HaveNewStartCol || HaveNewEndCol) { if (EndCol == NULL) { // It was a flat fill, so create a new flat fill attribute NewAttr = new FlatFillAttribute(NewStartCol); } else { // Create a similar graduated fill attribute with the new colours CCRuntimeClass *pCCRuntimeClass = SourceAttr->GetRuntimeClass(); NewAttr = (ColourFillAttribute *) pCCRuntimeClass->CreateObject(); if (NewAttr != NULL) { // Copy the details of the source attribute NewAttr->SimpleCopy(SourceAttr); // Set up the attribute, replacing the colours we've decided to change if (HaveNewStartCol) NewAttr->SetStartColour(&NewStartCol); if (HaveNewEndCol) NewAttr->SetEndColour(&NewEndCol); } } return(NewAttr); } } // --- Check for a valid ColourPlate - if there is none, then no more effects will apply ERROR3IF(CurrentColContext == NULL, "No colour context when rendering?!"); ColourPlate *ColPlate = CurrentColContext->GetColourPlate(); if (ColPlate == NULL || ColPlate->IsDisabled()) return(NULL); // --- Check for overprint // Is this entire colour plate set to overprint? BOOL Overprint = CurrentColContext->GetColourPlate()->Overprints(); // If not, then is there a current "overprint fill" attribute in effect? if (!Overprint) Overprint = ((OverprintFillAttrValue *) CurrentAttrs[ATTR_OVERPRINTFILL].pAttr)->IsOverprintOn(); // If not, then is this a "black" CMYK colour/fill? // We check if "Always Overprint Black" is enabled, and if the fill is a flat "black" fill, or // a grad fill between two "black" colours - but the checks are in a special order to try to // make the code as efficient as possible. if (!Overprint && StartCol->GetColourModel() == COLOURMODEL_CMYK && !StartCol->IsTransparent()) { // How about the end colour? If it's a flat fill (no end col), or the end col is also CMYK, we continue if ( EndCol == NULL || (EndCol->GetColourModel() == COLOURMODEL_CMYK && !EndCol->IsTransparent()) ) { // Both colours are potentially "black" - is the "always overprint black objects" flag enabled? if (RenderView->GetPrintControl() != NULL) { TypesetInfo *TPInfo = RenderView->GetPrintControl()->GetTypesetInfo(); if (TPInfo != NULL && TPInfo->AlwaysOverprintBlack()) { // It is enabled, so check if this is a CMYK colour with more than 95% Key in it. ColourCMYK ColDef; StartCol->GetSourceColour((ColourGeneric *) &ColDef); if (ColDef.Key.MakeDouble() > 0.95) // It is "black", so we'll overprint it { if (EndCol == NULL) Overprint = TRUE; // Flat "black" fill, so overprint it else { // The start colour is "black", but is the End colour "black" too? EndCol->GetSourceColour((ColourGeneric *) &ColDef); if (ColDef.Key.MakeDouble() > 0.95) // Both cols are "black" so we'll overprint Overprint = TRUE; } } } } } } if (Overprint) { ERROR3IF(CurrentColContext->GetColourModel() != COLOURMODEL_RGBT, "Rendering ColourContext is not RGB. Bummer"); // If overprint is on, then check if the colour is visible on this plate (i.e. is it white?) PColourRGBT ColDef; // Check the start colour. If it's white, we'll set it to no-colour (note: the default is to be // no-colour, so we only have to flag the fact that we want to change it here) BOOL UseTransStart = FALSE; if (!StartCol->IsTransparent() && StartCol->IsSeparable()) { CurrentColContext->ConvertColour(StartCol, (ColourPacked *) &ColDef); UseTransStart = (ColDef.Red > 254 && ColDef.Green > 254 && ColDef.Blue > 254); } // Check the end colour - same as the start col, except that it may be NULL if it's a flat fill BOOL UseTransEnd = FALSE; if (EndCol != NULL && !EndCol->IsTransparent() && EndCol->IsSeparable()) { CurrentColContext->ConvertColour(EndCol, (ColourPacked *) &ColDef); UseTransEnd = (ColDef.Red > 254 && ColDef.Green > 254 && ColDef.Blue > 254); } if (UseTransStart || UseTransEnd) // If we must change either end to transparent... { if (EndCol == NULL || // If it's a flat fill, or ((UseTransStart || StartCol->IsTransparent()) && // the start and end are both (UseTransEnd || EndCol->IsTransparent())) // no-colour, make a flat fill ) { // Make a flat fill // (NOTE: this convert-to-flat-fill is necessary for the no-colour to no-colour grad fills // that overprint can create, as they otherwise (helpfully) render as a black solid fill // rather than the expected no-fill, while a no-colour flat fill works properly) DocColour Trans(COLOUR_TRANS); NewAttr = new FlatFillAttribute((UseTransStart) ? Trans : *StartCol); return(NewAttr); } // NOTE: // We don't change the fill if it will remain graduated, because a grad fill from a colour // to no-colour will not make the fill go transparent for overprint, so we might as well // just leave it alone - i.e. the only case we care about is when the grad fill ends // up as ultimately a transparent-transparent fill after colour separation. } } // No special effects apply - tell the caller to use the original return(NULL); }

StrokeColourAttribute * RenderRegion::PrepareLineColour (  StrokeColourAttribute *  SourceAttr = NULL  )  [protected]

This function is used to allow 3 special attributes to function correctly. => Overprint line, Overprint fill, and Print on all plates. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 30/7/96 Parameters: SourceAttr  - NULL (to copy the current rendering line attribute), [INPUTS] or the attribute to be "prepared". Returns: NULL if the given attribute needs not be changed before it is stacked, or points to a new attribute which should be stacked in place of the given one. Note that it is up to the caller to delete the new attribute (so when stacking it, you should set the "Temp" flag) These attributes are specil in that they act as modifiers to the current stroke and fill attributes - they convert active colours into either no-colour, or a special greyscale value. This is achieved by the following 2 steps: (1) Whenever a colour attribute is stacked, it is possibly replaced by a copy which has been modified with respect to the current states of the 3 Imagesetting attributes. (2) Whenever an Imagesetting attribute is stacked, the current line and/or fill attributes are copied (if necessary) in order to "apply" the new attribute effects to the current rendering colours. This function takes the appropriate attribute and determines if it needs to be changed. If it does, a new, replacement, attribute is created and returned, which the caller should use in place of the See also: RenderRegion::SetFillGeometry; RenderRegion::SetLineColour Definition at line 1917 of file rndrgn.cpp. { // --- Make sure we've got a source attribute to play with if (SourceAttr == NULL) SourceAttr = (StrokeColourAttribute *) CurrentAttrs[ATTR_STROKECOLOUR].pAttr; if (SourceAttr == NULL) // No attribute to modify return(NULL); // --- Find the source line colour. If it's transparent or non-separable, we won't change it DocColour *SourceCol = SourceAttr->GetStartColour(); if (SourceCol == NULL || SourceCol->IsTransparent() || !SourceCol->IsSeparable()) return(NULL); // --- Check for the PrintOnAllPlates attribute if ( ((PrintOnAllPlatesAttrValue *) CurrentAttrs[ATTR_PRINTONALLPLATES].pAttr)->IsPrintOnAllPlatesOn() ) { // Get a global default CMYK colour context ColourContextGreyT *cc = (ColourContextGreyT *) ColourManager::GetColourContext(COLOURMODEL_GREYT); ERROR3IF(cc == NULL, "No default Greyscale colour context?!"); // The print on all plates attribute is set, so we convert this into a pre-separated // Key greyscale DocColour, overriding overprint etc. First get it as a greyscale: PColourGreyT GreyDef; cc->ConvertColour(SourceCol, (ColourPacked *) &GreyDef); // Then create a new CMYK colour with the grey-level in the Key component PColourCMYK ColDef; ColDef.Key = 255 - GreyDef.Intensity; ColDef.Cyan = ColDef.Magenta = ColDef.Yellow = 0; DocColour NewCol; // Place the SourceCol into a DocColour, and make NewCol.SetCMYKValue(&ColDef); // it non-colour-separable, so that it is dumped NewCol.SetSeparable(FALSE); // out to the rendering device as it stands // And create and return a new stroke colour attribute StrokeColourAttribute *NewAttr = new StrokeColourAttribute(NewCol); return(NewAttr); } // --- Check for a valid ColourPlate - if there is none, then no more effects will apply ERROR3IF(CurrentColContext == NULL, "No colour context when rendering?!"); ColourPlate *ColPlate = CurrentColContext->GetColourPlate(); // Is there an active colour plate? If not, no overprint effects will occur if (ColPlate == NULL || ColPlate->IsDisabled()) return(NULL); // --- Check for overprint // Is this entire colour plate set to overprint? BOOL Overprint = CurrentColContext->GetColourPlate()->Overprints(); // If not, then is there a current "overprint line" attribute in effect? if (!Overprint) Overprint = ((OverprintLineAttrValue *) CurrentAttrs[ATTR_OVERPRINTLINE].pAttr)->IsOverprintOn(); // If not, then is this a CMYK colour? if (!Overprint && SourceCol->GetColourModel() == COLOURMODEL_CMYK) { // It is CMYK - is the "always overprint black objects" flag enabled? if (RenderView->GetPrintControl() != NULL) { TypesetInfo *TPInfo = RenderView->GetPrintControl()->GetTypesetInfo(); if (TPInfo != NULL && TPInfo->AlwaysOverprintBlack()) { // It is enabled, so check if this is a CMYK colour with more than 95% Key in it. ColourCMYK ColDef; SourceCol->GetSourceColour((ColourGeneric *) &ColDef); if (ColDef.Key.MakeDouble() > 0.95) // It is "black", so we'll overprint it Overprint = TRUE; } } } if (Overprint) { ERROR3IF(CurrentColContext->GetColourModel() != COLOURMODEL_RGBT, "Rendering ColourContext is not RGB. Bummer"); // If overprint is on, then check if the colour is visible on this plate (i.e. is it white?) PColourRGBT ColDef; CurrentColContext->ConvertColour(SourceCol, (ColourPacked *) &ColDef); if (ColDef.Red > 254 && ColDef.Green > 254 && ColDef.Blue > 254) { DocColour NewCol(COLOUR_TRANS); // It shouldn't appear on this plate, so return no-colour StrokeColourAttribute *NewAttr = new StrokeColourAttribute(NewCol); return(NewAttr); } } // No special effects apply - tell the caller to use the original return(NULL); }

void RenderRegion::PushPathProcessor (  PathProcessor *  pProcessor  )

Adds a PathProcessor to the rendering PathProcessor stack. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 20/12/96 Parameters: pProcessor  - the processor to push onto the processor stack [INPUTS] THIS PROCESSOR IS NOW OWNED BY THE RENDER REGION and will be deleted when it is popped. Notes: The render region must be supplied a new PathProcessor every time you push one, because PathProcessors generally have an internal state, and this must be preserved when background rendering or multi-threading causes the same thing to be rendered "simultaneously". See also: PathProcessor; RenderRegion::PopPathProcessor Definition at line 5266 of file rndrgn.cpp. { ERROR3IF(pProcessor == NULL, "Illegal NULL param"); #if _DEBUG // BLOCK { // In debug builds, scan the entire PathProcessor stack, checking that this // processor is ot already in it. ERROR3IF(pProcessor->GetNextProcessor() != NULL, "PushPathProcessor - processor is already in a stack"); PathProcessor *pPP = PathProcessorStack; while (pPP != NULL) { // TRACEUSER( "Jason", _T(" ")); // More indent for each processor on the stack ERROR3IF(pPP == pProcessor, "PushPathProcessor - Processor pushed TWICE!"); pPP = pPP->GetNextProcessor(); } } // TRACEUSER( "Jason", _T(" >> PushPathProcessor %x\n"), pProcessor); #endif if (pProcessor != NULL) { pProcessor->SetNextProcessor(PathProcessorStack); // Make TOS the second PathProcessorStack = pProcessor; // And point TOS at new item } }

BOOL RenderRegion::RenderBits (  KernelBitmap *  pkBitmap, DocCoord *  pCoords, INT32  numcoords, BOOL  bForceNoTransp, Node *  pEffectsOwner )  [virtual]

To blit one bitmap defined by a DocRect into the current RenderRegion. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 01/07/2004 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the bitmap was rendered See also: GRenderRegion::StartCapture Definition at line 7701 of file rndrgn.cpp. { ERROR2IF(!(numcoords==2 || numcoords==3), FALSE, "Wrong number of coords passed to RenderBits"); if (pkBitmap->GetWidth()==0 || pkBitmap->GetHeight()==0) return FALSE; // TRACEUSER( "Phil", _T("RenderBits %x %d, %d, %d, %d, %d, %d\n"), lpBits, pCoords[0].x, pCoords[0].y, pCoords[1].x, pCoords[1].y, pCoords[2].x, pCoords[2].y); SaveContext(); // No lines on the rectangle SetLineColour(COLOUR_TRANS); SetLineWidth(0); BitmapFillAttribute *pBitmapAttr = new BitmapFillAttribute; pBitmapAttr->GetBitmapRef()->SetBitmap(pkBitmap); Path InkPath; if (numcoords==2) { // This code was for upright rectangles only... InkPath.Initialise(); InkPath.AddMoveTo(pCoords[0]); InkPath.AddLineTo(DocCoord(pCoords[1].x, pCoords[0].y)); InkPath.AddLineTo(pCoords[1]); InkPath.AddLineTo(DocCoord(pCoords[0].x, pCoords[1].y)); InkPath.AddLineTo(pCoords[0]); InkPath.CloseSubPath(); pBitmapAttr->StartPoint = pCoords[0]; pBitmapAttr->EndPoint = DocCoord(pCoords[1].x, pCoords[0].y); pBitmapAttr->EndPoint2 = DocCoord(pCoords[0].x, pCoords[1].y); } else { // This version of the same code uses the array of 3 coords describing a parallelogram InkPath.Initialise(); InkPath.AddMoveTo(pCoords[0]); InkPath.AddLineTo(pCoords[1]); InkPath.AddLineTo(DocCoord(pCoords[2].x+pCoords[1].x-pCoords[0].x, pCoords[2].y+pCoords[1].y-pCoords[0].y)); InkPath.AddLineTo(pCoords[2]); InkPath.AddLineTo(pCoords[0]); InkPath.CloseSubPath(); pBitmapAttr->StartPoint = pCoords[0]; pBitmapAttr->EndPoint = pCoords[1]; pBitmapAttr->EndPoint2 = pCoords[2]; } // Set bitmap attribute, and get the render region to throw it away when it's finished // with (hence the TRUE parameter). SetFillGeometry(pBitmapAttr, TRUE); SetSmoothingFlags(pBitmapAttr); // Set the mapping to have no repeat, otherwise we get artifacts at the edges when // anti-aliasing is enabled (see bug 1391). FillMappingLinearAttribute *pNoRepeatAttr = new FillMappingLinearAttribute; // Repeat value of '3' means 'repeat inverted' (there are no symbolic names for // these repeat values - shout at Will if you want some!). // pNoRepeatAttr->Repeat = 3; pNoRepeatAttr->Repeat = 0; // Set mapping attribute, and get the render region to throw it away when it's finished // with (hence the TRUE parameter). SetFillMapping(pNoRepeatAttr, TRUE); // Force a 0% mix transparency (the transparency is in the bitmap) FlatTranspFillAttribute NoFillTransp(TT_NoTranspType); StrokeTranspAttribute NoLineTransp(TT_NoTranspType); if (bForceNoTransp) { SetTranspFillGeometry(&NoFillTransp, FALSE); SetLineTransp(&NoLineTransp, FALSE); } if (pEffectsOwner && pEffectsOwner->IsBounded()) ((NodeRenderableBounded*)pEffectsOwner)->RenderEffectAttributes(this); // Draw the bitmap by rendering a bitmap filled path. InkPath.IsFilled = TRUE; DrawPath(&InkPath); SetSmoothingFlags(NULL); RestoreContext(); return TRUE; }

BOOL RenderRegion::RenderBits (  LPBITMAPINFO  lpBitmapInfo, LPBYTE  lpBits, DocCoord *  pCoords, INT32  numcoords, BOOL  bForceNoTransp = TRUE, Node *  pEffectsOwner = NULL )  [virtual]

To blit one bitmap defined by a DocRect into the current RenderRegion. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 01/07/2004 Parameters: -  [INPUTS] lpBitmapInfo  [OUTPUTS] lpBits rect Returns: TRUE if the bitmap was rendered See also: GRenderRegion::StartCapture Definition at line 7652 of file rndrgn.cpp. { ERROR2IF(!(numcoords==2 || numcoords==3), FALSE, "Wrong number of coords passed to RenderBits"); if (lpBitmapInfo->bmiHeader.biWidth==0 || lpBitmapInfo->bmiHeader.biHeight==0) return FALSE; // TRACEUSER( "Phil", _T("RenderBits %x %d, %d, %d, %d, %d, %d\n"), lpBits, pCoords[0].x, pCoords[0].y, pCoords[1].x, pCoords[1].y, pCoords[2].x, pCoords[2].y); CWxBitmap *pBitmap = new CWxBitmap(lpBitmapInfo, lpBits); KernelBitmap *pkBitmap = new KernelBitmap(pBitmap, TRUE); // Assume 8BPP bitmaps must be greyscale... if (pkBitmap->GetBPP()==8) { LPRGBQUAD pPalette = pkBitmap->GetPaletteForBitmap(); for ( INT32 i=0 ; i<0x100 ; i++ ) (UINT32&)pPalette[i] = i*0x010101 ; } RenderBits(pkBitmap, pCoords, numcoords, bForceNoTransp, pEffectsOwner); if (pBitmap) { pBitmap->BMBytes = ((CWxBitmap*)OILBitmap::Default)->BMBytes; } if (pkBitmap) { delete pkBitmap; pkBitmap = NULL; } return TRUE; }

BOOL RenderRegion::RenderBits (  LPBITMAPINFO  lpBitmapInfo, LPBYTE  lpBits, DocRect  rect, BOOL  bForceNoTransp = TRUE, Node *  pEffectsOwner = NULL )  [virtual]

To blit one bitmap defined by a DocRect into the current RenderRegion. ? Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 01/07/2004 Parameters: -  [INPUTS] lpBitmapInfo  [OUTPUTS] lpBits rect Returns: TRUE if the bitmap was rendered See also: GRenderRegion::StartCapture Definition at line 7629 of file rndrgn.cpp. { return RenderBits(lpBitmapInfo, lpBits, (DocCoord*)&rect, 2, bForceNoTransp, pEffectsOwner); }

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

Render a character, using the specified transform and current attributes in the render region. Author: Ed_Cornes (Xara Group Ltd) <camelotdev@xara.com> Date: 19/3/95 Parameters: ch  - unicode value of char [INPUTS] pMatrix - matrix specifying transforms to place char correctly in document Returns: FALSE if fails Reimplemented in AIEPSRenderRegion, CamelotEPSRenderRegion, NativeRenderRegion, PrintingMaskedRenderRegion, PrintPSRenderRegion, EPSRenderRegion, and OSRenderRegion. Definition at line 6033 of file rndrgn.cpp. { ERROR2IF(pMatrix==NULL,FALSE,"RenderRegion::RenderChar() - pMatrix==NULL"); // create the char's path Path* pCharPath=CreateCharPath(ch,pMatrix); if (pCharPath==NULL) return FALSE; // if at least one point, draw path using current attibutes in render region if (pCharPath->GetNumCoords()!=0) DrawPath(pCharPath); // clean up delete pCharPath; return TRUE; }

BOOL RenderRegion::RenderNode (  Node *  pNode, Node *  pRunToNode, RenderCallback *  pCallback )  [protected, virtual]

Wrap up the common stuff that's done to every node we render Render a single node and find out whether we should suspend rendering at this point Helper function for RenderTree. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 28/6/2004 Parameters: -  [INPUTS] TRUE  if RenderTree rendering can continue [OUTPUTS] FALSE if RenderTree rendering Definition at line 7235 of file rndrgn.cpp. { BOOL bSuspendRendering = FALSE; BOOL bRender = TRUE; // Give RenderCallback object a chance to pre-process the rendering... if (pCallback) bRender = pCallback->BeforeNode(this, pNode); // Allow the loop to run forward to the RunTo node without rendering objects if it's set up... if (pRunToNode) { if (pRunToNode==pNode) // If we are at the RunTo node pRunToNode = NULL; // Then clear the system and allow it to render normally else if (pNode->IsAnObject()) // Else if this node is an object bRender = FALSE; // Don't let it render anything yet... } // If we can render this node, go ahead and do it. if (bRender && pNode->IsRenderedAsInk() && pNode->IsRenderable()) { //TRACEUSER( "Phil", _T("RenderNode Node %x %s\n"), pNode, pNode->GetRuntimeClass()->m_lpszClassName); pNode->Render(this); // Render the node if (CurrentSubRenderState!=NULL) // If the node aborted rendering and set a subrender state bSuspendRendering = TRUE; // Then Stop rendering without moving on the node pointer } return bSuspendRendering; }

virtual BOOL RenderRegion::RenderPaperAsInk (   )  [inline, virtual]

Reimplemented in XPFRenderRegion. Definition at line 722 of file rndrgn.h. { return(FALSE); }

BOOL RenderRegion::RenderTree (  Node *  pRoot, BOOL  bTimeSlice = TRUE, BOOL  bClip = TRUE, RenderCallback *  pCallback = NULL )

To render a specified subtree in this RenderRegion. The dominating factor in this routine is that it renders the document with as little time overhead as possible. Obviously, this is mainly down to RenderRegions and the tree scanning routines working fast but we can do a bit to help. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 19/5/93 (16/06/2004) Parameters: pRoot  - pointer to root node [INPUTS] bTimeSlice - TRUE if rendering should be time-sliced (interruptible) bClip - TRUE if only those objects intersecting the clipping region should be rendered pCallback - Pointer to RenderCallback object to callback for each object or NULL TRUE  if rendering was interrupted (by reaching the end of a timeslice typically) [OUTPUTS] FALSE if rendering was completed Definition at line 6935 of file rndrgn.cpp. { // TRACEUSER( "Gerry", _T("In RenderTree CC = 0x%08x\n"), GetColourContext()->GetColourPlate()); Node* pNode = NULL; Node* pRunToNode = NULL; DocRect ClipRect; // BOOL HasRendered = FALSE; BOOL Continue = TRUE; // TEMP BODGE! DO NOT RELEASE! //bTimeSlice = FALSE; m_bRenderTreeTimeSlice = bTimeSlice; // CBitmapCache* pBitmapCache = Camelot.GetBitmapCache(); // double ScaledPixelSize = GetScaledPixelWidth(); // Record time when rendering started m_timeRenderTreeStartTime.Sample(); PORTNOTE("other","PerfCounter not used under Linux") #if defined(__WXMSW__) LARGE_INTEGER countStart; LARGE_INTEGER countEnd; INT64 countOrigTotal = m_countTotal; QueryPerformanceCounter(&countStart); #endif // Find where to pick up rendering from... // Have we started rendering ink? if (bTimeSlice && IsInkRenderStarted) pNode = GetRenderState(); if (!IsInkRenderStarted || pNode==NULL) { pNode = pRoot; SetRenderState(pRoot); if (CurrentSubRenderState != NULL) { // In the middle of rendering so lose this sub-context and set it to NULL delete CurrentSubRenderState; SetSubRenderState(NULL); } // We only want to do this once IsInkRenderStarted = TRUE; } #ifdef _DEBUG try { #endif // --------------------------------------------------- // This is the new rendering loop... // // The algorithm is basically this: // Do // Render A Subtree // While more to do // // In a bit more detail: // Do // Try to find deepest first child subtree of Node (pushing context onto stack, when going down) // Else Render Node and Try to move to Next // Else Render Parent and Move Next After Parent (pulling context off stack when coming up) // While more to do // Node* pNextNode = NULL; Node* pChildNode = NULL; do { // TRACEUSER( "Gerry", _T(" CC = 0x%08x\n"), GetColourContext()->GetColourPlate()); // if (GetColourContext()->GetColourPlate() == (ColourPlate*)0xfeeefeee) { __asm {INT32 3}; } // At this point pNode ALWAYS refers to a node/subtree that has NOT yet been rendered! // (Er, unless there's a SubRenderContext stored - in which case we must continue // to render the current node without entering its subtree.) // // ----------------------------------------------- // --- Test Subtree --- // // Check whether it's even worth bothering with this subtree... // (RenderSubtree does clip rect testing) // //TRACEUSER( "Phil", _T("RenderTree %x %s\n"), pNode, pNode->GetRuntimeClass()->m_lpszClassName); SubtreeRenderState state = SUBTREE_ROOTANDCHILDREN; // Assume normal depth-first behaviour SubtreeRenderState callbackstate = SUBTREE_NORENDER; if (CurrentSubRenderState) // If we're partway through a node state = CurrentSubRenderState->renderstate; // Continue rendering that node (usually SUBTREE_ROOTONLY) else if (pCallback && pCallback->BeforeSubtree(this, pNode, &pNextNode, bClip, &callbackstate)) state = callbackstate; else { if (pNode->IsRenderable()) // If this node is at all renderable state = pNode->RenderSubtree(this, &pNextNode, bClip); // Allow node to decide where to go else state = SUBTREE_NORENDER; // Else don't render anything } // ----------------------------------------------- // if (GetColourContext()->GetColourPlate() == (ColourPlate*)0xfeeefeee) { __asm {INT32 3}; } if (state==SUBTREE_JUMPTO) { // Node wants rendering to jump somewhere else // This isn't really sorted yet - something needs to be done about context // stacking... if (pNextNode!=NULL) { pNode = pNextNode; continue; } // (If pNextNode was NULL then we fall through to finding the next node...) } if (state==SUBTREE_RUNTO) { // Node wants rendering to run forward to somewhere else without actually // rendering any object but maintaining the attribute stack correctly if (pNextNode!=NULL) { pRunToNode = pNextNode; // NOTE! Since we don't preserve pRunToNode outside this routine // it must not abort due to timeslicing while pRunToNode!=NULL } // (If pNextNode was NULL then we fall through to finding the next node...) } if (state==SUBTREE_ROOTANDCHILDREN || state==SUBTREE_RUNTO) { // Depth-first, so check for children first... // Go down the tree from the current node, looking for child lists to render pChildNode = pNode->FindFirstChild(); if (pChildNode) { // Then scan the child list SaveContext(); // <<<< Going down //TRACEUSER( "Phil", _T("SaveContext scope = %x\n"), pNode); // Set this child as the next subtree to consider... pNode = pChildNode; continue; } } // Finished trying to deal with subtree so render subtree root node if (state==SUBTREE_ROOTONLY || state==SUBTREE_ROOTANDCHILDREN || state==SUBTREE_RUNTO) { // No children or root only so render this node directly... BOOL bSuspend = RenderNode(pNode, pRunToNode, pCallback); // if (GetColourContext()->GetColourPlate() == (ColourPlate*)0xfeeefeee) { __asm {INT32 3}; } if (bSuspend) break; } // Balance the call to RenderSubtree if (!(pCallback && pCallback->AfterSubtree(this, pNode))) pNode->RenderAfterSubtree(this); // ----------------------------------------------- // --- Move on to next subtree --- // // SUBTREE_NORENDER // pNextNode = pNode->FindNext(); // See if we got here because we set up a subrender context especially to do so // If so, get rid of this context so that rendering can proceed normally if (CurrentSubRenderState && CurrentSubRenderState->IsKindOf(CC_RUNTIME_CLASS(SubTreeRenderContext))) { delete CurrentSubRenderState; CurrentSubRenderState = NULL; } // ----------------------------------------------- // --- Render Subtree Parents --- // // While no next sibling found, look for parent's next sibling... if (pNextNode==NULL && pNode!=pRoot && Continue) { do { pNode = pNode->FindParent(); if (pNode) { // Render the parent node now that its children have all been rendered... BOOL bSuspend = RenderNode(pNode, pRunToNode, pCallback); // if (GetColourContext()->GetColourPlate() == (ColourPlate*)0xfeeefeee) { __asm {INT32 3}; } if (bSuspend) break; //TRACEUSER( "Phil", _T("RestoreContext scope = %x\n"), pNode); RestoreContext(); // >>>> Coming up // Slightly unpleasant to have yet another call to the Node // but for things to balance correctly, it needs to be given a chance // to do stuff /outside/ the attribute scope created by the calls // to SaveContext and RestoreContext... // // Balance the call to RenderSubtree if (!(pCallback && pCallback->AfterSubtree(this, pNode))) pNode->RenderAfterSubtree(this); pNextNode = pNode->FindNext(); PORTNOTE("other","PerfCounter not used under Linux") #if defined(__WXMSW__) // I'm not really happy about doing this here but profiling will tell us // whether it's really a problem... QueryPerformanceCounter(&countEnd); m_countTotal = countOrigTotal + countEnd.QuadPart - countStart.QuadPart; #endif // See if we should stop coming up out of this subtree because we've run out of time Continue = RenderTreeCanContinue(); } } while (pNextNode==NULL && pNode!=pRoot && Continue); if (!Continue) { // We have run out of time while following parent links // so we need to set things up so that when rendering // is restarted, it doesn't go DOWN into the subtree again!!! // We do this by setting up a subrender state so that the logic above // will drop through the SUBTREE_NORENDER path // // Note: Leave the current node pointer alone // SubTreeRenderContext* pReturnHereContext = new SubTreeRenderContext(); SetSubRenderState(pReturnHereContext); break; } } // We should move the current node pointer on if we know that // the if (pNextNode && pNode!=pRoot) pNode = pNextNode; PORTNOTE("other","PerfCounter not used under Linux") #if defined(__WXMSW__) // I'm not really happy about doing this here but profiling will tell us // whether it's really a problem... QueryPerformanceCounter(&countEnd); m_countTotal = countOrigTotal + countEnd.QuadPart - countStart.QuadPart; #endif // See if we are time slicing and we still have more time available Continue = RenderTreeCanContinue(); } while (pNode && pNode!=pRoot && (Continue || pRunToNode!=NULL)); // // Here endeth the new rendering loop // --------------------------------------------------- #ifdef _DEBUG } catch (...) { TRACEUSER( "Phil", _T("Exception during rendering...\n")); } #endif if (pNode==pRoot) pNode = NULL; // Reset state to new posn in tree. SetRenderState(pNode); ENSURE(pRunToNode==NULL, "Expected pRunToNode to be NULL at end of RenderTree\n"); //TRACEUSER( "Phil", _T("RenderTree exiting %x %s\n", pNode, pNode?pNode->GetRuntimeClass()->m_lpszClassName:"NULL")); // if (pbHaveRendered) // *pbHaveRendered = *pbHaveRendered || HasRendered; return Continue; }

BOOL RenderRegion::RenderTreeCanContinue (   )

Decide whether we can continue to render in RenderTree. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 28/6/2004 Parameters: -  [INPUTS] TRUE  if RenderTree rendering can continue [OUTPUTS] FALSE if RenderTree rendering should stop Definition at line 7283 of file rndrgn.cpp. { // If we are currently capturing offscreen stuff then we prefer to continue rendering // because the overhead of composing offscreen bitmaps together is so great // so lengthen the timeslice to make this happen less often INT32 t = Timeslice; if (GetCaptureDepth()>1) t = t*2; // if m_bRenderTreeTimeSlice == FALSE // or the timeslice hasn't elapsed yet then we can continue return !m_bRenderTreeTimeSlice || !m_timeRenderTreeStartTime.Elapsed(t); }

BOOL RenderRegion::RenderTreeNoCache (  Node *  pRoot  )

Renders a subtree with cacheing disabled. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 20/07/2005 Parameters: pNode  - pointer to root node of subtree to render [INPUTS] Returns: FALSE if the render failed TRUE if it worked Definition at line 7310 of file rndrgn.cpp. { if (pRoot == NULL || this == NULL) return FALSE; // pNode may not be in the document tree! // So all bets are off regarding cacheing. // Therefore we disable cacheing during this render. ScopedFlagSetter fsBitmapCacheing(NodeRenderableBounded::bEnableCacheing, FALSE); SaveContext(); RenderTree(pRoot, FALSE, FALSE); RestoreContext(); return TRUE; }

BOOL RenderRegion::ResetColourContext (   )

Definition at line 1008 of file rndrgn.cpp. { // Find this documents default colour context for the screen (RGB) if (RenderView != NULL) { // Find a colour context for the View we're rendering. This will automatically find // a suitable local, document, or global context for us to use CurrentColContext = RenderView->GetColourContext(COLOURMODEL_RGBT); if (CurrentColContext == NULL) // should never be a problem! { DiagnosticFn( _T("InitDevice:"), _T("No colour context") ); ERROR(_R(IDT_INTERNAL_ERROR), FALSE); } } else { ERROR3("View is NULL in RenderRegion::InitDevice()"); return FALSE; } return(TRUE); }

void RenderRegion::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 in GRenderRegion. Definition at line 6227 of file rndrgn.cpp. { // Note from Will. We really need to be re-rendering the Paper onto // the screen, if we have rendered something in this Region, but we // don't seem to be able to do this during a Paint message, as it // appears you can only render into the Area specified as invalid by // the message. I tried clearing the clipping region etc, but this // made no difference. There must be some way to do it though. // A solution would be to flag that the paper needs re-rendering, // and do it on the next 'StartRender' call. Capture* pCapture = GetTopCapture(); while (pCapture) { ENSURE(!pCapture->OwnsBitmap(), "Capture unexpectedly owns bitmap in RenderRegion::ResetRegion"); m_CaptureStack.Pop(); //TRACEUSER( "Phil", _T("ResetRegion Pop/Delete Capture\n")); if (pCapture->IsMaster()) { SetRenderToCapture(pCapture, FALSE, FALSE); } else { pCapture->FreeDIB(); } delete pCapture; pCapture = GetTopCapture(); } // Set the new clipping rect SetClipRect(NewClipRect); // We set this flag to get the render region to blit the paper on the first // time past after it is reset. // Unfortunately this causes large amounts of unecessary blitting when scrolling // an empty document around with the push tool // Arrghh. No we don't. We clear the IsPaperRendered flag so that the paper is // rendered into the region on the next render timeslice if the region requires it // This should eliminate all unecessary blitting // Gerry Iles 13/01/2006 // NeedsOSPaper = FALSE; IsPaperRendered = FALSE; // No Banding please IsRegionBanded = FALSE; IsWaitingForRAM = FALSE; IsLastBand = TRUE; CanRegionBeMerged = TRUE; // Set the region for this render region to match the clip rect RegionRect = CurrentClipRect; // Reset the rendering state ResetRender(); // Make sure that that we re-init the device RenderFlags.ValidDevice = FALSE; }

void RenderRegion::ResetRender (   )  [virtual]

Reset the rendering state of this region. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 1/12/2004 Definition at line 6300 of file rndrgn.cpp. { IsPaperRendered = FALSE; IsInkRenderStarted = FALSE; IsBeingReset = TRUE; { // Copy a blank stack over our old one, in order to wipe it clean. RenderStack EmptyStack; if (!TheStack.Copy(&EmptyStack, this)) { // We failed to copy the empty attribute stack ERROR3("Empty Attribute Stack could not be copied"); } } IsBeingReset = FALSE; // And clean up any errant PathProcessors. (If a node, e.g. a Mould, added a PathProcessor // and we aborted rendering halfway through its subtree, nobody calls the mould back // to de-initialise, so the PathProcessor would be left lying around) while (PathProcessorStack != NULL) PopPathProcessor(); // Now setup the render state CurrentRenderState = NULL; SubRenderStateLocked = FALSE; if (CurrentSubRenderState!=NULL) { // get rid of any sub-render context we may have. delete CurrentSubRenderState; CurrentSubRenderState = NULL; } }

void RenderRegion::ResizeRegion (  DocRect &  NewClipRect  )  [virtual]

Called when a Region is changed in size (eg. clipped to the client area). Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 4/7/95 Reimplemented in GRenderDIB. Definition at line 6208 of file rndrgn.cpp. { // Just reset the region by default ResetRegion(NewClipRect); }

void RenderRegion::RestoreAttribute (  UINT32  Index, AttributeValue *  pAttr, BOOL  Temp )

Restore the given attribute to the current attribute array. This is called when the rendering context stack is popped - the current attribute is ousted (and deleted if it is a temporary object), and the given one is installed in its place. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 12/04/94 Parameters: Index  - Unique attribute ID (See AttributeManager::RegisterDefaultAttribute). [INPUTS] pAttr - the new attribute to use as the current one. Temp - TRUE if pAttr points to a temporary object, FALSE if not. See also: RenderRegion::SaveAttribute Definition at line 1756 of file rndrgn.cpp. { #ifdef DEBUG if(m_TraceOutContextLevels) { TRACE( _T("Am Resetting %d "), IsBeingReset); TRACE( _T("...Restoring Level %d Attribute 0x%x with 0x%x"),m_CurrentContextLevel,CurrentAttrs[Index].pAttr, pAttr); } // Make sure the current Attr is a valid pointer. if(!IsBeingReset) CC_ASSERT_VALID((CurrentAttrs[Index].pAttr)); if(m_TraceOutContextLevels) { TRACE( _T(" Attribute %s\n"), (LPCTSTR)pAttr->GetRuntimeClass()->m_lpszClassName); } #endif // Mark Howitt Friday 13th Oct 2000 // I`ve placed this new check in here in order to stop a problem that causes camelot to crash // when calling the GoingOutOfScope function. The problem is that the attribute that the stack // is pointing to has been deleted and is pointing at deleted memory! // This only happens in the case of when an Op is called when the render loop is deep inside // the tree and the Op affects an attribute above the current context which when restored is // corrupt!!! The way we are now dealing with this is to basically not call the GoingOutOfScope // function but just make a call to the PopPathProcessor function. This makes sure that we // relinquish any memory. // We`re using the IsBeingReset variable as it only goes TRUE when the region is about to die! // It`s also an Ilan variable used for the OffScreenRenderRegions! if(!IsBeingReset) CurrentAttrs[Index].pAttr->GoingOutOfScope(this); else PopPathProcessor(); // If the current attribute is a temporary one, then delete it as we're about to stop // using it. if (CurrentAttrs[Index].Temp) delete CurrentAttrs[Index].pAttr; // Install the new attribute. CurrentAttrs[Index].pAttr = pAttr; CurrentAttrs[Index].Temp = Temp; }

void RenderRegion::RestoreClipRegion (  ClipRegionAttribute *  pAttr, BOOL  Temp )  [virtual]

Restore this render-region's current clipping region, using the attribute supplied. See also: ClipRegionAttribute::Restore(), RenderRegion::SetClipRegion(). Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 11 April 2000 Parameters: pAttr  the new ClipRegionAttribute. [INPUTS] Temp whether the new attribute is temporary, and should therefore be deleted when it is finished with. Reimplemented in AIEPSRenderRegion, EPSRenderRegion, and GRenderRegion. Definition at line 5021 of file rndrgn.cpp. { RestoreAttribute(ATTR_CLIPREGION, (AttributeValue *) pAttr, Temp); }

void RenderRegion::RestoreContext (   )

Definition at line 1103 of file rndrgn.cpp. { TheStack.RestoreContext(this); #ifdef _DEBUG m_CurrentContextLevel--; #endif }

void RenderRegion::RestoreDashPattern (  DashPatternAttribute *  pAttr, BOOL  Temp )  [virtual]

Get rid of the current dash pattern, and restore the specified one. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/94 Parameters: pAttr  - the object specifying the dash pattern to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::SetDashPattern Definition at line 3416 of file rndrgn.cpp. { // Set up the new attribute RestoreAttribute(ATTR_DASHPATTERN, pAttr, Temp); // The line attributes need to be reset before drawing anything. SetLineAttributes(CHANGEATTR_DASHPATTERN); }

void RenderRegion::RestoreDrawingMode (  DrawingModeAttribute *  pAttr, BOOL  Temp )  [virtual]

Get rid of the current drawing mode, and restore the specified drawing mode. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 12/04/94 Parameters: pAttr  - the object specifying the drawing mode to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::SetDrawingMode Definition at line 4133 of file rndrgn.cpp. { // Set up the new attribute RestoreAttribute(DrawingModeAttribute::ID, pAttr, Temp); DrawingMode = pAttr->DrawingMode; // The drawing mode needs to be set // MarkH - 12/11/99 // First check to see if we`re dealing with a derived class or using the base class as // the base class ( RenderRegion ) 'SetOSDrawingMode()' is a pure virtual which will // ultimately crash in a big way if it is called!!!! if(!IS_A(this,RenderRegion)) { SetOSDrawingMode(); } }

void RenderRegion::RestoreEndArrow (  EndArrowAttribute *  pAttr, BOOL  Temp )  [virtual]

Get rid of the current EndArrow, and restore the specified one. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 5/4/95 Parameters: pAttr  - the object specifying the dash pattern to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::SetEndArrow Definition at line 3900 of file rndrgn.cpp. { // Set up the new attribute RestoreAttribute(ATTR_ENDARROW, pAttr, Temp); // The line attributes need to be reset before drawing anything. SetLineAttributes(CHANGEATTR_ENDARROW); }

void RenderRegion::RestoreFillEffect (  FillEffectAttribute *  pAttr, BOOL  Temp )  [virtual]

Get rid of the current fill type, and restore the specified fill type. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 12/04/94 Parameters: pAttr  - the object specifying the fill type to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::SetFillType; RenderRegion::SetFillColour Definition at line 3031 of file rndrgn.cpp. { // Set up the new attribute RestoreAttribute(ATTR_FILLEFFECT, pAttr, Temp); // The fill attributes need to be reset before drawing anything. SetFillAttributes(CHANGEATTR_EFFECT); }

void RenderRegion::RestoreFillGeometry (  ColourFillAttribute *  pAttr, BOOL  Temp )  [virtual]

Get rid of the current fill type, and restore the specified fill type. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 12/04/94 Parameters: pAttr  - the object specifying the fill type to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::SetFillType; RenderRegion::SetFillColour Definition at line 2931 of file rndrgn.cpp. { // Set up the new attribute RestoreAttribute(ATTR_FILLGEOMETRY, pAttr, Temp); // The fill attributes need to be reset before drawing anything. SetFillAttributes(CHANGEATTR_GEOMETRY); }

void RenderRegion::RestoreFillMapping (  FillMappingAttribute *  pAttr, BOOL  Temp )  [virtual]

Get rid of the current fill type, and restore the specified fill type. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 12/04/94 Parameters: pAttr  - the object specifying the fill type to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::SetFillType; RenderRegion::SetFillColour Definition at line 2981 of file rndrgn.cpp. { // Set up the new attribute RestoreAttribute(ATTR_FILLMAPPING, pAttr, Temp); // The fill attributes need to be reset before drawing anything. SetFillAttributes(CHANGEATTR_MAPPING); }

void RenderRegion::RestoreFillOverprint (  OverprintFillAttrValue *  NewAttr, BOOL  Temp )  [virtual]

Restore the previous Fill Overprint state, popping the previous state from the rendering stack. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 30/7/96 Parameters: NewAttr  - The new OverPrintLineAttrValue you want to set current [INPUTS] Temp - TRUE if this is a temporary object which the render region should delete when finished with it; FALSE if someone else will delete it (i.e. it's in the document tree) See also: RenderRegion::SetOverprintLine Definition at line 2440 of file rndrgn.cpp. { RestoreAttribute(ATTR_OVERPRINTFILL, NewAttr, Temp); }

void RenderRegion::RestoreJoinType (  JoinTypeAttribute *  pAttr, BOOL  Temp )  [virtual]

Get rid of the current JoinType, and restore the specified one. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 5/4/95 Parameters: pAttr  - the object specifying the dash pattern to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::SetJoinType Definition at line 3564 of file rndrgn.cpp. { // Set up the new attribute RestoreAttribute(ATTR_JOINTYPE, pAttr, Temp); // The line attributes need to be reset before drawing anything. SetLineAttributes(CHANGEATTR_JOINTYPE); }

void RenderRegion::RestoreLineColour (  StrokeColourAttribute *  pAttr, BOOL  Temp )  [virtual]

Get rid of the current line colour, and restore the specified line colour value. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 12/04/94 Parameters: pAttr  - the object specifying the colour to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::SetLineColour Definition at line 2620 of file rndrgn.cpp. { // Restore the line colour attribute RestoreAttribute(ATTR_STROKECOLOUR, pAttr, Temp); // The line attributes need to be reset before drawing anything. SetLineAttributes(CHANGEATTR_STROKECOL); }

void RenderRegion::RestoreLineOverprint (  OverprintLineAttrValue *  NewAttr, BOOL  Temp )  [virtual]

Restore the previous Line Overprint state, popping the previous state from the rendering stack. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 30/7/96 Parameters: NewAttr  - The new OverPrintLineAttrValue you want to set current [INPUTS] Temp - TRUE if this is a temporary object which the render region should delete when finished with it; FALSE if someone else will delete it (i.e. it's in the document tree) See also: RenderRegion::SetOverprintLine Definition at line 2382 of file rndrgn.cpp. { RestoreAttribute(ATTR_OVERPRINTLINE, NewAttr, Temp); }

void RenderRegion::RestoreLineTransp (  StrokeTranspAttribute *  pAttr, BOOL  Temp )  [virtual]

Get rid of the current line colour, and restore the specified line colour value. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 12/04/94 Parameters: pAttr  - the object specifying the colour to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::SetLineColour Definition at line 2704 of file rndrgn.cpp. { // Restore the line colour attribute RestoreAttribute(ATTR_STROKETRANSP, pAttr, Temp); // The line attributes need to be reset before drawing anything. SetLineAttributes(CHANGEATTR_STROKETRANSP); }

void RenderRegion::RestoreLineWidth (  LineWidthAttribute *  pAttr, BOOL  Temp )  [virtual]

Get rid of the current line width, and restore the specified line width. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 12/04/94 Parameters: pAttr  - the object specifying the line width to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::SetLineWidth Definition at line 3251 of file rndrgn.cpp. { // Set up the new attribute RestoreAttribute(ATTR_LINEWIDTH, pAttr, Temp); // The line attributes need to be reset before drawing anything. SetLineAttributes(CHANGEATTR_LINEWIDTH); // NB We need to invalidate the dash pattern too as this depends // on line width (doesn't seem to matter normally, but PostScript // gets dash patterns wrong otherwise. SetLineAttributes(CHANGEATTR_DASHPATTERN); }

void RenderRegion::RestoreMitreLimit (  MitreLimitAttribute *  pAttr, BOOL  Temp )  [virtual]

Get rid of the current MitreLimit, and restore the specified one. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 5/4/95 Parameters: pAttr  - the object specifying the dash pattern to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::SetMitreLimit Definition at line 3974 of file rndrgn.cpp. { // Set up the new attribute RestoreAttribute(ATTR_MITRELIMIT, pAttr, Temp); // The line attributes need to be reset before drawing anything. SetLineAttributes(CHANGEATTR_MITRELIMIT); }

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

Reimplemented in MaskedRenderRegion, PrintingMaskedRenderRegion, GRenderBrush, and GRenderRegion. Definition at line 4958 of file rndrgn.cpp. { // End this capture: // Don't render captured bitmap back into render region - owner will do that after processing // Release bitmap here - if this region is being reset if (!IsBeingReset) { LPBITMAPINFO lpCapturedBitmapInfo = NULL; LPBYTE lpCapturedBits = NULL; DocRect CaptureRect = CurrentOffscreenAttr->GetOffscreenBoundingRect(); // Initialise to size of feathered object // so that StopCapture can return sensible 24BPP bitmap if needed Capture* pTopCapture = GetTopCapture(); ENSURE(pTopCapture && pTopCapture->GetOwner()==CurrentOffscreenAttr, "RestoreOffscreen attr is not owned by top capture\n"); if (pTopCapture && pTopCapture->GetOwner()==CurrentOffscreenAttr) { StopCapture(CurrentOffscreenAttr, FALSE, IsBeingReset, &lpCapturedBitmapInfo, &lpCapturedBits, &CaptureRect); } // Normal restore in process of traversing the tree // So tell the offscreen attribute to handle the captured bitmap as it sees fit... CurrentOffscreenAttr->OffscreenRenderingCompleted(this, lpCapturedBitmapInfo, lpCapturedBits, CaptureRect); } // RenderRegion::RestoreOffscreen(pAttr); CurrentOffscreenAttr = pAttr; }

void RenderRegion::RestorePrintOnAllPlates (  PrintOnAllPlatesAttrValue *  NewAttr, BOOL  Temp )  [virtual]

Restore the previous print-on-all-plates state, popping the previous state from the rendering stack. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 30/7/96 Parameters: NewAttr  - The new OverPrintLineAttrValue you want to set current [INPUTS] Temp - TRUE if this is a temporary object which the render region should delete when finished with it; FALSE if someone else will delete it (i.e. it's in the document tree) See also: RenderRegion::SetOverprintLine Definition at line 2503 of file rndrgn.cpp. { RestoreAttribute(ATTR_PRINTONALLPLATES, NewAttr, Temp); }

void RenderRegion::RestoreQuality (  QualityAttribute *  pAttr, BOOL  Temp )  [virtual]

Get rid of the current quality level, and restore the specified quality level. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 12/04/94 Parameters: pAttr  - the object specifying the quality level to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::SetQuality Definition at line 3633 of file rndrgn.cpp. { // Set up the new attribute RestoreAttribute(ATTR_QUALITY, pAttr, Temp); RRQuality = pAttr->QualityValue; // The render region's rendering objects need to be reset before drawing anything. SetQualityLevel(); }

void RenderRegion::RestoreStartArrow (  StartArrowAttribute *  pAttr, BOOL  Temp )  [virtual]

Get rid of the current StartArrow, and restore the specified one. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 5/4/95 Parameters: pAttr  - the object specifying the dash pattern to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::SetStartArrow Definition at line 3799 of file rndrgn.cpp. { // Set up the new attribute RestoreAttribute(ATTR_STARTARROW, pAttr, Temp); // The line attributes need to be reset before drawing anything. SetLineAttributes(CHANGEATTR_STARTARROW); }

void RenderRegion::RestoreStartCap (  StartCapAttribute *  pAttr, BOOL  Temp )  [virtual]

Get rid of the current start cap, and restore the specified one. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 5/4/95 Parameters: pAttr  - the object specifying the dash pattern to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::SetStartCap Definition at line 3490 of file rndrgn.cpp. { // Set up the new attribute RestoreAttribute(ATTR_STARTCAP, pAttr, Temp); // The line attributes need to be reset before drawing anything. SetLineAttributes(CHANGEATTR_LINECAP); }

void RenderRegion::RestoreStrokeType (  StrokeTypeAttrValue *  pAttr, BOOL  Temp )  [virtual]

Get rid of the current stroke type, and restore the specified stroke type. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 7/1/97 Parameters: pAttr  - the object specifying the new stroke type [INPUTS] Temp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::SetStrokeType Definition at line 2757 of file rndrgn.cpp. { RestoreAttribute(ATTR_STROKETYPE, pAttr, Temp); }

void RenderRegion::RestoreTranspFillGeometry (  TranspFillAttribute *  pAttr, BOOL  Temp )  [virtual]

Get rid of the current fill type, and restore the specified fill type. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 23/8/94 Parameters: pAttr  - the object specifying the fill type to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::SetFillType; RenderRegion::SetFillColour Definition at line 3125 of file rndrgn.cpp. { // Set up the new attribute RestoreAttribute(ATTR_TRANSPFILLGEOMETRY, pAttr, Temp); // The fill attributes need to be reset before drawing anything. SetFillAttributes(CHANGEATTR_TRANSP_GEOMETRY); }

void RenderRegion::RestoreTranspFillMapping (  TranspFillMappingAttribute *  pAttr, BOOL  Temp )  [virtual]

Get rid of the current fill type, and restore the specified fill type. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 23/8/94 Parameters: pAttr  - the object specifying the fill type to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::SetFillType; RenderRegion::SetFillColour Definition at line 3173 of file rndrgn.cpp. { // Set up the new attribute RestoreAttribute(ATTR_TRANSPFILLMAPPING, pAttr, Temp); // The fill attributes need to be reset before drawing anything. SetFillAttributes(CHANGEATTR_TRANSP_MAPPING); }

void RenderRegion::RestoreTxtAspectRatio (  TxtAspectRatioAttribute *  pAttr, BOOL  Temp )

Get rid of the current Text Aspect Ratio, and restore the specified Aspect Ratio value. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/03/95 Parameters: pAttr  - the object specifying the colour to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::SetTxtAspectRatio Definition at line 4431 of file rndrgn.cpp. { // Restore the Text Aspect Ratio attribute RestoreAttribute(ATTR_TXTASPECTRATIO, (AttributeValue*)pAttr, Temp); SetTextAttributes(CHANGEATTR_ASPECT); }

void RenderRegion::RestoreTxtBaseLine (  TxtBaseLineAttribute *  pAttr, BOOL  Temp )

Get rid of the current Text BaseLine, and restore the specified BaseLine value. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/03/95 Parameters: pAttr  - the object specifying the colour to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::SetTxtBaseLine Definition at line 4618 of file rndrgn.cpp. { // Restore the Text BaseLine attribute RestoreAttribute(ATTR_TXTBASELINE, (AttributeValue*)pAttr, Temp); SetTextAttributes(CHANGEATTR_BASELINE); }

void RenderRegion::RestoreTxtBold (  TxtBoldAttribute *  pAttr, BOOL  Temp )

Get rid of the current Text Boldness, and restore the specified Boldness value. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/03/95 Parameters: pAttr  - the object specifying the colour to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::SetTxtBold Definition at line 4242 of file rndrgn.cpp. { // Restore the Text Bold attribute RestoreAttribute(ATTR_TXTBOLD, (AttributeValue*)pAttr, Temp); SetTextAttributes(CHANGEATTR_BOLD); }

void RenderRegion::RestoreTxtFirstIndent (  TxtFirstIndentAttribute *  , BOOL  )

Definition at line 4724 of file rndrgn.cpp. { // Restore the attribute RestoreAttribute(ATTR_TXTFIRSTINDENT, (AttributeValue*)pAttr, Temp); SetTextAttributes(CHANGEATTR_FIRSTINDENT); }

void RenderRegion::RestoreTxtFontSize (  TxtFontSizeAttribute *  pAttr, BOOL  Temp )

Get rid of the current font size, and restore the specified font size. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 13/03/95 Parameters: pAttr  - the object specifying the font size [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::SetTxtFontSize Definition at line 4337 of file rndrgn.cpp. { // Restore the Text Italic attribute RestoreAttribute(ATTR_TXTFONTSIZE, (AttributeValue*)pAttr, Temp); SetTextAttributes(CHANGEATTR_SIZE); }

void RenderRegion::RestoreTxtFontTypeface (  TxtFontTypefaceAttribute *  pAttr, BOOL  Temp )

Get rid of the current Text Font Typeface, and restore the specified Typeface value. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/03/95 Parameters: pAttr  - the object specifying the colour to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::SetTxtFontTypeface Definition at line 4194 of file rndrgn.cpp. { // BOOL NewAttr = pAttr->HTypeface != RR_TXTFONTTYPEFACE(); // Restore the Font Typeface attribute RestoreAttribute(ATTR_TXTFONTTYPEFACE, (AttributeValue*)pAttr, Temp); // if(NewAttr) SetTextAttributes(CHANGEATTR_FONT); }

void RenderRegion::RestoreTxtItalic (  TxtItalicAttribute *  pAttr, BOOL  Temp )

Get rid of the current Text Italicness, and restore the specified Italicness value. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/03/95 Parameters: pAttr  - the object specifying the colour to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::SetTxtItalic Definition at line 4289 of file rndrgn.cpp. { // Restore the Text Italic attribute RestoreAttribute(ATTR_TXTITALIC, (AttributeValue*)pAttr, Temp); SetTextAttributes(CHANGEATTR_ITALIC); }

void RenderRegion::RestoreTxtJustification (  TxtJustificationAttribute *  pAttr, BOOL  Temp )

Get rid of the current Text Justification, and restore the specified Justification value. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/03/95 Parameters: pAttr  - the object specifying the colour to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::SetTxtJustification Definition at line 4477 of file rndrgn.cpp. { // Restore the Text Justification attribute RestoreAttribute(ATTR_TXTJUSTIFICATION, (AttributeValue*)pAttr, Temp); SetTextAttributes(CHANGEATTR_JUSTIFY); }

void RenderRegion::RestoreTxtLeftMargin (  TxtLeftMarginAttribute *  , BOOL  )

Definition at line 4692 of file rndrgn.cpp. { // Restore the attribute RestoreAttribute(ATTR_TXTLEFTMARGIN, (AttributeValue*)pAttr, Temp); SetTextAttributes(CHANGEATTR_LEFTMARGIN); }

void RenderRegion::RestoreTxtLineSpace (  TxtLineSpaceAttribute *  pAttr, BOOL  Temp )

Get rid of the current Text LineSpace, and restore the specified LineSpace value. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/03/95 Parameters: pAttr  - the object specifying the colour to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::SetTxtLineSpace Definition at line 4665 of file rndrgn.cpp. { // Restore the Text LineSpace attribute RestoreAttribute(ATTR_TXTLINESPACE, (AttributeValue*)pAttr, Temp); SetTextAttributes(CHANGEATTR_LINESPACE); }

void RenderRegion::RestoreTxtRightMargin (  TxtRightMarginAttribute *  , BOOL  )

Definition at line 4708 of file rndrgn.cpp. { // Restore the attribute RestoreAttribute(ATTR_TXTRIGHTMARGIN, (AttributeValue*)pAttr, Temp); SetTextAttributes(CHANGEATTR_RIGHTMARGIN); }

void RenderRegion::RestoreTxtRuler (  TxtRulerAttribute *  , BOOL  )

Definition at line 4740 of file rndrgn.cpp. { // Restore the attribute RestoreAttribute(ATTR_TXTRULER, (AttributeValue*)pAttr, Temp); SetTextAttributes(CHANGEATTR_RULER); }

void RenderRegion::RestoreTxtScript (  TxtScriptAttribute *  pAttr, BOOL  Temp )

Get rid of the current Text Script, and restore the specified Script value. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/03/95 Parameters: pAttr  - the object specifying the colour to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::SetTxtScript Definition at line 4571 of file rndrgn.cpp. { // Restore the Text Script attribute RestoreAttribute(ATTR_TXTSCRIPT, (AttributeValue*)pAttr, Temp); SetTextAttributes(CHANGEATTR_SCRIPT); }

void RenderRegion::RestoreTxtTracking (  TxtTrackingAttribute *  pAttr, BOOL  Temp )

Get rid of the current Text Tracking, and restore the specified Tracking value. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/03/95 Parameters: pAttr  - the object specifying the colour to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::SetTxtTracking Definition at line 4523 of file rndrgn.cpp. { // Restore the Text Tracking attribute RestoreAttribute(ATTR_TXTTRACKING, (AttributeValue*)pAttr, Temp); SetTextAttributes(CHANGEATTR_TRACKING); }

void RenderRegion::RestoreTxtUnderline (  TxtUnderlineAttribute *  pAttr, BOOL  Temp )

Get rid of the current Text underline state, and restore the specified underline value. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 13/03/95 Parameters: pAttr  - the object specifying the colour to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::SetTxtUnderline Definition at line 4385 of file rndrgn.cpp. { // Restore the Text Italic attribute RestoreAttribute(ATTR_TXTUNDERLINE, (AttributeValue*)pAttr, Temp); SetTextAttributes(CHANGEATTR_UNDERLINE); }

void RenderRegion::RestoreVariableWidth (  VariableWidthAttrValue *  pAttr, BOOL  Temp )  [virtual]

Get rid of the current VariableWidth, and restore the specified VariableWidth. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 7/1/97 Parameters: pAttr  - the object specifying the new stroke type [INPUTS] Temp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::SetVariableWidth Definition at line 2806 of file rndrgn.cpp. { RestoreAttribute(ATTR_VARWIDTH, pAttr, Temp); }

void RenderRegion::RestoreWebAddress (  WebAddressAttribute *  pAttr, BOOL  Temp )  [virtual]

Restore the Web Address. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 18/3/97 Parameters: pAttr  - pointer to a Web Address to set [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::SetWebAddress Definition at line 3701 of file rndrgn.cpp. { // Set up the new attribute RestoreAttribute(ATTR_WEBADDRESS, (AttributeValue*) pAttr, Temp); }

void RenderRegion::RestoreWindingRule (  WindingRuleAttribute *  pAttr, BOOL  Temp )  [virtual]

Get rid of the current winding rule, and restore the specified winding rule. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 12/04/94 Parameters: pAttr  - the object specifying the winding rule to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::SetWindingRule Definition at line 4051 of file rndrgn.cpp. { // Set up the new attribute RestoreAttribute(ATTR_WINDINGRULE, pAttr, Temp); // The fill attributes need to be reset before drawing anything. SetFillAttributes(CHANGEATTR_WINDING_RULE); }

BOOL RenderRegion::SaveAttribute (  UINT32  Index, AttributeValue *  pAttr, BOOL  Temp )  [virtual]

Saves the current attribute on the attribute context stack, and installs the given attribute as the new attribute. If the attribute object is temporary, then it is deleted when the attribute is popped off the stack. See RenderRegion::RestoreAttribute. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 12/04/94 Parameters: Index  - Unique attribute ID (See AttributeManager::RegisterDefaultAttribute). [INPUTS] pAttr - the new attribute to use as the current one. Temp - TRUE if pAttr points to a temporary object, FALSE if not. Returns: TRUE if the operation completed successfully, FALSE if not. Errors: Out of memory. See also: AttributeManager::RegisterDefaultAttribute Reimplemented in EPSRenderRegion. Definition at line 1710 of file rndrgn.cpp. { #ifdef _DEBUG if(m_TraceOutContextLevels) { TRACE( _T("...Saving Level %d Attribute %s 0x%x\n"),m_CurrentContextLevel,(LPCTSTR)pAttr->GetRuntimeClass()->GetClassName(), pAttr); } // Make sure the current Attr is a valid pointer. CC_ASSERT_VALID((CurrentAttrs[Index].pAttr)); CC_ASSERT_VALID((pAttr)); #endif // Push the current attribute onto the stack, and install the new attribute as // the 'current' one. if (TheStack.Push(CurrentAttrs[Index].pAttr, CurrentAttrs[Index].Temp)) { CurrentAttrs[Index].pAttr = pAttr; CurrentAttrs[Index].Temp = Temp; // Everything worked ok. return TRUE; } // Failed return FALSE; }

void RenderRegion::SaveContext (   )

Definition at line 1094 of file rndrgn.cpp. { TheStack.SaveContext(); #ifdef _DEBUG m_CurrentContextLevel++; #endif }

void RenderRegion::SetBackgroundColour (  DocColour &  Colour  )

Sets the value of mBackground colour, which is used whenever the program needs to know what the background colour of a file is. Author: Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com> Date: 19/1/00 Input: Colour - The background colour of the current document. Returns: - See also: - Definition at line 6794 of file rndrgn.cpp. { mBackgroundColour = Colour; }

void RenderRegion::SetBackmostChangedNode (  Node *  pInvalidNode  )  [virtual]

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 09/08/2004 Parameters: -  [INPUTS] -  [OUTPUTS] Definition at line 7342 of file rndrgn.cpp. { if (pInvalidNode) { if (pInvalidNode->FindParent()==NULL) { // ERROR2RAW("SetBackmostChangedNode called on node with no parent"); return; } if (m_pBackmostChangedNode==NULL || pInvalidNode->IsUnder(m_pBackmostChangedNode)) m_pBackmostChangedNode = pInvalidNode; } }

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

Virtual function used to inform render region that defers update that it should set its render state to be 'clean', i.e. if no more rendering occurs then it need not update the device. This is used for render regions such as GRenderRegions, where we render the paper using the host OS graphics primitives, but we have to render the paper into the GRenderRegion too, otherwise we will get garbage. Equally though, we don't want the GRenderRegion to do a potentially slow blit if all it is going to draw is some paper. It also allows the 'changed box' to be reset, so if we only have a small object on the page, then only the area containing the object is updated using a blit. The default implementation of this function does nothing - most render regions won't need to over-ride this null behaviour. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 28/06/94 Parameters: FillWhite  is an optional parameter which lets the region fill itself with [INPUTS] white. This is used during hit-testing. See also: GRenderRegion::SetClean Reimplemented in GRenderClick, and GRenderRegion. Definition at line 1280 of file rndrgn.cpp. { }

void RenderRegion::SetClipRect (  DocRect &  NewClipRect, BOOL  ReCalcContextNode = FALSE )

Sets the Clipping rectangle of the Render Region. Calls InitClipping() to acually set the clip region in an OS specific way. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 24/6/93 Parameters: A  DocRect describing the tightest bounding box around the clipping region. [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: RenderRegion::GetClipRect(); RenderRegion::RenderRegion() Definition at line 1357 of file rndrgn.cpp. { ENSURE(NewClipRect.IsValid(),"RenderRegion::SetClipRect called with Invalid Rectangle"); CurrentClipRect = NewClipRect; ENSURE(GetMasterCapture()==NULL || MasterCaptureIsCurrent(), "SetClipRect being called while child Captures are running\n"); if (GetMasterCapture()!=NULL) { if (MasterCaptureIsCurrent()) { GetMasterCapture()->SetClipRect(NewClipRect); } } if (RenderFlags.Rendering) { // Do some OS specific initialisation of the clipping region InitClipping(); // This is implemented in the Derived classes (OSRenderRegion etc) } // if we need to recalculate the regions context node then go ahead if (ReCalcContextNode==TRUE) { // CurrentRenderState = RenderSpread->FindFirstForClippedInkRender(&CurrentClipRect, this); CurrentRenderState = RenderSpread; // For use with RenderTree // Don't need Node sub context anymore delete CurrentSubRenderState; CurrentSubRenderState = NULL; SubRenderStateLocked = FALSE; } }

void RenderRegion::SetClipRegion (  ClipRegionAttribute *  pAttr, BOOL  Temp )  [virtual]

Set this render-region's current clipping region. See also: ClipRegionAttribute::Render(), RenderRegion::RestoreClipRegion(). Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 11 April 2000 Parameters: pAttr  the new ClipRegionAttribute. [INPUTS] Temp whether the new attribute is temporary, and should therefore be deleted when it is finished with. Reimplemented in AIEPSRenderRegion, EPSRenderRegion, and GRenderRegion. Definition at line 5000 of file rndrgn.cpp. { SaveAttribute(ATTR_CLIPREGION, (AttributeValue *) pAttr, Temp); }

void RenderRegion::SetDashPattern (  StockDash  NewDashPattern  )

Set the dash pattern, pushing the current dash pattern onto the context stack. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/94 Parameters: NewDashPattern  - the on-off pattern of the dash. [INPUTS] See also: RenderRegion::RestoreDashPattern Definition at line 3304 of file rndrgn.cpp. { DashPatternAttribute *TempAttr = new DashPatternAttribute(); TempAttr->SetStockDashPattern(NewDashPattern); // Don't bother if it doesn't cause a change DashPatternAttribute *pAttr = (DashPatternAttribute *) CurrentAttrs[ATTR_DASHPATTERN].pAttr; if ((pAttr != NULL) && (TempAttr->DashPattern == pAttr->DashPattern)) { delete TempAttr; return; } // Create a temporary attribute and use it to set the line colour. SetDashPattern(TempAttr, TRUE); }

void RenderRegion::SetDashPattern (  DashRec &  NewDashPattern  )

Set the dash pattern, pushing the current dash pattern onto the context stack. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/94 Parameters: NewDashPattern  - the on-off pattern of the dash. [INPUTS] See also: RenderRegion::RestoreDashPattern Definition at line 3278 of file rndrgn.cpp. { // Don't bother if it doesn't cause a change DashPatternAttribute *pAttr = (DashPatternAttribute *) CurrentAttrs[ATTR_DASHPATTERN].pAttr; if ((pAttr != NULL) && (NewDashPattern == pAttr->DashPattern)) return; // Create a temporary attribute and use it to set the line colour. pAttr = new DashPatternAttribute(); pAttr->SetDashPattern(NewDashPattern); SetDashPattern(pAttr, TRUE); }

void RenderRegion::SetDashPattern (  DashPatternAttribute *  pAttr, BOOL  Temp )  [virtual]

Set the current dash pattern according to an AttributeValue object, pushing the current dash pattern onto the context stack. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/94 Parameters: pAttr  - the object specifying the line width to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::RestoreDashPattern Definition at line 3392 of file rndrgn.cpp. { // Set up the new attribute if (SaveAttribute(ATTR_DASHPATTERN, pAttr, Temp)) { // The line attributes need to be reset before drawing anything. SetLineAttributes(CHANGEATTR_DASHPATTERN); } }

void RenderRegion::SetDefaultQuality (   )

Set the quality attribute to the default setting, pushing the current quality level onto the context stack. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 12/04/94 See also: RenderRegion::RestoreQuality Definition at line 3586 of file rndrgn.cpp. { // Create a temporary attribute and use it to set the default quality.. QualityAttribute *pAttr = new QualityAttribute(); SetQuality(pAttr, TRUE); }

void RenderRegion::SetDeviceDashPattern (  StockDash  NewDashPattern  )

Set the dash pattern, pushing the current dash pattern onto the context stack. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/94 Parameters: NewDashPattern  - the on-off pattern of the dash. [INPUTS] See also: RenderRegion::RestoreDashPattern Definition at line 3360 of file rndrgn.cpp. { DashPatternAttribute *TempAttr = new DashPatternAttribute(); TempAttr->SetDeviceStockDashPattern(NewDashPattern, GetScaledPixelWidth()); // Don't bother if it doesn't cause a change DashPatternAttribute *pAttr = (DashPatternAttribute *) CurrentAttrs[ATTR_DASHPATTERN].pAttr; if ((pAttr != NULL) && (TempAttr->DashPattern == pAttr->DashPattern)) { delete TempAttr; return; } // Create a temporary attribute and use it to set the line colour. SetDashPattern(TempAttr, TRUE); }

void RenderRegion::SetDeviceDashPattern (  DashRec &  NewDashPattern  )

Set the dash pattern, pushing the current dash pattern onto the context stack. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/94 Parameters: NewDashPattern  - the on-off pattern of the dash. [INPUTS] See also: RenderRegion::RestoreDashPattern Definition at line 3334 of file rndrgn.cpp. { // Don't bother if it doesn't cause a change DashPatternAttribute *pAttr = (DashPatternAttribute *) CurrentAttrs[ATTR_DASHPATTERN].pAttr; if ((pAttr != NULL) && (NewDashPattern == pAttr->DashPattern)) return; // Create a temporary attribute and use it to set the line colour. pAttr = new DashPatternAttribute(); pAttr->SetDeviceDashPattern(NewDashPattern, GetScaledPixelWidth()); SetDashPattern(pAttr, TRUE); }

void RenderRegion::SetDrawingMode (  DrawModeType  NewDrawingMode  )

Set the drawing mode, pushing the current drawing mode onto the context stack. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 12/04/94 Parameters: NewDrawingMode  - the drawing mode to use. [INPUTS] See also: RenderRegion::RestoreDrawingMode Definition at line 4074 of file rndrgn.cpp. { // Don't bother if it doesn't cause a change DrawingModeAttribute *pAttr = (DrawingModeAttribute *) CurrentAttrs[DrawingModeAttribute::ID].pAttr; if ((pAttr != NULL) && (NewDrawingMode == pAttr->DrawingMode)) return; // Create a temporary attribute and use it to set the drawing mode pAttr = new DrawingModeAttribute(NewDrawingMode); SetDrawingMode(pAttr, TRUE); }

void RenderRegion::SetDrawingMode (  DrawingModeAttribute *  pAttr, BOOL  Temp )  [virtual]

Set the current drawing mode according to an AttributeValue object, pushing the current drawing mode onto the context stack. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 12/04/94 Parameters: pAttr  - the object specifying the drawing mode to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::RestoreDrawingMode Definition at line 4102 of file rndrgn.cpp. { // Save the current attribute SaveAttribute(DrawingModeAttribute::ID, pAttr, Temp); DrawingMode = pAttr->DrawingMode; // The drawing mode needs to be set // MarkH - 12/11/99 // First check to see if we`re dealing with a derived class or using the base class as // the base class ( RenderRegion ) 'SetOSDrawingMode()' is a pure virtual which will // ultimately crash in a big way if it is called!!!! if(!IS_A(this,RenderRegion)) { SetOSDrawingMode(); } }

void RenderRegion::SetEndArrow (  ArrowRec &  NewEndArrow  )

Set the current EndArrow according to an AttributeValue object, pushing the current Arrow the context stack. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 5/4/95 Parameters: NewEndArrow,the  new Arrow to draw on the end of lines. [INPUTS] See also: RenderRegion::RestoreEndArrow Definition at line 3848 of file rndrgn.cpp. { // Don't bother if it doesn't cause a change EndArrowAttribute *pAttr = (EndArrowAttribute *) CurrentAttrs[ATTR_ENDARROW].pAttr; if ((pAttr != NULL) && (pAttr->EndArrow == NewEndArrow)) return; // Create a temporary attribute and use it to set the Start Arrow. pAttr = new EndArrowAttribute(); pAttr->EndArrow = NewEndArrow; SetEndArrow(pAttr, TRUE); }

void RenderRegion::SetEndArrow (  StockArrow  NewEndArrow  )

Set the current EndArrow according to an AttributeValue object, pushing the current Arrow the context stack. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 5/4/95 Parameters: NewEndArrow,the  new Arrow to draw on the end of lines. [INPUTS] See also: RenderRegion::RestoreEndArrow Definition at line 3822 of file rndrgn.cpp. { // Don't bother if it doesn't cause a change EndArrowAttribute *pAttr = (EndArrowAttribute *) CurrentAttrs[ATTR_ENDARROW].pAttr; if ((pAttr != NULL) && (pAttr->EndArrow == NewEndArrow)) return; // Create a temporary attribute and use it to set the Start Arrow. pAttr = new EndArrowAttribute(); pAttr->EndArrow = NewEndArrow; SetEndArrow(pAttr, TRUE); }

void RenderRegion::SetEndArrow (  EndArrowAttribute *  pAttr, BOOL  Temp )  [virtual]

Set the current EndArrow according to an AttributeValue object, pushing the current EndArrow the context stack. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 5/4/95 Parameters: pAttr  - the object specifying the dash pattern to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::RestoreEndArrow Definition at line 3876 of file rndrgn.cpp. { // Set up the new attribute if (SaveAttribute(ATTR_ENDARROW, pAttr, Temp)) { // The line attributes need to be reset before drawing anything. SetLineAttributes(CHANGEATTR_ENDARROW); } }

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

Inform the render region that an aspect of the path filling attributes has changed. The base class version just updates the RenderRegion member variable FillFlags to reflect which aspects of the fill attributes have become invalid. Derived render regions can either call the base class or just implement whatever methods they need for keeping track of these changes - or a combination of the two, of course. Some render regions (e.g. GRenderRegions) don't need to do anything about this at all as all attributes are invoked whenever anything is rendered. If this is the case, then this should be over-ridden to have a NULL implementation because this will improve rendering speed. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/94 Parameters: Type  - the type of the fill attribute that has changed, can be: [INPUTS] CHANGEATTR_ALL CHANGEATTR_GEOMETRY CHANGEATTR_EFFECT CHANGEATTR_MAPPING CHANGEATTR_TRANSP_GEOMETRY CHANGEATTR_TRANSP_EFFECT CHANGEATTR_TRANSP_MAPPING CHANGEATTR_WINDING_RULE See also: ChangeAttrType Reimplemented in OSRenderRegion. Definition at line 1643 of file rndrgn.cpp. { switch (Type) { case CHANGEATTR_ALL: FillFlags.ValidGeometry = FALSE; FillFlags.ValidEffect = FALSE; FillFlags.ValidMapping = FALSE; FillFlags.ValidTransGeometry = FALSE; FillFlags.ValidTransEffect = FALSE; FillFlags.ValidTransMapping = FALSE; FillFlags.ValidWindingRule = FALSE; break; case CHANGEATTR_GEOMETRY: FillFlags.ValidGeometry = FALSE; break; case CHANGEATTR_EFFECT: FillFlags.ValidEffect = FALSE; break; case CHANGEATTR_MAPPING: FillFlags.ValidMapping = FALSE; break; case CHANGEATTR_TRANSP_GEOMETRY: FillFlags.ValidTransGeometry = FALSE; break; case CHANGEATTR_TRANSP_EFFECT: FillFlags.ValidTransEffect = FALSE; break; case CHANGEATTR_TRANSP_MAPPING: FillFlags.ValidTransMapping = FALSE; break; case CHANGEATTR_WINDING_RULE: FillFlags.ValidWindingRule = FALSE; break; default: ERROR3_PF(("Invalid attribute type (%d) in SetFillAttributes", Type)); break; } }

void RenderRegion::SetFillColour (  StockColour  New  )

Set the fill colour to a specific colour, pushing the current fill colour onto the context stack. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 12/04/94 Parameters: NewFillColour  - the colour to set the fill colour to. [INPUTS] See also: RenderRegion::RestoreFillColour Definition at line 2856 of file rndrgn.cpp. { DocColour NewFillColour(New); // Don't bother if it doesn't cause a change ColourFillAttribute *pAttr = (ColourFillAttribute *) CurrentAttrs[ATTR_FILLGEOMETRY].pAttr; if ((pAttr != NULL) && (pAttr->GetRuntimeClass() == CC_RUNTIME_CLASS(FlatFillAttribute)) && (NewFillColour == ((FlatFillAttribute *) pAttr)->Colour)) return; // Create a temporary attribute and use it to set the line colour. pAttr = new FlatFillAttribute(NewFillColour); SetFillGeometry(pAttr, TRUE); }

void RenderRegion::SetFillColour (  DocColour &  NewFillColour  )

Set the fill colour to a specific colour, pushing the current fill colour onto the context stack. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 12/04/94 Parameters: NewFillColour  - the colour to set the fill colour to. [INPUTS] See also: RenderRegion::RestoreFillColour Definition at line 2826 of file rndrgn.cpp. { // Don't bother if it doesn't cause a change ColourFillAttribute *pAttr = (ColourFillAttribute *) CurrentAttrs[ATTR_FILLGEOMETRY].pAttr; if ((pAttr != NULL) && (pAttr->GetRuntimeClass() == CC_RUNTIME_CLASS(FlatFillAttribute)) && (NewFillColour == ((FlatFillAttribute *) pAttr)->Colour)) return; // Create a temporary attribute and use it to set the line colour. pAttr = new FlatFillAttribute(NewFillColour); SetFillGeometry(pAttr, TRUE); }

void RenderRegion::SetFillEffect (  FillEffectAttribute *  pAttr, BOOL  Temp )  [virtual]

Set the current fill type according to an AttributeValue object, pushing the current fill type onto the context stack. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 12/04/94 Parameters: pAttr  - the object specifying the fill type to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::RestoreFillType; RenderRegion::SetFillColour Definition at line 3007 of file rndrgn.cpp. { // Save the current attribute if (SaveAttribute(ATTR_FILLEFFECT, pAttr, Temp)) { // The fill attributes need to be reset before drawing anything. SetFillAttributes(CHANGEATTR_EFFECT); } }

void RenderRegion::SetFillGeometry (  ColourFillAttribute *  pAttr, BOOL  Temp )  [virtual]

Set the current fill type according to an AttributeValue object, pushing the current fill type onto the context stack. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 12/04/94 Parameters: pAttr  - the object specifying the fill type to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::RestoreFillType; RenderRegion::SetFillColour Definition at line 2893 of file rndrgn.cpp. { // Before stacking the attribute, check for overprint and print on all plates - these // may cause the fill colours to change, in which case we replace the given attribute // with a new modified one. ColourFillAttribute *NewAttr = PrepareFillGeometry(pAttr); if (NewAttr != NULL) { if (Temp) delete pAttr; pAttr = NewAttr; // Use the modified attribute Temp = TRUE; // ...which is always temporary } // Save the current attribute if (SaveAttribute(ATTR_FILLGEOMETRY, pAttr, Temp)) { // The fill attributes need to be reset before drawing anything. SetFillAttributes(CHANGEATTR_GEOMETRY); } }

void RenderRegion::SetFillMapping (  FillMappingAttribute *  pAttr, BOOL  Temp )  [virtual]

Set the current fill type according to an AttributeValue object, pushing the current fill type onto the context stack. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 12/04/94 Parameters: pAttr  - the object specifying the fill type to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::RestoreFillType; RenderRegion::SetFillColour Definition at line 2955 of file rndrgn.cpp. { // Save the current attribute if (SaveAttribute(ATTR_FILLMAPPING, pAttr, Temp)) { // The fill attributes need to be reset before drawing anything. SetFillAttributes(CHANGEATTR_MAPPING); } }

void RenderRegion::SetFillOverprint (  OverprintFillAttrValue *  NewAttr, BOOL  Temp )  [virtual]

Set the fill overprint state, pushing the current "overprint fill" attribute onto the context stack. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 30/7/96 Parameters: NewAttr  - The new OverPrintFillAttrValue you want to set current [INPUTS] Temp - TRUE if this is a temporary object which the render region should delete when finished with it; FALSE if someone else will delete it (i.e. it's in the document tree) See also: RenderRegion::RestoreOverprintFill Definition at line 2408 of file rndrgn.cpp. { // Set the new Overprint state SaveAttribute(ATTR_OVERPRINTFILL, NewAttr, Temp); // And make sure the current fill colour attribute is affected by the new overprint state ColourFillAttribute *NewFillGeometry = PrepareFillGeometry(); if (NewFillGeometry != NULL) SetFillGeometry(NewFillGeometry, TRUE); }

void RenderRegion::SetFilter (  Filter *  pFilter  )  [inline]

Definition at line 682 of file rndrgn.h. {m_pFilter = pFilter;}

BOOL RenderRegion::SetFirstBand (   )  [virtual]

This function gives the render region a chance to see if it want to do some banding or not. If it decides it does, then this function will set it all up ready to start. It should be called before StartRender. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 2/5/95 Returns: TRUE if all went OK, FALSE if there was a problem Reimplemented in GRenderBitmap, GRenderClick, GRenderDIB, and GRenderPrint. Definition at line 6349 of file rndrgn.cpp. { // No Banding please IsRegionBanded = FALSE; IsWaitingForRAM = FALSE; IsLastBand = TRUE; CanRegionBeMerged = TRUE; return TRUE; }

void RenderRegion::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 in FormatRegion, GRenderRegion, and OSRenderRegion. Definition at line 5089 of file rndrgn.cpp. { ERROR2RAW("Attempt to call unsupported RenderRegion::SetFixedSystemTextColours method"); }

void RenderRegion::SetForceMixTransparency (  BOOL  bForceMix  )  [inline]

Definition at line 731 of file rndrgn.h. { m_bForceMix = bForceMix; }

void RenderRegion::SetImmediateRender (  BOOL  SetVal  )  [inline]

Definition at line 728 of file rndrgn.h. {RenderFlags.bImmediateRender = SetVal;}

void RenderRegion::SetJoinType (  JointType  NewJoinType  )

Set the current JoinType according to an AttributeValue object, pushing the current JoinType the context stack. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 5/4/95 Parameters: NewJoinType,the  new Join Type to join lines with. [INPUTS] See also: RenderRegion::RestoreJoinType Definition at line 3512 of file rndrgn.cpp. { // Don't bother if it doesn't cause a change JoinTypeAttribute *pAttr = (JoinTypeAttribute *) CurrentAttrs[ATTR_JOINTYPE].pAttr; if ((pAttr != NULL) && (NewJoinType == pAttr->JoinType)) return; // Create a temporary attribute and use it to set the Join Type. pAttr = new JoinTypeAttribute(); pAttr->JoinType = NewJoinType; SetJoinType(pAttr, TRUE); }

void RenderRegion::SetJoinType (  JoinTypeAttribute *  pAttr, BOOL  Temp )  [virtual]

Set the current JoinType according to an AttributeValue object, pushing the current JoinType the context stack. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 5/4/95 Parameters: pAttr  - the object specifying the dash pattern to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::RestoreJoinType Definition at line 3540 of file rndrgn.cpp. { // Set up the new attribute if (SaveAttribute(ATTR_JOINTYPE, pAttr, Temp)) { // The line attributes need to be reset before drawing anything. SetLineAttributes(CHANGEATTR_JOINTYPE); } }

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

Inform the render region that an aspect of the path stroking attributes has changed. The base class version just updates the RenderRegion member variable StrokeFlags to reflect which aspects of the stroke attributes have become invalid. Derived render regions can either call the base class or just implement whatever methods they need for keeping track of these changes - or a combination of the two, of course. Some render regions (e.g. GRenderRegions) don't need to do anything about this at all as all attributes are invoked whenever anything is rendered. If this is the case, then this should be over-ridden to have a NULL implementation because this will improve rendering speed. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 15/4/95 Parameters: Type  - the type of the fill attribute that has changed, can be: [INPUTS] CHANGEATTR_ALL CHANGEATTR_STROKECOL CHANGEATTR_STROKETRANSP CHANGEATTR_LINEWIDTH CHANGEATTR_JOINTYPE CHANGEATTR_DASHPATTERN CHANGEATTR_LINECAP CHANGEATTR_STARTARROW CHANGEATTR_ENDARROW CHANGEATTR_MITRELIMIT See also: ChangeLineAttrType Reimplemented in OSRenderRegion. Definition at line 1553 of file rndrgn.cpp. { switch (Type) { case CHANGELINEATTR_ALL: StrokeFlags.ValidStrokeColour = FALSE; StrokeFlags.ValidStrokeTransp = FALSE; StrokeFlags.ValidLineWidth = FALSE; StrokeFlags.ValidJoinType = FALSE; StrokeFlags.ValidDashPattern = FALSE; StrokeFlags.ValidLineCap = FALSE; StrokeFlags.ValidStartArrow = FALSE; StrokeFlags.ValidEndArrow = FALSE; StrokeFlags.ValidMitreLimit = FALSE; break; case CHANGEATTR_STROKECOL: StrokeFlags.ValidStrokeColour = FALSE; break; case CHANGEATTR_STROKETRANSP: StrokeFlags.ValidStrokeTransp = FALSE; break; case CHANGEATTR_LINEWIDTH: StrokeFlags.ValidLineWidth = FALSE; break; case CHANGEATTR_JOINTYPE: StrokeFlags.ValidJoinType = FALSE; break; case CHANGEATTR_DASHPATTERN: StrokeFlags.ValidDashPattern = FALSE; break; case CHANGEATTR_LINECAP: StrokeFlags.ValidLineCap = FALSE; break; case CHANGEATTR_STARTARROW: StrokeFlags.ValidStartArrow = FALSE; break; case CHANGEATTR_ENDARROW: StrokeFlags.ValidEndArrow = FALSE; break; case CHANGEATTR_MITRELIMIT: StrokeFlags.ValidMitreLimit = FALSE; break; default: ERROR3_PF(("Invalid attribute type (%d) in SetLineAttributes", Type)); break; } }

void RenderRegion::SetLineColour (  StockColour  New  )

Set the line colour to a specific colour, pushing the current line colour onto the context stack. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 12/04/94 Parameters: NewLineColour  - the colour to set the line colour to. [INPUTS] See also: RenderRegion::RestoreLineColour Definition at line 2550 of file rndrgn.cpp. { DocColour NewLineColour(New); // Don't bother if it doesn't cause a change StrokeColourAttribute *pAttr = (StrokeColourAttribute *) CurrentAttrs[ATTR_STROKECOLOUR].pAttr; if ((pAttr != NULL) && (NewLineColour == pAttr->Colour)) return; // Create a temporary attribute and use it to set the line colour. pAttr = new StrokeColourAttribute(NewLineColour); SetLineColour(pAttr, TRUE); }

void RenderRegion::SetLineColour (  DocColour &  NewLineColour  )

Set the line colour to a specific colour, pushing the current line colour onto the context stack. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 12/04/94 Parameters: NewLineColour  - the colour to set the line colour to. [INPUTS] See also: RenderRegion::RestoreLineColour Definition at line 2523 of file rndrgn.cpp. { // Don't bother if it doesn't cause a change StrokeColourAttribute *pAttr = (StrokeColourAttribute *) CurrentAttrs[ATTR_STROKECOLOUR].pAttr; if ((pAttr != NULL) && (NewLineColour == pAttr->Colour)) return; // Create a temporary attribute and use it to set the line colour. pAttr = new StrokeColourAttribute(NewLineColour); SetLineColour(pAttr, TRUE); }

void RenderRegion::SetLineColour (  StrokeColourAttribute *  pAttr, BOOL  Temp )  [virtual]

Set the current line colour according to an AttributeValue object, pushing the current line colour onto the context stack. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 12/04/94 Parameters: pAttr  - the object specifying the colour to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::RestoreLineColour Definition at line 2581 of file rndrgn.cpp. { // Before stacking the attribute, check for overprint and print on all plates - these // may cause the line colour to change, in which case we replace the given attribute // with a new modified one. StrokeColourAttribute *NewAttr = PrepareLineColour(pAttr); if (NewAttr != NULL) { if (Temp) delete pAttr; pAttr = NewAttr; // Use the modified attribute Temp = TRUE; // ...which is always temporary } // Save the current attribute and set up the new one if (SaveAttribute(ATTR_STROKECOLOUR, pAttr, Temp)) { // The line attributes need to be reset before drawing anything. SetLineAttributes(CHANGEATTR_STROKECOL); } }

void RenderRegion::SetLineOverprint (  OverprintLineAttrValue *  NewAttr, BOOL  Temp )  [virtual]

Set the line overprint state, pushing the current "overprint line" attribute onto the context stack. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 30/7/96 Parameters: NewAttr  - The new OverPrintLineAttrValue you want to set current [INPUTS] Temp - TRUE if this is a temporary object which the render region should delete when finished with it; FALSE if someone else will delete it (i.e. it's in the document tree) See also: RenderRegion::RestoreOverprintLine Definition at line 2350 of file rndrgn.cpp. { // Set the new Overprint state SaveAttribute(ATTR_OVERPRINTLINE, NewAttr, Temp); // And make sure the current line colour attribute is affected by the new overprint state StrokeColourAttribute *NewLineCol = PrepareLineColour(); if (NewLineCol != NULL) SetLineColour(NewLineCol, TRUE); }

void RenderRegion::SetLineTransp (  StrokeTranspAttribute *  pAttr, BOOL  Temp )  [virtual]

Set the current line colour according to an AttributeValue object, pushing the current line colour onto the context stack. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 30/11/94 Parameters: pAttr  - the object specifying the colour to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::RestoreLineColour Definition at line 2644 of file rndrgn.cpp. { StrokeTranspAttribute* pNewAttr = NULL; if (m_bForceMix) { UINT32 Type = pAttr->GetTranspType(); if (Type != TT_NoTranspType && Type != TT_Mix && Type != TT_DARKEN && Type != TT_LIGHTEN && Type != TT_BRIGHTNESS && Type != TT_BEVEL) { if (Temp) { pNewAttr = pAttr; } else { pNewAttr = (StrokeTranspAttribute*)(pAttr->GetRuntimeClass()->CreateObject()); if (pNewAttr) { pNewAttr->SimpleCopy(pAttr); } } } } if (pNewAttr) { pNewAttr->SetTranspType(TT_Mix); Temp = TRUE; } else pNewAttr = pAttr; // Save the current attribute and set up the new one if (SaveAttribute(ATTR_STROKETRANSP, pNewAttr, Temp)) { // The line attributes need to be reset before drawing anything. SetLineAttributes(CHANGEATTR_STROKETRANSP); } }

void RenderRegion::SetLineWidth (  MILLIPOINT  NewLineWidth  )

Set the line width to a specific size, pushing the current line width onto the context stack. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 12/04/94 Parameters: NewLineWidth  - the size to set the line width to. [INPUTS] See also: RenderRegion::RestoreLineColour Definition at line 3195 of file rndrgn.cpp. { // Don't bother if it doesn't cause a change LineWidthAttribute *pAttr = (LineWidthAttribute *) CurrentAttrs[ATTR_LINEWIDTH].pAttr; if ((pAttr != NULL) && (NewLineWidth == pAttr->LineWidth)) return; // Create a temporary attribute and use it to set the line colour. pAttr = new LineWidthAttribute(NewLineWidth); SetLineWidth(pAttr, TRUE); }

void RenderRegion::SetLineWidth (  LineWidthAttribute *  pAttr, BOOL  Temp )  [virtual]

Set the current line width according to an AttributeValue object, pushing the current linewidth onto the context stack. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 12/04/94 Parameters: pAttr  - the object specifying the line width to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::RestoreLineWidth Definition at line 3222 of file rndrgn.cpp. { // Set up the new attribute if (SaveAttribute(ATTR_LINEWIDTH, pAttr, Temp)) { // The line attributes need to be reset before drawing anything. SetLineAttributes(CHANGEATTR_LINEWIDTH); // NB We need to invalidate the dash pattern too as this depends // on line width (doesn't seem to matter normally, but PostScript // gets dash patterns wrong otherwise. SetLineAttributes(CHANGEATTR_DASHPATTERN); } }

void RenderRegion::SetMatrix (  Matrix &  NewMatrix  )  [virtual]

This can be used to set the RenderRegions transform matrix to the given matrix. This should really be used with care! Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 26/10/93 Parameters: NewMatrix  - The matrix that will replace the old RenderMatrix [INPUTS] See also: RenderRegion::ConcatenateMatrix Definition at line 1297 of file rndrgn.cpp. { // Set the Render Matrix to the one provided RenderMatrix = NewMatrix; if (GetMasterCapture()) { GetMasterCapture()->CaptureMatrix = NewMatrix; } }

void RenderRegion::SetMitreLimit (  MILLIPOINT  NewMitreLimit  )

Set the current MitreLimit according to an AttributeValue object, pushing the current Arrow the context stack. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 5/4/95 Parameters: NewMitreLimit,the  new Arrow to draw on the end of lines. [INPUTS] See also: RenderRegion::RestoreMitreLimit Definition at line 3922 of file rndrgn.cpp. { // Don't bother if it doesn't cause a change MitreLimitAttribute *pAttr = (MitreLimitAttribute *) CurrentAttrs[ATTR_MITRELIMIT].pAttr; if ((pAttr != NULL) && (pAttr->MitreLimit == NewMitreLimit)) return; // Create a temporary attribute and use it to set the Start Arrow. pAttr = new MitreLimitAttribute(); pAttr->MitreLimit = NewMitreLimit; SetMitreLimit(pAttr, TRUE); }

void RenderRegion::SetMitreLimit (  MitreLimitAttribute *  pAttr, BOOL  Temp )  [virtual]

Set the current MitreLimit according to an AttributeValue object, pushing the current MitreLimit the context stack. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 5/4/95 Parameters: pAttr  - the object specifying the dash pattern to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::RestoreMitreLimit Definition at line 3950 of file rndrgn.cpp. { // Set up the new attribute if (SaveAttribute(ATTR_MITRELIMIT, pAttr, Temp)) { // The line attributes need to be reset before drawing anything. SetLineAttributes(CHANGEATTR_MITRELIMIT); } }

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

Uses attribute stacking to offscreen rendering system notified when offscreen bitmap has been rendered (ie occurs when subtree is finished rendering and attributes are being restored). See also: RenderRegion::SaveAttribute; Reimplemented in MaskedRenderRegion, PrintingMaskedRenderRegion, GRenderBrush, and GRenderRegion. Definition at line 4771 of file rndrgn.cpp. { // TRACEUSER( "Gerry", _T("RenderRegion::SetOffscreen (0x%08x)\n"), pAttr); // 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; // Karim 23/07/2000 // Don't bother with feathering at all if our quality setting is too low. // Note: this test should probably be made in a Feather override of a Node vfn. if (RRQuality.GetFillQuality() < Quality::Graduated) return; //--------------------------------------------- // Karim 20/07/2000 // Moved from OffscreenAttrValue::Render(), to avoid checks for render-region types // in the feathering code. // The following code works out and sets the offscreen attr's // offscreen bounding box. // Invalid area = intersection of node's and render-region's bounding rects. // // Notes: 1. Inflate the node's bounding rect slightly, so it _completely_ // encloses the node (sometimes it doesn't quite). // 2. Inflate the RR's clip-rect slightly, so that we don't get // anti-aliasing edge artifacts in the final feather-bmp render. // 3. If printing, then use the GRR's inner rect instead of its clipping // rect, to fix stripey printing of feathers. // This BODGE is necessary because for some reason CurrentClipRect // does not cover a GRR's whole bitmap when printing !?!? // MILLIPOINT LargePixelWidth = (MILLIPOINT)ceil(GetScaledPixelWidthDouble()); MILLIPOINT LargePixelWidth = GetScaledPixelWidth(); DocRect NodeBB = pAttr->GetLinkedNode()->GetBoundingRect(); NodeBB.Inflate( LargePixelWidth ); DocRect GRegionBB = CurrentClipRect; // Removed by Phil 2/6/2004 // Seems to be bogus... // if (IsPrinting()) // GRegionBB = InnerRect; // else GRegionBB.Inflate( 2 * LargePixelWidth ); // If we should be checking the bounds if (CheckOffscreenBounds()) { // Then check them if (!NodeBB.IsIntersectedWith(GRegionBB)) return; } // calculate their intersection. DocRect drOffBB = NodeBB.Intersection(GRegionBB); // Ensure that we have minimum pixel dimensions // Expand cliprect if more pixels required // NB expanding by GRR->ScaledPixelWidth will ensure we increase bmp size // by exactly the no. of pixels required UINT32 RequiredWidth, RequiredHeight; pAttr->GetMinimumOffscreenBmpDimensions(&RequiredWidth,&RequiredHeight); // WinRect Rect = CalculateWinRect( drOffBB ); WinRect Rect = OSRenderRegion::DocRectToWin( RenderMatrix, drOffBB, GetPixelsPerInch() ); // NOTE! Use of ScaledPixelWidth in GetPixelsPerInch! UINT32 ProposedWidth = Rect.width; UINT32 ProposedHeight = Rect.height; MILLIPOINT ScaledPixelWidth = GetScaledPixelWidth(); // We have to check if the render matrix involves rotation as we have to // expand the DocRect in the other direction // First get the components of the matrix FIXED16 comps[4]; RenderMatrix.GetComponents(comps, NULL); // It is rotated if a = d = 0 and b = -c BOOL bRotated = (comps[0] == FIXED16(0) && comps[3] == FIXED16(0) && comps[1] == -comps[2]); if(ProposedWidth < (UINT32)RequiredWidth) { // make the bitmap wider // For odd pixel differences, widen rightwards by extra pixel MILLIPOINT ExtraPixelWidth = (MILLIPOINT)(RequiredWidth - ProposedWidth); MILLIPOINT Decrement = (ExtraPixelWidth / 2) * ScaledPixelWidth; MILLIPOINT Increment = Decrement + ((ExtraPixelWidth % 2) * ScaledPixelWidth); // if there is a rotation involved we have to increase the height of the DocRect // otherwise we increase the width if (bRotated) { drOffBB.lo.y -= Decrement; drOffBB.hi.y += Increment; } else { drOffBB.lo.x -= Decrement; drOffBB.hi.x += Increment; } } if (ProposedHeight < (UINT32)RequiredHeight) { // make the bitmap taller // For odd pixel differences, stretch upwards by extra pixel MILLIPOINT ExtraPixelHeight = (MILLIPOINT)(RequiredHeight - ProposedHeight); MILLIPOINT Decrement = (ExtraPixelHeight / 2) * ScaledPixelWidth; MILLIPOINT Increment = Decrement + ((ExtraPixelHeight & 1) * ScaledPixelWidth); // if there is a rotation involved we have to increase the width of the DocRect // otherwise we increase the height if (bRotated) { drOffBB.lo.x -= Decrement; drOffBB.hi.x += Increment; } else { drOffBB.lo.y -= Decrement; drOffBB.hi.y += Increment; } } pAttr->SetOffscreenBoundingRect(drOffBB); //--------------------------------------------- // Now startup the offscreen capture... // // If a non-mix attribute is already in scope we must not start capturing transparently // because transparent bitmaps can't render non-mix transparencies correctly // (See SetTranspFillGeometry and ChangeCapture) // // If the Master Capture is itself Transparent, then there's nothing we can do to grab // any non-mix transparencies correctly so test that first (typical case: Create Bitmap Copy) // BOOL bStartTransparently = FALSE; if (LockedTransparentCaptures()) bStartTransparently = TRUE; else { TranspFillAttribute* pTransAttr = (TranspFillAttribute *) GetCurrentAttribute(ATTR_TRANSPFILLGEOMETRY); UINT32 ttype = pTransAttr->GetTranspType(); bStartTransparently = (ttype==TT_NoTranspType || ttype==TT_Mix); // Also, scan down into the tree and see whether this node has any non-mix that would // cause us to revert to non-transparent capture // Because it's (probably) quicker to scan the tree than to revert during rendering... // Urgh. NodeRenderableInk* pLinkedNode = pAttr->GetLinkedNode()->IsAnObject() ? (NodeRenderableInk*)pAttr->GetLinkedNode() : NULL; bStartTransparently = bStartTransparently && !(pLinkedNode && pLinkedNode->ContainsNonMixTransparency(this)); } Capture* pCapture = StartCapture(pAttr, drOffBB, CAPTUREINFO(ctNESTABLE, cfNONE + cfDEBUG), // Don't allow collapse to master bitmap, CollapseToMaster=0 bStartTransparently, !bStartTransparently ); if (pCapture==NULL) return; // Save pointer to OffscreenAttr, and move current OffscreenAttr to the attr context stack // RenderRegion::SetOffscreen(pAttr); // Push the current offscreen attribute onto the stack, and install the new attribute as // the 'current' one. (taken from RenderRegion::SaveAttribute) // NB I can't imagine a circumstance where you would want to render a Temp offscreen // attribute so I am forcing Temp = FALSE here if (TheStack.Push((AttributeValue*)CurrentOffscreenAttr, FALSE)) CurrentOffscreenAttr = pAttr; }

virtual void RenderRegion::SetOSDrawingMode (   )  [protected, pure virtual]

Implemented in AIEPSGradientScanRenderRegion, ImagemapRenderRegion, FormatRegion, ScanningRenderRegion, VectorFileRenderRegion, XPFRenderRegion, GRenderRegion, and OSRenderRegion.

void RenderRegion::SetPrintOnAllPlates (  PrintOnAllPlatesAttrValue *  NewAttr, BOOL  Temp )  [virtual]

Set the PrintOnAllPlates state, pushing the current "print on all plates" attribute onto the context stack. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 30/7/96 Parameters: NewAttr  - The new PrintOnAllPlatesAttrValue you want to set current [INPUTS] Temp - TRUE if this is a temporary object which the render region should delete when finished with it; FALSE if someone else will delete it (i.e. it's in the document tree) See also: RenderRegion::RestorePrintOnAllPlates Definition at line 2466 of file rndrgn.cpp. { // Set the new Overprint state SaveAttribute(ATTR_PRINTONALLPLATES, NewAttr, Temp); // And make sure the current line colour attribute is affected by the new state StrokeColourAttribute *NewLineCol = PrepareLineColour(); if (NewLineCol != NULL) SetLineColour(NewLineCol, TRUE); // And make sure the current fill colour attribute is affected by the new state ColourFillAttribute *NewFillGeometry = PrepareFillGeometry(); if (NewFillGeometry != NULL) SetFillGeometry(NewFillGeometry, TRUE); }

void RenderRegion::SetQuality (  QualityAttribute *  pAttr, BOOL  Temp )  [virtual]

Set the current display quality according to an AttributeValue object, pushing the current quality onto the context stack. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 12/04/94 Parameters: pAttr  - the object specifying the quality to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::RestoreQuality Definition at line 3608 of file rndrgn.cpp. { // Set up the new attribute SaveAttribute(ATTR_QUALITY, pAttr, Temp); RRQuality = pAttr->QualityValue; // The render region's rendering objects need to be reset before drawing anything. SetQualityLevel(); }

void RenderRegion::SetQualityLevel (  void   )  [protected, 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 in ImagemapRenderRegion, FormatRegion, ScanningRenderRegion, VectorFileRenderRegion, XPFRenderRegion, GRenderRegion, and OSRenderRegion. Definition at line 3659 of file rndrgn.cpp. { }

BOOL RenderRegion::SetRenderComplexShapes (  BOOL  NewState  )

This function sets the state of the flag RenderComplexShapes. This flag is used by some classes of render region to decide what shapes to draw. If the flag is TRUE, then all shapes will be drawn that are asked to be drawn. If it is FALSE, only the shapes that are not considered to be complex by the render region will rendered. OSRenderRegions use this, as they can be used as part of the 3 phase rendering system that needs to render only specific nodes. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 25/4/95 Parameters: NewState  - The new state for the RenderComplexShapes flag [INPUTS] Returns: The old state of the flag See also: RenderRegion::TestForComplexShape Definition at line 6717 of file rndrgn.cpp. { // make a note of the old value BOOL OldValue = RenderComplexShapes; // Set it to the new value RenderComplexShapes = NewState; // return the old value return OldValue; }

void RenderRegion::SetRenderState (  Node *  RenderState  )  [inline]

Reimplemented in ScanningRenderRegion. Definition at line 427 of file rndrgn.h. { CurrentRenderState = RenderState; }

virtual BOOL RenderRegion::SetRenderToCapture (  Capture *  pCapture, BOOL  ApplyClipRegion, BOOL  bSetBitmap )  [inline, protected, virtual]

Reimplemented in GRenderRegion. Definition at line 766 of file rndrgn.h. {return TRUE;}

virtual BOOL RenderRegion::SetSmoothingFlags (  FillGeometryAttribute *  Fill  )  [inline, virtual]

Reimplemented in GRenderRegion. Definition at line 719 of file rndrgn.h. {return TRUE;}

virtual void RenderRegion::SetSolidColours (  BOOL  SetSolid  )  [inline, virtual]

Reimplemented in GRenderRegion, and OSRenderRegion. Definition at line 580 of file rndrgn.h. {}

void RenderRegion::SetStartArrow (  ArrowRec &  NewStartArrow  )

Set the current StartArrow according to an AttributeValue object, pushing the current Arrow the context stack. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 5/4/95 Parameters: NewStartArrow,the  new Arrow to draw on the start of lines. [INPUTS] See also: RenderRegion::RestoreStartArrow Definition at line 3747 of file rndrgn.cpp. { // Don't bother if it doesn't cause a change StartArrowAttribute *pAttr = (StartArrowAttribute *) CurrentAttrs[ATTR_STARTARROW].pAttr; if ((pAttr != NULL) && (pAttr->StartArrow == NewStartArrow)) return; // Create a temporary attribute and use it to set the Start Arrow. pAttr = new StartArrowAttribute(); pAttr->StartArrow = NewStartArrow; SetStartArrow(pAttr, TRUE); }

void RenderRegion::SetStartArrow (  StockArrow  NewStartArrow  )

Set the current StartArrow according to an AttributeValue object, pushing the current Arrow the context stack. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 5/4/95 Parameters: NewStartArrow,the  new Arrow to draw on the start of lines. [INPUTS] See also: RenderRegion::RestoreStartArrow Definition at line 3721 of file rndrgn.cpp. { // Don't bother if it doesn't cause a change StartArrowAttribute *pAttr = (StartArrowAttribute *) CurrentAttrs[ATTR_STARTARROW].pAttr; if ((pAttr != NULL) && (pAttr->StartArrow == NewStartArrow)) return; // Create a temporary attribute and use it to set the Start Arrow. pAttr = new StartArrowAttribute(); pAttr->StartArrow = NewStartArrow; SetStartArrow(pAttr, TRUE); }

void RenderRegion::SetStartArrow (  StartArrowAttribute *  pAttr, BOOL  Temp )  [virtual]

Set the current StartArrow according to an AttributeValue object, pushing the current StartArrow the context stack. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 5/4/95 Parameters: pAttr  - the object specifying the dash pattern to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::RestoreStartArrow Definition at line 3775 of file rndrgn.cpp. { // Set up the new attribute if (SaveAttribute(ATTR_STARTARROW, pAttr, Temp)) { // The line attributes need to be reset before drawing anything. SetLineAttributes(CHANGEATTR_STARTARROW); } }

void RenderRegion::SetStartCap (  LineCapType  NewStartCap  )

Set the current Line Cap according to an AttributeValue object, pushing the current LineCap the context stack. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 5/4/95 Parameters: NewStartCap,the  new LineCap Type to cap lines with. [INPUTS] See also: RenderRegion::RestoreStartCap Definition at line 3438 of file rndrgn.cpp. { // Don't bother if it doesn't cause a change StartCapAttribute *pAttr = (StartCapAttribute *) CurrentAttrs[ATTR_STARTCAP].pAttr; if ((pAttr != NULL) && (NewStartCap == pAttr->StartCap)) return; // Create a temporary attribute and use it to set the Start Cap. pAttr = new StartCapAttribute(); pAttr->StartCap = NewStartCap; SetStartCap(pAttr, TRUE); }

void RenderRegion::SetStartCap (  StartCapAttribute *  pAttr, BOOL  Temp )  [virtual]

Set the current Line Cap according to an AttributeValue object, pushing the current LineCap the context stack. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 5/4/95 Parameters: pAttr  - the object specifying the dash pattern to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::RestoreStartCap Definition at line 3466 of file rndrgn.cpp. { // Set up the new attribute if (SaveAttribute(ATTR_STARTCAP, pAttr, Temp)) { // The line attributes need to be reset before drawing anything. SetLineAttributes(CHANGEATTR_LINECAP); } }

virtual void RenderRegion::SetStoredCount (  INT64  llcount  )  [inline, virtual]

Definition at line 408 of file rndrgn.h. {m_countStored = llcount;}

void RenderRegion::SetStrokeType (  StrokeTypeAttrValue *  pAttr, BOOL  Temp )  [virtual]

Set the current Stroke Type according to an AttributeValue object, pushing the current Stroke Type onto the context stack. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 7/1/97 Parameters: pAttr  - the object specifying the colour to use. [INPUTS] Temp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::RestoreStrokeType Definition at line 2733 of file rndrgn.cpp. { SaveAttribute(ATTR_STROKETYPE, pAttr, Temp); }

void RenderRegion::SetSubRenderState (  SubRenderContext *  SubRenderState  )  [inline]

Definition at line 435 of file rndrgn.h. { ERROR3IF(SubRenderStateLocked && SubRenderState != NULL, "Oi! No!"); CurrentSubRenderState = SubRenderState; if (SubRenderState == NULL) SubRenderStateLocked = FALSE; }

void RenderRegion::SetTextAttributes (  ChangeFillAttrType  Type = CHANGEFILLATTR_ALL  )  [protected, virtual]

Inform the render region that an aspect of the path filling attributes has changed. The base class version just updates the RenderRegion member variable FillFlags to reflect which aspects of the fill attributes have become invalid. Derived render regions can either call the base class or just implement whatever methods they need for keeping track of these changes - or a combination of the two, of course. Some render regions (e.g. GRenderRegions) don't need to do anything about this at all as all attributes are invoked whenever anything is rendered. If this is the case, then this should be over-ridden to have a NULL implementation because this will improve rendering speed. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/94 Parameters: Type  - the type of the fill attribute that has changed, can be: [INPUTS] CHANGEATTR_ALL CHANGEATTR_GEOMETRY CHANGEATTR_EFFECT CHANGEATTR_MAPPING CHANGEATTR_TRANSP_GEOMETRY CHANGEATTR_TRANSP_EFFECT CHANGEATTR_TRANSP_MAPPING CHANGEATTR_WINDING_RULE See also: ChangeAttrType Definition at line 1440 of file rndrgn.cpp. { switch (Type) { case CHANGEFILLATTR_ALL: TextFlags.ValidFont = FALSE; TextFlags.ValidBold = FALSE; TextFlags.ValidItalic = FALSE; TextFlags.ValidUnderline = FALSE; TextFlags.ValidAspect = FALSE; TextFlags.ValidTracking = FALSE; TextFlags.ValidFontSize = FALSE; TextFlags.ValidJustify = FALSE; TextFlags.ValidScript = FALSE; TextFlags.ValidBaseLine = FALSE; TextFlags.ValidLineSpace = FALSE; TextFlags.ValidLeftMargin = FALSE; TextFlags.ValidRightMargin = FALSE; TextFlags.ValidFirstIndent = FALSE; TextFlags.ValidRuler = FALSE; break; case CHANGEATTR_FONT: TextFlags.ValidFont = FALSE; break; case CHANGEATTR_BOLD: TextFlags.ValidBold = FALSE; break; case CHANGEATTR_ITALIC: TextFlags.ValidItalic = FALSE; break; case CHANGEATTR_UNDERLINE: TextFlags.ValidUnderline = FALSE; break; case CHANGEATTR_ASPECT: TextFlags.ValidAspect = FALSE; break; case CHANGEATTR_TRACKING: TextFlags.ValidTracking = FALSE; break; case CHANGEATTR_SIZE: TextFlags.ValidFontSize = FALSE; break; case CHANGEATTR_JUSTIFY: TextFlags.ValidJustify = FALSE; break; case CHANGEATTR_SCRIPT: TextFlags.ValidScript = FALSE; break; case CHANGEATTR_BASELINE: TextFlags.ValidBaseLine = FALSE; break; case CHANGEATTR_LINESPACE: TextFlags.ValidLineSpace = FALSE; break; case CHANGEATTR_LEFTMARGIN: TextFlags.ValidLeftMargin = FALSE; break; case CHANGEATTR_RIGHTMARGIN: TextFlags.ValidRightMargin = FALSE; break; case CHANGEATTR_FIRSTINDENT: TextFlags.ValidFirstIndent = FALSE; break; case CHANGEATTR_RULER: TextFlags.ValidRuler = FALSE; break; default: ERROR3_PF(("Invalid attribute type (%d) in SetFillAttributes", Type)); break; } }

void RenderRegion::SetTranspFillGeometry (  TranspFillAttribute *  pAttr, BOOL  Temp )  [virtual]

Set the current fill type according to an AttributeValue object, pushing the current fill type onto the context stack. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 23/8/94 Parameters: pAttr  - the object specifying the fill type to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::RestoreFillType; RenderRegion::SetFillColour Definition at line 3055 of file rndrgn.cpp. { TranspFillAttribute* pNewAttr = NULL; if (m_bForceMix) { UINT32 Type = pAttr->GetTranspType(); if (Type != TT_NoTranspType && Type != TT_Mix && Type != TT_DARKEN && Type != TT_LIGHTEN && Type != TT_BRIGHTNESS && Type != TT_BEVEL) { if (Temp) { pNewAttr = pAttr; } else { pNewAttr = (TranspFillAttribute*)(pAttr->GetRuntimeClass()->CreateObject()); if (pNewAttr) { pNewAttr->SimpleCopy(pAttr); } } } } if (pNewAttr) { pNewAttr->SetTranspType(TT_Mix); Temp = TRUE; } else pNewAttr = pAttr; // Save the current attribute if (SaveAttribute(ATTR_TRANSPFILLGEOMETRY, pNewAttr, Temp)) { // The fill attributes need to be reset before drawing anything. SetFillAttributes(CHANGEATTR_TRANSP_GEOMETRY); // The capture system needs to know about non-MIX transparencies being set // because it can't capture them in RGBT bitmaps... UINT32 ttype = pNewAttr->GetTranspType(); ERROR3IF(ttype<TT_NoTranspType || ttype>TT_MAX, "Someone's trying to set an unknown transp type!"); // if (!(ttype==TT_NoTranspType || ttype==TT_Mix)) if (!TranspTypeIsRGBTCompatible(ttype)) { ChangeCapture(CAPTUREINFO(ctREUSE, cfCOLLAPSETOMASTER), FALSE, TRUE); } } }

void RenderRegion::SetTranspFillMapping (  TranspFillMappingAttribute *  pAttr, BOOL  Temp )  [virtual]

Set the current fill type according to an AttributeValue object, pushing the current fill type onto the context stack. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 23/8/94 Parameters: pAttr  - the object specifying the fill type to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::RestoreFillType; RenderRegion::SetFillColour Definition at line 3149 of file rndrgn.cpp. { // Save the current attribute if (SaveAttribute(ATTR_TRANSPFILLMAPPING, pAttr, Temp)) { // The fill attributes need to be reset before drawing anything. SetFillAttributes(CHANGEATTR_TRANSP_MAPPING); } }

void RenderRegion::SetTxtAspectRatio (  TxtAspectRatioAttribute *  pAttr, BOOL  Temp )  [virtual]

Set the current Text Aspect Ratio according to an AttributeValue object, pushing the current Aspect Ratio onto the context stack. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/03/95 Parameters: pAttr  - the object specifying the colour to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::RestoreTxtAspectRatio Definition at line 4407 of file rndrgn.cpp. { // Save the current attribute and set up the new one if (SaveAttribute(ATTR_TXTASPECTRATIO, (AttributeValue*)pAttr, Temp)) { SetTextAttributes(CHANGEATTR_ASPECT); } }

void RenderRegion::SetTxtBaseLine (  TxtBaseLineAttribute *  pAttr, BOOL  Temp )  [virtual]

Set the current Text BaseLine according to an AttributeValue object, pushing the current BaseLine onto the context stack. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/03/95 Parameters: pAttr  - the object specifying the colour to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::RestoreTxtBaseLine Definition at line 4594 of file rndrgn.cpp. { // Save the current attribute and set up the new one if (SaveAttribute(ATTR_TXTBASELINE, (AttributeValue*)pAttr, Temp)) { SetTextAttributes(CHANGEATTR_BASELINE); } }

void RenderRegion::SetTxtBold (  TxtBoldAttribute *  pAttr, BOOL  Temp )  [virtual]

Set the current Text Boldness according to an AttributeValue object, pushing the current Boldness onto the context stack. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/03/95 Parameters: pAttr  - the object specifying the colour to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::RestoreTxtBold Definition at line 4218 of file rndrgn.cpp. { // Save the current attribute and set up the new one if (SaveAttribute(ATTR_TXTBOLD, (AttributeValue*)pAttr, Temp)) { SetTextAttributes(CHANGEATTR_BOLD); } }

void RenderRegion::SetTxtFirstIndent (  TxtFirstIndentAttribute *  , BOOL  Temp )  [virtual]

Definition at line 4715 of file rndrgn.cpp. { // Save the current attribute and set up the new one if (SaveAttribute(ATTR_TXTFIRSTINDENT, (AttributeValue*)pAttr, Temp)) { SetTextAttributes(CHANGEATTR_FIRSTINDENT); } }

void RenderRegion::SetTxtFontSize (  TxtFontSizeAttribute *  pAttr, BOOL  Temp )  [virtual]

Set the current Font Size according to an AttributeValue object, pushing the current font size state onto the context stack. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 13/03/95 Parameters: pAttr  - the object specifying the font size to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. Definition at line 4311 of file rndrgn.cpp. { // Save the current attribute and set up the new one if (SaveAttribute(ATTR_TXTFONTSIZE, (AttributeValue*)pAttr, Temp)) { SetTextAttributes(CHANGEATTR_SIZE); } }

void RenderRegion::SetTxtFontTypeface (  TxtFontTypefaceAttribute *  pAttr, BOOL  Temp )  [virtual]

Set the current Text Font Typeface according to an AttributeValue object, pushing the current Font Typeface onto the context stack. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/03/95 Parameters: pAttr  - the object specifying the colour to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::RestoreTxtFontTypeface Definition at line 4170 of file rndrgn.cpp. { // Save the current attribute and set up the new one if (SaveAttribute(ATTR_TXTFONTTYPEFACE, (AttributeValue*)pAttr, Temp)) { SetTextAttributes(CHANGEATTR_FONT); } }

void RenderRegion::SetTxtItalic (  TxtItalicAttribute *  pAttr, BOOL  Temp )  [virtual]

Set the current Text Italicness according to an AttributeValue object, pushing the current Italicness onto the context stack. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/03/95 Parameters: pAttr  - the object specifying the colour to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::RestoreTxtItalic Definition at line 4265 of file rndrgn.cpp. { // Save the current attribute and set up the new one if (SaveAttribute(ATTR_TXTITALIC, (AttributeValue*)pAttr, Temp)) { SetTextAttributes(CHANGEATTR_ITALIC); } }

void RenderRegion::SetTxtJustification (  TxtJustificationAttribute *  pAttr, BOOL  Temp )  [virtual]

Set the current Text Justification according to an AttributeValue object, pushing the current Justification onto the context stack. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/03/95 Parameters: pAttr  - the object specifying the colour to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::RestoreTxtJustification Definition at line 4453 of file rndrgn.cpp. { // Save the current attribute and set up the new one if (SaveAttribute(ATTR_TXTJUSTIFICATION, (AttributeValue*)pAttr, Temp)) { SetTextAttributes(CHANGEATTR_JUSTIFY); } }

void RenderRegion::SetTxtLeftMargin (  TxtLeftMarginAttribute *  pAttr, BOOL  Temp )  [virtual]

See other Set/Restore routines above. Author: Martin Wuerthner <xara@mw-software.com> Date: 13/06/06 Parameters: See  other Set/Restore routines above [INPUTS] Definition at line 4683 of file rndrgn.cpp. { // Save the current attribute and set up the new one if (SaveAttribute(ATTR_TXTLEFTMARGIN, (AttributeValue*)pAttr, Temp)) { SetTextAttributes(CHANGEATTR_LEFTMARGIN); } }

void RenderRegion::SetTxtLineSpace (  TxtLineSpaceAttribute *  pAttr, BOOL  Temp )  [virtual]

Set the current Text LineSpace according to an AttributeValue object, pushing the current LineSpace onto the context stack. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/03/95 Parameters: pAttr  - the object specifying the colour to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::RestoreTxtLineSpace Definition at line 4641 of file rndrgn.cpp. { // Save the current attribute and set up the new one if (SaveAttribute(ATTR_TXTLINESPACE, (AttributeValue*)pAttr, Temp)) { SetTextAttributes(CHANGEATTR_LINESPACE); } }

void RenderRegion::SetTxtRightMargin (  TxtRightMarginAttribute *  , BOOL  Temp )  [virtual]

Definition at line 4699 of file rndrgn.cpp. { // Save the current attribute and set up the new one if (SaveAttribute(ATTR_TXTRIGHTMARGIN, (AttributeValue*)pAttr, Temp)) { SetTextAttributes(CHANGEATTR_RIGHTMARGIN); } }

void RenderRegion::SetTxtRuler (  TxtRulerAttribute *  , BOOL  Temp )  [virtual]

Definition at line 4731 of file rndrgn.cpp. { // Save the current attribute and set up the new one if (SaveAttribute(ATTR_TXTRULER, (AttributeValue*)pAttr, Temp)) { SetTextAttributes(CHANGEATTR_RULER); } }

void RenderRegion::SetTxtScript (  TxtScriptAttribute *  pAttr, BOOL  Temp )  [virtual]

Set the current Text Script according to an AttributeValue object, pushing the current Script onto the context stack. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 11/04/95 Parameters: pAttr  - the object specifying the colour to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::RestoreTxtScript Definition at line 4547 of file rndrgn.cpp. { // Save the current attribute and set up the new one if (SaveAttribute(ATTR_TXTSCRIPT, (AttributeValue*)pAttr, Temp)) { SetTextAttributes(CHANGEATTR_SCRIPT); } }

void RenderRegion::SetTxtTracking (  TxtTrackingAttribute *  pAttr, BOOL  Temp )  [virtual]

Set the current Text Tracking according to an AttributeValue object, pushing the current Tracking onto the context stack. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/03/95 Parameters: pAttr  - the object specifying the colour to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::RestoreTxtTracking Definition at line 4499 of file rndrgn.cpp. { // Save the current attribute and set up the new one if (SaveAttribute(ATTR_TXTTRACKING, (AttributeValue*)pAttr, Temp)) { SetTextAttributes(CHANGEATTR_TRACKING); } }

void RenderRegion::SetTxtUnderline (  TxtUnderlineAttribute *  pAttr, BOOL  Temp )  [virtual]

Set the current Text Underline state according to an AttributeValue object, pushing the current Underline state onto the context stack. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 13/03/95 Parameters: pAttr  - the object specifying the colour to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. Definition at line 4361 of file rndrgn.cpp. { // Save the current attribute and set up the new one if (SaveAttribute(ATTR_TXTUNDERLINE, (AttributeValue*)pAttr, Temp)) { SetTextAttributes(CHANGEATTR_UNDERLINE); } }

void RenderRegion::SetupFuzzyClipRects (   )  [protected]

Sets up the fuzzy clipping rects, basing them on the CurrentClipRect. Don't ask me what they're used for - I'm just moving some useful code into a function :o). Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 01/08/2000 Definition at line 5998 of file rndrgn.cpp. { // Set up the Fuzzy Clipping Rects. if (!CurrentClipRect.IsValid()) return; // Inner rect is used to clip with, so we need to make it bigger than the region so that // things like thick lines do not show up. InnerRect = CurrentClipRect; INT32 ScaleBy = (RR_LINEWIDTH()/2) + 16 * ScaledPixelWidth; InnerRect.Inflate(ScaleBy, ScaleBy); if (!InnerRect.IsValid()) return; // The outer rect is used to determine if clipping is needed, so make it // a few times bigger than the inner rect. OuterRect = InnerRect; OuterRect.Inflate(InnerRect.Width()*3, InnerRect.Height()*3); }

void RenderRegion::SetUsingSmoothedBitmaps (  BOOL  set  )  [inline]

Definition at line 460 of file rndrgn.h. { RenderFlags.SmoothedBitmaps = set; }

void RenderRegion::SetVariableWidth (  VariableWidthAttrValue *  pAttr, BOOL  Temp )  [virtual]

Set the current VariableWidth according to an AttributeValue object, pushing the current VariableWidth onto the context stack. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 7/1/97 Parameters: pAttr  - the object specifying the colour to use. [INPUTS] Temp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::RestoreVariableWidth Definition at line 2782 of file rndrgn.cpp. { SaveAttribute(ATTR_VARWIDTH, pAttr, Temp); }

void RenderRegion::SetWebAddress (  WebAddressAttribute *  pAttr, BOOL  Temp )  [virtual]

Set the current WebAddress. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 18/3/97 Parameters: pAttr  - pointer to a Web Address to set [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. This attribute has no effect on rendering, so there's no need to change anything in the rendering system itself when we do this. See also: RenderRegion::RestoreWebAddress Definition at line 3681 of file rndrgn.cpp. { // Set up the new attribute SaveAttribute(ATTR_WEBADDRESS, (AttributeValue*) pAttr, Temp); }

void RenderRegion::SetWindingRule (  WindingType  NewWindingRule  )

Set the winding rule, pushing the current winding rule onto the context stack. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 12/04/94 Parameters: NewWindingRule  - the winding rule to use. [INPUTS] See also: RenderRegion::RestoreWindingRule Definition at line 3999 of file rndrgn.cpp. { // Don't bother if it doesn't cause a change WindingRuleAttribute *pAttr = (WindingRuleAttribute *) CurrentAttrs[ATTR_WINDINGRULE].pAttr; if ((pAttr != NULL) && (NewWindingRule == pAttr->WindingRule)) return; // Create a temporary attribute and use it to set the drawing mode pAttr = new WindingRuleAttribute(NewWindingRule); SetWindingRule(pAttr, TRUE); }

void RenderRegion::SetWindingRule (  WindingRuleAttribute *  pAttr, BOOL  Temp )  [virtual]

Set the current winding rule according to an AttributeValue object, pushing the current winding rule onto the context stack. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 12/04/94 Parameters: pAttr  - the object specifying the winding rule to use. [INPUTS] Tmp - indicates if pAttr points to a temporary attribute that should be deleted when it's finished with. See also: RenderRegion::RestoreWindingRule Definition at line 4027 of file rndrgn.cpp. { // Save the current attribute if (SaveAttribute(ATTR_WINDINGRULE, pAttr, Temp)) { // The fill attributes need to be reset before drawing anything. SetFillAttributes(CHANGEATTR_WINDING_RULE); } }

Capture * RenderRegion::StartCapture (  CCObject *  pOwner, DocRect  CaptureRect, CAPTUREINFO  cinfo, BOOL  bTransparent = TRUE, BOOL  bCaptureBackground = FALSE, double  dPPI = 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 in GRenderRegion. Definition at line 7407 of file rndrgn.cpp. { ENSURE(cinfo.caType==ctNESTABLE, "We only support nestable captures at the moment\n"); // 1) alloc new mem, and setup state variables for new offscreen rendering // mem alloced = bmp // vars setup = docrect, gmatrix // 2) save current // 3) change to new offscreen state // If there's already a capture running and this one is nested but wants to change // the transparency type then we must notify existing captures of the change... Capture* pCurrentCapture = GetTopCapture(); if (pCurrentCapture!=NULL && cinfo.caType==ctNESTABLE && !cinfo.caFlags.GrabRendered && pCurrentCapture->IsTransparent() && !bTransparent) { ChangeCapture(cinfo, bTransparent, bCaptureBackground); } // If the caller didn't specify the capture resolution in pixels per inch // Then set it to the default value of the render region // And use the default matrix in our setup calculations Matrix CaptureMatrix; if (dPPI==0) { // dPPI = GetPixelsPerInch(); // Find current top bitmap capture and copy its res and res scale control flag Capture* pCap = GetTopCapture(); ERROR2IF(pCap==NULL, NULL, "There MUST be a bitmap capture in the stack - the master capture at least"); dPPI = pCap->dPixelsPerInch; cinfo.caFlags.CalcScaledPixWidth = pCap->info.caFlags.CalcScaledPixWidth; CaptureMatrix = RenderMatrix; } else { // If the caller specified a particular DPI we will assume he wants the capture // to grab the rendered objects at 100% scale... // No need to construct a new matrix in a complex way - the clip rect and // object are all stored in doccoords. // CaptureMatrix = Identity; } // In non-Master Captures, make sure that we use a default colour context // to prevent multiple colour corrections when rendering bitmaps in "print preview" // type modes... ColourContext* pColContext = NULL; if (!cinfo.caFlags.Master) { BOOL bOldForce = RenderView->SetForceDefaultColourContexts(); pColContext = RenderView->GetColourContext(COLOURMODEL_RGBT); RenderView->SetForceDefaultColourContexts(bOldForce); } else { // Must get RenderRegion's current colour context for Master Capture pColContext = CurrentColContext; } // Create a new capture instance... Capture* pNewCapture = new Capture(pOwner, cinfo, CaptureMatrix, CaptureRect, dPPI, pColContext); ENSURE(!pNewCapture->IsMaster(), "Can only have one master capture!"); m_CaptureStack.Push(pNewCapture); return pNewCapture; }

BOOL RenderRegion::StartRender (  void   )  [virtual]

Initialises the device attachment, if we haven't already done so for this render region. This is so that we can have a two-stage attachment of a device to a render region. This allows us to create render regions very quickly, which makes background rendering more efficient as quite often we will just throw them away without ever needing a proper connection to the device context. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 27/05/94 See also: RenderRegion::AttachDevice; RenderRegion::InitDevice Reimplemented in ArtWorksEPSRenderRegion, CamelotEPSRenderRegion, MaskedRenderRegion, PrintPSRenderRegion, ScanningRenderRegion, VectorFileRenderRegion, XPFRenderRegion, GRenderBitmap, GRenderClick, GRenderClickColour, GRenderPrint, GRenderRegion, and OSRenderRegion. Definition at line 1173 of file rndrgn.cpp. { // If the device has not been Inited, then do it now if (!RenderFlags.ValidDevice) { // Device needs to be initialised if (!InitDevice()) { // Something's gone wrong - inform the user. //InformSeriousError(); TRACE( _T("InitDevice failed in Render Region (Could be not enough mem for Gdraw bitmap)")); return FALSE; } // Make sure we don't do this again for this render region RenderFlags.ValidDevice = TRUE; } // Set up the Fuzzy Clipping Rects // Inner rect is used to clip with, so we need to make it bigger than the region so that // things like thick lines do not show up InnerRect = CurrentClipRect; INT32 ScaleBy = 1000*ScaledPixelWidth; InnerRect.Inflate(ScaleBy, ScaleBy); // The outer rect is used to determine if clipping is needed, so make it // a few times bigger than the inner rect OuterRect = InnerRect; OuterRect.Inflate(InnerRect.Width()*3, InnerRect.Height()*3); // Create the default, master capture... Capture* pNewMasterCapture = NULL; if (m_CaptureStack.Empty()) { pNewMasterCapture = new Capture(this, CAPTUREINFO(ctNESTABLE, cfMASTER | cfPIXWIDTHSCALE), RenderMatrix, CurrentClipRect, GetPixelsPerInch(), CurrentColContext); // NOTE! Use of ScaledPixelWidth in GetPixelsPerInch in RenderRegion! if (pNewMasterCapture==NULL) return FALSE; m_CaptureStack.Push(pNewMasterCapture); } return TRUE; }

BOOL RenderRegion::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 in GRenderRegion. Definition at line 7505 of file rndrgn.cpp. { Capture* pCapture = GetTopCapture(); if (pCapture==NULL) return FALSE; if (pCapture->IsMaster()) { ERROR2(FALSE, "StopCapture called on the master capture!\n"); return FALSE; } // Pop the capture off the stack now m_CaptureStack.Pop(); delete pCapture; return TRUE; }

virtual BOOL RenderRegion::StopRender (   )  [pure virtual]

Implemented in AIEPSGradientScanRenderRegion, CamelotEPSRenderRegion, ImagemapRenderRegion, FormatRegion, PrintPSRenderRegion, ScanningRenderRegion, VectorFileRenderRegion, XPFRenderRegion, GRenderPrint, GRenderRegion, and OSRenderRegion.

BOOL RenderRegion::TestForComplexShape (  RRCaps *  pCaps  )

This function is called whenever someone calls one of the primitive render functions in a ScanningRenderRegion. This takes a look at all the attributes (and anything else it might need to) to see if this represents a complex shape or not. If it is a complex shape, all the internal data members of the render region are updated accordingly. This function makes use of the RRCaps object that was set with the SetHostRRCaps() function to see what things the Host render region considers to be complex. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 10/4/95 Returns: TRUE if the current state of the attributes make this a complex shape. FALSE if the host render region could render this with no trouble See also: SetHostRRCaps() Definition at line 6469 of file rndrgn.cpp. { // we will start off assuming that this is not a complex shape we are trying to draw BOOL IsComplex = FALSE; // If we are in very low quality mode then assume everything is simple if (RRQuality.GetFillQuality() <= Quality::Bitmaps) return FALSE; if (pCaps->DoesRegionDoNothing()) return TRUE; // if the host rr can not do transparancy, then see if there is any if (!pCaps->Transparency) { // Find out about the transparancy attribute TranspFillAttribute* pTransAttr = RR_FILLTRANSP(); UINT32 Type = pTransAttr->GetTranspType(); UINT32* pAmount1 = pTransAttr->GetStartTransp(); // This may be a grad fill transp // we will get ready for this by setting up a var for the end transp UINT32 DefaultAmount = 0; UINT32* pAmount2 = &DefaultAmount; UINT32* pAmount3 = &DefaultAmount; UINT32* pAmount4 = &DefaultAmount; // get the end point transparencies (if there are any) if (pTransAttr->GetEndTransp()) pAmount2 = pTransAttr->GetEndTransp(); if (pTransAttr->GetEndTransp2()) pAmount3 = pTransAttr->GetEndTransp2(); if (pTransAttr->GetEndTransp3()) pAmount4 = pTransAttr->GetEndTransp3(); // See if there is any transparency in it if ((Type != 1) || (*pAmount1 > 1) || (*pAmount2 > 1) || (*pAmount3 > 1) || (*pAmount4 > 1)) { // we found something that might be a bit transparent IsComplex = TRUE; } // CGS could - check for transparency profiling here as well // BUT these no point, since if were dealing with transparency, // then IsComplex will have just been set to TRUE by the above, which will cause us // to be rendered correctly anyway .... // Get the current fill attr FillGeometryAttribute* pFillAttr = (FillGeometryAttribute*) CurrentAttrs[ATTR_FILLGEOMETRY].pAttr; if (!IsComplex) { if (pFillAttr->GetBitmap() != NULL) { KernelBitmap* pBmp = pFillAttr->GetBitmap(); if (pBmp && pBmp->IsTransparent()) IsComplex = TRUE; } } // now check for colour ramp .... if (!IsComplex) { // if there is a colour ramp, then the shape is complex .... if (pFillAttr->GetColourRamp () != NULL) { IsComplex = TRUE; } } // now lets check for fill profiling .... CProfileBiasGain DefaultBiasGain; if (!(pFillAttr->GetProfile () == DefaultBiasGain)) { IsComplex = TRUE; } } // If it is not complex yet, and we can't do bitmaps, see if we can do them if ((!IsComplex) && (!pCaps->BitmapFills || !pCaps->PerspectiveBitmapFills)) { // Get the current fill attr ColourFillAttribute* pFillAttr = (ColourFillAttribute*) CurrentAttrs[ATTR_FILLGEOMETRY].pAttr; // see if it is a bitmap fill, and if it is, mark the shape as complex if (pFillAttr->IS_KIND_OF(BitmapFillAttribute)) { // First check for the simple case of clipped bitmaps, as opposed to tiled // bitmap fills. FillMappingAttribute* pMapAttr = (FillMappingAttribute*) CurrentAttrs[ATTR_FILLMAPPING].pAttr; if ((pMapAttr->Repeat == 1) && (pCaps->ClippedSimpleBitmaps || pCaps->ClippedArbitraryBitmaps)) { // 'Simple' bitmap fill - is it a simple stretch, or has it been // arbitrarily transformed? if (!pCaps->ClippedArbitraryBitmaps) { // Here we check the start and end points - the default arrangement is this: // // EndPoint2 // ^ // | // | // | // | // +-----------> EndPoint // StartPoint // // So we check that the start and end points are aligned in the y axis, // and then check that the start and second end point are aligned in // the x axis. // DocCoord Geometry[3]; Geometry[0] = *(pFillAttr->GetStartPoint()); Geometry[1] = *(pFillAttr->GetEndPoint()); Geometry[2] = *(pFillAttr->GetEndPoint2()); if ((Geometry[0].x != Geometry[2].x) || (Geometry[0].y != Geometry[1].y)) { // It's not a simple stretch - we can't do it! IsComplex = TRUE; } } } else { if (!pCaps->BitmapFills) // We can't do bitmap fills! IsComplex = TRUE; else if (pFillAttr->IsPerspective() && !pCaps->PerspectiveBitmapFills) // Bitmap fill is perspectivised, and we can't do that. IsComplex = TRUE; } } } // If it is not complex yet, and we can't do Grad Fills, see if we can do them if ((!IsComplex) && (!pCaps->GradFills || !pCaps->PerspectiveGradFills || !pCaps->Grad3and4Fills)) { // Get the current fill attr ColourFillAttribute* pFillAttr = (ColourFillAttribute*) CurrentAttrs[ATTR_FILLGEOMETRY].pAttr; FillMappingAttribute* pMapAttr = (FillMappingAttribute*) CurrentAttrs[ATTR_FILLMAPPING].pAttr; // see if it is a graduated fill, and if it is, mark the shape as complex if (pFillAttr->IsAGradFill()) { if (!pCaps->GradFills) // We just can't do graduated fills IsComplex = TRUE; else if (pFillAttr->IsPerspective() && !pCaps->PerspectiveGradFills) // It's perspectivised, and we can't do that. IsComplex = TRUE; else if (pFillAttr->IsASquareFill() && !pCaps->Grad3and4Fills) // We use the same flag rather than put a new one in as this fill type // will probably be supported soon IsComplex = TRUE; else if (pFillAttr->IsAThreeColFill() && !pCaps->Grad3and4Fills) IsComplex = TRUE; //Mark Howitt, 13/10/97. If the fill is a new repeating grad fill, then that`s really complex! else if (pMapAttr->Repeat == 4) IsComplex = TRUE; //CGS, 24/5/2000 Need to do this for the new multi-stage and profiled fills as well .... // now check for colour ramp .... // if there is a colour ramp, then the shape is real complex .... else if (pFillAttr->GetColourRamp () != NULL) { IsComplex = TRUE; } // now check for fill profiling .... else { CProfileBiasGain DefaultBiasGain; // if their not identical, then were complex! if (!(pFillAttr->GetProfile () == DefaultBiasGain)) { IsComplex = TRUE; } } } } // Test for offscreen attributes. // We currently do this for all RRs 'cept those which can do everything. if (!IsComplex && !pCaps->DoesRegionDoAll()) { OffscreenAttrValue* pOffAttr = CurrentOffscreenAttr; // we're complex if the current attr is not the default. if ( ! ((GeometryLinkedAttrValue*)pOffAttr)->IsDefaultFlagSet() ) IsComplex = TRUE; } // Test to see whether the RR can clip its output to an arbitrary path. // Currently, only GRenderRegion and PostScript RR's can do this. if (!IsComplex && !pCaps->ClippedOutput) { ClipRegionAttribute* pClipAttr = RR_CLIPREGION(); IsComplex = (pClipAttr->GetClipPath() != NULL); } // we seem to have problems printing variable width strokes, though the problem // goes away if they are transparent, so treat them as complex if (PathProcessorStack != NULL && PathProcessorStack->IsAPathProcessorStroke()) IsComplex = TRUE; // return what we found out return IsComplex; }

virtual BOOL RenderRegion::TranspTypeIsRGBTCompatible (  UINT32  ttype  )  const [inline, virtual]

Reimplemented in GRenderRegion. Definition at line 718 of file rndrgn.h. {return TRUE;} // Should be TranspType ttype

BOOL RenderRegion::TryToFuzzyClip (  Path *  pPath, DocCoord **  pNewCoords, PathVerb **  pNewVerbs, UINT32 *  NewNumCoords )  [protected]

This function works out if clipping is needed (based on scale factor etc) and tries to clip the paths. If it works it will return TRUE, meaning that you should only try to draw that path info found in pNewCoords etc. If FALSE is returned pNewCoords etc will all be NULL. If this function returns TRUE it will have allocated memory to put the new coords and verbs in. It will be your responsibility to delete this memory after you have rendered the path. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 9/3/95 Parameters: pPath  - The path to try to clip [INPUTS] pNewCoords  - The clipped coords that need rendering [OUTPUTS] pNewVerbs - The Clipped set of verbs NewNumCoords - The number of coords in this new clipped path Returns: TRUE if it needed to clip the path, FALSE if it did nothing Definition at line 5924 of file rndrgn.cpp. { // Start out by setting all the return values to something sensible *pNewCoords = NULL; *pNewVerbs = NULL; *NewNumCoords = 0; // Decide if we need to clip this path in order to draw it // Only bother if we are zoomed in a bit (400%) if (RenderView->GetViewScale() > FIXED16(4)) { // Make some new coords etc DocCoord* pOldCoords = pPath->GetCoordArray(); PathVerb* pOldVerbs = pPath->GetVerbArray(); size_t OldNumCoords = (size_t)pPath->GetNumCoords(); // Allow the new path to have a few extra points in it as this is possible. // If it gets to be more than this, then it will simply be unclipped // Usually the number of points is reduced when clipping. size_t NumCoords = OldNumCoords+20; // Get some mem for the coords DocCoord* Coords = new DocCoord[NumCoords]; if (Coords==NULL) return FALSE; // Get some mem for the verbs PathVerb* Verbs = new PathVerb[NumCoords]; if (Verbs==NULL) { delete [] Coords; return FALSE; } // Actually clip the path to the rectangles NumCoords = FuzzyClip( (PPOINT)pOldCoords, pOldVerbs, OldNumCoords, pPath->IsFilled, (RECT*)(&InnerRect), (RECT*)(&OuterRect), (PPOINT)Coords, Verbs, NumCoords); // See if it worked if (NumCoords == (size_t)-1) { // No it did not, so clean up and return delete [] Coords; delete [] Verbs; return FALSE; } else { // fill in the correct values for the outputs and return TRUE *pNewCoords = Coords; *pNewVerbs = Verbs; *NewNumCoords = (UINT32)NumCoords; return TRUE; } } // There was no need to clip, so return false return FALSE; }

BOOL RenderRegion::WantsGrids (   )  [virtual]

This function is designed to help with the rendering of grids, as they are not always wanted (eg xara eps). If your class of render region does not want grids to appear, then overide this function and get it to return FALSE. The default behaviour is to return TRUE, which will allow grids to render if they want to. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 12/12/95 Returns: TRUE Reimplemented in CMXRenderRegion, ImagemapRenderRegion, NativeRenderRegion, and EPSRenderRegion. Definition at line 6775 of file rndrgn.cpp. { return TRUE; }

BOOL RenderRegion::WriteNewLine (  void   )  [virtual]

Writes in a new-line token if necessary. In this class, it's just a stub function that's over-ridden in the derived classes. Author: Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com> Date: 27/4/00 Parameters: -  [INPUTS] Returns: TRUE - Success. FALSE - Failure. Reimplemented in AIEPSRenderRegion, CamelotEPSRenderRegion, and EPSRenderRegion. Definition at line 6066 of file rndrgn.cpp. { return TRUE; }

---

Member Data Documentation

BOOL RenderRegion::CanRegionBeMerged [protected]

Definition at line 940 of file rndrgn.h.

UINT32 RenderRegion::ClipViewBlobSize = 8 [static, protected]

This number represents the size of the ClipView's special selection blobs. These blobs are only visible on selected ClipView groups when using the selector tool, and are used to select different sections of the group. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 22 May 2000 See also: SelectedBlobSize Definition at line 929 of file rndrgn.h.

AttributeEntry* RenderRegion::CurrentAttrs [protected]

Definition at line 904 of file rndrgn.h.

DocRect RenderRegion::CurrentClipRect [protected]

Definition at line 889 of file rndrgn.h.

ColourContext* RenderRegion::CurrentColContext [protected]

Definition at line 890 of file rndrgn.h.

OffscreenAttrValue* RenderRegion::CurrentOffscreenAttr [protected]

Definition at line 911 of file rndrgn.h.

Node* RenderRegion::CurrentRenderState [protected]

Definition at line 897 of file rndrgn.h.

SubRenderContext* RenderRegion::CurrentSubRenderState [protected]

Definition at line 898 of file rndrgn.h.

DrawModeType RenderRegion::DrawingMode

Definition at line 519 of file rndrgn.h.

struct RenderRegion::_FillFlags RenderRegion::FillFlags [protected]

DocRect RenderRegion::InnerRect [protected]

Definition at line 821 of file rndrgn.h.

BOOL RenderRegion::IsBeingReset [protected]

Definition at line 953 of file rndrgn.h.

BOOL RenderRegion::IsInkRenderStarted

Definition at line 789 of file rndrgn.h.

BOOL RenderRegion::IsLastBand

Definition at line 778 of file rndrgn.h.

BOOL RenderRegion::IsPaperRendered

Definition at line 788 of file rndrgn.h.

BOOL RenderRegion::IsRegionBanded [protected]

Definition at line 939 of file rndrgn.h.

BOOL RenderRegion::IsWaitingForRAM

Definition at line 777 of file rndrgn.h.

BOOL RenderRegion::m_bForceMix [protected]

Definition at line 959 of file rndrgn.h.

BOOL RenderRegion::m_bRenderTreeTimeSlice [protected]

Definition at line 917 of file rndrgn.h.

StackT<Capture*> RenderRegion::m_CaptureStack [protected]

Definition at line 770 of file rndrgn.h.

INT64 RenderRegion::m_countStored [protected]

Definition at line 829 of file rndrgn.h.

INT64 RenderRegion::m_countTotal [protected]

Definition at line 828 of file rndrgn.h.

BOOL RenderRegion::m_DoCompression

Definition at line 793 of file rndrgn.h.

bool RenderRegion::m_fOwned [protected]

Definition at line 895 of file rndrgn.h.

Node* RenderRegion::m_pBackmostChangedNode [protected]

Definition at line 947 of file rndrgn.h.

Filter* RenderRegion::m_pFilter [protected]

Reimplemented in XPFRenderRegion. Definition at line 956 of file rndrgn.h.

MonotonicTime RenderRegion::m_timeRenderTreeStartTime [protected]

Definition at line 918 of file rndrgn.h.

DocColour RenderRegion::mBackgroundColour [protected]

Definition at line 796 of file rndrgn.h.

UINT32 RenderRegion::MultiStageSelectedBlobSize = 4 [static, protected]

Definition at line 924 of file rndrgn.h.

UINT32 RenderRegion::MultiStageUnSelectedBlobSize = 3 [static, protected]

Definition at line 925 of file rndrgn.h.

BOOL RenderRegion::NeedsOSPaper

Definition at line 782 of file rndrgn.h.

INT32 RenderRegion::NumCurrentAttrs [protected]

Definition at line 905 of file rndrgn.h.

DocRect RenderRegion::OuterRect [protected]

Definition at line 822 of file rndrgn.h.

PathProcessor* RenderRegion::PathProcessorStack [private]

Definition at line 965 of file rndrgn.h.

MILLIPOINT RenderRegion::PixelWidth [protected]

Definition at line 932 of file rndrgn.h.

DocRect RenderRegion::RegionRect [protected]

Definition at line 938 of file rndrgn.h.

BOOL RenderRegion::RenderComplexShapes [protected]

Definition at line 825 of file rndrgn.h.

CNativeDC* RenderRegion::RenderDC [protected]

Definition at line 893 of file rndrgn.h.

struct CCAPI RenderRegion::FlagBlock RenderRegion::RenderFlags [protected]

Matrix RenderRegion::RenderMatrix [protected]

Definition at line 888 of file rndrgn.h.

BOOL RenderRegion::RenderOSPaper

Definition at line 785 of file rndrgn.h.

Spread* RenderRegion::RenderSpread [protected]

Definition at line 894 of file rndrgn.h.

View* RenderRegion::RenderView [protected]

Definition at line 892 of file rndrgn.h.

Quality RenderRegion::RRQuality

Definition at line 790 of file rndrgn.h.

MILLIPOINT RenderRegion::ScaledPixelWidth [protected]

Definition at line 933 of file rndrgn.h.

FIXED16 RenderRegion::ScaleFactor [protected]

Definition at line 901 of file rndrgn.h.

UINT32 RenderRegion::SelectedBlobSize = 3 [static, protected]

The number represents the size of the blobs on the control points of selected objects. The Selected Blob Size is the size of the blobs when they have been clicked on. Preference: SelectedBlobSize Section: Selection Blob Sizes Range: 0 - 30 See also: UnSelectedBlobSize Definition at line 922 of file rndrgn.h.

struct RenderRegion::_StrokeFlags RenderRegion::StrokeFlags [protected]

BOOL RenderRegion::SubRenderStateLocked [protected]

Definition at line 899 of file rndrgn.h.

struct RenderRegion::_TextFlags RenderRegion::TextFlags [protected]

RenderStack RenderRegion::TheStack [protected]

Definition at line 935 of file rndrgn.h.

INT32 RenderRegion::Timeslice [protected]

Definition at line 916 of file rndrgn.h.

UINT32 RenderRegion::UnSelectedBlobSize = 2 [static, protected]

The number represents the size of the blobs on the control points of selected objects. The UnSelected Blob Size is the size of the blobs when the object is selected, but none of its control points have been clicked on (and are not themselves selected). Preference: UnSelectedBlobSize Section: Selection Blob Sizes Range: 0 - 30 See also: SelectedBlobSize Definition at line 923 of file rndrgn.h.

---

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

• Kernel/rndrgn.h (r1785/r1445)
• Kernel/rndrgn.cpp (r1785/r1609)

---