attrappl.cpp

Go to the documentation of this file.

// $Id: attrappl.cpp 1664 2006-08-04 10:06:16Z gerry $
/* @@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============================
 */
// AttrAppl.cpp - Implementation of the OpApplyAttribToSelected class

#include "camtypes.h"

#include "attrappl.h"
//#include "attrmgr.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "document.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "ink.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "lineattr.h"
#include "linwthop.h"
//#include "mario.h"
#include "nodedoc.h"
//#include "simon.h"
//#include "group.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "fillattr.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "app.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "toollist.h"
//#include "will.h"     // for _R(IDS_APPLYTONODEOP)
#include "ndoptmz.h"    // for NodeAttributePtrItem
#include "objchge.h"
//#include "spread.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "progress.h"
#include "fillndge.h"
//#include "txtattr.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "nodetxtl.h"
//#include "jason.h"
#include "colormgr.h"
//#include "bubbleid.h"
#include "nodecont.h"
#include "lineattr.h"
#include "opdrbrsh.h"
#include "brshattr.h"
#include "effects_stack.h"
#include "ophist.h"
//#include "docview.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "nodetext.h"
#include "ppbrush.h"

CC_IMPLEMENT_DYNCREATE(OpApplyAttrib, SelOperation)
CC_IMPLEMENT_DYNCREATE(OpApplyAttribToSelected, OpApplyAttrib)
CC_IMPLEMENT_DYNCREATE(OpApplyAttrInteractive, OpApplyAttrib)
CC_IMPLEMENT_DYNCREATE(OpApplyAttribsToSelected, OpApplyAttrib)
CC_IMPLEMENT_DYNCREATE(OpRepeatApplyAttribToSelected, Operation)
CC_IMPLEMENT_DYNCREATE(OpApplyAttribToNode, OpApplyAttrib)
CC_IMPLEMENT_DYNCREATE(OpReplaceAttributes, SelOperation)
CC_IMPLEMENT_DYNCREATE(ReplaceAttributesParam, OpParam)
CC_IMPLEMENT_MEMDUMP(ApplyAttribsToSelectedParam, OpParam)

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

// Static Fill Blob selection state, used to determine whether or not to
// merge apply ops
FillBlobSelectionState OpRepeatApplyAttribToSelected::FillBlobState;


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

>   NodeRenderableInk * OpApplyAttrib::FindCompoundNodeWhichRequiresAttribute(
                                                                NodeRenderableInk * pStartNode)

    Author:     David_McClarnon (Xara Group Ltd) <camelotdev@xara.com>
    Created:    8/4/2000
    Inputs:     pStartNode : the node to start from
    Outputs:    The compound node which requires the attribute

    Returns:    pStartNode when not finding any appropriate nodes
    Purpose:    When applying an attribute it's necessary to test its parents to see if
                the attribute application should be promoted
                Uses the PromoteAttributeApplicationToMe virtual function in Node to
                discover whether to promote or not
    

********************************************************************************************/
NodeRenderableInk * OpApplyAttrib::FindCompoundNodeWhichRequiresAttribute(
                                                    NodeRenderableInk * pStartNode,
                                                    CCRuntimeClass * pClass)
{
    NodeRenderableInk * pNodeToApply = pStartNode;

    if (!pStartNode->NeedsParent(NULL))
    {
        Node * pParent = pNodeToApply->FindParent();

        while (pParent)
        {
            if (pParent->IsCompoundClass())
            {
                if (((NodeCompound*)pParent)->PromoteAttributeApplicationToMe(pClass))
                {
                    pNodeToApply = (NodeRenderableInk *)pParent;
                }
            }

            // we need to go all the way up the tree to find the top-most node
            pParent = pParent->FindParent();
        }
    }

    return pNodeToApply;
}

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

>   BOOL SelOperation::DoApply(Node* CurrentNode,
                                NodeAttribute* Attrib,
                                BOOL Mutate, 
                                BOOL InvalidateRegion = TRUE
                                BOOL KeepExistingCharacteristics  = TRUE,
                                BOOL* AttribWasRequired = NULL,
                                BOOL* pbCanDiscardUndo = NULL)

    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> 
    Created:    5/4/95
    Inputs:     InvalidateRegion: When TRUE DoInvalidateNodeRegion is called before and
                                  after the attribute has been applied. If the attribute
                                  is being applied to a range of objects then it is 
                                  inefficient to do this.
                KeepExistingCols: When TRUE the new attribute takes on the colour
                                  characteristics of the attribute it is replacing.
    Outputs:    AttribWasRequired:This output is optional. It indicates if  the
                                  Attrib was required by the object.
    Returns:    TRUE if successful 
                FALSE if the operation should be aborted (TIDYUP THEN CALL End()!) 
    Purpose:    
                Will not apply the attribute to CurrentNode if it does not require it
    Errors:     -
    SeeAlso:    NodeRenderableInk::GetObjectToApplyTo

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

BOOL SelOperation::DoApply(Node* CurrentNode, 
                            NodeAttribute* Attrib, 
                            BOOL Mutate, 
                            BOOL InvalidateRegion,
                            BOOL KeepExistingCols, /* = TRUE */
                            BOOL* pbAttribWasRequired,    /* = NULL */
                            BOOL* pbCanDiscardUndo /* = NULL */
                            )
{
    return SelOperation::DoApply(this, CurrentNode, Attrib, Mutate, InvalidateRegion, KeepExistingCols, TRUE, pbAttribWasRequired, pbCanDiscardUndo);
}

BOOL SelOperation::DoApply( SelOperation* pOp,
                            Node* CurrentNode, 
                            NodeAttribute* Attrib, 
                            BOOL Mutate, 
                            BOOL InvalidateRegion,
                            BOOL KeepExistingCols, /* = TRUE */
                            BOOL bOptimise,
                            BOOL* pbAttribWasRequired,    /* = NULL */
                            BOOL* pbCanDiscardUndo /* = NULL */
                            )
{
    BOOL AttributeExists = FALSE;  // Until we find that the attribute does exist

    CCRuntimeClass* AttrType = Attrib->GetAttributeType();
    
    ERROR3IF(!CurrentNode->IsAnObject(), "Trying to apply an attribute to a non-NodeRenderableInk");
    
    // We don't allow attributes like 'Quality' to be applied to objects directly.
    ERROR3IF(!(Attrib->CanBeAppliedToObject()), "Trying to apply an illegal attribute to the object"); 
    
    if (!(Attrib->CanBeAppliedToObject()))
        return TRUE;  // Just pretend they ever tried.

    Node* OriginalCurrentNode = CurrentNode;

    if (CurrentNode->IsAnObject())
    {

        // Obtain the real object to apply the attribute to 
        CurrentNode = ((NodeRenderableInk*)CurrentNode)->GetObjectToApplyTo(Attrib->GetAttributeType()); 
        if (!CurrentNode)
        {
            ERROR3("OpApplyAttrib::DoApply, Unable to find object to apply to");
            return TRUE;
        }
    }

    // NOTE! Better to get the value of this flag here, now that GetObjectToApplyTo has been called
    BOOL bEffectRootOnly = (CurrentNode->IsAnObject() && ((NodeRenderableInk*)CurrentNode)->IsValidEffectAttr(Attrib));

    // If we are applying attributes to the Caret alone then the caller should not retain an undo record
    // for this operation...
    if (pbCanDiscardUndo)
        *pbCanDiscardUndo = *pbCanDiscardUndo && CurrentNode->DiscardsAttributeChildren();

    // BODGE! ------------------------------------------------------------
    // Don't apply stroke transparency as an effect attribute - nothing
    // needs it. Test has to be done here because other objects in the
    // selection might need it...
    if (bEffectRootOnly && AttrType == CC_RUNTIME_CLASS(AttrStrokeTransp))
        return TRUE;
    // END-BODGE! --------------------------------------------------------

    // Needed to support adding triggers, who can be multiply applied
    BOOL AddEvenIfMultiple = FALSE;

    // Do not apply the attribute if CurrentNode does not require it 
    if ((((NodeRenderableInk*)CurrentNode)->RequiresAttrib(Attrib)))
    {

        if (pbAttribWasRequired)
            *pbAttribWasRequired = TRUE;

        if (CurrentNode != OriginalCurrentNode)
        {
            // BODGE TEXT
            // We need to call AllowOp, for the TextStories benefit, 
            // so that lines know they have been affected 

            ObjChangeFlags cFlags;
            cFlags.Attribute = TRUE;
            ObjChangeParam ObjChange(OBJCHANGE_STARTING, cFlags, NULL, pOp);

            if (!CurrentNode->AllowOp(&ObjChange))
            {
                // It's already passed the test once.
                ERROR3("Doing op when no nodes will allow it");
            }
        }
            
        // -----------------------------------------------------------------------------
        // Determine if the current node already has an attribute which is the same 
        // runtime class as Attrib. 
        Node* n = CurrentNode->FindFirstChild(); 
        Node* pLastBoundedNode = NULL;
        if (bEffectRootOnly)
        {
            pLastBoundedNode = CurrentNode->FindLastChild(CC_RUNTIME_CLASS(NodeRenderableBounded));
            ERROR3IF(pLastBoundedNode==NULL, "Attempt to apply effect attr to node with no children");

            if (pLastBoundedNode) n = pLastBoundedNode->FindNext();
        }

        while (n  && (n->IsOrHidesAnAttribute()))
        {
            // Now lets see if we can find an attribute of the same type
            // as the one we are interested in.
            if (n->IsAnAttribute())
            {
                NodeAttribute* pNdAttr = (NodeAttribute*)n;
                 
                if( pNdAttr->GetAttributeType() == AttrType)
                {
                    // Attributes are of the same type (whatever that might mean)

                    // Look for another attribute of the same Type if we're allowed more than
                    // one per object
                    BOOL LookForMultiple = FALSE;

                    if (Attrib->CanBeMultiplyApplied())
                    {
                        // If the classID's are the same then we want to replace the old one
                        // (unless they're identical)
                        if (Attrib->GetAttributeClassID() == pNdAttr->GetAttributeClassID())
                        {
                            LookForMultiple = FALSE;    // stop looking now
                            AddEvenIfMultiple = FALSE;  // replace the old one
                        }
                        else
                        {
                            // they're not the same classID's then we'll add a new one
                            // but keep looking for a duplicate
                            LookForMultiple = TRUE;
                            AddEvenIfMultiple = TRUE;
                        }
                    }
    
                    // Do the attributes have the same value ?. If they do then there is no point in 
                    // applying it a second time

                    // to have the same value they must share the same runtime class
                    if (IS_SAME_CLASS(pNdAttr, Attrib))
                    {
                        // Found an identical attribute, so ignore this apply
                        if ((*pNdAttr)==(*Attrib))
                            return TRUE;     // We are not failing, just doing nothing.

                        if (Attrib->IsABrush())
                            ((AttrBrushType*)Attrib)->OnReplaceAttribute((AttrBrushType*)pNdAttr);
                    }
                    
                    // if applying a brush attribute we must copy some data over
                    if (!LookForMultiple)
                    {
                        AttributeExists = TRUE; 
                        break; 
                    }
                }
            }
            n = n->FindNext(); // Find next child of CurrentNode
        }   

        // >>>> Temporary BODGE to aid select-inside...
        // >>>> ALWAYS clear any attributes of the same type from the subtree (even if the
        // >>>> attribute just applied replaced an existing one) so that dubious
        // >>>> attribute states (due to this routine not dealing with Select-inside
        // >>>> properly yet) can be cleared.
        // >>>> NOTE! the current att (n) is passed in to DoRemoveAttTypeFromSubtree so
        // >>>> that it won't be deleted along with atts of the same type - that would be
        // >>>> (has been) disastrous!
        // Triggers can be multiply applied to groups, so we need to check CanBeMultiplyApplied
        if (CurrentNode->IsCompound() && !Attrib->CanBeMultiplyApplied() && !bEffectRootOnly)
        {
            // Remove all instances of attributes of the same type from the subtree.
            // This is not neccessary if the AttributeExists flag is TRUE because
            // we know in this situation that the subtree cannot contain any other
            // instances of the attribute !.
            if (pOp && !pOp->DoRemoveAttrTypeFromSubtree(CurrentNode, Attrib->GetAttributeType(), n))
            {
                pOp->FailAndExecute(); // Just to make sure
                return FALSE;
            }           
        }

        // At this point we have Either .....
        //      1. Found an attribute of the same type as the new one, and we will
        //         now replace it.
        //      2. Found the specific attribute we were looking for and will replace
        //         that.
        //      3. Found an attribute to mutate.
        //      4. Found no attribute of the correct type, indicating that it has
        //         been factored out, and we need to put a new one in here.
        //      5. The attribute had CanBeMultiplyApplied() set, and no exact same
        //         Attribute was found.
        //
        // Have we have got an Attribute to do something with ?
        NodeAttribute* AttribClone = NULL;
        if ( !AddEvenIfMultiple && n && n->IsAnAttribute())
        {
            // Yes !
            NodeAttribute* pAttr = (NodeAttribute*)n;

            if (Mutate)
            {
                // Mutate it into the new type.
                AttribClone = ((AttrFillGeometry*)n)->Mutate((AttrFillGeometry*)Attrib, bOptimise);
            }
            else
            {
                // We're gunna just replace the attribute with the new one.

                // First make a copy of the new attribute.
                if (pOp)
                    ALLOC_WITH_FAIL(AttribClone ,((NodeAttribute*)Attrib->SimpleCopy()), pOp)
                else
                    AttribClone = (NodeAttribute*)Attrib->SimpleCopy();
                if (AttribClone == NULL)
                    return FALSE; 

                // Complication !!
                // If we are replacing a Fill Attribute and the attribute we are replacing
                // is already filled, then we need to extract the colour of the existing
                // fill and use them for the new fill.
                if ( KeepExistingCols && ((NodeAttribute*)n)->IsAFillAttr() )
                {
                    AttrFillGeometry* NodeReplaced = (AttrFillGeometry*)n;

                    // Copy the old fill characteristics into the new Fill
                    if (!OpApplyAttrib::KeepExistingCharacteristics(NodeReplaced, (AttrFillGeometry*)AttribClone))
                        return FALSE;
                }

                if ( Attrib->IsATranspFill() && Attrib->IsAFlatFill())
                {
                    ((AttrFillGeometry*)n)->RenderFillBlobs();
                }
            }

            // If Mutate returned NULL, which means the Mutate
            // did nothing, we should return TRUE, which will move
            // onto the next object.
            if (AttribClone == NULL)
                return TRUE; 

            // ----------------------------------------------------------
            // If we have just set an effect attribute then we can avoid releasing
            // cached info of the specified node and all its children...
            //
            // We RELY on invalidations associated with this function not
            // calling ReleaseCached themselves!
            //
            ReleaseCachedForAttrApply((NodeRenderableBounded*)CurrentNode, bEffectRootOnly);
            // ----------------------------------------------------------

            if (InvalidateRegion)
            {
                // Invalidate the Object before the attribute is applied
                if (!InvalidateNodeRegion(pOp, (NodeRenderableBounded*)CurrentNode, Attrib, Mutate))    // Doesn't invalidate cached info!
                    return FALSE;
            }

            // Now we have done with the old attribute, so lets hide it, so
            // the changes can be undone
            //
            // Don't write any undo info if we don't have an op or the node
            // discards attributes by itself
            if (pOp && !CurrentNode->DiscardsAttributeChildren())
            {
                // Note that we wouldn't need this test and we wouldn't need
                // to use the HideNode/ShowNode actions here if solid fill
                // dragging used OpApplyAttrInteractive. Instead it uses an
                // older system which relies on the HideNodeAction recording
                // a pointer to an attribute at the start of the drag which
                // is subsequently updated during the drag.
                if (pOp->IsKindOf(CC_RUNTIME_CLASS(OpApplyAttrInteractive)))
                {
                    ApplyAction* pUndoApply; 
                    // Create an action to re-apply the attribute when we undo 
                    if ( ApplyAction::Init(pOp, 
                                            pOp->GetUndoActionList(),
                                            CurrentNode,
                                            pAttr,
                                            TRUE,               // When the attribute gets hidden we
                                                                // must include its size 
                                            (Action**)(&pUndoApply))
                         == AC_FAIL)
                    {
                        return FALSE;
                    }
                    pAttr->CascadeDelete();
                    delete pAttr;
                    pAttr = NULL;
                }
                else
                {
                    if (!pOp->DoHideNode(n, TRUE))          // Include the subtree size 
                        return FALSE;
                }
            }
            else
            {
                pAttr->CascadeDelete();
                delete pAttr;
                pAttr = NULL;
            }

        }
        else  // if (n != NULL)
        {
            // We've not found an attribute to replace, so we'll have to put
            // a new one in
            NodeAttribute* TempAttr = NULL;

            BOOL FoundAttr = ((NodeRenderableInk*)CurrentNode)->
                                FindAppliedAttribute(Attrib->GetAttributeType(), &TempAttr);

            if (!FoundAttr || TempAttr == NULL)
                return FALSE;

            if (Mutate)
            {
                AttribClone = ((AttrFillGeometry*)TempAttr)->Mutate((AttrFillGeometry*)Attrib, bOptimise);
            }
            else
            {
                // We'll just put a copy of our attribute in the tree.
                if (pOp)
                    ALLOC_WITH_FAIL(AttribClone ,((NodeAttribute*)Attrib->SimpleCopy()), pOp)
                else
                    AttribClone = (NodeAttribute*)Attrib->SimpleCopy();

                if ( KeepExistingCols && (TempAttr->IsAFillAttr()) )
                {
                    AttrFillGeometry* NodeReplaced = (AttrFillGeometry*)TempAttr;

                    // Copy the old fill characteristics into the new Fill
                    if (!OpApplyAttrib::KeepExistingCharacteristics(NodeReplaced, (AttrFillGeometry*)AttribClone))
                        return FALSE;
                }

                if (Attrib->IsATranspFill() && Attrib->IsAFlatFill())
                {
                    // If we are mutating into a flat fill, then we need
                    // to make sure we remove any existing fill blobs.
                    ((AttrFillGeometry*)TempAttr)->RenderFillBlobs();
                }
            }

            if (AttribClone)
            {
                ReleaseCachedForAttrApply((NodeRenderableBounded*)CurrentNode, bEffectRootOnly);

                if (InvalidateRegion)
                {
                    // Make sure the node is redrawn
                    if (!InvalidateNodeRegion(pOp, (NodeRenderableBounded*)CurrentNode, Attrib, Mutate))    // Doesn't invalidate cached info!
                        return FALSE;
                }
            }
        }

        // If the AttribClone has the same value as an applied attribute 
        // (A default attr if the attribs have been localised). Then we don't want to apply it !
        if (AttribClone && AttribClone->ShouldBeOptimized() && !bEffectRootOnly && bOptimise)
        {
            NodeAttribute* pAppliedAttr;
            if (((NodeRenderableInk*)CurrentNode)->FindAppliedAttribute(AttribClone->GetAttributeType(), 
                                                  &pAppliedAttr))
            {
                // Do the attributes have the same value ?
                if ((IS_SAME_CLASS(AttribClone, pAppliedAttr)))
                {
                    if ((*AttribClone)==(*pAppliedAttr))
                    {
                        AttribClone->CascadeDelete();       // Delete the attribute

                        // If attribute affect's the bounds of the object (eg. a LineWidth) then invalidate the
                        // bounds of the object

                        if (pAppliedAttr->EffectsParentBounds())
                        {
                            ((NodeRenderableBounded*)CurrentNode)->InvalidateBoundingRect(TRUE);
                        }

                        delete AttribClone;
                        AttribClone = NULL;
                    }
                }
            }
        }

        // Effect attributes don't optimise so if the value of this is the
        // same as the default value we should not add it here
        //
        if (AttribClone && bEffectRootOnly && AttribClone->HasEquivalentDefaultValue() && bOptimise)
        {
            // Just allow the attribute to be hidden
            AttribClone->CascadeDelete();       // Delete the attribute
            delete AttribClone;
            AttribClone = NULL;
        }

        if (AttribClone)
        {
            // Finally !! We can add the new attribute node into the tree.
            if (bEffectRootOnly)
                AttribClone->AttachNode(pLastBoundedNode, NEXT);
            else
                AttribClone->AttachNode(CurrentNode, FIRSTCHILD);

            AttributeManager::pLastNodeAppliedTo = (NodeRenderableInk*)CurrentNode;

            // And now it's in the tree, we need to make sure that any fill control
            // points are valid.
            if (AttribClone->IsAFillAttr())
            {
                ((AttrFillGeometry*)AttribClone)->AttributeChanged();
            }

            if (pOp && !CurrentNode->DiscardsAttributeChildren())
            {
                // Note that we wouldn't need this test and we wouldn't need
                // to use the HideNode/ShowNode actions here if solid fill
                // dragging used OpApplyAttrInteractive. Instead it uses an
                // older system which relies on the HideNodeAction recording
                // a pointer to an attribute at the start of the drag and the
                // contents of the attribute being updated during the drag.
                if (pOp->IsKindOf(CC_RUNTIME_CLASS(OpApplyAttrInteractive)))
                {
                    UnApplyAction* pUndoApply; 
                    // Create an action to hide the attribute when we undo 
                    if ( UnApplyAction::Init(pOp, 
                                              pOp->GetUndoActionList(),
                                              CurrentNode,
                                              AttribClone,
                                              TRUE,             // When the attribute gets hidden we
                                                                // must include its size 
                                             (Action**)(&pUndoApply))
                         == AC_FAIL)
                    {   
                        AttribClone->CascadeDelete();       
                        delete (AttribClone); 
                        return FALSE;  
                    }
                }
                else
                {
                    HideNodeAction* UndoHideNodeAction; 
                    // Create an action to hide the attribute when we undo 
                    if ( HideNodeAction::Init(pOp,
                                              pOp->GetUndoActionList(),
                                              AttribClone,
                                              TRUE,             // When the attribute gets hidden we
                                                                // must include its size 
                                             (Action**)(&UndoHideNodeAction))
                         == AC_FAIL)  
                    {   
                        AttribClone->CascadeDelete();       
                        delete (AttribClone); 
                        return FALSE;  
                    }
                }
            }

        }

        ReleaseCachedForAttrApply((NodeRenderableBounded*)CurrentNode, bEffectRootOnly);

        if (InvalidateRegion)
        {
            // Invalidate the node rectangle, now the new attr has been applied
            if (!InvalidateNodeRegion(pOp, (NodeRenderableBounded*)CurrentNode, Attrib, Mutate))    // Doesn't invalidate cached info!
                return FALSE; 
        }
    }

    // we may have to apply this to a brushed node
    if (pOp)                                                // TODO: Make this work when no undo op specified?
    {
        if (!pOp->ApplyAttributeToBrush(CurrentNode, Attrib))
            return FALSE;
    }
    return TRUE; // success
}




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

>   static BOOL SelOperation::ReleaseCachedForAttrApply(NodeRenderableBounded* pNode, BOOL bEffectRootOnly) 

    Author:     Phil_Martin (Xara Group Ltd) <camelotdev@xara.com>
    Created:    08/03/2005
    Inputs:     pCurrentNode    - the node that the attribute is being applied to 
                bEffectRootOnly - TRUE if
    Returns:    TRUE if all ok.
    Purpose:    If we have just set an effect attribute then we can avoid releasing
                cached info of the specified node and all its children...
                We RELY on invalidations associated with this function not
                calling ReleaseCached themselves!
    Errors:     -
    SeeAlso:    -

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

BOOL SelOperation::ReleaseCachedForAttrApply(NodeRenderableBounded* pNode, BOOL bEffectRootOnly)
{
    if (bEffectRootOnly)
        pNode->ReleaseCached(TRUE, FALSE, FALSE, TRUE);                     // Parents and Derived data only
    else
        pNode->ReleaseCached();                                             // Self, Parents, Children and derived data

    return TRUE;
}




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

>       BOOL SelOperation::ApplyAttributeToBrush(Node* pCurrentNode, NodeAttribute* pAttr) 
                        

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Created:    24/2/2000
    Inputs:     pCurrentNode - the node that the attribute is being applied to 
                pAttr        - the attribute to apply
    Returns:    TRUE if all ok.
    Purpose:    Works out if pCurrentNode has an applied brush attribute, and if so then sets
                up an action to tell the brush to use the attribute being applied.
    Errors:     -
    SeeAlso:    -

    Notes:      This is only currently operational for fill attributes, others may be added
                in future.
                18/4/2000 - Line widths added
********************************************************************************************/

BOOL SelOperation::ApplyAttributeToBrush(Node* pCurrentNode, NodeAttribute* pAttr)
{
    ERROR2IF(pCurrentNode == NULL, FALSE, "Current node is NULL");
    ERROR2IF(pAttr == NULL, FALSE, "Attribute is NULL");
    
    // currently this only works for colour changes and transparent fills
    if (!pAttr->IsKindOf(CC_RUNTIME_CLASS(AttrStrokeColourChange)) && !pAttr->IsATranspFill()
        && !pAttr->IsKindOf(CC_RUNTIME_CLASS(AttrLineWidth)) && !pAttr->IsABrush())
        return TRUE;
    
    // first get the existing brush attribute
    AttrBrushType* pAttrBrush = NULL;
    // for some reason we don't check the return value here??
    /*BOOL ok =*/ ((NodeRenderableInk*)pCurrentNode)->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrBrushType),
                                                                        (NodeAttribute**)&pAttrBrush);

    // if we're applying a brush attribute then do something else
    if (pAttr->IsABrush())
    {
        AttrBrushType* pNewAttrBrush = (AttrBrushType*)pAttr;
        return ApplyBrushAttr(pCurrentNode, pNewAttrBrush);
    }


    // there isn't one - thats ok
    if (pAttrBrush == NULL || pAttrBrush->GetBrushHandle() == BrushHandle_NoBrush)
        return TRUE;

    // so now we have a brush attribute, so lets determine what to do:
    if (pAttr->IsKindOf(CC_RUNTIME_CLASS(AttrStrokeColourChange)))
    {
        // only do this is the new colour is not transparent
        AttrStrokeColourChange* pStrokeCol = static_cast<AttrStrokeColourChange*>(pAttr);
        DocColour* pCol = pStrokeCol->GetStartColour();
//PORTNOTE("other","Removed DocColour usage") - AMB Unremoved
        if (pCol->IsTransparent())
            return TRUE;

        return ApplyStrokeColourToBrush(pAttrBrush, (NodeRenderableInk*)pCurrentNode);
    }

// Is this a porting comment-out? AMB
//  if (pAttr->IsATranspFill())
//      return ApplyTransparencyToBrush(pAttrBrush, (NodeRenderableInk*)pCurrentNode);
    if (pAttr->IsKindOf(CC_RUNTIME_CLASS(AttrLineWidth)))
        return ApplyLineWidthToBrush(pAttrBrush, (NodeRenderableInk*)pCurrentNode, pAttr);

    // trash the cached bounding rect
    pAttrBrush->ClearCachedRect();

    // if it isn't one of the above then we dont have to do anything
    return TRUE;
}

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

>   BOOL SelOperation::ApplyTransparencyToBrush(AttrBrushType* pAttrBrush, NodeAttribute* pAttr) 
                        

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Created:    24/2/2000
    Inputs:     pAttrBrush   - the brush attribute that we wish to update
                pAttr        - the attribute to apply
    Returns:    TRUE if all ok.
    Purpose:    When a transparency is applied to a brushed object we need to set a flag
                in the brush to tell it to use this new transparency
********************************************************************************************/

BOOL SelOperation::ApplyTransparencyToBrush(AttrBrushType* pAttrBrush, NodeRenderableInk* pBrushedNode)
{
    ERROR2IF(pAttrBrush == NULL, FALSE, "Attribute pointer is NULL in OnApplyAttrib::ApplyTransparencyToBrush");
    ERROR2IF(pBrushedNode == NULL, FALSE,  "Attribute pointer is NULL in OnApplyAttrib::ApplyTransparencyToBrush");

    // make the OpParam
    ChangeBrushOpParam Param;

    Param.ChangeType = CHANGEBRUSH_USELOCALTRANSP;
    Param.m_bNewUseLocalTransp = TRUE;
    ChangeBrushAction* pAction = NULL;
    // initialise the action
    if (ChangeBrushAction::Init(this, &UndoActions, pBrushedNode, &Param, &pAction) == AC_FAIL)
        return FALSE;

    return TRUE;
}
/********************************************************************************************

>   BOOL SelOperation::ApplyStrokeColourToBrush(AttrBrushType* pAttrBrush,NodeRenderableInk* pBrushedNode) 
                        

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Created:    24/2/2000
    Inputs:     pAttrBrush   - the brush attribute that we wish to update
                pbrushed node   - the node that the brush applies to
    Returns:    TRUE if all ok.
    Purpose:    When a new stroke colour is applied to a brushed object we wish to set the
                flag that tells the brush to override the named colours in the brush with
                the colour applied

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

BOOL SelOperation::ApplyStrokeColourToBrush(AttrBrushType* pAttrBrush, NodeRenderableInk* pBrushedNode)
{
    ERROR2IF(pAttrBrush == NULL, FALSE, "Attribute pointer is NULL in OnApplyAttrib::ApplyStrokeColourToBrush");
    ERROR2IF(pBrushedNode == NULL, FALSE,  "Attribute pointer is NULL in OnApplyAttrib::ApplyStrokeColourToBrush");

    
    

    // if the brush already uses local colours then don't bother doing anything
    PathProcessorBrush *pPPB = pAttrBrush->GetPathProcessor();
    if (pPPB == NULL)
        return TRUE;

    if (pPPB->GetUseLocalFillColour() || !pPPB->GetUseNamedColours())
        return TRUE;

    // make the OpParam
    ChangeBrushOpParam Param;

    Param.ChangeType = CHANGEBRUSH_USENAMEDCOL;
    Param.m_bNewUseNamed = FALSE;
    ChangeBrushAction* pAction = NULL;
    // initialise the action
    if (ChangeBrushAction::Init(this, &UndoActions, pBrushedNode, 
                            &Param, &pAction) == AC_FAIL)
        return FALSE;

    return TRUE;
}



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

>   BOOL SelOperation::ApplyLineWidthToBrush(AttrBrushType* pAttrBrush, NodeRenderableInk* pBrushedNode,
                                NodeAttribute* pAttr) 
                        

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Created:    24/2/2000
    Inputs:     pAttrBrush   - the brush attribute that we wish to update
                pBrushedNode   -the node that the brush applies to
                pAttr      - the line width that we are applying
    Returns:    TRUE if all ok.
    Purpose:    If we are applying a line width to a brushed node we need to tell the brush that
                it must scale to line width.
                We must also do an additional invalidate region so that if we are increasing in
                size then the brush will be rerendered properly
********************************************************************************************/

BOOL SelOperation::ApplyLineWidthToBrush(AttrBrushType* pAttrBrush, NodeRenderableInk* pBrushedNode,
                                          NodeAttribute* pAttr)
{
    ERROR2IF(pAttrBrush == NULL, FALSE, "Attribute pointer is NULL in OnApplyAttrib::ApplyLineWidthToBrush");
    ERROR2IF(pBrushedNode == NULL, FALSE,  "Node pointer is NULL in OnApplyAttrib::ApplyLineWidthToBrush");
    ERROR2IF(pAttr == NULL, FALSE, "Attribute pointer is NULL in OnApplyAttrib::ApplyLineWidthToBrush");

    // if we are on a closed path then ask the PPB to even out the spacing
    PathProcessorBrush* pPPB = pAttrBrush->GetPathProcessor();
    if (pPPB != NULL)
    {
        // scale to the new line width
        AttrLineWidth* pLineWidth = (AttrLineWidth*)pAttr;
        BOOL UsesPressure = pAttrBrush->GetPressureCache() != NULL;
        pPPB->ScaleToValue(pLineWidth->Value.LineWidth, !UsesPressure);
        pPPB->AdjustSpacingForClosedPath(pBrushedNode);
    }

    return TRUE;
}



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

>BOOL SelOperation::ApplyBrushAttr(Node* pCurrentNode, AttrBrushType* pAttrBrush)
                        

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Created:    24/2/2000
    Inputs:     pCurrentNode - the node we are applying the brush to
                pAttrBrush   - the brush attribute we are applying
    Returns:    TRUE if all ok.
    Purpose:    When we apply a brush attribute to an object we want to check to see if the
                current line width attribute is the same as the default attribute.  If it is then
                we will apply the default line width suggested by the brush itself.
                This is because people keep on applying brush attributes to 500MP lines
                and ending up with thousands of brush objects, which makes everything really slow.
********************************************************************************************/

BOOL SelOperation::ApplyBrushAttr(Node* pCurrentNode, AttrBrushType* pAttrBrush)
{
    ERROR2IF(pCurrentNode == NULL || pAttrBrush == NULL, FALSE, "Null input pointers to OpApplyAttrib::ApplyBrushAttr");
    ERROR2IF(!pCurrentNode->IsAnObject(), FALSE, "Input node is not an ink node in OpApplyAttrib::ApplyBrushAttr");

    // its too complicated when you have compound nodes
    if (pCurrentNode->IsCompound())
        return TRUE;

    AttrLineWidth* pCurrentLineWidth = NULL;
    ((NodeRenderableInk*)pCurrentNode)->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrLineWidth), (NodeAttribute**)&pCurrentLineWidth);
    
    if (pCurrentLineWidth != NULL)
    {
        // Get the default line width
        AttrLineWidth* pDefault = (AttrLineWidth*)(AttributeManager::GetDefaultAttribute(ATTR_LINEWIDTH));
        if (pDefault == NULL)
        {
            ERROR3("Unable to get default line width, theres no way this can happen Jim!");
            // continue anyway
        }
        else
        {
            // check to see if default is the same as current, if not then just leave
            if (pCurrentLineWidth->Value.LineWidth != pDefault->Value.LineWidth-1)
            {
                delete pDefault;
                PathProcessorBrush* pPPB = pAttrBrush->GetPathProcessor();
                if (pPPB)
                {
                    BOOL UsesPressure = pAttrBrush->GetPressureCache() != NULL;
                    pPPB->ScaleToValue(pCurrentLineWidth->Value.LineWidth, !UsesPressure);
                    pPPB->AdjustSpacingForClosedPath((NodeRenderableInk*)pCurrentNode);
                }

                return TRUE;
            }
            delete pDefault;
        }
    }


    // otherwise we want a new line width attribute
    MILLIPOINT LineWidth = pAttrBrush->GetDefaultLineWidth(TRUE);
    
    //DoApply makes a copy so we only need to make this local
    AttrLineWidth NewLineWidth;

    NewLineWidth.Value.LineWidth = LineWidth;

    // now apply it
    return DoApply(pCurrentNode, &NewLineWidth, FALSE, FALSE);
    
}

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

>   static BOOL OpApplyAttrib::KeepExistingCharacteristics(AttrFillGeometry* OldAttr, 
                                                    AttrFillGeometry* NewAttr)

    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    6/6/95
    Inputs:     -
    Returns:    TRUE if all ok.
    Purpose:    Retains the previous fill charateristics when applying a new fill.
    Errors:     -
    SeeAlso:    -

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

BOOL OpApplyAttrib::KeepExistingCharacteristics(AttrFillGeometry* OldAttr, 
                                                AttrFillGeometry* NewAttr)
{
    NewAttr->SetStartTransp(OldAttr->GetStartTransp());
    NewAttr->SetEndTransp(OldAttr->GetEndTransp());

    NewAttr->SetTranspType(OldAttr->GetTranspType());

    if (OldAttr->IsAFlatFill())
    {
        if (OldAttr->FindParent()->IsNodeDocument())
        {
            // If the applied attr is the default fill at the top of the tree,
            // then we need to 'bodge' it to be black.
            DocColour DefFillCol;
            AttributeManager::FindDefaultColour(ColourManager::GetCurrentColourList(),
                                                _R(IDS_BLACKNAME), &DefFillCol);
            NewAttr->SetEndColour(&DefFillCol);
        }
        else
            NewAttr->SetEndColour(OldAttr->GetStartColour());
    }
    else
    {
        NewAttr->SetStartColour(OldAttr->GetStartColour());
        NewAttr->SetEndColour(OldAttr->GetEndColour());
    }

    NewAttr->SetTesselation(OldAttr->GetTesselation());
    NewAttr->AttachBitmap(OldAttr->GetBitmap());

    if (OldAttr->IsAFractalFill())
    {
        NewAttr->SetSeed(OldAttr->GetSeed());
        NewAttr->SetGraininess(OldAttr->GetGraininess());
        NewAttr->SetGravity(OldAttr->GetGravity());
        NewAttr->SetSquash(OldAttr->GetSquash());
        NewAttr->SetTileable(OldAttr->GetTileable());
        NewAttr->SetFractalDPI(AttrFillGeometry::FractalDPI);
        NewAttr->RecalcFractal();
    }

    return TRUE;
}

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

>   BOOL SelOperation::InvalidateNodeRegion(    SelOperation* pOp,
                                                NodeRenderableBounded* CurrentNode, 
                                                NodeAttribute* Attrib, 
                                                BOOL Mutate)
    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    6/6/95
    Inputs:     -
    Returns:    TRUE if region invalidated ok.
    Purpose:    Invalidates the Bounds of a Node.
    Errors:     -
    SeeAlso:    -

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

BOOL SelOperation::InvalidateNodeRegion(    SelOperation* pOp,
                                            NodeRenderableBounded* CurrentNode, 
                                            NodeAttribute* Attrib, 
                                            BOOL Mutate)
{
    // Include the blobs, if the attribute will change the parents bounds.
    BOOL IncludeBlobs = Attrib->EffectsParentBounds();

    if ( (Mutate && !Attrib->IsAValueChange()) ||
         Attrib->GetRuntimeClass() == CC_RUNTIME_CLASS(AttrBitmapDpiChange) )
    {
        // Check for special cases of, either a mutate from one fill type to another,
        // or a dpi change.  Both of these can change the blob bounds.
        IncludeBlobs = TRUE;
    }

    // Invalidate the bounds of the node, including the blobs if necessary.
    if (pOp)
    {
        if (!pOp->DoInvalidateNodeRegion(CurrentNode, IncludeBlobs, FALSE, FALSE, FALSE))   // NOTE! We do not release cached info!
                                                                                        // Must be used in conjunction with ApplyToSelection
        {
            // Summit went wrong.
            return FALSE;
        }
    }
    else
    {
        BaseDocument* pBaseDoc = CurrentNode->FindOwnerDoc();
        if (pBaseDoc && pBaseDoc->IsKindOf(CC_RUNTIME_CLASS(Document)))
        {
            Document* pDoc = (Document*)pBaseDoc;
            Spread* pSpread = (Spread*)CurrentNode->FindParent(CC_RUNTIME_CLASS(Spread));
            DocRect TempRect; 
            TempRect = (IncludeBlobs ? 
                            (CurrentNode->GetUnionBlobBoundingRect()):
                            (CurrentNode->GetBoundingRect())
                         );
            TempRect = TempRect.Union(CurrentNode->GetEffectStackBounds());
            pDoc->ForceRedraw(pSpread, TempRect, TRUE, CurrentNode, FALSE);
        }
    }

    return TRUE;    // All ok
}

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

>   BOOL OpApplyAttrib::DoInvalidateRegions(Range* NodeRange, 
                                            NodeAttribute* Attrib, 
                                            BOOL Mutate, 
                                            NodeAttribute* OtherAttr,
                                            BOOL OtherMuate)
    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    10/6/95