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 range.cpp. { if (bGetCopy) return EffectsStack::GetEffectsStackFromSelection(this, bEscapeDerived); if (m_pEffectsStack==NULL) m_pEffectsStack = EffectsStack::GetEffectsStackFromSelection(this, bEscapeDerived); return m_pEffectsStack; }

Node * SelRange::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). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 04/01/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: NULL, or a pointer to the last node that was selected This information is used by entities such as the colour editor (which needs to know the last object selected when it recieves a SelChanged message, so it can make an intelligent guess at a good colour to edit) See also: SelRange::Update Returns: Errors: - Definition at line 4758 of file range.cpp. { if (pLastSelectedNode != NULL) // If we know a last-selected node { if (!pLastSelectedNode->IsSelected() || // ...& is no longer selected... pLastSelectedDoc != Document::GetSelected()) // ...or was in a different doc... { pLastSelectedNode = NULL; // ...then forget about it pLastSelectedDoc = NULL; } } return(pLastSelectedNode); }

ListRange * SelRange::GetTopClassRange (  CCRuntimeClass *  pClass, BOOL  bClassOnly = TRUE, BOOL  bIgnorePassThroughEffects = FALSE, Node **  ppMasterNode = NULL, INT32 *  piStackPos = NULL )

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 13/05/2005 Parameters: pClass  - pointer to class descriptor for class we're looking for [INPUTS] pMasterNode  - pointer to master node (sample node from consistent range) or NULL [OUTPUTS] iStackPos - index into effect stack or STACKPOS_INVALID if range not valid in stack Returns: - Errors: - See also: - Definition at line 4903 of file range.cpp. { CCRuntimeClass* pEffectClass = NULL; Node* pFirstEffectNode = NULL; // First get the type of the nodes in the cached range if (m_pEffectClassRange) pFirstEffectNode = m_pEffectClassRange->FindFirst(); if (pFirstEffectNode) pEffectClass = pFirstEffectNode->GetRuntimeClass(); if (m_pEffectClassRange==NULL || pClass!=pEffectClass || m_bEffectClassNodesOnly!=bClassOnly) { if (m_pEffectClassRange) delete m_pEffectClassRange; m_pEffectClassRange = EffectsStack::GetTopClassRange(pClass, bClassOnly, bIgnorePassThroughEffects, ppMasterNode, piStackPos, this, !bIgnorePassThroughEffects); m_bEffectClassNodesOnly = bClassOnly; } else { if (ppMasterNode) *ppMasterNode = pFirstEffectNode; if (piStackPos) *piStackPos = STACKPOS_INVALID; } return m_pEffectClassRange; }

BOOL SelRange::IsCached (   )  [inline]

Definition at line 603 of file range.h. { return Cached; }

BOOL SelRange::IsSelRangeGagged (   )

For getting the current gag state of the SelRange. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 20/05/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the SelRange is gagged, FALSE if it isn't Definition at line 5757 of file range.cpp. { return IsGagged; }

String_256 SelRange::LayerDescription (  DescriptionFormat  nFormat  )  [private]

Builds the text displayed by the status-bar code. Rewritten to be internationally portable. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 3/1/96 Parameters: nFormat  an enum describing how this description will be used, [INPUTS] eg. STATUS_BAR (anything else returns empty string). Returns: A string containing a text description of what is selected, if anything, on the selected layer(s). Definition at line 5331 of file range.cpp. { // Check if there's nothing to do. String_256 strDescription; if (nFormat != STATUS_BAR || FindFirst() == NULL || FindLast() == NULL) return strDescription; // Do we need to describe the selection as "inside"? BOOL fIsInside = ContainsSelectInside() && !(Count() == 1 && IS_A(FindFirst(), CaretNode)); // DMc change Layer* pLastLayer = NULL; pLastLayer = (Layer*) (FindLast()->FindParent(CC_RUNTIME_CLASS(Layer))); //Graham 8/7/97: Now, get the document Document* pDocument = pLastLayer->FindDocument(); if (pDocument == NULL) { // No document yet. So return an empty string return String_256(""); } //Is there only one layer in the document? if (pDocument->GetNumLayers()==1) { //Yes. So we needn't put the layer name into the description string. //So, is the selection "inside"? if(fIsInside) { //Yes. So return "(inside)" as our description string return String_256(_R(IDS_SINGLELAYER_INSIDE)); } else { //No. So return an empty string return String_256(""); } } // Count how many layers contain select objects if more than one object is selected. // INT32 nLayers=0; INT32 nLayersWithSelected = 1; if (Count() > 1) { // Loop over all the layers in the doc (?) Layer* pLayer = (Layer*) (FindFirst()->FindParent(CC_RUNTIME_CLASS(Layer))); while (pLayer != pLastLayer) { // Over-run? ERROR3IF(pLayer == NULL, "Couldn't find the last layer in SelRange::LayerDescription"); // Determine if pLayer has any selected objects. Node* pObj = pLayer->FindFirstChild(); while (pObj != NULL) { // Is selected or has selected children? if (pObj->IsSelected() || pObj->IsParentOfSelected()) { // Yes, go on to next layer. nLayersWithSelected++; break; } // No, consider the next sibling. pObj = pObj->FindNext(); } // Go on to the next sibling layer. pLayer = (Layer*) (pLayer->FindNext(CC_RUNTIME_CLASS(Layer))); } } // Is there more than one layer with selected objects? if (nLayersWithSelected > 1) { // Yes, so we want a string with one of these formats:- // 'on <no. of layers> layers' or 'on <no. of layers> layers (inside)' UINT32 nID = (fIsInside) ? _R(IDS_ON_MANY_LAYERS_INSIDE) // " on #1%d layers (inside)" : _R(IDS_ON_MANY_LAYERS); // " on #1%d layers" strDescription.MakeMsg(nID, (INT32) nLayersWithSelected); } else { // Only one layer with a selection. Decide whether to use 'inside' as a prefix or suffix. BOOL fShouldSuffix = (Count() != 1); // Does the name of the layer contain the word 'layer'/'Frame' in whatever language?) BOOL fLayerReferredTo = FALSE; // RanbirR - 28/10/97 - Changed for Camelot v2, Frame/Layer integration. #ifdef WEBSTER // Choose which format string to use. This is the proper way to construct portable strings! static UINT32 nFormat[8] = { _R(IDS_ON_FRAME_OUTSIDE_NOREF), // " on frame #1%S" _R(IDS_ON_FRAME_OUTSIDE_NOREF), _R(IDS_ON_FRAME_OUTSIDE_REF), // " on #1%S" _R(IDS_ON_FRAME_OUTSIDE_REF), _R(IDS_ON_FRAME_INSIDE_NOREF_PREFIX), // " inside on frame #1%S" _R(IDS_ON_FRAME_INSIDE_NOREF_SUFFIX), // " on frame #1%S (inside)" _R(IDS_ON_FRAME_INSIDE_REF_PREFIX), // " inside on #1%S" _R(IDS_ON_FRAME_INSIDE_REF_SUFFIX) // " on #1%S (inside)" }; String_256 strLayerID = pLastLayer->GetLayerID(); strLayerID.toUpper(); fLayerReferredTo = (strLayerID.Sub(String_64(_R(IDS_LOCAL_LAYER_NOUN))) != -1); #else static UINT32 nFormat[8]; // Determine the document mode. BOOL IsFrame = pLastLayer->IsFrame(); // Frame Mode. if(IsFrame) { nFormat[0] = _R(IDS_ON_FRAME_OUTSIDE_NOREF); // " on frame #1%S" nFormat[1] = _R(IDS_ON_FRAME_OUTSIDE_NOREF); nFormat[2] = _R(IDS_ON_FRAME_OUTSIDE_REF); // " on #1%S" nFormat[3] = _R(IDS_ON_FRAME_OUTSIDE_REF); nFormat[4] = _R(IDS_ON_FRAME_INSIDE_NOREF_PREFIX); // " inside on frame #1%S" nFormat[5] = _R(IDS_ON_FRAME_INSIDE_NOREF_SUFFIX); // " on frame #1%S (inside)" nFormat[6] = _R(IDS_ON_FRAME_INSIDE_REF_PREFIX); // " inside on #1%S" nFormat[7] = _R(IDS_ON_FRAME_INSIDE_REF_SUFFIX); // " on #1%S (inside)" // Is the Word 'frame' already included in the text name. String_256 strLayerID = pLastLayer->GetLayerID(); strLayerID.toUpper(); fLayerReferredTo = (strLayerID.Sub(String_64(_R(IDS_LOCAL_FRAME_NOUN))) != -1); } // Layer Mode. else { nFormat[0] = _R(IDS_ON_LAYER_OUTSIDE_NOREF); // " on layer #1%S" nFormat[1] = _R(IDS_ON_LAYER_OUTSIDE_NOREF); nFormat[2] = _R(IDS_ON_LAYER_OUTSIDE_REF); // " on #1%S" nFormat[3] = _R(IDS_ON_LAYER_OUTSIDE_REF); nFormat[4] = _R(IDS_ON_LAYER_INSIDE_NOREF_PREFIX); // " inside on layer #1%S" nFormat[5] = _R(IDS_ON_LAYER_INSIDE_NOREF_SUFFIX); // " on layer #1%S (inside)" nFormat[6] = _R(IDS_ON_LAYER_INSIDE_REF_PREFIX); // " inside on #1%S" nFormat[7] = _R(IDS_ON_LAYER_INSIDE_REF_SUFFIX); // " on #1%S (inside)" // Is the Word 'layer' already included in the text name. String_256 strLayerID = pLastLayer->GetLayerID(); strLayerID.toUpper(); fLayerReferredTo = (strLayerID.Sub(String_64(_R(IDS_LOCAL_LAYER_NOUN))) != -1); } #endif UINT32 nID = nFormat[(fIsInside << 2) | (fLayerReferredTo << 1) | fShouldSuffix]; // Substitute the layer's name into the correct format string. strDescription.MakeMsg(nID, &(pLastLayer->GetLayerID())); } // OK, return the resulting description. return strDescription; }

BOOL SelRange::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. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> (from Karim MacDonald) Date: 21/04/2005 (25 August 2000) Parameters: TellWorld  Whether or not to tell everyone if the selection changes. [INPUTS] Note that if this function is called from within an Op, this flag can be set to FALSE as the selection will be updated on completion of the Op. If  any text characters are selected, then their parent text stories will be [OUTPUTS] selected instead. Returns: TRUE if successful, FALSE otherwise. Definition at line 5945 of file range.cpp. { BOOL bChangedSelection = FALSE; Node* pNode = FindFirst(); while (pNode) { // Push any text sub-selection up to the selected story if (pNode->IsAnAbstractTextChar()) { ((NodeRenderableInk*)pNode)->DeSelect(TRUE); TextStory* pStory = ((AbstractTextChar*)pNode)->FindParentStory(); if (pStory != NULL) { pStory->Select(TRUE); bChangedSelection = TRUE; } } // Push subselection of fit-text-to-curve node up to the selected story if (bPathInText && pNode->IsNodePath() && pNode->FindParent()->IsKindOf(CC_RUNTIME_CLASS(TextStory))) { ((TextStory*)pNode->FindParent())->Select(TRUE); bChangedSelection = TRUE; } // Push subselection of fit-text-to-curve node up to the selected story if (bPathInText && pNode->IsNodePath() && pNode->FindParent()->IsKindOf(CC_RUNTIME_CLASS(TextStory))) { ((TextStory*)pNode->FindParent())->Select(TRUE); bChangedSelection = TRUE; } // Push subselection of fit-text-to-curve node up to the selected story if (bPathInText && pNode->IsNodePath() && pNode->FindParent()->IsKindOf(CC_RUNTIME_CLASS(TextStory))) { ((TextStory*)pNode->FindParent())->Select(TRUE); bChangedSelection = TRUE; } // Push subselection of fit-text-to-curve node up to the selected story if (bPathInText && pNode->IsNodePath() && pNode->FindParent()->IsKindOf(CC_RUNTIME_CLASS(TextStory))) { ((TextStory*)pNode->FindParent())->Select(TRUE); bChangedSelection = TRUE; } if (!bTextOnly) { // Do the same thing for sub-selection inside controller nodes NodeCompound* pController = pNode->GetParentController(); if (pController && pNode->NeedsParent(pController)) { ((NodeRenderableInk*)pNode)->DeSelect(TRUE); NodeRenderableInk* pInkNode = pController->GetInkNodeFromController(); if (pInkNode) pInkNode->Select(TRUE); bChangedSelection = TRUE; } } pNode = FindNext(pNode); } if (bChangedSelection) Update(TellWorld); return TRUE; }

String_64 SelRange::ObjectDescription (  DescriptionFormat  Format  )  [private]

Returns a string describing the objects in the selection, see SelRange::Describe for a description of the format. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 30/6/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - Scope: private See also: SelRange::Describe SelRange::LayerDescription Definition at line 5191 of file range.cpp. { String_256 Description; Node* Current = FindFirst(); // Implementation if (Current != NULL) // There are objects in range { // Use shortended description for Menus BOOL Verbose = (Format != MENU); Node* FirstInRange = Current; // Simon - 17/08/95. Pre Quickshapes the NodeType was the runtime class of the object // we now use description strings. This should still be quick cos most will be // identifiable by the first char. String NodeType = Current->Describe(FALSE, Verbose); // Use singular // -------------------------------------------------------------------------------- // Determine if there is more than one type of object selected BOOL OneTypeOfObject = TRUE; // TRUE if range contains only // one type of object. while ((Current = FindNext(Current)) != NULL) { if (Current->Describe(FALSE, Verbose) != NodeType) // Range contains more than one // type of object { // Current object is not the same type as the first so we know there is more // than one type of object. OneTypeOfObject = FALSE; break; } } UINT32 NumObjectsInRange = Count(); // Count is cached ERROR3IF(NumObjectsInRange <= 0, "No objects selected"); if (OneTypeOfObject) { // All objects in the selection are of the same type String_32 Name; BOOL UseClassToDescribe = TRUE; NodeGroup* FirstGroup = NULL; if (FirstInRange->GetRuntimeClass() == CC_RUNTIME_CLASS(NodeGroup)) { UseClassToDescribe = FALSE; // If all selected groups have the same name then the name is used in the // description FirstGroup = (NodeGroup*)FirstInRange; NodeGroup* CurrentGroup = FirstGroup; Name = CurrentGroup->GetName(); if (!(Name.IsEmpty())) { do { CurrentGroup=(NodeGroup*)FindNext(CurrentGroup); if (CurrentGroup != NULL) { if (CurrentGroup->GetName() != Name) { // A group has been found with a different name. Stop the search and // use the class to describe the selection. UseClassToDescribe = TRUE; break; } } } while (CurrentGroup != NULL); } else { UseClassToDescribe = TRUE; } } if (UseClassToDescribe) { Description = (FirstInRange->Describe(NumObjectsInRange>1, Verbose)); } else { // Use the group name to describe the selection ERROR3IF(FirstGroup == NULL, "FirstGroup should be the first selected group"); if (NumObjectsInRange > 1) { Description = Pluralise(FirstGroup->GetName()); } else { Description = FirstGroup->GetName(); } } } else { // There must be more than one type of selected objects // ERROR3IF(NumObjectsInRange <= 1, "Only a single object is in range"); // Cos there are multiple objects of different types we describe them as 'objects' Description = String(_R(IDS_OBJECTS)); } if (Format == STATUS_BAR) { // If the description is to be displayed on the status bar, then it needs to be prefixed // with the number of objects in the range Description._MakeMsg( _T("#1%lu #2%S"),NumObjectsInRange, &Description); } } else // No objects are selected { // Only show "Nothing selected:" if there are documents open. PORTNOTE("other","Removed ScreenView usage") #ifndef EXCLUDE_FROM_XARALX if (ScreenView::HowMany() > 0) Description = String_32(_R(IDS_NO_OBJECTS_SEL)); #endif } return (Description); }

String_256 SelRange::Pluralise (  String_256  Noun  )  [static]

Converts the Noun string to a plural. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 30/6/94 Parameters: Noun,:  The word to pluralise [INPUTS] -  [OUTPUTS] Returns: The plural of Noun Errors: - See also: - Definition at line 5513 of file range.cpp. { // A bit simple for now return (Noun += String_8(_R(IDS_K_RANGE_PLURAL))); }

void SelRange::SelChangedCommit (   )  [private]

This private fn gets called to inform the world that the selection has changed / update the status bar etc. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 18/7/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - Scope: private See also: - Definition at line 5019 of file range.cpp. { BOOL DifferentDoc = (ScopeDocument != Document::GetSelected()); // Tell the world that the selection has changed if (!IsGagged) { BROADCAST_TO_ALL(SelChangingMsg(SelChangingMsg::SELECTIONCHANGED, DifferentDoc)); InformedSelChanged = TRUE; // Update the status bar description of the selection DescribeSelectionInStatusBar(); } // Update our idea of the current scope document ScopeDocument = Document::GetSelected(); Node* pNode = FindFirst(); if (pNode != NULL) { // Set the selected spread to be the parent spread of the first node in the selection. pNode = pNode->FindParent(CC_RUNTIME_CLASS(Spread)); ERROR3IF(pNode == NULL,"first node in selection doesn't have a parent spread!"); // Ensure selected Doc, DocView, and Spread are legal // (If pNode is NULL, it will try to sort out our life for us) Document::SetSelectedViewAndSpread(ScopeDocument, NULL, (Spread *)pNode); } }

void SelRange::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. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 20/05/95 Parameters: NewState  - TRUE to gag the SelRange - FALSE to ungag it [INPUTS] -  [OUTPUTS] Returns: - Definition at line 5740 of file range.cpp. { IsGagged = NewState; }

void SelRange::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). Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 18/02/94 Parameters: RangeControlFlags,:  Specifies the properties of the nodes to be included [INPUTS] in the range. Or it would if we didn't ignore it. -  [OUTPUTS] Returns: - Errors: - See also: - Reimplemented from Range. Definition at line 4004 of file range.cpp. { TRACE( _T("Warning: Calls to SelRange::SetRangeControl have no effect")); }

void SelRange::Update (  BOOL  TellWorld = FALSE, Node *  LastSelectedNode = NULL )  [virtual]

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. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> (Changed by Phil, 30/11/94) Date: 18/5/94 (Was an inline function prior to this) Parameters: BOOL  TellWorld: When TRUE the function will inform the world that the [INPUTS] selection has changed. Normally the selection is changed in an operation and it is unneccesary to broadcast a SelChangingMsg at this point because this will occur at the end of the operation. However If the selection is changed outside of an operation then the flag should be set to TRUE. LastSelectedNode - NULL (the default), or a pointer to the node being selected. This is remembered for return by GetLastSelectedNode, which is used by entities such as the colour editor to try to show a sensible colour for editing. Parameters: -  [OUTPUTS] Returns: - See also: SelRange::GetLastSelectedNode; SelRange::UpdateBounds Definition at line 4803 of file range.cpp. { Cached = FALSE; CachedCount = 0; InformedSelChanged = FALSE; FirstNode = NULL; LastNode = NULL; CachedBounds = FALSE; CachedBoundsNoAttrs = FALSE; LastFindNextNode = NULL; // Ensure all on-the-fly FindNext caching is wiped // destroy the CommonAttribute cache, a new one will be created the next time // a user calls the if (pCommonAttribCache) { delete (pCommonAttribCache); pCommonAttribCache = NULL; } // Get rid of any postprocessor stack that has been created // Note that this means that people using the PostPro stack at times when Update is likely to be called // must make local copies and NOT rely on this cached copy! // And there's no such thing as a "Fog Chicken" if (m_pEffectsStack) { delete m_pEffectsStack; m_pEffectsStack = NULL; } if (m_pEffectClassRange) { delete m_pEffectClassRange; m_pEffectClassRange = NULL; } m_pAreaNode = NULL; // Remember the last node which was selected (or if it's NULL, forget the last // node, because we cannot any longer guarantee (a) that it is still selected, or // (far more importantly) (b) if it still exists if (LastSelectedNode != NULL) { pLastSelectedNode = LastSelectedNode; pLastSelectedDoc = Document::GetSelected(); } // Inform the DialogBars that the system state has changed so that they can refresh // themselves DialogBarOp::SetSystemStateChanged(); if (TellWorld) { // Broadcast message/ update status bar etc. SelChangedCommit(); } }

void SelRange::UpdateBounds (   )

To inform the SelRange that its bounds have changed. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 12/12/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 4949 of file range.cpp. { CachedBounds = FALSE; CachedBoundsNoAttrs = FALSE; // 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 bounds 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! // 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 }

---

Friends And Related Function Documentation

friend class SelRangeMessageHandler [friend]

Definition at line 531 of file range.h.

---

Member Data Documentation

BOOL SelRange::Cached [private]

Definition at line 627 of file range.h.

DocRect SelRange::CachedBBox [private]

Definition at line 639 of file range.h.

DocRect SelRange::CachedBBoxNoAttrs [private]

Definition at line 646 of file range.h.

DocRect SelRange::CachedBlobBBox [private]

Definition at line 642 of file range.h.

BOOL SelRange::CachedBounds [private]

Definition at line 635 of file range.h.

BOOL SelRange::CachedBoundsNoAttrs [private]

Definition at line 645 of file range.h.

INT32 SelRange::CachedCount [private]

Definition at line 648 of file range.h.

BOOL SelRange::InformedSelChanged [private]

Definition at line 630 of file range.h.

BOOL SelRange::IsGagged [private]

Definition at line 632 of file range.h.

Node* SelRange::LastFindNextNode [private]

Definition at line 665 of file range.h.

BOOL SelRange::m_bEffectClassNodesOnly [private]

Definition at line 678 of file range.h.

Node* SelRange::m_pAreaNode [private]

Definition at line 681 of file range.h.

ListRange* SelRange::m_pEffectClassRange [private]

Definition at line 674 of file range.h.

EffectsStack* SelRange::m_pEffectsStack [private]

Definition at line 672 of file range.h.

SelRangeMessageHandler* SelRange::MessageHandler [private]

Definition at line 669 of file range.h.

Document* SelRange::pLastSelectedDoc [private]

Definition at line 662 of file range.h.

Node* SelRange::pLastSelectedNode [private]

Definition at line 659 of file range.h.

Document* SelRange::ScopeDocument [private]

Definition at line 624 of file range.h.

---

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

• Kernel/range.h (r1785/r1252)
• Kernel/range.cpp (r1785/r1744)

---