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

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.195 by sf-exg, Mon Jan 2 19:31:00 2012 UTC vs.
Revision 1.209 by sf-exg, Fri May 11 12:21:22 2012 UTC

…		…
3	----------------------------------------------------------------------	3	----------------------------------------------------------------------
4	*	4	*
5	* All portions of code are copyright by their respective author/s.	5	* All portions of code are copyright by their respective author/s.
6	* Copyright (c) 2005-2008 Marc Lehmann <schmorp@schmorp.de>	6	* Copyright (c) 2005-2008 Marc Lehmann <schmorp@schmorp.de>
7	* Copyright (c) 2007 Sasha Vasko <sasha@aftercode.net>	7	* Copyright (c) 2007 Sasha Vasko <sasha@aftercode.net>
8	* Copyright (c) 2010 Emanuele Giaquinta <e.giaquinta@glauco.it>	8	* Copyright (c) 2010-2012 Emanuele Giaquinta <e.giaquinta@glauco.it>
9	*	9	*
10	* This program is free software; you can redistribute it and/or modify	10	* This program is free software; you can redistribute it and/or modify
11	* it under the terms of the GNU General Public License as published by	11	* it under the terms of the GNU General Public License as published by
12	* the Free Software Foundation; either version 2 of the License, or	12	* the Free Software Foundation; either version 2 of the License, or
13	* (at your option) any later version.	13	* (at your option) any later version.
…		…
20	* You should have received a copy of the GNU General Public License	20	* You should have received a copy of the GNU General Public License
21	* along with this program; if not, write to the Free Software	21	* along with this program; if not, write to the Free Software
22	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	22	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23	---------------------------------------------------------------------/	23	---------------------------------------------------------------------/
24		24
25	#include <cmath>	25	#include <math.h>
26	#include "../config.h" /* NECESSARY */	26	#include "../config.h" /* NECESSARY */
27	#include "rxvt.h" /* NECESSARY */	27	#include "rxvt.h" /* NECESSARY */
28		28
29	#if XRENDER	29	#if XRENDER
30	# include <X11/extensions/Xrender.h>	30	# include <X11/extensions/Xrender.h>
…		…
58	# endif	58	# endif
59		59
60	void	60	void
61	rxvt_term::bg_destroy ()	61	rxvt_term::bg_destroy ()
62	{	62	{
63	#ifdef HAVE_AFTERIMAGE
64	if (original_asim)
65	safe_asimage_destroy (original_asim);
66	if (asv)
67	destroy_asvisual (asv, 0);
68	if (asimman)
69	destroy_image_manager (asimman, 0);
70	#endif
71
72	#ifdef HAVE_PIXBUF	63	#ifdef HAVE_PIXBUF
73	if (pixbuf)	64	if (pixbuf)
74	g_object_unref (pixbuf);	65	g_object_unref (pixbuf);
75	#endif	66	#endif
76		67
…		…
129		120
130	return false;	121	return false;
131	}	122	}
132		123
133	# ifdef BG_IMAGE_FROM_FILE	124	# ifdef BG_IMAGE_FROM_FILE
134	static inline bool
135	check_set_scale_value (int geom_flags, int flag, unsigned int &scale, unsigned int new_value)
136	{
137	if (geom_flags & flag)
138	{
139	if (new_value > 1000)
140	new_value = 1000;
141	if (new_value != scale)
142	{
143	scale = new_value;
144	return true;
145	}
146	}
147	return false;
148	}
149
150	static inline bool
151	check_set_align_value (int geom_flags, int flag, int &align, int new_value)
152	{
153	if (geom_flags & flag)
154	{
155	if (new_value < -100)
156	new_value = -100;
157	else if (new_value > 200)
158	new_value = 200;
159	if (new_value != align)
160	{
161	align = new_value;
162	return true;
163	}
164	}
165	return false;
166	}
167
168	static inline int	125	static inline int
169	make_align_position (int align, int window_size, int image_size)	126	make_align_position (int align, int window_size, int image_size)
170	{	127	{
171	int diff = window_size - image_size;
172	int smaller = min (image_size, window_size);
173
174	if (align >= 0 && align <= 100)	128	if (align >= 0 && align <= 100)
175	return diff * align / 100;	129	return lerp (0, window_size - image_size, align);
176	else if (align > 100 && align <= 200)	130	else if (align > 100)
177	return (align - 100) * smaller / 100 + window_size - smaller;	131	return lerp (window_size - image_size, window_size, align - 100);
178	else if (align >= -100 && align < 0)	132	else
179	return (align + 100) * smaller / 100 - image_size;	133	return lerp (-image_size, 0, align + 100);
180	return 0;
181	}	134	}
182		135
183	static inline int	136	static inline int
184	make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)	137	make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)
185	{	138	{
…		…
191	src_pos = -pos;	144	src_pos = -pos;
192	dst_pos = 0;	145	dst_pos = 0;
193	dst_size += pos;	146	dst_size += pos;
194	}	147	}
195		148
196	if (dst_pos + dst_size > target_size)
197	dst_size = target_size - dst_pos;	149	min_it (dst_size, target_size - dst_pos);
198	return src_pos;	150	return src_pos;
199	}	151	}
200		152
201	bool	153	bool
202	rxvt_term::bg_set_geometry (const char *geom, bool update)	154	rxvt_term::bg_set_geometry (const char *geom, bool update)
203	{	155	{
204	bool changed = false;	156	bool changed = false;
205	int geom_flags = 0;	157	int geom_flags = 0;
206	int x = 0, y = 0;	158	int x = h_align;
		159	int y = v_align;
207	unsigned int w = 0, h = 0;	160	unsigned int w = h_scale;
		161	unsigned int h = v_scale;
208	unsigned long new_flags = 0;	162	unsigned long new_flags = 0;
209		163
210	if (geom == NULL)	164	if (geom == NULL)
211	return false;	165	return false;
212		166
…		…
321	w = h = defaultScale;	275	w = h = defaultScale;
322	else if (!(geom_flags & HeightValue))	276	else if (!(geom_flags & HeightValue))
323	h = w;	277	h = w;
324	else if (!(geom_flags & WidthValue))	278	else if (!(geom_flags & WidthValue))
325	w = h;	279	w = h;
326
327	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;
328	}	280	}
329		281
330	if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true;	282	min_it (w, 1000);
331	if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true;	283	min_it (h, 1000);
332	if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true;	284	clamp_it (x, -100, 200);
333	if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true;	285	clamp_it (y, -100, 200);
334		286
335	if (new_flags != bg_flags)	287	if (bg_flags != new_flags
		288	\|\| h_scale != w
		289	\|\| v_scale != h
		290	\|\| h_align != x
		291	\|\| v_align != y)
336	{	292	{
337	bg_flags = new_flags;	293	bg_flags = new_flags;
		294	h_scale = w;
		295	v_scale = h;
		296	h_align = x;
		297	v_align = y;
338	changed = true;	298	changed = true;
339	}	299	}
340		300
341	return changed;	301	return changed;
342	}	302	}
…		…
370	{	330	{
371	x = make_align_position (h_align, target_width, w);	331	x = make_align_position (h_align, target_width, w);
372	y = make_align_position (v_align, target_height, h);	332	y = make_align_position (v_align, target_height, h);
373	}	333	}
374		334
375	bg_flags &= ~BG_IS_SIZE_SENSITIVE;
376	if (!(bg_flags & BG_TILE)	335	if (!(bg_flags & BG_TILE)
377	\|\| h_scale \|\| v_scale	336	\|\| h_scale \|\| v_scale
378	\|\| (!(bg_flags & BG_ROOT_ALIGN) && (h_align \|\| v_align))	337	\|\| (!(bg_flags & BG_ROOT_ALIGN) && (h_align \|\| v_align))
379	\|\| w > target_width \|\| h > target_height)	338	\|\| image_width > target_width \|\| image_height > target_height)
380	bg_flags \|= BG_IS_SIZE_SENSITIVE;	339	bg_flags \|= BG_IS_SIZE_SENSITIVE;
381	}
382
383	# ifdef HAVE_AFTERIMAGE
384	bool
385	rxvt_term::render_image (unsigned long tr_flags)
386	{
387	init_asv ();
388
389	ASImage *background = NULL;
390	ARGB32 background_tint = TINT_LEAVE_SAME;
391
392	# ifdef ENABLE_TRANSPARENCY
393	if (tr_flags)
394	background = pixmap2ximage (asv, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, 100);
395
396	if (tr_flags & BG_NEEDS_TINT)
397	{
398	ShadingInfo as_shade;
399	as_shade.shading = shade;
400
401	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
402	if (bg_flags & BG_TINT_SET)
403	tint.get (c);
404	as_shade.tintColor.red = c.r;
405	as_shade.tintColor.green = c.g;
406	as_shade.tintColor.blue = c.b;
407
408	background_tint = shading2tint32 (&as_shade);
409	}
410
411	if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)
412	{
413	ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,
414	ASA_XImage,
415	100, ASIMAGE_QUALITY_DEFAULT);
416	if (tmp)
417	{
418	destroy_asimage (&background);
419	background = tmp;
420	}
421	}
422	# endif
423
424	ASImage *result = 0;
425
426	int target_width = szHint.width;
427	int target_height = szHint.height;
428	int new_pmap_width = target_width;
429	int new_pmap_height = target_height;
430
431	int x = 0;
432	int y = 0;
433	int w = 0;
434	int h = 0;
435
436	if (original_asim)
437	get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
438
439	if (!original_asim
440	\|\| (!(bg_flags & BG_ROOT_ALIGN)
441	&& (x >= target_width
442	\|\| y >= target_height
443	\|\| x + w <= 0
444	\|\| y + h <= 0)))
445	{
446	if (background)
447	{
448	new_pmap_width = background->width;
449	new_pmap_height = background->height;
450	result = background;
451
452	if (background_tint != TINT_LEAVE_SAME)
453	{
454	ASImage *tmp = tile_asimage (asv, background, 0, 0,
455	target_width, target_height, background_tint,
456	ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
457	if (tmp)
458	result = tmp;
459	}
460	}
461	else
462	new_pmap_width = new_pmap_height = 0;
463	}
464	else	340	else
465	{	341	bg_flags &= ~BG_IS_SIZE_SENSITIVE;
466	result = original_asim;
467
468	if (w != original_asim->width
469	\|\| h != original_asim->height)
470	{
471	result = scale_asimage (asv, original_asim,
472	w, h,
473	ASA_XImage,
474	100, ASIMAGE_QUALITY_DEFAULT);
475	}
476
477	if (background == NULL)
478	{
479	if (bg_flags & BG_TILE)
480	{
481	/* if tiling - pixmap has to be sized exactly as the image,
482	but there is no need to make it bigger than the window! */
483	new_pmap_width = min (result->width, target_width);
484	new_pmap_height = min (result->height, target_height);
485
486	/* we also need to tile our image in both directions */
487	ASImage *tmp = tile_asimage (asv, result,
488	(int)result->width - x,
489	(int)result->height - y,
490	new_pmap_width,
491	new_pmap_height,
492	TINT_LEAVE_SAME, ASA_XImage,
493	100, ASIMAGE_QUALITY_DEFAULT);
494	if (tmp)
495	{
496	if (result != original_asim)
497	destroy_asimage (&result);
498
499	result = tmp;
500	}
501	}
502	}
503	else
504	{
505	/* if blending background and image - pixmap has to be sized same as target window */
506	ASImageLayer *layers = create_image_layers (2);
507
508	layers[0].im = background;
509	layers[0].clip_width = target_width;
510	layers[0].clip_height = target_height;
511	layers[0].tint = background_tint;
512	layers[1].im = result;
513
514	if (bg_flags & BG_TILE)
515	{
516	/* tile horizontally */
517	while (x > 0) x -= (int)result->width;
518	layers[1].dst_x = x;
519	layers[1].clip_width = result->width+target_width;
520	}
521	else
522	{
523	/* clip horizontally */
524	layers[1].dst_x = x;
525	layers[1].clip_width = result->width;
526	}
527
528	if (bg_flags & BG_TILE)
529	{
530	while (y > 0) y -= (int)result->height;
531	layers[1].dst_y = y;
532	layers[1].clip_height = result->height + target_height;
533	}
534	else
535	{
536	layers[1].dst_y = y;
537	layers[1].clip_height = result->height;
538	}
539
540	if (rs[Rs_blendtype])
541	{
542	layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
543	if (layers[1].merge_scanlines == NULL)
544	layers[1].merge_scanlines = alphablend_scanlines;
545	}
546
547	ASImage *tmp = merge_layers (asv, layers, 2, target_width, target_height,
548	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
549
550	if (tmp)
551	{
552	if (result != original_asim)
553	destroy_asimage (&result);
554
555	result = tmp;
556	}
557
558	free (layers);
559	}
560	}
561
562	bool ret = false;
563
564	if (result)
565	{
566	XGCValues gcv;
567	GC gc;
568
569	/* create Pixmap */
570	if (bg_pixmap == None
571	\|\| bg_pmap_width != new_pmap_width
572	\|\| bg_pmap_height != new_pmap_height)
573	{
574	if (bg_pixmap)
575	XFreePixmap (dpy, bg_pixmap);
576	bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
577	bg_pmap_width = new_pmap_width;
578	bg_pmap_height = new_pmap_height;
579	}
580	/* fill with background color (if result's not completely overlapping it) */
581	gcv.foreground = pix_colors[Color_bg];
582	gc = XCreateGC (dpy, vt, GCForeground, &gcv);
583
584	int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
585	int dst_width = result->width, dst_height = result->height;
586	if (background == NULL)
587	{
588	if (!(bg_flags & BG_TILE))
589	{
590	src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );
591	src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
592	}
593
594	if (dst_x > 0 \|\| dst_y > 0
595	\|\| dst_x + dst_width < new_pmap_width
596	\|\| dst_y + dst_height < new_pmap_height)
597	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
598	}
599
600	/* put result on pixmap */
601	if (dst_x < new_pmap_width && dst_y < new_pmap_height)
602	asimage2drawable (asv, bg_pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);
603
604	if (result != background && result != original_asim)
605	destroy_asimage (&result);
606
607	XFreeGC (dpy, gc);
608
609	ret = true;
610	}
611
612	if (background)
613	destroy_asimage (&background);
614
615	return ret;
616	}	342	}
617	# endif /* HAVE_AFTERIMAGE */
618		343
619	# ifdef HAVE_PIXBUF	344	# ifdef HAVE_PIXBUF
620	bool	345	bool
621	rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,	346	rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
622	int src_x, int src_y, int dst_x, int dst_y,	347	int src_x, int src_y, int dst_x, int dst_y,
623	unsigned int width, unsigned int height)	348	unsigned int width, unsigned int height)
624	{	349	{
625	XImage *ximage;	350	XImage *ximage;
626	char data, line;	351	char data, line;
627	int bytes_per_pixel;	352	int bytes_per_pixel;
628	int width_r, width_g, width_b;	353	int width_r, width_g, width_b, width_a;
629	int sh_r, sh_g, sh_b;	354	int sh_r, sh_g, sh_b, sh_a;
		355	uint32_t alpha_mask;
630	int rowstride;	356	int rowstride;
631	int channels;	357	int channels;
632	unsigned char *row;	358	unsigned char *row;
633		359
634	if (visual->c_class != TrueColor)	360	if (visual->c_class != TrueColor)
635	return false;	361	return false;
		362
		363	#if XRENDER
		364	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
		365	if (format)
		366	alpha_mask = (uint32_t)format->direct.alphaMask << format->direct.alpha;
		367	else
		368	#endif
		369	alpha_mask = 0;
636		370
637	if (depth == 24 \|\| depth == 32)	371	if (depth == 24 \|\| depth == 32)
638	bytes_per_pixel = 4;	372	bytes_per_pixel = 4;
639	else if (depth == 15 \|\| depth == 16)	373	else if (depth == 15 \|\| depth == 16)
640	bytes_per_pixel = 2;	374	bytes_per_pixel = 2;
…		…
642	return false;	376	return false;
643		377
644	width_r = ecb_popcount32 (visual->red_mask);	378	width_r = ecb_popcount32 (visual->red_mask);
645	width_g = ecb_popcount32 (visual->green_mask);	379	width_g = ecb_popcount32 (visual->green_mask);
646	width_b = ecb_popcount32 (visual->blue_mask);	380	width_b = ecb_popcount32 (visual->blue_mask);
		381	width_a = ecb_popcount32 (alpha_mask);
647		382
648	if (width_r > 8 \|\| width_g > 8 \|\| width_b > 8)	383	if (width_r > 8 \|\| width_g > 8 \|\| width_b > 8 \|\| width_a > 8)
649	return false;	384	return false;
650		385
651	sh_r = ecb_ctz32 (visual->red_mask);	386	sh_r = ecb_ctz32 (visual->red_mask);
652	sh_g = ecb_ctz32 (visual->green_mask);	387	sh_g = ecb_ctz32 (visual->green_mask);
653	sh_b = ecb_ctz32 (visual->blue_mask);	388	sh_b = ecb_ctz32 (visual->blue_mask);
		389	sh_a = ecb_ctz32 (alpha_mask);
654		390
655	if (width > INT_MAX / height / bytes_per_pixel)	391	if (width > INT_MAX / height / bytes_per_pixel)
656	return false;	392	return false;
657		393
658	data = (char )malloc (width height * bytes_per_pixel);	394	data = (char )malloc (width height * bytes_per_pixel);
…		…
672	rowstride = gdk_pixbuf_get_rowstride (pixbuf);	408	rowstride = gdk_pixbuf_get_rowstride (pixbuf);
673	channels = gdk_pixbuf_get_n_channels (pixbuf);	409	channels = gdk_pixbuf_get_n_channels (pixbuf);
674	row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels;	410	row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels;
675	line = data;	411	line = data;
676		412
		413	rgba c (0, 0, 0);
		414
		415	if (channels == 4 && alpha_mask == 0)
		416	{
		417	pix_colors[Color_bg].get (c);
		418	c.r >>= 8;
		419	c.g >>= 8;
		420	c.b >>= 8;
		421	}
		422
677	for (int y = 0; y < height; y++)	423	for (int y = 0; y < height; y++)
678	{	424	{
679	for (int x = 0; x < width; x++)	425	for (int x = 0; x < width; x++)
680	{	426	{
681	unsigned char pixel = row + x channels;	427	unsigned char pixel = row + x channels;
682	uint32_t value;	428	uint32_t value;
		429	unsigned char r, g, b, a;
683		430
		431	if (channels == 4)
		432	{
		433	a = pixel[3];
		434	r = (pixel[0] * a + c.r * (0xff - a)) / 0xff;
		435	g = (pixel[1] * a + c.g * (0xff - a)) / 0xff;
		436	b = (pixel[2] * a + c.b * (0xff - a)) / 0xff;
		437	}
		438	else
		439	{
		440	a = 0xff;
		441	r = pixel[0];
		442	g = pixel[1];
		443	b = pixel[2];
		444	}
		445
684	value = ((pixel[0] >> (8 - width_r)) << sh_r)	446	value = ((r >> (8 - width_r)) << sh_r)
685	\| ((pixel[1] >> (8 - width_g)) << sh_g)	447	\| ((g >> (8 - width_g)) << sh_g)
686	\| ((pixel[2] >> (8 - width_b)) << sh_b);	448	\| ((b >> (8 - width_b)) << sh_b)
		449	\| ((a >> (8 - width_a)) << sh_a);
687		450
688	if (bytes_per_pixel == 4)	451	if (bytes_per_pixel == 4)
689	((uint32_t *)line)[x] = value;	452	((uint32_t *)line)[x] = value;
690	else	453	else
691	((uint16_t *)line)[x] = value;	454	((uint16_t *)line)[x] = value;
…		…
699	XDestroyImage (ximage);	462	XDestroyImage (ximage);
700	return true;	463	return true;
701	}	464	}
702		465
703	bool	466	bool
704	rxvt_term::render_image (unsigned long tr_flags)	467	rxvt_term::render_image (bool transparent)
705	{	468	{
706	if (!pixbuf)	469	if (!pixbuf)
707	return false;	470	return false;
708		471
709	if (tr_flags	472	if (transparent
710	&& !(bg_flags & BG_HAS_RENDER))	473	&& !(bg_flags & BG_HAS_RENDER))
711	return false;	474	return false;
712		475
713	GdkPixbuf *result;	476	GdkPixbuf *result;
714		477
…		…
754	Pixmap root_pmap;	517	Pixmap root_pmap;
755		518
756	image_width = gdk_pixbuf_get_width (result);	519	image_width = gdk_pixbuf_get_width (result);
757	image_height = gdk_pixbuf_get_height (result);	520	image_height = gdk_pixbuf_get_height (result);
758		521
759	if (tr_flags)	522	if (transparent)
760	{	523	{
761	root_pmap = bg_pixmap;	524	root_pmap = bg_pixmap;
762	bg_pixmap = None;	525	bg_pixmap = None;
763	}	526	}
764	else	527	else
…		…
822	dst_x, dst_y,	585	dst_x, dst_y,
823	dst_width, dst_height);	586	dst_width, dst_height);
824	}	587	}
825		588
826	#if XRENDER	589	#if XRENDER
827	if (tr_flags)	590	if (transparent)
828	{	591	{
829	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	592	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
830		593
831	Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);	594	Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
832		595
…		…
856	}	619	}
857		620
858	if (result != pixbuf)	621	if (result != pixbuf)
859	g_object_unref (result);	622	g_object_unref (result);
860		623
861	if (tr_flags)	624	if (transparent)
862	XFreePixmap (dpy, root_pmap);	625	XFreePixmap (dpy, root_pmap);
863		626
864	return ret;	627	return ret;
865	}	628	}
866	# endif /* HAVE_PIXBUF */	629	# endif /* HAVE_PIXBUF */
…		…
881	memcpy (f, file, len);	644	memcpy (f, file, len);
882	f[len] = '\0';	645	f[len] = '\0';
883	file = f;	646	file = f;
884	}	647	}
885		648
886	# ifdef HAVE_AFTERIMAGE
887	if (!asimman)
888	asimman = create_generic_imageman (rs[Rs_path]);
889	ASImage *image = get_asimage (asimman, file, 0xFFFFFFFF, 100);
890	if (image)
891	{
892	if (original_asim)
893	safe_asimage_destroy (original_asim);
894	original_asim = image;
895	bg_flags \|= BG_IS_FROM_FILE \| BG_CLIENT_RENDER;
896	ret = true;
897	}
898	# endif
899
900	# ifdef HAVE_PIXBUF	649	# ifdef HAVE_PIXBUF
901	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);	650	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
902	if (image)	651	if (image)
903	{	652	{
904	if (pixbuf)	653	if (pixbuf)
…		…
961	{	710	{
962	changed = true;	711	changed = true;
963	v_blurRadius = vr;	712	v_blurRadius = vr;
964	}	713	}
965		714
966	if (h_blurRadius == 0 \|\| v_blurRadius == 0)	715	if (h_blurRadius && v_blurRadius)
		716	bg_flags \|= BG_NEEDS_BLUR;
		717	else
967	bg_flags &= ~BG_NEEDS_BLUR;	718	bg_flags &= ~BG_NEEDS_BLUR;
968	else
969	bg_flags \|= BG_NEEDS_BLUR;
970		719
971	return changed;	720	return changed;
972	}	721	}
973		722
974	void	723	void
975	rxvt_term::set_tint_shade_flags ()	724	rxvt_term::set_tint_shade_flags ()
976	{	725	{
		726	if (shade != 100 \|\| (bg_flags & BG_TINT_SET))
		727	bg_flags \|= BG_NEEDS_TINT;
		728	else
		729	bg_flags &= ~BG_NEEDS_TINT;
		730	}
		731
		732	bool
		733	rxvt_term::bg_set_tint (rxvt_color &new_tint)
		734	{
		735	if (!(bg_flags & BG_TINT_SET) \|\| tint != new_tint)
		736	{
		737	tint = new_tint;
		738	bg_flags \|= BG_TINT_SET;
		739
977	rgba c;	740	rgba c;
978	bool has_shade = shade != 100;
979
980	bg_flags &= ~BG_TINT_FLAGS;
981
982	if (bg_flags & BG_TINT_SET)
983	{
984	tint.get (c);	741	tint.get (c);
985	if (!has_shade
986	&& (c.r <= 0x00ff \|\| c.r >= 0xff00)	742	if ((c.r <= 0x00ff \|\| c.r >= 0xff00)
987	&& (c.g <= 0x00ff \|\| c.g >= 0xff00)	743	&& (c.g <= 0x00ff \|\| c.g >= 0xff00)
988	&& (c.b <= 0x00ff \|\| c.b >= 0xff00))	744	&& (c.b <= 0x00ff \|\| c.b >= 0xff00))
989	bg_flags \|= BG_TINT_BITAND;	745	bg_flags \|= BG_TINT_BITAND;
990	}	746	else
991
992	if (has_shade \|\| (bg_flags & BG_TINT_SET))
993	bg_flags \|= BG_NEEDS_TINT;
994	}
995
996	bool
997	rxvt_term::bg_set_tint (rxvt_color &new_tint)
998	{
999	if (!(bg_flags & BG_TINT_SET) \|\| tint != new_tint)
1000	{
1001	tint = new_tint;
1002	bg_flags \|= BG_TINT_SET;	747	bg_flags &= ~BG_TINT_BITAND;
		748
1003	set_tint_shade_flags ();	749	set_tint_shade_flags ();
1004	return true;	750	return true;
1005	}	751	}
1006		752
1007	return false;	753	return false;
…		…
1048	params[i+2] = XDoubleToFixed (kernel[i] / sum);	794	params[i+2] = XDoubleToFixed (kernel[i] / sum);
1049	}	795	}
1050	#endif	796	#endif
1051		797
1052	bool	798	bool
1053	rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	799	rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height, int depth)
1054	{	800	{
1055	bool ret = false;	801	bool ret = false;
1056	#if XRENDER	802	#if XRENDER
1057	if (!(bg_flags & BG_HAS_RENDER_CONV))	803	if (!(bg_flags & BG_HAS_RENDER_CONV))
1058	return false;	804	return false;
…		…
1064	XRenderPictureAttributes pa;	810	XRenderPictureAttributes pa;
1065	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	811	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1066		812
1067	pa.repeat = RepeatPad;	813	pa.repeat = RepeatPad;
1068	Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);	814	Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
		815	Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1069	Picture dst = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);	816	Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
		817	XFreePixmap (dpy, tmp);
1070		818
1071	if (kernel && params)	819	if (kernel && params)
1072	{	820	{
1073	size = h_blurRadius * 2 + 1;	821	size = h_blurRadius * 2 + 1;
1074	get_gaussian_kernel (h_blurRadius, size, kernel, params);	822	get_gaussian_kernel (h_blurRadius, size, kernel, params);
…		…
1082	0, 0,	830	0, 0,
1083	0, 0,	831	0, 0,
1084	0, 0,	832	0, 0,
1085	width, height);	833	width, height);
1086		834
		835	::swap (src, dst);
		836
1087	size = v_blurRadius * 2 + 1;	837	size = v_blurRadius * 2 + 1;
1088	get_gaussian_kernel (v_blurRadius, size, kernel, params);	838	get_gaussian_kernel (v_blurRadius, size, kernel, params);
1089	::swap (params[0], params[1]);	839	::swap (params[0], params[1]);
1090		840
1091	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	841	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
…		…
1113	bool	863	bool
1114	rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	864	rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1115	{	865	{
1116	bool ret = false;	866	bool ret = false;
1117		867
1118	if (bg_flags & BG_TINT_BITAND)	868	if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1119	{	869	{
1120	XGCValues gcv;	870	XGCValues gcv;
1121	GC gc;	871	GC gc;
1122		872
1123	/* In this case we can tint image server-side getting significant	873	/* In this case we can tint image server-side getting significant
…		…
1204	/*	954	/*
1205	* Builds a pixmap of the same size as the terminal window that contains	955	* Builds a pixmap of the same size as the terminal window that contains
1206	* the tiled portion of the root pixmap that is supposed to be covered by	956	* the tiled portion of the root pixmap that is supposed to be covered by
1207	* our window.	957	* our window.
1208	*/	958	*/
1209	unsigned long	959	bool
1210	rxvt_term::make_transparency_pixmap ()	960	rxvt_term::make_transparency_pixmap ()
1211	{	961	{
1212	unsigned long result = 0;	962	bool ret = false;
1213		963
1214	/* root dimensions may change from call to call - but Display structure should	964	/* root dimensions may change from call to call - but Display structure should
1215	* be always up-to-date, so let's use it :	965	* be always up-to-date, so let's use it :
1216	*/	966	*/
1217	int screen = display->screen;	967	int screen = display->screen;
…		…
1298	gc = XCreateGC (dpy, vt, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcv);	1048	gc = XCreateGC (dpy, vt, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcv);
1299		1049
1300	if (gc)	1050	if (gc)
1301	{	1051	{
1302	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);	1052	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1303	result \|= BG_IS_VALID \| (bg_flags & BG_EFFECTS_FLAGS);	1053	ret = true;
		1054	unsigned long tr_flags = bg_flags & BG_EFFECTS_FLAGS;
1304		1055
1305	if (!(bg_flags & BG_CLIENT_RENDER))	1056	if (!(bg_flags & BG_CLIENT_RENDER))
1306	{	1057	{
1307	if (bg_flags & BG_NEEDS_BLUR)	1058	if (bg_flags & BG_NEEDS_BLUR)
1308	{	1059	{
1309	if (blur_pixmap (bg_pixmap, visual, window_width, window_height))	1060	if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth))
1310	result &= ~BG_NEEDS_BLUR;	1061	tr_flags &= ~BG_NEEDS_BLUR;
1311	}	1062	}
1312	if (bg_flags & BG_NEEDS_TINT)	1063	if (bg_flags & BG_NEEDS_TINT)
1313	{	1064	{
1314	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))	1065	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1315	result &= ~BG_NEEDS_TINT;	1066	tr_flags &= ~BG_NEEDS_TINT;
1316	}	1067	}
1317	# ifndef HAVE_AFTERIMAGE
1318	if (result & BG_NEEDS_TINT)	1068	if (tr_flags & BG_NEEDS_TINT)
1319	{	1069	{
1320	XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);	1070	XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1321	if (ximage)	1071	if (ximage)
1322	{	1072	{
1323	/* our own client-side tinting */	1073	/* our own client-side tinting */
…		…
1325		1075
1326	XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);	1076	XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
1327	XDestroyImage (ximage);	1077	XDestroyImage (ximage);
1328	}	1078	}
1329	}	1079	}
1330	# endif
1331	} /* server side rendering completed */	1080	} /* server side rendering completed */
1332		1081
1333	XFreeGC (dpy, gc);	1082	XFreeGC (dpy, gc);
1334	}	1083	}
1335		1084
1336	if (recoded_root_pmap != root_pixmap)	1085	if (recoded_root_pmap != root_pixmap)
1337	XFreePixmap (dpy, recoded_root_pmap);	1086	XFreePixmap (dpy, recoded_root_pmap);
1338		1087
1339	return result;	1088	return ret;
1340	}	1089	}
1341		1090
1342	void	1091	void
1343	rxvt_term::bg_set_root_pixmap ()	1092	rxvt_term::bg_set_root_pixmap ()
1344	{	1093	{
…		…
1351	# endif /* ENABLE_TRANSPARENCY */	1100	# endif /* ENABLE_TRANSPARENCY */
1352		1101
1353	bool	1102	bool
1354	rxvt_term::bg_render ()	1103	rxvt_term::bg_render ()
1355	{	1104	{
1356	unsigned long tr_flags = 0;	1105	bool transparent = false;
1357		1106
1358	bg_invalidate ();	1107	bg_invalidate ();
1359	# ifdef ENABLE_TRANSPARENCY	1108	# ifdef ENABLE_TRANSPARENCY
1360	if (bg_flags & BG_IS_TRANSPARENT)	1109	if (bg_flags & BG_IS_TRANSPARENT)
1361	{	1110	{
1362	/* we need to re-generate transparency pixmap in that case ! */	1111	/* we need to re-generate transparency pixmap in that case ! */
1363	tr_flags = make_transparency_pixmap ();	1112	transparent = make_transparency_pixmap ();
1364	if (tr_flags == 0)	1113	if (transparent)
1365	return false;
1366	bg_flags \|= BG_IS_VALID;	1114	bg_flags \|= BG_IS_VALID;
1367	}	1115	}
1368	# endif	1116	# endif
1369		1117
1370	# ifdef BG_IMAGE_FROM_FILE	1118	# ifdef BG_IMAGE_FROM_FILE
1371	if ((bg_flags & BG_IS_FROM_FILE)	1119	if (bg_flags & BG_IS_FROM_FILE)
1372	\|\| (tr_flags & BG_EFFECTS_FLAGS))
1373	{	1120	{
1374	if (render_image (tr_flags))	1121	if (render_image (transparent))
1375	bg_flags \|= BG_IS_VALID;	1122	bg_flags \|= BG_IS_VALID;
1376	}	1123	}
1377	# endif	1124	# endif
1378		1125
1379	if (!(bg_flags & BG_IS_VALID))	1126	if (!(bg_flags & BG_IS_VALID))
…		…
1417	#endif	1164	#endif
1418	}	1165	}
1419		1166
1420	#endif /* HAVE_BG_PIXMAP */	1167	#endif /* HAVE_BG_PIXMAP */
1421		1168
1422	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)	1169	#ifdef ENABLE_TRANSPARENCY
1423	/* based on code from aterm-0.4.2 */	1170	/* based on code from aterm-0.4.2 */
1424		1171
1425	static inline void	1172	static inline void
1426	fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)	1173	fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
1427	{	1174	{
…		…
1435	}	1182	}
1436		1183
1437	void	1184	void
1438	rxvt_term::tint_ximage (Visual visual, XImage ximage)	1185	rxvt_term::tint_ximage (Visual visual, XImage ximage)
1439	{	1186	{
		1187	unsigned int size_r, size_g, size_b;
1440	int sh_r, sh_g, sh_b;	1188	int sh_r, sh_g, sh_b;
1441	uint32_t mask_r, mask_g, mask_b;	1189	uint32_t mask_r, mask_g, mask_b;
1442	uint32_t lookup, lookup_r, lookup_g, lookup_b;	1190	uint32_t lookup, lookup_r, lookup_g, lookup_b;
1443	unsigned short low;	1191	unsigned short low;
1444	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;	1192	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
…		…
1449	mask_r = visual->red_mask;	1197	mask_r = visual->red_mask;
1450	mask_g = visual->green_mask;	1198	mask_g = visual->green_mask;
1451	mask_b = visual->blue_mask;	1199	mask_b = visual->blue_mask;
1452		1200
1453	/* boring lookup table pre-initialization */	1201	/* boring lookup table pre-initialization */
1454	switch (ximage->depth)	1202	sh_r = ecb_ctz32 (mask_r);
1455	{	1203	sh_g = ecb_ctz32 (mask_g);
1456	case 15:	1204	sh_b = ecb_ctz32 (mask_b);
1457	if ((mask_r != 0x7c00) \|\|	1205
1458	(mask_g != 0x03e0) \|\|	1206	size_r = mask_r >> sh_r;
1459	(mask_b != 0x001f))	1207	size_g = mask_g >> sh_g;
		1208	size_b = mask_b >> sh_b;
		1209
		1210	if (size_r++ > 255 \|\| size_g++ > 255 \|\| size_b++ > 255)
1460	return;	1211	return;
1461	lookup = (uint32_t ) malloc (sizeof (uint32_t)(32+32+32));	1212
		1213	lookup = (uint32_t )malloc (sizeof (uint32_t) (size_r + size_g + size_b));
1462	lookup_r = lookup;	1214	lookup_r = lookup;
1463	lookup_g = lookup+32;	1215	lookup_g = lookup + size_r;
1464	lookup_b = lookup+32+32;	1216	lookup_b = lookup + size_r + size_g;
1465	sh_r = 10;
1466	sh_g = 5;
1467	sh_b = 0;
1468	break;
1469	case 16:
1470	if ((mask_r != 0xf800) \|\|
1471	(mask_g != 0x07e0) \|\|
1472	(mask_b != 0x001f))
1473	return;
1474	lookup = (uint32_t ) malloc (sizeof (uint32_t)(32+64+32));
1475	lookup_r = lookup;
1476	lookup_g = lookup+32;
1477	lookup_b = lookup+32+64;
1478	sh_r = 11;
1479	sh_g = 5;
1480	sh_b = 0;
1481	break;
1482	case 24:
1483	if ((mask_r != 0xff0000) \|\|
1484	(mask_g != 0x00ff00) \|\|
1485	(mask_b != 0x0000ff))
1486	return;
1487	lookup = (uint32_t ) malloc (sizeof (uint32_t)(256+256+256));
1488	lookup_r = lookup;
1489	lookup_g = lookup+256;
1490	lookup_b = lookup+256+256;
1491	sh_r = 16;
1492	sh_g = 8;
1493	sh_b = 0;
1494	break;
1495	case 32:
1496	if ((mask_r != 0xff0000) \|\|
1497	(mask_g != 0x00ff00) \|\|
1498	(mask_b != 0x0000ff))
1499	return;
1500	lookup = (uint32_t ) malloc (sizeof (uint32_t)(256+256+256));
1501	lookup_r = lookup;
1502	lookup_g = lookup+256;
1503	lookup_b = lookup+256+256;
1504	sh_r = 16;
1505	sh_g = 8;
1506	sh_b = 0;
1507	break;
1508	default:
1509	return; /* we do not support this color depth */
1510	}
1511		1217
1512	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);	1218	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1513		1219
1514	if (bg_flags & BG_TINT_SET)	1220	if (bg_flags & BG_TINT_SET)
1515	tint.get (c);	1221	tint.get (c);
…		…
1537	fill_lut (lookup_g, mask_g, sh_g, low, c.g);	1243	fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1538	fill_lut (lookup_b, mask_b, sh_b, low, c.b);	1244	fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1539		1245
1540	/* apply table to input image (replacing colors by newly calculated ones) */	1246	/* apply table to input image (replacing colors by newly calculated ones) */
1541	if (ximage->bits_per_pixel == 32	1247	if (ximage->bits_per_pixel == 32
1542	&& (ximage->depth == 24 \|\| ximage->depth == 32)
1543	&& ximage->byte_order == host_byte_order)	1248	&& ximage->byte_order == host_byte_order)
1544	{	1249	{
1545	uint32_t p1, pf, p, pl;	1250	char *line = ximage->data;
1546	p1 = (uint32_t *) ximage->data;
1547	pf = (uint32_t ) (ximage->data + ximage->height ximage->bytes_per_line);
1548		1251
1549	while (p1 < pf)	1252	for (int y = 0; y < ximage->height; y++)
1550	{
1551	p = p1;
1552	pl = p1 + ximage->width;
1553	for (; p < pl; p++)
1554	{	1253	{
1555	p = lookup_r[(p & 0xff0000) >> 16] \|	1254	uint32_t p = (uint32_t )line;
1556	lookup_g[(*p & 0x00ff00) >> 8] \|	1255	for (int x = 0; x < ximage->width; x++)
1557	lookup_b[(*p & 0x0000ff)] \|
1558	(*p & 0xff000000);
1559	}	1256	{
1560	p1 = (uint32_t ) ((char ) p1 + ximage->bytes_per_line);	1257	p = lookup_r[(p & mask_r) >> sh_r] \|
		1258	lookup_g[(*p & mask_g) >> sh_g] \|
		1259	lookup_b[(*p & mask_b) >> sh_b];
		1260	p++;
		1261	}
		1262	line += ximage->bytes_per_line;
1561	}	1263	}
1562	}	1264	}
1563	else	1265	else
1564	{	1266	{
1565	for (int y = 0; y < ximage->height; y++)	1267	for (int y = 0; y < ximage->height; y++)
…		…
1573	}	1275	}
1574	}	1276	}
1575		1277
1576	free (lookup);	1278	free (lookup);
1577	}	1279	}
1578	#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */	1280	#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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

Comparing rxvt-unicode/src/background.C (file contents): Revision 1.195 by sf-exg, Mon Jan 2 19:31:00 2012 UTC vs. Revision 1.209 by sf-exg, Fri May 11 12:21:22 2012 UTC

Diff Legend

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.195 by sf-exg, Mon Jan 2 19:31:00 2012 UTC vs.
Revision 1.209 by sf-exg, Fri May 11 12:21:22 2012 UTC