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 BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
 270     EVT_IDLE(wxAppBase::OnIdle)
 271 END_EVENT_TABLE()
 272
 273 wxApp::wxApp()
 274 {
 275 #ifdef __WXDEBUG__
 276     m_isInAssert = false;
 277 #endif // __WXDEBUG__
 278 #if wxUSE_THREADS
 279     m_idleMutex = NULL;
 280 #endif
 281     m_idleSourceId = 0;
 282 }
 283
 284 wxApp::~wxApp()
 285 {
 286 }
 287
 288 bool wxApp::OnInitGui()
 289 {
 290     if ( !wxAppBase::OnInitGui() )
 291         return false;
 292
 293     // if this is a wxGLApp (derived from wxApp), and we've already
 294     // chosen a specific visual, then derive the GdkVisual from that
 295     if ( GetXVisualInfo() )
 296     {
 297         GdkVisual* vis = gtk_widget_get_default_visual();
 298
 299         GdkColormap *colormap = gdk_colormap_new( vis, FALSE );
 300         gtk_widget_set_default_colormap( colormap );
 301     }
 302     else
 303     {
 304         // On some machines, the default visual is just 256 colours, so
 305         // we make sure we get the best. This can sometimes be wasteful.
 306         if (m_useBestVisual)
 307         {
 308             if (m_forceTrueColour)
 309             {
 310                 GdkVisual* visual = gdk_visual_get_best_with_both( 24, GDK_VISUAL_TRUE_COLOR );
 311                 if (!visual)
 312                 {
 313                     wxLogError(wxT("Unable to initialize TrueColor visual."));
 314                     return false;
 315                 }
 316                 GdkColormap *colormap = gdk_colormap_new( visual, FALSE );
 317                 gtk_widget_set_default_colormap( colormap );
 318             }
 319             else
 320             {
 321                 if (gdk_visual_get_best() != gdk_visual_get_system())
 322                 {
 323                     GdkVisual* visual = gdk_visual_get_best();
 324                     GdkColormap *colormap = gdk_colormap_new( visual, FALSE );
 325                     gtk_widget_set_default_colormap( colormap );
 326                 }
 327             }
 328         }
 329     }
 330
 331     return true;
 332 }
 333
 334 GdkVisual *wxApp::GetGdkVisual()
 335 {
 336     GdkVisual *visual = NULL;
 337
 338     XVisualInfo *xvi = (XVisualInfo *)GetXVisualInfo();
 339     if ( xvi )
 340         visual = gdkx_visual_get( xvi->visualid );
 341     else
 342         visual = gdk_drawable_get_visual( wxGetRootWindow()->window );
 343
 344     wxASSERT( visual );
 345
 346     return visual;
 347 }
 348
 349 // use unusual names for the parameters to avoid conflict with wxApp::arg[cv]
 350 bool wxApp::Initialize(int& argc_, wxChar **argv_)
 351 {
 352     if ( !wxAppBase::Initialize(argc_, argv_) )
 353         return false;
 354
 355 #if wxUSE_THREADS
 356     if (!g_thread_supported())
 357         g_thread_init(NULL);
 358
 359     wxgs_poll_func = g_main_context_get_poll_func(NULL);
 360     g_main_context_set_poll_func(NULL, wxapp_poll_func);
 361 #endif // wxUSE_THREADS
 362
 363     // We should have the wxUSE_WCHAR_T test on the _outside_
 364 #if wxUSE_WCHAR_T
 365     // gtk+ 2.0 supports Unicode through UTF-8 strings
 366     wxConvCurrent = &wxConvUTF8;
 367 #else // !wxUSE_WCHAR_T
 368     if (!wxOKlibc())
 369         wxConvCurrent = (wxMBConv*) NULL;
 370 #endif // wxUSE_WCHAR_T/!wxUSE_WCHAR_T
 371
 372     // decide which conversion to use for the file names
 373
 374     // (1) this variable exists for the sole purpose of specifying the encoding
 375     //     of the filenames for GTK+ programs, so use it if it is set
 376     wxString encName(wxGetenv(_T("G_FILENAME_ENCODING")));
 377     encName = encName.BeforeFirst(_T(','));
 378     if (encName.CmpNoCase(_T("@locale")) == 0)
 379         encName.clear();
 380     encName.MakeUpper();
 381 #if wxUSE_INTL
 382     if (encName.empty())
 383     {
 384         // (2) if a non default locale is set, assume that the user wants his
 385         //     filenames in this locale too
 386         encName = wxLocale::GetSystemEncodingName().Upper();
 387         // (3) finally use UTF-8 by default
 388         if (encName.empty() || encName == _T("US-ASCII"))
 389             encName = _T("UTF-8");
 390         wxSetEnv(_T("G_FILENAME_ENCODING"), encName);
 391     }
 392 #else
 393     if (encName.empty())
 394         encName = _T("UTF-8");
 395
 396     // if wxUSE_INTL==0 it probably indicates that only "C" locale is supported
 397     // by the program anyhow so prevent GTK+ from calling setlocale(LC_ALL, "")
 398     // from gtk_init_check() as it does by default
 399     gtk_disable_setlocale();
 400
 401 #endif // wxUSE_INTL
 402     static wxConvBrokenFileNames fileconv(encName);
 403     wxConvFileName = &fileconv;
 404
 405
 406     bool init_result;
 407
 408 #if wxUSE_UNICODE
 409     // gtk_init() wants UTF-8, not wchar_t, so convert
 410     int i;
 411     char **argvGTK = new char *[argc_ + 1];
 412     for ( i = 0; i < argc_; i++ )
 413     {
 414         argvGTK[i] = wxStrdupA(wxConvUTF8.cWX2MB(argv_[i]));
 415     }
 416
 417     argvGTK[argc_] = NULL;
 418
 419     int argcGTK = argc_;
 420
 421 #ifdef __WXGPE__
 422     init_result = true;  // is there a _check() version of this?
 423     gpe_application_init( &argcGTK, &argvGTK );
 424 #else
 425     init_result = gtk_init_check( &argcGTK, &argvGTK );
 426 #endif
 427     wxUpdateLocaleIsUtf8();
 428
 429     if ( argcGTK != argc_ )
 430     {
 431         // we have to drop the parameters which were consumed by GTK+
 432         for ( i = 0; i < argcGTK; i++ )
 433         {
 434             while ( strcmp(wxConvUTF8.cWX2MB(argv_[i]), argvGTK[i]) != 0 )
 435             {
 436                 memmove(argv_ + i, argv_ + i + 1, (argc_ - i)*sizeof(*argv_));
 437             }
 438         }
 439
 440         argc_ = argcGTK;
 441     }
 442     //else: gtk_init() didn't modify our parameters
 443
 444     // free our copy
 445     for ( i = 0; i < argcGTK; i++ )
 446     {
 447         free(argvGTK[i]);
 448     }
 449
 450     delete [] argvGTK;
 451 #else // !wxUSE_UNICODE
 452     // gtk_init() shouldn't actually change argv_ itself (just its contents) so
 453     // it's ok to pass pointer to it
 454     init_result = gtk_init_check( &argc_, &argv_ );
 455 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
 456
 457     // update internal arg[cv] as GTK+ may have removed processed options:
 458     this->argc = argc_;
 459     this->argv = argv_;
 460
 461     if ( m_traits )
 462     {
 463         // if there are still GTK+ standard options unparsed in the command
 464         // line, it means that they were not syntactically correct and GTK+
 465         // already printed a warning on the command line and we should now
 466         // exit:
 467         wxArrayString opt, desc;
 468         m_traits->GetStandardCmdLineOptions(opt, desc);
 469
 470         for ( int i = 0; i < argc_; i++ )
 471         {
 472             // leave just the names of the options with values
 473             const wxString str = wxString(argv_[i]).BeforeFirst('=');
 474
 475             for ( size_t j = 0; j < opt.size(); j++ )
 476             {
 477                 // remove the leading spaces from the option string as it does
 478                 // have them
 479                 if ( opt[j].Trim(false).BeforeFirst('=') == str )
 480                 {
 481                     // a GTK+ option can be left on the command line only if
 482                     // there was an error in (or before, in another standard
 483                     // options) it, so abort, just as we do if incorrect
 484                     // program option is given
 485                     wxLogError(_("Invalid GTK+ command line option, use \"%s --help\""),
 486                                argv_[0]);
 487                     return false;
 488                 }
 489             }
 490         }
 491     }
 492
 493     if ( !init_result )
 494     {
 495         wxLogError(_("Unable to initialize GTK+, is DISPLAY set properly?"));
 496         return false;
 497     }
 498
 499     // we can not enter threads before gtk_init is done
 500     gdk_threads_enter();
 501
 502     wxSetDetectableAutoRepeat( true );
 503
 504 #if wxUSE_INTL
 505     wxFont::SetDefaultEncoding(wxLocale::GetSystemEncoding());
 506 #endif
 507
 508 #if wxUSE_THREADS
 509     m_idleMutex = new wxMutex;
 510 #endif
 511     // make sure GtkWidget type is loaded, idle hooks need it
 512     g_type_class_ref(GTK_TYPE_WIDGET);
 513     WakeUpIdle();
 514
 515     return true;
 516 }
 517
 518 void wxApp::CleanUp()
 519 {
 520     if (m_idleSourceId != 0)
 521         g_source_remove(m_idleSourceId);
 522 #if wxUSE_THREADS
 523     delete m_idleMutex;
 524     m_idleMutex = NULL;
 525 #endif
 526     // release reference acquired by Initialize()
 527     g_type_class_unref(g_type_class_peek(GTK_TYPE_WIDGET));
 528
 529     gdk_threads_leave();
 530
 531     wxAppBase::CleanUp();
 532 }
 533
 534 void wxApp::WakeUpIdle()
 535 {
 536 #if wxUSE_THREADS
 537     wxMutexLocker lock(*m_idleMutex);
 538 #endif
 539     if (m_idleSourceId == 0)
 540         m_idleSourceId = g_idle_add_full(G_PRIORITY_LOW, wxapp_idle_callback, NULL, NULL);
 541 }
 542
 543 // Checking for pending events requires first removing our idle source,
 544 // otherwise it will cause the check to always return true.
 545 bool wxApp::EventsPending()
 546 {
 547 #if wxUSE_THREADS
 548     wxMutexLocker lock(*m_idleMutex);
 549 #endif
 550     if (m_idleSourceId != 0)
 551     {
 552         g_source_remove(m_idleSourceId);
 553         m_idleSourceId = 0;
 554         wx_add_idle_hooks();
 555     }
 556     return gtk_events_pending() != 0;
 557 }
 558
 559 #ifdef __WXDEBUG__
 560
 561 void wxApp::OnAssertFailure(const wxChar *file,
 562                             int line,
 563                             const wxChar* func,
 564                             const wxChar* cond,
 565                             const wxChar *msg)
 566 {
 567
 568     // block wx idle events while assert dialog is showing
 569     m_isInAssert = true;
 570
 571     wxAppBase::OnAssertFailure(file, line, func, cond, msg);
 572
 573     m_isInAssert = false;
 574 }
 575
 576 #endif // __WXDEBUG__