src/gtk/utilsgtk.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/gtk/utilsgtk.cpp
   3 // Purpose:
   4 // Author:      Robert Roebling
   5 // Id:          $Id$
   6 // Copyright:   (c) 1998 Robert Roebling
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 // For compilers that support precompilation, includes "wx.h".
  11 #include "wx/wxprec.h"
  12
  13 #include "wx/utils.h"
  14
  15 #ifndef WX_PRECOMP
  16     #include "wx/string.h"
  17     #include "wx/intl.h"
  18     #include "wx/log.h"
  19 #endif
  20
  21 #include "wx/apptrait.h"
  22 #include "wx/process.h"
  23 #include "wx/sysopt.h"
  24 #include "wx/unix/execute.h"
  25
  26 #include "wx/gtk/private/timer.h"
  27 #include "wx/evtloop.h"
  28
  29 #include <gtk/gtk.h>
  30 #include <gdk/gdkx.h>
  31
  32 #if wxDEBUG_LEVEL
  33     #include "wx/gtk/assertdlg_gtk.h"
  34     #if wxUSE_STACKWALKER
  35         #include "wx/stackwalk.h"
  36     #endif // wxUSE_STACKWALKER
  37 #endif // wxDEBUG_LEVEL
  38
  39 #include <stdarg.h>
  40 #include <string.h>
  41 #include <sys/stat.h>
  42 #include <sys/types.h>
  43 #include <sys/wait.h>   // for WNOHANG
  44 #include <unistd.h>
  45
  46 #if wxUSE_DETECT_SM
  47     #include <X11/SM/SMlib.h>
  48
  49     #include "wx/unix/utilsx11.h"
  50 #endif
  51
  52 //-----------------------------------------------------------------------------
  53 // data
  54 //-----------------------------------------------------------------------------
  55
  56 extern GtkWidget *wxGetRootWindow();
  57
  58 //----------------------------------------------------------------------------
  59 // misc.
  60 //----------------------------------------------------------------------------
  61 #ifndef __EMX__
  62 // on OS/2, we use the wxBell from wxBase library
  63
  64 void wxBell()
  65 {
  66     gdk_beep();
  67 }
  68 #endif
  69
  70 // ----------------------------------------------------------------------------
  71 // display characterstics
  72 // ----------------------------------------------------------------------------
  73
  74 void *wxGetDisplay()
  75 {
  76     return GDK_DISPLAY();
  77 }
  78
  79 void wxDisplaySize( int *width, int *height )
  80 {
  81     if (width) *width = gdk_screen_width();
  82     if (height) *height = gdk_screen_height();
  83 }
  84
  85 void wxDisplaySizeMM( int *width, int *height )
  86 {
  87     if (width) *width = gdk_screen_width_mm();
  88     if (height) *height = gdk_screen_height_mm();
  89 }
  90
  91 void wxGetMousePosition( int* x, int* y )
  92 {
  93     gdk_window_get_pointer(gtk_widget_get_root_window(wxGetRootWindow()), x, y, NULL);
  94 }
  95
  96 bool wxColourDisplay()
  97 {
  98     return true;
  99 }
 100
 101 int wxDisplayDepth()
 102 {
 103     return gtk_widget_get_visual(wxGetRootWindow())->depth;
 104 }
 105
 106 wxWindow* wxFindWindowAtPoint(const wxPoint& pt)
 107 {
 108     return wxGenericFindWindowAtPoint(pt);
 109 }
 110
 111 #if !wxUSE_UNICODE
 112
 113 WXDLLIMPEXP_CORE wxCharBuffer
 114 wxConvertToGTK(const wxString& s, wxFontEncoding enc)
 115 {
 116     wxWCharBuffer wbuf;
 117     if ( enc == wxFONTENCODING_SYSTEM || enc == wxFONTENCODING_DEFAULT )
 118     {
 119         wbuf = wxConvUI->cMB2WC(s.c_str());
 120     }
 121     else // another encoding, use generic conversion class
 122     {
 123         wbuf = wxCSConv(enc).cMB2WC(s.c_str());
 124     }
 125
 126     if ( !wbuf && !s.empty() )
 127     {
 128         // conversion failed, but we still want to show something to the user
 129         // even if it's going to be wrong it is better than nothing
 130         //
 131         // we choose ISO8859-1 here arbitrarily, it's just the most common
 132         // encoding probably and, also importantly here, conversion from it
 133         // never fails as it's done internally by wxCSConv
 134         wbuf = wxCSConv(wxFONTENCODING_ISO8859_1).cMB2WC(s.c_str());
 135     }
 136
 137     return wxConvUTF8.cWC2MB(wbuf);
 138 }
 139
 140 WXDLLIMPEXP_CORE wxCharBuffer
 141 wxConvertFromGTK(const wxString& s, wxFontEncoding enc)
 142 {
 143     // this conversion should never fail as GTK+ always uses UTF-8 internally
 144     // so there are no complications here
 145     const wxWCharBuffer wbuf(wxConvUTF8.cMB2WC(s.c_str()));
 146     if ( enc == wxFONTENCODING_SYSTEM )
 147         return wxConvUI->cWC2MB(wbuf);
 148
 149     return wxCSConv(enc).cWC2MB(wbuf);
 150 }
 151
 152 #endif // !wxUSE_UNICODE
 153
 154 // Returns NULL if version is certainly greater or equal than major.minor.micro
 155 // Returns string describing the error if version is lower than
 156 // major.minor.micro OR it cannot be determined and one should not rely on the
 157 // availability of pango version major.minor.micro, nor the non-availability
 158 const gchar *wx_pango_version_check (int major, int minor, int micro)
 159 {
 160     // NOTE: you don't need to use this macro to check for Pango features
 161     //       added in pango-1.4 or earlier since GTK 2.4 (our minimum requirement
 162     //       for GTK lib) required pango 1.4...
 163
 164 #ifdef PANGO_VERSION_MAJOR
 165     if (!gtk_check_version (2,11,0))
 166     {
 167         // GTK+ 2.11 requires Pango >= 1.15.3 and pango_version_check
 168         // was added in Pango 1.15.2 thus we know for sure the pango lib we're
 169         // using has the pango_version_check function:
 170         return pango_version_check (major, minor, micro);
 171     }
 172
 173     return "can't check";
 174 #else // !PANGO_VERSION_MAJOR
 175     wxUnusedVar(major);
 176     wxUnusedVar(minor);
 177     wxUnusedVar(micro);
 178
 179     return "too old headers";
 180 #endif
 181 }
 182
 183
 184 // ----------------------------------------------------------------------------
 185 // subprocess routines
 186 // ----------------------------------------------------------------------------
 187
 188 extern "C" {
 189 static gboolean EndProcessDetector(GIOChannel* source, GIOCondition, void* data)
 190 {
 191     wxEndProcessData * const
 192         proc_data = static_cast<wxEndProcessData *>(data);
 193
 194     // child exited, end waiting
 195     close(g_io_channel_unix_get_fd(source));
 196
 197     wxHandleProcessTermination(proc_data);
 198
 199     // don't call us again!
 200     return false;
 201 }
 202 }
 203
 204 int wxGUIAppTraits::AddProcessCallback(wxEndProcessData *proc_data, int fd)
 205 {
 206     GIOChannel* channel = g_io_channel_unix_new(fd);
 207     GIOCondition cond = GIOCondition(G_IO_IN | G_IO_HUP | G_IO_ERR);
 208     unsigned id = g_io_add_watch(channel, cond, EndProcessDetector, proc_data);
 209     g_io_channel_unref(channel);
 210     return int(id);
 211 }
 212
 213
 214
 215 // ----------------------------------------------------------------------------
 216 // wxPlatformInfo-related
 217 // ----------------------------------------------------------------------------
 218
 219 wxPortId wxGUIAppTraits::GetToolkitVersion(int *verMaj, int *verMin) const
 220 {
 221     if ( verMaj )
 222         *verMaj = gtk_major_version;
 223     if ( verMin )
 224         *verMin = gtk_minor_version;
 225
 226     return wxPORT_GTK;
 227 }
 228
 229 #if wxUSE_TIMER
 230
 231 wxTimerImpl *wxGUIAppTraits::CreateTimerImpl(wxTimer *timer)
 232 {
 233     return new wxGTKTimerImpl(timer);
 234 }
 235
 236 #endif // wxUSE_TIMER
 237
 238 #if wxUSE_DETECT_SM
 239 static wxString GetSM()
 240 {
 241     wxX11Display dpy;
 242     if ( !dpy )
 243         return wxEmptyString;
 244
 245     char smerr[256];
 246     char *client_id;
 247     SmcConn smc_conn = SmcOpenConnection(NULL, NULL,
 248                                          999, 999,
 249                                          0 /* mask */, NULL /* callbacks */,
 250                                          NULL, &client_id,
 251                                          WXSIZEOF(smerr), smerr);
 252
 253     if ( !smc_conn )
 254     {
 255         wxLogDebug("Failed to connect to session manager: %s", smerr);
 256         return wxEmptyString;
 257     }
 258
 259     char *vendor = SmcVendor(smc_conn);
 260     wxString ret = wxString::FromAscii( vendor );
 261     free(vendor);
 262
 263     SmcCloseConnection(smc_conn, 0, NULL);
 264     free(client_id);
 265
 266     return ret;
 267 }
 268 #endif // wxUSE_DETECT_SM
 269
 270
 271 //-----------------------------------------------------------------------------
 272 // wxGUIAppTraits
 273 //-----------------------------------------------------------------------------
 274
 275 wxEventLoopBase *wxGUIAppTraits::CreateEventLoop()
 276 {
 277     return new wxEventLoop();
 278 }
 279
 280
 281 #if wxUSE_INTL
 282 void wxGUIAppTraits::SetLocale()
 283 {
 284     gtk_set_locale();
 285     wxUpdateLocaleIsUtf8();
 286 }
 287 #endif
 288
 289 #if wxDEBUG_LEVEL && wxUSE_STACKWALKER
 290
 291 // private helper class
 292 class StackDump : public wxStackWalker
 293 {
 294 public:
 295     StackDump(GtkAssertDialog *dlg) { m_dlg=dlg; }
 296
 297 protected:
 298     virtual void OnStackFrame(const wxStackFrame& frame)
 299     {
 300         wxString fncname = frame.GetName();
 301         wxString fncargs = fncname;
 302
 303         size_t n = fncname.find(wxT('('));
 304         if (n != wxString::npos)
 305         {
 306             // remove arguments from function name
 307             fncname.erase(n);
 308
 309             // remove function name and brackets from arguments
 310             fncargs = fncargs.substr(n+1, fncargs.length()-n-2);
 311         }
 312         else
 313             fncargs = wxEmptyString;
 314
 315         // append this stack frame's info in the dialog
 316         if (!frame.GetFileName().empty() || !fncname.empty())
 317             gtk_assert_dialog_append_stack_frame(m_dlg,
 318                                                 fncname.mb_str(),
 319                                                 fncargs.mb_str(),
 320                                                 frame.GetFileName().mb_str(),
 321                                                 frame.GetLine());
 322     }
 323
 324 private:
 325     GtkAssertDialog *m_dlg;
 326 };
 327
 328 static void get_stackframe_callback(void* p)
 329 {
 330     StackDump* dump = static_cast<StackDump*>(p);
 331     // skip over frames up to including wxOnAssert()
 332     dump->ProcessFrames(3);
 333 }
 334
 335 #endif // wxDEBUG_LEVEL && wxUSE_STACKWALKER
 336
 337 bool wxGUIAppTraits::ShowAssertDialog(const wxString& msg)
 338 {
 339 #if wxDEBUG_LEVEL
 340     // we can't show the dialog from another thread
 341     if ( wxIsMainThread() )
 342     {
 343         // under GTK2 we prefer to use a dialog widget written using directly
 344         // in GTK+ as use a dialog written using wxWidgets would need the
 345         // wxWidgets idle processing to work correctly which might not be the
 346         // case when assert happens
 347         GtkWidget *dialog = gtk_assert_dialog_new();
 348         gtk_assert_dialog_set_message(GTK_ASSERT_DIALOG(dialog), msg.mb_str());
 349
 350 #if wxUSE_STACKWALKER
 351         // save the current stack ow...
 352         StackDump dump(GTK_ASSERT_DIALOG(dialog));
 353         dump.SaveStack(100); // showing more than 100 frames is not very useful
 354
 355         // ...but process it only if the user needs it
 356         gtk_assert_dialog_set_backtrace_callback
 357         (
 358             GTK_ASSERT_DIALOG(dialog),
 359             get_stackframe_callback,
 360             &dump
 361         );
 362 #endif // wxUSE_STACKWALKER
 363
 364         gint result = gtk_dialog_run(GTK_DIALOG (dialog));
 365         bool returnCode = false;
 366         switch (result)
 367         {
 368             case GTK_ASSERT_DIALOG_STOP:
 369                 wxTrap();
 370                 break;
 371             case GTK_ASSERT_DIALOG_CONTINUE:
 372                 // nothing to do
 373                 break;
 374             case GTK_ASSERT_DIALOG_CONTINUE_SUPPRESSING:
 375                 // no more asserts
 376                 returnCode = true;
 377                 break;
 378
 379             default:
 380                 wxFAIL_MSG( wxT("unexpected return code from GtkAssertDialog") );
 381         }
 382
 383         gtk_widget_destroy(dialog);
 384         return returnCode;
 385     }
 386 #endif // wxDEBUG_LEVEL
 387
 388     return wxAppTraitsBase::ShowAssertDialog(msg);
 389 }
 390
 391 wxString wxGUIAppTraits::GetDesktopEnvironment() const
 392 {
 393     wxString de = wxSystemOptions::GetOption(wxT("gtk.desktop"));
 394 #if wxUSE_DETECT_SM
 395     if ( de.empty() )
 396     {
 397         static const wxString s_SM = GetSM();
 398
 399         if (s_SM == wxT("GnomeSM"))
 400             de = wxT("GNOME");
 401         else if (s_SM == wxT("KDE"))
 402             de = wxT("KDE");
 403     }
 404 #endif // wxUSE_DETECT_SM
 405
 406     return de;
 407 }
 408
 409 #ifdef __WXGTK26__
 410
 411 // see the hack below in wxCmdLineParser::GetUsageString().
 412 // TODO: replace this hack with a g_option_group_get_entries()
 413 //       call as soon as such function exists;
 414 //       see http://bugzilla.gnome.org/show_bug.cgi?id=431021 for the relative
 415 //       feature request
 416 struct _GOptionGroup
 417 {
 418   gchar           *name;
 419   gchar           *description;
 420   gchar           *help_description;
 421
 422   GDestroyNotify   destroy_notify;
 423   gpointer         user_data;
 424
 425   GTranslateFunc   translate_func;
 426   GDestroyNotify   translate_notify;
 427   gpointer     translate_data;
 428
 429   GOptionEntry    *entries;
 430   gint             n_entries;
 431
 432   GOptionParseFunc pre_parse_func;
 433   GOptionParseFunc post_parse_func;
 434   GOptionErrorFunc error_func;
 435 };
 436
 437 wxString wxGetNameFromGtkOptionEntry(const GOptionEntry *opt)
 438 {
 439     wxString ret;
 440
 441     if (opt->short_name)
 442         ret << wxT("-") << opt->short_name;
 443     if (opt->long_name)
 444     {
 445         if (!ret.empty())
 446             ret << wxT(", ");
 447         ret << wxT("--") << opt->long_name;
 448
 449         if (opt->arg_description)
 450             ret << wxT("=") << opt->arg_description;
 451     }
 452
 453     return wxT("  ") + ret;
 454 }
 455
 456 #endif // __WXGTK26__
 457
 458 wxString
 459 wxGUIAppTraits::GetStandardCmdLineOptions(wxArrayString& names,
 460                                           wxArrayString& desc) const
 461 {
 462     wxString usage;
 463
 464 #ifdef __WXGTK26__
 465     if (!gtk_check_version(2,6,0))
 466     {
 467         // since GTK>=2.6, we can use the glib_check_version() symbol...
 468
 469         // check whether GLib version is greater than 2.6 but also lower than 2.19
 470         // because, as we use the undocumented _GOptionGroup struct, we don't want
 471         // to run this code with future versions which might change it (2.19 is the
 472         // latest one at the time of this writing)
 473         if (!glib_check_version(2,6,0) && glib_check_version(2,20,0))
 474         {
 475             usage << _("The following standard GTK+ options are also supported:\n");
 476
 477             // passing true here means that the function can open the default
 478             // display while parsing (not really used here anyhow)
 479             GOptionGroup *gtkOpts = gtk_get_option_group(true);
 480
 481             // WARNING: here we access the internals of GOptionGroup:
 482             GOptionEntry *entries = ((_GOptionGroup*)gtkOpts)->entries;
 483             unsigned int n_entries = ((_GOptionGroup*)gtkOpts)->n_entries;
 484             wxArrayString namesOptions, descOptions;
 485
 486             for ( size_t n = 0; n < n_entries; n++ )
 487             {
 488                 if ( entries[n].flags & G_OPTION_FLAG_HIDDEN )
 489                     continue;       // skip
 490
 491                 names.push_back(wxGetNameFromGtkOptionEntry(&entries[n]));
 492
 493                 const gchar * const entryDesc = entries[n].description;
 494                 desc.push_back(wxString(entryDesc));
 495             }
 496
 497             g_option_group_free (gtkOpts);
 498         }
 499     }
 500 #else
 501     wxUnusedVar(names);
 502     wxUnusedVar(desc);
 503 #endif // __WXGTK26__
 504
 505     return usage;
 506 }
 507