]>
git.saurik.com Git - wxWidgets.git/blob - src/gtk1/app.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/gtk1/app.cpp
4 // Author: Robert Roebling
6 // Copyright: (c) 1998 Robert Roebling, Julian Smart
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
11 // vms_jackets.h should for proper working be included before anything else
12 # include <vms_jackets.h>
13 #undef ConnectionNumber
16 // For compilers that support precompilation, includes "wx.h".
17 #include "wx/wxprec.h"
25 #include "wx/dialog.h"
26 #include "wx/settings.h"
27 #include "wx/msgdlg.h"
28 #include "wx/memory.h"
30 #include "wx/gdicmn.h"
35 #include "wx/filename.h"
36 #include "wx/module.h"
37 #include "wx/thread.h"
43 #ifdef __WXUNIVERSAL__
44 #include "wx/univ/theme.h"
45 #include "wx/univ/renderer.h"
49 #include "wx/thread.h"
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
72 // we implement poll() ourselves using select() which is supposed exist in
74 #include <sys/types.h>
77 #ifdef HAVE_SYS_SELECT_H
78 #include <sys/select.h>
80 #endif // HAVE_POLL/!HAVE_POLL
82 #include "wx/unix/private.h"
83 #include "wx/gtk1/win_gtk.h"
87 //-----------------------------------------------------------------------------
89 //-----------------------------------------------------------------------------
91 bool g_mainThreadLocked
= false ;
92 gint g_pendingTag
= 0 ;
94 static GtkWidget
* gs_RootWindow
= ( GtkWidget
*) NULL
;
96 //-----------------------------------------------------------------------------
98 //-----------------------------------------------------------------------------
100 extern bool g_isIdle
;
102 void wxapp_install_idle_handler ();
105 static wxMutex gs_idleTagsMutex
;
108 //-----------------------------------------------------------------------------
110 //-----------------------------------------------------------------------------
112 // not static because used by textctrl.cpp
115 bool wxIsInsideYield
= false ;
117 bool wxApp :: Yield ( bool onlyIfNeeded
)
119 if ( wxIsInsideYield
)
123 wxFAIL_MSG ( wxT ( "wxYield called recursively" ) );
130 if ( ! wxThread :: IsMain () )
132 // can't call gtk_main_iteration() from other threads like this
135 #endif // wxUSE_THREADS
137 wxIsInsideYield
= true ;
139 // We need to remove idle callbacks or the loop will
141 wxTheApp
-> RemoveIdleTag ();
144 // disable log flushing from here because a call to wxYield() shouldn't
145 // normally result in message boxes popping up &c
149 while ( gtk_events_pending ())
150 gtk_main_iteration ();
152 // It's necessary to call ProcessIdle() to update the frames sizes which
153 // might have been changed (it also will update other things set from
154 // OnUpdateUI() which is a nice (and desired) side effect). But we
155 // call ProcessIdle() only once since this is not meant for longish
156 // background jobs (controlled by wxIdleEvent::RequestMore() and the
157 // return value of Processidle().
161 // let the logs be flashed again
165 wxIsInsideYield
= false ;
170 //-----------------------------------------------------------------------------
172 //-----------------------------------------------------------------------------
174 // RR/KH: The wxMutexGui calls are not needed on GTK2 according to
175 // the GTK faq, http://www.gtk.org/faq/#AEN500
176 // The calls to gdk_threads_enter() and leave() are specifically noted
177 // as not being necessary. The MutexGui calls are still left in for GTK1.
178 // Eliminating the MutexGui calls fixes the long-standing "random" lockup
179 // when using wxPostEvent (which calls WakeUpIdle) from a thread.
181 void wxApp :: WakeUpIdle ()
184 if (! wxThread :: IsMain ())
186 #endif // wxUSE_THREADS_
188 wxapp_install_idle_handler ();
191 if (! wxThread :: IsMain ())
193 #endif // wxUSE_THREADS_
196 //-----------------------------------------------------------------------------
198 //-----------------------------------------------------------------------------
200 // the callback functions must be extern "C" to comply with GTK+ declarations
204 static gint
wxapp_pending_callback ( gpointer
WXUNUSED ( data
) )
206 if (! wxTheApp
) return TRUE
;
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.
213 // Sent idle event to all who request them.
214 wxTheApp
-> ProcessPendingEvents ();
218 wxMutexLocker
lock ( gs_idleTagsMutex
);
223 // Flush the logged messages if any.
225 wxLog :: FlushActive ();
228 // Release lock again
231 // Return FALSE to indicate that no more idle events are
232 // to be sent (single shot instead of continuous stream)
236 static gint
wxapp_idle_callback ( gpointer
WXUNUSED ( data
) )
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 () )
247 // But repaint the assertion message if necessary
248 if ( wxTopLevelWindows
. GetCount () > 0 )
250 wxWindow
* win
= ( wxWindow
*) wxTopLevelWindows
. GetLast ()-> GetData ();
251 if ( win
-> IsKindOf ( CLASSINFO ( wxGenericMessageDialog
)))
252 win
-> OnInternalIdle ();
256 #endif // __WXDEBUG__
258 // When getting called from GDK's time-out handler
259 // we are no longer within GDK's grab on the GUI
260 // thread so we must lock it here ourselves.
263 // Indicate that we are now in idle mode and event handlers
264 // will have to reinstall the idle handler again.
267 wxMutexLocker
lock ( gs_idleTagsMutex
);
270 wxTheApp
-> m_idleTag
= 0 ;
273 // Send idle event to all who request them as long as
274 // no events have popped up in the event queue.
275 while ( wxTheApp
-> ProcessIdle () && ( gtk_events_pending () == 0 ))
278 // Release lock again
281 // Return FALSE to indicate that no more idle events are
282 // to be sent (single shot instead of continuous stream).
290 #define wxPollFd pollfd
293 typedef GPollFD wxPollFd
;
295 int wxPoll ( wxPollFd
* ufds
, unsigned int nfds
, int timeout
)
297 // convert timeout from ms to struct timeval (s/us)
299 tv_timeout
. tv_sec
= timeout
/ 1000 ;
300 tv_timeout
. tv_usec
= ( timeout%1000
)* 1000 ;
302 // remember the highest fd used here
305 // and fill the sets for select()
310 wxFD_ZERO (& writefds
);
311 wxFD_ZERO (& exceptfds
);
314 for ( i
= 0 ; i
< nfds
; i
++ )
316 wxASSERT_MSG ( ufds
[ i
]. fd
< wxFD_SETSIZE
, _T ( "fd out of range" ) );
318 if ( ufds
[ i
]. events
& G_IO_IN
)
319 wxFD_SET ( ufds
[ i
]. fd
, & readfds
);
321 if ( ufds
[ i
]. events
& G_IO_PRI
)
322 wxFD_SET ( ufds
[ i
]. fd
, & exceptfds
);
324 if ( ufds
[ i
]. events
& G_IO_OUT
)
325 wxFD_SET ( ufds
[ i
]. fd
, & writefds
);
327 if ( ufds
[ i
]. fd
> fdMax
)
332 int res
= select ( fdMax
, & readfds
, & writefds
, & exceptfds
, & tv_timeout
);
334 // translate the results back
335 for ( i
= 0 ; i
< nfds
; i
++ )
339 if ( wxFD_ISSET ( ufds
[ i
]. fd
, & readfds
) )
340 ufds
[ i
]. revents
|= G_IO_IN
;
342 if ( wxFD_ISSET ( ufds
[ i
]. fd
, & exceptfds
) )
343 ufds
[ i
]. revents
|= G_IO_PRI
;
345 if ( wxFD_ISSET ( ufds
[ i
]. fd
, & writefds
) )
346 ufds
[ i
]. revents
|= G_IO_OUT
;
352 #endif // HAVE_POLL/!HAVE_POLL
354 static gint
wxapp_poll_func ( GPollFD
* ufds
, guint nfds
, gint timeout
)
359 g_mainThreadLocked
= true ;
361 // we rely on the fact that glib GPollFD struct is really just pollfd but
362 // I wonder how wise is this in the long term (VZ)
363 gint res
= wxPoll ( ( wxPollFd
*) ufds
, nfds
, timeout
);
366 g_mainThreadLocked
= false ;
373 #endif // wxUSE_THREADS
377 void wxapp_install_idle_handler ()
380 wxMutexLocker
lock ( gs_idleTagsMutex
);
383 // Don't install the handler if it's already installed. This test *MUST*
384 // be done when gs_idleTagsMutex is locked!
388 // GD: this assert is raised when using the thread sample (which works)
389 // so the test is probably not so easy. Can widget callbacks be
390 // triggered from child threads and, if so, for which widgets?
391 // wxASSERT_MSG( wxThread::IsMain() || gs_WakeUpIdle, wxT("attempt to install idle handler from widget callback in child thread (should be exclusively from wxWakeUpIdle)") );
393 wxASSERT_MSG ( wxTheApp
-> m_idleTag
== 0 , wxT ( "attempt to install idle handler twice" ) );
397 if ( g_pendingTag
== 0 )
398 g_pendingTag
= gtk_idle_add_priority ( 900 , wxapp_pending_callback
, ( gpointer
) NULL
);
400 // This routine gets called by all event handlers
401 // indicating that the idle is over. It may also
402 // get called from other thread for sending events
403 // to the main thread (and processing these in
404 // idle time). Very low priority.
405 wxTheApp
-> m_idleTag
= gtk_idle_add_priority ( 1000 , wxapp_idle_callback
, ( gpointer
) NULL
);
408 //-----------------------------------------------------------------------------
409 // Access to the root window global
410 //-----------------------------------------------------------------------------
412 GtkWidget
* wxGetRootWindow ()
414 if ( gs_RootWindow
== NULL
)
416 gs_RootWindow
= gtk_window_new ( GTK_WINDOW_TOPLEVEL
);
417 gtk_widget_realize ( gs_RootWindow
);
419 return gs_RootWindow
;
422 //-----------------------------------------------------------------------------
424 //-----------------------------------------------------------------------------
426 IMPLEMENT_DYNAMIC_CLASS ( wxApp
, wxEvtHandler
)
428 BEGIN_EVENT_TABLE ( wxApp
, wxEvtHandler
)
429 EVT_IDLE ( wxAppBase :: OnIdle
)
435 m_isInAssert
= false ;
436 #endif // __WXDEBUG__
440 wxapp_install_idle_handler ();
443 g_main_set_poll_func ( wxapp_poll_func
);
446 m_colorCube
= ( unsigned char *) NULL
;
448 // this is NULL for a "regular" wxApp, but is set (and freed) by a wxGLApp
449 m_glVisualInfo
= ( void *) NULL
;
450 m_glFBCInfo
= ( void *) NULL
;
455 if ( m_idleTag
) gtk_idle_remove ( m_idleTag
);
457 if ( m_colorCube
) free ( m_colorCube
);
460 bool wxApp :: OnInitGui ()
462 if ( ! wxAppBase :: OnInitGui () )
465 GdkVisual
* visual
= gdk_visual_get_system ();
467 // if this is a wxGLApp (derived from wxApp), and we've already
468 // chosen a specific visual, then derive the GdkVisual from that
469 if ( m_glVisualInfo
!= NULL
)
471 GdkVisual
* vis
= gdkx_visual_get (
472 (( XVisualInfo
*) m_glVisualInfo
) -> visualid
);
473 gtk_widget_set_default_visual ( vis
);
475 GdkColormap
* colormap
= gdk_colormap_new ( vis
, FALSE
);
476 gtk_widget_set_default_colormap ( colormap
);
481 // On some machines, the default visual is just 256 colours, so
482 // we make sure we get the best. This can sometimes be wasteful.
485 if (( gdk_visual_get_best () != gdk_visual_get_system ()) && ( m_useBestVisual
))
487 GdkVisual
* vis
= gdk_visual_get_best ();
488 gtk_widget_set_default_visual ( vis
);
490 GdkColormap
* colormap
= gdk_colormap_new ( vis
, FALSE
);
491 gtk_widget_set_default_colormap ( colormap
);
496 // Nothing to do for 15, 16, 24, 32 bit displays
497 if ( visual
-> depth
> 8 ) return TRUE
;
499 // initialize color cube for 8-bit color reduction dithering
501 GdkColormap
* cmap
= gtk_widget_get_default_colormap ();
503 m_colorCube
= ( unsigned char *) malloc ( 32 * 32 * 32 );
505 for ( int r
= 0 ; r
< 32 ; r
++)
507 for ( int g
= 0 ; g
< 32 ; g
++)
509 for ( int b
= 0 ; b
< 32 ; b
++)
511 int rr
= ( r
<< 3 ) | ( r
>> 2 );
512 int gg
= ( g
<< 3 ) | ( g
>> 2 );
513 int bb
= ( b
<< 3 ) | ( b
>> 2 );
517 GdkColor
* colors
= cmap
-> colors
;
522 for ( int i
= 0 ; i
< cmap
-> size
; i
++)
524 int rdiff
= (( rr
<< 8 ) - colors
[ i
]. red
);
525 int gdiff
= (( gg
<< 8 ) - colors
[ i
]. green
);
526 int bdiff
= (( bb
<< 8 ) - colors
[ i
]. blue
);
527 int sum
= ABS ( rdiff
) + ABS ( gdiff
) + ABS ( bdiff
);
530 index
= i
; max
= sum
;
536 // assume 8-bit true or static colors. this really exists
537 GdkVisual
* vis
= gdk_colormap_get_visual ( cmap
);
538 index
= ( r
>> ( 5 - vis
-> red_prec
)) << vis
-> red_shift
;
539 index
|= ( g
>> ( 5 - vis
-> green_prec
)) << vis
-> green_shift
;
540 index
|= ( b
>> ( 5 - vis
-> blue_prec
)) << vis
-> blue_shift
;
542 m_colorCube
[ ( r
* 1024 ) + ( g
* 32 ) + b
] = index
;
550 GdkVisual
* wxApp :: GetGdkVisual ()
552 GdkVisual
* visual
= NULL
;
555 visual
= gdkx_visual_get ( (( XVisualInfo
*) m_glVisualInfo
)-> visualid
);
557 visual
= gdk_window_get_visual ( wxGetRootWindow ()-> window
);
564 bool wxApp :: Initialize ( int & argc
, wxChar
** argv
)
569 // GTK 1.2 up to version 1.2.3 has broken threads
570 if (( gtk_major_version
== 1 ) &&
571 ( gtk_minor_version
== 2 ) &&
572 ( gtk_micro_version
< 4 ))
574 printf ( "wxWidgets warning: GUI threading disabled due to outdated GTK version \n " );
578 if (! g_thread_supported ())
581 #endif // wxUSE_THREADS
585 // We should have the wxUSE_WCHAR_T test on the _outside_
588 wxConvCurrent
= & wxConvLocal
;
589 #else // !wxUSE_WCHAR_T
591 wxConvCurrent
= ( wxMBConv
*) NULL
;
592 #endif // wxUSE_WCHAR_T/!wxUSE_WCHAR_T
595 // gtk_init() wants UTF-8, not wchar_t, so convert
597 char ** argvGTK
= new char *[ argc
+ 1 ];
598 for ( i
= 0 ; i
< argc
; i
++ )
600 argvGTK
[ i
] = wxStrdupA ( wxConvUTF8
. cWX2MB ( argv
[ i
]));
603 argvGTK
[ argc
] = NULL
;
608 init_result
= true ; // is there a _check() version of this?
609 gpe_application_init ( & argcGTK
, & argvGTK
);
611 init_result
= gtk_init_check ( & argcGTK
, & argvGTK
);
614 if ( argcGTK
!= argc
)
616 // we have to drop the parameters which were consumed by GTK+
617 for ( i
= 0 ; i
< argcGTK
; i
++ )
619 while ( strcmp ( wxConvUTF8
. cWX2MB ( argv
[ i
]), argvGTK
[ i
]) != 0 )
621 memmove ( argv
+ i
, argv
+ i
+ 1 , argc
- i
);
627 //else: gtk_init() didn't modify our parameters
630 for ( i
= 0 ; i
< argcGTK
; i
++ )
636 #else // !wxUSE_UNICODE
637 // gtk_init() shouldn't actually change argv itself (just its contents) so
638 // it's ok to pass pointer to it
639 init_result
= gtk_init_check ( & argc
, & argv
);
640 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
643 wxLogError ( wxT ( "Unable to initialize gtk, is DISPLAY set properly?" ));
647 // we can not enter threads before gtk_init is done
650 if ( ! wxAppBase :: Initialize ( argc
, argv
) )
657 wxSetDetectableAutoRepeat ( TRUE
);
660 wxFont :: SetDefaultEncoding ( wxLocale :: GetSystemEncoding ());
666 void wxApp :: CleanUp ()
670 wxAppBase :: CleanUp ();
675 void wxApp :: OnAssert ( const wxChar
* file
, int line
, const wxChar
* cond
, const wxChar
* msg
)
679 wxAppBase :: OnAssert ( file
, line
, cond
, msg
);
681 m_isInAssert
= false ;
684 #endif // __WXDEBUG__
686 void wxApp :: RemoveIdleTag ()
689 wxMutexLocker
lock ( gs_idleTagsMutex
);
693 gtk_idle_remove ( wxTheApp
-> m_idleTag
);
694 wxTheApp
-> m_idleTag
= 0 ;