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

Diff Legend

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