]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/gtk/app.cpp
Corrected small mistake (set static variable)
[wxWidgets.git] / src / gtk / app.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: app.cpp
3// Purpose:
4// Author: Robert Roebling
5// Id: $Id$
6// Copyright: (c) 1998 Robert Roebling, Julian Smart
7// Licence: wxWindows licence
8/////////////////////////////////////////////////////////////////////////////
9
10#ifdef __GNUG__
11 #pragma implementation "app.h"
12#endif
13
14#include "wx/app.h"
15#include "wx/gdicmn.h"
16#include "wx/utils.h"
17#include "wx/intl.h"
18#include "wx/log.h"
19#include "wx/memory.h"
20#include "wx/font.h"
21#include "wx/settings.h"
22#include "wx/dialog.h"
23
24#if wxUSE_WX_RESOURCES
25 #include "wx/resource.h"
26#endif
27
28#include "wx/module.h"
29#include "wx/image.h"
30
31#if wxUSE_THREADS
32#include "wx/thread.h"
33#endif
34
35#include "unistd.h"
36
37#include "glib.h"
38#include "gdk/gdk.h"
39#include "gtk/gtk.h"
40
41#include "wx/gtk/win_gtk.h"
42
43//-----------------------------------------------------------------------------
44// global data
45//-----------------------------------------------------------------------------
46
47wxApp *wxTheApp = (wxApp *) NULL;
48wxAppInitializerFunction wxAppBase::m_appInitFn = (wxAppInitializerFunction) NULL;
49
50extern wxResourceCache *wxTheResourceCache;
51extern bool g_isIdle;
52
53unsigned char g_palette[64*3] =
54{
55 0x0, 0x0, 0x0,
56 0xff, 0xff, 0xff,
57 0xff, 0x0, 0x0,
58 0xff, 0xff, 0x0,
59 0x0, 0xff, 0x0,
60 0x0, 0x0, 0xff,
61 0x0, 0xff, 0xff,
62 0x99, 0x99, 0x99,
63 0xff, 0x88, 0x0,
64 0x88, 0x0, 0x0,
65 0x0, 0x88, 0x88,
66 0x88, 0x88, 0x0,
67 0xff, 0xcc, 0x97,
68 0xbb, 0xbb, 0xbb,
69 0x9f, 0x6b, 0x42,
70 0x55, 0x55, 0x55,
71 0xdd, 0xdd, 0xdd,
72 0x77, 0x77, 0x77,
73 0x33, 0x33, 0x33,
74 0xcc, 0x0, 0x0,
75 0xff, 0x44, 0x0,
76 0xff, 0xcc, 0x0,
77 0xcc, 0xcc, 0x0,
78 0x60, 0x60, 0x0,
79 0x0, 0x43, 0x0,
80 0x0, 0x7f, 0x0,
81 0x0, 0xcc, 0x0,
82 0x0, 0x44, 0x44,
83 0x0, 0x0, 0x44,
84 0x0, 0x0, 0x88,
85 0xef, 0xb1, 0x7b,
86 0xdf, 0x98, 0x5f,
87 0xbf, 0x87, 0x56,
88 0x7f, 0x57, 0x26,
89 0x5f, 0x39, 0xc,
90 0x3f, 0x1c, 0x0,
91 0x21, 0x0, 0x0,
92 0x0, 0x43, 0x87,
93 0x2d, 0x70, 0xaf,
94 0x5a, 0x9e, 0xd7,
95 0x87, 0xcc, 0xff,
96 0xff, 0xe0, 0xba,
97 0x21, 0x43, 0xf,
98 0x3d, 0x5d, 0x25,
99 0x59, 0x78, 0x3a,
100 0x75, 0x93, 0x4f,
101 0x91, 0xae, 0x64,
102 0xad, 0xc8, 0x7a,
103 0xf0, 0xa8, 0xef,
104 0xd0, 0x88, 0xd0,
105 0xaf, 0x66, 0xaf,
106 0x8e, 0x44, 0x8e,
107 0x6d, 0x22, 0x6d,
108 0x4b, 0x0, 0x4b,
109 0xff, 0xc0, 0xbc,
110 0xff, 0x93, 0x91,
111 0xff, 0x66, 0x67,
112 0xd8, 0xf2, 0xbf,
113 0xff, 0xc9, 0x68,
114 0xff, 0x96, 0x67,
115 0xa5, 0x60, 0xff,
116 0x51, 0xff, 0x99,
117 0x3f, 0xa5, 0x63,
118 0x98, 0x90, 0x67
119};
120
121//-----------------------------------------------------------------------------
122// local functions
123//-----------------------------------------------------------------------------
124
125extern void wxFlushResources();
126
127//-----------------------------------------------------------------------------
128// global functions
129//-----------------------------------------------------------------------------
130
131void wxExit()
132{
133 gtk_main_quit();
134}
135
136/* forward declaration */
137gint wxapp_idle_callback( gpointer WXUNUSED(data) );
138
139bool wxYield()
140{
141 bool has_idle = (wxTheApp->m_idleTag != 0);
142
143 if (has_idle)
144 {
145 /* We need to temporarily remove idle callbacks or the loop will
146 never finish. */
147 gtk_idle_remove( wxTheApp->m_idleTag );
148 wxTheApp->m_idleTag = 0;
149 }
150
151 while (gtk_events_pending())
152 gtk_main_iteration();
153
154 /* it's necessary to call ProcessIdle() to update the frames sizes which
155 might have been changed (it also will update other things set from
156 OnUpdateUI() which is a nice (and desired) side effect) */
157 while (wxTheApp->ProcessIdle()) { }
158
159 if (has_idle)
160 {
161 /* re-add idle handler */
162 wxTheApp->m_idleTag = gtk_idle_add( wxapp_idle_callback, (gpointer) NULL );
163 }
164
165 return TRUE;
166}
167
168gint wxapp_idle_callback( gpointer WXUNUSED(data) )
169{
170 if (!wxTheApp) return TRUE;
171
172#if (GTK_MINOR_VERSION > 0)
173 /* when getting called from GDK's idle handler we
174 are no longer within GDK's grab on the GUI
175 thread so we must lock it here ourselves */
176 GDK_THREADS_ENTER ();
177#endif
178
179 /* sent idle event to all who request them */
180 while (wxTheApp->ProcessIdle()) { }
181
182 /* we don't want any more idle events until the next event is
183 sent to wxGTK */
184 gtk_idle_remove( wxTheApp->m_idleTag );
185 wxTheApp->m_idleTag = 0;
186
187 /* indicate that we are now in idle mode - even so deeply
188 in idle mode that we don't get any idle events anymore.
189 this is like wxMSW where an idle event is sent only
190 once each time after the event queue has been completely
191 emptied */
192 g_isIdle = TRUE;
193
194#if (GTK_MINOR_VERSION > 0)
195 /* release lock again */
196 GDK_THREADS_LEAVE ();
197#endif
198
199 return TRUE;
200}
201
202void wxapp_install_idle_handler()
203{
204 wxASSERT_MSG( wxTheApp->m_idleTag == 0, wxT("attempt to install idle handler twice") );
205
206 /* this routine gets called by all event handlers
207 indicating that the idle is over. */
208
209 wxTheApp->m_idleTag = gtk_idle_add( wxapp_idle_callback, (gpointer) NULL );
210
211 g_isIdle = FALSE;
212}
213
214#if wxUSE_THREADS
215
216/* forward declaration */
217static gint wxapp_wakeup_timerout_callback( gpointer WXUNUSED(data) );
218
219void wxapp_install_thread_wakeup()
220{
221 if (wxTheApp->m_wakeUpTimerTag) return;
222
223 wxTheApp->m_wakeUpTimerTag = gtk_timeout_add( 100, wxapp_wakeup_timerout_callback, (gpointer) NULL );
224}
225
226void wxapp_uninstall_thread_wakeup()
227{
228 if (!wxTheApp->m_wakeUpTimerTag) return;
229
230 gtk_timeout_remove( wxTheApp->m_wakeUpTimerTag );
231 wxTheApp->m_wakeUpTimerTag = 0;
232}
233
234static gint wxapp_wakeup_timerout_callback( gpointer WXUNUSED(data) )
235{
236 wxapp_uninstall_thread_wakeup();
237
238#if (GTK_MINOR_VERSION > 0)
239 // when getting called from GDK's time-out handler
240 // we are no longer within GDK's grab on the GUI
241 // thread so we must lock it here ourselves
242 GDK_THREADS_ENTER ();
243#endif
244
245 // unblock other threads wishing to do some GUI things
246 wxMutexGuiLeave();
247
248 // wake up other threads
249 wxUsleep( 1 );
250
251 // block other thread again
252 wxMutexGuiEnter();
253
254#if (GTK_MINOR_VERSION > 0)
255 // release lock again
256 GDK_THREADS_LEAVE ();
257#endif
258
259 wxapp_install_thread_wakeup();
260
261 return TRUE;
262}
263
264#endif // wxUSE_THREADS
265
266//-----------------------------------------------------------------------------
267// wxApp
268//-----------------------------------------------------------------------------
269
270IMPLEMENT_DYNAMIC_CLASS(wxApp,wxEvtHandler)
271
272BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
273 EVT_IDLE(wxApp::OnIdle)
274END_EVENT_TABLE()
275
276wxApp::wxApp()
277{
278 wxTheApp = this;
279
280 m_topWindow = (wxWindow *) NULL;
281 m_exitOnFrameDelete = TRUE;
282
283 m_idleTag = gtk_idle_add( wxapp_idle_callback, (gpointer) NULL );
284
285#if wxUSE_THREADS
286 m_wakeUpTimerTag = 0;
287 wxapp_install_thread_wakeup();
288#endif
289
290 m_colorCube = (unsigned char*) NULL;
291}
292
293wxApp::~wxApp()
294{
295 if (m_idleTag) gtk_idle_remove( m_idleTag );
296
297#if wxUSE_THREADS
298 wxapp_uninstall_thread_wakeup();
299#endif
300
301 if (m_colorCube) free(m_colorCube);
302}
303
304bool wxApp::OnInitGui()
305{
306 GdkVisual *visual = gdk_visual_get_system();
307
308 /* on some machines, the default visual is just 256 colours, so
309 we make sure we get the best. this can sometimes be wasteful,
310 of course, but what do these guys pay $30.000 for? */
311/*
312 if (gdk_visual_get_best() != gdk_visual_get_system())
313 {
314 GdkVisual* vis = gdk_visual_get_best();
315 gtk_widget_set_default_visual( vis );
316
317 GdkColormap *colormap = gdk_colormap_new( vis, FALSE );
318 gtk_widget_set_default_colormap( colormap );
319
320 visual = vis;
321 }
322*/
323
324 /* Nothing to do for 15, 16, 24, 32 bit displays */
325 if (visual->depth > 8) return TRUE;
326
327 /* this initiates the standard palette as defined by GdkImlib
328 in the GNOME libraries. it ensures that all GNOME applications
329 use the same 64 colormap entries on 8-bit displays so you
330 can use several rather graphics-heavy applications at the
331 same time.
332 NOTE: this doesn't really seem to work this way... */
333
334 /*
335 GdkColormap *cmap = gdk_colormap_new( gdk_visual_get_system(), TRUE );
336
337 for (int i = 0; i < 64; i++)
338 {
339 GdkColor col;
340 col.red = g_palette[i*3 + 0] << 8;
341 col.green = g_palette[i*3 + 1] << 8;
342 col.blue = g_palette[i*3 + 2] << 8;
343 col.pixel = 0;
344
345 gdk_color_alloc( cmap, &col );
346 }
347
348 gtk_widget_set_default_colormap( cmap );
349 */
350
351 /* initialize color cube for 8-bit color reduction dithering */
352
353 GdkColormap *cmap = gtk_widget_get_default_colormap();
354
355 m_colorCube = (unsigned char*)malloc(32 * 32 * 32);
356
357 for (int r = 0; r < 32; r++)
358 {
359 for (int g = 0; g < 32; g++)
360 {
361 for (int b = 0; b < 32; b++)
362 {
363 int rr = (r << 3) | (r >> 2);
364 int gg = (g << 3) | (g >> 2);
365 int bb = (b << 3) | (b >> 2);
366
367 int index = -1;
368
369 GdkColor *colors = cmap->colors;
370 if (colors)
371 {
372 int max = 3 * 65536;
373
374 for (int i = 0; i < cmap->size; i++)
375 {
376 int rdiff = ((rr << 8) - colors[i].red);
377 int gdiff = ((gg << 8) - colors[i].green);
378 int bdiff = ((bb << 8) - colors[i].blue);
379 int sum = ABS (rdiff) + ABS (gdiff) + ABS (bdiff);
380 if (sum < max)
381 {
382 index = i; max = sum;
383 }
384 }
385 }
386 else
387 {
388#if (GTK_MINOR_VERSION > 0)
389 /* assume 8-bit true or static colors. this really
390 exists. */
391 GdkVisual* vis = gdk_colormap_get_visual( cmap );
392 index = (r >> (5 - vis->red_prec)) << vis->red_shift;
393 index |= (g >> (5 - vis->green_prec)) << vis->green_shift;
394 index |= (b >> (5 - vis->blue_prec)) << vis->blue_shift;
395#else
396 wxFAIL_MSG( wxT("Unsupported graphics hardware") );
397#endif
398 }
399 m_colorCube[ (r*1024) + (g*32) + b ] = index;
400 }
401 }
402 }
403
404 return TRUE;
405}
406
407bool wxApp::ProcessIdle()
408{
409 wxIdleEvent event;
410 event.SetEventObject( this );
411 ProcessEvent( event );
412
413 return event.MoreRequested();
414}
415
416void wxApp::OnIdle( wxIdleEvent &event )
417{
418 static bool s_inOnIdle = FALSE;
419
420 /* Avoid recursion (via ProcessEvent default case) */
421 if (s_inOnIdle)
422 return;
423
424 s_inOnIdle = TRUE;
425
426 /* Resend in the main thread events which have been prepared in other
427 threads */
428 ProcessPendingEvents();
429
430 /* 'Garbage' collection of windows deleted with Close(). */
431 DeletePendingObjects();
432
433 /* flush the logged messages if any */
434#if wxUSE_LOG
435 wxLog *log = wxLog::GetActiveTarget();
436 if (log != NULL && log->HasPendingMessages())
437 log->Flush();
438#endif // wxUSE_LOG
439
440 /* Send OnIdle events to all windows */
441 bool needMore = SendIdleEvents();
442
443 if (needMore)
444 event.RequestMore(TRUE);
445
446 s_inOnIdle = FALSE;
447}
448
449bool wxApp::SendIdleEvents()
450{
451 bool needMore = FALSE;
452
453 wxWindowList::Node* node = wxTopLevelWindows.GetFirst();
454 while (node)
455 {
456 wxWindow* win = node->GetData();
457 if (SendIdleEvents(win))
458 needMore = TRUE;
459 node = node->GetNext();
460 }
461
462 return needMore;
463}
464
465bool wxApp::SendIdleEvents( wxWindow* win )
466{
467 bool needMore = FALSE;
468
469 wxIdleEvent event;
470 event.SetEventObject(win);
471
472 win->ProcessEvent(event);
473
474 win->OnInternalIdle();
475
476 if (event.MoreRequested())
477 needMore = TRUE;
478
479 wxNode* node = win->GetChildren().First();
480 while (node)
481 {
482 wxWindow* win = (wxWindow*) node->Data();
483 if (SendIdleEvents(win))
484 needMore = TRUE;
485
486 node = node->Next();
487 }
488 return needMore ;
489}
490
491int wxApp::MainLoop()
492{
493 gtk_main();
494 return 0;
495}
496
497void wxApp::ExitMainLoop()
498{
499 gtk_main_quit();
500}
501
502bool wxApp::Initialized()
503{
504 return m_initialized;
505}
506
507bool wxApp::Pending()
508{
509 return (gtk_events_pending() > 0);
510}
511
512void wxApp::Dispatch()
513{
514 gtk_main_iteration();
515}
516
517void wxApp::DeletePendingObjects()
518{
519 wxNode *node = wxPendingDelete.First();
520 while (node)
521 {
522 wxObject *obj = (wxObject *)node->Data();
523
524 delete obj;
525
526 if (wxPendingDelete.Find(obj))
527 delete node;
528
529 node = wxPendingDelete.First();
530 }
531}
532
533bool wxApp::Initialize()
534{
535 wxBuffer = new wxChar[BUFSIZ + 512];
536
537 wxClassInfo::InitializeClasses();
538
539 wxSystemSettings::Init();
540
541 // GL: I'm annoyed ... I don't know where to put this and I don't want to
542 // create a module for that as it's part of the core.
543#if wxUSE_THREADS
544 wxPendingEvents = new wxList();
545 wxPendingEventsLocker = new wxCriticalSection();
546#endif
547
548/*
549 wxTheFontNameDirectory = new wxFontNameDirectory;
550 wxTheFontNameDirectory->Initialize();
551*/
552
553 wxTheColourDatabase = new wxColourDatabase( wxKEY_STRING );
554 wxTheColourDatabase->Initialize();
555
556 wxInitializeStockLists();
557 wxInitializeStockObjects();
558
559#if wxUSE_WX_RESOURCES
560 wxTheResourceCache = new wxResourceCache( wxKEY_STRING );
561
562 wxInitializeResourceSystem();
563#endif
564
565 wxModule::RegisterModules();
566 if (!wxModule::InitializeModules()) return FALSE;
567
568 return TRUE;
569}
570
571void wxApp::CleanUp()
572{
573 wxModule::CleanUpModules();
574
575#if wxUSE_WX_RESOURCES
576 wxFlushResources();
577
578 if (wxTheResourceCache)
579 delete wxTheResourceCache;
580 wxTheResourceCache = (wxResourceCache*) NULL;
581
582 wxCleanUpResourceSystem();
583#endif
584
585 if (wxTheColourDatabase)
586 delete wxTheColourDatabase;
587 wxTheColourDatabase = (wxColourDatabase*) NULL;
588
589/*
590 if (wxTheFontNameDirectory) delete wxTheFontNameDirectory;
591 wxTheFontNameDirectory = (wxFontNameDirectory*) NULL;
592*/
593
594 wxDeleteStockObjects();
595
596 wxDeleteStockLists();
597
598 delete wxTheApp;
599 wxTheApp = (wxApp*) NULL;
600
601 // GL: I'm annoyed ... I don't know where to put this and I don't want to
602 // create a module for that as it's part of the core.
603#if wxUSE_THREADS
604 delete wxPendingEvents;
605 delete wxPendingEventsLocker;
606#endif
607
608 wxSystemSettings::Done();
609
610 delete[] wxBuffer;
611
612 wxClassInfo::CleanUpClasses();
613
614 // check for memory leaks
615#if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
616 if (wxDebugContext::CountObjectsLeft() > 0)
617 {
618 wxLogDebug(wxT("There were memory leaks.\n"));
619 wxDebugContext::Dump();
620 wxDebugContext::PrintStatistics();
621 }
622#endif // Debug
623
624#if wxUSE_LOG
625 // do this as the very last thing because everything else can log messages
626 wxLog::DontCreateOnDemand();
627
628 wxLog *oldLog = wxLog::SetActiveTarget( (wxLog*) NULL );
629 if (oldLog)
630 delete oldLog;
631#endif // wxUSE_LOG
632}
633
634//-----------------------------------------------------------------------------
635// wxEntry
636//-----------------------------------------------------------------------------
637
638int wxEntry( int argc, char *argv[] )
639{
640 gtk_set_locale();
641
642#if wxUSE_WCHAR_T
643 if (!wxOKlibc()) wxConvCurrent = &wxConvLocal;
644#else
645 if (!wxOKlibc()) wxConvCurrent = (wxMBConv*) NULL;
646#endif
647
648 gtk_init( &argc, &argv );
649
650 wxSetDetectableAutoRepeat( TRUE );
651
652 if (!wxApp::Initialize())
653 return -1;
654
655 if (!wxTheApp)
656 {
657 wxCHECK_MSG( wxApp::GetInitializerFunction(), -1,
658 wxT("wxWindows error: No initializer - use IMPLEMENT_APP macro.\n") );
659
660 wxAppInitializerFunction app_ini = wxApp::GetInitializerFunction();
661
662 wxObject *test_app = app_ini();
663
664 wxTheApp = (wxApp*) test_app;
665 }
666
667 wxCHECK_MSG( wxTheApp, -1, wxT("wxWindows error: no application object") );
668
669 wxTheApp->argc = argc;
670#if wxUSE_UNICODE
671 wxTheApp->argv = new wxChar*[argc+1];
672 int mb_argc = 0;
673 while (mb_argc < argc) {
674 wxTheApp->argv[mb_argc] = wxStrdup(wxConvLibc.cMB2WX(argv[mb_argc]));
675 mb_argc++;
676 }
677 wxTheApp->argv[mb_argc] = (wxChar *)NULL;
678#else
679 wxTheApp->argv = argv;
680#endif
681
682 wxString name(wxFileNameFromPath(argv[0]));
683 wxStripExtension( name );
684 wxTheApp->SetAppName( name );
685
686 int retValue = 0;
687
688 if ( !wxTheApp->OnInitGui() )
689 retValue = -1;
690
691 // Here frames insert themselves automatically into wxTopLevelWindows by
692 // getting created in OnInit().
693 if ( retValue == 0 )
694 {
695 if ( !wxTheApp->OnInit() )
696 retValue = -1;
697 }
698
699 if ( retValue == 0 )
700 {
701 /* delete pending toplevel windows (typically a single
702 dialog) so that, if there isn't any left, we don't
703 call OnRun() */
704 wxTheApp->DeletePendingObjects();
705
706 wxTheApp->m_initialized = wxTopLevelWindows.GetCount() != 0;
707
708 if (wxTheApp->Initialized())
709 {
710 retValue = wxTheApp->OnRun();
711
712 wxWindow *topWindow = wxTheApp->GetTopWindow();
713 if (topWindow)
714 {
715 /* Forcibly delete the window. */
716 if (topWindow->IsKindOf(CLASSINFO(wxFrame)) ||
717 topWindow->IsKindOf(CLASSINFO(wxDialog)) )
718 {
719 topWindow->Close( TRUE );
720 wxTheApp->DeletePendingObjects();
721 }
722 else
723 {
724 delete topWindow;
725 wxTheApp->SetTopWindow( (wxWindow*) NULL );
726 }
727 }
728 wxTheApp->OnExit();
729 }
730 }
731
732#if wxUSE_LOG
733 // flush the logged messages if any
734 wxLog *log = wxLog::GetActiveTarget();
735 if (log != NULL && log->HasPendingMessages())
736 log->Flush();
737
738 // continuing to use user defined log target is unsafe from now on because
739 // some resources may be already unavailable, so replace it by something
740 // more safe
741 wxLog *oldlog = wxLog::SetActiveTarget(new wxLogStderr);
742 if ( oldlog )
743 delete oldlog;
744#endif // wxUSE_LOG
745
746 wxApp::CleanUp();
747
748 return retValue;
749}
750
751#include "wx/gtk/info.xpm"
752#include "wx/gtk/error.xpm"
753#include "wx/gtk/question.xpm"
754#include "wx/gtk/warning.xpm"
755
756wxIcon
757wxApp::GetStdIcon(int which) const
758{
759 switch(which)
760 {
761 case wxICON_INFORMATION:
762 return wxIcon(info_xpm);
763
764 case wxICON_QUESTION:
765 return wxIcon(question_xpm);
766
767 case wxICON_EXCLAMATION:
768 return wxIcon(warning_xpm);
769
770 default:
771 wxFAIL_MSG(wxT("requested non existent standard icon"));
772 // still fall through
773
774 case wxICON_HAND:
775 return wxIcon(error_xpm);
776 }
777}