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

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

…		…
47	* Adjusting position only :	47	* Adjusting position only :
48	* =+X+Y Set position to X% by Y% (absolute).	48	* =+X+Y Set position to X% by Y% (absolute).
49	* =+X Set position to X% by X%.	49	* =+X Set position to X% by X%.
50	* +X+Y Adjust position horizontally X% and vertically Y%	50	* +X+Y Adjust position horizontally X% and vertically Y%
51	* from current position (relative).	51	* from current position (relative).
52	* +X+X Adjust position horizontally X% and vertically X%	52	* +X Adjust position horizontally X% and vertically X%
53	* from current position.	53	* from current position.
54	*	54	*
55	* Adjusting scale only :	55	* Adjusting scale only :
56	* Wx0 Multiply horizontal scaling factor by W%	56	* Wx0 Multiply horizontal scaling factor by W%
57	* 0xH Multiply vertical scaling factor by H%	57	* 0xH Multiply vertical scaling factor by H%
…		…
72		72
73	#ifdef HAVE_BG_PIXMAP	73	#ifdef HAVE_BG_PIXMAP
74	bool	74	bool
75	bgPixmap_t::window_size_sensitive ()	75	bgPixmap_t::window_size_sensitive ()
76	{	76	{
77	return (flags&(bgPmap_Scale\|bgPmap_Transparent));
78	}
79
80	#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	}
		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
81	bool	164	bool
82	bgPixmap_t::handle_geometry (const char *geom)	165	bgPixmap_t::handle_geometry (const char *geom)
83	{	166	{
84	int geom_flags, changed = 0;	167	int geom_flags = 0, changed = 0;
85	int x = 0, y = 0;	168	int x = 0, y = 0;
86	unsigned int w = 0, h = 0;	169	unsigned int w = 0, h = 0;
87	unsigned int n;	170	unsigned int n;
88	unsigned long new_flags = (flags&(~bgPmap_geometryFlags)) ;	171	unsigned long new_flags = (flags&(~bgPmap_geometryFlags));
89	char *p;	172	char *p;
90	#define MAXLEN_GEOM sizeof("[10000x10000+10000+10000]")	173	# define MAXLEN_GEOM 256 /* could be longer then regular geometry string */
91		174
92	if (geom == NULL)	175	if (geom == NULL)
93	return false;	176	return false;
94		177
95	char str[MAXLEN_GEOM];	178	char str[MAXLEN_GEOM];
96		179
97	if (!strcmp (geom, "?"))	180	if (!strcmp (geom, "?"))
98	{	181	{
99	#if 0 /* TODO: */	182	if (target)
		183	{
100	sprintf (str, "[%dx%d+%d+%d]", /* can't presume snprintf () ! */	184	sprintf (str, "[%dx%d+%d+%d]", /* can't presume snprintf () ! */
101	min (h_scale, 32767), min (v_scale, 32767),	185	min (h_scale, 32767), min (v_scale, 32767),
102	min (h_align, 32767), min (v_align, 32767));	186	min (h_align, 32767), min (v_align, 32767));
103	process_xterm_seq (XTerm_title, str, CHAR_ST);	187	target->process_xterm_seq (XTerm_title, str, CHAR_ST);
104	#endif	188	}
105	return false;	189	return false;
106	}	190	}
107		191	while (isspace(*geom)) ++geom;
108	if ((p = strchr (geom, ';')) == NULL)	192	if ((p = strchr (geom, ';')) == NULL)
109	p = strchr (geom, '\0');	193	p = strchr (geom, '\0');
110		194
111	n = (p - geom);	195	n = (p - geom);
112	if (n < MAXLEN_GEOM)	196	if (n < MAXLEN_GEOM)
113	{	197	{
		198	char *ops;
114	new_flags \|= bgPmap_geometrySet;	199	new_flags \|= bgPmap_geometrySet;
115		200
116	strncpy (str, geom, n);	201	strncpy (str, geom, n);
117	str[n] = '\0';	202	str[n] = '\0';
118		203	if (str[0] == ':')
119	if (strcmp(str, "auto") == 0)	204	ops = &str[0];
120	{	205	else if (str[0] != 'x' && str[0] != 'X' && isalpha(str[0]))
121	w = h = 100;	206	ops = &str[0];
122	geom_flags = WidthValue\|HeightValue ;
123	}
124	else	207	else
125	{	208	{
		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 */
126	geom_flags = XParseGeometry (str, &x, &y, &w, &h);	222	geom_flags = XParseGeometry (str, &x, &y, &w, &h);
127	}	223
128	/* code below is garbage and needs to be rewritten */	224	if ((geom_flags & XValue) && !(geom_flags & YValue))
129	if (!geom_flags)
130	{	225	{
		226	y = x;
131	geom_flags \|= WidthValue;	227	geom_flags \|= YValue;
132	w = 0;	228	}
133	} /* default is tile */
134		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	}
135	if (geom_flags & WidthValue)	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 */
136	{	255	{
137	if (!(geom_flags & XValue))	256	if (!(geom_flags & XValue))
138	x = 50;	257	{/* use default geometry - centered */
		258	x = y = bgPmap_defaultAlign;
		259	}
		260	else if (!(geom_flags & YValue))
		261	y = x;
139		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	{
140	if (!(geom_flags & HeightValue))	269	if (!(geom_flags & HeightValue))
141	h = w;	270	h = w;
142		271	}
143	if (w && !h)	272	else
		273	w = h;
144	{	274	}
145	w = (h_scale * w) / 100;	275	} /* done parsing geometry string */
146	h = v_scale;	276	else if (!(flags & bgPmap_geometrySet))
		277	{ /* default geometry - scaled and centered */
		278	x = y = bgPmap_defaultAlign;
		279	w = h = bgPmap_defaultScale;
147	}	280	}
148	else if (h && !w)
149	{
150	w = h_scale;
151	h = (v_scale * h) / 100;
152	}
153
154	min_it (w, 32767);
155	min_it (h, 32767);
156
157	if (h_scale != w)
158	{
159	h_scale = w;
160	changed++;
161	}
162
163	if (v_scale != h)
164	{
165	v_scale = h;
166	changed++;
167	}
168	}	281
169	if (!(geom_flags & YValue))	282	if (!(flags & bgPmap_geometrySet))
170	{	283	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;
171	if (geom_flags & XNegative)
172	geom_flags \|= YNegative;
173		284
174	y = x;	285	if (ops)
175	}	286	{
176		287	while (*ops)
177	if (!(geom_flags & WidthValue) && geom[0] != '=')	288	{
		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"))
		292	{
		293	w = h = 0;
		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 */
178	{	336	}
179	x += h_align;
180	y += v_align;
181	}
182		337
183	if (h_align != x)	338	if (check_set_scale_value (geom_flags, WidthValue, h_scale, w))
184	{
185	h_align = x;
186	changed++;	339	++changed;
187	}	340	if (check_set_scale_value (geom_flags, HeightValue, v_scale, h))
188
189	if (v_align != y)
190	{
191	v_align = y;
192	changed++;	341	++changed;
193	}	342	if (check_set_align_value (geom_flags, XValue, h_align, x))
194		343	++changed;
195	if (h_scale != 0)	344	if (check_set_align_value (geom_flags, YValue, v_align, y))
196	new_flags \|= bgPmap_hScale;	345	++changed;
197	if (v_scale != 0)
198	new_flags \|= bgPmap_vScale;
199	}	346	}
200		347
201	if (new_flags != flags)	348	if (new_flags != flags)
202	{	349	{
203	flags = new_flags;	350	flags = new_flags;
204	changed++;	351	changed++;
205	}	352	}
		353	//fprintf( stderr, "flags = %lX, scale = %ux%u, align=%+d%+d\n",
		354	// flags, h_scale, v_scale, h_align, v_align);
206	return (changed > 0);	355	return (changed > 0);
207	}	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)
		393	{
		394	ASImage* tmp = tile_asimage (target->asv, background, 0, 0,
		395	target_width, target_height, background_tint,
		396	ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
		397	if (tmp)
		398	result = tmp;
		399	}
		400	}
		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)
		424	{
		425	ASImage *tmp = tile_asimage (target->asv, result,
		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	}
		437	}
		438	}
		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)
		461	{
		462	while (y > 0) y -= (int)result->height;
		463	layers[1].dst_y = y;
		464	layers[1].clip_height = result->height + target_height;
		465	}
		466	else
		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);
		486	}
		487	}
		488
		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)
		495	{
		496	XFreePixmap (target->dpy, pixmap);
		497	pixmap = None;
		498	}
		499	}
		500
		501	if (result)
		502	{
		503	XGCValues gcv;
		504	GC gc;
		505
		506	/* create Pixmap */
		507	if (pixmap == None)
		508	{
		509	pixmap = XCreatePixmap (target->dpy, target->vt, new_pmap_width, new_pmap_height, target->depth);
		510	pmap_width = new_pmap_width;
		511	pmap_height = new_pmap_height;
		512	pmap_depth = target->depth;
		513	}
		514	/* fill with background color ( if result's not completely overlapping it)*/
		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)
		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);
		526
		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	}
		533	}
		534
		535	/* put result on pixmap */
		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);
		538
		539	if (result != background && result != original_asim)
		540	destroy_asimage (&result);
		541
		542	XFreeGC (target->dpy, gc);
		543	if (background)
		544	flags \|= bgPmap_Transparent;
		545	else
		546	flags &= ~bgPmap_Transparent;
		547	}
		548
		549	return true;
		550	}
		551	# endif /* HAVE_AFTERIMAGE */
208		552
209	void	553	void
210	rxvt_term::resize_pixmap ()	554	rxvt_term::resize_pixmap ()
211	{	555	{
212	XGCValues gcvalue;	556
213	GC gc;
214	unsigned int w = bgPixmap.h_scale*szHint.width/100;
215	unsigned int h = bgPixmap.v_scale*szHint.height/100;
216	int x = bgPixmap.h_align*szHint.width/100;
217	int y = bgPixmap.v_align*szHint.height/100;
218	#ifdef HAVE_AFTERIMAGE
219	ASImage *im = bgPixmap.original_asim;
220	#else
221	void *im = NULL;
222	#endif
223	/* preliminary cleanup - this needs to be integrated with check_our_parents() code */
224	if (bgPixmap.pixmap != None)
225	{
226	XFreePixmap (dpy, bgPixmap.pixmap);
227	bgPixmap.pixmap = None ;
228	}
229	#ifdef ENABLE_TRANSPARENCY	557	# ifdef ENABLE_TRANSPARENCY
230	if (option(Opt_transparent) && am_transparent)	558	if (option(Opt_transparent) && am_transparent)
231	{	559	{
232	/* we need to re-generate transparency pixmap in that case ! */	560	/* we need to re-generate transparency pixmap in that case ! */
233	check_our_parents ();	561	check_our_parents ();
234	return;	562	return;
235	}	563	}
236	#endif	564	# endif
237
238	if (im == NULL)
239	{ /* So be it: I'm not using pixmaps */
240	XSetWindowBackground (dpy, vt, pix_colors[Color_bg]);
241	return;
242	}
243
244	gcvalue.foreground = pix_colors[Color_bg];
245	gc = XCreateGC (dpy, vt, GCForeground, &gcvalue);
246
247	/* don't zoom pixmap too much nor expand really small pixmaps */
248	if (w > 16000)
249	w = 1;
250	if (h > 16000)
251	h = 1;
252
253	#ifdef HAVE_AFTERIMAGE	565	# ifdef HAVE_AFTERIMAGE
254	if (w == 0)	566	bgPixmap.render_asim(NULL, TINT_LEAVE_SAME);
255	w = im->width;	567	bgPixmap.apply_background();
256	if (h == 0)
257	h = im->height;
258
259	if (w != im->width \|\| h != im->height)
260	{
261	ASImage *tmp = scale_asimage (asv, im, w, h, (x == 0 && y == 0)?ASA_XImage:ASA_ASImage, 0, ASIMAGE_QUALITY_DEFAULT);
262	if (tmp != NULL)
263	im = tmp;
264	}
265	bgPixmap.pmap_width = MIN(w,szHint.width);
266	bgPixmap.pmap_height = MIN(h,szHint.height);
267	#if 0 /* TODO: fix that! */
268	if (x != 0 \|\| y != 0)
269	{
270	ASImage *tmp = tile_asimage (asv, im, x, y, w, h, TINT_LEAVE_SAME, ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
271	if (tmp != NULL)
272	{
273	if (im != bgPixmap.original_asim)
274	destroy_asimage (&im);
275	im = tmp;
276	}
277	}
278	#endif
279	bgPixmap.pixmap = XCreatePixmap (dpy, vt, bgPixmap.pmap_width, bgPixmap.pmap_height, depth);
280	bgPixmap.pmap_depth = depth;
281
282	asimage2drawable (asv, bgPixmap.pixmap, im, gc, 0, 0, 0, 0, bgPixmap.pmap_width, bgPixmap.pmap_height, True);
283
284	if (im != bgPixmap.original_asim)
285	destroy_asimage (&im);
286	#endif	568	# endif
287	if( bgPixmap.pixmap )
288	XSetWindowBackgroundPixmap (dpy, vt, bgPixmap.pixmap);
289
290	XFreeGC (dpy, gc);
291	}	569	}
292		570
293	void	571	void
294	rxvt_term::set_bgPixmap (const char *file)	572	rxvt_term::set_bgPixmap (const char *file)
295	{	573	{
…		…
304	}	582	}
305		583
306	XSetWindowBackground (dpy, vt, pix_colors[Color_bg]);	584	XSetWindowBackground (dpy, vt, pix_colors[Color_bg]);
307	if (*file != '\0')	585	if (*file != '\0')
308	{	586	{
309	#ifdef HAVE_AFTERIMAGE	587	# ifdef HAVE_AFTERIMAGE
310	if (asimman == NULL)	588	if (asimman == NULL)
311	asimman = create_generic_imageman(rs[Rs_path]);	589	asimman = create_generic_imageman(rs[Rs_path]);
312	if ((f = strchr (file, ';')) == NULL)	590	if ((f = strchr (file, ';')) == NULL)
313	bgPixmap.original_asim = get_asimage( asimman, file, 0xFFFFFFFF, 100 );	591	bgPixmap.original_asim = get_asimage( asimman, file, 0xFFFFFFFF, 100 );
314	else	592	else
…		…
318	strncpy (f, file, len);	596	strncpy (f, file, len);
319	f[len] = '\0';	597	f[len] = '\0';
320	bgPixmap.original_asim = get_asimage( asimman, f, 0xFFFFFFFF, 100 );	598	bgPixmap.original_asim = get_asimage( asimman, f, 0xFFFFFFFF, 100 );
321	free( f );	599	free( f );
322	}	600	}
323	#endif	601	# endif
324	}	602	}
325		603	resize_pixmap (); /* TODO: temporary fix - should be done by the caller! */
326	resize_pixmap ();
327	}	604	}
328		605
329	#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	}
330	#endif /* HAVE_BG_PIXMAP */	694	#endif /* HAVE_BG_PIXMAP */
331		695
		696
		697
332	#ifdef ENABLE_TRANSPARENCY	698	#ifdef ENABLE_TRANSPARENCY
333	#if TINTING && !defined(HAVE_AFTERIMAGE)	699	#ifndef HAVE_AFTERIMAGE
334	/* taken from aterm-0.4.2 */	700	/* taken from aterm-0.4.2 */
335		701
336	typedef uint32_t RUINT32T;	702	typedef uint32_t RUINT32T;
337		703
338	static void	704	static void
…		…
575	}	941	}
576		942
577	void	943	void
578	rxvt_term::check_our_parents_cb (time_watcher &w)	944	rxvt_term::check_our_parents_cb (time_watcher &w)
579	{	945	{
580	int i, pchanged, aformat, rootdepth;	946	int i, aformat, rootdepth;
581	unsigned long nitems, bytes_after;	947	unsigned long nitems, bytes_after;
582	Atom atype;	948	Atom atype;
583	unsigned char *prop = NULL;	949	unsigned char *prop = NULL;
584	Window root, oldp, *list;	950	Window root, oldp, *list;
585	Pixmap rootpixmap = None;	951	Pixmap rootpixmap = None;
586	XWindowAttributes wattr, wrootattr;	952	XWindowAttributes wattr, wrootattr;
587	int sx, sy;	953	int sx, sy;
588	Window cr;	954	Window cr;
589	unsigned int rootpixmap_w = 0, rootpixmap_h = 0;	955	unsigned int rootpixmap_w = 0, rootpixmap_h = 0;
590		956
591	pchanged = 0;
592
593	if (!option (Opt_transparent))	957	if (!option (Opt_transparent))
594	return /pchanged/; /* Don't try any more */	958	return; /* Don't try any more */
595		959
596	#if 0	960	#if 0
597	struct timeval stv;	961	struct timeval stv;
598	gettimeofday (&stv,NULL);	962	gettimeofday (&stv,NULL);
599	#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;\
…		…
611		975
612	if (rootdepth != wattr.depth)	976	if (rootdepth != wattr.depth)
613	{	977	{
614	if (am_transparent)	978	if (am_transparent)
615	{	979	{
616	pchanged = 1;
617	XSetWindowBackground (dpy, vt, pix_colors_focused[Color_bg]);	980	XSetWindowBackground (dpy, vt, pix_colors_focused[Color_bg]);
618	am_transparent = am_pixmap_trans = 0;	981	am_transparent = am_pixmap_trans = 0;
619	}	982	}
620		983
621	return /pchanged/; /* Don't try any more */	984	return; /* Don't try any more */
622	}	985	}
623		986
624	/* 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. */
625	XSync (dpy, False);	988	XSync (dpy, False);
626		989
…		…
644	i = (xa[XA_ESETROOT_PMAP_ID]	1007	i = (xa[XA_ESETROOT_PMAP_ID]
645	&& XGetWindowProperty (dpy, display->root, xa[XA_ESETROOT_PMAP_ID],	1008	&& XGetWindowProperty (dpy, display->root, xa[XA_ESETROOT_PMAP_ID],
646	0L, 1L, False, XA_PIXMAP, &atype, &aformat,	1009	0L, 1L, False, XA_PIXMAP, &atype, &aformat,
647	&nitems, &bytes_after, &prop) == Success);	1010	&nitems, &bytes_after, &prop) == Success);
648		1011
649	/* TODO: the below logic needs to be cleaned up */
650	if (!i \|\| prop == NULL	1012	if (!i \|\| prop == NULL)
651	#if TINTING
652	\|\| (!ISSET_PIXCOLOR (Color_tint) && rs[Rs_shade] == NULL
653	#ifdef HAVE_AFTERIMAGE
654	&& bgPixmap.original_asim == NULL && rs[Rs_blurradius] == NULL
655	#endif
656	)
657	#endif
658	)
659	rootpixmap = None;	1013	rootpixmap = None;
660	else	1014	else
661	{	1015	{
662	int junk;	1016	int junk;
663	unsigned int ujunk;	1017	unsigned int ujunk;
…		…
682	Bool whole_tint = False, no_tint = True;	1036	Bool whole_tint = False, no_tint = True;
683		1037
684	while (sx < 0) sx += (int)wrootattr.width;	1038	while (sx < 0) sx += (int)wrootattr.width;
685	while (sy < 0) sy += (int)wrootattr.height;	1039	while (sy < 0) sy += (int)wrootattr.height;
686		1040
687	#if TINTING
688	if (rs[Rs_shade])	1041	if (rs[Rs_shade])
689	shade = atoi (rs[Rs_shade]);	1042	shade = atoi (rs[Rs_shade]);
690	if (ISSET_PIXCOLOR (Color_tint))	1043	if (ISSET_PIXCOLOR (Color_tint))
691	pix_colors_focused [Color_tint].get (c);	1044	pix_colors_focused [Color_tint].get (c);
692	#define IS_COMPONENT_WHOLESOME(c) ((c) <=0x000700 \|\| (c)>=0x00f700)	1045	#define IS_COMPONENT_WHOLESOME(c) ((c) <=0x000700 \|\| (c)>=0x00f700)
…		…
694	whole_tint = (IS_COMPONENT_WHOLESOME(c.r)	1047	whole_tint = (IS_COMPONENT_WHOLESOME(c.r)
695	&& IS_COMPONENT_WHOLESOME(c.g)	1048	&& IS_COMPONENT_WHOLESOME(c.g)
696	&& IS_COMPONENT_WHOLESOME(c.b));	1049	&& IS_COMPONENT_WHOLESOME(c.b));
697	no_tint = (c.r >= 0x00f700 && c.g >= 0x00f700 && c.b >= 0x00f700);	1050	no_tint = (c.r >= 0x00f700 && c.g >= 0x00f700 && c.b >= 0x00f700);
698	#undef IS_COMPONENT_WHOLESOME	1051	#undef IS_COMPONENT_WHOLESOME
699	#endif /* TINTING */
700	/* theer are no performance advantages to reusing same pixmap */	1052	/* theer are no performance advantages to reusing same pixmap */
701	if (bgPixmap.pixmap != None)	1053	if (bgPixmap.pixmap != None)
702	XFreePixmap (dpy, bgPixmap.pixmap);	1054	XFreePixmap (dpy, bgPixmap.pixmap);
703	bgPixmap.pixmap = XCreatePixmap (dpy, vt, szHint.width, szHint.height, rootdepth);	1055	bgPixmap.pixmap = XCreatePixmap (dpy, vt, szHint.width, szHint.height, rootdepth);
704	bgPixmap.pmap_width = szHint.width;	1056	bgPixmap.pmap_width = szHint.width;
…		…
719	gcvalue.ts_x_origin = -sx;	1071	gcvalue.ts_x_origin = -sx;
720	gcvalue.ts_y_origin = -sy;	1072	gcvalue.ts_y_origin = -sy;
721	gc = XCreateGC (dpy, rootpixmap, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcvalue);	1073	gc = XCreateGC (dpy, rootpixmap, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcvalue);
722	XFillRectangle (dpy, bgPixmap.pixmap, gc, 0, 0, szHint.width, szHint.height);	1074	XFillRectangle (dpy, bgPixmap.pixmap, gc, 0, 0, szHint.width, szHint.height);
723		1075
724	#if TINTING
725	if (whole_tint && !no_tint)	1076	if (whole_tint && !no_tint)
726	{	1077	{
727	/* In this case we can tint image server-side getting significant	1078	/* In this case we can tint image server-side getting significant
728	* performance improvements, as we eliminate XImage transfer	1079	* performance improvements, as we eliminate XImage transfer
729	*/	1080	*/
…		…
731	gcvalue.function = GXand;	1082	gcvalue.function = GXand;
732	gcvalue.fill_style = FillSolid;	1083	gcvalue.fill_style = FillSolid;
733	XChangeGC (dpy, gc, GCFillStyle \| GCForeground \| GCFunction, &gcvalue);	1084	XChangeGC (dpy, gc, GCFillStyle \| GCForeground \| GCFunction, &gcvalue);
734	XFillRectangle (dpy, bgPixmap.pixmap, gc, 0, 0, szHint.width, szHint.height);	1085	XFillRectangle (dpy, bgPixmap.pixmap, gc, 0, 0, szHint.width, szHint.height);
735	}	1086	}
736	#endif
737	success = True;	1087	success = True;
738	#ifdef HAVE_AFTERIMAGE	1088	#ifdef HAVE_AFTERIMAGE
739	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)))
740	{	1090	{
741	ARGB32 tint = TINT_LEAVE_SAME;	1091	ARGB32 tint = TINT_LEAVE_SAME;
…		…
771	{	1121	{
772	destroy_asimage (&back_im);	1122	destroy_asimage (&back_im);
773	back_im = tmp;	1123	back_im = tmp;
774	}	1124	}
775	}	1125	}
776		1126	/* TODO: temporary fix - redo the logic, so that same function can do both
777	if (bgPixmap.original_asim != NULL)	1127	transparency and non-transparency */
778	{	1128	bgPixmap.render_asim (back_im, tint);
779	ASImageLayer *layers = create_image_layers (2);
780	ASImage *merged_im = NULL;
781	int fore_w, fore_h;
782
783	layers[0].im = back_im;
784	layers[0].clip_width = szHint.width;
785	layers[0].clip_height = szHint.height;
786	layers[0].tint = tint;
787	layers[1].im = bgPixmap.original_asim;
788
789	fore_w = (bgPixmap.h_scale == 0) ? bgPixmap.original_asim->width : bgPixmap.h_scale*szHint.width/100;
790	fore_h = (bgPixmap.v_scale == 0) ? bgPixmap.original_asim->height : bgPixmap.v_scale*szHint.height/100;
791
792	if (fore_w != bgPixmap.original_asim->width
793	\|\| fore_h != bgPixmap.original_asim->height)
794	{
795	layers[1].im = scale_asimage (asv,
796	bgPixmap.original_asim,
797	fore_w, fore_h,
798	ASA_ASImage, 100,
799	ASIMAGE_QUALITY_DEFAULT);
800	}
801	layers[1].clip_width = szHint.width;
802	layers[1].clip_height = szHint.height;
803
804	if (rs[Rs_blendtype])
805	{
806	layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
807	if (layers[1].merge_scanlines == NULL)
808	layers[1].merge_scanlines = alphablend_scanlines;
809	}
810	PRINT_BACKGROUND_OP_TIME;
811	merged_im = merge_layers (asv, layers, 2, szHint.width, szHint.height,
812	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
813	if (layers[1].im != bgPixmap.original_asim)
814	destroy_asimage (&(layers[1].im));
815	free (layers);
816
817	if (merged_im != NULL)
818	{
819	destroy_asimage (&back_im);
820	back_im = merged_im;
821	}
822	PRINT_BACKGROUND_OP_TIME;
823	}
824	else if (tint != TINT_LEAVE_SAME)
825	{
826	ASImage* tmp = tile_asimage (asv, back_im, 0, 0, szHint.width, szHint.height, tint, ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
827	if (tmp)
828	{
829	destroy_asimage (&back_im);
830	back_im = tmp;
831	}
832	PRINT_BACKGROUND_OP_TIME;
833	}
834	asimage2drawable (asv, bgPixmap.pixmap, back_im, gc, 0, 0, 0, 0, szHint.width, szHint.height, True);
835	destroy_asimage (&back_im);	1129	destroy_asimage (&back_im);
		1130
836	} /* back_im != NULL */	1131	} /* back_im != NULL */
837	else	1132	else
838	success = False;	1133	success = False;
839	}	1134	}
840	#else /* HAVE_AFTERIMAGE */	1135	#else /* HAVE_AFTERIMAGE */
841	#if TINTING
842	if (!whole_tint && (!no_tint \|\| shade !=100))	1136	if (!whole_tint && (!no_tint \|\| shade !=100))
843	{	1137	{
844	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);
845	success = False;	1139	success = False;
846	if (image != NULL)	1140	if (image != NULL)
…		…
853	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);
854	XDestroyImage (image);	1148	XDestroyImage (image);
855	success = True;	1149	success = True;
856	}	1150	}
857	}	1151	}
858	#endif
859	#endif /* HAVE_AFTERIMAGE */	1152	#endif /* HAVE_AFTERIMAGE */
860	PRINT_BACKGROUND_OP_TIME;	1153	PRINT_BACKGROUND_OP_TIME;
861		1154
862	if (gc != NULL)	1155	if (gc != NULL)
863	XFreeGC (dpy, gc);	1156	XFreeGC (dpy, gc);
864		1157
		1158	bgPixmap.apply_background();
865	if (!success)	1159	if (!success)
866	{
867	if (am_transparent && am_pixmap_trans)
868	{
869	pchanged = 1;
870	if (bgPixmap.pixmap != None)
871	{
872	XFreePixmap (dpy, bgPixmap.pixmap);
873	bgPixmap.pixmap = None;
874	}
875	}
876
877	am_pixmap_trans = 0;	1160	am_pixmap_trans = 0;
878	}
879	else	1161	else
880	{	1162	{
881	XSetWindowBackgroundPixmap (dpy, parent[0], bgPixmap.pixmap);
882	XClearWindow (dpy, parent[0]);
883
884	if (!am_transparent \|\| !am_pixmap_trans)
885	pchanged = 1;
886
887	am_transparent = am_pixmap_trans = 1;	1163	am_transparent = am_pixmap_trans = 1;
888	}	1164	}
889	} /* rootpixmap != None */	1165	} /* rootpixmap != None */
890		1166
891	if (am_pixmap_trans)	1167	if (am_pixmap_trans)
892	XSetWindowBackgroundPixmap (dpy, vt, ParentRelative);
893	else
894	{
895	unsigned int n;
896	/*
897	* InheritPixmap transparency
898	*/
899	for (i = 1; i < (int) (sizeof (parent) / sizeof (Window)); i++)
900	{
901	oldp = parent[i];
902	XQueryTree (dpy, parent[i - 1], &root, &parent[i], &list, &n);
903	XFree (list);
904
905	if (parent[i] == display->root)
906	{
907	if (oldp != None)
908	pchanged = 1;
909
910	break;
911	}
912
913	if (oldp != parent[i])
914	pchanged = 1;
915	}
916
917	n = 0;
918
919	if (pchanged)
920	for (; n < (unsigned int)i; n++)
921	{
922	XGetWindowAttributes (dpy, parent[n], &wattr);
923
924	if (wattr.depth != rootdepth \|\| wattr.c_class == InputOnly)
925	{
926	n = (int) (sizeof (parent) / sizeof (Window)) + 1;
927	break;
928	}
929	}
930
931	if (n > (sizeof (parent) / sizeof (parent[0])))
932	{
933	XSetWindowBackground (dpy, parent[0], pix_colors_focused[Color_border]);
934	XSetWindowBackground (dpy, vt, pix_colors_focused[Color_bg]);
935	am_transparent = 0;
936	/* XXX: also turn off Opt_transparent? */
937	}
938	else
939	{
940	for (n = 0; n < (unsigned int)i; n++)
941	{
942	XSetWindowBackgroundPixmap (dpy, parent[n], ParentRelative);
943	XClearWindow (dpy, parent[n]);
944	}
945
946	XSetWindowBackgroundPixmap (dpy, vt, ParentRelative);
947	am_transparent = 1;
948	}
949
950	for (; i < (int) (sizeof (parent) / sizeof (Window)); i++)
951	parent[i] = None;
952	}	1168	{
953
954	if (scrollBar.win)	1169	if (scrollBar.win)
955	{	1170	{
956	XSetWindowBackgroundPixmap (dpy, scrollBar.win, ParentRelative);
957	scrollBar.setIdle ();	1171	scrollBar.setIdle ();
958	scrollbar_show (0);	1172	scrollbar_show (0);
959	}	1173	}
960		1174
961	if (am_transparent)	1175	if (am_transparent)
962	{	1176	{
963	want_refresh = want_full_refresh = 1;	1177	want_refresh = want_full_refresh = 1;
964	if (am_pixmap_trans)	1178	if (am_pixmap_trans)
965	flush ();	1179	flush ();
		1180	}
966	}	1181	}
967
968	// return pchanged;
969	}	1182	}
970	#endif	1183	#endif

Diff Legend

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

Comparing rxvt-unicode/src/xpm.C (file contents): Revision 1.56 by sasha, Fri Aug 3 22:40:10 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.56 by sasha, Fri Aug 3 22:40:10 2007 UTC vs.
Revision 1.63 by sasha, Wed Aug 8 22:39:49 2007 UTC