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.118 by sf-exg, Tue Nov 16 15:49:56 2010 UTC vs.
Revision 1.161 by sf-exg, Thu Aug 11 08:39:10 2011 UTC

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

Diff Legend

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