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.172 by sf-exg, Tue Aug 30 15:00:27 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)
… …
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;
… …
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;
… …
1351 if ((bg_flags & BG_IS_FROM_FILE) 1371 if ((bg_flags & BG_IS_FROM_FILE)
1352 || (tr_flags & BG_EFFECTS_FLAGS)) 1372 || (tr_flags & BG_EFFECTS_FLAGS))
1353 { 1373 {
1354 if (render_image (tr_flags)) 1374 if (render_image (tr_flags))
1355 bg_flags |= BG_IS_VALID; 1375 bg_flags |= BG_IS_VALID;
1356 }
1357# endif
1358
1359# if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1360 XImage *result = NULL;
1361
1362 if (tr_flags & BG_NEEDS_TINT)
1363 {
1364 result = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1365 }
1366
1367 if (result)
1368 {
1369 /* our own client-side tinting */
1370 //if (tr_flags & BG_NEEDS_TINT)
1371 if (1)
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 }
1387
1388 XDestroyImage (result);
1389 } 1376 }
1390# endif 1377# endif
1391 1378
1392 if (!(bg_flags & BG_IS_VALID)) 1379 if (!(bg_flags & BG_IS_VALID))
1393 { 1380 {
… …
1433#endif /* HAVE_BG_PIXMAP */ 1420#endif /* HAVE_BG_PIXMAP */
1434 1421
1435#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) 1422#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1436/* based on code from aterm-0.4.2 */ 1423/* based on code from aterm-0.4.2 */
1437 1424
1438static void 1425static inline void
1439shade_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)
1440{ 1439{
1441 int sh_r, sh_g, sh_b; 1440 int sh_r, sh_g, sh_b;
1442 uint32_t mask_r, mask_g, mask_b; 1441 uint32_t mask_r, mask_g, mask_b;
1443 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b; 1442 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1444 rgba low; 1443 unsigned short low;
1445 rgba high;
1446 int i;
1447 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst; 1444 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1448 1445
1449 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return; 1446 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;
1450 1447
1451 /* for convenience */ 1448 /* for convenience */
… …
1510 break; 1507 break;
1511 default: 1508 default:
1512 return; /* we do not support this color depth */ 1509 return; /* we do not support this color depth */
1513 } 1510 }
1514 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
1515 /* prepare limits for color transformation (each channel is handled separately) */ 1517 /* prepare limits for color transformation (each channel is handled separately) */
1516 if (shade > 100) 1518 if (shade > 100)
1517 { 1519 {
1518 shade = 200 - shade;
1519
1520 high.r = c.r * shade / 100;
1521 high.g = c.g * shade / 100;
1522 high.b = c.b * shade / 100;
1523
1524 low.r = 65535 * (100 - shade) / 100; 1520 c.r = c.r * (200 - shade) / 100;
1525 low.g = 65535 * (100 - shade) / 100; 1521 c.g = c.g * (200 - shade) / 100;
1526 low.b = 65535 * (100 - shade) / 100; 1522 c.b = c.b * (200 - shade) / 100;
1523
1524 low = 0xffff * (shade - 100) / 100;
1527 } 1525 }
1528 else 1526 else
1529 { 1527 {
1530 high.r = c.r * shade / 100; 1528 c.r = c.r * shade / 100;
1531 high.g = c.g * shade / 100; 1529 c.g = c.g * shade / 100;
1532 high.b = c.b * shade / 100; 1530 c.b = c.b * shade / 100;
1533 1531
1534 low.r = low.g = low.b = 0; 1532 low = 0;
1535 } 1533 }
1536 1534
1537 /* fill our lookup tables */ 1535 /* fill our lookup tables */
1538 for (i = 0; i <= mask_r>>sh_r; i++) 1536 fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1539 { 1537 fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1540 uint32_t tmp; 1538 fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1541 tmp = i * high.r;
1542 tmp += (mask_r>>sh_r) * low.r;
1543 lookup_r[i] = (tmp/65535)<<sh_r;
1544 }
1545 for (i = 0; i <= mask_g>>sh_g; i++)
1546 {
1547 uint32_t tmp;
1548 tmp = i * high.g;
1549 tmp += (mask_g>>sh_g) * low.g;
1550 lookup_g[i] = (tmp/65535)<<sh_g;
1551 }
1552 for (i = 0; i <= mask_b>>sh_b; i++)
1553 {
1554 uint32_t tmp;
1555 tmp = i * high.b;
1556 tmp += (mask_b>>sh_b) * low.b;
1557 lookup_b[i] = (tmp/65535)<<sh_b;
1558 }
1559 1539
1560 /* apply table to input image (replacing colors by newly calculated ones) */ 1540 /* apply table to input image (replacing colors by newly calculated ones) */
1561 if (ximage->bits_per_pixel == 32 1541 if (ximage->bits_per_pixel == 32
1562 && (ximage->depth == 24 || ximage->depth == 32) 1542 && (ximage->depth == 24 || ximage->depth == 32)
1563 && ximage->byte_order == host_byte_order) 1543 && ximage->byte_order == host_byte_order)

Diff Legend

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