node.cpp

Go to the documentation of this file.

// $Id: node.cpp 1621 2006-07-31 15:35:28Z phil $
/* @@tag:xara-cn@@ DO NOT MODIFY THIS LINE
================================XARAHEADERSTART===========================
 
               Xara LX, a vector drawing and manipulation program.
                    Copyright (C) 1993-2006 Xara Group Ltd.
       Copyright on certain contributions may be held in joint with their
              respective authors. See AUTHORS file for details.

LICENSE TO USE AND MODIFY SOFTWARE
----------------------------------

This file is part of Xara LX.

Xara LX is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License version 2 as published
by the Free Software Foundation.

Xara LX and its component source files are distributed in the hope
that it will be useful, but WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along
with Xara LX (see the file GPL in the root directory of the
distribution); if not, write to the Free Software Foundation, Inc., 51
Franklin St, Fifth Floor, Boston, MA  02110-1301 USA


ADDITIONAL RIGHTS
-----------------

Conditional upon your continuing compliance with the GNU General Public
License described above, Xara Group Ltd grants to you certain additional
rights. 

The additional rights are to use, modify, and distribute the software
together with the wxWidgets library, the wxXtra library, and the "CDraw"
library and any other such library that any version of Xara LX relased
by Xara Group Ltd requires in order to compile and execute, including
the static linking of that library to XaraLX. In the case of the
"CDraw" library, you may satisfy obligation under the GNU General Public
License to provide source code by providing a binary copy of the library
concerned and a copy of the license accompanying it.

Nothing in this section restricts any of the rights you have under
the GNU General Public License.


SCOPE OF LICENSE
----------------

This license applies to this program (XaraLX) and its constituent source
files only, and does not necessarily apply to other Xara products which may
in part share the same code base, and are subject to their own licensing
terms.

This license does not apply to files in the wxXtra directory, which
are built into a separate library, and are subject to the wxWindows
license contained within that directory in the file "WXXTRA-LICENSE".

This license does not apply to the binary libraries (if any) within
the "libs" directory, which are subject to a separate license contained
within that directory in the file "LIBS-LICENSE".


ARRANGEMENTS FOR CONTRIBUTION OF MODIFICATIONS
----------------------------------------------

Subject to the terms of the GNU Public License (see above), you are
free to do whatever you like with your modifications. However, you may
(at your option) wish contribute them to Xara's source tree. You can
find details of how to do this at:
  http://www.xaraxtreme.org/developers/

Prior to contributing your modifications, you will need to complete our
contributor agreement. This can be found at:
  http://www.xaraxtreme.org/developers/contribute/

Please note that Xara will not accept modifications which modify any of
the text between the start and end of this header (marked
XARAHEADERSTART and XARAHEADEREND).


MARKS
-----

Xara, Xara LX, Xara X, Xara X/Xtreme, Xara Xtreme, the Xtreme and Xara
designs are registered or unregistered trademarks, design-marks, and/or
service marks of Xara Group Ltd. All rights in these marks are reserved.


      Xara Group Ltd, Gaddesden Place, Hemel Hempstead, HP2 6EX, UK.
                        http://www.xara.com/

=================================XARAHEADEREND============================
 */
                  

// Implementation of the Node class
                  
// Check in comments



#include "camtypes.h"                          
//#include "mario.h"    // for _R(IDE_NOMORE_MEMORY)    
//#include "spread.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "chapter.h"
#include "nodedoc.h"
#include "page.h"
#include "progress.h"
#include "insertnd.h"
#include "lineattr.h"
#include "objchge.h"
#include "nodepath.h"
#include "ndoptmz.h"
#include "dbugtree.h"
//#include "camfiltr.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "cxftags.h"
#include "nodetxts.h"

#include "extender.h"
#include "ngcore.h"     // NameGallery, for stretching functionality
//#include "group.h" - in camtypes.h [AUTOMATICALLY REMOVED]

#ifdef RALPH
#include "ralphcri.h"
#endif
   

MILLIPOINT Node::PixelWidth;   
MILLIPOINT Node::PixelHeight; 
BOOL Node::HourglassOn = FALSE; // When TRUE certain slow routines will call ContinueSlowJob

DECLARE_SOURCE("$Revision: 1621 $");
CC_IMPLEMENT_DYNAMIC(Node, CCObject)
      
// Declare smart memory handling in Debug builds
#define new CAM_DEBUG_NEW    
                            
      
/***********************************************************************************************

>    Node::Node(void)

     Author:    Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
     Created:   19/4/93
     Inputs:    -
     Outputs:   -
     Returns:   - (Constructor)
     Purpose:   This constructor creates a node linked to no other with all status flags
                FALSE.  Also updates the Node counter of the current Document.
     Errors:    An assertion failure will occur if there is no current document
     Notes:     This method relies on the current document having been set in the Document
                object.   

***********************************************************************************************/


Node::Node()
{
    Previous=Next=Child=Parent=NULL; 
    // Set OpPermission stuff here too as SetOpPermission does a GetOpPermission which otherwise reads an undefined value
    Flags.Locked=Flags.Mangled=Flags.Marked=Flags.Selected=Flags.Renderable=Flags.OpPermission1=Flags.OpPermission2 = FALSE;   
    Flags.SelectedChildren = FALSE;
    SetOpPermission(PERMISSION_UNDEFINED);  
    HiddenRefCnt = 0; 
         
    // Has no TAG because it is not in a document yet.
    Tag = TAG_NOT_IN_DOC; 
}
 

/***********************************************************************************************

>   Node::Node( Node* ContextNode,  
                AttachNodeDirection Direction, 
                BOOL Locked = FALSE, 
                BOOL Mangled = FALSE,  
                BOOL Marked = FALSE, 
                BOOL Selected = FALSE, 
                BOOL Renderable = FALSE)

    Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:26/4/93             
    
    Inputs: ContextNode: Pointer to a node which this  node is to be attached to.     
    
            Direction: 
            
                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)
            
    Outputs:   -
    Returns:   - 
    Purpose: 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.
             
             Also updates the Node counter of the current document.  
   
    Errors: An assertion failure will occur if the ContextNode is NULL
    
***********************************************************************************************/
/*
Technical notes:

This method Initializes the flags to the values specified, and then calls a method
to attach a node to ContextNode, in the direction specified by Direction. 

***********************************************************************************************/                
 

Node::Node(Node* ContextNode,  
                AttachNodeDirection Direction, 
                BOOL Locked, 
                BOOL Mangled,  
                BOOL Marked, 
                BOOL Selected, 
                BOOL Renderable
               )
{                             
    // Defensive programming
    ENSURE(ContextNode != NULL,"Trying to attach a node to a NULL node");              

    // Initialize the flags
    Flags.Locked = Locked; 
    Flags.Mangled = Mangled; 
    Flags.Marked = Marked; 
    Flags.Selected = Selected; 
    Flags.SelectedChildren = FALSE;
    Flags.Renderable = Renderable;
    Flags.OpPermission1 = Flags.OpPermission2 = FALSE; // because SetOpPermission does a GetOpPermission

    // Has no TAG because it is not in a document yet.
    Tag = TAG_NOT_IN_DOC; 

    SetOpPermission(PERMISSION_UNDEFINED);  
    Child=NULL;                         // New node has no children
    AttachNode(ContextNode,Direction);  
             
    // Sanity check of unique TAG for object
    BaseDocument* pDoc = ContextNode->FindOwnerDoc();
    if (pDoc != NULL)
    {
        ERROR3IF(Tag==TAG_NOT_IN_DOC, "Tag should have a valid value");
        // Get a tag for this node and update the count of nodes in the document.
        if (Tag==TAG_NOT_IN_DOC)
            SetTags(pDoc);
    }
    else 
    {
        ERROR3IF(Tag!=TAG_NOT_IN_DOC, "Tag should be TAG_NOT_IN_DOC");
        Tag = TAG_NOT_IN_DOC; // Has no TAG
    }

    HiddenRefCnt = 0;

    if (Selected) 
    {
        // Inform the Selection SelRange that the selection has changed
        // Pass in 'this' to let it know that I am the most recently selected node
        SelRange *Selection = GetApplication()->FindSelection();
        if (Selection != NULL)
            Selection->Update(FALSE, this);
    }
} 




/********************************************************************************************

>   virtual Node::~Node()

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    30/11/93
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    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'.
    Errors:     -
    SeeAlso:    Document::DecCurrentNodeCount

********************************************************************************************/

Node::~Node()
{
    ERROR3IF(Child != NULL,"Deleting a node that has a ptr to child nodes");

    // Ensure that the Selection SelRange doesn't still keep a cached pointer to me
    SelRange *Selection = GetApplication()->FindSelection();
    if (Selection != NULL)
        Selection->ClearLastSelectedNodeIfItIs(this);

}

                   
/***********************************************************************************************

>   virtual void Node::Render(void)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    30/4/93
    Inputs:     RendRegion: Render region to render into
    Outputs:    -
    Returns:    -   
    Purpose:    For rendering a node
        
***********************************************************************************************/

void Node::Render( RenderRegion* pRender ) {};   



/********************************************************************************************

>   void Node::RenderTreeAtomic(RenderRegion* pRender)

    Author:     Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/09/2000
    Inputs:     pRender     the RenderRegion to render into.

    Purpose:    Renders the tree rooted at this node into the given RenderRegion.

    Notes:      !!! THIS FUNCTION IS NOT RECURSIVE AS OF 23/06/2004 - Phil !!!

                *** THIS FUNCTION IS CURRENTLY RECURSIVE ***

                *** THIS FUNCTION IS CURRENTLY ATOMIC ***
                So don't call it willy-nilly, as you will ruin Camelot's interruptible
                background rendering functionality.

                Rendering is depth-first, with PreRenderChildren() called on all nodes.

                This function currently goes *down* the tree, so it will miss any attributes
                applied to this node via its parent. To get around this, do:

                NodeRenderableInk* pParent = (NodeRenderableInk*)pNodeToRender->FindParent();
                if (pParent != NULL)
                {
                    CCAttrMap* pAttrMap = CCAttrMap::MakeAppliedAttrMap(pParent);
                    if (pAttrMap != NULL)
                    {
                        pAttrMap->Render(pRenderRegion);
                        delete pAttrMap;
                    }
                }
                pNodeToRender->RenderTreeAtomic(pRenderRegion);

                Misconceptions: Render() does not render a tree - only one node.
                                RenderAppliedAttributes() cannot be used generally - it is
                                only designed for and used in the hit-test code.

    Errors:     pRender is checked for NULL in DEBUG builds.

********************************************************************************************/
void Node::RenderTreeAtomic(RenderRegion* pRender)
{
    ERROR3IF(pRender == NULL, "Node::RenderTreeAtomic; NULL pRender parameter not allowed!");

    pRender->RenderTree(this, FALSE);
}



/********************************************************************************************

>   BOOL Node::NeedsToRender(RenderRegion *pRender)

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    07/02/94
    Inputs:     pRender - the render region in question (NULL if none)
    Returns:    TRUE  => This node should be rendered,
                FALSE => This node does not need to be rendered.
    Purpose:    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.
    SeeAlso:    Node::Render

********************************************************************************************/

BOOL Node::NeedsToRender(RenderRegion* pRender)
{
    // NeedsToRender has been deprecated and replaced by RenderSubtree
    // It is retained in this base class for those algorithms that still have to use
    // NeedsToRender and FindNextForClippedInkRender
    //
    // Now implemented by calling RenderSubtree
    //
    SubtreeRenderState state = RenderSubtree(pRender);
    ERROR2IF(state==SUBTREE_JUMPTO, FALSE, "Complex render state return to BOOL NeedsToRender\n");

    return (state==SUBTREE_ROOTONLY || state==SUBTREE_ROOTANDCHILDREN);
}


/*********************************************************************************************

>    void Node::SetRender(BOOL Status, BOOL bAndChildren=FALSE) const

     Author:    Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
     Created:   19/4/93
     Inputs:    val: Status of node's renderable flag
                Recursion flag
     Outputs:   -
     Returns:   -
     Purpose:   To set Nodes renderable status (TRUE/FALSE)
     Errors:    -

**********************************************************************************************/
      

void Node::SetRender(BOOL Status, BOOL bAndChildren)
{
    Flags.Renderable = Status;

    if (bAndChildren)
    {
        Node* pNode = FindFirstChild();
        while (pNode)
        {
            pNode->SetRender(Status, bAndChildren);
            pNode = pNode->FindNext();
        }
    }
}     
    


/********************************************************************************************

>   void Node::PreExportRender( RenderRegion* pRender )

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    25/03/94
    Inputs:     pRender - the render region we are exporting to.
    Purpose:    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).
    SeeAlso:    Node::ExportRender; Node::NeedsToExport

********************************************************************************************/

void Node::PreExportRender( RenderRegion* pRender )
{
}

/********************************************************************************************

>   BOOL Node::ExportRender( RenderRegion* pRender )

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    25/03/94
    Inputs:     pRender - the render region we are exporting to.
    Returns:    TRUE  => Rendered (exported) ok; don't call Render().
                FALSE => Exporting is the same as normal rendering; nothing has been
                         rendered, so call the default Render() function.
    Purpose:    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.
    SeeAlso:    Node::PreExportRender; Node::NeedsToExport

********************************************************************************************/

BOOL Node::ExportRender( RenderRegion* pRender )
{
    // By default, use normal rendering when exporting.
    return FALSE;
}

/********************************************************************************************

>   BOOL Node::NeedsToExport(RenderRegion* pRender, BOOL VisibleLayersOnly = FALSE,
                             BOOL CheckSelected = FALSE)

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/03/94
    Inputs:     pRender - the render region we are exporting to (NULL if none)
                VisibleLayersOnly - TRUE => remove nodes which are on invisible layers
                                   - FALSE => export everything
                CheckSelected - TRUE => we check if object selected and only export selected bjects
                              - FALSE => we don't bother checking for selection or not
    Returns:    TRUE  => Yes, export this node.
                FALSE => Do not export this node.
    Purpose:    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.
    SeeAlso:    Node::NeedsToRender.

********************************************************************************************/

BOOL Node::NeedsToExport(RenderRegion* pRender, BOOL VisibleLayersOnly, BOOL CheckSelected)
{
    return FALSE;
}



/********************************************************************************************

>   virtual String Describe(BOOL Plural, BOOL Verbose = TRUE)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    18/6/93
    Inputs:     Plural: Flag indicating if the string description should be plural or
                        singular.
                Verbose: Flag indicating if a shortended or full description is required. 
                         Most classes will ignore this, but some (eg. Bitmaps) will just
                         give shortended desciptions more appropriate for menus.
    Outputs:    -
    Retuns:     Description of the object 
    Purpose:    To return a description of the Node object in either the singular or the 
                plural. This method is called by the DescribeRange method.
                
                The description will always begin with a lower case letter.   
                
    Errors:     A resource exception will be thrown if a problem occurs when loading the 
                string resource. 
    SeeAlso:    -

********************************************************************************************/
/*
    Technical Notes:
    
    The String resource identifiers should be of the form: ID_<Class>_DescriptionS for the 
    singular description and ID_<Class>_DescriptionP for the plural. 
*/              
              
String Node::Describe(BOOL Plural, BOOL Verbose) 
{     
    ENSURE (FALSE,"The illegal function Node::Describe was called\n"); 
    
    return( _T("") ); // Just to keep the compiler happy
}; 

/***********************************************************************************************
    
                                 
>   void Node::AttachNode(  Node* ContextNode, 
                            AttachNodeDirection Direction,
                            BOOL fCheckTransparent = TRUE,
                            BOOL InvalidateBounds = TRUE)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/4/93             
    
    Inputs:     ContextNode: Pointer to a node to which this node is to be attached     
    
                Direction: 
            
                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.
    Outputs:   -
    Returns:   - 
    Purpose:    This method attaches the node to a context node in the direction specified 
                by Direction. All necessary tree links are updated. 
   
    Errors:     An assertion failure will occur if ContextNode is NULL   
    
    Scope:      private 

***********************************************************************************************/
                             
void Node::AttachNode(  Node* ContextNode,
                        AttachNodeDirection Direction, 
                        BOOL fCheckTransparent,
                        BOOL InvalidateBounds) 
{  
    ERROR3IF(IsAnAttribute() && (!(((NodeAttribute*)this)->CanBeAppliedToObject())) &&
             ContextNode->IsAnObject(), 
        "Trying to attach invalid attribute to this object");
         
    ENSURE(ContextNode != NULL,"Trying to attach a node to a NULL node");              
    switch (Direction)
    {
        case PREV:        // Attach node as a previous sibling of the ContextNode  
            AttachAsPreviousNode(ContextNode); 
            break; 
        case NEXT:         // Attach node as a next sibling of the ContextNode
            AttachAsNextNode(ContextNode);                                 
            break; 
        case FIRSTCHILD:   // Attach node as the first child of the Context node
            AttachAsFirstChildNode(ContextNode);       
            break;
        case LASTCHILD:    // Attach node as the last child of the Context node
            AttachAsLastChildNode(ContextNode);            
            break;  
    }

    // If an attribute is being attached which affects the parents bounds then we need to
    // invalidate it's parent and all children of the parent!.
    
    if (InvalidateBounds)
    {
        Node* pParent = FindParent();
        if (pParent != NULL)
        { 
            if (pParent->IsBounded())
            { 
                BOOL AffectsParentsChildren = (this->IsAnAttribute() && ((NodeAttribute*)this)->EffectsParentBounds());
                if (AffectsParentsChildren)
                {
                    ((NodeRenderableBounded*)pParent)->InvalidateBoundingRect(TRUE);
                }
            }
        }
    }

    // Set the tags for this node and any children
    BaseDocument* pDoc = ContextNode->FindOwnerDoc();
    SetTags(pDoc);
}     
    

/***********************************************************************************************

>   void Node::SetTags(BaseDocument *pOwnerDoc)

    Author:  Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created: 3/11/95
    Inputs:  pOwnerDoc - the document that this node is in; NULL if not in a document.
    Purpose: Sets the tag of this node and all its descendants to a legal value, according
             to which document it is in, if any.

***********************************************************************************************/

void Node::SetTags(BaseDocument *pOwnerDoc)
{
    // Set the tag for this node according to the document.
    if (pOwnerDoc != NULL)
    {
        // Only set the tag if it is not already a legal tag.
        if (Tag == TAG_NOT_IN_DOC)
        {
            Tag = pOwnerDoc->NewTag();
            pOwnerDoc->IncNodeCount();
        }
    }
    else 
    {
        // Ensure this is marked as not being in a document.
        Tag = TAG_NOT_IN_DOC;
    }

    // Now set the tags of any children of this node - start with the first child of this node.
    Node *pChild = FindFirstChild();

    while (pChild != NULL)
    {
        // Set the tags of this child and its children.
        pChild->SetTags(pOwnerDoc);

        // Do the next child.
        pChild = pChild->FindNext();
    }
}
      
/***********************************************************************************************

>   void Node::AttachAsPreviousNode(Node* ContextNode) 

    Author:  Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created: 25/4/93             
    
    Inputs:  ContextNode: Pointer to a node to which the new node is to be attached as a
             previous sibling     
    Outputs: -
    Returns: - 
    Purpose: Links the node as a previous sibling of ContextNode.   
    
    Errors:  An assertion failure will occur if ContextNode is NULL 
    
    Scope:   private 

***********************************************************************************************/
/*
Technical notes:

 When linking the node as a previous sibling of the context node there are a number of  
 cases to consider. 
 
 1. The context node has no existing previous sibling  
    1.1 The context node has a parent  
    1.2 The context node has no parent 
 2. The context node has an existing previous sibling   

***********************************************************************************************/                
 
      
void Node::AttachAsPreviousNode(Node* ContextNode)
{                                
    ENSURE(ContextNode != NULL,"Trying to attach a node to a NULL node");              
    
    // Check if ContextNode already has a Previous sibling 
    if (ContextNode->Previous == NULL)  // ContextNode has no previous sibling                                       
    {
        Previous = NULL; // The new node has no previous sibling
           
        // If ContextNode has a parent then ContextNode will currently be the 
        // first child of the parent because Previous == NULL   
        if (ContextNode->Parent != NULL) 
        {                                           
            // Make the new node the first child of ContextNode
            ContextNode->Parent->Child = this; 
        }
    }
    else // Context node has a previous sibling     
    {
        // The new node's Previous sibling becomes the context node's previous sibling
        Previous = ContextNode->Previous;    
        // The previous siblings next sibling becomes the new node
        Previous->Next = this; 
    }        
    ContextNode->Previous = this;  // Attach new node as previous sibling
    Next = ContextNode;                // New node's next sibling is ContextNode
    Parent = ContextNode->Parent;  // New nodes parent same as the ContextNode.  
}    

      
/***********************************************************************************************

>   void Node::AttachAsNextNode(Node* ContextNode) 

    Author:    Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:   25/4/93             
                                                                         *
    Inputs:    ContextNode: Pointer to a node to which the new node is to be attached as a
               next sibling     
    Outputs:   -
    Returns:   - 
    Purpose:   Links the node as a next sibling of ContextNode. 
    Errors:    An assertion failure will occur if ContextNode is NULL
    Scope:     Private

***********************************************************************************************/
/*
Technical notes:

 When linking the node as a next sibling of the context node there are two   
 cases to consider. 
 
 1. The context node has no existing next sibling
 2. The context node has an existing next sibling   
    
***********************************************************************************************/                
  
       
void Node::AttachAsNextNode(Node* ContextNode)
{                     
    ENSURE(ContextNode != NULL,"Trying to attach a node to a NULL node");              
    
    // Check if ContextNode already has a Next sibling
    if (ContextNode->Next == NULL)  // Context node has no next sibling  
        Next = NULL; // New node has no next sibling
    else  
    {   
        // The new node's next sibling = the context node's next sibling
        Next = ContextNode->Next; 
        // The next sibling's previous sibling becomes the new node
        Next->Previous = this; 
    }          
    ContextNode->Next = this; // Attach new node as next sibling
    Previous = ContextNode;   // New node's previous sibling is ContextNode
    Parent = ContextNode->Parent; // New node's parent same as the ContextNode
}
                       

/***********************************************************************************************

>   void Node::AttachAsFirstChildNode(Node* ContextNode) 

    Author:    Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:   25/4/93             
    
    Inputs:    ContextNode: Pointer to a node to which the new node is to be attached as a
               first child     
    Outputs:   -
    Returns:   - 
    Purpose:   Links the node as a first child of ContextNode.  
    Errors:    An assertion failure will occur if ContextNode is NULL                                    
    Notes:     This is a private method
    Scope:     private

***********************************************************************************************/
/*
Technical notes:

 When linking the node as a first child of the context node there are two   
 cases to consider. 
 
 1. The context node has no existing first child
 2. The context node has an existing first child  
    
***********************************************************************************************/                
  
                       
void Node::AttachAsFirstChildNode(Node* ContextNode)
{                   
    ENSURE(ContextNode != NULL,"Trying to attach a node to a NULL node");              

    // Check if ContextNode already has a Child
    if (ContextNode->Child == NULL)    
        Next = NULL; // If not then new node has no next sibling
    else
    {   
        // Context node's first child becomes the new node's next sibling
        Next = ContextNode->Child; 
        // The next sibling's previous sibling becomes the new node
        Next->Previous = this; 
    }          
    ContextNode->Child = this; // Attach new node as first child of context node
    Previous = NULL;      // A first child cannot have a previous sibling
    Parent = ContextNode; // New node's parent is ContextNode       
}                                 
  
      
/***********************************************************************************************

>   void Node::AttachAsLastChildNode(Node* ContextNode) 

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    25/4/93             
    
    Inputs:     ContextNode: Pointer to a node to which the new node is to be attached as a
                last child     
    Outputs:    -
    Returns:    - 
    Purpose:    Links the node as a last child of ContextNode. 
    Errors:     An assertion failure will occur if ContextNode is NULL
    Scope:      private
    

***********************************************************************************************/
/*
Technical notes:

 When linking the node as a last child of the context node there are two   
 cases to consider: 
 
 1. The context node has no existing children 
    In this case we can attach the node as a first child
 2. The context node has existing children
    In this case we can find the current last child, and attach the node to it as a next sibling . 
    
***********************************************************************************************/                
                   

void Node::AttachAsLastChildNode(Node* ContextNode)
{               
    ENSURE(ContextNode != NULL,"Trying to attach a node to a NULL node");              
    if (!ContextNode)
        return; // Don't just blow up

    if (ContextNode->Child == NULL)      // The context node has no children   
        AttachAsFirstChildNode(ContextNode);      // Add node as first child of context node                            
    else
    {                                             
        // Search for the current last child of Context node
        Node* np; 
        for(np=ContextNode->Child; (np->Next != NULL); np = np->Next);   
        // Add node as the next node of the current last child of ContextNode
        AttachAsNextNode(np);    
    }
}                              

/***********************************************************************************************

>    void Node::CascadeDelete(void) 

     Author:    Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
     Created:   26/4/93
     Purpose:   This method removes the node from the tree and deletes all its child nodes 
                (including hidden nodes). 

                "IT DOES NOT DELETE THE NODE ITSELF (only its children)"
                            
                
                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 
            
            
     Errors:    -
***********************************************************************************************/
/*
Technical notes:

The routine calls methods to firstly delete the children of the node, and then to unlink the 
node from the tree.      
 
***********************************************************************************************/                
  
                   
void Node::CascadeDelete(void) 
{
    ERROR3IF(GetHiddenCnt() != 0, "Trying to delete a node with a hidden ref cnt"); 
    // Delete all the node's children
    DeleteChildren(Child);
    // Unlink the node from the tree
    UnlinkNodeFromTree();
}  

/***********************************************************************************************

>    void Node::DeleteChildren(Node* FirstChild) 

     Author:    Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
     Created:   26/4/93
     Inputs:    FirstChild: Pointer to the first child to be deleted
     Outputs:   -
     Returns:   - 
     Purpose:   Deletes the children and all the children's children etc. 
                starting from FirstChild. 

                Certain nodes are not deleted but simply unlinked, these are the nodes which are
                pointed at by the OperationHistory.

                NodeHidden nodes (ShowNodeActions point at them)
                Nodes with a HiddenCnt not equal to 0 - HiddenNodes point at them




     Errors:    -
     Scope:     private          
***********************************************************************************************/
/*
Technical notes:

The implementation is recursive: 
        
 For each child
    IF the child has children THEN delete the child's children
    delete the child               
    

***********************************************************************************************/                
  

void Node::DeleteChildren(Node* FirstChild)
{          
    Node* CurrentNode = FirstChild;

    if (ShowHourglass())
    {
        ContinueSlowJob(); 
    }

    BaseDocument *pOwnerDoc = NULL;

    if (FirstChild != NULL)
        FirstChild->FindOwnerDoc();

    while (CurrentNode != NULL)   // While there are children left to process
    {                               
        Node* NextNode = CurrentNode->Next;  
        // It is not the job of DeleteChildren to delete HiddenNodes or nodes pointed to by hidden nodes
        // They should be considered to be in the OperationHistory
        if ( (!CurrentNode->IsNodeHidden()) && (CurrentNode->GetHiddenCnt() == 0) )
        {
            if (CurrentNode->Child != NULL)  // There are children to delete      
                DeleteChildren(CurrentNode->Child);

            // Unlink from tree before deleting it
            CurrentNode->UnlinkNodeFromTree(pOwnerDoc); // Nice and safe !!!!

            delete CurrentNode;              // Current node has no children so can be deleted
        }
        else
            CurrentNode->UnlinkNodeFromTree(pOwnerDoc);

        CurrentNode = NextNode;          // Process next sibling

        if (ShowHourglass())
        {
            ContinueSlowJob(); 
        }

    } //end while
    Child = NULL; 
}                      


/***********************************************************************************************

>    void Node::UnlinkNodeFromTree(BaseDocument *pOwnerDoc == NULL)

     Author:    Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
     Created:   26/4/93
     Inputs:    pOwnerDoc - pointer to the document that this node is in.  This is used to
                            update the node count.  If it is NULL, then the tree is scanned
                            upwards to find the owner document instead.  This is merely a
                            performance enhancement, so that if a lot of nodes are being
                            deleted, then we don't have to scan the tree all the time.

                            This parameter is passed in automatically by Node functions which
                            delete many nodes in one go, such as:

                                Node::CascadeDelete
                                Node::DeleteChildren
                                ...
                                etc.

     Purpose:   Unlinks the node from the tree.
     SeeAlso:   Node::FindOwnerDoc
         
***********************************************************************************************/
/*
Technical notes:  

When unlinking the node there are a number of cases to consider:

1. The Node has a previous node     
 
2. The Node has no previous node 
    2.1 The node has a parent
    2.2 The node has no parent  

3. The Node has a next node
4. The Node has no next Node

***********************************************************************************************/                
  
void Node::UnlinkNodeFromTree(BaseDocument *pOwnerDoc)
{
    // Find the owner document if we don't have one
    if (pOwnerDoc == NULL)
        pOwnerDoc = FindOwnerDoc();

    // Update the node count if this node is actually in a document
    if (pOwnerDoc != NULL)
        pOwnerDoc->DecNodeCount();

    // Inform classes that may be holding pointers to this node
    RenderRegionList* pRList = GetApplication()->GetRegionList();
    if (pRList)
        pRList->HandleNodeDeletion(this);

    if (pOwnerDoc && pOwnerDoc->IsKindOf(CC_RUNTIME_CLASS(Document)))
        ((Document*)pOwnerDoc)->HandleNodeDeletion(this);

    // Now do the actual unlinking
    if (Previous == NULL) // Node must be a first child or root
    {
        if (Parent != NULL) // Node is a first child
            // The parent's new first child is the next sibling of the node being deleted
            Parent->Child = Next; 
    }
    else     
        //The previous node's next sibling becomes the node's Next sibling   
        Previous->Next = Next;                                                
    
    if (Next != NULL)   
        //The next node's previous sibling becomes the node's Previous sibling                          
        Next->Previous = Previous;    

    // Remove nodes links into the tree            
    Next = NULL; 
    Previous = NULL; 
    Parent = NULL; 
}



/***********************************************************************************************

>   BOOL Node::CopyNode(Node* Destination, 
                        AttachNodeDirection Direction) 

     Author:    Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
     Created:   28/4/93
    
     Inputs:    Destination: The destination node the copied node is to be attached to. 
         
                Direction: 
            
                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      
                
    Outputs:    
    Returns:    FALSE if memory ran out during the copy. 
                Otherwise TRUE. 
                 
    Purpose:    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.      
             
    Notes:       Before:-                                    
        
    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        
    
    Errors:     If memory is exhausted whilst copying, the routine returns FALSE after 
                deleting any partially copied subtree.               
         
***********************************************************************************************/
/*
Technical notes:  

This method makes a call to the recursive CopyChildren to create a copy of the subtree, and 
then attaches the subtree to the destination node. 

***********************************************************************************************/                

BOOL Node::CopyNode(Node* DestinationNode, AttachNodeDirection Direction)
{     
    // Get a copy of the subtree  
    if (ShowHourglass())
    {
        ContinueSlowJob(); 
    }

    Node* NewNode;
    if (!NodeCopy(&NewNode))
        return FALSE;

    // Attach the copied node to the Destination node                                                       
    NewNode->AttachNode(DestinationNode, Direction);
    return (TRUE);
}


/********************************************************************************************

>   BOOL Node::NodeCopy(Node** NodeCopy)   

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> / Mike
    Created:    4/3/94
    Inputs:     -
    Outputs:    NodeCopy: A deep copy of the node if Successful
    Returns:    - 
    Purpose:    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. 

    Errors:     -
    SeeAlso:    Node::CopyNode

********************************************************************************************/

BOOL Node::NodeCopy(Node** ppNodeCopy)   
{     
    Node* NewNode =