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.206 by sf-exg, Thu Apr 12 10:22:50 2012 UTC

… …
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,
… …
710 XDestroyImage (ximage); 424 XDestroyImage (ximage);
711 return true; 425 return true;
712} 426}
713 427
714bool 428bool
715rxvt_term::render_image (unsigned long tr_flags) 429rxvt_term::render_image (bool transparent)
716{ 430{
717 if (!pixbuf) 431 if (!pixbuf)
718 return false; 432 return false;
719 433
720 if (tr_flags 434 if (transparent
721 && !(bg_flags & BG_HAS_RENDER)) 435 && !(bg_flags & BG_HAS_RENDER))
722 return false; 436 return false;
723 437
724 GdkPixbuf *result; 438 GdkPixbuf *result;
725 439
… …
739 get_image_geometry (image_width, image_height, w, h, x, y); 453 get_image_geometry (image_width, image_height, w, h, x, y);
740 454
741 if (!(bg_flags & BG_ROOT_ALIGN) 455 if (!(bg_flags & BG_ROOT_ALIGN)
742 && (x >= target_width 456 && (x >= target_width
743 || y >= target_height 457 || y >= target_height
744 || (x + w <= 0) 458 || x + w <= 0
745 || (y + h <= 0))) 459 || y + h <= 0))
746 return false; 460 return false;
747 461
748 result = pixbuf; 462 result = pixbuf;
749 463
750 if ((w != image_width) 464 if (w != image_width
751 || (h != image_height)) 465 || h != image_height)
752 { 466 {
753 result = gdk_pixbuf_scale_simple (pixbuf, 467 result = gdk_pixbuf_scale_simple (pixbuf,
754 w, h, 468 w, h,
755 GDK_INTERP_BILINEAR); 469 GDK_INTERP_BILINEAR);
756 } 470 }
… …
765 Pixmap root_pmap; 479 Pixmap root_pmap;
766 480
767 image_width = gdk_pixbuf_get_width (result); 481 image_width = gdk_pixbuf_get_width (result);
768 image_height = gdk_pixbuf_get_height (result); 482 image_height = gdk_pixbuf_get_height (result);
769 483
770 if (tr_flags) 484 if (transparent)
771 { 485 {
772 root_pmap = bg_pixmap; 486 root_pmap = bg_pixmap;
773 bg_pixmap = None; 487 bg_pixmap = None;
774 } 488 }
775 else 489 else
… …
833 dst_x, dst_y, 547 dst_x, dst_y,
834 dst_width, dst_height); 548 dst_width, dst_height);
835 } 549 }
836 550
837#if XRENDER 551#if XRENDER
838 if (tr_flags) 552 if (transparent)
839 { 553 {
840 XRenderPictureAttributes pa;
841
842 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, visual); 554 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
555
843 Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa); 556 Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
844 557
845 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
846 Picture dst = XRenderCreatePicture (dpy, bg_pixmap, dst_format, 0, &pa); 558 Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
847 559
848 pa.repeat = True; 560 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 561
854 XRenderColor mask_c; 562 XRenderColor mask_c;
855 563
856 mask_c.alpha = 0x8000; 564 mask_c.alpha = 0x8000;
857 mask_c.red = 0; 565 mask_c.red =
858 mask_c.green = 0; 566 mask_c.green =
859 mask_c.blue = 0; 567 mask_c.blue = 0;
860 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1); 568 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
569
861 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height); 570 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
862 571
863 XRenderFreePicture (dpy, src); 572 XRenderFreePicture (dpy, src);
864 XRenderFreePicture (dpy, dst); 573 XRenderFreePicture (dpy, dst);
865 XRenderFreePicture (dpy, mask); 574 XRenderFreePicture (dpy, mask);
… …
872 } 581 }
873 582
874 if (result != pixbuf) 583 if (result != pixbuf)
875 g_object_unref (result); 584 g_object_unref (result);
876 585
877 if (tr_flags) 586 if (transparent)
878 XFreePixmap (dpy, root_pmap); 587 XFreePixmap (dpy, root_pmap);
879 588
880 return ret; 589 return ret;
881} 590}
882# endif /* HAVE_PIXBUF */ 591# endif /* HAVE_PIXBUF */
… …
885rxvt_term::bg_set_file (const char *file) 594rxvt_term::bg_set_file (const char *file)
886{ 595{
887 if (!file || !*file) 596 if (!file || !*file)
888 return false; 597 return false;
889 598
599 bool ret = false;
890 if (const char *p = strchr (file, ';')) 600 const char *p = strchr (file, ';');
601
602 if (p)
891 { 603 {
892 size_t len = p - file; 604 size_t len = p - file;
893 char *f = rxvt_temp_buf<char> (len + 1); 605 char *f = rxvt_temp_buf<char> (len + 1);
894 memcpy (f, file, len); 606 memcpy (f, file, len);
895 f[len] = '\0'; 607 f[len] = '\0';
896 file = f; 608 file = f;
897 } 609 }
898 610
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 611# ifdef HAVE_PIXBUF
914 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL); 612 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
915 if (image) 613 if (image)
916 { 614 {
917 if (pixbuf) 615 if (pixbuf)
918 g_object_unref (pixbuf); 616 g_object_unref (pixbuf);
919 pixbuf = image; 617 pixbuf = image;
920 bg_flags |= BG_IS_FROM_FILE; 618 bg_flags |= BG_IS_FROM_FILE;
921 return true; 619 ret = true;
922 } 620 }
923# endif 621# endif
924 622
623 if (ret)
624 {
625 if (p)
626 bg_set_geometry (p + 1);
627 else
628 bg_set_default_geometry ();
629 }
630
925 return false; 631 return ret;
926} 632}
927 633
928# endif /* BG_IMAGE_FROM_FILE */ 634# endif /* BG_IMAGE_FROM_FILE */
929 635
930# ifdef ENABLE_TRANSPARENCY 636# ifdef ENABLE_TRANSPARENCY
… …
966 { 672 {
967 changed = true; 673 changed = true;
968 v_blurRadius = vr; 674 v_blurRadius = vr;
969 } 675 }
970 676
971 if (v_blurRadius == 0 && h_blurRadius == 0) 677 if (h_blurRadius && v_blurRadius)
678 bg_flags |= BG_NEEDS_BLUR;
679 else
972 bg_flags &= ~BG_NEEDS_BLUR; 680 bg_flags &= ~BG_NEEDS_BLUR;
973 else
974 bg_flags |= BG_NEEDS_BLUR;
975 681
976 return changed; 682 return changed;
977} 683}
978 684
979void 685void
980rxvt_term::set_tint_shade_flags () 686rxvt_term::set_tint_shade_flags ()
981{ 687{
982 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 688 if (shade != 100 || (bg_flags & BG_TINT_SET))
983 bool has_shade = shade != 100; 689 bg_flags |= BG_NEEDS_TINT;
690 else
691 bg_flags &= ~BG_NEEDS_TINT;
692}
984 693
694bool
695rxvt_term::bg_set_tint (rxvt_color &new_tint)
696{
697 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
698 {
699 tint = new_tint;
985 bg_flags &= ~BG_TINT_FLAGS; 700 bg_flags |= BG_TINT_SET;
986 701
987 if (bg_flags & BG_TINT_SET) 702 rgba c;
988 {
989 tint.get (c); 703 tint.get (c);
990 if (!has_shade
991 && (c.r <= 0x00ff || c.r >= 0xff00) 704 if ((c.r <= 0x00ff || c.r >= 0xff00)
992 && (c.g <= 0x00ff || c.g >= 0xff00) 705 && (c.g <= 0x00ff || c.g >= 0xff00)
993 && (c.b <= 0x00ff || c.b >= 0xff00)) 706 && (c.b <= 0x00ff || c.b >= 0xff00))
994 bg_flags |= BG_TINT_BITAND; 707 bg_flags |= BG_TINT_BITAND;
995 } 708 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; 709 bg_flags &= ~BG_TINT_BITAND;
710
1008 set_tint_shade_flags (); 711 set_tint_shade_flags ();
1009 return true; 712 return true;
1010 } 713 }
1011 714
1012 return false; 715 return false;
1013} 716}
1014 717
1015bool 718bool
1016rxvt_term::bg_set_shade (const char *shade_str) 719rxvt_term::bg_set_shade (const char *shade_str)
1017{ 720{
1018 int new_shade = (shade_str) ? atoi (shade_str) : 100; 721 int new_shade = atoi (shade_str);
1019 722
1020 clamp_it (new_shade, -100, 200); 723 clamp_it (new_shade, -100, 200);
1021 if (new_shade < 0) 724 if (new_shade < 0)
1022 new_shade = 200 - (100 + new_shade); 725 new_shade = 200 - (100 + new_shade);
1023 726
… …
1053 params[i+2] = XDoubleToFixed (kernel[i] / sum); 756 params[i+2] = XDoubleToFixed (kernel[i] / sum);
1054} 757}
1055#endif 758#endif
1056 759
1057bool 760bool
1058rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 761rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height, int depth)
1059{ 762{
1060 bool ret = false; 763 bool ret = false;
1061#if XRENDER 764#if XRENDER
765 if (!(bg_flags & BG_HAS_RENDER_CONV))
766 return false;
767
1062 int size = max (h_blurRadius, v_blurRadius) * 2 + 1; 768 int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1063 double *kernel = (double *)malloc (size * sizeof (double)); 769 double *kernel = (double *)malloc (size * sizeof (double));
1064 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 770 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1065 771
1066 XRenderPictureAttributes pa; 772 XRenderPictureAttributes pa;
1067 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 773 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1068 774
775 pa.repeat = RepeatPad;
1069 Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 776 Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
777 Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1070 Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 778 Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
779 XFreePixmap (dpy, tmp);
1071 780
1072 if (kernel && params) 781 if (kernel && params)
1073 { 782 {
1074 if (h_blurRadius)
1075 {
1076 size = h_blurRadius * 2 + 1; 783 size = h_blurRadius * 2 + 1;
1077 get_gaussian_kernel (h_blurRadius, size, kernel, params); 784 get_gaussian_kernel (h_blurRadius, size, kernel, params);
1078 785
1079 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 786 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1080 XRenderComposite (dpy, 787 XRenderComposite (dpy,
1081 PictOpSrc, 788 PictOpSrc,
1082 src, 789 src,
1083 None, 790 None,
1084 dst, 791 dst,
1085 0, 0, 792 0, 0,
1086 0, 0, 793 0, 0,
1087 0, 0, 794 0, 0,
1088 width, height); 795 width, height);
1089 }
1090 796
1091 if (v_blurRadius) 797 ::swap (src, dst);
1092 { 798
1093 size = v_blurRadius * 2 + 1; 799 size = v_blurRadius * 2 + 1;
1094 get_gaussian_kernel (v_blurRadius, size, kernel, params); 800 get_gaussian_kernel (v_blurRadius, size, kernel, params);
1095 ::swap (params[0], params[1]); 801 ::swap (params[0], params[1]);
1096 802
1097 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 803 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1098 XRenderComposite (dpy, 804 XRenderComposite (dpy,
1099 PictOpSrc, 805 PictOpSrc,
1100 src, 806 src,
1101 None, 807 None,
1102 dst, 808 dst,
1103 0, 0, 809 0, 0,
1104 0, 0, 810 0, 0,
1105 0, 0, 811 0, 0,
1106 width, height); 812 width, height);
1107 }
1108 813
1109 ret = true; 814 ret = true;
1110 } 815 }
1111 816
1112 free (kernel); 817 free (kernel);
… …
1120bool 825bool
1121rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 826rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1122{ 827{
1123 bool ret = false; 828 bool ret = false;
1124 829
1125 if (bg_flags & BG_TINT_BITAND) 830 if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1126 { 831 {
1127 XGCValues gcv; 832 XGCValues gcv;
1128 GC gc; 833 GC gc;
1129 834
1130 /* In this case we can tint image server-side getting significant 835 /* In this case we can tint image server-side getting significant
… …
1139 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height); 844 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1140 ret = true; 845 ret = true;
1141 XFreeGC (dpy, gc); 846 XFreeGC (dpy, gc);
1142 } 847 }
1143 } 848 }
1144 else
1145 {
1146# if XRENDER 849# if XRENDER
850 else if (bg_flags & BG_HAS_RENDER)
851 {
1147 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC); 852 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1148 853
1149 if (bg_flags & BG_TINT_SET) 854 if (bg_flags & BG_TINT_SET)
1150 tint.get (c); 855 tint.get (c);
1151 856
… …
1160 c.r = c.r * (200 - shade) / 100; 865 c.r = c.r * (200 - shade) / 100;
1161 c.g = c.g * (200 - shade) / 100; 866 c.g = c.g * (200 - shade) / 100;
1162 c.b = c.b * (200 - shade) / 100; 867 c.b = c.b * (200 - shade) / 100;
1163 } 868 }
1164 869
1165 XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1166 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 870 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1167 XRenderPictureAttributes pa;
1168 871
1169 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 872 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1170 873
1171 pa.repeat = True; 874 Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1172 875
1173 Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32); 876 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 877
1182 XRenderColor mask_c; 878 XRenderColor mask_c;
1183 879
1184 mask_c.alpha = 0xffff; 880 mask_c.alpha = 0xffff;
1185 mask_c.red = 881 mask_c.red =
… …
1190 mask_c.alpha = 0; 886 mask_c.alpha = 0;
1191 mask_c.red = 0xffff - c.r; 887 mask_c.red = 0xffff - c.r;
1192 mask_c.green = 0xffff - c.g; 888 mask_c.green = 0xffff - c.g;
1193 mask_c.blue = 0xffff - c.b; 889 mask_c.blue = 0xffff - c.b;
1194 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1); 890 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
891
1195 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height); 892 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1196 893
1197 if (shade > 100) 894 if (shade > 100)
1198 { 895 {
1199 mask_c.red = mask_c.green = mask_c.blue = 0xffff * (shade - 100) / 100;
1200 mask_c.alpha = 0; 896 mask_c.alpha = 0;
897 mask_c.red =
898 mask_c.green =
899 mask_c.blue = 0xffff * (shade - 100) / 100;
1201 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1); 900 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1202 901
1203 XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height); 902 XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1204 } 903 }
1205 904
1206 ret = true; 905 ret = true;
1207 906
1208 XRenderFreePicture (dpy, mask_pic); 907 XRenderFreePicture (dpy, mask_pic);
1209 XRenderFreePicture (dpy, overlay_pic); 908 XRenderFreePicture (dpy, overlay_pic);
1210 XRenderFreePicture (dpy, back_pic); 909 XRenderFreePicture (dpy, back_pic);
910 }
1211# endif 911# endif
1212 }
1213 912
1214 return ret; 913 return ret;
1215} 914}
1216 915
1217/* 916/*
1218 * Builds a pixmap of the same size as the terminal window that contains 917 * 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 918 * the tiled portion of the root pixmap that is supposed to be covered by
1220 * our window. 919 * our window.
1221 */ 920 */
1222unsigned long 921bool
1223rxvt_term::make_transparency_pixmap () 922rxvt_term::make_transparency_pixmap ()
1224{ 923{
1225 unsigned long result = 0; 924 bool ret = false;
1226 925
1227 /* root dimensions may change from call to call - but Display structure should 926 /* root dimensions may change from call to call - but Display structure should
1228 * be always up-to-date, so let's use it : 927 * be always up-to-date, so let's use it :
1229 */ 928 */
1230 int screen = display->screen; 929 int screen = display->screen;
… …
1268#if XRENDER 967#if XRENDER
1269 if (bg_flags & BG_HAS_RENDER) 968 if (bg_flags & BG_HAS_RENDER)
1270 { 969 {
1271 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth); 970 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1272 971
1273 XRenderPictureAttributes pa;
1274
1275 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen)); 972 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1276 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa); 973 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1277 974
1278 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual); 975 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1279 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa); 976 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1280 977
1281 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height); 978 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
1282 979
1283 XRenderFreePicture (dpy, src); 980 XRenderFreePicture (dpy, src);
1284 XRenderFreePicture (dpy, dst); 981 XRenderFreePicture (dpy, dst);
… …
1301 bg_pmap_width = window_width; 998 bg_pmap_width = window_width;
1302 bg_pmap_height = window_height; 999 bg_pmap_height = window_height;
1303 } 1000 }
1304 1001
1305 /* straightforward pixmap copy */ 1002 /* straightforward pixmap copy */
1306 while (sx < 0) sx += root_width; 1003 while (sx < 0) sx += root_pmap_width;
1307 while (sy < 0) sy += root_height; 1004 while (sy < 0) sy += root_pmap_height;
1308 1005
1309 gcv.tile = recoded_root_pmap; 1006 gcv.tile = recoded_root_pmap;
1310 gcv.fill_style = FillTiled; 1007 gcv.fill_style = FillTiled;
1311 gcv.ts_x_origin = -sx; 1008 gcv.ts_x_origin = -sx;
1312 gcv.ts_y_origin = -sy; 1009 gcv.ts_y_origin = -sy;
1313 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); 1010 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1314 1011
1315 if (gc) 1012 if (gc)
1316 { 1013 {
1317 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height); 1014 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1318 result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS); 1015 ret = true;
1016 unsigned long tr_flags = bg_flags & BG_EFFECTS_FLAGS;
1017
1018 if (!(bg_flags & BG_CLIENT_RENDER))
1019 {
1020 if (bg_flags & BG_NEEDS_BLUR)
1021 {
1022 if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth))
1023 tr_flags &= ~BG_NEEDS_BLUR;
1024 }
1025 if (bg_flags & BG_NEEDS_TINT)
1026 {
1027 if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1028 tr_flags &= ~BG_NEEDS_TINT;
1029 }
1030 if (tr_flags & BG_NEEDS_TINT)
1031 {
1032 XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1033 if (ximage)
1034 {
1035 /* our own client-side tinting */
1036 tint_ximage (DefaultVisual (dpy, display->screen), ximage);
1037
1038 XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
1039 XDestroyImage (ximage);
1040 }
1041 }
1042 } /* server side rendering completed */
1043
1319 XFreeGC (dpy, gc); 1044 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 } 1045 }
1337 1046
1338 if (recoded_root_pmap != root_pixmap) 1047 if (recoded_root_pmap != root_pixmap)
1339 XFreePixmap (dpy, recoded_root_pmap); 1048 XFreePixmap (dpy, recoded_root_pmap);
1340 1049
1341 return result; 1050 return ret;
1342} 1051}
1343 1052
1344void 1053void
1345rxvt_term::bg_set_root_pixmap () 1054rxvt_term::bg_set_root_pixmap ()
1346{ 1055{
… …
1350 1059
1351 root_pixmap = new_root_pixmap; 1060 root_pixmap = new_root_pixmap;
1352} 1061}
1353# endif /* ENABLE_TRANSPARENCY */ 1062# endif /* ENABLE_TRANSPARENCY */
1354 1063
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 1064bool
1360rxvt_term::bg_render () 1065rxvt_term::bg_render ()
1361{ 1066{
1362 unsigned long tr_flags = 0; 1067 bool transparent = false;
1363 1068
1364 bg_invalidate (); 1069 bg_invalidate ();
1365# ifdef ENABLE_TRANSPARENCY 1070# ifdef ENABLE_TRANSPARENCY
1366 if (bg_flags & BG_IS_TRANSPARENT) 1071 if (bg_flags & BG_IS_TRANSPARENT)
1367 { 1072 {
1368 /* we need to re-generate transparency pixmap in that case ! */ 1073 /* we need to re-generate transparency pixmap in that case ! */
1369 tr_flags = make_transparency_pixmap (); 1074 transparent = make_transparency_pixmap ();
1370 if (tr_flags == 0) 1075 if (transparent)
1371 return false;
1372 else if (!(tr_flags & BG_EFFECTS_FLAGS))
1373 bg_flags |= BG_IS_VALID; 1076 bg_flags |= BG_IS_VALID;
1374 } 1077 }
1375# endif 1078# endif
1376 1079
1377# ifdef BG_IMAGE_FROM_FILE 1080# ifdef BG_IMAGE_FROM_FILE
1378 if ((bg_flags & BG_IS_FROM_FILE) 1081 if (bg_flags & BG_IS_FROM_FILE)
1379 || (tr_flags & BG_EFFECTS_FLAGS))
1380 { 1082 {
1381 if (render_image (tr_flags)) 1083 if (render_image (transparent))
1382 bg_flags |= BG_IS_VALID; 1084 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 } 1085 }
1417# endif 1086# endif
1418 1087
1419 if (!(bg_flags & BG_IS_VALID)) 1088 if (!(bg_flags & BG_IS_VALID))
1420 { 1089 {
… …
1457#endif 1126#endif
1458} 1127}
1459 1128
1460#endif /* HAVE_BG_PIXMAP */ 1129#endif /* HAVE_BG_PIXMAP */
1461 1130
1462#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) 1131#ifdef ENABLE_TRANSPARENCY
1463/* taken from aterm-0.4.2 */ 1132/* based on code from aterm-0.4.2 */
1464 1133
1465static void 1134static inline void
1466shade_ximage (Visual *visual, XImage *ximage, int shade, const rgba &c) 1135fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
1136{
1137 for (int i = 0; i <= mask >> sh; i++)
1138 {
1139 uint32_t tmp;
1140 tmp = i * high;
1141 tmp += (mask >> sh) * low;
1142 lookup[i] = (tmp / 0xffff) << sh;
1143 }
1144}
1145
1146void
1147rxvt_term::tint_ximage (Visual *visual, XImage *ximage)
1467{ 1148{
1468 int sh_r, sh_g, sh_b; 1149 int sh_r, sh_g, sh_b;
1469 uint32_t mask_r, mask_g, mask_b; 1150 uint32_t mask_r, mask_g, mask_b;
1470 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b; 1151 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1471 rgba low; 1152 unsigned short low;
1472 rgba high;
1473 int i;
1474 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst; 1153 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1475 1154
1476 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return; 1155 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;
1477 1156
1478 /* for convenience */ 1157 /* for convenience */
… …
1537 break; 1216 break;
1538 default: 1217 default:
1539 return; /* we do not support this color depth */ 1218 return; /* we do not support this color depth */
1540 } 1219 }
1541 1220
1221 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1222
1223 if (bg_flags & BG_TINT_SET)
1224 tint.get (c);
1225
1542 /* prepare limits for color transformation (each channel is handled separately) */ 1226 /* prepare limits for color transformation (each channel is handled separately) */
1543 if (shade > 100) 1227 if (shade > 100)
1544 { 1228 {
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; 1229 c.r = c.r * (200 - shade) / 100;
1552 low.g = 65535 * (100 - shade) / 100; 1230 c.g = c.g * (200 - shade) / 100;
1553 low.b = 65535 * (100 - shade) / 100; 1231 c.b = c.b * (200 - shade) / 100;
1232
1233 low = 0xffff * (shade - 100) / 100;
1554 } 1234 }
1555 else 1235 else
1556 { 1236 {
1557 high.r = c.r * shade / 100; 1237 c.r = c.r * shade / 100;
1558 high.g = c.g * shade / 100; 1238 c.g = c.g * shade / 100;
1559 high.b = c.b * shade / 100; 1239 c.b = c.b * shade / 100;
1560 1240
1561 low.r = low.g = low.b = 0; 1241 low = 0;
1562 } 1242 }
1563 1243
1564 /* fill our lookup tables */ 1244 /* fill our lookup tables */
1565 for (i = 0; i <= mask_r>>sh_r; i++) 1245 fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1566 { 1246 fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1567 uint32_t tmp; 1247 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 1248
1587 /* apply table to input image (replacing colors by newly calculated ones) */ 1249 /* apply table to input image (replacing colors by newly calculated ones) */
1588 if (ximage->bits_per_pixel == 32 1250 if (ximage->bits_per_pixel == 32
1589 && (ximage->depth == 24 || ximage->depth == 32) 1251 && (ximage->depth == 24 || ximage->depth == 32)
1590 && ximage->byte_order == host_byte_order) 1252 && ximage->byte_order == host_byte_order)
… …
1620 } 1282 }
1621 } 1283 }
1622 1284
1623 free (lookup); 1285 free (lookup);
1624} 1286}
1625#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */ 1287#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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