undoop.cpp

Go to the documentation of this file.

// $Id: undoop.cpp 1282 2006-06-09 09:46:49Z alex $
/* @@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============================
 */

#include "camtypes.h"
//#include "undoop.h" - in camtypes.h [AUTOMATICALLY REMOVED]

#include "ophist.h"

//#include "range.h"                         - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "document.h"   - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "ensure.h"      - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "selstate.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "tranform.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "docview.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "mario.h"
//#include "ink.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "spread.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "fixmem.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "nodepath.h"
//#include "app.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "cpyact.h"
#include "clipint.h"
#include "pathedit.h"
#include "ndoptmz.h"
#include "sprdmsg.h"
#include "layer.h"
//#include "markn.h"
#include "progress.h"
#include "invalid.h"
//#include "becomea.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "nodeattr.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "objchge.h"
//#include "group.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "nodeblnd.h"
#include "nodetxtl.h"
#include "nodetxts.h"
#include "ndbldpth.h"
#include "textops.h"
#include "cutop.h"
#include "camdoc.h"
#include "effects_stack.h"  // for EffectsStack
#include "attrmap.h"

#ifdef _DEBUG
#include "layermsg.h"   // layer messages for redraw layer message in debug builds
#endif

#include "ngcore.h"     // for NameGallery stretching implementation.
#include "chapter.h"

#include "opdupbar.h"
 
CC_IMPLEMENT_DYNCREATE( UndoableOperation, Operation )

// Declare smart memory handling in Debug builds
#define new CAM_DEBUG_NEW    

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// ObjectSet methods


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

>   BOOL ObjectSet::AddToSet(NodeRenderableInk* pObject)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/5/95
    Returns:    FALSE if we run out of memory
    Purpose:    Adds pObject to the set
    SeeAlso:    ObjectSet::InSet
    SeeAlso:    ObjectSet::CopySet


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

BOOL ObjectSet::AddToSet(NodeRenderableInk* pObject)
{
    ERROR3IF(pObject == NULL, "AddToSet: pObject is NULL"); 
    // Determine if the pObject is already in the set
    ObjectItem* pObjItem = (ObjectItem*) GetHead();
    while (pObjItem != NULL)
    {
        if (pObjItem->pObject == pObject)
        {
            return TRUE; // Already in set so return
        }
        pObjItem = (ObjectItem*)GetNext(pObjItem);
    }
    
    // The attribute type is not in the set so let's add it
    pObjItem = new  ObjectItem;
    if (!pObjItem)
        return FALSE;   // out of memory (error has been set)

    pObjItem->pObject = pObject;

    AddHead(pObjItem); // Add attribute to the head of the list
     
    return TRUE; 
}


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

>   BOOL ObjectSet::CopySet()

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    15/5/95
    Inputs:     -
    Outputs:    -
    Returns:    A copy of the set, or NULL if we run out of memory
    Purpose:    Makes a copy of the object set
    Errors:     -
    SeeAlso:    ObjectSet::AddToSet
    SeeAlso:    ObjectSet::InSet

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

ObjectSet* ObjectSet::CopySet()
{
    ObjectSet* pSetCopy; 
    pSetCopy = new ObjectSet;
    if (!pSetCopy)
        return NULL; // Out of memory

    // Copy each item in turn
    ObjectItem* pItemCopy;
    ObjectItem* pCurrent = (ObjectItem*)GetHead(); 
    while (pCurrent)
    {
        pItemCopy = new ObjectItem;
        if (!pItemCopy)
        {
            // Tidyup
            pSetCopy->DeleteAll();
            delete pSetCopy;
            return NULL;  
        }
        pItemCopy->pObject = pCurrent->pObject;
        pSetCopy->AddTail(pItemCopy); 
        pCurrent = (ObjectItem*)GetNext(pCurrent);  
    }
    return pSetCopy;
}

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

>   BOOL ObjectSet::InSet(NodeRenderableInk* pObject)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    15/5/95
    Inputs:     pObject: A pointer to an object
    Outputs:    -
    Returns:    TRUE if pObject is in the set
    Purpose:    To determine if pObject is in the set   
    Errors:     -
    SeeAlso:    ObjectSet::CopySet
    SeeAlso:    ObjectSet::AddToSet


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

BOOL ObjectSet::InSet(NodeRenderableInk* pObject)
{
    ObjectItem* pCurrent = (ObjectItem*)GetHead(); 
    while (pCurrent)
    {
        if (pCurrent->pObject == pObject)
            return TRUE; 
        pCurrent = (ObjectItem*)GetNext(pCurrent);  
    }
    return FALSE; 
}         



// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// UndoableOperation methods



BOOL UndoableOperation::MovingNode = FALSE;
                                                                
/********************************************************************************************

>   UndoableOperation::UndoableOperation()

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    9/3/94
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Constructs a new undoable operation object:
    Errors:     -
    SeeAlso:    Operation::Operation

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

UndoableOperation::UndoableOperation(): Operation()
{   
    // This var is a flag that ensures that this warning will only appear once for the lifetime of this op
    WarnInsertObjsOntoLockedLayers = TRUE;
}


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

>   virtual UndoableOperation::~UndoableOperation()


    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    9/3/94
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    UndoableOperation destructor
    Errors:     -
    SeeAlso:    -

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

UndoableOperation::~UndoableOperation()
{
}



// ---------------------------------------------------------------------------------------
// The Do functions 

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

>   BOOL UndoableOperation::DoInsertNewNode(NodeRenderableBounded* NewNode, 
                                            Spread *pSpread, 
                                            BOOL InvalidateRgn,
                                            BOOL ClearSelection = TRUE,
                                            BOOL SelectNewObject = TRUE,
                                            BOOL NormaliseAttributes=TRUE)


    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    13/9/93
    Inputs:     NewNode:            The new node to be added 
                pSpread:            The spread to add the new node to 
                                    *Set this to NULL if you want to insert
                                    the node onto the selected spread.
                InvalidateRgn:      Invalidate the node's region (including blobs)
                ClearSelection:     Clear all selected objects prior to the new object
                                    being inserted (Default TRUE)
                SelectNewObject:    Select the new object (Default TRUE)
                NormaliseAttributes:When TRUE redundant attributes are removed from the 
                                    node. If you know that the node being inserted has
                                    the correct set of attributes then you can set this to
                                    FALSE.   
 
                Note: Do not set the bounding rectangle of NewNode prior to calling 
                      this function, or the bounds will not be propagated. 
    Returns:    TRUE if successful 
                FALSE if the operation should be aborted (TIDYUP THEN CALL End()!) 
    Purpose:    Inserts the node as a last child of the active layer of the pSpread. 
                If the NewNode is a NodeRenderableInk then the node becomes selected and
                all other nodes are deselected. If pSpread is NULL then the object is inserted
                on the selected spread.
    SeeAlso:    UndoableOperation::DoInsertNewNode

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

BOOL UndoableOperation::DoInsertNewNode(NodeRenderableBounded* NewNode, 
                                Spread *pSpread, 
                                BOOL InvalidateRgn,
                                BOOL ClearSelection,        // = TRUE
                                BOOL SelectNewObject,       // = TRUE
                                BOOL NormaliseAttributes)   // = TRUE

{ 
    ENSURE( pOurDoc!=NULL, "No current document in DoInsertNode" );

    // Insert node as the active layer of the spread 
    pOurDoc->InsertNewNode(NewNode, pSpread);
    NewNode->SetSelected(FALSE); 

    // This is a brand new node, so we have to make sure that all its parents
    // are invalidated as well.
    // if this nodes bounding rect was already invalid when it was added the parent
    // will not be invalidated as well, so we first mark its bounds as valid.
    // This is very important - Ask Rik if you think it looks silly.
    NewNode->ValidateBoundingRect();
    NewNode->InvalidateBoundingRect();

    // If inserting a node onto a layer that is locked or invisible, warn the user before
    // proceeding, and ensure that the node is not selected.
    if (NewNode->IsKindOf(CC_RUNTIME_CLASS(NodeRenderableInk)))
    {
        Layer* pLayer = (Layer*)NewNode->FindParent(CC_RUNTIME_CLASS(Layer));
        if (pLayer != NULL)
        {
            if (!pLayer->IsVisible() || pLayer->IsLocked())
            {
                if (WarnInsertObjsOntoLockedLayers)
                {
#if (_OLE_VER >= 0x200)
                    // Only warn the user if the document is visible to him/her.
                    if (pOurDoc && pOurDoc->GetOilDoc() && pOurDoc->GetOilDoc()->IsVisible())
#endif
                    {
                        InformWarning(_R(IDS_WARNING_INSERTLAYER));
                    }
                    // Set flag to FALSE so it won't be reported back again in this op
                    WarnInsertObjsOntoLockedLayers = FALSE;
                }
                SelectNewObject = FALSE;
            }

            // Note that this layer has been edited
            pLayer->SetEdited(TRUE);
#ifdef _DEBUG
            // Tell the frame gallery to update its display of the frame
            BROADCAST_TO_ALL( LayerMsg( pLayer, LayerMsg::REDRAW_LAYER ) );
#endif
        }
    }


    /*
    if (InvalidateRgn)
    {
        if (!DoInvalidateNodeRegion((NodeRenderable*)NewNode, TRUE))
        {
            // Remove the NewNodeFrom the tree 
            NewNode->UnlinkNodeFromTree(); 
            return FALSE; 
        }
    }
    */

    // Create a hide node action to hide the node when we undo 
    HideNodeAction* UndoHideNodeAction;     
    if (HideNodeAction::Init(this,                    
                             &UndoActions,
                             NewNode, 
                             TRUE,       // Include subtree size 
                             ( Action**)(&UndoHideNodeAction))      
                              == AC_FAIL)

    {  
        // Remove the NewNodeFrom the tree 
        NewNode->UnlinkNodeFromTree(); 
        return FALSE; 
    }


    // Make it the currently selected object if it is an Ink object
    if ( NewNode->IsKindOf(CC_RUNTIME_CLASS(NodeRenderableInk)) )
    {
        if (ClearSelection)
        {
            NodeRenderableInk::DeselectAll();
            GetApplication()->UpdateSelection();
        }


        if (SelectNewObject)
        {
            // Select the new node, and don't redraw it yet 
            ((NodeRenderableInk*)NewNode)->Select(FALSE);
        }

        if (NormaliseAttributes)
        {
            ((NodeRenderableInk*)NewNode)->NormaliseAttributes(); // Removes redundant attributes
        }


    }

    // Update the selection
    if (NewNode->IsSelected())
        GetApplication()->UpdateSelection();

    if ( NewNode->IsKindOf(CC_RUNTIME_CLASS(NodeRenderableBounded)) )
    {
        if (InvalidateRgn)
        {
            if (!DoInvalidateNodeRegion((NodeRenderableBounded*)NewNode, TRUE))
            {
                return FALSE; 
            }
        }
    }

// Added by Jim: Broadcast the layerchanged message when inserting a new layer

    if (NewNode->GetRuntimeClass() == CC_RUNTIME_CLASS(Layer))
    {
        Spread* pSpread = (Spread*) NewNode->FindParent(CC_RUNTIME_CLASS(Spread)); 
        BROADCAST_TO_ALL(SpreadMsg(pSpread,SpreadMsg::LAYERCHANGES));
    }

    return (TRUE); 
}     




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

>   BOOL UndoableOperation::DoInsertNewNode(NodeRenderableBounded* NewNode, 
                                            Node* ContextNode,
                                            AttachNodeDirection Direction, 
                                            BOOL InvalidateRegion,
                                            BOOL ClearSelection = TRUE,
                                            BOOL SelectNewObject = TRUE,
                                            BOOL NormaliseAttributes=TRUE)


    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    13/9/93
    Inputs:     NewNode:            The new node to be added 
                ContextNode:        The node to which NewNode is to be attached
                Direction:          The direction the new node should be attached to the
                                    context node. 
                InvalidateRgn:      Invalidate the node's region (including blobs)
                ClearSelection:     Clear all selected objects prior to the new object
                                    being inserted (Default TRUE)
                SelectNewObject:    Select the new object (Default TRUE) 
                NormaliseAttributes:When TRUE redundant attributes are removed from the 
                                    node. If you know that the node being inserted has
                                    the correct set of attributes then you can set this to
                                    FALSE. 
                Note: Do not set the bounding rectangle of NewNode prior to calling 
                      this function, or the bounds will not be propagated. 
    Returns:    TRUE if successful 
                FALSE if the operation should be aborted (TIDYUP THEN CALL End()!) 
    Purpose:    This high level do function attaches the node to ContextNode in the direction 
                specified. If the NewNode is a NodeRenderableInk then the node becomes 
                selected and all other nodes are deselected. 
    SeeAlso:    UndoableOperation::DoInsertNewNode

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

BOOL UndoableOperation::DoInsertNewNode(NodeRenderableBounded* NewNode, 
                                Node* ContextNode,
                                AttachNodeDirection Direction, 
                                BOOL InvalidateRegion, 
                                BOOL ClearSelection, 
                                BOOL SelectNewObject,
                                BOOL NormaliseAttributes)
{
    // Insert the NewNode into the tree
    NewNode->AttachNode(ContextNode, Direction); 
    NewNode->SetSelected(FALSE); 

    // This is a brand new node, so we have to make sure that all its parents
    // are invalidated as well.
    // if this nodes bounding rect was already invalid when it was added the parent
    // will not be invalidated as well, so we first mark its bounds as valid.
    // This is very important - Ask Rik if you think it looks silly.
    NewNode->ValidateBoundingRect();
    NewNode->InvalidateBoundingRect();

    // If inserting a node onto a layer that is locked or invisible, warn the user before
    // proceeding, and ensure that the node is not selected.
    if (NewNode->IsKindOf(CC_RUNTIME_CLASS(NodeRenderableInk)))
    {
        Layer* pLayer = (Layer*)NewNode->FindParent(CC_RUNTIME_CLASS(Layer));
        if (pLayer != NULL)
        {
            if (!pLayer->IsVisible() || pLayer->IsLocked())
            {
                if (WarnInsertObjsOntoLockedLayers)
                {
#if (_OLE_VER >= 0x200)
                    // Only warn the user if the document is visible to him/her.
                    if (pOurDoc && pOurDoc->GetOilDoc() && pOurDoc->GetOilDoc()->IsVisible())
#endif
                    {
                        // ignore this warning on some ops - like if we have text syncing between layers
                        // or other bar ops that manipulate invisible layers
                        // or doing the right click from drag op since the msg upsets the drag
PORTNOTE("text","Removed OpTextFormat reference")
#ifndef EXCLUDE_FROM_XARALX
                        if (!IS_A(this, OpTextFormat) && !IS_A(this, OpDuplicateBar) && !IS_A(this, OpCopyAndTransform))
                            InformWarning(_R(IDS_WARNING_INSERTLAYER));
#endif
                    }

                    // Set flag to FALSE so it won't be reported back again in this op
                    WarnInsertObjsOntoLockedLayers = FALSE;
                }
                SelectNewObject = FALSE;
            }

            // Note that this layer has been edited
            pLayer->SetEdited(TRUE);
#ifdef _DEBUG
            // Tell the frame gallery to update its display of the frame
            BROADCAST_TO_ALL(LayerMsg(pLayer, LayerMsg::/*LayerReason::*/REDRAW_LAYER));
#endif
        }
    }

    // Create a hide node action to hide the node when we undo 
    HideNodeAction* UndoHideNodeAction;     
    if (HideNodeAction::Init(this,                    
                             &UndoActions,
                             NewNode, 
                             TRUE,       // Include subtree size 
                             ( Action**)(&UndoHideNodeAction))      
                              == AC_FAIL)

    {   
        return FALSE; 
    }

    

    // Make it the currently selected object if it is an Ink object
    if ( NewNode->IsKindOf(CC_RUNTIME_CLASS(NodeRenderableInk)) )
    {
        if (ClearSelection)
        {
            NodeRenderableInk::DeselectAll();
            GetApplication()->UpdateSelection();

        }

        if (SelectNewObject)
        {

            // Select the new node
            ((NodeRenderableInk*)NewNode)->Select(FALSE);
        }


        if (NormaliseAttributes)
        {
            ((NodeRenderableInk*)NewNode)->NormaliseAttributes(); // Removes redundant attributes
        }

    
    }

    // Update the selection
    if (NewNode->IsSelected())
        GetApplication()->UpdateSelection();


    if ( NewNode->IsKindOf(CC_RUNTIME_CLASS(NodeRenderableBounded)) )
    {
        if (InvalidateRegion)
        {
            NewNode->ReleaseCached(TRUE, FALSE, TRUE, TRUE);
            if (!DoInvalidateNodeRegion((NodeRenderableBounded*)NewNode, TRUE, FALSE, FALSE, FALSE))    // Don't recache automatically!
            {
                return FALSE; 
            }
        }
    }

//  #ifdef _DEBUG
//      // If the node being Inserted is a layer then people need to know about it
//      if (NewNode->GetRuntimeClass() == CC_RUNTIME_CLASS(Layer))
//      {
//          TRACE( _T("Layer inserted. Have you remembered to broadcast a SpreadMsg::LAYERCHANGES message?"));
//          //Spread* pSpread = (Spread*) NewNode->FindParent(CC_RUNTIME_CLASS(Spread)); 
//          //BROADCAST_TO_ALL(SpreadMsg(pSpread,SpreadMsg::LAYERCHANGES));
//      }
//  #endif

// Added by Jim: Broadcast the layerchanged message when inserting a new layer

    if (NewNode->GetRuntimeClass() == CC_RUNTIME_CLASS(Layer))
    {
        Spread* pSpread = (Spread*) NewNode->FindParent(CC_RUNTIME_CLASS(Spread)); 
        BROADCAST_TO_ALL(SpreadMsg(pSpread,SpreadMsg::LAYERCHANGES));
    }
        
    return (TRUE);
}  


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

>   BOOL UndoableOperation::DoHideNode(Node* NodeToHide, BOOL IncludeSubtreeSize, 
                                        NodeHidden** nodeHidden = NULL,
                                        BOOL TellSubtree = TRUE) 

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    18/10/93
    Inputs:     Node:               The Node to be hidden 
      
                IncludeSubtreeSize: Flag indicating if the subtree being hidden should 
                                    be considered as belonging to the Operation history
                                    or not. (See the note in ops.h)

    Outputs:    nodeHidden: A pointer to the NodeHidden hiding the NodeToHide. This 
                output is optional. 

    Returns:    TRUE if successful 
                FALSE if the operation should be aborted (TIDYUP THEN CALL End()!) 
    Purpose:    This low level Do function hides the subtree with root NodeToHide   
    Errors:     -
    SeeAlso:    UndoableOperation::DoHideNodes

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

BOOL UndoableOperation::DoHideNode(Node* NodeToHide, 
                                    BOOL IncludeSubtreeSize, 
                                    NodeHidden** nodeHidden,
                                    BOOL TellSubtree)  
{
    ERROR3IF(!OpFlags.SucceedAndDiscard && NodeToHide->IsAnAttribute() && NodeToHide->FindParent()->DiscardsAttributeChildren(), "DoHide called under Caret");

    if (NodeToHide->DiscardsAttributeChildren())    // If the node to hide doesn't want to produce undo (CaretNode)
        return TRUE;                                // Then bomb out now before we do anything...

    // We shouldn't tell the node that it's being hidden if we are only
    // moving it.
    // Also if we are Hiding a Node Group, then there is no
    // need to tell anyone either.  As the children are unaffected.
    if (TellSubtree)
    {
        // Tell the node and it's subtree, that they are being hidden
        Node* pNode = NodeToHide->FindFirstDepthFirst();
        while (pNode!=NULL)
        {
            if (!pNode->HidingNode())
                return FALSE;

            // And find the next node
            pNode = pNode->FindNextDepthFirst(NodeToHide);
        }
        // Invalidate the region, we need to do this here because we are deleting the node
        if (NodeToHide->IsBounded())
            ((NodeRenderableBounded*)NodeToHide)->InvalidateBoundingRect();

    }

// removed by Ed 23/5/95 'cos it caused text redraw problems
// and nobody could justify why just moving an object in the tree should
// cause the renderable bound associated with it to be invalidated
//  // Invalidate the region
//  if (NodeToHide->IsBounded())
//      ((NodeRenderableBounded*)NodeToHide)->InvalidateBoundingRect();

    // Try to hide the Node    
    NodeHidden* Hidden; 
    ALLOC_WITH_FAIL(Hidden,(new NodeHidden(NodeToHide)),this);
    if (Hidden == NULL)
    {          
        return (FALSE); 
    }

    // Try to create a ShowNodeAction which will show the node that we have just hidden. 
    
    ShowNodeAction* UndoShowNodeAction; 

    if (ShowNodeAction::Init(this,  
                             &UndoActions, 
                             Hidden, 
                             IncludeSubtreeSize, 
                             (Action**)(&UndoShowNodeAction),
                             TellSubtree) == AC_FAIL)
    {   
        // We must unhide the NodeToHide manually, cos no action will do it for us 
        Hidden->ShowNode(); // Hidden is deleted don't worry 
        return FALSE; 
    }
    
    if (NodeToHide->IsSelected())
    {
        // Update the selection range 
        Camelot.UpdateSelection();
    }

    // If the user provided a nodeHidden parameter then return a pointer to the NodeHidden
    if (nodeHidden != NULL)
        *nodeHidden = Hidden;    

// Added by Jim: Broadcast the layerchanged message when inserting a new layer

    if (NodeToHide->GetRuntimeClass() == CC_RUNTIME_CLASS(Layer))
    {
        Spread* pSpread = (Spread*) Hidden->FindParent(CC_RUNTIME_CLASS(Spread)); 
        BROADCAST_TO_ALL(SpreadMsg(pSpread,SpreadMsg::LAYERCHANGES));
    }
    // Success  
    return (TRUE); 
}

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

>   BOOL UndoableOperation::DoHideNodes(Range NodeRange, BOOL IncludeSubtreeSize, 
                                        BOOL TellSubtree = TRUE)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    03/03/94

    Inputs:     NodeRange:          The Range of nodes to be hidden 
      
                IncludeSubtreeSize: Flag indicating if the subtrees being hidden should 
                                    be considered as belonging to the Operation history
                                    or not. (See the note in ops.h)


    Returns:    TRUE if successful 
                FALSE if the operation should be aborted (TIDYUP THEN CALL End()!) 
    Purpose:    This low level Do function hides a range of the subtrees 
    Errors:     -
    SeeAlso:    UndoableOperation::DoHideNode

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

BOOL UndoableOperation::DoHideNodes(Range NodeRange, BOOL IncludeSubtreeSize, BOOL TellSubtree)
{
    Node* Current = NodeRange.FindFirst(); 
    while (Current != NULL)
    {
        Node* Next = NodeRange.FindNext(Current);
        if (!DoHideNode(Current, IncludeSubtreeSize, NULL, TellSubtree))
        {
            return FALSE;    // Failure 
        } 
        Current = Next; 
    }
    return TRUE; // Success
}                    



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

>   BOOL UndoableOperation::DoHideComplexRange(Range& RangeToHide)

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    3/5/95
    Inputs:     RangeToHide = the current range of nodes which need hiding
    Outputs:    RangeToHide = the updated range of nodes which need hiding
    Returns:    TRUE then all necessary objects were hidden correctly
                FALSE if failed to hide one of the objects

    Purpose:    This function is a pre process to DoHideNodes(). It calls each object in
                the range to hide themselves in a complex way. It may be that no objects
                in the selection require this facility, which means the RangeToHide object
                will be returned from this function unaffected. DoHideNodes() will then
                go through hidding all nodes in the range itself. If however a node responds
                to ComplexHide() and hides itself, the node will be removed from the range.
                This allows complex group nodes to control how they are hidden.
                Note, it is expected that ComplexHide() responders will hide nodes themselves
                This will have the automatic effect of removing them from the range. Hidden
                nodes do not appear in ranges.

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

BOOL UndoableOperation::DoHideComplexRange(Range& RangeToHide)
{
    BOOL Failed=FALSE;      
    Node *Next, *Current = RangeToHide.FindFirst();

    while (Current!=NULL)
    {
        // set the next node pointer.
        Next=RangeToHide.FindNext(Current);
        INT32 success = Current->ComplexHide(this, Next);
        // success=-1 then error unable to hide node
        // success= 0 then ignore
        // success= 1 then node has been hidden
        Failed=(success<0);
        if (Failed)
            break;

        Current=Next;
    }

    return (!Failed);
}



/********************************************************************************************
                          
>   BOOL UndoableOperation::DoMoveNodes(Range NodeRange, 
                                        Node* Destination, 
                                        AttachNodeDirection Direction)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    13/9/93
    Inputs:     NodeRange:      The node range to be moved
                Destination:    The context node
                Direction:      The direction Node is to be attached to Destination    

    Outputs:    -
    Returns:    TRUE if successful 
                FALSE if the operation should be aborted (TIDYUP THEN CALL End()!) 
                
    Purpose:    This high level function moves the range of nodes from their current position
                in the tree, and attaches them to the Destination node in the direction 
                specified by Direction. 

                The nodes in the range maintain their relative z-order when they move.
                    
    Errors:     -
    SeeAlso:    UndoableOperation::DoMoveNode 

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

BOOL UndoableOperation::DoMoveNodes(Range NodeRange, 
                                    Node* Destination, 
                                    AttachNodeDirection Direction)   
{
    Node* Current = NodeRange.FindFirst(); // Get the first node to move
    ENSURE(Current != NULL, "Trying to move an empty range");
    
    Node* NextNode = NodeRange.FindNext(Current);

    // Attach the first node in the range to the Destination node in the direction specified
    if (!DoMoveNode(Current, Destination, Direction))
    {
        return FALSE; // Failed to move Current 
    }
    
    Node* PrevNode = Current; 

    // Get the next node in the range  
    Current = NextNode; 

    // Attach all other nodes in the range 
    while (Current != NULL)
    {
        NextNode = NodeRange.FindNext(Current);
        if (!DoMoveNode(Current, PrevNode, NEXT))
        {
            return FALSE; // Failed to move Current 
        }   
        PrevNode = Current; 
        Current = NextNode;  
    }
    return TRUE; 
}

/********************************************************************************************
                          
>   BOOL UndoableOperation::DoMoveNode(Node* NodeToMove, 
                                       Node* Destination, 
                                       AttachNodeDirection Direction)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    13/9/93
    Inputs:     NodeToMove:     The node to be moved, cannot be an attribute
                Destination:    The context node
                Direction:      The direction Node is to be attached to Destination    

    Outputs:    -
    Returns:    TRUE if successful 
                FALSE if the operation should be aborted (TIDYUP THEN CALL End()!) 
                
    Purpose:    This high level function moves NodeToMove from its current position in the 
                tree, and attaches it to Destination in the direction specified by Direction.

                Note: It is illegal to move an attribute in the tree. This is because it may
                      be deleted as a result of attribute optimisation. It is unlikely that
                      you would want to move an attribute anyway.An ERROR2 will be generated 
                      if this occurs.
                Update, 22/03/2005:
                        It is legal to move an effect attribute because they are not optimised
                        in the same way as other attributes.
                    
    Errors:     -
    SeeAlso:    UndoableOperation::DoMoveNodes 

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

BOOL UndoableOperation::DoMoveNode(Node* NodeToMove, 
                                   Node* Destination, 
                                   AttachNodeDirection Direction) 

{  
    ERROR2IF(NodeToMove->IsAnAttribute() && !((NodeAttribute*)NodeToMove)->IsEffectAttribute(), FALSE, "Trying to move an attribute, this is bad"); 

    // --------------------------------------------------------------------
    // We have to move attributes by copying...
    if (NodeToMove->IsAnAttribute())
    {
        // Copy the attribute to the destination location
        // Then hide the original

        // Copy
        NodeAttribute* pCopyAttr = NULL;
        BOOL bOK = FALSE;
        CALL_WITH_FAIL(((NodeAttribute*)NodeToMove)->NodeCopy((Node**)&pCopyAttr), this, bOK);
        if (!bOK) return FALSE; // No room to take a copy of the node

        // Create a hide node action to hide the node when we undo 
        pCopyAttr->AttachNode(Destination, Direction);
        HideNodeAction* UndoHideNodeAction;
        if (HideNodeAction::Init(this, this->GetUndoActions(), pCopyAttr, TRUE, (Action**)(&UndoHideNodeAction))
                == AC_FAIL)
        {
            pCopyAttr->CascadeDelete();
            delete pCopyAttr;
            return FALSE;
        }

        // Hide
        if (!DoHideNode(NodeToMove, TRUE, NULL, TRUE))
            return FALSE;

        return TRUE;
    }

    // --------------------------------------------------------------------
    // Objects are physically moved, leaving a NodeHidden in the original location
    // with a "hyperspace" reference to the object in its final location.
    //
    // We must flag that we are only moving the node, so we don't
    // try and called the 'Hiding Node' function, which should only
    // be called when we are 'Really' hiding the node.
    MovingNode = TRUE;

    // Find out if the node is selected
    BOOL IsSelected = NodeToMove->IsSelected();

    // Before we move the object determine what the source layer is
    Layer* pSrcLayer = NULL; 
    if (NodeToMove->IsAnObject())
    {
        // Only consider ink nodes
        pSrcLayer = (Layer*) (NodeToMove->FindParent(CC_RUNTIME_CLASS(Layer)));
    } 

    // Hide it
    HideNodeAction* UndoHideNodeAction;  
//  NodeRenderableBounded* pBounded = NULL;

    // hide the node
    if (!DoHideNode(NodeToMove, FALSE, NULL, FALSE)) 
        goto Failed; 
    
    // build the action
    if ( HideNodeAction::Init(this, 
                              &UndoActions, 
                              NodeToMove,
                              FALSE,                            // Don't include the 
                                                                // subtree size 
                              (Action**)(&UndoHideNodeAction),
                              
                              FALSE)                            // Don't tell subtree
                               == AC_FAIL)  
    {   
        goto Failed; 
    };  

    // Move the node to its new location
    NodeToMove->MoveNode(Destination, Direction);
    if (IsSelected)
        NodeToMove->SetSelected(IsSelected);

    MovingNode = FALSE;

    if (NodeToMove->IsAnObject())
    {
        // If the object has moved to a new layer then we need to invalidate both old and new 
        // layers
        Layer* pDestLayer = (Layer*) (NodeToMove->FindParent(CC_RUNTIME_CLASS(Layer)));
        if ((pSrcLayer != pDestLayer) && pSrcLayer && pDestLayer)
        {
            pSrcLayer->InvalidateBoundingRect();
            pDestLayer->InvalidateBoundingRect();
        }
        
        if (pSrcLayer)
        {
            // Note that this layer has been edited
            pSrcLayer->SetEdited(TRUE);
//#ifdef _DEBUG
//          // Tell the frame gallery to update its display of the frame
//          BROADCAST_TO_ALL(LayerMsg(pSrcLayer, LayerMsg::LayerReason::REDRAW_LAYER));
//#endif
        }

        if (pDestLayer && (pSrcLayer != pDestLayer))
        {
            // Note that this layer has been edited
            pDestLayer->SetEdited(TRUE);
//#ifdef _DEBUG
//          // Tell the frame gallery to update its display of the frame
//          BROADCAST_TO_ALL(LayerMsg(pDestLayer, LayerMsg::LayerReason::REDRAW_LAYER));
//#endif
        }

    }
    // finish happy
    return (TRUE);

Failed:
    MovingNode = FALSE;     // Ensure we clear this is an error occurred 
    return FALSE;
}


                    

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

>   BOOL UndoableOperation::DoSaveCopyOfNodes(Range NodeRange)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    7/3/94
    Inputs:     NodeRange: The range of nodes to save 
    Outputs:    -
    Returns:    -
    Purpose:    This fn takes a copy of the nodes in the range. The copies are restored when 
                the operation is undone. 
    
    Errors:     -
    SeeAlso:    UndoableOperation::DoSaveCopyOfNode

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

BOOL UndoableOperation::DoSaveCopyOfNodes(Range NodeRange) 
{
    Node* Current = NodeRange.FindFirst();
    BOOL CopiedOK;
    Node* TheCopy;  
    HideNodeAction* UndoHideNodeAction; 
    while (Current != NULL)
    {   
        // Salary check
        if (!Current->IsBounded())
        {
            ERROR3("Current is not a NodeRenderable node");
            continue;
        }

        // Make a copy of Current 
        CALL_WITH_FAIL(Current->NodeCopy(&TheCopy), this, CopiedOK);  
        if (!CopiedOK)
        {
            return FALSE; // No room to take a copy of the node 
        }

        // We need to insert the new node into the tree, but we can't use DoInsertNewNode
        // as this will insert an unwanted NideNode action
        TheCopy->AttachNode(Current, PREV); 
        TheCopy->SetSelected(FALSE); 
        ((NodeRenderableBounded*)TheCopy)->ValidateBoundingRect();
        ((NodeRenderableBounded*)TheCopy)->InvalidateBoundingRect();

        // Hide the copy, creating a ShowNodeAction to show the copy when we undo 
        if (!DoHideNode(TheCopy, 
                        TRUE        // The hidden node is in the operation history
                       )
           )
        {
            return FALSE;   
        } 

        // Create a Hide node action to hide the current node when we undo
        if ( HideNodeAction::Init(this, 
                                  &UndoActions, 
                                  Current, 
                                  FALSE, 
                                  (Action**)(&UndoHideNodeAction))
            == AC_FAIL)  
        {   
            return FALSE;      
        };  
    
        Current = NodeRange.FindNext(Current); 
    }
    return TRUE; 
} 

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

>   BOOL UndoableOperation::DoSaveCopyOfNode(NodeRenderable* Node)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    7/3/94
    Inputs:     Node: 
    Outputs:    -
    Returns:    -
    Purpose:    This fn saves a copy of the node in the operation history. When the operation
                is undone the copy is restored.  
    
    Errors:     -
    SeeAlso:    UndoableOperation::DoSaveCopyOfNodes

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

BOOL UndoableOperation::DoSaveCopyOfNode(NodeRenderable* Node)
{
    ENSURE((!OpFlags.Failed), "Calling a DO function after operation has failed");
    RangeControl        rc( TRUE, TRUE, TRUE ); // All nodes in range
    Range               range( Node, Node, rc );
    return DoSaveCopyOfNodes( range ); 
}

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

>   BOOL UndoableOperation::DoTransformNodes(Range NodeRange, 
                                     TransformBase* Trans)   

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    13/9/93
    Inputs:     Range: The range of nodes to transform 
                Trans: The transform to apply to every node in the range 
    Outputs:    -
    Returns:    TRUE if successful 

                FALSE if the operation should be aborted (TIDYUP THEN CALL End()!) 
                The Trans is deleted. 
                
    Purpose:    This high level Do function applies the transform Trans to each 
                object in the range. 
                
                Don't delete the Trans object, it's deleted in TransformNodeAction slaughter
                method. 
               
    Errors:     -
    SeeAlso:    UndoableOperation::DoTransformNode


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

BOOL UndoableOperation::DoTransformNodes(Range NodeRange, 
                                         TransformBase* Trans)
{
    // If the Trans is invertible then create a Transform node action to undo the transform
    // Note at this point Trans is not the inverse Transformation, but it will be soon !!
//  Node * pParent = NULL;
//  Node * pNodeToTransform = NULL;

    // DMc 17/5/99
    // include the parent nodes in the range if they wish to be transformed with
    // their children by changing the range control flags   
    RangeControl rg = NodeRange.GetRangeControlFlags();
    rg.PromoteToParent = TRUE;
    NodeRange.Range::SetRangeControl(rg);

//  DoInvalidateNodesRegions(NodeRange, TRUE);
    DoInvalidateNodesRegions(NodeRange, TRUE, FALSE, FALSE, FALSE); // Don't forcibly recache (see bHaveTransformedAllCached)

    if (Trans->IsInvertable()) 
    {
        TransformNodeAction* UndoTransformNodeAction; 

        if ( TransformNo