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