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.184 by sf-exg, Sun Dec 25 17:07:00 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
… …
1353 if (render_image (tr_flags)) 1366 if (render_image (tr_flags))
1354 bg_flags |= BG_IS_VALID; 1367 bg_flags |= BG_IS_VALID;
1355 } 1368 }
1356# endif 1369# endif
1357 1370
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)) 1371 if (!(bg_flags & BG_IS_VALID))
1387 { 1372 {
1388 if (bg_pixmap != None) 1373 if (bg_pixmap != None)
1389 { 1374 {
1390 XFreePixmap (dpy, bg_pixmap); 1375 XFreePixmap (dpy, bg_pixmap);
… …
1402 1387
1403void 1388void
1404rxvt_term::bg_init () 1389rxvt_term::bg_init ()
1405{ 1390{
1406#ifdef ENABLE_TRANSPARENCY 1391#ifdef ENABLE_TRANSPARENCY
1392 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1393 tint.set (this, c);
1407 shade = 100; 1394 shade = 100;
1408#endif 1395#endif
1409 1396
1410 bg_flags &= ~(BG_HAS_RENDER | BG_HAS_RENDER_CONV); 1397 bg_flags &= ~(BG_HAS_RENDER | BG_HAS_RENDER_CONV);
1411#if XRENDER 1398#if XRENDER
… …
1514 break; 1501 break;
1515 default: 1502 default:
1516 return; /* we do not support this color depth */ 1503 return; /* we do not support this color depth */
1517 } 1504 }
1518 1505
1519 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC); 1506 rgba c;
1520 1507
1521 if (bg_flags & BG_TINT_SET)
1522 tint.get (c); 1508 tint.get (c);
1523 1509
1524 /* prepare limits for color transformation (each channel is handled separately) */ 1510 /* prepare limits for color transformation (each channel is handled separately) */
1525 if (shade > 100) 1511 if (shade > 100)
1526 { 1512 {
1527 c.r = c.r * (200 - shade) / 100; 1513 c.r = c.r * (200 - shade) / 100;

Diff Legend

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