ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/rxvt-unicode/src/background.C
(Generate patch)

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.80 by sf-exg, Wed Oct 13 23:04:57 2010 UTC vs.
Revision 1.212 by sf-exg, Sun May 13 15:50:18 2012 UTC

1/*----------------------------------------------------------------------* 1/*----------------------------------------------------------------------*
2 * File: background.C - former xpm.C 2 * File: background.C - former xpm.C
3 *----------------------------------------------------------------------* 3 *----------------------------------------------------------------------*
4 * 4 *
5 * All portions of code are copyright by their respective author/s. 5 * All portions of code are copyright by their respective author/s.
6 * Copyright (c) 2005-2008 Marc Lehmann <pcg@goof.com> 6 * Copyright (c) 2005-2008 Marc Lehmann <schmorp@schmorp.de>
7 * Copyright (c) 2007 Sasha Vasko <sasha@aftercode.net> 7 * Copyright (c) 2007 Sasha Vasko <sasha@aftercode.net>
8 * Copyright (c) 2010-2012 Emanuele Giaquinta <e.giaquinta@glauco.it>
8 * 9 *
9 * This program is free software; you can redistribute it and/or modify 10 * 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 * 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 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version. 13 * (at your option) any later version.
… …
19 * You should have received a copy of the GNU General Public License 20 * 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 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 *---------------------------------------------------------------------*/ 23 *---------------------------------------------------------------------*/
23 24
24#include <cmath> 25#include <math.h>
25#include "../config.h" /* NECESSARY */ 26#include "../config.h" /* NECESSARY */
26#include "rxvt.h" /* NECESSARY */ 27#include "rxvt.h" /* NECESSARY */
27 28
28#define DO_TIMING_TEST 0 29#if XRENDER
29 30# include <X11/extensions/Xrender.h>
30#if DO_TIMING_TEST
31# include <sys/time.h>
32#define TIMING_TEST_START(id) \
33 struct timeval timing_test_##id##_stv; \
34 gettimeofday (&timing_test_##id##_stv, NULL);
35
36#define TIMING_TEST_PRINT_RESULT(id) \
37 do { \
38 struct timeval tv; \
39 gettimeofday (&tv, NULL); \
40 tv.tv_sec -= (timing_test_##id##_stv).tv_sec; \
41 fprintf (stderr, "%s: %s: %d: elapsed %ld usec\n", #id, __FILE__, __LINE__, \
42 tv.tv_sec * 1000000 + tv.tv_usec - (timing_test_##id##_stv).tv_usec); \
43 } while (0)
44
45#else
46#define TIMING_TEST_START(id) do {} while (0)
47#define TIMING_TEST_PRINT_RESULT(id) do {} while (0)
48#endif 31#endif
49 32
50/* 33#ifndef FilterConvolution
51 * Pixmap geometry string interpretation : 34#define FilterConvolution "convolution"
52 * Each geometry string contains zero or one scale/position 35#endif
53 * adjustment and may optionally be followed by a colon and one or more 36
54 * colon-delimited pixmap operations. 37#ifndef RepeatPad
55 * The following table shows the valid geometry strings and their 38#define RepeatPad True
56 * effects on the background image : 39#endif
57 *
58 * WxH+X+Y Set scaling to W% by H%, and position to X% by Y%.
59 * W and H are percentages of the terminal window size.
60 * X and Y are also percentages; e.g., +50+50 centers
61 * the image in the window.
62 * WxH+X Assumes Y == X
63 * WxH Assumes Y == X == 50 (centers the image)
64 * W+X+Y Assumes H == W
65 * W+X Assumes H == W and Y == X
66 * W Assumes H == W and Y == X == 50
67 *
68 * Adjusting position only :
69 * =+X+Y Set position to X% by Y% (absolute).
70 * =+X Set position to X% by X%.
71 * +X+Y Adjust position horizontally X% and vertically Y%
72 * from current position (relative).
73 * +X Adjust position horizontally X% and vertically X%
74 * from current position.
75 *
76 * Adjusting scale only :
77 * Wx0 Multiply horizontal scaling factor by W%
78 * 0xH Multiply vertical scaling factor by H%
79 * 0x0 No scaling (show image at normal size).
80 *
81 * Pixmap Operations : (should be prepended by a colon)
82 * tile Tile image. Scaling/position modifiers above will affect
83 * the tile size and origin.
84 * propscale When scaling, scale proportionally. That is, maintain the
85 * proper aspect ratio for the image. Any portion of the
86 * background not covered by the image is filled with the
87 * current background color.
88 * hscale Scale horizontally, tile vertically ?
89 * vscale Tile horizontally, scale vertically ?
90 * scale Scale both up and down
91 * auto Same as 100x100+50+50
92 */
93 40
94#ifdef HAVE_BG_PIXMAP 41#ifdef HAVE_BG_PIXMAP
95bgPixmap_t::bgPixmap_t () 42# if XRENDER
43static Picture
44create_xrender_mask (Display *dpy, Drawable drawable, Bool argb, Bool component_alpha)
96{ 45{
97 // this is basically redundant as bgPixmap_t is only used in 46 Pixmap pixmap = XCreatePixmap (dpy, drawable, 1, 1, argb ? 32 : 8);
98 // zero_initialised-derived structs 47
99#ifdef HAVE_AFTERIMAGE 48 XRenderPictFormat *format = XRenderFindStandardFormat (dpy, argb ? PictStandardARGB32 : PictStandardA8);
100 original_asim = NULL; 49 XRenderPictureAttributes pa;
50 pa.repeat = True;
51 pa.component_alpha = component_alpha;
52 Picture mask = XRenderCreatePicture (dpy, pixmap, format, CPRepeat | CPComponentAlpha, &pa);
53
54 XFreePixmap (dpy, pixmap);
55
56 return mask;
57}
101#endif 58# endif
102#ifdef HAVE_PIXBUF
103 pixbuf = NULL;
104#endif
105#ifdef BG_IMAGE_FROM_FILE
106 have_image = false;
107 h_scale = v_scale = 0;
108 h_align = v_align = 0;
109#endif
110#ifdef ENABLE_TRANSPARENCY
111 shade = 100;
112#endif
113 flags = 0;
114 pixmap = None;
115 valid_since = invalid_since = 0;
116 target = 0;
117}
118 59
119void 60void
120bgPixmap_t::destroy () 61rxvt_term::bg_destroy ()
121{ 62{
122#ifdef HAVE_AFTERIMAGE
123 if (original_asim)
124 safe_asimage_destroy (original_asim);
125#endif
126
127#ifdef HAVE_PIXBUF 63#ifdef HAVE_PIXBUF
128 if (pixbuf) 64 if (pixbuf)
129 g_object_unref (pixbuf); 65 g_object_unref (pixbuf);
130#endif 66#endif
131 67
132 if (pixmap && target) 68 if (bg_pixmap)
133 XFreePixmap (target->dpy, pixmap); 69 XFreePixmap (dpy, bg_pixmap);
134} 70}
135 71
136bool 72bool
137bgPixmap_t::window_size_sensitive () 73rxvt_term::bg_set_position (int x, int y)
74{
75
76 if (target_x != x
77 || target_y != y)
78 {
79 target_x = x;
80 target_y = y;
81 return true;
82 }
83 return false;
84}
85
86bool
87rxvt_term::bg_window_size_sensitive ()
138{ 88{
139# ifdef ENABLE_TRANSPARENCY 89# ifdef ENABLE_TRANSPARENCY
140 if (flags & isTransparent) 90 if (bg_flags & BG_IS_TRANSPARENT)
141 return true; 91 return true;
142# endif 92# endif
143 93
144# ifdef BG_IMAGE_FROM_FILE 94# ifdef BG_IMAGE_FROM_FILE
145 if (have_image) 95 if (bg_flags & BG_IS_FROM_FILE)
146 { 96 {
147 if (flags & sizeSensitive) 97 if (bg_flags & BG_IS_SIZE_SENSITIVE)
148 return true; 98 return true;
149 } 99 }
150# endif 100# endif
151 101
152 return false; 102 return false;
153} 103}
154 104
155bool 105bool
156bgPixmap_t::window_position_sensitive () 106rxvt_term::bg_window_position_sensitive ()
157{ 107{
158# ifdef ENABLE_TRANSPARENCY 108# ifdef ENABLE_TRANSPARENCY
159 if (flags & isTransparent) 109 if (bg_flags & BG_IS_TRANSPARENT)
160 return true; 110 return true;
161# endif 111# endif
162 112
163# ifdef BG_IMAGE_FROM_FILE 113# ifdef BG_IMAGE_FROM_FILE
164 if (have_image) 114 if (bg_flags & BG_IS_FROM_FILE)
165 { 115 {
166 if (flags & rootAlign) 116 if (bg_flags & BG_ROOT_ALIGN)
167 return true; 117 return true;
168 } 118 }
169# endif 119# endif
170 120
171 return false; 121 return false;
172};
173
174bool bgPixmap_t::need_client_side_rendering ()
175{
176# ifdef HAVE_AFTERIMAGE
177 if (original_asim)
178 return true;
179# endif
180# ifdef ENABLE_TRANSPARENCY
181 if (flags & isTransparent)
182 {
183# ifdef HAVE_AFTERIMAGE
184 if ((flags & blurNeeded) && !(flags & blurServerSide))
185 return true;
186# endif
187 if ((flags & tintNeeded) && !(flags & tintServerSide))
188 return true;
189 }
190# endif
191 return false;
192} 122}
193 123
194# ifdef BG_IMAGE_FROM_FILE 124# ifdef BG_IMAGE_FROM_FILE
195static inline bool
196check_set_scale_value (int geom_flags, int flag, unsigned int &scale, unsigned int new_value)
197{
198 if (geom_flags & flag)
199 {
200 if (new_value > 1000)
201 new_value = 1000;
202 if (new_value != scale)
203 {
204 scale = new_value;
205 return true;
206 }
207 }
208 return false;
209}
210
211static inline bool
212check_set_align_value (int geom_flags, int flag, int &align, int new_value)
213{
214 if (geom_flags & flag)
215 {
216 if (new_value < -100)
217 new_value = -100;
218 else if (new_value > 200)
219 new_value = 200;
220 if (new_value != align)
221 {
222 align = new_value;
223 return true;
224 }
225 }
226 return false;
227}
228
229static inline int 125static inline int
230make_align_position (int align, int window_size, int image_size) 126make_align_position (int align, int window_size, int image_size)
231{ 127{
232 int diff = window_size - image_size;
233 int smaller = min (image_size, window_size);
234
235 if (align >= 0 && align <= 100) 128 if (align >= 0 && align <= 100)
236 return diff * align / 100; 129 return lerp (0, window_size - image_size, align);
237 else if (align > 100 && align <= 200 ) 130 else if (align > 100)
238 return ((align - 100) * smaller / 100) + window_size - smaller; 131 return lerp (window_size - image_size, window_size, align - 100);
239 else if (align >= -100 && align < 0) 132 else
240 return ((align + 100) * smaller / 100) - image_size; 133 return lerp (-image_size, 0, align + 100);
241 return 0;
242} 134}
243 135
244static inline int 136static inline int
245make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size) 137make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)
246{ 138{
… …
252 src_pos = -pos; 144 src_pos = -pos;
253 dst_pos = 0; 145 dst_pos = 0;
254 dst_size += pos; 146 dst_size += pos;
255 } 147 }
256 148
257 if (dst_pos + dst_size > target_size)
258 dst_size = target_size - dst_pos; 149 min_it (dst_size, target_size - dst_pos);
259 return src_pos; 150 return src_pos;
260} 151}
261 152
262bool 153bool
263bgPixmap_t::set_geometry (const char *geom) 154rxvt_term::bg_set_geometry (const char *geom, bool update)
264{ 155{
156 bool changed = false;
265 int geom_flags = 0, changed = 0; 157 int geom_flags = 0;
266 int x = 0, y = 0; 158 int x = h_align;
159 int y = v_align;
267 unsigned int w = 0, h = 0; 160 unsigned int w = h_scale;
268 unsigned int n; 161 unsigned int h = v_scale;
269 unsigned long new_flags = (flags & (~geometryFlags)); 162 unsigned long new_flags = 0;
270 const char *p;
271# define MAXLEN_GEOM 256 /* could be longer than regular geometry string */
272 163
273 if (geom == NULL) 164 if (geom == NULL)
274 return false; 165 return false;
275 166
276 char str[MAXLEN_GEOM]; 167 if (geom[0])
277
278 while (isspace(*geom)) ++geom;
279 if ((p = strchr (geom, ';')) == NULL)
280 p = strchr (geom, '\0');
281
282 n = (p - geom);
283 if (n < MAXLEN_GEOM)
284 { 168 {
285 char *ops; 169 char **arr = rxvt_strsplit (':', geom);
286 new_flags |= geometrySet;
287 170
288 memcpy (str, geom, n); 171 for (int i = 0; arr[i]; i++)
289 str[n] = '\0';
290 if (str[0] == ':')
291 ops = &str[0];
292 else if (str[0] != 'x' && str[0] != 'X' && isalpha(str[0]))
293 ops = &str[0];
294 else
295 {
296 char *tmp;
297 ops = strchr (str, ':');
298 if (ops != NULL)
299 { 172 {
300 for (tmp = ops-1; tmp >= str && isspace(*tmp); --tmp); 173 if (!strcasecmp (arr[i], "style=tiled"))
301 *(++tmp) = '\0';
302 if (ops == tmp) ++ops;
303 } 174 {
304 } 175 new_flags = BG_TILE;
305
306 if (ops > str || ops == NULL)
307 {
308 /* we have geometry string - let's handle it prior to applying ops */
309 geom_flags = XParseGeometry (str, &x, &y, &w, &h);
310
311 if ((geom_flags & XValue) && !(geom_flags & YValue))
312 {
313 y = x;
314 geom_flags |= YValue;
315 }
316
317 if (flags & geometrySet)
318 {
319 /* new geometry is an adjustment to the old one ! */
320 if ((geom_flags & WidthValue) && (geom_flags & HeightValue))
321 {
322 if (w == 0 && h != 0)
323 {
324 w = h_scale; 176 w = h = noScale;
325 h = (v_scale * h) / 100;
326 }
327 else if (h == 0 && w != 0)
328 {
329 w = (h_scale * w) / 100;
330 h = v_scale;
331 }
332 }
333 if (geom_flags & XValue)
334 {
335 if (str[0] != '=')
336 {
337 y += v_align;
338 x += h_align;
339 }
340 }
341 }
342 else /* setting up geometry from scratch */
343 {
344 if (!(geom_flags & XValue))
345 {
346 /* use default geometry - centered */
347 x = y = defaultAlign;
348 }
349 else if (!(geom_flags & YValue))
350 y = x; 177 x = y = 0;
351
352 if ((geom_flags & (WidthValue|HeightValue)) == 0)
353 {
354 /* use default geometry - scaled */
355 w = h = defaultScale;
356 }
357 else if (geom_flags & WidthValue)
358 {
359 if (!(geom_flags & HeightValue))
360 h = w;
361 }
362 else
363 w = h;
364 }
365 } /* done parsing geometry string */
366 else if (!(flags & geometrySet))
367 {
368 /* default geometry - scaled and centered */
369 x = y = defaultAlign;
370 w = h = defaultScale;
371 }
372
373 if (!(flags & geometrySet))
374 geom_flags |= WidthValue|HeightValue|XValue|YValue; 178 geom_flags = WidthValue|HeightValue|XValue|YValue;
375
376 if (ops)
377 {
378 while (*ops)
379 { 179 }
380 while (*ops == ':' || isspace(*ops)) ++ops; 180 else if (!strcasecmp (arr[i], "style=aspect-stretched"))
381
382# define CHECK_GEOM_OPS(op_str) (strncasecmp (ops, (op_str), sizeof (op_str) - 1) == 0)
383 if (CHECK_GEOM_OPS ("tile"))
384 { 181 {
182 new_flags = BG_KEEP_ASPECT;
183 w = h = windowScale;
184 x = y = centerAlign;
185 geom_flags = WidthValue|HeightValue|XValue|YValue;
186 }
187 else if (!strcasecmp (arr[i], "style=stretched"))
188 {
189 new_flags = 0;
190 w = h = windowScale;
191 geom_flags = WidthValue|HeightValue;
192 }
193 else if (!strcasecmp (arr[i], "style=centered"))
194 {
195 new_flags = 0;
385 w = h = noScale; 196 w = h = noScale;
197 x = y = centerAlign;
198 geom_flags = WidthValue|HeightValue|XValue|YValue;
199 }
200 else if (!strcasecmp (arr[i], "style=root-tiled"))
201 {
202 new_flags = BG_TILE|BG_ROOT_ALIGN;
203 w = h = noScale;
204 geom_flags = WidthValue|HeightValue;
205 }
206 else if (!strcasecmp (arr[i], "op=tile"))
207 new_flags |= BG_TILE;
208 else if (!strcasecmp (arr[i], "op=keep-aspect"))
209 new_flags |= BG_KEEP_ASPECT;
210 else if (!strcasecmp (arr[i], "op=root-align"))
211 new_flags |= BG_ROOT_ALIGN;
212
213 // deprecated
214 else if (!strcasecmp (arr[i], "tile"))
215 {
216 new_flags |= BG_TILE;
217 w = h = noScale;
386 geom_flags |= WidthValue|HeightValue; 218 geom_flags |= WidthValue|HeightValue;
387 } 219 }
388 else if (CHECK_GEOM_OPS ("propscale")) 220 else if (!strcasecmp (arr[i], "propscale"))
389 { 221 {
390 new_flags |= propScale; 222 new_flags |= BG_KEEP_ASPECT;
391 }
392 else if (CHECK_GEOM_OPS ("hscale"))
393 {
394 if (w == 0) w = windowScale;
395
396 h = noScale; 223 w = h = windowScale;
397 geom_flags |= WidthValue|HeightValue; 224 geom_flags |= WidthValue|HeightValue;
398 } 225 }
399 else if (CHECK_GEOM_OPS ("vscale")) 226 else if (!strcasecmp (arr[i], "hscale"))
400 { 227 {
228 new_flags |= BG_TILE;
401 if (h == 0) h = windowScale; 229 w = windowScale;
402
403 w = noScale; 230 h = noScale;
404 geom_flags |= WidthValue|HeightValue; 231 geom_flags |= WidthValue|HeightValue;
405 } 232 }
406 else if (CHECK_GEOM_OPS ("scale")) 233 else if (!strcasecmp (arr[i], "vscale"))
407 { 234 {
235 new_flags |= BG_TILE;
408 if (h == 0) h = windowScale; 236 h = windowScale;
409 if (w == 0) w = windowScale; 237 w = noScale;
410
411 geom_flags |= WidthValue|HeightValue; 238 geom_flags |= WidthValue|HeightValue;
412 } 239 }
413 else if (CHECK_GEOM_OPS ("auto")) 240 else if (!strcasecmp (arr[i], "scale"))
414 { 241 {
415 w = h = windowScale; 242 w = h = windowScale;
243 geom_flags |= WidthValue|HeightValue;
244 }
245 else if (!strcasecmp (arr[i], "auto"))
246 {
247 w = h = windowScale;
416 x = y = centerAlign; 248 x = y = centerAlign;
417 geom_flags |= WidthValue|HeightValue|XValue|YValue; 249 geom_flags |= WidthValue|HeightValue|XValue|YValue;
418 } 250 }
419 else if (CHECK_GEOM_OPS ("root")) 251 else if (!strcasecmp (arr[i], "root"))
420 { 252 {
421 new_flags |= rootAlign; 253 new_flags |= BG_TILE|BG_ROOT_ALIGN;
422 w = h = noScale; 254 w = h = noScale;
423 geom_flags |= WidthValue|HeightValue; 255 geom_flags |= WidthValue|HeightValue;
424 } 256 }
425# undef CHECK_GEOM_OPS
426 257
427 while (*ops != ':' && *ops != '\0') ++ops; 258 else
259 geom_flags |= XParseGeometry (arr[i], &x, &y, &w, &h);
428 } /* done parsing ops */ 260 } /* done parsing ops */
429 }
430 261
431 if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) ++changed; 262 rxvt_free_strsplit (arr);
432 if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) ++changed;
433 if (check_set_align_value (geom_flags, XValue, h_align, x)) ++changed;
434 if (check_set_align_value (geom_flags, YValue, v_align, y)) ++changed;
435 }
436
437 if (new_flags != flags)
438 { 263 }
264
265 new_flags |= bg_flags & ~BG_GEOMETRY_FLAGS;
266
267 if (!update)
268 {
269 if (!(geom_flags & XValue))
270 x = y = defaultAlign;
271 else if (!(geom_flags & YValue))
272 y = x;
273
274 if (!(geom_flags & (WidthValue|HeightValue)))
275 w = h = defaultScale;
276 else if (!(geom_flags & HeightValue))
277 h = w;
278 else if (!(geom_flags & WidthValue))
279 w = h;
280 }
281
282 min_it (w, 1000);
283 min_it (h, 1000);
284 clamp_it (x, -100, 200);
285 clamp_it (y, -100, 200);
286
287 if (bg_flags != new_flags
288 || h_scale != w
289 || v_scale != h
290 || h_align != x
291 || v_align != y)
292 {
439 flags = new_flags; 293 bg_flags = new_flags;
294 h_scale = w;
295 v_scale = h;
296 h_align = x;
297 v_align = y;
440 changed++; 298 changed = true;
441 } 299 }
442 300
443 //fprintf (stderr, "flags = %lX, scale = %ux%u, align=%+d%+d\n",
444 // flags, h_scale, v_scale, h_align, v_align);
445 return (changed > 0); 301 return changed;
446} 302}
447 303
448void 304void
449bgPixmap_t::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y) 305rxvt_term::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y)
450{ 306{
451 int target_width = target->szHint.width; 307 int target_width = szHint.width;
452 int target_height = target->szHint.height; 308 int target_height = szHint.height;
453 309
454 if (flags & propScale) 310 w = h_scale * target_width / 100;
311 h = v_scale * target_height / 100;
312
313 if (bg_flags & BG_KEEP_ASPECT)
455 { 314 {
456 float scale = (float)target_width / image_width; 315 float scale = (float)w / image_width;
457 min_it (scale, (float)target_height / image_height); 316 min_it (scale, (float)h / image_height);
458 w = image_width * scale + 0.5; 317 w = image_width * scale + 0.5;
459 h = image_height * scale + 0.5; 318 h = image_height * scale + 0.5;
460 } 319 }
461 else
462 {
463 w = h_scale * target_width / 100;
464 h = v_scale * target_height / 100;
465 }
466 320
467 if (!w) w = image_width; 321 if (!w) w = image_width;
468 if (!h) h = image_height; 322 if (!h) h = image_height;
469 323
470 if (flags & rootAlign) 324 if (bg_flags & BG_ROOT_ALIGN)
471 { 325 {
472 target->get_window_origin (x, y);
473 x = -x; 326 x = -target_x;
474 y = -y; 327 y = -target_y;
475 } 328 }
476 else 329 else
477 { 330 {
478 x = make_align_position (h_align, target_width, w); 331 x = make_align_position (h_align, target_width, w);
479 y = make_align_position (v_align, target_height, h); 332 y = make_align_position (v_align, target_height, h);
480 } 333 }
481 334
482 flags &= ~sizeSensitive; 335 if (!(bg_flags & BG_TILE)
483 if (h_scale != 0 || v_scale != 0 336 || h_scale || v_scale
484 || h_align != 0 || v_align != 0 337 || (!(bg_flags & BG_ROOT_ALIGN) && (h_align || v_align))
485 || w > target_width || h > target_height) 338 || image_width > target_width || image_height > target_height)
486 flags |= sizeSensitive; 339 bg_flags |= BG_IS_SIZE_SENSITIVE;
340 else
341 bg_flags &= ~BG_IS_SIZE_SENSITIVE;
487} 342}
488 343
489# ifdef HAVE_AFTERIMAGE 344# ifdef HAVE_PIXBUF
490bool 345bool
491bgPixmap_t::render_image (unsigned long background_flags) 346rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
347 int src_x, int src_y, int dst_x, int dst_y,
348 unsigned int width, unsigned int height)
492{ 349{
493 if (target == NULL) 350 XImage *ximage;
351 char *line;
352 int width_r, width_g, width_b, width_a;
353 int sh_r, sh_g, sh_b, sh_a;
354 uint32_t alpha_mask;
355 int rowstride;
356 int channels;
357 unsigned char *row;
358
359 if (visual->c_class != TrueColor)
494 return false; 360 return false;
495 361
496 target->init_asv (); 362#if XRENDER
363 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
364 if (format)
365 alpha_mask = (uint32_t)format->direct.alphaMask << format->direct.alpha;
366 else
367#endif
368 alpha_mask = 0;
497 369
498 ASImage *background = NULL; 370 width_r = ecb_popcount32 (visual->red_mask);
499 ARGB32 background_tint = TINT_LEAVE_SAME; 371 width_g = ecb_popcount32 (visual->green_mask);
372 width_b = ecb_popcount32 (visual->blue_mask);
373 width_a = ecb_popcount32 (alpha_mask);
500 374
501# ifdef ENABLE_TRANSPARENCY 375 if (width_r > 8 || width_g > 8 || width_b > 8 || width_a > 8)
502 if (background_flags) 376 return false;
503 background = pixmap2ximage (target->asv, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, 100);
504 377
505 if (!(background_flags & transpPmapTinted) && (flags & tintNeeded)) 378 sh_r = ecb_ctz32 (visual->red_mask);
506 { 379 sh_g = ecb_ctz32 (visual->green_mask);
507 ShadingInfo as_shade; 380 sh_b = ecb_ctz32 (visual->blue_mask);
508 as_shade.shading = shade; 381 sh_a = ecb_ctz32 (alpha_mask);
509 382
510 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 383 if (width > 32767 || height > 32767)
511 if (flags & tintSet) 384 return false;
512 tint.get (c);
513 as_shade.tintColor.red = c.r;
514 as_shade.tintColor.green = c.g;
515 as_shade.tintColor.blue = c.b;
516 385
517 background_tint = shading2tint32 (&as_shade); 386 ximage = XCreateImage (dpy, visual, depth, ZPixmap, 0, 0,
387 width, height, 32, 0);
388 if (!ximage)
389 return false;
390
391 if (height > INT_MAX / ximage->bytes_per_line
392 || !(ximage->data = (char *)malloc (height * ximage->bytes_per_line)))
518 } 393 {
519 394 XDestroyImage (ximage);
520 if (!(background_flags & transpPmapBlurred) && (flags & blurNeeded) && background != NULL) 395 return false;
521 { 396 }
522 ASImage *tmp = blur_asimage_gauss (target->asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF, 397
523 (original_asim == NULL || tint == TINT_LEAVE_SAME) ? ASA_XImage : ASA_ASImage, 398 ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
524 100, ASIMAGE_QUALITY_DEFAULT); 399
525 if (tmp) 400 rowstride = gdk_pixbuf_get_rowstride (pixbuf);
401 channels = gdk_pixbuf_get_n_channels (pixbuf);
402 row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels;
403 line = ximage->data;
404
405 rgba c (0, 0, 0);
406
407 if (channels == 4 && alpha_mask == 0)
408 {
409 pix_colors[Color_bg].get (c);
410 c.r >>= 8;
411 c.g >>= 8;
412 c.b >>= 8;
413 }
414
415 for (int y = 0; y < height; y++)
416 {
417 for (int x = 0; x < width; x++)
418 {
419 unsigned char *pixel = row + x * channels;
420 uint32_t value;
421 unsigned char r, g, b, a;
422
423 if (channels == 4)
526 { 424 {
527 destroy_asimage (&background); 425 a = pixel[3];
528 background = tmp; 426 r = (pixel[0] * a + c.r * (0xff - a)) / 0xff;
427 g = (pixel[1] * a + c.g * (0xff - a)) / 0xff;
428 b = (pixel[2] * a + c.b * (0xff - a)) / 0xff;
429 }
430 else
431 {
432 a = 0xff;
433 r = pixel[0];
434 g = pixel[1];
435 b = pixel[2];
436 }
437
438 value = ((r >> (8 - width_r)) << sh_r)
439 | ((g >> (8 - width_g)) << sh_g)
440 | ((b >> (8 - width_b)) << sh_b)
441 | ((a >> (8 - width_a)) << sh_a);
442
443 if (ximage->bits_per_pixel == 32)
444 ((uint32_t *)line)[x] = value;
445 else
446 XPutPixel (ximage, x, y, value);
529 } 447 }
530 }
531# endif
532 448
533 ASImage *result = 0; 449 row += rowstride;
450 line += ximage->bytes_per_line;
451 }
534 452
453 XPutImage (dpy, pixmap, gc, ximage, 0, 0, dst_x, dst_y, width, height);
454 XDestroyImage (ximage);
455 return true;
456}
457
458bool
459rxvt_term::render_image (bool transparent)
460{
461 if (!pixbuf)
462 return false;
463
464 if (transparent
465 && !(bg_flags & BG_HAS_RENDER))
466 return false;
467
468 GdkPixbuf *result;
469
470 int image_width = gdk_pixbuf_get_width (pixbuf);
471 int image_height = gdk_pixbuf_get_height (pixbuf);
472
535 int target_width = target->szHint.width; 473 int target_width = szHint.width;
536 int target_height = target->szHint.height; 474 int target_height = szHint.height;
537 int new_pmap_width = target_width; 475 int new_pmap_width = target_width;
538 int new_pmap_height = target_height; 476 int new_pmap_height = target_height;
539 477
540 int x = 0; 478 int x = 0;
541 int y = 0; 479 int y = 0;
542 int w = 0; 480 int w = 0;
543 int h = 0; 481 int h = 0;
544 482
545 TIMING_TEST_START (asim);
546
547 if (original_asim)
548 get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
549
550 if (!original_asim
551 || (!(flags & rootAlign)
552 && (x >= target_width
553 || y >= target_height
554 || (x + w <= 0)
555 || (y + h <= 0))))
556 {
557 if (background)
558 {
559 new_pmap_width = background->width;
560 new_pmap_height = background->height;
561 result = background;
562
563 if (background_tint != TINT_LEAVE_SAME)
564 {
565 ASImage *tmp = tile_asimage (target->asv, background, 0, 0,
566 target_width, target_height, background_tint,
567 ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
568 if (tmp)
569 result = tmp;
570 }
571 }
572 else
573 new_pmap_width = new_pmap_height = 0;
574 }
575 else
576 {
577 result = original_asim;
578
579 if ((w != original_asim->width)
580 || (h != original_asim->height))
581 {
582 result = scale_asimage (target->asv, original_asim,
583 w, h,
584 background ? ASA_ASImage : ASA_XImage,
585 100, ASIMAGE_QUALITY_DEFAULT);
586 }
587
588 if (background == NULL)
589 {
590 if (h_scale == 0 || v_scale == 0)
591 {
592 /* if tiling - pixmap has to be sized exactly as the image,
593 but there is no need to make it bigger than the window! */
594 new_pmap_width = min (result->width, target_width);
595 new_pmap_height = min (result->height, target_height);
596
597 /* we also need to tile our image in both directions */
598 ASImage *tmp = tile_asimage (target->asv, result,
599 (int)result->width - x,
600 (int)result->height - y,
601 new_pmap_width,
602 new_pmap_height,
603 TINT_LEAVE_SAME, ASA_XImage,
604 100, ASIMAGE_QUALITY_DEFAULT);
605 if (tmp)
606 {
607 if (result != original_asim)
608 destroy_asimage (&result);
609
610 result = tmp;
611 }
612 }
613 }
614 else
615 {
616 /* if blending background and image - pixmap has to be sized same as target window */
617 ASImageLayer *layers = create_image_layers (2);
618
619 layers[0].im = background;
620 layers[0].clip_width = target_width;
621 layers[0].clip_height = target_height;
622 layers[0].tint = background_tint;
623 layers[1].im = result;
624
625 if (h_scale == 0 || v_scale == 0)
626 {
627 /* tile horizontally */
628 while (x > 0) x -= (int)result->width;
629 layers[1].dst_x = x;
630 layers[1].clip_width = result->width+target_width;
631 }
632 else
633 {
634 /* clip horizontally */
635 layers[1].dst_x = x;
636 layers[1].clip_width = result->width;
637 }
638
639 if (h_scale == 0 || v_scale == 0)
640 {
641 while (y > 0) y -= (int)result->height;
642 layers[1].dst_y = y;
643 layers[1].clip_height = result->height + target_height;
644 }
645 else
646 {
647 layers[1].dst_y = y;
648 layers[1].clip_height = result->height;
649 }
650
651 if (target->rs[Rs_blendtype])
652 {
653 layers[1].merge_scanlines = blend_scanlines_name2func (target->rs[Rs_blendtype]);
654 if (layers[1].merge_scanlines == NULL)
655 layers[1].merge_scanlines = alphablend_scanlines;
656 }
657
658 ASImage *tmp = merge_layers (target->asv, layers, 2, target_width, target_height,
659 ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
660
661 if (tmp)
662 {
663 if (result != original_asim)
664 destroy_asimage (&result);
665
666 result = tmp;
667 }
668
669 free (layers);
670 }
671 }
672 TIMING_TEST_PRINT_RESULT (asim);
673
674 bool ret = false;
675
676 if (result)
677 {
678 XGCValues gcv;
679 GC gc;
680
681 if (pixmap)
682 {
683 if (pmap_width != new_pmap_width
684 || pmap_height != new_pmap_height
685 || pmap_depth != target->depth)
686 {
687 XFreePixmap (target->dpy, pixmap);
688 pixmap = None;
689 }
690 }
691
692 /* create Pixmap */
693 if (pixmap == None)
694 {
695 pixmap = XCreatePixmap (target->dpy, target->vt, new_pmap_width, new_pmap_height, target->depth);
696 pmap_width = new_pmap_width;
697 pmap_height = new_pmap_height;
698 pmap_depth = target->depth;
699 }
700 /* fill with background color (if result's not completely overlapping it) */
701 gcv.foreground = target->pix_colors[Color_bg];
702 gc = XCreateGC (target->dpy, target->vt, GCForeground, &gcv);
703
704 int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
705 int dst_width = result->width, dst_height = result->height;
706 if (background == NULL)
707 {
708 if (!(h_scale == 0 || v_scale == 0))
709 {
710 src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );
711 src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
712 }
713
714 if (dst_x > 0 || dst_y > 0
715 || dst_x + dst_width < new_pmap_width
716 || dst_y + dst_height < new_pmap_height)
717 XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
718 }
719
720 /* put result on pixmap */
721 if (dst_x < new_pmap_width && dst_y < new_pmap_height)
722 asimage2drawable (target->asv, pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);
723
724 if (result != background && result != original_asim)
725 destroy_asimage (&result);
726
727 XFreeGC (target->dpy, gc);
728 TIMING_TEST_PRINT_RESULT (asim);
729
730 ret = true;
731 }
732
733 if (background)
734 destroy_asimage (&background);
735
736 return ret;
737}
738# endif /* HAVE_AFTERIMAGE */
739
740# ifdef HAVE_PIXBUF
741bool
742bgPixmap_t::render_image (unsigned long background_flags)
743{
744 if (target == NULL)
745 return false;
746
747 if (!pixbuf)
748 return false;
749
750#if !XFT
751 if (background_flags)
752 return false;
753#endif
754
755 GdkPixbuf *result;
756
757 int image_width = gdk_pixbuf_get_width (pixbuf);
758 int image_height = gdk_pixbuf_get_height (pixbuf);
759
760 int target_width = target->szHint.width;
761 int target_height = target->szHint.height;
762 int new_pmap_width = target_width;
763 int new_pmap_height = target_height;
764
765 int x = 0;
766 int y = 0;
767 int w = 0;
768 int h = 0;
769
770 get_image_geometry (image_width, image_height, w, h, x, y); 483 get_image_geometry (image_width, image_height, w, h, x, y);
771 484
772 if (!(flags & rootAlign) 485 if (!(bg_flags & BG_ROOT_ALIGN)
773 && (x >= target_width 486 && (x >= target_width
774 || y >= target_height 487 || y >= target_height
775 || (x + w <= 0) 488 || x + w <= 0
776 || (y + h <= 0))) 489 || y + h <= 0))
777 return false; 490 return false;
778 491
779 result = pixbuf; 492 result = pixbuf;
780 493
781 if ((w != image_width) 494 if (w != image_width
782 || (h != image_height)) 495 || h != image_height)
783 { 496 {
784 result = gdk_pixbuf_scale_simple (pixbuf, 497 result = gdk_pixbuf_scale_simple (pixbuf,
785 w, h, 498 w, h,
786 GDK_INTERP_BILINEAR); 499 GDK_INTERP_BILINEAR);
787 } 500 }
788 501
502 if (!result)
503 return false;
504
789 bool ret = false; 505 bool ret = false;
790 506
791 if (result)
792 {
793 XGCValues gcv; 507 XGCValues gcv;
794 GC gc; 508 GC gc;
795 Pixmap root_pmap; 509 Pixmap root_pmap;
796 510
797 image_width = gdk_pixbuf_get_width (result); 511 image_width = gdk_pixbuf_get_width (result);
798 image_height = gdk_pixbuf_get_height (result); 512 image_height = gdk_pixbuf_get_height (result);
799 513
800 if (background_flags) 514 if (transparent)
801 { 515 {
802 root_pmap = pixmap; 516 root_pmap = bg_pixmap;
803 pixmap = None; 517 bg_pixmap = None;
518 }
519 else
520 {
521 if (bg_flags & BG_TILE)
522 {
523 new_pmap_width = min (image_width, target_width);
524 new_pmap_height = min (image_height, target_height);
804 } 525 }
805 else 526 }
806 {
807 if (h_scale == 0 || v_scale == 0)
808 {
809 new_pmap_width = min (image_width, target_width);
810 new_pmap_height = min (image_height, target_height);
811 }
812 }
813 527
528 if (bg_pixmap == None
529 || bg_pmap_width != new_pmap_width
530 || bg_pmap_height != new_pmap_height)
531 {
814 if (pixmap) 532 if (bg_pixmap)
815 {
816 if (pmap_width != new_pmap_width
817 || pmap_height != new_pmap_height
818 || pmap_depth != target->depth)
819 {
820 XFreePixmap (target->dpy, pixmap); 533 XFreePixmap (dpy, bg_pixmap);
821 pixmap = None;
822 }
823 }
824
825 if (pixmap == None)
826 {
827 pixmap = XCreatePixmap (target->dpy, target->vt, new_pmap_width, new_pmap_height, target->depth); 534 bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
828 pmap_width = new_pmap_width; 535 bg_pmap_width = new_pmap_width;
829 pmap_height = new_pmap_height; 536 bg_pmap_height = new_pmap_height;
830 pmap_depth = target->depth; 537 }
538
539 gcv.foreground = pix_colors[Color_bg];
540 gc = XCreateGC (dpy, vt, GCForeground, &gcv);
541
542 if (gc)
543 {
544 if (bg_flags & BG_TILE)
831 } 545 {
832
833 gcv.foreground = target->pix_colors[Color_bg];
834 gc = XCreateGC (target->dpy, target->vt, GCForeground, &gcv);
835
836 if (h_scale == 0 || v_scale == 0)
837 {
838 Pixmap tile = XCreatePixmap (target->dpy, target->vt, image_width, image_height, target->depth); 546 Pixmap tile = XCreatePixmap (dpy, vt, image_width, image_height, depth);
839 gdk_pixbuf_xlib_render_to_drawable (result, tile, gc, 547 pixbuf_to_pixmap (result, tile, gc,
840 0, 0, 548 0, 0,
841 0, 0, 549 0, 0,
842 image_width, image_height, 550 image_width, image_height);
843 XLIB_RGB_DITHER_NONE,
844 0, 0);
845 551
846 gcv.tile = tile; 552 gcv.tile = tile;
847 gcv.fill_style = FillTiled; 553 gcv.fill_style = FillTiled;
848 gcv.ts_x_origin = x; 554 gcv.ts_x_origin = x;
849 gcv.ts_y_origin = y; 555 gcv.ts_y_origin = y;
850 XChangeGC (target->dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); 556 XChangeGC (dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
851 557
852 XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height); 558 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
853 XFreePixmap (target->dpy, tile); 559 XFreePixmap (dpy, tile);
854 } 560 }
855 else 561 else
856 { 562 {
857 int src_x, src_y, dst_x, dst_y; 563 int src_x, src_y, dst_x, dst_y;
858 int dst_width, dst_height; 564 int dst_width, dst_height;
… …
861 src_y = make_clip_rectangle (y, image_height, new_pmap_height, dst_y, dst_height); 567 src_y = make_clip_rectangle (y, image_height, new_pmap_height, dst_y, dst_height);
862 568
863 if (dst_x > 0 || dst_y > 0 569 if (dst_x > 0 || dst_y > 0
864 || dst_x + dst_width < new_pmap_width 570 || dst_x + dst_width < new_pmap_width
865 || dst_y + dst_height < new_pmap_height) 571 || dst_y + dst_height < new_pmap_height)
866 XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height); 572 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
867 573
868 if (dst_x < new_pmap_width && dst_y < new_pmap_height) 574 if (dst_x < new_pmap_width && dst_y < new_pmap_height)
869 gdk_pixbuf_xlib_render_to_drawable (result, pixmap, gc, 575 pixbuf_to_pixmap (result, bg_pixmap, gc,
870 src_x, src_y, 576 src_x, src_y,
871 dst_x, dst_y, 577 dst_x, dst_y,
872 dst_width, dst_height, 578 dst_width, dst_height);
873 XLIB_RGB_DITHER_NONE,
874 0, 0);
875 } 579 }
876 580
877#if XFT 581#if XRENDER
878 if (background_flags) 582 if (transparent)
879 { 583 {
880 Display *dpy = target->dpy;
881 XRenderPictureAttributes pa;
882
883 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, target->display->screen)); 584 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
585
884 Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa); 586 Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
885 587
886 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, target->visual);
887 Picture dst = XRenderCreatePicture (dpy, pixmap, dst_format, 0, &pa); 588 Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
888 589
889 pa.repeat = True; 590 Picture mask = create_xrender_mask (dpy, vt, False, False);
890 Pixmap mask_pmap = XCreatePixmap (dpy, target->vt, 1, 1, 8);
891 XRenderPictFormat *mask_format = XRenderFindStandardFormat (dpy, PictStandardA8);
892 Picture mask = XRenderCreatePicture (dpy, mask_pmap, mask_format, CPRepeat, &pa);
893 XFreePixmap (dpy, mask_pmap);
894 591
895 if (src && dst && mask)
896 {
897 XRenderColor mask_c; 592 XRenderColor mask_c;
898 593
899 mask_c.alpha = 0x8000; 594 mask_c.alpha = 0x8000;
900 mask_c.red = 0; 595 mask_c.red =
901 mask_c.green = 0; 596 mask_c.green =
902 mask_c.blue = 0; 597 mask_c.blue = 0;
903 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1); 598 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
599
904 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height); 600 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
905 }
906 601
907 XRenderFreePicture (dpy, src); 602 XRenderFreePicture (dpy, src);
908 XRenderFreePicture (dpy, dst); 603 XRenderFreePicture (dpy, dst);
909 XRenderFreePicture (dpy, mask); 604 XRenderFreePicture (dpy, mask);
910
911 XFreePixmap (dpy, root_pmap);
912 } 605 }
913#endif 606#endif
914 607
915 if (result != pixbuf)
916 g_object_unref (result);
917
918 XFreeGC (target->dpy, gc); 608 XFreeGC (dpy, gc);
919 609
920 ret = true; 610 ret = true;
921 } 611 }
922 612
613 if (result != pixbuf)
614 g_object_unref (result);
615
616 if (transparent)
617 XFreePixmap (dpy, root_pmap);
618
923 return ret; 619 return ret;
924} 620}
925# endif /* HAVE_PIXBUF */ 621# endif /* HAVE_PIXBUF */
926 622
927bool 623bool
928bgPixmap_t::set_file (const char *file) 624rxvt_term::bg_set_file (const char *file)
929{ 625{
930 assert (file); 626 if (!file || !*file)
627 return false;
931 628
932 if (*file) 629 bool ret = false;
933 {
934 if (const char *p = strchr (file, ';')) 630 const char *p = strchr (file, ';');
935 { 631
632 if (p)
633 {
936 size_t len = p - file; 634 size_t len = p - file;
937 char *f = rxvt_temp_buf<char> (len + 1); 635 char *f = rxvt_temp_buf<char> (len + 1);
938 memcpy (f, file, len); 636 memcpy (f, file, len);
939 f[len] = '\0'; 637 f[len] = '\0';
940 file = f; 638 file = f;
941 } 639 }
942 640
943# ifdef HAVE_AFTERIMAGE 641# ifdef HAVE_PIXBUF
944 if (!target->asimman) 642 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
945 target->asimman = create_generic_imageman (target->rs[Rs_path]); 643 if (image)
946 original_asim = get_asimage (target->asimman, file, 0xFFFFFFFF, 100); 644 {
947 if (original_asim) 645 if (pixbuf)
948 have_image = true; 646 g_object_unref (pixbuf);
949 return have_image; 647 pixbuf = image;
648 bg_flags |= BG_IS_FROM_FILE;
649 ret = true;
650 }
950# endif 651# endif
951 652
952# ifdef HAVE_PIXBUF 653 if (ret)
953 pixbuf = gdk_pixbuf_new_from_file (file, NULL); 654 {
954 if (pixbuf) 655 if (p)
955 have_image = true; 656 bg_set_geometry (p + 1);
956 return have_image; 657 else
957# endif 658 bg_set_default_geometry ();
958 } 659 }
959 660
960 return false; 661 return ret;
961} 662}
962 663
963# endif /* BG_IMAGE_FROM_FILE */ 664# endif /* BG_IMAGE_FROM_FILE */
964 665
965# ifdef ENABLE_TRANSPARENCY 666# ifdef ENABLE_TRANSPARENCY
966bool 667bool
967bgPixmap_t::set_transparent () 668rxvt_term::bg_set_blur (const char *geom)
968{ 669{
969 if (!(flags & isTransparent)) 670 bool changed = false;
970 {
971 flags |= isTransparent;
972 return true;
973 }
974
975 return false;
976}
977
978bool
979bgPixmap_t::set_blur_radius (const char *geom)
980{
981 int changed = 0;
982 unsigned int hr, vr; 671 unsigned int hr, vr;
983 int junk; 672 int junk;
984 int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr); 673 int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr);
985 674
986 if (!(geom_flags & WidthValue)) 675 if (!(geom_flags & WidthValue))
… …
991 min_it (hr, 128); 680 min_it (hr, 128);
992 min_it (vr, 128); 681 min_it (vr, 128);
993 682
994 if (h_blurRadius != hr) 683 if (h_blurRadius != hr)
995 { 684 {
996 ++changed; 685 changed = true;
997 h_blurRadius = hr; 686 h_blurRadius = hr;
998 } 687 }
999 688
1000 if (v_blurRadius != vr) 689 if (v_blurRadius != vr)
1001 { 690 {
1002 ++changed; 691 changed = true;
1003 v_blurRadius = vr; 692 v_blurRadius = vr;
1004 } 693 }
1005 694
1006 if (v_blurRadius == 0 && h_blurRadius == 0)
1007 flags &= ~blurNeeded;
1008 else
1009 flags |= blurNeeded;
1010
1011#if XFT
1012 XFilters *filters = XRenderQueryFilters (target->dpy, target->display->root);
1013 if (filters)
1014 {
1015 for (int i = 0; i < filters->nfilter; i++)
1016 if (!strcmp (filters->filter[i], FilterConvolution))
1017 flags |= bgPixmap_t::blurServerSide;
1018
1019 XFree (filters);
1020 }
1021#endif
1022
1023 return (changed > 0); 695 return changed;
1024} 696}
1025 697
1026static inline unsigned long 698bool
1027compute_tint_shade_flags (rxvt_color *tint, int shade) 699rxvt_term::bg_set_tint (rxvt_color &new_tint)
1028{ 700{
1029 unsigned long flags = 0; 701 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
1030 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1031 bool has_shade = shade != 100;
1032
1033 if (tint)
1034 { 702 {
703 tint = new_tint;
704 bg_flags |= BG_TINT_SET;
705
706 rgba c;
1035 tint->get (c); 707 tint.get (c);
1036# define IS_COMPONENT_WHOLESOME(cmp) ((cmp) <= 0x000700 || (cmp) >= 0x00f700) 708 if ((c.r <= 0x00ff || c.r >= 0xff00)
1037 if (!has_shade && IS_COMPONENT_WHOLESOME (c.r) 709 && (c.g <= 0x00ff || c.g >= 0xff00)
1038 && IS_COMPONENT_WHOLESOME (c.g) 710 && (c.b <= 0x00ff || c.b >= 0xff00))
1039 && IS_COMPONENT_WHOLESOME (c.b)) 711 bg_flags |= BG_TINT_BITAND;
1040 flags |= bgPixmap_t::tintWholesome;
1041# undef IS_COMPONENT_WHOLESOME
1042 }
1043
1044 if (has_shade)
1045 flags |= bgPixmap_t::tintNeeded;
1046 else if (tint)
1047 {
1048 if ((c.r > 0x000700 || c.g > 0x000700 || c.b > 0x000700)
1049 && (c.r < 0x00f700 || c.g < 0x00f700 || c.b < 0x00f700))
1050 {
1051 flags |= bgPixmap_t::tintNeeded;
1052 }
1053 }
1054
1055 if (flags & bgPixmap_t::tintNeeded)
1056 {
1057 if (flags & bgPixmap_t::tintWholesome)
1058 flags |= bgPixmap_t::tintServerSide;
1059 else 712 else
1060 { 713 bg_flags &= ~BG_TINT_BITAND;
1061#if XFT
1062 flags |= bgPixmap_t::tintServerSide;
1063#endif
1064 }
1065 }
1066 714
1067 return flags;
1068}
1069
1070bool
1071bgPixmap_t::set_tint (rxvt_color &new_tint)
1072{
1073 if (!(flags & tintSet) || tint != new_tint)
1074 {
1075 unsigned long new_flags = compute_tint_shade_flags (&new_tint, shade);
1076 tint = new_tint;
1077 flags = (flags & ~tintFlags) | new_flags | tintSet;
1078 return true; 715 return true;
1079 } 716 }
1080 717
1081 return false; 718 return false;
1082} 719}
1083 720
1084bool 721bool
1085bgPixmap_t::unset_tint ()
1086{
1087 unsigned long new_flags = compute_tint_shade_flags (NULL, shade);
1088
1089 if (new_flags != (flags & tintFlags))
1090 {
1091 flags = (flags & ~tintFlags) | new_flags;
1092 return true;
1093 }
1094
1095 return false;
1096}
1097
1098bool
1099bgPixmap_t::set_shade (const char *shade_str) 722rxvt_term::bg_set_shade (const char *shade_str)
1100{ 723{
1101 int new_shade = (shade_str) ? atoi (shade_str) : 100; 724 int new_shade = atoi (shade_str);
1102 725
1103 clamp_it (new_shade, -100, 200); 726 clamp_it (new_shade, -100, 200);
1104 if (new_shade < 0) 727 if (new_shade < 0)
1105 new_shade = 200 - (100 + new_shade); 728 new_shade = 200 - (100 + new_shade);
1106 729
1107 if (new_shade != shade) 730 if (new_shade != shade)
1108 { 731 {
1109 unsigned long new_flags = compute_tint_shade_flags ((flags & tintSet) ? &tint : NULL, new_shade);
1110 shade = new_shade; 732 shade = new_shade;
1111 flags = (flags & (~tintFlags | tintSet)) | new_flags;
1112 return true; 733 return true;
1113 } 734 }
1114 735
1115 return false; 736 return false;
1116} 737}
1117 738
739#if XRENDER
1118static void 740static void
1119get_gaussian_kernel (int radius, int width, double *kernel, XFixed *params) 741get_gaussian_kernel (int radius, int width, double *kernel, XFixed *params)
1120{ 742{
1121 double sigma = radius / 2.0; 743 double sigma = radius / 2.0;
1122 double scale = sqrt (2.0 * M_PI) * sigma; 744 double scale = sqrt (2.0 * M_PI) * sigma;
1123 double sum = 0.0; 745 double sum = 0.0;
1124 746
1125 for (int i = 0; i < width; i++) 747 for (int i = 0; i < width; i++)
1126 { 748 {
1127 double x = i - width / 2; 749 double x = i - width / 2;
1128 kernel[i] = exp (-(x * x) / (2.0 * sigma * sigma)) / scale; 750 kernel[i] = exp (-(x * x) / (2.0 * sigma * sigma)) / scale;
1129 sum += kernel[i]; 751 sum += kernel[i];
1130 } 752 }
1131 753
1132 params[0] = XDoubleToFixed (width); 754 params[0] = XDoubleToFixed (width);
1133 params[1] = XDoubleToFixed (1); 755 params[1] = XDoubleToFixed (1);
1134 756
1135 for (int i = 0; i < width; i++) 757 for (int i = 0; i < width; i++)
1136 params[i+2] = XDoubleToFixed (kernel[i] / sum); 758 params[i+2] = XDoubleToFixed (kernel[i] / sum);
1137} 759}
760#endif
1138 761
1139bool 762bool
1140bgPixmap_t::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 763rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height, int depth)
1141{ 764{
1142 bool ret = false; 765 bool ret = false;
1143#if XFT 766#if XRENDER
767 if (!(bg_flags & BG_HAS_RENDER_CONV))
768 return false;
769
1144 int size = max (h_blurRadius, v_blurRadius) * 2 + 1; 770 int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1145 double *kernel = (double *)malloc (size * sizeof (double)); 771 double *kernel = (double *)malloc (size * sizeof (double));
1146 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 772 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1147 773
1148 Display *dpy = target->dpy;
1149 XRenderPictureAttributes pa; 774 XRenderPictureAttributes pa;
1150 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, target->visual); 775 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1151 776
777 pa.repeat = RepeatPad;
1152 Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 778 Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
779 Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1153 Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 780 Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
781 XFreePixmap (dpy, tmp);
1154 782
1155 if (kernel && params && src && dst) 783 if (kernel && params)
1156 { 784 {
1157 if (h_blurRadius)
1158 {
1159 size = h_blurRadius * 2 + 1; 785 size = h_blurRadius * 2 + 1;
1160 get_gaussian_kernel (h_blurRadius, size, kernel, params); 786 get_gaussian_kernel (h_blurRadius, size, kernel, params);
1161 787
1162 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 788 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1163 XRenderComposite (dpy, 789 XRenderComposite (dpy,
1164 PictOpSrc, 790 PictOpSrc,
1165 src, 791 src,
1166 None, 792 None,
1167 dst, 793 dst,
1168 0, 0, 794 0, 0,
1169 0, 0, 795 0, 0,
1170 0, 0, 796 0, 0,
1171 width, height); 797 width, height);
1172 }
1173 798
1174 if (v_blurRadius) 799 ::swap (src, dst);
1175 { 800
1176 size = v_blurRadius * 2 + 1; 801 size = v_blurRadius * 2 + 1;
1177 get_gaussian_kernel (v_blurRadius, size, kernel, params); 802 get_gaussian_kernel (v_blurRadius, size, kernel, params);
1178 swap (params[0], params[1]); 803 ::swap (params[0], params[1]);
1179 804
1180 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 805 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1181 XRenderComposite (dpy, 806 XRenderComposite (dpy,
1182 PictOpSrc, 807 PictOpSrc,
1183 src, 808 src,
1184 None, 809 None,
1185 dst, 810 dst,
1186 0, 0, 811 0, 0,
1187 0, 0, 812 0, 0,
1188 0, 0, 813 0, 0,
1189 width, height); 814 width, height);
1190 }
1191 815
1192 ret = true; 816 ret = true;
1193 } 817 }
1194 818
1195 free (kernel); 819 free (kernel);
… …
1199#endif 823#endif
1200 return ret; 824 return ret;
1201} 825}
1202 826
1203bool 827bool
1204bgPixmap_t::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 828rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1205{ 829{
1206 Display *dpy = target->dpy;
1207 bool ret = false; 830 bool ret = false;
1208 831
1209 if (flags & tintWholesome) 832 if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1210 { 833 {
1211 XGCValues gcv; 834 XGCValues gcv;
1212 GC gc; 835 GC gc;
1213 836
1214 /* In this case we can tint image server-side getting significant 837 /* In this case we can tint image server-side getting significant
… …
1223 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height); 846 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1224 ret = true; 847 ret = true;
1225 XFreeGC (dpy, gc); 848 XFreeGC (dpy, gc);
1226 } 849 }
1227 } 850 }
1228 else 851# if XRENDER
852 else if (bg_flags & BG_HAS_RENDER)
1229 { 853 {
1230# if XFT
1231 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 854 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1232 855
1233 if (flags & tintSet) 856 if (bg_flags & BG_TINT_SET)
1234 tint.get (c); 857 tint.get (c);
1235 858
1236 if (shade <= 100) 859 if (shade <= 100)
1237 { 860 {
1238 c.r = (c.r * shade) / 100; 861 c.r = c.r * shade / 100;
1239 c.g = (c.g * shade) / 100; 862 c.g = c.g * shade / 100;
1240 c.b = (c.b * shade) / 100; 863 c.b = c.b * shade / 100;
1241 } 864 }
1242 else 865 else
1243 { 866 {
1244 c.r = ((0xffff - c.r) * (200 - shade)) / 100; 867 c.r = c.r * (200 - shade) / 100;
1245 c.g = ((0xffff - c.g) * (200 - shade)) / 100; 868 c.g = c.g * (200 - shade) / 100;
1246 c.b = ((0xffff - c.b) * (200 - shade)) / 100; 869 c.b = c.b * (200 - shade) / 100;
1247 } 870 }
1248 871
1249 XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1250 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 872 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1251 XRenderPictureAttributes pa;
1252 873
1253 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 874 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1254 875
1255 pa.repeat = True; 876 Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1256 877
1257 Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32); 878 Picture mask_pic = create_xrender_mask (dpy, pixmap, True, True);
1258 Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1259 XFreePixmap (dpy, overlay_pmap);
1260 879
1261 pa.component_alpha = True;
1262 Pixmap mask_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
1263 Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat|CPComponentAlpha, &pa);
1264 XFreePixmap (dpy, mask_pmap);
1265
1266 if (mask_pic && overlay_pic && back_pic)
1267 {
1268 XRenderColor mask_c; 880 XRenderColor mask_c;
1269 881
1270 memset (&mask_c, (shade > 100) ? 0xFF : 0x0, sizeof (mask_c));
1271 mask_c.alpha = 0xffff; 882 mask_c.alpha = 0xffff;
883 mask_c.red =
884 mask_c.green =
885 mask_c.blue = 0;
886 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
887
888 mask_c.alpha = 0;
889 mask_c.red = 0xffff - c.r;
890 mask_c.green = 0xffff - c.g;
891 mask_c.blue = 0xffff - c.b;
892 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
893
894 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
895
896 if (shade > 100)
897 {
898 mask_c.alpha = 0;
899 mask_c.red =
900 mask_c.green =
901 mask_c.blue = 0xffff * (shade - 100) / 100;
1272 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1); 902 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1273 903
1274 mask_c.alpha = 0;
1275 mask_c.red = 0xffff - c.r;
1276 mask_c.green = 0xffff - c.g;
1277 mask_c.blue = 0xffff - c.b;
1278 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
1279 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height); 904 XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1280 ret = true;
1281 } 905 }
906
907 ret = true;
1282 908
1283 XRenderFreePicture (dpy, mask_pic); 909 XRenderFreePicture (dpy, mask_pic);
1284 XRenderFreePicture (dpy, overlay_pic); 910 XRenderFreePicture (dpy, overlay_pic);
1285 XRenderFreePicture (dpy, back_pic); 911 XRenderFreePicture (dpy, back_pic);
1286# if DO_TIMING_TEST 912 }
1287 XSync (dpy, False);
1288# endif
1289# endif 913# endif
1290 }
1291 914
1292 return ret; 915 return ret;
1293} 916}
1294 917
1295/* make_transparency_pixmap() 918/*
1296 * Builds a pixmap sized the same as terminal window, with depth same as the root window 919 * Builds a pixmap of the same size as the terminal window that contains
1297 * that pixmap contains tiled portion of the root pixmap that is supposed to be covered by 920 * the tiled portion of the root pixmap that is supposed to be covered by
1298 * our window. 921 * our window.
1299 */ 922 */
1300unsigned long 923bool
1301bgPixmap_t::make_transparency_pixmap () 924rxvt_term::make_transparency_pixmap ()
1302{ 925{
1303 unsigned long result = 0; 926 bool ret = false;
1304
1305 if (target == NULL)
1306 return 0;
1307 927
1308 /* root dimensions may change from call to call - but Display structure should 928 /* root dimensions may change from call to call - but Display structure should
1309 * be always up-to-date, so let's use it : 929 * be always up-to-date, so let's use it :
1310 */ 930 */
1311 Window root = target->display->root;
1312 int screen = target->display->screen; 931 int screen = display->screen;
1313 Display *dpy = target->dpy; 932 int root_depth = DefaultDepth (dpy, screen);
1314 int root_width = DisplayWidth (dpy, screen); 933 int root_width = DisplayWidth (dpy, screen);
1315 int root_height = DisplayHeight (dpy, screen); 934 int root_height = DisplayHeight (dpy, screen);
1316 unsigned int root_pmap_width, root_pmap_height; 935 unsigned int root_pmap_width, root_pmap_height;
1317 int window_width = target->szHint.width; 936 int window_width = szHint.width;
1318 int window_height = target->szHint.height; 937 int window_height = szHint.height;
1319 int sx, sy; 938 int sx, sy;
1320 XGCValues gcv; 939 XGCValues gcv;
940 GC gc;
1321 941
1322 TIMING_TEST_START (tp); 942 sx = target_x;
1323 target->get_window_origin (sx, sy); 943 sy = target_y;
1324 944
1325 /* check if we are outside of the visible part of the virtual screen : */ 945 /* check if we are outside of the visible part of the virtual screen : */
1326 if (sx + window_width <= 0 || sy + window_height <= 0 946 if (sx + window_width <= 0 || sy + window_height <= 0
1327 || sx >= root_width || sy >= root_height) 947 || sx >= root_width || sy >= root_height)
1328 return 0; 948 return 0;
1329 949
950 // validate root pixmap and get its size
1330 if (root_pixmap != None) 951 if (root_pixmap != None)
1331 { 952 {
1332 /* we want to validate the pixmap and get its size at the same time : */ 953 Window wdummy;
1333 int junk; 954 int idummy;
1334 unsigned int ujunk; 955 unsigned int udummy;
1335 /* root pixmap may be bad - allow a error */ 956
1336 target->allowedxerror = -1; 957 allowedxerror = -1;
1337 958
1338 if (!XGetGeometry (dpy, root_pixmap, &root, &junk, &junk, &root_pmap_width, &root_pmap_height, &ujunk, &ujunk)) 959 if (!XGetGeometry (dpy, root_pixmap, &wdummy, &idummy, &idummy, &root_pmap_width, &root_pmap_height, &udummy, &udummy))
1339 root_pixmap = None; 960 root_pixmap = None;
1340 961
1341 target->allowedxerror = 0; 962 allowedxerror = 0;
1342 }
1343
1344 Pixmap tiled_root_pmap = XCreatePixmap (dpy, root, window_width, window_height, root_depth);
1345 GC gc = NULL;
1346
1347 if (tiled_root_pmap == None) /* something really bad happened - abort */
1348 return 0;
1349
1350 if (root_pixmap == None)
1351 { 963 }
1352 /* use tricks to obtain the root background image :*/
1353 /* we want to create Overrideredirect window overlapping out window
1354 with background type of Parent Relative and then grab it */
1355 XSetWindowAttributes attr;
1356 Window src;
1357 bool success = false;
1358 964
1359 attr.background_pixmap = ParentRelative; 965 Pixmap recoded_root_pmap = root_pixmap;
1360 attr.backing_store = Always;
1361 attr.event_mask = ExposureMask;
1362 attr.override_redirect = True;
1363 src = XCreateWindow (dpy, root, sx, sy, window_width, window_height, 0,
1364 CopyFromParent, CopyFromParent, CopyFromParent,
1365 CWBackPixmap|CWBackingStore|CWOverrideRedirect|CWEventMask,
1366 &attr);
1367 966
1368 if (src != None) 967 if (root_pixmap != None && root_depth != depth)
1369 { 968 {
1370 XEvent event; 969#if XRENDER
1371 int ev_count = 0; 970 if (bg_flags & BG_HAS_RENDER)
1372 XGrabServer (dpy);
1373 XMapRaised (dpy, src);
1374 XSync (dpy, False);
1375
1376 /* XSync should get window where it's properly exposed,
1377 * but to be on the safe side - let's check for the actual event to arrive : */
1378 while (XCheckWindowEvent (dpy, src, ExposureMask, &event))
1379 ++ev_count;
1380
1381 if (ev_count > 0);
1382 {
1383 /* hooray! - we can grab the image! */
1384 gc = XCreateGC (dpy, root, 0, NULL);
1385 if (gc)
1386 {
1387 XCopyArea (dpy, src, tiled_root_pmap, gc, 0, 0, window_width, window_height, 0, 0);
1388 success = true;
1389 }
1390 }
1391
1392 XDestroyWindow (dpy, src);
1393 XUngrabServer (dpy);
1394 //fprintf (stderr, "%s:%d: ev_count = %d\n", __FUNCTION__, __LINE__, ev_count);
1395 } 971 {
972 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1396 973
1397 if (!success) 974 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1398 { 975 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1399 XFreePixmap (dpy, tiled_root_pmap); 976
1400 tiled_root_pmap = None; 977 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
978 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
979
980 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
981
982 XRenderFreePicture (dpy, src);
983 XRenderFreePicture (dpy, dst);
1401 } 984 }
1402 else 985 else
1403 result |= transpPmapTiled; 986#endif
1404 } 987 recoded_root_pmap = None;
1405 else
1406 { 988 }
989
990 if (recoded_root_pmap == None)
991 return 0;
992
993 if (bg_pixmap == None
994 || bg_pmap_width != window_width
995 || bg_pmap_height != window_height)
996 {
997 if (bg_pixmap)
998 XFreePixmap (dpy, bg_pixmap);
999 bg_pixmap = XCreatePixmap (dpy, vt, window_width, window_height, depth);
1000 bg_pmap_width = window_width;
1001 bg_pmap_height = window_height;
1002 }
1003
1407 /* straightforward pixmap copy */ 1004 /* straightforward pixmap copy */
1005 while (sx < 0) sx += root_pmap_width;
1006 while (sy < 0) sy += root_pmap_height;
1007
1408 gcv.tile = root_pixmap; 1008 gcv.tile = recoded_root_pmap;
1409 gcv.fill_style = FillTiled; 1009 gcv.fill_style = FillTiled;
1410
1411 while (sx < 0) sx += (int)root_width;
1412 while (sy < 0) sy += (int)root_height;
1413
1414 gcv.ts_x_origin = -sx; 1010 gcv.ts_x_origin = -sx;
1415 gcv.ts_y_origin = -sy; 1011 gcv.ts_y_origin = -sy;
1416 gc = XCreateGC (dpy, root, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); 1012 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1417 1013
1418 if (gc) 1014 if (gc)
1419 { 1015 {
1420 XFillRectangle (dpy, tiled_root_pmap, gc, 0, 0, window_width, window_height); 1016 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1421 result |= transpPmapTiled; 1017 ret = true;
1018 bool need_blur = h_blurRadius && v_blurRadius;
1019 bool need_tint = shade != 100 || (bg_flags & BG_TINT_SET);
1020
1021 if (!(bg_flags & BG_CLIENT_RENDER))
1022 {
1023 if (need_blur)
1024 {
1025 if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth))
1026 need_blur = false;
1027 }
1028 if (need_tint)
1029 {
1030 if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1031 need_tint = false;
1032 }
1033 if (need_tint)
1034 {
1035 XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1036 if (ximage)
1037 {
1038 /* our own client-side tinting */
1039 tint_ximage (DefaultVisual (dpy, display->screen), ximage);
1040
1041 XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
1042 XDestroyImage (ximage);
1043 }
1044 }
1045 } /* server side rendering completed */
1046
1047 XFreeGC (dpy, gc);
1048 }
1049
1050 if (recoded_root_pmap != root_pixmap)
1051 XFreePixmap (dpy, recoded_root_pmap);
1052
1053 return ret;
1054}
1055
1056void
1057rxvt_term::bg_set_root_pixmap ()
1058{
1059 Pixmap new_root_pixmap = get_pixmap_property (xa[XA_XROOTPMAP_ID]);
1060 if (new_root_pixmap == None)
1061 new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]);
1062
1063 root_pixmap = new_root_pixmap;
1064}
1065# endif /* ENABLE_TRANSPARENCY */
1066
1067bool
1068rxvt_term::bg_render ()
1069{
1070 bool transparent = false;
1071
1072 bg_invalidate ();
1073# ifdef ENABLE_TRANSPARENCY
1074 if (bg_flags & BG_IS_TRANSPARENT)
1075 {
1076 /* we need to re-generate transparency pixmap in that case ! */
1077 transparent = make_transparency_pixmap ();
1078 if (transparent)
1079 bg_flags |= BG_IS_VALID;
1080 }
1081# endif
1082
1083# ifdef BG_IMAGE_FROM_FILE
1084 if (bg_flags & BG_IS_FROM_FILE)
1085 {
1086 if (render_image (transparent))
1087 bg_flags |= BG_IS_VALID;
1088 }
1089# endif
1090
1091 if (!(bg_flags & BG_IS_VALID))
1092 {
1093 if (bg_pixmap != None)
1094 {
1095 XFreePixmap (dpy, bg_pixmap);
1096 bg_pixmap = None;
1422 } 1097 }
1423 } 1098 }
1424 TIMING_TEST_PRINT_RESULT (tp);
1425 1099
1426 if (tiled_root_pmap != None) 1100 scr_recolour (false);
1427 { 1101 bg_flags |= BG_NEEDS_REFRESH;
1428 if (!need_client_side_rendering ())
1429 {
1430 if ((flags & blurNeeded))
1431 {
1432 if (blur_pixmap (tiled_root_pmap, DefaultVisual (dpy, target->display->screen), window_width, window_height))
1433 result |= transpPmapBlurred;
1434 }
1435 if ((flags & tintNeeded))
1436 {
1437 if (tint_pixmap (tiled_root_pmap, DefaultVisual (dpy, target->display->screen), window_width, window_height))
1438 result |= transpPmapTinted;
1439 }
1440 } /* server side rendering completed */
1441 1102
1442 if (pixmap)
1443 XFreePixmap (dpy, pixmap);
1444
1445 pixmap = tiled_root_pmap;
1446 pmap_width = window_width;
1447 pmap_height = window_height;
1448 pmap_depth = root_depth;
1449 }
1450
1451 if (gc)
1452 XFreeGC (dpy, gc);
1453
1454 TIMING_TEST_PRINT_RESULT (tp);
1455
1456 return result;
1457}
1458
1459bool
1460bgPixmap_t::set_root_pixmap ()
1461{
1462 Pixmap new_root_pixmap = target->get_pixmap_property (XA_XROOTPMAP_ID);
1463 if (new_root_pixmap == None)
1464 new_root_pixmap = target->get_pixmap_property (XA_ESETROOT_PMAP_ID);
1465
1466 if (new_root_pixmap != root_pixmap)
1467 {
1468 root_pixmap = new_root_pixmap;
1469 return true;
1470 }
1471
1472 return false;
1473}
1474# endif /* ENABLE_TRANSPARENCY */
1475
1476# ifndef HAVE_AFTERIMAGE
1477static void ShadeXImage(rxvt_term *term, XImage *srcImage, int shade, int rm, int gm, int bm);
1478# endif
1479
1480bool
1481bgPixmap_t::render ()
1482{
1483 unsigned long background_flags = 0;
1484
1485 if (target == NULL)
1486 return false;
1487
1488 TIMING_TEST_START (tp);
1489
1490 invalidate ();
1491# ifdef ENABLE_TRANSPARENCY
1492 if (flags & isTransparent)
1493 {
1494 /* we need to re-generate transparency pixmap in that case ! */
1495 background_flags = make_transparency_pixmap ();
1496 if (background_flags == 0)
1497 return false;
1498 else if ((background_flags & transpTransformations) == (flags & transpTransformations)
1499 && pmap_depth == target->depth)
1500 flags = flags & ~isInvalid;
1501 }
1502# endif
1503
1504# ifdef BG_IMAGE_FROM_FILE
1505 if (have_image
1506 || (background_flags & transpTransformations) != (flags & transpTransformations))
1507 {
1508 if (render_image (background_flags))
1509 flags = flags & ~isInvalid;
1510 }
1511# endif
1512
1513 XImage *result = NULL;
1514
1515 if (background_flags && (flags & isInvalid))
1516 {
1517 result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap);
1518 }
1519
1520 if (result)
1521 {
1522# if !defined(HAVE_AFTERIMAGE) && !XFT
1523 /* our own client-side tinting */
1524 /* ATTENTION: We ASSUME that XFT will let us do all the tinting necessary server-side.
1525 This may need to be changed in need_client_side_rendering() logic is altered !!! */
1526 if (!(background_flags & transpPmapTinted) && (flags & tintNeeded))
1527 {
1528 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1529 if (flags & tintSet)
1530 tint.get (c);
1531 ShadeXImage (target, result, shade, c.r, c.g, c.b);
1532 }
1533# endif
1534
1535 GC gc = XCreateGC (target->dpy, target->vt, 0UL, NULL);
1536
1537 if (gc)
1538 {
1539 if (/*pmap_depth != target->depth &&*/ pixmap != None)
1540 {
1541 XFreePixmap (target->dpy, pixmap);
1542 pixmap = None;
1543 }
1544
1545 if (pixmap == None)
1546 {
1547 pixmap = XCreatePixmap (target->dpy, target->vt, result->width, result->height, target->depth);
1548 pmap_width = result->width;
1549 pmap_height = result->height;
1550 pmap_depth = target->depth;
1551 }
1552
1553 if (pmap_depth != result->depth)
1554 {
1555 /* Bad Match error will ensue ! stupid X !!!! */
1556 if (result->depth == 24 && pmap_depth == 32)
1557 result->depth = 32;
1558 else if (result->depth == 32 && pmap_depth == 24)
1559 result->depth = 24;
1560 else
1561 {
1562 /* TODO: implement image recoding */
1563 }
1564 }
1565
1566 if (pmap_depth == result->depth)
1567 XPutImage (target->dpy, pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1568
1569 XFreeGC (target->dpy, gc);
1570 flags = flags & ~isInvalid;
1571 }
1572
1573 XDestroyImage (result);
1574 }
1575
1576 if (flags & isInvalid)
1577 {
1578 if (pixmap != None)
1579 {
1580 XFreePixmap (target->dpy, pixmap);
1581 pixmap = None;
1582 }
1583 }
1584
1585 apply ();
1586
1587 XSync (target->dpy, False);
1588 valid_since = ev::now (); 1103 bg_valid_since = ev::now ();
1589
1590 TIMING_TEST_PRINT_RESULT (tp);
1591 1104
1592 return true; 1105 return true;
1593} 1106}
1594 1107
1595bool
1596bgPixmap_t::set_target (rxvt_term *new_target)
1597{
1598 if (new_target)
1599 if (target != new_target)
1600 {
1601 target = new_target;
1602# ifdef ENABLE_TRANSPARENCY
1603 root_depth = DefaultDepthOfScreen (ScreenOfDisplay (target->dpy, target->display->screen));
1604# endif
1605 return true;
1606 }
1607
1608 return false;
1609}
1610
1611void 1108void
1612bgPixmap_t::apply () 1109rxvt_term::bg_init ()
1613{ 1110{
1614 if (target)
1615 {
1616 flags &= ~isVtOrigin;
1617
1618 if (pixmap != None)
1619 {
1620 /* set target's background to pixmap */
1621# ifdef ENABLE_TRANSPARENCY 1111#ifdef ENABLE_TRANSPARENCY
1622 if (flags & isTransparent) 1112 shade = 100;
1623 {
1624 XSetWindowBackgroundPixmap (target->dpy, target->parent[0], pixmap);
1625 XSetWindowBackgroundPixmap (target->dpy, target->vt, ParentRelative);
1626
1627 if (target->scrollBar.win)
1628 XSetWindowBackgroundPixmap (target->dpy, target->scrollBar.win, ParentRelative);
1629 }
1630 else
1631# endif 1113#endif
1632 {
1633 flags |= isVtOrigin;
1634 /* force old pixmap dereference in case it was transparent before :*/
1635 XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
1636 XSetWindowBackgroundPixmap (target->dpy, target->vt, pixmap);
1637 /* do we also need to set scrollbar's background here ? */
1638 1114
1639 if (target->scrollBar.win) 1115 bg_flags &= ~(BG_HAS_RENDER | BG_HAS_RENDER_CONV);
1640 XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]); 1116#if XRENDER
1641 } 1117 int major, minor;
1642 } 1118 if (XRenderQueryVersion (dpy, &major, &minor))
1643 else 1119 bg_flags |= BG_HAS_RENDER;
1644 { 1120 XFilters *filters = XRenderQueryFilters (dpy, vt);
1645 /* set target background to a pixel */ 1121 if (filters)
1646 XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
1647 XSetWindowBackground (target->dpy, target->vt, target->pix_colors[Color_bg]);
1648 /* do we also need to set scrollbar's background here ? */
1649 if (target->scrollBar.win)
1650 XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);
1651 }
1652
1653 /* don't want Expose on the parent or vt. It is better to use
1654 scr_touch or we get a great deal of flicker otherwise: */
1655 XClearWindow (target->dpy, target->parent[0]);
1656
1657 if (target->scrollBar.state && target->scrollBar.win)
1658 {
1659 target->scrollBar.state = STATE_IDLE;
1660 target->scrollBar.show (0);
1661 }
1662
1663 target->want_refresh = 1;
1664 flags |= hasChanged;
1665 } 1122 {
1123 for (int i = 0; i < filters->nfilter; i++)
1124 if (!strcmp (filters->filter[i], FilterConvolution))
1125 bg_flags |= BG_HAS_RENDER_CONV;
1126
1127 XFree (filters);
1128 }
1129#endif
1666} 1130}
1667 1131
1668#endif /* HAVE_BG_PIXMAP */ 1132#endif /* HAVE_BG_PIXMAP */
1669 1133
1670#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) && !XFT 1134#ifdef ENABLE_TRANSPARENCY
1671/* taken from aterm-0.4.2 */ 1135/* based on code from aterm-0.4.2 */
1672 1136
1673typedef uint32_t RUINT32T;
1674
1675static void 1137static inline void
1676ShadeXImage(rxvt_term *term, XImage *srcImage, int shade, int rm, int gm, int bm) 1138fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
1677{ 1139{
1140 for (int i = 0; i <= mask >> sh; i++)
1141 {
1142 uint32_t tmp;
1143 tmp = i * high;
1144 tmp += (mask >> sh) * low;
1145 lookup[i] = (tmp / 0xffff) << sh;
1146 }
1147}
1148
1149void
1150rxvt_term::tint_ximage (Visual *visual, XImage *ximage)
1151{
1152 unsigned int size_r, size_g, size_b;
1678 int sh_r, sh_g, sh_b; 1153 int sh_r, sh_g, sh_b;
1679 RUINT32T mask_r, mask_g, mask_b; 1154 uint32_t mask_r, mask_g, mask_b;
1680 RUINT32T *lookup, *lookup_r, *lookup_g, *lookup_b; 1155 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1681 unsigned int lower_lim_r, lower_lim_g, lower_lim_b; 1156 unsigned short low;
1682 unsigned int upper_lim_r, upper_lim_g, upper_lim_b; 1157 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1683 int i;
1684 1158
1685 Visual *visual = term->visual;
1686
1687 if (visual->c_class != TrueColor || srcImage->format != ZPixmap) return ; 1159 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;
1688 1160
1689 /* for convenience */ 1161 /* for convenience */
1690 mask_r = visual->red_mask; 1162 mask_r = visual->red_mask;
1691 mask_g = visual->green_mask; 1163 mask_g = visual->green_mask;
1692 mask_b = visual->blue_mask; 1164 mask_b = visual->blue_mask;
1693 1165
1694 /* boring lookup table pre-initialization */ 1166 /* boring lookup table pre-initialization */
1695 switch (srcImage->bits_per_pixel) { 1167 sh_r = ecb_ctz32 (mask_r);
1696 case 15: 1168 sh_g = ecb_ctz32 (mask_g);
1697 if ((mask_r != 0x7c00) || 1169 sh_b = ecb_ctz32 (mask_b);
1698 (mask_g != 0x03e0) || 1170
1699 (mask_b != 0x001f)) 1171 size_r = mask_r >> sh_r;
1172 size_g = mask_g >> sh_g;
1173 size_b = mask_b >> sh_b;
1174
1175 if (size_r++ > 255 || size_g++ > 255 || size_b++ > 255)
1700 return; 1176 return;
1701 lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(32+32+32)); 1177
1178 lookup = (uint32_t *)malloc (sizeof (uint32_t) * (size_r + size_g + size_b));
1702 lookup_r = lookup; 1179 lookup_r = lookup;
1703 lookup_g = lookup+32; 1180 lookup_g = lookup + size_r;
1704 lookup_b = lookup+32+32; 1181 lookup_b = lookup + size_r + size_g;
1705 sh_r = 10; 1182
1706 sh_g = 5; 1183 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1707 sh_b = 0; 1184
1708 break; 1185 if (bg_flags & BG_TINT_SET)
1709 case 16: 1186 tint.get (c);
1710 if ((mask_r != 0xf800) ||
1711 (mask_g != 0x07e0) ||
1712 (mask_b != 0x001f))
1713 return;
1714 lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(32+64+32));
1715 lookup_r = lookup;
1716 lookup_g = lookup+32;
1717 lookup_b = lookup+32+64;
1718 sh_r = 11;
1719 sh_g = 5;
1720 sh_b = 0;
1721 break;
1722 case 24:
1723 if ((mask_r != 0xff0000) ||
1724 (mask_g != 0x00ff00) ||
1725 (mask_b != 0x0000ff))
1726 return;
1727 lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(256+256+256));
1728 lookup_r = lookup;
1729 lookup_g = lookup+256;
1730 lookup_b = lookup+256+256;
1731 sh_r = 16;
1732 sh_g = 8;
1733 sh_b = 0;
1734 break;
1735 case 32:
1736 if ((mask_r != 0xff0000) ||
1737 (mask_g != 0x00ff00) ||
1738 (mask_b != 0x0000ff))
1739 return;
1740 lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(256+256+256));
1741 lookup_r = lookup;
1742 lookup_g = lookup+256;
1743 lookup_b = lookup+256+256;
1744 sh_r = 16;
1745 sh_g = 8;
1746 sh_b = 0;
1747 break;
1748 default:
1749 return; /* we do not support this color depth */
1750 }
1751 1187
1752 /* prepare limits for color transformation (each channel is handled separately) */ 1188 /* prepare limits for color transformation (each channel is handled separately) */
1753 if (shade > 100) { 1189 if (shade > 100)
1754 shade = 200 - shade;
1755
1756 lower_lim_r = 65535-rm;
1757 lower_lim_g = 65535-gm;
1758 lower_lim_b = 65535-bm;
1759
1760 lower_lim_r = 65535-(unsigned int)(((RUINT32T)lower_lim_r)*((RUINT32T)shade)/100);
1761 lower_lim_g = 65535-(unsigned int)(((RUINT32T)lower_lim_g)*((RUINT32T)shade)/100);
1762 lower_lim_b = 65535-(unsigned int)(((RUINT32T)lower_lim_b)*((RUINT32T)shade)/100);
1763
1764 upper_lim_r = upper_lim_g = upper_lim_b = 65535;
1765 } else {
1766
1767 lower_lim_r = lower_lim_g = lower_lim_b = 0;
1768
1769 upper_lim_r = (unsigned int)((((RUINT32T)rm)*((RUINT32T)shade))/100);
1770 upper_lim_g = (unsigned int)((((RUINT32T)gm)*((RUINT32T)shade))/100);
1771 upper_lim_b = (unsigned int)((((RUINT32T)bm)*((RUINT32T)shade))/100);
1772 }
1773
1774 /* switch red and blue bytes if necessary, we need it for some weird XServers like XFree86 3.3.3.1 */
1775 if ((srcImage->bits_per_pixel == 24) && (mask_r >= 0xFF0000 ))
1776 { 1190 {
1777 unsigned int tmp; 1191 c.r = c.r * (200 - shade) / 100;
1192 c.g = c.g * (200 - shade) / 100;
1193 c.b = c.b * (200 - shade) / 100;
1778 1194
1779 tmp = lower_lim_r; 1195 low = 0xffff * (shade - 100) / 100;
1780 lower_lim_r = lower_lim_b;
1781 lower_lim_b = tmp;
1782
1783 tmp = upper_lim_r;
1784 upper_lim_r = upper_lim_b;
1785 upper_lim_b = tmp;
1786 } 1196 }
1197 else
1198 {
1199 c.r = c.r * shade / 100;
1200 c.g = c.g * shade / 100;
1201 c.b = c.b * shade / 100;
1202
1203 low = 0;
1204 }
1787 1205
1788 /* fill our lookup tables */ 1206 /* fill our lookup tables */
1789 for (i = 0; i <= mask_r>>sh_r; i++) 1207 fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1790 { 1208 fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1791 RUINT32T tmp; 1209 fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1792 tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_r-lower_lim_r));
1793 tmp += ((RUINT32T)(mask_r>>sh_r))*((RUINT32T)lower_lim_r);
1794 lookup_r[i] = (tmp/65535)<<sh_r;
1795 }
1796 for (i = 0; i <= mask_g>>sh_g; i++)
1797 {
1798 RUINT32T tmp;
1799 tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_g-lower_lim_g));
1800 tmp += ((RUINT32T)(mask_g>>sh_g))*((RUINT32T)lower_lim_g);
1801 lookup_g[i] = (tmp/65535)<<sh_g;
1802 }
1803 for (i = 0; i <= mask_b>>sh_b; i++)
1804 {
1805 RUINT32T tmp;
1806 tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_b-lower_lim_b));
1807 tmp += ((RUINT32T)(mask_b>>sh_b))*((RUINT32T)lower_lim_b);
1808 lookup_b[i] = (tmp/65535)<<sh_b;
1809 }
1810 1210
1811 /* apply table to input image (replacing colors by newly calculated ones) */ 1211 /* apply table to input image (replacing colors by newly calculated ones) */
1812 switch (srcImage->bits_per_pixel) 1212 if (ximage->bits_per_pixel == 32
1213 && ximage->byte_order == host_byte_order)
1813 { 1214 {
1814 case 15: 1215 char *line = ximage->data;
1815 { 1216
1816 unsigned short *p1, *pf, *p, *pl; 1217 for (int y = 0; y < ximage->height; y++)
1817 p1 = (unsigned short *) srcImage->data;
1818 pf = (unsigned short *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
1819 while (p1 < pf)
1820 { 1218 {
1821 p = p1; 1219 uint32_t *p = (uint32_t *)line;
1822 pl = p1 + srcImage->width; 1220 for (int x = 0; x < ximage->width; x++)
1823 for (; p < pl; p++)
1824 { 1221 {
1825 *p = lookup_r[(*p & 0x7c00)>>10] | 1222 *p = lookup_r[(*p & mask_r) >> sh_r] |
1826 lookup_g[(*p & 0x03e0)>> 5] | 1223 lookup_g[(*p & mask_g) >> sh_g] |
1827 lookup_b[(*p & 0x001f)]; 1224 lookup_b[(*p & mask_b) >> sh_b];
1225 p++;
1226 }
1227 line += ximage->bytes_per_line;
1828 } 1228 }
1829 p1 = (unsigned short *) ((char *) p1 + srcImage->bytes_per_line);
1830 } 1229 }
1831 break; 1230 else
1832 }
1833 case 16:
1834 {
1835 unsigned short *p1, *pf, *p, *pl;
1836 p1 = (unsigned short *) srcImage->data;
1837 pf = (unsigned short *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
1838 while (p1 < pf)
1839 { 1231 {
1840 p = p1; 1232 for (int y = 0; y < ximage->height; y++)
1841 pl = p1 + srcImage->width; 1233 for (int x = 0; x < ximage->width; x++)
1842 for (; p < pl; p++)
1843 { 1234 {
1844 *p = lookup_r[(*p & 0xf800)>>11] | 1235 unsigned long pixel = XGetPixel (ximage, x, y);
1845 lookup_g[(*p & 0x07e0)>> 5] | 1236 pixel = lookup_r[(pixel & mask_r) >> sh_r] |
1846 lookup_b[(*p & 0x001f)]; 1237 lookup_g[(pixel & mask_g) >> sh_g] |
1238 lookup_b[(pixel & mask_b) >> sh_b];
1239 XPutPixel (ximage, x, y, pixel);
1847 } 1240 }
1848 p1 = (unsigned short *) ((char *) p1 + srcImage->bytes_per_line);
1849 } 1241 }
1850 break;
1851 }
1852 case 24:
1853 {
1854 unsigned char *p1, *pf, *p, *pl;
1855 p1 = (unsigned char *) srcImage->data;
1856 pf = (unsigned char *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
1857 while (p1 < pf)
1858 {
1859 p = p1;
1860 pl = p1 + srcImage->width * 3;
1861 for (; p < pl; p += 3)
1862 {
1863 p[0] = lookup_r[(p[0] & 0xff0000)>>16];
1864 p[1] = lookup_r[(p[1] & 0x00ff00)>> 8];
1865 p[2] = lookup_r[(p[2] & 0x0000ff)];
1866 }
1867 p1 = (unsigned char *) ((char *) p1 + srcImage->bytes_per_line);
1868 }
1869 break;
1870 }
1871 case 32:
1872 {
1873 RUINT32T *p1, *pf, *p, *pl;
1874 p1 = (RUINT32T *) srcImage->data;
1875 pf = (RUINT32T *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
1876
1877 while (p1 < pf)
1878 {
1879 p = p1;
1880 pl = p1 + srcImage->width;
1881 for (; p < pl; p++)
1882 {
1883 *p = lookup_r[(*p & 0xff0000)>>16] |
1884 lookup_g[(*p & 0x00ff00)>> 8] |
1885 lookup_b[(*p & 0x0000ff)] |
1886 (*p & ~0xffffff);
1887 }
1888 p1 = (RUINT32T *) ((char *) p1 + srcImage->bytes_per_line);
1889 }
1890 break;
1891 }
1892 }
1893 1242
1894 free (lookup); 1243 free (lookup);
1895} 1244}
1896#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */ 1245#endif /* ENABLE_TRANSPARENCY */

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines