SelRange Class Reference

This class represents a range of selected nodes directly under the Selection Surface. The Selection Surface is the highest surface in the tree at which the user can select nodes. It is usually the child list of Layers but the user can push the Selection Surface lower, into groups, using Select Inside. More...

#include <range.h>

Inheritance diagram for SelRange:

List of all members.

Public Member Functions
	SelRange ()
	SelRange constructor. Defines a SelRange to be a range containing selected objects and that range is allowed to cross layers.
	~SelRange ()
	SelRange (SelRange &From)
	SelRange constructor. Defines a SelRange to be a range containing selected objects and that range is allowed to cross layers.
void	FreshenCache ()
	Internal call for caching useful information Determines if the SelRange information cache is valid, and if not, scans the entire range to accumulate that information, and freshens the cache.
virtual void	Update (BOOL TellWorld=FALSE, Node *SelectedNode=NULL)
	To inform the SelRange that the selection has changed This invalidates the SelRange's selection-info cache so it will be recached when info is next requested.
void	UpdateBounds ()
	To inform the SelRange that its bounds have changed.
virtual void	BroadcastAnyPendingMessages (void)
	Ensures that any pending SelChangingMsg broadcasts are sent immediately. This should be called by any code which calls SelRange::Update with the default FALSE (don't broadcast yet) flag parameter, to ensure that soon after the change the delayed message broadcast occurs.
virtual void	AttrsHaveChanged ()
	This function gets called to inform the range that attributes applied to its objects have, or may have changed. It deletes the Common attribute cache if one exists.
virtual DocRect	GetBoundingRect (BOOL bPromoteToControllers=FALSE)
	To find the bounding box of all objects in a selection range.
DocRect	GetBlobBoundingRect ()
	To find the bounding box of all objects in a selection range, including their selection blobs.
virtual DocRect	GetBoundsWithoutAttrs (void)
	To find the bounding box of all objects in a selection range, not including the effects of any attributes applied thereto.
Node *	FindLast ()
	The purpose of this function is to find the last node in a SelRange.
void	SetRangeControl (RangeControl RangeControlFlgs)
	To prevent the range controls of the SelRange subclass being altered. A call to this function has no effect (other than a TRACE warning msg).
Node *	FindFirst (BOOL AndChildren=FALSE)
	The purpose of this function is to find the first node in a range.
Node *	FindNext (Node *Previous, BOOL AndChildren=FALSE)
	The purpose of this function is to find the next node in the range after Prev.
UINT32	Count ()
	To count the number of nodes in a range.
BOOL	FindObject (CCRuntimeClass *p, Node **pOutput=NULL)
	Scans the selection hunting for a selected object of type pClass. If an object is found, the function will return true, and set pOutput to point at the object (if it was not NULL on entry).
Node *	FindFirstObject (CCRuntimeClass *p)
	Finds the first selected object of the required class. For finding derived classes use FindFirstDerivedObject.
Node *	FindNextObject (CCRuntimeClass *p, Node *Previous)
	Finds the next selected object of the required class. For finding derived classes use FindNextDerivedObject.
Node *	FindFirstDerivedObject (CCRuntimeClass *p)
	Finds the first selected object of the required derived class. For finding extact class matches uses FindFirstObject.
Node *	FindNextDerivedObject (CCRuntimeClass *p, Node *Previous)
	Finds the next selected object of the required derived class. For finding exact class matches use FindNextObject.
String_256	Describe (DescriptionFormat Format)
	This routine returns a description of a range of objects.
void	DescribeSelectionInStatusBar ()
	This function should get called whenever the selection description needs to be displayed. The description is cached.
BOOL	IsCached ()
Node *	GetLastSelectedNode (void)
	To find the last node that was selected. This may be only a short-term memory (i.e. any update of the selection cache will force us to forget the node, so the info may only be available for a short time after the node is selected).
void	ClearLastSelectedNodeIfItIs (Node *TheNodeToCheck)
	Ensures that the SelRange does not retain a pointer to a node (in pLastSelectedNode) which has been destructed. Called by Node::~Node() - not to be called by anyone else.
void	SetGag (BOOL NewState)
	Allows operations to gag the selrange in order to stop it sending SelChanged messages. THIS IS VERY SCARY! The only op that does this it the moment is when the text caret is moving left/right. Whilst the cursor key is down the SelRange is gagged so the cursor movement is not slowed by constant SelChanged messages.
BOOL	IsSelRangeGagged ()
	For getting the current gag state of the SelRange.
BOOL	MakePartialSelectionWhole (BOOL TellWorld=TRUE, BOOL bTextOnly=FALSE, BOOL bPathInText=FALSE)
	Run through the selection and make sure that no children of TextStories are selected - only whole TextStories themselves.
EffectsStack *	GetEffectsStack (BOOL bGetCopy=FALSE, BOOL bEscapeDerived=TRUE)
ListRange *	GetTopClassRange (CCRuntimeClass *pClass, BOOL bClassOnly=TRUE, BOOL bIgnorePassThroughEffects=FALSE, Node **ppMasterNode=NULL, INT32 *piStackPos=NULL)
Static Public Member Functions
static BOOL	DeclarePrefs ()
	Declares any preferences that the SelRange class needs to declare.
static String_256	Pluralise (String_256 Noun)
	Converts the Noun string to a plural.
Private Member Functions
void	FreshenBoundsCache ()
	This function ensures that the CachedBBox and CachedBlobBBox are up-to-date.
String_256	LayerDescription (DescriptionFormat Format)
	Builds the text displayed by the status-bar code. Rewritten to be internationally portable.
String_64	ObjectDescription (DescriptionFormat Format)
	Returns a string describing the objects in the selection, see SelRange::Describe for a description of the format.
void	SelChangedCommit ()
	This private fn gets called to inform the world that the selection has changed / update the status bar etc.
Private Attributes
Document *	ScopeDocument
BOOL	Cached
BOOL	InformedSelChanged
BOOL	IsGagged
BOOL	CachedBounds
DocRect	CachedBBox
DocRect	CachedBlobBBox
BOOL	CachedBoundsNoAttrs
DocRect	CachedBBoxNoAttrs
INT32	CachedCount
Node *	pLastSelectedNode
Document *	pLastSelectedDoc
Node *	LastFindNextNode
SelRangeMessageHandler *	MessageHandler
EffectsStack *	m_pEffectsStack
ListRange *	m_pEffectClassRange
BOOL	m_bEffectClassNodesOnly
Node *	m_pAreaNode
Friends
class	SelRangeMessageHandler

---

Detailed Description

This class represents a range of selected nodes directly under the Selection Surface. The Selection Surface is the highest surface in the tree at which the user can select nodes. It is usually the child list of Layers but the user can push the Selection Surface lower, into groups, using Select Inside.

Author:

Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> & Jason

Date:

28/11/94 (Date this comment added!!! Actually written long before this)

The SelRange also offers a set of cached information pertinent to the selection, such as the bounds, number of objects included, etc. This cache generally makes access to such information much more efficient than a brute force treesearch.

Definition at line 528 of file range.h.

---

Constructor & Destructor Documentation

SelRange::SelRange (   )

SelRange constructor. Defines a SelRange to be a range containing selected objects and that range is allowed to cross layers. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 16/2/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - Definition at line 3902 of file range.cpp. : Range(NULL, NULL, RangeControl(TRUE,FALSE,TRUE,TRUE)) // Call Range constructor { ScopeDocument = NULL; Cached = FALSE; IsGagged = FALSE; CachedBounds = FALSE; // Bounds not cached CachedBoundsNoAttrs = FALSE; // Nor are bounds-without-attributes InformedSelChanged = FALSE; CachedCount = 0; // Number of objects in range is unknown LastFindNextNode = NULL; // SelectedSpread = NULL; // There is no need to initialise CachedBBox, CachedBlobBBox, or CachedBBoxNoBounds pLastSelectedNode = NULL; // We don't know of any last selected node yet pLastSelectedDoc = NULL; MessageHandler = new SelRangeMessageHandler; m_pEffectsStack = NULL; m_pEffectClassRange = NULL; m_bEffectClassNodesOnly = FALSE; m_pAreaNode = NULL; }

SelRange::~SelRange (   )

Definition at line 3975 of file range.cpp. { if (MessageHandler) { delete MessageHandler; } }

SelRange::SelRange (  SelRange &  Copy  )

SelRange constructor. Defines a SelRange to be a range containing selected objects and that range is allowed to cross layers. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 16/2/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - Definition at line 3945 of file range.cpp. : Range(Copy) { ScopeDocument = Copy.ScopeDocument; Cached = Copy.Cached; IsGagged = Copy.IsGagged; CachedBounds = Copy.CachedBounds; // Bounds not cached CachedBoundsNoAttrs = Copy.CachedBoundsNoAttrs; // Nor are bounds-without-attributes InformedSelChanged = Copy.InformedSelChanged; CachedCount = Copy.CachedCount; // Number of objects in range is unknown LastFindNextNode = Copy.LastFindNextNode; // SelectedSpread = NULL; // There is no need to initialise CachedBBox, CachedBlobBBox, or CachedBBoxNoBounds pLastSelectedNode = Copy.pLastSelectedNode; // We don't know of any last selected node yet pLastSelectedDoc = Copy.pLastSelectedDoc; MessageHandler = new SelRangeMessageHandler; m_pEffectsStack = NULL; m_pEffectClassRange = NULL; m_bEffectClassNodesOnly = FALSE; m_pAreaNode = NULL; }

---

Member Function Documentation

void SelRange::AttrsHaveChanged (   )  [virtual]

This function gets called to inform the range that attributes applied to its objects have, or may have changed. It deletes the Common attribute cache if one exists. void SelRange::AttrsHaveChanged() Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 12/12/94 See also: Range::AttrsHaveChanged Reimplemented from Range. Definition at line 5894 of file range.cpp. { // Removed by Jason, 23/10/95 // After discussion with Simon, this has been removed, as we reckon it's completely // rampant. The selection has not been changed, but the attrs of the selected item(s) // have changed. Perhaps there should be a notification broadcast, but it should NOT // be the SelChangingMsg::SELECTIONCHANGED message that this flag triggers! // In fact, all the current callers (in AttrMgr.cpp) send relevant notification // broadcasts around, so setting us up for another broadcast is silly. // InformedSelChanged = FALSE; #if !defined(EXCLUDE_FROM_RALPH) // Inform the DialogBars that the system state has changed so that they can refresh // themselves DialogBarOp::SetSystemStateChanged(); #endif if (m_pEffectsStack) { m_pEffectsStack->AttrsHaveChanged(); } if (m_pEffectClassRange) m_pEffectClassRange->AttrsHaveChanged(); Range::AttrsHaveChanged(); // Call base class fn }

void SelRange::BroadcastAnyPendingMessages (  void   )  [virtual]

Ensures that any pending SelChangingMsg broadcasts are sent immediately. This should be called by any code which calls SelRange::Update with the default FALSE (don't broadcast yet) flag parameter, to ensure that soon after the change the delayed message broadcast occurs. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 21/10/95 Note: Any pending message is automatically sent when an Op ends. Thus, you only need to call this code directly when you update the selection outside an Op. (e.g. when the selected document changes, etc) See also: SelRange::Update() Definition at line 4992 of file range.cpp. { // If we're not gagged, and we have any pending message broadcast, do it if (!IsGagged && !InformedSelChanged) SelChangedCommit(); }

void SelRange::ClearLastSelectedNodeIfItIs (  Node *  TheNodeToCheck  )  [inline]

Ensures that the SelRange does not retain a pointer to a node (in pLastSelectedNode) which has been destructed. Called by Node::~Node() - not to be called by anyone else. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 4/1/95 Parameters: TheNodeToCheck  - A pointer to a node being destructed. [INPUTS] See also: SelRange::GetLastSelectedNode; Node::~Node Definition at line 703 of file range.h. { if (TheNodeToCheck == pLastSelectedNode) pLastSelectedNode = NULL; }

UINT32 SelRange::Count (   )

To count the number of nodes in a range. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 18/02/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The number of nodes described by the SelRange (may be zero) Notes: After a call to this function, all possible SelRange information will have been cached. The cache is invalidated when the selection changes. Returns: Errors: - Reimplemented from Range. Definition at line 4342 of file range.cpp. { // DMc 18/5/99 // if PromoteToParent is set, then I think we need to recalc this Node * pNode = FindFirst(); INT32 count = 0; while (pNode) { count ++; pNode = FindNext(pNode); } CachedCount = count; return(CachedCount); // Return the cached count }

BOOL SelRange::DeclarePrefs (   )  [static]

Declares any preferences that the SelRange class needs to declare. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 18/08/95 Returns: TRUE if it worked, FALSE if it failed Definition at line 3872 of file range.cpp. { BOOL ok = TRUE; // No preferences today, thank you! return ok; }

String_256 SelRange::Describe (  DescriptionFormat  Format  )

This routine returns a description of a range of objects. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 25/6/93 Parameters: DescriptFormat,:  The format of the description generated. Currently there are [INPUTS] two types of description which can be generated. When DescriptFormat = MENU A description suitable for displaying on a menu is generated. The description will have the form: "rounded rectangle" // For a single rounded rectangle object in the range. "rounded rectangles" // For multiple rounded rectangles in the range. "objects" // For multiple objects of different types in the range. If the range conatains only group nodes which all have the same name then the Group name is used for the description i.e "bannana" // For a single group with the name bananna "bannanas" // For multiple groups all with the name bananna When DescriptionFormat = INFOBAR A description suitable for the infobar is generated. The description will be the same as that generated by the MENU DescriptFormat, except that the descriptions will be prefixed by the number of objects in the range, and will contain a layer description "1 rounded rectangle on layer Blobby" "5 rounded rectangles on layer Blobby "5 bannanas on 4 layers" if one item is selected, and is inside, then the description will look like this "1 bannana 'inside' on layer Blobby" If there is more than one item selected and at least one item is inside then the description will have the word 'inside' appended to it, like this "5 bannanas on 4 layers ('inside')" Parameters: -  [OUTPUTS] Returns: If there are any members in the range then a description of the members in the range is returned, else an empty string is returned. Errors: A resource exception will be thrown if a problem occurs when loading a string resource. See also: - Definition at line 5163 of file range.cpp. { String_256 str = ObjectDescription(Format); SafeAppendString(&str, LayerDescription(Format), FALSE); return str; }

void SelRange::DescribeSelectionInStatusBar (   )

This function should get called whenever the selection description needs to be displayed. The description is cached. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 28/6/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 5539 of file range.cpp. { String_256 strNull(""); GetApplication()->UpdateStatusBarText( &strNull ); }

Node * SelRange::FindFirst (  BOOL  AndChildren = FALSE  )  [virtual]

The purpose of this function is to find the first node in a range. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> (& Jason) (Changed by Phil, 30/11/94) Date: 18/02/94 Returns: If the range contains any members then A pointer to the first node in the range is returned Else NULL is returned Notes: This function, in combination with SelRange::FindNext, will attempt to cache useful information on the fly. This will occur if you scan the range in sequential order from start to finish. See also: SelRange::FindNext; SelRange::FindLast Reimplemented from Range. Definition at line 4034 of file range.cpp. { if (Document::GetSelected() == NULL) { Cached = FALSE; CachedBounds = FALSE; CachedBoundsNoAttrs = FALSE; if (pCommonAttribCache) { delete pCommonAttribCache; pCommonAttribCache = NULL; } return(NULL); // No document so no selection } // If we're in a Document SelChanged message broadcast, somebody might ask us // for info before we get the msg: In this case, we flush the cache, so that // we don't return any out of date info if (Cached && Document::GetSelected() != ScopeDocument) { Update(FALSE, NULL); pLastSelectedNode = NULL; } // Call base class FindFirst function instead of more specialised and less flexible // one in Node. (When FirstNode is already known, calling this func instead of just // returning FirstNode allows children of it to be returned.) Node* pNode = Range::FindFirst(AndChildren); // Don't set FirstNode or LastNode yet, we'll set FirstNode below only if it's // not already been cached. LastNode will only be set when SelRange::FindNext // reaches the end of the range. if (!Cached || CachedCount < 0) // If cached count is invalid/incomplete { Cached = FALSE; if (pCommonAttribCache) { delete pCommonAttribCache; pCommonAttribCache = NULL; } CachedBounds = FALSE; if (pNode == NULL) { // No objects in range. Note that in this case // the BBoxes will be recalculated whenever // requested, so we don't need to touch them CachedCount = 0; FirstNode = NULL; LastNode = NULL; } else { // Range contains at least some members! // // Only allow primary members of the range to be counted and have their bounds // accumulated by setting the AndChildren flag FALSE on the InRange test... if ( InRange(pNode,FALSE) ) { FirstNode = pNode; CachedBBox = ((NodeRenderableBounded*)FirstNode)->GetBoundingRect(); CachedCount = -1; } else CachedCount = 0; } } return(LastFindNextNode = pNode); }

Node * SelRange::FindFirstDerivedObject (  CCRuntimeClass *  pClass  )

Finds the first selected object of the required derived class. For finding extact class matches uses FindFirstObject. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 20/05/95 Parameters: pClass  = A runtime class [INPUTS] -  [OUTPUTS] Returns: A pointer to the first selected object derived from the class specified. NULL if none found See also: SelRange::FindObject, SelRange::FindFirstObject Definition at line 5835 of file range.cpp. { Node* pNode = FindFirst(); while ((pNode != NULL) && !pNode->IsKindOf(pClass)) { pNode = FindNext(pNode); } return pNode; }

Node * SelRange::FindFirstObject (  CCRuntimeClass *  pClass  )

Finds the first selected object of the required class. For finding derived classes use FindFirstDerivedObject. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 20/05/95 Parameters: pClass  = A runtime class [INPUTS] -  [OUTPUTS] Returns: A pointer to the first selected object that is the class specified. NULL if none found See also: SelRange::FindObject, SelRange::FindFirstDerivedObject Definition at line 5777 of file range.cpp. { Node* pNode = FindFirst(); while ((pNode != NULL) && (pNode->GetRuntimeClass() != pClass)) { pNode = FindNext(pNode); } return pNode; }

Node * SelRange::FindLast (   )  [virtual]

The purpose of this function is to find the last node in a SelRange. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 02/03/94 Returns: If the range contains any members then A pointer to the last node in the range is returned Else NULL is returned Notes: If the LastNode value is not cached, then this will necessitate a scan of the entire selction range to determine (and cache) the LastNode. See also: SelRange::FindFirst; Reimplemented from Range. Definition at line 4215 of file range.cpp. { FreshenCache(); // Ensure the cache is valid return(LastNode); // Return cached LastNode value }

Node * SelRange::FindNext (  Node *  Previous, BOOL  AndChildren = FALSE )  [virtual]

The purpose of this function is to find the next node in the range after Prev. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> (& Jason) (Changed by Phil, 30/11/94) Date: 18/02/94 Parameters: Prev,:  The previous node in the range (usually returned from a [INPUTS] Range::FindFirst, or a previous Range::FindNext call). -  [OUTPUTS] Returns: If the range contains any more members then A pointer to the next node in the range is returned (NOTE this does not return members of a selected group object) Else NULL is returned Notes: This function, in combination with SelRange::FindFirst, will attempt to cache useful information on the fly. This will occur if you scan the range in sequential order from start to finish. See also: SelRange::FindFirst; Range::findNext Returns: Errors: An assertion failure will occur if: There are no more nodes to search and the last node to search was not found. The pointer passed in is NULL Technical Notes: This function attempts to cache as much useful information as possible. After reaching the last node of a range, it has cached the first and last pointers. If the client progressed through the range in a sequential fashion (each 'Previous' pointer passed in was returned by the previous FindNext call) then a cached count of the number of objects is also recorded. If this is not the case, then the count will be set to zero, which forces the Count() function to re-scan the entire range to determine the count. Note that during this process CachedCount is zero if the count is invalid, or a NEGATIVE accumulated count of number of objects counted so far. If the value is positive, it is already cached. While the CachedCount is valid, an overall Bounding Box will also be cached. Reimplemented from Range. Definition at line 4152 of file range.cpp. { // Preconditions // ERROR2IF(Previous==NULL,NULL,"NULL pointer passed to SelRange::FindNext"); NodeRenderableBounded* pNext; if (Previous == NULL) return(LastFindNextNode = NULL); if (CachedCount < 0 && Previous != LastFindNextNode) // If accumulating a count, and CachedCount = 0; // not progressing sequentially through // the range, abandon the cached count. // Call base class FindNext... pNext = (NodeRenderableBounded*) Range::FindNext(Previous, AndChildren); if (!Cached) { if (pNext != NULL) // If there is another node { if (CachedCount < 0 && InRange(pNext,FALSE)) { CachedCount--; // and if count still valid, accumulate it CachedBBox = CachedBBox.Union(pNext->GetBoundingRect()); } } else { if (CachedCount < 0) { // If there were no more selected nodes Cached = TRUE; // then Last is now true last object ptr CachedCount = -CachedCount; // and count (if any) is now valid LastNode = Previous; // Know that Previous was last, so record that info } } } return ( LastFindNextNode = (Node *) pNext ); // Return, remembering the return value }

Node * SelRange::FindNextDerivedObject (  CCRuntimeClass *  pClass, Node *  Previous )

Finds the next selected object of the required derived class. For finding exact class matches use FindNextObject. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 20/05/95 Parameters: pClass  - A runtime class [INPUTS] Previous - the node to scan from -  [OUTPUTS] Returns: A pointer to the next selected object that is derived from the class specified. NULL if none found See also: SelRange::FindNext, SelRange::FindNextObject Definition at line 5864 of file range.cpp. { ERROR3IF(Previous == NULL, "Previous node pointer was NULL"); if (Previous != NULL) Previous = FindNext(Previous); while ((Previous != NULL) && !Previous->IsKindOf(pClass)) { Previous = FindNext(Previous); } return Previous; }

Node * SelRange::FindNextObject (  CCRuntimeClass *  pClass, Node *  Previous )

Finds the next selected object of the required class. For finding derived classes use FindNextDerivedObject. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 20/05/95 Parameters: pClass  - A runtime class [INPUTS] Previous - the node to scan from -  [OUTPUTS] Returns: A pointer to the next selected object that is the class specified. NULL if none found See also: SelRange::FindNext, SelRange::FindNextDerivedObject Definition at line 5805 of file range.cpp. { ERROR3IF(Previous == NULL, "Previous node pointer was NULL"); if (Previous != NULL) Previous = FindNext(Previous); while ((Previous != NULL) && (Previous->GetRuntimeClass() != pClass)) { Previous = FindNext(Previous); } return Previous; }

BOOL SelRange::FindObject (  CCRuntimeClass *  p, Node **  pOutput = NULL )

Scans the selection hunting for a selected object of type pClass. If an object is found, the function will return true, and set pOutput to point at the object (if it was not NULL on entry). Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 19/01/95 Parameters: pClass  = A runtime class [INPUTS] pOutput = A pointer to a pointer to a node (NULL if none) pOutput  (if non-NULL) is updated to point to the first node of type [OUTPUTS] pClass in the selection. If there is no object of this type, this is returned containing NULL. Returns: TRUE if there is an object of this type in the selection FALSE if not Definition at line 5703 of file range.cpp. { BOOL Sel = FALSE; if (pOutput != NULL) // Set a reasonable return value if we fail *pOutput = NULL; Node *pNode = FindFirst(); while ((pNode!=NULL) && (!Sel)) { Sel = (pNode->GetRuntimeClass() == p); if (!Sel) pNode = FindNext(pNode); } if (Sel && pOutput != NULL) *pOutput = pNode; return Sel; }

void SelRange::FreshenBoundsCache (   )  [private]

This function ensures that the CachedBBox and CachedBlobBBox are up-to-date. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Scope: private Returns: Errors: - See also: SelRange::UpdateBounds Definition at line 4380 of file range.cpp. { FreshenCache(); // Ensure the cache is valid if (!CachedBounds) { // Scan the range and calculate the bounds CachedBBox.MakeEmpty(); CachedBlobBBox.MakeEmpty(); BOOL bOldValue = RangeControlFlags.PromoteToParent; RangeControlFlags.PromoteToParent = TRUE; Node* Current = FindFirst(); while (Current != NULL) { CachedBBox = CachedBBox.Union(((NodeRenderableBounded*)Current)->GetBoundingRect()); Current = FindNext(Current); } RangeControlFlags.PromoteToParent = bOldValue; CachedBounds = TRUE; } }

void SelRange::FreshenCache (   )  [virtual]

Internal call for caching useful information Determines if the SelRange information cache is valid, and if not, scans the entire range to accumulate that information, and freshens the cache. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> (with tattered remnants of Phil's code in there somewhere) Date: 02/03/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Notes: After a call to this function, all possible SelRange information will have been cached. The cache is invalidated when the selection changes. This routine just makes repeated calls to SelRange::FindFirst and FindNext because they will cache any missing information. See also: SelRange::FindFirst; SelRange::FindNext Returns: Errors: - Reimplemented from Range. Definition at line 4249 of file range.cpp. { BOOL NoDocument = (Document::GetSelected() == NULL); Node* pNode = NULL; if (NoDocument || (Cached && Document::GetSelected() != ScopeDocument)) { Cached = FALSE; if (pCommonAttribCache) { delete pCommonAttribCache; pCommonAttribCache = NULL; } CachedBounds = FALSE; FirstNode = LastNode = NULL; CachedCount = 0; CachedBBox.MakeEmpty(); CachedBlobBBox.MakeEmpty(); pLastSelectedNode = NULL; pLastSelectedDoc = NULL; } if (!Cached || CachedCount <= 0 || FirstNode==NULL) // If count not cached, or is invalid { BOOL bOldValue = RangeControlFlags.PromoteToParent; RangeControlFlags.PromoteToParent = TRUE; if ((!Cached && !NoDocument) || FirstNode==NULL) // If FirstNode not cached, find it pNode = FindFirst(); // Call own find first in SelRange function if (FirstNode != NULL) { while (pNode) // Scan the range... { pNode = FindNext(pNode); // by calling own find next in SelRange function } } else { // No objects - Ensure that the bounding boxes are set to 'empty' CachedBBox.MakeEmpty(); CachedBlobBBox.MakeEmpty(); CachedBoundsNoAttrs = FALSE; CachedBBoxNoAttrs.MakeEmpty(); LastNode = NULL; } RangeControlFlags.PromoteToParent = bOldValue; if (!NoDocument && FirstNode!=NULL) { Cached = TRUE; // All useful info possible has been cached CachedBounds = TRUE; } } // This seems to serve no useful purpose other than bringing up an Ensure box // in the middle of some perfectly valid situations. //#ifdef _DEBUG // if (NoDocument) // ERROR3("SelRange called when there is no SelectedDocument!"); //#endif }

DocRect SelRange::GetBlobBoundingRect (  void   )

To find the bounding box of all objects in a selection range, including their selection blobs. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 03/03/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The bounding rectangle of the current selection, including the selection blobs If nothing is selected this will be an empty rectangle. Note that rather than using DocRect::IsEmpty, it may be slightly more efficient to check the empty case with if (SelRange::Count() == 0), as the SelRange caching mechanism results in this being an efficient call. This may also make your code more readable. Notes: After a call to this function, all possible SelRange information will have been cached. The cache is invalidated when the selection changes. See also: SelRange::GetBoundingRect Returns: Errors: - Definition at line 4546 of file range.cpp. { // Get some rectangles DocRect BlobRect; DocRect RealRect; // Make sure they are empty BlobRect.MakeEmpty(); RealRect.MakeEmpty(); // Loop through the selection BOOL bOldValue = RangeControlFlags.PromoteToParent; RangeControlFlags.PromoteToParent = TRUE; Node* Current = FindFirst(); while (Current != NULL) { ERROR3IF(!Current->IsBounded(), "Non-bounded node in selection in GetBlobBoundingRect\n"); if (Current->IsBounded()) { NodeRenderableBounded* pBounded = (NodeRenderableBounded*)Current; // Get the real bounding rect, since this is worked out anyway RealRect = RealRect.Union(pBounded->GetBoundingRect()); // Get the blob bounding rect BlobRect = BlobRect.Union(pBounded->GetBlobBoundingRect()); } // Get the next node in the list Current = FindNext(Current); } // Make sure the basic selection's blob bounds are included (without doing // fully recursive scan of the selection) RangeControlFlags.PromoteToParent = FALSE; Current = FindFirst(); while (Current != NULL) { ERROR3IF(!Current->IsBounded(), "Non-bounded node in selection in GetBlobBoundingRect\n"); if (Current->IsBounded()) { NodeRenderableBounded* pBounded = (NodeRenderableBounded*)Current; // Get the blob bounding rect BlobRect = BlobRect.Union(pBounded->GetBlobBoundingRect()); } // Get the next node in the list Current = FindNext(Current); } RangeControlFlags.PromoteToParent = bOldValue; // It the cached bounds was out of date, we can use the one we have just built if (!CachedBounds) { // Update the cached rectangle and make it as valid CachedBBox = RealRect; CachedBounds = TRUE; } // return the blob bounding rect return BlobRect; }

DocRect SelRange::GetBoundingRect (  BOOL  bPromoteToControllers = FALSE  )  [virtual]

To find the bounding box of all objects in a selection range. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 02/03/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The bounding rectangle of the current selection. If nothing is selected this will be an empty rectangle. Note that rather than using DocRect::IsEmpty, it may be slightly more efficient to check the empty case with if (SelRange::Count() == 0), as the SelRange caching mechanism results in this being an efficient call. This may also make your code more readable. Notes: After a call to this function, all possible SelRange information will have been cached. The cache is invalidated when the selection changes. See also: SelRange::GetBlobBoundingRect Returns: Errors: - Definition at line 4432 of file range.cpp. { FreshenBoundsCache(); // Ensure the cache is valid // This strange stuff is needed because FreshenBoundsCache doesn't necessarilly // loop through the node in this range // Phil 27/10/2004 // BOOL bOldValue = SetPromoteToParent(bPromoteToControllers); // Calculate the union of all nodes within the range DocRect Bounds; NodeRenderableBounded* pNode = (NodeRenderableBounded*) FindFirst(FALSE); while (pNode != NULL) { Bounds = Bounds.Union(pNode->GetBoundingRect()); pNode =(NodeRenderableBounded*)FindNext(pNode, FALSE); } CachedBBox = Bounds; SetPromoteToParent(bOldValue); return(CachedBBox); // Return cached bounding box }

DocRect SelRange::GetBoundsWithoutAttrs (  void   )  [virtual]

To find the bounding box of all objects in a selection range, not including the effects of any attributes applied thereto. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 23/02/95 Returns: The bounds of the selection, not including the effects of attributes (e.g. line widths, etc) This is used (mainly in the selector tool) to provide things like the width and height of objects, exclusive of line width. Notes: The returned bounding box will be "Empty" if there is no selection. Definition at line 4481 of file range.cpp. { // If we happen to have already got this information, then it'll be cached, // but otherwise, we'll have to go and find out. if (!CachedBoundsNoAttrs) { // Set a reasonable default state in case of failure CachedBBoxNoAttrs.MakeEmpty(); // Scan the range, accumulating the bounds. GetBoundingRect is called with a TRUE // parameter in order to get the bounds exclusive of attributes. Node *pNode = FindFirst(); if (pNode != NULL) { // Set the bounds to the bounds of the first object - who can tell what we'll // get if we union an "empty" rectangle with another. CachedBBoxNoAttrs = ((NodeRenderableBounded*)pNode)->GetBoundingRect(TRUE); pNode = FindNext(pNode); while (pNode != NULL) { CachedBBoxNoAttrs = CachedBBoxNoAttrs.Union( ((NodeRenderableBounded*)pNode)->GetBoundingRect(TRUE) ); pNode = FindNext(pNode); } } // And remember that we now have a cached set of bounds CachedBoundsNoAttrs = TRUE; } return(CachedBBoxNoAttrs); }

EffectsStack * SelRange::GetEffectsStack (  BOOL  bGetCopy = FALSE, BOOL  bEscapeDerived = TRUE )

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 16/11/2004 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 4875 of file