penedit.cpp

Go to the documentation of this file.

// $Id: penedit.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============================
 */
// The pen tools edit code. Contains all operations provided for the 
// pen tool
// Created by Mike on 25/9/94

#include "camtypes.h"
//#include "resource.h"
#include "penedit.h"
//#include "mike.h"
#include "osrndrgn.h"
//#include "docview.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "nodepath.h"
//#include "document.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "ops.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "selop.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "progress.h"
//#include "attrmgr.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "pathedit.h"
//#include "app.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "stockcol.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "spread.h" - in camtypes.h [AUTOMATICALLY REMOVED]

CC_IMPLEMENT_DYNCREATE( OpPenHandles, Operation )
CC_IMPLEMENT_DYNCREATE( OpPenDragBlobs, OpPenHandles )
CC_IMPLEMENT_DYNCREATE( OpPenCreateInternal, OpPenDragBlobs )
CC_IMPLEMENT_DYNCREATE( OpPenEditInternal, OpPenDragBlobs )
CC_IMPLEMENT_DYNCREATE( OpPenEditPath, OpPenHandles )
CC_IMPLEMENT_DYNCREATE( OpPenCreatePath, OpPenEditPath )
CC_IMPLEMENT_DYNCREATE( OpPenAddElement, OpPenEditPath )
CC_IMPLEMENT_DYNCREATE( OpPenClosePath, OpPenEditPath )

CC_IMPLEMENT_DYNCREATE( OpAddPath, SelOperation )
CC_IMPLEMENT_DYNCREATE( OpAddNewPath, OpAddPath )
CC_IMPLEMENT_DYNCREATE( OpAddPathToPath, OpAddPath )
CC_IMPLEMENT_DYNCREATE( OpClosePathWithPath, OpAddPath )


#define new CAM_DEBUG_NEW

/*
*/


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

>  HandleFlags::HandleFlags(BOOL rTrackEnd = TRUE,
                            BOOL rGhostEnd = TRUE,
                            BOOL TrackPtMoves = TRUE,
                            BOOL TrackPtSpins = FALSE,
                            BOOL GhostPtMoves = TRUE
                            BOOL GhostPtSpins = FALSE);

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    25/9/94
    Purpose:    constructor for handle flags class
    SeeAlso:    -

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

HandleFlags::HandleFlags(   BOOL rTrackEnd,
                            BOOL rGhostEnd,
                            BOOL TrackPtMoves,
                            BOOL GhostPtMoves,
                            BOOL TrackPtSpins,
                            BOOL GhostPtSpins)
{
    // Set up some flags for rendering handles correctly
    RenderTrackEnd = rTrackEnd;
    RenderGhostEnd = rGhostEnd;
    TrackPointMoves = TrackPtMoves;
    GhostPointMoves = GhostPtMoves;
    TrackPointSpins = TrackPtSpins;
    GhostPointSpins = GhostPtSpins;
}


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

>  WobbleFlags::WobbleFlags(BOOL pSister  = FALSE,
                            BOOL pBrother = TRUE,
                            BOOL nBrother = FALSE,
                            BOOL nSister  = FALSE)
    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    25/9/94
    Purpose:    constructor for wobble flags class
    SeeAlso:    -

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

WobbleFlags::WobbleFlags(   BOOL pSister,
                            BOOL pBrother,
                            BOOL nBrother, 
                            BOOL nSister)
{
    // Set up some flags for wobbling a curves control points correctly
    PrevSister  = pSister;
    PrevBrother = pBrother;
    NextBrother = nBrother;
    NextSister  = nSister;
};

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

    ControlPts::ControlPts() / ~ControlPts()

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    25/9/94
    Purpose:    Control points class constructor and destructor
    SeeAlso:    -

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

ControlPts::ControlPts()
{
    pHndSpread = NULL;
}

ControlPts::~ControlPts()
{
}


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

>   OpPenHandles::OpPenHandles()

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    25/9/94
    Purpose:    OpPenEorHandles constructor
    SeeAlso:    -

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

OpPenHandles::OpPenHandles()
{
    // default constructor (do nothing)
}


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

>   DocCoord OpPenHandles::GetTrackHandle() const;

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    25/9/94
    Inputs:     -
    Outputs:    The current track handle coordinate
    Purpose:    Return the private track handle coordinate for reference by none
                inclass code.

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

DocCoord OpPenHandles::GetTrackHandle() const
{
    return TrackEnd;
}

DocCoord OpPenHandles::GetGhostHandle() const
{
    return GhostEnd;
}

DocCoord OpPenHandles::GetMidHandle() const
{
    return MidPoint;
}


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

>   DocCoord OpPenHandles::CalcGhostEnd(DocCoord start, DocCoord end) const;

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    25/9/94
    Inputs:     start   = point 1
                end     = point 2
    Returns:    ghost doc coordinate
    Purpose:    Calculate a ghost end coordinate given two input coordinates.
                ghost = point1 - (point2 - point1) 

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

DocCoord OpPenHandles::CalcGhostEnd(DocCoord start, DocCoord end) const
{
    DocCoord ghost;
    ghost.x = start.x - (end.x - start.x);
    ghost.y = start.y - (end.y - start.y);

    return ghost;
}



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

>   DocRect OpPenHandles::GetHandlesRect()

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    26/9/94
    Returns:    DocRect, 
    Purpose:    Calculate the bounding rect of the drag blobs.

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

DocRect OpPenHandles::GetHandlesRect()
{
    // just set it to be an empty rectangle
    DocRect BoundRect (0,0,0,0);
    DocView* pDocView = DocView::GetSelected();
    ERROR2IF(pDocView == NULL, BoundRect, 
             "No selected DocView in OpPenHandles::GetHandlesRect()");

    // Find the Rect around the drag blobs if there is any, otherwise return that bbox
    // of the start pos.

    OSRenderRegion::GetBlobRect(pDocView->GetViewScale(), TrackEnd, BT_SELECTEDLARGEST, &BoundRect);
    DocRect BlobRect;
    OSRenderRegion::GetBlobRect(pDocView->GetViewScale(), GhostEnd, BT_SELECTEDLARGEST, &BlobRect);
    BoundRect = BoundRect.Union(BlobRect);
    return BoundRect;
}



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

>   void OpPenHandles::RecalcHandles(DocCoord DragPos, BOOL constrain)

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    26/9/94
    Inputs:     DragPos     = New position to take as the drag position
                constrain   = TRUE the constrain the handle positions
    Purpose:    Recalc handles, given a new drag position which is generally following the
                mouse pointer, will work out the relative positions of the drag handles.
                The drag handles can be made to follow the drag position absolutely, or
                reletively dependent on their start positions.

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

void OpPenHandles::RecalcHandles(DocCoord DragPos, BOOL constrain)
{

    // Recalculate the position of the handle which is following the
    // mouse.

    DocCoord Constrain = DragPos;
    if (constrain)
        DocView::ConstrainToAngle(MidPoint, &Constrain);

    if (Hflags.TrackPointMoves)
            TrackEnd=Constrain;
    else if (Hflags.TrackPointSpins)
    {
        double Glen = TrackEnd.Distance(MidPoint);
        double Dlen = Constrain.Distance(MidPoint);
        DocCoord direction;
        direction.x = Constrain.x - MidPoint.x;
        direction.y = Constrain.y - MidPoint.y;
        if (Dlen!=0)
        {
            double ndx = direction.x / Dlen;
            double ndy = direction.y / Dlen;
            TrackEnd.x = MidPoint.x + (INT32)(Glen*ndx);
            TrackEnd.y = MidPoint.y + (INT32)(Glen*ndy);
        }
    }

    // Recalc the position of the handle opposite, the track handle accross
    // the midpoint.

    if (Hflags.GhostPointMoves)
    {
        GhostEnd.x = MidPoint.x - (Constrain.x - MidPoint.x);
        GhostEnd.y = MidPoint.y - (Constrain.y - MidPoint.y);
    }
    else if (Hflags.GhostPointSpins)
    {
        // if we're spinning, the ghost point will remain a set distance
        // from the midpoint, but just spin around coincident with
        // the drag pos.
        double Glen = GhostEnd.Distance(MidPoint);
        double Dlen = Constrain.Distance(MidPoint);
        DocCoord direction;
        direction.x = Constrain.x - MidPoint.x;
        direction.y = Constrain.y - MidPoint.y;
        if (Dlen!=0)
        {
            double ndx = direction.x / Dlen;
            double ndy = direction.y / Dlen;
            GhostEnd.x = MidPoint.x - (INT32)(Glen*ndx);
            GhostEnd.y = MidPoint.y - (INT32)(Glen*ndy);
        }
    }

}



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

>   void OpPenHandles::RenderHandles()

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    26/9/94
    Purpose:    Render some drag control handles as the mouse moves around. These will
                spin around an anchor point.

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

void OpPenHandles::RenderHandles()
{
    DocRect Rect = GetHandlesRect();
    RenderRegion* pRegion = DocView::RenderOnTop( &Rect, StartSpread, ClippedEOR );
    while ( pRegion )
    {
        UpdateHandles(pRegion);
        pRegion = DocView::GetNextOnTop(NULL);
    }   
}


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

>   void OpPenHandles::UpdateHandles( RenderRegion* pRegion )

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    30/9/94
    Inputs:     pRegion =   Pointer to a region to draw into
    Purpose:    Render some drag control handles as the mouse moves around. These will
                spin around an anchor point. Their appearence and positioning is set
                by the flags variable hflags.
    SeeAlso:    Hflags


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

void OpPenHandles::UpdateHandles( RenderRegion* pRegion )
{
    pRegion->SetLineColour(COLOUR_BEZIERBLOB);
    pRegion->SetFillColour(COLOUR_TRANS);
    pRegion->DrawBlob(MidPoint, BT_SELECTED);

    if (TrackEnd != MidPoint)
    {
        pRegion->SetLineColour(COLOUR_BEZIERLINE);
        pRegion->SetFillColour(COLOUR_TRANS);

        if (Hflags.RenderTrackEnd && Hflags.RenderGhostEnd)
            pRegion->DrawLine(TrackEnd, GhostEnd);
        else
        {
            if (Hflags.RenderTrackEnd)
                pRegion->DrawLine(TrackEnd,MidPoint);
            if (Hflags.RenderGhostEnd)
                pRegion->DrawLine(GhostEnd,MidPoint);
        }

        pRegion -> SetLineColour(COLOUR_TRANS);
        pRegion -> SetFillColour(COLOUR_UNSELECTEDBLOB);

        if (Hflags.RenderTrackEnd)
            pRegion -> DrawBlob(TrackEnd, BT_UNSELECTED);
        if (Hflags.RenderGhostEnd)
            pRegion -> DrawBlob(GhostEnd, BT_UNSELECTED);

    }
}


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

>   void OpPenHandles::SetHandleEnds(DocCoord ClickPos, DocCoord DragPos)

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    26/9/94
    Purpose:    

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

void OpPenHandles::SetHandleEnds(DocCoord ClickPos, DocCoord DragPos, DocCoord GhostPos)
{
    MidPoint = ClickPos;
    TrackEnd = DragPos;
    GhostEnd = GhostPos;
}



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

>   OpPenHandles::SetDragHandles(   HandleFlags HandFlags,
                                    DocCoord Click,
                                    DocCoord Drag,
                                    DocCoord Ghost,
                                    Spread* pSpread)

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    25/9/94
    Purpose:    Set up the initial positions of the drag handles. Note, the handles
                contain their own coordinates of where they think they are. These are
                separate from the drag mouse position. This allows the handles to represent
                a relation to the drag point and not an absolute position.
    SeeAlso:    -

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

void OpPenHandles::SetDragHandles(  HandleFlags HandFlags,
                                    DocCoord Click,
                                    DocCoord Drag,
                                    DocCoord Ghost,
                                    Spread* pSpread)
{
    StartMousePos = Click;
    CurrentMousePos = Click;
    StartSpread = pSpread;
    Hflags = HandFlags;
    SetHandleEnds(Click, Drag, Ghost);
}


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

>   void OpPenHandles::ChangeTrackHandle(DocCoord newpos, BOOL constrain)

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    26/9/94
    Purpose:    

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

void OpPenHandles::ChangeTrackHandle(DocCoord newpos, BOOL constrain)
{
    CurrentMousePos = newpos;
    RecalcHandles(newpos, constrain);
}



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

>   void OpPenHandles::HasMouseMoved(DocCoord& OriginalPoint, DocCoord& PointerPos, double threshold=2)

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    26/9/94
    Inputs      OriginalPoint = usually the last mouse position recorded
                PointerPos    = usually the current mouse position to check
                threshold     = a value to multiply the scaled pixel size for the view by.
    Purpose:    Checks to see whether two coordinates are the same. The current test also
                checks for movement of less than two pixels in the scaled view. If the mouse
                has moved less than threshold*ScaledPixelSize then the points are considered
                equivalent.

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

BOOL OpPenHandles::HasMouseMoved(DocCoord& OriginalPoint, DocCoord& PointerPos, double threshold)
{
    if (OriginalPoint==PointerPos)
        return FALSE;

    INT32 dist = (INT32)(OriginalPoint.Distance(PointerPos)+0.5);
    
    FIXED16 ScaledPixelWidth,
            ScaledPixelHeight;
    GetWorkingView()->GetScaledPixelSize(&ScaledPixelWidth, &ScaledPixelHeight);

    INT32 PixWidth  = ScaledPixelWidth.MakeLong();
    INT32 PixHeight = ScaledPixelHeight.MakeLong();

    PixWidth    = (INT32)(PixWidth*threshold+0.5);
    PixHeight   = (INT32)(PixHeight*threshold+0.5);

    INT32 range;
    (PixWidth<PixHeight) ? (range=PixHeight) : (range=PixWidth);

    return (dist>range);
}   



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

>   void OpPenHandles::RenderTestRect( DocRect Rect, Spread* pSpread, StockColour colour )

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/9/94
    Purpose:    Render a black rectangle. Useful for checking render regions and clipping

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

void OpPenHandles::RenderTestRect( DocRect Rect, Spread* pSpread, StockColour colour )
{
    if (Error::IsUserName("Mike"))
    {
        TRACE( _T("RectLox=%d\n"),Rect.lo.x);
        TRACE( _T("RectLoy=%d\n"),Rect.lo.y);
        TRACE( _T("RectHix=%d\n"),Rect.hi.x);
        TRACE( _T("RectHiy=%d\n\n"),Rect.hi.y);
    }

    RenderRegion* pRegion = DocView::RenderOnTop( &Rect, pSpread, ClippedEOR );
    while ( pRegion )
    {
        pRegion -> SetFillColour(colour);
        pRegion -> DrawRect(&Rect);
        pRegion = DocView::GetNextOnTop(NULL);
    }
}

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

>   OpPenDragBlobs::OpPenDragBolbs()

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    25/9/94
    Purpose:    OpPenDragBlobs constructor
    SeeAlso:    -

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

OpPenDragBlobs::OpPenDragBlobs()
{
}


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

>   BOOL OpPenDragBlobs::DoPenDragBlobs()

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    26/9/94
    Inputs:     tptr    =   pointer to calling tool.
    Outputs:    -
    Returns:    TRUE if able to start the drag, FALSE if not
    Purpose:    
    Errors:     failandexecute will be called if the operation fails in some way, most
                likely when no memory is available. 

********************************************************************************************/
    
BOOL OpPenDragBlobs::DoPenDragBlobs()
{   
    // And tell the Dragging system that we need drags to happen
    DocRect HandlesRect = GetHandlesRect();
    return StartDrag(DRAGTYPE_AUTOSCROLL, &HandlesRect, &CurrentMousePos);
}



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

>   void OpPenDragBlobs::DragPointerMove(   DocCoord PointerPos,
                                            ClickModifiers ClickMods,
                                            Spread* pSpread,
                                            BOOL bSolidDrag)

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    26/9/94
    Inputs:     PointerPos - The current position of the mouse in Doc Coords
                ClickMods - Which key modifiers are being pressed
    Purpose:    This is called every time the mouse moves, during a drag.
    SeeAlso:    ClickModifiers

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

void OpPenDragBlobs::DragPointerMove(DocCoord PointerPos, 
                                     ClickModifiers ClickMods,
                                     Spread* pSpread,
                                     BOOL bSolidDrag)
{
    // If drag has moved onto a different spread, convert the coord to be relative to the
    // original spread.
    if (pSpread != StartSpread)
        PointerPos = MakeRelativeToSpread(StartSpread, pSpread, PointerPos);

    // Make sure we get the grid snapping involved
    DocCoord SnapPos = PointerPos;
    DocView::SnapCurrent(pSpread,&SnapPos);

    // Rub out the old EORed version of the handles, and stick some new ones on.
    RenderHandles();
    ChangeTrackHandle(SnapPos, ClickMods.Constrain);
    RenderHandles();
}



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

>   void OpPenDragBlobs::DragFinished( DocCoord PointerPos, ClickModifiers ClickMods,
                                            Spread* pSpread, BOOL Success, BOOL bSolidDrag)

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    26/9/94
    Inputs:     PointerPos - The position of the mouse at the end of the drag
                ClickMods - the key modifiers being pressed
                Success - TRUE if the drag was terminated properly, FALSE if it
                was ended with the escape key being pressed
    Purpose:    This is called when a drag operation finishes.
    SeeAlso:    ClickModifiers

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

void OpPenDragBlobs::DragFinished( DocCoord PointerPos, ClickModifiers ClickMods, 
                                        Spread* pSpread, BOOL Success, BOOL bSolidDrag)
{
    // terminate the drag and operation
    EndDrag();      
}



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

>   virtual void OpPenDragBlobs::RenderDragBlobs( DocRect Rect, Spread* pSpread, BOOL bSolidDrag )

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/9/94
    Purpose:    This function is called to render our drag blobs during scrolling.

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

void OpPenDragBlobs::RenderDragBlobs( DocRect Rect, Spread* pSpread, BOOL bSolidDrag )
{
    if (StartSpread!=pSpread) return;
    RenderRegion* pRegion = DocView::RenderOnTop( &Rect, pSpread, ClippedEOR );
    while ( pRegion )
    {
        UpdateHandles(pRegion);
        pRegion = DocView::GetNextOnTop(NULL);
    }
}




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

>   OpPenCreateInternal::OpPenCreateInternal()

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    25/9/94
    Purpose:    OpPenCreateInternal constructor
    SeeAlso:    -

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

OpPenCreateInternal::OpPenCreateInternal()
{
}



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

>   BOOL OpPenCreateInternal::Init()

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

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

BOOL OpPenCreateInternal::Init()
{
    return (RegisterOpDescriptor(0,                                     // tool ID
                                _R(IDS_PENCREATEINTERNALOP),                // string resource ID
                                CC_RUNTIME_CLASS(OpPenCreateInternal),  // runtime class for Op
                                OPTOKEN_PENCREATEINTERNAL,              // Ptr to token string
                                OpPenCreateInternal::GetState,          // GetState function
                                0,                                      // help ID = 0
                                _R(IDBBL_PENCREATEINTERNALOP),              // bubble help ID = 0
                                0                                       // resource ID = 0
                                )); 

}               


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

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

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    26/9/94
    Inputs:     -
    Outputs:    -
    Returns:    The state of the OpPenCreateInternal
    Purpose:    For finding the OpPenCreateInternal's state. 
    Errors:     -
    SeeAlso:    -

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

OpState OpPenCreateInternal::GetState(String_256* UIDescription, OpDescriptor*)
{
    OpState OpSt;
    return OpSt;   
}







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

>   void OpPenCreateInternal::DoPenCreateInternal(  DocCoord Anchor, 
                                                    Spread *pSpread, 
                                                    ControlPts* pHandles)

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    26/9/94
    Inputs:     Anchor  =   position of first click
                pSpread =   pointer to spread where first click occured
                pHandles=   pointer to handles block
    Outputs:    -
    Returns:    -
    Purpose:    
    Errors:     failandexecute will be called if the operation fails in some way, most
                likely when no memory is available. 

********************************************************************************************/
    
void OpPenCreateInternal::DoPenCreateInternal(DocCoord Anchor, Spread* pSpread, ControlPts* pHandles)
{   
    // initialise the drag handles into the default mode.

    pUserHandles = pHandles;
    HandleFlags Flags;

    // Make sure we get the grid snapping involved
    DocCoord SnapPos = Anchor;
    DocView::SnapCurrent(pSpread,&SnapPos);

    SetDragHandles(Flags, SnapPos, SnapPos, SnapPos, pSpread);

    // call the base classes drag init function
    if (!DoPenDragBlobs())
    {
        FailAndExecute();
        End();
        return;
    }

    // Render the current drag blobs where necessary
    RenderHandles();
}




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

>   void OpPenCreateInternal::DragFinished( DocCoord PointerPos, ClickModifiers ClickMods,
                                            Spread* pSpread, BOOL Success, BOOL bSolidDrag)

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    26/9/94
    Inputs:     PointerPos - The position of the mouse at the end of the drag
                ClickMods - the key modifiers being pressed
                Success - TRUE if the drag was terminated properly, FALSE if it
                was ended with the escape key being pressed
    Purpose:    This is called when a drag operation finishes.
    SeeAlso:    ClickModifiers

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

void OpPenCreateInternal::DragFinished( DocCoord PointerPos, ClickModifiers ClickMods, 
                                        Spread* pSpread, BOOL Success, BOOL bSolidDrag)
{
    // Rub out the old EORed version of the handles
    RenderHandles();

    // inform the base class to stop dragging
    OpPenDragBlobs::DragFinished( PointerPos, ClickMods, pSpread, Success, bSolidDrag);

    // inform the pen tool that a drag has come to an end
    if (Success)
    {
        pUserHandles->HndClick = GetMidHandle();
        pUserHandles->HndDrag = GetTrackHandle();
        pUserHandles->pHndSpread = StartSpread;
    }
    else
        FailAndExecute();
    // End the operation
    End();
}




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

>   OpPenEditInternal::OpPenEditInternal()

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    25/9/94
    Purpose:    OpPenEditInternal constructor
    SeeAlso:    -

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

OpPenEditInternal::OpPenEditInternal()
{
}


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

>   BOOL OpPenEditInternal::Init()

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

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

BOOL OpPenEditInternal::Init()
{
    return (RegisterOpDescriptor(0,                                     // tool ID
                                _R(IDS_PENEDITINTERNALOP),                  // string resource ID
                                CC_RUNTIME_CLASS(OpPenEditInternal),    // runtime class for Op
                                OPTOKEN_PENEDITINTERNAL,                // Ptr to token string
                                OpPenEditInternal::GetState,            // GetState function
                                0,                                      // help ID = 0
                                _R(IDBBL_PENEDITINTERNALOP),                // bubble help ID = 0
                                0                                       // resource ID = 0
                                )); 

}               


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

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

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    26/9/94
    Inputs:     -
    Outputs:    -
    Returns:    The state of the OpPenEditInternal
    Purpose:    For finding the OpPenEditInternal's state. 
    Errors:     -
    SeeAlso:    -

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

OpState OpPenEditInternal::GetState(String_256* UIDescription, OpDescriptor*)
{
    OpState OpSt;
    return OpSt;   
}



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

>   void OpPenEditInternal::DoPenEditInternal(ControlPts* pHandles)

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    26/9/94
    Inputs:     pHandles    = Pointer to a handles block containing click pos, drag pos
                              and spread ptr
    Outputs:    -
    Returns:    -
    Purpose:    
    Errors:     failandexecute will be called if the operation fails in some way, most
                likely when no memory is available. 

********************************************************************************************/
    
void OpPenEditInternal::DoPenEditInternal(ControlPts* pHandles)
{   

    // Set the internal state
    pUserHandles = pHandles;

    HandleFlags Flags;
    DocCoord ghst = CalcGhostEnd(pHandles->HndClick, pHandles->HndDrag);
    SetDragHandles(Flags, pHandles->HndClick, pHandles->HndDrag, ghst, pHandles->pHndSpread);

    // call the base classes drag init function
    if (!DoPenDragBlobs())
    {
        FailAndExecute();
        End();
        return;
    }
}


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

>   void OpPenEditInternal::DragFinished( DocCoord PointerPos, ClickModifiers ClickMods,
                                            Spread* pSpread, BOOL Success, BOOL bSolidDrag)

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    26/9/94
    Inputs:     PointerPos - The position of the mouse at the end of the drag
                ClickMods - the key modifiers being pressed
                Success - TRUE if the drag was terminated properly, FALSE if it
                was ended with the escape key being pressed
    Purpose:    This is called when a drag operation finishes.
    SeeAlso:    ClickModifiers

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

void OpPenEditInternal::DragFinished( DocCoord PointerPos, ClickModifiers ClickMods, 
                                        Spread* pSpread, BOOL Success, BOOL bSolidDrag)
{
    // Rub out the old EORed version of the handles
    RenderHandles();

    // inform the base class to stop dragging
    OpPenDragBlobs::DragFinished( PointerPos, ClickMods, pSpread, Success, bSolidDrag);

    // inform the pen tool that a drag has come to an end
    if (Success)
    {
        pUserHandles->HndClick  = GetMidHandle();
        pUserHandles->HndDrag   = GetTrackHandle();
        pUserHandles->pHndSpread = StartSpread;
    }
    else
        FailAndExecute();

    // terminate the op
    End();      
}




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

>   OpPenEditPath::OpPenEditPath()

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/9/94
    Purpose:    OpPenEditPath constructor
    SeeAlso:    -

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

OpPenEditPath::OpPenEditPath()
{
}

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

>   OpPenEditPath::SetWobbleIndex(WobbleFlags wibble, const INT32 index)

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/9/94
    Inputs:     wibble  = wobble flags indicating which control handles will follow those
                          of the drag handles.
                index   = the index into our edit curve of the endpoint handle whose brother
                          and sister handles are being dragged around.
    Outputs:    -
    Purpose:    Set the control handle index of our edit curve which will follow the
                dragging control handles.
    SeeAlso:    -

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

void OpPenEditPath::SetWobbleIndex(WobbleFlags wibble, const INT32 index)
{
    Wobble = wibble;
    WobbleIndex = index;
}


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

>   BOOL OpPenEditPath::DoPenDragPath(Path* pEditPath)

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/9/94
    Inputs:     pEditPath = pointer a path to begin editing.
    Returns:    TRUE if able to start the drag, FALSE otherwise
    Returns:    -
    Purpose:    

********************************************************************************************/
    
BOOL OpPenEditPath::DoPenDragPath()
{   
    // Tell the Dragging system that we need drags to happen
    DocRect HandlesRect = GetBoundingRect();
    return StartDrag(DRAGTYPE_AUTOSCROLL, &HandlesRect, &CurrentMousePos);
}



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

>   void OpPenEditPath::WobbleCoords

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    11/10/94
    Inputs:     
    Purpose:    Moves the control handles around dependent on the classes wobble flags

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

void OpPenEditPath::WobbleCoords()
{
    DocCoord* Coords = pEditPath->GetCoordArray();

    if (Wobble.PrevBrother)
        Coords[WobbleIndex-1] = GetGhostHandle();

    if (Wobble.PrevSister)
    {
        Coords[WobbleIndex-2].x = (2*Coords[WobbleIndex-3].x + Coords[WobbleIndex-1].x)/3;
        Coords[WobbleIndex-2].y = (2*Coords[WobbleIndex-3].y + Coords[WobbleIndex-1].y)/3;
    }

    if (Wobble.NextBrother)
        Coords[WobbleIndex+1] = GetTrackHandle();

    if (Wobble.NextSister)
    {
        Coords[WobbleIndex+2].x = (Coords[WobbleIndex+1].x + 2*Coords[WobbleIndex+3].x)/3;
        Coords[WobbleIndex+2].y = (Coords[WobbleIndex+1].y + 2*Coords[WobbleIndex+3].y)/3;
    }
}


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

>   void OpPenEditPath::DragPointerMove(DocCoord PointerPos, 
                                        ClickModifiers ClickMods,
                                        Spread* pSpread, BOOL bSolidDrag)

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    26/9/94
    Inputs:     PointerPos - The current position of the mouse in Doc Coords
                ClickMods - Which key modifiers are being pressed
    Purpose:    This is called every time the mouse moves, during a drag.
    SeeAlso:    ClickModifiers

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

void OpPenEditPath::DragPointerMove(DocCoord PointerPos,
                                    ClickModifiers ClickMods,
                                    Spread* pSpread, BOOL bSolidDrag)
{
    // If drag has moved onto a different spread, convert the coord to be relative to the
    // original spread.
    if (pSpread != StartSpread)
        PointerPos = MakeRelativeToSpread(StartSpread, pSpread, PointerPos);

    // Make sure we get the grid snapping involved
    DocCoord SnapPos = PointerPos;
    DocView::SnapCurrent(pSpread,&SnapPos);

    if (CurrentMousePos != SnapPos)
    {

        // Rub out the old EORed version of the path and stick a new one on
        DocRect Rect = OpPenEditPath::GetBoundingRect();
        RenderDragBlobs(Rect, StartSpread, bSolidDrag);

        Rect.IncludePoint(SnapPos);

        // Alter the curve drag handles
        ChangeTrackHandle(SnapPos, ClickMods.Constrain);
        
        // make sure we wobble all the coordinates around this control point
        // correctly.
        WobbleCoords();

        // Now render the blobs back on again
        Rect = Rect.Union(OpPenEditPath::GetBoundingRect());
        RenderDragBlobs(Rect, StartSpread, bSolidDrag);
    }

}



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

>   DocRect OpPenEditPath::GetBoundingRect()

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    30/9/94
    Inputs:     -
    Purpose:    Find the bounding box of the edit path and the drag handles.

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

DocRect OpPenEditPath::GetBoundingRect()
{

    DocRect Rect;   
    DocView* pDocView = DocView::GetSelected();
    ENSURE( pDocView != NULL, "There was no selected docview when getting the bounding box" );

    if ( pDocView != NULL )
    {
        DocRect BlobRect;
        DocCoord Coord;
        Rect = pEditPath->GetBoundingRect();
        Rect = Rect.Union(OpPenHandles::GetHandlesRect());
        // inflate by 1/4 of an inch to avoid eor problems
        Rect.Inflate(72000>>2);
    }

    return Rect;
}


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

>   DocRect OpPenEditPath::ConvertToLine(const INT32 index)

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    30/9/94
    Inputs:     index   = index of element to remove from.
    Purpose:    Convert the currently edited curve element into a line

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

void OpPenEditPath::ConvertToLine(const INT32 index)
{
    // remove the curve element, then stick a none smooth line
    // segment in there.

    pEditPath->DeleteFromElement(index);
    PathFlags tempflags;
    tempflags.IsSelected = TRUE;
    pEditPath->InsertLineTo(GetMidHandle(), &tempflags);
}



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

>   void OpPenEditPath::RemoveRotateEnd(const INT32 index)

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    30/9/94
    Inputs:     index   = index of bezierto element
    Purpose:    Remove any rotate bits from a bezier element, starting at index
    
********************************************************************************************/

void OpPenEditPath::RemoveRotateEnd(const INT32 index)
{
    // Remove all rotate values from the end curve element
    PathFlags* Flags = pEditPath->GetFlagArray();