ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/rxvt-unicode/src/background.C
Revision: 1.17
Committed: Wed Dec 5 08:46:27 2007 UTC (16 years, 6 months ago) by ayin
Content type: text/plain
Branch: MAIN
Changes since 1.16: +19 -10 lines
Log Message:
Cosmetics.

File Contents

# User Rev Content
1 sasha 1.1 /*----------------------------------------------------------------------*
2 ayin 1.4 * File: background.C - former xpm.C
3 sasha 1.1 *----------------------------------------------------------------------*
4     *
5     * All portions of code are copyright by their respective author/s.
6     * Copyright (c) 2005-2006 Marc Lehmann <pcg@goof.com>
7     * Copyright (c) 2007 Sasha Vasko <sasha@aftercode.net>
8     *
9     * This program is free software; you can redistribute it and/or modify
10     * it under the terms of the GNU General Public License as published by
11     * the Free Software Foundation; either version 2 of the License, or
12     * (at your option) any later version.
13     *
14     * This program is distributed in the hope that it will be useful,
15     * but WITHOUT ANY WARRANTY; without even the implied warranty of
16     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17     * GNU General Public License for more details.
18     *
19     * You should have received a copy of the GNU General Public License
20     * along with this program; if not, write to the Free Software
21     * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22     *---------------------------------------------------------------------*/
23    
24     #include "../config.h" /* NECESSARY */
25     #include "rxvt.h" /* NECESSARY */
26    
27     #define DO_TIMING_TEST 0
28    
29     #if DO_TIMING_TEST
30     #define TIMING_TEST_START(id) \
31     struct timeval timing_test_##id##_stv;\
32     gettimeofday (&timing_test_##id##_stv, NULL);
33 ayin 1.10
34 sasha 1.1 #define TIMING_TEST_PRINT_RESULT(id) \
35     do{ struct timeval tv;gettimeofday (&tv, NULL); tv.tv_sec -= (timing_test_##id##_stv).tv_sec;\
36     fprintf (stderr, "%s: %s: %d: elapsed %ld usec\n", #id, __FILE__, __LINE__,\
37     tv.tv_sec * 1000000 + tv.tv_usec - (timing_test_##id##_stv).tv_usec);}while (0)
38    
39     #else
40     #define TIMING_TEST_START(id) do{}while (0)
41     #define TIMING_TEST_PRINT_RESULT(id) do{}while (0)
42     #endif
43    
44     /*
45     * Pixmap geometry string interpretation :
46     * Each geometry string contains zero or one scale/position
47     * adjustment and may optionally be followed by a colon and one or more
48     * colon-delimited pixmap operations.
49     * The following table shows the valid geometry strings and their
50     * affects on the background image :
51     *
52     * WxH+X+Y Set scaling to W% by H%, and position to X% by Y%.
53     * W and H are percentages of the terminal window size.
54     * X and Y are also percentages; e.g., +50+50 centers
55     * the image in the window.
56     * WxH+X Assumes Y == X
57     * WxH Assumes Y == X == 50 (centers the image)
58     * W+X+Y Assumes H == W
59     * W+X Assumes H == W and Y == X
60     * W Assumes H == W and Y == X == 50
61     *
62     * Adjusting position only :
63     * =+X+Y Set position to X% by Y% (absolute).
64     * =+X Set position to X% by X%.
65     * +X+Y Adjust position horizontally X% and vertically Y%
66     * from current position (relative).
67     * +X Adjust position horizontally X% and vertically X%
68     * from current position.
69     *
70     * Adjusting scale only :
71     * Wx0 Multiply horizontal scaling factor by W%
72     * 0xH Multiply vertical scaling factor by H%
73     * 0x0 No scaling (show image at normal size).
74     *
75     * Pixmap Operations : (should be prepended by a colon)
76     * tile Tile image. Scaling/position modifiers above will affect
77     * the tile size and origin.
78     * propscale When scaling, scale proportionally. That is, maintain the
79     * proper aspect ratio for the image. Any portion of the
80     * background not covered by the image is filled with the
81     * current background color.
82     * hscale Scale horizontally, tile vertically ?
83     * vscale Tile horizontally, scale vertically ?
84     * scale Scale both up and down
85     * auto Same as 100x100+50+50
86     */
87    
88     #ifdef HAVE_BG_PIXMAP
89 root 1.14 bgPixmap_t::bgPixmap_t ()
90 sasha 1.2 {
91     #ifdef HAVE_AFTERIMAGE
92     original_asim = NULL;
93     #endif
94     #ifdef BG_IMAGE_FROM_FILE
95     h_scale = v_scale = 0;
96     h_align = v_align = 0;
97     #endif
98     flags = 0;
99     pixmap = None;
100     }
101    
102 root 1.14 void
103     bgPixmap_t::destroy ()
104 sasha 1.11 {
105     #ifdef HAVE_AFTERIMAGE
106     if (original_asim)
107     safe_asimage_destroy (original_asim);
108     #endif
109 root 1.14
110 sasha 1.11 if (pixmap && target)
111     XFreePixmap (target->dpy, pixmap);
112     }
113 sasha 1.2
114 sasha 1.1 bool
115     bgPixmap_t::window_size_sensitive ()
116     {
117 sasha 1.13 # ifdef ENABLE_TRANSPARENCY
118     if (flags & isTransparent)
119     return true;
120     # endif
121    
122 sasha 1.2 # ifdef BG_IMAGE_FROM_FILE
123 sasha 1.1 # ifdef HAVE_AFTERIMAGE
124     if (original_asim != NULL)
125     # endif
126     {
127     if (h_scale != 0 || v_scale != 0
128     || h_align != 0 || v_align != 0)
129     return true;
130     }
131     # endif
132 sasha 1.13
133     return false;
134     }
135    
136     bool
137     bgPixmap_t::window_position_sensitive ()
138     {
139 sasha 1.1 # ifdef ENABLE_TRANSPARENCY
140     if (flags & isTransparent)
141     return true;
142     # endif
143 sasha 1.13
144     # ifdef BG_IMAGE_FROM_FILE
145     # ifdef HAVE_AFTERIMAGE
146     if (original_asim != NULL)
147     # endif
148     {
149     if (h_align == rootAlign || v_align == rootAlign)
150     return true;
151     }
152     # endif
153    
154 sasha 1.1 return false;
155 sasha 1.13 };
156 sasha 1.1
157     bool bgPixmap_t::need_client_side_rendering ()
158     {
159     # ifdef HAVE_AFTERIMAGE
160     if (original_asim != NULL)
161     return true;
162     # endif
163     # ifdef ENABLE_TRANSPARENCY
164     if (flags & isTransparent)
165     {
166 sasha 1.7 # ifdef HAVE_AFTERIMAGE // can't blur without libAI anyways
167     if ((flags & blurNeeded) && !(flags & blurServerSide))
168 ayin 1.8 return true;
169 sasha 1.7 # endif
170     if ((flags & tintNeeded) && !(flags & tintServerSide))
171     return true;
172 sasha 1.1 }
173     # endif
174     return false;
175     }
176    
177 sasha 1.2 # ifdef BG_IMAGE_FROM_FILE
178 sasha 1.1 static inline bool
179     check_set_scale_value (int geom_flags, int flag, unsigned int &scale, unsigned int new_value)
180     {
181     if (geom_flags & flag)
182     {
183     if (new_value > 1000)
184     new_value = 1000;
185     if (new_value != scale)
186     {
187     scale = new_value;
188     return true;
189     }
190     }
191     return false;
192     }
193    
194     static inline bool
195     check_set_align_value (int geom_flags, int flag, int &align, int new_value)
196     {
197     if (geom_flags & flag)
198     {
199 sasha 1.13 if (new_value != bgPixmap_t::rootAlign)
200     {
201     if (new_value < -100)
202     new_value = -100;
203     else if (new_value > 200)
204     new_value = 200;
205     }
206 sasha 1.1 if (new_value != align)
207     {
208     align = new_value;
209     return true;
210     }
211     }
212     return false;
213     }
214    
215     static inline int
216     make_align_position (int align, int window_size, int image_size)
217     {
218     int diff = window_size - image_size;
219     int smaller = MIN (image_size,window_size);
220    
221     if (align >= 0 && align <= 50)
222     return diff * align / 100;
223     else if (align > 50 && align <= 100)
224     return window_size - image_size - diff * (100 - align) / 100;
225     else if (align > 100 && align <= 200 )
226     return ((align - 100) * smaller / 100) + window_size - smaller;
227     else if (align > -100 && align < 0)
228     return ((align + 100) * smaller / 100) - image_size;
229     return 0;
230     }
231    
232     static inline int
233     make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)
234     {
235     int src_pos = 0;
236     dst_pos = 0;
237     dst_size = size;
238     if (pos < 0 && size > target_size)
239     {
240     src_pos = -pos;
241     dst_size += pos;
242     }
243     else if (pos > 0)
244     dst_pos = pos;
245    
246     if (dst_pos + dst_size > target_size)
247     dst_size = target_size - dst_pos;
248     return src_pos;
249     }
250    
251     bool
252     bgPixmap_t::set_geometry (const char *geom)
253     {
254     int geom_flags = 0, changed = 0;
255     int x = 0, y = 0;
256     unsigned int w = 0, h = 0;
257     unsigned int n;
258     unsigned long new_flags = (flags & (~geometryFlags));
259     char *p;
260     # define MAXLEN_GEOM 256 /* could be longer then regular geometry string */
261    
262     if (geom == NULL)
263     return false;
264    
265     char str[MAXLEN_GEOM];
266    
267     while (isspace(*geom)) ++geom;
268     if ((p = strchr (geom, ';')) == NULL)
269     p = strchr (geom, '\0');
270    
271     n = (p - geom);
272     if (n < MAXLEN_GEOM)
273     {
274     char *ops;
275     new_flags |= geometrySet;
276    
277     strncpy (str, geom, n);
278     str[n] = '\0';
279     if (str[0] == ':')
280     ops = &str[0];
281     else if (str[0] != 'x' && str[0] != 'X' && isalpha(str[0]))
282     ops = &str[0];
283     else
284     {
285     char *tmp;
286     ops = strchr (str, ':');
287     if (ops != NULL)
288     {
289     for (tmp = ops-1; tmp >= str && isspace(*tmp); --tmp);
290     *(++tmp) = '\0';
291     if (ops == tmp) ++ops;
292     }
293     }
294    
295     if (ops > str || ops == NULL)
296     {
297     /* we have geometry string - let's handle it prior to applying ops */
298     geom_flags = XParseGeometry (str, &x, &y, &w, &h);
299    
300     if ((geom_flags & XValue) && !(geom_flags & YValue))
301     {
302     y = x;
303     geom_flags |= YValue;
304     }
305    
306     if (flags & geometrySet)
307 ayin 1.17 {
308     /* new geometry is an adjustment to the old one ! */
309 sasha 1.1 if ((geom_flags & WidthValue) && (geom_flags & HeightValue))
310     {
311     if (w == 0 && h != 0)
312     {
313     w = h_scale;
314     h = (v_scale * h) / 100;
315     }
316     else if (h == 0 && w != 0)
317     {
318     w = (h_scale * w) / 100;
319     h = v_scale;
320     }
321     }
322     if (geom_flags & XValue)
323     {
324     if (str[0] != '=')
325     {
326     y += v_align;
327     x += h_align;
328     }
329     }
330     }
331     else /* setting up geometry from scratch */
332     {
333     if (!(geom_flags & XValue))
334 ayin 1.17 {
335     /* use default geometry - centered */
336 sasha 1.1 x = y = defaultAlign;
337     }
338     else if (!(geom_flags & YValue))
339     y = x;
340    
341     if ((geom_flags & (WidthValue|HeightValue)) == 0)
342 ayin 1.17 {
343     /* use default geometry - scaled */
344 sasha 1.1 w = h = defaultScale;
345     }
346     else if (geom_flags & WidthValue)
347     {
348     if (!(geom_flags & HeightValue))
349     h = w;
350     }
351     else
352     w = h;
353     }
354     } /* done parsing geometry string */
355     else if (!(flags & geometrySet))
356 ayin 1.16 {
357     /* default geometry - scaled and centered */
358 sasha 1.1 x = y = defaultAlign;
359     w = h = defaultScale;
360     }
361 ayin 1.10
362 sasha 1.1 if (!(flags & geometrySet))
363     geom_flags |= WidthValue|HeightValue|XValue|YValue;
364    
365     if (ops)
366     {
367     while (*ops)
368     {
369     while (*ops == ':' || isspace(*ops)) ++ops;
370     # define CHECK_GEOM_OPS(op_str) (strncasecmp (ops, (op_str), sizeof(op_str)-1) == 0)
371     if (CHECK_GEOM_OPS("tile"))
372     {
373 sasha 1.13 w = h = noScale;
374 sasha 1.1 geom_flags |= WidthValue|HeightValue;
375     }
376     else if (CHECK_GEOM_OPS("propscale"))
377     {
378     if (w == 0 && h == 0)
379     {
380 sasha 1.13 w = windowScale;
381 sasha 1.1 geom_flags |= WidthValue;
382     }
383     new_flags |= propScale;
384     }
385     else if (CHECK_GEOM_OPS("hscale"))
386     {
387     if (w == 0)
388 sasha 1.13 w = windowScale;
389     h = noScale;
390 sasha 1.1 geom_flags |= WidthValue|HeightValue;
391     }
392     else if (CHECK_GEOM_OPS("vscale"))
393     {
394     if (h == 0)
395 sasha 1.13 h = windowScale;
396     w = noScale;
397 sasha 1.1 geom_flags |= WidthValue|HeightValue;
398     }
399     else if (CHECK_GEOM_OPS("scale"))
400     {
401     if (h == 0)
402 sasha 1.13 h = windowScale;
403 sasha 1.1 if (w == 0)
404 sasha 1.13 w = windowScale;
405 sasha 1.1 geom_flags |= WidthValue|HeightValue;
406     }
407     else if (CHECK_GEOM_OPS("auto"))
408     {
409 sasha 1.13 w = h = windowScale;
410     x = y = centerAlign;
411     geom_flags |= WidthValue|HeightValue|XValue|YValue;
412     }
413     else if (CHECK_GEOM_OPS("root"))
414     {
415     w = h = noScale;
416     x = y = rootAlign;
417 sasha 1.1 geom_flags |= WidthValue|HeightValue|XValue|YValue;
418     }
419     # undef CHECK_GEOM_OPS
420     while (*ops != ':' && *ops != '\0') ++ops;
421     } /* done parsing ops */
422     }
423    
424     if (check_set_scale_value (geom_flags, WidthValue, h_scale, w))
425     ++changed;
426     if (check_set_scale_value (geom_flags, HeightValue, v_scale, h))
427     ++changed;
428     if (check_set_align_value (geom_flags, XValue, h_align, x))
429     ++changed;
430     if (check_set_align_value (geom_flags, YValue, v_align, y))
431     ++changed;
432     }
433    
434     if (new_flags != flags)
435     {
436     flags = new_flags;
437     changed++;
438     }
439     //fprintf( stderr, "flags = %lX, scale = %ux%u, align=%+d%+d\n",
440     // flags, h_scale, v_scale, h_align, v_align);
441     return (changed > 0);
442     }
443    
444     # ifdef HAVE_AFTERIMAGE
445     bool
446     bgPixmap_t::render_asim (ASImage *background, ARGB32 background_tint)
447     {
448     if (target == NULL)
449     return false;
450    
451     int target_width = (int)target->szHint.width;
452     int target_height = (int)target->szHint.height;
453     int new_pmap_width = target_width, new_pmap_height = target_height;
454     ASImage *result = NULL;
455    
456     int x = 0;
457     int y = 0;
458     int w = h_scale * target_width / 100;
459     int h = v_scale * target_height / 100;
460    
461     TIMING_TEST_START (asim);
462    
463     if (original_asim)
464     {
465 sasha 1.13 if (h_align == rootAlign || v_align == rootAlign)
466     {
467     target->get_window_origin(x, y);
468     x = -x;
469     y = -y;
470     }
471     if (h_align != rootAlign)
472     x = make_align_position (h_align, target_width, w > 0 ? w : (int)original_asim->width);
473     if (v_align != rootAlign)
474     y = make_align_position (v_align, target_height, h > 0 ? h : (int)original_asim->height);
475 sasha 1.1 }
476    
477     if (original_asim == NULL
478     || x >= target_width
479     || y >= target_height
480     || (w > 0 && x + w <= 0)
481     || (h > 0 && y + h <= 0))
482     {
483     if (background)
484     {
485     new_pmap_width = background->width;
486     new_pmap_height = background->height;
487     result = background;
488     if (background_tint != TINT_LEAVE_SAME)
489     {
490     ASImage* tmp = tile_asimage (target->asv, background, 0, 0,
491     target_width, target_height, background_tint,
492     ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
493     if (tmp)
494     result = tmp;
495     }
496     }
497     else
498     new_pmap_width = new_pmap_height = 0;
499     }
500     else
501     {
502     result = original_asim;
503     if ((w > 0 && w != original_asim->width)
504     || (h > 0 && h != original_asim->height))
505     {
506 ayin 1.10 result = scale_asimage (target->asv, original_asim,
507     w > 0 ? w : original_asim->width,
508 sasha 1.1 h > 0 ? h : original_asim->height,
509     background ? ASA_ASImage : ASA_XImage,
510     100, ASIMAGE_QUALITY_DEFAULT);
511     }
512     if (background == NULL)
513 ayin 1.17 {
514     /* if tiling - pixmap has to be sized exactly as the image,
515     but there is no need to make it bigger then the window! */
516 sasha 1.1 if (h_scale == 0)
517 sasha 1.13 new_pmap_width = min (result->width, target_width);
518 sasha 1.1 if (v_scale == 0)
519 sasha 1.13 new_pmap_height = min (result->height, target_height);
520 sasha 1.1 /* we also need to tile our image in one or both directions */
521     if (h_scale == 0 || v_scale == 0)
522     {
523     ASImage *tmp = tile_asimage (target->asv, result,
524 ayin 1.10 (h_scale > 0) ? 0 : (int)result->width - x,
525     (v_scale > 0) ? 0 : (int)result->height - y,
526 sasha 1.13 new_pmap_width,
527     new_pmap_height,
528 sasha 1.1 TINT_LEAVE_SAME, ASA_XImage,
529     100, ASIMAGE_QUALITY_DEFAULT);
530     if (tmp)
531     {
532     if (result != original_asim)
533     destroy_asimage (&result);
534     result = tmp;
535     }
536     }
537     }
538     else
539 ayin 1.17 {
540     /* if blending background and image - pixmap has to be sized same as target window */
541 sasha 1.1 ASImageLayer *layers = create_image_layers (2);
542     ASImage *merged_im = NULL;
543    
544     layers[0].im = background;
545     layers[0].clip_width = target_width;
546     layers[0].clip_height = target_height;
547     layers[0].tint = background_tint;
548     layers[1].im = result;
549     if (w <= 0)
550 ayin 1.17 {
551     /* tile horizontally */
552 sasha 1.1 while (x > 0) x -= (int)result->width;
553     layers[1].dst_x = x;
554     layers[1].clip_width = result->width+target_width;
555     }
556     else
557 ayin 1.17 {
558     /* clip horizontally */
559 sasha 1.1 layers[1].dst_x = x;
560     layers[1].clip_width = result->width;
561     }
562     if (h <= 0)
563     {
564     while (y > 0) y -= (int)result->height;
565     layers[1].dst_y = y;
566     layers[1].clip_height = result->height + target_height;
567     }
568     else
569     {
570     layers[1].dst_y = y;
571     layers[1].clip_height = result->height;
572     }
573     if (target->rs[Rs_blendtype])
574     {
575     layers[1].merge_scanlines = blend_scanlines_name2func (target->rs[Rs_blendtype]);
576     if (layers[1].merge_scanlines == NULL)
577     layers[1].merge_scanlines = alphablend_scanlines;
578     }
579     ASImage *tmp = merge_layers (target->asv, layers, 2, target_width, target_height,
580     ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
581     if (tmp)
582     {
583     if (result != original_asim)
584     destroy_asimage (&result);
585     result = tmp;
586     }
587     free (layers);
588     }
589     }
590     TIMING_TEST_PRINT_RESULT (asim);
591    
592     if (pixmap)
593     {
594     if (result == NULL
595     || pmap_width != new_pmap_width
596     || pmap_height != new_pmap_height
597     || pmap_depth != target->depth)
598     {
599     XFreePixmap (target->dpy, pixmap);
600     pixmap = None;
601     }
602     }
603    
604     if (result)
605     {
606     XGCValues gcv;
607     GC gc;
608    
609     /* create Pixmap */
610     if (pixmap == None)
611     {
612     pixmap = XCreatePixmap (target->dpy, target->vt, new_pmap_width, new_pmap_height, target->depth);
613     pmap_width = new_pmap_width;
614     pmap_height = new_pmap_height;
615     pmap_depth = target->depth;
616     }
617     /* fill with background color ( if result's not completely overlapping it)*/
618     gcv.foreground = target->pix_colors[Color_bg];
619     gc = XCreateGC (target->dpy, target->vt, GCForeground, &gcv);
620    
621     int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
622     int dst_width = result->width, dst_height = result->height;
623     if (background == NULL)
624     {
625     if (h_scale > 0)
626     src_x = make_clip_rectangle (x, result->width, new_pmap_width, dst_x, dst_width);
627     if (v_scale > 0)
628     src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
629    
630     if (dst_x > 0 || dst_y > 0
631     || dst_x + dst_width < new_pmap_width
632     || dst_y + dst_height < new_pmap_height)
633     {
634     XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
635     }
636     }
637    
638     /* put result on pixmap */
639     if (dst_x < new_pmap_width && dst_y < new_pmap_height)
640     asimage2drawable (target->asv, pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);
641 ayin 1.10
642 sasha 1.1 if (result != background && result != original_asim)
643     destroy_asimage (&result);
644    
645     XFreeGC (target->dpy, gc);
646     TIMING_TEST_PRINT_RESULT (asim);
647     }
648    
649     return true;
650     }
651     # endif /* HAVE_AFTERIMAGE */
652    
653     bool
654     bgPixmap_t::set_file (const char *file)
655     {
656     char *f;
657    
658     assert (file != NULL);
659    
660     if (*file != '\0')
661     {
662     # ifdef HAVE_AFTERIMAGE
663     if (target->asimman == NULL)
664     target->asimman = create_generic_imageman (target->rs[Rs_path]);
665     if ((f = strchr (file, ';')) == NULL)
666     original_asim = get_asimage (target->asimman, file, 0xFFFFFFFF, 100);
667     else
668     {
669     size_t len = f - file;
670     f = (char *)malloc (len + 1);
671     strncpy (f, file, len);
672     f[len] = '\0';
673     original_asim = get_asimage (target->asimman, f, 0xFFFFFFFF, 100);
674     free (f);
675     }
676     return (original_asim != NULL);
677 ayin 1.10 # endif
678 sasha 1.1 }
679     return false;
680     }
681    
682 ayin 1.12 # endif /* BG_IMAGE_FROM_FILE */
683 sasha 1.1
684     # ifdef ENABLE_TRANSPARENCY
685 ayin 1.10 bool
686 sasha 1.1 bgPixmap_t::set_transparent ()
687     {
688     if (!(flags & isTransparent))
689     {
690     flags |= isTransparent;
691     return true;
692     }
693     return false;
694     }
695    
696     bool
697     bgPixmap_t::set_blur_radius (const char *geom)
698     {
699     int changed = 0;
700     unsigned int hr, vr;
701     int junk;
702     int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr);
703    
704     if (!(geom_flags&WidthValue))
705     hr = 1;
706     if (!(geom_flags&HeightValue))
707     vr = hr;
708    
709     if (h_blurRadius != hr)
710     {
711     ++changed;
712     h_blurRadius = hr;
713     }
714    
715     if (v_blurRadius != vr)
716     {
717     ++changed;
718     v_blurRadius = vr;
719     }
720 ayin 1.10
721 sasha 1.1 if (v_blurRadius == 0 && h_blurRadius == 0)
722     flags &= ~blurNeeded;
723     else
724     flags |= blurNeeded;
725    
726     return (changed>0);
727     }
728    
729     static inline unsigned long
730     compute_tint_shade_flags (rxvt_color *tint, int shade)
731     {
732     unsigned long flags = 0;
733     rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
734 sasha 1.3 bool has_shade = (shade > 0 && shade < 100) || (shade > 100 && shade < 200);
735 sasha 1.1
736     if (tint)
737     {
738     tint->get (c);
739     # define IS_COMPONENT_WHOLESOME(cmp) ((cmp) <= 0x000700 || (cmp) >= 0x00f700)
740 sasha 1.3 if (!has_shade && IS_COMPONENT_WHOLESOME (c.r)
741 sasha 1.1 && IS_COMPONENT_WHOLESOME (c.g)
742     && IS_COMPONENT_WHOLESOME (c.b))
743     flags |= bgPixmap_t::tintWholesome;
744     # undef IS_COMPONENT_WHOLESOME
745     }
746    
747 sasha 1.3 if (has_shade)
748 sasha 1.1 flags |= bgPixmap_t::tintNeeded;
749     else if (tint)
750     {
751     if ((c.r > 0x000700 || c.g > 0x000700 || c.b > 0x000700)
752     && (c.r < 0x00f700 || c.g < 0x00f700 || c.b < 0x00f700))
753     {
754     flags |= bgPixmap_t::tintNeeded;
755     }
756     }
757 ayin 1.10
758 sasha 1.1 if (flags & bgPixmap_t::tintNeeded)
759     {
760     if (flags & bgPixmap_t::tintWholesome)
761     flags |= bgPixmap_t::tintServerSide;
762 sasha 1.3 else
763     {
764 sasha 1.1 #if XFT
765 sasha 1.3 flags |= bgPixmap_t::tintServerSide;
766 sasha 1.1 #endif
767 sasha 1.3 }
768 sasha 1.1 }
769    
770     return flags;
771     }
772    
773     bool
774     bgPixmap_t::set_tint (rxvt_color &new_tint)
775     {
776     if (tint != new_tint)
777     {
778     unsigned long new_flags = compute_tint_shade_flags (&new_tint, shade);
779     tint = new_tint;
780     flags = (flags & ~tintFlags) | new_flags | tintSet;
781     return true;
782     }
783     return false;
784     }
785    
786     bool
787     bgPixmap_t::unset_tint ()
788     {
789     unsigned long new_flags = compute_tint_shade_flags (NULL, shade);
790    
791     if (new_flags != (flags & tintFlags))
792     {
793     flags = (flags&~tintFlags)|new_flags;
794     return true;
795     }
796     return false;
797     }
798    
799     bool
800     bgPixmap_t::set_shade (const char *shade_str)
801     {
802     int new_shade = (shade_str) ? atoi (shade_str) : 0;
803    
804 sasha 1.9 if (new_shade < 0 && new_shade > -100)
805     new_shade = 200 - (100 + new_shade);
806     else if (new_shade == 100)
807 sasha 1.1 new_shade = 0;
808    
809     if (new_shade != shade)
810     {
811     unsigned long new_flags = compute_tint_shade_flags ((flags & tintSet) ? &tint : NULL, new_shade);
812     shade = new_shade;
813 sasha 1.3 flags = (flags & (~tintFlags | tintSet)) | new_flags;
814 sasha 1.1 return true;
815     }
816     return false;
817     }
818    
819 ayin 1.10 /* make_transparency_pixmap()
820 sasha 1.1 * Builds a pixmap sized the same as terminal window, with depth same as the root window
821 ayin 1.10 * that pixmap contains tiled portion of the root pixmap that is supposed to be covered by
822 sasha 1.1 * our window.
823     */
824     unsigned long
825     bgPixmap_t::make_transparency_pixmap ()
826     {
827     unsigned long result = 0;
828    
829     if (target == NULL)
830     return 0;
831    
832     /* root dimentions may change from call to call - but Display structure should
833     * be always up-to-date, so let's use it :
834     */
835     Window root = target->display->root;
836     int screen = target->display->screen;
837     Display *dpy = target->dpy;
838     int root_width = DisplayWidth (dpy, screen);
839     int root_height = DisplayHeight (dpy, screen);
840     unsigned int root_pmap_width, root_pmap_height;
841     int window_width = target->szHint.width;
842     int window_height = target->szHint.height;
843     int sx, sy;
844     XGCValues gcv;
845    
846     TIMING_TEST_START (tp);
847     target->get_window_origin (sx, sy);
848    
849     /* check if we are outside of the visible part of the virtual screen : */
850     if (sx + window_width <= 0 || sy + window_height <= 0
851     || sx >= root_width || sy >= root_height)
852     return 0;
853    
854     if (root_pixmap != None)
855 ayin 1.17 {
856     /* we want to validate the pixmap and get it's size at the same time : */
857 sasha 1.1 int junk;
858     unsigned int ujunk;
859     /* root pixmap may be bad - allow a error */
860     target->allowedxerror = -1;
861    
862     if (!XGetGeometry (dpy, root_pixmap, &root, &junk, &junk, &root_pmap_width, &root_pmap_height, &ujunk, &ujunk))
863     root_pixmap = None;
864    
865     target->allowedxerror = 0;
866     }
867    
868     Pixmap tiled_root_pmap = XCreatePixmap (dpy, root, window_width, window_height, root_depth);
869     GC gc = NULL;
870    
871     if (tiled_root_pmap == None) /* something really bad happened - abort */
872     return 0;
873    
874     if (root_pixmap == None)
875 ayin 1.16 {
876     /* use tricks to obtain the root background image :*/
877 sasha 1.1 /* we want to create Overrideredirect window overlapping out window
878     with background type of Parent Relative and then grab it */
879     XSetWindowAttributes attr;
880     Window src;
881     bool success = false;
882    
883     attr.background_pixmap = ParentRelative;
884     attr.backing_store = Always;
885     attr.event_mask = ExposureMask;
886     attr.override_redirect = True;
887     src = XCreateWindow (dpy, root, sx, sy, window_width, window_height, 0,
888     CopyFromParent, CopyFromParent, CopyFromParent,
889     CWBackPixmap|CWBackingStore|CWOverrideRedirect|CWEventMask,
890     &attr);
891    
892     if (src != None)
893     {
894     XEvent event;
895     int ev_count = 0;
896     XGrabServer (dpy);
897     XMapRaised (dpy, src);
898     XSync (dpy, False);
899    
900     /* XSync should get window where it's properly exposed,
901     * but to be on the safe side - let's check for the actuall event to arrive : */
902     while (XCheckWindowEvent (dpy, src, ExposureMask, &event))
903     ++ev_count;
904    
905     if (ev_count > 0);
906 ayin 1.16 {
907     /* hooray! - we can grab the image! */
908 sasha 1.1 gc = XCreateGC (dpy, root, 0, NULL);
909     if (gc)
910     {
911     XCopyArea (dpy, src, tiled_root_pmap, gc, 0, 0, window_width, window_height, 0, 0);
912     success = true;
913     }
914     }
915     XDestroyWindow (dpy, src);
916     XUngrabServer (dpy);
917     //fprintf (stderr, "%s:%d: ev_count = %d\n", __FUNCTION__, __LINE__, ev_count);
918     }
919    
920     if (!success)
921     {
922     XFreePixmap (dpy, tiled_root_pmap);
923     tiled_root_pmap = None;
924     }
925     else
926     result |= transpPmapTiled;
927     }
928     else
929 ayin 1.17 {
930     /* strightforward pixmap copy */
931 sasha 1.1 gcv.tile = root_pixmap;
932     gcv.fill_style = FillTiled;
933    
934 sasha 1.6 while (sx < 0) sx += (int)root_width;
935     while (sy < 0) sy += (int)root_height;
936 sasha 1.1
937     gcv.ts_x_origin = -sx;
938     gcv.ts_y_origin = -sy;
939     gc = XCreateGC (dpy, root, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
940    
941     if (gc)
942     {
943     XFillRectangle (dpy, tiled_root_pmap, gc, 0, 0, window_width, window_height);
944     result |= transpPmapTiled;
945     }
946     }
947     TIMING_TEST_PRINT_RESULT (tp);
948    
949     if (tiled_root_pmap != None)
950     {
951 ayin 1.10 if (!need_client_side_rendering ())
952 sasha 1.1 {
953 ayin 1.10 if ((flags & tintNeeded))
954 sasha 1.1 {
955     if (flags & tintWholesome)
956     {
957     /* In this case we can tint image server-side getting significant
958     * performance improvements, as we eliminate XImage transfer
959     */
960     gcv.foreground = Pixel (tint);
961     gcv.function = GXand;
962     gcv.fill_style = FillSolid;
963     if (gc)
964     XChangeGC (dpy, gc, GCFillStyle | GCForeground | GCFunction, &gcv);
965     else
966     gc = XCreateGC (dpy, root, GCFillStyle | GCForeground | GCFunction, &gcv);
967     if (gc)
968     {
969     XFillRectangle (dpy, tiled_root_pmap, gc, 0, 0, window_width, window_height);
970     result |= transpPmapTinted;
971     }
972     }
973     else
974     {
975     # if XFT
976     Picture back_pic = 0;
977     rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
978    
979     if (flags & tintSet)
980     tint.get (c);
981    
982     if (shade > 0 && shade < 100)
983     {
984     c.r = (c.r * shade) / 100;
985     c.g = (c.g * shade) / 100;
986     c.b = (c.b * shade) / 100;
987     }
988     else if( shade > 100 && shade < 200)
989     {
990     c.r = (c.r * (200 - shade)) / 100;
991     c.g = (c.g * (200 - shade)) / 100;
992     c.b = (c.b * (200 - shade)) / 100;
993     }
994    
995     XRenderPictFormat pf;
996     pf.type = PictTypeDirect;
997     pf.depth = 32;
998     pf.direct.redMask = 0xff;
999     pf.direct.greenMask = 0xff;
1000     pf.direct.blueMask = 0xff;
1001     pf.direct.alphaMask = 0xff;
1002    
1003     XRenderPictFormat *solid_format = XRenderFindFormat (dpy,
1004 ayin 1.8 (PictFormatType|
1005     PictFormatDepth|
1006     PictFormatRedMask|
1007     PictFormatGreenMask|
1008     PictFormatBlueMask|
1009     PictFormatAlphaMask),
1010     &pf,
1011     0);
1012 sasha 1.1 XRenderPictFormat *root_format = XRenderFindVisualFormat (dpy, DefaultVisualOfScreen (ScreenOfDisplay (dpy, target->display->screen)));
1013     XRenderPictureAttributes pa ;
1014    
1015     back_pic = XRenderCreatePicture (dpy, tiled_root_pmap, root_format, 0, &pa);
1016    
1017     pa.repeat = True;
1018    
1019     Pixmap overlay_pmap = XCreatePixmap (dpy, root, 1, 1, 32);
1020     Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1021     XFreePixmap (dpy, overlay_pmap);
1022    
1023 ayin 1.10 pa.component_alpha = True;
1024 sasha 1.1 Pixmap mask_pmap = XCreatePixmap (dpy, root, 1, 1, 32);
1025     Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat|CPComponentAlpha, &pa);
1026     XFreePixmap (dpy, mask_pmap);
1027    
1028     if (mask_pic && overlay_pic && back_pic)
1029     {
1030     XRenderColor mask_c;
1031    
1032     memset (&mask_c, (shade > 100) ? 0xFF : 0x0, sizeof (mask_c));
1033     mask_c.alpha = 0xffff;
1034     XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1035 sasha 1.3
1036 sasha 1.1 mask_c.alpha = 0;
1037 sasha 1.3 mask_c.red = 0xffff - c.r;
1038     mask_c.green = 0xffff - c.g;
1039     mask_c.blue = 0xffff - c.b;
1040     XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
1041     XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, window_width, window_height);
1042     result |= transpPmapTinted;
1043 sasha 1.1 }
1044     XRenderFreePicture (dpy, mask_pic);
1045     XRenderFreePicture (dpy, overlay_pic);
1046     XRenderFreePicture (dpy, back_pic);
1047     # if DO_TIMING_TEST
1048     XSync (dpy, False);
1049 ayin 1.10 # endif
1050 sasha 1.1 # endif
1051     }
1052     }
1053     } /* server side rendering completed */
1054    
1055     if (pixmap)
1056     XFreePixmap (dpy, pixmap);
1057    
1058     pixmap = tiled_root_pmap;
1059     pmap_width = window_width;
1060     pmap_height = window_height;
1061     pmap_depth = root_depth;
1062     }
1063 ayin 1.10
1064 sasha 1.1 if (gc)
1065     XFreeGC (dpy, gc);
1066    
1067     TIMING_TEST_PRINT_RESULT (tp);
1068 ayin 1.10
1069     return result;
1070 sasha 1.1 }
1071    
1072     bool
1073     bgPixmap_t::set_root_pixmap ()
1074     {
1075     Pixmap new_root_pixmap = None;
1076 ayin 1.10
1077 sasha 1.1 new_root_pixmap = target->get_pixmap_property (XA_XROOTPMAP_ID);
1078     if (new_root_pixmap == None)
1079     new_root_pixmap = target->get_pixmap_property (XA_ESETROOT_PMAP_ID);
1080    
1081     if (new_root_pixmap != root_pixmap)
1082     {
1083     root_pixmap = new_root_pixmap;
1084     return true;
1085     }
1086     return false;
1087     }
1088     # endif /* ENABLE_TRANSPARENCY */
1089    
1090     # ifndef HAVE_AFTERIMAGE
1091     static void ShadeXImage(rxvt_term *term, XImage* srcImage, int shade, int rm, int gm, int bm);
1092     # endif
1093    
1094    
1095     bool
1096     bgPixmap_t::render ()
1097     {
1098     unsigned long background_flags = 0;
1099    
1100     if (target == NULL)
1101     return false;
1102    
1103 sasha 1.3 TIMING_TEST_START (tp);
1104    
1105 sasha 1.1 invalidate();
1106     # ifdef ENABLE_TRANSPARENCY
1107     if (flags & isTransparent)
1108     {
1109     /* we need to re-generate transparency pixmap in that case ! */
1110     background_flags = make_transparency_pixmap ();
1111     if (background_flags == 0)
1112     return false;
1113     else if ((background_flags & transpTransformations) == (flags & transpTransformations)
1114     && pmap_depth == target->depth)
1115     flags = flags & ~isInvalid;
1116     }
1117     # endif
1118    
1119     XImage *result = NULL;
1120     # ifdef HAVE_AFTERIMAGE
1121     if (original_asim
1122     || (background_flags & transpTransformations) != (flags & transpTransformations))
1123     {
1124     ASImage *background = NULL;
1125     ARGB32 as_tint = TINT_LEAVE_SAME;
1126     if (background_flags)
1127     background = pixmap2ximage (target->asv, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, 100);
1128    
1129     # ifdef ENABLE_TRANSPARENCY
1130     if (!(background_flags & transpPmapTinted) && (flags & tintNeeded))
1131     {
1132     ShadingInfo as_shade;
1133     as_shade.shading = (shade == 0) ? 100 : shade;
1134    
1135     rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1136     if (flags & tintSet)
1137     tint.get (c);
1138     as_shade.tintColor.red = c.r;
1139     as_shade.tintColor.green = c.g;
1140     as_shade.tintColor.blue = c.b;
1141    
1142     as_tint = shading2tint32 (&as_shade);
1143     }
1144     if (!(background_flags & transpPmapBlured) && (flags & blurNeeded) && background != NULL)
1145     {
1146     ASImage* tmp = blur_asimage_gauss (target->asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,
1147     (original_asim == NULL || tint == TINT_LEAVE_SAME)?ASA_XImage:ASA_ASImage,
1148     100, ASIMAGE_QUALITY_DEFAULT);
1149     if (tmp)
1150     {
1151     destroy_asimage (&background);
1152     background = tmp;
1153     }
1154     }
1155     # endif
1156    
1157     if (render_asim (background, as_tint))
1158     flags = flags & ~isInvalid;
1159     if (background)
1160     destroy_asimage (&background);
1161     }
1162     else if (background_flags && pmap_depth != target->depth)
1163     {
1164     result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap);
1165     }
1166 sasha 1.7
1167     # elif !XFT /* our own client-side tinting */
1168    
1169 ayin 1.8 /* ATTENTION: We ASSUME that XFT will let us do all the tinting neccessary server-side.
1170     This may need to be changed in need_client_side_rendering() logic is altered !!! */
1171 sasha 1.7
1172 sasha 1.1 if (background_flags && (flags & isInvalid))
1173     {
1174     result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap);
1175     if (result != NULL && !(background_flags & transpPmapTinted) && (flags & tintNeeded))
1176     {
1177     rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1178     if (flags & tintSet)
1179     tint.get (c);
1180     ShadeXImage (target, result, shade, c.r, c.g, c.b);
1181     }
1182     }
1183     # endif /* HAVE_AFTERIMAGE */
1184    
1185     if (result != NULL)
1186     {
1187     GC gc = XCreateGC (target->dpy, target->vt, 0UL, NULL);
1188     if (gc)
1189     {
1190     if (/*pmap_depth != target->depth &&*/ pixmap != None)
1191     {
1192     XFreePixmap (target->dpy, pixmap);
1193     pixmap = None;
1194     }
1195     if (pixmap == None)
1196     {
1197     pixmap = XCreatePixmap (target->dpy, target->vt, result->width, result->height, target->depth);
1198     pmap_width = result->width;
1199     pmap_height = result->height;
1200     pmap_depth = target->depth;
1201     }
1202     if (pmap_depth != result->depth)
1203 ayin 1.16 {
1204     /* Bad Match error will ensue ! stupid X !!!! */
1205 sasha 1.1 if( result->depth == 24 && pmap_depth == 32)
1206     result->depth = 32;
1207     else if( result->depth == 32 && pmap_depth == 24)
1208     result->depth = 24;
1209     else
1210     {
1211     /* TODO: implement image recoding */
1212     }
1213     }
1214     if (pmap_depth == result->depth)
1215     XPutImage (target->dpy, pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1216     XFreeGC (target->dpy, gc);
1217     flags = flags & ~isInvalid;
1218     }
1219     XDestroyImage (result);
1220     }
1221    
1222     if (flags & isInvalid)
1223     {
1224     if (pixmap != None)
1225     {
1226     XFreePixmap (target->dpy, pixmap);
1227     pixmap = None;
1228     }
1229     }
1230    
1231     apply ();
1232    
1233 sasha 1.3 TIMING_TEST_PRINT_RESULT (tp);
1234    
1235 ayin 1.10 return true;
1236 sasha 1.1 }
1237    
1238 ayin 1.10 bool
1239 sasha 1.1 bgPixmap_t::set_target (rxvt_term *new_target)
1240     {
1241     if (new_target)
1242     if (target != new_target)
1243     {
1244     target = new_target;
1245     # ifdef ENABLE_TRANSPARENCY
1246     root_depth = DefaultDepthOfScreen (ScreenOfDisplay (target->dpy, target->display->screen));
1247     # endif
1248     return true;
1249     }
1250     return false;
1251     }
1252    
1253     void
1254     bgPixmap_t::apply()
1255     {
1256     if (target)
1257     {
1258     flags &= ~isVtOrigin;
1259     if (pixmap != None)
1260 ayin 1.16 {
1261     /* set target's background to pixmap */
1262 sasha 1.1 # ifdef ENABLE_TRANSPARENCY
1263     if (flags & isTransparent)
1264     {
1265     XSetWindowBackgroundPixmap (target->dpy, target->parent[0], pixmap);
1266     XSetWindowBackgroundPixmap (target->dpy, target->vt, ParentRelative);
1267     # if HAVE_SCROLLBARS
1268     if (target->scrollBar.win)
1269     XSetWindowBackgroundPixmap (target->dpy, target->scrollBar.win, ParentRelative);
1270     # endif
1271     }
1272     else
1273     # endif
1274     {
1275     flags |= isVtOrigin;
1276     /* force old pixmap dereference in case it was transparent before :*/
1277     XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
1278     XSetWindowBackgroundPixmap (target->dpy, target->vt, pixmap);
1279     /* do we also need to set scrollbar's background here ? */
1280     # if HAVE_SCROLLBARS
1281     if (target->scrollBar.win)
1282     XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);
1283     # endif
1284     }
1285     }
1286     else
1287 ayin 1.16 {
1288     /* set target background to a pixel */
1289 sasha 1.1 XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
1290     XSetWindowBackground (target->dpy, target->vt, target->pix_colors[Color_bg]);
1291     /* do we also need to set scrollbar's background here ? */
1292     # if HAVE_SCROLLBARS
1293     if (target->scrollBar.win)
1294     XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);
1295     # endif
1296     }
1297 ayin 1.10 /* don't want Expose on the parent or vt. It is better to use
1298 sasha 1.5 scr_touch or we get a great deal of flicker otherwise: */
1299     XClearWindow (target->dpy, target->parent[0]);
1300 sasha 1.1
1301     # if HAVE_SCROLLBARS
1302     if (target->scrollBar.win)
1303     {
1304     target->scrollBar.setIdle ();
1305     target->scrollbar_show (0);
1306     }
1307     # endif
1308 sasha 1.5
1309     target->want_refresh = 1;
1310     flags |= hasChanged;
1311 sasha 1.1 }
1312     }
1313    
1314 ayin 1.12 #endif /* HAVE_BG_PIXMAP */
1315 sasha 1.1
1316 sasha 1.7 #if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) && !XFT
1317 sasha 1.1 /* taken from aterm-0.4.2 */
1318    
1319     typedef uint32_t RUINT32T;
1320    
1321     static void
1322     ShadeXImage(rxvt_term *term, XImage* srcImage, int shade, int rm, int gm, int bm)
1323     {
1324     int sh_r, sh_g, sh_b;
1325     RUINT32T mask_r, mask_g, mask_b;
1326     RUINT32T *lookup, *lookup_r, *lookup_g, *lookup_b;
1327     unsigned int lower_lim_r, lower_lim_g, lower_lim_b;
1328     unsigned int upper_lim_r, upper_lim_g, upper_lim_b;
1329     int i;
1330    
1331     Visual *visual = term->visual;
1332    
1333     if (visual->c_class != TrueColor || srcImage->format != ZPixmap) return ;
1334    
1335     if (shade == 0)
1336     shade = 100;
1337    
1338     /* for convenience */
1339     mask_r = visual->red_mask;
1340     mask_g = visual->green_mask;
1341     mask_b = visual->blue_mask;
1342    
1343     /* boring lookup table pre-initialization */
1344     switch (srcImage->bits_per_pixel) {
1345     case 15:
1346     if ((mask_r != 0x7c00) ||
1347     (mask_g != 0x03e0) ||
1348     (mask_b != 0x001f))
1349     return;
1350     lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(32+32+32));
1351     lookup_r = lookup;
1352     lookup_g = lookup+32;
1353     lookup_b = lookup+32+32;
1354     sh_r = 10;
1355     sh_g = 5;
1356     sh_b = 0;
1357     break;
1358     case 16:
1359     if ((mask_r != 0xf800) ||
1360     (mask_g != 0x07e0) ||
1361     (mask_b != 0x001f))
1362     return;
1363     lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(32+64+32));
1364     lookup_r = lookup;
1365     lookup_g = lookup+32;
1366     lookup_b = lookup+32+64;
1367     sh_r = 11;
1368     sh_g = 5;
1369     sh_b = 0;
1370     break;
1371     case 24:
1372     if ((mask_r != 0xff0000) ||
1373     (mask_g != 0x00ff00) ||
1374     (mask_b != 0x0000ff))
1375     return;
1376     lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(256+256+256));
1377     lookup_r = lookup;
1378     lookup_g = lookup+256;
1379     lookup_b = lookup+256+256;
1380     sh_r = 16;
1381     sh_g = 8;
1382     sh_b = 0;
1383     break;
1384     case 32:
1385     if ((mask_r != 0xff0000) ||
1386     (mask_g != 0x00ff00) ||
1387     (mask_b != 0x0000ff))
1388     return;
1389     lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(256+256+256));
1390     lookup_r = lookup;
1391     lookup_g = lookup+256;
1392     lookup_b = lookup+256+256;
1393     sh_r = 16;
1394     sh_g = 8;
1395     sh_b = 0;
1396     break;
1397     default:
1398     return; /* we do not support this color depth */
1399     }
1400    
1401     /* prepare limits for color transformation (each channel is handled separately) */
1402     if (shade < 0) {
1403     shade = -shade;
1404     if (shade < 0) shade = 0;
1405     if (shade > 100) shade = 100;
1406    
1407     lower_lim_r = 65535-rm;
1408     lower_lim_g = 65535-gm;
1409     lower_lim_b = 65535-bm;
1410    
1411     lower_lim_r = 65535-(unsigned int)(((RUINT32T)lower_lim_r)*((RUINT32T)shade)/100);
1412     lower_lim_g = 65535-(unsigned int)(((RUINT32T)lower_lim_g)*((RUINT32T)shade)/100);
1413     lower_lim_b = 65535-(unsigned int)(((RUINT32T)lower_lim_b)*((RUINT32T)shade)/100);
1414    
1415     upper_lim_r = upper_lim_g = upper_lim_b = 65535;
1416     } else {
1417     if (shade < 0) shade = 0;
1418     if (shade > 100) shade = 100;
1419    
1420     lower_lim_r = lower_lim_g = lower_lim_b = 0;
1421    
1422     upper_lim_r = (unsigned int)((((RUINT32T)rm)*((RUINT32T)shade))/100);
1423     upper_lim_g = (unsigned int)((((RUINT32T)gm)*((RUINT32T)shade))/100);
1424     upper_lim_b = (unsigned int)((((RUINT32T)bm)*((RUINT32T)shade))/100);
1425     }
1426    
1427     /* switch red and blue bytes if necessary, we need it for some weird XServers like XFree86 3.3.3.1 */
1428     if ((srcImage->bits_per_pixel == 24) && (mask_r >= 0xFF0000 ))
1429     {
1430     unsigned int tmp;
1431    
1432     tmp = lower_lim_r;
1433     lower_lim_r = lower_lim_b;
1434     lower_lim_b = tmp;
1435    
1436     tmp = upper_lim_r;
1437     upper_lim_r = upper_lim_b;
1438     upper_lim_b = tmp;
1439     }
1440    
1441     /* fill our lookup tables */
1442     for (i = 0; i <= mask_r>>sh_r; i++)
1443     {
1444     RUINT32T tmp;
1445     tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_r-lower_lim_r));
1446     tmp += ((RUINT32T)(mask_r>>sh_r))*((RUINT32T)lower_lim_r);
1447     lookup_r[i] = (tmp/65535)<<sh_r;
1448     }
1449     for (i = 0; i <= mask_g>>sh_g; i++)
1450     {
1451     RUINT32T tmp;
1452     tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_g-lower_lim_g));
1453     tmp += ((RUINT32T)(mask_g>>sh_g))*((RUINT32T)lower_lim_g);
1454     lookup_g[i] = (tmp/65535)<<sh_g;
1455     }
1456     for (i = 0; i <= mask_b>>sh_b; i++)
1457     {
1458     RUINT32T tmp;
1459     tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_b-lower_lim_b));
1460     tmp += ((RUINT32T)(mask_b>>sh_b))*((RUINT32T)lower_lim_b);
1461     lookup_b[i] = (tmp/65535)<<sh_b;
1462     }
1463    
1464     /* apply table to input image (replacing colors by newly calculated ones) */
1465     switch (srcImage->bits_per_pixel)
1466     {
1467     case 15:
1468     {
1469     unsigned short *p1, *pf, *p, *pl;
1470     p1 = (unsigned short *) srcImage->data;
1471     pf = (unsigned short *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
1472     while (p1 < pf)
1473     {
1474     p = p1;
1475     pl = p1 + srcImage->width;
1476     for (; p < pl; p++)
1477     {
1478     *p = lookup_r[(*p & 0x7c00)>>10] |
1479     lookup_g[(*p & 0x03e0)>> 5] |
1480     lookup_b[(*p & 0x001f)];
1481     }
1482     p1 = (unsigned short *) ((char *) p1 + srcImage->bytes_per_line);
1483     }
1484     break;
1485     }
1486     case 16:
1487     {
1488     unsigned short *p1, *pf, *p, *pl;
1489     p1 = (unsigned short *) srcImage->data;
1490     pf = (unsigned short *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
1491     while (p1 < pf)
1492     {
1493     p = p1;
1494     pl = p1 + srcImage->width;
1495     for (; p < pl; p++)
1496     {
1497     *p = lookup_r[(*p & 0xf800)>>11] |
1498     lookup_g[(*p & 0x07e0)>> 5] |
1499     lookup_b[(*p & 0x001f)];
1500     }
1501     p1 = (unsigned short *) ((char *) p1 + srcImage->bytes_per_line);
1502     }
1503     break;
1504     }
1505     case 24:
1506     {
1507     unsigned char *p1, *pf, *p, *pl;
1508     p1 = (unsigned char *) srcImage->data;
1509     pf = (unsigned char *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
1510     while (p1 < pf)
1511     {
1512     p = p1;
1513     pl = p1 + srcImage->width * 3;
1514     for (; p < pl; p += 3)
1515     {
1516     p[0] = lookup_r[(p[0] & 0xff0000)>>16];
1517     p[1] = lookup_r[(p[1] & 0x00ff00)>> 8];
1518     p[2] = lookup_r[(p[2] & 0x0000ff)];
1519     }
1520     p1 = (unsigned char *) ((char *) p1 + srcImage->bytes_per_line);
1521     }
1522     break;
1523     }
1524     case 32:
1525     {
1526     RUINT32T *p1, *pf, *p, *pl;
1527     p1 = (RUINT32T *) srcImage->data;
1528     pf = (RUINT32T *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
1529    
1530     while (p1 < pf)
1531     {
1532     p = p1;
1533     pl = p1 + srcImage->width;
1534     for (; p < pl; p++)
1535     {
1536     *p = lookup_r[(*p & 0xff0000)>>16] |
1537     lookup_g[(*p & 0x00ff00)>> 8] |
1538     lookup_b[(*p & 0x0000ff)] |
1539     (*p & ~0xffffff);
1540     }
1541     p1 = (RUINT32T *) ((char *) p1 + srcImage->bytes_per_line);
1542     }
1543     break;
1544     }
1545     }
1546    
1547     free (lookup);
1548     }
1549     #endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */