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.205 by sf-exg, Wed Apr 11 10:06:45 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);
169 130
170 if (align >= 0 && align <= 100) 131 if (align >= 0 && align <= 100)
171 return diff * align / 100; 132 return diff * align / 100;
172 else if (align > 100 && align <= 200) 133 else if (align > 100)
173 return (align - 100) * smaller / 100 + window_size - smaller; 134 return (align - 100) * smaller / 100 + window_size - smaller;
174 else if (align >= -100 && align < 0) 135 else
175 return (align + 100) * smaller / 100 - image_size; 136 return (align + 100) * smaller / 100 - image_size;
176 return 0;
177} 137}
178 138
179static inline int 139static inline int
180make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size) 140make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)
181{ 141{
… …
187 src_pos = -pos; 147 src_pos = -pos;
188 dst_pos = 0; 148 dst_pos = 0;
189 dst_size += pos; 149 dst_size += pos;
190 } 150 }
191 151
192 if (dst_pos + dst_size > target_size)
193 dst_size = target_size - dst_pos; 152 min_it (dst_size, target_size - dst_pos);
194 return src_pos; 153 return src_pos;
195} 154}
196 155
197bool 156bool
198rxvt_term::bg_set_geometry (const char *geom, bool update) 157rxvt_term::bg_set_geometry (const char *geom, bool update)
199{ 158{
200 bool changed = false; 159 bool changed = false;
201 int geom_flags = 0; 160 int geom_flags = 0;
202 int x = 0, y = 0; 161 int x = h_align;
162 int y = v_align;
203 unsigned int w = 0, h = 0; 163 unsigned int w = h_scale;
164 unsigned int h = v_scale;
204 unsigned long new_flags = 0; 165 unsigned long new_flags = 0;
205 166
206 if (geom == NULL) 167 if (geom == NULL)
207 return false; 168 return false;
208 169
… …
317 w = h = defaultScale; 278 w = h = defaultScale;
318 else if (!(geom_flags & HeightValue)) 279 else if (!(geom_flags & HeightValue))
319 h = w; 280 h = w;
320 else if (!(geom_flags & WidthValue)) 281 else if (!(geom_flags & WidthValue))
321 w = h; 282 w = h;
322
323 geom_flags |= WidthValue|HeightValue|XValue|YValue;
324 } 283 }
325 284
326 if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true; 285 min_it (w, 1000);
327 if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true; 286 min_it (h, 1000);
328 if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true; 287 clamp_it (x, -100, 200);
329 if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true; 288 clamp_it (y, -100, 200);
330 289
331 if (new_flags != bg_flags) 290 if (bg_flags != new_flags
291 || h_scale != w
292 || v_scale != h
293 || h_align != x
294 || v_align != y)
332 { 295 {
333 bg_flags = new_flags; 296 bg_flags = new_flags;
297 h_scale = w;
298 v_scale = h;
299 h_align = x;
300 v_align = y;
334 changed = true; 301 changed = true;
335 } 302 }
336 303
337 return changed; 304 return changed;
338} 305}
… …
366 { 333 {
367 x = make_align_position (h_align, target_width, w); 334 x = make_align_position (h_align, target_width, w);
368 y = make_align_position (v_align, target_height, h); 335 y = make_align_position (v_align, target_height, h);
369 } 336 }
370 337
371 bg_flags &= ~BG_IS_SIZE_SENSITIVE;
372 if (!(bg_flags & BG_TILE) 338 if (!(bg_flags & BG_TILE)
373 || h_scale || v_scale 339 || h_scale || v_scale
374 || (!(bg_flags & BG_ROOT_ALIGN) && (h_align || v_align)) 340 || (!(bg_flags & BG_ROOT_ALIGN) && (h_align || v_align))
375 || w > target_width || h > target_height) 341 || image_width > target_width || image_height > target_height)
376 bg_flags |= BG_IS_SIZE_SENSITIVE; 342 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 343 else
460 { 344 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} 345}
612# endif /* HAVE_AFTERIMAGE */
613 346
614# ifdef HAVE_PIXBUF 347# ifdef HAVE_PIXBUF
615bool 348bool
616rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc, 349rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
617 int src_x, int src_y, int dst_x, int dst_y, 350 int src_x, int src_y, int dst_x, int dst_y,
… …
694 XDestroyImage (ximage); 427 XDestroyImage (ximage);
695 return true; 428 return true;
696} 429}
697 430
698bool 431bool
699rxvt_term::render_image (unsigned long tr_flags) 432rxvt_term::render_image (bool transparent)
700{ 433{
701 if (!pixbuf) 434 if (!pixbuf)
702 return false; 435 return false;
703 436
704 if (tr_flags 437 if (transparent
705 && !(bg_flags & BG_HAS_RENDER)) 438 && !(bg_flags & BG_HAS_RENDER))
706 return false; 439 return false;
707 440
708 GdkPixbuf *result; 441 GdkPixbuf *result;
709 442
… …
749 Pixmap root_pmap; 482 Pixmap root_pmap;
750 483
751 image_width = gdk_pixbuf_get_width (result); 484 image_width = gdk_pixbuf_get_width (result);
752 image_height = gdk_pixbuf_get_height (result); 485 image_height = gdk_pixbuf_get_height (result);
753 486
754 if (tr_flags) 487 if (transparent)
755 { 488 {
756 root_pmap = bg_pixmap; 489 root_pmap = bg_pixmap;
757 bg_pixmap = None; 490 bg_pixmap = None;
758 } 491 }
759 else 492 else
… …
817 dst_x, dst_y, 550 dst_x, dst_y,
818 dst_width, dst_height); 551 dst_width, dst_height);
819 } 552 }
820 553
821#if XRENDER 554#if XRENDER
822 if (tr_flags) 555 if (transparent)
823 { 556 {
824 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 557 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
825 558
826 Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0); 559 Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
827 560
… …
851 } 584 }
852 585
853 if (result != pixbuf) 586 if (result != pixbuf)
854 g_object_unref (result); 587 g_object_unref (result);
855 588
856 if (tr_flags) 589 if (transparent)
857 XFreePixmap (dpy, root_pmap); 590 XFreePixmap (dpy, root_pmap);
858 591
859 return ret; 592 return ret;
860} 593}
861# endif /* HAVE_PIXBUF */ 594# endif /* HAVE_PIXBUF */
… …
876 memcpy (f, file, len); 609 memcpy (f, file, len);
877 f[len] = '\0'; 610 f[len] = '\0';
878 file = f; 611 file = f;
879 } 612 }
880 613
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 614# ifdef HAVE_PIXBUF
896 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL); 615 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
897 if (image) 616 if (image)
898 { 617 {
899 if (pixbuf) 618 if (pixbuf)
… …
956 { 675 {
957 changed = true; 676 changed = true;
958 v_blurRadius = vr; 677 v_blurRadius = vr;
959 } 678 }
960 679
961 if (h_blurRadius == 0 || v_blurRadius == 0) 680 if (h_blurRadius && v_blurRadius)
681 bg_flags |= BG_NEEDS_BLUR;
682 else
962 bg_flags &= ~BG_NEEDS_BLUR; 683 bg_flags &= ~BG_NEEDS_BLUR;
963 else
964 bg_flags |= BG_NEEDS_BLUR;
965 684
966 return changed; 685 return changed;
967} 686}
968 687
969void 688void
970rxvt_term::set_tint_shade_flags () 689rxvt_term::set_tint_shade_flags ()
971{ 690{
972 rgba c; 691 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; 692 bg_flags |= BG_NEEDS_TINT;
693 else
694 bg_flags &= ~BG_NEEDS_TINT;
990} 695}
991 696
992bool 697bool
993rxvt_term::bg_set_tint (rxvt_color &new_tint) 698rxvt_term::bg_set_tint (rxvt_color &new_tint)
994{ 699{
995 if (tint != new_tint) 700 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
996 { 701 {
997 tint = new_tint; 702 tint = new_tint;
703 bg_flags |= BG_TINT_SET;
704
705 rgba c;
706 tint.get (c);
707 if ((c.r <= 0x00ff || c.r >= 0xff00)
708 && (c.g <= 0x00ff || c.g >= 0xff00)
709 && (c.b <= 0x00ff || c.b >= 0xff00))
710 bg_flags |= BG_TINT_BITAND;
711 else
712 bg_flags &= ~BG_TINT_BITAND;
713
998 set_tint_shade_flags (); 714 set_tint_shade_flags ();
999 return true; 715 return true;
1000 } 716 }
1001 717
1002 return false; 718 return false;
… …
1043 params[i+2] = XDoubleToFixed (kernel[i] / sum); 759 params[i+2] = XDoubleToFixed (kernel[i] / sum);
1044} 760}
1045#endif 761#endif
1046 762
1047bool 763bool
1048rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 764rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height, int depth)
1049{ 765{
1050 bool ret = false; 766 bool ret = false;
1051#if XRENDER 767#if XRENDER
1052 if (!(bg_flags & BG_HAS_RENDER_CONV)) 768 if (!(bg_flags & BG_HAS_RENDER_CONV))
1053 return false; 769 return false;
1054 770
1055 int size = max (h_blurRadius, v_blurRadius) * 2 + 1; 771 int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1056 double *kernel = (double *)malloc (size * sizeof (double)); 772 double *kernel = (double *)malloc (size * sizeof (double));
1057 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 773 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1058 774
775 XRenderPictureAttributes pa;
1059 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 776 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1060 777
778 pa.repeat = RepeatPad;
1061 Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, 0); 779 Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
780 Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1062 Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, 0); 781 Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
782 XFreePixmap (dpy, tmp);
1063 783
1064 if (kernel && params) 784 if (kernel && params)
1065 { 785 {
1066 size = h_blurRadius * 2 + 1; 786 size = h_blurRadius * 2 + 1;
1067 get_gaussian_kernel (h_blurRadius, size, kernel, params); 787 get_gaussian_kernel (h_blurRadius, size, kernel, params);
… …
1075 0, 0, 795 0, 0,
1076 0, 0, 796 0, 0,
1077 0, 0, 797 0, 0,
1078 width, height); 798 width, height);
1079 799
800 ::swap (src, dst);
801
1080 size = v_blurRadius * 2 + 1; 802 size = v_blurRadius * 2 + 1;
1081 get_gaussian_kernel (v_blurRadius, size, kernel, params); 803 get_gaussian_kernel (v_blurRadius, size, kernel, params);
1082 ::swap (params[0], params[1]); 804 ::swap (params[0], params[1]);
1083 805
1084 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 806 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
… …
1106bool 828bool
1107rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 829rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1108{ 830{
1109 bool ret = false; 831 bool ret = false;
1110 832
1111 if (bg_flags & BG_TINT_BITAND) 833 if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1112 { 834 {
1113 XGCValues gcv; 835 XGCValues gcv;
1114 GC gc; 836 GC gc;
1115 837
1116 /* In this case we can tint image server-side getting significant 838 /* In this case we can tint image server-side getting significant
… …
1128 } 850 }
1129 } 851 }
1130# if XRENDER 852# if XRENDER
1131 else if (bg_flags & BG_HAS_RENDER) 853 else if (bg_flags & BG_HAS_RENDER)
1132 { 854 {
1133 rgba c; 855 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1134 856
857 if (bg_flags & BG_TINT_SET)
1135 tint.get (c); 858 tint.get (c);
1136 859
1137 if (shade <= 100) 860 if (shade <= 100)
1138 { 861 {
1139 c.r = c.r * shade / 100; 862 c.r = c.r * shade / 100;
1140 c.g = c.g * shade / 100; 863 c.g = c.g * shade / 100;
… …
1196/* 919/*
1197 * Builds a pixmap of the same size as the terminal window that contains 920 * 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 921 * the tiled portion of the root pixmap that is supposed to be covered by
1199 * our window. 922 * our window.
1200 */ 923 */
1201unsigned long 924bool
1202rxvt_term::make_transparency_pixmap () 925rxvt_term::make_transparency_pixmap ()
1203{ 926{
1204 unsigned long result = 0; 927 bool ret = false;
1205 928
1206 /* root dimensions may change from call to call - but Display structure should 929 /* root dimensions may change from call to call - but Display structure should
1207 * be always up-to-date, so let's use it : 930 * be always up-to-date, so let's use it :
1208 */ 931 */
1209 int screen = display->screen; 932 int screen = display->screen;
… …
1290 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); 1013 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1291 1014
1292 if (gc) 1015 if (gc)
1293 { 1016 {
1294 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height); 1017 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1295 result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS); 1018 ret = true;
1019 unsigned long tr_flags = bg_flags & BG_EFFECTS_FLAGS;
1296 1020
1297 if (!(bg_flags & BG_CLIENT_RENDER)) 1021 if (!(bg_flags & BG_CLIENT_RENDER))
1298 { 1022 {
1299 if (bg_flags & BG_NEEDS_BLUR) 1023 if (bg_flags & BG_NEEDS_BLUR)
1300 { 1024 {
1301 if (blur_pixmap (bg_pixmap, visual, window_width, window_height)) 1025 if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth))
1302 result &= ~BG_NEEDS_BLUR; 1026 tr_flags &= ~BG_NEEDS_BLUR;
1303 } 1027 }
1304 if (bg_flags & BG_NEEDS_TINT) 1028 if (bg_flags & BG_NEEDS_TINT)
1305 { 1029 {
1306 if (tint_pixmap (bg_pixmap, visual, window_width, window_height)) 1030 if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1307 result &= ~BG_NEEDS_TINT; 1031 tr_flags &= ~BG_NEEDS_TINT;
1308 } 1032 }
1309# ifndef HAVE_AFTERIMAGE
1310 if (result & BG_NEEDS_TINT) 1033 if (tr_flags & BG_NEEDS_TINT)
1311 { 1034 {
1312 XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap); 1035 XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1313 if (ximage) 1036 if (ximage)
1314 { 1037 {
1315 /* our own client-side tinting */ 1038 /* our own client-side tinting */
… …
1317 1040
1318 XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height); 1041 XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
1319 XDestroyImage (ximage); 1042 XDestroyImage (ximage);
1320 } 1043 }
1321 } 1044 }
1322# endif
1323 } /* server side rendering completed */ 1045 } /* server side rendering completed */
1324 1046
1325 XFreeGC (dpy, gc); 1047 XFreeGC (dpy, gc);
1326 } 1048 }
1327 1049
1328 if (recoded_root_pmap != root_pixmap) 1050 if (recoded_root_pmap != root_pixmap)
1329 XFreePixmap (dpy, recoded_root_pmap); 1051 XFreePixmap (dpy, recoded_root_pmap);
1330 1052
1331 return result; 1053 return ret;
1332} 1054}
1333 1055
1334void 1056void
1335rxvt_term::bg_set_root_pixmap () 1057rxvt_term::bg_set_root_pixmap ()
1336{ 1058{
… …
1343# endif /* ENABLE_TRANSPARENCY */ 1065# endif /* ENABLE_TRANSPARENCY */
1344 1066
1345bool 1067bool
1346rxvt_term::bg_render () 1068rxvt_term::bg_render ()
1347{ 1069{
1348 unsigned long tr_flags = 0; 1070 bool transparent = false;
1349 1071
1350 bg_invalidate (); 1072 bg_invalidate ();
1351# ifdef ENABLE_TRANSPARENCY 1073# ifdef ENABLE_TRANSPARENCY
1352 if (bg_flags & BG_IS_TRANSPARENT) 1074 if (bg_flags & BG_IS_TRANSPARENT)
1353 { 1075 {
1354 /* we need to re-generate transparency pixmap in that case ! */ 1076 /* we need to re-generate transparency pixmap in that case ! */
1355 tr_flags = make_transparency_pixmap (); 1077 transparent = make_transparency_pixmap ();
1356 if (tr_flags == 0) 1078 if (transparent)
1357 return false;
1358 bg_flags |= BG_IS_VALID; 1079 bg_flags |= BG_IS_VALID;
1359 } 1080 }
1360# endif 1081# endif
1361 1082
1362# ifdef BG_IMAGE_FROM_FILE 1083# ifdef BG_IMAGE_FROM_FILE
1363 if ((bg_flags & BG_IS_FROM_FILE) 1084 if (bg_flags & BG_IS_FROM_FILE)
1364 || (tr_flags & BG_EFFECTS_FLAGS))
1365 { 1085 {
1366 if (render_image (tr_flags)) 1086 if (render_image (transparent))
1367 bg_flags |= BG_IS_VALID; 1087 bg_flags |= BG_IS_VALID;
1368 } 1088 }
1369# endif 1089# endif
1370 1090
1371 if (!(bg_flags & BG_IS_VALID)) 1091 if (!(bg_flags & BG_IS_VALID))
… …
1387 1107
1388void 1108void
1389rxvt_term::bg_init () 1109rxvt_term::bg_init ()
1390{ 1110{
1391#ifdef ENABLE_TRANSPARENCY 1111#ifdef ENABLE_TRANSPARENCY
1392 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1393 tint.set (this, c);
1394 shade = 100; 1112 shade = 100;
1395#endif 1113#endif
1396 1114
1397 bg_flags &= ~(BG_HAS_RENDER | BG_HAS_RENDER_CONV); 1115 bg_flags &= ~(BG_HAS_RENDER | BG_HAS_RENDER_CONV);
1398#if XRENDER 1116#if XRENDER
… …
1411#endif 1129#endif
1412} 1130}
1413 1131
1414#endif /* HAVE_BG_PIXMAP */ 1132#endif /* HAVE_BG_PIXMAP */
1415 1133
1416#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) 1134#ifdef ENABLE_TRANSPARENCY
1417/* based on code from aterm-0.4.2 */ 1135/* based on code from aterm-0.4.2 */
1418 1136
1419static inline void 1137static inline void
1420fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high) 1138fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
1421{ 1139{
… …
1501 break; 1219 break;
1502 default: 1220 default:
1503 return; /* we do not support this color depth */ 1221 return; /* we do not support this color depth */
1504 } 1222 }
1505 1223
1506 rgba c; 1224 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1507 1225
1226 if (bg_flags & BG_TINT_SET)
1508 tint.get (c); 1227 tint.get (c);
1509 1228
1510 /* prepare limits for color transformation (each channel is handled separately) */ 1229 /* prepare limits for color transformation (each channel is handled separately) */
1511 if (shade > 100) 1230 if (shade > 100)
1512 { 1231 {
1513 c.r = c.r * (200 - shade) / 100; 1232 c.r = c.r * (200 - shade) / 100;
… …
1566 } 1285 }
1567 } 1286 }
1568 1287
1569 free (lookup); 1288 free (lookup);
1570} 1289}
1571#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */ 1290#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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