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

Diff Legend

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