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

Diff Legend

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