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

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.84 by sf-exg, Sat Oct 16 20:25:06 2010 UTC vs.
Revision 1.102 by sf-exg, Sun Oct 31 09:34:23 2010 UTC

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

Diff Legend

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.84 by sf-exg, Sat Oct 16 20:25:06 2010 UTC vs.
Revision 1.102 by sf-exg, Sun Oct 31 09:34:23 2010 UTC