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.168 by sf-exg, Fri Aug 19 17:49:08 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#ifndef RepeatPad
38#define RepeatPad True
39#endif
40
37#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
38void 60void
39rxvt_term::bg_destroy () 61rxvt_term::bg_destroy ()
40{ 62{
41#ifdef HAVE_AFTERIMAGE 63#ifdef HAVE_AFTERIMAGE
42 if (original_asim) 64 if (original_asim)
… …
150 int smaller = min (image_size, window_size); 172 int smaller = min (image_size, window_size);
151 173
152 if (align >= 0 && align <= 100) 174 if (align >= 0 && align <= 100)
153 return diff * align / 100; 175 return diff * align / 100;
154 else if (align > 100 && align <= 200) 176 else if (align > 100 && align <= 200)
155 return ((align - 100) * smaller / 100) + window_size - smaller; 177 return (align - 100) * smaller / 100 + window_size - smaller;
156 else if (align >= -100 && align < 0) 178 else if (align >= -100 && align < 0)
157 return ((align + 100) * smaller / 100) - image_size; 179 return (align + 100) * smaller / 100 - image_size;
158 return 0; 180 return 0;
159} 181}
160 182
161static inline int 183static inline int
162make_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)
… …
181{ 203{
182 bool changed = false; 204 bool changed = false;
183 int geom_flags = 0; 205 int geom_flags = 0;
184 int x = 0, y = 0; 206 int x = 0, y = 0;
185 unsigned int w = 0, h = 0; 207 unsigned int w = 0, h = 0;
186 unsigned long new_flags = (bg_flags & (~BG_GEOMETRY_FLAGS)); 208 unsigned long new_flags = 0;
187 209
188 if (geom == NULL) 210 if (geom == NULL)
189 return false; 211 return false;
190 212
191 if (geom[0]) 213 if (geom[0])
192 { 214 {
193 char **arr = rxvt_strsplit (':', geom); 215 char **arr = rxvt_strsplit (':', geom);
194 216
195 for (int i = 0; arr[i]; i++) 217 for (int i = 0; arr[i]; i++)
196 { 218 {
197 if (!strcasecmp (arr[i], "style=tiled")) 219 if (!strcasecmp (arr[i], "style=tiled"))
198 { 220 {
199 new_flags = BG_TILE; 221 new_flags = BG_TILE;
200 w = h = noScale; 222 w = h = noScale;
201 x = y = 0; 223 x = y = 0;
202 geom_flags = WidthValue|HeightValue|XValue|YValue; 224 geom_flags = WidthValue|HeightValue|XValue|YValue;
203 } 225 }
204 else if (!strcasecmp (arr[i], "style=aspect-stretched")) 226 else if (!strcasecmp (arr[i], "style=aspect-stretched"))
205 { 227 {
206 new_flags = BG_PROP_SCALE; 228 new_flags = BG_KEEP_ASPECT;
207 w = h = windowScale; 229 w = h = windowScale;
208 x = y = centerAlign; 230 x = y = centerAlign;
209 geom_flags = WidthValue|HeightValue|XValue|YValue; 231 geom_flags = WidthValue|HeightValue|XValue|YValue;
210 } 232 }
211 else if (!strcasecmp (arr[i], "style=stretched")) 233 else if (!strcasecmp (arr[i], "style=stretched"))
… …
227 w = h = noScale; 249 w = h = noScale;
228 geom_flags = WidthValue|HeightValue; 250 geom_flags = WidthValue|HeightValue;
229 } 251 }
230 else if (!strcasecmp (arr[i], "op=tile")) 252 else if (!strcasecmp (arr[i], "op=tile"))
231 new_flags |= BG_TILE; 253 new_flags |= BG_TILE;
232 else if (!strcasecmp (arr[i], "op=pscale")) 254 else if (!strcasecmp (arr[i], "op=keep-aspect"))
233 new_flags |= BG_PROP_SCALE; 255 new_flags |= BG_KEEP_ASPECT;
234 else if (!strcasecmp (arr[i], "op=root")) 256 else if (!strcasecmp (arr[i], "op=root-align"))
235 new_flags |= BG_ROOT_ALIGN; 257 new_flags |= BG_ROOT_ALIGN;
236 258
237 // deprecated 259 // deprecated
238 else if (!strcasecmp (arr[i], "tile")) 260 else if (!strcasecmp (arr[i], "tile"))
239 { 261 {
… …
241 w = h = noScale; 263 w = h = noScale;
242 geom_flags |= WidthValue|HeightValue; 264 geom_flags |= WidthValue|HeightValue;
243 } 265 }
244 else if (!strcasecmp (arr[i], "propscale")) 266 else if (!strcasecmp (arr[i], "propscale"))
245 { 267 {
246 new_flags |= BG_PROP_SCALE; 268 new_flags |= BG_KEEP_ASPECT;
269 w = h = windowScale;
270 geom_flags |= WidthValue|HeightValue;
247 } 271 }
248 else if (!strcasecmp (arr[i], "hscale")) 272 else if (!strcasecmp (arr[i], "hscale"))
249 { 273 {
250 new_flags |= BG_TILE; 274 new_flags |= BG_TILE;
251 w = windowScale; 275 w = windowScale;
… …
281 geom_flags |= XParseGeometry (arr[i], &x, &y, &w, &h); 305 geom_flags |= XParseGeometry (arr[i], &x, &y, &w, &h);
282 } /* done parsing ops */ 306 } /* done parsing ops */
283 307
284 rxvt_free_strsplit (arr); 308 rxvt_free_strsplit (arr);
285 } 309 }
310
311 new_flags |= bg_flags & ~BG_GEOMETRY_FLAGS;
286 312
287 if (!update) 313 if (!update)
288 { 314 {
289 if (!(geom_flags & XValue)) 315 if (!(geom_flags & XValue))
290 x = y = defaultAlign; 316 x = y = defaultAlign;
… …
322 int target_height = szHint.height; 348 int target_height = szHint.height;
323 349
324 w = h_scale * target_width / 100; 350 w = h_scale * target_width / 100;
325 h = v_scale * target_height / 100; 351 h = v_scale * target_height / 100;
326 352
327 if (bg_flags & BG_PROP_SCALE) 353 if (bg_flags & BG_KEEP_ASPECT)
328 { 354 {
329 float scale = (float)w / image_width; 355 float scale = (float)w / image_width;
330 min_it (scale, (float)h / image_height); 356 min_it (scale, (float)h / image_height);
331 w = image_width * scale + 0.5; 357 w = image_width * scale + 0.5;
332 h = image_height * scale + 0.5; 358 h = image_height * scale + 0.5;
… …
383 } 409 }
384 410
385 if ((tr_flags & BG_NEEDS_BLUR) && background != NULL) 411 if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)
386 { 412 {
387 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,
388 (original_asim == NULL || tint == TINT_LEAVE_SAME) ? ASA_XImage : ASA_ASImage, 414 ASA_XImage,
389 100, ASIMAGE_QUALITY_DEFAULT); 415 100, ASIMAGE_QUALITY_DEFAULT);
390 if (tmp) 416 if (tmp)
391 { 417 {
392 destroy_asimage (&background); 418 destroy_asimage (&background);
393 background = tmp; 419 background = tmp;
… …
412 438
413 if (!original_asim 439 if (!original_asim
414 || (!(bg_flags & BG_ROOT_ALIGN) 440 || (!(bg_flags & BG_ROOT_ALIGN)
415 && (x >= target_width 441 && (x >= target_width
416 || y >= target_height 442 || y >= target_height
417 || (x + w <= 0) 443 || x + w <= 0
418 || (y + h <= 0)))) 444 || y + h <= 0)))
419 { 445 {
420 if (background) 446 if (background)
421 { 447 {
422 new_pmap_width = background->width; 448 new_pmap_width = background->width;
423 new_pmap_height = background->height; 449 new_pmap_height = background->height;
… …
437 } 463 }
438 else 464 else
439 { 465 {
440 result = original_asim; 466 result = original_asim;
441 467
442 if ((w != original_asim->width) 468 if (w != original_asim->width
443 || (h != original_asim->height)) 469 || h != original_asim->height)
444 { 470 {
445 result = scale_asimage (asv, original_asim, 471 result = scale_asimage (asv, original_asim,
446 w, h, 472 w, h,
447 background ? ASA_ASImage : ASA_XImage, 473 ASA_XImage,
448 100, ASIMAGE_QUALITY_DEFAULT); 474 100, ASIMAGE_QUALITY_DEFAULT);
449 } 475 }
450 476
451 if (background == NULL) 477 if (background == NULL)
452 { 478 {
… …
702 get_image_geometry (image_width, image_height, w, h, x, y); 728 get_image_geometry (image_width, image_height, w, h, x, y);
703 729
704 if (!(bg_flags & BG_ROOT_ALIGN) 730 if (!(bg_flags & BG_ROOT_ALIGN)
705 && (x >= target_width 731 && (x >= target_width
706 || y >= target_height 732 || y >= target_height
707 || (x + w <= 0) 733 || x + w <= 0
708 || (y + h <= 0))) 734 || y + h <= 0))
709 return false; 735 return false;
710 736
711 result = pixbuf; 737 result = pixbuf;
712 738
713 if ((w != image_width) 739 if (w != image_width
714 || (h != image_height)) 740 || h != image_height)
715 { 741 {
716 result = gdk_pixbuf_scale_simple (pixbuf, 742 result = gdk_pixbuf_scale_simple (pixbuf,
717 w, h, 743 w, h,
718 GDK_INTERP_BILINEAR); 744 GDK_INTERP_BILINEAR);
719 } 745 }
… …
798 } 824 }
799 825
800#if XRENDER 826#if XRENDER
801 if (tr_flags) 827 if (tr_flags)
802 { 828 {
803 XRenderPictureAttributes pa;
804
805 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, visual); 829 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
830
806 Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa); 831 Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
807 832
808 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
809 Picture dst = XRenderCreatePicture (dpy, bg_pixmap, dst_format, 0, &pa); 833 Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
810 834
811 pa.repeat = True; 835 Picture mask = create_xrender_mask (dpy, vt, False, False);
812 Pixmap mask_pmap = XCreatePixmap (dpy, vt, 1, 1, 8);
813 XRenderPictFormat *mask_format = XRenderFindStandardFormat (dpy, PictStandardA8);
814 Picture mask = XRenderCreatePicture (dpy, mask_pmap, mask_format, CPRepeat, &pa);
815 XFreePixmap (dpy, mask_pmap);
816 836
817 XRenderColor mask_c; 837 XRenderColor mask_c;
818 838
819 mask_c.alpha = 0x8000; 839 mask_c.alpha = 0x8000;
820 mask_c.red = 0; 840 mask_c.red =
821 mask_c.green = 0; 841 mask_c.green =
822 mask_c.blue = 0; 842 mask_c.blue = 0;
823 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1); 843 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
844
824 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);
825 846
826 XRenderFreePicture (dpy, src); 847 XRenderFreePicture (dpy, src);
827 XRenderFreePicture (dpy, dst); 848 XRenderFreePicture (dpy, dst);
828 XRenderFreePicture (dpy, mask); 849 XRenderFreePicture (dpy, mask);
… …
940 { 961 {
941 changed = true; 962 changed = true;
942 v_blurRadius = vr; 963 v_blurRadius = vr;
943 } 964 }
944 965
945 if (v_blurRadius == 0 && h_blurRadius == 0) 966 if (h_blurRadius == 0 || v_blurRadius == 0)
946 bg_flags &= ~BG_NEEDS_BLUR; 967 bg_flags &= ~BG_NEEDS_BLUR;
947 else 968 else
948 bg_flags |= BG_NEEDS_BLUR; 969 bg_flags |= BG_NEEDS_BLUR;
949 970
950 return changed; 971 return changed;
951} 972}
952 973
953void 974void
954rxvt_term::set_tint_shade_flags () 975rxvt_term::set_tint_shade_flags ()
955{ 976{
956 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 977 rgba c;
957 bool has_shade = shade != 100; 978 bool has_shade = shade != 100;
958 979
959 bg_flags &= ~BG_TINT_FLAGS; 980 bg_flags &= ~BG_TINT_FLAGS;
960 981
961 if (bg_flags & BG_TINT_SET) 982 if (bg_flags & BG_TINT_SET)
… …
987} 1008}
988 1009
989bool 1010bool
990rxvt_term::bg_set_shade (const char *shade_str) 1011rxvt_term::bg_set_shade (const char *shade_str)
991{ 1012{
992 int new_shade = (shade_str) ? atoi (shade_str) : 100; 1013 int new_shade = atoi (shade_str);
993 1014
994 clamp_it (new_shade, -100, 200); 1015 clamp_it (new_shade, -100, 200);
995 if (new_shade < 0) 1016 if (new_shade < 0)
996 new_shade = 200 - (100 + new_shade); 1017 new_shade = 200 - (100 + new_shade);
997 1018
… …
1031bool 1052bool
1032rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 1053rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1033{ 1054{
1034 bool ret = false; 1055 bool ret = false;
1035#if XRENDER 1056#if XRENDER
1057 if (!(bg_flags & BG_HAS_RENDER_CONV))
1058 return false;
1059
1036 int size = max (h_blurRadius, v_blurRadius) * 2 + 1; 1060 int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1037 double *kernel = (double *)malloc (size * sizeof (double)); 1061 double *kernel = (double *)malloc (size * sizeof (double));
1038 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 1062 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1039 1063
1040 XRenderPictureAttributes pa; 1064 XRenderPictureAttributes pa;
1041 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 1065 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1042 1066
1067 pa.repeat = RepeatPad;
1043 Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 1068 Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
1044 Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 1069 Picture dst = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
1045 1070
1046 if (kernel && params) 1071 if (kernel && params)
1047 { 1072 {
1048 if (h_blurRadius)
1049 {
1050 size = h_blurRadius * 2 + 1; 1073 size = h_blurRadius * 2 + 1;
1051 get_gaussian_kernel (h_blurRadius, size, kernel, params); 1074 get_gaussian_kernel (h_blurRadius, size, kernel, params);
1052 1075
1053 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 1076 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1054 XRenderComposite (dpy, 1077 XRenderComposite (dpy,
1055 PictOpSrc, 1078 PictOpSrc,
1056 src, 1079 src,
1057 None, 1080 None,
1058 dst, 1081 dst,
1059 0, 0, 1082 0, 0,
1060 0, 0, 1083 0, 0,
1061 0, 0, 1084 0, 0,
1062 width, height); 1085 width, height);
1063 }
1064 1086
1065 if (v_blurRadius)
1066 {
1067 size = v_blurRadius * 2 + 1; 1087 size = v_blurRadius * 2 + 1;
1068 get_gaussian_kernel (v_blurRadius, size, kernel, params); 1088 get_gaussian_kernel (v_blurRadius, size, kernel, params);
1069 ::swap (params[0], params[1]); 1089 ::swap (params[0], params[1]);
1070 1090
1071 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 1091 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1072 XRenderComposite (dpy, 1092 XRenderComposite (dpy,
1073 PictOpSrc, 1093 PictOpSrc,
1074 src, 1094 src,
1075 None, 1095 None,
1076 dst, 1096 dst,
1077 0, 0, 1097 0, 0,
1078 0, 0, 1098 0, 0,
1079 0, 0, 1099 0, 0,
1080 width, height); 1100 width, height);
1081 }
1082 1101
1083 ret = true; 1102 ret = true;
1084 } 1103 }
1085 1104
1086 free (kernel); 1105 free (kernel);
… …
1113 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height); 1132 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1114 ret = true; 1133 ret = true;
1115 XFreeGC (dpy, gc); 1134 XFreeGC (dpy, gc);
1116 } 1135 }
1117 } 1136 }
1118 else
1119 {
1120# if XRENDER 1137# if XRENDER
1138 else if (bg_flags & BG_HAS_RENDER)
1139 {
1121 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC); 1140 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1122 1141
1123 if (bg_flags & BG_TINT_SET) 1142 if (bg_flags & BG_TINT_SET)
1124 tint.get (c); 1143 tint.get (c);
1125 1144
… …
1134 c.r = c.r * (200 - shade) / 100; 1153 c.r = c.r * (200 - shade) / 100;
1135 c.g = c.g * (200 - shade) / 100; 1154 c.g = c.g * (200 - shade) / 100;
1136 c.b = c.b * (200 - shade) / 100; 1155 c.b = c.b * (200 - shade) / 100;
1137 } 1156 }
1138 1157
1139 XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1140 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 1158 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1141 XRenderPictureAttributes pa;
1142 1159
1143 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 1160 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1144 1161
1145 pa.repeat = True; 1162 Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1146 1163
1147 Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32); 1164 Picture mask_pic = create_xrender_mask (dpy, pixmap, True, True);
1148 Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1149 XFreePixmap (dpy, overlay_pmap);
1150
1151 pa.component_alpha = True;
1152 Pixmap mask_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
1153 Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat | CPComponentAlpha, &pa);
1154 XFreePixmap (dpy, mask_pmap);
1155 1165
1156 XRenderColor mask_c; 1166 XRenderColor mask_c;
1157 1167
1158 mask_c.alpha = 0xffff; 1168 mask_c.alpha = 0xffff;
1159 mask_c.red = 1169 mask_c.red =
… …
1164 mask_c.alpha = 0; 1174 mask_c.alpha = 0;
1165 mask_c.red = 0xffff - c.r; 1175 mask_c.red = 0xffff - c.r;
1166 mask_c.green = 0xffff - c.g; 1176 mask_c.green = 0xffff - c.g;
1167 mask_c.blue = 0xffff - c.b; 1177 mask_c.blue = 0xffff - c.b;
1168 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1); 1178 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
1179
1169 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);
1170 1181
1171 if (shade > 100) 1182 if (shade > 100)
1172 { 1183 {
1173 mask_c.red = mask_c.green = mask_c.blue = 0xffff * (shade - 100) / 100;
1174 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;
1175 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1); 1188 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1176 1189
1177 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);
1178 } 1191 }
1179 1192
1180 ret = true; 1193 ret = true;
1181 1194
1182 XRenderFreePicture (dpy, mask_pic); 1195 XRenderFreePicture (dpy, mask_pic);
1183 XRenderFreePicture (dpy, overlay_pic); 1196 XRenderFreePicture (dpy, overlay_pic);
1184 XRenderFreePicture (dpy, back_pic); 1197 XRenderFreePicture (dpy, back_pic);
1198 }
1185# endif 1199# endif
1186 }
1187 1200
1188 return ret; 1201 return ret;
1189} 1202}
1190 1203
1191/* 1204/*
… …
1242#if XRENDER 1255#if XRENDER
1243 if (bg_flags & BG_HAS_RENDER) 1256 if (bg_flags & BG_HAS_RENDER)
1244 { 1257 {
1245 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);
1246 1259
1247 XRenderPictureAttributes pa;
1248
1249 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen)); 1260 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1250 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa); 1261 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1251 1262
1252 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual); 1263 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1253 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa); 1264 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1254 1265
1255 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);
1256 1267
1257 XRenderFreePicture (dpy, src); 1268 XRenderFreePicture (dpy, src);
1258 XRenderFreePicture (dpy, dst); 1269 XRenderFreePicture (dpy, dst);
… …
1275 bg_pmap_width = window_width; 1286 bg_pmap_width = window_width;
1276 bg_pmap_height = window_height; 1287 bg_pmap_height = window_height;
1277 } 1288 }
1278 1289
1279 /* straightforward pixmap copy */ 1290 /* straightforward pixmap copy */
1280 while (sx < 0) sx += root_width; 1291 while (sx < 0) sx += root_pmap_width;
1281 while (sy < 0) sy += root_height; 1292 while (sy < 0) sy += root_pmap_height;
1282 1293
1283 gcv.tile = recoded_root_pmap; 1294 gcv.tile = recoded_root_pmap;
1284 gcv.fill_style = FillTiled; 1295 gcv.fill_style = FillTiled;
1285 gcv.ts_x_origin = -sx; 1296 gcv.ts_x_origin = -sx;
1286 gcv.ts_y_origin = -sy; 1297 gcv.ts_y_origin = -sy;
… …
1288 1299
1289 if (gc) 1300 if (gc)
1290 { 1301 {
1291 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height); 1302 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1292 result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS); 1303 result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS);
1293 XFreeGC (dpy, gc);
1294 1304
1295 if (!(bg_flags & BG_CLIENT_RENDER)) 1305 if (!(bg_flags & BG_CLIENT_RENDER))
1296 { 1306 {
1297 if ((bg_flags & BG_NEEDS_BLUR) 1307 if (bg_flags & BG_NEEDS_BLUR)
1298 && (bg_flags & BG_HAS_RENDER_CONV))
1299 { 1308 {
1300 if (blur_pixmap (bg_pixmap, visual, window_width, window_height)) 1309 if (blur_pixmap (bg_pixmap, visual, window_width, window_height))
1301 result &= ~BG_NEEDS_BLUR; 1310 result &= ~BG_NEEDS_BLUR;
1302 } 1311 }
1303 if ((bg_flags & BG_NEEDS_TINT) 1312 if (bg_flags & BG_NEEDS_TINT)
1304 && (bg_flags & (BG_TINT_BITAND | BG_HAS_RENDER)))
1305 { 1313 {
1306 if (tint_pixmap (bg_pixmap, visual, window_width, window_height)) 1314 if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1307 result &= ~BG_NEEDS_TINT; 1315 result &= ~BG_NEEDS_TINT;
1308 } 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
1309 } /* server side rendering completed */ 1331 } /* server side rendering completed */
1332
1333 XFreeGC (dpy, gc);
1310 } 1334 }
1311 1335
1312 if (recoded_root_pmap != root_pixmap) 1336 if (recoded_root_pmap != root_pixmap)
1313 XFreePixmap (dpy, recoded_root_pmap); 1337 XFreePixmap (dpy, recoded_root_pmap);
1314 1338
… …
1323 new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]); 1347 new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]);
1324 1348
1325 root_pixmap = new_root_pixmap; 1349 root_pixmap = new_root_pixmap;
1326} 1350}
1327# endif /* ENABLE_TRANSPARENCY */ 1351# endif /* ENABLE_TRANSPARENCY */
1328
1329#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1330static void shade_ximage (Visual *visual, XImage *ximage, int shade, const rgba &c);
1331# endif
1332 1352
1333bool 1353bool
1334rxvt_term::bg_render () 1354rxvt_term::bg_render ()
1335{ 1355{
1336 unsigned long tr_flags = 0; 1356 unsigned long tr_flags = 0;
… …
1341 { 1361 {
1342 /* we need to re-generate transparency pixmap in that case ! */ 1362 /* we need to re-generate transparency pixmap in that case ! */
1343 tr_flags = make_transparency_pixmap (); 1363 tr_flags = make_transparency_pixmap ();
1344 if (tr_flags == 0) 1364 if (tr_flags == 0)
1345 return false; 1365 return false;
1346 else if (!(tr_flags & BG_EFFECTS_FLAGS))
1347 bg_flags |= BG_IS_VALID; 1366 bg_flags |= BG_IS_VALID;
1348 } 1367 }
1349# endif 1368# endif
1350 1369
1351# ifdef BG_IMAGE_FROM_FILE 1370# ifdef BG_IMAGE_FROM_FILE
1352 if ((bg_flags & BG_IS_FROM_FILE) 1371 if ((bg_flags & BG_IS_FROM_FILE)
1353 || (tr_flags & BG_EFFECTS_FLAGS)) 1372 || (tr_flags & BG_EFFECTS_FLAGS))
1354 { 1373 {
1355 if (render_image (tr_flags)) 1374 if (render_image (tr_flags))
1356 bg_flags |= BG_IS_VALID; 1375 bg_flags |= BG_IS_VALID;
1357 }
1358# endif
1359
1360# if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1361 XImage *result = NULL;
1362
1363 if (tr_flags && !(bg_flags & BG_IS_VALID))
1364 {
1365 result = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1366 }
1367
1368 if (result)
1369 {
1370 /* our own client-side tinting */
1371 if (tr_flags & BG_NEEDS_TINT)
1372 {
1373 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1374 if (bg_flags & BG_TINT_SET)
1375 tint.get (c);
1376 shade_ximage (DefaultVisual (dpy, display->screen), result, shade, c);
1377 }
1378
1379 GC gc = XCreateGC (dpy, vt, 0UL, NULL);
1380
1381 if (gc)
1382 {
1383 XPutImage (dpy, bg_pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1384
1385 XFreeGC (dpy, gc);
1386 bg_flags |= BG_IS_VALID;
1387 }
1388
1389 XDestroyImage (result);
1390 } 1376 }
1391# endif 1377# endif
1392 1378
1393 if (!(bg_flags & BG_IS_VALID)) 1379 if (!(bg_flags & BG_IS_VALID))
1394 { 1380 {
… …
1432} 1418}
1433 1419
1434#endif /* HAVE_BG_PIXMAP */ 1420#endif /* HAVE_BG_PIXMAP */
1435 1421
1436#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) 1422#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1437/* taken from aterm-0.4.2 */ 1423/* based on code from aterm-0.4.2 */
1438 1424
1439static void 1425static inline void
1440shade_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)
1441{ 1439{
1442 int sh_r, sh_g, sh_b; 1440 int sh_r, sh_g, sh_b;
1443 uint32_t mask_r, mask_g, mask_b; 1441 uint32_t mask_r, mask_g, mask_b;
1444 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b; 1442 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1445 rgba low; 1443 unsigned short low;
1446 rgba high;
1447 int i;
1448 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst; 1444 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1449 1445
1450 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return; 1446 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;
1451 1447
1452 /* for convenience */ 1448 /* for convenience */
… …
1511 break; 1507 break;
1512 default: 1508 default:
1513 return; /* we do not support this color depth */ 1509 return; /* we do not support this color depth */
1514 } 1510 }
1515 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
1516 /* prepare limits for color transformation (each channel is handled separately) */ 1517 /* prepare limits for color transformation (each channel is handled separately) */
1517 if (shade > 100) 1518 if (shade > 100)
1518 { 1519 {
1519 shade = 200 - shade;
1520
1521 high.r = c.r * shade / 100;
1522 high.g = c.g * shade / 100;
1523 high.b = c.b * shade / 100;
1524
1525 low.r = 65535 * (100 - shade) / 100; 1520 c.r = c.r * (200 - shade) / 100;
1526 low.g = 65535 * (100 - shade) / 100; 1521 c.g = c.g * (200 - shade) / 100;
1527 low.b = 65535 * (100 - shade) / 100; 1522 c.b = c.b * (200 - shade) / 100;
1523
1524 low = 0xffff * (shade - 100) / 100;
1528 } 1525 }
1529 else 1526 else
1530 { 1527 {
1531 high.r = c.r * shade / 100; 1528 c.r = c.r * shade / 100;
1532 high.g = c.g * shade / 100; 1529 c.g = c.g * shade / 100;
1533 high.b = c.b * shade / 100; 1530 c.b = c.b * shade / 100;
1534 1531
1535 low.r = low.g = low.b = 0; 1532 low = 0;
1536 } 1533 }
1537 1534
1538 /* fill our lookup tables */ 1535 /* fill our lookup tables */
1539 for (i = 0; i <= mask_r>>sh_r; i++) 1536 fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1540 { 1537 fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1541 uint32_t tmp; 1538 fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1542 tmp = i * high.r;
1543 tmp += (mask_r>>sh_r) * low.r;
1544 lookup_r[i] = (tmp/65535)<<sh_r;
1545 }
1546 for (i = 0; i <= mask_g>>sh_g; i++)
1547 {
1548 uint32_t tmp;
1549 tmp = i * high.g;
1550 tmp += (mask_g>>sh_g) * low.g;
1551 lookup_g[i] = (tmp/65535)<<sh_g;
1552 }
1553 for (i = 0; i <= mask_b>>sh_b; i++)
1554 {
1555 uint32_t tmp;
1556 tmp = i * high.b;
1557 tmp += (mask_b>>sh_b) * low.b;
1558 lookup_b[i] = (tmp/65535)<<sh_b;
1559 }
1560 1539
1561 /* apply table to input image (replacing colors by newly calculated ones) */ 1540 /* apply table to input image (replacing colors by newly calculated ones) */
1562 if (ximage->bits_per_pixel == 32 1541 if (ximage->bits_per_pixel == 32
1563 && (ximage->depth == 24 || ximage->depth == 32) 1542 && (ximage->depth == 24 || ximage->depth == 32)
1564 && ximage->byte_order == host_byte_order) 1543 && ximage->byte_order == host_byte_order)

Diff Legend

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