]> git.saurik.com Git - wxWidgets.git/blame - src/msw/app.cpp
made SetDirectory() work, minor code cleanup (much is left to do)
[wxWidgets.git] / src / msw / app.cpp
CommitLineData
2bda0e17
KB
1/////////////////////////////////////////////////////////////////////////////
2// Name: app.cpp
3// Purpose: wxApp
4// Author: Julian Smart
5// Modified by:
6// Created: 04/01/98
7// RCS-ID: $Id$
8// Copyright: (c) Julian Smart and Markus Holzem
a5e0e655 9// Licence: wxWindows license
2bda0e17
KB
10/////////////////////////////////////////////////////////////////////////////
11
e5c0b16a
VZ
12// ===========================================================================
13// declarations
14// ===========================================================================
15
16// ---------------------------------------------------------------------------
17// headers
18// ---------------------------------------------------------------------------
19
2bda0e17 20#ifdef __GNUG__
e5c0b16a 21 #pragma implementation "app.h"
2bda0e17
KB
22#endif
23
24// For compilers that support precompilation, includes "wx.h".
2bda0e17
KB
25#include "wx/wxprec.h"
26
27#if defined(__BORLANDC__)
e5c0b16a 28 #pragma hdrstop
2bda0e17
KB
29#endif
30
31#ifndef WX_PRECOMP
e5c0b16a
VZ
32 #include "wx/frame.h"
33 #include "wx/app.h"
34 #include "wx/utils.h"
35 #include "wx/gdicmn.h"
36 #include "wx/pen.h"
37 #include "wx/brush.h"
38 #include "wx/cursor.h"
39 #include "wx/icon.h"
40 #include "wx/palette.h"
41 #include "wx/dc.h"
42 #include "wx/dialog.h"
43 #include "wx/msgdlg.h"
44 #include "wx/intl.h"
45 #include "wx/dynarray.h"
72cdf4c9
VZ
46 #include "wx/wxchar.h"
47 #include "wx/icon.h"
31f6de22 48 #include "wx/log.h"
2bda0e17
KB
49#endif
50
31f6de22 51#include "wx/cmdline.h"
7104f65d 52#include "wx/filename.h"
2bda0e17 53#include "wx/module.h"
4bf78aae 54
4286a5b5
RR
55#include "wx/msw/private.h"
56
4bf78aae 57#if wxUSE_THREADS
bee503b0
VZ
58 #include "wx/thread.h"
59
60 // define the array of MSG strutures
61 WX_DECLARE_OBJARRAY(MSG, wxMsgArray);
62
63 #include "wx/arrimpl.cpp"
64
65 WX_DEFINE_OBJARRAY(wxMsgArray);
66#endif // wxUSE_THREADS
2bda0e17 67
47d67540 68#if wxUSE_WX_RESOURCES
e5c0b16a 69 #include "wx/resource.h"
2bda0e17
KB
70#endif
71
8614c467
VZ
72#if wxUSE_TOOLTIPS
73 #include "wx/tooltip.h"
74#endif // wxUSE_TOOLTIPS
75
c42404a5
VZ
76// OLE is used for drag-and-drop, clipboard, OLE Automation..., but some
77// compilers don't support it (missing headers, libs, ...)
78#if defined(__GNUWIN32_OLD__) || defined(__SC__) || defined(__SALFORDC__)
e5c0b16a
VZ
79 #undef wxUSE_OLE
80
81 #define wxUSE_OLE 0
82#endif // broken compilers
83
84#if wxUSE_OLE
6e0d9d43 85 #include <ole2.h>
d05237ea 86#endif
ce3ed50d 87
2bda0e17 88#include <string.h>
a5e0e655 89#include <ctype.h>
2bda0e17 90
04ef50df 91#if defined(__WIN95__) && !((defined(__GNUWIN32_OLD__) || defined(__TWIN32__) || defined(__WXMICROWIN__)) && !defined(__CYGWIN10__))
e5c0b16a 92 #include <commctrl.h>
2bda0e17
KB
93#endif
94
04ef50df 95#ifndef __WXMICROWIN__
6e0d9d43 96#include "wx/msw/msvcrt.h"
04ef50df 97#endif
370382c7 98
bdc72a22
VZ
99// ----------------------------------------------------------------------------
100// conditional compilation
101// ----------------------------------------------------------------------------
102
103// The macro _WIN32_IE is defined by commctrl.h (unless it had already been
104// defined before) and shows us what common control features are available
105// during the compile time (it doesn't mean that they will be available during
106// the run-time, use GetComCtl32Version() to test for them!). The possible
107// values are:
108//
109// 0x0200 for comctl32.dll 4.00 shipped with Win95/NT 4.0
110// 0x0300 4.70 IE 3.x
111// 0x0400 4.71 IE 4.0
112// 0x0401 4.72 IE 4.01 and Win98
113// 0x0500 5.00 IE 5.x and NT 5.0 (Win2000)
114
115#ifndef _WIN32_IE
116 // minimal set of features by default
117 #define _WIN32_IE 0x0200
118#endif
119
a4a2e5d2
MB
120#if _WIN32_IE >= 0x0300 && \
121 (!defined(__MINGW32__) || wxCHECK_W32API_VERSION( 2, 0 ))
036bc7d9
VZ
122 #include <shlwapi.h>
123#endif
124
e5c0b16a
VZ
125// ---------------------------------------------------------------------------
126// global variables
127// ---------------------------------------------------------------------------
128
837e5743 129extern wxChar *wxBuffer;
cde9f08e 130extern wxList WXDLLEXPORT wxPendingDelete;
04ef50df 131#ifndef __WXMICROWIN__
2bda0e17 132extern void wxSetKeyboardHook(bool doIt);
04ef50df 133#endif
2bda0e17 134
42e69d6b 135MSG s_currentMsg;
2bda0e17
KB
136wxApp *wxTheApp = NULL;
137
193fe989
VZ
138// NB: all "NoRedraw" classes must have the same names as the "normal" classes
139// with NR suffix - wxWindow::MSWCreate() supposes this
03baf031
VZ
140const wxChar *wxCanvasClassName = wxT("wxWindowClass");
141const wxChar *wxCanvasClassNameNR = wxT("wxWindowClassNR");
2ffa221c
VZ
142const wxChar *wxMDIFrameClassName = wxT("wxMDIFrameClass");
143const wxChar *wxMDIFrameClassNameNoRedraw = wxT("wxMDIFrameClassNR");
144const wxChar *wxMDIChildFrameClassName = wxT("wxMDIChildFrameClass");
145const wxChar *wxMDIChildFrameClassNameNoRedraw = wxT("wxMDIChildFrameClassNR");
2bda0e17 146
57c208c5
JS
147HICON wxSTD_FRAME_ICON = (HICON) NULL;
148HICON wxSTD_MDICHILDFRAME_ICON = (HICON) NULL;
149HICON wxSTD_MDIPARENTFRAME_ICON = (HICON) NULL;
2bda0e17 150
57c208c5
JS
151HICON wxDEFAULT_FRAME_ICON = (HICON) NULL;
152HICON wxDEFAULT_MDICHILDFRAME_ICON = (HICON) NULL;
153HICON wxDEFAULT_MDIPARENTFRAME_ICON = (HICON) NULL;
2bda0e17 154
57c208c5 155HBRUSH wxDisableButtonBrush = (HBRUSH) 0;
2bda0e17 156
3135f4a7 157LRESULT WXDLLEXPORT APIENTRY wxWndProc(HWND, UINT, WPARAM, LPARAM);
2bda0e17 158
bd3277fe
VZ
159// FIXME wxUSE_ON_FATAL_EXCEPTION is only supported for VC++ now because it
160// needs compiler support for Win32 SEH. Others (especially Borland)
161// probably have it too, but I'm not sure about how it works
f6bcfd97
BP
162// JACS: get 'Cannot use __try in functions that require unwinding
163// in Unicode mode, so disabling.
164#if !defined(__VISUALC__) || defined(__WIN16__) || defined(UNICODE)
bd3277fe
VZ
165 #undef wxUSE_ON_FATAL_EXCEPTION
166 #define wxUSE_ON_FATAL_EXCEPTION 0
167#endif // VC++
168
3b415ba4
VZ
169#if wxUSE_ON_FATAL_EXCEPTION
170 static bool gs_handleExceptions = FALSE;
171#endif
172
e5c0b16a
VZ
173// ===========================================================================
174// implementation
175// ===========================================================================
589f0e3e 176
e5c0b16a
VZ
177// ---------------------------------------------------------------------------
178// wxApp
179// ---------------------------------------------------------------------------
180
f6bcfd97 181IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
e5c0b16a 182
f6bcfd97
BP
183BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
184 EVT_IDLE(wxApp::OnIdle)
185 EVT_END_SESSION(wxApp::OnEndSession)
186 EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
187END_EVENT_TABLE()
e5c0b16a 188
e5c0b16a 189//// Initialize
589f0e3e 190bool wxApp::Initialize()
2bda0e17 191{
f6bcfd97 192 // the first thing to do is to check if we're trying to run an Unicode
dfc40ef3
VS
193 // program under Win9x w/o MSLU emulation layer - if so, abort right now
194 // as it has no chance to work
eb5e4d9a 195#if wxUSE_UNICODE && !wxUSE_UNICODE_MSLU
f6bcfd97
BP
196 if ( wxGetOsVersion() != wxWINDOWS_NT )
197 {
198 // note that we can use MessageBoxW() as it's implemented even under
199 // Win9x - OTOH, we can't use wxGetTranslation() because the file APIs
200 // used by wxLocale are not
201 ::MessageBox
202 (
203 NULL,
eb5e4d9a 204 _T("This program uses Unicode and requires Windows NT/2000/XP.\nProgram aborted."),
f6bcfd97
BP
205 _T("wxWindows Fatal Error"),
206 MB_ICONERROR | MB_OK
207 );
208
209 return FALSE;
210 }
eb5e4d9a 211#endif // wxUSE_UNICODE && !wxUSE_UNICODE_MSLU
f6bcfd97 212
837e5743 213 wxBuffer = new wxChar[1500]; // FIXME
589f0e3e 214
aa0b7e1e 215 wxClassInfo::InitializeClasses();
589f0e3e 216
4d3a259a 217#if wxUSE_THREADS
8e193f38 218 wxPendingEventsLocker = new wxCriticalSection;
4d3a259a
GL
219#endif
220
aa0b7e1e
JS
221 wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING);
222 wxTheColourDatabase->Initialize();
589f0e3e 223
aa0b7e1e
JS
224 wxInitializeStockLists();
225 wxInitializeStockObjects();
589f0e3e 226
aa0b7e1e 227#if wxUSE_WX_RESOURCES
a5e0e655 228 wxInitializeResourceSystem();
aa0b7e1e 229#endif
2bda0e17 230
aa0b7e1e 231 wxBitmap::InitStandardHandlers();
2bda0e17 232
04ef50df 233#if defined(__WIN95__) && !defined(__WXMICROWIN__)
a5e0e655 234 InitCommonControls();
e5c0b16a 235#endif // __WIN95__
2bda0e17 236
8cb172b4 237#if wxUSE_OLE || wxUSE_DRAG_AND_DROP
c49245f8
VZ
238
239#ifdef __WIN16__
e5c0b16a 240 // for OLE, enlarge message queue to be as large as possible
aa0b7e1e 241 int iMsg = 96;
c49245f8
VZ
242 while (!SetMessageQueue(iMsg) && (iMsg -= 8))
243 ;
244#endif // Win16
8cb172b4 245
abad5367 246#if wxUSE_OLE
a5e0e655
VZ
247 // we need to initialize OLE library
248 if ( FAILED(::OleInitialize(NULL)) )
e5c0b16a 249 wxLogError(_("Cannot initialize OLE"));
abad5367 250#endif
1e6feb95 251
c49245f8 252#endif // wxUSE_OLE
2bda0e17 253
1f112209 254#if wxUSE_CTL3D
a5e0e655 255 if (!Ctl3dRegister(wxhInstance))
223d09f6 256 wxLogError(wxT("Cannot register CTL3D"));
2bda0e17 257
a5e0e655 258 Ctl3dAutoSubclass(wxhInstance);
1e6feb95 259#endif // wxUSE_CTL3D
2bda0e17 260
87a1e308
VZ
261 // VZ: these icons are not in wx.rc anyhow (but should they?)!
262#if 0
223d09f6
KB
263 wxSTD_FRAME_ICON = LoadIcon(wxhInstance, wxT("wxSTD_FRAME"));
264 wxSTD_MDIPARENTFRAME_ICON = LoadIcon(wxhInstance, wxT("wxSTD_MDIPARENTFRAME"));
265 wxSTD_MDICHILDFRAME_ICON = LoadIcon(wxhInstance, wxT("wxSTD_MDICHILDFRAME"));
2bda0e17 266
223d09f6
KB
267 wxDEFAULT_FRAME_ICON = LoadIcon(wxhInstance, wxT("wxDEFAULT_FRAME"));
268 wxDEFAULT_MDIPARENTFRAME_ICON = LoadIcon(wxhInstance, wxT("wxDEFAULT_MDIPARENTFRAME"));
269 wxDEFAULT_MDICHILDFRAME_ICON = LoadIcon(wxhInstance, wxT("wxDEFAULT_MDICHILDFRAME"));
87a1e308 270#endif // 0
2bda0e17 271
aa0b7e1e 272 RegisterWindowClasses();
2bda0e17 273
04ef50df 274#ifndef __WXMICROWIN__
aa0b7e1e 275 // Create the brush for disabling bitmap buttons
2bda0e17 276
42e69d6b 277 LOGBRUSH lb;
aa0b7e1e 278 lb.lbStyle = BS_PATTERN;
097f29c2 279 lb.lbColor = 0;
223d09f6 280 lb.lbHatch = (int)LoadBitmap( wxhInstance, wxT("wxDISABLE_BUTTON_BITMAP") );
3a5ffa81
VZ
281 if ( lb.lbHatch )
282 {
283 wxDisableButtonBrush = ::CreateBrushIndirect( & lb );
284 ::DeleteObject( (HGDIOBJ)lb.lbHatch );
285 }
286 //else: wxWindows resources are probably not linked in
04ef50df 287#endif
2bda0e17 288
aa0b7e1e 289#if wxUSE_PENWINDOWS
a5e0e655 290 wxRegisterPenWin();
aa0b7e1e 291#endif
2bda0e17 292
1bffa913 293 wxWinHandleHash = new wxWinHashTable(wxKEY_INTEGER, 100);
2bda0e17 294
6e0d9d43 295 // This is to foil optimizations in Visual C++ that throw out dummy.obj.
8cbd2bde 296 // PLEASE DO NOT ALTER THIS.
7fee680b 297#if defined(__VISUALC__) && defined(__WIN16__) && !defined(WXMAKINGDLL)
a5e0e655
VZ
298 extern char wxDummyChar;
299 if (wxDummyChar) wxDummyChar++;
aa0b7e1e 300#endif
a5e0e655 301
04ef50df 302#ifndef __WXMICROWIN__
aa0b7e1e 303 wxSetKeyboardHook(TRUE);
04ef50df 304#endif
2bda0e17 305
aa0b7e1e
JS
306 wxModule::RegisterModules();
307 if (!wxModule::InitializeModules())
308 return FALSE;
309 return TRUE;
2bda0e17
KB
310}
311
42e69d6b
VZ
312// ---------------------------------------------------------------------------
313// RegisterWindowClasses
314// ---------------------------------------------------------------------------
589f0e3e 315
b782f2e0
VZ
316// TODO we should only register classes really used by the app. For this it
317// would be enough to just delay the class registration until an attempt
318// to create a window of this class is made.
bb6290e3 319bool wxApp::RegisterWindowClasses()
2bda0e17 320{
42e69d6b 321 WNDCLASS wndclass;
03baf031 322 wxZeroMemory(wndclass);
e5c0b16a 323
193fe989
VZ
324 // for each class we register one with CS_(V|H)REDRAW style and one
325 // without for windows created with wxNO_FULL_REDRAW_ON_REPAINT flag
326 static const long styleNormal = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
327 static const long styleNoRedraw = CS_DBLCLKS;
328
42e69d6b 329 // the fields which are common to all classes
e5c0b16a 330 wndclass.lpfnWndProc = (WNDPROC)wxWndProc;
e5c0b16a 331 wndclass.hInstance = wxhInstance;
42e69d6b 332 wndclass.hCursor = ::LoadCursor((HINSTANCE)NULL, IDC_ARROW);
42e69d6b
VZ
333
334 // Register the frame window class.
335 wndclass.hbrBackground = (HBRUSH)(COLOR_APPWORKSPACE + 1);
03baf031 336 wndclass.lpszClassName = wxCanvasClassName;
b782f2e0 337 wndclass.style = styleNormal;
e5c0b16a 338
42e69d6b 339 if ( !RegisterClass(&wndclass) )
e5c0b16a 340 {
f6bcfd97 341 wxLogLastError(wxT("RegisterClass(frame)"));
e5c0b16a
VZ
342 }
343
193fe989 344 // "no redraw" frame
03baf031 345 wndclass.lpszClassName = wxCanvasClassNameNR;
193fe989
VZ
346 wndclass.style = styleNoRedraw;
347
348 if ( !RegisterClass(&wndclass) )
349 {
f6bcfd97 350 wxLogLastError(wxT("RegisterClass(no redraw frame)"));
193fe989
VZ
351 }
352
e5c0b16a 353 // Register the MDI frame window class.
42e69d6b 354 wndclass.hbrBackground = (HBRUSH)NULL; // paint MDI frame ourselves
b782f2e0
VZ
355 wndclass.lpszClassName = wxMDIFrameClassName;
356 wndclass.style = styleNormal;
42e69d6b
VZ
357
358 if ( !RegisterClass(&wndclass) )
e5c0b16a 359 {
f6bcfd97 360 wxLogLastError(wxT("RegisterClass(MDI parent)"));
e5c0b16a
VZ
361 }
362
193fe989 363 // "no redraw" MDI frame
b782f2e0 364 wndclass.lpszClassName = wxMDIFrameClassNameNoRedraw;
193fe989
VZ
365 wndclass.style = styleNoRedraw;
366
367 if ( !RegisterClass(&wndclass) )
368 {
f6bcfd97 369 wxLogLastError(wxT("RegisterClass(no redraw MDI parent frame)"));
193fe989
VZ
370 }
371
e5c0b16a 372 // Register the MDI child frame window class.
42e69d6b
VZ
373 wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
374 wndclass.lpszClassName = wxMDIChildFrameClassName;
b782f2e0 375 wndclass.style = styleNormal;
42e69d6b
VZ
376
377 if ( !RegisterClass(&wndclass) )
e5c0b16a 378 {
f6bcfd97 379 wxLogLastError(wxT("RegisterClass(MDI child)"));
e5c0b16a
VZ
380 }
381
193fe989
VZ
382 // "no redraw" MDI child frame
383 wndclass.lpszClassName = wxMDIChildFrameClassNameNoRedraw;
384 wndclass.style = styleNoRedraw;
385
386 if ( !RegisterClass(&wndclass) )
387 {
f6bcfd97 388 wxLogLastError(wxT("RegisterClass(no redraw MDI child)"));
193fe989
VZ
389 }
390
e5c0b16a 391 return TRUE;
2bda0e17
KB
392}
393
9787a4b6
VZ
394// ---------------------------------------------------------------------------
395// UnregisterWindowClasses
396// ---------------------------------------------------------------------------
397
398bool wxApp::UnregisterWindowClasses()
399{
400 bool retval = TRUE;
401
c67d6888 402#ifndef __WXMICROWIN__
9787a4b6 403 // MDI frame window class.
03baf031 404 if ( !::UnregisterClass(wxMDIFrameClassName, wxhInstance) )
9787a4b6
VZ
405 {
406 wxLogLastError(wxT("UnregisterClass(MDI parent)"));
407
408 retval = FALSE;
409 }
410
411 // "no redraw" MDI frame
03baf031 412 if ( !::UnregisterClass(wxMDIFrameClassNameNoRedraw, wxhInstance) )
9787a4b6
VZ
413 {
414 wxLogLastError(wxT("UnregisterClass(no redraw MDI parent frame)"));
415
416 retval = FALSE;
417 }
418
419 // MDI child frame window class.
03baf031 420 if ( !::UnregisterClass(wxMDIChildFrameClassName, wxhInstance) )
9787a4b6
VZ
421 {
422 wxLogLastError(wxT("UnregisterClass(MDI child)"));
423
424 retval = FALSE;
425 }
426
427 // "no redraw" MDI child frame
03baf031 428 if ( !::UnregisterClass(wxMDIChildFrameClassNameNoRedraw, wxhInstance) )
9787a4b6
VZ
429 {
430 wxLogLastError(wxT("UnregisterClass(no redraw MDI child)"));
431
432 retval = FALSE;
433 }
434
03baf031
VZ
435 // canvas class name
436 if ( !::UnregisterClass(wxCanvasClassName, wxhInstance) )
9787a4b6
VZ
437 {
438 wxLogLastError(wxT("UnregisterClass(canvas)"));
439
440 retval = FALSE;
441 }
442
03baf031 443 if ( !::UnregisterClass(wxCanvasClassNameNR, wxhInstance) )
9787a4b6
VZ
444 {
445 wxLogLastError(wxT("UnregisterClass(no redraw canvas)"));
446
447 retval = FALSE;
448 }
03baf031
VZ
449#endif // __WXMICROWIN__
450
9787a4b6
VZ
451 return retval;
452}
453
42e69d6b
VZ
454// ---------------------------------------------------------------------------
455// Convert Windows to argc, argv style
456// ---------------------------------------------------------------------------
589f0e3e 457
31f6de22 458void wxApp::ConvertToStandardCommandArgs(const char* lpCmdLine)
589f0e3e 459{
31f6de22
VZ
460 // break the command line in words
461 wxArrayString args =
462 wxCmdLineParser::ConvertStringToArgs(wxConvertMB2WX(lpCmdLine));
589f0e3e 463
31f6de22
VZ
464 // +1 here for the program name
465 argc = args.GetCount() + 1;
589f0e3e 466
31f6de22
VZ
467 // and +1 here for the terminating NULL
468 argv = new wxChar *[argc + 1];
da36f544 469
31f6de22
VZ
470 argv[0] = new wxChar[260]; // 260 is MAX_PATH value from windef.h
471 ::GetModuleFileName(wxhInstance, argv[0], 260);
589f0e3e 472
7104f65d
VZ
473 // also set the app name from argv[0]
474 wxString name;
475 wxFileName::SplitPath(argv[0], NULL, &name, NULL);
476
477 SetAppName(name);
478
479 // copy all the other arguments to wxApp::argv[]
31f6de22 480 for ( int i = 1; i < argc; i++ )
a5e0e655 481 {
31f6de22 482 argv[i] = copystring(args[i - 1]);
a5e0e655 483 }
a5e0e655 484
31f6de22
VZ
485 // argv[] must be NULL-terminated
486 argv[argc] = NULL;
589f0e3e
JS
487}
488
489//// Cleans up any wxWindows internal structures left lying around
490
bb6290e3 491void wxApp::CleanUp()
2bda0e17 492{
e5c0b16a
VZ
493 //// COMMON CLEANUP
494
546db2a8 495#if wxUSE_LOG
e5c0b16a
VZ
496 // flush the logged messages if any and install a 'safer' log target: the
497 // default one (wxLogGui) can't be used after the resources are freed just
498 // below and the user suppliedo ne might be even more unsafe (using any
499 // wxWindows GUI function is unsafe starting from now)
500 wxLog::DontCreateOnDemand();
f5e5bd66 501
e5c0b16a
VZ
502 // this will flush the old messages if any
503 delete wxLog::SetActiveTarget(new wxLogStderr);
546db2a8 504#endif // wxUSE_LOG
f5e5bd66 505
e5c0b16a
VZ
506 // One last chance for pending objects to be cleaned up
507 wxTheApp->DeletePendingObjects();
f5e5bd66 508
e5c0b16a 509 wxModule::CleanUpModules();
2bda0e17 510
47d67540 511#if wxUSE_WX_RESOURCES
e5c0b16a 512 wxCleanUpResourceSystem();
589f0e3e 513
e5c0b16a 514 // wxDefaultResourceTable->ClearTable();
589f0e3e
JS
515#endif
516
42e69d6b 517 wxDeleteStockObjects();
589f0e3e 518
e5c0b16a
VZ
519 // Destroy all GDI lists, etc.
520 wxDeleteStockLists();
589f0e3e 521
e5c0b16a
VZ
522 delete wxTheColourDatabase;
523 wxTheColourDatabase = NULL;
589f0e3e 524
e5c0b16a 525 wxBitmap::CleanUpHandlers();
589f0e3e 526
e5c0b16a
VZ
527 delete[] wxBuffer;
528 wxBuffer = NULL;
589f0e3e 529
e5c0b16a 530 //// WINDOWS-SPECIFIC CLEANUP
2bda0e17 531
04ef50df 532#ifndef __WXMICROWIN__
e5c0b16a 533 wxSetKeyboardHook(FALSE);
04ef50df 534#endif
2bda0e17 535
47d67540 536#if wxUSE_PENWINDOWS
e5c0b16a 537 wxCleanUpPenWin();
2bda0e17
KB
538#endif
539
e5c0b16a
VZ
540 if (wxSTD_FRAME_ICON)
541 DestroyIcon(wxSTD_FRAME_ICON);
542 if (wxSTD_MDICHILDFRAME_ICON)
543 DestroyIcon(wxSTD_MDICHILDFRAME_ICON);
544 if (wxSTD_MDIPARENTFRAME_ICON)
545 DestroyIcon(wxSTD_MDIPARENTFRAME_ICON);
546
547 if (wxDEFAULT_FRAME_ICON)
548 DestroyIcon(wxDEFAULT_FRAME_ICON);
549 if (wxDEFAULT_MDICHILDFRAME_ICON)
550 DestroyIcon(wxDEFAULT_MDICHILDFRAME_ICON);
551 if (wxDEFAULT_MDIPARENTFRAME_ICON)
552 DestroyIcon(wxDEFAULT_MDIPARENTFRAME_ICON);
553
554 if ( wxDisableButtonBrush )
42e69d6b 555 ::DeleteObject( wxDisableButtonBrush );
e5c0b16a
VZ
556
557#if wxUSE_OLE
558 ::OleUninitialize();
5de5db0e 559#endif
2bda0e17 560
9787a4b6
VZ
561#ifdef WXMAKINGDLL
562 // for an EXE the classes are unregistered when it terminates but DLL may
563 // be loaded several times (load/unload/load) into the same process in
564 // which case the registration will fail after the first time if we don't
565 // unregister the classes now
566 UnregisterWindowClasses();
567#endif // WXMAKINGDLL
568
1f112209 569#if wxUSE_CTL3D
e5c0b16a 570 Ctl3dUnregister(wxhInstance);
2bda0e17
KB
571#endif
572
1bffa913 573 delete wxWinHandleHash;
d50b2a58 574
3135f4a7 575 // GL: I'm annoyed ... I don't know where to put this and I don't want to
4d3a259a 576 // create a module for that as it's part of the core.
4d3a259a 577 delete wxPendingEvents;
1e6feb95 578
8e193f38 579#if wxUSE_THREADS
4d3a259a 580 delete wxPendingEventsLocker;
1e6feb95 581 // If we don't do the following, we get an apparent memory leak
f80eabe5 582#if wxUSE_VALIDATORS
63863e09 583 ((wxEvtHandler&) wxDefaultValidator).ClearEventLocker();
1e6feb95
VZ
584#endif // wxUSE_VALIDATORS
585#endif // wxUSE_THREADS
4d3a259a 586
e5c0b16a 587 wxClassInfo::CleanUpClasses();
0c32066b 588
e5c0b16a
VZ
589 delete wxTheApp;
590 wxTheApp = NULL;
184b5d99
JS
591
592#if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
e5c0b16a
VZ
593 // At this point we want to check if there are any memory
594 // blocks that aren't part of the wxDebugContext itself,
595 // as a special case. Then when dumping we need to ignore
596 // wxDebugContext, too.
d13c32e9 597 if (wxDebugContext::CountObjectsLeft(TRUE) > 0)
e5c0b16a 598 {
5fa399c9 599 wxLogMessage(wxT("There were memory leaks."));
e5c0b16a
VZ
600 wxDebugContext::Dump();
601 wxDebugContext::PrintStatistics();
602 }
603 // wxDebugContext::SetStream(NULL, NULL);
184b5d99
JS
604#endif
605
546db2a8 606#if wxUSE_LOG
e5c0b16a
VZ
607 // do it as the very last thing because everything else can log messages
608 delete wxLog::SetActiveTarget(NULL);
546db2a8 609#endif // wxUSE_LOG
2bda0e17
KB
610}
611
7ece89c6
RD
612//----------------------------------------------------------------------
613// Entry point helpers, used by wxPython
614//----------------------------------------------------------------------
615
f6bcfd97 616int WXDLLEXPORT wxEntryStart( int WXUNUSED(argc), char** WXUNUSED(argv) )
7ece89c6
RD
617{
618 return wxApp::Initialize();
619}
620
f6bcfd97 621int WXDLLEXPORT wxEntryInitGui()
7ece89c6 622{
1e6feb95 623 return wxTheApp->OnInitGui();
7ece89c6
RD
624}
625
626void WXDLLEXPORT wxEntryCleanup()
627{
628 wxApp::CleanUp();
629}
630
631
2bda0e17
KB
632#if !defined(_WINDLL) || (defined(_WINDLL) && defined(WXMAKINGDLL))
633
e5c0b16a
VZ
634// temporarily disable this warning which would be generated in release builds
635// because of __try
3f4a0c5b 636#ifdef __VISUALC__
f8a3e080
VZ
637 #pragma warning(disable: 4715) // not all control paths return a value
638#endif // Visual C++
639
7ece89c6
RD
640//----------------------------------------------------------------------
641// Main wxWindows entry point
642//----------------------------------------------------------------------
a5e0e655
VZ
643int wxEntry(WXHINSTANCE hInstance,
644 WXHINSTANCE WXUNUSED(hPrevInstance),
645 char *lpCmdLine,
646 int nCmdShow,
647 bool enterLoop)
2bda0e17 648{
6e0d9d43
VZ
649 // do check for memory leaks on program exit
650 // (another useful flag is _CRTDBG_DELAY_FREE_MEM_DF which doesn't free
651 // deallocated memory which may be used to simulate low-memory condition)
04ef50df 652#ifndef __WXMICROWIN__
6e0d9d43 653 wxCrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF);
04ef50df
JS
654#endif
655
6418cb93
SC
656#ifdef __MWERKS__
657#if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
658 // This seems to be necessary since there are 'rogue'
659 // objects present at this point (perhaps global objects?)
660 // Setting a checkpoint will ignore them as far as the
661 // memory checking facility is concerned.
662 // Of course you may argue that memory allocated in globals should be
663 // checked, but this is a reasonable compromise.
664 wxDebugContext::SetCheckpoint();
665#endif
666#endif
3b415ba4
VZ
667
668 // take everything into a try-except block to be able to call
669 // OnFatalException() if necessary
3b415ba4 670#if wxUSE_ON_FATAL_EXCEPTION
3f4a0c5b 671 __try {
a5e0e655 672#endif
e5c0b16a 673 wxhInstance = (HINSTANCE) hInstance;
2bda0e17 674
7ece89c6 675 if (!wxEntryStart(0,0))
e5c0b16a 676 return 0;
2bda0e17 677
e5c0b16a
VZ
678 // create the application object or ensure that one already exists
679 if (!wxTheApp)
680 {
681 // The app may have declared a global application object, but we recommend
682 // the IMPLEMENT_APP macro is used instead, which sets an initializer
683 // function for delayed, dynamic app object construction.
684 wxCHECK_MSG( wxApp::GetInitializerFunction(), 0,
223d09f6 685 wxT("No initializer - use IMPLEMENT_APP macro.") );
f8a3e080 686
8cb172b4 687 wxTheApp = (wxApp*) (*wxApp::GetInitializerFunction()) ();
e5c0b16a
VZ
688 }
689
223d09f6 690 wxCHECK_MSG( wxTheApp, 0, wxT("You have to define an instance of wxApp!") );
e5c0b16a
VZ
691
692 // save the WinMain() parameters
232b0051 693 if (lpCmdLine) // MicroWindows passes NULL
3ac59f21 694 wxTheApp->ConvertToStandardCommandArgs(lpCmdLine);
e5c0b16a 695 wxTheApp->m_nCmdShow = nCmdShow;
a5e0e655 696
36edded9
JS
697 // We really don't want timestamps by default, because it means
698 // we can't simply double-click on the error message and get to that
699 // line in the source. So VC++ at least, let's have a sensible default.
700#ifdef __VISUALC__
701 wxLog::SetTimestamp(NULL);
702#endif
703
6afafc42 704 // init the app
1cbee0b4 705 int retValue = wxEntryInitGui() && wxTheApp->OnInit() ? 0 : -1;
6afafc42
VZ
706
707 if ( retValue == 0 )
e5c0b16a
VZ
708 {
709 if ( enterLoop )
710 {
6afafc42 711 // run the main loop
e5c0b16a
VZ
712 retValue = wxTheApp->OnRun();
713 }
714 else
6afafc42
VZ
715 {
716 // we want to initialize, but not run or exit immediately.
e5c0b16a 717 return 1;
6afafc42 718 }
e5c0b16a
VZ
719 }
720 //else: app initialization failed, so we skipped OnRun()
721
722 wxWindow *topWindow = wxTheApp->GetTopWindow();
723 if ( topWindow )
724 {
725 // Forcibly delete the window.
726 if ( topWindow->IsKindOf(CLASSINFO(wxFrame)) ||
727 topWindow->IsKindOf(CLASSINFO(wxDialog)) )
728 {
729 topWindow->Close(TRUE);
730 wxTheApp->DeletePendingObjects();
731 }
732 else
733 {
734 delete topWindow;
735 wxTheApp->SetTopWindow(NULL);
736 }
737 }
738
739 wxTheApp->OnExit();
740
7ece89c6 741 wxEntryCleanup();
e5c0b16a
VZ
742
743 return retValue;
744
3b415ba4 745#if wxUSE_ON_FATAL_EXCEPTION
e5c0b16a 746 }
3b415ba4
VZ
747 __except ( gs_handleExceptions ? EXCEPTION_EXECUTE_HANDLER
748 : EXCEPTION_CONTINUE_SEARCH ) {
749 if ( wxTheApp )
f6bcfd97
BP
750 {
751 // give the user a chance to do something special about this
e5c0b16a 752 wxTheApp->OnFatalException();
f6bcfd97 753 }
e5c0b16a
VZ
754
755 ::ExitProcess(3); // the same exit code as abort()
756
757 // NOTREACHED
758 }
3b415ba4 759#endif // wxUSE_ON_FATAL_EXCEPTION
2bda0e17
KB
760}
761
f8a3e080 762// restore warning state
3f4a0c5b 763#ifdef __VISUALC__
f8a3e080
VZ
764 #pragma warning(default: 4715) // not all control paths return a value
765#endif // Visual C++
766
2bda0e17
KB
767#else /* _WINDLL */
768
7ece89c6
RD
769//----------------------------------------------------------------------
770// Entry point for wxWindows + the App in a DLL
771//----------------------------------------------------------------------
589f0e3e 772
2bda0e17
KB
773int wxEntry(WXHINSTANCE hInstance)
774{
e5c0b16a 775 wxhInstance = (HINSTANCE) hInstance;
7ece89c6 776 wxEntryStart(0, 0);
2bda0e17 777
e5c0b16a
VZ
778 // The app may have declared a global application object, but we recommend
779 // the IMPLEMENT_APP macro is used instead, which sets an initializer function
780 // for delayed, dynamic app object construction.
781 if (!wxTheApp)
a5e0e655 782 {
e5c0b16a
VZ
783 wxCHECK_MSG( wxApp::GetInitializerFunction(), 0,
784 "No initializer - use IMPLEMENT_APP macro." );
2bda0e17 785
e5c0b16a
VZ
786 wxTheApp = (* wxApp::GetInitializerFunction()) ();
787 }
2bda0e17 788
e5c0b16a 789 wxCHECK_MSG( wxTheApp, 0, "You have to define an instance of wxApp!" );
2bda0e17 790
e5c0b16a
VZ
791 wxTheApp->argc = 0;
792 wxTheApp->argv = NULL;
2bda0e17 793
7ece89c6 794 wxEntryInitGui();
2bda0e17 795
e5c0b16a 796 wxTheApp->OnInit();
2bda0e17 797
e5c0b16a
VZ
798 wxWindow *topWindow = wxTheApp->GetTopWindow();
799 if ( topWindow && topWindow->GetHWND())
800 {
801 topWindow->Show(TRUE);
802 }
2bda0e17 803
e5c0b16a 804 return 1;
2bda0e17
KB
805}
806#endif // _WINDLL
807
589f0e3e
JS
808//// Static member initialization
809
c94ad3c3 810wxAppInitializerFunction wxAppBase::m_appInitFn = (wxAppInitializerFunction) NULL;
2bda0e17 811
bb6290e3 812wxApp::wxApp()
2bda0e17 813{
e5c0b16a
VZ
814 argc = 0;
815 argv = NULL;
e5c0b16a 816 m_printMode = wxPRINT_WINDOWS;
e5c0b16a 817 m_auto3D = TRUE;
2bda0e17
KB
818}
819
589f0e3e
JS
820wxApp::~wxApp()
821{
e5c0b16a
VZ
822 // Delete command-line args
823 int i;
824 for (i = 0; i < argc; i++)
825 {
826 delete[] argv[i];
827 }
828 delete[] argv;
589f0e3e
JS
829}
830
bb6290e3 831bool wxApp::Initialized()
2bda0e17
KB
832{
833#ifndef _WINDLL
e5c0b16a
VZ
834 if (GetTopWindow())
835 return TRUE;
836 else
837 return FALSE;
3b415ba4 838#else // Assume initialized if DLL (no way of telling)
e5c0b16a 839 return TRUE;
2bda0e17
KB
840#endif
841}
842
843/*
844 * Get and process a message, returning FALSE if WM_QUIT
bee503b0 845 * received (and also set the flag telling the app to exit the main loop)
2bda0e17
KB
846 *
847 */
bb6290e3 848bool wxApp::DoMessage()
2bda0e17 849{
bee503b0
VZ
850 BOOL rc = ::GetMessage(&s_currentMsg, (HWND) NULL, 0, 0);
851 if ( rc == 0 )
852 {
853 // got WM_QUIT
854 m_keepGoing = FALSE;
4a9968f9 855
bee503b0
VZ
856 return FALSE;
857 }
858 else if ( rc == -1 )
859 {
860 // should never happen, but let's test for it nevertheless
f6bcfd97 861 wxLogLastError(wxT("GetMessage"));
bee503b0
VZ
862 }
863 else
864 {
865#if wxUSE_THREADS
866 wxASSERT_MSG( wxThread::IsMain(),
223d09f6 867 wxT("only the main thread can process Windows messages") );
d50b2a58 868
bee503b0
VZ
869 static bool s_hadGuiLock = TRUE;
870 static wxMsgArray s_aSavedMessages;
871
872 // if a secondary thread owns is doing GUI calls, save all messages for
873 // later processing - we can't process them right now because it will
874 // lead to recursive library calls (and we're not reentrant)
875 if ( !wxGuiOwnedByMainThread() )
876 {
877 s_hadGuiLock = FALSE;
878
4a9968f9
VZ
879 // leave out WM_COMMAND messages: too dangerous, sometimes
880 // the message will be processed twice
881 if ( !wxIsWaitingForThread() ||
e5c0b16a 882 s_currentMsg.message != WM_COMMAND )
4a9968f9
VZ
883 {
884 s_aSavedMessages.Add(s_currentMsg);
885 }
bee503b0
VZ
886
887 return TRUE;
888 }
889 else
890 {
891 // have we just regained the GUI lock? if so, post all of the saved
892 // messages
893 //
894 // FIXME of course, it's not _exactly_ the same as processing the
895 // messages normally - expect some things to break...
896 if ( !s_hadGuiLock )
897 {
898 s_hadGuiLock = TRUE;
899
0a95f6d0 900 size_t count = s_aSavedMessages.GetCount();
bee503b0
VZ
901 for ( size_t n = 0; n < count; n++ )
902 {
903 MSG& msg = s_aSavedMessages[n];
904
0a95f6d0 905 DoMessage((WXMSG *)&msg);
bee503b0
VZ
906 }
907
908 s_aSavedMessages.Empty();
909 }
910 }
911#endif // wxUSE_THREADS
912
913 // Process the message
ed45e263 914 DoMessage((WXMSG *)&s_currentMsg);
bee503b0
VZ
915 }
916
917 return TRUE;
2bda0e17
KB
918}
919
ed45e263
VZ
920void wxApp::DoMessage(WXMSG *pMsg)
921{
922 if ( !ProcessMessage(pMsg) )
923 {
924 ::TranslateMessage((MSG *)pMsg);
925 ::DispatchMessage((MSG *)pMsg);
926 }
927}
928
2bda0e17
KB
929/*
930 * Keep trying to process messages until WM_QUIT
931 * received.
932 *
933 * If there are messages to be processed, they will all be
934 * processed and OnIdle will not be called.
935 * When there are no more messages, OnIdle is called.
936 * If OnIdle requests more time,
937 * it will be repeatedly called so long as there are no pending messages.
938 * A 'feature' of this is that once OnIdle has decided that no more processing
939 * is required, then it won't get processing time until further messages
940 * are processed (it'll sit in DoMessage).
941 */
942
bb6290e3 943int wxApp::MainLoop()
2bda0e17 944{
e5c0b16a 945 m_keepGoing = TRUE;
bee503b0 946
e5c0b16a
VZ
947 while ( m_keepGoing )
948 {
949#if wxUSE_THREADS
bee503b0 950 wxMutexGuiLeaveOrEnter();
e5c0b16a 951#endif // wxUSE_THREADS
bee503b0 952
b6c588e1
VZ
953 while ( !Pending() && ProcessIdle() )
954 ;
7214297d 955
b6c588e1 956 // a message came or no more idle processing to do
e5c0b16a
VZ
957 DoMessage();
958 }
2bda0e17 959
e5c0b16a 960 return s_currentMsg.wParam;
2bda0e17
KB
961}
962
963// Returns TRUE if more time is needed.
bb6290e3 964bool wxApp::ProcessIdle()
2bda0e17
KB
965{
966 wxIdleEvent event;
967 event.SetEventObject(this);
968 ProcessEvent(event);
969
970 return event.MoreRequested();
971}
972
bb6290e3 973void wxApp::ExitMainLoop()
2bda0e17 974{
1cbee0b4
VZ
975 // this will set m_keepGoing to FALSE a bit later
976 ::PostQuitMessage(0);
2bda0e17
KB
977}
978
bb6290e3 979bool wxApp::Pending()
2bda0e17 980{
b6c588e1 981 return ::PeekMessage(&s_currentMsg, 0, 0, 0, PM_NOREMOVE) != 0;
2bda0e17
KB
982}
983
bb6290e3 984void wxApp::Dispatch()
2bda0e17 985{
bee503b0 986 DoMessage();
2bda0e17
KB
987}
988
989/*
990 * Give all windows a chance to preprocess
991 * the message. Some may have accelerator tables, or have
992 * MDI complications.
993 */
2a47d3c1 994
d3f0a137 995bool wxApp::ProcessMessage(WXMSG *wxmsg)
2bda0e17 996{
d3f0a137 997 MSG *msg = (MSG *)wxmsg;
2a3caeb5
VZ
998 HWND hwnd = msg->hwnd;
999 wxWindow *wndThis = wxGetWindowFromHWND((WXHWND)hwnd);
2bda0e17 1000
761989ff
VZ
1001 // this may happen if the event occured in a standard modeless dialog (the
1002 // only example of which I know of is the find/replace dialog) - then call
1003 // IsDialogMessage() to make TAB navigation in it work
1004 if ( !wndThis )
1005 {
2a3caeb5
VZ
1006 // we need to find the dialog containing this control as
1007 // IsDialogMessage() just eats all the messages (i.e. returns TRUE for
1008 // them) if we call it for the control itself
de7f0860 1009 while ( hwnd && ::GetWindowLong(hwnd, GWL_STYLE) & WS_CHILD )
2a3caeb5
VZ
1010 {
1011 hwnd = ::GetParent(hwnd);
1012 }
1013
de7f0860 1014 return hwnd && ::IsDialogMessage(hwnd, msg) != 0;
761989ff
VZ
1015 }
1016
8614c467
VZ
1017#if wxUSE_TOOLTIPS
1018 // we must relay WM_MOUSEMOVE events to the tooltip ctrl if we want it to
1019 // popup the tooltip bubbles
761989ff 1020 if ( (msg->message == WM_MOUSEMOVE) )
834362a2 1021 {
8614c467
VZ
1022 wxToolTip *tt = wndThis->GetToolTip();
1023 if ( tt )
1024 {
1025 tt->RelayEvent(wxmsg);
1026 }
834362a2 1027 }
8614c467 1028#endif // wxUSE_TOOLTIPS
834362a2 1029
a37d422a
VZ
1030 // allow the window to prevent certain messages from being
1031 // translated/processed (this is currently used by wxTextCtrl to always
1032 // grab Ctrl-C/V/X, even if they are also accelerators in some parent)
1033 if ( !wndThis->MSWShouldPreProcessMessage(wxmsg) )
1034 {
1035 return FALSE;
1036 }
1037
2a3caeb5 1038 // try translations first: the accelerators override everything
8614c467 1039 wxWindow *wnd;
42bcb12b 1040
d3f0a137 1041 for ( wnd = wndThis; wnd; wnd = wnd->GetParent() )
2bda0e17 1042 {
2a3caeb5 1043 if ( wnd->MSWTranslateMessage(wxmsg))
d3f0a137 1044 return TRUE;
3bdc265d
VZ
1045
1046 // stop at first top level window, i.e. don't try to process the key
1047 // strokes originating in a dialog using the accelerators of the parent
1048 // frame - this doesn't make much sense
1049 if ( wnd->IsTopLevel() )
2a3caeb5
VZ
1050 break;
1051 }
1052
a37d422a
VZ
1053 // now try the other hooks (kbd navigation is handled here): we start from
1054 // wndThis->GetParent() because wndThis->MSWProcessMessage() was already
1055 // called above
1056 for ( wnd = wndThis->GetParent(); wnd; wnd = wnd->GetParent() )
2a3caeb5
VZ
1057 {
1058 if ( wnd->MSWProcessMessage(wxmsg) )
1059 return TRUE;
57a7b7c1 1060 }
d3f0a137 1061
a37d422a 1062 // no special preprocessing for this message, dispatch it normally
e5c0b16a 1063 return FALSE;
2bda0e17
KB
1064}
1065
1066void wxApp::OnIdle(wxIdleEvent& event)
1067{
3222fde2 1068 static bool s_inOnIdle = FALSE;
2bda0e17 1069
3222fde2
VZ
1070 // Avoid recursion (via ProcessEvent default case)
1071 if ( s_inOnIdle )
1072 return;
2bda0e17 1073
3222fde2 1074 s_inOnIdle = TRUE;
2bda0e17 1075
52e52bea
GRG
1076 // If there are pending events, we must process them: pending events
1077 // are either events to the threads other than main or events posted
1078 // with wxPostEvent() functions
1079 // GRG: I have moved this here so that all pending events are processed
1080 // before starting to delete any objects. This behaves better (in
1081 // particular, wrt wxPostEvent) and is coherent with wxGTK's current
1082 // behaviour. Changed Feb/2000 before 2.1.14
1083 ProcessPendingEvents();
1084
3222fde2
VZ
1085 // 'Garbage' collection of windows deleted with Close().
1086 DeletePendingObjects();
2bda0e17 1087
546db2a8 1088#if wxUSE_LOG
3222fde2 1089 // flush the logged messages if any
2ed3265e 1090 wxLog::FlushActive();
546db2a8 1091#endif // wxUSE_LOG
c54f78a2 1092
aef94d68
JS
1093#if wxUSE_DC_CACHEING
1094 // automated DC cache management: clear the cached DCs and bitmap
1095 // if it's likely that the app has finished with them, that is, we
1096 // get an idle event and we're not dragging anything.
4624defa 1097 if (!::GetKeyState(MK_LBUTTON) && !::GetKeyState(MK_MBUTTON) && !::GetKeyState(MK_RBUTTON))
aef94d68
JS
1098 wxDC::ClearCache();
1099#endif // wxUSE_DC_CACHEING
1100
3222fde2
VZ
1101 // Send OnIdle events to all windows
1102 if ( SendIdleEvents() )
1103 {
1104 // SendIdleEvents() returns TRUE if at least one window requested more
1105 // idle events
1106 event.RequestMore(TRUE);
1107 }
2bda0e17 1108
3222fde2 1109 s_inOnIdle = FALSE;
2bda0e17
KB
1110}
1111
1112// Send idle event to all top-level windows
bb6290e3 1113bool wxApp::SendIdleEvents()
2bda0e17
KB
1114{
1115 bool needMore = FALSE;
e146b8c8 1116
f1d534df 1117 wxWindowList::Node* node = wxTopLevelWindows.GetFirst();
3222fde2
VZ
1118 while (node)
1119 {
e146b8c8 1120 wxWindow* win = node->GetData();
3222fde2 1121 if (SendIdleEvents(win))
2bda0e17 1122 needMore = TRUE;
e146b8c8 1123 node = node->GetNext();
3222fde2
VZ
1124 }
1125
2bda0e17
KB
1126 return needMore;
1127}
1128
1129// Send idle event to window and all subwindows
1130bool wxApp::SendIdleEvents(wxWindow* win)
1131{
e5c0b16a 1132 bool needMore = FALSE;
2bda0e17 1133
e5c0b16a
VZ
1134 wxIdleEvent event;
1135 event.SetEventObject(win);
1136 win->GetEventHandler()->ProcessEvent(event);
2bda0e17 1137
e5c0b16a
VZ
1138 if (event.MoreRequested())
1139 needMore = TRUE;
2bda0e17 1140
e5c0b16a
VZ
1141 wxNode* node = win->GetChildren().First();
1142 while (node)
1143 {
1144 wxWindow* win = (wxWindow*) node->Data();
1145 if (SendIdleEvents(win))
1146 needMore = TRUE;
2bda0e17 1147
e5c0b16a
VZ
1148 node = node->Next();
1149 }
42e69d6b 1150 return needMore;
2bda0e17
KB
1151}
1152
bb6290e3 1153void wxApp::DeletePendingObjects()
2bda0e17 1154{
e5c0b16a
VZ
1155 wxNode *node = wxPendingDelete.First();
1156 while (node)
1157 {
1158 wxObject *obj = (wxObject *)node->Data();
d50b2a58 1159
e5c0b16a 1160 delete obj;
2bda0e17 1161
e5c0b16a
VZ
1162 if (wxPendingDelete.Member(obj))
1163 delete node;
2bda0e17 1164
e5c0b16a
VZ
1165 // Deleting one object may have deleted other pending
1166 // objects, so start from beginning of list again.
1167 node = wxPendingDelete.First();
1168 }
2bda0e17
KB
1169}
1170
57c208c5 1171void wxApp::OnEndSession(wxCloseEvent& WXUNUSED(event))
387a3b02
JS
1172{
1173 if (GetTopWindow())
1174 GetTopWindow()->Close(TRUE);
1175}
1176
1177// Default behaviour: close the application with prompts. The
1178// user can veto the close, and therefore the end session.
1179void wxApp::OnQueryEndSession(wxCloseEvent& event)
1180{
1181 if (GetTopWindow())
1182 {
1183 if (!GetTopWindow()->Close(!event.CanVeto()))
1184 event.Veto(TRUE);
1185 }
1186}
1187
6d167489
VZ
1188/* static */
1189int wxApp::GetComCtl32Version()
1190{
04ef50df
JS
1191#ifdef __WXMICROWIN__
1192 return 0;
1193#else
6d167489 1194 // cache the result
bdc72a22
VZ
1195 static int s_verComCtl32 = -1;
1196
1197 wxCRIT_SECT_DECLARE(csComCtl32);
1198 wxCRIT_SECT_LOCKER(lock, csComCtl32);
6d167489
VZ
1199
1200 if ( s_verComCtl32 == -1 )
1201 {
bdc72a22 1202 // initally assume no comctl32.dll at all
6d167489
VZ
1203 s_verComCtl32 = 0;
1204
bdc72a22
VZ
1205 // do we have it?
1206 HMODULE hModuleComCtl32 = ::GetModuleHandle(wxT("COMCTL32"));
6d167489
VZ
1207
1208 // if so, then we can check for the version
bdc72a22 1209 if ( hModuleComCtl32 )
bb6290e3 1210 {
bdc72a22
VZ
1211 // try to use DllGetVersion() if available in _headers_
1212 #ifdef DLLVER_PLATFORM_WINDOWS // defined in shlwapi.h
1213 DLLGETVERSIONPROC pfnDllGetVersion = (DLLGETVERSIONPROC)
f6bcfd97 1214 ::GetProcAddress(hModuleComCtl32, "DllGetVersion");
bdc72a22 1215 if ( pfnDllGetVersion )
6d167489 1216 {
bdc72a22
VZ
1217 DLLVERSIONINFO dvi;
1218 dvi.cbSize = sizeof(dvi);
1219
1220 HRESULT hr = (*pfnDllGetVersion)(&dvi);
1221 if ( FAILED(hr) )
1222 {
1223 wxLogApiError(_T("DllGetVersion"), hr);
1224 }
1225 else
1226 {
1227 // this is incompatible with _WIN32_IE values, but
1228 // compatible with the other values returned by
1229 // GetComCtl32Version()
1230 s_verComCtl32 = 100*dvi.dwMajorVersion +
1231 dvi.dwMinorVersion;
1232 }
6d167489 1233 }
bdc72a22
VZ
1234 #endif
1235 // DllGetVersion() unavailable either during compile or
1236 // run-time, try to guess the version otherwise
1237 if ( !s_verComCtl32 )
1238 {
1239 // InitCommonControlsEx is unique to 4.70 and later
1240 FARPROC theProc = ::GetProcAddress
1241 (
1242 hModuleComCtl32,
a8ee71c7 1243 "InitCommonControlsEx"
bdc72a22
VZ
1244 );
1245
1246 if ( !theProc )
1247 {
1248 // not found, must be 4.00
1249 s_verComCtl32 = 400;
1250 }
1251 else
1252 {
1253 // many symbols appeared in comctl32 4.71, could use
1254 // any of them except may be DllInstall
1255 theProc = ::GetProcAddress
1256 (
1257 hModuleComCtl32,
a8ee71c7 1258 "InitializeFlatSB"
bdc72a22
VZ
1259 );
1260 if ( !theProc )
1261 {
1262 // not found, must be 4.70
1263 s_verComCtl32 = 470;
1264 }
1265 else
1266 {
1267 // found, must be 4.71
1268 s_verComCtl32 = 471;
1269 }
1270 }
6d167489 1271 }
bb6290e3
JS
1272 }
1273 }
6d167489
VZ
1274
1275 return s_verComCtl32;
04ef50df 1276#endif
bb6290e3
JS
1277}
1278
1279void wxExit()
2bda0e17 1280{
e5c0b16a
VZ
1281 wxLogError(_("Fatal error: exiting"));
1282
1283 wxApp::CleanUp();
3f8e5072 1284 exit(0);
2bda0e17
KB
1285}
1286
1287// Yield to incoming messages
cb2713bf 1288
8461e4c2 1289bool wxApp::Yield(bool onlyIfNeeded)
2bda0e17 1290{
8461e4c2
VZ
1291 // MT-FIXME
1292 static bool s_inYield = FALSE;
1293
2ed3265e
VZ
1294 // disable log flushing from here because a call to wxYield() shouldn't
1295 // normally result in message boxes popping up &c
1296 wxLog::Suspend();
1297
8461e4c2
VZ
1298 if ( s_inYield )
1299 {
1300 if ( !onlyIfNeeded )
1301 {
1302 wxFAIL_MSG( wxT("wxYield called recursively" ) );
1303 }
33ac7e6f 1304
8461e4c2
VZ
1305 return FALSE;
1306 }
1307
1308 s_inYield = TRUE;
cb2713bf 1309
8e193f38
VZ
1310 // we don't want to process WM_QUIT from here - it should be processed in
1311 // the main event loop in order to stop it
e5c0b16a 1312 MSG msg;
8e193f38
VZ
1313 while ( PeekMessage(&msg, (HWND)0, 0, 0, PM_NOREMOVE) &&
1314 msg.message != WM_QUIT )
e5c0b16a 1315 {
5b615ed8
VZ
1316#if wxUSE_THREADS
1317 wxMutexGuiLeaveOrEnter();
1318#endif // wxUSE_THREADS
1319
e5c0b16a
VZ
1320 if ( !wxTheApp->DoMessage() )
1321 break;
1322 }
8e193f38 1323
8461e4c2
VZ
1324 // if there are pending events, we must process them.
1325 ProcessPendingEvents();
e5c0b16a 1326
2ed3265e
VZ
1327 // let the logs be flashed again
1328 wxLog::Resume();
1329
8461e4c2 1330 s_inYield = FALSE;
cb2713bf 1331
e5c0b16a 1332 return TRUE;
2bda0e17 1333}
094637f6 1334
3b415ba4
VZ
1335bool wxHandleFatalExceptions(bool doit)
1336{
1337#if wxUSE_ON_FATAL_EXCEPTION
1338 // assume this can only be called from the main thread
1339 gs_handleExceptions = doit;
1340
1341 return TRUE;
1342#else
8461e4c2
VZ
1343 wxFAIL_MSG(_T("set wxUSE_ON_FATAL_EXCEPTION to 1 to use this function"));
1344
1345 (void)doit;
3b415ba4
VZ
1346 return FALSE;
1347#endif
1348}
1349
9779893b
RD
1350//-----------------------------------------------------------------------------
1351// wxWakeUpIdle
1352//-----------------------------------------------------------------------------
1353
1354void wxWakeUpIdle()
1355{
1356 // Send the top window a dummy message so idle handler processing will
1357 // start up again. Doing it this way ensures that the idle handler
b568d04f
VZ
1358 // wakes up in the right thread (see also wxWakeUpMainThread() which does
1359 // the same for the main app thread only)
9779893b 1360 wxWindow *topWindow = wxTheApp->GetTopWindow();
b568d04f
VZ
1361 if ( topWindow )
1362 {
1363 if ( !::PostMessage(GetHwndOf(topWindow), WM_NULL, 0, 0) )
1364 {
1365 // should never happen
f6bcfd97 1366 wxLogLastError(wxT("PostMessage(WM_NULL)"));
b568d04f 1367 }
9779893b
RD
1368 }
1369}
1370
1371//-----------------------------------------------------------------------------
1372
2bda0e17
KB
1373// For some reason, with MSVC++ 1.5, WinMain isn't linked in properly
1374// if in a separate file. So include it here to ensure it's linked.
31e78e0c 1375#if (defined(__VISUALC__) && !defined(__WIN32__)) || (defined(__GNUWIN32__) && !defined(__TWIN32__) && !defined(WXMAKINGDLL))
e5c0b16a 1376#include "main.cpp"
2bda0e17 1377#endif