[ViewVC] Diff of: cvs/rxvt-unicode/src/background.C

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.90 by sf-exg, Mon Oct 18 16:02:48 2010 UTC vs.
Revision 1.104 by sf-exg, Sun Oct 31 17:44:39 2010 UTC

…		…
428	{	428	{
429	flags = new_flags;	429	flags = new_flags;
430	changed++;	430	changed++;
431	}	431	}
432		432
433	//fprintf (stderr, "flags = %lX, scale = %ux%u, align=%+d%+d\n",
434	// flags, h_scale, v_scale, h_align, v_align);
435	return (changed > 0);	433	return (changed > 0);
436	}	434	}
437		435
438	void	436	void
439	bgPixmap_t::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y)	437	bgPixmap_t::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y)
…		…
529		527
530	int x = 0;	528	int x = 0;
531	int y = 0;	529	int y = 0;
532	int w = 0;	530	int w = 0;
533	int h = 0;	531	int h = 0;
534
535	TIMING_TEST_START (asim);
536		532
537	if (original_asim)	533	if (original_asim)
538	get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);	534	get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
539		535
540	if (!original_asim	536	if (!original_asim
…		…
657	}	653	}
658		654
659	free (layers);	655	free (layers);
660	}	656	}
661	}	657	}
662	TIMING_TEST_PRINT_RESULT (asim);
663		658
664	bool ret = false;	659	bool ret = false;
665		660
666	if (result)	661	if (result)
667	{	662	{
…		…
713		708
714	if (result != background && result != original_asim)	709	if (result != background && result != original_asim)
715	destroy_asimage (&result);	710	destroy_asimage (&result);
716		711
717	XFreeGC (target->dpy, gc);	712	XFreeGC (target->dpy, gc);
718	TIMING_TEST_PRINT_RESULT (asim);
719		713
720	ret = true;	714	ret = true;
721	}	715	}
722		716
723	if (background)	717	if (background)
…		…
735	return false;	729	return false;
736		730
737	if (!pixbuf)	731	if (!pixbuf)
738	return false;	732	return false;
739		733
740	#if !XFT	734	#if !XRENDER
741	if (background_flags)	735	if (background_flags)
742	return false;	736	return false;
743	#endif	737	#endif
744		738
745	GdkPixbuf *result;	739	GdkPixbuf *result;
…		…
862	dst_width, dst_height,	856	dst_width, dst_height,
863	XLIB_RGB_DITHER_NONE,	857	XLIB_RGB_DITHER_NONE,
864	0, 0);	858	0, 0);
865	}	859	}
866		860
867	#if XFT	861	#if XRENDER
868	if (background_flags)	862	if (background_flags)
869	{	863	{
870	Display *dpy = target->dpy;	864	Display *dpy = target->dpy;
871	XRenderPictureAttributes pa;	865	XRenderPictureAttributes pa;
872		866
873	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, target->display->screen));	867	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, target->visual);
874	Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa);	868	Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa);
875		869
876	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, target->visual);	870	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, target->visual);
877	Picture dst = XRenderCreatePicture (dpy, pixmap, dst_format, 0, &pa);	871	Picture dst = XRenderCreatePicture (dpy, pixmap, dst_format, 0, &pa);
878		872
…		…
1006	if (v_blurRadius == 0 && h_blurRadius == 0)	1000	if (v_blurRadius == 0 && h_blurRadius == 0)
1007	flags &= ~blurNeeded;	1001	flags &= ~blurNeeded;
1008	else	1002	else
1009	flags \|= blurNeeded;	1003	flags \|= blurNeeded;
1010		1004
1011	#if XFT	1005	#if XRENDER
1012	XFilters *filters = XRenderQueryFilters (target->dpy, target->display->root);	1006	XFilters *filters = XRenderQueryFilters (target->dpy, target->vt);
1013	if (filters)	1007	if (filters)
1014	{	1008	{
1015	for (int i = 0; i < filters->nfilter; i++)	1009	for (int i = 0; i < filters->nfilter; i++)
1016	if (!strcmp (filters->filter[i], FilterConvolution))	1010	if (!strcmp (filters->filter[i], FilterConvolution))
1017	flags \|= bgPixmap_t::blurServerSide;	1011	flags \|= bgPixmap_t::blurServerSide;
…		…
1056	{	1050	{
1057	if (flags & bgPixmap_t::tintWholesome)	1051	if (flags & bgPixmap_t::tintWholesome)
1058	flags \|= bgPixmap_t::tintServerSide;	1052	flags \|= bgPixmap_t::tintServerSide;
1059	else	1053	else
1060	{	1054	{
1061	#if XFT	1055	#if XRENDER
1062	flags \|= bgPixmap_t::tintServerSide;	1056	flags \|= bgPixmap_t::tintServerSide;
1063	#endif	1057	#endif
1064	}	1058	}
1065	}	1059	}
1066		1060
…		…
1113	}	1107	}
1114		1108
1115	return false;	1109	return false;
1116	}	1110	}
1117		1111
1118	#if XFT	1112	#if XRENDER
1119	static void	1113	static void
1120	get_gaussian_kernel (int radius, int width, double kernel, XFixed params)	1114	get_gaussian_kernel (int radius, int width, double kernel, XFixed params)
1121	{	1115	{
1122	double sigma = radius / 2.0;	1116	double sigma = radius / 2.0;
1123	double scale = sqrt (2.0 * M_PI) * sigma;	1117	double scale = sqrt (2.0 * M_PI) * sigma;
…		…
1140		1134
1141	bool	1135	bool
1142	bgPixmap_t::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	1136	bgPixmap_t::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1143	{	1137	{
1144	bool ret = false;	1138	bool ret = false;
1145	#if XFT	1139	#if XRENDER
1146	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;	1140	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1147	double kernel = (double )malloc (size * sizeof (double));	1141	double kernel = (double )malloc (size * sizeof (double));
1148	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));	1142	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));
1149		1143
1150	Display *dpy = target->dpy;	1144	Display *dpy = target->dpy;
1151	XRenderPictureAttributes pa;	1145	XRenderPictureAttributes pa;
1152	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, target->visual);	1146	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1153		1147
1154	Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1148	Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);
1155	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1149	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);
1156		1150
1157	if (kernel && params && src && dst)	1151	if (kernel && params && src && dst)
…		…
1227	XFreeGC (dpy, gc);	1221	XFreeGC (dpy, gc);
1228	}	1222	}
1229	}	1223	}
1230	else	1224	else
1231	{	1225	{
1232	# if XFT	1226	# if XRENDER
1233	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);	1227	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1234		1228
1235	if (flags & tintSet)	1229	if (flags & tintSet)
1236	tint.get (c);	1230	tint.get (c);
1237		1231
…		…
1283	}	1277	}
1284		1278
1285	XRenderFreePicture (dpy, mask_pic);	1279	XRenderFreePicture (dpy, mask_pic);
1286	XRenderFreePicture (dpy, overlay_pic);	1280	XRenderFreePicture (dpy, overlay_pic);
1287	XRenderFreePicture (dpy, back_pic);	1281	XRenderFreePicture (dpy, back_pic);
1288	# if DO_TIMING_TEST
1289	XSync (dpy, False);
1290	# endif
1291	# endif	1282	# endif
1292	}	1283	}
1293		1284
1294	return ret;	1285	return ret;
1295	}	1286	}
1296		1287
1297	/* make_transparency_pixmap()	1288	/* make_transparency_pixmap()
1298	* Builds a pixmap sized the same as terminal window, with depth same as the root window	1289	* Builds a pixmap of the same size as the terminal window that contains
1299	* that pixmap contains tiled portion of the root pixmap that is supposed to be covered by	1290	* the tiled portion of the root pixmap that is supposed to be covered by
1300	* our window.	1291	* our window.
1301	*/	1292	*/
1302	unsigned long	1293	unsigned long
1303	bgPixmap_t::make_transparency_pixmap ()	1294	bgPixmap_t::make_transparency_pixmap ()
1304	{	1295	{
…		…
1308	return 0;	1299	return 0;
1309		1300
1310	/* root dimensions may change from call to call - but Display structure should	1301	/* root dimensions may change from call to call - but Display structure should
1311	* be always up-to-date, so let's use it :	1302	* be always up-to-date, so let's use it :
1312	*/	1303	*/
1313	Window root = target->display->root;
1314	int screen = target->display->screen;	1304	int screen = target->display->screen;
1315	Display *dpy = target->dpy;	1305	Display *dpy = target->dpy;
		1306	int root_depth = DefaultDepth (dpy, screen);
1316	int root_width = DisplayWidth (dpy, screen);	1307	int root_width = DisplayWidth (dpy, screen);
1317	int root_height = DisplayHeight (dpy, screen);	1308	int root_height = DisplayHeight (dpy, screen);
1318	unsigned int root_pmap_width, root_pmap_height;	1309	unsigned int root_pmap_width, root_pmap_height;
1319	int window_width = target->szHint.width;	1310	int window_width = target->szHint.width;
1320	int window_height = target->szHint.height;	1311	int window_height = target->szHint.height;
1321	int sx, sy;	1312	int sx, sy;
1322	XGCValues gcv;	1313	XGCValues gcv;
1323	GC gc;	1314	GC gc;
1324		1315
1325	TIMING_TEST_START (tp);
1326	target->get_window_origin (sx, sy);	1316	target->get_window_origin (sx, sy);
1327		1317
1328	/* check if we are outside of the visible part of the virtual screen : */	1318	/* check if we are outside of the visible part of the virtual screen : */
1329	if (sx + window_width <= 0 \|\| sy + window_height <= 0	1319	if (sx + window_width <= 0 \|\| sy + window_height <= 0
1330	\|\| sx >= root_width \|\| sy >= root_height)	1320	\|\| sx >= root_width \|\| sy >= root_height)
1331	return 0;	1321	return 0;
1332		1322
		1323	// validate root pixmap and get its size
1333	if (root_pixmap != None)	1324	if (root_pixmap != None)
1334	{	1325	{
1335	/* we want to validate the pixmap and get its size at the same time : */	1326	Window wdummy;
1336	int junk;	1327	int idummy;
1337	unsigned int ujunk;	1328	unsigned int udummy;
1338	/* root pixmap may be bad - allow a error */	1329
1339	target->allowedxerror = -1;	1330	target->allowedxerror = -1;
1340		1331
1341	if (!XGetGeometry (dpy, root_pixmap, &root, &junk, &junk, &root_pmap_width, &root_pmap_height, &ujunk, &ujunk))	1332	if (!XGetGeometry (dpy, root_pixmap, &wdummy, &idummy, &idummy, &root_pmap_width, &root_pmap_height, &udummy, &udummy))
1342	root_pixmap = None;	1333	root_pixmap = None;
1343		1334
1344	target->allowedxerror = 0;	1335	target->allowedxerror = 0;
		1336	}
		1337
		1338	Pixmap recoded_root_pmap = root_pixmap;
		1339
		1340	if (root_pixmap != None && root_depth != target->depth)
		1341	{
		1342	#if XRENDER
		1343	XRenderPictureAttributes pa;
		1344
		1345	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
		1346	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa);
		1347
		1348	recoded_root_pmap = XCreatePixmap (dpy, target->vt, root_pmap_width, root_pmap_height, target->depth);
		1349	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, target->visual);
		1350	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa);
		1351
		1352	if (src && dst)
		1353	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
		1354	else
		1355	{
		1356	XFreePixmap (dpy, recoded_root_pmap);
		1357	root_pixmap = None;
		1358	}
		1359
		1360	XRenderFreePicture (dpy, src);
		1361	XRenderFreePicture (dpy, dst);
		1362	#else
		1363	root_pixmap = None;
		1364	#endif
1345	}	1365	}
1346		1366
1347	if (root_pixmap == None)	1367	if (root_pixmap == None)
1348	return 0;	1368	return 0;
1349		1369
1350	Pixmap tiled_root_pmap = XCreatePixmap (dpy, root, window_width, window_height, root_depth);	1370	Pixmap tiled_root_pmap = XCreatePixmap (dpy, target->vt, window_width, window_height, target->depth);
1351		1371
1352	if (tiled_root_pmap == None) /* something really bad happened - abort */	1372	if (tiled_root_pmap == None) /* something really bad happened - abort */
1353	return 0;	1373	return 0;
1354		1374
1355	/* straightforward pixmap copy */	1375	/* straightforward pixmap copy */
1356	gcv.tile = root_pixmap;	1376	gcv.tile = recoded_root_pmap;
1357	gcv.fill_style = FillTiled;	1377	gcv.fill_style = FillTiled;
1358		1378
1359	while (sx < 0) sx += (int)root_width;	1379	while (sx < 0) sx += (int)root_width;
1360	while (sy < 0) sy += (int)root_height;	1380	while (sy < 0) sy += (int)root_height;
1361		1381
1362	gcv.ts_x_origin = -sx;	1382	gcv.ts_x_origin = -sx;
1363	gcv.ts_y_origin = -sy;	1383	gcv.ts_y_origin = -sy;
1364	gc = XCreateGC (dpy, root, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcv);	1384	gc = XCreateGC (dpy, target->vt, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcv);
1365		1385
1366	if (gc)	1386	if (gc)
1367	{	1387	{
1368	XFillRectangle (dpy, tiled_root_pmap, gc, 0, 0, window_width, window_height);	1388	XFillRectangle (dpy, tiled_root_pmap, gc, 0, 0, window_width, window_height);
1369	result \|= transpPmapTiled;	1389	result \|= transpPmapTiled;
1370	XFreeGC (dpy, gc);	1390	XFreeGC (dpy, gc);
1371	}	1391	}
1372	TIMING_TEST_PRINT_RESULT (tp);
1373		1392
1374	if (tiled_root_pmap != None)	1393	if (tiled_root_pmap != None)
1375	{	1394	{
1376	if (!need_client_side_rendering ())	1395	if (!need_client_side_rendering ())
1377	{	1396	{
1378	if (flags & (blurNeeded \| blurServerSide))	1397	if (flags & (blurNeeded \| blurServerSide))
1379	{	1398	{
1380	if (blur_pixmap (tiled_root_pmap, DefaultVisual (dpy, screen), window_width, window_height))	1399	if (blur_pixmap (tiled_root_pmap, target->visual, window_width, window_height))
1381	result \|= transpPmapBlurred;	1400	result \|= transpPmapBlurred;
1382	}	1401	}
1383	if (flags & (tintNeeded \| tintServerSide))	1402	if (flags & (tintNeeded \| tintServerSide))
1384	{	1403	{
1385	if (tint_pixmap (tiled_root_pmap, DefaultVisual (dpy, screen), window_width, window_height))	1404	if (tint_pixmap (tiled_root_pmap, target->visual, window_width, window_height))
1386	result \|= transpPmapTinted;	1405	result \|= transpPmapTinted;
1387	}	1406	}
1388	} /* server side rendering completed */	1407	} /* server side rendering completed */
1389		1408
1390	if (pixmap)	1409	if (pixmap)
1391	XFreePixmap (dpy, pixmap);	1410	XFreePixmap (dpy, pixmap);
1392		1411
1393	pixmap = tiled_root_pmap;	1412	pixmap = tiled_root_pmap;
1394	pmap_width = window_width;	1413	pmap_width = window_width;
1395	pmap_height = window_height;	1414	pmap_height = window_height;
1396	pmap_depth = root_depth;	1415	pmap_depth = target->depth;
1397	}	1416	}
1398		1417
1399	TIMING_TEST_PRINT_RESULT (tp);	1418	if (recoded_root_pmap != root_pixmap)
		1419	XFreePixmap (dpy, recoded_root_pmap);
1400		1420
1401	return result;	1421	return result;
1402	}	1422	}
1403		1423
1404	bool	1424	void
1405	bgPixmap_t::set_root_pixmap ()	1425	bgPixmap_t::set_root_pixmap ()
1406	{	1426	{
1407	Pixmap new_root_pixmap = target->get_pixmap_property (XA_XROOTPMAP_ID);	1427	Pixmap new_root_pixmap = target->get_pixmap_property (XA_XROOTPMAP_ID);
1408	if (new_root_pixmap == None)	1428	if (new_root_pixmap == None)
1409	new_root_pixmap = target->get_pixmap_property (XA_ESETROOT_PMAP_ID);	1429	new_root_pixmap = target->get_pixmap_property (XA_ESETROOT_PMAP_ID);
1410		1430
1411	if (new_root_pixmap != root_pixmap)
1412	{
1413	root_pixmap = new_root_pixmap;	1431	root_pixmap = new_root_pixmap;
1414	return true;
1415	}
1416
1417	return false;
1418	}	1432	}
1419	# endif /* ENABLE_TRANSPARENCY */	1433	# endif /* ENABLE_TRANSPARENCY */
1420		1434
1421	# ifndef HAVE_AFTERIMAGE	1435	# ifndef HAVE_AFTERIMAGE
1422	static void ShadeXImage(rxvt_term term, XImage srcImage, int shade, int rm, int gm, int bm);	1436	static void ShadeXImage(Visual visual, XImage srcImage, int shade, int rm, int gm, int bm);
1423	# endif	1437	# endif
1424		1438
1425	bool	1439	bool
1426	bgPixmap_t::render ()	1440	bgPixmap_t::render ()
1427	{	1441	{
1428	unsigned long background_flags = 0;	1442	unsigned long background_flags = 0;
1429		1443
1430	if (target == NULL)	1444	if (target == NULL)
1431	return false;	1445	return false;
1432
1433	TIMING_TEST_START (tp);
1434		1446
1435	invalidate ();	1447	invalidate ();
1436	# ifdef ENABLE_TRANSPARENCY	1448	# ifdef ENABLE_TRANSPARENCY
1437	if (flags & isTransparent)	1449	if (flags & isTransparent)
1438	{	1450	{
1439	/* we need to re-generate transparency pixmap in that case ! */	1451	/* we need to re-generate transparency pixmap in that case ! */
1440	background_flags = make_transparency_pixmap ();	1452	background_flags = make_transparency_pixmap ();
1441	if (background_flags == 0)	1453	if (background_flags == 0)
1442	return false;	1454	return false;
1443	else if ((background_flags & transpTransformations) == (flags & transpTransformations)	1455	else if ((background_flags & transpTransformations) == (flags & transpTransformations))
1444	&& pmap_depth == target->depth)
1445	flags = flags & ~isInvalid;	1456	flags = flags & ~isInvalid;
1446	}	1457	}
1447	# endif	1458	# endif
1448		1459
1449	# ifdef BG_IMAGE_FROM_FILE	1460	# ifdef BG_IMAGE_FROM_FILE
…		…
1462	result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap);	1473	result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap);
1463	}	1474	}
1464		1475
1465	if (result)	1476	if (result)
1466	{	1477	{
1467	# if !defined(HAVE_AFTERIMAGE) && !XFT	1478	# if !defined(HAVE_AFTERIMAGE) && !XRENDER
1468	/* our own client-side tinting */	1479	/* our own client-side tinting */
1469	/* ATTENTION: We ASSUME that XFT will let us do all the tinting necessary server-side.
1470	This may need to be changed in need_client_side_rendering() logic is altered !!! */
1471	if (!(background_flags & transpPmapTinted) && (flags & tintNeeded))	1480	if (!(background_flags & transpPmapTinted) && (flags & tintNeeded))
1472	{	1481	{
1473	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);	1482	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1474	if (flags & tintSet)	1483	if (flags & tintSet)
1475	tint.get (c);	1484	tint.get (c);
1476	ShadeXImage (target, result, shade, c.r, c.g, c.b);	1485	ShadeXImage (DefaultVisual (target->dpy, target->display->screen), result, shade, c.r, c.g, c.b);
1477	}	1486	}
1478	# endif	1487	# endif
1479		1488
1480	GC gc = XCreateGC (target->dpy, target->vt, 0UL, NULL);	1489	GC gc = XCreateGC (target->dpy, target->vt, 0UL, NULL);
1481		1490
1482	if (gc)	1491	if (gc)
1483	{	1492	{
1484	if (/pmap_depth != target->depth &&/ pixmap != None)
1485	{
1486	XFreePixmap (target->dpy, pixmap);
1487	pixmap = None;
1488	}
1489
1490	if (pixmap == None)
1491	{
1492	pixmap = XCreatePixmap (target->dpy, target->vt, result->width, result->height, target->depth);
1493	pmap_width = result->width;
1494	pmap_height = result->height;
1495	pmap_depth = target->depth;
1496	}
1497
1498	if (pmap_depth != result->depth)
1499	{
1500	/* Bad Match error will ensue ! stupid X !!!! */
1501	if (result->depth == 24 && pmap_depth == 32)
1502	result->depth = 32;
1503	else if (result->depth == 32 && pmap_depth == 24)
1504	result->depth = 24;
1505	else
1506	{
1507	/* TODO: implement image recoding */
1508	}
1509	}
1510
1511	if (pmap_depth == result->depth)
1512	XPutImage (target->dpy, pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);	1493	XPutImage (target->dpy, pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1513		1494
1514	XFreeGC (target->dpy, gc);	1495	XFreeGC (target->dpy, gc);
1515	flags = flags & ~isInvalid;	1496	flags = flags & ~isInvalid;
1516	}	1497	}
1517		1498
…		…
1527	}	1508	}
1528	}	1509	}
1529		1510
1530	apply ();	1511	apply ();
1531		1512
1532	XSync (target->dpy, False);
1533	valid_since = ev::now ();	1513	valid_since = ev::now ();
1534
1535	TIMING_TEST_PRINT_RESULT (tp);
1536		1514
1537	return true;	1515	return true;
1538	}	1516	}
1539		1517
1540	bool	1518	bool
…		…
1542	{	1520	{
1543	if (new_target)	1521	if (new_target)
1544	if (target != new_target)	1522	if (target != new_target)
1545	{	1523	{
1546	target = new_target;	1524	target = new_target;
1547	# ifdef ENABLE_TRANSPARENCY
1548	root_depth = DefaultDepthOfScreen (ScreenOfDisplay (target->dpy, target->display->screen));
1549	# endif
1550	return true;	1525	return true;
1551	}	1526	}
1552		1527
1553	return false;	1528	return false;
1554	}	1529	}
…		…
1556	void	1531	void
1557	bgPixmap_t::apply ()	1532	bgPixmap_t::apply ()
1558	{	1533	{
1559	if (target)	1534	if (target)
1560	{	1535	{
1561	flags &= ~isVtOrigin;
1562
1563	if (pixmap != None)	1536	if (pixmap != None)
1564	{	1537	{
1565	/* set target's background to pixmap */	1538	/* set target's background to pixmap */
1566	# ifdef ENABLE_TRANSPARENCY	1539	# ifdef ENABLE_TRANSPARENCY
1567	if (flags & isTransparent)	1540	if (flags & isTransparent)
…		…
1573	XSetWindowBackgroundPixmap (target->dpy, target->scrollBar.win, ParentRelative);	1546	XSetWindowBackgroundPixmap (target->dpy, target->scrollBar.win, ParentRelative);
1574	}	1547	}
1575	else	1548	else
1576	# endif	1549	# endif
1577	{	1550	{
1578	flags \|= isVtOrigin;
1579	/* force old pixmap dereference in case it was transparent before :*/	1551	/* force old pixmap dereference in case it was transparent before :*/
1580	XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);	1552	XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
1581	XSetWindowBackgroundPixmap (target->dpy, target->vt, pixmap);	1553	XSetWindowBackgroundPixmap (target->dpy, target->vt, pixmap);
1582	/* do we also need to set scrollbar's background here ? */	1554	/* do we also need to set scrollbar's background here ? */
1583		1555
…		…
1610	}	1582	}
1611	}	1583	}
1612		1584
1613	#endif /* HAVE_BG_PIXMAP */	1585	#endif /* HAVE_BG_PIXMAP */
1614		1586
1615	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) && !XFT	1587	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) && !XRENDER
1616	/* taken from aterm-0.4.2 */	1588	/* taken from aterm-0.4.2 */
1617		1589
1618	typedef uint32_t RUINT32T;
1619
1620	static void	1590	static void
1621	ShadeXImage(rxvt_term term, XImage srcImage, int shade, int rm, int gm, int bm)	1591	ShadeXImage(Visual visual, XImage srcImage, int shade, int rm, int gm, int bm)
1622	{	1592	{
1623	int sh_r, sh_g, sh_b;	1593	int sh_r, sh_g, sh_b;
1624	RUINT32T mask_r, mask_g, mask_b;	1594	uint32_t mask_r, mask_g, mask_b;
1625	RUINT32T lookup, lookup_r, lookup_g, lookup_b;	1595	uint32_t lookup, lookup_r, lookup_g, lookup_b;
1626	unsigned int lower_lim_r, lower_lim_g, lower_lim_b;	1596	unsigned int lower_lim_r, lower_lim_g, lower_lim_b;
1627	unsigned int upper_lim_r, upper_lim_g, upper_lim_b;	1597	unsigned int upper_lim_r, upper_lim_g, upper_lim_b;
1628	int i;	1598	int i;
1629		1599	int host_byte_order = byteorder.big_endian () ? MSBFirst : LSBFirst;
1630	Visual *visual = term->visual;
1631		1600
1632	if (visual->c_class != TrueColor \|\| srcImage->format != ZPixmap) return;	1601	if (visual->c_class != TrueColor \|\| srcImage->format != ZPixmap) return;
1633		1602
1634	/* for convenience */	1603	/* for convenience */
1635	mask_r = visual->red_mask;	1604	mask_r = visual->red_mask;
1636	mask_g = visual->green_mask;	1605	mask_g = visual->green_mask;
1637	mask_b = visual->blue_mask;	1606	mask_b = visual->blue_mask;
1638		1607
1639	/* boring lookup table pre-initialization */	1608	/* boring lookup table pre-initialization */
1640	switch (srcImage->bits_per_pixel)	1609	switch (srcImage->depth)
1641	{	1610	{
1642	case 15:	1611	case 15:
1643	if ((mask_r != 0x7c00) \|\|	1612	if ((mask_r != 0x7c00) \|\|
1644	(mask_g != 0x03e0) \|\|	1613	(mask_g != 0x03e0) \|\|
1645	(mask_b != 0x001f))	1614	(mask_b != 0x001f))
1646	return;	1615	return;
1647	lookup = (RUINT32T ) malloc (sizeof (RUINT32T)(32+32+32));	1616	lookup = (uint32_t ) malloc (sizeof (uint32_t)(32+32+32));
1648	lookup_r = lookup;	1617	lookup_r = lookup;
1649	lookup_g = lookup+32;	1618	lookup_g = lookup+32;
1650	lookup_b = lookup+32+32;	1619	lookup_b = lookup+32+32;
1651	sh_r = 10;	1620	sh_r = 10;
1652	sh_g = 5;	1621	sh_g = 5;
…		…
1655	case 16:	1624	case 16:
1656	if ((mask_r != 0xf800) \|\|	1625	if ((mask_r != 0xf800) \|\|
1657	(mask_g != 0x07e0) \|\|	1626	(mask_g != 0x07e0) \|\|
1658	(mask_b != 0x001f))	1627	(mask_b != 0x001f))
1659	return;	1628	return;
1660	lookup = (RUINT32T ) malloc (sizeof (RUINT32T)(32+64+32));	1629	lookup = (uint32_t ) malloc (sizeof (uint32_t)(32+64+32));
1661	lookup_r = lookup;	1630	lookup_r = lookup;
1662	lookup_g = lookup+32;	1631	lookup_g = lookup+32;
1663	lookup_b = lookup+32+64;	1632	lookup_b = lookup+32+64;
1664	sh_r = 11;	1633	sh_r = 11;
1665	sh_g = 5;	1634	sh_g = 5;
…		…
1668	case 24:	1637	case 24:
1669	if ((mask_r != 0xff0000) \|\|	1638	if ((mask_r != 0xff0000) \|\|
1670	(mask_g != 0x00ff00) \|\|	1639	(mask_g != 0x00ff00) \|\|
1671	(mask_b != 0x0000ff))	1640	(mask_b != 0x0000ff))
1672	return;	1641	return;
1673	lookup = (RUINT32T ) malloc (sizeof (RUINT32T)(256+256+256));	1642	lookup = (uint32_t ) malloc (sizeof (uint32_t)(256+256+256));
1674	lookup_r = lookup;	1643	lookup_r = lookup;
1675	lookup_g = lookup+256;	1644	lookup_g = lookup+256;
1676	lookup_b = lookup+256+256;	1645	lookup_b = lookup+256+256;
1677	sh_r = 16;	1646	sh_r = 16;
1678	sh_g = 8;	1647	sh_g = 8;
…		…
1681	case 32:	1650	case 32:
1682	if ((mask_r != 0xff0000) \|\|	1651	if ((mask_r != 0xff0000) \|\|
1683	(mask_g != 0x00ff00) \|\|	1652	(mask_g != 0x00ff00) \|\|
1684	(mask_b != 0x0000ff))	1653	(mask_b != 0x0000ff))
1685	return;	1654	return;
1686	lookup = (RUINT32T ) malloc (sizeof (RUINT32T)(256+256+256));	1655	lookup = (uint32_t ) malloc (sizeof (uint32_t)(256+256+256));
1687	lookup_r = lookup;	1656	lookup_r = lookup;
1688	lookup_g = lookup+256;	1657	lookup_g = lookup+256;
1689	lookup_b = lookup+256+256;	1658	lookup_b = lookup+256+256;
1690	sh_r = 16;	1659	sh_r = 16;
1691	sh_g = 8;	1660	sh_g = 8;
…		…
1702		1671
1703	lower_lim_r = 65535-rm;	1672	lower_lim_r = 65535-rm;
1704	lower_lim_g = 65535-gm;	1673	lower_lim_g = 65535-gm;
1705	lower_lim_b = 65535-bm;	1674	lower_lim_b = 65535-bm;
1706		1675
1707	lower_lim_r = 65535-(unsigned int)(((RUINT32T)lower_lim_r)*((RUINT32T)shade)/100);	1676	lower_lim_r = 65535-(unsigned int)(((uint32_t)lower_lim_r)*((uint32_t)shade)/100);
1708	lower_lim_g = 65535-(unsigned int)(((RUINT32T)lower_lim_g)*((RUINT32T)shade)/100);	1677	lower_lim_g = 65535-(unsigned int)(((uint32_t)lower_lim_g)*((uint32_t)shade)/100);
1709	lower_lim_b = 65535-(unsigned int)(((RUINT32T)lower_lim_b)*((RUINT32T)shade)/100);	1678	lower_lim_b = 65535-(unsigned int)(((uint32_t)lower_lim_b)*((uint32_t)shade)/100);
1710		1679
1711	upper_lim_r = upper_lim_g = upper_lim_b = 65535;	1680	upper_lim_r = upper_lim_g = upper_lim_b = 65535;
1712	}	1681	}
1713	else	1682	else
1714	{	1683	{
1715		1684
1716	lower_lim_r = lower_lim_g = lower_lim_b = 0;	1685	lower_lim_r = lower_lim_g = lower_lim_b = 0;
1717		1686
1718	upper_lim_r = (unsigned int)((((RUINT32T)rm)*((RUINT32T)shade))/100);	1687	upper_lim_r = (unsigned int)((((uint32_t)rm)*((uint32_t)shade))/100);
1719	upper_lim_g = (unsigned int)((((RUINT32T)gm)*((RUINT32T)shade))/100);	1688	upper_lim_g = (unsigned int)((((uint32_t)gm)*((uint32_t)shade))/100);
1720	upper_lim_b = (unsigned int)((((RUINT32T)bm)*((RUINT32T)shade))/100);	1689	upper_lim_b = (unsigned int)((((uint32_t)bm)*((uint32_t)shade))/100);
1721	}
1722
1723	/* switch red and blue bytes if necessary, we need it for some weird XServers like XFree86 3.3.3.1 */
1724	if ((srcImage->bits_per_pixel == 24) && (mask_r >= 0xFF0000))
1725	{
1726	unsigned int tmp;
1727
1728	tmp = lower_lim_r;
1729	lower_lim_r = lower_lim_b;
1730	lower_lim_b = tmp;
1731
1732	tmp = upper_lim_r;
1733	upper_lim_r = upper_lim_b;
1734	upper_lim_b = tmp;
1735	}	1690	}
1736		1691
1737	/* fill our lookup tables */	1692	/* fill our lookup tables */
1738	for (i = 0; i <= mask_r>>sh_r; i++)	1693	for (i = 0; i <= mask_r>>sh_r; i++)
1739	{	1694	{
1740	RUINT32T tmp;	1695	uint32_t tmp;
1741	tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_r-lower_lim_r));	1696	tmp = ((uint32_t)i)*((uint32_t)(upper_lim_r-lower_lim_r));
1742	tmp += ((RUINT32T)(mask_r>>sh_r))*((RUINT32T)lower_lim_r);	1697	tmp += ((uint32_t)(mask_r>>sh_r))*((uint32_t)lower_lim_r);
1743	lookup_r[i] = (tmp/65535)<<sh_r;	1698	lookup_r[i] = (tmp/65535)<<sh_r;
1744	}	1699	}
1745	for (i = 0; i <= mask_g>>sh_g; i++)	1700	for (i = 0; i <= mask_g>>sh_g; i++)
1746	{	1701	{
1747	RUINT32T tmp;	1702	uint32_t tmp;
1748	tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_g-lower_lim_g));	1703	tmp = ((uint32_t)i)*((uint32_t)(upper_lim_g-lower_lim_g));
1749	tmp += ((RUINT32T)(mask_g>>sh_g))*((RUINT32T)lower_lim_g);	1704	tmp += ((uint32_t)(mask_g>>sh_g))*((uint32_t)lower_lim_g);
1750	lookup_g[i] = (tmp/65535)<<sh_g;	1705	lookup_g[i] = (tmp/65535)<<sh_g;
1751	}	1706	}
1752	for (i = 0; i <= mask_b>>sh_b; i++)	1707	for (i = 0; i <= mask_b>>sh_b; i++)
1753	{	1708	{
1754	RUINT32T tmp;	1709	uint32_t tmp;
1755	tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_b-lower_lim_b));	1710	tmp = ((uint32_t)i)*((uint32_t)(upper_lim_b-lower_lim_b));
1756	tmp += ((RUINT32T)(mask_b>>sh_b))*((RUINT32T)lower_lim_b);	1711	tmp += ((uint32_t)(mask_b>>sh_b))*((uint32_t)lower_lim_b);
1757	lookup_b[i] = (tmp/65535)<<sh_b;	1712	lookup_b[i] = (tmp/65535)<<sh_b;
1758	}	1713	}
1759		1714
1760	/* apply table to input image (replacing colors by newly calculated ones) */	1715	/* apply table to input image (replacing colors by newly calculated ones) */
1761	switch (srcImage->bits_per_pixel)	1716	if (srcImage->bits_per_pixel == 32
		1717	&& (srcImage->depth == 24 \|\| srcImage->depth == 32)
		1718	&& srcImage->byte_order == host_byte_order)
1762	{	1719	{
1763	case 15:	1720	uint32_t p1, pf, p, pl;
1764	{
1765	unsigned short p1, pf, p, pl;
1766	p1 = (unsigned short *) srcImage->data;	1721	p1 = (uint32_t *) srcImage->data;
1767	pf = (unsigned short ) (srcImage->data + srcImage->height srcImage->bytes_per_line);	1722	pf = (uint32_t ) (srcImage->data + srcImage->height srcImage->bytes_per_line);
		1723
1768	while (p1 < pf)	1724	while (p1 < pf)
1769	{	1725	{
1770	p = p1;	1726	p = p1;
1771	pl = p1 + srcImage->width;	1727	pl = p1 + srcImage->width;
1772	for (; p < pl; p++)	1728	for (; p < pl; p++)
1773	{
1774	p = lookup_r[(p & 0x7c00)>>10] \|
1775	lookup_g[(*p & 0x03e0)>> 5] \|
1776	lookup_b[(*p & 0x001f)];
1777	}
1778	p1 = (unsigned short ) ((char ) p1 + srcImage->bytes_per_line);
1779	}	1729	{
1780	break;
1781	}
1782	case 16:
1783	{
1784	unsigned short p1, pf, p, pl;
1785	p1 = (unsigned short *) srcImage->data;
1786	pf = (unsigned short ) (srcImage->data + srcImage->height srcImage->bytes_per_line);
1787	while (p1 < pf)
1788	{
1789	p = p1;
1790	pl = p1 + srcImage->width;
1791	for (; p < pl; p++)
1792	{
1793	p = lookup_r[(p & 0xf800)>>11] \|
1794	lookup_g[(*p & 0x07e0)>> 5] \|
1795	lookup_b[(*p & 0x001f)];
1796	}
1797	p1 = (unsigned short ) ((char ) p1 + srcImage->bytes_per_line);
1798	}
1799	break;
1800	}
1801	case 24:
1802	{
1803	unsigned char p1, pf, p, pl;
1804	p1 = (unsigned char *) srcImage->data;
1805	pf = (unsigned char ) (srcImage->data + srcImage->height srcImage->bytes_per_line);
1806	while (p1 < pf)
1807	{
1808	p = p1;
1809	pl = p1 + srcImage->width * 3;
1810	for (; p < pl; p += 3)
1811	{
1812	p[0] = lookup_r[(p[0] & 0xff0000)>>16];
1813	p[1] = lookup_r[(p[1] & 0x00ff00)>> 8];
1814	p[2] = lookup_r[(p[2] & 0x0000ff)];
1815	}
1816	p1 = (unsigned char ) ((char ) p1 + srcImage->bytes_per_line);
1817	}
1818	break;
1819	}
1820	case 32:
1821	{
1822	RUINT32T p1, pf, p, pl;
1823	p1 = (RUINT32T *) srcImage->data;
1824	pf = (RUINT32T ) (srcImage->data + srcImage->height srcImage->bytes_per_line);
1825
1826	while (p1 < pf)
1827	{
1828	p = p1;
1829	pl = p1 + srcImage->width;
1830	for (; p < pl; p++)
1831	{
1832	p = lookup_r[(p & 0xff0000)>>16] \|	1730	p = lookup_r[(p & 0xff0000) >> 16] \|
1833	lookup_g[(*p & 0x00ff00)>> 8] \|	1731	lookup_g[(*p & 0x00ff00) >> 8] \|
1834	lookup_b[(*p & 0x0000ff)] \|	1732	lookup_b[(*p & 0x0000ff)] \|
1835	(*p & ~0xffffff);	1733	(*p & 0xff000000);
1836	}	1734	}
1837	p1 = (RUINT32T ) ((char ) p1 + srcImage->bytes_per_line);	1735	p1 = (uint32_t ) ((char ) p1 + srcImage->bytes_per_line);
		1736	}
		1737	}
		1738	else
		1739	{
		1740	for (int y = 0; y < srcImage->height; y++)
		1741	for (int x = 0; x < srcImage->width; x++)
		1742	{
		1743	unsigned long pixel = XGetPixel (srcImage, x, y);
		1744	pixel = lookup_r[(pixel & mask_r) >> sh_r] \|
		1745	lookup_g[(pixel & mask_g) >> sh_g] \|
		1746	lookup_b[(pixel & mask_b) >> sh_b];
		1747	XPutPixel (srcImage, x, y, pixel);
1838	}	1748	}
1839	break;
1840	}
1841	}	1749	}
1842		1750
1843	free (lookup);	1751	free (lookup);
1844	}	1752	}
1845	#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */	1753	#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */

Diff Legend

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

Comparing rxvt-unicode/src/background.C (file contents): Revision 1.90 by sf-exg, Mon Oct 18 16:02:48 2010 UTC vs. Revision 1.104 by sf-exg, Sun Oct 31 17:44:39 2010 UTC

Diff Legend

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.90 by sf-exg, Mon Oct 18 16:02:48 2010 UTC vs.
Revision 1.104 by sf-exg, Sun Oct 31 17:44:39 2010 UTC