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

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.162 by sf-exg, Thu Aug 11 12:27:26 2011 UTC vs.
Revision 1.201 by sf-exg, Sat Feb 4 21:47:06 2012 UTC

…		…
20	* You should have received a copy of the GNU General Public License	20	* You should have received a copy of the GNU General Public License
21	* along with this program; if not, write to the Free Software	21	* along with this program; if not, write to the Free Software
22	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	22	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23	---------------------------------------------------------------------/	23	---------------------------------------------------------------------/
24		24
25	#include <cmath>	25	#include <math.h>
26	#include "../config.h" /* NECESSARY */	26	#include "../config.h" /* NECESSARY */
27	#include "rxvt.h" /* NECESSARY */	27	#include "rxvt.h" /* NECESSARY */
28		28
29	#if XRENDER	29	#if XRENDER
30	# include <X11/extensions/Xrender.h>	30	# include <X11/extensions/Xrender.h>
…		…
32		32
33	#ifndef FilterConvolution	33	#ifndef FilterConvolution
34	#define FilterConvolution "convolution"	34	#define FilterConvolution "convolution"
35	#endif	35	#endif
36		36
37	/*	37	#ifndef RepeatPad
38	* Pixmap geometry string interpretation :	38	#define RepeatPad True
39	* Each geometry string contains zero or one scale/position	39	#endif
40	* adjustment and may optionally be followed by a colon and one or more
41	* colon-delimited pixmap operations.
42	* The following table shows the valid geometry strings and their
43	* effects on the background image :
44	*
45	* WxH+X+Y Set scaling to W% by H%, and position to X% by Y%.
46	* W and H are percentages of the terminal window size.
47	* X and Y are also percentages; e.g., +50+50 centers
48	* the image in the window.
49	*
50	* Pixmap Operations : (should be prepended by a colon)
51	*/
52		40
53	#ifdef HAVE_BG_PIXMAP	41	#ifdef HAVE_BG_PIXMAP
		42	# if XRENDER
		43	static Picture
		44	create_xrender_mask (Display *dpy, Drawable drawable, Bool argb, Bool component_alpha)
		45	{
		46	Pixmap pixmap = XCreatePixmap (dpy, drawable, 1, 1, argb ? 32 : 8);
		47
		48	XRenderPictFormat *format = XRenderFindStandardFormat (dpy, argb ? PictStandardARGB32 : PictStandardA8);
		49	XRenderPictureAttributes pa;
		50	pa.repeat = True;
		51	pa.component_alpha = component_alpha;
		52	Picture mask = XRenderCreatePicture (dpy, pixmap, format, CPRepeat \| CPComponentAlpha, &pa);
		53
		54	XFreePixmap (dpy, pixmap);
		55
		56	return mask;
		57	}
		58	# endif
		59
54	void	60	void
55	rxvt_term::bg_destroy ()	61	rxvt_term::bg_destroy ()
56	{	62	{
57	#ifdef HAVE_AFTERIMAGE
58	if (original_asim)
59	safe_asimage_destroy (original_asim);
60	if (asv)
61	destroy_asvisual (asv, 0);
62	if (asimman)
63	destroy_image_manager (asimman, 0);
64	#endif
65
66	#ifdef HAVE_PIXBUF	63	#ifdef HAVE_PIXBUF
67	if (pixbuf)	64	if (pixbuf)
68	g_object_unref (pixbuf);	65	g_object_unref (pixbuf);
69	#endif	66	#endif
70		67
…		…
123		120
124	return false;	121	return false;
125	}	122	}
126		123
127	# ifdef BG_IMAGE_FROM_FILE	124	# ifdef BG_IMAGE_FROM_FILE
128	static inline bool
129	check_set_scale_value (int geom_flags, int flag, unsigned int &scale, unsigned int new_value)
130	{
131	if (geom_flags & flag)
132	{
133	if (new_value > 1000)
134	new_value = 1000;
135	if (new_value != scale)
136	{
137	scale = new_value;
138	return true;
139	}
140	}
141	return false;
142	}
143
144	static inline bool
145	check_set_align_value (int geom_flags, int flag, int &align, int new_value)
146	{
147	if (geom_flags & flag)
148	{
149	if (new_value < -100)
150	new_value = -100;
151	else if (new_value > 200)
152	new_value = 200;
153	if (new_value != align)
154	{
155	align = new_value;
156	return true;
157	}
158	}
159	return false;
160	}
161
162	static inline int	125	static inline int
163	make_align_position (int align, int window_size, int image_size)	126	make_align_position (int align, int window_size, int image_size)
164	{	127	{
165	int diff = window_size - image_size;	128	int diff = window_size - image_size;
166	int smaller = min (image_size, window_size);	129	int smaller = min (image_size, window_size);
167		130
168	if (align >= 0 && align <= 100)	131	if (align >= 0 && align <= 100)
169	return diff * align / 100;	132	return diff * align / 100;
170	else if (align > 100 && align <= 200)	133	else if (align > 100 && align <= 200)
171	return ((align - 100) * smaller / 100) + window_size - smaller;	134	return (align - 100) * smaller / 100 + window_size - smaller;
172	else if (align >= -100 && align < 0)	135	else if (align >= -100 && align < 0)
173	return ((align + 100) * smaller / 100) - image_size;	136	return (align + 100) * smaller / 100 - image_size;
174	return 0;	137	return 0;
175	}	138	}
176		139
177	static inline int	140	static inline int
178	make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)	141	make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)
…		…
185	src_pos = -pos;	148	src_pos = -pos;
186	dst_pos = 0;	149	dst_pos = 0;
187	dst_size += pos;	150	dst_size += pos;
188	}	151	}
189		152
190	if (dst_pos + dst_size > target_size)
191	dst_size = target_size - dst_pos;	153	min_it (dst_size, target_size - dst_pos);
192	return src_pos;	154	return src_pos;
193	}	155	}
194		156
195	bool	157	bool
196	rxvt_term::bg_set_geometry (const char *geom, bool update)	158	rxvt_term::bg_set_geometry (const char *geom, bool update)
197	{	159	{
198	bool changed = false;	160	bool changed = false;
199	int geom_flags = 0;	161	int geom_flags = 0;
200	int x = 0, y = 0;	162	int x = h_align;
		163	int y = v_align;
201	unsigned int w = 0, h = 0;	164	unsigned int w = h_scale;
202	unsigned int n;	165	unsigned int h = v_scale;
203	unsigned long new_flags = (bg_flags & (~BG_GEOMETRY_FLAGS));	166	unsigned long new_flags = 0;
204	const char *ops;
205		167
206	if (geom == NULL)	168	if (geom == NULL)
207	return false;	169	return false;
208		170
209	char str[256];	171	if (geom[0])
210
211	ops = strchr (geom, ':');
212	if (ops == NULL)
213	n = strlen (geom);
214	else
215	n = ops - geom;
216
217	if (n >= sizeof (str))
218	return false;
219
220	memcpy (str, geom, n);
221	str[n] = '\0';
222	rxvt_strtrim (str);
223
224	if (str[0])
225	{	172	{
226	/* we have geometry string - let's handle it prior to applying ops */	173	char **arr = rxvt_strsplit (':', geom);
		174
		175	for (int i = 0; arr[i]; i++)
		176	{
		177	if (!strcasecmp (arr[i], "style=tiled"))
		178	{
		179	new_flags = BG_TILE;
		180	w = h = noScale;
		181	x = y = 0;
		182	geom_flags = WidthValue\|HeightValue\|XValue\|YValue;
		183	}
		184	else if (!strcasecmp (arr[i], "style=aspect-stretched"))
		185	{
		186	new_flags = BG_KEEP_ASPECT;
		187	w = h = windowScale;
		188	x = y = centerAlign;
		189	geom_flags = WidthValue\|HeightValue\|XValue\|YValue;
		190	}
		191	else if (!strcasecmp (arr[i], "style=stretched"))
		192	{
		193	new_flags = 0;
		194	w = h = windowScale;
		195	geom_flags = WidthValue\|HeightValue;
		196	}
		197	else if (!strcasecmp (arr[i], "style=centered"))
		198	{
		199	new_flags = 0;
		200	w = h = noScale;
		201	x = y = centerAlign;
		202	geom_flags = WidthValue\|HeightValue\|XValue\|YValue;
		203	}
		204	else if (!strcasecmp (arr[i], "style=root-tiled"))
		205	{
		206	new_flags = BG_TILE\|BG_ROOT_ALIGN;
		207	w = h = noScale;
		208	geom_flags = WidthValue\|HeightValue;
		209	}
		210	else if (!strcasecmp (arr[i], "op=tile"))
		211	new_flags \|= BG_TILE;
		212	else if (!strcasecmp (arr[i], "op=keep-aspect"))
		213	new_flags \|= BG_KEEP_ASPECT;
		214	else if (!strcasecmp (arr[i], "op=root-align"))
		215	new_flags \|= BG_ROOT_ALIGN;
		216
		217	// deprecated
		218	else if (!strcasecmp (arr[i], "tile"))
		219	{
		220	new_flags \|= BG_TILE;
		221	w = h = noScale;
		222	geom_flags \|= WidthValue\|HeightValue;
		223	}
		224	else if (!strcasecmp (arr[i], "propscale"))
		225	{
		226	new_flags \|= BG_KEEP_ASPECT;
		227	w = h = windowScale;
		228	geom_flags \|= WidthValue\|HeightValue;
		229	}
		230	else if (!strcasecmp (arr[i], "hscale"))
		231	{
		232	new_flags \|= BG_TILE;
		233	w = windowScale;
		234	h = noScale;
		235	geom_flags \|= WidthValue\|HeightValue;
		236	}
		237	else if (!strcasecmp (arr[i], "vscale"))
		238	{
		239	new_flags \|= BG_TILE;
		240	h = windowScale;
		241	w = noScale;
		242	geom_flags \|= WidthValue\|HeightValue;
		243	}
		244	else if (!strcasecmp (arr[i], "scale"))
		245	{
		246	w = h = windowScale;
		247	geom_flags \|= WidthValue\|HeightValue;
		248	}
		249	else if (!strcasecmp (arr[i], "auto"))
		250	{
		251	w = h = windowScale;
		252	x = y = centerAlign;
		253	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;
		254	}
		255	else if (!strcasecmp (arr[i], "root"))
		256	{
		257	new_flags \|= BG_TILE\|BG_ROOT_ALIGN;
		258	w = h = noScale;
		259	geom_flags \|= WidthValue\|HeightValue;
		260	}
		261
		262	else
227	geom_flags = XParseGeometry (str, &x, &y, &w, &h);	263	geom_flags \|= XParseGeometry (arr[i], &x, &y, &w, &h);
228	} /* done parsing geometry string */	264	} /* done parsing ops */
		265
		266	rxvt_free_strsplit (arr);
		267	}
		268
		269	new_flags \|= bg_flags & ~BG_GEOMETRY_FLAGS;
229		270
230	if (!update)	271	if (!update)
231	{	272	{
232	if (!(geom_flags & XValue))	273	if (!(geom_flags & XValue))
233	x = y = defaultAlign;	274	x = y = defaultAlign;
…		…
238	w = h = defaultScale;	279	w = h = defaultScale;
239	else if (!(geom_flags & HeightValue))	280	else if (!(geom_flags & HeightValue))
240	h = w;	281	h = w;
241	else if (!(geom_flags & WidthValue))	282	else if (!(geom_flags & WidthValue))
242	w = h;	283	w = h;
243
244	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;
245	}
246
247	if (ops)
248	{	284	}
249	char **arr = rxvt_strsplit (':', ops + 1);
250		285
251	for (int i = 0; arr[i]; i++)	286	min_it (w, 1000);
252	{	287	min_it (h, 1000);
253	if (!strcasecmp (arr[i], "style=tiled"))	288	clamp_it (x, -100, 200);
254	{	289	clamp_it (y, -100, 200);
255	new_flags = BG_TILE;
256	w = h = noScale;
257	x = y = 0;
258	geom_flags = WidthValue\|HeightValue\|XValue\|YValue;
259	}
260	else if (!strcasecmp (arr[i], "style=aspect-stretched"))
261	{
262	new_flags = BG_PROP_SCALE;
263	x = y = centerAlign;
264	geom_flags = XValue\|YValue;
265	}
266	else if (!strcasecmp (arr[i], "style=stretched"))
267	{
268	new_flags = 0;
269	w = h = windowScale;
270	geom_flags = WidthValue\|HeightValue;
271	}
272	else if (!strcasecmp (arr[i], "style=centered"))
273	{
274	new_flags = 0;
275	w = h = noScale;
276	x = y = centerAlign;
277	geom_flags = WidthValue\|HeightValue\|XValue\|YValue;
278	}
279	else if (!strcasecmp (arr[i], "style=root-tiled"))
280	{
281	new_flags = BG_TILE\|BG_ROOT_ALIGN;
282	w = h = noScale;
283	geom_flags = WidthValue\|HeightValue;
284	}
285	else if (!strcasecmp (arr[i], "op=tile"))
286	new_flags \|= BG_TILE;
287	else if (!strcasecmp (arr[i], "op=pscale"))
288	new_flags \|= BG_PROP_SCALE;
289	else if (!strcasecmp (arr[i], "op=root"))
290	new_flags \|= BG_ROOT_ALIGN;
291		290
292	// deprecated	291	if (bg_flags != new_flags
293	else if (!strcasecmp (arr[i], "tile"))	292	\|\| h_scale != w
294	{	293	\|\| v_scale != h
295	new_flags \|= BG_TILE;	294	\|\| h_align != x
296	w = h = noScale;	295	\|\| v_align != y)
297	geom_flags \|= WidthValue\|HeightValue;
298	}
299	else if (!strcasecmp (arr[i], "propscale"))
300	{
301	new_flags \|= BG_PROP_SCALE;
302	}
303	else if (!strcasecmp (arr[i], "hscale"))
304	{
305	new_flags \|= BG_TILE;
306	w = windowScale;
307	h = noScale;
308	geom_flags \|= WidthValue\|HeightValue;
309	}
310	else if (!strcasecmp (arr[i], "vscale"))
311	{
312	new_flags \|= BG_TILE;
313	h = windowScale;
314	w = noScale;
315	geom_flags \|= WidthValue\|HeightValue;
316	}
317	else if (!strcasecmp (arr[i], "scale"))
318	{
319	w = h = windowScale;
320	geom_flags \|= WidthValue\|HeightValue;
321	}
322	else if (!strcasecmp (arr[i], "auto"))
323	{
324	w = h = windowScale;
325	x = y = centerAlign;
326	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;
327	}
328	else if (!strcasecmp (arr[i], "root"))
329	{
330	new_flags \|= BG_TILE\|BG_ROOT_ALIGN;
331	w = h = noScale;
332	geom_flags \|= WidthValue\|HeightValue;
333	}
334	} /* done parsing ops */
335
336	rxvt_free_strsplit (arr);
337	}
338
339	if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true;
340	if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true;
341	if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true;
342	if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true;
343
344	if (new_flags != bg_flags)
345	{	296	{
346	bg_flags = new_flags;	297	bg_flags = new_flags;
		298	h_scale = w;
		299	v_scale = h;
		300	h_align = x;
		301	v_align = y;
347	changed = true;	302	changed = true;
348	}	303	}
349		304
350	return changed;	305	return changed;
351	}	306	}
…		…
354	rxvt_term::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y)	309	rxvt_term::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y)
355	{	310	{
356	int target_width = szHint.width;	311	int target_width = szHint.width;
357	int target_height = szHint.height;	312	int target_height = szHint.height;
358		313
		314	w = h_scale * target_width / 100;
		315	h = v_scale * target_height / 100;
		316
359	if (bg_flags & BG_PROP_SCALE)	317	if (bg_flags & BG_KEEP_ASPECT)
360	{	318	{
361	float scale = (float)target_width / image_width;	319	float scale = (float)w / image_width;
362	min_it (scale, (float)target_height / image_height);	320	min_it (scale, (float)h / image_height);
363	w = image_width * scale + 0.5;	321	w = image_width * scale + 0.5;
364	h = image_height * scale + 0.5;	322	h = image_height * scale + 0.5;
365	}	323	}
366	else
367	{
368	w = h_scale * target_width / 100;
369	h = v_scale * target_height / 100;
370	}
371		324
372	if (!w) w = image_width;	325	if (!w) w = image_width;
373	if (!h) h = image_height;	326	if (!h) h = image_height;
374		327
375	if (bg_flags & BG_ROOT_ALIGN)	328	if (bg_flags & BG_ROOT_ALIGN)
…		…
383	y = make_align_position (v_align, target_height, h);	336	y = make_align_position (v_align, target_height, h);
384	}	337	}
385		338
386	bg_flags &= ~BG_IS_SIZE_SENSITIVE;	339	bg_flags &= ~BG_IS_SIZE_SENSITIVE;
387	if (!(bg_flags & BG_TILE)	340	if (!(bg_flags & BG_TILE)
388	\|\| (bg_flags & BG_PROP_SCALE) \|\| h_scale \|\| v_scale	341	\|\| h_scale \|\| v_scale
389	\|\| (!(bg_flags & BG_ROOT_ALIGN) && (h_align \|\| v_align))	342	\|\| (!(bg_flags & BG_ROOT_ALIGN) && (h_align \|\| v_align))
390	\|\| w > target_width \|\| h > target_height)	343	\|\| w > target_width \|\| h > target_height)
391	bg_flags \|= BG_IS_SIZE_SENSITIVE;	344	bg_flags \|= BG_IS_SIZE_SENSITIVE;
392	}	345	}
393
394	# ifdef HAVE_AFTERIMAGE
395	bool
396	rxvt_term::render_image (unsigned long tr_flags)
397	{
398	init_asv ();
399
400	ASImage *background = NULL;
401	ARGB32 background_tint = TINT_LEAVE_SAME;
402
403	# ifdef ENABLE_TRANSPARENCY
404	if (tr_flags)
405	background = pixmap2ximage (asv, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, 100);
406
407	if (tr_flags & BG_NEEDS_TINT)
408	{
409	ShadingInfo as_shade;
410	as_shade.shading = shade;
411
412	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
413	if (bg_flags & BG_TINT_SET)
414	tint.get (c);
415	as_shade.tintColor.red = c.r;
416	as_shade.tintColor.green = c.g;
417	as_shade.tintColor.blue = c.b;
418
419	background_tint = shading2tint32 (&as_shade);
420	}
421
422	if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)
423	{
424	ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,
425	(original_asim == NULL \|\| tint == TINT_LEAVE_SAME) ? ASA_XImage : ASA_ASImage,
426	100, ASIMAGE_QUALITY_DEFAULT);
427	if (tmp)
428	{
429	destroy_asimage (&background);
430	background = tmp;
431	}
432	}
433	# endif
434
435	ASImage *result = 0;
436
437	int target_width = szHint.width;
438	int target_height = szHint.height;
439	int new_pmap_width = target_width;
440	int new_pmap_height = target_height;
441
442	int x = 0;
443	int y = 0;
444	int w = 0;
445	int h = 0;
446
447	if (original_asim)
448	get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
449
450	if (!original_asim
451	\|\| (!(bg_flags & BG_ROOT_ALIGN)
452	&& (x >= target_width
453	\|\| y >= target_height
454	\|\| (x + w <= 0)
455	\|\| (y + h <= 0))))
456	{
457	if (background)
458	{
459	new_pmap_width = background->width;
460	new_pmap_height = background->height;
461	result = background;
462
463	if (background_tint != TINT_LEAVE_SAME)
464	{
465	ASImage *tmp = tile_asimage (asv, background, 0, 0,
466	target_width, target_height, background_tint,
467	ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
468	if (tmp)
469	result = tmp;
470	}
471	}
472	else
473	new_pmap_width = new_pmap_height = 0;
474	}
475	else
476	{
477	result = original_asim;
478
479	if ((w != original_asim->width)
480	\|\| (h != original_asim->height))
481	{
482	result = scale_asimage (asv, original_asim,
483	w, h,
484	background ? ASA_ASImage : ASA_XImage,
485	100, ASIMAGE_QUALITY_DEFAULT);
486	}
487
488	if (background == NULL)
489	{
490	if (bg_flags & BG_TILE)
491	{
492	/* if tiling - pixmap has to be sized exactly as the image,
493	but there is no need to make it bigger than the window! */
494	new_pmap_width = min (result->width, target_width);
495	new_pmap_height = min (result->height, target_height);
496
497	/* we also need to tile our image in both directions */
498	ASImage *tmp = tile_asimage (asv, result,
499	(int)result->width - x,
500	(int)result->height - y,
501	new_pmap_width,
502	new_pmap_height,
503	TINT_LEAVE_SAME, ASA_XImage,
504	100, ASIMAGE_QUALITY_DEFAULT);
505	if (tmp)
506	{
507	if (result != original_asim)
508	destroy_asimage (&result);
509
510	result = tmp;
511	}
512	}
513	}
514	else
515	{
516	/* if blending background and image - pixmap has to be sized same as target window */
517	ASImageLayer *layers = create_image_layers (2);
518
519	layers[0].im = background;
520	layers[0].clip_width = target_width;
521	layers[0].clip_height = target_height;
522	layers[0].tint = background_tint;
523	layers[1].im = result;
524
525	if (bg_flags & BG_TILE)
526	{
527	/* tile horizontally */
528	while (x > 0) x -= (int)result->width;
529	layers[1].dst_x = x;
530	layers[1].clip_width = result->width+target_width;
531	}
532	else
533	{
534	/* clip horizontally */
535	layers[1].dst_x = x;
536	layers[1].clip_width = result->width;
537	}
538
539	if (bg_flags & BG_TILE)
540	{
541	while (y > 0) y -= (int)result->height;
542	layers[1].dst_y = y;
543	layers[1].clip_height = result->height + target_height;
544	}
545	else
546	{
547	layers[1].dst_y = y;
548	layers[1].clip_height = result->height;
549	}
550
551	if (rs[Rs_blendtype])
552	{
553	layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
554	if (layers[1].merge_scanlines == NULL)
555	layers[1].merge_scanlines = alphablend_scanlines;
556	}
557
558	ASImage *tmp = merge_layers (asv, layers, 2, target_width, target_height,
559	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
560
561	if (tmp)
562	{
563	if (result != original_asim)
564	destroy_asimage (&result);
565
566	result = tmp;
567	}
568
569	free (layers);
570	}
571	}
572
573	bool ret = false;
574
575	if (result)
576	{
577	XGCValues gcv;
578	GC gc;
579
580	/* create Pixmap */
581	if (bg_pixmap == None
582	\|\| bg_pmap_width != new_pmap_width
583	\|\| bg_pmap_height != new_pmap_height)
584	{
585	if (bg_pixmap)
586	XFreePixmap (dpy, bg_pixmap);
587	bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
588	bg_pmap_width = new_pmap_width;
589	bg_pmap_height = new_pmap_height;
590	}
591	/* fill with background color (if result's not completely overlapping it) */
592	gcv.foreground = pix_colors[Color_bg];
593	gc = XCreateGC (dpy, vt, GCForeground, &gcv);
594
595	int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
596	int dst_width = result->width, dst_height = result->height;
597	if (background == NULL)
598	{
599	if (!(bg_flags & BG_TILE))
600	{
601	src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );
602	src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
603	}
604
605	if (dst_x > 0 \|\| dst_y > 0
606	\|\| dst_x + dst_width < new_pmap_width
607	\|\| dst_y + dst_height < new_pmap_height)
608	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
609	}
610
611	/* put result on pixmap */
612	if (dst_x < new_pmap_width && dst_y < new_pmap_height)
613	asimage2drawable (asv, bg_pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);
614
615	if (result != background && result != original_asim)
616	destroy_asimage (&result);
617
618	XFreeGC (dpy, gc);
619
620	ret = true;
621	}
622
623	if (background)
624	destroy_asimage (&background);
625
626	return ret;
627	}
628	# endif /* HAVE_AFTERIMAGE */
629		346
630	# ifdef HAVE_PIXBUF	347	# ifdef HAVE_PIXBUF
631	bool	348	bool
632	rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,	349	rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
633	int src_x, int src_y, int dst_x, int dst_y,	350	int src_x, int src_y, int dst_x, int dst_y,
…		…
739	get_image_geometry (image_width, image_height, w, h, x, y);	456	get_image_geometry (image_width, image_height, w, h, x, y);
740		457
741	if (!(bg_flags & BG_ROOT_ALIGN)	458	if (!(bg_flags & BG_ROOT_ALIGN)
742	&& (x >= target_width	459	&& (x >= target_width
743	\|\| y >= target_height	460	\|\| y >= target_height
744	\|\| (x + w <= 0)	461	\|\| x + w <= 0
745	\|\| (y + h <= 0)))	462	\|\| y + h <= 0))
746	return false;	463	return false;
747		464
748	result = pixbuf;	465	result = pixbuf;
749		466
750	if ((w != image_width)	467	if (w != image_width
751	\|\| (h != image_height))	468	\|\| h != image_height)
752	{	469	{
753	result = gdk_pixbuf_scale_simple (pixbuf,	470	result = gdk_pixbuf_scale_simple (pixbuf,
754	w, h,	471	w, h,
755	GDK_INTERP_BILINEAR);	472	GDK_INTERP_BILINEAR);
756	}	473	}
…		…
835	}	552	}
836		553
837	#if XRENDER	554	#if XRENDER
838	if (tr_flags)	555	if (tr_flags)
839	{	556	{
840	XRenderPictureAttributes pa;
841
842	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, visual);	557	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
		558
843	Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa);	559	Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
844		560
845	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
846	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, dst_format, 0, &pa);	561	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
847		562
848	pa.repeat = True;	563	Picture mask = create_xrender_mask (dpy, vt, False, False);
849	Pixmap mask_pmap = XCreatePixmap (dpy, vt, 1, 1, 8);
850	XRenderPictFormat *mask_format = XRenderFindStandardFormat (dpy, PictStandardA8);
851	Picture mask = XRenderCreatePicture (dpy, mask_pmap, mask_format, CPRepeat, &pa);
852	XFreePixmap (dpy, mask_pmap);
853		564
854	XRenderColor mask_c;	565	XRenderColor mask_c;
855		566
856	mask_c.alpha = 0x8000;	567	mask_c.alpha = 0x8000;
857	mask_c.red = 0;	568	mask_c.red =
858	mask_c.green = 0;	569	mask_c.green =
859	mask_c.blue = 0;	570	mask_c.blue = 0;
860	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);	571	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
		572
861	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);	573	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
862		574
863	XRenderFreePicture (dpy, src);	575	XRenderFreePicture (dpy, src);
864	XRenderFreePicture (dpy, dst);	576	XRenderFreePicture (dpy, dst);
865	XRenderFreePicture (dpy, mask);	577	XRenderFreePicture (dpy, mask);
…		…
885	rxvt_term::bg_set_file (const char *file)	597	rxvt_term::bg_set_file (const char *file)
886	{	598	{
887	if (!file \|\| !*file)	599	if (!file \|\| !*file)
888	return false;	600	return false;
889		601
		602	bool ret = false;
890	if (const char *p = strchr (file, ';'))	603	const char *p = strchr (file, ';');
		604
		605	if (p)
891	{	606	{
892	size_t len = p - file;	607	size_t len = p - file;
893	char *f = rxvt_temp_buf<char> (len + 1);	608	char *f = rxvt_temp_buf<char> (len + 1);
894	memcpy (f, file, len);	609	memcpy (f, file, len);
895	f[len] = '\0';	610	f[len] = '\0';
896	file = f;	611	file = f;
897	}	612	}
898		613
899	# ifdef HAVE_AFTERIMAGE
900	if (!asimman)
901	asimman = create_generic_imageman (rs[Rs_path]);
902	ASImage *image = get_asimage (asimman, file, 0xFFFFFFFF, 100);
903	if (image)
904	{
905	if (original_asim)
906	safe_asimage_destroy (original_asim);
907	original_asim = image;
908	bg_flags \|= BG_IS_FROM_FILE \| BG_CLIENT_RENDER;
909	return true;
910	}
911	# endif
912
913	# ifdef HAVE_PIXBUF	614	# ifdef HAVE_PIXBUF
914	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);	615	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
915	if (image)	616	if (image)
916	{	617	{
917	if (pixbuf)	618	if (pixbuf)
918	g_object_unref (pixbuf);	619	g_object_unref (pixbuf);
919	pixbuf = image;	620	pixbuf = image;
920	bg_flags \|= BG_IS_FROM_FILE;	621	bg_flags \|= BG_IS_FROM_FILE;
921	return true;	622	ret = true;
922	}	623	}
923	# endif	624	# endif
924		625
		626	if (ret)
		627	{
		628	if (p)
		629	bg_set_geometry (p + 1);
		630	else
		631	bg_set_default_geometry ();
		632	}
		633
925	return false;	634	return ret;
926	}	635	}
927		636
928	# endif /* BG_IMAGE_FROM_FILE */	637	# endif /* BG_IMAGE_FROM_FILE */
929		638
930	# ifdef ENABLE_TRANSPARENCY	639	# ifdef ENABLE_TRANSPARENCY
…		…
966	{	675	{
967	changed = true;	676	changed = true;
968	v_blurRadius = vr;	677	v_blurRadius = vr;
969	}	678	}
970		679
971	if (v_blurRadius == 0 && h_blurRadius == 0)	680	if (h_blurRadius == 0 \|\| v_blurRadius == 0)
972	bg_flags &= ~BG_NEEDS_BLUR;	681	bg_flags &= ~BG_NEEDS_BLUR;
973	else	682	else
974	bg_flags \|= BG_NEEDS_BLUR;	683	bg_flags \|= BG_NEEDS_BLUR;
975		684
976	return changed;	685	return changed;
977	}	686	}
978		687
979	void	688	void
980	rxvt_term::set_tint_shade_flags ()	689	rxvt_term::set_tint_shade_flags ()
981	{	690	{
982	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);	691	rgba c;
983	bool has_shade = shade != 100;	692	bool has_shade = shade != 100;
984		693
985	bg_flags &= ~BG_TINT_FLAGS;	694	bg_flags &= ~BG_TINT_FLAGS;
986		695
987	if (bg_flags & BG_TINT_SET)	696	if (bg_flags & BG_TINT_SET)
…		…
1013	}	722	}
1014		723
1015	bool	724	bool
1016	rxvt_term::bg_set_shade (const char *shade_str)	725	rxvt_term::bg_set_shade (const char *shade_str)
1017	{	726	{
1018	int new_shade = (shade_str) ? atoi (shade_str) : 100;	727	int new_shade = atoi (shade_str);
1019		728
1020	clamp_it (new_shade, -100, 200);	729	clamp_it (new_shade, -100, 200);
1021	if (new_shade < 0)	730	if (new_shade < 0)
1022	new_shade = 200 - (100 + new_shade);	731	new_shade = 200 - (100 + new_shade);
1023		732
…		…
1053	params[i+2] = XDoubleToFixed (kernel[i] / sum);	762	params[i+2] = XDoubleToFixed (kernel[i] / sum);
1054	}	763	}
1055	#endif	764	#endif
1056		765
1057	bool	766	bool
1058	rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	767	rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height, int depth)
1059	{	768	{
1060	bool ret = false;	769	bool ret = false;
1061	#if XRENDER	770	#if XRENDER
		771	if (!(bg_flags & BG_HAS_RENDER_CONV))
		772	return false;
		773
1062	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;	774	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1063	double kernel = (double )malloc (size * sizeof (double));	775	double kernel = (double )malloc (size * sizeof (double));
1064	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));	776	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));
1065		777
1066	XRenderPictureAttributes pa;	778	XRenderPictureAttributes pa;
1067	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	779	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1068		780
		781	pa.repeat = RepeatPad;
1069	Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	782	Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
		783	Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1070	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	784	Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
		785	XFreePixmap (dpy, tmp);
1071		786
1072	if (kernel && params)	787	if (kernel && params)
1073	{	788	{
1074	if (h_blurRadius)
1075	{
1076	size = h_blurRadius * 2 + 1;	789	size = h_blurRadius * 2 + 1;
1077	get_gaussian_kernel (h_blurRadius, size, kernel, params);	790	get_gaussian_kernel (h_blurRadius, size, kernel, params);
1078		791
1079	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	792	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1080	XRenderComposite (dpy,	793	XRenderComposite (dpy,
1081	PictOpSrc,	794	PictOpSrc,
1082	src,	795	src,
1083	None,	796	None,
1084	dst,	797	dst,
1085	0, 0,	798	0, 0,
1086	0, 0,	799	0, 0,
1087	0, 0,	800	0, 0,
1088	width, height);	801	width, height);
1089	}
1090		802
1091	if (v_blurRadius)	803	::swap (src, dst);
1092	{	804
1093	size = v_blurRadius * 2 + 1;	805	size = v_blurRadius * 2 + 1;
1094	get_gaussian_kernel (v_blurRadius, size, kernel, params);	806	get_gaussian_kernel (v_blurRadius, size, kernel, params);
1095	::swap (params[0], params[1]);	807	::swap (params[0], params[1]);
1096		808
1097	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	809	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1098	XRenderComposite (dpy,	810	XRenderComposite (dpy,
1099	PictOpSrc,	811	PictOpSrc,
1100	src,	812	src,
1101	None,	813	None,
1102	dst,	814	dst,
1103	0, 0,	815	0, 0,
1104	0, 0,	816	0, 0,
1105	0, 0,	817	0, 0,
1106	width, height);	818	width, height);
1107	}
1108		819
1109	ret = true;	820	ret = true;
1110	}	821	}
1111		822
1112	free (kernel);	823	free (kernel);
…		…
1139	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);	850	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1140	ret = true;	851	ret = true;
1141	XFreeGC (dpy, gc);	852	XFreeGC (dpy, gc);
1142	}	853	}
1143	}	854	}
1144	else
1145	{
1146	# if XRENDER	855	# if XRENDER
		856	else if (bg_flags & BG_HAS_RENDER)
		857	{
1147	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);	858	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1148		859
1149	if (bg_flags & BG_TINT_SET)	860	if (bg_flags & BG_TINT_SET)
1150	tint.get (c);	861	tint.get (c);
1151		862
…		…
1160	c.r = c.r * (200 - shade) / 100;	871	c.r = c.r * (200 - shade) / 100;
1161	c.g = c.g * (200 - shade) / 100;	872	c.g = c.g * (200 - shade) / 100;
1162	c.b = c.b * (200 - shade) / 100;	873	c.b = c.b * (200 - shade) / 100;
1163	}	874	}
1164		875
1165	XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1166	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	876	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1167	XRenderPictureAttributes pa;
1168		877
1169	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	878	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1170		879
1171	pa.repeat = True;	880	Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1172		881
1173	Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);	882	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
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		883
1182	XRenderColor mask_c;	884	XRenderColor mask_c;
1183		885
1184	mask_c.alpha = 0xffff;	886	mask_c.alpha = 0xffff;
1185	mask_c.red =	887	mask_c.red =
…		…
1190	mask_c.alpha = 0;	892	mask_c.alpha = 0;
1191	mask_c.red = 0xffff - c.r;	893	mask_c.red = 0xffff - c.r;
1192	mask_c.green = 0xffff - c.g;	894	mask_c.green = 0xffff - c.g;
1193	mask_c.blue = 0xffff - c.b;	895	mask_c.blue = 0xffff - c.b;
1194	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);	896	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
		897
1195	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);	898	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1196		899
1197	if (shade > 100)	900	if (shade > 100)
1198	{	901	{
1199	mask_c.red = mask_c.green = mask_c.blue = 0xffff * (shade - 100) / 100;
1200	mask_c.alpha = 0;	902	mask_c.alpha = 0;
		903	mask_c.red =
		904	mask_c.green =
		905	mask_c.blue = 0xffff * (shade - 100) / 100;
1201	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);	906	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1202		907
1203	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);	908	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1204	}	909	}
1205		910
1206	ret = true;	911	ret = true;
1207		912
1208	XRenderFreePicture (dpy, mask_pic);	913	XRenderFreePicture (dpy, mask_pic);
1209	XRenderFreePicture (dpy, overlay_pic);	914	XRenderFreePicture (dpy, overlay_pic);
1210	XRenderFreePicture (dpy, back_pic);	915	XRenderFreePicture (dpy, back_pic);
		916	}
1211	# endif	917	# endif
1212	}
1213		918
1214	return ret;	919	return ret;
1215	}	920	}
1216		921
1217	/*	922	/*
…		…
1268	#if XRENDER	973	#if XRENDER
1269	if (bg_flags & BG_HAS_RENDER)	974	if (bg_flags & BG_HAS_RENDER)
1270	{	975	{
1271	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);	976	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1272		977
1273	XRenderPictureAttributes pa;
1274
1275	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));	978	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1276	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa);	979	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1277		980
1278	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);	981	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1279	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa);	982	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1280		983
1281	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);	984	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
1282		985
1283	XRenderFreePicture (dpy, src);	986	XRenderFreePicture (dpy, src);
1284	XRenderFreePicture (dpy, dst);	987	XRenderFreePicture (dpy, dst);
…		…
1301	bg_pmap_width = window_width;	1004	bg_pmap_width = window_width;
1302	bg_pmap_height = window_height;	1005	bg_pmap_height = window_height;
1303	}	1006	}
1304		1007
1305	/* straightforward pixmap copy */	1008	/* straightforward pixmap copy */
1306	while (sx < 0) sx += root_width;	1009	while (sx < 0) sx += root_pmap_width;
1307	while (sy < 0) sy += root_height;	1010	while (sy < 0) sy += root_pmap_height;
1308		1011
1309	gcv.tile = recoded_root_pmap;	1012	gcv.tile = recoded_root_pmap;
1310	gcv.fill_style = FillTiled;	1013	gcv.fill_style = FillTiled;
1311	gcv.ts_x_origin = -sx;	1014	gcv.ts_x_origin = -sx;
1312	gcv.ts_y_origin = -sy;	1015	gcv.ts_y_origin = -sy;
…		…
1314		1017
1315	if (gc)	1018	if (gc)
1316	{	1019	{
1317	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);	1020	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1318	result \|= BG_IS_VALID \| (bg_flags & BG_EFFECTS_FLAGS);	1021	result \|= BG_IS_VALID \| (bg_flags & BG_EFFECTS_FLAGS);
1319	XFreeGC (dpy, gc);
1320		1022
1321	if (!(bg_flags & BG_CLIENT_RENDER))	1023	if (!(bg_flags & BG_CLIENT_RENDER))
1322	{	1024	{
1323	if ((bg_flags & BG_NEEDS_BLUR)	1025	if (bg_flags & BG_NEEDS_BLUR)
1324	&& (bg_flags & BG_HAS_RENDER_CONV))
1325	{	1026	{
1326	if (blur_pixmap (bg_pixmap, visual, window_width, window_height))	1027	if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth))
1327	result &= ~BG_NEEDS_BLUR;	1028	result &= ~BG_NEEDS_BLUR;
1328	}	1029	}
1329	if ((bg_flags & BG_NEEDS_TINT)	1030	if (bg_flags & BG_NEEDS_TINT)
1330	&& (bg_flags & (BG_TINT_BITAND \| BG_HAS_RENDER)))
1331	{	1031	{
1332	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))	1032	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1333	result &= ~BG_NEEDS_TINT;	1033	result &= ~BG_NEEDS_TINT;
1334	}	1034	}
		1035	if (result & BG_NEEDS_TINT)
		1036	{
		1037	XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
		1038	if (ximage)
		1039	{
		1040	/* our own client-side tinting */
		1041	tint_ximage (DefaultVisual (dpy, display->screen), ximage);
		1042
		1043	XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
		1044	XDestroyImage (ximage);
		1045	}
		1046	}
1335	} /* server side rendering completed */	1047	} /* server side rendering completed */
		1048
		1049	XFreeGC (dpy, gc);
1336	}	1050	}
1337		1051
1338	if (recoded_root_pmap != root_pixmap)	1052	if (recoded_root_pmap != root_pixmap)
1339	XFreePixmap (dpy, recoded_root_pmap);	1053	XFreePixmap (dpy, recoded_root_pmap);
1340		1054
…		…
1350		1064
1351	root_pixmap = new_root_pixmap;	1065	root_pixmap = new_root_pixmap;
1352	}	1066	}
1353	# endif /* ENABLE_TRANSPARENCY */	1067	# endif /* ENABLE_TRANSPARENCY */
1354		1068
1355	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1356	static void shade_ximage (Visual visual, XImage ximage, int shade, const rgba &c);
1357	# endif
1358
1359	bool	1069	bool
1360	rxvt_term::bg_render ()	1070	rxvt_term::bg_render ()
1361	{	1071	{
1362	unsigned long tr_flags = 0;	1072	unsigned long tr_flags = 0;
1363		1073
…		…
1365	# ifdef ENABLE_TRANSPARENCY	1075	# ifdef ENABLE_TRANSPARENCY
1366	if (bg_flags & BG_IS_TRANSPARENT)	1076	if (bg_flags & BG_IS_TRANSPARENT)
1367	{	1077	{
1368	/* we need to re-generate transparency pixmap in that case ! */	1078	/* we need to re-generate transparency pixmap in that case ! */
1369	tr_flags = make_transparency_pixmap ();	1079	tr_flags = make_transparency_pixmap ();
1370	if (tr_flags == 0)	1080	if (tr_flags)
1371	return false;
1372	else if (!(tr_flags & BG_EFFECTS_FLAGS))
1373	bg_flags \|= BG_IS_VALID;	1081	bg_flags \|= BG_IS_VALID;
1374	}	1082	}
1375	# endif	1083	# endif
1376		1084
1377	# ifdef BG_IMAGE_FROM_FILE	1085	# ifdef BG_IMAGE_FROM_FILE
1378	if ((bg_flags & BG_IS_FROM_FILE)	1086	if ((bg_flags & BG_IS_FROM_FILE)
1379	\|\| (tr_flags & BG_EFFECTS_FLAGS))	1087	\|\| (tr_flags & BG_EFFECTS_FLAGS))
1380	{	1088	{
1381	if (render_image (tr_flags))	1089	if (render_image (tr_flags))
1382	bg_flags \|= BG_IS_VALID;	1090	bg_flags \|= BG_IS_VALID;
1383	}
1384	# endif
1385
1386	# if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1387	XImage *result = NULL;
1388
1389	if (tr_flags && !(bg_flags & BG_IS_VALID))
1390	{
1391	result = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1392	}
1393
1394	if (result)
1395	{
1396	/* our own client-side tinting */
1397	if (tr_flags & BG_NEEDS_TINT)
1398	{
1399	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1400	if (bg_flags & BG_TINT_SET)
1401	tint.get (c);
1402	shade_ximage (DefaultVisual (dpy, display->screen), result, shade, c);
1403	}
1404
1405	GC gc = XCreateGC (dpy, vt, 0UL, NULL);
1406
1407	if (gc)
1408	{
1409	XPutImage (dpy, bg_pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1410
1411	XFreeGC (dpy, gc);
1412	bg_flags \|= BG_IS_VALID;
1413	}
1414
1415	XDestroyImage (result);
1416	}	1091	}
1417	# endif	1092	# endif
1418		1093
1419	if (!(bg_flags & BG_IS_VALID))	1094	if (!(bg_flags & BG_IS_VALID))
1420	{	1095	{
…		…
1457	#endif	1132	#endif
1458	}	1133	}
1459		1134
1460	#endif /* HAVE_BG_PIXMAP */	1135	#endif /* HAVE_BG_PIXMAP */
1461		1136
1462	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)	1137	#ifdef ENABLE_TRANSPARENCY
1463	/* taken from aterm-0.4.2 */	1138	/* based on code from aterm-0.4.2 */
1464		1139
1465	static void	1140	static inline void
1466	shade_ximage (Visual visual, XImage ximage, int shade, const rgba &c)	1141	fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
		1142	{
		1143	for (int i = 0; i <= mask >> sh; i++)
		1144	{
		1145	uint32_t tmp;
		1146	tmp = i * high;
		1147	tmp += (mask >> sh) * low;
		1148	lookup[i] = (tmp / 0xffff) << sh;
		1149	}
		1150	}
		1151
		1152	void
		1153	rxvt_term::tint_ximage (Visual visual, XImage ximage)
1467	{	1154	{
1468	int sh_r, sh_g, sh_b;	1155	int sh_r, sh_g, sh_b;
1469	uint32_t mask_r, mask_g, mask_b;	1156	uint32_t mask_r, mask_g, mask_b;
1470	uint32_t lookup, lookup_r, lookup_g, lookup_b;	1157	uint32_t lookup, lookup_r, lookup_g, lookup_b;
1471	rgba low;	1158	unsigned short low;
1472	rgba high;
1473	int i;
1474	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;	1159	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1475		1160
1476	if (visual->c_class != TrueColor \|\| ximage->format != ZPixmap) return;	1161	if (visual->c_class != TrueColor \|\| ximage->format != ZPixmap) return;
1477		1162
1478	/* for convenience */	1163	/* for convenience */
…		…
1537	break;	1222	break;
1538	default:	1223	default:
1539	return; /* we do not support this color depth */	1224	return; /* we do not support this color depth */
1540	}	1225	}
1541		1226
		1227	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
		1228
		1229	if (bg_flags & BG_TINT_SET)
		1230	tint.get (c);
		1231
1542	/* prepare limits for color transformation (each channel is handled separately) */	1232	/* prepare limits for color transformation (each channel is handled separately) */
1543	if (shade > 100)	1233	if (shade > 100)
1544	{	1234	{
1545	shade = 200 - shade;
1546
1547	high.r = c.r * shade / 100;
1548	high.g = c.g * shade / 100;
1549	high.b = c.b * shade / 100;
1550
1551	low.r = 65535 * (100 - shade) / 100;	1235	c.r = c.r * (200 - shade) / 100;
1552	low.g = 65535 * (100 - shade) / 100;	1236	c.g = c.g * (200 - shade) / 100;
1553	low.b = 65535 * (100 - shade) / 100;	1237	c.b = c.b * (200 - shade) / 100;
		1238
		1239	low = 0xffff * (shade - 100) / 100;
1554	}	1240	}
1555	else	1241	else
1556	{	1242	{
1557	high.r = c.r * shade / 100;	1243	c.r = c.r * shade / 100;
1558	high.g = c.g * shade / 100;	1244	c.g = c.g * shade / 100;
1559	high.b = c.b * shade / 100;	1245	c.b = c.b * shade / 100;
1560		1246
1561	low.r = low.g = low.b = 0;	1247	low = 0;
1562	}	1248	}
1563		1249
1564	/* fill our lookup tables */	1250	/* fill our lookup tables */
1565	for (i = 0; i <= mask_r>>sh_r; i++)	1251	fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1566	{	1252	fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1567	uint32_t tmp;	1253	fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1568	tmp = i * high.r;
1569	tmp += (mask_r>>sh_r) * low.r;
1570	lookup_r[i] = (tmp/65535)<<sh_r;
1571	}
1572	for (i = 0; i <= mask_g>>sh_g; i++)
1573	{
1574	uint32_t tmp;
1575	tmp = i * high.g;
1576	tmp += (mask_g>>sh_g) * low.g;
1577	lookup_g[i] = (tmp/65535)<<sh_g;
1578	}
1579	for (i = 0; i <= mask_b>>sh_b; i++)
1580	{
1581	uint32_t tmp;
1582	tmp = i * high.b;
1583	tmp += (mask_b>>sh_b) * low.b;
1584	lookup_b[i] = (tmp/65535)<<sh_b;
1585	}
1586		1254
1587	/* apply table to input image (replacing colors by newly calculated ones) */	1255	/* apply table to input image (replacing colors by newly calculated ones) */
1588	if (ximage->bits_per_pixel == 32	1256	if (ximage->bits_per_pixel == 32
1589	&& (ximage->depth == 24 \|\| ximage->depth == 32)	1257	&& (ximage->depth == 24 \|\| ximage->depth == 32)
1590	&& ximage->byte_order == host_byte_order)	1258	&& ximage->byte_order == host_byte_order)
…		…
1620	}	1288	}
1621	}	1289	}
1622		1290
1623	free (lookup);	1291	free (lookup);
1624	}	1292	}
1625	#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */	1293	#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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

Comparing rxvt-unicode/src/background.C (file contents): Revision 1.162 by sf-exg, Thu Aug 11 12:27:26 2011 UTC vs. Revision 1.201 by sf-exg, Sat Feb 4 21:47:06 2012 UTC

Diff Legend

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.162 by sf-exg, Thu Aug 11 12:27:26 2011 UTC vs.
Revision 1.201 by sf-exg, Sat Feb 4 21:47:06 2012 UTC