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

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.152 by sf-exg, Sun May 8 21:03:03 2011 UTC vs.
Revision 1.195 by sf-exg, Mon Jan 2 19:31:00 2012 UTC

…		…
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	* tile Tile image. Scaling/position modifiers above will affect
52	* the tile size and origin.
53	* propscale When scaling, scale proportionally. That is, maintain the
54	* proper aspect ratio for the image. Any portion of the
55	* background not covered by the image is filled with the
56	* current background color.
57	* hscale Scale horizontally, tile vertically ?
58	* vscale Tile horizontally, scale vertically ?
59	* scale Scale both up and down
60	* auto Same as 100x100+50+50
61	*/
62		40
63	#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
64	void	60	void
65	rxvt_term::bg_destroy ()	61	rxvt_term::bg_destroy ()
66	{	62	{
67	#ifdef HAVE_AFTERIMAGE	63	#ifdef HAVE_AFTERIMAGE
68	if (original_asim)	64	if (original_asim)
…		…
176	int smaller = min (image_size, window_size);	172	int smaller = min (image_size, window_size);
177		173
178	if (align >= 0 && align <= 100)	174	if (align >= 0 && align <= 100)
179	return diff * align / 100;	175	return diff * align / 100;
180	else if (align > 100 && align <= 200)	176	else if (align > 100 && align <= 200)
181	return ((align - 100) * smaller / 100) + window_size - smaller;	177	return (align - 100) * smaller / 100 + window_size - smaller;
182	else if (align >= -100 && align < 0)	178	else if (align >= -100 && align < 0)
183	return ((align + 100) * smaller / 100) - image_size;	179	return (align + 100) * smaller / 100 - image_size;
184	return 0;	180	return 0;
185	}	181	}
186		182
187	static inline int	183	static inline int
188	make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)	184	make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)
…		…
207	{	203	{
208	bool changed = false;	204	bool changed = false;
209	int geom_flags = 0;	205	int geom_flags = 0;
210	int x = 0, y = 0;	206	int x = 0, y = 0;
211	unsigned int w = 0, h = 0;	207	unsigned int w = 0, h = 0;
212	unsigned int n;	208	unsigned long new_flags = 0;
213	unsigned long new_flags = (bg_flags & (~BG_GEOMETRY_FLAGS));
214	const char *ops;
215		209
216	if (geom == NULL)	210	if (geom == NULL)
217	return false;	211	return false;
218		212
219	char str[256];	213	if (geom[0])
220
221	ops = strchr (geom, ':');
222	if (ops == NULL)
223	n = strlen (geom);
224	else
225	n = ops - geom;
226
227	if (n >= sizeof (str))
228	return false;
229
230	memcpy (str, geom, n);
231	str[n] = '\0';
232	rxvt_strtrim (str);
233
234	if (str[0])
235	{	214	{
236	/* we have geometry string - let's handle it prior to applying ops */	215	char **arr = rxvt_strsplit (':', geom);
		216
		217	for (int i = 0; arr[i]; i++)
		218	{
		219	if (!strcasecmp (arr[i], "style=tiled"))
		220	{
		221	new_flags = BG_TILE;
		222	w = h = noScale;
		223	x = y = 0;
		224	geom_flags = WidthValue\|HeightValue\|XValue\|YValue;
		225	}
		226	else if (!strcasecmp (arr[i], "style=aspect-stretched"))
		227	{
		228	new_flags = BG_KEEP_ASPECT;
		229	w = h = windowScale;
		230	x = y = centerAlign;
		231	geom_flags = WidthValue\|HeightValue\|XValue\|YValue;
		232	}
		233	else if (!strcasecmp (arr[i], "style=stretched"))
		234	{
		235	new_flags = 0;
		236	w = h = windowScale;
		237	geom_flags = WidthValue\|HeightValue;
		238	}
		239	else if (!strcasecmp (arr[i], "style=centered"))
		240	{
		241	new_flags = 0;
		242	w = h = noScale;
		243	x = y = centerAlign;
		244	geom_flags = WidthValue\|HeightValue\|XValue\|YValue;
		245	}
		246	else if (!strcasecmp (arr[i], "style=root-tiled"))
		247	{
		248	new_flags = BG_TILE\|BG_ROOT_ALIGN;
		249	w = h = noScale;
		250	geom_flags = WidthValue\|HeightValue;
		251	}
		252	else if (!strcasecmp (arr[i], "op=tile"))
		253	new_flags \|= BG_TILE;
		254	else if (!strcasecmp (arr[i], "op=keep-aspect"))
		255	new_flags \|= BG_KEEP_ASPECT;
		256	else if (!strcasecmp (arr[i], "op=root-align"))
		257	new_flags \|= BG_ROOT_ALIGN;
		258
		259	// deprecated
		260	else if (!strcasecmp (arr[i], "tile"))
		261	{
		262	new_flags \|= BG_TILE;
		263	w = h = noScale;
		264	geom_flags \|= WidthValue\|HeightValue;
		265	}
		266	else if (!strcasecmp (arr[i], "propscale"))
		267	{
		268	new_flags \|= BG_KEEP_ASPECT;
		269	w = h = windowScale;
		270	geom_flags \|= WidthValue\|HeightValue;
		271	}
		272	else if (!strcasecmp (arr[i], "hscale"))
		273	{
		274	new_flags \|= BG_TILE;
		275	w = windowScale;
		276	h = noScale;
		277	geom_flags \|= WidthValue\|HeightValue;
		278	}
		279	else if (!strcasecmp (arr[i], "vscale"))
		280	{
		281	new_flags \|= BG_TILE;
		282	h = windowScale;
		283	w = noScale;
		284	geom_flags \|= WidthValue\|HeightValue;
		285	}
		286	else if (!strcasecmp (arr[i], "scale"))
		287	{
		288	w = h = windowScale;
		289	geom_flags \|= WidthValue\|HeightValue;
		290	}
		291	else if (!strcasecmp (arr[i], "auto"))
		292	{
		293	w = h = windowScale;
		294	x = y = centerAlign;
		295	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;
		296	}
		297	else if (!strcasecmp (arr[i], "root"))
		298	{
		299	new_flags \|= BG_TILE\|BG_ROOT_ALIGN;
		300	w = h = noScale;
		301	geom_flags \|= WidthValue\|HeightValue;
		302	}
		303
		304	else
237	geom_flags = XParseGeometry (str, &x, &y, &w, &h);	305	geom_flags \|= XParseGeometry (arr[i], &x, &y, &w, &h);
238	} /* done parsing geometry string */	306	} /* done parsing ops */
		307
		308	rxvt_free_strsplit (arr);
		309	}
		310
		311	new_flags \|= bg_flags & ~BG_GEOMETRY_FLAGS;
239		312
240	if (!update)	313	if (!update)
241	{	314	{
242	if (!(geom_flags & XValue))	315	if (!(geom_flags & XValue))
243	x = y = defaultAlign;	316	x = y = defaultAlign;
…		…
252	w = h;	325	w = h;
253		326
254	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;	327	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;
255	}	328	}
256		329
257	if (ops)
258	{
259	char **arr = rxvt_strsplit (':', ops + 1);
260
261	for (int i = 0; arr[i]; i++)
262	{
263	if (!strcasecmp (arr[i], "tile"))
264	{
265	w = h = noScale;
266	geom_flags \|= WidthValue\|HeightValue;
267	}
268	else if (!strcasecmp (arr[i], "propscale"))
269	{
270	new_flags \|= BG_PROP_SCALE;
271	}
272	else if (!strcasecmp (arr[i], "hscale"))
273	{
274	if (w == 0) w = windowScale;
275
276	h = noScale;
277	geom_flags \|= WidthValue\|HeightValue;
278	}
279	else if (!strcasecmp (arr[i], "vscale"))
280	{
281	if (h == 0) h = windowScale;
282
283	w = noScale;
284	geom_flags \|= WidthValue\|HeightValue;
285	}
286	else if (!strcasecmp (arr[i], "scale"))
287	{
288	if (h == 0) h = windowScale;
289	if (w == 0) w = windowScale;
290
291	geom_flags \|= WidthValue\|HeightValue;
292	}
293	else if (!strcasecmp (arr[i], "auto"))
294	{
295	w = h = windowScale;
296	x = y = centerAlign;
297	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;
298	}
299	else if (!strcasecmp (arr[i], "root"))
300	{
301	new_flags \|= BG_ROOT_ALIGN;
302	w = h = noScale;
303	geom_flags \|= WidthValue\|HeightValue;
304	}
305	} /* done parsing ops */
306
307	rxvt_free_strsplit (arr);
308	}
309
310	if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true;	330	if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true;
311	if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true;	331	if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true;
312	if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true;	332	if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true;
313	if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true;	333	if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true;
314		334
…		…
325	rxvt_term::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y)	345	rxvt_term::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y)
326	{	346	{
327	int target_width = szHint.width;	347	int target_width = szHint.width;
328	int target_height = szHint.height;	348	int target_height = szHint.height;
329		349
		350	w = h_scale * target_width / 100;
		351	h = v_scale * target_height / 100;
		352
330	if (bg_flags & BG_PROP_SCALE)	353	if (bg_flags & BG_KEEP_ASPECT)
331	{	354	{
332	float scale = (float)target_width / image_width;	355	float scale = (float)w / image_width;
333	min_it (scale, (float)target_height / image_height);	356	min_it (scale, (float)h / image_height);
334	w = image_width * scale + 0.5;	357	w = image_width * scale + 0.5;
335	h = image_height * scale + 0.5;	358	h = image_height * scale + 0.5;
336	}	359	}
337	else
338	{
339	w = h_scale * target_width / 100;
340	h = v_scale * target_height / 100;
341	}
342		360
343	if (!w) w = image_width;	361	if (!w) w = image_width;
344	if (!h) h = image_height;	362	if (!h) h = image_height;
345		363
346	if (bg_flags & BG_ROOT_ALIGN)	364	if (bg_flags & BG_ROOT_ALIGN)
…		…
353	x = make_align_position (h_align, target_width, w);	371	x = make_align_position (h_align, target_width, w);
354	y = make_align_position (v_align, target_height, h);	372	y = make_align_position (v_align, target_height, h);
355	}	373	}
356		374
357	bg_flags &= ~BG_IS_SIZE_SENSITIVE;	375	bg_flags &= ~BG_IS_SIZE_SENSITIVE;
358	if ((bg_flags & BG_PROP_SCALE) \|\| h_scale \|\| v_scale	376	if (!(bg_flags & BG_TILE)
		377	\|\| h_scale \|\| v_scale
359	\|\| (!(bg_flags & BG_ROOT_ALIGN) && (h_align \|\| v_align))	378	\|\| (!(bg_flags & BG_ROOT_ALIGN) && (h_align \|\| v_align))
360	\|\| w > target_width \|\| h > target_height)	379	\|\| w > target_width \|\| h > target_height)
361	bg_flags \|= BG_IS_SIZE_SENSITIVE;	380	bg_flags \|= BG_IS_SIZE_SENSITIVE;
362	}	381	}
363		382
…		…
390	}	409	}
391		410
392	if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)	411	if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)
393	{	412	{
394	ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,	413	ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,
395	(original_asim == NULL \|\| tint == TINT_LEAVE_SAME) ? ASA_XImage : ASA_ASImage,	414	ASA_XImage,
396	100, ASIMAGE_QUALITY_DEFAULT);	415	100, ASIMAGE_QUALITY_DEFAULT);
397	if (tmp)	416	if (tmp)
398	{	417	{
399	destroy_asimage (&background);	418	destroy_asimage (&background);
400	background = tmp;	419	background = tmp;
…		…
419		438
420	if (!original_asim	439	if (!original_asim
421	\|\| (!(bg_flags & BG_ROOT_ALIGN)	440	\|\| (!(bg_flags & BG_ROOT_ALIGN)
422	&& (x >= target_width	441	&& (x >= target_width
423	\|\| y >= target_height	442	\|\| y >= target_height
424	\|\| (x + w <= 0)	443	\|\| x + w <= 0
425	\|\| (y + h <= 0))))	444	\|\| y + h <= 0)))
426	{	445	{
427	if (background)	446	if (background)
428	{	447	{
429	new_pmap_width = background->width;	448	new_pmap_width = background->width;
430	new_pmap_height = background->height;	449	new_pmap_height = background->height;
…		…
444	}	463	}
445	else	464	else
446	{	465	{
447	result = original_asim;	466	result = original_asim;
448		467
449	if ((w != original_asim->width)	468	if (w != original_asim->width
450	\|\| (h != original_asim->height))	469	\|\| h != original_asim->height)
451	{	470	{
452	result = scale_asimage (asv, original_asim,	471	result = scale_asimage (asv, original_asim,
453	w, h,	472	w, h,
454	background ? ASA_ASImage : ASA_XImage,	473	ASA_XImage,
455	100, ASIMAGE_QUALITY_DEFAULT);	474	100, ASIMAGE_QUALITY_DEFAULT);
456	}	475	}
457		476
458	if (background == NULL)	477	if (background == NULL)
459	{	478	{
460	if (h_scale == 0 \|\| v_scale == 0)	479	if (bg_flags & BG_TILE)
461	{	480	{
462	/* if tiling - pixmap has to be sized exactly as the image,	481	/* if tiling - pixmap has to be sized exactly as the image,
463	but there is no need to make it bigger than the window! */	482	but there is no need to make it bigger than the window! */
464	new_pmap_width = min (result->width, target_width);	483	new_pmap_width = min (result->width, target_width);
465	new_pmap_height = min (result->height, target_height);	484	new_pmap_height = min (result->height, target_height);
…		…
490	layers[0].clip_width = target_width;	509	layers[0].clip_width = target_width;
491	layers[0].clip_height = target_height;	510	layers[0].clip_height = target_height;
492	layers[0].tint = background_tint;	511	layers[0].tint = background_tint;
493	layers[1].im = result;	512	layers[1].im = result;
494		513
495	if (h_scale == 0 \|\| v_scale == 0)	514	if (bg_flags & BG_TILE)
496	{	515	{
497	/* tile horizontally */	516	/* tile horizontally */
498	while (x > 0) x -= (int)result->width;	517	while (x > 0) x -= (int)result->width;
499	layers[1].dst_x = x;	518	layers[1].dst_x = x;
500	layers[1].clip_width = result->width+target_width;	519	layers[1].clip_width = result->width+target_width;
…		…
504	/* clip horizontally */	523	/* clip horizontally */
505	layers[1].dst_x = x;	524	layers[1].dst_x = x;
506	layers[1].clip_width = result->width;	525	layers[1].clip_width = result->width;
507	}	526	}
508		527
509	if (h_scale == 0 \|\| v_scale == 0)	528	if (bg_flags & BG_TILE)
510	{	529	{
511	while (y > 0) y -= (int)result->height;	530	while (y > 0) y -= (int)result->height;
512	layers[1].dst_y = y;	531	layers[1].dst_y = y;
513	layers[1].clip_height = result->height + target_height;	532	layers[1].clip_height = result->height + target_height;
514	}	533	}
…		…
564		583
565	int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;	584	int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
566	int dst_width = result->width, dst_height = result->height;	585	int dst_width = result->width, dst_height = result->height;
567	if (background == NULL)	586	if (background == NULL)
568	{	587	{
569	if (!(h_scale == 0 \|\| v_scale == 0))	588	if (!(bg_flags & BG_TILE))
570	{	589	{
571	src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );	590	src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );
572	src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);	591	src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
573	}	592	}
574		593
…		…
620	else if (depth == 15 \|\| depth == 16)	639	else if (depth == 15 \|\| depth == 16)
621	bytes_per_pixel = 2;	640	bytes_per_pixel = 2;
622	else	641	else
623	return false;	642	return false;
624		643
625	width_r = rxvt_popcount (visual->red_mask);	644	width_r = ecb_popcount32 (visual->red_mask);
626	width_g = rxvt_popcount (visual->green_mask);	645	width_g = ecb_popcount32 (visual->green_mask);
627	width_b = rxvt_popcount (visual->blue_mask);	646	width_b = ecb_popcount32 (visual->blue_mask);
628		647
629	if (width_r > 8 \|\| width_g > 8 \|\| width_b > 8)	648	if (width_r > 8 \|\| width_g > 8 \|\| width_b > 8)
630	return false;	649	return false;
631		650
632	sh_r = rxvt_ctz (visual->red_mask);	651	sh_r = ecb_ctz32 (visual->red_mask);
633	sh_g = rxvt_ctz (visual->green_mask);	652	sh_g = ecb_ctz32 (visual->green_mask);
634	sh_b = rxvt_ctz (visual->blue_mask);	653	sh_b = ecb_ctz32 (visual->blue_mask);
635		654
636	if (width > INT_MAX / height / bytes_per_pixel)	655	if (width > INT_MAX / height / bytes_per_pixel)
637	return false;	656	return false;
638		657
639	data = (char )malloc (width height * bytes_per_pixel);	658	data = (char )malloc (width height * bytes_per_pixel);
…		…
646	{	665	{
647	free (data);	666	free (data);
648	return false;	667	return false;
649	}	668	}
650		669
651	ximage->byte_order = byteorder::big_endian () ? MSBFirst : LSBFirst;	670	ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
652		671
653	rowstride = gdk_pixbuf_get_rowstride (pixbuf);	672	rowstride = gdk_pixbuf_get_rowstride (pixbuf);
654	channels = gdk_pixbuf_get_n_channels (pixbuf);	673	channels = gdk_pixbuf_get_n_channels (pixbuf);
655	row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels;	674	row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels;
656	line = data;	675	line = data;
…		…
709	get_image_geometry (image_width, image_height, w, h, x, y);	728	get_image_geometry (image_width, image_height, w, h, x, y);
710		729
711	if (!(bg_flags & BG_ROOT_ALIGN)	730	if (!(bg_flags & BG_ROOT_ALIGN)
712	&& (x >= target_width	731	&& (x >= target_width
713	\|\| y >= target_height	732	\|\| y >= target_height
714	\|\| (x + w <= 0)	733	\|\| x + w <= 0
715	\|\| (y + h <= 0)))	734	\|\| y + h <= 0))
716	return false;	735	return false;
717		736
718	result = pixbuf;	737	result = pixbuf;
719		738
720	if ((w != image_width)	739	if (w != image_width
721	\|\| (h != image_height))	740	\|\| h != image_height)
722	{	741	{
723	result = gdk_pixbuf_scale_simple (pixbuf,	742	result = gdk_pixbuf_scale_simple (pixbuf,
724	w, h,	743	w, h,
725	GDK_INTERP_BILINEAR);	744	GDK_INTERP_BILINEAR);
726	}	745	}
…		…
742	root_pmap = bg_pixmap;	761	root_pmap = bg_pixmap;
743	bg_pixmap = None;	762	bg_pixmap = None;
744	}	763	}
745	else	764	else
746	{	765	{
747	if (h_scale == 0 \|\| v_scale == 0)	766	if (bg_flags & BG_TILE)
748	{	767	{
749	new_pmap_width = min (image_width, target_width);	768	new_pmap_width = min (image_width, target_width);
750	new_pmap_height = min (image_height, target_height);	769	new_pmap_height = min (image_height, target_height);
751	}	770	}
752	}	771	}
…		…
760	bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);	779	bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
761	bg_pmap_width = new_pmap_width;	780	bg_pmap_width = new_pmap_width;
762	bg_pmap_height = new_pmap_height;	781	bg_pmap_height = new_pmap_height;
763	}	782	}
764		783
765	if (bg_pixmap != None)
766	{
767	gcv.foreground = pix_colors[Color_bg];	784	gcv.foreground = pix_colors[Color_bg];
768	gc = XCreateGC (dpy, vt, GCForeground, &gcv);	785	gc = XCreateGC (dpy, vt, GCForeground, &gcv);
769		786
770	if (gc)	787	if (gc)
771	{	788	{
772	if (h_scale == 0 \|\| v_scale == 0)	789	if (bg_flags & BG_TILE)
773	{	790	{
774	Pixmap tile = XCreatePixmap (dpy, vt, image_width, image_height, depth);	791	Pixmap tile = XCreatePixmap (dpy, vt, image_width, image_height, depth);
775
776	if (tile != None)
777	{
778	pixbuf_to_pixmap (result, tile, gc,	792	pixbuf_to_pixmap (result, tile, gc,
779	0, 0,	793	0, 0,
780	0, 0,	794	0, 0,
781	image_width, image_height);	795	image_width, image_height);
782		796
783	gcv.tile = tile;	797	gcv.tile = tile;
784	gcv.fill_style = FillTiled;	798	gcv.fill_style = FillTiled;
785	gcv.ts_x_origin = x;	799	gcv.ts_x_origin = x;
786	gcv.ts_y_origin = y;	800	gcv.ts_y_origin = y;
787	XChangeGC (dpy, gc, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcv);	801	XChangeGC (dpy, gc, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcv);
788		802
789	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);	803	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
790	XFreePixmap (dpy, tile);	804	XFreePixmap (dpy, tile);
791	}
792	}	805	}
793	else	806	else
794	{	807	{
795	int src_x, src_y, dst_x, dst_y;	808	int src_x, src_y, dst_x, dst_y;
796	int dst_width, dst_height;	809	int dst_width, dst_height;
797		810
798	src_x = make_clip_rectangle (x, image_width , new_pmap_width , dst_x, dst_width );	811	src_x = make_clip_rectangle (x, image_width , new_pmap_width , dst_x, dst_width );
799	src_y = make_clip_rectangle (y, image_height, new_pmap_height, dst_y, dst_height);	812	src_y = make_clip_rectangle (y, image_height, new_pmap_height, dst_y, dst_height);
800		813
801	if (dst_x > 0 \|\| dst_y > 0	814	if (dst_x > 0 \|\| dst_y > 0
802	\|\| dst_x + dst_width < new_pmap_width	815	\|\| dst_x + dst_width < new_pmap_width
803	\|\| dst_y + dst_height < new_pmap_height)	816	\|\| dst_y + dst_height < new_pmap_height)
804	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);	817	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
805		818
806	if (dst_x < new_pmap_width && dst_y < new_pmap_height)	819	if (dst_x < new_pmap_width && dst_y < new_pmap_height)
807	pixbuf_to_pixmap (result, bg_pixmap, gc,	820	pixbuf_to_pixmap (result, bg_pixmap, gc,
808	src_x, src_y,	821	src_x, src_y,
809	dst_x, dst_y,	822	dst_x, dst_y,
810	dst_width, dst_height);	823	dst_width, dst_height);
811	}	824	}
812		825
813	#if XRENDER	826	#if XRENDER
814	if (tr_flags)	827	if (tr_flags)
815	{	828	{
816	XRenderPictureAttributes pa;
817
818	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, visual);	829	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
		830
819	Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa);	831	Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
820		832
821	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
822	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, dst_format, 0, &pa);	833	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
823		834
824	pa.repeat = True;	835	Picture mask = create_xrender_mask (dpy, vt, False, False);
825	Pixmap mask_pmap = XCreatePixmap (dpy, vt, 1, 1, 8);
826	XRenderPictFormat *mask_format = XRenderFindStandardFormat (dpy, PictStandardA8);
827	Picture mask = XRenderCreatePicture (dpy, mask_pmap, mask_format, CPRepeat, &pa);
828	XFreePixmap (dpy, mask_pmap);
829		836
830	if (src && dst && mask)
831	{
832	XRenderColor mask_c;	837	XRenderColor mask_c;
833		838
834	mask_c.alpha = 0x8000;	839	mask_c.alpha = 0x8000;
835	mask_c.red = 0;	840	mask_c.red =
836	mask_c.green = 0;	841	mask_c.green =
837	mask_c.blue = 0;	842	mask_c.blue = 0;
838	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);	843	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
		844
839	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);	845	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
840	}
841		846
842	XRenderFreePicture (dpy, src);	847	XRenderFreePicture (dpy, src);
843	XRenderFreePicture (dpy, dst);	848	XRenderFreePicture (dpy, dst);
844	XRenderFreePicture (dpy, mask);	849	XRenderFreePicture (dpy, mask);
845	}	850	}
846	#endif	851	#endif
847		852
848	XFreeGC (dpy, gc);	853	XFreeGC (dpy, gc);
849		854
850	ret = true;	855	ret = true;
851	}
852	}	856	}
853		857
854	if (result != pixbuf)	858	if (result != pixbuf)
855	g_object_unref (result);	859	g_object_unref (result);
856		860
…		…
865	rxvt_term::bg_set_file (const char *file)	869	rxvt_term::bg_set_file (const char *file)
866	{	870	{
867	if (!file \|\| !*file)	871	if (!file \|\| !*file)
868	return false;	872	return false;
869		873
		874	bool ret = false;
870	if (const char *p = strchr (file, ';'))	875	const char *p = strchr (file, ';');
		876
		877	if (p)
871	{	878	{
872	size_t len = p - file;	879	size_t len = p - file;
873	char *f = rxvt_temp_buf<char> (len + 1);	880	char *f = rxvt_temp_buf<char> (len + 1);
874	memcpy (f, file, len);	881	memcpy (f, file, len);
875	f[len] = '\0';	882	f[len] = '\0';
…		…
884	{	891	{
885	if (original_asim)	892	if (original_asim)
886	safe_asimage_destroy (original_asim);	893	safe_asimage_destroy (original_asim);
887	original_asim = image;	894	original_asim = image;
888	bg_flags \|= BG_IS_FROM_FILE \| BG_CLIENT_RENDER;	895	bg_flags \|= BG_IS_FROM_FILE \| BG_CLIENT_RENDER;
889	return true;	896	ret = true;
890	}	897	}
891	# endif	898	# endif
892		899
893	# ifdef HAVE_PIXBUF	900	# ifdef HAVE_PIXBUF
894	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);	901	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
…		…
896	{	903	{
897	if (pixbuf)	904	if (pixbuf)
898	g_object_unref (pixbuf);	905	g_object_unref (pixbuf);
899	pixbuf = image;	906	pixbuf = image;
900	bg_flags \|= BG_IS_FROM_FILE;	907	bg_flags \|= BG_IS_FROM_FILE;
901	return true;	908	ret = true;
902	}	909	}
903	# endif	910	# endif
904		911
		912	if (ret)
		913	{
		914	if (p)
		915	bg_set_geometry (p + 1);
		916	else
		917	bg_set_default_geometry ();
		918	}
		919
905	return false;	920	return ret;
906	}	921	}
907		922
908	# endif /* BG_IMAGE_FROM_FILE */	923	# endif /* BG_IMAGE_FROM_FILE */
909		924
910	# ifdef ENABLE_TRANSPARENCY	925	# ifdef ENABLE_TRANSPARENCY
…		…
946	{	961	{
947	changed = true;	962	changed = true;
948	v_blurRadius = vr;	963	v_blurRadius = vr;
949	}	964	}
950		965
951	if (v_blurRadius == 0 && h_blurRadius == 0)	966	if (h_blurRadius == 0 \|\| v_blurRadius == 0)
952	bg_flags &= ~BG_NEEDS_BLUR;	967	bg_flags &= ~BG_NEEDS_BLUR;
953	else	968	else
954	bg_flags \|= BG_NEEDS_BLUR;	969	bg_flags \|= BG_NEEDS_BLUR;
955		970
956	return changed;	971	return changed;
957	}	972	}
958		973
959	void	974	void
960	rxvt_term::set_tint_shade_flags ()	975	rxvt_term::set_tint_shade_flags ()
961	{	976	{
962	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);	977	rgba c;
963	bool has_shade = shade != 100;	978	bool has_shade = shade != 100;
964		979
965	bg_flags &= ~BG_TINT_FLAGS;	980	bg_flags &= ~BG_TINT_FLAGS;
966		981
967	if (bg_flags & BG_TINT_SET)	982	if (bg_flags & BG_TINT_SET)
…		…
993	}	1008	}
994		1009
995	bool	1010	bool
996	rxvt_term::bg_set_shade (const char *shade_str)	1011	rxvt_term::bg_set_shade (const char *shade_str)
997	{	1012	{
998	int new_shade = (shade_str) ? atoi (shade_str) : 100;	1013	int new_shade = atoi (shade_str);
999		1014
1000	clamp_it (new_shade, -100, 200);	1015	clamp_it (new_shade, -100, 200);
1001	if (new_shade < 0)	1016	if (new_shade < 0)
1002	new_shade = 200 - (100 + new_shade);	1017	new_shade = 200 - (100 + new_shade);
1003		1018
…		…
1037	bool	1052	bool
1038	rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	1053	rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1039	{	1054	{
1040	bool ret = false;	1055	bool ret = false;
1041	#if XRENDER	1056	#if XRENDER
		1057	if (!(bg_flags & BG_HAS_RENDER_CONV))
		1058	return false;
		1059
1042	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;	1060	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1043	double kernel = (double )malloc (size * sizeof (double));	1061	double kernel = (double )malloc (size * sizeof (double));
1044	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));	1062	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));
1045		1063
1046	XRenderPictureAttributes pa;	1064	XRenderPictureAttributes pa;
1047	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	1065	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1048		1066
		1067	pa.repeat = RepeatPad;
1049	Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1068	Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
1050	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1069	Picture dst = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
1051		1070
1052	if (kernel && params && src && dst)	1071	if (kernel && params)
1053	{	1072	{
1054	if (h_blurRadius)
1055	{
1056	size = h_blurRadius * 2 + 1;	1073	size = h_blurRadius * 2 + 1;
1057	get_gaussian_kernel (h_blurRadius, size, kernel, params);	1074	get_gaussian_kernel (h_blurRadius, size, kernel, params);
1058		1075
1059	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	1076	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1060	XRenderComposite (dpy,	1077	XRenderComposite (dpy,
1061	PictOpSrc,	1078	PictOpSrc,
1062	src,	1079	src,
1063	None,	1080	None,
1064	dst,	1081	dst,
1065	0, 0,	1082	0, 0,
1066	0, 0,	1083	0, 0,
1067	0, 0,	1084	0, 0,
1068	width, height);	1085	width, height);
1069	}
1070		1086
1071	if (v_blurRadius)
1072	{
1073	size = v_blurRadius * 2 + 1;	1087	size = v_blurRadius * 2 + 1;
1074	get_gaussian_kernel (v_blurRadius, size, kernel, params);	1088	get_gaussian_kernel (v_blurRadius, size, kernel, params);
1075	::swap (params[0], params[1]);	1089	::swap (params[0], params[1]);
1076		1090
1077	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	1091	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1078	XRenderComposite (dpy,	1092	XRenderComposite (dpy,
1079	PictOpSrc,	1093	PictOpSrc,
1080	src,	1094	src,
1081	None,	1095	None,
1082	dst,	1096	dst,
1083	0, 0,	1097	0, 0,
1084	0, 0,	1098	0, 0,
1085	0, 0,	1099	0, 0,
1086	width, height);	1100	width, height);
1087	}
1088		1101
1089	ret = true;	1102	ret = true;
1090	}	1103	}
1091		1104
1092	free (kernel);	1105	free (kernel);
…		…
1119	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);	1132	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1120	ret = true;	1133	ret = true;
1121	XFreeGC (dpy, gc);	1134	XFreeGC (dpy, gc);
1122	}	1135	}
1123	}	1136	}
1124	else
1125	{
1126	# if XRENDER	1137	# if XRENDER
		1138	else if (bg_flags & BG_HAS_RENDER)
		1139	{
1127	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);	1140	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1128		1141
1129	if (bg_flags & BG_TINT_SET)	1142	if (bg_flags & BG_TINT_SET)
1130	tint.get (c);	1143	tint.get (c);
1131		1144
…		…
1140	c.r = c.r * (200 - shade) / 100;	1153	c.r = c.r * (200 - shade) / 100;
1141	c.g = c.g * (200 - shade) / 100;	1154	c.g = c.g * (200 - shade) / 100;
1142	c.b = c.b * (200 - shade) / 100;	1155	c.b = c.b * (200 - shade) / 100;
1143	}	1156	}
1144		1157
1145	XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1146	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	1158	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1147	XRenderPictureAttributes pa;
1148		1159
1149	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1160	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1150		1161
1151	pa.repeat = True;	1162	Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1152		1163
1153	Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);	1164	Picture mask_pic = create_xrender_mask (dpy, pixmap, True, True);
1154	Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1155	XFreePixmap (dpy, overlay_pmap);
1156		1165
1157	pa.component_alpha = True;
1158	Pixmap mask_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
1159	Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat \| CPComponentAlpha, &pa);
1160	XFreePixmap (dpy, mask_pmap);
1161
1162	if (mask_pic && overlay_pic && back_pic)
1163	{
1164	XRenderColor mask_c;	1166	XRenderColor mask_c;
1165		1167
1166	mask_c.alpha = 0xffff;	1168	mask_c.alpha = 0xffff;
		1169	mask_c.red =
		1170	mask_c.green =
		1171	mask_c.blue = 0;
		1172	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
		1173
		1174	mask_c.alpha = 0;
		1175	mask_c.red = 0xffff - c.r;
		1176	mask_c.green = 0xffff - c.g;
		1177	mask_c.blue = 0xffff - c.b;
		1178	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
		1179
		1180	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
		1181
		1182	if (shade > 100)
		1183	{
		1184	mask_c.alpha = 0;
1167	mask_c.red =	1185	mask_c.red =
1168	mask_c.green =	1186	mask_c.green =
1169	mask_c.blue = 0;	1187	mask_c.blue = 0xffff * (shade - 100) / 100;
1170	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);	1188	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1171		1189
1172	mask_c.alpha = 0;
1173	mask_c.red = 0xffff - c.r;
1174	mask_c.green = 0xffff - c.g;
1175	mask_c.blue = 0xffff - c.b;
1176	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
1177	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1178
1179	if (shade > 100)
1180	{
1181	mask_c.red = mask_c.green = mask_c.blue = 0xffff * (shade - 100) / 100;
1182	mask_c.alpha = 0;
1183	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1184
1185	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);	1190	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1186	}	1191	}
1187		1192
1188	ret = true;	1193	ret = true;
1189	}
1190		1194
1191	XRenderFreePicture (dpy, mask_pic);	1195	XRenderFreePicture (dpy, mask_pic);
1192	XRenderFreePicture (dpy, overlay_pic);	1196	XRenderFreePicture (dpy, overlay_pic);
1193	XRenderFreePicture (dpy, back_pic);	1197	XRenderFreePicture (dpy, back_pic);
		1198	}
1194	# endif	1199	# endif
1195	}
1196		1200
1197	return ret;	1201	return ret;
1198	}	1202	}
1199		1203
1200	/*	1204	/*
…		…
1251	#if XRENDER	1255	#if XRENDER
1252	if (bg_flags & BG_HAS_RENDER)	1256	if (bg_flags & BG_HAS_RENDER)
1253	{	1257	{
1254	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);	1258	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1255		1259
1256	if (recoded_root_pmap != None)
1257	{
1258	XRenderPictureAttributes pa;
1259
1260	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));	1260	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1261	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa);	1261	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1262		1262
1263	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);	1263	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1264	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa);	1264	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1265		1265
1266	if (src && dst)
1267	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);	1266	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
1268	else
1269	{
1270	XFreePixmap (dpy, recoded_root_pmap);
1271	recoded_root_pmap = None;
1272	}
1273		1267
1274	XRenderFreePicture (dpy, src);	1268	XRenderFreePicture (dpy, src);
1275	XRenderFreePicture (dpy, dst);	1269	XRenderFreePicture (dpy, dst);
1276	}
1277	}	1270	}
1278	else	1271	else
1279	#endif	1272	#endif
1280	recoded_root_pmap = None;	1273	recoded_root_pmap = None;
1281	}	1274	}
…		…
1292	bg_pixmap = XCreatePixmap (dpy, vt, window_width, window_height, depth);	1285	bg_pixmap = XCreatePixmap (dpy, vt, window_width, window_height, depth);
1293	bg_pmap_width = window_width;	1286	bg_pmap_width = window_width;
1294	bg_pmap_height = window_height;	1287	bg_pmap_height = window_height;
1295	}	1288	}
1296		1289
1297	if (bg_pixmap != None)
1298	{
1299	/* straightforward pixmap copy */	1290	/* straightforward pixmap copy */
1300	while (sx < 0) sx += (int)root_width;	1291	while (sx < 0) sx += root_pmap_width;
1301	while (sy < 0) sy += (int)root_height;	1292	while (sy < 0) sy += root_pmap_height;
1302		1293
1303	gcv.tile = recoded_root_pmap;	1294	gcv.tile = recoded_root_pmap;
1304	gcv.fill_style = FillTiled;	1295	gcv.fill_style = FillTiled;
1305	gcv.ts_x_origin = -sx;	1296	gcv.ts_x_origin = -sx;
1306	gcv.ts_y_origin = -sy;	1297	gcv.ts_y_origin = -sy;
1307	gc = XCreateGC (dpy, vt, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcv);	1298	gc = XCreateGC (dpy, vt, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcv);
1308		1299
1309	if (gc)	1300	if (gc)
1310	{	1301	{
1311	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);	1302	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1312	result \|= BG_IS_VALID \| (bg_flags & BG_EFFECTS_FLAGS);	1303	result \|= BG_IS_VALID \| (bg_flags & BG_EFFECTS_FLAGS);
1313	XFreeGC (dpy, gc);
1314		1304
1315	if (!(bg_flags & BG_CLIENT_RENDER))	1305	if (!(bg_flags & BG_CLIENT_RENDER))
1316	{	1306	{
1317	if ((bg_flags & BG_NEEDS_BLUR)	1307	if (bg_flags & BG_NEEDS_BLUR)
1318	&& (bg_flags & BG_HAS_RENDER_CONV))	1308	{
		1309	if (blur_pixmap (bg_pixmap, visual, window_width, window_height))
		1310	result &= ~BG_NEEDS_BLUR;
		1311	}
		1312	if (bg_flags & BG_NEEDS_TINT)
		1313	{
		1314	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
		1315	result &= ~BG_NEEDS_TINT;
		1316	}
		1317	# ifndef HAVE_AFTERIMAGE
		1318	if (result & BG_NEEDS_TINT)
		1319	{
		1320	XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
		1321	if (ximage)
1319	{	1322	{
1320	if (blur_pixmap (bg_pixmap, visual, window_width, window_height))	1323	/* our own client-side tinting */
1321	result &= ~BG_NEEDS_BLUR;	1324	tint_ximage (DefaultVisual (dpy, display->screen), ximage);
		1325
		1326	XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
		1327	XDestroyImage (ximage);
1322	}	1328	}
1323	if ((bg_flags & BG_NEEDS_TINT)
1324	&& (bg_flags & (BG_TINT_BITAND \| BG_HAS_RENDER)))
1325	{
1326	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1327	result &= ~BG_NEEDS_TINT;
1328	}	1329	}
		1330	# endif
1329	} /* server side rendering completed */	1331	} /* server side rendering completed */
1330	}	1332
		1333	XFreeGC (dpy, gc);
1331	}	1334	}
1332		1335
1333	if (recoded_root_pmap != root_pixmap)	1336	if (recoded_root_pmap != root_pixmap)
1334	XFreePixmap (dpy, recoded_root_pmap);	1337	XFreePixmap (dpy, recoded_root_pmap);
1335		1338
…		…
1344	new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]);	1347	new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]);
1345		1348
1346	root_pixmap = new_root_pixmap;	1349	root_pixmap = new_root_pixmap;
1347	}	1350	}
1348	# endif /* ENABLE_TRANSPARENCY */	1351	# endif /* ENABLE_TRANSPARENCY */
1349
1350	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1351	static void shade_ximage (Visual visual, XImage ximage, int shade, const rgba &c);
1352	# endif
1353		1352
1354	bool	1353	bool
1355	rxvt_term::bg_render ()	1354	rxvt_term::bg_render ()
1356	{	1355	{
1357	unsigned long tr_flags = 0;	1356	unsigned long tr_flags = 0;
…		…
1362	{	1361	{
1363	/* we need to re-generate transparency pixmap in that case ! */	1362	/* we need to re-generate transparency pixmap in that case ! */
1364	tr_flags = make_transparency_pixmap ();	1363	tr_flags = make_transparency_pixmap ();
1365	if (tr_flags == 0)	1364	if (tr_flags == 0)
1366	return false;	1365	return false;
1367	else if (!(tr_flags & BG_EFFECTS_FLAGS))
1368	bg_flags \|= BG_IS_VALID;	1366	bg_flags \|= BG_IS_VALID;
1369	}	1367	}
1370	# endif	1368	# endif
1371		1369
1372	# ifdef BG_IMAGE_FROM_FILE	1370	# ifdef BG_IMAGE_FROM_FILE
1373	if ((bg_flags & BG_IS_FROM_FILE)	1371	if ((bg_flags & BG_IS_FROM_FILE)
1374	\|\| (tr_flags & BG_EFFECTS_FLAGS))	1372	\|\| (tr_flags & BG_EFFECTS_FLAGS))
1375	{	1373	{
1376	if (render_image (tr_flags))	1374	if (render_image (tr_flags))
1377	bg_flags \|= BG_IS_VALID;	1375	bg_flags \|= BG_IS_VALID;
1378	}
1379	# endif
1380
1381	# if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1382	XImage *result = NULL;
1383
1384	if (tr_flags && !(bg_flags & BG_IS_VALID))
1385	{
1386	result = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1387	}
1388
1389	if (result)
1390	{
1391	/* our own client-side tinting */
1392	if (tr_flags & BG_NEEDS_TINT)
1393	{
1394	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1395	if (bg_flags & BG_TINT_SET)
1396	tint.get (c);
1397	shade_ximage (DefaultVisual (dpy, display->screen), result, shade, c);
1398	}
1399
1400	GC gc = XCreateGC (dpy, vt, 0UL, NULL);
1401
1402	if (gc)
1403	{
1404	XPutImage (dpy, bg_pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1405
1406	XFreeGC (dpy, gc);
1407	bg_flags \|= BG_IS_VALID;
1408	}
1409
1410	XDestroyImage (result);
1411	}	1376	}
1412	# endif	1377	# endif
1413		1378
1414	if (!(bg_flags & BG_IS_VALID))	1379	if (!(bg_flags & BG_IS_VALID))
1415	{	1380	{
…		…
1453	}	1418	}
1454		1419
1455	#endif /* HAVE_BG_PIXMAP */	1420	#endif /* HAVE_BG_PIXMAP */
1456		1421
1457	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)	1422	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1458	/* taken from aterm-0.4.2 */	1423	/* based on code from aterm-0.4.2 */
1459		1424
1460	static void	1425	static inline void
1461	shade_ximage (Visual visual, XImage ximage, int shade, const rgba &c)	1426	fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
		1427	{
		1428	for (int i = 0; i <= mask >> sh; i++)
		1429	{
		1430	uint32_t tmp;
		1431	tmp = i * high;
		1432	tmp += (mask >> sh) * low;
		1433	lookup[i] = (tmp / 0xffff) << sh;
		1434	}
		1435	}
		1436
		1437	void
		1438	rxvt_term::tint_ximage (Visual visual, XImage ximage)
1462	{	1439	{
1463	int sh_r, sh_g, sh_b;	1440	int sh_r, sh_g, sh_b;
1464	uint32_t mask_r, mask_g, mask_b;	1441	uint32_t mask_r, mask_g, mask_b;
1465	uint32_t lookup, lookup_r, lookup_g, lookup_b;	1442	uint32_t lookup, lookup_r, lookup_g, lookup_b;
1466	rgba low;	1443	unsigned short low;
1467	rgba high;
1468	int i;
1469	int host_byte_order = byteorder::big_endian () ? MSBFirst : LSBFirst;	1444	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1470		1445
1471	if (visual->c_class != TrueColor \|\| ximage->format != ZPixmap) return;	1446	if (visual->c_class != TrueColor \|\| ximage->format != ZPixmap) return;
1472		1447
1473	/* for convenience */	1448	/* for convenience */
1474	mask_r = visual->red_mask;	1449	mask_r = visual->red_mask;
…		…
1532	break;	1507	break;
1533	default:	1508	default:
1534	return; /* we do not support this color depth */	1509	return; /* we do not support this color depth */
1535	}	1510	}
1536		1511
		1512	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
		1513
		1514	if (bg_flags & BG_TINT_SET)
		1515	tint.get (c);
		1516
1537	/* prepare limits for color transformation (each channel is handled separately) */	1517	/* prepare limits for color transformation (each channel is handled separately) */
1538	if (shade > 100)	1518	if (shade > 100)
1539	{	1519	{
1540	shade = 200 - shade;
1541
1542	high.r = c.r * shade / 100;
1543	high.g = c.g * shade / 100;
1544	high.b = c.b * shade / 100;
1545
1546	low.r = 65535 * (100 - shade) / 100;	1520	c.r = c.r * (200 - shade) / 100;
1547	low.g = 65535 * (100 - shade) / 100;	1521	c.g = c.g * (200 - shade) / 100;
1548	low.b = 65535 * (100 - shade) / 100;	1522	c.b = c.b * (200 - shade) / 100;
		1523
		1524	low = 0xffff * (shade - 100) / 100;
1549	}	1525	}
1550	else	1526	else
1551	{	1527	{
1552	high.r = c.r * shade / 100;	1528	c.r = c.r * shade / 100;
1553	high.g = c.g * shade / 100;	1529	c.g = c.g * shade / 100;
1554	high.b = c.b * shade / 100;	1530	c.b = c.b * shade / 100;
1555		1531
1556	low.r = low.g = low.b = 0;	1532	low = 0;
1557	}	1533	}
1558		1534
1559	/* fill our lookup tables */	1535	/* fill our lookup tables */
1560	for (i = 0; i <= mask_r>>sh_r; i++)	1536	fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1561	{	1537	fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1562	uint32_t tmp;	1538	fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1563	tmp = i * high.r;
1564	tmp += (mask_r>>sh_r) * low.r;
1565	lookup_r[i] = (tmp/65535)<<sh_r;
1566	}
1567	for (i = 0; i <= mask_g>>sh_g; i++)
1568	{
1569	uint32_t tmp;
1570	tmp = i * high.g;
1571	tmp += (mask_g>>sh_g) * low.g;
1572	lookup_g[i] = (tmp/65535)<<sh_g;
1573	}
1574	for (i = 0; i <= mask_b>>sh_b; i++)
1575	{
1576	uint32_t tmp;
1577	tmp = i * high.b;
1578	tmp += (mask_b>>sh_b) * low.b;
1579	lookup_b[i] = (tmp/65535)<<sh_b;
1580	}
1581		1539
1582	/* apply table to input image (replacing colors by newly calculated ones) */	1540	/* apply table to input image (replacing colors by newly calculated ones) */
1583	if (ximage->bits_per_pixel == 32	1541	if (ximage->bits_per_pixel == 32
1584	&& (ximage->depth == 24 \|\| ximage->depth == 32)	1542	&& (ximage->depth == 24 \|\| ximage->depth == 32)
1585	&& ximage->byte_order == host_byte_order)	1543	&& ximage->byte_order == host_byte_order)

Diff Legend

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

Comparing rxvt-unicode/src/background.C (file contents): Revision 1.152 by sf-exg, Sun May 8 21:03:03 2011 UTC vs. Revision 1.195 by sf-exg, Mon Jan 2 19:31:00 2012 UTC

Diff Legend

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.152 by sf-exg, Sun May 8 21:03:03 2011 UTC vs.
Revision 1.195 by sf-exg, Mon Jan 2 19:31:00 2012 UTC