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

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

Diff Legend

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.144 by sf-exg, Fri Jan 28 00:20:47 2011 UTC vs.
Revision 1.197 by sf-exg, Wed Jan 11 13:22:01 2012 UTC