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.177 by sf-exg, Wed Dec 14 12:07:12 2011 UTC vs.
Revision 1.193 by sf-exg, Sun Jan 1 14:31:29 2012 UTC

… …
33#ifndef FilterConvolution 33#ifndef FilterConvolution
34#define FilterConvolution "convolution" 34#define FilterConvolution "convolution"
35#endif 35#endif
36 36
37#ifdef HAVE_BG_PIXMAP 37#ifdef HAVE_BG_PIXMAP
38# if XRENDER
39static Picture
40create_xrender_mask (Display *dpy, Drawable drawable, Bool argb, Bool component_alpha)
41{
42 Pixmap pixmap = XCreatePixmap (dpy, drawable, 1, 1, argb ? 32 : 8);
43
44 XRenderPictFormat *format = XRenderFindStandardFormat (dpy, argb ? PictStandardARGB32 : PictStandardA8);
45 XRenderPictureAttributes pa;
46 pa.repeat = True;
47 pa.component_alpha = component_alpha;
48 Picture mask = XRenderCreatePicture (dpy, pixmap, format, CPRepeat | CPComponentAlpha, &pa);
49
50 XFreePixmap (dpy, pixmap);
51
52 return mask;
53}
54# endif
55
38void 56void
39rxvt_term::bg_destroy () 57rxvt_term::bg_destroy ()
40{ 58{
41#ifdef HAVE_AFTERIMAGE 59#ifdef HAVE_AFTERIMAGE
42 if (original_asim) 60 if (original_asim)
… …
181{ 199{
182 bool changed = false; 200 bool changed = false;
183 int geom_flags = 0; 201 int geom_flags = 0;
184 int x = 0, y = 0; 202 int x = 0, y = 0;
185 unsigned int w = 0, h = 0; 203 unsigned int w = 0, h = 0;
186 unsigned long new_flags = bg_flags & ~BG_GEOMETRY_FLAGS; 204 unsigned long new_flags = 0;
187 205
188 if (geom == NULL) 206 if (geom == NULL)
189 return false; 207 return false;
190 208
191 if (geom[0]) 209 if (geom[0])
… …
284 } /* done parsing ops */ 302 } /* done parsing ops */
285 303
286 rxvt_free_strsplit (arr); 304 rxvt_free_strsplit (arr);
287 } 305 }
288 306
307 new_flags |= bg_flags & ~BG_GEOMETRY_FLAGS;
308
289 if (!update) 309 if (!update)
290 { 310 {
291 if (!(geom_flags & XValue)) 311 if (!(geom_flags & XValue))
292 x = y = defaultAlign; 312 x = y = defaultAlign;
293 else if (!(geom_flags & YValue)) 313 else if (!(geom_flags & YValue))
… …
372 if (tr_flags & BG_NEEDS_TINT) 392 if (tr_flags & BG_NEEDS_TINT)
373 { 393 {
374 ShadingInfo as_shade; 394 ShadingInfo as_shade;
375 as_shade.shading = shade; 395 as_shade.shading = shade;
376 396
377 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 397 rgba c;
378 if (bg_flags & BG_TINT_SET)
379 tint.get (c); 398 tint.get (c);
380 as_shade.tintColor.red = c.r; 399 as_shade.tintColor.red = c.r;
381 as_shade.tintColor.green = c.g; 400 as_shade.tintColor.green = c.g;
382 as_shade.tintColor.blue = c.b; 401 as_shade.tintColor.blue = c.b;
383 402
384 background_tint = shading2tint32 (&as_shade); 403 background_tint = shading2tint32 (&as_shade);
… …
800 } 819 }
801 820
802#if XRENDER 821#if XRENDER
803 if (tr_flags) 822 if (tr_flags)
804 { 823 {
805 XRenderPictureAttributes pa;
806
807 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, visual); 824 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
825
808 Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa); 826 Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
809 827
810 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
811 Picture dst = XRenderCreatePicture (dpy, bg_pixmap, dst_format, 0, &pa); 828 Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
812 829
813 pa.repeat = True; 830 Picture mask = create_xrender_mask (dpy, vt, False, False);
814 Pixmap mask_pmap = XCreatePixmap (dpy, vt, 1, 1, 8);
815 XRenderPictFormat *mask_format = XRenderFindStandardFormat (dpy, PictStandardA8);
816 Picture mask = XRenderCreatePicture (dpy, mask_pmap, mask_format, CPRepeat, &pa);
817 XFreePixmap (dpy, mask_pmap);
818 831
819 XRenderColor mask_c; 832 XRenderColor mask_c;
820 833
821 mask_c.alpha = 0x8000; 834 mask_c.alpha = 0x8000;
822 mask_c.red = 0; 835 mask_c.red =
823 mask_c.green = 0; 836 mask_c.green =
824 mask_c.blue = 0; 837 mask_c.blue = 0;
825 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1); 838 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
839
826 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height); 840 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
827 841
828 XRenderFreePicture (dpy, src); 842 XRenderFreePicture (dpy, src);
829 XRenderFreePicture (dpy, dst); 843 XRenderFreePicture (dpy, dst);
830 XRenderFreePicture (dpy, mask); 844 XRenderFreePicture (dpy, mask);
… …
942 { 956 {
943 changed = true; 957 changed = true;
944 v_blurRadius = vr; 958 v_blurRadius = vr;
945 } 959 }
946 960
947 if (v_blurRadius == 0 && h_blurRadius == 0) 961 if (h_blurRadius == 0 || v_blurRadius == 0)
948 bg_flags &= ~BG_NEEDS_BLUR; 962 bg_flags &= ~BG_NEEDS_BLUR;
949 else 963 else
950 bg_flags |= BG_NEEDS_BLUR; 964 bg_flags |= BG_NEEDS_BLUR;
951 965
952 return changed; 966 return changed;
953} 967}
954 968
955void 969void
956rxvt_term::set_tint_shade_flags () 970rxvt_term::set_tint_shade_flags ()
957{ 971{
958 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 972 rgba c;
959 bool has_shade = shade != 100; 973 bool has_shade = shade != 100;
960 974
961 bg_flags &= ~BG_TINT_FLAGS; 975 bg_flags &= ~BG_TINT_FLAGS;
962 976
963 if (bg_flags & BG_TINT_SET)
964 {
965 tint.get (c); 977 tint.get (c);
978
966 if (!has_shade 979 if (!has_shade
967 && (c.r <= 0x00ff || c.r >= 0xff00) 980 && (c.r <= 0x00ff || c.r >= 0xff00)
968 && (c.g <= 0x00ff || c.g >= 0xff00) 981 && (c.g <= 0x00ff || c.g >= 0xff00)
969 && (c.b <= 0x00ff || c.b >= 0xff00)) 982 && (c.b <= 0x00ff || c.b >= 0xff00))
970 bg_flags |= BG_TINT_BITAND; 983 bg_flags |= BG_TINT_BITAND;
971 }
972 984
973 if (has_shade || (bg_flags & BG_TINT_SET)) 985 if (has_shade
986 || c.r < 0xff00
987 || c.g < 0xff00
988 || c.b < 0xff00)
974 bg_flags |= BG_NEEDS_TINT; 989 bg_flags |= BG_NEEDS_TINT;
975} 990}
976 991
977bool 992bool
978rxvt_term::bg_set_tint (rxvt_color &new_tint) 993rxvt_term::bg_set_tint (rxvt_color &new_tint)
979{ 994{
980 if (!(bg_flags & BG_TINT_SET) || tint != new_tint) 995 if (tint != new_tint)
981 { 996 {
982 tint = new_tint; 997 tint = new_tint;
983 bg_flags |= BG_TINT_SET;
984 set_tint_shade_flags (); 998 set_tint_shade_flags ();
985 return true; 999 return true;
986 } 1000 }
987 1001
988 return false; 1002 return false;
989} 1003}
990 1004
991bool 1005bool
992rxvt_term::bg_set_shade (const char *shade_str) 1006rxvt_term::bg_set_shade (const char *shade_str)
993{ 1007{
994 int new_shade = (shade_str) ? atoi (shade_str) : 100; 1008 int new_shade = atoi (shade_str);
995 1009
996 clamp_it (new_shade, -100, 200); 1010 clamp_it (new_shade, -100, 200);
997 if (new_shade < 0) 1011 if (new_shade < 0)
998 new_shade = 200 - (100 + new_shade); 1012 new_shade = 200 - (100 + new_shade);
999 1013
… …
1033bool 1047bool
1034rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 1048rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1035{ 1049{
1036 bool ret = false; 1050 bool ret = false;
1037#if XRENDER 1051#if XRENDER
1052 if (!(bg_flags & BG_HAS_RENDER_CONV))
1053 return false;
1054
1038 int size = max (h_blurRadius, v_blurRadius) * 2 + 1; 1055 int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1039 double *kernel = (double *)malloc (size * sizeof (double)); 1056 double *kernel = (double *)malloc (size * sizeof (double));
1040 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 1057 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1041 1058
1042 XRenderPictureAttributes pa;
1043 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 1059 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1044 1060
1045 Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 1061 Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1046 Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 1062 Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1047 1063
1048 if (kernel && params) 1064 if (kernel && params)
1049 { 1065 {
1050 if (h_blurRadius)
1051 {
1052 size = h_blurRadius * 2 + 1; 1066 size = h_blurRadius * 2 + 1;
1053 get_gaussian_kernel (h_blurRadius, size, kernel, params); 1067 get_gaussian_kernel (h_blurRadius, size, kernel, params);
1054 1068
1055 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 1069 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1056 XRenderComposite (dpy, 1070 XRenderComposite (dpy,
1057 PictOpSrc, 1071 PictOpSrc,
1058 src, 1072 src,
1059 None, 1073 None,
1060 dst, 1074 dst,
1061 0, 0, 1075 0, 0,
1062 0, 0, 1076 0, 0,
1063 0, 0, 1077 0, 0,
1064 width, height); 1078 width, height);
1065 }
1066 1079
1067 if (v_blurRadius)
1068 {
1069 size = v_blurRadius * 2 + 1; 1080 size = v_blurRadius * 2 + 1;
1070 get_gaussian_kernel (v_blurRadius, size, kernel, params); 1081 get_gaussian_kernel (v_blurRadius, size, kernel, params);
1071 ::swap (params[0], params[1]); 1082 ::swap (params[0], params[1]);
1072 1083
1073 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 1084 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1074 XRenderComposite (dpy, 1085 XRenderComposite (dpy,
1075 PictOpSrc, 1086 PictOpSrc,
1076 src, 1087 src,
1077 None, 1088 None,
1078 dst, 1089 dst,
1079 0, 0, 1090 0, 0,
1080 0, 0, 1091 0, 0,
1081 0, 0, 1092 0, 0,
1082 width, height); 1093 width, height);
1083 }
1084 1094
1085 ret = true; 1095 ret = true;
1086 } 1096 }
1087 1097
1088 free (kernel); 1098 free (kernel);
… …
1115 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height); 1125 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1116 ret = true; 1126 ret = true;
1117 XFreeGC (dpy, gc); 1127 XFreeGC (dpy, gc);
1118 } 1128 }
1119 } 1129 }
1120 else
1121 {
1122# if XRENDER 1130# if XRENDER
1123 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC); 1131 else if (bg_flags & BG_HAS_RENDER)
1132 {
1133 rgba c;
1124 1134
1125 if (bg_flags & BG_TINT_SET)
1126 tint.get (c); 1135 tint.get (c);
1127 1136
1128 if (shade <= 100) 1137 if (shade <= 100)
1129 { 1138 {
1130 c.r = c.r * shade / 100; 1139 c.r = c.r * shade / 100;
1131 c.g = c.g * shade / 100; 1140 c.g = c.g * shade / 100;
… …
1136 c.r = c.r * (200 - shade) / 100; 1145 c.r = c.r * (200 - shade) / 100;
1137 c.g = c.g * (200 - shade) / 100; 1146 c.g = c.g * (200 - shade) / 100;
1138 c.b = c.b * (200 - shade) / 100; 1147 c.b = c.b * (200 - shade) / 100;
1139 } 1148 }
1140 1149
1141 XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1142 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 1150 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1143 XRenderPictureAttributes pa;
1144 1151
1145 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 1152 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1146 1153
1147 pa.repeat = True; 1154 Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1148 1155
1149 Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32); 1156 Picture mask_pic = create_xrender_mask (dpy, pixmap, True, True);
1150 Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1151 XFreePixmap (dpy, overlay_pmap);
1152
1153 pa.component_alpha = True;
1154 Pixmap mask_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
1155 Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat | CPComponentAlpha, &pa);
1156 XFreePixmap (dpy, mask_pmap);
1157 1157
1158 XRenderColor mask_c; 1158 XRenderColor mask_c;
1159 1159
1160 mask_c.alpha = 0xffff; 1160 mask_c.alpha = 0xffff;
1161 mask_c.red = 1161 mask_c.red =
… …
1166 mask_c.alpha = 0; 1166 mask_c.alpha = 0;
1167 mask_c.red = 0xffff - c.r; 1167 mask_c.red = 0xffff - c.r;
1168 mask_c.green = 0xffff - c.g; 1168 mask_c.green = 0xffff - c.g;
1169 mask_c.blue = 0xffff - c.b; 1169 mask_c.blue = 0xffff - c.b;
1170 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1); 1170 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
1171
1171 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height); 1172 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1172 1173
1173 if (shade > 100) 1174 if (shade > 100)
1174 { 1175 {
1175 mask_c.red = mask_c.green = mask_c.blue = 0xffff * (shade - 100) / 100;
1176 mask_c.alpha = 0; 1176 mask_c.alpha = 0;
1177 mask_c.red =
1178 mask_c.green =
1179 mask_c.blue = 0xffff * (shade - 100) / 100;
1177 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1); 1180 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1178 1181
1179 XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height); 1182 XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1180 } 1183 }
1181 1184
1182 ret = true; 1185 ret = true;
1183 1186
1184 XRenderFreePicture (dpy, mask_pic); 1187 XRenderFreePicture (dpy, mask_pic);
1185 XRenderFreePicture (dpy, overlay_pic); 1188 XRenderFreePicture (dpy, overlay_pic);
1186 XRenderFreePicture (dpy, back_pic); 1189 XRenderFreePicture (dpy, back_pic);
1190 }
1187# endif 1191# endif
1188 }
1189 1192
1190 return ret; 1193 return ret;
1191} 1194}
1192 1195
1193/* 1196/*
… …
1244#if XRENDER 1247#if XRENDER
1245 if (bg_flags & BG_HAS_RENDER) 1248 if (bg_flags & BG_HAS_RENDER)
1246 { 1249 {
1247 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth); 1250 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1248 1251
1249 XRenderPictureAttributes pa;
1250
1251 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen)); 1252 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1252 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa); 1253 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1253 1254
1254 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual); 1255 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1255 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa); 1256 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1256 1257
1257 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height); 1258 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
1258 1259
1259 XRenderFreePicture (dpy, src); 1260 XRenderFreePicture (dpy, src);
1260 XRenderFreePicture (dpy, dst); 1261 XRenderFreePicture (dpy, dst);
… …
1277 bg_pmap_width = window_width; 1278 bg_pmap_width = window_width;
1278 bg_pmap_height = window_height; 1279 bg_pmap_height = window_height;
1279 } 1280 }
1280 1281
1281 /* straightforward pixmap copy */ 1282 /* straightforward pixmap copy */
1282 while (sx < 0) sx += root_width; 1283 while (sx < 0) sx += root_pmap_width;
1283 while (sy < 0) sy += root_height; 1284 while (sy < 0) sy += root_pmap_height;
1284 1285
1285 gcv.tile = recoded_root_pmap; 1286 gcv.tile = recoded_root_pmap;
1286 gcv.fill_style = FillTiled; 1287 gcv.fill_style = FillTiled;
1287 gcv.ts_x_origin = -sx; 1288 gcv.ts_x_origin = -sx;
1288 gcv.ts_y_origin = -sy; 1289 gcv.ts_y_origin = -sy;
… …
1290 1291
1291 if (gc) 1292 if (gc)
1292 { 1293 {
1293 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height); 1294 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1294 result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS); 1295 result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS);
1295 XFreeGC (dpy, gc);
1296 1296
1297 if (!(bg_flags & BG_CLIENT_RENDER)) 1297 if (!(bg_flags & BG_CLIENT_RENDER))
1298 { 1298 {
1299 if ((bg_flags & BG_NEEDS_BLUR) 1299 if (bg_flags & BG_NEEDS_BLUR)
1300 && (bg_flags & BG_HAS_RENDER_CONV))
1301 { 1300 {
1302 if (blur_pixmap (bg_pixmap, visual, window_width, window_height)) 1301 if (blur_pixmap (bg_pixmap, visual, window_width, window_height))
1303 result &= ~BG_NEEDS_BLUR; 1302 result &= ~BG_NEEDS_BLUR;
1304 } 1303 }
1305 if ((bg_flags & BG_NEEDS_TINT) 1304 if (bg_flags & BG_NEEDS_TINT)
1306 && (bg_flags & (BG_TINT_BITAND | BG_HAS_RENDER)))
1307 { 1305 {
1308 if (tint_pixmap (bg_pixmap, visual, window_width, window_height)) 1306 if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1309 result &= ~BG_NEEDS_TINT; 1307 result &= ~BG_NEEDS_TINT;
1310 } 1308 }
1309# ifndef HAVE_AFTERIMAGE
1310 if (result & BG_NEEDS_TINT)
1311 {
1312 XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1313 if (ximage)
1314 {
1315 /* our own client-side tinting */
1316 tint_ximage (DefaultVisual (dpy, display->screen), ximage);
1317
1318 XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
1319 XDestroyImage (ximage);
1320 }
1321 }
1322# endif
1311 } /* server side rendering completed */ 1323 } /* server side rendering completed */
1324
1325 XFreeGC (dpy, gc);
1312 } 1326 }
1313 1327
1314 if (recoded_root_pmap != root_pixmap) 1328 if (recoded_root_pmap != root_pixmap)
1315 XFreePixmap (dpy, recoded_root_pmap); 1329 XFreePixmap (dpy, recoded_root_pmap);
1316 1330
… …
1325 new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]); 1339 new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]);
1326 1340
1327 root_pixmap = new_root_pixmap; 1341 root_pixmap = new_root_pixmap;
1328} 1342}
1329# endif /* ENABLE_TRANSPARENCY */ 1343# endif /* ENABLE_TRANSPARENCY */
1330
1331#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1332static void shade_ximage (Visual *visual, XImage *ximage, int shade, const rgba &c);
1333# endif
1334 1344
1335bool 1345bool
1336rxvt_term::bg_render () 1346rxvt_term::bg_render ()
1337{ 1347{
1338 unsigned long tr_flags = 0; 1348 unsigned long tr_flags = 0;
… …
1356 if (render_image (tr_flags)) 1366 if (render_image (tr_flags))
1357 bg_flags |= BG_IS_VALID; 1367 bg_flags |= BG_IS_VALID;
1358 } 1368 }
1359# endif 1369# endif
1360 1370
1361# if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1362 XImage *result = NULL;
1363
1364 if (tr_flags & BG_NEEDS_TINT)
1365 {
1366 result = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1367 }
1368
1369 if (result)
1370 {
1371 /* our own client-side tinting */
1372 //if (tr_flags & BG_NEEDS_TINT)
1373 if (1)
1374 {
1375 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1376 if (bg_flags & BG_TINT_SET)
1377 tint.get (c);
1378 shade_ximage (DefaultVisual (dpy, display->screen), result, shade, c);
1379 }
1380
1381 GC gc = XCreateGC (dpy, vt, 0UL, NULL);
1382
1383 if (gc)
1384 {
1385 XPutImage (dpy, bg_pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1386
1387 XFreeGC (dpy, gc);
1388 }
1389
1390 XDestroyImage (result);
1391 }
1392# endif
1393
1394 if (!(bg_flags & BG_IS_VALID)) 1371 if (!(bg_flags & BG_IS_VALID))
1395 { 1372 {
1396 if (bg_pixmap != None) 1373 if (bg_pixmap != None)
1397 { 1374 {
1398 XFreePixmap (dpy, bg_pixmap); 1375 XFreePixmap (dpy, bg_pixmap);
… …
1410 1387
1411void 1388void
1412rxvt_term::bg_init () 1389rxvt_term::bg_init ()
1413{ 1390{
1414#ifdef ENABLE_TRANSPARENCY 1391#ifdef ENABLE_TRANSPARENCY
1392 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1393 tint.set (this, c);
1415 shade = 100; 1394 shade = 100;
1416#endif 1395#endif
1417 1396
1418 bg_flags &= ~(BG_HAS_RENDER | BG_HAS_RENDER_CONV); 1397 bg_flags &= ~(BG_HAS_RENDER | BG_HAS_RENDER_CONV);
1419#if XRENDER 1398#if XRENDER
… …
1435#endif /* HAVE_BG_PIXMAP */ 1414#endif /* HAVE_BG_PIXMAP */
1436 1415
1437#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) 1416#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1438/* based on code from aterm-0.4.2 */ 1417/* based on code from aterm-0.4.2 */
1439 1418
1440static void 1419static inline void
1441shade_ximage (Visual *visual, XImage *ximage, int shade, const rgba &c) 1420fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
1421{
1422 for (int i = 0; i <= mask >> sh; i++)
1423 {
1424 uint32_t tmp;
1425 tmp = i * high;
1426 tmp += (mask >> sh) * low;
1427 lookup[i] = (tmp / 0xffff) << sh;
1428 }
1429}
1430
1431void
1432rxvt_term::tint_ximage (Visual *visual, XImage *ximage)
1442{ 1433{
1443 int sh_r, sh_g, sh_b; 1434 int sh_r, sh_g, sh_b;
1444 uint32_t mask_r, mask_g, mask_b; 1435 uint32_t mask_r, mask_g, mask_b;
1445 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b; 1436 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1446 rgba low; 1437 unsigned short low;
1447 rgba high;
1448 int i;
1449 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst; 1438 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1450 1439
1451 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return; 1440 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;
1452 1441
1453 /* for convenience */ 1442 /* for convenience */
… …
1512 break; 1501 break;
1513 default: 1502 default:
1514 return; /* we do not support this color depth */ 1503 return; /* we do not support this color depth */
1515 } 1504 }
1516 1505
1506 rgba c;
1507
1508 tint.get (c);
1509
1517 /* prepare limits for color transformation (each channel is handled separately) */ 1510 /* prepare limits for color transformation (each channel is handled separately) */
1518 if (shade > 100) 1511 if (shade > 100)
1519 { 1512 {
1520 shade = 200 - shade;
1521
1522 high.r = c.r * shade / 100;
1523 high.g = c.g * shade / 100;
1524 high.b = c.b * shade / 100;
1525
1526 low.r = 65535 * (100 - shade) / 100; 1513 c.r = c.r * (200 - shade) / 100;
1527 low.g = 65535 * (100 - shade) / 100; 1514 c.g = c.g * (200 - shade) / 100;
1528 low.b = 65535 * (100 - shade) / 100; 1515 c.b = c.b * (200 - shade) / 100;
1516
1517 low = 0xffff * (shade - 100) / 100;
1529 } 1518 }
1530 else 1519 else
1531 { 1520 {
1532 high.r = c.r * shade / 100; 1521 c.r = c.r * shade / 100;
1533 high.g = c.g * shade / 100; 1522 c.g = c.g * shade / 100;
1534 high.b = c.b * shade / 100; 1523 c.b = c.b * shade / 100;
1535 1524
1536 low.r = low.g = low.b = 0; 1525 low = 0;
1537 } 1526 }
1538 1527
1539 /* fill our lookup tables */ 1528 /* fill our lookup tables */
1540 for (i = 0; i <= mask_r>>sh_r; i++) 1529 fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1541 { 1530 fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1542 uint32_t tmp; 1531 fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1543 tmp = i * high.r;
1544 tmp += (mask_r>>sh_r) * low.r;
1545 lookup_r[i] = (tmp/65535)<<sh_r;
1546 }
1547 for (i = 0; i <= mask_g>>sh_g; i++)
1548 {
1549 uint32_t tmp;
1550 tmp = i * high.g;
1551 tmp += (mask_g>>sh_g) * low.g;
1552 lookup_g[i] = (tmp/65535)<<sh_g;
1553 }
1554 for (i = 0; i <= mask_b>>sh_b; i++)
1555 {
1556 uint32_t tmp;
1557 tmp = i * high.b;
1558 tmp += (mask_b>>sh_b) * low.b;
1559 lookup_b[i] = (tmp/65535)<<sh_b;
1560 }
1561 1532
1562 /* apply table to input image (replacing colors by newly calculated ones) */ 1533 /* apply table to input image (replacing colors by newly calculated ones) */
1563 if (ximage->bits_per_pixel == 32 1534 if (ximage->bits_per_pixel == 32
1564 && (ximage->depth == 24 || ximage->depth == 32) 1535 && (ximage->depth == 24 || ximage->depth == 32)
1565 && ximage->byte_order == host_byte_order) 1536 && ximage->byte_order == host_byte_order)

Diff Legend

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