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.162 by sf-exg, Thu Aug 11 12:27:26 2011 UTC vs.
Revision 1.209 by sf-exg, Fri May 11 12:21:22 2012 UTC

… …
3 *----------------------------------------------------------------------* 3 *----------------------------------------------------------------------*
4 * 4 *
5 * All portions of code are copyright by their respective author/s. 5 * All portions of code are copyright by their respective author/s.
6 * Copyright (c) 2005-2008 Marc Lehmann <schmorp@schmorp.de> 6 * Copyright (c) 2005-2008 Marc Lehmann <schmorp@schmorp.de>
7 * Copyright (c) 2007 Sasha Vasko <sasha@aftercode.net> 7 * Copyright (c) 2007 Sasha Vasko <sasha@aftercode.net>
8 * Copyright (c) 2010 Emanuele Giaquinta <e.giaquinta@glauco.it> 8 * Copyright (c) 2010-2012 Emanuele Giaquinta <e.giaquinta@glauco.it>
9 * 9 *
10 * This program is free software; you can redistribute it and/or modify 10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by 11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or 12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version. 13 * (at your option) any later version.
… …
20 * You should have received a copy of the GNU General Public License 20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software 21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 *---------------------------------------------------------------------*/ 23 *---------------------------------------------------------------------*/
24 24
25#include <cmath> 25#include <math.h>
26#include "../config.h" /* NECESSARY */ 26#include "../config.h" /* NECESSARY */
27#include "rxvt.h" /* NECESSARY */ 27#include "rxvt.h" /* NECESSARY */
28 28
29#if XRENDER 29#if XRENDER
30# include <X11/extensions/Xrender.h> 30# include <X11/extensions/Xrender.h>
… …
32 32
33#ifndef FilterConvolution 33#ifndef FilterConvolution
34#define FilterConvolution "convolution" 34#define FilterConvolution "convolution"
35#endif 35#endif
36 36
37/* 37#ifndef RepeatPad
38 * Pixmap geometry string interpretation : 38#define RepeatPad True
39 * Each geometry string contains zero or one scale/position 39#endif
40 * adjustment and may optionally be followed by a colon and one or more
41 * colon-delimited pixmap operations.
42 * The following table shows the valid geometry strings and their
43 * effects on the background image :
44 *
45 * WxH+X+Y Set scaling to W% by H%, and position to X% by Y%.
46 * W and H are percentages of the terminal window size.
47 * X and Y are also percentages; e.g., +50+50 centers
48 * the image in the window.
49 *
50 * Pixmap Operations : (should be prepended by a colon)
51 */
52 40
53#ifdef HAVE_BG_PIXMAP 41#ifdef HAVE_BG_PIXMAP
42# if XRENDER
43static Picture
44create_xrender_mask (Display *dpy, Drawable drawable, Bool argb, Bool component_alpha)
45{
46 Pixmap pixmap = XCreatePixmap (dpy, drawable, 1, 1, argb ? 32 : 8);
47
48 XRenderPictFormat *format = XRenderFindStandardFormat (dpy, argb ? PictStandardARGB32 : PictStandardA8);
49 XRenderPictureAttributes pa;
50 pa.repeat = True;
51 pa.component_alpha = component_alpha;
52 Picture mask = XRenderCreatePicture (dpy, pixmap, format, CPRepeat | CPComponentAlpha, &pa);
53
54 XFreePixmap (dpy, pixmap);
55
56 return mask;
57}
58# endif
59
54void 60void
55rxvt_term::bg_destroy () 61rxvt_term::bg_destroy ()
56{ 62{
57#ifdef HAVE_AFTERIMAGE
58 if (original_asim)
59 safe_asimage_destroy (original_asim);
60 if (asv)
61 destroy_asvisual (asv, 0);
62 if (asimman)
63 destroy_image_manager (asimman, 0);
64#endif
65
66#ifdef HAVE_PIXBUF 63#ifdef HAVE_PIXBUF
67 if (pixbuf) 64 if (pixbuf)
68 g_object_unref (pixbuf); 65 g_object_unref (pixbuf);
69#endif 66#endif
70 67
… …
123 120
124 return false; 121 return false;
125} 122}
126 123
127# ifdef BG_IMAGE_FROM_FILE 124# ifdef BG_IMAGE_FROM_FILE
128static inline bool
129check_set_scale_value (int geom_flags, int flag, unsigned int &scale, unsigned int new_value)
130{
131 if (geom_flags & flag)
132 {
133 if (new_value > 1000)
134 new_value = 1000;
135 if (new_value != scale)
136 {
137 scale = new_value;
138 return true;
139 }
140 }
141 return false;
142}
143
144static inline bool
145check_set_align_value (int geom_flags, int flag, int &align, int new_value)
146{
147 if (geom_flags & flag)
148 {
149 if (new_value < -100)
150 new_value = -100;
151 else if (new_value > 200)
152 new_value = 200;
153 if (new_value != align)
154 {
155 align = new_value;
156 return true;
157 }
158 }
159 return false;
160}
161
162static inline int 125static inline int
163make_align_position (int align, int window_size, int image_size) 126make_align_position (int align, int window_size, int image_size)
164{ 127{
165 int diff = window_size - image_size;
166 int smaller = min (image_size, window_size);
167
168 if (align >= 0 && align <= 100) 128 if (align >= 0 && align <= 100)
169 return diff * align / 100; 129 return lerp (0, window_size - image_size, align);
170 else if (align > 100 && align <= 200) 130 else if (align > 100)
171 return ((align - 100) * smaller / 100) + window_size - smaller; 131 return lerp (window_size - image_size, window_size, align - 100);
172 else if (align >= -100 && align < 0) 132 else
173 return ((align + 100) * smaller / 100) - image_size; 133 return lerp (-image_size, 0, align + 100);
174 return 0;
175} 134}
176 135
177static inline int 136static inline int
178make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size) 137make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)
179{ 138{
… …
185 src_pos = -pos; 144 src_pos = -pos;
186 dst_pos = 0; 145 dst_pos = 0;
187 dst_size += pos; 146 dst_size += pos;
188 } 147 }
189 148
190 if (dst_pos + dst_size > target_size)
191 dst_size = target_size - dst_pos; 149 min_it (dst_size, target_size - dst_pos);
192 return src_pos; 150 return src_pos;
193} 151}
194 152
195bool 153bool
196rxvt_term::bg_set_geometry (const char *geom, bool update) 154rxvt_term::bg_set_geometry (const char *geom, bool update)
197{ 155{
198 bool changed = false; 156 bool changed = false;
199 int geom_flags = 0; 157 int geom_flags = 0;
200 int x = 0, y = 0; 158 int x = h_align;
159 int y = v_align;
201 unsigned int w = 0, h = 0; 160 unsigned int w = h_scale;
202 unsigned int n; 161 unsigned int h = v_scale;
203 unsigned long new_flags = (bg_flags & (~BG_GEOMETRY_FLAGS)); 162 unsigned long new_flags = 0;
204 const char *ops;
205 163
206 if (geom == NULL) 164 if (geom == NULL)
207 return false; 165 return false;
208 166
209 char str[256]; 167 if (geom[0])
210
211 ops = strchr (geom, ':');
212 if (ops == NULL)
213 n = strlen (geom);
214 else
215 n = ops - geom;
216
217 if (n >= sizeof (str))
218 return false;
219
220 memcpy (str, geom, n);
221 str[n] = '\0';
222 rxvt_strtrim (str);
223
224 if (str[0])
225 { 168 {
226 /* we have geometry string - let's handle it prior to applying ops */ 169 char **arr = rxvt_strsplit (':', geom);
170
171 for (int i = 0; arr[i]; i++)
172 {
173 if (!strcasecmp (arr[i], "style=tiled"))
174 {
175 new_flags = BG_TILE;
176 w = h = noScale;
177 x = y = 0;
178 geom_flags = WidthValue|HeightValue|XValue|YValue;
179 }
180 else if (!strcasecmp (arr[i], "style=aspect-stretched"))
181 {
182 new_flags = BG_KEEP_ASPECT;
183 w = h = windowScale;
184 x = y = centerAlign;
185 geom_flags = WidthValue|HeightValue|XValue|YValue;
186 }
187 else if (!strcasecmp (arr[i], "style=stretched"))
188 {
189 new_flags = 0;
190 w = h = windowScale;
191 geom_flags = WidthValue|HeightValue;
192 }
193 else if (!strcasecmp (arr[i], "style=centered"))
194 {
195 new_flags = 0;
196 w = h = noScale;
197 x = y = centerAlign;
198 geom_flags = WidthValue|HeightValue|XValue|YValue;
199 }
200 else if (!strcasecmp (arr[i], "style=root-tiled"))
201 {
202 new_flags = BG_TILE|BG_ROOT_ALIGN;
203 w = h = noScale;
204 geom_flags = WidthValue|HeightValue;
205 }
206 else if (!strcasecmp (arr[i], "op=tile"))
207 new_flags |= BG_TILE;
208 else if (!strcasecmp (arr[i], "op=keep-aspect"))
209 new_flags |= BG_KEEP_ASPECT;
210 else if (!strcasecmp (arr[i], "op=root-align"))
211 new_flags |= BG_ROOT_ALIGN;
212
213 // deprecated
214 else if (!strcasecmp (arr[i], "tile"))
215 {
216 new_flags |= BG_TILE;
217 w = h = noScale;
218 geom_flags |= WidthValue|HeightValue;
219 }
220 else if (!strcasecmp (arr[i], "propscale"))
221 {
222 new_flags |= BG_KEEP_ASPECT;
223 w = h = windowScale;
224 geom_flags |= WidthValue|HeightValue;
225 }
226 else if (!strcasecmp (arr[i], "hscale"))
227 {
228 new_flags |= BG_TILE;
229 w = windowScale;
230 h = noScale;
231 geom_flags |= WidthValue|HeightValue;
232 }
233 else if (!strcasecmp (arr[i], "vscale"))
234 {
235 new_flags |= BG_TILE;
236 h = windowScale;
237 w = noScale;
238 geom_flags |= WidthValue|HeightValue;
239 }
240 else if (!strcasecmp (arr[i], "scale"))
241 {
242 w = h = windowScale;
243 geom_flags |= WidthValue|HeightValue;
244 }
245 else if (!strcasecmp (arr[i], "auto"))
246 {
247 w = h = windowScale;
248 x = y = centerAlign;
249 geom_flags |= WidthValue|HeightValue|XValue|YValue;
250 }
251 else if (!strcasecmp (arr[i], "root"))
252 {
253 new_flags |= BG_TILE|BG_ROOT_ALIGN;
254 w = h = noScale;
255 geom_flags |= WidthValue|HeightValue;
256 }
257
258 else
227 geom_flags = XParseGeometry (str, &x, &y, &w, &h); 259 geom_flags |= XParseGeometry (arr[i], &x, &y, &w, &h);
228 } /* done parsing geometry string */ 260 } /* done parsing ops */
261
262 rxvt_free_strsplit (arr);
263 }
264
265 new_flags |= bg_flags & ~BG_GEOMETRY_FLAGS;
229 266
230 if (!update) 267 if (!update)
231 { 268 {
232 if (!(geom_flags & XValue)) 269 if (!(geom_flags & XValue))
233 x = y = defaultAlign; 270 x = y = defaultAlign;
… …
238 w = h = defaultScale; 275 w = h = defaultScale;
239 else if (!(geom_flags & HeightValue)) 276 else if (!(geom_flags & HeightValue))
240 h = w; 277 h = w;
241 else if (!(geom_flags & WidthValue)) 278 else if (!(geom_flags & WidthValue))
242 w = h; 279 w = h;
243
244 geom_flags |= WidthValue|HeightValue|XValue|YValue;
245 }
246
247 if (ops)
248 { 280 }
249 char **arr = rxvt_strsplit (':', ops + 1);
250 281
251 for (int i = 0; arr[i]; i++) 282 min_it (w, 1000);
252 { 283 min_it (h, 1000);
253 if (!strcasecmp (arr[i], "style=tiled")) 284 clamp_it (x, -100, 200);
254 { 285 clamp_it (y, -100, 200);
255 new_flags = BG_TILE;
256 w = h = noScale;
257 x = y = 0;
258 geom_flags = WidthValue|HeightValue|XValue|YValue;
259 }
260 else if (!strcasecmp (arr[i], "style=aspect-stretched"))
261 {
262 new_flags = BG_PROP_SCALE;
263 x = y = centerAlign;
264 geom_flags = XValue|YValue;
265 }
266 else if (!strcasecmp (arr[i], "style=stretched"))
267 {
268 new_flags = 0;
269 w = h = windowScale;
270 geom_flags = WidthValue|HeightValue;
271 }
272 else if (!strcasecmp (arr[i], "style=centered"))
273 {
274 new_flags = 0;
275 w = h = noScale;
276 x = y = centerAlign;
277 geom_flags = WidthValue|HeightValue|XValue|YValue;
278 }
279 else if (!strcasecmp (arr[i], "style=root-tiled"))
280 {
281 new_flags = BG_TILE|BG_ROOT_ALIGN;
282 w = h = noScale;
283 geom_flags = WidthValue|HeightValue;
284 }
285 else if (!strcasecmp (arr[i], "op=tile"))
286 new_flags |= BG_TILE;
287 else if (!strcasecmp (arr[i], "op=pscale"))
288 new_flags |= BG_PROP_SCALE;
289 else if (!strcasecmp (arr[i], "op=root"))
290 new_flags |= BG_ROOT_ALIGN;
291 286
292 // deprecated 287 if (bg_flags != new_flags
293 else if (!strcasecmp (arr[i], "tile")) 288 || h_scale != w
294 { 289 || v_scale != h
295 new_flags |= BG_TILE; 290 || h_align != x
296 w = h = noScale; 291 || v_align != y)
297 geom_flags |= WidthValue|HeightValue;
298 }
299 else if (!strcasecmp (arr[i], "propscale"))
300 {
301 new_flags |= BG_PROP_SCALE;
302 }
303 else if (!strcasecmp (arr[i], "hscale"))
304 {
305 new_flags |= BG_TILE;
306 w = windowScale;
307 h = noScale;
308 geom_flags |= WidthValue|HeightValue;
309 }
310 else if (!strcasecmp (arr[i], "vscale"))
311 {
312 new_flags |= BG_TILE;
313 h = windowScale;
314 w = noScale;
315 geom_flags |= WidthValue|HeightValue;
316 }
317 else if (!strcasecmp (arr[i], "scale"))
318 {
319 w = h = windowScale;
320 geom_flags |= WidthValue|HeightValue;
321 }
322 else if (!strcasecmp (arr[i], "auto"))
323 {
324 w = h = windowScale;
325 x = y = centerAlign;
326 geom_flags |= WidthValue|HeightValue|XValue|YValue;
327 }
328 else if (!strcasecmp (arr[i], "root"))
329 {
330 new_flags |= BG_TILE|BG_ROOT_ALIGN;
331 w = h = noScale;
332 geom_flags |= WidthValue|HeightValue;
333 }
334 } /* done parsing ops */
335
336 rxvt_free_strsplit (arr);
337 }
338
339 if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true;
340 if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true;
341 if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true;
342 if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true;
343
344 if (new_flags != bg_flags)
345 { 292 {
346 bg_flags = new_flags; 293 bg_flags = new_flags;
294 h_scale = w;
295 v_scale = h;
296 h_align = x;
297 v_align = y;
347 changed = true; 298 changed = true;
348 } 299 }
349 300
350 return changed; 301 return changed;
351} 302}
… …
354rxvt_term::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y) 305rxvt_term::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y)
355{ 306{
356 int target_width = szHint.width; 307 int target_width = szHint.width;
357 int target_height = szHint.height; 308 int target_height = szHint.height;
358 309
310 w = h_scale * target_width / 100;
311 h = v_scale * target_height / 100;
312
359 if (bg_flags & BG_PROP_SCALE) 313 if (bg_flags & BG_KEEP_ASPECT)
360 { 314 {
361 float scale = (float)target_width / image_width; 315 float scale = (float)w / image_width;
362 min_it (scale, (float)target_height / image_height); 316 min_it (scale, (float)h / image_height);
363 w = image_width * scale + 0.5; 317 w = image_width * scale + 0.5;
364 h = image_height * scale + 0.5; 318 h = image_height * scale + 0.5;
365 } 319 }
366 else
367 {
368 w = h_scale * target_width / 100;
369 h = v_scale * target_height / 100;
370 }
371 320
372 if (!w) w = image_width; 321 if (!w) w = image_width;
373 if (!h) h = image_height; 322 if (!h) h = image_height;
374 323
375 if (bg_flags & BG_ROOT_ALIGN) 324 if (bg_flags & BG_ROOT_ALIGN)
… …
381 { 330 {
382 x = make_align_position (h_align, target_width, w); 331 x = make_align_position (h_align, target_width, w);
383 y = make_align_position (v_align, target_height, h); 332 y = make_align_position (v_align, target_height, h);
384 } 333 }
385 334
386 bg_flags &= ~BG_IS_SIZE_SENSITIVE;
387 if (!(bg_flags & BG_TILE) 335 if (!(bg_flags & BG_TILE)
388 || (bg_flags & BG_PROP_SCALE) || h_scale || v_scale 336 || h_scale || v_scale
389 || (!(bg_flags & BG_ROOT_ALIGN) && (h_align || v_align)) 337 || (!(bg_flags & BG_ROOT_ALIGN) && (h_align || v_align))
390 || w > target_width || h > target_height) 338 || image_width > target_width || image_height > target_height)
391 bg_flags |= BG_IS_SIZE_SENSITIVE; 339 bg_flags |= BG_IS_SIZE_SENSITIVE;
392}
393
394# ifdef HAVE_AFTERIMAGE
395bool
396rxvt_term::render_image (unsigned long tr_flags)
397{
398 init_asv ();
399
400 ASImage *background = NULL;
401 ARGB32 background_tint = TINT_LEAVE_SAME;
402
403# ifdef ENABLE_TRANSPARENCY
404 if (tr_flags)
405 background = pixmap2ximage (asv, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, 100);
406
407 if (tr_flags & BG_NEEDS_TINT)
408 {
409 ShadingInfo as_shade;
410 as_shade.shading = shade;
411
412 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
413 if (bg_flags & BG_TINT_SET)
414 tint.get (c);
415 as_shade.tintColor.red = c.r;
416 as_shade.tintColor.green = c.g;
417 as_shade.tintColor.blue = c.b;
418
419 background_tint = shading2tint32 (&as_shade);
420 }
421
422 if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)
423 {
424 ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,
425 (original_asim == NULL || tint == TINT_LEAVE_SAME) ? ASA_XImage : ASA_ASImage,
426 100, ASIMAGE_QUALITY_DEFAULT);
427 if (tmp)
428 {
429 destroy_asimage (&background);
430 background = tmp;
431 }
432 }
433# endif
434
435 ASImage *result = 0;
436
437 int target_width = szHint.width;
438 int target_height = szHint.height;
439 int new_pmap_width = target_width;
440 int new_pmap_height = target_height;
441
442 int x = 0;
443 int y = 0;
444 int w = 0;
445 int h = 0;
446
447 if (original_asim)
448 get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
449
450 if (!original_asim
451 || (!(bg_flags & BG_ROOT_ALIGN)
452 && (x >= target_width
453 || y >= target_height
454 || (x + w <= 0)
455 || (y + h <= 0))))
456 {
457 if (background)
458 {
459 new_pmap_width = background->width;
460 new_pmap_height = background->height;
461 result = background;
462
463 if (background_tint != TINT_LEAVE_SAME)
464 {
465 ASImage *tmp = tile_asimage (asv, background, 0, 0,
466 target_width, target_height, background_tint,
467 ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
468 if (tmp)
469 result = tmp;
470 }
471 }
472 else
473 new_pmap_width = new_pmap_height = 0;
474 }
475 else 340 else
476 { 341 bg_flags &= ~BG_IS_SIZE_SENSITIVE;
477 result = original_asim;
478
479 if ((w != original_asim->width)
480 || (h != original_asim->height))
481 {
482 result = scale_asimage (asv, original_asim,
483 w, h,
484 background ? ASA_ASImage : ASA_XImage,
485 100, ASIMAGE_QUALITY_DEFAULT);
486 }
487
488 if (background == NULL)
489 {
490 if (bg_flags & BG_TILE)
491 {
492 /* if tiling - pixmap has to be sized exactly as the image,
493 but there is no need to make it bigger than the window! */
494 new_pmap_width = min (result->width, target_width);
495 new_pmap_height = min (result->height, target_height);
496
497 /* we also need to tile our image in both directions */
498 ASImage *tmp = tile_asimage (asv, result,
499 (int)result->width - x,
500 (int)result->height - y,
501 new_pmap_width,
502 new_pmap_height,
503 TINT_LEAVE_SAME, ASA_XImage,
504 100, ASIMAGE_QUALITY_DEFAULT);
505 if (tmp)
506 {
507 if (result != original_asim)
508 destroy_asimage (&result);
509
510 result = tmp;
511 }
512 }
513 }
514 else
515 {
516 /* if blending background and image - pixmap has to be sized same as target window */
517 ASImageLayer *layers = create_image_layers (2);
518
519 layers[0].im = background;
520 layers[0].clip_width = target_width;
521 layers[0].clip_height = target_height;
522 layers[0].tint = background_tint;
523 layers[1].im = result;
524
525 if (bg_flags & BG_TILE)
526 {
527 /* tile horizontally */
528 while (x > 0) x -= (int)result->width;
529 layers[1].dst_x = x;
530 layers[1].clip_width = result->width+target_width;
531 }
532 else
533 {
534 /* clip horizontally */
535 layers[1].dst_x = x;
536 layers[1].clip_width = result->width;
537 }
538
539 if (bg_flags & BG_TILE)
540 {
541 while (y > 0) y -= (int)result->height;
542 layers[1].dst_y = y;
543 layers[1].clip_height = result->height + target_height;
544 }
545 else
546 {
547 layers[1].dst_y = y;
548 layers[1].clip_height = result->height;
549 }
550
551 if (rs[Rs_blendtype])
552 {
553 layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
554 if (layers[1].merge_scanlines == NULL)
555 layers[1].merge_scanlines = alphablend_scanlines;
556 }
557
558 ASImage *tmp = merge_layers (asv, layers, 2, target_width, target_height,
559 ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
560
561 if (tmp)
562 {
563 if (result != original_asim)
564 destroy_asimage (&result);
565
566 result = tmp;
567 }
568
569 free (layers);
570 }
571 }
572
573 bool ret = false;
574
575 if (result)
576 {
577 XGCValues gcv;
578 GC gc;
579
580 /* create Pixmap */
581 if (bg_pixmap == None
582 || bg_pmap_width != new_pmap_width
583 || bg_pmap_height != new_pmap_height)
584 {
585 if (bg_pixmap)
586 XFreePixmap (dpy, bg_pixmap);
587 bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
588 bg_pmap_width = new_pmap_width;
589 bg_pmap_height = new_pmap_height;
590 }
591 /* fill with background color (if result's not completely overlapping it) */
592 gcv.foreground = pix_colors[Color_bg];
593 gc = XCreateGC (dpy, vt, GCForeground, &gcv);
594
595 int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
596 int dst_width = result->width, dst_height = result->height;
597 if (background == NULL)
598 {
599 if (!(bg_flags & BG_TILE))
600 {
601 src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );
602 src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
603 }
604
605 if (dst_x > 0 || dst_y > 0
606 || dst_x + dst_width < new_pmap_width
607 || dst_y + dst_height < new_pmap_height)
608 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
609 }
610
611 /* put result on pixmap */
612 if (dst_x < new_pmap_width && dst_y < new_pmap_height)
613 asimage2drawable (asv, bg_pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);
614
615 if (result != background && result != original_asim)
616 destroy_asimage (&result);
617
618 XFreeGC (dpy, gc);
619
620 ret = true;
621 }
622
623 if (background)
624 destroy_asimage (&background);
625
626 return ret;
627} 342}
628# endif /* HAVE_AFTERIMAGE */
629 343
630# ifdef HAVE_PIXBUF 344# ifdef HAVE_PIXBUF
631bool 345bool
632rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc, 346rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
633 int src_x, int src_y, int dst_x, int dst_y, 347 int src_x, int src_y, int dst_x, int dst_y,
634 unsigned int width, unsigned int height) 348 unsigned int width, unsigned int height)
635{ 349{
636 XImage *ximage; 350 XImage *ximage;
637 char *data, *line; 351 char *data, *line;
638 int bytes_per_pixel; 352 int bytes_per_pixel;
639 int width_r, width_g, width_b; 353 int width_r, width_g, width_b, width_a;
640 int sh_r, sh_g, sh_b; 354 int sh_r, sh_g, sh_b, sh_a;
355 uint32_t alpha_mask;
641 int rowstride; 356 int rowstride;
642 int channels; 357 int channels;
643 unsigned char *row; 358 unsigned char *row;
644 359
645 if (visual->c_class != TrueColor) 360 if (visual->c_class != TrueColor)
646 return false; 361 return false;
362
363#if XRENDER
364 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
365 if (format)
366 alpha_mask = (uint32_t)format->direct.alphaMask << format->direct.alpha;
367 else
368#endif
369 alpha_mask = 0;
647 370
648 if (depth == 24 || depth == 32) 371 if (depth == 24 || depth == 32)
649 bytes_per_pixel = 4; 372 bytes_per_pixel = 4;
650 else if (depth == 15 || depth == 16) 373 else if (depth == 15 || depth == 16)
651 bytes_per_pixel = 2; 374 bytes_per_pixel = 2;
… …
653 return false; 376 return false;
654 377
655 width_r = ecb_popcount32 (visual->red_mask); 378 width_r = ecb_popcount32 (visual->red_mask);
656 width_g = ecb_popcount32 (visual->green_mask); 379 width_g = ecb_popcount32 (visual->green_mask);
657 width_b = ecb_popcount32 (visual->blue_mask); 380 width_b = ecb_popcount32 (visual->blue_mask);
381 width_a = ecb_popcount32 (alpha_mask);
658 382
659 if (width_r > 8 || width_g > 8 || width_b > 8) 383 if (width_r > 8 || width_g > 8 || width_b > 8 || width_a > 8)
660 return false; 384 return false;
661 385
662 sh_r = ecb_ctz32 (visual->red_mask); 386 sh_r = ecb_ctz32 (visual->red_mask);
663 sh_g = ecb_ctz32 (visual->green_mask); 387 sh_g = ecb_ctz32 (visual->green_mask);
664 sh_b = ecb_ctz32 (visual->blue_mask); 388 sh_b = ecb_ctz32 (visual->blue_mask);
389 sh_a = ecb_ctz32 (alpha_mask);
665 390
666 if (width > INT_MAX / height / bytes_per_pixel) 391 if (width > INT_MAX / height / bytes_per_pixel)
667 return false; 392 return false;
668 393
669 data = (char *)malloc (width * height * bytes_per_pixel); 394 data = (char *)malloc (width * height * bytes_per_pixel);
… …
683 rowstride = gdk_pixbuf_get_rowstride (pixbuf); 408 rowstride = gdk_pixbuf_get_rowstride (pixbuf);
684 channels = gdk_pixbuf_get_n_channels (pixbuf); 409 channels = gdk_pixbuf_get_n_channels (pixbuf);
685 row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels; 410 row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels;
686 line = data; 411 line = data;
687 412
413 rgba c (0, 0, 0);
414
415 if (channels == 4 && alpha_mask == 0)
416 {
417 pix_colors[Color_bg].get (c);
418 c.r >>= 8;
419 c.g >>= 8;
420 c.b >>= 8;
421 }
422
688 for (int y = 0; y < height; y++) 423 for (int y = 0; y < height; y++)
689 { 424 {
690 for (int x = 0; x < width; x++) 425 for (int x = 0; x < width; x++)
691 { 426 {
692 unsigned char *pixel = row + x * channels; 427 unsigned char *pixel = row + x * channels;
693 uint32_t value; 428 uint32_t value;
429 unsigned char r, g, b, a;
694 430
431 if (channels == 4)
432 {
433 a = pixel[3];
434 r = (pixel[0] * a + c.r * (0xff - a)) / 0xff;
435 g = (pixel[1] * a + c.g * (0xff - a)) / 0xff;
436 b = (pixel[2] * a + c.b * (0xff - a)) / 0xff;
437 }
438 else
439 {
440 a = 0xff;
441 r = pixel[0];
442 g = pixel[1];
443 b = pixel[2];
444 }
445
695 value = ((pixel[0] >> (8 - width_r)) << sh_r) 446 value = ((r >> (8 - width_r)) << sh_r)
696 | ((pixel[1] >> (8 - width_g)) << sh_g) 447 | ((g >> (8 - width_g)) << sh_g)
697 | ((pixel[2] >> (8 - width_b)) << sh_b); 448 | ((b >> (8 - width_b)) << sh_b)
449 | ((a >> (8 - width_a)) << sh_a);
698 450
699 if (bytes_per_pixel == 4) 451 if (bytes_per_pixel == 4)
700 ((uint32_t *)line)[x] = value; 452 ((uint32_t *)line)[x] = value;
701 else 453 else
702 ((uint16_t *)line)[x] = value; 454 ((uint16_t *)line)[x] = value;
… …
710 XDestroyImage (ximage); 462 XDestroyImage (ximage);
711 return true; 463 return true;
712} 464}
713 465
714bool 466bool
715rxvt_term::render_image (unsigned long tr_flags) 467rxvt_term::render_image (bool transparent)
716{ 468{
717 if (!pixbuf) 469 if (!pixbuf)
718 return false; 470 return false;
719 471
720 if (tr_flags 472 if (transparent
721 && !(bg_flags & BG_HAS_RENDER)) 473 && !(bg_flags & BG_HAS_RENDER))
722 return false; 474 return false;
723 475
724 GdkPixbuf *result; 476 GdkPixbuf *result;
725 477
… …
739 get_image_geometry (image_width, image_height, w, h, x, y); 491 get_image_geometry (image_width, image_height, w, h, x, y);
740 492
741 if (!(bg_flags & BG_ROOT_ALIGN) 493 if (!(bg_flags & BG_ROOT_ALIGN)
742 && (x >= target_width 494 && (x >= target_width
743 || y >= target_height 495 || y >= target_height
744 || (x + w <= 0) 496 || x + w <= 0
745 || (y + h <= 0))) 497 || y + h <= 0))
746 return false; 498 return false;
747 499
748 result = pixbuf; 500 result = pixbuf;
749 501
750 if ((w != image_width) 502 if (w != image_width
751 || (h != image_height)) 503 || h != image_height)
752 { 504 {
753 result = gdk_pixbuf_scale_simple (pixbuf, 505 result = gdk_pixbuf_scale_simple (pixbuf,
754 w, h, 506 w, h,
755 GDK_INTERP_BILINEAR); 507 GDK_INTERP_BILINEAR);
756 } 508 }
… …
765 Pixmap root_pmap; 517 Pixmap root_pmap;
766 518
767 image_width = gdk_pixbuf_get_width (result); 519 image_width = gdk_pixbuf_get_width (result);
768 image_height = gdk_pixbuf_get_height (result); 520 image_height = gdk_pixbuf_get_height (result);
769 521
770 if (tr_flags) 522 if (transparent)
771 { 523 {
772 root_pmap = bg_pixmap; 524 root_pmap = bg_pixmap;
773 bg_pixmap = None; 525 bg_pixmap = None;
774 } 526 }
775 else 527 else
… …
833 dst_x, dst_y, 585 dst_x, dst_y,
834 dst_width, dst_height); 586 dst_width, dst_height);
835 } 587 }
836 588
837#if XRENDER 589#if XRENDER
838 if (tr_flags) 590 if (transparent)
839 { 591 {
840 XRenderPictureAttributes pa;
841
842 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, visual); 592 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
593
843 Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa); 594 Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
844 595
845 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
846 Picture dst = XRenderCreatePicture (dpy, bg_pixmap, dst_format, 0, &pa); 596 Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
847 597
848 pa.repeat = True; 598 Picture mask = create_xrender_mask (dpy, vt, False, False);
849 Pixmap mask_pmap = XCreatePixmap (dpy, vt, 1, 1, 8);
850 XRenderPictFormat *mask_format = XRenderFindStandardFormat (dpy, PictStandardA8);
851 Picture mask = XRenderCreatePicture (dpy, mask_pmap, mask_format, CPRepeat, &pa);
852 XFreePixmap (dpy, mask_pmap);
853 599
854 XRenderColor mask_c; 600 XRenderColor mask_c;
855 601
856 mask_c.alpha = 0x8000; 602 mask_c.alpha = 0x8000;
857 mask_c.red = 0; 603 mask_c.red =
858 mask_c.green = 0; 604 mask_c.green =
859 mask_c.blue = 0; 605 mask_c.blue = 0;
860 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1); 606 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
607
861 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height); 608 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
862 609
863 XRenderFreePicture (dpy, src); 610 XRenderFreePicture (dpy, src);
864 XRenderFreePicture (dpy, dst); 611 XRenderFreePicture (dpy, dst);
865 XRenderFreePicture (dpy, mask); 612 XRenderFreePicture (dpy, mask);
… …
872 } 619 }
873 620
874 if (result != pixbuf) 621 if (result != pixbuf)
875 g_object_unref (result); 622 g_object_unref (result);
876 623
877 if (tr_flags) 624 if (transparent)
878 XFreePixmap (dpy, root_pmap); 625 XFreePixmap (dpy, root_pmap);
879 626
880 return ret; 627 return ret;
881} 628}
882# endif /* HAVE_PIXBUF */ 629# endif /* HAVE_PIXBUF */
… …
885rxvt_term::bg_set_file (const char *file) 632rxvt_term::bg_set_file (const char *file)
886{ 633{
887 if (!file || !*file) 634 if (!file || !*file)
888 return false; 635 return false;
889 636
637 bool ret = false;
890 if (const char *p = strchr (file, ';')) 638 const char *p = strchr (file, ';');
639
640 if (p)
891 { 641 {
892 size_t len = p - file; 642 size_t len = p - file;
893 char *f = rxvt_temp_buf<char> (len + 1); 643 char *f = rxvt_temp_buf<char> (len + 1);
894 memcpy (f, file, len); 644 memcpy (f, file, len);
895 f[len] = '\0'; 645 f[len] = '\0';
896 file = f; 646 file = f;
897 } 647 }
898 648
899# ifdef HAVE_AFTERIMAGE
900 if (!asimman)
901 asimman = create_generic_imageman (rs[Rs_path]);
902 ASImage *image = get_asimage (asimman, file, 0xFFFFFFFF, 100);
903 if (image)
904 {
905 if (original_asim)
906 safe_asimage_destroy (original_asim);
907 original_asim = image;
908 bg_flags |= BG_IS_FROM_FILE | BG_CLIENT_RENDER;
909 return true;
910 }
911# endif
912
913# ifdef HAVE_PIXBUF 649# ifdef HAVE_PIXBUF
914 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL); 650 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
915 if (image) 651 if (image)
916 { 652 {
917 if (pixbuf) 653 if (pixbuf)
918 g_object_unref (pixbuf); 654 g_object_unref (pixbuf);
919 pixbuf = image; 655 pixbuf = image;
920 bg_flags |= BG_IS_FROM_FILE; 656 bg_flags |= BG_IS_FROM_FILE;
921 return true; 657 ret = true;
922 } 658 }
923# endif 659# endif
924 660
661 if (ret)
662 {
663 if (p)
664 bg_set_geometry (p + 1);
665 else
666 bg_set_default_geometry ();
667 }
668
925 return false; 669 return ret;
926} 670}
927 671
928# endif /* BG_IMAGE_FROM_FILE */ 672# endif /* BG_IMAGE_FROM_FILE */
929 673
930# ifdef ENABLE_TRANSPARENCY 674# ifdef ENABLE_TRANSPARENCY
… …
966 { 710 {
967 changed = true; 711 changed = true;
968 v_blurRadius = vr; 712 v_blurRadius = vr;
969 } 713 }
970 714
971 if (v_blurRadius == 0 && h_blurRadius == 0) 715 if (h_blurRadius && v_blurRadius)
716 bg_flags |= BG_NEEDS_BLUR;
717 else
972 bg_flags &= ~BG_NEEDS_BLUR; 718 bg_flags &= ~BG_NEEDS_BLUR;
973 else
974 bg_flags |= BG_NEEDS_BLUR;
975 719
976 return changed; 720 return changed;
977} 721}
978 722
979void 723void
980rxvt_term::set_tint_shade_flags () 724rxvt_term::set_tint_shade_flags ()
981{ 725{
982 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 726 if (shade != 100 || (bg_flags & BG_TINT_SET))
983 bool has_shade = shade != 100; 727 bg_flags |= BG_NEEDS_TINT;
728 else
729 bg_flags &= ~BG_NEEDS_TINT;
730}
984 731
732bool
733rxvt_term::bg_set_tint (rxvt_color &new_tint)
734{
735 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
736 {
737 tint = new_tint;
985 bg_flags &= ~BG_TINT_FLAGS; 738 bg_flags |= BG_TINT_SET;
986 739
987 if (bg_flags & BG_TINT_SET) 740 rgba c;
988 {
989 tint.get (c); 741 tint.get (c);
990 if (!has_shade
991 && (c.r <= 0x00ff || c.r >= 0xff00) 742 if ((c.r <= 0x00ff || c.r >= 0xff00)
992 && (c.g <= 0x00ff || c.g >= 0xff00) 743 && (c.g <= 0x00ff || c.g >= 0xff00)
993 && (c.b <= 0x00ff || c.b >= 0xff00)) 744 && (c.b <= 0x00ff || c.b >= 0xff00))
994 bg_flags |= BG_TINT_BITAND; 745 bg_flags |= BG_TINT_BITAND;
995 } 746 else
996
997 if (has_shade || (bg_flags & BG_TINT_SET))
998 bg_flags |= BG_NEEDS_TINT;
999}
1000
1001bool
1002rxvt_term::bg_set_tint (rxvt_color &new_tint)
1003{
1004 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
1005 {
1006 tint = new_tint;
1007 bg_flags |= BG_TINT_SET; 747 bg_flags &= ~BG_TINT_BITAND;
748
1008 set_tint_shade_flags (); 749 set_tint_shade_flags ();
1009 return true; 750 return true;
1010 } 751 }
1011 752
1012 return false; 753 return false;
1013} 754}
1014 755
1015bool 756bool
1016rxvt_term::bg_set_shade (const char *shade_str) 757rxvt_term::bg_set_shade (const char *shade_str)
1017{ 758{
1018 int new_shade = (shade_str) ? atoi (shade_str) : 100; 759 int new_shade = atoi (shade_str);
1019 760
1020 clamp_it (new_shade, -100, 200); 761 clamp_it (new_shade, -100, 200);
1021 if (new_shade < 0) 762 if (new_shade < 0)
1022 new_shade = 200 - (100 + new_shade); 763 new_shade = 200 - (100 + new_shade);
1023 764
… …
1053 params[i+2] = XDoubleToFixed (kernel[i] / sum); 794 params[i+2] = XDoubleToFixed (kernel[i] / sum);
1054} 795}
1055#endif 796#endif
1056 797
1057bool 798bool
1058rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 799rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height, int depth)
1059{ 800{
1060 bool ret = false; 801 bool ret = false;
1061#if XRENDER 802#if XRENDER
803 if (!(bg_flags & BG_HAS_RENDER_CONV))
804 return false;
805
1062 int size = max (h_blurRadius, v_blurRadius) * 2 + 1; 806 int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1063 double *kernel = (double *)malloc (size * sizeof (double)); 807 double *kernel = (double *)malloc (size * sizeof (double));
1064 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 808 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1065 809
1066 XRenderPictureAttributes pa; 810 XRenderPictureAttributes pa;
1067 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 811 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1068 812
813 pa.repeat = RepeatPad;
1069 Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 814 Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
815 Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1070 Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 816 Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
817 XFreePixmap (dpy, tmp);
1071 818
1072 if (kernel && params) 819 if (kernel && params)
1073 { 820 {
1074 if (h_blurRadius)
1075 {
1076 size = h_blurRadius * 2 + 1; 821 size = h_blurRadius * 2 + 1;
1077 get_gaussian_kernel (h_blurRadius, size, kernel, params); 822 get_gaussian_kernel (h_blurRadius, size, kernel, params);
1078 823
1079 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 824 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1080 XRenderComposite (dpy, 825 XRenderComposite (dpy,
1081 PictOpSrc, 826 PictOpSrc,
1082 src, 827 src,
1083 None, 828 None,
1084 dst, 829 dst,
1085 0, 0, 830 0, 0,
1086 0, 0, 831 0, 0,
1087 0, 0, 832 0, 0,
1088 width, height); 833 width, height);
1089 }
1090 834
1091 if (v_blurRadius) 835 ::swap (src, dst);
1092 { 836
1093 size = v_blurRadius * 2 + 1; 837 size = v_blurRadius * 2 + 1;
1094 get_gaussian_kernel (v_blurRadius, size, kernel, params); 838 get_gaussian_kernel (v_blurRadius, size, kernel, params);
1095 ::swap (params[0], params[1]); 839 ::swap (params[0], params[1]);
1096 840
1097 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 841 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1098 XRenderComposite (dpy, 842 XRenderComposite (dpy,
1099 PictOpSrc, 843 PictOpSrc,
1100 src, 844 src,
1101 None, 845 None,
1102 dst, 846 dst,
1103 0, 0, 847 0, 0,
1104 0, 0, 848 0, 0,
1105 0, 0, 849 0, 0,
1106 width, height); 850 width, height);
1107 }
1108 851
1109 ret = true; 852 ret = true;
1110 } 853 }
1111 854
1112 free (kernel); 855 free (kernel);
… …
1120bool 863bool
1121rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 864rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1122{ 865{
1123 bool ret = false; 866 bool ret = false;
1124 867
1125 if (bg_flags & BG_TINT_BITAND) 868 if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1126 { 869 {
1127 XGCValues gcv; 870 XGCValues gcv;
1128 GC gc; 871 GC gc;
1129 872
1130 /* In this case we can tint image server-side getting significant 873 /* In this case we can tint image server-side getting significant
… …
1139 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height); 882 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1140 ret = true; 883 ret = true;
1141 XFreeGC (dpy, gc); 884 XFreeGC (dpy, gc);
1142 } 885 }
1143 } 886 }
1144 else
1145 {
1146# if XRENDER 887# if XRENDER
888 else if (bg_flags & BG_HAS_RENDER)
889 {
1147 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC); 890 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1148 891
1149 if (bg_flags & BG_TINT_SET) 892 if (bg_flags & BG_TINT_SET)
1150 tint.get (c); 893 tint.get (c);
1151 894
… …
1160 c.r = c.r * (200 - shade) / 100; 903 c.r = c.r * (200 - shade) / 100;
1161 c.g = c.g * (200 - shade) / 100; 904 c.g = c.g * (200 - shade) / 100;
1162 c.b = c.b * (200 - shade) / 100; 905 c.b = c.b * (200 - shade) / 100;
1163 } 906 }
1164 907
1165 XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1166 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 908 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1167 XRenderPictureAttributes pa;
1168 909
1169 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 910 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1170 911
1171 pa.repeat = True; 912 Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1172 913
1173 Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32); 914 Picture mask_pic = create_xrender_mask (dpy, pixmap, True, True);
1174 Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1175 XFreePixmap (dpy, overlay_pmap);
1176
1177 pa.component_alpha = True;
1178 Pixmap mask_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
1179 Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat | CPComponentAlpha, &pa);
1180 XFreePixmap (dpy, mask_pmap);
1181 915
1182 XRenderColor mask_c; 916 XRenderColor mask_c;
1183 917
1184 mask_c.alpha = 0xffff; 918 mask_c.alpha = 0xffff;
1185 mask_c.red = 919 mask_c.red =
… …
1190 mask_c.alpha = 0; 924 mask_c.alpha = 0;
1191 mask_c.red = 0xffff - c.r; 925 mask_c.red = 0xffff - c.r;
1192 mask_c.green = 0xffff - c.g; 926 mask_c.green = 0xffff - c.g;
1193 mask_c.blue = 0xffff - c.b; 927 mask_c.blue = 0xffff - c.b;
1194 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1); 928 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
929
1195 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height); 930 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1196 931
1197 if (shade > 100) 932 if (shade > 100)
1198 { 933 {
1199 mask_c.red = mask_c.green = mask_c.blue = 0xffff * (shade - 100) / 100;
1200 mask_c.alpha = 0; 934 mask_c.alpha = 0;
935 mask_c.red =
936 mask_c.green =
937 mask_c.blue = 0xffff * (shade - 100) / 100;
1201 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1); 938 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1202 939
1203 XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height); 940 XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1204 } 941 }
1205 942
1206 ret = true; 943 ret = true;
1207 944
1208 XRenderFreePicture (dpy, mask_pic); 945 XRenderFreePicture (dpy, mask_pic);
1209 XRenderFreePicture (dpy, overlay_pic); 946 XRenderFreePicture (dpy, overlay_pic);
1210 XRenderFreePicture (dpy, back_pic); 947 XRenderFreePicture (dpy, back_pic);
948 }
1211# endif 949# endif
1212 }
1213 950
1214 return ret; 951 return ret;
1215} 952}
1216 953
1217/* 954/*
1218 * Builds a pixmap of the same size as the terminal window that contains 955 * Builds a pixmap of the same size as the terminal window that contains
1219 * the tiled portion of the root pixmap that is supposed to be covered by 956 * the tiled portion of the root pixmap that is supposed to be covered by
1220 * our window. 957 * our window.
1221 */ 958 */
1222unsigned long 959bool
1223rxvt_term::make_transparency_pixmap () 960rxvt_term::make_transparency_pixmap ()
1224{ 961{
1225 unsigned long result = 0; 962 bool ret = false;
1226 963
1227 /* root dimensions may change from call to call - but Display structure should 964 /* root dimensions may change from call to call - but Display structure should
1228 * be always up-to-date, so let's use it : 965 * be always up-to-date, so let's use it :
1229 */ 966 */
1230 int screen = display->screen; 967 int screen = display->screen;
… …
1268#if XRENDER 1005#if XRENDER
1269 if (bg_flags & BG_HAS_RENDER) 1006 if (bg_flags & BG_HAS_RENDER)
1270 { 1007 {
1271 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth); 1008 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1272 1009
1273 XRenderPictureAttributes pa;
1274
1275 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen)); 1010 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1276 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa); 1011 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1277 1012
1278 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual); 1013 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1279 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa); 1014 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1280 1015
1281 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height); 1016 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
1282 1017
1283 XRenderFreePicture (dpy, src); 1018 XRenderFreePicture (dpy, src);
1284 XRenderFreePicture (dpy, dst); 1019 XRenderFreePicture (dpy, dst);
… …
1301 bg_pmap_width = window_width; 1036 bg_pmap_width = window_width;
1302 bg_pmap_height = window_height; 1037 bg_pmap_height = window_height;
1303 } 1038 }
1304 1039
1305 /* straightforward pixmap copy */ 1040 /* straightforward pixmap copy */
1306 while (sx < 0) sx += root_width; 1041 while (sx < 0) sx += root_pmap_width;
1307 while (sy < 0) sy += root_height; 1042 while (sy < 0) sy += root_pmap_height;
1308 1043
1309 gcv.tile = recoded_root_pmap; 1044 gcv.tile = recoded_root_pmap;
1310 gcv.fill_style = FillTiled; 1045 gcv.fill_style = FillTiled;
1311 gcv.ts_x_origin = -sx; 1046 gcv.ts_x_origin = -sx;
1312 gcv.ts_y_origin = -sy; 1047 gcv.ts_y_origin = -sy;
1313 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); 1048 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1314 1049
1315 if (gc) 1050 if (gc)
1316 { 1051 {
1317 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height); 1052 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1318 result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS); 1053 ret = true;
1054 unsigned long tr_flags = bg_flags & BG_EFFECTS_FLAGS;
1055
1056 if (!(bg_flags & BG_CLIENT_RENDER))
1057 {
1058 if (bg_flags & BG_NEEDS_BLUR)
1059 {
1060 if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth))
1061 tr_flags &= ~BG_NEEDS_BLUR;
1062 }
1063 if (bg_flags & BG_NEEDS_TINT)
1064 {
1065 if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1066 tr_flags &= ~BG_NEEDS_TINT;
1067 }
1068 if (tr_flags & BG_NEEDS_TINT)
1069 {
1070 XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1071 if (ximage)
1072 {
1073 /* our own client-side tinting */
1074 tint_ximage (DefaultVisual (dpy, display->screen), ximage);
1075
1076 XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
1077 XDestroyImage (ximage);
1078 }
1079 }
1080 } /* server side rendering completed */
1081
1319 XFreeGC (dpy, gc); 1082 XFreeGC (dpy, gc);
1320
1321 if (!(bg_flags & BG_CLIENT_RENDER))
1322 {
1323 if ((bg_flags & BG_NEEDS_BLUR)
1324 && (bg_flags & BG_HAS_RENDER_CONV))
1325 {
1326 if (blur_pixmap (bg_pixmap, visual, window_width, window_height))
1327 result &= ~BG_NEEDS_BLUR;
1328 }
1329 if ((bg_flags & BG_NEEDS_TINT)
1330 && (bg_flags & (BG_TINT_BITAND | BG_HAS_RENDER)))
1331 {
1332 if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1333 result &= ~BG_NEEDS_TINT;
1334 }
1335 } /* server side rendering completed */
1336 } 1083 }
1337 1084
1338 if (recoded_root_pmap != root_pixmap) 1085 if (recoded_root_pmap != root_pixmap)
1339 XFreePixmap (dpy, recoded_root_pmap); 1086 XFreePixmap (dpy, recoded_root_pmap);
1340 1087
1341 return result; 1088 return ret;
1342} 1089}
1343 1090
1344void 1091void
1345rxvt_term::bg_set_root_pixmap () 1092rxvt_term::bg_set_root_pixmap ()
1346{ 1093{
… …
1350 1097
1351 root_pixmap = new_root_pixmap; 1098 root_pixmap = new_root_pixmap;
1352} 1099}
1353# endif /* ENABLE_TRANSPARENCY */ 1100# endif /* ENABLE_TRANSPARENCY */
1354 1101
1355#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1356static void shade_ximage (Visual *visual, XImage *ximage, int shade, const rgba &c);
1357# endif
1358
1359bool 1102bool
1360rxvt_term::bg_render () 1103rxvt_term::bg_render ()
1361{ 1104{
1362 unsigned long tr_flags = 0; 1105 bool transparent = false;
1363 1106
1364 bg_invalidate (); 1107 bg_invalidate ();
1365# ifdef ENABLE_TRANSPARENCY 1108# ifdef ENABLE_TRANSPARENCY
1366 if (bg_flags & BG_IS_TRANSPARENT) 1109 if (bg_flags & BG_IS_TRANSPARENT)
1367 { 1110 {
1368 /* we need to re-generate transparency pixmap in that case ! */ 1111 /* we need to re-generate transparency pixmap in that case ! */
1369 tr_flags = make_transparency_pixmap (); 1112 transparent = make_transparency_pixmap ();
1370 if (tr_flags == 0) 1113 if (transparent)
1371 return false;
1372 else if (!(tr_flags & BG_EFFECTS_FLAGS))
1373 bg_flags |= BG_IS_VALID; 1114 bg_flags |= BG_IS_VALID;
1374 } 1115 }
1375# endif 1116# endif
1376 1117
1377# ifdef BG_IMAGE_FROM_FILE 1118# ifdef BG_IMAGE_FROM_FILE
1378 if ((bg_flags & BG_IS_FROM_FILE) 1119 if (bg_flags & BG_IS_FROM_FILE)
1379 || (tr_flags & BG_EFFECTS_FLAGS))
1380 { 1120 {
1381 if (render_image (tr_flags)) 1121 if (render_image (transparent))
1382 bg_flags |= BG_IS_VALID; 1122 bg_flags |= BG_IS_VALID;
1383 }
1384# endif
1385
1386# if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1387 XImage *result = NULL;
1388
1389 if (tr_flags && !(bg_flags & BG_IS_VALID))
1390 {
1391 result = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1392 }
1393
1394 if (result)
1395 {
1396 /* our own client-side tinting */
1397 if (tr_flags & BG_NEEDS_TINT)
1398 {
1399 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1400 if (bg_flags & BG_TINT_SET)
1401 tint.get (c);
1402 shade_ximage (DefaultVisual (dpy, display->screen), result, shade, c);
1403 }
1404
1405 GC gc = XCreateGC (dpy, vt, 0UL, NULL);
1406
1407 if (gc)
1408 {
1409 XPutImage (dpy, bg_pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1410
1411 XFreeGC (dpy, gc);
1412 bg_flags |= BG_IS_VALID;
1413 }
1414
1415 XDestroyImage (result);
1416 } 1123 }
1417# endif 1124# endif
1418 1125
1419 if (!(bg_flags & BG_IS_VALID)) 1126 if (!(bg_flags & BG_IS_VALID))
1420 { 1127 {
… …
1457#endif 1164#endif
1458} 1165}
1459 1166
1460#endif /* HAVE_BG_PIXMAP */ 1167#endif /* HAVE_BG_PIXMAP */
1461 1168
1462#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) 1169#ifdef ENABLE_TRANSPARENCY
1463/* taken from aterm-0.4.2 */ 1170/* based on code from aterm-0.4.2 */
1464 1171
1465static void 1172static inline void
1466shade_ximage (Visual *visual, XImage *ximage, int shade, const rgba &c) 1173fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
1467{ 1174{
1175 for (int i = 0; i <= mask >> sh; i++)
1176 {
1177 uint32_t tmp;
1178 tmp = i * high;
1179 tmp += (mask >> sh) * low;
1180 lookup[i] = (tmp / 0xffff) << sh;
1181 }
1182}
1183
1184void
1185rxvt_term::tint_ximage (Visual *visual, XImage *ximage)
1186{
1187 unsigned int size_r, size_g, size_b;
1468 int sh_r, sh_g, sh_b; 1188 int sh_r, sh_g, sh_b;
1469 uint32_t mask_r, mask_g, mask_b; 1189 uint32_t mask_r, mask_g, mask_b;
1470 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b; 1190 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1471 rgba low; 1191 unsigned short low;
1472 rgba high;
1473 int i;
1474 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst; 1192 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1475 1193
1476 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return; 1194 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;
1477 1195
1478 /* for convenience */ 1196 /* for convenience */
1479 mask_r = visual->red_mask; 1197 mask_r = visual->red_mask;
1480 mask_g = visual->green_mask; 1198 mask_g = visual->green_mask;
1481 mask_b = visual->blue_mask; 1199 mask_b = visual->blue_mask;
1482 1200
1483 /* boring lookup table pre-initialization */ 1201 /* boring lookup table pre-initialization */
1484 switch (ximage->depth) 1202 sh_r = ecb_ctz32 (mask_r);
1485 { 1203 sh_g = ecb_ctz32 (mask_g);
1486 case 15: 1204 sh_b = ecb_ctz32 (mask_b);
1487 if ((mask_r != 0x7c00) || 1205
1488 (mask_g != 0x03e0) || 1206 size_r = mask_r >> sh_r;
1489 (mask_b != 0x001f)) 1207 size_g = mask_g >> sh_g;
1208 size_b = mask_b >> sh_b;
1209
1210 if (size_r++ > 255 || size_g++ > 255 || size_b++ > 255)
1490 return; 1211 return;
1491 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+32+32)); 1212
1213 lookup = (uint32_t *)malloc (sizeof (uint32_t) * (size_r + size_g + size_b));
1492 lookup_r = lookup; 1214 lookup_r = lookup;
1493 lookup_g = lookup+32; 1215 lookup_g = lookup + size_r;
1494 lookup_b = lookup+32+32; 1216 lookup_b = lookup + size_r + size_g;
1495 sh_r = 10; 1217
1496 sh_g = 5; 1218 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1497 sh_b = 0; 1219
1498 break; 1220 if (bg_flags & BG_TINT_SET)
1499 case 16: 1221 tint.get (c);
1500 if ((mask_r != 0xf800) ||
1501 (mask_g != 0x07e0) ||
1502 (mask_b != 0x001f))
1503 return;
1504 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+64+32));
1505 lookup_r = lookup;
1506 lookup_g = lookup+32;
1507 lookup_b = lookup+32+64;
1508 sh_r = 11;
1509 sh_g = 5;
1510 sh_b = 0;
1511 break;
1512 case 24:
1513 if ((mask_r != 0xff0000) ||
1514 (mask_g != 0x00ff00) ||
1515 (mask_b != 0x0000ff))
1516 return;
1517 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(256+256+256));
1518 lookup_r = lookup;
1519 lookup_g = lookup+256;
1520 lookup_b = lookup+256+256;
1521 sh_r = 16;
1522 sh_g = 8;
1523 sh_b = 0;
1524 break;
1525 case 32:
1526 if ((mask_r != 0xff0000) ||
1527 (mask_g != 0x00ff00) ||
1528 (mask_b != 0x0000ff))
1529 return;
1530 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(256+256+256));
1531 lookup_r = lookup;
1532 lookup_g = lookup+256;
1533 lookup_b = lookup+256+256;
1534 sh_r = 16;
1535 sh_g = 8;
1536 sh_b = 0;
1537 break;
1538 default:
1539 return; /* we do not support this color depth */
1540 }
1541 1222
1542 /* prepare limits for color transformation (each channel is handled separately) */ 1223 /* prepare limits for color transformation (each channel is handled separately) */
1543 if (shade > 100) 1224 if (shade > 100)
1544 { 1225 {
1545 shade = 200 - shade;
1546
1547 high.r = c.r * shade / 100;
1548 high.g = c.g * shade / 100;
1549 high.b = c.b * shade / 100;
1550
1551 low.r = 65535 * (100 - shade) / 100; 1226 c.r = c.r * (200 - shade) / 100;
1552 low.g = 65535 * (100 - shade) / 100; 1227 c.g = c.g * (200 - shade) / 100;
1553 low.b = 65535 * (100 - shade) / 100; 1228 c.b = c.b * (200 - shade) / 100;
1229
1230 low = 0xffff * (shade - 100) / 100;
1554 } 1231 }
1555 else 1232 else
1556 { 1233 {
1557 high.r = c.r * shade / 100; 1234 c.r = c.r * shade / 100;
1558 high.g = c.g * shade / 100; 1235 c.g = c.g * shade / 100;
1559 high.b = c.b * shade / 100; 1236 c.b = c.b * shade / 100;
1560 1237
1561 low.r = low.g = low.b = 0; 1238 low = 0;
1562 } 1239 }
1563 1240
1564 /* fill our lookup tables */ 1241 /* fill our lookup tables */
1565 for (i = 0; i <= mask_r>>sh_r; i++) 1242 fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1566 { 1243 fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1567 uint32_t tmp; 1244 fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1568 tmp = i * high.r;
1569 tmp += (mask_r>>sh_r) * low.r;
1570 lookup_r[i] = (tmp/65535)<<sh_r;
1571 }
1572 for (i = 0; i <= mask_g>>sh_g; i++)
1573 {
1574 uint32_t tmp;
1575 tmp = i * high.g;
1576 tmp += (mask_g>>sh_g) * low.g;
1577 lookup_g[i] = (tmp/65535)<<sh_g;
1578 }
1579 for (i = 0; i <= mask_b>>sh_b; i++)
1580 {
1581 uint32_t tmp;
1582 tmp = i * high.b;
1583 tmp += (mask_b>>sh_b) * low.b;
1584 lookup_b[i] = (tmp/65535)<<sh_b;
1585 }
1586 1245
1587 /* apply table to input image (replacing colors by newly calculated ones) */ 1246 /* apply table to input image (replacing colors by newly calculated ones) */
1588 if (ximage->bits_per_pixel == 32 1247 if (ximage->bits_per_pixel == 32
1589 && (ximage->depth == 24 || ximage->depth == 32)
1590 && ximage->byte_order == host_byte_order) 1248 && ximage->byte_order == host_byte_order)
1591 { 1249 {
1592 uint32_t *p1, *pf, *p, *pl; 1250 char *line = ximage->data;
1593 p1 = (uint32_t *) ximage->data;
1594 pf = (uint32_t *) (ximage->data + ximage->height * ximage->bytes_per_line);
1595 1251
1596 while (p1 < pf) 1252 for (int y = 0; y < ximage->height; y++)
1597 {
1598 p = p1;
1599 pl = p1 + ximage->width;
1600 for (; p < pl; p++)
1601 { 1253 {
1602 *p = lookup_r[(*p & 0xff0000) >> 16] | 1254 uint32_t *p = (uint32_t *)line;
1603 lookup_g[(*p & 0x00ff00) >> 8] | 1255 for (int x = 0; x < ximage->width; x++)
1604 lookup_b[(*p & 0x0000ff)] |
1605 (*p & 0xff000000);
1606 } 1256 {
1607 p1 = (uint32_t *) ((char *) p1 + ximage->bytes_per_line); 1257 *p = lookup_r[(*p & mask_r) >> sh_r] |
1258 lookup_g[(*p & mask_g) >> sh_g] |
1259 lookup_b[(*p & mask_b) >> sh_b];
1260 p++;
1261 }
1262 line += ximage->bytes_per_line;
1608 } 1263 }
1609 } 1264 }
1610 else 1265 else
1611 { 1266 {
1612 for (int y = 0; y < ximage->height; y++) 1267 for (int y = 0; y < ximage->height; y++)
… …
1620 } 1275 }
1621 } 1276 }
1622 1277
1623 free (lookup); 1278 free (lookup);
1624} 1279}
1625#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */ 1280#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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