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