utils/emulator/src/emulator.cpp

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