[ 1216436 ] cleanup 'shadow variable' warnings from gcc in headers.
[wxWidgets.git] / src / gtk / app.cpp
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 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
11 #pragma implementation "app.h"
12 #endif
13
14 #ifdef __VMS
15 // vms_jackets.h should for proper working be included before anything else
16 # include <vms_jackets.h>
17 #undef ConnectionNumber
18 #endif
19
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
22
23 #include "wx/app.h"
24 #include "wx/gdicmn.h"
25 #include "wx/utils.h"
26 #include "wx/intl.h"
27 #include "wx/log.h"
28 #include "wx/memory.h"
29 #include "wx/font.h"
30 #include "wx/settings.h"
31 #include "wx/dialog.h"
32 #include "wx/msgdlg.h"
33 #include "wx/file.h"
34 #include "wx/filename.h"
35 #include "wx/module.h"
36 #include "wx/image.h"
37 #include "wx/thread.h"
38
39 #ifdef __WXGPE__
40 #include <gpe/init.h>
41 #endif
42
43 #ifdef __WXUNIVERSAL__
44 #include "wx/univ/theme.h"
45 #include "wx/univ/renderer.h"
46 #endif
47
48 #if wxUSE_THREADS
49 #include "wx/thread.h"
50 #endif
51
52 #include <unistd.h>
53
54 #ifdef HAVE_POLL
55 #if defined(__VMS)
56 #include <poll.h>
57 #else
58 // bug in the OpenBSD headers: at least in 3.1 there is no extern "C"
59 // in neither poll.h nor sys/poll.h which results in link errors later
60 #ifdef __OPENBSD__
61 extern "C"
62 {
63 #endif
64
65 #include <sys/poll.h>
66
67 #ifdef __OPENBSD__
68 };
69 #endif
70 #endif // platform
71 #else // !HAVE_POLL
72 // we implement poll() ourselves using select() which is supposed exist in
73 // all modern Unices
74 #include <sys/types.h>
75 #include <sys/time.h>
76 #include <unistd.h>
77 #endif // HAVE_POLL/!HAVE_POLL
78
79 #include "wx/gtk/win_gtk.h"
80
81 #include <gtk/gtk.h>
82
83 //-----------------------------------------------------------------------------
84 // global data
85 //-----------------------------------------------------------------------------
86
87 bool g_mainThreadLocked = FALSE;
88 gint g_pendingTag = 0;
89
90 static GtkWidget *gs_RootWindow = (GtkWidget*) NULL;
91
92 //-----------------------------------------------------------------------------
93 // idle system
94 //-----------------------------------------------------------------------------
95
96 extern bool g_isIdle;
97
98 void wxapp_install_idle_handler();
99
100 #if wxUSE_THREADS
101 static wxMutex gs_idleTagsMutex;
102 #endif
103
104 //-----------------------------------------------------------------------------
105 // wxYield
106 //-----------------------------------------------------------------------------
107
108 // not static because used by textctrl.cpp
109 //
110 // MT-FIXME
111 bool wxIsInsideYield = FALSE;
112
113 bool wxApp::Yield(bool onlyIfNeeded)
114 {
115 if ( wxIsInsideYield )
116 {
117 if ( !onlyIfNeeded )
118 {
119 wxFAIL_MSG( wxT("wxYield called recursively" ) );
120 }
121
122 return FALSE;
123 }
124
125 #if wxUSE_THREADS
126 if ( !wxThread::IsMain() )
127 {
128 // can't call gtk_main_iteration() from other threads like this
129 return TRUE;
130 }
131 #endif // wxUSE_THREADS
132
133 wxIsInsideYield = TRUE;
134
135 // We need to remove idle callbacks or the loop will
136 // never finish.
137 wxTheApp->RemoveIdleTag();
138
139 #if wxUSE_LOG
140 // disable log flushing from here because a call to wxYield() shouldn't
141 // normally result in message boxes popping up &c
142 wxLog::Suspend();
143 #endif
144
145 while (gtk_events_pending())
146 gtk_main_iteration();
147
148 // It's necessary to call ProcessIdle() to update the frames sizes which
149 // might have been changed (it also will update other things set from
150 // OnUpdateUI() which is a nice (and desired) side effect). But we
151 // call ProcessIdle() only once since this is not meant for longish
152 // background jobs (controlled by wxIdleEvent::RequestMore() and the
153 // return value of Processidle().
154 ProcessIdle();
155
156 #if wxUSE_LOG
157 // let the logs be flashed again
158 wxLog::Resume();
159 #endif
160
161 wxIsInsideYield = FALSE;
162
163 return TRUE;
164 }
165
166 //-----------------------------------------------------------------------------
167 // wxWakeUpIdle
168 //-----------------------------------------------------------------------------
169
170 // RR/KH: The wxMutexGui calls are not needed on GTK2 according to
171 // the GTK faq, http://www.gtk.org/faq/#AEN500
172 // The calls to gdk_threads_enter() and leave() are specifically noted
173 // as not being necessary. The MutexGui calls are still left in for GTK1.
174 // Eliminating the MutexGui calls fixes the long-standing "random" lockup
175 // when using wxPostEvent (which calls WakeUpIdle) from a thread.
176
177 void wxApp::WakeUpIdle()
178 {
179 #ifndef __WXGTK20__
180 #if wxUSE_THREADS
181 if (!wxThread::IsMain())
182 wxMutexGuiEnter();
183 #endif // wxUSE_THREADS_
184 #endif // __WXGTK2__
185
186 wxapp_install_idle_handler();
187
188 #ifndef __WXGTK20__
189 #if wxUSE_THREADS
190 if (!wxThread::IsMain())
191 wxMutexGuiLeave();
192 #endif // wxUSE_THREADS_
193 #endif // __WXGTK2__
194 }
195
196 //-----------------------------------------------------------------------------
197 // local functions
198 //-----------------------------------------------------------------------------
199
200 // the callback functions must be extern "C" to comply with GTK+ declarations
201 extern "C"
202 {
203
204 static gint wxapp_pending_callback( gpointer WXUNUSED(data) )
205 {
206 if (!wxTheApp) return TRUE;
207
208 // When getting called from GDK's time-out handler
209 // we are no longer within GDK's grab on the GUI
210 // thread so we must lock it here ourselves.
211 gdk_threads_enter();
212
213 // Sent idle event to all who request them.
214 wxTheApp->ProcessPendingEvents();
215
216 {
217 #if wxUSE_THREADS
218 wxMutexLocker lock(gs_idleTagsMutex);
219 #endif
220 g_pendingTag = 0;
221 }
222
223 // Flush the logged messages if any.
224 #if wxUSE_LOG
225 wxLog::FlushActive();
226 #endif // wxUSE_LOG
227
228 // Release lock again
229 gdk_threads_leave();
230
231 // Return FALSE to indicate that no more idle events are
232 // to be sent (single shot instead of continuous stream)
233 return FALSE;
234 }
235
236 static gint wxapp_idle_callback( gpointer WXUNUSED(data) )
237 {
238 if (!wxTheApp)
239 return TRUE;
240
241 #ifdef __WXDEBUG__
242 // don't generate the idle events while the assert modal dialog is shown,
243 // this completely confuses the apps which don't expect to be reentered
244 // from some safely-looking functions
245 if ( wxTheApp->IsInAssert() )
246 {
247 // But repaint the assertion message if necessary
248 if (wxTopLevelWindows.GetCount() > 0)
249 {
250 wxWindow* win = (wxWindow*) wxTopLevelWindows.GetLast()->GetData();
251 #ifdef __WXGTK20__
252 if (win->IsKindOf(CLASSINFO(wxMessageDialog)))
253 #else
254 if (win->IsKindOf(CLASSINFO(wxGenericMessageDialog)))
255 #endif
256 win->OnInternalIdle();
257 }
258 return TRUE;
259 }
260 #endif // __WXDEBUG__
261
262 // When getting called from GDK's time-out handler
263 // we are no longer within GDK's grab on the GUI
264 // thread so we must lock it here ourselves.
265 gdk_threads_enter();
266
267 // Indicate that we are now in idle mode and event handlers
268 // will have to reinstall the idle handler again.
269 {
270 #if wxUSE_THREADS
271 wxMutexLocker lock(gs_idleTagsMutex);
272 #endif
273 g_isIdle = TRUE;
274 wxTheApp->m_idleTag = 0;
275 }
276
277 // Send idle event to all who request them as long as
278 // no events have popped up in the event queue.
279 while (wxTheApp->ProcessIdle() && (gtk_events_pending() == 0))
280 ;
281
282 // Release lock again
283 gdk_threads_leave();
284
285 // Return FALSE to indicate that no more idle events are
286 // to be sent (single shot instead of continuous stream).
287 return FALSE;
288 }
289
290 #if wxUSE_THREADS
291
292 #ifdef HAVE_POLL
293 #define wxPoll poll
294 #define wxPollFd pollfd
295 #else // !HAVE_POLL
296
297 typedef GPollFD wxPollFd;
298
299 int wxPoll(wxPollFd *ufds, unsigned int nfds, int timeout)
300 {
301 // convert timeout from ms to struct timeval (s/us)
302 timeval tv_timeout;
303 tv_timeout.tv_sec = timeout/1000;
304 tv_timeout.tv_usec = (timeout%1000)*1000;
305
306 // remember the highest fd used here
307 int fdMax = -1;
308
309 // and fill the sets for select()
310 fd_set readfds;
311 fd_set writefds;
312 fd_set exceptfds;
313 FD_ZERO(&readfds);
314 FD_ZERO(&writefds);
315 FD_ZERO(&exceptfds);
316
317 unsigned int i;
318 for ( i = 0; i < nfds; i++ )
319 {
320 wxASSERT_MSG( ufds[i].fd < FD_SETSIZE, _T("fd out of range") );
321
322 if ( ufds[i].events & G_IO_IN )
323 FD_SET(ufds[i].fd, &readfds);
324
325 if ( ufds[i].events & G_IO_PRI )
326 FD_SET(ufds[i].fd, &exceptfds);
327
328 if ( ufds[i].events & G_IO_OUT )
329 FD_SET(ufds[i].fd, &writefds);
330
331 if ( ufds[i].fd > fdMax )
332 fdMax = ufds[i].fd;
333 }
334
335 fdMax++;
336 int res = select(fdMax, &readfds, &writefds, &exceptfds, &tv_timeout);
337
338 // translate the results back
339 for ( i = 0; i < nfds; i++ )
340 {
341 ufds[i].revents = 0;
342
343 if ( FD_ISSET(ufds[i].fd, &readfds ) )
344 ufds[i].revents |= G_IO_IN;
345
346 if ( FD_ISSET(ufds[i].fd, &exceptfds ) )
347 ufds[i].revents |= G_IO_PRI;
348
349 if ( FD_ISSET(ufds[i].fd, &writefds ) )
350 ufds[i].revents |= G_IO_OUT;
351 }
352
353 return res;
354 }
355
356 #endif // HAVE_POLL/!HAVE_POLL
357
358 static gint wxapp_poll_func( GPollFD *ufds, guint nfds, gint timeout )
359 {
360 gdk_threads_enter();
361
362 wxMutexGuiLeave();
363 g_mainThreadLocked = TRUE;
364
365 // we rely on the fact that glib GPollFD struct is really just pollfd but
366 // I wonder how wise is this in the long term (VZ)
367 gint res = wxPoll( (wxPollFd *) ufds, nfds, timeout );
368
369 wxMutexGuiEnter();
370 g_mainThreadLocked = FALSE;
371
372 gdk_threads_leave();
373
374 return res;
375 }
376
377 #endif // wxUSE_THREADS
378
379 } // extern "C"
380
381 void wxapp_install_idle_handler()
382 {
383 #if wxUSE_THREADS
384 wxMutexLocker lock(gs_idleTagsMutex);
385 #endif
386
387 // Don't install the handler if it's already installed. This test *MUST*
388 // be done when gs_idleTagsMutex is locked!
389 if (!g_isIdle)
390 return;
391
392 // GD: this assert is raised when using the thread sample (which works)
393 // so the test is probably not so easy. Can widget callbacks be
394 // triggered from child threads and, if so, for which widgets?
395 // wxASSERT_MSG( wxThread::IsMain() || gs_WakeUpIdle, wxT("attempt to install idle handler from widget callback in child thread (should be exclusively from wxWakeUpIdle)") );
396
397 wxASSERT_MSG( wxTheApp->m_idleTag == 0, wxT("attempt to install idle handler twice") );
398
399 g_isIdle = FALSE;
400
401 if (g_pendingTag == 0)
402 g_pendingTag = gtk_idle_add_priority( 900, wxapp_pending_callback, (gpointer) NULL );
403
404 // This routine gets called by all event handlers
405 // indicating that the idle is over. It may also
406 // get called from other thread for sending events
407 // to the main thread (and processing these in
408 // idle time). Very low priority.
409 wxTheApp->m_idleTag = gtk_idle_add_priority( 1000, wxapp_idle_callback, (gpointer) NULL );
410 }
411
412 //-----------------------------------------------------------------------------
413 // Access to the root window global
414 //-----------------------------------------------------------------------------
415
416 GtkWidget* wxGetRootWindow()
417 {
418 if (gs_RootWindow == NULL)
419 {
420 gs_RootWindow = gtk_window_new( GTK_WINDOW_TOPLEVEL );
421 gtk_widget_realize( gs_RootWindow );
422 }
423 return gs_RootWindow;
424 }
425
426 //-----------------------------------------------------------------------------
427 // wxApp
428 //-----------------------------------------------------------------------------
429
430 IMPLEMENT_DYNAMIC_CLASS(wxApp,wxEvtHandler)
431
432 BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
433 EVT_IDLE(wxAppBase::OnIdle)
434 END_EVENT_TABLE()
435
436 wxApp::wxApp()
437 {
438 #ifdef __WXDEBUG__
439 m_isInAssert = FALSE;
440 #endif // __WXDEBUG__
441
442 m_idleTag = 0;
443 g_isIdle = TRUE;
444 wxapp_install_idle_handler();
445
446 #if wxUSE_THREADS
447 g_main_set_poll_func( wxapp_poll_func );
448 #endif
449
450 m_colorCube = (unsigned char*) NULL;
451
452 // this is NULL for a "regular" wxApp, but is set (and freed) by a wxGLApp
453 m_glVisualInfo = (void *) NULL;
454 m_glFBCInfo = (void *) NULL;
455 }
456
457 wxApp::~wxApp()
458 {
459 if (m_idleTag) gtk_idle_remove( m_idleTag );
460
461 if (m_colorCube) free(m_colorCube);
462 }
463
464 bool wxApp::OnInitGui()
465 {
466 if ( !wxAppBase::OnInitGui() )
467 return FALSE;
468
469 GdkVisual *visual = gdk_visual_get_system();
470
471 // if this is a wxGLApp (derived from wxApp), and we've already
472 // chosen a specific visual, then derive the GdkVisual from that
473 if (m_glVisualInfo != NULL)
474 {
475 #ifdef __WXGTK20__
476 // seems gtk_widget_set_default_visual no longer exists?
477 GdkVisual* vis = gtk_widget_get_default_visual();
478 #else
479 GdkVisual* vis = gdkx_visual_get(
480 ((XVisualInfo *) m_glVisualInfo) ->visualid );
481 gtk_widget_set_default_visual( vis );
482 #endif
483
484 GdkColormap *colormap = gdk_colormap_new( vis, FALSE );
485 gtk_widget_set_default_colormap( colormap );
486
487 visual = vis;
488 }
489
490 // On some machines, the default visual is just 256 colours, so
491 // we make sure we get the best. This can sometimes be wasteful.
492
493 else
494 if ((gdk_visual_get_best() != gdk_visual_get_system()) && (m_useBestVisual))
495 {
496 #ifdef __WXGTK20__
497 /* seems gtk_widget_set_default_visual no longer exists? */
498 GdkVisual* vis = gtk_widget_get_default_visual();
499 #else
500 GdkVisual* vis = gdk_visual_get_best();
501 gtk_widget_set_default_visual( vis );
502 #endif
503
504 GdkColormap *colormap = gdk_colormap_new( vis, FALSE );
505 gtk_widget_set_default_colormap( colormap );
506
507 visual = vis;
508 }
509
510 // Nothing to do for 15, 16, 24, 32 bit displays
511 if (visual->depth > 8) return TRUE;
512
513 // initialize color cube for 8-bit color reduction dithering
514
515 GdkColormap *cmap = gtk_widget_get_default_colormap();
516
517 m_colorCube = (unsigned char*)malloc(32 * 32 * 32);
518
519 for (int r = 0; r < 32; r++)
520 {
521 for (int g = 0; g < 32; g++)
522 {
523 for (int b = 0; b < 32; b++)
524 {
525 int rr = (r << 3) | (r >> 2);
526 int gg = (g << 3) | (g >> 2);
527 int bb = (b << 3) | (b >> 2);
528
529 int index = -1;
530
531 GdkColor *colors = cmap->colors;
532 if (colors)
533 {
534 int max = 3 * 65536;
535
536 for (int i = 0; i < cmap->size; i++)
537 {
538 int rdiff = ((rr << 8) - colors[i].red);
539 int gdiff = ((gg << 8) - colors[i].green);
540 int bdiff = ((bb << 8) - colors[i].blue);
541 int sum = ABS (rdiff) + ABS (gdiff) + ABS (bdiff);
542 if (sum < max)
543 {
544 index = i; max = sum;
545 }
546 }
547 }
548 else
549 {
550 // assume 8-bit true or static colors. this really exists
551 GdkVisual* vis = gdk_colormap_get_visual( cmap );
552 index = (r >> (5 - vis->red_prec)) << vis->red_shift;
553 index |= (g >> (5 - vis->green_prec)) << vis->green_shift;
554 index |= (b >> (5 - vis->blue_prec)) << vis->blue_shift;
555 }
556 m_colorCube[ (r*1024) + (g*32) + b ] = index;
557 }
558 }
559 }
560
561 return TRUE;
562 }
563
564 GdkVisual *wxApp::GetGdkVisual()
565 {
566 GdkVisual *visual = NULL;
567
568 if (m_glVisualInfo)
569 visual = gdkx_visual_get( ((XVisualInfo *) m_glVisualInfo)->visualid );
570 else
571 visual = gdk_window_get_visual( wxGetRootWindow()->window );
572
573 wxASSERT( visual );
574
575 return visual;
576 }
577
578 bool wxApp::Initialize(int& argc, wxChar **argv)
579 {
580 bool init_result;
581
582 #if wxUSE_THREADS
583 // GTK 1.2 up to version 1.2.3 has broken threads
584 if ((gtk_major_version == 1) &&
585 (gtk_minor_version == 2) &&
586 (gtk_micro_version < 4))
587 {
588 printf( "wxWidgets warning: GUI threading disabled due to outdated GTK version\n" );
589 }
590 else
591 {
592 if (!g_thread_supported())
593 g_thread_init(NULL);
594 }
595 #endif // wxUSE_THREADS
596
597 gtk_set_locale();
598
599 // We should have the wxUSE_WCHAR_T test on the _outside_
600 #if wxUSE_WCHAR_T
601 #if defined(__WXGTK20__)
602 // gtk+ 2.0 supports Unicode through UTF-8 strings
603 wxConvCurrent = &wxConvUTF8;
604 #else // GTK 1.x
605 if (!wxOKlibc())
606 wxConvCurrent = &wxConvLocal;
607 #endif
608 #else // !wxUSE_WCHAR_T
609 if (!wxOKlibc())
610 wxConvCurrent = (wxMBConv*) NULL;
611 #endif // wxUSE_WCHAR_T/!wxUSE_WCHAR_T
612
613 #ifdef __WXGTK20__
614 // decide which conversion to use for the file names
615
616 // (1) this variable exists for the sole purpose of specifying the encoding
617 // of the filenames for GTK+ programs, so use it if it is set
618 wxString encName(wxGetenv(_T("G_FILENAME_ENCODING")));
619 if (encName == _T("@locale"))
620 encName.clear();
621 encName.MakeUpper();
622 #if wxUSE_INTL
623 if (encName.empty())
624 {
625 // (2) if a non default locale is set, assume that the user wants his
626 // filenames in this locale too
627 encName = wxLocale::GetSystemEncodingName().Upper();
628 // (3) finally use UTF-8 by default
629 if (encName.empty() || encName == _T("US-ASCII"))
630 encName = _T("UTF-8");
631 wxSetEnv(_T("G_FILENAME_ENCODING"), encName);
632 }
633 #else
634 if (encName.empty())
635 encName = _T("UTF-8");
636 #endif // wxUSE_INTL
637 static wxConvBrokenFileNames fileconv(encName);
638 wxConvFileName = &fileconv;
639 #endif // __WXGTK20__
640
641 #if wxUSE_UNICODE
642 // gtk_init() wants UTF-8, not wchar_t, so convert
643 int i;
644 char **argvGTK = new char *[argc + 1];
645 for ( i = 0; i < argc; i++ )
646 {
647 argvGTK[i] = wxStrdupA(wxConvUTF8.cWX2MB(argv[i]));
648 }
649
650 argvGTK[argc] = NULL;
651
652 int argcGTK = argc;
653
654 #ifdef __WXGPE__
655 init_result = true; // is there a _check() version of this?
656 gpe_application_init( &argcGTK, &argvGTK );
657 #else
658 init_result = gtk_init_check( &argcGTK, &argvGTK );
659 #endif
660
661 if ( argcGTK != argc )
662 {
663 // we have to drop the parameters which were consumed by GTK+
664 for ( i = 0; i < argcGTK; i++ )
665 {
666 while ( strcmp(wxConvUTF8.cWX2MB(argv[i]), argvGTK[i]) != 0 )
667 {
668 memmove(argv + i, argv + i + 1, argc - i);
669 }
670 }
671
672 argc = argcGTK;
673 }
674 //else: gtk_init() didn't modify our parameters
675
676 // free our copy
677 for ( i = 0; i < argcGTK; i++ )
678 {
679 free(argvGTK[i]);
680 }
681
682 delete [] argvGTK;
683 #else // !wxUSE_UNICODE
684 // gtk_init() shouldn't actually change argv itself (just its contents) so
685 // it's ok to pass pointer to it
686 init_result = gtk_init_check( &argc, &argv );
687 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
688
689 if (!init_result) {
690 wxLogError(wxT("Unable to initialize gtk, is DISPLAY set properly?"));
691 return false;
692 }
693
694 // we can not enter threads before gtk_init is done
695 gdk_threads_enter();
696
697 if ( !wxAppBase::Initialize(argc, argv) )
698 {
699 gdk_threads_leave();
700
701 return false;
702 }
703
704 wxSetDetectableAutoRepeat( TRUE );
705
706 #if wxUSE_INTL
707 wxFont::SetDefaultEncoding(wxLocale::GetSystemEncoding());
708 #endif
709
710 return true;
711 }
712
713 void wxApp::CleanUp()
714 {
715 gdk_threads_leave();
716
717 wxAppBase::CleanUp();
718 }
719
720 #ifdef __WXDEBUG__
721
722 void wxApp::OnAssert(const wxChar *file, int line, const wxChar* cond, const wxChar *msg)
723 {
724 m_isInAssert = TRUE;
725
726 wxAppBase::OnAssert(file, line, cond, msg);
727
728 m_isInAssert = FALSE;
729 }
730
731 #endif // __WXDEBUG__
732
733 void wxApp::RemoveIdleTag()
734 {
735 #if wxUSE_THREADS
736 wxMutexLocker lock(gs_idleTagsMutex);
737 #endif
738 if (!g_isIdle)
739 {
740 gtk_idle_remove( wxTheApp->m_idleTag );
741 wxTheApp->m_idleTag = 0;
742 g_isIdle = TRUE;
743 }
744 }