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.132 by sf-exg, Mon Jan 10 20:46:20 2011 UTC vs.
Revision 1.213 by sf-exg, Sun May 13 21:12:01 2012 UTC

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

Diff Legend

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