]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: src/motif/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 | // For compilers that support precompilation, includes "wx.h". | |
21 | #include "wx/wxprec.h" | |
22 | ||
23 | #include "wx/utils.h" | |
24 | ||
25 | #ifndef WX_PRECOMP | |
26 | #include "wx/app.h" | |
27 | #include "wx/dcmemory.h" | |
28 | #include "wx/bitmap.h" | |
29 | #endif | |
30 | ||
31 | #include "wx/apptrait.h" | |
32 | #include "wx/evtloop.h" | |
33 | #include "wx/motif/private/timer.h" | |
34 | ||
35 | #include <string.h> | |
36 | ||
37 | #if (defined(__SUNCC__) || defined(__CLCC__)) | |
38 | #include <sysent.h> | |
39 | #endif | |
40 | ||
41 | #ifdef __VMS__ | |
42 | #pragma message disable nosimpint | |
43 | #endif | |
44 | ||
45 | #include "wx/unix/execute.h" | |
46 | ||
47 | #include <Xm/Xm.h> | |
48 | #include <Xm/Frame.h> | |
49 | ||
50 | #include "wx/motif/private.h" | |
51 | ||
52 | #include "X11/Xutil.h" | |
53 | ||
54 | #ifdef __VMS__ | |
55 | #pragma message enable nosimpint | |
56 | #endif | |
57 | ||
58 | ||
59 | // ============================================================================ | |
60 | // implementation | |
61 | // ============================================================================ | |
62 | ||
63 | // ---------------------------------------------------------------------------- | |
64 | // async event processing | |
65 | // ---------------------------------------------------------------------------- | |
66 | ||
67 | // Consume all events until no more left | |
68 | void wxFlushEvents(WXDisplay* wxdisplay) | |
69 | { | |
70 | Display *display = (Display*)wxdisplay; | |
71 | wxEventLoop evtLoop; | |
72 | ||
73 | XSync (display, False); | |
74 | ||
75 | while (evtLoop.Pending()) | |
76 | { | |
77 | XFlush (display); | |
78 | evtLoop.Dispatch(); | |
79 | } | |
80 | } | |
81 | ||
82 | // ---------------------------------------------------------------------------- | |
83 | // wxExecute stuff | |
84 | // ---------------------------------------------------------------------------- | |
85 | ||
86 | static void xt_notify_end_process(XtPointer data, int *WXUNUSED(fid), | |
87 | XtInputId *id) | |
88 | { | |
89 | wxEndProcessData *proc_data = (wxEndProcessData *)data; | |
90 | ||
91 | wxHandleProcessTermination(proc_data); | |
92 | ||
93 | // VZ: I think they should be the same... | |
94 | wxASSERT( (int)*id == proc_data->tag ); | |
95 | ||
96 | XtRemoveInput(*id); | |
97 | } | |
98 | ||
99 | int wxGUIAppTraits::AddProcessCallback(wxEndProcessData *proc_data, int fd) | |
100 | { | |
101 | XtInputId id = XtAppAddInput((XtAppContext) wxTheApp->GetAppContext(), | |
102 | fd, | |
103 | (XtPointer *) XtInputReadMask, | |
104 | (XtInputCallbackProc) xt_notify_end_process, | |
105 | (XtPointer) proc_data); | |
106 | ||
107 | return (int)id; | |
108 | } | |
109 | ||
110 | // ---------------------------------------------------------------------------- | |
111 | // misc | |
112 | // ---------------------------------------------------------------------------- | |
113 | ||
114 | // Emit a beeeeeep | |
115 | #ifndef __EMX__ | |
116 | // on OS/2, we use the wxBell from wxBase library (src/os2/utils.cpp) | |
117 | void wxBell() | |
118 | { | |
119 | // Use current setting for the bell | |
120 | XBell (wxGlobalDisplay(), 0); | |
121 | } | |
122 | #endif | |
123 | ||
124 | wxPortId wxGUIAppTraits::GetToolkitVersion(int *verMaj, int *verMin) const | |
125 | { | |
126 | // XmVERSION and XmREVISION are defined in Xm/Xm.h | |
127 | if ( verMaj ) | |
128 | *verMaj = XmVERSION; | |
129 | if ( verMin ) | |
130 | *verMin = XmREVISION; | |
131 | ||
132 | return wxPORT_MOTIF; | |
133 | } | |
134 | ||
135 | wxEventLoopBase* wxGUIAppTraits::CreateEventLoop() | |
136 | { | |
137 | return new wxEventLoop; | |
138 | } | |
139 | ||
140 | wxTimerImpl* wxGUIAppTraits::CreateTimerImpl(wxTimer* timer) | |
141 | { | |
142 | return new wxMotifTimerImpl(timer); | |
143 | } | |
144 | ||
145 | // ---------------------------------------------------------------------------- | |
146 | // display info | |
147 | // ---------------------------------------------------------------------------- | |
148 | ||
149 | void wxGetMousePosition( int* x, int* y ) | |
150 | { | |
151 | #if wxUSE_NANOX | |
152 | // TODO | |
153 | *x = 0; | |
154 | *y = 0; | |
155 | #else | |
156 | XMotionEvent xev; | |
157 | Window root, child; | |
158 | XQueryPointer(wxGlobalDisplay(), | |
159 | DefaultRootWindow(wxGlobalDisplay()), | |
160 | &root, &child, | |
161 | &(xev.x_root), &(xev.y_root), | |
162 | &(xev.x), &(xev.y), | |
163 | &(xev.state)); | |
164 | *x = xev.x_root; | |
165 | *y = xev.y_root; | |
166 | #endif | |
167 | } | |
168 | ||
169 | // Return true if we have a colour display | |
170 | bool wxColourDisplay() | |
171 | { | |
172 | return wxDisplayDepth() > 1; | |
173 | } | |
174 | ||
175 | // Returns depth of screen | |
176 | int wxDisplayDepth() | |
177 | { | |
178 | Display *dpy = wxGlobalDisplay(); | |
179 | ||
180 | return DefaultDepth (dpy, DefaultScreen (dpy)); | |
181 | } | |
182 | ||
183 | // Get size of display | |
184 | void wxDisplaySize(int *width, int *height) | |
185 | { | |
186 | Display *dpy = wxGlobalDisplay(); | |
187 | ||
188 | if ( width ) | |
189 | *width = DisplayWidth (dpy, DefaultScreen (dpy)); | |
190 | if ( height ) | |
191 | *height = DisplayHeight (dpy, DefaultScreen (dpy)); | |
192 | } | |
193 | ||
194 | void wxDisplaySizeMM(int *width, int *height) | |
195 | { | |
196 | Display *dpy = wxGlobalDisplay(); | |
197 | ||
198 | if ( width ) | |
199 | *width = DisplayWidthMM(dpy, DefaultScreen (dpy)); | |
200 | if ( height ) | |
201 | *height = DisplayHeightMM(dpy, DefaultScreen (dpy)); | |
202 | } | |
203 | ||
204 | // Configurable display in wxX11 and wxMotif | |
205 | static WXDisplay *gs_currentDisplay = NULL; | |
206 | static wxString gs_displayName; | |
207 | ||
208 | WXDisplay *wxGetDisplay() | |
209 | { | |
210 | if (gs_currentDisplay) | |
211 | return gs_currentDisplay; | |
212 | else if (wxTheApp) | |
213 | return wxTheApp->GetInitialDisplay(); | |
214 | return NULL; | |
215 | } | |
216 | ||
217 | bool wxSetDisplay(const wxString& display_name) | |
218 | { | |
219 | gs_displayName = display_name; | |
220 | ||
221 | if ( display_name.empty() ) | |
222 | { | |
223 | gs_currentDisplay = NULL; | |
224 | ||
225 | return true; | |
226 | } | |
227 | else | |
228 | { | |
229 | Cardinal argc = 0; | |
230 | ||
231 | Display *display = XtOpenDisplay((XtAppContext) wxTheApp->GetAppContext(), | |
232 | display_name.c_str(), | |
233 | wxTheApp->GetAppName().c_str(), | |
234 | wxTheApp->GetClassName().c_str(), | |
235 | NULL, | |
236 | #if XtSpecificationRelease < 5 | |
237 | 0, &argc, | |
238 | #else | |
239 | 0, (int *)&argc, | |
240 | #endif | |
241 | NULL); | |
242 | ||
243 | if (display) | |
244 | { | |
245 | gs_currentDisplay = (WXDisplay*) display; | |
246 | return true; | |
247 | } | |
248 | else | |
249 | return false; | |
250 | } | |
251 | } | |
252 | ||
253 | wxString wxGetDisplayName() | |
254 | { | |
255 | return gs_displayName; | |
256 | } | |
257 | ||
258 | wxWindow* wxFindWindowAtPoint(const wxPoint& pt) | |
259 | { | |
260 | return wxGenericFindWindowAtPoint(pt); | |
261 | } | |
262 | ||
263 | // ---------------------------------------------------------------------------- | |
264 | // Some colour manipulation routines | |
265 | // ---------------------------------------------------------------------------- | |
266 | ||
267 | void wxHSVToXColor(wxHSV *hsv,XColor *rgb) | |
268 | { | |
269 | int h = hsv->h; | |
270 | int s = hsv->s; | |
271 | int v = hsv->v; | |
272 | int r = 0, g = 0, b = 0; | |
273 | int i, f; | |
274 | int p, q, t; | |
275 | s = (s * wxMAX_RGB) / wxMAX_SV; | |
276 | v = (v * wxMAX_RGB) / wxMAX_SV; | |
277 | if (h == 360) h = 0; | |
278 | if (s == 0) { h = 0; r = g = b = v; } | |
279 | i = h / 60; | |
280 | f = h % 60; | |
281 | p = v * (wxMAX_RGB - s) / wxMAX_RGB; | |
282 | q = v * (wxMAX_RGB - s * f / 60) / wxMAX_RGB; | |
283 | t = v * (wxMAX_RGB - s * (60 - f) / 60) / wxMAX_RGB; | |
284 | switch (i) | |
285 | { | |
286 | case 0: r = v, g = t, b = p; break; | |
287 | case 1: r = q, g = v, b = p; break; | |
288 | case 2: r = p, g = v, b = t; break; | |
289 | case 3: r = p, g = q, b = v; break; | |
290 | case 4: r = t, g = p, b = v; break; | |
291 | case 5: r = v, g = p, b = q; break; | |
292 | } | |
293 | rgb->red = (unsigned short)(r << 8); | |
294 | rgb->green = (unsigned short)(g << 8); | |
295 | rgb->blue = (unsigned short)(b << 8); | |
296 | } | |
297 | ||
298 | void wxXColorToHSV(wxHSV *hsv,XColor *rgb) | |
299 | { | |
300 | int r = rgb->red >> 8; | |
301 | int g = rgb->green >> 8; | |
302 | int b = rgb->blue >> 8; | |
303 | int maxv = wxMax3(r, g, b); | |
304 | int minv = wxMin3(r, g, b); | |
305 | int h = 0, s, v; | |
306 | v = maxv; | |
307 | if (maxv) s = (maxv - minv) * wxMAX_RGB / maxv; | |
308 | else s = 0; | |
309 | if (s == 0) h = 0; | |
310 | else | |
311 | { | |
312 | int rc, gc, bc, hex = 0; | |
313 | rc = (maxv - r) * wxMAX_RGB / (maxv - minv); | |
314 | gc = (maxv - g) * wxMAX_RGB / (maxv - minv); | |
315 | bc = (maxv - b) * wxMAX_RGB / (maxv - minv); | |
316 | if (r == maxv) { h = bc - gc, hex = 0; } | |
317 | else if (g == maxv) { h = rc - bc, hex = 2; } | |
318 | else if (b == maxv) { h = gc - rc, hex = 4; } | |
319 | h = hex * 60 + (h * 60 / wxMAX_RGB); | |
320 | if (h < 0) h += 360; | |
321 | } | |
322 | hsv->h = h; | |
323 | hsv->s = (s * wxMAX_SV) / wxMAX_RGB; | |
324 | hsv->v = (v * wxMAX_SV) / wxMAX_RGB; | |
325 | } | |
326 | ||
327 | void wxAllocNearestColor(Display *d,Colormap cmp,XColor *xc) | |
328 | { | |
329 | #if !wxUSE_NANOX | |
330 | int llp; | |
331 | ||
332 | int screen = DefaultScreen(d); | |
333 | int num_colors = DisplayCells(d,screen); | |
334 | ||
335 | XColor *color_defs = new XColor[num_colors]; | |
336 | for(llp = 0;llp < num_colors;llp++) color_defs[llp].pixel = llp; | |
337 | XQueryColors(d,cmp,color_defs,num_colors); | |
338 | ||
339 | wxHSV hsv_defs, hsv; | |
340 | wxXColorToHSV(&hsv,xc); | |
341 | ||
342 | int diff, min_diff = 0, pixel = 0; | |
343 | ||
344 | for(llp = 0;llp < num_colors;llp++) | |
345 | { | |
346 | wxXColorToHSV(&hsv_defs,&color_defs[llp]); | |
347 | diff = wxSIGN(wxH_WEIGHT * (hsv.h - hsv_defs.h)) + | |
348 | wxSIGN(wxS_WEIGHT * (hsv.s - hsv_defs.s)) + | |
349 | wxSIGN(wxV_WEIGHT * (hsv.v - hsv_defs.v)); | |
350 | if (llp == 0) min_diff = diff; | |
351 | if (min_diff > diff) { min_diff = diff; pixel = llp; } | |
352 | if (min_diff == 0) break; | |
353 | } | |
354 | ||
355 | xc -> red = color_defs[pixel].red; | |
356 | xc -> green = color_defs[pixel].green; | |
357 | xc -> blue = color_defs[pixel].blue; | |
358 | xc -> flags = DoRed | DoGreen | DoBlue; | |
359 | ||
360 | /* FIXME, TODO | |
361 | if (!XAllocColor(d,cmp,xc)) | |
362 | cout << "wxAllocNearestColor : Warning : Cannot find nearest color !\n"; | |
363 | */ | |
364 | ||
365 | delete[] color_defs; | |
366 | #endif | |
367 | } | |
368 | ||
369 | void wxAllocColor(Display *d,Colormap cmp,XColor *xc) | |
370 | { | |
371 | if (!XAllocColor(d,cmp,xc)) | |
372 | { | |
373 | // cout << "wxAllocColor : Warning : cannot allocate color, attempt find nearest !\n"; | |
374 | wxAllocNearestColor(d,cmp,xc); | |
375 | } | |
376 | } | |
377 | ||
378 | wxString wxGetXEventName(XEvent& event) | |
379 | { | |
380 | #if wxUSE_NANOX | |
381 | wxString str(wxT("(some event)")); | |
382 | return str; | |
383 | #else | |
384 | int type = event.xany.type; | |
385 | static char* event_name[] = { | |
386 | wxMOTIF_STR(""), wxMOTIF_STR("unknown(-)"), // 0-1 | |
387 | wxMOTIF_STR("KeyPress"), wxMOTIF_STR("KeyRelease"), wxMOTIF_STR("ButtonPress"), wxMOTIF_STR("ButtonRelease"), // 2-5 | |
388 | wxMOTIF_STR("MotionNotify"), wxMOTIF_STR("EnterNotify"), wxMOTIF_STR("LeaveNotify"), wxMOTIF_STR("FocusIn"), // 6-9 | |
389 | wxMOTIF_STR("FocusOut"), wxMOTIF_STR("KeymapNotify"), wxMOTIF_STR("Expose"), wxMOTIF_STR("GraphicsExpose"), // 10-13 | |
390 | wxMOTIF_STR("NoExpose"), wxMOTIF_STR("VisibilityNotify"), wxMOTIF_STR("CreateNotify"), // 14-16 | |
391 | wxMOTIF_STR("DestroyNotify"), wxMOTIF_STR("UnmapNotify"), wxMOTIF_STR("MapNotify"), wxMOTIF_STR("MapRequest"),// 17-20 | |
392 | wxMOTIF_STR("ReparentNotify"), wxMOTIF_STR("ConfigureNotify"), wxMOTIF_STR("ConfigureRequest"), // 21-23 | |
393 | wxMOTIF_STR("GravityNotify"), wxMOTIF_STR("ResizeRequest"), wxMOTIF_STR("CirculateNotify"), // 24-26 | |
394 | wxMOTIF_STR("CirculateRequest"), wxMOTIF_STR("PropertyNotify"), wxMOTIF_STR("SelectionClear"), // 27-29 | |
395 | wxMOTIF_STR("SelectionRequest"), wxMOTIF_STR("SelectionNotify"), wxMOTIF_STR("ColormapNotify"), // 30-32 | |
396 | wxMOTIF_STR("ClientMessage"), wxMOTIF_STR("MappingNotify"), // 33-34 | |
397 | wxMOTIF_STR("unknown(+)")}; // 35 | |
398 | type = wxMin(35, type); type = wxMax(1, type); | |
399 | wxString str(event_name[type]); | |
400 | return str; | |
401 | #endif | |
402 | } | |
403 | ||
404 | // ---------------------------------------------------------------------------- | |
405 | // accelerators | |
406 | // ---------------------------------------------------------------------------- | |
407 | ||
408 | // Find the letter corresponding to the mnemonic, for Motif | |
409 | char wxFindMnemonic (const char *s) | |
410 | { | |
411 | char mnem = 0; | |
412 | int len = strlen (s); | |
413 | int i; | |
414 | ||
415 | for (i = 0; i < len; i++) | |
416 | { | |
417 | if (s[i] == '&') | |
418 | { | |
419 | // Carefully handle && | |
420 | if ((i + 1) <= len && s[i + 1] == '&') | |
421 | i++; | |
422 | else | |
423 | { | |
424 | mnem = s[i + 1]; | |
425 | break; | |
426 | } | |
427 | } | |
428 | } | |
429 | return mnem; | |
430 | } | |
431 | ||
432 | char* wxFindAccelerator( const char *s ) | |
433 | { | |
434 | #if 1 | |
435 | wxUnusedVar(s); | |
436 | // VZ: this function returns incorrect keysym which completely breaks kbd | |
437 | // handling | |
438 | return NULL; | |
439 | #else | |
440 | // The accelerator text is after the \t char. | |
441 | s = strchr( s, '\t' ); | |
442 | ||
443 | if( !s ) return NULL; | |
444 | ||
445 | /* | |
446 | Now we need to format it as X standard: | |
447 | ||
448 | input output | |
449 | ||
450 | F7 --> <Key>F7 | |
451 | Ctrl+N --> Ctrl<Key>N | |
452 | Alt+k --> Meta<Key>k | |
453 | Ctrl+Shift+A --> Ctrl Shift<Key>A | |
454 | ||
455 | and handle Ctrl-N & similia | |
456 | */ | |
457 | ||
458 | static char buf[256]; | |
459 | ||
460 | buf[0] = '\0'; | |
461 | wxString tmp = s + 1; // skip TAB | |
462 | size_t index = 0; | |
463 | ||
464 | while( index < tmp.length() ) | |
465 | { | |
466 | size_t plus = tmp.find( '+', index ); | |
467 | size_t minus = tmp.find( '-', index ); | |
468 | ||
469 | // neither '+' nor '-', add <Key> | |
470 | if( plus == wxString::npos && minus == wxString::npos ) | |
471 | { | |
472 | strcat( buf, "<Key>" ); | |
473 | strcat( buf, tmp.c_str() + index ); | |
474 | ||
475 | return buf; | |
476 | } | |
477 | ||
478 | // OK: npos is big and positive | |
479 | size_t sep = wxMin( plus, minus ); | |
480 | wxString mod = tmp.substr( index, sep - index ); | |
481 | ||
482 | // Ctrl -> Ctrl | |
483 | // Shift -> Shift | |
484 | // Alt -> Meta | |
485 | if( mod == "Alt" ) | |
486 | mod = "Meta"; | |
487 | ||
488 | if( buf[0] ) | |
489 | strcat( buf, " " ); | |
490 | ||
491 | strcat( buf, mod.c_str() ); | |
492 | ||
493 | index = sep + 1; | |
494 | } | |
495 | ||
496 | return NULL; | |
497 | #endif | |
498 | } | |
499 | ||
500 | XmString wxFindAcceleratorText (const char *s) | |
501 | { | |
502 | #if 1 | |
503 | wxUnusedVar(s); | |
504 | // VZ: this function returns incorrect keysym which completely breaks kbd | |
505 | // handling | |
506 | return NULL; | |
507 | #else | |
508 | // The accelerator text is after the \t char. | |
509 | s = strchr( s, '\t' ); | |
510 | ||
511 | if( !s ) return NULL; | |
512 | ||
513 | return wxStringToXmString( s + 1 ); // skip TAB! | |
514 | #endif | |
515 | } | |
516 | ||
517 | // Change a widget's foreground and background colours. | |
518 | void wxDoChangeForegroundColour(WXWidget widget, wxColour& foregroundColour) | |
519 | { | |
520 | if (!foregroundColour.IsOk()) | |
521 | return; | |
522 | ||
523 | // When should we specify the foreground, if it's calculated | |
524 | // by wxComputeColours? | |
525 | // Solution: say we start with the default (computed) foreground colour. | |
526 | // If we call SetForegroundColour explicitly for a control or window, | |
527 | // then the foreground is changed. | |
528 | // Therefore SetBackgroundColour computes the foreground colour, and | |
529 | // SetForegroundColour changes the foreground colour. The ordering is | |
530 | // important. | |
531 | ||
532 | XtVaSetValues ((Widget) widget, | |
533 | XmNforeground, foregroundColour.AllocColour(XtDisplay((Widget) widget)), | |
534 | NULL); | |
535 | } | |
536 | ||
537 | void wxDoChangeBackgroundColour(WXWidget widget, const wxColour& backgroundColour, bool changeArmColour) | |
538 | { | |
539 | if (!backgroundColour.IsOk()) | |
540 | return; | |
541 | ||
542 | wxComputeColours (XtDisplay((Widget) widget), & backgroundColour, | |
543 | NULL); | |
544 | ||
545 | XtVaSetValues ((Widget) widget, | |
546 | XmNbackground, g_itemColors[wxBACK_INDEX].pixel, | |
547 | XmNtopShadowColor, g_itemColors[wxTOPS_INDEX].pixel, | |
548 | XmNbottomShadowColor, g_itemColors[wxBOTS_INDEX].pixel, | |
549 | XmNforeground, g_itemColors[wxFORE_INDEX].pixel, | |
550 | NULL); | |
551 | ||
552 | if (changeArmColour) | |
553 | XtVaSetValues ((Widget) widget, | |
554 | XmNarmColor, g_itemColors[wxSELE_INDEX].pixel, | |
555 | NULL); | |
556 | } | |
557 | ||
558 | extern void wxDoChangeFont(WXWidget widget, const wxFont& font) | |
559 | { | |
560 | // Lesstif 0.87 hangs here, but 0.93 does not; MBN: sometimes it does | |
561 | #if !wxCHECK_LESSTIF() // || wxCHECK_LESSTIF_VERSION( 0, 93 ) | |
562 | Widget w = (Widget)widget; | |
563 | XtVaSetValues( w, | |
564 | wxFont::GetFontTag(), font.GetFontTypeC( XtDisplay(w) ), | |
565 | NULL ); | |
566 | #else | |
567 | wxUnusedVar(widget); | |
568 | wxUnusedVar(font); | |
569 | #endif | |
570 | ||
571 | } | |
572 | ||
573 | wxString wxXmStringToString( const XmString& xmString ) | |
574 | { | |
575 | char *txt; | |
576 | if( XmStringGetLtoR( xmString, XmSTRING_DEFAULT_CHARSET, &txt ) ) | |
577 | { | |
578 | wxString str(txt); | |
579 | XtFree (txt); | |
580 | return str; | |
581 | } | |
582 | ||
583 | return wxEmptyString; | |
584 | } | |
585 | ||
586 | XmString wxStringToXmString( const char* str ) | |
587 | { | |
588 | return XmStringCreateLtoR((char *)str, XmSTRING_DEFAULT_CHARSET); | |
589 | } | |
590 | ||
591 | // ---------------------------------------------------------------------------- | |
592 | // wxBitmap utility functions | |
593 | // ---------------------------------------------------------------------------- | |
594 | ||
595 | // Creates a bitmap with transparent areas drawn in | |
596 | // the given colour. | |
597 | wxBitmap wxCreateMaskedBitmap(const wxBitmap& bitmap, const wxColour& colour) | |
598 | { | |
599 | wxBitmap newBitmap(bitmap.GetWidth(), | |
600 | bitmap.GetHeight(), | |
601 | bitmap.GetDepth()); | |
602 | wxMemoryDC destDC; | |
603 | wxMemoryDC srcDC; | |
604 | ||
605 | srcDC.SelectObjectAsSource(bitmap); | |
606 | destDC.SelectObject(newBitmap); | |
607 | ||
608 | wxBrush brush(colour, wxSOLID); | |
609 | destDC.SetBackground(brush); | |
610 | destDC.Clear(); | |
611 | destDC.Blit(0, 0, bitmap.GetWidth(), bitmap.GetHeight(), | |
612 | &srcDC, 0, 0, wxCOPY, true); | |
613 | ||
614 | return newBitmap; | |
615 | } | |
616 | ||
617 | // ---------------------------------------------------------------------------- | |
618 | // Miscellaneous functions | |
619 | // ---------------------------------------------------------------------------- | |
620 | ||
621 | WXWidget wxCreateBorderWidget( WXWidget parent, long style ) | |
622 | { | |
623 | Widget borderWidget = (Widget)NULL, parentWidget = (Widget)parent; | |
624 | ||
625 | if (style & wxSIMPLE_BORDER) | |
626 | { | |
627 | borderWidget = XtVaCreateManagedWidget | |
628 | ( | |
629 | "simpleBorder", | |
630 | xmFrameWidgetClass, parentWidget, | |
631 | XmNshadowType, XmSHADOW_ETCHED_IN, | |
632 | XmNshadowThickness, 1, | |
633 | NULL | |
634 | ); | |
635 | } | |
636 | else if ((style & wxSUNKEN_BORDER) || (style & wxBORDER_THEME)) | |
637 | { | |
638 | borderWidget = XtVaCreateManagedWidget | |
639 | ( | |
640 | "sunkenBorder", | |
641 | xmFrameWidgetClass, parentWidget, | |
642 | XmNshadowType, XmSHADOW_IN, | |
643 | NULL | |
644 | ); | |
645 | } | |
646 | else if (style & wxRAISED_BORDER) | |
647 | { | |
648 | borderWidget = XtVaCreateManagedWidget | |
649 | ( | |
650 | "raisedBorder", | |
651 | xmFrameWidgetClass, parentWidget, | |
652 | XmNshadowType, XmSHADOW_OUT, | |
653 | NULL | |
654 | ); | |
655 | } | |
656 | ||
657 | return borderWidget; | |
658 | } |