]> git.saurik.com Git - wxWidgets.git/blob - src/msw/app.cpp
projects / wxWidgets.git / blob
? search:


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