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.194 by sf-exg, Sun Jan 1 17:43:47 2012 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>
31#endif 31#endif
32 32
33#ifndef FilterConvolution 33#ifndef FilterConvolution
34#define FilterConvolution "convolution" 34#define FilterConvolution "convolution"
35#endif
36
37#ifndef RepeatPad
38#define RepeatPad True
35#endif 39#endif
36 40
37#ifdef HAVE_BG_PIXMAP 41#ifdef HAVE_BG_PIXMAP
38# if XRENDER 42# if XRENDER
39static Picture 43static Picture
… …
54# endif 58# endif
55 59
56void 60void
57rxvt_term::bg_destroy () 61rxvt_term::bg_destroy ()
58{ 62{
59#ifdef HAVE_AFTERIMAGE
60 if (original_asim)
61 safe_asimage_destroy (original_asim);
62 if (asv)
63 destroy_asvisual (asv, 0);
64 if (asimman)
65 destroy_image_manager (asimman, 0);
66#endif
67
68#ifdef HAVE_PIXBUF 63#ifdef HAVE_PIXBUF
69 if (pixbuf) 64 if (pixbuf)
70 g_object_unref (pixbuf); 65 g_object_unref (pixbuf);
71#endif 66#endif
72 67
… …
125 120
126 return false; 121 return false;
127} 122}
128 123
129# ifdef BG_IMAGE_FROM_FILE 124# ifdef BG_IMAGE_FROM_FILE
130static inline bool
131check_set_scale_value (int geom_flags, int flag, unsigned int &scale, unsigned int new_value)
132{
133 if (geom_flags & flag)
134 {
135 if (new_value > 1000)
136 new_value = 1000;
137 if (new_value != scale)
138 {
139 scale = new_value;
140 return true;
141 }
142 }
143 return false;
144}
145
146static inline bool
147check_set_align_value (int geom_flags, int flag, int &align, int new_value)
148{
149 if (geom_flags & flag)
150 {
151 if (new_value < -100)
152 new_value = -100;
153 else if (new_value > 200)
154 new_value = 200;
155 if (new_value != align)
156 {
157 align = new_value;
158 return true;
159 }
160 }
161 return false;
162}
163
164static inline int 125static inline int
165make_align_position (int align, int window_size, int image_size) 126make_align_position (int align, int window_size, int image_size)
166{ 127{
167 int diff = window_size - image_size;
168 int smaller = min (image_size, window_size);
169
170 if (align >= 0 && align <= 100) 128 if (align >= 0 && align <= 100)
171 return diff * align / 100; 129 return lerp (0, window_size - image_size, align);
172 else if (align > 100 && align <= 200) 130 else if (align > 100)
173 return (align - 100) * smaller / 100 + window_size - smaller; 131 return lerp (window_size - image_size, window_size, align - 100);
174 else if (align >= -100 && align < 0) 132 else
175 return (align + 100) * smaller / 100 - image_size; 133 return lerp (-image_size, 0, align + 100);
176 return 0;
177} 134}
178 135
179static inline int 136static inline int
180make_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)
181{ 138{
… …
187 src_pos = -pos; 144 src_pos = -pos;
188 dst_pos = 0; 145 dst_pos = 0;
189 dst_size += pos; 146 dst_size += pos;
190 } 147 }
191 148
192 if (dst_pos + dst_size > target_size)
193 dst_size = target_size - dst_pos; 149 min_it (dst_size, target_size - dst_pos);
194 return src_pos; 150 return src_pos;
195} 151}
196 152
197bool 153bool
198rxvt_term::bg_set_geometry (const char *geom, bool update) 154rxvt_term::bg_set_geometry (const char *geom, bool update)
199{ 155{
200 bool changed = false; 156 bool changed = false;
201 int geom_flags = 0; 157 int geom_flags = 0;
202 int x = 0, y = 0; 158 int x = h_align;
159 int y = v_align;
203 unsigned int w = 0, h = 0; 160 unsigned int w = h_scale;
161 unsigned int h = v_scale;
204 unsigned long new_flags = 0; 162 unsigned long new_flags = 0;
205 163
206 if (geom == NULL) 164 if (geom == NULL)
207 return false; 165 return false;
208 166
… …
317 w = h = defaultScale; 275 w = h = defaultScale;
318 else if (!(geom_flags & HeightValue)) 276 else if (!(geom_flags & HeightValue))
319 h = w; 277 h = w;
320 else if (!(geom_flags & WidthValue)) 278 else if (!(geom_flags & WidthValue))
321 w = h; 279 w = h;
322
323 geom_flags |= WidthValue|HeightValue|XValue|YValue;
324 } 280 }
325 281
326 if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true; 282 min_it (w, 1000);
327 if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true; 283 min_it (h, 1000);
328 if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true; 284 clamp_it (x, -100, 200);
329 if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true; 285 clamp_it (y, -100, 200);
330 286
331 if (new_flags != bg_flags) 287 if (bg_flags != new_flags
288 || h_scale != w
289 || v_scale != h
290 || h_align != x
291 || v_align != y)
332 { 292 {
333 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;
334 changed = true; 298 changed = true;
335 } 299 }
336 300
337 return changed; 301 return changed;
338} 302}
… …
366 { 330 {
367 x = make_align_position (h_align, target_width, w); 331 x = make_align_position (h_align, target_width, w);
368 y = make_align_position (v_align, target_height, h); 332 y = make_align_position (v_align, target_height, h);
369 } 333 }
370 334
371 bg_flags &= ~BG_IS_SIZE_SENSITIVE;
372 if (!(bg_flags & BG_TILE) 335 if (!(bg_flags & BG_TILE)
373 || h_scale || v_scale 336 || h_scale || v_scale
374 || (!(bg_flags & BG_ROOT_ALIGN) && (h_align || v_align)) 337 || (!(bg_flags & BG_ROOT_ALIGN) && (h_align || v_align))
375 || w > target_width || h > target_height) 338 || image_width > target_width || image_height > target_height)
376 bg_flags |= BG_IS_SIZE_SENSITIVE; 339 bg_flags |= BG_IS_SIZE_SENSITIVE;
377}
378
379# ifdef HAVE_AFTERIMAGE
380bool
381rxvt_term::render_image (unsigned long tr_flags)
382{
383 init_asv ();
384
385 ASImage *background = NULL;
386 ARGB32 background_tint = TINT_LEAVE_SAME;
387
388# ifdef ENABLE_TRANSPARENCY
389 if (tr_flags)
390 background = pixmap2ximage (asv, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, 100);
391
392 if (tr_flags & BG_NEEDS_TINT)
393 {
394 ShadingInfo as_shade;
395 as_shade.shading = shade;
396
397 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
398 if (bg_flags & BG_TINT_SET)
399 tint.get (c);
400 as_shade.tintColor.red = c.r;
401 as_shade.tintColor.green = c.g;
402 as_shade.tintColor.blue = c.b;
403
404 background_tint = shading2tint32 (&as_shade);
405 }
406
407 if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)
408 {
409 ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,
410 ASA_XImage,
411 100, ASIMAGE_QUALITY_DEFAULT);
412 if (tmp)
413 {
414 destroy_asimage (&background);
415 background = tmp;
416 }
417 }
418# endif
419
420 ASImage *result = 0;
421
422 int target_width = szHint.width;
423 int target_height = szHint.height;
424 int new_pmap_width = target_width;
425 int new_pmap_height = target_height;
426
427 int x = 0;
428 int y = 0;
429 int w = 0;
430 int h = 0;
431
432 if (original_asim)
433 get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
434
435 if (!original_asim
436 || (!(bg_flags & BG_ROOT_ALIGN)
437 && (x >= target_width
438 || y >= target_height
439 || x + w <= 0
440 || y + h <= 0)))
441 {
442 if (background)
443 {
444 new_pmap_width = background->width;
445 new_pmap_height = background->height;
446 result = background;
447
448 if (background_tint != TINT_LEAVE_SAME)
449 {
450 ASImage *tmp = tile_asimage (asv, background, 0, 0,
451 target_width, target_height, background_tint,
452 ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
453 if (tmp)
454 result = tmp;
455 }
456 }
457 else
458 new_pmap_width = new_pmap_height = 0;
459 }
460 else 340 else
461 { 341 bg_flags &= ~BG_IS_SIZE_SENSITIVE;
462 result = original_asim;
463
464 if (w != original_asim->width
465 || h != original_asim->height)
466 {
467 result = scale_asimage (asv, original_asim,
468 w, h,
469 ASA_XImage,
470 100, ASIMAGE_QUALITY_DEFAULT);
471 }
472
473 if (background == NULL)
474 {
475 if (bg_flags & BG_TILE)
476 {
477 /* if tiling - pixmap has to be sized exactly as the image,
478 but there is no need to make it bigger than the window! */
479 new_pmap_width = min (result->width, target_width);
480 new_pmap_height = min (result->height, target_height);
481
482 /* we also need to tile our image in both directions */
483 ASImage *tmp = tile_asimage (asv, result,
484 (int)result->width - x,
485 (int)result->height - y,
486 new_pmap_width,
487 new_pmap_height,
488 TINT_LEAVE_SAME, ASA_XImage,
489 100, ASIMAGE_QUALITY_DEFAULT);
490 if (tmp)
491 {
492 if (result != original_asim)
493 destroy_asimage (&result);
494
495 result = tmp;
496 }
497 }
498 }
499 else
500 {
501 /* if blending background and image - pixmap has to be sized same as target window */
502 ASImageLayer *layers = create_image_layers (2);
503
504 layers[0].im = background;
505 layers[0].clip_width = target_width;
506 layers[0].clip_height = target_height;
507 layers[0].tint = background_tint;
508 layers[1].im = result;
509
510 if (bg_flags & BG_TILE)
511 {
512 /* tile horizontally */
513 while (x > 0) x -= (int)result->width;
514 layers[1].dst_x = x;
515 layers[1].clip_width = result->width+target_width;
516 }
517 else
518 {
519 /* clip horizontally */
520 layers[1].dst_x = x;
521 layers[1].clip_width = result->width;
522 }
523
524 if (bg_flags & BG_TILE)
525 {
526 while (y > 0) y -= (int)result->height;
527 layers[1].dst_y = y;
528 layers[1].clip_height = result->height + target_height;
529 }
530 else
531 {
532 layers[1].dst_y = y;
533 layers[1].clip_height = result->height;
534 }
535
536 if (rs[Rs_blendtype])
537 {
538 layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
539 if (layers[1].merge_scanlines == NULL)
540 layers[1].merge_scanlines = alphablend_scanlines;
541 }
542
543 ASImage *tmp = merge_layers (asv, layers, 2, target_width, target_height,
544 ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
545
546 if (tmp)
547 {
548 if (result != original_asim)
549 destroy_asimage (&result);
550
551 result = tmp;
552 }
553
554 free (layers);
555 }
556 }
557
558 bool ret = false;
559
560 if (result)
561 {
562 XGCValues gcv;
563 GC gc;
564
565 /* create Pixmap */
566 if (bg_pixmap == None
567 || bg_pmap_width != new_pmap_width
568 || bg_pmap_height != new_pmap_height)
569 {
570 if (bg_pixmap)
571 XFreePixmap (dpy, bg_pixmap);
572 bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
573 bg_pmap_width = new_pmap_width;
574 bg_pmap_height = new_pmap_height;
575 }
576 /* fill with background color (if result's not completely overlapping it) */
577 gcv.foreground = pix_colors[Color_bg];
578 gc = XCreateGC (dpy, vt, GCForeground, &gcv);
579
580 int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
581 int dst_width = result->width, dst_height = result->height;
582 if (background == NULL)
583 {
584 if (!(bg_flags & BG_TILE))
585 {
586 src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );
587 src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
588 }
589
590 if (dst_x > 0 || dst_y > 0
591 || dst_x + dst_width < new_pmap_width
592 || dst_y + dst_height < new_pmap_height)
593 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
594 }
595
596 /* put result on pixmap */
597 if (dst_x < new_pmap_width && dst_y < new_pmap_height)
598 asimage2drawable (asv, bg_pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);
599
600 if (result != background && result != original_asim)
601 destroy_asimage (&result);
602
603 XFreeGC (dpy, gc);
604
605 ret = true;
606 }
607
608 if (background)
609 destroy_asimage (&background);
610
611 return ret;
612} 342}
613# endif /* HAVE_AFTERIMAGE */
614 343
615# ifdef HAVE_PIXBUF 344# ifdef HAVE_PIXBUF
616bool 345bool
617rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc, 346rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
618 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,
… …
695 XDestroyImage (ximage); 424 XDestroyImage (ximage);
696 return true; 425 return true;
697} 426}
698 427
699bool 428bool
700rxvt_term::render_image (unsigned long tr_flags) 429rxvt_term::render_image (bool transparent)
701{ 430{
702 if (!pixbuf) 431 if (!pixbuf)
703 return false; 432 return false;
704 433
705 if (tr_flags 434 if (transparent
706 && !(bg_flags & BG_HAS_RENDER)) 435 && !(bg_flags & BG_HAS_RENDER))
707 return false; 436 return false;
708 437
709 GdkPixbuf *result; 438 GdkPixbuf *result;
710 439
… …
750 Pixmap root_pmap; 479 Pixmap root_pmap;
751 480
752 image_width = gdk_pixbuf_get_width (result); 481 image_width = gdk_pixbuf_get_width (result);
753 image_height = gdk_pixbuf_get_height (result); 482 image_height = gdk_pixbuf_get_height (result);
754 483
755 if (tr_flags) 484 if (transparent)
756 { 485 {
757 root_pmap = bg_pixmap; 486 root_pmap = bg_pixmap;
758 bg_pixmap = None; 487 bg_pixmap = None;
759 } 488 }
760 else 489 else
… …
818 dst_x, dst_y, 547 dst_x, dst_y,
819 dst_width, dst_height); 548 dst_width, dst_height);
820 } 549 }
821 550
822#if XRENDER 551#if XRENDER
823 if (tr_flags) 552 if (transparent)
824 { 553 {
825 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 554 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
826 555
827 Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0); 556 Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
828 557
… …
852 } 581 }
853 582
854 if (result != pixbuf) 583 if (result != pixbuf)
855 g_object_unref (result); 584 g_object_unref (result);
856 585
857 if (tr_flags) 586 if (transparent)
858 XFreePixmap (dpy, root_pmap); 587 XFreePixmap (dpy, root_pmap);
859 588
860 return ret; 589 return ret;
861} 590}
862# endif /* HAVE_PIXBUF */ 591# endif /* HAVE_PIXBUF */
… …
877 memcpy (f, file, len); 606 memcpy (f, file, len);
878 f[len] = '\0'; 607 f[len] = '\0';
879 file = f; 608 file = f;
880 } 609 }
881 610
882# ifdef HAVE_AFTERIMAGE
883 if (!asimman)
884 asimman = create_generic_imageman (rs[Rs_path]);
885 ASImage *image = get_asimage (asimman, file, 0xFFFFFFFF, 100);
886 if (image)
887 {
888 if (original_asim)
889 safe_asimage_destroy (original_asim);
890 original_asim = image;
891 bg_flags |= BG_IS_FROM_FILE | BG_CLIENT_RENDER;
892 ret = true;
893 }
894# endif
895
896# ifdef HAVE_PIXBUF 611# ifdef HAVE_PIXBUF
897 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL); 612 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
898 if (image) 613 if (image)
899 { 614 {
900 if (pixbuf) 615 if (pixbuf)
… …
957 { 672 {
958 changed = true; 673 changed = true;
959 v_blurRadius = vr; 674 v_blurRadius = vr;
960 } 675 }
961 676
962 if (h_blurRadius == 0 || v_blurRadius == 0) 677 if (h_blurRadius && v_blurRadius)
678 bg_flags |= BG_NEEDS_BLUR;
679 else
963 bg_flags &= ~BG_NEEDS_BLUR; 680 bg_flags &= ~BG_NEEDS_BLUR;
964 else
965 bg_flags |= BG_NEEDS_BLUR;
966 681
967 return changed; 682 return changed;
968} 683}
969 684
970void 685void
971rxvt_term::set_tint_shade_flags () 686rxvt_term::set_tint_shade_flags ()
972{ 687{
688 if (shade != 100 || (bg_flags & BG_TINT_SET))
689 bg_flags |= BG_NEEDS_TINT;
690 else
691 bg_flags &= ~BG_NEEDS_TINT;
692}
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;
700 bg_flags |= BG_TINT_SET;
701
973 rgba c; 702 rgba c;
974 bool has_shade = shade != 100;
975
976 bg_flags &= ~BG_TINT_FLAGS;
977
978 if (bg_flags & BG_TINT_SET)
979 {
980 tint.get (c); 703 tint.get (c);
981 if (!has_shade
982 && (c.r <= 0x00ff || c.r >= 0xff00) 704 if ((c.r <= 0x00ff || c.r >= 0xff00)
983 && (c.g <= 0x00ff || c.g >= 0xff00) 705 && (c.g <= 0x00ff || c.g >= 0xff00)
984 && (c.b <= 0x00ff || c.b >= 0xff00)) 706 && (c.b <= 0x00ff || c.b >= 0xff00))
985 bg_flags |= BG_TINT_BITAND; 707 bg_flags |= BG_TINT_BITAND;
986 } 708 else
987
988 if (has_shade || (bg_flags & BG_TINT_SET))
989 bg_flags |= BG_NEEDS_TINT;
990}
991
992bool
993rxvt_term::bg_set_tint (rxvt_color &new_tint)
994{
995 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
996 {
997 tint = new_tint;
998 bg_flags |= BG_TINT_SET; 709 bg_flags &= ~BG_TINT_BITAND;
710
999 set_tint_shade_flags (); 711 set_tint_shade_flags ();
1000 return true; 712 return true;
1001 } 713 }
1002 714
1003 return false; 715 return false;
… …
1044 params[i+2] = XDoubleToFixed (kernel[i] / sum); 756 params[i+2] = XDoubleToFixed (kernel[i] / sum);
1045} 757}
1046#endif 758#endif
1047 759
1048bool 760bool
1049rxvt_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)
1050{ 762{
1051 bool ret = false; 763 bool ret = false;
1052#if XRENDER 764#if XRENDER
1053 if (!(bg_flags & BG_HAS_RENDER_CONV)) 765 if (!(bg_flags & BG_HAS_RENDER_CONV))
1054 return false; 766 return false;
1055 767
1056 int size = max (h_blurRadius, v_blurRadius) * 2 + 1; 768 int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1057 double *kernel = (double *)malloc (size * sizeof (double)); 769 double *kernel = (double *)malloc (size * sizeof (double));
1058 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 770 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1059 771
772 XRenderPictureAttributes pa;
1060 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 773 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1061 774
775 pa.repeat = RepeatPad;
1062 Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, 0); 776 Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
777 Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1063 Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, 0); 778 Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
779 XFreePixmap (dpy, tmp);
1064 780
1065 if (kernel && params) 781 if (kernel && params)
1066 { 782 {
1067 size = h_blurRadius * 2 + 1; 783 size = h_blurRadius * 2 + 1;
1068 get_gaussian_kernel (h_blurRadius, size, kernel, params); 784 get_gaussian_kernel (h_blurRadius, size, kernel, params);
… …
1076 0, 0, 792 0, 0,
1077 0, 0, 793 0, 0,
1078 0, 0, 794 0, 0,
1079 width, height); 795 width, height);
1080 796
797 ::swap (src, dst);
798
1081 size = v_blurRadius * 2 + 1; 799 size = v_blurRadius * 2 + 1;
1082 get_gaussian_kernel (v_blurRadius, size, kernel, params); 800 get_gaussian_kernel (v_blurRadius, size, kernel, params);
1083 ::swap (params[0], params[1]); 801 ::swap (params[0], params[1]);
1084 802
1085 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 803 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
… …
1107bool 825bool
1108rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 826rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1109{ 827{
1110 bool ret = false; 828 bool ret = false;
1111 829
1112 if (bg_flags & BG_TINT_BITAND) 830 if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1113 { 831 {
1114 XGCValues gcv; 832 XGCValues gcv;
1115 GC gc; 833 GC gc;
1116 834
1117 /* In this case we can tint image server-side getting significant 835 /* In this case we can tint image server-side getting significant
… …
1198/* 916/*
1199 * 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
1200 * 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
1201 * our window. 919 * our window.
1202 */ 920 */
1203unsigned long 921bool
1204rxvt_term::make_transparency_pixmap () 922rxvt_term::make_transparency_pixmap ()
1205{ 923{
1206 unsigned long result = 0; 924 bool ret = false;
1207 925
1208 /* 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
1209 * be always up-to-date, so let's use it : 927 * be always up-to-date, so let's use it :
1210 */ 928 */
1211 int screen = display->screen; 929 int screen = display->screen;
… …
1292 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); 1010 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1293 1011
1294 if (gc) 1012 if (gc)
1295 { 1013 {
1296 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height); 1014 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1297 result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS); 1015 ret = true;
1016 unsigned long tr_flags = bg_flags & BG_EFFECTS_FLAGS;
1298 1017
1299 if (!(bg_flags & BG_CLIENT_RENDER)) 1018 if (!(bg_flags & BG_CLIENT_RENDER))
1300 { 1019 {
1301 if (bg_flags & BG_NEEDS_BLUR) 1020 if (bg_flags & BG_NEEDS_BLUR)
1302 { 1021 {
1303 if (blur_pixmap (bg_pixmap, visual, window_width, window_height)) 1022 if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth))
1304 result &= ~BG_NEEDS_BLUR; 1023 tr_flags &= ~BG_NEEDS_BLUR;
1305 } 1024 }
1306 if (bg_flags & BG_NEEDS_TINT) 1025 if (bg_flags & BG_NEEDS_TINT)
1307 { 1026 {
1308 if (tint_pixmap (bg_pixmap, visual, window_width, window_height)) 1027 if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1309 result &= ~BG_NEEDS_TINT; 1028 tr_flags &= ~BG_NEEDS_TINT;
1310 } 1029 }
1311# ifndef HAVE_AFTERIMAGE
1312 if (result & BG_NEEDS_TINT) 1030 if (tr_flags & BG_NEEDS_TINT)
1313 { 1031 {
1314 XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap); 1032 XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1315 if (ximage) 1033 if (ximage)
1316 { 1034 {
1317 /* our own client-side tinting */ 1035 /* our own client-side tinting */
… …
1319 1037
1320 XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height); 1038 XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
1321 XDestroyImage (ximage); 1039 XDestroyImage (ximage);
1322 } 1040 }
1323 } 1041 }
1324# endif
1325 } /* server side rendering completed */ 1042 } /* server side rendering completed */
1326 1043
1327 XFreeGC (dpy, gc); 1044 XFreeGC (dpy, gc);
1328 } 1045 }
1329 1046
1330 if (recoded_root_pmap != root_pixmap) 1047 if (recoded_root_pmap != root_pixmap)
1331 XFreePixmap (dpy, recoded_root_pmap); 1048 XFreePixmap (dpy, recoded_root_pmap);
1332 1049
1333 return result; 1050 return ret;
1334} 1051}
1335 1052
1336void 1053void
1337rxvt_term::bg_set_root_pixmap () 1054rxvt_term::bg_set_root_pixmap ()
1338{ 1055{
… …
1345# endif /* ENABLE_TRANSPARENCY */ 1062# endif /* ENABLE_TRANSPARENCY */
1346 1063
1347bool 1064bool
1348rxvt_term::bg_render () 1065rxvt_term::bg_render ()
1349{ 1066{
1350 unsigned long tr_flags = 0; 1067 bool transparent = false;
1351 1068
1352 bg_invalidate (); 1069 bg_invalidate ();
1353# ifdef ENABLE_TRANSPARENCY 1070# ifdef ENABLE_TRANSPARENCY
1354 if (bg_flags & BG_IS_TRANSPARENT) 1071 if (bg_flags & BG_IS_TRANSPARENT)
1355 { 1072 {
1356 /* we need to re-generate transparency pixmap in that case ! */ 1073 /* we need to re-generate transparency pixmap in that case ! */
1357 tr_flags = make_transparency_pixmap (); 1074 transparent = make_transparency_pixmap ();
1358 if (tr_flags == 0) 1075 if (transparent)
1359 return false;
1360 bg_flags |= BG_IS_VALID; 1076 bg_flags |= BG_IS_VALID;
1361 } 1077 }
1362# endif 1078# endif
1363 1079
1364# ifdef BG_IMAGE_FROM_FILE 1080# ifdef BG_IMAGE_FROM_FILE
1365 if ((bg_flags & BG_IS_FROM_FILE) 1081 if (bg_flags & BG_IS_FROM_FILE)
1366 || (tr_flags & BG_EFFECTS_FLAGS))
1367 { 1082 {
1368 if (render_image (tr_flags)) 1083 if (render_image (transparent))
1369 bg_flags |= BG_IS_VALID; 1084 bg_flags |= BG_IS_VALID;
1370 } 1085 }
1371# endif 1086# endif
1372 1087
1373 if (!(bg_flags & BG_IS_VALID)) 1088 if (!(bg_flags & BG_IS_VALID))
… …
1411#endif 1126#endif
1412} 1127}
1413 1128
1414#endif /* HAVE_BG_PIXMAP */ 1129#endif /* HAVE_BG_PIXMAP */
1415 1130
1416#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) 1131#ifdef ENABLE_TRANSPARENCY
1417/* based on code from aterm-0.4.2 */ 1132/* based on code from aterm-0.4.2 */
1418 1133
1419static inline void 1134static inline void
1420fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high) 1135fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
1421{ 1136{
… …
1567 } 1282 }
1568 } 1283 }
1569 1284
1570 free (lookup); 1285 free (lookup);
1571} 1286}
1572#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */ 1287#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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