cdrfiltr.cpp

Go to the documentation of this file.

// $Id: cdrfiltr.cpp 1282 2006-06-09 09:46:49Z 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============================
 */
// *********CDR file filter

/*
*/

// this line disables extrudes as they don't *quite* work yet - corel still need some
// interegation about what's going on. It seems the object is pre-transformed by some
// random values. Weird. #define this to include the stuff.
#undef CDR_DOEXTRUDES

#include "camtypes.h"
#include "cdrfiltr.h"
//#include "oilfltrs.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "ben.h"
//#include "ccfile.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "progress.h"
#include "cdrcol.h"
#include "rifffile.h"
#include "cdrform.h"
//#include "fixmem.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "nodepath.h"
//#include "group.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "page.h"
//#include "spread.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "nodershp.h"
//#include "resource.h"
//#include "fixst256.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "ndoptmz.h"
#include "collist.h"
#include "layer.h"
#include "sglayer.h"
#include "sprdmsg.h"
#include "nodebmp.h"
#include "nodetxts.h"
//#include "textinfo.h"
#include "zoomops.h"
//#include "docview.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "nodemold.h"
#include "moldshap.h"
#include "ndmldpth.h"
#include "nodemldr.h"
//#include "nev.h"
#include "fontman.h"
//#include "app.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "cmxres.h"
#include "cmxifltr.h"       // so we can pass stuff to it nicely

DECLARE_SOURCE("$Revision: 1282 $");

CC_IMPLEMENT_DYNAMIC(CDRFilter, VectorFilter)
CC_IMPLEMENT_MEMDUMP(CDRAttributeStore, List)
CC_IMPLEMENT_MEMDUMP(CDRAttributeStoredItem, ListItem)
CC_IMPLEMENT_MEMDUMP(CDRArrowheadStore, List)
CC_IMPLEMENT_MEMDUMP(CDRArrowheadStoredItem, ListItem)
CC_IMPLEMENT_MEMDUMP(CDRBitmapStore, List)
CC_IMPLEMENT_MEMDUMP(CDRBitmapStoredItem, ListItem)
CC_IMPLEMENT_MEMDUMP(CDRVectorStore, List)
CC_IMPLEMENT_MEMDUMP(CDRVectorStoredItem, ListItem)
CC_IMPLEMENT_MEMDUMP(CDRFontnameStore, List)
CC_IMPLEMENT_MEMDUMP(CDRFontnameStoredItem, ListItem)
CC_IMPLEMENT_MEMDUMP(CDRLayerList, List)
CC_IMPLEMENT_MEMDUMP(CDRLayerListItem, ListItem)
CC_IMPLEMENT_MEMDUMP(CDRPageList, List)
CC_IMPLEMENT_MEMDUMP(CDRPageListItem, ListItem)
CC_IMPLEMENT_MEMDUMP(CDRActionList, List)
CC_IMPLEMENT_DYNAMIC(CDRActionListItem, ListItem)
CC_IMPLEMENT_DYNAMIC(CDRActionTransform, CDRActionListItem)
CC_IMPLEMENT_DYNAMIC(CDRActionGroupEnd, CDRActionListItem)
CC_IMPLEMENT_MEMDUMP(CDRTransformConvertor, CC_CLASS_MEMDUMP)
CC_IMPLEMENT_MEMDUMP(CDRTransformConvertor5, CDRTransformConvertor)
CC_IMPLEMENT_MEMDUMP(CDRTransformConvertor4, CDRTransformConvertor)
CC_IMPLEMENT_MEMDUMP(CDRTransformConvertor3, CDRTransformConvertor)
CC_IMPLEMENT_MEMDUMP(CDRTextOnPathLink, ListItem)


#define new CAM_DEBUG_NEW

#define PROGRESSUPDATE_MASK 0x7f

INT32 CDRFilter::BitmapNumber = 0;
INT32 CDRFilter::PatternNumber = 0;

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

>   static void CDRFilter::UpdateProgress(BOOL Now = FALSE)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22 03 95
    Inputs:     None
    Returns:    None
    Purpose:    Updating the progress everysooften - called at every significant place
                to get a nice smooth update on that progress bar thingy
    SeeAlso:    Filter

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

BOOL CDRFilter::UpdateProgress(BOOL Now)
{
    BOOL Result = TRUE;
    
    if(Now)
    {
        Result = ContinueSlowJob(RIFF->ProgressNow());
        ProgressCount = 0;
    }
    else
    {
        if((ProgressCount & PROGRESSUPDATE_MASK) == 0) {
            Result = ContinueSlowJob(RIFF->ProgressNow());
        }

        ProgressCount++;
    }

    if(!Result)
    {
        Error::ClearError();        // because this may not be handled the first time around
        Error::SetError(_R(IDN_USER_CANCELLED));
    }
    
    return Result;
}

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

>   CDRFilter::CDRFilter(void)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    21 03 95
    Inputs:     As for the Filter class
    Returns:    As for the Filter class
    Purpose:    Constructor
    SeeAlso:    Filter

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

CDRFilter::CDRFilter(void)
{
    // Set up filter descriptions.
    FilterName.Load(_R(IDT_CDRFILTER_FILTERNAME));
    FilterInfo.Load(_R(IDT_CDRFILTER_FILTERINFO));
    FilterID = FILTERID_CDR;

    Flags.CanImport = TRUE;
    Flags.CanExport = FALSE;

    Version = CDRVERSION_NULL;
}


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

>   BOOL CDRFilter::Init(void)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    21 03 95
    Inputs:     As for the Filter class
    Returns:    As for the Filter class
    Purpose:    Initialisation
    SeeAlso:    Filter

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

BOOL CDRFilter::Init(void)
{
    // Get the OILFilter object
    pOILFilter = new CDROILFilter(this);
    if (pOILFilter == NULL)
        return FALSE;

    // make sure we'll complain about life if HowCompatable isn't called
    Version  = CDRVERSION_NULL;

    // All ok
    return TRUE;
}

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

>   INT32 CDRFilter::HowCompatible(PathName& Filename, ADDR  HeaderStart,
        UINT32 HeaderSize, UINT32 FileSize)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    21 03 95
    Inputs:     As for the Filter class
    Returns:    As for the Filter class
    Purpose:    Examines a file to see how compatable it is with this filter.
    SeeAlso:    Filter

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

INT32 CDRFilter::HowCompatible(PathName& Filename, ADDR  HeaderStart,
        UINT32 HeaderSize, UINT32 FileSize)
{
PORTNOTE("byteorder", "TODO: Check byte ordering")
    BOOL ExtensionMatches = pOILFilter->DoesExtensionOfPathNameMatch(&Filename);

    // check for version 2 files if the extension matches...
    if (ExtensionMatches)
    {
        if(camStrncmp((char *)HeaderStart, "WL", 2) == 0)
            return 10;          // a version 2.xx CDR file
    }

    // check for version 3 - 5 files...
    FOURCC FormType;

    FormType = RIFFFile::CheckRIFFHeader(HeaderStart, FileSize);

    Version  = CDRVERSION_NULL;
    
    switch (FormType)
    {
        case cdrT_CDR:
            Version = CDRVERSION_3;
            break;
        
        case cdrT_CDR4:
        case cdrT_CDST:         // version 4 template
            Version = CDRVERSION_4;
            break;

        case cdrT_CDR5:
        case cdrT_CDT5:
            Version = CDRVERSION_5;
            break;

        case cdrT_CDR6:
        case cdrT_CDT6:
            Version = CDRVERSION_6;
            break;

        default:
            break;
    }

    INT32 HowMuchWeLikedThisFile = 0;

    if(Version != CDRVERSION_NULL)
    {
        HowMuchWeLikedThisFile = 10;        // loved the file

        // check to see if there is a CMX file embedded in there
        if(HasCDRFileGotCMXFile(&Filename))
        {
            HowMuchWeLikedThisFile = 5;     // didn't like it so much then -- let the CMX filter grab it
        }
    }

    return HowMuchWeLikedThisFile;
}

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

>   BOOL CDRFilter::DoImport(SelOperation *Op, CCLexFile *pDiskFile, Document *DestDoc, 
        BOOL AutoChosen, ImportPosition *Pos,
        KernelBitmap** ppImportedBitmap, DocCoord* pPosTranslate, String_256* URL)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    21 03 95
    Inputs:     As for the Filter class
    Returns:    As for the Filter class
    Purpose:    Does the import of a CDR (.cdr or .cdt)
    SeeAlso:    Filter

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

#define CDRFILTER_DI_RETURNERROR {Success = FALSE; return ClearUp();}

BOOL CDRFilter::DoImport(SelOperation *Op, CCLexFile *pDiskFile, Document *DestDoc, 
        BOOL AutoChosen, ImportPosition *Pos,
        KernelBitmap** ppImportedBitmap, DocCoord* pPosTranslate, String_256* URL)
{
    // check to see if we've got a CMX file in there, but only if we weren't autochosen
    if(!AutoChosen && HasCDRFileGotCMXFile(NULL, pDiskFile))
    {
        TRACEUSER( "Ben", _T(">>> loading CDR file with new CMXImportFilter\n"));
        // right, somehow we got here -- probably because the user specifically
        // asked to see CorelDRAW files only
        CMXImportFilter *pFilter = new CMXImportFilter;

        if(pFilter == NULL)
            return FALSE;

        BOOL ok = pFilter->DoImport(Op, pDiskFile, DestDoc, AutoChosen, Pos);

        delete pFilter;
        pFilter = NULL;

        return ok;
    }

    // normal CDR import stuff
    BOOL ExtensionMatches = pOILFilter->DoesExtensionOfFileMatch(pDiskFile);

    RIFFFile RIFFo;

TRACEUSER( "Ben", _T("In CDRFilter::DoImport\n"));
    //ERROR2IF(Version == CDRVERSION_NULL, FALSE, "CDRFilter::HowCompatible failed to set recognised version\n");

    // in debug builds, warn about fills hanging around
    ERROR3IF(Fills.IsEmpty() == FALSE, "Fills store not empty");
    ERROR3IF(Outlines.IsEmpty() == FALSE, "Outlines store not empty");
    ERROR3IF(Styles.IsEmpty() == FALSE, "Styles store not empty");
    ERROR3IF(Fonts.IsEmpty() == FALSE, "Fonts store not empty");
    ERROR3IF(Arrowheads.IsEmpty() == FALSE, "Arrowheads store not empty");
    ERROR3IF(Patterns.IsEmpty() == FALSE, "Patterns store not empty");
    ERROR3IF(Bitmaps.IsEmpty() == FALSE, "Bitmap store not empty");
    ERROR3IF(Vectors.IsEmpty() == FALSE, "Vector store not empty");
    ERROR3IF(TextBBoxes.IsEmpty() == FALSE, "TextBBoxes list not empty");
    ERROR3IF(TextV4.IsEmpty() == FALSE, "TextV4 store not empty");
    ERROR3IF(TextOnPathLinks.IsEmpty() == FALSE, "TextOnPathLinks not empty");

    // in retail builds, just vape any contents
    Fills.DeleteAll();
    Outlines.DeleteAll();
    Styles.DeleteAll();
    Fonts.DeleteAll();
    Arrowheads.DeleteAll();
    Patterns.DeleteAll();
    Bitmaps.DeleteAll();
    Vectors.DeleteAll();
    TextV4.DeleteAll();
    Pages.DeleteAll();
    Actions.DeleteAll();
    TextBBoxes.DeleteAll();
    TextOnPathLinks.DeleteAll();

    // set a few flags and initialise some variables
    pDocument = DestDoc;
    Success = TRUE;
    SlowJobStarted = FALSE;
    TranslateByX = 0;
    TranslateByY = 0;
    PageX = 0;
    PageY = 0;
    pLevelNodeList = 0;
    DoneDoc = FALSE;
    DoneMasterPage = FALSE;
    InMasterPage = FALSE;
    ThisPage = 0;
    ThisLayer = 0;
    pMadeNode = 0;
    ObjectsConverted = 0;
    ObjectsFormatWrong = 0;
    ObjectsUnknown = 0;
    EnvelopesApproximated = 0;
    ObjDataBlock = 0;
    ObjDataBlockSize = 0;
    AttrsAlreadyApplied = FALSE;
    TransformChunk = 0;
    FontTableV3 = 0;
    FontStylesV3 = 0;
    LinkTable = 0;
    ThisOp = Op;
    LinkTransformsExist = FALSE;
    TheDocument = DestDoc;

    // if the extension matches, check it for being a 2.xx file
    if(ExtensionMatches)
    {
        // get the first few bytes
        TCHAR FirstBit[8];

        if(pDiskFile->read((void *)FirstBit, sizeof(FirstBit)).bad())
            return FALSE;

        ERROR1IF(camStrncmp((char *)FirstBit, "WL", 2) == 0, FALSE, _R(IDT_CDRFILTER_ISAV2FILE));
    
        // let's pop the file back to the beginning
        if(pDiskFile->seek(0).bad())
            return FALSE;
    }

    // sort out the RIFF file
    RIFF = &RIFFo;

    FOURCC FormType = RIFF->Init(pDiskFile);

    if(FormType == 1)       // error
    {
        CDRFILTER_DI_RETURNERROR;
    }
    
    // sort out which version we're on
    switch(FormType)
    {
        case cdrT_CDR:
            Version = CDRVERSION_3;
            break;
        
        case cdrT_CDR4:
        case cdrT_CDST:         // version 4 template
            Version = CDRVERSION_4;
            break;

        case cdrT_CDR5:
        case cdrT_CDT5:
            Version = CDRVERSION_5;
            break;

        case cdrT_CDR6:
        case cdrT_CDT6:
            // version 6 file -- we don't support these
            ERROR1(FALSE, _R(IDE_CDRFILTER_CDR6));
            break;

        default:
TRACEUSER( "Ben", _T("Attempted to load something which wasn't a CDR file. I don't think so..."));
            ERROR1(FALSE, _R(IDE_CDRFILTER_NOTCDR));
            break;
    }

    // sort out a colour list
    ColList = DestDoc->GetIndexedColours();
    
    // do we want to import with layers?
    UseLayers = FALSE;
#ifdef WEBSTER
    // In Webster, just use the default preference settings as these should be set to
    // ImportWithLayers to False.
    if (
        (!DestDoc->IsImporting() && Filter::OpenWithLayers) ||
        (DestDoc->IsImporting() && Filter::ImportWithLayers)
        )
        UseLayers = TRUE;
#else
    // In Camelot, we must check to see if the document is being imported and if so if
    // there are any frames present. If there are then don't use layers, if there are
    // then use the preference setting.
    if (DestDoc->IsImporting())
    {
        Spread * pTheSpread = DestDoc->GetSelectedSpread();
        Layer * pFrame = NULL;
        if (pTheSpread != NULL)
            pFrame = pTheSpread->FindFirstFrameLayer();
        if (pFrame != NULL)
            UseLayers = FALSE;                      // Frames present so do not import layers
        else
            UseLayers = Filter::ImportWithLayers;   // No frames so use the preference setting
    }
    else
    {
        UseLayers = Filter::OpenWithLayers;
    }
#endif

    // If importing without layers, make sure there is a layer to put things on, and make one if not
    if(UseLayers == FALSE)
    {
        if (!MakeSureLayerExists(DestDoc))
        {
            // clean up and return and error
            CDRFILTER_DI_RETURNERROR;
        }
    }

    // For now, position Draw objects on 1st page of spread 1
    pSpread = DestDoc->GetSelectedSpread();
    pPage = (Page *) pSpread->FindFirstPageInSpread();
    
    // Use bottom left of page as origin
    DocRect PageRect = pPage->GetPageRect();
    Origin = PageRect.lo;

    // OK, let's get into the swing of things!
    
    // Get a default set of attributes for ink objects.
    if (!SetUpCurrentAttrs())
        return FALSE;

    // Let start off by setting the progress indicatorx
    UINT32 id;
    switch(Version)
    {
        case CDRVERSION_4:  id = _R(IDT_IMPORTMSG_CDR4);    break;
        case CDRVERSION_5:  id = _R(IDT_IMPORTMSG_CDR5);    break;
        default:            id = _R(IDT_IMPORTMSG_CDR3);    break;
    }
    if(!DestDoc->IsImporting())
        id += _R(IDT_OPENMSG_CDR3) - _R(IDT_IMPORTMSG_CDR3);
    //String_64 ImportMessage(id);
    String_64 ImportMessage = GetImportProgressString(pDiskFile, id);
    
    // this slow job doesn't have a delay because if the CDR file has a bitmap at the
    // beginning, ContinueSlowJob can't be called for rather a long time (sometimes)
    // and you get 'Nothing Selected' instead of a message telling you what's happening.
    BeginSlowJob(RIFF->ProgressLimit(), FALSE, &ImportMessage);
    SlowJobStarted = TRUE;

    // loop through looking at top level lists, and dispatch them to various handlers
    do
    {
        // get the next object in the file
        if(!RIFF->NextObject())
            CDRFILTER_DI_RETURNERROR;

        if(RIFF->GetObjType() == RIFFOBJECTTYPE_LISTSTART)
        {
            switch(RIFF->GetObjChunkType())
            {
                case cdrT_doc:
                    if(!ProcessDoc())
                    {
TRACEUSER( "Ben", _T("ProcessDoc returned FALSE\n"));
                        CDRFILTER_DI_RETURNERROR;
                    }
                    break;

                case cdrT_page:
                    if(!ProcessPage())
                    {
TRACEUSER( "Ben", _T("ProcessPage returned FALSE\n"));
                        CDRFILTER_DI_RETURNERROR;
                    }
                    break;

                default:
                    // we're not interested in any other root level list, so skip it
                    if(!RIFF->SkipToListEnd(RIFF->GetObjLevel()))
                        CDRFILTER_DI_RETURNERROR;
                    break;
            }
        }

        if(!UpdateProgress())
            return FALSE;
    } while(RIFF->GetObjType() != RIFFOBJECTTYPE_FILEEND);

    // make sure we're at the end
    ContinueSlowJob(RIFF->ProgressLimit());

    // attach paths to text stories
    if(!AttachTextToPaths())
        return FALSE;

    // only stick objects into the document if some were converted
    if(ObjectsConverted > 0)
    {
    
        // check that there were at least two pages
        if(Pages.GetCount() < 1)
        {
    TRACEUSER( "Ben", _T("not enough pages in file\n"));
            CDRFILTER_DI_RETURNERROR;
        }
    
        // get the pointer to the list of levels on the master pages
        CDRLayerList *MasterLayers;
        CDRPageListItem *En = (CDRPageListItem *)Pages.GetHead();

        if(En == 0)
            CDRFILTER_DI_RETURNERROR;

        MasterLayers = &En->Layers;
    
        // get the list of levels on the actual page
        CDRLayerList *PageLayers;
        En = (CDRPageListItem *)Pages.GetNext(En);

        if(Version != CDRVERSION_3)
        {
            if(En == 0)
                CDRFILTER_DI_RETURNERROR;

            PageLayers = &En->Layers;

            // check that they have the same number of layers in their lists
            if(MasterLayers->GetCount() != PageLayers->GetCount())
            {
        TRACEUSER( "Ben", _T("not the same number of layers on master page and on page\n"));
                CDRFILTER_DI_RETURNERROR;
            }
        } else
        {
            PageLayers = 0;
        }

        if(MasterLayers->GetCount() <= 0)
            CDRFILTER_DI_RETURNERROR;

        // if it's a CDR 3 file set the page size and translation things
        if(Version == CDRVERSION_3)
        {
            // set the page size?
            if(!DestDoc->IsImporting() && PageX > 0 && PageY > 0)
            {
// Make the pasteboard an extra page width either side of the page and an extra
// half page height above and below the page. That should be nicely proportional.

                INT32 ms = (PageX > PageY)?PageX:PageY;
    
                // we're opening the file, so set the page size
                if (pSpread)
                {
                    BOOL ok = pSpread->SetPageSize(PageX, PageY, ms, 0, FALSE, TRUE);
                    // Must set the origin of the grid to the bottom left corner of the
                    // union rectangle of all pages on the spread as this is where the x,y
                    // measurements are made from.
                    DocRect PagesRect;
                    NodeGrid* pGrid = pSpread->FindFirstDefaultGridInSpread();
                    ok = ok && pSpread->GetPagesRect(&PagesRect);
                    if (pGrid)
                        pGrid->SetOrigin(PagesRect.lox, PagesRect.loy);
                    
                    if (!ok)
                        CDRFILTER_DI_RETURNERROR;
                }
            }
        
            DocRect PageRect = pPage->GetPageRect();
            Origin = PageRect.lo;

            TranslateByX = Origin.x + (PageX / 2);
            TranslateByY = Origin.y + (PageY / 2);
        }

        // set up pointers to the layers
        CDRLayerListItem *MasterEn = (CDRLayerListItem *)MasterLayers->GetTail();
        CDRLayerListItem *PageEn = 0;
        if(PageLayers != 0)
            PageEn = (CDRLayerListItem *)PageLayers->GetTail();

        EndSlowJob();
        BeginSlowJob();

        // insert everything into the document
        if(UseLayers)
        {
            // go through inserting every layer which has sometime on it
            while(MasterEn != 0)
            {
                // check to see if we have objects to import
                if(MasterEn->Objects != 0 || (PageEn != 0 && PageEn->Objects != 0))
                {
                    // OK, we've got some objects to import, create a layer to put them in
                    Layer *pLayer = new Layer();

                    if(pLayer == 0)
                        CDRFILTER_DI_RETURNERROR;

                    // set it's name and attributes
                    pLayer->SetLayerID(MasterEn->Name);
                    pLayer->SetVisible(MasterEn->IsVisible);
                    pLayer->SetLocked(MasterEn->IsLocked);
                    pLayer->SetActive(FALSE);
                    pLayer->SetPrintable(TRUE);
                    pLayer->SetBackground(FALSE);
                    pLayer->SetOutline(FALSE);

                    // stick objects below it
                    Node *Objects = 0;

                    if(MasterEn->Objects != 0)
                    {
                        Objects = MasterEn->Objects;
                        MasterEn->LayerInDocument = TRUE;
                    }
                    else
                    {
                        Objects = PageEn->Objects;
                        PageEn->LayerInDocument = TRUE;
                    }

                    ERROR3IF(Objects == 0, "Er, tried to make a layer for objects which didn't exist");

                    // attach the objects to the layer
                    Objects->InsertChainSimple(pLayer, FIRSTCHILD);

                    // if it's a CDR 3 file and translate it
                    if(Version == CDRVERSION_3)
                    {
                        Trans2DMatrix Trans(TranslateByX, TranslateByY);
                        pLayer->Transform(Trans);
                    }
                    
                    // insert the layer...
                    if (!Op->DoInsertNewNode(pLayer, (Node *)pSpread, LASTCHILD, TRUE))
                    {
                        // It didn't work - delete the sub-tree we just created
                        pLayer->CascadeDelete();
                        delete pLayer;
                        pLayer = NULL;
                        CDRFILTER_DI_RETURNERROR;
                    }

                    // make sure it's name is unique
                    pLayer->EnsureUniqueLayerID();
                    
                    // ... and finally optimise it's attributes
                    if(!pLayer->OptimiseAttributes())
                        CDRFILTER_DI_RETURNERROR;
                }
    
                // get the next (previous) layer to import
                MasterEn = (CDRLayerListItem *)MasterLayers->GetPrev(MasterEn);
                if(PageEn != 0)
                    PageEn = (CDRLayerListItem *)PageLayers->GetPrev(PageEn);
            }       

            // get the insertation node set up
            DestDoc->ResetInsertionPosition();
        }
        else 
        {
            // get a group node to put everything in as we're not using layers here.
            NodeGroup *pGroup = new NodeGroup;
            if(pGroup == 0)
                CDRFILTER_DI_RETURNERROR;
    
            // run through the layers putting in the stuff - remember they're in reverse order
            while(MasterEn != 0)
            {
        TRACEUSER( "Ben", _T("Putting layer '%s' into document\n"), (TCHAR *)MasterEn->Name);       
        
                // put the master pages objects onto this group
                if(MasterEn->Objects != 0)
                {
                    MasterEn->Objects->InsertChainSimple(pGroup, LASTCHILD);
        
                    MasterEn->LayerInDocument = TRUE;
                }

                // put the page objects into this group
                if(PageEn != 0 && PageEn->Objects != 0)
                {
                    PageEn->Objects->InsertChainSimple(pGroup, LASTCHILD);

                    PageEn->LayerInDocument = TRUE;
                }

        
                // get the next (previous) layer to import
                MasterEn = (CDRLayerListItem *)MasterLayers->GetPrev(MasterEn);
                if(PageEn != 0)
                    PageEn = (CDRLayerListItem *)PageLayers->GetPrev(PageEn);
            }

            // if it's a CDR 3 file translate it
            if(Version == CDRVERSION_3)
            {
                Trans2DMatrix Trans(TranslateByX, TranslateByY);
                pGroup->Transform(Trans);
            }

            // check to see if the group node has more than one child
            // if it doesn't just insert the child and not the group, and then
            // delete the group node afterwards
            NodeRenderableBounded *InsertNode = pGroup;

            NodeRenderableBounded *FirstChild = (NodeRenderableBounded *)pGroup->FindFirstChild();

            if(FirstChild != 0)
            {
                // if the first child hasn't got a sibling, then there's only one
                // child to the group, so just insert the child
                if(FirstChild->FindNext() == 0)
                    InsertNode = FirstChild;
            }

            // and slap the group into the document
            if (!Op->DoInsertNewNode(InsertNode, pSpread, TRUE))
            {
                // It didn't work - delete the sub-tree we just created
                pGroup->CascadeDelete();
                delete pGroup;
                pGroup = NULL;
                CDRFILTER_DI_RETURNERROR;
            }

            if(InsertNode != pGroup)
                delete pGroup;

            // optimise the attributes in our nice new group
            if(!InsertNode->OptimiseAttributes())
                CDRFILTER_DI_RETURNERROR;
        }
    }
    else
    {
        // if we were opening the document, then we need make a layer and set the insertation node
        if(!DestDoc->IsImporting())
        {
            if (!MakeSureLayerExists(DestDoc))
                CDRFILTER_DI_RETURNERROR;

            DestDoc->ResetInsertionPosition();
        }
    }

    // add some standard colours
    if(!AddStandardColourSet(pDocument))
        CDRFILTER_DI_RETURNERROR;

    // do a quick post import on it
    DestDoc->PostImport();
    
    // find out how many dodgy objects were encountered along the way
    INT32 ObjNotConv = ObjectsFormatWrong + ObjectsUnknown;

    if(ObjNotConv > 0)
    {
        // tell the user that some objects couldn't be converted
        String_256 WarnMsg;
        WarnMsg.MakeMsg((ObjNotConv == 1)?_R(IDT_CDRFILTER_OBJWARNING1):_R(IDT_CDRFILTER_OBJWARNING), ObjNotConv);
        Error::SetError(0, WarnMsg, 0);
        InformWarning();
        Error::ClearError();
    }

    if(EnvelopesApproximated > 0)
    {
        // tell the user that some envelopes were approximated
        String_256 WarnMsg;
        WarnMsg.MakeMsg((EnvelopesApproximated == 1)?_R(IDT_CDRFILTER_ENVAPPROXWARNING1):_R(IDT_CDRFILTER_ENVAPPROXWARNING), EnvelopesApproximated);
        Error::SetError(0, WarnMsg, 0);
        InformWarning();
        Error::ClearError();
    }

TRACEUSER( "Ben", _T("Do import finished\n"));
    return ClearUp();
}

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

>   BOOL CDRFilter::ProcessDoc(void)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22 03 95
    Inputs:     none
    Returns:    error flag
    Purpose:    Processes the root level doc chunk of a CDR file
    SeeAlso:    Filter

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

BOOL CDRFilter::ProcessDoc(void)
{
    BOOL InFillTable = FALSE;
    BOOL InOutlineTable = FALSE;
    BOOL InStyleTable = FALSE;
    BOOL InFontTable = FALSE;
    BOOL InArrowheadTable = FALSE;
    BOOL InPatternTable = FALSE;
    BOOL InBitmapTable = FALSE;
    BOOL GotPageInfo = FALSE;

    ADDR VectorListContents = 0;
    INT32 VectorListContentsSize;

TRACEUSER( "Ben", _T("In ProcessDoc\n"));

    // store the level we're working on
    UINT32 StartLevel = RIFF->GetObjLevel();

    do
    {
        switch(RIFF->GetObjType())
        {
            case RIFFOBJECTTYPE_LISTSTART:
                // list start - attributes are stored in lists
                switch(RIFF->GetObjChunkType())
                {
                    case cdrT_filt:     InFillTable = TRUE;         break;
                    case cdrT_otlt:     InOutlineTable = TRUE;      break;
                    case cdrT_stlt:     InStyleTable = TRUE;        break;
                    case cdrT_fntt:     InFontTable = TRUE;         break;
                    case cdrT_arrt:     InArrowheadTable = TRUE;    break;
                    case cdrT_bpft:     InPatternTable = TRUE;      break;
                    case cdrT_bmpt:     InBitmapTable = TRUE;       break;
                    default:                                        break;

                    case cdrT_vect:
                        // get the contents of this list for later
                        if(!RIFF->GetListContents(&VectorListContents, &VectorListContentsSize))
                            return FALSE;

                        // and skip to the end of it
                        if(!RIFF->SkipToListEnd(RIFF->GetObjLevel()))
                            return FALSE;
                        break;
                    
                    case cdrT_btxt:
                        if(Version == CDRVERSION_4)
                        {
                            // if we're in a version 4 file, this contains text for the paragraph text objects
                            if(!ProcessTextList4())
                                return FALSE;
                        }
                        break;
                }
                break;

            case RIFFOBJECTTYPE_LISTEND:
                switch(RIFF->GetObjChunkType())
                {
                    case cdrT_filt:     InFillTable = FALSE;        break;
                    case cdrT_otlt:     InOutlineTable = FALSE;     break;
                    case cdrT_stlt:     InStyleTable = FALSE;       break;
                    case cdrT_fntt:     InFontTable = FALSE;        break;
                    case cdrT_arrt:     InArrowheadTable = FALSE;   break;
                    case cdrT_bpft:     InPatternTable = FALSE;     break;
                    case cdrT_bmpt:     InBitmapTable = FALSE;      break;
                    default:                                        break;
                }
                break;

            case RIFFOBJECTTYPE_CHUNK:
                // got a chunk to be interested about!
                switch(RIFF->GetObjChunkType())
                {
                    case cdrT_fill:
                        if(InFillTable)
                            Fills.AddChunkToStore(RIFF);
                        break;

                    case cdrT_outl:
                        if(InOutlineTable)
                            Outlines.AddChunkToStore(RIFF);
                        break;

                    case cdrT_styd:
                        if(InStyleTable)
                            Styles.AddChunkToStore(RIFF);
                        break;

                    case cdrT_font:
                        if(InFontTable)
                            Fonts.AddChunkToStore(RIFF, Version);
                        break;

                    case cdrT_arrw:
                        if(InArrowheadTable)
                            Arrowheads.AddChunkToStore(RIFF);
                        break;

                    case cdrT_bmpf:
                        if(InPatternTable)
                            Patterns.AddChunkToStore(RIFF, TRUE, this);

                        UpdateProgress(TRUE);
                        break;

                    case cdrT_bmp:
                        // a couple of forced progress updates here to ensure a
                        // resonably often updated progress bar
                        UpdateProgress(TRUE);

                        if(InBitmapTable)
                            Bitmaps.AddChunkToStore(RIFF, FALSE, this);

                        UpdateProgress(TRUE);
                        break;

                    case cdrT_mcfg:
                        {   // get the chunk and read the page size
                            if(GotPageInfo)     // if we've already got it, then there's a problem with the file
                            {
TRACEUSER( "Ben", _T("mcfg chunk encountered twice in doc list\n"));                                
                                ERROR1(FALSE, _R(IDE_CDRFILTER_FORMATERROR));
                            }

                            if(!RIFF->AquireChunkData())
                                return FALSE;

                            cdrfPageInfo *i = (cdrfPageInfo *)RIFF->GetAquiredData();

                            ERROR3IF(i == 0, "No aquired data returned from RIFF chunk");

                            PageX = CDRDATA_WORD(i->PageX) * CDRCOORDS_TO_MILLIPOINTS;
                            PageY = CDRDATA_WORD(i->PageY) * CDRCOORDS_TO_MILLIPOINTS;
                            Landscape = (CDRDATA_WORD(i->Orientation) == cdrf_ORIENTATION_LANDSCAPE)?TRUE:FALSE;

                            GotPageInfo = TRUE;
                        }
                        break;

                    case cdrT_tspc:     // font style table for version 3
                        if(Version == CDRVERSION_3)
                        {
                            // store the font styles
                            if((FontStylesV3 = (ADDR)CCMalloc(RIFF->GetObjSize())) == 0)
                                return FALSE;

                            if(!RIFF->GetChunkData(FontStylesV3, RIFF->GetObjSize()))
                                return FALSE;
                        }
                        break;

                    case cdrT_ftbl:     // font name table for version 3
                        if(Version == CDRVERSION_3)
                        {
                            // store the font names
                            if((FontTableV3 = (ADDR)CCMalloc(RIFF->GetObjSize())) == 0)
                                return FALSE;

                            if(!RIFF->GetChunkData(FontTableV3, RIFF->GetObjSize()))
                                return FALSE;

                            // store number of entries
                            FontTableEntriesV3 = RIFF->GetObjSize() / sizeof(cdrfFontTableEntryV3);
                            
                            // cache the font names
                            cdrfFontTableEntryV3 *FT = (cdrfFontTableEntryV3 *)FontTableV3;
                            for(INT32 l = 0; l < FontTableEntriesV3; l++)
                            {
                                if(FT[l].Name[0] != '\0' && FT[l].Name[0] != ' ')
                                {
                                    //GetApplication()->GetFontManager()->CacheNamedFont(&String_64((TCHAR *)&