docview.cpp

Go to the documentation of this file.

// $Id: docview.cpp 1729 2006-08-30 12:48:48Z 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============================
 */
                                    
/********************************************************************************************
 DocView.CPP - DocView class definition file.

    This is the Camelot document viewer object.

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

#include "camtypes.h"
//#include "docview.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "camview.h"
#include "vstate.h"
#include "wrkrect.h"
//#include "tool.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "toollist.h"
//#include "monotime.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "rndrgn.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "osrndrgn.h"
#include "grndrgn.h"
#include "paper.h"
//#include "oilcoord.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "doccoord.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "winrect.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "oilrect.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "errors.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "mario.h"
//#include "will.h"
#include "camelot.h"        // For DisableSys flag
#include "ccdc.h"
#include "csrstack.h"
//#include "app.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "document.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "nodedoc.h"
#include "chapter.h"
//#include "spread.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "page.h"
//#include "ink.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "blobs.h"
//#include "fillattr.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "snap.h"
//#include "progress.h"
#include "lineattr.h"
//#include "attrmgr.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "nodepath.h"
#include "nodeshap.h"
#include "nodershp.h"
//#include "dragcol.h"
//#include "mainfrm.h"
#include "zoomops.h"
#include "viewmenu.h"
#include "menuops.h"
//#include "clikmods.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "nodetext.h"
#include "nodetxts.h"
#include "rulers.h"
#include "dlgmgr.h"
//#include "bubbleid.h"
//#include "filters.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "keypress.h"
#include "nodebev.h"

// for shadow node hit-testing 
#include "nodecont.h"
#include "nodeshad.h"
#include "nbevcont.h"

#include "pushtool.h"   // For OpPush
//#include "bars.h" - in camtypes.h [AUTOMATICALLY REMOVED]

#ifdef PHOTOSHOPPLUGINS
#include "plugmngr.h"   // CheckHaveDetailsOnPlugIns
#endif //PHOTOSHOPPLUGINS

//#include "resource.h" // Matt 12/01/2001 - For _R(IDC_PUSHTOOLCURSOR)

#include "colplate.h"   // For on-screen separated rendering

#include "rendwnd.h"    // Shouldn't need this
#include "draginfo.h"

DECLARE_SOURCE("$Revision: 1729 $");


// Used by SpreadRedraws class.
#define MAX_REDRAW_REGIONS (20)

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

>   class SpreadRedraws : public ListItem

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/12/94
    Purpose:    Encapsulates a set of regions on a spread, which must be accumulated in order
                for them to be redrawn at some point, possibly all in one go.  This class
                chooses the most efficient invalidation method, according to the number
                and nature of regions added.
    SeeAlso:    PendingRedraws

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

class SpreadRedraws : public ListItem
{
    CC_DECLARE_MEMDUMP(SpreadRedraws);

public:
    SpreadRedraws(Spread*);

    Spread *GetSpread() { return pInvalidSpread; }
    void AddInvalidRegion(DocRect, Node* pInvalidNode);
    void FlushRedraw(DocView*);
    void ClearBackmostChangedNode(Node* pNode);

private:
    Spread *pInvalidSpread;
    UINT32 RectCount;
    BOOL TooManyRegions;
    DocRect InvalidRegions[MAX_REDRAW_REGIONS];
    Node* m_pBackmostChangedNode;
};



CC_IMPLEMENT_MEMDUMP(PendingRedraws, List)
CC_IMPLEMENT_MEMDUMP(SpreadRedraws, ListItem)
CC_IMPLEMENT_DYNAMIC(DocView, View)
CC_IMPLEMENT_DYNAMIC(DocViewMsg, Msg)
CC_IMPLEMENT_DYNCREATE(OpToggleFore, Operation)
CC_IMPLEMENT_DYNCREATE(OpToggleScroll, Operation)
CC_IMPLEMENT_DYNCREATE(OpToggleSolidDrag, Operation)


#define new CAM_DEBUG_NEW



//-----------------------------------------------------------------------------------------//
// Swap macro
// this is too beautiful to work!  (This is too obscure to be worth it!)

#define Swap(a, b)      ((a) ^= (b), (b) ^= (a), (a) ^= (b))



// *******************************************************
// MIN and MAX Macros - These should not be here, I'm sure

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

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



//-----------------------------------------------------------------------------------------//
// Initialise class static variables...
//
DocView*        DocView::Selected = NULL;

INT32           DocView::OnTopCount  = 0;
OnTopCode       DocView::OnTopReason = Normal;
Spread*         DocView::OnTopSpread = NULL;
RenderRegion*   DocView::OnTopRenderRegion = NULL;


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

    Preference: ConstrainAngle
    Section:    Constraints
    Range:      >0 ---> <2PI
    Purpose:    This is the default angle to which angles are constrained to (eg when
                rotating with constrain on, it will only rotate in multiples of this
                constrain angle.  It must be greater than zero degrees and less than
                360 degrees (note that it is recorded in radians).

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

double DocView::DefaultConstrainAngle = PI / 4.0;


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

    Preference: BackgroundRendering
    Section:    Rendering
    Range:      0 or 1
    Purpose:    Defines whether or not to use background rendering on new views.
                0 => No background rendering
                1 => Use background rendering

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

BOOL DocView::BackgroundRendering = TRUE;


//-----------------------------------------------------------------------------------------//



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

    Preference: SolidDragging
    Section:    Dragging
    Range:      0 or 1
    Purpose:    Defines whether or not solid dragging is enabled.
                0 => Solid dragging disabled
                1 => Solid dragging enabled

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

BOOL DocView::SolidDragging = TRUE;


//-----------------------------------------------------------------------------------------//



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

    Preference: IdleDragDelay
    Section:    Dragging
    Range:      0 to 10000
    Purpose:    Defines delay time in milliseconds between detecting idle state and showing
                extra dragging info.

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

UINT32 DocView::IdleDragDelay = 200;


//-----------------------------------------------------------------------------------------//



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

    Preference: IdleDragDelay2
    Section:    Dragging
    Range:      0 to 10000
    Purpose:    Defines delay time in milliseconds between detecting idle state and showing
                extra dragging info.

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

UINT32 DocView::IdleDragDelay2 = 1000;


//-----------------------------------------------------------------------------------------//



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

    Preference: SolidDragTimeLimit
    Section:    Dragging
    Range:      0 to 10000
    Purpose:    Defines time limit in milliseconds for solid drag redraw. When redraw takes
                longer than this value, dragging falls back to outline mode

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

UINT32 DocView::SolidDragTimeLimit = 333;


//-----------------------------------------------------------------------------------------//



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

    Preference: OriginOutlineShowNonOverlap
    Section:    Dragging
    Range:      0 or 1
    Purpose:    Original outlines will be shown as soon as dragged items don't overlap
                originals.

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

BOOL DocView::OriginOutlineShowNonOverlap = FALSE;


//-----------------------------------------------------------------------------------------//



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

    Preference: OriginOutlineShowAlways
    Section:    Dragging
    Range:      0 or 1
    Purpose:    Original outlines will be shown as soon as dragged items don't overlap
                originals.

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

BOOL DocView::OriginOutlineShowAlways = FALSE;


//-----------------------------------------------------------------------------------------//



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

    Preference: OutlineShowBounds
    Section:    Dragging
    Range:      0 or 1
    Purpose:    Dragged outlines will show a bounding rectangle.

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

BOOL DocView::OutlineShowBounds = TRUE;


//-----------------------------------------------------------------------------------------//



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

>   SpreadRedraws::SpreadRedraws(Spread *pSpread)

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/12/94
    Inputs:     pSpread - the spread on which invalid regions will occur.
    Purpose:    Construct a spread redraw regions object for a given spread.  The invalid
                region is initially NULL.
    SeeAlso:    SpreadRedraws; PendingRedraws

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

SpreadRedraws::SpreadRedraws(Spread *pSpread)
{
    pInvalidSpread = pSpread;
    RectCount = 0;
    TooManyRegions = FALSE;
    m_pBackmostChangedNode = NULL;
}

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

>   void SpreadRedraws::AddInvalidRegion(DocRect Rect, Node* pInvalidNode)

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/12/94
    Inputs:     Rect - the region to add (in document co-ordinates)
    Purpose:    Add another invalid region to the collection of regions for a spread.
    SeeAlso:    SpreadRedraws; PendingRedraws

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

void SpreadRedraws::AddInvalidRegion(DocRect Rect, Node* pInvalidNode)
{
    if (pInvalidNode!=NULL)
        if (m_pBackmostChangedNode==NULL || pInvalidNode->IsUnder(m_pBackmostChangedNode)) m_pBackmostChangedNode = pInvalidNode;

    if (TooManyRegions)
    {
        // We have exceeded the maximum number of inidividual regions, so we just
        // union them all together.
        InvalidRegions[0] = InvalidRegions[0].Union(Rect);
    }
    else
    {
        // Have we just exceeded the maximum number of regions?
        if (RectCount == MAX_REDRAW_REGIONS)
        {
            // Yes - gather all the existing regions together into one.
            for (INT32 i = 1; i < MAX_REDRAW_REGIONS; i++)
            {
                InvalidRegions[0] = InvalidRegions[0].Union(InvalidRegions[i]);
            }

            // Now merge the new region in
            InvalidRegions[0] = InvalidRegions[0].Union(Rect);

            // Indicate that we have too many regions
            RectCount = 1;
            TooManyRegions = TRUE;
        }
        else
        {
            // Otherwise, just add region to the array
            InvalidRegions[RectCount] = Rect;
            RectCount++;
        }
    }
}

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

>   void SpreadRedraws::ClearBackMostChangedNode(Node* pNode)

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/12/94
    Inputs:     Rect - the region to add (in document co-ordinates)
    Purpose:    Add another invalid region to the collection of regions for a spread.
    SeeAlso:    SpreadRedraws; PendingRedraws

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

void SpreadRedraws::ClearBackmostChangedNode(Node* pNode)
{
    if (pNode && (m_pBackmostChangedNode==pNode || pNode->IsNodeInSubtree(m_pBackmostChangedNode)))
        m_pBackmostChangedNode = pNode->FindParentSpread();
}

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

>   void SpreadRedraws::FlushRedraw(DocView *pDocView)

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/12/94
    Inputs:     pDocView - the DocView to invalidate
    Purpose:    Force the specified DocView to immediately update all the regions 
                encapsulated by this object.
    SeeAlso:    SpreadRedraws; PendingRedraws

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

void SpreadRedraws::FlushRedraw(DocView *pDocView)
{
    // Cause an immediate update of the DocView
    for (UINT32 i = 0; i < RectCount; i++)
    {
        // For the moment, assume that pending redraws must have been due to editing...
        pDocView->ForceRedraw(pInvalidSpread, InvalidRegions[i], FALSE, m_pBackmostChangedNode);
    }
}


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

>   PendingRedraws::PendingRedraws()

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/12/94
    Purpose:    Initialise a PendingRedraws object.
    SeeAlso:    SpreadRedraws; PendingRedraws

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

PendingRedraws::PendingRedraws()
{
}


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

>   PendingRedraws::~PendingRedraws()

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/12/94
    Purpose:    Destroys a PendingRedraws object.
    SeeAlso:    SpreadRedraws; PendingRedraws

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

PendingRedraws::~PendingRedraws()
{
    DeleteAll();
}


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

>   BOOL PendingRedraws::AddInvalidRegion(Spread *pSpread, DocRect Rect, Node* pInvalidNode)

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/12/94
    Inputs:     pSpread - the spread on which the invalid region is located.
                Rect - the invalid region (in document co-ordinates)
    Returns:    TRUE if added ok;
                FALSE if not 
    Purpose:    Add another invalid region to the specified Spread's collection.
    Errors:     Out of memory => ERROR1
    SeeAlso:    SpreadRedraws; PendingRedraws

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

BOOL PendingRedraws::AddInvalidRegion(Spread *pSpread, DocRect Rect, Node* pInvalidNode)
{
    // Look for this spread in our list
    SpreadRedraws *pItem = (SpreadRedraws *) GetHead();

    while ((pItem != NULL) && (pItem->GetSpread() != pSpread))
    {
        // Nope - try next item
        pItem = (SpreadRedraws *) GetNext(pItem);
    }

    if (pItem == NULL)
    {
        // No entry for the spread - we'd better make one
        pItem = new SpreadRedraws(pSpread);

        // Did it work?
        if (pItem == NULL)
            return FALSE;

        // Yes - add to the list
        AddTail(pItem);
    }

    // Got an an entry for this spread - add the region
    pItem->AddInvalidRegion(Rect, pInvalidNode);

    // All ok
    return TRUE;
}

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

>   void PendingRedraws::FlushRedraw(DocView *pDocView)

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/12/94
    Inputs:     pDocView - the DocView to invalidate.
    Purpose:    Cause all pending update regions on all spreads for this DocView to be 
                updated immediately.
    SeeAlso:    SpreadRedraws; PendingRedraws

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

void PendingRedraws::FlushRedraw(DocView *pDocView)
{
    // Invalidate the regions on each spread...
    SpreadRedraws *pItem = (SpreadRedraws *) GetHead();

    while (pItem != NULL)
    {
        // Invalid the regions on this spread, and delete this item
        pItem->FlushRedraw(pDocView);
        delete RemoveItem(pItem);

        // Now try the next item...
        pItem = (SpreadRedraws *) GetHead();
    }
}


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

>   void PendingRedraws::HanldeNodeDeletion(Node* pNode)

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/12/94
    Inputs:     pDocView - the DocView to invalidate.
    Purpose:    Cause all pending update regions on all spreads for this DocView to be 
                updated immediately.
    SeeAlso:    SpreadRedraws; PendingRedraws

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

void PendingRedraws::HandleNodeDeletion(Node* pNode)
{
    // Invalidate the regions on each spread...
    SpreadRedraws *pItem = (SpreadRedraws *) GetHead();

    while (pItem != NULL)
    {
        pItem->ClearBackmostChangedNode(pNode);

        // Now try the next item...
        pItem = (SpreadRedraws *) this->GetNext(pItem);
    }
}


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

>   static BOOL DocView::DeclarePreferences()

    Author:     Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com>
    Created:    19/10/94
    Returns:    TRUE if it worked, FALSE if it failed
    Purpose:    Declares any preferences that the DocView class needs to decalre

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

BOOL DocView::DeclarePreferences()
{
    // NB. Constrain angle must be between 1 and 359 degrees.
    return GetApplication()->DeclareSection(TEXT("Constraints"), 1)
        && GetApplication()->DeclarePref(TEXT("Constraints"), TEXT("Constrain Angle"),
                                         &DefaultConstrainAngle,
                                         (2 * PI) / 360, ((2 * PI) * 359) / 360)

        && GetApplication()->DeclareSection(TEXT("Rendering"), 2)
        && GetApplication()->DeclarePref(TEXT("Rendering"), TEXT("BackgroundRendering"),
                                         &BackgroundRendering, FALSE, TRUE)

        && GetApplication()->DeclareSection(TEXT("AutoScrolling"), 1)
        && GetApplication()->DeclarePref(TEXT("AutoScrolling"), TEXT("ScrollToShowMargin"),
                                         &ScrollToShowMargin)

        && GetApplication()->DeclareSection(TEXT("Dragging"), 6)
        && GetApplication()->DeclarePref(TEXT("Dragging"), TEXT("SolidDragging"),
                                         &SolidDragging, FALSE, TRUE)
        && GetApplication()->DeclarePref(TEXT("Dragging"), TEXT("IdleDragDelay"),
                                         (UINT32*)&IdleDragDelay, 0, 10000)
        && GetApplication()->DeclarePref(TEXT("Dragging"), TEXT("IdleDragDelay2"),
                                         (UINT32*)&IdleDragDelay2, 0, 10000)
        && GetApplication()->DeclarePref(TEXT("Dragging"), TEXT("SolidDragTimeLimit"),
                                         (UINT32*)&SolidDragTimeLimit, 0, 10000)
        && GetApplication()->DeclarePref(TEXT("Dragging"), TEXT("OriginOutlineShowAlways"),
                                         &OriginOutlineShowAlways, FALSE, TRUE)
        && GetApplication()->DeclarePref(TEXT("Dragging"), TEXT("OriginOutlineShowNonOverlap"),
                                         &OriginOutlineShowNonOverlap, FALSE, TRUE)
        && GetApplication()->DeclarePref(TEXT("Dragging"), TEXT("OutlineShowBounds"),
                                         &OutlineShowBounds, FALSE, TRUE);
}

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

>   DocView::DocView() 

    Author:     Phil_Martin (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/5/93
    Inputs:     Pointer to Document to which it belongs
    Outputs:    None
    Returns:    None
    Purpose:    DocView class constructor
                A DocView object is usually created by the Document and is linked into a list 
                of DocViews owned by the Document. So the DocView constructor takes and stores 
                a pointer to the Document object so that it can get to it quickly.
    Errors:     None

    
********************************************************************************************/
/*
    Technical notes:
    In debugging mode, constructor will assert that the Owner document pointer is not null.

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

DocView::DocView(Document* pOwnerDoc) :
    m_PushCursor( (Tool_v1*)NULL, _R(IDC_PUSHTOOLCURSOR) )
{
    // Set the flag that indicates if the view is dying or not. Make sure it is not dying
    IsViewDying = FALSE;

    // Implementation...
    ERROR3IF( pOwnerDoc == NULL, "DocView has no Owner Document !!" );

    pDoc = pOwnerDoc;                           // Maintain link to Document which owns us
    pViewWindow = NULL;                         // Clear pointer to window
    pVState = NULL;
    PushToolCursorID = 0;   // Matt 12/01/2001 - Ensure it is set to a sensible value at creation
    pCurrentDragOp = NULL;                      // we aren't dragging just yet
    Scale = 1.0;                                // Viewing scale = 1.00

    ViewFlags.BackgroundRender  = BackgroundRendering;      // Use preference

    ViewFlags.GridShow          = FALSE;        // Grid not shown
    ViewFlags.GridSnap          = FALSE;        // Grid not snapping
    ViewFlags.ObjectsSnap       = FALSE;        // All objects not snapping
    ViewFlags.MagObjectsSnap    = FALSE;        // Magnetic objects not snapping
    ViewFlags.PrintBorderShow   = FALSE;        // Print borders not shown
    ViewFlags.LogicalView       = TRUE;         // Chapters are shown one above the other
    ViewFlags.WorkClickCached   = FALSE;        // Haven't got a click cached
    ViewFlags.Dragging          = FALSE;        // We're not dragging anything
    ViewFlags.GuidesSnap        = TRUE;         // Not snapping to guides
    ViewFlags.GuidesShow        = TRUE;         // Show guides by default

        // Get the default quality level
    RenderQuality = Quality::DefaultQuality;

    // Initialise the snap object to NULL.  This is set up in the Snap functions
    pCSnap = NULL;

    // init pointer to rulers
    pRulerPair = NULL;

    // make sure we don't prevent ourselves from rendering
    m_bPreventRenderView = FALSE;

    // Setup solid dragging flags
    m_bSolidDragSupported = FALSE;
    m_bSolidDrag = FALSE;

    // Make ourselves current.
    SetCurrent();

    // Broadcast a message to all that there's a new view on the block . . .
    BROADCAST_TO_ALL(DocViewMsg(this, DocViewMsg::BORN));

}



/********************************************************************************************
>   virtual DocView::~DocView() 

    Author:     Phil_Martin (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/5/93
    Inputs:     None
    Outputs:    None
    Returns:    None
    Purpose:    DocView class destructor
    Errors:     None
********************************************************************************************/

DocView::~DocView()
{
    // delete the rulers (must be done first to prevent them receiving doc view dying messages)
    if(pRulerPair)
    {
        delete pRulerPair;
    }
    pRulerPair=NULL;

    // Set the flag that indicates if the view is dying.
    IsViewDying = TRUE;

    // Make sure that Current and Selected do not refer to the dying DocView
    if (this == Current)    SetNoCurrent();
    if (this == Selected)   Document::SetNoSelectedViewAndSpread();

    Camelot.DeleteRenderRegions(this);

    // Inform parent doc that we are about to die
    pDoc->OnDocViewDying(this);

    // Bye bye to the ViewState object (DON'T deallocate - done by CCamView).
    pVState = NULL;

    // If we have an attached CSnap object, junk it
    if (pCSnap != NULL) delete pCSnap;

    // Broadcast to everyone that this view is a dead duck.
    BROADCAST_TO_ALL(DocViewMsg(this, DocViewMsg::KILLED));
}


/********************************************************************************************
>   BOOL DocView::Init()

    Author:     Ed_Cornes (Xara Group Ltd) <camelotdev@xara.com>
    Created:    1/9/95
    Returns:    FALSE if fails
    Purpose:    Init a doc view
********************************************************************************************/

BOOL DocView::Init()
{
    pRulerPair = NULL;

    pRulerPair = new RulerPair();
    ERROR2IF(pRulerPair==NULL,FALSE,"DocView::Init() - failed to create RulerPair");

    // update indicator in StatusLine
    DialogBarOp::SetSystemStateChanged();

    return TRUE;
}

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

>   DocView::ScrollToShowMargin

    Author:     Andy_Hayward (Xara Group Ltd) <camelotdev@xara.com>
    Created:    3/6/1996
    Purpose:    Margins to use (in millipoints) when autoscrolling with a margin

    See Also:   ScrollToShowWithMargin

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

UINT32 DocView::ScrollToShowMargin = 18000; // defaults to 1/4 inch

/********************************************************************************************
>   BOOL DocView::SetScrollOffsets(WorkCoord NewTopLeft, BOOL RedrawNeeded = TRUE)

    Author:     Phil_Martin (Xara Group Ltd) <camelotdev@xara.com>
    Created:    6/7/93
    Inputs:     New scroll offsets
                Flag to control whether redraw is needed or not
    Purpose:    To scroll this view to a new position over the document. The coordinate
                supplied is the coordinate of the top left corner of the viewport onto the
                document. The RedrawNeeded flag is TRUE when any invalid areas created should
                be redrawn immediately and FALSE if they should be ignored.
********************************************************************************************/

BOOL DocView::SetScrollOffsets(WorkCoord NewTopLeft, BOOL RedrawNeeded)
{
    if (!View::SetScrollOffsets(NewTopLeft, RedrawNeeded))
        // Something went wrong - report failure to caller.
        return FALSE;

    WorkCoord RoundedTopLeft = GetScrollOffsets();

    // Tell Oil they've changed
    pViewWindow->SetScrollOffset(RoundedTopLeft, RedrawNeeded);

    return TRUE;
}



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

>   void DocView::ScrollToShow(DocCoord* pCoord)

    Author:     Andy_Hayward (Xara Group Ltd) <camelotdev@xara.com>
    Created:    6/3/1996
    Inputs:     pCoord      - coord to show in spread coords
    Outputs:    -
    Returns:    -
    Purpose:    Scrolls the currently selected document view to bring this coord into view.
                If this coord is already visible then we do nothing.

                If an ordinate of pCoord is zero then it is ignored and the view willnot
                be scrolled in that direction.

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

void DocView::ScrollToShow(DocCoord* pCoord)
{
    ERROR3IF(pCoord == NULL,"pCoord is NULL");
    if (pCoord == NULL) return;

    // call ScrollToShowAux, which does the actual work
    ScrollToShowAux(pCoord, DocCoord(0,0));
}



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

>   void DocView::ScrollToShow(DocRect *RectToShow)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/3/96
    Inputs:     RectToShow - Rectangle to show, in spread coords

    Purpose:    Scrolls the currently selected view to ensure that as much as possible of
                RectToShow is visible. If the entire rect cannot be seen, then it will scroll
                the minimum distance in order to make a part of it visible.

                i.e. Unlike the other ScrollToShow functions, this actually scrolls to show
                the given rectangle, as opposed to single points.

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

void DocView::ScrollToShow(DocRect *RectToShow)
{
    ERROR3IF(RectToShow == NULL, "Illegal NULL params");
    
    Spread* pSpread = GetFirstSelectedSpread();

    if (pSpread == NULL)
        return;

    // The TRUE argument for GetPasteBoardRect means that the result gets
    // pixelised. Otherwise the clipping code below doesn't work properly
    DocRect ViewRect = (GetDocViewRect(pSpread)).ToSpread(pSpread, this);

    // If the rect is entirely visible, or as much as possible of it is visible, then don't scroll!
    if (ViewRect.ContainsRect(*RectToShow) || RectToShow->ContainsRect(ViewRect))
        return;

    // Find the distance of the rectangle from each edge of the view rect, and work out
    // the distance we should scroll the view by
    DocCoord Offset(0,0);

    // If we need to scroll in x axis, work out by how much
    // "Need to scroll" means: The target rect lies outside the view rect on *only* one side
    if (
        (RectToShow->lo.x < ViewRect.lo.x || RectToShow->hi.x > ViewRect.hi.x) &&   // Outside
        !(RectToShow->lo.x < ViewRect.lo.x && RectToShow->hi.x > ViewRect.hi.x)     // On one side only
        )
    {
        // Find the distance needed to scroll the left edge of target to the left edge of the view
        // and the right edge to the right edge.
        INT32 Diff1 = RectToShow->lo.x - ViewRect.lo.x;
        INT32 Diff2 = RectToShow->hi.x - ViewRect.hi.x;

        // We need to scroll by the smaller of these 2 distances
        INT32 AbsDiff1 = ABS(Diff1);
        INT32 AbsDiff2 = ABS(Diff2);

        Offset.x = (AbsDiff1 < AbsDiff2) ? Diff1 : Diff2;
    }

    // Repeat the above for the Y axis
    if (
        (RectToShow->lo.y < ViewRect.lo.y || RectToShow->hi.y > ViewRect.hi.y) &&   // Outside
        !(RectToShow->lo.y < ViewRect.lo.y && RectToShow->hi.y > ViewRect.hi.y)     // On one side only
        )
    {
        // Find the distance to scroll to the left and right edges
        INT32 Diff1 = RectToShow->lo.y - ViewRect.lo.y;
        INT32 Diff2 = RectToShow->hi.y - ViewRect.hi.y;

        // We need to scroll by the smaller of these 2 distances
        INT32 AbsDiff1 = ABS(Diff1);
        INT32 AbsDiff2 = ABS(Diff2);

        Offset.y = (AbsDiff1 < AbsDiff2) ? Diff1 : Diff2;
    }

    // Ensure we don't scroll off the pasteboard area. This should really be done by
    // SetScrollOffsets, but it appears that function is complete pants, and I've already
    // had to change over 60 files because of poorly designed fundamental code, so
    // I really don't have time to fix yet more problems.
    DocRect PasteRect = (pSpread->GetPasteboardRect(TRUE)).ToSpread(pSpread, this);
    if (Offset.x < 0)
    {
        if (ViewRect.lo.x + Offset.x < PasteRect.lo.x)
            Offset.x = ViewRect.lo.x - PasteRect.lo.x;
    }
    else
    {
        if (ViewRect.hi.x + Offset.x > PasteRect.hi.x)
            Offset.x = PasteRect.hi.x - ViewRect.hi.x;
    }

    if (Offset.y < 0)
    {
        if (ViewRect.lo.y + Offset.y < PasteRect.lo.y)
            Offset.y = ViewRect.lo.y - PasteRect.lo.y;
    }
    else
    {
        if (ViewRect.hi.y + Offset.y > PasteRect.hi.y)
            Offset.y = PasteRect.hi.y - ViewRect.hi.y;
    }

    // determine if we need to scroll or not,
    if (Offset != DocCoord(0,0))
    {
        WorkCoord ScrollOffset;
        WorkCoord WorkOffset;

        WorkOffset.x = (XLONG) (MakeXLong(Offset.x) * GetViewScale());
        WorkOffset.y = (XLONG) (MakeXLong(Offset.y) * GetViewScale());

        ScrollOffset = GetScrollOffsets();
        ScrollOffset.x = ScrollOffset.x + WorkOffset.x;
        ScrollOffset.y = ScrollOffset.y + WorkOffset.y;

        if (ScrollOffset.x < (XLONG) 0) ScrollOffset.x = (XLONG) 0;
        if (ScrollOffset.y > (XLONG) 0) ScrollOffset.y = (XLONG) 0;

        SetScrollOffsets(ScrollOffset, TRUE);
    }
}



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

>   DocView::ScrollToShow(DocRect* pBoundingBox, DocCoord Direction)

    Author:     Andy_Hayward (Xara Group Ltd) <camelotdev@xara.com>
    Created:    6/3/1996
    Inputs:     pBoundingBox        - DocRect to show in spread coords
                Direction           - Direction of movement
    Outputs:    -
    Returns:    -
    Purpose:    Scrolls the currently selected view to ensure that edge(s) of pBoundingBox
                are visible. The Direction argument tells us which edges. If the movement
                was towards the top of the screen then we need to make the top edge of the
                DocRect visible.

                If an ordinate of Direction is zero then we ignore it and no scrolling is done
                in that direction.

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

void DocView::ScrollToShow(DocRect* pBoundingBox, DocCoord Direction)
{
    ERROR3IF(pBoundingBox == NULL,"pBoundingBox is NULL");
    if (pBoundingBox == NULL) return;

    DocCoord Point;

    if (Direction.x > 0)
        Point.x = pBoundingBox->hi.x;
    else if (Direction.x < 0)
        Point.x = pBoundingBox->lo.x;
    else
        Point.x = 0;

    if (Direction.y > 0)
        Point.y = pBoundingBox->hi.y;
    else if (Direction.y < 0)
        Point.y = pBoundingBox->lo.y;
    else
        Point.y = 0;

    // call ScrollToShowAux which does the actual work
    ScrollToShowAux(&Point, DocCoord(0,0));
}



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

>   void DocView::ScrollToShowWithMargin(DocCoord* pCoord)

    Author:     Andy_Hayward (Xara Group Ltd) <camelotdev@xara.com>
    Created:    6/3/1996
    Inputs:     pCoord - coord to show in spread coords
    Outputs:    -
    Returns:    -
    Purpose:    Scrolls the currently selected view to show the coord; if the coord in already
                in view then we do nothing.

                If an ordinate of pCoord is zero then we ignore it and do not scroll in that
                direction.

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

void DocView::ScrollToShowWithMargin(DocCoord* pCoord)
{
    ERROR3IF(pCoord == NULL,"pCoord is NULL");
    if (pCoord == NULL) return;

    DocCoord Margin;

    double Scale = GetViewScale().MakeDouble();

    Margin.x = (INT32) (ScrollToShowMargin/Scale);
    Margin.y = (INT32) (ScrollToShowMargin/Scale);

    // call ScrollToShowAux, which does all the actual work
    ScrollToShowAux(pCoord, Margin);
}



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

>   void DocView::ScrollToShowWithMargin(DocRect *RectToShow)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/3/96
    Inputs:     RectToShow - Rectangle to show, in spread coords

    Purpose:    Scrolls the currently selected view to ensure that as much as possible of
                RectToShow is visible. If the entire rect cannot be seen, then it will scroll
                the minimum distance in order to make a part of it visible.

                i.e. Unlike the other ScrollToShow functions, this actually scrolls to show
                the given rectangle, as opposed to single points.

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

void DocView::ScrollToShowWithMargin(DocRect *RectToShow)
{
    ERROR3IF(RectToShow == NULL, "Illegal NULL params");

    DocRect Temp(*RectToShow);

    double Scale = GetViewScale().MakeDouble();

    INT32 Margin = (INT32) (ScrollToShowMargin / Scale);

    Temp.Inflate(Margin, Margin);

    ScrollToShow(&Temp);
}



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

>   void DocView::ScrollToShowWithMargin(DocRect* pBoundingBox, DocCoord Direction)

    Author:     Andy_Hayward (Xara Group Ltd) <camelotdev@xara.com>
    Created:    6/3/1996
    Inputs:     pBoundingBox    - DocRect to show, in spread coords
                Direction       - direction of movement
    Outputs:    -
    Returns:    -
    Purpose:    Scrolls the current view to show parts of pBoundingBox. The edge(s) of
                pBoundingBox are determined by Direction, if we have moved objects towards
                the top of the screen then we need to ensure that the top edge of the DocRect
                is visible.

                If an ordinate of Direction is zero then we ignore it and do not scroll in
                that direction.

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

void DocView::ScrollToShowWithMargin(DocRect* pBoundingBox, DocCoord Direction)
{
    ERROR3IF(pBoundingBox == NULL,"pBoundingBox is NULL");
    if (pBoundingBox == NULL) return;

    DocCoord Point;
    DocCoord Margin;

    if (Direction.x > 0)
        Point.x = pBoundingBox->hi.x;
    else if (Direction.x < 0)
        Point.x = pBoundingBox->lo.x;
    else
        Point.x = 0;

    if (Direction.y > 0)
        Point.y = pBoundingBox->hi.y;
    else if (Direction.y < 0)
        Point.y = pBounding