1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/app.cpp
4 // Author: Julian Smart
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ===========================================================================
14 // ===========================================================================
16 // ---------------------------------------------------------------------------
18 // ---------------------------------------------------------------------------
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
23 #if defined(__BORLANDC__)
28 #include "wx/msw/wrapcctl.h"
29 #include "wx/dynarray.h"
33 #include "wx/gdicmn.h"
36 #include "wx/cursor.h"
38 #include "wx/palette.h"
40 #include "wx/dialog.h"
41 #include "wx/msgdlg.h"
45 #include "wx/module.h"
48 #include "wx/apptrait.h"
49 #include "wx/filename.h"
50 #include "wx/dynlib.h"
51 #include "wx/evtloop.h"
53 #include "wx/msw/private.h"
54 #include "wx/msw/ole/oleutils.h"
55 #include "wx/msw/private/timer.h"
58 #include "wx/tooltip.h"
59 #endif // wxUSE_TOOLTIPS
61 // OLE is used for drag-and-drop, clipboard, OLE Automation..., but some
62 // compilers don't support it (missing headers, libs, ...)
63 #if defined(__GNUWIN32_OLD__) || defined(__SYMANTEC__) || defined(__SALFORDC__)
67 #endif // broken compilers
69 #if defined(__POCKETPC__) || defined(__SMARTPHONE__)
81 #include "wx/msw/missing.h"
83 // instead of including <shlwapi.h> which is not part of the core SDK and not
84 // shipped at all with other compilers, we always define the parts of it we
85 // need here ourselves
87 // NB: DLLVER_PLATFORM_WINDOWS will be defined if shlwapi.h had been somehow
89 #ifndef DLLVER_PLATFORM_WINDOWS
90 // hopefully we don't need to change packing as DWORDs should be already
95 DWORD dwMajorVersion
; // Major version
96 DWORD dwMinorVersion
; // Minor version
97 DWORD dwBuildNumber
; // Build number
98 DWORD dwPlatformID
; // DLLVER_PLATFORM_*
101 typedef HRESULT (CALLBACK
* DLLGETVERSIONPROC
)(DLLVERSIONINFO
*);
102 #endif // defined(DLLVERSIONINFO)
105 // ---------------------------------------------------------------------------
107 // ---------------------------------------------------------------------------
109 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
110 extern void wxSetKeyboardHook(bool doIt
);
113 // NB: all "NoRedraw" classes must have the same names as the "normal" classes
114 // with NR suffix - wxWindow::MSWCreate() supposes this
116 WXDLLIMPEXP_CORE wxChar
*wxCanvasClassName
;
117 WXDLLIMPEXP_CORE wxChar
*wxCanvasClassNameNR
;
119 WXDLLIMPEXP_CORE
const wxChar
*wxCanvasClassName
= wxT("wxWindowClass");
120 WXDLLIMPEXP_CORE
const wxChar
*wxCanvasClassNameNR
= wxT("wxWindowClassNR");
122 WXDLLIMPEXP_CORE
const wxChar
*wxMDIFrameClassName
= wxT("wxMDIFrameClass");
123 WXDLLIMPEXP_CORE
const wxChar
*wxMDIFrameClassNameNoRedraw
= wxT("wxMDIFrameClassNR");
124 WXDLLIMPEXP_CORE
const wxChar
*wxMDIChildFrameClassName
= wxT("wxMDIChildFrameClass");
125 WXDLLIMPEXP_CORE
const wxChar
*wxMDIChildFrameClassNameNoRedraw
= wxT("wxMDIChildFrameClassNR");
127 // ----------------------------------------------------------------------------
129 // ----------------------------------------------------------------------------
131 LRESULT WXDLLEXPORT APIENTRY
wxWndProc(HWND
, UINT
, WPARAM
, LPARAM
);
133 // ===========================================================================
134 // wxGUIAppTraits implementation
135 // ===========================================================================
137 // private class which we use to pass parameters from BeforeChildWaitLoop() to
138 // AfterChildWaitLoop()
139 struct ChildWaitLoopData
141 ChildWaitLoopData(wxWindowDisabler
*wd_
, wxWindow
*winActive_
)
144 winActive
= winActive_
;
147 wxWindowDisabler
*wd
;
151 void *wxGUIAppTraits::BeforeChildWaitLoop()
154 We use a dirty hack here to disable all application windows (which we
155 must do because otherwise the calls to wxYield() could lead to some very
156 unexpected reentrancies in the users code) but to avoid losing
157 focus/activation entirely when the child process terminates which would
158 happen if we simply disabled everything using wxWindowDisabler. Indeed,
159 remember that Windows will never activate a disabled window and when the
160 last childs window is closed and Windows looks for a window to activate
161 all our windows are still disabled. There is no way to enable them in
162 time because we don't know when the childs windows are going to be
163 closed, so the solution we use here is to keep one special tiny frame
164 enabled all the time. Then when the child terminates it will get
165 activated and when we close it below -- after reenabling all the other
166 windows! -- the previously active window becomes activated again and
171 // first disable all existing windows
172 wxWindowDisabler
*wd
= new wxWindowDisabler
;
174 // then create an "invisible" frame: it has minimal size, is positioned
175 // (hopefully) outside the screen and doesn't appear on the taskbar
176 wxWindow
*winActive
= new wxFrame
178 wxTheApp
->GetTopWindow(),
181 wxPoint(32600, 32600),
183 wxDEFAULT_FRAME_STYLE
| wxFRAME_NO_TASKBAR
187 return new ChildWaitLoopData(wd
, winActive
);
190 void wxGUIAppTraits::AlwaysYield()
195 void wxGUIAppTraits::AfterChildWaitLoop(void *dataOrig
)
199 ChildWaitLoopData
* const data
= (ChildWaitLoopData
*)dataOrig
;
203 // finally delete the dummy frame and, as wd has been already destroyed and
204 // the other windows reenabled, the activation is going to return to the
205 // window which had had it before
206 data
->winActive
->Destroy();
208 // also delete the temporary data object itself
212 bool wxGUIAppTraits::DoMessageFromThreadWait()
214 // we should return false only if the app should exit, i.e. only if
215 // Dispatch() determines that the main event loop should terminate
216 wxEventLoopBase
* const evtLoop
= wxEventLoop::GetActive();
217 if ( !evtLoop
|| !evtLoop
->Pending() )
219 // no events means no quit event
223 return evtLoop
->Dispatch();
226 DWORD
wxGUIAppTraits::WaitForThread(WXHANDLE hThread
)
228 // if we don't have a running event loop, we shouldn't wait for the
229 // messages as we never remove them from the message queue and so we enter
230 // an infinite loop as MsgWaitForMultipleObjects() keeps returning
232 if ( !wxEventLoop::GetActive() )
233 return DoSimpleWaitForThread(hThread
);
235 return ::MsgWaitForMultipleObjects
237 1, // number of objects to wait for
238 (HANDLE
*)&hThread
, // the objects
239 false, // wait for any objects, not all
240 INFINITE
, // no timeout
241 QS_ALLINPUT
| // return as soon as there are any events
246 wxPortId
wxGUIAppTraits::GetToolkitVersion(int *majVer
, int *minVer
) const
251 // on Windows, the toolkit version is the same of the OS version
252 // as Windows integrates the OS kernel with the GUI toolkit.
253 info
.dwOSVersionInfoSize
= sizeof(OSVERSIONINFO
);
254 if ( ::GetVersionEx(&info
) )
257 *majVer
= info
.dwMajorVersion
;
259 *minVer
= info
.dwMinorVersion
;
262 #if defined(__WXHANDHELD__) || defined(__WXWINCE__)
271 wxTimerImpl
*wxGUIAppTraits::CreateTimerImpl(wxTimer
*timer
)
273 return new wxMSWTimerImpl(timer
);
276 #endif // wxUSE_TIMER
278 wxEventLoopBase
* wxGUIAppTraits::CreateEventLoop()
280 return new wxEventLoop
;
283 // ===========================================================================
284 // wxApp implementation
285 // ===========================================================================
287 int wxApp::m_nCmdShow
= SW_SHOWNORMAL
;
289 // ---------------------------------------------------------------------------
291 // ---------------------------------------------------------------------------
293 IMPLEMENT_DYNAMIC_CLASS(wxApp
, wxEvtHandler
)
295 BEGIN_EVENT_TABLE(wxApp
, wxEvtHandler
)
296 EVT_IDLE(wxApp::OnIdle
)
297 EVT_END_SESSION(wxApp::OnEndSession
)
298 EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession
)
301 // class to ensure that wxAppBase::CleanUp() is called if our Initialize()
303 class wxCallBaseCleanup
306 wxCallBaseCleanup(wxApp
*app
) : m_app(app
) { }
307 ~wxCallBaseCleanup() { if ( m_app
) m_app
->wxAppBase::CleanUp(); }
309 void Dismiss() { m_app
= NULL
; }
316 bool wxApp::Initialize(int& argc
, wxChar
**argv
)
318 if ( !wxAppBase::Initialize(argc
, argv
) )
321 // ensure that base cleanup is done if we return too early
322 wxCallBaseCleanup
callBaseCleanup(this);
325 wxString tmp
= GetAppName();
326 tmp
+= wxT("ClassName");
327 wxCanvasClassName
= wxStrdup( tmp
.wc_str() );
329 wxCanvasClassNameNR
= wxStrdup( tmp
.wc_str() );
330 HWND hWnd
= FindWindow( wxCanvasClassNameNR
, NULL
);
333 SetForegroundWindow( (HWND
)(((DWORD
)hWnd
)|0x01) );
338 #if !defined(__WXMICROWIN__)
339 InitCommonControls();
340 #endif // !defined(__WXMICROWIN__)
342 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
343 SHInitExtraControls();
347 // Don't show a message box if a function such as SHGetFileInfo
348 // fails to find a device.
349 SetErrorMode(SEM_FAILCRITICALERRORS
|SEM_NOOPENFILEERRORBOX
);
354 RegisterWindowClasses();
356 wxWinHandleHash
= new wxWinHashTable(wxKEY_INTEGER
, 100);
358 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
359 wxSetKeyboardHook(true);
362 callBaseCleanup
.Dismiss();
367 // ---------------------------------------------------------------------------
368 // RegisterWindowClasses
369 // ---------------------------------------------------------------------------
371 // TODO we should only register classes really used by the app. For this it
372 // would be enough to just delay the class registration until an attempt
373 // to create a window of this class is made.
374 bool wxApp::RegisterWindowClasses()
377 wxZeroMemory(wndclass
);
379 // for each class we register one with CS_(V|H)REDRAW style and one
380 // without for windows created with wxNO_FULL_REDRAW_ON_REPAINT flag
381 static const long styleNormal
= CS_HREDRAW
| CS_VREDRAW
| CS_DBLCLKS
;
382 static const long styleNoRedraw
= CS_DBLCLKS
;
384 // the fields which are common to all classes
385 wndclass
.lpfnWndProc
= (WNDPROC
)wxWndProc
;
386 wndclass
.hInstance
= wxhInstance
;
387 wndclass
.hCursor
= ::LoadCursor((HINSTANCE
)NULL
, IDC_ARROW
);
389 // register the class for all normal windows
390 wndclass
.hbrBackground
= (HBRUSH
)(COLOR_BTNFACE
+ 1);
391 wndclass
.lpszClassName
= wxCanvasClassName
;
392 wndclass
.style
= styleNormal
;
394 if ( !RegisterClass(&wndclass
) )
396 wxLogLastError(wxT("RegisterClass(frame)"));
400 wndclass
.lpszClassName
= wxCanvasClassNameNR
;
401 wndclass
.style
= styleNoRedraw
;
403 if ( !RegisterClass(&wndclass
) )
405 wxLogLastError(wxT("RegisterClass(no redraw frame)"));
408 // Register the MDI frame window class.
409 wndclass
.hbrBackground
= (HBRUSH
)NULL
; // paint MDI frame ourselves
410 wndclass
.lpszClassName
= wxMDIFrameClassName
;
411 wndclass
.style
= styleNormal
;
413 if ( !RegisterClass(&wndclass
) )
415 wxLogLastError(wxT("RegisterClass(MDI parent)"));
418 // "no redraw" MDI frame
419 wndclass
.lpszClassName
= wxMDIFrameClassNameNoRedraw
;
420 wndclass
.style
= styleNoRedraw
;
422 if ( !RegisterClass(&wndclass
) )
424 wxLogLastError(wxT("RegisterClass(no redraw MDI parent frame)"));
427 // Register the MDI child frame window class.
428 wndclass
.hbrBackground
= (HBRUSH
)(COLOR_WINDOW
+ 1);
429 wndclass
.lpszClassName
= wxMDIChildFrameClassName
;
430 wndclass
.style
= styleNormal
;
432 if ( !RegisterClass(&wndclass
) )
434 wxLogLastError(wxT("RegisterClass(MDI child)"));
437 // "no redraw" MDI child frame
438 wndclass
.lpszClassName
= wxMDIChildFrameClassNameNoRedraw
;
439 wndclass
.style
= styleNoRedraw
;
441 if ( !RegisterClass(&wndclass
) )
443 wxLogLastError(wxT("RegisterClass(no redraw MDI child)"));
449 // ---------------------------------------------------------------------------
450 // UnregisterWindowClasses
451 // ---------------------------------------------------------------------------
453 bool wxApp::UnregisterWindowClasses()
457 #ifndef __WXMICROWIN__
458 // MDI frame window class.
459 if ( !::UnregisterClass(wxMDIFrameClassName
, wxhInstance
) )
461 wxLogLastError(wxT("UnregisterClass(MDI parent)"));
466 // "no redraw" MDI frame
467 if ( !::UnregisterClass(wxMDIFrameClassNameNoRedraw
, wxhInstance
) )
469 wxLogLastError(wxT("UnregisterClass(no redraw MDI parent frame)"));
474 // MDI child frame window class.
475 if ( !::UnregisterClass(wxMDIChildFrameClassName
, wxhInstance
) )
477 wxLogLastError(wxT("UnregisterClass(MDI child)"));
482 // "no redraw" MDI child frame
483 if ( !::UnregisterClass(wxMDIChildFrameClassNameNoRedraw
, wxhInstance
) )
485 wxLogLastError(wxT("UnregisterClass(no redraw MDI child)"));
491 if ( !::UnregisterClass(wxCanvasClassName
, wxhInstance
) )
493 wxLogLastError(wxT("UnregisterClass(canvas)"));
498 if ( !::UnregisterClass(wxCanvasClassNameNR
, wxhInstance
) )
500 wxLogLastError(wxT("UnregisterClass(no redraw canvas)"));
504 #endif // __WXMICROWIN__
509 void wxApp::CleanUp()
511 // all objects pending for deletion must be deleted first, otherwise we
512 // would crash when they use wxWinHandleHash (and UnregisterWindowClasses()
513 // call wouldn't succeed as long as any windows still exist), so call the
514 // base class method first and only then do our clean up
515 wxAppBase::CleanUp();
517 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
518 wxSetKeyboardHook(false);
523 // for an EXE the classes are unregistered when it terminates but DLL may
524 // be loaded several times (load/unload/load) into the same process in
525 // which case the registration will fail after the first time if we don't
526 // unregister the classes now
527 UnregisterWindowClasses();
529 delete wxWinHandleHash
;
530 wxWinHandleHash
= NULL
;
533 free( wxCanvasClassName
);
534 free( wxCanvasClassNameNR
);
538 // ----------------------------------------------------------------------------
540 // ----------------------------------------------------------------------------
544 m_printMode
= wxPRINT_WINDOWS
;
551 // ----------------------------------------------------------------------------
552 // wxApp idle handling
553 // ----------------------------------------------------------------------------
555 void wxApp::OnIdle(wxIdleEvent
& WXUNUSED(event
))
557 #if wxUSE_DC_CACHEING
558 // automated DC cache management: clear the cached DCs and bitmap
559 // if it's likely that the app has finished with them, that is, we
560 // get an idle event and we're not dragging anything.
561 if (!::GetKeyState(MK_LBUTTON
) && !::GetKeyState(MK_MBUTTON
) && !::GetKeyState(MK_RBUTTON
))
562 wxMSWDCImpl::ClearCache();
563 #endif // wxUSE_DC_CACHEING
566 void wxApp::WakeUpIdle()
568 // Send the top window a dummy message so idle handler processing will
569 // start up again. Doing it this way ensures that the idle handler
570 // wakes up in the right thread (see also wxWakeUpMainThread() which does
571 // the same for the main app thread only)
572 wxWindow
*topWindow
= wxTheApp
->GetTopWindow();
575 if ( !::PostMessage(GetHwndOf(topWindow
), WM_NULL
, 0, 0) )
577 // should never happen
578 wxLogLastError(wxT("PostMessage(WM_NULL)"));
583 // ----------------------------------------------------------------------------
584 // other wxApp event hanlders
585 // ----------------------------------------------------------------------------
587 void wxApp::OnEndSession(wxCloseEvent
& WXUNUSED(event
))
590 GetTopWindow()->Close(true);
593 // Default behaviour: close the application with prompts. The
594 // user can veto the close, and therefore the end session.
595 void wxApp::OnQueryEndSession(wxCloseEvent
& event
)
599 if (!GetTopWindow()->Close(!event
.CanVeto()))
604 // ----------------------------------------------------------------------------
606 // ----------------------------------------------------------------------------
609 int wxApp::GetComCtl32Version()
611 #if defined(__WXMICROWIN__) || defined(__WXWINCE__)
616 // NB: this is MT-ok as in the worst case we'd compute s_verComCtl32 twice,
617 // but as its value should be the same both times it doesn't matter
618 static int s_verComCtl32
= -1;
620 if ( s_verComCtl32
== -1 )
622 // initally assume no comctl32.dll at all
625 // we're prepared to handle the errors
628 #if wxUSE_DYNLIB_CLASS
630 wxDynamicLibrary
dllComCtl32(_T("comctl32.dll"), wxDL_VERBATIM
);
632 // if so, then we can check for the version
633 if ( dllComCtl32
.IsLoaded() )
635 // now check if the function is available during run-time
636 wxDYNLIB_FUNCTION( DLLGETVERSIONPROC
, DllGetVersion
, dllComCtl32
);
637 if ( pfnDllGetVersion
)
640 dvi
.cbSize
= sizeof(dvi
);
642 HRESULT hr
= (*pfnDllGetVersion
)(&dvi
);
645 wxLogApiError(_T("DllGetVersion"), hr
);
649 // this is incompatible with _WIN32_IE values, but
650 // compatible with the other values returned by
651 // GetComCtl32Version()
652 s_verComCtl32
= 100*dvi
.dwMajorVersion
+
657 // if DllGetVersion() is unavailable either during compile or
658 // run-time, try to guess the version otherwise
659 if ( !s_verComCtl32
)
661 // InitCommonControlsEx is unique to 4.70 and later
662 void *pfn
= dllComCtl32
.GetSymbol(_T("InitCommonControlsEx"));
665 // not found, must be 4.00
670 // many symbols appeared in comctl32 4.71, could use any of
671 // them except may be DllInstall()
672 pfn
= dllComCtl32
.GetSymbol(_T("InitializeFlatSB"));
675 // not found, must be 4.70
680 // found, must be 4.71 or later
689 return s_verComCtl32
;
690 #endif // Microwin/!Microwin
693 // Yield to incoming messages
695 bool wxApp::Yield(bool onlyIfNeeded
)
698 static bool s_inYield
= false;
701 // disable log flushing from here because a call to wxYield() shouldn't
702 // normally result in message boxes popping up &c
710 wxFAIL_MSG( wxT("wxYield called recursively" ) );
718 // we don't want to process WM_QUIT from here - it should be processed in
719 // the main event loop in order to stop it
721 while ( PeekMessage(&msg
, (HWND
)0, 0, 0, PM_NOREMOVE
) &&
722 msg
.message
!= WM_QUIT
)
725 wxMutexGuiLeaveOrEnter();
726 #endif // wxUSE_THREADS
728 if ( !wxTheApp
->Dispatch() )
732 // if there are pending events, we must process them.
733 ProcessPendingEvents();
736 // let the logs be flashed again
747 // ----------------------------------------------------------------------------
748 // exception handling
749 // ----------------------------------------------------------------------------
751 bool wxApp::OnExceptionInMainLoop()
753 // ask the user about what to do: use the Win32 API function here as it
754 // could be dangerous to use any wxWidgets code in this state
759 _T("An unhandled exception occurred. Press \"Abort\" to \
760 terminate the program,\r\n\
761 \"Retry\" to exit the program normally and \"Ignore\" to try to continue."),
762 _T("Unhandled exception"),
763 MB_ABORTRETRYIGNORE
|
773 wxFAIL_MSG( _T("unexpected MessageBox() return code") );
784 #endif // wxUSE_EXCEPTIONS