src/msw/app.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        app.cpp
   3 // Purpose:     wxApp
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart and Markus Holzem
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ===========================================================================
  13 // declarations
  14 // ===========================================================================
  15
  16 // ---------------------------------------------------------------------------
  17 // headers
  18 // ---------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21     #pragma implementation "app.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #if defined(__BORLANDC__)
  28     #pragma hdrstop
  29 #endif
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/frame.h"
  33     #include "wx/app.h"
  34     #include "wx/utils.h"
  35     #include "wx/gdicmn.h"
  36     #include "wx/pen.h"
  37     #include "wx/brush.h"
  38     #include "wx/cursor.h"
  39     #include "wx/icon.h"
  40     #include "wx/palette.h"
  41     #include "wx/dc.h"
  42     #include "wx/dialog.h"
  43     #include "wx/msgdlg.h"
  44     #include "wx/intl.h"
  45     #include "wx/dynarray.h"
  46 #endif
  47
  48 #include "wx/msw/private.h"
  49 #include "wx/log.h"
  50 #include "wx/module.h"
  51
  52 #if wxUSE_THREADS
  53     #include "wx/thread.h"
  54
  55     // define the array of MSG strutures
  56     WX_DECLARE_OBJARRAY(MSG, wxMsgArray);
  57
  58     #include "wx/arrimpl.cpp"
  59
  60     WX_DEFINE_OBJARRAY(wxMsgArray);
  61 #endif // wxUSE_THREADS
  62
  63 #if wxUSE_WX_RESOURCES
  64     #include "wx/resource.h"
  65 #endif
  66
  67 // OLE is used for drag-and-drop, clipboard, OLE Automation...
  68 #if defined(__GNUWIN32__) || defined(__SC__) || defined(__SALFORDC__)
  69     #undef wxUSE_OLE
  70
  71     #define  wxUSE_OLE 0
  72 #endif // broken compilers
  73
  74 #if wxUSE_OLE
  75     #include <ole2.h>
  76 #endif
  77
  78 #include <string.h>
  79 #include <ctype.h>
  80
  81 #if (defined(__WIN95__) && !defined(__GNUWIN32__)) || defined(__TWIN32__)
  82     #include <commctrl.h>
  83 #endif
  84
  85 #include "wx/msw/msvcrt.h"
  86
  87 // ---------------------------------------------------------------------------
  88 // global variables
  89 // ---------------------------------------------------------------------------
  90
  91 extern char *wxBuffer;
  92 extern char *wxOsVersion;
  93 extern wxList *wxWinHandleList;
  94 extern wxList WXDLLEXPORT wxPendingDelete;
  95 #if wxUSE_THREADS
  96 extern wxList *wxPendingEvents;
  97 extern wxCriticalSection *wxPendingEventsLocker;
  98 #endif
  99 extern void wxSetKeyboardHook(bool doIt);
 100 extern wxCursor *g_globalCursor;
 101
 102 HINSTANCE wxhInstance = 0;
 103 static MSG s_currentMsg;
 104 wxApp *wxTheApp = NULL;
 105
 106 // FIXME why not const? and not static?
 107 char wxFrameClassName[]         = "wxFrameClass";
 108 char wxMDIFrameClassName[]      = "wxMDIFrameClass";
 109 char wxMDIChildFrameClassName[] = "wxMDIChildFrameClass";
 110 char wxPanelClassName[]         = "wxPanelClass";
 111 char wxCanvasClassName[]        = "wxCanvasClass";
 112
 113 HICON wxSTD_FRAME_ICON = (HICON) NULL;
 114 HICON wxSTD_MDICHILDFRAME_ICON = (HICON) NULL;
 115 HICON wxSTD_MDIPARENTFRAME_ICON = (HICON) NULL;
 116
 117 HICON wxDEFAULT_FRAME_ICON = (HICON) NULL;
 118 HICON wxDEFAULT_MDICHILDFRAME_ICON = (HICON) NULL;
 119 HICON wxDEFAULT_MDIPARENTFRAME_ICON = (HICON) NULL;
 120
 121 HBRUSH wxDisableButtonBrush = (HBRUSH) 0;
 122
 123 LRESULT APIENTRY wxWndProc(HWND, UINT, WPARAM, LPARAM);
 124
 125 #if defined(__WIN95__) && !defined(__TWIN32__)
 126     #define wxUSE_RICHEDIT 1
 127 #else
 128     #define wxUSE_RICHEDIT 0
 129 #endif
 130
 131 #if wxUSE_RICHEDIT
 132     static HINSTANCE gs_hRichEdit = (HINSTANCE) NULL;
 133 #endif
 134
 135 // ===========================================================================
 136 // implementation
 137 // ===========================================================================
 138
 139 // ---------------------------------------------------------------------------
 140 // wxApp
 141 // ---------------------------------------------------------------------------
 142
 143 #if !USE_SHARED_LIBRARY
 144     IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
 145
 146     BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
 147         EVT_IDLE(wxApp::OnIdle)
 148         EVT_END_SESSION(wxApp::OnEndSession)
 149         EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
 150     END_EVENT_TABLE()
 151 #endif
 152
 153 long wxApp::sm_lastMessageTime = 0;
 154
 155 //// Initialize
 156 bool wxApp::Initialize()
 157 {
 158     // Some people may wish to use this, but
 159     // probably it shouldn't be here by default.
 160 #ifdef __WXDEBUG__
 161     //    wxRedirectIOToConsole();
 162 #endif
 163
 164     wxBuffer = new char[1500]; // FIXME
 165
 166     wxClassInfo::InitializeClasses();
 167
 168 #if wxUSE_RESOURCES
 169     wxGetResource("wxWindows", "OsVersion", &wxOsVersion);
 170 #endif
 171
 172     // I'm annoyed ... I don't know where to put this and I don't want to create    // a module for that as it's part of the core.
 173 #if wxUSE_THREADS
 174     wxPendingEvents = new wxList();
 175     wxPendingEventsLocker = new wxCriticalSection();
 176 #endif
 177
 178     wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING);
 179     wxTheColourDatabase->Initialize();
 180
 181     wxInitializeStockLists();
 182     wxInitializeStockObjects();
 183
 184 #if wxUSE_WX_RESOURCES
 185     wxInitializeResourceSystem();
 186 #endif
 187
 188     wxBitmap::InitStandardHandlers();
 189
 190 #if defined(__WIN95__)
 191     InitCommonControls();
 192
 193 #if wxUSE_RICHEDIT
 194     gs_hRichEdit = LoadLibrary("RICHED32.DLL");
 195
 196     if (gs_hRichEdit == (HINSTANCE) NULL)
 197     {
 198         wxLogError(_("Could not initialise Rich Edit DLL"));
 199     }
 200 #endif // wxUSE_RICHEDIT
 201
 202 #endif // __WIN95__
 203
 204     // for OLE, enlarge message queue to be as large as possible
 205     int iMsg = 96;
 206     while (!SetMessageQueue(iMsg) && (iMsg -= 8));
 207
 208     /*
 209        DWORD dwOleVer;
 210        dwOleVer = CoBuildVersion();
 211
 212     // check the OLE library version
 213     if (rmm != HIWORD(dwOleVer))
 214     {
 215     wxMessageBox("Incorrect version of OLE libraries.");
 216     return FALSE;
 217     }
 218      */
 219
 220 #if wxUSE_OLE
 221     // we need to initialize OLE library
 222     if ( FAILED(::OleInitialize(NULL)) )
 223         wxLogError(_("Cannot initialize OLE"));
 224 #endif
 225
 226 #if wxUSE_CTL3D
 227     if (!Ctl3dRegister(wxhInstance))
 228         wxLogError("Cannot register CTL3D");
 229
 230     Ctl3dAutoSubclass(wxhInstance);
 231 #endif
 232
 233     g_globalCursor = new wxCursor;
 234
 235     wxSTD_FRAME_ICON = LoadIcon(wxhInstance, "wxSTD_FRAME");
 236     wxSTD_MDIPARENTFRAME_ICON = LoadIcon(wxhInstance, "wxSTD_MDIPARENTFRAME");
 237     wxSTD_MDICHILDFRAME_ICON = LoadIcon(wxhInstance, "wxSTD_MDICHILDFRAME");
 238
 239     wxDEFAULT_FRAME_ICON = LoadIcon(wxhInstance, "wxDEFAULT_FRAME");
 240     wxDEFAULT_MDIPARENTFRAME_ICON = LoadIcon(wxhInstance, "wxDEFAULT_MDIPARENTFRAME");
 241     wxDEFAULT_MDICHILDFRAME_ICON = LoadIcon(wxhInstance, "wxDEFAULT_MDICHILDFRAME");
 242
 243     RegisterWindowClasses();
 244
 245     // Create the brush for disabling bitmap buttons
 246
 247     LOGBRUSH lb ;
 248     lb.lbStyle = BS_PATTERN;
 249     lb.lbHatch = (int)LoadBitmap( wxhInstance, "wxDISABLE_BUTTON_BITMAP" ) ;
 250     wxDisableButtonBrush = ::CreateBrushIndirect( & lb ) ;
 251     ::DeleteObject( (HGDIOBJ)lb.lbHatch ) ;
 252
 253 #if wxUSE_PENWINDOWS
 254     wxRegisterPenWin();
 255 #endif
 256
 257     wxWinHandleList = new wxList(wxKEY_INTEGER);
 258
 259     // This is to foil optimizations in Visual C++ that throw out dummy.obj.
 260     // PLEASE DO NOT ALTER THIS.
 261 #if defined(__VISUALC__) && !defined(WXMAKINGDLL)
 262     extern char wxDummyChar;
 263     if (wxDummyChar) wxDummyChar++;
 264 #endif
 265
 266     wxSetKeyboardHook(TRUE);
 267
 268     wxModule::RegisterModules();
 269     if (!wxModule::InitializeModules())
 270         return FALSE;
 271     return TRUE;
 272 }
 273
 274 //// RegisterWindowClasses
 275
 276 bool wxApp::RegisterWindowClasses()
 277 {
 278     ///////////////////////////////////////////////////////////////////////
 279     // Register the frame window class.
 280     WNDCLASS wndclass;   // Structure used to register Windows class.
 281
 282     wndclass.style         = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS ;
 283     wndclass.lpfnWndProc   = (WNDPROC)wxWndProc;
 284     wndclass.cbClsExtra    = 0;
 285     wndclass.cbWndExtra    = sizeof( DWORD ); // was 4
 286     wndclass.hInstance     = wxhInstance;
 287     wndclass.hIcon         = (HICON) NULL;        // wxSTD_FRAME_ICON;
 288     wndclass.hCursor       = LoadCursor( (HINSTANCE) NULL, IDC_ARROW );
 289     wndclass.hbrBackground =  (HBRUSH)(COLOR_APPWORKSPACE+1) ;
 290     //  wndclass.hbrBackground = GetStockObject( WHITE_BRUSH );
 291     wndclass.lpszMenuName  = NULL;
 292 #ifdef _MULTIPLE_INSTANCES
 293     sprintf( wxFrameClassName,"wxFrameClass%d", wxhInstance );
 294 #endif
 295     wndclass.lpszClassName = wxFrameClassName;
 296
 297     if (!RegisterClass( &wndclass ))
 298     {
 299         // wxFatalError("Can't register Frame Window class");
 300     }
 301
 302     ///////////////////////////////////////////////////////////////////////
 303     // Register the MDI frame window class.
 304     WNDCLASS wndclass1;   // Structure used to register Windows class.
 305
 306     wndclass1.style         = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS ;
 307     wndclass1.lpfnWndProc   = (WNDPROC)wxWndProc;
 308     wndclass1.cbClsExtra    = 0;
 309     wndclass1.cbWndExtra    = sizeof( DWORD ); // was 4
 310     wndclass1.hInstance     = wxhInstance;
 311     wndclass1.hIcon         = (HICON) NULL; // wxSTD_MDIPARENTFRAME_ICON;
 312     wndclass1.hCursor       = LoadCursor( (HINSTANCE) NULL, IDC_ARROW );
 313     //  wndclass1.hbrBackground =  (HBRUSH)(COLOR_APPWORKSPACE+1) ;
 314     wndclass1.hbrBackground = (HBRUSH) NULL;
 315     wndclass1.lpszMenuName  = NULL;
 316
 317     wndclass1.lpszClassName = wxMDIFrameClassName;
 318     if (!RegisterClass( &wndclass1 ))
 319     {
 320         //    wxFatalError("Can't register MDI Frame window class");
 321         //  return FALSE;
 322     }
 323
 324     ///////////////////////////////////////////////////////////////////////
 325     // Register the MDI child frame window class.
 326     WNDCLASS wndclass4;   // Structure used to register Windows class.
 327
 328     wndclass4.style         = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS ;
 329     wndclass4.lpfnWndProc   = (WNDPROC)wxWndProc;
 330     wndclass4.cbClsExtra    = 0;
 331     wndclass4.cbWndExtra    = sizeof( DWORD ); // was 4
 332     wndclass4.hInstance     = wxhInstance;
 333     wndclass4.hIcon         = (HICON) NULL;       // wxSTD_MDICHILDFRAME_ICON;
 334     wndclass4.hCursor       = LoadCursor( (HINSTANCE) NULL, IDC_ARROW );
 335     // TODO: perhaps this should be NULL so that Windows doesn't
 336     // paint the background itself (would OnEraseBackground duplicate
 337     // this?)
 338     wndclass4.hbrBackground =  (HBRUSH)(COLOR_WINDOW+1) ;
 339     //  wndclass4.hbrBackground = NULL;
 340     wndclass4.lpszMenuName  = NULL;
 341     wndclass4.lpszClassName = wxMDIChildFrameClassName;
 342
 343     if (!RegisterClass( &wndclass4 ))
 344     {
 345         //   wxFatalError("Can't register MDI child frame window class");
 346         //   return FALSE;
 347     }
 348
 349     ///////////////////////////////////////////////////////////////////////
 350     // Register the panel window class.
 351     WNDCLASS wndclass2;   // Structure used to register Windows class.
 352     memset(&wndclass2, 0, sizeof(WNDCLASS));   // start with NULL defaults
 353     wndclass2.style         = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS ;
 354     wndclass2.lpfnWndProc   = (WNDPROC)wxWndProc;
 355     wndclass2.cbClsExtra    = 0;
 356     wndclass2.cbWndExtra    = sizeof( DWORD ); // was 4
 357     wndclass2.hInstance     = wxhInstance;
 358     wndclass2.hIcon         = (HICON) NULL;
 359     wndclass2.hCursor       = LoadCursor( (HINSTANCE) NULL, IDC_ARROW );
 360     //  wndclass2.hbrBackground = (HBRUSH)(COLOR_BTNFACE+1) ;
 361     wndclass2.hbrBackground = (HBRUSH) GetStockObject( LTGRAY_BRUSH );
 362     wndclass2.lpszMenuName  = NULL;
 363     wndclass2.lpszClassName = wxPanelClassName;
 364     if (!RegisterClass( &wndclass2 ))
 365     {
 366         //   wxFatalError("Can't register Panel Window class");
 367         //   return FALSE;
 368     }
 369
 370     ///////////////////////////////////////////////////////////////////////
 371     // Register the canvas and textsubwindow class name
 372     WNDCLASS wndclass3;   // Structure used to register Windows class.
 373     memset(&wndclass3, 0, sizeof(WNDCLASS));   // start with NULL defaults
 374     // Use CS_OWNDC to avoid messing about restoring the context
 375     // for every graphic operation.
 376     //  wndclass3.style         = CS_HREDRAW | CS_VREDRAW | CS_OWNDC | CS_DBLCLKS ;
 377     // wxWin 2.0
 378     wndclass3.style         = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS ;
 379     wndclass3.lpfnWndProc   = (WNDPROC)wxWndProc;
 380     wndclass3.cbClsExtra    = 0;
 381     wndclass3.cbWndExtra    = sizeof( DWORD ); // was 4
 382     wndclass3.hInstance     = wxhInstance;
 383     wndclass3.hIcon         = (HICON) NULL;
 384     wndclass3.hCursor       = LoadCursor( (HINSTANCE) NULL, IDC_ARROW );
 385     //  wndclass3.hbrBackground = (HBRUSH)(COLOR_WINDOW+1) ;
 386     wndclass3.hbrBackground = (HBRUSH) NULL;
 387     wndclass3.lpszMenuName  = NULL;
 388     wndclass3.lpszClassName = wxCanvasClassName;
 389     if (!RegisterClass( &wndclass3))
 390     {
 391         //   wxFatalError("Can't register Canvas class");
 392         //   return FALSE;
 393     }
 394
 395     return TRUE;
 396 }
 397
 398 //// Convert Windows to argc, argv style
 399
 400 void wxApp::ConvertToStandardCommandArgs(char* lpCmdLine)
 401 {
 402     wxStringList args;
 403
 404     wxString cmdLine(lpCmdLine);
 405     int count = 0;
 406
 407     // Get application name
 408     char name[260]; // 260 is MAX_PATH value from windef.h
 409     ::GetModuleFileName(wxhInstance, name, WXSIZEOF(name));
 410
 411     args.Add(name);
 412     count++;
 413
 414     strcpy(name, wxFileNameFromPath(name));
 415     wxStripExtension(name);
 416     wxTheApp->SetAppName(name);
 417
 418     // Break up string
 419     // Treat strings enclosed in double-quotes as single arguments
 420     int i = 0;
 421     int len = cmdLine.Length();
 422     while (i < len)
 423     {
 424         // Skip whitespace
 425         while ((i < len) && isspace(cmdLine.GetChar(i)))
 426             i ++;
 427
 428         if (i < len)
 429         {
 430             if (cmdLine.GetChar(i) == '"') // We found the start of a string
 431             {
 432                 i ++;
 433                 int first = i;
 434                 while ((i < len) && (cmdLine.GetChar(i) != '"'))
 435                     i ++;
 436
 437                 wxString arg(cmdLine.Mid(first, (i - first)));
 438
 439                 args.Add(arg);
 440                 count ++;
 441
 442                 if (i < len)
 443                     i ++; // Skip past 2nd quote
 444             }
 445             else // Unquoted argument
 446             {
 447                 int first = i;
 448                 while ((i < len) && !isspace(cmdLine.GetChar(i)))
 449                     i ++;
 450
 451                 wxString arg(cmdLine.Mid(first, (i - first)));
 452
 453                 args.Add(arg);
 454                 count ++;
 455             }
 456         }
 457     }
 458
 459     wxTheApp->argv = new char*[count + 1];
 460     for (i = 0; i < count; i++)
 461     {
 462         wxString arg(args[i]);
 463         wxTheApp->argv[i] = copystring((const char*)arg);
 464     }
 465     wxTheApp->argv[count] = NULL; // argv[] is a NULL-terminated list
 466     wxTheApp->argc = count;
 467 }
 468
 469 //// Cleans up any wxWindows internal structures left lying around
 470
 471 void wxApp::CleanUp()
 472 {
 473     //// COMMON CLEANUP
 474
 475     // flush the logged messages if any and install a 'safer' log target: the
 476     // default one (wxLogGui) can't be used after the resources are freed just
 477     // below and the user suppliedo ne might be even more unsafe (using any
 478     // wxWindows GUI function is unsafe starting from now)
 479     wxLog::DontCreateOnDemand();
 480
 481     // this will flush the old messages if any
 482     delete wxLog::SetActiveTarget(new wxLogStderr);
 483
 484     // One last chance for pending objects to be cleaned up
 485     wxTheApp->DeletePendingObjects();
 486
 487     wxModule::CleanUpModules();
 488
 489 #if wxUSE_WX_RESOURCES
 490     wxCleanUpResourceSystem();
 491
 492     //  wxDefaultResourceTable->ClearTable();
 493 #endif
 494
 495     // Indicate that the cursor can be freed, so that cursor won't be deleted
 496     // by deleting the bitmap list before g_globalCursor goes out of scope
 497     // (double deletion of the cursor).
 498     wxSetCursor(wxNullCursor);
 499     delete g_globalCursor;
 500     g_globalCursor = NULL;
 501
 502     wxDeleteStockObjects() ;
 503
 504     // Destroy all GDI lists, etc.
 505     wxDeleteStockLists();
 506
 507     delete wxTheColourDatabase;
 508     wxTheColourDatabase = NULL;
 509
 510     wxBitmap::CleanUpHandlers();
 511
 512     delete[] wxBuffer;
 513     wxBuffer = NULL;
 514
 515     //// WINDOWS-SPECIFIC CLEANUP
 516
 517     wxSetKeyboardHook(FALSE);
 518
 519 #ifdef __WIN95__
 520
 521 #if wxUSE_RICHEDIT
 522     if (gs_hRichEdit != (HINSTANCE) NULL)
 523         FreeLibrary(gs_hRichEdit);
 524 #endif
 525
 526 #endif
 527
 528 #if wxUSE_PENWINDOWS
 529     wxCleanUpPenWin();
 530 #endif
 531
 532     if (wxSTD_FRAME_ICON)
 533         DestroyIcon(wxSTD_FRAME_ICON);
 534     if (wxSTD_MDICHILDFRAME_ICON)
 535         DestroyIcon(wxSTD_MDICHILDFRAME_ICON);
 536     if (wxSTD_MDIPARENTFRAME_ICON)
 537         DestroyIcon(wxSTD_MDIPARENTFRAME_ICON);
 538
 539     if (wxDEFAULT_FRAME_ICON)
 540         DestroyIcon(wxDEFAULT_FRAME_ICON);
 541     if (wxDEFAULT_MDICHILDFRAME_ICON)
 542         DestroyIcon(wxDEFAULT_MDICHILDFRAME_ICON);
 543     if (wxDEFAULT_MDIPARENTFRAME_ICON)
 544         DestroyIcon(wxDEFAULT_MDIPARENTFRAME_ICON);
 545
 546     if ( wxDisableButtonBrush )
 547         ::DeleteObject( wxDisableButtonBrush ) ;
 548
 549 #if wxUSE_OLE
 550     ::OleUninitialize();
 551 #endif
 552
 553 #if wxUSE_CTL3D
 554     Ctl3dUnregister(wxhInstance);
 555 #endif
 556
 557     if (wxWinHandleList)
 558         delete wxWinHandleList ;
 559
 560     // GL: I'm annoyed ... I don't know where to put this and I don't want to
 561     // create a module for that as it's part of the core.
 562 #if wxUSE_THREADS
 563     delete wxPendingEvents;
 564     delete wxPendingEventsLocker;
 565 #endif
 566
 567     wxClassInfo::CleanUpClasses();
 568
 569     delete wxTheApp;
 570     wxTheApp = NULL;
 571
 572 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
 573     // At this point we want to check if there are any memory
 574     // blocks that aren't part of the wxDebugContext itself,
 575     // as a special case. Then when dumping we need to ignore
 576     // wxDebugContext, too.
 577     if (wxDebugContext::CountObjectsLeft(TRUE) > 0)
 578     {
 579         wxLogDebug("There were memory leaks.");
 580         wxDebugContext::Dump();
 581         wxDebugContext::PrintStatistics();
 582     }
 583     //  wxDebugContext::SetStream(NULL, NULL);
 584 #endif
 585
 586     // do it as the very last thing because everything else can log messages
 587     delete wxLog::SetActiveTarget(NULL);
 588 }
 589
 590 #if !defined(_WINDLL) || (defined(_WINDLL) && defined(WXMAKINGDLL))
 591
 592 // temporarily disable this warning which would be generated in release builds
 593 // because of __try
 594 #ifdef __VISUALC__
 595     #pragma warning(disable: 4715) // not all control paths return a value
 596 #endif // Visual C++
 597
 598 //// Main wxWindows entry point
 599 int wxEntry(WXHINSTANCE hInstance,
 600             WXHINSTANCE WXUNUSED(hPrevInstance),
 601             char *lpCmdLine,
 602             int nCmdShow,
 603             bool enterLoop)
 604 {
 605     // do check for memory leaks on program exit
 606     // (another useful flag is _CRTDBG_DELAY_FREE_MEM_DF which doesn't free
 607     //  deallocated memory which may be used to simulate low-memory condition)
 608     wxCrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF);
 609
 610     // take everything into a try-except block in release build
 611     // FIXME other compilers must support Win32 SEH (structured exception
 612     //       handling) too, just find the appropriate keyword in their docs!
 613     //       Please note that it's _not_ the same as C++ exceptions!
 614 #if !defined(__WXDEBUG__) && defined(__VISUALC__)
 615     #define CATCH_PROGRAM_EXCEPTIONS
 616
 617     __try {
 618 #else
 619     #undef  CATCH_PROGRAM_EXCEPTIONS
 620 #endif
 621
 622         wxhInstance = (HINSTANCE) hInstance;
 623
 624         if (!wxApp::Initialize())
 625             return 0;
 626
 627         // create the application object or ensure that one already exists
 628         if (!wxTheApp)
 629         {
 630             // The app may have declared a global application object, but we recommend
 631             // the IMPLEMENT_APP macro is used instead, which sets an initializer
 632             // function for delayed, dynamic app object construction.
 633             wxCHECK_MSG( wxApp::GetInitializerFunction(), 0,
 634                          "No initializer - use IMPLEMENT_APP macro." );
 635
 636             wxTheApp = (*wxApp::GetInitializerFunction()) ();
 637         }
 638
 639         wxCHECK_MSG( wxTheApp, 0, "You have to define an instance of wxApp!" );
 640
 641         // save the WinMain() parameters
 642         wxTheApp->ConvertToStandardCommandArgs(lpCmdLine);
 643         wxTheApp->m_nCmdShow = nCmdShow;
 644
 645         // GUI-specific initialisation. In fact on Windows we don't have any,
 646         // but this call is provided for compatibility across platforms.
 647         wxTheApp->OnInitGui() ;
 648
 649         int retValue = 0;
 650
 651         if ( wxTheApp->OnInit() )
 652         {
 653             if ( enterLoop )
 654             {
 655                 retValue = wxTheApp->OnRun();
 656             }
 657             else
 658                 // We want to initialize, but not run or exit immediately.
 659                 return 1;
 660         }
 661         //else: app initialization failed, so we skipped OnRun()
 662
 663         wxWindow *topWindow = wxTheApp->GetTopWindow();
 664         if ( topWindow )
 665         {
 666             // Forcibly delete the window.
 667             if ( topWindow->IsKindOf(CLASSINFO(wxFrame)) ||
 668                     topWindow->IsKindOf(CLASSINFO(wxDialog)) )
 669             {
 670                 topWindow->Close(TRUE);
 671                 wxTheApp->DeletePendingObjects();
 672             }
 673             else
 674             {
 675                 delete topWindow;
 676                 wxTheApp->SetTopWindow(NULL);
 677             }
 678         }
 679
 680         wxTheApp->OnExit();
 681
 682         wxApp::CleanUp();
 683
 684         return retValue;
 685
 686 #ifdef CATCH_PROGRAM_EXCEPTIONS
 687     }
 688     __except ( EXCEPTION_EXECUTE_HANDLER ) {
 689         /*
 690            if ( wxTheApp )
 691            wxTheApp->OnFatalException();
 692          */
 693
 694         // using wxLog would be unsafe here
 695         ::MessageBox(NULL,
 696                      _("Unrecoverable program error detected: "
 697                      " the application will terminate."),
 698                      _("Fatal Error"),
 699                      MB_APPLMODAL | MB_ICONSTOP | MB_OK);
 700
 701         ::ExitProcess(3); // the same exit code as abort()
 702
 703         // NOTREACHED
 704     }
 705 #endif // CATCH_PROGRAM_EXCEPTIONS
 706 }
 707
 708 // restore warning state
 709 #ifdef __VISUALC__
 710     #pragma warning(default: 4715) // not all control paths return a value
 711 #endif // Visual C++
 712
 713 #else /*  _WINDLL  */
 714
 715 //// Entry point for DLLs
 716
 717 int wxEntry(WXHINSTANCE hInstance)
 718 {
 719     wxhInstance = (HINSTANCE) hInstance;
 720     wxApp::Initialize();
 721
 722     // The app may have declared a global application object, but we recommend
 723     // the IMPLEMENT_APP macro is used instead, which sets an initializer function
 724     // for delayed, dynamic app object construction.
 725     if (!wxTheApp)
 726     {
 727         wxCHECK_MSG( wxApp::GetInitializerFunction(), 0,
 728                      "No initializer - use IMPLEMENT_APP macro." );
 729
 730         wxTheApp = (* wxApp::GetInitializerFunction()) ();
 731     }
 732
 733     wxCHECK_MSG( wxTheApp, 0, "You have to define an instance of wxApp!" );
 734
 735     wxTheApp->argc = 0;
 736     wxTheApp->argv = NULL;
 737
 738     wxTheApp->OnInitGui();
 739
 740     wxTheApp->OnInit();
 741
 742     wxWindow *topWindow = wxTheApp->GetTopWindow();
 743     if ( topWindow && topWindow->GetHWND())
 744     {
 745         topWindow->Show(TRUE);
 746     }
 747
 748     return 1;
 749 }
 750 #endif // _WINDLL
 751
 752 //// Static member initialization
 753
 754 wxAppInitializerFunction wxApp::m_appInitFn = (wxAppInitializerFunction) NULL;
 755
 756 wxApp::wxApp()
 757 {
 758     m_topWindow = NULL;
 759     wxTheApp = this;
 760     m_className = "";
 761     m_wantDebugOutput = TRUE ;
 762     m_appName = "";
 763     argc = 0;
 764     argv = NULL;
 765 #ifdef __WXMSW__
 766     m_printMode = wxPRINT_WINDOWS;
 767 #else
 768     m_printMode = wxPRINT_POSTSCRIPT;
 769 #endif
 770     m_exitOnFrameDelete = TRUE;
 771     m_auto3D = TRUE;
 772 }
 773
 774 wxApp::~wxApp()
 775 {
 776     // Delete command-line args
 777     int i;
 778     for (i = 0; i < argc; i++)
 779     {
 780         delete[] argv[i];
 781     }
 782     delete[] argv;
 783 }
 784
 785 bool wxApp::Initialized()
 786 {
 787 #ifndef _WINDLL
 788     if (GetTopWindow())
 789         return TRUE;
 790     else
 791         return FALSE;
 792 #endif
 793 #ifdef _WINDLL // Assume initialized if DLL (no way of telling)
 794     return TRUE;
 795 #endif
 796 }
 797
 798 /*
 799  * Get and process a message, returning FALSE if WM_QUIT
 800  * received (and also set the flag telling the app to exit the main loop)
 801  *
 802  */
 803 bool wxApp::DoMessage()
 804 {
 805     BOOL rc = ::GetMessage(&s_currentMsg, (HWND) NULL, 0, 0);
 806     if ( rc == 0 )
 807     {
 808         // got WM_QUIT
 809         m_keepGoing = FALSE;
 810
 811         return FALSE;
 812     }
 813     else if ( rc == -1 )
 814     {
 815         // should never happen, but let's test for it nevertheless
 816         wxLogLastError("GetMessage");
 817     }
 818     else
 819     {
 820 #if wxUSE_THREADS
 821         wxASSERT_MSG( wxThread::IsMain(),
 822                       "only the main thread can process Windows messages" );
 823
 824         static bool s_hadGuiLock = TRUE;
 825         static wxMsgArray s_aSavedMessages;
 826
 827         // if a secondary thread owns is doing GUI calls, save all messages for
 828         // later processing - we can't process them right now because it will
 829         // lead to recursive library calls (and we're not reentrant)
 830         if ( !wxGuiOwnedByMainThread() )
 831         {
 832             s_hadGuiLock = FALSE;
 833
 834             // leave out WM_COMMAND messages: too dangerous, sometimes
 835             // the message will be processed twice
 836             if ( !wxIsWaitingForThread() ||
 837                     s_currentMsg.message != WM_COMMAND )
 838             {
 839                 s_aSavedMessages.Add(s_currentMsg);
 840             }
 841
 842             return TRUE;
 843         }
 844         else
 845         {
 846             // have we just regained the GUI lock? if so, post all of the saved
 847             // messages
 848             //
 849             // FIXME of course, it's not _exactly_ the same as processing the
 850             //       messages normally - expect some things to break...
 851             if ( !s_hadGuiLock )
 852             {
 853                 s_hadGuiLock = TRUE;
 854
 855                 size_t count = s_aSavedMessages.Count();
 856                 for ( size_t n = 0; n < count; n++ )
 857                 {
 858                     MSG& msg = s_aSavedMessages[n];
 859
 860                     if ( !ProcessMessage((WXMSG *)&msg) )
 861                     {
 862                         ::TranslateMessage(&msg);
 863                         ::DispatchMessage(&msg);
 864                     }
 865                 }
 866
 867                 s_aSavedMessages.Empty();
 868             }
 869         }
 870 #endif // wxUSE_THREADS
 871
 872         // Process the message
 873         if ( !ProcessMessage((WXMSG *)&s_currentMsg) )
 874         {
 875             ::TranslateMessage(&s_currentMsg);
 876             wxApp::sm_lastMessageTime = s_currentMsg.time; /* MATTHEW: timeStamp impl. */
 877             ::DispatchMessage(&s_currentMsg);
 878         }
 879     }
 880
 881     return TRUE;
 882 }
 883
 884 /*
 885  * Keep trying to process messages until WM_QUIT
 886  * received.
 887  *
 888  * If there are messages to be processed, they will all be
 889  * processed and OnIdle will not be called.
 890  * When there are no more messages, OnIdle is called.
 891  * If OnIdle requests more time,
 892  * it will be repeatedly called so long as there are no pending messages.
 893  * A 'feature' of this is that once OnIdle has decided that no more processing
 894  * is required, then it won't get processing time until further messages
 895  * are processed (it'll sit in DoMessage).
 896  */
 897
 898 int wxApp::MainLoop()
 899 {
 900     m_keepGoing = TRUE;
 901
 902     while ( m_keepGoing )
 903     {
 904 #if wxUSE_THREADS
 905         wxMutexGuiLeaveOrEnter();
 906 #endif // wxUSE_THREADS
 907
 908         while ( !::PeekMessage(&s_currentMsg, 0, 0, 0, PM_NOREMOVE) &&
 909                 ProcessIdle() )
 910         {
 911         }
 912
 913
 914         DoMessage();
 915
 916         // If they are pending events, we must process them.
 917 #if wxUSE_THREADS
 918         ProcessPendingEvents();
 919 #endif
 920     }
 921
 922     return s_currentMsg.wParam;
 923 }
 924
 925 // Returns TRUE if more time is needed.
 926 bool wxApp::ProcessIdle()
 927 {
 928     wxIdleEvent event;
 929     event.SetEventObject(this);
 930     ProcessEvent(event);
 931
 932     return event.MoreRequested();
 933 }
 934
 935 #if wxUSE_THREADS
 936 void wxApp::ProcessPendingEvents()
 937 {
 938     wxNode *node = wxPendingEvents->First();
 939     wxCriticalSectionLocker locker(*wxPendingEventsLocker);
 940
 941     while (node)
 942     {
 943         wxEvtHandler *handler = (wxEvtHandler *)node->Data();
 944
 945         handler->ProcessPendingEvents();
 946
 947         delete node;
 948         node = wxPendingEvents->First();
 949     }
 950 }
 951 #endif
 952
 953
 954 void wxApp::ExitMainLoop()
 955 {
 956     m_keepGoing = FALSE;
 957 }
 958
 959 bool wxApp::Pending()
 960 {
 961     return (::PeekMessage(&s_currentMsg, 0, 0, 0, PM_NOREMOVE) != 0) ;
 962 }
 963
 964 void wxApp::Dispatch()
 965 {
 966     DoMessage();
 967 }
 968
 969 /*
 970  * Give all windows a chance to preprocess
 971  * the message. Some may have accelerator tables, or have
 972  * MDI complications.
 973  */
 974
 975 bool wxApp::ProcessMessage(WXMSG *wxmsg)
 976 {
 977     MSG *msg = (MSG *)wxmsg;
 978     HWND hWnd = msg->hwnd;
 979     wxWindow *wndThis = wxFindWinFromHandle((WXHWND)hWnd), *wnd;
 980
 981     // Try translations first; find the youngest window with
 982     // a translation table.
 983     for ( wnd = wndThis; wnd; wnd = wnd->GetParent() )
 984     {
 985         if ( wnd->MSWTranslateMessage(wxmsg) )
 986             return TRUE;
 987     }
 988
 989     // Anyone for a non-translation message? Try youngest descendants first.
 990     for ( wnd = wndThis; wnd; wnd = wnd->GetParent() )
 991     {
 992         if ( wnd->MSWProcessMessage(wxmsg) )
 993             return TRUE;
 994     }
 995
 996     return FALSE;
 997 }
 998
 999 void wxApp::OnIdle(wxIdleEvent& event)
1000 {
1001     static bool s_inOnIdle = FALSE;
1002
1003     // Avoid recursion (via ProcessEvent default case)
1004     if ( s_inOnIdle )
1005         return;
1006
1007     s_inOnIdle = TRUE;
1008
1009     // 'Garbage' collection of windows deleted with Close().
1010     DeletePendingObjects();
1011
1012     // flush the logged messages if any
1013     wxLog *pLog = wxLog::GetActiveTarget();
1014     if ( pLog != NULL && pLog->HasPendingMessages() )
1015         pLog->Flush();
1016
1017     // Send OnIdle events to all windows
1018     if ( SendIdleEvents() )
1019     {
1020         // SendIdleEvents() returns TRUE if at least one window requested more
1021         // idle events
1022         event.RequestMore(TRUE);
1023     }
1024
1025     s_inOnIdle = FALSE;
1026 }
1027
1028 // Send idle event to all top-level windows
1029 bool wxApp::SendIdleEvents()
1030 {
1031     bool needMore = FALSE;
1032
1033     wxWindowList::Node* node = wxTopLevelWindows.GetFirst();
1034     while (node)
1035     {
1036         wxWindow* win = node->GetData();
1037         if (SendIdleEvents(win))
1038             needMore = TRUE;
1039         node = node->GetNext();
1040     }
1041
1042     return needMore;
1043 }
1044
1045 // Send idle event to window and all subwindows
1046 bool wxApp::SendIdleEvents(wxWindow* win)
1047 {
1048     bool needMore = FALSE;
1049
1050     wxIdleEvent event;
1051     event.SetEventObject(win);
1052     win->GetEventHandler()->ProcessEvent(event);
1053
1054     if (event.MoreRequested())
1055         needMore = TRUE;
1056
1057     wxNode* node = win->GetChildren().First();
1058     while (node)
1059     {
1060         wxWindow* win = (wxWindow*) node->Data();
1061         if (SendIdleEvents(win))
1062             needMore = TRUE;
1063
1064         node = node->Next();
1065     }
1066     return needMore ;
1067 }
1068
1069 void wxApp::DeletePendingObjects()
1070 {
1071     wxNode *node = wxPendingDelete.First();
1072     while (node)
1073     {
1074         wxObject *obj = (wxObject *)node->Data();
1075
1076         delete obj;
1077
1078         if (wxPendingDelete.Member(obj))
1079             delete node;
1080
1081         // Deleting one object may have deleted other pending
1082         // objects, so start from beginning of list again.
1083         node = wxPendingDelete.First();
1084     }
1085 }
1086
1087 void wxApp::OnEndSession(wxCloseEvent& WXUNUSED(event))
1088 {
1089     if (GetTopWindow())
1090         GetTopWindow()->Close(TRUE);
1091 }
1092
1093 // Default behaviour: close the application with prompts. The
1094 // user can veto the close, and therefore the end session.
1095 void wxApp::OnQueryEndSession(wxCloseEvent& event)
1096 {
1097     if (GetTopWindow())
1098     {
1099         if (!GetTopWindow()->Close(!event.CanVeto()))
1100             event.Veto(TRUE);
1101     }
1102 }
1103
1104 wxLog* wxApp::CreateLogTarget()
1105 {
1106     return new wxLogGui;
1107 }
1108
1109 wxWindow* wxApp::GetTopWindow() const
1110 {
1111     if (m_topWindow)
1112         return m_topWindow;
1113     else if (wxTopLevelWindows.GetCount() > 0)
1114         return wxTopLevelWindows.GetFirst()->GetData();
1115     else
1116         return NULL;
1117 }
1118
1119 int wxApp::GetComCtl32Version() const
1120 {
1121     // have we loaded COMCTL32 yet?
1122     HMODULE theModule = ::GetModuleHandle("COMCTL32");
1123     int version = 0;
1124
1125     // if so, then we can check for the version
1126     if (theModule)
1127     {
1128         // InitCommonControlsEx is unique to 4.7 and later
1129         FARPROC theProc = ::GetProcAddress(theModule, "InitCommonControlsEx");
1130
1131         if (! theProc)
1132         {                    // not found, must be 4.00
1133             version = 400;
1134         }
1135         else
1136         {
1137             // The following symbol are unique to 4.71
1138             //   DllInstall
1139             //   FlatSB_EnableScrollBar FlatSB_GetScrollInfo FlatSB_GetScrollPos
1140             //   FlatSB_GetScrollProp FlatSB_GetScrollRange FlatSB_SetScrollInfo
1141             //   FlatSB_SetScrollPos FlatSB_SetScrollProp FlatSB_SetScrollRange
1142             //   FlatSB_ShowScrollBar
1143             //   _DrawIndirectImageList _DuplicateImageList
1144             //   InitializeFlatSB
1145             //   UninitializeFlatSB
1146             // we could check for any of these - I chose DllInstall
1147             FARPROC theProc = ::GetProcAddress(theModule, "DllInstall");
1148             if (! theProc)
1149             {
1150                 // not found, must be 4.70
1151                 version = 470;
1152             }
1153             else
1154             {                         // found, must be 4.71
1155                 version = 471;
1156             }
1157         }
1158     }
1159     return version;
1160 }
1161
1162 void wxExit()
1163 {
1164     wxLogError(_("Fatal error: exiting"));
1165
1166     wxApp::CleanUp();
1167 }
1168
1169 // Yield to incoming messages
1170 bool wxYield()
1171 {
1172     MSG msg;
1173     // We want to go back to the main message loop
1174     // if we see a WM_QUIT. (?)
1175     while (PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE) && msg.message != WM_QUIT)
1176     {
1177         if ( !wxTheApp->DoMessage() )
1178             break;
1179     }
1180
1181     return TRUE;
1182 }
1183
1184 HINSTANCE wxGetInstance()
1185 {
1186     return wxhInstance;
1187 }
1188
1189 void wxSetInstance(HINSTANCE hInst)
1190 {
1191     wxhInstance = hInst;
1192 }
1193
1194 // For some reason, with MSVC++ 1.5, WinMain isn't linked in properly
1195 // if in a separate file. So include it here to ensure it's linked.
1196 #if (defined(__VISUALC__) && !defined(__WIN32__)) || (defined(__GNUWIN32__) && !defined(__TWIN32__))
1197 #include "main.cpp"
1198 #endif