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

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.157 by sf-exg, Tue Aug 9 21:48:00 2011 UTC vs.
Revision 1.201 by sf-exg, Sat Feb 4 21:47:06 2012 UTC

…		…
20	* You should have received a copy of the GNU General Public License	20	* You should have received a copy of the GNU General Public License
21	* along with this program; if not, write to the Free Software	21	* along with this program; if not, write to the Free Software
22	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	22	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23	---------------------------------------------------------------------/	23	---------------------------------------------------------------------/
24		24
25	#include <cmath>	25	#include <math.h>
26	#include "../config.h" /* NECESSARY */	26	#include "../config.h" /* NECESSARY */
27	#include "rxvt.h" /* NECESSARY */	27	#include "rxvt.h" /* NECESSARY */
28		28
29	#if XRENDER	29	#if XRENDER
30	# include <X11/extensions/Xrender.h>	30	# include <X11/extensions/Xrender.h>
…		…
32		32
33	#ifndef FilterConvolution	33	#ifndef FilterConvolution
34	#define FilterConvolution "convolution"	34	#define FilterConvolution "convolution"
35	#endif	35	#endif
36		36
37	/*	37	#ifndef RepeatPad
38	* Pixmap geometry string interpretation :	38	#define RepeatPad True
39	* Each geometry string contains zero or one scale/position	39	#endif
40	* adjustment and may optionally be followed by a colon and one or more
41	* colon-delimited pixmap operations.
42	* The following table shows the valid geometry strings and their
43	* effects on the background image :
44	*
45	* WxH+X+Y Set scaling to W% by H%, and position to X% by Y%.
46	* W and H are percentages of the terminal window size.
47	* X and Y are also percentages; e.g., +50+50 centers
48	* the image in the window.
49	*
50	* Pixmap Operations : (should be prepended by a colon)
51	* 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	*/
61		40
62	#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
63	void	60	void
64	rxvt_term::bg_destroy ()	61	rxvt_term::bg_destroy ()
65	{	62	{
66	#ifdef HAVE_AFTERIMAGE
67	if (original_asim)
68	safe_asimage_destroy (original_asim);
69	if (asv)
70	destroy_asvisual (asv, 0);
71	if (asimman)
72	destroy_image_manager (asimman, 0);
73	#endif
74
75	#ifdef HAVE_PIXBUF	63	#ifdef HAVE_PIXBUF
76	if (pixbuf)	64	if (pixbuf)
77	g_object_unref (pixbuf);	65	g_object_unref (pixbuf);
78	#endif	66	#endif
79		67
…		…
132		120
133	return false;	121	return false;
134	}	122	}
135		123
136	# ifdef BG_IMAGE_FROM_FILE	124	# ifdef BG_IMAGE_FROM_FILE
137	static inline bool
138	check_set_scale_value (int geom_flags, int flag, unsigned int &scale, unsigned int new_value)
139	{
140	if (geom_flags & flag)
141	{
142	if (new_value > 1000)
143	new_value = 1000;
144	if (new_value != scale)
145	{
146	scale = new_value;
147	return true;
148	}
149	}
150	return false;
151	}
152
153	static inline bool
154	check_set_align_value (int geom_flags, int flag, int &align, int new_value)
155	{
156	if (geom_flags & flag)
157	{
158	if (new_value < -100)
159	new_value = -100;
160	else if (new_value > 200)
161	new_value = 200;
162	if (new_value != align)
163	{
164	align = new_value;
165	return true;
166	}
167	}
168	return false;
169	}
170
171	static inline int	125	static inline int
172	make_align_position (int align, int window_size, int image_size)	126	make_align_position (int align, int window_size, int image_size)
173	{	127	{
174	int diff = window_size - image_size;	128	int diff = window_size - image_size;
175	int smaller = min (image_size, window_size);	129	int smaller = min (image_size, window_size);
176		130
177	if (align >= 0 && align <= 100)	131	if (align >= 0 && align <= 100)
178	return diff * align / 100;	132	return diff * align / 100;
179	else if (align > 100 && align <= 200)	133	else if (align > 100 && align <= 200)
180	return ((align - 100) * smaller / 100) + window_size - smaller;	134	return (align - 100) * smaller / 100 + window_size - smaller;
181	else if (align >= -100 && align < 0)	135	else if (align >= -100 && align < 0)
182	return ((align + 100) * smaller / 100) - image_size;	136	return (align + 100) * smaller / 100 - image_size;
183	return 0;	137	return 0;
184	}	138	}
185		139
186	static inline int	140	static inline int
187	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)
…		…
194	src_pos = -pos;	148	src_pos = -pos;
195	dst_pos = 0;	149	dst_pos = 0;
196	dst_size += pos;	150	dst_size += pos;
197	}	151	}
198		152
199	if (dst_pos + dst_size > target_size)
200	dst_size = target_size - dst_pos;	153	min_it (dst_size, target_size - dst_pos);
201	return src_pos;	154	return src_pos;
202	}	155	}
203		156
204	bool	157	bool
205	rxvt_term::bg_set_geometry (const char *geom, bool update)	158	rxvt_term::bg_set_geometry (const char *geom, bool update)
206	{	159	{
207	bool changed = false;	160	bool changed = false;
208	int geom_flags = 0;	161	int geom_flags = 0;
209	int x = 0, y = 0;	162	int x = h_align;
		163	int y = v_align;
210	unsigned int w = 0, h = 0;	164	unsigned int w = h_scale;
211	unsigned int n;	165	unsigned int h = v_scale;
212	unsigned long new_flags = (bg_flags & (~BG_GEOMETRY_FLAGS));	166	unsigned long new_flags = 0;
213	const char *ops;
214		167
215	if (geom == NULL)	168	if (geom == NULL)
216	return false;	169	return false;
217		170
218	char str[256];	171	if (geom[0])
219
220	ops = strchr (geom, ':');
221	if (ops == NULL)
222	n = strlen (geom);
223	else
224	n = ops - geom;
225
226	if (n >= sizeof (str))
227	return false;
228
229	memcpy (str, geom, n);
230	str[n] = '\0';
231	rxvt_strtrim (str);
232
233	if (str[0])
234	{	172	{
235	/* 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
236	geom_flags = XParseGeometry (str, &x, &y, &w, &h);	263	geom_flags \|= XParseGeometry (arr[i], &x, &y, &w, &h);
237	} /* done parsing geometry string */	264	} /* done parsing ops */
		265
		266	rxvt_free_strsplit (arr);
		267	}
		268
		269	new_flags \|= bg_flags & ~BG_GEOMETRY_FLAGS;
238		270
239	if (!update)	271	if (!update)
240	{	272	{
241	if (!(geom_flags & XValue))	273	if (!(geom_flags & XValue))
242	x = y = defaultAlign;	274	x = y = defaultAlign;
…		…
247	w = h = defaultScale;	279	w = h = defaultScale;
248	else if (!(geom_flags & HeightValue))	280	else if (!(geom_flags & HeightValue))
249	h = w;	281	h = w;
250	else if (!(geom_flags & WidthValue))	282	else if (!(geom_flags & WidthValue))
251	w = h;	283	w = h;
252
253	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;
254	}
255
256	if (ops)
257	{	284	}
258	char **arr = rxvt_strsplit (':', ops + 1);
259		285
260	for (int i = 0; arr[i]; i++)	286	min_it (w, 1000);
261	{	287	min_it (h, 1000);
262	if (!strcasecmp (arr[i], "tile"))	288	clamp_it (x, -100, 200);
263	{	289	clamp_it (y, -100, 200);
264	new_flags \|= BG_TILE;
265	w = h = noScale;
266	geom_flags \|= WidthValue\|HeightValue;
267	}
268	else if (!strcasecmp (arr[i], "propscale"))
269	{
270	new_flags \|= BG_PROP_SCALE;
271	}
272	else if (!strcasecmp (arr[i], "hscale"))
273	{
274	if (w == 0) w = windowScale;
275		290
276	h = noScale;	291	if (bg_flags != new_flags
277	geom_flags \|= WidthValue\|HeightValue;	292	\|\| h_scale != w
278	}	293	\|\| v_scale != h
279	else if (!strcasecmp (arr[i], "vscale"))	294	\|\| h_align != x
280	{	295	\|\| v_align != y)
281	if (h == 0) h = windowScale;
282
283	w = noScale;
284	geom_flags \|= WidthValue\|HeightValue;
285	}
286	else if (!strcasecmp (arr[i], "scale"))
287	{
288	if (h == 0) h = windowScale;
289	if (w == 0) w = windowScale;
290
291	geom_flags \|= WidthValue\|HeightValue;
292	}
293	else if (!strcasecmp (arr[i], "root"))
294	{
295	new_flags \|= BG_TILE\|BG_ROOT_ALIGN;
296	w = h = noScale;
297	geom_flags \|= WidthValue\|HeightValue;
298	}
299	} /* done parsing ops */
300
301	rxvt_free_strsplit (arr);
302	}
303
304	if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true;
305	if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true;
306	if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true;
307	if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true;
308
309	if (new_flags != bg_flags)
310	{	296	{
311	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;
312	changed = true;	302	changed = true;
313	}	303	}
314		304
315	return changed;	305	return changed;
316	}	306	}
…		…
319	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)
320	{	310	{
321	int target_width = szHint.width;	311	int target_width = szHint.width;
322	int target_height = szHint.height;	312	int target_height = szHint.height;
323		313
		314	w = h_scale * target_width / 100;
		315	h = v_scale * target_height / 100;
		316
324	if (bg_flags & BG_PROP_SCALE)	317	if (bg_flags & BG_KEEP_ASPECT)
325	{	318	{
326	float scale = (float)target_width / image_width;	319	float scale = (float)w / image_width;
327	min_it (scale, (float)target_height / image_height);	320	min_it (scale, (float)h / image_height);
328	w = image_width * scale + 0.5;	321	w = image_width * scale + 0.5;
329	h = image_height * scale + 0.5;	322	h = image_height * scale + 0.5;
330	}	323	}
331	else
332	{
333	w = h_scale * target_width / 100;
334	h = v_scale * target_height / 100;
335	}
336		324
337	if (!w) w = image_width;	325	if (!w) w = image_width;
338	if (!h) h = image_height;	326	if (!h) h = image_height;
339		327
340	if (bg_flags & BG_ROOT_ALIGN)	328	if (bg_flags & BG_ROOT_ALIGN)
…		…
348	y = make_align_position (v_align, target_height, h);	336	y = make_align_position (v_align, target_height, h);
349	}	337	}
350		338
351	bg_flags &= ~BG_IS_SIZE_SENSITIVE;	339	bg_flags &= ~BG_IS_SIZE_SENSITIVE;
352	if (!(bg_flags & BG_TILE)	340	if (!(bg_flags & BG_TILE)
353	\|\| (bg_flags & BG_PROP_SCALE) \|\| h_scale \|\| v_scale	341	\|\| h_scale \|\| v_scale
354	\|\| (!(bg_flags & BG_ROOT_ALIGN) && (h_align \|\| v_align))	342	\|\| (!(bg_flags & BG_ROOT_ALIGN) && (h_align \|\| v_align))
355	\|\| w > target_width \|\| h > target_height)	343	\|\| w > target_width \|\| h > target_height)
356	bg_flags \|= BG_IS_SIZE_SENSITIVE;	344	bg_flags \|= BG_IS_SIZE_SENSITIVE;
357	}	345	}
358
359	# ifdef HAVE_AFTERIMAGE
360	bool
361	rxvt_term::render_image (unsigned long tr_flags)
362	{
363	init_asv ();
364
365	ASImage *background = NULL;
366	ARGB32 background_tint = TINT_LEAVE_SAME;
367
368	# ifdef ENABLE_TRANSPARENCY
369	if (tr_flags)
370	background = pixmap2ximage (asv, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, 100);
371
372	if (tr_flags & BG_NEEDS_TINT)
373	{
374	ShadingInfo as_shade;
375	as_shade.shading = shade;
376
377	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
378	if (bg_flags & BG_TINT_SET)
379	tint.get (c);
380	as_shade.tintColor.red = c.r;
381	as_shade.tintColor.green = c.g;
382	as_shade.tintColor.blue = c.b;
383
384	background_tint = shading2tint32 (&as_shade);
385	}
386
387	if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)
388	{
389	ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,
390	(original_asim == NULL \|\| tint == TINT_LEAVE_SAME) ? ASA_XImage : ASA_ASImage,
391	100, ASIMAGE_QUALITY_DEFAULT);
392	if (tmp)
393	{
394	destroy_asimage (&background);
395	background = tmp;
396	}
397	}
398	# endif
399
400	ASImage *result = 0;
401
402	int target_width = szHint.width;
403	int target_height = szHint.height;
404	int new_pmap_width = target_width;
405	int new_pmap_height = target_height;
406
407	int x = 0;
408	int y = 0;
409	int w = 0;
410	int h = 0;
411
412	if (original_asim)
413	get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
414
415	if (!original_asim
416	\|\| (!(bg_flags & BG_ROOT_ALIGN)
417	&& (x >= target_width
418	\|\| y >= target_height
419	\|\| (x + w <= 0)
420	\|\| (y + h <= 0))))
421	{
422	if (background)
423	{
424	new_pmap_width = background->width;
425	new_pmap_height = background->height;
426	result = background;
427
428	if (background_tint != TINT_LEAVE_SAME)
429	{
430	ASImage *tmp = tile_asimage (asv, background, 0, 0,
431	target_width, target_height, background_tint,
432	ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
433	if (tmp)
434	result = tmp;
435	}
436	}
437	else
438	new_pmap_width = new_pmap_height = 0;
439	}
440	else
441	{
442	result = original_asim;
443
444	if ((w != original_asim->width)
445	\|\| (h != original_asim->height))
446	{
447	result = scale_asimage (asv, original_asim,
448	w, h,
449	background ? ASA_ASImage : ASA_XImage,
450	100, ASIMAGE_QUALITY_DEFAULT);
451	}
452
453	if (background == NULL)
454	{
455	if (bg_flags & BG_TILE)
456	{
457	/* if tiling - pixmap has to be sized exactly as the image,
458	but there is no need to make it bigger than the window! */
459	new_pmap_width = min (result->width, target_width);
460	new_pmap_height = min (result->height, target_height);
461
462	/* we also need to tile our image in both directions */
463	ASImage *tmp = tile_asimage (asv, result,
464	(int)result->width - x,
465	(int)result->height - y,
466	new_pmap_width,
467	new_pmap_height,
468	TINT_LEAVE_SAME, ASA_XImage,
469	100, ASIMAGE_QUALITY_DEFAULT);
470	if (tmp)
471	{
472	if (result != original_asim)
473	destroy_asimage (&result);
474
475	result = tmp;
476	}
477	}
478	}
479	else
480	{
481	/* if blending background and image - pixmap has to be sized same as target window */
482	ASImageLayer *layers = create_image_layers (2);
483
484	layers[0].im = background;
485	layers[0].clip_width = target_width;
486	layers[0].clip_height = target_height;
487	layers[0].tint = background_tint;
488	layers[1].im = result;
489
490	if (bg_flags & BG_TILE)
491	{
492	/* tile horizontally */
493	while (x > 0) x -= (int)result->width;
494	layers[1].dst_x = x;
495	layers[1].clip_width = result->width+target_width;
496	}
497	else
498	{
499	/* clip horizontally */
500	layers[1].dst_x = x;
501	layers[1].clip_width = result->width;
502	}
503
504	if (bg_flags & BG_TILE)
505	{
506	while (y > 0) y -= (int)result->height;
507	layers[1].dst_y = y;
508	layers[1].clip_height = result->height + target_height;
509	}
510	else
511	{
512	layers[1].dst_y = y;
513	layers[1].clip_height = result->height;
514	}
515
516	if (rs[Rs_blendtype])
517	{
518	layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
519	if (layers[1].merge_scanlines == NULL)
520	layers[1].merge_scanlines = alphablend_scanlines;
521	}
522
523	ASImage *tmp = merge_layers (asv, layers, 2, target_width, target_height,
524	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
525
526	if (tmp)
527	{
528	if (result != original_asim)
529	destroy_asimage (&result);
530
531	result = tmp;
532	}
533
534	free (layers);
535	}
536	}
537
538	bool ret = false;
539
540	if (result)
541	{
542	XGCValues gcv;
543	GC gc;
544
545	/* create Pixmap */
546	if (bg_pixmap == None
547	\|\| bg_pmap_width != new_pmap_width
548	\|\| bg_pmap_height != new_pmap_height)
549	{
550	if (bg_pixmap)
551	XFreePixmap (dpy, bg_pixmap);
552	bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
553	bg_pmap_width = new_pmap_width;
554	bg_pmap_height = new_pmap_height;
555	}
556	/* fill with background color (if result's not completely overlapping it) */
557	gcv.foreground = pix_colors[Color_bg];
558	gc = XCreateGC (dpy, vt, GCForeground, &gcv);
559
560	int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
561	int dst_width = result->width, dst_height = result->height;
562	if (background == NULL)
563	{
564	if (!(bg_flags & BG_TILE))
565	{
566	src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );
567	src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
568	}
569
570	if (dst_x > 0 \|\| dst_y > 0
571	\|\| dst_x + dst_width < new_pmap_width
572	\|\| dst_y + dst_height < new_pmap_height)
573	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
574	}
575
576	/* put result on pixmap */
577	if (dst_x < new_pmap_width && dst_y < new_pmap_height)
578	asimage2drawable (asv, bg_pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);
579
580	if (result != background && result != original_asim)
581	destroy_asimage (&result);
582
583	XFreeGC (dpy, gc);
584
585	ret = true;
586	}
587
588	if (background)
589	destroy_asimage (&background);
590
591	return ret;
592	}
593	# endif /* HAVE_AFTERIMAGE */
594		346
595	# ifdef HAVE_PIXBUF	347	# ifdef HAVE_PIXBUF
596	bool	348	bool
597	rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,	349	rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
598	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,
…		…
704	get_image_geometry (image_width, image_height, w, h, x, y);	456	get_image_geometry (image_width, image_height, w, h, x, y);
705		457
706	if (!(bg_flags & BG_ROOT_ALIGN)	458	if (!(bg_flags & BG_ROOT_ALIGN)
707	&& (x >= target_width	459	&& (x >= target_width
708	\|\| y >= target_height	460	\|\| y >= target_height
709	\|\| (x + w <= 0)	461	\|\| x + w <= 0
710	\|\| (y + h <= 0)))	462	\|\| y + h <= 0))
711	return false;	463	return false;
712		464
713	result = pixbuf;	465	result = pixbuf;
714		466
715	if ((w != image_width)	467	if (w != image_width
716	\|\| (h != image_height))	468	\|\| h != image_height)
717	{	469	{
718	result = gdk_pixbuf_scale_simple (pixbuf,	470	result = gdk_pixbuf_scale_simple (pixbuf,
719	w, h,	471	w, h,
720	GDK_INTERP_BILINEAR);	472	GDK_INTERP_BILINEAR);
721	}	473	}
…		…
800	}	552	}
801		553
802	#if XRENDER	554	#if XRENDER
803	if (tr_flags)	555	if (tr_flags)
804	{	556	{
805	XRenderPictureAttributes pa;
806
807	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, visual);	557	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
		558
808	Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa);	559	Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
809		560
810	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
811	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, dst_format, 0, &pa);	561	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
812		562
813	pa.repeat = True;	563	Picture mask = create_xrender_mask (dpy, vt, False, False);
814	Pixmap mask_pmap = XCreatePixmap (dpy, vt, 1, 1, 8);
815	XRenderPictFormat *mask_format = XRenderFindStandardFormat (dpy, PictStandardA8);
816	Picture mask = XRenderCreatePicture (dpy, mask_pmap, mask_format, CPRepeat, &pa);
817	XFreePixmap (dpy, mask_pmap);
818		564
819	XRenderColor mask_c;	565	XRenderColor mask_c;
820		566
821	mask_c.alpha = 0x8000;	567	mask_c.alpha = 0x8000;
822	mask_c.red = 0;	568	mask_c.red =
823	mask_c.green = 0;	569	mask_c.green =
824	mask_c.blue = 0;	570	mask_c.blue = 0;
825	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);	571	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
		572
826	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);
827		574
828	XRenderFreePicture (dpy, src);	575	XRenderFreePicture (dpy, src);
829	XRenderFreePicture (dpy, dst);	576	XRenderFreePicture (dpy, dst);
830	XRenderFreePicture (dpy, mask);	577	XRenderFreePicture (dpy, mask);
…		…
850	rxvt_term::bg_set_file (const char *file)	597	rxvt_term::bg_set_file (const char *file)
851	{	598	{
852	if (!file \|\| !*file)	599	if (!file \|\| !*file)
853	return false;	600	return false;
854		601
		602	bool ret = false;
855	if (const char *p = strchr (file, ';'))	603	const char *p = strchr (file, ';');
		604
		605	if (p)
856	{	606	{
857	size_t len = p - file;	607	size_t len = p - file;
858	char *f = rxvt_temp_buf<char> (len + 1);	608	char *f = rxvt_temp_buf<char> (len + 1);
859	memcpy (f, file, len);	609	memcpy (f, file, len);
860	f[len] = '\0';	610	f[len] = '\0';
861	file = f;	611	file = f;
862	}	612	}
863		613
864	# ifdef HAVE_AFTERIMAGE
865	if (!asimman)
866	asimman = create_generic_imageman (rs[Rs_path]);
867	ASImage *image = get_asimage (asimman, file, 0xFFFFFFFF, 100);
868	if (image)
869	{
870	if (original_asim)
871	safe_asimage_destroy (original_asim);
872	original_asim = image;
873	bg_flags \|= BG_IS_FROM_FILE \| BG_CLIENT_RENDER;
874	return true;
875	}
876	# endif
877
878	# ifdef HAVE_PIXBUF	614	# ifdef HAVE_PIXBUF
879	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);	615	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
880	if (image)	616	if (image)
881	{	617	{
882	if (pixbuf)	618	if (pixbuf)
883	g_object_unref (pixbuf);	619	g_object_unref (pixbuf);
884	pixbuf = image;	620	pixbuf = image;
885	bg_flags \|= BG_IS_FROM_FILE;	621	bg_flags \|= BG_IS_FROM_FILE;
886	return true;	622	ret = true;
887	}	623	}
888	# endif	624	# endif
889		625
		626	if (ret)
		627	{
		628	if (p)
		629	bg_set_geometry (p + 1);
		630	else
		631	bg_set_default_geometry ();
		632	}
		633
890	return false;	634	return ret;
891	}	635	}
892		636
893	# endif /* BG_IMAGE_FROM_FILE */	637	# endif /* BG_IMAGE_FROM_FILE */
894		638
895	# ifdef ENABLE_TRANSPARENCY	639	# ifdef ENABLE_TRANSPARENCY
…		…
931	{	675	{
932	changed = true;	676	changed = true;
933	v_blurRadius = vr;	677	v_blurRadius = vr;
934	}	678	}
935		679
936	if (v_blurRadius == 0 && h_blurRadius == 0)	680	if (h_blurRadius == 0 \|\| v_blurRadius == 0)
937	bg_flags &= ~BG_NEEDS_BLUR;	681	bg_flags &= ~BG_NEEDS_BLUR;
938	else	682	else
939	bg_flags \|= BG_NEEDS_BLUR;	683	bg_flags \|= BG_NEEDS_BLUR;
940		684
941	return changed;	685	return changed;
942	}	686	}
943		687
944	void	688	void
945	rxvt_term::set_tint_shade_flags ()	689	rxvt_term::set_tint_shade_flags ()
946	{	690	{
947	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);	691	rgba c;
948	bool has_shade = shade != 100;	692	bool has_shade = shade != 100;
949		693
950	bg_flags &= ~BG_TINT_FLAGS;	694	bg_flags &= ~BG_TINT_FLAGS;
951		695
952	if (bg_flags & BG_TINT_SET)	696	if (bg_flags & BG_TINT_SET)
…		…
978	}	722	}
979		723
980	bool	724	bool
981	rxvt_term::bg_set_shade (const char *shade_str)	725	rxvt_term::bg_set_shade (const char *shade_str)
982	{	726	{
983	int new_shade = (shade_str) ? atoi (shade_str) : 100;	727	int new_shade = atoi (shade_str);
984		728
985	clamp_it (new_shade, -100, 200);	729	clamp_it (new_shade, -100, 200);
986	if (new_shade < 0)	730	if (new_shade < 0)
987	new_shade = 200 - (100 + new_shade);	731	new_shade = 200 - (100 + new_shade);
988		732
…		…
1018	params[i+2] = XDoubleToFixed (kernel[i] / sum);	762	params[i+2] = XDoubleToFixed (kernel[i] / sum);
1019	}	763	}
1020	#endif	764	#endif
1021		765
1022	bool	766	bool
1023	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)
1024	{	768	{
1025	bool ret = false;	769	bool ret = false;
1026	#if XRENDER	770	#if XRENDER
		771	if (!(bg_flags & BG_HAS_RENDER_CONV))
		772	return false;
		773
1027	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;	774	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1028	double kernel = (double )malloc (size * sizeof (double));	775	double kernel = (double )malloc (size * sizeof (double));
1029	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));	776	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));
1030		777
1031	XRenderPictureAttributes pa;	778	XRenderPictureAttributes pa;
1032	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	779	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1033		780
		781	pa.repeat = RepeatPad;
1034	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);
1035	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	784	Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
		785	XFreePixmap (dpy, tmp);
1036		786
1037	if (kernel && params)	787	if (kernel && params)
1038	{	788	{
1039	if (h_blurRadius)
1040	{
1041	size = h_blurRadius * 2 + 1;	789	size = h_blurRadius * 2 + 1;
1042	get_gaussian_kernel (h_blurRadius, size, kernel, params);	790	get_gaussian_kernel (h_blurRadius, size, kernel, params);
1043		791
1044	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	792	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1045	XRenderComposite (dpy,	793	XRenderComposite (dpy,
1046	PictOpSrc,	794	PictOpSrc,
1047	src,	795	src,
1048	None,	796	None,
1049	dst,	797	dst,
1050	0, 0,	798	0, 0,
1051	0, 0,	799	0, 0,
1052	0, 0,	800	0, 0,
1053	width, height);	801	width, height);
1054	}
1055		802
1056	if (v_blurRadius)	803	::swap (src, dst);
1057	{	804
1058	size = v_blurRadius * 2 + 1;	805	size = v_blurRadius * 2 + 1;
1059	get_gaussian_kernel (v_blurRadius, size, kernel, params);	806	get_gaussian_kernel (v_blurRadius, size, kernel, params);
1060	::swap (params[0], params[1]);	807	::swap (params[0], params[1]);
1061		808
1062	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	809	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1063	XRenderComposite (dpy,	810	XRenderComposite (dpy,
1064	PictOpSrc,	811	PictOpSrc,
1065	src,	812	src,
1066	None,	813	None,
1067	dst,	814	dst,
1068	0, 0,	815	0, 0,
1069	0, 0,	816	0, 0,
1070	0, 0,	817	0, 0,
1071	width, height);	818	width, height);
1072	}
1073		819
1074	ret = true;	820	ret = true;
1075	}	821	}
1076		822
1077	free (kernel);	823	free (kernel);
…		…
1104	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);	850	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1105	ret = true;	851	ret = true;
1106	XFreeGC (dpy, gc);	852	XFreeGC (dpy, gc);
1107	}	853	}
1108	}	854	}
1109	else
1110	{
1111	# if XRENDER	855	# if XRENDER
		856	else if (bg_flags & BG_HAS_RENDER)
		857	{
1112	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);	858	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1113		859
1114	if (bg_flags & BG_TINT_SET)	860	if (bg_flags & BG_TINT_SET)
1115	tint.get (c);	861	tint.get (c);
1116		862
…		…
1125	c.r = c.r * (200 - shade) / 100;	871	c.r = c.r * (200 - shade) / 100;
1126	c.g = c.g * (200 - shade) / 100;	872	c.g = c.g * (200 - shade) / 100;
1127	c.b = c.b * (200 - shade) / 100;	873	c.b = c.b * (200 - shade) / 100;
1128	}	874	}
1129		875
1130	XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1131	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	876	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1132	XRenderPictureAttributes pa;
1133		877
1134	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	878	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1135		879
1136	pa.repeat = True;	880	Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1137		881
1138	Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);	882	Picture mask_pic = create_xrender_mask (dpy, pixmap, True, True);
1139	Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1140	XFreePixmap (dpy, overlay_pmap);
1141
1142	pa.component_alpha = True;
1143	Pixmap mask_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
1144	Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat \| CPComponentAlpha, &pa);
1145	XFreePixmap (dpy, mask_pmap);
1146		883
1147	XRenderColor mask_c;	884	XRenderColor mask_c;
1148		885
1149	mask_c.alpha = 0xffff;	886	mask_c.alpha = 0xffff;
1150	mask_c.red =	887	mask_c.red =
…		…
1155	mask_c.alpha = 0;	892	mask_c.alpha = 0;
1156	mask_c.red = 0xffff - c.r;	893	mask_c.red = 0xffff - c.r;
1157	mask_c.green = 0xffff - c.g;	894	mask_c.green = 0xffff - c.g;
1158	mask_c.blue = 0xffff - c.b;	895	mask_c.blue = 0xffff - c.b;
1159	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);	896	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
		897
1160	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);
1161		899
1162	if (shade > 100)	900	if (shade > 100)
1163	{	901	{
1164	mask_c.red = mask_c.green = mask_c.blue = 0xffff * (shade - 100) / 100;
1165	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;
1166	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);	906	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1167		907
1168	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);
1169	}	909	}
1170		910
1171	ret = true;	911	ret = true;
1172		912
1173	XRenderFreePicture (dpy, mask_pic);	913	XRenderFreePicture (dpy, mask_pic);
1174	XRenderFreePicture (dpy, overlay_pic);	914	XRenderFreePicture (dpy, overlay_pic);
1175	XRenderFreePicture (dpy, back_pic);	915	XRenderFreePicture (dpy, back_pic);
		916	}
1176	# endif	917	# endif
1177	}
1178		918
1179	return ret;	919	return ret;
1180	}	920	}
1181		921
1182	/*	922	/*
…		…
1233	#if XRENDER	973	#if XRENDER
1234	if (bg_flags & BG_HAS_RENDER)	974	if (bg_flags & BG_HAS_RENDER)
1235	{	975	{
1236	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);
1237		977
1238	XRenderPictureAttributes pa;
1239
1240	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));	978	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1241	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa);	979	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1242		980
1243	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);	981	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1244	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa);	982	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1245		983
1246	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);
1247		985
1248	XRenderFreePicture (dpy, src);	986	XRenderFreePicture (dpy, src);
1249	XRenderFreePicture (dpy, dst);	987	XRenderFreePicture (dpy, dst);
…		…
1266	bg_pmap_width = window_width;	1004	bg_pmap_width = window_width;
1267	bg_pmap_height = window_height;	1005	bg_pmap_height = window_height;
1268	}	1006	}
1269		1007
1270	/* straightforward pixmap copy */	1008	/* straightforward pixmap copy */
1271	while (sx < 0) sx += root_width;	1009	while (sx < 0) sx += root_pmap_width;
1272	while (sy < 0) sy += root_height;	1010	while (sy < 0) sy += root_pmap_height;
1273		1011
1274	gcv.tile = recoded_root_pmap;	1012	gcv.tile = recoded_root_pmap;
1275	gcv.fill_style = FillTiled;	1013	gcv.fill_style = FillTiled;
1276	gcv.ts_x_origin = -sx;	1014	gcv.ts_x_origin = -sx;
1277	gcv.ts_y_origin = -sy;	1015	gcv.ts_y_origin = -sy;
…		…
1279		1017
1280	if (gc)	1018	if (gc)
1281	{	1019	{
1282	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);	1020	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1283	result \|= BG_IS_VALID \| (bg_flags & BG_EFFECTS_FLAGS);	1021	result \|= BG_IS_VALID \| (bg_flags & BG_EFFECTS_FLAGS);
1284	XFreeGC (dpy, gc);
1285		1022
1286	if (!(bg_flags & BG_CLIENT_RENDER))	1023	if (!(bg_flags & BG_CLIENT_RENDER))
1287	{	1024	{
1288	if ((bg_flags & BG_NEEDS_BLUR)	1025	if (bg_flags & BG_NEEDS_BLUR)
1289	&& (bg_flags & BG_HAS_RENDER_CONV))
1290	{	1026	{
1291	if (blur_pixmap (bg_pixmap, visual, window_width, window_height))	1027	if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth))
1292	result &= ~BG_NEEDS_BLUR;	1028	result &= ~BG_NEEDS_BLUR;
1293	}	1029	}
1294	if ((bg_flags & BG_NEEDS_TINT)	1030	if (bg_flags & BG_NEEDS_TINT)
1295	&& (bg_flags & (BG_TINT_BITAND \| BG_HAS_RENDER)))
1296	{	1031	{
1297	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))	1032	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1298	result &= ~BG_NEEDS_TINT;	1033	result &= ~BG_NEEDS_TINT;
1299	}	1034	}
		1035	if (result & BG_NEEDS_TINT)
		1036	{
		1037	XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
		1038	if (ximage)
		1039	{
		1040	/* our own client-side tinting */
		1041	tint_ximage (DefaultVisual (dpy, display->screen), ximage);
		1042
		1043	XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
		1044	XDestroyImage (ximage);
		1045	}
		1046	}
1300	} /* server side rendering completed */	1047	} /* server side rendering completed */
		1048
		1049	XFreeGC (dpy, gc);
1301	}	1050	}
1302		1051
1303	if (recoded_root_pmap != root_pixmap)	1052	if (recoded_root_pmap != root_pixmap)
1304	XFreePixmap (dpy, recoded_root_pmap);	1053	XFreePixmap (dpy, recoded_root_pmap);
1305		1054
…		…
1315		1064
1316	root_pixmap = new_root_pixmap;	1065	root_pixmap = new_root_pixmap;
1317	}	1066	}
1318	# endif /* ENABLE_TRANSPARENCY */	1067	# endif /* ENABLE_TRANSPARENCY */
1319		1068
1320	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1321	static void shade_ximage (Visual visual, XImage ximage, int shade, const rgba &c);
1322	# endif
1323
1324	bool	1069	bool
1325	rxvt_term::bg_render ()	1070	rxvt_term::bg_render ()
1326	{	1071	{
1327	unsigned long tr_flags = 0;	1072	unsigned long tr_flags = 0;
1328		1073
…		…
1330	# ifdef ENABLE_TRANSPARENCY	1075	# ifdef ENABLE_TRANSPARENCY
1331	if (bg_flags & BG_IS_TRANSPARENT)	1076	if (bg_flags & BG_IS_TRANSPARENT)
1332	{	1077	{
1333	/* we need to re-generate transparency pixmap in that case ! */	1078	/* we need to re-generate transparency pixmap in that case ! */
1334	tr_flags = make_transparency_pixmap ();	1079	tr_flags = make_transparency_pixmap ();
1335	if (tr_flags == 0)	1080	if (tr_flags)
1336	return false;
1337	else if (!(tr_flags & BG_EFFECTS_FLAGS))
1338	bg_flags \|= BG_IS_VALID;	1081	bg_flags \|= BG_IS_VALID;
1339	}	1082	}
1340	# endif	1083	# endif
1341		1084
1342	# ifdef BG_IMAGE_FROM_FILE	1085	# ifdef BG_IMAGE_FROM_FILE
1343	if ((bg_flags & BG_IS_FROM_FILE)	1086	if ((bg_flags & BG_IS_FROM_FILE)
1344	\|\| (tr_flags & BG_EFFECTS_FLAGS))	1087	\|\| (tr_flags & BG_EFFECTS_FLAGS))
1345	{	1088	{
1346	if (render_image (tr_flags))	1089	if (render_image (tr_flags))
1347	bg_flags \|= BG_IS_VALID;	1090	bg_flags \|= BG_IS_VALID;
1348	}
1349	# endif
1350
1351	# if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1352	XImage *result = NULL;
1353
1354	if (tr_flags && !(bg_flags & BG_IS_VALID))
1355	{
1356	result = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1357	}
1358
1359	if (result)
1360	{
1361	/* our own client-side tinting */
1362	if (tr_flags & BG_NEEDS_TINT)
1363	{
1364	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1365	if (bg_flags & BG_TINT_SET)
1366	tint.get (c);
1367	shade_ximage (DefaultVisual (dpy, display->screen), result, shade, c);
1368	}
1369
1370	GC gc = XCreateGC (dpy, vt, 0UL, NULL);
1371
1372	if (gc)
1373	{
1374	XPutImage (dpy, bg_pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1375
1376	XFreeGC (dpy, gc);
1377	bg_flags \|= BG_IS_VALID;
1378	}
1379
1380	XDestroyImage (result);
1381	}	1091	}
1382	# endif	1092	# endif
1383		1093
1384	if (!(bg_flags & BG_IS_VALID))	1094	if (!(bg_flags & BG_IS_VALID))
1385	{	1095	{
…		…
1422	#endif	1132	#endif
1423	}	1133	}
1424		1134
1425	#endif /* HAVE_BG_PIXMAP */	1135	#endif /* HAVE_BG_PIXMAP */
1426		1136
1427	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)	1137	#ifdef ENABLE_TRANSPARENCY
1428	/* taken from aterm-0.4.2 */	1138	/* based on code from aterm-0.4.2 */
1429		1139
1430	static void	1140	static inline void
1431	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)
1432	{	1154	{
1433	int sh_r, sh_g, sh_b;	1155	int sh_r, sh_g, sh_b;
1434	uint32_t mask_r, mask_g, mask_b;	1156	uint32_t mask_r, mask_g, mask_b;
1435	uint32_t lookup, lookup_r, lookup_g, lookup_b;	1157	uint32_t lookup, lookup_r, lookup_g, lookup_b;
1436	rgba low;	1158	unsigned short low;
1437	rgba high;
1438	int i;
1439	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;	1159	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1440		1160
1441	if (visual->c_class != TrueColor \|\| ximage->format != ZPixmap) return;	1161	if (visual->c_class != TrueColor \|\| ximage->format != ZPixmap) return;
1442		1162
1443	/* for convenience */	1163	/* for convenience */
…		…
1502	break;	1222	break;
1503	default:	1223	default:
1504	return; /* we do not support this color depth */	1224	return; /* we do not support this color depth */
1505	}	1225	}
1506		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
1507	/* prepare limits for color transformation (each channel is handled separately) */	1232	/* prepare limits for color transformation (each channel is handled separately) */
1508	if (shade > 100)	1233	if (shade > 100)
1509	{	1234	{
1510	shade = 200 - shade;
1511
1512	high.r = c.r * shade / 100;
1513	high.g = c.g * shade / 100;
1514	high.b = c.b * shade / 100;
1515
1516	low.r = 65535 * (100 - shade) / 100;	1235	c.r = c.r * (200 - shade) / 100;
1517	low.g = 65535 * (100 - shade) / 100;	1236	c.g = c.g * (200 - shade) / 100;
1518	low.b = 65535 * (100 - shade) / 100;	1237	c.b = c.b * (200 - shade) / 100;
		1238
		1239	low = 0xffff * (shade - 100) / 100;
1519	}	1240	}
1520	else	1241	else
1521	{	1242	{
1522	high.r = c.r * shade / 100;	1243	c.r = c.r * shade / 100;
1523	high.g = c.g * shade / 100;	1244	c.g = c.g * shade / 100;
1524	high.b = c.b * shade / 100;	1245	c.b = c.b * shade / 100;
1525		1246
1526	low.r = low.g = low.b = 0;	1247	low = 0;
1527	}	1248	}
1528		1249
1529	/* fill our lookup tables */	1250	/* fill our lookup tables */
1530	for (i = 0; i <= mask_r>>sh_r; i++)	1251	fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1531	{	1252	fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1532	uint32_t tmp;	1253	fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1533	tmp = i * high.r;
1534	tmp += (mask_r>>sh_r) * low.r;
1535	lookup_r[i] = (tmp/65535)<<sh_r;
1536	}
1537	for (i = 0; i <= mask_g>>sh_g; i++)
1538	{
1539	uint32_t tmp;
1540	tmp = i * high.g;
1541	tmp += (mask_g>>sh_g) * low.g;
1542	lookup_g[i] = (tmp/65535)<<sh_g;
1543	}
1544	for (i = 0; i <= mask_b>>sh_b; i++)
1545	{
1546	uint32_t tmp;
1547	tmp = i * high.b;
1548	tmp += (mask_b>>sh_b) * low.b;
1549	lookup_b[i] = (tmp/65535)<<sh_b;
1550	}
1551		1254
1552	/* apply table to input image (replacing colors by newly calculated ones) */	1255	/* apply table to input image (replacing colors by newly calculated ones) */
1553	if (ximage->bits_per_pixel == 32	1256	if (ximage->bits_per_pixel == 32
1554	&& (ximage->depth == 24 \|\| ximage->depth == 32)	1257	&& (ximage->depth == 24 \|\| ximage->depth == 32)
1555	&& ximage->byte_order == host_byte_order)	1258	&& ximage->byte_order == host_byte_order)
…		…
1585	}	1288	}
1586	}	1289	}
1587		1290
1588	free (lookup);	1291	free (lookup);
1589	}	1292	}
1590	#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.157 by sf-exg, Tue Aug 9 21:48:00 2011 UTC vs. Revision 1.201 by sf-exg, Sat Feb 4 21:47:06 2012 UTC

Diff Legend

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.157 by sf-exg, Tue Aug 9 21:48:00 2011 UTC vs.
Revision 1.201 by sf-exg, Sat Feb 4 21:47:06 2012 UTC