range.cpp

Go to the documentation of this file.

// $Id: range.cpp 1744 2006-09-06 15:58:54Z 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============================
 */
    
/* Implementation of class Range */     
    
/*
*/ 
 
#include "camtypes.h" 

//#include "app.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "document.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "docmsgs.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "docview.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "ensure.h"  - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "node.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "range.h"    - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "rndrgn.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "simon.h"
//#include "ink.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "spread.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "dlgbar.h"
//#include "group.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "sprdmsg.h"
#include "layer.h"
//#include "fillattr.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "attrmgr.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "peter.h"
#include "nodetext.h"
//#include "undoop.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "nodetxtl.h"
#include "nodetxts.h"
#include "nodecont.h"
#include "nodeshad.h"
#include "objreg.h"
#include "attrmap.h"
#include "toolmsg.h"
#include "comattrmsg.h"
#include "qualattr.h"
#include "ngcore.h"     // NameGallery, for stretching functionality
#include "objchge.h"    // for ues of ObjChangeParam
//#include "scrvw.h"
//#include "will2.h"
//#include "justin2.h"
//#include "resimmap.h" //For _R(IDS_SINGLELAYER_INSIDE)
//#include "bmpsdlgr.h" // _R(IDS_ON_FRAME_OUTSIDE_NOREF)
#include "effects_stack.h"
//#include "bars.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "fillattr2.h"

DECLARE_SOURCE( "$Revision: 1744 $" );    

CC_IMPLEMENT_DYNAMIC(Range, CCObject)   
CC_IMPLEMENT_DYNAMIC(NodeListItem, ListItem)

CC_IMPLEMENT_DYNAMIC(SelRange, Range)   
CC_IMPLEMENT_DYNAMIC(SelChangingMsg, Msg)

CC_IMPLEMENT_DYNAMIC(ListRange, Range)   

CC_IMPLEMENT_DYNAMIC(SelRangeMessageHandler, MessageHandler)

CC_IMPLEMENT_DYNAMIC(CommonAttrsChangedMsg, Msg);


// This line MUST occur after all CC_IMPLEMENT lines
// Declare smart memory handling in Debug builds
#define new CAM_DEBUG_NEW


// Enable Fast XOR drag blob rendering - see below
// Set this value to 0 (FALSE) to disable, or 1 (TRUE) to enable fast XORing
#define ENABLE_FAST_XOR 1


// Define _DEBUG_LISTCHECKS to enable list checking in ListRange
#ifdef _DEBUG
//  #define _DEBUG_LISTCHECKS
#endif


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

>   RangeControl::RangeControl( BOOL Sel                = FALSE,
                                BOOL Unsel              = FALSE,
                                BOOL Cross              = FALSE,
                                BOOL IgLock             = FALSE,
                                BOOL Rendr              = FALSE,
                                BOOL IgInvisible        = FALSE,
                                BOOL SibsOnly           = FALSE,
                                BOOL Promot             = FALSE )
    Author:     Phil_Martin (Xara Group Ltd) <camelotdev@xara.com>
    Created:    26/01/95

    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    RangeControl constructor. Sets the flags to safe defaults!
                See RangeControl definition for details of flags.

    Errors:     -

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

RangeControl::RangeControl( BOOL Sel, BOOL Unsel, BOOL Cross,
                            BOOL IgLock, BOOL Rendr, BOOL IgInvisible, BOOL SibsOnly,
                            BOOL Promot )
{
    Selected = Sel;
    Unselected = Unsel;
    CrossLayer = Cross;
    IgnoreLockedLayers = IgLock;
    IgnoreNoneRenderable = Rendr;
    IgnoreInvisibleLayers = IgInvisible;
    SiblingsOnly = SibsOnly;
    PromoteToParent = Promot;
}




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

>   Range::Range(Node* First, Node* Last, RangeControl RangeControlFlgs)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/6/93
    Inputs:     RangeControlFlags: Specifies the selected status of the nodes to be included
                                   in the range.
                                   
                                   If RangeControlFlgs.Selected = TRUE
                                        All nodes with a selected status are included as 
                                        members of the range. 
                                        
                                   If RangeControlFlgs.Unselected = TRUE
                                        All nodes with an unselected status are included as
                                        members in the range. 
                                        
                                   If both these flags are TRUE then all nodes from First to Last
                                   are included in the range. 

                                   If RangeControlFlgs.CrossLayer = TRUE
                                        The range may cross several layers; when the end of a layer
                                        is reached, the search will continue at the start of the
                                        following layer.

                                   If RangeControlFlgs.IgnoreLockedLayers = TRUE
                                        locked layers are included in the search.
                                        Defaults to FALSE so locked layers ignored.
                                   
                                   If RangeControlFlgs.IgnoreNoneRenderable = TRUE
                                        non-renderable nodes are included in the search.
                                        Defaults to FALSE so non-redenderable nodes ignored.
                                   
                                   If RangeControlFlgs.IgnoreInvisibleLayers = TRUE
                                        Invisable layers are included in the search.
                                        Defaults to FALSE so invisible layers ignored.
                                   
                First:  The node from which to commence searching for members of a range.  
                Last:   The final node to search (must be a right sibling of First, or NULL). 
                        NULL specifies that all nodes from First to the end of First's sibling 
                        list (or end of the tree, if CrossLayer is TRUE) are to be searched for
                        members of the range. 
                            
                                    
    Outputs:    -
    Returns:    -
    Purpose:    The purpose of this function is to create a node range. 
    Errors:     -

********************************************************************************************/
  
Range::Range(Node* First, Node* Last, RangeControl RangeControlFlgs)
{
    // When the First node in a range is NULL the range is assumed to lie directly under
    // the surface of layers...
/*
    if (First!=NULL)
    {
        ERROR3IF( RangeControlFlgs.Unselected
                    && !First->FindParent()->IsLayer()
                    && First != Last,
                    "Attempt to create an illegal range!"
                 );
    }
*/

    RangeControlFlags = RangeControlFlgs; 
    FirstNode = First; 
    LastNode = Last;
    pCommonAttribCache = NULL;             // The common attribute cache only comes into
                                           // existance if the FindCommonAttribute functions
                                           // are called on the range.
 
    // Initialise the XOR rendering stuff
    NodeToRender = NULL;
    ResetXOROutlineRenderer(TRUE);
} 




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

>   Range::Range()


    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    2/3/94
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Creates an uninitialised range 
    Errors:     -
    SeeAlso:    -

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

Range::Range()
{
    FirstNode = LastNode = NULL;
    pCommonAttribCache = NULL;             // The common attribute cache only comes into
                                           // existance if the FindCommonAttribute functions
}




Range::~Range()
{
    // Destroy the CommonAttribSet if one exists
    if (pCommonAttribCache)
    {
        delete pCommonAttribCache; 
    }
}




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

>   Range::Range(const Range& Range);   

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    2/3/94
    Inputs:     Rng:    The Range to copy 
    Outputs:    -
    Returns:    -
    Purpose:    Range copy constructor 
    Errors:     -
    SeeAlso:    -

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

Range::Range(Range& Rng)
{
    // If the range is a sel range we must be sure that the range has been cached 
    Rng.FreshenCache();

    RangeControlFlags = Rng.RangeControlFlags;  
    FirstNode = Rng.FirstNode; 
    LastNode = Rng.LastNode;
    pCommonAttribCache = NULL;      
}      




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

>   Range& Range::operator=(Range& Range)              

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    2/3/94
    Inputs:     Range: The range to copy 
    Outputs:    
    Returns:    The Range
    Purpose:    Range = operator
    Errors:     -
    SeeAlso:    -

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

Range& Range::operator=(Range& Rng)
{
    // If the range is a sel range we must be sure that the range has been cached 
    Rng.FreshenCache(); 

    RangeControlFlags = Rng.RangeControlFlags;  
    FirstNode = Rng.FirstNode; 
    LastNode = Rng.LastNode; 
    pCommonAttribCache = NULL;      
    return *this;       
}




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

>   void Range::SetRangeControl(RangeControl RangeControlFlgs)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/6/93 
    
    Inputs:     RangeControlFlags: Specifies the selected status of the nodes to be included
                                   in the range.
    Outputs:    -
    Returns:    -
    Purpose:    To set the range control for the range.  
    Errors:     -
    SeeAlso:    -

********************************************************************************************/
                            
void Range::SetRangeControl(RangeControl RangeControlFlgs)
{
    RangeControlFlags = RangeControlFlgs;
}   




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

>    Node* Range::FindFirst(BOOL AndChildren = FALSE)

     Author:    Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> (Changed by Phil, 30/11/94)
     Created:   25/6/93
     
     Returns:   If the range contains any members then
                    A pointer to the first node in the range is returned
                Else
                    NULL is returned 
            
     Purpose:   The purpose of this function is to find the first node in a range. 

     SeeAlso:   Range::FindNext    
     
     Errors:    An assertion failure will occur if:

                There are no more nodes to search and the last node to search was not found.

**********************************************************************************************/
                                    
Node* Range::FindFirst(BOOL AndChildren)
{
    // Preconditions...
    ERROR2IF(this==NULL,NULL,"FindFirst called on NULL range");

    // Locals...
    Node* pNode = FirstNode;


// **** !!!! BODGE - Traps bug in message broadcast from document.cpp to try to
// keep the program stable.
    if (Document::GetSelectedSpread() != NULL)
    {
        if (!Document::SpreadBelongsToDoc(Document::GetSelected(),
                                            Document::GetSelectedSpread()))
        {
            TRACE( _T("SelRange: Selected Spread is NOT in the Selected Document!\n"));
            return(NULL);
        }
    }
// **** !!!! BODGE

    // Implementation...
    // If First is NULL then the caller expects to get a range of nodes
    // in the child lists of layers. So find the first layer on the
    // current spread.
    if (pNode == NULL)
    {
        Spread* pSelectedSpread = Document::GetSelectedSpread();
        if (pSelectedSpread==NULL)
        {
            // The range does not have a FirstNode. Normally it would find one
            // automatically based on the SelectedSpread but there is no SelectedSpread
            // so we have no choice but to return an empty range to the caller...
            TRACEUSER( "Phil", _T("Warning! Range is NULL because there's no selected spread\n"));
            return NULL;
        }
        
        // Oh well, we will use the first layer instead
        pNode = pSelectedSpread->FindFirstLayer();

        // If there is no layer, then give up and return NULL
        if (pNode==NULL)
            return NULL;
    }

    // The first node might be a valid member of the range so test for that...
    // (Set the special FirstNode flag TRUE so that the logic treats this node is
    //  if it hasn't yet been met in the scan.)
    pNode = SmartFindNext(pNode, AndChildren, TRUE);
    return pNode;
}                       


     

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

>    Node* Range::FindNext(Node* Prev, BOOL AndChildren = FALSE)
     Author:    Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>  (Changed by Phil, 30/11/94)
     Created:   25/6/93
     Inputs:    Prev: The previous node in the range (usually returned from a 
                       Range::FindFirst, or a previous Range::FindNext call). 
     Outputs:    - 
     Returns:   If the range contains any more members then
                    A pointer to the next node in the range is returned
                Else
                    NULL is returned 
     Purpose:   The purpose of this function is to find the next node in the range after Prev 
     SeeAlso:   Range::FindFirst    
     Errors:    An assertion failure will occur if:
                There are no more nodes to search and the last node to search was not found.

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

Node* Range::FindNext(Node* pPrevious, BOOL AndChildren)
{
    // Preconditions
    // No need to check that "this" is NULL because that's already been done
    // in FindFirst.
    ERROR2IF(pPrevious == NULL, NULL, "NULL pointer passed to Range::FindNext");

    Node* pNode = SmartFindNext(pPrevious, AndChildren);

    // DMc
    // if the output is the same as the input, and promote to parent is set,
    // the this should never happen !
    if (pNode == pPrevious && RangeControlFlags.PromoteToParent)
    {
        return NULL;
    }
        
    return pNode;
}



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

>    Node* Range::FindPrev(Node* pNode, BOOL AndChildren = FALSE)
     Author:    Phil_Martin (Xara Group Ltd) <camelotdev@xara.com>
     Created:   19/01/95
     Inputs:    pNode: The node which you want the previous one in the range to... 
     Outputs:    - 
     Returns:   If the range contains any members before the input node then
                    A pointer to the prev node in the range is returned
                Else
                    NULL is returned (Note NULL returned if input node was not in the range)
     Purpose:   The purpose of this function is to find the previous node in the range before
                the input node.
                NOTE! THIS ROUTINE IS SLOW! It scans through the range in forwards order
                until it meets the input node, then returns the previous node to that!!!
     SeeAlso:   Range::FindFirst; Range::FindNext    
     Errors:    -

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

Node* Range::FindPrev(Node* pNode, BOOL AndChildren)
{
    // Preconditions
    // No need to check that "this" is NULL because that's already been done
    // in FindFirst.
    ERROR2IF(pNode == NULL, NULL, "NULL pointer passed to Range::FindNext");

    Node* pPrev = NULL;
    Node* pCurrent = FindFirst(AndChildren);
    while (pCurrent)                                // While there's a node to check
    {
        if (pCurrent == pNode)                      // See if it's the one we're looking for
            return pPrev;                           // If it is return the previous node!

        pPrev = pCurrent;                           // Else, remember this node
        pCurrent = FindNext(pCurrent, AndChildren); // and find the next one in the range
    }

    return NULL;
}



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

>    Node* Range::FindLast()

     Author:    Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
     Created:   25/6/93
     
     Returns:   If the range contains any members then
                    A pointer to the last node in the range is returned
                Else
                    NULL is returned 
            
     Purpose:   The purpose of this function is to find the last node in a range. 
                If the range was constructed with a NULL last node specifier then
                the range is scanned until the last node is found. If a non NULL last node
                was specified however the value of last is simply returned. It's existance
                is not verified !. 

     SeeAlso:   Range::FindFirst
                Range::FindNext    
     
     Errors:    An assertion failure will occur if:

                There are no more nodes to search and the last node to search was not found.

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

Node* Range::FindLast()
{
    if (LastNode == NULL)
    {
        // We need to search for the last node in the range
        Node* Scout = FindFirst();
        Node* n = NULL; 
        while (Scout != NULL)
        {
            n = Scout;
            Scout = FindNext(Scout); // Get the next value in the range
        }
        return n; // If the range is empty NULL will be returned
    }
    else
    {
        // get the parent of the last node (if necessary to promote)
        Node * pContext = LastNode;

        if (pContext != NULL)
        {
            Node *pParent = pContext->FindParent();
        
            if (RangeControlFlags.PromoteToParent)
            {
                while (pParent)
                {
                    if (pParent->ShouldITransformWithChildren())
                    {
                        pContext = pParent;
                    }
                
                    pParent = pParent->FindParent();
                }
            }
        }

        return pContext; 
    }
}




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

>   void Range::Update(BOOL TellWorld = FALSE)

     Author:    Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
     Created:   03/10/94    (Was an inline function prior to this)

     Inputs:    BOOL TellWorld: When TRUE the function will inform the world that the 
                selection has changed. Normally the selection is changed in an operation
                and it is unneccesary to broadcast a SelChangingMsg at this point because
                this will occur at the end of the operation. However If the selection is
                changed outside of an operation then the flag should be set to TRUE.  
     Outputs:   -
     Returns:   -

     Purpose:   To inform the SelRange that the selection has changed
                This invalidates the SelRange's selection-info cache so it will be
                recached when info is next requested.

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

void  Range::Update(BOOL TellWorld)
{
    Camelot.FindSelection()->Update(TellWorld);     
}   




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

>    UINT32 Range::Count()
     Author:    Phil_Martin (Xara Group Ltd) <camelotdev@xara.com>
     Created:   15/2/94
     Inputs:    -
     Outputs:   -
     Returns:   The number of nodes described by the Range.
     Purpose:   To count the number of nodes in a range. Currently this routine always scans
                the range to count the number of nodes. In some future incarnation it may 
                keep the count cached for quicker access.
     SeeAlso:   Range::FindFirst
     SeeAlso:   Node::FindNextInRange
     Errors:    -

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

UINT32 Range::Count()
{
    UINT32 count = 0;
    Node* pNode;

    pNode = FindFirst();
    while (pNode)
    {
        count++;
        pNode = FindNext(pNode);
    }

    return(count); 
}


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

>    BOOL Range::Contains(Node* pLookFor, BOOL bAndChildren)

     Author:    Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
     Created:   3/5/95
     Inputs:    pLookFor = a pointer to a node to look for.
                bAndChildren - Test for node being in subtree of member of range
     Outputs:   -
     Returns:   TRUE if the range contains this particular node
                FALSE if the node is not held within this range
     Purpose:   To determin whether a particular node is actually in the range list.
     Errors:    -

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

BOOL Range::Contains(Node* pLookFor, BOOL bAndChildren)
{
    Node* pNode=FindFirst();
    while (pNode)
    {
        if (pNode==pLookFor)
            return TRUE;

        if (bAndChildren && pNode->IsNodeInSubtree(pLookFor))
            return TRUE;

        pNode=FindNext(pNode);
    }
    return FALSE;
}



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

>   BOOL Range::ContainsSelectInside()
    Author:     Phil_Martin (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/11/94
    Inputs:     -
    Outputs:    -
    Returns:    TRUE if Selection inside occurs in this range one or more times.
                FALSE otherwise.
                (Also returns FALSE when the Range is empty)
    Purpose:    To find out whether Select-inside is going on in this range. I.e. are any
                members of this range children of nodes which would normally be selected.
    Errors:     -

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

BOOL Range::ContainsSelectInside()
{
#if !defined(EXCLUDE_FROM_RALPH)
    // Preconditions
    ERROR2IF(this==NULL,FALSE,"ContainsSelectInside called on NULL pointer");

    // Implementation
    Node* pNodeInRange = FindFirst();
    Node* pParent;
    while (pNodeInRange)                                // While there's a node in the range
    {
        pParent = pNodeInRange->FindParent();           // Look at it's parent node
        
        // DMc - added promotehittestonchildrentome test to eliminate the 'inside' setting
        // for nodes should as shadows, contours, bevels etc
        while (pParent)
        {
            if (pParent->IsAnObject() && pParent->IsParentOfSelected() &&
                pParent->PromoteHitTestOnChildrenToMe())    // If that's marked parent of sel
                return TRUE;                                // Then this node is "inside" so return TRUE

            pParent = pParent->FindParent();
        }

        pNodeInRange = FindNext(pNodeInRange);          // Else, keep scanning members of range
    }
#endif
    return FALSE;                                       // If no more in range, none were "inside"
}




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

>    Node* Range::SmartFindNext(Node* pContext, BOOL AndChildren = FALSE, BOOL FirstCall = FALSE) const
     Author:    Phil_Martin (Xara Group Ltd) <camelotdev@xara.com>
     Created:   24/11/94
     Inputs:    pContext    Pointer to node in range to find next range member from
                            NOTE! pContext MUST be in the range!!!
                AndChildren Flag specifying whether to return children of nodes in
                            the range.
                Last        A pointer to the final node to search or NULL if all possible
                            members of the range are to be searched.   
                Flags       Define the nodes which are to be members of the range 
                     Flags.Selected   : Selected nodes in the range
                     Flags.Unselected : Unselected nodes in the range
                     Flags.CrossLayer : Crossing into the next layer is allowed
                If Flags.Selected and Flags.Unselected are both set, then all nodes from
                this node to the Last node (or end of the layer, whichever comes first,
                if CrossLayer is clear) are included in the range.
     Returns:   If the range contains any members following pContext then
                    A pointer to the next node in the range is returned
                Else
                    A NULL is returned 
                If no flags are set then there can be no members in the range
                and NULL is returned.
     Purpose:   This function looks for the next node in a range following this node
                and ending at the node specified by Last (or the last node in this layer
                if the CrossLayer flag is clear).
                Last must be a right sibling of this node, or NULL if all siblings are
                to be searched.                 
     SeeAlso:   Node::FindFirstInRange; Node::FindNextInRange    
     Errors:    There are no more nodes to search and Last was not found
     Scope:     Protected

**********************************************************************************************/
/*  Technical Notes:

    This routine is just a souped up depth-first traversal of the whole tree with subtrees
    carefully pruned off to make the routine efficient.

**********************************************************************************************/
Node* Range::SmartFindNext(Node* pContext, BOOL AndChildren, BOOL FirstCall) const
{
    // Preconditions
    ERROR2IF(this==NULL,NULL,"SmartFindNext called on NULL range");
    ERROR2IF(pContext==NULL,NULL,"SmartFindNext not given a context node to start from");
    ERROR2IF(RangeControlFlags.Unselected && AndChildren,NULL,"Range can't cope with unsel and children");
    ERROR2IF(pContext->IsPaper() && !pContext->IsLayer(),NULL,"SmartFindNext called above layers surface");

    // If the PromoteToParent flag is set then the context node might be a "promoted parent"
    if (RangeControlFlags.PromoteToParent && !FirstCall && !AndChildren)
    {
        // Using PromoteToParent, it is possible for the context node to jump *above* the
        // last node in the Range, causing us to iterate outside of it. We must therefore
        // check whether the context node is a parent of the last node, in which case
        // we have finished iteration.
        if (pContext->IsNodeInSubtree(LastNode))
            return NULL;

        // If the context node's parents wish to do so, then switch them in instead of it.
        // Go up the tree until this is no longer the case.
        Node* pParent = pContext->FindParent();
        while (pParent != NULL && pParent->ShouldITransformWithChildren())
        {
            pContext = pParent;
            pParent = pContext->FindParent();
        }
    }

    // Implementation
    // Loop, looking for suitable nodes and testing whether they're in the range or not.
    // Traverses the tree in basically depth-first order...
    do
    {
        // If context node from previous findnext was last node then there can be no more...
        if (!FirstCall && LastNode!=NULL && pContext==LastNode) return NULL;

        // Do the normal depth-first thing; assume subtree we're given has already been
        // met and so try to find lowest leaf of next subtree...
        // (If this is the first call, from FindFirst, then treat the node we've got
        //  as if it hasn't been scanned yet. 'Cos it hasn't!)
        if (pContext->FindNext() || FirstCall)
        {
            // Here, either have a sibling or FirstCall is TRUE
            // So, if firstcall is NOT TRUE, must be here due to sibling...
            if (!FirstCall)
                pContext = pContext->FindNext();                    // Find top of next subtree
            FirstCall = FALSE;

            // In a normal depth-first traversal of the tree we would find the deepest first child
            // in the subtree. However, by choosing not to go down certain child links
            // we can omit whole subtrees from the scan.
            // The following tests optimise away much of the work of a true depth-first
            // search by pruning subtrees that don't need to be traversed.

            //---------------------------------------------------------------------------//
            // If above layers, skip on down towards one...
            while (pContext->FindFirstChild() && !pContext->IsLayer() && pContext->IsPaper())
                pContext = pContext->FindFirstChild();
            // If we've not made it to a layer and we're still in paper then prune whatever
            // subtree we have because this routine is interested in children of layers and
            // their subtrees.
            if (pContext->IsPaper() && !pContext->IsLayer())
                goto PruneSubtree;

            //---------------------------------------------------------------------------//
            // We know now we're either at a layer node or underneath one...
            // If this layer has children go down to that level because that surface has
            // a special meaning to this routine. Most ranges are found in the child lists
            // of Layers.
            if (pContext->IsLayer())
            {
                // Don't allow Ranges into invisible layers at all!
                // New range control flag allows this to be overriden, defaults to FALSE
                if ( !RangeControlFlags.IgnoreInvisibleLayers && !((Layer*)pContext)->IsVisible() )
                    goto PruneSubtree;

                // Don't allow SelRanges into locked layers at all!
                // New range control flag allows this to be overriden, defaults to FALSE
                if ( RangeControlFlags.IgnoreLockedLayers && ((Layer*)pContext)->IsLocked() )
                    goto PruneSubtree;

                // If layer has children go find first child and continue pruning tests
                if (pContext->FindFirstChild())
                    pContext = pContext->FindFirstChild();
                // Otherwise don't try to process empty layers at all!
                else
                    goto PruneSubtree;
            }

            //---------------------------------------------------------------------------//
            // Descend subtree further if we come across select-inside (flagged by ParentOfSelected)
            // If looking for selected nodes (and not unselected nodes - Ed 1/5/95)
            // AND this node is the parent of selected nodes
            // Then go down this subtree as far as the parent of selected
            // flags last out...
            if (pContext->IsParentOfSelected() && RangeControlFlags.Selected && !RangeControlFlags.Unselected)
            {
                while (pContext->IsParentOfSelected() && pContext->FindFirstChild())
                {
                    pContext = pContext->FindFirstChild();
                }
                ERROR3IF(pContext->IsParentOfSelected(),"Parent of selected has no children!");
            }

// Logically, if promotetoparent is not set we shouldn't return any node which would
// be the target of promotetoparent activities...
if (!RangeControlFlags.PromoteToParent && RangeControlFlags.Selected && RangeControlFlags.Unselected)
{
    while (pContext->ShouldITransformWithChildren() && pContext->FindFirstChild())
    {
        pContext = pContext->FindFirstChild();
    }
    ERROR3IF(pContext->ShouldITransformWithChildren(), "Parent of selected has no children!");
}

            //---------------------------------------------------------------------------//
            // Finally, there's no choice any more, we've got to descend into the subtree IF
            // the AndChildren flag is set and the node is a Primary member of the range
            // Then we are either already scanning a subtree and so we must continue
            // or else we're starting to scan a subtree because it meets the range
            // criteria and the range specifies that all child nodes of primary nodes
            // should be returned.
            // So, look for lowest leaf of subtree...
            if (!RangeControlFlags.SiblingsOnly && AndChildren)
            {
                Node* pChild = pContext->FindFirstChild();
                while (pChild)
                {
                    if (InRange(pChild, AndChildren))
                    {
                        pContext=pChild;
                        pChild=pChild->FindFirstChild();
                    }
                    else
                        pChild=pChild->FindNext();
                }
            }

            //---------------------------------------------------------------------------//
            // If control gets here then the root of the "next" subtree is being returned for
            // consideration because we have judged that its subtree doesn't need scanning!
PruneSubtree:;

        }
        else
        {
            // No next subtree, so go up to parent...
            // If no parent then we must have scanned the entire tree (by definition of
            // depth-first traversal) so return NULL to caller.
            pContext = pContext->FindParent();

            // If we're not promoting to parent and we find our parent is the type of object we would normally
            // promote to, DON'T return it, keep going up!
            // (It doesn't make sense to return a node and it's parent controller)
            // This change made so that a shadowed node on the clipboard will return a set of sensible
            // common attributes when FindCommonAttributes is called on the clipboard range.
            // Test by using Paste Attributes
// NOPE, THIS DOESN'T WORK!
//          while (pContext && !AndChildren && !RangeControlFlags.PromoteToParent && pContext->ShouldITransformWithChildren())
//          {
//              pContext = pContext->FindParent();
//          }

            if (pContext==NULL)
                return NULL;

            // Ranges cannot exist across spreads so if we reach a Spread node we can stop...
            if (pContext->IsSpread())
                return NULL;

            if (pContext->IsLayer() && !RangeControlFlags.CrossLayer)
                // Can't cross layers so signal end of Range...
                return NULL;
        }
    }
    while (pContext!=NULL && (pContext->IsLayer() || pContext->IsPaper() || !InRange(pContext, AndChildren)));

    // Finally, check for parents wanting to be included instead of the children
    if (pContext != NULL && RangeControlFlags.PromoteToParent && !AndChildren)
    {
        Node *pParent = pContext->FindParent();
        while (pParent != NULL && pParent->ShouldITransformWithChildren())
        {
            pContext = pParent;
            pParent = pContext->FindParent();
        }
    }

    return pContext;
}




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

>   BOOL Range::InRange(Node* pNode, BOOL AndChildren) const

     Author:    Phil_Martin (Xara Group Ltd) <camelotdev@xara.com>
     Created:   24/11/94
     Rewritten: 08/12/2004
     Inputs:    pNode           Pointer to node to test for inclusion in the range
                AndChildren     Children of the primary range are allowed to be returned
     Outputs:   -
     Returns:   TRUE if node is in this range (ignoring CrossLayer flag)
                FALSE if not
     Purpose:   Private helper function for SmartFindNext.
                Tests whether the presented node is in the range according to the
                RangeControlFlags and two other locally presented flags.

                Version 2, 08/12/2004
                Simplified and adjusted to deal with selection inside Compound Parents
                Controllers and PostProcessors

                This function should ONLY be called on nodes that /could/ be members of Range
                Not Layers or Paper nodes!

     Scope:     Protected
     SeeAlso:   Range::SmartFindNext
     Errors:    When attempting to return children and finds no parent link.

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

BOOL Range::InRange(Node* pNode, BOOL AndChildren) const
{
    // Preconditions
    ERROR2IF(this==NULL, FALSE, "InRange called on NULL range");
    ERROR2IF(pNode==NULL, FALSE, "InRange given a NULL node");
    ERROR2IF(pNode->IsPaper(), FALSE, "InRange asked to decide on Paper");
    ERROR2IF(pNode->IsLayer(), FALSE, "InRange asked to decide on Layer");
    ERROR2IF(RangeControlFlags.Unselected && !RangeControlFlags.Selected && FirstNode==NULL, FALSE, "InRange can't detect unselected nodes without a FirstNode");

    //------------------------------------------------------------------------------------
    // Test for Primary members of the range...
    //
    // If an op has asked this node for permission to apply the op to it, and the node said no, return.
    if (pNode->GetOpPermission() == PERMISSION_DENIED)
        return FALSE;

    // if trying to ignore none renderable nodes then check the node
    SubtreeRenderState state = pNode->RenderSubtree(NULL);
    if (RangeControlFlags.IgnoreNoneRenderable && !(state==SUBTREE_ROOTONLY || state==SUBTREE_ROOTANDCHILDREN))
        return FALSE;

    // If looking for selected nodes and node is selected, OK
    if (RangeControlFlags.Selected && pNode->IsSelected())
        return TRUE;

// If we're not promoting to parents but we seem to have found one such parent
// Then deny this node
if (!AndChildren && !RangeControlFlags.PromoteToParent && pNode->ShouldITransformWithChildren())
    return FALSE;

    // If looking for all nodes but not going into child subtrees, OK whether node is selected or not
    if (!AndChildren && RangeControlFlags.Selected && RangeControlFlags.Unselected)
        return TRUE;

    // If node isn't paper then it ought to have a parent node which we will need later...
    Node* pParent = pNode->FindParent();
    ERROR2IF_PF(pParent==NULL, FALSE, ("OOER! Range found an ink node %lx without any parents!",pNode));

    Node* pFirstParent = NULL;
    if (FirstNode)
        pFirstParent = FirstNode->FindParent();

    // If looking for immediate siblings only then check that this ndoe has the same parent as
    // the first node (we've already checked pParent to be non-NULL)
    if (RangeControlFlags.SiblingsOnly)
    {
        if (pFirstParent!=pParent)
            return FALSE;
    }
    
    // If looking for unselected nodes then we need to check whether this node is unselected
    // and in the same level of the tree as the first node...
    while (!pNode->IsSelected() && RangeControlFlags.Unselected && pFirstParent && pParent)
    {
        if (pFirstParent == pParent)
            return TRUE;

        pFirstParent = pFirstParent->FindParent();
        pParent = pParent->FindParent();
    }

    //------------------------------------------------------------------------------------
    // Test for Secondary members of the range by recursion...
    //
    // If looking for children of nodes in the primary range specification
    // or looking for selected nodes (which may be "selected-inside")
    // Then we must check that our parent is in the range. If he is then we are!
    if (AndChildren && !pParent->IsLayer() && !pParent->IsPaper())
        return InRange(pParent, AndChildren);

    return FALSE;
}








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

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

>   List* Range::MakeListOfNodes(BOOL AndChildren = FALSE)

    Author:     Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/7/94
    Inputs:     -
    Outputs:    -
    Returns:    Pointer to a list of NodeListItems representing the current range
    Purpose:    This function will create and return a pointer to a list representing
                the objects in the range. It will return NULL if it couldn't create the
                list due to lack of memory.
                WARNING! This function creates objects which must be deleted by the calling
                routine. The last thing we need right now is another bunch of listitems
                appearing on shutdown.
    Errors:     -
    SeeAlso:    -

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

List* Range::MakeListOfNodes(BOOL AndChildren)
{
    // Create the list object first
    List* RangeList = new List;
    
    // only build the list if we found enough memory
    if (RangeList)
    {
        // Get the first object in the range to start the loop
        Node* pNode = FindFirst(AndChildren);
        BOOL Failed = FALSE;            // Will be TRUE if we ran out of memory

        // loop round all the objects in the range
        while (pNode)
        {
            if (!pNode->IsNodeHidden()) // DON'T record hidden nodes because they might be deleted!
            {
                // Mark Howitt 13/12/00 - This is a bodge fix for the release version. As the ClipViewAttribute is
                // only used by the new bevel code, it`s safe (Bodge) to make it not includable in any selections.
                // This will need to be fix for future versions if we decide to start using the attribute correctly!
                if(!pNode->IsAClipViewAttr())
                {
                    NodeListItem* pItem;
                    if ((pItem = new NodeListItem(pNode))!=NULL)
                    {
                        // Creation successful, so add it to the list
                        RangeList->AddTail(pItem);
                    }
                    else
                    {
                        // Creation failed, so flag an error and break the loop
                        Failed = TRUE;
                        break;
                    }
                }
            }

            // Go to the next node in the range
            pNode = FindNext(pNode, AndChildren);
        }
        // Handle an error if it occurred
        if (Failed)
        {
            while (!RangeList->IsEmpty())
            {
                NodeListItem* pItem = (NodeListItem*)(RangeList->RemoveHead());
                delete pItem;
            }
            delete RangeList;
            return NULL;
        }

    }
    return RangeList;
}


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

>   void Range::UpdateParentBoundsOfSelection(BOOL AndChildren = FALSE)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    15/7/94
    Purpose:    This function updates the parent bounds of all selected objects. It is a 
                lot more efficient than calling ChangeBounds on every node in the selection
                (cos it uses an algorithm!)
    SeeAlso:    NodeRenderableBounded::ChangeBounds

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

void Range::UpdateParentBoundsOfSelection(BOOL AndChildren)
{
    // Find the first node in the selection
    Node* pNode = FindFirst(AndChildren);
    
    // loop through the selection, invalidating all the bounding rects
    while (pNode!=NULL)
    {
        // If the node was bounded, then invalidate its bounding rect
        if (pNode->IsBounded())
            ((NodeRenderableBounded*)pNode)->InvalidateBoundingRect();

        // Get the next node in the selection
        pNode = FindNext(pNode,