]> git.saurik.com Git - wxWidgets.git/blob - src/msw/app.cpp
No changes, just fix a typo in a variable name.
[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 #include "wx/scopeguard.h"
54 #include "wx/vector.h"
55
56 #include "wx/msw/private.h"
57 #include "wx/msw/dc.h"
58 #include "wx/msw/ole/oleutils.h"
59 #include "wx/msw/private/timer.h"
60
61 #if wxUSE_TOOLTIPS
62 #include "wx/tooltip.h"
63 #endif // wxUSE_TOOLTIPS
64
65 // OLE is used for drag-and-drop, clipboard, OLE Automation..., but some
66 // compilers don't support it (missing headers, libs, ...)
67 #if defined(__GNUWIN32_OLD__) || defined(__SYMANTEC__)
68 #undef wxUSE_OLE
69
70 #define wxUSE_OLE 0
71 #endif // broken compilers
72
73 #if defined(__POCKETPC__) || defined(__SMARTPHONE__)
74 #include <ole2.h>
75 #include <aygshell.h>
76 #endif
77
78 #if wxUSE_OLE
79 #include <ole2.h>
80 #endif
81
82 #include <string.h>
83 #include <ctype.h>
84
85 #include "wx/msw/missing.h"
86
87 // instead of including <shlwapi.h> which is not part of the core SDK and not
88 // shipped at all with other compilers, we always define the parts of it we
89 // need here ourselves
90 //
91 // NB: DLLVER_PLATFORM_WINDOWS will be defined if shlwapi.h had been somehow
92 // included already
93 #ifndef DLLVER_PLATFORM_WINDOWS
94 // hopefully we don't need to change packing as DWORDs should be already
95 // correctly aligned
96 struct DLLVERSIONINFO
97 {
98 DWORD cbSize;
99 DWORD dwMajorVersion; // Major version
100 DWORD dwMinorVersion; // Minor version
101 DWORD dwBuildNumber; // Build number
102 DWORD dwPlatformID; // DLLVER_PLATFORM_*
103 };
104
105 typedef HRESULT (CALLBACK* DLLGETVERSIONPROC)(DLLVERSIONINFO *);
106 #endif // defined(DLLVERSIONINFO)
107
108 #ifndef ATTACH_PARENT_PROCESS
109 #define ATTACH_PARENT_PROCESS ((DWORD)-1)
110 #endif
111
112 // ---------------------------------------------------------------------------
113 // global variables
114 // ---------------------------------------------------------------------------
115
116 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
117 extern void wxSetKeyboardHook(bool doIt);
118 #endif
119
120 // because of mingw32 4.3 bug this struct can't be inside the namespace below:
121 // see http://article.gmane.org/gmane.comp.lib.wxwidgets.devel/110282
122 struct ClassRegInfo
123 {
124 ClassRegInfo(const wxChar *name)
125 : regname(name),
126 regnameNR(regname + wxApp::GetNoRedrawClassSuffix())
127 {
128 }
129
130 // the name of the registered class with and without CS_[HV]REDRAW styles
131 wxString regname;
132 wxString regnameNR;
133 };
134
135 namespace
136 {
137
138 wxVector<ClassRegInfo> gs_regClassesInfo;
139
140 } // anonymous namespace
141
142 // ----------------------------------------------------------------------------
143 // private functions
144 // ----------------------------------------------------------------------------
145
146 LRESULT WXDLLEXPORT APIENTRY wxWndProc(HWND, UINT, WPARAM, LPARAM);
147
148 // ===========================================================================
149 // wxGUIAppTraits implementation
150 // ===========================================================================
151
152 // private class which we use to pass parameters from BeforeChildWaitLoop() to
153 // AfterChildWaitLoop()
154 struct ChildWaitLoopData
155 {
156 ChildWaitLoopData(wxWindowDisabler *wd_, wxWindow *winActive_)
157 {
158 wd = wd_;
159 winActive = winActive_;
160 }
161
162 wxWindowDisabler *wd;
163 wxWindow *winActive;
164 };
165
166 void *wxGUIAppTraits::BeforeChildWaitLoop()
167 {
168 /*
169 We use a dirty hack here to disable all application windows (which we
170 must do because otherwise the calls to wxYield() could lead to some very
171 unexpected reentrancies in the users code) but to avoid losing
172 focus/activation entirely when the child process terminates which would
173 happen if we simply disabled everything using wxWindowDisabler. Indeed,
174 remember that Windows will never activate a disabled window and when the
175 last childs window is closed and Windows looks for a window to activate
176 all our windows are still disabled. There is no way to enable them in
177 time because we don't know when the childs windows are going to be
178 closed, so the solution we use here is to keep one special tiny frame
179 enabled all the time. Then when the child terminates it will get
180 activated and when we close it below -- after reenabling all the other
181 windows! -- the previously active window becomes activated again and
182 everything is ok.
183 */
184 wxBeginBusyCursor();
185
186 // first disable all existing windows
187 wxWindowDisabler *wd = new wxWindowDisabler;
188
189 // then create an "invisible" frame: it has minimal size, is positioned
190 // (hopefully) outside the screen and doesn't appear on the taskbar
191 wxWindow *winActive = new wxFrame
192 (
193 wxTheApp->GetTopWindow(),
194 wxID_ANY,
195 wxEmptyString,
196 wxPoint(32600, 32600),
197 wxSize(1, 1),
198 wxDEFAULT_FRAME_STYLE | wxFRAME_NO_TASKBAR
199 );
200 winActive->Show();
201
202 return new ChildWaitLoopData(wd, winActive);
203 }
204
205 void wxGUIAppTraits::AfterChildWaitLoop(void *dataOrig)
206 {
207 wxEndBusyCursor();
208
209 ChildWaitLoopData * const data = (ChildWaitLoopData *)dataOrig;
210
211 delete data->wd;
212
213 // finally delete the dummy frame and, as wd has been already destroyed and
214 // the other windows reenabled, the activation is going to return to the
215 // window which had had it before
216 data->winActive->Destroy();
217
218 // also delete the temporary data object itself
219 delete data;
220 }
221
222 bool wxGUIAppTraits::DoMessageFromThreadWait()
223 {
224 // we should return false only if the app should exit, i.e. only if
225 // Dispatch() determines that the main event loop should terminate
226 wxEventLoopBase * const evtLoop = wxEventLoop::GetActive();
227 if ( !evtLoop || !evtLoop->Pending() )
228 {
229 // no events means no quit event
230 return true;
231 }
232
233 return evtLoop->Dispatch();
234 }
235
236 DWORD wxGUIAppTraits::WaitForThread(WXHANDLE hThread)
237 {
238 // We only ever dispatch messages from the main thread and, additionally,
239 // even from the main thread we shouldn't wait for the message if we don't
240 // have a running event loop as we would never remove them from the message
241 // queue then and so we would enter an infinite loop as
242 // MsgWaitForMultipleObjects() keeps returning WAIT_OBJECT_0 + 1.
243 if ( !wxIsMainThread() || !wxEventLoop::GetActive() )
244 return DoSimpleWaitForThread(hThread);
245
246 return ::MsgWaitForMultipleObjects
247 (
248 1, // number of objects to wait for
249 (HANDLE *)&hThread, // the objects
250 false, // wait for any objects, not all
251 INFINITE, // no timeout
252 QS_ALLINPUT | // return as soon as there are any events
253 QS_ALLPOSTMESSAGE
254 );
255 }
256
257 wxPortId wxGUIAppTraits::GetToolkitVersion(int *majVer, int *minVer) const
258 {
259 OSVERSIONINFO info;
260 wxZeroMemory(info);
261
262 // on Windows, the toolkit version is the same of the OS version
263 // as Windows integrates the OS kernel with the GUI toolkit.
264 info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
265 if ( ::GetVersionEx(&info) )
266 {
267 if ( majVer )
268 *majVer = info.dwMajorVersion;
269 if ( minVer )
270 *minVer = info.dwMinorVersion;
271 }
272
273 #if defined(__WXHANDHELD__) || defined(__WXWINCE__)
274 return wxPORT_WINCE;
275 #else
276 return wxPORT_MSW;
277 #endif
278 }
279
280 #if wxUSE_TIMER
281
282 wxTimerImpl *wxGUIAppTraits::CreateTimerImpl(wxTimer *timer)
283 {
284 return new wxMSWTimerImpl(timer);
285 }
286
287 #endif // wxUSE_TIMER
288
289 wxEventLoopBase* wxGUIAppTraits::CreateEventLoop()
290 {
291 return new wxEventLoop;
292 }
293
294 // ---------------------------------------------------------------------------
295 // Stuff for using console from the GUI applications
296 // ---------------------------------------------------------------------------
297
298 #ifndef __WXWINCE__
299
300 #if wxUSE_DYNLIB_CLASS
301
302 #include <wx/dynlib.h>
303
304 namespace
305 {
306
307 /*
308 Helper class to manipulate console from a GUI app.
309
310 Notice that console output is available in the GUI app only if:
311 - AttachConsole() returns TRUE (which means it never works under pre-XP)
312 - we have a valid STD_ERROR_HANDLE
313 - command history hasn't been changed since our startup
314
315 To check if all these conditions are verified, you need to simple call
316 IsOkToUse(). It will check the first two conditions above the first time it
317 is called (and if this fails, the subsequent calls will return immediately)
318 and also recheck the last one every time it is called.
319 */
320 class wxConsoleStderr
321 {
322 public:
323 // default ctor does nothing, call Init() before using this class
324 wxConsoleStderr()
325 {
326 m_hStderr = INVALID_HANDLE_VALUE;
327 m_historyLen =
328 m_dataLen =
329 m_dataLine = 0;
330
331 m_ok = -1;
332 }
333
334 ~wxConsoleStderr()
335 {
336 if ( m_hStderr != INVALID_HANDLE_VALUE )
337 {
338 if ( !::FreeConsole() )
339 {
340 wxLogLastError(wxT("FreeConsole"));
341 }
342 }
343 }
344
345 // return true if we were successfully initialized and there had been no
346 // console activity which would interfere with our output since then
347 bool IsOkToUse() const
348 {
349 if ( m_ok == -1 )
350 {
351 wxConsoleStderr * const self = const_cast<wxConsoleStderr *>(this);
352 self->m_ok = self->DoInit();
353
354 // no need to call IsHistoryUnchanged() as we just initialized
355 // m_history anyhow
356 return m_ok == 1;
357 }
358
359 return m_ok && IsHistoryUnchanged();
360 }
361
362
363 // output the provided text on the console, return true if ok
364 bool Write(const wxString& text);
365
366 private:
367 // called by Init() once only to do the real initialization
368 bool DoInit();
369
370 // retrieve the command line history into the provided buffer and return
371 // its length
372 int GetCommandHistory(wxWxCharBuffer& buf) const;
373
374 // check if the console history has changed
375 bool IsHistoryUnchanged() const;
376
377 int m_ok; // initially -1, set to true or false by Init()
378
379 wxDynamicLibrary m_dllKernel32;
380
381 HANDLE m_hStderr; // console handle, if it's valid we must call
382 // FreeConsole() (even if m_ok != 1)
383
384 wxWxCharBuffer m_history; // command history on startup
385 int m_historyLen; // length command history buffer
386
387 wxCharBuffer m_data; // data between empty line and cursor position
388 int m_dataLen; // length data buffer
389 int m_dataLine; // line offset
390
391 typedef DWORD (WINAPI *GetConsoleCommandHistory_t)(LPTSTR sCommands,
392 DWORD nBufferLength,
393 LPCTSTR sExeName);
394 typedef DWORD (WINAPI *GetConsoleCommandHistoryLength_t)(LPCTSTR sExeName);
395
396 GetConsoleCommandHistory_t m_pfnGetConsoleCommandHistory;
397 GetConsoleCommandHistoryLength_t m_pfnGetConsoleCommandHistoryLength;
398
399 wxDECLARE_NO_COPY_CLASS(wxConsoleStderr);
400 };
401
402 bool wxConsoleStderr::DoInit()
403 {
404 HANDLE hStderr = ::GetStdHandle(STD_ERROR_HANDLE);
405
406 if ( hStderr == INVALID_HANDLE_VALUE || !hStderr )
407 return false;
408
409 if ( !m_dllKernel32.Load(wxT("kernel32.dll")) )
410 return false;
411
412 typedef BOOL (WINAPI *AttachConsole_t)(DWORD dwProcessId);
413 AttachConsole_t wxDL_INIT_FUNC(pfn, AttachConsole, m_dllKernel32);
414
415 if ( !pfnAttachConsole || !pfnAttachConsole(ATTACH_PARENT_PROCESS) )
416 return false;
417
418 // console attached, set m_hStderr now to ensure that we free it in the
419 // dtor
420 m_hStderr = hStderr;
421
422 wxDL_INIT_FUNC_AW(m_pfn, GetConsoleCommandHistory, m_dllKernel32);
423 if ( !m_pfnGetConsoleCommandHistory )
424 return false;
425
426 wxDL_INIT_FUNC_AW(m_pfn, GetConsoleCommandHistoryLength, m_dllKernel32);
427 if ( !m_pfnGetConsoleCommandHistoryLength )
428 return false;
429
430 // remember the current command history to be able to compare with it later
431 // in IsHistoryUnchanged()
432 m_historyLen = GetCommandHistory(m_history);
433 if ( !m_history )
434 return false;
435
436
437 // now find the first blank line above the current position
438 CONSOLE_SCREEN_BUFFER_INFO csbi;
439
440 if ( !::GetConsoleScreenBufferInfo(m_hStderr, &csbi) )
441 {
442 wxLogLastError(wxT("GetConsoleScreenBufferInfo"));
443 return false;
444 }
445
446 COORD pos;
447 pos.X = 0;
448 pos.Y = csbi.dwCursorPosition.Y + 1;
449
450 // we decide that a line is empty if first 4 characters are spaces
451 DWORD ret;
452 char buf[4];
453 do
454 {
455 pos.Y--;
456 if ( !::ReadConsoleOutputCharacterA(m_hStderr, buf, WXSIZEOF(buf),
457 pos, &ret) )
458 {
459 wxLogLastError(wxT("ReadConsoleOutputCharacterA"));
460 return false;
461 }
462 } while ( wxStrncmp(" ", buf, WXSIZEOF(buf)) != 0 );
463
464 // calculate line offset and length of data
465 m_dataLine = csbi.dwCursorPosition.Y - pos.Y;
466 m_dataLen = m_dataLine*csbi.dwMaximumWindowSize.X + csbi.dwCursorPosition.X;
467
468 if ( m_dataLen > 0 )
469 {
470 m_data.extend(m_dataLen);
471 if ( !::ReadConsoleOutputCharacterA(m_hStderr, m_data.data(), m_dataLen,
472 pos, &ret) )
473 {
474 wxLogLastError(wxT("ReadConsoleOutputCharacterA"));
475 return false;
476 }
477 }
478
479 return true;
480 }
481
482 int wxConsoleStderr::GetCommandHistory(wxWxCharBuffer& buf) const
483 {
484 // these functions are internal and may only be called by cmd.exe
485 static const wxChar *CMD_EXE = wxT("cmd.exe");
486
487 const int len = m_pfnGetConsoleCommandHistoryLength(CMD_EXE);
488 if ( len )
489 {
490 buf.extend(len);
491
492 int len2 = m_pfnGetConsoleCommandHistory(buf.data(), len, CMD_EXE);
493
494 #if !wxUSE_UNICODE
495 // there seems to be a bug in the GetConsoleCommandHistoryA(), it
496 // returns the length of Unicode string and not ANSI one
497 len2 /= 2;
498 #endif // !wxUSE_UNICODE
499
500 if ( len2 != len )
501 {
502 wxFAIL_MSG( wxT("failed getting history?") );
503 }
504 }
505
506 return len;
507 }
508
509 bool wxConsoleStderr::IsHistoryUnchanged() const
510 {
511 wxASSERT_MSG( m_ok == 1, wxT("shouldn't be called if not initialized") );
512
513 // get (possibly changed) command history
514 wxWxCharBuffer history;
515 const int historyLen = GetCommandHistory(history);
516
517 // and compare it with the original one
518 return historyLen == m_historyLen && history &&
519 memcmp(m_history, history, historyLen) == 0;
520 }
521
522 bool wxConsoleStderr::Write(const wxString& text)
523 {
524 wxASSERT_MSG( m_hStderr != INVALID_HANDLE_VALUE,
525 wxT("should only be called if Init() returned true") );
526
527 // get current position
528 CONSOLE_SCREEN_BUFFER_INFO csbi;
529 if ( !::GetConsoleScreenBufferInfo(m_hStderr, &csbi) )
530 {
531 wxLogLastError(wxT("GetConsoleScreenBufferInfo"));
532 return false;
533 }
534
535 // and calculate new position (where is empty line)
536 csbi.dwCursorPosition.X = 0;
537 csbi.dwCursorPosition.Y -= m_dataLine;
538
539 if ( !::SetConsoleCursorPosition(m_hStderr, csbi.dwCursorPosition) )
540 {
541 wxLogLastError(wxT("SetConsoleCursorPosition"));
542 return false;
543 }
544
545 DWORD ret;
546 if ( !::FillConsoleOutputCharacter(m_hStderr, wxT(' '), m_dataLen,
547 csbi.dwCursorPosition, &ret) )
548 {
549 wxLogLastError(wxT("FillConsoleOutputCharacter"));
550 return false;
551 }
552
553 if ( !::WriteConsole(m_hStderr, text.wx_str(), text.length(), &ret, NULL) )
554 {
555 wxLogLastError(wxT("WriteConsole"));
556 return false;
557 }
558
559 WriteConsoleA(m_hStderr, m_data, m_dataLen, &ret, 0);
560
561 return true;
562 }
563
564 wxConsoleStderr s_consoleStderr;
565
566 } // anonymous namespace
567
568 bool wxGUIAppTraits::CanUseStderr()
569 {
570 return s_consoleStderr.IsOkToUse();
571 }
572
573 bool wxGUIAppTraits::WriteToStderr(const wxString& text)
574 {
575 return s_consoleStderr.IsOkToUse() && s_consoleStderr.Write(text);
576 }
577
578 #else // !wxUSE_DYNLIB_CLASS
579
580 bool wxGUIAppTraits::CanUseStderr()
581 {
582 return false;
583 }
584
585 bool wxGUIAppTraits::WriteToStderr(const wxString& WXUNUSED(text))
586 {
587 return false;
588 }
589
590 #endif // wxUSE_DYNLIB_CLASS/!wxUSE_DYNLIB_CLASS
591
592 #endif // !__WXWINCE__
593
594 // ===========================================================================
595 // wxApp implementation
596 // ===========================================================================
597
598 int wxApp::m_nCmdShow = SW_SHOWNORMAL;
599
600 // ---------------------------------------------------------------------------
601 // wxWin macros
602 // ---------------------------------------------------------------------------
603
604 IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
605
606 BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
607 EVT_IDLE(wxApp::OnIdle)
608 EVT_END_SESSION(wxApp::OnEndSession)
609 EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
610 END_EVENT_TABLE()
611
612 // class to ensure that wxAppBase::CleanUp() is called if our Initialize()
613 // fails
614 class wxCallBaseCleanup
615 {
616 public:
617 wxCallBaseCleanup(wxApp *app) : m_app(app) { }
618 ~wxCallBaseCleanup() { if ( m_app ) m_app->wxAppBase::CleanUp(); }
619
620 void Dismiss() { m_app = NULL; }
621
622 private:
623 wxApp *m_app;
624 };
625
626 //// Initialize
627 bool wxApp::Initialize(int& argc, wxChar **argv)
628 {
629 if ( !wxAppBase::Initialize(argc, argv) )
630 return false;
631
632 // ensure that base cleanup is done if we return too early
633 wxCallBaseCleanup callBaseCleanup(this);
634
635 #if !defined(__WXMICROWIN__)
636 InitCommonControls();
637 #endif // !defined(__WXMICROWIN__)
638
639 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
640 SHInitExtraControls();
641 #endif
642
643 #ifndef __WXWINCE__
644 // Don't show a message box if a function such as SHGetFileInfo
645 // fails to find a device.
646 SetErrorMode(SEM_FAILCRITICALERRORS|SEM_NOOPENFILEERRORBOX);
647 #endif
648
649 wxOleInitialize();
650
651 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
652 wxSetKeyboardHook(true);
653 #endif
654
655 callBaseCleanup.Dismiss();
656
657 return true;
658 }
659
660 // ---------------------------------------------------------------------------
661 // Win32 window class registration
662 // ---------------------------------------------------------------------------
663
664 /* static */
665 const wxChar *wxApp::GetRegisteredClassName(const wxChar *name,
666 int bgBrushCol,
667 int extraStyles)
668 {
669 const size_t count = gs_regClassesInfo.size();
670 for ( size_t n = 0; n < count; n++ )
671 {
672 if ( gs_regClassesInfo[n].regname == name )
673 return gs_regClassesInfo[n].regname.c_str();
674 }
675
676 // we need to register this class
677 WNDCLASS wndclass;
678 wxZeroMemory(wndclass);
679
680 wndclass.lpfnWndProc = (WNDPROC)wxWndProc;
681 wndclass.hInstance = wxGetInstance();
682 wndclass.hCursor = ::LoadCursor(NULL, IDC_ARROW);
683 wndclass.hbrBackground = (HBRUSH)wxUIntToPtr(bgBrushCol + 1);
684 wndclass.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS | extraStyles;
685
686
687 ClassRegInfo regClass(name);
688 wndclass.lpszClassName = regClass.regname.wx_str();
689 if ( !::RegisterClass(&wndclass) )
690 {
691 wxLogLastError(wxString::Format(wxT("RegisterClass(%s)"),
692 regClass.regname));
693 return NULL;
694 }
695
696 wndclass.style &= ~(CS_HREDRAW | CS_VREDRAW);
697 wndclass.lpszClassName = regClass.regnameNR.wx_str();
698 if ( !::RegisterClass(&wndclass) )
699 {
700 wxLogLastError(wxString::Format(wxT("RegisterClass(%s)"),
701 regClass.regname));
702 ::UnregisterClass(regClass.regname.c_str(), wxGetInstance());
703 return NULL;
704 }
705
706 gs_regClassesInfo.push_back(regClass);
707
708 // take care to return the pointer which will remain valid after the
709 // function returns (it could be invalidated later if new elements are
710 // added to the vector and it's reallocated but this shouldn't matter as
711 // this pointer should be used right now, not stored)
712 return gs_regClassesInfo.back().regname.wx_str();
713 }
714
715 bool wxApp::IsRegisteredClassName(const wxString& name)
716 {
717 const size_t count = gs_regClassesInfo.size();
718 for ( size_t n = 0; n < count; n++ )
719 {
720 if ( gs_regClassesInfo[n].regname == name ||
721 gs_regClassesInfo[n].regnameNR == name )
722 return true;
723 }
724
725 return false;
726 }
727
728 void wxApp::UnregisterWindowClasses()
729 {
730 const size_t count = gs_regClassesInfo.size();
731 for ( size_t n = 0; n < count; n++ )
732 {
733 const ClassRegInfo& regClass = gs_regClassesInfo[n];
734 if ( !::UnregisterClass(regClass.regname.c_str(), wxGetInstance()) )
735 {
736 wxLogLastError(wxString::Format(wxT("UnregisterClass(%s)"),
737 regClass.regname));
738 }
739
740 if ( !::UnregisterClass(regClass.regnameNR.c_str(), wxGetInstance()) )
741 {
742 wxLogLastError(wxString::Format(wxT("UnregisterClass(%s)"),
743 regClass.regnameNR));
744 }
745 }
746
747 gs_regClassesInfo.clear();
748 }
749
750 void wxApp::CleanUp()
751 {
752 // all objects pending for deletion must be deleted first, otherwise
753 // UnregisterWindowClasses() call wouldn't succeed (because windows
754 // using the classes being unregistered still exist), so call the base
755 // class method first and only then do our clean up
756 wxAppBase::CleanUp();
757
758 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
759 wxSetKeyboardHook(false);
760 #endif
761
762 wxOleUninitialize();
763
764 // for an EXE the classes are unregistered when it terminates but DLL may
765 // be loaded several times (load/unload/load) into the same process in
766 // which case the registration will fail after the first time if we don't
767 // unregister the classes now
768 UnregisterWindowClasses();
769 }
770
771 // ----------------------------------------------------------------------------
772 // wxApp ctor/dtor
773 // ----------------------------------------------------------------------------
774
775 wxApp::wxApp()
776 {
777 m_printMode = wxPRINT_WINDOWS;
778 }
779
780 wxApp::~wxApp()
781 {
782 }
783
784 // ----------------------------------------------------------------------------
785 // wxApp idle handling
786 // ----------------------------------------------------------------------------
787
788 void wxApp::OnIdle(wxIdleEvent& WXUNUSED(event))
789 {
790 #if wxUSE_DC_CACHEING
791 // automated DC cache management: clear the cached DCs and bitmap
792 // if it's likely that the app has finished with them, that is, we
793 // get an idle event and we're not dragging anything.
794 if (!::GetKeyState(MK_LBUTTON) && !::GetKeyState(MK_MBUTTON) && !::GetKeyState(MK_RBUTTON))
795 wxMSWDCImpl::ClearCache();
796 #endif // wxUSE_DC_CACHEING
797 }
798
799 void wxApp::WakeUpIdle()
800 {
801 // Send the top window a dummy message so idle handler processing will
802 // start up again. Doing it this way ensures that the idle handler
803 // wakes up in the right thread (see also wxWakeUpMainThread() which does
804 // the same for the main app thread only)
805 wxWindow * const topWindow = wxTheApp->GetTopWindow();
806 if ( topWindow )
807 {
808 HWND hwndTop = GetHwndOf(topWindow);
809
810 // Do not post WM_NULL if there's already a pending WM_NULL to avoid
811 // overflowing the message queue.
812 //
813 // Notice that due to a limitation of PeekMessage() API (which handles
814 // 0,0 range specially), we have to check the range from 0-1 instead.
815 // This still makes it possible to overflow the queue with WM_NULLs by
816 // interspersing the calles to WakeUpIdle() with windows creation but
817 // it should be rather hard to do it accidentally.
818 MSG msg;
819 if ( !::PeekMessage(&msg, hwndTop, 0, 1, PM_NOREMOVE) ||
820 ::PeekMessage(&msg, hwndTop, 1, 1, PM_NOREMOVE) )
821 {
822 if ( !::PostMessage(hwndTop, WM_NULL, 0, 0) )
823 {
824 // should never happen
825 wxLogLastError(wxT("PostMessage(WM_NULL)"));
826 }
827 }
828 }
829 #if wxUSE_THREADS
830 else
831 wxWakeUpMainThread();
832 #endif // wxUSE_THREADS
833 }
834
835 // ----------------------------------------------------------------------------
836 // other wxApp event hanlders
837 // ----------------------------------------------------------------------------
838
839 void wxApp::OnEndSession(wxCloseEvent& WXUNUSED(event))
840 {
841 // Windows will terminate the process soon after we return from
842 // WM_ENDSESSION handler or when we delete our last window, so make sure we
843 // at least execute our cleanup code before
844
845 // prevent the window from being destroyed when the corresponding wxTLW is
846 // destroyed: this will result in a leak of a HWND, of course, but who
847 // cares when the process is being killed anyhow
848 if ( !wxTopLevelWindows.empty() )
849 wxTopLevelWindows[0]->SetHWND(0);
850
851 const int rc = OnExit();
852
853 wxEntryCleanup();
854
855 // calling exit() instead of ExitProcess() or not doing anything at all and
856 // being killed by Windows has the advantage of executing the dtors of
857 // global objects
858 exit(rc);
859 }
860
861 // Default behaviour: close the application with prompts. The
862 // user can veto the close, and therefore the end session.
863 void wxApp::OnQueryEndSession(wxCloseEvent& event)
864 {
865 if (GetTopWindow())
866 {
867 if (!GetTopWindow()->Close(!event.CanVeto()))
868 event.Veto(true);
869 }
870 }
871
872 // ----------------------------------------------------------------------------
873 // system DLL versions
874 // ----------------------------------------------------------------------------
875
876 // these functions have trivial inline implementations for CE
877 #ifndef __WXWINCE__
878
879 #if wxUSE_DYNLIB_CLASS
880
881 namespace
882 {
883
884 // helper function: retrieve the DLL version by using DllGetVersion(), returns
885 // 0 if the DLL doesn't export such function
886 int CallDllGetVersion(wxDynamicLibrary& dll)
887 {
888 // now check if the function is available during run-time
889 wxDYNLIB_FUNCTION( DLLGETVERSIONPROC, DllGetVersion, dll );
890 if ( !pfnDllGetVersion )
891 return 0;
892
893 DLLVERSIONINFO dvi;
894 dvi.cbSize = sizeof(dvi);
895
896 HRESULT hr = (*pfnDllGetVersion)(&dvi);
897 if ( FAILED(hr) )
898 {
899 wxLogApiError(wxT("DllGetVersion"), hr);
900
901 return 0;
902 }
903
904 return 100*dvi.dwMajorVersion + dvi.dwMinorVersion;
905 }
906
907 } // anonymous namespace
908
909 /* static */
910 int wxApp::GetComCtl32Version()
911 {
912 // cache the result
913 //
914 // NB: this is MT-ok as in the worst case we'd compute s_verComCtl32 twice,
915 // but as its value should be the same both times it doesn't matter
916 static int s_verComCtl32 = -1;
917
918 if ( s_verComCtl32 == -1 )
919 {
920 // we're prepared to handle the errors
921 wxLogNull noLog;
922
923 // we don't want to load comctl32.dll, it should be already loaded but,
924 // depending on the OS version and the presence of the manifest, it can
925 // be either v5 or v6 and instead of trying to guess it just get the
926 // handle of the already loaded version
927 wxLoadedDLL dllComCtl32(wxT("comctl32.dll"));
928 if ( !dllComCtl32.IsLoaded() )
929 {
930 s_verComCtl32 = 0;
931 return 0;
932 }
933
934 // try DllGetVersion() for recent DLLs
935 s_verComCtl32 = CallDllGetVersion(dllComCtl32);
936
937 // if DllGetVersion() is unavailable either during compile or
938 // run-time, try to guess the version otherwise
939 if ( !s_verComCtl32 )
940 {
941 // InitCommonControlsEx is unique to 4.70 and later
942 void *pfn = dllComCtl32.GetSymbol(wxT("InitCommonControlsEx"));
943 if ( !pfn )
944 {
945 // not found, must be 4.00
946 s_verComCtl32 = 400;
947 }
948 else // 4.70+
949 {
950 // many symbols appeared in comctl32 4.71, could use any of
951 // them except may be DllInstall()
952 pfn = dllComCtl32.GetSymbol(wxT("InitializeFlatSB"));
953 if ( !pfn )
954 {
955 // not found, must be 4.70
956 s_verComCtl32 = 470;
957 }
958 else
959 {
960 // found, must be 4.71 or later
961 s_verComCtl32 = 471;
962 }
963 }
964 }
965 }
966
967 return s_verComCtl32;
968 }
969
970 /* static */
971 int wxApp::GetShell32Version()
972 {
973 static int s_verShell32 = -1;
974 if ( s_verShell32 == -1 )
975 {
976 // we're prepared to handle the errors
977 wxLogNull noLog;
978
979 wxDynamicLibrary dllShell32(wxT("shell32.dll"), wxDL_VERBATIM);
980 if ( dllShell32.IsLoaded() )
981 {
982 s_verShell32 = CallDllGetVersion(dllShell32);
983
984 if ( !s_verShell32 )
985 {
986 // there doesn't seem to be any way to distinguish between 4.00
987 // and 4.70 (starting from 4.71 we have DllGetVersion()) so
988 // just assume it is 4.0
989 s_verShell32 = 400;
990 }
991 }
992 else // failed load the DLL?
993 {
994 s_verShell32 = 0;
995 }
996 }
997
998 return s_verShell32;
999 }
1000
1001 #else // !wxUSE_DYNLIB_CLASS
1002
1003 /* static */
1004 int wxApp::GetComCtl32Version()
1005 {
1006 return 0;
1007 }
1008
1009 /* static */
1010 int wxApp::GetShell32Version()
1011 {
1012 return 0;
1013 }
1014
1015 #endif // wxUSE_DYNLIB_CLASS/!wxUSE_DYNLIB_CLASS
1016
1017 #endif // !__WXWINCE__
1018
1019 #if wxUSE_EXCEPTIONS
1020
1021 // ----------------------------------------------------------------------------
1022 // exception handling
1023 // ----------------------------------------------------------------------------
1024
1025 bool wxApp::OnExceptionInMainLoop()
1026 {
1027 // ask the user about what to do: use the Win32 API function here as it
1028 // could be dangerous to use any wxWidgets code in this state
1029 switch (
1030 ::MessageBox
1031 (
1032 NULL,
1033 wxT("An unhandled exception occurred. Press \"Abort\" to \
1034 terminate the program,\r\n\
1035 \"Retry\" to exit the program normally and \"Ignore\" to try to continue."),
1036 wxT("Unhandled exception"),
1037 MB_ABORTRETRYIGNORE |
1038 MB_ICONERROR|
1039 MB_TASKMODAL
1040 )
1041 )
1042 {
1043 case IDABORT:
1044 throw;
1045
1046 default:
1047 wxFAIL_MSG( wxT("unexpected MessageBox() return code") );
1048 // fall through
1049
1050 case IDRETRY:
1051 return false;
1052
1053 case IDIGNORE:
1054 return true;
1055 }
1056 }
1057
1058 #endif // wxUSE_EXCEPTIONS