/[pcsx2_0.9.7]/branch/r3113_0.9.7_beta/3rdparty/wxWidgets/src/msw/app.cpp
ViewVC logotype

Contents of /branch/r3113_0.9.7_beta/3rdparty/wxWidgets/src/msw/app.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 32 - (show annotations) (download)
Tue Sep 7 03:29:01 2010 UTC (9 years, 11 months ago) by william
File size: 24510 byte(s)
branching from upstream revision (http://pcsx2.googlecode.com/svn/trunk
): r3113 to
https://svn.netsolutions.dnsalias.com/websvn/ps2/pcsx2/pcsx2_0.9.7/branch/r3113_0.9.7_beta
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/app.cpp
3 // Purpose: wxApp
4 // Author: Julian Smart
5 // Modified by:
6 // Created: 04/01/98
7 // RCS-ID: $Id: app.cpp 58750 2009-02-08 10:01:03Z VZ $
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ===========================================================================
13 // declarations
14 // ===========================================================================
15
16 // ---------------------------------------------------------------------------
17 // headers
18 // ---------------------------------------------------------------------------
19
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
22
23 #if defined(__BORLANDC__)
24 #pragma hdrstop
25 #endif
26
27 #ifndef WX_PRECOMP
28 #include "wx/msw/wrapcctl.h"
29 #include "wx/dynarray.h"
30 #include "wx/frame.h"
31 #include "wx/app.h"
32 #include "wx/utils.h"
33 #include "wx/gdicmn.h"
34 #include "wx/pen.h"
35 #include "wx/brush.h"
36 #include "wx/cursor.h"
37 #include "wx/icon.h"
38 #include "wx/palette.h"
39 #include "wx/dc.h"
40 #include "wx/dialog.h"
41 #include "wx/msgdlg.h"
42 #include "wx/intl.h"
43 #include "wx/wxchar.h"
44 #include "wx/log.h"
45 #include "wx/module.h"
46 #endif
47
48 #include "wx/apptrait.h"
49 #include "wx/filename.h"
50 #include "wx/dynlib.h"
51 #include "wx/evtloop.h"
52
53 #include "wx/msw/private.h"
54 #include "wx/msw/ole/oleutils.h"
55
56 #if wxUSE_TOOLTIPS
57 #include "wx/tooltip.h"
58 #endif // wxUSE_TOOLTIPS
59
60 // OLE is used for drag-and-drop, clipboard, OLE Automation..., but some
61 // compilers don't support it (missing headers, libs, ...)
62 #if defined(__GNUWIN32_OLD__) || defined(__SYMANTEC__) || defined(__SALFORDC__)
63 #undef wxUSE_OLE
64
65 #define wxUSE_OLE 0
66 #endif // broken compilers
67
68 #if defined(__POCKETPC__) || defined(__SMARTPHONE__)
69 #include <ole2.h>
70 #include <aygshell.h>
71 #endif
72
73 #if wxUSE_OLE
74 #include <ole2.h>
75 #endif
76
77 #include <string.h>
78 #include <ctype.h>
79
80 // For MB_TASKMODAL
81 #ifdef __WXWINCE__
82 #include "wx/msw/wince/missing.h"
83 #endif
84
85 // instead of including <shlwapi.h> which is not part of the core SDK and not
86 // shipped at all with other compilers, we always define the parts of it we
87 // need here ourselves
88 //
89 // NB: DLLVER_PLATFORM_WINDOWS will be defined if shlwapi.h had been somehow
90 // included already
91 #ifndef DLLVER_PLATFORM_WINDOWS
92 // hopefully we don't need to change packing as DWORDs should be already
93 // correctly aligned
94 struct DLLVERSIONINFO
95 {
96 DWORD cbSize;
97 DWORD dwMajorVersion; // Major version
98 DWORD dwMinorVersion; // Minor version
99 DWORD dwBuildNumber; // Build number
100 DWORD dwPlatformID; // DLLVER_PLATFORM_*
101 };
102
103 typedef HRESULT (CALLBACK* DLLGETVERSIONPROC)(DLLVERSIONINFO *);
104 #endif // defined(DLLVERSIONINFO)
105
106
107 // ---------------------------------------------------------------------------
108 // global variables
109 // ---------------------------------------------------------------------------
110
111 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
112 extern void wxSetKeyboardHook(bool doIt);
113 #endif
114
115 // NB: all "NoRedraw" classes must have the same names as the "normal" classes
116 // with NR suffix - wxWindow::MSWCreate() supposes this
117 #ifdef __WXWINCE__
118 WXDLLIMPEXP_CORE wxChar *wxCanvasClassName;
119 WXDLLIMPEXP_CORE wxChar *wxCanvasClassNameNR;
120 #else
121 WXDLLIMPEXP_CORE const wxChar *wxCanvasClassName = wxT("wxWindowClass");
122 WXDLLIMPEXP_CORE const wxChar *wxCanvasClassNameNR = wxT("wxWindowClassNR");
123 #endif
124 WXDLLIMPEXP_CORE const wxChar *wxMDIFrameClassName = wxT("wxMDIFrameClass");
125 WXDLLIMPEXP_CORE const wxChar *wxMDIFrameClassNameNoRedraw = wxT("wxMDIFrameClassNR");
126 WXDLLIMPEXP_CORE const wxChar *wxMDIChildFrameClassName = wxT("wxMDIChildFrameClass");
127 WXDLLIMPEXP_CORE const wxChar *wxMDIChildFrameClassNameNoRedraw = wxT("wxMDIChildFrameClassNR");
128
129 // ----------------------------------------------------------------------------
130 // private functions
131 // ----------------------------------------------------------------------------
132
133 LRESULT WXDLLEXPORT APIENTRY wxWndProc(HWND, UINT, WPARAM, LPARAM);
134
135 // ===========================================================================
136 // wxGUIAppTraits implementation
137 // ===========================================================================
138
139 // private class which we use to pass parameters from BeforeChildWaitLoop() to
140 // AfterChildWaitLoop()
141 struct ChildWaitLoopData
142 {
143 ChildWaitLoopData(wxWindowDisabler *wd_, wxWindow *winActive_)
144 {
145 wd = wd_;
146 winActive = winActive_;
147 }
148
149 wxWindowDisabler *wd;
150 wxWindow *winActive;
151 };
152
153 void *wxGUIAppTraits::BeforeChildWaitLoop()
154 {
155 /*
156 We use a dirty hack here to disable all application windows (which we
157 must do because otherwise the calls to wxYield() could lead to some very
158 unexpected reentrancies in the users code) but to avoid losing
159 focus/activation entirely when the child process terminates which would
160 happen if we simply disabled everything using wxWindowDisabler. Indeed,
161 remember that Windows will never activate a disabled window and when the
162 last childs window is closed and Windows looks for a window to activate
163 all our windows are still disabled. There is no way to enable them in
164 time because we don't know when the childs windows are going to be
165 closed, so the solution we use here is to keep one special tiny frame
166 enabled all the time. Then when the child terminates it will get
167 activated and when we close it below -- after reenabling all the other
168 windows! -- the previously active window becomes activated again and
169 everything is ok.
170 */
171 wxBeginBusyCursor();
172
173 // first disable all existing windows
174 wxWindowDisabler *wd = new wxWindowDisabler;
175
176 // then create an "invisible" frame: it has minimal size, is positioned
177 // (hopefully) outside the screen and doesn't appear on the taskbar
178 wxWindow *winActive = new wxFrame
179 (
180 wxTheApp->GetTopWindow(),
181 wxID_ANY,
182 wxEmptyString,
183 wxPoint(32600, 32600),
184 wxSize(1, 1),
185 wxDEFAULT_FRAME_STYLE | wxFRAME_NO_TASKBAR
186 );
187 winActive->Show();
188
189 return new ChildWaitLoopData(wd, winActive);
190 }
191
192 void wxGUIAppTraits::AlwaysYield()
193 {
194 wxYield();
195 }
196
197 void wxGUIAppTraits::AfterChildWaitLoop(void *dataOrig)
198 {
199 wxEndBusyCursor();
200
201 ChildWaitLoopData * const data = (ChildWaitLoopData *)dataOrig;
202
203 delete data->wd;
204
205 // finally delete the dummy frame and, as wd has been already destroyed and
206 // the other windows reenabled, the activation is going to return to the
207 // window which had had it before
208 data->winActive->Destroy();
209
210 // also delete the temporary data object itself
211 delete data;
212 }
213
214 bool wxGUIAppTraits::DoMessageFromThreadWait()
215 {
216 // we should return false only if the app should exit, i.e. only if
217 // Dispatch() determines that the main event loop should terminate
218 wxEventLoop *evtLoop = wxEventLoop::GetActive();
219 if ( !evtLoop || !evtLoop->Pending() )
220 {
221 // no events means no quit event
222 return true;
223 }
224
225 return evtLoop->Dispatch();
226 }
227
228 wxPortId wxGUIAppTraits::GetToolkitVersion(int *majVer, int *minVer) const
229 {
230 OSVERSIONINFO info;
231 wxZeroMemory(info);
232
233 // on Windows, the toolkit version is the same of the OS version
234 // as Windows integrates the OS kernel with the GUI toolkit.
235 info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
236 if ( ::GetVersionEx(&info) )
237 {
238 if ( majVer )
239 *majVer = info.dwMajorVersion;
240 if ( minVer )
241 *minVer = info.dwMinorVersion;
242 }
243
244 #if defined(__WXHANDHELD__) || defined(__WXWINCE__)
245 return wxPORT_WINCE;
246 #else
247 return wxPORT_MSW;
248 #endif
249 }
250
251 // ===========================================================================
252 // wxApp implementation
253 // ===========================================================================
254
255 int wxApp::m_nCmdShow = SW_SHOWNORMAL;
256
257 // ---------------------------------------------------------------------------
258 // wxWin macros
259 // ---------------------------------------------------------------------------
260
261 IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
262
263 BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
264 EVT_IDLE(wxApp::OnIdle)
265 EVT_END_SESSION(wxApp::OnEndSession)
266 EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
267 END_EVENT_TABLE()
268
269 // class to ensure that wxAppBase::CleanUp() is called if our Initialize()
270 // fails
271 class wxCallBaseCleanup
272 {
273 public:
274 wxCallBaseCleanup(wxApp *app) : m_app(app) { }
275 ~wxCallBaseCleanup() { if ( m_app ) m_app->wxAppBase::CleanUp(); }
276
277 void Dismiss() { m_app = NULL; }
278
279 private:
280 wxApp *m_app;
281 };
282
283 //// Initialize
284 bool wxApp::Initialize(int& argc, wxChar **argv)
285 {
286 if ( !wxAppBase::Initialize(argc, argv) )
287 return false;
288
289 // ensure that base cleanup is done if we return too early
290 wxCallBaseCleanup callBaseCleanup(this);
291
292 #ifdef __WXWINCE__
293 wxString tmp = GetAppName();
294 tmp += wxT("ClassName");
295 wxCanvasClassName = wxStrdup( tmp.c_str() );
296 tmp += wxT("NR");
297 wxCanvasClassNameNR = wxStrdup( tmp.c_str() );
298 HWND hWnd = FindWindow( wxCanvasClassNameNR, NULL );
299 if (hWnd)
300 {
301 SetForegroundWindow( (HWND)(((DWORD)hWnd)|0x01) );
302 return false;
303 }
304 #endif
305
306 #if !defined(__WXMICROWIN__)
307 InitCommonControls();
308 #endif // !defined(__WXMICROWIN__)
309
310 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
311 SHInitExtraControls();
312 #endif
313
314 #ifndef __WXWINCE__
315 // Don't show a message box if a function such as SHGetFileInfo
316 // fails to find a device.
317 SetErrorMode(SEM_FAILCRITICALERRORS|SEM_NOOPENFILEERRORBOX);
318 #endif
319
320 wxOleInitialize();
321
322 RegisterWindowClasses();
323
324 wxWinHandleHash = new wxWinHashTable(wxKEY_INTEGER, 100);
325
326 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
327 wxSetKeyboardHook(true);
328 #endif
329
330 callBaseCleanup.Dismiss();
331
332 return true;
333 }
334
335 // ---------------------------------------------------------------------------
336 // RegisterWindowClasses
337 // ---------------------------------------------------------------------------
338
339 // TODO we should only register classes really used by the app. For this it
340 // would be enough to just delay the class registration until an attempt
341 // to create a window of this class is made.
342 bool wxApp::RegisterWindowClasses()
343 {
344 WNDCLASS wndclass;
345 wxZeroMemory(wndclass);
346
347 // for each class we register one with CS_(V|H)REDRAW style and one
348 // without for windows created with wxNO_FULL_REDRAW_ON_REPAINT flag
349 static const long styleNormal = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
350 static const long styleNoRedraw = CS_DBLCLKS;
351
352 // the fields which are common to all classes
353 wndclass.lpfnWndProc = (WNDPROC)wxWndProc;
354 wndclass.hInstance = wxhInstance;
355 wndclass.hCursor = ::LoadCursor((HINSTANCE)NULL, IDC_ARROW);
356
357 // register the class for all normal windows
358 wndclass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
359 wndclass.lpszClassName = wxCanvasClassName;
360 wndclass.style = styleNormal;
361
362 if ( !RegisterClass(&wndclass) )
363 {
364 wxLogLastError(wxT("RegisterClass(frame)"));
365 }
366
367 // "no redraw" frame
368 wndclass.lpszClassName = wxCanvasClassNameNR;
369 wndclass.style = styleNoRedraw;
370
371 if ( !RegisterClass(&wndclass) )
372 {
373 wxLogLastError(wxT("RegisterClass(no redraw frame)"));
374 }
375
376 // Register the MDI frame window class.
377 wndclass.hbrBackground = (HBRUSH)NULL; // paint MDI frame ourselves
378 wndclass.lpszClassName = wxMDIFrameClassName;
379 wndclass.style = styleNormal;
380
381 if ( !RegisterClass(&wndclass) )
382 {
383 wxLogLastError(wxT("RegisterClass(MDI parent)"));
384 }
385
386 // "no redraw" MDI frame
387 wndclass.lpszClassName = wxMDIFrameClassNameNoRedraw;
388 wndclass.style = styleNoRedraw;
389
390 if ( !RegisterClass(&wndclass) )
391 {
392 wxLogLastError(wxT("RegisterClass(no redraw MDI parent frame)"));
393 }
394
395 // Register the MDI child frame window class.
396 wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
397 wndclass.lpszClassName = wxMDIChildFrameClassName;
398 wndclass.style = styleNormal;
399
400 if ( !RegisterClass(&wndclass) )
401 {
402 wxLogLastError(wxT("RegisterClass(MDI child)"));
403 }
404
405 // "no redraw" MDI child frame
406 wndclass.lpszClassName = wxMDIChildFrameClassNameNoRedraw;
407 wndclass.style = styleNoRedraw;
408
409 if ( !RegisterClass(&wndclass) )
410 {
411 wxLogLastError(wxT("RegisterClass(no redraw MDI child)"));
412 }
413
414 return true;
415 }
416
417 // ---------------------------------------------------------------------------
418 // UnregisterWindowClasses
419 // ---------------------------------------------------------------------------
420
421 bool wxApp::UnregisterWindowClasses()
422 {
423 bool retval = true;
424
425 #ifndef __WXMICROWIN__
426 // MDI frame window class.
427 if ( !::UnregisterClass(wxMDIFrameClassName, wxhInstance) )
428 {
429 wxLogLastError(wxT("UnregisterClass(MDI parent)"));
430
431 retval = false;
432 }
433
434 // "no redraw" MDI frame
435 if ( !::UnregisterClass(wxMDIFrameClassNameNoRedraw, wxhInstance) )
436 {
437 wxLogLastError(wxT("UnregisterClass(no redraw MDI parent frame)"));
438
439 retval = false;
440 }
441
442 // MDI child frame window class.
443 if ( !::UnregisterClass(wxMDIChildFrameClassName, wxhInstance) )
444 {
445 wxLogLastError(wxT("UnregisterClass(MDI child)"));
446
447 retval = false;
448 }
449
450 // "no redraw" MDI child frame
451 if ( !::UnregisterClass(wxMDIChildFrameClassNameNoRedraw, wxhInstance) )
452 {
453 wxLogLastError(wxT("UnregisterClass(no redraw MDI child)"));
454
455 retval = false;
456 }
457
458 // canvas class name
459 if ( !::UnregisterClass(wxCanvasClassName, wxhInstance) )
460 {
461 wxLogLastError(wxT("UnregisterClass(canvas)"));
462
463 retval = false;
464 }
465
466 if ( !::UnregisterClass(wxCanvasClassNameNR, wxhInstance) )
467 {
468 wxLogLastError(wxT("UnregisterClass(no redraw canvas)"));
469
470 retval = false;
471 }
472 #endif // __WXMICROWIN__
473
474 return retval;
475 }
476
477 void wxApp::CleanUp()
478 {
479 // all objects pending for deletion must be deleted first, otherwise we
480 // would crash when they use wxWinHandleHash (and UnregisterWindowClasses()
481 // call wouldn't succeed as long as any windows still exist), so call the
482 // base class method first and only then do our clean up
483 wxAppBase::CleanUp();
484
485 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
486 wxSetKeyboardHook(false);
487 #endif
488
489 wxOleUninitialize();
490
491 // for an EXE the classes are unregistered when it terminates but DLL may
492 // be loaded several times (load/unload/load) into the same process in
493 // which case the registration will fail after the first time if we don't
494 // unregister the classes now
495 UnregisterWindowClasses();
496
497 delete wxWinHandleHash;
498 wxWinHandleHash = NULL;
499
500 #ifdef __WXWINCE__
501 free( wxCanvasClassName );
502 free( wxCanvasClassNameNR );
503 #endif
504 }
505
506 // ----------------------------------------------------------------------------
507 // wxApp ctor/dtor
508 // ----------------------------------------------------------------------------
509
510 wxApp::wxApp()
511 {
512 m_printMode = wxPRINT_WINDOWS;
513 }
514
515 wxApp::~wxApp()
516 {
517 }
518
519 // ----------------------------------------------------------------------------
520 // wxApp idle handling
521 // ----------------------------------------------------------------------------
522
523 void wxApp::OnIdle(wxIdleEvent& event)
524 {
525 wxAppBase::OnIdle(event);
526
527 #if wxUSE_DC_CACHEING
528 // automated DC cache management: clear the cached DCs and bitmap
529 // if it's likely that the app has finished with them, that is, we
530 // get an idle event and we're not dragging anything.
531 if (!::GetKeyState(MK_LBUTTON) && !::GetKeyState(MK_MBUTTON) && !::GetKeyState(MK_RBUTTON))
532 wxDC::ClearCache();
533 #endif // wxUSE_DC_CACHEING
534 }
535
536 void wxApp::WakeUpIdle()
537 {
538 // Send the top window a dummy message so idle handler processing will
539 // start up again. Doing it this way ensures that the idle handler
540 // wakes up in the right thread (see also wxWakeUpMainThread() which does
541 // the same for the main app thread only)
542 wxWindow * const topWindow = wxTheApp->GetTopWindow();
543 if ( topWindow )
544 {
545 HWND hwndTop = GetHwndOf(topWindow);
546
547 // Do not post WM_NULL if there's already a pending WM_NULL to avoid
548 // overflowing the message queue.
549 //
550 // Notice that due to a limitation of PeekMessage() API (which handles
551 // 0,0 range specially), we have to check the range from 0-1 instead.
552 // This still makes it possible to overflow the queue with WM_NULLs by
553 // interspersing the calles to WakeUpIdle() with windows creation but
554 // it should be rather hard to do it accidentally.
555 MSG msg;
556 if ( !::PeekMessage(&msg, hwndTop, 0, 1, PM_NOREMOVE) ||
557 ::PeekMessage(&msg, hwndTop, 1, 1, PM_NOREMOVE) )
558 {
559 if ( !::PostMessage(hwndTop, WM_NULL, 0, 0) )
560 {
561 // should never happen
562 wxLogLastError(wxT("PostMessage(WM_NULL)"));
563 }
564 }
565 }
566 }
567
568 // ----------------------------------------------------------------------------
569 // other wxApp event hanlders
570 // ----------------------------------------------------------------------------
571
572 void wxApp::OnEndSession(wxCloseEvent& WXUNUSED(event))
573 {
574 if (GetTopWindow())
575 GetTopWindow()->Close(true);
576 }
577
578 // Default behaviour: close the application with prompts. The
579 // user can veto the close, and therefore the end session.
580 void wxApp::OnQueryEndSession(wxCloseEvent& event)
581 {
582 if (GetTopWindow())
583 {
584 if (!GetTopWindow()->Close(!event.CanVeto()))
585 event.Veto(true);
586 }
587 }
588
589 // ----------------------------------------------------------------------------
590 // miscellaneous
591 // ----------------------------------------------------------------------------
592
593 /* static */
594 int wxApp::GetComCtl32Version()
595 {
596 #if defined(__WXMICROWIN__) || defined(__WXWINCE__)
597 return 0;
598 #else
599 // cache the result
600 //
601 // NB: this is MT-ok as in the worst case we'd compute s_verComCtl32 twice,
602 // but as its value should be the same both times it doesn't matter
603 static int s_verComCtl32 = -1;
604
605 if ( s_verComCtl32 == -1 )
606 {
607 // initally assume no comctl32.dll at all
608 s_verComCtl32 = 0;
609
610 // we're prepared to handle the errors
611 wxLogNull noLog;
612
613 #if wxUSE_DYNLIB_CLASS
614 // we don't want to load comctl32.dll, it should be already loaded but,
615 // depending on the OS version and the presence of the manifest, it can
616 // be either v5 or v6 and instead of trying to guess it just get the
617 // handle of the already loaded version
618 wxLoadedDLL dllComCtl32(_T("comctl32.dll"));
619 if ( !dllComCtl32.IsLoaded() )
620 {
621 s_verComCtl32 = 0;
622 return 0;
623 }
624
625 // if so, then we can check for the version
626 if ( dllComCtl32.IsLoaded() )
627 {
628 // now check if the function is available during run-time
629 wxDYNLIB_FUNCTION( DLLGETVERSIONPROC, DllGetVersion, dllComCtl32 );
630 if ( pfnDllGetVersion )
631 {
632 DLLVERSIONINFO dvi;
633 dvi.cbSize = sizeof(dvi);
634
635 HRESULT hr = (*pfnDllGetVersion)(&dvi);
636 if ( FAILED(hr) )
637 {
638 wxLogApiError(_T("DllGetVersion"), hr);
639 }
640 else
641 {
642 // this is incompatible with _WIN32_IE values, but
643 // compatible with the other values returned by
644 // GetComCtl32Version()
645 s_verComCtl32 = 100*dvi.dwMajorVersion +
646 dvi.dwMinorVersion;
647 }
648 }
649
650 // if DllGetVersion() is unavailable either during compile or
651 // run-time, try to guess the version otherwise
652 if ( !s_verComCtl32 )
653 {
654 // InitCommonControlsEx is unique to 4.70 and later
655 void *pfn = dllComCtl32.GetSymbol(_T("InitCommonControlsEx"));
656 if ( !pfn )
657 {
658 // not found, must be 4.00
659 s_verComCtl32 = 400;
660 }
661 else // 4.70+
662 {
663 // many symbols appeared in comctl32 4.71, could use any of
664 // them except may be DllInstall()
665 pfn = dllComCtl32.GetSymbol(_T("InitializeFlatSB"));
666 if ( !pfn )
667 {
668 // not found, must be 4.70
669 s_verComCtl32 = 470;
670 }
671 else
672 {
673 // found, must be 4.71 or later
674 s_verComCtl32 = 471;
675 }
676 }
677 }
678 }
679 #endif // wxUSE_DYNLIB_CLASS
680 }
681
682 return s_verComCtl32;
683 #endif // Microwin/!Microwin
684 }
685
686 // Yield to incoming messages
687
688 bool wxApp::Yield(bool onlyIfNeeded)
689 {
690 // MT-FIXME
691 static bool s_inYield = false;
692
693 if ( s_inYield )
694 {
695 if ( !onlyIfNeeded )
696 {
697 wxFAIL_MSG( wxT("wxYield called recursively" ) );
698 }
699
700 return false;
701 }
702
703 #if wxUSE_LOG
704 // disable log flushing from here because a call to wxYield() shouldn't
705 // normally result in message boxes popping up &c
706 wxLog::Suspend();
707 #endif // wxUSE_LOG
708
709 s_inYield = true;
710
711 // we don't want to process WM_QUIT from here - it should be processed in
712 // the main event loop in order to stop it
713 wxEventLoopGuarantor dummyLoopIfNeeded;
714 MSG msg;
715 while ( PeekMessage(&msg, (HWND)0, 0, 0, PM_NOREMOVE) &&
716 msg.message != WM_QUIT )
717 {
718 #if wxUSE_THREADS
719 wxMutexGuiLeaveOrEnter();
720 #endif // wxUSE_THREADS
721
722 if ( !wxTheApp->Dispatch() )
723 break;
724 }
725
726 // if there are pending events, we must process them.
727 ProcessPendingEvents();
728
729 #if wxUSE_LOG
730 // let the logs be flashed again
731 wxLog::Resume();
732 #endif // wxUSE_LOG
733
734 s_inYield = false;
735
736 return true;
737 }
738
739 #if wxUSE_EXCEPTIONS
740
741 // ----------------------------------------------------------------------------
742 // exception handling
743 // ----------------------------------------------------------------------------
744
745 bool wxApp::OnExceptionInMainLoop()
746 {
747 // ask the user about what to do: use the Win32 API function here as it
748 // could be dangerous to use any wxWidgets code in this state
749 switch (
750 ::MessageBox
751 (
752 NULL,
753 _T("An unhandled exception occurred. Press \"Abort\" to \
754 terminate the program,\r\n\
755 \"Retry\" to exit the program normally and \"Ignore\" to try to continue."),
756 _T("Unhandled exception"),
757 MB_ABORTRETRYIGNORE |
758 MB_ICONERROR|
759 MB_TASKMODAL
760 )
761 )
762 {
763 case IDABORT:
764 throw;
765
766 default:
767 wxFAIL_MSG( _T("unexpected MessageBox() return code") );
768 // fall through
769
770 case IDRETRY:
771 return false;
772
773 case IDIGNORE:
774 return true;
775 }
776 }
777
778 #endif // wxUSE_EXCEPTIONS
779
780 // ----------------------------------------------------------------------------
781 // deprecated event loop functions
782 // ----------------------------------------------------------------------------
783
784 #if WXWIN_COMPATIBILITY_2_4
785
786 void wxApp::DoMessage(WXMSG *pMsg)
787 {
788 wxEventLoop *evtLoop = wxEventLoop::GetActive();
789 if ( evtLoop )
790 evtLoop->ProcessMessage(pMsg);
791 }
792
793 bool wxApp::DoMessage()
794 {
795 wxEventLoop *evtLoop = wxEventLoop::GetActive();
796 return evtLoop ? evtLoop->Dispatch() : false;
797 }
798
799 bool wxApp::ProcessMessage(WXMSG* pMsg)
800 {
801 wxEventLoop *evtLoop = wxEventLoop::GetActive();
802 return evtLoop && evtLoop->PreProcessMessage(pMsg);
803 }
804
805 #endif // WXWIN_COMPATIBILITY_2_4

  ViewVC Help
Powered by ViewVC 1.1.22