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

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.160 by sf-exg, Thu Aug 11 08:37:17 2011 UTC vs.
Revision 1.202 by sf-exg, Sat Feb 25 22:20:47 2012 UTC

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

Diff Legend

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

Comparing rxvt-unicode/src/background.C (file contents): Revision 1.160 by sf-exg, Thu Aug 11 08:37:17 2011 UTC vs. Revision 1.202 by sf-exg, Sat Feb 25 22:20:47 2012 UTC

Diff Legend

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.160 by sf-exg, Thu Aug 11 08:37:17 2011 UTC vs.
Revision 1.202 by sf-exg, Sat Feb 25 22:20:47 2012 UTC