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