src/gtk/app.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/gtk/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 __VMS
  11 // vms_jackets.h should for proper working be included before anything else
  12 # include <vms_jackets.h>
  13 #undef ConnectionNumber
  14 #endif
  15
  16 // For compilers that support precompilation, includes "wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #include "wx/app.h"
  20
  21 #ifndef WX_PRECOMP
  22     #include "wx/intl.h"
  23     #include "wx/log.h"
  24     #include "wx/utils.h"
  25     #include "wx/memory.h"
  26     #include "wx/font.h"
  27 #endif
  28
  29 #include "wx/thread.h"
  30
  31 #ifdef __WXGPE__
  32     #include <gpe/init.h>
  33 #endif
  34
  35 #include "wx/gtk/win_gtk.h"
  36 #include "wx/gtk/private.h"
  37
  38 #include <gdk/gdkx.h>
  39
  40 //-----------------------------------------------------------------------------
  41 // link GnomeVFS
  42 //-----------------------------------------------------------------------------
  43
  44 #if wxUSE_MIMETYPE && wxUSE_LIBGNOMEVFS
  45     #include "wx/link.h"
  46     wxFORCE_LINK_MODULE(gnome_vfs)
  47 #endif
  48
  49 //-----------------------------------------------------------------------------
  50 // global data
  51 //-----------------------------------------------------------------------------
  52
  53 bool   g_mainThreadLocked = false;
  54
  55 static GtkWidget *gs_RootWindow = (GtkWidget*) NULL;
  56
  57 //-----------------------------------------------------------------------------
  58 // idle system
  59 //-----------------------------------------------------------------------------
  60
  61 void wxapp_install_idle_handler();
  62
  63 #if wxUSE_THREADS
  64 static wxMutex gs_idleTagsMutex;
  65 #endif
  66
  67 //-----------------------------------------------------------------------------
  68 // wxYield
  69 //-----------------------------------------------------------------------------
  70
  71 // not static because used by textctrl.cpp
  72 //
  73 // MT-FIXME
  74 bool wxIsInsideYield = false;
  75
  76 bool wxApp::Yield(bool onlyIfNeeded)
  77 {
  78     if ( wxIsInsideYield )
  79     {
  80         if ( !onlyIfNeeded )
  81         {
  82             wxFAIL_MSG( wxT("wxYield called recursively" ) );
  83         }
  84
  85         return false;
  86     }
  87
  88 #if wxUSE_THREADS
  89     if ( !wxThread::IsMain() )
  90     {
  91         // can't call gtk_main_iteration() from other threads like this
  92         return true;
  93     }
  94 #endif // wxUSE_THREADS
  95
  96     wxIsInsideYield = true;
  97
  98     // We need to remove idle callbacks or the loop will
  99     // never finish.
 100     SuspendIdleCallback();
 101
 102 #if wxUSE_LOG
 103     // disable log flushing from here because a call to wxYield() shouldn't
 104     // normally result in message boxes popping up &c
 105     wxLog::Suspend();
 106 #endif
 107
 108     while (gtk_events_pending())
 109         gtk_main_iteration();
 110
 111     // It's necessary to call ProcessIdle() to update the frames sizes which
 112     // might have been changed (it also will update other things set from
 113     // OnUpdateUI() which is a nice (and desired) side effect). But we
 114     // call ProcessIdle() only once since this is not meant for longish
 115     // background jobs (controlled by wxIdleEvent::RequestMore() and the
 116     // return value of Processidle().
 117     ProcessIdle();
 118
 119 #if wxUSE_LOG
 120     // let the logs be flashed again
 121     wxLog::Resume();
 122 #endif
 123
 124     wxIsInsideYield = false;
 125
 126     return true;
 127 }
 128
 129 //-----------------------------------------------------------------------------
 130 // wxWakeUpIdle
 131 //-----------------------------------------------------------------------------
 132
 133 // RR/KH: No wxMutexGui calls are needed here according to the GTK faq,
 134 // http://www.gtk.org/faq/#AEN500 - this caused problems for wxPostEvent.
 135
 136 void wxApp::WakeUpIdle()
 137 {
 138     wxapp_install_idle_handler();
 139 }
 140
 141 //-----------------------------------------------------------------------------
 142 // local functions
 143 //-----------------------------------------------------------------------------
 144
 145 // the callback functions must be extern "C" to comply with GTK+ declarations
 146 extern "C"
 147 {
 148
 149 // One-shot emission hook for "event" signal, to install idle handler.
 150 // This will be called when the "event" signal is issued on any GtkWidget object.
 151 static gboolean
 152 event_emission_hook(GSignalInvocationHint*, guint, const GValue*, gpointer)
 153 {
 154     wxapp_install_idle_handler();
 155     // remove hook
 156     return false;
 157 }
 158
 159 // add emission hook for "event" signal, to re-install idle handler when needed
 160 static inline void wxAddEmissionHook()
 161 {
 162     GType widgetType = GTK_TYPE_WIDGET;
 163     // if GtkWidget type is loaded
 164     if (g_type_class_peek(widgetType) != NULL)
 165     {
 166         guint sig_id = g_signal_lookup("event", widgetType);
 167         g_signal_add_emission_hook(sig_id, 0, event_emission_hook, NULL, NULL);
 168     }
 169 }
 170
 171 static gint wxapp_idle_callback( gpointer WXUNUSED(data) )
 172 {
 173     // this does not look possible, but just in case...
 174     if (!wxTheApp)
 175         return false;
 176
 177     bool moreIdles = false;
 178
 179 #ifdef __WXDEBUG__
 180     // don't generate the idle events while the assert modal dialog is shown,
 181     // this matches the behavior of wxMSW
 182     if (!wxTheApp->IsInAssert())
 183 #endif // __WXDEBUG__
 184     {
 185         guint idleID_save;
 186         {
 187             // Allow another idle source to be added while this one is busy.
 188             // Needed if an idle event handler runs a new event loop,
 189             // for example by showing a dialog.
 190 #if wxUSE_THREADS
 191             wxMutexLocker lock(gs_idleTagsMutex);
 192 #endif
 193             idleID_save = wxTheApp->m_idleTag;
 194             wxTheApp->m_idleTag = 0;
 195             g_isIdle = true;
 196             wxAddEmissionHook();
 197         }
 198
 199         // When getting called from GDK's time-out handler
 200         // we are no longer within GDK's grab on the GUI
 201         // thread so we must lock it here ourselves.
 202         gdk_threads_enter();
 203
 204         // Send idle event to all who request them as long as
 205         // no events have popped up in the event queue.
 206         do {
 207             moreIdles = wxTheApp->ProcessIdle();
 208         } while (moreIdles && gtk_events_pending() == 0);
 209
 210         // Release lock again
 211         gdk_threads_leave();
 212
 213         {
 214             // If another idle source was added, remove it
 215 #if wxUSE_THREADS
 216             wxMutexLocker lock(gs_idleTagsMutex);
 217 #endif
 218             if (wxTheApp->m_idleTag != 0)
 219                 g_source_remove(wxTheApp->m_idleTag);
 220             wxTheApp->m_idleTag = idleID_save;
 221             g_isIdle = false;
 222         }
 223     }
 224
 225     if (!moreIdles)
 226     {
 227 #if wxUSE_THREADS
 228         wxMutexLocker lock(gs_idleTagsMutex);
 229 #endif
 230         // Indicate that we are now in idle mode and event handlers
 231         // will have to reinstall the idle handler again.
 232         g_isIdle = true;
 233         wxTheApp->m_idleTag = 0;
 234
 235         wxAddEmissionHook();
 236     }
 237
 238     // Return FALSE if no more idle events are to be sent
 239     return moreIdles;
 240 }
 241 } // extern "C"
 242
 243 #if wxUSE_THREADS
 244
 245 static GPollFunc wxgs_poll_func;
 246
 247 extern "C" {
 248 static gint wxapp_poll_func( GPollFD *ufds, guint nfds, gint timeout )
 249 {
 250     gdk_threads_enter();
 251
 252     wxMutexGuiLeave();
 253     g_mainThreadLocked = true;
 254
 255     gint res = (*wxgs_poll_func)(ufds, nfds, timeout);
 256
 257     wxMutexGuiEnter();
 258     g_mainThreadLocked = false;
 259
 260     gdk_threads_leave();
 261
 262     return res;
 263 }
 264 }
 265
 266 #endif // wxUSE_THREADS
 267
 268 void wxapp_install_idle_handler()
 269 {
 270     if (wxTheApp == NULL)
 271         return;
 272
 273 #if wxUSE_THREADS
 274     wxMutexLocker lock(gs_idleTagsMutex);
 275 #endif
 276
 277     // Don't install the handler if it's already installed. This test *MUST*
 278     // be done when gs_idleTagsMutex is locked!
 279     if (!g_isIdle)
 280         return;
 281
 282     // GD: this assert is raised when using the thread sample (which works)
 283     //     so the test is probably not so easy. Can widget callbacks be
 284     //     triggered from child threads and, if so, for which widgets?
 285     // wxASSERT_MSG( wxThread::IsMain() || gs_WakeUpIdle, wxT("attempt to install idle handler from widget callback in child thread (should be exclusively from wxWakeUpIdle)") );
 286
 287     wxASSERT_MSG( wxTheApp->m_idleTag == 0, wxT("attempt to install idle handler twice") );
 288
 289     g_isIdle = false;
 290
 291     // This routine gets called by all event handlers
 292     // indicating that the idle is over. It may also
 293     // get called from other thread for sending events
 294     // to the main thread (and processing these in
 295     // idle time). Very low priority.
 296     wxTheApp->m_idleTag = g_idle_add_full(G_PRIORITY_LOW, wxapp_idle_callback, NULL, NULL);
 297 }
 298
 299 //-----------------------------------------------------------------------------
 300 // Access to the root window global
 301 //-----------------------------------------------------------------------------
 302
 303 GtkWidget* wxGetRootWindow()
 304 {
 305     if (gs_RootWindow == NULL)
 306     {
 307         gs_RootWindow = gtk_window_new( GTK_WINDOW_TOPLEVEL );
 308         gtk_widget_realize( gs_RootWindow );
 309     }
 310     return gs_RootWindow;
 311 }
 312
 313 //-----------------------------------------------------------------------------
 314 // wxApp
 315 //-----------------------------------------------------------------------------
 316
 317 IMPLEMENT_DYNAMIC_CLASS(wxApp,wxEvtHandler)
 318
 319 BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
 320     EVT_IDLE(wxAppBase::OnIdle)
 321 END_EVENT_TABLE()
 322
 323 wxApp::wxApp()
 324 {
 325 #ifdef __WXDEBUG__
 326     m_isInAssert = false;
 327 #endif // __WXDEBUG__
 328
 329     m_idleTag = 0;
 330     g_isIdle = true;
 331     wxapp_install_idle_handler();
 332
 333     // this is NULL for a "regular" wxApp, but is set (and freed) by a wxGLApp
 334     m_glVisualInfo = (void *) NULL;
 335     m_glFBCInfo = (void *) NULL;
 336 }
 337
 338 wxApp::~wxApp()
 339 {
 340     if (m_idleTag)
 341         g_source_remove( m_idleTag );
 342
 343     if (m_glFBCInfo)
 344         XFree(m_glFBCInfo);
 345     if (m_glVisualInfo)
 346         XFree(m_glVisualInfo);
 347 }
 348
 349 bool wxApp::OnInitGui()
 350 {
 351     if ( !wxAppBase::OnInitGui() )
 352         return false;
 353
 354     // if this is a wxGLApp (derived from wxApp), and we've already
 355     // chosen a specific visual, then derive the GdkVisual from that
 356     if (m_glVisualInfo != NULL)
 357     {
 358         GdkVisual* vis = gtk_widget_get_default_visual();
 359
 360         GdkColormap *colormap = gdk_colormap_new( vis, FALSE );
 361         gtk_widget_set_default_colormap( colormap );
 362     }
 363     else
 364     {
 365         // On some machines, the default visual is just 256 colours, so
 366         // we make sure we get the best. This can sometimes be wasteful.
 367         if (m_useBestVisual)
 368         {
 369             if (m_forceTrueColour)
 370             {
 371                 GdkVisual* visual = gdk_visual_get_best_with_both( 24, GDK_VISUAL_TRUE_COLOR );
 372                 if (!visual)
 373                 {
 374                     wxLogError(wxT("Unable to initialize TrueColor visual."));
 375                     return false;
 376                 }
 377                 GdkColormap *colormap = gdk_colormap_new( visual, FALSE );
 378                 gtk_widget_set_default_colormap( colormap );
 379             }
 380             else
 381             {
 382                 if (gdk_visual_get_best() != gdk_visual_get_system())
 383                 {
 384                     GdkVisual* visual = gdk_visual_get_best();
 385                     GdkColormap *colormap = gdk_colormap_new( visual, FALSE );
 386                     gtk_widget_set_default_colormap( colormap );
 387                 }
 388             }
 389         }
 390     }
 391
 392     return true;
 393 }
 394
 395 GdkVisual *wxApp::GetGdkVisual()
 396 {
 397     GdkVisual *visual = NULL;
 398
 399     if (m_glVisualInfo)
 400         visual = gdkx_visual_get( ((XVisualInfo *) m_glVisualInfo)->visualid );
 401     else
 402         visual = gdk_drawable_get_visual( wxGetRootWindow()->window );
 403
 404     wxASSERT( visual );
 405
 406     return visual;
 407 }
 408
 409 bool wxApp::Initialize(int& argc, wxChar **argv)
 410 {
 411     if ( !wxAppBase::Initialize(argc, argv) )
 412         return false;
 413
 414 #if wxUSE_THREADS
 415     if (!g_thread_supported())
 416         g_thread_init(NULL);
 417
 418     wxgs_poll_func = g_main_context_get_poll_func(NULL);
 419     g_main_context_set_poll_func(NULL, wxapp_poll_func);
 420 #endif // wxUSE_THREADS
 421
 422     // We should have the wxUSE_WCHAR_T test on the _outside_
 423 #if wxUSE_WCHAR_T
 424     // gtk+ 2.0 supports Unicode through UTF-8 strings
 425     wxConvCurrent = &wxConvUTF8;
 426 #else // !wxUSE_WCHAR_T
 427     if (!wxOKlibc())
 428         wxConvCurrent = (wxMBConv*) NULL;
 429 #endif // wxUSE_WCHAR_T/!wxUSE_WCHAR_T
 430
 431     // decide which conversion to use for the file names
 432
 433     // (1) this variable exists for the sole purpose of specifying the encoding
 434     //     of the filenames for GTK+ programs, so use it if it is set
 435     wxString encName(wxGetenv(_T("G_FILENAME_ENCODING")));
 436     encName = encName.BeforeFirst(_T(','));
 437     if (encName.CmpNoCase(_T("@locale")) == 0)
 438         encName.clear();
 439     encName.MakeUpper();
 440 #if wxUSE_INTL
 441     if (encName.empty())
 442     {
 443         // (2) if a non default locale is set, assume that the user wants his
 444         //     filenames in this locale too
 445         encName = wxLocale::GetSystemEncodingName().Upper();
 446         // (3) finally use UTF-8 by default
 447         if (encName.empty() || encName == _T("US-ASCII"))
 448             encName = _T("UTF-8");
 449         wxSetEnv(_T("G_FILENAME_ENCODING"), encName);
 450     }
 451 #else
 452     if (encName.empty())
 453         encName = _T("UTF-8");
 454
 455     // if wxUSE_INTL==0 it probably indicates that only "C" locale is supported
 456     // by the program anyhow so prevent GTK+ from calling setlocale(LC_ALL, "")
 457     // from gtk_init_check() as it does by default
 458     gtk_disable_setlocale();
 459
 460 #endif // wxUSE_INTL
 461     static wxConvBrokenFileNames fileconv(encName);
 462     wxConvFileName = &fileconv;
 463
 464
 465     bool init_result;
 466
 467 #if wxUSE_UNICODE
 468     // gtk_init() wants UTF-8, not wchar_t, so convert
 469     int i;
 470     char **argvGTK = new char *[argc + 1];
 471     for ( i = 0; i < argc; i++ )
 472     {
 473         argvGTK[i] = wxStrdupA(wxConvUTF8.cWX2MB(argv[i]));
 474     }
 475
 476     argvGTK[argc] = NULL;
 477
 478     int argcGTK = argc;
 479
 480 #ifdef __WXGPE__
 481     init_result = true;  // is there a _check() version of this?
 482     gpe_application_init( &argcGTK, &argvGTK );
 483 #else
 484     init_result = gtk_init_check( &argcGTK, &argvGTK );
 485 #endif
 486
 487     if ( argcGTK != argc )
 488     {
 489         // we have to drop the parameters which were consumed by GTK+
 490         for ( i = 0; i < argcGTK; i++ )
 491         {
 492             while ( strcmp(wxConvUTF8.cWX2MB(argv[i]), argvGTK[i]) != 0 )
 493             {
 494                 memmove(argv + i, argv + i + 1, (argc - i)*sizeof(*argv));
 495             }
 496         }
 497
 498         argc = argcGTK;
 499     }
 500     //else: gtk_init() didn't modify our parameters
 501
 502     // free our copy
 503     for ( i = 0; i < argcGTK; i++ )
 504     {
 505         free(argvGTK[i]);
 506     }
 507
 508     delete [] argvGTK;
 509 #else // !wxUSE_UNICODE
 510     // gtk_init() shouldn't actually change argv itself (just its contents) so
 511     // it's ok to pass pointer to it
 512     init_result = gtk_init_check( &argc, &argv );
 513 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
 514
 515     if (!init_result) {
 516         wxLogError(wxT("Unable to initialize gtk, is DISPLAY set properly?"));
 517         return false;
 518     }
 519
 520     // we can not enter threads before gtk_init is done
 521     gdk_threads_enter();
 522
 523     wxSetDetectableAutoRepeat( true );
 524
 525 #if wxUSE_INTL
 526     wxFont::SetDefaultEncoding(wxLocale::GetSystemEncoding());
 527 #endif
 528
 529     return true;
 530 }
 531
 532 void wxApp::CleanUp()
 533 {
 534     gdk_threads_leave();
 535
 536     wxAppBase::CleanUp();
 537 }
 538
 539 #ifdef __WXDEBUG__
 540
 541 void wxApp::OnAssertFailure(const wxChar *file,
 542                             int line,
 543                             const wxChar* func,
 544                             const wxChar* cond,
 545                             const wxChar *msg)
 546 {
 547
 548     // block wx idle events while assert dialog is showing
 549     m_isInAssert = true;
 550
 551     wxAppBase::OnAssertFailure(file, line, func, cond, msg);
 552
 553     m_isInAssert = false;
 554 }
 555
 556 #endif // __WXDEBUG__
 557
 558 void wxApp::SuspendIdleCallback()
 559 {
 560 #if wxUSE_THREADS
 561     wxMutexLocker lock(gs_idleTagsMutex);
 562 #endif
 563     if (m_idleTag != 0)
 564     {
 565         g_source_remove(m_idleTag);
 566         m_idleTag = 0;
 567         g_isIdle = true;
 568         wxAddEmissionHook();
 569     }
 570 }