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

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.153 by sf-exg, Sun May 8 21:07:43 2011 UTC vs.
Revision 1.193 by sf-exg, Sun Jan 1 14:31:29 2012 UTC

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

Diff Legend

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.153 by sf-exg, Sun May 8 21:07:43 2011 UTC vs.
Revision 1.193 by sf-exg, Sun Jan 1 14:31:29 2012 UTC