src/x11/utils.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/x11/utils.cpp
   3 // Purpose:     Various utilities
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     17/09/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // for compilers that support precompilation, includes "wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #if defined(__BORLANDC__)
  16     #pragma hdrstop
  17 #endif
  18
  19 // ============================================================================
  20 // declarations
  21 // ============================================================================
  22
  23 // ----------------------------------------------------------------------------
  24 // headers
  25 // ----------------------------------------------------------------------------
  26
  27 #include "wx/utils.h"
  28
  29 #ifndef WX_PRECOMP
  30     #include "wx/app.h"
  31     #include "wx/window.h" // for wxTopLevelWindows
  32     #include "wx/cursor.h"
  33     #include "wx/msgdlg.h"
  34 #endif
  35
  36 #include "wx/apptrait.h"
  37
  38 #include <ctype.h>
  39 #include <stdarg.h>
  40 #include <dirent.h>
  41 #include <string.h>
  42 #include <sys/stat.h>
  43 #include <sys/types.h>
  44 #include <unistd.h>
  45 #include <sys/wait.h>
  46 #include <pwd.h>
  47 #include <errno.h>
  48 // #include <netdb.h>
  49 #include <signal.h>
  50
  51 #if (defined(__SUNCC__) || defined(__CLCC__))
  52     #include <sysent.h>
  53 #endif
  54
  55 #ifdef __VMS__
  56 #pragma message disable nosimpint
  57 #endif
  58
  59 #include "wx/unix/execute.h"
  60
  61 #include "wx/x11/private.h"
  62
  63 #include "X11/Xutil.h"
  64
  65 #ifdef __VMS__
  66 #pragma message enable nosimpint
  67 #endif
  68
  69 // ----------------------------------------------------------------------------
  70 // async event processing
  71 // ----------------------------------------------------------------------------
  72
  73 // Consume all events until no more left
  74 void wxFlushEvents()
  75 {
  76     Display *display = (Display*) wxGetDisplay();
  77
  78     XSync (display, FALSE);
  79
  80     // TODO for X11
  81     // ??
  82 }
  83
  84 bool wxCheckForInterrupt(wxWindow *wnd)
  85 {
  86     wxFAIL_MSG(wxT("wxCheckForInterrupt not yet implemented."));
  87     return false;
  88 }
  89
  90 // ----------------------------------------------------------------------------
  91 // wxExecute stuff
  92 // ----------------------------------------------------------------------------
  93
  94 WX_DECLARE_HASH_MAP( int, wxEndProcessData*, wxIntegerHash, wxIntegerEqual, wxProcMap );
  95
  96 static wxProcMap *gs_procmap;
  97
  98 int wxAddProcessCallback(wxEndProcessData *proc_data, int fd)
  99 {
 100     if (!gs_procmap) gs_procmap = new wxProcMap();
 101     (*gs_procmap)[fd] = proc_data;
 102     return 1;
 103 }
 104
 105 void wxCheckForFinishedChildren()
 106 {
 107     wxProcMap::iterator it;
 108     if (!gs_procmap) return;
 109     if (gs_procmap->size() == 0) {
 110       // Map empty, delete it.
 111       delete gs_procmap;
 112       gs_procmap = NULL;
 113     }
 114     for (it = gs_procmap->begin();it != gs_procmap->end(); ++it)
 115     {
 116         wxEndProcessData *proc_data = it->second;
 117         int pid = (proc_data->pid > 0) ? proc_data->pid : -(proc_data->pid);
 118         int status = 0;
 119         // has the process really terminated?
 120         int rc = waitpid(pid, &status, WNOHANG);
 121         if (rc == 0)
 122             continue;       // no, it didn't exit yet, continue waiting
 123
 124         // set exit code to -1 if something bad happened
 125         proc_data->exitcode = rc != -1 && WIFEXITED(status) ?
 126                    WEXITSTATUS(status) : -1;
 127
 128         // child exited, end waiting
 129         close(it->first);
 130
 131         // don't call us again!
 132         gs_procmap->erase(it->first);
 133
 134         wxHandleProcessTermination(proc_data);
 135
 136         // Iterator is invalid. Handle any further children in subsequent
 137         // calls.
 138         break;
 139     }
 140 }
 141
 142 // ----------------------------------------------------------------------------
 143 // misc
 144 // ----------------------------------------------------------------------------
 145
 146 // Emit a beeeeeep
 147 #ifndef __EMX__
 148 // on OS/2, we use the wxBell from wxBase library (src/os2/utils.cpp)
 149 void wxBell()
 150 {
 151     // Use current setting for the bell
 152     XBell ((Display*) wxGetDisplay(), 0);
 153 }
 154 #endif
 155
 156 wxPortId wxGUIAppTraits::GetToolkitVersion(int *verMaj, int *verMin) const
 157 {
 158     // get X protocol version
 159     Display *display = wxGlobalDisplay();
 160     if (display)
 161     {
 162         if ( verMaj )
 163             *verMaj = ProtocolVersion (display);
 164         if ( verMin )
 165             *verMin = ProtocolRevision (display);
 166     }
 167
 168     return wxPORT_X11;
 169 }
 170
 171
 172 // ----------------------------------------------------------------------------
 173 // display info
 174 // ----------------------------------------------------------------------------
 175
 176 void wxGetMousePosition( int* x, int* y )
 177 {
 178 #if wxUSE_NANOX
 179     // TODO
 180     *x = 0;
 181     *y = 0;
 182 #else
 183     XMotionEvent xev;
 184     Window root, child;
 185     XQueryPointer((Display*) wxGetDisplay(),
 186                   DefaultRootWindow((Display*) wxGetDisplay()),
 187                   &root, &child,
 188                   &(xev.x_root), &(xev.y_root),
 189                   &(xev.x),      &(xev.y),
 190                   &(xev.state));
 191     *x = xev.x_root;
 192     *y = xev.y_root;
 193 #endif
 194 };
 195
 196 // Return true if we have a colour display
 197 bool wxColourDisplay()
 198 {
 199     return wxDisplayDepth() > 1;
 200 }
 201
 202 // Returns depth of screen
 203 int wxDisplayDepth()
 204 {
 205     Display *dpy = (Display*) wxGetDisplay();
 206
 207     return DefaultDepth (dpy, DefaultScreen (dpy));
 208 }
 209
 210 // Get size of display
 211 void wxDisplaySize(int *width, int *height)
 212 {
 213     Display *dpy = (Display*) wxGetDisplay();
 214
 215     if ( width )
 216         *width = DisplayWidth (dpy, DefaultScreen (dpy));
 217     if ( height )
 218         *height = DisplayHeight (dpy, DefaultScreen (dpy));
 219 }
 220
 221 void wxDisplaySizeMM(int *width, int *height)
 222 {
 223     Display *dpy = (Display*) wxGetDisplay();
 224
 225     if ( width )
 226         *width = DisplayWidthMM(dpy, DefaultScreen (dpy));
 227     if ( height )
 228         *height = DisplayHeightMM(dpy, DefaultScreen (dpy));
 229 }
 230
 231 void wxClientDisplayRect(int *x, int *y, int *width, int *height)
 232 {
 233     // This is supposed to return desktop dimensions minus any window
 234     // manager panels, menus, taskbars, etc.  If there is a way to do that
 235     // for this platform please fix this function, otherwise it defaults
 236     // to the entire desktop.
 237     if (x) *x = 0;
 238     if (y) *y = 0;
 239     wxDisplaySize(width, height);
 240 }
 241
 242 wxWindow* wxFindWindowAtPoint(const wxPoint& pt)
 243 {
 244     return wxGenericFindWindowAtPoint(pt);
 245 }
 246
 247
 248 // Configurable display in wxX11 and wxMotif
 249 static Display *gs_currentDisplay = NULL;
 250 static wxString gs_displayName;
 251
 252 WXDisplay *wxGetDisplay()
 253 {
 254     return (WXDisplay *)gs_currentDisplay;
 255 }
 256
 257 // close the current display
 258 void wxCloseDisplay()
 259 {
 260     if ( gs_currentDisplay )
 261     {
 262         if ( XCloseDisplay(gs_currentDisplay) != 0 )
 263         {
 264             wxLogWarning(_("Failed to close the display \"%s\""),
 265                          gs_displayName.c_str());
 266         }
 267
 268         gs_currentDisplay = NULL;
 269         gs_displayName.clear();
 270     }
 271 }
 272
 273 bool wxSetDisplay(const wxString& displayName)
 274 {
 275     Display *
 276         dpy = XOpenDisplay(displayName.empty() ? NULL : displayName.mb_str());
 277
 278     if ( !dpy )
 279     {
 280         wxLogError(_("Failed to open display \"%s\"."), displayName.c_str());
 281         return false;
 282     }
 283
 284     wxCloseDisplay();
 285
 286     gs_currentDisplay = dpy;
 287     gs_displayName = displayName;
 288
 289     return true;
 290 }
 291
 292 wxString wxGetDisplayName()
 293 {
 294     return gs_displayName;
 295 }
 296
 297 #include "wx/module.h"
 298
 299 // the module responsible for closing the X11 display at the program end
 300 class wxX11DisplayModule : public wxModule
 301 {
 302 public:
 303     virtual bool OnInit() { return true; }
 304     virtual void OnExit() { wxCloseDisplay(); }
 305
 306 private:
 307     DECLARE_DYNAMIC_CLASS(wxX11DisplayModule)
 308 };
 309
 310 IMPLEMENT_DYNAMIC_CLASS(wxX11DisplayModule, wxModule)
 311
 312 // ----------------------------------------------------------------------------
 313 // Some colour manipulation routines
 314 // ----------------------------------------------------------------------------
 315
 316 void wxHSVToXColor(wxHSV *hsv,XColor *rgb)
 317 {
 318     int h = hsv->h;
 319     int s = hsv->s;
 320     int v = hsv->v;
 321     int r = 0, g = 0, b = 0;
 322     int i, f;
 323     int p, q, t;
 324     s = (s * wxMAX_RGB) / wxMAX_SV;
 325     v = (v * wxMAX_RGB) / wxMAX_SV;
 326     if (h == 360) h = 0;
 327     if (s == 0) { h = 0; r = g = b = v; }
 328     i = h / 60;
 329     f = h % 60;
 330     p = v * (wxMAX_RGB - s) / wxMAX_RGB;
 331     q = v * (wxMAX_RGB - s * f / 60) / wxMAX_RGB;
 332     t = v * (wxMAX_RGB - s * (60 - f) / 60) / wxMAX_RGB;
 333     switch (i)
 334     {
 335     case 0: r = v, g = t, b = p; break;
 336     case 1: r = q, g = v, b = p; break;
 337     case 2: r = p, g = v, b = t; break;
 338     case 3: r = p, g = q, b = v; break;
 339     case 4: r = t, g = p, b = v; break;
 340     case 5: r = v, g = p, b = q; break;
 341     }
 342     rgb->red = r << 8;
 343     rgb->green = g << 8;
 344     rgb->blue = b << 8;
 345 }
 346
 347 void wxXColorToHSV(wxHSV *hsv,XColor *rgb)
 348 {
 349     int r = rgb->red >> 8;
 350     int g = rgb->green >> 8;
 351     int b = rgb->blue >> 8;
 352     int maxv = wxMax3(r, g, b);
 353     int minv = wxMin3(r, g, b);
 354     int h = 0, s, v;
 355     v = maxv;
 356     if (maxv) s = (maxv - minv) * wxMAX_RGB / maxv;
 357     else s = 0;
 358     if (s == 0) h = 0;
 359     else
 360     {
 361         int rc, gc, bc, hex = 0;
 362         rc = (maxv - r) * wxMAX_RGB / (maxv - minv);
 363         gc = (maxv - g) * wxMAX_RGB / (maxv - minv);
 364         bc = (maxv - b) * wxMAX_RGB / (maxv - minv);
 365         if (r == maxv) { h = bc - gc, hex = 0; }
 366         else if (g == maxv) { h = rc - bc, hex = 2; }
 367         else if (b == maxv) { h = gc - rc, hex = 4; }
 368         h = hex * 60 + (h * 60 / wxMAX_RGB);
 369         if (h < 0) h += 360;
 370     }
 371     hsv->h = h;
 372     hsv->s = (s * wxMAX_SV) / wxMAX_RGB;
 373     hsv->v = (v * wxMAX_SV) / wxMAX_RGB;
 374 }
 375
 376 void wxAllocNearestColor(Display *d,Colormap cmp,XColor *xc)
 377 {
 378 #if !wxUSE_NANOX
 379     int llp;
 380
 381     int screen = DefaultScreen(d);
 382     int num_colors = DisplayCells(d,screen);
 383
 384     XColor *color_defs = new XColor[num_colors];
 385     for(llp = 0;llp < num_colors;llp++) color_defs[llp].pixel = llp;
 386     XQueryColors(d,cmp,color_defs,num_colors);
 387
 388     wxHSV hsv_defs, hsv;
 389     wxXColorToHSV(&hsv,xc);
 390
 391     int diff, min_diff = 0, pixel = 0;
 392
 393     for(llp = 0;llp < num_colors;llp++)
 394     {
 395         wxXColorToHSV(&hsv_defs,&color_defs[llp]);
 396         diff = wxSIGN(wxH_WEIGHT * (hsv.h - hsv_defs.h)) +
 397             wxSIGN(wxS_WEIGHT * (hsv.s - hsv_defs.s)) +
 398             wxSIGN(wxV_WEIGHT * (hsv.v - hsv_defs.v));
 399         if (llp == 0) min_diff = diff;
 400         if (min_diff > diff) { min_diff = diff; pixel = llp; }
 401         if (min_diff == 0) break;
 402     }
 403
 404     xc -> red = color_defs[pixel].red;
 405     xc -> green = color_defs[pixel].green;
 406     xc -> blue = color_defs[pixel].blue;
 407     xc -> flags = DoRed | DoGreen | DoBlue;
 408
 409 /*  FIXME, TODO
 410     if (!XAllocColor(d,cmp,xc))
 411         cout << "wxAllocNearestColor : Warning : Cannot find nearest color !\n";
 412 */
 413
 414     delete[] color_defs;
 415 #endif
 416 }
 417
 418 void wxAllocColor(Display *d,Colormap cmp,XColor *xc)
 419 {
 420     if (!XAllocColor(d,cmp,xc))
 421     {
 422         //          cout << "wxAllocColor : Warning : Can not allocate color, attempt find nearest !\n";
 423         wxAllocNearestColor(d,cmp,xc);
 424     }
 425 }
 426
 427 #ifdef __WXDEBUG__
 428 wxString wxGetXEventName(XEvent& event)
 429 {
 430 #if wxUSE_NANOX
 431     wxString str(wxT("(some event)"));
 432     return str;
 433 #else
 434     int type = event.xany.type;
 435     static char* event_name[] = {
 436         "", "unknown(-)",                                         // 0-1
 437         "KeyPress", "KeyRelease", "ButtonPress", "ButtonRelease", // 2-5
 438         "MotionNotify", "EnterNotify", "LeaveNotify", "FocusIn",  // 6-9
 439         "FocusOut", "KeymapNotify", "Expose", "GraphicsExpose",   // 10-13
 440         "NoExpose", "VisibilityNotify", "CreateNotify",           // 14-16
 441         "DestroyNotify", "UnmapNotify", "MapNotify", "MapRequest",// 17-20
 442         "ReparentNotify", "ConfigureNotify", "ConfigureRequest",  // 21-23
 443         "GravityNotify", "ResizeRequest", "CirculateNotify",      // 24-26
 444         "CirculateRequest", "PropertyNotify", "SelectionClear",   // 27-29
 445         "SelectionRequest", "SelectionNotify", "ColormapNotify",  // 30-32
 446         "ClientMessage", "MappingNotify",                         // 33-34
 447         "unknown(+)"};                                            // 35
 448         type = wxMin(35, type); type = wxMax(1, type);
 449         return wxString::FromAscii(event_name[type]);
 450 #endif
 451 }
 452 #endif
 453
 454 bool wxWindowIsVisible(Window win)
 455 {
 456     XWindowAttributes wa;
 457     XGetWindowAttributes(wxGlobalDisplay(), win, &wa);
 458
 459     return (wa.map_state == IsViewable);
 460 }