sgliboil.cpp

Go to the documentation of this file.

// $Id: sgliboil.cpp 1664 2006-08-04 10:06:16Z gerry $
/* @@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============================
 */
// SGLibOil.cpp - Library OIL code

#include "camtypes.h"
#include "sgliboil.h"

//#include "app.h"      // For GetApplication() - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "galstr.h"
//#include "pathname.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "sginit.h"
//#include "sglcart.h"  // This .cpp file's corresponding header
//#include "sglib.h"
//#include "sgfonts.h"
//#include "sgscan.h"       // Generate code with hourglass...
//#include "sgscanf.h"      // Generate code with hourglass...
//#include "thumb.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "ccdc.h"       // For render-into-dialogue support
//#include "fillval.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "grnddib.h"
//#include "galres.h"
//#include "richard.h"
//#include "errors.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "oilfltrs.h"
//#include "tim.h"
//#include "nev.h"
//#include "fixmem.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "selop.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "filedlgs.h"
//#include "scrcamvw.h" // PageDropInfo
//#include "resource.h" // _R(IDS_CANCEL)
#include "dlgmgr.h"
//#include "bitmap.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "oilbitmap.h"
//#include "dibutil.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "reshlpid.h"
#include "progress.h"
#include "helpuser.h"
//#include "reshlpid.h"
//#include "sgindgen.h"
//#include "ctrlhelp.h"
//#include "richard2.h"
//#include "richard3.h"
#include "camelot.h"
#include "camdoc.h"
#include "unicdman.h"
//#include "fonts.h"
//#include "camfiltr.h" // BaseCamelotFilter - version 2 native filter - in camtypes.h [AUTOMATICALLY REMOVED]
#include "cxftags.h"    // TAG_DEFINEBITMAP_****
#include "cxfile.h"     // CXF_UNKNOWN_SIZE
//#include "cxfrech.h"  // CXaraFileRecordHandler - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "expcol.h"       // ExportedColours handling class
//#include "cxfrec.h"       // CXaraFileRecord handler - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "webster.h"
#include "pathnmex.h"
//#include "docview.h"      // For DocView::GetCentreImportPosition - in camtypes.h [AUTOMATICALLY REMOVED]

//#include "attrmgr.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "fillattr.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "backgrnd.h" // OpBackground
#include "nodebmp.h"    // OpCreateBitmapNode
#include "product.h"    // PROGRAM_NAME macro

//#include <io.h>           // for FileExists
//#include <stdio.h>
//#include <commdlg.h>  // For GetLibPath
//#include <dlgs.h>
//#include <stdlib.h>
//#include <mmsystem.h>

//#include <sys\stat.h> // FileModified

#if defined(__WXMSW__)
#include <shfolder.h>   // For SHGetFolderPath
#endif

extern void FixFPControlRegister(void);

// Implement the dynamic class bits...
PORTNOTE("dialog","Removed OpClipartImport")
#ifndef EXCLUDE_FROM_XARALX
CC_IMPLEMENT_DYNCREATE(OpClipartImport, SelOperation)
#endif
PORTNOTE("dialog","Removed OpBitmapImport")
#ifndef EXCLUDE_FROM_XARALX
CC_IMPLEMENT_DYNCREATE(OpBitmapImport, Operation)
#endif
CC_IMPLEMENT_DYNCREATE(SGLibOil, CCObject)

// This line mustn't go before any CC_IMPLEMENT_... macros
// Declare smart memory handling in Debug builds
#define new CAM_DEBUG_NEW

extern BOOL getDrive(const TCHAR**, TCHAR* drive);
extern BOOL getNetDrive(const TCHAR**, TCHAR* drive, BOOL *BadCharacter);

TCHAR *SGLibOil::TmpSndName = NULL;

// Define or undefine this to enable / disable the checking of network drive serial numbers
// for the inhouse 'FindCD' code... It's safe to leave in in release versions because it checks
// serial numbers of drives, which are never the same... The code's never called if they aren't
// connected to a network, or don't have their network mounts assigned to drive letters...
#define SCANFORXARAMOUNT

#if defined(__WXMSW__)
const TCHAR             chPathSep = _T('\\');
#else
const TCHAR             chPathSep = _T('/');
#endif

PORTNOTE("dialog","Removed OpClipartImport impl.")
#ifndef EXCLUDE_FROM_XARALX

// Constructor for ClipartImportParam,
// Makes sure the parameter defaults are sensible
ClipartImportParam::ClipartImportParam()
{
    File        = NULL;
    Import      = FALSE;
    Result      = FALSE;
    DropInfo    = NULL;
}


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

>   OpClipartImport::OpClipartImport() : UndoableOperation()

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    20/3/95
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    OpClipartImport constructor (Creates an undoable operation)
    SeeAlso:

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

OpClipartImport::OpClipartImport() : SelOperation()
{
    OpFlags.HasOwnTimeIndicator = TRUE; // The OpMenuImport op has its own time indicator
}       

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

>   OpClipartImport::~OpClipartImport() 

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    20/3/95
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    OpClipartImport destructor
    Errors:     -
    SeeAlso:    -

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

OpClipartImport::~OpClipartImport()
{
}

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

>   BOOL OpClipartImport::Init()

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    20/3/95
    Returns:    FALSE if it fails (due to lack of memory)
    Purpose:    Creates an OpDescriptor for an ClipartImport operation
    SeeAlso:

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

BOOL OpClipartImport::Init()
{  
    OpBitmapImport::Init();
    OpAsynchBitmapImport::Init();

    return RegisterOpDescriptor(
        0,                              // Tool ID
        _R(IDS_OPCLIPARTIMPORT),                // String resource ID
        CC_RUNTIME_CLASS(OpClipartImport),  // Runtime class
        OPTOKEN_OPCLIPARTIMPORT,            // Token string
        OpClipartImport::GetState,          // GetState function
        0,                              // Help ID
        0,                              // Bubble ID
        0,                              // Resource ID
        0                               // Control ID
//  needs   'GREY_WHEN_NO_CURRENT_DOC'
    );
}   

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

>   OpState OpClipartImport::GetState(String_256* pString, OpDescriptor* pOpDesc)

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    20/3/95
    Purpose:    Returns the OpState of the OpClipartImport operation.
    SeeAlso:

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

OpState OpClipartImport::GetState(String_256* pString, OpDescriptor* pOpDesc)
{
    //OpState OpSt;
    OpState OpSt;

    return(OpSt);
}

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

>   void OpClipartImport::Do(OpDescriptor*)

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    20/3/95
    Inputs:     OpClipartImport (unused)
    Outputs:    -
    Returns:    -
    Purpose:    
    Errors:     Always fails because this Do doesn't.
    SeeAlso:    -

********************************************************************************************/
            
void OpClipartImport::Do(OpDescriptor *NotUsed)
{
    ERROR3("OpClipartImport does not provide a Do() function - Use DoWithParam");
    End();
}

/******************************************************************************************
>   void OpClipartImport::DoWithParam(OpDescriptor* pOp, OpParam* pAlignParam)

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com> (well, most of the code taken from tim's OpMenuImport)
    Created:    20/3/95
    Inputs:     pOp - OpDescriptor as for all Do() functions
                Param - points to a handy ClipartImport structure which says which
                    file to import, etc...
    Outputs:    -
    Returns:    -
    Purpose:    Performs a clipart import / open depending on the parameters...
                Imports overlay the clipart on the existing document,
                Opens create a new page and import to that.

    SeeAlso:
******************************************************************************************/

void OpClipartImport::DoWithParam(OpDescriptor* pOp, OpParam* pClipartImportParam)
{
    ClipartImportParam *pInfo = (ClipartImportParam *) pClipartImportParam;

    if(pInfo == NULL)
    {
        ERROR3("OpClipartImport called with NULL info pointer");
        FailAndExecute(); 
        End();
        return;
    }
    else
    {
        if(pInfo->File == NULL)
        {
            ERROR3("OpClipartImport called with NULL file pointer");
            FailAndExecute(); 
            End();
            return;
        }
    }

    PathName Path = *(pInfo->File);

    if(!Path.IsValid())
    {
        ERROR3("Filename is invalid");
        //InformError(_R(IDT_IMPORT_NOTFOUND));
        FailAndExecute();
        End();
        return;
    }

    if(!pInfo->Import)
    {
        // Open / Load a file
        CCamApp        *pApp = AfxGetApp();
        BaseFileDialog::SelectedFilter = 0;
        
        String_256 OpenPath((const TCHAR *)Path.GetPath());
//      Error::ClearError();

        // Open a document
        CCamDoc* pDoc = (CCamDoc*) pApp->OpenDocumentFile((TCHAR *)OpenPath);

        // Force the Ops 'Working Doc' to the selected one, in case the open
        // document thingy deleted the existing docs.
        if(pDoc != NULL) pOurDoc = Document::GetSelected();
        
        Document* pCurDoc = pDoc->GetKernelDoc();

        // And redraw the imported document
        //if(pCurDoc) pCurDoc->ForceRedraw();

    }
    else
    {
        // Can't import if no selected document (!)
        if(Document::GetSelected() == NULL)
        {
            ERROR3("No selected document");
            //InformError(_R(IDT_IMPORT_NOTFOUND));
            FailAndExecute();
            End();
            return;
        }
            
        // Import a file
        UINT32 SelFilter = FILTERID_GENERIC;
        BOOL LayersImport = FALSE;
        
        // Find the filter that the user chose
        Filter *pFilter = Filter::GetFirst();

        if(pFilter == NULL)
            return;

        while (pFilter != NULL)
        {
            if ((pFilter->GetFlags().CanImport) && (pFilter->FilterID == SelFilter))
                // This is the filter!
                break;

            // Try the next filter
            pFilter = Filter::GetNext(pFilter);
        }

        if (pFilter == NULL)
        {
            InformError(_R(IDT_CANT_FIND_FILTER));
            FailAndExecute(); 
            End();
            return;
        }
        else
        {
            // If this is not a filter family, check for compatibility before asking
            // filter to load the file.
            // This means the user has chosen an explicit filter to handle the import
            if (!pFilter->IS_KIND_OF(FilterFamily))
            {
                UINT32 Size = 1024;
                INT32 FileSize;
                ADDR FilterBuf = pFilter->LoadInitialSegment(Path, &Size, &FileSize);

                // If there has been a problem in the load initial segment then fail now.
                if (FilterBuf == NULL)
                {
                    // Tell the user about the problem and get out now while the goings good 
                    InformError();
                    FailAndExecute(); 
                    End();
                    return;
                }

                // Inform any filters that we are about to do a HowCompatible call.
                // This would allow a set of filters which have common functionality hidden in a
                // filter that cannot import and cannot export handle this call and hence set
                // itself up. This would allow it to maybe cache a result which should only be
                // checked by the first filter in the group. 
                pFilter->PreHowCompatible();
        
                // Change this to be less than 9 as the built in BMP filter returns 8 if it
                // is not too sure about the file and would like the AccusoftBMp filter to 
                // load the file if it is present.  
                if (pFilter->HowCompatible(Path, FilterBuf, Size, FileSize) < 9)
                {
                    // Not 100% happy with this file - ask for confirmation.
                    ErrorInfo Question;
                    Question.ErrorMsg = _R(IDT_IMPQUERY_NOTSURE);
                    Question.Button[0] = _R(IDB_IMPQUERY_IMPORT);
                    Question.Button[1] = _R(IDB_IMPQUERY_DONTIMPORT);

                    if (AskQuestion(&Question) != _R(IDB_IMPQUERY_IMPORT))
                    {
                        // User asked for this to be cancelled.
                        TRACEUSER( "Richard", wxT("Filter compatibility was less than 10\n") );

                        // Close the file, report the abort and finish.
                        CCFree(FilterBuf);
                        FailAndExecute();
                        InformMessage(_R(IDT_IMP_USERABORT));
                        End();
                        return;
                    }
                }

                // Get rid of initial file header
                CCFree(FilterBuf);
            }

            // Start the selection operation
            if (DoStartSelOp(FALSE)) // We don't want to save the end selection status because 
                                     // it will be restored automatically when the operation is 
                                     // redone
            {
                // First off, we have to try and open the file
                CCDiskFile DiskFile(1024, FALSE, TRUE);

                // Get pointer to current doc 'cos we'll need it several times...
                //Document* pCurDoc = Document::GetCurrent();
                Document* pCurDoc;
                ImportPosition Pos;

                if (pInfo->DropInfo)
                {
                    // A specfic Import Position has been specified.
                    // Get the document, spread, and position to import at.
                    pCurDoc = pInfo->DropInfo->pDoc;

                    Pos.Position    = pInfo->DropInfo->DropPos;
                    Pos.pSpread     = pInfo->DropInfo->pSpread;
                }
                else
                {
                    pCurDoc = Document::GetSelected();
                }

                if(pCurDoc == NULL)
                {
                    ERROR3("OpClipartImport::DoWithParam retrieved NULL selected doc");
                    return;
                }

                TRY
                {
                    if (!DiskFile.open(Path, ios::in | ios::binary))
                    {
                        // Failed to open the file...
                        TRACEUSER( "Richard", wxT("Failed to open file in ClipartImport Do") );
                        InformError(_R(IDT_IMPORT_NOTFOUND));
                        FailAndExecute();
                        End();
                        return;
                    }

                    // Import the file and see if Something went a bit wrong - tell the user what it was.
                    ImportPosition* ImportPos;
                    if (pInfo->DropInfo)
                        ImportPos = &Pos;   // Import at a specific point.
                    else
                    {
                        //Graham 15/7/97
                        //Otherwise, put the imported object in the centre of the view
                        //So get the current view
                        DocView* pDocView=DocView::GetCurrent();

                        //And find its centre import position
                        Pos=pDocView->GetCentreImportPosition();

                        ImportPos=&Pos;
                    }



                    if (!pFilter->DoImport(this, &DiskFile, pCurDoc, FALSE, ImportPos))
                    {
                        // Only tell them if not special user cancelled error message
                        if (Error::GetErrorNumber() != _R(IDN_USER_CANCELLED))
                            InformError();
                        else
                            Error::ClearError();    // otherwise remove the error so it won't get reported
                        FailAndExecute();
                        End();

                        // close the file
                        if (DiskFile.isOpen())
                            DiskFile.close();

                        return;
                    }

                    // close the file
                    if (DiskFile.isOpen())
                        DiskFile.close();

                }

                // See if there was a file io error
                CATCH(CFileException, e)
                {
                    // Report the error if no one else did
                    if (Error::GetErrorNumber() != _R(IDN_USER_CANCELLED))
                        InformError();
                    else
                        Error::ClearError();    // otherwise remove the error so it won't get reported

                    // Make sure that the file is closed
                    TRY
                    {
                        if (DiskFile.isOpen())
                            DiskFile.close();
                    }
                    CATCH(CFileException, e)
                    {
                        // Failed to close the file - not much we can do about it really
                    }
                    END_CATCH

                    // and fail
                    FailAndExecute();
                    End();
                    return;
                }
                END_CATCH
            }
        }
    }
        
    // grab the focus
    GetMainFrame()->SetActiveWindow();
    // Finished the operation
    End();
}






// Constructor for BitmapImportParam,
// Makes sure the parameter defaults are sensible
BitmapImportParam::BitmapImportParam()
{
    File            = NULL;
    Result          = FALSE;

    pTargetDoc      = 0;
    TagObjectToFill = 0;
    TagObjectValid  = false;
    pObject         = 0;
    pObjectValid    = false;
}


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

>   OpBitmapImport::OpBitmapImport() : UndoableOperation()

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    20/3/95
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    OpBitmapImport constructor (Creates an undoable operation)
    SeeAlso:

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

OpBitmapImport::OpBitmapImport() : Operation()
{
    OpFlags.HasOwnTimeIndicator = TRUE; // The OpMenuImport op has its own time indicator
}       

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

>   OpBitmapImport::~OpBitmapImport() 

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    20/3/95
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    OpBitmapImport destructor
    Errors:     -
    SeeAlso:    -

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

OpBitmapImport::~OpBitmapImport()
{
}

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

>   BOOL OpAlign::Init()

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    20/3/95
    Returns:    FALSE if it fails (due to lack of memory)
    Purpose:    Creates an OpDescriptor for an BitmapImport operation
    SeeAlso:

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

BOOL OpBitmapImport::Init()
{
    return RegisterOpDescriptor(
        0,                              // Tool ID
        _R(IDS_OPCLIPARTIMPORT),                // String resource ID
        CC_RUNTIME_CLASS(OpBitmapImport),   // Runtime class
        OPTOKEN_OPBITMAPIMPORT,         // Token string
        OpBitmapImport::GetState,           // GetState function
        0,                              // Help ID
        0,                              // Bubble ID
        0,                              // Resource ID
        0                               // Control ID
//  needs   'GREY_WHEN_NO_CURRENT_DOC'
    );
}   

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

>   OpState OpBitmapImport::GetState(String_256* pString, OpDescriptor* pOpDesc)

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    20/3/95
    Purpose:    Returns the OpState of the OpBitmapImport operation.
    SeeAlso:

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

OpState OpBitmapImport::GetState(String_256* pString, OpDescriptor* pOpDesc)
{
    //OpState OpSt;
    OpState OpSt;

    return(OpSt);
}

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

>   void OpBitmapImport::Do(OpDescriptor*)

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    20/3/95
    Inputs:     OpBitmapImport (unused)
    Outputs:    -
    Returns:    -
    Purpose:    
    Errors:     Always fails because this Do doesn't.
    SeeAlso:    -

********************************************************************************************/
            
void OpBitmapImport::Do(OpDescriptor *NotUsed)
{
    ERROR3("OpBitmapImport does not provide a Do() function - Use DoWithParam");
    End();
}

/******************************************************************************************
>   void OpBitmapImport::DoWithParam(OpDescriptor* pOp, OpParam* pAlignParam)

    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    9/4/95
    Inputs:     pOp - OpDescriptor as for all Do() functions
                Param - points to a handy BitmapImport structure which says which
                    file to import, etc...
    Outputs:    -
    Returns:    -
    Purpose:    Performs a Bitmap import.
                Returns a pointer to the imported bitmap, without creating any objects.

    SeeAlso:
******************************************************************************************/

void OpBitmapImport::DoWithParam(OpDescriptor* pOp, OpParam* pBitmapImportParam)
{
    BitmapImportParam *pInfo = (BitmapImportParam *) pBitmapImportParam;
    KernelBitmap* pBitmap = 0;

    if(pInfo == NULL)
    {
        ERROR3("OpBitmapImport called with NULL info pointer");
        FailAndExecute(); 
        End();
        return;
    }
    else
    {
        if(pInfo->File == NULL)
        {
            ERROR3("OpBitmapImport called with NULL file pointer");
            FailAndExecute(); 
            End();
            return;
        }
    }

    PathName Path = *(pInfo->File);

    if(!Path.IsValid())
    {
        ERROR3("Filename is invalid");
        //InformError(_R(IDT_IMPORT_NOTFOUND));
        FailAndExecute();
        End();
        return;
    }

    // Import a file
    UINT32 SelFilter = FILTERID_GENERIC;
    BOOL LayersImport = FALSE;
    
    // Find the filter that the user chose
    Filter *pFilter = Filter::GetFirst();

    if(pFilter == NULL)
        return;

    while (pFilter != NULL)
    {
        if ((pFilter->GetFlags().CanImport) && (pFilter->FilterID == SelFilter))
            // This is the filter!
            break;

        // Try the next filter
        pFilter = Filter::GetNext(pFilter);
    }

    if (pFilter == NULL)
    {
        InformError(_R(IDT_CANT_FIND_FILTER));
        FailAndExecute(); 
        End();
        return;
    }
    else
    {
        // If this is not a filter family, check for compatibility before asking
        // filter to load the file.
        // This means the user has chosen an explicit filter to handle the import
        if (!pFilter->IS_KIND_OF(FilterFamily))
        {
            UINT32 Size = 1024;
            INT32 FileSize;
            ADDR FilterBuf = pFilter->LoadInitialSegment(Path, &Size, &FileSize);

            // If there has been a problem in the load initial segment then fail now.
            if (FilterBuf == NULL)
            {
                // Tell the user about the problem and get out now while the goings good 
                InformError();
                FailAndExecute(); 
                End();
                return;
            }

            // Inform any filters that we are about to do a HowCompatible call.
            // This would allow a set of filters which have common functionality hidden in a
            // filter that cannot import and cannot export handle this call and hence set
            // itself up. This would allow it to maybe cache a result which should only be
            // checked by the first filter in the group. 
            pFilter->PreHowCompatible();
    
            // Change this to be less than 9 as the built in BMP filter returns 8 if it
            // is not too sure about the file and would like the AccusoftBMp filter to 
            // load the file if it is present.  
            if (pFilter->HowCompatible(Path, FilterBuf, Size, FileSize) < 9)
            {
                // Not 100% happy with this file - ask for confirmation.
                ErrorInfo Question;
                Question.ErrorMsg = _R(IDT_IMPQUERY_NOTSURE);
                Question.Button[0] = _R(IDB_IMPQUERY_IMPORT);
                Question.Button[1] = _R(IDB_IMPQUERY_DONTIMPORT);

                if (AskQuestion(&Question) != _R(IDB_IMPQUERY_IMPORT))
                {
                    // User asked for this to be cancelled.
                    TRACEUSER( "Richard", wxT("Filter compatibility was less than 10\n") );

                    // Close the file, report the abort and finish.
                    CCFree(FilterBuf);
                    FailAndExecute();
                    InformMessage(_R(IDT_IMP_USERABORT));
                    End();
                    return;
                }
            }

            // Get rid of initial file header
            CCFree(FilterBuf);
        }

        // First off, we have to try and open the file
        CCDiskFile DiskFile(1024, FALSE, TRUE);

        TRY
        {
            if (!DiskFile.open(Path, ios::in | ios::binary))
            {
                // Failed to open the file...
                TRACEUSER( "Richard", wxT("Failed to open file in BitmapImport Do") );
                InformError(_R(IDT_IMPORT_NOTFOUND));
                FailAndExecute();
                End();
                return;
            }

            // Import the file and see if Something went a bit wrong - tell the user what it was.
            if (!pFilter->ImportBitmap(&DiskFile, &pBitmap))
            {
                // Only tell them if not special user cancelled error message
                if (Error::GetErrorNumber() != _R(IDN_USER_CANCELLED))
                    InformError();
                else
                    Error::ClearError();    // otherwise remove the error so it won't get reported
                FailAndExecute();
                End();

                return;
            }

            // close the file
            if (DiskFile.isOpen())
                DiskFile.close();
        }

        // See if there was a file io error
        CATCH(CFileException, e)
        {
            // Report the error if no one else did
            if (Error::GetErrorNumber() != _R(IDN_USER_CANCELLED))
                InformError();
            else
                Error::ClearError();    // otherwise remove the error so it won't get reported

            // Make sure that the file is closed
            TRY
            {
                if (DiskFile.isOpen())
                    DiskFile.close();
            }
            CATCH(CFileException, e)
            {
                // Failed to close the file - not much we can do about it really
            }
            END_CATCH

            // and fail
            FailAndExecute();
            End();
            return;
        }
        END_CATCH
    }

    // Should really check the return value of ApplyFill(...)
    ApplyFill(pInfo, pBitmap);

    // If we have created a bitmap and it hasn't been added to a list somewhere
    if (pBitmap && pBitmap->GetParentBitmapList() == NULL)
    {
        // Delete it
        delete pBitmap;
    }

    // grab the focus
    GetMainFrame()->SetActiveWindow();

    // Finished the operation
    End();
}

bool OpBitmapImport::ApplyFill(BitmapImportParam *pInfo, KernelBitmap* pBitmap)
{
    // Check the document pointer points to the current document
    if (Document::GetCurrent() != pInfo->pTargetDoc || pInfo->pTargetDoc == 0)
    {
        // At the moment we cannot apply a fill to an object that is not in
        // the current document (the operations used in this function appear to
        // add the object to one documents tree and render the object on the other
        // document).
        ERROR3("Cannot apply fill when active document has changed");
        return false;
    }

    // Check the spread is valid
    if (!Document::SpreadBelongsToDoc(pInfo->pTargetDoc, pInfo->pSpread))
    {
        ERROR3("Trying to import a bitmap fill into a non-existent spread");
        return false;
    }

    // Everything looks OK, lets do the fill
    switch(pInfo->FillType)
    {
        // If you need to change ApplyToObject, you may need to change ApplyToObjectAsTrans
        case ApplyToObject:
        {
            NodeRenderableInk* pObjectToUse;
            if (pInfo->TagObjectValid)
            {
                Node *pTreeRoot = pInfo->pTargetDoc->GetFirstNode()->FindFirstDepthFirst();
                if (pTreeRoot) pTreeRoot = pTreeRoot->FindNext();
                Node *pNode = pTreeRoot->FindFirstDepthFirst();
                while ((pNode != NULL) && (pNode->GetTag() != pInfo->TagObjectToFill))
                    pNode = pNode->FindNextDepthFirst(pTreeRoot);

                if (pNode == 0)
                    return false;

                if (pNode->IsAnObject())
                    pObjectToUse = static_cast<NodeRenderableInk *>(pNode); // should use dynamic_cast but no RTTI available
                else
                {
                    ERROR3("It has the tag we saved but its type has changed.  This is odd");
                    return false;
                }
            }

            AttrBitmapColourFill* Attrib = new AttrBitmapColourFill;
            if (Attrib == 0)
                return false;

            Attrib->AttachBitmap(pBitmap);

            if (pInfo->TagObjectValid)
                AttributeManager::ApplyAttribToNode(pObjectToUse, Attrib);
            else if (pInfo->pObjectValid)
                AttributeManager::ApplyAttribToNode(pInfo->pObject, Attrib);
            else
                AttributeManager::AttributeSelected(0, Attrib);

            return true;
        }
        // If you need to change ApplyToObjectAsTransp, you may need to change ApplyToObject
        case ApplyToObjectAsTransp:
        {
            NodeRenderableInk* pObjectToUse;

            if (pInfo->TagObjectValid)
            {
                Node *pTreeRoot = pInfo->pTargetDoc->GetFirstNode()->FindFirstDepthFirst();
                if (pTreeRoot) pTreeRoot = pTreeRoot->FindNext();
                Node *pNode = pTreeRoot->FindFirstDepthFirst();
                while ((pNode != NULL) && (pNode->GetTag() != pInfo->TagObjectToFill))
                    pNode = pNode->FindNextDepthFirst(pTreeRoot);

                if (pNode == 0)
                    return false;

                if (pNode->IsAnObject())
                    pObjectToUse = static_cast<NodeRenderableInk *>(pNode); // should use dynamic_cast but no RTTI available
                else
                {
                    ERROR3("It has the tag we saved but its type has changed.  This is odd");
                    return false;
                }
            }

            pBitmap = NodeBitmap::CheckGreyscaleBitmap(pBitmap, _R(IDS_BMPGAL_MAKEGREY), _R(IDS_BMPGAL_DOGREY));

            AttributeManager::HaveAskedAboutContoneColours  = FALSE;
            AttributeManager::UserCancelledContoneColours   = FALSE;

            if (pBitmap == 0)
                return false;

            // Fill colour selected so create a fill colour attribute
            NodeAttribute *Attrib = new AttrBitmapTranspFill;
            if (Attrib == 0)
                return false;

            (static_cast<AttrBitmapTranspFill *>(Attrib))->AttachBitmap(pBitmap);

            if (pInfo->TagObjectValid)
                AttributeManager::ApplyAttribToNode(pObjectToUse, Attrib);
            else if (pInfo->pObjectValid)
                AttributeManager::ApplyAttribToNode(pInfo->pObject, Attrib);
            else
                AttributeManager::AttributeSelected(0, Attrib);

            return true;
        }
        case SetBackground:
        {
            OpBackgroundParam Param;
            Param.pBitmap   = pBitmap;
            Param.pDoc      = pInfo->pTargetDoc;            
            Param.pSpread   = pInfo->pSpread;
            
            // Obtain a pointer to the op descriptor for the create operation 
            OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_BACKGROUND);

            // Invoke the operation, passing in our parameters
            pOpDesc->Invoke(&Param);
            return true;
        }
        case AddToPage:
        {
            PageDropInfo DropInfo;

            DropInfo.pDoc       = pInfo->pTargetDoc;
            DropInfo.pSpread    = pInfo->pSpread;
            DropInfo.DropPos    = pInfo->DropPos;

            // Obtain a pointer to the op descriptor for the create operation 
            OpDescriptor* OpDesc = OpDescriptor::FindOpDescriptor(CC_RUNTIME_CLASS(OpCreateNodeBitmap));

            // Invoke the operation, passing DocView and Pos as parameters
            OpDesc->Invoke(&OpParam((INT32)pBitmap,(INT32)&DropInfo));
            return true;
        }
        default:
        {
            ERROR3("Unknown fill type");
            return false;
        }
    }
}

#endif // wxCamelot port

/***********************************************************************************************
>   static BOOL SGLibOil::TidyUp(void)

    Purpose: Called by camelot de-init routines
***********************************************************************************************/

BOOL SGLibOil::TidyUp(void)
{
    if(TmpSndName != NULL)
    {
        PathName TheFile(TmpSndName);
        FileDelete(&TheFile);
        TmpSndName = NULL;
    }
    return TRUE;
}

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

>   static BOOL SGLibOil::FileCopy(PathName *Source, PathName *Destination)

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/3/95
    Inputs:     Source - Source path to grab file from
                Destination - Destination path to copy file to
    Returns:    Returns true if all was hunky dorey
    Purpose:    Copies a file from source to destination.
    Notes:      This function was deemed necessary as actually doing this sort of
                thing in windows 3.1 is completely nasty, and completely incompatible
                with NT's way...
          
***********************************************************************************************/

BOOL SGLibOil::FileCopy(PathName *Source, PathName *Destination)
{
    PORTNOTETRACE("dialog","SGLibOil::FileCopy - do nothing");
#ifndef EXCLUDE_FROM_XARALX
    if(Source == NULL || Destination == NULL)
    {
        ERROR3("SGLibOil::FileCopy Source or Destination files should not be null");
        return FALSE;
    }

    if(!Destination->IsValid() || !Source->IsValid())
    {
        ERROR3("SGLibOil::FileCopy given invalid path");
        return FALSE;
    }

    if(FileExists(Destination))
    {
        ERROR3("SGLibOil::FileCopy destination file already exists");
        return FALSE;
    }

    if(!FileExists(Source))
    {
        ERROR3("SGLibOil::FileCopy source file doesn't exist");
        return FALSE;
    }

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

//  return CopyFile((TCHAR *)Source->GetPath(), (TCHAR *)Destination->GetPath(), FALSE);

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

    INT32 Size = SGLibOil::FileSize(Source);
    void *Buffer = CCMalloc(Size + 4);

    if(Buffer != NULL)
    {
        CCDiskFile File(1024, FALSE, TRUE);
 
        // Open file and check if it exists at the same time
        try
        {
            // Read file into the buffer
            File.open( Source->GetPath(), ios::in | ios::binary );
            File.read( Buffer, Size );
            if(File.isOpen())
                File.close();

            // Write file from buffer into output file
            File.open(Destination->GetPath(), ios::out | ios::binary);
            File.write(Buffer, Size);
            if(File.isOpen())
                File.close();

            CCFree(Buffer);

            // File copied ok...
            return TRUE;
        }       
        catch( CFileException )
        {
            // File not copied ok... Clear the errors and fall though to alternative low-
            // memory file copy... (this should be very rare !)
            Error::ClearError();
        }

        CCFree(Buffer);
    }

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

    // Not enough memory available, do the copy the old, slow, byte by byte (ANSI) way...

    FILE               *FPin  = NULL;
    FILE               *FPout = NULL;

#if defined(__WXMSW__)
    FPin  = _tfopen((const TCHAR *)Source->GetPath(), "rb");
    FPout = _tfopen((const TCHAR *)Destination->GetPath(), "wb");
#else
    PSTR                pszSrc, pszDst;
    {
        size_t          cchTmp = camWcstombs( NULL, Source->GetPath(), 0 ) + 1;
        pszSrc = PSTR( alloca( cchTmp ) );
        camWcstombs( pszSrc, Source->GetPath(), cchTmp );
    }
    {
        size_t          cchTmp = camWcstombs( NULL, Destination->GetPath(), 0 ) + 1;
        pszDst = PSTR( alloca( cchTmp ) );
        camWcstombs( pszDst, Destination->GetPath(), cchTmp );
    }

    FPin  = fopen( pszSrc, "rb" );
    FPout = fopen( pszDst, "wb" );
#endif
    
    if(FPin != NULL || FPout != NULL)
    {
        TCHAR C;
        while(!feof(FPin))
        {
            C = _fgettc(FPin);
            if(!feof(FPin)) _fputtc(C, FPout);
        }                       
        fclose(FPin);
        fclose(FPout);
        return TRUE;
    }

    if(FPin != NULL) fclose(FPin);
    if(FPout != NULL) fclose(FPout);
#endif
    return FALSE;
}

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

>   static BOOL SGLibOil::FileExists(PathName *FileName)

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    8/3/95
    Inputs:     File - Pointer to path and filename of file
    Returns:    Returns true if the specified file exists
    Purpose:    To find out whether a file actually exists.
    Notes:

********