BlobManager Class Reference

Class to Manage the various types of selection blobs in Camelot. Currently Camelot knows about the following forms of selection blob :-. More...

#include <blobs.h>

Inheritance diagram for BlobManager:

List of all members.

Public Member Functions
	BlobManager ()
	Default constructor for the blob manager, marks all the blobs as off.
	~BlobManager ()
void	ToolInterest (BlobStyle)
void	AddInterest (BlobStyle)
	If the blobs specified are not already displayed, then they are rendered onto the screen. The Flags that the blob manager maintains about which blobs are on screen and which are not are also updated.
void	RemoveInterest (BlobStyle)
	If the blobs specified are already displayed, then they are rendered onto the screen to get rid of them (EORing!). The Flags that the blob manager maintains about which blobs are on screen and which are not are also updated.
BlobStyle	GetCurrentInterest (BOOL bIgnoreOffState=FALSE)
	Allows people other than the blobmanager to know what blob are currently displayed.
void	BlobRenderingOff (BOOL Redraw)
	After calling this function, any attempts to render blobs from anywhere in Camelot will result in nothing appearing on screen. This is a dangerous function to call if you are not sure what is going on. Normally you should use this function if you are about to do something that will involve the selection state becoming inconsistent with the blobs on screen and you specifically do not want lots of blob rendering going on until you have finished. Here is an example way of using it MonoOn Get rid of the blobs from the screen BlobMgr->BlobRenderingOff(TRUE);.
void	BlobRenderingOn (BOOL Redraw)
	If blob rendering has been turned off ( by calling BlobRenderinOff() ) then this function will re-enable it so that rendering can carry on like normal. Ideally this should be called not very long after calling BlobRenderingOff().
INT32	GetBlobSize ()
	This function allows you to find out how wide a blob should be.
void	GetBlobRect (const DocCoord &Centre, DocRect *Rect, BOOL MFill=FALSE, BlobType eBlobType=BT_SELECTEDLARGEST)
	Finds the rectangle of a blob that surrounds a given coord. This is to replace the rather long winded method that had to be employed before. If there is no selected document it will leave the rect unchanged.
void	Render (DocRect *Rect, Spread *pSpread)
	This function will render all the blobs that are currently being displayed for the given clipping rectangle.
void	RenderOn (DocRect *Rect, Spread *pSpread)
	This function will render on all the blobs that are currently being displayed for the given clipping rectangle.
void	RenderOff (DocRect *Rect, Spread *pSpread)
	This function will render off all the blobs that are currently being displayed for the given clipping rectangle.
void	RenderMyBlobs (DocRect *Rect, Spread *pSpread, NodeRenderable *pNode)
	Renders the blobs for the given node. Only the required blobs are rendered and since the blobs are EOR rendered, this function can be used to put the blobs onto the screen or take them off the screen.
void	RenderMyBlobsOn (DocRect *Rect, Spread *pSpread, NodeRenderable *pNode)
	This function will render on all the blobs that are currently being displayed for the given clipping rectangle.
void	RenderMyBlobsOff (DocRect *Rect, Spread *pSpread, NodeRenderable *pNode)
	This function will render off all the blobs that are currently being displayed for the given clipping rectangle.
void	RenderObjectBlobs (DocRect *Rect, Spread *pSpread, NodeRenderable *pNode)
	This function will render all the blobs that are currently being displayed for the given clipping rectangle.
void	RenderObjectBlobsOn (DocRect *Rect, Spread *pSpread, NodeRenderable *pNode)
	This function will render on all the blobs that are currently being displayed for the given clipping rectangle.
void	RenderObjectBlobsOff (DocRect *Rect, Spread *pSpread, NodeRenderable *pNode)
	This function will render off all the blobs that are currently being displayed for the given clipping rectangle.
void	RenderToolBlobsOn (Tool_v1 *pTool, Spread *pSpread, DocRect *pClipRect)
	This function will render on the specified tools blobs.
void	RenderToolBlobsOff (Tool_v1 *pTool, Spread *pSpread, DocRect *pClipRect)
	This function will render off the specified tools blobs.
BOOL	IsRemovingBlobs ()
Protected Member Functions
void	RenderRequiredBlobs (NodeRenderable *, RenderRegion *)
	Renders the required blobs for the given node into the given render region. The required blobs are specified by the tool when it is activated.
void	RenderSpecificBlobs (NodeRenderable *, RenderRegion *, BOOL, BOOL, BOOL, BOOL, BOOL, BOOL, BOOL)
	Renders only the blobs specified. This is called from the Add and Remove Interest Functions to add new types of blob to the display or take types of blob that are no longer needed off the display.
void	RenderRequiredBlobsOnSelection (DocRect *Rect)
	Renders the required blobs for the given node into the given render region. The required blobs are specified by the tool when it is activated.
void	RenderSpecificBlobsOnSelection (DocRect *Rect, BOOL, BOOL, BOOL, BOOL, BOOL, BOOL, BOOL)
	Renders only the blobs specified. This is called from the Add and Remove Interest Functions to add new types of blob to the display or take types of blob that are no longer needed off the display.
BOOL	NeedToRenderSelectionBlobs (DocRect *Rect)
	Check to make sure we need to render some blobs.
BOOL	NeedToRenderNodeBlobs (DocRect *Rect, Spread *pSpread, NodeRenderable *pNode)
	Check to make sure we need to render some blobs.
MsgResult	Message (Msg *Msg)
	Handles the View Changing message, and makes sure that the blobs are removed from the old view and drawn onto the new view.
Protected Attributes
BOOL	IsFillBlob
BOOL	IsObjectBlob
BOOL	IsArtisticBlob
BOOL	IsTinyBlob
BOOL	IsPenBlob
BOOL	IsToolObjectBlob
BOOL	IsEffectBlob
BOOL	DrawBlobsAtAll
BOOL	RemovingBlobs
BOOL	bToolBlobsAreOff
Private Member Functions
	CC_DECLARE_MEMDUMP (BlobManager)

---

Detailed Description

Class to Manage the various types of selection blobs in Camelot. Currently Camelot knows about the following forms of selection blob :-.

Author:

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

Date:

15/6/94

Fill Blobs - The blobs rendered by things like Graduated fills to show where the fill starts and ends, it direction etc.

Object Blobs - The blobs that appear to edit the shape of an object. ie the control point blobs on a path

Artistic Blobs - Used to edit information such as pressure details along shapes.

Tiny Blobs - the Blob that is displayed by an object when it is the Boundary selection mode of the selector tool to indicate that it is one of the selected objects.

ToolObject Blobs - These blobs are displayed and used by an object only when a specific tool is selected. They are similar to object blobs except that the _object_ has the final say in whether they are rendered/used or not.

Definition at line 208 of file blobs.h.

---

Constructor & Destructor Documentation

BlobManager::BlobManager (   )

Default constructor for the blob manager, marks all the blobs as off. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 23/6/94 Definition at line 194 of file blobs.cpp. : MessageHandler(CC_RUNTIME_CLASS(MessageHandler), TRUE) { // There are no blobs visible when we start IsFillBlob = FALSE; IsObjectBlob = FALSE; IsArtisticBlob = FALSE; IsTinyBlob = FALSE; IsPenBlob = FALSE; IsToolObjectBlob = FALSE; IsEffectBlob = FALSE; // Blob rendering is switched on by default DrawBlobsAtAll = TRUE; RemovingBlobs = FALSE; bToolBlobsAreOff = FALSE; }

BlobManager::~BlobManager (   )  [inline]

Definition at line 216 of file blobs.h. {}

---

Member Function Documentation

void BlobManager::AddInterest (  BlobStyle  Blobs  )

If the blobs specified are not already displayed, then they are rendered onto the screen. The Flags that the blob manager maintains about which blobs are on screen and which are not are also updated. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 16/6/94 Parameters: Blobs  - The blobs that you which to add to the ones currently displayed [INPUTS] See also: BlobManager::RemoveInterest; BlobStyle Definition at line 332 of file blobs.cpp. { RemovingBlobs = FALSE; // First we have to work out which bits of the we have to add. // Do we need Object blobs to be rendered BOOL DrawObject = FALSE; if (!IsObjectBlob && Blobs.Object) { DrawObject = TRUE; IsObjectBlob = TRUE; } // Do we need Artistic blobs to be rendered BOOL DrawArtistic = FALSE; if (!IsArtisticBlob && Blobs.Artistic) { DrawArtistic = TRUE; IsArtisticBlob = TRUE; } // Do we need Fill blobs to be rendered BOOL DrawFill = FALSE; if (!IsFillBlob && Blobs.Fill) { DrawFill = TRUE; IsFillBlob = TRUE; } // Do we need Effect blobs to be rendered BOOL DrawEffect = FALSE; if (!IsEffectBlob && Blobs.Effect) { DrawEffect = TRUE; IsEffectBlob = TRUE; } // Do we need Tiny blobs to be rendered BOOL DrawTiny = FALSE; if (!IsTinyBlob && Blobs.Tiny) { DrawTiny = TRUE; IsTinyBlob = TRUE; } // Do we need Pen blobs to be rendered BOOL DrawPen = FALSE; if (!IsPenBlob && Blobs.Pen) { DrawPen = TRUE; IsPenBlob = TRUE; } // Do we need ToolObject blobs to be rendered BOOL DrawToolObject = FALSE; if (!IsToolObjectBlob && Blobs.ToolObject) { DrawToolObject = TRUE; IsToolObjectBlob = TRUE; } if (!NeedToRenderSelectionBlobs(NULL)) return; RenderSpecificBlobsOnSelection( NULL, DrawObject, DrawArtistic, DrawFill, DrawTiny, DrawPen, DrawToolObject, DrawEffect); // Now EOR off in all the render regions that are still rendering, // so that the Blob rendering when the region is finished, // will put them on RenderRegionList* pRegionList = GetApplication()->GetRegionList(); if (!pRegionList->IsEmpty()) { // Find out which spread the selection is on SelRange* Selected = GetApplication()->FindSelection(); Node* pNode = Selected->FindFirst(); if (pNode) // Is there a Selection ? { Spread* pSpread = pNode->FindParentSpread(); RenderRegion* pRegion = (RenderRegion*)pRegionList->GetHead(); while (pRegion) { // Check the RenderRegion is for the same spread. if (pRegion->GetRenderSpread() == pSpread && pRegion->GetRenderView()==DocView::GetSelected() && (pRegion->IsInkRenderStarted || pRegion->NeedsOSPaper)) { // Render the blobs 'clipped' to this Render Region. DocRect ClipRect = pRegion->GetRegionRect(); RenderSpecificBlobsOnSelection( &ClipRect, DrawObject, DrawArtistic, DrawFill, DrawTiny, DrawPen, DrawToolObject, DrawEffect ); } // Get the Next render region pRegion = (RenderRegion*)pRegionList->GetNext(pRegion); } } } }

void BlobManager::BlobRenderingOff (  BOOL  Redraw  )

After calling this function, any attempts to render blobs from anywhere in Camelot will result in nothing appearing on screen. This is a dangerous function to call if you are not sure what is going on. Normally you should use this function if you are about to do something that will involve the selection state becoming inconsistent with the blobs on screen and you specifically do not want lots of blob rendering going on until you have finished. Here is an example way of using it MonoOn Get rid of the blobs from the screen BlobMgr->BlobRenderingOff(TRUE);. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 11/7/94 Parameters: Redraw  - TRUE if you want the blob to be rendered before blob rendering is [INPUTS] turned off. Party on the selection and change lots of things ... Invalidate the region of the blobs ... Switch the blob manager back on again but leave the rendering of the blobs to the normal OnDraw loop BlobMgr->BlobRenderingOn(FALSE) MonoOff See also: BlobManager::BlobRenderingOn() Definition at line 628 of file blobs.cpp. { RemovingBlobs = TRUE; if (Redraw && NeedToRenderSelectionBlobs(NULL)) { // EOR on in all the render regions that are still rendering, // so that the Blob rendering when the region is finished, // will take them off RenderRegionList* pRegionList = GetApplication()->GetRegionList(); if (!pRegionList->IsEmpty()) { // Find out which spread the selection is on SelRange* Selected = GetApplication()->FindSelection(); Node* pNode = Selected->FindFirst(); if (pNode) // Is there a Selection ? { Spread* pSpread = pNode->FindParentSpread(); RenderRegion* pRegion = (RenderRegion*)pRegionList->GetHead(); while (pRegion) { // Check the RenderRegion is for the same spread. if (pRegion->GetRenderSpread() == pSpread && pRegion->GetRenderView()==DocView::GetSelected() && (pRegion->IsInkRenderStarted || pRegion->NeedsOSPaper)) { // Render the blobs 'clipped' to this Render Region. DocRect ClipRect = pRegion->GetRegionRect(); RenderRequiredBlobsOnSelection(&ClipRect); } // Get the Next render region pRegion = (RenderRegion*)pRegionList->GetNext(pRegion); } } } RenderRequiredBlobsOnSelection(NULL); } // Mark blob rendering to be off DrawBlobsAtAll = FALSE; // Bodge to stop fill meshes EOR each other out. AttrFillGeometry::LastRenderedMesh = NULL; }

void BlobManager::BlobRenderingOn (  BOOL  Redraw  )

If blob rendering has been turned off ( by calling BlobRenderinOff() ) then this function will re-enable it so that rendering can carry on like normal. Ideally this should be called not very long after calling BlobRenderingOff(). Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 11/7/94 Parameters: Redraw  - TRUE if you want the blobs to be rendered before blob rendering is [INPUTS] turned on. See also: BlobManager::BlobRenderingOn() Definition at line 696 of file blobs.cpp. { RemovingBlobs = FALSE; if (Redraw && NeedToRenderSelectionBlobs(NULL)) { RenderRequiredBlobsOnSelection(NULL); // Now EOR off in all the render regions that are still rendering, // so that the Blob rendering when the region is finished, // will put them on RenderRegionList* pRegionList = GetApplication()->GetRegionList(); if (!pRegionList->IsEmpty()) { // Find out which spread the selection is on SelRange* Selected = GetApplication()->FindSelection(); Node* pNode = Selected->FindFirst(); if (pNode) // Is there a Selection ? { Spread* pSpread = pNode->FindParentSpread(); RenderRegion* pRegion = (RenderRegion*)pRegionList->GetHead(); while (pRegion) { // Check the RenderRegion is for the same spread. if (pRegion->GetRenderSpread() == pSpread && pRegion->GetRenderView()==DocView::GetSelected() && (pRegion->IsInkRenderStarted || pRegion->NeedsOSPaper)) { // Render the blobs 'clipped' to this Render Region. DocRect ClipRect = pRegion->GetRegionRect(); RenderRequiredBlobsOnSelection(&ClipRect); } // Get the Next render region pRegion = (RenderRegion*)pRegionList->GetNext(pRegion); } } } } // Mark blob rendering to be on DrawBlobsAtAll = TRUE; // Bodge to stop fill meshes EOR each other out. AttrFillGeometry::LastRenderedMesh = NULL; }

BlobManager::CC_DECLARE_MEMDUMP (  BlobManager   )  [private]

void BlobManager::GetBlobRect (  const DocCoord &  Centre, DocRect *  Rect, BOOL  MFill = FALSE, BlobType  eBlobType = BT_SELECTEDLARGEST )

Finds the rectangle of a blob that surrounds a given coord. This is to replace the rather long winded method that had to be employed before. If there is no selected document it will leave the rect unchanged. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 27/6/94 Parameters: Centre  - The coordinate to centre the blob on [INPUTS] MFill = Whether we should force this routine to use multi-stage fill routine Rect  - The rect in DocCoords of the blobs [OUTPUTS] Karim 22/05/2000 - modified this method to take a BlobType param. Note that you *cannot* make use of this new param until the MFill param is removed and all current instances of GetBlobRect() updated. The new param is currently only checked against my ClipView blob type. Definition at line 793 of file blobs.cpp. { // We will be needing a view to do this DocView* pDocView = DocView::GetSelected(); // Find out how big a rect is these days, if we have a view if (pDocView!=NULL) { switch (eBlobType) { case BT_CLIPVIEW: OSRenderRegion::GetBlobRect(pDocView->GetViewScale(), Centre, BT_CLIPVIEW, Rect); break; default: if (!MFill) { OSRenderRegion::GetBlobRect(pDocView->GetViewScale(), Centre, BT_SELECTEDLARGEST, Rect); } else { OSRenderRegion::GetBlobRect(pDocView->GetViewScale(), Centre, BT_MSTAGESELECTEDLARGEST, Rect); } break; } } }

INT32 BlobManager::GetBlobSize (   )

This function allows you to find out how wide a blob should be. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 27/6/94 Returns: INT32 - The size (in DocCoords) of a blob. Definition at line 761 of file blobs.cpp. { // To do this, we need to find out how big a blobs rect is DocRect Rect; GetBlobRect(DocCoord(0,0), &Rect); // return the width of the resulting rect return Rect.Width(); }

BlobStyle BlobManager::GetCurrentInterest (  BOOL  bIgnoreOffState = FALSE  )

Allows people other than the blobmanager to know what blob are currently displayed. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 15/8/94 Parameters: bIgnoreOffState  - Flag for use by GetBlobBoundingRect functions so that [INPUTS] they can return correct bounds even when blob rendering is turned off Returns: A 'BlobStyle' refecting the current blob interest See also: BlobManager::AddInterest; BlobStyle Definition at line 574 of file blobs.cpp. { // Make a default blob style with all interest off. BlobStyle CurrentBlobs; if (DrawBlobsAtAll || bIgnoreOffState) { // Update it with the current Interest CurrentBlobs.Fill = IsFillBlob; CurrentBlobs.Effect = IsEffectBlob; CurrentBlobs.Object = IsObjectBlob; CurrentBlobs.Artistic = IsArtisticBlob; CurrentBlobs.Tiny = IsTinyBlob; CurrentBlobs.Pen = IsPenBlob; CurrentBlobs.ToolObject = IsToolObjectBlob; } return CurrentBlobs; }

BOOL BlobManager::IsRemovingBlobs (   )  [inline]

Definition at line 251 of file blobs.h. { return RemovingBlobs; }

MsgResult BlobManager::Message (  Msg *  Message  )  [protected, virtual]

Handles the View Changing message, and makes sure that the blobs are removed from the old view and drawn onto the new view. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 29/6/94 Parameters: Message  - the message to examine [INPUTS] Returns: - Reimplemented from MessageHandler. Definition at line 1600 of file blobs.cpp. { if (MESSAGE_IS_A(Message, DocViewMsg)) { // Get a version of the message in the right type DocViewMsg* pDocViewMsg = (DocViewMsg*) Message; switch (pDocViewMsg->State) { // respond to messages that arrive just before and just after the view has changed. case DocViewMsg::SELABOUTTOCHANGE: case DocViewMsg::SELCHANGED: { // rub blobs off old view or draw them in on the new one if (DocView::GetSelected()!=NULL) { // go find the selection SelRange* Selected = GetApplication()->FindSelection(); // Have to be sure that the selection is correct for the view Selected->Update(); Node* pNode = Selected->FindFirst(); // If there is something selected if (pNode!=NULL) { // Find its spread Spread* pSpread = pNode->FindParentSpread(); if (pSpread!=NULL) { // and render the blobs Render(NULL, pSpread); } } } break; } default: break; } } return OK; }

BOOL BlobManager::NeedToRenderNodeBlobs (  DocRect *  Rect, Spread *  pSpread, NodeRenderable *  pNode )  [protected]

Check to make sure we need to render some blobs. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 15/6/95 Definition at line 1812 of file blobs.cpp. { RenderRegionList* pRegionList = GetApplication()->GetRegionList(); if (pRegionList->IsEmpty()) return TRUE; if (Rect != NULL || pNode->IsBounded()) { // If the Blob we are about to render, is completely contained // within a pending Render Region, then we don't need to // render anything // Find out the blob rect of this node, if we can DocRect NodeRect = DocRect(0,0,0,0); if (pNode->IsBounded()) { // Use the node's blob bounds NodeRect = ((NodeRenderableBounded*)pNode)->GetBlobBoundingRect(); } // If a clip rect was given, and it doesn't completely contain the node rect, // then we'll have to use that if (Rect && !Rect->ContainsRect(NodeRect)) NodeRect = *Rect; if (!NodeRect.IsEmpty()) { // So lets check the pending regions RenderRegion* pRegion = (RenderRegion*)pRegionList->GetHead(); while (pRegion) { // Check the RenderRegion is for the same spread. if (pRegion->GetRenderSpread() == pSpread && pRegion->GetRenderView()==DocView::GetSelected() && (pRegion->IsInkRenderStarted || pRegion->NeedsOSPaper)) { // Get the 'clip' rect of this Render Region. DocRect ClipRect = pRegion->GetRegionRect(); // If any of the RenderRegions completely contain the rect // then there is no point in rendering anything if (ClipRect.ContainsRect(NodeRect)) return FALSE; // We don't need to render this node's blobs } // Get the Next render region pRegion = (RenderRegion*)pRegionList->GetNext(pRegion); } } } return TRUE; }

BOOL BlobManager::NeedToRenderSelectionBlobs (  DocRect *  Rect  )  [protected]

Check to make sure we need to render some blobs. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 15/6/95 Definition at line 1750 of file blobs.cpp. { RenderRegionList* pRegionList = GetApplication()->GetRegionList(); if (pRegionList->IsEmpty()) return TRUE; // Find the first selected object in the tree; SelRange* Selected = GetApplication()->FindSelection(); if (Selected->Count() == 0) return FALSE; // Nothing to render Node* pNode = Selected->FindFirst(); Spread* pSpread = pNode->FindParentSpread(); // Find out the blob rect of the selection DocRect SelRect = Selected->GetBlobBoundingRect(); // If a clip rect was given, and it doesn't completely contain the sel bounds, // then we'll have to use that if (Rect && !Rect->ContainsRect(SelRect)) SelRect = *Rect; if (!SelRect.IsEmpty()) { // So lets check the pending regions RenderRegion* pRegion = (RenderRegion*)pRegionList->GetHead(); while (pRegion) { // Check the RenderRegion is for the same spread. if (pRegion->GetRenderSpread() == pSpread && pRegion->GetRenderView()==DocView::GetSelected() && (pRegion->IsInkRenderStarted || pRegion->NeedsOSPaper)) { // Get the 'clip' rect of this Render Region. DocRect ClipRect = pRegion->GetRegionRect(); // If any of the RenderRegions completely contain the rect // then there is no point in rendering anything if (ClipRect.ContainsRect(SelRect)) return FALSE; // We don't need to render any blobs } // Get the Next render region pRegion = (RenderRegion*)pRegionList->GetNext(pRegion); } } return TRUE; }

void BlobManager::RemoveInterest (  BlobStyle  Blobs  )

If the blobs specified are already displayed, then they are rendered onto the screen to get rid of them (EORing!). The Flags that the blob manager maintains about which blobs are on screen and which are not are also updated. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 16/6/94 Parameters: Blobs  - The blobs that you which to remove from the ones currently displayed [INPUTS] See also: BlobManager::AddInterest; BlobStyle Definition at line 454 of file blobs.cpp. { RemovingBlobs = TRUE; // First we have to work out which bits of the we have to add. // Do we need Object blobs to be rendered BOOL DrawObject = FALSE; if (IsObjectBlob && Blobs.Object) { DrawObject = TRUE; IsObjectBlob = FALSE; } // Do we need Artistic blobs to be rendered BOOL DrawArtistic = FALSE; if (IsArtisticBlob && Blobs.Artistic) { DrawArtistic = TRUE; IsArtisticBlob = FALSE; } // Do we need Fill blobs to be rendered BOOL DrawFill = FALSE; if (IsFillBlob && Blobs.Fill) { DrawFill = TRUE; IsFillBlob = FALSE; } // Do we need Fill blobs to be rendered BOOL DrawEffect = FALSE; if (IsEffectBlob && Blobs.Effect) { DrawEffect = TRUE; IsEffectBlob = FALSE; } // Do we need Tiny blobs to be rendered BOOL DrawTiny = FALSE; if (IsTinyBlob && Blobs.Tiny) { DrawTiny = TRUE; IsTinyBlob = FALSE; } // Do we need Pen blobs to be rendered BOOL DrawPen = FALSE; if (IsPenBlob && Blobs.Pen) { DrawPen = TRUE; IsPenBlob = FALSE; } // Do we need ToolObject blobs to be rendered BOOL DrawToolObject = FALSE; if (IsToolObjectBlob && Blobs.ToolObject) { DrawToolObject = TRUE; IsToolObjectBlob = FALSE; } if (!NeedToRenderSelectionBlobs(NULL)) return; // EOR on in all the render regions that are still rendering, // so that the Blob rendering when the region is finished, // will take them off RenderRegionList* pRegionList = GetApplication()->GetRegionList(); if (!pRegionList->IsEmpty()) { // Find out which spread the selection is on SelRange* Selected = GetApplication()->FindSelection(); Node* pNode = Selected->FindFirst(); if (pNode) // Is there a Selection ? { Spread* pSpread = pNode->FindParentSpread(); RenderRegion* pRegion = (RenderRegion*)pRegionList->GetHead(); while (pRegion) { // Check the RenderRegion is for the same spread. if (pRegion->GetRenderSpread() == pSpread && pRegion->GetRenderView()==DocView::GetSelected() && (pRegion->IsInkRenderStarted || pRegion->NeedsOSPaper)) { // Render the blobs 'clipped' to this Render Region. DocRect ClipRect = pRegion->GetRegionRect(); RenderSpecificBlobsOnSelection( &ClipRect, DrawObject, DrawArtistic, DrawFill, DrawTiny, DrawPen, DrawToolObject, DrawEffect ); } // Get the Next render region pRegion = (RenderRegion*)pRegionList->GetNext(pRegion); } } } RenderSpecificBlobsOnSelection( NULL, DrawObject, DrawArtistic, DrawFill, DrawTiny, DrawPen, DrawToolObject, DrawEffect); }

void BlobManager::Render (  DocRect *  Rect, Spread *  pSpread )

This function will render all the blobs that are currently being displayed for the given clipping rectangle. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 16/6/94 Definition at line 834 of file blobs.cpp. { // If we are not drawing blobs today, then return straight away if (!DrawBlobsAtAll) return; // Now render the sections that need to be rendered to get the corrent blobs on screen RenderRegion* pRegion = DocView::RenderOnTop(Rect, pSpread, ClippedEOR); while (pRegion) { // Find out the clipping rect of this region DocRect TestRect = pRegion->GetClipRect(); // Find the first selected object in the tree; SelRange* Selected = GetApplication()->FindSelection(); // Karim 29/06/2000 // PromoteToParent should never be set TRUE on the selection range, outside // of code in which its modifications are required. // I have included a TRACE statement here, as a 'quiet' note to programmers, // should this occur. RangeControl rc = Selected->GetRangeControlFlags(); if (rc.PromoteToParent) { TRACE( _T("BlobManager::Render; PromoteToParent is TRUE! Read inline comment for details.\n")); rc.PromoteToParent = FALSE; Selected->Range::SetRangeControl(rc); } Node* pNode = Selected->FindFirst(); while(pNode) { // Render only the required blobs if (pNode->IsBounded()) { // This node is bounded, so see if we really need to render it if (TestRect.IsIntersectedWith(((NodeRenderableBounded*)pNode)->GetBlobBoundingRect())) RenderRequiredBlobs((NodeRenderable*)pNode, pRegion); } else { // Always render it if it is not bounded (probably an Attribute) RenderRequiredBlobs((NodeRenderable*)pNode, pRegion); } // Find the next selected node to render pNode = Selected->FindNext(pNode); } // Go find the next region pRegion = DocView::GetNextOnTop(Rect); } // Bodge to stop fill meshes EOR each other out. AttrFillGeometry::LastRenderedMesh = NULL; }

void BlobManager::RenderMyBlobs (  DocRect *  Rect, Spread *  pSpread, NodeRenderable *  pNode )

Renders the blobs for the given node. Only the required blobs are rendered and since the blobs are EOR rendered, this function can be used to put the blobs onto the screen or take them off the screen. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 17/6/94 Parameters: pNode  - The node to render the blobs of [INPUTS] Definition at line 1056 of file blobs.cpp. { // If we are not drawing blobs today, then return straight away if (!DrawBlobsAtAll) return; // Now render the sections that need to be rendered to get the corrent blobs on screen RenderRegion* pRegion = DocView::RenderOnTop(Rect, pSpread, ClippedEOR); while (pRegion) { // Find out the clipping rect of this region DocRect TestRect = pRegion->GetClipRect(); // Render only the blobs that need to be drawn if (pNode->IsBounded()) { // This node is bounded, so see if we really need to render it if (TestRect.IsIntersectedWith(((NodeRenderableBounded*)pNode)->GetBlobBoundingRect())) RenderRequiredBlobs(pNode, pRegion); } else { // Always render it if it is not bounded (probably an Attribute) RenderRequiredBlobs(pNode, pRegion); } // Go find the next region pRegion = DocView::GetNextOnTop(Rect); } }

void BlobManager::RenderMyBlobsOff (  DocRect *  Rect, Spread *  pSpread, NodeRenderable *  pNode )

This function will render off all the blobs that are currently being displayed for the given clipping rectangle. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/6/95 Definition at line 1169 of file blobs.cpp. { RemovingBlobs = TRUE; // If we are not drawing blobs today, then return straight away if (!DrawBlobsAtAll) return; // Are we in the middle of a Background redraw ? RenderRegionList* pRegionList = GetApplication()->GetRegionList(); if (pRegionList->IsEmpty()) { // Nope, so do stuff as normal // Draw the blobs off RenderMyBlobs(Rect, pSpread, pNode); return; } // We must be background rendering ... // So lets try a bit of an optimisation if (!NeedToRenderNodeBlobs(Rect, pSpread, pNode)) return; // Oh well, lets render some blobs then // EOR on in all the render regions that are still rendering, // so that the Blob rendering when the region is finished, // will take them off RenderRegion* pRegion = (RenderRegion*)pRegionList->GetHead(); while (pRegion) { // Check the RenderRegion is for the same spread. if (pRegion->GetRenderSpread() == pSpread && pRegion->GetRenderView()==DocView::GetSelected() && (pRegion->IsInkRenderStarted || pRegion->NeedsOSPaper)) { // Render the blobs 'clipped' to this Render Region. DocRect ClipRect = pRegion->GetRegionRect(); RenderMyBlobs(&ClipRect, pSpread, pNode); } // Get the Next render region pRegion = (RenderRegion*)pRegionList->GetNext(pRegion); } // Stop fill meshes EORing each other out. FillGeometryAttribute* pLastMesh = AttrFillGeometry::LastRenderedMesh; AttrFillGeometry::LastRenderedMesh = NULL; // Draw the blobs off RenderMyBlobs(Rect, pSpread, pNode); // Stop fill meshes EORing each other out. AttrFillGeometry::LastRenderedMesh = pLastMesh; }

void BlobManager::RenderMyBlobsOn (  DocRect *  Rect, Spread *  pSpread, NodeRenderable *  pNode )

This function will render on all the blobs that are currently being displayed for the given clipping rectangle. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/6/95 Definition at line 1098 of file blobs.cpp. { RemovingBlobs = FALSE; // If we are not drawing blobs today, then return straight away if (!DrawBlobsAtAll) return; // Are we in the middle of a Background redraw ? RenderRegionList* pRegionList = GetApplication()->GetRegionList(); if (pRegionList->IsEmpty()) { // Nope, so do stuff as normal // Draw the blobs on RenderMyBlobs(Rect, pSpread, pNode); return; } // We must be background rendering ... // So lets try a bit of an optimisation if (!NeedToRenderNodeBlobs(Rect, pSpread, pNode)) return; // Oh well, lets render some blobs then // Draw the blobs on RenderMyBlobs(Rect, pSpread, pNode); // Stop fill meshes EORing each other out. FillGeometryAttribute* pLastMesh = AttrFillGeometry::LastRenderedMesh; AttrFillGeometry::LastRenderedMesh = NULL; // Now EOR off in all the render regions that are still rendering, // so that the Blob rendering when the region is finished, // will put them on RenderRegion* pRegion = (RenderRegion*)pRegionList->GetHead(); while (pRegion) { // Check the RenderRegion is for the same spread. if (pRegion->GetRenderSpread() == pSpread && pRegion->GetRenderView()==DocView::GetSelected() && (pRegion->IsInkRenderStarted || pRegion->NeedsOSPaper)) { // Render the blobs 'clipped' to this Render Region. DocRect ClipRect = pRegion->GetRegionRect(); RenderMyBlobs(&ClipRect, pSpread, pNode); } // Get the Next render region pRegion = (RenderRegion*)pRegionList->GetNext(pRegion); } // Stop fill meshes EORing each other out. AttrFillGeometry::LastRenderedMesh = pLastMesh; }

void BlobManager::RenderObjectBlobs (  DocRect *  Rect, Spread *  pSpread, NodeRenderable *  pNode )

This function will render all the blobs that are currently being displayed for the given clipping rectangle. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/6/95 Definition at line 1361 of file blobs.cpp. { RenderRegion* pOnTopRegion = DocView::RenderOnTop(Rect, pSpread, ClippedEOR); while (pOnTopRegion) { pNode->RenderObjectBlobs(pOnTopRegion); // Go find the next region pOnTopRegion = DocView::GetNextOnTop(Rect); } }

void BlobManager::RenderObjectBlobsOff (  DocRect *  Rect, Spread *  pSpread, NodeRenderable *  pNode )

This function will render off all the blobs that are currently being displayed for the given clipping rectangle. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/6/95 Definition at line 1300 of file blobs.cpp. { RemovingBlobs = TRUE; // Are we in the middle of a Background redraw ? RenderRegionList* pRegionList = GetApplication()->GetRegionList(); if (pRegionList->IsEmpty()) { // Nope, so do stuff as normal // Draw the blobs off RenderObjectBlobs(Rect, pSpread, pNode); return; } // We must be background rendering ... // So lets try a bit of an optimisation if (!NeedToRenderNodeBlobs(Rect, pSpread, pNode)) return; // Oh well, lets render some blobs then // EOR on in all the render regions that are still rendering, // so that the Blob rendering when the region is finished, // will take them off RenderRegion* pRegion = (RenderRegion*)pRegionList->GetHead(); while (pRegion) { // Check the RenderRegion is for the same spread. if (pRegion->GetRenderSpread() == pSpread && pRegion->GetRenderView()==DocView::GetSelected() && (pRegion->IsInkRenderStarted || pRegion->NeedsOSPaper)) { // Render the blobs 'clipped' to this Render Region. DocRect ClipRect = pRegion->GetRegionRect(); // Render what we need to RenderObjectBlobs(&ClipRect, pSpread, pNode); } // Get the Next render region pRegion = (RenderRegion*)pRegionList->GetNext(pRegion); } // Draw the blobs off RenderObjectBlobs(Rect, pSpread, pNode); }

void BlobManager::RenderObjectBlobsOn (  DocRect *  Rect, Spread *  pSpread, NodeRenderable *  pNode )

This function will render on all the blobs that are currently being displayed for the given clipping rectangle. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/6/95 Definition at line 1239 of file blobs.cpp. { RemovingBlobs = FALSE; // Are we in the middle of a Background redraw ? RenderRegionList* pRegionList = GetApplication()->GetRegionList(); if (pRegionList->IsEmpty()) { // Nope, so do stuff as normal // Draw the blobs on RenderObjectBlobs(Rect, pSpread, pNode); return; } // We must be background rendering ... // So lets try a bit of an optimisation if (!NeedToRenderNodeBlobs(Rect, pSpread, pNode)) return; // Oh well, lets render some blobs then // Draw the blobs on RenderObjectBlobs(Rect, pSpread, pNode); // EOR off in all the render regions that are still rendering, // so that the Blob rendering when the region is finished, // will put them on RenderRegion* pRegion = (RenderRegion*)pRegionList->GetHead(); while (pRegion) { // Check the RenderRegion is for the same spread. if (pRegion->GetRenderSpread() == pSpread && pRegion->GetRenderView()==DocView::GetSelected() && (pRegion->IsInkRenderStarted || pRegion->NeedsOSPaper)) { // Render the blobs 'clipped' to this Render Region. DocRect ClipRect = pRegion->GetRegionRect(); // Render what we need to RenderObjectBlobs(&ClipRect, pSpread, pNode); } // Get the Next render region pRegion = (RenderRegion*)pRegionList->GetNext(pRegion); } }

void BlobManager::RenderOff (  DocRect *  Rect, Spread *  pSpread )

This function will render off all the blobs that are currently being displayed for the given clipping rectangle. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/6/95 Definition at line 978 of file blobs.cpp. { RemovingBlobs = TRUE; // If we are not drawing blobs today, then return straight away if (!DrawBlobsAtAll) return; // Are we in the middle of a Background redraw ? RenderRegionList* pRegionList = GetApplication()->GetRegionList(); if (pRegionList->IsEmpty()) { // Nope, so do stuff as normal // Draw the blobs on Render(Rect, pSpread); // Stop fill meshes EORing each other out. AttrFillGeometry::LastRenderedMesh = NULL; return; } // We must be background rendering ... // So lets try a bit of an optimisation // If the Blob we are about to render, is completely contained // within a pending Render Region, then we don't need to // render anything if (!NeedToRenderSelectionBlobs(Rect)) return; // Oh well, lets render some blobs then // EOR on in all the render regions that are still rendering, // so that the Blob rendering when the region is finished, // will take them off RenderRegion* pRegion = (RenderRegion*)pRegionList->GetHead(); while (pRegion) { // Check the RenderRegion is for the same spread. if (pRegion->GetRenderSpread() == pSpread && pRegion->GetRenderView()==DocView::GetSelected() && (pRegion->IsInkRenderStarted || pRegion->NeedsOSPaper)) { // Render the blobs 'clipped' to this Render Region. DocRect ClipRect = pRegion->GetRegionRect(); Render(&ClipRect, pSpread); } // Get the Next render region pRegion = (RenderRegion*)pRegionList->GetNext(pRegion); } // Stop fill meshes EORing each other out. AttrFillGeometry::LastRenderedMesh = NULL; // Draw the blobs off Render(Rect, pSpread); // Stop fill meshes EORing each other out. AttrFillGeometry::LastRenderedMesh = NULL; }

void BlobManager::RenderOn (  DocRect *  Rect, Spread *  pSpread )

This function will render on all the blobs that are currently being displayed for the given clipping rectangle. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/6/95 Definition at line 902 of file blobs.cpp. { RemovingBlobs = FALSE; // If we are not drawing blobs today, then return straight away if (!DrawBlobsAtAll) return; // Are we in the middle of a Background redraw ? RenderRegionList* pRegionList = GetApplication()->GetRegionList(); if (pRegionList->IsEmpty()) { // Nope, so do stuff as normal // Draw the blobs on Render(Rect, pSpread); // Stop fill meshes EORing each other out. AttrFillGeometry::LastRenderedMesh = NULL; return; } // We must be background rendering ... // So lets try a bit of an optimisation // If the Blob we are about to render, is completely contained // within a pending Render Region, then we don't need to // render anything if (!NeedToRenderSelectionBlobs(Rect)) return; // Oh well, lets render some blobs then // Draw the blobs on Render(Rect, pSpread); // Stop fill meshes EORing each other out. AttrFillGeometry::LastRenderedMesh = NULL; // Now EOR off in all the render regions that are still rendering, // so that the Blob rendering when the region is finished, // will put them on RenderRegion* pRegion = (RenderRegion*)pRegionList->GetHead(); while (pRegion) { // Check the RenderRegion is for the same spread. if (pRegion->GetRenderSpread() == pSpread && pRegion->GetRenderView()==DocView::GetSelected() && (pRegion->IsInkRenderStarted || pRegion->NeedsOSPaper)) { // Render the blobs 'clipped' to this Render Region. DocRect ClipRect = pRegion->GetRegionRect(); Render(&ClipRect, pSpread); } // Get the Next render region pRegion = (RenderRegion*)pRegionList->GetNext(pRegion); } // Stop fill meshes EORing each other out. AttrFillGeometry::LastRenderedMesh = NULL; }

void BlobManager::RenderRequiredBlobs (  NodeRenderable *  pNode, RenderRegion *  pRegion )  [protected]

Renders the required blobs for the given node into the given render region. The required blobs are specified by the tool when it is activated. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 22/6/94 Parameters: pNode  - The Node whos blobs need rendering [INPUTS] pRegion - The render region to draw into Definition at line 1386 of file blobs.cpp. { // We know that the node is a renderable ink as it is selected ENSURE( pNode->IsKindOf(CC_RUNTIME_CLASS(NodeRenderableInk)), "Selected object was not Renderable!"); // Render the Object Blobs of this node if (IsObjectBlob) pNode->RenderObjectBlobs(pRegion); // Render the Artistic blobs of this node if (IsArtisticBlob) pNode->RenderArtisticBlobs(pRegion); // Render the Fill blobs of this node if (IsFillBlob) pNode->RenderAppliedFillBlobs(pRegion); // Render the Fill blobs of this node if (IsEffectBlob) pNode->RenderEffectBlobs(pRegion); // Render the tiny blobs of this node if (IsTinyBlob) pNode->RenderTinyBlobs(pRegion); // Render the pen blobs of this node if (IsPenBlob) pNode->RenderPenBlobs(pRegion); // Render the ToolObject blobs of this node if (IsToolObjectBlob) pNode->RenderToolObjectBlobs(pRegion); }

void BlobManager::RenderRequiredBlobsOnSelection (  DocRect *  Rect  )  [protected]

Renders the required blobs for the given node into the given render region. The required blobs are specified by the tool when it is activated. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 14/6/95 Parameters: pNode  - The Node whos blobs need rendering [INPUTS] pRegion - The render region to draw into Definition at line 1433 of file blobs.cpp. { // Find out which spread the selection is on SelRange* Selected = GetApplication()->FindSelection(); Node* pNode = Selected->FindFirst(); // go and render the blobs if there are any selected nodes if (pNode!=NULL && DrawBlobsAtAll) { Spread* pSpread = pNode->FindParentSpread(); // Render what we need to RenderRegion* pRegion = DocView::RenderOnTop(Rect, pSpread, ClippedEOR); while (pRegion) { // Find the first selected object in the tree; Node* pNode = Selected->FindFirst(); while(pNode) { // Render only those blobs that are changing state (ie those appearing or disappearing) RenderRequiredBlobs((NodeRenderable*) pNode, pRegion); // Find the next selected node to render pNode = Selected->FindNext(pNode); } // Go find the next region pRegion = DocView::GetNextOnTop(Rect); } } // Bodge to stop fill meshes EOR each other out. AttrFillGeometry::LastRenderedMesh = NULL; }

void BlobManager::RenderSpecificBlobs (  NodeRenderable *  pNode, RenderRegion *  pRegion, BOOL  DrawObject, BOOL  DrawArtistic, BOOL  DrawFill, BOOL  DrawTiny, BOOL  DrawPen, BOOL  DrawToolObject, BOOL  DrawEffect )  [protected]

Renders only the blobs specified. This is called from the Add and Remove Interest Functions to add new types of blob to the display or take types of blob that are no longer needed off the display. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 22/6/94 Parameters: pNode  - The node to draw the blobs for [INPUTS] pRegion - The region to render them into DrawObject - Do we want to draw the Object Blobs DrawArtistic - Do we want to draw the Artistic Blobs DrawFill - Do we want to draw the Fill Blobs DrawTiny - Do we want to draw the Tiny Blobs DrawPen - Do we want to draw the Pen Blobs DrawToolObject - Do we want to draw the ToolObject Blobs Definition at line 1490 of file blobs.cpp. { // We know that the node is a renderable ink as it is selected ENSURE( pNode->IsKindOf(CC_RUNTIME_CLASS(NodeRenderableInk)), "Selected object was not Renderable!"); // Render the Object Blobs of this node if (DrawObject) pNode->RenderObjectBlobs(pRegion); // Render the Artistic blobs of this node if (DrawArtistic) pNode->RenderArtisticBlobs(pRegion); // Render the Fill blobs of this node if (DrawFill) pNode->RenderAppliedFillBlobs(pRegion); // Render the tiny blobs of this node if (DrawTiny) pNode->RenderTinyBlobs(pRegion); // Render the Pen blobs of this node if (DrawPen) pNode->RenderPenBlobs(pRegion); // Render the ToolObject blobs of this node if (DrawToolObject) pNode->RenderToolObjectBlobs(pRegion); // Render the Effect blobs of this node if (DrawEffect) pNode->RenderEffectBlobs(pRegion); }

void BlobManager::RenderSpecificBlobsOnSelection (  DocRect *  Rect, BOOL  DrawObject, BOOL  DrawArtistic, BOOL  DrawFill, BOOL  DrawTiny, BOOL  DrawPen, BOOL  DrawToolObject, BOOL  DrawEffect )  [protected]

Renders only the blobs specified. This is called from the Add and Remove Interest Functions to add new types of blob to the display or take types of blob that are no longer needed off the display. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/6/95 Parameters: pNode  - The node to draw the blobs for [INPUTS] pRegion - The region to render them into DrawObject - Do we want to draw the Object Blobs DrawArtistic - Do we want to draw the Artistic Blobs DrawFill - Do we want to draw the Fill Blobs DrawTiny - Do we want to draw the Tiny Blobs DrawPen - Do we want to draw the Pen Blobs DrawToolObject - Do we want to draw the ToolObject Blobs Definition at line 1548 of file blobs.cpp. { // Find out which spread the selection is on SelRange* Selected = GetApplication()->FindSelection(); Node* pNode = Selected->FindFirst(); // go and render the blobs if there are any selected nodes if (pNode!=NULL && DrawBlobsAtAll) { Spread* pSpread = pNode->FindParentSpread(); // Render what we need to RenderRegion* pRegion = DocView::RenderOnTop(Rect, pSpread, ClippedEOR); while (pRegion) { // Find the first selected object in the tree; Node* pNode = Selected->FindFirst(); while(pNode) { // Render only those blobs that are changing state (ie those appearing or disappearing) RenderSpecificBlobs((NodeRenderable*)pNode, pRegion, DrawObject, DrawArtistic, DrawFill, DrawTiny, DrawPen, DrawToolObject, DrawEffect); // Find the next selected node to render pNode = Selected->FindNext(pNode); } // Go find the next region pRegion = DocView::GetNextOnTop(Rect); } } // Bodge to stop fill meshes EOR each other out. AttrFillGeometry::LastRenderedMesh = NULL; }

void BlobManager::RenderToolBlobsOff (  Tool_v1 *  pTool, Spread *  pSpread, DocRect *  pClipRect )

This function will render off the specified tools blobs. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/6/95 Definition at line 1702 of file blobs.cpp. { // If we are not drawing blobs today, then return straight away if (!DrawBlobsAtAll) return; // if (bToolBlobsAreOff) // return; // EOR on in all the render regions that are still rendering, // so that the Blob rendering when the region is finished, // will take them off RenderRegionList* pRegionList = GetApplication()->GetRegionList(); if (!pRegionList->IsEmpty()) { RenderRegion* pRegion = (RenderRegion*)pRegionList->GetHead(); while (pRegion) { // Check the RenderRegion is for the same spread. if (pRegion->GetRenderSpread() == pSpread && pRegion->GetRenderView()==DocView::GetSelected()) { // Render the blobs 'clipped' to this Render Region. DocRect ClipRect = pRegion->GetRegionRect(); pTool->RenderToolBlobs(pSpread, &ClipRect); } // Get the Next render region pRegion = (RenderRegion*)pRegionList->GetNext(pRegion); } } // Take the tool blobs off pTool->RenderToolBlobs(pSpread, pClipRect); bToolBlobsAreOff = TRUE; }

void BlobManager::RenderToolBlobsOn (  Tool_v1 *  pTool, Spread *  pSpread, DocRect *  pClipRect )

This function will render on the specified tools blobs. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/6/95 Definition at line 1657 of file blobs.cpp. { // If we are not drawing blobs today, then return straight away if (!DrawBlobsAtAll) return; // Put the tool blobs on pTool->RenderToolBlobs(pSpread, pClipRect); // Now EOR off in all the render regions that are still rendering, // so that the Blob rendering when the region is finished, // will put them on RenderRegionList* pRegionList = GetApplication()->GetRegionList(); if (!pRegionList->IsEmpty()) { RenderRegion* pRegion = (RenderRegion*)pRegionList->GetHead(); while (pRegion) { // Check the RenderRegion is for the same spread. if (pRegion->GetRenderSpread() == pSpread && pRegion->GetRenderView()==DocView::GetSelected()) { // Render the blobs 'clipped' to this Render Region. DocRect ClipRect = pRegion->GetRegionRect(); pTool->RenderToolBlobs(pSpread, &ClipRect); } // Get the Next render region pRegion = (RenderRegion*)pRegionList->GetNext(pRegion); } } bToolBlobsAreOff = FALSE; }

void BlobManager::ToolInterest (  BlobStyle  Blobs  )

Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 16/6/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: BlobStyle Definition at line 228 of file blobs.cpp. { BlobStyle BlobsToRemove; // Find all the blobs that are NOT selected BlobsToRemove.Object = !Blobs.Object; BlobsToRemove.Artistic = !Blobs.Artistic; BlobsToRemove.Fill = !Blobs.Fill; BlobsToRemove.Tiny = !Blobs.Tiny; BlobsToRemove.Pen = !Blobs.Pen; BlobsToRemove.ToolObject= !Blobs.ToolObject; BlobsToRemove.Effect = !Blobs.Effect; // and remove them RemoveInterest(BlobsToRemove); // Add the selected blobs AddInterest(Blobs); /* // Do we need to render Object Blobs BOOL DrawObject = FALSE; if ((Blobs.Object && !IsObjectBlob) || (!Blobs.Object && IsObjectBlob)) DrawObject = TRUE; // Do we need to render Artistic Blobs BOOL DrawArtistic = FALSE; if ((Blobs.Artistic && !IsArtisticBlob) || (!Blobs.Artistic && IsArtisticBlob)) DrawArtistic = TRUE; // Do we need to render Fill Blobs BOOL DrawFill = FALSE; if ((Blobs.Fill && !IsFillBlob) || (!Blobs.Fill && IsFillBlob)) DrawFill = TRUE; // Do we need to render Tiny Blobs BOOL DrawTiny = FALSE; if ((Blobs.Tiny && !IsTinyBlob) || (!Blobs.Tiny && IsTinyBlob)) DrawTiny = TRUE; // Do we need to render Tiny Blobs BOOL DrawPen = FALSE; if ((Blobs.Pen && !IsPenBlob) || (!Blobs.Pen && IsPenBlob)) DrawPen = TRUE; // Find out about the selection SelRange* Selected = GetApplication()->FindSelection(); Node* pNode = Selected->FindFirst(); // was there a selection to render? if (pNode!=NULL && DrawBlobsAtAll) { // Find the parent spread Spread* pSpread = pNode->FindParentSpread(); // Render what we need to RenderRegion* pRegion = DocView::RenderOnTop(NULL, pSpread, ClippedEOR); while (pRegion) { // Find the first selected object in the tree; Node* pNode = Selected->FindFirst(); while(pNode) { // Render only those blobs that are changing state (ie those appearing or disappearing) RenderSpecificBlobs((NodeRenderable*)pNode, pRegion, DrawObject, DrawArtistic, DrawFill, DrawTiny, DrawPen); // Find the next selected node to render pNode = Selected->FindNext(pNode); } // Go find the next region pRegion = DocView::GetNextOnTop(NULL); } } // Now we have to set the flags to the appropraite value IsFillBlob = Blobs.Fill; IsArtisticBlob = Blobs.Artistic; IsObjectBlob = Blobs.Object; IsTinyBlob = Blobs.Tiny; IsPenBlob = Blobs.Pen; // Bodge to stop fill meshes EOR each other out. AttrFillGeometry::LastRenderedMesh = NULL; */ }

---

Member Data Documentation

BOOL BlobManager::bToolBlobsAreOff [protected]

Definition at line 284 of file blobs.h.

BOOL BlobManager::DrawBlobsAtAll [protected]

Definition at line 280 of file blobs.h.

BOOL BlobManager::IsArtisticBlob [protected]

Definition at line 273 of file blobs.h.

BOOL BlobManager::IsEffectBlob [protected]

Definition at line 277 of file blobs.h.

BOOL BlobManager::IsFillBlob [protected]

Definition at line 271 of file blobs.h.

BOOL BlobManager::IsObjectBlob [protected]

Definition at line 272 of file blobs.h.

BOOL BlobManager::IsPenBlob [protected]

Definition at line 275 of file blobs.h.

BOOL BlobManager::IsTinyBlob [protected]

Definition at line 274 of file blobs.h.

BOOL BlobManager::IsToolObjectBlob [protected]

Definition at line 276 of file blobs.h.

BOOL BlobManager::RemovingBlobs [protected]

Definition at line 283 of file blobs.h.

---

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

• Kernel/blobs.h (r1785/r1282)
• Kernel/blobs.cpp (r1785/r1601)

---