camelot.cpp

Go to the documentation of this file.

// $Id: camelot.cpp 1771 2007-06-17 20:14:43Z 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============================
 */
/***************************************************************************************************************************/
//
// camelot.cpp - main application class derived from wxApp
//
/***************************************************************************************************************************/

#include "camtypes.h"

#include "camdoc.h"
//#include "docview.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "camview.h"
#include "camframe.h"
//#include "Res/UKEnglish/stringtbl.h"
#include "kernel.h"
#include "grndrgn.h"
#include "oilmenus.h"

#if !defined(__WXMSW__)
#include "gdraw.h"
#endif

#include "cversion.h"
#include "camelot.h"
#include "camdoctp.h"

#include "keypress.h"
#include "ccdc.h"
#include "camprofile.h"
#include "dlgevt.h"
#include "cartprov.h"
#include "ctrllist.h"
#include "cartctl.h"
#include "xmlutils.h"
#include "camplatform.h"
#include "filedlgs.h"
#include "progress.h"
#include "prdlgctl.h"
#include "prncamvw.h"
#include "gbrush.h"
#include "selmedia.h"
#include "filedlgs.h"
#include "rendwnd.h"

#include "camprocess.h"

//
// Define FILELIST for recent file list on file menu.
// Note that this currently seems to be rather unreliable.
//
//#if defined(_DEBUG)
//#define FILELIST
//#endif

//
// Define XARA_MENUGEN to use Xtreme style menu creation.
// Note that this currently doesn't have full functionality
// but it's getting there
//#if defined(_DEBUG)
#define XARA_MENUGEN
//#endif

BOOL CCamApp::InInitOrDeInit = TRUE;
IMPLEMENT_DYNAMIC_CLASS( wxWindowDeletionWatcher, wxObject);
WindowToWindowDeletionWatcher * wxWindowDeletionWatcher::s_UndeletedWindowHash = NULL;

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

    Preference: MainWndMax
    Section:    Windows
    Range:      0 (FALSE) or 1 (TRUE)
    Purpose:    If non-zero then main window defaults to maximized, else normal position.
                This default will be overridden if the user explicitly asked for a mode
                when starting the app (e.g. minimized). If the user exits while maximized,
                the flag will be set ready for next time.

********************************************************************************************/
BOOL CCamApp::MainWndMaximized = FALSE;


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

    Preference: MainWndMin
    Section:    Windows
    Range:      0 (FALSE) or 1 (TRUE)
    Purpose:    If non-zero then main window defaults to minimized, else normal position.
                This default will be overridden if the user explicitly asked for a mode
                when starting the app (e.g. minimized). If the user exits while minimized,
                the flag will be set ready for next time.

********************************************************************************************/
BOOL CCamApp::MainWndMinimized = FALSE;


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

    Preference: MainWndPos
    Section:    Windows
    Range:      Six numbers, separated with spaces, which are x y w h sx sy
    Purpose:    Remembers users last 'normal' window position for them. Also remembers the
                screen size so can be scaled if next time runs in different screen mode.

********************************************************************************************/
String_256 CCamApp::MainWndPosString;


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

    Preference: FirstRun
    Section:    Preferences
    Range:      0 (FALSE) or 1 (TRUE)
    Purpose:    If 1 then this is the first time this application has been run with
                this set of preferences
                If 0 then it has been run before

********************************************************************************************/
BOOL CCamApp::bFirstRun = TRUE;


/***************************************************************************************************************************/
//
// Timer used for background redraw.
// For now we have gone back to using the idle system for redraw as it does seem to work
// The background redraw may be changed to use a timer or some other method
//

#define CAM_TIMER_ID         42
#define CAM_TIMER_FREQUENCY 100

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

IMPLEMENT_APP( CCamApp )
BEGIN_EVENT_TABLE( CCamApp, wxApp )
    EVT_IDLE( CCamApp::OnIdle )
//  EVT_TIMER( CAM_TIMER_ID, CCamApp::OnTimer )
END_EVENT_TABLE()

DialogManager           CCamApp::m_DlgMgr;
bool                    CCamApp::s_bIsDisabled = false; // Initially system is not disabled.
wxString                CCamApp::m_strResourcePath;
String_256              CCamApp::m_strResourceDirPath;
String_256              CCamApp::m_strResourceDirPathOverride;
String_256              CCamApp::m_strMediaApplication;

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

CCamApp::CCamApp()
{
}

/*********************************************************************************************
>   int TYPENOTE: Correct CCamApp::FilterEvent( wxEvent& event )

    Author:     Luke_Hart (Xara Group Ltd) <LukeH@xara.com>
    Created:    09/05/06
    Inputs:     A reference to the event to filter
    Outputs:    -
    Returns:    -
    Purpose:    This function is used to collect the key press information for handling by
                applictaion. It passes event unmolested for controls that are allowed focus and
                controls within modal dialogs. It also has code to make sure that key events
                that are passed on aren't checked again, based on the event timestamp. All other 
                keys are passed into application keypress handling code.
    Errors:     -
    Scope:      Protected
    SeeAlso:    The focus handling document

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

int /*TYPENOTE: Correct*/ CCamApp::FilterEvent( wxEvent& event )
{
    static /*TYPENOTE: Correct*/ long   lLastTimeStamp = 0;

    wxObject* pEventObject = event.GetEventObject();

    if (( event.GetEventType() == wxEVT_DESTROY ) && pEventObject->IsKindOf(CLASSINFO(wxWindow)))
    {
        // Register window destruction
        wxWindowDeletionWatcher::RegisterWindowDeletion((wxWindow *)pEventObject);
    }

    if (PrintMonitor::IsPrintingNow())
    {
        // Disable processing of paint messages for various controls which may use GDraw or GBrush to paint, as this
        // appears to upset printing
        if (event.IsKindOf(CLASSINFO(wxPaintEvent)))
        {
            if (!pEventObject->IsKindOf(CLASSINFO(wxCamArtControl)))
            {   
                // TRACEUSER("amb", _T("CCamApp::FilterEvent caught paint for %s"), pEventObject->GetClassInfo()->GetClassName());
                return false;
            }
        }
    }

    if( event.GetEventType() == wxEVT_ACTIVATE )
    {
        TRACEUSER("luke", _T("CCamApp::FilterEvent activate to %s"), pEventObject->GetClassInfo()->GetClassName());

        if( pEventObject->IsKindOf( CLASSINFO(wxAuiFloatingFrame) ) )
        {
            wxClassInfo* pClassInfo = pEventObject->GetClassInfo();
            while( NULL != pClassInfo )
            {
                TRACEUSER( "luke", _T("Class = %s"), (PCTSTR)pClassInfo->GetClassName() );

                const wxChar* pszBaseClass = pClassInfo->GetBaseClassName1();
                pClassInfo = NULL == pszBaseClass ? NULL : wxClassInfo::FindClass( pszBaseClass );
            }
            TRACEUSER( "luke", _T("Parent = %x, %x"), ((wxWindow*)pEventObject)->GetParent(), m_pMainFrame );
            TRACEUSER( "luke", _T("Active = %x"), ((wxTopLevelWindow*)pEventObject)->IsActive() );

            GiveActiveCanvasFocus();
            return 1;               // Don't let the recipent know it was activated
        } 
    }

// useful code to see where focus events originate from. Set a breakpoint below and look
// at the call stack
    if ( event.GetEventType() == wxEVT_SET_FOCUS )
    {
        TRACEUSER("luke", _T("CCamApp::FilterEvent focus to %s"), pEventObject->GetClassInfo()->GetClassName());
/*      if (pEventObject->IsKindOf(CLASSINFO(CRenderWnd)))
        {
            INT32 i=1;
        } */
    }

    if ( event.GetEventType() == wxEVT_KILL_FOCUS )
    {
#if defined(_DEBUG)
        wxFocusEvent&   FocusEvent = (wxFocusEvent&)event;
        TRACEUSER( "luke", _T("CCamApp::FilterEvent kill focus to %016x from 0x%016x"), FocusEvent.GetWindow(), 
                FocusEvent.GetEventObject() );
#endif

        // Any loss of focus could well a good time to kill cursor
        wxSetCursor( *wxSTANDARD_CURSOR );
    }

    if (( event.GetEventType() == wxEVT_CREATE )
        && pEventObject
        && (pEventObject->IsKindOf(CLASSINFO(wxTopLevelWindow)))
        && !(pEventObject->IsKindOf(CLASSINFO(wxAdvSplashScreen))) // Don't trigger this on the creation of the splash screen itself
        && !(pEventObject->IsKindOf(CLASSINFO(wxSplashScreen)))
        )
    {
        // a top level window is about to be created. End the splash screen if it is up as it may obscure it
        CamResource::DoneInit(FALSE);   
    }

#if defined(_DEBUG)
    if( event.GetEventType() == wxEVT_CHAR )
    {
        if (pEventObject)
        {
            TRACEUSER( "jlh92", _T("KeyEvent 4 %s CH\n"),
                ((wxWindow*)pEventObject)->GetClassInfo()->GetClassName() );
        }
    }
#endif

    if( event.GetEventType() == wxEVT_KEY_DOWN ||
        event.GetEventType() == wxEVT_KEY_UP )
    {
        // Use timestamp to detect events which are passing
        // down the chain (which we've tested)
        if( lLastTimeStamp == event.GetTimestamp() )
            return -1;
        lLastTimeStamp = event.GetTimestamp();

        TRACEUSER( "jlh92", _T("KeyEvent 4 %s %s\n"),
            ((wxWindow*)pEventObject)->GetClassInfo()->GetClassName(),
            event.GetEventType() == wxEVT_KEY_DOWN ? _T("KD") : _T("KU") );
        
        // Is the object allowed to recieve keys? We have to go done the object hierarchy
        // since some control (notably Combos) will produce temporary windows which can get
        // key events.
        wxWindow* pScanObj = (wxWindow*)pEventObject;
        while( NULL != pScanObj )
        {
            wxClassInfo* pClassInfo = pScanObj->GetClassInfo();
#if defined(DEBUG_KEYPRESS_SPEW)
            {
                wxClassInfo *pTmpInfo = pClassInfo;
                while( NULL != pTmpInfo )
                {
                    TRACEUSER( "jlh92", _T("Class %s\n"), PCTSTR(pTmpInfo->GetClassName()) );
        
                    PCTSTR  pszName = pTmpInfo->GetBaseClassName1();
                    pTmpInfo = NULL == pszName ? NULL : wxClassInfo::FindClass( pszName );
                }
                TRACEUSER( "jlh92", _T("----------------------\n") );
            }
#endif
            TRACEUSER("amb", _T("CCamApp::FilterEvent key for %s"), pClassInfo->GetClassName());

            if( pClassInfo->IsKindOf( CLASSINFO(wxTextCtrl) ) ||
                pClassInfo->IsKindOf( CLASSINFO(wxComboBox) ) ||
                pClassInfo->IsKindOf( CLASSINFO(wxSliderCombo) ) ||
                pClassInfo->IsKindOf( CLASSINFO(wxOwnerDrawnComboBox) ) ||
                pClassInfo->IsKindOf( CLASSINFO(wxComboCtrl) )
                )
            {
                TRACEUSER("amb", _T("CCamApp::FilterEvent gets keys as special"));
                TRACEUSER( "jlh92", _T("Control gets keys") );
                // Yes, pass on as usual
                return -1;
            }

            pScanObj = pScanObj->GetParent();
        }

        // Scan down ancestors looking for either wxPanels (always non-modal) and
        // wxDailogs (can be modal, so we check)
        wxWindow *pWnd = (wxWindow*)pEventObject;
        while( NULL != pWnd && !pWnd->IsKindOf( CLASSINFO(wxPanel) ) )
        {
            // Dialogs may-be modal so check
            if( pWnd->IsKindOf( CLASSINFO(wxDialog) ) )
            {
                // Pass event down chain if modal
                if( ((wxDialog*)pWnd)->IsModal() )
                {
                    TRACEUSER( "jlh92", _T("Modal dialog\n") );
                    TRACEUSER("amb", _T("CCamApp::FilterEvent gets keys as modal"));
                    return -1;
                }

                // Non-modal dialog so do focus handling
                break;
            }

            pWnd = pWnd->GetParent();
        }

        TRACEUSER("amb", _T("CCamApp::FilterEvent handle"));
        TRACEUSER( "jlh92", _T("Handled!\n") );

        // Do our best to see if the object is deleted.
        wxWindowDeletionWatcher * wd = NULL;
        if (pEventObject->IsKindOf(CLASSINFO(wxWindow)))
        {
            wd = new wxWindowDeletionWatcher((wxWindow*)pEventObject);
            if (!wd)
                return -1;
        }

        // Process keyboard messages (and mark event as handled)
        if( HandleKeyPress( (wxKeyEvent&)event ) )
        {
            BOOL deleted = wd && wd->HasBeenDeleted();
            if (wd)
                delete wd;
            if (deleted)
                return 1; // event handled. Do NOT anything else here as the object may by now
                        // have been deleted (e.g. FileClose hotkey).
            else
                return -1;
        }
        if (wd)
            delete wd;
    }
    
    return -1;
}

static bool GiveFocusToFocusableOffspring( wxWindow* pWnd )
{
    TRACEUSER( "jlh92", _T("GF2FO class %s\n"), pWnd->GetClassInfo()->GetClassName() );

    // Can we give focus to passed window. Yes, give focus
    // and return happy
    if( pWnd->AcceptsFocus() )
    {
        TRACEUSER( "jlh92", _T("Focused!\n") );
        pWnd->SetFocus();
        return true;
    }

    // No, lets try the children then
    wxWindowList&       lstChild = pWnd->GetChildren();
    wxWindowListNode*   pNode = lstChild.GetFirst();
    while( NULL != pNode )
    {
        if( GiveFocusToFocusableOffspring( pNode->GetData() ) )
            return true;

        pNode = pNode->GetNext();
    }
    
    return false;
}


/***************************************************************************************************************************/
//
// Initialisation.
//

const wxString camIPC_START = _T("StartOther");

class CamIPCConnection : public wxConnection
{

public:
    CamIPCConnection() : wxConnection(m_pBuffer, WXSIZEOF(m_pBuffer)) {}

    virtual bool OnExecute (const wxString& WXUNUSED(topic),
                            wxChar *data,
                            int /* TYPENOTE: Correct */ size,
                            wxIPCFormat WXUNUSED(format))
    {
        // argv buffer
        INT32 argc = 0;

        INT32 i;
        for (i=0; i<size; i++)
        {
            // exit if this is a NULL, and the last character was a NULL
            if (!data[i] && i && !data[i-1])
                break;

            if (!data[i])
                argc++;
        }

        wxChar ** argv = new wxChar*[argc];

        wxChar* p = data;
        for (i=0; i<argc; i++)
        {
            argv[i] = camStrdup(p);
            p+=wxStrlen(argv[i])+1; // move past null
        }

        BOOL result = wxGetApp().OnSecondInstance(argv, argc);

        // free memory
        for (i=0; i<argc; i++)
        {
            free(argv[i]);
        }
        delete [] argv;

        // return
        return result;
    }

private:
    wxChar m_pBuffer[4096];

};

class CamIPCServer : public wxServer
{
public:
    virtual wxConnectionBase *OnAcceptConnection (const wxString& topic)
    {
        if (topic != camIPC_START)
            return NULL;
        else
            return new CamIPCConnection;
    }
};

// Global so we can use it for parsing second instance
static const wxCmdLineEntryDesc cmdLineDesc[] =
{
#if defined(_DEBUG)
    { wxCMD_LINE_OPTION, _T("u"), _T("user"), _T("set username for debug tracing") },
    { wxCMD_LINE_SWITCH, _T("m"), _T("memorycheck"), _T("check memory") },
    { wxCMD_LINE_OPTION, _T("l"), _T("listdebug"), _T("list debug level") , wxCMD_LINE_VAL_NUMBER },
#endif
    { wxCMD_LINE_SWITCH, _T("h"), _T("help"),   _T("Display this help"), wxCMD_LINE_VAL_NONE, wxCMD_LINE_OPTION_HELP },
    { wxCMD_LINE_SWITCH, _T("v"), _T("version"),    _T("Display the version information") },
    { wxCMD_LINE_OPTION, _T("r"), _T("resource"),   _T("resource directory") },
    { wxCMD_LINE_SWITCH, _T("x"), _T("xrccheckgen"), _T("generate xrc.check file") },
    { wxCMD_LINE_PARAM, NULL, NULL, _T("input file"), wxCMD_LINE_VAL_STRING, 
                                        wxCMD_LINE_PARAM_OPTIONAL|wxCMD_LINE_PARAM_MULTIPLE },
    { wxCMD_LINE_NONE }
};

BOOL CCamApp::OnSecondInstance(wxChar** argv, INT32 argc)
{
    // Parse command line. We do this early so we get flags which
    // are useful for init, such as -u
    //
    wxCmdLineParser parser(argc,argv);
    parser.SetDesc(cmdLineDesc);
    if (parser.Parse()) // Handles help automatically
    {
        return FALSE;
    }
    if (parser.GetParamCount()>=1)
    {
        for ( UINT32 i=0 ; i<parser.GetParamCount() ; i++ )
            m_docManager->CreateDocument(parser.GetParam(i),wxDOC_SILENT);
    }
    m_pMainFrame->Raise();
    return TRUE;
}

bool CCamApp::OnInit()
{
    InInitOrDeInit = TRUE; // Don't allow the user to try carrying on working
    ::wxHandleFatalExceptions(TRUE);

    //
    // Parse command line. We do this early so we get flags which
    // are useful for init, such as -u
    //
    wxCmdLineParser parser(argc,argv);
    parser.SetDesc(cmdLineDesc);
    if (parser.Parse()) // Handles help automatically
    {
        return FALSE;
    }

    wxString ResourceDir = _T("");
    if (parser.Found(_T("r"), &ResourceDir))
    {
        if (!ResourceDir.IsEmpty())
        {
            CamResource::SetResourceFilePath(ResourceDir);
        }

        if ( parser.Found( _T("x") ) )
        {
            CamResource::SetGenerateXRCCheck(TRUE);
        }
    }

    if( parser.Found( _T("v") ) )
    {
        wxString            strMessage;

#if defined(__WXMSW__)
        strMessage = wxString::Format( wxT("Xara Xtreme\nVersion: %s\nCDraw Version: %d.%03d\n"), 
            g_pszAppVersion, HIWORD(GDraw_GetVersion()), LOWORD(GDraw_GetVersion()) );
#else
#if FALSE == wxUSE_UNICODE
        TCHAR*          pszCDrawVer = GDraw_GetSvnVersion();
#else
        TCHAR           pszCDrawVer[32];
        camMbstowcs( pszCDrawVer, GDraw_GetSvnVersion(), 31 );
#endif
        strMessage = wxString::Format( wxT("Xara Xtreme\nVersion: %s (%s)\nCDraw Version: %d.%03d (%s)\nBuild date: %s\n"), 
            g_pszAppVersion, g_pszSvnVersion, HIWORD(GDraw_GetVersion()), LOWORD(GDraw_GetVersion()), pszCDrawVer, CAMELOT_BUILD_DATE );
#endif

        camPrintf( strMessage.c_str() );
        
        return FALSE;
    }
    
#if defined(_DEBUG)
    if (parser.Found(_T("m"))) SimpleCCObject::CheckMemoryFlag=1;

    long listlevel; // TYPENOTE: Correct - wxWidgets doesn't know about INT32 etc.
    if (parser.Found(_T("l"), &listlevel))
    {
        List::ListDebugLevel = listlevel;
    }

    // Set up the username for tracing
    // We should default this to the environment setting for (say) LOGNAME
    wxString Username = _T("");

    // Overwrite with LOGNAME if it is set
    wxGetEnv(_T("LOGNAME"), &Username);

    // Overwrite with -u option if it is set
    parser.Found(_T("u"), &Username);

    Error::SetUserName(Username);

    if (Username==_T(""))
    {
        TRACEUSER("ALL", _T("No user specific trace output\n"));
    }
    else
    {
//      TRACEUSER("ALL",_T("Tracing output where user is %s\n"),(const char *)Username.mb_str(wxConvUTF8));
        TRACEUSER("ALL",_T("Tracing output where user is %s\n"),(const TCHAR *)Username.c_str());
    }

    TRACEUSER("ALL",_T("Memory debugging %d, List debugging %d\n"), SimpleCCObject::CheckMemoryFlag, List::ListDebugLevel);

#endif

    // OK, now we've handled the help case, and some VERY early init, we should see if another instance
    // is running.

    // Set and check for single instance running
    wxString SIname = wxString(_T(".XARA-XTREME-WX-"))  +GetAppName()+wxString::Format(_T("-%s"), wxGetUserId().c_str());
    wxFileName IPCfn(wxGetHomeDir(),SIname+_T(".ipc"));
    wxString IPCname = IPCfn.GetFullPath();

    m_pSingleInstanceChecker = NULL;
    m_pServer = NULL;

#ifdef _DEBUG
    BOOL SingleInstanceCheck = FALSE;
#else
    BOOL SingleInstanceCheck = TRUE;
#endif

    if (SingleInstanceCheck)
    {
        // Create a single instance checker at that location
        m_pSingleInstanceChecker = new wxSingleInstanceChecker(SIname);
        if (!m_pSingleInstanceChecker)
        {
            ERROR2(FALSE, "Failed to create single instance checker");
        }
    
        // Now see if another is running
        if (m_pSingleInstanceChecker->IsAnotherRunning())
        {
            wxClient Client;
            wxConnectionBase * Connection = Client.MakeConnection(wxEmptyString, IPCname, camIPC_START);
    
            // If there is no connection, perhaps the other end is dead. We will start up anyway.
            if (Connection)
            {
                INT32 len=1; // terminating null
                INT32 i;
    
                wxArrayString docs;
                INT32 doccount = parser.GetParamCount()+1; // add one for the dummy
    
                // Add all docs with a dummy argv[0]
                for ( i=0 ; i<doccount; i++ )
                {
                    wxString docname;
                    if (i)
                    {
                        docname = parser.GetParam(i-1);
                        wxFileName fn(docname);
                        fn.Normalize(wxPATH_NORM_ALL);
                        docname=fn.GetFullPath();
                    }
                    else
                    {
                        docname=argv[0];
                    }
                    len+=docname.length()+1; // include the trailing zero
                    docs.Add(docname);
                }
    
                wxChar * Data = new wxChar[len];
                if (!Data)
                {
                    ERROR2(FALSE, "Failed to create single instance checker data");
                }
    
                // Copy the 
                wxChar * p = Data;
                for (i = 0; i < doccount; i++)
                {
                    wxStrcpy(p, docs[i]);
                    p+=docs[i].length()+1; // move past string and terminating NULL
                }
                *p = _T('\0'); // add a final terminating NULL
    
                // Now send the data over the connection
                if (Connection->Execute (Data, len*sizeof(wxChar)))
                {
                    delete [] Data;
                    delete Connection;
    
                    //.Free up the single instance checker
                    delete m_pSingleInstanceChecker;
                    m_pSingleInstanceChecker = NULL;
    
                    // We're out of here...
                    return FALSE;
                }
    
                // Hmmmm, it didn't want to execute it. perhaps the other process is stuck. We'll run anyway
                delete [] Data;
                delete Connection;
            }
        }
    }

    // OK, we are the only instance running. Delete any stale socket (ours has not been created yet).
    ::wxRemoveFile(IPCname);

    // Register the image handler which loads CURs (used for Cursors, obviously)
    wxImage::AddHandler( new wxCURHandler );

    // Register the image handler which loads PNGs (used for TBs)
    wxImage::AddHandler( new wxPNGHandler );

    // Init the BinReloc stuff (we don't really care if this fails, since it
    // fails safe)
    BrInitError error;
    br_init( &error );
    
    // Useful debug tracing enablers, left here for next debug session...
//  wxLog::AddTraceMask( _T("focus") );
//  wxLog::AddTraceMask( _T("keyevent") );

    // Initialise the MonotonicTime class
    MonotonicTime::Init();

    // We initialize profiling here to allow the rest of the app to be profiled
    CamProfile::Init();
    // Don't start profiling until Alex has finished the code!
    CamProfile::ActivateProfiling(TRUE);
    // Indicate time from now on should be assigned to "OTHER"
    CamProfile::AtBase(CAMPROFILE_OTHER);

    TRACET(_T("CCamApp::OnInit first available time to trace"));

    // Initialize resources system
    if (!CamResource::Init()) return FALSE;
    // Initialize the art provider - needed for dialogs
    wxPlatformDependent::Init(CLASSINFO(CamPlatformDependent));
    if (!CamArtProvider::Init()) return FALSE;
    // We need this pretty early so we can handle ERROR boxes etc
    if (!DialogEventHandler::Init()) return FALSE;
    if (!ControlList::Init()) return FALSE;

    TRACET(_T("CCamApp::Calling Camelot.Init"));

    // Initialise the kernel application object & Prefs
    if( !Camelot.Init() )
        return false;

    // --------------------------------------------------------------------------
    // Detect first-time run and make Open File dialog default to Examples folder
    if (Camelot.DeclareSection(TEXT("Preferences"), 10))
    {
        Camelot.DeclarePref(NULL, TEXT("FirstRun"), &bFirstRun, 0, 1);
    }

    // Check the resource dir exists
    Camelot.DeclarePref( NULL, TEXT("ResourceDirOverride"), &m_strResourceDirPathOverride );
    m_strResourceDirPath = m_strResourceDirPathOverride; // this way, the path we find never gets put within the preferences
    if( /*bFirstRun ||*/ m_strResourceDirPath == _T("") || !wxDir::Exists( (PCTSTR)m_strResourceDirPath ) ) // AB: don't need to do this on first run especially
    {
#if !defined(RESOURCE_DIR)
        // we can't use auto pointers here because they free using delete but BR allocates using malloc (strdup actually)
        char * pszDataPath = br_find_data_dir( "/usr/share" );
        if (pszDataPath)
        {
            m_strResourceDirPath = wxString( pszDataPath, wxConvFile );
            free(pszDataPath);
            m_strResourceDirPath += _T("/xaralx");
            TRACEUSER( "luke", _T("Using resource directory \"%s\"\n"), PCTSTR(m_strResourceDirPath) );
#if defined(_DEBUG)
            if( !wxDir::Exists( PCTSTR(m_strResourceDirPath) ) )
            {
                // We'll try default location under debug to make life easier
                m_strResourceDirPath = _T("/usr/share/xaralx");
                TRACEUSER( "luke", _T("Try = \"%s\"\n"), PCTSTR(m_strResourceDirPath) );
            }
#endif
        }
#else
        // The "" is needed to stop the macro expanding to LRESOURCE_DIR
        m_strResourceDirPath = _T(""RESOURCE_DIR);
#endif
    }
    TRACEUSER( "luke", _T("ResDir = %s\n"), PCTSTR(m_strResourceDirPath) );

    // Get the media replay application setting
    Camelot.DeclarePref( NULL, TEXT("MediaApplication"), &m_strMediaApplication );

    TRACET(_T("CCamApp::Calling InitKernel"));
    // then initialise the kernel (and almost everything else)  
    if( !InitKernel() )
        return false;

    if( !Camelot.LateInit() )
        return false;

    TRACET(_T("CCamApp::Calling GRenderRegion::Init"));
    if (!GRenderRegion::Init(true))
        return false;

    // Declare the prefs for the window size and state
    if (Camelot.DeclareSection(TEXT("Windows"), 10))
    {
        Camelot.DeclarePref(NULL, TEXT("MainWndMax"), &MainWndMaximized, 0, 1);
        Camelot.DeclarePref(NULL, TEXT("MainWndMin"), &MainWndMinimized, 0, 1);
        Camelot.DeclarePref(NULL, TEXT("MainWndPos"), &MainWndPosString);
    }

    TRACET(_T("CCamApp::Making Doc Manager"));
    
    // Create the document manager and register our doc template
    m_docManager = std::auto_ptr<wxDocManager>( new wxDocManager() );

    wxDocTemplate      *pDocTemplate;
    pDocTemplate = new CCamDocTemplate(
        m_docManager.get(), wxT("Xara"), wxT("*.xar;*.web"), wxT(""), wxT("xar"), wxT("Xara document"), 
        wxT("Text View"),
        CLASSINFO(CCamDoc),
        CLASSINFO(CCamView) );
//  pDocTemplate = new CCamDocTemplate(
//      m_docManager.get(), wxT("Xara"), wxT("*.web"), wxT(""), wxT("web"), wxT("Xara document"), 
//      wxT("Text View"),
//      CLASSINFO(CCamDoc),
//      CLASSINFO(ScreenCamView) );

    // Reload the file history (9 entries)
    wxFileHistory*      pFileHist = m_docManager->GetFileHistory();
    for( UINT32 ord = 0; ord < 9; ++ord )
    {
        // This is safe since we control all variables!
        TCHAR           pszTag[8];
        camSprintf( pszTag, _T("File%d"), ord );

        String_256      strFileName;
        Camelot.GetPrefDirect( _T("Recent File list"), pszTag, &strFileName );
        
        if( strFileName != _T("") )
            pFileHist->AddFileToHistory( PCTSTR(strFileName) );
    }

    if (bFirstRun)
    {
        // Set File Open dialog location to our Examples folder
        wxString    strConfigPath( (TCHAR*)m_strResourceDirPath );
        strConfigPath += _T("/Examples");

#if defined(_DEBUG)
        // Debug-only fallback
        if (!wxDir::Exists(strConfigPath))
            strConfigPath = _T("/usr/share/xaralx/Examples");
#endif

        if (wxDir::Exists(strConfigPath))
            BaseFileDialog::DefaultOpenFilePath = strConfigPath;
    }

    // NOTE! Set bFirstRun = FALSE in OnExit handler below
    // --------------------------------------------------------------------------

    // Set idles to only get sent to windows that want them
    wxIdleEvent::SetMode(wxIDLE_PROCESS_SPECIFIED); 

    // Create the Frame window
    //
    // get user preference info for main window
    wxSize ScreenSize = ::wxGetDisplaySize();
    wxRect WndRect;
    wxSize OldScreenSize;
    if ((camSscanf(MainWndPosString, _T("%d %d %d %d %d %d"),
            &WndRect.x, &WndRect.y, &WndRect.width, &WndRect.height, &OldScreenSize.x, &OldScreenSize.y) == 6) &&
            (WndRect.width > 0) && (WndRect.height > 0))
    {
        // numbers scanned OK, scale them to fit current screen size
        if (OldScreenSize.x != ScreenSize.x)
        {
            // if screen size different from last time, them scale them
            WndRect.x = MulDiv(WndRect.x, ScreenSize.x, OldScreenSize.x);
            WndRect.width = MulDiv(WndRect.width, ScreenSize.x, OldScreenSize.x);
        }
        if (OldScreenSize.y != ScreenSize.y)
        {
            WndRect.y = MulDiv(WndRect.y, ScreenSize.y, OldScreenSize.y);
            WndRect.height = MulDiv(WndRect.height, ScreenSize.y, OldScreenSize.y);
        }
    }
    else
    {
        // make up a sensible default position for the window, inset five percent
        // in x and 10 percent in y to avoid taskbars on linux
        WndRect.x = ScreenSize.x / 20;
        WndRect.width = ScreenSize.x - WndRect.x * 2;
        WndRect.y = ScreenSize.y / 10;
        WndRect.height = ScreenSize.y - WndRect.y * 2;
    }

    TRACET(_T("CCamApp::Making Frame Window"));
    m_pMainFrame = new CCamFrame( m_docManager.get(), (wxFrame *)NULL, wxT("Xara Xtreme"), 
        WndRect.GetPosition(), WndRect.GetSize(), wxDEFAULT_FRAME_STYLE);

    m_pMainFrame->Show(FALSE); // Don't show it yet

#if !defined(XARA_MENUGEN)
    TRACET(_T("CCamApp::Making Menu structure"));
    //
    // Build the MDI style file menu
    // This is just a simple menu. The full menu is created
    // after loading a document.
    //
    wxMenu* pFileMenu = new wxMenu;

    pFileMenu->Append( wxID_NEW,  wxT("&New...") );
    pFileMenu->Append( wxID_OPEN, wxT("&Open...") );

#if defined(FILELIST)
    wxMenu* pRecentFilesMenu = new wxMenu;
    m_docManager->FileHistoryUseMenu(pRecentFilesMenu);
    m_docManager->FileHistoryAddFilesToMenu(pRecentFilesMenu);

    pFileMenu->AppendSeparator();
    pFileMenu->Append( -1, wxT("&Recent files"),pRecentFilesMenu );
#endif //defiend(FILELIST)

    pFileMenu->AppendSeparator();
    pFileMenu->Append( wxID_EXIT, wxT("E&xit") );

    // Build help menu
    wxMenu             *pHelpMenu = new wxMenu;
    pHelpMenu->Append( _R(DOCVIEW_ABOUT), wxT("&About...") );

    // Place menus into the menu bar
    wxMenuBar          *pMenuBar = new wxMenuBar;
    pMenuBar->Append( pFileMenu, wxT("File") );
    pMenuBar->Append( pHelpMenu, wxT("Help") );

#ifdef __WXMAC__
    wxMenuBar::MacSetCommonMenuBar( pMenuBar );
#endif //def __WXMAC__

    // Set up menu bar...
    m_pMainFrame->SetMenuBar( pMenuBar );

#else

#ifdef __WXMAC__
    wxMenuBar::MacSetCommonMenuBar( WinMDIMenu );
#endif //def __WXMAC__

    // Set up menu bar...
    m_pMainFrame->SetMenuBar( WinMDIMenu );
    WinMDIMenu->ClearAccelTable();

#endif

    // We don't want auto-accelerators, this is done using our hotkeys
    // I don't know how to do this yet, but I'm looking....
//  wxAcceleratorTable* pAccelTable = pMenuBar->GetAccelTable();
//  *pAccelTable = wxAcceleratorTable();

    TRACET(_T("CCamApp::Init Setting mainframe as top window"));

    m_pMainFrame->CreateToolbars();
    m_pMainFrame->UpdateFrameManager();

    // Show the main frame window
    // make maximized if thats what we were last time, unless overridden by user
    if (MainWndMaximized)
    {
        m_pMainFrame->Maximize();
    }
    if (MainWndMinimized)
    {
        m_pMainFrame->Iconize();
    }
    SetTopWindow( m_pMainFrame );
    ::wxYield(); // allow resizing to take place
    m_pMainFrame->Show( true );
    ::wxYield(); // allow resizing to take place
    wxPlatformDependent::Get()->FixUpdate(m_pMainFrame); // Force the main frame to be redrawn properly
    ::wxYield(); // allow resizing to take place

#ifndef EXCLUDE_FROM_XARALX
    m_pMainFrame->CacheNormalPlaceMode();
    m_pMainFrame->CheckFullScreenMode();

    // if the splash box is up, draw our window behind it (will be a big pending WM_PAINT)
    // IT MUST NOT BE ACTIVE else palette problems
    if (AfxOleGetUserCtrl())
    {
        if (m_nCmdShow == SW_SHOWMINIMIZED || m_nCmdShow == SW_SHOWMINNOACTIVE)
        {
            pMainFrame->ShowWindow(SW_SHOWMINNOACTIVE);
        }
        else
        {
            if (m_nCmdShow == SW_SHOWMAXIMIZED)
                m_pMainWnd->ShowWindow(SW_SHOWMAXIMIZED);
            else
                pMainFrame->ShowWindow(SW_SHOWNOACTIVATE);

            // the ShowWindow() above has made the main window active so make the splash box active, else
            // we get nasty palette problems later on
            pSplashbox->SetActiveWindow();
        }
    }
#endif

    Tool::SelectFirstTool();

    // Go through the command line and load documents
    TRACET(_T("CCamApp::Init Loading docs (if any) from command line"));

    if( 0 == parser.GetParamCount() )
        m_docManager->CreateDocument( _T(""), wxDOC_NEW );
    else
    {
        for ( UINT32 i=0 ; i<parser.GetParamCount() ; i++ )
            m_docManager->CreateDocument(parser.GetParam(i),wxDOC_SILENT);
    }

    // Remove the splash screen
    CamResource::DoneInit();

    CXMLUtils::Initialise();

    if (SingleInstanceCheck)
    {
        // We are able to load documents, so now start our own IPC server
        m_pServer = new CamIPCServer();
        if (!m_pServer)
        {
            delete (m_pSingleInstanceChecker);
            m_pSingleInstanceChecker = NULL;
            ERROR2(FALSE, "Failed to create IPC server");
        }
    
        // and initialize it
        if (!(m_pServer->Create(IPCname)))
        {
            delete m_pServer;
            m_pServer = NULL;
    
            delete (m_pSingleInstanceChecker);
            m_pSingleInstanceChecker = NULL;
            ERROR2(FALSE, "Failed to init IPC server");
        }
    }

    // Give focus to any child that will take it, parent can't have it since
    // it's a frame (see gtk_widget_grab_focus)
    GiveFocusToFocusableOffspring( m_pMainFrame );
    
    // Create timer used for background rendering.
//  m_Timer.SetOwner(this,CAM_TIMER_ID);
//  m_Timer.Start(CAM_TIMER_FREQUENCY);

    InInitOrDeInit = FALSE; // Now allow the user a chance to save their work on a SEGV

    return true;
}

/***************************************************************************************************************************/
//
// Deinitialisation.
//

INT32 CCamApp::OnExit( void )
{
    InInitOrDeInit = TRUE; // Don't allow them to save their work on a SEGV
    // We can no longer stop the closedown, so flag this fact
    Camelot.ShuttingDown(TRUE);

    // Dump the file history (9 entries as for Xtreme 4 Win)
    wxFileHistory*      pFileHist = m_docManager->GetFileHistory();
    UINT32              cRecent   = UINT32(pFileHist->GetCount());
    for( UINT32 ord = 0; ord < 9; ++ord )
    {
        // This is safe since we control all variables!
        TCHAR           pszTag[8];
        camSprintf( pszTag, _T("File%d"), ord );

        if( ord < cRecent )
        {
            wxString    strFileName( pFileHist->GetHistoryFile( ord ) );
            Camelot.SetPrefDirect( _T("Recent File list"), pszTag, PCTSTR(strFileName), TRUE );
        }
        else
            Camelot.SetPrefDirect( _T("Recent File list"), pszTag, _T(""), TRUE );
    }

    // we can't load documents any more - delete IPC server
    if (m_pServer)
    {
        delete m_pServer;
        m_pServer = NULL;
    }

    // delete single instance checked
    if (m_pSingleInstanceChecker)
    {
        delete m_pSingleInstanceChecker;
        m_pSingleInstanceChecker = NULL;
    }

    // Rendering is back on idle events for now as it actually works
//  m_Timer.Stop();

#if defined(FILELIST)
    {
        m_docManager->FileHistorySave(Preferences::GetOilPrefs());
    }
#endif
    m_docManager = std::auto_ptr<wxDocManager>( NULL );

    bFirstRun = FALSE;

    // Now deinit everything

    CXMLUtils::DeInitialise();

    DeinitKernel();

#if CUSTOM_INONE == 2
    DLLControlClass::DeinitAllControls();
#endif

    GRenderRegion::DeInit();                        // tidy up GDraw

PORTNOTE("other","Removed GDI+, filelist and profilename support")
#ifndef EXCLUDE_FROM_XARALX
    Gdiplus::GdiplusShutdown(gdiplusToken);

    // Finished with preferences/registry so remove the allocated ProfileName. Was not here before 18/2/97
    if (m_pszProfileName != NULL)
    {
        free((void *) m_pszProfileName);
        m_pszProfileName = NULL;
    }
#endif

    ControlList::DeInit();
    DialogEventHandler::DeInit();
    // Kill of art provider
    CamArtProvider::DeInit();
    wxPlatformDependent::DeInit();
    // Kill of resources
    CamResource::DeInit();

    // Kill off profiling
    CamProfile::ActivateProfiling(FALSE);

#if DUMP_MEM_AT_END
    MemoryState.DumpAllObjectsSince();
#endif

    // We want a memory dump on Debug builds only
#ifdef _DEBUG
    SimpleCCObject::MemoryDump();
    DumpCCMallocTrace();
#endif
    
PORTNOTE("other","Removed 3D, Extras and UserHelp support")
#ifndef EXCLUDE_FROM_XARALX
    // For fabby 3D
    if (Is3dWanted())
        pCtl3dUnregister(AfxGetInstanceHandle()); 

    OILModule::DeinitExtras();                          // free all DLLs (e.g. ctl3d)

    // Last of all, deinit the help system now that there's very little else to go wrong.
    DeInitUserHelp();
#endif

    // zap this after we know all windows have gone
    wxWindowDeletionWatcher::DeInit();

    ::wxHandleFatalExceptions(FALSE);
    return wxApp::OnExit();
}

//  WEBSTER-ranbirr-12/11/96
#ifndef WEBSTER
void CCamApp::OnFilePrintSetup()
{
#ifndef STANDALONE
    Document *pDoc = Document::GetSelected();
    DocView *pDocView = DocView::GetSelected();

    if (pDoc && pDocView && pDocView->GetConnectionToOilView())
    {
        // Inform the user if we have switched to using the default printer on the system
        // before opening the print setup dlg.
        CCPrintDialog::InformResetToDefaultPrinter(FALSE);
    
        // This no longer calls the base class OnFilePrint() function.
        // Instead, we involke the print dlg ourselves so that we can update our
        // printer settings when the dlg is closed via the user clicking on OK
        // (7/4/95 - Markn)

        CCPrintInfo printinfo(pDoc, pDocView->GetConnectionToOilView());
        printinfo.OnPreparePrinting(TRUE);          
    }
    
#endif
}
#endif

void CCamApp::OnAppExit()
{
PORTNOTE("other","Removed multi-instance flag stuff")
#ifndef EXCLUDE_FROM_XARALX
    // remove the flag that prevents camelot starting more than once; BUT only if were
    // the camelot that set it!

    HWND mainWindow = m_pMainWnd->m_hWnd;
    
    if (mainWindow)
    {
        BOOL* ret = (BOOL*) RemoveProp (m_pMainWnd->m_hWnd, "Xara X sfs");

        if (ret) delete (ret);
    }
#endi