prnmks.cpp

Go to the documentation of this file.

// $Id: prnmks.cpp 1320 2006-06-14 14:39:32Z 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============================
 */
//
// Author  : Mike
// Created : 23/07/96
// Purpose : The PrintMarks Manager and all its helper classes.
//           This manager handles the caching and rendering of print marks
//           within a document. PrintMarks are generally only used for typesetting

/*
*/

#include "camtypes.h"
//#include "node.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "app.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "prnmks.h"
//#include "group.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "fileutil.h"
//#include "document.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "docview.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "opdesc.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "nativeop.h"
#include "layer.h"
//#include "spread.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "page.h"
//#include "nodeattr.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "colormgr.h"
#include "prnmkcom.h"
#include "qualattr.h"
//#include "matrix.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "dbugtree.h"
//#include "paths.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "cctime.h"
#include "nodetxts.h"
#include "nodetxtl.h"
#include "colplate.h"
#include "printctl.h"
#include "fontman.h"
#include "psrndrgn.h"
#include "psdc.h"
//#include "printstr.h"
#include <stdlib.h>

CC_IMPLEMENT_MEMDUMP(LoadPrintMarks, LoadDirect);
CC_IMPLEMENT_MEMDUMP(PrintMarksMan, CC_CLASS_MEMDUMP);
CC_IMPLEMENT_MEMDUMP(PrintMarksCache, CC_CLASS_MEMDUMP);
CC_IMPLEMENT_MEMDUMP(PrintMark, CC_CLASS_MEMDUMP);
CC_IMPLEMENT_DYNCREATE(MarkPosition, ListItem);
CC_IMPLEMENT_DYNCREATE(PrintMarkItem, ListItem);
CC_IMPLEMENT_MEMDUMP(MarkFormatRegion, CC_CLASS_MEMDUMP);
CC_IMPLEMENT_DYNCREATE(PageRect, ListItem);
CC_IMPLEMENT_DYNAMIC(PageRectList, List);

DECLARE_SOURCE("$Revision: 1320 $");

#define new CAM_DEBUG_NEW


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

>   MarkFormat::MarkFormat()

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/07/96
    Purpose:    Construct a Mark format object

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

MarkFormat::MarkFormat()
{
    Top = Middle = Bottom = FALSE;
    Left = Centre = Right = FALSE;
}

BOOL MarkFormat::IsValid() const
{
    return (Top || Middle || Bottom || Left || Centre || Right);
}

void MarkFormat::MakeValid()
{
    Centre = Middle = TRUE;
    Top = Bottom = Left = Right = FALSE;
}

INT32 operator==(const MarkFormat& x, const MarkFormat& y)
{
    return ( (x.Centre == y.Centre) &&
             (x.Middle == y.Middle) &&
             (x.Left   == y.Left)   &&
             (x.Right  == y.Right)  &&
             (x.Top    == y.Top)    &&
             (x.Bottom == y.Bottom)
            );
}



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

>   BYTE MarkFormat::GetAsFlagByte(void)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    6/9/96

    Returns:    A Byte with bits set for each of the mark formats available

    Purpose:    Fill in a mark format object from a "flags byte"
                Used for native file load/save

    SeeAlso:    MarkFormat::SetFromFlagByte

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

BYTE MarkFormat::GetAsFlagByte(void)
{
    BYTE Flags = 0;

    if (Left)   Flags |= 0x01;
    if (Centre) Flags |= 0x02;
    if (Right)  Flags |= 0x04;
    if (Top)    Flags |= 0x08;
    if (Middle) Flags |= 0x10;
    if (Bottom) Flags |= 0x20;

    return(Flags);
}



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

>   void MarkFormat::SetFromFlagByte(BYTE Flags)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    6/9/96

    Inputs:     Flags - A Byte with bits set for each of the mark formats available

    Purpose:    Fill in a mark format object from a "flags byte"
                Used for native file load/save

    SeeAlso:    MarkFormat::GetAsFlagByte

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

void MarkFormat::SetFromFlagByte(BYTE Flags)
{
    Left    = (Flags & 0x01) ? TRUE : FALSE;
    Centre  = (Flags & 0x02) ? TRUE : FALSE;
    Right   = (Flags & 0x04) ? TRUE : FALSE;
    Top     = (Flags & 0x08) ? TRUE : FALSE;
    Middle  = (Flags & 0x10) ? TRUE : FALSE;
    Bottom  = (Flags & 0x20) ? TRUE : FALSE;
}





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

>   MarkPosition::MarkPosition()

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/07/96
    Purpose:    Construct a mark position object

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

MarkPosition::MarkPosition()
{
    Initialise();
}


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

>   void MarkPosition::Initialise()

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/07/96
    Purpose:    Initialise all the local variables in this mark position

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

void MarkPosition::Initialise()
{
    Region = MarkRegion_TopLeft;
}


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

>   BOOL MarkPosition::IsEqualTo(const MarkPosition* pOther) const

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/07/96
    Inputs:     pOther = a pointer to a mark position to match
    Returns:    TRUE if pOther is identical to this mark
                FALSE if not
    Purpose:    Check whether another mark position is identical to this one

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

BOOL MarkPosition::IsEqualTo(const MarkPosition* pOther) const
{
    ERROR2IF(pOther==NULL, FALSE, "NULL pointer passed to MarkPosition::IsEqualTo");
    return ( (Region == pOther->Region) &&
             (Format == pOther->Format)
           );
}


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

>   PrintMark::PrintMark

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/07/96
    Purpose:    Construct a new print mark

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

PrintMark::PrintMark()
{
    MarkIsCustom    = FALSE;
    IDByte          = 0;
    Type            = MarkType_Unknown;
    Orientation     = MO_None;
    OnAsDefault     = FALSE;
}


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

>   virtual PrintMark::~PrintMark()

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/07/96
    Purpose:    virtual destructor, destroys all instances of the 'MarkPositions' list

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

PrintMark::~PrintMark()
{
    MarkPosition* pMarkPos;
    while ((pMarkPos=(MarkPosition*)MarkPositions.RemoveTail()))
        delete pMarkPos;
}



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

>   void PrintMark::SetMarkMenuText(const String_256* pMenuText)

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/07/96
    Inputs:     pMenuText = a pointer to a string containing the textual description of 
                            the print mark, (may be used in menus).
    Purpose:    Set this print mars menu text

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

void PrintMark::SetMarkMenuText(const String_256* pMenuText)
{
    ERROR3IF(pMenuText==NULL,"ERROR ERROR, NULL pointer passed to SetMarkMenuText");
    if (pMenuText!=NULL)
        MenuText = (*pMenuText);
}


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

>   String_256 PrintMark::GetMarkMenuText() const

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/07/96
    Inputs:     -
    Returns:    This print marks textual description
    Purpose:    Return the menu text string saved in this print mark

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

String_256 PrintMark::GetMarkMenuText() const
{
    return MenuText;
}


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

>   void PrintMark::AddNewPosition(MarkPosition* pNewMarkPos)

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/07/96
    Inputs:     pNewMarkPos, a pointer to a new mark position
    Returns:    This print marks textual description
    Purpose:    Return the menu text string saved in this print mark

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

void PrintMark::AddNewPosition(MarkPosition* pNewMarkPos)
{
    ERROR3IF(pNewMarkPos==NULL,"NULL MarkPosition pointer passed to AddNewPosition");
    if (pNewMarkPos)
    {
        if (!FindMarkPosition(pNewMarkPos))
            MarkPositions.AddTail(pNewMarkPos);
    }
}

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

>   BOOL PrintMark::FindMarkPosition(const MarkPosition* pSearchMark, MarkPosition** pFoundMark=NULL) const

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/07/96
    Inputs:     pSearchMark = a pointer to a print mark to search for
                pFoundMark, a pointer to a pointer to be set on exit. This defaults to null
                when we're only interested in whether the mark exists or not.

    Outputs:    pFoundMark set to a pointer to the print mark in the cache if we find it
                pFoundMark set to NULL if no match found
                                    
    Returns:    TRUE if there is a mark in the cache identical to this search mark
                FALSE if there isn't
    Purpose:    Check the cache to see if there's a mark already in it which matches
                pSearchMark. You can get the pointer to this cached mark by using pFoundMark

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

BOOL PrintMark::FindMarkPosition(const MarkPosition* pSearchMark, MarkPosition** pFoundMark) const
{
    ERROR3IF(pSearchMark==NULL,"PrintMark::FindMarkPosition passed a NULL search mark pointer");
    if (pSearchMark)
    {
        MarkPosition* pMarkPos = GetFirstPosition();
        while (pMarkPos)
        {
            // Check to see if this exists
            if (pSearchMark->IsEqualTo(pMarkPos))
            {
                if (pFoundMark!=NULL)
                    (*pFoundMark=pMarkPos);
                return TRUE;
            }
            pMarkPos = GetNextPosition(pMarkPos);
        }
    }
    if (pFoundMark!=NULL)
        (*pFoundMark=NULL);
    return FALSE;
}

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

>   BOOL PrintMark::IsSimilarTo(const PrintMark* pOther) const

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/07/96
    Inputs:     pOther, a pointer to another print mark
    Returns:    TRUE if this print mark is similar to pOther.
                FALSE if not
    Purpose:    Checks whether this print mark is similar to pOther. The current checks
                for similarity are...
                (1) the mark is of the same type
                (2) the mark has the same menu text

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

BOOL PrintMark::IsSimilarTo(const PrintMark* pOther) const
{
    ERROR2IF(pOther==NULL, FALSE, "NULL PrintMark pointer passed to IsSimilar()");

    if (Type == pOther->GetType())
    {
        if (MenuText == pOther->GetMarkMenuText())
            return TRUE;
    }
    return FALSE;
}



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

>   PrintMarkItem::PrintMarkItem

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/07/96
    Purpose:    Construct a new print mark item

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

PrintMarkItem::PrintMarkItem()
{
    pMarkGlyph  = NULL;
    Handle      = 0;
    Saveable    = TRUE;
    Renderable  = TRUE;
}


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

>   PrintMarkItem::~PrintMarkItem

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/07/96
    Purpose:    destruct a print mark item

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

PrintMarkItem::~PrintMarkItem()
{
    RemoveMark();
}




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

    BOOL PrintMarkItem::SetMarkGlyph(NodeGroup* pNewMark, BOOL MakeCopy=FALSE)

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/07/96
    Inputs:     pNewMark = A pointer to a group node containing the mark. 
                           The node should still be in the tree.
                MakeCopy = TRUE, the mark will be left where it is and an
                                 attribute complete copy will be made.
                           FALSE, the mark will be extracted from the document as is. 
    Purpose:    Cache a print mark in this print mark item. The mark pointer should be
                a group held in the document tree. As we attempt to make attributes
                complete on this group, it has to be in the tree. MakeCopy which defaults
                to FALSE will, when TRUE, copy the entire group and used the copy, hence
                it will leave the document unaffected. When FALSE the group will be
                extracted from the tree. This is only acceptable in a few circumstances
                when undo is not being generated.

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

BOOL PrintMarkItem::SetMarkGlyph(NodeGroup* pNewMark, BOOL MakeCopy)
{
    ERROR2IF(pNewMark==NULL,FALSE, "NULL mark pointer passed to SetMark");

    if (MakeCopy)
    {
        NodeGroup* pNewGroup = new NodeGroup;
        if (pNewGroup==NULL)
            return FALSE;

        NodeGroup* pNewGroup1 = new NodeGroup;
        if (pNewGroup1==NULL)
        {
            delete pNewGroup;
            return FALSE;
        }
        
        // attach this new group to the tree
        pNewGroup->AttachNode(pNewMark,NEXT);
        pNewGroup1->AttachNode(pNewGroup,FIRSTCHILD);

        // copy the children across to this new group
        if (!pNewMark->CopyChildrenTo(pNewGroup1))
        {
            // CascadeDelete unlinks the node from the tree so don't panic.
            pNewGroup->CascadeDelete();
            delete pNewGroup;
            return FALSE;
        }

        // make sure we have all the attributes we're gonna need
        if (!pNewGroup->MakeAttributeComplete(NULL,TRUE,NULL,TRUE))
        {
            pNewGroup->CascadeDelete();
            delete pNewGroup;
            return FALSE;
        }

        // dump the tree out
        //TRACEUSER( "Mike", _T("Dumping subtree contents\n\n"));
        //DebugTreeDlg::DumpSubTree(pNewGroup);
        
        // rip the node out of the tree and stick it in our cache.
        pNewGroup->UnlinkNodeFromTree();
                
        // Make sure we get rid of any previously cached mark
        if (pMarkGlyph!=NULL)
            RemoveMark();

        pMarkGlyph = pNewGroup;
    }
    else
    {
        if (!pNewMark->MakeAttributeComplete(NULL,TRUE,NULL,TRUE))
            return FALSE;

        pNewMark->UnlinkNodeFromTree();
                
        // Make sure we get rid of any previously cached mark
        if (pMarkGlyph!=NULL)
            RemoveMark();

        pMarkGlyph = pNewMark;
    }

    return TRUE;
}


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

>   void PrintMarkItem::RemoveMark()

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/07/96
    Purpose:    Remove the cached mark from our list structure. This is generally
                called when the mark item is destroyed.

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

void PrintMarkItem::RemoveMark()
{
    // check to see if we have a sub tree here
    if (pMarkGlyph!=NULL)
    {
        Node* pNode = pMarkGlyph->FindFirstChild();
        if (pNode!=NULL)
            pMarkGlyph->DeleteChildren(pNode);
    }
    delete pMarkGlyph;
    pMarkGlyph = NULL;
}


INT32 PrintMarkItem::GetWidth() const
{
    if (pMarkGlyph!=NULL)
    {
        DocRect bounds = pMarkGlyph->GetBoundingRect();
        return bounds.Width();
    }
    return 0;
}

INT32 PrintMarkItem::GetHeight() const
{
    if (pMarkGlyph!=NULL)
    {
        DocRect bounds = pMarkGlyph->GetBoundingRect();
        return bounds.Height();
    }
    return 0;
}

DocCoord PrintMarkItem::GetOrigin() const
{
    if (pMarkGlyph!=NULL)
    {
        DocRect bounds = pMarkGlyph->GetBoundingRect();
        return bounds.lo;
    }
    return DocCoord(0,0);
}


MarkOrient PrintMarkItem::GetOrient() const
{
    return Mark.GetOrientation();
}


BOOL PrintMarkItem::DefaultsToOn() const
{
    return Mark.DefaultsToOn();
}


BOOL PrintMarkItem::NeedsSaving() const
{
    return Saveable;
}


void PrintMarkItem::SetSaveable(BOOL savestate)
{
    Saveable = savestate;
}

BOOL PrintMarkItem::NeedsToRender() const
{
    return Renderable;
}

void PrintMarkItem::SetRenderable(BOOL renderstate)
{
    Renderable = renderstate;
}



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

>   PrintMarksCache::PrintMarksCache()

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/07/96
    Purpose:    Construct the PrintMarksCache object. This used to be part of the print
                marks manager but I've now split it into its own class to prevent
                confusion with the handling of cache marks and document marks. Various
                functions do similar things so it could become confusing without a
                scope resolution operator PMMCache::FindMark as opposed to Doc::FindMark

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

PrintMarksCache::PrintMarksCache()
{
    NextHandle=0;
    TextInfoHandle=0;
    CropMarkHandle=0;
}


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

>   PrintMarksCache::~PrintMarksCache()

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/07/96
    Purpose:    Destroys the cached marks completely

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

PrintMarksCache::~PrintMarksCache()
{
    Invalidate();
}


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

>   PrintMarksCache::~PrintMarksCache()

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/07/96
    Purpose:    Invalidate the cache list. If we do this, all the mark references
                in existing document will reference nothing. As we create new marks
                new handles will be built, so it might be necessary to delete references
                made in all doc components.
                Use with care.

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

void PrintMarksCache::Invalidate()
{
    // destroy all marks in the cache.
    PrintMarkItem* pItem;
    while ((pItem=(PrintMarkItem*)PrintMarkCache.RemoveTail())) // assignment
        delete pItem;
    // Make sure the crop and text info handles don't reference anything
    CropMarkHandle=0;
    TextInfoHandle=0;
}


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

>   UINT32 PrintMarksCache::GetUniqueHandle()

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/07/96
    Inputs:     -
    Returns:    A handle used to reference a unique print mark
    Purpose:    Generate a unique print mark handle. All handles will be >=1 and hence
                an illegal handle is given the value 0.

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

UINT32 PrintMarksCache::GetUniqueHandle()
{
    NextHandle++;
    return (NextHandle);
}



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

>   PrintMarkItem* PrintMarksCache::GetFirstMark() const

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/07/96
    Inputs:     -
    Returns:    A pointer to the first cached mark
    Purpose:    Return a pointer to the first cached mark

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

PrintMarkItem* PrintMarksCache::GetFirstMark() const
{
    return ((PrintMarkItem*)PrintMarkCache.GetHead()); 
}


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

>   PrintMarkItem* PrintMarksCache::GetNextMark(PrintMarkItem* pCurrMark) const

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/07/96
    Inputs:     A pointer to a print mark item
    Returns:    A pointer to the next print mark item after this
    Purpose:    Returns the next print mark item beyond pCurrMark

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

PrintMarkItem* PrintMarksCache::GetNextMark(PrintMarkItem* pCurrMark) const
{
    return ((PrintMarkItem*)PrintMarkCache.GetNext(pCurrMark));
}


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

>   BOOL PrintMarksCache::DoesMarkExist(PrintMark* pCheckMark) const

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/07/96
    Inputs:     A pointer to a print mark
    Returns:    TRUE if this mark already exists in the cache
                FALSE if not
    Purpose:    Try to find a print mark in the cache

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

BOOL PrintMarksCache::DoesMarkExist(PrintMark* pCheckMark) const
{
    PrintMarkItem* pItem = GetFirstMark();
    while (pItem)
    {
        PrintMark* pCurrMark = pItem->GetPrintMark();
        if (pCheckMark->IsSimilarTo(pCurrMark))
            return TRUE;
        pItem = GetNextMark(pItem);
    }
    return FALSE;
}


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

>   PrintMarkItem* PrintMarksCache::FindMark(UINT32 SearchHandle)

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/07/96
    Inputs:     SearchHandle = the handle of the mark to search for
    Returns:    A pointer to the print mark described by this handle (NULL if none)
    Purpose:    Try to find a print mark in the cache, using its handle

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

PrintMarkItem* PrintMarksCache::FindMark(UINT32 SearchHandle)
{
    PrintMarkItem* pItem = GetFirstMark();
    while (pItem)
    {
        if (pItem->GetHandle() == SearchHandle)
            return pItem;
        pItem = GetNextMark(pItem);
    }
    return NULL;
}




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

>   BOOL PrintMarksCache::DecodeCachedLayers(Document* pDocument)

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/07/96
    Inputs:     pDocument = a pointer to a document
    Returns:    TRUE if the document has been processed
                
    Purpose:    Given a document, we scan each layer in the document. For each layer
                we check the loaded layer name. If the layer name contains a % at the
                begining (meaning its a format string) and the format is PRINTMARK, we
                take the first group in the layer (+ all its contents) and assign a
                new print mark item to this group. This group object will (if successfully)
                loaded, become a new print mark.
    
*****************************************************************************************/

BOOL PrintMarksCache::DecodeCachedLayers(Document* pDocument)
{
    ERROR2IF(pDocument==NULL,FALSE,"NULL Layer passed to DecodeCachedLayer");
    
    Spread* pSpread = pDocument->FindFirstSpread();
    Layer* pLayer;
    while (pSpread!=NULL)
    {
        pLayer = pSpread->FindFirstLayer();
        while (pLayer!=NULL)
        {
            DecodeCachedLayer(pLayer);
            pLayer = pLayer->FindNextLayer(); // Find next layer
        }
        pSpread = pSpread->FindNextSpread();
    }
    return TRUE;
}


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

>   BOOL PrintMarksMan::DecodeCachedLayer(Layer* pLayer)

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/07/96
    Inputs:     pLayer = a pointer to a layer
    Returns:    TRUE if the layer has been processed
    Purpose:    Given a layer, if the layer contains a print mark, strip the print mark
                out and try to add it to the PrintMarksMan cache.
    
*****************************************************************************************/

BOOL PrintMarksCache::DecodeCachedLayer(Layer* pLayer)
{
    ERROR2IF(pLayer==NULL,FALSE,"NULL Layer passed to DecodeCachedLayer");

    // Read in the layer name
    String_256 Name;
    String_16 Token;

    Name = pLayer->GetLayerID();
    Name.Left(&Token, 10);

    BOOL IsValid = FALSE;
    BOOL IsCustomMark = FALSE;
    if (Token == String_16(_T("%PRINTMARK")))               // This text must not be internationalised
        IsValid = TRUE;

    if (!IsValid && Token == String_16(_T("%CUSTOMMAR")))   // This text must not be internationalised
    {
        IsValid = TRUE;
        IsCustomMark = TRUE;
    }

    if (!IsValid)
        return FALSE;

    // find the first renderable group in this layer.
    NodeGroup* pGroup = (NodeGroup*)pLayer->FindFirstChild(CC_RUNTIME_CLASS(NodeGroup));
    if (pGroup==NULL)
        return FALSE;

    // Create a new mark structure to put the decoded data into
    PrintMarkItem* pNewMark = new PrintMarkItem;
    if (!pNewMark)
        return FALSE;

    PrintMark* pMark = pNewMark->GetPrintMark();
    pMark->SetCustomOrDefault(IsCustomMark);        // Remember if it's a custom or default mark
    if (!DecodeMarkFormat(&Name, pMark))
    {
        delete pNewMark;
        return FALSE;
    }

    // Right we have a new print mark descriptor, 
    // we simply merge the mark into the
    // cache. It would be faster, before copying the subtree, to check whether we
    // dont already have this mark cached in the print mark manager.

    if (DoesMarkExist(pMark))
    {
        delete pNewMark;
        return TRUE;
    }

    // Add a handle to this mark
    pNewMark->SetHandle(GetUniqueHandle());

    // ok the mark does not exist, so now look for that first group
    if (!pNewMark->SetMarkGlyph(pGroup, TRUE))
    {
        delete pNewMark;
        return FALSE;
    }

    // Hey hey, we've finally done it! cool!
    PrintMarkCache.AddTail(pNewMark);

    return TRUE;
}


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

>   UINT32 PrintMarksCache::AddNewMark(PrintMarkItem* pNewMark, NodeGroup* pGroup)

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/07/96
    Inputs:     pNewMark = a pointer to the new mark to add
                pGroup = a pointer to the glyph to use. 
    Returns:    The handle of the newly added mark
    Purpose:    A simple way of adding a prebuilt mark to the list. The mark must be in
                a renderable format, in that it should be a group with all needed attrs
                as children, followed by a child group containing all the ink objects
    
*****************************************************************************************/

UINT32 PrintMarksCache::AddNewMark(PrintMarkItem* pNewMark, NodeGroup* pGroup)
{
    // Add a handle to this mark
    UINT32 hndle = GetUniqueHandle();
    pNewMark->SetHandle(hndle);
    pNewMark->pMarkGlyph = pGroup;
    // Hey hey, we've finally done it! cool!
    PrintMarkCache.AddTail(pNewMark);
    return hndle;
}


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

>   void PrintMarksCache::UpdateMarkGlyph(PrintMarkItem *pMarkItem, NodeGroup *pGroup)

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/07/96
    Inputs:     pMarkItem = a pointer to an existing cached mark
                pGroup    = a pointer to a new glyph to use.
    Returns:    -
    Purpose:    Change the mark glyph to this new mark.

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

void PrintMarksCache::UpdateMarkGlyph(PrintMarkItem *pMarkItem, NodeGroup *pGroup)
{
    if (pMarkItem!=NULL)
    {
        // Make sure there's nothing in there at the mo.
        pMarkItem->RemoveMark();
        // now set the new mark glyph
        pMarkItem->pMarkGlyph = pGroup;
    }
}



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

>   BOOL PrintMarksCache::DecodeMarkFormat(const String_256 *pFormatString, PrintMark* pMark)

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/07/96
    Inputs:     pFormatString
    Outputs:    pMark
    Returns:    TRUE if the format string was valid.
    Purpose:    Decode the string pointed to by pFormatString, placing each format
                identifier into the output mark.

                Special tag         Mark name           ID On/off Type      Position(s)
                %PRINTMARK  = "Registration mark",      3,  1,  _R(ID_STAR), 3MCS + 7MC + 11MCS + 15MC
                %CUSTOMMARK = "User registration mark", 0,  1,  _R(ID_STAR), 3MCS + 7MC + 11MCS + 15MC

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

BOOL PrintMarksCache::DecodeMarkFormat(const String_256 *pFormatString, PrintMark* pMark)
{
    ERROR2IF(pFormatString == NULL, FALSE, "NULL pointer passed to DecodeMarkFormat");
    ERROR2IF(pMark == NULL, FALSE, "NULL mark pointer passed to DecodeMarkFormat");

    String_256 Name(*pFormatString);
    String_256 MenuText;
    String_256 MenuID;
    MarkFormat NewFormat;
    MarkRegion NewRegion;
    MarkOrient NewOrient;

    const TCHAR COMMA   = TEXT(',');        // This text must not be internationalised
//  const TCHAR EQUALS  = TEXT('=');
    const TCHAR QUOTES  = TEXT('"');
    const TCHAR PLUS    = TEXT('+');
    const TCHAR SPACE   = TEXT(' ');

    INT32 pos, pos1;

    // Everything is hunky dory at the moment! ER NOT!
    BOOL AllIsWell = FALSE;

    // Turn on the exceptions function in the string reading class
    StringBase::EnableExceptionHandler();

    //try 
    {
        // toast everything up to the first quote
        pos = Name.FindNextChar(QUOTES);
        Name.Remove(0,pos+1);

        // now find the last quote of the first string
        pos = Name.FindNextChar(QUOTES);
        Name.Left(&MenuText,pos);
        Name.Remove(0,pos+1);

        // skip over the first comma onto the ID field
        pos  = Name.SkipComma();
        Name.Remove(0,pos);
        pos = 0;
        INT32 ID = Name.ConvertToInteger(pos);
        Name.Remove(0,pos);
        if (ID < 0 || ID > 255)
            ID = 0;
        pMark->SetIDByte((BYTE)ID);

        // skip over the next comma onto the enable/disable state
        pos  = Name.SkipComma();
        Name.Remove(0,pos);
        BOOL Enabled = (Name[0] == TEXT('1'));

        // skip comma to next field
        pos  = Name.SkipComma();
        pos1 = Name.FindNextChar(COMMA, pos+1);
        Name.Mid(&MenuID, pos, (pos1-pos));
        Name.Remove(0,pos1+1);

        // turn the menu id into a type of mark if we recognise it
        MarkType actid = (MarkType)DecodeToMarkType(&MenuID);

        // skip the orientation field
        pos=Name.FindNextChar();
        NewOrient=MO_None;
        if (Name[pos] == TEXT('H'))
            NewOrient=MO_Horizontal;
        else if (Name[pos] == TEXT('V'))
            NewOrient=MO_Vertical;

        // remove the orientation bit
        pos = Name.SkipComma();

        // Add what we have so far
        pMark->SetMarkMenuText(&MenuText);
        pMark->SetOrientation(NewOrient);
        pMark->SetType(actid);
        pMark->SetDefaultState(Enabled);

        // The remainder of this string is a format list
//      BOOL format=FALSE;
//      BOOL eos=FALSE;

        // Turn our exception handler off but don't pop it.
        StringBase::DisableExceptionHandler(FALSE);

        INT32 region;

        while (pos>0)
        {
            // Try to create a new mark to add
            MarkPosition* pNewMark = new MarkPosition;

            if (pNewMark!=NULL)
            {
                region = Name.ConvertToInteger(pos);

                if (region<1 || region>MAXPAGEREGIONS)
                {
                    // Ok, the region number is out of range so lets
                    // skip to the next one (if there is one!)
                    // we need to find the next +
                    delete pNewMark;
                    pos = Name.FindNextChar(PLUS, pos);
                }
                else
                {
                    // store this type of region
                    NewRegion = (MarkRegion)(region-1);
                    pNewMark->SetRegion(NewRegion);
                                
                    // if we haven't run off the end of the string
                    while ( Name.IsLegal(pos) && (Name[pos]!=PLUS) )
                    {
                        TCHAR c = Name[pos];
                        
                        switch (c)
                        {
                            case TEXT('T'): NewFormat.Top=TRUE;     break;
                            case TEXT('M'): NewFormat.Middle=TRUE;  break;
                            case TEXT('B'): NewFormat.Bottom=TRUE;  break;
                            case TEXT('L'): NewFormat.Left=TRUE;    break;
                            case TEXT('C'): NewFormat.Centre=TRUE;  break;
                            case TEXT('R'): NewFormat.Right=TRUE;   break;
                            default:
                                // unknown token, just ignore it!
                                if (c != SPACE)
                                    TRACEUSER( "Mike", _T("Unknown format character during PrintMarksMan::DecodeMarkFormat"));
                                break;
                        }
                        
                        pos = Name.FindNextChar(pos+1);
                    }

                    // make sure the format is ok
                    if (!NewFormat.IsValid())
                        NewFormat.MakeValid();
                    
                    // and set it in the structure.
                    pNewMark->SetFormat(NewFormat);

                    // Add the new mark position to the list.
                    pMark->AddNewPosition(pNewMark);

                    AllIsWell=TRUE;

                    if (Name.IsLegal(pos))
                        pos = Name.FindNextChar(pos+1);
                }
            }
            else
            {
                pos = -1;
            }
        }
    }
PORTNOTE("other", "Disabled random use of MFC CUserException in Kernel code")
#ifndef EXCLUDE_FROM_XARALX
    catch (CUserException)
    {
        // An exception has been thrown which means
        // we failed to parse this string, so simply report failure
        AllIsWell = FALSE;
    }
#endif

    // Switch off the exception state finally, (and of course pop it)!
    StringBase::DisableExceptionHandler();

    return AllIsWell;
}



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

>   UINT32 PrintMarksCache::DecodeToMarkType(String_256* Name) const

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/07/96
    Inputs:     Name = a pointer to a string describing the mark type
    Returns:    A unsigned integer describing the mark type (see MarkType for instances)
    Purpose:    Have a look at the string passed in and check to see it matches any of
                the known mark type names. If so return the proper mark type enum, otherwise
                'Unkown' is returned.
    
*****************************************************************************************/

UINT32 PrintMarksCache::DecodeToMarkType(const String_256* Name) const
{
    ERROR2IF(Name == NULL, MarkType_Unknown, "NULL pointer passed to DecodeToMarkType");
    
    if ((*Name)==String_16(_T("ID_NONE")))  return