utils/emulator/src/emulator.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        emulator.cpp
// Purpose:     Emulator wxWidgets sample
// Author:      Julian Smart
// Modified by:
// Created:     04/01/98
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

// for all others, include the necessary headers (this file is usually all you
// need because it includes almost all "standard" wxWidgets headers)
#ifndef WX_PRECOMP
    #include "wx/wx.h"
#endif

#include "wx/confbase.h"
#include "wx/fileconf.h"
#include "wx/cmdline.h"
#include "wx/image.h"
#include "wx/file.h"

#ifdef __WXX11__
#include "wx/x11/reparent.h"
#endif

#include "emulator.h"

// ----------------------------------------------------------------------------
// resources
// ----------------------------------------------------------------------------

// the application icon (under Windows and OS/2 it is in resources)
#if defined(__WXGTK__) || defined(__WXMOTIF__) || defined(__WXMAC__) || defined(__WXMGL__) || defined(__WXX11__)
    #include "emulator.xpm"
#endif

// ----------------------------------------------------------------------------
// event tables and other macros for wxWidgets
// ----------------------------------------------------------------------------

// the event tables connect the wxWidgets events with the functions (event
// handlers) which process them. It can be also done at run-time, but for the
// simple menu events like this the static method is much simpler.
BEGIN_EVENT_TABLE(wxEmulatorFrame, wxFrame)
    EVT_MENU(Emulator_Quit,  wxEmulatorFrame::OnQuit)
    EVT_MENU(Emulator_About, wxEmulatorFrame::OnAbout)
    EVT_CLOSE(wxEmulatorFrame::OnCloseWindow)
END_EVENT_TABLE()

// Create a new application object: this macro will allow wxWidgets to create
// the application object during program execution (it's better than using a
// static object for many reasons) and also declares the accessor function
// wxGetApp() which will return the reference of the right type (i.e. wxEmulatorApp and
// not wxApp)
IMPLEMENT_APP(wxEmulatorApp)

static const wxCmdLineEntryDesc sg_cmdLineDesc[] =
{
    { wxCMD_LINE_OPTION, _T("u"), _T("use-display"),   _T("display number to use (default 100)"), (wxCmdLineParamType)0, 0 },

    { wxCMD_LINE_SWITCH, _T("h"), _T("help"),   _T("displays help on the command line parameters"), (wxCmdLineParamType)0, 0 },
    { wxCMD_LINE_SWITCH, _T("v"), _T("version"),    _T("print version"), (wxCmdLineParamType)0, 0 },

    { wxCMD_LINE_PARAM,  NULL, NULL, _T("config file 1"), wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_OPTIONAL },

    { wxCMD_LINE_NONE, NULL, NULL, NULL, (wxCmdLineParamType)0, 0 }
};


// ============================================================================
// implementation
// ============================================================================

// ----------------------------------------------------------------------------
// the application class
// ----------------------------------------------------------------------------

wxEmulatorApp::wxEmulatorApp()
{
    m_xnestWindow = NULL;
    m_containerWindow = NULL;
    m_displayNumber = wxT("100");
    m_xnestPID = 0;

}

// 'Main program' equivalent: the program execution "starts" here
bool wxEmulatorApp::OnInit()
{
#if wxUSE_LOG
    wxLog::SetTimestamp(NULL);
#endif // wxUSE_LOG
    wxInitAllImageHandlers();

    wxString currentDir = wxGetCwd();

    // Use argv to get current app directory
    m_appDir = wxFindAppPath(argv[0], currentDir, wxT("WXEMUDIR"));

    // If the development version, go up a directory.
#ifdef __WXMSW__
    if ((m_appDir.Right(5).CmpNoCase(_T("DEBUG")) == 0) ||
        (m_appDir.Right(11).CmpNoCase(_T("DEBUGSTABLE")) == 0) ||
        (m_appDir.Right(7).CmpNoCase(_T("RELEASE")) == 0) ||
        (m_appDir.Right(13).CmpNoCase(_T("RELEASESTABLE")) == 0)
        )
        m_appDir = wxPathOnly(m_appDir);
#endif

    // Parse the command-line parameters and options
    wxCmdLineParser parser(sg_cmdLineDesc, argc, argv);
    int res;
    {
        wxLogNull log;
        res = parser.Parse();
    }
    if (res == -1 || res > 0 || parser.Found(wxT("h")))
    {
#ifdef __X__
        wxLog::SetActiveTarget(new wxLogStderr);
#endif
        parser.Usage();
        return false;
    }
    if (parser.Found(wxT("v")))
    {
#ifdef __X__
        wxLog::SetActiveTarget(new wxLogStderr);
#endif
        wxString msg;
        msg.Printf(wxT("wxWidgets PDA Emulator (c) Julian Smart, 2002 Version %.2f, %s"), wxEMULATOR_VERSION, __DATE__);
        wxLogMessage(msg);
        return false;
    }
    if (parser.Found(wxT("u"), & m_displayNumber))
    {
        // Should only be number, so strip out anything before
        // and including a : character
        if (m_displayNumber.Find(wxT(':')) != -1)
        {
            m_displayNumber = m_displayNumber.AfterFirst(wxT(':'));
        }
    }
    if (parser.GetParamCount() == 0)
    {
        m_emulatorInfo.m_emulatorFilename = wxT("default.wxe");
    }
    else if (parser.GetParamCount() > 0)
    {
        m_emulatorInfo.m_emulatorFilename = parser.GetParam(0);
    }

    // Load the emulation info
    if (!LoadEmulator(m_appDir))
    {
        //wxMessageBox(wxT("Sorry, could not load this emulator. Please check bitmaps are valid."));
        return false;
    }

    // create the main application window
    wxEmulatorFrame *frame = new wxEmulatorFrame(_T("wxEmulator"),
                                 wxPoint(50, 50), wxSize(450, 340));

#if wxUSE_STATUSBAR
    frame->SetStatusText(m_emulatorInfo.m_emulatorTitle, 0);

    wxString sizeStr;
    sizeStr.Printf(wxT("Screen: %dx%d"), (int) m_emulatorInfo.m_emulatorScreenSize.x,
            (int) m_emulatorInfo.m_emulatorScreenSize.y);
    frame->SetStatusText(sizeStr, 1);
#endif // wxUSE_STATUSBAR

    m_containerWindow = new wxEmulatorContainer(frame, wxID_ANY);

    frame->SetClientSize(m_emulatorInfo.m_emulatorDeviceSize.x,
                         m_emulatorInfo.m_emulatorDeviceSize.y);

    // and show it (the frames, unlike simple controls, are not shown when
    // created initially)
    frame->Show(true);

#ifdef __WXX11__
    m_xnestWindow = new wxAdoptedWindow;

    wxString cmd;
    cmd.Printf(wxT("Xnest :%s -geometry %dx%d"),
        m_displayNumber.c_str(),
        (int) m_emulatorInfo.m_emulatorScreenSize.x,
        (int) m_emulatorInfo.m_emulatorScreenSize.y);

    // Asynchronously executes Xnest
    m_xnestPID = wxExecute(cmd);
    if (0 == m_xnestPID)
    {
        frame->Destroy();
        wxMessageBox(wxT("Sorry, could not run Xnest. Please check your PATH."));
        return false;
    }

    wxReparenter reparenter;
    if (!reparenter.WaitAndReparent(m_containerWindow, m_xnestWindow, wxT("Xnest")))
    {
        wxMessageBox(wxT("Sorry, could not reparent Xnest.."));
        frame->Destroy();
        return false;
    }

#endif
    m_containerWindow->DoResize();

    // success: wxApp::OnRun() will be called which will enter the main message
    // loop and the application will run. If we returned false here, the
    // application would exit immediately.
    return true;
}

// Prepend the current program directory to the name
wxString wxEmulatorApp::GetFullAppPath(const wxString& filename) const
{
    wxString path(m_appDir);
    if (path.Last() != '\\' && path.Last() != '/' && filename[0] != '\\' && filename[0] != '/')
#ifdef __X__
        path += '/';
#else
        path += '\\';
#endif
    path += filename;

    return path;
}


// Load the specified emulator.
// For now, hard-wired. TODO: make this configurable
bool wxEmulatorApp::LoadEmulator(const wxString& appDir)
{
    // Load config file and bitmaps
    return m_emulatorInfo.Load(appDir);
}

// ----------------------------------------------------------------------------
// main frame
// ----------------------------------------------------------------------------

// frame constructor
wxEmulatorFrame::wxEmulatorFrame(const wxString& title,
    const wxPoint& pos, const wxSize& size)
    : wxFrame(NULL, wxID_ANY, title, pos, size)
{
    // set the frame icon
    SetIcon(wxICON(emulator));

#if wxUSE_MENUS
    // create a menu bar
    wxMenu *menuFile = new wxMenu;

    // the "About" item should be in the help menu
    wxMenu *helpMenu = new wxMenu;
    helpMenu->Append(Emulator_About, _T("&About...\tF1"), _T("Show about dialog"));

    menuFile->Append(Emulator_Quit, _T("E&xit\tAlt-X"), _T("Quit this program"));

    // now append the freshly created menu to the menu bar...
    wxMenuBar *menuBar = new wxMenuBar();
    menuBar->Append(menuFile, _T("&File"));
    menuBar->Append(helpMenu, _T("&Help"));

    // ... and attach this menu bar to the frame
    SetMenuBar(menuBar);
#endif // wxUSE_MENUS

#if wxUSE_STATUSBAR
    // create a status bar just for fun (by default with 1 pane only)
    CreateStatusBar(2);
#endif // wxUSE_STATUSBAR
}


// event handlers

void wxEmulatorFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
{
    // true is to force the frame to close
    Close(true);
}

void wxEmulatorFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
{
    wxString msg;
    msg.Printf( _T("wxEmulator is an environment for testing embedded X11 apps.\n"));

    wxMessageBox(msg, _T("About wxEmulator"), wxOK | wxICON_INFORMATION, this);
}

void wxEmulatorFrame::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
{
#ifdef __WXX11__
    if (wxGetApp().m_xnestWindow)
    {
        wxGetApp().m_xnestWindow->SetHandle((WXWindow) NULL);
    }
#endif
    this->Destroy();
    if (wxGetApp().m_xnestPID > 0)
    {
        wxKill(wxGetApp().m_xnestPID);
        wxGetApp().m_xnestPID = 0;
    }
}

IMPLEMENT_CLASS(wxEmulatorContainer, wxWindow)

BEGIN_EVENT_TABLE(wxEmulatorContainer, wxWindow)
    EVT_SIZE(wxEmulatorContainer::OnSize)
    EVT_PAINT(wxEmulatorContainer::OnPaint)
    EVT_ERASE_BACKGROUND(wxEmulatorContainer::OnEraseBackground)
END_EVENT_TABLE()

wxEmulatorContainer::wxEmulatorContainer(wxWindow* parent, wxWindowID id):
    wxWindow(parent, id, wxDefaultPosition, wxDefaultSize)
{
}

void wxEmulatorContainer::OnSize(wxSizeEvent& WXUNUSED(event))
{
    DoResize();
}

void wxEmulatorContainer::DoResize()
{
    wxSize sz = GetClientSize();
    if (wxGetApp().m_xnestWindow
#ifdef __WXX11__
        && wxGetApp().m_xnestWindow->GetMainWindow()
#endif
        )
    {
        int deviceWidth = wxGetApp().m_emulatorInfo.m_emulatorDeviceSize.x;
        int deviceHeight = wxGetApp().m_emulatorInfo.m_emulatorDeviceSize.y;

        int x = wxMax(0, (int) ((sz.x - deviceWidth)/2.0));
        int y = wxMax(0, (int) ((sz.y - deviceHeight)/2.0));

        x += wxGetApp().m_emulatorInfo.m_emulatorScreenPosition.x;
        y += wxGetApp().m_emulatorInfo.m_emulatorScreenPosition.y;

        wxGetApp().m_xnestWindow->Move(x, y);
    }
    Refresh();
}

void wxEmulatorContainer::OnPaint(wxPaintEvent& WXUNUSED(event))
{
    wxPaintDC dc(this);

    wxSize sz = GetClientSize();
    if (wxGetApp().m_emulatorInfo.m_emulatorBackgroundBitmap.Ok())
    {
        int deviceWidth = wxGetApp().m_emulatorInfo.m_emulatorDeviceSize.x;
        int deviceHeight = wxGetApp().m_emulatorInfo.m_emulatorDeviceSize.y;

        int x = wxMax(0, (int) ((sz.x - deviceWidth)/2.0));
        int y = wxMax(0, (int) ((sz.y - deviceHeight)/2.0));

        dc.DrawBitmap(wxGetApp().m_emulatorInfo.m_emulatorBackgroundBitmap, x, y);
    }
}

void wxEmulatorContainer::OnEraseBackground(wxEraseEvent& event)
{
    wxDC* dc wxDUMMY_INITIALIZE(NULL);

    if (event.GetDC())
    {
        dc = event.GetDC();
    }
    else
    {
        dc = new wxClientDC(this);
    }

    dc->SetBackground(wxBrush(wxGetApp().m_emulatorInfo.m_emulatorBackgroundColour, wxSOLID));
    dc->Clear();

    if (!event.GetDC())
        delete dc;
}

// Information about the emulator decorations

void wxEmulatorInfo::Copy(const wxEmulatorInfo& info)
{
    m_emulatorFilename = info.m_emulatorFilename;
    m_emulatorTitle = info.m_emulatorTitle;
    m_emulatorDescription = info.m_emulatorDescription;
    m_emulatorScreenPosition = info.m_emulatorScreenPosition;
    m_emulatorScreenSize = info.m_emulatorScreenSize;
    m_emulatorBackgroundBitmap = info.m_emulatorBackgroundBitmap;
    m_emulatorBackgroundBitmapName = info.m_emulatorBackgroundBitmapName;
    m_emulatorBackgroundColour = info.m_emulatorBackgroundColour;
    m_emulatorDeviceSize = info.m_emulatorDeviceSize;
}

// Initialisation
void wxEmulatorInfo::Init()
{
    m_emulatorDeviceSize = wxSize(260, 340);
    m_emulatorScreenSize = wxSize(240, 320);
}

// Loads bitmaps
bool wxEmulatorInfo::Load(const wxString& appDir)
{
    // Try to find absolute path
    wxString absoluteConfigPath = m_emulatorFilename;
    if ( !::wxIsAbsolutePath(absoluteConfigPath) )
    {
        wxString currDir = wxGetCwd();
        absoluteConfigPath = currDir + wxString(wxFILE_SEP_PATH) + m_emulatorFilename;
        if ( !wxFile::Exists(absoluteConfigPath) )
        {
            absoluteConfigPath = appDir + wxString(wxFILE_SEP_PATH)
                + m_emulatorFilename;
        }
    }

    if ( !wxFile::Exists(absoluteConfigPath) )
    {
        wxString str;
        str.Printf( wxT("Could not find config file %s"),
            absoluteConfigPath.c_str() );

        wxMessageBox(str);
        return false;
    }

    wxString rootPath = wxPathOnly(absoluteConfigPath);

    {
        wxFileConfig config(wxT("wxEmulator"), wxT("wxWidgets"),
            absoluteConfigPath, wxEmptyString, wxCONFIG_USE_LOCAL_FILE);

        config.Read(wxT("/General/title"), & m_emulatorTitle);
        config.Read(wxT("/General/description"), & m_emulatorDescription);
        config.Read(wxT("/General/backgroundBitmap"), & m_emulatorBackgroundBitmapName);

        wxString colString;
        if (config.Read(wxT("/General/backgroundColour"), & colString) ||
            config.Read(wxT("/General/backgroundColor"), & colString)
           )
        {
            m_emulatorBackgroundColour = wxHexStringToColour(colString);
        }

        int x = 0, y = 0, w = 0, h = 0, dw = 0, dh = 0;
        config.Read(wxT("/General/screenX"), & x);
        config.Read(wxT("/General/screenY"), & y);
        config.Read(wxT("/General/screenWidth"), & w);
        config.Read(wxT("/General/screenHeight"), & h);
        if (config.Read(wxT("/General/deviceWidth"), & dw) && config.Read(wxT("/General/deviceHeight"), & dh))
        {
            m_emulatorDeviceSize = wxSize(dw, dh);
        }

        m_emulatorScreenPosition = wxPoint(x, y);
        m_emulatorScreenSize = wxSize(w, h);
    }

    if (!m_emulatorBackgroundBitmapName.empty())
    {
        wxString absoluteBackgroundBitmapName = rootPath + wxString(wxFILE_SEP_PATH) + m_emulatorBackgroundBitmapName;
        if ( !wxFile::Exists(absoluteBackgroundBitmapName) )
        {
            wxString str;
            str.Printf( wxT("Could not find bitmap %s"),
                absoluteBackgroundBitmapName.c_str() );
            wxMessageBox(str);
            return false;
        }

        wxBitmapType type = wxDetermineImageType(m_emulatorBackgroundBitmapName);
        if (type == wxBITMAP_TYPE_INVALID)
            return false;

        if (!m_emulatorBackgroundBitmap.LoadFile(m_emulatorBackgroundBitmapName, type))
        {
            wxString str;
            str.Printf( wxT("Could not load bitmap file %s"),
                m_emulatorBackgroundBitmapName.c_str() );
            wxMessageBox(str);
            return false;
        }

        m_emulatorDeviceSize = wxSize(m_emulatorBackgroundBitmap.GetWidth(),
            m_emulatorBackgroundBitmap.GetHeight());
    }
    return true;
}

// Returns the image type, or -1, determined from the extension.
wxBitmapType wxDetermineImageType(const wxString& filename)
{
    wxString path, name, ext;

    wxSplitPath(filename, & path, & name, & ext);

    ext.MakeLower();
    if (ext == _T("jpg") || ext == _T("jpeg"))
        return wxBITMAP_TYPE_JPEG;
    if (ext == _T("gif"))
        return wxBITMAP_TYPE_GIF;
    if (ext == _T("bmp"))
        return wxBITMAP_TYPE_BMP;
    if (ext == _T("png"))
        return wxBITMAP_TYPE_PNG;
    if (ext == _T("pcx"))
        return wxBITMAP_TYPE_PCX;
    if (ext == _T("tif") || ext == _T("tiff"))
        return wxBITMAP_TYPE_TIF;

    return wxBITMAP_TYPE_INVALID;
}

// Convert a colour to a 6-digit hex string
wxString wxColourToHexString(const wxColour& col)
{
    wxString hex;

    hex += wxDecToHex(col.Red());
    hex += wxDecToHex(col.Green());
    hex += wxDecToHex(col.Blue());

    return hex;
}

// Convert 6-digit hex string to a colour
wxColour wxHexStringToColour(const wxString& hex)
{
    unsigned char r = (unsigned char)wxHexToDec(hex.Mid(0, 2));
    unsigned char g = (unsigned char)wxHexToDec(hex.Mid(2, 2));
    unsigned char b = (unsigned char)wxHexToDec(hex.Mid(4, 2));

    return wxColour(r, g, b);
}

// Find the absolute path where this application has been run from.
// argv0 is wxTheApp->argv[0]
// cwd is the current working directory (at startup)
// appVariableName is the name of a variable containing the directory for this app, e.g.
// MYAPPDIR. This is checked first.

wxString wxFindAppPath(const wxString& argv0, const wxString& cwd, const wxString& appVariableName)
{
    wxString str;

    // Try appVariableName
    if (!appVariableName.empty())
    {
        str = wxGetenv(appVariableName);
        if (!str.empty())
            return str;
    }

    if (wxIsAbsolutePath(argv0))
        return wxPathOnly(argv0);
    else
    {
        // Is it a relative path?
        wxString currentDir(cwd);
        if (!wxEndsWithPathSeparator(currentDir))
            currentDir += wxFILE_SEP_PATH;

        str = currentDir + argv0;
        if ( wxFile::Exists(str) )
            return wxPathOnly(str);
    }

    // OK, it's neither an absolute path nor a relative path.
    // Search PATH.

    wxPathList pathList;
    pathList.AddEnvList(wxT("PATH"));
    str = pathList.FindAbsoluteValidPath(argv0);
    if (!str.empty())
        return wxPathOnly(str);

    // Failed
    return wxEmptyString;
}
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: emulator.cpp
	3	// Purpose: Emulator wxWidgets sample
	4	// Author: Julian Smart
	5	// Modified by:
	6	// Created: 04/01/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Julian Smart
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// ============================================================================
	13	// declarations
	14	// ============================================================================
	15
	16	// ----------------------------------------------------------------------------
	17	// headers
	18	// ----------------------------------------------------------------------------
	19
	20	// For compilers that support precompilation, includes "wx/wx.h".
	21	#include "wx/wxprec.h"
	22
	23	#ifdef __BORLANDC__
	24	#pragma hdrstop
	25	#endif
	26
	27	// for all others, include the necessary headers (this file is usually all you
	28	// need because it includes almost all "standard" wxWidgets headers)
	29	#ifndef WX_PRECOMP
	30	#include "wx/wx.h"
	31	#endif
	32
	33	#include "wx/confbase.h"
	34	#include "wx/fileconf.h"
	35	#include "wx/cmdline.h"
	36	#include "wx/image.h"
	37	#include "wx/file.h"
	38
	39	#ifdef __WXX11__
	40	#include "wx/x11/reparent.h"
	41	#endif
	42
	43	#include "emulator.h"
	44
	45	// ----------------------------------------------------------------------------
	46	// resources
	47	// ----------------------------------------------------------------------------
	48
	49	// the application icon (under Windows and OS/2 it is in resources)
	50	#if defined(__WXGTK__) \|\| defined(__WXMOTIF__) \|\| defined(__WXMAC__) \|\| defined(__WXMGL__) \|\| defined(__WXX11__)
	51	#include "emulator.xpm"
	52	#endif
	53
	54	// ----------------------------------------------------------------------------
	55	// event tables and other macros for wxWidgets
	56	// ----------------------------------------------------------------------------
	57
	58	// the event tables connect the wxWidgets events with the functions (event
	59	// handlers) which process them. It can be also done at run-time, but for the
	60	// simple menu events like this the static method is much simpler.
	61	BEGIN_EVENT_TABLE(wxEmulatorFrame, wxFrame)
	62	EVT_MENU(Emulator_Quit, wxEmulatorFrame::OnQuit)
	63	EVT_MENU(Emulator_About, wxEmulatorFrame::OnAbout)
	64	EVT_CLOSE(wxEmulatorFrame::OnCloseWindow)
	65	END_EVENT_TABLE()
	66
	67	// Create a new application object: this macro will allow wxWidgets to create
	68	// the application object during program execution (it's better than using a
	69	// static object for many reasons) and also declares the accessor function
	70	// wxGetApp() which will return the reference of the right type (i.e. wxEmulatorApp and
	71	// not wxApp)
	72	IMPLEMENT_APP(wxEmulatorApp)
	73
	74	static const wxCmdLineEntryDesc sg_cmdLineDesc[] =
	75	{
	76	{ wxCMD_LINE_OPTION, _T("u"), _T("use-display"), _T("display number to use (default 100)"), (wxCmdLineParamType)0, 0 },
	77
	78	{ wxCMD_LINE_SWITCH, _T("h"), _T("help"), _T("displays help on the command line parameters"), (wxCmdLineParamType)0, 0 },
	79	{ wxCMD_LINE_SWITCH, _T("v"), _T("version"), _T("print version"), (wxCmdLineParamType)0, 0 },
	80
	81	{ wxCMD_LINE_PARAM, NULL, NULL, _T("config file 1"), wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_OPTIONAL },
	82
	83	{ wxCMD_LINE_NONE, NULL, NULL, NULL, (wxCmdLineParamType)0, 0 }
	84	};
	85
	86
	87	// ============================================================================
	88	// implementation
	89	// ============================================================================
	90
	91	// ----------------------------------------------------------------------------
	92	// the application class
	93	// ----------------------------------------------------------------------------
	94
	95	wxEmulatorApp::wxEmulatorApp()
	96	{
	97	m_xnestWindow = NULL;
	98	m_containerWindow = NULL;
	99	m_displayNumber = wxT("100");
	100	m_xnestPID = 0;
	101
	102	}
	103
	104	// 'Main program' equivalent: the program execution "starts" here
	105	bool wxEmulatorApp::OnInit()
	106	{
	107	#if wxUSE_LOG
	108	wxLog::SetTimestamp(NULL);
	109	#endif // wxUSE_LOG
	110	wxInitAllImageHandlers();
	111
	112	wxString currentDir = wxGetCwd();
	113
	114	// Use argv to get current app directory
	115	m_appDir = wxFindAppPath(argv[0], currentDir, wxT("WXEMUDIR"));
	116
	117	// If the development version, go up a directory.
	118	#ifdef __WXMSW__
	119	if ((m_appDir.Right(5).CmpNoCase(_T("DEBUG")) == 0) \|\|
	120	(m_appDir.Right(11).CmpNoCase(_T("DEBUGSTABLE")) == 0) \|\|
	121	(m_appDir.Right(7).CmpNoCase(_T("RELEASE")) == 0) \|\|
	122	(m_appDir.Right(13).CmpNoCase(_T("RELEASESTABLE")) == 0)
	123	)
	124	m_appDir = wxPathOnly(m_appDir);
	125	#endif
	126
	127	// Parse the command-line parameters and options
	128	wxCmdLineParser parser(sg_cmdLineDesc, argc, argv);
	129	int res;
	130	{
	131	wxLogNull log;
	132	res = parser.Parse();
	133	}
	134	if (res == -1 \|\| res > 0 \|\| parser.Found(wxT("h")))
	135	{
	136	#ifdef __X__
	137	wxLog::SetActiveTarget(new wxLogStderr);
	138	#endif
	139	parser.Usage();
	140	return false;
	141	}
	142	if (parser.Found(wxT("v")))
	143	{
	144	#ifdef __X__
	145	wxLog::SetActiveTarget(new wxLogStderr);
	146	#endif
	147	wxString msg;
	148	msg.Printf(wxT("wxWidgets PDA Emulator (c) Julian Smart, 2002 Version %.2f, %s"), wxEMULATOR_VERSION, __DATE__);
	149	wxLogMessage(msg);
	150	return false;
	151	}
	152	if (parser.Found(wxT("u"), & m_displayNumber))
	153	{
	154	// Should only be number, so strip out anything before
	155	// and including a : character
	156	if (m_displayNumber.Find(wxT(':')) != -1)
	157	{
	158	m_displayNumber = m_displayNumber.AfterFirst(wxT(':'));
	159	}
	160	}
	161	if (parser.GetParamCount() == 0)
	162	{
	163	m_emulatorInfo.m_emulatorFilename = wxT("default.wxe");
	164	}
	165	else if (parser.GetParamCount() > 0)
	166	{
	167	m_emulatorInfo.m_emulatorFilename = parser.GetParam(0);
	168	}
	169
	170	// Load the emulation info
	171	if (!LoadEmulator(m_appDir))
	172	{
	173	//wxMessageBox(wxT("Sorry, could not load this emulator. Please check bitmaps are valid."));
	174	return false;
	175	}
	176
	177	// create the main application window
	178	wxEmulatorFrame *frame = new wxEmulatorFrame(_T("wxEmulator"),
	179	wxPoint(50, 50), wxSize(450, 340));
	180
	181	#if wxUSE_STATUSBAR
	182	frame->SetStatusText(m_emulatorInfo.m_emulatorTitle, 0);
	183
	184	wxString sizeStr;
	185	sizeStr.Printf(wxT("Screen: %dx%d"), (int) m_emulatorInfo.m_emulatorScreenSize.x,
	186	(int) m_emulatorInfo.m_emulatorScreenSize.y);
	187	frame->SetStatusText(sizeStr, 1);
	188	#endif // wxUSE_STATUSBAR
	189
	190	m_containerWindow = new wxEmulatorContainer(frame, wxID_ANY);
	191
	192	frame->SetClientSize(m_emulatorInfo.m_emulatorDeviceSize.x,
	193	m_emulatorInfo.m_emulatorDeviceSize.y);
	194
	195	// and show it (the frames, unlike simple controls, are not shown when
	196	// created initially)
	197	frame->Show(true);
	198
	199	#ifdef __WXX11__
	200	m_xnestWindow = new wxAdoptedWindow;
	201
	202	wxString cmd;
	203	cmd.Printf(wxT("Xnest :%s -geometry %dx%d"),
	204	m_displayNumber.c_str(),
	205	(int) m_emulatorInfo.m_emulatorScreenSize.x,
	206	(int) m_emulatorInfo.m_emulatorScreenSize.y);
	207
	208	// Asynchronously executes Xnest
	209	m_xnestPID = wxExecute(cmd);
	210	if (0 == m_xnestPID)
	211	{
	212	frame->Destroy();
	213	wxMessageBox(wxT("Sorry, could not run Xnest. Please check your PATH."));
	214	return false;
	215	}
	216
	217	wxReparenter reparenter;
	218	if (!reparenter.WaitAndReparent(m_containerWindow, m_xnestWindow, wxT("Xnest")))
	219	{
	220	wxMessageBox(wxT("Sorry, could not reparent Xnest.."));
	221	frame->Destroy();
	222	return false;
	223	}
	224
	225	#endif
	226	m_containerWindow->DoResize();
	227
	228	// success: wxApp::OnRun() will be called which will enter the main message
	229	// loop and the application will run. If we returned false here, the
	230	// application would exit immediately.
	231	return true;
	232	}
	233
	234	// Prepend the current program directory to the name
	235	wxString wxEmulatorApp::GetFullAppPath(const wxString& filename) const
	236	{
	237	wxString path(m_appDir);
	238	if (path.Last() != '\\' && path.Last() != '/' && filename[0] != '\\' && filename[0] != '/')
	239	#ifdef __X__
	240	path += '/';
	241	#else
	242	path += '\\';
	243	#endif
	244	path += filename;
	245
	246	return path;
	247	}
	248
	249
	250	// Load the specified emulator.
	251	// For now, hard-wired. TODO: make this configurable
	252	bool wxEmulatorApp::LoadEmulator(const wxString& appDir)
	253	{
	254	// Load config file and bitmaps
	255	return m_emulatorInfo.Load(appDir);
	256	}
	257
	258	// ----------------------------------------------------------------------------
	259	// main frame
	260	// ----------------------------------------------------------------------------
	261
	262	// frame constructor
	263	wxEmulatorFrame::wxEmulatorFrame(const wxString& title,
	264	const wxPoint& pos, const wxSize& size)
	265	: wxFrame(NULL, wxID_ANY, title, pos, size)
	266	{
	267	// set the frame icon
	268	SetIcon(wxICON(emulator));
	269
	270	#if wxUSE_MENUS
	271	// create a menu bar
	272	wxMenu *menuFile = new wxMenu;
	273
	274	// the "About" item should be in the help menu
	275	wxMenu *helpMenu = new wxMenu;
	276	helpMenu->Append(Emulator_About, _T("&About...\tF1"), _T("Show about dialog"));
	277
	278	menuFile->Append(Emulator_Quit, _T("E&xit\tAlt-X"), _T("Quit this program"));
	279
	280	// now append the freshly created menu to the menu bar...
	281	wxMenuBar *menuBar = new wxMenuBar();
	282	menuBar->Append(menuFile, _T("&File"));
	283	menuBar->Append(helpMenu, _T("&Help"));
	284
	285	// ... and attach this menu bar to the frame
	286	SetMenuBar(menuBar);
	287	#endif // wxUSE_MENUS
	288
	289	#if wxUSE_STATUSBAR
	290	// create a status bar just for fun (by default with 1 pane only)
	291	CreateStatusBar(2);
	292	#endif // wxUSE_STATUSBAR
	293	}
	294
	295
	296	// event handlers
	297
	298	void wxEmulatorFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
	299	{
	300	// true is to force the frame to close
	301	Close(true);
	302	}
	303
	304	void wxEmulatorFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
	305	{
	306	wxString msg;
	307	msg.Printf( _T("wxEmulator is an environment for testing embedded X11 apps.\n"));
	308
	309	wxMessageBox(msg, _T("About wxEmulator"), wxOK \| wxICON_INFORMATION, this);
	310	}
	311
	312	void wxEmulatorFrame::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
	313	{
	314	#ifdef __WXX11__
	315	if (wxGetApp().m_xnestWindow)
	316	{
	317	wxGetApp().m_xnestWindow->SetHandle((WXWindow) NULL);
	318	}
	319	#endif
	320	this->Destroy();
	321	if (wxGetApp().m_xnestPID > 0)
	322	{
	323	wxKill(wxGetApp().m_xnestPID);
	324	wxGetApp().m_xnestPID = 0;
	325	}
	326	}
	327
	328	IMPLEMENT_CLASS(wxEmulatorContainer, wxWindow)
	329
	330	BEGIN_EVENT_TABLE(wxEmulatorContainer, wxWindow)
	331	EVT_SIZE(wxEmulatorContainer::OnSize)
	332	EVT_PAINT(wxEmulatorContainer::OnPaint)
	333	EVT_ERASE_BACKGROUND(wxEmulatorContainer::OnEraseBackground)
	334	END_EVENT_TABLE()
	335
	336	wxEmulatorContainer::wxEmulatorContainer(wxWindow* parent, wxWindowID id):
	337	wxWindow(parent, id, wxDefaultPosition, wxDefaultSize)
	338	{
	339	}
	340
	341	void wxEmulatorContainer::OnSize(wxSizeEvent& WXUNUSED(event))
	342	{
	343	DoResize();
	344	}
	345
	346	void wxEmulatorContainer::DoResize()
	347	{
	348	wxSize sz = GetClientSize();
	349	if (wxGetApp().m_xnestWindow
	350	#ifdef __WXX11__
	351	&& wxGetApp().m_xnestWindow->GetMainWindow()
	352	#endif
	353	)
	354	{
	355	int deviceWidth = wxGetApp().m_emulatorInfo.m_emulatorDeviceSize.x;
	356	int deviceHeight = wxGetApp().m_emulatorInfo.m_emulatorDeviceSize.y;
	357
	358	int x = wxMax(0, (int) ((sz.x - deviceWidth)/2.0));
	359	int y = wxMax(0, (int) ((sz.y - deviceHeight)/2.0));
	360
	361	x += wxGetApp().m_emulatorInfo.m_emulatorScreenPosition.x;
	362	y += wxGetApp().m_emulatorInfo.m_emulatorScreenPosition.y;
	363
	364	wxGetApp().m_xnestWindow->Move(x, y);
	365	}
	366	Refresh();
	367	}
	368
	369	void wxEmulatorContainer::OnPaint(wxPaintEvent& WXUNUSED(event))
	370	{
	371	wxPaintDC dc(this);
	372
	373	wxSize sz = GetClientSize();
	374	if (wxGetApp().m_emulatorInfo.m_emulatorBackgroundBitmap.Ok())
	375	{
	376	int deviceWidth = wxGetApp().m_emulatorInfo.m_emulatorDeviceSize.x;
	377	int deviceHeight = wxGetApp().m_emulatorInfo.m_emulatorDeviceSize.y;
	378
	379	int x = wxMax(0, (int) ((sz.x - deviceWidth)/2.0));
	380	int y = wxMax(0, (int) ((sz.y - deviceHeight)/2.0));
	381
	382	dc.DrawBitmap(wxGetApp().m_emulatorInfo.m_emulatorBackgroundBitmap, x, y);
	383	}
	384	}
	385
	386	void wxEmulatorContainer::OnEraseBackground(wxEraseEvent& event)
	387	{
	388	wxDC* dc wxDUMMY_INITIALIZE(NULL);
	389
	390	if (event.GetDC())
	391	{
	392	dc = event.GetDC();
	393	}
	394	else
	395	{
	396	dc = new wxClientDC(this);
	397	}
	398
	399	dc->SetBackground(wxBrush(wxGetApp().m_emulatorInfo.m_emulatorBackgroundColour, wxSOLID));
	400	dc->Clear();
	401
	402	if (!event.GetDC())
	403	delete dc;
	404	}
	405
	406	// Information about the emulator decorations
	407
	408	void wxEmulatorInfo::Copy(const wxEmulatorInfo& info)
	409	{
	410	m_emulatorFilename = info.m_emulatorFilename;
	411	m_emulatorTitle = info.m_emulatorTitle;
	412	m_emulatorDescription = info.m_emulatorDescription;
	413	m_emulatorScreenPosition = info.m_emulatorScreenPosition;
	414	m_emulatorScreenSize = info.m_emulatorScreenSize;
	415	m_emulatorBackgroundBitmap = info.m_emulatorBackgroundBitmap;
	416	m_emulatorBackgroundBitmapName = info.m_emulatorBackgroundBitmapName;
	417	m_emulatorBackgroundColour = info.m_emulatorBackgroundColour;
	418	m_emulatorDeviceSize = info.m_emulatorDeviceSize;
	419	}
	420
	421	// Initialisation
	422	void wxEmulatorInfo::Init()
	423	{
	424	m_emulatorDeviceSize = wxSize(260, 340);
	425	m_emulatorScreenSize = wxSize(240, 320);
	426	}
	427
	428	// Loads bitmaps
	429	bool wxEmulatorInfo::Load(const wxString& appDir)
	430	{
	431	// Try to find absolute path
	432	wxString absoluteConfigPath = m_emulatorFilename;
	433	if ( !::wxIsAbsolutePath(absoluteConfigPath) )
	434	{
	435	wxString currDir = wxGetCwd();
	436	absoluteConfigPath = currDir + wxString(wxFILE_SEP_PATH) + m_emulatorFilename;
	437	if ( !wxFile::Exists(absoluteConfigPath) )
	438	{
	439	absoluteConfigPath = appDir + wxString(wxFILE_SEP_PATH)
	440	+ m_emulatorFilename;
	441	}
	442	}
	443
	444	if ( !wxFile::Exists(absoluteConfigPath) )
	445	{
	446	wxString str;
	447	str.Printf( wxT("Could not find config file %s"),
	448	absoluteConfigPath.c_str() );
	449
	450	wxMessageBox(str);
	451	return false;
	452	}
	453
	454	wxString rootPath = wxPathOnly(absoluteConfigPath);
	455
	456	{
	457	wxFileConfig config(wxT("wxEmulator"), wxT("wxWidgets"),
	458	absoluteConfigPath, wxEmptyString, wxCONFIG_USE_LOCAL_FILE);
	459
	460	config.Read(wxT("/General/title"), & m_emulatorTitle);
	461	config.Read(wxT("/General/description"), & m_emulatorDescription);
	462	config.Read(wxT("/General/backgroundBitmap"), & m_emulatorBackgroundBitmapName);
	463
	464	wxString colString;
	465	if (config.Read(wxT("/General/backgroundColour"), & colString) \|\|
	466	config.Read(wxT("/General/backgroundColor"), & colString)
	467	)
	468	{
	469	m_emulatorBackgroundColour = wxHexStringToColour(colString);
	470	}
	471
	472	int x = 0, y = 0, w = 0, h = 0, dw = 0, dh = 0;
	473	config.Read(wxT("/General/screenX"), & x);
	474	config.Read(wxT("/General/screenY"), & y);
	475	config.Read(wxT("/General/screenWidth"), & w);
	476	config.Read(wxT("/General/screenHeight"), & h);
	477	if (config.Read(wxT("/General/deviceWidth"), & dw) && config.Read(wxT("/General/deviceHeight"), & dh))
	478	{
	479	m_emulatorDeviceSize = wxSize(dw, dh);
	480	}
	481
	482	m_emulatorScreenPosition = wxPoint(x, y);
	483	m_emulatorScreenSize = wxSize(w, h);
	484	}
	485
	486	if (!m_emulatorBackgroundBitmapName.empty())
	487	{
	488	wxString absoluteBackgroundBitmapName = rootPath + wxString(wxFILE_SEP_PATH) + m_emulatorBackgroundBitmapName;
	489	if ( !wxFile::Exists(absoluteBackgroundBitmapName) )
	490	{
	491	wxString str;
	492	str.Printf( wxT("Could not find bitmap %s"),
	493	absoluteBackgroundBitmapName.c_str() );
	494	wxMessageBox(str);
	495	return false;
	496	}
	497
	498	wxBitmapType type = wxDetermineImageType(m_emulatorBackgroundBitmapName);
	499	if (type == wxBITMAP_TYPE_INVALID)
	500	return false;
	501
	502	if (!m_emulatorBackgroundBitmap.LoadFile(m_emulatorBackgroundBitmapName, type))
	503	{
	504	wxString str;
	505	str.Printf( wxT("Could not load bitmap file %s"),
	506	m_emulatorBackgroundBitmapName.c_str() );
	507	wxMessageBox(str);
	508	return false;
	509	}
	510
	511	m_emulatorDeviceSize = wxSize(m_emulatorBackgroundBitmap.GetWidth(),
	512	m_emulatorBackgroundBitmap.GetHeight());
	513	}
	514	return true;
	515	}
	516
	517	// Returns the image type, or -1, determined from the extension.
	518	wxBitmapType wxDetermineImageType(const wxString& filename)
	519	{
	520	wxString path, name, ext;
	521
	522	wxSplitPath(filename, & path, & name, & ext);
	523
	524	ext.MakeLower();
	525	if (ext == _T("jpg") \|\| ext == _T("jpeg"))
	526	return wxBITMAP_TYPE_JPEG;
	527	if (ext == _T("gif"))
	528	return wxBITMAP_TYPE_GIF;
	529	if (ext == _T("bmp"))
	530	return wxBITMAP_TYPE_BMP;
	531	if (ext == _T("png"))
	532	return wxBITMAP_TYPE_PNG;
	533	if (ext == _T("pcx"))
	534	return wxBITMAP_TYPE_PCX;
	535	if (ext == _T("tif") \|\| ext == _T("tiff"))
	536	return wxBITMAP_TYPE_TIF;
	537
	538	return wxBITMAP_TYPE_INVALID;
	539	}
	540
	541	// Convert a colour to a 6-digit hex string
	542	wxString wxColourToHexString(const wxColour& col)
	543	{
	544	wxString hex;
	545
	546	hex += wxDecToHex(col.Red());
	547	hex += wxDecToHex(col.Green());
	548	hex += wxDecToHex(col.Blue());
	549
	550	return hex;
	551	}
	552
	553	// Convert 6-digit hex string to a colour
	554	wxColour wxHexStringToColour(const wxString& hex)
	555	{
	556	unsigned char r = (unsigned char)wxHexToDec(hex.Mid(0, 2));
	557	unsigned char g = (unsigned char)wxHexToDec(hex.Mid(2, 2));
	558	unsigned char b = (unsigned char)wxHexToDec(hex.Mid(4, 2));
	559
	560	return wxColour(r, g, b);
	561	}
	562
	563	// Find the absolute path where this application has been run from.
	564	// argv0 is wxTheApp->argv[0]
	565	// cwd is the current working directory (at startup)
	566	// appVariableName is the name of a variable containing the directory for this app, e.g.
	567	// MYAPPDIR. This is checked first.
	568
	569	wxString wxFindAppPath(const wxString& argv0, const wxString& cwd, const wxString& appVariableName)
	570	{
	571	wxString str;
	572
	573	// Try appVariableName
	574	if (!appVariableName.empty())
	575	{
	576	str = wxGetenv(appVariableName);
	577	if (!str.empty())
	578	return str;
	579	}
	580
	581	if (wxIsAbsolutePath(argv0))
	582	return wxPathOnly(argv0);
	583	else
	584	{
	585	// Is it a relative path?
	586	wxString currentDir(cwd);
	587	if (!wxEndsWithPathSeparator(currentDir))
	588	currentDir += wxFILE_SEP_PATH;
	589
	590	str = currentDir + argv0;
	591	if ( wxFile::Exists(str) )
	592	return wxPathOnly(str);
	593	}
	594
	595	// OK, it's neither an absolute path nor a relative path.
	596	// Search PATH.
	597
	598	wxPathList pathList;
	599	pathList.AddEnvList(wxT("PATH"));
	600	str = pathList.FindAbsoluteValidPath(argv0);
	601	if (!str.empty())
	602	return wxPathOnly(str);
	603
	604	// Failed
	605	return wxEmptyString;
	606	}
	607