selector.cpp

Go to the documentation of this file.

// $Id: selector.cpp 1740 2006-09-05 11:08:36Z 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============================
 */
// The Selector Tool

/*
*/

#include "camtypes.h"

//#include "app.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "stockcol.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "csrstack.h"
//#include "docview.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "ink.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "oilkeys.h"
#include "oilfiles.h"
//#include "rndrgn.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "osrndrgn.h"
//#include "spread.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "nodedoc.h"
//#include "selmsg.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "docvmsg.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "ensure.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "errors.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "selector.h"
#include "selinfo.h"
//#include "fillattr.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "progress.h"
#include "keypress.h"
#include "vkextra.h"
#include "insertnd.h"
#include "nodetxts.h"

#include "tranlate.h"
#include "opscale.h"
#include "opscale2.h"
#include "opsquash.h"
#include "opshear.h"
#include "opflip.h"
#include "oprotate.h"
#include "guides.h"
#include "layer.h"
//#include "basebar.h"

//#include "resource.h"
//#include "viewrc.h"
//#include "justin.h"
//#include "markn.h"
//#include "mario.h"
//#include "rik.h"
//#include "selstr.h"

//#include "will2.h"
//#include "oleprefs.h"
#include "menuops.h"

// knowledge of these classes is required by tab-selection.
// remove these if/when the Iterate...() methods are virtual-ised.
#include "nodebldr.h"


//Matt 11/11/00 - I only wanted a function from the next line...
#include "slicehelper.h"    //For helper functions

//But I had to include all of these to get it to work!!...
//#include "cxfrech.h"      //For CamelotRecordHandler - in camtypes.h [AUTOMATICALLY REMOVED]
#include "userattr.h"       //For UserAttr
#include "tmpltatr.h"       //For TemplateAttribute

#include "cartprov.h"


DECLARE_SOURCE( "$Revision: 1740 $" );

// Karim 09/08/2000 - enable the new tab selection-iteration code.
#define NEW_SELECTION_TAB_ITERATION

#define MIN(a, b)   ((a) < (b) ? (a) : (b))
#define MAX(a, b)   ((a) < (b) ? (b) : (a))
#define CURSORID_UNSET 5000

// Macro defining whether text should come from resources or should be direct...
#define T(res,string) res
//#define T(res,string) string  //<<<<

// These are still char* while we wait for resource technology to be developed for modules
TCHAR* SelectorTool::FamilyName = _T("Selection Tools");
TCHAR* SelectorTool::ToolName   = _T("Selector Tool");
TCHAR* SelectorTool::Purpose    = _T("Selecting objects and editing the selection");
TCHAR* SelectorTool::Author     = _T("Justin Flude & Phil Martin");

SelectorInfoBarOp* SelectorTool::pInfoBarOp = NULL;
BOOL SelectorTool::fSelectorIsCaching = FALSE;

INT32 SelectorTool::CursorStackID= CURSORID_UNSET;
BOOL SelectorTool::bNormalClickCheckProfileDialog = FALSE;
BOOL SelectorTool::bGlineSAllowed = TRUE;


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

    Preference: BlobBorder
    Section:    Selection Blob Sizes
    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Range:      0 ... 10 (millimetres)
    Purpose:    Determines how wide a border, in millimetres, to inflate the bounding
                rectangle of the selected object, when drawing blobs around it.  The
                default is 4 mm.

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

INT32 SelectorTool::nBlobBorder = 4;

// This defines the number of millipoints in a millimetre.
const MILLIPOINT nMPperMM = 2835L;



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

    Preference: InitialBlobs
    Section:    Selector Tool
    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Range:      0 ... UINT_MAX
    Purpose:    Determines which blobs should be initially displayed.  This should really be
                done by the blob manager!

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

unsigned SelectorTool::fBlobPref = 1;       // by default, show only bounds/rotate blobs



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

    Preference: AllowCorelToggleClick
    Section:    Selector Tool
    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Range:      FALSE ... TRUE
    Purpose:    If TRUE (the default) allows a single click on a selected object to toggle
                between bounds blobs & rotate blobs, for compatibility with Corel Draw.  This
                toggling option not allowed when Object blobs are shown, it would be a pain.

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

BOOL SelectorTool::fAllowCorelToggleClick = TRUE;



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

    Preference: SelectUnderLikeArtWorks
    Section:    Selector Tool
    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Range:      FALSE ... TRUE
    Purpose:    If TRUE then the select-under feature, Alt-Click, works exactly like ArtWorks,
                so that an Alt-Click on an unselected object selects that object rather than
                the object underneath.  If FALSE then Alt-Click always selects an object
                underneath the clicked object, irrespective of whether the clicked object
                was selected or not.  The default is FALSE, as this is consistent with the
                way that select-inside works.

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

BOOL SelectorTool::fSelectUnderLikeArtWorks = FALSE;



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

    Preference: SlaveLineWidthToButton

    Section:    Selector Tool
    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    26/2/96

    Range:      Boolean
    Purpose:    Controls whether attributes (line widths mainly) are considered when 
                calculating bounding rectangles for objects. This is used when displaying
                and editing width/height information in the infobar.

                If TRUE, the "Scale Line Widths" button will also control the behaviour
                of the function SelectorInfoBarOp::DontConsiderAttrs() - if the button is
                depressed, Attrs will not be considered, and vice versa.

                If FALSE, the behaviour will be fixed, and controlled by the preference
                "ConsiderLineWidths" in the "Selector Tool" section.

                The default setting (TRUE) is to determine the state from the button setting.

    Notes:      This preference is read by our associated SelectorInfoBarOp
                This preference is not currently written by camelot

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

BOOL SelectorTool::fSlaveLineWidthToButton = TRUE;



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

    Preference: ConsiderLineWidths

    Section:    Selector Tool
    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    26/2/96

    Range:      Boolean
    Purpose:    Controls whether attributes (line widths mainly) are considered when 
                calculating bounding rectangles for objects. This is used when displaying
                and editing width/height information in the infobar.

                This preference is IGNORED if the "SlaveLineWidthToButton" pref is TRUE.

                The default setting (FALSE) is to ignore line widths in these displays.

    Notes:      This preference is read by our associated SelectorInfoBarOp
                This preference is not currently written by camelot

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

BOOL SelectorTool::fConsiderLineWidths = FALSE;



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

    Preference: fUseScalingFix

    Section:    Selector Tool
    Author:     Harrison_Ainsworth (Xara Group Ltd) <camelotdev@xara.com>
    Created:    13/11/97

    Range:      Boolean
    Purpose:    Controls whether my scaling fix is used

                The default setting (FALSE) is to *not* use the new scaling fix

    Notes:      This preference is read by our associated SelectorInfoBarOp
                This preference is not currently written by camelot

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

BOOL SelectorTool::fUseScalingFix = FALSE;



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

    Preference: bPageDoubleClickOpenFile

    Section:    Selector Tool
    Author:     Phil_Martin (Xara Group Ltd) <camelotdev@xara.com>
    Created:    31/05/2005

    Range:      Boolean
    Purpose:    Controls whether double-clicking on the page will show the Open dialog

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

BOOL SelectorTool::bPageDoubleClickOpenFile = FALSE;



// This is our own permanent pointer to the blob manager.
BlobManager* SelectorTool::pBlobManager = NULL;

// Run-time type checking etc etc
CC_IMPLEMENT_DYNCREATE(OpSelectorDragBox, Operation)
CC_IMPLEMENT_DYNCREATE(OpDragRotateCentre, Operation)
CC_IMPLEMENT_MEMDUMP(SelectorTool, DragTool)

// report memory line info
#define new  CAM_DEBUG_NEW



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

>   SelectorTool::SelectorTool()

    Author:     Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com>
    Created:    21/6/93
    Purpose:    Dummy Constructor - sets member pointers to NULL and initialises the
                record of which blobs are displayed (initially only "tiny" blobs).
    SeeAlso:    SelectorTool::Init

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

SelectorTool::SelectorTool()
  : //pInfoBarOp(NULL),
    fRotateCentreIsValid(FALSE),
    eCurrentBlobs(BOUNDS_BLOBS),
    fShowToolBlobs(TRUE),
    fValidSelectedBlob(FALSE)
{
    // initialise all our member pointers to NULL.

    SelectionSpread = NULL;
    SelectRange     = NULL;
    StartSpread     = NULL;

    pClickSimpleNode    = NULL;
    pClickCompoundNode  = NULL;
    pLastClickNode      = NULL;
    pPreProcClickNode   = NULL;

    pNormalCursor       = NULL;
    pAdjustCursor       = NULL;
    pUnderCursor        = NULL;
    pInsideCursor       = NULL;
    pUnderAdjustCursor  = NULL;
    pInsideAdjustCursor = NULL;
    pLeafCursor         = NULL;
    pLeafAdjustCursor   = NULL;

    pALLCursor          = NULL;
    pNWSECursor         = NULL;
    pNESWCursor         = NULL;
    pNSCursor           = NULL;
    pWECursor           = NULL;
    pGradFillCursor     = NULL;
    pDragRotateCursor   = NULL;
    pHorzGuideCursor    = NULL;
    pVertGuideCursor    = NULL;

    bGlineSAllowed      = TRUE;
    m_bComputeAreaDetails   = FALSE;

    // Pre-load the resource we're going to use
    (CamArtProvider::Get())->FindBitmap( _R(IDBMP_HANDLE_6) );
    (CamArtProvider::Get())->FindBitmap( _R(IDBMP_HANDLE_3) );
    (CamArtProvider::Get())->FindBitmap( _R(IDBMP_HANDLE_1) );
    (CamArtProvider::Get())->FindBitmap( _R(IDBMP_HANDLE_8) );
    (CamArtProvider::Get())->FindBitmap( _R(IDBMP_HANDLE_45) );
    (CamArtProvider::Get())->FindBitmap( _R(IDBMP_HANDLE_45) );
    (CamArtProvider::Get())->FindBitmap( _R(IDBMP_HANDLE_27) );
    (CamArtProvider::Get())->FindBitmap( _R(IDBMP_HANDLE_27) );
    (CamArtProvider::Get())->FindBitmap( _R(IDBMP_HANDLE_CENTRE) );
}



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

>   virtual SelectorTool::~SelectorTool()

    Author:     Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com>
    Created:    21/6/93
    Purpose:    Destructor (Virtual). Does nothing.

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

SelectorTool::~SelectorTool()
{
    // empty
}



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

>   virtual BOOL SelectorTool::Init()

    Author:     Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com>
    Created:    21/6/93
    Returns:    FALSE if it does not want to be created, TRUE otherwise
    Purpose:    Used to check if the Tool was properly constructed
    SeeAlso:    SelectorTool::SelectorTool

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

BOOL SelectorTool::Init()
{
/*  // Claim the left Alt for our tool.
    ToolKeyClaimDetails Mods;
    Mods.Value = 0;
    Mods.Keys.Alternative1 = TRUE;
    ClaimToolKey((Tool*) this, Mods);
*/
    // Read in the preferences.
    if (!ReadPrefs())
    {
        TRACE( _T("Couldn't read Selector tool's preferences!\n"));
        return FALSE;
    }

    // Declare the OpDescriptors of each transform.
    if (!OpTranslateTrans::Declare() ||
        !OpRotateTrans::Declare() ||
        !OpScaleTrans::Declare() ||
//      !OpScale2Trans::Declare() ||
        !OpShearTrans::Declare() ||
        !OpSquashTrans::Declare() ||
        !OpFlipTrans::Declare() ||
        !OpSelectorDragBox::Declare() ||
        !OpDragRotateCentre::Declare())
    {
        ENSURE(FALSE, "Couldn't 'declare' all OpDescriptors in SelectorTool::Init");
        return FALSE;
    }

    // This should be set to NULL by default. It will be set properly below, if
    // everthing is working as it should
    pInfoBarOp = new SelectorInfoBarOp;
    
    // In the debug version make sure we can create a bar.
    ENSURE(pInfoBarOp != NULL, "Failed to create selector tool info-bar");
    if (pInfoBarOp == NULL) return FALSE;

    // Get a permanent pointer to the blob manager.
    pBlobManager = GetApplication()->GetBlobManager();
    ENSURE(pBlobManager != NULL, "Selector tool: couldn't get blob manager");
    if (pBlobManager == NULL) return FALSE;

    // Get a permanent pointer to the application's SelRange object.
    SelectRange = GetApplication()->FindSelection();

    // set the initial state of the blob buttons
    bsBlobStyle.Object   = (fBlobPref & 2) != 0;
    bsBlobStyle.Fill     = (fBlobPref & 4) != 0;
    bsBlobStyle.Artistic = (fBlobPref & 8) != 0;
    bsBlobStyle.ToolObject = TRUE;
    bsBlobStyle.Effect  = FALSE;

    // Object blobs & Tiny blobs are mutually exclusive.
    bsBlobStyle.Tiny     = !bsBlobStyle.Object;
    
    // If we are displaying tool blobs then decide whether they are bounds or rotate blobs.
    fShowToolBlobs = (fBlobPref & 1) != 0;
    eCurrentBlobs = (pInfoBarOp->InRotateMode()) ? ROTATE_BLOBS : BOUNDS_BLOBS;
    
    // Success!!
    return TRUE;
}



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

>   static BOOL SelectorTool::ReadPrefs()

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    15/8/94
    Inputs:     -
    Outputs:    -
    Returns:    TRUE if successful.
    Purpose:    Reads settings concerning the selector tool from the .INI file.
    Errors:     -
    SeeAlso:    SelectorTool::Init

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

BOOL SelectorTool::ReadPrefs()
{
    return  Camelot.DeclareSection(TEXT("Selector Tool"), 10) &&
            Camelot.DeclarePref(TEXT("Selector Tool"), TEXT("BlobBorder"),
                                &nBlobBorder, 0, 10) &&
            Camelot.DeclarePref(TEXT("Selector Tool"), TEXT("LockAspect"),
                                &SelectorInfoBarOp::fLockAspect, FALSE, TRUE) &&
//         Camelot.DeclarePref(TEXT("Selector Tool"), TEXT("LeaveCopy"),
//                             &SelectorInfoBarOp::fLeaveCopy,  FALSE, TRUE) &&
//         Camelot.DeclarePref(TEXT("Selector Tool"), TEXT("TransFills"),
//                             &SelectorInfoBarOp::fTransFills, FALSE, TRUE) &&
            Camelot.DeclarePref(TEXT("Selector Tool"), TEXT("ScaleLines"),
                                &SelectorInfoBarOp::fScaleLines, FALSE, TRUE) &&
            Camelot.DeclarePref(TEXT("Selector Tool"), TEXT("InitialBlobs"),
                                &SelectorTool::fBlobPref, 0, UINT_MAX) &&
            Camelot.DeclarePref(TEXT("Selector Tool"), TEXT("AllowCorelToggleClick"),
                                &SelectorTool::fAllowCorelToggleClick, FALSE, TRUE) &&
            Camelot.DeclarePref(TEXT("Selector Tool"), TEXT("SelectUnderLikeArtWorks"),
                                &SelectorTool::fSelectUnderLikeArtWorks, FALSE, TRUE) &&

            Camelot.DeclarePref(TEXT("Selector Tool"), TEXT("SlaveLineWidthToButton"), &fSlaveLineWidthToButton) &&
            Camelot.DeclarePref(TEXT("Selector Tool"), TEXT("ConsiderLineWidths"), &fConsiderLineWidths) &&
            Camelot.DeclarePref(TEXT("Selector Tool"), TEXT("UseScalingFix"), &fUseScalingFix) &&
            Camelot.DeclarePref(TEXT("Selector Tool"), TEXT("PageDoubleClickOpenFile"), &bPageDoubleClickOpenFile)
            ;
}



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

>   virtual void SelectorTool::Describe(void *InfoPtr)

    Author:     Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com>
    Created:    21/6/93
    Inputs:     InfoPtr - A pointer to a tool info block. It is passed cast to void* as
                the version of the tool is unknown at this point. Later versions of the
                Tool class may have more items in this block, that this tool will not use
    Outputs:    InfoPtr - The structure pointed to by InfoPtr will have had all the info
                that this version of the Tool knows about
    Purpose:    Allows the tool manager to extract information about the tool

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

void SelectorTool::Describe(void *InfoPtr)
{
    // Cast structure into the latest one we understand.
    ToolInfo_v1* Info = (ToolInfo_v1*) InfoPtr;
    Info->InfoVersion = 1;
    
    // You should always have this line.
    Info->InterfaceVersion = GetToolInterfaceVersion();  
        
    // These are all arbitrary at present.
    Info->Version = 1;
    Info->ID      = GetID();
    Info->TextID  = _R(IDS_SELECTOR_TOOL);
        
    Info->Family  = FamilyName;
    Info->Name    = ToolName;
    Info->Purpose = Purpose;
    Info->Author  = Author;
//  Info->ToolBoxBitmap = _R(IDB_SELR_TOOLBOX);
//  Info->ToolBoxBitmapActive = _R(IDB_SELR_TOOLBOX_ACTIVE);
    
    Info->InfoBarDialog = 0;
    Info->BubbleID = _R(IDBBL_SEL_TOOLICON);
}



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

>   virtual void SelectorTool::SelectChange(BOOL isSelected)

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    24/11/93
    Inputs:     isSelected  -   TRUE if this tool is becoming current, FALSE
                                otherwise
    Purpose:    Called whenever this tool is selected or deselected.

                Performs jobs related to changing tools, eg changing the cursor to a
                selector cursor, changing the displayed tool blobs to selector tool blobs,
                changing the preferences for BlobManager-rendered blobs.

    Errors:     Debug warning if creating the cursor fails.

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

void SelectorTool::SelectChange(BOOL isSelected)
{
    if (isSelected)
    {
        // Load the grad-fill cursor etc.
        pGradFillCursor     = new Cursor(this, _R(IDCSR_SEL_GRADPOINT));
        pNormalCursor       = new Cursor(this, _R(IDCSR_SEL_NORMAL));
        pAdjustCursor       = new Cursor(this, _R(IDCSR_SEL_ADJUST));
        pUnderCursor        = new Cursor(this, _R(IDCSR_SEL_UNDER));
        pInsideCursor       = new Cursor(this, _R(IDCSR_SEL_INSIDE));
        pUnderAdjustCursor  = new Cursor(this, _R(IDCSR_SEL_UNDERADJUST));
        pInsideAdjustCursor = new Cursor(this, _R(IDCSR_SEL_INSIDEADJUST));
        pALLCursor          = new Cursor(this, _R(IDCSR_SEL_GRADPOINT));
        pLeafCursor         = new Cursor(this, _R(IDCSR_SEL_LEAF));
        pLeafAdjustCursor   = new Cursor(this, _R(IDCSR_SEL_LEAFADJUST));
        pNWSECursor         = new Cursor(this, _R(IDCSR_SIZENWSE));
        pNESWCursor         = new Cursor(this, _R(IDCSR_SIZENESW));
        pNSCursor           = new Cursor(this, _R(IDCSR_SIZENS));
        pWECursor           = new Cursor(this, _R(IDCSR_SIZEWE));
        pDragRotateCursor   = new Cursor(this, _R(IDCSR_SEL_GRADPOINT));
        pHorzGuideCursor    = new Cursor(this, _R(IDCSR_SEL_HGUIDE));
        pVertGuideCursor    = new Cursor(this, _R(IDCSR_SEL_VGUIDE));
        
        // This tool has just been selected.  Push an appropriate cursor.
        CursorStackID = CursorStack::GPush(pNormalCursor);

        // Initially we know of no selection, above or below.
        SelectionSpread = NULL;
        pClickSimpleNode = NULL;
        pClickCompoundNode = NULL;
        pLastClickNode = NULL;
        pPreProcClickNode = NULL;

        // Reset these flags used within the click logic etc.
        fIsBlobDrag = fPossibleToggleClick = fIgnoreSelChange = FALSE;
        fAllowIdleProcessing = fMouseHasMoved = TRUE;

        // Create and display my info bar please
        if (pInfoBarOp != NULL)
        {
            pInfoBarOp->pSelectorTool = this;
            if(pInfoBarOp->WindowID == NULL)
            {
                // set its pointer to me and call its create() function to get it to set its
                // controls
                pInfoBarOp->Create();
            }
            else
            {
                pInfoBarOp->Open();
                pInfoBarOp->MakeCurrent();
            }
        }

        // Version 1.0 of Camelot doesn't have ArtLines, so make sure their blobs
        // are always OFF.
        bsBlobStyle.Artistic = FALSE;
        bsBlobStyle.Effect  = FALSE;
        
        // Which blobs do I want displayed
// >>>> Commented on advice from Rik
//      if (Document::GetCurrent() != NULL)
//      {
            // Tell the blob manager about our blobs.
            if (pBlobManager != NULL)
                pBlobManager->ToolInterest(bsBlobStyle);
//      }

        // Note that whenever we switch to the selector we always start in bounds
        // rather than rotate mode.
        eCurrentBlobs = BOUNDS_BLOBS;
        SelectorInfoBarOp::fRotateMode = FALSE;
        if (pInfoBarOp != NULL)
        {
            // Make sure the info-bar reflects the state of this.
            pInfoBarOp->SetRotateMode(SelectorInfoBarOp::fRotateMode);
        }

        // Get the initial selection, if any, and render the blobs.
        if (UpdateSelectionInfo()) pBlobManager->RenderToolBlobsOn(this, SelectionSpread, NULL);
    }
    else
    {
        // Deselection - pop the tool's cursor(s).
        CursorStack::GPop(CursorStackID);
        CursorStackID=CURSORID_UNSET;

        // Delete the grad-fill cursor etc.
        delete pGradFillCursor;
        delete pNormalCursor;
        delete pInsideCursor;
        delete pAdjustCursor;
        delete pUnderCursor;
        delete pUnderAdjustCursor;
        delete pInsideAdjustCursor;
        delete pLeafCursor;
        delete pLeafAdjustCursor;
        delete pALLCursor;
        delete pNWSECursor;
        delete pNESWCursor;
        delete pNSCursor;
        delete pWECursor;
        delete pDragRotateCursor;
        delete pHorzGuideCursor;
        delete pVertGuideCursor;
        
        // Use this flag to avoid an unsightly redraw when simply changing tools.
        fSelectorIsCaching = TRUE;
        
        // Hide and destroy the info bar.
        if (pInfoBarOp != NULL)
        {
            // Make sure that the info bars pointer here is set to null and close itself down.
            // But NOT if the application is on the way out
            if (pInfoBarOp->HasWindow() && !GetApplication()->CamelotIsDying() )
                pInfoBarOp->Close();
            pInfoBarOp->pSelectorTool = NULL;
            pInfoBarOp->Delete();
        }

        fSelectorIsCaching = FALSE;
        
        // ensure any tool object blobs are removed.
        if (pBlobManager != NULL)
        {
            BlobStyle bsRemoves;
            bsRemoves.ToolObject = TRUE;
            pBlobManager->RemoveInterest(bsRemoves);
        }

        // If there is a spread with the selection on it, there is still a view,
        // and the tool blobs are being displayed, then render them off
        pBlobManager->RenderToolBlobsOff(this, SelectionSpread, NULL);
    }
}

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

>   static void SelectorTool::UnCacheInfoBar(BOOL Force)

    Author:     Chris_Parks (Xara Group Ltd) <camelotdev@xara.com>
    Created:    13/10/94
    Inputs:     Force Flag - will be deleted even if current
    Outputs:    -
    Returns:    -
    Purpose:    deletes the cached infobar and sets it's ID to NULL -this is normally called
                when the selector is not the current tool - 
                it can be forced however(on close down etc..)
    Errors:     -
    SeeAlso:    -

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

void SelectorTool::UnCacheInfoBar(BOOL Force)
{
    if (pInfoBarOp)
    {
        // normally we would only uncache the infobar if we were not the current tool
        // but there are occasions when we might need to force it
        if (pInfoBarOp->pSelectorTool == NULL || Force)
        { 
            pInfoBarOp->Delete();   
            pInfoBarOp->WindowID = NULL;
        }
    }
}




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

>   virtual void SelectorTool::OnMouseMove(DocCoord dcPos, Spread* pSpread, ClickModifiers mods)

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    31/8/94
    Inputs:     dcPos       the current position of the mouse (spread coord)
                pSpread     the spread containing the mouse
                mods        the mouse modifiers, eg. Adjust, Constrain etc
    Outputs:    -
    Returns:    -
    Purpose:    Called by the tool system for the current tool when the mouse is moved
                outside of a drag.  Checks if the mouse is over one of the tool's blobs,
                changing the cursor appropriately if it is.
    Errors:     -
    SeeAlso:    SelectorTool::ChangeCursor; SelectorTool::IsNearBlob

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

void SelectorTool::OnMouseMove(DocCoord dcPos, Spread* pSpread, ClickModifiers mods)
{
    // Note that the mouse has moved so we know to update the status-bar text on the next
    // idle event.
    fMouseHasMoved = TRUE;

    // Make sure the cursor reflects which keys are down.  It is possible for the modifier
    // keys to change state without key-events being generated, so we must check this on
    // every mouse move.
//  ResetCursorNow();
    // Make sure the cursor reflects which keys are down.  It is possible for the modifier
    // keys to change state without key-events being generated, so we must check this on
    // every mouse move.
    // (That means prepare the global vars for us by GetClickModifiers in FigureUserFeedback)
//  StartSpread = pSpread;
//  ClickMods = mods;
//  ClickStart = dcPos;

    // If there isn't any selection, or it's in a different spread, then do nothing.
//  if (SelectionSpread == NULL || SelectionSpread != pSpread)
//      return;
    
    String_256 str;
    Cursor* pPointerShape;

    FigureUserFeedback(pSpread, dcPos, mods, FALSE, &str, &pPointerShape);

    if (!(str.IsEmpty()))
        SetStatusText(&str);

    if (CursorStackID!=CURSORID_UNSET)
        CursorStack::GSetTop(pPointerShape,CursorStackID);
}



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

>   virtual BOOL SelectorTool::OnKeyPress(KeyPress* pKey)

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/11/94
    Inputs:     pKey            pointer to a key-press object representing a keystroke.
    Outputs:    -
    Returns:    TRUE if the key-event is handled, FALSE if not.
    Purpose:    Called when a key is pressed of released.  If the key is a "click modifier"
                such as the ALT or CTRL key then the cursor is changed to indicate whatever
                the tool can do with that modifier.
    Errors:     -
    SeeAlso:    -

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

BOOL SelectorTool::OnKeyPress(KeyPress* pKey)
{
    // Find the current state of the "click" keyboard modifiers...
    ClickMods = ClickModifiers::GetClickModifiers();

    switch (pKey->GetVirtKey())
    {

// >>>> BODGE! These cases are only here to prevent the messages
//              being passed on to other key handlers (very slow!)
    case CAMKEY(CC_MOD_ADJUST):                     // bit 0 of fKeyStates (SHIFT)
        break;

    case CAMKEY(CC_MOD_ALTERNATIVE):                    // bit 1 of fKeyStates (ALT)
        break;

    case CAMKEY(CC_MOD_CONSTRAIN):                  // bit 2 of fKeyStates (CONTROL)
        break;
// >>>> End

    case CAMKEY(TAB):                               // moves selection to next rendered node
        if( pKey->IsConstrain() )
            return FALSE;           // We have other uses for Ctrl+Tab (switch document)

        if (pKey->IsPress()) HandleTabKey(ClickMods.Adjust);
        break;

    case CAMKEY(1):                                 // toggle tool blobs
        if (pKey->IsModified()) 
        {
            // if Ctrl/Alt/Shift is down, pass the message on to another handler
            // instead of 'absorbing' the keypress
            return FALSE;
        }
        if (pKey->IsPress() && !pKey->IsModified())
        {
            BoundsButtonChange();
            if (pInfoBarOp != NULL)
            {
                pInfoBarOp->SetLongGadgetValue(_R(IDC_SEL_SHOWBOUNDSBLOBS), fShowToolBlobs, FALSE);
            }
        }
        break;

    case CAMKEY(2):                                 // toggle edit blobs
        if (pKey->IsModified()) 
        {
            return FALSE;
        }
        if (pKey->IsPress() && !pKey->IsModified())
        {
            BlobStyle bs(TRUE);
            SelectionBlobChange(bs);
            if (pInfoBarOp != NULL)
            {
                pInfoBarOp->SetLongGadgetValue(_R(IDC_SEL_SHOWOBJECTBLOBS), bsBlobStyle.Object, FALSE);
            }
        }
        break;

    case CAMKEY(3):                                 // toggle fill blobs
        if (pKey->IsModified()) 
        {
            return FALSE;
        }
        if (pKey->IsPress() && !pKey->IsModified())
        {
            BlobStyle bs(FALSE, FALSE, TRUE);
            SelectionBlobChange(bs);
            if (pInfoBarOp != NULL)
            {
                pInfoBarOp->SetLongGadgetValue(_R(IDC_SEL_SHOWFILLBLOBS), bsBlobStyle.Fill, FALSE);
            }
        }
        break;

    case CAMKEY(HOME):                              // select first object in render order
        if (pKey->IsPress())
        {
            if (SelectionSpread != NULL) NodeRenderableInk::DeselectAll();
            HandleTabKey(FALSE);
        }
        break;

    case CAMKEY(END):                               // select last object in render order
        if (pKey->IsPress())
        {
            if (SelectionSpread != NULL) NodeRenderableInk::DeselectAll();
            HandleTabKey(TRUE);
        }
        break;

    case CAMKEY(4):                                 // toggle bounds/rotate blobs
        if (pKey->IsModified()) 
        {
            return FALSE;
        }
        if (pKey->IsPress() && !pKey->IsModified())
        {
            RotateButtonChange(SelectorInfoBarOp::fRotateMode = !SelectorInfoBarOp::fRotateMode);
            if (pInfoBarOp != NULL)
            {
                pInfoBarOp->SetLongGadgetValue(_R(IDC_SEL_ROTATEBUTTON), SelectorInfoBarOp::fRotateMode,
                                               FALSE);
            }
        }
        break;

    default:                                    // not interested in processing this
        return FALSE;
    }   

    // If we processed a click modifier then update the cursor and return that we processed
    // the keystroke.
        SetKeyDownCursor(ClickMods);

    // Yes, we processed this key-event.
    return TRUE;
}



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

>   void SelectorTool::SetKeyDownCursor(ClickModifiers cmods)

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    1/12/94
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Decodes the bit-field fKeyStates, indicating which combination of modifier
                keys are down, and sets the cursor appropriately.
    Errors:     -
    SeeAlso:    SelectorTool::OnKeyPress; SelectorTool::OnMouseMove

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

void SelectorTool::SetKeyDownCursor(ClickModifiers cmods)
{
    // Get current position information for call to change pointer shape...
    Spread*  pSpread;
    DocCoord dcMousePos;
    if( DocView::GetCurrentMousePos( &pSpread, &dcMousePos ) &&
        Tool::GetCurrentID()== TOOLID_SELECTOR )
PORTNOTE("other", "Removed bar drag usage")
#ifndef EXCLUDE_FROM_XARALX
        && !BaseBar::IsDragging())
#endif
    {
//      StartSpread = pSpread;
//      ClickStart = dcMousePos;
        // Call nice central routine to figure out what pointer shape to show...
        // (Set the status bar text while we're at it.)
        String_256 Str;
        Cursor* pPtr;
        FigureUserFeedback(pSpread, dcMousePos, cmods, TRUE, &Str, &pPtr);
        if (CursorStackID!=CURSORID_UNSET)
            CursorStack::GSetTop(pPtr,CursorStackID);
        if (!(Str.IsEmpty()))
            SetStatusText( &Str );
    }
}



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

>   void SelectorTool::ResetCursorNow()

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    13/1/95
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Called when a mouse button-up event or end-of-drag event occurs.  It resets
                the cursor according to which modifier keys are up or down, without a key
                event having to take place.
    Errors:     -
    SeeAlso:    SelectorTool::SetKeyDownCursor; SelectorTool::HandleDragClick;
                SelectorTool::HandleButtonUp; SelectorTool::OnMouseMove

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

void SelectorTool::ResetCursorNow()
{
    // Make sure the cursor reflects which keys are down.  It is possible for the modifier
    // keys to change state without key-events being generated, so we must check this on
    // every mouse move.
    SetKeyDownCursor(ClickModifiers::GetClickModifiers());
}



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

>   static void SelectorTool::AllowIdleWork(BOOL fIsAllowed)

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    14/10/94
    Inputs:     fIsAllowed          if TRUE then the tool will act on idle events, if FALSE
                                    the tool will ignore idle events.
    Outputs:    -
    Returns:    -
    Purpose:    Turns idle processing on or off.  During idle events the selector tool
                updates the status bar, so if a drag operation, for instance, wants to
                place its own text in the status bar while it is running it should call
                this function at its start and at its end.
    Errors:     -
    SeeAlso:    SelectorTool::OnIdle

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

void SelectorTool::AllowIdleWork(BOOL fIsAllowed)
{
    // Make sure the selector is the current tool.
    ERROR3IF(Tool::GetCurrent() == NULL || Tool::GetCurrent()->GetID() != TOOLID_SELECTOR,
                "Selector isn't current tool in SelectorTool::AllowIdleWork");

    if (Tool::GetCurrent() != NULL && Tool::GetCurrent()->GetID() == TOOLID_SELECTOR)
    {
        // Set the flag.
#ifndef SELECTION_AREA_FEATURE
        ((SelectorTool*) Tool::GetCurrent())->fAllowIdleProcessing = fIsAllowed;
#else
        ((SelectorTool*) Tool::GetCurrent())->fAllowIdleProcessing = fIsAllowed;
//      ((SelectorTool*) Tool::GetCurrent())->fAllowIdleProcessing = (fIsAllowed || m_bComputeAreaDetails);
#endif
    }
// >>>>
//((SelectorTool*) Tool::GetCurrent())->fAllowIdleProcessing = FALSE;
}



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

>   virtual BOOL SelectorTool::OnIdle()

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/10/94
    Inputs:     -
    Outputs:    -
    Returns:    TRUE if idle events are still required (currently always returns TRUE).
    Purpose:    Called on idle events.  Performs hit-detection on the current mouse position
                and updates the status-bar text accordingly.
    Errors:     -
    SeeAlso:    -

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

BOOL SelectorTool::OnIdle()
{
#ifdef SELECTION_AREA_FEATURE
    if (m_bComputeAreaDetails)
    {
        BOOL bNeedsMoreTime = SelectRange->GetAreaDetailsWhileIdle(&xlSelectionArea, &xlSelectionPerim);
        if (!bNeedsMoreTime)
        {
            pInfoBarOp->SetEdit_OnSelectionChange();
            pInfoBarOp->UpdateAllRecords();