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.145 by sf-exg, Fri Jan 28 00:21:10 2011 UTC vs.
Revision 1.222 by sf-exg, Sat May 26 08:10:25 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 (!(flags & IM_TILE)
309 || h_scale || v_scale
310 || (!(flags & IM_ROOT_ALIGN) && (h_align || v_align)))
311 flags |= IM_IS_SIZE_SENSITIVE;
312 else
313 flags &= ~IM_IS_SIZE_SENSITIVE;
314
321 return changed; 315 return changed;
322} 316}
323 317
324void 318void
325rxvt_term::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y) 319rxvt_term::get_image_geometry (rxvt_image &image, int &w, int &h, int &x, int &y)
326{ 320{
321 int image_width = image.width ();
322 int image_height = image.height ();
327 int target_width = szHint.width; 323 int target_width = szHint.width;
328 int target_height = szHint.height; 324 int target_height = szHint.height;
325 int h_scale = min (image.h_scale, 32767 * 100 / target_width);
326 int v_scale = min (image.v_scale, 32767 * 100 / target_height);
329 327
330 if (bg_flags & BG_PROP_SCALE) 328 w = h_scale * target_width / 100;
329 h = v_scale * target_height / 100;
330
331 if (image.flags & IM_KEEP_ASPECT)
331 { 332 {
332 float scale = (float)target_width / image_width; 333 float scale = (float)w / image_width;
333 min_it (scale, (float)target_height / image_height); 334 min_it (scale, (float)h / image_height);
334 w = image_width * scale + 0.5; 335 w = image_width * scale + 0.5;
335 h = image_height * scale + 0.5; 336 h = image_height * scale + 0.5;
336 } 337 }
337 else
338 {
339 w = h_scale * target_width / 100;
340 h = v_scale * target_height / 100;
341 }
342 338
343 if (!w) w = image_width; 339 if (!w) w = image_width;
344 if (!h) h = image_height; 340 if (!h) h = image_height;
345 341
346 if (bg_flags & BG_ROOT_ALIGN) 342 if (image.flags & IM_ROOT_ALIGN)
347 { 343 {
348 x = -target_x; 344 x = -target_x;
349 y = -target_y; 345 y = -target_y;
350 } 346 }
351 else 347 else
352 { 348 {
353 x = make_align_position (h_align, target_width, w); 349 x = make_align_position (image.h_align, target_width, w);
354 y = make_align_position (v_align, target_height, h); 350 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 { 351 }
379 ShadingInfo as_shade; 352}
380 as_shade.shading = shade;
381 353
382 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 354# ifdef HAVE_PIXBUF
383 if (bg_flags & BG_TINT_SET) 355bool
384 tint.get (c); 356rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
385 as_shade.tintColor.red = c.r; 357 int src_x, int src_y, int dst_x, int dst_y,
386 as_shade.tintColor.green = c.g; 358 unsigned int width, unsigned int height, bool argb)
387 as_shade.tintColor.blue = c.b; 359{
360 XImage *ximage;
361 char *line;
362 int width_r, width_g, width_b, width_a;
363 int sh_r, sh_g, sh_b, sh_a;
364 uint32_t red_mask, green_mask, blue_mask, alpha_mask;
365 int rowstride;
366 int channels;
367 unsigned char *row;
388 368
389 background_tint = shading2tint32 (&as_shade); 369 if (visual->c_class != TrueColor)
370 return false;
371
372 if (argb)
390 } 373 {
391 374 red_mask = 0xff << 16;
392 if ((tr_flags & BG_NEEDS_BLUR) && background != NULL) 375 green_mask = 0xff << 8;
376 blue_mask = 0xff;
377 alpha_mask = 0xff << 24;
393 { 378 }
394 ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF, 379 else
395 (original_asim == NULL || tint == TINT_LEAVE_SAME) ? ASA_XImage : ASA_ASImage, 380 {
396 100, ASIMAGE_QUALITY_DEFAULT); 381 red_mask = visual->red_mask;
382 green_mask = visual->green_mask;
383 blue_mask = visual->blue_mask;
384#if XRENDER
385 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
397 if (tmp) 386 if (format)
387 alpha_mask = (uint32_t)format->direct.alphaMask << format->direct.alpha;
388 else
389#endif
390 alpha_mask = 0;
391 }
392
393 width_r = ecb_popcount32 (red_mask);
394 width_g = ecb_popcount32 (green_mask);
395 width_b = ecb_popcount32 (blue_mask);
396 width_a = ecb_popcount32 (alpha_mask);
397
398 if (width_r > 8 || width_g > 8 || width_b > 8 || width_a > 8)
399 return false;
400
401 sh_r = ecb_ctz32 (red_mask);
402 sh_g = ecb_ctz32 (green_mask);
403 sh_b = ecb_ctz32 (blue_mask);
404 sh_a = ecb_ctz32 (alpha_mask);
405
406 if (width > 32767 || height > 32767)
407 return false;
408
409 ximage = XCreateImage (dpy, visual, argb ? 32 : depth, ZPixmap, 0, 0,
410 width, height, 32, 0);
411 if (!ximage)
412 return false;
413
414 if (height > INT_MAX / ximage->bytes_per_line
415 || !(ximage->data = (char *)malloc (height * ximage->bytes_per_line)))
416 {
417 XDestroyImage (ximage);
418 return false;
419 }
420
421 ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
422
423 rowstride = gdk_pixbuf_get_rowstride (pixbuf);
424 channels = gdk_pixbuf_get_n_channels (pixbuf);
425 row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels;
426 line = ximage->data;
427
428 rgba c (0, 0, 0);
429
430 if (channels == 4 && alpha_mask == 0)
431 {
432 pix_colors[Color_bg].get (c);
433 c.r >>= 8;
434 c.g >>= 8;
435 c.b >>= 8;
436 }
437
438 for (int y = 0; y < height; y++)
439 {
440 for (int x = 0; x < width; x++)
441 {
442 unsigned char *pixel = row + x * channels;
443 uint32_t value;
444 unsigned char r, g, b, a;
445
446 if (channels == 4)
398 { 447 {
399 destroy_asimage (&background); 448 a = pixel[3];
400 background = tmp; 449 r = (pixel[0] * a + c.r * (0xff - a)) / 0xff;
450 g = (pixel[1] * a + c.g * (0xff - a)) / 0xff;
451 b = (pixel[2] * a + c.b * (0xff - a)) / 0xff;
452 }
453 else
454 {
455 a = 0xff;
456 r = pixel[0];
457 g = pixel[1];
458 b = pixel[2];
459 }
460
461 value = ((r >> (8 - width_r)) << sh_r)
462 | ((g >> (8 - width_g)) << sh_g)
463 | ((b >> (8 - width_b)) << sh_b)
464 | ((a >> (8 - width_a)) << sh_a);
465
466 if (ximage->bits_per_pixel == 32)
467 ((uint32_t *)line)[x] = value;
468 else
469 XPutPixel (ximage, x, y, value);
401 } 470 }
402 }
403# endif
404 471
405 ASImage *result = 0; 472 row += rowstride;
473 line += ximage->bytes_per_line;
474 }
475
476 XPutImage (dpy, pixmap, gc, ximage, 0, 0, dst_x, dst_y, width, height);
477 XDestroyImage (ximage);
478 return true;
479}
480
481bool
482rxvt_term::render_image (rxvt_image &image)
483{
484 GdkPixbuf *pixbuf = image.pixbuf;
485 if (!pixbuf)
486 return false;
487
488 bool need_blend = bg_flags & BG_IS_VALID;
489
490 if (need_blend
491 && !(bg_flags & BG_HAS_RENDER))
492 return false;
493
494 GdkPixbuf *result;
495
496 int image_width = gdk_pixbuf_get_width (pixbuf);
497 int image_height = gdk_pixbuf_get_height (pixbuf);
406 498
407 int target_width = szHint.width; 499 int target_width = szHint.width;
408 int target_height = szHint.height; 500 int target_height = szHint.height;
409 int new_pmap_width = target_width; 501 int new_pmap_width = target_width;
410 int new_pmap_height = target_height; 502 int new_pmap_height = target_height;
… …
412 int x = 0; 504 int x = 0;
413 int y = 0; 505 int y = 0;
414 int w = 0; 506 int w = 0;
415 int h = 0; 507 int h = 0;
416 508
417 if (original_asim) 509 get_image_geometry (image, w, h, x, y);
418 get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
419 510
420 if (!original_asim 511 if (!(image.flags & IM_ROOT_ALIGN)
421 || (!(bg_flags & BG_ROOT_ALIGN)
422 && (x >= target_width 512 && (x >= target_width
423 || y >= target_height 513 || y >= target_height
424 || (x + w <= 0) 514 || x + w <= 0
425 || (y + h <= 0)))) 515 || y + h <= 0))
516 return false;
517
518 result = pixbuf;
519
520 if (w != image_width
521 || h != image_height)
522 {
523 result = gdk_pixbuf_scale_simple (pixbuf,
524 w, h,
525 GDK_INTERP_BILINEAR);
426 { 526 }
427 if (background)
428 {
429 new_pmap_width = background->width;
430 new_pmap_height = background->height;
431 result = background;
432 527
433 if (background_tint != TINT_LEAVE_SAME) 528 if (!result)
529 return false;
530
531 bool ret = false;
532
533 XGCValues gcv;
534 GC gc;
535 Pixmap tmp_pixmap;
536
537 image_width = gdk_pixbuf_get_width (result);
538 image_height = gdk_pixbuf_get_height (result);
539
540 if (need_blend)
541 tmp_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, 32);
542 else
543 {
544 // optimise bg pixmap size when tiling, but only if there are no
545 // other pixbufs to render. Otherwise, the bg pixmap size must
546 // be equal to the window size.
547 if ((image.flags & IM_TILE)
548 && image_vec.size () == 1)
434 { 549 {
435 ASImage *tmp = tile_asimage (asv, background, 0, 0, 550 new_pmap_width = min (image_width, target_width);
436 target_width, target_height, background_tint, 551 new_pmap_height = min (image_height, target_height);
437 ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
438 if (tmp)
439 result = tmp;
440 }
441 } 552 }
442 else
443 new_pmap_width = new_pmap_height = 0;
444 }
445 else
446 {
447 result = original_asim;
448 553
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 554 if (bg_pixmap == None
552 || bg_pmap_width != new_pmap_width 555 || bg_pmap_width != new_pmap_width
553 || bg_pmap_height != new_pmap_height) 556 || bg_pmap_height != new_pmap_height)
554 { 557 {
555 if (bg_pixmap) 558 if (bg_pixmap)
556 XFreePixmap (dpy, bg_pixmap); 559 XFreePixmap (dpy, bg_pixmap);
557 bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth); 560 bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
558 bg_pmap_width = new_pmap_width; 561 bg_pmap_width = new_pmap_width;
559 bg_pmap_height = new_pmap_height; 562 bg_pmap_height = new_pmap_height;
560 } 563 }
561 /* fill with background color (if result's not completely overlapping it) */ 564
565 tmp_pixmap = bg_pixmap;
566 }
567
562 gcv.foreground = pix_colors[Color_bg]; 568 gcv.foreground = pix_colors[Color_bg];
563 gc = XCreateGC (dpy, vt, GCForeground, &gcv); 569 gc = XCreateGC (dpy, tmp_pixmap, GCForeground, &gcv);
564 570
565 int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0; 571 if (gc)
566 int dst_width = result->width, dst_height = result->height; 572 {
567 if (background == NULL) 573 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 } 574 {
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); 575 Pixmap tile = XCreatePixmap (dpy, vt, image_width, image_height, need_blend ? 32 : depth);
770 pixbuf_to_pixmap (result, tile, gc, 576 pixbuf_to_pixmap (result, tile, gc,
771 0, 0, 577 0, 0,
772 0, 0, 578 0, 0,
773 image_width, image_height); 579 image_width, image_height, need_blend);
774 580
775 gcv.tile = tile; 581 gcv.tile = tile;
776 gcv.fill_style = FillTiled; 582 gcv.fill_style = FillTiled;
777 gcv.ts_x_origin = x; 583 gcv.ts_x_origin = x;
778 gcv.ts_y_origin = y; 584 gcv.ts_y_origin = y;
779 XChangeGC (dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); 585 XChangeGC (dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
780 586
781 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height); 587 XFillRectangle (dpy, tmp_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
782 XFreePixmap (dpy, tile); 588 XFreePixmap (dpy, tile);
783 } 589 }
784 else 590 else
785 { 591 {
786 int src_x, src_y, dst_x, dst_y; 592 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); 596 src_y = make_clip_rectangle (y, image_height, new_pmap_height, dst_y, dst_height);
791 597
792 if (dst_x > 0 || dst_y > 0 598 if (dst_x > 0 || dst_y > 0
793 || dst_x + dst_width < new_pmap_width 599 || dst_x + dst_width < new_pmap_width
794 || dst_y + dst_height < new_pmap_height) 600 || dst_y + dst_height < new_pmap_height)
795 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height); 601 XFillRectangle (dpy, tmp_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
796 602
797 if (dst_x < new_pmap_width && dst_y < new_pmap_height) 603 if (dst_x < new_pmap_width && dst_y < new_pmap_height)
798 pixbuf_to_pixmap (result, bg_pixmap, gc, 604 pixbuf_to_pixmap (result, tmp_pixmap, gc,
799 src_x, src_y, 605 src_x, src_y,
800 dst_x, dst_y, 606 dst_x, dst_y,
801 dst_width, dst_height); 607 dst_width, dst_height, need_blend);
802 } 608 }
803 609
804#if XRENDER 610#if XRENDER
805 if (tr_flags) 611 if (need_blend)
806 { 612 {
807 XRenderPictureAttributes pa; 613 XRenderPictFormat *argb_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
808
809 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, visual); 614 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
615
810 Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa); 616 Picture src = XRenderCreatePicture (dpy, tmp_pixmap, argb_format, 0, 0);
811 617
812 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
813 Picture dst = XRenderCreatePicture (dpy, bg_pixmap, dst_format, 0, &pa); 618 Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
814 619
815 pa.repeat = True; 620 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 621
821 if (src && dst && mask)
822 {
823 XRenderColor mask_c; 622 XRenderColor mask_c;
824 623
825 mask_c.alpha = 0x8000; 624 mask_c.alpha = gdk_pixbuf_get_has_alpha (image.pixbuf) ? 0xffff : image.alpha;
826 mask_c.red = 0; 625 mask_c.red =
827 mask_c.green = 0; 626 mask_c.green =
828 mask_c.blue = 0; 627 mask_c.blue = 0;
829 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1); 628 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
629
830 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height); 630 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
831 }
832 631
833 XRenderFreePicture (dpy, src); 632 XRenderFreePicture (dpy, src);
834 XRenderFreePicture (dpy, dst); 633 XRenderFreePicture (dpy, dst);
835 XRenderFreePicture (dpy, mask); 634 XRenderFreePicture (dpy, mask);
836
837 XFreePixmap (dpy, root_pmap);
838 } 635 }
839#endif 636#endif
840 637
841 if (result != pixbuf)
842 g_object_unref (result);
843
844 XFreeGC (dpy, gc); 638 XFreeGC (dpy, gc);
845 639
846 ret = true; 640 ret = true;
847 } 641 }
848 642
643 if (result != pixbuf)
644 g_object_unref (result);
645
646 if (need_blend)
647 XFreePixmap (dpy, tmp_pixmap);
648
849 return ret; 649 return ret;
850} 650}
851# endif /* HAVE_PIXBUF */ 651# endif /* HAVE_PIXBUF */
852 652
653# ifndef NO_RESOURCES
654static int
655rxvt_define_image (XrmDatabase *database ecb_unused,
656 XrmBindingList bindings ecb_unused,
657 XrmQuarkList quarks,
658 XrmRepresentation *type ecb_unused,
659 XrmValue *value,
660 XPointer closure ecb_unused)
661{
662 int size;
663
664 for (size = 0; quarks[size] != NULLQUARK; size++)
665 ;
666
667 if (size >= 2)
668 {
669 int id = strtol (XrmQuarkToString (quarks[size-2]), 0, 0);
670 if (id >= 1)
671 GET_R->parse_image (id, XrmQuarkToString (quarks[size-1]), (char *)value->addr);
672 }
673 return False;
674}
675
676void
677rxvt_term::parse_image (int id, const char *type, const char *arg)
678{
679 if (image_vec.size () < id + 1)
680 image_vec.resize (id + 1);
681
682 rxvt_image *image = &image_vec[id];
683}
684# endif
685
686rxvt_image::rxvt_image ()
687{
688 alpha =
689 flags =
690 h_scale =
691 v_scale =
692 h_align =
693 v_align = 0;
694
695# ifdef HAVE_PIXBUF
696 pixbuf = 0;
697# endif
698}
699
853bool 700bool
854rxvt_term::bg_set_file (const char *file) 701rxvt_image::set_file_geometry (const char *file)
855{ 702{
856 if (!file || !*file) 703 if (!file || !*file)
857 return false; 704 return false;
858 705
859 if (const char *p = strchr (file, ';')) 706 const char *p = strchr (file, ';');
707
708 if (p)
860 { 709 {
861 size_t len = p - file; 710 size_t len = p - file;
862 char *f = rxvt_temp_buf<char> (len + 1); 711 char *f = rxvt_temp_buf<char> (len + 1);
863 memcpy (f, file, len); 712 memcpy (f, file, len);
864 f[len] = '\0'; 713 f[len] = '\0';
865 file = f; 714 file = f;
866 } 715 }
867 716
868# ifdef HAVE_AFTERIMAGE 717 bool ret = set_file (file);
869 if (!asimman) 718 alpha = 0x8000;
870 asimman = create_generic_imageman (rs[Rs_path]); 719 if (ret && p)
871 ASImage *image = get_asimage (asimman, file, 0xFFFFFFFF, 100); 720 set_geometry (p + 1);
872 if (image) 721 return ret;
873 { 722}
874 if (original_asim) 723
875 safe_asimage_destroy (original_asim); 724bool
876 original_asim = image; 725rxvt_image::set_file (const char *file)
877 bg_flags |= BG_IS_FROM_FILE | BG_CLIENT_RENDER; 726{
878 return true; 727 bool ret = false;
879 }
880# endif
881 728
882# ifdef HAVE_PIXBUF 729# ifdef HAVE_PIXBUF
883 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL); 730 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
884 if (image) 731 if (image)
885 { 732 {
886 if (pixbuf) 733 if (pixbuf)
887 g_object_unref (pixbuf); 734 g_object_unref (pixbuf);
888 pixbuf = image; 735 pixbuf = image;
889 bg_flags |= BG_IS_FROM_FILE;
890 return true; 736 ret = true;
891 } 737 }
892# endif 738# endif
893 739
740 if (ret)
741 {
742 alpha = 0xffff;
743 flags = IM_IS_SET | IM_IS_SIZE_SENSITIVE;
744 h_scale = v_scale = defaultScale;
745 h_align = v_align = defaultAlign;
746 }
747
894 return false; 748 return ret;
895} 749}
896 750
897# endif /* BG_IMAGE_FROM_FILE */ 751# endif /* BG_IMAGE_FROM_FILE */
898 752
899# ifdef ENABLE_TRANSPARENCY 753# ifdef ENABLE_TRANSPARENCY
900bool
901rxvt_term::bg_set_transparent ()
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 754bool
913rxvt_term::bg_set_blur (const char *geom) 755rxvt_term::bg_set_blur (const char *geom)
914{ 756{
915 bool changed = false; 757 bool changed = false;
916 unsigned int hr, vr; 758 unsigned int hr, vr;
… …
935 { 777 {
936 changed = true; 778 changed = true;
937 v_blurRadius = vr; 779 v_blurRadius = vr;
938 } 780 }
939 781
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; 782 return changed;
946} 783}
947 784
948static inline unsigned long 785bool
949compute_tint_shade_flags (rxvt_color *tint, int shade) 786rxvt_term::bg_set_tint (rxvt_color &new_tint)
950{ 787{
951 unsigned long flags = 0; 788 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
952 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
953 bool has_shade = shade != 100;
954
955 if (tint)
956 { 789 {
790 tint = new_tint;
791 bg_flags |= BG_TINT_SET;
792
793 rgba c;
957 tint->get (c); 794 tint.get (c);
958 if (!has_shade
959 && (c.r <= 0x00ff || c.r >= 0xff00) 795 if ((c.r <= 0x00ff || c.r >= 0xff00)
960 && (c.g <= 0x00ff || c.g >= 0xff00) 796 && (c.g <= 0x00ff || c.g >= 0xff00)
961 && (c.b <= 0x00ff || c.b >= 0xff00)) 797 && (c.b <= 0x00ff || c.b >= 0xff00))
962 flags |= rxvt_term::BG_TINT_BITAND; 798 bg_flags |= BG_TINT_BITAND;
963 } 799 else
800 bg_flags &= ~BG_TINT_BITAND;
964 801
965 if (has_shade || tint)
966 flags |= rxvt_term::BG_NEEDS_TINT;
967
968 return flags;
969}
970
971bool
972rxvt_term::bg_set_tint (rxvt_color &new_tint)
973{
974 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
975 {
976 unsigned long new_flags = compute_tint_shade_flags (&new_tint, shade);
977 tint = new_tint;
978 bg_flags = (bg_flags & ~BG_TINT_FLAGS) | new_flags | BG_TINT_SET;
979 return true; 802 return true;
980 } 803 }
981 804
982 return false; 805 return false;
983} 806}
984 807
985bool 808bool
986rxvt_term::bg_set_shade (const char *shade_str) 809rxvt_term::bg_set_shade (const char *shade_str)
987{ 810{
988 int new_shade = (shade_str) ? atoi (shade_str) : 100; 811 int new_shade = atoi (shade_str);
989 812
990 clamp_it (new_shade, -100, 200); 813 clamp_it (new_shade, -100, 200);
991 if (new_shade < 0) 814 if (new_shade < 0)
992 new_shade = 200 - (100 + new_shade); 815 new_shade = 200 - (100 + new_shade);
993 816
994 if (new_shade != shade) 817 if (new_shade != shade)
995 { 818 {
996 unsigned long new_flags = compute_tint_shade_flags ((bg_flags & BG_TINT_SET) ? &tint : NULL, new_shade);
997 shade = new_shade; 819 shade = new_shade;
998 bg_flags = (bg_flags & ~BG_TINT_FLAGS) | new_flags;
999 return true; 820 return true;
1000 } 821 }
1001 822
1002 return false; 823 return false;
1003} 824}
… …
1024 params[i+2] = XDoubleToFixed (kernel[i] / sum); 845 params[i+2] = XDoubleToFixed (kernel[i] / sum);
1025} 846}
1026#endif 847#endif
1027 848
1028bool 849bool
1029rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 850rxvt_term::blur_pixmap (Pixmap pixmap, int width, int height)
1030{ 851{
1031 bool ret = false; 852 bool ret = false;
1032#if XRENDER 853#if XRENDER
854 if (!(bg_flags & BG_HAS_RENDER_CONV))
855 return false;
856
1033 int size = max (h_blurRadius, v_blurRadius) * 2 + 1; 857 int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1034 double *kernel = (double *)malloc (size * sizeof (double)); 858 double *kernel = (double *)malloc (size * sizeof (double));
1035 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 859 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1036 860
1037 XRenderPictureAttributes pa; 861 XRenderPictureAttributes pa;
1038 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 862 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1039 863
864 pa.repeat = RepeatPad;
1040 Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 865 Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
866 Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1041 Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 867 Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
868 XFreePixmap (dpy, tmp);
1042 869
1043 if (kernel && params && src && dst) 870 if (kernel && params)
1044 { 871 {
1045 if (h_blurRadius)
1046 {
1047 size = h_blurRadius * 2 + 1; 872 size = h_blurRadius * 2 + 1;
1048 get_gaussian_kernel (h_blurRadius, size, kernel, params); 873 get_gaussian_kernel (h_blurRadius, size, kernel, params);
1049 874
1050 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 875 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1051 XRenderComposite (dpy, 876 XRenderComposite (dpy,
1052 PictOpSrc, 877 PictOpSrc,
1053 src, 878 src,
1054 None, 879 None,
1055 dst, 880 dst,
1056 0, 0, 881 0, 0,
1057 0, 0, 882 0, 0,
1058 0, 0, 883 0, 0,
1059 width, height); 884 width, height);
1060 }
1061 885
1062 if (v_blurRadius) 886 ::swap (src, dst);
1063 { 887
1064 size = v_blurRadius * 2 + 1; 888 size = v_blurRadius * 2 + 1;
1065 get_gaussian_kernel (v_blurRadius, size, kernel, params); 889 get_gaussian_kernel (v_blurRadius, size, kernel, params);
1066 ::swap (params[0], params[1]); 890 ::swap (params[0], params[1]);
1067 891
1068 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 892 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1069 XRenderComposite (dpy, 893 XRenderComposite (dpy,
1070 PictOpSrc, 894 PictOpSrc,
1071 src, 895 src,
1072 None, 896 None,
1073 dst, 897 dst,
1074 0, 0, 898 0, 0,
1075 0, 0, 899 0, 0,
1076 0, 0, 900 0, 0,
1077 width, height); 901 width, height);
1078 }
1079 902
1080 ret = true; 903 ret = true;
1081 } 904 }
1082 905
1083 free (kernel); 906 free (kernel);
… …
1087#endif 910#endif
1088 return ret; 911 return ret;
1089} 912}
1090 913
1091bool 914bool
1092rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 915rxvt_term::tint_pixmap (Pixmap pixmap, int width, int height)
1093{ 916{
1094 bool ret = false; 917 bool ret = false;
1095 918
1096 if (bg_flags & BG_TINT_BITAND) 919 if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1097 { 920 {
1098 XGCValues gcv; 921 XGCValues gcv;
1099 GC gc; 922 GC gc;
1100 923
1101 /* In this case we can tint image server-side getting significant 924 /* In this case we can tint image server-side getting significant
… …
1110 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height); 933 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1111 ret = true; 934 ret = true;
1112 XFreeGC (dpy, gc); 935 XFreeGC (dpy, gc);
1113 } 936 }
1114 } 937 }
1115 else
1116 {
1117# if XRENDER 938# if XRENDER
939 else if (bg_flags & BG_HAS_RENDER)
940 {
1118 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 941 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1119 942
1120 if (bg_flags & BG_TINT_SET) 943 if (bg_flags & BG_TINT_SET)
1121 tint.get (c); 944 tint.get (c);
1122 945
1123 if (shade <= 100) 946 if (shade <= 100)
1124 { 947 {
1125 c.r = (c.r * shade) / 100; 948 c.r = c.r * shade / 100;
1126 c.g = (c.g * shade) / 100; 949 c.g = c.g * shade / 100;
1127 c.b = (c.b * shade) / 100; 950 c.b = c.b * shade / 100;
1128 } 951 }
1129 else 952 else
1130 { 953 {
1131 c.r = (c.r * (200 - shade)) / 100; 954 c.r = c.r * (200 - shade) / 100;
1132 c.g = (c.g * (200 - shade)) / 100; 955 c.g = c.g * (200 - shade) / 100;
1133 c.b = (c.b * (200 - shade)) / 100; 956 c.b = c.b * (200 - shade) / 100;
1134 } 957 }
1135 958
1136 XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1137 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 959 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1138 XRenderPictureAttributes pa;
1139 960
1140 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 961 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1141 962
1142 pa.repeat = True; 963 Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1143 964
1144 Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32); 965 Picture mask_pic = create_xrender_mask (dpy, pixmap, True, True);
1145 Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1146 XFreePixmap (dpy, overlay_pmap);
1147 966
1148 pa.component_alpha = True;
1149 Pixmap mask_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
1150 Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat|CPComponentAlpha, &pa);
1151 XFreePixmap (dpy, mask_pmap);
1152
1153 if (mask_pic && overlay_pic && back_pic)
1154 {
1155 XRenderColor mask_c; 967 XRenderColor mask_c;
1156 968
1157 mask_c.red = mask_c.green = mask_c.blue = 0;
1158 mask_c.alpha = 0xffff; 969 mask_c.alpha = 0xffff;
970 mask_c.red =
971 mask_c.green =
972 mask_c.blue = 0;
973 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
974
975 mask_c.alpha = 0;
976 mask_c.red = 0xffff - c.r;
977 mask_c.green = 0xffff - c.g;
978 mask_c.blue = 0xffff - c.b;
979 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
980
981 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
982
983 if (shade > 100)
984 {
985 mask_c.alpha = 0;
986 mask_c.red =
987 mask_c.green =
988 mask_c.blue = 0xffff * (shade - 100) / 100;
1159 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1); 989 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1160 990
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); 991 XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1175 }
1176
1177 ret = true;
1178 } 992 }
993
994 ret = true;
1179 995
1180 XRenderFreePicture (dpy, mask_pic); 996 XRenderFreePicture (dpy, mask_pic);
1181 XRenderFreePicture (dpy, overlay_pic); 997 XRenderFreePicture (dpy, overlay_pic);
1182 XRenderFreePicture (dpy, back_pic); 998 XRenderFreePicture (dpy, back_pic);
999 }
1183# endif 1000# endif
1184 }
1185 1001
1186 return ret; 1002 return ret;
1187} 1003}
1188 1004
1189/* make_transparency_pixmap() 1005/*
1190 * Builds a pixmap of the same size as the terminal window that contains 1006 * 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 1007 * the tiled portion of the root pixmap that is supposed to be covered by
1192 * our window. 1008 * our window.
1193 */ 1009 */
1194unsigned long 1010bool
1195rxvt_term::make_transparency_pixmap () 1011rxvt_term::make_transparency_pixmap ()
1196{ 1012{
1197 unsigned long result = 0; 1013 bool ret = false;
1198 1014
1199 /* root dimensions may change from call to call - but Display structure should 1015 /* root dimensions may change from call to call - but Display structure should
1200 * be always up-to-date, so let's use it : 1016 * be always up-to-date, so let's use it :
1201 */ 1017 */
1202 int screen = display->screen; 1018 int screen = display->screen;
… …
1238 if (root_pixmap != None && root_depth != depth) 1054 if (root_pixmap != None && root_depth != depth)
1239 { 1055 {
1240#if XRENDER 1056#if XRENDER
1241 if (bg_flags & BG_HAS_RENDER) 1057 if (bg_flags & BG_HAS_RENDER)
1242 { 1058 {
1243 XRenderPictureAttributes pa; 1059 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1244 1060
1245 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen)); 1061 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1246 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa); 1062 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1247 1063
1248 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1249 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual); 1064 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1250 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa); 1065 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1251 1066
1252 if (src && dst)
1253 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height); 1067 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 1068
1260 XRenderFreePicture (dpy, src); 1069 XRenderFreePicture (dpy, src);
1261 XRenderFreePicture (dpy, dst); 1070 XRenderFreePicture (dpy, dst);
1262 } 1071 }
1263 else 1072 else
1264#endif 1073#endif
1265 root_pixmap = None; 1074 recoded_root_pmap = None;
1266 } 1075 }
1267 1076
1268 if (root_pixmap == None) 1077 if (recoded_root_pmap == None)
1269 return 0; 1078 return 0;
1270 1079
1271 if (bg_pixmap == None 1080 if (bg_pixmap == None
1272 || bg_pmap_width != window_width 1081 || bg_pmap_width != window_width
1273 || bg_pmap_height != window_height) 1082 || bg_pmap_height != window_height)
… …
1277 bg_pixmap = XCreatePixmap (dpy, vt, window_width, window_height, depth); 1086 bg_pixmap = XCreatePixmap (dpy, vt, window_width, window_height, depth);
1278 bg_pmap_width = window_width; 1087 bg_pmap_width = window_width;
1279 bg_pmap_height = window_height; 1088 bg_pmap_height = window_height;
1280 } 1089 }
1281 1090
1282 if (bg_pixmap == None)
1283 return 0;
1284
1285 /* straightforward pixmap copy */ 1091 /* straightforward pixmap copy */
1286 while (sx < 0) sx += (int)root_width; 1092 while (sx < 0) sx += root_pmap_width;
1287 while (sy < 0) sy += (int)root_height; 1093 while (sy < 0) sy += root_pmap_height;
1288 1094
1289 gcv.tile = recoded_root_pmap; 1095 gcv.tile = recoded_root_pmap;
1290 gcv.fill_style = FillTiled; 1096 gcv.fill_style = FillTiled;
1291 gcv.ts_x_origin = -sx; 1097 gcv.ts_x_origin = -sx;
1292 gcv.ts_y_origin = -sy; 1098 gcv.ts_y_origin = -sy;
1293 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); 1099 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1294 1100
1295 if (gc) 1101 if (gc)
1296 { 1102 {
1297 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height); 1103 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1298 result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS); 1104 ret = true;
1299 XFreeGC (dpy, gc); 1105 bool need_blur = h_blurRadius && v_blurRadius;
1106 bool need_tint = shade != 100 || (bg_flags & BG_TINT_SET);
1300 1107
1301 if (!(bg_flags & BG_CLIENT_RENDER)) 1108 if (!(bg_flags & BG_CLIENT_RENDER))
1302 { 1109 {
1303 if ((bg_flags & BG_NEEDS_BLUR) 1110 if (need_blur)
1304 && (bg_flags & BG_HAS_RENDER_CONV))
1305 { 1111 {
1306 if (blur_pixmap (bg_pixmap, visual, window_width, window_height)) 1112 if (blur_pixmap (bg_pixmap, window_width, window_height))
1307 result &= ~BG_NEEDS_BLUR; 1113 need_blur = false;
1308 } 1114 }
1309 if ((bg_flags & BG_NEEDS_TINT) 1115 if (need_tint)
1310 && (bg_flags & (BG_TINT_BITAND | BG_HAS_RENDER)))
1311 { 1116 {
1312 if (tint_pixmap (bg_pixmap, visual, window_width, window_height)) 1117 if (tint_pixmap (bg_pixmap, window_width, window_height))
1313 result &= ~BG_NEEDS_TINT; 1118 need_tint = false;
1119 }
1120 if (need_tint)
1121 {
1122 XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1123 if (ximage)
1124 {
1125 /* our own client-side tinting */
1126 tint_ximage (ximage);
1127
1128 XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
1129 XDestroyImage (ximage);
1130 }
1314 } 1131 }
1315 } /* server side rendering completed */ 1132 } /* server side rendering completed */
1133
1134 XFreeGC (dpy, gc);
1316 } 1135 }
1317 1136
1318 if (recoded_root_pmap != root_pixmap) 1137 if (recoded_root_pmap != root_pixmap)
1319 XFreePixmap (dpy, recoded_root_pmap); 1138 XFreePixmap (dpy, recoded_root_pmap);
1320 1139
1321 return result; 1140 return ret;
1322} 1141}
1323 1142
1324void 1143void
1325rxvt_term::bg_set_root_pixmap () 1144rxvt_term::bg_set_root_pixmap ()
1326{ 1145{
… …
1330 1149
1331 root_pixmap = new_root_pixmap; 1150 root_pixmap = new_root_pixmap;
1332} 1151}
1333# endif /* ENABLE_TRANSPARENCY */ 1152# endif /* ENABLE_TRANSPARENCY */
1334 1153
1335#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1336static void shade_ximage (Visual *visual, XImage *ximage, int shade, const rgba &c);
1337# endif
1338
1339bool 1154bool
1340rxvt_term::bg_render () 1155rxvt_term::bg_render ()
1341{ 1156{
1342 unsigned long tr_flags = 0;
1343
1344 bg_invalidate (); 1157 bg_invalidate ();
1345# ifdef ENABLE_TRANSPARENCY 1158# ifdef ENABLE_TRANSPARENCY
1346 if (bg_flags & BG_IS_TRANSPARENT) 1159 if (bg_flags & BG_IS_TRANSPARENT)
1347 { 1160 {
1348 /* we need to re-generate transparency pixmap in that case ! */ 1161 /* we need to re-generate transparency pixmap in that case ! */
1349 tr_flags = make_transparency_pixmap (); 1162 if (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; 1163 bg_flags |= BG_IS_VALID;
1354 } 1164 }
1355# endif 1165# endif
1356 1166
1357# ifdef BG_IMAGE_FROM_FILE 1167# ifdef BG_IMAGE_FROM_FILE
1358 if ((bg_flags & BG_IS_FROM_FILE) 1168 for (vector<rxvt_image>::iterator bg_image = image_vec.begin (); bg_image < image_vec.end (); bg_image++)
1359 || (tr_flags & BG_EFFECTS_FLAGS))
1360 { 1169 {
1361 if (render_image (tr_flags)) 1170 if (render_image (*bg_image))
1362 bg_flags |= BG_IS_VALID; 1171 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 } 1172 }
1397# endif 1173# endif
1398 1174
1399 if (!(bg_flags & BG_IS_VALID)) 1175 if (!(bg_flags & BG_IS_VALID))
1400 { 1176 {
… …
1433 bg_flags |= BG_HAS_RENDER_CONV; 1209 bg_flags |= BG_HAS_RENDER_CONV;
1434 1210
1435 XFree (filters); 1211 XFree (filters);
1436 } 1212 }
1437#endif 1213#endif
1214
1215#ifdef BG_IMAGE_FROM_FILE
1216 if (rs[Rs_backgroundPixmap])
1217 {
1218 rxvt_image *image = new_image ();
1219 if (!image->set_file_geometry (rs[Rs_backgroundPixmap]))
1220 image_vec.pop_back ();
1221 }
1222
1223# ifndef NO_RESOURCES
1224 find_resources ("image", "Image", XrmEnumAllLevels, rxvt_define_image);
1225 vector<rxvt_image>::iterator bg_image = image_vec.begin ();
1226 while (bg_image != image_vec.end ())
1227 {
1228 if (!(bg_image->flags & IM_IS_SET))
1229 bg_image = image_vec.erase (bg_image);
1230 else
1231 bg_image++;
1232 }
1233# endif
1234
1235 if (image_vec.size () > 0
1236 && !bg_window_position_sensitive ())
1237 update_background ();
1238#endif
1438} 1239}
1439 1240
1440#endif /* HAVE_BG_PIXMAP */ 1241#endif /* HAVE_BG_PIXMAP */
1441 1242
1442#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) 1243#ifdef ENABLE_TRANSPARENCY
1443/* taken from aterm-0.4.2 */ 1244/* based on code from aterm-0.4.2 */
1444 1245
1445static void 1246static inline void
1446shade_ximage (Visual *visual, XImage *ximage, int shade, const rgba &c) 1247fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
1447{ 1248{
1249 for (int i = 0; i <= mask >> sh; i++)
1250 {
1251 uint32_t tmp;
1252 tmp = i * high;
1253 tmp += (mask >> sh) * low;
1254 lookup[i] = (tmp / 0xffff) << sh;
1255 }
1256}
1257
1258void
1259rxvt_term::tint_ximage (XImage *ximage)
1260{
1261 unsigned int size_r, size_g, size_b;
1448 int sh_r, sh_g, sh_b; 1262 int sh_r, sh_g, sh_b;
1449 uint32_t mask_r, mask_g, mask_b; 1263 uint32_t mask_r, mask_g, mask_b;
1450 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b; 1264 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1451 rgba low; 1265 unsigned short low;
1452 rgba high;
1453 int i;
1454 int host_byte_order = byteorder::big_endian () ? MSBFirst : LSBFirst; 1266 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1455 1267
1456 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return; 1268 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;
1457 1269
1458 /* for convenience */ 1270 /* for convenience */
1459 mask_r = visual->red_mask; 1271 mask_r = visual->red_mask;
1460 mask_g = visual->green_mask; 1272 mask_g = visual->green_mask;
1461 mask_b = visual->blue_mask; 1273 mask_b = visual->blue_mask;
1462 1274
1463 /* boring lookup table pre-initialization */ 1275 /* boring lookup table pre-initialization */
1464 switch (ximage->depth) 1276 sh_r = ecb_ctz32 (mask_r);
1465 { 1277 sh_g = ecb_ctz32 (mask_g);
1466 case 15: 1278 sh_b = ecb_ctz32 (mask_b);
1467 if ((mask_r != 0x7c00) || 1279
1468 (mask_g != 0x03e0) || 1280 size_r = mask_r >> sh_r;
1469 (mask_b != 0x001f)) 1281 size_g = mask_g >> sh_g;
1282 size_b = mask_b >> sh_b;
1283
1284 if (size_r++ > 255 || size_g++ > 255 || size_b++ > 255)
1470 return; 1285 return;
1471 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+32+32)); 1286
1287 lookup = (uint32_t *)malloc (sizeof (uint32_t) * (size_r + size_g + size_b));
1472 lookup_r = lookup; 1288 lookup_r = lookup;
1473 lookup_g = lookup+32; 1289 lookup_g = lookup + size_r;
1474 lookup_b = lookup+32+32; 1290 lookup_b = lookup + size_r + size_g;
1475 sh_r = 10; 1291
1476 sh_g = 5; 1292 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1477 sh_b = 0; 1293
1478 break; 1294 if (bg_flags & BG_TINT_SET)
1479 case 16: 1295 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 1296
1522 /* prepare limits for color transformation (each channel is handled separately) */ 1297 /* prepare limits for color transformation (each channel is handled separately) */
1523 if (shade > 100) 1298 if (shade > 100)
1524 { 1299 {
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; 1300 c.r = c.r * (200 - shade) / 100;
1532 low.g = 65535 * (100 - shade) / 100; 1301 c.g = c.g * (200 - shade) / 100;
1533 low.b = 65535 * (100 - shade) / 100; 1302 c.b = c.b * (200 - shade) / 100;
1303
1304 low = 0xffff * (shade - 100) / 100;
1534 } 1305 }
1535 else 1306 else
1536 { 1307 {
1537 high.r = c.r * shade / 100; 1308 c.r = c.r * shade / 100;
1538 high.g = c.g * shade / 100; 1309 c.g = c.g * shade / 100;
1539 high.b = c.b * shade / 100; 1310 c.b = c.b * shade / 100;
1540 1311
1541 low.r = low.g = low.b = 0; 1312 low = 0;
1542 } 1313 }
1543 1314
1544 /* fill our lookup tables */ 1315 /* fill our lookup tables */
1545 for (i = 0; i <= mask_r>>sh_r; i++) 1316 fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1546 { 1317 fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1547 uint32_t tmp; 1318 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 1319
1567 /* apply table to input image (replacing colors by newly calculated ones) */ 1320 /* apply table to input image (replacing colors by newly calculated ones) */
1568 if (ximage->bits_per_pixel == 32 1321 if (ximage->bits_per_pixel == 32
1569 && (ximage->depth == 24 || ximage->depth == 32)
1570 && ximage->byte_order == host_byte_order) 1322 && ximage->byte_order == host_byte_order)
1571 { 1323 {
1572 uint32_t *p1, *pf, *p, *pl; 1324 char *line = ximage->data;
1573 p1 = (uint32_t *) ximage->data;
1574 pf = (uint32_t *) (ximage->data + ximage->height * ximage->bytes_per_line);
1575 1325
1576 while (p1 < pf) 1326 for (int y = 0; y < ximage->height; y++)
1577 { 1327 {
1578 p = p1; 1328 uint32_t *p = (uint32_t *)line;
1579 pl = p1 + ximage->width; 1329 for (int x = 0; x < ximage->width; x++)
1580 for (; p < pl; p++)
1581 { 1330 {
1582 *p = lookup_r[(*p & 0xff0000) >> 16] | 1331 *p = lookup_r[(*p & mask_r) >> sh_r] |
1583 lookup_g[(*p & 0x00ff00) >> 8] | 1332 lookup_g[(*p & mask_g) >> sh_g] |
1584 lookup_b[(*p & 0x0000ff)] | 1333 lookup_b[(*p & mask_b) >> sh_b];
1585 (*p & 0xff000000); 1334 p++;
1586 } 1335 }
1587 p1 = (uint32_t *) ((char *) p1 + ximage->bytes_per_line); 1336 line += ximage->bytes_per_line;
1588 } 1337 }
1589 } 1338 }
1590 else 1339 else
1591 { 1340 {
1592 for (int y = 0; y < ximage->height; y++) 1341 for (int y = 0; y < ximage->height; y++)
… …
1600 } 1349 }
1601 } 1350 }
1602 1351
1603 free (lookup); 1352 free (lookup);
1604} 1353}
1605#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */ 1354#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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