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

Diff Legend

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