src/x11/utils.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        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 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #include "wx/setup.h"
  21 #include "wx/utils.h"
  22 #include "wx/app.h"
  23 #include "wx/msgdlg.h"
  24 #include "wx/cursor.h"
  25 #include "wx/window.h" // for wxTopLevelWindows
  26
  27 #include <ctype.h>
  28 #include <stdarg.h>
  29 #include <dirent.h>
  30 #include <string.h>
  31 #include <sys/stat.h>
  32 #include <sys/types.h>
  33 #include <unistd.h>
  34 #include <sys/wait.h>
  35 #include <pwd.h>
  36 #include <errno.h>
  37 #include <netdb.h>
  38 #include <signal.h>
  39
  40 #if (defined(__SUNCC__) || defined(__CLCC__))
  41     #include <sysent.h>
  42 #endif
  43
  44 #ifdef __VMS__
  45 #pragma message disable nosimpint
  46 #endif
  47
  48 #include "wx/unix/execute.h"
  49
  50 #ifdef __WXMOTIF__
  51 #include <Xm/Xm.h>
  52 #include "wx/motif/private.h"
  53 #endif
  54
  55 #ifdef __WXX11__
  56 #include "wx/x11/private.h"
  57 #endif
  58
  59 #if wxUSE_RESOURCES
  60 #include "X11/Xresource.h"
  61 #endif
  62
  63 #include "X11/Xutil.h"
  64
  65 #ifdef __VMS__
  66 #pragma message enable nosimpint
  67 #endif
  68
  69 // ----------------------------------------------------------------------------
  70 // private functions
  71 // ----------------------------------------------------------------------------
  72
  73 // Yuck this is really BOTH site and platform dependent
  74 // so we should use some other strategy!
  75 #ifdef sun
  76     #define DEFAULT_XRESOURCE_DIR "/usr/openwin/lib/app-defaults"
  77 #else
  78     #define DEFAULT_XRESOURCE_DIR "/usr/lib/X11/app-defaults"
  79 #endif
  80
  81 static char *GetIniFile (char *dest, const char *filename);
  82
  83 // ============================================================================
  84 // implementation
  85 // ============================================================================
  86
  87 // ----------------------------------------------------------------------------
  88 // async event processing
  89 // ----------------------------------------------------------------------------
  90
  91 // Consume all events until no more left
  92 void wxFlushEvents()
  93 {
  94     Display *display = (Display*) wxGetDisplay();
  95
  96     XSync (display, FALSE);
  97
  98 #ifdef __WXMOTIF__
  99     // XtAppPending returns availability of events AND timers/inputs, which
 100     // are processed via callbacks, so XtAppNextEvent will not return if
 101     // there are no events. So added '& XtIMXEvent' - Sergey.
 102     while (XtAppPending ((XtAppContext) wxTheApp->GetAppContext()) & XtIMXEvent)
 103     {
 104         XFlush (XtDisplay ((Widget) wxTheApp->GetTopLevelWidget()));
 105         // Jan Lessner: works better when events are non-X events
 106         XtAppProcessEvent((XtAppContext) wxTheApp->GetAppContext(), XtIMXEvent);
 107     }
 108 #endif
 109 #ifdef __WXX11__
 110     // TODO for X11
 111     // ??
 112 #endif
 113 }
 114
 115 // Check whether this window wants to process messages, e.g. Stop button
 116 // in long calculations.
 117 bool wxCheckForInterrupt(wxWindow *wnd)
 118 {
 119 #ifdef __WXMOTIF__
 120     wxCHECK_MSG( wnd, FALSE, "NULL window in wxCheckForInterrupt" );
 121
 122     Display *dpy=(Display*) wnd->GetXDisplay();
 123     Window win=(Window) wnd->GetXWindow();
 124     XEvent event;
 125     XFlush(dpy);
 126     if (wnd->GetMainWidget())
 127     {
 128         XmUpdateDisplay((Widget)(wnd->GetMainWidget()));
 129     }
 130
 131     bool hadEvents = FALSE;
 132     while( XCheckMaskEvent(dpy,
 133                            ButtonPressMask|ButtonReleaseMask|ButtonMotionMask|
 134                            PointerMotionMask|KeyPressMask|KeyReleaseMask,
 135                            &event) )
 136     {
 137         if ( event.xany.window == win )
 138         {
 139             hadEvents = TRUE;
 140
 141             XtDispatchEvent(&event);
 142         }
 143     }
 144
 145     return hadEvents;
 146 #else
 147     wxASSERT_MSG(FALSE, "wxCheckForInterrupt not yet implemented.");
 148     return FALSE;
 149 #endif
 150 }
 151
 152 // ----------------------------------------------------------------------------
 153 // wxExecute stuff
 154 // ----------------------------------------------------------------------------
 155 #ifdef __WXMOTIF__
 156 static void xt_notify_end_process(XtPointer data, int *WXUNUSED(fid),
 157                                   XtInputId *id)
 158 {
 159     wxEndProcessData *proc_data = (wxEndProcessData *)data;
 160
 161     wxHandleProcessTermination(proc_data);
 162
 163     // VZ: I think they should be the same...
 164     wxASSERT( (int)*id == proc_data->tag );
 165
 166     XtRemoveInput(*id);
 167 }
 168 #endif
 169
 170 int wxAddProcessCallback(wxEndProcessData *proc_data, int fd)
 171 {
 172 #ifdef __WXMOTIF__
 173     XtInputId id = XtAppAddInput((XtAppContext) wxTheApp->GetAppContext(),
 174                                  fd,
 175                                  (XtPointer *) XtInputReadMask,
 176                                  (XtInputCallbackProc) xt_notify_end_process,
 177                                  (XtPointer) proc_data);
 178
 179     return (int)id;
 180 #endif
 181 #ifdef __WXX11__
 182     // TODO
 183     return 0;
 184 #endif
 185 }
 186
 187 // ----------------------------------------------------------------------------
 188 // misc
 189 // ----------------------------------------------------------------------------
 190
 191 // Emit a beeeeeep
 192 void wxBell()
 193 {
 194     // Use current setting for the bell
 195     XBell ((Display*) wxGetDisplay(), 0);
 196 }
 197
 198 int wxGetOsVersion(int *majorVsn, int *minorVsn)
 199 {
 200 #ifdef __WXMOTIF__
 201     // FIXME TODO
 202     // This code is WRONG!! Does NOT return the
 203     // Motif version of the libs but the X protocol
 204     // version!
 205     Display *display = XtDisplay ((Widget) wxTheApp->GetTopLevelWidget());
 206     if (majorVsn)
 207         *majorVsn = ProtocolVersion (display);
 208     if (minorVsn)
 209         *minorVsn = ProtocolRevision (display);
 210
 211     return wxMOTIF_X;
 212 #endif
 213 #ifdef __WXX11__
 214     if (majorVsn)
 215         *majorVsn = 0;
 216     if (minorVsn)
 217         *minorVsn = 0;
 218     return wxX11;
 219 #endif
 220 }
 221
 222 // ----------------------------------------------------------------------------
 223 // Reading and writing resources (eg WIN.INI, .Xdefaults)
 224 // ----------------------------------------------------------------------------
 225
 226 // Read $HOME for what it says is home, if not
 227 // read $USER or $LOGNAME for user name else determine
 228 // the Real User, then determine the Real home dir.
 229 static char * GetIniFile (char *dest, const char *filename)
 230 {
 231     char *home = NULL;
 232     if (filename && wxIsAbsolutePath(filename))
 233     {
 234         strcpy(dest, filename);
 235     }
 236     else if ((home = wxGetUserHome("")) != NULL)
 237     {
 238         strcpy(dest, home);
 239         if (dest[strlen(dest) - 1] != '/')
 240             strcat (dest, "/");
 241         if (filename == NULL)
 242         {
 243             if ((filename = getenv ("XENVIRONMENT")) == NULL)
 244                 filename = ".Xdefaults";
 245         }
 246         else if (*filename != '.')
 247             strcat (dest, ".");
 248         strcat (dest, filename);
 249     } else
 250     {
 251         dest[0] = '\0';
 252     }
 253     return dest;
 254 }
 255
 256 #if wxUSE_RESOURCES
 257
 258 static char *GetResourcePath(char *buf, const char *name, bool create = FALSE)
 259 {
 260     if (create && wxFileExists (name) ) {
 261         strcpy(buf, name);
 262         return buf; // Exists so ...
 263     }
 264
 265     if (*name == '/')
 266         strcpy(buf, name);
 267     else {
 268         // Put in standard place for resource files if not absolute
 269         strcpy (buf, DEFAULT_XRESOURCE_DIR);
 270         strcat (buf, "/");
 271         strcat (buf, (const char*) wxFileNameFromPath (name));
 272     }
 273
 274     if (create) {
 275         // Touch the file to create it
 276         FILE *fd = fopen (buf, "w");
 277         if (fd) fclose (fd);
 278     }
 279     return buf;
 280 }
 281
 282 /*
 283 * We have a cache for writing different resource files,
 284 * which will only get flushed when we call wxFlushResources().
 285 * Build up a list of resource databases waiting to be written.
 286 *
 287 */
 288
 289 wxList wxResourceCache (wxKEY_STRING);
 290
 291 void
 292 wxFlushResources (void)
 293 {
 294     char nameBuffer[512];
 295
 296     wxNode *node = wxResourceCache.First ();
 297     while (node)
 298     {
 299         const char *file = node->GetKeyString();
 300         // If file doesn't exist, create it first.
 301         (void)GetResourcePath(nameBuffer, file, TRUE);
 302
 303         XrmDatabase database = (XrmDatabase) node->Data ();
 304         XrmPutFileDatabase (database, nameBuffer);
 305         XrmDestroyDatabase (database);
 306         wxNode *next = node->Next ();
 307         delete node;
 308         node = next;
 309     }
 310 }
 311
 312 static XrmDatabase wxResourceDatabase = 0;
 313
 314 void wxXMergeDatabases (wxApp * theApp, Display * display);
 315
 316 bool wxWriteResource(const wxString& section, const wxString& entry, const wxString& value, const wxString& file)
 317 {
 318     char buffer[500];
 319
 320     (void) GetIniFile (buffer, file);
 321
 322     XrmDatabase database;
 323     wxNode *node = wxResourceCache.Find (buffer);
 324     if (node)
 325         database = (XrmDatabase) node->Data ();
 326     else
 327     {
 328         database = XrmGetFileDatabase (buffer);
 329         wxResourceCache.Append (buffer, (wxObject *) database);
 330     }
 331
 332     char resName[300];
 333     strcpy (resName, (const char*) section);
 334     strcat (resName, ".");
 335     strcat (resName, (const char*) entry);
 336
 337     XrmPutStringResource (&database, resName, value);
 338     return TRUE;
 339 }
 340
 341 bool wxWriteResource(const wxString& section, const wxString& entry, float value, const wxString& file)
 342 {
 343     char buf[50];
 344     sprintf(buf, "%.4f", value);
 345     return wxWriteResource(section, entry, buf, file);
 346 }
 347
 348 bool wxWriteResource(const wxString& section, const wxString& entry, long value, const wxString& file)
 349 {
 350     char buf[50];
 351     sprintf(buf, "%ld", value);
 352     return wxWriteResource(section, entry, buf, file);
 353 }
 354
 355 bool wxWriteResource(const wxString& section, const wxString& entry, int value, const wxString& file)
 356 {
 357     char buf[50];
 358     sprintf(buf, "%d", value);
 359     return wxWriteResource(section, entry, buf, file);
 360 }
 361
 362 bool wxGetResource(const wxString& section, const wxString& entry, char **value, const wxString& file)
 363 {
 364     if (!wxResourceDatabase)
 365     {
 366         Display *display = (Display*) wxGetDisplay();
 367         wxXMergeDatabases (wxTheApp, display);
 368     }
 369
 370     XrmDatabase database;
 371
 372     if (file != "")
 373     {
 374         char buffer[500];
 375
 376         // Is this right? Trying to get it to look in the user's
 377         // home directory instead of current directory -- JACS
 378         (void) GetIniFile (buffer, file);
 379
 380         wxNode *node = wxResourceCache.Find (buffer);
 381         if (node)
 382             database = (XrmDatabase) node->Data ();
 383         else
 384         {
 385             database = XrmGetFileDatabase (buffer);
 386             wxResourceCache.Append (buffer, (wxObject *) database);
 387         }
 388     }
 389     else
 390         database = wxResourceDatabase;
 391
 392     XrmValue xvalue;
 393     char *str_type[20];
 394     char buf[150];
 395     strcpy (buf, section);
 396     strcat (buf, ".");
 397     strcat (buf, entry);
 398
 399     Bool success = XrmGetResource (database, buf, "*", str_type,
 400         &xvalue);
 401     // Try different combinations of upper/lower case, just in case...
 402     if (!success)
 403     {
 404         buf[0] = (isupper (buf[0]) ? tolower (buf[0]) : toupper (buf[0]));
 405         success = XrmGetResource (database, buf, "*", str_type,
 406             &xvalue);
 407     }
 408     if (success)
 409     {
 410         if (*value)
 411             delete[] *value;
 412
 413         *value = new char[xvalue.size + 1];
 414         strncpy (*value, xvalue.addr, (int) xvalue.size);
 415         return TRUE;
 416     }
 417     return FALSE;
 418 }
 419
 420 bool wxGetResource(const wxString& section, const wxString& entry, float *value, const wxString& file)
 421 {
 422     char *s = NULL;
 423     bool succ = wxGetResource(section, entry, (char **)&s, file);
 424     if (succ)
 425     {
 426         *value = (float)strtod(s, NULL);
 427         delete[] s;
 428         return TRUE;
 429     }
 430     else return FALSE;
 431 }
 432
 433 bool wxGetResource(const wxString& section, const wxString& entry, long *value, const wxString& file)
 434 {
 435     char *s = NULL;
 436     bool succ = wxGetResource(section, entry, (char **)&s, file);
 437     if (succ)
 438     {
 439         *value = strtol(s, NULL, 10);
 440         delete[] s;
 441         return TRUE;
 442     }
 443     else return FALSE;
 444 }
 445
 446 bool wxGetResource(const wxString& section, const wxString& entry, int *value, const wxString& file)
 447 {
 448     char *s = NULL;
 449     bool succ = wxGetResource(section, entry, (char **)&s, file);
 450     if (succ)
 451     {
 452         // Handle True, False here
 453         // True, Yes, Enables, Set or  Activated
 454         if (*s == 'T' || *s == 'Y' || *s == 'E' || *s == 'S' || *s == 'A')
 455             *value = TRUE;
 456         // False, No, Disabled, Reset, Cleared, Deactivated
 457         else if (*s == 'F' || *s == 'N' || *s == 'D' || *s == 'R' || *s == 'C')
 458             *value = FALSE;
 459         // Handle as Integer
 460         else
 461             *value = (int) strtol (s, NULL, 10);
 462         delete[] s;
 463         return TRUE;
 464     }
 465     else
 466         return FALSE;
 467 }
 468
 469 void wxXMergeDatabases (wxApp * theApp, Display * display)
 470 {
 471     XrmDatabase homeDB, serverDB, applicationDB;
 472     char filenamebuf[1024];
 473
 474     char *filename = &filenamebuf[0];
 475     char *environment;
 476     wxString classname = theApp->GetClassName();
 477     char name[256];
 478     (void) strcpy (name, "/usr/lib/X11/app-defaults/");
 479     (void) strcat (name, (const char*) classname);
 480
 481     /* Get application defaults file, if any */
 482     applicationDB = XrmGetFileDatabase (name);
 483     (void) XrmMergeDatabases (applicationDB, &wxResourceDatabase);
 484
 485     /* Merge server defaults, created by xrdb, loaded as a property of the root
 486     * window when the server initializes and loaded into the display
 487     * structure on XOpenDisplay;
 488     * if not defined, use .Xdefaults
 489     */
 490
 491     if (XResourceManagerString (display) != NULL)
 492     {
 493         serverDB = XrmGetStringDatabase (XResourceManagerString (display));
 494     }
 495     else
 496     {
 497         (void) GetIniFile (filename, NULL);
 498         serverDB = XrmGetFileDatabase (filename);
 499     }
 500     XrmMergeDatabases (serverDB, &wxResourceDatabase);
 501
 502     /* Open XENVIRONMENT file, or if not defined, the .Xdefaults,
 503     * and merge into existing database
 504     */
 505
 506     if ((environment = getenv ("XENVIRONMENT")) == NULL)
 507     {
 508         size_t len;
 509         environment = GetIniFile (filename, NULL);
 510         len = strlen (environment);
 511         wxString hostname = wxGetHostName();
 512         if ( !!hostname )
 513             strncat(environment, hostname, 1024 - len);
 514     }
 515     homeDB = XrmGetFileDatabase (environment);
 516     XrmMergeDatabases (homeDB, &wxResourceDatabase);
 517 }
 518
 519 #if 0
 520
 521 /*
 522 * Not yet used but may be useful.
 523 *
 524 */
 525 void
 526 wxSetDefaultResources (const Widget w, const char **resourceSpec, const char *name)
 527 {
 528     int i;
 529     Display *dpy = XtDisplay (w);    // Retrieve the display pointer
 530
 531     XrmDatabase rdb = NULL;    // A resource data base
 532
 533     // Create an empty resource database
 534     rdb = XrmGetStringDatabase ("");
 535
 536     // Add the Component resources, prepending the name of the component
 537
 538     i = 0;
 539     while (resourceSpec[i] != NULL)
 540     {
 541         char buf[1000];
 542
 543         sprintf (buf, "*%s%s", name, resourceSpec[i++]);
 544         XrmPutLineResource (&rdb, buf);
 545     }
 546
 547     // Merge them into the Xt database, with lowest precendence
 548
 549     if (rdb)
 550     {
 551 #if (XlibSpecificationRelease>=5)
 552         XrmDatabase db = XtDatabase (dpy);
 553         XrmCombineDatabase (rdb, &db, FALSE);
 554 #else
 555         XrmMergeDatabases (dpy->db, &rdb);
 556         dpy->db = rdb;
 557 #endif
 558     }
 559 }
 560 #endif
 561 // 0
 562
 563 #endif // wxUSE_RESOURCES
 564
 565 // ----------------------------------------------------------------------------
 566 // display info
 567 // ----------------------------------------------------------------------------
 568
 569 void wxGetMousePosition( int* x, int* y )
 570 {
 571 #if wxUSE_NANOX
 572     // TODO
 573     *x = 0;
 574     *y = 0;
 575 #else
 576     XMotionEvent xev;
 577     Window root, child;
 578     XQueryPointer((Display*) wxGetDisplay(),
 579                   DefaultRootWindow((Display*) wxGetDisplay()),
 580                   &root, &child,
 581                   &(xev.x_root), &(xev.y_root),
 582                   &(xev.x),      &(xev.y),
 583                   &(xev.state));
 584     *x = xev.x_root;
 585     *y = xev.y_root;
 586 #endif
 587 };
 588
 589 // Return TRUE if we have a colour display
 590 bool wxColourDisplay()
 591 {
 592     return wxDisplayDepth() > 1;
 593 }
 594
 595 // Returns depth of screen
 596 int wxDisplayDepth()
 597 {
 598     Display *dpy = (Display*) wxGetDisplay();
 599
 600     return DefaultDepth (dpy, DefaultScreen (dpy));
 601 }
 602
 603 // Get size of display
 604 void wxDisplaySize(int *width, int *height)
 605 {
 606     Display *dpy = (Display*) wxGetDisplay();
 607
 608     if ( width )
 609         *width = DisplayWidth (dpy, DefaultScreen (dpy));
 610     if ( height )
 611         *height = DisplayHeight (dpy, DefaultScreen (dpy));
 612 }
 613
 614 void wxDisplaySizeMM(int *width, int *height)
 615 {
 616     Display *dpy = (Display*) wxGetDisplay();
 617
 618     if ( width )
 619         *width = DisplayWidthMM(dpy, DefaultScreen (dpy));
 620     if ( height )
 621         *height = DisplayHeightMM(dpy, DefaultScreen (dpy));
 622 }
 623
 624 void wxClientDisplayRect(int *x, int *y, int *width, int *height)
 625 {
 626     // This is supposed to return desktop dimensions minus any window
 627     // manager panels, menus, taskbars, etc.  If there is a way to do that
 628     // for this platform please fix this function, otherwise it defaults
 629     // to the entire desktop.
 630     if (x) *x = 0;
 631     if (y) *y = 0;
 632     wxDisplaySize(width, height);
 633 }
 634
 635
 636 // Configurable display in wxX11 and wxMotif
 637 static WXDisplay *gs_currentDisplay = NULL;
 638 static wxString gs_displayName;
 639
 640 WXDisplay *wxGetDisplay()
 641 {
 642     if (gs_currentDisplay)
 643         return gs_currentDisplay;
 644 #ifdef __WXMOTIF__
 645     if (wxTheApp && wxTheApp->GetTopLevelWidget())
 646         return XtDisplay ((Widget) wxTheApp->GetTopLevelWidget());
 647     else if (wxTheApp)
 648         return wxTheApp->GetInitialDisplay();
 649     return NULL;
 650 #endif
 651 #ifdef __WXX11__
 652     return wxApp::GetDisplay();
 653 #endif
 654 }
 655
 656 bool wxSetDisplay(const wxString& display_name)
 657 {
 658     gs_displayName = display_name;
 659
 660     if ( display_name.IsEmpty() )
 661     {
 662         gs_currentDisplay = NULL;
 663
 664         return TRUE;
 665     }
 666     else
 667     {
 668 #ifdef __WXMOTIF__
 669         Cardinal argc = 0;
 670
 671         Display *display = XtOpenDisplay((XtAppContext) wxTheApp->GetAppContext(),
 672             (const char*) display_name,
 673             (const char*) wxTheApp->GetAppName(),
 674             (const char*) wxTheApp->GetClassName(),
 675             NULL,
 676 #if XtSpecificationRelease < 5
 677             0, &argc,
 678 #else
 679             0, (int *)&argc,
 680 #endif
 681             NULL);
 682
 683         if (display)
 684         {
 685             gs_currentDisplay = (WXDisplay*) display;
 686             return TRUE;
 687         }
 688         else
 689             return FALSE;
 690 #endif
 691 #ifdef __WXX11__
 692         Display* display = XOpenDisplay((char*) display_name.c_str());
 693
 694         if (display)
 695         {
 696             gs_currentDisplay = (WXDisplay*) display;
 697             return TRUE;
 698         }
 699         else
 700             return FALSE;
 701 #endif
 702     }
 703 }
 704
 705 wxString wxGetDisplayName()
 706 {
 707     return gs_displayName;
 708 }
 709
 710 wxWindow* wxFindWindowAtPoint(const wxPoint& pt)
 711 {
 712     return wxGenericFindWindowAtPoint(pt);
 713 }
 714
 715 // ----------------------------------------------------------------------------
 716 // keycode translations
 717 // ----------------------------------------------------------------------------
 718
 719 #include <X11/keysym.h>
 720
 721 // FIXME what about tables??
 722
 723 int wxCharCodeXToWX(KeySym keySym)
 724 {
 725     int id;
 726     switch (keySym)
 727     {
 728         case XK_Shift_L:
 729         case XK_Shift_R:
 730             id = WXK_SHIFT; break;
 731         case XK_Control_L:
 732         case XK_Control_R:
 733             id = WXK_CONTROL; break;
 734         case XK_BackSpace:
 735             id = WXK_BACK; break;
 736         case XK_Delete:
 737             id = WXK_DELETE; break;
 738         case XK_Clear:
 739             id = WXK_CLEAR; break;
 740         case XK_Tab:
 741             id = WXK_TAB; break;
 742         case XK_numbersign:
 743             id = '#'; break;
 744         case XK_Return:
 745             id = WXK_RETURN; break;
 746         case XK_Escape:
 747             id = WXK_ESCAPE; break;
 748         case XK_Pause:
 749         case XK_Break:
 750             id = WXK_PAUSE; break;
 751         case XK_Num_Lock:
 752             id = WXK_NUMLOCK; break;
 753         case XK_Scroll_Lock:
 754             id = WXK_SCROLL; break;
 755
 756         case XK_Home:
 757             id = WXK_HOME; break;
 758         case XK_End:
 759             id = WXK_END; break;
 760         case XK_Left:
 761             id = WXK_LEFT; break;
 762         case XK_Right:
 763             id = WXK_RIGHT; break;
 764         case XK_Up:
 765             id = WXK_UP; break;
 766         case XK_Down:
 767             id = WXK_DOWN; break;
 768         case XK_Next:
 769             id = WXK_NEXT; break;
 770         case XK_Prior:
 771             id = WXK_PRIOR; break;
 772         case XK_Menu:
 773             id = WXK_MENU; break;
 774         case XK_Select:
 775             id = WXK_SELECT; break;
 776         case XK_Cancel:
 777             id = WXK_CANCEL; break;
 778         case XK_Print:
 779             id = WXK_PRINT; break;
 780         case XK_Execute:
 781             id = WXK_EXECUTE; break;
 782         case XK_Insert:
 783             id = WXK_INSERT; break;
 784         case XK_Help:
 785             id = WXK_HELP; break;
 786
 787         case XK_KP_Multiply:
 788             id = WXK_MULTIPLY; break;
 789         case XK_KP_Add:
 790             id = WXK_ADD; break;
 791         case XK_KP_Subtract:
 792             id = WXK_SUBTRACT; break;
 793         case XK_KP_Divide:
 794             id = WXK_DIVIDE; break;
 795         case XK_KP_Decimal:
 796             id = WXK_DECIMAL; break;
 797         case XK_KP_Equal:
 798             id = '='; break;
 799         case XK_KP_Space:
 800             id = ' '; break;
 801         case XK_KP_Tab:
 802             id = WXK_TAB; break;
 803         case XK_KP_Enter:
 804             id = WXK_RETURN; break;
 805         case XK_KP_0:
 806             id = WXK_NUMPAD0; break;
 807         case XK_KP_1:
 808             id = WXK_NUMPAD1; break;
 809         case XK_KP_2:
 810             id = WXK_NUMPAD2; break;
 811         case XK_KP_3:
 812             id = WXK_NUMPAD3; break;
 813         case XK_KP_4:
 814             id = WXK_NUMPAD4; break;
 815         case XK_KP_5:
 816             id = WXK_NUMPAD5; break;
 817         case XK_KP_6:
 818             id = WXK_NUMPAD6; break;
 819         case XK_KP_7:
 820             id = WXK_NUMPAD7; break;
 821         case XK_KP_8:
 822             id = WXK_NUMPAD8; break;
 823         case XK_KP_9:
 824             id = WXK_NUMPAD9; break;
 825         case XK_F1:
 826             id = WXK_F1; break;
 827         case XK_F2:
 828             id = WXK_F2; break;
 829         case XK_F3:
 830             id = WXK_F3; break;
 831         case XK_F4:
 832             id = WXK_F4; break;
 833         case XK_F5:
 834             id = WXK_F5; break;
 835         case XK_F6:
 836             id = WXK_F6; break;
 837         case XK_F7:
 838             id = WXK_F7; break;
 839         case XK_F8:
 840             id = WXK_F8; break;
 841         case XK_F9:
 842             id = WXK_F9; break;
 843         case XK_F10:
 844             id = WXK_F10; break;
 845         case XK_F11:
 846             id = WXK_F11; break;
 847         case XK_F12:
 848             id = WXK_F12; break;
 849         case XK_F13:
 850             id = WXK_F13; break;
 851         case XK_F14:
 852             id = WXK_F14; break;
 853         case XK_F15:
 854             id = WXK_F15; break;
 855         case XK_F16:
 856             id = WXK_F16; break;
 857         case XK_F17:
 858             id = WXK_F17; break;
 859         case XK_F18:
 860             id = WXK_F18; break;
 861         case XK_F19:
 862             id = WXK_F19; break;
 863         case XK_F20:
 864             id = WXK_F20; break;
 865         case XK_F21:
 866             id = WXK_F21; break;
 867         case XK_F22:
 868             id = WXK_F22; break;
 869         case XK_F23:
 870             id = WXK_F23; break;
 871         case XK_F24:
 872             id = WXK_F24; break;
 873         default:
 874             id = (keySym <= 255) ? (int)keySym : -1;
 875     }
 876
 877     return id;
 878 }
 879
 880 KeySym wxCharCodeWXToX(int id)
 881 {
 882     KeySym keySym;
 883
 884     switch (id)
 885     {
 886         case WXK_CANCEL:            keySym = XK_Cancel; break;
 887         case WXK_BACK:              keySym = XK_BackSpace; break;
 888         case WXK_TAB:            keySym = XK_Tab; break;
 889         case WXK_CLEAR:        keySym = XK_Clear; break;
 890         case WXK_RETURN:        keySym = XK_Return; break;
 891         case WXK_SHIFT:        keySym = XK_Shift_L; break;
 892         case WXK_CONTROL:        keySym = XK_Control_L; break;
 893         case WXK_MENU :        keySym = XK_Menu; break;
 894         case WXK_PAUSE:        keySym = XK_Pause; break;
 895         case WXK_ESCAPE:        keySym = XK_Escape; break;
 896         case WXK_SPACE:        keySym = ' '; break;
 897         case WXK_PRIOR:        keySym = XK_Prior; break;
 898         case WXK_NEXT :        keySym = XK_Next; break;
 899         case WXK_END:        keySym = XK_End; break;
 900         case WXK_HOME :        keySym = XK_Home; break;
 901         case WXK_LEFT :        keySym = XK_Left; break;
 902         case WXK_UP:        keySym = XK_Up; break;
 903         case WXK_RIGHT:        keySym = XK_Right; break;
 904         case WXK_DOWN :        keySym = XK_Down; break;
 905         case WXK_SELECT:        keySym = XK_Select; break;
 906         case WXK_PRINT:        keySym = XK_Print; break;
 907         case WXK_EXECUTE:        keySym = XK_Execute; break;
 908         case WXK_INSERT:        keySym = XK_Insert; break;
 909         case WXK_DELETE:        keySym = XK_Delete; break;
 910         case WXK_HELP :        keySym = XK_Help; break;
 911         case WXK_NUMPAD0:        keySym = XK_KP_0; break;
 912         case WXK_NUMPAD1:        keySym = XK_KP_1; break;
 913         case WXK_NUMPAD2:        keySym = XK_KP_2; break;
 914         case WXK_NUMPAD3:        keySym = XK_KP_3; break;
 915         case WXK_NUMPAD4:        keySym = XK_KP_4; break;
 916         case WXK_NUMPAD5:        keySym = XK_KP_5; break;
 917         case WXK_NUMPAD6:        keySym = XK_KP_6; break;
 918         case WXK_NUMPAD7:        keySym = XK_KP_7; break;
 919         case WXK_NUMPAD8:        keySym = XK_KP_8; break;
 920         case WXK_NUMPAD9:        keySym = XK_KP_9; break;
 921         case WXK_MULTIPLY:        keySym = XK_KP_Multiply; break;
 922         case WXK_ADD:        keySym = XK_KP_Add; break;
 923         case WXK_SUBTRACT:        keySym = XK_KP_Subtract; break;
 924         case WXK_DECIMAL:        keySym = XK_KP_Decimal; break;
 925         case WXK_DIVIDE:        keySym = XK_KP_Divide; break;
 926         case WXK_F1:        keySym = XK_F1; break;
 927         case WXK_F2:        keySym = XK_F2; break;
 928         case WXK_F3:        keySym = XK_F3; break;
 929         case WXK_F4:        keySym = XK_F4; break;
 930         case WXK_F5:        keySym = XK_F5; break;
 931         case WXK_F6:        keySym = XK_F6; break;
 932         case WXK_F7:        keySym = XK_F7; break;
 933         case WXK_F8:        keySym = XK_F8; break;
 934         case WXK_F9:        keySym = XK_F9; break;
 935         case WXK_F10:        keySym = XK_F10; break;
 936         case WXK_F11:        keySym = XK_F11; break;
 937         case WXK_F12:        keySym = XK_F12; break;
 938         case WXK_F13:        keySym = XK_F13; break;
 939         case WXK_F14:        keySym = XK_F14; break;
 940         case WXK_F15:        keySym = XK_F15; break;
 941         case WXK_F16:        keySym = XK_F16; break;
 942         case WXK_F17:        keySym = XK_F17; break;
 943         case WXK_F18:        keySym = XK_F18; break;
 944         case WXK_F19:        keySym = XK_F19; break;
 945         case WXK_F20:        keySym = XK_F20; break;
 946         case WXK_F21:        keySym = XK_F21; break;
 947         case WXK_F22:        keySym = XK_F22; break;
 948         case WXK_F23:        keySym = XK_F23; break;
 949         case WXK_F24:        keySym = XK_F24; break;
 950         case WXK_NUMLOCK:    keySym = XK_Num_Lock; break;
 951         case WXK_SCROLL:     keySym = XK_Scroll_Lock; break;
 952         default:             keySym = id <= 255 ? (KeySym)id : 0;
 953     }
 954
 955     return keySym;
 956 }
 957
 958 // ----------------------------------------------------------------------------
 959 // Some colour manipulation routines
 960 // ----------------------------------------------------------------------------
 961
 962 void wxHSVToXColor(wxHSV *hsv,XColor *rgb)
 963 {
 964     int h = hsv->h;
 965     int s = hsv->s;
 966     int v = hsv->v;
 967     int r = 0, g = 0, b = 0;
 968     int i, f;
 969     int p, q, t;
 970     s = (s * wxMAX_RGB) / wxMAX_SV;
 971     v = (v * wxMAX_RGB) / wxMAX_SV;
 972     if (h == 360) h = 0;
 973     if (s == 0) { h = 0; r = g = b = v; }
 974     i = h / 60;
 975     f = h % 60;
 976     p = v * (wxMAX_RGB - s) / wxMAX_RGB;
 977     q = v * (wxMAX_RGB - s * f / 60) / wxMAX_RGB;
 978     t = v * (wxMAX_RGB - s * (60 - f) / 60) / wxMAX_RGB;
 979     switch (i)
 980     {
 981     case 0: r = v, g = t, b = p; break;
 982     case 1: r = q, g = v, b = p; break;
 983     case 2: r = p, g = v, b = t; break;
 984     case 3: r = p, g = q, b = v; break;
 985     case 4: r = t, g = p, b = v; break;
 986     case 5: r = v, g = p, b = q; break;
 987     }
 988     rgb->red = r << 8;
 989     rgb->green = g << 8;
 990     rgb->blue = b << 8;
 991 }
 992
 993 void wxXColorToHSV(wxHSV *hsv,XColor *rgb)
 994 {
 995     int r = rgb->red >> 8;
 996     int g = rgb->green >> 8;
 997     int b = rgb->blue >> 8;
 998     int maxv = wxMax3(r, g, b);
 999     int minv = wxMin3(r, g, b);
1000     int h = 0, s, v;
1001     v = maxv;
1002     if (maxv) s = (maxv - minv) * wxMAX_RGB / maxv;
1003     else s = 0;
1004     if (s == 0) h = 0;
1005     else
1006     {
1007         int rc, gc, bc, hex = 0;
1008         rc = (maxv - r) * wxMAX_RGB / (maxv - minv);
1009         gc = (maxv - g) * wxMAX_RGB / (maxv - minv);
1010         bc = (maxv - b) * wxMAX_RGB / (maxv - minv);
1011         if (r == maxv) { h = bc - gc, hex = 0; }
1012         else if (g == maxv) { h = rc - bc, hex = 2; }
1013         else if (b == maxv) { h = gc - rc, hex = 4; }
1014         h = hex * 60 + (h * 60 / wxMAX_RGB);
1015         if (h < 0) h += 360;
1016     }
1017     hsv->h = h;
1018     hsv->s = (s * wxMAX_SV) / wxMAX_RGB;
1019     hsv->v = (v * wxMAX_SV) / wxMAX_RGB;
1020 }
1021
1022 void wxAllocNearestColor(Display *d,Colormap cmp,XColor *xc)
1023 {
1024 #if !wxUSE_NANOX
1025     int llp;
1026
1027     int screen = DefaultScreen(d);
1028     int num_colors = DisplayCells(d,screen);
1029
1030     XColor *color_defs = new XColor[num_colors];
1031     for(llp = 0;llp < num_colors;llp++) color_defs[llp].pixel = llp;
1032     XQueryColors(d,cmp,color_defs,num_colors);
1033
1034     wxHSV hsv_defs, hsv;
1035     wxXColorToHSV(&hsv,xc);
1036
1037     int diff, min_diff = 0, pixel = 0;
1038
1039     for(llp = 0;llp < num_colors;llp++)
1040     {
1041         wxXColorToHSV(&hsv_defs,&color_defs[llp]);
1042         diff = wxSIGN(wxH_WEIGHT * (hsv.h - hsv_defs.h)) +
1043             wxSIGN(wxS_WEIGHT * (hsv.s - hsv_defs.s)) +
1044             wxSIGN(wxV_WEIGHT * (hsv.v - hsv_defs.v));
1045         if (llp == 0) min_diff = diff;
1046         if (min_diff > diff) { min_diff = diff; pixel = llp; }
1047         if (min_diff == 0) break;
1048     }
1049
1050     xc -> red = color_defs[pixel].red;
1051     xc -> green = color_defs[pixel].green;
1052     xc -> blue = color_defs[pixel].blue;
1053     xc -> flags = DoRed | DoGreen | DoBlue;
1054
1055 /*  FIXME, TODO
1056     if (!XAllocColor(d,cmp,xc))
1057         cout << "wxAllocNearestColor : Warning : Cannot find nearest color !\n";
1058 */
1059
1060     delete[] color_defs;
1061 #endif
1062 }
1063
1064 void wxAllocColor(Display *d,Colormap cmp,XColor *xc)
1065 {
1066     if (!XAllocColor(d,cmp,xc))
1067     {
1068         //          cout << "wxAllocColor : Warning : Can not allocate color, attempt find nearest !\n";
1069         wxAllocNearestColor(d,cmp,xc);
1070     }
1071 }
1072
1073 #ifdef __WXDEBUG__
1074 wxString wxGetXEventName(XEvent& event)
1075 {
1076 #if wxUSE_NANOX
1077     wxString str(wxT("(some event)"));
1078     return str;
1079 #else
1080     int type = event.xany.type;
1081             static char* event_name[] = {
1082                 "", "unknown(-)",                                         // 0-1
1083                 "KeyPress", "KeyRelease", "ButtonPress", "ButtonRelease", // 2-5
1084                 "MotionNotify", "EnterNotify", "LeaveNotify", "FocusIn",  // 6-9
1085                 "FocusOut", "KeymapNotify", "Expose", "GraphicsExpose",   // 10-13
1086                 "NoExpose", "VisibilityNotify", "CreateNotify",           // 14-16
1087                 "DestroyNotify", "UnmapNotify", "MapNotify", "MapRequest",// 17-20
1088                 "ReparentNotify", "ConfigureNotify", "ConfigureRequest",  // 21-23
1089                 "GravityNotify", "ResizeRequest", "CirculateNotify",      // 24-26
1090                 "CirculateRequest", "PropertyNotify", "SelectionClear",   // 27-29
1091                 "SelectionRequest", "SelectionNotify", "ColormapNotify",  // 30-32
1092                 "ClientMessage", "MappingNotify",                         // 33-34
1093                 "unknown(+)"};                                            // 35
1094             type = wxMin(35, type); type = wxMax(1, type);
1095         wxString str(event_name[type]);
1096         return str;
1097 #endif
1098 }
1099 #endif
1100
1101 #ifdef __WXMOTIF__
1102 // ----------------------------------------------------------------------------
1103 // accelerators
1104 // ----------------------------------------------------------------------------
1105
1106 // Find the letter corresponding to the mnemonic, for Motif
1107 char wxFindMnemonic (const char *s)
1108 {
1109     char mnem = 0;
1110     int len = strlen (s);
1111     int i;
1112     for (i = 0; i < len; i++)
1113     {
1114         if (s[i] == '&')
1115         {
1116             // Carefully handle &&
1117             if ((i + 1) <= len && s[i + 1] == '&')
1118                 i++;
1119             else
1120             {
1121                 mnem = s[i + 1];
1122                 break;
1123             }
1124         }
1125     }
1126     return mnem;
1127 }
1128
1129 char * wxFindAccelerator (const char *s)
1130 {
1131     // VZ: this function returns incorrect keysym which completely breaks kbd
1132     //     handling
1133     return NULL;
1134
1135 #if 0
1136    // The accelerator text is after the \t char.
1137     while (*s && *s != '\t')
1138         s++;
1139     if (*s == '\0')
1140         return (NULL);
1141     s++;
1142     /*
1143     Now we need to format it as X standard:
1144
1145       input            output
1146
1147         F7           --> <Key>F7
1148         Ctrl+N       --> Ctrl<Key>N
1149         Alt+k        --> Meta<Key>k
1150         Ctrl+Shift+A --> Ctrl Shift<Key>A
1151
1152     */
1153
1154     static char buf[256];
1155     buf[0] = '\0';
1156     char *tmp = copystring (s);
1157     s = tmp;
1158     char *p = tmp;
1159
1160     while (1)
1161     {
1162         while (*p && *p != '+')
1163             p++;
1164         if (*p)
1165         {
1166             *p = '\0';
1167             if (buf[0])
1168                 strcat (buf, " ");
1169             if (strcmp (s, "Alt"))
1170                 strcat (buf, s);
1171             else
1172                 strcat (buf, "Meta");
1173             s = p++;
1174         }
1175         else
1176         {
1177             strcat (buf, "<Key>");
1178             strcat (buf, s);
1179             break;
1180         }
1181     }
1182     delete[]tmp;
1183     return buf;
1184 #endif
1185 }
1186
1187 XmString wxFindAcceleratorText (const char *s)
1188 {
1189     // VZ: this function returns incorrect keysym which completely breaks kbd
1190     //     handling
1191     return NULL;
1192
1193 #if 0
1194    // The accelerator text is after the \t char.
1195     while (*s && *s != '\t')
1196         s++;
1197     if (*s == '\0')
1198         return (NULL);
1199     s++;
1200     XmString text = XmStringCreateSimple ((char *)s);
1201     return text;
1202 #endif
1203 }
1204
1205
1206 // These functions duplicate those in wxWindow, but are needed
1207 // for use outside of wxWindow (e.g. wxMenu, wxMenuBar).
1208
1209 // Change a widget's foreground and background colours.
1210
1211 void wxDoChangeForegroundColour(WXWidget widget, wxColour& foregroundColour)
1212 {
1213     // When should we specify the foreground, if it's calculated
1214     // by wxComputeColours?
1215     // Solution: say we start with the default (computed) foreground colour.
1216     // If we call SetForegroundColour explicitly for a control or window,
1217     // then the foreground is changed.
1218     // Therefore SetBackgroundColour computes the foreground colour, and
1219     // SetForegroundColour changes the foreground colour. The ordering is
1220     // important.
1221
1222     XtVaSetValues ((Widget) widget,
1223         XmNforeground, foregroundColour.AllocColour(XtDisplay((Widget) widget)),
1224         NULL);
1225 }
1226
1227 void wxDoChangeBackgroundColour(WXWidget widget, wxColour& backgroundColour, bool changeArmColour)
1228 {
1229     wxComputeColours (XtDisplay((Widget) widget), & backgroundColour,
1230         (wxColour*) NULL);
1231
1232     XtVaSetValues ((Widget) widget,
1233         XmNbackground, g_itemColors[wxBACK_INDEX].pixel,
1234         XmNtopShadowColor, g_itemColors[wxTOPS_INDEX].pixel,
1235         XmNbottomShadowColor, g_itemColors[wxBOTS_INDEX].pixel,
1236         XmNforeground, g_itemColors[wxFORE_INDEX].pixel,
1237         NULL);
1238
1239     if (changeArmColour)
1240         XtVaSetValues ((Widget) widget,
1241         XmNarmColor, g_itemColors[wxSELE_INDEX].pixel,
1242         NULL);
1243 }
1244
1245 #endif
1246     // __WXMOTIF__
1247
1248 bool wxWindowIsVisible(Window win)
1249 {
1250     XWindowAttributes wa;
1251     XGetWindowAttributes(wxGlobalDisplay(), win, &wa);
1252
1253     return (wa.map_state == IsViewable);
1254 }