Mercurial > hg > xemacs-beta

comparison lwlib/xlwgcs.c @ 424:11054d720c21 r21-2-20

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Import from CVS: tag r21-2-20
author cvs
date Mon, 13 Aug 2007 11:26:11 +0200
parents 74fd4e045ea6
children abe6d1db359e
comparison
equal deleted inserted replaced
423:28d9c139be4c 424:11054d720c21
1 /* Tabs Widget for XEmacs.
2 Copyright (C) 1999 Edward A. Falk
3
4 This file is part of XEmacs.
5
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.
10
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.
15
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. */
20
21 /* Synched up with: Gcs.c 1.7 */
22
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
165 * to be compatibile with ThreeD interface.)
166 */
167
168
169
170 #if XtSpecificationRelease < 5
171
172 static GC XtAllocateGC(Widget, int, u_long, XGCValues *, u_long, u_long) ;
173
174 #endif
175
176
177 #if NeedFunctionPrototypes
178 static Pixmap getDitherPixmap(Widget, int contrast) ;
179 #else
180 static Pixmap getDitherPixmap() ;
181 #endif
182
183 /* return a GC with the specified foreground and optional font */
184
185 GC
186 AllocFgGC(Widget w, Pixel fg, Font font)
187 {
188 XGCValues values ;
189 u_long vmask, dcmask ;
190
191 values.foreground = fg ;
192 values.font = font ;
193
194 if( font != None ) {
195 vmask = GCForeground|GCFont ;
196 dcmask = GCSubwindowMode|GCDashOffset|
197 GCDashList|GCArcMode|GCBackground|GCGraphicsExposures ;
198 } else {
199 vmask = GCForeground ;
200 dcmask = GCFont|GCSubwindowMode|GCDashOffset|
201 GCDashList|GCArcMode|GCBackground|GCGraphicsExposures ;
202 }
203
204 return XtAllocateGC(w, w->core.depth, vmask, &values, 0L, dcmask) ;
205 }
206
207
208 /* return gc with widget background color as the foreground */
209
210 GC
211 AllocBackgroundGC(Widget w, Font font)
212 {
213 return AllocFgGC(w, w->core.background_pixel, font) ;
214 }
215
216
217 /* Allocate an "inactive" GC. Color is grey (possibly via
218 * dither pattern).
219 */
220
221 GC
222 AllocGreyGC(Widget w, Pixel fg, Font font, int contrast, Bool be_nice_to_cmap)
223 {
224 return AllocShadeGC(w, fg, w->core.background_pixel,
225 font, contrast, be_nice_to_cmap) ;
226 }
227
228
229 /* Allocate a GC somewhere between two colors. */
230
231 GC
232 AllocShadeGC(Widget w, Pixel fg, Pixel bg, Font font,
233 int contrast, Bool be_nice_to_cmap)
234 {
235 XGCValues values ;
236 u_long vmask, dcmask ;
237
238 values.foreground = fg ;
239 values.background = bg ;
240 values.font = font ;
241
242 if( font != None ) {
243 vmask = GCForeground|GCFont ;
244 dcmask = GCSubwindowMode|GCDashOffset|
245 GCDashList|GCArcMode|GCGraphicsExposures ;
246 } else {
247 vmask = GCForeground;
248 dcmask = GCFont|GCSubwindowMode|GCDashOffset|
249 GCDashList|GCArcMode|GCGraphicsExposures ;
250 }
251 #ifdef HAVE_XMU
252 if( be_nice_to_cmap || w->core.depth == 1)
253 {
254 if( contrast <= 5 )
255 values.foreground = bg ;
256 else if( contrast >= 95 )
257 values.foreground = fg ;
258 else {
259 vmask |= GCBackground|GCStipple|GCFillStyle ;
260 values.fill_style = FillOpaqueStippled ;
261 values.stipple = getDitherPixmap(w, contrast) ;
262 }
263
264 return XtAllocateGC(w, w->core.depth, vmask, &values, 0L, dcmask) ;
265 }
266 else
267 #endif
268 {
269 dcmask |= GCBackground ;
270 values.foreground = AllocGreyPixel(w, fg, bg, contrast) ;
271 return XtAllocateGC(w, w->core.depth, vmask, &values, 0L, dcmask) ;
272 }
273 }
274
275 /* return top-shadow gc. */
276
277 GC
278 AllocTopShadowGC(Widget w, int contrast, Bool be_nice_to_cmap)
279 {
280 Screen *scr = XtScreen (w);
281 XGCValues values ;
282
283 if( w->core.depth == 1 )
284 values.foreground = BlackPixelOfScreen(scr) ;
285 else if( be_nice_to_cmap )
286 values.foreground = WhitePixelOfScreen(scr) ;
287 else
288 values.foreground = AllocShadowPixel(w, 100+contrast) ;
289
290 return XtAllocateGC(w, w->core.depth,
291 GCForeground, &values,
292 0L,
293 GCBackground|GCFont|GCSubwindowMode|GCGraphicsExposures|
294 GCDashOffset|GCDashList|GCArcMode) ;
295 }
296
297 /* return bottom-shadow gc. */
298
299 GC
300 AllocBotShadowGC(Widget w, int contrast, Bool be_nice_to_cmap)
301 {
302 Screen *scr = XtScreen (w);
303 XGCValues values ;
304
305 if( w->core.depth == 1 || be_nice_to_cmap )
306 values.foreground = BlackPixelOfScreen(scr) ;
307 else
308 values.foreground = AllocShadowPixel(w, 100-contrast) ;
309
310 return XtAllocateGC(w, w->core.depth,
311 GCForeground, &values,
312 0L,
313 GCBackground|GCFont|GCSubwindowMode|GCGraphicsExposures|
314 GCDashOffset|GCDashList|GCArcMode) ;
315 }
316
317 /* return arm-shadow gc. */
318
319 GC
320 AllocArmGC(Widget w, int contrast, Bool be_nice_to_cmap)
321 {
322 Screen *scr = XtScreen (w);
323 XGCValues values ;
324
325 /* Not clear exactly what we should do here. Take a look at
326 * Xaw3d to see what they do.
327 */
328 #ifdef HAVE_XMU
329 if( w->core.depth == 1 || be_nice_to_cmap )
330 {
331 values.background = w->core.background_pixel ;
332 if( values.background == BlackPixelOfScreen(scr) )
333 values.foreground = WhitePixelOfScreen(scr) ;
334 else
335 values.foreground = BlackPixelOfScreen(scr) ;
336 values.fill_style = FillStippled ;
337 values.stipple = XmuCreateStippledPixmap(XtScreen(w), 1L, 0L, 1) ;
338
339 return XtAllocateGC(w, w->core.depth,
340 GCForeground|GCBackground|GCStipple|GCFillStyle,
341 &values, 0L,
342 GCFont|GCSubwindowMode|GCGraphicsExposures|
343 GCDashOffset|GCDashList|GCArcMode) ;
344 }
345 else
346 #endif
347 {
348 values.foreground = AllocShadowPixel(w, 100-contrast) ;
349 return XtAllocateGC(w, w->core.depth,
350 GCForeground, &values,
351 0L,
352 GCBackground|GCFont|GCSubwindowMode|GCGraphicsExposures|
353 GCDashOffset|GCDashList|GCArcMode) ;
354 }
355 }
356
357
358 Pixel
359 AllocShadowPixel(Widget w, int scale)
360 {
361 XColor get_c, set_c ;
362 Display *dpy = XtDisplay(w) ;
363 Screen *scr = XtScreen(w) ;
364 Colormap cmap ;
365 Pixel maxColor ;
366
367 cmap = w->core.colormap ;
368
369 get_c.pixel = w->core.background_pixel ;
370 if( get_c.pixel == WhitePixelOfScreen(scr) ||
371 get_c.pixel == BlackPixelOfScreen(scr) )
372 {
373 /* what we *ought* to do is choose gray75 as the base color,
374 * or perhaps gray83. Instead, we choose colors that are
375 * the same as ThreeD would choose.
376 */
377 if( scale > 100 ) scale = 200 - scale ;
378 set_c.red = set_c.green = set_c.blue = 65535*scale/100 ;
379 }
380 else
381 {
382 XQueryColor(dpy, cmap, &get_c) ;
383 /* adjust scale so that brightest component does not
384 * exceed 65535; otherwise hue would change.
385 */
386 if( scale > 100 ) {
387 maxColor = Max(get_c.red, Max(get_c.green, get_c.blue)) ;
388 if( scale*maxColor > 65535*100 )
389 scale = 65535*100/maxColor ;
390 }
391 set_c.red = scale * get_c.red / 100 ;
392 set_c.green = scale * get_c.green / 100 ;
393 set_c.blue = scale * get_c.blue / 100 ;
394 }
395 set_c.flags = DoRed | DoGreen | DoBlue ;
396 if( XAllocColor(dpy, cmap, &set_c) )
397 return set_c.pixel ;
398 else if( scale > 100 )
399 return WhitePixelOfScreen(scr) ;
400 else
401 return BlackPixelOfScreen(scr) ;
402 }
403
404
405 /* Allocate a pixel partway between foreground and background */
406
407
408 Pixel
409 AllocGreyPixel(Widget w, Pixel fg, Pixel bg, int scale)
410 {
411 XColor get_cf, get_cb ;
412 Display *dpy = XtDisplay(w) ;
413 Colormap cmap ;
414
415 cmap = w->core.colormap ;
416
417 get_cf.pixel = fg ;
418 get_cb.pixel = bg ;
419
420 XQueryColor(dpy, cmap, &get_cf) ;
421 XQueryColor(dpy, cmap, &get_cb) ;
422
423 return AllocGreyPixelC(w, &get_cf, &get_cb, scale) ;
424 }
425
426
427
428 /* Allocate a pixel partway between foreground and background */
429
430
431 Pixel
432 AllocGreyPixelC(Widget w, XColor *fg, XColor *bg, int scale)
433 {
434 XColor set_c ;
435 Display *dpy = XtDisplay(w) ;
436 int r,g,b ;
437 Colormap cmap = w->core.colormap ;
438
439 r = (fg->red * scale + bg->red * (100-scale)) / 100 ;
440 g = (fg->green * scale + bg->green * (100-scale)) / 100 ;
441 b = (fg->blue * scale + bg->blue * (100-scale)) / 100 ;
442
443 if( scale > 100 || scale < 0 ) /* look out for overflow */
444 {
445 int minc, maxc ;
446 maxc = Max(r, Max(g,b)) ;
447 minc = Min(r, Min(g,b)) ;
448 if( maxc > 65535 )
449 {
450 maxc /= 16 ;
451 r = r*(65535/16) / maxc ;
452 g = g*(65535/16) / maxc ;
453 b = b*(65535/16) / maxc ;
454 }
455 if( minc < 0 )
456 {
457 r = Max(r,0) ;
458 g = Max(g,0) ;
459 b = Max(b,0) ;
460 }
461 }
462
463 set_c.red = r ; set_c.green = g ; set_c.blue = b ;
464 set_c.flags = DoRed | DoGreen | DoBlue ;
465 (void)XAllocColor(dpy, cmap, &set_c) ;
466 return set_c.pixel ;
467 }
468
469
470
471
472
473 /* draw a 3-d box */
474
475 void
476 Draw3dBox(Widget w, int x, int y, int wid, int hgt, int s, GC topgc, GC botgc)
477 {
478 Display *dpy = XtDisplay(w) ;
479 Window win = XtWindow(w) ;
480
481 if( s == 0 ) return ;
482
483 if( s == 1 ) {
484 XDrawLine(dpy,win,botgc, x,y+hgt-1, x+wid-1,y+hgt-1) ;
485 XDrawLine(dpy,win,botgc, x+wid-1,y, x+wid-1,y+hgt-1) ;
486 XDrawLine(dpy,win,topgc, x,y, x,y+hgt-1) ;
487 XDrawLine(dpy,win,topgc, x,y, x+wid-1,y) ;
488 }
489 else
490 {
491 XPoint pts[6] ;
492
493 /* bottom-right shadow */
494 pts[0].x = x ; pts[0].y = y + hgt ;
495 pts[1].x = s ; pts[1].y = -s ;
496 pts[2].x = wid-2*s ; pts[2].y = 0 ;
497 pts[3].x = 0 ; pts[3].y = -(hgt-2*s) ;
498 pts[4].x = s ; pts[4].y = -s ;
499 pts[5].x = 0 ; pts[5].y = hgt ;
500 XFillPolygon(dpy,win,botgc, pts,6, Nonconvex,CoordModePrevious) ;
501
502 /* top-left shadow */
503 pts[0].x = x ; pts[0].y = y ;
504 pts[1].x = wid ; pts[1].y = 0 ;
505 pts[2].x = -s ; pts[2].y = s ;
506 pts[3].x = -wid+2*s ; pts[3].y = 0 ;
507 pts[4].x = 0 ; pts[4].y = hgt-2*s ;
508 pts[5].x = -s ; pts[5].y = s ;
509 XFillPolygon(dpy,win,topgc, pts,6, Nonconvex,CoordModePrevious) ;
510 }
511 }
512
513 #if XtSpecificationRelease < 5
514
515 static GC
516 XtAllocateGC(Widget w, int depth, u_long mask, XGCValues *values,
517 u_long dynamic, du_long ontcare)
518 {
519 return XtGetGC(w, mask, values) ;
520 }
521 #endif
522
523
524 static u_char screen0[2] = {0,0} ;
525 static u_char screen25[2] = {0,0xaa} ;
526 static u_char screen75[2] = {0xaa,0xff} ;
527 static u_char screen100[2] = {0xff,0xff} ;
528
529 static Pixmap
530 getDitherPixmap(Widget w, int contrast)
531 {
532 Display *dpy = XtDisplay(w) ;
533 Window win = XtWindow(w) ;
534
535 if( contrast <= 5 )
536 return XCreateBitmapFromData(dpy,win, (char *)screen0, 2,2) ;
537 else if( contrast <= 37 )
538 return XCreateBitmapFromData(dpy,win, (char *)screen25, 2,2) ;
539 else if( contrast <= 62 )
540 return XmuCreateStippledPixmap(XtScreen(w), 1L, 0L, 1) ;
541 else if( contrast <= 95 )
542 return XCreateBitmapFromData(dpy,win, (char *)screen75, 2,2) ;
543 else
544 return XCreateBitmapFromData(dpy,win, (char *)screen100, 2,2) ;
545 }