document.cpp

Go to the documentation of this file.

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

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

This file is part of Xara LX.

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


MARKS
-----

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


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

=================================XARAHEADEREND============================
 */

#include "camtypes.h"

#include <fstream>
//#include <strstream> // this seems to be deprecated
#include <ctype.h>
#include <string>   
#include <stdlib.h>     // for rand() fn

#include "camdoc.h"
//#include "document.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "docmsgs.h" - in camtypes.h [AUTOMATICALLY REMOVED]

#include "dumbnode.h"
#include "noderect.h"
//#include "ensure.h"  - in camtypes.h [AUTOMATICALLY REMOVED]
#include "lineattr.h"        
#include "colcontx.h"
//#include "doccolor.h"
//#include "colourix.h"
//#include "docview.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "readeps.h"
//#include "app.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "errors.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "docview.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "csrstack.h"
#include "grid.h"
#include "nodedoc.h"
#include "chapter.h"
#include "page.h"
//#include "spread.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "wrkrect.h"
//#include "fixmem.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "msg.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "sprdmsg.h"
#include "layer.h"
#include "insertnd.h"
//#include "attrmgr.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "camview.h"
//#include "native.h"           // The new designed native filter, used for v2
#include "nativeps.h"       // The old style EPS native filter, used in v1.1
#include "saveeps.h"
#include "zoomops.h"
#include "qualops.h"
#include "ai_eps.h"
#include "ai_epsrr.h"
#include "fontlist.h"
#include "fontman.h"
#include "progress.h"
#include "bmpcomp.h"
#include "ralphdoc.h"
#include "camelot.h"        // For SafeRender Critical section stuff
//#include "clipint.h"
#include "nodedoc.h"
#include "ngsentry.h"
#include "opnudge.h"
#include "ophist.h"
#include "cutop.h"

//#include "ralphvw.h"
#include "vstate.h"

DECLARE_SOURCE("$Revision: 1668 $");

CC_IMPLEMENT_DYNAMIC(Document, BaseDocument)
CC_IMPLEMENT_DYNAMIC(DocChangingMsg, Msg)
CC_IMPLEMENT_DYNAMIC(SpreadMsg, Msg)
CC_IMPLEMENT_DYNAMIC(TranspModeMsg, Msg)
CC_IMPLEMENT_DYNAMIC(SafeRenderPointer, CCObject)

// Declare smart memory handling in Debug builds
#define new CAM_DEBUG_NEW

const MILLIPOINT PageWidth  = ( 8 * 72000);
const MILLIPOINT PageHeight = (11 * 72000);

// Default page size/position.
const MILLIPOINT Gap = 72000L;
const MILLIPOINT PasteBoardWidth  = PageWidth + (Gap * 2);
const MILLIPOINT PasteBoardHeight = PageHeight + (Gap * 2);
const MILLIPOINT DefBleedSize = 72000L/4;


Document* Document::Current  = NULL;
Document* Document::Selected = NULL;

Spread*   Document::pGlobalSelSpread = NULL;

BOOL Document::fRestoreViewOnImport = TRUE;


static String_256 ClipboardNameText(TEXT("Clipboard"));

// the default nudge size for our documents ....
// NOTE:  if you change this, you should also update the hard-coded value within:
// GeneralRecordHandler::HandleTagNudeSizeRecord ().  I could move this to the .h; but I can't
// be bothered ....
const UINT32 DEFAULT_NUDGE_SIZE = 2835;



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

>   Document::Document(BOOL IsAHiddenDoc = FALSE)

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    19/5/93
    Inputs:     IsAHiddenDoc - FALSE for a normal document (see below)
                                TRUE for a hidden document (including clipboards, etc)

    Purpose:    Constructor. Initialises the link to the OIL document.

    Notes:      You MUST call Document::Init after Creation of the document, to fill in
                the defaults and build the document tree root.

                HIDDEN DOCUMENTS
                A hidden document is one which is not shown to the user in any UI.
                Hidden docs are used mainly for clipboard (and OLE) data transfer operations.

                Note that if you pass in (pCCamDoc = NULL) then the document is forced to be hidden.
                SeeAlso IsAHiddenDoc() and IsNotAHiddenDoc() in document.h

                The InternalClipboard is now based upon Document. It creates a Hidden Document.
                Generally nobody should care about this, but some bits of code might have to be
                careful of the differences. Use IsAClipboard() to check if the doc is really a
                clipboard. Note also that Clipboard documents do not broadcast DocChangingMsgs.

    Errors:     None.
    SeeAlso:    Document::Init; InternalClipboard; BaseDocument

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

Document::Document(BOOL bIsAHiddenDoc)
  : BaseDocument(bIsAHiddenDoc),
    OilDoc(0)
{
    // NB. Make sure all the Document stuff is set up before calling routines which
    // might interrogate the Document object.
    
    // Set the default state of the flags.
    DocFlags.LayerMultilayer = FALSE;
    DocFlags.LayerAllVisible = FALSE;
    DocFlags.SaveWithUndo = TRUE;

    // Set the times
    CreationTime = ::time(NULL);
    LastSaveTime = 0;

    // Set up default bleed offset
    BleedOffset = DefBleedSize;

    // Set up our array of default colour contexts by copying the 'global' array
    ColourContext::GetGlobalDefaults( &DefaultColourContexts );

    // Add this document to the list of all documents in Camelot
#ifdef RALPH
    Camelot.Documents.AddHead(this);
#else
    if (IsNotAHiddenDoc())
    {
        Camelot.Documents.AddHead(this);
    }
#endif

    // Set this document to be the current one
    this->SetCurrent();

    NodesInTree = 0;       
                                 
    // Initialise pointers to sensible values (they are set up in the Init() function)
    OpHistory           = 0;
    AttributeMgr        = 0;
    m_pSetSentinel      = 0;
    pDocUnitList        = 0;
    pSelSpread          = 0;

    IsARalph = FALSE;
    pRalphDocument =NULL;
    Viewmode = DOCUMENT_VIEW;

    // Always keep this flag TRUE except when Loading New Files in
    DocIsImporting = TRUE;

    // Always keep this False unless loading a template document
    DocTemplateLoading = FALSE;

    // Make sure that the loaded as old version file is set to a known state
    LoadedAsVersion1File = FALSE;

    m_docNudge = DEFAULT_NUDGE_SIZE;
    SetBitmapSmoothing(TRUE);
    m_DuplicationOffset = DocCoord(OpDuplicate::DuplicatePlacementX, OpDuplicate::DuplicatePlacementY);

    // Document is not yet "born and stable".
    m_fStable = FALSE;
}



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

>   BOOL Document::Init(CCamDoc* pOilDoc)

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    20/7/93
    Inputs:     pOilDoc     ---     the CCamDoc to attach this Document too
    Returns:    TRUE if the document initialised ok, FALSE otherwise.
    Purpose:    Sets up the document tree.  At the moment it fills it with test data
                (paths etc) but in future only the initial tree nodes will be set up.
                When the document has been completely initialised, it becomes the
                selected and current document: DocChangingMsg message broadcasts will
                occur (in the order BORN, CURRENT, SELECTED).

    Notes:      This now also sets up the default list of indexed (named) colours which
                the user can base their document upon [in the BaseDocument Init method].
                These should be set up from a default document (or whatever) in future.

    Errors:     Out of memory.
    SeeAlso:    ReadEPSData; Document::Document;
                Document::SetSelectedViewAndSpread; Document::SetCurrent

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

BOOL Document::Init(CCamDoc* pOilDoc)
{
// Ralph has a NULL oildoc...
#ifndef RALPH
    ERROR2IF(OilDoc, FALSE, "Document already attached to a CCamDoc in Document::Init");
#endif
    OilDoc = pOilDoc;

    NodeDocument* Doc;
    EndDocument* End;

    // Make this the current document - NOTE! no broadcast as of 22/7/94
    SetCurrent();
    
    // Set the busy cursor . . .
    BeginSlowJob(-1, FALSE);

    // First, call the base class Init method to set up for us.
    // This creates the StartDocument, NodeDocument, & EndDocument, and sets up
    // a default colour list and other doc components.
    if (!BaseDocument::Init()) return InitFailed();

    // Check that the document is OK
    ERROR3IF(GetFirstNode() == NULL,"StartDoc not found"); 
    Doc = (NodeDocument*)GetFirstNode()->FindNext(); 
    ERROR3IF(Doc == NULL, "NodeDocument not found"); 
    End = (EndDocument*)Doc->FindNext(); 
    ERROR3IF(End == NULL, "EndDocument not found"); 

    // Make the doc unit list
    pDocUnitList = new DocUnitList;
    if (pDocUnitList == NULL || !pDocUnitList->MakeDefaultUnits())
        return(InitFailed());

    // Create the Operation history for the document                              
    OpHistory = new OperationHistory;
    if (OpHistory == NULL)
        return(InitFailed());

    // Create the attribute manager for the document 
    AttributeMgr = new AttributeManager; 
    if (AttributeMgr == NULL || !AttributeMgr->InitInstance())
        return(InitFailed());

    // Build the basic tree structure (Chapter, spread, layer)
    if (!InitTree(Doc))
        return(InitFailed());

    if (IsNotAHiddenDoc())
    {
        // Broadcast a message to all that there's a new document on the block . . .
        BROADCAST_TO_ALL(DocChangingMsg(this, DocChangingMsg::BORN));
    }
    
    // Add the default attributes as Nodes at the start of the tree
    // The clipboard document does not need default attributes, as things copied into it
    // are always kept attribute complete. But now that we're importing into the clipboard,
    // it is a very good idea to have safe defaults lying about.
    InitDefaultAttributeNodes(); 

    // Take the hourglass off
    EndSlowJob();
    
    return(TRUE);
}



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

>   BOOL Document::InitTree(NodeDocument *RootNode)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/4/95

    Inputs:     RootNode - points at the basic NodeDocument from which the main documet
                tree hangs.

    Returns:    TRUE if it succeeds, FALSE if it failed (in which case you should
                call InitFailed() and possibly InformError())

    Purpose:    Called by Document::Init to initialise the document tree structure.
                
                Mainly intended for use by the internal clipboard in order to delete
                and recreate the standard tree whenever it is wiped - I've done this
                here dso that any chnages to the normal document layout will also affect
                the clipboard document in an appropriate manner.

    Errors:     Lack of memory might make 'new' fail

    SeeAlso:    Document::Init

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

BOOL Document::InitTree(NodeDocument* pRootNode)
{
    if (pRootNode == NULL || !pRootNode->IsNodeDocument())
    {
        ERROR3("This doc's NodeDocument is NULL or isn't really a NodeDocument");
        return(FALSE);
    }

    // Temporary bodge to construct example document tree for Target 1.     
    Chapter* pChapter = new Chapter(pRootNode, LASTCHILD);
    if (pChapter == 0) return FALSE;

    // Create the sentinel node for all object names within the chapter, and a
    // child NodeBarProperty.
    m_pSetSentinel = new NodeSetSentinel(pChapter, FIRSTCHILD);
    if (m_pSetSentinel == 0) return FALSE;
    NodeBarProperty* pbp = new NodeBarProperty(m_pSetSentinel, LASTCHILD);
    if (pbp == 0) return FALSE;

    // Create a rectangle for the pasteboard
    DocRect PasteRect(MinDocCoord + 0x10000,
                      MaxDocCoord - 0x10000 - 1 * PasteBoardHeight,
                      MinDocCoord + 0x10000 + 2 * PasteBoardWidth,
                      MaxDocCoord - 0x10000);

    // Create the spread
    Spread *pSpread = new Spread(pChapter, FIRSTCHILD, PasteRect);
    if (pSpread == NULL) return FALSE;
    
    // Create the default page and grid (JustinF says: even if we are a hidden document)
    if (!pSpread->CreateDefaultPageAndGrid(TRUE)) return FALSE;

    // Create the Insertion node which must always live as a last child of the selected
    // spreads active layer. The Insertion node holds a pointer to this document so that
    // if for whatever reason the InsertionNode is destroyed (eg. Delete layer) then 
    // we can Inform this document and it can NULLIFY the InsertPos pointer.
    InsertPos = new InsertionNode(this);
    if (InsertPos == NULL) return FALSE;
    InsertPos->AttachNode(pSpread, LASTCHILD);

    return TRUE;
}



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

>   BOOL Document::InitDefaultAttributeNodes()

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/06/94
    Inputs:     -
    Outputs:    -
    Returns:    TRUE if the default attributes have been added to the tree OK
                FALSE if we run out of memory.
                
    Purpose:    This function adds the document's default attributes as nodes at the start
                of the tree (i.e. as first children of the NodeDocument).

                The Attribute optimisation routines will not work if the document does
                not contain the default attributes.

    Note:       This function must be called after the initial document structure has
                been set up and all default attributes have been registered.


    Errors:     The Out Of Memory Error is set if we run out of memory, FALSE is returned 
                in this situation.
                 

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

BOOL Document::InitDefaultAttributeNodes()
{
    ENSURE(AttributeMgr != NULL, "Attribute Manager pointer is NULL"); 

    // Find out the number of default attributes
    UINT32 NumDefaultAttribs = AttributeMgr->GetNumAttributes();
    ENSURE(NumDefaultAttribs != 0, "The document has no default attributes"); 
    
    AttributeEntry* DefaultAttribs = AttributeMgr->GetDefaultAttributes();
    
    if (DefaultAttribs == NULL)
        return FALSE;
    
    // ----------------------------------------------------------------------------------------
    // Try and find the NodeDocument node - to which the attributes will be added

    Node* TreeRoot; 

    ENSURE(TreeStart != NULL, "The initial tree structure has not been initialised"); 

    TreeRoot = TreeStart->FindNext(); 

    ENSURE(TreeRoot != NULL, "Can't find NodeDocument"); 
    ENSURE(TreeRoot->GetRuntimeClass() == CC_RUNTIME_CLASS(NodeDocument), "Alien tree structure"); 

    // ----------------------------------------------------------------------------------------
    // Create a NodeAttribute for each of the default attributes and add them into the
    // tree as first children of the NodeDocument.

    for(UINT32 i=0; i<NumDefaultAttribs; i++)
    {
        ENSURE(DefaultAttribs[i].pAttr != NULL, "Default attribute is NULL"); 
        
        Node* NodeAttr = DefaultAttribs[i].pAttr->MakeNode();

        if (NodeAttr != NULL)
        {
            // Add the Attribute as a first child of the NodeDocument.  Note that we suppress
            // the transparency check for default attributes.
            NodeAttr->AttachNode(TreeRoot, FIRSTCHILD, FALSE);

            NodeAttribute* pNa = (NodeAttribute*)NodeAttr;
            if(pNa->IsLinkedToNodeGeometry())
            {
                pNa->NewlyCreatedDefaultAttr((NodeDocument*)TreeRoot);
            }
        } 
    }

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

    // Default attribute array no longer required so we can safely delete it 
    CCFree(DefaultAttribs);
    return TRUE;
}



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

>   BOOL Document::ReInit()

    Author:     Chris_Parks (Xara Group Ltd) <camelotdev@xara.com>
    Created:    16/4/96
    Returns:    Init ok
    Purpose:    Calls InitFailed to delete the Tree and various others and follows this with 
                an Init to put the Document back into a virgin state
                Not used just yet...
    Errors:     

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

BOOL Document::ReInit()
{
    // RALPH
    InitFailed();
    return Init(OilDoc);

/* 
    TreeStart->CascadeDelete();
    ERROR3IF(GetFirstNode() == NULL,"StartDoc not found"); 
    NodeDocument *Doc = (NodeDocument*)GetFirstNode()->FindNext(); 
    return InitTree(Doc);
*/

//  return TRUE;

}



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

>   BOOL Document::InitFailed(void)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    8/12/94
    Returns:    FALSE
    
    Purpose:    Called by Document::Init when it fails; encapsulates all necessary
                tidying up, and then returns FALSE so that it can be called as part
                of the final return statement.
                Replaces some completely unnecessary goto code.

    SeeAlso:    Document::Init

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

BOOL Document::InitFailed(void)
{
    if (TreeStart != 0)
    {
        TreeStart->CascadeDelete();
        delete TreeStart;
        m_pSetSentinel = 0;
    }

    if (OpHistory != 0)
    {
        delete OpHistory;
        OpHistory = 0;
    }
    
    if (AttributeMgr != 0)
    {
        delete AttributeMgr;
        AttributeMgr = 0;
    }

    if (pDocUnitList != 0)
    {
        delete pDocUnitList;
        pDocUnitList = 0;
    }
    
    EndSlowJob();
    return(FALSE);
}



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

>   Document::~Document()

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    19/5/93
    Purpose:    Destructor. Deletes the whole document tree of this object, and all memory
                is returned to the heaps whence it came.  The busy cursor is displayed while
                this is happening.
                                                                 
***********************************************************************************************/

Document::~Document()
{
    // Set the busy cursor . . .
    BeginSlowJob(-1, FALSE);

#ifndef RALPH
    // Broadcast to everyone that this document is a dead duck.
    if (IsNotAHiddenDoc())
#endif
    {
        // Document no longer stable.
        SetStable(FALSE);
        BROADCAST_TO_ALL(DocChangingMsg(this, DocChangingMsg::ABOUTTODIE));
    }


#ifdef _DEBUG
        // DocViews should be closed before Documents, so all render regions for this document
        // should have been deleted - make sure they have.
        Camelot.DeleteRenderRegions(this);
#endif

#ifndef RALPH
    // Remove Document from list of all documents
    if (IsNotAHiddenDoc())
#endif
    {
        Camelot.Documents.RemoveItem(this);

        // Is this the last document in the program?
        BOOL ThisIsTheLastDoc = (Camelot.Documents.GetHead() == NULL);

        if (ThisIsTheLastDoc)
        {
            // There are no more documents, so ensure that the system is in the correct state.

            // If the system is working correctly, then the following should be true:
            //   If Current  != NULL, Current  must be this document
            //   If Selected != NULL, Selected must be this document
            // We will ensure this is the case in debug builds

            ENSURE((Current  == NULL) || (Current  == this),"Current document is garbage");
            ENSURE((Selected == NULL) || (Selected == this),"Selected document is garbage");

            // Reset Current and Selected document and DocView
            SetNoCurrent();
            SetNoSelectedViewAndSpread();

            DocView::SetNoCurrent();
    //      DocView::SetNoSelected();   -- now done in SetNoSelectedViewAndSpread(), above

        }
        else
        {
            // Make sure that Current and Selected do not refer to the dying document
            if (this == Current)    SetNoCurrent();
            if (this == Selected)   SetNoSelectedViewAndSpread();
            
            // This special test added to fix a problem whereby current doc was being set to null
            // above and hence causing unit display problems (ERROR2s) in the selector tool when
            // opening a bitmap had been aborted. 18/9/96 Neville
            if (Selected != NULL && Current == NULL) Current = Selected; 
        }           
    }

    // Delete all DocViews attached to document
    DocViews.DeleteAll();

#ifndef RALPH
    // Broadcast to everyone that this document is a dead duck.
    if (IsNotAHiddenDoc())
    {
        BROADCAST_TO_ALL(DocChangingMsg(this, DocChangingMsg::KILLED));
    }
#endif  
    // Destroy the operation history. This must get destroyed before the tree is destroyed
    if (OpHistory != NULL)
        delete (OpHistory);   

    // Destroy the attribute manager 
    if (AttributeMgr != NULL)
        delete (AttributeMgr); 

    // Destroy the list of units in this document
    if (pDocUnitList != NULL)
        delete (pDocUnitList);

    // All done...
    EndSlowJob(); 

    // Note that the tree is deleted in the base class destructor
}



/********************************************************************************************
>   BOOL Document::IsModified() const

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/3/94
    Inputs:     -
    Outputs:    -
    Returns:    Returns TRUE if the document has been modified since last being saved.
    Purpose:    Tests the "Modified" flag.
    Errors:     -
    SeeAlso:    CCamDoc::IsModified
********************************************************************************************/

BOOL Document::IsModified() const
{
    if (OilDoc)
        return OilDoc->IsModified();

    return(FALSE);
}



/********************************************************************************************
>   BOOL Document::IsReadOnly() const

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/3/94
    Inputs:     -
    Outputs:    -
    Returns:    Returns TRUE if the document is read-only, ie. cannot be modified.
    Purpose:    Tests the "Read Only" flag.
    Errors:     -
    SeeAlso:    CCamDoc::IsReadOnly
********************************************************************************************/

BOOL Document::IsReadOnly() const
{
    if (OilDoc)
        return OilDoc->IsReadOnly();

    return(FALSE);
}



/********************************************************************************************
>   BOOL Document::IsACopy() const

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/3/94
    Inputs:     -
    Outputs:    -
    Returns:    Returns TRUE if the document is a copy of another document.
    Purpose:    Tests the "Copy" flag.
    Errors:     -
    SeeAlso:    CCamDoc::IsACopy
********************************************************************************************/

BOOL Document::IsACopy() const
{
    if (OilDoc)
        return OilDoc->IsACopy();

    return(FALSE);
}



/********************************************************************************************
>   void Document::SetModified(BOOL fState = TRUE)

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/3/94
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Sets (or clears) the "document is modified" flag.
    Errors:     -
    SeeAlso:    CCamDoc::SetModified
********************************************************************************************/

void Document::SetModified(BOOL fState /* = TRUE */)
{
    if (OilDoc)
        OilDoc->SetModified( fState != FALSE );
}

/********************************************************************************************
>   void Document::IsLoadedAsVersion1File() const

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    30/7/96
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Returns the current state of the IsLoadedAsVersion1File flag.
                Flag to say that the document was loaded as a version 1 file
                and so the user needs to be given the option of saving it in this form
                when the document is saved
********************************************************************************************/

BOOL Document::IsLoadedAsVersion1File() const
{
    return LoadedAsVersion1File;
}

/********************************************************************************************
>   BOOL Document::ISetLoadedAsVersion1File(BOOL NewState)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    30/7/96
    Inputs:     New state of the flag required
    Outputs:    -
    Returns:    Old state of the flag
    Purpose:    Sets a new current state of the IsLoadedAsVersion1File flag.
                Flag to say that the document was loaded as a version 1 file
                and so the user needs to be given the option of saving it in this form
                when the document is saved
********************************************************************************************/

BOOL Document::SetLoadedAsVersion1File(BOOL NewState)
{
    BOOL OldState = LoadedAsVersion1File;
    LoadedAsVersion1File =  NewState;
    return OldState;
}





/********************************************************************************************
>   BOOL Document::CreateDragTargets()

    Author:     Chris_Parks (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/1/95
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Calls all (OILY) views to create their drag targets.
    Errors:     -
    SeeAlso:    CCamDoc::SetModified
********************************************************************************************/

BOOL Document::CreateDragTargets(DragInformation * DragInfo)
{
    if (IsNotAClipboard())
    {
        DocView * Ptr= (DocView*) DocViews.GetHead();
        CCamView* TheView;

        while(Ptr)
        {
            TheView = Ptr->GetConnectionToOilView();
            if(TheView)
                    TheView->CreateDragTarget(DragInfo);
            Ptr= (DocView*) DocViews.GetNext(Ptr);
        }
    }
    return TRUE;
}



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

>   String_256 Document::GetTitle() const

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    15/3/94
    Returns:    A String_256 that holds the document title
    Purpose:    Returns the Title of the document. The title is the text that appears in the
                documents windows (when it is not maximised). For example 'Untitled #1' or
                'Untitled #1 (Modified)' or even 'Blobby.art (Modified)'.
    SeeAlso:    Document::GetProducer; Document::GetComment; CCamDoc::GetKernelTitle

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

String_256 Document::GetTitle() const
{
    if (OilDoc)
        return OilDoc->GetKernelTitle();

    return(ClipboardNameText);
}


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

>   String_256 Document::GetDocName(BOOL IncludeFileType = TRUE) const

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    27/3/95
    Inputs:     IncludeFileType - TRUE if the filetype is required. Defaults to TRUE.
    Returns:    A String_256 that holds the document name
    Purpose:    Returns the name of the document. The name will be the first part of the title
                which is the text that appears in the document windows (when it is not maximised). For example 'Untitled #1' or
                'Untitled #1 (Modified)' or even 'Blobby.art (Modified)'.
    SeeAlso:    Document::GetTitle(); CCamDoc::GetKernelTitle(); CCamDoc::GetKernelDocName();
    SeeAlso:    Document::GetProducer; Document::GetComment; 

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

String_256 Document::GetDocName(BOOL IncludeFileType) const
{
    if (OilDoc)
        return OilDoc->GetKernelDocName(IncludeFileType);

    return(ClipboardNameText);
}   


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

>   String_256 Document::GetPathName(UINT32 MaxSize = 0) const

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    20/3/95
    Inputs:     MaxSize - This is the size we have to fit the pathname into.
                Defaults to zero , meaning all off the pathname.
    Returns:    A String_256 that holds the pathname for the document.
    Purpose:    Returns the pathname of the document.
    SeeAlso:    CCamDoc::GetKernelPathName; PathName::GetTruncatedPathName;
    SeeAlso:    Document::GetLocation; CCamDoc::GetTruncatedLocation;

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

String_256 Document::GetPathName(UINT32 MaxSize) const
{
    if (OilDoc)
        return OilDoc->GetKernelPathName(MaxSize);

    return(ClipboardNameText);
}

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

>   String_256 Document::GetLocation(UINT32 MaxSize = 0) const

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    20/3/95
    Inputs:     MaxSize - This is the size we have to fit the pathname into.
                Defaults to zero , meaning all off the pathname.
    Returns:    A String_256 that holds the location for the document.
    Purpose:    Returns the location of the document, which is the pathname with no filename.
    SeeAlso:    CCamDoc::GetKernelLocation; PathName::GetTruncatedLocation;
    SeeAlso:    Document::GetPathName; CCamDoc::GetKernelPathName;

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

String_256 Document::GetLocation(UINT32 MaxSize) const
{
    if (OilDoc)
        return OilDoc->GetKernelLocation(MaxSize);

    return(ClipboardNameText);
}


/********************************************************************************************
>   const String_256& Document::GetProducer() const

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    15/3/94
    Inputs:     -
    Outputs:    -
    Returns:    A reference to the (constant) producer's name of this document.
    Purpose:    
    Errors:     -
    SeeAlso:    Document::GetTitle; Document::GetComment
********************************************************************************************/

const String_256& Document::GetProducer() const
{
    return Producer;
}



/********************************************************************************************
>   const String_256& Document::GetComment() const

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    15/3/94
    Inputs:     -
    Outputs:    -
    Returns:    A reference to the (constant) producer's name of this document.
    Purpose:    Getting the time the document was created.
    Errors:     -
    SeeAlso:    Document::GetTitle; Document::GetProducer
********************************************************************************************/

const String_256& Document::GetComment() const
{
    return Comment;
}



/********************************************************************************************
>   void Document::SetComment(String_256* NewComment)

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    31/8/94
    Inputs:     A pointer to the new comment string.
    Outputs:    -
    Returns:    -
    Purpose:    Setting the document's comment string.
    Errors:     -
    SeeAlso:    Document::GetComment
********************************************************************************************/

void Document::SetComment(String_256* NewComment)
{
    Comment = *NewComment;
}



/********************************************************************************************
>   const time_t& Document::GetCreationTime() const

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    31/08/94
    Inputs:     -
    Outputs:    -
    Returns:    A reference to the time of the document's creation.
    Purpose:    
    Errors:     -
    SeeAlso:    Document::GetLastSaveTime
********************************************************************************************/

const time_t& Document::GetCreationTime() const
{
    return CreationTime;
}



/********************************************************************************************
>   const time_t& Document::GetLastSaveTime() const

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    31/08/94
    Inputs:     -
    Outputs:    -
    Returns:    A reference to the time of the document's creation.  Will be 0 if the
                document is unsaved.
    Purpose:    Getting the time the document was last saved.
    Errors:     -
    SeeAlso:    Document::GetCreationTime
********************************************************************************************/
                
const time_t& Document::GetLastSaveTime() const
{
    return LastSaveTime;
}



/********************************************************************************************
>   void Document::SetLastSaveTime() const

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    1/09/94
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Call on saving a document.  Sets the document's last saved time.
    Errors:     -
    SeeAlso:    Document::GetLastSaveTime
********************************************************************************************/

void Document::SetLastSaveTime()
{
    LastSaveTime = ::time(NULL);
}

/********************************************************************************************
>   void Document::SetLastSaveTime(time_t)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    30/7/96
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Allows setting of the document's last saved time.
    Errors:     -
    SeeAlso:    Document::GetLastSaveTime
********************************************************************************************/

void Document::SetLastSaveTime(time_t NewTime)
{
    LastSaveTime = NewTime;
}

/********************************************************************************************
>   void Document::SetCreationTime(time_t)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    30/7/96
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Allows setting of the document's creation time.
    Errors:     -
    SeeAlso:    Document::GetLastSaveTime
********************************************************************************************/

void Document::SetCreationTime(time_t NewTime)
{
    CreationTime = NewTime;
}

/********************************************************************************************
>   void Document::MakeJustCreated()

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    11/5/95
    Inputs:     -
    Outputs:    Sets member variables
    Returns:    -
    Purpose:    Resets member variables of the document so it abbears as if the document has
                just been created (eg CreationTime is set to the current time)
    Errors:     -
    SeeAlso:    -
********************************************************************************************/
void Document::MakeJustCreated()
{
    LastSaveTime = 0;               // Zero means not saved
    CreationTime = ::time(NULL);
}



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

>   void Document::InsertNewNode( Node* NewNode, DocCoord* Point )

    Author:     Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com>
    Created:    3/9/93
    Inputs:     NewNode - A Pointer to the New node to be inserted
                pDestSpread - pointer to the spread  which this new node should be
                              inserted, If this is NULL then the object is inserted
                              on the selected spread.

    Purpose:    Inserts the Node into the Document at the position specified.
                The node is added to the active layer on this spread 
    SeeAlso:    Document::FindEnclosingChapter(); Document::FindEnclosingPage()

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

void Document::InsertNewNode( Node* NewNode, Spread *pDestSpread )
{
    SetCurrent();

    Node *pNode; 

    // Most of the time we will be inserting onto the selected spread
    // So find out what this is.
    
    if ((pDestSpread == NULL) || (pDestSpread == Document::GetSelectedSpread()))
    {
        // We need to insert the node onto the selected spread. This is very quick because we
        // keep an Insertion node there.
        pNode = GetInsertionPosition(); 
        ENSURE(pNode != NULL, "Could not find insertion position in Document::InsertNewNode()");
        // Attach the node to the left of the insertion node
        NewNode -> AttachNode( pNode, PREV );

    } 
    else
    {
        // This is assuming that we are inserting into the non-selected spread and so does
        // not use the insertion position. Unfortunately, there is a chance that this MAY happen
        // as the selected spread may be in a different document and so we are inserting into a
        // single spread document with an insertion node. The code below will insert AFTER the
        // insertion node and so will be in an illegal position. We really should check this!!!
        // As we are close to release I will put an error 3 in just in case. Neville 24/9/96
        TRACE( _T("\aDocument::InsertNewNode inserting into the unselected spread. Is this correct?\n") );

        pNode = pDestSpread->FindActiveLayer();
        ENSURE(pNode != NULL, "Could not find layer in Document::InsertNewNode()");
        // Attach this node to the tree at this point
        NewNode -> AttachNode( pNode, LASTCHILD );
    }
}



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

    DocView *Document::GetSpareDocView()

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    19/5/93
    
    Inputs:     - 
    Outputs:    -
    Returns:    NULL, or a spare DocView
                 
    Purpose:    Looks for a DocView with no attached OilView, so we can recycle it
               
    Errors:     None.
                                                                 
***********************************************************************************************/

DocView* Document::GetSpareDocView()
{
    if (IsNotAClipboard())
    {
        DocView *View = (DocView *) DocViews.GetHead();
    
        while (View != NULL)
        {
            CCamView *pCamView = View->GetConnectionToOilView();
            if (pCamView == NULL) return View;
            View = (DocView *) DocViews.GetNext(View);
        }
    }

    return NULL;        // No free views found
}



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

>   DocView* Document::GetNewDocView()

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    19/5/93
    
    Inputs:     -