Range Class Reference

#include <range.h>

Inheritance diagram for Range:

List of all members.

Public Types
enum	CommonAttribResult { ATTR_COMMON, ATTR_NONE, ATTR_MANY }
Public Member Functions
	Range ()
	Creates an uninitialised range.
virtual	~Range ()
	Range (Node *First, Node *Last, RangeControl RangeControlFlgs)
	The purpose of this function is to create a node range.
	Range (Range &Range)
	Range copy constructor.
Range &	operator= (Range &Range)
	Range = operator.
BOOL	operator== (const Range &) const
	Test for equality of two ranges. Ranges are considered equal if they have the same flags and the same first & last nodes. SeeAlso Range::operator!=.
BOOL	operator!= (const Range &) const
	Test for non-equality of two ranges. Ranges are considered equal if they have the same flags and the same first & last nodes. SeeAlso Range::operator==.
void	SetRangeControl (RangeControl RangeControlFlgs)
	To set the range control for the range.
virtual Node *	FindFirst (BOOL AndChildren=FALSE)
	The purpose of this function is to find the first node in a range.
virtual Node *	FindLast ()
	The purpose of this function is to find the last node in a range. If the range was constructed with a NULL last node specifier then the range is scanned until the last node is found. If a non NULL last node was specified however the value of last is simply returned. It's existance is not verified !.
virtual Node *	FindNext (Node *Previous, BOOL AndChildren=FALSE)
virtual Node *	FindPrev (Node *pNode, BOOL AndChildren=FALSE)
virtual void	Update (BOOL TellWorld=FALSE)
	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.
virtual void	FreshenCache ()
RangeControl	GetRangeControlFlags () const
BOOL	ForceRenderEORAll () const
UINT32	Count ()
BOOL	Contains (Node *pNode, BOOL bAndChildren=FALSE)
	To determin whether a particular node is actually in the range list.
BOOL	ContainsSelectInside ()
BOOL	ConsistsOf (CCRuntimeClass *pccrtSearch, BOOL fIncludeDerivedClasses=TRUE)
	Determines whether the range consists entirely of the given class of object - or of derived classes of the given sort of object.
BOOL	IsEmpty ()
	Determines whether the range is empty.
List *	MakeListOfNodes (BOOL AndChildren=FALSE)
	This function will create and return a pointer to a list representing the objects in the range. It will return NULL if it couldn't create the list due to lack of memory. WARNING! This function creates objects which must be deleted by the calling routine. The last thing we need right now is another bunch of listitems appearing on shutdown.
void	UpdateParentBoundsOfSelection (BOOL AndChildren=FALSE)
	This function updates the parent bounds of all selected objects. It is a lot more efficient than calling ChangeBounds on every node in the selection (cos it uses an algorithm!).
BOOL	MakeAttributeComplete (BOOL CheckForDuplicates=TRUE, BOOL AndChildren=FALSE, BOOL IgnoreComplex=FALSE)
	This function calls NodeRenderableInk::MakeAttributeComplete on every Object in the selection. If we run out of memory then all changes are undone.
void	NormaliseAttributes (BOOL AndChildren=FALSE, BOOL IgnoreComplex=FALSE)
	This function calls NodeRenderableInk::NormaliseAttributes on every Object in the selection.
BOOL	CopyComponentDataToDoc (BaseDocument *pSrcDoc, BaseDocument *pDestDoc, BOOL AndChildren=FALSE)
	Asks all objects in the range (including their children) to copy across their component data to the specified destination document. The range must be in the destination doc.
void	ResetXOROutlineRenderer (BOOL FlushTheCache=TRUE)
void	RenderXOROutlinesOn (DocRect *ClipRect, Spread *pSpread, Matrix *Transform, Node *ClickedObject=NULL)
	Shared code used by the rotate, select, and scale tools to XOR the object(s) being dragged on/off screen. This function will do background rendering to XOR outlines onto screen (Successive calls will render more of the selection until it has all been rendered - it must therefore be called during mouse idle events to complete redraws).
void	RenderXOROutlinesOff (DocRect *ClipRect, Spread *pSpread, Matrix *Transform)
	Shared code used by the rotate, select, and scale tools to XOR the object(s) being dragged onto screen. This function is used to remove XORed object outline blobs from the screen (obviously they will only be truly removed if you call it with the screen in the correct state). After the outlines have been rendered, the XOROutline renderer state is reset, so it is ready to begin a fresh pass of rendering blobs back on to the screen.
void	RenderXOROutlinesToCatchUp (DocRect *ClipRect, Spread *pSpread, Matrix *Transform)
	Shared code used by the rotate, select, and scale tools to XOR the object(s) being dragged onto screen. This function is used when an area is redrawn during a drag (e.g. scrolling the window forces a redraw) to 'catch up' to the XOR outlines already present in other areas of the screen (i.e. it redraws everything that should already be on screen in unchanged areas into the invalidated area, so that XOR dragging can continue without leaving mess behind.
virtual DocRect	GetBoundingRect ()
	To determine the bounds of all objects in the range.
virtual DocRect	GetBoundingRectForEorDragging ()
	Same as for GetBoundingRect() but calls GetDragEorBoundingRect for all nodes.
virtual BOOL	AllowOp (ObjChangeParam *pParam, BOOL SetOpPermissionState=TRUE, BOOL DoPreTriggerEdit=TRUE)
	Calls AllowOp() on all nodes in the range. If SetOpPermissionState is TRUE, the op permission state of all nodes in the range, plus all parents of these nodes, will have their op permission state changed.
BOOL	GetCompoundObjectSet (ObjectSet *pCompoundObjectSet, BOOL ExcludeTextObjects=FALSE)
	This function traverses the range, and whenever it finds an object which is the child of a compound node it adds the compound node to the set.
BOOL	AddTextStoryCompoundsForDel (ObjectSet *pCompoundObjectSet)
	This function is really a BODGE. When we are deleting a range which contains text chars, the deletion code may/may-not hide unselected TextLines as well. If this occurs then we will not be able to globally localise/factor out attributes on these TextLines.
Range::CommonAttribResult	FindCommonAttribute (CCRuntimeClass *AttribClass, NodeAttribute **pAttribute, BOOL bRangeIsEffectsLevel=FALSE)
	To determine if all objects in the range share an attribute with the same value. You should only use this function if you need to find a common attribute value for a single attribute type. If you need to find common values for many types then FindCommonAttributes is much more efficient.
BOOL	FindCommonAttributes (CommonAttrSet *CommonAttributeSet, BOOL CompoundAccuracy=FALSE)
	Finds all attributes which are common to the objects in the selection. There is a CommonAttributeItem for every attribute type (common or not). The Status field in this structure specifies if the attribute is common.
Range::CommonAttribResult	FindCommonAttributeType (CCRuntimeClass *AttribType, CCRuntimeClass **pCommonType, BOOL ForceAttribType=FALSE, BOOL bRangeIsEffectsLevel=FALSE)
	To determine if all objects in the selection share attributes with the same type.
Range::CommonAttribResult	FindCommonNonOptimisingAttr (CCRuntimeClass *pAttribClass, NodeAttribute **ppAttr)
	Do a search on the range, for non-optimising attrs. Because they are not optimised, we don't need to search up and down the tree for these attributes - we just look at the children of each node in the range.
BOOL	FindBitmap (KernelBitmap **ppFoundBitmap=NULL, KernelBitmapRef **ppFoundBitmapRef=NULL, NodeBitmap **ppFoundNode=NULL, AttrFillGeometry **ppFoundFillAttribute=NULL)
	Find out if there is a valid bitmap in the selection and return useful information to the caller.
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 void	SetRenderable (BOOL bNewVis=FALSE)
virtual Range *	CloneNodes (UINT32 timeLimit, BOOL bCloneOnTop=FALSE, BOOL bLightweight=FALSE, Layer *pDestLayer=NULL)
virtual void	DeleteNodes ()
virtual void	ForceRedrawView (DocView *pDocView, BOOL bReleaseCache=FALSE, BOOL bUseBlobRects=FALSE, BOOL bReleaseParentsOnly=FALSE)
virtual BOOL	TransformNodes (TransformBase *Trans)
virtual void	SetDraggedNodes (BOOL bNewState=FALSE)
virtual void	CopyNodesContents (Range *pDestRange, BOOL bSetDragged=FALSE, BOOL bSetRenderable=FALSE)
virtual BOOL	SetPromoteToParent (BOOL bNewValue)
Public Attributes
Node *	NodeToRender
Protected Member Functions
CommonAttrSet *	GetCommonAttrCache ()
	This fn should be called to get a pointer to the range's common attribute cache. If the cache does not exist in the range then one is first created. Scope: private.
BOOL	FindNextXOROutlineNode (Node **OriginalNode, DocRect *pClipRect)
	Shared code used by the rotate, select, and scale tools to XOR the object(s) being dragged on/off screen. This function is used to calculate the next object to be drawn; it attempts to draw the most significant objects first, so that minute detail is only drawn if there is enough time spare. This significantly enhances interactiveness of dragging.
BOOL	CacheXOROutlineInfo (Spread *pSpread, Node *ClickedObject=NULL)
	This function is called before starting to XOR the objects onto screen to precalculate information pertaining to object significance (the order in which objects are drawn).
virtual Node *	SmartFindNext (Node *pContext, BOOL AndChildren=FALSE, BOOL FindFirst=FALSE) const
virtual BOOL	InRange (Node *pNode, BOOL AndChildren) const
	Private helper function for SmartFindNext. Tests whether the presented node is in the range according to the RangeControlFlags and two other locally presented flags.
Protected Attributes
CommonAttrSet *	pCommonAttribCache
RangeControl	RangeControlFlags
Node *	FirstNode
Node *	LastNode
INT32	NumObjectsDrawn
INT32	RenderingPass
XOROutlineInfoStr	XORInfo

---

Detailed Description

Definition at line 311 of file range.h.

---

Member Enumeration Documentation

enum Range::CommonAttribResult

Enumerator: ATTR_COMMON  ATTR_NONE  ATTR_MANY  Definition at line 387 of file range.h. { ATTR_COMMON, ATTR_NONE, ATTR_MANY };

---

Constructor & Destructor Documentation

Range::Range (   )

Creates an uninitialised range. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 2/3/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 314 of file range.cpp. { FirstNode = LastNode = NULL; pCommonAttribCache = NULL; // The common attribute cache only comes into // existance if the FindCommonAttribute functions }

Range::~Range (   )  [virtual]

Definition at line 324 of file range.cpp. { // Destroy the CommonAttribSet if one exists if (pCommonAttribCache) { delete pCommonAttribCache; } }

Range::Range (  Node *  First, Node *  Last, RangeControl  RangeControlFlgs )

The purpose of this function is to create a node range. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 28/6/93 Parameters: RangeControlFlags,:  Specifies the selected status of the nodes to be included [INPUTS] in the range. If RangeControlFlgs.Selected = TRUE All nodes with a selected status are included as members of the range. If RangeControlFlgs.Unselected = TRUE All nodes with an unselected status are included as members in the range. If both these flags are TRUE then all nodes from First to Last are included in the range. If RangeControlFlgs.CrossLayer = TRUE The range may cross several layers; when the end of a layer is reached, the search will continue at the start of the following layer. If RangeControlFlgs.IgnoreLockedLayers = TRUE locked layers are included in the search. Defaults to FALSE so locked layers ignored. If RangeControlFlgs.IgnoreNoneRenderable = TRUE non-renderable nodes are included in the search. Defaults to FALSE so non-redenderable nodes ignored. If RangeControlFlgs.IgnoreInvisibleLayers = TRUE Invisable layers are included in the search. Defaults to FALSE so invisible layers ignored. First: The node from which to commence searching for members of a range. Last: The final node to search (must be a right sibling of First, or NULL). NULL specifies that all nodes from First to the end of First's sibling list (or end of the tree, if CrossLayer is TRUE) are to be searched for members of the range. Parameters: -  [OUTPUTS] Returns: - Errors: - Definition at line 268 of file range.cpp. { // When the First node in a range is NULL the range is assumed to lie directly under // the surface of layers... /* if (First!=NULL) { ERROR3IF( RangeControlFlgs.Unselected && !First->FindParent()->IsLayer() && First != Last, "Attempt to create an illegal range!" ); } */ RangeControlFlags = RangeControlFlgs; FirstNode = First; LastNode = Last; pCommonAttribCache = NULL; // The common attribute cache only comes into // existance if the FindCommonAttribute functions // are called on the range. // Initialise the XOR rendering stuff NodeToRender = NULL; ResetXOROutlineRenderer(TRUE); }

Range::Range (  Range &  Rng  )

Range copy constructor. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 2/3/94 Parameters: Rng,:  The Range to copy [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 351 of file range.cpp. { // If the range is a sel range we must be sure that the range has been cached Rng.FreshenCache(); RangeControlFlags = Rng.RangeControlFlags; FirstNode = Rng.FirstNode; LastNode = Rng.LastNode; pCommonAttribCache = NULL; }

---

Member Function Documentation

BOOL Range::AddTextStoryCompoundsForDel (  ObjectSet *  pCompoundObjectSet  )

This function is really a BODGE. When we are deleting a range which contains text chars, the deletion code may/may-not hide unselected TextLines as well. If this occurs then we will not be able to globally localise/factor out attributes on these TextLines. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 6/6/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - So what this function does is to add all parent TextStory compounds of any selected TextChars to the set, so that we can factor out on these. Really any deletion of this sort should occur after the operation ends similar to group deletion in the no children case.But we have got to ship this product some time. Returns: Errors: - See also: - Definition at line 3371 of file range.cpp. { Node* pCurrent = FindFirst(); Node* pParent; while (pCurrent) { pParent = pCurrent->FindParent(); ERROR3IF(!pParent, "object in range has no parent"); if (pParent) { if (IS_A(pParent, TextLine)) { pParent = pParent->FindParent(); ERROR3IF(!pParent, "parent of object in range has no parent"); ERROR3IF(!(IS_A(pParent, TextStory)), "Parent of TextLine is not a TextStory"); if (IS_A(pParent, TextStory)) { // Add the story to the set if (!(pCompoundObjectSet->AddToSet((NodeRenderableInk*)pParent))) return FALSE; } } } pCurrent = pCurrent->FindNext(); } return TRUE; }

BOOL Range::AllowOp (  ObjChangeParam *  pParam, BOOL  SetOpPermissionState = TRUE, BOOL  DoPreTriggerEdit = TRUE )  [virtual]

Calls AllowOp() on all nodes in the range. If SetOpPermissionState is TRUE, the op permission state of all nodes in the range, plus all parents of these nodes, will have their op permission state changed. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> 19/01/2000 Date: 6/02/95 Parameters: pParam  = describes the way an op wants to change the node [INPUTS] SetOpPermissionState = if TRUE the Op permission state of this node (and its parents) will be set according to the outcome of the call DoPreTriggerEdit = if TRUE then calls NameGallery::PreTriggerEdit. Must* be TRUE if the calling Op may make any nodes change their bounds, eg move, line width, cut. Use TRUE if unsure. -  [OUTPUTS] Returns: TRUE if one or more of the nodes in the range will allow the op to happen, FALSE otherwise See also: Node::AllowOp(),Node::GetOpPermission(),Node::SetOpPermission() Definition at line 2349 of file range.cpp. { Node* pNode = FindFirst(); BOOL result = FALSE,allowed; // we call AllowOp on all Nodes in the range, but never ask for a PreTriggerEdit on // each one, as if it is necessary then we deal with them en masse next. while (pNode != NULL) { Node* pNextNode = FindNext(pNode); allowed = pNode->AllowOp(pParam, SetOpPermissionState, FALSE); result = result || allowed; pNode = pNextNode; } // if we're ok so far and were asked to do a PreTriggerEdit, then // determine whether the Op may change the bounds of some nodes. // If it may, then call NameGallery::PreTriggerEdit. if (result && DoPreTriggerEdit) { // if the Op is non-NULL then query its MayChangeNodeBounds() method. UndoableOperation* pChangeOp = pParam->GetOpPointer(); if (pChangeOp != NULL && pChangeOp->MayChangeNodeBounds() && NameGallery::Instance()) { result = NameGallery::Instance()->PreTriggerEdit(pChangeOp, pParam, this); } } return result; }

void Range::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 Range::AttrsHaveChanged() Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 12/12/94 See also: SelRange::AttrsHaveChanged Reimplemented in SelRange. Definition at line 3412 of file range.cpp. { // if we are currently caching current attrs delete them if (pCommonAttribCache) { delete pCommonAttribCache; pCommonAttribCache = NULL; } }

BOOL Range::CacheXOROutlineInfo (  Spread *  pSpread, Node *  ClickedObject = NULL )  [protected]

This function is called before starting to XOR the objects onto screen to precalculate information pertaining to object significance (the order in which objects are drawn). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 23/2/94 Parameters: Spread  - The spread in which the drag is occurring [INPUTS] ClickedNode - The renderable node which the user clicked on to start the drag. (This object will always be drawn first. You may pass in NULL, but this will reduce the interactiveness of the dragging system) Notes: See the selector and rotate tools for example code using this system. Scope: private See also: SelRange::RenderXOROutlinesOn; SelRange::RenderXOROutlinesOff; SelRange::RenderXOROutlinesToCatchUp Definition at line 1678 of file range.cpp. { #if !defined(EXCLUDE_FROM_RALPH) if (XORInfo.Cached) // Have already cached the info return TRUE; BOOL bPromote = RangeControlFlags.PromoteToParent; RangeControlFlags.PromoteToParent = TRUE; ERROR2IF(pSpread == NULL,FALSE, "NULL Spread pointer passed to SelRange::CacheXOROutlineInfo"); ERROR2IF(DocView::GetSelected() == NULL,FALSE, "DocView::GetSelected is NULL in SelRange::CacheXOROutlineInfo"); DocView *pDocView = DocView::GetSelected(); if (pDocView == NULL) { RangeControlFlags.PromoteToParent = bPromote; return FALSE; } XORInfo.SigRegion = pDocView->GetDocViewRect(pSpread); // Take screenrect or source bounding rect, whichever is smaller // (if the source rect passed in was NULL, just use screen coords) DocRect SourceRegion = GetBoundingRectForEorDragging(); if (Count() > 0 && XORInfo.SigRegion.Width() + XORInfo.SigRegion.Height() > SourceRegion.Width() + SourceRegion.Height()) { XORInfo.SigRegion = SourceRegion; XORInfo.SigRegionIsScreen = FALSE; } else { // Convert SigRgn from Document to Spread coords pSpread->DocCoordToSpreadCoord(&XORInfo.SigRegion); XORInfo.SigRegionIsScreen = TRUE; } XORInfo.PrimeObject = NULL; if (ClickedObject != NULL) { // And remember which object must always be drawn first (the prime object) // --but only if it's a renderable object that is part of the selection! BOOL Selected = ClickedObject->IsSelected(); if (ClickedObject->ShouldITransformWithChildren()) { Selected = TRUE; } if (!Selected) { // The object isn't selected, but perhaps it is in a selected group. // Search up through all parent nodes until we have determined if it // really is selected. Node *TheNode = (Node *) ClickedObject; do { Selected = (TheNode->IsSelected()); TheNode = TheNode->FindParent(); } while (!Selected && TheNode != NULL); } if (Selected && ClickedObject->IsKindOf(CC_RUNTIME_CLASS(NodeRenderableInk))) XORInfo.PrimeObject = ClickedObject; } else { } XORInfo.Cached = TRUE; RangeControlFlags.PromoteToParent = bPromote; return TRUE; #else return FALSE; #endif }

Range * Range::CloneNodes (  UINT32  timeLimit, BOOL  bCloneOnTop = FALSE, BOOL  bLightweight = FALSE, Layer *  pDestLayer = NULL )  [virtual]

Definition at line 3556 of file range.cpp. { Node* pNode; ListRange* pCloneRange = new ListRange(); MonotonicTime timeClone; pNode = FindFirst(); while (pNode && !timeClone.Elapsed(timeLimit)) { // Make a copy of the current node Node* pCopy = NULL; BOOL bOK = FALSE; // bOK = pNode->CloneNode(&pCopy, bLightweight); bOK = pNode->NodeCopy(&pCopy); if (!bOK) goto CloneError; // make sure that it is bounded ERROR2IF(!pCopy->IsBounded(), FALSE, "Object being pasted is not a NodeRenderableBounded"); // NodeRenderableBounded* BoundCopy = (NodeRenderableBounded*)pCopy; // Make sure the copy is not selected pCopy->SetSelected(FALSE); if (pDestLayer==NULL) { if (!bCloneOnTop) { // Insert the copied node right alongside the original pCopy->AttachNode(pNode, NEXT, FALSE, FALSE); } else { Node* pTail = pNode->FindParent(CC_RUNTIME_CLASS(Layer))->FindLastChild(TRUE); pCopy->AttachNode(pTail, NEXT, FALSE, FALSE); } } else { // Copy the node into a new target spread... Node* pTail = pDestLayer->FindLastChild(TRUE); if (pTail) pCopy->AttachNode(pTail, NEXT, FALSE, FALSE); else pCopy->AttachNode(pDestLayer, FIRSTCHILD, FALSE, FALSE); } // Add the copied node to the output ListRange pCloneRange->AddNode(pCopy); pNode = FindNext(pNode); } // If we ran through all the nodes we needed to then pNode will be NULL and we can exit normally if (pNode==NULL) return pCloneRange; // Else we aborted early and we must fall through to the tidy up routine and return NULL CloneError: pNode = pCloneRange->FindLast(); while (pNode) { pNode->CascadeDelete(); delete pNode; pNode = pCloneRange->FindPrev(pNode); } delete pCloneRange; return NULL; }

BOOL Range::ConsistsOf (  CCRuntimeClass *  pccrtSearch, BOOL  fIncludeDerivedClasses = TRUE )

Determines whether the range consists entirely of the given class of object - or of derived classes of the given sort of object. BOOL Range::ConsistsOf(CCRuntimeClass* pccrtSearch, BOOL fIncludeDerivedClasses=TRUE) Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 24/3/97 Parameters: pccrtSearch  The type of object to search for [INPUTS] fIncludeDerivedClasses If FALSE, the region must consist only of objects of class pccrtSearch. If TRUE, the region must consist only of objects of pccrtSearch and derived classes. This is used by the WebAddressDlg, which needs to know whether the selection consists entirely of text. See also: Range::FindFirst, Range::FindNext, SelRange::FindFirst, Range::FindNext Definition at line 3448 of file range.cpp. { //Find the first node in the range, not including children Node* pThisNode=FindFirst(FALSE); //Now scan until we get to the end of the range while (pThisNode!=NULL) { BOOL ok=TRUE; //Is the object allowed to be a derived class of pccrtSearch? if (fIncludeDerivedClasses) //Yes. So test to see whether the node is a derived class of pccrtSearch ok=pThisNode->IsKindOf(pccrtSearch); else //No. So test whether the node is exactly the same class as pccrtSearch ok=(pThisNode->GetRuntimeClass()==pccrtSearch); //If the node wasn't of the appropriate class, return FALSE now. if (!ok) return FALSE; //Get the next object to test pThisNode=FindNext(pThisNode, FALSE); } //We've reached the end of the range and all the nodes were of the class we wanted. //So return TRUE return TRUE; }

BOOL Range::Contains (  Node *  pLookFor, BOOL  bAndChildren = FALSE )

To determin whether a particular node is actually in the range list. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 3/5/95 Parameters: pLookFor  = a pointer to a node to look for. [INPUTS] bAndChildren - Test for node being in subtree of member of range -  [OUTPUTS] Returns: TRUE if the range contains this particular node FALSE if the node is not held within this range Errors: - Definition at line 731 of file range.cpp. { Node* pNode=FindFirst(); while (pNode) { if (pNode==pLookFor) return TRUE; if (bAndChildren && pNode->IsNodeInSubtree(pLookFor)) return TRUE; pNode=FindNext(pNode); } return FALSE; }

BOOL Range::ContainsSelectInside (   )

Definition at line 765 of file range.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // Preconditions ERROR2IF(this==NULL,FALSE,"ContainsSelectInside called on NULL pointer"); // Implementation Node* pNodeInRange = FindFirst(); Node* pParent; while (pNodeInRange) // While there's a node in the range { pParent = pNodeInRange->FindParent(); // Look at it's parent node // DMc - added promotehittestonchildrentome test to eliminate the 'inside' setting // for nodes should as shadows, contours, bevels etc while (pParent) { if (pParent->IsAnObject() && pParent->IsParentOfSelected() && pParent->PromoteHitTestOnChildrenToMe()) // If that's marked parent of sel return TRUE; // Then this node is "inside" so return TRUE pParent = pParent->FindParent(); } pNodeInRange = FindNext(pNodeInRange); // Else, keep scanning members of range } #endif return FALSE; // If no more in range, none were "inside" }

BOOL Range::CopyComponentDataToDoc (  BaseDocument *  pSrcDoc, BaseDocument *  pDestDoc, BOOL  AndChildren = FALSE )

Asks all objects in the range (including their children) to copy across their component data to the specified destination document. The range must be in the destination doc. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 9/9/94 Parameters: pSrcDoc,:  the document from where all nodes in the range were copied [INPUTS] pDestDoc - where to copy all the nodes to. Returns: FALSE if we are unable to copy the data accross. In this situation AbortComponentCopy is called on the CurrentDocument. Errors: - See also: - Definition at line 1443 of file range.cpp. { // Scan all nodes in the range Node* Scan = FindFirst(AndChildren); while (Scan != NULL) { Node* Root = Scan; Node* Current = Root->FindFirstDepthFirst(); // This depth first search was written BEFORE the AndChildren flag was passed in. // It could probably be removed now... while (Current != NULL) { // Ask the current node if it would copy it's data to the relevant DocComponents if (Current->IsKindOf(CC_RUNTIME_CLASS(NodeRenderable))) { if (!((NodeRenderable*)Current)->CopyComponentData(pSrcDoc, pDestDoc)) { // No luck pDestDoc->AbortComponentCopy(); // Cancel all data which has been copied return FALSE; } } Current = Current->FindNextDepthFirst(Root); } Scan = FindNext(Scan, AndChildren); } return TRUE; // Success }

void Range::CopyNodesContents (  Range *  pDestRange, BOOL  bSetDragged = FALSE, BOOL  bSetRenderable = FALSE )  [virtual]

Definition at line 3790 of file range.cpp. { Node* pSrcNode; Node* pDestNode; NodeRenderable* pSrcRendNode; NodeRenderable* pDestRendNode; // ENSURE(GetCount()==pDestRange->GetCount(), "Ranges differ too much"); pSrcNode = FindFirst(FALSE); pDestNode = pDestRange->FindFirst(FALSE); while (pSrcNode && pDestNode) { ENSURE(pSrcNode->GetRuntimeClass() == pDestNode->GetRuntimeClass(), "Ranges differ unexpectedly"); if (pSrcNode->IsBounded() && pSrcNode->GetRuntimeClass() == pDestNode->GetRuntimeClass()) { pSrcRendNode = (NodeRenderable*)pSrcNode; pDestRendNode = (NodeRenderable*)pDestNode; // Do the children because PolyCopyNodeContents can't sensibly be recursive Node* pSrcSubNode = pSrcRendNode->FindFirstDepthFirst(); while (pSrcSubNode && (pSrcSubNode->IsNodeHidden() || pSrcSubNode->IsDragged())) // URGH pSrcSubNode = pSrcSubNode->FindNextDepthFirst(pSrcRendNode); // URGH Node* pDestSubNode = pDestRendNode->FindFirstDepthFirst(); while (pDestSubNode && (pDestSubNode->IsNodeHidden() || !pDestSubNode->IsDragged())) // URGH pDestSubNode = pDestSubNode->FindNextDepthFirst(pDestRendNode); // URGH while (pSrcSubNode && pDestSubNode) { if (pSrcSubNode->IsNodeRenderableClass() && pDestSubNode->IsNodeRenderableClass()) { ENSURE(pSrcSubNode->GetRuntimeClass() == pDestSubNode->GetRuntimeClass(), "Ranges differ unexpectedly"); ((NodeRenderable*)pSrcSubNode)->PolyCopyNodeContents((NodeRenderable*)pDestSubNode); pDestSubNode->SetSelected(FALSE); pDestSubNode->SetParentOfSelected(FALSE); } pSrcSubNode = pSrcSubNode->FindNextDepthFirst(pSrcRendNode); while (pSrcSubNode && (pSrcSubNode->IsNodeHidden() || pDestSubNode->IsDragged())) // URGH pSrcSubNode = pSrcSubNode->FindNextDepthFirst(pSrcRendNode); // URGH pDestSubNode = pDestSubNode->FindNextDepthFirst(pDestRendNode); while (pDestSubNode && (pDestSubNode->IsNodeHidden() || !pDestSubNode->IsDragged())) // URGH pDestSubNode = pDestSubNode->FindNextDepthFirst(pDestRendNode); // URGH } // if (bSetDragged && pDestRendNode->IsBounded()) // ((NodeRenderableBounded*)pDestRendNode)->SetDraggedState(TRUE, TRUE); if (bSetDragged) pDestRendNode->SetDraggedState(TRUE, TRUE); if (bSetRenderable) pDestRendNode->SetRender(TRUE, TRUE); } pSrcNode = FindNext(pSrcNode, FALSE); pDestNode = pDestRange->FindNext(pDestNode, FALSE); } }

UINT32 Range::Count (   )

Reimplemented in SelRange. Definition at line 699 of file range.cpp. { UINT32 count = 0; Node* pNode; pNode = FindFirst(); while (pNode) { count++; pNode = FindNext(pNode); } return(count); }

void Range::DeleteNodes (   )  [virtual]

Definition at line 3648 of file range.cpp. { Node* pNode; Node* pNext; pNode = FindFirst(); while (pNode) { pNext = FindNext(pNode); pNode->CascadeDelete(); delete pNode; pNode = pNext; } }

BOOL Range::FindBitmap (  KernelBitmap **  ppFoundBitmap = NULL, KernelBitmapRef **  ppFoundBitmapRef = NULL, NodeBitmap **  ppFoundNode = NULL, AttrFillGeometry **  ppFoundFillAttribute = NULL )

Find out if there is a valid bitmap in the selection and return useful information to the caller. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 21/1/97 Changed: Phil, 20/01/2004: Moved from PlugInUndoOp static to be member function of range !!!!!!!!! Parameters: None  [INPUTS] if  supplied, it will return a pointer to the bitmap that is in the selection [OUTPUTS] if supplied, it will return a pointer to the bitmap ref that is in the selection if supplied, it will return a pointer to the node bitmap that is in the selection if supplied, it will return a pointer to the fill geometry that is in the selection Returns: TRUE if succeeded in finding a bitmap, FALSE if not See also: - Definition at line 7229 of file range.cpp. { KernelBitmap * pBitmap = NULL; KernelBitmapRef* pBitmapRef = NULL; // Assume nothing found if (ppFoundBitmap) *ppFoundBitmap = NULL; if (ppFoundBitmapRef) *ppFoundBitmapRef = NULL; if (ppFoundNode) *ppFoundNode = NULL; if (ppFoundFillAttribute) *ppFoundFillAttribute = NULL; Node* pCurrentNode = FindFirst(); if (pCurrentNode != NULL) // No nodes selected so End { // Do all bitmaps. OK this should pick up the fill as well. Never mind while (pCurrentNode != NULL) { if (pCurrentNode->IsABitmap()) { NodeBitmap* pNodeBmp = (NodeBitmap*)pCurrentNode; pBitmap = pNodeBmp->GetBitmap(); pBitmapRef = pNodeBmp->GetBitmapRef(); // If the caller wanted it, return the found bitmap to them if (ppFoundBitmap) *ppFoundBitmap = pBitmap; // ditto found bitmap ref if (ppFoundBitmapRef) *ppFoundBitmapRef = pBitmapRef; // ditto found node if (ppFoundNode) *ppFoundNode = pNodeBmp; // ditto found fill attribute if (ppFoundFillAttribute) *ppFoundFillAttribute = NULL; return TRUE; } pCurrentNode = FindNext(pCurrentNode); } } if (ppFoundFillAttribute) { // Find the first Fill Attribute in the selection AttrFillGeometry* pAttrNode = AttrFillGeometry::FindFirstSelectedAttr(); while (pAttrNode != NULL) { if (pAttrNode->IsKindOf(CC_RUNTIME_CLASS(AttrBitmapColourFill))) { pBitmap = pAttrNode->GetBitmap(); pBitmapRef = pAttrNode->GetBitmapRef(); // If the caller wanted it, return the found bitmap to them if (ppFoundBitmap) *ppFoundBitmap = pBitmap; // ditto found bitmap ref if (ppFoundBitmapRef) *ppFoundBitmapRef = pBitmapRef; // ditto found node if (ppFoundNode) *ppFoundNode = NULL; // ditto found fill attribute if (ppFoundFillAttribute) *ppFoundFillAttribute = pAttrNode; return TRUE; } // Check the next fill pAttrNode = AttrFillGeometry::FindNextSelectedAttr(); } } return FALSE; }

Range::CommonAttribResult Range::FindCommonAttribute (  CCRuntimeClass *  AttribType, NodeAttribute **  pAttribute, BOOL  bRangeIsEffectsLevel = FALSE )

To determine if all objects in the range share an attribute with the same value. You should only use this function if you need to find a common attribute value for a single attribute type. If you need to find common values for many types then FindCommonAttributes is much more efficient. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 29/6/94 Parameters: AttribType,:  The Type of attribute to find - defined in the virtual [INPUTS] GetAttributeType method of NodeAttribute pAttribute,:  Depends on the return value, see below [OUTPUTS] Returns: ATTR_COMMON:There is a common attribute pAttribute will point to an instance of it ATTR_NONE: There is no selection, or none of the selected objects require the attribute. If there is a document pAttribute will point to the current attribute for the selected tool, this will be the value which is usually displayed in this situation. else pAttribute will be NULL No value will usually be displayed in this situation ATTR_MANY: There is no common attribute, pAttribute will be NULL Returns: Errors: - Scope: private See also: Range::FindCommonAttributes Definition at line 2787 of file range.cpp. { #if !defined(EXCLUDE_FROM_RALPH) CommonAttribResult Result; *pAttribute = NULL; // Before we go away and do any hard work, let's see if the value that the user // is after is already cached. CommonAttrSet* pCommonAttrCache = GetCommonAttrCache(); if (pCommonAttrCache) { // are the AttrTypes common details cached CommonAttributeItem* pAttrItem = pCommonAttrCache->FindAttrItem(AttribType); if (pAttrItem) { // Aren't we lucky *pAttribute = pAttrItem->pAttr; return (pAttrItem->Status); } } // else the cache could not be created. We shall just have to work without one // Scan each selected node until we get a result NodeRenderableInk* n = NULL; NodeRenderableInk* pn = (NodeRenderableInk*)FindFirst(); NodeAttribute* AppliedAttr; // The attribute applied and used by n.