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

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

Diff Legend

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