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.147 by root, Mon Feb 21 07:40:59 2011 UTC vs.
Revision 1.223 by sf-exg, Sat May 26 08:55:27 2012 UTC

… …
3 *----------------------------------------------------------------------* 3 *----------------------------------------------------------------------*
4 * 4 *
5 * All portions of code are copyright by their respective author/s. 5 * All portions of code are copyright by their respective author/s.
6 * Copyright (c) 2005-2008 Marc Lehmann <schmorp@schmorp.de> 6 * Copyright (c) 2005-2008 Marc Lehmann <schmorp@schmorp.de>
7 * Copyright (c) 2007 Sasha Vasko <sasha@aftercode.net> 7 * Copyright (c) 2007 Sasha Vasko <sasha@aftercode.net>
8 * Copyright (c) 2010 Emanuele Giaquinta <e.giaquinta@glauco.it> 8 * Copyright (c) 2010-2012 Emanuele Giaquinta <e.giaquinta@glauco.it>
9 * 9 *
10 * This program is free software; you can redistribute it and/or modify 10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by 11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or 12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version. 13 * (at your option) any later version.
… …
20 * You should have received a copy of the GNU General Public License 20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software 21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 *---------------------------------------------------------------------*/ 23 *---------------------------------------------------------------------*/
24 24
25#include <cmath> 25#include <math.h>
26#include "../config.h" /* NECESSARY */ 26#include "../config.h" /* NECESSARY */
27#include "rxvt.h" /* NECESSARY */ 27#include "rxvt.h" /* NECESSARY */
28 28
29#if XRENDER 29#if XRENDER
30# include <X11/extensions/Xrender.h> 30# include <X11/extensions/Xrender.h>
… …
32 32
33#ifndef FilterConvolution 33#ifndef FilterConvolution
34#define FilterConvolution "convolution" 34#define FilterConvolution "convolution"
35#endif 35#endif
36 36
37/* 37#ifndef RepeatPad
38 * Pixmap geometry string interpretation : 38#define RepeatPad True
39 * Each geometry string contains zero or one scale/position 39#endif
40 * adjustment and may optionally be followed by a colon and one or more
41 * colon-delimited pixmap operations.
42 * The following table shows the valid geometry strings and their
43 * effects on the background image :
44 *
45 * WxH+X+Y Set scaling to W% by H%, and position to X% by Y%.
46 * W and H are percentages of the terminal window size.
47 * X and Y are also percentages; e.g., +50+50 centers
48 * the image in the window.
49 *
50 * Pixmap Operations : (should be prepended by a colon)
51 * tile Tile image. Scaling/position modifiers above will affect
52 * the tile size and origin.
53 * propscale When scaling, scale proportionally. That is, maintain the
54 * proper aspect ratio for the image. Any portion of the
55 * background not covered by the image is filled with the
56 * current background color.
57 * hscale Scale horizontally, tile vertically ?
58 * vscale Tile horizontally, scale vertically ?
59 * scale Scale both up and down
60 * auto Same as 100x100+50+50
61 */
62 40
63#ifdef HAVE_BG_PIXMAP 41#ifdef HAVE_BG_PIXMAP
42# if XRENDER
43static Picture
44create_xrender_mask (Display *dpy, Drawable drawable, Bool argb, Bool component_alpha)
45{
46 Pixmap pixmap = XCreatePixmap (dpy, drawable, 1, 1, argb ? 32 : 8);
47
48 XRenderPictFormat *format = XRenderFindStandardFormat (dpy, argb ? PictStandardARGB32 : PictStandardA8);
49 XRenderPictureAttributes pa;
50 pa.repeat = True;
51 pa.component_alpha = component_alpha;
52 Picture mask = XRenderCreatePicture (dpy, pixmap, format, CPRepeat | CPComponentAlpha, &pa);
53
54 XFreePixmap (dpy, pixmap);
55
56 return mask;
57}
58# endif
59
64void 60void
65rxvt_term::bg_destroy () 61rxvt_term::bg_destroy ()
66{ 62{
67#ifdef HAVE_AFTERIMAGE 63# 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 = 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
948void 785bool
949rxvt_term::set_tint_shade_flags () 786rxvt_term::bg_set_tint (rxvt_color &new_tint)
950{ 787{
951 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 788 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
952 bool has_shade = shade != 100; 789 {
953 790 tint = new_tint;
954 bg_flags &= ~BG_TINT_FLAGS; 791 bg_flags |= BG_TINT_SET;
955 792
956 if (bg_flags & BG_TINT_SET) 793 rgba c;
957 {
958 tint.get (c); 794 tint.get (c);
959 if (!has_shade
960 && (c.r <= 0x00ff || c.r >= 0xff00) 795 if ((c.r <= 0x00ff || c.r >= 0xff00)
961 && (c.g <= 0x00ff || c.g >= 0xff00) 796 && (c.g <= 0x00ff || c.g >= 0xff00)
962 && (c.b <= 0x00ff || c.b >= 0xff00)) 797 && (c.b <= 0x00ff || c.b >= 0xff00))
963 bg_flags |= BG_TINT_BITAND; 798 bg_flags |= BG_TINT_BITAND;
964 } 799 else
965
966 if (has_shade || (bg_flags & BG_TINT_SET))
967 bg_flags |= BG_NEEDS_TINT;
968}
969
970bool
971rxvt_term::bg_set_tint (rxvt_color &new_tint)
972{
973 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
974 {
975 tint = new_tint;
976 bg_flags |= BG_TINT_SET; 800 bg_flags &= ~BG_TINT_BITAND;
977 set_tint_shade_flags (); 801
978 return true; 802 return true;
979 } 803 }
980 804
981 return false; 805 return false;
982} 806}
983 807
984bool 808bool
985rxvt_term::bg_set_shade (const char *shade_str) 809rxvt_term::bg_set_shade (const char *shade_str)
986{ 810{
987 int new_shade = (shade_str) ? atoi (shade_str) : 100; 811 int new_shade = atoi (shade_str);
988 812
989 clamp_it (new_shade, -100, 200); 813 clamp_it (new_shade, -100, 200);
990 if (new_shade < 0) 814 if (new_shade < 0)
991 new_shade = 200 - (100 + new_shade); 815 new_shade = 200 - (100 + new_shade);
992 816
993 if (new_shade != shade) 817 if (new_shade != shade)
994 { 818 {
995 shade = new_shade; 819 shade = new_shade;
996 set_tint_shade_flags ();
997 return true; 820 return true;
998 } 821 }
999 822
1000 return false; 823 return false;
1001} 824}
… …
1022 params[i+2] = XDoubleToFixed (kernel[i] / sum); 845 params[i+2] = XDoubleToFixed (kernel[i] / sum);
1023} 846}
1024#endif 847#endif
1025 848
1026bool 849bool
1027rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 850rxvt_term::blur_pixmap (Pixmap pixmap, int width, int height)
1028{ 851{
1029 bool ret = false; 852 bool ret = false;
1030#if XRENDER 853#if XRENDER
854 if (!(bg_flags & BG_HAS_RENDER_CONV))
855 return false;
856
1031 int size = max (h_blurRadius, v_blurRadius) * 2 + 1; 857 int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1032 double *kernel = (double *)malloc (size * sizeof (double)); 858 double *kernel = (double *)malloc (size * sizeof (double));
1033 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 859 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1034 860
1035 XRenderPictureAttributes pa; 861 XRenderPictureAttributes pa;
1036 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 862 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1037 863
864 pa.repeat = RepeatPad;
1038 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);
1039 Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 867 Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
868 XFreePixmap (dpy, tmp);
1040 869
1041 if (kernel && params && src && dst) 870 if (kernel && params)
1042 { 871 {
1043 if (h_blurRadius)
1044 {
1045 size = h_blurRadius * 2 + 1; 872 size = h_blurRadius * 2 + 1;
1046 get_gaussian_kernel (h_blurRadius, size, kernel, params); 873 get_gaussian_kernel (h_blurRadius, size, kernel, params);
1047 874
1048 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 875 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1049 XRenderComposite (dpy, 876 XRenderComposite (dpy,
1050 PictOpSrc, 877 PictOpSrc,
1051 src, 878 src,
1052 None, 879 None,
1053 dst, 880 dst,
1054 0, 0, 881 0, 0,
1055 0, 0, 882 0, 0,
1056 0, 0, 883 0, 0,
1057 width, height); 884 width, height);
1058 }
1059 885
1060 if (v_blurRadius) 886 ::swap (src, dst);
1061 { 887
1062 size = v_blurRadius * 2 + 1; 888 size = v_blurRadius * 2 + 1;
1063 get_gaussian_kernel (v_blurRadius, size, kernel, params); 889 get_gaussian_kernel (v_blurRadius, size, kernel, params);
1064 ::swap (params[0], params[1]); 890 ::swap (params[0], params[1]);
1065 891
1066 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 892 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1067 XRenderComposite (dpy, 893 XRenderComposite (dpy,
1068 PictOpSrc, 894 PictOpSrc,
1069 src, 895 src,
1070 None, 896 None,
1071 dst, 897 dst,
1072 0, 0, 898 0, 0,
1073 0, 0, 899 0, 0,
1074 0, 0, 900 0, 0,
1075 width, height); 901 width, height);
1076 }
1077 902
1078 ret = true; 903 ret = true;
1079 } 904 }
1080 905
1081 free (kernel); 906 free (kernel);
… …
1085#endif 910#endif
1086 return ret; 911 return ret;
1087} 912}
1088 913
1089bool 914bool
1090rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 915rxvt_term::tint_pixmap (Pixmap pixmap, int width, int height)
1091{ 916{
1092 bool ret = false; 917 bool ret = false;
1093 918
1094 if (bg_flags & BG_TINT_BITAND) 919 if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1095 { 920 {
1096 XGCValues gcv; 921 XGCValues gcv;
1097 GC gc; 922 GC gc;
1098 923
1099 /* In this case we can tint image server-side getting significant 924 /* In this case we can tint image server-side getting significant
… …
1108 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height); 933 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1109 ret = true; 934 ret = true;
1110 XFreeGC (dpy, gc); 935 XFreeGC (dpy, gc);
1111 } 936 }
1112 } 937 }
1113 else
1114 {
1115# if XRENDER 938# if XRENDER
939 else if (bg_flags & BG_HAS_RENDER)
940 {
1116 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 941 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1117 942
1118 if (bg_flags & BG_TINT_SET) 943 if (bg_flags & BG_TINT_SET)
1119 tint.get (c); 944 tint.get (c);
1120 945
1121 if (shade <= 100) 946 if (shade <= 100)
1122 { 947 {
1123 c.r = (c.r * shade) / 100; 948 c.r = c.r * shade / 100;
1124 c.g = (c.g * shade) / 100; 949 c.g = c.g * shade / 100;
1125 c.b = (c.b * shade) / 100; 950 c.b = c.b * shade / 100;
1126 } 951 }
1127 else 952 else
1128 { 953 {
1129 c.r = (c.r * (200 - shade)) / 100; 954 c.r = c.r * (200 - shade) / 100;
1130 c.g = (c.g * (200 - shade)) / 100; 955 c.g = c.g * (200 - shade) / 100;
1131 c.b = (c.b * (200 - shade)) / 100; 956 c.b = c.b * (200 - shade) / 100;
1132 } 957 }
1133 958
1134 XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1135 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 959 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1136 XRenderPictureAttributes pa;
1137 960
1138 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 961 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1139 962
1140 pa.repeat = True; 963 Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1141 964
1142 Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32); 965 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 966
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; 967 XRenderColor mask_c;
1154 968
1155 mask_c.red = mask_c.green = mask_c.blue = 0;
1156 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;
1157 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1); 989 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1158 990
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); 991 XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1173 }
1174
1175 ret = true;
1176 } 992 }
993
994 ret = true;
1177 995
1178 XRenderFreePicture (dpy, mask_pic); 996 XRenderFreePicture (dpy, mask_pic);
1179 XRenderFreePicture (dpy, overlay_pic); 997 XRenderFreePicture (dpy, overlay_pic);
1180 XRenderFreePicture (dpy, back_pic); 998 XRenderFreePicture (dpy, back_pic);
999 }
1181# endif 1000# endif
1182 }
1183 1001
1184 return ret; 1002 return ret;
1185} 1003}
1186 1004
1187/* make_transparency_pixmap() 1005/*
1188 * 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
1189 * 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
1190 * our window. 1008 * our window.
1191 */ 1009 */
1192unsigned long 1010bool
1193rxvt_term::make_transparency_pixmap () 1011rxvt_term::make_transparency_pixmap ()
1194{ 1012{
1195 unsigned long result = 0; 1013 bool ret = false;
1196 1014
1197 /* 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
1198 * be always up-to-date, so let's use it : 1016 * be always up-to-date, so let's use it :
1199 */ 1017 */
1200 int screen = display->screen; 1018 int screen = display->screen;
… …
1236 if (root_pixmap != None && root_depth != depth) 1054 if (root_pixmap != None && root_depth != depth)
1237 { 1055 {
1238#if XRENDER 1056#if XRENDER
1239 if (bg_flags & BG_HAS_RENDER) 1057 if (bg_flags & BG_HAS_RENDER)
1240 { 1058 {
1241 XRenderPictureAttributes pa; 1059 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1242 1060
1243 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen)); 1061 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1244 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa); 1062 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1245 1063
1246 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1247 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual); 1064 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1248 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa); 1065 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1249 1066
1250 if (src && dst)
1251 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);
1252 else
1253 {
1254 XFreePixmap (dpy, recoded_root_pmap);
1255 root_pixmap = None;
1256 }
1257 1068
1258 XRenderFreePicture (dpy, src); 1069 XRenderFreePicture (dpy, src);
1259 XRenderFreePicture (dpy, dst); 1070 XRenderFreePicture (dpy, dst);
1260 } 1071 }
1261 else 1072 else
1262#endif 1073#endif
1263 root_pixmap = None; 1074 recoded_root_pmap = None;
1264 } 1075 }
1265 1076
1266 if (root_pixmap == None) 1077 if (recoded_root_pmap == None)
1267 return 0; 1078 return 0;
1268 1079
1269 if (bg_pixmap == None 1080 if (bg_pixmap == None
1270 || bg_pmap_width != window_width 1081 || bg_pmap_width != window_width
1271 || bg_pmap_height != window_height) 1082 || bg_pmap_height != window_height)
… …
1275 bg_pixmap = XCreatePixmap (dpy, vt, window_width, window_height, depth); 1086 bg_pixmap = XCreatePixmap (dpy, vt, window_width, window_height, depth);
1276 bg_pmap_width = window_width; 1087 bg_pmap_width = window_width;
1277 bg_pmap_height = window_height; 1088 bg_pmap_height = window_height;
1278 } 1089 }
1279 1090
1280 if (bg_pixmap == None)
1281 return 0;
1282
1283 /* straightforward pixmap copy */ 1091 /* straightforward pixmap copy */
1284 while (sx < 0) sx += (int)root_width; 1092 while (sx < 0) sx += root_pmap_width;
1285 while (sy < 0) sy += (int)root_height; 1093 while (sy < 0) sy += root_pmap_height;
1286 1094
1287 gcv.tile = recoded_root_pmap; 1095 gcv.tile = recoded_root_pmap;
1288 gcv.fill_style = FillTiled; 1096 gcv.fill_style = FillTiled;
1289 gcv.ts_x_origin = -sx; 1097 gcv.ts_x_origin = -sx;
1290 gcv.ts_y_origin = -sy; 1098 gcv.ts_y_origin = -sy;
1291 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); 1099 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1292 1100
1293 if (gc) 1101 if (gc)
1294 { 1102 {
1295 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height); 1103 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1296 result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS); 1104 ret = true;
1297 XFreeGC (dpy, gc); 1105 bool need_blur = h_blurRadius && v_blurRadius;
1106 bool need_tint = shade != 100 || (bg_flags & BG_TINT_SET);
1298 1107
1299 if (!(bg_flags & BG_CLIENT_RENDER)) 1108 if (!(bg_flags & BG_CLIENT_RENDER))
1300 { 1109 {
1301 if ((bg_flags & BG_NEEDS_BLUR) 1110 if (need_blur)
1302 && (bg_flags & BG_HAS_RENDER_CONV))
1303 { 1111 {
1304 if (blur_pixmap (bg_pixmap, visual, window_width, window_height)) 1112 if (blur_pixmap (bg_pixmap, window_width, window_height))
1305 result &= ~BG_NEEDS_BLUR; 1113 need_blur = false;
1306 } 1114 }
1307 if ((bg_flags & BG_NEEDS_TINT) 1115 if (need_tint)
1308 && (bg_flags & (BG_TINT_BITAND | BG_HAS_RENDER)))
1309 { 1116 {
1310 if (tint_pixmap (bg_pixmap, visual, window_width, window_height)) 1117 if (tint_pixmap (bg_pixmap, window_width, window_height))
1311 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 }
1312 } 1131 }
1313 } /* server side rendering completed */ 1132 } /* server side rendering completed */
1133
1134 XFreeGC (dpy, gc);
1314 } 1135 }
1315 1136
1316 if (recoded_root_pmap != root_pixmap) 1137 if (recoded_root_pmap != root_pixmap)
1317 XFreePixmap (dpy, recoded_root_pmap); 1138 XFreePixmap (dpy, recoded_root_pmap);
1318 1139
1319 return result; 1140 return ret;
1320} 1141}
1321 1142
1322void 1143void
1323rxvt_term::bg_set_root_pixmap () 1144rxvt_term::bg_set_root_pixmap ()
1324{ 1145{
… …
1328 1149
1329 root_pixmap = new_root_pixmap; 1150 root_pixmap = new_root_pixmap;
1330} 1151}
1331# endif /* ENABLE_TRANSPARENCY */ 1152# endif /* ENABLE_TRANSPARENCY */
1332 1153
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 1154bool
1338rxvt_term::bg_render () 1155rxvt_term::bg_render ()
1339{ 1156{
1340 unsigned long tr_flags = 0;
1341
1342 bg_invalidate (); 1157 bg_invalidate ();
1343# ifdef ENABLE_TRANSPARENCY 1158# ifdef ENABLE_TRANSPARENCY
1344 if (bg_flags & BG_IS_TRANSPARENT) 1159 if (bg_flags & BG_IS_TRANSPARENT)
1345 { 1160 {
1346 /* we need to re-generate transparency pixmap in that case ! */ 1161 /* we need to re-generate transparency pixmap in that case ! */
1347 tr_flags = make_transparency_pixmap (); 1162 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; 1163 bg_flags |= BG_IS_VALID;
1352 } 1164 }
1353# endif 1165# endif
1354 1166
1355# ifdef BG_IMAGE_FROM_FILE 1167# ifdef BG_IMAGE_FROM_FILE
1356 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++)
1357 || (tr_flags & BG_EFFECTS_FLAGS))
1358 { 1169 {
1359 if (render_image (tr_flags)) 1170 if (render_image (*bg_image))
1360 bg_flags |= BG_IS_VALID; 1171 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 } 1172 }
1395# endif 1173# endif
1396 1174
1397 if (!(bg_flags & BG_IS_VALID)) 1175 if (!(bg_flags & BG_IS_VALID))
1398 { 1176 {
… …
1431 bg_flags |= BG_HAS_RENDER_CONV; 1209 bg_flags |= BG_HAS_RENDER_CONV;
1432 1210
1433 XFree (filters); 1211 XFree (filters);
1434 } 1212 }
1435#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
1436} 1239}
1437 1240
1438#endif /* HAVE_BG_PIXMAP */ 1241#endif /* HAVE_BG_PIXMAP */
1439 1242
1440#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) 1243#ifdef ENABLE_TRANSPARENCY
1441/* taken from aterm-0.4.2 */ 1244/* based on code from aterm-0.4.2 */
1442 1245
1443static void 1246static inline void
1444shade_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)
1445{ 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;
1446 int sh_r, sh_g, sh_b; 1262 int sh_r, sh_g, sh_b;
1447 uint32_t mask_r, mask_g, mask_b; 1263 uint32_t mask_r, mask_g, mask_b;
1448 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b; 1264 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1449 rgba low; 1265 unsigned short low;
1450 rgba high;
1451 int i;
1452 int host_byte_order = byteorder::big_endian () ? MSBFirst : LSBFirst; 1266 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1453 1267
1454 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return; 1268 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;
1455 1269
1456 /* for convenience */ 1270 /* for convenience */
1457 mask_r = visual->red_mask; 1271 mask_r = visual->red_mask;
1458 mask_g = visual->green_mask; 1272 mask_g = visual->green_mask;
1459 mask_b = visual->blue_mask; 1273 mask_b = visual->blue_mask;
1460 1274
1461 /* boring lookup table pre-initialization */ 1275 /* boring lookup table pre-initialization */
1462 switch (ximage->depth) 1276 sh_r = ecb_ctz32 (mask_r);
1463 { 1277 sh_g = ecb_ctz32 (mask_g);
1464 case 15: 1278 sh_b = ecb_ctz32 (mask_b);
1465 if ((mask_r != 0x7c00) || 1279
1466 (mask_g != 0x03e0) || 1280 size_r = mask_r >> sh_r;
1467 (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)
1468 return; 1285 return;
1469 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));
1470 lookup_r = lookup; 1288 lookup_r = lookup;
1471 lookup_g = lookup+32; 1289 lookup_g = lookup + size_r;
1472 lookup_b = lookup+32+32; 1290 lookup_b = lookup + size_r + size_g;
1473 sh_r = 10; 1291
1474 sh_g = 5; 1292 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1475 sh_b = 0; 1293
1476 break; 1294 if (bg_flags & BG_TINT_SET)
1477 case 16: 1295 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 1296
1520 /* prepare limits for color transformation (each channel is handled separately) */ 1297 /* prepare limits for color transformation (each channel is handled separately) */
1521 if (shade > 100) 1298 if (shade > 100)
1522 { 1299 {
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; 1300 c.r = c.r * (200 - shade) / 100;
1530 low.g = 65535 * (100 - shade) / 100; 1301 c.g = c.g * (200 - shade) / 100;
1531 low.b = 65535 * (100 - shade) / 100; 1302 c.b = c.b * (200 - shade) / 100;
1303
1304 low = 0xffff * (shade - 100) / 100;
1532 } 1305 }
1533 else 1306 else
1534 { 1307 {
1535 high.r = c.r * shade / 100; 1308 c.r = c.r * shade / 100;
1536 high.g = c.g * shade / 100; 1309 c.g = c.g * shade / 100;
1537 high.b = c.b * shade / 100; 1310 c.b = c.b * shade / 100;
1538 1311
1539 low.r = low.g = low.b = 0; 1312 low = 0;
1540 } 1313 }
1541 1314
1542 /* fill our lookup tables */ 1315 /* fill our lookup tables */
1543 for (i = 0; i <= mask_r>>sh_r; i++) 1316 fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1544 { 1317 fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1545 uint32_t tmp; 1318 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 1319
1565 /* apply table to input image (replacing colors by newly calculated ones) */ 1320 /* apply table to input image (replacing colors by newly calculated ones) */
1566 if (ximage->bits_per_pixel == 32 1321 if (ximage->bits_per_pixel == 32
1567 && (ximage->depth == 24 || ximage->depth == 32)
1568 && ximage->byte_order == host_byte_order) 1322 && ximage->byte_order == host_byte_order)
1569 { 1323 {
1570 uint32_t *p1, *pf, *p, *pl; 1324 char *line = ximage->data;
1571 p1 = (uint32_t *) ximage->data;
1572 pf = (uint32_t *) (ximage->data + ximage->height * ximage->bytes_per_line);
1573 1325
1574 while (p1 < pf) 1326 for (int y = 0; y < ximage->height; y++)
1575 { 1327 {
1576 p = p1; 1328 uint32_t *p = (uint32_t *)line;
1577 pl = p1 + ximage->width; 1329 for (int x = 0; x < ximage->width; x++)
1578 for (; p < pl; p++)
1579 { 1330 {
1580 *p = lookup_r[(*p & 0xff0000) >> 16] | 1331 *p = lookup_r[(*p & mask_r) >> sh_r] |
1581 lookup_g[(*p & 0x00ff00) >> 8] | 1332 lookup_g[(*p & mask_g) >> sh_g] |
1582 lookup_b[(*p & 0x0000ff)] | 1333 lookup_b[(*p & mask_b) >> sh_b];
1583 (*p & 0xff000000); 1334 p++;
1584 } 1335 }
1585 p1 = (uint32_t *) ((char *) p1 + ximage->bytes_per_line); 1336 line += ximage->bytes_per_line;
1586 } 1337 }
1587 } 1338 }
1588 else 1339 else
1589 { 1340 {
1590 for (int y = 0; y < ximage->height; y++) 1341 for (int y = 0; y < ximage->height; y++)
… …
1598 } 1349 }
1599 } 1350 }
1600 1351
1601 free (lookup); 1352 free (lookup);
1602} 1353}
1603#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */ 1354#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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