opbarcreation.cpp

Go to the documentation of this file.

// $Id: opbarcreation.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============================
 */
/*
    $Header: /Camelot/kernel/OpBarCreation.cpp 44    26/05/05 15:49 Luke $
*/

#include "camtypes.h"
#include "opbarcreation.h"
//#include "simon.h"
//#include "resource.h"

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

#include "slice.h"

//#include "cxfrech.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "userattr.h"
#include "tmpltatr.h"

#include "progress.h"
//#include "fillval.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "fillattr.h" - in camtypes.h [AUTOMATICALLY REMOVED]


// bevel stuff for playing with light angles
#include "nbevcont.h"
#include "attrbev.h"
#include "opbevel.h"

// name set stuff
#include "ngcore.h"
#include "ngitem.h"
#include "ngprop.h"
#include "ngsentry.h"

#include "layermsg.h"   // the layer messaging
#include "sprdmsg.h"    // SpreadMsg

#include "slicehelper.h"
//#include "sliceres.h"

#include "fillramp.h"   // for ColRampItem
#include "objchge.h" // for the allow op flags

#include "extender.h"
#include "nodetxts.h"

#include "nodetxts.h"
#include "nodetxtl.h"
#include "nodetext.h"
#include "nodecntr.h"

#include "page.h"

#include "extender.h"

// need to know about shadows and bevels since they size funny for the GetNodeBounding()
#include "nodeshad.h"

#include "opdupbar.h" // for the showlayer stuff

#include "nodeblnd.h"

#ifdef _DEBUG
#undef THIS_FILE
static char BASED_CODE THIS_FILE[] = __FILE__;
#endif

DECLARE_SOURCE("$Revision: 1282 $");

CC_IMPLEMENT_DYNCREATE(OpBarCreation, CarbonCopyOp)

#define new CAM_DEBUG_NEW


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

>   OpClone::OpBarCreation() 

    Author:     Simon_Knight (Xara Group Ltd) <camelotdev@xara.com>
    Created:    27/8/99
    Purpose:    OpBarCreation constructor
    Errors:     -
    SeeAlso:    CarbonCopyOp

********************************************************************************************/            
OpBarCreation::OpBarCreation(): CarbonCopyOp()                              
{                              
}



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

>   BOOL OpBarCreation::Init()

    Author:     Simon_Knight (Xara Group Ltd) <camelotdev@xara.com>
    Created:    27/8/99
    Returns:    TRUE if the operation could be successfully initialised 
                FALSE if no more memory could be allocated 
    Purpose:    OpBarCreation initialiser method
    Errors:     ERROR will be called if there was insufficient memory to allocate the 
                operation.
    SeeAlso:    -

********************************************************************************************/
BOOL OpBarCreation::Init()
{
    return  (RegisterOpDescriptor(0,
                                _R(IDS_BARCREATIONOP),
                                CC_RUNTIME_CLASS(OpBarCreation),
                                OPTOKEN_BARCREATIONOP,
                                OpBarCreation::GetState,
                                0,                  // help ID 
                                _R(IDBBL_BARCREATIONOP),// bubble help
                                0,                  // resource ID
                                0, //_R(IDC_BC_CREATE),     // control ID
                                SYSTEMBAR_ILLEGAL,  // Bar ID
                                TRUE,               // Receive messages
                                FALSE,
                                FALSE,
                                0,
                                (GREY_WHEN_NO_CURRENT_DOC) ));
}



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

>   OpState OpBarCreation::GetState(String_256*, OpDescriptor*)

    Author:     Simon_Knight (Xara Group Ltd) <camelotdev@xara.com> based on Jason
    Created:    27/8/99
    Returns:    The state of the OpBarCreation
    Purpose:    For finding the operations state.  

********************************************************************************************/
OpState OpBarCreation::GetState(String_256* UIDescription, OpDescriptor *Bob)
{
    OpState OpSt;

    // if we don't allow it
    OpSt.Greyed = TRUE;
    Spread* pSpread = Document::GetSelectedSpread();
    if (pSpread && !pSpread->FindActiveLayer()->IsFrame())
        OpSt.Greyed = FALSE;

    return(OpSt);   
}

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

>   void OpBarCreation::DoWithParam(OpDescriptor* token, OpParam* pOpParam)

    Author:     Simon_Knight (Xara Group Ltd) <camelotdev@xara.com>
    Created:    27/8/99
    Inputs:     OpParam - describes the number of buttons, what layers to create, any mutation
    Outputs:    -
    Returns:    -
    Purpose:    Creates a navigation rollover bar in the drawing by copying the selection
                several times unto named layers, and naming each copy of the selection.
    Errors:     -
    SeeAlso:    OpBarCreation::DoWithParam, CarbonCopyOp::DoProcessing

********************************************************************************************/   
void OpBarCreation::DoWithParam(OpDescriptor* token, OpParam* pOpParam)
{
    // start the op
    if (pOpParam != NULL && DoStartSelOp(FALSE,TRUE))
    {
        // do the biz
        // create or edit the bar depending on the params
        BOOL ok = TRUE;
        
        // touch the bar in question
        NameGallery * pNameGallery = NameGallery::Instance();
        if (pNameGallery)
        {
            pNameGallery->m_TouchedBar = SliceHelper::GetBarNumberFromBarName(((OpParamBarCreation*)pOpParam)->m_BarName);
        }

        if (((OpParamBarCreation*)pOpParam)->m_DelExistingState)
        {
            INT32 NewLayerNo = 0;

            if (((OpParamBarCreation*)pOpParam)->m_WantMouse)
                NewLayerNo = 1;
            else if (((OpParamBarCreation*)pOpParam)->m_WantClicked)
                NewLayerNo = 2;
            else if (((OpParamBarCreation*)pOpParam)->m_WantSelected)
                NewLayerNo = 3;

            // delete elements in this state before we create it
            OpDelBar::DelBar(((OpParamBarCreation*)pOpParam)->m_BarName, NewLayerNo, this);
        }

        if (((OpParamBarCreation*)pOpParam)->m_WantBackBar)
        {
            // want to build the bar and the backbar at once!!!
            if (((OpParamBarCreation*)pOpParam)->m_WantDefault)
                ok = CreateBarAndBackBar(pOpParam); // generates its own warnings if required
            else
            {
                ok = CreateBackBarFromSelection(pOpParam);
                if (ok)
                    InformMessage(_R(IDS_BACKBAR_CREATED_OK));
                else
                    InformWarning(_R(IDS_FAILLED_MAKE_BACKBAR));
            }
        }
        else
        {
            if (((OpParamBarCreation*)pOpParam)->m_FromSelection)
                ok = CreateOrEditBar(pOpParam);
            else
                ok = CreateFromDefaultState(pOpParam);

            if (!ok)
                InformWarning(_R(IDS_FAILLED_MAKE_BAR));
        }

        if (!ok)
            FailAndExecute();

        // end the op
        End();

        // update the bars
        DialogBarOp::SetSystemStateChanged();
        DialogBarOp::UpdateStateOfAllBars(); 
    }
    else
    {
        // give up and go home
        FailAndExecute();
        End();
    }
}

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

>   BOOL OpBarCreation::CreateOrEditBar (OpParam* pOpParam)

    Author:     Simon_Knight (Xara Group Ltd) <camelotdev@xara.com>
    Created:    27/8/99 - re-writen 17/4/00
    Inputs:     OpParam - describes the number of buttons, what layers to create, any mutation
    Outputs:    -
    Returns:    TRUE on success, FALSE on failure
    Purpose:    Creates a navigation rollover bar in the drawing by copying the selection
                several times unto named layers, and naming each copy of the selection.
    Errors:     -
    SeeAlso:    OpBarCreation::DoWithParam

********************************************************************************************/   
BOOL OpBarCreation::CreateOrEditBar (OpParam* pOpParam)
{
    String_256 ActiveLayerStr(_R(IDS_ROLLOVER_DEFAULT));
    Spread* pSpread = Document::GetSelectedSpread();
    if (pSpread)
    {
        ActiveLayerStr = pSpread->FindActiveLayer()->GetLayerID();
    }

    OpParamBarCreation* pBarParam = (OpParamBarCreation*)pOpParam;
    if (pBarParam->m_NoOfButtons > MAX_BUTTONS_IN_A_BAR)
        return FALSE; // too many buttons requested

    // get the name of this bar
    m_BarName = pBarParam->m_BarName;
    INT32 BarNo = SliceHelper::GetBarNumberFromBarName(m_BarName);

    // set up the layer names
    m_RolloverName[DEFAULT].Load(_R(IDS_ROLLOVER_DEFAULT)); // = "Default";
    m_RolloverName[MOUSE].Load(_R(IDS_ROLLOVER_MOUSE)); // = "Mouse";
    m_RolloverName[CLICKED].Load(_R(IDS_ROLLOVER_CLICKED)); // = "Clicked";
    m_RolloverName[SELECTED].Load(_R(IDS_ROLLOVER_SELECTED)); // = "Selected";
    m_RolloverName[BACKBAR].Load(_R(IDS_BACK_BAR)); // = "Back Bar";

    INT32 NewLayerNo = 0;

    if (pBarParam->m_WantMouse)
        NewLayerNo = 1;
    else if (pBarParam->m_WantClicked)
        NewLayerNo = 2;
    else if (pBarParam->m_WantSelected)
        NewLayerNo = 3;

    List SelectionList; // list of nodes we are copying to each point
    List DelList;       // list of nodes we no longer have any use for
    Node * pNode = NULL;

    // get the selection
    Range Sel(*(GetApplication()->FindSelection()));

    // set the range flags so it includes shadow and bevel manager nodes
    RangeControl rg = Sel.GetRangeControlFlags();
    rg.PromoteToParent = TRUE;
    Sel.Range::SetRangeControl(rg);

    // remove any quickshape objects from the selection
    if (Extender::ConvertQuickShapesInSelRangeToPaths(this, &Sel))
    {
        Sel = *(GetApplication()->FindSelection());
        rg = Sel.GetRangeControlFlags();
        rg.PromoteToParent = TRUE;
        Sel.Range::SetRangeControl(rg);
    }

    if (Sel.IsEmpty())
    {
        InformWarning(_R(IDS_WARNING_NO_SEL_TEMPLATE));
        return FALSE;
    }
    
    // Prepare an ObjChangeParam so we can mark which nodes will allow this op to happen to them
    ObjChangeFlags cFlags;
    cFlags.MultiReplaceNode = TRUE;
    cFlags.RegenerateNode = TRUE;
    ObjChangeParam ObjChange(OBJCHANGE_STARTING,cFlags,NULL,this);

    // Mark nodes that will allow this to happen, and error if no nodes will let it happen
    if (!Sel.AllowOp(&ObjChange))
        return FALSE; // op not allowed

    // modify the selection to the allowed constraints
    // use the selection list from now on
    CleanSelection (&Sel, &SelectionList, &DelList, NewLayerNo);

    if (SelectionList.IsEmpty())
    {
        InformWarning(_R(IDS_WARNING_NO_SEL_TEMPLATE));
        return FALSE;
    }

    // create the new layer
    Layer * pNewLayer = AddLayer(m_RolloverName[NewLayerNo], NewLayerNo);
    
    if (!pNewLayer)
        return FALSE;

    // mark the existing back bar for deletion if not in the selection
    SliceHelper::BuildListOfNodesInBar(&DelList, pNewLayer, m_BarName);

    // the deletion list should be of the actual nodes not the attribs as these
    // can get removed in the process
    NodeListItem * pNodeListItem = (NodeListItem *)DelList.GetHead();

    while(pNodeListItem)
    {
        Node *pParent = pNodeListItem->pNode;

        // if it is the template attrib we are looking at
        // we mean the node on which it is attached
        if (IS_A(pParent, TemplateAttribute))
        {
            pParent = pParent->FindParent();
            pNodeListItem->pNode = pParent;
        }

        // if it is under a bevel or shadow or something look at the top node of the compound thing
        while (!IS_A(pParent->FindParent(), NodeGroup) && !pParent->FindParent()->IsLayer())
        {
            pParent = pParent->FindParent();
            pNodeListItem->pNode = pParent;
        }

        pNodeListItem = (NodeListItem *)DelList.GetNext(pNodeListItem);
    }

    // get the size of the selection
    DocRect SelRect;
    SelRect.MakeEmpty();
    DocRect FullSelRect;
    FullSelRect.MakeEmpty();
    
    // localise all the attribs in the selection list
    pNodeListItem = (NodeListItem *)SelectionList.GetHead();

    while(pNodeListItem)
    {
        // localise attribs for this node
        DoLocaliseForAttrChange((NodeRenderableInk*) pNodeListItem->pNode, (AttrTypeSet *)NULL, (ObjectSet*) NULL);

        // calc the size of this node as part of the size of the selection
        SelRect = SelRect.Union(SliceHelper::BoundingNodeSize(pNodeListItem->pNode));
        if (IS_A(pNodeListItem->pNode, NodeShadowController) || IS_A(pNodeListItem->pNode, TextStory))
            FullSelRect = FullSelRect.Union(SliceHelper::BoundingNodeSize(pNodeListItem->pNode));
        else
            FullSelRect = FullSelRect.Union(((NodeRenderableBounded*)(pNodeListItem->pNode))->GetBoundingRect());

        pNodeListItem = (NodeListItem *)SelectionList.GetNext(pNodeListItem);
    }

    // find the center of the selection
    DocCoord SelCentre = SelRect.Centre();

    // not used by this function but set it up for later
    m_BarSelectionRect = SelRect;
    m_FinishedBarRect.MakeEmpty();


    // Matt - 20/12/2000
    // We wish you a Merry Christmas, We wish you a Merry Christmas, We wish you a Merry Christmas and a Happy New Year... That'll be 10p guv...
    // Find out whereabouts the centre of each button ON THIS LAYER was previously if we have a user positioned bar or LiveStretching is OFF
    // This is so that in these cases, when the user chooses 'Set New Design' we know the location and do not reposition/misalign things !!!
    BOOL LiveStretching = FALSE;
    BOOL IgnoreSettings = FALSE;
    INT32 m_ExistingButtonsInBar = 0;
    DocCoord oldbuttoncentres[MAX_BUTTONS_IN_A_BAR];
    TemplateAttribute ** m_ppFoundButton[MAX_BUTTONS_IN_A_BAR];
    for (INT32 temp = 0; temp < MAX_BUTTONS_IN_A_BAR; temp++)
    {
        m_ppFoundButton[temp] = NULL;
    }

    SliceHelper::CountButtonsInBarScan(pNewLayer, (TemplateAttribute **) m_ppFoundButton, &m_ExistingButtonsInBar, m_BarName);

    NodeBarProperty* pNodeBarProperty = (NodeBarProperty*) Document::GetCurrent()->GetSetSentinel()->FindBarProperty();
    BarDataType NewBarData = pNodeBarProperty->Bar(BarNo);
    if (pNodeBarProperty  && BarNo < pNodeBarProperty->HowMany())
    {
        LiveStretching = NewBarData.IsLive;
    }

    if (!LiveStretching || !NewBarData.RequiresShuffle)
    {
        // We need to get all nodes that are on this layer, for each of the buttons of this bar (in turn) - then we need to find out their bounding box in order
        // to record their centre position - this may take a while...

        for (INT32 i = 0; i < pBarParam->m_NoOfButtons; i++)
        {
            List * pList = new List;
            DocRect ButtonRect;
            ButtonRect.MakeEmpty();

            if (!((TemplateAttribute *) m_ppFoundButton[i]))
            {
                IgnoreSettings = TRUE;
                i = pBarParam->m_NoOfButtons;
            }
            else
            {
                SliceHelper::BuildListOfNodesInButton(pList, pNewLayer, ((TemplateAttribute *) m_ppFoundButton[i])->GetParam());

                NodeListItem * pNodeListItem = NULL;
                if (pList)
                {
                    pNodeListItem = (NodeListItem *)pList->GetHead();
                }

                while(pNodeListItem)
                {
                    // localise attribs for this node
                    DoLocaliseForAttrChange((NodeRenderableInk*) pNodeListItem->pNode, (AttrTypeSet *)NULL, (ObjectSet*) NULL);
                    ButtonRect = ButtonRect.Union(SliceHelper::BoundingNodeSize(pNodeListItem->pNode));

                    pNodeListItem = (NodeListItem *)pList->GetNext(pNodeListItem);
                }

                oldbuttoncentres[i] = ButtonRect.Centre();

                pList->DeleteAll();
                delete pList;
            }
        }
    }




    // *** Calculate the properties needed to be added to the buttons for stretching *** 

    // set up the target and extender strs by scanning the selection
    String_256  Target = ""; // the button name of the selection
    String_256  Extender = ""; // the thing in this button that extends it
    BOOL        MakeItStretch = TRUE; // nothing stretched before - but I want it to stretch using button text
    BOOL        TextStoryInSelection = FALSE;
    BYTE        ExtenderFlags = 0; // the way the buttons will extend

    DocRect TargetRect;
    DocRect ExtenderRect;
    DocRect TextRect;
    DocRect NoTextRect;

    // find the Target, extender and if there are any text stories in the selection
    pNodeListItem = (NodeListItem *)SelectionList.GetHead();
    Node * pTextStory = NULL;

    INT32 RequiredLevel = 0;
    while (pNodeListItem && RequiredLevel < 2)
    {
        Node * pCurrent = pNodeListItem->pNode;

        RequiredLevel = SliceHelper::FindTargetAndExtender(pCurrent, Target, Extender, RequiredLevel, &ExtenderFlags,
                                                            &TargetRect, &ExtenderRect);
        pTextStory = SliceHelper::FindNextOfClass(pCurrent, pCurrent, CC_RUNTIME_CLASS(TextStory), TRUE);
        if (pTextStory)
        {
            TextStoryInSelection = TRUE;
            TextRect = TextRect.Union(SliceHelper::BoundingNodeSize(pCurrent));

            // warn if there are any grouped text stories and fail
            while (!pTextStory->IsLayer())
            {
                if (IS_A(pTextStory, NodeGroup)) //cant call ->IsAGroup() since shadows say yes!
                {
                    InformWarning(_R(IDS_WARNING_GROUPED_TEXT));
                    SelectionList.DeleteAll();
                    DelList.DeleteAll();
                    return FALSE;
                }
                pTextStory = pTextStory->FindParent();
            }

        }
        else
            NoTextRect = NoTextRect.Union(SliceHelper::BoundingNodeSize(pCurrent));


        pNodeListItem = (NodeListItem *)SelectionList.GetNext(pNodeListItem);
    }

    // for this level we copy the stretch data across rather than "make it stretch"
    // or if there is no text story then it we can't use the "make it stretch"
    if (RequiredLevel > 1 || !TextStoryInSelection || NoTextRect.IsEmpty())
        MakeItStretch = FALSE;

//  if (MakeItStretch)
//  {
//      NoTextRect = NoTextRect.Union(TextRect); // since the text trigger is also part of the target!
//  }


    // *** calculate the translation to build up the bar into the correct location ***

    // data class to store temp data needed to build up this bar
    class ButtonDataType
    {
    public:
        DocCoord Translation;
        String_256  Name;
        BOOL HaveCreatedProperty;
        TextStory * pOriginalStory;
        String_256 Storytext;
        DocRect OriginalTextStoryDims;
        DocRect NewTextStoryDims;
    } ButtonData[MAX_BUTTONS_IN_A_BAR];

    INT32 ButtonsInitialised = 0;

    // ask the name gallery what buttons do we already have defined
    // get their names and work out the translations to line up a new state
    NameGallery * pNameGallery = NameGallery::Instance();

    if (pNameGallery)
    {
        pNameGallery->FastUpdateNamedSetSizes(); // make sure we are using the most up-to-date data
        
        SGUsedNames* pNames = pNameGallery->GetUsedNames();
        SGNameItem* pNameGalleryItem = pNames ? (SGNameItem*) pNames->GetChild() : NULL;
    
            
        while (pNameGalleryItem)
        {
            if (pNameGalleryItem->m_BarNumber == BarNo && !pNameGalleryItem->IsEmpty() && !pNameGalleryItem->IsABackBar())
            {
                // set the name
                pNameGalleryItem->GetNameText(&(ButtonData[ButtonsInitialised].Name));
                ButtonData[ButtonsInitialised].HaveCreatedProperty = FALSE;
    
                // Matt 19/12/2000
                // If the LiveStretching check box is turned on, then we should reposition the buttons relative to the centre of their set bounds.
                // If not, then we should position them central to where their set bounds on THIS layer are...
                // This is so that you can change some colours (etc) on one state, click 'SetNewDesign' and be sure that your button isn't
                // about to realign itself centrally to its set (when this may not have been appropriate)
                BOOL LiveStretching = FALSE;
                NodeBarProperty* pNodeBarProperty = (NodeBarProperty*) Document::GetCurrent()->GetSetSentinel()->FindBarProperty();
                BarDataType NewBarData = pNodeBarProperty->Bar(BarNo);
                if (pNodeBarProperty  && BarNo < pNodeBarProperty->HowMany())
                {
                    LiveStretching = NewBarData.IsLive;
                }
    
                // If LiveStretching is not enabled or the bar does not require shuffling (ie user positioned)
                if ((!LiveStretching || !NewBarData.RequiresShuffle) && !IgnoreSettings)
                {
                    // Unfortunately, I now want to know where the old version of this button was... I need to know this so that I can position the new buttons with
                    // their new designs in the same place as the original ones so as to minimise on-screen fun... Also, we should use this in the case of User Positioned
                    // buttons so that we don't turn them into Vertical Bars everytime the user clicks 'Set New Design' - not very user positioned!
                    ButtonData[ButtonsInitialised].Translation.x = oldbuttoncentres[ButtonsInitialised].x - SelCentre.x;
                    ButtonData[ButtonsInitialised].Translation.y = oldbuttoncentres[ButtonsInitialised].y - SelCentre.y;
                }
                else
                {
                    // position to new button state on top of the other button states
                    ButtonData[ButtonsInitialised].Translation.x = pNameGalleryItem->GetSetBounds().Centre().x - SelCentre.x;
                    ButtonData[ButtonsInitialised].Translation.y = pNameGalleryItem->GetSetBounds().Centre().y - SelCentre.y;
                }
    
                ButtonsInitialised++;
    
            }
            pNameGalleryItem = (SGNameItem *) pNameGalleryItem->GetNext();
        }
    }

    // init buttons that haven't been seen yet working out their new names and their locations
    INT32 listbuttonno = 0;
    for (;ButtonsInitialised < pBarParam->m_NoOfButtons; ButtonsInitialised++)
    {
        // get the next free button name and put it into listbuttonno
        SliceHelper::GetNextFreeButtonName(listbuttonno, &(ButtonData[ButtonsInitialised].Name));
        ButtonData[ButtonsInitialised].HaveCreatedProperty = FALSE;

        if (ButtonsInitialised == 0)
        {
            ButtonData[ButtonsInitialised].Translation.x = 0;
            ButtonData[ButtonsInitialised].Translation.y = 0;

        }
        else
        {
            if (pBarParam->m_IsVertical)
            {
                ButtonData[ButtonsInitialised].Translation.x = ButtonData[ButtonsInitialised-1].Translation.x;

                ButtonData[ButtonsInitialised].Translation.y = ButtonData[ButtonsInitialised-1].Translation.y
                    - pBarParam->m_Spacing - SelRect.Height();

                // place the new button on the same subpixel level as the first button?
                if (pBarParam->m_Spacing == 0 || pBarParam->m_Spacing >= 3750)
                    ButtonData[ButtonsInitialised].Translation.y = (ButtonData[ButtonsInitialised].Translation.y /750)*750;
            }
            else
            {
                ButtonData[ButtonsInitialised].Translation.x = ButtonData[ButtonsInitialised-1].Translation.x
                    + pBarParam->m_Spacing + SelRect.Width();

                ButtonData[ButtonsInitialised].Translation.y = ButtonData[ButtonsInitialised-1].Translation.y;

                // place the new button on the same subpixel level as the first button?
                if (pBarParam->m_Spacing == 0 || pBarParam->m_Spacing >= 3750)
                    ButtonData[ButtonsInitialised].Translation.x = (ButtonData[ButtonsInitialised].Translation.x /750)*750;
            }
        }
    }

    // find a ptr to the original text stories in this bar
    for (ButtonsInitialised = 0; ButtonsInitialised < pBarParam->m_NoOfButtons; ButtonsInitialised++)
    {
        ButtonData[ButtonsInitialised].pOriginalStory = SliceHelper::FindNextTextStoryToSync( NULL,
                                                pNewLayer,
                                                NULL,
                                                ButtonData[ButtonsInitialised].Name,
                                                "",
                                                TRUE);

        if (ButtonData[ButtonsInitialised].pOriginalStory)
            ButtonData[ButtonsInitialised].Storytext = ButtonData[ButtonsInitialised].pOriginalStory->GetStoryAsString();


        ButtonData[ButtonsInitialised].OriginalTextStoryDims.MakeEmpty();
        ButtonData[ButtonsInitialised].NewTextStoryDims.MakeEmpty();
    }

    // activate the layer we are about to stuff things on
    SliceHelper::ShowLayer(TRUE, pNewLayer, pSpread, this);
    LayerSGallery::MakeActiveLayer(pNewLayer, FALSE); // dont tell as this will be restored

    // add items directly after the layer node as its first child
    Node * pTail = pNewLayer;
    AttachNodeDirection TailAttachDirection = FIRSTCHILD;

    pNodeListItem = NULL;
    Trans2DMatrix Transformer;


    // for each button we want to produce
    INT32 but;
    for (but = 0; but < pBarParam->m_NoOfButtons; but++)
    {
        // copy the selection from where it is to the new layer
        pNodeListItem = (NodeListItem *)SelectionList.GetHead();

        // set the transformer to position the button
        Transformer.SetTransform(   ButtonData[but].Translation.x,
                                    ButtonData[but].Translation.y);

        while (pNodeListItem)
        {
            pNode = pNodeListItem->pNode;
            if (pNode)
            {
                // add this node into the tree on the layer defined in list order
                // Make a copy of the current node
                Node* pTheCopy;
                BOOL ok;
                
                CALL_WITH_FAIL(pNode->NodeCopy(&pTheCopy), this, ok);

                if (ok && !DoInsertNewNode((NodeRenderableBounded *)pTheCopy, pTail, TailAttachDirection,
                                         TRUE,      // Do Invalidate region 
                                         FALSE))    // Don't Clear the selections
                    {
                        ok = FALSE;
                    }

                if (ok)
                {
                    // don't have any of these new nodes selected
                    pTheCopy->SetSelected(but == 0);

                    // move it to the new location
                    ((NodeRenderableBounded *)pTheCopy)->Transform(Transformer);
                    pTheCopy->AllowOp(&ObjChange);
                    DoInvalidateNodeRegion((NodeRenderableBounded*) pTheCopy, TRUE, FALSE);

                    // not used by this function but recorded by the object
                    m_FinishedBarRect = m_FinishedBarRect.Union(SliceHelper::BoundingNodeSize(pTheCopy));

                    // sync the text as it goes in
                    if (ButtonData[but].pOriginalStory && !ButtonData[but].Storytext.IsEmpty())
                    {
                        TextStory * pStory = (TextStory *) SliceHelper::FindNextOfClass(pTheCopy, pTheCopy, CC_RUNTIME_CLASS(TextStory), TRUE);
                        while (pStory)
                        {
                            // work out how to reposition this newly sync'ed text
                            Node * pNodeSetSentinel = Document::GetSelected()->GetSetSentinel();
                            NodeBarProperty * pNodeBarProperty = (NodeBarProperty*) ((NodeSetSentinel *)pNodeSetSentinel)->FindBarProperty();
                            INT32 alignment = pNodeBarProperty->Bar(BarNo).SameSize;

                            // where is the defining position of the text story before the change?
                            DocRect OldRect = SliceHelper::BoundingNodeSize(pStory);
                            BOOL changed = SliceHelper::SyncTextStories(pStory, ButtonData[but].pOriginalStory, this);
                            if (changed)
                            {
                                DocRect NewRect = SliceHelper::BoundingNodeSize(pStory);
                                // make the new and old texts be centred in the same place
                                INT32 tx = OldRect.Centre().x - NewRect.Centre().x;
                                INT32 ty = OldRect.Centre().y - NewRect.Centre().y;

                                if (alignment == 1)
                                    tx = OldRect.lox - NewRect.lox;
                                else
                                if (alignment == 2)
                                    tx = OldRect.hix - NewRect.hix;
                                
                                Trans2DMatrix TextTransformer(tx, ty);
                                pStory->Transform(TextTransformer);

                                if (alignment == 3) // only store the data if they are different sizes
                                {
                                    NewRect.Translate(tx,ty);
                                    ButtonData[but].NewTextStoryDims = ButtonData[but].NewTextStoryDims.Union(NewRect);
                                    ButtonData[but].OriginalTextStoryDims = ButtonData[but].OriginalTextStoryDims.Union(OldRect);
                                }
                            }
                            // translate the altered text story to have the same defining position
                            pStory = (TextStory *) SliceHelper::FindNextOfClass(pStory, pTheCopy, CC_RUNTIME_CLASS(TextStory));
                        }
                    }

                    // Look at the wix attribs it has been given
                    if (!Target.IsEmpty()) // only if we know the target name
                    {
                        TemplateAttribute * pTemplateAttribute = (TemplateAttribute *) SliceHelper::FindNextOfClass(pTheCopy, pTheCopy, CC_RUNTIME_CLASS(TemplateAttribute));
                        while (pTemplateAttribute)
                        {
                            TemplateAttribute * pNextTemplateAttribute = (TemplateAttribute *) SliceHelper::FindNextOfClass(pTemplateAttribute, pTheCopy, CC_RUNTIME_CLASS(TemplateAttribute));
                            // found a target
                            if (Target.CompareTo(pTemplateAttribute->GetParam()) == 0)
                            {
                                // hide this, it is replaced by the ApplyNameAttr call bellow
                                // which will use the buttons new name
                                //NodeListItem * pItem = new NodeListItem(pTemplateAttribute);
                                //DelList.AddTail(pItem);
                                DoHideNode(pTemplateAttribute, TRUE);
                            }
                            else if (!Extender.IsEmpty() && Extender.CompareTo(pTemplateAttribute->GetParam()) == 0)
                            {
                                // found a node that matches the extender object in the selection
                                // replace this with a new button name that matches the buttons
                                // new name but has the word extender stuffed after it.
                                // We also need to add to the node sentinel the fact that
                                // NewExtenderName stretches ButtonName in the same way that
                                // Extender stretched Target
                                String_32   ExtenderPostfix;
                                ExtenderPostfix.Load(_R(IDS_EXTENDER_POSTFIX));
                                String_256  NewExtenderName = ButtonData[but].Name;
                                NewExtenderName += ExtenderPostfix;
                                // apply the extender name, but not the bar name to it
                                ApplyNameAttr(&NewExtenderName, pTheCopy, FALSE);

                                //NodeListItem * pItem = new NodeListItem(pTemplateAttribute);
                                //DelList.AddTail(pItem);
                                DoHideNode(pTemplateAttribute, TRUE);

                                if (!ButtonData[but].HaveCreatedProperty)
                                {
                                    TRACE( _T("redef from existing data\n"));

                                    DocRect TempTarget(TargetRect);
                                    TempTarget.Translate(   ButtonData[but].Translation.x,
                                                            ButtonData[but].Translation.y);
                                    DocRect TempExtender(ExtenderRect);
                                    TempExtender.Translate( ButtonData[but].Translation.x,
                                                            ButtonData[but].Translation.y);

                                    // create the properties for the button/Target that this extender extends
                                    SliceHelper::CreatePropertiesForSet(ButtonData[but].Name, m_BarName, TRUE, ExtenderFlags != 0, FALSE, ExtenderFlags,
                                                                        NewExtenderName, FALSE, &TempTarget, &TempExtender,
                                                                        this);

                                    // create default properties for the extender
                                    SliceHelper::CreatePropertiesForSet(NewExtenderName, TEXT(""),  FALSE, FALSE, FALSE, 0,
                                                                        TEXT(""), FALSE, NULL, NULL, this);

                                    ButtonData[but].HaveCreatedProperty = TRUE;
                                }
                            }
                            pTemplateAttribute = pNextTemplateAttribute;
                        }
                    }

                    // make it stretch if it didn't before
                    if (MakeItStretch)
                    {
                        if (IS_A(pTheCopy,TextStory) || SliceHelper::FindNextOfClass(pTheCopy, pTheCopy, CC_RUNTIME_CLASS(TextStory)))
                        {
                            // found a node that matches the extender object in the selection
                            // replace this with a new button name that matches the buttons
                            // new name but has the word extender stuffed after it.
                            // We also need to add to the node sentinel the fact that
                            // NewExtenderName stretches ButtonName in the same way that
                            // Extender stretched Target
                            String_32   ExtenderPostfix;
                            ExtenderPostfix.Load(_R(IDS_EXTENDER_POSTFIX));
                            String_256  NewExtenderName = ButtonData[but].Name;
                            NewExtenderName += ExtenderPostfix;
                            // apply the extender name, but not the bar name to it
                            ApplyNameAttr(&NewExtenderName, pTheCopy, FALSE);

                            if (!ButtonData[but].HaveCreatedProperty)
                            {
                                DocRect TempTarget(NoTextRect);
                                TempTarget.Translate(   ButtonData[but].Translation.x,
                                                        ButtonData[but].Translation.y);
                                DocRect TempExtender(TextRect);
                                TempExtender.Translate( ButtonData[but].Translation.x,
                                                        ButtonData[but].Translation.y);

                                // create the properties for the button/Target that this extender extends
                                SliceHelper::CreatePropertiesForSet(ButtonData[but].Name, m_BarName, TRUE, pBarParam->m_ExtendFlags != 0, FALSE,
                                                                    pBarParam->m_ExtendFlags, NewExtenderName, FALSE,
                                                                    &TempTarget, &TempExtender, this);

                                // create default properties for the extender
                                SliceHelper::CreatePropertiesForSet(NewExtenderName, m_BarName, FALSE, FALSE, FALSE, 0,
                                                                    TEXT(""), FALSE, NULL, NULL, this);

                                ButtonData[but].HaveCreatedProperty = TRUE;
                            }
                        }
                    }

                    // give it the button's name
                    ApplyNameAttr(&ButtonData[but].Name, pTheCopy);

                    // no extender?
                    // then we should add the default properties to the button
                    // in the node sentry too
                    if (Extender.IsEmpty() && !ButtonData[but].HaveCreatedProperty && !MakeItStretch)
                    {
                        SliceHelper::CreatePropertiesForSet(ButtonData[but].Name, m_BarName, TRUE, FALSE, FALSE,
                                                            0, TEXT(""), FALSE, NULL, NULL, this);
                        ButtonData[but].HaveCreatedProperty = TRUE;
                    }

                    // factor out common attribs
                    if (pTheCopy->IsCompound() && !pTheCopy->IsABlend())
                        DoFactorOutCommonChildAttributes((NodeRenderableInk*) pTheCopy);
                    else
                        DoFactorOutAfterAttrChange((NodeRenderableInk*) pTheCopy, (AttrTypeSet *)NULL);

                    // attach the next node after this one
                    TailAttachDirection = NEXT;
                    pTail = pTheCopy;
                }
            }

            // and for the next item in the list
            pNodeListItem = (NodeListItem *)SelectionList.GetNext(pNodeListItem);
        }
    }

    // clean up the selection list
    pNodeListItem = (NodeListItem *)SelectionList.GetHead();
    NodeListItem *pNodeListItemToDel = NULL;

    while (pNodeListItem)
    {
        pNodeListItemToDel = pNodeListItem;
        pNodeListItem = (NodeListItem *)SelectionList.GetNext(pNodeListItem);
        SelectionList.RemoveItem((NodeListItem *)pNodeListItemToDel);
        delete pNodeListItemToDel;
    }

    // delete the existing back bar nodes
    pNodeListItem = (NodeListItem *)DelList.GetHead();

    while(pNodeListItem)
    {
        Node *pParent = pNodeListItem->pNode;

        BOOL HideIt = TRUE;
        NodeListItem * pPreviousNodeListItem = (NodeListItem *)DelList.GetHead();

        //TRACEUSER( "SimonK", _T("considering %s %d\n"), (LPCTSTR) pParent->GetRuntimeClass()->m_lpszClassName, pParent);

        // test for deleting this item twice - a double delete will crash!!!
        while (pPreviousNodeListItem && pPreviousNodeListItem != pNodeListItem && HideIt)
        {
            //TRACEUSER( "SimonK", _T("testing %s %d\n"), (LPCTSTR) pPreviousNodeListItem->pNode->GetRuntimeClass()->m_lpszClassName, pPreviousNodeListItem->pNode);
            if (pParent == pPreviousNodeListItem->pNode)
            {
                HideIt = FALSE; // since it has already been hidden by us
                //TRACEUSER( "SimonK", _T("MATCHED\n"));
            }

            pPreviousNodeListItem = (NodeListItem *)DelList.GetNext(pPreviousNodeListItem);
        }

        // hide the node if we haven't already done so
        if (HideIt)
        {
            DoInvalidateNodeRegion((NodeRenderableBounded*) pParent, TRUE, FALSE);
            pParent->SetSelected(FALSE);
            DoHideNode(pParent, TRUE);
        }

        pNodeListItem = (NodeListItem *)DelList.GetNext(pNodeListItem);
    }


    pNodeListItem = (NodeListItem *)DelList.GetHead();
    pNodeListItemToDel = NULL;

    while(pNodeListItem)
    {
        pNodeListItemToDel = pNodeListItem;
        pNodeListItem = (NodeListItem *)DelList.GetNext(pNodeListItem);
        DelList.RemoveItem((NodeListItem *)pNodeListItemToDel);
        delete pNodeListItemToDel;
    }

    // sort out any buttons just created that need to be extended due to the text
    // having been swapped. This usually happens if during the "redefine state" op
    // added 25/8/00 by sjk

    for (but = 0; but < pBarParam->m_NoOfButtons; but++)
    {
        NodeSetSentinel * pNodeSetSentinel = Document::GetSelected()->GetSetSentinel();
        if (ButtonData[but].OriginalTextStoryDims != ButtonData[but].NewTextStoryDims)
        {
            NodeSetProperty * pProp = pNodeSetSentinel->FindPropertyNode(ButtonData[but].Name);
            NamedStretchProp* pStretchProp = pProp ? (NamedStretchProp*) pProp->GetProperty(NamedStretchProp::nIndex) : NULL;

            if (pStretchProp)
            {
                // found an altered text story
                DocRect ButtonRect = TargetRect;
                if (ButtonRect.IsEmpty() || !ButtonRect.IsValid())
                    ButtonRect = SelRect;

                ButtonRect.Translate(   ButtonData[but].Translation.x,
                                        ButtonData[but].Translation.y);

                Node * pNode = SliceHelper::FindNextNameNode(pNewLayer, pNewLayer);

                while (pNode)
                {
                    Node * pParent = pNode->FindParent();
                    if (!IS_A(pParent, TextStory) && ButtonData[but].Name.CompareTo(((TemplateAttribute *)pNode)->GetParam()) == 0)
                        // do the extend
                        Extender::Extend((NodeRenderableInk*) (pParent),
                            pBarParam->m_ExtendFlags,
                            pStretchProp->GetRefUnionTriggerBounds(),
                            pStretchProp->GetRefTargetBounds(),
                            ButtonData[but].NewTextStoryDims,
                            ButtonData[but].OriginalTextStoryDims,
                            ButtonRect,
                            NULL, // no restrictions on extending
                            TRUE
                            );

                    pNode = SliceHelper::FindNextNameNode(pNode, pNewLayer);
                }
            }
        }
    }

    // set the active layer to the layer that was active before
    // if that is possible
    Layer* pActiveLayer = SliceHelper::FindLayerCalled(ActiveLayerStr);
    if (pActiveLayer != 0)
        LayerSGallery::MakeActiveLayer(pActiveLayer, FALSE); // dont tell as we are putting it back

    // inform that there may well be more/less layers about to be visible or not
    BROADCAST_TO_ALL(LayerMsg(pActiveLayer, LayerMsg::LayerReason::LAYER_VISIBILITY_CHANGED));

    // the selection will have changed - after all we just deleted it
    BROADCAST_TO_ALL(SelChangingMsg(SelChangingMsg::NONCOLOURATTCHANGED));
    GetApplication()->UpdateSelection();

    ObjChange.Define(OBJCHANGE_FINISHED,cFlags,NULL,this);
    UpdateChangedNodes(&ObjChange);

    return TRUE;
}

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

>   void OpBarCreation::Do(OpDescriptor*)

    Author:     Simon_Knight (Xara Group Ltd) <camelotdev@xara.com>
    Created:    27/8/99
    Inputs:     OpDescriptor (unused)
    Outputs:    -
    Returns:    -
    Purpose:    Creates a navigation rollover bar in the drawing by copying the selection
                several times unto named layers, and naming each copy of the selection.
    Errors:     -
    SeeAlso:    OpBarCreation::DoWithParam, CarbonCopyOp::Do

********************************************************************************************/   
void OpBarCreation::Do(OpDescriptor* token)
{   
    OpParamBarCreation BarParam;
    DoWithParam(token, &BarParam);
}


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

>   Layer * OpBarCreation::AddLayer(String_256 LayerName)

    Author:     Simon_Knight (Xara Group Ltd) <camelotdev@xara.com>
    Created:    27/8/99
    Inputs:     Name of the Layer to create
    Outputs:    Pointer to the newly created layer
    Returns:    -
    Purpose:    Create a new named layer

********************************************************************************************/
Layer * OpBarCreation::AddLayer(String_256 LayerName, INT32 NewLayerNo)
{
    Spread* pSpread = Document::GetSelectedSpread();
    if (pSpread == NULL)
        return NULL;

    // check to see if we need to add one first 
    Layer * pStandardLayer = SliceHelper::FindLayerCalled(LayerName);
    if (pStandardLayer)
    {
        LayerSGallery::MakeActiveLayer(pStandardLayer, FALSE); // dont tell, but we must put this back
        return pStandardLayer;
    }

    // find out where to add it and create it now
    Layer*              pLayer      = NULL;
    Node*               pContextNode= pSpread;
    AttachNodeDirection AttDir      = FIRSTCHILD;
    LayerStatus         NewStatus;
    NewStatus.StringLayerID = LayerName;

    // avoid the page - make the layers after the page node
    Node * pNode = pSpread->FindFirstChild();
    while (pNode)
    {
        // after the page node
        if (IS_A(pNode, Page))
        {
            pContextNode = pNode;
            AttDir = NEXT;
        }
        // and after any background nodes
        else if (pNode->IS_KIND_OF(Layer))
        {
            if (((Layer *)pNode)->IsBackground())
            {
                pContextNode = pNode;
                AttDir = NEXT;
            }
        }

        pNode = pNode->FindNext();
    }

    // order the special layers
    BOOL FoundHigherLayer = FALSE;
    INT32 LayerToFind = NewLayerNo-1;
    while (!FoundHigherLayer && LayerToFind >= DEFAULT)
    {
        pStandardLayer = SliceHelper::FindLayerCalled(m_RolloverName[LayerToFind]);
        if (pStandardLayer)
        {
            FoundHigherLayer = TRUE; // found the layer to stick it just previous to

            pContextNode = pStandardLayer;
            AttDir      = PREV;
        }
        else
        {
            LayerToFind--;
        }
    }

    // create the new layer and stick it in the tree
    ALLOC_WITH_FAIL(pLayer, (new Layer()), this);         
    if (pLayer == NULL) return NULL;

    // Set the new layer's status  
    pLayer->SetLayerStatus(NewStatus); 

    if (DoInsertNewNode(pLayer,pContextNode,AttDir,FALSE))
    {
        LayerSGallery::MakeActiveLayer(pLayer, FALSE); // dont tell but we must put this back
    }

    return pLayer;
}

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

>   BOOL OpBarCreation::ApplyNameAttr(String_256 * pNameAttr, Node * pNode, BOOL UseBarName)

    Author:     Simon_Knight (Xara Group Ltd) <camelotdev@xara.com>
    Created:    27/8/99
    Inputs:     The object name and the node to apply it to
    Returns:    TRUE unless a error occurred
    Purpose:    To apply the names Button1, Button2, etc to the different buttons
                so that the image slicing/rollover stuff works okay.
                NB. it uses the question part of the wix attribute to store the
                bar name. This then gets saved out in the wix files but will be
                destroyed by Merlin if wixxed up.

********************************************************************************************/   
BOOL OpBarCreation::ApplyNameAttr(String_256 * pNameAttr, Node * pNode, BOOL UseBarName)
{
    TemplateAttribute* pAttr = new TemplateAttribute(   String_256(TEXT("ObjectName")),
                                                        UseBarName ? m_BarName : "",
                                                        *pNameAttr);

    if (!pAttr) return FALSE;

    // add the attrib into the tree
    pAttr->AttachNode(pNode, FIRSTCHILD);

    return TRUE;
}


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

>   void OpBarCreation::FindAttribColours(Node * pAttrNode, INT32 PercentColourChange, INT32 State)

    Author:     Simon_Knight (Xara Group Ltd) <camelotdev@xara.com>
    Created:    27/8/99
    Inputs:     The Node to test and manipulate (it will test all its children too and their
                children recursively - so use with care).
                PercentColourChange - is a relative amount to change the colours by (100 does nothing)
                State = (DEFAULT = 0, MOUSE = 1, CLICKED = 2, SELECTED = 3) used to gadge the
                state of the button being modified.
    Returns:    -
    Purpose:    Modifies the colours of objects for the "suggest design" mode
                Will also rotate bevels for the SELECTED state.

********************************************************************************************/   
void OpBarCreation::FindAttribColours(Node * pAttrNode, INT32 PercentColourChange, INT32 State)
{
    if (pAttrNode->IsAnAttribute())
    {
        // change the colour of the attribute
        if (PercentColourChange != 100 && pAttrNode->IsKindOf(CC_RUNTIME_CLASS(AttrFlatColourFill)))
        {
            DocColour* pdoccol = ((AttrFlatColourFill *)pAttrNode)->GetStartColour();
            ShiftColourValue(pdoccol, PercentColourChange);
        }
        // this else clause *must* come before that which tests for AttrFillGeometry!
        else if (PercentColourChange != 100 && pAttrNode->IsKindOf(CC_RUNTIME_CLASS(AttrFillGeometry)))
        {
            ColRampItem* pColItem;
            ColourRamp* pColRamp = ((AttrFillGeometry*)pAttrNode)->GetColourRamp();
            if (pColRamp != NULL)
            {
                pColItem = pColRamp->GetFirstCol();
                while (pColItem != NULL)
                {
                    ShiftColourValue(pColItem->GetColourAddr(), PercentColourChange);
                    pColItem = pColRamp->GetNextCol(pColItem);
                }
            }

            DocColour* pdoccol = ((AttrFillGeometry *)pAttrNode)->GetStartColour();
            ShiftColourValue(pdoccol, PercentColourChange);
            pdoccol = ((AttrFillGeometry *)pAttrNode)->GetEndColour();
            ShiftColourValue(pdoccol, PercentColourChange);
            pdoccol = ((AttrFillGeometry *)pAttrNode)->GetEndColour2();
            ShiftColourValue(pdoccol, PercentColourChange);
            pdoccol = ((AttrFillGeometry *)pAttrNode)->GetEndColour3();
            ShiftColourValue(pdoccol, PercentColourChange);
        }
        // rotate the bevel light angle for selected states
        else if (State == SELECTED && pAttrNode->IsKindOf(CC_RUNTIME_CLASS(AttrBevelLightAngle)))
        {
            // assumes the parent of the bevel attrib is the bevel controller
            INT32 angle = 135;
            Node * pParent = pAttrNode->FindParent();
            if (pParent->IsKindOf(CC_RUNTIME_CLASS(NodeBevelController)))
            {
                angle = (INT32)((NodeBevelController *)pAttrNode->FindParent())->m_LightAngle + 180;
                if (angle > 360) angle -= 360;
            }
            ((AttrBevelLightAngle *)pAttrNode)->SetValue(angle);
        }
    }
    else // find anything else interesting?
    {
        Node * pChildNode = pAttrNode->FindFirstChild();

        while (pChildNode)
        {
            // recursive call
            FindAttribColours(pChildNode, PercentColourChange, State);
            pChildNode = pChildNode->FindNext();
        }
    }
}


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

>   void OpBarCreation::ShiftColourValue(DocColour* pdoccol, INT32 PercentColourChange)

    Author:     Simon_Knight (Xara Group Ltd) <camelotdev@xara.com>
    Created:    27/8/99
    Inputs:     ptr to the doc colour - changing this changes the colour
                PercentColourChange - amount of colour to change
    Returns:    -
    Purpose:    Modifies the colours of objects for the "suggest design" mode
                Uses HSV colour model. Drops or raises V. When this goes out of bounds
                it lowers s too.

********************************************************************************************/   
void OpBarCreation::ShiftColourValue(DocColour* pdoccol, INT32 PercentColourChange)
{
    if (!pdoccol || pdoccol->IsTransparent())
        return;

    INT32 h,s,v;

    pdoccol->GetHSVValue(&h, &s, &v);


    // usual lighter and darker code
    if (PercentColourChange != 0)
    {
        v -= PercentColourChange - 100;
        if (v < 0)
        {
            s -= v*2;
            if (s > 255) s = 255;
            v = 0;
        }
        else
        if (v > 255)
        {
            s -= (v-255)*2;
            if (s < 0) s = 0;
            v = 255;
        }
    }
    else // spin the hue!!!
    {
        h += 35; // arbitry amount that you can see the difference with
        if (h > 255)
            h -= 255;
    }
    pdoccol->SetHSVValue(h, s, v);

}


/********************************************************************************************
>   NodeBarProperty* GetBarData()

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/3/00
    Returns:    Current document's NodeBarProperty, if any.
    SeeAlso:    BarDataType; NodeBarProperty; NodeSetSentinel
********************************************************************************************/

NodeBarProperty* GetBarData()
{
    return (NodeBarProperty*) Document::GetCurrent()->GetSetSentinel()->FindBarProperty();
}


/********************************************************************************************
>   BOOL OpBarCreation::CreateFromDefaultState (OpParam* pOpParam)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> K
    Created:    25/3/00
    Purpose:    Pretty much just has to copy the contents of this bar from the default
                layer to the layer prescribed. All bar properties and stetching etc should
                already have been set up from creating the MouseOff state/layer

    Returns:    TRUE if all went well
********************************************************************************************/
BOOL OpBarCreation::CreateFromDefaultState (OpParam* pOpParam)
{
    // work out which is the active layer so we can set this back when
    // we are finished playing around with them all
    String_256 ActiveLayerStr(_R(IDS_ROLLOVER_DEFAULT));
    Spread* pSpread = Document::GetSelectedSpread();
    if (pSpread)
    {
        ActiveLayerStr = pSpread->FindActiveLayer()->GetLayerID();
    }

    OpParamBarCreation* pBarParam = (OpParamBarCreation*)pOpParam;

    // get the name of this bar
    m_BarName = pBarParam->m_BarName;

    // set up the layer names
    m_RolloverName[DEFAULT].Load(_R(IDS_ROLLOVER_DEFAULT)); // = "Default";
    m_RolloverName[MOUSE].Load(_R(IDS_ROLLOVER_MOUSE)); // = "Mouse";
    m_RolloverName[CLICKED].Load(_R(IDS_ROLLOVER_CLICKED)); // = "Clicked";
    m_RolloverName[SELECTED].Load(_R(IDS_ROLLOVER_SELECTED)); // = "Selected";
    m_RolloverName[BACKBAR].Load(_R(IDS_BACK_BAR)); // = "Back Bar";

    INT32 NewLayerNo = 0;

    if (pBarParam->m_WantMouse)
        NewLayerNo = 1;
    else if (pBarParam->m_WantClicked)
        NewLayerNo = 2;
    else if (pBarParam->m_WantSelected)
        NewLayerNo = 3;

    // create the new layer
    Layer * pNewLayer = AddLayer(m_RolloverName[NewLayerNo], NewLayerNo);
    
    if (!pNewLayer)
        return FALSE;

    // make the new layer visible
    SliceHelper::ShowLayer(TRUE, pNewLayer, pSpread, this);

    Layer * pLayer = NULL;

    List BarList;

    pLayer = SliceHelper::FindLayerCalled(m_RolloverName[DEFAULT]);

    if (!pLayer)
        return FALSE;

    // Prepare an ObjChangeParam so we can mark which nodes will allow this op to happen to them
    ObjChangeFlags cFlags;
    cFlags.RegenerateNode = TRUE;
    ObjChangeParam ObjChange(OBJCHANGE_STARTING,cFlags,NULL,this);

    // list all of this bar that is on the default layer
    SliceHelper::BuildListOfNodesInBar(&BarList, pLayer, m_BarName);

    // copy each item referenced by a template attrib marked with this bar ID
    NodeListItem * pNodeListItem = (NodeListItem *)BarList.GetHead();
    NodeListItem * pDelThisToo = NULL;

    Node * pTail = pNewLayer;
    AttachNodeDirection TailAttachDirection = FIRSTCHILD;

    while(pNodeListItem)
    {
        pDelThisToo = pNodeListItem;
        Node *pNode = pNodeListItem->pNode->FindParent();
        if (pNode)
        {
            // add this node into the tree on the layer defined in list order
            // Make a copy of the current node
            Node* pTheCopy;
            BOOL ok = TRUE;
            
            if (ok)
                CALL_WITH_FAIL(pNode->NodeCopy(&pTheCopy), this, ok);

            if (ok && pBarParam->m_SuggestDesign)
            {
                INT32 ColShift = 100;
                if (NewLayerNo == MOUSE)
                    ColShift = 40;
                else if (NewLayerNo == SELECTED)
                    ColShift = 150;
                else if (NewLayerNo == CLICKED)
                    ColShift = 0; // this plays with the hue instead

                FindAttribColours(pTheCopy, ColShift, NewLayerNo);
            }

            if (ok && !DoInsertNewNode((NodeRenderableBounded *)pTheCopy, pTail, TailAttachDirection,
                                     TRUE,      // Do Invalidate region 
                                     FALSE))    // Don't Clear the selections
                {
                    ok = FALSE;
                }

            if (ok)
            {
                // if we are making the selected version check that we didn't have a default light angle
                // on the bevel that we would have missed. If we did miss it add in a reverse of the 
                // default light angle
                if (NewLayerNo == SELECTED && pBarParam->m_SuggestDesign)
                {
                    // was there a bevel? With out a bev light angle?
                    Node * pBev = SliceHelper::FindNextOfClass(pTheCopy, pTheCopy, CC_RUNTIME_CLASS(NodeBevelController), TRUE );
                    if (pBev && !SliceHelper::FindNextOfClass(pTheCopy, pTheCopy, CC_RUNTIME_CLASS(AttrBevelLightAngle) ))
                    {
                        // then give it a bev light angle
                        AttrBevelLightAngle* pNewLightAttr = new AttrBevelLightAngle();
                        if (pNewLightAttr)
                        {
                            pNewLightAttr->Value.m_LightAngle = 120; // reverse of the default
                            // add the attrib into the tree
                            pNewLightAttr->AttachNode(pTheCopy, FIRSTCHILD);

                        }
                    }
                }

                // don't have any of these new nodes selected
                pTheCopy->SetSelected(FALSE);

                // make it regenerate
                pTheCopy->AllowOp(&ObjChange);

                // attach the next node after this one
                TailAttachDirection = NEXT;
                pTail = pTheCopy;
            }
        }

        pNodeListItem = (NodeListItem *)BarList.GetNext(pNodeListItem);

        // tidy up the list as we go along
        BarList.RemoveItem((NodeListItem *)pDelThisToo);
        delete pDelThisToo;
    }

    // set the active layer to the layer that was active before
    // if that is possible
    Layer* pActiveLayer = SliceHelper::FindLayerCalled(ActiveLayerStr);
    if (pActiveLayer != 0)
        LayerSGallery::MakeActiveLayer(pActiveLayer, FALSE); // dont tell as we are putting this back

    // show just the new layer we have made
    ShowState(NewLayerNo);

    // inform that there may well be more/less layers about to be visible or not
    BROADCAST_TO_ALL(LayerMsg(pActiveLayer, LayerMsg::LayerReason::LAYER_VISIBILITY_CHANGED));
    BROADCAST_TO_ALL(SelChangingMsg(SelChangingMsg::NONCOLOURATTCHANGED));

    ObjChange.Define(OBJCHANGE_FINISHED,cFlags,NULL,this);
    UpdateChangedNodes(&ObjChange);


    // the selection will have changed - after all we just deleted it
    GetApplication()->UpdateSelection();
    return TRUE;
}


/********************************************************************************************
>   BOOL OpBarCreation::CreateBackBarFromSelection (OpParam* pOpParam)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> K
    Created:    5/4/00
    Purpose:    Creates the back bar from the selection
    Returns:    TRUE if all went well
********************************************************************************************/
BOOL OpBarCreation::CreateBackBarFromSelection (OpParam* pOpParam, BOOL Extend)
{
    String_256 ActiveLayerStr(_R(IDS_ROLLOVER_DEFAULT));
    Spread* pSpread = Document::GetSelectedSpread();
    if (pSpread)
    {
        ActiveLayerStr = pSpread->FindActiveLayer()->GetLayerID();
    }

    OpParamBarCreation* pBarParam = (OpParamBarCreation*)pOpParam;

    // get the name of this bar
    m_BarName = pBarParam->m_BarName;

    // work out the name of the back bar
    String_256 BackBarName = "";
    BackBarName.MakeMsg(_R(IDS_BACKBARNAME), SliceHelper::GetBarNumberFromBarName(m_BarName) +1);

    // set up the layer names
    m_RolloverName[DEFAULT].Load(_R(IDS_ROLLOVER_DEFAULT)); // = "Default";
    m_RolloverName[MOUSE].Load(_R(IDS_ROLLOVER_MOUSE)); // = "Mouse";
    m_RolloverName[CLICKED].Load(_R(IDS_ROLLOVER_CLICKED)); // = "Clicked";
    m_RolloverName[SELECTED].Load(_R(IDS_ROLLOVER_SELECTED)); // = "Selected";
    m_RolloverName[BACKBAR].Load(_R(IDS_BACK_BAR)); // = "Back Bar";

    List SelectionList;
    List DelList;

    // get the selection
    Range Sel(*(GetApplication()->FindSelection()));

    // set the range flags so it includes shadow and bevel manager nodes
    RangeControl rg = Sel.GetRangeControlFlags();
    rg.PromoteToParent = TRUE;
    Sel.Range::SetRangeControl(rg);

    // remove any quickshape objects from the selection
    if (Extender::ConvertQuickShapesInSelRangeToPaths(this, &Sel))
    {
        Sel = *(GetApplication()->FindSelection());
        rg = Sel.GetRangeControlFlags();
        rg.PromoteToParent = TRUE;
        Sel.Range::SetRangeControl(rg);
    }

    if (Sel.IsEmpty())
    {
        InformWarning(_R(IDS_WARNING_NO_SEL_BACKBAR));
        return FALSE;
    }
    
    // Prepare an ObjChangeParam so we can mark which nodes will allow this op to happen to them
    ObjChangeFlags cFlags;
    cFlags.MultiReplaceNode = TRUE;
    cFlags.RegenerateNode = TRUE;
    ObjChangeParam ObjChange(OBJCHANGE_STARTING,cFlags,NULL,this);

    // Mark nodes that will allow this to happen, and error if no nodes will let it happen
    if (!Sel.AllowOp(&ObjChange))
        return FALSE; // op not allowed

    // get the size of the selection
    DocRect SelRect; // = Sel.GetBoundingRect();
    SelRect.MakeEmpty();

    // modify the selection to the allowed constraints
    // use the selection list from now on
    CleanSelection (&Sel, &SelectionList, &DelList, BACKBAR);
    if (SelectionList.IsEmpty())
    {
        InformWarning(_R(IDS_WARNING_NO_SEL_BACKBAR));
        return FALSE;
    }

    // define the SelRect from the selection list
    NodeListItem * pNodeListItem = (NodeListItem *)SelectionList.GetHead();
    while(pNodeListItem)
    {
        // localise attribs for this node
        DoLocaliseForAttrChange((NodeRenderableInk*) pNodeListItem->pNode, (AttrTypeSet *)NULL, (ObjectSet*) NULL);

        // calc the size of this node as part of the size of the selection
        SelRect = SelRect.Union(SliceHelper::BoundingNodeSize(pNodeListItem->pNode));

        pNodeListItem = (NodeListItem *)SelectionList.GetNext(pNodeListItem);
    }

    // create a barBar layer if there isn't one
    Layer * pNewLayer = AddLayer(m_RolloverName[BACKBAR], BACKBAR);

    // mark the existing back bar for deletion if not in the selection
    SliceHelper::BuildListOfNodesInBar(&DelList, pNewLayer, m_BarName);

    // activate the layer we are about to stuff things on
    SliceHelper::ShowLayer(TRUE, pNewLayer, pSpread, this);

    LayerSGallery::MakeActiveLayer(pNewLayer, FALSE); // dont tell as we will put this back

    // add items directly after the layer node as its first child
    Node * pTail = pNewLayer;
    AttachNodeDirection TailAttachDirection = FIRSTCHILD;

    // copy the selection from where it is to the backbar layer
    pNodeListItem = (NodeListItem *)SelectionList.GetHead();
    Node * pNode;

    while (pNodeListItem)
    {
        pNode = pNodeListItem->pNode;
        if (pNode)
        {
            // add this node into the tree on the layer defined in list order
            // Make a copy of the current node
            Node* pTheCopy;
            BOOL ok;
            
            CALL_WITH_FAIL(pNode->NodeCopy(&pTheCopy), this, ok);

            if (ok && !DoInsertNewNode((NodeRenderableBounded *)pTheCopy, pTail, TailAttachDirection,
                                     TRUE,      // Do Invalidate region 
                                     FALSE))    // Don't Clear the selections
                {
                    ok = FALSE;
                }

            if (ok)
            {
                // have all of these new nodes selected
                pTheCopy->SetSelected(TRUE);

                // delete any wix attribs that are on this node
                TemplateAttribute * pTemplateAttribute = (TemplateAttribute *) SliceHelper::FindNextOfClass(pTheCopy, pTheCopy, CC_RUNTIME_CLASS(TemplateAttribute));
                while (pTemplateAttribute)
                {
                    TemplateAttribute * pNextTemplateAttribute = (TemplateAttribute *) SliceHelper::FindNextOfClass(pTemplateAttribute, pTheCopy, CC_RUNTIME_CLASS(TemplateAttribute));
                    // found a bar element
                    if (SliceHelper::GetBarNumberFromBarName(pTemplateAttribute->GetQuestion()) >= 0)
                    {
                        // hide this, it is replaced by the ApplyNameAttr call bellow
                        // which will use the buttons new name
                        DoHideNode(pTemplateAttribute, TRUE);
                    }

                    pTemplateAttribute = pNextTemplateAttribute;
                }

                // if it is not correctly named add the name now
                ApplyNameAttr(&BackBarName, pTheCopy);

                // if extending extend this backbar item on the fly!
                if (Extend)
                {
                    // do the extend
                    Extender::Extend((NodeRenderableInk*) (pTheCopy),
                        pBarParam->m_ExtendFlags,
                        m_BarSelectionRect,
                        SelRect,
                        m_FinishedBarRect,
                        m_BarSelectionRect,
                        SelRect,
                        NULL, // no restrictions on extending
                        TRUE
                        );
                    
                    // wake up blends They appear to need this extra wake up call otherwise they
                    // do not redraw to their new extended dimensions
                    if (pTheCopy->IsABlend())
                        ((NodeBlend*)(pTheCopy))->Reinit(FALSE);
                }

                // factor out common attribs
                if (pTheCopy->IsCompound() && !pTheCopy->IsABlend())
                    DoFactorOutCommonChildAttributes((NodeRenderableInk*) pTheCopy);
                else
                    DoFactorOutAfterAttrChange((NodeRenderableInk*) pTheCopy, (AttrTypeSet *)NULL);

                // attach the next node after this one
                TailAttachDirection = NEXT;
                pTail = pTheCopy;
            }
        }

        // and for the next item in the list
        pNodeListItem = (NodeListItem *)SelectionList.GetNext(pNodeListItem);
    }


    // add the back bar properties, which means it is extended by every member of the bar
    SliceHelper::CreatePropertiesForSet(BackBarName, m_BarName, FALSE, pBarParam->m_ExtendFlags != 0, TRUE, pBarParam->m_ExtendFlags,
                TEXT(""), FALSE, &SelRect, Extend ? &m_BarSelectionRect : NULL, this);

    // clean up the selection list
    pNodeListItem = (NodeListItem *)SelectionList.GetHead();
    NodeListItem *pNodeListItemToDel = NULL;

    while (pNodeListItem)
    {
        pNodeListItemToDel = pNodeListItem;
        pNodeListItem = (NodeListItem *)SelectionList.GetNext(pNodeListItem);
        SelectionList.RemoveItem((NodeListItem *)pNodeListItemToDel);
        delete pNodeListItemToDel;
    }

    // delete the existing back bar nodes
    pNodeListItem = (NodeListItem *)DelList.GetHead();
    pNodeListItemToDel = NULL;

    while(pNodeListItem)
    {
        pNodeListItemToDel = pNodeListItem;
        Node *pParent = pNodeListItem->pNode;

        // if it is the template attrib we are looking at
        // we mean the node on which it is attached
        if (IS_A(pParent, TemplateAttribute))
            pParent = pParent->FindParent();

        if (pParent->FindParent())
        {
            DoInvalidateNodeRegion((NodeRenderableBounded*) pParent, TRUE, FALSE);
            pParent->SetSelected(FALSE);
            DoHideNode(pParent, TRUE);
        }

        pNodeListItem = (NodeListItem *)DelList.GetNext(pNodeListItem);
        DelList.RemoveItem((NodeListItem *)pNodeListItemToDel);
        delete pNodeListItemToDel;
    }

    // set the active layer to the layer that was active before
    // if that is possible
    Layer* pActiveLayer = SliceHelper::FindLayerCalled(ActiveLayerStr);
    if (pActiveLayer != 0) 
    {
        LayerSGallery::MakeActiveLayer(pActiveLayer, FALSE); // don't tell as we are putting it back
    }

    // inform that there may well be more/less layers about to be visible or not
    BROADCAST_TO_ALL(LayerMsg(pActiveLayer, LayerMsg::LayerReason::LAYER_VISIBILITY_CHANGED));

    // the selection will have changed - after all we just deleted it
    BROADCAST_TO_ALL(SelChangingMsg(SelChangingMsg::NONCOLOURATTCHANGED));
    GetApplication()->UpdateSelection();

    ObjChange.Define(OBJCHANGE_FINISHED,cFlags,NULL,this);
    UpdateChangedNodes(&ObjChange, pSpread);
    return TRUE;
}


/********************************************************************************************
>   BOOL OpBarCreation::CleanSelection (Range * pSel, List * pSelectionList, List * pDeletionList)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> K
    Created:    30/3/00
    Purpose:    Has a look at the selection making it into a node list called selection
                if it is on a state layer that is not the current state layer it should be
                excluded from the selection as this must be an accident
                if the item is in the selection but not in any state layer
                it needs to be in the selection so it can be copied and added to the deletion list
                so it can be removed from play.

    Returns:    TRUE if all went well
********************************************************************************************/
BOOL OpBarCreation::CleanSelection (Range * pSel, List * pSelectionList, List * pDeletionList, INT32 LayerNumToCreate)
{
    Layer * pLayer = NULL;
    Node * pCurrent = pSel->FindFirst();
    Node * pParent = NULL;
    Spread* pSpread = Document::GetSelectedSpread();
    BOOL AllOk = TRUE;
    String_256 ButtonBeingEdited = "";

    // for each node in the selection
    while (pCurrent)
    {
        // find the layer on which it resides
        pParent = pCurrent;
        while (!pParent->IsLayer())
            pParent = pParent->FindParent();

        pLayer = (Layer *)pParent;

        BOOL ok = FALSE;

        // use nodes from the layer we are going to be adding to
        if (LayerNumToCreate >=0 && LayerNumToCreate <=4)
        {
            if (pLayer->GetLayerID() == m_RolloverName[LayerNumToCreate])
                ok = TRUE;
        }

        if (!ok)
        {   
            ok = TRUE;
            // test the newly found layer against the state layers
            // if it is not on a state layer it should be in the sel and del lists
            for (INT32 i = 0; i < 5; i++)
            {
                if (pLayer->GetLayerID() == m_RolloverName[i])
                {
                    ok = FALSE;
                    AllOk = FALSE;
                }
            }

            if (!ok)
            {
                // it could be a normal shape drawn on the wrong layer
                // so if it is not tagged with a bar tag make it ok
                ok = TRUE;

                // of course we need to find the template attribs first

                Node * pAttr = SliceHelper::FindNextOfClass(pCurrent,pCurrent, CC_RUNTIME_CLASS(TemplateAttribute));

                while (pAttr)
                {
                    if (!SliceHelper::GetBarName((TemplateAttribute *)pAttr).IsEmpty())
                    {
                        ok = FALSE;
                        break;
                    }

                    pAttr = SliceHelper::FindNextOfClass(pAttr,pCurrent, CC_RUNTIME_CLASS(TemplateAttribute));
                }
            }

            if (ok) // add to the deletion list - its on Layer 1 or whatever
            {
                NodeListItem * pItem = new NodeListItem(pCurrent);
                pDeletionList->AddTail(pItem);
            }
        }
        else // drawn on the layer you are going to copy to? 
            //  still want to delete your original drawing as it wont have the tags required
        {
            // only want to copy from a single button
            // if it is from a different button do not add it to the selection or
            // delete it
            // of course we need to find the template attribs first

            Node * pAttr = SliceHelper::FindNextOfClass(pCurrent,pCurrent, CC_RUNTIME_CLASS(TemplateAttribute));
            BOOL FromThisBar = TRUE;

            while (pAttr)
            {
                if (!SliceHelper::GetBarName((TemplateAttribute *)pAttr).IsEmpty())
                {
                    // the source is from another bar
                    if (m_BarName.CompareTo(SliceHelper::GetBarName((TemplateAttribute *)pAttr)) != 0)
                    {
                        FromThisBar = FALSE;
                    }

                    String_256 AttrSet = SliceHelper::GetSetNameFromAttrib(pAttr);
                    if (ButtonBeingEdited.IsEmpty())
                    {
                        ButtonBeingEdited = AttrSet;
                        break;
                    }
                    else if (ButtonBeingEdited == AttrSet || AttrSet.IsEmpty())
                    {
                        break;
                    }
                    else
                        ok = FALSE; // it is of another bar name set
                    break;
                }

                pAttr = SliceHelper::FindNextOfClass(pAttr,pCurrent, CC_RUNTIME_CLASS(TemplateAttribute));
            }
            
            if (ok && FromThisBar) // delete it from here
            {
                NodeListItem * pItem = new NodeListItem(pCurrent);
                pDeletionList->AddTail(pItem);
            }
        }

        if (ok)
        { // add to the selection list
            NodeListItem * pItem = new NodeListItem(pCurrent);
            pSelectionList->AddTail(pItem);
        }

        // check the next item on the list
        pCurrent = pSel->FindNext(pCurrent);
    }

    return AllOk;
}


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

>   void OpBarCreation::ShowState(INT32 ShowLayer)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/6/00
    Returns:    -
    Purpose:    Makea sure that that just the state is shown, out of the specail states
                Updates the screen drawing and informs other dlgs/galleries such as
                the layer gallery.

********************************************************************************************/
void OpBarCreation::ShowState(INT32 ShowLayer)
{
    OpShowState::ShowState(ShowLayer, this);
}

BOOL OpBarCreation::CreateBarAndBackBar (OpParam* pOpParam)
{

    // unselect the back object and note it down to make into a back bar
    Node * pBackObj = NULL;

    // get the selection
    Range Sel(*(GetApplication()->FindSelection()));

    // set the range flags so it includes shadow and bevel manager nodes
    RangeControl rg = Sel.GetRangeControlFlags();
    rg.PromoteToParent = TRUE;
    Sel.Range::SetRangeControl(rg);

    if (Sel.Count() < 2)
        return FALSE;
    else
    {
        pBackObj = Sel.FindFirst();
        pBackObj->SetSelected(FALSE);
    }


    BOOL ok = CreateOrEditBar(pOpParam);

    if (!ok)
    {
        InformWarning(_R(IDS_FAILLED_MAKE_BAR));
        return FALSE;
    }

    // deselect everything
    NodeRenderableInk::DeselectAll(TRUE);

    // select everything in the group not the group itself
    // dont bother with this now as we deal with true groups extending
/*  if (pBackObj->IsCompound())
    {
        pBackObj = pBackObj->FindFirstChild();
        while (pBackObj)
        {
            if (!pBackObj->IsNodeHidden() && !pBackObj->IsAnAttribute())
                pBackObj->SetSelected(TRUE);

            pBackObj = pBackObj->FindNext();
        }
    }
    else // else select the node
*/      pBackObj->SetSelected(TRUE);

    ok = CreateBackBarFromSelection(pOpParam, TRUE);

    if (!ok)
        InformWarning(_R(IDS_FAILLED_MAKE_BACKBAR));

    return ok;
}

---