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"
48 #include "wx/msw/private.h"
50 #include "wx/module.h"
53 #include "wx/thread.h"
55 // define the array of MSG strutures
56 WX_DECLARE_OBJARRAY(MSG
, wxMsgArray
);
58 #include "wx/arrimpl.cpp"
60 WX_DEFINE_OBJARRAY(wxMsgArray
);
61 #endif // wxUSE_THREADS
63 #if wxUSE_WX_RESOURCES
64 #include "wx/resource.h"
67 // OLE is used for drag-and-drop, clipboard, OLE Automation...
68 #if defined(__GNUWIN32__) || defined(__SC__) || defined(__SALFORDC__)
72 #endif // broken compilers
81 #if (defined(__WIN95__) && !defined(__GNUWIN32__)) || defined(__TWIN32__)
85 #include "wx/msw/msvcrt.h"
87 // ---------------------------------------------------------------------------
89 // ---------------------------------------------------------------------------
91 extern char *wxBuffer
;
92 extern char *wxOsVersion
;
93 extern wxList
*wxWinHandleList
;
94 extern wxList WXDLLEXPORT wxPendingDelete
;
95 extern void wxSetKeyboardHook(bool doIt
);
96 extern wxCursor
*g_globalCursor
;
98 HINSTANCE wxhInstance
= 0;
99 static MSG s_currentMsg
;
100 wxApp
*wxTheApp
= NULL
;
102 // FIXME why not const? and not static?
103 char wxFrameClassName
[] = "wxFrameClass";
104 char wxMDIFrameClassName
[] = "wxMDIFrameClass";
105 char wxMDIChildFrameClassName
[] = "wxMDIChildFrameClass";
106 char wxPanelClassName
[] = "wxPanelClass";
107 char wxCanvasClassName
[] = "wxCanvasClass";
109 HICON wxSTD_FRAME_ICON
= (HICON
) NULL
;
110 HICON wxSTD_MDICHILDFRAME_ICON
= (HICON
) NULL
;
111 HICON wxSTD_MDIPARENTFRAME_ICON
= (HICON
) NULL
;
113 HICON wxDEFAULT_FRAME_ICON
= (HICON
) NULL
;
114 HICON wxDEFAULT_MDICHILDFRAME_ICON
= (HICON
) NULL
;
115 HICON wxDEFAULT_MDIPARENTFRAME_ICON
= (HICON
) NULL
;
117 HBRUSH wxDisableButtonBrush
= (HBRUSH
) 0;
119 LRESULT APIENTRY
wxWndProc(HWND
, UINT
, WPARAM
, LPARAM
);
121 #if defined(__WIN95__) && !defined(__TWIN32__)
122 #define wxUSE_RICHEDIT 1
124 #define wxUSE_RICHEDIT 0
128 static HINSTANCE gs_hRichEdit
= (HINSTANCE
) NULL
;
131 // ===========================================================================
133 // ===========================================================================
135 // ---------------------------------------------------------------------------
137 // ---------------------------------------------------------------------------
139 #if !USE_SHARED_LIBRARY
140 IMPLEMENT_DYNAMIC_CLASS(wxApp
, wxEvtHandler
)
142 BEGIN_EVENT_TABLE(wxApp
, wxEvtHandler
)
143 EVT_IDLE(wxApp::OnIdle
)
144 EVT_END_SESSION(wxApp::OnEndSession
)
145 EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession
)
149 long wxApp::sm_lastMessageTime
= 0;
152 bool wxApp::Initialize()
154 // Some people may wish to use this, but
155 // probably it shouldn't be here by default.
157 // wxRedirectIOToConsole();
160 wxBuffer
= new char[1500]; // FIXME
162 wxClassInfo::InitializeClasses();
165 wxGetResource("wxWindows", "OsVersion", &wxOsVersion
);
168 wxTheColourDatabase
= new wxColourDatabase(wxKEY_STRING
);
169 wxTheColourDatabase
->Initialize();
171 wxInitializeStockLists();
172 wxInitializeStockObjects();
174 #if wxUSE_WX_RESOURCES
175 wxInitializeResourceSystem();
178 wxBitmap::InitStandardHandlers();
180 #if defined(__WIN95__)
181 InitCommonControls();
184 gs_hRichEdit
= LoadLibrary("RICHED32.DLL");
186 if (gs_hRichEdit
== (HINSTANCE
) NULL
)
188 wxLogError(_("Could not initialise Rich Edit DLL"));
190 #endif // wxUSE_RICHEDIT
194 // for OLE, enlarge message queue to be as large as possible
196 while (!SetMessageQueue(iMsg
) && (iMsg
-= 8));
200 dwOleVer = CoBuildVersion();
202 // check the OLE library version
203 if (rmm != HIWORD(dwOleVer))
205 wxMessageBox("Incorrect version of OLE libraries.");
211 // we need to initialize OLE library
212 if ( FAILED(::OleInitialize(NULL
)) )
213 wxLogError(_("Cannot initialize OLE"));
217 if (!Ctl3dRegister(wxhInstance
))
218 wxLogError("Cannot register CTL3D");
220 Ctl3dAutoSubclass(wxhInstance
);
223 g_globalCursor
= new wxCursor
;
225 wxSTD_FRAME_ICON
= LoadIcon(wxhInstance
, "wxSTD_FRAME");
226 wxSTD_MDIPARENTFRAME_ICON
= LoadIcon(wxhInstance
, "wxSTD_MDIPARENTFRAME");
227 wxSTD_MDICHILDFRAME_ICON
= LoadIcon(wxhInstance
, "wxSTD_MDICHILDFRAME");
229 wxDEFAULT_FRAME_ICON
= LoadIcon(wxhInstance
, "wxDEFAULT_FRAME");
230 wxDEFAULT_MDIPARENTFRAME_ICON
= LoadIcon(wxhInstance
, "wxDEFAULT_MDIPARENTFRAME");
231 wxDEFAULT_MDICHILDFRAME_ICON
= LoadIcon(wxhInstance
, "wxDEFAULT_MDICHILDFRAME");
233 RegisterWindowClasses();
235 // Create the brush for disabling bitmap buttons
238 lb
.lbStyle
= BS_PATTERN
;
239 lb
.lbHatch
= (int)LoadBitmap( wxhInstance
, "wxDISABLE_BUTTON_BITMAP" ) ;
240 wxDisableButtonBrush
= ::CreateBrushIndirect( & lb
) ;
241 ::DeleteObject( (HGDIOBJ
)lb
.lbHatch
) ;
247 wxWinHandleList
= new wxList(wxKEY_INTEGER
);
249 // This is to foil optimizations in Visual C++ that throw out dummy.obj.
250 // PLEASE DO NOT ALTER THIS.
251 #if defined(__VISUALC__) && !defined(WXMAKINGDLL)
252 extern char wxDummyChar
;
253 if (wxDummyChar
) wxDummyChar
++;
256 wxSetKeyboardHook(TRUE
);
258 wxModule::RegisterModules();
259 if (!wxModule::InitializeModules())
264 //// RegisterWindowClasses
266 bool wxApp::RegisterWindowClasses()
268 ///////////////////////////////////////////////////////////////////////
269 // Register the frame window class.
270 WNDCLASS wndclass
; // Structure used to register Windows class.
272 wndclass
.style
= CS_HREDRAW
| CS_VREDRAW
| CS_DBLCLKS
;
273 wndclass
.lpfnWndProc
= (WNDPROC
)wxWndProc
;
274 wndclass
.cbClsExtra
= 0;
275 wndclass
.cbWndExtra
= sizeof( DWORD
); // was 4
276 wndclass
.hInstance
= wxhInstance
;
277 wndclass
.hIcon
= (HICON
) NULL
; // wxSTD_FRAME_ICON;
278 wndclass
.hCursor
= LoadCursor( (HINSTANCE
) NULL
, IDC_ARROW
);
279 wndclass
.hbrBackground
= (HBRUSH
)(COLOR_APPWORKSPACE
+1) ;
280 // wndclass.hbrBackground = GetStockObject( WHITE_BRUSH );
281 wndclass
.lpszMenuName
= NULL
;
282 #ifdef _MULTIPLE_INSTANCES
283 sprintf( wxFrameClassName
,"wxFrameClass%d", wxhInstance
);
285 wndclass
.lpszClassName
= wxFrameClassName
;
287 if (!RegisterClass( &wndclass
))
289 // wxFatalError("Can't register Frame Window class");
292 ///////////////////////////////////////////////////////////////////////
293 // Register the MDI frame window class.
294 WNDCLASS wndclass1
; // Structure used to register Windows class.
296 wndclass1
.style
= CS_HREDRAW
| CS_VREDRAW
| CS_DBLCLKS
;
297 wndclass1
.lpfnWndProc
= (WNDPROC
)wxWndProc
;
298 wndclass1
.cbClsExtra
= 0;
299 wndclass1
.cbWndExtra
= sizeof( DWORD
); // was 4
300 wndclass1
.hInstance
= wxhInstance
;
301 wndclass1
.hIcon
= (HICON
) NULL
; // wxSTD_MDIPARENTFRAME_ICON;
302 wndclass1
.hCursor
= LoadCursor( (HINSTANCE
) NULL
, IDC_ARROW
);
303 // wndclass1.hbrBackground = (HBRUSH)(COLOR_APPWORKSPACE+1) ;
304 wndclass1
.hbrBackground
= (HBRUSH
) NULL
;
305 wndclass1
.lpszMenuName
= NULL
;
307 wndclass1
.lpszClassName
= wxMDIFrameClassName
;
308 if (!RegisterClass( &wndclass1
))
310 // wxFatalError("Can't register MDI Frame window class");
314 ///////////////////////////////////////////////////////////////////////
315 // Register the MDI child frame window class.
316 WNDCLASS wndclass4
; // Structure used to register Windows class.
318 wndclass4
.style
= CS_HREDRAW
| CS_VREDRAW
| CS_DBLCLKS
;
319 wndclass4
.lpfnWndProc
= (WNDPROC
)wxWndProc
;
320 wndclass4
.cbClsExtra
= 0;
321 wndclass4
.cbWndExtra
= sizeof( DWORD
); // was 4
322 wndclass4
.hInstance
= wxhInstance
;
323 wndclass4
.hIcon
= (HICON
) NULL
; // wxSTD_MDICHILDFRAME_ICON;
324 wndclass4
.hCursor
= LoadCursor( (HINSTANCE
) NULL
, IDC_ARROW
);
325 // TODO: perhaps this should be NULL so that Windows doesn't
326 // paint the background itself (would OnEraseBackground duplicate
328 wndclass4
.hbrBackground
= (HBRUSH
)(COLOR_WINDOW
+1) ;
329 // wndclass4.hbrBackground = NULL;
330 wndclass4
.lpszMenuName
= NULL
;
331 wndclass4
.lpszClassName
= wxMDIChildFrameClassName
;
333 if (!RegisterClass( &wndclass4
))
335 // wxFatalError("Can't register MDI child frame window class");
339 ///////////////////////////////////////////////////////////////////////
340 // Register the panel window class.
341 WNDCLASS wndclass2
; // Structure used to register Windows class.
342 memset(&wndclass2
, 0, sizeof(WNDCLASS
)); // start with NULL defaults
343 wndclass2
.style
= CS_HREDRAW
| CS_VREDRAW
| CS_DBLCLKS
;
344 wndclass2
.lpfnWndProc
= (WNDPROC
)wxWndProc
;
345 wndclass2
.cbClsExtra
= 0;
346 wndclass2
.cbWndExtra
= sizeof( DWORD
); // was 4
347 wndclass2
.hInstance
= wxhInstance
;
348 wndclass2
.hIcon
= (HICON
) NULL
;
349 wndclass2
.hCursor
= LoadCursor( (HINSTANCE
) NULL
, IDC_ARROW
);
350 // wndclass2.hbrBackground = (HBRUSH)(COLOR_BTNFACE+1) ;
351 wndclass2
.hbrBackground
= (HBRUSH
) GetStockObject( LTGRAY_BRUSH
);
352 wndclass2
.lpszMenuName
= NULL
;
353 wndclass2
.lpszClassName
= wxPanelClassName
;
354 if (!RegisterClass( &wndclass2
))
356 // wxFatalError("Can't register Panel Window class");
360 ///////////////////////////////////////////////////////////////////////
361 // Register the canvas and textsubwindow class name
362 WNDCLASS wndclass3
; // Structure used to register Windows class.
363 memset(&wndclass3
, 0, sizeof(WNDCLASS
)); // start with NULL defaults
364 // Use CS_OWNDC to avoid messing about restoring the context
365 // for every graphic operation.
366 // wndclass3.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC | CS_DBLCLKS ;
368 wndclass3
.style
= CS_HREDRAW
| CS_VREDRAW
| CS_DBLCLKS
;
369 wndclass3
.lpfnWndProc
= (WNDPROC
)wxWndProc
;
370 wndclass3
.cbClsExtra
= 0;
371 wndclass3
.cbWndExtra
= sizeof( DWORD
); // was 4
372 wndclass3
.hInstance
= wxhInstance
;
373 wndclass3
.hIcon
= (HICON
) NULL
;
374 wndclass3
.hCursor
= LoadCursor( (HINSTANCE
) NULL
, IDC_ARROW
);
375 // wndclass3.hbrBackground = (HBRUSH)(COLOR_WINDOW+1) ;
376 wndclass3
.hbrBackground
= (HBRUSH
) NULL
;
377 wndclass3
.lpszMenuName
= NULL
;
378 wndclass3
.lpszClassName
= wxCanvasClassName
;
379 if (!RegisterClass( &wndclass3
))
381 // wxFatalError("Can't register Canvas class");
388 //// Convert Windows to argc, argv style
390 void wxApp::ConvertToStandardCommandArgs(char* lpCmdLine
)
394 wxString
cmdLine(lpCmdLine
);
397 // Get application name
398 char name
[260]; // 260 is MAX_PATH value from windef.h
399 ::GetModuleFileName(wxhInstance
, name
, WXSIZEOF(name
));
401 // GNUWIN32 already fills in the first arg with the application name.
402 // JACS: apparently not now (b20 and above?)
403 #if 0 // !defined(__GNUWIN32__)
408 strcpy(name
, wxFileNameFromPath(name
));
409 wxStripExtension(name
);
410 wxTheApp
->SetAppName(name
);
413 // Treat strings enclosed in double-quotes as single arguments
415 int len
= cmdLine
.Length();
419 while ((i
< len
) && isspace(cmdLine
.GetChar(i
)))
424 if (cmdLine
.GetChar(i
) == '"') // We found the start of a string
428 while ((i
< len
) && (cmdLine
.GetChar(i
) != '"'))
431 wxString
arg(cmdLine
.Mid(first
, (i
- first
)));
437 i
++; // Skip past 2nd quote
439 else // Unquoted argument
442 while ((i
< len
) && !isspace(cmdLine
.GetChar(i
)))
445 wxString
arg(cmdLine
.Mid(first
, (i
- first
)));
453 wxTheApp
->argv
= new char*[count
+ 1];
454 for (i
= 0; i
< count
; i
++)
456 wxString
arg(args
[i
]);
457 wxTheApp
->argv
[i
] = copystring((const char*)arg
);
459 wxTheApp
->argv
[count
] = NULL
; // argv[] is a NULL-terminated list
460 wxTheApp
->argc
= count
;
463 //// Cleans up any wxWindows internal structures left lying around
465 void wxApp::CleanUp()
469 // flush the logged messages if any and install a 'safer' log target: the
470 // default one (wxLogGui) can't be used after the resources are freed just
471 // below and the user suppliedo ne might be even more unsafe (using any
472 // wxWindows GUI function is unsafe starting from now)
473 wxLog::DontCreateOnDemand();
475 // this will flush the old messages if any
476 delete wxLog::SetActiveTarget(new wxLogStderr
);
478 // One last chance for pending objects to be cleaned up
479 wxTheApp
->DeletePendingObjects();
481 wxModule::CleanUpModules();
483 #if wxUSE_WX_RESOURCES
484 wxCleanUpResourceSystem();
486 // wxDefaultResourceTable->ClearTable();
489 // Indicate that the cursor can be freed, so that cursor won't be deleted
490 // by deleting the bitmap list before g_globalCursor goes out of scope
491 // (double deletion of the cursor).
492 wxSetCursor(wxNullCursor
);
493 delete g_globalCursor
;
494 g_globalCursor
= NULL
;
496 wxDeleteStockObjects() ;
498 // Destroy all GDI lists, etc.
499 wxDeleteStockLists();
501 delete wxTheColourDatabase
;
502 wxTheColourDatabase
= NULL
;
504 wxBitmap::CleanUpHandlers();
509 //// WINDOWS-SPECIFIC CLEANUP
511 wxSetKeyboardHook(FALSE
);
516 if (gs_hRichEdit
!= (HINSTANCE
) NULL
)
517 FreeLibrary(gs_hRichEdit
);
526 if (wxSTD_FRAME_ICON
)
527 DestroyIcon(wxSTD_FRAME_ICON
);
528 if (wxSTD_MDICHILDFRAME_ICON
)
529 DestroyIcon(wxSTD_MDICHILDFRAME_ICON
);
530 if (wxSTD_MDIPARENTFRAME_ICON
)
531 DestroyIcon(wxSTD_MDIPARENTFRAME_ICON
);
533 if (wxDEFAULT_FRAME_ICON
)
534 DestroyIcon(wxDEFAULT_FRAME_ICON
);
535 if (wxDEFAULT_MDICHILDFRAME_ICON
)
536 DestroyIcon(wxDEFAULT_MDICHILDFRAME_ICON
);
537 if (wxDEFAULT_MDIPARENTFRAME_ICON
)
538 DestroyIcon(wxDEFAULT_MDIPARENTFRAME_ICON
);
540 if ( wxDisableButtonBrush
)
541 ::DeleteObject( wxDisableButtonBrush
) ;
548 Ctl3dUnregister(wxhInstance
);
552 delete wxWinHandleList
;
554 wxClassInfo::CleanUpClasses();
559 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
560 // At this point we want to check if there are any memory
561 // blocks that aren't part of the wxDebugContext itself,
562 // as a special case. Then when dumping we need to ignore
563 // wxDebugContext, too.
564 if (wxDebugContext::CountObjectsLeft() > 0)
566 wxLogDebug("There were memory leaks.");
567 wxDebugContext::Dump();
568 wxDebugContext::PrintStatistics();
570 // wxDebugContext::SetStream(NULL, NULL);
573 // do it as the very last thing because everything else can log messages
574 delete wxLog::SetActiveTarget(NULL
);
577 #if !defined(_WINDLL) || (defined(_WINDLL) && defined(WXMAKINGDLL))
579 // temporarily disable this warning which would be generated in release builds
582 #pragma warning(disable: 4715) // not all control paths return a value
585 //// Main wxWindows entry point
586 int wxEntry(WXHINSTANCE hInstance
,
587 WXHINSTANCE
WXUNUSED(hPrevInstance
),
592 // do check for memory leaks on program exit
593 // (another useful flag is _CRTDBG_DELAY_FREE_MEM_DF which doesn't free
594 // deallocated memory which may be used to simulate low-memory condition)
595 wxCrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF
);
597 // take everything into a try-except block in release build
598 // FIXME other compilers must support Win32 SEH (structured exception
599 // handling) too, just find the appropriate keyword in their docs!
600 // Please note that it's _not_ the same as C++ exceptions!
601 #if !defined(__WXDEBUG__) && defined(__VISUALC__)
602 #define CATCH_PROGRAM_EXCEPTIONS
606 #undef CATCH_PROGRAM_EXCEPTIONS
609 wxhInstance
= (HINSTANCE
) hInstance
;
611 if (!wxApp::Initialize())
614 // create the application object or ensure that one already exists
617 // The app may have declared a global application object, but we recommend
618 // the IMPLEMENT_APP macro is used instead, which sets an initializer
619 // function for delayed, dynamic app object construction.
620 wxCHECK_MSG( wxApp::GetInitializerFunction(), 0,
621 "No initializer - use IMPLEMENT_APP macro." );
623 wxTheApp
= (*wxApp::GetInitializerFunction()) ();
626 wxCHECK_MSG( wxTheApp
, 0, "You have to define an instance of wxApp!" );
628 // save the WinMain() parameters
629 wxTheApp
->ConvertToStandardCommandArgs(lpCmdLine
);
630 wxTheApp
->m_nCmdShow
= nCmdShow
;
632 // GUI-specific initialisation. In fact on Windows we don't have any,
633 // but this call is provided for compatibility across platforms.
634 wxTheApp
->OnInitGui() ;
638 if ( wxTheApp
->OnInit() )
642 retValue
= wxTheApp
->OnRun();
645 // We want to initialize, but not run or exit immediately.
648 //else: app initialization failed, so we skipped OnRun()
650 wxWindow
*topWindow
= wxTheApp
->GetTopWindow();
653 // Forcibly delete the window.
654 if ( topWindow
->IsKindOf(CLASSINFO(wxFrame
)) ||
655 topWindow
->IsKindOf(CLASSINFO(wxDialog
)) )
657 topWindow
->Close(TRUE
);
658 wxTheApp
->DeletePendingObjects();
663 wxTheApp
->SetTopWindow(NULL
);
673 #ifdef CATCH_PROGRAM_EXCEPTIONS
675 __except ( EXCEPTION_EXECUTE_HANDLER
) {
678 wxTheApp->OnFatalException();
681 // using wxLog would be unsafe here
683 _("Unrecoverable program error detected: "
684 " the application will terminate."),
686 MB_APPLMODAL
| MB_ICONSTOP
| MB_OK
);
688 ::ExitProcess(3); // the same exit code as abort()
692 #endif // CATCH_PROGRAM_EXCEPTIONS
695 // restore warning state
697 #pragma warning(default: 4715) // not all control paths return a value
702 //// Entry point for DLLs
704 int wxEntry(WXHINSTANCE hInstance
)
706 wxhInstance
= (HINSTANCE
) hInstance
;
709 // The app may have declared a global application object, but we recommend
710 // the IMPLEMENT_APP macro is used instead, which sets an initializer function
711 // for delayed, dynamic app object construction.
714 wxCHECK_MSG( wxApp::GetInitializerFunction(), 0,
715 "No initializer - use IMPLEMENT_APP macro." );
717 wxTheApp
= (* wxApp::GetInitializerFunction()) ();
720 wxCHECK_MSG( wxTheApp
, 0, "You have to define an instance of wxApp!" );
723 wxTheApp
->argv
= NULL
;
725 wxTheApp
->OnInitGui();
729 wxWindow
*topWindow
= wxTheApp
->GetTopWindow();
730 if ( topWindow
&& topWindow
->GetHWND())
732 topWindow
->Show(TRUE
);
739 //// Static member initialization
741 wxAppInitializerFunction
wxApp::m_appInitFn
= (wxAppInitializerFunction
) NULL
;
748 m_wantDebugOutput
= TRUE
;
753 m_printMode
= wxPRINT_WINDOWS
;
755 m_printMode
= wxPRINT_POSTSCRIPT
;
757 m_exitOnFrameDelete
= TRUE
;
763 // Delete command-line args
765 for (i
= 0; i
< argc
; i
++)
772 bool wxApp::Initialized()
780 #ifdef _WINDLL // Assume initialized if DLL (no way of telling)
786 * Get and process a message, returning FALSE if WM_QUIT
787 * received (and also set the flag telling the app to exit the main loop)
790 bool wxApp::DoMessage()
792 BOOL rc
= ::GetMessage(&s_currentMsg
, (HWND
) NULL
, 0, 0);
802 // should never happen, but let's test for it nevertheless
803 wxLogLastError("GetMessage");
808 wxASSERT_MSG( wxThread::IsMain(),
809 "only the main thread can process Windows messages" );
811 static bool s_hadGuiLock
= TRUE
;
812 static wxMsgArray s_aSavedMessages
;
814 // if a secondary thread owns is doing GUI calls, save all messages for
815 // later processing - we can't process them right now because it will
816 // lead to recursive library calls (and we're not reentrant)
817 if ( !wxGuiOwnedByMainThread() )
819 s_hadGuiLock
= FALSE
;
821 // leave out WM_COMMAND messages: too dangerous, sometimes
822 // the message will be processed twice
823 if ( !wxIsWaitingForThread() ||
824 s_currentMsg
.message
!= WM_COMMAND
)
826 s_aSavedMessages
.Add(s_currentMsg
);
833 // have we just regained the GUI lock? if so, post all of the saved
836 // FIXME of course, it's not _exactly_ the same as processing the
837 // messages normally - expect some things to break...
842 size_t count
= s_aSavedMessages
.Count();
843 for ( size_t n
= 0; n
< count
; n
++ )
845 MSG
& msg
= s_aSavedMessages
[n
];
847 if ( !ProcessMessage((WXMSG
*)&msg
) )
849 ::TranslateMessage(&msg
);
850 ::DispatchMessage(&msg
);
854 s_aSavedMessages
.Empty();
857 #endif // wxUSE_THREADS
859 // Process the message
860 if ( !ProcessMessage((WXMSG
*)&s_currentMsg
) )
862 ::TranslateMessage(&s_currentMsg
);
863 wxApp::sm_lastMessageTime
= s_currentMsg
.time
; /* MATTHEW: timeStamp impl. */
864 ::DispatchMessage(&s_currentMsg
);
872 * Keep trying to process messages until WM_QUIT
875 * If there are messages to be processed, they will all be
876 * processed and OnIdle will not be called.
877 * When there are no more messages, OnIdle is called.
878 * If OnIdle requests more time,
879 * it will be repeatedly called so long as there are no pending messages.
880 * A 'feature' of this is that once OnIdle has decided that no more processing
881 * is required, then it won't get processing time until further messages
882 * are processed (it'll sit in DoMessage).
885 int wxApp::MainLoop()
889 while ( m_keepGoing
)
892 wxMutexGuiLeaveOrEnter();
893 #endif // wxUSE_THREADS
895 while ( !::PeekMessage(&s_currentMsg
, 0, 0, 0, PM_NOREMOVE
) &&
903 return s_currentMsg
.wParam
;
906 // Returns TRUE if more time is needed.
907 bool wxApp::ProcessIdle()
910 event
.SetEventObject(this);
913 return event
.MoreRequested();
916 void wxApp::ExitMainLoop()
921 bool wxApp::Pending()
923 return (::PeekMessage(&s_currentMsg
, 0, 0, 0, PM_NOREMOVE
) != 0) ;
926 void wxApp::Dispatch()
932 * Give all windows a chance to preprocess
933 * the message. Some may have accelerator tables, or have
937 bool wxApp::ProcessMessage(WXMSG
*wxmsg
)
939 MSG
*msg
= (MSG
*)wxmsg
;
940 HWND hWnd
= msg
->hwnd
;
941 wxWindow
*wndThis
= wxFindWinFromHandle((WXHWND
)hWnd
), *wnd
;
943 // Try translations first; find the youngest window with
944 // a translation table.
945 for ( wnd
= wndThis
; wnd
; wnd
= wnd
->GetParent() )
947 if ( wnd
->MSWTranslateMessage(wxmsg
) )
951 // Anyone for a non-translation message? Try youngest descendants first.
952 for ( wnd
= wndThis
; wnd
; wnd
= wnd
->GetParent() )
954 if ( wnd
->MSWProcessMessage(wxmsg
) )
961 void wxApp::OnIdle(wxIdleEvent
& event
)
963 static bool s_inOnIdle
= FALSE
;
965 // Avoid recursion (via ProcessEvent default case)
971 // 'Garbage' collection of windows deleted with Close().
972 DeletePendingObjects();
974 // flush the logged messages if any
975 wxLog
*pLog
= wxLog::GetActiveTarget();
976 if ( pLog
!= NULL
&& pLog
->HasPendingMessages() )
979 // Send OnIdle events to all windows
980 if ( SendIdleEvents() )
982 // SendIdleEvents() returns TRUE if at least one window requested more
984 event
.RequestMore(TRUE
);
990 // Send idle event to all top-level windows
991 bool wxApp::SendIdleEvents()
993 bool needMore
= FALSE
;
994 wxNode
* node
= wxTopLevelWindows
.First();
997 wxWindow
* win
= (wxWindow
*) node
->Data();
998 if (SendIdleEvents(win
))
1001 node
= node
->Next();
1007 // Send idle event to window and all subwindows
1008 bool wxApp::SendIdleEvents(wxWindow
* win
)
1010 bool needMore
= FALSE
;
1013 event
.SetEventObject(win
);
1014 win
->GetEventHandler()->ProcessEvent(event
);
1016 if (event
.MoreRequested())
1019 wxNode
* node
= win
->GetChildren().First();
1022 wxWindow
* win
= (wxWindow
*) node
->Data();
1023 if (SendIdleEvents(win
))
1026 node
= node
->Next();
1031 void wxApp::DeletePendingObjects()
1033 wxNode
*node
= wxPendingDelete
.First();
1036 wxObject
*obj
= (wxObject
*)node
->Data();
1040 if (wxPendingDelete
.Member(obj
))
1043 // Deleting one object may have deleted other pending
1044 // objects, so start from beginning of list again.
1045 node
= wxPendingDelete
.First();
1049 void wxApp::OnEndSession(wxCloseEvent
& WXUNUSED(event
))
1052 GetTopWindow()->Close(TRUE
);
1055 // Default behaviour: close the application with prompts. The
1056 // user can veto the close, and therefore the end session.
1057 void wxApp::OnQueryEndSession(wxCloseEvent
& event
)
1061 if (!GetTopWindow()->Close(!event
.CanVeto()))
1066 wxLog
* wxApp::CreateLogTarget()
1068 return new wxLogGui
;
1071 wxWindow
* wxApp::GetTopWindow() const
1075 else if (wxTopLevelWindows
.Number() > 0)
1076 return (wxWindow
*) wxTopLevelWindows
.First()->Data();
1081 int wxApp::GetComCtl32Version() const
1083 // have we loaded COMCTL32 yet?
1084 HMODULE theModule
= ::GetModuleHandle("COMCTL32");
1087 // if so, then we can check for the version
1090 // InitCommonControlsEx is unique to 4.7 and later
1091 FARPROC theProc
= ::GetProcAddress(theModule
, "InitCommonControlsEx");
1094 { // not found, must be 4.00
1099 // The following symbol are unique to 4.71
1101 // FlatSB_EnableScrollBar FlatSB_GetScrollInfo FlatSB_GetScrollPos
1102 // FlatSB_GetScrollProp FlatSB_GetScrollRange FlatSB_SetScrollInfo
1103 // FlatSB_SetScrollPos FlatSB_SetScrollProp FlatSB_SetScrollRange
1104 // FlatSB_ShowScrollBar
1105 // _DrawIndirectImageList _DuplicateImageList
1107 // UninitializeFlatSB
1108 // we could check for any of these - I chose DllInstall
1109 FARPROC theProc
= ::GetProcAddress(theModule
, "DllInstall");
1112 // not found, must be 4.70
1116 { // found, must be 4.71
1126 wxLogError(_("Fatal error: exiting"));
1131 // Yield to incoming messages
1135 // We want to go back to the main message loop
1136 // if we see a WM_QUIT. (?)
1137 while (PeekMessage(&msg
, NULL
, 0, 0, PM_NOREMOVE
) && msg
.message
!= WM_QUIT
)
1139 if ( !wxTheApp
->DoMessage() )
1146 HINSTANCE
wxGetInstance()
1151 void wxSetInstance(HINSTANCE hInst
)
1153 wxhInstance
= hInst
;
1156 // For some reason, with MSVC++ 1.5, WinMain isn't linked in properly
1157 // if in a separate file. So include it here to ensure it's linked.
1158 #if (defined(__VISUALC__) && !defined(__WIN32__)) || (defined(__GNUWIN32__) && !defined(__TWIN32__))