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.193 by sf-exg, Sun Jan 1 14:31:29 2012 UTC vs.
Revision 1.204 by sf-exg, Tue Apr 10 15:19:22 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; 128 int diff = window_size - image_size;
168 int smaller = min (image_size, window_size); 129 int smaller = min (image_size, window_size);
… …
187 src_pos = -pos; 148 src_pos = -pos;
188 dst_pos = 0; 149 dst_pos = 0;
189 dst_size += pos; 150 dst_size += pos;
190 } 151 }
191 152
192 if (dst_pos + dst_size > target_size)
193 dst_size = target_size - dst_pos; 153 min_it (dst_size, target_size - dst_pos);
194 return src_pos; 154 return src_pos;
195} 155}
196 156
197bool 157bool
198rxvt_term::bg_set_geometry (const char *geom, bool update) 158rxvt_term::bg_set_geometry (const char *geom, bool update)
199{ 159{
200 bool changed = false; 160 bool changed = false;
201 int geom_flags = 0; 161 int geom_flags = 0;
202 int x = 0, y = 0; 162 int x = h_align;
163 int y = v_align;
203 unsigned int w = 0, h = 0; 164 unsigned int w = h_scale;
165 unsigned int h = v_scale;
204 unsigned long new_flags = 0; 166 unsigned long new_flags = 0;
205 167
206 if (geom == NULL) 168 if (geom == NULL)
207 return false; 169 return false;
208 170
… …
317 w = h = defaultScale; 279 w = h = defaultScale;
318 else if (!(geom_flags & HeightValue)) 280 else if (!(geom_flags & HeightValue))
319 h = w; 281 h = w;
320 else if (!(geom_flags & WidthValue)) 282 else if (!(geom_flags & WidthValue))
321 w = h; 283 w = h;
322
323 geom_flags |= WidthValue|HeightValue|XValue|YValue;
324 } 284 }
325 285
326 if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true; 286 min_it (w, 1000);
327 if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true; 287 min_it (h, 1000);
328 if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true; 288 clamp_it (x, -100, 200);
329 if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true; 289 clamp_it (y, -100, 200);
330 290
331 if (new_flags != bg_flags) 291 if (bg_flags != new_flags
292 || h_scale != w
293 || v_scale != h
294 || h_align != x
295 || v_align != y)
332 { 296 {
333 bg_flags = new_flags; 297 bg_flags = new_flags;
298 h_scale = w;
299 v_scale = h;
300 h_align = x;
301 v_align = y;
334 changed = true; 302 changed = true;
335 } 303 }
336 304
337 return changed; 305 return changed;
338} 306}
… …
366 { 334 {
367 x = make_align_position (h_align, target_width, w); 335 x = make_align_position (h_align, target_width, w);
368 y = make_align_position (v_align, target_height, h); 336 y = make_align_position (v_align, target_height, h);
369 } 337 }
370 338
371 bg_flags &= ~BG_IS_SIZE_SENSITIVE;
372 if (!(bg_flags & BG_TILE) 339 if (!(bg_flags & BG_TILE)
373 || h_scale || v_scale 340 || h_scale || v_scale
374 || (!(bg_flags & BG_ROOT_ALIGN) && (h_align || v_align)) 341 || (!(bg_flags & BG_ROOT_ALIGN) && (h_align || v_align))
375 || w > target_width || h > target_height) 342 || image_width > target_width || image_height > target_height)
376 bg_flags |= BG_IS_SIZE_SENSITIVE; 343 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;
398 tint.get (c);
399 as_shade.tintColor.red = c.r;
400 as_shade.tintColor.green = c.g;
401 as_shade.tintColor.blue = c.b;
402
403 background_tint = shading2tint32 (&as_shade);
404 }
405
406 if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)
407 {
408 ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,
409 ASA_XImage,
410 100, ASIMAGE_QUALITY_DEFAULT);
411 if (tmp)
412 {
413 destroy_asimage (&background);
414 background = tmp;
415 }
416 }
417# endif
418
419 ASImage *result = 0;
420
421 int target_width = szHint.width;
422 int target_height = szHint.height;
423 int new_pmap_width = target_width;
424 int new_pmap_height = target_height;
425
426 int x = 0;
427 int y = 0;
428 int w = 0;
429 int h = 0;
430
431 if (original_asim)
432 get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
433
434 if (!original_asim
435 || (!(bg_flags & BG_ROOT_ALIGN)
436 && (x >= target_width
437 || y >= target_height
438 || x + w <= 0
439 || y + h <= 0)))
440 {
441 if (background)
442 {
443 new_pmap_width = background->width;
444 new_pmap_height = background->height;
445 result = background;
446
447 if (background_tint != TINT_LEAVE_SAME)
448 {
449 ASImage *tmp = tile_asimage (asv, background, 0, 0,
450 target_width, target_height, background_tint,
451 ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
452 if (tmp)
453 result = tmp;
454 }
455 }
456 else
457 new_pmap_width = new_pmap_height = 0;
458 }
459 else 344 else
460 { 345 bg_flags &= ~BG_IS_SIZE_SENSITIVE;
461 result = original_asim;
462
463 if (w != original_asim->width
464 || h != original_asim->height)
465 {
466 result = scale_asimage (asv, original_asim,
467 w, h,
468 ASA_XImage,
469 100, ASIMAGE_QUALITY_DEFAULT);
470 }
471
472 if (background == NULL)
473 {
474 if (bg_flags & BG_TILE)
475 {
476 /* if tiling - pixmap has to be sized exactly as the image,
477 but there is no need to make it bigger than the window! */
478 new_pmap_width = min (result->width, target_width);
479 new_pmap_height = min (result->height, target_height);
480
481 /* we also need to tile our image in both directions */
482 ASImage *tmp = tile_asimage (asv, result,
483 (int)result->width - x,
484 (int)result->height - y,
485 new_pmap_width,
486 new_pmap_height,
487 TINT_LEAVE_SAME, ASA_XImage,
488 100, ASIMAGE_QUALITY_DEFAULT);
489 if (tmp)
490 {
491 if (result != original_asim)
492 destroy_asimage (&result);
493
494 result = tmp;
495 }
496 }
497 }
498 else
499 {
500 /* if blending background and image - pixmap has to be sized same as target window */
501 ASImageLayer *layers = create_image_layers (2);
502
503 layers[0].im = background;
504 layers[0].clip_width = target_width;
505 layers[0].clip_height = target_height;
506 layers[0].tint = background_tint;
507 layers[1].im = result;
508
509 if (bg_flags & BG_TILE)
510 {
511 /* tile horizontally */
512 while (x > 0) x -= (int)result->width;
513 layers[1].dst_x = x;
514 layers[1].clip_width = result->width+target_width;
515 }
516 else
517 {
518 /* clip horizontally */
519 layers[1].dst_x = x;
520 layers[1].clip_width = result->width;
521 }
522
523 if (bg_flags & BG_TILE)
524 {
525 while (y > 0) y -= (int)result->height;
526 layers[1].dst_y = y;
527 layers[1].clip_height = result->height + target_height;
528 }
529 else
530 {
531 layers[1].dst_y = y;
532 layers[1].clip_height = result->height;
533 }
534
535 if (rs[Rs_blendtype])
536 {
537 layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
538 if (layers[1].merge_scanlines == NULL)
539 layers[1].merge_scanlines = alphablend_scanlines;
540 }
541
542 ASImage *tmp = merge_layers (asv, layers, 2, target_width, target_height,
543 ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
544
545 if (tmp)
546 {
547 if (result != original_asim)
548 destroy_asimage (&result);
549
550 result = tmp;
551 }
552
553 free (layers);
554 }
555 }
556
557 bool ret = false;
558
559 if (result)
560 {
561 XGCValues gcv;
562 GC gc;
563
564 /* create Pixmap */
565 if (bg_pixmap == None
566 || bg_pmap_width != new_pmap_width
567 || bg_pmap_height != new_pmap_height)
568 {
569 if (bg_pixmap)
570 XFreePixmap (dpy, bg_pixmap);
571 bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
572 bg_pmap_width = new_pmap_width;
573 bg_pmap_height = new_pmap_height;
574 }
575 /* fill with background color (if result's not completely overlapping it) */
576 gcv.foreground = pix_colors[Color_bg];
577 gc = XCreateGC (dpy, vt, GCForeground, &gcv);
578
579 int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
580 int dst_width = result->width, dst_height = result->height;
581 if (background == NULL)
582 {
583 if (!(bg_flags & BG_TILE))
584 {
585 src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );
586 src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
587 }
588
589 if (dst_x > 0 || dst_y > 0
590 || dst_x + dst_width < new_pmap_width
591 || dst_y + dst_height < new_pmap_height)
592 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
593 }
594
595 /* put result on pixmap */
596 if (dst_x < new_pmap_width && dst_y < new_pmap_height)
597 asimage2drawable (asv, bg_pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);
598
599 if (result != background && result != original_asim)
600 destroy_asimage (&result);
601
602 XFreeGC (dpy, gc);
603
604 ret = true;
605 }
606
607 if (background)
608 destroy_asimage (&background);
609
610 return ret;
611} 346}
612# endif /* HAVE_AFTERIMAGE */
613 347
614# ifdef HAVE_PIXBUF 348# ifdef HAVE_PIXBUF
615bool 349bool
616rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc, 350rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
617 int src_x, int src_y, int dst_x, int dst_y, 351 int src_x, int src_y, int dst_x, int dst_y,
… …
694 XDestroyImage (ximage); 428 XDestroyImage (ximage);
695 return true; 429 return true;
696} 430}
697 431
698bool 432bool
699rxvt_term::render_image (unsigned long tr_flags) 433rxvt_term::render_image (bool transparent)
700{ 434{
701 if (!pixbuf) 435 if (!pixbuf)
702 return false; 436 return false;
703 437
704 if (tr_flags 438 if (transparent
705 && !(bg_flags & BG_HAS_RENDER)) 439 && !(bg_flags & BG_HAS_RENDER))
706 return false; 440 return false;
707 441
708 GdkPixbuf *result; 442 GdkPixbuf *result;
709 443
… …
749 Pixmap root_pmap; 483 Pixmap root_pmap;
750 484
751 image_width = gdk_pixbuf_get_width (result); 485 image_width = gdk_pixbuf_get_width (result);
752 image_height = gdk_pixbuf_get_height (result); 486 image_height = gdk_pixbuf_get_height (result);
753 487
754 if (tr_flags) 488 if (transparent)
755 { 489 {
756 root_pmap = bg_pixmap; 490 root_pmap = bg_pixmap;
757 bg_pixmap = None; 491 bg_pixmap = None;
758 } 492 }
759 else 493 else
… …
817 dst_x, dst_y, 551 dst_x, dst_y,
818 dst_width, dst_height); 552 dst_width, dst_height);
819 } 553 }
820 554
821#if XRENDER 555#if XRENDER
822 if (tr_flags) 556 if (transparent)
823 { 557 {
824 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 558 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
825 559
826 Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0); 560 Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
827 561
… …
851 } 585 }
852 586
853 if (result != pixbuf) 587 if (result != pixbuf)
854 g_object_unref (result); 588 g_object_unref (result);
855 589
856 if (tr_flags) 590 if (transparent)
857 XFreePixmap (dpy, root_pmap); 591 XFreePixmap (dpy, root_pmap);
858 592
859 return ret; 593 return ret;
860} 594}
861# endif /* HAVE_PIXBUF */ 595# endif /* HAVE_PIXBUF */
… …
876 memcpy (f, file, len); 610 memcpy (f, file, len);
877 f[len] = '\0'; 611 f[len] = '\0';
878 file = f; 612 file = f;
879 } 613 }
880 614
881# ifdef HAVE_AFTERIMAGE
882 if (!asimman)
883 asimman = create_generic_imageman (rs[Rs_path]);
884 ASImage *image = get_asimage (asimman, file, 0xFFFFFFFF, 100);
885 if (image)
886 {
887 if (original_asim)
888 safe_asimage_destroy (original_asim);
889 original_asim = image;
890 bg_flags |= BG_IS_FROM_FILE | BG_CLIENT_RENDER;
891 ret = true;
892 }
893# endif
894
895# ifdef HAVE_PIXBUF 615# ifdef HAVE_PIXBUF
896 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL); 616 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
897 if (image) 617 if (image)
898 { 618 {
899 if (pixbuf) 619 if (pixbuf)
… …
956 { 676 {
957 changed = true; 677 changed = true;
958 v_blurRadius = vr; 678 v_blurRadius = vr;
959 } 679 }
960 680
961 if (h_blurRadius == 0 || v_blurRadius == 0) 681 if (h_blurRadius && v_blurRadius)
682 bg_flags |= BG_NEEDS_BLUR;
683 else
962 bg_flags &= ~BG_NEEDS_BLUR; 684 bg_flags &= ~BG_NEEDS_BLUR;
963 else
964 bg_flags |= BG_NEEDS_BLUR;
965 685
966 return changed; 686 return changed;
967} 687}
968 688
969void 689void
970rxvt_term::set_tint_shade_flags () 690rxvt_term::set_tint_shade_flags ()
971{ 691{
972 rgba c; 692 if (shade != 100 || (bg_flags & BG_TINT_SET))
973 bool has_shade = shade != 100;
974
975 bg_flags &= ~BG_TINT_FLAGS;
976
977 tint.get (c);
978
979 if (!has_shade
980 && (c.r <= 0x00ff || c.r >= 0xff00)
981 && (c.g <= 0x00ff || c.g >= 0xff00)
982 && (c.b <= 0x00ff || c.b >= 0xff00))
983 bg_flags |= BG_TINT_BITAND;
984
985 if (has_shade
986 || c.r < 0xff00
987 || c.g < 0xff00
988 || c.b < 0xff00)
989 bg_flags |= BG_NEEDS_TINT; 693 bg_flags |= BG_NEEDS_TINT;
694 else
695 bg_flags &= ~BG_NEEDS_TINT;
990} 696}
991 697
992bool 698bool
993rxvt_term::bg_set_tint (rxvt_color &new_tint) 699rxvt_term::bg_set_tint (rxvt_color &new_tint)
994{ 700{
995 if (tint != new_tint) 701 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
996 { 702 {
997 tint = new_tint; 703 tint = new_tint;
704 bg_flags |= BG_TINT_SET;
705
706 rgba c;
707 tint.get (c);
708 if ((c.r <= 0x00ff || c.r >= 0xff00)
709 && (c.g <= 0x00ff || c.g >= 0xff00)
710 && (c.b <= 0x00ff || c.b >= 0xff00))
711 bg_flags |= BG_TINT_BITAND;
712 else
713 bg_flags &= ~BG_TINT_BITAND;
714
998 set_tint_shade_flags (); 715 set_tint_shade_flags ();
999 return true; 716 return true;
1000 } 717 }
1001 718
1002 return false; 719 return false;
… …
1043 params[i+2] = XDoubleToFixed (kernel[i] / sum); 760 params[i+2] = XDoubleToFixed (kernel[i] / sum);
1044} 761}
1045#endif 762#endif
1046 763
1047bool 764bool
1048rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 765rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height, int depth)
1049{ 766{
1050 bool ret = false; 767 bool ret = false;
1051#if XRENDER 768#if XRENDER
1052 if (!(bg_flags & BG_HAS_RENDER_CONV)) 769 if (!(bg_flags & BG_HAS_RENDER_CONV))
1053 return false; 770 return false;
1054 771
1055 int size = max (h_blurRadius, v_blurRadius) * 2 + 1; 772 int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1056 double *kernel = (double *)malloc (size * sizeof (double)); 773 double *kernel = (double *)malloc (size * sizeof (double));
1057 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 774 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1058 775
776 XRenderPictureAttributes pa;
1059 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 777 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1060 778
779 pa.repeat = RepeatPad;
1061 Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, 0); 780 Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
781 Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1062 Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, 0); 782 Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
783 XFreePixmap (dpy, tmp);
1063 784
1064 if (kernel && params) 785 if (kernel && params)
1065 { 786 {
1066 size = h_blurRadius * 2 + 1; 787 size = h_blurRadius * 2 + 1;
1067 get_gaussian_kernel (h_blurRadius, size, kernel, params); 788 get_gaussian_kernel (h_blurRadius, size, kernel, params);
… …
1075 0, 0, 796 0, 0,
1076 0, 0, 797 0, 0,
1077 0, 0, 798 0, 0,
1078 width, height); 799 width, height);
1079 800
801 ::swap (src, dst);
802
1080 size = v_blurRadius * 2 + 1; 803 size = v_blurRadius * 2 + 1;
1081 get_gaussian_kernel (v_blurRadius, size, kernel, params); 804 get_gaussian_kernel (v_blurRadius, size, kernel, params);
1082 ::swap (params[0], params[1]); 805 ::swap (params[0], params[1]);
1083 806
1084 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 807 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
… …
1106bool 829bool
1107rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 830rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1108{ 831{
1109 bool ret = false; 832 bool ret = false;
1110 833
1111 if (bg_flags & BG_TINT_BITAND) 834 if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1112 { 835 {
1113 XGCValues gcv; 836 XGCValues gcv;
1114 GC gc; 837 GC gc;
1115 838
1116 /* In this case we can tint image server-side getting significant 839 /* In this case we can tint image server-side getting significant
… …
1128 } 851 }
1129 } 852 }
1130# if XRENDER 853# if XRENDER
1131 else if (bg_flags & BG_HAS_RENDER) 854 else if (bg_flags & BG_HAS_RENDER)
1132 { 855 {
1133 rgba c; 856 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1134 857
858 if (bg_flags & BG_TINT_SET)
1135 tint.get (c); 859 tint.get (c);
1136 860
1137 if (shade <= 100) 861 if (shade <= 100)
1138 { 862 {
1139 c.r = c.r * shade / 100; 863 c.r = c.r * shade / 100;
1140 c.g = c.g * shade / 100; 864 c.g = c.g * shade / 100;
… …
1196/* 920/*
1197 * Builds a pixmap of the same size as the terminal window that contains 921 * Builds a pixmap of the same size as the terminal window that contains
1198 * the tiled portion of the root pixmap that is supposed to be covered by 922 * the tiled portion of the root pixmap that is supposed to be covered by
1199 * our window. 923 * our window.
1200 */ 924 */
1201unsigned long 925bool
1202rxvt_term::make_transparency_pixmap () 926rxvt_term::make_transparency_pixmap ()
1203{ 927{
1204 unsigned long result = 0; 928 bool ret = false;
1205 929
1206 /* root dimensions may change from call to call - but Display structure should 930 /* root dimensions may change from call to call - but Display structure should
1207 * be always up-to-date, so let's use it : 931 * be always up-to-date, so let's use it :
1208 */ 932 */
1209 int screen = display->screen; 933 int screen = display->screen;
… …
1290 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); 1014 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1291 1015
1292 if (gc) 1016 if (gc)
1293 { 1017 {
1294 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height); 1018 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1295 result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS); 1019 ret = true;
1020 unsigned long tr_flags = bg_flags & BG_EFFECTS_FLAGS;
1296 1021
1297 if (!(bg_flags & BG_CLIENT_RENDER)) 1022 if (!(bg_flags & BG_CLIENT_RENDER))
1298 { 1023 {
1299 if (bg_flags & BG_NEEDS_BLUR) 1024 if (bg_flags & BG_NEEDS_BLUR)
1300 { 1025 {
1301 if (blur_pixmap (bg_pixmap, visual, window_width, window_height)) 1026 if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth))
1302 result &= ~BG_NEEDS_BLUR; 1027 tr_flags &= ~BG_NEEDS_BLUR;
1303 } 1028 }
1304 if (bg_flags & BG_NEEDS_TINT) 1029 if (bg_flags & BG_NEEDS_TINT)
1305 { 1030 {
1306 if (tint_pixmap (bg_pixmap, visual, window_width, window_height)) 1031 if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1307 result &= ~BG_NEEDS_TINT; 1032 tr_flags &= ~BG_NEEDS_TINT;
1308 } 1033 }
1309# ifndef HAVE_AFTERIMAGE
1310 if (result & BG_NEEDS_TINT) 1034 if (tr_flags & BG_NEEDS_TINT)
1311 { 1035 {
1312 XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap); 1036 XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1313 if (ximage) 1037 if (ximage)
1314 { 1038 {
1315 /* our own client-side tinting */ 1039 /* our own client-side tinting */
… …
1317 1041
1318 XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height); 1042 XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
1319 XDestroyImage (ximage); 1043 XDestroyImage (ximage);
1320 } 1044 }
1321 } 1045 }
1322# endif
1323 } /* server side rendering completed */ 1046 } /* server side rendering completed */
1324 1047
1325 XFreeGC (dpy, gc); 1048 XFreeGC (dpy, gc);
1326 } 1049 }
1327 1050
1328 if (recoded_root_pmap != root_pixmap) 1051 if (recoded_root_pmap != root_pixmap)
1329 XFreePixmap (dpy, recoded_root_pmap); 1052 XFreePixmap (dpy, recoded_root_pmap);
1330 1053
1331 return result; 1054 return ret;
1332} 1055}
1333 1056
1334void 1057void
1335rxvt_term::bg_set_root_pixmap () 1058rxvt_term::bg_set_root_pixmap ()
1336{ 1059{
… …
1343# endif /* ENABLE_TRANSPARENCY */ 1066# endif /* ENABLE_TRANSPARENCY */
1344 1067
1345bool 1068bool
1346rxvt_term::bg_render () 1069rxvt_term::bg_render ()
1347{ 1070{
1348 unsigned long tr_flags = 0; 1071 bool transparent = false;
1349 1072
1350 bg_invalidate (); 1073 bg_invalidate ();
1351# ifdef ENABLE_TRANSPARENCY 1074# ifdef ENABLE_TRANSPARENCY
1352 if (bg_flags & BG_IS_TRANSPARENT) 1075 if (bg_flags & BG_IS_TRANSPARENT)
1353 { 1076 {
1354 /* we need to re-generate transparency pixmap in that case ! */ 1077 /* we need to re-generate transparency pixmap in that case ! */
1355 tr_flags = make_transparency_pixmap (); 1078 transparent = make_transparency_pixmap ();
1356 if (tr_flags == 0) 1079 if (transparent)
1357 return false;
1358 bg_flags |= BG_IS_VALID; 1080 bg_flags |= BG_IS_VALID;
1359 } 1081 }
1360# endif 1082# endif
1361 1083
1362# ifdef BG_IMAGE_FROM_FILE 1084# ifdef BG_IMAGE_FROM_FILE
1363 if ((bg_flags & BG_IS_FROM_FILE) 1085 if (bg_flags & BG_IS_FROM_FILE)
1364 || (tr_flags & BG_EFFECTS_FLAGS))
1365 { 1086 {
1366 if (render_image (tr_flags)) 1087 if (render_image (transparent))
1367 bg_flags |= BG_IS_VALID; 1088 bg_flags |= BG_IS_VALID;
1368 } 1089 }
1369# endif 1090# endif
1370 1091
1371 if (!(bg_flags & BG_IS_VALID)) 1092 if (!(bg_flags & BG_IS_VALID))
… …
1387 1108
1388void 1109void
1389rxvt_term::bg_init () 1110rxvt_term::bg_init ()
1390{ 1111{
1391#ifdef ENABLE_TRANSPARENCY 1112#ifdef ENABLE_TRANSPARENCY
1392 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1393 tint.set (this, c);
1394 shade = 100; 1113 shade = 100;
1395#endif 1114#endif
1396 1115
1397 bg_flags &= ~(BG_HAS_RENDER | BG_HAS_RENDER_CONV); 1116 bg_flags &= ~(BG_HAS_RENDER | BG_HAS_RENDER_CONV);
1398#if XRENDER 1117#if XRENDER
… …
1411#endif 1130#endif
1412} 1131}
1413 1132
1414#endif /* HAVE_BG_PIXMAP */ 1133#endif /* HAVE_BG_PIXMAP */
1415 1134
1416#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) 1135#ifdef ENABLE_TRANSPARENCY
1417/* based on code from aterm-0.4.2 */ 1136/* based on code from aterm-0.4.2 */
1418 1137
1419static inline void 1138static inline void
1420fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high) 1139fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
1421{ 1140{
… …
1501 break; 1220 break;
1502 default: 1221 default:
1503 return; /* we do not support this color depth */ 1222 return; /* we do not support this color depth */
1504 } 1223 }
1505 1224
1506 rgba c; 1225 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1507 1226
1227 if (bg_flags & BG_TINT_SET)
1508 tint.get (c); 1228 tint.get (c);
1509 1229
1510 /* prepare limits for color transformation (each channel is handled separately) */ 1230 /* prepare limits for color transformation (each channel is handled separately) */
1511 if (shade > 100) 1231 if (shade > 100)
1512 { 1232 {
1513 c.r = c.r * (200 - shade) / 100; 1233 c.r = c.r * (200 - shade) / 100;
… …
1566 } 1286 }
1567 } 1287 }
1568 1288
1569 free (lookup); 1289 free (lookup);
1570} 1290}
1571#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */ 1291#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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