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.82 by sf-exg, Thu Oct 14 16:01:28 2010 UTC vs.
Revision 1.194 by sf-exg, Sun Jan 1 17:43:47 2012 UTC

1/*----------------------------------------------------------------------* 1/*----------------------------------------------------------------------*
2 * File: background.C - former xpm.C 2 * File: background.C - former xpm.C
3 *----------------------------------------------------------------------* 3 *----------------------------------------------------------------------*
4 * 4 *
5 * All portions of code are copyright by their respective author/s. 5 * All portions of code are copyright by their respective author/s.
6 * Copyright (c) 2005-2008 Marc Lehmann <pcg@goof.com> 6 * Copyright (c) 2005-2008 Marc Lehmann <schmorp@schmorp.de>
7 * Copyright (c) 2007 Sasha Vasko <sasha@aftercode.net> 7 * Copyright (c) 2007 Sasha Vasko <sasha@aftercode.net>
8 * Copyright (c) 2010 Emanuele Giaquinta <e.giaquinta@glauco.it>
8 * 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 (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
511 if (flags & tintSet) 398 if (bg_flags & BG_TINT_SET)
512 tint.get (c); 399 tint.get (c);
513 as_shade.tintColor.red = c.r; 400 as_shade.tintColor.red = c.r;
514 as_shade.tintColor.green = c.g; 401 as_shade.tintColor.green = c.g;
515 as_shade.tintColor.blue = c.b; 402 as_shade.tintColor.blue = c.b;
516 403
517 background_tint = shading2tint32 (&as_shade); 404 background_tint = shading2tint32 (&as_shade);
518 } 405 }
519 406
520 if (!(background_flags & transpPmapBlurred) && (flags & blurNeeded) && background != NULL) 407 if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)
521 { 408 {
522 ASImage *tmp = blur_asimage_gauss (target->asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF, 409 ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,
523 (original_asim == NULL || tint == TINT_LEAVE_SAME) ? ASA_XImage : ASA_ASImage, 410 ASA_XImage,
524 100, ASIMAGE_QUALITY_DEFAULT); 411 100, ASIMAGE_QUALITY_DEFAULT);
525 if (tmp) 412 if (tmp)
526 { 413 {
527 destroy_asimage (&background); 414 destroy_asimage (&background);
528 background = tmp; 415 background = tmp;
… …
530 } 417 }
531# endif 418# endif
532 419
533 ASImage *result = 0; 420 ASImage *result = 0;
534 421
535 int target_width = target->szHint.width; 422 int target_width = szHint.width;
536 int target_height = target->szHint.height; 423 int target_height = szHint.height;
537 int new_pmap_width = target_width; 424 int new_pmap_width = target_width;
538 int new_pmap_height = target_height; 425 int new_pmap_height = target_height;
539 426
540 int x = 0; 427 int x = 0;
541 int y = 0; 428 int y = 0;
542 int w = 0; 429 int w = 0;
543 int h = 0; 430 int h = 0;
544 431
545 TIMING_TEST_START (asim);
546
547 if (original_asim) 432 if (original_asim)
548 get_image_geometry (original_asim->width, original_asim->height, w, h, x, y); 433 get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
549 434
550 if (!original_asim 435 if (!original_asim
551 || (!(flags & rootAlign) 436 || (!(bg_flags & BG_ROOT_ALIGN)
552 && (x >= target_width 437 && (x >= target_width
553 || y >= target_height 438 || y >= target_height
554 || (x + w <= 0) 439 || x + w <= 0
555 || (y + h <= 0)))) 440 || y + h <= 0)))
556 { 441 {
557 if (background) 442 if (background)
558 { 443 {
559 new_pmap_width = background->width; 444 new_pmap_width = background->width;
560 new_pmap_height = background->height; 445 new_pmap_height = background->height;
561 result = background; 446 result = background;
562 447
563 if (background_tint != TINT_LEAVE_SAME) 448 if (background_tint != TINT_LEAVE_SAME)
564 { 449 {
565 ASImage *tmp = tile_asimage (target->asv, background, 0, 0, 450 ASImage *tmp = tile_asimage (asv, background, 0, 0,
566 target_width, target_height, background_tint, 451 target_width, target_height, background_tint,
567 ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT); 452 ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
568 if (tmp) 453 if (tmp)
569 result = tmp; 454 result = tmp;
570 } 455 }
… …
574 } 459 }
575 else 460 else
576 { 461 {
577 result = original_asim; 462 result = original_asim;
578 463
579 if ((w != original_asim->width) 464 if (w != original_asim->width
580 || (h != original_asim->height)) 465 || h != original_asim->height)
581 { 466 {
582 result = scale_asimage (target->asv, original_asim, 467 result = scale_asimage (asv, original_asim,
583 w, h, 468 w, h,
584 background ? ASA_ASImage : ASA_XImage, 469 ASA_XImage,
585 100, ASIMAGE_QUALITY_DEFAULT); 470 100, ASIMAGE_QUALITY_DEFAULT);
586 } 471 }
587 472
588 if (background == NULL) 473 if (background == NULL)
589 { 474 {
590 if (h_scale == 0 || v_scale == 0) 475 if (bg_flags & BG_TILE)
591 { 476 {
592 /* if tiling - pixmap has to be sized exactly as the image, 477 /* if tiling - pixmap has to be sized exactly as the image,
593 but there is no need to make it bigger than the window! */ 478 but there is no need to make it bigger than the window! */
594 new_pmap_width = min (result->width, target_width); 479 new_pmap_width = min (result->width, target_width);
595 new_pmap_height = min (result->height, target_height); 480 new_pmap_height = min (result->height, target_height);
596 481
597 /* we also need to tile our image in both directions */ 482 /* we also need to tile our image in both directions */
598 ASImage *tmp = tile_asimage (target->asv, result, 483 ASImage *tmp = tile_asimage (asv, result,
599 (int)result->width - x, 484 (int)result->width - x,
600 (int)result->height - y, 485 (int)result->height - y,
601 new_pmap_width, 486 new_pmap_width,
602 new_pmap_height, 487 new_pmap_height,
603 TINT_LEAVE_SAME, ASA_XImage, 488 TINT_LEAVE_SAME, ASA_XImage,
… …
620 layers[0].clip_width = target_width; 505 layers[0].clip_width = target_width;
621 layers[0].clip_height = target_height; 506 layers[0].clip_height = target_height;
622 layers[0].tint = background_tint; 507 layers[0].tint = background_tint;
623 layers[1].im = result; 508 layers[1].im = result;
624 509
625 if (h_scale == 0 || v_scale == 0) 510 if (bg_flags & BG_TILE)
626 { 511 {
627 /* tile horizontally */ 512 /* tile horizontally */
628 while (x > 0) x -= (int)result->width; 513 while (x > 0) x -= (int)result->width;
629 layers[1].dst_x = x; 514 layers[1].dst_x = x;
630 layers[1].clip_width = result->width+target_width; 515 layers[1].clip_width = result->width+target_width;
… …
634 /* clip horizontally */ 519 /* clip horizontally */
635 layers[1].dst_x = x; 520 layers[1].dst_x = x;
636 layers[1].clip_width = result->width; 521 layers[1].clip_width = result->width;
637 } 522 }
638 523
639 if (h_scale == 0 || v_scale == 0) 524 if (bg_flags & BG_TILE)
640 { 525 {
641 while (y > 0) y -= (int)result->height; 526 while (y > 0) y -= (int)result->height;
642 layers[1].dst_y = y; 527 layers[1].dst_y = y;
643 layers[1].clip_height = result->height + target_height; 528 layers[1].clip_height = result->height + target_height;
644 } 529 }
… …
646 { 531 {
647 layers[1].dst_y = y; 532 layers[1].dst_y = y;
648 layers[1].clip_height = result->height; 533 layers[1].clip_height = result->height;
649 } 534 }
650 535
651 if (target->rs[Rs_blendtype]) 536 if (rs[Rs_blendtype])
652 { 537 {
653 layers[1].merge_scanlines = blend_scanlines_name2func (target->rs[Rs_blendtype]); 538 layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
654 if (layers[1].merge_scanlines == NULL) 539 if (layers[1].merge_scanlines == NULL)
655 layers[1].merge_scanlines = alphablend_scanlines; 540 layers[1].merge_scanlines = alphablend_scanlines;
656 } 541 }
657 542
658 ASImage *tmp = merge_layers (target->asv, layers, 2, target_width, target_height, 543 ASImage *tmp = merge_layers (asv, layers, 2, target_width, target_height,
659 ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT); 544 ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
660 545
661 if (tmp) 546 if (tmp)
662 { 547 {
663 if (result != original_asim) 548 if (result != original_asim)
… …
667 } 552 }
668 553
669 free (layers); 554 free (layers);
670 } 555 }
671 } 556 }
672 TIMING_TEST_PRINT_RESULT (asim);
673 557
674 bool ret = false; 558 bool ret = false;
675 559
676 if (result) 560 if (result)
677 { 561 {
678 XGCValues gcv; 562 XGCValues gcv;
679 GC gc; 563 GC gc;
680 564
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 */ 565 /* create Pixmap */
693 if (pixmap == None) 566 if (bg_pixmap == None
567 || bg_pmap_width != new_pmap_width
568 || bg_pmap_height != new_pmap_height)
694 { 569 {
570 if (bg_pixmap)
571 XFreePixmap (dpy, bg_pixmap);
695 pixmap = XCreatePixmap (target->dpy, target->vt, new_pmap_width, new_pmap_height, target->depth); 572 bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
696 pmap_width = new_pmap_width; 573 bg_pmap_width = new_pmap_width;
697 pmap_height = new_pmap_height; 574 bg_pmap_height = new_pmap_height;
698 pmap_depth = target->depth;
699 } 575 }
700 /* fill with background color (if result's not completely overlapping it) */ 576 /* fill with background color (if result's not completely overlapping it) */
701 gcv.foreground = target->pix_colors[Color_bg]; 577 gcv.foreground = pix_colors[Color_bg];
702 gc = XCreateGC (target->dpy, target->vt, GCForeground, &gcv); 578 gc = XCreateGC (dpy, vt, GCForeground, &gcv);
703 579
704 int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0; 580 int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
705 int dst_width = result->width, dst_height = result->height; 581 int dst_width = result->width, dst_height = result->height;
706 if (background == NULL) 582 if (background == NULL)
707 { 583 {
708 if (!(h_scale == 0 || v_scale == 0)) 584 if (!(bg_flags & BG_TILE))
709 { 585 {
710 src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width ); 586 src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );
711 src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height); 587 src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
712 } 588 }
713 589
714 if (dst_x > 0 || dst_y > 0 590 if (dst_x > 0 || dst_y > 0
715 || dst_x + dst_width < new_pmap_width 591 || dst_x + dst_width < new_pmap_width
716 || dst_y + dst_height < new_pmap_height) 592 || dst_y + dst_height < new_pmap_height)
717 XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height); 593 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
718 } 594 }
719 595
720 /* put result on pixmap */ 596 /* put result on pixmap */
721 if (dst_x < new_pmap_width && dst_y < new_pmap_height) 597 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); 598 asimage2drawable (asv, bg_pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);
723 599
724 if (result != background && result != original_asim) 600 if (result != background && result != original_asim)
725 destroy_asimage (&result); 601 destroy_asimage (&result);
726 602
727 XFreeGC (target->dpy, gc); 603 XFreeGC (dpy, gc);
728 TIMING_TEST_PRINT_RESULT (asim);
729 604
730 ret = true; 605 ret = true;
731 } 606 }
732 607
733 if (background) 608 if (background)
… …
737} 612}
738# endif /* HAVE_AFTERIMAGE */ 613# endif /* HAVE_AFTERIMAGE */
739 614
740# ifdef HAVE_PIXBUF 615# ifdef HAVE_PIXBUF
741bool 616bool
742bgPixmap_t::render_image (unsigned long background_flags) 617rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
618 int src_x, int src_y, int dst_x, int dst_y,
619 unsigned int width, unsigned int height)
743{ 620{
744 if (target == NULL) 621 XImage *ximage;
622 char *data, *line;
623 int bytes_per_pixel;
624 int width_r, width_g, width_b;
625 int sh_r, sh_g, sh_b;
626 int rowstride;
627 int channels;
628 unsigned char *row;
629
630 if (visual->c_class != TrueColor)
745 return false; 631 return false;
746 632
633 if (depth == 24 || depth == 32)
634 bytes_per_pixel = 4;
635 else if (depth == 15 || depth == 16)
636 bytes_per_pixel = 2;
637 else
638 return false;
639
640 width_r = ecb_popcount32 (visual->red_mask);
641 width_g = ecb_popcount32 (visual->green_mask);
642 width_b = ecb_popcount32 (visual->blue_mask);
643
644 if (width_r > 8 || width_g > 8 || width_b > 8)
645 return false;
646
647 sh_r = ecb_ctz32 (visual->red_mask);
648 sh_g = ecb_ctz32 (visual->green_mask);
649 sh_b = ecb_ctz32 (visual->blue_mask);
650
651 if (width > INT_MAX / height / bytes_per_pixel)
652 return false;
653
654 data = (char *)malloc (width * height * bytes_per_pixel);
655 if (!data)
656 return false;
657
658 ximage = XCreateImage (dpy, visual, depth, ZPixmap, 0, data,
659 width, height, bytes_per_pixel * 8, 0);
660 if (!ximage)
661 {
662 free (data);
663 return false;
664 }
665
666 ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
667
668 rowstride = gdk_pixbuf_get_rowstride (pixbuf);
669 channels = gdk_pixbuf_get_n_channels (pixbuf);
670 row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels;
671 line = data;
672
673 for (int y = 0; y < height; y++)
674 {
675 for (int x = 0; x < width; x++)
676 {
677 unsigned char *pixel = row + x * channels;
678 uint32_t value;
679
680 value = ((pixel[0] >> (8 - width_r)) << sh_r)
681 | ((pixel[1] >> (8 - width_g)) << sh_g)
682 | ((pixel[2] >> (8 - width_b)) << sh_b);
683
684 if (bytes_per_pixel == 4)
685 ((uint32_t *)line)[x] = value;
686 else
687 ((uint16_t *)line)[x] = value;
688 }
689
690 row += rowstride;
691 line += ximage->bytes_per_line;
692 }
693
694 XPutImage (dpy, pixmap, gc, ximage, 0, 0, dst_x, dst_y, width, height);
695 XDestroyImage (ximage);
696 return true;
697}
698
699bool
700rxvt_term::render_image (unsigned long tr_flags)
701{
747 if (!pixbuf) 702 if (!pixbuf)
748 return false; 703 return false;
749 704
750#if !XFT 705 if (tr_flags
751 if (background_flags) 706 && !(bg_flags & BG_HAS_RENDER))
752 return false; 707 return false;
753#endif
754 708
755 GdkPixbuf *result; 709 GdkPixbuf *result;
756 710
757 int image_width = gdk_pixbuf_get_width (pixbuf); 711 int image_width = gdk_pixbuf_get_width (pixbuf);
758 int image_height = gdk_pixbuf_get_height (pixbuf); 712 int image_height = gdk_pixbuf_get_height (pixbuf);
759 713
760 int target_width = target->szHint.width; 714 int target_width = szHint.width;
761 int target_height = target->szHint.height; 715 int target_height = szHint.height;
762 int new_pmap_width = target_width; 716 int new_pmap_width = target_width;
763 int new_pmap_height = target_height; 717 int new_pmap_height = target_height;
764 718
765 int x = 0; 719 int x = 0;
766 int y = 0; 720 int y = 0;
767 int w = 0; 721 int w = 0;
768 int h = 0; 722 int h = 0;
769 723
770 get_image_geometry (image_width, image_height, w, h, x, y); 724 get_image_geometry (image_width, image_height, w, h, x, y);
771 725
772 if (!(flags & rootAlign) 726 if (!(bg_flags & BG_ROOT_ALIGN)
773 && (x >= target_width 727 && (x >= target_width
774 || y >= target_height 728 || y >= target_height
775 || (x + w <= 0) 729 || x + w <= 0
776 || (y + h <= 0))) 730 || y + h <= 0))
777 return false; 731 return false;
778 732
779 result = pixbuf; 733 result = pixbuf;
780 734
781 if ((w != image_width) 735 if (w != image_width
782 || (h != image_height)) 736 || h != image_height)
783 { 737 {
784 result = gdk_pixbuf_scale_simple (pixbuf, 738 result = gdk_pixbuf_scale_simple (pixbuf,
785 w, h, 739 w, h,
786 GDK_INTERP_BILINEAR); 740 GDK_INTERP_BILINEAR);
787 } 741 }
788 742
743 if (!result)
744 return false;
745
789 bool ret = false; 746 bool ret = false;
790 747
791 if (result)
792 {
793 XGCValues gcv; 748 XGCValues gcv;
794 GC gc; 749 GC gc;
795 Pixmap root_pmap; 750 Pixmap root_pmap;
796 751
797 image_width = gdk_pixbuf_get_width (result); 752 image_width = gdk_pixbuf_get_width (result);
798 image_height = gdk_pixbuf_get_height (result); 753 image_height = gdk_pixbuf_get_height (result);
799 754
800 if (background_flags) 755 if (tr_flags)
801 { 756 {
802 root_pmap = pixmap; 757 root_pmap = bg_pixmap;
803 pixmap = None; 758 bg_pixmap = None;
759 }
760 else
761 {
762 if (bg_flags & BG_TILE)
804 } 763 {
805 else
806 {
807 if (h_scale == 0 || v_scale == 0)
808 {
809 new_pmap_width = min (image_width, target_width); 764 new_pmap_width = min (image_width, target_width);
810 new_pmap_height = min (image_height, target_height); 765 new_pmap_height = min (image_height, target_height);
811 } 766 }
812 } 767 }
813 768
769 if (bg_pixmap == None
770 || bg_pmap_width != new_pmap_width
771 || bg_pmap_height != new_pmap_height)
772 {
814 if (pixmap) 773 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); 774 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); 775 bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
828 pmap_width = new_pmap_width; 776 bg_pmap_width = new_pmap_width;
829 pmap_height = new_pmap_height; 777 bg_pmap_height = new_pmap_height;
830 pmap_depth = target->depth; 778 }
779
780 gcv.foreground = pix_colors[Color_bg];
781 gc = XCreateGC (dpy, vt, GCForeground, &gcv);
782
783 if (gc)
784 {
785 if (bg_flags & BG_TILE)
831 } 786 {
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); 787 Pixmap tile = XCreatePixmap (dpy, vt, image_width, image_height, depth);
839 gdk_pixbuf_xlib_render_to_drawable (result, tile, gc, 788 pixbuf_to_pixmap (result, tile, gc,
840 0, 0, 789 0, 0,
841 0, 0, 790 0, 0,
842 image_width, image_height, 791 image_width, image_height);
843 XLIB_RGB_DITHER_NONE,
844 0, 0);
845 792
846 gcv.tile = tile; 793 gcv.tile = tile;
847 gcv.fill_style = FillTiled; 794 gcv.fill_style = FillTiled;
848 gcv.ts_x_origin = x; 795 gcv.ts_x_origin = x;
849 gcv.ts_y_origin = y; 796 gcv.ts_y_origin = y;
850 XChangeGC (target->dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); 797 XChangeGC (dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
851 798
852 XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height); 799 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
853 XFreePixmap (target->dpy, tile); 800 XFreePixmap (dpy, tile);
854 } 801 }
855 else 802 else
856 { 803 {
857 int src_x, src_y, dst_x, dst_y; 804 int src_x, src_y, dst_x, dst_y;
858 int dst_width, dst_height; 805 int dst_width, dst_height;
… …
861 src_y = make_clip_rectangle (y, image_height, new_pmap_height, dst_y, dst_height); 808 src_y = make_clip_rectangle (y, image_height, new_pmap_height, dst_y, dst_height);
862 809
863 if (dst_x > 0 || dst_y > 0 810 if (dst_x > 0 || dst_y > 0
864 || dst_x + dst_width < new_pmap_width 811 || dst_x + dst_width < new_pmap_width
865 || dst_y + dst_height < new_pmap_height) 812 || dst_y + dst_height < new_pmap_height)
866 XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height); 813 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
867 814
868 if (dst_x < new_pmap_width && dst_y < new_pmap_height) 815 if (dst_x < new_pmap_width && dst_y < new_pmap_height)
869 gdk_pixbuf_xlib_render_to_drawable (result, pixmap, gc, 816 pixbuf_to_pixmap (result, bg_pixmap, gc,
870 src_x, src_y, 817 src_x, src_y,
871 dst_x, dst_y, 818 dst_x, dst_y,
872 dst_width, dst_height, 819 dst_width, dst_height);
873 XLIB_RGB_DITHER_NONE,
874 0, 0);
875 }
876
877#if XFT
878 if (background_flags)
879 { 820 }
880 Display *dpy = target->dpy;
881 XRenderPictureAttributes pa;
882 821
822#if XRENDER
823 if (tr_flags)
824 {
883 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, target->display->screen)); 825 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
826
884 Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa); 827 Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
885 828
886 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, target->visual);
887 Picture dst = XRenderCreatePicture (dpy, pixmap, dst_format, 0, &pa); 829 Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
888 830
889 pa.repeat = True; 831 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 832
895 if (src && dst && mask)
896 {
897 XRenderColor mask_c; 833 XRenderColor mask_c;
898 834
899 mask_c.alpha = 0x8000; 835 mask_c.alpha = 0x8000;
900 mask_c.red = 0; 836 mask_c.red =
901 mask_c.green = 0; 837 mask_c.green =
902 mask_c.blue = 0; 838 mask_c.blue = 0;
903 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1); 839 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
840
904 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height); 841 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
905 }
906 842
907 XRenderFreePicture (dpy, src); 843 XRenderFreePicture (dpy, src);
908 XRenderFreePicture (dpy, dst); 844 XRenderFreePicture (dpy, dst);
909 XRenderFreePicture (dpy, mask); 845 XRenderFreePicture (dpy, mask);
910
911 XFreePixmap (dpy, root_pmap);
912 } 846 }
913#endif 847#endif
914 848
915 if (result != pixbuf)
916 g_object_unref (result);
917
918 XFreeGC (target->dpy, gc); 849 XFreeGC (dpy, gc);
919 850
920 ret = true; 851 ret = true;
921 } 852 }
922 853
854 if (result != pixbuf)
855 g_object_unref (result);
856
857 if (tr_flags)
858 XFreePixmap (dpy, root_pmap);
859
923 return ret; 860 return ret;
924} 861}
925# endif /* HAVE_PIXBUF */ 862# endif /* HAVE_PIXBUF */
926 863
927bool 864bool
928bgPixmap_t::set_file (const char *file) 865rxvt_term::bg_set_file (const char *file)
929{ 866{
930 assert (file); 867 if (!file || !*file)
868 return false;
931 869
932 if (*file) 870 bool ret = false;
933 {
934 if (const char *p = strchr (file, ';')) 871 const char *p = strchr (file, ';');
935 { 872
873 if (p)
874 {
936 size_t len = p - file; 875 size_t len = p - file;
937 char *f = rxvt_temp_buf<char> (len + 1); 876 char *f = rxvt_temp_buf<char> (len + 1);
938 memcpy (f, file, len); 877 memcpy (f, file, len);
939 f[len] = '\0'; 878 f[len] = '\0';
940 file = f; 879 file = f;
941 } 880 }
942 881
943# ifdef HAVE_AFTERIMAGE 882# ifdef HAVE_AFTERIMAGE
944 if (!target->asimman) 883 if (!asimman)
945 target->asimman = create_generic_imageman (target->rs[Rs_path]); 884 asimman = create_generic_imageman (rs[Rs_path]);
946 ASImage *image = get_asimage (target->asimman, file, 0xFFFFFFFF, 100); 885 ASImage *image = get_asimage (asimman, file, 0xFFFFFFFF, 100);
947 if (image) 886 if (image)
948 { 887 {
949 if (original_asim) 888 if (original_asim)
950 safe_asimage_destroy (original_asim); 889 safe_asimage_destroy (original_asim);
951 original_asim = image; 890 original_asim = image;
952 have_image = true; 891 bg_flags |= BG_IS_FROM_FILE | BG_CLIENT_RENDER;
953 return true; 892 ret = true;
954 } 893 }
955# endif 894# endif
956 895
957# ifdef HAVE_PIXBUF 896# ifdef HAVE_PIXBUF
958 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL); 897 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
959 if (image) 898 if (image)
960 { 899 {
961 if (pixbuf) 900 if (pixbuf)
962 g_object_unref (pixbuf); 901 g_object_unref (pixbuf);
963 pixbuf = image; 902 pixbuf = image;
964 have_image = true; 903 bg_flags |= BG_IS_FROM_FILE;
965 return true; 904 ret = true;
966 } 905 }
967# endif 906# endif
907
908 if (ret)
968 } 909 {
910 if (p)
911 bg_set_geometry (p + 1);
912 else
913 bg_set_default_geometry ();
914 }
969 915
970 return false; 916 return ret;
971} 917}
972 918
973# endif /* BG_IMAGE_FROM_FILE */ 919# endif /* BG_IMAGE_FROM_FILE */
974 920
975# ifdef ENABLE_TRANSPARENCY 921# ifdef ENABLE_TRANSPARENCY
976bool 922bool
977bgPixmap_t::set_transparent () 923rxvt_term::bg_set_transparent ()
978{ 924{
979 if (!(flags & isTransparent)) 925 if (!(bg_flags & BG_IS_TRANSPARENT))
980 { 926 {
981 flags |= isTransparent; 927 bg_flags |= BG_IS_TRANSPARENT;
982 return true; 928 return true;
983 } 929 }
984 930
985 return false; 931 return false;
986} 932}
987 933
988bool 934bool
989bgPixmap_t::set_blur_radius (const char *geom) 935rxvt_term::bg_set_blur (const char *geom)
990{ 936{
991 int changed = 0; 937 bool changed = false;
992 unsigned int hr, vr; 938 unsigned int hr, vr;
993 int junk; 939 int junk;
994 int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr); 940 int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr);
995 941
996 if (!(geom_flags & WidthValue)) 942 if (!(geom_flags & WidthValue))
… …
1001 min_it (hr, 128); 947 min_it (hr, 128);
1002 min_it (vr, 128); 948 min_it (vr, 128);
1003 949
1004 if (h_blurRadius != hr) 950 if (h_blurRadius != hr)
1005 { 951 {
1006 ++changed; 952 changed = true;
1007 h_blurRadius = hr; 953 h_blurRadius = hr;
1008 } 954 }
1009 955
1010 if (v_blurRadius != vr) 956 if (v_blurRadius != vr)
1011 { 957 {
1012 ++changed; 958 changed = true;
1013 v_blurRadius = vr; 959 v_blurRadius = vr;
1014 } 960 }
1015 961
1016 if (v_blurRadius == 0 && h_blurRadius == 0) 962 if (h_blurRadius == 0 || v_blurRadius == 0)
1017 flags &= ~blurNeeded; 963 bg_flags &= ~BG_NEEDS_BLUR;
1018 else 964 else
1019 flags |= blurNeeded; 965 bg_flags |= BG_NEEDS_BLUR;
1020 966
1021#if XFT
1022 XFilters *filters = XRenderQueryFilters (target->dpy, target->display->root);
1023 if (filters)
1024 {
1025 for (int i = 0; i < filters->nfilter; i++)
1026 if (!strcmp (filters->filter[i], FilterConvolution))
1027 flags |= bgPixmap_t::blurServerSide;
1028
1029 XFree (filters);
1030 }
1031#endif
1032
1033 return (changed > 0); 967 return changed;
1034} 968}
1035 969
1036static inline unsigned long 970void
1037compute_tint_shade_flags (rxvt_color *tint, int shade) 971rxvt_term::set_tint_shade_flags ()
1038{ 972{
1039 unsigned long flags = 0; 973 rgba c;
1040 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1041 bool has_shade = shade != 100; 974 bool has_shade = shade != 100;
1042 975
1043 if (tint) 976 bg_flags &= ~BG_TINT_FLAGS;
977
978 if (bg_flags & BG_TINT_SET)
1044 { 979 {
1045 tint->get (c); 980 tint.get (c);
1046# define IS_COMPONENT_WHOLESOME(cmp) ((cmp) <= 0x000700 || (cmp) >= 0x00f700)
1047 if (!has_shade && IS_COMPONENT_WHOLESOME (c.r)
1048 && IS_COMPONENT_WHOLESOME (c.g)
1049 && IS_COMPONENT_WHOLESOME (c.b))
1050 flags |= bgPixmap_t::tintWholesome;
1051# undef IS_COMPONENT_WHOLESOME
1052 }
1053
1054 if (has_shade) 981 if (!has_shade
1055 flags |= bgPixmap_t::tintNeeded; 982 && (c.r <= 0x00ff || c.r >= 0xff00)
1056 else if (tint) 983 && (c.g <= 0x00ff || c.g >= 0xff00)
984 && (c.b <= 0x00ff || c.b >= 0xff00))
985 bg_flags |= BG_TINT_BITAND;
1057 { 986 }
1058 if ((c.r > 0x000700 || c.g > 0x000700 || c.b > 0x000700)
1059 && (c.r < 0x00f700 || c.g < 0x00f700 || c.b < 0x00f700))
1060 {
1061 flags |= bgPixmap_t::tintNeeded;
1062 }
1063 }
1064 987
1065 if (flags & bgPixmap_t::tintNeeded) 988 if (has_shade || (bg_flags & BG_TINT_SET))
1066 { 989 bg_flags |= BG_NEEDS_TINT;
1067 if (flags & bgPixmap_t::tintWholesome)
1068 flags |= bgPixmap_t::tintServerSide;
1069 else
1070 {
1071#if XFT
1072 flags |= bgPixmap_t::tintServerSide;
1073#endif
1074 }
1075 }
1076
1077 return flags;
1078} 990}
1079 991
1080bool 992bool
1081bgPixmap_t::set_tint (rxvt_color &new_tint) 993rxvt_term::bg_set_tint (rxvt_color &new_tint)
1082{ 994{
1083 if (!(flags & tintSet) || tint != new_tint) 995 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
1084 { 996 {
1085 unsigned long new_flags = compute_tint_shade_flags (&new_tint, shade);
1086 tint = new_tint; 997 tint = new_tint;
1087 flags = (flags & ~tintFlags) | new_flags | tintSet; 998 bg_flags |= BG_TINT_SET;
999 set_tint_shade_flags ();
1088 return true; 1000 return true;
1089 } 1001 }
1090 1002
1091 return false; 1003 return false;
1092} 1004}
1093 1005
1094bool 1006bool
1095bgPixmap_t::unset_tint ()
1096{
1097 unsigned long new_flags = compute_tint_shade_flags (NULL, shade);
1098
1099 if (new_flags != (flags & tintFlags))
1100 {
1101 flags = (flags & ~tintFlags) | new_flags;
1102 return true;
1103 }
1104
1105 return false;
1106}
1107
1108bool
1109bgPixmap_t::set_shade (const char *shade_str) 1007rxvt_term::bg_set_shade (const char *shade_str)
1110{ 1008{
1111 int new_shade = (shade_str) ? atoi (shade_str) : 100; 1009 int new_shade = atoi (shade_str);
1112 1010
1113 clamp_it (new_shade, -100, 200); 1011 clamp_it (new_shade, -100, 200);
1114 if (new_shade < 0) 1012 if (new_shade < 0)
1115 new_shade = 200 - (100 + new_shade); 1013 new_shade = 200 - (100 + new_shade);
1116 1014
1117 if (new_shade != shade) 1015 if (new_shade != shade)
1118 { 1016 {
1119 unsigned long new_flags = compute_tint_shade_flags ((flags & tintSet) ? &tint : NULL, new_shade);
1120 shade = new_shade; 1017 shade = new_shade;
1121 flags = (flags & (~tintFlags | tintSet)) | new_flags; 1018 set_tint_shade_flags ();
1122 return true; 1019 return true;
1123 } 1020 }
1124 1021
1125 return false; 1022 return false;
1126} 1023}
1127 1024
1025#if XRENDER
1128static void 1026static void
1129get_gaussian_kernel (int radius, int width, double *kernel, XFixed *params) 1027get_gaussian_kernel (int radius, int width, double *kernel, XFixed *params)
1130{ 1028{
1131 double sigma = radius / 2.0; 1029 double sigma = radius / 2.0;
1132 double scale = sqrt (2.0 * M_PI) * sigma; 1030 double scale = sqrt (2.0 * M_PI) * sigma;
1133 double sum = 0.0; 1031 double sum = 0.0;
1134 1032
1135 for (int i = 0; i < width; i++) 1033 for (int i = 0; i < width; i++)
1136 { 1034 {
1137 double x = i - width / 2; 1035 double x = i - width / 2;
1138 kernel[i] = exp (-(x * x) / (2.0 * sigma * sigma)) / scale; 1036 kernel[i] = exp (-(x * x) / (2.0 * sigma * sigma)) / scale;
1139 sum += kernel[i]; 1037 sum += kernel[i];
1140 } 1038 }
1141 1039
1142 params[0] = XDoubleToFixed (width); 1040 params[0] = XDoubleToFixed (width);
1143 params[1] = XDoubleToFixed (1); 1041 params[1] = XDoubleToFixed (1);
1144 1042
1145 for (int i = 0; i < width; i++) 1043 for (int i = 0; i < width; i++)
1146 params[i+2] = XDoubleToFixed (kernel[i] / sum); 1044 params[i+2] = XDoubleToFixed (kernel[i] / sum);
1147} 1045}
1046#endif
1148 1047
1149bool 1048bool
1150bgPixmap_t::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 1049rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1151{ 1050{
1152 bool ret = false; 1051 bool ret = false;
1153#if XFT 1052#if XRENDER
1053 if (!(bg_flags & BG_HAS_RENDER_CONV))
1054 return false;
1055
1154 int size = max (h_blurRadius, v_blurRadius) * 2 + 1; 1056 int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1155 double *kernel = (double *)malloc (size * sizeof (double)); 1057 double *kernel = (double *)malloc (size * sizeof (double));
1156 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 1058 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1157 1059
1158 Display *dpy = target->dpy;
1159 XRenderPictureAttributes pa;
1160 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, target->visual); 1060 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1161 1061
1162 Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 1062 Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1163 Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 1063 Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1164 1064
1165 if (kernel && params && src && dst) 1065 if (kernel && params)
1166 { 1066 {
1167 if (h_blurRadius)
1168 {
1169 size = h_blurRadius * 2 + 1; 1067 size = h_blurRadius * 2 + 1;
1170 get_gaussian_kernel (h_blurRadius, size, kernel, params); 1068 get_gaussian_kernel (h_blurRadius, size, kernel, params);
1171 1069
1172 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 1070 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1173 XRenderComposite (dpy, 1071 XRenderComposite (dpy,
1174 PictOpSrc, 1072 PictOpSrc,
1175 src, 1073 src,
1176 None, 1074 None,
1177 dst, 1075 dst,
1178 0, 0, 1076 0, 0,
1179 0, 0, 1077 0, 0,
1180 0, 0, 1078 0, 0,
1181 width, height); 1079 width, height);
1182 }
1183 1080
1184 if (v_blurRadius)
1185 {
1186 size = v_blurRadius * 2 + 1; 1081 size = v_blurRadius * 2 + 1;
1187 get_gaussian_kernel (v_blurRadius, size, kernel, params); 1082 get_gaussian_kernel (v_blurRadius, size, kernel, params);
1188 swap (params[0], params[1]); 1083 ::swap (params[0], params[1]);
1189 1084
1190 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 1085 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1191 XRenderComposite (dpy, 1086 XRenderComposite (dpy,
1192 PictOpSrc, 1087 PictOpSrc,
1193 src, 1088 src,
1194 None, 1089 None,
1195 dst, 1090 dst,
1196 0, 0, 1091 0, 0,
1197 0, 0, 1092 0, 0,
1198 0, 0, 1093 0, 0,
1199 width, height); 1094 width, height);
1200 }
1201 1095
1202 ret = true; 1096 ret = true;
1203 } 1097 }
1204 1098
1205 free (kernel); 1099 free (kernel);
… …
1209#endif 1103#endif
1210 return ret; 1104 return ret;
1211} 1105}
1212 1106
1213bool 1107bool
1214bgPixmap_t::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 1108rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1215{ 1109{
1216 Display *dpy = target->dpy;
1217 bool ret = false; 1110 bool ret = false;
1218 1111
1219 if (flags & tintWholesome) 1112 if (bg_flags & BG_TINT_BITAND)
1220 { 1113 {
1221 XGCValues gcv; 1114 XGCValues gcv;
1222 GC gc; 1115 GC gc;
1223 1116
1224 /* In this case we can tint image server-side getting significant 1117 /* In this case we can tint image server-side getting significant
… …
1233 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height); 1126 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1234 ret = true; 1127 ret = true;
1235 XFreeGC (dpy, gc); 1128 XFreeGC (dpy, gc);
1236 } 1129 }
1237 } 1130 }
1238 else 1131# if XRENDER
1132 else if (bg_flags & BG_HAS_RENDER)
1239 { 1133 {
1240# if XFT
1241 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 1134 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1242 1135
1243 if (flags & tintSet) 1136 if (bg_flags & BG_TINT_SET)
1244 tint.get (c); 1137 tint.get (c);
1245 1138
1246 if (shade <= 100) 1139 if (shade <= 100)
1247 { 1140 {
1248 c.r = (c.r * shade) / 100; 1141 c.r = c.r * shade / 100;
1249 c.g = (c.g * shade) / 100; 1142 c.g = c.g * shade / 100;
1250 c.b = (c.b * shade) / 100; 1143 c.b = c.b * shade / 100;
1251 } 1144 }
1252 else 1145 else
1253 { 1146 {
1254 c.r = ((0xffff - c.r) * (200 - shade)) / 100; 1147 c.r = c.r * (200 - shade) / 100;
1255 c.g = ((0xffff - c.g) * (200 - shade)) / 100; 1148 c.g = c.g * (200 - shade) / 100;
1256 c.b = ((0xffff - c.b) * (200 - shade)) / 100; 1149 c.b = c.b * (200 - shade) / 100;
1257 } 1150 }
1258 1151
1259 XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1260 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 1152 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1261 XRenderPictureAttributes pa;
1262 1153
1263 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 1154 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1264 1155
1265 pa.repeat = True; 1156 Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1266 1157
1267 Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32); 1158 Picture mask_pic = create_xrender_mask (dpy, pixmap, True, True);
1268 Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1269 XFreePixmap (dpy, overlay_pmap);
1270 1159
1271 pa.component_alpha = True;
1272 Pixmap mask_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
1273 Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat|CPComponentAlpha, &pa);
1274 XFreePixmap (dpy, mask_pmap);
1275
1276 if (mask_pic && overlay_pic && back_pic)
1277 {
1278 XRenderColor mask_c; 1160 XRenderColor mask_c;
1279 1161
1280 memset (&mask_c, (shade > 100) ? 0xFF : 0x0, sizeof (mask_c));
1281 mask_c.alpha = 0xffff; 1162 mask_c.alpha = 0xffff;
1163 mask_c.red =
1164 mask_c.green =
1165 mask_c.blue = 0;
1166 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1167
1168 mask_c.alpha = 0;
1169 mask_c.red = 0xffff - c.r;
1170 mask_c.green = 0xffff - c.g;
1171 mask_c.blue = 0xffff - c.b;
1172 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
1173
1174 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1175
1176 if (shade > 100)
1177 {
1178 mask_c.alpha = 0;
1179 mask_c.red =
1180 mask_c.green =
1181 mask_c.blue = 0xffff * (shade - 100) / 100;
1282 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1); 1182 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1283 1183
1284 mask_c.alpha = 0;
1285 mask_c.red = 0xffff - c.r;
1286 mask_c.green = 0xffff - c.g;
1287 mask_c.blue = 0xffff - c.b;
1288 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
1289 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height); 1184 XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1185 }
1186
1290 ret = true; 1187 ret = true;
1291 }
1292 1188
1293 XRenderFreePicture (dpy, mask_pic); 1189 XRenderFreePicture (dpy, mask_pic);
1294 XRenderFreePicture (dpy, overlay_pic); 1190 XRenderFreePicture (dpy, overlay_pic);
1295 XRenderFreePicture (dpy, back_pic); 1191 XRenderFreePicture (dpy, back_pic);
1296# if DO_TIMING_TEST 1192 }
1297 XSync (dpy, False);
1298# endif
1299# endif 1193# endif
1300 }
1301 1194
1302 return ret; 1195 return ret;
1303} 1196}
1304 1197
1305/* make_transparency_pixmap() 1198/*
1306 * Builds a pixmap sized the same as terminal window, with depth same as the root window 1199 * Builds a pixmap of the same size as the terminal window that contains
1307 * that pixmap contains tiled portion of the root pixmap that is supposed to be covered by 1200 * the tiled portion of the root pixmap that is supposed to be covered by
1308 * our window. 1201 * our window.
1309 */ 1202 */
1310unsigned long 1203unsigned long
1311bgPixmap_t::make_transparency_pixmap () 1204rxvt_term::make_transparency_pixmap ()
1312{ 1205{
1313 unsigned long result = 0; 1206 unsigned long result = 0;
1314
1315 if (target == NULL)
1316 return 0;
1317 1207
1318 /* root dimensions may change from call to call - but Display structure should 1208 /* root dimensions may change from call to call - but Display structure should
1319 * be always up-to-date, so let's use it : 1209 * be always up-to-date, so let's use it :
1320 */ 1210 */
1321 Window root = target->display->root;
1322 int screen = target->display->screen; 1211 int screen = display->screen;
1323 Display *dpy = target->dpy; 1212 int root_depth = DefaultDepth (dpy, screen);
1324 int root_width = DisplayWidth (dpy, screen); 1213 int root_width = DisplayWidth (dpy, screen);
1325 int root_height = DisplayHeight (dpy, screen); 1214 int root_height = DisplayHeight (dpy, screen);
1326 unsigned int root_pmap_width, root_pmap_height; 1215 unsigned int root_pmap_width, root_pmap_height;
1327 int window_width = target->szHint.width; 1216 int window_width = szHint.width;
1328 int window_height = target->szHint.height; 1217 int window_height = szHint.height;
1329 int sx, sy; 1218 int sx, sy;
1330 XGCValues gcv; 1219 XGCValues gcv;
1331 GC gc; 1220 GC gc;
1332 1221
1333 TIMING_TEST_START (tp); 1222 sx = target_x;
1334 target->get_window_origin (sx, sy); 1223 sy = target_y;
1335 1224
1336 /* check if we are outside of the visible part of the virtual screen : */ 1225 /* check if we are outside of the visible part of the virtual screen : */
1337 if (sx + window_width <= 0 || sy + window_height <= 0 1226 if (sx + window_width <= 0 || sy + window_height <= 0
1338 || sx >= root_width || sy >= root_height) 1227 || sx >= root_width || sy >= root_height)
1339 return 0; 1228 return 0;
1340 1229
1230 // validate root pixmap and get its size
1341 if (root_pixmap != None) 1231 if (root_pixmap != None)
1342 { 1232 {
1343 /* we want to validate the pixmap and get its size at the same time : */ 1233 Window wdummy;
1344 int junk; 1234 int idummy;
1345 unsigned int ujunk; 1235 unsigned int udummy;
1346 /* root pixmap may be bad - allow a error */ 1236
1347 target->allowedxerror = -1; 1237 allowedxerror = -1;
1348 1238
1349 if (!XGetGeometry (dpy, root_pixmap, &root, &junk, &junk, &root_pmap_width, &root_pmap_height, &ujunk, &ujunk)) 1239 if (!XGetGeometry (dpy, root_pixmap, &wdummy, &idummy, &idummy, &root_pmap_width, &root_pmap_height, &udummy, &udummy))
1350 root_pixmap = None; 1240 root_pixmap = None;
1351 1241
1352 target->allowedxerror = 0; 1242 allowedxerror = 0;
1243 }
1244
1245 Pixmap recoded_root_pmap = root_pixmap;
1246
1247 if (root_pixmap != None && root_depth != depth)
1353 } 1248 {
1249#if XRENDER
1250 if (bg_flags & BG_HAS_RENDER)
1251 {
1252 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1354 1253
1254 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1255 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1256
1257 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1258 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1259
1260 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
1261
1262 XRenderFreePicture (dpy, src);
1263 XRenderFreePicture (dpy, dst);
1264 }
1265 else
1266#endif
1267 recoded_root_pmap = None;
1268 }
1269
1355 if (root_pixmap == None) 1270 if (recoded_root_pmap == None)
1356 return 0; 1271 return 0;
1357 1272
1273 if (bg_pixmap == None
1274 || bg_pmap_width != window_width
1275 || bg_pmap_height != window_height)
1276 {
1277 if (bg_pixmap)
1278 XFreePixmap (dpy, bg_pixmap);
1358 Pixmap tiled_root_pmap = XCreatePixmap (dpy, root, window_width, window_height, root_depth); 1279 bg_pixmap = XCreatePixmap (dpy, vt, window_width, window_height, depth);
1359 1280 bg_pmap_width = window_width;
1360 if (tiled_root_pmap == None) /* something really bad happened - abort */ 1281 bg_pmap_height = window_height;
1361 return 0; 1282 }
1362 1283
1363 /* straightforward pixmap copy */ 1284 /* straightforward pixmap copy */
1285 while (sx < 0) sx += root_pmap_width;
1286 while (sy < 0) sy += root_pmap_height;
1287
1364 gcv.tile = root_pixmap; 1288 gcv.tile = recoded_root_pmap;
1365 gcv.fill_style = FillTiled; 1289 gcv.fill_style = FillTiled;
1366
1367 while (sx < 0) sx += (int)root_width;
1368 while (sy < 0) sy += (int)root_height;
1369
1370 gcv.ts_x_origin = -sx; 1290 gcv.ts_x_origin = -sx;
1371 gcv.ts_y_origin = -sy; 1291 gcv.ts_y_origin = -sy;
1372 gc = XCreateGC (dpy, root, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); 1292 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1373 1293
1374 if (gc) 1294 if (gc)
1375 { 1295 {
1376 XFillRectangle (dpy, tiled_root_pmap, gc, 0, 0, window_width, window_height); 1296 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1377 result |= transpPmapTiled; 1297 result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS);
1298
1299 if (!(bg_flags & BG_CLIENT_RENDER))
1300 {
1301 if (bg_flags & BG_NEEDS_BLUR)
1302 {
1303 if (blur_pixmap (bg_pixmap, visual, window_width, window_height))
1304 result &= ~BG_NEEDS_BLUR;
1305 }
1306 if (bg_flags & BG_NEEDS_TINT)
1307 {
1308 if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1309 result &= ~BG_NEEDS_TINT;
1310 }
1311# ifndef HAVE_AFTERIMAGE
1312 if (result & BG_NEEDS_TINT)
1313 {
1314 XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1315 if (ximage)
1316 {
1317 /* our own client-side tinting */
1318 tint_ximage (DefaultVisual (dpy, display->screen), ximage);
1319
1320 XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
1321 XDestroyImage (ximage);
1322 }
1323 }
1324# endif
1325 } /* server side rendering completed */
1326
1378 XFreeGC (dpy, gc); 1327 XFreeGC (dpy, gc);
1379 } 1328 }
1380 TIMING_TEST_PRINT_RESULT (tp);
1381 1329
1382 if (tiled_root_pmap != None) 1330 if (recoded_root_pmap != root_pixmap)
1383 { 1331 XFreePixmap (dpy, recoded_root_pmap);
1384 if (!need_client_side_rendering ())
1385 {
1386 if ((flags & blurNeeded))
1387 {
1388 if (blur_pixmap (tiled_root_pmap, DefaultVisual (dpy, target->display->screen), window_width, window_height))
1389 result |= transpPmapBlurred;
1390 }
1391 if ((flags & tintNeeded))
1392 {
1393 if (tint_pixmap (tiled_root_pmap, DefaultVisual (dpy, target->display->screen), window_width, window_height))
1394 result |= transpPmapTinted;
1395 }
1396 } /* server side rendering completed */
1397
1398 if (pixmap)
1399 XFreePixmap (dpy, pixmap);
1400
1401 pixmap = tiled_root_pmap;
1402 pmap_width = window_width;
1403 pmap_height = window_height;
1404 pmap_depth = root_depth;
1405 }
1406
1407 TIMING_TEST_PRINT_RESULT (tp);
1408 1332
1409 return result; 1333 return result;
1410} 1334}
1411 1335
1336void
1337rxvt_term::bg_set_root_pixmap ()
1338{
1339 Pixmap new_root_pixmap = get_pixmap_property (xa[XA_XROOTPMAP_ID]);
1340 if (new_root_pixmap == None)
1341 new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]);
1342
1343 root_pixmap = new_root_pixmap;
1344}
1345# endif /* ENABLE_TRANSPARENCY */
1346
1412bool 1347bool
1413bgPixmap_t::set_root_pixmap () 1348rxvt_term::bg_render ()
1414{ 1349{
1415 Pixmap new_root_pixmap = target->get_pixmap_property (XA_XROOTPMAP_ID); 1350 unsigned long tr_flags = 0;
1416 if (new_root_pixmap == None)
1417 new_root_pixmap = target->get_pixmap_property (XA_ESETROOT_PMAP_ID);
1418 1351
1419 if (new_root_pixmap != root_pixmap) 1352 bg_invalidate ();
1420 { 1353# ifdef ENABLE_TRANSPARENCY
1421 root_pixmap = new_root_pixmap; 1354 if (bg_flags & BG_IS_TRANSPARENT)
1422 return true;
1423 } 1355 {
1424 1356 /* we need to re-generate transparency pixmap in that case ! */
1357 tr_flags = make_transparency_pixmap ();
1358 if (tr_flags == 0)
1425 return false; 1359 return false;
1426} 1360 bg_flags |= BG_IS_VALID;
1427# endif /* ENABLE_TRANSPARENCY */ 1361 }
1428
1429# ifndef HAVE_AFTERIMAGE
1430static void ShadeXImage(rxvt_term *term, XImage *srcImage, int shade, int rm, int gm, int bm);
1431# endif 1362# endif
1432 1363
1433bool 1364# ifdef BG_IMAGE_FROM_FILE
1434bgPixmap_t::render () 1365 if ((bg_flags & BG_IS_FROM_FILE)
1435{ 1366 || (tr_flags & BG_EFFECTS_FLAGS))
1436 unsigned long background_flags = 0;
1437
1438 if (target == NULL)
1439 return false;
1440
1441 TIMING_TEST_START (tp);
1442
1443 invalidate ();
1444# ifdef ENABLE_TRANSPARENCY
1445 if (flags & isTransparent)
1446 { 1367 {
1447 /* we need to re-generate transparency pixmap in that case ! */ 1368 if (render_image (tr_flags))
1448 background_flags = make_transparency_pixmap (); 1369 bg_flags |= BG_IS_VALID;
1449 if (background_flags == 0)
1450 return false;
1451 else if ((background_flags & transpTransformations) == (flags & transpTransformations)
1452 && pmap_depth == target->depth)
1453 flags = flags & ~isInvalid;
1454 } 1370 }
1455# endif 1371# endif
1456 1372
1457# ifdef BG_IMAGE_FROM_FILE 1373 if (!(bg_flags & BG_IS_VALID))
1458 if (have_image
1459 || (background_flags & transpTransformations) != (flags & transpTransformations))
1460 {
1461 if (render_image (background_flags))
1462 flags = flags & ~isInvalid;
1463 } 1374 {
1464# endif
1465
1466 XImage *result = NULL;
1467
1468 if (background_flags && (flags & isInvalid))
1469 {
1470 result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap);
1471 }
1472
1473 if (result)
1474 {
1475# if !defined(HAVE_AFTERIMAGE) && !XFT
1476 /* our own client-side tinting */
1477 /* ATTENTION: We ASSUME that XFT will let us do all the tinting necessary server-side.
1478 This may need to be changed in need_client_side_rendering() logic is altered !!! */
1479 if (!(background_flags & transpPmapTinted) && (flags & tintNeeded))
1480 {
1481 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1482 if (flags & tintSet)
1483 tint.get (c);
1484 ShadeXImage (target, result, shade, c.r, c.g, c.b);
1485 }
1486# endif
1487
1488 GC gc = XCreateGC (target->dpy, target->vt, 0UL, NULL);
1489
1490 if (gc)
1491 {
1492 if (/*pmap_depth != target->depth &&*/ pixmap != None)
1493 {
1494 XFreePixmap (target->dpy, pixmap);
1495 pixmap = None;
1496 }
1497
1498 if (pixmap == None)
1499 {
1500 pixmap = XCreatePixmap (target->dpy, target->vt, result->width, result->height, target->depth);
1501 pmap_width = result->width;
1502 pmap_height = result->height;
1503 pmap_depth = target->depth;
1504 }
1505
1506 if (pmap_depth != result->depth)
1507 {
1508 /* Bad Match error will ensue ! stupid X !!!! */
1509 if (result->depth == 24 && pmap_depth == 32)
1510 result->depth = 32;
1511 else if (result->depth == 32 && pmap_depth == 24)
1512 result->depth = 24;
1513 else
1514 {
1515 /* TODO: implement image recoding */
1516 }
1517 }
1518
1519 if (pmap_depth == result->depth)
1520 XPutImage (target->dpy, pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1521
1522 XFreeGC (target->dpy, gc);
1523 flags = flags & ~isInvalid;
1524 }
1525
1526 XDestroyImage (result);
1527 }
1528
1529 if (flags & isInvalid)
1530 {
1531 if (pixmap != None) 1375 if (bg_pixmap != None)
1532 { 1376 {
1533 XFreePixmap (target->dpy, pixmap); 1377 XFreePixmap (dpy, bg_pixmap);
1534 pixmap = None; 1378 bg_pixmap = None;
1535 } 1379 }
1536 } 1380 }
1537 1381
1538 apply (); 1382 scr_recolour (false);
1383 bg_flags |= BG_NEEDS_REFRESH;
1539 1384
1540 XSync (target->dpy, False);
1541 valid_since = ev::now (); 1385 bg_valid_since = ev::now ();
1542
1543 TIMING_TEST_PRINT_RESULT (tp);
1544 1386
1545 return true; 1387 return true;
1546} 1388}
1547 1389
1548bool
1549bgPixmap_t::set_target (rxvt_term *new_target)
1550{
1551 if (new_target)
1552 if (target != new_target)
1553 {
1554 target = new_target;
1555# ifdef ENABLE_TRANSPARENCY
1556 root_depth = DefaultDepthOfScreen (ScreenOfDisplay (target->dpy, target->display->screen));
1557# endif
1558 return true;
1559 }
1560
1561 return false;
1562}
1563
1564void 1390void
1565bgPixmap_t::apply () 1391rxvt_term::bg_init ()
1566{ 1392{
1567 if (target)
1568 {
1569 flags &= ~isVtOrigin;
1570
1571 if (pixmap != None)
1572 {
1573 /* set target's background to pixmap */
1574# ifdef ENABLE_TRANSPARENCY 1393#ifdef ENABLE_TRANSPARENCY
1575 if (flags & isTransparent) 1394 shade = 100;
1576 {
1577 XSetWindowBackgroundPixmap (target->dpy, target->parent[0], pixmap);
1578 XSetWindowBackgroundPixmap (target->dpy, target->vt, ParentRelative);
1579
1580 if (target->scrollBar.win)
1581 XSetWindowBackgroundPixmap (target->dpy, target->scrollBar.win, ParentRelative);
1582 }
1583 else
1584# endif 1395#endif
1585 {
1586 flags |= isVtOrigin;
1587 /* force old pixmap dereference in case it was transparent before :*/
1588 XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
1589 XSetWindowBackgroundPixmap (target->dpy, target->vt, pixmap);
1590 /* do we also need to set scrollbar's background here ? */
1591 1396
1592 if (target->scrollBar.win) 1397 bg_flags &= ~(BG_HAS_RENDER | BG_HAS_RENDER_CONV);
1593 XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]); 1398#if XRENDER
1594 } 1399 int major, minor;
1595 } 1400 if (XRenderQueryVersion (dpy, &major, &minor))
1596 else 1401 bg_flags |= BG_HAS_RENDER;
1597 { 1402 XFilters *filters = XRenderQueryFilters (dpy, vt);
1598 /* set target background to a pixel */ 1403 if (filters)
1599 XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
1600 XSetWindowBackground (target->dpy, target->vt, target->pix_colors[Color_bg]);
1601 /* do we also need to set scrollbar's background here ? */
1602 if (target->scrollBar.win)
1603 XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);
1604 }
1605
1606 /* don't want Expose on the parent or vt. It is better to use
1607 scr_touch or we get a great deal of flicker otherwise: */
1608 XClearWindow (target->dpy, target->parent[0]);
1609
1610 if (target->scrollBar.state && target->scrollBar.win)
1611 {
1612 target->scrollBar.state = STATE_IDLE;
1613 target->scrollBar.show (0);
1614 }
1615
1616 target->want_refresh = 1;
1617 flags |= hasChanged;
1618 } 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
1619} 1412}
1620 1413
1621#endif /* HAVE_BG_PIXMAP */ 1414#endif /* HAVE_BG_PIXMAP */
1622 1415
1623#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) && !XFT 1416#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1624/* taken from aterm-0.4.2 */ 1417/* based on code from aterm-0.4.2 */
1625 1418
1626typedef uint32_t RUINT32T;
1627
1628static void 1419static inline void
1629ShadeXImage(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)
1630{ 1433{
1631 int sh_r, sh_g, sh_b; 1434 int sh_r, sh_g, sh_b;
1632 RUINT32T mask_r, mask_g, mask_b; 1435 uint32_t mask_r, mask_g, mask_b;
1633 RUINT32T *lookup, *lookup_r, *lookup_g, *lookup_b; 1436 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1634 unsigned int lower_lim_r, lower_lim_g, lower_lim_b; 1437 unsigned short low;
1635 unsigned int upper_lim_r, upper_lim_g, upper_lim_b; 1438 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1636 int i;
1637 1439
1638 Visual *visual = term->visual;
1639
1640 if (visual->c_class != TrueColor || srcImage->format != ZPixmap) return ; 1440 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;
1641 1441
1642 /* for convenience */ 1442 /* for convenience */
1643 mask_r = visual->red_mask; 1443 mask_r = visual->red_mask;
1644 mask_g = visual->green_mask; 1444 mask_g = visual->green_mask;
1645 mask_b = visual->blue_mask; 1445 mask_b = visual->blue_mask;
1646 1446
1647 /* boring lookup table pre-initialization */ 1447 /* boring lookup table pre-initialization */
1648 switch (srcImage->bits_per_pixel) { 1448 switch (ximage->depth)
1449 {
1649 case 15: 1450 case 15:
1650 if ((mask_r != 0x7c00) || 1451 if ((mask_r != 0x7c00) ||
1651 (mask_g != 0x03e0) || 1452 (mask_g != 0x03e0) ||
1652 (mask_b != 0x001f)) 1453 (mask_b != 0x001f))
1653 return; 1454 return;
1654 lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(32+32+32)); 1455 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+32+32));
1655 lookup_r = lookup; 1456 lookup_r = lookup;
1656 lookup_g = lookup+32; 1457 lookup_g = lookup+32;
1657 lookup_b = lookup+32+32; 1458 lookup_b = lookup+32+32;
1658 sh_r = 10; 1459 sh_r = 10;
1659 sh_g = 5; 1460 sh_g = 5;
1660 sh_b = 0; 1461 sh_b = 0;
1661 break; 1462 break;
1662 case 16: 1463 case 16:
1663 if ((mask_r != 0xf800) || 1464 if ((mask_r != 0xf800) ||
1664 (mask_g != 0x07e0) || 1465 (mask_g != 0x07e0) ||
1665 (mask_b != 0x001f)) 1466 (mask_b != 0x001f))
1666 return; 1467 return;
1667 lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(32+64+32)); 1468 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+64+32));
1668 lookup_r = lookup; 1469 lookup_r = lookup;
1669 lookup_g = lookup+32; 1470 lookup_g = lookup+32;
1670 lookup_b = lookup+32+64; 1471 lookup_b = lookup+32+64;
1671 sh_r = 11; 1472 sh_r = 11;
1672 sh_g = 5; 1473 sh_g = 5;
1673 sh_b = 0; 1474 sh_b = 0;
1674 break; 1475 break;
1675 case 24: 1476 case 24:
1676 if ((mask_r != 0xff0000) || 1477 if ((mask_r != 0xff0000) ||
1677 (mask_g != 0x00ff00) || 1478 (mask_g != 0x00ff00) ||
1678 (mask_b != 0x0000ff)) 1479 (mask_b != 0x0000ff))
1679 return; 1480 return;
1680 lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(256+256+256)); 1481 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(256+256+256));
1681 lookup_r = lookup; 1482 lookup_r = lookup;
1682 lookup_g = lookup+256; 1483 lookup_g = lookup+256;
1683 lookup_b = lookup+256+256; 1484 lookup_b = lookup+256+256;
1684 sh_r = 16; 1485 sh_r = 16;
1685 sh_g = 8; 1486 sh_g = 8;
1686 sh_b = 0; 1487 sh_b = 0;
1687 break; 1488 break;
1688 case 32: 1489 case 32:
1689 if ((mask_r != 0xff0000) || 1490 if ((mask_r != 0xff0000) ||
1690 (mask_g != 0x00ff00) || 1491 (mask_g != 0x00ff00) ||
1691 (mask_b != 0x0000ff)) 1492 (mask_b != 0x0000ff))
1692 return; 1493 return;
1693 lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(256+256+256)); 1494 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(256+256+256));
1694 lookup_r = lookup; 1495 lookup_r = lookup;
1695 lookup_g = lookup+256; 1496 lookup_g = lookup+256;
1696 lookup_b = lookup+256+256; 1497 lookup_b = lookup+256+256;
1697 sh_r = 16; 1498 sh_r = 16;
1698 sh_g = 8; 1499 sh_g = 8;
1699 sh_b = 0; 1500 sh_b = 0;
1700 break; 1501 break;
1701 default: 1502 default:
1702 return; /* we do not support this color depth */ 1503 return; /* we do not support this color depth */
1703 } 1504 }
1505
1506 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1507
1508 if (bg_flags & BG_TINT_SET)
1509 tint.get (c);
1704 1510
1705 /* prepare limits for color transformation (each channel is handled separately) */ 1511 /* prepare limits for color transformation (each channel is handled separately) */
1706 if (shade > 100) { 1512 if (shade > 100)
1707 shade = 200 - shade;
1708
1709 lower_lim_r = 65535-rm;
1710 lower_lim_g = 65535-gm;
1711 lower_lim_b = 65535-bm;
1712
1713 lower_lim_r = 65535-(unsigned int)(((RUINT32T)lower_lim_r)*((RUINT32T)shade)/100);
1714 lower_lim_g = 65535-(unsigned int)(((RUINT32T)lower_lim_g)*((RUINT32T)shade)/100);
1715 lower_lim_b = 65535-(unsigned int)(((RUINT32T)lower_lim_b)*((RUINT32T)shade)/100);
1716
1717 upper_lim_r = upper_lim_g = upper_lim_b = 65535;
1718 } else {
1719
1720 lower_lim_r = lower_lim_g = lower_lim_b = 0;
1721
1722 upper_lim_r = (unsigned int)((((RUINT32T)rm)*((RUINT32T)shade))/100);
1723 upper_lim_g = (unsigned int)((((RUINT32T)gm)*((RUINT32T)shade))/100);
1724 upper_lim_b = (unsigned int)((((RUINT32T)bm)*((RUINT32T)shade))/100);
1725 }
1726
1727 /* switch red and blue bytes if necessary, we need it for some weird XServers like XFree86 3.3.3.1 */
1728 if ((srcImage->bits_per_pixel == 24) && (mask_r >= 0xFF0000 ))
1729 { 1513 {
1730 unsigned int tmp; 1514 c.r = c.r * (200 - shade) / 100;
1515 c.g = c.g * (200 - shade) / 100;
1516 c.b = c.b * (200 - shade) / 100;
1731 1517
1732 tmp = lower_lim_r; 1518 low = 0xffff * (shade - 100) / 100;
1733 lower_lim_r = lower_lim_b;
1734 lower_lim_b = tmp;
1735
1736 tmp = upper_lim_r;
1737 upper_lim_r = upper_lim_b;
1738 upper_lim_b = tmp;
1739 } 1519 }
1520 else
1521 {
1522 c.r = c.r * shade / 100;
1523 c.g = c.g * shade / 100;
1524 c.b = c.b * shade / 100;
1525
1526 low = 0;
1527 }
1740 1528
1741 /* fill our lookup tables */ 1529 /* fill our lookup tables */
1742 for (i = 0; i <= mask_r>>sh_r; i++) 1530 fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1743 { 1531 fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1744 RUINT32T tmp; 1532 fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1745 tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_r-lower_lim_r));
1746 tmp += ((RUINT32T)(mask_r>>sh_r))*((RUINT32T)lower_lim_r);
1747 lookup_r[i] = (tmp/65535)<<sh_r;
1748 }
1749 for (i = 0; i <= mask_g>>sh_g; i++)
1750 {
1751 RUINT32T tmp;
1752 tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_g-lower_lim_g));
1753 tmp += ((RUINT32T)(mask_g>>sh_g))*((RUINT32T)lower_lim_g);
1754 lookup_g[i] = (tmp/65535)<<sh_g;
1755 }
1756 for (i = 0; i <= mask_b>>sh_b; i++)
1757 {
1758 RUINT32T tmp;
1759 tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_b-lower_lim_b));
1760 tmp += ((RUINT32T)(mask_b>>sh_b))*((RUINT32T)lower_lim_b);
1761 lookup_b[i] = (tmp/65535)<<sh_b;
1762 }
1763 1533
1764 /* apply table to input image (replacing colors by newly calculated ones) */ 1534 /* apply table to input image (replacing colors by newly calculated ones) */
1765 switch (srcImage->bits_per_pixel) 1535 if (ximage->bits_per_pixel == 32
1536 && (ximage->depth == 24 || ximage->depth == 32)
1537 && ximage->byte_order == host_byte_order)
1766 { 1538 {
1767 case 15:
1768 {
1769 unsigned short *p1, *pf, *p, *pl; 1539 uint32_t *p1, *pf, *p, *pl;
1770 p1 = (unsigned short *) srcImage->data; 1540 p1 = (uint32_t *) ximage->data;
1771 pf = (unsigned short *) (srcImage->data + srcImage->height * srcImage->bytes_per_line); 1541 pf = (uint32_t *) (ximage->data + ximage->height * ximage->bytes_per_line);
1542
1772 while (p1 < pf) 1543 while (p1 < pf)
1773 { 1544 {
1774 p = p1; 1545 p = p1;
1775 pl = p1 + srcImage->width; 1546 pl = p1 + ximage->width;
1776 for (; p < pl; p++) 1547 for (; p < pl; p++)
1777 { 1548 {
1778 *p = lookup_r[(*p & 0x7c00)>>10] |
1779 lookup_g[(*p & 0x03e0)>> 5] |
1780 lookup_b[(*p & 0x001f)];
1781 }
1782 p1 = (unsigned short *) ((char *) p1 + srcImage->bytes_per_line);
1783 }
1784 break;
1785 }
1786 case 16:
1787 {
1788 unsigned short *p1, *pf, *p, *pl;
1789 p1 = (unsigned short *) srcImage->data;
1790 pf = (unsigned short *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
1791 while (p1 < pf)
1792 {
1793 p = p1;
1794 pl = p1 + srcImage->width;
1795 for (; p < pl; p++)
1796 {
1797 *p = lookup_r[(*p & 0xf800)>>11] |
1798 lookup_g[(*p & 0x07e0)>> 5] |
1799 lookup_b[(*p & 0x001f)];
1800 }
1801 p1 = (unsigned short *) ((char *) p1 + srcImage->bytes_per_line);
1802 }
1803 break;
1804 }
1805 case 24:
1806 {
1807 unsigned char *p1, *pf, *p, *pl;
1808 p1 = (unsigned char *) srcImage->data;
1809 pf = (unsigned char *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
1810 while (p1 < pf)
1811 {
1812 p = p1;
1813 pl = p1 + srcImage->width * 3;
1814 for (; p < pl; p += 3)
1815 {
1816 p[0] = lookup_r[(p[0] & 0xff0000)>>16];
1817 p[1] = lookup_r[(p[1] & 0x00ff00)>> 8];
1818 p[2] = lookup_r[(p[2] & 0x0000ff)];
1819 }
1820 p1 = (unsigned char *) ((char *) p1 + srcImage->bytes_per_line);
1821 }
1822 break;
1823 }
1824 case 32:
1825 {
1826 RUINT32T *p1, *pf, *p, *pl;
1827 p1 = (RUINT32T *) srcImage->data;
1828 pf = (RUINT32T *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
1829
1830 while (p1 < pf)
1831 {
1832 p = p1;
1833 pl = p1 + srcImage->width;
1834 for (; p < pl; p++)
1835 {
1836 *p = lookup_r[(*p & 0xff0000)>>16] | 1549 *p = lookup_r[(*p & 0xff0000) >> 16] |
1837 lookup_g[(*p & 0x00ff00)>> 8] | 1550 lookup_g[(*p & 0x00ff00) >> 8] |
1838 lookup_b[(*p & 0x0000ff)] | 1551 lookup_b[(*p & 0x0000ff)] |
1839 (*p & ~0xffffff); 1552 (*p & 0xff000000);
1553 }
1554 p1 = (uint32_t *) ((char *) p1 + ximage->bytes_per_line);
1555 }
1556 }
1557 else
1558 {
1559 for (int y = 0; y < ximage->height; y++)
1560 for (int x = 0; x < ximage->width; x++)
1561 {
1562 unsigned long pixel = XGetPixel (ximage, x, y);
1563 pixel = lookup_r[(pixel & mask_r) >> sh_r] |
1564 lookup_g[(pixel & mask_g) >> sh_g] |
1565 lookup_b[(pixel & mask_b) >> sh_b];
1566 XPutPixel (ximage, x, y, pixel);
1840 } 1567 }
1841 p1 = (RUINT32T *) ((char *) p1 + srcImage->bytes_per_line);
1842 } 1568 }
1843 break;
1844 }
1845 }
1846 1569
1847 free (lookup); 1570 free (lookup);
1848} 1571}
1849#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */ 1572#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */

Diff Legend

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