]> git.saurik.com Git - wxWidgets.git/blob - src/motif/utils.cpp
compilation fix
[wxWidgets.git] / src / motif / 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