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.116 by sf-exg, Thu Nov 11 11:58:10 2010 UTC vs.
Revision 1.146 by sf-exg, Sat Jan 29 17:50:31 2011 UTC

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

Diff Legend

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