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.164 by sf-exg, Sun Aug 14 22:01:25 2011 UTC vs.
Revision 1.195 by sf-exg, Mon Jan 2 19:31:00 2012 UTC

… …
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 63#ifdef HAVE_AFTERIMAGE
58 if (original_asim) 64 if (original_asim)
… …
166 int smaller = min (image_size, window_size); 172 int smaller = min (image_size, window_size);
167 173
168 if (align >= 0 && align <= 100) 174 if (align >= 0 && align <= 100)
169 return diff * align / 100; 175 return diff * align / 100;
170 else if (align > 100 && align <= 200) 176 else if (align > 100 && align <= 200)
171 return ((align - 100) * smaller / 100) + window_size - smaller; 177 return (align - 100) * smaller / 100 + window_size - smaller;
172 else if (align >= -100 && align < 0) 178 else if (align >= -100 && align < 0)
173 return ((align + 100) * smaller / 100) - image_size; 179 return (align + 100) * smaller / 100 - image_size;
174 return 0; 180 return 0;
175} 181}
176 182
177static inline int 183static inline int
178make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size) 184make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)
… …
197{ 203{
198 bool changed = false; 204 bool changed = false;
199 int geom_flags = 0; 205 int geom_flags = 0;
200 int x = 0, y = 0; 206 int x = 0, y = 0;
201 unsigned int w = 0, h = 0; 207 unsigned int w = 0, h = 0;
202 unsigned long new_flags = (bg_flags & (~BG_GEOMETRY_FLAGS)); 208 unsigned long new_flags = 0;
203 209
204 if (geom == NULL) 210 if (geom == NULL)
205 return false; 211 return false;
206 212
207 if (geom[0]) 213 if (geom[0])
208 { 214 {
209 char **arr = rxvt_strsplit (':', geom); 215 char **arr = rxvt_strsplit (':', geom);
210 216
211 for (int i = 0; arr[i]; i++) 217 for (int i = 0; arr[i]; i++)
212 { 218 {
213 if (!strcasecmp (arr[i], "style=tiled")) 219 if (!strcasecmp (arr[i], "style=tiled"))
214 { 220 {
215 new_flags = BG_TILE; 221 new_flags = BG_TILE;
216 w = h = noScale; 222 w = h = noScale;
217 x = y = 0; 223 x = y = 0;
218 geom_flags = WidthValue|HeightValue|XValue|YValue; 224 geom_flags = WidthValue|HeightValue|XValue|YValue;
219 } 225 }
220 else if (!strcasecmp (arr[i], "style=aspect-stretched")) 226 else if (!strcasecmp (arr[i], "style=aspect-stretched"))
221 { 227 {
222 new_flags = BG_PROP_SCALE; 228 new_flags = BG_KEEP_ASPECT;
223 w = h = windowScale; 229 w = h = windowScale;
224 x = y = centerAlign; 230 x = y = centerAlign;
225 geom_flags = WidthValue|HeightValue|XValue|YValue; 231 geom_flags = WidthValue|HeightValue|XValue|YValue;
226 } 232 }
227 else if (!strcasecmp (arr[i], "style=stretched")) 233 else if (!strcasecmp (arr[i], "style=stretched"))
… …
243 w = h = noScale; 249 w = h = noScale;
244 geom_flags = WidthValue|HeightValue; 250 geom_flags = WidthValue|HeightValue;
245 } 251 }
246 else if (!strcasecmp (arr[i], "op=tile")) 252 else if (!strcasecmp (arr[i], "op=tile"))
247 new_flags |= BG_TILE; 253 new_flags |= BG_TILE;
248 else if (!strcasecmp (arr[i], "op=pscale")) 254 else if (!strcasecmp (arr[i], "op=keep-aspect"))
249 new_flags |= BG_PROP_SCALE; 255 new_flags |= BG_KEEP_ASPECT;
250 else if (!strcasecmp (arr[i], "op=root")) 256 else if (!strcasecmp (arr[i], "op=root-align"))
251 new_flags |= BG_ROOT_ALIGN; 257 new_flags |= BG_ROOT_ALIGN;
252 258
253 // deprecated 259 // deprecated
254 else if (!strcasecmp (arr[i], "tile")) 260 else if (!strcasecmp (arr[i], "tile"))
255 { 261 {
… …
257 w = h = noScale; 263 w = h = noScale;
258 geom_flags |= WidthValue|HeightValue; 264 geom_flags |= WidthValue|HeightValue;
259 } 265 }
260 else if (!strcasecmp (arr[i], "propscale")) 266 else if (!strcasecmp (arr[i], "propscale"))
261 { 267 {
262 new_flags |= BG_PROP_SCALE; 268 new_flags |= BG_KEEP_ASPECT;
269 w = h = windowScale;
270 geom_flags |= WidthValue|HeightValue;
263 } 271 }
264 else if (!strcasecmp (arr[i], "hscale")) 272 else if (!strcasecmp (arr[i], "hscale"))
265 { 273 {
266 new_flags |= BG_TILE; 274 new_flags |= BG_TILE;
267 w = windowScale; 275 w = windowScale;
… …
297 geom_flags |= XParseGeometry (arr[i], &x, &y, &w, &h); 305 geom_flags |= XParseGeometry (arr[i], &x, &y, &w, &h);
298 } /* done parsing ops */ 306 } /* done parsing ops */
299 307
300 rxvt_free_strsplit (arr); 308 rxvt_free_strsplit (arr);
301 } 309 }
310
311 new_flags |= bg_flags & ~BG_GEOMETRY_FLAGS;
302 312
303 if (!update) 313 if (!update)
304 { 314 {
305 if (!(geom_flags & XValue)) 315 if (!(geom_flags & XValue))
306 x = y = defaultAlign; 316 x = y = defaultAlign;
… …
338 int target_height = szHint.height; 348 int target_height = szHint.height;
339 349
340 w = h_scale * target_width / 100; 350 w = h_scale * target_width / 100;
341 h = v_scale * target_height / 100; 351 h = v_scale * target_height / 100;
342 352
343 if (bg_flags & BG_PROP_SCALE) 353 if (bg_flags & BG_KEEP_ASPECT)
344 { 354 {
345 float scale = (float)w / image_width; 355 float scale = (float)w / image_width;
346 min_it (scale, (float)h / image_height); 356 min_it (scale, (float)h / image_height);
347 w = image_width * scale + 0.5; 357 w = image_width * scale + 0.5;
348 h = image_height * scale + 0.5; 358 h = image_height * scale + 0.5;
… …
399 } 409 }
400 410
401 if ((tr_flags & BG_NEEDS_BLUR) && background != NULL) 411 if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)
402 { 412 {
403 ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF, 413 ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,
404 (original_asim == NULL || tint == TINT_LEAVE_SAME) ? ASA_XImage : ASA_ASImage, 414 ASA_XImage,
405 100, ASIMAGE_QUALITY_DEFAULT); 415 100, ASIMAGE_QUALITY_DEFAULT);
406 if (tmp) 416 if (tmp)
407 { 417 {
408 destroy_asimage (&background); 418 destroy_asimage (&background);
409 background = tmp; 419 background = tmp;
… …
428 438
429 if (!original_asim 439 if (!original_asim
430 || (!(bg_flags & BG_ROOT_ALIGN) 440 || (!(bg_flags & BG_ROOT_ALIGN)
431 && (x >= target_width 441 && (x >= target_width
432 || y >= target_height 442 || y >= target_height
433 || (x + w <= 0) 443 || x + w <= 0
434 || (y + h <= 0)))) 444 || y + h <= 0)))
435 { 445 {
436 if (background) 446 if (background)
437 { 447 {
438 new_pmap_width = background->width; 448 new_pmap_width = background->width;
439 new_pmap_height = background->height; 449 new_pmap_height = background->height;
… …
453 } 463 }
454 else 464 else
455 { 465 {
456 result = original_asim; 466 result = original_asim;
457 467
458 if ((w != original_asim->width) 468 if (w != original_asim->width
459 || (h != original_asim->height)) 469 || h != original_asim->height)
460 { 470 {
461 result = scale_asimage (asv, original_asim, 471 result = scale_asimage (asv, original_asim,
462 w, h, 472 w, h,
463 background ? ASA_ASImage : ASA_XImage, 473 ASA_XImage,
464 100, ASIMAGE_QUALITY_DEFAULT); 474 100, ASIMAGE_QUALITY_DEFAULT);
465 } 475 }
466 476
467 if (background == NULL) 477 if (background == NULL)
468 { 478 {
… …
718 get_image_geometry (image_width, image_height, w, h, x, y); 728 get_image_geometry (image_width, image_height, w, h, x, y);
719 729
720 if (!(bg_flags & BG_ROOT_ALIGN) 730 if (!(bg_flags & BG_ROOT_ALIGN)
721 && (x >= target_width 731 && (x >= target_width
722 || y >= target_height 732 || y >= target_height
723 || (x + w <= 0) 733 || x + w <= 0
724 || (y + h <= 0))) 734 || y + h <= 0))
725 return false; 735 return false;
726 736
727 result = pixbuf; 737 result = pixbuf;
728 738
729 if ((w != image_width) 739 if (w != image_width
730 || (h != image_height)) 740 || h != image_height)
731 { 741 {
732 result = gdk_pixbuf_scale_simple (pixbuf, 742 result = gdk_pixbuf_scale_simple (pixbuf,
733 w, h, 743 w, h,
734 GDK_INTERP_BILINEAR); 744 GDK_INTERP_BILINEAR);
735 } 745 }
… …
814 } 824 }
815 825
816#if XRENDER 826#if XRENDER
817 if (tr_flags) 827 if (tr_flags)
818 { 828 {
819 XRenderPictureAttributes pa;
820
821 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, visual); 829 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
830
822 Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa); 831 Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
823 832
824 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
825 Picture dst = XRenderCreatePicture (dpy, bg_pixmap, dst_format, 0, &pa); 833 Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
826 834
827 pa.repeat = True; 835 Picture mask = create_xrender_mask (dpy, vt, False, False);
828 Pixmap mask_pmap = XCreatePixmap (dpy, vt, 1, 1, 8);
829 XRenderPictFormat *mask_format = XRenderFindStandardFormat (dpy, PictStandardA8);
830 Picture mask = XRenderCreatePicture (dpy, mask_pmap, mask_format, CPRepeat, &pa);
831 XFreePixmap (dpy, mask_pmap);
832 836
833 XRenderColor mask_c; 837 XRenderColor mask_c;
834 838
835 mask_c.alpha = 0x8000; 839 mask_c.alpha = 0x8000;
836 mask_c.red = 0; 840 mask_c.red =
837 mask_c.green = 0; 841 mask_c.green =
838 mask_c.blue = 0; 842 mask_c.blue = 0;
839 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1); 843 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
844
840 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height); 845 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
841 846
842 XRenderFreePicture (dpy, src); 847 XRenderFreePicture (dpy, src);
843 XRenderFreePicture (dpy, dst); 848 XRenderFreePicture (dpy, dst);
844 XRenderFreePicture (dpy, mask); 849 XRenderFreePicture (dpy, mask);
… …
864rxvt_term::bg_set_file (const char *file) 869rxvt_term::bg_set_file (const char *file)
865{ 870{
866 if (!file || !*file) 871 if (!file || !*file)
867 return false; 872 return false;
868 873
874 bool ret = false;
869 if (const char *p = strchr (file, ';')) 875 const char *p = strchr (file, ';');
876
877 if (p)
870 { 878 {
871 size_t len = p - file; 879 size_t len = p - file;
872 char *f = rxvt_temp_buf<char> (len + 1); 880 char *f = rxvt_temp_buf<char> (len + 1);
873 memcpy (f, file, len); 881 memcpy (f, file, len);
874 f[len] = '\0'; 882 f[len] = '\0';
… …
883 { 891 {
884 if (original_asim) 892 if (original_asim)
885 safe_asimage_destroy (original_asim); 893 safe_asimage_destroy (original_asim);
886 original_asim = image; 894 original_asim = image;
887 bg_flags |= BG_IS_FROM_FILE | BG_CLIENT_RENDER; 895 bg_flags |= BG_IS_FROM_FILE | BG_CLIENT_RENDER;
888 return true; 896 ret = true;
889 } 897 }
890# endif 898# endif
891 899
892# ifdef HAVE_PIXBUF 900# ifdef HAVE_PIXBUF
893 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL); 901 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
… …
895 { 903 {
896 if (pixbuf) 904 if (pixbuf)
897 g_object_unref (pixbuf); 905 g_object_unref (pixbuf);
898 pixbuf = image; 906 pixbuf = image;
899 bg_flags |= BG_IS_FROM_FILE; 907 bg_flags |= BG_IS_FROM_FILE;
900 return true; 908 ret = true;
901 } 909 }
902# endif 910# endif
903 911
912 if (ret)
913 {
914 if (p)
915 bg_set_geometry (p + 1);
916 else
917 bg_set_default_geometry ();
918 }
919
904 return false; 920 return ret;
905} 921}
906 922
907# endif /* BG_IMAGE_FROM_FILE */ 923# endif /* BG_IMAGE_FROM_FILE */
908 924
909# ifdef ENABLE_TRANSPARENCY 925# ifdef ENABLE_TRANSPARENCY
… …
945 { 961 {
946 changed = true; 962 changed = true;
947 v_blurRadius = vr; 963 v_blurRadius = vr;
948 } 964 }
949 965
950 if (v_blurRadius == 0 && h_blurRadius == 0) 966 if (h_blurRadius == 0 || v_blurRadius == 0)
951 bg_flags &= ~BG_NEEDS_BLUR; 967 bg_flags &= ~BG_NEEDS_BLUR;
952 else 968 else
953 bg_flags |= BG_NEEDS_BLUR; 969 bg_flags |= BG_NEEDS_BLUR;
954 970
955 return changed; 971 return changed;
956} 972}
957 973
958void 974void
959rxvt_term::set_tint_shade_flags () 975rxvt_term::set_tint_shade_flags ()
960{ 976{
961 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 977 rgba c;
962 bool has_shade = shade != 100; 978 bool has_shade = shade != 100;
963 979
964 bg_flags &= ~BG_TINT_FLAGS; 980 bg_flags &= ~BG_TINT_FLAGS;
965 981
966 if (bg_flags & BG_TINT_SET) 982 if (bg_flags & BG_TINT_SET)
… …
992} 1008}
993 1009
994bool 1010bool
995rxvt_term::bg_set_shade (const char *shade_str) 1011rxvt_term::bg_set_shade (const char *shade_str)
996{ 1012{
997 int new_shade = (shade_str) ? atoi (shade_str) : 100; 1013 int new_shade = atoi (shade_str);
998 1014
999 clamp_it (new_shade, -100, 200); 1015 clamp_it (new_shade, -100, 200);
1000 if (new_shade < 0) 1016 if (new_shade < 0)
1001 new_shade = 200 - (100 + new_shade); 1017 new_shade = 200 - (100 + new_shade);
1002 1018
… …
1036bool 1052bool
1037rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 1053rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1038{ 1054{
1039 bool ret = false; 1055 bool ret = false;
1040#if XRENDER 1056#if XRENDER
1057 if (!(bg_flags & BG_HAS_RENDER_CONV))
1058 return false;
1059
1041 int size = max (h_blurRadius, v_blurRadius) * 2 + 1; 1060 int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1042 double *kernel = (double *)malloc (size * sizeof (double)); 1061 double *kernel = (double *)malloc (size * sizeof (double));
1043 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 1062 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1044 1063
1045 XRenderPictureAttributes pa; 1064 XRenderPictureAttributes pa;
1046 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 1065 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1047 1066
1067 pa.repeat = RepeatPad;
1048 Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 1068 Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
1049 Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 1069 Picture dst = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
1050 1070
1051 if (kernel && params) 1071 if (kernel && params)
1052 { 1072 {
1053 if (h_blurRadius)
1054 {
1055 size = h_blurRadius * 2 + 1; 1073 size = h_blurRadius * 2 + 1;
1056 get_gaussian_kernel (h_blurRadius, size, kernel, params); 1074 get_gaussian_kernel (h_blurRadius, size, kernel, params);
1057 1075
1058 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 1076 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1059 XRenderComposite (dpy, 1077 XRenderComposite (dpy,
1060 PictOpSrc, 1078 PictOpSrc,
1061 src, 1079 src,
1062 None, 1080 None,
1063 dst, 1081 dst,
1064 0, 0, 1082 0, 0,
1065 0, 0, 1083 0, 0,
1066 0, 0, 1084 0, 0,
1067 width, height); 1085 width, height);
1068 }
1069 1086
1070 if (v_blurRadius)
1071 {
1072 size = v_blurRadius * 2 + 1; 1087 size = v_blurRadius * 2 + 1;
1073 get_gaussian_kernel (v_blurRadius, size, kernel, params); 1088 get_gaussian_kernel (v_blurRadius, size, kernel, params);
1074 ::swap (params[0], params[1]); 1089 ::swap (params[0], params[1]);
1075 1090
1076 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 1091 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1077 XRenderComposite (dpy, 1092 XRenderComposite (dpy,
1078 PictOpSrc, 1093 PictOpSrc,
1079 src, 1094 src,
1080 None, 1095 None,
1081 dst, 1096 dst,
1082 0, 0, 1097 0, 0,
1083 0, 0, 1098 0, 0,
1084 0, 0, 1099 0, 0,
1085 width, height); 1100 width, height);
1086 }
1087 1101
1088 ret = true; 1102 ret = true;
1089 } 1103 }
1090 1104
1091 free (kernel); 1105 free (kernel);
… …
1118 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height); 1132 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1119 ret = true; 1133 ret = true;
1120 XFreeGC (dpy, gc); 1134 XFreeGC (dpy, gc);
1121 } 1135 }
1122 } 1136 }
1123 else
1124 {
1125# if XRENDER 1137# if XRENDER
1138 else if (bg_flags & BG_HAS_RENDER)
1139 {
1126 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC); 1140 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1127 1141
1128 if (bg_flags & BG_TINT_SET) 1142 if (bg_flags & BG_TINT_SET)
1129 tint.get (c); 1143 tint.get (c);
1130 1144
… …
1139 c.r = c.r * (200 - shade) / 100; 1153 c.r = c.r * (200 - shade) / 100;
1140 c.g = c.g * (200 - shade) / 100; 1154 c.g = c.g * (200 - shade) / 100;
1141 c.b = c.b * (200 - shade) / 100; 1155 c.b = c.b * (200 - shade) / 100;
1142 } 1156 }
1143 1157
1144 XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1145 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 1158 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1146 XRenderPictureAttributes pa;
1147 1159
1148 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 1160 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1149 1161
1150 pa.repeat = True; 1162 Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1151 1163
1152 Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32); 1164 Picture mask_pic = create_xrender_mask (dpy, pixmap, True, True);
1153 Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1154 XFreePixmap (dpy, overlay_pmap);
1155
1156 pa.component_alpha = True;
1157 Pixmap mask_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
1158 Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat | CPComponentAlpha, &pa);
1159 XFreePixmap (dpy, mask_pmap);
1160 1165
1161 XRenderColor mask_c; 1166 XRenderColor mask_c;
1162 1167
1163 mask_c.alpha = 0xffff; 1168 mask_c.alpha = 0xffff;
1164 mask_c.red = 1169 mask_c.red =
… …
1169 mask_c.alpha = 0; 1174 mask_c.alpha = 0;
1170 mask_c.red = 0xffff - c.r; 1175 mask_c.red = 0xffff - c.r;
1171 mask_c.green = 0xffff - c.g; 1176 mask_c.green = 0xffff - c.g;
1172 mask_c.blue = 0xffff - c.b; 1177 mask_c.blue = 0xffff - c.b;
1173 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1); 1178 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
1179
1174 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height); 1180 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1175 1181
1176 if (shade > 100) 1182 if (shade > 100)
1177 { 1183 {
1178 mask_c.red = mask_c.green = mask_c.blue = 0xffff * (shade - 100) / 100;
1179 mask_c.alpha = 0; 1184 mask_c.alpha = 0;
1185 mask_c.red =
1186 mask_c.green =
1187 mask_c.blue = 0xffff * (shade - 100) / 100;
1180 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1); 1188 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1181 1189
1182 XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height); 1190 XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1183 } 1191 }
1184 1192
1185 ret = true; 1193 ret = true;
1186 1194
1187 XRenderFreePicture (dpy, mask_pic); 1195 XRenderFreePicture (dpy, mask_pic);
1188 XRenderFreePicture (dpy, overlay_pic); 1196 XRenderFreePicture (dpy, overlay_pic);
1189 XRenderFreePicture (dpy, back_pic); 1197 XRenderFreePicture (dpy, back_pic);
1198 }
1190# endif 1199# endif
1191 }
1192 1200
1193 return ret; 1201 return ret;
1194} 1202}
1195 1203
1196/* 1204/*
… …
1247#if XRENDER 1255#if XRENDER
1248 if (bg_flags & BG_HAS_RENDER) 1256 if (bg_flags & BG_HAS_RENDER)
1249 { 1257 {
1250 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth); 1258 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1251 1259
1252 XRenderPictureAttributes pa;
1253
1254 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen)); 1260 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1255 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa); 1261 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1256 1262
1257 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual); 1263 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1258 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa); 1264 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1259 1265
1260 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height); 1266 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
1261 1267
1262 XRenderFreePicture (dpy, src); 1268 XRenderFreePicture (dpy, src);
1263 XRenderFreePicture (dpy, dst); 1269 XRenderFreePicture (dpy, dst);
… …
1280 bg_pmap_width = window_width; 1286 bg_pmap_width = window_width;
1281 bg_pmap_height = window_height; 1287 bg_pmap_height = window_height;
1282 } 1288 }
1283 1289
1284 /* straightforward pixmap copy */ 1290 /* straightforward pixmap copy */
1285 while (sx < 0) sx += root_width; 1291 while (sx < 0) sx += root_pmap_width;
1286 while (sy < 0) sy += root_height; 1292 while (sy < 0) sy += root_pmap_height;
1287 1293
1288 gcv.tile = recoded_root_pmap; 1294 gcv.tile = recoded_root_pmap;
1289 gcv.fill_style = FillTiled; 1295 gcv.fill_style = FillTiled;
1290 gcv.ts_x_origin = -sx; 1296 gcv.ts_x_origin = -sx;
1291 gcv.ts_y_origin = -sy; 1297 gcv.ts_y_origin = -sy;
… …
1293 1299
1294 if (gc) 1300 if (gc)
1295 { 1301 {
1296 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height); 1302 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1297 result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS); 1303 result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS);
1298 XFreeGC (dpy, gc);
1299 1304
1300 if (!(bg_flags & BG_CLIENT_RENDER)) 1305 if (!(bg_flags & BG_CLIENT_RENDER))
1301 { 1306 {
1302 if ((bg_flags & BG_NEEDS_BLUR) 1307 if (bg_flags & BG_NEEDS_BLUR)
1303 && (bg_flags & BG_HAS_RENDER_CONV))
1304 { 1308 {
1305 if (blur_pixmap (bg_pixmap, visual, window_width, window_height)) 1309 if (blur_pixmap (bg_pixmap, visual, window_width, window_height))
1306 result &= ~BG_NEEDS_BLUR; 1310 result &= ~BG_NEEDS_BLUR;
1307 } 1311 }
1308 if ((bg_flags & BG_NEEDS_TINT) 1312 if (bg_flags & BG_NEEDS_TINT)
1309 && (bg_flags & (BG_TINT_BITAND | BG_HAS_RENDER)))
1310 { 1313 {
1311 if (tint_pixmap (bg_pixmap, visual, window_width, window_height)) 1314 if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1312 result &= ~BG_NEEDS_TINT; 1315 result &= ~BG_NEEDS_TINT;
1313 } 1316 }
1317# ifndef HAVE_AFTERIMAGE
1318 if (result & BG_NEEDS_TINT)
1319 {
1320 XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1321 if (ximage)
1322 {
1323 /* our own client-side tinting */
1324 tint_ximage (DefaultVisual (dpy, display->screen), ximage);
1325
1326 XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
1327 XDestroyImage (ximage);
1328 }
1329 }
1330# endif
1314 } /* server side rendering completed */ 1331 } /* server side rendering completed */
1332
1333 XFreeGC (dpy, gc);
1315 } 1334 }
1316 1335
1317 if (recoded_root_pmap != root_pixmap) 1336 if (recoded_root_pmap != root_pixmap)
1318 XFreePixmap (dpy, recoded_root_pmap); 1337 XFreePixmap (dpy, recoded_root_pmap);
1319 1338
… …
1328 new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]); 1347 new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]);
1329 1348
1330 root_pixmap = new_root_pixmap; 1349 root_pixmap = new_root_pixmap;
1331} 1350}
1332# endif /* ENABLE_TRANSPARENCY */ 1351# endif /* ENABLE_TRANSPARENCY */
1333
1334#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1335static void shade_ximage (Visual *visual, XImage *ximage, int shade, const rgba &c);
1336# endif
1337 1352
1338bool 1353bool
1339rxvt_term::bg_render () 1354rxvt_term::bg_render ()
1340{ 1355{
1341 unsigned long tr_flags = 0; 1356 unsigned long tr_flags = 0;
… …
1346 { 1361 {
1347 /* we need to re-generate transparency pixmap in that case ! */ 1362 /* we need to re-generate transparency pixmap in that case ! */
1348 tr_flags = make_transparency_pixmap (); 1363 tr_flags = make_transparency_pixmap ();
1349 if (tr_flags == 0) 1364 if (tr_flags == 0)
1350 return false; 1365 return false;
1351 else if (!(tr_flags & BG_EFFECTS_FLAGS))
1352 bg_flags |= BG_IS_VALID; 1366 bg_flags |= BG_IS_VALID;
1353 } 1367 }
1354# endif 1368# endif
1355 1369
1356# ifdef BG_IMAGE_FROM_FILE 1370# ifdef BG_IMAGE_FROM_FILE
1357 if ((bg_flags & BG_IS_FROM_FILE) 1371 if ((bg_flags & BG_IS_FROM_FILE)
1358 || (tr_flags & BG_EFFECTS_FLAGS)) 1372 || (tr_flags & BG_EFFECTS_FLAGS))
1359 { 1373 {
1360 if (render_image (tr_flags)) 1374 if (render_image (tr_flags))
1361 bg_flags |= BG_IS_VALID; 1375 bg_flags |= BG_IS_VALID;
1362 }
1363# endif
1364
1365# if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1366 XImage *result = NULL;
1367
1368 if (tr_flags && !(bg_flags & BG_IS_VALID))
1369 {
1370 result = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1371 }
1372
1373 if (result)
1374 {
1375 /* our own client-side tinting */
1376 if (tr_flags & BG_NEEDS_TINT)
1377 {
1378 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1379 if (bg_flags & BG_TINT_SET)
1380 tint.get (c);
1381 shade_ximage (DefaultVisual (dpy, display->screen), result, shade, c);
1382 }
1383
1384 GC gc = XCreateGC (dpy, vt, 0UL, NULL);
1385
1386 if (gc)
1387 {
1388 XPutImage (dpy, bg_pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1389
1390 XFreeGC (dpy, gc);
1391 bg_flags |= BG_IS_VALID;
1392 }
1393
1394 XDestroyImage (result);
1395 } 1376 }
1396# endif 1377# endif
1397 1378
1398 if (!(bg_flags & BG_IS_VALID)) 1379 if (!(bg_flags & BG_IS_VALID))
1399 { 1380 {
… …
1437} 1418}
1438 1419
1439#endif /* HAVE_BG_PIXMAP */ 1420#endif /* HAVE_BG_PIXMAP */
1440 1421
1441#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) 1422#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1442/* taken from aterm-0.4.2 */ 1423/* based on code from aterm-0.4.2 */
1443 1424
1444static void 1425static inline void
1445shade_ximage (Visual *visual, XImage *ximage, int shade, const rgba &c) 1426fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
1427{
1428 for (int i = 0; i <= mask >> sh; i++)
1429 {
1430 uint32_t tmp;
1431 tmp = i * high;
1432 tmp += (mask >> sh) * low;
1433 lookup[i] = (tmp / 0xffff) << sh;
1434 }
1435}
1436
1437void
1438rxvt_term::tint_ximage (Visual *visual, XImage *ximage)
1446{ 1439{
1447 int sh_r, sh_g, sh_b; 1440 int sh_r, sh_g, sh_b;
1448 uint32_t mask_r, mask_g, mask_b; 1441 uint32_t mask_r, mask_g, mask_b;
1449 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b; 1442 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1450 rgba low; 1443 unsigned short low;
1451 rgba high;
1452 int i;
1453 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst; 1444 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1454 1445
1455 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return; 1446 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;
1456 1447
1457 /* for convenience */ 1448 /* for convenience */
… …
1516 break; 1507 break;
1517 default: 1508 default:
1518 return; /* we do not support this color depth */ 1509 return; /* we do not support this color depth */
1519 } 1510 }
1520 1511
1512 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1513
1514 if (bg_flags & BG_TINT_SET)
1515 tint.get (c);
1516
1521 /* prepare limits for color transformation (each channel is handled separately) */ 1517 /* prepare limits for color transformation (each channel is handled separately) */
1522 if (shade > 100) 1518 if (shade > 100)
1523 { 1519 {
1524 shade = 200 - shade;
1525
1526 high.r = c.r * shade / 100;
1527 high.g = c.g * shade / 100;
1528 high.b = c.b * shade / 100;
1529
1530 low.r = 65535 * (100 - shade) / 100; 1520 c.r = c.r * (200 - shade) / 100;
1531 low.g = 65535 * (100 - shade) / 100; 1521 c.g = c.g * (200 - shade) / 100;
1532 low.b = 65535 * (100 - shade) / 100; 1522 c.b = c.b * (200 - shade) / 100;
1523
1524 low = 0xffff * (shade - 100) / 100;
1533 } 1525 }
1534 else 1526 else
1535 { 1527 {
1536 high.r = c.r * shade / 100; 1528 c.r = c.r * shade / 100;
1537 high.g = c.g * shade / 100; 1529 c.g = c.g * shade / 100;
1538 high.b = c.b * shade / 100; 1530 c.b = c.b * shade / 100;
1539 1531
1540 low.r = low.g = low.b = 0; 1532 low = 0;
1541 } 1533 }
1542 1534
1543 /* fill our lookup tables */ 1535 /* fill our lookup tables */
1544 for (i = 0; i <= mask_r>>sh_r; i++) 1536 fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1545 { 1537 fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1546 uint32_t tmp; 1538 fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1547 tmp = i * high.r;
1548 tmp += (mask_r>>sh_r) * low.r;
1549 lookup_r[i] = (tmp/65535)<<sh_r;
1550 }
1551 for (i = 0; i <= mask_g>>sh_g; i++)
1552 {
1553 uint32_t tmp;
1554 tmp = i * high.g;
1555 tmp += (mask_g>>sh_g) * low.g;
1556 lookup_g[i] = (tmp/65535)<<sh_g;
1557 }
1558 for (i = 0; i <= mask_b>>sh_b; i++)
1559 {
1560 uint32_t tmp;
1561 tmp = i * high.b;
1562 tmp += (mask_b>>sh_b) * low.b;
1563 lookup_b[i] = (tmp/65535)<<sh_b;
1564 }
1565 1539
1566 /* apply table to input image (replacing colors by newly calculated ones) */ 1540 /* apply table to input image (replacing colors by newly calculated ones) */
1567 if (ximage->bits_per_pixel == 32 1541 if (ximage->bits_per_pixel == 32
1568 && (ximage->depth == 24 || ximage->depth == 32) 1542 && (ximage->depth == 24 || ximage->depth == 32)
1569 && ximage->byte_order == host_byte_order) 1543 && ximage->byte_order == host_byte_order)

Diff Legend

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