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

Comparing rxvt-unicode/src/xpm.C (file contents):
Revision 1.55 by sasha, Fri Aug 3 05:33:04 2007 UTC vs.
Revision 1.63 by sasha, Wed Aug 8 22:39:49 2007 UTC

…		…
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		28
29	#ifdef XPM_BACKGROUND
30
31	/*	29	/*
32	* These GEOM strings indicate absolute size/position:	30	* Pixmap geometry string interpretation :
33	* @ `WxH+X+Y'	31	* Each geometry string contains zero or one scale/position
34	* @ `WxH+X' -> Y = X	32	* adjustment and may optionally be followed by a colon and one or more
35	* @ `WxH' -> Y = X = 50	33	* colon-delimited pixmap operations.
36	* @ `W+X+Y' -> H = W	34	* The following table shows the valid geometry strings and their
37	* @ `W+X' -> H = W, Y = X	35	* affects on the background image :
38	* @ `W' -> H = W, X = Y = 50
39	* @ `0xH' -> H *= H/100, X = Y = 50 (W unchanged)
40	* @ `Wx0' -> W *= W/100, X = Y = 50 (H unchanged)
41	* @ `=+X+Y' -> (H, W unchanged)
42	* @ `=+X' -> Y = X (H, W unchanged)
43	*	36	*
44	* These GEOM strings adjust position relative to current position:	37	* WxH+X+Y Set scaling to W% by H%, and position to X% by Y%.
45	* @ `+X+Y'	38	* W and H are percentages of the terminal window size.
46	* @ `+X' -> Y = X	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
47	*	46	*
48	* And this GEOM string is for querying current scale/position:	47	* Adjusting position only :
49	* @ `?'	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
50	*/	71	*/
51	int	72
52	rxvt_term::scale_pixmap (const char *geom)	73	#ifdef HAVE_BG_PIXMAP
		74	bool
		75	bgPixmap_t::window_size_sensitive ()
53	{	76	{
		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	}
		92
		93	# ifdef XPM_BACKGROUND
		94	static inline bool
		95	check_set_scale_value (int geom_flags, int flag, unsigned int &scale, unsigned int new_value)
		96	{
		97	if (geom_flags & flag)
		98	{
		99	if (new_value > 1000)
		100	new_value = 1000;
		101	if (new_value != scale)
		102	{
		103	scale = new_value;
		104	return true;
		105	}
		106	}
		107	return false;
		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 * (100 - 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 int
		146	make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)
		147	{
		148	int src_pos = 0;
		149	dst_pos = 0;
		150	dst_size = size;
		151	if (pos < 0 && size > target_size)
		152	{
		153	src_pos = -pos;
		154	dst_size += pos;
		155	}
		156	else if (pos > 0)
		157	dst_pos = pos;
		158
		159	if (dst_pos + dst_size > target_size)
		160	dst_size = target_size - dst_pos;
		161	return src_pos;
		162	}
		163
		164	bool
		165	bgPixmap_t::handle_geometry (const char *geom)
		166	{
54	int flags, changed = 0;	167	int geom_flags = 0, changed = 0;
55	int x = 0, y = 0;	168	int x = 0, y = 0;
56	unsigned int w = 0, h = 0;	169	unsigned int w = 0, h = 0;
57	unsigned int n;	170	unsigned int n;
		171	unsigned long new_flags = (flags&(~bgPmap_geometryFlags));
58	char *p;	172	char *p;
59	bgPixmap_t *bgpixmap = &bgPixmap;	173	# define MAXLEN_GEOM 256 /* could be longer then regular geometry string */
60
61	#define MAXLEN_GEOM sizeof("[10000x10000+10000+10000]")
62		174
63	if (geom == NULL)	175	if (geom == NULL)
64	return 0;	176	return false;
65		177
66	char str[MAXLEN_GEOM];	178	char str[MAXLEN_GEOM];
67		179
68	if (!strcmp (geom, "?"))	180	if (!strcmp (geom, "?"))
69	{	181	{
		182	if (target)
		183	{
70	sprintf (str, "[%dx%d+%d+%d]", /* can't presume snprintf () ! */	184	sprintf (str, "[%dx%d+%d+%d]", /* can't presume snprintf () ! */
71	min (bgpixmap->w, 32767), min (bgpixmap->h, 32767),	185	min (h_scale, 32767), min (v_scale, 32767),
72	min (bgpixmap->x, 32767), min (bgpixmap->y, 32767));	186	min (h_align, 32767), min (v_align, 32767));
73	process_xterm_seq (XTerm_title, str, CHAR_ST);	187	target->process_xterm_seq (XTerm_title, str, CHAR_ST);
		188	}
74	return 0;	189	return false;
75	}	190	}
76		191	while (isspace(*geom)) ++geom;
77	if ((p = strchr (geom, ';')) == NULL)	192	if ((p = strchr (geom, ';')) == NULL)
78	p = strchr (geom, '\0');	193	p = strchr (geom, '\0');
79		194
80	n = (p - geom);	195	n = (p - geom);
81	if (n < MAXLEN_GEOM)	196	if (n < MAXLEN_GEOM)
82	{	197	{
		198	char *ops;
		199	new_flags \|= bgPmap_geometrySet;
		200
83	strncpy (str, geom, n);	201	strncpy (str, geom, n);
84	str[n] = '\0';	202	str[n] = '\0';
85		203	if (str[0] == ':')
86	if (strcmp(str, "auto") == 0)	204	ops = &str[0];
87	{	205	else if (str[0] != 'x' && str[0] != 'X' && isalpha(str[0]))
88	if (!bgpixmap->auto_resize)	206	ops = &str[0];
89	changed++;
90	bgpixmap->auto_resize = True ;
91	w = szHint.width ;
92	h = szHint.height ;
93	flags = WidthValue\|HeightValue ;
94	}
95	else	207	else
96	{	208	{
97	bgpixmap->auto_resize = False ;	209	char *tmp;
		210	ops = strchr (str, ':');
		211	if (ops != NULL)
		212	{
		213	for (tmp = ops-1; tmp >= str && isspace(*tmp); --tmp);
		214	*(++tmp) = '\0';
		215	if (ops == tmp) ++ops;
		216	}
		217	}
		218
		219	if (ops > str \|\| ops == NULL)
		220	{
		221	/* we have geometry string - let's handle it prior to applying ops */
98	flags = XParseGeometry (str, &x, &y, &w, &h);	222	geom_flags = XParseGeometry (str, &x, &y, &w, &h);
		223
		224	if ((geom_flags & XValue) && !(geom_flags & YValue))
		225	{
		226	y = x;
		227	geom_flags \|= YValue;
		228	}
		229
		230	if (flags & bgPmap_geometrySet)
		231	{/* new geometry is an adjustment to the old one ! */
		232	if ((geom_flags & WidthValue) && (geom_flags & HeightValue))
		233	{
		234	if (w == 0 && h != 0)
		235	{
		236	w = h_scale;
		237	h = (v_scale * h) / 100;
		238	}
		239	else if (h == 0 && w != 0)
		240	{
		241	w = (h_scale * w) / 100;
		242	h = v_scale;
		243	}
		244	}
		245	if (geom_flags & XValue)
		246	{
		247	if (str[0] != '=')
		248	{
		249	y += v_align;
		250	x += h_align;
		251	}
		252	}
		253	}
		254	else /* setting up geometry from scratch */
		255	{
		256	if (!(geom_flags & XValue))
		257	{/* use default geometry - centered */
		258	x = y = bgPmap_defaultAlign;
		259	}
		260	else if (!(geom_flags & YValue))
		261	y = x;
		262
		263	if ((geom_flags & (WidthValue\|HeightValue)) == 0)
		264	{/* use default geometry - scaled */
		265	w = h = bgPmap_defaultScale;
		266	}
		267	else if (geom_flags & WidthValue)
		268	{
		269	if (!(geom_flags & HeightValue))
		270	h = w;
		271	}
		272	else
		273	w = h;
		274	}
		275	} /* done parsing geometry string */
		276	else if (!(flags & bgPmap_geometrySet))
		277	{ /* default geometry - scaled and centered */
		278	x = y = bgPmap_defaultAlign;
		279	w = h = bgPmap_defaultScale;
		280	}
99	}	281
100	/* code below is garbage and needs to be rewritten */	282	if (!(flags & bgPmap_geometrySet))
		283	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;
		284
101	if (!flags)	285	if (ops)
102	{
103	flags \|= WidthValue;
104	w = 0;
105	} /* default is tile */
106
107	if (flags & WidthValue)
108	{
109	if (!(flags & XValue))
110	x = 50;
111
112	if (!(flags & HeightValue))
113	h = w;
114
115	if (w && !h)
116	{	286	{
117	w = (bgpixmap->w * w) / 100;	287	while (*ops)
118	h = bgpixmap->h;
119	}	288	{
120	else if (h && !w)	289	while (ops == ':' \|\| isspace(ops)) ++ops;
		290	# define CHECK_GEOM_OPS(op_str) (strncasecmp (ops, (op_str), sizeof(op_str)-1) == 0)
		291	if (CHECK_GEOM_OPS("tile"))
121	{	292	{
122	w = bgpixmap->w;	293	w = h = 0;
123	h = (bgpixmap->h * h) / 100;	294	geom_flags \|= WidthValue\|HeightValue;
		295	}
		296	else if (CHECK_GEOM_OPS("propscale"))
		297	{
		298	if (w == 0 && h == 0)
		299	{
		300	w = 100;
		301	geom_flags \|= WidthValue;
		302	}
		303	new_flags \|= bgPmap_propScale;
		304	}
		305	else if (CHECK_GEOM_OPS("hscale"))
		306	{
		307	if (w == 0)
		308	w = 100;
		309	h = 0;
		310	geom_flags \|= WidthValue\|HeightValue;
		311	}
		312	else if (CHECK_GEOM_OPS("vscale"))
		313	{
		314	if (h == 0)
		315	h = 100;
		316	w = 0;
		317	geom_flags \|= WidthValue\|HeightValue;
		318	}
		319	else if (CHECK_GEOM_OPS("scale"))
		320	{
		321	if (h == 0)
		322	h = 100;
		323	if (w == 0)
		324	w = 100;
		325	geom_flags \|= WidthValue\|HeightValue;
		326	}
		327	else if (CHECK_GEOM_OPS("auto"))
		328	{
		329	w = h = 100;
		330	x = y = 50;
		331	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;
		332	}
		333	# undef CHECK_GEOM_OPS
		334	while (ops != ':' && ops != '\0') ++ops;
		335	} /* done parsing ops */
		336	}
		337
		338	if (check_set_scale_value (geom_flags, WidthValue, h_scale, w))
		339	++changed;
		340	if (check_set_scale_value (geom_flags, HeightValue, v_scale, h))
		341	++changed;
		342	if (check_set_align_value (geom_flags, XValue, h_align, x))
		343	++changed;
		344	if (check_set_align_value (geom_flags, YValue, v_align, y))
		345	++changed;
		346	}
		347
		348	if (new_flags != flags)
		349	{
		350	flags = new_flags;
		351	changed++;
		352	}
		353	//fprintf( stderr, "flags = %lX, scale = %ux%u, align=%+d%+d\n",
		354	// flags, h_scale, v_scale, h_align, v_align);
		355	return (changed > 0);
		356	}
		357
		358	# ifdef HAVE_AFTERIMAGE
		359	bool
		360	bgPixmap_t::render_asim (ASImage *background, ARGB32 background_tint)
		361	{
		362	if (target == NULL)
		363	return false;
		364
		365	int target_width = (int)target->szHint.width;
		366	int target_height = (int)target->szHint.height;
		367	int new_pmap_width = target_width, new_pmap_height = target_height;
		368	ASImage *result = NULL;
		369
		370	int x = 0;
		371	int y = 0;
		372	int w = h_scale * target_width / 100;
		373	int h = v_scale * target_height / 100;
		374
		375	if (original_asim)
		376	{
		377	x = make_align_position (h_align, target_width, w > 0 ? w : (int)original_asim->width);
		378	y = make_align_position (v_align, target_height, h > 0 ? h : (int)original_asim->height);
		379	}
		380
		381	if (original_asim == NULL
		382	\|\| x >= target_width
		383	\|\| y >= target_height
		384	\|\| (w > 0 && x + w <= 0)
		385	\|\| (h > 0 && y + h <= 0))
		386	{
		387	if (background)
		388	{
		389	new_pmap_width = background->width;
		390	new_pmap_height = background->height;
		391	result = background;
		392	if (background_tint != TINT_LEAVE_SAME)
124	}	393	{
125		394	ASImage* tmp = tile_asimage (target->asv, background, 0, 0,
126	min_it (w, 32767);	395	target_width, target_height, background_tint,
127	min_it (h, 32767);	396	ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
128		397	if (tmp)
129	if (bgpixmap->w != (short)w)	398	result = tmp;
130	{	399	}
131	bgpixmap->w = (short)w;	400	}
132	changed++;	401	else
		402	new_pmap_width = new_pmap_height = 0;
		403	}
		404	else
		405	{
		406	result = original_asim;
		407	if ((w > 0 && w != original_asim->width)
		408	\|\| (h > 0 && h != original_asim->height))
		409	{
		410	result = scale_asimage (target->asv, original_asim,
		411	w > 0 ? w : original_asim->width,
		412	h > 0 ? h : original_asim->height,
		413	background ? ASA_ASImage : ASA_XImage,
		414	100, ASIMAGE_QUALITY_DEFAULT);
		415	}
		416	if (background == NULL)
		417	{/* if tiling - pixmap has to be sized exactly as the image */
		418	if (h_scale == 0)
		419	new_pmap_width = result->width;
		420	if (v_scale == 0)
		421	new_pmap_height = result->height;
		422	/* we also need to tile our image in one or both directions */
		423	if (h_scale == 0 \|\| v_scale == 0)
133	}	424	{
134		425	ASImage *tmp = tile_asimage (target->asv, result,
135	if (bgpixmap->h != (short)h)	426	(h_scale > 0) ? 0 : (int)result->width - x,
		427	(v_scale > 0) ? 0 : (int)result->height - y,
		428	result->width, result->height,
		429	TINT_LEAVE_SAME, ASA_XImage,
		430	100, ASIMAGE_QUALITY_DEFAULT);
		431	if (tmp)
		432	{
		433	if (result != original_asim)
		434	destroy_asimage (&result);
		435	result = tmp;
		436	}
136	{	437	}
137	bgpixmap->h = (short)h;	438	}
138	changed++;	439	else
		440	{/* if blending background and image - pixmap has to be sized same as target window */
		441	ASImageLayer *layers = create_image_layers (2);
		442	ASImage *merged_im = NULL;
		443
		444	layers[0].im = background;
		445	layers[0].clip_width = target_width;
		446	layers[0].clip_height = target_height;
		447	layers[0].tint = background_tint;
		448	layers[1].im = result;
		449	if (w <= 0)
		450	{/* tile horizontally */
		451	while (x > 0) x -= (int)result->width;
		452	layers[1].dst_x = x;
		453	layers[1].clip_width = result->width+target_width;
		454	}
		455	else
		456	{/* clip horizontally */
		457	layers[1].dst_x = x;
		458	layers[1].clip_width = result->width;
		459	}
		460	if (h <= 0)
139	}	461	{
		462	while (y > 0) y -= (int)result->height;
		463	layers[1].dst_y = y;
		464	layers[1].clip_height = result->height + target_height;
140	}	465	}
141		466	else
142	if (!(flags & YValue))	467	{
		468	layers[1].dst_y = y;
		469	layers[1].clip_height = result->height;
		470	}
		471	if (target->rs[Rs_blendtype])
		472	{
		473	layers[1].merge_scanlines = blend_scanlines_name2func (target->rs[Rs_blendtype]);
		474	if (layers[1].merge_scanlines == NULL)
		475	layers[1].merge_scanlines = alphablend_scanlines;
		476	}
		477	ASImage *tmp = merge_layers (target->asv, layers, 2, target_width, target_height,
		478	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
		479	if (tmp)
		480	{
		481	if (result != original_asim)
		482	destroy_asimage (&result);
		483	result = tmp;
		484	}
		485	free (layers);
143	{	486	}
144	if (flags & XNegative)	487	}
145	flags \|= YNegative;
146		488
147	y = x;	489	if (pixmap)
		490	{
		491	if (result == NULL
		492	\|\| pmap_width != new_pmap_width
		493	\|\| pmap_height != new_pmap_height
		494	\|\| pmap_depth != target->depth)
148	}	495	{
149		496	XFreePixmap (target->dpy, pixmap);
150	if (!(flags & WidthValue) && geom[0] != '=')	497	pixmap = None;
151	{	498	}
152	x += bgpixmap->x;	499	}
153	y += bgpixmap->y;	500
		501	if (result)
		502	{
		503	XGCValues gcv;
		504	GC gc;
		505
		506	/* create Pixmap */
		507	if (pixmap == None)
154	}	508	{
155		509	pixmap = XCreatePixmap (target->dpy, target->vt, new_pmap_width, new_pmap_height, target->depth);
156	if (bgpixmap->x != x)	510	pmap_width = new_pmap_width;
		511	pmap_height = new_pmap_height;
		512	pmap_depth = target->depth;
157	{	513	}
158	bgpixmap->x = x;	514	/* fill with background color ( if result's not completely overlapping it)*/
159	changed++;	515	gcv.foreground = target->pix_colors[Color_bg];
		516	gc = XCreateGC (target->dpy, target->vt, GCForeground, &gcv);
		517
		518	int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
		519	int dst_width = result->width, dst_height = result->height;
		520	if (background == NULL)
160	}	521	{
		522	if (h_scale > 0)
		523	src_x = make_clip_rectangle (x, result->width, new_pmap_width, dst_x, dst_width);
		524	if (v_scale > 0)
		525	src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
161		526
162	if (bgpixmap->y != y)	527	if (dst_x > 0 \|\| dst_y > 0
		528	\|\| dst_x + dst_width < new_pmap_width
		529	\|\| dst_y + dst_height < new_pmap_height)
		530	{
		531	XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
		532	}
163	{	533	}
164	bgpixmap->y = y;	534
165	changed++;	535	/* put result on pixmap */
166	}	536	if (dst_x < new_pmap_width && dst_y < new_pmap_height)
		537	asimage2drawable (target->asv, pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);
167	}	538
		539	if (result != background && result != original_asim)
		540	destroy_asimage (&result);
168		541
169	return changed;	542	XFreeGC (target->dpy, gc);
		543	if (background)
		544	flags \|= bgPmap_Transparent;
		545	else
		546	flags &= ~bgPmap_Transparent;
		547	}
		548
		549	return true;
170	}	550	}
		551	# endif /* HAVE_AFTERIMAGE */
171		552
172	void	553	void
173	rxvt_term::resize_pixmap ()	554	rxvt_term::resize_pixmap ()
174	{	555	{
175	XGCValues gcvalue;
176	GC gc;
177	unsigned int w = bgPixmap.w, h = bgPixmap.h;
178	unsigned int x = bgPixmap.x, y = bgPixmap.y;
179	ASImage *im = bgPixmap.original_asim;
180		556
181	/* preliminary cleanup - this needs to be integrated with check_our_parents() code */
182	if (bgPixmap.pixmap != None)
183	{
184	XFreePixmap (dpy, bgPixmap.pixmap);
185	bgPixmap.pixmap = None ;
186	}
187	#ifdef ENABLE_TRANSPARENCY	557	# ifdef ENABLE_TRANSPARENCY
188	if (option(Opt_transparent) && am_transparent)	558	if (option(Opt_transparent) && am_transparent)
189	{	559	{
190	/* we need to re-generate transparency pixmap in that case ! */	560	/* we need to re-generate transparency pixmap in that case ! */
191	check_our_parents ();	561	check_our_parents ();
192	return;	562	return;
193	}	563	}
194	#endif	564	# endif
195		565	# ifdef HAVE_AFTERIMAGE
196	if (bgPixmap.original_asim == NULL)	566	bgPixmap.render_asim(NULL, TINT_LEAVE_SAME);
197	{ /* So be it: I'm not using pixmaps */	567	bgPixmap.apply_background();
198	XSetWindowBackground (dpy, vt, pix_colors[Color_bg]);	568	# endif
199	return;
200	}
201
202	gcvalue.foreground = pix_colors[Color_bg];
203	gc = XCreateGC (dpy, vt, GCForeground, &gcvalue);
204
205	if (bgPixmap.auto_resize)
206	{
207	w = szHint.width;
208	h = szHint.height;
209	}
210	else
211	{ /* don't zoom pixmap too much nor expand really small pixmaps */
212	if (w > 16000)
213	w = 1;
214	if (h > 16000)
215	h = 1;
216	}
217	if (w == 0) w = im->width;
218	else if (w < 10) w *= im->width;
219	if (h == 0) h = im->height;
220	else if (w < 10) h *= im->height;
221
222	if (w != im->width \|\| h != im->height)
223	{
224	ASImage *tmp = scale_asimage (asv, im, w, h, (x == 0 && y == 0)?ASA_XImage:ASA_ASImage, 0, ASIMAGE_QUALITY_DEFAULT);
225	if (tmp != NULL)
226	im = tmp;
227	}
228	if (x != 0 \|\| y != 0)
229	{
230	ASImage *tmp = tile_asimage (asv, im, x, y, w, h, TINT_LEAVE_SAME, ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
231	if (tmp != NULL)
232	{
233	if (im != bgPixmap.original_asim)
234	destroy_asimage (&im);
235	im = tmp;
236	}
237	}
238	bgPixmap.pixmap = XCreatePixmap (dpy, vt, w, h, depth);
239	bgPixmap.pmap_width = w;
240	bgPixmap.pmap_height = h;
241	bgPixmap.pmap_depth = depth;
242
243	asimage2drawable (asv, bgPixmap.pixmap, im, gc, 0, 0, 0, 0, w, h, True);
244
245	if (im != bgPixmap.original_asim)
246	destroy_asimage (&im);
247
248	XSetWindowBackgroundPixmap (dpy, vt, bgPixmap.pixmap);
249
250	XFreeGC (dpy, gc);
251	}	569	}
252		570
253	void	571	void
254	rxvt_term::set_bgPixmap (const char *file)	572	rxvt_term::set_bgPixmap (const char *file)
255	{	573	{
…		…
262	XFreePixmap (dpy, bgPixmap.pixmap);	580	XFreePixmap (dpy, bgPixmap.pixmap);
263	bgPixmap.pixmap = None;	581	bgPixmap.pixmap = None;
264	}	582	}
265		583
266	XSetWindowBackground (dpy, vt, pix_colors[Color_bg]);	584	XSetWindowBackground (dpy, vt, pix_colors[Color_bg]);
267
268	if (*file != '\0')	585	if (*file != '\0')
269	{	586	{
		587	# ifdef HAVE_AFTERIMAGE
270	if (asimman == NULL)	588	if (asimman == NULL)
271	asimman = create_generic_imageman(rs[Rs_path]);	589	asimman = create_generic_imageman(rs[Rs_path]);
272	if ((f = strchr (file, ';')) == NULL)	590	if ((f = strchr (file, ';')) == NULL)
273	bgPixmap.original_asim = get_asimage( asimman, file, 0xFFFFFFFF, 100 );	591	bgPixmap.original_asim = get_asimage( asimman, file, 0xFFFFFFFF, 100 );
274	else	592	else
…		…
278	strncpy (f, file, len);	596	strncpy (f, file, len);
279	f[len] = '\0';	597	f[len] = '\0';
280	bgPixmap.original_asim = get_asimage( asimman, f, 0xFFFFFFFF, 100 );	598	bgPixmap.original_asim = get_asimage( asimman, f, 0xFFFFFFFF, 100 );
281	free( f );	599	free( f );
282	}	600	}
		601	# endif
283	}	602	}
284		603	resize_pixmap (); /* TODO: temporary fix - should be done by the caller! */
285	resize_pixmap ();
286	}	604	}
287		605
288	#endif /* XPM_BACKGROUND */	606	# endif /* XPM_BACKGROUND */
		607
		608	# ifdef ENABLE_TRANSPARENCY
		609	/* make_transparency_pixmap()
		610	* Builds a pixmap sized the same as terminal window, with depth same as the root window
		611	* that pixmap contains tiled portion of the root pixmap that is supposed to be covered by
		612	* our window.
		613	*/
		614	#if 0
		615	bool
		616	bgPixmap_t::make_transparency_pixmap()
		617	{
		618	if (target == NULL)
		619	return false;
		620
		621	int sx, sy;
		622	Window cr;
		623	XTranslateCoordinates (target->dpy, target->parent[0], target->display->root,
		624	0, 0, &sx, &sy, &cr);
		625
		626	/* check if we are outside of the visible part of the virtual screen : */
		627	if( sx + (int)szHint.width <= 0 \|\| sy + (int)szHint.height <= 0
		628	\|\| sx >= wrootattr.width \|\| sy >= wrootattr.height )
		629	return false ;
		630
		631	XWindowAttributes wattr, wrootattr;
		632
		633	XGetWindowAttributes (dpy, display->root, &wrootattr);
		634
		635	/*
		636	* Make the frame window set by the window manager have
		637	* the root background. Some window managers put multiple nested frame
		638	* windows for each client, so we have to take care about that.
		639	*/
		640	i = (xa[XA_XROOTPMAP_ID]
		641	&& XGetWindowProperty (dpy, display->root, xa[XA_XROOTPMAP_ID],
		642	0L, 1L, False, XA_PIXMAP, &atype, &aformat,
		643	&nitems, &bytes_after, &prop) == Success);
		644
		645	if (!i \|\| prop == NULL)
		646	i = (xa[XA_ESETROOT_PMAP_ID]
		647	&& XGetWindowProperty (dpy, display->root, xa[XA_ESETROOT_PMAP_ID],
		648	0L, 1L, False, XA_PIXMAP, &atype, &aformat,
		649	&nitems, &bytes_after, &prop) == Success);
		650
		651	if (!i \|\| prop == NULL)
		652	rootpixmap = None;
		653
		654	}
		655	#endif /* 0 */
		656	# endif /* ENABLE_TRANSPARENCY */
		657
		658	void
		659	bgPixmap_t::apply_background()
		660	{
		661	if (target)
		662	{
		663	if (pixmap != None)
		664	{ /* set target's background to pixmap */
		665	# ifdef ENABLE_TRANSPARENCY
		666	if (flags & bgPmap_Transparent)
		667	{
		668	XSetWindowBackgroundPixmap (target->dpy, target->parent[0], pixmap);
		669	XSetWindowBackgroundPixmap (target->dpy, target->vt, ParentRelative);
		670	if (target->scrollBar.win)
		671	XSetWindowBackgroundPixmap (target->dpy, target->scrollBar.win, ParentRelative);
		672	}
		673	else
		674	# endif
		675	{
		676	/* force old pixmap dereference in case it was transparent before :*/
		677	XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_bg]);
		678	XSetWindowBackgroundPixmap (target->dpy, target->vt, pixmap);
		679	/* do we also need to set scrollbar's background here ? */
		680	}
		681	}
		682	else
		683	{ /* set target background to a pixel */
		684	XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_bg]);
		685	XSetWindowBackground (target->dpy, target->vt, target->pix_colors[Color_bg]);
		686	/* do we also need to set scrollbar's background here ? */
		687	}
		688	/* don't want Expose on the parent */
		689	XClearArea (target->dpy, target->parent[0], 0, 0, 0, 0, False);
		690	/* do want Expose on the vt */
		691	XClearArea (target->dpy, target->parent[0], 0, 0, 0, 0, True);
		692	}
		693	}
		694	#endif /* HAVE_BG_PIXMAP */
		695
		696
289		697
290	#ifdef ENABLE_TRANSPARENCY	698	#ifdef ENABLE_TRANSPARENCY
291	#if TINTING && !defined(HAVE_AFTERIMAGE)	699	#ifndef HAVE_AFTERIMAGE
292	/* taken from aterm-0.4.2 */	700	/* taken from aterm-0.4.2 */
293		701
294	typedef uint32_t RUINT32T;	702	typedef uint32_t RUINT32T;
295		703
296	static void	704	static void
…		…
533	}	941	}
534		942
535	void	943	void
536	rxvt_term::check_our_parents_cb (time_watcher &w)	944	rxvt_term::check_our_parents_cb (time_watcher &w)
537	{	945	{
538	int i, pchanged, aformat, rootdepth;	946	int i, aformat, rootdepth;
539	unsigned long nitems, bytes_after;	947	unsigned long nitems, bytes_after;
540	Atom atype;	948	Atom atype;
541	unsigned char *prop = NULL;	949	unsigned char *prop = NULL;
542	Window root, oldp, *list;	950	Window root, oldp, *list;
543	Pixmap rootpixmap = None;	951	Pixmap rootpixmap = None;
544	XWindowAttributes wattr, wrootattr;	952	XWindowAttributes wattr, wrootattr;
545	int sx, sy;	953	int sx, sy;
546	Window cr;	954	Window cr;
547	unsigned int rootpixmap_w = 0, rootpixmap_h = 0;	955	unsigned int rootpixmap_w = 0, rootpixmap_h = 0;
548		956
549	pchanged = 0;
550
551	if (!option (Opt_transparent))	957	if (!option (Opt_transparent))
552	return /pchanged/; /* Don't try any more */	958	return; /* Don't try any more */
553		959
554	#if 0	960	#if 0
555	struct timeval stv;	961	struct timeval stv;
556	gettimeofday (&stv,NULL);	962	gettimeofday (&stv,NULL);
557	#define PRINT_BACKGROUND_OP_TIME do{ struct timeval tv;gettimeofday (&tv,NULL); tv.tv_sec-= stv.tv_sec;\	963	#define PRINT_BACKGROUND_OP_TIME do{ struct timeval tv;gettimeofday (&tv,NULL); tv.tv_sec-= stv.tv_sec;\
…		…
569		975
570	if (rootdepth != wattr.depth)	976	if (rootdepth != wattr.depth)
571	{	977	{
572	if (am_transparent)	978	if (am_transparent)
573	{	979	{
574	pchanged = 1;
575	XSetWindowBackground (dpy, vt, pix_colors_focused[Color_bg]);	980	XSetWindowBackground (dpy, vt, pix_colors_focused[Color_bg]);
576	am_transparent = am_pixmap_trans = 0;	981	am_transparent = am_pixmap_trans = 0;
577	}	982	}
578		983
579	return /pchanged/; /* Don't try any more */	984	return; /* Don't try any more */
580	}	985	}
581		986
582	/* Get all X ops out of the queue so that our information is up-to-date. */	987	/* Get all X ops out of the queue so that our information is up-to-date. */
583	XSync (dpy, False);	988	XSync (dpy, False);
584		989
…		…
602	i = (xa[XA_ESETROOT_PMAP_ID]	1007	i = (xa[XA_ESETROOT_PMAP_ID]
603	&& XGetWindowProperty (dpy, display->root, xa[XA_ESETROOT_PMAP_ID],	1008	&& XGetWindowProperty (dpy, display->root, xa[XA_ESETROOT_PMAP_ID],
604	0L, 1L, False, XA_PIXMAP, &atype, &aformat,	1009	0L, 1L, False, XA_PIXMAP, &atype, &aformat,
605	&nitems, &bytes_after, &prop) == Success);	1010	&nitems, &bytes_after, &prop) == Success);
606		1011
607	/* TODO: the below logic needs to be cleaned up */
608	if (!i \|\| prop == NULL	1012	if (!i \|\| prop == NULL)
609	#if TINTING
610	\|\| (!ISSET_PIXCOLOR (Color_tint) && rs[Rs_shade] == NULL
611	#ifdef HAVE_AFTERIMAGE
612	&& bgPixmap.original_asim == NULL && rs[Rs_blurradius] == NULL
613	#endif
614	)
615	#endif
616	)
617	rootpixmap = None;	1013	rootpixmap = None;
618	else	1014	else
619	{	1015	{
620	int junk;	1016	int junk;
621	unsigned int ujunk;	1017	unsigned int ujunk;
…		…
640	Bool whole_tint = False, no_tint = True;	1036	Bool whole_tint = False, no_tint = True;
641		1037
642	while (sx < 0) sx += (int)wrootattr.width;	1038	while (sx < 0) sx += (int)wrootattr.width;
643	while (sy < 0) sy += (int)wrootattr.height;	1039	while (sy < 0) sy += (int)wrootattr.height;
644		1040
645	#if TINTING
646	if (rs[Rs_shade])	1041	if (rs[Rs_shade])
647	shade = atoi (rs[Rs_shade]);	1042	shade = atoi (rs[Rs_shade]);
648	if (ISSET_PIXCOLOR (Color_tint))	1043	if (ISSET_PIXCOLOR (Color_tint))
649	pix_colors_focused [Color_tint].get (c);	1044	pix_colors_focused [Color_tint].get (c);
650	#define IS_COMPONENT_WHOLESOME(c) ((c) <=0x000700 \|\| (c)>=0x00f700)	1045	#define IS_COMPONENT_WHOLESOME(c) ((c) <=0x000700 \|\| (c)>=0x00f700)
…		…
652	whole_tint = (IS_COMPONENT_WHOLESOME(c.r)	1047	whole_tint = (IS_COMPONENT_WHOLESOME(c.r)
653	&& IS_COMPONENT_WHOLESOME(c.g)	1048	&& IS_COMPONENT_WHOLESOME(c.g)
654	&& IS_COMPONENT_WHOLESOME(c.b));	1049	&& IS_COMPONENT_WHOLESOME(c.b));
655	no_tint = (c.r >= 0x00f700 && c.g >= 0x00f700 && c.b >= 0x00f700);	1050	no_tint = (c.r >= 0x00f700 && c.g >= 0x00f700 && c.b >= 0x00f700);
656	#undef IS_COMPONENT_WHOLESOME	1051	#undef IS_COMPONENT_WHOLESOME
657	#endif /* TINTING */
658	/* theer are no performance advantages to reusing same pixmap */	1052	/* theer are no performance advantages to reusing same pixmap */
659	if (bgPixmap.pixmap != None)	1053	if (bgPixmap.pixmap != None)
660	XFreePixmap (dpy, bgPixmap.pixmap);	1054	XFreePixmap (dpy, bgPixmap.pixmap);
661	bgPixmap.pixmap = XCreatePixmap (dpy, vt, szHint.width, szHint.height, rootdepth);	1055	bgPixmap.pixmap = XCreatePixmap (dpy, vt, szHint.width, szHint.height, rootdepth);
662	bgPixmap.pmap_width = szHint.width;	1056	bgPixmap.pmap_width = szHint.width;
…		…
677	gcvalue.ts_x_origin = -sx;	1071	gcvalue.ts_x_origin = -sx;
678	gcvalue.ts_y_origin = -sy;	1072	gcvalue.ts_y_origin = -sy;
679	gc = XCreateGC (dpy, rootpixmap, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcvalue);	1073	gc = XCreateGC (dpy, rootpixmap, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcvalue);
680	XFillRectangle (dpy, bgPixmap.pixmap, gc, 0, 0, szHint.width, szHint.height);	1074	XFillRectangle (dpy, bgPixmap.pixmap, gc, 0, 0, szHint.width, szHint.height);
681		1075
682	#if TINTING
683	if (whole_tint && !no_tint)	1076	if (whole_tint && !no_tint)
684	{	1077	{
685	/* In this case we can tint image server-side getting significant	1078	/* In this case we can tint image server-side getting significant
686	* performance improvements, as we eliminate XImage transfer	1079	* performance improvements, as we eliminate XImage transfer
687	*/	1080	*/
…		…
689	gcvalue.function = GXand;	1082	gcvalue.function = GXand;
690	gcvalue.fill_style = FillSolid;	1083	gcvalue.fill_style = FillSolid;
691	XChangeGC (dpy, gc, GCFillStyle \| GCForeground \| GCFunction, &gcvalue);	1084	XChangeGC (dpy, gc, GCFillStyle \| GCForeground \| GCFunction, &gcvalue);
692	XFillRectangle (dpy, bgPixmap.pixmap, gc, 0, 0, szHint.width, szHint.height);	1085	XFillRectangle (dpy, bgPixmap.pixmap, gc, 0, 0, szHint.width, szHint.height);
693	}	1086	}
694	#endif
695	success = True;	1087	success = True;
696	#ifdef HAVE_AFTERIMAGE	1088	#ifdef HAVE_AFTERIMAGE
697	if (rs[Rs_blurradius] \|\| bgPixmap.original_asim != NULL \|\| (!whole_tint && (!no_tint \|\| shade !=100)))	1089	if (rs[Rs_blurradius] \|\| bgPixmap.original_asim != NULL \|\| (!whole_tint && (!no_tint \|\| shade !=100)))
698	{	1090	{
699	ARGB32 tint = TINT_LEAVE_SAME;	1091	ARGB32 tint = TINT_LEAVE_SAME;
…		…
729	{	1121	{
730	destroy_asimage (&back_im);	1122	destroy_asimage (&back_im);
731	back_im = tmp;	1123	back_im = tmp;
732	}	1124	}
733	}	1125	}
734		1126	/* TODO: temporary fix - redo the logic, so that same function can do both
735	if (bgPixmap.original_asim != NULL)	1127	transparency and non-transparency */
736	{	1128	bgPixmap.render_asim (back_im, tint);
737	ASImageLayer *layers = create_image_layers (2);
738	ASImage *merged_im = NULL;
739	int fore_w, fore_h;
740
741	layers[0].im = back_im;
742	layers[0].clip_width = szHint.width;
743	layers[0].clip_height = szHint.height;
744	layers[0].tint = tint;
745	layers[1].im = bgPixmap.original_asim;
746	if (bgPixmap.auto_resize)
747	{
748	fore_w = szHint.width;
749	fore_h = szHint.height;
750	}
751	else
752	{
753	fore_w = (bgPixmap.w == 0) ? bgPixmap.original_asim->width : bgPixmap.w;
754	fore_h = (bgPixmap.h == 0) ? bgPixmap.original_asim->height : bgPixmap.h;
755	}
756	if (fore_w != bgPixmap.original_asim->width
757	\|\| fore_h != bgPixmap.original_asim->height)
758	{
759	layers[1].im = scale_asimage (asv,
760	bgPixmap.original_asim,
761	fore_w, fore_h,
762	ASA_ASImage, 100,
763	ASIMAGE_QUALITY_DEFAULT);
764	}
765	layers[1].clip_width = szHint.width;
766	layers[1].clip_height = szHint.height;
767
768	if (rs[Rs_blendtype])
769	{
770	layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
771	if (layers[1].merge_scanlines == NULL)
772	layers[1].merge_scanlines = alphablend_scanlines;
773	}
774	PRINT_BACKGROUND_OP_TIME;
775	merged_im = merge_layers (asv, layers, 2, szHint.width, szHint.height,
776	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
777	if (layers[1].im != bgPixmap.original_asim)
778	destroy_asimage (&(layers[1].im));
779	free (layers);
780
781	if (merged_im != NULL)
782	{
783	destroy_asimage (&back_im);
784	back_im = merged_im;
785	}
786	PRINT_BACKGROUND_OP_TIME;
787	}
788	else if (tint != TINT_LEAVE_SAME)
789	{
790	ASImage* tmp = tile_asimage (asv, back_im, 0, 0, szHint.width, szHint.height, tint, ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
791	if (tmp)
792	{
793	destroy_asimage (&back_im);
794	back_im = tmp;
795	}
796	PRINT_BACKGROUND_OP_TIME;
797	}
798	asimage2drawable (asv, bgPixmap.pixmap, back_im, gc, 0, 0, 0, 0, szHint.width, szHint.height, True);
799	destroy_asimage (&back_im);	1129	destroy_asimage (&back_im);
		1130
800	} /* back_im != NULL */	1131	} /* back_im != NULL */
801	else	1132	else
802	success = False;	1133	success = False;
803	}	1134	}
804	#else /* HAVE_AFTERIMAGE */	1135	#else /* HAVE_AFTERIMAGE */
805	#if TINTING
806	if (!whole_tint && (!no_tint \|\| shade !=100))	1136	if (!whole_tint && (!no_tint \|\| shade !=100))
807	{	1137	{
808	XImage *image = XGetImage (dpy, bgPixmap.pixmap, 0, 0, szHint.width, szHint.height, AllPlanes, ZPixmap);	1138	XImage *image = XGetImage (dpy, bgPixmap.pixmap, 0, 0, szHint.width, szHint.height, AllPlanes, ZPixmap);
809	success = False;	1139	success = False;
810	if (image != NULL)	1140	if (image != NULL)
…		…
817	XPutImage (dpy, bgPixmap.pixmap, gc, image, 0, 0, 0, 0, image->width, image->height);	1147	XPutImage (dpy, bgPixmap.pixmap, gc, image, 0, 0, 0, 0, image->width, image->height);
818	XDestroyImage (image);	1148	XDestroyImage (image);
819	success = True;	1149	success = True;
820	}	1150	}
821	}	1151	}
822	#endif
823	#endif /* HAVE_AFTERIMAGE */	1152	#endif /* HAVE_AFTERIMAGE */
824	PRINT_BACKGROUND_OP_TIME;	1153	PRINT_BACKGROUND_OP_TIME;
825		1154
826	if (gc != NULL)	1155	if (gc != NULL)
827	XFreeGC (dpy, gc);	1156	XFreeGC (dpy, gc);
828		1157
		1158	bgPixmap.apply_background();
829	if (!success)	1159	if (!success)
830	{
831	if (am_transparent && am_pixmap_trans)
832	{
833	pchanged = 1;
834	if (bgPixmap.pixmap != None)
835	{
836	XFreePixmap (dpy, bgPixmap.pixmap);
837	bgPixmap.pixmap = None;
838	}
839	}
840
841	am_pixmap_trans = 0;	1160	am_pixmap_trans = 0;
842	}
843	else	1161	else
844	{	1162	{
845	XSetWindowBackgroundPixmap (dpy, parent[0], bgPixmap.pixmap);
846	XClearWindow (dpy, parent[0]);
847
848	if (!am_transparent \|\| !am_pixmap_trans)
849	pchanged = 1;
850
851	am_transparent = am_pixmap_trans = 1;	1163	am_transparent = am_pixmap_trans = 1;
852	}	1164	}
853	} /* rootpixmap != None */	1165	} /* rootpixmap != None */
854		1166
855	if (am_pixmap_trans)	1167	if (am_pixmap_trans)
856	XSetWindowBackgroundPixmap (dpy, vt, ParentRelative);
857	else
858	{
859	unsigned int n;
860	/*
861	* InheritPixmap transparency
862	*/
863	for (i = 1; i < (int) (sizeof (parent) / sizeof (Window)); i++)
864	{
865	oldp = parent[i];
866	XQueryTree (dpy, parent[i - 1], &root, &parent[i], &list, &n);
867	XFree (list);
868
869	if (parent[i] == display->root)
870	{
871	if (oldp != None)
872	pchanged = 1;
873
874	break;
875	}
876
877	if (oldp != parent[i])
878	pchanged = 1;
879	}
880
881	n = 0;
882
883	if (pchanged)
884	for (; n < (unsigned int)i; n++)
885	{
886	XGetWindowAttributes (dpy, parent[n], &wattr);
887
888	if (wattr.depth != rootdepth \|\| wattr.c_class == InputOnly)
889	{
890	n = (int) (sizeof (parent) / sizeof (Window)) + 1;
891	break;
892	}
893	}
894
895	if (n > (sizeof (parent) / sizeof (parent[0])))
896	{
897	XSetWindowBackground (dpy, parent[0], pix_colors_focused[Color_border]);
898	XSetWindowBackground (dpy, vt, pix_colors_focused[Color_bg]);
899	am_transparent = 0;
900	/* XXX: also turn off Opt_transparent? */
901	}
902	else
903	{
904	for (n = 0; n < (unsigned int)i; n++)
905	{
906	XSetWindowBackgroundPixmap (dpy, parent[n], ParentRelative);
907	XClearWindow (dpy, parent[n]);
908	}
909
910	XSetWindowBackgroundPixmap (dpy, vt, ParentRelative);
911	am_transparent = 1;
912	}
913
914	for (; i < (int) (sizeof (parent) / sizeof (Window)); i++)
915	parent[i] = None;
916	}	1168	{
917
918	if (scrollBar.win)	1169	if (scrollBar.win)
919	{	1170	{
920	XSetWindowBackgroundPixmap (dpy, scrollBar.win, ParentRelative);
921	scrollBar.setIdle ();	1171	scrollBar.setIdle ();
922	scrollbar_show (0);	1172	scrollbar_show (0);
923	}	1173	}
924		1174
925	if (am_transparent)	1175	if (am_transparent)
926	{	1176	{
927	want_refresh = want_full_refresh = 1;	1177	want_refresh = want_full_refresh = 1;
928	if (am_pixmap_trans)	1178	if (am_pixmap_trans)
929	flush ();	1179	flush ();
		1180	}
930	}	1181	}
931
932	// return pchanged;
933	}	1182	}
934	#endif	1183	#endif

Diff Legend

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

Comparing rxvt-unicode/src/xpm.C (file contents): Revision 1.55 by sasha, Fri Aug 3 05:33:04 2007 UTC vs. Revision 1.63 by sasha, Wed Aug 8 22:39:49 2007 UTC

Diff Legend

Comparing rxvt-unicode/src/xpm.C (file contents):
Revision 1.55 by sasha, Fri Aug 3 05:33:04 2007 UTC vs.
Revision 1.63 by sasha, Wed Aug 8 22:39:49 2007 UTC