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

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.80 by sf-exg, Wed Oct 13 23:04:57 2010 UTC vs.
Revision 1.197 by sf-exg, Wed Jan 11 13:22:01 2012 UTC

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

Diff Legend

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