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 #include "wx/apptrait.h"
  38
  39 #include <gdk/gdkx.h>
  40
  41 //-----------------------------------------------------------------------------
  42 // link GnomeVFS
  43 //-----------------------------------------------------------------------------
  44
  45 #if wxUSE_MIMETYPE && wxUSE_LIBGNOMEVFS
  46     #include "wx/link.h"
  47     wxFORCE_LINK_MODULE(gnome_vfs)
  48 #endif
  49
  50 //-----------------------------------------------------------------------------
  51 // global data
  52 //-----------------------------------------------------------------------------
  53
  54 bool   g_mainThreadLocked = false;
  55
  56 static GtkWidget *gs_RootWindow = (GtkWidget*) NULL;
  57
  58 //-----------------------------------------------------------------------------
  59 // wxYield
  60 //-----------------------------------------------------------------------------
  61
  62 // not static because used by textctrl.cpp
  63 //
  64 // MT-FIXME
  65 bool wxIsInsideYield = false;
  66
  67 bool wxApp::Yield(bool onlyIfNeeded)
  68 {
  69     if ( wxIsInsideYield )
  70     {
  71         if ( !onlyIfNeeded )
  72         {
  73             wxFAIL_MSG( wxT("wxYield called recursively" ) );
  74         }
  75
  76         return false;
  77     }
  78
  79 #if wxUSE_THREADS
  80     if ( !wxThread::IsMain() )
  81     {
  82         // can't call gtk_main_iteration() from other threads like this
  83         return true;
  84     }
  85 #endif // wxUSE_THREADS
  86
  87     wxIsInsideYield = true;
  88
  89 #if wxUSE_LOG
  90     // disable log flushing from here because a call to wxYield() shouldn't
  91     // normally result in message boxes popping up &c
  92     wxLog::Suspend();
  93 #endif
  94
  95     while (EventsPending())
  96         gtk_main_iteration();
  97
  98     // It's necessary to call ProcessIdle() to update the frames sizes which
  99     // might have been changed (it also will update other things set from
 100     // OnUpdateUI() which is a nice (and desired) side effect). But we
 101     // call ProcessIdle() only once since this is not meant for longish
 102     // background jobs (controlled by wxIdleEvent::RequestMore() and the
 103     // return value of Processidle().
 104     ProcessIdle();
 105
 106 #if wxUSE_LOG
 107     // let the logs be flashed again
 108     wxLog::Resume();
 109 #endif
 110
 111     wxIsInsideYield = false;
 112
 113     return true;
 114 }
 115
 116 //-----------------------------------------------------------------------------
 117 // local functions
 118 //-----------------------------------------------------------------------------
 119
 120 // One-shot signal emission hook, to install idle handler.
 121 extern "C" {
 122 static gboolean
 123 wx_emission_hook(GSignalInvocationHint*, guint, const GValue*, gpointer data)
 124 {
 125     wxApp* app = wxTheApp;
 126     if (app != NULL)
 127         app->WakeUpIdle();
 128     gulong* hook_id = (gulong*)data;
 129     // record that hook is not installed
 130     *hook_id = 0;
 131     // remove hook
 132     return false;
 133 }
 134 }
 135
 136 // Add signal emission hooks, to re-install idle handler when needed.
 137 static void wx_add_idle_hooks()
 138 {
 139     // "event" hook
 140     {
 141         static gulong hook_id = 0;
 142         if (hook_id == 0)
 143         {
 144             static guint sig_id = 0;
 145             if (sig_id == 0)
 146                 sig_id = g_signal_lookup("event", GTK_TYPE_WIDGET);
 147             hook_id = g_signal_add_emission_hook(
 148                 sig_id, 0, wx_emission_hook, &hook_id, NULL);
 149         }
 150     }
 151     // "size_allocate" hook
 152     // Needed to match the behavior of the old idle system,
 153     // but probably not necessary.
 154     {
 155         static gulong hook_id = 0;
 156         if (hook_id == 0)
 157         {
 158             static guint sig_id = 0;
 159             if (sig_id == 0)
 160                 sig_id = g_signal_lookup("size_allocate", GTK_TYPE_WIDGET);
 161             hook_id = g_signal_add_emission_hook(
 162                 sig_id, 0, wx_emission_hook, &hook_id, NULL);
 163         }
 164     }
 165 }
 166
 167 extern "C" {
 168 static gboolean wxapp_idle_callback(gpointer)
 169 {
 170     return wxTheApp->DoIdle();
 171 }
 172 }
 173
 174 bool wxApp::DoIdle()
 175 {
 176     guint id_save;
 177     {
 178         // Allow another idle source to be added while this one is busy.
 179         // Needed if an idle event handler runs a new event loop,
 180         // for example by showing a dialog.
 181 #if wxUSE_THREADS
 182         wxMutexLocker lock(*m_idleMutex);
 183 #endif
 184         id_save = m_idleSourceId;
 185         m_idleSourceId = 0;
 186         wx_add_idle_hooks();
 187 #ifdef __WXDEBUG__
 188         // don't generate the idle events while the assert modal dialog is shown,
 189         // this matches the behavior of wxMSW
 190         if (m_isInAssert)
 191             return false;
 192 #endif
 193     }
 194
 195     gdk_threads_enter();
 196     bool needMore;
 197     do {
 198         needMore = ProcessIdle();
 199     } while (needMore && gtk_events_pending() == 0);
 200     gdk_threads_leave();
 201
 202 #if wxUSE_THREADS
 203     wxMutexLocker lock(*m_idleMutex);
 204 #endif
 205     // if a new idle source was added during ProcessIdle
 206     if (m_idleSourceId != 0)
 207     {
 208         // remove it
 209         g_source_remove(m_idleSourceId);
 210         m_idleSourceId = 0;
 211     }
 212     // if more idle processing requested
 213     if (needMore)
 214     {
 215         // keep this source installed
 216         m_idleSourceId = id_save;
 217         return true;
 218     }
 219     // add hooks and remove this source
 220     wx_add_idle_hooks();
 221     return false;
 222 }
 223
 224 #if wxUSE_THREADS
 225
 226 static GPollFunc wxgs_poll_func;
 227
 228 extern "C" {
 229 static gint wxapp_poll_func( GPollFD *ufds, guint nfds, gint timeout )
 230 {
 231     gdk_threads_enter();
 232
 233     wxMutexGuiLeave();
 234     g_mainThreadLocked = true;
 235
 236     gint res = (*wxgs_poll_func)(ufds, nfds, timeout);
 237
 238     wxMutexGuiEnter();
 239     g_mainThreadLocked = false;
 240
 241     gdk_threads_leave();
 242
 243     return res;
 244 }
 245 }
 246
 247 #endif // wxUSE_THREADS
 248
 249 //-----------------------------------------------------------------------------
 250 // Access to the root window global
 251 //-----------------------------------------------------------------------------
 252
 253 GtkWidget* wxGetRootWindow()
 254 {
 255     if (gs_RootWindow == NULL)
 256     {
 257         gs_RootWindow = gtk_window_new( GTK_WINDOW_TOPLEVEL );
 258         gtk_widget_realize( gs_RootWindow );
 259     }
 260     return gs_RootWindow;
 261 }
 262
 263 //-----------------------------------------------------------------------------
 264 // wxApp
 265 //-----------------------------------------------------------------------------
 266
 267 IMPLEMENT_DYNAMIC_CLASS(wxApp,wxEvtHandler)
 268
 269 wxApp::wxApp()
 270 {
 271 #ifdef __WXDEBUG__
 272     m_isInAssert = false;
 273 #endif // __WXDEBUG__
 274 #if wxUSE_THREADS
 275     m_idleMutex = NULL;
 276 #endif
 277     m_idleSourceId = 0;
 278 }
 279
 280 wxApp::~wxApp()
 281 {
 282 }
 283
 284 bool wxApp::OnInitGui()
 285 {
 286     if ( !wxAppBase::OnInitGui() )
 287         return false;
 288
 289     // if this is a wxGLApp (derived from wxApp), and we've already
 290     // chosen a specific visual, then derive the GdkVisual from that
 291     if ( GetXVisualInfo() )
 292     {
 293         GdkVisual* vis = gtk_widget_get_default_visual();
 294
 295         GdkColormap *colormap = gdk_colormap_new( vis, FALSE );
 296         gtk_widget_set_default_colormap( colormap );
 297     }
 298     else
 299     {
 300         // On some machines, the default visual is just 256 colours, so
 301         // we make sure we get the best. This can sometimes be wasteful.
 302         if (m_useBestVisual)
 303         {
 304             if (m_forceTrueColour)
 305             {
 306                 GdkVisual* visual = gdk_visual_get_best_with_both( 24, GDK_VISUAL_TRUE_COLOR );
 307                 if (!visual)
 308                 {
 309                     wxLogError(wxT("Unable to initialize TrueColor visual."));
 310                     return false;
 311                 }
 312                 GdkColormap *colormap = gdk_colormap_new( visual, FALSE );
 313                 gtk_widget_set_default_colormap( colormap );
 314             }
 315             else
 316             {
 317                 if (gdk_visual_get_best() != gdk_visual_get_system())
 318                 {
 319                     GdkVisual* visual = gdk_visual_get_best();
 320                     GdkColormap *colormap = gdk_colormap_new( visual, FALSE );
 321                     gtk_widget_set_default_colormap( colormap );
 322                 }
 323             }
 324         }
 325     }
 326
 327     return true;
 328 }
 329
 330 GdkVisual *wxApp::GetGdkVisual()
 331 {
 332     GdkVisual *visual = NULL;
 333
 334     XVisualInfo *xvi = (XVisualInfo *)GetXVisualInfo();
 335     if ( xvi )
 336         visual = gdkx_visual_get( xvi->visualid );
 337     else
 338         visual = gdk_drawable_get_visual( wxGetRootWindow()->window );
 339
 340     wxASSERT( visual );
 341
 342     return visual;
 343 }
 344
 345 // use unusual names for the parameters to avoid conflict with wxApp::arg[cv]
 346 bool wxApp::Initialize(int& argc_, wxChar **argv_)
 347 {
 348     if ( !wxAppBase::Initialize(argc_, argv_) )
 349         return false;
 350
 351 #if wxUSE_THREADS
 352     if (!g_thread_supported())
 353         g_thread_init(NULL);
 354
 355     wxgs_poll_func = g_main_context_get_poll_func(NULL);
 356     g_main_context_set_poll_func(NULL, wxapp_poll_func);
 357 #endif // wxUSE_THREADS
 358
 359     // We should have the wxUSE_WCHAR_T test on the _outside_
 360 #if wxUSE_WCHAR_T
 361     // gtk+ 2.0 supports Unicode through UTF-8 strings
 362     wxConvCurrent = &wxConvUTF8;
 363 #else // !wxUSE_WCHAR_T
 364     if (!wxOKlibc())
 365         wxConvCurrent = (wxMBConv*) NULL;
 366 #endif // wxUSE_WCHAR_T/!wxUSE_WCHAR_T
 367
 368     // decide which conversion to use for the file names
 369
 370     // (1) this variable exists for the sole purpose of specifying the encoding
 371     //     of the filenames for GTK+ programs, so use it if it is set
 372     wxString encName(wxGetenv(_T("G_FILENAME_ENCODING")));
 373     encName = encName.BeforeFirst(_T(','));
 374     if (encName.CmpNoCase(_T("@locale")) == 0)
 375         encName.clear();
 376     encName.MakeUpper();
 377 #if wxUSE_INTL
 378     if (encName.empty())
 379     {
 380         // (2) if a non default locale is set, assume that the user wants his
 381         //     filenames in this locale too
 382         encName = wxLocale::GetSystemEncodingName().Upper();
 383         // (3) finally use UTF-8 by default
 384         if (encName.empty() || encName == _T("US-ASCII"))
 385             encName = _T("UTF-8");
 386         wxSetEnv(_T("G_FILENAME_ENCODING"), encName);
 387     }
 388 #else
 389     if (encName.empty())
 390         encName = _T("UTF-8");
 391
 392     // if wxUSE_INTL==0 it probably indicates that only "C" locale is supported
 393     // by the program anyhow so prevent GTK+ from calling setlocale(LC_ALL, "")
 394     // from gtk_init_check() as it does by default
 395     gtk_disable_setlocale();
 396
 397 #endif // wxUSE_INTL
 398     static wxConvBrokenFileNames fileconv(encName);
 399     wxConvFileName = &fileconv;
 400
 401
 402     bool init_result;
 403
 404 #if wxUSE_UNICODE
 405     // gtk_init() wants UTF-8, not wchar_t, so convert
 406     int i;
 407     char **argvGTK = new char *[argc_ + 1];
 408     for ( i = 0; i < argc_; i++ )
 409     {
 410         argvGTK[i] = wxStrdupA(wxConvUTF8.cWX2MB(argv_[i]));
 411     }
 412
 413     argvGTK[argc_] = NULL;
 414
 415     int argcGTK = argc_;
 416
 417 #ifdef __WXGPE__
 418     init_result = true;  // is there a _check() version of this?
 419     gpe_application_init( &argcGTK, &argvGTK );
 420 #else
 421     init_result = gtk_init_check( &argcGTK, &argvGTK );
 422 #endif
 423     wxUpdateLocaleIsUtf8();
 424
 425     if ( argcGTK != argc_ )
 426     {
 427         // we have to drop the parameters which were consumed by GTK+
 428         for ( i = 0; i < argcGTK; i++ )
 429         {
 430             while ( strcmp(wxConvUTF8.cWX2MB(argv_[i]), argvGTK[i]) != 0 )
 431             {
 432                 memmove(argv_ + i, argv_ + i + 1, (argc_ - i)*sizeof(*argv_));
 433             }
 434         }
 435
 436         argc_ = argcGTK;
 437     }
 438     //else: gtk_init() didn't modify our parameters
 439
 440     // free our copy
 441     for ( i = 0; i < argcGTK; i++ )
 442     {
 443         free(argvGTK[i]);
 444     }
 445
 446     delete [] argvGTK;
 447 #else // !wxUSE_UNICODE
 448     // gtk_init() shouldn't actually change argv_ itself (just its contents) so
 449     // it's ok to pass pointer to it
 450     init_result = gtk_init_check( &argc_, &argv_ );
 451 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
 452
 453     // update internal arg[cv] as GTK+ may have removed processed options:
 454     this->argc = argc_;
 455     this->argv = argv_;
 456
 457     if ( m_traits )
 458     {
 459         // if there are still GTK+ standard options unparsed in the command
 460         // line, it means that they were not syntactically correct and GTK+
 461         // already printed a warning on the command line and we should now
 462         // exit:
 463         wxArrayString opt, desc;
 464         m_traits->GetStandardCmdLineOptions(opt, desc);
 465
 466         for ( int i = 0; i < argc_; i++ )
 467         {
 468             // leave just the names of the options with values
 469             const wxString str = wxString(argv_[i]).BeforeFirst('=');
 470
 471             for ( size_t j = 0; j < opt.size(); j++ )
 472             {
 473                 // remove the leading spaces from the option string as it does
 474                 // have them
 475                 if ( opt[j].Trim(false).BeforeFirst('=') == str )
 476                 {
 477                     // a GTK+ option can be left on the command line only if
 478                     // there was an error in (or before, in another standard
 479                     // options) it, so abort, just as we do if incorrect
 480                     // program option is given
 481                     wxLogError(_("Invalid GTK+ command line option, use \"%s --help\""),
 482                                argv_[0]);
 483                     return false;
 484                 }
 485             }
 486         }
 487     }
 488
 489     if ( !init_result )
 490     {
 491         wxLogError(_("Unable to initialize GTK+, is DISPLAY set properly?"));
 492         return false;
 493     }
 494
 495     // we can not enter threads before gtk_init is done
 496     gdk_threads_enter();
 497
 498     wxSetDetectableAutoRepeat( true );
 499
 500 #if wxUSE_INTL
 501     wxFont::SetDefaultEncoding(wxLocale::GetSystemEncoding());
 502 #endif
 503
 504 #if wxUSE_THREADS
 505     m_idleMutex = new wxMutex;
 506 #endif
 507     // make sure GtkWidget type is loaded, idle hooks need it
 508     g_type_class_ref(GTK_TYPE_WIDGET);
 509     WakeUpIdle();
 510
 511     return true;
 512 }
 513
 514 void wxApp::CleanUp()
 515 {
 516     if (m_idleSourceId != 0)
 517         g_source_remove(m_idleSourceId);
 518 #if wxUSE_THREADS
 519     delete m_idleMutex;
 520     m_idleMutex = NULL;
 521 #endif
 522     // release reference acquired by Initialize()
 523     g_type_class_unref(g_type_class_peek(GTK_TYPE_WIDGET));
 524
 525     gdk_threads_leave();
 526
 527     wxAppBase::CleanUp();
 528 }
 529
 530 void wxApp::WakeUpIdle()
 531 {
 532 #if wxUSE_THREADS
 533     wxMutexLocker lock(*m_idleMutex);
 534 #endif
 535     if (m_idleSourceId == 0)
 536         m_idleSourceId = g_idle_add_full(G_PRIORITY_LOW, wxapp_idle_callback, NULL, NULL);
 537 }
 538
 539 // Checking for pending events requires first removing our idle source,
 540 // otherwise it will cause the check to always return true.
 541 bool wxApp::EventsPending()
 542 {
 543 #if wxUSE_THREADS
 544     wxMutexLocker lock(*m_idleMutex);
 545 #endif
 546     if (m_idleSourceId != 0)
 547     {
 548         g_source_remove(m_idleSourceId);
 549         m_idleSourceId = 0;
 550         wx_add_idle_hooks();
 551     }
 552     return gtk_events_pending() != 0;
 553 }
 554
 555 #ifdef __WXDEBUG__
 556
 557 void wxApp::OnAssertFailure(const wxChar *file,
 558                             int line,
 559                             const wxChar* func,
 560                             const wxChar* cond,
 561                             const wxChar *msg)
 562 {
 563
 564     // block wx idle events while assert dialog is showing
 565     m_isInAssert = true;
 566
 567     wxAppBase::OnAssertFailure(file, line, func, cond, msg);
 568
 569     m_isInAssert = false;
 570 }
 571
 572 #endif // __WXDEBUG__