ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/rxvt-unicode/src/xpm.C

Comparing rxvt-unicode/src/xpm.C (file contents):
Revision 1.5 by pcg, Sat Jan 31 00:20:21 2004 UTC vs.
Revision 1.60 by sasha, Mon Aug 6 22:42:05 2007 UTC

1	/*--------------------------------*-C-*---------------------------------*	1	/*----------------------------------------------------------------------*
2	* File: xpm.c	2	* File: xpm.C
3	*----------------------------------------------------------------------*	3	*----------------------------------------------------------------------*
4	* $Id: xpm.C,v 1.5 2004/01/31 00:20:21 pcg Exp $
5	*	4	*
6	* All portions of code are copyright by their respective author/s.	5	* All portions of code are copyright by their respective author/s.
7	* Copyright (c) 1997 Carsten Haitzler <raster@zip.com.au>	6	* Copyright (c) 1997 Carsten Haitzler <raster@zip.com.au>
8	* Copyright (c) 1997,1998 Oezguer Kesim <kesim@math.fu-berlin.de>	7	* Copyright (c) 1997,1998 Oezguer Kesim <kesim@math.fu-berlin.de>
9	* Copyright (c) 1998-2001 Geoff Wing <gcw@pobox.com>	8	* Copyright (c) 1998-2001 Geoff Wing <gcw@pobox.com>
		9	* Copyright (c) 2005-2006 Marc Lehmann <pcg@goof.com>
10	*	10	*
11	* This program is free software; you can redistribute it and/or modify	11	* This program is free software; you can redistribute it and/or modify
12	* it under the terms of the GNU General Public License as published by	12	* it under the terms of the GNU General Public License as published by
13	* the Free Software Foundation; either version 2 of the License, or	13	* the Free Software Foundation; either version 2 of the License, or
14	* (at your option) any later version.	14	* (at your option) any later version.
…		…
23	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	23	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24	*---------------------------------------------------------------------*/	24	*---------------------------------------------------------------------*/
25		25
26	#include "../config.h" /* NECESSARY */	26	#include "../config.h" /* NECESSARY */
27	#include "rxvt.h" /* NECESSARY */	27	#include "rxvt.h" /* NECESSARY */
28	#include "xpm.intpro" /* PROTOS for internal routines */
29		28
		29	/*
		30	* Pixmap geometry string interpretation :
		31	* Each geometry string contains zero or one scale/position
		32	* adjustment and may optionally be followed by a colon and one or more
		33	* colon-delimited pixmap operations.
		34	* The following table shows the valid geometry strings and their
		35	* affects on the background image :
		36	*
		37	* WxH+X+Y Set scaling to W% by H%, and position to X% by Y%.
		38	* W and H are percentages of the terminal window size.
		39	* X and Y are also percentages; e.g., +50+50 centers
		40	* the image in the window.
		41	* WxH+X Assumes Y == X
		42	* WxH Assumes Y == X == 50 (centers the image)
		43	* W+X+Y Assumes H == W
		44	* W+X Assumes H == W and Y == X
		45	* W Assumes H == W and Y == X == 50
		46	*
		47	* Adjusting position only :
		48	* =+X+Y Set position to X% by Y% (absolute).
		49	* =+X Set position to X% by X%.
		50	* +X+Y Adjust position horizontally X% and vertically Y%
		51	* from current position (relative).
		52	* +X Adjust position horizontally X% and vertically X%
		53	* from current position.
		54	*
		55	* Adjusting scale only :
		56	* Wx0 Multiply horizontal scaling factor by W%
		57	* 0xH Multiply vertical scaling factor by H%
		58	* 0x0 No scaling (show image at normal size).
		59	*
		60	* Pixmap Operations : (should be prepended by a colon)
		61	* tile Tile image. Scaling/position modifiers above will affect
		62	* the tile size and origin.
		63	* propscale When scaling, scale proportionally. That is, maintain the
		64	* proper aspect ratio for the image. Any portion of the
		65	* background not covered by the image is filled with the
		66	* current background color.
		67	* hscale Scale horizontally, tile vertically ?
		68	* vscale Tile horizontally, scale vertically ?
		69	* scale Scale both up and down
		70	* auto Same as 100x100+50+50
		71	*/
		72
		73	#ifdef HAVE_BG_PIXMAP
		74	bool
		75	bgPixmap_t::window_size_sensitive ()
		76	{
30	#ifdef XPM_BACKGROUND	77	#ifdef XPM_BACKGROUND
		78	#ifdef HAVE_AFTERIMAGE
		79	if (original_asim != NULL)
		80	#endif
		81	{
		82	if (h_scale != 0 || v_scale != 0)
		83	return true;
		84	}
		85	#endif
		86	#ifdef ENABLE_TRANSPARENCY
		87	if (flags & bgPmap_Transparent)
		88	return true;
		89	#endif
		90	return false;
		91	}
31		92
32	/*	93	#ifdef XPM_BACKGROUND
33	* These GEOM strings indicate absolute size/position:	94	static inline bool
34	* @ `WxH+X+Y'	95	check_set_scale_value (int geom_flags, int flag, unsigned int &scale, unsigned int new_value)
35	* @ `WxH+X' -> Y = X
36	* @ `WxH' -> Y = X = 50
37	* @ `W+X+Y' -> H = W
38	* @ `W+X' -> H = W, Y = X
39	* @ `W' -> H = W, X = Y = 50
40	* @ `0xH' -> H *= H/100, X = Y = 50 (W unchanged)
41	* @ `Wx0' -> W *= W/100, X = Y = 50 (H unchanged)
42	* @ `=+X+Y' -> (H, W unchanged)
43	* @ `=+X' -> Y = X (H, W unchanged)
44	*
45	* These GEOM strings adjust position relative to current position:
46	* @ `+X+Y'
47	* @ `+X' -> Y = X
48	*
49	* And this GEOM string is for querying current scale/position:
50	* @ `?'
51	*/
52	int
53	rxvt_term::scale_pixmap (const char *geom)
54	{	96	{
55	int flags, changed = 0;	97	if (geom_flags & flag)
56	int x = 0, y = 0;
57	unsigned int w = 0, h = 0;
58	unsigned int n;
59	char *p, *str;
60	bgPixmap_t *bgpixmap = &(bgPixmap);
61
62	#define MAXLEN_GEOM sizeof("[1000x1000+1000+1000]")
63
64	if (geom == NULL)
65	return 0;
66	str = (char *)rxvt_malloc (MAXLEN_GEOM + 1);
67	if (!STRCMP(geom, "?")) {
68	sprintf(str, "[%dx%d+%d+%d]", /* can't presume snprintf() ! */
69	min(bgpixmap->w, 9999), min(bgpixmap->h, 9999),
70	min(bgpixmap->x, 9999), min(bgpixmap->y, 9999));
71	xterm_seq (XTerm_title, str, CHAR_ST);
72	free(str);
73	return 0;
74	}	98	{
75		99	if (new_value > 1000)
76	if ((p = STRCHR(geom, ';')) == NULL)	100	new_value = 1000;
77	p = STRCHR(geom, '\0');	101	if (new_value != scale)
78	n = (p - geom);	102	{
79	if (n <= MAXLEN_GEOM) {	103	scale = new_value;
80	STRNCPY(str, geom, n);	104	return true;
81	str[n] = '\0';	105	}
82
83	flags = XParseGeometry(str, &x, &y, &w, &h);
84	if (!flags) {
85	flags |= WidthValue;
86	w = 0;
87	} /* default is tile */
88	if (flags & WidthValue) {
89	if (!(flags & XValue))
90	x = 50;
91	if (!(flags & HeightValue))
92	h = w;
93	if (w && !h) {
94	w = (bgpixmap->w * w) / 100;
95	h = bgpixmap->h;
96	} else if (h && !w) {
97	w = bgpixmap->w;
98	h = (bgpixmap->h * h) / 100;
99	}	106	}
100	if (w > 1000)	107	return false;
101	w = 1000;
102	if (h > 1000)
103	h = 1000;
104	if (bgpixmap->w != (short)w) {
105	bgpixmap->w = (short)w;
106	changed++;
107	}
108	if (bgpixmap->h != (short)h) {
109	bgpixmap->h = (short)h;
110	changed++;
111	}
112	}
113	if (!(flags & YValue)) {
114	if (flags & XNegative)
115	flags |= YNegative;
116	y = x;
117	}
118
119	if (!(flags & WidthValue) && geom[0] != '=') {
120	x += bgpixmap->x;
121	y += bgpixmap->y;
122	} else {
123	if (flags & XNegative)
124	x += 100;
125	if (flags & YNegative)
126	y += 100;
127	}
128	MIN_IT(x, 100);
129	MIN_IT(y, 100);
130	MAX_IT(x, 0);
131	MAX_IT(y, 0);
132	if (bgpixmap->x != x) {
133	bgpixmap->x = x;
134	changed++;
135	}
136	if (bgpixmap->y != y) {
137	bgpixmap->y = y;
138	changed++;
139	}
140	}
141	free(str);
142	return changed;
143	}	108	}
		109
		110	static inline bool
		111	check_set_align_value (int geom_flags, int flag, int &align, int new_value)
		112	{
		113	if (geom_flags & flag)
		114	{
		115	if (new_value < -100)
		116	new_value = -100;
		117	else if (new_value > 200)
		118	new_value = 200;
		119	if (new_value != align)
		120	{
		121	align = new_value;
		122	return true;
		123	}
		124	}
		125	return false;
		126	}
		127
		128	static inline int
		129	make_align_position (int align, int window_size, int image_size)
		130	{
		131	int diff = window_size - image_size;
		132	int smaller = MIN (image_size,window_size);
		133
		134	if (align >= 0 && align <= 50)
		135	return diff * align / 100;
		136	else if (align > 50 && align <= 100)
		137	return window_size - image_size + diff * align / 100;
		138	else if (align > 100 && align <= 200 )
		139	return ((align - 100) * smaller / 100) + window_size - smaller;
		140	else if (align > -100 && align < 0)
		141	return ((align + 100) * smaller / 100) - image_size;
		142	return 0;
		143	}
		144
		145	static inline void
		146	make_clip_rectangle (int pos, int size, int target_size, int &clip_pos, int &clip_size)
		147	{
		148	if (size <= 0)
		149	{ /* special case - tiling */
		150	clip_pos = pos;
		151	clip_size = target_size;
		152	}
		153	else if (pos < 0)
		154	{
		155	clip_pos = 0;
		156	clip_size = MIN (target_size, size + pos);
		157	}
		158	else
		159	{
		160	clip_pos = pos;
		161	clip_size = size;
		162	if (pos < target_size && (int)clip_size > target_size - pos)
		163	clip_pos = target_size - pos;
		164	}
		165	}
		166
		167	bool
		168	bgPixmap_t::handle_geometry (const char *geom)
		169	{
		170	int geom_flags = 0, changed = 0;
		171	int x = 0, y = 0;
		172	unsigned int w = 0, h = 0;
		173	unsigned int n;
		174	unsigned long new_flags = (flags&(~bgPmap_geometryFlags));
		175	char *p;
		176	#define MAXLEN_GEOM 256 /* could be longer then regular geometry string */
		177
		178	if (geom == NULL)
		179	return false;
		180
		181	char str[MAXLEN_GEOM];
		182
		183	if (!strcmp (geom, "?"))
		184	{
		185	#if 0 /* TODO: */
		186	sprintf (str, "[%dx%d+%d+%d]", /* can't presume snprintf () ! */
		187	min (h_scale, 32767), min (v_scale, 32767),
		188	min (h_align, 32767), min (v_align, 32767));
		189	process_xterm_seq (XTerm_title, str, CHAR_ST);
		190	#endif
		191	return false;
		192	}
		193	while (isspace(*geom)) ++geom;
		194	if ((p = strchr (geom, ';')) == NULL)
		195	p = strchr (geom, '\0');
		196
		197	n = (p - geom);
		198	if (n < MAXLEN_GEOM)
		199	{
		200	char *ops;
		201	new_flags |= bgPmap_geometrySet;
		202
		203	strncpy (str, geom, n);
		204	str[n] = '\0';
		205	if (str[0] == ':')
		206	ops = &str[0];
		207	else if (str[0] != 'x' && str[0] != 'X' && isalpha(str[0]))
		208	ops = &str[0];
		209	else
		210	{
		211	char *tmp;
		212	ops = strchr (str, ':');
		213	if (ops != NULL)
		214	{
		215	for (tmp = ops-1; tmp >= str && isspace(*tmp); --tmp);
		216	*(++tmp) = '\0';
		217	if (ops == tmp) ++ops;
		218	}
		219	}
		220
		221	if (ops > str || ops == NULL)
		222	{
		223	/* we have geometry string - let's handle it prior to applying ops */
		224	geom_flags = XParseGeometry (str, &x, &y, &w, &h);
		225
		226	if ((geom_flags & XValue) && !(geom_flags & YValue))
		227	{
		228	y = x;
		229	geom_flags |= YValue;
		230	}
		231
		232	if (flags & bgPmap_geometrySet)
		233	{/* new geometry is an adjustment to the old one ! */
		234	if ((geom_flags & WidthValue) && (geom_flags & HeightValue))
		235	{
		236	if (w == 0 && h != 0)
		237	{
		238	w = h_scale;
		239	h = (v_scale * h) / 100;
		240	}
		241	else if (h == 0 && w != 0)
		242	{
		243	w = (h_scale * w) / 100;
		244	h = v_scale;
		245	}
		246	}
		247	if (geom_flags & XValue)
		248	{
		249	if (str[0] != '=')
		250	{
		251	y += v_align;
		252	x += h_align;
		253	}
		254	}
		255	}
		256	else /* setting up geometry from scratch */
		257	{
		258	if (!(geom_flags & XValue))
		259	{/* use default geometry - centered */
		260	x = y = bgPmap_defaultAlign;
		261	}
		262	else if (!(geom_flags & YValue))
		263	y = x;
		264
		265	if ((geom_flags & (WidthValue|HeightValue)) == 0)
		266	{/* use default geometry - scaled */
		267	w = h = bgPmap_defaultScale;
		268	}
		269	else if (geom_flags & WidthValue)
		270	{
		271	if (!(geom_flags & HeightValue))
		272	h = w;
		273	}
		274	else
		275	w = h;
		276	}
		277	} /* done parsing geometry string */
		278	else if (!(flags & bgPmap_geometrySet))
		279	{ /* default geometry - scaled and centered */
		280	x = y = bgPmap_defaultAlign;
		281	w = h = bgPmap_defaultScale;
		282	}
		283
		284	if (!(flags & bgPmap_geometrySet))
		285	geom_flags |= WidthValue|HeightValue|XValue|YValue;
		286
		287	if (ops)
		288	{
		289	while (*ops)
		290	{
		291	while (*ops == ':' || isspace(*ops)) ++ops;
		292	#define CHECK_GEOM_OPS(op_str) (strncasecmp (ops, (op_str), sizeof(op_str)-1) == 0)
		293	if (CHECK_GEOM_OPS("tile"))
		294	{
		295	w = h = 0;
		296	geom_flags |= WidthValue|HeightValue;
		297	}
		298	else if (CHECK_GEOM_OPS("propscale"))
		299	{
		300	if (w == 0 && h == 0)
		301	{
		302	w = 100;
		303	geom_flags |= WidthValue;
		304	}
		305	new_flags |= bgPmap_propScale;
		306	}
		307	else if (CHECK_GEOM_OPS("hscale"))
		308	{
		309	if (w == 0)
		310	w = 100;
		311	h = 0;
		312	geom_flags |= WidthValue|HeightValue;
		313	}
		314	else if (CHECK_GEOM_OPS("vscale"))
		315	{
		316	if (h == 0)
		317	h = 100;
		318	w = 0;
		319	geom_flags |= WidthValue|HeightValue;
		320	}
		321	else if (CHECK_GEOM_OPS("scale"))
		322	{
		323	if (h == 0)
		324	h = 100;
		325	if (w == 0)
		326	w = 100;
		327	geom_flags |= WidthValue|HeightValue;
		328	}
		329	else if (CHECK_GEOM_OPS("auto"))
		330	{
		331	w = h = 100;
		332	x = y = 50;
		333	geom_flags |= WidthValue|HeightValue|XValue|YValue;
		334	}
		335	#undef CHECK_GEOM_OPS
		336	while (*ops != ':' && *ops != '\0') ++ops;
		337	} /* done parsing ops */
		338	}
		339
		340	if (check_set_scale_value (geom_flags, WidthValue, h_scale, w))
		341	++changed;
		342	if (check_set_scale_value (geom_flags, HeightValue, v_scale, h))
		343	++changed;
		344	if (check_set_align_value (geom_flags, XValue, h_align, x))
		345	++changed;
		346	if (check_set_align_value (geom_flags, YValue, v_align, y))
		347	++changed;
		348	}
		349
		350	if (new_flags != flags)
		351	{
		352	flags = new_flags;
		353	changed++;
		354	}
		355	//fprintf( stderr, "flags = %lX, scale = %ux%u, align=%+d%+d\n",
		356	// flags, h_scale, v_scale, h_align, v_align);
		357	return (changed > 0);
		358	}
		359
		360	#ifdef HAVE_AFTERIMAGE
		361	bool
		362	bgPixmap_t::render_asim (rxvt_term *target, ASImage *background, ARGB32 background_tint)
		363	{
		364	if (target == NULL)
		365	return false;
		366
		367	int target_width = (int)target->szHint.width;
		368	int target_height = (int)target->szHint.height;
		369	int new_pmap_width = target_width, new_pmap_height = target_height;
		370	ASImage *result = NULL;
		371
		372	int x = 0;
		373	int y = 0;
		374	int w = h_scale * target_width / 100;
		375	int h = v_scale * target_height / 100;
		376
		377	if (original_asim)
		378	{
		379	x = make_align_position (h_align, target_width, w > 0 ? w : (int)original_asim->width);
		380	y = make_align_position (v_align, target_height, h > 0 ? h : (int)original_asim->height);
		381	}
		382
		383	int dst_x, dst_y;
		384	int clip_width, clip_height;
		385
		386	make_clip_rectangle (x, w, target_width, dst_x, clip_width);
		387	make_clip_rectangle (y, h, target_height, dst_y, clip_height);
		388
		389	/* TODO : actuall scaling code :) */
		390	if (dst_x >= target_width || dst_y >= target_height
		391	|| clip_width <= 0 || clip_height <= 0 || original_asim == NULL)
		392	{
		393	result = background;
		394	dst_x = dst_y = 0;
		395	if (background)
		396	{
		397	new_pmap_width = clip_width = background->width;
		398	new_pmap_height = clip_height = background->height;
		399	}
		400	else
		401	new_pmap_width = new_pmap_height = 0;
		402	}
		403	else
		404	{
		405	result = original_asim;
		406	if ((w > 0 && w != original_asim->width)
		407	|| (h > 0 && h != original_asim->height))
		408	{
		409	result = scale_asimage (target->asv, original_asim,
		410	w > 0 ? w : original_asim->width,
		411	h > 0 ? h : original_asim->height,
		412	background ? ASA_ASImage : ASA_XImage,
		413	100, ASIMAGE_QUALITY_DEFAULT);
		414	}
		415	if (background == NULL)
		416	{/* if tiling - pixmap has to be sized exactly as the image */
		417	if (h_scale == 0)
		418	new_pmap_width = result->width;
		419	if (v_scale == 0)
		420	new_pmap_height = result->height;
		421	}
		422	else
		423	{/* if blending background and image - pixmap has to be sized same as target window */
		424	ASImageLayer *layers = create_image_layers (2);
		425	ASImage *merged_im = NULL;
		426
		427	layers[0].im = background;
		428	layers[0].clip_width = target_width;
		429	layers[0].clip_height = target_height;
		430	layers[0].tint = background_tint;
		431	layers[1].im = result;
		432	if (w <= 0)
		433	{/* tile horizontally */
		434	layers[1].dst_x = dst_x - (int)result->width;
		435	layers[1].clip_width = result->width;
		436	}
		437	else
		438	{/* clip horizontally */
		439	layers[1].dst_x = dst_x;
		440	layers[1].clip_width = clip_width;
		441	}
		442	if (h <= 0)
		443	{
		444	layers[1].dst_y = dst_y - (int)result->height;
		445	layers[1].clip_height = result->height;
		446	}
		447	else
		448	{
		449	layers[1].dst_y = dst_y;
		450	layers[1].clip_height = clip_height;
		451	}
		452	if (target->rs[Rs_blendtype])
		453	{
		454	layers[1].merge_scanlines = blend_scanlines_name2func (target->rs[Rs_blendtype]);
		455	if (layers[1].merge_scanlines == NULL)
		456	layers[1].merge_scanlines = alphablend_scanlines;
		457	}
		458	ASImage *tmp = merge_layers (target->asv, layers, 2, target_width, target_height,
		459	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
		460	if (tmp)
		461	{
		462	if (result != original_asim)
		463	destroy_asimage (&result);
		464	result = tmp;
		465	dst_x = dst_y = 0;
		466	clip_width = target_width;
		467	clip_height = target_height;
		468	}
		469	free (layers);
		470	}
		471	}
		472
		473	if (pixmap)
		474	{
		475	if (result == NULL
		476	|| pmap_width != new_pmap_width
		477	|| pmap_height != new_pmap_height
		478	|| pmap_depth != target->depth)
		479	{
		480	XFreePixmap (target->dpy, pixmap);
		481	pixmap = None;
		482	}
		483	}
		484
		485	if (result)
		486	{
		487	XGCValues gcv;
		488	GC gc;
		489
		490	/* create Pixmap */
		491	if (pixmap == None)
		492	{
		493	pixmap = XCreatePixmap (target->dpy, target->vt, new_pmap_width, new_pmap_height, target->depth);
		494	pmap_width = new_pmap_width;
		495	pmap_height = new_pmap_height;
		496	pmap_depth = target->depth;
		497	}
		498	/* fill with background color ( if result's not completely overlapping it)*/
		499	gcv.foreground = target->pix_colors[Color_bg];
		500	gc = XCreateGC (target->dpy, target->vt, GCForeground, &gcv);
		501
		502	if (dst_x > 0 || dst_y > 0
		503	|| dst_x + clip_width < new_pmap_width
		504	|| dst_y + clip_height < new_pmap_height)
		505	{
		506	XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
		507	}
		508	/* put result on pixmap */
		509	asimage2drawable (target->asv, pixmap, result, gc, 0, 0, dst_x, dst_y, clip_width, clip_height, True);
		510
		511	/* set target's background to pixmap */
		512	XSetWindowBackgroundPixmap (target->dpy, target->vt, pixmap);
		513
		514	XFreeGC (target->dpy, gc);
		515	}
		516	else
		517	{
		518	/* set target background to a pixel */
		519	XSetWindowBackground (target->dpy, target->vt, target->pix_colors[Color_bg]);
		520	}
		521
		522	return true;
		523	}
		524	#endif
144		525
145	void	526	void
146	rxvt_term::resize_pixmap ()	527	rxvt_term::resize_pixmap ()
147	{	528	{
148	XGCValues gcvalue;	529	XGCValues gcvalue;
149	GC gc;	530	GC gc;
150	unsigned int width = TermWin_TotalWidth();	531	unsigned int w = bgPixmap.h_scale*szHint.width/100;
151	unsigned int height = TermWin_TotalHeight();	532	unsigned int h = bgPixmap.v_scale*szHint.height/100;
152		533	int x = bgPixmap.h_align*szHint.width/100;
		534	int y = bgPixmap.v_align*szHint.height/100;
		535	#ifdef HAVE_AFTERIMAGE
		536	ASImage *im = bgPixmap.original_asim;
		537	#else
		538	void *im = NULL;
		539	#endif
		540	/* preliminary cleanup - this needs to be integrated with check_our_parents() code */
153	if (TermWin.pixmap != None)	541	if (bgPixmap.pixmap != None)
154	XFreePixmap(Xdisplay, TermWin.pixmap);
155
156	if (bgPixmap.pixmap == None) { /* So be it: I'm not using pixmaps */
157	TermWin.pixmap = None;
158	if (!(Options & Opt_transparent) || am_transparent == 0)
159	XSetWindowBackground(Xdisplay, TermWin.vt,
160	PixColors[Color_bg]);
161	return;
162	}	542	{
		543	XFreePixmap (dpy, bgPixmap.pixmap);
		544	bgPixmap.pixmap = None ;
		545	}
		546	#ifdef ENABLE_TRANSPARENCY
		547	if (option(Opt_transparent) && am_transparent)
		548	{
		549	/* we need to re-generate transparency pixmap in that case ! */
		550	check_our_parents ();
		551	return;
		552	}
		553	#endif
163		554
		555	if (im == NULL)
		556	{ /* So be it: I'm not using pixmaps */
		557	XSetWindowBackground (dpy, vt, pix_colors[Color_bg]);
		558	return;
		559	}
		560
164	gcvalue.foreground = PixColors[Color_bg];	561	gcvalue.foreground = pix_colors[Color_bg];
165	gc = XCreateGC(Xdisplay, TermWin.vt, GCForeground, &gcvalue);	562	gc = XCreateGC (dpy, vt, GCForeground, &gcvalue);
166		563
167	if (bgPixmap.pixmap != None) { /* we have a specified pixmap */
168	unsigned int w = bgPixmap.w, h = bgPixmap.h,
169	x = bgPixmap.x, y = bgPixmap.y;
170	unsigned int xpmh = xpmAttr.height,
171	xpmw = xpmAttr.width;
172
173	/*
174	* don't zoom pixmap too much nor expand really small pixmaps	564	/* don't zoom pixmap too much nor expand really small pixmaps */
175	*/	565	if (w > 16000)
176	if (w > 1000 || h > 1000)
177	w = 1;	566	w = 1;
178	else if (width > (10 * xpmw)	567	if (h > 16000)
179	|| height > (10 * xpmh))	568	h = 1;
180	w = 0; /* tile */	569
181		570	#ifdef HAVE_AFTERIMAGE
182	if (w == 0) {	571	if (w == 0)
183	/* basic X tiling - let the X server do it */	572	w = im->width;
184	TermWin.pixmap = XCreatePixmap(Xdisplay, TermWin.vt,	573	if (h == 0)
185	xpmw, xpmh,	574	h = im->height;
186	(unsigned int)XDEPTH);
187	XCopyArea(Xdisplay, bgPixmap.pixmap, TermWin.pixmap, gc,
188	0, 0, xpmw, xpmh, 0, 0);
189	} else {
190	float incr, p;
191	Pixmap tmp;
192		575
193	TermWin.pixmap = XCreatePixmap(Xdisplay, TermWin.vt,	576	if (w != im->width || h != im->height)
194	width, height,	577	{
195	(unsigned int)XDEPTH);	578	ASImage *tmp = scale_asimage (asv, im, w, h, (x == 0 && y == 0)?ASA_XImage:ASA_ASImage, 0, ASIMAGE_QUALITY_DEFAULT);
196	/*	579	if (tmp != NULL)
197	* horizontal scaling	580	im = tmp;
198	*/
199	rxvt_pixmap_incr(&w, &x, &incr, &p, width, xpmw);
200
201	tmp = XCreatePixmap(Xdisplay, TermWin.vt,
202	width, xpmh, (unsigned int)XDEPTH);
203	XFillRectangle(Xdisplay, tmp, gc, 0, 0, width,
204	xpmh);
205
206	for ( /*nil */ ; x < w; x++, p += incr) {
207	if (p >= xpmw)
208	p = 0;
209	/* copy one column from the original pixmap to the tmp pixmap */
210	XCopyArea(Xdisplay, bgPixmap.pixmap, tmp, gc,
211	(int)p, 0, 1, xpmh, (int)x, 0);
212	}	581	}
213		582	bgPixmap.pmap_width = MIN(w,szHint.width);
214	/*	583	bgPixmap.pmap_height = MIN(h,szHint.height);
215	* vertical scaling	584	#if 0 /* TODO: fix that! */
216	*/	585	if (x != 0 || y != 0)
217	rxvt_pixmap_incr(&h, &y, &incr, &p, height, xpmh);	586	{
218		587	ASImage *tmp = tile_asimage (asv, im, x, y, w, h, TINT_LEAVE_SAME, ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
219	if (y > 0)	588	if (tmp != NULL)
220	XFillRectangle(Xdisplay, TermWin.pixmap, gc, 0, 0, width,	589	{
221	y);	590	if (im != bgPixmap.original_asim)
222	if (h < height)	591	destroy_asimage (&im);
223	XFillRectangle(Xdisplay, TermWin.pixmap, gc, 0, (int)h,	592	im = tmp;
224	width, height - h + 1);	593	}
225	for ( /*nil */ ; y < h; y++, p += incr) {
226	if (p >= xpmh)
227	p = 0;
228	/* copy one row from the tmp pixmap to the main pixmap */
229	XCopyArea(Xdisplay, tmp, TermWin.pixmap, gc,
230	0, (int)p, width, 1, 0, (int)y);
231	}	594	}
232	XFreePixmap(Xdisplay, tmp);	595	#endif
233	}	596	bgPixmap.pixmap = XCreatePixmap (dpy, vt, bgPixmap.pmap_width, bgPixmap.pmap_height, depth);
234	}	597	bgPixmap.pmap_depth = depth;
		598
		599	asimage2drawable (asv, bgPixmap.pixmap, im, gc, 0, 0, 0, 0, bgPixmap.pmap_width, bgPixmap.pmap_height, True);
		600
		601	if (im != bgPixmap.original_asim)
		602	destroy_asimage (&im);
		603	#endif
		604	if( bgPixmap.pixmap )
235	XSetWindowBackgroundPixmap(Xdisplay, TermWin.vt, TermWin.pixmap);	605	XSetWindowBackgroundPixmap (dpy, vt, bgPixmap.pixmap);
		606
236	XFreeGC(Xdisplay, gc);	607	XFreeGC (dpy, gc);
237	am_transparent = 0;
238
239	XClearWindow(Xdisplay, TermWin.vt);
240
241	XSync(Xdisplay, False);
242	}	608	}
243		609
244	/*
245	* Calculate tiling sizes and increments
246	* At start, p == 0, incr == xpmwidthheight
247	*/
248	void	610	void
249	rxvt_pixmap_incr(unsigned int *wh, unsigned int *xy, float *incr, float *p, unsigned int widthheight, unsigned int xpmwidthheight)
250	{
251	unsigned int cwh, cxy;
252	float cincr, cp;
253
254	cp = 0;
255	cincr = (float)xpmwidthheight;
256	cxy = *xy;
257	cwh = *wh;
258	if (cwh == 1) { /* display one image, no horizontal/vertical scaling */
259	cincr = (float)widthheight;
260	if (xpmwidthheight <= widthheight) {
261	cwh = xpmwidthheight;
262	cxy = (cxy * (widthheight - cwh)) / 100; /* beware! order */
263	cwh += cxy;
264	} else {
265	cxy = 0;
266	cwh = widthheight;
267	}
268	} else if (cwh < 10) { /* fit WH images across/down screen */
269	cincr *= cwh;
270	cxy = 0;
271	cwh = widthheight;
272	} else {
273	cincr *= 100.0 / cwh;
274	if (cwh < 100) { /* contract */
275	float pos;
276
277	cwh = (cwh * widthheight) / 100;
278	pos = (float)cxy / 100 * widthheight - (cwh / 2);
279
280	cxy = (widthheight - cwh);
281	if (pos <= 0)
282	cxy = 0;
283	else if (pos < cxy)
284	cxy = (int) pos;
285	cwh += cxy;
286	} else { /* expand */
287	if (cxy > 0) { /* position */
288	float pos;
289
290	pos = (float)cxy / 100 * xpmwidthheight - (cincr / 2);
291	cp = xpmwidthheight - cincr;
292	if (pos <= 0)
293	cp = 0;
294	else if (pos < cp)
295	cp = pos;
296	}
297	cxy = 0;
298	cwh = widthheight;
299	}
300	}
301	cincr /= widthheight;
302	*wh = cwh;
303	*xy = cxy;
304	*incr = cincr;
305	*p = cp;
306	}
307
308	Pixmap
309	rxvt_term::set_bgPixmap (const char *file)	611	rxvt_term::set_bgPixmap (const char *file)
310	{	612	{
311	char *f;	613	char *f;
312		614
313	assert(file != NULL);	615	assert (file != NULL);
314		616
315	if (bgPixmap.pixmap != None) {	617	if (bgPixmap.pixmap != None)
		618	{
316	XFreePixmap(Xdisplay, bgPixmap.pixmap);	619	XFreePixmap (dpy, bgPixmap.pixmap);
317	bgPixmap.pixmap = None;	620	bgPixmap.pixmap = None;
318	}	621	}
		622
319	XSetWindowBackground(Xdisplay, TermWin.vt, PixColors[Color_bg]);	623	XSetWindowBackground (dpy, vt, pix_colors[Color_bg]);
320
321	if (*file != '\0') {	624	if (*file != '\0')
322	/* XWindowAttributes attr; */
323
324	/*
325	* we already have the required attributes
326	*/
327	/* XGetWindowAttributes(Xdisplay, TermWin.vt, &attr); */
328
329	xpmAttr.closeness = 30000;
330	xpmAttr.colormap = XCMAP;
331	xpmAttr.visual = XVISUAL;
332	xpmAttr.depth = XDEPTH;
333	xpmAttr.valuemask = (XpmCloseness | XpmColormap | XpmVisual |
334	XpmDepth | XpmSize | XpmReturnPixels);
335
336	/* search environment variables here too */
337	f = (char *)rxvt_File_find(file, ".xpm", rs[Rs_path]);
338	if (f == NULL
339	|| XpmReadFileToPixmap(Xdisplay, Xroot, f,
340	&bgPixmap.pixmap, NULL,
341	&xpmAttr)) {
342	char *p;
343
344	/* semi-colon delimited */
345	if ((p = STRCHR(file, ';')) == NULL)
346	p = STRCHR(file, '\0');
347
348	rxvt_print_error("couldn't load XPM file \"%.*s\"", (p - file),
349	file);
350	}
351	free(f);
352	}	625	{
		626	#ifdef HAVE_AFTERIMAGE
		627	if (asimman == NULL)
		628	asimman = create_generic_imageman(rs[Rs_path]);
		629	if ((f = strchr (file, ';')) == NULL)
		630	bgPixmap.original_asim = get_asimage( asimman, file, 0xFFFFFFFF, 100 );
		631	else
		632	{
		633	size_t len = f - file;
		634	f = (char *)malloc (len + 1);
		635	strncpy (f, file, len);
		636	f[len] = '\0';
		637	bgPixmap.original_asim = get_asimage( asimman, f, 0xFFFFFFFF, 100 );
		638	free( f );
		639	}
		640	#endif
		641	}
		642
353	resize_pixmap ();	643	resize_pixmap ();
354	return bgPixmap.pixmap;
355	}	644	}
356		645
357	#endif /* XPM_BACKGROUND */	646	#endif /* XPM_BACKGROUND */
		647	#endif /* HAVE_BG_PIXMAP */
		648
		649	#ifdef ENABLE_TRANSPARENCY
		650	#ifndef HAVE_AFTERIMAGE
		651	/* taken from aterm-0.4.2 */
		652
		653	typedef uint32_t RUINT32T;
		654
		655	static void
		656	ShadeXImage(rxvt_term *term, XImage* srcImage, int shade, int rm, int gm, int bm)
		657	{
		658	int sh_r, sh_g, sh_b;
		659	RUINT32T mask_r, mask_g, mask_b;
		660	RUINT32T *lookup, *lookup_r, *lookup_g, *lookup_b;
		661	unsigned int lower_lim_r, lower_lim_g, lower_lim_b;
		662	unsigned int upper_lim_r, upper_lim_g, upper_lim_b;
		663	int i;
		664
		665	Visual *visual = term->visual;
		666
		667	if( visual->c_class != TrueColor || srcImage->format != ZPixmap ) return ;
		668
		669	/* for convenience */
		670	mask_r = visual->red_mask;
		671	mask_g = visual->green_mask;
		672	mask_b = visual->blue_mask;
		673
		674	/* boring lookup table pre-initialization */
		675	switch (srcImage->bits_per_pixel) {
		676	case 15:
		677	if ((mask_r != 0x7c00) ||
		678	(mask_g != 0x03e0) ||
		679	(mask_b != 0x001f))
		680	return;
		681	lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(32+32+32));
		682	lookup_r = lookup;
		683	lookup_g = lookup+32;
		684	lookup_b = lookup+32+32;
		685	sh_r = 10;
		686	sh_g = 5;
		687	sh_b = 0;
		688	break;
		689	case 16:
		690	if ((mask_r != 0xf800) ||
		691	(mask_g != 0x07e0) ||
		692	(mask_b != 0x001f))
		693	return;
		694	lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(32+64+32));
		695	lookup_r = lookup;
		696	lookup_g = lookup+32;
		697	lookup_b = lookup+32+64;
		698	sh_r = 11;
		699	sh_g = 5;
		700	sh_b = 0;
		701	break;
		702	case 24:
		703	if ((mask_r != 0xff0000) ||
		704	(mask_g != 0x00ff00) ||
		705	(mask_b != 0x0000ff))
		706	return;
		707	lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(256+256+256));
		708	lookup_r = lookup;
		709	lookup_g = lookup+256;
		710	lookup_b = lookup+256+256;
		711	sh_r = 16;
		712	sh_g = 8;
		713	sh_b = 0;
		714	break;
		715	case 32:
		716	if ((mask_r != 0xff0000) ||
		717	(mask_g != 0x00ff00) ||
		718	(mask_b != 0x0000ff))
		719	return;
		720	lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(256+256+256));
		721	lookup_r = lookup;
		722	lookup_g = lookup+256;
		723	lookup_b = lookup+256+256;
		724	sh_r = 16;
		725	sh_g = 8;
		726	sh_b = 0;
		727	break;
		728	default:
		729	return; /* we do not support this color depth */
		730	}
		731
		732	/* prepare limits for color transformation (each channel is handled separately) */
		733	if (shade < 0) {
		734	shade = -shade;
		735	if (shade < 0) shade = 0;
		736	if (shade > 100) shade = 100;
		737
		738	lower_lim_r = 65535-rm;
		739	lower_lim_g = 65535-gm;
		740	lower_lim_b = 65535-bm;
		741
		742	lower_lim_r = 65535-(unsigned int)(((RUINT32T)lower_lim_r)*((RUINT32T)shade)/100);
		743	lower_lim_g = 65535-(unsigned int)(((RUINT32T)lower_lim_g)*((RUINT32T)shade)/100);
		744	lower_lim_b = 65535-(unsigned int)(((RUINT32T)lower_lim_b)*((RUINT32T)shade)/100);
		745
		746	upper_lim_r = upper_lim_g = upper_lim_b = 65535;
		747	} else {
		748	if (shade < 0) shade = 0;
		749	if (shade > 100) shade = 100;
		750
		751	lower_lim_r = lower_lim_g = lower_lim_b = 0;
		752
		753	upper_lim_r = (unsigned int)((((RUINT32T)rm)*((RUINT32T)shade))/100);
		754	upper_lim_g = (unsigned int)((((RUINT32T)gm)*((RUINT32T)shade))/100);
		755	upper_lim_b = (unsigned int)((((RUINT32T)bm)*((RUINT32T)shade))/100);
		756	}
		757
		758	/* switch red and blue bytes if necessary, we need it for some weird XServers like XFree86 3.3.3.1 */
		759	if ((srcImage->bits_per_pixel == 24) && (mask_r >= 0xFF0000 ))
		760	{
		761	unsigned int tmp;
		762
		763	tmp = lower_lim_r;
		764	lower_lim_r = lower_lim_b;
		765	lower_lim_b = tmp;
		766
		767	tmp = upper_lim_r;
		768	upper_lim_r = upper_lim_b;
		769	upper_lim_b = tmp;
		770	}
		771
		772	/* fill our lookup tables */
		773	for (i = 0; i <= mask_r>>sh_r; i++)
		774	{
		775	RUINT32T tmp;
		776	tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_r-lower_lim_r));
		777	tmp += ((RUINT32T)(mask_r>>sh_r))*((RUINT32T)lower_lim_r);
		778	lookup_r[i] = (tmp/65535)<<sh_r;
		779	}
		780	for (i = 0; i <= mask_g>>sh_g; i++)
		781	{
		782	RUINT32T tmp;
		783	tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_g-lower_lim_g));
		784	tmp += ((RUINT32T)(mask_g>>sh_g))*((RUINT32T)lower_lim_g);
		785	lookup_g[i] = (tmp/65535)<<sh_g;
		786	}
		787	for (i = 0; i <= mask_b>>sh_b; i++)
		788	{
		789	RUINT32T tmp;
		790	tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_b-lower_lim_b));
		791	tmp += ((RUINT32T)(mask_b>>sh_b))*((RUINT32T)lower_lim_b);
		792	lookup_b[i] = (tmp/65535)<<sh_b;
		793	}
		794
		795	/* apply table to input image (replacing colors by newly calculated ones) */
		796	switch (srcImage->bits_per_pixel)
		797	{
		798	case 15:
		799	{
		800	unsigned short *p1, *pf, *p, *pl;
		801	p1 = (unsigned short *) srcImage->data;
		802	pf = (unsigned short *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
		803	while (p1 < pf)
		804	{
		805	p = p1;
		806	pl = p1 + srcImage->width;
		807	for (; p < pl; p++)
		808	{
		809	*p = lookup_r[(*p & 0x7c00)>>10] |
		810	lookup_g[(*p & 0x03e0)>> 5] |
		811	lookup_b[(*p & 0x001f)];
		812	}
		813	p1 = (unsigned short *) ((char *) p1 + srcImage->bytes_per_line);
		814	}
		815	break;
		816	}
		817	case 16:
		818	{
		819	unsigned short *p1, *pf, *p, *pl;
		820	p1 = (unsigned short *) srcImage->data;
		821	pf = (unsigned short *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
		822	while (p1 < pf)
		823	{
		824	p = p1;
		825	pl = p1 + srcImage->width;
		826	for (; p < pl; p++)
		827	{
		828	*p = lookup_r[(*p & 0xf800)>>11] |
		829	lookup_g[(*p & 0x07e0)>> 5] |
		830	lookup_b[(*p & 0x001f)];
		831	}
		832	p1 = (unsigned short *) ((char *) p1 + srcImage->bytes_per_line);
		833	}
		834	break;
		835	}
		836	case 24:
		837	{
		838	unsigned char *p1, *pf, *p, *pl;
		839	p1 = (unsigned char *) srcImage->data;
		840	pf = (unsigned char *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
		841	while (p1 < pf)
		842	{
		843	p = p1;
		844	pl = p1 + srcImage->width * 3;
		845	for (; p < pl; p += 3)
		846	{
		847	p[0] = lookup_r[(p[0] & 0xff0000)>>16];
		848	p[1] = lookup_r[(p[1] & 0x00ff00)>> 8];
		849	p[2] = lookup_r[(p[2] & 0x0000ff)];
		850	}
		851	p1 = (unsigned char *) ((char *) p1 + srcImage->bytes_per_line);
		852	}
		853	break;
		854	}
		855	case 32:
		856	{
		857	RUINT32T *p1, *pf, *p, *pl;
		858	p1 = (RUINT32T *) srcImage->data;
		859	pf = (RUINT32T *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
		860
		861	while (p1 < pf)
		862	{
		863	p = p1;
		864	pl = p1 + srcImage->width;
		865	for (; p < pl; p++)
		866	{
		867	*p = lookup_r[(*p & 0xff0000)>>16] |
		868	lookup_g[(*p & 0x00ff00)>> 8] |
		869	lookup_b[(*p & 0x0000ff)] |
		870	(*p & ~0xffffff);
		871	}
		872	p1 = (RUINT32T *) ((char *) p1 + srcImage->bytes_per_line);
		873	}
		874	break;
		875	}
		876	}
		877
		878	free (lookup);
		879	}
		880	#endif
		881
		882	/*
		883	* Check our parents are still who we think they are.
		884	* Do transparency updates if required
		885	*/
		886	int
		887	rxvt_term::check_our_parents ()
		888	{
		889	check_our_parents_ev.stop ();
		890	check_our_parents_ev.start (NOW + .1);
		891	return 0;
		892	}
		893
		894	void
		895	rxvt_term::check_our_parents_cb (time_watcher &w)
		896	{
		897	int i, pchanged, aformat, rootdepth;
		898	unsigned long nitems, bytes_after;
		899	Atom atype;
		900	unsigned char *prop = NULL;
		901	Window root, oldp, *list;
		902	Pixmap rootpixmap = None;
		903	XWindowAttributes wattr, wrootattr;
		904	int sx, sy;
		905	Window cr;
		906	unsigned int rootpixmap_w = 0, rootpixmap_h = 0;
		907
		908	pchanged = 0;
		909
		910	if (!option (Opt_transparent))
		911	return /*pchanged*/; /* Don't try any more */
		912
		913	#if 0
		914	struct timeval stv;
		915	gettimeofday (&stv,NULL);
		916	#define PRINT_BACKGROUND_OP_TIME do{ struct timeval tv;gettimeofday (&tv,NULL); tv.tv_sec-= stv.tv_sec;\
		917	fprintf (stderr,"%d: elapsed %ld usec\n",__LINE__,\
		918	tv.tv_sec*1000000+tv.tv_usec-stv.tv_usec );}while(0)
		919	#else
		920	#define PRINT_BACKGROUND_OP_TIME do{}while(0)
		921	#endif
		922
		923
		924	XGetWindowAttributes (dpy, display->root, &wrootattr);
		925	rootdepth = wrootattr.depth;
		926
		927	XGetWindowAttributes (dpy, parent[0], &wattr);
		928
		929	if (rootdepth != wattr.depth)
		930	{
		931	if (am_transparent)
		932	{
		933	pchanged = 1;
		934	XSetWindowBackground (dpy, vt, pix_colors_focused[Color_bg]);
		935	am_transparent = am_pixmap_trans = 0;
		936	}
		937
		938	return /*pchanged*/; /* Don't try any more */
		939	}
		940
		941	/* Get all X ops out of the queue so that our information is up-to-date. */
		942	XSync (dpy, False);
		943
		944	XTranslateCoordinates (dpy, parent[0], display->root,
		945	0, 0, &sx, &sy, &cr);
		946	/* check if we are outside of the visible part of the virtual screen : */
		947	if( sx + (int)szHint.width <= 0 || sy + (int)szHint.height <= 0
		948	|| sx >= wrootattr.width || sy >= wrootattr.height )
		949	return /* 0 */ ;
		950	/*
		951	* Make the frame window set by the window manager have
		952	* the root background. Some window managers put multiple nested frame
		953	* windows for each client, so we have to take care about that.
		954	*/
		955	i = (xa[XA_XROOTPMAP_ID]
		956	&& XGetWindowProperty (dpy, display->root, xa[XA_XROOTPMAP_ID],
		957	0L, 1L, False, XA_PIXMAP, &atype, &aformat,
		958	&nitems, &bytes_after, &prop) == Success);
		959
		960	if (!i || prop == NULL)
		961	i = (xa[XA_ESETROOT_PMAP_ID]
		962	&& XGetWindowProperty (dpy, display->root, xa[XA_ESETROOT_PMAP_ID],
		963	0L, 1L, False, XA_PIXMAP, &atype, &aformat,
		964	&nitems, &bytes_after, &prop) == Success);
		965
		966	/* TODO: the below logic needs to be cleaned up */
		967	if (!i || prop == NULL
		968	|| (!ISSET_PIXCOLOR (Color_tint) && rs[Rs_shade] == NULL
		969	#ifdef HAVE_AFTERIMAGE
		970	&& bgPixmap.original_asim == NULL && rs[Rs_blurradius] == NULL
		971	#endif
		972	)
		973	)
		974	rootpixmap = None;
		975	else
		976	{
		977	int junk;
		978	unsigned int ujunk;
		979	/* root pixmap may be bad - allow a error */
		980	allowedxerror = -1;
		981	if ((rootpixmap = *(Pixmap *)prop) != None)
		982	if (!XGetGeometry (dpy, rootpixmap, &root, &junk, &junk, &rootpixmap_w, &rootpixmap_h, &ujunk, &ujunk))
		983	rootpixmap = None;
		984	allowedxerror = 0;
		985	}
		986
		987	if (prop != NULL)
		988	XFree (prop);
		989
		990	if (rootpixmap != None)
		991	{
		992	Bool success = False;
		993	GC gc = NULL;
		994	XGCValues gcvalue;
		995	int shade = 100;
		996	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
		997	Bool whole_tint = False, no_tint = True;
		998
		999	while (sx < 0) sx += (int)wrootattr.width;
		1000	while (sy < 0) sy += (int)wrootattr.height;
		1001
		1002	if (rs[Rs_shade])
		1003	shade = atoi (rs[Rs_shade]);
		1004	if (ISSET_PIXCOLOR (Color_tint))
		1005	pix_colors_focused [Color_tint].get (c);
		1006	#define IS_COMPONENT_WHOLESOME(c) ((c) <=0x000700 || (c)>=0x00f700)
		1007	if (shade >= 100)
		1008	whole_tint = (IS_COMPONENT_WHOLESOME(c.r)
		1009	&& IS_COMPONENT_WHOLESOME(c.g)
		1010	&& IS_COMPONENT_WHOLESOME(c.b));
		1011	no_tint = (c.r >= 0x00f700 && c.g >= 0x00f700 && c.b >= 0x00f700);
		1012	#undef IS_COMPONENT_WHOLESOME
		1013	/* theer are no performance advantages to reusing same pixmap */
		1014	if (bgPixmap.pixmap != None)
		1015	XFreePixmap (dpy, bgPixmap.pixmap);
		1016	bgPixmap.pixmap = XCreatePixmap (dpy, vt, szHint.width, szHint.height, rootdepth);
		1017	bgPixmap.pmap_width = szHint.width;
		1018	bgPixmap.pmap_height = szHint.height;
		1019	bgPixmap.pmap_depth = rootdepth;
		1020
		1021	#if 0 /* TODO : identify cases where this will be detrimental to performance : */
		1022	/* we want to tile root pixmap into our own pixmap in this cases :
		1023	* 1) rootpixmap does not cover our window entirely
		1024	* 2) whole_tint - we can use server-side tinting or tinting disabled
		1025	*/
		1026	if ( whole_tint || no_tint || pmap_w < sx + szHint.width || pmap_h < sy + szHint.height)
		1027	{
		1028	}
		1029	#endif
		1030	gcvalue.tile = rootpixmap;
		1031	gcvalue.fill_style = FillTiled;
		1032	gcvalue.ts_x_origin = -sx;
		1033	gcvalue.ts_y_origin = -sy;
		1034	gc = XCreateGC (dpy, rootpixmap, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcvalue);
		1035	XFillRectangle (dpy, bgPixmap.pixmap, gc, 0, 0, szHint.width, szHint.height);
		1036
		1037	if (whole_tint && !no_tint)
		1038	{
		1039	/* In this case we can tint image server-side getting significant
		1040	* performance improvements, as we eliminate XImage transfer
		1041	*/
		1042	gcvalue.foreground = Pixel (pix_colors_focused [Color_tint]);
		1043	gcvalue.function = GXand;
		1044	gcvalue.fill_style = FillSolid;
		1045	XChangeGC (dpy, gc, GCFillStyle | GCForeground | GCFunction, &gcvalue);
		1046	XFillRectangle (dpy, bgPixmap.pixmap, gc, 0, 0, szHint.width, szHint.height);
		1047	}
		1048	success = True;
		1049	#ifdef HAVE_AFTERIMAGE
		1050	if (rs[Rs_blurradius] || bgPixmap.original_asim != NULL || (!whole_tint && (!no_tint || shade !=100)))
		1051	{
		1052	ARGB32 tint = TINT_LEAVE_SAME;
		1053	ASImage *back_im = NULL;
		1054
		1055	back_im = pixmap2ximage (asv, bgPixmap.pixmap, 0, 0, szHint.width, szHint.height, AllPlanes, 100);
		1056	if (back_im != NULL)
		1057	{
		1058	if (!whole_tint && (!no_tint || shade !=100))
		1059	{
		1060	ShadingInfo as_shade;
		1061	as_shade.shading = shade;
		1062	as_shade.tintColor.red = c.r;
		1063	as_shade.tintColor.green = c.g;
		1064	as_shade.tintColor.blue = c.b;
		1065	tint = shading2tint32 (&as_shade);
		1066	}
		1067
		1068	if (rs[Rs_blurradius] && back_im)
		1069	{
		1070	ASImage* tmp;
		1071	int junk;
		1072	unsigned int hr = 1, vr = 1;
		1073	int flags = XParseGeometry (rs[Rs_blurradius], &junk, &junk, &hr, &vr);
		1074	if (!(flags&WidthValue))
		1075	hr = 1;
		1076	if (!(flags&HeightValue))
		1077	vr = hr;
		1078	tmp = blur_asimage_gauss (asv, back_im, hr, vr, 0xFFFFFFFF,
		1079	(bgPixmap.original_asim == NULL || tint == TINT_LEAVE_SAME)?ASA_XImage:ASA_ASImage,
		1080	100, ASIMAGE_QUALITY_DEFAULT);
		1081	if (tmp)
		1082	{
		1083	destroy_asimage (&back_im);
		1084	back_im = tmp;
		1085	}
		1086	}
		1087
		1088	if (bgPixmap.original_asim != NULL)
		1089	{
		1090	ASImageLayer *layers = create_image_layers (2);
		1091	ASImage *merged_im = NULL;
		1092	int fore_w, fore_h;
		1093
		1094	layers[0].im = back_im;
		1095	layers[0].clip_width = szHint.width;
		1096	layers[0].clip_height = szHint.height;
		1097	layers[0].tint = tint;
		1098	layers[1].im = bgPixmap.original_asim;
		1099
		1100	fore_w = (bgPixmap.h_scale == 0) ? bgPixmap.original_asim->width : bgPixmap.h_scale*szHint.width/100;
		1101	fore_h = (bgPixmap.v_scale == 0) ? bgPixmap.original_asim->height : bgPixmap.v_scale*szHint.height/100;
		1102
		1103	if (fore_w != bgPixmap.original_asim->width
		1104	|| fore_h != bgPixmap.original_asim->height)
		1105	{
		1106	layers[1].im = scale_asimage (asv,
		1107	bgPixmap.original_asim,
		1108	fore_w, fore_h,
		1109	ASA_ASImage, 100,
		1110	ASIMAGE_QUALITY_DEFAULT);
		1111	}
		1112	layers[1].clip_width = szHint.width;
		1113	layers[1].clip_height = szHint.height;
		1114
		1115	if (rs[Rs_blendtype])
		1116	{
		1117	layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
		1118	if (layers[1].merge_scanlines == NULL)
		1119	layers[1].merge_scanlines = alphablend_scanlines;
		1120	}
		1121	PRINT_BACKGROUND_OP_TIME;
		1122	merged_im = merge_layers (asv, layers, 2, szHint.width, szHint.height,
		1123	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
		1124	if (layers[1].im != bgPixmap.original_asim)
		1125	destroy_asimage (&(layers[1].im));
		1126	free (layers);
		1127
		1128	if (merged_im != NULL)
		1129	{
		1130	destroy_asimage (&back_im);
		1131	back_im = merged_im;
		1132	}
		1133	PRINT_BACKGROUND_OP_TIME;
		1134	}
		1135	else if (tint != TINT_LEAVE_SAME)
		1136	{
		1137	ASImage* tmp = tile_asimage (asv, back_im, 0, 0, szHint.width, szHint.height, tint, ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
		1138	if (tmp)
		1139	{
		1140	destroy_asimage (&back_im);
		1141	back_im = tmp;
		1142	}
		1143	PRINT_BACKGROUND_OP_TIME;
		1144	}
		1145	asimage2drawable (asv, bgPixmap.pixmap, back_im, gc, 0, 0, 0, 0, szHint.width, szHint.height, True);
		1146	destroy_asimage (&back_im);
		1147	} /* back_im != NULL */
		1148	else
		1149	success = False;
		1150	}
		1151	#else /* HAVE_AFTERIMAGE */
		1152	if (!whole_tint && (!no_tint || shade !=100))
		1153	{
		1154	XImage *image = XGetImage (dpy, bgPixmap.pixmap, 0, 0, szHint.width, szHint.height, AllPlanes, ZPixmap);
		1155	success = False;
		1156	if (image != NULL)
		1157	{
		1158	PRINT_BACKGROUND_OP_TIME;
		1159	if (gc == NULL)
		1160	gc = XCreateGC (dpy, vt, 0UL, &gcvalue);
		1161	if (ISSET_PIXCOLOR (Color_tint) || shade != 100)
		1162	ShadeXImage (this, image, shade, c.r, c.g, c.b);
		1163	XPutImage (dpy, bgPixmap.pixmap, gc, image, 0, 0, 0, 0, image->width, image->height);
		1164	XDestroyImage (image);
		1165	success = True;
		1166	}
		1167	}
		1168	#endif /* HAVE_AFTERIMAGE */
		1169	PRINT_BACKGROUND_OP_TIME;
		1170
		1171	if (gc != NULL)
		1172	XFreeGC (dpy, gc);
		1173
		1174	if (!success)
		1175	{
		1176	if (am_transparent && am_pixmap_trans)
		1177	{
		1178	pchanged = 1;
		1179	if (bgPixmap.pixmap != None)
		1180	{
		1181	XFreePixmap (dpy, bgPixmap.pixmap);
		1182	bgPixmap.pixmap = None;
		1183	}
		1184	}
		1185
		1186	am_pixmap_trans = 0;
		1187	}
		1188	else
		1189	{
		1190	XSetWindowBackgroundPixmap (dpy, parent[0], bgPixmap.pixmap);
		1191	XClearWindow (dpy, parent[0]);
		1192
		1193	if (!am_transparent || !am_pixmap_trans)
		1194	pchanged = 1;
		1195
		1196	am_transparent = am_pixmap_trans = 1;
		1197	}
		1198	} /* rootpixmap != None */
		1199
		1200	if (am_pixmap_trans)
		1201	XSetWindowBackgroundPixmap (dpy, vt, ParentRelative);
		1202	else
		1203	{
		1204	unsigned int n;
		1205	/*
		1206	* InheritPixmap transparency
		1207	*/
		1208	for (i = 1; i < (int) (sizeof (parent) / sizeof (Window)); i++)
		1209	{
		1210	oldp = parent[i];
		1211	XQueryTree (dpy, parent[i - 1], &root, &parent[i], &list, &n);
		1212	XFree (list);
		1213
		1214	if (parent[i] == display->root)
		1215	{
		1216	if (oldp != None)
		1217	pchanged = 1;
		1218
		1219	break;
		1220	}
		1221
		1222	if (oldp != parent[i])
		1223	pchanged = 1;
		1224	}
		1225
		1226	n = 0;
		1227
		1228	if (pchanged)
		1229	for (; n < (unsigned int)i; n++)
		1230	{
		1231	XGetWindowAttributes (dpy, parent[n], &wattr);
		1232
		1233	if (wattr.depth != rootdepth || wattr.c_class == InputOnly)
		1234	{
		1235	n = (int) (sizeof (parent) / sizeof (Window)) + 1;
		1236	break;
		1237	}
		1238	}
		1239
		1240	if (n > (sizeof (parent) / sizeof (parent[0])))
		1241	{
		1242	XSetWindowBackground (dpy, parent[0], pix_colors_focused[Color_border]);
		1243	XSetWindowBackground (dpy, vt, pix_colors_focused[Color_bg]);
		1244	am_transparent = 0;
		1245	/* XXX: also turn off Opt_transparent? */
		1246	}
		1247	else
		1248	{
		1249	for (n = 0; n < (unsigned int)i; n++)
		1250	{
		1251	XSetWindowBackgroundPixmap (dpy, parent[n], ParentRelative);
		1252	XClearWindow (dpy, parent[n]);
		1253	}
		1254
		1255	XSetWindowBackgroundPixmap (dpy, vt, ParentRelative);
		1256	am_transparent = 1;
		1257	}
		1258
		1259	for (; i < (int) (sizeof (parent) / sizeof (Window)); i++)
		1260	parent[i] = None;
		1261	}
		1262
		1263	if (scrollBar.win)
		1264	{
		1265	XSetWindowBackgroundPixmap (dpy, scrollBar.win, ParentRelative);
		1266	scrollBar.setIdle ();
		1267	scrollbar_show (0);
		1268	}
		1269
		1270	if (am_transparent)
		1271	{
		1272	want_refresh = want_full_refresh = 1;
		1273	if (am_pixmap_trans)
		1274	flush ();
		1275	}
		1276
		1277	// return pchanged;
		1278	}
		1279	#endif

Diff Legend

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