|
398
|
1 /* Tabs Widget for XEmacs.
|
|
|
2 Copyright (C) 1999 Edward A. Falk
|
|
442
|
3
|
|
398
|
4 This file is part of XEmacs.
|
|
442
|
5
|
|
398
|
6 XEmacs is free software; you can redistribute it and/or modify it
|
|
|
7 under the terms of the GNU General Public License as published by the
|
|
|
8 Free Software Foundation; either version 2, or (at your option) any
|
|
|
9 later version.
|
|
442
|
10
|
|
398
|
11 XEmacs is distributed in the hope that it will be useful, but WITHOUT
|
|
|
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
14 for more details.
|
|
442
|
15
|
|
398
|
16 You should have received a copy of the GNU General Public License
|
|
|
17 along with XEmacs; see the file COPYING. If not, write to
|
|
|
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
19 Boston, MA 02111-1307, USA. */
|
|
442
|
20
|
|
398
|
21 /* Synched up with: Gcs.c 1.7 */
|
|
442
|
22
|
|
398
|
23 /* #### This code is duplicated many times within lwlib and XEmacs. It
|
|
|
24 should be modularised. */
|
|
|
25
|
|
|
26 /*
|
|
|
27 * Gcs.c - Utility functions to allocate GCs.
|
|
|
28 *
|
|
|
29 * Author: Edward A. Falk
|
|
|
30 * falk@falconer.vip.best.com
|
|
|
31 *
|
|
|
32 * Date: Sept 29, 1998
|
|
|
33 */
|
|
|
34
|
|
|
35 /* Functions:
|
|
|
36 *
|
|
|
37 * GC AllocFgGC(w, fg, font)
|
|
|
38 * Return a GC with foreground set as specified.
|
|
|
39 * If font is None, then the returned GC is allocated with font specified
|
|
|
40 * as a "don't care" value.
|
|
|
41 *
|
|
|
42 * GC
|
|
|
43 * AllocBackgroundGC(w, font)
|
|
|
44 * Return a GC with the foreground set to the widget's background color.
|
|
|
45 *
|
|
|
46 * GC
|
|
|
47 * AllocGreyGC(w, fg, font, contrast, be_nice_to_cmap)
|
|
|
48 * Widget w ;
|
|
|
49 * Pixel fg ;
|
|
|
50 * Font font ;
|
|
|
51 * int contrast ;
|
|
|
52 * int be_nice_to_cmap ;
|
|
|
53 *
|
|
|
54 * Return a GC suitable for rendering a widget in its "inactive" color.
|
|
|
55 * Normally returns a GC with a color somewhere between the widget's
|
|
|
56 * background color and the specified foreground. If font is None, then
|
|
|
57 * the returned GC is allocated with font specified as "don't care".
|
|
|
58 * If be_nice_to_cmap is True, the returned GC is created using a 50%
|
|
|
59 * dither instead of a new color.
|
|
|
60 *
|
|
|
61 *
|
|
|
62 * GC
|
|
|
63 * AllocShadeGC(w, fg, bg, font, contrast, be_nice_to_cmap)
|
|
|
64 * Widget w ;
|
|
|
65 * Pixel fg, bg ;
|
|
|
66 * Font font ;
|
|
|
67 * int contrast ;
|
|
|
68 * int be_nice_to_cmap ;
|
|
|
69 *
|
|
|
70 * Return a GC suitable for rendering in a shade somewhere between
|
|
|
71 * bg and fg, as determined by contrast (0 = bg, 100 = fg)
|
|
|
72 * If font is None, then the returned GC is allocated with
|
|
|
73 * font specified as "don't care". If be_nice_to_cmap
|
|
|
74 * is True, the returned GC is created using a 50% dither
|
|
|
75 * instead of a new color.
|
|
|
76 *
|
|
|
77 *
|
|
|
78 * GC
|
|
|
79 * AllocTopShadowGC(w, contrast, be_nice_to_cmap)
|
|
|
80 * Return a GC suitable for rendering the "top shadow" decorations of
|
|
|
81 * a widget. Returns a GC with foreground computed from widget's
|
|
|
82 * background color and contrast. If be_nice_to_cmap is True, the
|
|
|
83 * returned GC will use a foreground color of white. If widget depth
|
|
|
84 * is 1, this function will use a foreground color of black.
|
|
|
85 *
|
|
|
86 * GC
|
|
|
87 * AllocBotShadowGC(w, contrast, be_nice_to_cmap)
|
|
|
88 * Return a GC suitable for rendering the "bottom shadow" decorations
|
|
|
89 * of a widget. Returns a GC with foreground computed from widget's
|
|
|
90 * background color and contrast. If be_nice_to_cmap is True, the
|
|
|
91 * returned GC will use a foreground color of black.
|
|
|
92 *
|
|
|
93 * GC
|
|
|
94 * AllocArmGC(w, contrast, be_nice_to_cmap)
|
|
|
95 * Return a GC suitable for rendering the "armed" decorations of a
|
|
|
96 * widget. This GC would typically be used to fill in the widget's
|
|
|
97 * background. Returns a GC with foreground computed from widget's
|
|
|
98 * background color and contrast. If be_nice_to_cmap is True, the
|
|
|
99 * returned GC will use a foreground color of black and a 50% dither.
|
|
|
100 *
|
|
|
101 *
|
|
|
102 * void
|
|
|
103 * Draw3dBox(w, x,y,wid,hgt,s, topgc, botgc)
|
|
|
104 * Utility function. Draws a raised shadow box with outside dimensions
|
|
|
105 * as specified by x,y,wid,hgt and shadow width specified by s.
|
|
|
106 * A lowered shadow box may be generated by swapping topgc and botgc.
|
|
|
107 *
|
|
|
108 */
|
|
|
109
|
|
|
110 #include <config.h>
|
|
|
111 #include <stdio.h>
|
|
|
112
|
|
|
113 #include <X11/Xlib.h>
|
|
|
114 #include <X11/IntrinsicP.h>
|
|
|
115 #include <X11/StringDefs.h>
|
|
|
116 #include "../src/xmu.h"
|
|
|
117 #include "xlwgcs.h"
|
|
|
118
|
|
|
119 /* Color & GC allocation.
|
|
|
120 *
|
|
|
121 * Frame widgets use the following graphics contexts:
|
|
|
122 *
|
|
|
123 * Foreground tab label text drawn this way
|
|
|
124 * Insensitive Fg foreground color greyed out.
|
|
|
125 * Background frame background color
|
|
|
126 * Top shadow upper-left highlight around widget
|
|
|
127 * Bottom shadow lower-right highlight around widget
|
|
|
128 * Arm shadow button pressed and ready to be released
|
|
|
129 *
|
|
|
130 *
|
|
|
131 * GC's are defined as follows, depending on attributes and
|
|
|
132 * window depth:
|
|
|
133 *
|
|
|
134 * Monochrome:
|
|
|
135 * Foreground = foreground color attribute or BlackPixel()
|
|
|
136 * Grey = Foreground color + 50% dither
|
|
|
137 * Background = background color attribute or WhitePixel()
|
|
|
138 * top shadow = foreground
|
|
|
139 * bottom shadow = foreground
|
|
|
140 * arm shadow = (what?)
|
|
|
141 *
|
|
|
142 * Color, beNiceToColormap=true:
|
|
|
143 * Foreground = foreground color attribute or BlackPixel()
|
|
|
144 * Grey = Foreground color + 50% dither
|
|
|
145 * Background = background color attribute or WhitePixel()
|
|
|
146 * top shadow = white
|
|
|
147 * bottom shadow = black
|
|
|
148 * arm shadow = (what?)
|
|
|
149 *
|
|
|
150 * Color, beNiceToColormap=false:
|
|
|
151 * Foreground = foreground color attribute or BlackPixel()
|
|
|
152 * Grey = (foreground color + background color)/2
|
|
|
153 * Background = background color attribute or WhitePixel()
|
|
|
154 * top shadow = background * 1.2
|
|
|
155 * bottom shadow = background * .6
|
|
|
156 * arm shadow = background * .8
|
|
|
157 *
|
|
|
158 * Special cases:
|
|
|
159 * If background is white, ??
|
|
|
160 * if background is black, ??
|
|
|
161 *
|
|
|
162 *
|
|
|
163 * If the widget's background is solid white or solid black,
|
|
|
164 * this code just picks some numbers. (The choice is designed
|
|
442
|
165 * to be compatible with ThreeD interface.)
|
|
398
|
166 */
|
|
|
167
|
|
|
168
|
|
|
169
|
|
|
170 #if XtSpecificationRelease < 5
|
|
|
171
|
|
458
|
172 static GC XtAllocateGC(Widget, int, unsigned long, XGCValues *,
|
|
|
173 unsigned long, unsigned long) ;
|
|
398
|
174
|
|
|
175 #endif
|
|
|
176
|
|
|
177
|
|
|
178 #if NeedFunctionPrototypes
|
|
|
179 static Pixmap getDitherPixmap(Widget, int contrast) ;
|
|
|
180 #else
|
|
|
181 static Pixmap getDitherPixmap() ;
|
|
|
182 #endif
|
|
|
183
|
|
|
184 /* return a GC with the specified foreground and optional font */
|
|
|
185
|
|
|
186 GC
|
|
|
187 AllocFgGC(Widget w, Pixel fg, Font font)
|
|
|
188 {
|
|
|
189 XGCValues values ;
|
|
458
|
190 unsigned long vmask, dcmask ;
|
|
398
|
191
|
|
|
192 values.foreground = fg ;
|
|
|
193 values.font = font ;
|
|
|
194
|
|
|
195 if( font != None ) {
|
|
|
196 vmask = GCForeground|GCFont ;
|
|
|
197 dcmask = GCSubwindowMode|GCDashOffset|
|
|
|
198 GCDashList|GCArcMode|GCBackground|GCGraphicsExposures ;
|
|
|
199 } else {
|
|
|
200 vmask = GCForeground ;
|
|
|
201 dcmask = GCFont|GCSubwindowMode|GCDashOffset|
|
|
|
202 GCDashList|GCArcMode|GCBackground|GCGraphicsExposures ;
|
|
|
203 }
|
|
|
204
|
|
|
205 return XtAllocateGC(w, w->core.depth, vmask, &values, 0L, dcmask) ;
|
|
|
206 }
|
|
|
207
|
|
|
208
|
|
|
209 /* return gc with widget background color as the foreground */
|
|
|
210
|
|
|
211 GC
|
|
|
212 AllocBackgroundGC(Widget w, Font font)
|
|
|
213 {
|
|
|
214 return AllocFgGC(w, w->core.background_pixel, font) ;
|
|
|
215 }
|
|
|
216
|
|
|
217
|
|
|
218 /* Allocate an "inactive" GC. Color is grey (possibly via
|
|
|
219 * dither pattern).
|
|
|
220 */
|
|
|
221
|
|
|
222 GC
|
|
|
223 AllocGreyGC(Widget w, Pixel fg, Font font, int contrast, Bool be_nice_to_cmap)
|
|
|
224 {
|
|
|
225 return AllocShadeGC(w, fg, w->core.background_pixel,
|
|
|
226 font, contrast, be_nice_to_cmap) ;
|
|
|
227 }
|
|
|
228
|
|
|
229
|
|
|
230 /* Allocate a GC somewhere between two colors. */
|
|
|
231
|
|
|
232 GC
|
|
|
233 AllocShadeGC(Widget w, Pixel fg, Pixel bg, Font font,
|
|
2286
|
234 int contrast,
|
|
|
235 #ifdef HAVE_XMU
|
|
|
236 Bool be_nice_to_cmap
|
|
|
237 #else
|
|
|
238 Bool UNUSED (be_nice_to_cmap)
|
|
|
239 #endif
|
|
|
240 )
|
|
398
|
241 {
|
|
|
242 XGCValues values ;
|
|
458
|
243 unsigned long vmask, dcmask ;
|
|
398
|
244
|
|
|
245 values.foreground = fg ;
|
|
|
246 values.background = bg ;
|
|
|
247 values.font = font ;
|
|
|
248
|
|
|
249 if( font != None ) {
|
|
|
250 vmask = GCForeground|GCFont ;
|
|
|
251 dcmask = GCSubwindowMode|GCDashOffset|
|
|
|
252 GCDashList|GCArcMode|GCGraphicsExposures ;
|
|
|
253 } else {
|
|
|
254 vmask = GCForeground;
|
|
|
255 dcmask = GCFont|GCSubwindowMode|GCDashOffset|
|
|
|
256 GCDashList|GCArcMode|GCGraphicsExposures ;
|
|
|
257 }
|
|
|
258 #ifdef HAVE_XMU
|
|
|
259 if( be_nice_to_cmap || w->core.depth == 1)
|
|
|
260 {
|
|
|
261 if( contrast <= 5 )
|
|
|
262 values.foreground = bg ;
|
|
|
263 else if( contrast >= 95 )
|
|
|
264 values.foreground = fg ;
|
|
|
265 else {
|
|
|
266 vmask |= GCBackground|GCStipple|GCFillStyle ;
|
|
|
267 values.fill_style = FillOpaqueStippled ;
|
|
|
268 values.stipple = getDitherPixmap(w, contrast) ;
|
|
|
269 }
|
|
|
270
|
|
|
271 return XtAllocateGC(w, w->core.depth, vmask, &values, 0L, dcmask) ;
|
|
|
272 }
|
|
|
273 else
|
|
|
274 #endif
|
|
|
275 {
|
|
|
276 dcmask |= GCBackground ;
|
|
|
277 values.foreground = AllocGreyPixel(w, fg, bg, contrast) ;
|
|
|
278 return XtAllocateGC(w, w->core.depth, vmask, &values, 0L, dcmask) ;
|
|
|
279 }
|
|
|
280 }
|
|
|
281
|
|
|
282 /* return top-shadow gc. */
|
|
|
283
|
|
|
284 GC
|
|
|
285 AllocTopShadowGC(Widget w, int contrast, Bool be_nice_to_cmap)
|
|
|
286 {
|
|
|
287 Screen *scr = XtScreen (w);
|
|
|
288 XGCValues values ;
|
|
|
289
|
|
|
290 if( w->core.depth == 1 )
|
|
|
291 values.foreground = BlackPixelOfScreen(scr) ;
|
|
|
292 else if( be_nice_to_cmap )
|
|
|
293 values.foreground = WhitePixelOfScreen(scr) ;
|
|
|
294 else
|
|
|
295 values.foreground = AllocShadowPixel(w, 100+contrast) ;
|
|
|
296
|
|
|
297 return XtAllocateGC(w, w->core.depth,
|
|
|
298 GCForeground, &values,
|
|
|
299 0L,
|
|
|
300 GCBackground|GCFont|GCSubwindowMode|GCGraphicsExposures|
|
|
|
301 GCDashOffset|GCDashList|GCArcMode) ;
|
|
|
302 }
|
|
|
303
|
|
|
304 /* return bottom-shadow gc. */
|
|
|
305
|
|
|
306 GC
|
|
|
307 AllocBotShadowGC(Widget w, int contrast, Bool be_nice_to_cmap)
|
|
|
308 {
|
|
|
309 Screen *scr = XtScreen (w);
|
|
|
310 XGCValues values ;
|
|
|
311
|
|
|
312 if( w->core.depth == 1 || be_nice_to_cmap )
|
|
|
313 values.foreground = BlackPixelOfScreen(scr) ;
|
|
|
314 else
|
|
|
315 values.foreground = AllocShadowPixel(w, 100-contrast) ;
|
|
|
316
|
|
|
317 return XtAllocateGC(w, w->core.depth,
|
|
|
318 GCForeground, &values,
|
|
|
319 0L,
|
|
|
320 GCBackground|GCFont|GCSubwindowMode|GCGraphicsExposures|
|
|
|
321 GCDashOffset|GCDashList|GCArcMode) ;
|
|
|
322 }
|
|
|
323
|
|
|
324 /* return arm-shadow gc. */
|
|
|
325
|
|
|
326 GC
|
|
2286
|
327 AllocArmGC(Widget w, int contrast,
|
|
|
328 #ifdef HAVE_XMU
|
|
|
329 Bool be_nice_to_cmap
|
|
|
330 #else
|
|
|
331 Bool UNUSED (be_nice_to_cmap)
|
|
|
332 #endif
|
|
|
333 )
|
|
398
|
334 {
|
|
|
335 Screen *scr = XtScreen (w);
|
|
|
336 XGCValues values ;
|
|
|
337
|
|
|
338 /* Not clear exactly what we should do here. Take a look at
|
|
|
339 * Xaw3d to see what they do.
|
|
|
340 */
|
|
|
341 #ifdef HAVE_XMU
|
|
|
342 if( w->core.depth == 1 || be_nice_to_cmap )
|
|
|
343 {
|
|
|
344 values.background = w->core.background_pixel ;
|
|
|
345 if( values.background == BlackPixelOfScreen(scr) )
|
|
|
346 values.foreground = WhitePixelOfScreen(scr) ;
|
|
|
347 else
|
|
|
348 values.foreground = BlackPixelOfScreen(scr) ;
|
|
|
349 values.fill_style = FillStippled ;
|
|
|
350 values.stipple = XmuCreateStippledPixmap(XtScreen(w), 1L, 0L, 1) ;
|
|
|
351
|
|
|
352 return XtAllocateGC(w, w->core.depth,
|
|
|
353 GCForeground|GCBackground|GCStipple|GCFillStyle,
|
|
|
354 &values, 0L,
|
|
|
355 GCFont|GCSubwindowMode|GCGraphicsExposures|
|
|
|
356 GCDashOffset|GCDashList|GCArcMode) ;
|
|
|
357 }
|
|
442
|
358 else
|
|
398
|
359 #endif
|
|
|
360 {
|
|
|
361 values.foreground = AllocShadowPixel(w, 100-contrast) ;
|
|
|
362 return XtAllocateGC(w, w->core.depth,
|
|
|
363 GCForeground, &values,
|
|
|
364 0L,
|
|
|
365 GCBackground|GCFont|GCSubwindowMode|GCGraphicsExposures|
|
|
|
366 GCDashOffset|GCDashList|GCArcMode) ;
|
|
|
367 }
|
|
|
368 }
|
|
|
369
|
|
|
370
|
|
|
371 Pixel
|
|
|
372 AllocShadowPixel(Widget w, int scale)
|
|
|
373 {
|
|
|
374 XColor get_c, set_c ;
|
|
|
375 Display *dpy = XtDisplay(w) ;
|
|
|
376 Screen *scr = XtScreen(w) ;
|
|
|
377 Colormap cmap ;
|
|
|
378 Pixel maxColor ;
|
|
|
379
|
|
|
380 cmap = w->core.colormap ;
|
|
|
381
|
|
|
382 get_c.pixel = w->core.background_pixel ;
|
|
|
383 if( get_c.pixel == WhitePixelOfScreen(scr) ||
|
|
|
384 get_c.pixel == BlackPixelOfScreen(scr) )
|
|
|
385 {
|
|
|
386 /* what we *ought* to do is choose gray75 as the base color,
|
|
|
387 * or perhaps gray83. Instead, we choose colors that are
|
|
|
388 * the same as ThreeD would choose.
|
|
|
389 */
|
|
|
390 if( scale > 100 ) scale = 200 - scale ;
|
|
|
391 set_c.red = set_c.green = set_c.blue = 65535*scale/100 ;
|
|
|
392 }
|
|
|
393 else
|
|
|
394 {
|
|
|
395 XQueryColor(dpy, cmap, &get_c) ;
|
|
|
396 /* adjust scale so that brightest component does not
|
|
|
397 * exceed 65535; otherwise hue would change.
|
|
|
398 */
|
|
|
399 if( scale > 100 ) {
|
|
|
400 maxColor = Max(get_c.red, Max(get_c.green, get_c.blue)) ;
|
|
|
401 if( scale*maxColor > 65535*100 )
|
|
|
402 scale = 65535*100/maxColor ;
|
|
|
403 }
|
|
|
404 set_c.red = scale * get_c.red / 100 ;
|
|
|
405 set_c.green = scale * get_c.green / 100 ;
|
|
|
406 set_c.blue = scale * get_c.blue / 100 ;
|
|
|
407 }
|
|
|
408 set_c.flags = DoRed | DoGreen | DoBlue ;
|
|
|
409 if( XAllocColor(dpy, cmap, &set_c) )
|
|
|
410 return set_c.pixel ;
|
|
|
411 else if( scale > 100 )
|
|
|
412 return WhitePixelOfScreen(scr) ;
|
|
|
413 else
|
|
|
414 return BlackPixelOfScreen(scr) ;
|
|
|
415 }
|
|
|
416
|
|
|
417
|
|
|
418 /* Allocate a pixel partway between foreground and background */
|
|
|
419
|
|
|
420
|
|
|
421 Pixel
|
|
|
422 AllocGreyPixel(Widget w, Pixel fg, Pixel bg, int scale)
|
|
|
423 {
|
|
|
424 XColor get_cf, get_cb ;
|
|
|
425 Display *dpy = XtDisplay(w) ;
|
|
|
426 Colormap cmap ;
|
|
|
427
|
|
|
428 cmap = w->core.colormap ;
|
|
|
429
|
|
|
430 get_cf.pixel = fg ;
|
|
|
431 get_cb.pixel = bg ;
|
|
|
432
|
|
|
433 XQueryColor(dpy, cmap, &get_cf) ;
|
|
|
434 XQueryColor(dpy, cmap, &get_cb) ;
|
|
|
435
|
|
|
436 return AllocGreyPixelC(w, &get_cf, &get_cb, scale) ;
|
|
|
437 }
|
|
|
438
|
|
|
439
|
|
|
440
|
|
|
441 /* Allocate a pixel partway between foreground and background */
|
|
|
442
|
|
|
443
|
|
|
444 Pixel
|
|
|
445 AllocGreyPixelC(Widget w, XColor *fg, XColor *bg, int scale)
|
|
|
446 {
|
|
|
447 XColor set_c ;
|
|
|
448 Display *dpy = XtDisplay(w) ;
|
|
|
449 int r,g,b ;
|
|
|
450 Colormap cmap = w->core.colormap ;
|
|
|
451
|
|
|
452 r = (fg->red * scale + bg->red * (100-scale)) / 100 ;
|
|
|
453 g = (fg->green * scale + bg->green * (100-scale)) / 100 ;
|
|
|
454 b = (fg->blue * scale + bg->blue * (100-scale)) / 100 ;
|
|
|
455
|
|
|
456 if( scale > 100 || scale < 0 ) /* look out for overflow */
|
|
|
457 {
|
|
|
458 int minc, maxc ;
|
|
|
459 maxc = Max(r, Max(g,b)) ;
|
|
|
460 minc = Min(r, Min(g,b)) ;
|
|
|
461 if( maxc > 65535 )
|
|
|
462 {
|
|
|
463 maxc /= 16 ;
|
|
|
464 r = r*(65535/16) / maxc ;
|
|
|
465 g = g*(65535/16) / maxc ;
|
|
|
466 b = b*(65535/16) / maxc ;
|
|
|
467 }
|
|
|
468 if( minc < 0 )
|
|
|
469 {
|
|
|
470 r = Max(r,0) ;
|
|
|
471 g = Max(g,0) ;
|
|
|
472 b = Max(b,0) ;
|
|
|
473 }
|
|
|
474 }
|
|
|
475
|
|
|
476 set_c.red = r ; set_c.green = g ; set_c.blue = b ;
|
|
|
477 set_c.flags = DoRed | DoGreen | DoBlue ;
|
|
|
478 (void)XAllocColor(dpy, cmap, &set_c) ;
|
|
|
479 return set_c.pixel ;
|
|
|
480 }
|
|
|
481
|
|
|
482
|
|
|
483
|
|
|
484
|
|
|
485
|
|
|
486 /* draw a 3-d box */
|
|
|
487
|
|
|
488 void
|
|
|
489 Draw3dBox(Widget w, int x, int y, int wid, int hgt, int s, GC topgc, GC botgc)
|
|
|
490 {
|
|
|
491 Display *dpy = XtDisplay(w) ;
|
|
|
492 Window win = XtWindow(w) ;
|
|
|
493
|
|
|
494 if( s == 0 ) return ;
|
|
|
495
|
|
|
496 if( s == 1 ) {
|
|
|
497 XDrawLine(dpy,win,botgc, x,y+hgt-1, x+wid-1,y+hgt-1) ;
|
|
|
498 XDrawLine(dpy,win,botgc, x+wid-1,y, x+wid-1,y+hgt-1) ;
|
|
|
499 XDrawLine(dpy,win,topgc, x,y, x,y+hgt-1) ;
|
|
|
500 XDrawLine(dpy,win,topgc, x,y, x+wid-1,y) ;
|
|
|
501 }
|
|
|
502 else
|
|
|
503 {
|
|
|
504 XPoint pts[6] ;
|
|
|
505
|
|
|
506 /* bottom-right shadow */
|
|
|
507 pts[0].x = x ; pts[0].y = y + hgt ;
|
|
|
508 pts[1].x = s ; pts[1].y = -s ;
|
|
|
509 pts[2].x = wid-2*s ; pts[2].y = 0 ;
|
|
|
510 pts[3].x = 0 ; pts[3].y = -(hgt-2*s) ;
|
|
|
511 pts[4].x = s ; pts[4].y = -s ;
|
|
|
512 pts[5].x = 0 ; pts[5].y = hgt ;
|
|
|
513 XFillPolygon(dpy,win,botgc, pts,6, Nonconvex,CoordModePrevious) ;
|
|
|
514
|
|
|
515 /* top-left shadow */
|
|
|
516 pts[0].x = x ; pts[0].y = y ;
|
|
|
517 pts[1].x = wid ; pts[1].y = 0 ;
|
|
|
518 pts[2].x = -s ; pts[2].y = s ;
|
|
|
519 pts[3].x = -wid+2*s ; pts[3].y = 0 ;
|
|
|
520 pts[4].x = 0 ; pts[4].y = hgt-2*s ;
|
|
|
521 pts[5].x = -s ; pts[5].y = s ;
|
|
|
522 XFillPolygon(dpy,win,topgc, pts,6, Nonconvex,CoordModePrevious) ;
|
|
|
523 }
|
|
|
524 }
|
|
|
525
|
|
|
526 #if XtSpecificationRelease < 5
|
|
|
527
|
|
|
528 static GC
|
|
2286
|
529 XtAllocateGC(Widget w, int UNUSED (depth), unsigned long mask,
|
|
|
530 XGCValues *values, unsigned long UNUSED (dynamic),
|
|
|
531 unsigned long UNUSED (dontcare))
|
|
398
|
532 {
|
|
|
533 return XtGetGC(w, mask, values) ;
|
|
|
534 }
|
|
|
535 #endif
|
|
|
536
|
|
|
537
|
|
458
|
538 static unsigned char screen0[2] = {0,0} ;
|
|
|
539 static unsigned char screen25[2] = {0,0xaa} ;
|
|
|
540 static unsigned char screen75[2] = {0xaa,0xff} ;
|
|
|
541 static unsigned char screen100[2] = {0xff,0xff} ;
|
|
398
|
542
|
|
|
543 static Pixmap
|
|
|
544 getDitherPixmap(Widget w, int contrast)
|
|
|
545 {
|
|
|
546 Display *dpy = XtDisplay(w) ;
|
|
|
547 Window win = XtWindow(w) ;
|
|
|
548
|
|
|
549 if( contrast <= 5 )
|
|
|
550 return XCreateBitmapFromData(dpy,win, (char *)screen0, 2,2) ;
|
|
|
551 else if( contrast <= 37 )
|
|
|
552 return XCreateBitmapFromData(dpy,win, (char *)screen25, 2,2) ;
|
|
|
553 else if( contrast <= 62 )
|
|
|
554 return XmuCreateStippledPixmap(XtScreen(w), 1L, 0L, 1) ;
|
|
|
555 else if( contrast <= 95 )
|
|
|
556 return XCreateBitmapFromData(dpy,win, (char *)screen75, 2,2) ;
|
|
|
557 else
|
|
|
558 return XCreateBitmapFromData(dpy,win, (char *)screen100, 2,2) ;
|
|
|
559 }
|
