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