#include <node.h>
Inheritance diagram for Node:
Public Types | |
| typedef BOOL(Node::* | TypeFunc )() const |
Public Member Functions | |
| Node () | |
| This constructor creates a node linked to no other with all status flags FALSE. Also updates the Node counter of the current Document. | |
| Node (Node *ContextNode, AttachNodeDirection Direction, BOOL Locked=FALSE, BOOL Mangled=FALSE, BOOL Marked=FALSE, BOOL Selected=FALSE, BOOL Renderable=FALSE) | |
| This constructor initialises a node and links it to ContextNode in the direction specified by Direction. All necessary tree links are updated. For example if a node is inserted as a FirstChild of ContextNode, and Context node already has children, then the current first child of context node will become the next sibling of the new first child node. | |
| virtual | ~Node () |
| Destroys a Node object. The base class updates the node counter of the current document, and ensures that the SelRange doesn't have a cached pointer to 'this' as its 'Last Selected Node'. | |
| virtual void | Render (RenderRegion *pRender) |
| For rendering a node. | |
| void | RenderTreeAtomic (RenderRegion *pRender) |
| Renders the tree rooted at this node into the given RenderRegion. | |
| virtual BOOL | NeedsToRender (RenderRegion *pRender) |
| Decide whether this node needs to be rendered, given the information provided by the parameters. This is a virtual function which defaults to returning FALSE - i.e. the node never needs to be rendered. This function should be overridden for any renderable nodes, so that they use the info provided to determine whether or not they need to be rendered. | |
| virtual void | PreExportRender (RenderRegion *pRender) |
| Perform any rendering required when exporting to a file, and this node is being 'passed by' during the tree searching. For example, a group node being exported to EPS would output a "start group" token, and then its ExportRender function would output a "end group" token. By default, it does nothing. Nodes wishing to do special export processing should override this function (and ExportRender). | |
| virtual BOOL | ExportRender (RenderRegion *pRender) |
| Perform special export rendering of an object, if it is different to the way the object would be rendered normally (e.g. graduated fill attributes, and so on). By default, the base class function returns FALSE, so by default all objects will be exported by calling the Render() function unless they override this function. | |
| virtual BOOL | NeedsToExport (RenderRegion *pRender, BOOL VisibleLayersOnly=FALSE, BOOL CheckSelected=FALSE) |
| To indicate whether a given node needs to be rendered when exporting the document tree to a foreign file format. The base class always returns FALSE; if derived nodes wish to be exported they must override it and return TRUE. | |
| virtual String | Describe (BOOL Plural, BOOL Verbose=TRUE) |
| To return a description of the Node object in either the singular or the plural. This method is called by the DescribeRange method. | |
| virtual ChangeCode | OnChildChange (ObjChangeParam *pParam) |
| This function should be overridden in derived object classes. Composite objects can use this function to respond to one of their children undergoing a change. They should return CC_FAIL whenever they are unable to cope with the change. | |
| virtual OpPermissionState | GetOpPermission () |
| Use this to access the node's permission flags to find out if the current op is doable to this node. | |
| virtual void | SetOpPermission (OpPermissionState NewState, BOOL AndParents=FALSE) |
| Use this to set the node's permission flags. | |
| virtual BOOL | AllowOp (ObjChangeParam *pParam, BOOL SetOpPermissionState=TRUE, BOOL DoPreTriggerEdit=TRUE) |
| This is the way to ask a node if you can do an op to it. | |
| virtual BOOL | AllowOp_AccountForCompound (ObjChangeParam *pParam, BOOL SetOpPermissionState=TRUE, BOOL DoPreTriggerEdit=TRUE) |
| if this is a compound node, ensures all child nodes have their AllowOp() called. | |
| void | CascadeDelete (void) |
| This method removes the node from the tree and deletes all its child nodes (including hidden nodes). | |
| virtual SubtreeRenderState | RenderSubtree (RenderRegion *pRender, Node **ppNextNode=NULL, BOOL bClip=TRUE) |
| Enables Nodes to be able to Do Pre Print time alterations or even take over the control of the current Printing of their children. | |
| virtual void | RenderAfterSubtree (RenderRegion *pRender) |
| virtual BOOL | WritePreChildrenWeb (BaseCamelotFilter *pFilter) |
| Writes out a record that represents the node. | |
| virtual BOOL | WritePreChildrenNative (BaseCamelotFilter *pFilter) |
| virtual BOOL | WritePostChildrenWeb (BaseCamelotFilter *pFilter) |
| Gives the node a change to write data to the filter after its children have been automatically written out. | |
| virtual BOOL | WritePostChildrenNative (BaseCamelotFilter *pFilter) |
| virtual BOOL | CanWriteChildrenWeb (BaseCamelotFilter *pFilter) |
| If the node does not mind the filter automatically writing out its child nodes, then return TRUE. | |
| virtual BOOL | CanWriteChildrenNative (BaseCamelotFilter *pFilter) |
| virtual BOOL | WriteBeginChildRecordsWeb (BaseCamelotFilter *pFilter) |
| Begin to write out you child records, in the web format. | |
| virtual BOOL | WriteBeginChildRecordsNative (BaseCamelotFilter *pFilter) |
| Begin to write out you child records, in the native format. | |
| virtual BOOL | WriteEndChildRecordsWeb (BaseCamelotFilter *pFilter) |
| Finished writing out you child records, in the web format. | |
| virtual BOOL | WriteEndChildRecordsNative (BaseCamelotFilter *pFilter) |
| Finished writing out you child records, in the native format. | |
| virtual BOOL | ReadPostChildrenWeb (BaseCamelotFilter *pFilter) |
| This function is called during the importing of the file. | |
| virtual BOOL | ReadPostChildrenNative (BaseCamelotFilter *pFilter) |
| virtual BOOL | AreYouSafeToRender () |
| This function is used by the progressive rendering system & the new file format to determine whether the node is renderable or not. | |
| BOOL | CopyNode (Node *DestinationNode, AttachNodeDirection Direction) |
| This method creates a 'deep' copy of the node and then attaches it to the destination node. The Direction input specifies how the node is to be attached to the Destination node. The following before and after diagram illustrates this method. | |
| virtual BOOL | NodeCopy (Node **ppNodeCopy) |
| This method outputs a 'deep' copy of the node. It is the same as CopyNode except that the copy is not linked into the tree. | |
| virtual BOOL | CloneNode (Node **ppNoeCopy, BOOL bLightweight) |
| This method outputs a 'deep' copy of the node. It is the same as CopyNode except that the copy is not linked into the tree. Override if yor class can interpret the lightweight flag. | |
| BOOL | CopyComplexRange (Range &RangeToCopy) |
| Copy the series of nodes described by RangeToCopy and attach them to onto the last child position of this object. | |
| BOOL | CopyChildrenTo (Node *DestinationNode, CopyControlFlags CopyFlags=ccALL) |
| This function copies the node's children to DestinationNode which should initially have no children. | |
| void | MoveNode (Node *DestinationNode, AttachNodeDirection Direction) |
| This method moves a node from its existing position in the tree to a new node position specified by Destination. The Direction input specifies how the node is to be attached to the Destination node. The following before and after diagram illustrates this method. | |
| void | AttachNode (Node *ContextNode, AttachNodeDirection Direction, BOOL fCheckTransparent=TRUE, BOOL InvalidateChildren=TRUE) |
| This method attaches the node to a context node in the direction specified by Direction. All necessary tree links are updated. | |
| void | InsertChainSimple (Node *ContextNode, AttachNodeDirection Direction) |
| Inserts a chain of nodes at contextnode. A chain is an unconnected set of siblings. This function should be called from the first node (left most) in the chain. It doesn't do anything fancy - in fact, little more than changing a few pointers here and there. | |
| virtual BOOL | PostImport () |
| This function is called after a document is imported. Nodes should override this function to do any post-import processing. | |
| virtual BOOL | PostDuplicate (UndoableOperation *pOp) |
| This function is called after this node has been created via a copy/duplicate type operation. Nodes should override this function to do any post-processing. | |
| UINT32 | GetTag () const |
| For finding a nodes TAG, which is a unique identifier for each node stored within a document. | |
| virtual UINT32 | GetNodeSize () const |
| For finding the size of a node, in concrete classes derived from Node. | |
| virtual CopyType | GetCopyType () |
| This function returns a type describing how this object is to be copied. The fuction is called from the low level copy operation CopyObjects. There are two options at present, these being SIMPLECOPY and COMPLEXCOPY. SIMPLECOPY indicates that the node can be copied by a call to its virtual function SimpleCopy() followed by a deep copy of all its children. COMPLEXCOPY however indicates that the node needs to do its own thing when copying and must be called via the ComplexCopy() virtual function. This virtual will likely return a tree of copied objects rather than just a copy of itself. | |
| UINT32 | GetSubtreeSize () |
| For finding the size of this subtree. | |
| BOOL | IsUnder (Node *pTestNode, BOOL bFirstCall=TRUE) const |
| For finding out whether this node is under another node. Where "under" is defined as being before it in rendering order. To find the answer quickly without scanning the entire tree, we will find the common root node of both this and pNode and find out whether the child links from that node lead down to this node first or pTestNode first. (Because if my parent is under the test node then so am I) Do this recursively so that state is held on the stack, not in the tree Clever, huh? There is some strictly unneccessary work done in finding the common ancestor in this implementation but it's the best compromise that is both reasonably fast and completely stateless. | |
| BOOL | IsLocked () const |
| For finding the status of the nodes locked flag. | |
| BOOL | IsMangled () const |
| For finding the status of the nodes mangled flag. | |
| BOOL | IsMarked () const |
| For finding the status of the nodes marked flag. | |
| BOOL | IsRenderable () const |
| For finding the status of the nodes renderable flag. | |
| BOOL | IsParentOfSelected () const |
| For finding the status of the nodes SelectedChildren flag Note: When this function returns TRUE it is not guaranteed that there will be selected children - there may be none! | |
| BOOL | IsSelected () const |
| For finding the status of the nodes selected flag. | |
| BOOL | IsChildOfSelected () |
| For finding out whether this node has a selected parent. Note: If a group (node) of a number of objects is selected then only the group node itself has the selected flag set. Any children of this group, i.e. objects in the group would also be deemed selected but would not have the selected bit set. This routine is based on the routine View::IsPrintableNodeSelected and just searches up until it finds a layer. If by then it has found a selected flag then its parent must be selected and hence it is. | |
| virtual BOOL | ShouldBeRendered () const |
| For determining quickly if the node is an object For finding the status of the node's Compound flag For finding the status of the node's Compound flag Allows you to see if this node is a NodeAttribute or is Hiding a NodeAttribute without having to use the expensive runtime checkingFor finding if a node is a paper node. For finding if a node is a layer node. For finding if a node is a spread node.For finding if a node is a chapter node.Determine if a node is *derived* from the NodeRenderable class. NB. This has nothing to do with the node's renderable flag! Work out if the node should be rendered - basically all nodes except NodeRenderable nodes should be rendered. However, some NodeRenderable derived classes should not actually be rendered - for example NodeMouldGroup hides the original un-moulded objects, which should definitely *not* be rendered. This is mainly used during printing where due to complications to do with banding and transparency, we cannot use NeedsToRender() to filter out such nodes, so we use this function instead. NB. This has nothing to do with the node's renderable flag! | |
| virtual BOOL | NeedsTransparency () const |
| Can be overriden in derived classes to return TRUE, indicating that the user may be prompted concerning transparency mode when such a node is inserted in the tree. | |
| virtual INT32 | EstimateNodeComplexity (OpParam *details) |
| virtual BOOL | IsAnObject () const |
| virtual BOOL | IsAnAttribute () const |
| virtual BOOL | IsKindOfTextAttribute () const |
| virtual BOOL | IsPaper () const |
| virtual BOOL | IsLayer () const |
| virtual BOOL | IsSpread () const |
| virtual BOOL | IsChapter () const |
| virtual BOOL | IsNodeDocument () const |
| virtual BOOL | IsNodeRenderableClass () const |
| virtual BOOL | IsNodeHidden () const |
| virtual BOOL | IsNodePath () const |
| virtual BOOL | IsARegularShape () const |
| virtual BOOL | IsOrHidesAnAttribute () const |
| virtual BOOL | IsABitmap () const |
| virtual BOOL | IsAFillAttr () const |
| virtual BOOL | IsABitmapFill () const |
| virtual BOOL | IsABitmapColourFill () const |
| virtual BOOL | IsABitmapTranspFill () const |
| virtual BOOL | IsAFeatherAttr () const |
| virtual BOOL | IsAClipViewAttr () const |
| virtual BOOL | IsBounded () const |
| virtual BOOL | IsDragged () const |
| virtual BOOL | IsController () |
| virtual BOOL | IsABlend () |
| virtual BOOL | IsCompound () const |
| virtual BOOL | IsCompoundClass () const |
| virtual BOOL | IsAVisibleTextNode () const |
| virtual BOOL | IsAnAbstractTextChar () const |
| virtual BOOL | IsATextChar () const |
| virtual BOOL | IsABaseTextClass () const |
| virtual BOOL | IsATypeface () const |
| virtual BOOL | IsAnObjectName () const |
| virtual BOOL | IsUserAttribute () const |
| virtual BOOL | IsSetCandidate () const |
| virtual BOOL | IsCacheCompound () const |
| virtual BOOL | IsABevel () const |
| virtual BOOL | IsABevelController () const |
| virtual BOOL | IsAContour () const |
| virtual BOOL | IsAContourController () const |
| virtual BOOL | IsAShadow () const |
| virtual BOOL | IsAShadowController () const |
| virtual BOOL | IsABrush () const |
| virtual BOOL | IsEffect () const |
| virtual BOOL | IsBitmapEffect () const |
| virtual BOOL | IsRenderedAsInk () const |
| BOOL | IsBrushed () const |
| Quicker way to test if this node is a bitmap. Virtual function for determining if the node is a Fill attribute Virtual function for determining if the node is a Fill attribute Virtual function for determining if the node is a Fill attribute Virtual function for determining if the node is a Fill attribute Quicker way to test if this node is an object-name attribute. Quicker way to test if this node is an AttrUser. Quicker way to test if this node is worth considering during Name gallery scans. Virtual function to determine whether this node is a NodeMould.Virtual function for determing whether this node is a brush attribute as above. | |
| virtual NodePath * | IsAnEditablePath () |
| Determine if a node is *derived* from the NodeHidden class.Determine if a node is a NodeDocument object.Determine if a node is a NodePath object.Determine if a node is a QuickShape object.Determine if a node is a visible text node.Determine if a node is an AbstractTextChar node. Determine if a node is a (or is derived from) TextChar. Determine if a node is a (or is derived from) BaseTextClass. Determine if a node is a (or is derived from) AttrTxtFontTypeface. Finds the node to edit (if it exists). This node could actually be 'this' node one of its children which the node wants to be editable. | |
| virtual BOOL | IsANodeClipViewController () const |
| virtual BOOL | IsANodeClipView () const |
| virtual BOOL | IsAGroup () const |
| virtual BOOL | IsAnInsertionNode () const |
| virtual BOOL | IsANodeMould () const |
| virtual BOOL | SupportsClipboardFormat (InternalClipboardFormat *Format) const |
| Determine if a node supports a given internal data type. This is used by the clipboard when exporting to other applications in order to determine if certain data types can be supplied. | |
| virtual BOOL | DiscardsAttributeChildren () const |
| This virtual was added because we need to know about nodes which can discard their child attributes, an example is the CaretNode. If an attribute gets applied to such a node then no undo info can be generated. | |
| virtual Node * | HasEditableChild (CCRuntimeClass *ChildClass, Node *pPrevNode) |
| This function allows compound objects to provide editable children. It also allows tools to ask an object what other nodes form part of its editable surface if the node itself cannot be editable. This allows complex objects such as moulds and text objects, who have a single parent above many objects (some of which are editable), to provide a way for tools to get at them. A tool scanning the selection may be looking to edit certain objects. If a selected object it comes accross is not of the correct type, the tool can also ask it whether it contains any editable objects of type(ChildClass). If the node overrides this virtual function it can provide a strangly shapes editable surface. Note, do not confuse this with select inside, where objects have been explicitly selected by the user. In that case the parent would never be asked for editable children as it does not form part of the selection under a select inside action. | |
| virtual KernelBitmap * | EnumerateBitmaps (UINT32 Count) |
| Find out what bitmaps, if any, are used by this node. | |
| virtual double | GetEffectiveBitmapMinDPI (KernelBitmap *pBitmap) |
| virtual BOOL | ReplaceBitmap (KernelBitmap *pOrigBitmap, KernelBitmap *pNewBitmap) |
| virtual TCHAR * | GetDefaultOpToken () |
| void | SetLocked (BOOL Status) |
| To set the node's locked status (TRUE/FALSE). | |
| void | SetMangled (BOOL Status) |
| To set Nodes mangled status (TRUE/FALSE). | |
| void | SetMarker (BOOL Status) |
| To set Nodes marked status (TRUE/FALSE). | |
| virtual void | SetSelected (BOOL Status) |
| To set Nodes selected status (TRUE/FALSE) This routine also deals with "select-inside" by making sure all the SelectedChildren flags are set appropriately. Note: Selecting a node prevents it from being a parent of selected nodes This routine therefore clears the selection of any children! Note2: Calling this routine clears any selection from children of this node and marks it to no longer be the parent of selected children. This is done because selected nodes can't have sel children and because unselecting a node implies that you thought it was selected in which case it shouldn't have selected children. | |
| void | SetRender (BOOL Status, BOOL bAndChildren=FALSE) |
| To set Nodes renderable status (TRUE/FALSE). | |
| void | SetParentOfSelected (BOOL Status) |
| To set Nodes SelectedChildren status (TRUE/FALSE) This is used to implement select-inside. | |
| BOOL | HasSelectedChildren () const |
| To find out whether a node has got selected children or children that themselves have selected children... Helper function for SetSelected Scope: Private. | |
| void | ClearSelection (BOOL AndChildren=FALSE) |
| Clears all selection flags in this node. It now deselects all children if the AndChildren is TRUE (Defaults to FALSE). | |
| BOOL | ChildrenNeedTransparency () |
| Used when adding sub-trees to a document (e.g. file load, import). It scans the node's children to determine if any of them need transparency in order to be displayed correctly. NB. The node itself is not checked; only its children. | |
| Node * | FindNext (void) const |
| For finding the next sibling of a node. | |
| Node * | FindPrevious (void) const |
| For finding the previous sibling of a node. | |
| Node * | FindParent (void) const |
| For finding the parent of a node. | |
| Node * | FindFirstChild (void) const |
| For finding the first child of a node. | |
| Node * | FindLastChild (BOOL ExcludeInsertionNode=FALSE) const |
| This function will return TRUE when called on NodeRenderableBounded nodes and those derived from it. This is the base class version that returns FALSE For finding a node's last child. | |
| Node * | FindParent (CCRuntimeClass *ParentClass) const |
| This function follows the node's parent links until it finds a node of class ParentClass. If no such node is found then an ENSURE will occur. | |
| Node * | FindNext (CCRuntimeClass *Class) const |
| This function follows the node's next links until it finds a node derived from Class. NULL is returned if no node is found. | |
| Node * | FindPrevious (CCRuntimeClass *Class) const |
| This function follows the node's Previous links until it finds a node derived from Class. NULL is returned if no node is found. | |
| Node * | FindFirstChild (CCRuntimeClass *Class) const |
| Find first child of specified type. | |
| Node * | FindLastChild (CCRuntimeClass *Class) const |
| Find last child of specified type. | |
| NodeRenderableInk * | FindNextInk () const |
| Find the next ink node. Notes: Analogous to FindNext(CC_RUNTIME_CLASS(NodeRenderableInk)), just faster and neater. | |
| NodeRenderableInk * | FindPreviousInk () const |
| Find the previous ink node. Notes: Analogous to FindPrevious(CC_RUNTIME_CLASS(NodeRenderableInk)), just faster and neater. | |
| NodeRenderableInk * | FindFirstChildInk () const |
| Find the first child ink-node. Notes: Analogous to FindFirstChild(CC_RUNTIME_CLASS(NodeRenderableInk)), just faster and neater. | |
| NodeRenderableInk * | FindLastChildInk () const |
| Find the last child ink-node. Notes: Analogous to FindLastChild(CC_RUNTIME_CLASS(NodeRenderableInk)), just faster and neater. | |
| BaseDocument * | FindOwnerDoc () const |
| Find out which document this node is in. This is used to maintain an accurate node count for each document. | |
| BOOL | IsFamily (CCRuntimeClass *ccrcType, Node *pAncestor) const |
| Basically, we're looking for a child-parent-grandparent relationship. We're the child and our parent can also be the grandparent. | |
| void | SetParentDangerous (Node *NewParent) |
| Sets the parent of the node to NewParent. | |
| void | SetNextDangerous (Node *NewNext) |
| void | SetPreviousDangerous (Node *NewPrev) |
| void | SetChildDangerous (Node *NewChild) |
| Node * | FindNextNonHidden (void) const |
| For finding the next sibling of a node (ignoring all NodeHidden nodes). | |
| Node * | FindPrevNonHidden (void) const |
| For finding the previous sibling of a node (ignoring all NodeHidden nodes). | |
| Spread * | FindParentSpread () |
| Find the spread node to which this node is ultimately attached. | |
| Node * | DocFindNextDepthFirst (void) |
| To find the next node in the depth first traversal of the current document tree. | |
| Node * | FindFirstDepthFirst () |
| To find the first node in a depth first traversal of this subtree. | |
| Node * | FindNextDepthFirst (Node *Subtree) |
| To find the next node in the depth first traversal of the subtree. | |
| Node * | FindFirstPreorder () |
| Node * | FindNextPreorder (Node *pRoot=NULL, BOOL bSkipSubtree=FALSE) |
| Chapter * | FindNextChapter (void) |
| To find the next chapter in the document tree. | |
| NodeRenderablePaper * | FindNextForClippedPaperRender (void) |
| To traverse the document tree to find the next paper renderable node which needs to be rendered, i.e. its pasteboard rectangle intersects with the current clipping rectangle. | |
| Node * | FindFirstForClippedInkRender (DocRect *pClipRect, RenderRegion *pRender, BOOL ExcludeLockedLayers=FALSE, Node *pStopNode=NULL) |
| To traverse the document tree depth first to find the first NodeRenderableInk or NodeAttribute node which needs to be rendered, i.e. in the case of a NodeRenderableInk node its bounding rectangle intersects with the current clipping rectangle (and it's not on a hidden layer). | |
| Node * | FindNextForClippedInkRender (DocRect *pClipRect, RenderRegion *pRender, BOOL ExcludeLockedLayers=FALSE, Node *pStopNode=NULL) |
| To traverse the document tree depth first to find the next NodeRenderableInk or NodeAttribute node which needs to be rendered, i.e. in the case of a NodeRenderableInk its bounding rectangle intersects with the current clipping rectangle. | |
| Node * | FindFirstForUnclippedInkRender (RenderRegion *pRender) |
| To traverse the document tree depth first to find the first NodeRenderableInk or NodeAttribute node which needs to be rendered, regardless of the clip rectangle of the render region (and it's not on a hidden layer). | |
| Node * | FindNextForUnclippedInkRender (RenderRegion *pRender) |
| To traverse the document tree depth first to find the next NodeRenderableInk or NodeAttribute node which needs to be rendered, ignoring the clipping rectangle of the clip region. (i.e. all renderable nodes except those on hidden layers). | |
| Chapter * | FindEnclosingChapter (DocCoord *ChapterPos, XLONG *ChapterDepth) |
| For finding the enclosing chapter of a node, the position of the start of the enclosing chapter, and the chapters depth. | |
| NodeAttribute * | FindFirstGeometryLinkedAttr () |
| NodeAttribute * | FindNextGeometryLinkedAttr () |
| virtual void | UnlinkNodeFromTree (BaseDocument *pOwnerDoc=NULL) |
| Unlinks the node from the tree. | |
| Node * | FindParentOfSelected () |
| To find the node at the normal selection surface from one of its selected-inside children. Note that this routine can be used to test whether a node is "selected-inside" or not by testing whether the Node* returned is NULL or not. (NULL means not selected-inside.). | |
| virtual NodeCompound * | GetParentController () const |
| virtual BOOL | CanBecomeA (BecomeA *pBecomeA) |
| Interrogation routine to see if a node can be changed into a different node type. | |
| virtual BOOL | DoBecomeA (BecomeA *pBecomeA) |
| Actually tries to change the node into a different node type. | |
| ChangeCode | WarnParentOfChange (ObjChangeParam *pParam, BOOL AllParents=TRUE) |
| When an object changes, this function should be used to inform its parent(s) of the change. If AllParents is TRUE it will call every parent, passing the object change parameter to their OnChildChange() virtual function. | |
| virtual BOOL | AllowSelectInside () const |
| void | IncHiddenCnt (void) |
| Increments the count of the number of NodeHidden nodes which reffer to the node. This routine should only be called from the NodeHidden methods. | |
| void | DecHiddenCnt (void) |
| Decrements the count of the number of NodeHidden nodes which reffer to the node. This routine should only be called from the NodeHidden methods. | |
| UINT32 | GetHiddenCnt (void) |
| For finding out how many hidden nodes reffer to the node. | |
| BOOL | OptimiseAttributes () |
| This function should be called on a subtree. | |
| virtual BOOL | HidingNode () |
| Useful for debugging - actually, it only exists in the debug build.This virtual function is called whenever the node is hidden. It allows the node do things like 'optimise' itself to use less memory or send a message to let others know it's is being hidden etc. | |
| virtual BOOL | ShowingNode () |
| This virtual function is called whenever the node is re-shown after being Hidden. It allows the node to reconstruct itself if it was optimised or send a message to let others know it is back etc. | |
| virtual INT32 | ComplexHide (UndoableOperation *pOp, Node *pNextInRange) |
| This function can be overridden by complex objects who wish to gain more control in what happens when they are hidden. For instance some nodes may not want to be hidden at all. If this function is not overridden, the normal action will be used, which is to use DoHideNode() on the node. It may be that some complex parents may wish to retain various sets of nodes within themselves and allow others to be hidden. To inherit this facility in your node, you simply need to override this virtual function and handle your own hiding of the node. | |
| void | MarkNodeAndChildren () |
| Mark this node and all its children. | |
| void | MarkChildren () |
| Mark all children of this node. | |
| void | ClearMarks () |
| Clear marks from this node and all its children. | |
| void | ClearChildMarks () |
| Clear marks from all the children of this node. | |
| virtual BOOL | IsDifferent (Node *pOther) |
| Determine if 2 nodes are considered different. | |
| virtual void | CountChildNodes (UINT32 *pChildCount, UINT32 *pChildAttrCount) |
| This scans the child sibling list of this node, counting the number of nodes it finds and the number of attributes. | |
| virtual BOOL | AreChildAttrsIdentical (Node *pOtherNode) |
| This scans the child sibling list of this node, to see of it contains the same attributes as pOtherNode. | |
| virtual BOOL | HasThisChildAttr (NodeAttribute *pAttr) |
| This scans the child sibling list of this node, to see if it contains an attribute that's exactly the same as the given one. | |
| virtual BOOL | CopyChildAttrs (Node *pDestNode) |
| This scans the child sibling list of this node, and copies all the child attributes, applying the copy as a child to the destination node. | |
| virtual BOOL | IsNodeInSubtree (Node *pNode) |
| Checks the parents of the given node, to see whether it lies within this node's subtree. | |
| virtual BOOL | RegenerateNode (UndoableOperation *pOp=NULL, BOOL bCacheRender=FALSE, BOOL bInformParents=TRUE) |
| virtual BOOL | PromoteHitTestOnChildrenToMe () const |
| virtual BOOL | ShouldITransformWithChildren () const |
| virtual BOOL | NeedsParent (Node *pClassNode) const |
| virtual BOOL | MarqueeSelectNode () const |
| virtual Node * | PublicCopy () |
| This method copies the node's contents to the node pointed to by NodeCopy. | |
| void | RemoveAttrTypeFromSubtree (CCRuntimeClass *AttrType, Node *pExceptThis=NULL) |
| Searches the subtree and every attribute which has type AttrType is deleted. | |
| void | DeleteChildren (Node *FirstChild) |
| Deletes the children and all the children's children etc. starting from FirstChild. | |
| virtual BOOL | SetParentLayerAsEdited () |
| Mark parent layer as edited. If an ink object as something done to it which changes its appearance then we need to mark the parent layer as edited. In this baseclass version do nothing. | |
| NodeAttribute * | FindFirstAttr (TypeFunc pfnTest) const |
| virtual BOOL | IsTypeExtendible () const |
| virtual DocRect | ValidateExtend (const ExtendParams &ExtParams) |
| Tests the reversibility of an Extend operation applied to this node. | |
| virtual void | Extend (const ExtendParams &ExtParams) |
| Perform an Extend operation on this Node, and its children if appropriate. Default implementation just calls Extend() on its children. | |
Static Public Member Functions | |
| static Node * | DocFindFirstDepthFirst (BaseDocument *pDocToSearch) |
| To find the first node in a depth first traversal of the document tree. | |
| static Chapter * | FindFirstChapter (BaseDocument *pDocToSearch) |
| To find the first chapter in the document tree. | |
| static void | StartHourglass () |
| static void | StopHourglass () |
| static BOOL | ShowHourglass () |
Protected Member Functions | |
| virtual Node * | SimpleCopy () |
| This method returns a shallow copy of the node with all Node pointers NULL. The function is virtual, and must be defined for all derived classes of Node. | |
| virtual INT32 | ComplexCopy (CopyStage Stage, Range &RangeToCopy, Node **pOutput) |
| This virtual function is useful for nodes needing to control how they are to be copied. It is overridden currently by text characters and line objects. These objects cannot exist outside the context of a text story. Hence when copying a character object, the parent line object and text story object must be copied along with it. To do this we must give an object the ability to copy whatever it needs to along with itself. In order to do that, the object needs to override this virtual function and the associated GetCopyType() function. ( Normally nodes which are not associated with a particular grouping will not need to override either of these functions. The copy mechanism defaults to using SimpleCopy(), whereby every node is copied as is ). | |
| void | CopyNodeContents (Node *nodeCopy) |
| This method copies the node's contents to the node pointed to by NodeCopy. | |
| Node * | FindChildToRender (DocRect *const pClipRect, RenderRegion *const pRender, BOOL ExcludeLockedLayers, Node *pStopNode=NULL) |
| Find the first child of this node that needs rendering. This follows the children (assuming they intersect with the clipping rectangle), and finds (via a depth first search) the first child that should be rendered according to our rules. The node should be either:. | |
| Node * | FindChildToRenderUnclipped (RenderRegion *const pRender) |
| Find the first child of this node that needs rendering. This follows the children (assuming they intersect with the clipping rectangle), and finds (via a depth first search) the first child that should be rendered according to our rules. The node should be either:. | |
| BOOL | CopyChildren (Node *FirstChild, Node *NewParent, CopyControlFlags=ccALL) |
| This private method makes a copy of all the subtree's children and attaches them to NewParent (the root of the new subtree). It is a helper method for CopyTree. | |
| BOOL | DeSelectSubtree () |
| To deselect all selected nodes below this node. This function also ensures that the SelectedChildren flags are cleared properly. It is self-recursive! Helper function for SetSelected Scope: Private. | |
Protected Attributes | |
| UINT32 | Tag |
| NodeFlags | Flags |
| Node * | Previous |
| Node * | Next |
| Node * | Child |
| Node * | Parent |
| UINT32 | HiddenRefCnt |
Static Protected Attributes | |
| static MILLIPOINT | PixelWidth |
| static MILLIPOINT | PixelHeight |
Private Member Functions | |
| void | AttachAsPreviousNode (Node *ContextNode) |
| Links the node as a previous sibling of ContextNode. | |
| void | AttachAsNextNode (Node *ContextNode) |
| Links the node as a next sibling of ContextNode. | |
| void | AttachAsFirstChildNode (Node *ContextNode) |
| Links the node as a first child of ContextNode. | |
| void | AttachAsLastChildNode (Node *ContextNode) |
| Links the node as a last child of ContextNode. | |
| void | SetTags (BaseDocument *pOwnerDoc) |
| Sets the tag of this node and all its descendants to a legal value, according to which document it is in, if any. | |
Static Private Attributes | |
| static BOOL | HourglassOn = FALSE |
Friends | |
| class | NodeHidden |
Classes | |
| struct | NodeFlags |
Definition at line 344 of file node.h.
|
|
|
|
|
This constructor creates a node linked to no other with all status flags FALSE. Also updates the Node counter of the current Document.
Definition at line 161 of file node.cpp. 00162 { 00163 Previous=Next=Child=Parent=NULL; 00164 // Set OpPermission stuff here too as SetOpPermission does a GetOpPermission which otherwise reads an undefined value 00165 Flags.Locked=Flags.Mangled=Flags.Marked=Flags.Selected=Flags.Renderable=Flags.OpPermission1=Flags.OpPermission2 = FALSE; 00166 Flags.SelectedChildren = FALSE; 00167 SetOpPermission(PERMISSION_UNDEFINED); 00168 HiddenRefCnt = 0; 00169 00170 // Has no TAG because it is not in a document yet. 00171 Tag = TAG_NOT_IN_DOC; 00172 }
|
|
||||||||||||||||||||||||||||||||
|
This constructor initialises a node and links it to ContextNode in the direction specified by Direction. All necessary tree links are updated. For example if a node is inserted as a FirstChild of ContextNode, and Context node already has children, then the current first child of context node will become the next sibling of the new first child node.
Specifies the direction in which the node is to be attached to the ContextNode. The values this variable can take are as follows: PREV : Attach node as a previous sibling of the context node NEXT : Attach node as a next sibling of the context node FIRSTCHILD: Attach node as the first child of the context node LASTCHILD : Attach node as a last child of the context node The remaining inputs specify the status of the node: Locked: Is node locked ? Mangled: Is node mangled ? Marked: Is node marked ? Selected: Is node selected ? Renderable: Is node renderable ? Compound: Can node contain non attribute children (eg. a group)
Definition at line 232 of file node.cpp. 00240 { 00241 // Defensive programming 00242 ENSURE(ContextNode != NULL,"Trying to attach a node to a NULL node"); 00243 00244 // Initialize the flags 00245 Flags.Locked = Locked; 00246 Flags.Mangled = Mangled; 00247 Flags.Marked = Marked; 00248 Flags.Selected = Selected; 00249 Flags.SelectedChildren = FALSE; 00250 Flags.Renderable = Renderable; 00251 Flags.OpPermission1 = Flags.OpPermission2 = FALSE; // because SetOpPermission does a GetOpPermission 00252 00253 // Has no TAG because it is not in a document yet. 00254 Tag = TAG_NOT_IN_DOC; 00255 00256 SetOpPermission(PERMISSION_UNDEFINED); 00257 Child=NULL; // New node has no children 00258 AttachNode(ContextNode,Direction); 00259 00260 // Sanity check of unique TAG for object 00261 BaseDocument* pDoc = ContextNode->FindOwnerDoc(); 00262 if (pDoc != NULL) 00263 { 00264 ERROR3IF(Tag==TAG_NOT_IN_DOC, "Tag should have a valid value"); 00265 // Get a tag for this node and update the count of nodes in the document. 00266 if (Tag==TAG_NOT_IN_DOC) 00267 SetTags(pDoc); 00268 } 00269 else 00270 { 00271 ERROR3IF(Tag!=TAG_NOT_IN_DOC, "Tag should be TAG_NOT_IN_DOC"); 00272 Tag = TAG_NOT_IN_DOC; // Has no TAG 00273 } 00274 00275 HiddenRefCnt = 0; 00276 00277 if (Selected) 00278 { 00279 // Inform the Selection SelRange that the selection has changed 00280 // Pass in 'this' to let it know that I am the most recently selected node 00281 SelRange *Selection = GetApplication()->FindSelection(); 00282 if (Selection != NULL) 00283 Selection->Update(FALSE, this); 00284 } 00285 }
|
|
|
Destroys a Node object. The base class updates the node counter of the current document, and ensures that the SelRange doesn't have a cached pointer to 'this' as its 'Last Selected Node'.
Definition at line 307 of file node.cpp. 00308 { 00309 ERROR3IF(Child != NULL,"Deleting a node that has a ptr to child nodes"); 00310 00311 // Ensure that the Selection SelRange doesn't still keep a cached pointer to me 00312 SelRange *Selection = GetApplication()->FindSelection(); 00313 if (Selection != NULL) 00314 Selection->ClearLastSelectedNodeIfItIs(this); 00315 00316 }
|
|
||||||||||||||||
|
This is the way to ask a node if you can do an op to it.
For example, the op could change the node's appearence (e.g. attr application, editing a path), replace the node with another node (e.g. because it uses hidden nodes to hide the original and put another node in its place, or "make shapes"), delete the node (e.g. the delete and cut ops), etc. This function gives the node a chance to say NO. It also gives the parents a chance to say no too. E.g. a blend node will allow itself to be deleted, but it will NOT allow a child of itself to be deleted). This call should only be made on selected, or parents of selected, nodes. It makes a decision as a straight node if it is selected. It makes a decision as a parent if it has selected children. E.g. NodeBlend::AllowOp(...op delete...) if the node is selected, then it will return TRUE (parents permitting), i.e. I can be deleted if the node is a parent of selected it will return FALSE (i.e. can't delete children of blends). So when the node is selected, you are asking the node if you can do the op to it. When the node is a parent of a selected node, you are asking if you can do the op to one of its children. If the 'SetOpPermissionState' param is TRUE, the following indented lines applies: The node's op permission state is set according to the result of this function. If TRUE is returned, then the node's op permission state will be left unchanged. AND the parent's op permission state will be set to PERMISSION_ALLOWED if FALSE is returned, then the node's op permission state will be PERMISSION_DENIED, AND all it's parents (up to the layer) will be set to PERMISSION_DENIED Also, all parents of this node are called via their AllowOp() func with the same state as this node. This means that after this call, you can guarantee that all of its parents will have either a PERMISSION_DENIED or PERMISSION_ALLOWED state. Note: Even if this node tries to set all it's parents to have a PERMISSION_DENIED state, if any of its parents have previously been set to PERMISSION_ALLOWED they will remain in that state (see SetOpPermission()). Why? Well, it is possible for a parent node to have one child with a PERMISSION_DENIED and another child with a PERMISSION_ALLOWED. It this state the parent MUST be in state PERMISSION_ALLOWED, because at least one of its children will allow the op to happen to it. So, after this call: The op permission state for this node will be either left unchanged (and therefore remain PERMISSION_UNDEFINED), or PERMISSION_DENIED. The parent's op permission state will be either PERMISSION_ALLOWED, or PERMISSION_DENIED. This is so UndoableOperation::UpdateChangedNodes() will only call OnChildChange() on parent nodes, because it only calls that func for nodes that have an op permission state of PERMISSION_ALLOWED.
Reimplemented in Layer, NodeContourController, NodeBlendPath, NodeClipViewController, NodeSetSentinel, NodeBevel, NodeBlend, NodeContour, NodeMoulder, NodePath, BaseTextClass, and TextStory. Definition at line 5147 of file node.cpp. 05148 { 05149 ERROR2IF(pParam==NULL,FALSE,"Node::AllowOp() - pParam==NULL"); 05150 05151 // if not called by a child AllowOp(), ensure AllowOp() called for all nodes in compound nodes, 05152 if (pParam->GetDirection()!=OBJCHANGE_CALLEDBYCHILD) 05153 { 05154 BOOL AnyAllowed=AllowOp_AccountForCompound( pParam, 05155 SetOpPermissionState, 05156 DoPreTriggerEdit ); 05157 // check for geometry linked attributes 05158 // NB this handles the passing of AllowOp messages to GeomLinkedAttrs on CALLEDBYPARENT 05159 // and CALLEDBYOP. 05160 // NB2 compounds which don't implement their own AllowOps will call 05161 // AccountForCompound from here so ensure that nodes don't inform 05162 // geom linked attrs of the change twice 05163 if(!IS_KIND_OF(NodeGroup)) 05164 { 05165 UndoableOperation* pChangeOp = pParam->GetOpPointer(); 05166 BOOL InformGeomLinkedAttrs = SetOpPermissionState && pChangeOp && pChangeOp->MayChangeNodeBounds(); 05167 if(InformGeomLinkedAttrs) 05168 { 05169 NodeAttribute* pNA = FindFirstGeometryLinkedAttr(); 05170 while(pNA) 05171 { 05172 pNA->LinkedNodeGeometryHasChanged(pChangeOp); 05173 pNA = pNA->FindNextGeometryLinkedAttr(); 05174 } 05175 } 05176 } 05177 05178 // if called by a parent, just pass this result back 05179 if (pParam->GetDirection()==OBJCHANGE_CALLEDBYPARENT) 05180 return AnyAllowed; 05181 } 05182 else 05183 { 05184 // clean out the calling-child ptr, so it doesn't get passed around unintentionally. 05185 pParam->SetCallingChild(NULL); 05186 } 05187 05188 05189 // at this point we must have been called directly by the op or via a child AllowOp() 05190 05191 // decide if we allow it ... err we do! 05192 BOOL allowed = TRUE; 05193 05194 // if we allowed it, see if our parents do ... 05195 if (Parent != NULL) 05196 { 05197 ObjChangeDirection OldDirection = pParam->GetDirection(); 05198 pParam->SetCallingChild(this); 05199 pParam->SetDirection(OBJCHANGE_CALLEDBYCHILD); 05200 allowed = Parent->AllowOp(pParam,SetOpPermissionState,DoPreTriggerEdit); 05201 pParam->SetDirection(OldDirection); 05202 } 05203 05204 // if setting permisions ... 05205 if (SetOpPermissionState) 05206 { 05207 // if allowed, mark parent accordingly, else mark child as denied and update parents 05208 if (!allowed) 05209 SetOpPermission(PERMISSION_DENIED,TRUE); 05210 else 05211 if (Parent != 0) Parent->SetOpPermission(PERMISSION_ALLOWED); 05212 } 05213 05214 if (allowed) 05215 { 05216 UndoableOperation* pChangeOp = pParam->GetOpPointer(); 05217 // check for geometry linked attributes (for CALLEDBYCHILD direction) 05218 if(IsCompound() && pParam->GetDirection()==OBJCHANGE_CALLEDBYCHILD) 05219 { 05220 BOOL InformGeomLinkedAttrs = SetOpPermissionState && pChangeOp && pChangeOp->MayChangeNodeBounds(); 05221 if(InformGeomLinkedAttrs) 05222 { 05223 NodeAttribute* pNA = FindFirstGeometryLinkedAttr(); 05224 while(pNA) 05225 { 05226 pNA->LinkedNodeGeometryHasChanged(pChangeOp); 05227 pNA = pNA->FindNextGeometryLinkedAttr(); 05228 } 05229 } 05230 } 05231 05232 // if we're ok so far and were asked to do a PreTriggerEdit, then 05233 // determine whether the Op may change the bounds of some nodes. 05234 // If it may, then call NameGallery::PreTriggerEdit. 05235 if(DoPreTriggerEdit) 05236 { 05237 // if the Op is non-NULL then query its MayChangeNodeBounds() method. 05238 if (pChangeOp != NULL && pChangeOp->MayChangeNodeBounds() && NameGallery::Instance()) 05239 { 05240 allowed = NameGallery::Instance()->PreTriggerEdit(pChangeOp, pParam, this); 05241 } 05242 } 05243 } 05244 05245 // return result (directly, or indirectly via a child AllowOp()) to op 05246 return allowed; 05247 }
|
|
||||||||||||||||
|
if this is a compound node, ensures all child nodes have their AllowOp() called.
This also ensures post-op code in OnChildChange()s is called (if the OpPermission is set on affected nodes AND PARENTS) eg. format redraw for TextStories This fixes the bug where attributes applied to a group/Mould/Blend containing a TextStory cause the text story to be formatted correctly Note: Optimisation - currently only done for attribute changes and transformations. Karim 18/05/2000 - Also now done when Flags.RegenerateNode is set. Reimplemented in NodeCompound, and TextStory. Definition at line 5280 of file node.cpp. 05282 { 05283 BOOL AnyAllowed=FALSE; 05284 05285 // 'optimised' to only do the biz if an attr changes, it's a transform or a regeneration. 05286 ObjChangeFlags Flags=pParam->GetChangeFlags(); 05287 if (IsCompound() && (Flags.Attribute || Flags.TransformNode || Flags.RegenerateNode) ) 05288 { 05289 ObjChangeDirection OldDirection=pParam->GetDirection(); 05290 pParam->SetDirection(OBJCHANGE_CALLEDBYPARENT); 05291 Node* pNode=FindFirstChild(); 05292 UndoableOperation* pChangeOp = pParam->GetOpPointer(); 05293 BOOL InformGeomLinkedAttrs = SetOpPermissionState && pChangeOp && pChangeOp->MayChangeNodeBounds(); 05294 05295 while (pNode!=NULL) 05296 { 05297 if (pNode->IsAnObject()) 05298 AnyAllowed |= pNode->AllowOp(pParam, SetOpPermissionState, DoPreTriggerEdit); 05299 else 05300 { 05301 if(pNode->IsAnAttribute() && ((NodeAttribute*)pNode)->IsLinkedToNodeGeometry()) 05302 if(InformGeomLinkedAttrs) 05303 ((NodeAttribute*)pNode)->LinkedNodeGeometryHasChanged(pChangeOp); 05304 } 05305 05306 pNode=pNode->FindNext(); 05307 } 05308 pParam->SetDirection(OldDirection); 05309 } 05310 05311 // if setting flags and any child allowed it, set this permission allowed 05312 if (AnyAllowed && SetOpPermissionState) 05313 SetOpPermission(PERMISSION_ALLOWED); 05314 05315 return AnyAllowed; 05316 }
|
|
|
Reimplemented in NodeLiveEffect, NodeLockedEffect, and NodeMould. Definition at line 669 of file node.h. 00669 { return TRUE; }
|
|
|
This scans the child sibling list of this node, to see of it contains the same attributes as pOtherNode.
Definition at line 6112 of file node.cpp. 06113 { 06114 ERROR2IF(pOtherNode == NULL,FALSE,"NULL node ptr"); 06115 06116 // Count the number of child attrs in this and the other nodes. 06117 UINT32 ChildAttrCount,OtherChildAttrCount; 06118 CountChildNodes(NULL,&ChildAttrCount); 06119 pOtherNode->CountChildNodes(NULL,&OtherChildAttrCount); 06120 06121 // If they don't have the same number of child attrs, then they can't have an identical set 06122 if (ChildAttrCount != OtherChildAttrCount) 06123 return FALSE; 06124 06125 Node* pNode = FindFirstChild(); 06126 while (pNode != NULL) 06127 { 06128 if (pNode->IsAnAttribute()) 06129 { 06130 if (!pOtherNode->HasThisChildAttr((NodeAttribute*)pNode)) 06131 return FALSE; 06132 } 06133 06134 pNode = pNode->FindNext(); 06135 } 06136 06137 return TRUE; 06138 }
|
|
|
This function is used by the progressive rendering system & the new file format to determine whether the node is renderable or not.
Reimplemented in NodeGroup, and NodeRenderableInk. Definition at line 5973 of file node.cpp. 05974 { 05975 return TRUE; 05976 }
|
|
|
Links the node as a first child of ContextNode.
Definition at line 839 of file node.cpp. 00840 { 00841 ENSURE(ContextNode != NULL,"Trying to attach a node to a NULL node"); 00842 00843 // Check if ContextNode already has a Child 00844 if (ContextNode->Child == NULL) 00845 Next = NULL; // If not then new node has no next sibling 00846 else 00847 { 00848 // Context node's first child becomes the new node's next sibling 00849 Next = ContextNode->Child; 00850 // The next sibling's previous sibling becomes the new node 00851 Next->Previous = this; 00852 } 00853 ContextNode->Child = this; // Attach new node as first child of context node 00854 Previous = NULL; // A first child cannot have a previous sibling 00855 Parent = ContextNode; // New node's parent is ContextNode 00856 }
|
|
|
Links the node as a last child of ContextNode.
Definition at line 890 of file node.cpp. 00891 { 00892 ENSURE(ContextNode != NULL,"Trying to attach a node to a NULL node"); 00893 if (!ContextNode) 00894 return; // Don't just blow up 00895 00896 if (ContextNode->Child == NULL) // The context node has no children 00897 AttachAsFirstChildNode(ContextNode); // Add node as first child of context node 00898 else 00899 { 00900 // Search for the current last child of Context node 00901 Node* np; 00902 for(np=ContextNode->Child; (np->Next != NULL); np = np->Next); 00903 // Add node as the next node of the current last child of ContextNode 00904 AttachAsNextNode(np); 00905 } 00906 }
|
|
|
Links the node as a next sibling of ContextNode.
Definition at line 790 of file node.cpp. 00791 { 00792 ENSURE(ContextNode != NULL,"Trying to attach a node to a NULL node"); 00793 00794 // Check if ContextNode already has a Next sibling 00795 if (ContextNode->Next == NULL) // Context node has no next sibling 00796 Next = NULL; // New node has no next sibling 00797 else 00798 { 00799 // The new node's next sibling = the context node's next sibling 00800 Next = ContextNode->Next; 00801 // The next sibling's previous sibling becomes the new node 00802 Next->Previous = this; 00803 } 00804 ContextNode->Next = this; // Attach new node as next sibling 00805 Previous = ContextNode; // New node's previous sibling is ContextNode 00806 Parent = ContextNode->Parent; // New node's parent same as the ContextNode 00807 }
|
|
|
Links the node as a previous sibling of ContextNode.
Definition at line 732 of file node.cpp. 00733 { 00734 ENSURE(ContextNode != NULL,"Trying to attach a node to a NULL node"); 00735 00736 // Check if ContextNode already has a Previous sibling 00737 if (ContextNode->Previous == NULL) // ContextNode has no previous sibling 00738 { 00739 Previous = NULL; // The new node has no previous sibling 00740 00741 // If ContextNode has a parent then ContextNode will currently be the 00742 // first child of the parent because Previous == NULL 00743 if (ContextNode->Parent != NULL) 00744 { 00745 // Make the new node the first child of ContextNode 00746 ContextNode->Parent->Child = this; 00747 } 00748 } 00749 else // Context node has a previous sibling 00750 { 00751 // The new node's Previous sibling becomes the context node's previous sibling 00752 Previous = ContextNode->Previous; 00753 // The previous siblings next sibling becomes the new node 00754 Previous->Next = this; 00755 } 00756 ContextNode->Previous = this; // Attach new node as previous sibling 00757 Next = ContextNode; // New node's next sibling is ContextNode 00758 Parent = ContextNode->Parent; // New nodes parent same as the ContextNode. 00759 }
|
|
||||||||||||||||||||
|
This method attaches the node to a context node in the direction specified by Direction. All necessary tree links are updated.
Specifies the direction in which this node is to be attached to the ContextNode. The values this variable can take are as follows: PREV : Attach node as a previous sibling of the context node NEXT : Attach node as a next sibling of the context node FIRSTCHILD: Attach node as the first child of the context node LASTCHILD : Attach node as a last child of the context node fCheckTransparent whether the insertion routine should test if the node to be inserted requires transparency mode to render, and if so, to prompt the user about this. InvalidateBounds When TRUE the parents bounds + all its childrens bounds will be invalidated if this is neccessary.
Definition at line 606 of file node.cpp. 00610 { 00611 ERROR3IF(IsAnAttribute() && (!(((NodeAttribute*)this)->CanBeAppliedToObject())) && 00612 ContextNode->IsAnObject(), 00613 "Trying to attach invalid attribute to this object"); 00614 00615 ENSURE(ContextNode != NULL,"Trying to attach a node to a NULL node"); 00616 switch (Direction) 00617 { 00618 case PREV: // Attach node as a previous sibling of the ContextNode 00619 AttachAsPreviousNode(ContextNode); 00620 break; 00621 case NEXT: // Attach node as a next sibling of the ContextNode 00622 AttachAsNextNode(ContextNode); 00623 break; 00624 case FIRSTCHILD: // Attach node as the first child of the Context node 00625 AttachAsFirstChildNode(ContextNode); 00626 break; 00627 case LASTCHILD: // Attach node as the last child of the Context node 00628 AttachAsLastChildNode(ContextNode); 00629 break; 00630 } 00631 00632 // If an attribute is being attached which affects the parents bounds then we need to 00633 // invalidate it's parent and all children of the parent!. 00634 00635 if (InvalidateBounds) 00636 { 00637 Node* pParent = FindParent(); 00638 if (pParent != NULL) 00639 { 00640 if (pParent->IsBounded()) 00641 { 00642 BOOL AffectsParentsChildren = (this->IsAnAttribute() && ((NodeAttribute*)this)->EffectsParentBounds()); 00643 if (AffectsParentsChildren) 00644 { 00645 ((NodeRenderableBounded*)pParent)->InvalidateBoundingRect(TRUE); 00646 } 00647 } 00648 } 00649 } 00650 00651 // Set the tags for this node and any children 00652 BaseDocument* pDoc = ContextNode->FindOwnerDoc(); 00653 SetTags(pDoc); 00654 }
|
|
|
Interrogation routine to see if a node can be changed into a different node type.
Also, the entry value of *pNumObjects cannot be assumed to be 0.
Reimplemented in AttrBevelType, NodeContourController, NodeClipViewController, NodeBevel, NodeBlender, NodeBitmap, NodeContour, NodeCompound, NodeBitmapEffect, NodeMoulder, NodeMould, NodePath, NodeRegularShape, NodeSimpleShape, and TextStory. Definition at line 5531 of file node.cpp. 05532 { 05533 return FALSE; 05534 }
|
|
|
Reimplemented in Layer, NodeBlend, NodeMoulder, TextChar, CaretNode, EOLNode, and TextStory. Definition at line 5789 of file node.cpp. 05790 { 05791 return TRUE; 05792 }
|
|
|
If the node does not mind the filter automatically writing out its child nodes, then return TRUE. > virtual BOOL Node::CanWriteChildrenWeb(BaseCamelotFilter* pFilter)
Reimplemented in Layer, NodeSetProperty, NodeBarProperty, NodeSetSentinel, NodeBlend, NodeMoulder, TextChar, CaretNode, EOLNode, and TextStory. Definition at line 5783 of file node.cpp. 05784 { 05785 return TRUE; 05786 }
|
|
|
This method removes the node from the tree and deletes all its child nodes (including hidden nodes).
The following before and after diagram illustrates this form of deletion: Notes: Before:- MonoOn .-----. | N1 | | | .-----. | V .-----. .-----. .-----. |N2 |----->|N3 |----->| N4 | | | | | | | .-----. .-----. .-----. | V .-----. .-----. |N5 |----->|N6 | | | | | .-----. .-----. | V .-----. |N7 | | | .-----. MonoOff After deleting node N3 MonoOn .-----. |N1 | | | .-----. | V .-----. .-----. |N2 |----->|N4 | | | | | .-----. .-----. MonoOff
Definition at line 981 of file node.cpp. 00982 { 00983 ERROR3IF(GetHiddenCnt() != 0, "Trying to delete a node with a hidden ref cnt"); 00984 // Delete all the node's children 00985 DeleteChildren(Child); 00986 // Unlink the node from the tree 00987 UnlinkNodeFromTree(); 00988 }
|
|
|
Used when adding sub-trees to a document (e.g. file load, import). It scans the node's children to determine if any of them need transparency in order to be displayed correctly. NB. The node itself is not checked; only its children.
Definition at line 4887 of file node.cpp. 04888 { 04889 #ifdef RALPH 04890 // Can't scan children when progressively loading/rendering in ralph 04891 return TRUE; 04892 #else 04893 // Start with the first child of this node. 04894 Node *pChild = FindFirstChild(); 04895 04896 while (pChild != NULL) 04897 { 04898 // Does this child (or any of its children) need transparency? 04899 if (pChild->NeedsTransparency() || pChild->ChildrenNeedTransparency()) 04900 // Yes - found some transparency 04901 return TRUE; 04902 04903 // Try the next child. 04904 pChild = pChild->FindNext(); 04905 } 04906 04907 // No transparency found 04908 return FALSE; 04909 #endif 04910 }
|
|
|
Clear marks from all the children of this node.
Definition at line 5493 of file node.cpp. 05494 { 05495 Node* pNode = FindFirstChild(); 05496 while (pNode!=NULL) 05497 { 05498 pNode->SetMarker(FALSE); 05499 pNode->ClearChildMarks(); 05500 pNode=pNode->FindNext(); 05501 } 05502 }
|
|
|
Clear marks from this node and all its children.
Definition at line 5475 of file node.cpp. 05476 { 05477 SetMarker(FALSE); 05478 ClearChildMarks(); 05479 }
|
|
|
Clears all selection flags in this node. It now deselects all children if the AndChildren is TRUE (Defaults to FALSE).
Definition at line 1185 of file node.h. 01186 { 01187 Flags.Selected = FALSE; 01188 Flags.SelectedChildren = FALSE; 01189 if (AndChildren) 01190 DeSelectSubtree(); 01191 }
|
|
||||||||||||
|
This method outputs a 'deep' copy of the node. It is the same as CopyNode except that the copy is not linked into the tree. Override if yor class can interpret the lightweight flag.
Definition at line 1298 of file node.cpp. 01299 { 01300 return NodeCopy(ppNodeCopy); 01301 }
|
|
||||||||||||||||
|
This virtual function is useful for nodes needing to control how they are to be copied. It is overridden currently by text characters and line objects. These objects cannot exist outside the context of a text story. Hence when copying a character object, the parent line object and text story object must be copied along with it. To do this we must give an object the ability to copy whatever it needs to along with itself. In order to do that, the object needs to override this virtual function and the associated GetCopyType() function. ( Normally nodes which are not associated with a particular grouping will not need to override either of these functions. The copy mechanism defaults to using SimpleCopy(), whereby every node is copied as is ).
Note: Imagine you override this function for a particular node pN which exists as a selectable item inside a common parent cP. Now, for you to do so obviously means that pN cannot exist outside cP and pN can be selected without pN being selected. Not to override this function would ofcourse allow pN to be copied to the clipboard by itself which may be hazardous. So overriding the function will allow you to make a copy of cP and pN together, when the function is called. You do not need to override this function inside the class pN. When pN is selected a SimpleCopy() copies it and all its children automatically ensuring validity. Its soley for use by children that need their parents!
Reimplemented in NodeBlendPath, NodeMouldPath, VisibleTextNode, and TextLine. Definition at line 1857 of file node.cpp.
|
|
||||||||||||
|
This function can be overridden by complex objects who wish to gain more control in what happens when they are hidden. For instance some nodes may not want to be hidden at all. If this function is not overridden, the normal action will be used, which is to use DoHideNode() on the node. It may be that some complex parents may wish to retain various sets of nodes within themselves and allow others to be hidden. To inherit this facility in your node, you simply need to override this virtual function and handle your own hiding of the node.
Reimplemented in NodeContourController, VisibleTextNode, and TextLine. Definition at line 4798 of file node.cpp.
|
|
|
This scans the child sibling list of this node, and copies all the child attributes, applying the copy as a child to the destination node.
Definition at line 6155 of file node.cpp. 06156 { 06157 ERROR2IF(pDestNode == NULL,FALSE,"NULL dest node ptr"); 06158 06159 Node* pLastInsert = NULL; 06160 Node* pSrcNode = FindFirstChild(); 06161 while (pSrcNode != NULL) 06162 { 06163 if (pSrcNode->IsAnAttribute()) 06164 { 06165 Node* pCopy = pSrcNode->SimpleCopy(); 06166 if (pCopy == NULL) 06167 return(FALSE); 06168 06169 if (pLastInsert == NULL) 06170 { 06171 pCopy->AttachNode(pDestNode,FIRSTCHILD); 06172 } 06173 else 06174 { 06175 pCopy->AttachNode(pLastInsert,NEXT); 06176 } 06177 pLastInsert = pCopy; 06178 } 06179 06180 pSrcNode = pSrcNode->FindNext(); 06181 } 06182 06183 return TRUE; 06184 }
|
|
||||||||||||||||
|
This private method makes a copy of all the subtree's children and attaches them to NewParent (the root of the new subtree). It is a helper method for CopyTree.
Definition at line 1460 of file node.cpp. 01461 { 01462 if (ShowHourglass()) 01463 { 01464 ContinueSlowJob(); 01465 } 01466 BOOL CopyObject=FALSE; 01467 01468 // Find out the destination document, if any. 01469 BaseDocument* pDoc = NewParent->FindOwnerDoc(); 01470 01471 NewParent->Child = NULL; // Just in case no nodes are copied 01472 01473 if (FirstChild != NULL) // New parent has children 01474 { 01475 Node* CurrentChild = FirstChild; 01476 Node* LastNewChild = NULL; 01477 while (CurrentChild != NULL) // While there are children left to copy 01478 { 01479 // We don't copy hidden nodes or the insertion node. 01480 if (!CurrentChild->IsNodeHidden() && !CurrentChild->IsAnInsertionNode()) 01481 { 01482 switch (CopyFlags) 01483 { 01484 case ccALL: 01485 CopyObject=TRUE; 01486 break; 01487 case ccLOCKED: 01488 CopyObject=((CurrentChild->IsLocked())!=0); 01489 break; 01490 case ccMANGLED: 01491 CopyObject=((CurrentChild->IsMangled())!=0); 01492 break; 01493 case ccMARKED: 01494 CopyObject=((CurrentChild->IsMarked())!=0); 01495 break; 01496 case ccSELECTED: 01497 CopyObject=((CurrentChild->IsSelected())!=0); 01498 break; 01499 case ccRENDERABLE: 01500 CopyObject=((CurrentChild->IsRenderable())!=0); 01501 break; 01502 } 01503 01504 if (CopyObject) 01505 { 01506 Node* NewChild = CurrentChild->SimpleCopy(); // Copy current node (virtual method) 01507 01508 if (NewChild == NULL) // Out of memory 01509 return FALSE; 01510 01511 // Attach the NewChild node to the previous or parent node 01512 if (LastNewChild != NULL) // Child is not a first child 01513 LastNewChild->Next = NewChild; 01514 else // Child is a first child 01515 NewParent->Child = NewChild; // NewParent's first child is the NewChild 01516 01517 NewChild->Parent = NewParent; // The parent of the new child node is NewParent 01518 NewChild->Previous = LastNewChild; // The previous sibling of the new child 01519 01520 // Karim 16/01/01 - GLA's must be re-linked up when they are copied. 01521 if (NewChild->IsAnAttribute() && ((NodeAttribute*)NewChild)->IsLinkedToNodeGeometry()) 01522 ((NodeAttribute*)NewChild)->LinkToGeometry(NewParent); 01523 01524 // Ensure that this new node has the correct tag. 01525 if (pDoc != NULL) 01526 { 01527 NewChild->Tag = pDoc->NewTag(); 01528 pDoc->IncNodeCount(); 01529 } 01530 else 01531 { 01532 // Ensure this is marked as not being in a document. 01533 NewChild->Tag = TAG_NOT_IN_DOC; 01534 } 01535 01536 if (CurrentChild->Child != NULL) // There are children to copy 01537 if(!CopyChildren(CurrentChild->Child,NewChild,CopyFlags))// Recursively copy child's children 01538 return (FALSE); // Out of memory 01539 01540 LastNewChild = NewChild; // Need to remember this for next/prev links 01541 } 01542 } 01543 CurrentChild = CurrentChild->Next; // Process next sibling 01544 01545 if (ShowHourglass()) 01546 { 01547 ContinueSlowJob(); 01548 } 01549 01550 } 01551 } 01552 return TRUE; // No errors occurred 01553 }
|
|
||||||||||||
|
This function copies the node's children to DestinationNode which should initially have no children.
Definition at line 1653 of file node.cpp. 01654 { 01655 Node* FirstChild = FindFirstChild(); 01656 if (FirstChild != NULL) 01657 { 01658 if (!CopyChildren(FirstChild, DestinationNode, CopyFlags)) 01659 { 01660 DeleteChildren(DestinationNode->FindFirstChild()); 01661 return (FALSE); 01662 } 01663 } 01664 return TRUE; 01665 }
|
|
|
Copy the series of nodes described by RangeToCopy and attach them to onto the last child position of this object.
Definition at line 1320 of file node.cpp. 01321 { 01322 BOOL Failed=FALSE; 01323 Node* Current = RangeToCopy.FindFirst(); 01324 Node* NewNode; 01325 01326 std::list<Node *> ListOfNodes(30); 01327 01328 while (Current!=NULL) 01329 { 01330 CopyType ctype = Current->GetCopyType(); 01331 switch (ctype) 01332 { 01333 case SIMPLECOPY: 01334 { 01335 Failed = !(Current->CopyNode(this, LASTCHILD)); 01336 01337 // kludge, should be part of post-copy system which does not exist!! 01338 // unwrap any text story on the clipboard 01339 if (IS_A(Current,TextStory)) 01340 { 01341 Node* pLastChild = this->FindLastChild(); 01342 if (IS_A(pLastChild,TextStory)) 01343 Failed = !((TextStory*)pLastChild)->UnWrapStory(NULL); 01344 else 01345 { 01346 ERROR2RAW("Node::CopyComplexRange() - did not find the story"); 01347 Failed = TRUE; 01348 } 01349 } 01350 01351 break; 01352 } 01353 01354 case COMPLEXCOPY: 01355 { 01356 INT32 success = Current->ComplexCopy(COPYOBJECT, RangeToCopy, &NewNode); 01357 // success=-1 then error 01358 // success= 0 then ignore 01359 // success= 1 then attach NewNode 01360 if (success>0) 01361 { 01362 NewNode->AttachNode(this, LASTCHILD); 01363 // we need to save a list of these nodes for a call back 01364 ListOfNodes.push_back( Current ); 01365 ListOfNodes.push_back( NewNode ); 01366 } 01367 01368 Failed=(success<0); 01369 break; 01370 } 01371 01372 default: 01373 { 01374 ERROR2RAW("Illegal copy type returned to CopyComplexRange()"); 01375 Failed=TRUE; 01376 break; 01377 } 01378 } 01379 01380 // if we haven't copied properly, tidy up and exit the loop 01381 if (Failed) 01382 break; 01383 01384 Current = RangeToCopy.FindNext(Current); 01385 } 01386 01387 // Now call the nodes complex copy functions again to say we've done something. 01388 // But only call those we have already! 01389 01390 while( !ListOfNodes.empty() ) 01391 { 01392 Node *pCopy = (Node *)ListOfNodes.back(); ListOfNodes.pop_back(); 01393 Node *pRecall = (Node *)ListOfNodes.back(); ListOfNodes.pop_back(); 01394 01395 if( pRecall && pCopy && pRecall->GetCopyType() == COMPLEXCOPY ) 01396 pRecall->ComplexCopy( COPYFINISHED, RangeToCopy, &pCopy ); 01397 } 01398 01399 /* 01400 if (Current!=NULL) 01401 Current=RangeToCopy.FindNext(Current); 01402 01403 Node* Recall = RangeToCopy.FindFirst(); 01404 while ((Recall!=Current) && (Recall!=NULL)) 01405 { 01406 if (Recall->GetCopyType()==COMPLEXCOPY) 01407 Recall->ComplexCopy(COPYFINISHED, RangeToCopy, &NewNode); 01408 Recall = RangeToCopy.FindNext(Recall); 01409 } 01410 */ 01411 01412 return (!Failed); 01413 }
|
|
||||||||||||
|
This method creates a 'deep' copy of the node and then attaches it to the destination node. The Direction input specifies how the node is to be attached to the Destination node. The following before and after diagram illustrates this method.
Specifies the direction in which the copied node is to be attached to the Destination node. The values this variable can take are as follows: PREV : Attach node as a previous sibling of the destination node NEXT : Attach no de as a next sibling of the destination node FIRSTCHILD: Attach node as the first child of the destination node LASTCHILD : Attach node as a last child of the destination node
MonoOn .-----. .-----. .-----. |N1 |----->|N2 |----->| N3 | | | | | | | .-----. .-----. .-----. | V .-----. .-----. |N4 |----->|N5 | | | | | .-----. .-----. MonoOff After copying node N2 to destination N2 as a next sibling:- MonoOn .-----. .-----. .-----. .-----. |N1 |----->|N2 |------------->| N2C |----->|N3 | | | | | | | | | .-----. .-----. .-----. .-----. | | V V .-----. .-----. .-----. .-----. |N4 |----->|N5 | |N4C |----->|N5C | | | | | | | | | .-----. .-----. .-----. .-----. MonoOff
Definition at line 1225 of file node.cpp. 01226 { 01227 // Get a copy of the subtree 01228 if (ShowHourglass()) 01229 { 01230 ContinueSlowJob(); 01231 } 01232 01233 Node* NewNode; 01234 if (!NodeCopy(&NewNode)) 01235 return FALSE; 01236 01237 // Attach the copied node to the Destination node 01238 NewNode->AttachNode(DestinationNode, Direction); 01239 return (TRUE); 01240 }
|
|
|
This method copies the node's contents to the node pointed to by NodeCopy.
Definition at line 1766 of file node.cpp. 01767 { 01768 ENSURE(NodeCopy != NULL,"Trying to copy node contents to\na node pointed to by a NULL pointer"); 01769 NodeCopy->Flags = Flags; 01770 // All tree pointers are NULL 01771 // Phil, 7/1/2004 01772 // DO NOT blat the tree pointers because the node may already be in the tree!!! 01773 // NodeCopy->Previous=NodeCopy->Next=NodeCopy->Parent=NodeCopy->Child = NULL; 01774 }
|
|
||||||||||||
|
This scans the child sibling list of this node, counting the number of nodes it finds and the number of attributes.
NOTE: Hidden nodes are not counted
Definition at line 5999 of file node.cpp. 06000 { 06001 UINT32 ChildCount = 0; 06002 UINT32 ChildAttrCount = 0; 06003 06004 Node* pNode = FindFirstChild(); 06005 while (pNode != NULL) 06006 { 06007 if (!pNode->IsNodeHidden()) 06008 { 06009 ChildCount++; 06010 if (pNode->IsAnAttribute()) 06011 ChildAttrCount++; 06012 } 06013 pNode = pNode->FindNext(); 06014 } 06015 06016 if (pChildCount != NULL) 06017 *pChildCount = ChildCount; 06018 06019 if (pChildAttrCount != NULL) 06020 *pChildAttrCount = ChildAttrCount; 06021 }
|
|
|
Decrements the count of the number of NodeHidden nodes which reffer to the node. This routine should only be called from the NodeHidden methods.
Definition at line 4668 of file node.cpp. 04669 { 04670 ENSURE((HiddenRefCnt != 0), "Trying to decrement a zero Hidden Node refference count"); 04671 HiddenRefCnt--; 04672 }
|
|
|
Deletes the children and all the children's children etc. starting from FirstChild.
NodeHidden nodes (ShowNodeActions point at them) Nodes with a HiddenCnt not equal to 0 - HiddenNodes point at them
Definition at line 1027 of file node.cpp. 01028 { 01029 Node* CurrentNode = FirstChild; 01030 01031 if (ShowHourglass()) 01032 { 01033 ContinueSlowJob(); 01034 } 01035 01036 BaseDocument *pOwnerDoc = NULL; 01037 01038 if (FirstChild != NULL) 01039 FirstChild->FindOwnerDoc(); 01040 01041 while (CurrentNode != NULL) // While there are children left to process 01042 { 01043 Node* NextNode = CurrentNode->Next; 01044 // It is not the job of DeleteChildren to delete HiddenNodes or nodes pointed to by hidden nodes 01045 // They should be considered to be in the OperationHistory 01046 if ( (!CurrentNode->IsNodeHidden()) && (CurrentNode->GetHiddenCnt() == 0) ) 01047 { 01048 if (CurrentNode->Child != NULL) // There are children to delete 01049 DeleteChildren(CurrentNode->Child); 01050 01051 // Unlink from tree before deleting it 01052 CurrentNode->UnlinkNodeFromTree(pOwnerDoc); // Nice and safe !!!! 01053 01054 delete CurrentNode; // Current node has no children so can be deleted 01055 } 01056 else 01057 CurrentNode->UnlinkNodeFromTree(pOwnerDoc); 01058 01059 CurrentNode = NextNode; // Process next sibling 01060 01061 if (ShowHourglass()) 01062 { 01063 ContinueSlowJob(); 01064 } 01065 01066 } //end while 01067 Child = NULL; 01068 }
|
|
||||||||||||
|
To return a description of the Node object in either the singular or the plural. This method is called by the DescribeRange method.
Reimplemented in Chapter, NodeGrid, NodeGridRect, NodeGridIso, NodeGroup, NodeGuideline, Layer, NodeContourController, NodeClipViewController, NodeMouldGroup, NodeMouldBitmap, NodeAnimatingBitmap, NodeBevel, NodeBlend, NodeBitmap, NodeBrush, NodeClipView, NodeContour, NodeEllipse, NodeLiveEffect, NodeLockedEffect, NodeFeatherEffect, NodeMoulder, NodeMould, NodePath, NodeRect, NodeRegularShape, AbstractTextChar, CaretNode, EOLNode, TextLine, TextStory, Page, and Spread. Definition at line 560 of file node.cpp. 00561 { 00562 ENSURE (FALSE,"The illegal function Node::Describe was called\n"); 00563 00564 return( _T("") ); // Just to keep the compiler happy 00565 };
|
|
|
To deselect all selected nodes below this node. This function also ensures that the SelectedChildren flags are cleared properly. It is self-recursive! Helper function for SetSelected Scope: Private.
Definition at line 2992 of file node.cpp. 02993 { 02994 ERROR2IF(this==NULL,FALSE,"DeSelectSubtree called on NULL node."); // Precondition 02995 02996 Node* pNode = Child; 02997 while (pNode) 02998 { 02999 pNode->Flags.Selected = FALSE; // Deselect this node directly 03000 03001 if (pNode->Flags.SelectedChildren) // If this node has selected children 03002 { 03003 pNode->DeSelectSubtree(); // Then deselect anything in its subtree 03004 } 03005 03006 pNode->Flags.SelectedChildren = FALSE; // Flag that this node no longer has sel children 03007 pNode = pNode->Next; 03008 } 03009 03010 return TRUE; 03011 }
|
|
|
This virtual was added because we need to know about nodes which can discard their child attributes, an example is the CaretNode. If an attribute gets applied to such a node then no undo info can be generated.
Apply attribute to caret generating undo Move caret, so deleting all initial attrs undo The undo tries to find the applied attribute so that it can hide it, but it does not exist anymore (BANG!) This base class function returns FALSE Notes: Phil, 24/09/2005 The usage of this function has changed subtly today. It used to prevent both attribute optimisation and undo recording on Caret nodes. As of today it just prevents undo recording - attribute optimisation goes ahead like normal on Caret nodes so that they behave more consistently. Reimplemented in CaretNode. Definition at line 2774 of file node.cpp. 02775 { 02776 return (FALSE); 02777 }
|
|
|
Actually tries to change the node into a different node type.
Reimplemented in AttrBevelType, NodeContourController, NodeBlendPath, NodeClipViewController, NodeBevel, NodeBlender, NodeBlend, NodeBitmap, NodeContour, NodeCompound, NodeBitmapEffect, NodeMoulder, NodeMould, NodePath, NodeRegularShape, NodeSimpleShape, and TextStory. Definition at line 5555 of file node.cpp. 05556 { 05557 // Always return TRUE so that this routine won't upset the caller. 05558 // Even though the CanBecomeA() function returns FALSE, this does NOT guarantee that DoBecomeA() 05559 // won't get called. 05560 05561 // E.g. Group::CanBecomeA() will return TRUE if ANY of its children return TRUE from their 05562 // CanBecomeA() virt func. When Group::DoBecomeA() is called, all the children's 05563 // DoBecomeA() funcs are called, so if they returned FALSE by default, the op will be aborted (this is bad). 05564 05565 return TRUE; 05566 }
|
|
|
To find the first node in a depth first traversal of the document tree.
Definition at line 3514 of file node.cpp. 03515 { 03516 // Make sure we have a document to search. 03517 ERROR2IF(pDocToSearch == NULL, NULL, "No document to search in DocFindFirstDepthFirst()"); 03518 03519 // Get the first node! 03520 return pDocToSearch->GetFirstNode(); 03521 }
|
|
|
To find the next node in the depth first traversal of the current document tree.
Definition at line 3545 of file node.cpp. 03546 { 03547 Node* CurrentNode = this; 03548 03549 if (CurrentNode->Next != NULL) 03550 { 03551 CurrentNode = CurrentNode->Next; 03552 03553 // Find leftmost child node 03554 while(CurrentNode->Child != NULL) 03555 CurrentNode = CurrentNode->Child; 03556 03557 return (CurrentNode); 03558 03559 } 03560 else 03561 return (CurrentNode->Parent); 03562 }
|
|
|
Find out what bitmaps, if any, are used by this node.
This function supports nodes that use more than one bitmap - you call this function repeatedly and keep incrementing the Count parameter that you pass in each time by 1. You should stop calling it when it returns NULL, as this indicates that no more bitmaps are used by this node. Count should start off as 0 for the first call. Note that this function can (and often will) return NULL for the first call, as many nodes don't use bitmaps, obviously.
Reimplemented in AttrBitmapFill, Layer, NodeAnimatingBitmap, NodeBitmap, and NodeLockedEffect. Definition at line 2804 of file node.cpp. 02805 { 02806 return NULL; 02807 }
|
|
|
Reimplemented in NodeBevel, NodeBlender, NodeBlend, NodeContour, NodeCompound, NodePath, and NodeRegularShape. Definition at line 455 of file node.h.
|
|
|
Perform special export rendering of an object, if it is different to the way the object would be rendered normally (e.g. graduated fill attributes, and so on). By default, the base class function returns FALSE, so by default all objects will be exported by calling the Render() function unless they override this function.
Reimplemented in NodeGroup, NodeGuideline, NodeRenderableInk, Layer, NodeContourController, NodeBlendPath, NodeClipViewController, NodeMouldGroup, NodeMouldPath, NodeBevel, NodeBevelBegin, NodeBlender, NodeBlend, NodeBitmap, NodeMoulder, NodeMould, NodeRegularShape, TextChar, KernCode, HorizontalTab, CaretNode, EOLNode, and TextStory. Definition at line 495 of file node.cpp. 00496 { 00497 // By default, use normal rendering when exporting. 00498 return FALSE; 00499 }
|
|
|
Perform an Extend operation on this Node, and its children if appropriate. Default implementation just calls Extend() on its children.
Reimplemented in AttrFillGeometry, AttrBitmapFill, NodeContourController, NodeMouldGroup, NodeHidden, NodeBevel, NodeBlend, NodeContour, NodeMould, NodePath, NodeRegularShape, NodeSimpleShape, and TextStory. Definition at line 6356 of file node.cpp. 06357 { 06358 for ( Node* pChildNode = FindFirstChild(); 06359 pChildNode != NULL; 06360 pChildNode = pChildNode->FindNext() ) 06361 { 06362 pChildNode->Extend(ExtParams); 06363 } 06364 }
|
|
||||||||||||||||||||
|
Find the first child of this node that needs rendering. This follows the children (assuming they intersect with the clipping rectangle), and finds (via a depth first search) the first child that should be rendered according to our rules. The node should be either:.
All other nodes (e.g. NodeHidden) are not rendered.
Definition at line 3945 of file node.cpp. 03947 { 03948 ENSURE(this != NULL, "FindChildToRender called on NULL pointer"); 03949 03950 Node *pNode = this; 03951 03952 SubtreeRenderState state = pNode->RenderSubtree(pRender); 03953 if (state!=SUBTREE_ROOTANDCHILDREN && !pNode->IsAnAttribute()) 03954 { 03955 pRender->SaveContext(); 03956 return pNode; 03957 } 03958 03959 // If this node has any children, save the context first. 03960 Node *pChild = pNode->Child; 03961 03962 if (pChild != NULL) 03963 pRender->SaveContext(); 03964 03965 do 03966 { 03967 if (pChild != NULL) 03968 { 03969 // Should it be rendered? 03970 if (pChild->NeedsToRender(pRender)) //(Flags.Required) 03971 { 03972 // See if this node has any suitable children to render. 03973 Node *pChildToRender = pChild->FindChildToRender(pClipRect, pRender, ExcludeLockedLayers); 03974 03975 if (pChildToRender != NULL) 03976 // This child has a child of its own to render so return it. 03977 return pChildToRender; 03978 else 03979 // This child has no children to render, so just render this child. 03980 return pChild; 03981 } 03982 03983 } 03984 else 03985 // This node has no children. 03986 return NULL; 03987 03988 // No luck - try the next child. 03989 pChild = pChild->Next; 03990 03991 } while (pChild != NULL);// && pChild != pStopNode ); 03992 03993 // No child nodes found to render 03994 ENSURE(pRender != NULL, "NULL Render region found !!"); 03995 return NULL; 03996 }
|
|
|
Find the first child of this node that needs rendering. This follows the children (assuming they intersect with the clipping rectangle), and finds (via a depth first search) the first child that should be rendered according to our rules. The node should be either:.
All other nodes (e.g. NodeHidden) are not rendered. Hidden layers are bypassed. Definition at line 4157 of file node.cpp. 04158 { 04159 ENSURE(this != NULL, "FindChildToRenderUnclipped called on NULL pointer"); 04160 04161 Node *pNode = this; 04162 04163 // INT32 DoFindChildren = PRE_RENDER_CHILDREN; 04164 04165 SubtreeRenderState state = pNode->RenderSubtree(pRender, NULL, FALSE); // Don't clip! 04166 if (state!=SUBTREE_ROOTANDCHILDREN && !pNode->IsAnAttribute()) 04167 { 04168 pRender->SaveContext(); 04169 return pNode; 04170 } 04171 04172 // If this node has any children, save the context first. 04173 Node *pChild = pNode->Child; 04174 04175 if (pChild != NULL) 04176 { 04177 pRender->SaveContext(); 04178 } 04179 04180 do 04181 { 04182 if (pChild != NULL) 04183 { 04184 // Should it be rendered? 04185 BOOL NeedsToRender = pChild->ShouldBeRendered(); 04186 04187 // Special case for layers - don't do hidden layers! 04188 if (pChild->IsLayer()) 04189 { 04190 NeedsToRender = pChild->NeedsToRender(pRender); // Clipped! 04191 } 04192 04193 if (NeedsToRender) 04194 { 04195 // See if this node has any suitable children to render. 04196 Node *pChildToRender = pChild->FindChildToRenderUnclipped(pRender); 04197 04198 if (pChildToRender != NULL) 04199 // This child has a child of its own to render so return it. 04200 return pChildToRender; 04201 else 04202 // This child has no children to render, so just render this child. 04203 return pChild; 04204 } 04205 } 04206 else 04207 // This node has no children. 04208 return NULL; 04209 04210 // No luck - try the next child. 04211 pChild = pChild->Next; 04212 04213 } while (pChild != NULL); 04214 04215 // No child nodes found to render 04216 ENSURE(pRender != NULL, "NULL Render region found !!"); 04217 return NULL; 04218 }
|
|
||||||||||||
|
For finding the enclosing chapter of a node, the position of the start of the enclosing chapter, and the chapters depth.
Definition at line 4341 of file node.cpp. 04342 { 04343 Node* CurrentNode = this; 04344 while (CurrentNode != NULL) 04345 { 04346 if (CurrentNode->IsChapter()) 04347 { 04348 // We have found the enclosing chapter 04349 Chapter* EnclosingChapter = (Chapter*)CurrentNode; 04350 04351 // Chapter position is the top left hand corner of the chapters pasteboard 04352 ChapterPos->x = (EnclosingChapter->GetPasteboardRect().LowCorner().x); 04353 ChapterPos->y = (EnclosingChapter->GetPasteboardRect().HighCorner().y); 04354 04355 // Calculate the ChapterDepth 04356 *ChapterDepth = 0; 04357 BaseDocument *pOwnerDoc = EnclosingChapter->FindOwnerDoc(); 04358 Chapter* CurrentChapter = Node::FindFirstChapter(pOwnerDoc); 04359 04360 while (CurrentChapter != EnclosingChapter) 04361 { 04362 ENSURE(CurrentChapter != NULL, ")CurrentChapter=NULL"); // This should always be true 04363 (*ChapterDepth) += CurrentChapter->GetPasteboardRect().Height(); 04364 CurrentChapter = CurrentChapter->FindNextChapter(); 04365 } 04366 return (EnclosingChapter); 04367 } 04368 else 04369 CurrentNode = CurrentNode->FindParent(); 04370 } 04371 ENSURE(FALSE,"Trying to find the enclosing chapter\nof a node which has no enclosing chapter"); 04372 return (NULL); 04373 }
|
|
|
Definition at line 6268 of file node.cpp. 06269 { 06270 // Begin searching from the last child of pInk, or if there isn't one, from pInk itself. 06271 const Node* pNode = FindLastChild(); 06272 if (pNode == 0) pNode = this; 06273 06274 // Search for the class in the previous sibling nodes, then the parent's siblings, 06275 // then the parent siblings of the parent of ... etc. 06276 while (!(pNode->*pfnTest)()) 06277 { 06278 // Work out the next node in the search order. 06279 if (pNode->FindPrevious() != 0) 06280 { 06281 // The next node is the previous sibling. 06282 pNode = pNode->FindPrevious(); 06283 } 06284 else 06285 { 06286 // The next node is the parent, if there is one. 06287 pNode = pNode->FindParent(); 06288 if (pNode == 0) break; 06289 } 06290 } 06291 06292 // Return the attribute, or null if none was found. 06293 return (NodeAttribute*) pNode; 06294 }
|
|
|
To find the first chapter in the document tree.
Definition at line 3775 of file node.cpp. 03776 { 03777 // Sanity check 03778 ERROR2IF(pDocToSearch == NULL, NULL, "NULL document in FindFirstChapter()"); 03779 03780 // Make sure that the document is not toast 03781 ERROR3IF(!pDocToSearch->GetFirstNode()->FindNext()->IsKindOf(CC_RUNTIME_CLASS(NodeDocument)), 03782 "A NodeDocument node was not found at the root of the document tree"); 03783 03784 // Get the start node 03785 Node* StartChapterList = pDocToSearch->GetFirstNode()->FindNext()->FindFirstChild(); 03786 if (StartChapterList == NULL) 03787 return NULL; 03788 else 03789 { 03790 if (StartChapterList->IsChapter()) 03791 return ((Chapter*) StartChapterList); 03792 else 03793 return(StartChapterList->FindNextChapter()); 03794 } 03795 }
|
|
|
Find first child of specified type.
Definition at line 3209 of file node.cpp. 03210 { 03211 Node* pNode = FindFirstChild(); 03212 while (pNode) 03213 { 03214 if (pNode->IsKindOf(Class)) 03215 return pNode; 03216 pNode = pNode->FindNext(); 03217 } 03218 return NULL; 03219 }
|
|
|
For finding the first child of a node.
Definition at line 1141 of file node.h. 01142 { 01143 return(Child); 01144 }
|
|
|
Find the first child ink-node. Notes: Analogous to FindFirstChild(CC_RUNTIME_CLASS(NodeRenderableInk)), just faster and neater.
Definition at line 3299 of file node.cpp. 03300 { 03301 Node* pInk = FindFirstChild(); 03302 while (pInk != NULL && !pInk->IsAnObject()) 03303 pInk = pInk->FindNext(); 03304 03305 return (NodeRenderableInk*)pInk; 03306 }
|
|
|
To find the first node in a depth first traversal of this subtree.
Definition at line 3587 of file node.cpp. 03588 { 03589 // Find the leftmost child node 03590 Node* Current = this; 03591 while (Current->FindFirstChild() != NULL) 03592 { 03593 Current = Current->FindFirstChild(); 03594 } 03595 return (Current); 03596 }
|
|
||||||||||||||||||||
|
To traverse the document tree depth first to find the first NodeRenderableInk or NodeAttribute node which needs to be rendered, i.e. in the case of a NodeRenderableInk node its bounding rectangle intersects with the current clipping rectangle (and it's not on a hidden layer).
Definition at line 3909 of file node.cpp. 03913 { 03914 ENSURE(pRender != NULL, "Render region NULL in FindFirstForClippedInkRender"); 03915 ENSURE( IsKindOf(CC_RUNTIME_CLASS(Spread)), "Oh No, that's not a spread in FindFirstForClippedInkRender" ); 03916 // Let FindNextForClippedInkRender do all the work 03917 return FindNextForClippedInkRender(pClipRect, pRender, ExcludeLockedLayers, pStopNode); 03918 }
|
|
|
To traverse the document tree depth first to find the first NodeRenderableInk or NodeAttribute node which needs to be rendered, regardless of the clip rectangle of the render region (and it's not on a hidden layer).
Definition at line 4127 of file node.cpp. 04128 { 04129 ENSURE(pRender != NULL, "Render region NULL in FindFirstForUnclippedInkRender"); 04130 ENSURE( IsKindOf(CC_RUNTIME_CLASS(Spread)), "Oh No, that's not a spread in FindFirstForUnclippedInkRender" ); 04131 // Let FindNextForUnclippedInkRender do all the work 04132 return FindNextForUnclippedInkRender(pRender); 04133 }
|
|
|
Definition at line 4423 of file node.cpp. 04424 { 04425 Node* pCurr = FindFirstChild(); 04426 while(pCurr) 04427 { 04428 if(pCurr->IsAnAttribute()) 04429 if(((NodeAttribute*)pCurr)->IsLinkedToNodeGeometry()) 04430 return (NodeAttribute*) pCurr; 04431 04432 pCurr = pCurr->FindNext(); 04433 } 04434 04435 return NULL; 04436 }
|
|
|
Definition at line 3664 of file node.cpp.
|
|
|
Find last child of specified type.
Definition at line 3232 of file node.cpp. 03233 { 03234 Node* pNode = FindFirstChild(); 03235 Node* pNodeOfGivenClass = NULL; 03236 while (pNode) 03237 { 03238 if (pNode->IsKindOf(Class)) 03239 pNodeOfGivenClass = pNode; 03240 pNode = pNode->FindNext(); 03241 } 03242 return pNodeOfGivenClass; 03243 }
|
|
|
This function will return TRUE when called on NodeRenderableBounded nodes and those derived from it. This is the base class version that returns FALSE For finding a node's last child.
Definition at line 3088 of file node.cpp. 03089 { 03090 Node* n = Child; // First child 03091 if (n != NULL) 03092 { 03093 while ((n->Next) != NULL) 03094 n = n->Next; 03095 03096 if ((ExcludeInsertionNode) && (IS_A(n, InsertionNode))) 03097 { 03098 n = n->Previous; 03099 } 03100 } 03101 return(n); 03102 }
|
|
|
Find the last child ink-node. Notes: Analogous to FindLastChild(CC_RUNTIME_CLASS(NodeRenderableInk)), just faster and neater.
Definition at line 3320 of file node.cpp. 03321 { 03322 Node* pInk = FindLastChild(); 03323 while (pInk != NULL && !pInk->IsAnObject()) 03324 pInk = pInk->FindPrevious(); 03325 03326 return (NodeRenderableInk*)pInk; 03327 }
|
|
|
This function follows the node's next links until it finds a node derived from Class. NULL is returned if no node is found.
Definition at line 3155 of file node.cpp. 03156 { 03157 Node* Current = this->FindNext(); 03158 while (Current != NULL) 03159 { 03160 if (Current->IsKindOf(Class)) 03161 { 03162 return Current; 03163 } 03164 Current = Current->FindNext(); 03165 } 03166 return NULL; 03167 }
|
|
|
For finding the next sibling of a node.
Definition at line 1089 of file node.h. 01090 { 01091 return(Next); 01092 }
|
|
|
To find the next chapter in the document tree.
Definition at line 3813 of file node.cpp. 03814 { 03815 const Node* CurrentNode = this->FindNext(); 03816 03817 while (CurrentNode != NULL) 03818 { 03819 if (CurrentNode->IsChapter()) 03820 return ((Chapter*)CurrentNode); 03821 CurrentNode = CurrentNode->FindNext(); 03822 } 03823 03824 return (NULL); // No chapter found 03825 }
|
|
|
To find the next node in the depth first traversal of the subtree.
Definition at line 3621 of file node.cpp. 03622 { 03623 if (this != Subtree) // There are more nodes in the subtree 03624 { 03625 Node* CurrentNode = this; 03626 03627 if (CurrentNode->Next != NULL) // Has this node got any siblings 03628 { 03629 CurrentNode = CurrentNode->Next; 03630 03631 // Find leftmost child node 03632 while(CurrentNode->Child != NULL) 03633 { 03634 CurrentNode = CurrentNode->Child; 03635 } 03636 03637 return (CurrentNode); 03638 } 03639 else 03640 { 03641 return (CurrentNode->Parent); 03642 } 03643 } 03644 return (NULL); 03645 }
|
|
||||||||||||||||||||
|
To traverse the document tree depth first to find the next NodeRenderableInk or NodeAttribute node which needs to be rendered, i.e. in the case of a NodeRenderableInk its bounding rectangle intersects with the current clipping rectangle.
Definition at line 4032 of file node.cpp. 04036 { 04037 ENSURE(pRender != NULL, "Render region NULL in FindNextForClippedInkRender"); 04038 Node* pNode = this; 04039 BOOL IsSpread = pNode->IsSpread(); 04040 04041 do 04042 { 04043 // If this node (which has been rendered) has any children, then those children have 04044 // also been rendered, but they have just gone out of scope, so restore the attribute 04045 // context. 04046 if (!IsSpread && (pNode->Child != NULL)) 04047 { 04048 pRender->RestoreContext(); 04049 } 04050 04051 04052 // If this Node is non-NULL 04053 while (IsSpread || (pNode->Next != NULL)) 04054 { 04055 // If this node is not a spread, move to the next sibling. 04056 if (!IsSpread) 04057 pNode = pNode->Next; 04058 04059 if (IsSpread || pNode->NeedsToRender(pRender)) //Flags.Required) 04060 { 04061 // Follow the child links (saving the context as we go) to the deepest child 04062 // of this node, and then return this node for rendering. 04063 // NB. If no children, then this code just returns the current node to render. 04064 Node *pChild = pNode->FindChildToRender(pClipRect, pRender, ExcludeLockedLayers, pStopNode); 04065 04066 if (pChild != NULL) 04067 return pChild; 04068 else if (!IsSpread) 04069 return pNode; 04070 else 04071 // Spread has nothing at all to render 04072 return NULL; 04073 } 04074 04075 // Definitely not rendering a spread anymore 04076 IsSpread = FALSE; 04077 ENSURE(!pNode->IsKindOf(CC_RUNTIME_CLASS(Spread)), 04078 "Node should not be a spread!"); 04079 } 04080 04081 // No siblings left to render (i.e. that intersect the clipping rectangle), so 04082 // return to the parent. 04083 pNode = pNode->Parent; 04084 04085 ENSURE(pNode != NULL, "NULL parent found in FindNextForClippedInkRender"); 04086 04087 // If the parent is NodeRenderableInk or a NodeAttribute (ie renderable), then return it. 04088 if (pNode->IsAnObject() || pNode->IsAnAttribute()) 04089 // We want to render this node. 04090 return pNode; 04091 04092 } while (!pNode->IsSpread()); 04093 04094 // We found no more renderable nodes in this spread, so stop looking. 04095 // If the spread had any children, then FindChildToRender would have called 04096 // SaveContext(), so we call RestoreContext() to balance it. 04097 if (pNode->Child != NULL) 04098 pRender->RestoreContext(); 04099 04100 // All done. 04101 return NULL; 04102 }
|
|
|
To traverse the document tree to find the next paper renderable node which needs to be rendered, i.e. its pasteboard rectangle intersects with the current clipping rectangle.
Definition at line 3851 of file node.cpp. 03852 { 03853 Node *pNode = this; 03854 03855 // If the node is a spread, then search its children for a paper object 03856 if (pNode->IsSpread()) 03857 { 03858 pNode = pNode->FindFirstChild(); 03859 if (pNode->IsPaper()) 03860 return (NodeRenderablePaper *) pNode; // Found a paper object 03861 } 03862 03863 // Search this node's siblings for another paper object 03864 do 03865 { 03866 pNode = pNode->FindNext(); 03867 } 03868 while ((pNode != NULL) && !pNode->IsPaper()); 03869 03870 // Return pointer to next page, or NULL if no more paper objects left to render. 03871 return ((NodeRenderablePaper *) pNode); 03872 }
|
|
|
To traverse the document tree depth first to find the next NodeRenderableInk or NodeAttribute node which needs to be rendered, ignoring the clipping rectangle of the clip region. (i.e. all renderable nodes except those on hidden layers).
Definition at line 4242 of file node.cpp. 04243 { 04244 ENSURE(pRender != NULL, "Render region NULL in FindNextForUnclippedInkRender"); 04245 Node* pNode = this; 04246 04247 BOOL IsSpread = pNode->IsSpread(); 04248 04249 do 04250 { 04251 // If this node (which has been rendered) has any children, then those children have 04252 // also been rendered, but they have just gone out of scope, so restore the attribute 04253 // context. 04254 if (!IsSpread && (pNode->Child != NULL)) 04255 pRender->RestoreContext(); 04256 04257 // If this Node is non-NULL 04258 while (IsSpread || (pNode->Next != NULL)) 04259 { 04260 // If this node is not a spread, move to the next sibling. 04261 if (!IsSpread) 04262 pNode = pNode->Next; 04263 04264 // Should it be rendered? 04265 BOOL NeedsToRender = IsSpread || pNode->ShouldBeRendered(); 04266 04267 // Special case for layers - don't do hidden layers! 04268 if (pNode->IsLayer()) 04269 NeedsToRender = pNode->NeedsToRender(pRender); // Clipped!!! 04270 04271 if (NeedsToRender) 04272 { 04273 // Follow the child links (saving the context as we go) to the deepest child 04274 // of this node, and then return this node for rendering. 04275 // NB. If no children, then this code just returns the current node to render. 04276 Node *pChild = pNode->FindChildToRenderUnclipped(pRender); 04277 04278 if (pChild != NULL) 04279 return pChild; 04280 else if (!IsSpread) 04281 return pNode; 04282 else 04283 // Spread has nothing at all to render 04284 return NULL; 04285 } 04286 04287 // Definitely not rendering a spread anymore 04288 IsSpread = FALSE; 04289 ENSURE(!pNode->IsKindOf(CC_RUNTIME_CLASS(Spread)), 04290 "Node should not be a spread!"); 04291 } 04292 04293 // No siblings left to render (i.e. that intersect the clipping rectangle), so 04294 // return to the parent. 04295 pNode = pNode->Parent; 04296 04297 ENSURE(pNode != NULL, "NULL parent found in FindNextForClippedInkRender"); 04298 04299 // If the parent is NodeRenderableInk or a NodeAttribute (ie renderable), then return it. 04300 if (pNode->IsAnObject() || pNode->IsAnAttribute()) 04301 // We want to render this node. 04302 return pNode; 04303 04304 } while (!pNode->IsSpread()); 04305 04306 // We found no more renderable nodes in this spread, so stop looking. 04307 // If the spread had any children, then FindChildToRender would have called 04308 // SaveContext(), so we call RestoreContext() to balance it. 04309 if (pNode->Child != NULL) 04310 pRender->RestoreContext(); 04311 04312 // All done. 04313 return NULL; 04314 }
|
|
|
Definition at line 4449 of file node.cpp. 04450 { 04451 Node* pCurr = FindNext(); 04452 while(pCurr) 04453 { 04454 if(pCurr->IsAnAttribute()) 04455 if(((NodeAttribute*)pCurr)->IsLinkedToNodeGeometry()) 04456 return (NodeAttribute*) pCurr; 04457 04458 pCurr = pCurr->FindNext(); 04459 } 04460 04461 return NULL; 04462 }
|
|
|
Find the next ink node. Notes: Analogous to FindNext(CC_RUNTIME_CLASS(NodeRenderableInk)), just faster and neater.
Definition at line 3257 of file node.cpp. 03258 { 03259 Node* pInk = FindNext(); 03260 while (pInk != NULL && !pInk->IsAnObject()) 03261 pInk = pInk->FindNext(); 03262 03263 return (NodeRenderableInk*)pInk; 03264 }
|
|
|
For finding the next sibling of a node (ignoring all NodeHidden nodes).
Definition at line 3441 of file node.cpp. 03442 { 03443 Node* Current = Next; 03444 if (Current != NULL) 03445 { 03446 while (Current->IsNodeHidden()) 03447 { 03448 Current = Current->Next; 03449 if (Current == NULL) break; 03450 } 03451 } 03452 return (Current); 03453 }
|
|
||||||||||||
|
Definition at line 3686 of file node.cpp. 03687 { 03688 Node* pNode = this; 03689 03690 // We have visited this, so visit its children, then visit siblings and finally parents siblings 03691 if (pNode->FindFirstChild() && !bSkipSubtree) 03692 return pNode->FindFirstChild(); 03693 03694 if (pNode==pRoot) 03695 return NULL; 03696 03697 if (pNode->FindNext()) 03698 return pNode->FindNext(); 03699 03700 do 03701 { 03702 pNode = pNode->FindParent(); 03703 if (pNode==NULL || pNode==pRoot) 03704 return NULL; 03705 } 03706 while (pNode->FindNext()==NULL); 03707 03708 return pNode->FindNext(); 03709 }
|
|
|
Find out which document this node is in. This is used to maintain an accurate node count for each document.
Definition at line 3343 of file node.cpp. 03344 { 03345 // Find the document this node is attached to - go up the tree until we reach the 03346 // NodeDocument object or we run out of parents (i.e. it's an orphan sub-tree waiting to 03347 // go into a document. 03348 const Node *pNode = this; 03349 while ((pNode != NULL) && (!pNode->IsNodeDocument())) 03350 pNode = pNode->FindParent(); 03351 03352 if (pNode != NULL) 03353 return ((NodeDocument *) pNode)->GetParentDoc(); 03354 else 03355 return NULL; 03356 }
|
|
|
This function follows the node's parent links until it finds a node of class ParentClass. If no such node is found then an ENSURE will occur.
Definition at line 3123 of file node.cpp. 03124 { 03125 Node* Current = this->FindParent(); 03126 while (Current != NULL) 03127 { 03128 if (Current->GetRuntimeClass() == ParentClass) 03129 { 03130 return Current; 03131 } 03132 Current = Current->FindParent(); // Get the next parent 03133 } 03134 //ENSURE(FALSE, "Could not find parent of correct type"); 03135 return NULL; 03136 }
|
|
|
For finding the parent of a node.
Definition at line 1124 of file node.h. 01125 { 01126 return(Parent); 01127 }
|
|
|
To find the node at the normal selection surface from one of its selected-inside children. Note that this routine can be used to test whether a node is "selected-inside" or not by testing whether the Node* returned is NULL or not. (NULL means not selected-inside.).
Definition at line 4394 of file node.cpp. 04395 { 04396 ERROR2IF(this==NULL,NULL,"FindParentOfSelected called on NULL node."); 04397 04398 Node* pParentOf = NULL; 04399 Node* pParent = Parent; 04400 while ( pParent!=NULL && !pParent->IsLayer() ) 04401 { 04402 pParentOf = pParent; // Record last parent before we reached the Layer 04403 pParent = pParent->Parent; // Find it's parent. 04404 } 04405 ERROR3IF(pParent==NULL,"Node doesn't seem to be in a layer!"); 04406 04407 return pParentOf; 04408 }
|
|
|
Find the spread node to which this node is ultimately attached.
Definition at line 3726 of file node.cpp. 03727 { 03728 ERROR2IF(this==NULL, NULL, "NULL node in Node::FindParentSpread"); 03729 ENSURE(!IsKindOf(CC_RUNTIME_CLASS(Spread)), "A spread cannot contain a spread"); 03730 03731 Node *pNode = this; 03732 03733 // Search up the tree for the parent spread 03734 while ((pNode != NULL) && !pNode->IsSpread()) 03735 pNode = pNode->Parent; 03736 03737 ENSURE(pNode != NULL, "No parent spread found in Node::FindParentSpread"); 03738 03739 return (Spread *) pNode; 03740 }
|
|
|
This function follows the node's Previous links until it finds a node derived from Class. NULL is returned if no node is found.
Definition at line 3185 of file node.cpp. 03186 { 03187 Node* Current = this->FindPrevious(); 03188 while (Current != NULL) 03189 { 03190 if (Current->IsKindOf(Class)) 03191 { 03192 return Current; 03193 } 03194 Current = Current->FindPrevious(); 03195 } 03196 return NULL; 03197 }
|
|
|
For finding the previous sibling of a node.
Definition at line 1107 of file node.h. 01108 { 01109 return(Previous); 01110 }
|
|
|
Find the previous ink node. Notes: Analogous to FindPrevious(CC_RUNTIME_CLASS(NodeRenderableInk)), just faster and neater.
Definition at line 3278 of file node.cpp. 03279 { 03280 Node* pInk = FindPrevious(); 03281 while (pInk != NULL && !pInk->IsAnObject()) 03282 pInk = pInk->FindPrevious(); 03283 03284 return (NodeRenderableInk*)pInk; 03285 }
|
|
|
For finding the previous sibling of a node (ignoring all NodeHidden nodes).
Definition at line 3474 of file node.cpp. 03475 { 03476 Node* Current = Previous; 03477 if (Current != NULL) 03478 { 03479 while (Current->IsNodeHidden()) 03480 { 03481 Current = Current->Previous; 03482 if (Current == NULL) break; 03483 } 03484 } 03485 return (Current); 03486 }
|
|
|
This function returns a type describing how this object is to be copied. The fuction is called from the low level copy operation CopyObjects. There are two options at present, these being SIMPLECOPY and COMPLEXCOPY. SIMPLECOPY indicates that the node can be copied by a call to its virtual function SimpleCopy() followed by a deep copy of all its children. COMPLEXCOPY however indicates that the node needs to do its own thing when copying and must be called via the ComplexCopy() virtual function. This virtual will likely return a tree of copied objects rather than just a copy of itself.
Reimplemented in NodeBlendPath, NodeMouldPath, VisibleTextNode, and TextLine. Definition at line 1689 of file node.cpp. 01690 { 01691 return SIMPLECOPY; 01692 }
|
|
|
Reimplemented in NodeBitmap. Definition at line 544 of file node.h. 00544 {return NULL;}
|
|
|
Reimplemented in AttrBitmapFill, and NodeBitmap. Definition at line 538 of file node.h.
|
|
|
For finding out how many hidden nodes reffer to the node.
Definition at line 4689 of file node.cpp. 04690 { 04691 return (HiddenRefCnt); 04692 }
|
|
|
|
Use this to access the node's permission flags to find out if the current op is doable to this node.
Range uses this value to decide whether a node is in the range. A node is not in the range is its permission value is PERMISSION_DENIED, otherwise it is in the range (RangeControlFlags permitting that is) This state should be set via the AllowOp() function, using the most appropriate out of Node and Range's varients.
Definition at line 5003 of file node.cpp. 05004 { 05005 if (!Flags.OpPermission1) 05006 { 05007 if (!Flags.OpPermission2) 05008 return PERMISSION_DENIED; 05009 else 05010 return PERMISSION_ALLOWED; 05011 } 05012 else 05013 return PERMISSION_UNDEFINED; 05014 }
|
|
|
Reimplemented in NodeBevel, NodeBlend, NodeContour, and NodeCompound. Definition at line 653 of file node.h. 00653 {return NULL;} // Implement if your node was created by a PostProcessor of some sort
|
|
|
For finding the size of this subtree.
Definition at line 1995 of file node.cpp. 01996 { 01997 UINT32 Total = 0; 01998 Node* Current = this->FindFirstDepthFirst(); 01999 while (Current != NULL) 02000 { 02001 Total += Current->GetNodeSize(); 02002 Current = Current->FindNextDepthFirst(this); 02003 } 02004 return Total; 02005 }
|
|
|
For finding a nodes TAG, which is a unique identifier for each node stored within a document.
Definition at line 886 of file node.h. 00887 { 00888 return Tag; 00889 }
|
|
||||||||||||
|
This function allows compound objects to provide editable children. It also allows tools to ask an object what other nodes form part of its editable surface if the node itself cannot be editable. This allows complex objects such as moulds and text objects, who have a single parent above many objects (some of which are editable), to provide a way for tools to get at them. A tool scanning the selection may be looking to edit certain objects. If a selected object it comes accross is not of the correct type, the tool can also ask it whether it contains any editable objects of type(ChildClass). If the node overrides this virtual function it can provide a strangly shapes editable surface. Note, do not confuse this with select inside, where objects have been explicitly selected by the user. In that case the parent would never be asked for editable children as it does not form part of the selection under a select inside action.
Reimplemented in NodeBlend, NodeBrush, and NodeMould. Definition at line 2843 of file node.cpp. 02844 { 02845 return NULL; 02846 }
|
|
|
To find out whether a node has got selected children or children that themselves have selected children... Helper function for SetSelected Scope: Private.
Definition at line 3033 of file node.cpp. 03034 { 03035 ERROR2IF(this==NULL,FALSE,"HasSelectedChildren called on NULL node."); // Precondition 03036 03037 // BOOL has = FALSE; 03038 Node* pNode = Child; 03039 while (pNode!=NULL) // While there are children to process 03040 { 03041 if (pNode->Flags.Selected || 03042 pNode->Flags.SelectedChildren) // See if this child is Sel or SelChildren 03043 return TRUE; // If so, then return TRUE immediately! 03044 pNode = pNode->Next; // Else go look for next child 03045 } 03046 03047 return FALSE; // If no children Sel or SelChildren then 03048 // Return FALSE. 03049 }
|
|
|
This scans the child sibling list of this node, to see if it contains an attribute that's exactly the same as the given one.
Definition at line 6070 of file node.cpp. 06071 { 06072 ERROR2IF(pAttr == NULL,FALSE,"NULL attr ptr"); 06073 06074 Node* pNode = FindFirstChild(); 06075 while (pNode != NULL) 06076 { 06077 if (pNode->IsAnAttribute()) 06078 { 06079 NodeAttribute* pOtherAttr = (NodeAttribute*)pNode; 06080 06081 if (pAttr->GetAttributeType() == pOtherAttr->GetAttributeType()) 06082 { 06083 if (*pAttr == *pOtherAttr) 06084 return TRUE; 06085 } 06086 } 06087 06088 pNode = pNode->FindNext(); 06089 } 06090 06091 return FALSE; 06092 }
|
|
|
Useful for debugging - actually, it only exists in the debug build.This virtual function is called whenever the node is hidden. It allows the node do things like 'optimise' itself to use less memory or send a message to let others know it's is being hidden etc.
Reimplemented in AttrBitmapFill, AttrFractalFill, Layer, NodeMouldGroup, NodeBlender, NodeBlend, NodeBitmap, and TextStory. Definition at line 4734 of file node.cpp. 04735 { 04736 return TRUE; 04737 }
|
|
|
Increments the count of the number of NodeHidden nodes which reffer to the node. This routine should only be called from the NodeHidden methods.
Definition at line 4646 of file node.cpp. 04647 { 04648 HiddenRefCnt++; 04649 }
|
|
||||||||||||
|
Inserts a chain of nodes at contextnode. A chain is an unconnected set of siblings. This function should be called from the first node (left most) in the chain. It doesn't do anything fancy - in fact, little more than changing a few pointers here and there.
Definition at line 5338 of file node.cpp. 05339 { 05340 ERROR3IF(Previous != 0, "Node is not first in the chain"); 05341 05342 if(Direction == FIRSTCHILD) 05343 { 05344 Node *N = this; // will be the last chain in node 05345 Node *Last = NULL; 05346 05347 // shoot though the chain setting parent pointers and find the last one 05348 while(N != 0) 05349 { 05350 N->Parent = ContextNode; 05351 Last = N; 05352 N = N->FindNext(); 05353 } 05354 05355 Last->Next = ContextNode->Child; 05356 ContextNode->Child = this; 05357 } else if(Direction == LASTCHILD) 05358 { 05359 if(ContextNode->Child != 0) 05360 { 05361 Node *End = ContextNode->FindLastChild(); 05362 05363 ERROR3IF(End->Next != 0, "Last child has next pointer"); 05364 05365 End->Next = this; 05366 Previous = End; 05367 } else { 05368 ContextNode->Child = this; 05369 } 05370 05371 Node *N = this; 05372 05373 // shoot though the chain setting parent pointers 05374 while(N != 0) 05375 { 05376 N->Parent = ContextNode; 05377 N = N->FindNext(); 05378 } 05379 } else { 05380 ERROR3("Direction not implemented yet in Node::InsertChainSimple"); 05381 } 05382 }
|
|
|
Reimplemented in BaseTextClass. Definition at line 489 of file node.h. 00489 {return FALSE;}
|
|
|
Reimplemented in NodeBevel. Definition at line 495 of file node.h. 00495 { return FALSE; }
|
|
|
Definition at line 496 of file node.h. 00496 { return FALSE; }
|
|
|
Reimplemented in NodeBitmap. Definition at line 473 of file node.h. 00473 {return FALSE;}
|
|
|
Reimplemented in AttrBitmapColourFill. Definition at line 476 of file node.h. 00476 {return FALSE;}
|
|
|
Reimplemented in AttrBitmapFill, AttrBitmapColourFill, and NodeAttribute. Definition at line 475 of file node.h. 00475 {return FALSE;}
|
|
|
Reimplemented in AttrBitmapTranspFill. Definition at line 477 of file node.h. 00477 {return FALSE;}
|
|
|
Reimplemented in NodeBlend. Definition at line 483 of file node.h. 00483 { return FALSE; }
|
|
|
Reimplemented in AttrBrushType. Definition at line 501 of file node.h. 00501 {return FALSE;}
|
|
|
Reimplemented in AttrClipView. Definition at line 479 of file node.h. 00479 { return FALSE; }
|
|
|
Reimplemented in NodeContour. Definition at line 497 of file node.h. 00497 { return FALSE; }
|
|
|
Reimplemented in NodeContourController. Definition at line 498 of file node.h. 00498 { return FALSE; }
|
|
|
Reimplemented in AttrFeather. Definition at line 478 of file node.h. 00478 { return FALSE; }
|
|
|
Reimplemented in AttrFillGeometry. Definition at line 474 of file node.h. 00474 {return FALSE;}
|
|
|
Reimplemented in NodeGroup. Definition at line 515 of file node.h. 00515 { return FALSE; }
|
|
|
Reimplemented in AbstractTextChar. Definition at line 487 of file node.h. 00487 {return FALSE;}
|
|
|
Reimplemented in NodeAttribute. Definition at line 461 of file node.h. 00461 {return FALSE;}
|
|
|
Determine if a node is *derived* from the NodeHidden class.Determine if a node is a NodeDocument object.Determine if a node is a NodePath object.Determine if a node is a QuickShape object.Determine if a node is a visible text node.Determine if a node is an AbstractTextChar node. Determine if a node is a (or is derived from) TextChar. Determine if a node is a (or is derived from) BaseTextClass. Determine if a node is a (or is derived from) AttrTxtFontTypeface. Finds the node to edit (if it exists). This node could actually be 'this' node one of its children which the node wants to be editable.
Definition at line 2500 of file node.cpp. 02501 { 02502 Node* pNode = this; 02503 if (pNode->IsNodePath()) 02504 return ((NodePath*)pNode); 02505 02506 return ((NodePath*) pNode->HasEditableChild(CC_RUNTIME_CLASS(NodePath), NULL)); 02507 }
|
|
|
Reimplemented in InsertionNode. Definition at line 518 of file node.h. 00518 { return FALSE; }
|
|
|
Reimplemented in NodeRenderableInk. Definition at line 460 of file node.h. 00460 {return FALSE;}
|
|
|
Reimplemented in TemplateAttribute. Definition at line 491 of file node.h. 00491 {return FALSE;}
|
|
|
Reimplemented in NodeClipView. Definition at line 512 of file node.h. 00512 { return FALSE; }
|
|
|
Reimplemented in NodeClipViewController. Definition at line 511 of file node.h. 00511 { return FALSE; }
|
|
|
Reimplemented in NodeMould. Definition at line 521 of file node.h. 00521 {return FALSE;}
|
|
|
Reimplemented in NodeRegularShape. Definition at line 471 of file node.h. 00471 {return FALSE;}
|
|
|
Definition at line 499 of file node.h. 00499 { return FALSE; }
|
|
|
Definition at line 500 of file node.h. 00500 { return FALSE; }
|
|
|
Reimplemented in TextChar. Definition at line 488 of file node.h. 00488 {return FALSE;}
|
|
|
Reimplemented in AttrTxtFontTypeface. Definition at line 490 of file node.h. 00490 {return FALSE;}
|
|
|
Reimplemented in VisibleTextNode. Definition at line 486 of file node.h. 00486 {return FALSE;}
|
|