?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* FvwmTheme/FvwmTheme.1: Language check, general edits,
[fvwm.git] / libs / PictureUtils.c
blob3480694356220cde0759f5d11e3f374308134272
1 /* -*-c-*- */
2 /* Copyright (C) 1993, Robert Nation
3 * Copyright (C) 2002 Olivier Chapuis
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 */
19
20 /* ---------------------------- included header files ----------------------- */
21
22 #include "config.h"
23
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <signal.h>
27 #include <ctype.h>
28 #include <time.h>
29 #include <math.h>
30
31 #include <X11/Xlib.h>
32 #include <X11/Xmd.h>
33
34 #include <fvwmlib.h>
35 #include "PictureBase.h"
36 #include "PictureUtils.h"
37 #include "PictureDitherMatrice.h"
38
39 /* ---------------------------- local definitions and macro ------------------ */
40
41 #define PICTURE_DEBUG_COLORS_ALLOC_FAILURE 0
42
43 /* form alloc_in_cmap from the xpm lib */
44 #define XPM_DIST(r1,g1,b1,r2,g2,b2) (long)\
45 (3*(abs((long)r1-(long)r2) + \
46 abs((long)g1-(long)g2) + \
47 abs((long)b1-(long)b2)) + \
48 abs((long)r1 + (long)g1 + (long)b1 - \
49 ((long)r2 + (long)g2 + (long)b2)))
50 #define XPM_COLOR_CLOSENESS 40000
51
52 #define SQUARE(X) ((X)*(X))
53
54 #define TRUE_DIST(r1,g1,b1,r2,g2,b2) (long)\
55 (SQUARE((long)((r1 - r2)>>8)) \
56 + SQUARE((long)((g1 - g2)>>8)) \
57 + SQUARE((long)((b1 - b2)>>8)))
58
59 #define FAST_DIST(r1,g1,b1,r2,g2,b2) (long)\
60 (abs((long)(r1 - r2)) \
61 + abs((long)(g1 - g2)) \
62 + abs((long)(b1 - b2)))
63
64 #define FVWM_DIST(r1,g1,b1,r2,g2,b2) \
65 (abs(r1 - r2) + abs(g1 - g2) + abs(b1 - b2) \
66 + 2*abs(abs(r1-g1) + abs(g1-b1) + abs(r1-b1) \
67 - abs(r2-g2) - abs(g2-b2) - abs(r2-b2)))
68
69 #define USED_DIST(r1,g1,b1,r2,g2,b2) FVWM_DIST(r1,g1,b1,r2,g2,b2)
70
71 #define PICTURE_COLOR_CLOSENESS USED_DIST(3,3,3,0,0,0)
72
73 #define PICTURE_PAllocTable 1000000
74 #define PICTURE_PUseDynamicColors 100000
75 #define PICTURE_PStrictColorLimit 10000
76 #define PICTURE_use_named 1000
77 #define PICTURE_TABLETYPE_LENGHT 7
78
79 /* humm ... dither is probably borken with gamma correction. Anyway I do
80 * do think that using gamma correction for the colors cubes is a good
81 * idea */
82 #define USE_GAMMA_CORECTION 0
83 /* 2.2 is recommanded by the Poynon colors FAQ, some others suggest 1.5 and 2
84 * Use float constants!*/
85 #define COLOR_GAMMA 1.5
86 #define GREY_GAMMA 2.0
87
88 /* ---------------------------- imports ------------------------------------- */
89
90 /* ---------------------------- included code files ------------------------- */
91
92 /* ---------------------------- local types --------------------------------- */
93
94 typedef struct
95 {
96 XColor color; /* rgb color info */
97 unsigned long alloc_count; /* nbr of allocation */
98 } PColor;
99
100 typedef struct
101 {
102 /*
103 * info for colors table (depth <= 8)
104 */
105 /* color cube used */
106 short nr;
107 short ng;
108 short nb;
109 short ngrey;
110 /* grey palette def, nbr of grey = 2^grey_bits */
111 short grey_bits;
112 /* color cube used for dithering with the named table */
113 short d_nr;
114 short d_ng;
115 short d_nb;
116 short d_ngrey_bits;
117 /* do we found a pre-allocated pallet ? */
118 Bool pre_allocated_pallet;
119 /* info for depth > 8 */
120 int red_shift;
121 int green_shift;
122 int blue_shift;
123 int red_prec;
124 int green_prec;
125 int blue_prec;
126 /* for dithering in depth 15 and 16 */
127 unsigned short *red_dither;
128 unsigned short *green_dither;
129 unsigned short *blue_dither;
130 /* colors allocation function */
131 int (*alloc_color)();
132 int (*alloc_color_no_limit)();
133 int (*alloc_color_dither)();
134 void (*free_colors)();
135 void (*free_colors_no_limit)();
136 } PColorsInfo;
137
138 typedef struct {
139 int cols_index;
140 long closeness;
141 } CloseColor;
142
143 /* ---------------------------- forward declarations ------------------------ */
144
145 /* ---------------------------- local variables ----------------------------- */
146
147 static int PColorLimit = 0;
148 static PColor *Pct = NULL;
149 static PColor *Pac = NULL;
150 static short *PMappingTable = NULL;
151 static short *PDitherMappingTable = NULL;
152 static Bool PStrictColorLimit = 0;
153 static Bool PAllocTable = 0;
154 static PColorsInfo Pcsi = {
155 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL,
156 NULL, NULL, NULL, NULL};
157
158 /* ---------------------------- exported variables (globals) ---------------- */
159
160 /* ---------------------------- local functions ----------------------------- */
161
162 /* ***************************************************************************
163 * get shift and prec from a mask
164 * ***************************************************************************/
165 static
166 void decompose_mask(
167 unsigned long mask, int *shift, int *prec)
168 {
169 *shift = 0;
170 *prec = 0;
171
172 while (!(mask & 0x1))
173 {
174 (*shift)++;
175 mask >>= 1;
176 }
177
178 while (mask & 0x1)
179 {
180 (*prec)++;
181 mask >>= 1;
182 }
183 }
184
185 /* ***************************************************************************
186 * color allocation in the colormap. strongly inspired by SetCloseColor from
187 * the Xpm library (depth <= 8)
188 * ***************************************************************************/
189
190 static int
191 closeness_cmp(const void *a, const void *b)
192 {
193 CloseColor *x = (CloseColor *) a, *y = (CloseColor *) b;
194
195 /* cast to int as qsort requires */
196 return (int) (x->closeness - y->closeness);
197 }
198
199 static
200 int alloc_color_in_cmap(XColor *c, Bool force)
201 {
202 static XColor colors[256];
203 CloseColor closenesses[256];
204 XColor tmp;
205 int i,j;
206 int map_entries = (Pvisual->class == DirectColor)?
207 (1 << Pdepth) : Pvisual->map_entries;
208 time_t current_time;
209 time_t last_time = 0;
210
211 map_entries = (map_entries > 256)? 256:map_entries;
212 current_time = time(NULL);
213 if (current_time - last_time >= 2 || force)
214 {
215 last_time = current_time;
216 for (i = 0; i < map_entries; i++)
217 {
218 colors[i].pixel = i;
219 }
220 XQueryColors(Pdpy, Pcmap, colors, map_entries);
221 }
222 for(i = 0; i < map_entries; i++)
223 {
224 closenesses[i].cols_index = i;
225 closenesses[i].closeness = USED_DIST(
226 (int)(c->red),
227 (int)(c->green),
228 (int)(c->blue),
229 (int)(colors[i].red),
230 (int)(colors[i].green),
231 (int)(colors[i].blue));
232 }
233 qsort(closenesses, map_entries, sizeof(CloseColor), closeness_cmp);
234
235 i = 0;
236 j = closenesses[i].cols_index;
237 while (force ||
238 (abs((long)c->red - (long)colors[j].red) <=
239 PICTURE_COLOR_CLOSENESS &&
240 abs((long)c->green - (long)colors[j].green) <=
241 PICTURE_COLOR_CLOSENESS &&
242 abs((long)c->blue - (long)colors[j].blue) <=
243 PICTURE_COLOR_CLOSENESS))
244 {
245 tmp.red = colors[j].red;
246 tmp.green = colors[j].green;
247 tmp.blue = colors[j].blue;
248 if (XAllocColor(Pdpy, Pcmap, &tmp))
249 {
250 c->red = tmp.red;
251 c->green = tmp.green;
252 c->blue = tmp.blue;
253 c->pixel = tmp.pixel;
254 return 1;
255 }
256 else
257 {
258 i++;
259 if (i == map_entries)
260 break;
261 j = closenesses[i].cols_index;
262 }
263 }
264 return 0;
265 }
266
267 /* ***************************************************************************
268 * dithering
269 * ***************************************************************************/
270
271 static
272 int my_dither(int x, int y, XColor *c)
273 {
274 /* the dither matrice */
275 static const char DM[128][128] = DITHER_MATRICE;
276 int index;
277 const char *dmp;
278
279 if (Pcsi.grey_bits != 0)
280 {
281 /* Grey Scale */
282 int prec = Pcsi.grey_bits;
283
284 if (Pcsi.grey_bits == 1)
285 {
286 /* FIXME, can we do a better dithering */
287 prec = 2;
288 }
289 dmp = DM[(0 + y) & (DM_HEIGHT - 1)];
290 index = (c->green + ((c->blue + c->red) >> 1)) >> 1;
291 index += (dmp[(0 + x) & (DM_WIDTH - 1)] << 2) >> prec;
292 index = (index - (index >> prec));
293 index = index >> (8 - Pcsi.grey_bits);
294 }
295 else
296 {
297 /* color cube */
298 int dith, rs, gs, bs, gb, b;
299 int tr,tb,tg;
300
301 rs = Pcsi.d_nr - 1;
302 gs = Pcsi.d_ng - 1;
303 bs = Pcsi.d_nb - 1;
304 gb = Pcsi.d_ng*Pcsi.d_nb;
305 b = Pcsi.d_nb;
306
307 dmp = DM[(0 + y) & (DM_HEIGHT - 1)];
308 dith = (dmp[(0 + x) & (DM_WIDTH - 1)] << 2) | 7;
309 tr = ((c->red * rs) + dith) >> 8;
310 tg = ((c->green * gs) + (262 - dith)) >> 8;
311 tb = ((c->blue * bs) + dith) >> 8;
312 index = tr * gb + tg * b + tb;
313 #if 0
314 /* try to use the additonal grey. Not easy, good for
315 * certain image/gradient bad for others */
316 if (Pcsi.d_ngrey_bits)
317 {
318 int g_index;
319
320 /* dither in the Pcsi.ngrey^3 cc */
321 tr = ((c->red * (Pcsi.ngrey-1)) + dith) >> 8;
322 tg = ((c->green * (Pcsi.ngrey-1)) + (262 - dith)) >> 8;
323 tb = ((c->blue * (Pcsi.ngrey-1)) + dith) >> 8;
324 /* get the grey */
325 fprintf(stderr, "%i,%i,%i(%i/%i) ", tr,tg,tb,
326 abs(tr-tg) + abs(tb-tg) + abs(tb-tr),Pcsi.ngrey);
327 g_index = ((tr + tg + tb)/3);
328 if (g_index != 0 && g_index != Pcsi.ngrey-1 &&
329 abs(tr-tg) + abs(tb-tg) + abs(tb-tr) <=
330 Pcsi.d_ngrey_bits)
331 {
332 g_index = g_index + Pcsi.ng*Pcsi.nb*Pcsi.ng -1;
333 index = g_index;
334 }
335 }
336 #endif
337 if (PDitherMappingTable != NULL)
338 {
339 index = PDitherMappingTable[index];
340 }
341 }
342 return index;
343 }
344
345 static
346 int my_dither_depth_15_16_init(void)
347 {
348 const unsigned char _dither_44[4][4] =
349 {
350 {0, 4, 1, 5},
351 {6, 2, 7, 3},
352 {1, 5, 0, 4},
353 {7, 3, 6, 2}
354 };
355 int y,x,i;
356 int rm = 0xf8, re = 0x7, gm = 0xfc, ge = 0x3, bm = 0xf8, be = 0x7;
357
358 if (Pdepth == 16 && (Pvisual->red_mask == 0xf800) &&
359 (Pvisual->green_mask == 0x7e0) &&
360 (Pvisual->blue_mask == 0x1f))
361 {
362 /* ok */
363 }
364 else if (Pdepth == 15 && (Pvisual->red_mask == 0x7c00) &&
365 (Pvisual->green_mask == 0x3e0) &&
366 (Pvisual->blue_mask == 0x1f))
367 {
368 gm = 0xf8; ge = 0x7;
369 }
370 else
371 {
372 return 0; /* fail */
373 }
374
375 Pcsi.red_dither =
376 (unsigned short *)safemalloc(4*4*256*sizeof(unsigned short));
377 Pcsi.green_dither =
378 (unsigned short *)safemalloc(4*4*256*sizeof(unsigned short));
379 Pcsi.blue_dither =
380 (unsigned short *)safemalloc(4*4*256*sizeof(unsigned short));
381
382 for (y = 0; y < 4; y++)
383 {
384 for (x = 0; x < 4; x++)
385 {
386 for (i = 0; i < 256; i++)
387 {
388 if ((_dither_44[x][y] < (i & re)) &&
389 (i < (256 - 8)))
390 {
391 Pcsi.red_dither[
392 (x << 10) | (y << 8) | i] =
393 ((i + 8) & rm) << 8;
394 }
395 else
396 {
397 Pcsi.red_dither[
398 (x << 10) | (y << 8) | i] =
399 (i & rm) << 8;
400 }
401 if ((_dither_44[x][y] < ((i & ge) << 1))
402 && (i < (256 - 4)))
403 {
404 Pcsi.green_dither[
405 (x << 10) | (y << 8) | i] =
406 ((i + 4) & gm) << 8;
407 }
408 else
409 {
410 Pcsi.green_dither[
411 (x << 10) | (y << 8) | i] =
412 (i & gm) << 8;
413 }
414 if ((_dither_44[x][y] < (i & be)) &&
415 (i < (256 - 8)))
416 {
417 Pcsi.blue_dither[
418 (x << 10) | (y << 8) | i] =
419 ((i + 8) & bm) << 8;
420 }
421 else
422 {
423 Pcsi.blue_dither[
424 (x << 10) | (y << 8) | i] =
425 (i & bm) << 8;
426 }
427 }
428 }
429 }
430 return 1;
431 }
432
433 /* ***************************************************************************
434 * Color allocation in the "palette"
435 * ***************************************************************************/
436
437 static
438 int alloc_color_in_pct(XColor *c, int index)
439 {
440 if (Pct[index].alloc_count == 0)
441 {
442 int s = PStrictColorLimit;
443
444 PStrictColorLimit = 0;
445 c->red = Pct[index].color.red;
446 c->green = Pct[index].color.green;
447 c->blue = Pct[index].color.blue;
448 PictureAllocColor(Pdpy, Pcmap, c, True); /* WARN (rec) */
449 Pct[index].color.pixel = c->pixel;
450 Pct[index].alloc_count = 1;
451 PStrictColorLimit = s;
452 }
453 else
454 {
455 c->red = Pct[index].color.red;
456 c->green = Pct[index].color.green;
457 c->blue = Pct[index].color.blue;
458 c->pixel = Pct[index].color.pixel;
459 if (Pct[index].alloc_count < 0xffffffff)
460 (Pct[index].alloc_count)++;
461 }
462 return 1;
463 }
464
465 static
466 int get_color_index(int r, int g, int b, int is_8)
467 {
468 int index;
469
470 if (!is_8)
471 {
472 r= r >> 8;
473 g= g >> 8;
474 b= b >> 8;
475 }
476 if (Pcsi.grey_bits > 0)
477 {
478 /* FIXME: Use other proporition ? */
479 index = ((r+g+b)/3) >> (8 - Pcsi.grey_bits);
480 }
481 else
482 {
483 #if 1
484 /* "exact" computation (corrected linear dist) */
485 float fr,fg,fb;
486 int ir, ig, ib;
487
488 /* map to the cube */
489 fr = ((float)r * (Pcsi.nr-1))/255;
490 fg = ((float)g * (Pcsi.ng-1))/255;
491 fb = ((float)b * (Pcsi.nb-1))/255;
492
493 if (PMappingTable != NULL)
494 {
495 ir = (int)fr + (fr - (int)fr > 0.5);
496 ig = (int)fg + (fg - (int)fg > 0.5);
497 ib = (int)fb + (fb - (int)fb > 0.5);
498
499 index = ir * Pcsi.ng*Pcsi.nb + ig * Pcsi.nb + ib;
500 }
501 else
502 {
503 /* found the best of the 8 linear closest points */
504 int lr,lg,lb,tr,tg,tb,best_dist = -1,i,d;
505
506 index = 0;
507 lr = min((int)fr+1,Pcsi.nr-1);
508 lg = min((int)fg+1,Pcsi.ng-1);
509 lb = min((int)fb+1,Pcsi.nb-1);
510 for(tr =(int)fr; tr<=lr; tr++)
511 {
512 for(tg =(int)fg; tg<=lg; tg++)
513 {
514 for(tb =(int)fb; tb<=lb; tb++)
515 {
516 i = tr * Pcsi.ng*Pcsi.nb +
517 tg * Pcsi.nb +
518 tb;
519 d = USED_DIST(
520 r,g,b,
521 (Pct[i].color.red>>8),
522 (Pct[i].color.green>>8),
523 (Pct[i].color.blue>>8));
524 if (best_dist == -1 ||
525 d < best_dist)
526 {
527 index = i;
528 best_dist = d;
529 }
530 }
531 }
532 }
533
534 /* now found the best grey */
535 if (Pcsi.ngrey - 2 > 0)
536 {
537 /* FIXME: speedup this with more than 8 grey */
538 int start = Pcsi.nr*Pcsi.ng*Pcsi.nb;
539 for(i=start; i < start+Pcsi.ngrey-2; i++)
540 {
541 d = USED_DIST(
542 r,g,b,
543 (Pct[i].color.red>>8),
544 (Pct[i].color.green>>8),
545 (Pct[i].color.blue>>8));
546 if (d < best_dist)
547 {
548 index = i;
549 best_dist = d;
550 }
551 }
552 }
553 return index;
554 }
555 #else
556 /* approximation; faster */
557 index = ((r * Pcsi.nr)>>8) * Pcsi.ng*Pcsi.nb +
558 ((g * Pcsi.ng)>>8) * Pcsi.nb +
559 ((b * Pcsi.nb)>>8);
560 #endif
561 if (PMappingTable != NULL)
562 {
563 index = PMappingTable[index];
564 }
565 }
566 return index;
567 }
568
569 /* ***************************************************************************
570 * Main colors allocator
571 * ***************************************************************************/
572 static
573 int alloc_color_proportion(Display *dpy, Colormap cmap, XColor *c)
574 {
575 c->pixel = (Pixel)(
576 ((c->red >> (16 - Pcsi.red_prec))<< Pcsi.red_shift) +
577 ((c->green >> (16 - Pcsi.green_prec))<< Pcsi.green_shift) +
578 ((c->blue >> (16 - Pcsi.blue_prec))<< Pcsi.blue_shift)
579 );
580 return 1;
581 }
582
583 static
584 int alloc_color_proportion_dither(
585 Display *dpy, Colormap cmap, XColor *c, int x, int y)
586 {
587 /* 8 bit colors !! */
588 c->red = Pcsi.red_dither[
589 (((x + 0) & 0x3) << 10) | ((y & 0x3) << 8) |
590 ((c->red) & 0xff)] * 257;
591 c->green = Pcsi.green_dither[
592 (((x + 0) & 0x3) << 10) | ((y & 0x3) << 8) |
593 ((c->green) & 0xff)] * 257;
594 c->blue = Pcsi.blue_dither[
595 (((x + 0) & 0x3) << 10) | ((y & 0x3) << 8) |
596 ((c->blue) & 0xff)] * 257;
597 c->pixel = (Pixel)(
598 ((c->red >> (16 - Pcsi.red_prec)) << Pcsi.red_shift) +
599 ((c->green >> (16 - Pcsi.green_prec))
600 << Pcsi.green_shift) +
601 ((c->blue >> (16 - Pcsi.blue_prec)) << Pcsi.blue_shift)
602 );
603 return 1;
604 }
605
606 static
607 int alloc_color_proportion_grey(
608 Display *dpy, Colormap cmap, XColor *c)
609 {
610 /* FIXME: is this ok in general? */
611 c->pixel = ((c->red + c->green + c->blue)/3);
612 if (Pdepth < 16)
613 {
614 c->pixel = c->pixel >> (16 - Pdepth);
615 }
616 return 1;
617 }
618
619 static
620 int alloc_color_in_table(Display *dpy, Colormap cmap, XColor *c)
621 {
622
623 int index = get_color_index(c->red,c->green,c->blue, False);
624 return alloc_color_in_pct(c, index);
625 }
626
627 static
628 int alloc_color_in_table_dither(
629 Display *dpy, Colormap cmap, XColor *c, int x, int y)
630 {
631 int index;
632 /* 8 bit colors !! */
633 index = my_dither(x, y, c);
634 return alloc_color_in_pct(c, index);
635 }
636
637 static
638 int alloc_color_dynamic_no_limit(
639 Display *dpy, Colormap cmap, XColor *c)
640 {
641 int r = 0;
642
643 if (XAllocColor(dpy, cmap, c))
644 {
645 r = 1;
646 }
647 else if (!alloc_color_in_cmap(c, False))
648 {
649 XGrabServer(dpy);
650 r = alloc_color_in_cmap(c, True);
651 XUngrabServer(dpy);
652 }
653 else
654 {
655 r = 1;
656 }
657 if (r && Pac != NULL && (c->pixel <= (1 << Pdepth) /* always true*/))
658 {
659 Pac[c->pixel].alloc_count++;
660 Pac[c->pixel].color.red = c->red;
661 Pac[c->pixel].color.green = c->green;
662 Pac[c->pixel].color.blue = c->blue;
663 Pac[c->pixel].color.pixel = c->pixel;
664 }
665 return r;
666 }
667
668 static
669 int alloc_color_x(
670 Display *dpy, Colormap cmap, XColor *c)
671 {
672 return XAllocColor(dpy, cmap, c);
673 }
674
675 static
676 void free_colors_in_table(
677 Display *dpy, Colormap cmap, Pixel *pixels, int n, unsigned long planes,
678 Bool no_limit)
679 {
680 Pixel *p;
681 int i,j,do_free;
682 int m = 0;
683
684 if (!Pct || !PUseDynamicColors)
685 {
686 return;
687 }
688
689 p = (Pixel *)safemalloc(n*sizeof(Pixel));
690 for(i= 0; i < n; i++)
691 {
692 do_free = 1;
693 for(j=0; j<PColorLimit; j++)
694 {
695 if (Pct[j].alloc_count &&
696 Pct[j].alloc_count < 0xffffffff &&
697 pixels[i] == Pct[j].color.pixel)
698 {
699 (Pct[j].alloc_count)--;
700 if (Pct[j].alloc_count)
701 do_free = 0;
702 break;
703 }
704 }
705 if (do_free)
706 {
707 p[m++] = pixels[i];
708 }
709 }
710 if (m > 0)
711 {
712 XFreeColors(dpy, cmap, p, m, planes);
713 }
714 free(p);
715
716 return;
717 }
718
719 static
720 void free_colors_x(
721 Display *dpy, Colormap cmap, Pixel *pixels, int n, unsigned long planes,
722 Bool no_limit)
723 {
724 XFreeColors(dpy, cmap, pixels, n, planes);
725 if (Pac != NULL)
726 {
727 int nbr_colors = (1 << Pdepth);
728 int i;
729
730 for(i= 0; i < n; i++)
731 {
732 if (pixels[i] <= nbr_colors)
733 {
734 Pac[pixels[i]].alloc_count--;
735 }
736 }
737 }
738 }
739
740 /* ***************************************************************************
741 * local function for building pallet (dynamic colors, private DirectColor
742 * cmap)
743 * ***************************************************************************/
744 static
745 XColor *build_mapping_colors(int nr, int ng, int nb)
746 {
747 int r, g, b, i;
748 XColor *colors;
749
750 colors = (XColor *)safemalloc(nr*ng*nb * sizeof(XColor));
751 i = 0;
752 for (r = 0; r < nr; r++)
753 {
754 for (g = 0; g < ng; g++)
755 {
756 for (b = 0; b < nb; b++)
757 {
758 colors[i].red =
759 r * 65535 / (nr - 1);
760 colors[i].green =
761 g * 65535 / (ng - 1);
762 colors[i].blue =
763 b * 65535 / (nb - 1);
764 i++;
765 }
766 }
767 }
768 return colors;
769 }
770
771 short *build_mapping_table(int nr, int ng, int nb, Bool use_named)
772 {
773 int size = nr*ng*nb;
774 XColor *colors_map;
775 short *Table;
776 int i,j, minind;
777 double mindst = 40000;
778 double dst;
779
780 colors_map = build_mapping_colors(nr, ng, nb);
781 Table = (short *)safemalloc((size+1) * sizeof(short));
782 for(i=0; i<size; i++)
783 {
784 minind = 0;
785 for(j=0; j<PColorLimit; j++)
786 {
787 if (use_named)
788 {
789 /* for back ward compatibility */
790 dst = TRUE_DIST(colors_map[i].red,
791 colors_map[i].green,
792 colors_map[i].blue,
793 Pct[j].color.red,
794 Pct[j].color.green,
795 Pct[j].color.blue);
796 }
797 else
798 {
799 dst = USED_DIST(colors_map[i].red,
800 colors_map[i].green,
801 colors_map[i].blue,
802 Pct[j].color.red,
803 Pct[j].color.green,
804 Pct[j].color.blue);
805 }
806 if (j == 0 || dst < mindst)
807 {
808 mindst=dst;
809 minind=j;
810 }
811 }
812 Table[i] = minind;
813 }
814 Table[size] = Table[size-1];
815 free(colors_map);
816 return Table;
817 }
818
819 static
820 void free_table_colors(PColor *color_table, int npixels)
821 {
822 Pixel pixels[256];
823 int i,n=0;
824
825 if (npixels > 0)
826 {
827 for(i = 0; i < npixels; i++)
828 {
829 if (color_table[i].alloc_count)
830 {
831 pixels[n++] = color_table[i].color.pixel;
832 }
833 color_table[i].alloc_count = 0;
834 }
835 if (n > 0)
836 {
837 XFreeColors(Pdpy, Pcmap, pixels, n, 0);
838 }
839 }
840 }
841
842 /* FIXME: the DirectColor case */
843 static
844 int get_nbr_of_free_colors(int max_check)
845 {
846 int check = 1;
847 Pixel Pixels[256];
848 int map_entries = (Pvisual->class == DirectColor)?
849 (1 << Pdepth):Pvisual->map_entries;
850 if (max_check < 1)
851 return 0;
852 if (map_entries > 256)
853 {
854 max_check = 256;
855 }
856 max_check = (max_check > map_entries) ? map_entries:max_check;
857 while(1)
858 {
859 if (XAllocColorCells(
860 Pdpy, Pcmap, False, NULL, 0, Pixels, check))
861 {
862 XFreeColors(Pdpy, Pcmap, Pixels, check, 0);
863 check++;
864 }
865 else
866 {
867 return check-1;
868 }
869 if (check > max_check)
870 {
871 return check-1;
872 }
873 }
874 return check-1;
875 }
876
877 static
878 PColor *alloc_color_cube(
879 int nr, int ng, int nb, int ngrey, int grey_bits, Bool do_allocate)
880 {
881 int r, g, b, grey, i, start_grey, end_grey;
882 PColor *color_table;
883 XColor color;
884 int size;
885
886 size = nr*ng*nb + ngrey + (1 << grey_bits)*(grey_bits != 0);
887 if (grey_bits)
888 {
889 ngrey = (1 << grey_bits);
890 }
891 if (nr > 0 && ngrey > 0)
892 {
893 start_grey = 1;
894 end_grey = ngrey - 1;
895 size = size - 2;
896 }
897 else
898 {
899 start_grey = 0;
900 end_grey = ngrey;
901 }
902
903 color_table = (PColor *)safemalloc((size+1) * sizeof(PColor));
904
905 i = 0;
906
907 #if USE_GAMMA_CORECTION
908 #define CG(x) 65535.0 * pow((x)/65535.0,1/COLOR_GAMMA)
909 #define GG(x) 65535.0 * pow((x)/65535.0,1/GREY_GAMMA)
910 #else
911 #define CG(x) x
912 #define GG(x) x
913 #endif
914
915 if (nr > 0)
916 {
917 for (r = 0; r < nr; r++)
918 {
919 for (g = 0; g < ng; g++)
920 {
921 for (b = 0; b < nb; b++)
922 {
923 color.red = CG(r * 65535 / (nr - 1));
924 color.green = CG(g * 65535 / (ng - 1));
925 color.blue = CG(b * 65535 / (nb - 1));
926 if (do_allocate)
927 {
928 if (!XAllocColor(Pdpy, Pcmap,
929 &color))
930 {
931 free_table_colors(
932 color_table, i);
933 free(color_table);
934 return NULL;
935 }
936 color_table[i].color.pixel =
937 color.pixel;
938 color_table[i].alloc_count = 1;
939 }
940 else
941 {
942 color_table[i].alloc_count = 0;
943 }
944 color_table[i].color.red = color.red;
945 color_table[i].color.green = color.green;
946 color_table[i].color.blue = color.blue;
947 i++;
948 }
949 }
950 }
951 }
952
953 if (ngrey > 0)
954 {
955 for (grey = start_grey; grey < end_grey; grey++)
956 {
957 color.red = color.green = color.blue =
958 GG(grey * 65535 / (ngrey - 1));
959 if (do_allocate)
960 {
961 if (!XAllocColor(Pdpy, Pcmap, &color))
962 {
963 free_table_colors(color_table, i);
964 free(color_table);
965 return NULL;
966 }
967 color_table[i].color.pixel = color.pixel;
968 color_table[i].alloc_count = 1;
969 }
970 else
971 {
972 color_table[i].alloc_count = 0;
973 }
974 color_table[i].color.red = color.red;
975 color_table[i].color.green = color.green;
976 color_table[i].color.blue = color.blue;
977 i++;
978 }
979 }
980 color_table[size].color.red = color_table[size-1].color.red;
981 color_table[size].color.green = color_table[size-1].color.green;
982 color_table[size].color.blue = color_table[size-1].color.blue;
983 color_table[size].color.pixel = color_table[size-1].color.pixel;
984 color_table[size].alloc_count = 0;
985 PColorLimit = size;
986 return color_table;
987 }
988
989
990 static
991 PColor *alloc_named_ct(int *limit, Bool do_allocate)
992 {
993
994 /* First thing in base array are colors probably already in the color map
995 because they have familiar names.
996 I pasted them into a xpm and spread them out so that similar colors are
997 spread out.
998 Toward the end are some colors to fill in the gaps.
999 Currently 61 colors in this list.
1000 */
1001 char *color_names[] =
1002 {
1003 "black",
1004 "white",
1005 "grey",
1006 "green",
1007 "blue",
1008 "red",
1009 "cyan",
1010 "yellow",
1011 "magenta",
1012 "DodgerBlue",
1013 "SteelBlue",
1014 "chartreuse",
1015 "wheat",
1016 "turquoise",
1017 "CadetBlue",
1018 "gray87",
1019 "CornflowerBlue",
1020 "YellowGreen",
1021 "NavyBlue",
1022 "MediumBlue",
1023 "plum",
1024 "aquamarine",
1025 "orchid",
1026 "ForestGreen",
1027 "lightyellow",
1028 "brown",
1029 "orange",
1030 "red3",
1031 "HotPink",
1032 "LightBlue",
1033 "gray47",
1034 "pink",
1035 "red4",
1036 "violet",
1037 "purple",
1038 "gray63",
1039 "gray94",
1040 "plum1",
1041 "PeachPuff",
1042 "maroon",
1043 "lavender",
1044 "salmon", /* for peachpuff, orange gap */
1045 "blue4", /* for navyblue/mediumblue gap */
1046 "PaleGreen4", /* for forestgreen, yellowgreen gap */
1047 "#AA7700", /* brick, no close named color */
1048 "#11EE88", /* light green, no close named color */
1049 "#884466", /* dark brown, no close named color */
1050 "#CC8888", /* light brick, no close named color */
1051 "#EECC44", /* gold, no close named color */
1052 "#AAAA44", /* dull green, no close named color */
1053 "#FF1188", /* pinkish red */
1054 "#992299", /* purple */
1055 "#CCFFAA", /* light green */
1056 "#664400", /* dark brown*/
1057 "#AADD99", /* light green */
1058 "#66CCFF", /* light blue */
1059 "#CC2299", /* dark red */
1060 "#FF11CC", /* bright pink */
1061 "#11CC99", /* grey/green */
1062 "#AA77AA", /* purple/red */
1063 "#EEBB77" /* orange/yellow */
1064 };
1065 int NColors = sizeof(color_names)/sizeof(char *);
1066 int i,rc;
1067 PColor *color_table;
1068 XColor color;
1069
1070 *limit = (*limit > NColors)? NColors: *limit;
1071 color_table = (PColor *)safemalloc((*limit+1) * sizeof(PColor));
1072 for(i=0; i<*limit; i++)
1073 {
1074 rc=XParseColor(Pdpy, Pcmap, color_names[i], &color);
1075 if (rc==0) {
1076 fprintf(stderr,"color_to_rgb: can't parse color %s,"
1077 " rc %d\n", color_names[i], rc);
1078 free_table_colors(color_table, i);
1079 free(color_table);
1080 return NULL;
1081 }
1082 if (do_allocate)
1083 {
1084 if (!XAllocColor(Pdpy, Pcmap, &color))
1085 {
1086 free_table_colors(color_table, i);
1087 free(color_table);
1088 return NULL;
1089 }
1090 color_table[i].color.pixel = color.pixel;
1091 color_table[i].alloc_count = 1;
1092 }
1093 else
1094 {
1095 color_table[i].alloc_count = 0;
1096 }
1097 color_table[i].color.red = color.red;
1098 color_table[i].color.green = color.green;
1099 color_table[i].color.blue = color.blue;
1100 }
1101 color_table[*limit].color.red = color_table[*limit-1].color.red;
1102 color_table[*limit].color.green = color_table[*limit-1].color.green;
1103 color_table[*limit].color.blue = color_table[*limit-1].color.blue;
1104 color_table[*limit].color.pixel = color_table[*limit-1].color.pixel;
1105 color_table[*limit].alloc_count = 0;
1106 PColorLimit = *limit;
1107 return color_table;
1108 }
1109
1110 static
1111 void create_mapping_table(
1112 int nr, int ng, int nb, int ngrey, int grey_bits,
1113 Bool non_regular_pallet)
1114 {
1115
1116 Pcsi.grey_bits = 0;
1117
1118 /* initialize dithering colors numbers */
1119 if (!non_regular_pallet)
1120 {
1121 /* */
1122 Pcsi.d_nr = nr;
1123 Pcsi.d_ng = ng;
1124 Pcsi.d_nb = nb;
1125 Pcsi.d_ngrey_bits = 2;
1126 while((1<<Pcsi.d_ngrey_bits) < ngrey)
1127 {
1128 Pcsi.d_ngrey_bits++;
1129 }
1130 if (1<<Pcsi.d_ngrey_bits != ngrey)
1131 {
1132 Pcsi.d_ngrey_bits = 0;
1133 }
1134 Pcsi.grey_bits = grey_bits;
1135 }
1136 else
1137 {
1138 /* dither table should be small */
1139 Pcsi.grey_bits = 0;
1140 if (PColorLimit <= 9)
1141 {
1142 Pcsi.d_nr = 3;
1143 Pcsi.d_ng = 3;
1144 Pcsi.d_nb = 3;
1145 Pcsi.d_ngrey_bits = 0;
1146 }
1147 else if (PColorLimit <= 64)
1148 {
1149 Pcsi.d_nr = 4;
1150 Pcsi.d_ng = 4;
1151 Pcsi.d_nb = 4;
1152 Pcsi.d_ngrey_bits = 0;
1153 }
1154 else
1155 {
1156 Pcsi.d_nr = 8;
1157 Pcsi.d_ng = 8;
1158 Pcsi.d_nb = 8;
1159 Pcsi.d_ngrey_bits = 0;
1160 }
1161 PDitherMappingTable = build_mapping_table(
1162 Pcsi.d_nr, Pcsi.d_ng, Pcsi.d_nb, non_regular_pallet);
1163 }
1164
1165 /* initialize colors number fo index computation */
1166 if (PColorLimit == 2)
1167 {
1168 /* ok */
1169 Pcsi.nr = 0;
1170 Pcsi.ng = 0;
1171 Pcsi.nb = 0;
1172 Pcsi.ngrey = 0;
1173 Pcsi.grey_bits = 1;
1174 }
1175 else if (grey_bits > 0)
1176 {
1177 Pcsi.nr = 0;
1178 Pcsi.ng = 0;
1179 Pcsi.nb = 0;
1180 Pcsi.ngrey = 0;
1181 Pcsi.grey_bits = grey_bits;
1182 }
1183 else if (non_regular_pallet || (0&&ngrey>0))
1184 {
1185 /* note: using these table with !used_named && ngrey>0 will
1186 * probably leads to faster image loading. But I see nothing
1187 * of significative. On the others hands not using it gives
1188 * maybe better colors approximation. */
1189 if (PColorLimit <= 9)
1190 {
1191 Pcsi.nr = 8;
1192 Pcsi.ng = 8;
1193 Pcsi.nb = 8;
1194 Pcsi.ngrey = 0;
1195 }
1196 else
1197 {
1198 Pcsi.nr = 16;
1199 Pcsi.ng = 16;
1200 Pcsi.nb = 16;
1201 Pcsi.ngrey = 0;
1202 }
1203 PMappingTable = build_mapping_table(
1204 Pcsi.nr, Pcsi.ng, Pcsi.nb, non_regular_pallet);
1205 }
1206 else
1207 {
1208 Pcsi.nr = nr;
1209 Pcsi.ng = ng;
1210 Pcsi.nb = nb;
1211 Pcsi.ngrey = ngrey;
1212 Pcsi.grey_bits = 0;
1213 }
1214 }
1215
1216 void finish_ct_init(
1217 int call_type, int ctt, int nr, int ng, int nb, int ngrey, int grey_bits,
1218 Bool use_named)
1219 {
1220 if (call_type == PICTURE_CALLED_BY_FVWM)
1221 {
1222 char *env;
1223
1224 if (PAllocTable)
1225 {
1226 ctt = PICTURE_PAllocTable + ctt;
1227 }
1228 if (PUseDynamicColors)
1229 {
1230 ctt = PICTURE_PUseDynamicColors + ctt;
1231 }
1232 if (PStrictColorLimit)
1233 {
1234 ctt = PICTURE_PStrictColorLimit + ctt;
1235 }
1236 if (use_named)
1237 {
1238 ctt = PICTURE_use_named + ctt;
1239 }
1240 else
1241 {
1242 ctt++;
1243 }
1244 env = safemalloc(21+PICTURE_TABLETYPE_LENGHT+1);
1245 sprintf(env,"FVWM_COLORTABLE_TYPE=%i",ctt);
1246 putenv(env);
1247 if (Pdepth <= 8)
1248 {
1249 Pac = (PColor *)safecalloc(
1250 (1 << Pdepth), sizeof(PColor));
1251 }
1252 }
1253
1254 if (Pct)
1255 {
1256 if (!PAllocTable && call_type == PICTURE_CALLED_BY_FVWM)
1257 {
1258 free_table_colors(Pct, PColorLimit);
1259 }
1260 create_mapping_table(nr,ng,nb,ngrey,grey_bits,use_named);
1261 }
1262 }
1263
1264 #define PA_COLOR_CUBE (1 << 1)
1265 #define FVWM_COLOR_CUBE (1 << 2)
1266 #define PA_GRAY_SCALE (1 << 3)
1267 #define FVWM_GRAY_SCALE (1 << 4)
1268 #define ANY_COLOR_CUBE (PA_COLOR_CUBE|FVWM_COLOR_CUBE)
1269 #define ANY_GRAY_SCALE (PA_GRAY_SCALE|FVWM_GRAY_SCALE)
1270
1271 static
1272 int PictureAllocColorTable(
1273 PictureColorLimitOption *opt, int call_type, Bool use_my_color_limit)
1274 {
1275 char *envp;
1276 int free_colors, nbr_of_color, limit, cc_nbr, i, size;
1277 int use_named_table = 0;
1278 int do_allocate = 0;
1279 int use_default = 1;
1280 int private_cmap = !(Pdefault);
1281 int dyn_cl_set = False;
1282 int strict_cl_set = False;
1283 int alloc_table_set = False;
1284 int color_limit;
1285 int pa_type = (Pvisual->class != GrayScale)? PA_COLOR_CUBE:PA_GRAY_SCALE;
1286 int fvwm_type = (Pvisual->class != GrayScale)?
1287 FVWM_COLOR_CUBE:FVWM_GRAY_SCALE;
1288 int cc[][6] =
1289 {
1290 /* {nr,ng,nb,ngrey,grey_bits,logic} */
1291 /* 5 first for direct colors and Pdepth > 8*/
1292 /* 8192 colors depth 13, a reasonable max for a color table */
1293 {16, 32, 16, 0, 0, FVWM_COLOR_CUBE},
1294 /* 4096 colors depth 12 */
1295 {16, 16, 16, 0, 0, FVWM_COLOR_CUBE},
1296 /* 1024 colors depth 10 */
1297 {8, 16, 8, 0, 0, FVWM_COLOR_CUBE},
1298 /* 512 colors depth 9 */
1299 {8, 8, 8, 0, 0, FVWM_COLOR_CUBE},
1300 /* 256 colors 3/3/2 standard colormap */
1301 {8, 8, 4, 0, 0, FVWM_COLOR_CUBE},
1302 /* 256 grey scale */
1303 {0, 0, 0, 0, 8, ANY_GRAY_SCALE},
1304 /* 244 Xrender XFree-4.2 */
1305 {6, 6, 6, 30, 0, ANY_COLOR_CUBE},
1306 /* 216 Xrender XFree-4.2,GTK/QT "default cc" */
1307 {6, 6, 6, 0, 0, ANY_COLOR_CUBE},
1308 /* 180 (GTK) */
1309 {6, 6, 5, 0, 0, ANY_COLOR_CUBE},
1310 /* 144 (GTK) */
1311 {6, 6, 4, 0, 0, ANY_COLOR_CUBE},
1312 /* 128 grey scale */
1313 {0, 0, 0, 0, 7, ANY_GRAY_SCALE},
1314 /* 125 GTK mini default cc (may change? 444) */
1315 {5, 5, 5, 0, 0, ANY_COLOR_CUBE},
1316 /* 100 (GTK with color limit) */
1317 {5, 5, 4, 0, 0, ANY_COLOR_CUBE},
1318 /* 85 Xrender XFree-4.3 */
1319 {4, 4, 4, 23, 0, ANY_COLOR_CUBE},
1320 /* 78 (in fact 76) a good default ??*/
1321 {4, 4, 4, 16, 0, FVWM_COLOR_CUBE},
1322 /* 70 a good default ?? */
1323 {4, 4, 4, 8, 0, ANY_COLOR_CUBE},
1324 /* 68 a good default ?? */
1325 {4, 4, 4, 6, 0, ANY_COLOR_CUBE},
1326 /* 64 Xrender XFree-4.3 (GTK wcl) */
1327 {4, 4, 4, 0, 0, ANY_COLOR_CUBE},
1328 /* 64 grey scale */
1329 {0, 0, 0, 0, 6, ANY_GRAY_SCALE},
1330 /* 54, maybe a good default? */
1331 {4, 4, 3, 8, 0, FVWM_COLOR_CUBE},
1332 /* 48, (GTK wcl) no grey but ok */
1333 {4, 4, 3, 0, 0, FVWM_COLOR_CUBE},
1334 /* 32, 2/2/1 standard colormap */
1335 {4, 4, 2, 0, 0, FVWM_COLOR_CUBE},
1336 /* 32 xrender xfree-4.2 */
1337 {0, 0, 0, 0, 6, ANY_GRAY_SCALE},
1338 /* 29 */
1339 {3, 3, 3, 4, 0, FVWM_COLOR_CUBE},
1340 /* 27 (xrender in depth 6&7(hypo) GTK wcl) */
1341 {3, 3, 3, 0, 0, FVWM_COLOR_CUBE|PA_COLOR_CUBE*(Pdepth<8)},
1342 /* 16 grey scale */
1343 {0, 0, 0, 0, 4, FVWM_GRAY_SCALE},
1344 /* 10 */
1345 {2, 2, 2, 4, 0, FVWM_COLOR_CUBE},
1346 /* 8 (xrender/qt/gtk wcl) */
1347 {2, 2, 2, 0, 0, FVWM_COLOR_CUBE},
1348 /* 8 grey scale Xrender depth 4 and XFree-4.3 */
1349 {0, 0, 0, 0, 3, FVWM_GRAY_SCALE|PA_GRAY_SCALE*(Pdepth<5)},
1350 /* 4 grey scale*/
1351 {0, 0, 0, 0, 2,
1352 FVWM_GRAY_SCALE|FVWM_COLOR_CUBE|PA_COLOR_CUBE*(Pdepth<4)},
1353 /* 2 */
1354 {0, 0, 0, 0, 1, FVWM_COLOR_CUBE|FVWM_GRAY_SCALE}
1355 };
1356
1357 cc_nbr = sizeof(cc)/(sizeof(cc[0]));
1358
1359 /* set up default */
1360 PStrictColorLimit = 0;
1361 PUseDynamicColors = 1;
1362 PAllocTable = 0;
1363 use_named_table = False;
1364 color_limit = 0;
1365 use_default = True;
1366
1367 /* use fvwm color limit */
1368 if (!use_my_color_limit &&
1369 (envp = getenv("FVWM_COLORTABLE_TYPE")) != NULL)
1370 {
1371 int nr = 0, ng = 0, nb = 0, grey_bits = 0, ngrey = 0;
1372 int ctt = atoi(envp);
1373
1374 if (ctt >= PICTURE_PAllocTable)
1375 {
1376 ctt -= PICTURE_PAllocTable;
1377 PAllocTable = 1; /* not useful for a module !*/
1378 }
1379 if (ctt >= PICTURE_PUseDynamicColors)
1380 {
1381 PUseDynamicColors = 1;
1382 ctt -= PICTURE_PUseDynamicColors;
1383 }
1384 if (ctt >= PICTURE_PStrictColorLimit)
1385 {
1386 PStrictColorLimit = 1;
1387 ctt -= PICTURE_PStrictColorLimit;
1388 }
1389 if (ctt >= PICTURE_use_named)
1390 {
1391 ctt -= PICTURE_use_named;
1392 Pct = alloc_named_ct(&ctt, False);
1393 use_named_table = True;
1394 }
1395 else if (ctt == 0)
1396 {
1397 /* depth <= 8 and no colors limit ! */
1398 PColorLimit = 0;
1399 return 0;
1400 }
1401 else if (ctt <= cc_nbr)
1402 {
1403 ctt--;
1404 Pct = alloc_color_cube(
1405 cc[ctt][0], cc[ctt][1], cc[ctt][2], cc[ctt][3],
1406 cc[ctt][4],
1407 False);
1408 nr = cc[ctt][0];
1409 ng = cc[ctt][1];
1410 nb = cc[ctt][2];
1411 ngrey = cc[ctt][3];
1412 grey_bits = cc[ctt][4];
1413 }
1414 if (Pct != NULL)
1415 {
1416 /* should always happen */
1417 finish_ct_init(
1418 call_type, ctt, nr, ng, nb, ngrey, grey_bits,
1419 use_named_table);
1420 return PColorLimit;
1421 }
1422 }
1423
1424 nbr_of_color = (1 << Pdepth);
1425 color_limit = 0;
1426
1427 /* parse the color limit env variable */
1428 if ((envp = getenv("FVWM_COLORLIMIT")) != NULL)
1429 {
1430 char *rest, *l;
1431
1432 rest = GetQuotedString(envp, &l, ":", NULL, NULL, NULL);
1433 if (l && *l != '\0' && (color_limit = atoi(l)) >= 0)
1434 {
1435 use_default = 0;
1436 }
1437 if (l != NULL)
1438 {
1439 free(l);
1440 }
1441 if (color_limit == 9 || color_limit == 61)
1442 {
1443 use_named_table = 1;
1444 }
1445 if (rest && *rest != '\0')
1446 {
1447 if (rest[0] == '1')
1448 {
1449 strict_cl_set = True;
1450 PStrictColorLimit = 1;
1451 }
1452 else
1453 {
1454 strict_cl_set = True;
1455 PStrictColorLimit = 0;
1456 }
1457 if (strlen(rest) > 1 && rest[1] == '1')
1458 {
1459 use_named_table = 1;
1460 }
1461 else
1462 {
1463 use_named_table = 0;
1464 }
1465 if (strlen(rest) > 2 && rest[2] == '1')
1466 {
1467 dyn_cl_set = True;
1468 PUseDynamicColors = 1;
1469 }
1470 else
1471 {
1472 dyn_cl_set = True;
1473 PUseDynamicColors = 0;
1474 }
1475 if (strlen(rest) > 3 && rest[3] == '1')
1476 {
1477 alloc_table_set = True;
1478 PAllocTable = 1;
1479 }
1480 else
1481 {
1482 alloc_table_set = True;
1483 PAllocTable = 0;
1484 }
1485 }
1486 }
1487 else if (opt != NULL) /* use the option */
1488 {
1489 if (opt->color_limit > 0)
1490 {
1491 use_default = 0;
1492 color_limit = opt->color_limit;
1493 }
1494 if (color_limit == 9 || color_limit == 61)
1495 {
1496 use_named_table = 1;
1497 }
1498 if (opt->strict > 0)
1499 {
1500 strict_cl_set = True;
1501 PStrictColorLimit = 1;
1502 }
1503 else if (opt->strict == 0)
1504 {
1505 strict_cl_set = True;
1506 PStrictColorLimit = 0;
1507 }
1508 if (opt->use_named_table > 0)
1509 {
1510 use_named_table = 1;
1511 }
1512 else if (opt->use_named_table == 0)
1513 {
1514 use_named_table = 0;
1515 }
1516 if (opt->not_dynamic > 0)
1517 {
1518 dyn_cl_set = True;
1519 PUseDynamicColors = 0;
1520 }
1521 else if (opt->not_dynamic == 0)
1522 {
1523 dyn_cl_set = True;
1524 PUseDynamicColors = 0;
1525 }
1526 if (opt->allocate > 0)
1527 {
1528 alloc_table_set = True;
1529 PAllocTable = 1;
1530 }
1531 else if (opt->allocate == 0)
1532 {
1533 alloc_table_set = True;
1534 PAllocTable = 0;
1535 }
1536 }
1537
1538 if (color_limit <= 0)
1539 {
1540 use_default = 1;
1541 color_limit = nbr_of_color;
1542 }
1543
1544 /* first try to see if we have a "pre-allocated" color cube.
1545 * The bultin RENDER X extension pre-allocate a color cube plus
1546 * some grey's (xc/programs/Xserver/render/miindex)
1547 * See gdk/gdkrgb.c for the cubes used by gtk+-2, 666 is the default,
1548 * 555 is the minimal cc (this may change): if gtk cannot allocate
1549 * the 555 cc (or better) a private cmap is used.
1550 * for qt-3: see src/kernel/{qapplication.cpp,qimage.cpp,qcolor_x11.c}
1551 * the 666 cube is used by default (with approx in the cmap if some
1552 * color allocation fail), and some qt app may accept an
1553 * --ncols option to limit the nbr of colors, then some "2:3:1"
1554 * proportions color cube are used (222, 232, ..., 252, 342, ..., 362,
1555 * 452, ...,693, ...)
1556 * imlib2 try to allocate the 666 cube if this fail it try more
1557 * exotic table (see rend.c and rgba.c) */
1558 i = 0;
1559 free_colors = 0;
1560 if (Pdepth <= 8 && !private_cmap && use_default &&
1561 i < cc_nbr && Pct == NULL && (Pvisual->class & 1))
1562 {
1563 free_colors = get_nbr_of_free_colors(nbr_of_color);
1564 }
1565 while(Pdepth <= 8 && !private_cmap && use_default &&
1566 i < cc_nbr && Pct == NULL && (Pvisual->class & 1))
1567 {
1568 size = cc[i][0]*cc[i][1]*cc[i][2] + cc[i][3] - 2*(cc[i][3] > 0) +
1569 (1 << cc[i][4])*(cc[i][4] != 0);
1570 if (size > nbr_of_color || !(cc[i][5] & pa_type))
1571 {
1572 i++;
1573 continue;
1574 }
1575 if (free_colors <= nbr_of_color - size)
1576 {
1577 Pct = alloc_color_cube(
1578 cc[i][0], cc[i][1], cc[i][2], cc[i][3], cc[i][4],
1579 True);
1580 }
1581 if (Pct != NULL)
1582 {
1583 if (free_colors <=
1584 get_nbr_of_free_colors(nbr_of_color))
1585 {
1586 /* done */
1587 }
1588 else
1589 {
1590 free_table_colors(Pct, PColorLimit);
1591 free(Pct);
1592 Pct = NULL;
1593 }
1594 }
1595 i++;
1596 }
1597 if (Pct != NULL)
1598 {
1599 PUseDynamicColors = 0;
1600 PAllocTable = 1;
1601 Pcsi.pre_allocated_pallet = 1;
1602 i = i - 1;
1603 finish_ct_init(
1604 call_type, i, cc[i][0], cc[i][1], cc[i][2], cc[i][3],
1605 cc[i][4], 0);
1606 return PColorLimit;
1607 }
1608
1609 /*
1610 * now use "our" table
1611 */
1612
1613 limit = (color_limit >= nbr_of_color)? nbr_of_color:color_limit;
1614
1615 if (use_default && !private_cmap)
1616 {
1617 /* XRender cvs default: */
1618 #if 0
1619 if (limit > 100)
1620 limit = nbr_of_color/3;
1621 else
1622 limit = nbr_of_color/2;
1623 /* depth 8: 85 */
1624 /* depth 4: 8 */
1625 #endif
1626 if (limit > 256)
1627 {
1628 /* direct colors & Pdepth > 8 */
1629 if (Pdepth >= 16)
1630 {
1631 limit = 8192;
1632 }
1633 else if (Pdepth >= 15)
1634 {
1635 limit = 4096;
1636 }
1637 else
1638 {
1639 limit = 512;
1640 }
1641 }
1642 else if (limit == 256)
1643 {
1644 if (Pvisual->class == GrayScale)
1645 {
1646 limit = 64;
1647 }
1648 else if (Pvisual->class == DirectColor)
1649 {
1650 limit = 32;
1651 }
1652 else
1653 {
1654 limit = 68;
1655 /* candidate:
1656 * limit = 54; 4x4x3 + 6 grey
1657 * limit = 61 (named table)
1658 * limit = 85 current XRender default 4cc + 21
1659 * limit = 76 future(?) XRender default 4cc + 16
1660 * limit = 68 4x4x4 + 4
1661 * limit = 64 4x4x4 + 0 */
1662 }
1663
1664 }
1665 else if (limit == 128 || limit == 64)
1666 {
1667 if (Pvisual->class == GrayScale)
1668 {
1669 limit = 32;
1670 }
1671 else
1672 {
1673 limit = 31;
1674 }
1675 }
1676 else if (limit >= 16)
1677 {
1678 if (Pvisual->class == GrayScale)
1679 {
1680 limit = 8;
1681 }
1682 else
1683 {
1684 limit = 10;
1685 }
1686 }
1687 else if (limit >= 8)
1688 {
1689 limit = 4;
1690 }
1691 else
1692 {
1693 limit = 2;
1694 }
1695 }
1696 if (limit < 2)
1697 {
1698 limit = 2;
1699 }
1700
1701 if (Pvisual->class == DirectColor)
1702 {
1703 /* humm ... Any way this case should never happen in real life:
1704 * DirectColor default colormap! */
1705 PUseDynamicColors = 0;
1706 PAllocTable = 1;
1707 PStrictColorLimit = 1;
1708 }
1709 if (PAllocTable)
1710 {
1711 do_allocate = 1;
1712 }
1713 else
1714 {
1715 do_allocate = 0;
1716 }
1717
1718 /* use the named table ? */
1719 if (use_named_table)
1720 {
1721 i = limit;
1722 while(Pct == NULL && i >= 2)
1723 {
1724 Pct = alloc_named_ct(&i, do_allocate);
1725 i--;
1726 }
1727 }
1728 if (Pct != NULL)
1729 {
1730 finish_ct_init(
1731 call_type, PColorLimit, 0, 0, 0, 0, 0, 1);
1732 return PColorLimit;
1733 }
1734
1735 /* color cube or regular grey scale */
1736 i = 0;
1737 while(i < cc_nbr && Pct == NULL)
1738 {
1739 if ((cc[i][5] & fvwm_type) &&
1740 cc[i][0]*cc[i][1]*cc[i][2] + cc[i][3] - 2*(cc[i][3] > 0) +
1741 (1 << cc[i][4])*(cc[i][4] != 0) <= limit)
1742 {
1743 Pct = alloc_color_cube(
1744 cc[i][0], cc[i][1], cc[i][2], cc[i][3], cc[i][4],
1745 do_allocate);
1746 }
1747 i++;
1748 }
1749 if (Pct != NULL)
1750 {
1751 i = i-1;
1752 finish_ct_init(
1753 call_type, i, cc[i][0], cc[i][1], cc[i][2], cc[i][3],
1754 cc[i][4], 0);
1755 return PColorLimit;
1756 }
1757
1758 /* I do not think we can be here */
1759 Pct = alloc_color_cube(0, 0, 0, 0, 1, False);
1760 finish_ct_init(call_type, cc_nbr-1, 0, 0, 0, 0, 1, 0);
1761 if (Pct == NULL)
1762 {
1763 fprintf(stderr,
1764 "[FVWM] ERR -- Cannot get Black and White. exiting!\n");
1765 exit(2);
1766 }
1767 return PColorLimit;
1768 }
1769
1770 /* ***************************************************************************
1771 * Allocation of a private DirectColor cmap this is broken for depth > 16
1772 * ***************************************************************************/
1773 static
1774 Bool alloc_direct_colors(int *limit, Bool use_my_color_limit)
1775 {
1776 unsigned long nr,ng,nb,r,g,b,cr,cg,cf,pr,pg;
1777 unsigned long red_mask, green_mask, blue_mask;
1778 XColor *colors;
1779
1780 if (Pdepth <= 16)
1781 {
1782 red_mask = Pvisual->red_mask;
1783 green_mask = Pvisual->green_mask;
1784 blue_mask = Pvisual->blue_mask;
1785 }
1786 else
1787 {
1788 /* Use a standard depth 16 colormap. This is broken FIXME! */
1789 red_mask = 0xf800;
1790 green_mask = 0x7e0;
1791 blue_mask = 0x1f;
1792 }
1793
1794 decompose_mask(
1795 red_mask, &Pcsi.red_shift, &Pcsi.red_prec);
1796 decompose_mask(
1797 green_mask, &Pcsi.green_shift, &Pcsi.green_prec);
1798 decompose_mask(
1799 blue_mask, &Pcsi.blue_shift, &Pcsi.blue_prec);
1800
1801 if (!use_my_color_limit)
1802 {
1803 /* colors allocated by fvwm we can return */
1804 return 1;
1805 }
1806
1807 nr = 1 << Pcsi.red_prec;
1808 ng = 1 << Pcsi.green_prec;
1809 nb = 1 << Pcsi.blue_prec;
1810
1811 colors = (XColor *)safemalloc(nb*sizeof(XColor));
1812 cf = DoRed|DoBlue|DoGreen;
1813 for (r=0; r<nr; r++)
1814 {
1815 cr = r * 65535 / (nr - 1);
1816 pr = (cr >> (16 - Pcsi.red_prec)) << Pcsi.red_shift;
1817 for (g = 0; g < ng; g++)
1818 {
1819 cg = g * 65535 / (ng - 1);
1820 pg = (cg >> (16 - Pcsi.green_prec)) << Pcsi.green_shift;
1821 for (b = 0; b < nb; b++)
1822 {
1823 colors[b].flags = cf;
1824 colors[b].red = cr;
1825 colors[b].green = cg;
1826 colors[b].blue = b * 65535 / (nb - 1);
1827 colors[b].pixel =
1828 (Pixel)(pr + pg +
1829 ((colors[b].blue >>
1830 (16 - Pcsi.blue_prec)) <<
1831 Pcsi.blue_shift));
1832 }
1833 XStoreColors(Pdpy, Pcmap, colors, nb);
1834 }
1835 }
1836 free(colors);
1837 return 1;
1838 }
1839
1840 /* ***************************************************************************
1841 * Init the table for Static Colors
1842 * ***************************************************************************/
1843 static
1844 void init_static_colors_table(void)
1845 {
1846 XColor colors[256];
1847 int i;
1848 int nbr_of_colors = max(256, (1 << Pdepth));
1849
1850 PColorLimit = nbr_of_colors;
1851 Pct = (PColor *)safemalloc((nbr_of_colors+1) * sizeof(PColor));
1852 for (i = 0; i < nbr_of_colors; i++)
1853 {
1854 colors[i].pixel = Pct[i].color.pixel = i;
1855 }
1856 XQueryColors(Pdpy, Pcmap, colors, nbr_of_colors);
1857 for (i = 0; i < nbr_of_colors; i++)
1858 {
1859 Pct[i].color.red = colors[i].red;
1860 Pct[i].color.green = colors[i].green;
1861 Pct[i].color.blue = colors[i].blue;
1862 Pct[i].alloc_count = 1;
1863 }
1864 Pct[PColorLimit].color.red = Pct[PColorLimit-1].color.red;
1865 Pct[PColorLimit].color.green = Pct[PColorLimit-1].color.green;
1866 Pct[PColorLimit].color.blue = Pct[PColorLimit-1].color.blue;
1867 Pct[PColorLimit].alloc_count = 1;
1868 create_mapping_table(0, 0, 0, 0, 0, True);
1869 }
1870
1871
1872 /* ***************************************************************************
1873 * misc local functions
1874 * ***************************************************************************/
1875 static
1876 void print_colormap(Colormap cmap)
1877 {
1878 XColor colors[256];
1879 int i;
1880 int nbr_of_colors = max(256, (1 << Pdepth));
1881 for (i = 0; i < nbr_of_colors; i++)
1882 {
1883 colors[i].pixel = i;
1884 }
1885 XQueryColors(Pdpy, cmap, colors, nbr_of_colors);
1886 for (i = 0; i < nbr_of_colors; i++)
1887 {
1888 fprintf(stderr," rgb(%.3i): %.3i/%.3i/%.3i\n", i,
1889 colors[i].red >> 8,
1890 colors[i].green >> 8,
1891 colors[i].blue >> 8);
1892 }
1893 }
1894
1895 /* ---------------------------- interface functions ------------------------- */
1896
1897 int PictureAllocColor(Display *dpy, Colormap cmap, XColor *c, int no_limit)
1898 {
1899 if (PStrictColorLimit && Pct != NULL)
1900 {
1901 no_limit = 0;
1902 }
1903
1904 if (no_limit)
1905 {
1906 return Pcsi.alloc_color_no_limit(dpy, cmap, c);
1907 }
1908 else
1909 {
1910 return Pcsi.alloc_color(dpy, cmap, c);
1911 }
1912 return 0;
1913 }
1914
1915
1916 int PictureAllocColorAllProp(
1917 Display *dpy, Colormap cmap, XColor *c, int x, int y,
1918 Bool no_limit, Bool is_8, Bool do_dither)
1919 {
1920
1921 if (!no_limit && do_dither && Pcsi.alloc_color_dither != NULL)
1922 {
1923 if (!is_8)
1924 {
1925 c->red = c->red >> 8;
1926 c->green = c->green >> 8;
1927 c->blue = c->blue >> 8;
1928 }
1929 return Pcsi.alloc_color_dither(dpy, cmap, c, x, y);
1930 }
1931 else
1932 {
1933 if (is_8)
1934 {
1935 c->red = c->red << 8;
1936 c->green = c->green << 8;
1937 c->blue = c->blue << 8;
1938 }
1939 return PictureAllocColor(dpy, cmap, c, False);
1940 }
1941 return 0;
1942 }
1943
1944 int PictureAllocColorImage(
1945 Display *dpy, PictureImageColorAllocator *pica, XColor *c, int x, int y)
1946 {
1947 int r;
1948
1949 r = PictureAllocColorAllProp(
1950 dpy, pica->cmap, c, x, y,
1951 pica->no_limit, pica->is_8, pica->dither);
1952 if (r && pica->pixels_table != NULL && pica->pixels_table_size &&
1953 c->pixel < pica->pixels_table_size)
1954 {
1955 pica->pixels_table[c->pixel]++;
1956 }
1957 return r;
1958 }
1959
1960 PictureImageColorAllocator *PictureOpenImageColorAllocator(
1961 Display *dpy, Colormap cmap, int x, int y, Bool no_limit,
1962 Bool do_not_save_pixels, int dither, Bool is_8)
1963 {
1964 PictureImageColorAllocator *pica;
1965 Bool do_save_pixels = False;
1966
1967 pica = (PictureImageColorAllocator *)safemalloc(
1968 sizeof(PictureImageColorAllocator));
1969 if (Pdepth <= 8 && !do_not_save_pixels && (Pvisual->class & 1) &&
1970 ((PUseDynamicColors && Pct) || no_limit))
1971 {
1972 int s = 1 << Pdepth;
1973 pica->pixels_table = (unsigned long *)safecalloc(
1974 s, sizeof(unsigned long));
1975 pica->pixels_table_size = s;
1976 do_save_pixels = True;
1977 }
1978 if (!do_save_pixels)
1979 {
1980 pica->pixels_table = NULL;
1981 pica->pixels_table_size = 0;
1982 }
1983 pica->is_8 = is_8;
1984 if (dither && Pdepth <= 16)
1985 {
1986 pica->dither = dither;
1987 }
1988 else
1989 {
1990 pica->dither = dither;
1991 }
1992 pica->no_limit = no_limit;
1993 pica->cmap = cmap;
1994 return pica;
1995 }
1996
1997 void PictureCloseImageColorAllocator(
1998 Display *dpy, PictureImageColorAllocator *pica, int *nalloc_pixels,
1999 Pixel **alloc_pixels, Bool *no_limit)
2000 {
2001 if (nalloc_pixels)
2002 {
2003 *nalloc_pixels = 0;
2004 }
2005 if (alloc_pixels != NULL)
2006 {
2007 *alloc_pixels = NULL;
2008 }
2009 if (no_limit != NULL)
2010 {
2011 *no_limit = 0;
2012 }
2013 if (pica->pixels_table)
2014 {
2015 int i,j;
2016 int k = 0, l = 0, np = 0;
2017 int free_num = 0;
2018 Pixel *free_pixels = NULL;
2019 Pixel *save_pixels = NULL;
2020
2021 for(i = 0; i < pica->pixels_table_size; i++)
2022 {
2023 if (pica->pixels_table[i])
2024 {
2025 free_num += (pica->pixels_table[i]-1);
2026 np++;
2027 }
2028 }
2029 if (free_num)
2030 {
2031 free_pixels = (Pixel *)safemalloc(
2032 free_num * sizeof(Pixel));
2033 }
2034 if (np && nalloc_pixels != NULL && alloc_pixels != NULL)
2035 {
2036 save_pixels = (Pixel *)safemalloc(np * sizeof(Pixel));
2037 }
2038 for(i = 0; i < pica->pixels_table_size; i++)
2039 {
2040 if (pica->pixels_table[i])
2041 {
2042 if (save_pixels)
2043 {
2044 save_pixels[k++] = i;
2045 }
2046 for(j=1; j < pica->pixels_table[i]; j++)
2047 {
2048 free_pixels[l++] = i;
2049 }
2050 }
2051 }
2052 if (free_num)
2053 {
2054 PictureFreeColors(
2055 dpy, pica->cmap, free_pixels, free_num, 0,
2056 pica->no_limit);
2057 free(free_pixels);
2058 }
2059 if (nalloc_pixels != NULL && alloc_pixels != NULL)
2060 {
2061 *nalloc_pixels = np;
2062 *alloc_pixels = save_pixels;
2063 if (no_limit != NULL)
2064 {
2065 *no_limit = pica->no_limit;
2066 }
2067 }
2068 else if (save_pixels)
2069 {
2070 free(save_pixels);
2071 }
2072 free(pica->pixels_table);
2073 }
2074 free(pica);
2075 return;
2076 }
2077
2078 void PictureFreeColors(
2079 Display *dpy, Colormap cmap, Pixel *pixels, int n, unsigned long planes,
2080 Bool no_limit)
2081 {
2082 if (no_limit)
2083 {
2084 if (Pcsi.free_colors_no_limit != NULL)
2085 {
2086 Pcsi.free_colors_no_limit(
2087 dpy, cmap, pixels, n, planes);
2088 }
2089 }
2090 else
2091 {
2092 if (Pcsi.free_colors != NULL)
2093 {
2094 Pcsi.free_colors(dpy, cmap, pixels, n, planes);
2095 }
2096 }
2097 return;
2098 }
2099
2100 Pixel PictureGetNextColor(Pixel p, int n)
2101 {
2102 int i;
2103 XColor c;
2104
2105 if (n >= 0)
2106 n = 1;
2107 else
2108 n = -1;
2109
2110 if (Pct == NULL)
2111 {
2112 return p;
2113 }
2114 for(i=0; i<PColorLimit; i++)
2115 {
2116 if (Pct[i].color.pixel == p)
2117 {
2118 if (i == 0 && n < 0)
2119 {
2120 c = Pct[PColorLimit-1].color;
2121 alloc_color_in_pct(&c, PColorLimit-1);
2122 return Pct[PColorLimit-1].color.pixel;
2123 }
2124 else if (i == PColorLimit-1 && n > 0)
2125 {
2126 c = Pct[0].color;
2127 alloc_color_in_pct(&c, 0);
2128 return Pct[0].color.pixel;
2129 }
2130 else
2131 {
2132 c = Pct[i+n].color;
2133 alloc_color_in_pct(&c, i+n);
2134 return Pct[i+n].color.pixel;
2135 }
2136 }
2137 }
2138 return p;
2139 }
2140
2141 /* Replace the color in my_color by the closest matching color
2142 from base_table */
2143 void PictureReduceColorName(char **my_color)
2144 {
2145 int index;
2146 XColor rgb; /* place to calc rgb for each color in xpm */
2147
2148 if (!XpmSupport)
2149 return;
2150
2151 if (!strcasecmp(*my_color,"none")) {
2152 return; /* do not substitute the "none" color */
2153 }
2154
2155 if (!XParseColor(Pdpy, Pcmap, *my_color, &rgb))
2156 {
2157 fprintf(stderr,"color_to_rgb: can't parse color %s\n",
2158 *my_color);
2159 }
2160 index = get_color_index(rgb.red,rgb.green,rgb.blue, False);
2161 /* Finally: replace the color string by the newly determined color
2162 * string */
2163 free(*my_color); /* free old color */
2164 /* area for new color */
2165 *my_color = safemalloc(8);
2166 sprintf(*my_color,"#%x%x%x",
2167 Pct[index].color.red >> 8,
2168 Pct[index].color.green >> 8,
2169 Pct[index].color.blue >> 8); /* put it there */
2170 return;
2171 }
2172
2173 Bool PictureDitherByDefault(void)
2174 {
2175 if (Pct != NULL)
2176 {
2177 return True;
2178 }
2179 return False;
2180 }
2181
2182 Bool PictureUseBWOnly(void)
2183 {
2184 if (Pdepth < 2 || (PStrictColorLimit && PColorLimit == 2))
2185 {
2186 return True;
2187 }
2188 return False;
2189 }
2190
2191 int PictureInitColors(
2192 int call_type, Bool init_color_limit, PictureColorLimitOption *opt,
2193 Bool use_my_color_limit, Bool init_dither)
2194 {
2195 Bool dither_ok = False;
2196
2197 switch (Pvisual->class)
2198 {
2199 case DirectColor:
2200 /* direct colors is more or less broken */
2201 decompose_mask(
2202 Pvisual->red_mask, &Pcsi.red_shift,
2203 &Pcsi.red_prec);
2204 decompose_mask(
2205 Pvisual->green_mask, &Pcsi.green_shift,
2206 &Pcsi.green_prec);
2207 decompose_mask(
2208 Pvisual->blue_mask, &Pcsi.blue_shift,
2209 &Pcsi.blue_prec);
2210 Pcsi.alloc_color_no_limit = alloc_color_proportion;
2211 Pcsi.alloc_color = alloc_color_proportion;
2212 Pcsi.alloc_color_dither = alloc_color_proportion_dither;
2213 Pcsi.free_colors_no_limit = NULL;
2214 Pcsi.free_colors = NULL;
2215 PColorLimit = 0;
2216 break;
2217 case TrueColor:
2218 decompose_mask(
2219 Pvisual->red_mask, &Pcsi.red_shift,
2220 &Pcsi.red_prec);
2221 decompose_mask(
2222 Pvisual->green_mask, &Pcsi.green_shift,
2223 &Pcsi.green_prec);
2224 decompose_mask(
2225 Pvisual->blue_mask, &Pcsi.blue_shift,
2226 &Pcsi.blue_prec);
2227 Pcsi.alloc_color_no_limit = alloc_color_proportion;
2228 Pcsi.alloc_color = alloc_color_proportion;
2229 Pcsi.free_colors_no_limit = NULL;
2230 Pcsi.free_colors = NULL;
2231 PColorLimit = 0;
2232 if (init_dither && (Pdepth == 15 || Pdepth == 16))
2233 {
2234 dither_ok = my_dither_depth_15_16_init();
2235 }
2236 if (dither_ok)
2237 {
2238 Pcsi.alloc_color_dither = alloc_color_proportion_dither;
2239 }
2240 else
2241 {
2242 Pcsi.alloc_color_dither = NULL;
2243 }
2244 break;
2245 case StaticColor:
2246 if (0 && Pvisual->red_mask != 0 && Pvisual->green_mask != 0 &&
2247 Pvisual->blue_mask != 0)
2248 {
2249 decompose_mask(
2250 Pvisual->red_mask, &Pcsi.red_shift,
2251 &Pcsi.red_prec);
2252 decompose_mask(
2253 Pvisual->green_mask, &Pcsi.green_shift,
2254 &Pcsi.green_prec);
2255 decompose_mask(
2256 Pvisual->blue_mask, &Pcsi.blue_shift,
2257 &Pcsi.blue_prec);
2258 Pcsi.alloc_color_no_limit = alloc_color_proportion;
2259 Pcsi.alloc_color = alloc_color_proportion;
2260 PColorLimit = 0;
2261 }
2262 else
2263 {
2264 if (init_color_limit)
2265 {
2266 Pcsi.alloc_color = alloc_color_in_table;
2267 Pcsi.alloc_color_dither =
2268 alloc_color_in_table_dither;
2269 Pcsi.alloc_color_no_limit = alloc_color_x;
2270 init_static_colors_table();
2271 }
2272 else
2273 {
2274 Pcsi.alloc_color = alloc_color_x;
2275 Pcsi.alloc_color_dither = NULL;
2276 Pcsi.alloc_color_no_limit = alloc_color_x;
2277 }
2278 }
2279 Pcsi.free_colors_no_limit = NULL;
2280 Pcsi.free_colors = NULL;
2281 break;
2282 case StaticGray:
2283 /* FIXME: we assume that we have a regular grey ramp */
2284 if (0)
2285 {
2286 Pcsi.alloc_color_no_limit = alloc_color_proportion_grey;
2287 Pcsi.alloc_color = alloc_color_proportion;
2288 PColorLimit = 0;
2289 }
2290 else
2291 {
2292 if (init_color_limit)
2293 {
2294 Pcsi.alloc_color = alloc_color_in_table;
2295 Pcsi.alloc_color_dither =
2296 alloc_color_in_table_dither;
2297 Pcsi.alloc_color_no_limit = alloc_color_x;
2298 init_static_colors_table();
2299 }
2300 else
2301 {
2302 Pcsi.alloc_color = alloc_color_x;
2303 Pcsi.alloc_color_dither = NULL;
2304 Pcsi.alloc_color_no_limit = alloc_color_x;
2305 }
2306 }
2307 Pcsi.free_colors_no_limit = NULL;
2308 Pcsi.free_colors = NULL;
2309 break;
2310 case PseudoColor:
2311 case GrayScale:
2312 default:
2313 Pcsi.alloc_color_no_limit = alloc_color_dynamic_no_limit;
2314 Pcsi.free_colors_no_limit = free_colors_x;
2315 break;
2316 }
2317
2318 if (!(Pvisual->class & 1))
2319 {
2320 /* static classes */
2321 PUseDynamicColors = 0;
2322 if (call_type == PICTURE_CALLED_BY_FVWM &&
2323 getenv("FVWM_COLORTABLE_TYPE") != NULL)
2324 {
2325 putenv("FVWM_COLORTABLE_TYPE=");
2326 }
2327 return PColorLimit;
2328 }
2329
2330 /* dynamic classes */
2331
2332 if (!Pdefault && Pvisual->class == DirectColor)
2333 {
2334 PColorLimit = 0;
2335 PUseDynamicColors = 0;
2336 alloc_direct_colors(0, use_my_color_limit);
2337 if (call_type == PICTURE_CALLED_BY_FVWM &&
2338 getenv("FVWM_COLORTABLE_TYPE") != NULL)
2339 {
2340 putenv("FVWM_COLORTABLE_TYPE=");
2341 }
2342 return 0;
2343 }
2344
2345
2346 if (init_color_limit)
2347 {
2348 Pcsi.alloc_color = alloc_color_in_table;
2349 Pcsi.alloc_color_dither = alloc_color_in_table_dither;
2350 PictureAllocColorTable(opt, call_type, use_my_color_limit);
2351 if (PUseDynamicColors)
2352 {
2353 Pcsi.free_colors = free_colors_in_table;
2354 }
2355 else
2356 {
2357 Pcsi.free_colors = NULL;
2358 }
2359 }
2360 else
2361 {
2362 Pcsi.alloc_color = alloc_color_dynamic_no_limit;
2363 Pcsi.free_colors = free_colors_x;
2364 Pcsi.alloc_color_dither = NULL;
2365 }
2366 return PColorLimit;
2367 }
2368
2369 void PicturePrintColorInfo(int verbose)
2370 {
2371 unsigned long nbr_of_colors = 1 << Pdepth;
2372
2373 fprintf(stderr, "FVWM info on colors\n");
2374 fprintf(stderr, " Visual ID: 0x%x, Default?: %s, Class: ",
2375 (int)(Pvisual->visualid),
2376 (Pdefault)? "Yes":"No");
2377 if (Pvisual->class == TrueColor)
2378 {
2379 fprintf(stderr,"TrueColor");
2380 }
2381 else if (Pvisual->class == PseudoColor)
2382 {
2383 fprintf(stderr,"PseudoColor");
2384 }
2385 else if (Pvisual->class == DirectColor)
2386 {
2387 fprintf(stderr,"DirectColor");
2388 }
2389 else if (Pvisual->class == StaticColor)
2390 {
2391 fprintf(stderr,"StaticColor");
2392 }
2393 else if (Pvisual->class == GrayScale)
2394 {
2395 fprintf(stderr,"GrayScale");
2396 }
2397 else if (Pvisual->class == StaticGray)
2398 {
2399 fprintf(stderr,"StaticGray");
2400 }
2401 fprintf(stderr, "\n");
2402 fprintf(stderr, " Depth: %i, Number of colors: %lu",
2403 Pdepth, (unsigned long)nbr_of_colors);
2404 if (Pct != NULL)
2405 {
2406 fprintf(stderr,"\n Pallet with %i colors", PColorLimit);
2407 if (Pvisual->class & 1)
2408 {
2409 fprintf(stderr,", Number of free colors: %i\n",
2410 get_nbr_of_free_colors((1 << Pdepth)));
2411 fprintf(stderr,
2412 " Auto Detected: %s, Strict: %s, Allocated: %s,"
2413 " Dynamic: %s\n",
2414 (Pcsi.pre_allocated_pallet)? "Yes":"No",
2415 (PStrictColorLimit)? "Yes":"No",
2416 (PAllocTable)? "Yes":"No",
2417 (PUseDynamicColors)? "Yes":"No");
2418 }
2419 else
2420 {
2421 fprintf(stderr," (default colormap)\n");
2422 }
2423 if (PColorLimit <= 256)
2424 {
2425 int i;
2426 int count = 0;
2427 int count_alloc = 0;
2428
2429 if (verbose)
2430 {
2431 fprintf(stderr," The fvwm colors table:\n");
2432 }
2433 for (i = 0; i < PColorLimit; i++)
2434 {
2435 if (verbose)
2436 {
2437 fprintf(
2438 stderr,
2439 " rgb:%.3i/%.3i/%.3i\t%lu\n",
2440 Pct[i].color.red >> 8,
2441 Pct[i].color.green >> 8,
2442 Pct[i].color.blue >> 8,
2443 Pct[i].alloc_count);
2444 }
2445 if (Pct[i].alloc_count)
2446 {
2447 count++;
2448 }
2449 }
2450 if ((Pvisual->class & 1) && Pac != NULL)
2451 {
2452 if (verbose)
2453 {
2454 fprintf(stderr," fvwm colors not in"
2455 " the table:\n");
2456 }
2457 for(i=0; i < nbr_of_colors; i++)
2458 {
2459 int j = 0;
2460 Bool found = False;
2461
2462 if (!Pac[i].alloc_count)
2463 continue;
2464 while(j < PColorLimit && !found)
2465 {
2466 if (i == Pct[j].color.pixel)
2467 {
2468 found = True;
2469 }
2470 j++;
2471 }
2472 if (found)
2473 continue;
2474 count_alloc++;
2475 if (verbose)
2476 {
2477 fprintf(
2478 stderr,
2479 " rgb:"
2480 "%.3i/%.3i/%.3i\t%lu\n",
2481 Pac[i].color.red >> 8,
2482 Pac[i].color.green >> 8,
2483 Pac[i].color.blue >> 8,
2484 Pac[i].alloc_count);
2485 }
2486 }
2487 if (verbose && count_alloc == 0)
2488 {
2489 if (verbose)
2490 {
2491 fprintf(stderr," None\n");
2492 }
2493 }
2494 }
2495 if (Pvisual->class & 1)
2496 {
2497 fprintf(stderr,
2498 " Number of colours used by fvwm:\n");
2499 fprintf(stderr,
2500 " In the table: %i\n", count);
2501 fprintf(
2502 stderr, " Out of the table: %i\n",
2503 count_alloc);
2504 fprintf(stderr,
2505 " Total: %i\n", count_alloc+count);
2506 }
2507 }
2508 }
2509 else
2510 {
2511 if (Pvisual->class == DirectColor)
2512 {
2513 fprintf(stderr, ", Pseudo Pallet with: %i colors\n",
2514 (1 << Pcsi.red_prec)*(1 << Pcsi.green_prec)*
2515 (1 << Pcsi.blue_prec));
2516 }
2517 else
2518 {
2519 fprintf(stderr, ", No Pallet (static colors)\n");
2520 }
2521 fprintf(stderr, " red: %i, green: %i, blue %i\n",
2522 1 << Pcsi.red_prec, 1 << Pcsi.green_prec,
2523 1 << Pcsi.blue_prec);
2524 if (verbose && Pdepth <= 8)
2525 {
2526 if (Pvisual->class == DirectColor)
2527 {
2528 fprintf(stderr, " Colormap:\n");
2529 }
2530 else
2531 {
2532 fprintf(stderr,
2533 " Static Colormap used by fvwm:\n");
2534 }
2535 print_colormap(Pcmap);
2536 }
2537 }
2538
2539 if (Pdepth <= 8 && verbose >= 2)
2540 {
2541 fprintf(stderr,"\n Default Colormap:\n");
2542 print_colormap(DefaultColormap(Pdpy,DefaultScreen(Pdpy)));
2543 }
2544 }
CVS import of FVWM to Git.