cmxexdc.cpp

Go to the documentation of this file.

// $Id: cmxexdc.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============================
 */
// CMX export device context

#include <math.h>
#include "camtypes.h"
//#include "ccfile.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "cmxexdc.h"
#include "cmxform.h"
#include "riffform.h"
//#include "docrect.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "colormgr.h"
//#include "colmodel.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "camelot.h"
#include "cversion.h"
#include "prvwflt.h"
//#include "extfilts.h"
#include "product.h"
#include "hardwaremanager.h"
using namespace oilHardwareManager;

CC_IMPLEMENT_DYNAMIC(CMXFutureUpdater, CCObject);
CC_IMPLEMENT_DYNAMIC(CMXFutureLength, CMXFutureUpdater);
CC_IMPLEMENT_DYNAMIC(CMXFutureNumber, CMXFutureUpdater);
CC_IMPLEMENT_DYNAMIC(CMXFutureIndex, CMXFutureUpdater);
CC_IMPLEMENT_DYNAMIC(CMXReferListItem, ListItem);
CC_IMPLEMENT_DYNAMIC(CMXReferListItemOffset, CMXReferListItem);
CC_IMPLEMENT_DYNAMIC(CMXReferLayer, CMXReferListItemOffset);
CC_IMPLEMENT_DYNAMIC(CMXReferMasterIndex, CMXReferListItemOffset);
CC_IMPLEMENT_DYNAMIC(CMXReferPage, CMXReferListItemOffset);
CC_IMPLEMENT_DYNAMIC(CMXReferMasterLayer, CMXReferListItemOffset);
CC_IMPLEMENT_DYNAMIC(CMXReferColour, CMXReferListItem);
CC_IMPLEMENT_DYNAMIC(CMXReferDefaultScreen, CMXReferListItem);
CC_IMPLEMENT_DYNAMIC(CMXReferDefaultDotDash, CMXReferDotDash);
CC_IMPLEMENT_DYNAMIC(CMXReferPen, CMXReferListItem);
CC_IMPLEMENT_DYNAMIC(CMXReferArrowheads, CMXReferListItem);
CC_IMPLEMENT_DYNAMIC(CMXReferArrow, CMXReferListItem);
CC_IMPLEMENT_DYNAMIC(CMXReferLens, CMXReferListItem);
CC_IMPLEMENT_DYNAMIC(CMXReferLineStyle, CMXReferListItem);
CC_IMPLEMENT_DYNAMIC(CMXReferOutline, CMXReferListItem);
CC_IMPLEMENT_DYNAMIC(CMXReferBitmap, CMXReferListItem);
CC_IMPLEMENT_DYNAMIC(CMXReferBitmapFill, CMXReferListItem);
CC_IMPLEMENT_DYNAMIC(CMXReferDotDash, CMXReferListItem);
CC_IMPLEMENT_DYNAMIC(CMXGroupRecord, ListItem);
CC_IMPLEMENT_DYNAMIC(CMXNestedTagRecord, ListItem);
CC_IMPLEMENT_DYNAMIC(CMXLensBBox, ListItem);

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

>   CMXFutureUpdater::CMXFutureUpdater()

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    21/06/96
    Inputs:     none
    Returns:    none
    Purpose:    constructor
    SeeAlso:    

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

CMXFutureUpdater::CMXFutureUpdater()
{
    AbsPosition = -1;
    DataSize = 0;
}


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

>   CMXFutureUpdater::CMXFutureUpdater()

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    21/06/96
    Inputs:     none
    Returns:    none
    Purpose:    destructor
    SeeAlso:    

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

CMXFutureUpdater::~CMXFutureUpdater()
{
    if(AbsPosition >= 0)
        TRACEUSER( "Ben", _T("AWWOOOOGA! CMXFutureUpdated deleted, but not written\n\n"));
}


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

>   BOOL CMXFutureUpdater::Init(CMXExportDC *pDC, INT32 RelativePos, UINT32 DataSize)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    21/06/96
    Inputs:     export dc, relative position (+ve = forwards in file), size of data
    Returns:    none
    Purpose:    initialises a updater object
    SeeAlso:    

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

BOOL CMXFutureUpdater::Init(CMXExportDC *pDC, INT32 RelativePos, UINT32 tDataSize)
{
    ERROR2IF(AbsPosition >= 0, FALSE, "Updater already initialised");
    ERROR2IF(pDC == 0, FALSE, "No pDC, chaps");
    ERROR2IF(DataSize < 0 || DataSize > 4, FALSE, "Bit of a data size problem really");

    INT32 CurrentPos = pDC->GetFilePosition();
    ERROR2IF(CurrentPos < 0, FALSE, "Whoops -- negative file position here");
    AbsPosition = CurrentPos + RelativePos;
    ERROR2IF(AbsPosition < 0, FALSE, "Serious Bummer -- expected to update a position before the start of the file");
    DataSize = tDataSize;

    return TRUE;
}

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

>   BOOL CMXFutureUpdater::WriteValue(CMXExportDC *pDC, INT32 Value)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    21/06/96
    Inputs:     export dc, value
    Returns:    none
    Purpose:    writes a value to the file
    SeeAlso:    

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

BOOL CMXFutureUpdater::WriteValue(CMXExportDC *pDC, INT32 Value)
{
    ERROR2IF(pDC == 0, FALSE, "No pDC, chaps");

    // write the number
    if(!pDC->WriteNumber(AbsPosition, DataSize, Value))
        return FALSE;

    // reset everything for the next run, should we want one.
    AbsPosition = -1;
    DataSize = 0;
    Reset();            // get the derivedness to reset itself too.

    return TRUE;
}


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

>   CMXFutureLength::CMXFutureLength()

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    21/06/96
    Inputs:     none
    Returns:    none
    Purpose:    constructor
    SeeAlso:    

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

CMXFutureLength::CMXFutureLength()
{
    StartPos = -1;
}

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

>   BOOL CMXFutureLength::SetLengthStartPos(CMXExportDC *pDC, INT32 RelativePos);

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    21/06/96
    Inputs:     export dc, relative position from current position (+ve is forwards)
    Returns:    none
    Purpose:    sets the start position of the length which is to be written
    SeeAlso:    

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

BOOL CMXFutureLength::SetLengthStartPos(CMXExportDC *pDC, INT32 RelativePos)
{
    ERROR2IF(StartPos >= 0, FALSE, "Start position already set");
    ERROR2IF(pDC == 0, FALSE, "No dc");
    StartPos = pDC->GetFilePosition() + RelativePos;

    return TRUE;
}


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

>   void CMXFutureLength::Reset(void)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    21/06/96
    Inputs:     export dc, relative position from current position (+ve is forwards)
    Returns:    none
    Purpose:    resets the future updater object after a write
    SeeAlso:    

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

void CMXFutureLength::Reset(void)
{
    StartPos = -1;
}


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

>   BOOL CMXFutureLength::Write(CMXExportDC *pDC)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    21/06/96
    Inputs:     export dc
    Returns:    none
    Purpose:    writes the length to the file. The length is the (+ve) value from the
                start position set earlier to the current position in the file.
    SeeAlso:    

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

BOOL CMXFutureLength::Write(CMXExportDC *pDC)
{
    ERROR2IF(pDC == 0, FALSE, "No dc");
    ERROR2IF(StartPos < 0, FALSE, "StartPos is negative... has this length been initialised properly?");

    INT32 len = pDC->GetFilePosition() - StartPos;

    ERROR2IF(len < 0, FALSE, "We're talking negative lengths here? I don't think so");
    
    return WriteValue(pDC, len);
}

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

>   BOOL CMXFutureIndex::Write(CMXExportDC *pDC)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    21/06/96
    Inputs:     export dc
    Returns:    none
    Purpose:    writes the index to the file. The index is the current file position.
    SeeAlso:    

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

BOOL CMXFutureIndex::Write(CMXExportDC *pDC)
{
    ERROR2IF(pDC == 0, FALSE, "No dc");

    return WriteValue(pDC, pDC->GetFilePosition());
}


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

>   BOOL CMXFutureIndex::Write(CMXExportDC *pDC)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    21/06/96
    Inputs:     export dc
    Returns:    none
    Purpose:    writes the number to the file
    SeeAlso:    

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

BOOL CMXFutureNumber::Write(CMXExportDC *pDC)
{
    ERROR2IF(pDC == 0, FALSE, "No dc");

    return WriteValue(pDC, Number);
}

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

>   CMXReferListItemOffset::CMXReferListItemOffset(CMXExportDC *pDC)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    21/06/96
    Inputs:     export dc
    Returns:    none
    Purpose:    constructs the refer list item by getting the offset
    SeeAlso:    

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

CMXReferListItemOffset::CMXReferListItemOffset(CMXExportDC *pDC)
    : CMXReferListItem(pDC)
{
    Offset = pDC->GetFilePosition();        // will throw an exception if it goes wrong
}


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

>   void CMXReferLayer::SetLayerDetails(WORD Number, String_256 *tName)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    26/06/96
    Inputs:     layer number, name
    Returns:    none
    Purpose:    sets the layer details
    SeeAlso:    

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

void CMXReferLayer::SetLayerDetails(WORD Number, String_256 *tName)
{
    LayerNumber = Number;
    Name = *tName;
}


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

>   BOOL CMXReferLayer::WriteInReferenceList(CMXExportDC *pDC)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    26/06/96
    Inputs:     export dc
    Returns:    sucess
    Purpose:    writes the relevant entry in the reference list of the file
    SeeAlso:    

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

BOOL CMXReferLayer::WriteInReferenceList(CMXExportDC *pDC)
{
    ERROR2IF(pDC == 0, FALSE, "no DC");

    // write the entry
    cmxRefListEntryRef en;
    memset(&en, '\0', sizeof(en));

    en.Association = cmxREFLISTEN_DESC_COMPONENT;
    en.Type = cmxREFLISTEN_TYPE_LAYER;
    en.ReferenceNumber = LayerNumber;

    pDC->WriteData(&en, sizeof(en));

    return TRUE;
}


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

>   INT32 CMXReferLayer::IndexEntrySize(CMXExportDC *pDC)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    26/06/96
    Inputs:     none
    Returns:    length of entry we'll write
    Purpose:    gets the length of the entry we'll write in the index
    SeeAlso:    

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

INT32 CMXReferLayer::IndexEntrySize(CMXExportDC *pDC)
{
    ERROR2IF(pDC == NULL, 0, "no dc");
    
    INT32 StrLen = Name.Length();

    return StrLen + sizeof(WORD) + sizeof(DWORD) * 2 + ((pDC->IsThirtyTwoBit())?sizeof(WORD):0);
}


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

>   BOOL CMXReferLayer::WriteInIndex(CMXExportDC *pDC)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    26/06/96
    Inputs:     export dc
    Returns:    none
    Purpose:    writes the layer details in the layer list
    SeeAlso:    

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

BOOL CMXReferLayer::WriteInIndex(CMXExportDC *pDC)
{
    // write size in file
    pDC->WriteSizeInFile(Name.Length() + sizeof(DWORD) * 2);

    DWORD tOffset = Offset;
    pDC->WriteData(&tOffset, sizeof(tOffset));

    pDC->WriteString(&Name);

    SDWORD RefList = -1;
    pDC->WriteData(&RefList, sizeof(RefList));

    return TRUE;
}


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

>   BOOL CMXReferPage::WriteInIndex(CMXExportDC *pDC)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    26/06/96
    Inputs:     export dc
    Returns:    none
    Purpose:    writes the page details in the layer list
    SeeAlso:    

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

BOOL CMXReferPage::WriteInIndex(CMXExportDC *pDC)
{

    // write the entry
    cmxPageIndexEntry pe;

    // write size in file
    pDC->WriteSizeInFile(sizeof(pe));

    pe.PageOffset = Offset;
    pe.LayerTableOffset = LayerTableOffset;
    pe.ThumbnailOffset = 0;
    pe.RefListOffset = RefListOffset;

    if(!pDC->WriteData(&pe, sizeof(pe)))
        return FALSE;

    return TRUE;
}


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

>   BOOL CMXReferDefaultScreen::WriteInDesc(CMXExportDC *pDC)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    26/06/96
    Inputs:     export dc
    Returns:    none
    Purpose:    writes the default screen list entry -- same as the default one corel writes
    SeeAlso:    

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

BOOL CMXReferDefaultScreen::WriteInDesc(CMXExportDC *pDC)
{
    if(pDC->IsThirtyTwoBit())
    {
        cmxScreenDef32 scrdef = {0,0,0,0,0};

        if(!pDC->WriteTag(cmxTAG_DescrSection_Screen_Basic, &scrdef, sizeof(scrdef))
            || !pDC->WriteMinEndTag())
            return FALSE;
    }
    else
    {
        cmxScreenDef16 scrdef = {0,0,0,0};

        if(!pDC->WriteData(&scrdef, sizeof(scrdef)))
            return FALSE;
    }

    return TRUE;
}


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

>   BOOL CMXReferDefaultDotDash::WriteInDesc(CMXExportDC *pDC)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    26/06/96
    Inputs:     export dc
    Returns:    none
    Purpose:    writes the default dot dash list entry
    SeeAlso:    

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

BOOL CMXReferDefaultDotDash::WriteInDesc(CMXExportDC *pDC)
{
    WORD DotCount = 0;

    if(!pDC->WriteTag(cmxTAG_DescrSection_Dash, &DotCount, sizeof(DotCount))
        || !pDC->WriteMinEndTag())
        return FALSE;

    return TRUE;
}


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

>   BOOL CMXReferColour::WriteInDesc(CMXExportDC *pDC)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    26/06/96
    Inputs:     export dc
    Returns:    none
    Purpose:    writes the colour to the DC in a description list
    SeeAlso:    

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

BOOL CMXReferColour::WriteInDesc(CMXExportDC *pDC)
{
    ColourModel OutputModel;
    struct {
        BYTE ColType;
        BYTE Palette;
    } ColH;
    ColH.Palette = 5;       // user palette

    // Work out which CMX colour type we will export as, and therefore which internal
    // colour model we should convert the colour to.
    switch (Colour.GetColourModel())
    {
        case COLOURMODEL_HSVT:
            OutputModel = COLOURMODEL_HSVT;
            ColH.ColType = cmxCOLMODEL_HSB;
            break;

        case COLOURMODEL_CMYK:
            OutputModel = COLOURMODEL_CMYK;
            ColH.ColType = cmxCOLMODEL_CMYK255;
            break;

        case COLOURMODEL_GREYT:
            OutputModel = COLOURMODEL_GREYT;
            ColH.ColType = cmxCOLMODEL_GREY;
            break;
        
        case COLOURMODEL_RGBT:
        default:
            // It's RGB, or we don't know the model, so we'll output it as RGB
            OutputModel = COLOURMODEL_RGBT;
            ColH.ColType = cmxCOLMODEL_RGB;
            break;
    }

    // write the header tag
    if(!pDC->WriteTag(cmxTAG_DescrSection_Color_Base, &ColH, sizeof(ColH)))
        return FALSE;

    // Find an appropriate colour context to convert the colour for output
    ColourContext *OutputCC = ColourManager::GetColourContext(OutputModel);
    ERROR3IF(OutputCC == NULL, "Can't find a colour context");

    // Convert the colour into a packed format
    ColourPacked Result;
    OutputCC->ConvertColour(&Colour, &Result);

    // start the tag
    if(!pDC->StartTag(cmxTAG_DescrSection_Color_ColorDescr))
        return FALSE;

    // Pull the converted colour out and export it to the CMX file
    switch (OutputModel)
    {
        case COLOURMODEL_HSVT:
            {
/*TRACEUSER( "Ben", _T("HSV colour: hue %d, sat %d, val %d\n"), Result.HSVT.Hue, Result.HSVT.Saturation, Result.HSVT.Value);
            WORD Hue = Result.HSVT.Hue;
            pDC->WriteData(&Hue, sizeof(Hue));
            pDC->WriteByte(Result.HSVT.Saturation);
            pDC->WriteByte(Result.HSVT.Value); */

                // BODGE because the colour system can't convert HSVT properly yet
            ColourHSVT GResult;
            OutputCC->ConvertColour(&Colour, (ColourGeneric *)&GResult);

            WORD Hue = (WORD)(360.0 * GResult.Hue.MakeDouble());
            pDC->WriteData(&Hue, sizeof(Hue));
            pDC->WriteByte((BYTE)(255.0 * GResult.Saturation.MakeDouble()));
            pDC->WriteByte((BYTE)(255.0 * GResult.Value.MakeDouble()));
            }
            break;

        case COLOURMODEL_CMYK:
TRACEUSER( "Ben", _T("CMYK colour: cyan %d mag %d yel %d key %d\n"), Result.CMYK.Cyan, Result.CMYK.Magenta, Result.CMYK.Yellow, Result.CMYK.Key);
            pDC->WriteByte(Result.CMYK.Cyan);
            pDC->WriteByte(Result.CMYK.Magenta);
            pDC->WriteByte(Result.CMYK.Yellow);
            pDC->WriteByte(Result.CMYK.Key);
            break;

        case COLOURMODEL_GREYT:
TRACEUSER( "Ben", _T("grey colour: grey %d\n"), Result.GreyT.Intensity);
            pDC->WriteByte(Result.GreyT.Intensity);
            break;

        case COLOURMODEL_RGBT:
        default:
TRACEUSER( "Ben", _T("RGB colour: red %d green %d blue %d\n"), Result.RGBT.Red, Result.RGBT.Green, Result.RGBT.Blue);
            pDC->WriteByte(Result.RGBT.Red);
            pDC->WriteByte(Result.RGBT.Green);
            pDC->WriteByte(Result.RGBT.Blue);
            break;
    }

    // end the tag
    if(!pDC->EndTag())
        return FALSE;

    // write the end tag
    if(!pDC->WriteMinEndTag())
        return FALSE;

    return TRUE;
}


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

>   BOOL CMXReferMasterIndex::WriteInIndex(CMXExportDC *pDC)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    26/06/96
    Inputs:     export dc
    Returns:    none
    Purpose:    writes the index details in the master index
    SeeAlso:    

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

BOOL CMXReferMasterIndex::WriteInIndex(CMXExportDC *pDC)
{
    // write the entry
    cmxMasterIndexEntry me;

    me.Type = Type;
    me.Offset = Offset;

TRACEUSER( "Ben", _T("Writing entry in master index, type = %d, offset = %x = %d, size = %d\n"), Type, Offset, Offset, sizeof(me));

    if(!pDC->WriteData(&me, sizeof(me)))
        return FALSE;

    return TRUE;
}


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

>   BOOL CMXReferMasterIndex::WriteInIndex(CMXExportDC *pDC)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    26/06/96
    Inputs:     export dc
    Returns:    none
    Purpose:    writes the index details in the master index
    SeeAlso:    

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

BOOL CMXReferMasterLayer::WriteInIndex(CMXExportDC *pDC)
{
    // write the entry
    if(pDC->IsThirtyTwoBit())
    {
        cmxMasterLayerEntry32 le;       // note that this is the entire table, not an entry

        le.TableType = cmxMASTERIN_MASTERLAYER;     // quite why we need this is another matter
        le.SizeInFile = sizeof(DWORD);
        le.ID = 1;                  // first page, I presume
        le.Offset = Offset;         // offset...

        if(!pDC->WriteData(&le, sizeof(le)))
            return FALSE;
    }
    else
    {
        cmxMasterLayerEntry16 le;       // note that this is the entire table, not an entry

        le.TableType = cmxMASTERIN_MASTERLAYER;     // quite why we need this is another matter
        le.ID = 1;                  // first page, I presume
        le.Offset = Offset;         // offset...

        if(!pDC->WriteData(&le, sizeof(le)))
            return FALSE;
    }

    return TRUE;
}


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

>   CMXExportDC::CMXExportDC(Filter *Parent)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    18/6/96
    Inputs:     The filter object associated with this export DC.
    Purpose:    Initialise a DC for exporting EPS.

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

CMXExportDC::CMXExportDC(Filter *Parent) : ExportDC(Parent)
{
}



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

>   BOOL CMXExportDC::Init(CCLexFile* pFile, CMXRenderRegion *pReg, BOOL bThirtyTwoBit)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    18/6/96
    Inputs:     pFile - The file to attach to the DC
    Returns:    TRUE if all went well, FALSE if not
    Purpose:    Calls the base class Init function and then sets up the DC to throw exceptions
                when it gets errors as that is how the EPS stuff expects errors to be reported.
    SeeAlso:    ExportDC::Init

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

BOOL CMXExportDC::Init(CCLexFile* pFile, CMXRenderRegion *pReg, BOOL bThirtyTwoBit, BOOL ClipboardExport)
{
    // First get the base class to do its thing
    if (!ExportDC::Init(pFile)) return FALSE;

    // now do what I want done.
    // We want export files to throw exceptions, and not report errors.
    ExportFile->SetThrowExceptions(TRUE);
    ExportFile->SetReportErrors(FALSE);

    // set the bitness of the file
    ThirtyTwoBit = bThirtyTwoBit;

    // mark the fact that we've not actually doing a section at all
    CurrentSection = CMXSECTION_NONE;

    // set up a few more variables
    DoingCommand = FALSE;
    DoingPage = FALSE;
    DoingLayer = FALSE;
    PageRefer = NULL;
    DoingTag = FALSE;
    pMatrix = NULL;
    NestedTagLevel = 0;
    CurrentInstrFilePosition = -1;
    pRenderRegion = pReg;
    DoingRIFFList = FALSE;
    NumberOfEntriesUsedInCache = 0;

    // overlapped lenses flag
    if(!ClipboardExport)
    {
        // normal ask the user mode
        AreIgnoreingOverlappedLenses = FALSE;
        OverlappedLensesHaveBeenIgnored = FALSE;
        HaveAskedUserAboutLenses = FALSE;
    }
    else
    {
        // don't ask the user
        AreIgnoreingOverlappedLenses = TRUE;
        OverlappedLensesHaveBeenIgnored = FALSE;
        HaveAskedUserAboutLenses = TRUE;
    }

    for(INT32 i = 0 ; i < CMXFUTUREVALUECACHESIZE ; i++)
    {
        //  init the write-cache 
        FutureDataCache[i].Location = INT32_MAX;
        FutureDataCache[i].Data     = 0;
        FutureDataCache[i].DataSize = 0;
    }

    // pop in the default screen thingy
    CMXReferDefaultScreen *pDefScreen = new CMXReferDefaultScreen(this);
    if(pDefScreen == NULL) return FALSE;

    // and add it to the list
    ReferList.AddTail(pDefScreen);

    // pop in the default dot dash thingy
    CMXReferDefaultDotDash *pDefdd = new CMXReferDefaultDotDash(this);
    if(pDefdd == NULL) return FALSE;

    // and add it to the list
    ReferList.AddTail(pDefdd);
    return TRUE;
}

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

>   void CMXExportDC::CleanUp(void)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    26/06/96
    Inputs:     none
    Returns:    none
    Purpose:    Cleans up after writing to a file
    SeeAlso:    

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

void CMXExportDC::CleanUp(void)
{
    WriteFutureDataCache();
    ReferList.DeleteAll();
    LensBBoxes.DeleteAll();
}


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

>   BOOL CMXExportDC::StartSection(CMXSectionType Type)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    18/6/96
    Inputs:     The type of section to start
    Returns:    success
    Purpose:    Start writing a section to a CMX file
    SeeAlso:    

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

BOOL CMXExportDC::StartSection(CMXSectionType Type)
{
    ERROR2IF(CurrentSection != CMXSECTION_NONE, FALSE, "Tried to start a section without ending the previous one");

    // write the riff file header
    // first, decide what riff chunck id we want
    DWORD id;
    BOOL IsAList = FALSE;           // whether in fact it's a list
    switch(Type)
    {
    case CMXSECTION_NONE:
        ERROR2(FALSE, "Tried to start a section of type none. Oh dear");
        break;
    case CMXSECTION_HEADER:     id = cmxRIFFCI_Header;          break;
    case CMXSECTION_PAGE:       id = cmxRIFFCI_Page;            break;
    case CMXSECTION_REFLIST:    id = cmxRIFFCI_ReferenceList;   break;
    case CMXSECTION_INDEX:      id = cmxRIFFLIST_Index; IsAList=TRUE;   break;
    case CMXSECTION_TRAILER:    id = cmxRIFFLIST_Trail; IsAList=TRUE;   break;
    case CMXSECTION_ARROW:      id = cmxRIFFCI_Desc_Arrow;      break;
    case CMXSECTION_ARROWHEADS: id = cmxRIFFCI_Desc_Arrowheads; break;
    case CMXSECTION_COLOUR:     id = cmxRIFFCI_Desc_Colour;     break;
    case CMXSECTION_DOTDASH:    id = cmxRIFFCI_Desc_DotDash;    break;
    case CMXSECTION_FONT:       id = cmxRIFFCI_Desc_Font;       break;
    case CMXSECTION_OUTLINE:    id = cmxRIFFCI_Desc_Outline;    break;
    case CMXSECTION_LINESTYLE:  id = cmxRIFFCI_Desc_LineStyle;  break;
    case CMXSECTION_PEN:        id = cmxRIFFCI_Desc_Pen;        break;
    case CMXSECTION_LENS:       id = cmxRIFFCI_Desc_Lens;       break;
    case CMXSECTION_SCREEN:     id = cmxRIFFCI_Desc_Screen;     break;
    case CMXSECTION_IMAGINFO:   id = cmxRIFFCI_ImageInfo;       break;
    case CMXSECTION_IMAGDATA:   id = cmxRIFFCI_ImageData;       break;
    case CMXSECTION_PROCBITFILL:id = cmxRIFFCI_Procedure;       break;
    case CMXSECTION_PREVIEWBITMAP: id = cmxRIFFCI_Thumbnail;    break;
    default:
        ERROR2(FALSE, "Unknown section type");
        break;
    }

    // OK, write the RIFF header
    RIFFck chdr;
    chdr.ckID = IsAList?RIFFTYPE_LIST:id;
    chdr.ckSize = 0;
    ExportFile->write(&chdr, sizeof(chdr));

    // set the future length
    SectionLengthFuture.Init(this, FUTURE_BACKLOC(&chdr, ckSize), sizeof(chdr.ckSize));
    SectionLengthFuture.SetLengthStartPos(this, 0 /* - (INT32)sizeof(chdr)*/);

    // write the list type, if we're doing a list
    if(IsAList)
        ExportFile->write(&id, sizeof(id));

    // note which section type we just did
    CurrentSection = Type;
    
    return TRUE;
}


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

>   BOOL CMXExportDC::EndSection(void)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    24/06/96
    Inputs:     none
    Returns:    success
    Purpose:    Finish off writing a section to a CMX file
    SeeAlso:    

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

BOOL CMXExportDC::EndSection(void)
{
    ERROR2IF(CurrentSection == CMXSECTION_NONE, FALSE, "Tried to end a section which didn't exist");

    // write the length
    SectionLengthFuture.Write(this);

    // set the section type to none
    CurrentSection = CMXSECTION_NONE;

    // word align the file
    if((GetFilePosition() & 1) != 0)
    {
        // put an extra byte in the file
        ExportFile->put('\0');
    }

    return TRUE;
}


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

>   BOOL CMXExportDC::StartRIFFList(INT32 Type)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    16/07/96
    Inputs:     The type of section to start
    Returns:    success
    Purpose:    Start writing a section to a CMX file
    SeeAlso:    

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

BOOL CMXExportDC::StartRIFFList(INT32 Type)
{
    ERROR2IF(DoingRIFFList, FALSE, "Tried to start a riff list without ending the previous one");

    // write the riff list header
    RIFFck chdr;
    chdr.ckID = RIFFTYPE_LIST;
    chdr.ckSize = 0;
    ExportFile->write(&chdr, sizeof(chdr));

    // set the future length
    RIFFListLengthFuture.Init(this, FUTURE_BACKLOC(&chdr, ckSize), sizeof(chdr.ckSize));
    RIFFListLengthFuture.SetLengthStartPos(this, 0);

    // write the list type, if we're doing a list
    DWORD id = Type;
    ExportFile->write(&id, sizeof(id));

    // flag...
    DoingRIFFList = TRUE;
    
    return TRUE;
}


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

>   BOOL CMXExportDC::EndRIFFList(void)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    16/07/96
    Inputs:     none
    Returns:    success
    Purpose:    Finish off writing a section to a CMX file
    SeeAlso:    

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

BOOL CMXExportDC::EndRIFFList(void)
{
    ERROR2IF(!DoingRIFFList, FALSE, "Tried to end a riff list which didn't exist");

    // write the length
    RIFFListLengthFuture.Write(this);

    // word align the file
    if((GetFilePosition() & 1) != 0)
    {
        // put an extra byte in the file
        ExportFile->put('\0');
    }

    // flag
    DoingRIFFList = FALSE;

    return TRUE;
}


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

>   BOOL CMXExportDC::StartTag(INT32 Tag)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    27/06/96
    Inputs:     Tag for the command
    Returns:    success
    Purpose:    starts writing a tag to the file
    SeeAlso:    

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

BOOL CMXExportDC::StartTag(INT32 Tag)
{
    if(!ThirtyTwoBit)
        return TRUE;        // 16 bit files don't have tags

    ERROR2IF(DoingTag == TRUE, FALSE, "already doing a tag");

    // write the tag header
    cmxTagHdr hdr;
    hdr.ID = (BYTE)Tag;
    hdr.Size = 0;
    ExportFile->write(&hdr, sizeof(hdr));

    // initialise the future value
    TagLengthFuture.Init(this, FUTURE_BACKLOC(&hdr, Size), sizeof(hdr.Size));
    TagLengthFuture.SetLengthStartPos(this, 0-(INT32)sizeof(hdr));

    // flag
    DoingTag = TRUE;

    return TRUE;
}

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

>   BOOL CMXExportDC::EndTag(void)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    27/06/96
    Inputs:     none
    Returns:    success
    Purpose:    ends a tag
    SeeAlso:    

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

BOOL CMXExportDC::EndTag(void)
{
    if(!ThirtyTwoBit)
        return TRUE;        // 16 bit files don't have tags

    ERROR2IF(DoingTag == FALSE, FALSE, "not doing a tag");
    ERROR2IF(NestedTagLevel != 0, FALSE, "tried to end a main tag when nested tags are active");

    // write the length
    TagLengthFuture.Write(this);

    // flag
    DoingTag = FALSE;

    return TRUE;
}


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

>   BOOL CMXExportDC::StartNestedTag(INT32 Tag)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    27/06/96
    Inputs:     Tag for the command
    Returns:    success
    Purpose:    starts writing a nested tag to the file
    SeeAlso:    

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

BOOL CMXExportDC::StartNestedTag(INT32 Tag)
{
    if(!ThirtyTwoBit)
        return TRUE;        // 16 bit files don't have tags

    ERROR2IF(DoingTag == FALSE, FALSE, "tried to start a nested tag outside a tag");

    // write the tag header
    cmxTagHdr hdr;
    hdr.ID = (BYTE)Tag;
    hdr.Size = 0;
    ExportFile->write(&hdr, sizeof(hdr));

    // get one of those nested tag record things
    CMXNestedTagRecord *pRec = new CMXNestedTagRecord;
    if(pRec == NULL)
        return FALSE;

    // initialise the future value
    pRec->LengthFuture.Init(this, FUTURE_BACKLOC(&hdr, Size), sizeof(hdr.Size));
    pRec->LengthFuture.SetLengthStartPos(this, 0-(INT32)sizeof(hdr));

    // add the record to the list
    NestedTagList.AddTail(pRec);

    // flag
    NestedTagLevel++;

    return TRUE;
}

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

>   BOOL CMXExportDC::EndNestedTag(void)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    04/07/96
    Inputs:     none
    Returns:    success
    Purpose:    ends a nested tag
    SeeAlso:    

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