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