1 /////////////////////////////////////////////////////////////////////////////
4 // Author: Julian Smart
8 // Copyright: (c) Julian Smart and Markus Holzem
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
12 // ===========================================================================
14 // ===========================================================================
16 // ---------------------------------------------------------------------------
18 // ---------------------------------------------------------------------------
21 #pragma implementation "app.h"
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
27 #if defined(__BORLANDC__)
35 #include "wx/gdicmn.h"
38 #include "wx/cursor.h"
40 #include "wx/palette.h"
42 #include "wx/dialog.h"
43 #include "wx/msgdlg.h"
45 #include "wx/dynarray.h"
46 #include "wx/wxchar.h"
51 #include "wx/module.h"
53 #include "wx/msw/private.h"
56 #include "wx/thread.h"
58 // define the array of MSG strutures
59 WX_DECLARE_OBJARRAY(MSG
, wxMsgArray
);
61 #include "wx/arrimpl.cpp"
63 WX_DEFINE_OBJARRAY(wxMsgArray
);
64 #endif // wxUSE_THREADS
66 #if wxUSE_WX_RESOURCES
67 #include "wx/resource.h"
71 #include "wx/tooltip.h"
72 #endif // wxUSE_TOOLTIPS
74 // OLE is used for drag-and-drop, clipboard, OLE Automation..., but some
75 // compilers don't support it (missing headers, libs, ...)
76 #if defined(__GNUWIN32_OLD__) || defined(__SC__) || defined(__SALFORDC__)
80 #endif // broken compilers
89 #if defined(__WIN95__) && !((defined(__GNUWIN32_OLD__) || defined(__TWIN32__) || defined(__WXMICROWIN__)) && !defined(__CYGWIN10__))
93 #ifndef __WXMICROWIN__
94 #include "wx/msw/msvcrt.h"
97 // ----------------------------------------------------------------------------
98 // conditional compilation
99 // ----------------------------------------------------------------------------
101 // The macro _WIN32_IE is defined by commctrl.h (unless it had already been
102 // defined before) and shows us what common control features are available
103 // during the compile time (it doesn't mean that they will be available during
104 // the run-time, use GetComCtl32Version() to test for them!). The possible
107 // 0x0200 for comctl32.dll 4.00 shipped with Win95/NT 4.0
108 // 0x0300 4.70 IE 3.x
109 // 0x0400 4.71 IE 4.0
110 // 0x0401 4.72 IE 4.01 and Win98
111 // 0x0500 5.00 IE 5.x and NT 5.0 (Win2000)
114 // minimal set of features by default
115 #define _WIN32_IE 0x0200
118 #if _WIN32_IE >= 0x0300 \
119 && !( defined(__MINGW32__) && !wxCHECK_W32API_VERSION( 1, 0 ) )
123 // ---------------------------------------------------------------------------
125 // ---------------------------------------------------------------------------
127 extern wxChar
*wxBuffer
;
128 extern wxList
*wxWinHandleList
;
129 extern wxList WXDLLEXPORT wxPendingDelete
;
130 #ifndef __WXMICROWIN__
131 extern void wxSetKeyboardHook(bool doIt
);
135 wxApp
*wxTheApp
= NULL
;
137 // NB: all "NoRedraw" classes must have the same names as the "normal" classes
138 // with NR suffix - wxWindow::MSWCreate() supposes this
139 const wxChar
*wxFrameClassName
= wxT("wxFrameClass");
140 const wxChar
*wxFrameClassNameNoRedraw
= wxT("wxFrameClassNR");
141 const wxChar
*wxMDIFrameClassName
= wxT("wxMDIFrameClass");
142 const wxChar
*wxMDIFrameClassNameNoRedraw
= wxT("wxMDIFrameClassNR");
143 const wxChar
*wxMDIChildFrameClassName
= wxT("wxMDIChildFrameClass");
144 const wxChar
*wxMDIChildFrameClassNameNoRedraw
= wxT("wxMDIChildFrameClassNR");
145 const wxChar
*wxPanelClassName
= wxT("wxPanelClass");
146 const wxChar
*wxPanelClassNameNR
= wxT("wxPanelClassNR");
147 const wxChar
*wxCanvasClassName
= wxT("wxCanvasClass");
148 const wxChar
*wxCanvasClassNameNR
= wxT("wxCanvasClassNR");
150 HICON wxSTD_FRAME_ICON
= (HICON
) NULL
;
151 HICON wxSTD_MDICHILDFRAME_ICON
= (HICON
) NULL
;
152 HICON wxSTD_MDIPARENTFRAME_ICON
= (HICON
) NULL
;
154 HICON wxDEFAULT_FRAME_ICON
= (HICON
) NULL
;
155 HICON wxDEFAULT_MDICHILDFRAME_ICON
= (HICON
) NULL
;
156 HICON wxDEFAULT_MDIPARENTFRAME_ICON
= (HICON
) NULL
;
158 HBRUSH wxDisableButtonBrush
= (HBRUSH
) 0;
160 LRESULT WXDLLEXPORT APIENTRY
wxWndProc(HWND
, UINT
, WPARAM
, LPARAM
);
162 // FIXME wxUSE_ON_FATAL_EXCEPTION is only supported for VC++ now because it
163 // needs compiler support for Win32 SEH. Others (especially Borland)
164 // probably have it too, but I'm not sure about how it works
165 // JACS: get 'Cannot use __try in functions that require unwinding
166 // in Unicode mode, so disabling.
167 #if !defined(__VISUALC__) || defined(__WIN16__) || defined(UNICODE)
168 #undef wxUSE_ON_FATAL_EXCEPTION
169 #define wxUSE_ON_FATAL_EXCEPTION 0
172 #if wxUSE_ON_FATAL_EXCEPTION
173 static bool gs_handleExceptions
= FALSE
;
176 // ===========================================================================
178 // ===========================================================================
180 // ---------------------------------------------------------------------------
182 // ---------------------------------------------------------------------------
184 IMPLEMENT_DYNAMIC_CLASS(wxApp
, wxEvtHandler
)
186 BEGIN_EVENT_TABLE(wxApp
, wxEvtHandler
)
187 EVT_IDLE(wxApp::OnIdle
)
188 EVT_END_SESSION(wxApp::OnEndSession
)
189 EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession
)
193 bool wxApp::Initialize()
195 // the first thing to do is to check if we're trying to run an Unicode
196 // program under Win9x - if so, abort right now as it has no chance to
199 if ( wxGetOsVersion() != wxWINDOWS_NT
)
201 // note that we can use MessageBoxW() as it's implemented even under
202 // Win9x - OTOH, we can't use wxGetTranslation() because the file APIs
203 // used by wxLocale are not
207 _T("This program uses Unicode and requires Windows NT/2000.\nProgram aborted."),
208 _T("wxWindows Fatal Error"),
214 #endif // wxUSE_UNICODE
216 // Some people may wish to use this, but
217 // probably it shouldn't be here by default.
219 // wxRedirectIOToConsole();
222 wxBuffer
= new wxChar
[1500]; // FIXME
224 wxClassInfo::InitializeClasses();
227 wxPendingEventsLocker
= new wxCriticalSection
;
230 wxTheColourDatabase
= new wxColourDatabase(wxKEY_STRING
);
231 wxTheColourDatabase
->Initialize();
233 wxInitializeStockLists();
234 wxInitializeStockObjects();
236 #if wxUSE_WX_RESOURCES
237 wxInitializeResourceSystem();
240 wxBitmap::InitStandardHandlers();
242 #if defined(__WIN95__) && !defined(__WXMICROWIN__)
243 InitCommonControls();
246 #if wxUSE_OLE || wxUSE_DRAG_AND_DROP
249 // for OLE, enlarge message queue to be as large as possible
251 while (!SetMessageQueue(iMsg
) && (iMsg
-= 8))
255 // we need to initialize OLE library
256 if ( FAILED(::OleInitialize(NULL
)) )
257 wxLogError(_("Cannot initialize OLE"));
262 if (!Ctl3dRegister(wxhInstance
))
263 wxLogError(wxT("Cannot register CTL3D"));
265 Ctl3dAutoSubclass(wxhInstance
);
266 #endif // wxUSE_CTL3D
268 // VZ: these icons are not in wx.rc anyhow (but should they?)!
270 wxSTD_FRAME_ICON
= LoadIcon(wxhInstance
, wxT("wxSTD_FRAME"));
271 wxSTD_MDIPARENTFRAME_ICON
= LoadIcon(wxhInstance
, wxT("wxSTD_MDIPARENTFRAME"));
272 wxSTD_MDICHILDFRAME_ICON
= LoadIcon(wxhInstance
, wxT("wxSTD_MDICHILDFRAME"));
274 wxDEFAULT_FRAME_ICON
= LoadIcon(wxhInstance
, wxT("wxDEFAULT_FRAME"));
275 wxDEFAULT_MDIPARENTFRAME_ICON
= LoadIcon(wxhInstance
, wxT("wxDEFAULT_MDIPARENTFRAME"));
276 wxDEFAULT_MDICHILDFRAME_ICON
= LoadIcon(wxhInstance
, wxT("wxDEFAULT_MDICHILDFRAME"));
279 RegisterWindowClasses();
281 #ifndef __WXMICROWIN__
282 // Create the brush for disabling bitmap buttons
285 lb
.lbStyle
= BS_PATTERN
;
286 lb
.lbHatch
= (int)LoadBitmap( wxhInstance
, wxT("wxDISABLE_BUTTON_BITMAP") );
289 wxDisableButtonBrush
= ::CreateBrushIndirect( & lb
);
290 ::DeleteObject( (HGDIOBJ
)lb
.lbHatch
);
292 //else: wxWindows resources are probably not linked in
299 wxWinHandleList
= new wxList(wxKEY_INTEGER
);
301 // This is to foil optimizations in Visual C++ that throw out dummy.obj.
302 // PLEASE DO NOT ALTER THIS.
303 #if defined(__VISUALC__) && defined(__WIN16__) && !defined(WXMAKINGDLL)
304 extern char wxDummyChar
;
305 if (wxDummyChar
) wxDummyChar
++;
308 #ifndef __WXMICROWIN__
309 wxSetKeyboardHook(TRUE
);
312 wxModule::RegisterModules();
313 if (!wxModule::InitializeModules())
318 // ---------------------------------------------------------------------------
319 // RegisterWindowClasses
320 // ---------------------------------------------------------------------------
322 // TODO we should only register classes really used by the app. For this it
323 // would be enough to just delay the class registration until an attempt
324 // to create a window of this class is made.
325 bool wxApp::RegisterWindowClasses()
329 // for each class we register one with CS_(V|H)REDRAW style and one
330 // without for windows created with wxNO_FULL_REDRAW_ON_REPAINT flag
331 static const long styleNormal
= CS_HREDRAW
| CS_VREDRAW
| CS_DBLCLKS
;
332 static const long styleNoRedraw
= CS_DBLCLKS
;
334 // the fields which are common to all classes
335 wndclass
.lpfnWndProc
= (WNDPROC
)wxWndProc
;
336 wndclass
.cbClsExtra
= 0;
337 wndclass
.cbWndExtra
= sizeof( DWORD
); // VZ: what is this DWORD used for?
338 wndclass
.hInstance
= wxhInstance
;
339 wndclass
.hIcon
= (HICON
) NULL
;
340 wndclass
.hCursor
= ::LoadCursor((HINSTANCE
)NULL
, IDC_ARROW
);
341 wndclass
.lpszMenuName
= NULL
;
343 // Register the frame window class.
344 wndclass
.hbrBackground
= (HBRUSH
)(COLOR_APPWORKSPACE
+ 1);
345 wndclass
.lpszClassName
= wxFrameClassName
;
346 wndclass
.style
= styleNormal
;
348 if ( !RegisterClass(&wndclass
) )
350 wxLogLastError(wxT("RegisterClass(frame)"));
356 wndclass
.lpszClassName
= wxFrameClassNameNoRedraw
;
357 wndclass
.style
= styleNoRedraw
;
359 if ( !RegisterClass(&wndclass
) )
361 wxLogLastError(wxT("RegisterClass(no redraw frame)"));
366 // Register the MDI frame window class.
367 wndclass
.hbrBackground
= (HBRUSH
)NULL
; // paint MDI frame ourselves
368 wndclass
.lpszClassName
= wxMDIFrameClassName
;
369 wndclass
.style
= styleNormal
;
371 if ( !RegisterClass(&wndclass
) )
373 wxLogLastError(wxT("RegisterClass(MDI parent)"));
378 // "no redraw" MDI frame
379 wndclass
.lpszClassName
= wxMDIFrameClassNameNoRedraw
;
380 wndclass
.style
= styleNoRedraw
;
382 if ( !RegisterClass(&wndclass
) )
384 wxLogLastError(wxT("RegisterClass(no redraw MDI parent frame)"));
389 // Register the MDI child frame window class.
390 wndclass
.hbrBackground
= (HBRUSH
)(COLOR_WINDOW
+ 1);
391 wndclass
.lpszClassName
= wxMDIChildFrameClassName
;
392 wndclass
.style
= styleNormal
;
394 if ( !RegisterClass(&wndclass
) )
396 wxLogLastError(wxT("RegisterClass(MDI child)"));
401 // "no redraw" MDI child frame
402 wndclass
.lpszClassName
= wxMDIChildFrameClassNameNoRedraw
;
403 wndclass
.style
= styleNoRedraw
;
405 if ( !RegisterClass(&wndclass
) )
407 wxLogLastError(wxT("RegisterClass(no redraw MDI child)"));
412 // Register the panel window class.
413 wndclass
.hbrBackground
= (HBRUSH
) GetStockObject( LTGRAY_BRUSH
);
414 wndclass
.lpszClassName
= wxPanelClassName
;
415 wndclass
.style
= styleNormal
;
417 if ( !RegisterClass(&wndclass
) )
419 wxLogLastError(wxT("RegisterClass(panel)"));
424 // Register the no redraw panel window class.
425 wndclass
.lpszClassName
= wxPanelClassNameNR
;
426 wndclass
.style
= styleNoRedraw
;
428 if ( !RegisterClass(&wndclass
) )
430 wxLogLastError(wxT("RegisterClass(no redraw panel)"));
435 // Register the canvas and textsubwindow class name
436 wndclass
.hbrBackground
= (HBRUSH
)NULL
;
437 wndclass
.lpszClassName
= wxCanvasClassName
;
439 if ( !RegisterClass(&wndclass
) )
441 wxLogLastError(wxT("RegisterClass(canvas)"));
446 wndclass
.lpszClassName
= wxCanvasClassNameNR
;
447 wndclass
.style
= styleNoRedraw
;
448 if ( !RegisterClass(&wndclass
) )
450 wxLogLastError(wxT("RegisterClass(no redraw canvas)"));
458 // ---------------------------------------------------------------------------
459 // UnregisterWindowClasses
460 // ---------------------------------------------------------------------------
462 bool wxApp::UnregisterWindowClasses()
466 // frame window class.
467 if ( !UnregisterClass(wxFrameClassName
, wxhInstance
) )
469 wxLogLastError(wxT("UnregisterClass(frame)"));
475 if ( !UnregisterClass(wxFrameClassNameNoRedraw
, wxhInstance
) )
477 wxLogLastError(wxT("UnregisterClass(no redraw frame)"));
482 // MDI frame window class.
483 if ( !UnregisterClass(wxMDIFrameClassName
, wxhInstance
) )
485 wxLogLastError(wxT("UnregisterClass(MDI parent)"));
490 // "no redraw" MDI frame
491 if ( !UnregisterClass(wxMDIFrameClassNameNoRedraw
, wxhInstance
) )
493 wxLogLastError(wxT("UnregisterClass(no redraw MDI parent frame)"));
498 // MDI child frame window class.
499 if ( !UnregisterClass(wxMDIChildFrameClassName
, wxhInstance
) )
501 wxLogLastError(wxT("UnregisterClass(MDI child)"));
506 // "no redraw" MDI child frame
507 if ( !UnregisterClass(wxMDIChildFrameClassNameNoRedraw
, wxhInstance
) )
509 wxLogLastError(wxT("UnregisterClass(no redraw MDI child)"));
514 // panel window class.
515 if ( !UnregisterClass(wxPanelClassName
, wxhInstance
) )
517 wxLogLastError(wxT("UnregisterClass(panel)"));
522 // no redraw panel window class.
523 if ( !UnregisterClass(wxPanelClassNameNR
, wxhInstance
) )
525 wxLogLastError(wxT("UnregisterClass(no redraw panel)"));
530 // canvas and textsubwindow class name
531 if ( !UnregisterClass(wxCanvasClassName
, wxhInstance
) )
533 wxLogLastError(wxT("UnregisterClass(canvas)"));
538 if ( !UnregisterClass(wxCanvasClassNameNR
, wxhInstance
) )
540 wxLogLastError(wxT("UnregisterClass(no redraw canvas)"));
548 // ---------------------------------------------------------------------------
549 // Convert Windows to argc, argv style
550 // ---------------------------------------------------------------------------
552 void wxApp::ConvertToStandardCommandArgs(char* lpCmdLine
)
556 wxString
cmdLine(lpCmdLine
);
559 // Get application name
560 wxChar name
[260]; // 260 is MAX_PATH value from windef.h
561 ::GetModuleFileName(wxhInstance
, name
, WXSIZEOF(name
));
566 wxStrcpy(name
, wxFileNameFromPath(name
));
567 wxStripExtension(name
);
568 wxTheApp
->SetAppName(name
);
571 // Treat strings enclosed in double-quotes as single arguments
573 int len
= cmdLine
.Length();
577 while ((i
< len
) && wxIsspace(cmdLine
.GetChar(i
)))
582 if (cmdLine
.GetChar(i
) == wxT('"')) // We found the start of a string
586 while ((i
< len
) && (cmdLine
.GetChar(i
) != wxT('"')))
589 wxString
arg(cmdLine
.Mid(first
, (i
- first
)));
595 i
++; // Skip past 2nd quote
597 else // Unquoted argument
600 while ((i
< len
) && !wxIsspace(cmdLine
.GetChar(i
)))
603 wxString
arg(cmdLine
.Mid(first
, (i
- first
)));
611 wxTheApp
->argv
= new wxChar
*[count
+ 1];
612 for (i
= 0; i
< count
; i
++)
614 wxString
arg(args
[i
]);
615 wxTheApp
->argv
[i
] = copystring((const wxChar
*)arg
);
617 wxTheApp
->argv
[count
] = NULL
; // argv[] is a NULL-terminated list
618 wxTheApp
->argc
= count
;
621 //// Cleans up any wxWindows internal structures left lying around
623 void wxApp::CleanUp()
628 // flush the logged messages if any and install a 'safer' log target: the
629 // default one (wxLogGui) can't be used after the resources are freed just
630 // below and the user suppliedo ne might be even more unsafe (using any
631 // wxWindows GUI function is unsafe starting from now)
632 wxLog::DontCreateOnDemand();
634 // this will flush the old messages if any
635 delete wxLog::SetActiveTarget(new wxLogStderr
);
638 // One last chance for pending objects to be cleaned up
639 wxTheApp
->DeletePendingObjects();
641 wxModule::CleanUpModules();
643 #if wxUSE_WX_RESOURCES
644 wxCleanUpResourceSystem();
646 // wxDefaultResourceTable->ClearTable();
649 wxDeleteStockObjects();
651 // Destroy all GDI lists, etc.
652 wxDeleteStockLists();
654 delete wxTheColourDatabase
;
655 wxTheColourDatabase
= NULL
;
657 wxBitmap::CleanUpHandlers();
662 //// WINDOWS-SPECIFIC CLEANUP
664 #ifndef __WXMICROWIN__
665 wxSetKeyboardHook(FALSE
);
672 if (wxSTD_FRAME_ICON
)
673 DestroyIcon(wxSTD_FRAME_ICON
);
674 if (wxSTD_MDICHILDFRAME_ICON
)
675 DestroyIcon(wxSTD_MDICHILDFRAME_ICON
);
676 if (wxSTD_MDIPARENTFRAME_ICON
)
677 DestroyIcon(wxSTD_MDIPARENTFRAME_ICON
);
679 if (wxDEFAULT_FRAME_ICON
)
680 DestroyIcon(wxDEFAULT_FRAME_ICON
);
681 if (wxDEFAULT_MDICHILDFRAME_ICON
)
682 DestroyIcon(wxDEFAULT_MDICHILDFRAME_ICON
);
683 if (wxDEFAULT_MDIPARENTFRAME_ICON
)
684 DestroyIcon(wxDEFAULT_MDIPARENTFRAME_ICON
);
686 if ( wxDisableButtonBrush
)
687 ::DeleteObject( wxDisableButtonBrush
);
694 // for an EXE the classes are unregistered when it terminates but DLL may
695 // be loaded several times (load/unload/load) into the same process in
696 // which case the registration will fail after the first time if we don't
697 // unregister the classes now
698 UnregisterWindowClasses();
699 #endif // WXMAKINGDLL
702 Ctl3dUnregister(wxhInstance
);
706 delete wxWinHandleList
;
708 // GL: I'm annoyed ... I don't know where to put this and I don't want to
709 // create a module for that as it's part of the core.
710 delete wxPendingEvents
;
713 delete wxPendingEventsLocker
;
714 // If we don't do the following, we get an apparent memory leak
716 ((wxEvtHandler
&) wxDefaultValidator
).ClearEventLocker();
717 #endif // wxUSE_VALIDATORS
718 #endif // wxUSE_THREADS
720 wxClassInfo::CleanUpClasses();
725 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
726 // At this point we want to check if there are any memory
727 // blocks that aren't part of the wxDebugContext itself,
728 // as a special case. Then when dumping we need to ignore
729 // wxDebugContext, too.
730 if (wxDebugContext::CountObjectsLeft(TRUE
) > 0)
732 wxLogMessage(wxT("There were memory leaks."));
733 wxDebugContext::Dump();
734 wxDebugContext::PrintStatistics();
736 // wxDebugContext::SetStream(NULL, NULL);
740 // do it as the very last thing because everything else can log messages
741 delete wxLog::SetActiveTarget(NULL
);
745 //----------------------------------------------------------------------
746 // Entry point helpers, used by wxPython
747 //----------------------------------------------------------------------
749 int WXDLLEXPORT
wxEntryStart( int WXUNUSED(argc
), char** WXUNUSED(argv
) )
751 return wxApp::Initialize();
754 int WXDLLEXPORT
wxEntryInitGui()
756 return wxTheApp
->OnInitGui();
759 void WXDLLEXPORT
wxEntryCleanup()
765 #if !defined(_WINDLL) || (defined(_WINDLL) && defined(WXMAKINGDLL))
767 // temporarily disable this warning which would be generated in release builds
770 #pragma warning(disable: 4715) // not all control paths return a value
773 //----------------------------------------------------------------------
774 // Main wxWindows entry point
775 //----------------------------------------------------------------------
776 int wxEntry(WXHINSTANCE hInstance
,
777 WXHINSTANCE
WXUNUSED(hPrevInstance
),
782 // do check for memory leaks on program exit
783 // (another useful flag is _CRTDBG_DELAY_FREE_MEM_DF which doesn't free
784 // deallocated memory which may be used to simulate low-memory condition)
785 #ifndef __WXMICROWIN__
786 wxCrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF
);
790 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
791 // This seems to be necessary since there are 'rogue'
792 // objects present at this point (perhaps global objects?)
793 // Setting a checkpoint will ignore them as far as the
794 // memory checking facility is concerned.
795 // Of course you may argue that memory allocated in globals should be
796 // checked, but this is a reasonable compromise.
797 wxDebugContext::SetCheckpoint();
801 // take everything into a try-except block to be able to call
802 // OnFatalException() if necessary
803 #if wxUSE_ON_FATAL_EXCEPTION
806 wxhInstance
= (HINSTANCE
) hInstance
;
808 if (!wxEntryStart(0,0))
811 // create the application object or ensure that one already exists
814 // The app may have declared a global application object, but we recommend
815 // the IMPLEMENT_APP macro is used instead, which sets an initializer
816 // function for delayed, dynamic app object construction.
817 wxCHECK_MSG( wxApp::GetInitializerFunction(), 0,
818 wxT("No initializer - use IMPLEMENT_APP macro.") );
820 wxTheApp
= (wxApp
*) (*wxApp::GetInitializerFunction()) ();
823 wxCHECK_MSG( wxTheApp
, 0, wxT("You have to define an instance of wxApp!") );
825 // save the WinMain() parameters
826 wxTheApp
->ConvertToStandardCommandArgs(lpCmdLine
);
827 wxTheApp
->m_nCmdShow
= nCmdShow
;
829 // We really don't want timestamps by default, because it means
830 // we can't simply double-click on the error message and get to that
831 // line in the source. So VC++ at least, let's have a sensible default.
833 wxLog::SetTimestamp(NULL
);
838 // it is common to create a modal dialog in OnInit() (to ask/notify the
839 // user about something) but it wouldn't work if we don't change the
840 // "exit on delete last frame" flag here as when this dialog is
841 // deleted, the app would terminate (it was the last top level window
842 // as the main frame wasn't created yet!), so disable this behaviour
844 bool exitOnLastFrameDelete
= wxTheApp
->GetExitOnFrameDelete();
845 wxTheApp
->SetExitOnFrameDelete(FALSE
);
848 retValue
= wxEntryInitGui() && wxTheApp
->OnInit() ? 0 : -1;
850 // restore the old flag value
851 wxTheApp
->SetExitOnFrameDelete(exitOnLastFrameDelete
);
858 retValue
= wxTheApp
->OnRun();
862 // we want to initialize, but not run or exit immediately.
866 //else: app initialization failed, so we skipped OnRun()
868 wxWindow
*topWindow
= wxTheApp
->GetTopWindow();
871 // Forcibly delete the window.
872 if ( topWindow
->IsKindOf(CLASSINFO(wxFrame
)) ||
873 topWindow
->IsKindOf(CLASSINFO(wxDialog
)) )
875 topWindow
->Close(TRUE
);
876 wxTheApp
->DeletePendingObjects();
881 wxTheApp
->SetTopWindow(NULL
);
891 #if wxUSE_ON_FATAL_EXCEPTION
893 __except ( gs_handleExceptions
? EXCEPTION_EXECUTE_HANDLER
894 : EXCEPTION_CONTINUE_SEARCH
) {
897 // give the user a chance to do something special about this
898 wxTheApp
->OnFatalException();
901 ::ExitProcess(3); // the same exit code as abort()
905 #endif // wxUSE_ON_FATAL_EXCEPTION
908 // restore warning state
910 #pragma warning(default: 4715) // not all control paths return a value
915 //----------------------------------------------------------------------
916 // Entry point for wxWindows + the App in a DLL
917 //----------------------------------------------------------------------
919 int wxEntry(WXHINSTANCE hInstance
)
921 wxhInstance
= (HINSTANCE
) hInstance
;
924 // The app may have declared a global application object, but we recommend
925 // the IMPLEMENT_APP macro is used instead, which sets an initializer function
926 // for delayed, dynamic app object construction.
929 wxCHECK_MSG( wxApp::GetInitializerFunction(), 0,
930 "No initializer - use IMPLEMENT_APP macro." );
932 wxTheApp
= (* wxApp::GetInitializerFunction()) ();
935 wxCHECK_MSG( wxTheApp
, 0, "You have to define an instance of wxApp!" );
938 wxTheApp
->argv
= NULL
;
944 wxWindow
*topWindow
= wxTheApp
->GetTopWindow();
945 if ( topWindow
&& topWindow
->GetHWND())
947 topWindow
->Show(TRUE
);
954 //// Static member initialization
956 wxAppInitializerFunction
wxAppBase::m_appInitFn
= (wxAppInitializerFunction
) NULL
;
962 m_printMode
= wxPRINT_WINDOWS
;
968 // Delete command-line args
970 for (i
= 0; i
< argc
; i
++)
977 bool wxApp::Initialized()
984 #else // Assume initialized if DLL (no way of telling)
990 * Get and process a message, returning FALSE if WM_QUIT
991 * received (and also set the flag telling the app to exit the main loop)
994 bool wxApp::DoMessage()
996 BOOL rc
= ::GetMessage(&s_currentMsg
, (HWND
) NULL
, 0, 0);
1000 m_keepGoing
= FALSE
;
1004 else if ( rc
== -1 )
1006 // should never happen, but let's test for it nevertheless
1007 wxLogLastError(wxT("GetMessage"));
1012 wxASSERT_MSG( wxThread::IsMain(),
1013 wxT("only the main thread can process Windows messages") );
1015 static bool s_hadGuiLock
= TRUE
;
1016 static wxMsgArray s_aSavedMessages
;
1018 // if a secondary thread owns is doing GUI calls, save all messages for
1019 // later processing - we can't process them right now because it will
1020 // lead to recursive library calls (and we're not reentrant)
1021 if ( !wxGuiOwnedByMainThread() )
1023 s_hadGuiLock
= FALSE
;
1025 // leave out WM_COMMAND messages: too dangerous, sometimes
1026 // the message will be processed twice
1027 if ( !wxIsWaitingForThread() ||
1028 s_currentMsg
.message
!= WM_COMMAND
)
1030 s_aSavedMessages
.Add(s_currentMsg
);
1037 // have we just regained the GUI lock? if so, post all of the saved
1040 // FIXME of course, it's not _exactly_ the same as processing the
1041 // messages normally - expect some things to break...
1042 if ( !s_hadGuiLock
)
1044 s_hadGuiLock
= TRUE
;
1046 size_t count
= s_aSavedMessages
.Count();
1047 for ( size_t n
= 0; n
< count
; n
++ )
1049 MSG
& msg
= s_aSavedMessages
[n
];
1051 if ( !ProcessMessage((WXMSG
*)&msg
) )
1053 ::TranslateMessage(&msg
);
1054 ::DispatchMessage(&msg
);
1058 s_aSavedMessages
.Empty();
1061 #endif // wxUSE_THREADS
1063 // Process the message
1064 DoMessage((WXMSG
*)&s_currentMsg
);
1070 void wxApp::DoMessage(WXMSG
*pMsg
)
1072 if ( !ProcessMessage(pMsg
) )
1074 ::TranslateMessage((MSG
*)pMsg
);
1075 ::DispatchMessage((MSG
*)pMsg
);
1080 * Keep trying to process messages until WM_QUIT
1083 * If there are messages to be processed, they will all be
1084 * processed and OnIdle will not be called.
1085 * When there are no more messages, OnIdle is called.
1086 * If OnIdle requests more time,
1087 * it will be repeatedly called so long as there are no pending messages.
1088 * A 'feature' of this is that once OnIdle has decided that no more processing
1089 * is required, then it won't get processing time until further messages
1090 * are processed (it'll sit in DoMessage).
1093 int wxApp::MainLoop()
1097 while ( m_keepGoing
)
1100 wxMutexGuiLeaveOrEnter();
1101 #endif // wxUSE_THREADS
1103 while ( !Pending() && ProcessIdle() )
1106 // a message came or no more idle processing to do
1110 return s_currentMsg
.wParam
;
1113 // Returns TRUE if more time is needed.
1114 bool wxApp::ProcessIdle()
1117 event
.SetEventObject(this);
1118 ProcessEvent(event
);
1120 return event
.MoreRequested();
1123 void wxApp::ExitMainLoop()
1125 // VZ: why not ::PostQuitMessage()?
1126 m_keepGoing
= FALSE
;
1129 bool wxApp::Pending()
1131 return ::PeekMessage(&s_currentMsg
, 0, 0, 0, PM_NOREMOVE
) != 0;
1134 void wxApp::Dispatch()
1140 * Give all windows a chance to preprocess
1141 * the message. Some may have accelerator tables, or have
1142 * MDI complications.
1145 bool wxApp::ProcessMessage(WXMSG
*wxmsg
)
1147 MSG
*msg
= (MSG
*)wxmsg
;
1148 HWND hwnd
= msg
->hwnd
;
1149 wxWindow
*wndThis
= wxGetWindowFromHWND((WXHWND
)hwnd
);
1151 // this may happen if the event occured in a standard modeless dialog (the
1152 // only example of which I know of is the find/replace dialog) - then call
1153 // IsDialogMessage() to make TAB navigation in it work
1156 // we need to find the dialog containing this control as
1157 // IsDialogMessage() just eats all the messages (i.e. returns TRUE for
1158 // them) if we call it for the control itself
1159 while ( ::GetWindowLong(hwnd
, GWL_STYLE
) & WS_CHILD
)
1161 hwnd
= ::GetParent(hwnd
);
1164 return ::IsDialogMessage(hwnd
, msg
) != 0;
1168 // we must relay WM_MOUSEMOVE events to the tooltip ctrl if we want it to
1169 // popup the tooltip bubbles
1170 if ( (msg
->message
== WM_MOUSEMOVE
) )
1172 wxToolTip
*tt
= wndThis
->GetToolTip();
1175 tt
->RelayEvent(wxmsg
);
1178 #endif // wxUSE_TOOLTIPS
1180 // allow the window to prevent certain messages from being
1181 // translated/processed (this is currently used by wxTextCtrl to always
1182 // grab Ctrl-C/V/X, even if they are also accelerators in some parent)
1183 if ( !wndThis
->MSWShouldPreProcessMessage(wxmsg
) )
1188 // try translations first: the accelerators override everything
1191 for ( wnd
= wndThis
; wnd
; wnd
= wnd
->GetParent() )
1193 if ( wnd
->MSWTranslateMessage(wxmsg
))
1196 // stop at first top level window, i.e. don't try to process the key
1197 // strokes originating in a dialog using the accelerators of the parent
1198 // frame - this doesn't make much sense
1199 if ( wnd
->IsTopLevel() )
1203 // now try the other hooks (kbd navigation is handled here): we start from
1204 // wndThis->GetParent() because wndThis->MSWProcessMessage() was already
1206 for ( wnd
= wndThis
->GetParent(); wnd
; wnd
= wnd
->GetParent() )
1208 if ( wnd
->MSWProcessMessage(wxmsg
) )
1212 // no special preprocessing for this message, dispatch it normally
1216 void wxApp::OnIdle(wxIdleEvent
& event
)
1218 static bool s_inOnIdle
= FALSE
;
1220 // Avoid recursion (via ProcessEvent default case)
1226 // If there are pending events, we must process them: pending events
1227 // are either events to the threads other than main or events posted
1228 // with wxPostEvent() functions
1229 // GRG: I have moved this here so that all pending events are processed
1230 // before starting to delete any objects. This behaves better (in
1231 // particular, wrt wxPostEvent) and is coherent with wxGTK's current
1232 // behaviour. Changed Feb/2000 before 2.1.14
1233 ProcessPendingEvents();
1235 // 'Garbage' collection of windows deleted with Close().
1236 DeletePendingObjects();
1239 // flush the logged messages if any
1240 wxLog::FlushActive();
1243 #if wxUSE_DC_CACHEING
1244 // automated DC cache management: clear the cached DCs and bitmap
1245 // if it's likely that the app has finished with them, that is, we
1246 // get an idle event and we're not dragging anything.
1247 if (!::GetKeyState(MK_LBUTTON
) && !::GetKeyState(MK_MBUTTON
) && !::GetKeyState(MK_RBUTTON
))
1249 #endif // wxUSE_DC_CACHEING
1251 // Send OnIdle events to all windows
1252 if ( SendIdleEvents() )
1254 // SendIdleEvents() returns TRUE if at least one window requested more
1256 event
.RequestMore(TRUE
);
1262 // Send idle event to all top-level windows
1263 bool wxApp::SendIdleEvents()
1265 bool needMore
= FALSE
;
1267 wxWindowList::Node
* node
= wxTopLevelWindows
.GetFirst();
1270 wxWindow
* win
= node
->GetData();
1271 if (SendIdleEvents(win
))
1273 node
= node
->GetNext();
1279 // Send idle event to window and all subwindows
1280 bool wxApp::SendIdleEvents(wxWindow
* win
)
1282 bool needMore
= FALSE
;
1285 event
.SetEventObject(win
);
1286 win
->GetEventHandler()->ProcessEvent(event
);
1288 if (event
.MoreRequested())
1291 wxNode
* node
= win
->GetChildren().First();
1294 wxWindow
* win
= (wxWindow
*) node
->Data();
1295 if (SendIdleEvents(win
))
1298 node
= node
->Next();
1303 void wxApp::DeletePendingObjects()
1305 wxNode
*node
= wxPendingDelete
.First();
1308 wxObject
*obj
= (wxObject
*)node
->Data();
1312 if (wxPendingDelete
.Member(obj
))
1315 // Deleting one object may have deleted other pending
1316 // objects, so start from beginning of list again.
1317 node
= wxPendingDelete
.First();
1321 void wxApp::OnEndSession(wxCloseEvent
& WXUNUSED(event
))
1324 GetTopWindow()->Close(TRUE
);
1327 // Default behaviour: close the application with prompts. The
1328 // user can veto the close, and therefore the end session.
1329 void wxApp::OnQueryEndSession(wxCloseEvent
& event
)
1333 if (!GetTopWindow()->Close(!event
.CanVeto()))
1339 int wxApp::GetComCtl32Version()
1341 #ifdef __WXMICROWIN__
1345 static int s_verComCtl32
= -1;
1347 wxCRIT_SECT_DECLARE(csComCtl32
);
1348 wxCRIT_SECT_LOCKER(lock
, csComCtl32
);
1350 if ( s_verComCtl32
== -1 )
1352 // initally assume no comctl32.dll at all
1356 HMODULE hModuleComCtl32
= ::GetModuleHandle(wxT("COMCTL32"));
1358 // if so, then we can check for the version
1359 if ( hModuleComCtl32
)
1361 // try to use DllGetVersion() if available in _headers_
1362 #ifdef DLLVER_PLATFORM_WINDOWS // defined in shlwapi.h
1363 DLLGETVERSIONPROC pfnDllGetVersion
= (DLLGETVERSIONPROC
)
1364 ::GetProcAddress(hModuleComCtl32
, "DllGetVersion");
1365 if ( pfnDllGetVersion
)
1368 dvi
.cbSize
= sizeof(dvi
);
1370 HRESULT hr
= (*pfnDllGetVersion
)(&dvi
);
1373 wxLogApiError(_T("DllGetVersion"), hr
);
1377 // this is incompatible with _WIN32_IE values, but
1378 // compatible with the other values returned by
1379 // GetComCtl32Version()
1380 s_verComCtl32
= 100*dvi
.dwMajorVersion
+
1385 // DllGetVersion() unavailable either during compile or
1386 // run-time, try to guess the version otherwise
1387 if ( !s_verComCtl32
)
1389 // InitCommonControlsEx is unique to 4.70 and later
1390 FARPROC theProc
= ::GetProcAddress
1393 "InitCommonControlsEx"
1398 // not found, must be 4.00
1399 s_verComCtl32
= 400;
1403 // many symbols appeared in comctl32 4.71, could use
1404 // any of them except may be DllInstall
1405 theProc
= ::GetProcAddress
1412 // not found, must be 4.70
1413 s_verComCtl32
= 470;
1417 // found, must be 4.71
1418 s_verComCtl32
= 471;
1425 return s_verComCtl32
;
1431 wxLogError(_("Fatal error: exiting"));
1437 // Yield to incoming messages
1439 static bool gs_inYield
= FALSE
;
1443 // disable log flushing from here because a call to wxYield() shouldn't
1444 // normally result in message boxes popping up &c
1449 wxFAIL_MSG( wxT("wxYield called recursively" ) );
1454 // we don't want to process WM_QUIT from here - it should be processed in
1455 // the main event loop in order to stop it
1457 while ( PeekMessage(&msg
, (HWND
)0, 0, 0, PM_NOREMOVE
) &&
1458 msg
.message
!= WM_QUIT
)
1461 wxMutexGuiLeaveOrEnter();
1462 #endif // wxUSE_THREADS
1464 if ( !wxTheApp
->DoMessage() )
1468 // If they are pending events, we must process them.
1470 wxTheApp
->ProcessPendingEvents();
1472 // let the logs be flashed again
1480 // Yield to incoming messages; but fail silently if recursion is detected.
1481 bool wxYieldIfNeeded()
1489 bool wxHandleFatalExceptions(bool doit
)
1491 #if wxUSE_ON_FATAL_EXCEPTION
1492 // assume this can only be called from the main thread
1493 gs_handleExceptions
= doit
;
1497 wxFAIL_MSG(_T("set wxUSE_ON_FATAL_EXCEPTION to 1 to sue this function"));
1504 //-----------------------------------------------------------------------------
1506 //-----------------------------------------------------------------------------
1510 // Send the top window a dummy message so idle handler processing will
1511 // start up again. Doing it this way ensures that the idle handler
1512 // wakes up in the right thread (see also wxWakeUpMainThread() which does
1513 // the same for the main app thread only)
1514 wxWindow
*topWindow
= wxTheApp
->GetTopWindow();
1517 if ( !::PostMessage(GetHwndOf(topWindow
), WM_NULL
, 0, 0) )
1519 // should never happen
1520 wxLogLastError(wxT("PostMessage(WM_NULL)"));
1525 //-----------------------------------------------------------------------------
1528 wxApp::GetStdIcon(int which
) const
1532 case wxICON_INFORMATION
:
1533 return wxIcon("wxICON_INFO");
1535 case wxICON_QUESTION
:
1536 return wxIcon("wxICON_QUESTION");
1538 case wxICON_EXCLAMATION
:
1539 return wxIcon("wxICON_WARNING");
1542 wxFAIL_MSG(wxT("requested non existent standard icon"));
1543 // still fall through
1546 return wxIcon("wxICON_ERROR");
1550 // For some reason, with MSVC++ 1.5, WinMain isn't linked in properly
1551 // if in a separate file. So include it here to ensure it's linked.
1552 #if (defined(__VISUALC__) && !defined(__WIN32__)) || (defined(__GNUWIN32__) && !defined(__TWIN32__) && !defined(WXMAKINGDLL))