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

Diff Legend

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