]> git.saurik.com Git - wxWidgets.git/blob - src/msw/app.cpp
Made the various logical 2 device transforms consistent with what's drawn on all...
[wxWidgets.git] / src / msw / app.cpp
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$
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/crt.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 #include "wx/thread.h"
53
54 #include "wx/msw/private.h"
55 #include "wx/msw/dc.h"
56 #include "wx/msw/ole/oleutils.h"
57 #include "wx/msw/private/timer.h"
58
59 #if wxUSE_TOOLTIPS
60 #include "wx/tooltip.h"
61 #endif // wxUSE_TOOLTIPS
62
63 // OLE is used for drag-and-drop, clipboard, OLE Automation..., but some
64 // compilers don't support it (missing headers, libs, ...)
65 #if defined(__GNUWIN32_OLD__) || defined(__SYMANTEC__)
66 #undef wxUSE_OLE
67
68 #define wxUSE_OLE 0
69 #endif // broken compilers
70
71 #if defined(__POCKETPC__) || defined(__SMARTPHONE__)
72 #include <ole2.h>
73 #include <aygshell.h>
74 #endif
75
76 #if wxUSE_OLE
77 #include <ole2.h>
78 #endif
79
80 #include <string.h>
81 #include <ctype.h>
82
83 #include "wx/msw/missing.h"
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 = NULL;
122 WXDLLIMPEXP_CORE const wxChar *wxCanvasClassNameNR = NULL;
123 #endif
124 WXDLLIMPEXP_CORE const wxChar *wxMDIFrameClassName = NULL;
125 WXDLLIMPEXP_CORE const wxChar *wxMDIFrameClassNameNoRedraw = NULL;
126 WXDLLIMPEXP_CORE const wxChar *wxMDIChildFrameClassName = NULL;
127 WXDLLIMPEXP_CORE const wxChar *wxMDIChildFrameClassNameNoRedraw = NULL;
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 wxEventLoopBase * const 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 DWORD wxGUIAppTraits::WaitForThread(WXHANDLE hThread)
229 {
230 // if we don't have a running event loop, we shouldn't wait for the
231 // messages as we never remove them from the message queue and so we enter
232 // an infinite loop as MsgWaitForMultipleObjects() keeps returning
233 // WAIT_OBJECT_0 + 1
234 if ( !wxEventLoop::GetActive() )
235 return DoSimpleWaitForThread(hThread);
236
237 return ::MsgWaitForMultipleObjects
238 (
239 1, // number of objects to wait for
240 (HANDLE *)&hThread, // the objects
241 false, // wait for any objects, not all
242 INFINITE, // no timeout
243 QS_ALLINPUT | // return as soon as there are any events
244 QS_ALLPOSTMESSAGE
245 );
246 }
247
248 wxPortId wxGUIAppTraits::GetToolkitVersion(int *majVer, int *minVer) const
249 {
250 OSVERSIONINFO info;
251 wxZeroMemory(info);
252
253 // on Windows, the toolkit version is the same of the OS version
254 // as Windows integrates the OS kernel with the GUI toolkit.
255 info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
256 if ( ::GetVersionEx(&info) )
257 {
258 if ( majVer )
259 *majVer = info.dwMajorVersion;
260 if ( minVer )
261 *minVer = info.dwMinorVersion;
262 }
263
264 #if defined(__WXHANDHELD__) || defined(__WXWINCE__)
265 return wxPORT_WINCE;
266 #else
267 return wxPORT_MSW;
268 #endif
269 }
270
271 #if wxUSE_TIMER
272
273 wxTimerImpl *wxGUIAppTraits::CreateTimerImpl(wxTimer *timer)
274 {
275 return new wxMSWTimerImpl(timer);
276 }
277
278 #endif // wxUSE_TIMER
279
280 wxEventLoopBase* wxGUIAppTraits::CreateEventLoop()
281 {
282 return new wxEventLoop;
283 }
284
285 // ===========================================================================
286 // wxApp implementation
287 // ===========================================================================
288
289 int wxApp::m_nCmdShow = SW_SHOWNORMAL;
290
291 // ---------------------------------------------------------------------------
292 // wxWin macros
293 // ---------------------------------------------------------------------------
294
295 IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
296
297 BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
298 EVT_IDLE(wxApp::OnIdle)
299 EVT_END_SESSION(wxApp::OnEndSession)
300 EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
301 END_EVENT_TABLE()
302
303 // class to ensure that wxAppBase::CleanUp() is called if our Initialize()
304 // fails
305 class wxCallBaseCleanup
306 {
307 public:
308 wxCallBaseCleanup(wxApp *app) : m_app(app) { }
309 ~wxCallBaseCleanup() { if ( m_app ) m_app->wxAppBase::CleanUp(); }
310
311 void Dismiss() { m_app = NULL; }
312
313 private:
314 wxApp *m_app;
315 };
316
317 //// Initialize
318 bool wxApp::Initialize(int& argc, wxChar **argv)
319 {
320 if ( !wxAppBase::Initialize(argc, argv) )
321 return false;
322
323 // ensure that base cleanup is done if we return too early
324 wxCallBaseCleanup callBaseCleanup(this);
325
326 #ifdef __WXWINCE__
327 wxString tmp = GetAppName();
328 tmp += wxT("ClassName");
329 wxCanvasClassName = wxStrdup( tmp.wc_str() );
330 tmp += wxT("NR");
331 wxCanvasClassNameNR = wxStrdup( tmp.wc_str() );
332 HWND hWnd = FindWindow( wxCanvasClassNameNR, NULL );
333 if (hWnd)
334 {
335 SetForegroundWindow( (HWND)(((DWORD)hWnd)|0x01) );
336 return false;
337 }
338 #endif
339
340 #if !defined(__WXMICROWIN__)
341 InitCommonControls();
342 #endif // !defined(__WXMICROWIN__)
343
344 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
345 SHInitExtraControls();
346 #endif
347
348 #ifndef __WXWINCE__
349 // Don't show a message box if a function such as SHGetFileInfo
350 // fails to find a device.
351 SetErrorMode(SEM_FAILCRITICALERRORS|SEM_NOOPENFILEERRORBOX);
352 #endif
353
354 wxOleInitialize();
355
356 RegisterWindowClasses();
357
358 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
359 wxSetKeyboardHook(true);
360 #endif
361
362 callBaseCleanup.Dismiss();
363
364 return true;
365 }
366
367 // ---------------------------------------------------------------------------
368 // RegisterWindowClasses
369 // ---------------------------------------------------------------------------
370
371 // This function registers the given class name and stores a pointer to a
372 // heap-allocated copy of it at the specified location, it must be deleted
373 // later.
374 static void RegisterAndStoreClassName(const wxString& uniqueClassName,
375 const wxChar **className,
376 WNDCLASS *lpWndClass)
377 {
378 const size_t length = uniqueClassName.length() + 1; // for trailing NUL
379 wxChar *newChars = new wxChar[length];
380 wxStrncpy(newChars, uniqueClassName, length);
381 *className = newChars;
382 lpWndClass->lpszClassName = *className;
383
384 if ( !::RegisterClass(lpWndClass) )
385 {
386 wxLogLastError(wxString::Format(wxT("RegisterClass(%s)"), newChars));
387 }
388 }
389
390 // This function registers the class defined by the provided WNDCLASS struct
391 // contents using a unique name constructed from the specified base name and
392 // and a suffix unique to this library instance. It also stores the generated
393 // unique names for normal and "no redraw" versions of the class in the
394 // provided variables, caller must delete their contents later.
395 static void RegisterClassWithUniqueNames(const wxString& baseName,
396 const wxChar **className,
397 const wxChar **classNameNR,
398 WNDCLASS *lpWndClass)
399 {
400 // for each class we register one with CS_(V|H)REDRAW style and one
401 // without for windows created with wxNO_FULL_REDRAW_ON_REPAINT flag
402 static const long styleNormal = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
403 static const long styleNoRedraw = CS_DBLCLKS;
404
405 const wxString uniqueSuffix(wxString::Format(wxT("@%p"), className));
406
407 wxString uniqueClassName(baseName + uniqueSuffix);
408 lpWndClass->style = styleNormal;
409 RegisterAndStoreClassName(uniqueClassName, className, lpWndClass);
410
411 // NB: remember that code elsewhere supposes that no redraw class names
412 // use the same names as normal classes with "NR" suffix so we must put
413 // "NR" at the end instead of using more natural baseName+"NR"+suffix
414 wxString uniqueClassNameNR(uniqueClassName + wxT("NR"));
415 lpWndClass->style = styleNoRedraw;
416 RegisterAndStoreClassName(uniqueClassNameNR, classNameNR, lpWndClass);
417 }
418
419 // TODO we should only register classes really used by the app. For this it
420 // would be enough to just delay the class registration until an attempt
421 // to create a window of this class is made.
422 bool wxApp::RegisterWindowClasses()
423 {
424 WNDCLASS wndclass;
425 wxZeroMemory(wndclass);
426
427 // the fields which are common to all classes
428 wndclass.lpfnWndProc = (WNDPROC)wxWndProc;
429 wndclass.hInstance = wxhInstance;
430 wndclass.hCursor = ::LoadCursor((HINSTANCE)NULL, IDC_ARROW);
431
432 // register the class for all normal windows and "no redraw" frames
433 wndclass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
434 RegisterClassWithUniqueNames(wxT("wxWindowClass"),
435 &wxCanvasClassName,
436 &wxCanvasClassNameNR,
437 &wndclass);
438
439 // Register the MDI frame window class and "no redraw" MDI frame
440 wndclass.hbrBackground = (HBRUSH)NULL; // paint MDI frame ourselves
441 RegisterClassWithUniqueNames(wxT("wxMDIFrameClass"),
442 &wxMDIFrameClassName,
443 &wxMDIFrameClassNameNoRedraw,
444 &wndclass);
445
446 // Register the MDI child frame window class and "no redraw" MDI child frame
447 wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
448 RegisterClassWithUniqueNames(wxT("wxMDIChildFrameClass"),
449 &wxMDIChildFrameClassName,
450 &wxMDIChildFrameClassNameNoRedraw,
451 &wndclass);
452
453 return true;
454 }
455
456 // ---------------------------------------------------------------------------
457 // UnregisterWindowClasses
458 // ---------------------------------------------------------------------------
459
460 // This function unregisters the class with the given name and frees memory
461 // allocated for it by RegisterAndStoreClassName().
462 static bool UnregisterAndFreeClassName(const wxChar **ppClassName)
463 {
464 bool retval = true;
465
466 if ( !::UnregisterClass(*ppClassName, wxhInstance) )
467 {
468 wxLogLastError(
469 wxString::Format(wxT("UnregisterClass(%s)"), *ppClassName));
470
471 retval = false;
472 }
473
474 delete [] (wxChar*) *ppClassName;
475 *ppClassName = NULL;
476
477 return retval;
478 }
479
480 bool wxApp::UnregisterWindowClasses()
481 {
482 bool retval = true;
483
484 #ifndef __WXMICROWIN__
485 if ( !UnregisterAndFreeClassName(&wxMDIFrameClassName) )
486 retval = false;
487
488 if ( !UnregisterAndFreeClassName(&wxMDIFrameClassNameNoRedraw) )
489 retval = false;
490
491 if ( !UnregisterAndFreeClassName(&wxMDIChildFrameClassName) )
492 retval = false;
493
494 if ( !UnregisterAndFreeClassName(&wxMDIChildFrameClassNameNoRedraw) )
495 retval = false;
496
497 if ( !UnregisterAndFreeClassName(&wxCanvasClassName) )
498 retval = false;
499
500 if ( !UnregisterAndFreeClassName(&wxCanvasClassNameNR) )
501 retval = false;
502 #endif // __WXMICROWIN__
503
504 return retval;
505 }
506
507 void wxApp::CleanUp()
508 {
509 // all objects pending for deletion must be deleted first, otherwise
510 // UnregisterWindowClasses() call wouldn't succeed (because windows
511 // using the classes being unregistered still exist), so call the base
512 // class method first and only then do our clean up
513 wxAppBase::CleanUp();
514
515 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
516 wxSetKeyboardHook(false);
517 #endif
518
519 wxOleUninitialize();
520
521 // for an EXE the classes are unregistered when it terminates but DLL may
522 // be loaded several times (load/unload/load) into the same process in
523 // which case the registration will fail after the first time if we don't
524 // unregister the classes now
525 UnregisterWindowClasses();
526
527 #ifdef __WXWINCE__
528 free( wxCanvasClassName );
529 free( wxCanvasClassNameNR );
530 #endif
531 }
532
533 // ----------------------------------------------------------------------------
534 // wxApp ctor/dtor
535 // ----------------------------------------------------------------------------
536
537 wxApp::wxApp()
538 {
539 m_printMode = wxPRINT_WINDOWS;
540 }
541
542 wxApp::~wxApp()
543 {
544 }
545
546 // ----------------------------------------------------------------------------
547 // wxApp idle handling
548 // ----------------------------------------------------------------------------
549
550 void wxApp::OnIdle(wxIdleEvent& WXUNUSED(event))
551 {
552 #if wxUSE_DC_CACHEING
553 // automated DC cache management: clear the cached DCs and bitmap
554 // if it's likely that the app has finished with them, that is, we
555 // get an idle event and we're not dragging anything.
556 if (!::GetKeyState(MK_LBUTTON) && !::GetKeyState(MK_MBUTTON) && !::GetKeyState(MK_RBUTTON))
557 wxMSWDCImpl::ClearCache();
558 #endif // wxUSE_DC_CACHEING
559 }
560
561 void wxApp::WakeUpIdle()
562 {
563 // Send the top window a dummy message so idle handler processing will
564 // start up again. Doing it this way ensures that the idle handler
565 // wakes up in the right thread (see also wxWakeUpMainThread() which does
566 // the same for the main app thread only)
567 wxWindow * const topWindow = wxTheApp->GetTopWindow();
568 if ( topWindow )
569 {
570 HWND hwndTop = GetHwndOf(topWindow);
571
572 // Do not post WM_NULL if there's already a pending WM_NULL to avoid
573 // overflowing the message queue.
574 //
575 // Notice that due to a limitation of PeekMessage() API (which handles
576 // 0,0 range specially), we have to check the range from 0-1 instead.
577 // This still makes it possible to overflow the queue with WM_NULLs by
578 // interspersing the calles to WakeUpIdle() with windows creation but
579 // it should be rather hard to do it accidentally.
580 MSG msg;
581 if ( !::PeekMessage(&msg, hwndTop, 0, 1, PM_NOREMOVE) ||
582 ::PeekMessage(&msg, hwndTop, 1, 1, PM_NOREMOVE) )
583 {
584 if ( !::PostMessage(hwndTop, WM_NULL, 0, 0) )
585 {
586 // should never happen
587 wxLogLastError(wxT("PostMessage(WM_NULL)"));
588 }
589 }
590 }
591 }
592
593 // ----------------------------------------------------------------------------
594 // other wxApp event hanlders
595 // ----------------------------------------------------------------------------
596
597 void wxApp::OnEndSession(wxCloseEvent& WXUNUSED(event))
598 {
599 // Windows will terminate the process soon after we return from
600 // WM_ENDSESSION handler or when we delete our last window, so make sure we
601 // at least execute our cleanup code before
602
603 // prevent the window from being destroyed when the corresponding wxTLW is
604 // destroyed: this will result in a leak of a HWND, of course, but who
605 // cares when the process is being killed anyhow
606 if ( !wxTopLevelWindows.empty() )
607 wxTopLevelWindows[0]->SetHWND(0);
608
609 const int rc = OnExit();
610
611 wxEntryCleanup();
612
613 // calling exit() instead of ExitProcess() or not doing anything at all and
614 // being killed by Windows has the advantage of executing the dtors of
615 // global objects
616 exit(rc);
617 }
618
619 // Default behaviour: close the application with prompts. The
620 // user can veto the close, and therefore the end session.
621 void wxApp::OnQueryEndSession(wxCloseEvent& event)
622 {
623 if (GetTopWindow())
624 {
625 if (!GetTopWindow()->Close(!event.CanVeto()))
626 event.Veto(true);
627 }
628 }
629
630 // ----------------------------------------------------------------------------
631 // system DLL versions
632 // ----------------------------------------------------------------------------
633
634 // these functions have trivial inline implementations for CE
635 #ifndef __WXWINCE__
636
637 #if wxUSE_DYNLIB_CLASS
638
639 namespace
640 {
641
642 // helper function: retrieve the DLL version by using DllGetVersion(), returns
643 // 0 if the DLL doesn't export such function
644 int CallDllGetVersion(wxDynamicLibrary& dll)
645 {
646 // now check if the function is available during run-time
647 wxDYNLIB_FUNCTION( DLLGETVERSIONPROC, DllGetVersion, dll );
648 if ( !pfnDllGetVersion )
649 return 0;
650
651 DLLVERSIONINFO dvi;
652 dvi.cbSize = sizeof(dvi);
653
654 HRESULT hr = (*pfnDllGetVersion)(&dvi);
655 if ( FAILED(hr) )
656 {
657 wxLogApiError(_T("DllGetVersion"), hr);
658
659 return 0;
660 }
661
662 return 100*dvi.dwMajorVersion + dvi.dwMinorVersion;
663 }
664
665 } // anonymous namespace
666
667 /* static */
668 int wxApp::GetComCtl32Version()
669 {
670 // cache the result
671 //
672 // NB: this is MT-ok as in the worst case we'd compute s_verComCtl32 twice,
673 // but as its value should be the same both times it doesn't matter
674 static int s_verComCtl32 = -1;
675
676 if ( s_verComCtl32 == -1 )
677 {
678 // we're prepared to handle the errors
679 wxLogNull noLog;
680
681 // the DLL should really be available
682 wxDynamicLibrary dllComCtl32(_T("comctl32.dll"), wxDL_VERBATIM);
683 if ( !dllComCtl32.IsLoaded() )
684 {
685 s_verComCtl32 = 0;
686 return 0;
687 }
688
689 // try DllGetVersion() for recent DLLs
690 s_verComCtl32 = CallDllGetVersion(dllComCtl32);
691
692 // if DllGetVersion() is unavailable either during compile or
693 // run-time, try to guess the version otherwise
694 if ( !s_verComCtl32 )
695 {
696 // InitCommonControlsEx is unique to 4.70 and later
697 void *pfn = dllComCtl32.GetSymbol(_T("InitCommonControlsEx"));
698 if ( !pfn )
699 {
700 // not found, must be 4.00
701 s_verComCtl32 = 400;
702 }
703 else // 4.70+
704 {
705 // many symbols appeared in comctl32 4.71, could use any of
706 // them except may be DllInstall()
707 pfn = dllComCtl32.GetSymbol(_T("InitializeFlatSB"));
708 if ( !pfn )
709 {
710 // not found, must be 4.70
711 s_verComCtl32 = 470;
712 }
713 else
714 {
715 // found, must be 4.71 or later
716 s_verComCtl32 = 471;
717 }
718 }
719 }
720 }
721
722 return s_verComCtl32;
723 }
724
725 /* static */
726 int wxApp::GetShell32Version()
727 {
728 static int s_verShell32 = -1;
729 if ( s_verShell32 == -1 )
730 {
731 // we're prepared to handle the errors
732 wxLogNull noLog;
733
734 wxDynamicLibrary dllShell32(_T("shell32.dll"), wxDL_VERBATIM);
735 if ( dllShell32.IsLoaded() )
736 {
737 s_verShell32 = CallDllGetVersion(dllShell32);
738
739 if ( !s_verShell32 )
740 {
741 // there doesn't seem to be any way to distinguish between 4.00
742 // and 4.70 (starting from 4.71 we have DllGetVersion()) so
743 // just assume it is 4.0
744 s_verShell32 = 400;
745 }
746 }
747 else // failed load the DLL?
748 {
749 s_verShell32 = 0;
750 }
751 }
752
753 return s_verShell32;
754 }
755
756 #else // !wxUSE_DYNLIB_CLASS
757
758 /* static */
759 int wxApp::GetComCtl32Version()
760 {
761 return 0;
762 }
763
764 /* static */
765 int wxApp::GetShell32Version()
766 {
767 return 0;
768 }
769
770 #endif // wxUSE_DYNLIB_CLASS/!wxUSE_DYNLIB_CLASS
771
772 #endif // !__WXWINCE__
773
774 // ----------------------------------------------------------------------------
775 // Yield to incoming messages
776 // ----------------------------------------------------------------------------
777
778 bool wxApp::Yield(bool onlyIfNeeded)
779 {
780 // MT-FIXME
781 static bool s_inYield = false;
782
783 #if wxUSE_LOG
784 // disable log flushing from here because a call to wxYield() shouldn't
785 // normally result in message boxes popping up &c
786 wxLog::Suspend();
787 #endif // wxUSE_LOG
788
789 if ( s_inYield )
790 {
791 if ( !onlyIfNeeded )
792 {
793 wxFAIL_MSG( wxT("wxYield called recursively" ) );
794 }
795
796 return false;
797 }
798
799 s_inYield = true;
800
801 // we don't want to process WM_QUIT from here - it should be processed in
802 // the main event loop in order to stop it
803 wxEventLoopGuarantor dummyLoopIfNeeded;
804 MSG msg;
805 while ( PeekMessage(&msg, (HWND)0, 0, 0, PM_NOREMOVE) &&
806 msg.message != WM_QUIT )
807 {
808 #if wxUSE_THREADS
809 wxMutexGuiLeaveOrEnter();
810 #endif // wxUSE_THREADS
811
812 if ( !wxTheApp->Dispatch() )
813 break;
814 }
815
816 // if there are pending events, we must process them.
817 ProcessPendingEvents();
818
819 #if wxUSE_LOG
820 // let the logs be flashed again
821 wxLog::Resume();
822 #endif // wxUSE_LOG
823
824 s_inYield = false;
825
826 return true;
827 }
828
829 #if wxUSE_EXCEPTIONS
830
831 // ----------------------------------------------------------------------------
832 // exception handling
833 // ----------------------------------------------------------------------------
834
835 bool wxApp::OnExceptionInMainLoop()
836 {
837 // ask the user about what to do: use the Win32 API function here as it
838 // could be dangerous to use any wxWidgets code in this state
839 switch (
840 ::MessageBox
841 (
842 NULL,
843 _T("An unhandled exception occurred. Press \"Abort\" to \
844 terminate the program,\r\n\
845 \"Retry\" to exit the program normally and \"Ignore\" to try to continue."),
846 _T("Unhandled exception"),
847 MB_ABORTRETRYIGNORE |
848 MB_ICONERROR|
849 MB_TASKMODAL
850 )
851 )
852 {
853 case IDABORT:
854 throw;
855
856 default:
857 wxFAIL_MSG( _T("unexpected MessageBox() return code") );
858 // fall through
859
860 case IDRETRY:
861 return false;
862
863 case IDIGNORE:
864 return true;
865 }
866 }
867
868 #endif // wxUSE_EXCEPTIONS