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.221 by sf-exg, Fri May 25 09:27:35 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 = 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 rxvt_image *image;
680
681 for (image = image_vec.begin (); image < image_vec.end (); image++)
682 if (image->id == id)
683 break;
684
685 if (image == image_vec.end ())
686 {
687 image = new_image ();
688 image->id = id;
689 }
690}
691# endif
692
693rxvt_image::rxvt_image ()
694{
695 id =
696 alpha =
697 flags =
698 h_scale =
699 v_scale =
700 h_align =
701 v_align = 0;
702
703# ifdef HAVE_PIXBUF
704 pixbuf = 0;
705# endif
706}
707
853bool 708bool
854rxvt_term::bg_set_file (const char *file) 709rxvt_image::set_file_geometry (const char *file)
855{ 710{
856 if (!file || !*file) 711 if (!file || !*file)
857 return false; 712 return false;
858 713
859 if (const char *p = strchr (file, ';')) 714 const char *p = strchr (file, ';');
715
716 if (p)
860 { 717 {
861 size_t len = p - file; 718 size_t len = p - file;
862 char *f = rxvt_temp_buf<char> (len + 1); 719 char *f = rxvt_temp_buf<char> (len + 1);
863 memcpy (f, file, len); 720 memcpy (f, file, len);
864 f[len] = '\0'; 721 f[len] = '\0';
865 file = f; 722 file = f;
866 } 723 }
867 724
868# ifdef HAVE_AFTERIMAGE 725 bool ret = set_file (file);
869 if (!asimman) 726 alpha = 0x8000;
870 asimman = create_generic_imageman (rs[Rs_path]); 727 if (ret && p)
871 ASImage *image = get_asimage (asimman, file, 0xFFFFFFFF, 100); 728 set_geometry (p + 1);
872 if (image) 729 return ret;
873 { 730}
874 if (original_asim) 731
875 safe_asimage_destroy (original_asim); 732bool
876 original_asim = image; 733rxvt_image::set_file (const char *file)
877 bg_flags |= BG_IS_FROM_FILE | BG_CLIENT_RENDER; 734{
878 return true; 735 bool ret = false;
879 }
880# endif
881 736
882# ifdef HAVE_PIXBUF 737# ifdef HAVE_PIXBUF
883 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL); 738 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
884 if (image) 739 if (image)
885 { 740 {
886 if (pixbuf) 741 if (pixbuf)
887 g_object_unref (pixbuf); 742 g_object_unref (pixbuf);
888 pixbuf = image; 743 pixbuf = image;
889 bg_flags |= BG_IS_FROM_FILE;
890 return true; 744 ret = true;
891 } 745 }
892# endif 746# endif
893 747
748 if (ret)
749 {
750 alpha = 0xffff;
751 flags = IM_IS_SET | IM_IS_SIZE_SENSITIVE;
752 h_scale = v_scale = defaultScale;
753 h_align = v_align = defaultAlign;
754 }
755
894 return false; 756 return ret;
895} 757}
896 758
897# endif /* BG_IMAGE_FROM_FILE */ 759# endif /* BG_IMAGE_FROM_FILE */
898 760
899# ifdef ENABLE_TRANSPARENCY 761# 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 762bool
913rxvt_term::bg_set_blur (const char *geom) 763rxvt_term::bg_set_blur (const char *geom)
914{ 764{
915 bool changed = false; 765 bool changed = false;
916 unsigned int hr, vr; 766 unsigned int hr, vr;
… …
935 { 785 {
936 changed = true; 786 changed = true;
937 v_blurRadius = vr; 787 v_blurRadius = vr;
938 } 788 }
939 789
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; 790 return changed;
946} 791}
947 792
948void 793bool
949rxvt_term::set_tint_shade_flags () 794rxvt_term::bg_set_tint (rxvt_color &new_tint)
950{ 795{
951 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 796 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
952 bool has_shade = shade != 100; 797 {
953 798 tint = new_tint;
954 bg_flags &= ~BG_TINT_FLAGS; 799 bg_flags |= BG_TINT_SET;
955 800
956 if (bg_flags & BG_TINT_SET) 801 rgba c;
957 {
958 tint.get (c); 802 tint.get (c);
959 if (!has_shade
960 && (c.r <= 0x00ff || c.r >= 0xff00) 803 if ((c.r <= 0x00ff || c.r >= 0xff00)
961 && (c.g <= 0x00ff || c.g >= 0xff00) 804 && (c.g <= 0x00ff || c.g >= 0xff00)
962 && (c.b <= 0x00ff || c.b >= 0xff00)) 805 && (c.b <= 0x00ff || c.b >= 0xff00))
963 bg_flags |= BG_TINT_BITAND; 806 bg_flags |= BG_TINT_BITAND;
964 } 807 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; 808 bg_flags &= ~BG_TINT_BITAND;
977 set_tint_shade_flags (); 809
978 return true; 810 return true;
979 } 811 }
980 812
981 return false; 813 return false;
982} 814}
983 815
984bool 816bool
985rxvt_term::bg_set_shade (const char *shade_str) 817rxvt_term::bg_set_shade (const char *shade_str)
986{ 818{
987 int new_shade = (shade_str) ? atoi (shade_str) : 100; 819 int new_shade = atoi (shade_str);
988 820
989 clamp_it (new_shade, -100, 200); 821 clamp_it (new_shade, -100, 200);
990 if (new_shade < 0) 822 if (new_shade < 0)
991 new_shade = 200 - (100 + new_shade); 823 new_shade = 200 - (100 + new_shade);
992 824
993 if (new_shade != shade) 825 if (new_shade != shade)
994 { 826 {
995 shade = new_shade; 827 shade = new_shade;
996 set_tint_shade_flags ();
997 return true; 828 return true;
998 } 829 }
999 830
1000 return false; 831 return false;
1001} 832}
… …
1022 params[i+2] = XDoubleToFixed (kernel[i] / sum); 853 params[i+2] = XDoubleToFixed (kernel[i] / sum);
1023} 854}
1024#endif 855#endif
1025 856
1026bool 857bool
1027rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 858rxvt_term::blur_pixmap (Pixmap pixmap, int width, int height)
1028{ 859{
1029 bool ret = false; 860 bool ret = false;
1030#if XRENDER 861#if XRENDER
862 if (!(bg_flags & BG_HAS_RENDER_CONV))
863 return false;
864
1031 int size = max (h_blurRadius, v_blurRadius) * 2 + 1; 865 int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1032 double *kernel = (double *)malloc (size * sizeof (double)); 866 double *kernel = (double *)malloc (size * sizeof (double));
1033 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 867 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1034 868
1035 XRenderPictureAttributes pa; 869 XRenderPictureAttributes pa;
1036 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 870 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1037 871
872 pa.repeat = RepeatPad;
1038 Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 873 Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
874 Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1039 Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 875 Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
876 XFreePixmap (dpy, tmp);
1040 877
1041 if (kernel && params && src && dst) 878 if (kernel && params)
1042 { 879 {
1043 if (h_blurRadius)
1044 {
1045 size = h_blurRadius * 2 + 1; 880 size = h_blurRadius * 2 + 1;
1046 get_gaussian_kernel (h_blurRadius, size, kernel, params); 881 get_gaussian_kernel (h_blurRadius, size, kernel, params);
1047 882
1048 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 883 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1049 XRenderComposite (dpy, 884 XRenderComposite (dpy,
1050 PictOpSrc, 885 PictOpSrc,
1051 src, 886 src,
1052 None, 887 None,
1053 dst, 888 dst,
1054 0, 0, 889 0, 0,
1055 0, 0, 890 0, 0,
1056 0, 0, 891 0, 0,
1057 width, height); 892 width, height);
1058 }
1059 893
1060 if (v_blurRadius) 894 ::swap (src, dst);
1061 { 895
1062 size = v_blurRadius * 2 + 1; 896 size = v_blurRadius * 2 + 1;
1063 get_gaussian_kernel (v_blurRadius, size, kernel, params); 897 get_gaussian_kernel (v_blurRadius, size, kernel, params);
1064 ::swap (params[0], params[1]); 898 ::swap (params[0], params[1]);
1065 899
1066 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 900 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1067 XRenderComposite (dpy, 901 XRenderComposite (dpy,
1068 PictOpSrc, 902 PictOpSrc,
1069 src, 903 src,
1070 None, 904 None,
1071 dst, 905 dst,
1072 0, 0, 906 0, 0,
1073 0, 0, 907 0, 0,
1074 0, 0, 908 0, 0,
1075 width, height); 909 width, height);
1076 }
1077 910
1078 ret = true; 911 ret = true;
1079 } 912 }
1080 913
1081 free (kernel); 914 free (kernel);
… …
1085#endif 918#endif
1086 return ret; 919 return ret;
1087} 920}
1088 921
1089bool 922bool
1090rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 923rxvt_term::tint_pixmap (Pixmap pixmap, int width, int height)
1091{ 924{
1092 bool ret = false; 925 bool ret = false;
1093 926
1094 if (bg_flags & BG_TINT_BITAND) 927 if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1095 { 928 {
1096 XGCValues gcv; 929 XGCValues gcv;
1097 GC gc; 930 GC gc;
1098 931
1099 /* In this case we can tint image server-side getting significant 932 /* In this case we can tint image server-side getting significant
… …
1108 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height); 941 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1109 ret = true; 942 ret = true;
1110 XFreeGC (dpy, gc); 943 XFreeGC (dpy, gc);
1111 } 944 }
1112 } 945 }
1113 else
1114 {
1115# if XRENDER 946# if XRENDER
947 else if (bg_flags & BG_HAS_RENDER)
948 {
1116 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 949 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1117 950
1118 if (bg_flags & BG_TINT_SET) 951 if (bg_flags & BG_TINT_SET)
1119 tint.get (c); 952 tint.get (c);
1120 953
1121 if (shade <= 100) 954 if (shade <= 100)
1122 { 955 {
1123 c.r = (c.r * shade) / 100; 956 c.r = c.r * shade / 100;
1124 c.g = (c.g * shade) / 100; 957 c.g = c.g * shade / 100;
1125 c.b = (c.b * shade) / 100; 958 c.b = c.b * shade / 100;
1126 } 959 }
1127 else 960 else
1128 { 961 {
1129 c.r = (c.r * (200 - shade)) / 100; 962 c.r = c.r * (200 - shade) / 100;
1130 c.g = (c.g * (200 - shade)) / 100; 963 c.g = c.g * (200 - shade) / 100;
1131 c.b = (c.b * (200 - shade)) / 100; 964 c.b = c.b * (200 - shade) / 100;
1132 } 965 }
1133 966
1134 XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1135 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 967 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1136 XRenderPictureAttributes pa;
1137 968
1138 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 969 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1139 970
1140 pa.repeat = True; 971 Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1141 972
1142 Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32); 973 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 974
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; 975 XRenderColor mask_c;
1154 976
1155 mask_c.red = mask_c.green = mask_c.blue = 0;
1156 mask_c.alpha = 0xffff; 977 mask_c.alpha = 0xffff;
978 mask_c.red =
979 mask_c.green =
980 mask_c.blue = 0;
981 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
982
983 mask_c.alpha = 0;
984 mask_c.red = 0xffff - c.r;
985 mask_c.green = 0xffff - c.g;
986 mask_c.blue = 0xffff - c.b;
987 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
988
989 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
990
991 if (shade > 100)
992 {
993 mask_c.alpha = 0;
994 mask_c.red =
995 mask_c.green =
996 mask_c.blue = 0xffff * (shade - 100) / 100;
1157 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1); 997 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1158 998
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); 999 XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1173 }
1174
1175 ret = true;
1176 } 1000 }
1001
1002 ret = true;
1177 1003
1178 XRenderFreePicture (dpy, mask_pic); 1004 XRenderFreePicture (dpy, mask_pic);
1179 XRenderFreePicture (dpy, overlay_pic); 1005 XRenderFreePicture (dpy, overlay_pic);
1180 XRenderFreePicture (dpy, back_pic); 1006 XRenderFreePicture (dpy, back_pic);
1007 }
1181# endif 1008# endif
1182 }
1183 1009
1184 return ret; 1010 return ret;
1185} 1011}
1186 1012
1187/* make_transparency_pixmap() 1013/*
1188 * Builds a pixmap of the same size as the terminal window that contains 1014 * 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 1015 * the tiled portion of the root pixmap that is supposed to be covered by
1190 * our window. 1016 * our window.
1191 */ 1017 */
1192unsigned long 1018bool
1193rxvt_term::make_transparency_pixmap () 1019rxvt_term::make_transparency_pixmap ()
1194{ 1020{
1195 unsigned long result = 0; 1021 bool ret = false;
1196 1022
1197 /* root dimensions may change from call to call - but Display structure should 1023 /* root dimensions may change from call to call - but Display structure should
1198 * be always up-to-date, so let's use it : 1024 * be always up-to-date, so let's use it :
1199 */ 1025 */
1200 int screen = display->screen; 1026 int screen = display->screen;
… …
1236 if (root_pixmap != None && root_depth != depth) 1062 if (root_pixmap != None && root_depth != depth)
1237 { 1063 {
1238#if XRENDER 1064#if XRENDER
1239 if (bg_flags & BG_HAS_RENDER) 1065 if (bg_flags & BG_HAS_RENDER)
1240 { 1066 {
1241 XRenderPictureAttributes pa; 1067 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1242 1068
1243 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen)); 1069 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1244 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa); 1070 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1245 1071
1246 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1247 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual); 1072 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1248 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa); 1073 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1249 1074
1250 if (src && dst)
1251 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height); 1075 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 1076
1258 XRenderFreePicture (dpy, src); 1077 XRenderFreePicture (dpy, src);
1259 XRenderFreePicture (dpy, dst); 1078 XRenderFreePicture (dpy, dst);
1260 } 1079 }
1261 else 1080 else
1262#endif 1081#endif
1263 root_pixmap = None; 1082 recoded_root_pmap = None;
1264 } 1083 }
1265 1084
1266 if (root_pixmap == None) 1085 if (recoded_root_pmap == None)
1267 return 0; 1086 return 0;
1268 1087
1269 if (bg_pixmap == None 1088 if (bg_pixmap == None
1270 || bg_pmap_width != window_width 1089 || bg_pmap_width != window_width
1271 || bg_pmap_height != window_height) 1090 || bg_pmap_height != window_height)
… …
1275 bg_pixmap = XCreatePixmap (dpy, vt, window_width, window_height, depth); 1094 bg_pixmap = XCreatePixmap (dpy, vt, window_width, window_height, depth);
1276 bg_pmap_width = window_width; 1095 bg_pmap_width = window_width;
1277 bg_pmap_height = window_height; 1096 bg_pmap_height = window_height;
1278 } 1097 }
1279 1098
1280 if (bg_pixmap == None)
1281 return 0;
1282
1283 /* straightforward pixmap copy */ 1099 /* straightforward pixmap copy */
1284 while (sx < 0) sx += (int)root_width; 1100 while (sx < 0) sx += root_pmap_width;
1285 while (sy < 0) sy += (int)root_height; 1101 while (sy < 0) sy += root_pmap_height;
1286 1102
1287 gcv.tile = recoded_root_pmap; 1103 gcv.tile = recoded_root_pmap;
1288 gcv.fill_style = FillTiled; 1104 gcv.fill_style = FillTiled;
1289 gcv.ts_x_origin = -sx; 1105 gcv.ts_x_origin = -sx;
1290 gcv.ts_y_origin = -sy; 1106 gcv.ts_y_origin = -sy;
1291 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); 1107 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1292 1108
1293 if (gc) 1109 if (gc)
1294 { 1110 {
1295 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height); 1111 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1296 result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS); 1112 ret = true;
1297 XFreeGC (dpy, gc); 1113 bool need_blur = h_blurRadius && v_blurRadius;
1114 bool need_tint = shade != 100 || (bg_flags & BG_TINT_SET);
1298 1115
1299 if (!(bg_flags & BG_CLIENT_RENDER)) 1116 if (!(bg_flags & BG_CLIENT_RENDER))
1300 { 1117 {
1301 if ((bg_flags & BG_NEEDS_BLUR) 1118 if (need_blur)
1302 && (bg_flags & BG_HAS_RENDER_CONV))
1303 { 1119 {
1304 if (blur_pixmap (bg_pixmap, visual, window_width, window_height)) 1120 if (blur_pixmap (bg_pixmap, window_width, window_height))
1305 result &= ~BG_NEEDS_BLUR; 1121 need_blur = false;
1306 } 1122 }
1307 if ((bg_flags & BG_NEEDS_TINT) 1123 if (need_tint)
1308 && (bg_flags & (BG_TINT_BITAND | BG_HAS_RENDER)))
1309 { 1124 {
1310 if (tint_pixmap (bg_pixmap, visual, window_width, window_height)) 1125 if (tint_pixmap (bg_pixmap, window_width, window_height))
1311 result &= ~BG_NEEDS_TINT; 1126 need_tint = false;
1127 }
1128 if (need_tint)
1129 {
1130 XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1131 if (ximage)
1132 {
1133 /* our own client-side tinting */
1134 tint_ximage (ximage);
1135
1136 XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
1137 XDestroyImage (ximage);
1138 }
1312 } 1139 }
1313 } /* server side rendering completed */ 1140 } /* server side rendering completed */
1141
1142 XFreeGC (dpy, gc);
1314 } 1143 }
1315 1144
1316 if (recoded_root_pmap != root_pixmap) 1145 if (recoded_root_pmap != root_pixmap)
1317 XFreePixmap (dpy, recoded_root_pmap); 1146 XFreePixmap (dpy, recoded_root_pmap);
1318 1147
1319 return result; 1148 return ret;
1320} 1149}
1321 1150
1322void 1151void
1323rxvt_term::bg_set_root_pixmap () 1152rxvt_term::bg_set_root_pixmap ()
1324{ 1153{
… …
1328 1157
1329 root_pixmap = new_root_pixmap; 1158 root_pixmap = new_root_pixmap;
1330} 1159}
1331# endif /* ENABLE_TRANSPARENCY */ 1160# endif /* ENABLE_TRANSPARENCY */
1332 1161
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 1162bool
1338rxvt_term::bg_render () 1163rxvt_term::bg_render ()
1339{ 1164{
1340 unsigned long tr_flags = 0;
1341
1342 bg_invalidate (); 1165 bg_invalidate ();
1343# ifdef ENABLE_TRANSPARENCY 1166# ifdef ENABLE_TRANSPARENCY
1344 if (bg_flags & BG_IS_TRANSPARENT) 1167 if (bg_flags & BG_IS_TRANSPARENT)
1345 { 1168 {
1346 /* we need to re-generate transparency pixmap in that case ! */ 1169 /* we need to re-generate transparency pixmap in that case ! */
1347 tr_flags = make_transparency_pixmap (); 1170 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; 1171 bg_flags |= BG_IS_VALID;
1352 } 1172 }
1353# endif 1173# endif
1354 1174
1355# ifdef BG_IMAGE_FROM_FILE 1175# ifdef BG_IMAGE_FROM_FILE
1356 if ((bg_flags & BG_IS_FROM_FILE) 1176 for (vector<rxvt_image>::iterator bg_image = image_vec.begin (); bg_image < image_vec.end (); bg_image++)
1357 || (tr_flags & BG_EFFECTS_FLAGS))
1358 { 1177 {
1359 if (render_image (tr_flags)) 1178 if (render_image (*bg_image))
1360 bg_flags |= BG_IS_VALID; 1179 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 } 1180 }
1395# endif 1181# endif
1396 1182
1397 if (!(bg_flags & BG_IS_VALID)) 1183 if (!(bg_flags & BG_IS_VALID))
1398 { 1184 {
… …
1431 bg_flags |= BG_HAS_RENDER_CONV; 1217 bg_flags |= BG_HAS_RENDER_CONV;
1432 1218
1433 XFree (filters); 1219 XFree (filters);
1434 } 1220 }
1435#endif 1221#endif
1222
1223#ifdef BG_IMAGE_FROM_FILE
1224 if (rs[Rs_backgroundPixmap])
1225 {
1226 rxvt_image *image = new_image ();
1227 if (!image->set_file_geometry (rs[Rs_backgroundPixmap]))
1228 image_vec.pop_back ();
1229 }
1230
1231# ifndef NO_RESOURCES
1232 find_resources ("image", "Image", XrmEnumAllLevels, rxvt_define_image);
1233 vector<rxvt_image>::iterator bg_image = image_vec.begin ();
1234 while (bg_image != image_vec.end ())
1235 {
1236 if (!(bg_image->flags & IM_IS_SET))
1237 bg_image = image_vec.erase (bg_image);
1238 else
1239 bg_image++;
1240 }
1241# endif
1242
1243 if (image_vec.size () > 0
1244 && !bg_window_position_sensitive ())
1245 update_background ();
1246#endif
1436} 1247}
1437 1248
1438#endif /* HAVE_BG_PIXMAP */ 1249#endif /* HAVE_BG_PIXMAP */
1439 1250
1440#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) 1251#ifdef ENABLE_TRANSPARENCY
1441/* taken from aterm-0.4.2 */ 1252/* based on code from aterm-0.4.2 */
1442 1253
1443static void 1254static inline void
1444shade_ximage (Visual *visual, XImage *ximage, int shade, const rgba &c) 1255fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
1445{ 1256{
1257 for (int i = 0; i <= mask >> sh; i++)
1258 {
1259 uint32_t tmp;
1260 tmp = i * high;
1261 tmp += (mask >> sh) * low;
1262 lookup[i] = (tmp / 0xffff) << sh;
1263 }
1264}
1265
1266void
1267rxvt_term::tint_ximage (XImage *ximage)
1268{
1269 unsigned int size_r, size_g, size_b;
1446 int sh_r, sh_g, sh_b; 1270 int sh_r, sh_g, sh_b;
1447 uint32_t mask_r, mask_g, mask_b; 1271 uint32_t mask_r, mask_g, mask_b;
1448 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b; 1272 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1449 rgba low; 1273 unsigned short low;
1450 rgba high;
1451 int i;
1452 int host_byte_order = byteorder::big_endian () ? MSBFirst : LSBFirst; 1274 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1453 1275
1454 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return; 1276 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;
1455 1277
1456 /* for convenience */ 1278 /* for convenience */
1457 mask_r = visual->red_mask; 1279 mask_r = visual->red_mask;
1458 mask_g = visual->green_mask; 1280 mask_g = visual->green_mask;
1459 mask_b = visual->blue_mask; 1281 mask_b = visual->blue_mask;
1460 1282
1461 /* boring lookup table pre-initialization */ 1283 /* boring lookup table pre-initialization */
1462 switch (ximage->depth) 1284 sh_r = ecb_ctz32 (mask_r);
1463 { 1285 sh_g = ecb_ctz32 (mask_g);
1464 case 15: 1286 sh_b = ecb_ctz32 (mask_b);
1465 if ((mask_r != 0x7c00) || 1287
1466 (mask_g != 0x03e0) || 1288 size_r = mask_r >> sh_r;
1467 (mask_b != 0x001f)) 1289 size_g = mask_g >> sh_g;
1290 size_b = mask_b >> sh_b;
1291
1292 if (size_r++ > 255 || size_g++ > 255 || size_b++ > 255)
1468 return; 1293 return;
1469 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+32+32)); 1294
1295 lookup = (uint32_t *)malloc (sizeof (uint32_t) * (size_r + size_g + size_b));
1470 lookup_r = lookup; 1296 lookup_r = lookup;
1471 lookup_g = lookup+32; 1297 lookup_g = lookup + size_r;
1472 lookup_b = lookup+32+32; 1298 lookup_b = lookup + size_r + size_g;
1473 sh_r = 10; 1299
1474 sh_g = 5; 1300 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1475 sh_b = 0; 1301
1476 break; 1302 if (bg_flags & BG_TINT_SET)
1477 case 16: 1303 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 1304
1520 /* prepare limits for color transformation (each channel is handled separately) */ 1305 /* prepare limits for color transformation (each channel is handled separately) */
1521 if (shade > 100) 1306 if (shade > 100)
1522 { 1307 {
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; 1308 c.r = c.r * (200 - shade) / 100;
1530 low.g = 65535 * (100 - shade) / 100; 1309 c.g = c.g * (200 - shade) / 100;
1531 low.b = 65535 * (100 - shade) / 100; 1310 c.b = c.b * (200 - shade) / 100;
1311
1312 low = 0xffff * (shade - 100) / 100;
1532 } 1313 }
1533 else 1314 else
1534 { 1315 {
1535 high.r = c.r * shade / 100; 1316 c.r = c.r * shade / 100;
1536 high.g = c.g * shade / 100; 1317 c.g = c.g * shade / 100;
1537 high.b = c.b * shade / 100; 1318 c.b = c.b * shade / 100;
1538 1319
1539 low.r = low.g = low.b = 0; 1320 low = 0;
1540 } 1321 }
1541 1322
1542 /* fill our lookup tables */ 1323 /* fill our lookup tables */
1543 for (i = 0; i <= mask_r>>sh_r; i++) 1324 fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1544 { 1325 fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1545 uint32_t tmp; 1326 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 1327
1565 /* apply table to input image (replacing colors by newly calculated ones) */ 1328 /* apply table to input image (replacing colors by newly calculated ones) */
1566 if (ximage->bits_per_pixel == 32 1329 if (ximage->bits_per_pixel == 32
1567 && (ximage->depth == 24 || ximage->depth == 32)
1568 && ximage->byte_order == host_byte_order) 1330 && ximage->byte_order == host_byte_order)
1569 { 1331 {
1570 uint32_t *p1, *pf, *p, *pl; 1332 char *line = ximage->data;
1571 p1 = (uint32_t *) ximage->data;
1572 pf = (uint32_t *) (ximage->data + ximage->height * ximage->bytes_per_line);
1573 1333
1574 while (p1 < pf) 1334 for (int y = 0; y < ximage->height; y++)
1575 { 1335 {
1576 p = p1; 1336 uint32_t *p = (uint32_t *)line;
1577 pl = p1 + ximage->width; 1337 for (int x = 0; x < ximage->width; x++)
1578 for (; p < pl; p++)
1579 { 1338 {
1580 *p = lookup_r[(*p & 0xff0000) >> 16] | 1339 *p = lookup_r[(*p & mask_r) >> sh_r] |
1581 lookup_g[(*p & 0x00ff00) >> 8] | 1340 lookup_g[(*p & mask_g) >> sh_g] |
1582 lookup_b[(*p & 0x0000ff)] | 1341 lookup_b[(*p & mask_b) >> sh_b];
1583 (*p & 0xff000000); 1342 p++;
1584 } 1343 }
1585 p1 = (uint32_t *) ((char *) p1 + ximage->bytes_per_line); 1344 line += ximage->bytes_per_line;
1586 } 1345 }
1587 } 1346 }
1588 else 1347 else
1589 { 1348 {
1590 for (int y = 0; y < ximage->height; y++) 1349 for (int y = 0; y < ximage->height; y++)
… …
1598 } 1357 }
1599 } 1358 }
1600 1359
1601 free (lookup); 1360 free (lookup);
1602} 1361}
1603#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */ 1362#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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