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.210 by sf-exg, Sat May 12 09:43:06 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-2012 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
12 * the Free Software Foundation; either version 2 of the License, or 12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version. 13 * (at your option) any later version.
… …
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 {
291 char *tmp;
292 ops = strchr (str, ':');
293 if (ops != NULL)
294 { 172 {
295 for (tmp = ops-1; tmp >= str && isspace(*tmp); --tmp); 173 if (!strcasecmp (arr[i], "style=tiled"))
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 *line;
352 int width_r, width_g, width_b, width_a;
353 int sh_r, sh_g, sh_b, sh_a;
354 uint32_t alpha_mask;
355 int rowstride;
356 int channels;
357 unsigned char *row;
358
359 if (visual->c_class != TrueColor)
487 return false; 360 return false;
488 361
489 target->init_asv (); 362#if XRENDER
363 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
364 if (format)
365 alpha_mask = (uint32_t)format->direct.alphaMask << format->direct.alpha;
366 else
367#endif
368 alpha_mask = 0;
490 369
491 ASImage *background = NULL; 370 width_r = ecb_popcount32 (visual->red_mask);
492 ARGB32 background_tint = TINT_LEAVE_SAME; 371 width_g = ecb_popcount32 (visual->green_mask);
372 width_b = ecb_popcount32 (visual->blue_mask);
373 width_a = ecb_popcount32 (alpha_mask);
493 374
494# ifdef ENABLE_TRANSPARENCY 375 if (width_r > 8 || width_g > 8 || width_b > 8 || width_a > 8)
495 if (background_flags) 376 return false;
496 background = pixmap2ximage (target->asv, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, 100);
497 377
498 if (!(background_flags & transpPmapTinted) && (flags & tintNeeded)) 378 sh_r = ecb_ctz32 (visual->red_mask);
499 { 379 sh_g = ecb_ctz32 (visual->green_mask);
500 ShadingInfo as_shade; 380 sh_b = ecb_ctz32 (visual->blue_mask);
501 as_shade.shading = shade; 381 sh_a = ecb_ctz32 (alpha_mask);
502 382
503 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 383 if (width > 32767 || height > 32767)
504 if (flags & tintSet) 384 return false;
505 tint.get (c);
506 as_shade.tintColor.red = c.r;
507 as_shade.tintColor.green = c.g;
508 as_shade.tintColor.blue = c.b;
509 385
510 background_tint = shading2tint32 (&as_shade); 386 ximage = XCreateImage (dpy, visual, depth, ZPixmap, 0, 0,
387 width, height, 32, 0);
388 if (!ximage)
389 return false;
390
391 if (height > INT_MAX / ximage->bytes_per_line
392 || !(ximage->data = (char *)malloc (height * ximage->bytes_per_line)))
511 } 393 {
512 394 XDestroyImage (ximage);
513 if (!(background_flags & transpPmapBlurred) && (flags & blurNeeded) && background != NULL) 395 return false;
514 { 396 }
515 ASImage *tmp = blur_asimage_gauss (target->asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF, 397
516 (original_asim == NULL || tint == TINT_LEAVE_SAME) ? ASA_XImage : ASA_ASImage, 398 ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
517 100, ASIMAGE_QUALITY_DEFAULT); 399
518 if (tmp) 400 rowstride = gdk_pixbuf_get_rowstride (pixbuf);
401 channels = gdk_pixbuf_get_n_channels (pixbuf);
402 row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels;
403 line = ximage->data;
404
405 rgba c (0, 0, 0);
406
407 if (channels == 4 && alpha_mask == 0)
408 {
409 pix_colors[Color_bg].get (c);
410 c.r >>= 8;
411 c.g >>= 8;
412 c.b >>= 8;
413 }
414
415 for (int y = 0; y < height; y++)
416 {
417 for (int x = 0; x < width; x++)
418 {
419 unsigned char *pixel = row + x * channels;
420 uint32_t value;
421 unsigned char r, g, b, a;
422
423 if (channels == 4)
519 { 424 {
520 destroy_asimage (&background); 425 a = pixel[3];
521 background = tmp; 426 r = (pixel[0] * a + c.r * (0xff - a)) / 0xff;
427 g = (pixel[1] * a + c.g * (0xff - a)) / 0xff;
428 b = (pixel[2] * a + c.b * (0xff - a)) / 0xff;
429 }
430 else
431 {
432 a = 0xff;
433 r = pixel[0];
434 g = pixel[1];
435 b = pixel[2];
436 }
437
438 value = ((r >> (8 - width_r)) << sh_r)
439 | ((g >> (8 - width_g)) << sh_g)
440 | ((b >> (8 - width_b)) << sh_b)
441 | ((a >> (8 - width_a)) << sh_a);
442
443 if (ximage->bits_per_pixel == 32)
444 ((uint32_t *)line)[x] = value;
445 else
446 XPutPixel (ximage, x, y, value);
522 } 447 }
523 }
524# endif
525 448
526 ASImage *result = 0; 449 row += rowstride;
450 line += ximage->bytes_per_line;
451 }
527 452
453 XPutImage (dpy, pixmap, gc, ximage, 0, 0, dst_x, dst_y, width, height);
454 XDestroyImage (ximage);
455 return true;
456}
457
458bool
459rxvt_term::render_image (bool transparent)
460{
461 if (!pixbuf)
462 return false;
463
464 if (transparent
465 && !(bg_flags & BG_HAS_RENDER))
466 return false;
467
468 GdkPixbuf *result;
469
470 int image_width = gdk_pixbuf_get_width (pixbuf);
471 int image_height = gdk_pixbuf_get_height (pixbuf);
472
528 int target_width = target->szHint.width; 473 int target_width = szHint.width;
529 int target_height = target->szHint.height; 474 int target_height = szHint.height;
530 int new_pmap_width = target_width; 475 int new_pmap_width = target_width;
531 int new_pmap_height = target_height; 476 int new_pmap_height = target_height;
532 477
533 int x = 0; 478 int x = 0;
534 int y = 0; 479 int y = 0;
535 int w = 0; 480 int w = 0;
536 int h = 0; 481 int h = 0;
537 482
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); 483 get_image_geometry (image_width, image_height, w, h, x, y);
759 484
760 if (!(flags & rootAlign) 485 if (!(bg_flags & BG_ROOT_ALIGN)
761 && (x >= target_width 486 && (x >= target_width
762 || y >= target_height 487 || y >= target_height
763 || (x + w <= 0) 488 || x + w <= 0
764 || (y + h <= 0))) 489 || y + h <= 0))
765 return false; 490 return false;
766 491
767 result = pixbuf; 492 result = pixbuf;
768 493
769 if ((w != image_width) 494 if (w != image_width
770 || (h != image_height)) 495 || h != image_height)
771 { 496 {
772 result = gdk_pixbuf_scale_simple (pixbuf, 497 result = gdk_pixbuf_scale_simple (pixbuf,
773 w, h, 498 w, h,
774 GDK_INTERP_BILINEAR); 499 GDK_INTERP_BILINEAR);
775 } 500 }
776 501
502 if (!result)
503 return false;
504
777 bool ret = false; 505 bool ret = false;
778 506
779 if (result)
780 {
781 XGCValues gcv; 507 XGCValues gcv;
782 GC gc; 508 GC gc;
783 Pixmap root_pmap; 509 Pixmap root_pmap;
784 510
785 image_width = gdk_pixbuf_get_width (result); 511 image_width = gdk_pixbuf_get_width (result);
786 image_height = gdk_pixbuf_get_height (result); 512 image_height = gdk_pixbuf_get_height (result);
787 513
788 if (background_flags) 514 if (transparent)
789 { 515 {
790 root_pmap = pixmap; 516 root_pmap = bg_pixmap;
791 pixmap = None; 517 bg_pixmap = None;
518 }
519 else
520 {
521 if (bg_flags & BG_TILE)
522 {
523 new_pmap_width = min (image_width, target_width);
524 new_pmap_height = min (image_height, target_height);
792 } 525 }
793 else 526 }
794 {
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 527
528 if (bg_pixmap == None
529 || bg_pmap_width != new_pmap_width
530 || bg_pmap_height != new_pmap_height)
531 {
802 if (pixmap) 532 if (bg_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); 533 XFreePixmap (dpy, bg_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); 534 bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
816 pmap_width = new_pmap_width; 535 bg_pmap_width = new_pmap_width;
817 pmap_height = new_pmap_height; 536 bg_pmap_height = new_pmap_height;
818 pmap_depth = target->depth; 537 }
538
539 gcv.foreground = pix_colors[Color_bg];
540 gc = XCreateGC (dpy, vt, GCForeground, &gcv);
541
542 if (gc)
543 {
544 if (bg_flags & BG_TILE)
819 } 545 {
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); 546 Pixmap tile = XCreatePixmap (dpy, vt, image_width, image_height, depth);
827 gdk_pixbuf_xlib_render_to_drawable (result, tile, gc, 547 pixbuf_to_pixmap (result, tile, gc,
828 0, 0, 548 0, 0,
829 0, 0, 549 0, 0,
830 image_width, image_height, 550 image_width, image_height);
831 XLIB_RGB_DITHER_NONE,
832 0, 0);
833 551
834 gcv.tile = tile; 552 gcv.tile = tile;
835 gcv.fill_style = FillTiled; 553 gcv.fill_style = FillTiled;
836 gcv.ts_x_origin = x; 554 gcv.ts_x_origin = x;
837 gcv.ts_y_origin = y; 555 gcv.ts_y_origin = y;
838 XChangeGC (target->dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); 556 XChangeGC (dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
839 557
840 XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height); 558 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
841 XFreePixmap (target->dpy, tile); 559 XFreePixmap (dpy, tile);
842 } 560 }
843 else 561 else
844 { 562 {
845 int src_x, src_y, dst_x, dst_y; 563 int src_x, src_y, dst_x, dst_y;
846 int dst_width, dst_height; 564 int dst_width, dst_height;
… …
849 src_y = make_clip_rectangle (y, image_height, new_pmap_height, dst_y, dst_height); 567 src_y = make_clip_rectangle (y, image_height, new_pmap_height, dst_y, dst_height);
850 568
851 if (dst_x > 0 || dst_y > 0 569 if (dst_x > 0 || dst_y > 0
852 || dst_x + dst_width < new_pmap_width 570 || dst_x + dst_width < new_pmap_width
853 || dst_y + dst_height < new_pmap_height) 571 || dst_y + dst_height < new_pmap_height)
854 XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height); 572 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
855 573
856 if (dst_x < new_pmap_width && dst_y < new_pmap_height) 574 if (dst_x < new_pmap_width && dst_y < new_pmap_height)
857 gdk_pixbuf_xlib_render_to_drawable (result, pixmap, gc, 575 pixbuf_to_pixmap (result, bg_pixmap, gc,
858 src_x, src_y, 576 src_x, src_y,
859 dst_x, dst_y, 577 dst_x, dst_y,
860 dst_width, dst_height, 578 dst_width, dst_height);
861 XLIB_RGB_DITHER_NONE,
862 0, 0);
863 } 579 }
864 580
865#if XRENDER 581#if XRENDER
866 if (background_flags) 582 if (transparent)
867 { 583 {
868 Display *dpy = target->dpy;
869 XRenderPictureAttributes pa;
870
871 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, target->visual); 584 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
585
872 Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa); 586 Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
873 587
874 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, target->visual);
875 Picture dst = XRenderCreatePicture (dpy, pixmap, dst_format, 0, &pa); 588 Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
876 589
877 pa.repeat = True; 590 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 591
883 if (src && dst && mask)
884 {
885 XRenderColor mask_c; 592 XRenderColor mask_c;
886 593
887 mask_c.alpha = 0x8000; 594 mask_c.alpha = 0x8000;
888 mask_c.red = 0; 595 mask_c.red =
889 mask_c.green = 0; 596 mask_c.green =
890 mask_c.blue = 0; 597 mask_c.blue = 0;
891 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1); 598 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
599
892 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height); 600 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
893 }
894 601
895 XRenderFreePicture (dpy, src); 602 XRenderFreePicture (dpy, src);
896 XRenderFreePicture (dpy, dst); 603 XRenderFreePicture (dpy, dst);
897 XRenderFreePicture (dpy, mask); 604 XRenderFreePicture (dpy, mask);
898
899 XFreePixmap (dpy, root_pmap);
900 } 605 }
901#endif 606#endif
902 607
903 if (result != pixbuf)
904 g_object_unref (result);
905
906 XFreeGC (target->dpy, gc); 608 XFreeGC (dpy, gc);
907 609
908 ret = true; 610 ret = true;
909 } 611 }
910 612
613 if (result != pixbuf)
614 g_object_unref (result);
615
616 if (transparent)
617 XFreePixmap (dpy, root_pmap);
618
911 return ret; 619 return ret;
912} 620}
913# endif /* HAVE_PIXBUF */ 621# endif /* HAVE_PIXBUF */
914 622
915bool 623bool
916bgPixmap_t::set_file (const char *file) 624rxvt_term::bg_set_file (const char *file)
917{ 625{
918 if (!file || !*file) 626 if (!file || !*file)
919 return false; 627 return false;
920 628
629 bool ret = false;
921 if (const char *p = strchr (file, ';')) 630 const char *p = strchr (file, ';');
631
632 if (p)
922 { 633 {
923 size_t len = p - file; 634 size_t len = p - file;
924 char *f = rxvt_temp_buf<char> (len + 1); 635 char *f = rxvt_temp_buf<char> (len + 1);
925 memcpy (f, file, len); 636 memcpy (f, file, len);
926 f[len] = '\0'; 637 f[len] = '\0';
927 file = f; 638 file = f;
928 } 639 }
929 640
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 641# ifdef HAVE_PIXBUF
945 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL); 642 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
946 if (image) 643 if (image)
947 { 644 {
948 if (pixbuf) 645 if (pixbuf)
949 g_object_unref (pixbuf); 646 g_object_unref (pixbuf);
950 pixbuf = image; 647 pixbuf = image;
951 have_image = true; 648 bg_flags |= BG_IS_FROM_FILE;
649 ret = true;
650 }
651# endif
652
653 if (ret)
654 {
655 if (p)
656 bg_set_geometry (p + 1);
657 else
658 bg_set_default_geometry ();
659 }
660
661 return ret;
662}
663
664# endif /* BG_IMAGE_FROM_FILE */
665
666# ifdef ENABLE_TRANSPARENCY
667bool
668rxvt_term::bg_set_transparent ()
669{
670 if (!(bg_flags & BG_IS_TRANSPARENT))
671 {
672 bg_flags |= BG_IS_TRANSPARENT;
952 return true; 673 return true;
953 } 674 }
954# endif
955 675
956 return false; 676 return false;
957} 677}
958 678
959# endif /* BG_IMAGE_FROM_FILE */
960
961# ifdef ENABLE_TRANSPARENCY
962bool 679bool
963bgPixmap_t::set_transparent () 680rxvt_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{ 681{
977 bool changed = false; 682 bool changed = false;
978 unsigned int hr, vr; 683 unsigned int hr, vr;
979 int junk; 684 int junk;
980 int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr); 685 int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr);
… …
997 { 702 {
998 changed = true; 703 changed = true;
999 v_blurRadius = vr; 704 v_blurRadius = vr;
1000 } 705 }
1001 706
1002 if (v_blurRadius == 0 && h_blurRadius == 0) 707 if (h_blurRadius && v_blurRadius)
1003 flags &= ~blurNeeded; 708 bg_flags |= BG_NEEDS_BLUR;
1004 else 709 else
1005 flags |= blurNeeded; 710 bg_flags &= ~BG_NEEDS_BLUR;
1006 711
1007 return changed; 712 return changed;
1008} 713}
1009 714
1010static inline unsigned long 715void
1011compute_tint_shade_flags (rxvt_color *tint, int shade) 716rxvt_term::set_tint_shade_flags ()
1012{ 717{
1013 unsigned long flags = 0; 718 if (shade != 100 || (bg_flags & BG_TINT_SET))
1014 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 719 bg_flags |= BG_NEEDS_TINT;
1015 bool has_shade = shade != 100; 720 else
721 bg_flags &= ~BG_NEEDS_TINT;
722}
1016 723
1017 if (tint) 724bool
1018 { 725rxvt_term::bg_set_tint (rxvt_color &new_tint)
1019 tint->get (c); 726{
1020# define IS_COMPONENT_WHOLESOME(cmp) ((cmp) <= 0x000700 || (cmp) >= 0x00f700) 727 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 } 728 {
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; 729 tint = new_tint;
1049 flags = (flags & ~tintFlags) | new_flags | tintSet; 730 bg_flags |= BG_TINT_SET;
731
732 rgba c;
733 tint.get (c);
734 if ((c.r <= 0x00ff || c.r >= 0xff00)
735 && (c.g <= 0x00ff || c.g >= 0xff00)
736 && (c.b <= 0x00ff || c.b >= 0xff00))
737 bg_flags |= BG_TINT_BITAND;
738 else
739 bg_flags &= ~BG_TINT_BITAND;
740
741 set_tint_shade_flags ();
1050 return true; 742 return true;
1051 } 743 }
1052 744
1053 return false; 745 return false;
1054} 746}
1055 747
1056bool 748bool
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) 749rxvt_term::bg_set_shade (const char *shade_str)
1072{ 750{
1073 int new_shade = (shade_str) ? atoi (shade_str) : 100; 751 int new_shade = atoi (shade_str);
1074 752
1075 clamp_it (new_shade, -100, 200); 753 clamp_it (new_shade, -100, 200);
1076 if (new_shade < 0) 754 if (new_shade < 0)
1077 new_shade = 200 - (100 + new_shade); 755 new_shade = 200 - (100 + new_shade);
1078 756
1079 if (new_shade != shade) 757 if (new_shade != shade)
1080 { 758 {
1081 unsigned long new_flags = compute_tint_shade_flags ((flags & tintSet) ? &tint : NULL, new_shade);
1082 shade = new_shade; 759 shade = new_shade;
1083 flags = (flags & (~tintFlags | tintSet)) | new_flags; 760 set_tint_shade_flags ();
1084 return true; 761 return true;
1085 } 762 }
1086 763
1087 return false; 764 return false;
1088} 765}
… …
1109 params[i+2] = XDoubleToFixed (kernel[i] / sum); 786 params[i+2] = XDoubleToFixed (kernel[i] / sum);
1110} 787}
1111#endif 788#endif
1112 789
1113bool 790bool
1114bgPixmap_t::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 791rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height, int depth)
1115{ 792{
1116 bool ret = false; 793 bool ret = false;
1117#if XRENDER 794#if XRENDER
795 if (!(bg_flags & BG_HAS_RENDER_CONV))
796 return false;
797
1118 int size = max (h_blurRadius, v_blurRadius) * 2 + 1; 798 int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1119 double *kernel = (double *)malloc (size * sizeof (double)); 799 double *kernel = (double *)malloc (size * sizeof (double));
1120 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 800 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1121 801
1122 Display *dpy = target->dpy;
1123 XRenderPictureAttributes pa; 802 XRenderPictureAttributes pa;
1124 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 803 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1125 804
805 pa.repeat = RepeatPad;
1126 Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 806 Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
807 Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1127 Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 808 Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
809 XFreePixmap (dpy, tmp);
1128 810
1129 if (kernel && params && src && dst) 811 if (kernel && params)
1130 { 812 {
1131 if (h_blurRadius)
1132 {
1133 size = h_blurRadius * 2 + 1; 813 size = h_blurRadius * 2 + 1;
1134 get_gaussian_kernel (h_blurRadius, size, kernel, params); 814 get_gaussian_kernel (h_blurRadius, size, kernel, params);
1135 815
1136 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 816 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1137 XRenderComposite (dpy, 817 XRenderComposite (dpy,
1138 PictOpSrc, 818 PictOpSrc,
1139 src, 819 src,
1140 None, 820 None,
1141 dst, 821 dst,
1142 0, 0, 822 0, 0,
1143 0, 0, 823 0, 0,
1144 0, 0, 824 0, 0,
1145 width, height); 825 width, height);
1146 }
1147 826
1148 if (v_blurRadius) 827 ::swap (src, dst);
1149 { 828
1150 size = v_blurRadius * 2 + 1; 829 size = v_blurRadius * 2 + 1;
1151 get_gaussian_kernel (v_blurRadius, size, kernel, params); 830 get_gaussian_kernel (v_blurRadius, size, kernel, params);
1152 swap (params[0], params[1]); 831 ::swap (params[0], params[1]);
1153 832
1154 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 833 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1155 XRenderComposite (dpy, 834 XRenderComposite (dpy,
1156 PictOpSrc, 835 PictOpSrc,
1157 src, 836 src,
1158 None, 837 None,
1159 dst, 838 dst,
1160 0, 0, 839 0, 0,
1161 0, 0, 840 0, 0,
1162 0, 0, 841 0, 0,
1163 width, height); 842 width, height);
1164 }
1165 843
1166 ret = true; 844 ret = true;
1167 } 845 }
1168 846
1169 free (kernel); 847 free (kernel);
… …
1173#endif 851#endif
1174 return ret; 852 return ret;
1175} 853}
1176 854
1177bool 855bool
1178bgPixmap_t::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 856rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1179{ 857{
1180 Display *dpy = target->dpy;
1181 bool ret = false; 858 bool ret = false;
1182 859
1183 if (flags & tintWholesome) 860 if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1184 { 861 {
1185 XGCValues gcv; 862 XGCValues gcv;
1186 GC gc; 863 GC gc;
1187 864
1188 /* In this case we can tint image server-side getting significant 865 /* In this case we can tint image server-side getting significant
… …
1197 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height); 874 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1198 ret = true; 875 ret = true;
1199 XFreeGC (dpy, gc); 876 XFreeGC (dpy, gc);
1200 } 877 }
1201 } 878 }
1202 else
1203 {
1204# if XRENDER 879# if XRENDER
880 else if (bg_flags & BG_HAS_RENDER)
881 {
1205 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 882 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1206 883
1207 if (flags & tintSet) 884 if (bg_flags & BG_TINT_SET)
1208 tint.get (c); 885 tint.get (c);
1209 886
1210 if (shade <= 100) 887 if (shade <= 100)
1211 { 888 {
1212 c.r = (c.r * shade) / 100; 889 c.r = c.r * shade / 100;
1213 c.g = (c.g * shade) / 100; 890 c.g = c.g * shade / 100;
1214 c.b = (c.b * shade) / 100; 891 c.b = c.b * shade / 100;
1215 } 892 }
1216 else 893 else
1217 { 894 {
1218 c.r = ((0xffff - c.r) * (200 - shade)) / 100; 895 c.r = c.r * (200 - shade) / 100;
1219 c.g = ((0xffff - c.g) * (200 - shade)) / 100; 896 c.g = c.g * (200 - shade) / 100;
1220 c.b = ((0xffff - c.b) * (200 - shade)) / 100; 897 c.b = c.b * (200 - shade) / 100;
1221 } 898 }
1222 899
1223 XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1224 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 900 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1225 XRenderPictureAttributes pa;
1226 901
1227 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 902 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1228 903
1229 pa.repeat = True; 904 Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1230 905
1231 Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32); 906 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 907
1235 pa.component_alpha = True;
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
1240 if (mask_pic && overlay_pic && back_pic)
1241 {
1242 XRenderColor mask_c; 908 XRenderColor mask_c;
1243 909
1244 memset (&mask_c, (shade > 100) ? 0xFF : 0x0, sizeof (mask_c));
1245 mask_c.alpha = 0xffff; 910 mask_c.alpha = 0xffff;
911 mask_c.red =
912 mask_c.green =
913 mask_c.blue = 0;
914 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
915
916 mask_c.alpha = 0;
917 mask_c.red = 0xffff - c.r;
918 mask_c.green = 0xffff - c.g;
919 mask_c.blue = 0xffff - c.b;
920 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
921
922 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
923
924 if (shade > 100)
925 {
926 mask_c.alpha = 0;
927 mask_c.red =
928 mask_c.green =
929 mask_c.blue = 0xffff * (shade - 100) / 100;
1246 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1); 930 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1247 931
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); 932 XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1254 ret = true;
1255 } 933 }
934
935 ret = true;
1256 936
1257 XRenderFreePicture (dpy, mask_pic); 937 XRenderFreePicture (dpy, mask_pic);
1258 XRenderFreePicture (dpy, overlay_pic); 938 XRenderFreePicture (dpy, overlay_pic);
1259 XRenderFreePicture (dpy, back_pic); 939 XRenderFreePicture (dpy, back_pic);
940 }
1260# endif 941# endif
1261 }
1262 942
1263 return ret; 943 return ret;
1264} 944}
1265 945
1266/* make_transparency_pixmap() 946/*
1267 * Builds a pixmap of the same size as the terminal window that contains 947 * 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 948 * the tiled portion of the root pixmap that is supposed to be covered by
1269 * our window. 949 * our window.
1270 */ 950 */
1271unsigned long 951bool
1272bgPixmap_t::make_transparency_pixmap () 952rxvt_term::make_transparency_pixmap ()
1273{ 953{
1274 unsigned long result = 0; 954 bool ret = false;
1275
1276 if (target == NULL)
1277 return 0;
1278 955
1279 /* root dimensions may change from call to call - but Display structure should 956 /* root dimensions may change from call to call - but Display structure should
1280 * be always up-to-date, so let's use it : 957 * be always up-to-date, so let's use it :
1281 */ 958 */
1282 int screen = target->display->screen; 959 int screen = display->screen;
1283 Display *dpy = target->dpy;
1284 int root_depth = DefaultDepth (dpy, screen); 960 int root_depth = DefaultDepth (dpy, screen);
1285 int root_width = DisplayWidth (dpy, screen); 961 int root_width = DisplayWidth (dpy, screen);
1286 int root_height = DisplayHeight (dpy, screen); 962 int root_height = DisplayHeight (dpy, screen);
1287 unsigned int root_pmap_width, root_pmap_height; 963 unsigned int root_pmap_width, root_pmap_height;
1288 int window_width = target->szHint.width; 964 int window_width = szHint.width;
1289 int window_height = target->szHint.height; 965 int window_height = szHint.height;
1290 int sx, sy; 966 int sx, sy;
1291 XGCValues gcv; 967 XGCValues gcv;
1292 GC gc; 968 GC gc;
1293 969
1294 target->get_window_origin (sx, sy); 970 sx = target_x;
971 sy = target_y;
1295 972
1296 /* check if we are outside of the visible part of the virtual screen : */ 973 /* check if we are outside of the visible part of the virtual screen : */
1297 if (sx + window_width <= 0 || sy + window_height <= 0 974 if (sx + window_width <= 0 || sy + window_height <= 0
1298 || sx >= root_width || sy >= root_height) 975 || sx >= root_width || sy >= root_height)
1299 return 0; 976 return 0;
… …
1303 { 980 {
1304 Window wdummy; 981 Window wdummy;
1305 int idummy; 982 int idummy;
1306 unsigned int udummy; 983 unsigned int udummy;
1307 984
1308 target->allowedxerror = -1; 985 allowedxerror = -1;
1309 986
1310 if (!XGetGeometry (dpy, root_pixmap, &wdummy, &idummy, &idummy, &root_pmap_width, &root_pmap_height, &udummy, &udummy)) 987 if (!XGetGeometry (dpy, root_pixmap, &wdummy, &idummy, &idummy, &root_pmap_width, &root_pmap_height, &udummy, &udummy))
1311 root_pixmap = None; 988 root_pixmap = None;
1312 989
1313 target->allowedxerror = 0; 990 allowedxerror = 0;
1314 } 991 }
1315 992
1316 Pixmap recoded_root_pmap = root_pixmap; 993 Pixmap recoded_root_pmap = root_pixmap;
1317 994
1318 if (root_pixmap != None && root_depth != target->depth) 995 if (root_pixmap != None && root_depth != depth)
1319 { 996 {
1320#if XRENDER 997#if XRENDER
1321 if (flags & HAS_RENDER) 998 if (bg_flags & BG_HAS_RENDER)
1322 { 999 {
1323 XRenderPictureAttributes pa; 1000 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1324 1001
1325 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen)); 1002 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1326 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa); 1003 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1327 1004
1328 recoded_root_pmap = XCreatePixmap (dpy, target->vt, root_pmap_width, root_pmap_height, target->depth);
1329 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, target->visual); 1005 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1330 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa); 1006 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1331 1007
1332 if (src && dst)
1333 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height); 1008 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 1009
1340 XRenderFreePicture (dpy, src); 1010 XRenderFreePicture (dpy, src);
1341 XRenderFreePicture (dpy, dst); 1011 XRenderFreePicture (dpy, dst);
1342 } 1012 }
1343 else 1013 else
1344#endif 1014#endif
1345 root_pixmap = None; 1015 recoded_root_pmap = None;
1346 } 1016 }
1347 1017
1348 if (root_pixmap == None) 1018 if (recoded_root_pmap == None)
1349 return 0; 1019 return 0;
1350 1020
1021 if (bg_pixmap == None
1022 || bg_pmap_width != window_width
1023 || bg_pmap_height != window_height)
1024 {
1025 if (bg_pixmap)
1026 XFreePixmap (dpy, bg_pixmap);
1351 Pixmap tiled_root_pmap = XCreatePixmap (dpy, target->vt, window_width, window_height, target->depth); 1027 bg_pixmap = XCreatePixmap (dpy, vt, window_width, window_height, depth);
1352 1028 bg_pmap_width = window_width;
1353 if (tiled_root_pmap == None) /* something really bad happened - abort */ 1029 bg_pmap_height = window_height;
1354 return 0; 1030 }
1355 1031
1356 /* straightforward pixmap copy */ 1032 /* straightforward pixmap copy */
1033 while (sx < 0) sx += root_pmap_width;
1034 while (sy < 0) sy += root_pmap_height;
1035
1357 gcv.tile = recoded_root_pmap; 1036 gcv.tile = recoded_root_pmap;
1358 gcv.fill_style = FillTiled; 1037 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; 1038 gcv.ts_x_origin = -sx;
1364 gcv.ts_y_origin = -sy; 1039 gcv.ts_y_origin = -sy;
1365 gc = XCreateGC (dpy, target->vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); 1040 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1366 1041
1367 if (gc) 1042 if (gc)
1368 { 1043 {
1369 XFillRectangle (dpy, tiled_root_pmap, gc, 0, 0, window_width, window_height); 1044 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1370 result |= transpPmapTiled; 1045 ret = true;
1046 unsigned long tr_flags = bg_flags & BG_EFFECTS_FLAGS;
1047
1048 if (!(bg_flags & BG_CLIENT_RENDER))
1049 {
1050 if (bg_flags & BG_NEEDS_BLUR)
1051 {
1052 if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth))
1053 tr_flags &= ~BG_NEEDS_BLUR;
1054 }
1055 if (bg_flags & BG_NEEDS_TINT)
1056 {
1057 if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1058 tr_flags &= ~BG_NEEDS_TINT;
1059 }
1060 if (tr_flags & BG_NEEDS_TINT)
1061 {
1062 XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1063 if (ximage)
1064 {
1065 /* our own client-side tinting */
1066 tint_ximage (DefaultVisual (dpy, display->screen), ximage);
1067
1068 XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
1069 XDestroyImage (ximage);
1070 }
1071 }
1072 } /* server side rendering completed */
1073
1371 XFreeGC (dpy, gc); 1074 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 } 1075 }
1400 1076
1401 if (recoded_root_pmap != root_pixmap) 1077 if (recoded_root_pmap != root_pixmap)
1402 XFreePixmap (dpy, recoded_root_pmap); 1078 XFreePixmap (dpy, recoded_root_pmap);
1403 1079
1404 return result; 1080 return ret;
1405} 1081}
1406 1082
1407void 1083void
1408bgPixmap_t::set_root_pixmap () 1084rxvt_term::bg_set_root_pixmap ()
1409{ 1085{
1410 Pixmap new_root_pixmap = target->get_pixmap_property (XA_XROOTPMAP_ID); 1086 Pixmap new_root_pixmap = get_pixmap_property (xa[XA_XROOTPMAP_ID]);
1411 if (new_root_pixmap == None) 1087 if (new_root_pixmap == None)
1412 new_root_pixmap = target->get_pixmap_property (XA_ESETROOT_PMAP_ID); 1088 new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]);
1413 1089
1414 root_pixmap = new_root_pixmap; 1090 root_pixmap = new_root_pixmap;
1415} 1091}
1416# endif /* ENABLE_TRANSPARENCY */ 1092# endif /* ENABLE_TRANSPARENCY */
1417 1093
1418#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) 1094bool
1419static void ShadeXImage(Visual *visual, XImage *srcImage, int shade, const rgba &c); 1095rxvt_term::bg_render ()
1096{
1097 bool transparent = false;
1098
1099 bg_invalidate ();
1100# ifdef ENABLE_TRANSPARENCY
1101 if (bg_flags & BG_IS_TRANSPARENT)
1102 {
1103 /* we need to re-generate transparency pixmap in that case ! */
1104 transparent = make_transparency_pixmap ();
1105 if (transparent)
1106 bg_flags |= BG_IS_VALID;
1107 }
1420# endif 1108# endif
1421 1109
1422bool 1110# ifdef BG_IMAGE_FROM_FILE
1423bgPixmap_t::render () 1111 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 { 1112 {
1434 /* we need to re-generate transparency pixmap in that case ! */ 1113 if (render_image (transparent))
1435 background_flags = make_transparency_pixmap (); 1114 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 } 1115 }
1441# endif 1116# endif
1442 1117
1443# ifdef BG_IMAGE_FROM_FILE 1118 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 } 1119 {
1450# endif 1120 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 { 1121 {
1465 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 1122 XFreePixmap (dpy, bg_pixmap);
1466 if (flags & tintSet) 1123 bg_pixmap = None;
1467 tint.get (c);
1468 ShadeXImage (DefaultVisual (target->dpy, target->display->screen), result, shade, c);
1469 } 1124 }
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 { 1125 }
1487 if (pixmap != None)
1488 {
1489 XFreePixmap (target->dpy, pixmap);
1490 pixmap = None;
1491 }
1492 }
1493 1126
1494 apply (); 1127 scr_recolour (false);
1128 bg_flags |= BG_NEEDS_REFRESH;
1495 1129
1496 valid_since = ev::now (); 1130 bg_valid_since = ev::now ();
1497 1131
1498 return true; 1132 return true;
1499} 1133}
1500 1134
1501void 1135void
1502bgPixmap_t::set_target (rxvt_term *new_target) 1136rxvt_term::bg_init ()
1503{ 1137{
1504 target = new_target; 1138#ifdef ENABLE_TRANSPARENCY
1139 shade = 100;
1140#endif
1505 1141
1506 flags &= ~(HAS_RENDER | HAS_RENDER_CONV); 1142 bg_flags &= ~(BG_HAS_RENDER | BG_HAS_RENDER_CONV);
1507#if XRENDER 1143#if XRENDER
1508 int major, minor; 1144 int major, minor;
1509 if (XRenderQueryVersion (target->dpy, &major, &minor)) 1145 if (XRenderQueryVersion (dpy, &major, &minor))
1510 flags |= HAS_RENDER; 1146 bg_flags |= BG_HAS_RENDER;
1511 XFilters *filters = XRenderQueryFilters (target->dpy, target->vt); 1147 XFilters *filters = XRenderQueryFilters (dpy, vt);
1512 if (filters) 1148 if (filters)
1513 { 1149 {
1514 for (int i = 0; i < filters->nfilter; i++) 1150 for (int i = 0; i < filters->nfilter; i++)
1515 if (!strcmp (filters->filter[i], FilterConvolution)) 1151 if (!strcmp (filters->filter[i], FilterConvolution))
1516 flags |= HAS_RENDER_CONV; 1152 bg_flags |= BG_HAS_RENDER_CONV;
1517 1153
1518 XFree (filters); 1154 XFree (filters);
1519 } 1155 }
1520#endif 1156#endif
1521} 1157}
1522 1158
1159#endif /* HAVE_BG_PIXMAP */
1160
1161#ifdef ENABLE_TRANSPARENCY
1162/* based on code from aterm-0.4.2 */
1163
1164static inline void
1165fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
1166{
1167 for (int i = 0; i <= mask >> sh; i++)
1168 {
1169 uint32_t tmp;
1170 tmp = i * high;
1171 tmp += (mask >> sh) * low;
1172 lookup[i] = (tmp / 0xffff) << sh;
1173 }
1174}
1175
1523void 1176void
1524bgPixmap_t::apply () 1177rxvt_term::tint_ximage (Visual *visual, XImage *ximage)
1525{ 1178{
1526 if (target == NULL) 1179 unsigned int size_r, size_g, size_b;
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{
1585 int sh_r, sh_g, sh_b; 1180 int sh_r, sh_g, sh_b;
1586 uint32_t mask_r, mask_g, mask_b; 1181 uint32_t mask_r, mask_g, mask_b;
1587 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b; 1182 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1588 rgba low; 1183 unsigned short low;
1589 rgba high;
1590 int i;
1591 int host_byte_order = byteorder.big_endian () ? MSBFirst : LSBFirst; 1184 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1592 1185
1593 if (visual->c_class != TrueColor || srcImage->format != ZPixmap) return; 1186 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;
1594 1187
1595 /* for convenience */ 1188 /* for convenience */
1596 mask_r = visual->red_mask; 1189 mask_r = visual->red_mask;
1597 mask_g = visual->green_mask; 1190 mask_g = visual->green_mask;
1598 mask_b = visual->blue_mask; 1191 mask_b = visual->blue_mask;
1599 1192
1600 /* boring lookup table pre-initialization */ 1193 /* boring lookup table pre-initialization */
1601 switch (srcImage->depth) 1194 sh_r = ecb_ctz32 (mask_r);
1602 { 1195 sh_g = ecb_ctz32 (mask_g);
1603 case 15: 1196 sh_b = ecb_ctz32 (mask_b);
1604 if ((mask_r != 0x7c00) || 1197
1605 (mask_g != 0x03e0) || 1198 size_r = mask_r >> sh_r;
1606 (mask_b != 0x001f)) 1199 size_g = mask_g >> sh_g;
1200 size_b = mask_b >> sh_b;
1201
1202 if (size_r++ > 255 || size_g++ > 255 || size_b++ > 255)
1607 return; 1203 return;
1608 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+32+32)); 1204
1205 lookup = (uint32_t *)malloc (sizeof (uint32_t) * (size_r + size_g + size_b));
1609 lookup_r = lookup; 1206 lookup_r = lookup;
1610 lookup_g = lookup+32; 1207 lookup_g = lookup + size_r;
1611 lookup_b = lookup+32+32; 1208 lookup_b = lookup + size_r + size_g;
1612 sh_r = 10; 1209
1613 sh_g = 5; 1210 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1614 sh_b = 0; 1211
1615 break; 1212 if (bg_flags & BG_TINT_SET)
1616 case 16: 1213 tint.get (c);
1617 if ((mask_r != 0xf800) ||
1618 (mask_g != 0x07e0) ||
1619 (mask_b != 0x001f))
1620 return;
1621 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+64+32));
1622 lookup_r = lookup;
1623 lookup_g = lookup+32;
1624 lookup_b = lookup+32+64;
1625 sh_r = 11;
1626 sh_g = 5;
1627 sh_b = 0;
1628 break;
1629 case 24:
1630 if ((mask_r != 0xff0000) ||
1631 (mask_g != 0x00ff00) ||
1632 (mask_b != 0x0000ff))
1633 return;
1634 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(256+256+256));
1635 lookup_r = lookup;
1636 lookup_g = lookup+256;
1637 lookup_b = lookup+256+256;
1638 sh_r = 16;
1639 sh_g = 8;
1640 sh_b = 0;
1641 break;
1642 case 32:
1643 if ((mask_r != 0xff0000) ||
1644 (mask_g != 0x00ff00) ||
1645 (mask_b != 0x0000ff))
1646 return;
1647 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(256+256+256));
1648 lookup_r = lookup;
1649 lookup_g = lookup+256;
1650 lookup_b = lookup+256+256;
1651 sh_r = 16;
1652 sh_g = 8;
1653 sh_b = 0;
1654 break;
1655 default:
1656 return; /* we do not support this color depth */
1657 }
1658 1214
1659 /* prepare limits for color transformation (each channel is handled separately) */ 1215 /* prepare limits for color transformation (each channel is handled separately) */
1660 if (shade > 100) 1216 if (shade > 100)
1661 { 1217 {
1662 shade = 200 - shade; 1218 c.r = c.r * (200 - shade) / 100;
1219 c.g = c.g * (200 - shade) / 100;
1220 c.b = c.b * (200 - shade) / 100;
1663 1221
1664 high.r = (65535 - c.r) * shade / 100; 1222 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 } 1223 }
1672 else 1224 else
1673 { 1225 {
1674 high.r = c.r * shade / 100; 1226 c.r = c.r * shade / 100;
1675 high.g = c.g * shade / 100; 1227 c.g = c.g * shade / 100;
1676 high.b = c.b * shade / 100; 1228 c.b = c.b * shade / 100;
1677 1229
1678 low.r = low.g = low.b = 0; 1230 low = 0;
1679 } 1231 }
1680 1232
1681 /* fill our lookup tables */ 1233 /* fill our lookup tables */
1682 for (i = 0; i <= mask_r>>sh_r; i++) 1234 fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1683 { 1235 fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1684 uint32_t tmp; 1236 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 1237
1704 /* apply table to input image (replacing colors by newly calculated ones) */ 1238 /* apply table to input image (replacing colors by newly calculated ones) */
1705 if (srcImage->bits_per_pixel == 32 1239 if (ximage->bits_per_pixel == 32
1706 && (srcImage->depth == 24 || srcImage->depth == 32)
1707 && srcImage->byte_order == host_byte_order) 1240 && ximage->byte_order == host_byte_order)
1708 { 1241 {
1709 uint32_t *p1, *pf, *p, *pl; 1242 char *line = ximage->data;
1710 p1 = (uint32_t *) srcImage->data;
1711 pf = (uint32_t *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
1712 1243
1713 while (p1 < pf) 1244 for (int y = 0; y < ximage->height; y++)
1714 {
1715 p = p1;
1716 pl = p1 + srcImage->width;
1717 for (; p < pl; p++)
1718 { 1245 {
1719 *p = lookup_r[(*p & 0xff0000) >> 16] | 1246 uint32_t *p = (uint32_t *)line;
1720 lookup_g[(*p & 0x00ff00) >> 8] | 1247 for (int x = 0; x < ximage->width; x++)
1721 lookup_b[(*p & 0x0000ff)] |
1722 (*p & 0xff000000);
1723 } 1248 {
1724 p1 = (uint32_t *) ((char *) p1 + srcImage->bytes_per_line); 1249 *p = lookup_r[(*p & mask_r) >> sh_r] |
1250 lookup_g[(*p & mask_g) >> sh_g] |
1251 lookup_b[(*p & mask_b) >> sh_b];
1252 p++;
1253 }
1254 line += ximage->bytes_per_line;
1725 } 1255 }
1726 } 1256 }
1727 else 1257 else
1728 { 1258 {
1729 for (int y = 0; y < srcImage->height; y++) 1259 for (int y = 0; y < ximage->height; y++)
1730 for (int x = 0; x < srcImage->width; x++) 1260 for (int x = 0; x < ximage->width; x++)
1731 { 1261 {
1732 unsigned long pixel = XGetPixel (srcImage, x, y); 1262 unsigned long pixel = XGetPixel (ximage, x, y);
1733 pixel = lookup_r[(pixel & mask_r) >> sh_r] | 1263 pixel = lookup_r[(pixel & mask_r) >> sh_r] |
1734 lookup_g[(pixel & mask_g) >> sh_g] | 1264 lookup_g[(pixel & mask_g) >> sh_g] |
1735 lookup_b[(pixel & mask_b) >> sh_b]; 1265 lookup_b[(pixel & mask_b) >> sh_b];
1736 XPutPixel (srcImage, x, y, pixel); 1266 XPutPixel (ximage, x, y, pixel);
1737 } 1267 }
1738 } 1268 }
1739 1269
1740 free (lookup); 1270 free (lookup);
1741} 1271}
1742#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */ 1272#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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