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.222 by sf-exg, Sat May 26 08:10:25 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 if (image_vec.size () < id + 1)
680 image_vec.resize (id + 1);
681
682 rxvt_image *image = &image_vec[id];
683}
684# endif
685
686rxvt_image::rxvt_image ()
687{
688 alpha =
689 flags =
690 h_scale =
691 v_scale =
692 h_align =
693 v_align = 0;
694
695# ifdef HAVE_PIXBUF
696 pixbuf = 0;
697# endif
698}
699
863bool 700bool
864rxvt_term::bg_set_file (const char *file) 701rxvt_image::set_file_geometry (const char *file)
865{ 702{
866 if (!file || !*file) 703 if (!file || !*file)
867 return false; 704 return false;
868 705
869 bool ret = false;
870 const char *p = strchr (file, ';'); 706 const char *p = strchr (file, ';');
871 707
872 if (p) 708 if (p)
873 { 709 {
874 size_t len = p - file; 710 size_t len = p - file;
… …
876 memcpy (f, file, len); 712 memcpy (f, file, len);
877 f[len] = '\0'; 713 f[len] = '\0';
878 file = f; 714 file = f;
879 } 715 }
880 716
881# ifdef HAVE_AFTERIMAGE 717 bool ret = set_file (file);
882 if (!asimman) 718 alpha = 0x8000;
883 asimman = create_generic_imageman (rs[Rs_path]); 719 if (ret && p)
884 ASImage *image = get_asimage (asimman, file, 0xFFFFFFFF, 100); 720 set_geometry (p + 1);
885 if (image) 721 return ret;
886 { 722}
887 if (original_asim) 723
888 safe_asimage_destroy (original_asim); 724bool
889 original_asim = image; 725rxvt_image::set_file (const char *file)
890 bg_flags |= BG_IS_FROM_FILE | BG_CLIENT_RENDER; 726{
891 ret = true; 727 bool ret = false;
892 }
893# endif
894 728
895# ifdef HAVE_PIXBUF 729# ifdef HAVE_PIXBUF
896 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL); 730 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
897 if (image) 731 if (image)
898 { 732 {
899 if (pixbuf) 733 if (pixbuf)
900 g_object_unref (pixbuf); 734 g_object_unref (pixbuf);
901 pixbuf = image; 735 pixbuf = image;
902 bg_flags |= BG_IS_FROM_FILE;
903 ret = true; 736 ret = true;
904 } 737 }
905# endif 738# endif
906 739
907 if (ret) 740 if (ret)
908 { 741 {
909 if (p) 742 alpha = 0xffff;
910 bg_set_geometry (p + 1); 743 flags = IM_IS_SET | IM_IS_SIZE_SENSITIVE;
911 else 744 h_scale = v_scale = defaultScale;
912 bg_set_default_geometry (); 745 h_align = v_align = defaultAlign;
913 } 746 }
914 747
915 return ret; 748 return ret;
916} 749}
917 750
918# endif /* BG_IMAGE_FROM_FILE */ 751# endif /* BG_IMAGE_FROM_FILE */
919 752
920# ifdef ENABLE_TRANSPARENCY 753# 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 754bool
934rxvt_term::bg_set_blur (const char *geom) 755rxvt_term::bg_set_blur (const char *geom)
935{ 756{
936 bool changed = false; 757 bool changed = false;
937 unsigned int hr, vr; 758 unsigned int hr, vr;
… …
956 { 777 {
957 changed = true; 778 changed = true;
958 v_blurRadius = vr; 779 v_blurRadius = vr;
959 } 780 }
960 781
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; 782 return changed;
967} 783}
968 784
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 785bool
993rxvt_term::bg_set_tint (rxvt_color &new_tint) 786rxvt_term::bg_set_tint (rxvt_color &new_tint)
994{ 787{
995 if (tint != new_tint) 788 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
996 { 789 {
997 tint = new_tint; 790 tint = new_tint;
998 set_tint_shade_flags (); 791 bg_flags |= BG_TINT_SET;
792
793 rgba c;
794 tint.get (c);
795 if ((c.r <= 0x00ff || c.r >= 0xff00)
796 && (c.g <= 0x00ff || c.g >= 0xff00)
797 && (c.b <= 0x00ff || c.b >= 0xff00))
798 bg_flags |= BG_TINT_BITAND;
799 else
800 bg_flags &= ~BG_TINT_BITAND;
801
999 return true; 802 return true;
1000 } 803 }
1001 804
1002 return false; 805 return false;
1003} 806}
… …
1012 new_shade = 200 - (100 + new_shade); 815 new_shade = 200 - (100 + new_shade);
1013 816
1014 if (new_shade != shade) 817 if (new_shade != shade)
1015 { 818 {
1016 shade = new_shade; 819 shade = new_shade;
1017 set_tint_shade_flags ();
1018 return true; 820 return true;
1019 } 821 }
1020 822
1021 return false; 823 return false;
1022} 824}
… …
1043 params[i+2] = XDoubleToFixed (kernel[i] / sum); 845 params[i+2] = XDoubleToFixed (kernel[i] / sum);
1044} 846}
1045#endif 847#endif
1046 848
1047bool 849bool
1048rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 850rxvt_term::blur_pixmap (Pixmap pixmap, int width, int height)
1049{ 851{
1050 bool ret = false; 852 bool ret = false;
1051#if XRENDER 853#if XRENDER
1052 if (!(bg_flags & BG_HAS_RENDER_CONV)) 854 if (!(bg_flags & BG_HAS_RENDER_CONV))
1053 return false; 855 return false;
1054 856
1055 int size = max (h_blurRadius, v_blurRadius) * 2 + 1; 857 int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1056 double *kernel = (double *)malloc (size * sizeof (double)); 858 double *kernel = (double *)malloc (size * sizeof (double));
1057 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 859 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1058 860
861 XRenderPictureAttributes pa;
1059 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 862 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1060 863
864 pa.repeat = RepeatPad;
1061 Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, 0); 865 Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
866 Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1062 Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, 0); 867 Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
868 XFreePixmap (dpy, tmp);
1063 869
1064 if (kernel && params) 870 if (kernel && params)
1065 { 871 {
1066 if (h_blurRadius)
1067 {
1068 size = h_blurRadius * 2 + 1; 872 size = h_blurRadius * 2 + 1;
1069 get_gaussian_kernel (h_blurRadius, size, kernel, params); 873 get_gaussian_kernel (h_blurRadius, size, kernel, params);
1070 874
1071 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 875 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1072 XRenderComposite (dpy, 876 XRenderComposite (dpy,
1073 PictOpSrc, 877 PictOpSrc,
1074 src, 878 src,
1075 None, 879 None,
1076 dst, 880 dst,
1077 0, 0, 881 0, 0,
1078 0, 0, 882 0, 0,
1079 0, 0, 883 0, 0,
1080 width, height); 884 width, height);
1081 }
1082 885
1083 if (v_blurRadius) 886 ::swap (src, dst);
1084 { 887
1085 size = v_blurRadius * 2 + 1; 888 size = v_blurRadius * 2 + 1;
1086 get_gaussian_kernel (v_blurRadius, size, kernel, params); 889 get_gaussian_kernel (v_blurRadius, size, kernel, params);
1087 ::swap (params[0], params[1]); 890 ::swap (params[0], params[1]);
1088 891
1089 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 892 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1090 XRenderComposite (dpy, 893 XRenderComposite (dpy,
1091 PictOpSrc, 894 PictOpSrc,
1092 src, 895 src,
1093 None, 896 None,
1094 dst, 897 dst,
1095 0, 0, 898 0, 0,
1096 0, 0, 899 0, 0,
1097 0, 0, 900 0, 0,
1098 width, height); 901 width, height);
1099 }
1100 902
1101 ret = true; 903 ret = true;
1102 } 904 }
1103 905
1104 free (kernel); 906 free (kernel);
… …
1108#endif 910#endif
1109 return ret; 911 return ret;
1110} 912}
1111 913
1112bool 914bool
1113rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 915rxvt_term::tint_pixmap (Pixmap pixmap, int width, int height)
1114{ 916{
1115 bool ret = false; 917 bool ret = false;
1116 918
1117 if (bg_flags & BG_TINT_BITAND) 919 if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1118 { 920 {
1119 XGCValues gcv; 921 XGCValues gcv;
1120 GC gc; 922 GC gc;
1121 923
1122 /* In this case we can tint image server-side getting significant 924 /* In this case we can tint image server-side getting significant
… …
1134 } 936 }
1135 } 937 }
1136# if XRENDER 938# if XRENDER
1137 else if (bg_flags & BG_HAS_RENDER) 939 else if (bg_flags & BG_HAS_RENDER)
1138 { 940 {
1139 rgba c; 941 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1140 942
943 if (bg_flags & BG_TINT_SET)
1141 tint.get (c); 944 tint.get (c);
1142 945
1143 if (shade <= 100) 946 if (shade <= 100)
1144 { 947 {
1145 c.r = c.r * shade / 100; 948 c.r = c.r * shade / 100;
1146 c.g = c.g * shade / 100; 949 c.g = c.g * shade / 100;
… …
1202/* 1005/*
1203 * Builds a pixmap of the same size as the terminal window that contains 1006 * Builds a pixmap of the same size as the terminal window that contains
1204 * the tiled portion of the root pixmap that is supposed to be covered by 1007 * the tiled portion of the root pixmap that is supposed to be covered by
1205 * our window. 1008 * our window.
1206 */ 1009 */
1207unsigned long 1010bool
1208rxvt_term::make_transparency_pixmap () 1011rxvt_term::make_transparency_pixmap ()
1209{ 1012{
1210 unsigned long result = 0; 1013 bool ret = false;
1211 1014
1212 /* root dimensions may change from call to call - but Display structure should 1015 /* root dimensions may change from call to call - but Display structure should
1213 * be always up-to-date, so let's use it : 1016 * be always up-to-date, so let's use it :
1214 */ 1017 */
1215 int screen = display->screen; 1018 int screen = display->screen;
… …
1296 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); 1099 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1297 1100
1298 if (gc) 1101 if (gc)
1299 { 1102 {
1300 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height); 1103 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1301 result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS); 1104 ret = true;
1105 bool need_blur = h_blurRadius && v_blurRadius;
1106 bool need_tint = shade != 100 || (bg_flags & BG_TINT_SET);
1302 1107
1303 if (!(bg_flags & BG_CLIENT_RENDER)) 1108 if (!(bg_flags & BG_CLIENT_RENDER))
1304 { 1109 {
1305 if (bg_flags & BG_NEEDS_BLUR) 1110 if (need_blur)
1306 { 1111 {
1307 if (blur_pixmap (bg_pixmap, visual, window_width, window_height)) 1112 if (blur_pixmap (bg_pixmap, window_width, window_height))
1308 result &= ~BG_NEEDS_BLUR; 1113 need_blur = false;
1309 } 1114 }
1310 if (bg_flags & BG_NEEDS_TINT) 1115 if (need_tint)
1311 { 1116 {
1312 if (tint_pixmap (bg_pixmap, visual, window_width, window_height)) 1117 if (tint_pixmap (bg_pixmap, window_width, window_height))
1313 result &= ~BG_NEEDS_TINT; 1118 need_tint = false;
1314 } 1119 }
1315# ifndef HAVE_AFTERIMAGE 1120 if (need_tint)
1316 if (result & BG_NEEDS_TINT)
1317 { 1121 {
1318 XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap); 1122 XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1319 if (ximage) 1123 if (ximage)
1320 { 1124 {
1321 /* our own client-side tinting */ 1125 /* our own client-side tinting */
1322 tint_ximage (DefaultVisual (dpy, display->screen), ximage); 1126 tint_ximage (ximage);
1323 1127
1324 XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height); 1128 XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
1325 XDestroyImage (ximage); 1129 XDestroyImage (ximage);
1326 } 1130 }
1327 } 1131 }
1328# endif
1329 } /* server side rendering completed */ 1132 } /* server side rendering completed */
1330 1133
1331 XFreeGC (dpy, gc); 1134 XFreeGC (dpy, gc);
1332 } 1135 }
1333 1136
1334 if (recoded_root_pmap != root_pixmap) 1137 if (recoded_root_pmap != root_pixmap)
1335 XFreePixmap (dpy, recoded_root_pmap); 1138 XFreePixmap (dpy, recoded_root_pmap);
1336 1139
1337 return result; 1140 return ret;
1338} 1141}
1339 1142
1340void 1143void
1341rxvt_term::bg_set_root_pixmap () 1144rxvt_term::bg_set_root_pixmap ()
1342{ 1145{
… …
1349# endif /* ENABLE_TRANSPARENCY */ 1152# endif /* ENABLE_TRANSPARENCY */
1350 1153
1351bool 1154bool
1352rxvt_term::bg_render () 1155rxvt_term::bg_render ()
1353{ 1156{
1354 unsigned long tr_flags = 0;
1355
1356 bg_invalidate (); 1157 bg_invalidate ();
1357# ifdef ENABLE_TRANSPARENCY 1158# ifdef ENABLE_TRANSPARENCY
1358 if (bg_flags & BG_IS_TRANSPARENT) 1159 if (bg_flags & BG_IS_TRANSPARENT)
1359 { 1160 {
1360 /* we need to re-generate transparency pixmap in that case ! */ 1161 /* we need to re-generate transparency pixmap in that case ! */
1361 tr_flags = make_transparency_pixmap (); 1162 if (make_transparency_pixmap ())
1362 if (tr_flags == 0)
1363 return false;
1364 bg_flags |= BG_IS_VALID; 1163 bg_flags |= BG_IS_VALID;
1365 } 1164 }
1366# endif 1165# endif
1367 1166
1368# ifdef BG_IMAGE_FROM_FILE 1167# ifdef BG_IMAGE_FROM_FILE
1369 if ((bg_flags & BG_IS_FROM_FILE) 1168 for (vector<rxvt_image>::iterator bg_image = image_vec.begin (); bg_image < image_vec.end (); bg_image++)
1370 || (tr_flags & BG_EFFECTS_FLAGS))
1371 { 1169 {
1372 if (render_image (tr_flags)) 1170 if (render_image (*bg_image))
1373 bg_flags |= BG_IS_VALID; 1171 bg_flags |= BG_IS_VALID;
1374 } 1172 }
1375# endif 1173# endif
1376 1174
1377 if (!(bg_flags & BG_IS_VALID)) 1175 if (!(bg_flags & BG_IS_VALID))
… …
1393 1191
1394void 1192void
1395rxvt_term::bg_init () 1193rxvt_term::bg_init ()
1396{ 1194{
1397#ifdef ENABLE_TRANSPARENCY 1195#ifdef ENABLE_TRANSPARENCY
1398 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1399 tint.set (this, c);
1400 shade = 100; 1196 shade = 100;
1401#endif 1197#endif
1402 1198
1403 bg_flags &= ~(BG_HAS_RENDER | BG_HAS_RENDER_CONV); 1199 bg_flags &= ~(BG_HAS_RENDER | BG_HAS_RENDER_CONV);
1404#if XRENDER 1200#if XRENDER
… …
1413 bg_flags |= BG_HAS_RENDER_CONV; 1209 bg_flags |= BG_HAS_RENDER_CONV;
1414 1210
1415 XFree (filters); 1211 XFree (filters);
1416 } 1212 }
1417#endif 1213#endif
1214
1215#ifdef BG_IMAGE_FROM_FILE
1216 if (rs[Rs_backgroundPixmap])
1217 {
1218 rxvt_image *image = new_image ();
1219 if (!image->set_file_geometry (rs[Rs_backgroundPixmap]))
1220 image_vec.pop_back ();
1221 }
1222
1223# ifndef NO_RESOURCES
1224 find_resources ("image", "Image", XrmEnumAllLevels, rxvt_define_image);
1225 vector<rxvt_image>::iterator bg_image = image_vec.begin ();
1226 while (bg_image != image_vec.end ())
1227 {
1228 if (!(bg_image->flags & IM_IS_SET))
1229 bg_image = image_vec.erase (bg_image);
1230 else
1231 bg_image++;
1232 }
1233# endif
1234
1235 if (image_vec.size () > 0
1236 && !bg_window_position_sensitive ())
1237 update_background ();
1238#endif
1418} 1239}
1419 1240
1420#endif /* HAVE_BG_PIXMAP */ 1241#endif /* HAVE_BG_PIXMAP */
1421 1242
1422#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) 1243#ifdef ENABLE_TRANSPARENCY
1423/* based on code from aterm-0.4.2 */ 1244/* based on code from aterm-0.4.2 */
1424 1245
1425static inline void 1246static inline void
1426fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high) 1247fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
1427{ 1248{
… …
1433 lookup[i] = (tmp / 0xffff) << sh; 1254 lookup[i] = (tmp / 0xffff) << sh;
1434 } 1255 }
1435} 1256}
1436 1257
1437void 1258void
1438rxvt_term::tint_ximage (Visual *visual, XImage *ximage) 1259rxvt_term::tint_ximage (XImage *ximage)
1439{ 1260{
1261 unsigned int size_r, size_g, size_b;
1440 int sh_r, sh_g, sh_b; 1262 int sh_r, sh_g, sh_b;
1441 uint32_t mask_r, mask_g, mask_b; 1263 uint32_t mask_r, mask_g, mask_b;
1442 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b; 1264 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1443 unsigned short low; 1265 unsigned short low;
1444 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst; 1266 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
… …
1449 mask_r = visual->red_mask; 1271 mask_r = visual->red_mask;
1450 mask_g = visual->green_mask; 1272 mask_g = visual->green_mask;
1451 mask_b = visual->blue_mask; 1273 mask_b = visual->blue_mask;
1452 1274
1453 /* boring lookup table pre-initialization */ 1275 /* boring lookup table pre-initialization */
1454 switch (ximage->depth) 1276 sh_r = ecb_ctz32 (mask_r);
1455 { 1277 sh_g = ecb_ctz32 (mask_g);
1456 case 15: 1278 sh_b = ecb_ctz32 (mask_b);
1457 if ((mask_r != 0x7c00) || 1279
1458 (mask_g != 0x03e0) || 1280 size_r = mask_r >> sh_r;
1459 (mask_b != 0x001f)) 1281 size_g = mask_g >> sh_g;
1282 size_b = mask_b >> sh_b;
1283
1284 if (size_r++ > 255 || size_g++ > 255 || size_b++ > 255)
1460 return; 1285 return;
1461 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+32+32)); 1286
1287 lookup = (uint32_t *)malloc (sizeof (uint32_t) * (size_r + size_g + size_b));
1462 lookup_r = lookup; 1288 lookup_r = lookup;
1463 lookup_g = lookup+32; 1289 lookup_g = lookup + size_r;
1464 lookup_b = lookup+32+32; 1290 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 1291
1512 rgba c; 1292 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1513 1293
1294 if (bg_flags & BG_TINT_SET)
1514 tint.get (c); 1295 tint.get (c);
1515 1296
1516 /* prepare limits for color transformation (each channel is handled separately) */ 1297 /* prepare limits for color transformation (each channel is handled separately) */
1517 if (shade > 100) 1298 if (shade > 100)
1518 { 1299 {
1519 c.r = c.r * (200 - shade) / 100; 1300 c.r = c.r * (200 - shade) / 100;
… …
1536 fill_lut (lookup_g, mask_g, sh_g, low, c.g); 1317 fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1537 fill_lut (lookup_b, mask_b, sh_b, low, c.b); 1318 fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1538 1319
1539 /* apply table to input image (replacing colors by newly calculated ones) */ 1320 /* apply table to input image (replacing colors by newly calculated ones) */
1540 if (ximage->bits_per_pixel == 32 1321 if (ximage->bits_per_pixel == 32
1541 && (ximage->depth == 24 || ximage->depth == 32)
1542 && ximage->byte_order == host_byte_order) 1322 && ximage->byte_order == host_byte_order)
1543 { 1323 {
1544 uint32_t *p1, *pf, *p, *pl; 1324 char *line = ximage->data;
1545 p1 = (uint32_t *) ximage->data;
1546 pf = (uint32_t *) (ximage->data + ximage->height * ximage->bytes_per_line);
1547 1325
1548 while (p1 < pf) 1326 for (int y = 0; y < ximage->height; y++)
1549 { 1327 {
1550 p = p1; 1328 uint32_t *p = (uint32_t *)line;
1551 pl = p1 + ximage->width; 1329 for (int x = 0; x < ximage->width; x++)
1552 for (; p < pl; p++)
1553 { 1330 {
1554 *p = lookup_r[(*p & 0xff0000) >> 16] | 1331 *p = lookup_r[(*p & mask_r) >> sh_r] |
1555 lookup_g[(*p & 0x00ff00) >> 8] | 1332 lookup_g[(*p & mask_g) >> sh_g] |
1556 lookup_b[(*p & 0x0000ff)] | 1333 lookup_b[(*p & mask_b) >> sh_b];
1557 (*p & 0xff000000); 1334 p++;
1558 } 1335 }
1559 p1 = (uint32_t *) ((char *) p1 + ximage->bytes_per_line); 1336 line += ximage->bytes_per_line;
1560 } 1337 }
1561 } 1338 }
1562 else 1339 else
1563 { 1340 {
1564 for (int y = 0; y < ximage->height; y++) 1341 for (int y = 0; y < ximage->height; y++)
… …
1572 } 1349 }
1573 } 1350 }
1574 1351
1575 free (lookup); 1352 free (lookup);
1576} 1353}
1577#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */ 1354#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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