?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* A little clean-up.
[fvwm.git] / libs / Graphics.c
blob3ee628118c691798c6e7a95d90257d0c35a5062e
1 /* -*-c-*- */
2 /* This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15 */
16
17 /* Graphics.c: misc convenience functions for drawing stuff */
18
19 /* ---------------------------- included header files ---------------------- */
20
21 #include "config.h"
22
23 #include <X11/Xlib.h>
24 #include <stdio.h>
25 #include <math.h>
26
27 #include "defaults.h"
28 #include "libs/fvwmlib.h"
29 #include "libs/PictureBase.h"
30 #include "libs/PictureUtils.h"
31 #include "libs/PictureGraphics.h"
32 #include "libs/gravity.h"
33 #include "libs/FImage.h"
34
35 /* ---------------------------- local definitions -------------------------- */
36
37 /* Define some standard constants that are not defined on QNX 4.25 */
38 #ifndef M_PI
39 #define M_PI 3.14159265358979323846
40 #endif
41 #ifndef M_PI_2
42 #define M_PI_2 1.57079632679489661923
43 #endif
44
45 /* ---------------------------- local macros ------------------------------- */
46
47 /* ---------------------------- imports ------------------------------------ */
48
49 /* ---------------------------- included code files ------------------------ */
50
51 /* ---------------------------- local types -------------------------------- */
52
53 /* ---------------------------- forward declarations ----------------------- */
54
55 /* ---------------------------- local variables ---------------------------- */
56
57 /* ---------------------------- exported variables (globals) --------------- */
58
59 /* ---------------------------- local functions ---------------------------- */
60
61 /* ---------------------------- interface functions ------------------------ */
62
63 /* Draws the relief pattern around a window
64 * Draws a line_width wide rectangle from (x,y) to (x+w,y+h) i.e w+1 wide,
65 * h+1 high
66 * Draws end points assuming CAP_NOT_LAST style in GC
67 * Draws anti-clockwise in case CAP_BUTT is the style and the end points overlap
68 * Top and bottom lines come out full length, the sides come out 1 pixel less
69 * This is so FvwmBorder windows have a correct bottom edge and the sticky lines
70 * look like just lines
71 * rotation rotate the relief and shadow part
72 */
73 void do_relieve_rectangle_with_rotation(
74 Display *dpy, Drawable d, int x, int y, int w, int h,
75 GC ReliefGC, GC ShadowGC, int line_width, Bool use_alternate_shading,
76 int rotation)
77 {
78 XSegment* seg;
79 GC shadow_gc, relief_gc;
80 int i,i2;
81 int a;
82 int l;
83
84 a = (use_alternate_shading) ? 1 : 0;
85 l = 1 - a;
86 if (w <= 0 || h <= 0)
87 {
88 return;
89 }
90 /* If line_width is negative, reverse the rotation, which will */
91 /* have the effect of inverting the relief. */
92 if (line_width < 0)
93 {
94 line_width = -line_width;
95 rotation = gravity_add_rotations(rotation, ROTATION_180);
96 }
97 switch (rotation)
98 {
99 case ROTATION_180:
100 case ROTATION_270:
101 rotation = gravity_add_rotations(rotation, ROTATION_180);
102 shadow_gc = ReliefGC;
103 relief_gc = ShadowGC;
104 break;
105 default:
106 shadow_gc = ShadowGC;
107 relief_gc = ReliefGC;
108 break;
109 }
110 seg = (XSegment*)alloca((sizeof(XSegment) * line_width) * 2);
111 /* from 0 to the lesser of line_width & just over half w */
112 for (i = 0; (i < line_width) && (i <= w / 2); i++)
113 {
114 if (rotation == ROTATION_0)
115 {
116 /* left */
117 seg[i].x1 = x+i; seg[i].y1 = y+i+a;
118 seg[i].x2 = x+i; seg[i].y2 = y+h-i+a;
119 }
120 else /* ROTATION_90 */
121 {
122 /* right */
123 seg[i].x1 = x+w-i; seg[i].y1 = y+h-i-a;
124 seg[i].x2 = x+w-i; seg[i].y2 = y+i+1-a;
125 }
126 }
127 i2 = i;
128 /* draw top segments */
129 for (i = 0; (i < line_width) && (i <= h / 2); i++,i2++)
130 {
131 seg[i2].x1 = x+w-i-a; seg[i2].y1 = y+i;
132 seg[i2].x2 = x+i+1-a; seg[i2].y2 = y+i;
133 }
134 XDrawSegments(dpy, d, relief_gc, seg, i2);
135 /* bottom */
136 for (i = 0; (i < line_width) && (i <= h / 2); i++)
137 {
138 seg[i].x1 = x+i+a+l; seg[i].y1 = y+h-i;
139 seg[i].x2 = x+w-i-1+a; seg[i].y2 = y+h-i;
140 }
141 i2 = i;
142 for (i = 0; (i < line_width) && (i <= w / 2); i++,i2++)
143 {
144 if (rotation == ROTATION_0)
145 {
146 /* right */
147 seg[i2].x1 = x+w-i; seg[i2].y1 = y+h-i-a;
148 seg[i2].x2 = x+w-i; seg[i2].y2 = y+i+1-a;
149 }
150 else /* ROTATION_90 */
151 {
152 /* left */
153 seg[i2].x1 = x+i; seg[i2].y1 = y+i+a;
154 seg[i2].x2 = x+i; seg[i2].y2 = y+h-i+a;
155 }
156 }
157 XDrawSegments(dpy, d, shadow_gc, seg, i2);
158
159 return;
160 }
161
162 void do_relieve_rectangle(
163 Display *dpy, Drawable d, int x, int y, int w, int h,
164 GC ReliefGC, GC ShadowGC, int line_width, Bool use_alternate_shading)
165 {
166 do_relieve_rectangle_with_rotation(
167 dpy, d, x, y, w, h, ReliefGC, ShadowGC, line_width,
168 use_alternate_shading, ROTATION_0);
169 return;
170 }
171
172 /* Creates a pixmap that is a horizontally stretched version of the input
173 * pixmap
174 */
175 Pixmap CreateStretchXPixmap(
176 Display *dpy, Pixmap src, int src_width, int src_height, int src_depth,
177 int dest_width, GC gc)
178 {
179 int i;
180 Pixmap pixmap;
181 GC my_gc = None;
182
183 if (src_width < 0 || src_height < 0 || dest_width < 0)
184 {
185 return None;
186 }
187 pixmap = XCreatePixmap(dpy, src, dest_width, src_height, src_depth);
188 if (pixmap == None)
189 {
190 return None;
191 }
192 if (gc == None)
193 {
194 my_gc = fvwmlib_XCreateGC(dpy, pixmap, 0, 0);
195 }
196 for (i = 0; i < dest_width; i++)
197 {
198 XCopyArea(
199 dpy, src, pixmap, (gc == None)? my_gc:gc,
200 (i * src_width) / dest_width, 0, 1, src_height, i, 0);
201 }
202 if (my_gc)
203 {
204 XFreeGC(dpy, my_gc);
205 }
206 return pixmap;
207 }
208
209
210 /* Creates a pixmap that is a vertically stretched version of the input
211 * pixmap
212 */
213 Pixmap CreateStretchYPixmap(
214 Display *dpy, Pixmap src, int src_width, int src_height, int src_depth,
215 int dest_height, GC gc)
216 {
217 int i;
218 Pixmap pixmap;
219 GC my_gc = None;
220
221 if (src_height < 0 || src_depth < 0 || dest_height < 0)
222 {
223 return None;
224 }
225 pixmap = XCreatePixmap(dpy, src, src_width, dest_height, src_depth);
226 if (pixmap == None)
227 {
228 return None;
229 }
230 if (gc == None)
231 {
232 my_gc = fvwmlib_XCreateGC(dpy, pixmap, 0, 0);
233 }
234 for (i = 0; i < dest_height; i++)
235 {
236 XCopyArea(
237 dpy, src, pixmap, (gc == None)? my_gc:gc,
238 0, (i * src_height) / dest_height, src_width, 1, 0, i);
239 }
240 if (my_gc)
241 {
242 XFreeGC(dpy, my_gc);
243 }
244 return pixmap;
245 }
246
247
248 /* Creates a pixmap that is a stretched version of the input
249 * pixmap
250 */
251 Pixmap CreateStretchPixmap(
252 Display *dpy, Pixmap src, int src_width, int src_height, int src_depth,
253 int dest_width, int dest_height, GC gc)
254 {
255 Pixmap pixmap = None;
256 Pixmap temp_pixmap;
257 GC my_gc = None;
258
259 if (src_width < 0 || src_height < 0 || src_depth < 0 || dest_width < 0)
260 {
261 return None;
262 }
263 if (gc == None)
264 {
265 my_gc = fvwmlib_XCreateGC(dpy, src, 0, 0);
266 }
267 temp_pixmap = CreateStretchXPixmap(
268 dpy, src, src_width, src_height, src_depth, dest_width,
269 (gc == None)? my_gc:gc);
270 if (temp_pixmap == None)
271 {
272 if (my_gc)
273 {
274 XFreeGC(dpy, my_gc);
275 }
276 return None;
277 }
278 pixmap = CreateStretchYPixmap(
279 dpy, temp_pixmap, dest_width, src_height, src_depth,
280 dest_height, (gc == None)? my_gc:gc);
281 XFreePixmap(dpy, temp_pixmap);
282 if (my_gc)
283 {
284 XFreeGC(dpy, my_gc);
285 }
286 return pixmap;
287 }
288
289 /* Creates a pixmap that is a tiled version of the input pixmap. Modifies the
290 * sets the fill_style of the GC to FillSolid and the tile to None. */
291 Pixmap CreateTiledPixmap(
292 Display *dpy, Pixmap src, int src_width, int src_height,
293 int dest_width, int dest_height, int depth, GC gc)
294 {
295 XGCValues xgcv;
296 Pixmap pixmap;
297
298 if (src_width < 0 || src_height < 0 ||
299 dest_width < 0 || dest_height < 0)
300 {
301 return None;
302 }
303 pixmap = XCreatePixmap(dpy, src, dest_width, dest_height, depth);
304 if (pixmap == None)
305 {
306 return None;
307 }
308 xgcv.fill_style = FillTiled;
309 xgcv.tile = src;
310 xgcv.ts_x_origin = 0;
311 xgcv.ts_y_origin = 0;
312 XChangeGC(
313 dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin |
314 GCTileStipYOrigin, &xgcv);
315 XFillRectangle(dpy, pixmap, gc, 0, 0, dest_width, dest_height);
316 xgcv.fill_style = FillSolid;
317 XChangeGC(dpy, gc, GCFillStyle, &xgcv);
318
319 return pixmap;
320 }
321
322 Pixmap CreateRotatedPixmap(
323 Display *dpy, Pixmap src, int src_width, int src_height, int depth,
324 GC gc, int rotation)
325 {
326 GC my_gc = None;
327 Pixmap pixmap = None;
328 int dest_width, dest_height, i, j;
329 Bool error = False;
330 FImage *fim = NULL;
331 FImage *src_fim = NULL;
332
333 if (src_width <= 0 || src_height <= 0)
334 {
335 return None;
336 }
337 switch(rotation)
338 {
339 case ROTATION_90:
340 case ROTATION_270:
341 dest_width = src_height;
342 dest_height = src_width;
343 break;
344 case ROTATION_0:
345 case ROTATION_180:
346 dest_width = src_width;
347 dest_height = src_height;
348 break;
349 default:
350 return None;
351 break;
352 }
353 pixmap = XCreatePixmap(dpy, src, dest_width, dest_height, depth);
354 if (pixmap == None)
355 {
356 return None;
357 }
358 if (gc == None)
359 {
360 my_gc = fvwmlib_XCreateGC(dpy, src, 0, 0);
361 }
362 if (rotation == ROTATION_0)
363 {
364 XCopyArea(
365 dpy, src, pixmap, (gc == None)? my_gc:gc,
366 0, 0, src_width, src_height, 0, 0);
367 goto bail;
368 }
369
370 if (!(src_fim = FGetFImage(
371 dpy, src, Pvisual, depth, 0, 0, src_width, src_height,
372 AllPlanes, ZPixmap)))
373 {
374 error = True;
375 goto bail;
376 }
377 if (!(fim = FCreateFImage(
378 dpy, Pvisual, depth, ZPixmap, dest_width, dest_height)))
379 {
380 error = True;
381 goto bail;
382 }
383
384 for (j = 0; j < src_height; j++)
385 {
386 for (i = 0; i < src_width; i++)
387 {
388 switch(rotation)
389 {
390 case ROTATION_270:
391 XPutPixel(
392 fim->im, j, src_width - i - 1,
393 XGetPixel(src_fim->im, i, j));
394 break;
395 case ROTATION_90:
396 XPutPixel(
397 fim->im, src_height - j - 1, i,
398 XGetPixel(src_fim->im, i, j));
399 break;
400 case ROTATION_180:
401 XPutPixel(
402 fim->im,
403 src_width - i - 1, src_height - j - 1,
404 XGetPixel(src_fim->im, i, j));
405 break;
406 default:
407 break;
408 }
409 }
410 }
411 FPutFImage(dpy, pixmap, gc, fim, 0, 0, 0, 0, dest_width, dest_height);
412 bail:
413 if (error && pixmap)
414 {
415 XFreePixmap(dpy,pixmap);
416 pixmap = None;
417 }
418 if (fim)
419 {
420 FDestroyFImage(dpy, fim);
421 }
422 if (src_fim)
423 {
424 FDestroyFImage(dpy, src_fim);
425 }
426 if (my_gc)
427 {
428 XFreeGC(dpy, my_gc);
429 }
430 return pixmap;
431 }
432
433 /*
434 *
435 * Returns True if the given type of gradient is supported.
436 *
437 */
438 Bool IsGradientTypeSupported(char type)
439 {
440 switch (toupper(type))
441 {
442 case V_GRADIENT:
443 case H_GRADIENT:
444 case B_GRADIENT:
445 case D_GRADIENT:
446 case R_GRADIENT:
447 case Y_GRADIENT:
448 case S_GRADIENT:
449 case C_GRADIENT:
450 return True;
451 default:
452 fprintf(stderr, "%cGradient type is not supported\n",
453 toupper(type));
454 return False;
455 }
456 }
457
458 /*
459 *
460 * Allocates a linear color gradient (veliaa@rpi.edu)
461 *
462 */
463 static
464 XColor *AllocLinearGradient(
465 char *s_from, char *s_to, int npixels, int skip_first_color, int dither)
466 {
467 XColor *xcs;
468 XColor from, to, c;
469 float r;
470 float dr;
471 float g;
472 float dg;
473 float b;
474 float db;
475 int i;
476 int got_all = 1;
477 int div;
478
479 if (npixels < 1)
480 {
481 fprintf(stderr,
482 "AllocLinearGradient: Invalid number of pixels: %d\n",
483 npixels);
484 return NULL;
485 }
486 if (!s_from || !XParseColor(Pdpy, Pcmap, s_from, &from))
487 {
488 fprintf(stderr, "Cannot parse color \"%s\"\n",
489 s_from ? s_from : "<blank>");
490 return NULL;
491 }
492 if (!s_to || !XParseColor(Pdpy, Pcmap, s_to, &to))
493 {
494 fprintf(stderr, "Cannot parse color \"%s\"\n",
495 s_to ? s_to : "<blank>");
496 return NULL;
497 }
498
499 /* divisor must not be zero, hence this calculation */
500 div = (npixels == 1) ? 1 : npixels - 1;
501 c = from;
502 /* red part and step width */
503 r = from.red;
504 dr = (float)(to.red - from.red);
505 /* green part and step width */
506 g = from.green;
507 dg = (float)(to.green - from.green);
508 /* blue part and step width */
509 b = from.blue;
510 db = (float)(to.blue - from.blue);
511 xcs = (XColor *)safemalloc(sizeof(XColor) * npixels);
512 memset(xcs, 0, sizeof(XColor) * npixels);
513 c.flags = DoRed | DoGreen | DoBlue;
514 for (i = (skip_first_color) ? 1 : 0; i < npixels && div > 0; ++i)
515 {
516 c.red = (unsigned short)
517 ((int)(r + dr / (float)div * (float)i + 0.5));
518 c.green = (unsigned short)
519 ((int)(g + dg / (float)div * (float)i + 0.5));
520 c.blue = (unsigned short)
521 ((int)(b + db / (float)div * (float)i + 0.5));
522 if (dither == 0 && !PictureAllocColor(Pdpy, Pcmap, &c, False))
523 {
524 got_all = 0;
525 }
526 xcs[i] = c;
527 }
528 if (!got_all && dither == 0)
529 {
530 fprintf(stderr, "Cannot alloc color gradient %s to %s\n",
531 s_from, s_to);
532 }
533
534 return xcs;
535 }
536
537 /*
538 *
539 * Allocates a nonlinear color gradient (veliaa@rpi.edu)
540 *
541 */
542 static XColor *AllocNonlinearGradient(
543 char *s_colors[], int clen[], int nsegs, int npixels, int dither)
544 {
545 XColor *xcs = (XColor *)safemalloc(sizeof(XColor) * npixels);
546 int i;
547 int curpixel = 0;
548 int *seg_end_colors;
549 int seg_sum = 0;
550 float color_sum = 0.0;
551
552 if (nsegs < 1 || npixels < 2)
553 {
554 fprintf(stderr,
555 "Gradients must specify at least one segment and"
556 " two colors\n");
557 free(xcs);
558 return NULL;
559 }
560 for (i = 0; i < npixels; i++)
561 {
562 xcs[i].pixel = 0;
563 }
564
565 /* get total length of all segments */
566 for (i = 0; i < nsegs; i++)
567 {
568 seg_sum += clen[i];
569 }
570
571 /* calculate the index of a segment's las color */
572 seg_end_colors = alloca(nsegs * sizeof(int));
573 if (nsegs == 1)
574 {
575 seg_end_colors[0] = npixels - 1;
576 }
577 else
578 {
579 for (i = 0; i < nsegs; i++)
580 {
581 color_sum += (float)(clen[i] * (npixels - 1)) /
582 (float)(seg_sum);
583 seg_end_colors[i] = (int)(color_sum + 0.5);
584 }
585 if (seg_end_colors[nsegs - 1] > npixels - 1)
586 {
587 fprintf(stderr,
588 "BUG: (AllocNonlinearGradient): "
589 "seg_end_colors[nsegs - 1] (%d)"
590 " > npixels - 1 (%d)."
591 " Gradient drawing aborted\n",
592 seg_end_colors[nsegs - 1], npixels - 1);
593 return NULL;
594 }
595 /* take care of rounding errors */
596 seg_end_colors[nsegs - 1] = npixels - 1;
597 }
598
599 for (i = 0; i < nsegs; ++i)
600 {
601 XColor *c = NULL;
602 int j;
603 int n;
604 int skip_first_color = (curpixel != 0);
605
606 if (i == 0)
607 {
608 n = seg_end_colors[0] + 1;
609 }
610 else
611 {
612 n = seg_end_colors[i] - seg_end_colors[i - 1] + 1;
613 }
614
615 if (n > 1)
616 {
617 c = AllocLinearGradient(
618 s_colors[i], s_colors[i + 1], n,
619 skip_first_color, dither);
620 if (!c && (n - skip_first_color) != 0)
621 {
622 free(xcs);
623 return NULL;
624 }
625 for (j = skip_first_color; j < n; ++j)
626 {
627 xcs[curpixel + j] = c[j];
628 }
629 curpixel += n - 1;
630 }
631 if (c)
632 {
633 free(c);
634 c = NULL;
635 }
636 if (curpixel != seg_end_colors[i])
637 {
638 fprintf(stderr,
639 "BUG: (AllocNonlinearGradient): "
640 "nsegs %d, i %d, curpixel %d,"
641 " seg_end_colors[i] = %d,"
642 " npixels %d, n %d\n",
643 nsegs, i, curpixel,
644 seg_end_colors[i],npixels,n);
645 return NULL;
646 }
647 }
648 return xcs;
649 }
650
651 /* Convenience function. Calls AllocNonLinearGradient to fetch all colors and
652 * then frees the color names and the perc and color_name arrays. */
653 XColor *AllocAllGradientColors(
654 char *color_names[], int perc[], int nsegs, int ncolors, int dither)
655 {
656 XColor *xcs = NULL;
657 int i;
658
659 /* grab the colors */
660 xcs = AllocNonlinearGradient(
661 color_names, perc, nsegs, ncolors, dither);
662 for (i = 0; i <= nsegs; i++)
663 {
664 if (color_names[i])
665 {
666 free(color_names[i]);
667 }
668 }
669 free(color_names);
670 free(perc);
671 if (!xcs)
672 {
673 fprintf(stderr, "couldn't create gradient\n");
674 return NULL;
675 }
676
677 return xcs;
678 }
679
680 /* groks a gradient string and creates arrays of colors and percentages
681 * returns the number of colors asked for (No. allocated may be less due
682 * to the ColorLimit command). A return of 0 indicates an error
683 */
684 unsigned int ParseGradient(
685 char *gradient, char **rest, char ***colors_return, int **perc_return,
686 int *nsegs_return)
687 {
688 char *item;
689 char *orig;
690 unsigned int npixels;
691 char **s_colors;
692 int *perc;
693 int nsegs, i, sum;
694 Bool is_syntax_error = False;
695
696 /* get the number of colors specified */
697 if (rest)
698 {
699 *rest = gradient;
700 }
701 orig = gradient;
702
703 if (GetIntegerArguments(gradient, &gradient, (int *)&npixels, 1) != 1 ||
704 npixels < 2)
705 {
706 fprintf(
707 stderr, "ParseGradient: illegal number of colors in"
708 " gradient: '%s'\n", orig);
709 return 0;
710 }
711
712 /* get the starting color or number of segments */
713 gradient = GetNextToken(gradient, &item);
714 if (gradient)
715 {
716 gradient = SkipSpaces(gradient, NULL, 0);
717 }
718 if (!gradient || !*gradient || !item)
719 {
720 fprintf(stderr, "Incomplete gradient style: '%s'\n", orig);
721 if (item)
722 {
723 free(item);
724 }
725 if (rest)
726 {
727 *rest = gradient;
728 }
729 return 0;
730 }
731
732 if (GetIntegerArguments(item, NULL, &nsegs, 1) != 1)
733 {
734 /* get the end color of a simple gradient */
735 s_colors = (char **)safemalloc(sizeof(char *) * 2);
736 perc = (int *)safemalloc(sizeof(int));
737 nsegs = 1;
738 s_colors[0] = item;
739 gradient = GetNextToken(gradient, &item);
740 s_colors[1] = item;
741 perc[0] = 100;
742 }
743 else
744 {
745 free(item);
746 /* get a list of colors and percentages */
747 if (nsegs < 1)
748 nsegs = 1;
749 if (nsegs > MAX_GRADIENT_SEGMENTS)
750 nsegs = MAX_GRADIENT_SEGMENTS;
751 s_colors = (char **)safemalloc(sizeof(char *) * (nsegs + 1));
752 perc = (int *)safemalloc(sizeof(int) * nsegs);
753 for (i = 0; !is_syntax_error && i <= nsegs; i++)
754 {
755 s_colors[i] = 0;
756 gradient = GetNextToken(gradient, &s_colors[i]);
757 if (i < nsegs)
758 {
759 if (GetIntegerArguments(
760 gradient, &gradient, &perc[i], 1)
761 != 1 || perc[i] <= 0)
762 {
763 /* illegal size */
764 perc[i] = 0;
765 }
766 }
767 }
768 if (s_colors[nsegs] == NULL)
769 {
770 fprintf(
771 stderr, "ParseGradient: too few gradient"
772 " segments: '%s'\n", orig);
773 is_syntax_error = True;
774 }
775 }
776
777 /* sanity check */
778 for (i = 0, sum = 0; !is_syntax_error && i < nsegs; ++i)
779 {
780 int old_sum = sum;
781
782 sum += perc[i];
783 if (sum < old_sum)
784 {
785 /* integer overflow */
786 fprintf(
787 stderr, "ParseGradient: multi gradient"
788 " overflow: '%s'", orig);
789 is_syntax_error = 1;
790 break;
791 }
792 }
793 if (is_syntax_error)
794 {
795 for (i = 0; i <= nsegs; ++i)
796 {
797 if (s_colors[i])
798 {
799 free(s_colors[i]);
800 }
801 }
802 free(s_colors);
803 free(perc);
804 if (rest)
805 {
806 *rest = gradient;
807 }
808 return 0;
809 }
810
811
812 /* sensible limits */
813 if (npixels < 2)
814 npixels = 2;
815 if (npixels > MAX_GRADIENT_COLORS)
816 npixels = MAX_GRADIENT_COLORS;
817
818 /* send data back */
819 *colors_return = s_colors;
820 *perc_return = perc;
821 *nsegs_return = nsegs;
822 if (rest)
823 *rest = gradient;
824
825 return npixels;
826 }
827
828 /* Calculate the prefered dimensions of a gradient, based on the number of
829 * colors and the gradient type. Returns False if the gradient type is not
830 * supported. */
831 Bool CalculateGradientDimensions(
832 Display *dpy, Drawable d, int ncolors, char type, int dither,
833 unsigned int *width_ret, unsigned int *height_ret)
834 {
835 static unsigned int best_width = 0, best_height = 0;
836 int dither_factor = (dither > 0)? 128:1;
837
838 /* get the best tile size (once) */
839 if (!best_width)
840 {
841 if (!XQueryBestTile(dpy, d, 1, 1, &best_width, &best_height))
842 {
843 best_width = 0;
844 best_height = 0;
845 }
846 /* this is needed for buggy X servers like XFree 3.3.3.1 */
847 if (!best_width)
848 best_width = 1;
849 if (!best_height)
850 best_height = 1;
851 }
852
853 switch (type) {
854 case H_GRADIENT:
855 *width_ret = ncolors;
856 *height_ret = best_height * dither_factor;
857 break;
858 case V_GRADIENT:
859 *width_ret = best_width * dither_factor;
860 *height_ret = ncolors;
861 break;
862 case D_GRADIENT:
863 case B_GRADIENT:
864 /* diagonal gradients are rendered into a rectangle for which
865 * the width plus the height is equal to ncolors + 1. The
866 * rectangle is square when ncolors is odd and one pixel
867 * taller than wide with even numbers */
868 *width_ret = (ncolors + 1) / 2;
869 *height_ret = ncolors + 1 - *width_ret;
870 break;
871 case S_GRADIENT:
872 /* square gradients have the last color as a single pixel in
873 * the centre */
874 *width_ret = *height_ret = 2 * ncolors - 1;
875 break;
876 case C_GRADIENT:
877 /* circular gradients have the first color as a pixel in each
878 * corner */
879 *width_ret = *height_ret = 2 * ncolors - 1;
880 break;
881 case R_GRADIENT:
882 case Y_GRADIENT:
883 /* swept types need each color to occupy at least one pixel at
884 * the edge. Get the smallest odd number that will provide
885 * enough */
886 for (*width_ret = 1;
887 (double)(*width_ret - 1) * M_PI < (double)ncolors;
888 *width_ret += 2)
889 {
890 /* nothing to do here */
891 }
892 *height_ret = *width_ret;
893 break;
894 default:
895 fprintf(stderr, "%cGradient not supported\n", type);
896 return False;
897 }
898 return True;
899 }
900
901 /* Does the actual drawing of the pixmap. If the in_drawable argument is None,
902 * a new pixmap of the given depth, width and height is created. If it is not
903 * None the gradient is drawn into it. The d_width, d_height, d_x and d_y
904 * describe the traget rectangle within the drawable. */
905 Drawable CreateGradientPixmap(
906 Display *dpy, Drawable d, GC gc, int type, int g_width, int g_height,
907 int ncolors, XColor *xcs, int dither, Pixel **d_pixels, int *d_npixels,
908 Drawable in_drawable, int d_x, int d_y, int d_width, int d_height,
909 XRectangle *rclip)
910 {
911 Pixmap pixmap = None;
912 PictureImageColorAllocator *pica = NULL;
913 XColor c;
914 FImage *fim;
915 register int i, j;
916 XGCValues xgcv;
917 Drawable target;
918 int t_x;
919 int t_y;
920 int t_width;
921 int t_height;
922 int ps;
923
924 if (d_pixels != NULL && *d_pixels != NULL)
925 {
926 if (d_npixels != NULL && *d_npixels > 0)
927 {
928 PictureFreeColors(
929 dpy, Pcmap, *d_pixels, *d_npixels, 0, False);
930 }
931 free(*d_pixels);
932 *d_pixels = NULL;
933 }
934 if (d_npixels != NULL)
935 {
936 *d_npixels = 0;
937 }
938 if (g_height < 0 || g_width < 0 || d_width < 0 || d_height < 0)
939 return None;
940
941 if (in_drawable == None)
942 {
943 /* create a pixmap to use */
944 pixmap = XCreatePixmap(dpy, d, g_width, g_height, Pdepth);
945 if (pixmap == None)
946 return None;
947 target = pixmap;
948 t_x = 0;
949 t_y = 0;
950 t_width = g_width;
951 t_height = g_height;
952 }
953 else
954 {
955 target = in_drawable;
956 t_x = d_x;
957 t_y = d_y;
958 t_width = d_width;
959 t_height = d_height;
960 }
961
962 fim = FCreateFImage(
963 dpy, Pvisual, Pdepth, ZPixmap, t_width, t_height);
964 if (!fim)
965 {
966 fprintf(stderr, "%cGradient couldn't get image\n", type);
967 if (pixmap != None)
968 XFreePixmap(dpy, pixmap);
969 return None;
970 }
971 if (dither)
972 {
973 pica = PictureOpenImageColorAllocator(
974 dpy, Pcmap, t_width, t_height,
975 False, False, dither, False);
976 }
977 ps = t_width * t_height;
978 /* now do the fancy drawing */
979 switch (type)
980 {
981 case H_GRADIENT:
982 {
983 for (i = 0; i < t_width; i++)
984 {
985 int d = i * ncolors / t_width;
986 c = xcs[d];
987 for (j = 0; j < t_height; j++)
988 {
989 if (dither)
990 {
991 c = xcs[d];
992 PictureAllocColorImage(
993 dpy, pica, &c, i, j);
994 }
995 XPutPixel(fim->im, i, j, c.pixel);
996 }
997 }
998 }
999 break;
1000 case V_GRADIENT:
1001 {
1002 for (j = 0; j < t_height; j++)
1003 {
1004 int d = j * ncolors / t_height;
1005 c = xcs[d];
1006 for (i = 0; i < t_width; i++)
1007 {
1008 if (dither)
1009 {
1010 c = xcs[d];
1011 PictureAllocColorImage(
1012 dpy, pica, &c, i, j);
1013 }
1014 XPutPixel(fim->im, i, j, c.pixel);
1015 }
1016 }
1017 break;
1018 }
1019 case D_GRADIENT:
1020 {
1021 register int t_scale = t_width + t_height - 1;
1022 for (i = 0; i < t_width; i++)
1023 {
1024 for (j = 0; j < t_height; j++)
1025 {
1026 c = xcs[(i+j) * ncolors / t_scale];
1027 if (dither)
1028 {
1029 PictureAllocColorImage(
1030 dpy, pica, &c, i, j);
1031 }
1032 XPutPixel(fim->im, i, j, c.pixel);
1033 }
1034 }
1035 break;
1036 }
1037 case B_GRADIENT:
1038 {
1039 register int t_scale = t_width + t_height - 1;
1040 for (i = 0; i < t_width; i++)
1041 {
1042 for (j = 0; j < t_height; j++)
1043 {
1044 c = xcs[(i + (t_height - j - 1)) * ncolors /
1045 t_scale];
1046 if (dither)
1047 {
1048 PictureAllocColorImage(
1049 dpy, pica, &c, i, j);
1050 }
1051 XPutPixel(fim->im, i, j, c.pixel);
1052 }
1053 }
1054 break;
1055 }
1056 case S_GRADIENT:
1057 {
1058 register int t_scale = t_width * t_height;
1059 register int myncolors = ncolors * 2;
1060 for (i = 0; i < t_width; i++) {
1061 register int pi = min(i, t_width - 1 - i) * t_height;
1062 for (j = 0; j < t_height; j++) {
1063 register int pj =
1064 min(j, t_height - 1 - j) * t_width;
1065 c = xcs[(min(pi, pj) * myncolors - 1) /
1066 t_scale];
1067 if (dither)
1068 {
1069 PictureAllocColorImage(
1070 dpy, pica, &c, i, j);
1071 }
1072 XPutPixel(fim->im, i, j, c.pixel);
1073 }
1074 }
1075 }
1076 break;
1077 case C_GRADIENT:
1078 {
1079 register double t_scale =
1080 (double)(t_width * t_height) / sqrt(8);
1081 for (i = 0; i < t_width; i++)
1082 {
1083 for (j = 0; j < t_height; j++)
1084 {
1085 register double x =
1086 (double)((2 * i - t_width) * t_height) /
1087 4.0;
1088 register double y =
1089 (double)((t_height - 2 * j) * t_width) /
1090 4.0;
1091 register double rad = sqrt(x * x + y * y);
1092 c = xcs[(int)((rad * ncolors - 0.5) / t_scale)];
1093 if (dither)
1094 {
1095 PictureAllocColorImage(
1096 dpy, pica, &c, i, j);
1097 }
1098 XPutPixel(fim->im, i, j, c.pixel);
1099 }
1100 }
1101 break;
1102 }
1103 case R_GRADIENT:
1104 {
1105 register int w = t_width - 1;
1106 register int h = t_height - 1;
1107 /* g_width == g_height, both are odd, therefore x can be 0.0 */
1108 for (i = 0; i <= w; i++) {
1109 for (j = 0; j <= h; j++) {
1110 register double x =
1111 (double)((2 * i - w) * h) / 4.0;
1112 register double y =
1113 (double)((h - 2 * j) * w) / 4.0;
1114 /* angle ranges from -pi/2 to +pi/2 */
1115 register double angle;
1116 if (x != 0.0) {
1117 angle = atan(y / x);
1118 } else {
1119 angle = (y < 0) ? - M_PI_2 : M_PI_2;
1120 }
1121 /* extend to -pi/2 to 3pi/2 */
1122 if (x < 0)
1123 angle += M_PI;
1124 /* move range from -pi/2:3*pi/2 to 0:2*pi */
1125 if (angle < 0.0)
1126 angle += M_PI * 2.0;
1127 /* normalize to gradient */
1128 c = xcs[(int)(angle * M_1_PI * 0.5 * ncolors)];
1129 if (dither)
1130 {
1131 PictureAllocColorImage(
1132 dpy, pica, &c, i, j);
1133 }
1134 XPutPixel(fim->im, i, j, c.pixel);
1135 }
1136 }
1137 }
1138 break;
1139 /*
1140 * The Yin Yang gradient style and the following code are:
1141 * Copyright 1999 Sir Boris. (email to sir_boris@bigfoot.com may be
1142 * read by his groom but is not guaranteed to elicit a response)
1143 * No restrictions are placed on this code, as long as the copyright
1144 * notice is preserved.
1145 */
1146 case Y_GRADIENT:
1147 {
1148 register int r = t_width * t_height / 4;
1149 for (i = 0; i < t_width; i++) {
1150 for (j = 0; j < t_height; j++) {
1151 register double x =
1152 (double)((2 * i - t_width) * t_height) /
1153 4.0;
1154 register double y =
1155 (double)((t_height - 2 * j) * t_width) /
1156 4.0;
1157 register double rad = sqrt(x * x + y * y);
1158 /* angle ranges from -pi/2 to +pi/2 */
1159 register double angle;
1160
1161 if (x != 0.0) {
1162 angle = atan(y / x);
1163 } else {
1164 angle = (y < 0) ? - M_PI_2 : M_PI_2;
1165 }
1166 /* extend to -pi/2 to 3pi/2 */
1167 if (x < 0)
1168 angle += M_PI;
1169 /* warp the angle within the yinyang circle */
1170 if (rad <= r) {
1171 angle -= acos(rad / r);
1172 }
1173 /* move range from -pi/2:3*pi/2 to 0:2*pi */
1174 if (angle < 0.0)
1175 angle += M_PI * 2.0;
1176 /* normalize to gradient */
1177 c = xcs[(int)(angle * M_1_PI * 0.5 * ncolors)];
1178 if (dither)
1179 {
1180 PictureAllocColorImage(
1181 dpy, pica, &c, i, j);
1182 }
1183 XPutPixel(fim->im, i, j, c.pixel);
1184 }
1185 }
1186 }
1187 break;
1188 default:
1189 /* placeholder function, just fills the pixmap with the first
1190 * color */
1191 memset(fim->im->data, 0, fim->im->bytes_per_line * t_height);
1192 XAddPixel(fim->im, xcs[0].pixel);
1193 break;
1194 }
1195
1196 if (dither)
1197 {
1198 if (d_pixels != NULL && d_npixels != NULL)
1199 {
1200 PictureCloseImageColorAllocator(
1201 dpy, pica, d_npixels, d_pixels, 0);
1202 }
1203 else
1204 {
1205 /* possible color leak */
1206 }
1207 }
1208
1209 /* set the gc style */
1210 xgcv.function = GXcopy;
1211 xgcv.plane_mask = AllPlanes;
1212 xgcv.fill_style = FillSolid;
1213 xgcv.clip_mask = None;
1214 XChangeGC(dpy, gc, GCFunction|GCPlaneMask|GCFillStyle|GCClipMask,
1215 &xgcv);
1216 if (rclip)
1217 {
1218 XSetClipRectangles(dpy, gc, 0, 0, rclip, 1, Unsorted);
1219 }
1220 /* copy the image to the server */
1221 FPutFImage(dpy, target, gc, fim, 0, 0, t_x, t_y, t_width, t_height);
1222 if (rclip)
1223 {
1224 XSetClipMask(dpy, gc, None);
1225 }
1226 FDestroyFImage(dpy, fim);
1227 return target;
1228 }
1229
1230
1231 /* Create a pixmap from a gradient specifier, width and height are hints
1232 * that are only used for gradients that can be tiled e.g. H or V types
1233 * types are HVDBSCRY for Horizontal, Vertical, Diagonal, Back-diagonal, Square,
1234 * Circular, Radar and Yin/Yang respectively (in order of bloatiness)
1235 */
1236 Pixmap CreateGradientPixmapFromString(
1237 Display *dpy, Drawable d, GC gc, int type, char *action,
1238 unsigned int *width_return, unsigned int *height_return,
1239 Pixel **pixels_return, int *nalloc_pixels, int dither)
1240 {
1241 Pixel *d_pixels = NULL;
1242 unsigned int d_npixels = 0;
1243 XColor *xcs = NULL;
1244 unsigned int ncolors = 0;
1245 char **colors;
1246 int *perc, nsegs;
1247 Pixmap pixmap = None;
1248
1249 /* set return pixels to NULL in case of premature return */
1250 if (pixels_return)
1251 *pixels_return = NULL;
1252 if (nalloc_pixels)
1253 *nalloc_pixels = 0;
1254
1255 /* translate the gradient string into an array of colors etc */
1256 if (!(ncolors = ParseGradient(action, NULL, &colors, &perc, &nsegs))) {
1257 fprintf(stderr, "Can't parse gradient: '%s'\n", action);
1258 return None;
1259 }
1260 /* grab the colors */
1261 xcs = AllocAllGradientColors(
1262 colors, perc, nsegs, ncolors, dither);
1263 if (xcs == NULL)
1264 {
1265 return None;
1266 }
1267
1268 /* grok the size to create from the type */
1269 type = toupper(type);
1270
1271 if (CalculateGradientDimensions(
1272 dpy, d, ncolors, type, dither, width_return, height_return))
1273 {
1274 pixmap = CreateGradientPixmap(
1275 dpy, d, gc, type, *width_return, *height_return,
1276 ncolors, xcs, dither, &d_pixels, &d_npixels,
1277 None, 0, 0, 0, 0, NULL);
1278 }
1279
1280 /* if the caller has not asked for the pixels there is probably a leak
1281 */
1282 if (PUseDynamicColors)
1283 {
1284 if (!(pixels_return && nalloc_pixels))
1285 {
1286 /* if the caller has not asked for the pixels there is
1287 * probably a leak */
1288 fprintf(stderr,
1289 "CreateGradient: potential color leak, losing track"
1290 " of pixels\n");
1291 if (d_pixels != NULL)
1292 {
1293 free(d_pixels);
1294 }
1295 }
1296 else
1297 {
1298 if (!dither)
1299 {
1300 Pixel *pixels;
1301 int i;
1302
1303 pixels = (Pixel *)safemalloc(
1304 ncolors * sizeof(Pixel));
1305 for(i=0; i<ncolors; i++)
1306 {
1307 pixels[i] = xcs[i].pixel;
1308 }
1309 *pixels_return = pixels;
1310 *nalloc_pixels = ncolors;
1311 }
1312 else
1313 {
1314 *pixels_return = d_pixels;
1315 *nalloc_pixels = d_npixels;
1316 }
1317 }
1318 }
1319 else if (d_pixels != NULL)
1320 {
1321 /* should not happen */
1322 free(d_pixels);
1323 }
1324
1325 free(xcs);
1326
1327 return pixmap;
1328 }
1329
1330 /*
1331 *
1332 * Draws a little Triangle pattern within a window
1333 *
1334 */
1335 void DrawTrianglePattern(
1336 Display *dpy, Drawable d, GC ReliefGC, GC ShadowGC, GC FillGC,
1337 int x, int y, int width, int height, int bw, char orientation,
1338 Bool draw_relief, Bool do_fill, Bool is_pressed)
1339 {
1340 const struct
1341 {
1342 const char line[3];
1343 const char point[3];
1344 } hi[4] =
1345 {
1346 { { 1, 0, 0 }, { 1, 1, 0 } }, /* up */
1347 { { 1, 0, 1 }, { 1, 0, 0 } }, /* down */
1348 { { 1, 0, 0 }, { 1, 1, 0 } }, /* left */
1349 { { 1, 0, 1 }, { 1, 1, 0 } } /* right */
1350 };
1351 XPoint points[4];
1352 GC temp_gc;
1353 int short_side;
1354 int long_side;
1355 int t_width;
1356 int t_height;
1357 int i;
1358 int type;
1359
1360 /* remove border width from target area */
1361 width -= 2 * bw;
1362 height -= 2 * bw;
1363 x += bw;
1364 y += bw;
1365 if (width < 1 || height < 1)
1366 /* nothing to do */
1367 return;
1368
1369 orientation = tolower(orientation);
1370 switch (orientation)
1371 {
1372 case 'u':
1373 case 'd':
1374 long_side = width;
1375 short_side = height;
1376 type = (orientation == 'd');
1377 break;
1378 case 'l':
1379 case 'r':
1380 long_side = height;
1381 short_side = width;
1382 type = (orientation == 'r') + 2;
1383 break;
1384 default:
1385 /* unknowm orientation */
1386 return;
1387 }
1388
1389 /* assure the base side has an odd length */
1390 if ((long_side & 0x1) == 0)
1391 long_side--;
1392 /* reduce base length if short sides don't fit */
1393 if (short_side < long_side / 2 + 1)
1394 long_side = 2 * short_side - 1;
1395 else
1396 short_side = long_side / 2 + 1;
1397
1398 if (orientation == 'u' || orientation == 'd')
1399 {
1400 t_width = long_side;
1401 t_height = short_side;
1402 }
1403 else
1404 {
1405 t_width = short_side;
1406 t_height = long_side;
1407 }
1408 /* find proper x/y coordinate */
1409 x += (width - t_width) / 2;
1410 y += (height - t_height) / 2;
1411 /* decrement width and height for convenience of calculation */
1412 t_width--;
1413 t_height--;
1414
1415 /* get the list of points to draw */
1416 switch (orientation)
1417 {
1418 case 'u':
1419 y += t_height;
1420 t_height = -t_height;
1421 case 'd':
1422 points[1].x = x + t_width / 2;
1423 points[1].y = y + t_height;
1424 points[2].x = x + t_width;
1425 points[2].y = y;
1426 break;
1427 case 'l':
1428 x += t_width;
1429 t_width = -t_width;
1430 case 'r':
1431 points[1].x = x + t_width;
1432 points[1].y = y + t_height / 2;
1433 points[2].x = x;
1434 points[2].y = y + t_height;
1435 break;
1436 }
1437 points[0].x = x;
1438 points[0].y = y;
1439 points[3].x = x;
1440 points[3].y = y;
1441
1442 if (do_fill)
1443 {
1444 /* solid triangle */
1445 XFillPolygon(
1446 dpy, d, FillGC, points, 3, Convex, CoordModeOrigin);
1447 }
1448 if (draw_relief)
1449 {
1450 /* relief triangle */
1451 for (i = 0; i < 3; i++)
1452 {
1453 temp_gc = (is_pressed ^ hi[type].line[i]) ?
1454 ReliefGC : ShadowGC;
1455 XDrawLine(
1456 dpy, d, temp_gc, points[i].x, points[i].y,
1457 points[i+1].x, points[i+1].y);
1458 }
1459 for (i = 0; i < 3; i++)
1460 {
1461 temp_gc = (is_pressed ^ hi[type].point[i]) ?
1462 ReliefGC : ShadowGC;
1463 XDrawPoint(dpy, d, temp_gc, points[i].x, points[i].y);
1464 }
1465 }
1466
1467 return;
1468 }
1469
1470 GC fvwmlib_XCreateGC(
1471 Display *display, Drawable drawable, unsigned long valuemask,
1472 XGCValues *values)
1473 {
1474 GC gc;
1475 Bool f;
1476 XGCValues gcv;
1477
1478 if (!values)
1479 {
1480 values = &gcv;
1481 }
1482 f = values->graphics_exposures;
1483 if (!(valuemask & GCGraphicsExposures))
1484 {
1485 valuemask |= GCGraphicsExposures;
1486 values->graphics_exposures = 0;
1487 }
1488 gc = XCreateGC(display, drawable, valuemask, values);
1489 values->graphics_exposures = f;
1490
1491 return gc;
1492 }
CVS import of FVWM to Git.