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.182 by sf-exg, Sun Dec 25 17:01:21 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;
… …
958 rgba c; 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
… …
1040 1054
1041 int size = max (h_blurRadius, v_blurRadius) * 2 + 1; 1055 int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1042 double *kernel = (double *)malloc (size * sizeof (double)); 1056 double *kernel = (double *)malloc (size * sizeof (double));
1043 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 1057 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1044 1058
1045 XRenderPictureAttributes pa;
1046 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 1059 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1047 1060
1048 Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 1061 Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1049 Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 1062 Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1050 1063
1051 if (kernel && params) 1064 if (kernel && params)
1052 { 1065 {
1053 if (h_blurRadius)
1054 {
1055 size = h_blurRadius * 2 + 1; 1066 size = h_blurRadius * 2 + 1;
1056 get_gaussian_kernel (h_blurRadius, size, kernel, params); 1067 get_gaussian_kernel (h_blurRadius, size, kernel, params);
1057 1068
1058 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 1069 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1059 XRenderComposite (dpy, 1070 XRenderComposite (dpy,
1060 PictOpSrc, 1071 PictOpSrc,
1061 src, 1072 src,
1062 None, 1073 None,
1063 dst, 1074 dst,
1064 0, 0, 1075 0, 0,
1065 0, 0, 1076 0, 0,
1066 0, 0, 1077 0, 0,
1067 width, height); 1078 width, height);
1068 }
1069 1079
1070 if (v_blurRadius)
1071 {
1072 size = v_blurRadius * 2 + 1; 1080 size = v_blurRadius * 2 + 1;
1073 get_gaussian_kernel (v_blurRadius, size, kernel, params); 1081 get_gaussian_kernel (v_blurRadius, size, kernel, params);
1074 ::swap (params[0], params[1]); 1082 ::swap (params[0], params[1]);
1075 1083
1076 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 1084 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1077 XRenderComposite (dpy, 1085 XRenderComposite (dpy,
1078 PictOpSrc, 1086 PictOpSrc,
1079 src, 1087 src,
1080 None, 1088 None,
1081 dst, 1089 dst,
1082 0, 0, 1090 0, 0,
1083 0, 0, 1091 0, 0,
1084 0, 0, 1092 0, 0,
1085 width, height); 1093 width, height);
1086 }
1087 1094
1088 ret = true; 1095 ret = true;
1089 } 1096 }
1090 1097
1091 free (kernel); 1098 free (kernel);
… …
1121 } 1128 }
1122 } 1129 }
1123# if XRENDER 1130# if XRENDER
1124 else if (bg_flags & BG_HAS_RENDER) 1131 else if (bg_flags & BG_HAS_RENDER)
1125 { 1132 {
1126 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC); 1133 rgba c;
1127 1134
1128 if (bg_flags & BG_TINT_SET)
1129 tint.get (c); 1135 tint.get (c);
1130 1136
1131 if (shade <= 100) 1137 if (shade <= 100)
1132 { 1138 {
1133 c.r = c.r * shade / 100; 1139 c.r = c.r * shade / 100;
1134 c.g = c.g * shade / 100; 1140 c.g = c.g * shade / 100;
… …
1139 c.r = c.r * (200 - shade) / 100; 1145 c.r = c.r * (200 - shade) / 100;
1140 c.g = c.g * (200 - shade) / 100; 1146 c.g = c.g * (200 - shade) / 100;
1141 c.b = c.b * (200 - shade) / 100; 1147 c.b = c.b * (200 - shade) / 100;
1142 } 1148 }
1143 1149
1144 XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1145 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 1150 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1146 XRenderPictureAttributes pa;
1147 1151
1148 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 1152 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1149 1153
1150 pa.repeat = True; 1154 Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1151 1155
1152 Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32); 1156 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 1157
1161 XRenderColor mask_c; 1158 XRenderColor mask_c;
1162 1159
1163 mask_c.alpha = 0xffff; 1160 mask_c.alpha = 0xffff;
1164 mask_c.red = 1161 mask_c.red =
… …
1169 mask_c.alpha = 0; 1166 mask_c.alpha = 0;
1170 mask_c.red = 0xffff - c.r; 1167 mask_c.red = 0xffff - c.r;
1171 mask_c.green = 0xffff - c.g; 1168 mask_c.green = 0xffff - c.g;
1172 mask_c.blue = 0xffff - c.b; 1169 mask_c.blue = 0xffff - c.b;
1173 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1); 1170 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
1171
1174 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);
1175 1173
1176 if (shade > 100) 1174 if (shade > 100)
1177 { 1175 {
1178 mask_c.red = mask_c.green = mask_c.blue = 0xffff * (shade - 100) / 100;
1179 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;
1180 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1); 1180 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1181 1181
1182 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);
1183 } 1183 }
1184 1184
… …
1247#if XRENDER 1247#if XRENDER
1248 if (bg_flags & BG_HAS_RENDER) 1248 if (bg_flags & BG_HAS_RENDER)
1249 { 1249 {
1250 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);
1251 1251
1252 XRenderPictureAttributes pa;
1253
1254 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen)); 1252 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1255 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa); 1253 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1256 1254
1257 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual); 1255 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1258 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa); 1256 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1259 1257
1260 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);
1261 1259
1262 XRenderFreePicture (dpy, src); 1260 XRenderFreePicture (dpy, src);
1263 XRenderFreePicture (dpy, dst); 1261 XRenderFreePicture (dpy, dst);
… …
1293 1291
1294 if (gc) 1292 if (gc)
1295 { 1293 {
1296 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height); 1294 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1297 result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS); 1295 result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS);
1298 XFreeGC (dpy, gc);
1299 1296
1300 if (!(bg_flags & BG_CLIENT_RENDER)) 1297 if (!(bg_flags & BG_CLIENT_RENDER))
1301 { 1298 {
1302 if (bg_flags & BG_NEEDS_BLUR) 1299 if (bg_flags & BG_NEEDS_BLUR)
1303 { 1300 {
… …
1307 if (bg_flags & BG_NEEDS_TINT) 1304 if (bg_flags & BG_NEEDS_TINT)
1308 { 1305 {
1309 if (tint_pixmap (bg_pixmap, visual, window_width, window_height)) 1306 if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1310 result &= ~BG_NEEDS_TINT; 1307 result &= ~BG_NEEDS_TINT;
1311 } 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
1312 } /* server side rendering completed */ 1323 } /* server side rendering completed */
1324
1325 XFreeGC (dpy, gc);
1313 } 1326 }
1314 1327
1315 if (recoded_root_pmap != root_pixmap) 1328 if (recoded_root_pmap != root_pixmap)
1316 XFreePixmap (dpy, recoded_root_pmap); 1329 XFreePixmap (dpy, recoded_root_pmap);
1317 1330
… …
1326 new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]); 1339 new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]);
1327 1340
1328 root_pixmap = new_root_pixmap; 1341 root_pixmap = new_root_pixmap;
1329} 1342}
1330# endif /* ENABLE_TRANSPARENCY */ 1343# endif /* ENABLE_TRANSPARENCY */
1331
1332#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1333static void shade_ximage (Visual *visual, XImage *ximage, int shade, const rgba &c);
1334# endif
1335 1344
1336bool 1345bool
1337rxvt_term::bg_render () 1346rxvt_term::bg_render ()
1338{ 1347{
1339 unsigned long tr_flags = 0; 1348 unsigned long tr_flags = 0;
… …
1357 if (render_image (tr_flags)) 1366 if (render_image (tr_flags))
1358 bg_flags |= BG_IS_VALID; 1367 bg_flags |= BG_IS_VALID;
1359 } 1368 }
1360# endif 1369# endif
1361 1370
1362# if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1363 XImage *result = NULL;
1364
1365 if (tr_flags & BG_NEEDS_TINT)
1366 {
1367 result = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1368 }
1369
1370 if (result)
1371 {
1372 /* our own client-side tinting */
1373 //if (tr_flags & BG_NEEDS_TINT)
1374 if (1)
1375 {
1376 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1377 if (bg_flags & BG_TINT_SET)
1378 tint.get (c);
1379 shade_ximage (DefaultVisual (dpy, display->screen), result, shade, c);
1380 }
1381
1382 GC gc = XCreateGC (dpy, vt, 0UL, NULL);
1383
1384 if (gc)
1385 {
1386 XPutImage (dpy, bg_pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1387
1388 XFreeGC (dpy, gc);
1389 }
1390
1391 XDestroyImage (result);
1392 }
1393# endif
1394
1395 if (!(bg_flags & BG_IS_VALID)) 1371 if (!(bg_flags & BG_IS_VALID))
1396 { 1372 {
1397 if (bg_pixmap != None) 1373 if (bg_pixmap != None)
1398 { 1374 {
1399 XFreePixmap (dpy, bg_pixmap); 1375 XFreePixmap (dpy, bg_pixmap);
… …
1411 1387
1412void 1388void
1413rxvt_term::bg_init () 1389rxvt_term::bg_init ()
1414{ 1390{
1415#ifdef ENABLE_TRANSPARENCY 1391#ifdef ENABLE_TRANSPARENCY
1392 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1393 tint.set (this, c);
1416 shade = 100; 1394 shade = 100;
1417#endif 1395#endif
1418 1396
1419 bg_flags &= ~(BG_HAS_RENDER | BG_HAS_RENDER_CONV); 1397 bg_flags &= ~(BG_HAS_RENDER | BG_HAS_RENDER_CONV);
1420#if XRENDER 1398#if XRENDER
… …
1448 tmp += (mask >> sh) * low; 1426 tmp += (mask >> sh) * low;
1449 lookup[i] = (tmp / 0xffff) << sh; 1427 lookup[i] = (tmp / 0xffff) << sh;
1450 } 1428 }
1451} 1429}
1452 1430
1453static void 1431void
1454shade_ximage (Visual *visual, XImage *ximage, int shade, const rgba &c) 1432rxvt_term::tint_ximage (Visual *visual, XImage *ximage)
1455{ 1433{
1456 int sh_r, sh_g, sh_b; 1434 int sh_r, sh_g, sh_b;
1457 uint32_t mask_r, mask_g, mask_b; 1435 uint32_t mask_r, mask_g, mask_b;
1458 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b; 1436 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1459 unsigned short low; 1437 unsigned short low;
1460 rgba high;
1461 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst; 1438 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1462 1439
1463 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return; 1440 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;
1464 1441
1465 /* for convenience */ 1442 /* for convenience */
… …
1524 break; 1501 break;
1525 default: 1502 default:
1526 return; /* we do not support this color depth */ 1503 return; /* we do not support this color depth */
1527 } 1504 }
1528 1505
1506 rgba c;
1507
1508 tint.get (c);
1509
1529 /* prepare limits for color transformation (each channel is handled separately) */ 1510 /* prepare limits for color transformation (each channel is handled separately) */
1530 if (shade > 100) 1511 if (shade > 100)
1531 { 1512 {
1532 shade = 200 - shade; 1513 c.r = c.r * (200 - shade) / 100;
1514 c.g = c.g * (200 - shade) / 100;
1515 c.b = c.b * (200 - shade) / 100;
1533 1516
1534 high.r = c.r * shade / 100;
1535 high.g = c.g * shade / 100;
1536 high.b = c.b * shade / 100;
1537
1538 low = 0xffff * (100 - shade) / 100; 1517 low = 0xffff * (shade - 100) / 100;
1539 } 1518 }
1540 else 1519 else
1541 { 1520 {
1542 high.r = c.r * shade / 100; 1521 c.r = c.r * shade / 100;
1543 high.g = c.g * shade / 100; 1522 c.g = c.g * shade / 100;
1544 high.b = c.b * shade / 100; 1523 c.b = c.b * shade / 100;
1545 1524
1546 low = 0; 1525 low = 0;
1547 } 1526 }
1548 1527
1549 /* fill our lookup tables */ 1528 /* fill our lookup tables */
1550 fill_lut (lookup_r, mask_r, sh_r, low, high.r); 1529 fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1551 fill_lut (lookup_g, mask_g, sh_g, low, high.g); 1530 fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1552 fill_lut (lookup_b, mask_b, sh_b, low, high.b); 1531 fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1553 1532
1554 /* apply table to input image (replacing colors by newly calculated ones) */ 1533 /* apply table to input image (replacing colors by newly calculated ones) */
1555 if (ximage->bits_per_pixel == 32 1534 if (ximage->bits_per_pixel == 32
1556 && (ximage->depth == 24 || ximage->depth == 32) 1535 && (ximage->depth == 24 || ximage->depth == 32)
1557 && ximage->byte_order == host_byte_order) 1536 && ximage->byte_order == host_byte_order)

Diff Legend

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