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.148 by root, Tue Apr 26 09:48:09 2011 UTC vs.
Revision 1.234 by sf-exg, Thu Jun 7 09:21:18 2012 UTC

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

Diff Legend

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