← Back to branch summary

~ubuntu-dev/wxwidgets2.6/upstream-debian

« back to all changes in this revision

Viewing changes to utils/emulator/src/emulator.cpp

  • Committer: Daniel T Chen
  • Date: 2006-06-26 10:15:11 UTC
  • Revision ID: crimsun@ubuntu.com-20060626101511-a4436cec4c6d9b35
Import Debian 2.6.3.2.1

Show diffs side-by-side

added added

removed removed

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