ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/rxvt-unicode/src/background.C

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.119 by sf-exg, Thu Nov 18 17:28:12 2010 UTC vs.
Revision 1.193 by sf-exg, Sun Jan 1 14:31:29 2012 UTC

1	/*----------------------------------------------------------------------*	1	/*----------------------------------------------------------------------*
2	* File: background.C - former xpm.C	2	* File: background.C - former xpm.C
3	*----------------------------------------------------------------------*	3	*----------------------------------------------------------------------*
4	*	4	*
5	* All portions of code are copyright by their respective author/s.	5	* All portions of code are copyright by their respective author/s.
6	* Copyright (c) 2005-2008 Marc Lehmann <pcg@goof.com>	6	* Copyright (c) 2005-2008 Marc Lehmann <schmorp@schmorp.de>
7	* Copyright (c) 2007 Sasha Vasko <sasha@aftercode.net>	7	* Copyright (c) 2007 Sasha Vasko <sasha@aftercode.net>
8	* Copyright (c) 2010 Emanuele Giaquinta <e.giaquinta@glauco.it>	8	* Copyright (c) 2010 Emanuele Giaquinta <e.giaquinta@glauco.it>
9	*	9	*
10	* This program is free software; you can redistribute it and/or modify	10	* This program is free software; you can redistribute it and/or modify
11	* it under the terms of the GNU General Public License as published by	11	* it under the terms of the GNU General Public License as published by
…		…
32		32
33	#ifndef FilterConvolution	33	#ifndef FilterConvolution
34	#define FilterConvolution "convolution"	34	#define FilterConvolution "convolution"
35	#endif	35	#endif
36		36
37	#define DO_TIMING_TEST 0
38
39	#if DO_TIMING_TEST
40	# include <sys/time.h>
41	#define TIMING_TEST_START(id) \
42	struct timeval timing_test_##id##_stv; \
43	gettimeofday (&timing_test_##id##_stv, NULL);
44
45	#define TIMING_TEST_PRINT_RESULT(id) \
46	do { \
47	struct timeval tv; \
48	gettimeofday (&tv, NULL); \
49	tv.tv_sec -= (timing_test_##id##_stv).tv_sec; \
50	fprintf (stderr, "%s: %s: %d: elapsed %ld usec\n", #id, __FILE__, __LINE__, \
51	tv.tv_sec * 1000000 + tv.tv_usec - (timing_test_##id##_stv).tv_usec); \
52	} while (0)
53
54	#else
55	#define TIMING_TEST_START(id) do {} while (0)
56	#define TIMING_TEST_PRINT_RESULT(id) do {} while (0)
57	#endif
58
59	/*
60	* Pixmap geometry string interpretation :
61	* Each geometry string contains zero or one scale/position
62	* adjustment and may optionally be followed by a colon and one or more
63	* colon-delimited pixmap operations.
64	* The following table shows the valid geometry strings and their
65	* effects on the background image :
66	*
67	* WxH+X+Y Set scaling to W% by H%, and position to X% by Y%.
68	* W and H are percentages of the terminal window size.
69	* X and Y are also percentages; e.g., +50+50 centers
70	* the image in the window.
71	*
72	* Pixmap Operations : (should be prepended by a colon)
73	* tile Tile image. Scaling/position modifiers above will affect
74	* the tile size and origin.
75	* propscale When scaling, scale proportionally. That is, maintain the
76	* proper aspect ratio for the image. Any portion of the
77	* background not covered by the image is filled with the
78	* current background color.
79	* hscale Scale horizontally, tile vertically ?
80	* vscale Tile horizontally, scale vertically ?
81	* scale Scale both up and down
82	* auto Same as 100x100+50+50
83	*/
84
85	#ifdef HAVE_BG_PIXMAP	37	#ifdef HAVE_BG_PIXMAP
86	bgPixmap_t::bgPixmap_t ()	38	# if XRENDER
		39	static Picture
		40	create_xrender_mask (Display *dpy, Drawable drawable, Bool argb, Bool component_alpha)
87	{	41	{
88	// this is basically redundant as bgPixmap_t is only used in	42	Pixmap pixmap = XCreatePixmap (dpy, drawable, 1, 1, argb ? 32 : 8);
89	// zero_initialised-derived structs	43
90	#ifdef HAVE_AFTERIMAGE	44	XRenderPictFormat *format = XRenderFindStandardFormat (dpy, argb ? PictStandardARGB32 : PictStandardA8);
91	original_asim = NULL;	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	}
92	#endif	54	# endif
93	#ifdef HAVE_PIXBUF
94	pixbuf = NULL;
95	#endif
96	#ifdef BG_IMAGE_FROM_FILE
97	have_image = false;
98	h_scale = v_scale = 0;
99	h_align = v_align = 0;
100	#endif
101	#ifdef ENABLE_TRANSPARENCY
102	shade = 100;
103	#endif
104	flags = 0;
105	pixmap = None;
106	valid_since = invalid_since = 0;
107	target = 0;
108	}
109		55
110	void	56	void
111	bgPixmap_t::destroy ()	57	rxvt_term::bg_destroy ()
112	{	58	{
113	#ifdef HAVE_AFTERIMAGE	59	#ifdef HAVE_AFTERIMAGE
114	if (original_asim)	60	if (original_asim)
115	safe_asimage_destroy (original_asim);	61	safe_asimage_destroy (original_asim);
		62	if (asv)
		63	destroy_asvisual (asv, 0);
		64	if (asimman)
		65	destroy_image_manager (asimman, 0);
116	#endif	66	#endif
117		67
118	#ifdef HAVE_PIXBUF	68	#ifdef HAVE_PIXBUF
119	if (pixbuf)	69	if (pixbuf)
120	g_object_unref (pixbuf);	70	g_object_unref (pixbuf);
121	#endif	71	#endif
122		72
123	if (pixmap && target)	73	if (bg_pixmap)
124	XFreePixmap (target->dpy, pixmap);	74	XFreePixmap (dpy, bg_pixmap);
125	}	75	}
126		76
127	bool	77	bool
128	bgPixmap_t::window_size_sensitive ()	78	rxvt_term::bg_set_position (int x, int y)
		79	{
		80
		81	if (target_x != x
		82	|| target_y != y)
		83	{
		84	target_x = x;
		85	target_y = y;
		86	return true;
		87	}
		88	return false;
		89	}
		90
		91	bool
		92	rxvt_term::bg_window_size_sensitive ()
129	{	93	{
130	# ifdef ENABLE_TRANSPARENCY	94	# ifdef ENABLE_TRANSPARENCY
131	if (flags & isTransparent)	95	if (bg_flags & BG_IS_TRANSPARENT)
132	return true;	96	return true;
133	# endif	97	# endif
134		98
135	# ifdef BG_IMAGE_FROM_FILE	99	# ifdef BG_IMAGE_FROM_FILE
136	if (have_image)	100	if (bg_flags & BG_IS_FROM_FILE)
137	{	101	{
138	if (flags & sizeSensitive)	102	if (bg_flags & BG_IS_SIZE_SENSITIVE)
139	return true;	103	return true;
140	}	104	}
141	# endif	105	# endif
142		106
143	return false;	107	return false;
144	}	108	}
145		109
146	bool	110	bool
147	bgPixmap_t::window_position_sensitive ()	111	rxvt_term::bg_window_position_sensitive ()
148	{	112	{
149	# ifdef ENABLE_TRANSPARENCY	113	# ifdef ENABLE_TRANSPARENCY
150	if (flags & isTransparent)	114	if (bg_flags & BG_IS_TRANSPARENT)
151	return true;	115	return true;
152	# endif	116	# endif
153		117
154	# ifdef BG_IMAGE_FROM_FILE	118	# ifdef BG_IMAGE_FROM_FILE
155	if (have_image)	119	if (bg_flags & BG_IS_FROM_FILE)
156	{	120	{
157	if (flags & rootAlign)	121	if (bg_flags & BG_ROOT_ALIGN)
158	return true;	122	return true;
159	}	123	}
160	# endif	124	# endif
161		125
162	return false;
163	}
164
165	bool bgPixmap_t::need_client_side_rendering ()
166	{
167	# ifdef HAVE_AFTERIMAGE
168	if (original_asim)
169	return true;
170	# endif
171	return false;	126	return false;
172	}	127	}
173		128
174	# ifdef BG_IMAGE_FROM_FILE	129	# ifdef BG_IMAGE_FROM_FILE
175	static inline bool	130	static inline bool
…		…
213	int smaller = min (image_size, window_size);	168	int smaller = min (image_size, window_size);
214		169
215	if (align >= 0 && align <= 100)	170	if (align >= 0 && align <= 100)
216	return diff * align / 100;	171	return diff * align / 100;
217	else if (align > 100 && align <= 200)	172	else if (align > 100 && align <= 200)
218	return ((align - 100) * smaller / 100) + window_size - smaller;	173	return (align - 100) * smaller / 100 + window_size - smaller;
219	else if (align >= -100 && align < 0)	174	else if (align >= -100 && align < 0)
220	return ((align + 100) * smaller / 100) - image_size;	175	return (align + 100) * smaller / 100 - image_size;
221	return 0;	176	return 0;
222	}	177	}
223		178
224	static inline int	179	static inline int
225	make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)	180	make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)
…		…
238	dst_size = target_size - dst_pos;	193	dst_size = target_size - dst_pos;
239	return src_pos;	194	return src_pos;
240	}	195	}
241		196
242	bool	197	bool
243	bgPixmap_t::set_geometry (const char *geom, bool update)	198	rxvt_term::bg_set_geometry (const char *geom, bool update)
244	{	199	{
245	bool changed = false;	200	bool changed = false;
246	int geom_flags = 0;	201	int geom_flags = 0;
247	int x = 0, y = 0;	202	int x = 0, y = 0;
248	unsigned int w = 0, h = 0;	203	unsigned int w = 0, h = 0;
249	unsigned int n;	204	unsigned long new_flags = 0;
250	unsigned long new_flags = (flags & (~geometryFlags));
251	const char *p;
252	# define MAXLEN_GEOM 256 /* could be longer than regular geometry string */
253		205
254	if (geom == NULL)	206	if (geom == NULL)
255	return false;	207	return false;
256		208
257	char str[MAXLEN_GEOM];	209	if (geom[0])
258
259	while (isspace(*geom)) ++geom;
260	if ((p = strchr (geom, ';')) == NULL)
261	p = strchr (geom, '\0');
262
263	n = (p - geom);
264	if (n < MAXLEN_GEOM)
265	{	210	{
266	char *ops;	211	char **arr = rxvt_strsplit (':', geom);
267		212
268	memcpy (str, geom, n);	213	for (int i = 0; arr[i]; i++)
269	str[n] = '\0';
270	if (str[0] == ':')
271	ops = &str[0];
272	else if (str[0] != 'x' && str[0] != 'X' && isalpha(str[0]))
273	ops = &str[0];
274	else
275	{
276	char *tmp;
277	ops = strchr (str, ':');
278	if (ops != NULL)
279	{	214	{
280	for (tmp = ops-1; tmp >= str && isspace(*tmp); --tmp);	215	if (!strcasecmp (arr[i], "style=tiled"))
281	*(++tmp) = '\0';
282	if (ops == tmp) ++ops;
283	}	216	{
284	}	217	new_flags = BG_TILE;
285		218	w = h = noScale;
286	if (ops > str || ops == NULL)	219	x = y = 0;
287	{	220	geom_flags = WidthValue|HeightValue|XValue|YValue;
288	/* we have geometry string - let's handle it prior to applying ops */
289	geom_flags = XParseGeometry (str, &x, &y, &w, &h);
290
291	if (!update) /* setting up geometry from scratch */
292	{	221	}
293	if (!(geom_flags & XValue))	222	else if (!strcasecmp (arr[i], "style=aspect-stretched"))
294	{
295	/* use default geometry - centered */
296	x = y = defaultAlign;
297	}
298	else if (!(geom_flags & YValue))
299	y = x;
300
301	if ((geom_flags & (WidthValue|HeightValue)) == 0)
302	{
303	/* use default geometry - scaled */
304	w = h = defaultScale;
305	}
306	else if (geom_flags & WidthValue)
307	{
308	if (!(geom_flags & HeightValue))
309	h = w;
310	}
311	else
312	w = h;
313	}	223	{
314	} /* done parsing geometry string */	224	new_flags = BG_KEEP_ASPECT;
315	else if (!update)	225	w = h = windowScale;
		226	x = y = centerAlign;
		227	geom_flags = WidthValue|HeightValue|XValue|YValue;
		228	}
		229	else if (!strcasecmp (arr[i], "style=stretched"))
316	{	230	{
317	/* default geometry - scaled and centered */	231	new_flags = 0;
		232	w = h = windowScale;
		233	geom_flags = WidthValue|HeightValue;
		234	}
		235	else if (!strcasecmp (arr[i], "style=centered"))
		236	{
		237	new_flags = 0;
		238	w = h = noScale;
		239	x = y = centerAlign;
		240	geom_flags = WidthValue|HeightValue|XValue|YValue;
		241	}
		242	else if (!strcasecmp (arr[i], "style=root-tiled"))
		243	{
		244	new_flags = BG_TILE|BG_ROOT_ALIGN;
		245	w = h = noScale;
		246	geom_flags = WidthValue|HeightValue;
		247	}
		248	else if (!strcasecmp (arr[i], "op=tile"))
		249	new_flags |= BG_TILE;
		250	else if (!strcasecmp (arr[i], "op=keep-aspect"))
		251	new_flags |= BG_KEEP_ASPECT;
		252	else if (!strcasecmp (arr[i], "op=root-align"))
		253	new_flags |= BG_ROOT_ALIGN;
		254
		255	// deprecated
		256	else if (!strcasecmp (arr[i], "tile"))
		257	{
		258	new_flags |= BG_TILE;
		259	w = h = noScale;
		260	geom_flags |= WidthValue|HeightValue;
		261	}
		262	else if (!strcasecmp (arr[i], "propscale"))
		263	{
		264	new_flags |= BG_KEEP_ASPECT;
		265	w = h = windowScale;
		266	geom_flags |= WidthValue|HeightValue;
		267	}
		268	else if (!strcasecmp (arr[i], "hscale"))
		269	{
		270	new_flags |= BG_TILE;
		271	w = windowScale;
		272	h = noScale;
		273	geom_flags |= WidthValue|HeightValue;
		274	}
		275	else if (!strcasecmp (arr[i], "vscale"))
		276	{
		277	new_flags |= BG_TILE;
		278	h = windowScale;
		279	w = noScale;
		280	geom_flags |= WidthValue|HeightValue;
		281	}
		282	else if (!strcasecmp (arr[i], "scale"))
		283	{
		284	w = h = windowScale;
		285	geom_flags |= WidthValue|HeightValue;
		286	}
		287	else if (!strcasecmp (arr[i], "auto"))
		288	{
		289	w = h = windowScale;
		290	x = y = centerAlign;
		291	geom_flags |= WidthValue|HeightValue|XValue|YValue;
		292	}
		293	else if (!strcasecmp (arr[i], "root"))
		294	{
		295	new_flags |= BG_TILE|BG_ROOT_ALIGN;
		296	w = h = noScale;
		297	geom_flags |= WidthValue|HeightValue;
		298	}
		299
		300	else
		301	geom_flags |= XParseGeometry (arr[i], &x, &y, &w, &h);
		302	} /* done parsing ops */
		303
		304	rxvt_free_strsplit (arr);
		305	}
		306
		307	new_flags |= bg_flags & ~BG_GEOMETRY_FLAGS;
		308
		309	if (!update)
		310	{
		311	if (!(geom_flags & XValue))
318	x = y = defaultAlign;	312	x = y = defaultAlign;
		313	else if (!(geom_flags & YValue))
		314	y = x;
		315
		316	if (!(geom_flags & (WidthValue|HeightValue)))
319	w = h = defaultScale;	317	w = h = defaultScale;
320	}	318	else if (!(geom_flags & HeightValue))
		319	h = w;
		320	else if (!(geom_flags & WidthValue))
		321	w = h;
321		322
322	if (!update)
323	geom_flags |= WidthValue|HeightValue|XValue|YValue;	323	geom_flags |= WidthValue|HeightValue|XValue|YValue;
		324	}
324		325
325	if (ops)
326	{
327	while (*ops)
328	{
329	while (*ops == ':' || isspace(*ops)) ++ops;
330
331	# define CHECK_GEOM_OPS(op_str) (strncasecmp (ops, (op_str), sizeof (op_str) - 1) == 0)
332	if (CHECK_GEOM_OPS ("tile"))
333	{
334	w = h = noScale;
335	geom_flags |= WidthValue|HeightValue;
336	}
337	else if (CHECK_GEOM_OPS ("propscale"))
338	{
339	new_flags |= propScale;
340	}
341	else if (CHECK_GEOM_OPS ("hscale"))
342	{
343	if (w == 0) w = windowScale;
344
345	h = noScale;
346	geom_flags |= WidthValue|HeightValue;
347	}
348	else if (CHECK_GEOM_OPS ("vscale"))
349	{
350	if (h == 0) h = windowScale;
351
352	w = noScale;
353	geom_flags |= WidthValue|HeightValue;
354	}
355	else if (CHECK_GEOM_OPS ("scale"))
356	{
357	if (h == 0) h = windowScale;
358	if (w == 0) w = windowScale;
359
360	geom_flags |= WidthValue|HeightValue;
361	}
362	else if (CHECK_GEOM_OPS ("auto"))
363	{
364	w = h = windowScale;
365	x = y = centerAlign;
366	geom_flags |= WidthValue|HeightValue|XValue|YValue;
367	}
368	else if (CHECK_GEOM_OPS ("root"))
369	{
370	new_flags |= rootAlign;
371	w = h = noScale;
372	geom_flags |= WidthValue|HeightValue;
373	}
374	# undef CHECK_GEOM_OPS
375
376	while (*ops != ':' && *ops != '\0') ++ops;
377	} /* done parsing ops */
378	}
379
380	if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true;	326	if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true;
381	if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true;	327	if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true;
382	if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true;	328	if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true;
383	if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true;	329	if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true;
384	}
385		330
386	if (new_flags != flags)	331	if (new_flags != bg_flags)
387	{	332	{
388	flags = new_flags;	333	bg_flags = new_flags;
389	changed = true;	334	changed = true;
390	}	335	}
391		336
392	return changed;	337	return changed;
393	}	338	}
394		339
395	void	340	void
396	bgPixmap_t::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y)	341	rxvt_term::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y)
397	{	342	{
398	int target_width = target->szHint.width;	343	int target_width = szHint.width;
399	int target_height = target->szHint.height;	344	int target_height = szHint.height;
400		345
401	if (flags & propScale)	346	w = h_scale * target_width / 100;
		347	h = v_scale * target_height / 100;
		348
		349	if (bg_flags & BG_KEEP_ASPECT)
402	{	350	{
403	float scale = (float)target_width / image_width;	351	float scale = (float)w / image_width;
404	min_it (scale, (float)target_height / image_height);	352	min_it (scale, (float)h / image_height);
405	w = image_width * scale + 0.5;	353	w = image_width * scale + 0.5;
406	h = image_height * scale + 0.5;	354	h = image_height * scale + 0.5;
407	}	355	}
408	else
409	{
410	w = h_scale * target_width / 100;
411	h = v_scale * target_height / 100;
412	}
413		356
414	if (!w) w = image_width;	357	if (!w) w = image_width;
415	if (!h) h = image_height;	358	if (!h) h = image_height;
416		359
417	if (flags & rootAlign)	360	if (bg_flags & BG_ROOT_ALIGN)
418	{	361	{
419	target->get_window_origin (x, y);
420	x = -x;	362	x = -target_x;
421	y = -y;	363	y = -target_y;
422	}	364	}
423	else	365	else
424	{	366	{
425	x = make_align_position (h_align, target_width, w);	367	x = make_align_position (h_align, target_width, w);
426	y = make_align_position (v_align, target_height, h);	368	y = make_align_position (v_align, target_height, h);
427	}	369	}
428		370
429	flags &= ~sizeSensitive;	371	bg_flags &= ~BG_IS_SIZE_SENSITIVE;
430	if ((flags & propScale) || h_scale || v_scale	372	if (!(bg_flags & BG_TILE)
		373	|| h_scale || v_scale
431	|| (!(flags & rootAlign) && (h_align || v_align))	374	|| (!(bg_flags & BG_ROOT_ALIGN) && (h_align || v_align))
432	|| w > target_width || h > target_height)	375	|| w > target_width || h > target_height)
433	flags |= sizeSensitive;	376	bg_flags |= BG_IS_SIZE_SENSITIVE;
434	}	377	}
435		378
436	# ifdef HAVE_AFTERIMAGE	379	# ifdef HAVE_AFTERIMAGE
437	bool	380	bool
438	bgPixmap_t::render_image (unsigned long background_flags)	381	rxvt_term::render_image (unsigned long tr_flags)
439	{	382	{
440	if (target == NULL)
441	return false;
442
443	target->init_asv ();	383	init_asv ();
444		384
445	ASImage *background = NULL;	385	ASImage *background = NULL;
446	ARGB32 background_tint = TINT_LEAVE_SAME;	386	ARGB32 background_tint = TINT_LEAVE_SAME;
447		387
448	# ifdef ENABLE_TRANSPARENCY	388	# ifdef ENABLE_TRANSPARENCY
449	if (background_flags)	389	if (tr_flags)
450	background = pixmap2ximage (target->asv, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, 100);	390	background = pixmap2ximage (asv, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, 100);
451		391
452	if (!(background_flags & transpPmapTinted) && (flags & tintNeeded))	392	if (tr_flags & BG_NEEDS_TINT)
453	{	393	{
454	ShadingInfo as_shade;	394	ShadingInfo as_shade;
455	as_shade.shading = shade;	395	as_shade.shading = shade;
456		396
457	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);	397	rgba c;
458	if (flags & tintSet)
459	tint.get (c);	398	tint.get (c);
460	as_shade.tintColor.red = c.r;	399	as_shade.tintColor.red = c.r;
461	as_shade.tintColor.green = c.g;	400	as_shade.tintColor.green = c.g;
462	as_shade.tintColor.blue = c.b;	401	as_shade.tintColor.blue = c.b;
463		402
464	background_tint = shading2tint32 (&as_shade);	403	background_tint = shading2tint32 (&as_shade);
465	}	404	}
466		405
467	if (!(background_flags & transpPmapBlurred) && (flags & blurNeeded) && background != NULL)	406	if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)
468	{	407	{
469	ASImage *tmp = blur_asimage_gauss (target->asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,	408	ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,
470	(original_asim == NULL || tint == TINT_LEAVE_SAME) ? ASA_XImage : ASA_ASImage,	409	ASA_XImage,
471	100, ASIMAGE_QUALITY_DEFAULT);	410	100, ASIMAGE_QUALITY_DEFAULT);
472	if (tmp)	411	if (tmp)
473	{	412	{
474	destroy_asimage (&background);	413	destroy_asimage (&background);
475	background = tmp;	414	background = tmp;
…		…
477	}	416	}
478	# endif	417	# endif
479		418
480	ASImage *result = 0;	419	ASImage *result = 0;
481		420
482	int target_width = target->szHint.width;	421	int target_width = szHint.width;
483	int target_height = target->szHint.height;	422	int target_height = szHint.height;
484	int new_pmap_width = target_width;	423	int new_pmap_width = target_width;
485	int new_pmap_height = target_height;	424	int new_pmap_height = target_height;
486		425
487	int x = 0;	426	int x = 0;
488	int y = 0;	427	int y = 0;
…		…
491		430
492	if (original_asim)	431	if (original_asim)
493	get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);	432	get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
494		433
495	if (!original_asim	434	if (!original_asim
496	|| (!(flags & rootAlign)	435	|| (!(bg_flags & BG_ROOT_ALIGN)
497	&& (x >= target_width	436	&& (x >= target_width
498	|| y >= target_height	437	|| y >= target_height
499	|| (x + w <= 0)	438	|| x + w <= 0
500	|| (y + h <= 0))))	439	|| y + h <= 0)))
501	{	440	{
502	if (background)	441	if (background)
503	{	442	{
504	new_pmap_width = background->width;	443	new_pmap_width = background->width;
505	new_pmap_height = background->height;	444	new_pmap_height = background->height;
506	result = background;	445	result = background;
507		446
508	if (background_tint != TINT_LEAVE_SAME)	447	if (background_tint != TINT_LEAVE_SAME)
509	{	448	{
510	ASImage *tmp = tile_asimage (target->asv, background, 0, 0,	449	ASImage *tmp = tile_asimage (asv, background, 0, 0,
511	target_width, target_height, background_tint,	450	target_width, target_height, background_tint,
512	ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);	451	ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
513	if (tmp)	452	if (tmp)
514	result = tmp;	453	result = tmp;
515	}	454	}
…		…
519	}	458	}
520	else	459	else
521	{	460	{
522	result = original_asim;	461	result = original_asim;
523		462
524	if ((w != original_asim->width)	463	if (w != original_asim->width
525	|| (h != original_asim->height))	464	|| h != original_asim->height)
526	{	465	{
527	result = scale_asimage (target->asv, original_asim,	466	result = scale_asimage (asv, original_asim,
528	w, h,	467	w, h,
529	background ? ASA_ASImage : ASA_XImage,	468	ASA_XImage,
530	100, ASIMAGE_QUALITY_DEFAULT);	469	100, ASIMAGE_QUALITY_DEFAULT);
531	}	470	}
532		471
533	if (background == NULL)	472	if (background == NULL)
534	{	473	{
535	if (h_scale == 0 || v_scale == 0)	474	if (bg_flags & BG_TILE)
536	{	475	{
537	/* if tiling - pixmap has to be sized exactly as the image,	476	/* if tiling - pixmap has to be sized exactly as the image,
538	but there is no need to make it bigger than the window! */	477	but there is no need to make it bigger than the window! */
539	new_pmap_width = min (result->width, target_width);	478	new_pmap_width = min (result->width, target_width);
540	new_pmap_height = min (result->height, target_height);	479	new_pmap_height = min (result->height, target_height);
541		480
542	/* we also need to tile our image in both directions */	481	/* we also need to tile our image in both directions */
543	ASImage *tmp = tile_asimage (target->asv, result,	482	ASImage *tmp = tile_asimage (asv, result,
544	(int)result->width - x,	483	(int)result->width - x,
545	(int)result->height - y,	484	(int)result->height - y,
546	new_pmap_width,	485	new_pmap_width,
547	new_pmap_height,	486	new_pmap_height,
548	TINT_LEAVE_SAME, ASA_XImage,	487	TINT_LEAVE_SAME, ASA_XImage,
…		…
565	layers[0].clip_width = target_width;	504	layers[0].clip_width = target_width;
566	layers[0].clip_height = target_height;	505	layers[0].clip_height = target_height;
567	layers[0].tint = background_tint;	506	layers[0].tint = background_tint;
568	layers[1].im = result;	507	layers[1].im = result;
569		508
570	if (h_scale == 0 || v_scale == 0)	509	if (bg_flags & BG_TILE)
571	{	510	{
572	/* tile horizontally */	511	/* tile horizontally */
573	while (x > 0) x -= (int)result->width;	512	while (x > 0) x -= (int)result->width;
574	layers[1].dst_x = x;	513	layers[1].dst_x = x;
575	layers[1].clip_width = result->width+target_width;	514	layers[1].clip_width = result->width+target_width;
…		…
579	/* clip horizontally */	518	/* clip horizontally */
580	layers[1].dst_x = x;	519	layers[1].dst_x = x;
581	layers[1].clip_width = result->width;	520	layers[1].clip_width = result->width;
582	}	521	}
583		522
584	if (h_scale == 0 || v_scale == 0)	523	if (bg_flags & BG_TILE)
585	{	524	{
586	while (y > 0) y -= (int)result->height;	525	while (y > 0) y -= (int)result->height;
587	layers[1].dst_y = y;	526	layers[1].dst_y = y;
588	layers[1].clip_height = result->height + target_height;	527	layers[1].clip_height = result->height + target_height;
589	}	528	}
…		…
591	{	530	{
592	layers[1].dst_y = y;	531	layers[1].dst_y = y;
593	layers[1].clip_height = result->height;	532	layers[1].clip_height = result->height;
594	}	533	}
595		534
596	if (target->rs[Rs_blendtype])	535	if (rs[Rs_blendtype])
597	{	536	{
598	layers[1].merge_scanlines = blend_scanlines_name2func (target->rs[Rs_blendtype]);	537	layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
599	if (layers[1].merge_scanlines == NULL)	538	if (layers[1].merge_scanlines == NULL)
600	layers[1].merge_scanlines = alphablend_scanlines;	539	layers[1].merge_scanlines = alphablend_scanlines;
601	}	540	}
602		541
603	ASImage *tmp = merge_layers (target->asv, layers, 2, target_width, target_height,	542	ASImage *tmp = merge_layers (asv, layers, 2, target_width, target_height,
604	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);	543	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
605		544
606	if (tmp)	545	if (tmp)
607	{	546	{
608	if (result != original_asim)	547	if (result != original_asim)
…		…
621	{	560	{
622	XGCValues gcv;	561	XGCValues gcv;
623	GC gc;	562	GC gc;
624		563
625	/* create Pixmap */	564	/* create Pixmap */
626	if (pixmap == None	565	if (bg_pixmap == None
627	|| pmap_width != new_pmap_width	566	|| bg_pmap_width != new_pmap_width
628	|| pmap_height != new_pmap_height	567	|| bg_pmap_height != new_pmap_height)
629	|| pmap_depth != target->depth)
630	{	568	{
631	if (pixmap)	569	if (bg_pixmap)
632	XFreePixmap (target->dpy, pixmap);	570	XFreePixmap (dpy, bg_pixmap);
633	pixmap = XCreatePixmap (target->dpy, target->vt, new_pmap_width, new_pmap_height, target->depth);	571	bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
634	pmap_width = new_pmap_width;	572	bg_pmap_width = new_pmap_width;
635	pmap_height = new_pmap_height;	573	bg_pmap_height = new_pmap_height;
636	pmap_depth = target->depth;
637	}	574	}
638	/* fill with background color (if result's not completely overlapping it) */	575	/* fill with background color (if result's not completely overlapping it) */
639	gcv.foreground = target->pix_colors[Color_bg];	576	gcv.foreground = pix_colors[Color_bg];
640	gc = XCreateGC (target->dpy, target->vt, GCForeground, &gcv);	577	gc = XCreateGC (dpy, vt, GCForeground, &gcv);
641		578
642	int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;	579	int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
643	int dst_width = result->width, dst_height = result->height;	580	int dst_width = result->width, dst_height = result->height;
644	if (background == NULL)	581	if (background == NULL)
645	{	582	{
646	if (!(h_scale == 0 || v_scale == 0))	583	if (!(bg_flags & BG_TILE))
647	{	584	{
648	src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );	585	src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );
649	src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);	586	src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
650	}	587	}
651		588
652	if (dst_x > 0 || dst_y > 0	589	if (dst_x > 0 || dst_y > 0
653	|| dst_x + dst_width < new_pmap_width	590	|| dst_x + dst_width < new_pmap_width
654	|| dst_y + dst_height < new_pmap_height)	591	|| dst_y + dst_height < new_pmap_height)
655	XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);	592	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
656	}	593	}
657		594
658	/* put result on pixmap */	595	/* put result on pixmap */
659	if (dst_x < new_pmap_width && dst_y < new_pmap_height)	596	if (dst_x < new_pmap_width && dst_y < new_pmap_height)
660	asimage2drawable (target->asv, pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);	597	asimage2drawable (asv, bg_pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);
661		598
662	if (result != background && result != original_asim)	599	if (result != background && result != original_asim)
663	destroy_asimage (&result);	600	destroy_asimage (&result);
664		601
665	XFreeGC (target->dpy, gc);	602	XFreeGC (dpy, gc);
666		603
667	ret = true;	604	ret = true;
668	}	605	}
669		606
670	if (background)	607	if (background)
…		…
674	}	611	}
675	# endif /* HAVE_AFTERIMAGE */	612	# endif /* HAVE_AFTERIMAGE */
676		613
677	# ifdef HAVE_PIXBUF	614	# ifdef HAVE_PIXBUF
678	bool	615	bool
679	bgPixmap_t::render_image (unsigned long background_flags)	616	rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
		617	int src_x, int src_y, int dst_x, int dst_y,
		618	unsigned int width, unsigned int height)
680	{	619	{
681	if (target == NULL)	620	XImage *ximage;
		621	char *data, *line;
		622	int bytes_per_pixel;
		623	int width_r, width_g, width_b;
		624	int sh_r, sh_g, sh_b;
		625	int rowstride;
		626	int channels;
		627	unsigned char *row;
		628
		629	if (visual->c_class != TrueColor)
682	return false;	630	return false;
683		631
		632	if (depth == 24 || depth == 32)
		633	bytes_per_pixel = 4;
		634	else if (depth == 15 || depth == 16)
		635	bytes_per_pixel = 2;
		636	else
		637	return false;
		638
		639	width_r = ecb_popcount32 (visual->red_mask);
		640	width_g = ecb_popcount32 (visual->green_mask);
		641	width_b = ecb_popcount32 (visual->blue_mask);
		642
		643	if (width_r > 8 || width_g > 8 || width_b > 8)
		644	return false;
		645
		646	sh_r = ecb_ctz32 (visual->red_mask);
		647	sh_g = ecb_ctz32 (visual->green_mask);
		648	sh_b = ecb_ctz32 (visual->blue_mask);
		649
		650	if (width > INT_MAX / height / bytes_per_pixel)
		651	return false;
		652
		653	data = (char *)malloc (width * height * bytes_per_pixel);
		654	if (!data)
		655	return false;
		656
		657	ximage = XCreateImage (dpy, visual, depth, ZPixmap, 0, data,
		658	width, height, bytes_per_pixel * 8, 0);
		659	if (!ximage)
		660	{
		661	free (data);
		662	return false;
		663	}
		664
		665	ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
		666
		667	rowstride = gdk_pixbuf_get_rowstride (pixbuf);
		668	channels = gdk_pixbuf_get_n_channels (pixbuf);
		669	row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels;
		670	line = data;
		671
		672	for (int y = 0; y < height; y++)
		673	{
		674	for (int x = 0; x < width; x++)
		675	{
		676	unsigned char *pixel = row + x * channels;
		677	uint32_t value;
		678
		679	value = ((pixel[0] >> (8 - width_r)) << sh_r)
		680	| ((pixel[1] >> (8 - width_g)) << sh_g)
		681	| ((pixel[2] >> (8 - width_b)) << sh_b);
		682
		683	if (bytes_per_pixel == 4)
		684	((uint32_t *)line)[x] = value;
		685	else
		686	((uint16_t *)line)[x] = value;
		687	}
		688
		689	row += rowstride;
		690	line += ximage->bytes_per_line;
		691	}
		692
		693	XPutImage (dpy, pixmap, gc, ximage, 0, 0, dst_x, dst_y, width, height);
		694	XDestroyImage (ximage);
		695	return true;
		696	}
		697
		698	bool
		699	rxvt_term::render_image (unsigned long tr_flags)
		700	{
684	if (!pixbuf)	701	if (!pixbuf)
685	return false;	702	return false;
686		703
687	if (background_flags	704	if (tr_flags
688	&& !(flags & HAS_RENDER))	705	&& !(bg_flags & BG_HAS_RENDER))
689	return false;	706	return false;
690		707
691	GdkPixbuf *result;	708	GdkPixbuf *result;
692		709
693	int image_width = gdk_pixbuf_get_width (pixbuf);	710	int image_width = gdk_pixbuf_get_width (pixbuf);
694	int image_height = gdk_pixbuf_get_height (pixbuf);	711	int image_height = gdk_pixbuf_get_height (pixbuf);
695		712
696	int target_width = target->szHint.width;	713	int target_width = szHint.width;
697	int target_height = target->szHint.height;	714	int target_height = szHint.height;
698	int new_pmap_width = target_width;	715	int new_pmap_width = target_width;
699	int new_pmap_height = target_height;	716	int new_pmap_height = target_height;
700		717
701	int x = 0;	718	int x = 0;
702	int y = 0;	719	int y = 0;
703	int w = 0;	720	int w = 0;
704	int h = 0;	721	int h = 0;
705		722
706	get_image_geometry (image_width, image_height, w, h, x, y);	723	get_image_geometry (image_width, image_height, w, h, x, y);
707		724
708	if (!(flags & rootAlign)	725	if (!(bg_flags & BG_ROOT_ALIGN)
709	&& (x >= target_width	726	&& (x >= target_width
710	|| y >= target_height	727	|| y >= target_height
711	|| (x + w <= 0)	728	|| x + w <= 0
712	|| (y + h <= 0)))	729	|| y + h <= 0))
713	return false;	730	return false;
714		731
715	result = pixbuf;	732	result = pixbuf;
716		733
717	if ((w != image_width)	734	if (w != image_width
718	|| (h != image_height))	735	|| h != image_height)
719	{	736	{
720	result = gdk_pixbuf_scale_simple (pixbuf,	737	result = gdk_pixbuf_scale_simple (pixbuf,
721	w, h,	738	w, h,
722	GDK_INTERP_BILINEAR);	739	GDK_INTERP_BILINEAR);
723	}	740	}
724		741
		742	if (!result)
		743	return false;
		744
725	bool ret = false;	745	bool ret = false;
726		746
727	if (result)
728	{
729	XGCValues gcv;	747	XGCValues gcv;
730	GC gc;	748	GC gc;
731	Pixmap root_pmap;	749	Pixmap root_pmap;
732		750
733	image_width = gdk_pixbuf_get_width (result);	751	image_width = gdk_pixbuf_get_width (result);
734	image_height = gdk_pixbuf_get_height (result);	752	image_height = gdk_pixbuf_get_height (result);
735		753
736	if (background_flags)	754	if (tr_flags)
737	{	755	{
738	root_pmap = pixmap;	756	root_pmap = bg_pixmap;
739	pixmap = None;	757	bg_pixmap = None;
		758	}
		759	else
		760	{
		761	if (bg_flags & BG_TILE)
740	}	762	{
741	else
742	{
743	if (h_scale == 0 || v_scale == 0)
744	{
745	new_pmap_width = min (image_width, target_width);	763	new_pmap_width = min (image_width, target_width);
746	new_pmap_height = min (image_height, target_height);	764	new_pmap_height = min (image_height, target_height);
747	}	765	}
748	}	766	}
749		767
750	if (pixmap == None	768	if (bg_pixmap == None
751	|| pmap_width != new_pmap_width	769	|| bg_pmap_width != new_pmap_width
752	|| pmap_height != new_pmap_height	770	|| bg_pmap_height != new_pmap_height)
753	|| pmap_depth != target->depth)	771	{
754	{
755	if (pixmap)	772	if (bg_pixmap)
756	XFreePixmap (target->dpy, pixmap);	773	XFreePixmap (dpy, bg_pixmap);
757	pixmap = XCreatePixmap (target->dpy, target->vt, new_pmap_width, new_pmap_height, target->depth);	774	bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
758	pmap_width = new_pmap_width;	775	bg_pmap_width = new_pmap_width;
759	pmap_height = new_pmap_height;	776	bg_pmap_height = new_pmap_height;
760	pmap_depth = target->depth;	777	}
		778
		779	gcv.foreground = pix_colors[Color_bg];
		780	gc = XCreateGC (dpy, vt, GCForeground, &gcv);
		781
		782	if (gc)
		783	{
		784	if (bg_flags & BG_TILE)
761	}	785	{
762
763	gcv.foreground = target->pix_colors[Color_bg];
764	gc = XCreateGC (target->dpy, target->vt, GCForeground, &gcv);
765
766	if (h_scale == 0 || v_scale == 0)
767	{
768	Pixmap tile = XCreatePixmap (target->dpy, target->vt, image_width, image_height, target->depth);	786	Pixmap tile = XCreatePixmap (dpy, vt, image_width, image_height, depth);
769	gdk_pixbuf_xlib_render_to_drawable (result, tile, gc,	787	pixbuf_to_pixmap (result, tile, gc,
770	0, 0,	788	0, 0,
771	0, 0,	789	0, 0,
772	image_width, image_height,	790	image_width, image_height);
773	XLIB_RGB_DITHER_NONE,
774	0, 0);
775		791
776	gcv.tile = tile;	792	gcv.tile = tile;
777	gcv.fill_style = FillTiled;	793	gcv.fill_style = FillTiled;
778	gcv.ts_x_origin = x;	794	gcv.ts_x_origin = x;
779	gcv.ts_y_origin = y;	795	gcv.ts_y_origin = y;
780	XChangeGC (target->dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);	796	XChangeGC (dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
781		797
782	XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);	798	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
783	XFreePixmap (target->dpy, tile);	799	XFreePixmap (dpy, tile);
784	}	800	}
785	else	801	else
786	{	802	{
787	int src_x, src_y, dst_x, dst_y;	803	int src_x, src_y, dst_x, dst_y;
788	int dst_width, dst_height;	804	int dst_width, dst_height;
…		…
791	src_y = make_clip_rectangle (y, image_height, new_pmap_height, dst_y, dst_height);	807	src_y = make_clip_rectangle (y, image_height, new_pmap_height, dst_y, dst_height);
792		808
793	if (dst_x > 0 || dst_y > 0	809	if (dst_x > 0 || dst_y > 0
794	|| dst_x + dst_width < new_pmap_width	810	|| dst_x + dst_width < new_pmap_width
795	|| dst_y + dst_height < new_pmap_height)	811	|| dst_y + dst_height < new_pmap_height)
796	XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);	812	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
797		813
798	if (dst_x < new_pmap_width && dst_y < new_pmap_height)	814	if (dst_x < new_pmap_width && dst_y < new_pmap_height)
799	gdk_pixbuf_xlib_render_to_drawable (result, pixmap, gc,	815	pixbuf_to_pixmap (result, bg_pixmap, gc,
800	src_x, src_y,	816	src_x, src_y,
801	dst_x, dst_y,	817	dst_x, dst_y,
802	dst_width, dst_height,	818	dst_width, dst_height);
803	XLIB_RGB_DITHER_NONE,
804	0, 0);
805	}	819	}
806		820
807	#if XRENDER	821	#if XRENDER
808	if (background_flags)	822	if (tr_flags)
809	{	823	{
810	Display *dpy = target->dpy;
811	XRenderPictureAttributes pa;
812
813	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, target->visual);	824	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
		825
814	Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa);	826	Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
815		827
816	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, target->visual);
817	Picture dst = XRenderCreatePicture (dpy, pixmap, dst_format, 0, &pa);	828	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
818		829
819	pa.repeat = True;	830	Picture mask = create_xrender_mask (dpy, vt, False, False);
820	Pixmap mask_pmap = XCreatePixmap (dpy, target->vt, 1, 1, 8);
821	XRenderPictFormat *mask_format = XRenderFindStandardFormat (dpy, PictStandardA8);
822	Picture mask = XRenderCreatePicture (dpy, mask_pmap, mask_format, CPRepeat, &pa);
823	XFreePixmap (dpy, mask_pmap);
824		831
825	if (src && dst && mask)
826	{
827	XRenderColor mask_c;	832	XRenderColor mask_c;
828		833
829	mask_c.alpha = 0x8000;	834	mask_c.alpha = 0x8000;
830	mask_c.red = 0;	835	mask_c.red =
831	mask_c.green = 0;	836	mask_c.green =
832	mask_c.blue = 0;	837	mask_c.blue = 0;
833	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);	838	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
		839
834	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);
835	}
836		841
837	XRenderFreePicture (dpy, src);	842	XRenderFreePicture (dpy, src);
838	XRenderFreePicture (dpy, dst);	843	XRenderFreePicture (dpy, dst);
839	XRenderFreePicture (dpy, mask);	844	XRenderFreePicture (dpy, mask);
840
841	XFreePixmap (dpy, root_pmap);
842	}	845	}
843	#endif	846	#endif
844		847
845	if (result != pixbuf)
846	g_object_unref (result);
847
848	XFreeGC (target->dpy, gc);	848	XFreeGC (dpy, gc);
849		849
850	ret = true;	850	ret = true;
851	}	851	}
852		852
		853	if (result != pixbuf)
		854	g_object_unref (result);
		855
		856	if (tr_flags)
		857	XFreePixmap (dpy, root_pmap);
		858
853	return ret;	859	return ret;
854	}	860	}
855	# endif /* HAVE_PIXBUF */	861	# endif /* HAVE_PIXBUF */
856		862
857	bool	863	bool
858	bgPixmap_t::set_file (const char *file)	864	rxvt_term::bg_set_file (const char *file)
859	{	865	{
860	if (!file || !*file)	866	if (!file || !*file)
861	return false;	867	return false;
862		868
		869	bool ret = false;
863	if (const char *p = strchr (file, ';'))	870	const char *p = strchr (file, ';');
		871
		872	if (p)
864	{	873	{
865	size_t len = p - file;	874	size_t len = p - file;
866	char *f = rxvt_temp_buf<char> (len + 1);	875	char *f = rxvt_temp_buf<char> (len + 1);
867	memcpy (f, file, len);	876	memcpy (f, file, len);
868	f[len] = '\0';	877	f[len] = '\0';
869	file = f;	878	file = f;
870	}	879	}
871		880
872	# ifdef HAVE_AFTERIMAGE	881	# ifdef HAVE_AFTERIMAGE
873	if (!target->asimman)	882	if (!asimman)
874	target->asimman = create_generic_imageman (target->rs[Rs_path]);	883	asimman = create_generic_imageman (rs[Rs_path]);
875	ASImage *image = get_asimage (target->asimman, file, 0xFFFFFFFF, 100);	884	ASImage *image = get_asimage (asimman, file, 0xFFFFFFFF, 100);
876	if (image)	885	if (image)
877	{	886	{
878	if (original_asim)	887	if (original_asim)
879	safe_asimage_destroy (original_asim);	888	safe_asimage_destroy (original_asim);
880	original_asim = image;	889	original_asim = image;
881	have_image = true;	890	bg_flags |= BG_IS_FROM_FILE | BG_CLIENT_RENDER;
882	return true;	891	ret = true;
883	}	892	}
884	# endif	893	# endif
885		894
886	# ifdef HAVE_PIXBUF	895	# ifdef HAVE_PIXBUF
887	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);	896	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
888	if (image)	897	if (image)
889	{	898	{
890	if (pixbuf)	899	if (pixbuf)
891	g_object_unref (pixbuf);	900	g_object_unref (pixbuf);
892	pixbuf = image;	901	pixbuf = image;
893	have_image = true;	902	bg_flags |= BG_IS_FROM_FILE;
894	return true;	903	ret = true;
895	}	904	}
896	# endif	905	# endif
897		906
		907	if (ret)
		908	{
		909	if (p)
		910	bg_set_geometry (p + 1);
		911	else
		912	bg_set_default_geometry ();
		913	}
		914
898	return false;	915	return ret;
899	}	916	}
900		917
901	# endif /* BG_IMAGE_FROM_FILE */	918	# endif /* BG_IMAGE_FROM_FILE */
902		919
903	# ifdef ENABLE_TRANSPARENCY	920	# ifdef ENABLE_TRANSPARENCY
904	bool	921	bool
905	bgPixmap_t::set_transparent ()	922	rxvt_term::bg_set_transparent ()
906	{	923	{
907	if (!(flags & isTransparent))	924	if (!(bg_flags & BG_IS_TRANSPARENT))
908	{	925	{
909	flags |= isTransparent;	926	bg_flags |= BG_IS_TRANSPARENT;
910	return true;	927	return true;
911	}	928	}
912		929
913	return false;	930	return false;
914	}	931	}
915		932
916	bool	933	bool
917	bgPixmap_t::set_blur_radius (const char *geom)	934	rxvt_term::bg_set_blur (const char *geom)
918	{	935	{
919	bool changed = false;	936	bool changed = false;
920	unsigned int hr, vr;	937	unsigned int hr, vr;
921	int junk;	938	int junk;
922	int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr);	939	int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr);
…		…
939	{	956	{
940	changed = true;	957	changed = true;
941	v_blurRadius = vr;	958	v_blurRadius = vr;
942	}	959	}
943		960
944	if (v_blurRadius == 0 && h_blurRadius == 0)	961	if (h_blurRadius == 0 || v_blurRadius == 0)
945	flags &= ~blurNeeded;	962	bg_flags &= ~BG_NEEDS_BLUR;
946	else	963	else
947	flags |= blurNeeded;	964	bg_flags |= BG_NEEDS_BLUR;
948		965
949	return changed;	966	return changed;
950	}	967	}
951		968
952	static inline unsigned long	969	void
953	compute_tint_shade_flags (rxvt_color *tint, int shade)	970	rxvt_term::set_tint_shade_flags ()
954	{	971	{
955	unsigned long flags = 0;	972	rgba c;
956	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
957	bool has_shade = shade != 100;	973	bool has_shade = shade != 100;
958		974
959	if (tint)	975	bg_flags &= ~BG_TINT_FLAGS;
960	{	976
961	tint->get (c);	977	tint.get (c);
962	# define IS_COMPONENT_WHOLESOME(cmp) ((cmp) <= 0x000700 || (cmp) >= 0x00f700)
963	if (!has_shade && IS_COMPONENT_WHOLESOME (c.r)
964	&& IS_COMPONENT_WHOLESOME (c.g)
965	&& IS_COMPONENT_WHOLESOME (c.b))
966	flags |= bgPixmap_t::tintWholesome;
967	# undef IS_COMPONENT_WHOLESOME
968	}
969		978
		979	if (!has_shade
		980	&& (c.r <= 0x00ff || c.r >= 0xff00)
		981	&& (c.g <= 0x00ff || c.g >= 0xff00)
		982	&& (c.b <= 0x00ff || c.b >= 0xff00))
		983	bg_flags |= BG_TINT_BITAND;
		984
970	if (has_shade)	985	if (has_shade
971	flags |= bgPixmap_t::tintNeeded;	986	|| c.r < 0xff00
972	else if (tint)	987	|| c.g < 0xff00
973	{	988	|| c.b < 0xff00)
974	if ((c.r > 0x000700 || c.g > 0x000700 || c.b > 0x000700)	989	bg_flags |= BG_NEEDS_TINT;
975	&& (c.r < 0x00f700 || c.g < 0x00f700 || c.b < 0x00f700))
976	{
977	flags |= bgPixmap_t::tintNeeded;
978	}
979	}
980
981	return flags;
982	}	990	}
983		991
984	bool	992	bool
985	bgPixmap_t::set_tint (rxvt_color &new_tint)	993	rxvt_term::bg_set_tint (rxvt_color &new_tint)
986	{	994	{
987	if (!(flags & tintSet) || tint != new_tint)	995	if (tint != new_tint)
988	{	996	{
989	unsigned long new_flags = compute_tint_shade_flags (&new_tint, shade);
990	tint = new_tint;	997	tint = new_tint;
991	flags = (flags & ~tintFlags) | new_flags | tintSet;	998	set_tint_shade_flags ();
992	return true;	999	return true;
993	}	1000	}
994		1001
995	return false;	1002	return false;
996	}	1003	}
997		1004
998	bool	1005	bool
999	bgPixmap_t::unset_tint ()
1000	{
1001	unsigned long new_flags = compute_tint_shade_flags (NULL, shade);
1002
1003	if (new_flags != (flags & tintFlags))
1004	{
1005	flags = (flags & ~tintFlags) | new_flags;
1006	return true;
1007	}
1008
1009	return false;
1010	}
1011
1012	bool
1013	bgPixmap_t::set_shade (const char *shade_str)	1006	rxvt_term::bg_set_shade (const char *shade_str)
1014	{	1007	{
1015	int new_shade = (shade_str) ? atoi (shade_str) : 100;	1008	int new_shade = atoi (shade_str);
1016		1009
1017	clamp_it (new_shade, -100, 200);	1010	clamp_it (new_shade, -100, 200);
1018	if (new_shade < 0)	1011	if (new_shade < 0)
1019	new_shade = 200 - (100 + new_shade);	1012	new_shade = 200 - (100 + new_shade);
1020		1013
1021	if (new_shade != shade)	1014	if (new_shade != shade)
1022	{	1015	{
1023	unsigned long new_flags = compute_tint_shade_flags ((flags & tintSet) ? &tint : NULL, new_shade);
1024	shade = new_shade;	1016	shade = new_shade;
1025	flags = (flags & (~tintFlags | tintSet)) | new_flags;	1017	set_tint_shade_flags ();
1026	return true;	1018	return true;
1027	}	1019	}
1028		1020
1029	return false;	1021	return false;
1030	}	1022	}
…		…
1051	params[i+2] = XDoubleToFixed (kernel[i] / sum);	1043	params[i+2] = XDoubleToFixed (kernel[i] / sum);
1052	}	1044	}
1053	#endif	1045	#endif
1054		1046
1055	bool	1047	bool
1056	bgPixmap_t::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	1048	rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1057	{	1049	{
1058	bool ret = false;	1050	bool ret = false;
1059	#if XRENDER	1051	#if XRENDER
		1052	if (!(bg_flags & BG_HAS_RENDER_CONV))
		1053	return false;
		1054
1060	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;	1055	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1061	double *kernel = (double *)malloc (size * sizeof (double));	1056	double *kernel = (double *)malloc (size * sizeof (double));
1062	XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));	1057	XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1063		1058
1064	Display *dpy = target->dpy;
1065	XRenderPictureAttributes pa;
1066	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	1059	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1067		1060
1068	Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1061	Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1069	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1062	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1070		1063
1071	if (kernel && params && src && dst)	1064	if (kernel && params)
1072	{	1065	{
1073	if (h_blurRadius)
1074	{
1075	size = h_blurRadius * 2 + 1;	1066	size = h_blurRadius * 2 + 1;
1076	get_gaussian_kernel (h_blurRadius, size, kernel, params);	1067	get_gaussian_kernel (h_blurRadius, size, kernel, params);
1077		1068
1078	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	1069	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1079	XRenderComposite (dpy,	1070	XRenderComposite (dpy,
1080	PictOpSrc,	1071	PictOpSrc,
1081	src,	1072	src,
1082	None,	1073	None,
1083	dst,	1074	dst,
1084	0, 0,	1075	0, 0,
1085	0, 0,	1076	0, 0,
1086	0, 0,	1077	0, 0,
1087	width, height);	1078	width, height);
1088	}
1089		1079
1090	if (v_blurRadius)
1091	{
1092	size = v_blurRadius * 2 + 1;	1080	size = v_blurRadius * 2 + 1;
1093	get_gaussian_kernel (v_blurRadius, size, kernel, params);	1081	get_gaussian_kernel (v_blurRadius, size, kernel, params);
1094	swap (params[0], params[1]);	1082	::swap (params[0], params[1]);
1095		1083
1096	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	1084	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1097	XRenderComposite (dpy,	1085	XRenderComposite (dpy,
1098	PictOpSrc,	1086	PictOpSrc,
1099	src,	1087	src,
1100	None,	1088	None,
1101	dst,	1089	dst,
1102	0, 0,	1090	0, 0,
1103	0, 0,	1091	0, 0,
1104	0, 0,	1092	0, 0,
1105	width, height);	1093	width, height);
1106	}
1107		1094
1108	ret = true;	1095	ret = true;
1109	}	1096	}
1110		1097
1111	free (kernel);	1098	free (kernel);
…		…
1115	#endif	1102	#endif
1116	return ret;	1103	return ret;
1117	}	1104	}
1118		1105
1119	bool	1106	bool
1120	bgPixmap_t::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	1107	rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1121	{	1108	{
1122	Display *dpy = target->dpy;
1123	bool ret = false;	1109	bool ret = false;
1124		1110
1125	if (flags & tintWholesome)	1111	if (bg_flags & BG_TINT_BITAND)
1126	{	1112	{
1127	XGCValues gcv;	1113	XGCValues gcv;
1128	GC gc;	1114	GC gc;
1129		1115
1130	/* In this case we can tint image server-side getting significant	1116	/* In this case we can tint image server-side getting significant
…		…
1139	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);	1125	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1140	ret = true;	1126	ret = true;
1141	XFreeGC (dpy, gc);	1127	XFreeGC (dpy, gc);
1142	}	1128	}
1143	}	1129	}
1144	else
1145	{
1146	# if XRENDER	1130	# if XRENDER
1147	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);	1131	else if (bg_flags & BG_HAS_RENDER)
		1132	{
		1133	rgba c;
1148		1134
1149	if (flags & tintSet)
1150	tint.get (c);	1135	tint.get (c);
1151		1136
1152	if (shade <= 100)	1137	if (shade <= 100)
1153	{	1138	{
1154	c.r = (c.r * shade) / 100;	1139	c.r = c.r * shade / 100;
1155	c.g = (c.g * shade) / 100;	1140	c.g = c.g * shade / 100;
1156	c.b = (c.b * shade) / 100;	1141	c.b = c.b * shade / 100;
1157	}	1142	}
1158	else	1143	else
1159	{	1144	{
1160	c.r = ((0xffff - c.r) * (200 - shade)) / 100;	1145	c.r = c.r * (200 - shade) / 100;
1161	c.g = ((0xffff - c.g) * (200 - shade)) / 100;	1146	c.g = c.g * (200 - shade) / 100;
1162	c.b = ((0xffff - c.b) * (200 - shade)) / 100;	1147	c.b = c.b * (200 - shade) / 100;
1163	}	1148	}
1164		1149
1165	XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1166	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	1150	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1167	XRenderPictureAttributes pa;
1168		1151
1169	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1152	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1170		1153
1171	pa.repeat = True;	1154	Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1172		1155
1173	Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);	1156	Picture mask_pic = create_xrender_mask (dpy, pixmap, True, True);
1174	Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1175	XFreePixmap (dpy, overlay_pmap);
1176		1157
1177	pa.component_alpha = True;
1178	Pixmap mask_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
1179	Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat|CPComponentAlpha, &pa);
1180	XFreePixmap (dpy, mask_pmap);
1181
1182	if (mask_pic && overlay_pic && back_pic)
1183	{
1184	XRenderColor mask_c;	1158	XRenderColor mask_c;
1185		1159
1186	mask_c.red = mask_c.green = mask_c.blue = shade > 100 ? 0xffff : 0;
1187	mask_c.alpha = 0xffff;	1160	mask_c.alpha = 0xffff;
		1161	mask_c.red =
		1162	mask_c.green =
		1163	mask_c.blue = 0;
		1164	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
		1165
		1166	mask_c.alpha = 0;
		1167	mask_c.red = 0xffff - c.r;
		1168	mask_c.green = 0xffff - c.g;
		1169	mask_c.blue = 0xffff - c.b;
		1170	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
		1171
		1172	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
		1173
		1174	if (shade > 100)
		1175	{
		1176	mask_c.alpha = 0;
		1177	mask_c.red =
		1178	mask_c.green =
		1179	mask_c.blue = 0xffff * (shade - 100) / 100;
1188	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);	1180	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1189		1181
1190	mask_c.alpha = 0;
1191	mask_c.red = 0xffff - c.r;
1192	mask_c.green = 0xffff - c.g;
1193	mask_c.blue = 0xffff - c.b;
1194	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
1195	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, 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	}
		1184
1196	ret = true;	1185	ret = true;
1197	}
1198		1186
1199	XRenderFreePicture (dpy, mask_pic);	1187	XRenderFreePicture (dpy, mask_pic);
1200	XRenderFreePicture (dpy, overlay_pic);	1188	XRenderFreePicture (dpy, overlay_pic);
1201	XRenderFreePicture (dpy, back_pic);	1189	XRenderFreePicture (dpy, back_pic);
		1190	}
1202	# endif	1191	# endif
1203	}
1204		1192
1205	return ret;	1193	return ret;
1206	}	1194	}
1207		1195
1208	/* make_transparency_pixmap()	1196	/*
1209	* Builds a pixmap of the same size as the terminal window that contains	1197	* Builds a pixmap of the same size as the terminal window that contains
1210	* the tiled portion of the root pixmap that is supposed to be covered by	1198	* the tiled portion of the root pixmap that is supposed to be covered by
1211	* our window.	1199	* our window.
1212	*/	1200	*/
1213	unsigned long	1201	unsigned long
1214	bgPixmap_t::make_transparency_pixmap ()	1202	rxvt_term::make_transparency_pixmap ()
1215	{	1203	{
1216	unsigned long result = 0;	1204	unsigned long result = 0;
1217
1218	if (target == NULL)
1219	return 0;
1220		1205
1221	/* root dimensions may change from call to call - but Display structure should	1206	/* root dimensions may change from call to call - but Display structure should
1222	* be always up-to-date, so let's use it :	1207	* be always up-to-date, so let's use it :
1223	*/	1208	*/
1224	int screen = target->display->screen;	1209	int screen = display->screen;
1225	Display *dpy = target->dpy;
1226	int root_depth = DefaultDepth (dpy, screen);	1210	int root_depth = DefaultDepth (dpy, screen);
1227	int root_width = DisplayWidth (dpy, screen);	1211	int root_width = DisplayWidth (dpy, screen);
1228	int root_height = DisplayHeight (dpy, screen);	1212	int root_height = DisplayHeight (dpy, screen);
1229	unsigned int root_pmap_width, root_pmap_height;	1213	unsigned int root_pmap_width, root_pmap_height;
1230	int window_width = target->szHint.width;	1214	int window_width = szHint.width;
1231	int window_height = target->szHint.height;	1215	int window_height = szHint.height;
1232	int sx, sy;	1216	int sx, sy;
1233	XGCValues gcv;	1217	XGCValues gcv;
1234	GC gc;	1218	GC gc;
1235		1219
1236	target->get_window_origin (sx, sy);	1220	sx = target_x;
		1221	sy = target_y;
1237		1222
1238	/* check if we are outside of the visible part of the virtual screen : */	1223	/* check if we are outside of the visible part of the virtual screen : */
1239	if (sx + window_width <= 0 || sy + window_height <= 0	1224	if (sx + window_width <= 0 || sy + window_height <= 0
1240	|| sx >= root_width || sy >= root_height)	1225	|| sx >= root_width || sy >= root_height)
1241	return 0;	1226	return 0;
…		…
1245	{	1230	{
1246	Window wdummy;	1231	Window wdummy;
1247	int idummy;	1232	int idummy;
1248	unsigned int udummy;	1233	unsigned int udummy;
1249		1234
1250	target->allowedxerror = -1;	1235	allowedxerror = -1;
1251		1236
1252	if (!XGetGeometry (dpy, root_pixmap, &wdummy, &idummy, &idummy, &root_pmap_width, &root_pmap_height, &udummy, &udummy))	1237	if (!XGetGeometry (dpy, root_pixmap, &wdummy, &idummy, &idummy, &root_pmap_width, &root_pmap_height, &udummy, &udummy))
1253	root_pixmap = None;	1238	root_pixmap = None;
1254		1239
1255	target->allowedxerror = 0;	1240	allowedxerror = 0;
1256	}	1241	}
1257		1242
1258	Pixmap recoded_root_pmap = root_pixmap;	1243	Pixmap recoded_root_pmap = root_pixmap;
1259		1244
1260	if (root_pixmap != None && root_depth != target->depth)	1245	if (root_pixmap != None && root_depth != depth)
1261	{	1246	{
1262	#if XRENDER	1247	#if XRENDER
1263	if (flags & HAS_RENDER)	1248	if (bg_flags & BG_HAS_RENDER)
1264	{	1249	{
1265	XRenderPictureAttributes pa;	1250	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1266		1251
1267	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));	1252	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1268	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa);	1253	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1269		1254
1270	recoded_root_pmap = XCreatePixmap (dpy, target->vt, root_pmap_width, root_pmap_height, target->depth);
1271	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, target->visual);	1255	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1272	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa);	1256	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1273		1257
1274	if (src && dst)
1275	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);
1276	else
1277	{
1278	XFreePixmap (dpy, recoded_root_pmap);
1279	root_pixmap = None;
1280	}
1281		1259
1282	XRenderFreePicture (dpy, src);	1260	XRenderFreePicture (dpy, src);
1283	XRenderFreePicture (dpy, dst);	1261	XRenderFreePicture (dpy, dst);
1284	}	1262	}
1285	else	1263	else
1286	#endif	1264	#endif
1287	root_pixmap = None;	1265	recoded_root_pmap = None;
1288	}	1266	}
1289		1267
1290	if (root_pixmap == None)	1268	if (recoded_root_pmap == None)
1291	return 0;	1269	return 0;
1292		1270
		1271	if (bg_pixmap == None
		1272	|| bg_pmap_width != window_width
		1273	|| bg_pmap_height != window_height)
		1274	{
		1275	if (bg_pixmap)
		1276	XFreePixmap (dpy, bg_pixmap);
1293	Pixmap tiled_root_pmap = XCreatePixmap (dpy, target->vt, window_width, window_height, target->depth);	1277	bg_pixmap = XCreatePixmap (dpy, vt, window_width, window_height, depth);
1294		1278	bg_pmap_width = window_width;
1295	if (tiled_root_pmap == None) /* something really bad happened - abort */	1279	bg_pmap_height = window_height;
1296	return 0;	1280	}
1297		1281
1298	/* straightforward pixmap copy */	1282	/* straightforward pixmap copy */
		1283	while (sx < 0) sx += root_pmap_width;
		1284	while (sy < 0) sy += root_pmap_height;
		1285
1299	gcv.tile = recoded_root_pmap;	1286	gcv.tile = recoded_root_pmap;
1300	gcv.fill_style = FillTiled;	1287	gcv.fill_style = FillTiled;
1301
1302	while (sx < 0) sx += (int)root_width;
1303	while (sy < 0) sy += (int)root_height;
1304
1305	gcv.ts_x_origin = -sx;	1288	gcv.ts_x_origin = -sx;
1306	gcv.ts_y_origin = -sy;	1289	gcv.ts_y_origin = -sy;
1307	gc = XCreateGC (dpy, target->vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);	1290	gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1308		1291
1309	if (gc)	1292	if (gc)
1310	{	1293	{
1311	XFillRectangle (dpy, tiled_root_pmap, gc, 0, 0, window_width, window_height);	1294	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1312	result |= transpPmapTiled;	1295	result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS);
		1296
		1297	if (!(bg_flags & BG_CLIENT_RENDER))
		1298	{
		1299	if (bg_flags & BG_NEEDS_BLUR)
		1300	{
		1301	if (blur_pixmap (bg_pixmap, visual, window_width, window_height))
		1302	result &= ~BG_NEEDS_BLUR;
		1303	}
		1304	if (bg_flags & BG_NEEDS_TINT)
		1305	{
		1306	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
		1307	result &= ~BG_NEEDS_TINT;
		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
		1323	} /* server side rendering completed */
		1324
1313	XFreeGC (dpy, gc);	1325	XFreeGC (dpy, gc);
1314
1315	if (!need_client_side_rendering ())
1316	{
1317	if ((flags & blurNeeded)
1318	&& (flags & HAS_RENDER_CONV))
1319	{
1320	if (blur_pixmap (tiled_root_pmap, target->visual, window_width, window_height))
1321	result |= transpPmapBlurred;
1322	}
1323	if ((flags & tintNeeded)
1324	&& (flags & (tintWholesome | HAS_RENDER)))
1325	{
1326	if (tint_pixmap (tiled_root_pmap, target->visual, window_width, window_height))
1327	result |= transpPmapTinted;
1328	}
1329	} /* server side rendering completed */
1330
1331	if (pixmap)
1332	XFreePixmap (dpy, pixmap);
1333
1334	pixmap = tiled_root_pmap;
1335	pmap_width = window_width;
1336	pmap_height = window_height;
1337	pmap_depth = target->depth;
1338	}	1326	}
1339	else
1340	XFreePixmap (dpy, tiled_root_pmap);
1341		1327
1342	if (recoded_root_pmap != root_pixmap)	1328	if (recoded_root_pmap != root_pixmap)
1343	XFreePixmap (dpy, recoded_root_pmap);	1329	XFreePixmap (dpy, recoded_root_pmap);
1344		1330
1345	return result;	1331	return result;
1346	}	1332	}
1347		1333
1348	void	1334	void
1349	bgPixmap_t::set_root_pixmap ()	1335	rxvt_term::bg_set_root_pixmap ()
1350	{	1336	{
1351	Pixmap new_root_pixmap = target->get_pixmap_property (XA_XROOTPMAP_ID);	1337	Pixmap new_root_pixmap = get_pixmap_property (xa[XA_XROOTPMAP_ID]);
1352	if (new_root_pixmap == None)	1338	if (new_root_pixmap == None)
1353	new_root_pixmap = target->get_pixmap_property (XA_ESETROOT_PMAP_ID);	1339	new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]);
1354		1340
1355	root_pixmap = new_root_pixmap;	1341	root_pixmap = new_root_pixmap;
1356	}	1342	}
1357	# endif /* ENABLE_TRANSPARENCY */	1343	# endif /* ENABLE_TRANSPARENCY */
1358		1344
1359	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)	1345	bool
1360	static void ShadeXImage(Visual *visual, XImage *srcImage, int shade, const rgba &c);	1346	rxvt_term::bg_render ()
		1347	{
		1348	unsigned long tr_flags = 0;
		1349
		1350	bg_invalidate ();
		1351	# ifdef ENABLE_TRANSPARENCY
		1352	if (bg_flags & BG_IS_TRANSPARENT)
		1353	{
		1354	/* we need to re-generate transparency pixmap in that case ! */
		1355	tr_flags = make_transparency_pixmap ();
		1356	if (tr_flags == 0)
		1357	return false;
		1358	bg_flags |= BG_IS_VALID;
		1359	}
1361	# endif	1360	# endif
1362		1361
1363	bool	1362	# ifdef BG_IMAGE_FROM_FILE
1364	bgPixmap_t::render ()	1363	if ((bg_flags & BG_IS_FROM_FILE)
1365	{	1364	|| (tr_flags & BG_EFFECTS_FLAGS))
1366	unsigned long background_flags = 0;
1367
1368	if (target == NULL)
1369	return false;
1370
1371	invalidate ();
1372	# ifdef ENABLE_TRANSPARENCY
1373	if (flags & isTransparent)
1374	{	1365	{
1375	/* we need to re-generate transparency pixmap in that case ! */	1366	if (render_image (tr_flags))
1376	background_flags = make_transparency_pixmap ();	1367	bg_flags |= BG_IS_VALID;
1377	if (background_flags == 0)
1378	return false;
1379	else if ((background_flags & transpTransformations) == (flags & transpTransformations))
1380	flags = flags & ~isInvalid;
1381	}	1368	}
1382	# endif	1369	# endif
1383		1370
1384	# ifdef BG_IMAGE_FROM_FILE	1371	if (!(bg_flags & BG_IS_VALID))
1385	if (have_image
1386	|| (background_flags & transpTransformations) != (flags & transpTransformations))
1387	{
1388	if (render_image (background_flags))
1389	flags = flags & ~isInvalid;
1390	}	1372	{
1391	# endif
1392
1393	# if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1394	XImage *result = NULL;
1395
1396	if (background_flags && (flags & isInvalid))
1397	{
1398	result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap);
1399	}
1400
1401	if (result)
1402	{
1403	/* our own client-side tinting */
1404	if (!(background_flags & transpPmapTinted) && (flags & tintNeeded))
1405	{
1406	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1407	if (flags & tintSet)
1408	tint.get (c);
1409	ShadeXImage (DefaultVisual (target->dpy, target->display->screen), result, shade, c);
1410	}
1411
1412	GC gc = XCreateGC (target->dpy, target->vt, 0UL, NULL);
1413
1414	if (gc)
1415	{
1416	XPutImage (target->dpy, pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1417
1418	XFreeGC (target->dpy, gc);
1419	flags = flags & ~isInvalid;
1420	}
1421
1422	XDestroyImage (result);
1423	}
1424	# endif
1425
1426	if (flags & isInvalid)
1427	{
1428	if (pixmap != None)	1373	if (bg_pixmap != None)
1429	{	1374	{
1430	XFreePixmap (target->dpy, pixmap);	1375	XFreePixmap (dpy, bg_pixmap);
1431	pixmap = None;	1376	bg_pixmap = None;
1432	}	1377	}
1433	}	1378	}
1434		1379
1435	apply ();	1380	scr_recolour (false);
		1381	bg_flags |= BG_NEEDS_REFRESH;
1436		1382
1437	valid_since = ev::now ();	1383	bg_valid_since = ev::now ();
1438		1384
1439	return true;	1385	return true;
1440	}	1386	}
1441		1387
1442	void	1388	void
1443	bgPixmap_t::set_target (rxvt_term *new_target)	1389	rxvt_term::bg_init ()
1444	{	1390	{
1445	target = new_target;	1391	#ifdef ENABLE_TRANSPARENCY
		1392	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
		1393	tint.set (this, c);
		1394	shade = 100;
		1395	#endif
1446		1396
1447	flags &= ~(HAS_RENDER | HAS_RENDER_CONV);	1397	bg_flags &= ~(BG_HAS_RENDER | BG_HAS_RENDER_CONV);
1448	#if XRENDER	1398	#if XRENDER
1449	int major, minor;	1399	int major, minor;
1450	if (XRenderQueryVersion (target->dpy, &major, &minor))	1400	if (XRenderQueryVersion (dpy, &major, &minor))
1451	flags |= HAS_RENDER;	1401	bg_flags |= BG_HAS_RENDER;
1452	XFilters *filters = XRenderQueryFilters (target->dpy, target->vt);	1402	XFilters *filters = XRenderQueryFilters (dpy, vt);
1453	if (filters)	1403	if (filters)
1454	{	1404	{
1455	for (int i = 0; i < filters->nfilter; i++)	1405	for (int i = 0; i < filters->nfilter; i++)
1456	if (!strcmp (filters->filter[i], FilterConvolution))	1406	if (!strcmp (filters->filter[i], FilterConvolution))
1457	flags |= HAS_RENDER_CONV;	1407	bg_flags |= BG_HAS_RENDER_CONV;
1458		1408
1459	XFree (filters);	1409	XFree (filters);
1460	}	1410	}
1461	#endif	1411	#endif
1462	}	1412	}
1463		1413
		1414	#endif /* HAVE_BG_PIXMAP */
		1415
		1416	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
		1417	/* based on code from aterm-0.4.2 */
		1418
		1419	static inline void
		1420	fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
		1421	{
		1422	for (int i = 0; i <= mask >> sh; i++)
		1423	{
		1424	uint32_t tmp;
		1425	tmp = i * high;
		1426	tmp += (mask >> sh) * low;
		1427	lookup[i] = (tmp / 0xffff) << sh;
		1428	}
		1429	}
		1430
1464	void	1431	void
1465	bgPixmap_t::apply ()	1432	rxvt_term::tint_ximage (Visual *visual, XImage *ximage)
1466	{
1467	if (target == NULL)
1468	return;
1469
1470	if (pixmap != None)
1471	{
1472	/* set target's background to pixmap */
1473	# ifdef ENABLE_TRANSPARENCY
1474	if (flags & isTransparent)
1475	{
1476	XSetWindowBackgroundPixmap (target->dpy, target->parent[0], pixmap);
1477	XSetWindowBackgroundPixmap (target->dpy, target->vt, ParentRelative);
1478
1479	if (target->scrollBar.win)
1480	XSetWindowBackgroundPixmap (target->dpy, target->scrollBar.win, ParentRelative);
1481	}
1482	else
1483	# endif
1484	{
1485	/* force old pixmap dereference in case it was transparent before :*/
1486	XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
1487	XSetWindowBackgroundPixmap (target->dpy, target->vt, pixmap);
1488	/* do we also need to set scrollbar's background here ? */
1489
1490	if (target->scrollBar.win)
1491	XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);
1492	}
1493	}
1494	else
1495	{
1496	/* set target background to a pixel */
1497	XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
1498	XSetWindowBackground (target->dpy, target->vt, target->pix_colors[Color_bg]);
1499	/* do we also need to set scrollbar's background here ? */
1500	if (target->scrollBar.win)
1501	XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);
1502	}
1503
1504	/* don't want Expose on the parent or vt. It is better to use
1505	scr_touch or we get a great deal of flicker otherwise: */
1506	XClearWindow (target->dpy, target->parent[0]);
1507
1508	if (target->scrollBar.state && target->scrollBar.win)
1509	{
1510	target->scrollBar.state = STATE_IDLE;
1511	target->scrollBar.show (0);
1512	}
1513
1514	target->want_refresh = 1;
1515	flags |= hasChanged;
1516	}
1517
1518	#endif /* HAVE_BG_PIXMAP */
1519
1520	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1521	/* taken from aterm-0.4.2 */
1522
1523	static void
1524	ShadeXImage(Visual *visual, XImage *srcImage, int shade, const rgba &c)
1525	{	1433	{
1526	int sh_r, sh_g, sh_b;	1434	int sh_r, sh_g, sh_b;
1527	uint32_t mask_r, mask_g, mask_b;	1435	uint32_t mask_r, mask_g, mask_b;
1528	uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;	1436	uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1529	rgba low;	1437	unsigned short low;
1530	rgba high;
1531	int i;
1532	int host_byte_order = byteorder.big_endian () ? MSBFirst : LSBFirst;	1438	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1533		1439
1534	if (visual->c_class != TrueColor || srcImage->format != ZPixmap) return;	1440	if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;
1535		1441
1536	/* for convenience */	1442	/* for convenience */
1537	mask_r = visual->red_mask;	1443	mask_r = visual->red_mask;
1538	mask_g = visual->green_mask;	1444	mask_g = visual->green_mask;
1539	mask_b = visual->blue_mask;	1445	mask_b = visual->blue_mask;
1540		1446
1541	/* boring lookup table pre-initialization */	1447	/* boring lookup table pre-initialization */
1542	switch (srcImage->depth)	1448	switch (ximage->depth)
1543	{	1449	{
1544	case 15:	1450	case 15:
1545	if ((mask_r != 0x7c00) ||	1451	if ((mask_r != 0x7c00) ||
1546	(mask_g != 0x03e0) ||	1452	(mask_g != 0x03e0) ||
1547	(mask_b != 0x001f))	1453	(mask_b != 0x001f))
…		…
1595	break;	1501	break;
1596	default:	1502	default:
1597	return; /* we do not support this color depth */	1503	return; /* we do not support this color depth */
1598	}	1504	}
1599		1505
		1506	rgba c;
		1507
		1508	tint.get (c);
		1509
1600	/* prepare limits for color transformation (each channel is handled separately) */	1510	/* prepare limits for color transformation (each channel is handled separately) */
1601	if (shade > 100)	1511	if (shade > 100)
1602	{	1512	{
1603	shade = 200 - shade;	1513	c.r = c.r * (200 - shade) / 100;
		1514	c.g = c.g * (200 - shade) / 100;
		1515	c.b = c.b * (200 - shade) / 100;
1604		1516
1605	high.r = (65535 - c.r) * shade / 100;	1517	low = 0xffff * (shade - 100) / 100;
1606	high.g = (65535 - c.g) * shade / 100;
1607	high.b = (65535 - c.b) * shade / 100;
1608
1609	low.r = 65535 - high.r;
1610	low.g = 65535 - high.g;
1611	low.b = 65535 - high.b;
1612	}	1518	}
1613	else	1519	else
1614	{	1520	{
1615	high.r = c.r * shade / 100;	1521	c.r = c.r * shade / 100;
1616	high.g = c.g * shade / 100;	1522	c.g = c.g * shade / 100;
1617	high.b = c.b * shade / 100;	1523	c.b = c.b * shade / 100;
1618		1524
1619	low.r = low.g = low.b = 0;	1525	low = 0;
1620	}	1526	}
1621		1527
1622	/* fill our lookup tables */	1528	/* fill our lookup tables */
1623	for (i = 0; i <= mask_r>>sh_r; i++)	1529	fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1624	{	1530	fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1625	uint32_t tmp;	1531	fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1626	tmp = i * high.r;
1627	tmp += (mask_r>>sh_r) * low.r;
1628	lookup_r[i] = (tmp/65535)<<sh_r;
1629	}
1630	for (i = 0; i <= mask_g>>sh_g; i++)
1631	{
1632	uint32_t tmp;
1633	tmp = i * high.g;
1634	tmp += (mask_g>>sh_g) * low.g;
1635	lookup_g[i] = (tmp/65535)<<sh_g;
1636	}
1637	for (i = 0; i <= mask_b>>sh_b; i++)
1638	{
1639	uint32_t tmp;
1640	tmp = i * high.b;
1641	tmp += (mask_b>>sh_b) * low.b;
1642	lookup_b[i] = (tmp/65535)<<sh_b;
1643	}
1644		1532
1645	/* apply table to input image (replacing colors by newly calculated ones) */	1533	/* apply table to input image (replacing colors by newly calculated ones) */
1646	if (srcImage->bits_per_pixel == 32	1534	if (ximage->bits_per_pixel == 32
1647	&& (srcImage->depth == 24 || srcImage->depth == 32)	1535	&& (ximage->depth == 24 || ximage->depth == 32)
1648	&& srcImage->byte_order == host_byte_order)	1536	&& ximage->byte_order == host_byte_order)
1649	{	1537	{
1650	uint32_t *p1, *pf, *p, *pl;	1538	uint32_t *p1, *pf, *p, *pl;
1651	p1 = (uint32_t *) srcImage->data;	1539	p1 = (uint32_t *) ximage->data;
1652	pf = (uint32_t *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);	1540	pf = (uint32_t *) (ximage->data + ximage->height * ximage->bytes_per_line);
1653		1541
1654	while (p1 < pf)	1542	while (p1 < pf)
1655	{	1543	{
1656	p = p1;	1544	p = p1;
1657	pl = p1 + srcImage->width;	1545	pl = p1 + ximage->width;
1658	for (; p < pl; p++)	1546	for (; p < pl; p++)
1659	{	1547	{
1660	*p = lookup_r[(*p & 0xff0000) >> 16] |	1548	*p = lookup_r[(*p & 0xff0000) >> 16] |
1661	lookup_g[(*p & 0x00ff00) >> 8] |	1549	lookup_g[(*p & 0x00ff00) >> 8] |
1662	lookup_b[(*p & 0x0000ff)] |	1550	lookup_b[(*p & 0x0000ff)] |
1663	(*p & 0xff000000);	1551	(*p & 0xff000000);
1664	}	1552	}
1665	p1 = (uint32_t *) ((char *) p1 + srcImage->bytes_per_line);	1553	p1 = (uint32_t *) ((char *) p1 + ximage->bytes_per_line);
1666	}	1554	}
1667	}	1555	}
1668	else	1556	else
1669	{	1557	{
1670	for (int y = 0; y < srcImage->height; y++)	1558	for (int y = 0; y < ximage->height; y++)
1671	for (int x = 0; x < srcImage->width; x++)	1559	for (int x = 0; x < ximage->width; x++)
1672	{	1560	{
1673	unsigned long pixel = XGetPixel (srcImage, x, y);	1561	unsigned long pixel = XGetPixel (ximage, x, y);
1674	pixel = lookup_r[(pixel & mask_r) >> sh_r] |	1562	pixel = lookup_r[(pixel & mask_r) >> sh_r] |
1675	lookup_g[(pixel & mask_g) >> sh_g] |	1563	lookup_g[(pixel & mask_g) >> sh_g] |
1676	lookup_b[(pixel & mask_b) >> sh_b];	1564	lookup_b[(pixel & mask_b) >> sh_b];
1677	XPutPixel (srcImage, x, y, pixel);	1565	XPutPixel (ximage, x, y, pixel);
1678	}	1566	}
1679	}	1567	}
1680		1568
1681	free (lookup);	1569	free (lookup);
1682	}	1570	}

Diff Legend

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