cutop.cpp

Go to the documentation of this file.

// $Id: cutop.cpp 1467 2006-07-18 17:00:07Z gerry $
/* @@tag:xara-cn@@ DO NOT MODIFY THIS LINE
================================XARAHEADERSTART===========================
 
               Xara LX, a vector drawing and manipulation program.
                    Copyright (C) 1993-2006 Xara Group Ltd.
       Copyright on certain contributions may be held in joint with their
              respective authors. See AUTHORS file for details.

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

This file is part of Xara LX.

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


MARKS
-----

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


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

=================================XARAHEADEREND============================
 */
// Implementation of cut/copy and paste operations 

/*
//*/

#include "camtypes.h" 
#include "cutop.h"

//#include "app.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "clipint.h"
//#include "docrect.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "document.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "docview.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "ink.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "layer.h" 
//#include "spread.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "trans2d.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "wrkrect.h"
#include "objchge.h"

//#include "clikdrag.h"

//#include "jason.h"
//#include "peter.h"
//#include "simon.h"
//#include "tool.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "attrmgr.h" - in camtypes.h [AUTOMATICALLY REMOVED]

#include "textops.h"
#include "nodetxts.h"       // For temporary disabling of text subselection copying/cutting
//#include "barsdlgs.h"     // button controls

//#include "fillattr.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "ndoptmz.h"
#include "progress.h"
#include "transop.h"
//#include "bubbleid.h"

#include "camdoc.h"         // for CCamDoc::GetKernelPathName & CCamDoc::SetPathName

#include "fillramp.h"
#include "opgrad.h"
#include "blobs.h"

//#include "cxfdefs.h"      // for TemplateAttribute - in camtypes.h [AUTOMATICALLY REMOVED]
#include "cxftags.h"
//#include "cxfrec.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "cxfrech.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "attrval.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "userattr.h"
#include "tmpltatr.h"

#include "ngsentry.h"       // for NodeSetProperty etc
#include "slicehelper.h"    // for the MeshLayers fn

//#include "will2.h"            // for _R(IDS_FILLTOOL_FILLINFOBARNAME)
#include "filltool.h"       // for GradInfoBarOp
#include "ngitem.h"         // for SGNameItem
//#include "units.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "effects_stack.h"
#include "ophist.h"

DECLARE_SOURCE("$Revision: 1467 $");

CC_IMPLEMENT_DYNCREATE(OpCut, SelOperation)
CC_IMPLEMENT_DYNCREATE(OpCopy, UndoableOperation)  
CC_IMPLEMENT_DYNCREATE(OpPaste, SelOperation)  
CC_IMPLEMENT_DYNCREATE(OpDelete, SelOperation)
CC_IMPLEMENT_DYNCREATE(CarbonCopyOp, SelOperation)
CC_IMPLEMENT_DYNCREATE(OpDuplicate, CarbonCopyOp)
CC_IMPLEMENT_DYNCREATE(OpClone, CarbonCopyOp)
CC_IMPLEMENT_DYNCREATE(OpCopyAndTransform, CarbonCopyOp)
CC_IMPLEMENT_DYNCREATE(OpPasteAttributes, SelOperation)
CC_IMPLEMENT_DYNAMIC(OpParamPasteAtPosition,OpParam)


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

>   static void SetCutOpText(String_256 *UIDescription, UINT32 PrefixStringID)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/5/95
    Inputs:     UIDescription - points to the UOIDescription for a GetState method
                PrefixStringID - the ID of a prefix to use (e.g. "Cut ")

    Outputs:    UIDescription will either be left unchanged (no special description
                available) or will be filled in (e.g. "Cut lines")

    Purpose:    Shared code used by almost all the GetState methods in kernel cutop.cpp
                Given a prefix string ("Copy "), it scans the selection for a description
                and generates an op description string ("Cut shape")

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

static void SetCutOpText(String_256 *UIDescription, UINT32 PrefixStringID)
{
    String_256 Description = GetApplication()->FindSelection()->Describe(MENU);

    if (!Description.IsEmpty())
    {
        *UIDescription = String_256(PrefixStringID);
        *UIDescription += Description;
    }
    // else Leave the UIDescription as it stands (probably a simple "Cut" etc)
}



// ------------------------------------------------------------------------------------------
// OpCut methods
            
/********************************************************************************************

>   OpCut::OpCut() 

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/9/93
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    OpCut constructor
    Errors:     -
    SeeAlso:    -

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

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

>   BOOL OpCut::Init()

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

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

BOOL OpCut::Init()
{
    return (RegisterOpDescriptor(0,
                            _R(IDS_CUTOP),
                            CC_RUNTIME_CLASS(OpCut),
                            OPTOKEN_CUT,
                            OpCut::GetState,
                            0,                          // help ID 
                            _R(IDBBL_CUT),
                            0,
                            0,
                            SYSTEMBAR_ILLEGAL,          // For now !
                            TRUE,                       // Receive messages
                            FALSE,
                            FALSE,
                            0,
                            0 //(GREY_WHEN_NO_CURRENT_DOC | GREY_WHEN_NO_SELECTION)
    ));
}               
    
/********************************************************************************************

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

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

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

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

    // BODGE Temporarily disable copying TextStory sub-selections
/*
    Range Sel(*(GetApplication()->FindSelection()));
    Node* Current = Sel.FindFirst();
    while(Current != NULL)
    {
        if (Current->IS_KIND_OF(BaseTextClass))
        {
            if (!(IS_A(Current, TextStory)))
            {
                OpSt.Greyed = TRUE;
                return(OpSt);
            }
        }
        Current = Sel.FindNext(Current, TRUE); 
    }
*/

    SelRange* pSelRange = GetApplication()->FindSelection();    // get the selected range

    // Set up the ObjChangeParam so we can ask the selected nodes if they minds being cut
    ObjChangeFlags cFlags(TRUE);
    ObjChangeParam ObjChange(OBJCHANGE_STARTING,cFlags,NULL,NULL);

    // Will one or more selected nodes allow this op?
    if (!pSelRange->AllowOp(&ObjChange,FALSE))
    {
        // None of the nodes can be deleted
        OpSt.Greyed = TRUE;

        // Load reason why operation is disabled
        UINT32 IDS = ObjChange.GetReasonForDenial();
        if (IDS == 0) IDS = _R(IDS_NO_OBJECTS_SELECTED);    // if 0 (i.e. not been set), then assume there's no selection
        *UIDescription = String_256(IDS);               // Resolve the string ID
    }
    else
        SetCutOpText(UIDescription, _R(IDS_CLIPBOARD_PRECUT));

    return(OpSt);
}

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

>   void OpCut::Do(OpDescriptor*)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    16/8/93
    Inputs:     OpDescriptor (unused)
    Outputs:    -
    Returns:    -
    Purpose:    Performs the Cut operation. 
                
    Errors:     -
    SeeAlso:    -

********************************************************************************************/
    
void OpCut::Do(OpDescriptor*)
{  
    ObjectSet CompoundSet;

    BeginSlowJob(-1, FALSE);        // Make sure we have a simple hourglass, without a delay

    // Check with the clipboard if it is OK to go ahead
    InternalClipboard *Clipboard = InternalClipboard::Instance();
    if (Clipboard == NULL || !Clipboard->PrepareForCopy())
    {
        FailAndExecute();

        EndSlowJob();
        End();
        return;
    }

    // Obtain the current selection
    Range Sel(*(GetApplication()->FindSelection()));
    
    // DMc change to range control
    RangeControl rg = Sel.GetRangeControlFlags();
    rg.PromoteToParent = TRUE;
    Sel.Range::SetRangeControl(rg);


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

    if (!DoStartSelOp(TRUE,FALSE))  // Try to record the selection state
        goto EndOperation;  
    
    // Mark nodes that will allow this to happen, and error if no nodes will let it happen
    if (!Sel.AllowOp(&ObjChange))
    {
        ERROR3("AllowOp() returned FALSE, i.e. op should have been greyed out");
        goto EndOperation;
    }

    
    // We need to invalidate the region
    if (!DoInvalidateNodesRegions(Sel, TRUE))
        goto EndOperation; 

    // Prior to hiding anything lets get ourselves a set of compound nodes which 
    // we will need to factor out attributes on. We cannot use the SelRange because
    // this will be empty after the deletion has taken place. 

    if (!(Sel.GetCompoundObjectSet(&CompoundSet, 
                                    TRUE )))
    {
        goto EndOperation; 
    }
    
    // Removed 24/07/95 (We now leave it up to the text story deletion code to handle its own attributes)

    // Because of complex deletion we must also add the TextStory objects 
    // of selected chars. This code will hopefuly be removed in future. It is
    // inefficient cos we will need to factor out more than once for each line !.
    
    //if (!(Sel.AddTextStoryCompoundsForDel(&CompoundSet)))
    //{
    //  goto EndOperation;
    //} 

    // We now must localise the attributes on every item marked for deletion
    if (!DoLocaliseForAttrChange(&Sel, (AttrTypeSet*)NULL, TRUE ))
    {
        goto EndOperation;
    }


    // Copy the selection to the internal clipboard
    if (!DoCopyNodesToClipboard(Sel))
        goto EndOperation; 

    // Go through one pass, asking nodes to hide themselves
    if (!DoHideComplexRange(Sel))
        goto EndOperation;
    {
        SelRange* pRange = GetApplication()->FindSelection();
        if (pRange)
        {
            // freshen the selection range by counting the currently selected objects
            pRange->Update(FALSE,NULL);
//          INT32 num = pRange->Count();
            pRange->Count();    // side-effect?
        
            // Obtain the current selection (should be up-to-date now!)
            Range NewSel(*pRange);

            // Now go through a second pass snip the remainder out of the tree
            if (!DoHideNodes(NewSel,TRUE))   // Hide the nodes (IncludeSubtreeSize)
                goto EndOperation;
        }
    }

    // Finally try to factor out the attributes on all compounds. Note that if a particular compound
    // is hidden then it will  be it's parent that has its attributes factored out !
    if (!DoFactorOutAfterAttrChange(&CompoundSet,(AttrTypeSet*)NULL))
    {
        goto EndOperation; 
    }
    
    // We need to inform the DocComponents of the clipboard that the copy is complete

EndOperation:

    CompoundSet.DeleteAll();    // Delete all items in the CompoundSet
        
    // Update all the changed nodes, i.e. tell all the parents of the children that have been effected
    ObjChange.Define(OBJCHANGE_FINISHED,cFlags,NULL,this);
    if (!UpdateChangedNodes(&ObjChange))
        FailAndExecute();

    // Invalidate sel range as it may have been cached in the middle of the op while the tree is
    // in an invalid state (i.e. some selected nodes may have had the PERMISSION_DENIED state set during caching).
    {
        SelRange* pRange = GetApplication()->FindSelection();
        if (pRange)
            pRange->Update(FALSE,NULL);
    }

    // Copy the doc's file-path etc, so that the clipboard doc knows if it is possible to
    // OLE link to the doc.
    Document* pSourceDoc = Document::GetSelected();
    if (pSourceDoc && !pSourceDoc->GetOilDoc()->GetKernelPathName().IsEmpty())
    {
        // Don't add to the MRU list!
        String_256 str = pSourceDoc->GetOilDoc()->GetKernelPathName();
        InternalClipboard::Instance()->GetOilDoc()->SetPathName(str, FALSE);
        TRACEUSER( "JustinF", _T("Copied file-path %s to clipboard document\n"),
                    (LPCTSTR) InternalClipboard::Instance()->GetOilDoc()->GetKernelPathName());
    }
    else
    {
        // Set the path-name to be empty (what a delicious potential bug!)
        InternalClipboard::Instance()->GetOilDoc()->SetPathNameEmpty();
        TRACEUSER( "JustinF", _T("Setting clipboard file-path to nothing\n"));
    }

    // And finally, tell the clipboard we've finished copying to it
    // (This is the point where it is made available to other applications, etc)
    if (!Clipboard->CopyCompleted())
        FailAndExecute();

    EndSlowJob();
    End();
}           


// ------------------------------------------------------------------------------------------
// OpCopy methods
            
/********************************************************************************************

>   OpCopy::OpCopy() 

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/9/93
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    OpCopy constructor
    Errors:     -
    SeeAlso:    -

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

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

>   BOOL OpCopy::Init()

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

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

BOOL OpCopy::Init()
{
    return (RegisterOpDescriptor(0,
                            _R(IDS_COPYOP),
                            CC_RUNTIME_CLASS(OpCopy),
                            OPTOKEN_COPY,
                            OpCopy::GetState,
                            0,                          // help ID
                            _R(IDBBL_COPY),
                            0,                          // bitmap ID
                            0,
                            SYSTEMBAR_ILLEGAL,          // For now !
                            TRUE,                       // Receive messages
                            FALSE,
                            FALSE,
                            0,
                            (DONT_GREY_WHEN_SELECT_INSIDE | GREY_WHEN_NO_CURRENT_DOC | GREY_WHEN_NO_SELECTION)
                            ));
}               
    
/********************************************************************************************

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

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

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

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

    // BODGE Temporarily disable copying TextStory sub-selections
    Range Sel(*(GetApplication()->FindSelection()));
    /*Node* Current =*/ Sel.FindFirst();

    // Set up the ObjChangeParam so we can ask the selected nodes if they minds being copied
    ObjChangeFlags cFlags;
    cFlags.CopyNode=TRUE;
    ObjChangeParam ObjChange(OBJCHANGE_STARTING,cFlags,NULL,NULL);

    // Will one or more selected nodes allow this op?
    if (!Sel.AllowOp(&ObjChange,FALSE))
    {
        // None of the nodes can be deleted
        OpSt.Greyed = TRUE;

        // Load reason why operation is disabled
        UINT32 IDS = ObjChange.GetReasonForDenial();
        if (IDS == 0) IDS = _R(IDS_NO_OBJECTS_SELECTED);    // if 0 (i.e. not been set), then assume there's no selection
        *UIDescription = String_256(IDS);               // Resolve the string ID
    }
    else
        SetCutOpText(UIDescription, _R(IDS_CLIPBOARD_PRECOPY));

    return(OpSt);   
}

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

>   void OpCopy::Do(OpDescriptor*)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    16/8/93
    Inputs:     OpDescriptor (unused)
    Outputs:    -
    Returns:    -
    Purpose:    Performs the Copy operation. 
                
    Errors:     -
    SeeAlso:    -

********************************************************************************************/
    
void OpCopy::Do(OpDescriptor*)
{   
    BeginSlowJob(-1, FALSE);        // Make sure we have a simple hourglass, without a delay

    // Check with the clipboard if it is OK to go ahead
    InternalClipboard *Clipboard = InternalClipboard::Instance();
    if (Clipboard == NULL || !Clipboard->PrepareForCopy())
    {
        FailAndExecute();

        EndSlowJob();
        End();
        return;
    }

    // Obtain the current selections 
    Range Sel(*(GetApplication()->FindSelection()));

    // DMc change to range control
    
    RangeControl rg = Sel.GetRangeControlFlags();
    rg.PromoteToParent = TRUE;
    Sel.Range::SetRangeControl(rg);
    
    // Prepare an ObjChangeParam so we can mark which nodes will allow this op to happen to them
    ObjChangeFlags cFlags;
    cFlags.CopyNode=TRUE;
    ObjChangeParam ObjChange(OBJCHANGE_STARTING,cFlags,NULL,this);

    // Find the first node which is selected 
    Node* FirstSelectedNode = Sel.FindFirst(); 
    
    ENSURE(FirstSelectedNode != NULL, "Called copy operation with no nodes selected"); 
    
    // In the retail build it is best to do nothing if we find there are no selected nodes 
    if (FirstSelectedNode != NULL) // No nodes selected so End
    {   
        if (!DoStartSelOp(TRUE,TRUE))  // Try to record the selection state
        {
            goto EndOperation;  
        }

        // Mark nodes that will allow this to happen, and error if no nodes will let it happen
        if (!Sel.AllowOp(&ObjChange))
        {
            ERROR3("AllowOp() returned FALSE, i.e. op should have been greyed out");
            goto EndOperation;
        }
        
        // Copy the selection to the internal clipboard
        if (!DoCopyNodesToClipboard(Sel))
        {
            goto EndOperation; 
        }
    }


EndOperation:
    // Update all the changed nodes, i.e. tell all the parents of the children that have been effected
    ObjChange.Define(OBJCHANGE_FINISHED,cFlags,NULL,this);
    if (!UpdateChangedNodes(&ObjChange))
        FailAndExecute();

    // Copy the doc's file-path etc, so that the clipboard doc knows if it is possible to
    // OLE link to the doc.
    Document* pSourceDoc = Document::GetSelected();
    if (pSourceDoc && !pSourceDoc->GetOilDoc()->GetKernelPathName().IsEmpty())
    {
        // Don't add to the MRU list!
        String_256 str = pSourceDoc->GetOilDoc()->GetKernelPathName();
        InternalClipboard::Instance()->GetOilDoc()->SetPathName(str, FALSE);
        TRACEUSER( "JustinF", _T("Copied file-path %s to clipboard document\n"),
                    (LPCTSTR) InternalClipboard::Instance()->GetOilDoc()->GetKernelPathName());
    }
    else
    {
        // Set the path-name to be empty (what a delicious potential bug!)
        InternalClipboard::Instance()->GetOilDoc()->SetPathNameEmpty();
        TRACEUSER( "JustinF", _T("Setting clipboard file-path to nothing\n"));
    }

    // And finally, tell the clipboard we've finished copying to it
    // (This is the point where it is made available to other applications, etc)
    if (!Clipboard->CopyCompleted())
        FailAndExecute();

    EndSlowJob();
    End();
}           


// ------------------------------------------------------------------------------------------
// OpPaste methods
            
/********************************************************************************************

>   OpPaste::OpPaste() 

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/9/93
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    OpPaste constructor
    Errors:     -
    SeeAlso:    -

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

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

>   BOOL OpPaste::Init()

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

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

BOOL OpPaste::Init()
{
    BOOL ok =  (RegisterOpDescriptor(0,
                            _R(IDS_PASTEOP),
                            CC_RUNTIME_CLASS(OpPaste),
                            OPTOKEN_PASTE,
                            OpPaste::GetState,
                            0,                          // help ID
                            _R(IDBBL_PASTE),
                            0,                          // bitmap ID 
                            0,
                            SYSTEMBAR_ILLEGAL,          // For now !
                            TRUE,                       // Receive messages
                            FALSE,
                            FALSE,
                            0,
                            (GREY_WHEN_NO_CURRENT_DOC | DONT_GREY_WHEN_SELECT_INSIDE)
                            ));
    if (ok)
    {
        // Register a second OpDescriptor, for paste at same position. This OpDescriptor
        // will probably never appear directly on a bar/menu so it uses the same strings
        // as the above.
        ok =  (RegisterOpDescriptor(0,
                            _R(IDS_PASTEATSAMEPOSOP),
                            CC_RUNTIME_CLASS(OpPaste),
                            OPTOKEN_PASTEATSAMEPOS,
                            OpPaste::GetState,
                            0,                          // help ID
                            _R(IDBBL_PASTEATSAMEPOS),
                            _R(IDD_BARCONTROLSTORE),        // resource ID
                            _R(IDC_PASTEATSAMEPOS),         // control ID
                            SYSTEMBAR_EDIT,             // Bar ID
                            TRUE,                       // Receive messages
                            FALSE,
                            FALSE,
                            0,
                            (GREY_WHEN_NO_CURRENT_DOC | DONT_GREY_WHEN_SELECT_INSIDE)
                            ));
    }

    return ok;
}               
    
/********************************************************************************************

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

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

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

OpState OpPaste::GetState(String_256* UIDescription, OpDescriptor* pOpDesc)
{
    OpState OpSt;

    if (InternalClipboard::IsEmpty())
    {
        // There is no data to paste, so grey out, and return a reason for greying
        OpSt.Greyed = TRUE;
        *UIDescription = String_256(_R(IDS_CLIPBOARD_EMPTY));
    }
    else
    {
        // Otherwise, determine a string to display - always show "Paste", but if possible
        // add a description, e.g. "Paste quickshape", "Paste bitmap"

        String_64 Type;
        InternalClipboard::DescribeContents(&Type);
        if (!Type.IsEmpty() && pOpDesc->Token==String_256(OPTOKEN_PASTE))
        {
            *UIDescription = String_256(_R(IDS_CLIPBOARD_PREPASTE));
            *UIDescription += Type;
        }
    }
    return(OpSt);
}



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

>   void OpPaste::Do(OpDescriptor*)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    16/8/93
    Inputs:     OpDescriptor (unused)
    Outputs:    -
    Returns:    -
    Purpose:    Performs the Paste operation. 
                
    Errors:     -
    SeeAlso:    -

********************************************************************************************/
    
void OpPaste::Do(OpDescriptor* WhichOp)
{
    DoPaste(WhichOp,NULL,NULL);
}           

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

>   void OpPaste::DoWithParam(OpDescriptor* WhichOp, OpParam* pOpParam)

    Author:     Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
    Created:    10/10/96
    Inputs:     WhichOp = ptr to op descriptor
                pOpParam = ptr to the params (must be an OpParamPasteAtPosition object)
    Outputs:    -
    Returns:    -
    Purpose:    Performs the Paste operation using the give param object.  This mechanism
                is used by the "paste at position" op, utilised by the OLE drag & drop system.

                pOpParam should be a ptr to an OpParamPasteAtPosition, so that the spread 
                and centre coord of the paste can be passed in.

                If pOpParam is not an OpParamPasteAtPosition, the op fails
                
    Errors:     -
    SeeAlso:    -

********************************************************************************************/
    
void OpPaste::DoWithParam(OpDescriptor* WhichOp, OpParam* pOpParam)
{
    if (pOpParam != NULL && IS_A(pOpParam,OpParamPasteAtPosition))
    {
        OpParamPasteAtPosition* pPasteParam = (OpParamPasteAtPosition*)pOpParam;

        Spread* pSpread = pPasteParam->GetSpread();
        DocCoord Centre = pPasteParam->GetCentre();

        DoPaste(WhichOp,pSpread,&Centre);
    }
    else
    {
        FailAndExecute();
        End();
    }
}

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

>   void OpPaste::DoPaste(OpDescriptor* WhichOp,Spread* pSpread, DocCoord* pCentre)

    Author:     Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
    Created:    10/10/96
    Inputs:     WhichOp = ptr to op descriptor
                pSpread = ptr to spread to paste objects into (can be NULL)
                pCentre = coord of centre point of paste destination (can be NULL if pSpread is NULL)
    Outputs:    -
    Returns:    -
    Purpose:    Helper function for Do() & DoWithParam(), which in turn interfaces with
                DoPasteStandard() (don't look at me - I didn't design this stuff)
                
    Errors:     -
    SeeAlso:    -

********************************************************************************************/
    
void OpPaste::DoPaste(OpDescriptor* WhichOp,Spread* pSpread, DocCoord* pCentre)
{
    BeginSlowJob(-1, FALSE);        // Make sure we have a simple hourglass, without a delay

    // Check with the clipboard if it is OK to go ahead. If the clipboard contents are
    // currently external, this means it'll have to import them into the InternalClipboard
    // before we can actually copy them into our document.
    InternalClipboard *Clipboard = InternalClipboard::Instance();
    BOOL ExternalObjects;
    BOOL ok = (Clipboard!=NULL && Clipboard->PrepareForPaste(&ExternalObjects));

    if (ok)
    {
        // We paste at the same position if the operation was invoked via the PASTEATSAMEPOS OpDescriptor
        // and the stuff we are pasting has not come from an external source.
        BOOL PasteAtSamePos = (((WhichOp->Token) == String(OPTOKEN_PASTEATSAMEPOS)) && (!ExternalObjects));
        ok = DoPasteStandard(PasteAtSamePos, ExternalObjects, pSpread, pCentre);
    }

    if (ok)
        ok = Clipboard->PasteCompleted();

    if (!ok)
        FailAndExecute();

    EndSlowJob();
    End();
}           

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

>   BOOL OpPaste::FindCentreInsertionPosition(Spread** Spread, DocCoord* Position)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/7/94
    Inputs:     -
    Outputs:    Spread:  The spread to place the clipboard objects on
                Position:The centre of the view (Spread coords)

    Returns:    FALSE if it failed. In this case, Spread is returned containing a NULL, and
                Position is returned as DocCoord(0,0)

    Purpose:    Finds the centre insertion position for clipboard objects
    Errors:     -
    Scope:      private
    SeeAlso:    -

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

BOOL OpPaste::FindCentreInsertionPosition(Spread** Spread, DocCoord* Position)
{
    // Let's chuck in a smattering of defensive programming
    ERROR3IF(Spread == NULL || Position == NULL, "Illegal NULL params");
    *Spread = NULL;
    *Position = DocCoord(0,0);  // A default value if we fail

    // ---------------------------------------------------------------------------------
    // Find out which spread is in the centre of the view 
    // this is the spread that the pasted objects will be placed on

    // Obtain the current DocView
    DocView* CurDocView = DocView::GetCurrent();

    ENSURE(CurDocView != NULL, "The current DocView is NULL"); 
    if (CurDocView == NULL)
    {
        return FALSE; // No DocView
    }

    // Get the view rect
    WorkRect WrkViewRect = CurDocView->GetViewRect();

    if (WrkViewRect.IsEmpty() || (!WrkViewRect.IsValid()) )
    {
        return FALSE; // Defensive
    }
    
    // Determine the centre of the view
    WorkCoord WrkCentreOfView; 
    WrkCentreOfView.x = WrkViewRect.lo.x    + (WrkViewRect.Width()/2); 
    WrkCentreOfView.y = WrkViewRect.lo.y    + (WrkViewRect.Height()/2);
    
    // FindEnclosing spread requires an OilCoord
    OilCoord OilCentreOfView = WrkCentreOfView.ToOil(CurDocView->GetScrollOffsets()); 

    // Find out which spread to insert the pasteboard objects onto
    (*Spread) = CurDocView->FindEnclosingSpread(OilCentreOfView);
    if ((*Spread) == NULL)
    {
        // There is no spread
        return FALSE; 
    }

    // Phew
    // ---------------------------------------------------------------------------------
    // Now lets find the spread coordinate of the centre of the view
    DocRect DocViewRect = CurDocView->GetDocViewRect(*Spread);
    
    if ( DocViewRect.IsEmpty() || (!DocViewRect.IsValid()) )
    {
        ERROR3("DocViewRect is invalid");
        return FALSE; // Defensive
    }

    // Find the centre of the DocViewRect
    DocCoord DocCentreOfView; 
    DocCentreOfView.x = DocViewRect.lo.x    + (DocViewRect.Width()/2); 
    DocCentreOfView.y = DocViewRect.lo.y    + (DocViewRect.Height()/2);

    // --------------------------------------------------------------------------------
    // Now convert from DocCoords to spread coords
    (*Spread)->DocCoordToSpreadCoord(&DocCentreOfView);

    // Finally, copy the result into the output parameter
    *Position = DocCentreOfView;
    
    return TRUE;  
}


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

>   BOOL OpPaste::DoPasteStandard(BOOL PasteAtSamePos,  BOOL ExternalData, Spread* pSpread = NULL, DocCoord* pCentre = NULL)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> / Mike
    Created:    28/7/94
    Inputs:     PasteAtSamePos: TRUE if we should paste the objects at their existing positions.
                                FALSE if they should be pasted in the centre of the view

                ExternalData:   This flag indicates that the data has come from the external
                                clipboard. We transform all objects in the clipboard to the
                                centre of the view whenever this flag is set. This is so that
                                subsequent PasteAtSamePos operations position the objects somewhere
                                sensible. 

                pSpread:        ptr to insertion spread.  If NULL, spread in the centre
                                of the current view is used AND pCentre is ignored.
                                
                pCentre:        ptr to coord defining the centre of the paste.
                                if PasteAtSamePos is TRUE, this coord is not used (I think! - Markn)
                                
    Outputs:    -
    Returns:    -
    Purpose:    Pastes the contents of the clipboard into the current document.
    Errors:     -
    Scope:      protected
    SeeAlso:    -

    Changes:    1/6/95  - Fixed the error recovery mechanisms so they don't leave the undo
                          system in a state.
                          Made this function more accessible to derived classes.

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

BOOL OpPaste::DoPasteStandard(BOOL PasteAtSamePos, BOOL ExternalData, Spread* pSpread, DocCoord* pCentre)
{
    // Assume failure until told otherwise
    BOOL HasFailed=TRUE;

    Spread*  InsertionSpread = pSpread;
    DocCoord PastePosition;

    if (InsertionSpread == NULL)
    {
        if (!FindCentreInsertionPosition(&InsertionSpread, &PastePosition))
            return FALSE;
    }
    else
    {
        ERROR3IF(pCentre == NULL,"You've supplied a spread, but no centre coord.  Are you mad?");

        if (pCentre != NULL)
            PastePosition = *pCentre;
    }

    ERROR3IF(InsertionSpread == NULL,"Spread is NULL");

    // -----------------------------------
    // This is an horrendous bodge!
    // What's the point passing in a centre of the routine insists on calculating it for itself?
    // Ho hum...
    // If the data has come from the outside world it's original position is unknown
    // So now that the user has committed themselves to pasting at a certain position
    // record that as being the data's "original position".
    if (ExternalData)
    {
        InternalClipboard::SetOriginalCentrePoint(PastePosition);
    }

    // If trying to paste data at its original position
    // Then retrieve that info from the clipboard and use it as the paste position
    if (PasteAtSamePos)
    {
        PastePosition = InternalClipboard::GetOriginalCentrePoint();
    }
    // -----------------------------------

    if (InsertionSpread != NULL)
    {
        Node* Current;

        InternalClipboard* IntClip = InternalClipboard::Instance();
        if (IntClip==NULL)
        {
            ERROR3("Could not find internal clipboard");
            goto EndOperation;
        }

        BOOL FirstObjectCopied = TRUE; 
        DocRect ObjectsBounds;
        DocCoord CentreOfObjectsBounds; 

        // Create the transform to be applied to all pasted objects
        ObjectsBounds = IntClip->GetObjectsBounds(); 

        CentreOfObjectsBounds.x = ObjectsBounds.lo.x    + (ObjectsBounds.Width()/2); 
        CentreOfObjectsBounds.y = ObjectsBounds.lo.y    + (ObjectsBounds.Height()/2);

        Trans2DMatrix ObjectTrans  (PastePosition.x - CentreOfObjectsBounds.x,
                                    PastePosition.y - CentreOfObjectsBounds.y); 

        // Set the selected spread (assume it is in the Selected Doc and DocView - an
        // ENSURE will occur if this turns out not to be the case!)
        // NOTE selected spread should change due to a change in the sel range!
        Document::SetSelectedViewAndSpread(NULL, NULL, InsertionSpread);

        // Get the current tool
        Tool* pTool = Tool::GetCurrent();
        Spread* pSelSpread = Document::GetSelectedSpread();

        // Get the tool to remove all its blobs before we deselect the nodes.
        // Only do this if the current tool dosent update itself on sel changed messages
        if (pSelSpread!=NULL && pTool!=NULL && !pTool->AreToolBlobsRenderedOnSelection())
            pTool->RenderToolBlobs(pSelSpread,NULL);

        if (!DoStartSelOp(FALSE, TRUE))  // Try to record the selection state
            goto EndOperation;  

        // After the operation ends we will need to inform all DocComponents in the 
        // destination document of the outcome.
        InformDocComponentsOfOperationsOutcome(GetWorkingDoc()); 

        // Inform all DocComponents in the destination doc that a copy is about to take place
        BOOL ok;
        CALL_WITH_FAIL((GetWorkingDoc()->StartComponentCopy()),this, ok)
        
        if (!ok)
        {
            // Start Component copy has failed so abort operation
            // Note that AbortComponentCopy will have been called
            goto EndOperation;
        } 


        Current = IntClip->GetInsertionLayer()->FindFirstChild();

        // Create a range of all clipboard objects which are about to be copied
        // Selected + Unselected + don't cross layers

        // DMc - also need to set the PromoteToParent flag
        Range ClipRange(Current,NULL,RangeControl(TRUE,TRUE,FALSE, FALSE, FALSE, FALSE, FALSE, FALSE));
              
        Node* FirstCopiedObj = NULL;
        Node* Copy; 

        // Now we try and copy all clipboard nodes
        while (Current != NULL)
        {
            // Make a copy of Current
            CALL_WITH_FAIL(Current->NodeCopy(&Copy), this, ok);

            if (!ok)
                goto EndOperation; 

            // Sanity check, will vapourise in retails
            ENSURE(Copy->IsKindOf(CC_RUNTIME_CLASS(NodeRenderableBounded)), 
                "Object being pasted is not a NodeRenderableBounded");
            
            // Remember the first copy we make
            if (FirstCopiedObj == NULL) 
                FirstCopiedObj = Copy; 

            NodeRenderableBounded* pBoundCopy = (NodeRenderableBounded*)Copy;
         
            // Insert object
            if (!DoInsertNewNode(pBoundCopy,
                                 (Spread*)NULL, // Selected spread
                                 FALSE,         // Dont Invalidate region
                                 FirstObjectCopied  // Only clear the selection if this is the
                                                    // first object being copied
                                 ))
            {
                // Tidyup
                Copy->CascadeDelete(); 
                delete Copy;
                goto EndOperation; 
            }

            // Now translate the object into the correct position.
            // Note: This has to be done even when PasteInPlace is operational because
            // the clipboard may have moved the objects ready for OLE external use.
            pBoundCopy->Transform(ObjectTrans);

            // Now call PostDuplicate on the copied node aand all it's children
            BOOL ok = TRUE;
            Node* pCurrent = pBoundCopy->FindFirstDepthFirst();
            while (pCurrent!=NULL && ok)
            {
                ok = pCurrent->PostDuplicate(this);

                pCurrent = pCurrent->FindNextDepthFirst(pBoundCopy);
            }
        
            // We also need to invalidate the region of the node now that it has been transformed
            if (!ok || !DoInvalidateNodeRegion(pBoundCopy, TRUE, FALSE))
            {
                // Tidyup
                Copy->CascadeDelete(); 
                delete Copy; 
                goto EndOperation; 
            } 

            // Normalise the attributes
            ((NodeRenderableInk*) pBoundCopy)->NormaliseAttributes();

            // remove any name attr