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

Diff Legend

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