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
  23 #include "wx/process.h"
  24
  25 #include "wx/unix/execute.h"
  26
  27 #include "wx/gtk/private/timer.h"
  28
  29 #ifdef __WXDEBUG__
  30     #include "wx/gtk/assertdlg_gtk.h"
  31     #if wxUSE_STACKWALKER
  32         #include "wx/stackwalk.h"
  33     #endif // wxUSE_STACKWALKER
  34 #endif // __WXDEBUG__
  35
  36 #include <stdarg.h>
  37 #include <string.h>
  38 #include <sys/stat.h>
  39 #include <sys/types.h>
  40 #include <sys/wait.h>   // for WNOHANG
  41 #include <unistd.h>
  42
  43 #include "glib.h"
  44 #include "gdk/gdk.h"
  45 #include "gtk/gtk.h"
  46 #include "gdk/gdkx.h"
  47
  48 #ifdef HAVE_X11_XKBLIB_H
  49     /* under HP-UX and Solaris 2.6, at least, XKBlib.h defines structures with
  50      * field named "explicit" - which is, of course, an error for a C++
  51      * compiler. To be on the safe side, just redefine it everywhere. */
  52     #define explicit __wx_explicit
  53
  54     #include "X11/XKBlib.h"
  55
  56     #undef explicit
  57 #endif // HAVE_X11_XKBLIB_H
  58
  59
  60 #if wxUSE_DETECT_SM
  61     #include "X11/Xlib.h"
  62     #include "X11/SM/SMlib.h"
  63 #endif
  64
  65 //-----------------------------------------------------------------------------
  66 // data
  67 //-----------------------------------------------------------------------------
  68
  69 extern GtkWidget *wxGetRootWindow();
  70
  71 //----------------------------------------------------------------------------
  72 // misc.
  73 //----------------------------------------------------------------------------
  74 #ifndef __EMX__
  75 // on OS/2, we use the wxBell from wxBase library
  76
  77 void wxBell()
  78 {
  79     gdk_beep();
  80 }
  81 #endif
  82
  83 /* Don't synthesize KeyUp events holding down a key and producing
  84    KeyDown events with autorepeat. */
  85 #ifdef HAVE_X11_XKBLIB_H
  86 bool wxSetDetectableAutoRepeat( bool flag )
  87 {
  88     Bool result;
  89     XkbSetDetectableAutoRepeat( GDK_DISPLAY(), flag, &result );
  90     return result;       /* true if keyboard hardware supports this mode */
  91 }
  92 #else
  93 bool wxSetDetectableAutoRepeat( bool WXUNUSED(flag) )
  94 {
  95     return false;
  96 }
  97 #endif
  98
  99 // Escapes string so that it is valid Pango markup XML string:
 100 wxString wxEscapeStringForPangoMarkup(const wxString& str)
 101 {
 102     size_t len = str.length();
 103     wxString out;
 104     out.Alloc(len);
 105     for (size_t i = 0; i < len; i++)
 106     {
 107         wxChar c = str[i];
 108         switch (c)
 109         {
 110             case _T('&'):
 111                 out << _T("&amp;");
 112                 break;
 113             case _T('<'):
 114                 out << _T("&lt;");
 115                 break;
 116             case _T('>'):
 117                 out << _T("&gt;");
 118                 break;
 119             case _T('\''):
 120                 out << _T("&apos;");
 121                 break;
 122             case _T('"'):
 123                 out << _T("&quot;");
 124                 break;
 125             default:
 126                 out << c;
 127                 break;
 128         }
 129     }
 130     return out;
 131 }
 132
 133
 134 // ----------------------------------------------------------------------------
 135 // display characterstics
 136 // ----------------------------------------------------------------------------
 137
 138 void *wxGetDisplay()
 139 {
 140     return GDK_DISPLAY();
 141 }
 142
 143 void wxDisplaySize( int *width, int *height )
 144 {
 145     if (width) *width = gdk_screen_width();
 146     if (height) *height = gdk_screen_height();
 147 }
 148
 149 void wxDisplaySizeMM( int *width, int *height )
 150 {
 151     if (width) *width = gdk_screen_width_mm();
 152     if (height) *height = gdk_screen_height_mm();
 153 }
 154
 155 void wxClientDisplayRect(int *x, int *y, int *width, int *height)
 156 {
 157     // This is supposed to return desktop dimensions minus any window
 158     // manager panels, menus, taskbars, etc.  If there is a way to do that
 159     // for this platform please fix this function, otherwise it defaults
 160     // to the entire desktop.
 161     if (x) *x = 0;
 162     if (y) *y = 0;
 163     wxDisplaySize(width, height);
 164 }
 165
 166 void wxGetMousePosition( int* x, int* y )
 167 {
 168     gdk_window_get_pointer( (GdkWindow*) NULL, x, y, (GdkModifierType*) NULL );
 169 }
 170
 171 bool wxColourDisplay()
 172 {
 173     return true;
 174 }
 175
 176 int wxDisplayDepth()
 177 {
 178     return gdk_drawable_get_visual( wxGetRootWindow()->window )->depth;
 179 }
 180
 181 wxWindow* wxFindWindowAtPoint(const wxPoint& pt)
 182 {
 183     return wxGenericFindWindowAtPoint(pt);
 184 }
 185
 186 #if !wxUSE_UNICODE
 187
 188 wxCharBuffer wxConvertToGTK(const wxString& s, wxFontEncoding enc)
 189 {
 190     wxWCharBuffer wbuf;
 191     if ( enc == wxFONTENCODING_SYSTEM || enc == wxFONTENCODING_DEFAULT )
 192     {
 193         wbuf = wxConvUI->cMB2WC(s);
 194     }
 195     else // another encoding, use generic conversion class
 196     {
 197         wbuf = wxCSConv(enc).cMB2WC(s);
 198     }
 199
 200     if ( !wbuf && !s.empty() )
 201     {
 202         // conversion failed, but we still want to show something to the user
 203         // even if it's going to be wrong it is better than nothing
 204         //
 205         // we choose ISO8859-1 here arbitrarily, it's just the most common
 206         // encoding probably and, also importantly here, conversion from it
 207         // never fails as it's done internally by wxCSConv
 208         wbuf = wxCSConv(wxFONTENCODING_ISO8859_1).cMB2WC(s);
 209     }
 210
 211     return wxConvUTF8.cWC2MB(wbuf);
 212 }
 213
 214 wxCharBuffer wxConvertFromGTK(const wxString& s, wxFontEncoding enc)
 215 {
 216     // this conversion should never fail as GTK+ always uses UTF-8 internally
 217     // so there are no complications here
 218     const wxWCharBuffer wbuf(wxConvUTF8.cMB2WC(s));
 219     if ( enc == wxFONTENCODING_SYSTEM )
 220         return wxConvUI->cWC2MB(wbuf);
 221
 222     return wxCSConv(enc).cWC2MB(wbuf);
 223 }
 224
 225 #endif // !wxUSE_UNICODE
 226
 227 // Returns false if version is certainly greater or equal than major.minor.micro
 228 // Returns true if version is lower than major.minor.micro OR it cannot be
 229 // determined and one should not rely on the availability of pango version
 230 // major.minor.micro, nor the non-availability
 231 const gchar *wx_pango_version_check (int major, int minor, int micro)
 232 {
 233 #ifdef PANGO_VERSION_MAJOR
 234     if (!gtk_check_version (2,11,0))
 235     {
 236         // GTK+ 2.11 requires Pango >= 1.15.3 and pango_version_check
 237         // was added in Pango 1.15.2 thus we know for sure the pango lib we're
 238         // using has the pango_version_check function:
 239         return pango_version_check (major, minor, micro);
 240     }
 241
 242     return "can't check";
 243 #else // !PANGO_VERSION_MAJOR
 244     return "too old headers";
 245 #endif
 246 }
 247
 248
 249 // ----------------------------------------------------------------------------
 250 // subprocess routines
 251 // ----------------------------------------------------------------------------
 252
 253 extern "C" {
 254 static
 255 void GTK_EndProcessDetector(gpointer data, gint source,
 256                             GdkInputCondition WXUNUSED(condition) )
 257 {
 258    wxEndProcessData *proc_data = (wxEndProcessData *)data;
 259
 260    // has the process really terminated? unfortunately GDK (or GLib) seem to
 261    // generate G_IO_HUP notification even when it simply tries to read from a
 262    // closed fd and hasn't terminated at all
 263    int pid = (proc_data->pid > 0) ? proc_data->pid : -(proc_data->pid);
 264    int status = 0;
 265    int rc = waitpid(pid, &status, WNOHANG);
 266
 267    if ( rc == 0 )
 268    {
 269        // no, it didn't exit yet, continue waiting
 270        return;
 271    }
 272
 273    // set exit code to -1 if something bad happened
 274    proc_data->exitcode = rc != -1 && WIFEXITED(status) ? WEXITSTATUS(status)
 275                                                       : -1;
 276
 277    // child exited, end waiting
 278    close(source);
 279
 280    // don't call us again!
 281    gdk_input_remove(proc_data->tag);
 282
 283    wxHandleProcessTermination(proc_data);
 284 }
 285 }
 286
 287 int wxAddProcessCallback(wxEndProcessData *proc_data, int fd)
 288 {
 289     int tag = gdk_input_add(fd,
 290                             GDK_INPUT_READ,
 291                             GTK_EndProcessDetector,
 292                             (gpointer)proc_data);
 293
 294     return tag;
 295 }
 296
 297
 298
 299 // ----------------------------------------------------------------------------
 300 // wxPlatformInfo-related
 301 // ----------------------------------------------------------------------------
 302
 303 wxPortId wxGUIAppTraits::GetToolkitVersion(int *verMaj, int *verMin) const
 304 {
 305     if ( verMaj )
 306         *verMaj = gtk_major_version;
 307     if ( verMin )
 308         *verMin = gtk_minor_version;
 309
 310     return wxPORT_GTK;
 311 }
 312
 313 wxTimerImpl *wxGUIAppTraits::CreateTimerImpl(wxTimer *timer)
 314 {
 315     return new wxGTKTimerImpl(timer);
 316 }
 317
 318 #if wxUSE_DETECT_SM
 319 static wxString GetSM()
 320 {
 321     class Dpy
 322     {
 323     public:
 324         Dpy() { m_dpy = XOpenDisplay(NULL); }
 325         ~Dpy() { if ( m_dpy ) XCloseDisplay(m_dpy); }
 326
 327         operator Display *() const { return m_dpy; }
 328     private:
 329         Display *m_dpy;
 330     } dpy;
 331
 332     if ( !dpy )
 333         return wxEmptyString;
 334
 335     char *client_id;
 336     SmcConn smc_conn = SmcOpenConnection(NULL, NULL,
 337                                          999, 999,
 338                                          0 /* mask */, NULL /* callbacks */,
 339                                          NULL, &client_id,
 340                                          0, NULL);
 341
 342     if ( !smc_conn )
 343         return wxEmptyString;
 344
 345     char *vendor = SmcVendor(smc_conn);
 346     wxString ret = wxString::FromAscii( vendor );
 347     free(vendor);
 348
 349     SmcCloseConnection(smc_conn, 0, NULL);
 350     free(client_id);
 351
 352     return ret;
 353 }
 354 #endif // wxUSE_DETECT_SM
 355
 356
 357 //-----------------------------------------------------------------------------
 358 // wxGUIAppTraits
 359 //-----------------------------------------------------------------------------
 360
 361 #if wxUSE_INTL
 362 void wxGUIAppTraits::SetLocale()
 363 {
 364     gtk_set_locale();
 365 }
 366 #endif
 367
 368 #ifdef __WXDEBUG__
 369
 370 #if wxUSE_STACKWALKER
 371
 372 // private helper class
 373 class StackDump : public wxStackWalker
 374 {
 375 public:
 376     StackDump(GtkAssertDialog *dlg) { m_dlg=dlg; }
 377
 378 protected:
 379     virtual void OnStackFrame(const wxStackFrame& frame)
 380     {
 381         wxString fncname = frame.GetName();
 382         wxString fncargs = fncname;
 383
 384         size_t n = fncname.find(wxT('('));
 385         if (n != wxString::npos)
 386         {
 387             // remove arguments from function name
 388             fncname.erase(n);
 389
 390             // remove function name and brackets from arguments
 391             fncargs = fncargs.substr(n+1, fncargs.length()-n-2);
 392         }
 393         else
 394             fncargs = wxEmptyString;
 395
 396         // append this stack frame's info in the dialog
 397         if (!frame.GetFileName().empty() || !fncname.empty())
 398             gtk_assert_dialog_append_stack_frame(m_dlg,
 399                                                 fncname.mb_str(),
 400                                                 fncargs.mb_str(),
 401                                                 frame.GetFileName().mb_str(),
 402                                                 frame.GetLine());
 403     }
 404
 405 private:
 406     GtkAssertDialog *m_dlg;
 407 };
 408
 409 // the callback functions must be extern "C" to comply with GTK+ declarations
 410 extern "C"
 411 {
 412     void get_stackframe_callback(StackDump *dump)
 413     {
 414         // skip over frames up to including wxOnAssert()
 415         dump->ProcessFrames(3);
 416     }
 417 }
 418
 419 #endif      // wxUSE_STACKWALKER
 420
 421 bool wxGUIAppTraits::ShowAssertDialog(const wxString& msg)
 422 {
 423     // under GTK2 we prefer to use a dialog widget written using directly GTK+;
 424     // in fact we cannot use a dialog written using wxWidgets: it would need
 425     // the wxWidgets idle processing to work correctly!
 426     GtkWidget *dialog = gtk_assert_dialog_new();
 427     gtk_assert_dialog_set_message(GTK_ASSERT_DIALOG(dialog), msg.mb_str());
 428
 429 #if wxUSE_STACKWALKER
 430     // don't show more than maxLines or we could get a dialog too tall to be
 431     // shown on screen: 20 should be ok everywhere as even with 15 pixel high
 432     // characters it is still only 300 pixels...
 433     static const int maxLines = 20;
 434
 435     // save current stack frame...
 436     StackDump dump(GTK_ASSERT_DIALOG(dialog));
 437     dump.SaveStack(maxLines);
 438
 439     // ...but process it only if the user needs it
 440     gtk_assert_dialog_set_backtrace_callback(GTK_ASSERT_DIALOG(dialog),
 441                                              (GtkAssertDialogStackFrameCallback)get_stackframe_callback,
 442                                              &dump);
 443 #endif      // wxUSE_STACKWALKER
 444
 445     gint result = gtk_dialog_run(GTK_DIALOG (dialog));
 446     bool returnCode = false;
 447     switch (result)
 448     {
 449     case GTK_ASSERT_DIALOG_STOP:
 450         wxTrap();
 451         break;
 452     case GTK_ASSERT_DIALOG_CONTINUE:
 453         // nothing to do
 454         break;
 455     case GTK_ASSERT_DIALOG_CONTINUE_SUPPRESSING:
 456         // no more asserts
 457         returnCode = true;
 458         break;
 459
 460     default:
 461         wxFAIL_MSG( _T("unexpected return code from GtkAssertDialog") );
 462     }
 463
 464     gtk_widget_destroy(dialog);
 465     return returnCode;
 466 }
 467
 468 #endif  // __WXDEBUG__
 469
 470 wxString wxGUIAppTraits::GetDesktopEnvironment() const
 471 {
 472 #if wxUSE_DETECT_SM
 473     const wxString SM = GetSM();
 474
 475     if (SM == wxT("GnomeSM"))
 476         return wxT("GNOME");
 477
 478     if (SM == wxT("KDE"))
 479         return wxT("KDE");
 480 #endif // wxUSE_DETECT_SM
 481
 482     return wxEmptyString;
 483 }
 484
 485
 486