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.114 by sf-exg, Wed Nov 10 13:15:08 2010 UTC vs.
Revision 1.212 by sf-exg, Sun May 13 15:50:18 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;
952 return true; 649 ret = true;
953 } 650 }
954# endif 651# endif
955 652
653 if (ret)
654 {
655 if (p)
656 bg_set_geometry (p + 1);
657 else
658 bg_set_default_geometry ();
659 }
660
956 return false; 661 return ret;
957} 662}
958 663
959# endif /* BG_IMAGE_FROM_FILE */ 664# endif /* BG_IMAGE_FROM_FILE */
960 665
961# ifdef ENABLE_TRANSPARENCY 666# ifdef ENABLE_TRANSPARENCY
962bool 667bool
963bgPixmap_t::set_transparent () 668rxvt_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{ 669{
977 bool changed = false; 670 bool changed = false;
978 unsigned int hr, vr; 671 unsigned int hr, vr;
979 int junk; 672 int junk;
980 int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr); 673 int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr);
… …
997 { 690 {
998 changed = true; 691 changed = true;
999 v_blurRadius = vr; 692 v_blurRadius = vr;
1000 } 693 }
1001 694
1002 if (v_blurRadius == 0 && h_blurRadius == 0)
1003 flags &= ~blurNeeded;
1004 else
1005 flags |= blurNeeded;
1006
1007 return changed; 695 return changed;
1008} 696}
1009 697
1010static inline unsigned long 698bool
1011compute_tint_shade_flags (rxvt_color *tint, int shade) 699rxvt_term::bg_set_tint (rxvt_color &new_tint)
1012{ 700{
1013 unsigned long flags = 0; 701 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
1014 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1015 bool has_shade = shade != 100;
1016
1017 if (tint)
1018 {
1019 tint->get (c);
1020# define IS_COMPONENT_WHOLESOME(cmp) ((cmp) <= 0x000700 || (cmp) >= 0x00f700)
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 } 702 {
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; 703 tint = new_tint;
1049 flags = (flags & ~tintFlags) | new_flags | tintSet; 704 bg_flags |= BG_TINT_SET;
705
706 rgba c;
707 tint.get (c);
708 if ((c.r <= 0x00ff || c.r >= 0xff00)
709 && (c.g <= 0x00ff || c.g >= 0xff00)
710 && (c.b <= 0x00ff || c.b >= 0xff00))
711 bg_flags |= BG_TINT_BITAND;
712 else
713 bg_flags &= ~BG_TINT_BITAND;
714
1050 return true; 715 return true;
1051 } 716 }
1052 717
1053 return false; 718 return false;
1054} 719}
1055 720
1056bool 721bool
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) 722rxvt_term::bg_set_shade (const char *shade_str)
1072{ 723{
1073 int new_shade = (shade_str) ? atoi (shade_str) : 100; 724 int new_shade = atoi (shade_str);
1074 725
1075 clamp_it (new_shade, -100, 200); 726 clamp_it (new_shade, -100, 200);
1076 if (new_shade < 0) 727 if (new_shade < 0)
1077 new_shade = 200 - (100 + new_shade); 728 new_shade = 200 - (100 + new_shade);
1078 729
1079 if (new_shade != shade) 730 if (new_shade != shade)
1080 { 731 {
1081 unsigned long new_flags = compute_tint_shade_flags ((flags & tintSet) ? &tint : NULL, new_shade);
1082 shade = new_shade; 732 shade = new_shade;
1083 flags = (flags & (~tintFlags | tintSet)) | new_flags;
1084 return true; 733 return true;
1085 } 734 }
1086 735
1087 return false; 736 return false;
1088} 737}
… …
1109 params[i+2] = XDoubleToFixed (kernel[i] / sum); 758 params[i+2] = XDoubleToFixed (kernel[i] / sum);
1110} 759}
1111#endif 760#endif
1112 761
1113bool 762bool
1114bgPixmap_t::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 763rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height, int depth)
1115{ 764{
1116 bool ret = false; 765 bool ret = false;
1117#if XRENDER 766#if XRENDER
767 if (!(bg_flags & BG_HAS_RENDER_CONV))
768 return false;
769
1118 int size = max (h_blurRadius, v_blurRadius) * 2 + 1; 770 int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1119 double *kernel = (double *)malloc (size * sizeof (double)); 771 double *kernel = (double *)malloc (size * sizeof (double));
1120 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 772 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1121 773
1122 Display *dpy = target->dpy;
1123 XRenderPictureAttributes pa; 774 XRenderPictureAttributes pa;
1124 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 775 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1125 776
777 pa.repeat = RepeatPad;
1126 Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 778 Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
779 Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1127 Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 780 Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
781 XFreePixmap (dpy, tmp);
1128 782
1129 if (kernel && params && src && dst) 783 if (kernel && params)
1130 { 784 {
1131 if (h_blurRadius)
1132 {
1133 size = h_blurRadius * 2 + 1; 785 size = h_blurRadius * 2 + 1;
1134 get_gaussian_kernel (h_blurRadius, size, kernel, params); 786 get_gaussian_kernel (h_blurRadius, size, kernel, params);
1135 787
1136 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 788 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1137 XRenderComposite (dpy, 789 XRenderComposite (dpy,
1138 PictOpSrc, 790 PictOpSrc,
1139 src, 791 src,
1140 None, 792 None,
1141 dst, 793 dst,
1142 0, 0, 794 0, 0,
1143 0, 0, 795 0, 0,
1144 0, 0, 796 0, 0,
1145 width, height); 797 width, height);
1146 }
1147 798
1148 if (v_blurRadius) 799 ::swap (src, dst);
1149 { 800
1150 size = v_blurRadius * 2 + 1; 801 size = v_blurRadius * 2 + 1;
1151 get_gaussian_kernel (v_blurRadius, size, kernel, params); 802 get_gaussian_kernel (v_blurRadius, size, kernel, params);
1152 swap (params[0], params[1]); 803 ::swap (params[0], params[1]);
1153 804
1154 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 805 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1155 XRenderComposite (dpy, 806 XRenderComposite (dpy,
1156 PictOpSrc, 807 PictOpSrc,
1157 src, 808 src,
1158 None, 809 None,
1159 dst, 810 dst,
1160 0, 0, 811 0, 0,
1161 0, 0, 812 0, 0,
1162 0, 0, 813 0, 0,
1163 width, height); 814 width, height);
1164 }
1165 815
1166 ret = true; 816 ret = true;
1167 } 817 }
1168 818
1169 free (kernel); 819 free (kernel);
… …
1173#endif 823#endif
1174 return ret; 824 return ret;
1175} 825}
1176 826
1177bool 827bool
1178bgPixmap_t::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 828rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1179{ 829{
1180 Display *dpy = target->dpy;
1181 bool ret = false; 830 bool ret = false;
1182 831
1183 if (flags & tintWholesome) 832 if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1184 { 833 {
1185 XGCValues gcv; 834 XGCValues gcv;
1186 GC gc; 835 GC gc;
1187 836
1188 /* In this case we can tint image server-side getting significant 837 /* In this case we can tint image server-side getting significant
… …
1197 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height); 846 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1198 ret = true; 847 ret = true;
1199 XFreeGC (dpy, gc); 848 XFreeGC (dpy, gc);
1200 } 849 }
1201 } 850 }
1202 else
1203 {
1204# if XRENDER 851# if XRENDER
852 else if (bg_flags & BG_HAS_RENDER)
853 {
1205 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 854 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1206 855
1207 if (flags & tintSet) 856 if (bg_flags & BG_TINT_SET)
1208 tint.get (c); 857 tint.get (c);
1209 858
1210 if (shade <= 100) 859 if (shade <= 100)
1211 { 860 {
1212 c.r = (c.r * shade) / 100; 861 c.r = c.r * shade / 100;
1213 c.g = (c.g * shade) / 100; 862 c.g = c.g * shade / 100;
1214 c.b = (c.b * shade) / 100; 863 c.b = c.b * shade / 100;
1215 } 864 }
1216 else 865 else
1217 { 866 {
1218 c.r = ((0xffff - c.r) * (200 - shade)) / 100; 867 c.r = c.r * (200 - shade) / 100;
1219 c.g = ((0xffff - c.g) * (200 - shade)) / 100; 868 c.g = c.g * (200 - shade) / 100;
1220 c.b = ((0xffff - c.b) * (200 - shade)) / 100; 869 c.b = c.b * (200 - shade) / 100;
1221 } 870 }
1222 871
1223 XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1224 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 872 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1225 XRenderPictureAttributes pa;
1226 873
1227 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 874 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1228 875
1229 pa.repeat = True; 876 Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1230 877
1231 Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32); 878 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 879
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; 880 XRenderColor mask_c;
1243 881
1244 memset (&mask_c, (shade > 100) ? 0xFF : 0x0, sizeof (mask_c));
1245 mask_c.alpha = 0xffff; 882 mask_c.alpha = 0xffff;
883 mask_c.red =
884 mask_c.green =
885 mask_c.blue = 0;
886 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
887
888 mask_c.alpha = 0;
889 mask_c.red = 0xffff - c.r;
890 mask_c.green = 0xffff - c.g;
891 mask_c.blue = 0xffff - c.b;
892 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
893
894 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
895
896 if (shade > 100)
897 {
898 mask_c.alpha = 0;
899 mask_c.red =
900 mask_c.green =
901 mask_c.blue = 0xffff * (shade - 100) / 100;
1246 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1); 902 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1247 903
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); 904 XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1254 ret = true;
1255 } 905 }
906
907 ret = true;
1256 908
1257 XRenderFreePicture (dpy, mask_pic); 909 XRenderFreePicture (dpy, mask_pic);
1258 XRenderFreePicture (dpy, overlay_pic); 910 XRenderFreePicture (dpy, overlay_pic);
1259 XRenderFreePicture (dpy, back_pic); 911 XRenderFreePicture (dpy, back_pic);
912 }
1260# endif 913# endif
1261 }
1262 914
1263 return ret; 915 return ret;
1264} 916}
1265 917
1266/* make_transparency_pixmap() 918/*
1267 * Builds a pixmap of the same size as the terminal window that contains 919 * 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 920 * the tiled portion of the root pixmap that is supposed to be covered by
1269 * our window. 921 * our window.
1270 */ 922 */
1271unsigned long 923bool
1272bgPixmap_t::make_transparency_pixmap () 924rxvt_term::make_transparency_pixmap ()
1273{ 925{
1274 unsigned long result = 0; 926 bool ret = false;
1275
1276 if (target == NULL)
1277 return 0;
1278 927
1279 /* root dimensions may change from call to call - but Display structure should 928 /* root dimensions may change from call to call - but Display structure should
1280 * be always up-to-date, so let's use it : 929 * be always up-to-date, so let's use it :
1281 */ 930 */
1282 int screen = target->display->screen; 931 int screen = display->screen;
1283 Display *dpy = target->dpy;
1284 int root_depth = DefaultDepth (dpy, screen); 932 int root_depth = DefaultDepth (dpy, screen);
1285 int root_width = DisplayWidth (dpy, screen); 933 int root_width = DisplayWidth (dpy, screen);
1286 int root_height = DisplayHeight (dpy, screen); 934 int root_height = DisplayHeight (dpy, screen);
1287 unsigned int root_pmap_width, root_pmap_height; 935 unsigned int root_pmap_width, root_pmap_height;
1288 int window_width = target->szHint.width; 936 int window_width = szHint.width;
1289 int window_height = target->szHint.height; 937 int window_height = szHint.height;
1290 int sx, sy; 938 int sx, sy;
1291 XGCValues gcv; 939 XGCValues gcv;
1292 GC gc; 940 GC gc;
1293 941
1294 target->get_window_origin (sx, sy); 942 sx = target_x;
943 sy = target_y;
1295 944
1296 /* check if we are outside of the visible part of the virtual screen : */ 945 /* check if we are outside of the visible part of the virtual screen : */
1297 if (sx + window_width <= 0 || sy + window_height <= 0 946 if (sx + window_width <= 0 || sy + window_height <= 0
1298 || sx >= root_width || sy >= root_height) 947 || sx >= root_width || sy >= root_height)
1299 return 0; 948 return 0;
… …
1303 { 952 {
1304 Window wdummy; 953 Window wdummy;
1305 int idummy; 954 int idummy;
1306 unsigned int udummy; 955 unsigned int udummy;
1307 956
1308 target->allowedxerror = -1; 957 allowedxerror = -1;
1309 958
1310 if (!XGetGeometry (dpy, root_pixmap, &wdummy, &idummy, &idummy, &root_pmap_width, &root_pmap_height, &udummy, &udummy)) 959 if (!XGetGeometry (dpy, root_pixmap, &wdummy, &idummy, &idummy, &root_pmap_width, &root_pmap_height, &udummy, &udummy))
1311 root_pixmap = None; 960 root_pixmap = None;
1312 961
1313 target->allowedxerror = 0; 962 allowedxerror = 0;
1314 } 963 }
1315 964
1316 Pixmap recoded_root_pmap = root_pixmap; 965 Pixmap recoded_root_pmap = root_pixmap;
1317 966
1318 if (root_pixmap != None && root_depth != target->depth) 967 if (root_pixmap != None && root_depth != depth)
1319 { 968 {
1320#if XRENDER 969#if XRENDER
1321 if (flags & HAS_RENDER) 970 if (bg_flags & BG_HAS_RENDER)
1322 { 971 {
1323 XRenderPictureAttributes pa; 972 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1324 973
1325 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen)); 974 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1326 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa); 975 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1327 976
1328 recoded_root_pmap = XCreatePixmap (dpy, target->vt, root_pmap_width, root_pmap_height, target->depth);
1329 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, target->visual); 977 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1330 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa); 978 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1331 979
1332 if (src && dst)
1333 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height); 980 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 981
1340 XRenderFreePicture (dpy, src); 982 XRenderFreePicture (dpy, src);
1341 XRenderFreePicture (dpy, dst); 983 XRenderFreePicture (dpy, dst);
1342 } 984 }
1343 else 985 else
1344#endif 986#endif
1345 root_pixmap = None; 987 recoded_root_pmap = None;
1346 } 988 }
1347 989
1348 if (root_pixmap == None) 990 if (recoded_root_pmap == None)
1349 return 0; 991 return 0;
1350 992
993 if (bg_pixmap == None
994 || bg_pmap_width != window_width
995 || bg_pmap_height != window_height)
996 {
997 if (bg_pixmap)
998 XFreePixmap (dpy, bg_pixmap);
1351 Pixmap tiled_root_pmap = XCreatePixmap (dpy, target->vt, window_width, window_height, target->depth); 999 bg_pixmap = XCreatePixmap (dpy, vt, window_width, window_height, depth);
1352 1000 bg_pmap_width = window_width;
1353 if (tiled_root_pmap == None) /* something really bad happened - abort */ 1001 bg_pmap_height = window_height;
1354 return 0; 1002 }
1355 1003
1356 /* straightforward pixmap copy */ 1004 /* straightforward pixmap copy */
1005 while (sx < 0) sx += root_pmap_width;
1006 while (sy < 0) sy += root_pmap_height;
1007
1357 gcv.tile = recoded_root_pmap; 1008 gcv.tile = recoded_root_pmap;
1358 gcv.fill_style = FillTiled; 1009 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; 1010 gcv.ts_x_origin = -sx;
1364 gcv.ts_y_origin = -sy; 1011 gcv.ts_y_origin = -sy;
1365 gc = XCreateGC (dpy, target->vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); 1012 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1366 1013
1367 if (gc) 1014 if (gc)
1368 { 1015 {
1369 XFillRectangle (dpy, tiled_root_pmap, gc, 0, 0, window_width, window_height); 1016 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1370 result |= transpPmapTiled; 1017 ret = true;
1018 bool need_blur = h_blurRadius && v_blurRadius;
1019 bool need_tint = shade != 100 || (bg_flags & BG_TINT_SET);
1020
1021 if (!(bg_flags & BG_CLIENT_RENDER))
1022 {
1023 if (need_blur)
1024 {
1025 if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth))
1026 need_blur = false;
1027 }
1028 if (need_tint)
1029 {
1030 if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1031 need_tint = false;
1032 }
1033 if (need_tint)
1034 {
1035 XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1036 if (ximage)
1037 {
1038 /* our own client-side tinting */
1039 tint_ximage (DefaultVisual (dpy, display->screen), ximage);
1040
1041 XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
1042 XDestroyImage (ximage);
1043 }
1044 }
1045 } /* server side rendering completed */
1046
1371 XFreeGC (dpy, gc); 1047 XFreeGC (dpy, gc);
1372
1373 if (!need_client_side_rendering ())
1374 {
1375 if ((flags & blurNeeded)
1376 && (flags & HAS_RENDER_CONV))
1377 {
1378 if (blur_pixmap (tiled_root_pmap, target->visual, window_width, window_height))
1379 result |= transpPmapBlurred;
1380 }
1381 if ((flags & tintNeeded)
1382 && (flags & (tintWholesome | HAS_RENDER)))
1383 {
1384 if (tint_pixmap (tiled_root_pmap, target->visual, window_width, window_height))
1385 result |= transpPmapTinted;
1386 }
1387 } /* server side rendering completed */
1388
1389 if (pixmap)
1390 XFreePixmap (dpy, pixmap);
1391
1392 pixmap = tiled_root_pmap;
1393 pmap_width = window_width;
1394 pmap_height = window_height;
1395 pmap_depth = target->depth;
1396 } 1048 }
1397 else
1398 XFreePixmap (dpy, tiled_root_pmap);
1399 1049
1400 if (recoded_root_pmap != root_pixmap) 1050 if (recoded_root_pmap != root_pixmap)
1401 XFreePixmap (dpy, recoded_root_pmap); 1051 XFreePixmap (dpy, recoded_root_pmap);
1402 1052
1403 return result; 1053 return ret;
1404} 1054}
1405 1055
1406void 1056void
1407bgPixmap_t::set_root_pixmap () 1057rxvt_term::bg_set_root_pixmap ()
1408{ 1058{
1409 Pixmap new_root_pixmap = target->get_pixmap_property (XA_XROOTPMAP_ID); 1059 Pixmap new_root_pixmap = get_pixmap_property (xa[XA_XROOTPMAP_ID]);
1410 if (new_root_pixmap == None) 1060 if (new_root_pixmap == None)
1411 new_root_pixmap = target->get_pixmap_property (XA_ESETROOT_PMAP_ID); 1061 new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]);
1412 1062
1413 root_pixmap = new_root_pixmap; 1063 root_pixmap = new_root_pixmap;
1414} 1064}
1415# endif /* ENABLE_TRANSPARENCY */ 1065# endif /* ENABLE_TRANSPARENCY */
1416 1066
1417#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) 1067bool
1418static void ShadeXImage(Visual *visual, XImage *srcImage, int shade, const rgba &c); 1068rxvt_term::bg_render ()
1069{
1070 bool transparent = false;
1071
1072 bg_invalidate ();
1073# ifdef ENABLE_TRANSPARENCY
1074 if (bg_flags & BG_IS_TRANSPARENT)
1075 {
1076 /* we need to re-generate transparency pixmap in that case ! */
1077 transparent = make_transparency_pixmap ();
1078 if (transparent)
1079 bg_flags |= BG_IS_VALID;
1080 }
1419# endif 1081# endif
1420 1082
1421bool 1083# ifdef BG_IMAGE_FROM_FILE
1422bgPixmap_t::render () 1084 if (bg_flags & BG_IS_FROM_FILE)
1423{
1424 unsigned long background_flags = 0;
1425
1426 if (target == NULL)
1427 return false;
1428
1429 invalidate ();
1430# ifdef ENABLE_TRANSPARENCY
1431 if (flags & isTransparent)
1432 { 1085 {
1433 /* we need to re-generate transparency pixmap in that case ! */ 1086 if (render_image (transparent))
1434 background_flags = make_transparency_pixmap (); 1087 bg_flags |= BG_IS_VALID;
1435 if (background_flags == 0)
1436 return false;
1437 else if ((background_flags & transpTransformations) == (flags & transpTransformations))
1438 flags = flags & ~isInvalid;
1439 } 1088 }
1440# endif 1089# endif
1441 1090
1442# ifdef BG_IMAGE_FROM_FILE 1091 if (!(bg_flags & BG_IS_VALID))
1443 if (have_image
1444 || (background_flags & transpTransformations) != (flags & transpTransformations))
1445 {
1446 if (render_image (background_flags))
1447 flags = flags & ~isInvalid;
1448 } 1092 {
1449# endif 1093 if (bg_pixmap != None)
1450
1451# if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1452 XImage *result = NULL;
1453
1454 if (background_flags && (flags & isInvalid))
1455 {
1456 result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap);
1457 }
1458
1459 if (result)
1460 {
1461 /* our own client-side tinting */
1462 if (!(background_flags & transpPmapTinted) && (flags & tintNeeded))
1463 { 1094 {
1464 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 1095 XFreePixmap (dpy, bg_pixmap);
1465 if (flags & tintSet) 1096 bg_pixmap = None;
1466 tint.get (c);
1467 ShadeXImage (DefaultVisual (target->dpy, target->display->screen), result, shade, c);
1468 } 1097 }
1469
1470 GC gc = XCreateGC (target->dpy, target->vt, 0UL, NULL);
1471
1472 if (gc)
1473 {
1474 XPutImage (target->dpy, pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1475
1476 XFreeGC (target->dpy, gc);
1477 flags = flags & ~isInvalid;
1478 }
1479
1480 XDestroyImage (result);
1481 }
1482# endif
1483
1484 if (flags & isInvalid)
1485 { 1098 }
1486 if (pixmap != None)
1487 {
1488 XFreePixmap (target->dpy, pixmap);
1489 pixmap = None;
1490 }
1491 }
1492 1099
1493 apply (); 1100 scr_recolour (false);
1101 bg_flags |= BG_NEEDS_REFRESH;
1494 1102
1495 valid_since = ev::now (); 1103 bg_valid_since = ev::now ();
1496 1104
1497 return true; 1105 return true;
1498} 1106}
1499 1107
1500void 1108void
1501bgPixmap_t::set_target (rxvt_term *new_target) 1109rxvt_term::bg_init ()
1502{ 1110{
1503 target = new_target; 1111#ifdef ENABLE_TRANSPARENCY
1112 shade = 100;
1113#endif
1504 1114
1505 flags &= ~(HAS_RENDER | HAS_RENDER_CONV); 1115 bg_flags &= ~(BG_HAS_RENDER | BG_HAS_RENDER_CONV);
1506#if XRENDER 1116#if XRENDER
1507 int major, minor; 1117 int major, minor;
1508 if (XRenderQueryVersion (target->dpy, &major, &minor)) 1118 if (XRenderQueryVersion (dpy, &major, &minor))
1509 flags |= HAS_RENDER; 1119 bg_flags |= BG_HAS_RENDER;
1510 XFilters *filters = XRenderQueryFilters (target->dpy, target->vt); 1120 XFilters *filters = XRenderQueryFilters (dpy, vt);
1511 if (filters) 1121 if (filters)
1512 { 1122 {
1513 for (int i = 0; i < filters->nfilter; i++) 1123 for (int i = 0; i < filters->nfilter; i++)
1514 if (!strcmp (filters->filter[i], FilterConvolution)) 1124 if (!strcmp (filters->filter[i], FilterConvolution))
1515 flags |= HAS_RENDER_CONV; 1125 bg_flags |= BG_HAS_RENDER_CONV;
1516 1126
1517 XFree (filters); 1127 XFree (filters);
1518 } 1128 }
1519#endif 1129#endif
1520} 1130}
1521 1131
1132#endif /* HAVE_BG_PIXMAP */
1133
1134#ifdef ENABLE_TRANSPARENCY
1135/* based on code from aterm-0.4.2 */
1136
1137static inline void
1138fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
1139{
1140 for (int i = 0; i <= mask >> sh; i++)
1141 {
1142 uint32_t tmp;
1143 tmp = i * high;
1144 tmp += (mask >> sh) * low;
1145 lookup[i] = (tmp / 0xffff) << sh;
1146 }
1147}
1148
1522void 1149void
1523bgPixmap_t::apply () 1150rxvt_term::tint_ximage (Visual *visual, XImage *ximage)
1524{ 1151{
1525 if (target == NULL) 1152 unsigned int size_r, size_g, size_b;
1526 return;
1527
1528 if (pixmap != None)
1529 {
1530 /* set target's background to pixmap */
1531# ifdef ENABLE_TRANSPARENCY
1532 if (flags & isTransparent)
1533 {
1534 XSetWindowBackgroundPixmap (target->dpy, target->parent[0], pixmap);
1535 XSetWindowBackgroundPixmap (target->dpy, target->vt, ParentRelative);
1536
1537 if (target->scrollBar.win)
1538 XSetWindowBackgroundPixmap (target->dpy, target->scrollBar.win, ParentRelative);
1539 }
1540 else
1541# endif
1542 {
1543 /* force old pixmap dereference in case it was transparent before :*/
1544 XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
1545 XSetWindowBackgroundPixmap (target->dpy, target->vt, pixmap);
1546 /* do we also need to set scrollbar's background here ? */
1547
1548 if (target->scrollBar.win)
1549 XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);
1550 }
1551 }
1552 else
1553 {
1554 /* set target background to a pixel */
1555 XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
1556 XSetWindowBackground (target->dpy, target->vt, target->pix_colors[Color_bg]);
1557 /* do we also need to set scrollbar's background here ? */
1558 if (target->scrollBar.win)
1559 XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);
1560 }
1561
1562 /* don't want Expose on the parent or vt. It is better to use
1563 scr_touch or we get a great deal of flicker otherwise: */
1564 XClearWindow (target->dpy, target->parent[0]);
1565
1566 if (target->scrollBar.state && target->scrollBar.win)
1567 {
1568 target->scrollBar.state = STATE_IDLE;
1569 target->scrollBar.show (0);
1570 }
1571
1572 target->want_refresh = 1;
1573 flags |= hasChanged;
1574}
1575
1576#endif /* HAVE_BG_PIXMAP */
1577
1578#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1579/* taken from aterm-0.4.2 */
1580
1581static void
1582ShadeXImage(Visual *visual, XImage *srcImage, int shade, const rgba &c)
1583{
1584 int sh_r, sh_g, sh_b; 1153 int sh_r, sh_g, sh_b;
1585 uint32_t mask_r, mask_g, mask_b; 1154 uint32_t mask_r, mask_g, mask_b;
1586 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b; 1155 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1587 rgba low; 1156 unsigned short low;
1588 rgba high;
1589 int i;
1590 int host_byte_order = byteorder.big_endian () ? MSBFirst : LSBFirst; 1157 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1591 1158
1592 if (visual->c_class != TrueColor || srcImage->format != ZPixmap) return; 1159 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;
1593 1160
1594 /* for convenience */ 1161 /* for convenience */
1595 mask_r = visual->red_mask; 1162 mask_r = visual->red_mask;
1596 mask_g = visual->green_mask; 1163 mask_g = visual->green_mask;
1597 mask_b = visual->blue_mask; 1164 mask_b = visual->blue_mask;
1598 1165
1599 /* boring lookup table pre-initialization */ 1166 /* boring lookup table pre-initialization */
1600 switch (srcImage->depth) 1167 sh_r = ecb_ctz32 (mask_r);
1601 { 1168 sh_g = ecb_ctz32 (mask_g);
1602 case 15: 1169 sh_b = ecb_ctz32 (mask_b);
1603 if ((mask_r != 0x7c00) || 1170
1604 (mask_g != 0x03e0) || 1171 size_r = mask_r >> sh_r;
1605 (mask_b != 0x001f)) 1172 size_g = mask_g >> sh_g;
1173 size_b = mask_b >> sh_b;
1174
1175 if (size_r++ > 255 || size_g++ > 255 || size_b++ > 255)
1606 return; 1176 return;
1607 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+32+32)); 1177
1178 lookup = (uint32_t *)malloc (sizeof (uint32_t) * (size_r + size_g + size_b));
1608 lookup_r = lookup; 1179 lookup_r = lookup;
1609 lookup_g = lookup+32; 1180 lookup_g = lookup + size_r;
1610 lookup_b = lookup+32+32; 1181 lookup_b = lookup + size_r + size_g;
1611 sh_r = 10; 1182
1612 sh_g = 5; 1183 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1613 sh_b = 0; 1184
1614 break; 1185 if (bg_flags & BG_TINT_SET)
1615 case 16: 1186 tint.get (c);
1616 if ((mask_r != 0xf800) ||
1617 (mask_g != 0x07e0) ||
1618 (mask_b != 0x001f))
1619 return;
1620 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+64+32));
1621 lookup_r = lookup;
1622 lookup_g = lookup+32;
1623 lookup_b = lookup+32+64;
1624 sh_r = 11;
1625 sh_g = 5;
1626 sh_b = 0;
1627 break;
1628 case 24:
1629 if ((mask_r != 0xff0000) ||
1630 (mask_g != 0x00ff00) ||
1631 (mask_b != 0x0000ff))
1632 return;
1633 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(256+256+256));
1634 lookup_r = lookup;
1635 lookup_g = lookup+256;
1636 lookup_b = lookup+256+256;
1637 sh_r = 16;
1638 sh_g = 8;
1639 sh_b = 0;
1640 break;
1641 case 32:
1642 if ((mask_r != 0xff0000) ||
1643 (mask_g != 0x00ff00) ||
1644 (mask_b != 0x0000ff))
1645 return;
1646 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(256+256+256));
1647 lookup_r = lookup;
1648 lookup_g = lookup+256;
1649 lookup_b = lookup+256+256;
1650 sh_r = 16;
1651 sh_g = 8;
1652 sh_b = 0;
1653 break;
1654 default:
1655 return; /* we do not support this color depth */
1656 }
1657 1187
1658 /* prepare limits for color transformation (each channel is handled separately) */ 1188 /* prepare limits for color transformation (each channel is handled separately) */
1659 if (shade > 100) 1189 if (shade > 100)
1660 { 1190 {
1661 shade = 200 - shade; 1191 c.r = c.r * (200 - shade) / 100;
1192 c.g = c.g * (200 - shade) / 100;
1193 c.b = c.b * (200 - shade) / 100;
1662 1194
1663 high.r = (65535 - c.r) * shade / 100; 1195 low = 0xffff * (shade - 100) / 100;
1664 high.g = (65535 - c.g) * shade / 100;
1665 high.b = (65535 - c.b) * shade / 100;
1666
1667 low.r = 65535 - high.r;
1668 low.g = 65535 - high.g;
1669 low.b = 65535 - high.b;
1670 } 1196 }
1671 else 1197 else
1672 { 1198 {
1673 high.r = c.r * shade / 100; 1199 c.r = c.r * shade / 100;
1674 high.g = c.g * shade / 100; 1200 c.g = c.g * shade / 100;
1675 high.b = c.b * shade / 100; 1201 c.b = c.b * shade / 100;
1676 1202
1677 low.r = low.g = low.b = 0; 1203 low = 0;
1678 } 1204 }
1679 1205
1680 /* fill our lookup tables */ 1206 /* fill our lookup tables */
1681 for (i = 0; i <= mask_r>>sh_r; i++) 1207 fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1682 { 1208 fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1683 uint32_t tmp; 1209 fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1684 tmp = i * high.r;
1685 tmp += (mask_r>>sh_r) * low.r;
1686 lookup_r[i] = (tmp/65535)<<sh_r;
1687 }
1688 for (i = 0; i <= mask_g>>sh_g; i++)
1689 {
1690 uint32_t tmp;
1691 tmp = i * high.g;
1692 tmp += (mask_g>>sh_g) * low.g;
1693 lookup_g[i] = (tmp/65535)<<sh_g;
1694 }
1695 for (i = 0; i <= mask_b>>sh_b; i++)
1696 {
1697 uint32_t tmp;
1698 tmp = i * high.b;
1699 tmp += (mask_b>>sh_b) * low.b;
1700 lookup_b[i] = (tmp/65535)<<sh_b;
1701 }
1702 1210
1703 /* apply table to input image (replacing colors by newly calculated ones) */ 1211 /* apply table to input image (replacing colors by newly calculated ones) */
1704 if (srcImage->bits_per_pixel == 32 1212 if (ximage->bits_per_pixel == 32
1705 && (srcImage->depth == 24 || srcImage->depth == 32)
1706 && srcImage->byte_order == host_byte_order) 1213 && ximage->byte_order == host_byte_order)
1707 { 1214 {
1708 uint32_t *p1, *pf, *p, *pl; 1215 char *line = ximage->data;
1709 p1 = (uint32_t *) srcImage->data;
1710 pf = (uint32_t *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
1711 1216
1712 while (p1 < pf) 1217 for (int y = 0; y < ximage->height; y++)
1713 {
1714 p = p1;
1715 pl = p1 + srcImage->width;
1716 for (; p < pl; p++)
1717 { 1218 {
1718 *p = lookup_r[(*p & 0xff0000) >> 16] | 1219 uint32_t *p = (uint32_t *)line;
1719 lookup_g[(*p & 0x00ff00) >> 8] | 1220 for (int x = 0; x < ximage->width; x++)
1720 lookup_b[(*p & 0x0000ff)] |
1721 (*p & 0xff000000);
1722 } 1221 {
1723 p1 = (uint32_t *) ((char *) p1 + srcImage->bytes_per_line); 1222 *p = lookup_r[(*p & mask_r) >> sh_r] |
1223 lookup_g[(*p & mask_g) >> sh_g] |
1224 lookup_b[(*p & mask_b) >> sh_b];
1225 p++;
1226 }
1227 line += ximage->bytes_per_line;
1724 } 1228 }
1725 } 1229 }
1726 else 1230 else
1727 { 1231 {
1728 for (int y = 0; y < srcImage->height; y++) 1232 for (int y = 0; y < ximage->height; y++)
1729 for (int x = 0; x < srcImage->width; x++) 1233 for (int x = 0; x < ximage->width; x++)
1730 { 1234 {
1731 unsigned long pixel = XGetPixel (srcImage, x, y); 1235 unsigned long pixel = XGetPixel (ximage, x, y);
1732 pixel = lookup_r[(pixel & mask_r) >> sh_r] | 1236 pixel = lookup_r[(pixel & mask_r) >> sh_r] |
1733 lookup_g[(pixel & mask_g) >> sh_g] | 1237 lookup_g[(pixel & mask_g) >> sh_g] |
1734 lookup_b[(pixel & mask_b) >> sh_b]; 1238 lookup_b[(pixel & mask_b) >> sh_b];
1735 XPutPixel (srcImage, x, y, pixel); 1239 XPutPixel (ximage, x, y, pixel);
1736 } 1240 }
1737 } 1241 }
1738 1242
1739 free (lookup); 1243 free (lookup);
1740} 1244}
1741#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */ 1245#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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