]> git.saurik.com Git - wxWidgets.git/blob - src/msw/app.cpp
Update wxList operators, TRUE, FALSE.
[wxWidgets.git] / 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 #include "wx/wxchar.h"
47 #include "wx/icon.h"
48 #include "wx/log.h"
49 #endif
50
51 #include "wx/cmdline.h"
52 #include "wx/filename.h"
53 #include "wx/module.h"
54
55 #include "wx/msw/private.h"
56
57 #if wxUSE_THREADS
58 #include "wx/thread.h"
59
60 // define the array of MSG strutures
61 WX_DECLARE_OBJARRAY(MSG, wxMsgArray);
62
63 #include "wx/arrimpl.cpp"
64
65 WX_DEFINE_OBJARRAY(wxMsgArray);
66 #endif // wxUSE_THREADS
67
68 #if wxUSE_WX_RESOURCES
69 #include "wx/resource.h"
70 #endif
71
72 #if wxUSE_TOOLTIPS
73 #include "wx/tooltip.h"
74 #endif // wxUSE_TOOLTIPS
75
76 // OLE is used for drag-and-drop, clipboard, OLE Automation..., but some
77 // compilers don't support it (missing headers, libs, ...)
78 #if defined(__GNUWIN32_OLD__) || defined(__SC__) || defined(__SALFORDC__)
79 #undef wxUSE_OLE
80
81 #define wxUSE_OLE 0
82 #endif // broken compilers
83
84 #if wxUSE_OLE
85 #include <ole2.h>
86 #endif
87
88 #include <string.h>
89 #include <ctype.h>
90
91 #if defined(__WIN95__) && !((defined(__GNUWIN32_OLD__) || defined(__TWIN32__) || defined(__WXMICROWIN__)) && !defined(__CYGWIN10__))
92 #include <commctrl.h>
93 #endif
94
95 #ifndef __WXMICROWIN__
96 #include "wx/msw/msvcrt.h"
97 #endif
98
99 // ----------------------------------------------------------------------------
100 // conditional compilation
101 // ----------------------------------------------------------------------------
102
103 // The macro _WIN32_IE is defined by commctrl.h (unless it had already been
104 // defined before) and shows us what common control features are available
105 // during the compile time (it doesn't mean that they will be available during
106 // the run-time, use GetComCtl32Version() to test for them!). The possible
107 // values are:
108 //
109 // 0x0200 for comctl32.dll 4.00 shipped with Win95/NT 4.0
110 // 0x0300 4.70 IE 3.x
111 // 0x0400 4.71 IE 4.0
112 // 0x0401 4.72 IE 4.01 and Win98
113 // 0x0500 5.00 IE 5.x and NT 5.0 (Win2000)
114
115 #ifndef _WIN32_IE
116 // minimal set of features by default
117 #define _WIN32_IE 0x0200
118 #endif
119
120 #if _WIN32_IE >= 0x0300 && \
121 (!defined(__MINGW32__) || wxCHECK_W32API_VERSION( 2, 0 )) && \
122 !defined(__CYGWIN__)
123 #include <shlwapi.h>
124 #endif
125
126 // ---------------------------------------------------------------------------
127 // global variables
128 // ---------------------------------------------------------------------------
129
130 extern wxChar *wxBuffer;
131 extern wxList WXDLLEXPORT wxPendingDelete;
132 #ifndef __WXMICROWIN__
133 extern void wxSetKeyboardHook(bool doIt);
134 #endif
135
136 MSG s_currentMsg;
137 wxApp *wxTheApp = NULL;
138
139 // NB: all "NoRedraw" classes must have the same names as the "normal" classes
140 // with NR suffix - wxWindow::MSWCreate() supposes this
141 const wxChar *wxCanvasClassName = wxT("wxWindowClass");
142 const wxChar *wxCanvasClassNameNR = wxT("wxWindowClassNR");
143 const wxChar *wxMDIFrameClassName = wxT("wxMDIFrameClass");
144 const wxChar *wxMDIFrameClassNameNoRedraw = wxT("wxMDIFrameClassNR");
145 const wxChar *wxMDIChildFrameClassName = wxT("wxMDIChildFrameClass");
146 const wxChar *wxMDIChildFrameClassNameNoRedraw = wxT("wxMDIChildFrameClassNR");
147
148 HICON wxSTD_FRAME_ICON = (HICON) NULL;
149 HICON wxSTD_MDICHILDFRAME_ICON = (HICON) NULL;
150 HICON wxSTD_MDIPARENTFRAME_ICON = (HICON) NULL;
151
152 HICON wxDEFAULT_FRAME_ICON = (HICON) NULL;
153 HICON wxDEFAULT_MDICHILDFRAME_ICON = (HICON) NULL;
154 HICON wxDEFAULT_MDIPARENTFRAME_ICON = (HICON) NULL;
155
156 HBRUSH wxDisableButtonBrush = (HBRUSH) 0;
157
158 LRESULT WXDLLEXPORT APIENTRY wxWndProc(HWND, UINT, WPARAM, LPARAM);
159
160 // FIXME wxUSE_ON_FATAL_EXCEPTION is only supported for VC++ now because it
161 // needs compiler support for Win32 SEH. Others (especially Borland)
162 // probably have it too, but I'm not sure about how it works
163 // JACS: get 'Cannot use __try in functions that require unwinding
164 // in Unicode mode, so disabling.
165 #if !defined(__VISUALC__) || defined(__WIN16__) || defined(UNICODE)
166 #undef wxUSE_ON_FATAL_EXCEPTION
167 #define wxUSE_ON_FATAL_EXCEPTION 0
168 #endif // VC++
169
170 #if wxUSE_ON_FATAL_EXCEPTION
171 static bool gs_handleExceptions = FALSE;
172 #endif
173
174 // ===========================================================================
175 // implementation
176 // ===========================================================================
177
178 // ---------------------------------------------------------------------------
179 // wxApp
180 // ---------------------------------------------------------------------------
181
182 IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
183
184 BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
185 EVT_IDLE(wxApp::OnIdle)
186 EVT_END_SESSION(wxApp::OnEndSession)
187 EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
188 END_EVENT_TABLE()
189
190 //// Initialize
191 bool wxApp::Initialize()
192 {
193 // the first thing to do is to check if we're trying to run an Unicode
194 // program under Win9x w/o MSLU emulation layer - if so, abort right now
195 // as it has no chance to work
196 #if wxUSE_UNICODE && !wxUSE_UNICODE_MSLU
197 if ( wxGetOsVersion() != wxWINDOWS_NT )
198 {
199 // note that we can use MessageBoxW() as it's implemented even under
200 // Win9x - OTOH, we can't use wxGetTranslation() because the file APIs
201 // used by wxLocale are not
202 ::MessageBox
203 (
204 NULL,
205 _T("This program uses Unicode and requires Windows NT/2000/XP.\nProgram aborted."),
206 _T("wxWindows Fatal Error"),
207 MB_ICONERROR | MB_OK
208 );
209
210 return FALSE;
211 }
212 #endif // wxUSE_UNICODE && !wxUSE_UNICODE_MSLU
213
214 wxBuffer = new wxChar[1500]; // FIXME
215
216 wxClassInfo::InitializeClasses();
217
218 #if wxUSE_THREADS
219 wxPendingEventsLocker = new wxCriticalSection;
220 #endif
221
222 wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING);
223 wxTheColourDatabase->Initialize();
224
225 wxInitializeStockLists();
226 wxInitializeStockObjects();
227
228 #if wxUSE_WX_RESOURCES
229 wxInitializeResourceSystem();
230 #endif
231
232 wxBitmap::InitStandardHandlers();
233
234 #if defined(__WIN95__) && !defined(__WXMICROWIN__)
235 InitCommonControls();
236 #endif // __WIN95__
237
238 #if wxUSE_OLE || wxUSE_DRAG_AND_DROP
239
240 #ifdef __WIN16__
241 // for OLE, enlarge message queue to be as large as possible
242 int iMsg = 96;
243 while (!SetMessageQueue(iMsg) && (iMsg -= 8))
244 ;
245 #endif // Win16
246
247 #if wxUSE_OLE
248 // we need to initialize OLE library
249 if ( FAILED(::OleInitialize(NULL)) )
250 wxLogError(_("Cannot initialize OLE"));
251 #endif
252
253 #endif // wxUSE_OLE
254
255 #if wxUSE_CTL3D
256 if (!Ctl3dRegister(wxhInstance))
257 wxLogError(wxT("Cannot register CTL3D"));
258
259 Ctl3dAutoSubclass(wxhInstance);
260 #endif // wxUSE_CTL3D
261
262 // VZ: these icons are not in wx.rc anyhow (but should they?)!
263 #if 0
264 wxSTD_FRAME_ICON = LoadIcon(wxhInstance, wxT("wxSTD_FRAME"));
265 wxSTD_MDIPARENTFRAME_ICON = LoadIcon(wxhInstance, wxT("wxSTD_MDIPARENTFRAME"));
266 wxSTD_MDICHILDFRAME_ICON = LoadIcon(wxhInstance, wxT("wxSTD_MDICHILDFRAME"));
267
268 wxDEFAULT_FRAME_ICON = LoadIcon(wxhInstance, wxT("wxDEFAULT_FRAME"));
269 wxDEFAULT_MDIPARENTFRAME_ICON = LoadIcon(wxhInstance, wxT("wxDEFAULT_MDIPARENTFRAME"));
270 wxDEFAULT_MDICHILDFRAME_ICON = LoadIcon(wxhInstance, wxT("wxDEFAULT_MDICHILDFRAME"));
271 #endif // 0
272
273 RegisterWindowClasses();
274
275 #ifndef __WXMICROWIN__
276 // Create the brush for disabling bitmap buttons
277
278 LOGBRUSH lb;
279 lb.lbStyle = BS_PATTERN;
280 lb.lbColor = 0;
281 lb.lbHatch = (int)LoadBitmap( wxhInstance, wxT("wxDISABLE_BUTTON_BITMAP") );
282 if ( lb.lbHatch )
283 {
284 wxDisableButtonBrush = ::CreateBrushIndirect( & lb );
285 ::DeleteObject( (HGDIOBJ)lb.lbHatch );
286 }
287 //else: wxWindows resources are probably not linked in
288 #endif
289
290 #if wxUSE_PENWINDOWS
291 wxRegisterPenWin();
292 #endif
293
294 wxWinHandleHash = new wxWinHashTable(wxKEY_INTEGER, 100);
295
296 // This is to foil optimizations in Visual C++ that throw out dummy.obj.
297 // PLEASE DO NOT ALTER THIS.
298 #if defined(__VISUALC__) && defined(__WIN16__) && !defined(WXMAKINGDLL)
299 extern char wxDummyChar;
300 if (wxDummyChar) wxDummyChar++;
301 #endif
302
303 #ifndef __WXMICROWIN__
304 wxSetKeyboardHook(TRUE);
305 #endif
306
307 wxModule::RegisterModules();
308 if (!wxModule::InitializeModules())
309 return FALSE;
310 return TRUE;
311 }
312
313 // ---------------------------------------------------------------------------
314 // RegisterWindowClasses
315 // ---------------------------------------------------------------------------
316
317 // TODO we should only register classes really used by the app. For this it
318 // would be enough to just delay the class registration until an attempt
319 // to create a window of this class is made.
320 bool wxApp::RegisterWindowClasses()
321 {
322 WNDCLASS wndclass;
323 wxZeroMemory(wndclass);
324
325 // for each class we register one with CS_(V|H)REDRAW style and one
326 // without for windows created with wxNO_FULL_REDRAW_ON_REPAINT flag
327 static const long styleNormal = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
328 static const long styleNoRedraw = CS_DBLCLKS;
329
330 // the fields which are common to all classes
331 wndclass.lpfnWndProc = (WNDPROC)wxWndProc;
332 wndclass.hInstance = wxhInstance;
333 wndclass.hCursor = ::LoadCursor((HINSTANCE)NULL, IDC_ARROW);
334
335 // Register the frame window class.
336 wndclass.hbrBackground = (HBRUSH)(COLOR_APPWORKSPACE + 1);
337 wndclass.lpszClassName = wxCanvasClassName;
338 wndclass.style = styleNormal;
339
340 if ( !RegisterClass(&wndclass) )
341 {
342 wxLogLastError(wxT("RegisterClass(frame)"));
343 }
344
345 // "no redraw" frame
346 wndclass.lpszClassName = wxCanvasClassNameNR;
347 wndclass.style = styleNoRedraw;
348
349 if ( !RegisterClass(&wndclass) )
350 {
351 wxLogLastError(wxT("RegisterClass(no redraw frame)"));
352 }
353
354 // Register the MDI frame window class.
355 wndclass.hbrBackground = (HBRUSH)NULL; // paint MDI frame ourselves
356 wndclass.lpszClassName = wxMDIFrameClassName;
357 wndclass.style = styleNormal;
358
359 if ( !RegisterClass(&wndclass) )
360 {
361 wxLogLastError(wxT("RegisterClass(MDI parent)"));
362 }
363
364 // "no redraw" MDI frame
365 wndclass.lpszClassName = wxMDIFrameClassNameNoRedraw;
366 wndclass.style = styleNoRedraw;
367
368 if ( !RegisterClass(&wndclass) )
369 {
370 wxLogLastError(wxT("RegisterClass(no redraw MDI parent frame)"));
371 }
372
373 // Register the MDI child frame window class.
374 wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
375 wndclass.lpszClassName = wxMDIChildFrameClassName;
376 wndclass.style = styleNormal;
377
378 if ( !RegisterClass(&wndclass) )
379 {
380 wxLogLastError(wxT("RegisterClass(MDI child)"));
381 }
382
383 // "no redraw" MDI child frame
384 wndclass.lpszClassName = wxMDIChildFrameClassNameNoRedraw;
385 wndclass.style = styleNoRedraw;
386
387 if ( !RegisterClass(&wndclass) )
388 {
389 wxLogLastError(wxT("RegisterClass(no redraw MDI child)"));
390 }
391
392 return TRUE;
393 }
394
395 // ---------------------------------------------------------------------------
396 // UnregisterWindowClasses
397 // ---------------------------------------------------------------------------
398
399 bool wxApp::UnregisterWindowClasses()
400 {
401 bool retval = TRUE;
402
403 #ifndef __WXMICROWIN__
404 // MDI frame window class.
405 if ( !::UnregisterClass(wxMDIFrameClassName, wxhInstance) )
406 {
407 wxLogLastError(wxT("UnregisterClass(MDI parent)"));
408
409 retval = FALSE;
410 }
411
412 // "no redraw" MDI frame
413 if ( !::UnregisterClass(wxMDIFrameClassNameNoRedraw, wxhInstance) )
414 {
415 wxLogLastError(wxT("UnregisterClass(no redraw MDI parent frame)"));
416
417 retval = FALSE;
418 }
419
420 // MDI child frame window class.
421 if ( !::UnregisterClass(wxMDIChildFrameClassName, wxhInstance) )
422 {
423 wxLogLastError(wxT("UnregisterClass(MDI child)"));
424
425 retval = FALSE;
426 }
427
428 // "no redraw" MDI child frame
429 if ( !::UnregisterClass(wxMDIChildFrameClassNameNoRedraw, wxhInstance) )
430 {
431 wxLogLastError(wxT("UnregisterClass(no redraw MDI child)"));
432
433 retval = FALSE;
434 }
435
436 // canvas class name
437 if ( !::UnregisterClass(wxCanvasClassName, wxhInstance) )
438 {
439 wxLogLastError(wxT("UnregisterClass(canvas)"));
440
441 retval = FALSE;
442 }
443
444 if ( !::UnregisterClass(wxCanvasClassNameNR, wxhInstance) )
445 {
446 wxLogLastError(wxT("UnregisterClass(no redraw canvas)"));
447
448 retval = FALSE;
449 }
450 #endif // __WXMICROWIN__
451
452 return retval;
453 }
454
455 // ---------------------------------------------------------------------------
456 // Convert Windows to argc, argv style
457 // ---------------------------------------------------------------------------
458
459 void wxApp::ConvertToStandardCommandArgs(const char* lpCmdLine)
460 {
461 // break the command line in words
462 wxArrayString args =
463 wxCmdLineParser::ConvertStringToArgs(wxConvertMB2WX(lpCmdLine));
464
465 // +1 here for the program name
466 argc = args.GetCount() + 1;
467
468 // and +1 here for the terminating NULL
469 argv = new wxChar *[argc + 1];
470
471 argv[0] = new wxChar[260]; // 260 is MAX_PATH value from windef.h
472 ::GetModuleFileName(wxhInstance, argv[0], 260);
473
474 // also set the app name from argv[0]
475 wxString name;
476 wxFileName::SplitPath(argv[0], NULL, &name, NULL);
477
478 // but don't override the name already set by the user code, if any
479 if ( GetAppName().empty() )
480 SetAppName(name);
481
482 // copy all the other arguments to wxApp::argv[]
483 for ( int i = 1; i < argc; i++ )
484 {
485 argv[i] = copystring(args[i - 1]);
486 }
487
488 // argv[] must be NULL-terminated
489 argv[argc] = NULL;
490 }
491
492 //// Cleans up any wxWindows internal structures left lying around
493
494 void wxApp::CleanUp()
495 {
496 //// COMMON CLEANUP
497
498 #if wxUSE_LOG
499 // flush the logged messages if any and install a 'safer' log target: the
500 // default one (wxLogGui) can't be used after the resources are freed just
501 // below and the user suppliedo ne might be even more unsafe (using any
502 // wxWindows GUI function is unsafe starting from now)
503 wxLog::DontCreateOnDemand();
504
505 // this will flush the old messages if any
506 delete wxLog::SetActiveTarget(new wxLogStderr);
507 #endif // wxUSE_LOG
508
509 // One last chance for pending objects to be cleaned up
510 wxTheApp->DeletePendingObjects();
511
512 wxModule::CleanUpModules();
513
514 #if wxUSE_WX_RESOURCES
515 wxCleanUpResourceSystem();
516
517 // wxDefaultResourceTable->ClearTable();
518 #endif
519
520 wxDeleteStockObjects();
521
522 // Destroy all GDI lists, etc.
523 wxDeleteStockLists();
524
525 delete wxTheColourDatabase;
526 wxTheColourDatabase = NULL;
527
528 wxBitmap::CleanUpHandlers();
529
530 delete[] wxBuffer;
531 wxBuffer = NULL;
532
533 //// WINDOWS-SPECIFIC CLEANUP
534
535 #ifndef __WXMICROWIN__
536 wxSetKeyboardHook(FALSE);
537 #endif
538
539 #if wxUSE_PENWINDOWS
540 wxCleanUpPenWin();
541 #endif
542
543 if (wxSTD_FRAME_ICON)
544 DestroyIcon(wxSTD_FRAME_ICON);
545 if (wxSTD_MDICHILDFRAME_ICON)
546 DestroyIcon(wxSTD_MDICHILDFRAME_ICON);
547 if (wxSTD_MDIPARENTFRAME_ICON)
548 DestroyIcon(wxSTD_MDIPARENTFRAME_ICON);
549
550 if (wxDEFAULT_FRAME_ICON)
551 DestroyIcon(wxDEFAULT_FRAME_ICON);
552 if (wxDEFAULT_MDICHILDFRAME_ICON)
553 DestroyIcon(wxDEFAULT_MDICHILDFRAME_ICON);
554 if (wxDEFAULT_MDIPARENTFRAME_ICON)
555 DestroyIcon(wxDEFAULT_MDIPARENTFRAME_ICON);
556
557 if ( wxDisableButtonBrush )
558 ::DeleteObject( wxDisableButtonBrush );
559
560 #if wxUSE_OLE
561 ::OleUninitialize();
562 #endif
563
564 #ifdef WXMAKINGDLL
565 // for an EXE the classes are unregistered when it terminates but DLL may
566 // be loaded several times (load/unload/load) into the same process in
567 // which case the registration will fail after the first time if we don't
568 // unregister the classes now
569 UnregisterWindowClasses();
570 #endif // WXMAKINGDLL
571
572 #if wxUSE_CTL3D
573 Ctl3dUnregister(wxhInstance);
574 #endif
575
576 delete wxWinHandleHash;
577
578 // GL: I'm annoyed ... I don't know where to put this and I don't want to
579 // create a module for that as it's part of the core.
580 delete wxPendingEvents;
581
582 #if wxUSE_THREADS
583 delete wxPendingEventsLocker;
584 // If we don't do the following, we get an apparent memory leak
585 #if wxUSE_VALIDATORS
586 ((wxEvtHandler&) wxDefaultValidator).ClearEventLocker();
587 #endif // wxUSE_VALIDATORS
588 #endif // wxUSE_THREADS
589
590 wxClassInfo::CleanUpClasses();
591
592 delete wxTheApp;
593 wxTheApp = NULL;
594
595 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
596 // At this point we want to check if there are any memory
597 // blocks that aren't part of the wxDebugContext itself,
598 // as a special case. Then when dumping we need to ignore
599 // wxDebugContext, too.
600 if (wxDebugContext::CountObjectsLeft(TRUE) > 0)
601 {
602 wxLogMessage(wxT("There were memory leaks."));
603 wxDebugContext::Dump();
604 wxDebugContext::PrintStatistics();
605 }
606 // wxDebugContext::SetStream(NULL, NULL);
607 #endif
608
609 #if wxUSE_LOG
610 // do it as the very last thing because everything else can log messages
611 delete wxLog::SetActiveTarget(NULL);
612 #endif // wxUSE_LOG
613 }
614
615 //----------------------------------------------------------------------
616 // Entry point helpers, used by wxPython
617 //----------------------------------------------------------------------
618
619 int WXDLLEXPORT wxEntryStart( int WXUNUSED(argc), char** WXUNUSED(argv) )
620 {
621 return wxApp::Initialize();
622 }
623
624 int WXDLLEXPORT wxEntryInitGui()
625 {
626 return wxTheApp->OnInitGui();
627 }
628
629 void WXDLLEXPORT wxEntryCleanup()
630 {
631 wxApp::CleanUp();
632 }
633
634
635 #if !defined(_WINDLL) || (defined(_WINDLL) && defined(WXMAKINGDLL))
636
637 // temporarily disable this warning which would be generated in release builds
638 // because of __try
639 #ifdef __VISUALC__
640 #pragma warning(disable: 4715) // not all control paths return a value
641 #endif // Visual C++
642
643 //----------------------------------------------------------------------
644 // Main wxWindows entry point
645 //----------------------------------------------------------------------
646 int wxEntry(WXHINSTANCE hInstance,
647 WXHINSTANCE WXUNUSED(hPrevInstance),
648 char *lpCmdLine,
649 int nCmdShow,
650 bool enterLoop)
651 {
652 // do check for memory leaks on program exit
653 // (another useful flag is _CRTDBG_DELAY_FREE_MEM_DF which doesn't free
654 // deallocated memory which may be used to simulate low-memory condition)
655 #ifndef __WXMICROWIN__
656 wxCrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF);
657 #endif
658
659 #ifdef __MWERKS__
660 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
661 // This seems to be necessary since there are 'rogue'
662 // objects present at this point (perhaps global objects?)
663 // Setting a checkpoint will ignore them as far as the
664 // memory checking facility is concerned.
665 // Of course you may argue that memory allocated in globals should be
666 // checked, but this is a reasonable compromise.
667 wxDebugContext::SetCheckpoint();
668 #endif
669 #endif
670
671 // take everything into a try-except block to be able to call
672 // OnFatalException() if necessary
673 #if wxUSE_ON_FATAL_EXCEPTION
674 __try {
675 #endif
676 wxhInstance = (HINSTANCE) hInstance;
677
678 if (!wxEntryStart(0,0))
679 return 0;
680
681 // create the application object or ensure that one already exists
682 if (!wxTheApp)
683 {
684 // The app may have declared a global application object, but we recommend
685 // the IMPLEMENT_APP macro is used instead, which sets an initializer
686 // function for delayed, dynamic app object construction.
687 wxCHECK_MSG( wxApp::GetInitializerFunction(), 0,
688 wxT("No initializer - use IMPLEMENT_APP macro.") );
689
690 wxTheApp = (wxApp*) (*wxApp::GetInitializerFunction()) ();
691 }
692
693 wxCHECK_MSG( wxTheApp, 0, wxT("You have to define an instance of wxApp!") );
694
695 // save the WinMain() parameters
696 if (lpCmdLine) // MicroWindows passes NULL
697 wxTheApp->ConvertToStandardCommandArgs(lpCmdLine);
698 wxTheApp->m_nCmdShow = nCmdShow;
699
700 // We really don't want timestamps by default, because it means
701 // we can't simply double-click on the error message and get to that
702 // line in the source. So VC++ at least, let's have a sensible default.
703 #ifdef __VISUALC__
704 #if wxUSE_LOG
705 wxLog::SetTimestamp(NULL);
706 #endif // wxUSE_LOG
707 #endif // __VISUALC__
708
709 // init the app
710 int retValue = wxEntryInitGui() && wxTheApp->OnInit() ? 0 : -1;
711
712 if ( retValue == 0 )
713 {
714 if ( enterLoop )
715 {
716 // run the main loop
717 wxTheApp->OnRun();
718 }
719 else
720 {
721 // we want to initialize, but not run or exit immediately.
722 return 1;
723 }
724 }
725 //else: app initialization failed, so we skipped OnRun()
726
727 wxWindow *topWindow = wxTheApp->GetTopWindow();
728 if ( topWindow )
729 {
730 // Forcibly delete the window.
731 if ( topWindow->IsKindOf(CLASSINFO(wxFrame)) ||
732 topWindow->IsKindOf(CLASSINFO(wxDialog)) )
733 {
734 topWindow->Close(TRUE);
735 wxTheApp->DeletePendingObjects();
736 }
737 else
738 {
739 delete topWindow;
740 wxTheApp->SetTopWindow(NULL);
741 }
742 }
743
744 retValue = wxTheApp->OnExit();
745
746 wxEntryCleanup();
747
748 return retValue;
749
750 #if wxUSE_ON_FATAL_EXCEPTION
751 }
752 __except ( gs_handleExceptions ? EXCEPTION_EXECUTE_HANDLER
753 : EXCEPTION_CONTINUE_SEARCH ) {
754 if ( wxTheApp )
755 {
756 // give the user a chance to do something special about this
757 wxTheApp->OnFatalException();
758 }
759
760 ::ExitProcess(3); // the same exit code as abort()
761
762 // NOTREACHED
763 }
764 #endif // wxUSE_ON_FATAL_EXCEPTION
765 }
766
767 // restore warning state
768 #ifdef __VISUALC__
769 #pragma warning(default: 4715) // not all control paths return a value
770 #endif // Visual C++
771
772 #else /* _WINDLL */
773
774 //----------------------------------------------------------------------
775 // Entry point for wxWindows + the App in a DLL
776 //----------------------------------------------------------------------
777
778 int wxEntry(WXHINSTANCE hInstance)
779 {
780 wxhInstance = (HINSTANCE) hInstance;
781 wxEntryStart(0, 0);
782
783 // The app may have declared a global application object, but we recommend
784 // the IMPLEMENT_APP macro is used instead, which sets an initializer function
785 // for delayed, dynamic app object construction.
786 if (!wxTheApp)
787 {
788 wxCHECK_MSG( wxApp::GetInitializerFunction(), 0,
789 "No initializer - use IMPLEMENT_APP macro." );
790
791 wxTheApp = (* wxApp::GetInitializerFunction()) ();
792 }
793
794 wxCHECK_MSG( wxTheApp, 0, "You have to define an instance of wxApp!" );
795
796 wxTheApp->argc = 0;
797 wxTheApp->argv = NULL;
798
799 wxEntryInitGui();
800
801 wxTheApp->OnInit();
802
803 wxWindow *topWindow = wxTheApp->GetTopWindow();
804 if ( topWindow && topWindow->GetHWND())
805 {
806 topWindow->Show(TRUE);
807 }
808
809 return 1;
810 }
811 #endif // _WINDLL
812
813 //// Static member initialization
814
815 wxAppInitializerFunction wxAppBase::m_appInitFn = (wxAppInitializerFunction) NULL;
816
817 wxApp::wxApp()
818 {
819 argc = 0;
820 argv = NULL;
821 m_printMode = wxPRINT_WINDOWS;
822 m_auto3D = TRUE;
823 }
824
825 wxApp::~wxApp()
826 {
827 // Delete command-line args
828 int i;
829 for (i = 0; i < argc; i++)
830 {
831 delete[] argv[i];
832 }
833 delete[] argv;
834 }
835
836 bool wxApp::Initialized()
837 {
838 #ifndef _WINDLL
839 if (GetTopWindow())
840 return TRUE;
841 else
842 return FALSE;
843 #else // Assume initialized if DLL (no way of telling)
844 return TRUE;
845 #endif
846 }
847
848 /*
849 * Get and process a message, returning FALSE if WM_QUIT
850 * received (and also set the flag telling the app to exit the main loop)
851 *
852 */
853 bool wxApp::DoMessage()
854 {
855 BOOL rc = ::GetMessage(&s_currentMsg, (HWND) NULL, 0, 0);
856 if ( rc == 0 )
857 {
858 // got WM_QUIT
859 m_keepGoing = FALSE;
860
861 return FALSE;
862 }
863 else if ( rc == -1 )
864 {
865 // should never happen, but let's test for it nevertheless
866 wxLogLastError(wxT("GetMessage"));
867 }
868 else
869 {
870 #if wxUSE_THREADS
871 wxASSERT_MSG( wxThread::IsMain(),
872 wxT("only the main thread can process Windows messages") );
873
874 static bool s_hadGuiLock = TRUE;
875 static wxMsgArray s_aSavedMessages;
876
877 // if a secondary thread owns is doing GUI calls, save all messages for
878 // later processing - we can't process them right now because it will
879 // lead to recursive library calls (and we're not reentrant)
880 if ( !wxGuiOwnedByMainThread() )
881 {
882 s_hadGuiLock = FALSE;
883
884 // leave out WM_COMMAND messages: too dangerous, sometimes
885 // the message will be processed twice
886 if ( !wxIsWaitingForThread() ||
887 s_currentMsg.message != WM_COMMAND )
888 {
889 s_aSavedMessages.Add(s_currentMsg);
890 }
891
892 return TRUE;
893 }
894 else
895 {
896 // have we just regained the GUI lock? if so, post all of the saved
897 // messages
898 //
899 // FIXME of course, it's not _exactly_ the same as processing the
900 // messages normally - expect some things to break...
901 if ( !s_hadGuiLock )
902 {
903 s_hadGuiLock = TRUE;
904
905 size_t count = s_aSavedMessages.GetCount();
906 for ( size_t n = 0; n < count; n++ )
907 {
908 MSG& msg = s_aSavedMessages[n];
909
910 DoMessage((WXMSG *)&msg);
911 }
912
913 s_aSavedMessages.Empty();
914 }
915 }
916 #endif // wxUSE_THREADS
917
918 // Process the message
919 DoMessage((WXMSG *)&s_currentMsg);
920 }
921
922 return TRUE;
923 }
924
925 void wxApp::DoMessage(WXMSG *pMsg)
926 {
927 if ( !ProcessMessage(pMsg) )
928 {
929 ::TranslateMessage((MSG *)pMsg);
930 ::DispatchMessage((MSG *)pMsg);
931 }
932 }
933
934 /*
935 * Keep trying to process messages until WM_QUIT
936 * received.
937 *
938 * If there are messages to be processed, they will all be
939 * processed and OnIdle will not be called.
940 * When there are no more messages, OnIdle is called.
941 * If OnIdle requests more time,
942 * it will be repeatedly called so long as there are no pending messages.
943 * A 'feature' of this is that once OnIdle has decided that no more processing
944 * is required, then it won't get processing time until further messages
945 * are processed (it'll sit in DoMessage).
946 */
947
948 int wxApp::MainLoop()
949 {
950 m_keepGoing = TRUE;
951
952 while ( m_keepGoing )
953 {
954 #if wxUSE_THREADS
955 wxMutexGuiLeaveOrEnter();
956 #endif // wxUSE_THREADS
957
958 while ( !Pending() && ProcessIdle() )
959 ;
960
961 // a message came or no more idle processing to do
962 DoMessage();
963 }
964
965 return s_currentMsg.wParam;
966 }
967
968 // Returns TRUE if more time is needed.
969 bool wxApp::ProcessIdle()
970 {
971 wxIdleEvent event;
972 event.SetEventObject(this);
973 ProcessEvent(event);
974
975 return event.MoreRequested();
976 }
977
978 void wxApp::ExitMainLoop()
979 {
980 // this will set m_keepGoing to FALSE a bit later
981 ::PostQuitMessage(0);
982 }
983
984 bool wxApp::Pending()
985 {
986 return ::PeekMessage(&s_currentMsg, 0, 0, 0, PM_NOREMOVE) != 0;
987 }
988
989 void wxApp::Dispatch()
990 {
991 DoMessage();
992 }
993
994 /*
995 * Give all windows a chance to preprocess
996 * the message. Some may have accelerator tables, or have
997 * MDI complications.
998 */
999
1000 bool wxApp::ProcessMessage(WXMSG *wxmsg)
1001 {
1002 MSG *msg = (MSG *)wxmsg;
1003 HWND hwnd = msg->hwnd;
1004 wxWindow *wndThis = wxGetWindowFromHWND((WXHWND)hwnd);
1005
1006 // this may happen if the event occured in a standard modeless dialog (the
1007 // only example of which I know of is the find/replace dialog) - then call
1008 // IsDialogMessage() to make TAB navigation in it work
1009 if ( !wndThis )
1010 {
1011 // we need to find the dialog containing this control as
1012 // IsDialogMessage() just eats all the messages (i.e. returns TRUE for
1013 // them) if we call it for the control itself
1014 while ( hwnd && ::GetWindowLong(hwnd, GWL_STYLE) & WS_CHILD )
1015 {
1016 hwnd = ::GetParent(hwnd);
1017 }
1018
1019 return hwnd && ::IsDialogMessage(hwnd, msg) != 0;
1020 }
1021
1022 #if wxUSE_TOOLTIPS
1023 // we must relay WM_MOUSEMOVE events to the tooltip ctrl if we want it to
1024 // popup the tooltip bubbles
1025 if ( (msg->message == WM_MOUSEMOVE) )
1026 {
1027 wxToolTip *tt = wndThis->GetToolTip();
1028 if ( tt )
1029 {
1030 tt->RelayEvent(wxmsg);
1031 }
1032 }
1033 #endif // wxUSE_TOOLTIPS
1034
1035 // allow the window to prevent certain messages from being
1036 // translated/processed (this is currently used by wxTextCtrl to always
1037 // grab Ctrl-C/V/X, even if they are also accelerators in some parent)
1038 if ( !wndThis->MSWShouldPreProcessMessage(wxmsg) )
1039 {
1040 return FALSE;
1041 }
1042
1043 // try translations first: the accelerators override everything
1044 wxWindow *wnd;
1045
1046 for ( wnd = wndThis; wnd; wnd = wnd->GetParent() )
1047 {
1048 if ( wnd->MSWTranslateMessage(wxmsg))
1049 return TRUE;
1050
1051 // stop at first top level window, i.e. don't try to process the key
1052 // strokes originating in a dialog using the accelerators of the parent
1053 // frame - this doesn't make much sense
1054 if ( wnd->IsTopLevel() )
1055 break;
1056 }
1057
1058 // now try the other hooks (kbd navigation is handled here): we start from
1059 // wndThis->GetParent() because wndThis->MSWProcessMessage() was already
1060 // called above
1061 for ( wnd = wndThis->GetParent(); wnd; wnd = wnd->GetParent() )
1062 {
1063 if ( wnd->MSWProcessMessage(wxmsg) )
1064 return TRUE;
1065 }
1066
1067 // no special preprocessing for this message, dispatch it normally
1068 return FALSE;
1069 }
1070
1071 // this is a temporary hack and will be replaced by using wxEventLoop in the
1072 // future
1073 //
1074 // it is needed to allow other event loops (currently only one: the modal
1075 // dialog one) to reset the OnIdle() semaphore because otherwise OnIdle()
1076 // wouldn't do anything while a modal dialog shown from OnIdle() call is shown.
1077 bool wxIsInOnIdleFlag = FALSE;
1078
1079 void wxApp::OnIdle(wxIdleEvent& event)
1080 {
1081 // Avoid recursion (via ProcessEvent default case)
1082 if ( wxIsInOnIdleFlag )
1083 return;
1084
1085 wxIsInOnIdleFlag = TRUE;
1086
1087 // If there are pending events, we must process them: pending events
1088 // are either events to the threads other than main or events posted
1089 // with wxPostEvent() functions
1090 // GRG: I have moved this here so that all pending events are processed
1091 // before starting to delete any objects. This behaves better (in
1092 // particular, wrt wxPostEvent) and is coherent with wxGTK's current
1093 // behaviour. Changed Feb/2000 before 2.1.14
1094 ProcessPendingEvents();
1095
1096 // 'Garbage' collection of windows deleted with Close().
1097 DeletePendingObjects();
1098
1099 #if wxUSE_LOG
1100 // flush the logged messages if any
1101 wxLog::FlushActive();
1102 #endif // wxUSE_LOG
1103
1104 #if wxUSE_DC_CACHEING
1105 // automated DC cache management: clear the cached DCs and bitmap
1106 // if it's likely that the app has finished with them, that is, we
1107 // get an idle event and we're not dragging anything.
1108 if (!::GetKeyState(MK_LBUTTON) && !::GetKeyState(MK_MBUTTON) && !::GetKeyState(MK_RBUTTON))
1109 wxDC::ClearCache();
1110 #endif // wxUSE_DC_CACHEING
1111
1112 // Send OnIdle events to all windows
1113 if ( SendIdleEvents() )
1114 {
1115 // SendIdleEvents() returns TRUE if at least one window requested more
1116 // idle events
1117 event.RequestMore(TRUE);
1118 }
1119
1120 wxIsInOnIdleFlag = FALSE;
1121 }
1122
1123 // Send idle event to all top-level windows
1124 bool wxApp::SendIdleEvents()
1125 {
1126 bool needMore = FALSE;
1127
1128 wxWindowList::Node* node = wxTopLevelWindows.GetFirst();
1129 while (node)
1130 {
1131 wxWindow* win = node->GetData();
1132 if (SendIdleEvents(win))
1133 needMore = TRUE;
1134 node = node->GetNext();
1135 }
1136
1137 return needMore;
1138 }
1139
1140 // Send idle event to window and all subwindows
1141 bool wxApp::SendIdleEvents(wxWindow* win)
1142 {
1143 bool needMore = FALSE;
1144
1145 wxIdleEvent event;
1146 event.SetEventObject(win);
1147 win->GetEventHandler()->ProcessEvent(event);
1148
1149 if (event.MoreRequested())
1150 needMore = TRUE;
1151
1152 wxWindowList::Node* node = win->GetChildren().GetFirst();
1153 while (node)
1154 {
1155 wxWindow* win = node->GetData();
1156 if (SendIdleEvents(win))
1157 needMore = TRUE;
1158
1159 node = node->GetNext();
1160 }
1161 return needMore;
1162 }
1163
1164 void wxApp::DeletePendingObjects()
1165 {
1166 wxNode *node = wxPendingDelete.GetFirst();
1167 while (node)
1168 {
1169 wxObject *obj = node->GetData();
1170
1171 delete obj;
1172
1173 if (wxPendingDelete.Member(obj))
1174 delete node;
1175
1176 // Deleting one object may have deleted other pending
1177 // objects, so start from beginning of list again.
1178 node = wxPendingDelete.GetFirst();
1179 }
1180 }
1181
1182 void wxApp::OnEndSession(wxCloseEvent& WXUNUSED(event))
1183 {
1184 if (GetTopWindow())
1185 GetTopWindow()->Close(TRUE);
1186 }
1187
1188 // Default behaviour: close the application with prompts. The
1189 // user can veto the close, and therefore the end session.
1190 void wxApp::OnQueryEndSession(wxCloseEvent& event)
1191 {
1192 if (GetTopWindow())
1193 {
1194 if (!GetTopWindow()->Close(!event.CanVeto()))
1195 event.Veto(TRUE);
1196 }
1197 }
1198
1199 /* static */
1200 int wxApp::GetComCtl32Version()
1201 {
1202 #ifdef __WXMICROWIN__
1203 return 0;
1204 #else
1205 // cache the result
1206 static int s_verComCtl32 = -1;
1207
1208 wxCRIT_SECT_DECLARE(csComCtl32);
1209 wxCRIT_SECT_LOCKER(lock, csComCtl32);
1210
1211 if ( s_verComCtl32 == -1 )
1212 {
1213 // initally assume no comctl32.dll at all
1214 s_verComCtl32 = 0;
1215
1216 // do we have it?
1217 HMODULE hModuleComCtl32 = ::GetModuleHandle(wxT("COMCTL32"));
1218
1219 // if so, then we can check for the version
1220 if ( hModuleComCtl32 )
1221 {
1222 // try to use DllGetVersion() if available in _headers_
1223 #ifdef DLLVER_PLATFORM_WINDOWS // defined in shlwapi.h
1224 DLLGETVERSIONPROC pfnDllGetVersion = (DLLGETVERSIONPROC)
1225 ::GetProcAddress(hModuleComCtl32, "DllGetVersion");
1226 if ( pfnDllGetVersion )
1227 {
1228 DLLVERSIONINFO dvi;
1229 dvi.cbSize = sizeof(dvi);
1230
1231 HRESULT hr = (*pfnDllGetVersion)(&dvi);
1232 if ( FAILED(hr) )
1233 {
1234 wxLogApiError(_T("DllGetVersion"), hr);
1235 }
1236 else
1237 {
1238 // this is incompatible with _WIN32_IE values, but
1239 // compatible with the other values returned by
1240 // GetComCtl32Version()
1241 s_verComCtl32 = 100*dvi.dwMajorVersion +
1242 dvi.dwMinorVersion;
1243 }
1244 }
1245 #endif
1246 // DllGetVersion() unavailable either during compile or
1247 // run-time, try to guess the version otherwise
1248 if ( !s_verComCtl32 )
1249 {
1250 // InitCommonControlsEx is unique to 4.70 and later
1251 FARPROC theProc = ::GetProcAddress
1252 (
1253 hModuleComCtl32,
1254 "InitCommonControlsEx"
1255 );
1256
1257 if ( !theProc )
1258 {
1259 // not found, must be 4.00
1260 s_verComCtl32 = 400;
1261 }
1262 else
1263 {
1264 // many symbols appeared in comctl32 4.71, could use
1265 // any of them except may be DllInstall
1266 theProc = ::GetProcAddress
1267 (
1268 hModuleComCtl32,
1269 "InitializeFlatSB"
1270 );
1271 if ( !theProc )
1272 {
1273 // not found, must be 4.70
1274 s_verComCtl32 = 470;
1275 }
1276 else
1277 {
1278 // found, must be 4.71
1279 s_verComCtl32 = 471;
1280 }
1281 }
1282 }
1283 }
1284 }
1285
1286 return s_verComCtl32;
1287 #endif
1288 }
1289
1290 void wxExit()
1291 {
1292 wxLogError(_("Fatal error: exiting"));
1293
1294 wxApp::CleanUp();
1295 exit(0);
1296 }
1297
1298 // Yield to incoming messages
1299
1300 bool wxApp::Yield(bool onlyIfNeeded)
1301 {
1302 // MT-FIXME
1303 static bool s_inYield = FALSE;
1304
1305 #if wxUSE_LOG
1306 // disable log flushing from here because a call to wxYield() shouldn't
1307 // normally result in message boxes popping up &c
1308 wxLog::Suspend();
1309 #endif // wxUSE_LOG
1310
1311 if ( s_inYield )
1312 {
1313 if ( !onlyIfNeeded )
1314 {
1315 wxFAIL_MSG( wxT("wxYield called recursively" ) );
1316 }
1317
1318 return FALSE;
1319 }
1320
1321 s_inYield = TRUE;
1322
1323 // we don't want to process WM_QUIT from here - it should be processed in
1324 // the main event loop in order to stop it
1325 MSG msg;
1326 while ( PeekMessage(&msg, (HWND)0, 0, 0, PM_NOREMOVE) &&
1327 msg.message != WM_QUIT )
1328 {
1329 #if wxUSE_THREADS
1330 wxMutexGuiLeaveOrEnter();
1331 #endif // wxUSE_THREADS
1332
1333 if ( !wxTheApp->DoMessage() )
1334 break;
1335 }
1336
1337 // if there are pending events, we must process them.
1338 ProcessPendingEvents();
1339
1340 #if wxUSE_LOG
1341 // let the logs be flashed again
1342 wxLog::Resume();
1343 #endif // wxUSE_LOG
1344
1345 s_inYield = FALSE;
1346
1347 return TRUE;
1348 }
1349
1350 bool wxHandleFatalExceptions(bool doit)
1351 {
1352 #if wxUSE_ON_FATAL_EXCEPTION
1353 // assume this can only be called from the main thread
1354 gs_handleExceptions = doit;
1355
1356 return TRUE;
1357 #else
1358 wxFAIL_MSG(_T("set wxUSE_ON_FATAL_EXCEPTION to 1 to use this function"));
1359
1360 (void)doit;
1361 return FALSE;
1362 #endif
1363 }
1364
1365 //-----------------------------------------------------------------------------
1366 // wxWakeUpIdle
1367 //-----------------------------------------------------------------------------
1368
1369 void wxWakeUpIdle()
1370 {
1371 // Send the top window a dummy message so idle handler processing will
1372 // start up again. Doing it this way ensures that the idle handler
1373 // wakes up in the right thread (see also wxWakeUpMainThread() which does
1374 // the same for the main app thread only)
1375 wxWindow *topWindow = wxTheApp->GetTopWindow();
1376 if ( topWindow )
1377 {
1378 if ( !::PostMessage(GetHwndOf(topWindow), WM_NULL, 0, 0) )
1379 {
1380 // should never happen
1381 wxLogLastError(wxT("PostMessage(WM_NULL)"));
1382 }
1383 }
1384 }
1385
1386 //-----------------------------------------------------------------------------
1387
1388 // For some reason, with MSVC++ 1.5, WinMain isn't linked in properly
1389 // if in a separate file. So include it here to ensure it's linked.
1390 #if (defined(__VISUALC__) && !defined(__WIN32__)) || (defined(__GNUWIN32__) && !defined(__WINE__) && !defined(__TWIN32__) && !defined(WXMAKINGDLL))
1391 #include "main.cpp"
1392 #endif