shapeops.cpp

Go to the documentation of this file.

// $Id: shapeops.cpp 1776 2007-06-27 11:16:49Z luke $
/* @@tag:xara-cn@@ DO NOT MODIFY THIS LINE
================================XARAHEADERSTART===========================
 
               Xara LX, a vector drawing and manipulation program.
                    Copyright (C) 1993-2006 Xara Group Ltd.
       Copyright on certain contributions may be held in joint with their
              respective authors. See AUTHORS file for details.

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

This file is part of Xara LX.

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


MARKS
-----

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


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

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

/*
*/

#include "camtypes.h"
#include "shapeops.h"

//#include "app.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "blobs.h"
#include "csrstack.h"
//#include "docview.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "nodepath.h"
#include "nodershp.h"
#include "pathedit.h"
//#include "peter.h"
#include "progress.h"
//#include "resource.h"
//#include "rndrgn.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "tool.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "trans2d.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "viewrc.h"
#include "objchge.h"
//#include "spread.h" - in camtypes.h [AUTOMATICALLY REMOVED]

#define PATRACE if(IsUserName("Peter")) TRACE

// Useful macro, given a pointer to a CCObject (or an object derived
// from it) and a string format, it will output the class name of the object. 
// Example usage PACLASSNAME(CurrentNode,"Node class = %s\n");
// N.B. No checking is node or parameters.  Note semi-colon on end.
#define PACLASSNAME(a,b) CCRuntimeClass* Blob; Blob = a->GetRuntimeClass(); PATRACE(b,Blob->m_lpszClassName)


DECLARE_SOURCE( "$Revision: 1776 $" );


CC_IMPLEMENT_MEMDUMP(EditRegularShapeParam, OpParam)    
CC_IMPLEMENT_DYNCREATE(OpEditRegularShape, SelOperation)
CC_IMPLEMENT_DYNCREATE(OpDragRegularShape, SelOperation)
CC_IMPLEMENT_DYNCREATE(OpReformShapeEdge, SelOperation)
CC_IMPLEMENT_DYNCREATE(ChangeShapeDataAction, Action)
CC_IMPLEMENT_DYNCREATE(ChangeShapePointAction, Action)
CC_IMPLEMENT_DYNCREATE(ChangeShapePathAction, Action)
CC_IMPLEMENT_DYNAMIC(ShapeEditedMsg, Msg)
CC_IMPLEMENT_DYNCREATE(OpShapeToggleBase, SelOperation)
CC_IMPLEMENT_DYNCREATE(OpShapeToggleElipPoly, OpShapeToggleBase)
CC_IMPLEMENT_DYNCREATE(OpShapeToggleStellation, OpShapeToggleBase)
CC_IMPLEMENT_DYNCREATE(OpShapeToggleCurvature, OpShapeToggleBase)
CC_IMPLEMENT_DYNCREATE(OpShapeMakeRegular, SelOperation)

CC_IMPLEMENT_DYNCREATE( OpShapeToggleSetNumSides, SelOperation )    
CC_IMPLEMENT_DYNCREATE( OpShapeToggleSetNumSides3, OpShapeToggleSetNumSides )    
CC_IMPLEMENT_DYNCREATE( OpShapeToggleSetNumSides4, OpShapeToggleSetNumSides )    
CC_IMPLEMENT_DYNCREATE( OpShapeToggleSetNumSides5, OpShapeToggleSetNumSides )    
CC_IMPLEMENT_DYNCREATE( OpShapeToggleSetNumSides6, OpShapeToggleSetNumSides )    
CC_IMPLEMENT_DYNCREATE( OpShapeToggleSetNumSides7, OpShapeToggleSetNumSides )    
CC_IMPLEMENT_DYNCREATE( OpShapeToggleSetNumSides8, OpShapeToggleSetNumSides )    
CC_IMPLEMENT_DYNCREATE( OpShapeToggleSetNumSides9, OpShapeToggleSetNumSides )    
CC_IMPLEMENT_DYNCREATE( OpShapeToggleSetNumSides10, OpShapeToggleSetNumSides )    



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

const DocCoord DontCare (0,0);

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

>   ShapeEditedMsg::ShapeEditedMsg(NodeRegularShape* pChangeShape, Spread* pParentSpread) 

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    17/1/95
    Inputs:     pChangeShape - pointer to the edited shape
                pParentSpread - pointer to the parent spread of the object
    Purpose:    initilise a ShapeEditedMsg
    SeeAlso:    ShapeEditedMsg

********************************************************************************************/
ShapeEditedMsg::ShapeEditedMsg(NodeRegularShape* pChangeShape, Spread* pParentSpread)                           
{                              
    pShape = pChangeShape;
    pSpread = pParentSpread;
}


//                                     EditRegularShapeParam                                //



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

>   EditRegularShapeParam::EditRegularShapeParam(NodeRegularShape* ChangeShapes) 

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    08/12/94    
    Inputs:     ChangeShapes - pointer to the shape to change OR NULL to change all selected shapes                                   
    Purpose:    EditRegularShapeParam constructor - sets all member items to unchange.
                After constructing the object, the caller should set those items that it wants
                OpEditRegularShape to change.

********************************************************************************************/
EditRegularShapeParam::EditRegularShapeParam(NodeRegularShape* ChangeShapes)                                
{                              
    ShapeToChange = ChangeShapes;
    ShapesToAffect = AFFECT_ALL;
    
    NewEdgePath1 = NULL;    
    NewEdgePath2 = NULL;    
    NewNumSides = 0;        
    NewCircular = CHANGE_DONTCARE;
    NewStellated = CHANGE_DONTCARE;
    NewPrimaryCurvature = CHANGE_DONTCARE;
    NewStellationCurvature = CHANGE_DONTCARE;
    NewStellRadiusToPrimary = -1.0; 
    NewPrimaryCurveToPrimary = -1.0;    
    NewStellCurveToStell = -1.0;        
    NewStellOffsetRatio = -1000.0;
//  NewCentrePoint = DontCare;      
//  NewMajorAxes = DontCare;        
//  NewMinorAxes = DontCare;        

    TranslateTo = DontCare;     
    TranslateBy = DontCare;     
    SetRadiusLength = -1;
    AddRadiusLength = -1;
    RotateTo = -1000.0;         
    RotateBy = -1000.0;         
    SetStellationLength = -1;   
    AddStellationLength = -1;   
    SetStellationOffset = -1000.0;
    AddStellationOffset = -1000.0;
    AddPrimaryCurvature = 0.0;
    AddStellationCurvature = 0.0;
    SetMajorAxisLength = 0;
    AddMajorAxisLength = 0;
    SetMinorAxisLength = 0;
    AddMinorAxisLength = 0;
}



//                                     OpEditRegularShape                                   //

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

>   OpEditRegularShape::OpEditRegularShape() 

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    08/12/94                                          
    Purpose:    OpEditRegularShape constructor - does nothing itself

********************************************************************************************/
OpEditRegularShape::OpEditRegularShape(): SelOperation()                                
{                              
}



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

>   BOOL OpEditRegularShape::Init()

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

********************************************************************************************/
BOOL OpEditRegularShape::Init()
{
    BOOL Success = RegisterOpDescriptor(0, 
                                        _R(IDS_EDITREGULARSHAPEOP),
                                        CC_RUNTIME_CLASS(OpEditRegularShape), 
                                        OPTOKEN_EDITREGULARSHAPE,
                                        OpEditRegularShape::GetState);

    if (Success)
        Success = OpShapeToggleElipPoly::Init();
    if (Success)
        Success = OpShapeToggleStellation::Init();
    if (Success)
        Success = OpShapeToggleCurvature::Init();
    if (Success)
        Success = OpShapeToggleSetNumSides::Init();
    if (Success)
        Success = OpShapeMakeRegular::Init();

    return Success;
}               
    


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

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

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    08/12/94
    Returns:    The state of the OpEditRegularShape
    Purpose:    For finding the OpEditRegularShape's state. 
    SeeAlso:    -

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

    return OpSt;                                 
}



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

>   void OpEditRegularShape::DoWithParam(OpDescriptor* pOpDesc, OpParam* pEntryOpParam)

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    08/12/94
    Inputs:     OpDescriptor (unused)
                pOpParam - pointer to the parameter object.
    Purpose:    Performs the edit regular shapes operation. 
    Errors:     -
    SeeAlso:    EditRegularShapeParam, OpEditRegularShape::CarryOut

********************************************************************************************/
void OpEditRegularShape::DoWithParam(OpDescriptor* pOpDesc, OpParam* pEntryOpParam)
{   
    EditRegularShapeParam* pOpParam = (EditRegularShapeParam*)pEntryOpParam;
    
    // Tell the operation system its kickoff time.
    if (DoStartSelOp(FALSE))
    {
        BOOL Complete = TRUE;

        // Data used by AllowOp() to ask the node if it's ok to do the op
        ObjChangeFlags cFlags;
        ObjChangeParam ObjChange(OBJCHANGE_STARTING,cFlags,NULL,this);

        // Either change just one shape or all selected shapes.
        if (pOpParam->ShapeToChange != NULL)
        {
            if (ShouldDoThisShape(pOpParam->ShapeToChange, pOpParam->ShapesToAffect))
            {
                if (pOpParam->ShapeToChange->AllowOp(&ObjChange))                   // Will node allow the op?
                    Complete = CarryOut(pOpParam->ShapeToChange, pOpParam);
            }
        }
        else
        {
            // Obtain the current selections and the first node in the selection
            SelRange*   Selected = GetApplication()->FindSelection();
            Node*       pNode = Selected->FindFirst();

            while ((pNode != NULL) && Complete)
            {
                if (IS_A(pNode,NodeRegularShape))
                {
                    if (ShouldDoThisShape((NodeRegularShape*)pNode, pOpParam->ShapesToAffect))
                    {
                        if (pNode->AllowOp(&ObjChange))                             // Will node allow the op?
                            Complete = CarryOut((NodeRegularShape*)pNode, pOpParam);
                    }
                }
                pNode = Selected->FindNext(pNode);
            }
        }

        GetApplication()->FindSelection()->Update(FALSE);
    
        if (Complete)
        {
            // updated effected parents
            ObjChange.Define(OBJCHANGE_FINISHED,cFlags,NULL,this);
            Complete = UpdateChangedNodes(&ObjChange);
        }

        // See if anything failed
        if (!Complete)
        {
            FailAndExecute();
        }
    }
    else
    {
        FailAndExecute();
    }

    End();
}



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

>   BOOL OpEditRegularShape::CarryOut(NodeRegularShape* ShapeToEdit, EditRegularShapeParam* NewShapeData)

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    08/12/94
    Inputs:     ShapeToEdit points to the Shape to change.
                NewShapeData points to the parameter object with the changes data.
    Purpose:    Performs the edit regular shapes operation on one particular shape
    Errors:     ERROR2 if there is no current DocView
    SeeAlso:    EditRegularShapeParam, OpEditRegularShape::DoWithParam

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

BOOL OpEditRegularShape::CarryOut(NodeRegularShape* ShapeToEdit, EditRegularShapeParam* NewShapeData)
{
    // Create an action to will cause the shape to recalc its bounds
    if (RecalcBoundsAction::DoRecalc(this, &UndoActions, ShapeToEdit) == AC_FAIL)
    {
        return FALSE;
    }

    // See if we should change the polygon/circular flag
    if (NewShapeData->NewCircular != EditRegularShapeParam::CHANGE_DONTCARE)
    {
        if (ChangeShapeDataAction::DoToggle(this, &UndoActions, ShapeToEdit, ChangeShapeDataAction::CHANGE_CIRCULAR,
                                                ShapeToEdit->IsCircular() ? 1.0 : 0.0) == AC_FAIL)
        {
            return FALSE;
        }
        ShapeToEdit->SetCircular(NewShapeData->NewCircular == EditRegularShapeParam::CHANGE_SETTRUE);
    }

    // See if we should change the stellated flag
    if (NewShapeData->NewStellated != EditRegularShapeParam::CHANGE_DONTCARE)
    {
/*      // If were turning off stellation them we may need to fix the primary curvature ratio
        if (NewShapeData->NewStellated == EditRegularShapeParam::CHANGE_SETFALSE)
        {
            if (ShapeToEdit->GetPrimaryCurveToPrimary() > 0.5)
                NewShapeData->NewPrimaryCurveToPrimary = 0.2;
        }
        else
        {
            // If we've turned on stellation them we may need to fix both curvature ratios
            if (ShapeToEdit->GetPrimaryCurveToPrimary()+ShapeToEdit->GetStellCurveToStell() > 1.0)
            {
                NewShapeData->NewPrimaryCurveToPrimary = 0.2;
                NewShapeData->NewStellCurveToStell = 0.2;
            }
        }*/

        if (ChangeShapeDataAction::DoToggle(this, &UndoActions, ShapeToEdit, ChangeShapeDataAction::CHANGE_STELLATED,
                                                 ShapeToEdit->IsStellated() ? 1.0 : 0.0) == AC_FAIL)
        {
            return FALSE;
        }
        ShapeToEdit->SetStellated(NewShapeData->NewStellated == EditRegularShapeParam::CHANGE_SETTRUE);
    }

    // See if we should change the primary curvature flag
    if (NewShapeData->NewPrimaryCurvature != EditRegularShapeParam::CHANGE_DONTCARE)
    {
        if (ChangeShapeDataAction::DoToggle(this, &UndoActions, ShapeToEdit, ChangeShapeDataAction::CHANGE_PRIMARYCURVATURE,
                                                 ShapeToEdit->IsPrimaryCurvature() ? 1.0 : 0.0) == AC_FAIL)
        {
            return FALSE;
        }
        ShapeToEdit->SetPrimaryCurvature(NewShapeData->NewPrimaryCurvature == EditRegularShapeParam::CHANGE_SETTRUE);
    }

    // See if we should change the stellation curvature flag
    if (NewShapeData->NewStellationCurvature != EditRegularShapeParam::CHANGE_DONTCARE)
    {
        if (ChangeShapeDataAction::DoToggle(this, &UndoActions, ShapeToEdit, ChangeShapeDataAction::CHANGE_STELLATIONCURVATURE,
                                                 ShapeToEdit->IsStellationCurvature() ? 1.0 : 0.0) == AC_FAIL)
        {
            return FALSE;
        }
        ShapeToEdit->SetStellationCurvature(NewShapeData->NewStellationCurvature == EditRegularShapeParam::CHANGE_SETTRUE);
    }

    // See if we should change the stellation offset
    if (NewShapeData->NewStellOffsetRatio != -1000.0)
    {
        if (ChangeShapeDataAction::DoToggle(this, &UndoActions, ShapeToEdit, 
                ChangeShapeDataAction::CHANGE_STELLATIONOFFSET, ShapeToEdit->GetStellationRatio()) == AC_FAIL)
        {
            return FALSE;
        }
        ShapeToEdit->SetStellationRatio(NewShapeData->NewStellOffsetRatio);
    }

    // See if we should change the number of sides
    if (NewShapeData->NewNumSides != 0)
    {
        if (ChangeShapeDataAction::DoToggle(this, &UndoActions, ShapeToEdit, 
                ChangeShapeDataAction::CHANGE_NUMSIDES, ShapeToEdit->GetNumSides()) == AC_FAIL)
        {
            return FALSE;
        }
        ShapeToEdit->SetNumSides(NewShapeData->NewNumSides);
    }

    // See if we should change the stellation radius ratio
    if (NewShapeData->NewStellRadiusToPrimary != -1.0)
    {
        if (ChangeShapeDataAction::DoToggle(this, &UndoActions, ShapeToEdit, 
                ChangeShapeDataAction::CHANGE_STELLRADIUSTOPRIMARY, 
                                            ShapeToEdit->GetStellRadiusToPrimary()) == AC_FAIL)
        {
            return FALSE;
        }
        ShapeToEdit->SetStellRadiusToPrimary(NewShapeData->NewStellRadiusToPrimary);
    }

    // See if we should change the primary curvature ratio
    if (NewShapeData->NewPrimaryCurveToPrimary != -1.0)
    {
        double NewRatio = NewShapeData->NewPrimaryCurveToPrimary;
/*      if (ShapeToEdit->IsStellated())
        {
            double StellRatio = ShapeToEdit->GetStellCurveToStell();
            if (NewShapeData->NewStellCurveToStell != -1.0)
                StellRatio = NewShapeData->NewStellCurveToStell;    

            NewRatio = __min(1.0-StellRatio, NewShapeData->NewPrimaryCurveToPrimary); 
        }
        else
        {
            NewRatio = __min(0.5, NewShapeData->NewPrimaryCurveToPrimary); 
        }*/
        
        if (ChangeShapeDataAction::DoToggle(this, &UndoActions, ShapeToEdit, 
                ChangeShapeDataAction::CHANGE_PRIMARYCURVETOPRIMARY, 
                                            ShapeToEdit->GetPrimaryCurveToPrimary()) == AC_FAIL)
        {
            return FALSE;
        }
        ShapeToEdit->SetPrimaryCurveToPrimary(NewRatio);
    }

    // See if we should bump the primary curvature ratio
    if (NewShapeData->AddPrimaryCurvature != -0.0)
    {
        double NewRatio = ShapeToEdit->GetPrimaryCurveToPrimary() + NewShapeData->AddPrimaryCurvature;
/*      if (ShapeToEdit->IsStellated())
        {
            NewRatio = __min(1.0-ShapeToEdit->GetStellCurveToStell(), NewRatio);
        }
        else
        {
            NewRatio = __min(0.5, NewRatio); 
        }*/
        NewRatio = max( 0.0, NewRatio );
        
        if (ChangeShapeDataAction::DoToggle(this, &UndoActions, ShapeToEdit, 
                ChangeShapeDataAction::CHANGE_PRIMARYCURVETOPRIMARY, 
                                            ShapeToEdit->GetPrimaryCurveToPrimary()) == AC_FAIL)
        {
            return FALSE;
        }
        ShapeToEdit->SetPrimaryCurveToPrimary(NewRatio);
    }

    // See if we should change the stellation curvature ratio
    if (NewShapeData->NewStellCurveToStell != -1.0)
    {
        double NewRatio = NewShapeData->NewStellCurveToStell;
        
//      NewRatio = __min (1.0-ShapeToEdit->GetPrimaryCurveToPrimary(), NewShapeData->NewStellCurveToStell); 

        if (ChangeShapeDataAction::DoToggle(this, &UndoActions, ShapeToEdit, 
                ChangeShapeDataAction::CHANGE_STELLCURVETOSTELL, 
                                            ShapeToEdit->GetStellCurveToStell()) == AC_FAIL)
        {
            return FALSE;
        }
        ShapeToEdit->SetStellCurveToStell(NewRatio);
    }

    // See if we should bump the stellation curvature ratio
    if (NewShapeData->AddStellationCurvature != 0.0)
    {
        double NewRatio = ShapeToEdit->GetStellCurveToStell() + NewShapeData->AddStellationCurvature;
//      NewRatio = __min(1.0-ShapeToEdit->GetPrimaryCurveToPrimary(), NewRatio); 
        NewRatio = max( 0.0, NewRatio );
        
        if (ChangeShapeDataAction::DoToggle(this, &UndoActions, ShapeToEdit, 
                ChangeShapeDataAction::CHANGE_PRIMARYCURVETOPRIMARY, 
                                            ShapeToEdit->GetStellCurveToStell()) == AC_FAIL)
        {
            return FALSE;
        }
        ShapeToEdit->SetStellCurveToStell(NewRatio);
    }

    // See if we should change the minor axes
/*  if (NewShapeData->NewMinorAxes != DontCare)
    {
        if (ChangeShapePointAction::DoToggle(this, &UndoActions, ShapeToEdit, 
                        ChangeShapePointAction::CHANGE_MINOR, ShapeToEdit->GetMinorAxes()) == AC_FAIL)
        {
            return FALSE;
        }
        ShapeToEdit->SetMinorAxes(NewShapeData->NewMinorAxes);
    }

    // See if we should change the major axes
    if (NewShapeData->NewMajorAxes != DontCare)
    {
        if (ChangeShapePointAction::DoToggle(this, &UndoActions, ShapeToEdit, 
                        ChangeShapePointAction::CHANGE_MAJOR, ShapeToEdit->GetMajorAxes()) == AC_FAIL)
        {
            return FALSE;
        }
        ShapeToEdit->SetMajorAxes(NewShapeData->NewMajorAxes);
    }*/

    // See if we should change the size of the shape to a new length
    // OR see if we should change the size of the shape by a specified ammount
    if ((NewShapeData->SetRadiusLength != -1) || (NewShapeData->AddRadiusLength != -1) )
    {
        // Get scaling factor
        fixed16 ScaleFactor;
        const double CurrentLength = ShapeToEdit->GetCentrePoint().Distance(ShapeToEdit->GetMajorAxes()) ;
        if (CurrentLength != 0.0)
        {
            if (NewShapeData->SetRadiusLength != -1)
            {
                double RequiredLength = NewShapeData->SetRadiusLength;
                ScaleFactor = RequiredLength / CurrentLength;
            }
            else
            {
                double RequiredAddition = NewShapeData->AddRadiusLength;
                ScaleFactor = (RequiredAddition + CurrentLength) / CurrentLength;
            }       
        }
        else
            ScaleFactor = 1.0;
        
        // Translate to origin, scale and translate back
        Trans2DMatrix* TransOriginMat = new Trans2DMatrix(-ShapeToEdit->GetCentrePoint().x, -ShapeToEdit->GetCentrePoint().y);
        Trans2DMatrix* ScaleMat = new Trans2DMatrix(Matrix(ScaleFactor,ScaleFactor));
        Trans2DMatrix* TransBackMat = new Trans2DMatrix(ShapeToEdit->GetCentrePoint().x, ShapeToEdit->GetCentrePoint().y);
        if (!(DoTransformNode(ShapeToEdit, TransOriginMat) && DoTransformNode(ShapeToEdit, ScaleMat)
                                                            && DoTransformNode(ShapeToEdit, TransBackMat) ))
        {
            return FALSE;
        }
    }

    // See if we should change the MajorAxis of the shape to a new length
    // OR see if we should change the MajorAxis of the shape by a specified ammount
    if ((NewShapeData->SetMajorAxisLength != 0) || (NewShapeData->AddMajorAxisLength != 0) )
    {
        // Get scaling factor
        fixed16 ScaleFactor;
        const double CurrentLength = ShapeToEdit->GetCentrePoint().Distance(ShapeToEdit->GetMajorAxes()) ;
        if (CurrentLength != 0.0)
        {
            if (NewShapeData->SetMajorAxisLength != 0)
            {
                double RequiredLength = NewShapeData->SetMajorAxisLength;
                ScaleFactor = RequiredLength / CurrentLength;
            }
            else
            {
                double RequiredAddition = NewShapeData->AddMajorAxisLength;
                ScaleFactor = (RequiredAddition + CurrentLength) / CurrentLength;
            }       
        }
        else
            ScaleFactor = 1.0;

        if (ChangeShapePointAction::DoToggle(this, &UndoActions, ShapeToEdit, 
                        ChangeShapePointAction::CHANGE_MAJOR, ShapeToEdit->GetUTMajorAxes()) == AC_FAIL)
        {
            return FALSE;
        }

        // Scale the major axes relative to the centre point
        Matrix ScaleMatrix(FIXED16(1.0), ScaleFactor);
        DocCoord Offset = ShapeToEdit->GetUTMajorAxes() - ShapeToEdit->GetUTCentrePoint();
        ScaleMatrix.transform(&Offset);
        ShapeToEdit->SetMajorAxes(ShapeToEdit->GetUTCentrePoint() + Offset);
    }

    // See if we should change the MinorAxis of the shape to a new length
    // OR see if we should change the MinorAxis of the shape by a specified ammount
    if ((NewShapeData->SetMinorAxisLength != 0) || (NewShapeData->AddMinorAxisLength != 0) )
    {
        // Get scaling factor
        fixed16 ScaleFactor;
        const double CurrentLength = ShapeToEdit->GetCentrePoint().Distance(ShapeToEdit->GetMinorAxes()) ;
        if (CurrentLength != 0.0)
        {
            if (NewShapeData->SetMinorAxisLength != 0)
            {
                double RequiredLength = NewShapeData->SetMinorAxisLength;
                ScaleFactor = RequiredLength / CurrentLength;
            }
            else
            {
                double RequiredAddition = NewShapeData->AddMinorAxisLength;
                ScaleFactor = (RequiredAddition + CurrentLength) / CurrentLength;
            }       
        }
        else
            ScaleFactor = 1.0;

        if (ChangeShapePointAction::DoToggle(this, &UndoActions, ShapeToEdit, 
                        ChangeShapePointAction::CHANGE_MINOR, ShapeToEdit->GetUTMinorAxes()) == AC_FAIL)
        {
            return FALSE;
        }

        // Scale the minor axes relative to the centre point
        Matrix ScaleMatrix(ScaleFactor, FIXED16(1.0));
        DocCoord Offset = ShapeToEdit->GetUTMinorAxes() - ShapeToEdit->GetUTCentrePoint();
        ScaleMatrix.transform(&Offset);
        ShapeToEdit->SetMinorAxes(ShapeToEdit->GetUTCentrePoint() + Offset);
    }

    // See if we should change the size of the stellation radius to a new length
    // OR see if we should change the size of the stellation radius by a specified ammount
    if ((NewShapeData->SetStellationLength != -1) || (NewShapeData->AddStellationLength != -1) )
    {
        const double CurrentLength = ShapeToEdit->GetCentrePoint().Distance(ShapeToEdit->GetMajorAxes()) ;
        double NewRatio;
        if (NewShapeData->SetStellationLength != -1)
        {
            // Get the current length of the shape and get the ratio from that
            NewRatio = double( min( fabs( NewShapeData->SetStellationLength / CurrentLength ), 1.0 ) );
        }
        else
        {
            double NewLength = fabs(CurrentLength - NewShapeData->AddStellationLength);
            NewRatio = double( min( fabs( ( NewLength / CurrentLength ) - 1 + ShapeToEdit->GetStellRadiusToPrimary() ), 1.0 ) );
        }

        if (ChangeShapeDataAction::DoToggle(this, &UndoActions, ShapeToEdit, 
                ChangeShapeDataAction::CHANGE_STELLRADIUSTOPRIMARY, 
                                            ShapeToEdit->GetStellRadiusToPrimary()) == AC_FAIL)
        {
            return FALSE;
        }
        ShapeToEdit->SetStellRadiusToPrimary(NewRatio);
    }

    // See if we should rotate the shape to a specific angle
    // OR see if we should rotate the shape by a specified ammount
    if ((NewShapeData->RotateTo != -1000.0) || (NewShapeData->RotateBy != -1000.0) )
    {
        // Get rotate matrix
        ANGLE RotateBy;
        const DocCoord MajorOrigin = ShapeToEdit->GetMajorAxes() - ShapeToEdit->GetCentrePoint();
        const double CurrentAngle = atan2((double)MajorOrigin.y, (double)MajorOrigin.x) ;
        if (NewShapeData->RotateTo != -1000.0)
        {
            RotateBy = -(CurrentAngle - NewShapeData->RotateTo) * (180/PI); 
        }
        else
        {                                                                  
            RotateBy = NewShapeData->RotateBy * (180/PI); 
        }       
        
        Trans2DMatrix* RotateMat = new Trans2DMatrix(ShapeToEdit->GetCentrePoint(), RotateBy);
        if (!DoTransformNode(ShapeToEdit, RotateMat))
        {
            return FALSE;
        }
    }

    // See if we should change the stellation offset to a new angle
    // OR see if we should change the stellation offset by a specified ammount
    if ((NewShapeData->SetStellationOffset != -1000.0) || (NewShapeData->AddStellationOffset != -1000.0) )
    {
        const UINT32 NumSides = ShapeToEdit->GetNumSides();
        const double OppositeRatio = 180.0/(360.0/NumSides);
        double NewRatio;
        if (NewShapeData->SetStellationOffset != -1000.0)
        {
            NewRatio = OppositeRatio * (NewShapeData->SetStellationOffset / 180.0);
        }
        else
        {
            double NewOffset = (ShapeToEdit->GetStellationRatio()/OppositeRatio)*180.0 + NewShapeData->AddStellationOffset;

            if (NewOffset < -180.0)
                NewOffset = 180.0 + (NewOffset + 180.0);
            if (NewOffset > 180.0)
                NewOffset = -180.0 + (NewOffset - 180.0);
            NewRatio = OppositeRatio * (NewOffset / 180.0);
        }

        if (ChangeShapeDataAction::DoToggle(this, &UndoActions, ShapeToEdit, 
                ChangeShapeDataAction::CHANGE_STELLATIONOFFSET, ShapeToEdit->GetStellationRatio()) == AC_FAIL)
        {
            return FALSE;
        }
        ShapeToEdit->SetStellationRatio(NewRatio);
    }

    // See if we should change the centre point
/*  if (NewShapeData->NewCentrePoint != DontCare)
    {
        if (ChangeShapePointAction::DoToggle(this, &UndoActions, ShapeToEdit, 
                    ChangeShapePointAction::CHANGE_CENTRE, ShapeToEdit->GetCentrePoint()) == AC_FAIL)
        {
            return FALSE;
        }
        ShapeToEdit->SetCentrePoint(NewShapeData->NewCentrePoint);
    }*/

    // See if we should translate the shape to an exact location
    if (NewShapeData->TranslateTo != DontCare)
    {
        DocCoord Offset = NewShapeData->TranslateTo - ShapeToEdit->GetCentrePoint() ;

        Trans2DMatrix* TransMat = new Trans2DMatrix(Offset.x, Offset.y);
        if (!DoTransformNode(ShapeToEdit, TransMat))
            return FALSE;
    }

    // See if we should translate the shape by an offset
    if (NewShapeData->TranslateBy != DontCare)
    {
        Trans2DMatrix* TransMat = new Trans2DMatrix(NewShapeData->TranslateBy.x, NewShapeData->TranslateBy.y);
        if (!DoTransformNode(ShapeToEdit, TransMat))
            return FALSE;
    }

    // See if we should change edge path one
    if (NewShapeData->NewEdgePath1 != NULL)
    {
        if (ChangeShapePathAction::DoReshape(this, &UndoActions, ShapeToEdit, 
                    ChangeShapePathAction::CHANGE_PATH1, &(ShapeToEdit->EdgePath1)) == AC_FAIL)
        {
            return FALSE;
        }
        ShapeToEdit->EdgePath1.ClearPath();
        ShapeToEdit->EdgePath1.CopyPathDataFrom(NewShapeData->NewEdgePath1);        
    }

    // See if we should change edge path two
    if (NewShapeData->NewEdgePath2 != NULL)
    {
        if (ChangeShapePathAction::DoReshape(this, &UndoActions, ShapeToEdit, 
                    ChangeShapePathAction::CHANGE_PATH2, &(ShapeToEdit->EdgePath2)) == AC_FAIL)
        {
            return FALSE;
        }
        ShapeToEdit->EdgePath2.ClearPath();
        ShapeToEdit->EdgePath2.CopyPathDataFrom(NewShapeData->NewEdgePath2);        
    }

    // Invalidate the shapes bounding rect as it's changed
    ShapeToEdit->InvalidateBoundingRect();
    ShapeToEdit->InvalidateCache();

    // Cause a redraw of the shape with its end bounds
    if (RecordBoundsAction::DoRecord(this, &UndoActions, ShapeToEdit) == AC_FAIL)
    {
        return FALSE;
    }

    return TRUE;
}



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

>   BOOL OpEditRegularShape::ShouldDoThisShape(NodeRegularShape* pShape, EditRegularShapeParam::AffectShape Allowance)

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    26/03/95
    Inputs:     pShape - points to a regular shape 
                Allowance - the current shape allowance mode
    Outputs:    -
    Returns:    TRUE if this shape should be changed in this operation
                FALSE if this shape should not be changed
    Purpose:    Do decide wether or not the shape should be edited.  The decision is based upon
                the Allowance mode.
    Errors:     -
    SeeAlso:    -

********************************************************************************************/
BOOL OpEditRegularShape::ShouldDoThisShape(NodeRegularShape* pShape, EditRegularShapeParam::AffectShape Allowance)
{
    ERROR2IF(pShape == NULL, FALSE, "Can't edit a NULL shape!");

    switch (Allowance)
    {
        case EditRegularShapeParam::AFFECT_ALL:
            return TRUE;
            break;
        case EditRegularShapeParam::AFFECT_ELLIPSES:
            return pShape->IsCircular();
            break;
        case EditRegularShapeParam::AFFECT_RECTANGLES:
            return (!pShape->IsCircular() && (pShape->GetNumSides() == 4) );
            break;
        default:
            ERROR3("Allowance was not known");
            return FALSE;
    }
}




// The ChangeShapeDataAction class                                                           //

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

>   ChangeShapeDataAction::ChangeShapeDataAction()

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    10/12/94
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Constructor for the action to toggle a data item of a regular state.
                Initialises the data members to sensible defaults.
    Errors:     -
    SeeAlso:    -

********************************************************************************************/
ChangeShapeDataAction::ChangeShapeDataAction()
{
    pToggleShape = NULL;
    ChangeItemID = CHANGE_NUMSIDES;
    NewValue = 0.0;
}



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

>   ActionCode ChangeShapeDataAction::Init( Operation* pOp,
                                            ActionList* pActionList,
                                            NodeRegularShape* pShape,
                                            enum ChangeItem NewItem,
                                            double NewData,
                                            Action** NewAction)

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    10/12/94
    Inputs:     pOp is the pointer to the operation to which this action belongs
                pShape is a pointer to the NodeRegularShape to change
                NewItem identifes the data item that shoudl be changed
                NewData is the value this action should set the data item to
                pActionList is the action list to which this action should be added
    Outputs:    NewAction is a pointer to a pointer to an action, allowing the function to
                return a pointer to the created action
    Returns:    ActionCode, one of AC_OK, AC_NO_RECORD or AC_FAIL
    Purpose:    This is the function which creates an instance of this action. If there is no
                room in the undo buffer (which is determined by the base class Init function
                called within) the function will either return AC_NO_RECORD which means the
                operation can continue, but no undo information needs to be stored, or AC_OK
                which means the operation should continue AND record undo information. If
                the function returns AC_FAIL, there was not enough memory to record the undo
                information, and the user has decided not to continue with the operation.
    Errors:     -
    SeeAlso:    Action::Init()

********************************************************************************************/
ActionCode ChangeShapeDataAction::Init( Operation* pOp,
                                        ActionList* pActionList,
                                        NodeRegularShape* pShape,
                                        enum ChangeItem NewItem,
                                        double NewData,
                                        Action** NewAction)
{
    UINT32 ActSize = sizeof(ChangeShapeDataAction);         

    ActionCode Ac = Action::Init( pOp, pActionList, ActSize, CC_RUNTIME_CLASS(ChangeShapeDataAction), NewAction);
    if ((Ac == AC_OK) && (*NewAction != NULL))
    {
        ((ChangeShapeDataAction*)*NewAction)->pToggleShape = pShape;
        ((ChangeShapeDataAction*)*NewAction)->ChangeItemID = NewItem;
        ((ChangeShapeDataAction*)*NewAction)->NewValue = NewData;
    }
    return Ac;
}



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

>   ActionCode ChangeShapeDataAction::DoToggle(Operation* pOp,
                                            ActionList* pActionList,
                                            NodeRegularShape* pShape,
                                            enum ChangeItem NewItem,
                                            double NewData)

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    10/12/94
    Inputs:     pOp is the currently running operation.
                pActionList is a pointer ot the action list to which the action should be appended.
                pShape is a pointer to the NodeRegularShape to change.
                NewItem identifes the data item that shoudl be changed
                NewData is the value this action should set the data item to
    Outputs:    -
    Returns:    Action code which indicates success or failure to create the action
    Purpose:    This static function makes it a little easier to use this action. It creates an instance
                of this action and appends it to the action list.
    Errors:     -
    SeeAlso:    -

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

ActionCode ChangeShapeDataAction::DoToggle(Operation* pOp,
                                        ActionList* pActionList,
                                        NodeRegularShape* pShape,
                                        enum ChangeItem NewItem,
                                        double NewData)
{
    // Get the runtime class info on this object and create a pointer to another object of the same type 
    ChangeShapeDataAction* NewAction; 

    // Now call the init function to set everything up
    ActionCode Act = ChangeShapeDataAction::Init(pOp, pActionList, pShape, NewItem, NewData, (Action**)&NewAction);
    return Act;
}



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

>   ActionCode ChangeShapeDataAction::Execute()

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    09/12/94
    Inputs:     -
    Outputs:    -
    Returns:    ActionCode, either AC_OK, AC_NORECORD or AC_FAIL
    Purpose:    Changes a data item in a Regular shape, createing another
                ChangeShapeDataAction to undo the change.
    Errors:     ERROR3 if the internal shape pointer was NULL.  ERROR2 checks on individual
                changes.
    SeeAlso:    -

********************************************************************************************/
ActionCode ChangeShapeDataAction::Execute()
{
    ERROR3IF(pToggleShape == NULL, "Pointer to shape was NULL.  Did you call Init/DoToggle OR handle their failure?");

    // Get the runtime class info on this object and create a pointer to another object of the same type 
    ChangeShapeDataAction *ReAction; 
    ActionCode Act = AC_FAIL;
    double ReData = 0.0;

    switch (ChangeItemID)
    {
        case CHANGE_NUMSIDES:
            ReData = pToggleShape->GetNumSides();
            break;
        case CHANGE_CIRCULAR:
            ReData = pToggleShape->IsCircular() ? 1.0 : 0.0;    
            break;
        case CHANGE_STELLATED:
            ReData = pToggleShape->IsStellated() ? 1.0 : 0.0;   
            break;
        case CHANGE_STELLRADIUSTOPRIMARY:
            ReData = pToggleShape->GetStellRadiusToPrimary();   
            break;
        case CHANGE_PRIMARYCURVATURE:
            ReData = pToggleShape->IsPrimaryCurvature() ? 1.0 : 0.0;    
            break;
        case CHANGE_STELLATIONCURVATURE:
            ReData = pToggleShape->IsStellationCurvature() ? 1.0 : 0.0; 
            break;
        case CHANGE_PRIMARYCURVETOPRIMARY:
            ReData = pToggleShape->GetPrimaryCurveToPrimary();  
            break;
        case CHANGE_STELLCURVETOSTELL:
            ReData = pToggleShape->GetStellCurveToStell();  
            break;
        case CHANGE_STELLATIONOFFSET:
            ReData = pToggleShape->GetStellationRatio();    
            break;
        default:
            ERROR2(Act, "What was that Change ID?!");
            break;
    }
    
    // Create a redo action for this action
    if (pToggleShape != NULL)
    {
        Act = ChangeShapeDataAction::Init(pOperation, pOppositeActLst, pToggleShape, ChangeItemID, 
                                                                            ReData, (Action**)(&ReAction));

        if (Act == AC_FAIL)
            return AC_FAIL;

        // Now do the actual action
        switch (ChangeItemID)
        {
            case CHANGE_NUMSIDES:
                pToggleShape->SetNumSides((UINT32)NewValue);
                break;
            case CHANGE_CIRCULAR:
                pToggleShape->SetCircular(NewValue == 1.0 ? TRUE : FALSE);
                break;
            case CHANGE_STELLATED:
                pToggleShape->SetStellated(NewValue == 1.0 ? TRUE : FALSE);
                break;
            case CHANGE_STELLRADIUSTOPRIMARY:
                pToggleShape->SetStellRadiusToPrimary(NewValue);
                break;
            case CHANGE_PRIMARYCURVATURE:
                pToggleShape->SetPrimaryCurvature(NewValue == 1.0 ?