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.187 by sf-exg, Wed Dec 28 13:13:33 2011 UTC vs.
Revision 1.194 by sf-exg, Sun Jan 1 17:43:47 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)
… …
374 if (tr_flags & BG_NEEDS_TINT) 392 if (tr_flags & BG_NEEDS_TINT)
375 { 393 {
376 ShadingInfo as_shade; 394 ShadingInfo as_shade;
377 as_shade.shading = shade; 395 as_shade.shading = shade;
378 396
379 rgba c; 397 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
398 if (bg_flags & BG_TINT_SET)
380 tint.get (c); 399 tint.get (c);
381 as_shade.tintColor.red = c.r; 400 as_shade.tintColor.red = c.r;
382 as_shade.tintColor.green = c.g; 401 as_shade.tintColor.green = c.g;
383 as_shade.tintColor.blue = c.b; 402 as_shade.tintColor.blue = c.b;
384 403
385 background_tint = shading2tint32 (&as_shade); 404 background_tint = shading2tint32 (&as_shade);
… …
801 } 820 }
802 821
803#if XRENDER 822#if XRENDER
804 if (tr_flags) 823 if (tr_flags)
805 { 824 {
806 XRenderPictureAttributes pa;
807
808 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, visual); 825 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
826
809 Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa); 827 Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
810 828
811 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
812 Picture dst = XRenderCreatePicture (dpy, bg_pixmap, dst_format, 0, &pa); 829 Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
813 830
814 pa.repeat = True; 831 Picture mask = create_xrender_mask (dpy, vt, False, False);
815 Pixmap mask_pmap = XCreatePixmap (dpy, vt, 1, 1, 8);
816 XRenderPictFormat *mask_format = XRenderFindStandardFormat (dpy, PictStandardA8);
817 Picture mask = XRenderCreatePicture (dpy, mask_pmap, mask_format, CPRepeat, &pa);
818 XFreePixmap (dpy, mask_pmap);
819 832
820 XRenderColor mask_c; 833 XRenderColor mask_c;
821 834
822 mask_c.alpha = 0x8000; 835 mask_c.alpha = 0x8000;
823 mask_c.red = 0; 836 mask_c.red =
824 mask_c.green = 0; 837 mask_c.green =
825 mask_c.blue = 0; 838 mask_c.blue = 0;
826 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1); 839 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
840
827 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height); 841 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
828 842
829 XRenderFreePicture (dpy, src); 843 XRenderFreePicture (dpy, src);
830 XRenderFreePicture (dpy, dst); 844 XRenderFreePicture (dpy, dst);
831 XRenderFreePicture (dpy, mask); 845 XRenderFreePicture (dpy, mask);
… …
943 { 957 {
944 changed = true; 958 changed = true;
945 v_blurRadius = vr; 959 v_blurRadius = vr;
946 } 960 }
947 961
948 if (v_blurRadius == 0 && h_blurRadius == 0) 962 if (h_blurRadius == 0 || v_blurRadius == 0)
949 bg_flags &= ~BG_NEEDS_BLUR; 963 bg_flags &= ~BG_NEEDS_BLUR;
950 else 964 else
951 bg_flags |= BG_NEEDS_BLUR; 965 bg_flags |= BG_NEEDS_BLUR;
952 966
953 return changed; 967 return changed;
… …
959 rgba c; 973 rgba c;
960 bool has_shade = shade != 100; 974 bool has_shade = shade != 100;
961 975
962 bg_flags &= ~BG_TINT_FLAGS; 976 bg_flags &= ~BG_TINT_FLAGS;
963 977
978 if (bg_flags & BG_TINT_SET)
979 {
964 tint.get (c); 980 tint.get (c);
965
966 if (!has_shade 981 if (!has_shade
967 && (c.r <= 0x00ff || c.r >= 0xff00) 982 && (c.r <= 0x00ff || c.r >= 0xff00)
968 && (c.g <= 0x00ff || c.g >= 0xff00) 983 && (c.g <= 0x00ff || c.g >= 0xff00)
969 && (c.b <= 0x00ff || c.b >= 0xff00)) 984 && (c.b <= 0x00ff || c.b >= 0xff00))
970 bg_flags |= BG_TINT_BITAND; 985 bg_flags |= BG_TINT_BITAND;
986 }
971 987
972 if (has_shade 988 if (has_shade || (bg_flags & BG_TINT_SET))
973 || c.r < 0xff00
974 || c.g < 0xff00
975 || c.b < 0xff00)
976 bg_flags |= BG_NEEDS_TINT; 989 bg_flags |= BG_NEEDS_TINT;
977} 990}
978 991
979bool 992bool
980rxvt_term::bg_set_tint (rxvt_color &new_tint) 993rxvt_term::bg_set_tint (rxvt_color &new_tint)
981{ 994{
982 if (tint != new_tint) 995 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
983 { 996 {
984 tint = new_tint; 997 tint = new_tint;
998 bg_flags |= BG_TINT_SET;
985 set_tint_shade_flags (); 999 set_tint_shade_flags ();
986 return true; 1000 return true;
987 } 1001 }
988 1002
989 return false; 1003 return false;
… …
1041 1055
1042 int size = max (h_blurRadius, v_blurRadius) * 2 + 1; 1056 int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1043 double *kernel = (double *)malloc (size * sizeof (double)); 1057 double *kernel = (double *)malloc (size * sizeof (double));
1044 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 1058 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1045 1059
1046 XRenderPictureAttributes pa;
1047 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 1060 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1048 1061
1049 Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 1062 Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1050 Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 1063 Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1051 1064
1052 if (kernel && params) 1065 if (kernel && params)
1053 { 1066 {
1054 if (h_blurRadius)
1055 {
1056 size = h_blurRadius * 2 + 1; 1067 size = h_blurRadius * 2 + 1;
1057 get_gaussian_kernel (h_blurRadius, size, kernel, params); 1068 get_gaussian_kernel (h_blurRadius, size, kernel, params);
1058 1069
1059 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 1070 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1060 XRenderComposite (dpy, 1071 XRenderComposite (dpy,
1061 PictOpSrc, 1072 PictOpSrc,
1062 src, 1073 src,
1063 None, 1074 None,
1064 dst, 1075 dst,
1065 0, 0, 1076 0, 0,
1066 0, 0, 1077 0, 0,
1067 0, 0, 1078 0, 0,
1068 width, height); 1079 width, height);
1069 }
1070 1080
1071 if (v_blurRadius)
1072 {
1073 size = v_blurRadius * 2 + 1; 1081 size = v_blurRadius * 2 + 1;
1074 get_gaussian_kernel (v_blurRadius, size, kernel, params); 1082 get_gaussian_kernel (v_blurRadius, size, kernel, params);
1075 ::swap (params[0], params[1]); 1083 ::swap (params[0], params[1]);
1076 1084
1077 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 1085 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1078 XRenderComposite (dpy, 1086 XRenderComposite (dpy,
1079 PictOpSrc, 1087 PictOpSrc,
1080 src, 1088 src,
1081 None, 1089 None,
1082 dst, 1090 dst,
1083 0, 0, 1091 0, 0,
1084 0, 0, 1092 0, 0,
1085 0, 0, 1093 0, 0,
1086 width, height); 1094 width, height);
1087 }
1088 1095
1089 ret = true; 1096 ret = true;
1090 } 1097 }
1091 1098
1092 free (kernel); 1099 free (kernel);
… …
1122 } 1129 }
1123 } 1130 }
1124# if XRENDER 1131# if XRENDER
1125 else if (bg_flags & BG_HAS_RENDER) 1132 else if (bg_flags & BG_HAS_RENDER)
1126 { 1133 {
1127 rgba c; 1134 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1128 1135
1136 if (bg_flags & BG_TINT_SET)
1129 tint.get (c); 1137 tint.get (c);
1130 1138
1131 if (shade <= 100) 1139 if (shade <= 100)
1132 { 1140 {
1133 c.r = c.r * shade / 100; 1141 c.r = c.r * shade / 100;
1134 c.g = c.g * shade / 100; 1142 c.g = c.g * shade / 100;
… …
1139 c.r = c.r * (200 - shade) / 100; 1147 c.r = c.r * (200 - shade) / 100;
1140 c.g = c.g * (200 - shade) / 100; 1148 c.g = c.g * (200 - shade) / 100;
1141 c.b = c.b * (200 - shade) / 100; 1149 c.b = c.b * (200 - shade) / 100;
1142 } 1150 }
1143 1151
1144 XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1145 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 1152 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1146 XRenderPictureAttributes pa;
1147 1153
1148 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 1154 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1149 1155
1150 pa.repeat = True; 1156 Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1151 1157
1152 Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32); 1158 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 1159
1161 XRenderColor mask_c; 1160 XRenderColor mask_c;
1162 1161
1163 mask_c.alpha = 0xffff; 1162 mask_c.alpha = 0xffff;
1164 mask_c.red = 1163 mask_c.red =
… …
1169 mask_c.alpha = 0; 1168 mask_c.alpha = 0;
1170 mask_c.red = 0xffff - c.r; 1169 mask_c.red = 0xffff - c.r;
1171 mask_c.green = 0xffff - c.g; 1170 mask_c.green = 0xffff - c.g;
1172 mask_c.blue = 0xffff - c.b; 1171 mask_c.blue = 0xffff - c.b;
1173 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1); 1172 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
1173
1174 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height); 1174 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1175 1175
1176 if (shade > 100) 1176 if (shade > 100)
1177 { 1177 {
1178 mask_c.red = mask_c.green = mask_c.blue = 0xffff * (shade - 100) / 100;
1179 mask_c.alpha = 0; 1178 mask_c.alpha = 0;
1179 mask_c.red =
1180 mask_c.green =
1181 mask_c.blue = 0xffff * (shade - 100) / 100;
1180 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1); 1182 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1181 1183
1182 XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height); 1184 XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1183 } 1185 }
1184 1186
… …
1247#if XRENDER 1249#if XRENDER
1248 if (bg_flags & BG_HAS_RENDER) 1250 if (bg_flags & BG_HAS_RENDER)
1249 { 1251 {
1250 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth); 1252 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1251 1253
1252 XRenderPictureAttributes pa;
1253
1254 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen)); 1254 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1255 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa); 1255 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1256 1256
1257 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual); 1257 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1258 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa); 1258 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1259 1259
1260 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height); 1260 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
1261 1261
1262 XRenderFreePicture (dpy, src); 1262 XRenderFreePicture (dpy, src);
1263 XRenderFreePicture (dpy, dst); 1263 XRenderFreePicture (dpy, dst);
… …
1293 1293
1294 if (gc) 1294 if (gc)
1295 { 1295 {
1296 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height); 1296 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1297 result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS); 1297 result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS);
1298 XFreeGC (dpy, gc);
1299 1298
1300 if (!(bg_flags & BG_CLIENT_RENDER)) 1299 if (!(bg_flags & BG_CLIENT_RENDER))
1301 { 1300 {
1302 if (bg_flags & BG_NEEDS_BLUR) 1301 if (bg_flags & BG_NEEDS_BLUR)
1303 { 1302 {
… …
1307 if (bg_flags & BG_NEEDS_TINT) 1306 if (bg_flags & BG_NEEDS_TINT)
1308 { 1307 {
1309 if (tint_pixmap (bg_pixmap, visual, window_width, window_height)) 1308 if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1310 result &= ~BG_NEEDS_TINT; 1309 result &= ~BG_NEEDS_TINT;
1311 } 1310 }
1311# ifndef HAVE_AFTERIMAGE
1312 if (result & BG_NEEDS_TINT)
1313 {
1314 XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1315 if (ximage)
1316 {
1317 /* our own client-side tinting */
1318 tint_ximage (DefaultVisual (dpy, display->screen), ximage);
1319
1320 XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
1321 XDestroyImage (ximage);
1322 }
1323 }
1324# endif
1312 } /* server side rendering completed */ 1325 } /* server side rendering completed */
1326
1327 XFreeGC (dpy, gc);
1313 } 1328 }
1314 1329
1315 if (recoded_root_pmap != root_pixmap) 1330 if (recoded_root_pmap != root_pixmap)
1316 XFreePixmap (dpy, recoded_root_pmap); 1331 XFreePixmap (dpy, recoded_root_pmap);
1317 1332
… …
1353 if (render_image (tr_flags)) 1368 if (render_image (tr_flags))
1354 bg_flags |= BG_IS_VALID; 1369 bg_flags |= BG_IS_VALID;
1355 } 1370 }
1356# endif 1371# endif
1357 1372
1358# if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1359 XImage *result = NULL;
1360
1361 if (tr_flags & BG_NEEDS_TINT)
1362 {
1363 result = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1364 }
1365
1366 if (result)
1367 {
1368 /* our own client-side tinting */
1369 //if (tr_flags & BG_NEEDS_TINT)
1370 if (1)
1371 tint_ximage (DefaultVisual (dpy, display->screen), result);
1372
1373 GC gc = XCreateGC (dpy, vt, 0UL, NULL);
1374
1375 if (gc)
1376 {
1377 XPutImage (dpy, bg_pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1378
1379 XFreeGC (dpy, gc);
1380 }
1381
1382 XDestroyImage (result);
1383 }
1384# endif
1385
1386 if (!(bg_flags & BG_IS_VALID)) 1373 if (!(bg_flags & BG_IS_VALID))
1387 { 1374 {
1388 if (bg_pixmap != None) 1375 if (bg_pixmap != None)
1389 { 1376 {
1390 XFreePixmap (dpy, bg_pixmap); 1377 XFreePixmap (dpy, bg_pixmap);
… …
1402 1389
1403void 1390void
1404rxvt_term::bg_init () 1391rxvt_term::bg_init ()
1405{ 1392{
1406#ifdef ENABLE_TRANSPARENCY 1393#ifdef ENABLE_TRANSPARENCY
1407 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1408 tint.set (this, c);
1409 shade = 100; 1394 shade = 100;
1410#endif 1395#endif
1411 1396
1412 bg_flags &= ~(BG_HAS_RENDER | BG_HAS_RENDER_CONV); 1397 bg_flags &= ~(BG_HAS_RENDER | BG_HAS_RENDER_CONV);
1413#if XRENDER 1398#if XRENDER
… …
1516 break; 1501 break;
1517 default: 1502 default:
1518 return; /* we do not support this color depth */ 1503 return; /* we do not support this color depth */
1519 } 1504 }
1520 1505
1521 rgba c; 1506 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1522 1507
1508 if (bg_flags & BG_TINT_SET)
1523 tint.get (c); 1509 tint.get (c);
1524 1510
1525 /* prepare limits for color transformation (each channel is handled separately) */ 1511 /* prepare limits for color transformation (each channel is handled separately) */
1526 if (shade > 100) 1512 if (shade > 100)
1527 { 1513 {
1528 c.r = c.r * (200 - shade) / 100; 1514 c.r = c.r * (200 - shade) / 100;

Diff Legend

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