ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/rxvt-unicode/src/rxvtimg.C
(Generate patch)

Comparing rxvt-unicode/src/rxvtimg.C (file contents):
Revision 1.9 by root, Sun Jun 3 20:47:00 2012 UTC vs.
Revision 1.48 by root, Thu Jun 7 19:24:02 2012 UTC

… …
2#include "../config.h" 2#include "../config.h"
3#include "rxvt.h" 3#include "rxvt.h"
4 4
5#if HAVE_IMG 5#if HAVE_IMG
6 6
7#define float_to_component(d) ((d) * 65535.99)
8
9rxvt_img::rxvt_img (rxvt_screen *screen, XRenderPictFormat *format, int width, int height) 7rxvt_img::rxvt_img (rxvt_screen *screen, XRenderPictFormat *format, int x, int y, int width, int height, int repeat)
10: s(screen), w(width), h(height), format(format), shared(false) 8: s(screen), x(x), y(y), w(width), h(height), format(format), repeat(repeat),
9 pm(0), ref(0)
11{ 10{
12 pm = XCreatePixmap (s->display->dpy, s->display->root, w, h, format->depth);
13} 11}
14 12
13rxvt_img::rxvt_img (const rxvt_img &img)
14: s(img.s), x(img.x), y(img.y), w(img.w), h(img.h), format(img.format), repeat(img.repeat), pm(img.pm), ref(img.ref)
15{
16 ++ref->cnt;
17}
18
19#if 0
15rxvt_img::rxvt_img (rxvt_screen *screen, XRenderPictFormat *format, int width, int height, Pixmap pixmap) 20rxvt_img::rxvt_img (rxvt_screen *screen, XRenderPictFormat *format, int width, int height, Pixmap pixmap)
16: s(screen), pm(pixmap), w(width), h(height), format(format), shared(false) 21: s(screen), x(0), y(0), w(width), h(height), format(format), repeat(RepeatNormal), shared(false), pm(pixmap)
17{ 22{
18} 23}
24#endif
19 25
20rxvt_img * 26rxvt_img *
21rxvt_img::new_from_file (rxvt_screen *s, const char *filename) 27rxvt_img::new_from_root (rxvt_screen *s)
22{ 28{
23 GError *err; 29 Display *dpy = s->display->dpy;
24 GdkPixbuf *pb = gdk_pixbuf_new_from_file (filename, &err); 30 unsigned int root_pm_w, root_pm_h;
31 Pixmap root_pixmap = s->display->get_pixmap_property (s->display->xa[XA_XROOTPMAP_ID]);
32 if (root_pixmap == None)
33 root_pixmap = s->display->get_pixmap_property (s->display->xa[XA_ESETROOT_PMAP_ID]);
25 34
26 if (!pb) 35 if (root_pixmap == None)
36 return 0;
37
38 Window wdummy;
39 int idummy;
40 unsigned int udummy;
41
42 if (!XGetGeometry (dpy, root_pixmap, &wdummy, &idummy, &idummy, &root_pm_w, &root_pm_h, &udummy, &udummy))
27 return 0; 43 return 0;
28 44
29 rxvt_img *img = new rxvt_img ( 45 rxvt_img *img = new rxvt_img (
30 s, 46 s,
31 XRenderFindStandardFormat (s->display->dpy, gdk_pixbuf_get_has_alpha (pb) ? PictStandardARGB32 : PictStandardRGB24), 47 XRenderFindVisualFormat (dpy, DefaultVisual (dpy, s->display->screen)),
32 gdk_pixbuf_get_width (pb), 48 0,
33 gdk_pixbuf_get_height (pb) 49 0,
50 root_pm_w,
51 root_pm_h
34 ); 52 );
35 53
36 img->render (pb, 0, 0, img->w, img->h, 0, 0); 54 img->pm = root_pixmap;
55 img->ref = new pixref (root_pm_w, root_pm_h);
56 img->ref->ours = false;
37 57
58 return img;
59}
60
61rxvt_img *
62rxvt_img::new_from_pixbuf (rxvt_screen *s, GdkPixbuf *pb)
63{
64 Display *dpy = s->display->dpy;
65
66 int width = gdk_pixbuf_get_width (pb);
67 int height = gdk_pixbuf_get_height (pb);
68
69 if (width > 32767 || height > 32767) // well, we *could* upload in chunks
70 rxvt_fatal ("rxvt_img::new_from_pixbuf: image too big (maximum size 32768x32768).\n");
71
72 // since we require rgb24/argb32 formats from xrender we assume
73 // that both 24 and 32 bpp MUST be supported by any screen that supports xrender
74 int depth = gdk_pixbuf_get_has_alpha (pb) ? 32 : 24;
75
76 XImage xi;
77
78 xi.width = width;
79 xi.height = height;
80 xi.xoffset = 0;
81 xi.format = ZPixmap;
82 xi.byte_order = MSBFirst; // maybe go for host byte order, because servers are usually local?
83 xi.bitmap_unit = 32;
84 xi.bitmap_bit_order = MSBFirst;
85 xi.bitmap_pad = BitmapPad (dpy);
86 xi.depth = depth;
87 xi.bytes_per_line = 0;
88 xi.bits_per_pixel = 32;
89 xi.red_mask = 0x00ff0000;
90 xi.green_mask = 0x0000ff00;
91 xi.blue_mask = 0x000000ff;
92
93 if (!XInitImage (&xi))
94 rxvt_fatal ("unable to initialise ximage, please report.\n");
95
96 if (height > INT_MAX / xi.bytes_per_line)
97 rxvt_fatal ("rxvt_img::new_from_pixbuf: image too big for Xlib.\n");
98
99 xi.data = (char *)rxvt_malloc (height * xi.bytes_per_line);
100
101 int rowstride = gdk_pixbuf_get_rowstride (pb);
102
103 assert (3 + (depth == 32) == gdk_pixbuf_get_n_channels (pb));
104 unsigned char *row = gdk_pixbuf_get_pixels (pb);
105 char *line = xi.data;
106
107 for (int y = 0; y < height; y++)
108 {
109 unsigned char r, g, b, a;
110 unsigned char *data = row;
111
112 if (depth == 24)
113 for (int x = 0; x < width; x++)
114 {
115 asm volatile("nop");
116 r = *data++;
117 g = *data++;
118 b = *data++;
119 *line++ = 0;
120 *line++ = r;
121 *line++ = g;
122 *line++ = b;
123 asm volatile("nop");
124 }
125 else
126 for (int x = 0; x < width; x++)
127 {
128 uint32_t v = *(uint32_t *)data; data += 4;
129 v = ecb_big_endian () ? ecb_rotr32 (v, 8) : ecb_rotl32 (v, 8);
130 *(uint32_t *)line = x; line += 4;
131 }
132
133 row += rowstride;
134 }
135
136 rxvt_img *img = new rxvt_img (s, XRenderFindStandardFormat (dpy, depth == 24 ? PictStandardRGB24 : PictStandardARGB32), 0, 0, width, height);
137 img->alloc ();
138
139 GC gc = XCreateGC (dpy, img->pm, 0, 0);
140 XPutImage (dpy, img->pm, gc, &xi, 0, 0, 0, 0, width, height);
141 XFreeGC (dpy, gc);
142
143 free (xi.data);
144
145 return img;
146}
147
148rxvt_img *
149rxvt_img::new_from_file (rxvt_screen *s, const char *filename)
150{
151 GError *err = 0;
152 GdkPixbuf *pb = gdk_pixbuf_new_from_file (filename, &err);
153
154 if (!pb)
155 rxvt_fatal ("rxvt_img::new_from_file: %s\n", err->message);
156
157 rxvt_img *img = new_from_pixbuf (s, pb);
158
159 g_object_unref (pb);
160
161 return img;
162}
163
164void
165rxvt_img::destroy ()
166{
167 if (--ref->cnt)
38 return img; 168 return;
169
170 if (pm && ref->ours)
171 XFreePixmap (s->display->dpy, pm);
172
173 delete ref;
39} 174}
40 175
41rxvt_img::~rxvt_img () 176rxvt_img::~rxvt_img ()
42{ 177{
43 if (!shared) 178 destroy ();
179}
180
181void
182rxvt_img::alloc ()
183{
184 pm = XCreatePixmap (s->display->dpy, s->display->root, w, h, format->depth);
185 ref = new pixref (w, h);
186}
187
188Picture
189rxvt_img::src_picture ()
190{
191 Display *dpy = s->display->dpy;
192
193 XRenderPictureAttributes pa;
194 pa.repeat = repeat;
195 Picture pic = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);
196
197 return pic;
198}
199
200void
201rxvt_img::unshare ()
202{
203 if (ref->cnt == 1 && ref->ours)
204 return;
205
206 //TODO: maybe should reify instead
207 Pixmap pm2 = XCreatePixmap (s->display->dpy, s->display->root, ref->w, ref->h, format->depth);
208 GC gc = XCreateGC (s->display->dpy, pm, 0, 0);
209 XCopyArea (s->display->dpy, pm, pm2, gc, 0, 0, ref->w, ref->h, 0, 0);
44 XFreePixmap (s->display->dpy, pm); 210 XFreeGC (s->display->dpy, gc);
211
212 destroy ();
213
214 pm = pm2;
215 ref = new pixref (ref->w, ref->h);
45} 216}
46 217
47void 218void
48rxvt_img::fill (const rxvt_color &c) 219rxvt_img::fill (const rxvt_color &c)
49{ 220{
… …
73 244
74 for (int i = 0; i < width; i++) 245 for (int i = 0; i < width; i++)
75 params[i+2] = XDoubleToFixed (kernel[i] / sum); 246 params[i+2] = XDoubleToFixed (kernel[i] / sum);
76} 247}
77 248
78void 249rxvt_img *
79rxvt_img::blur (int rh, int rv) 250rxvt_img::blur (int rh, int rv)
80{ 251{
81 if (!(s->display->flags & DISPLAY_HAS_RENDER_CONV)) 252 if (!(s->display->flags & DISPLAY_HAS_RENDER_CONV))
82 return; 253 return clone ();
83 254
84 Display *dpy = s->display->dpy; 255 Display *dpy = s->display->dpy;
85 int size = max (rh, rv) * 2 + 1; 256 int size = max (rh, rv) * 2 + 1;
86 double *kernel = (double *)malloc (size * sizeof (double)); 257 double *kernel = (double *)malloc (size * sizeof (double));
87 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 258 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
259 rxvt_img *img = new rxvt_img (s, format, x, y, w, h, repeat);
260 img->alloc ();
261
262 Picture src = src_picture ();
88 263
89 XRenderPictureAttributes pa; 264 XRenderPictureAttributes pa;
90
91 pa.repeat = RepeatPad; 265 pa.repeat = RepeatPad;
92 Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa); 266 Picture dst = XRenderCreatePicture (dpy, img->pm, format, CPRepeat, &pa);
267
93 Pixmap tmp = XCreatePixmap (dpy, pm, w, h, format->depth); 268 Pixmap tmp_pm = XCreatePixmap (dpy, pm, w, h, format->depth);
94 Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa); 269 Picture tmp = XRenderCreatePicture (dpy, tmp_pm , format, CPRepeat, &pa);
95 XFreePixmap (dpy, tmp); 270 XFreePixmap (dpy, tmp_pm);
96 271
97 if (kernel && params) 272 if (kernel && params)
98 { 273 {
99 size = rh * 2 + 1; 274 size = rh * 2 + 1;
100 get_gaussian_kernel (rh, size, kernel, params); 275 get_gaussian_kernel (rh, size, kernel, params);
… …
102 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 277 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
103 XRenderComposite (dpy, 278 XRenderComposite (dpy,
104 PictOpSrc, 279 PictOpSrc,
105 src, 280 src,
106 None, 281 None,
107 dst, 282 tmp,
108 0, 0, 283 0, 0,
109 0, 0, 284 0, 0,
110 0, 0, 285 0, 0,
111 w, h); 286 w, h);
112 287
113 ::swap (src, dst);
114
115 size = rv * 2 + 1; 288 size = rv * 2 + 1;
116 get_gaussian_kernel (rv, size, kernel, params); 289 get_gaussian_kernel (rv, size, kernel, params);
117 ::swap (params[0], params[1]); 290 ::swap (params[0], params[1]);
118 291
119 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 292 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
120 XRenderComposite (dpy, 293 XRenderComposite (dpy,
121 PictOpSrc, 294 PictOpSrc,
122 src, 295 tmp,
123 None, 296 None,
124 dst, 297 dst,
125 0, 0, 298 0, 0,
126 0, 0, 299 0, 0,
127 0, 0, 300 0, 0,
… …
130 303
131 free (kernel); 304 free (kernel);
132 free (params); 305 free (params);
133 XRenderFreePicture (dpy, src); 306 XRenderFreePicture (dpy, src);
134 XRenderFreePicture (dpy, dst); 307 XRenderFreePicture (dpy, dst);
308 XRenderFreePicture (dpy, tmp);
309
310 return img;
135} 311}
136 312
137static Picture 313static Picture
138create_xrender_mask (Display *dpy, Drawable drawable, Bool argb) 314create_xrender_mask (Display *dpy, Drawable drawable, Bool argb)
139{ 315{
… …
148 324
149 return mask; 325 return mask;
150} 326}
151 327
152void 328void
153rxvt_img::brightness (double r, double g, double b, double a) 329rxvt_img::brightness (unsigned short r, unsigned short g, unsigned short b, unsigned short a)
154{ 330{
155 Display *dpy = s->display->dpy; 331 Display *dpy = s->display->dpy;
156 Picture src = create_xrender_mask (dpy, pm, True); 332 Picture src = create_xrender_mask (dpy, pm, True);
157 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0); 333 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);
158 334
159 XRenderColor mask_c; 335 XRenderColor mask_c;
160 mask_c.red = float_to_component (r); 336 mask_c.red = r;
161 mask_c.green = float_to_component (g); 337 mask_c.green = g;
162 mask_c.blue = float_to_component (b); 338 mask_c.blue = b;
163 mask_c.alpha = float_to_component (a); 339 mask_c.alpha = a;
164 XRenderFillRectangle (dpy, PictOpSrc, src, &mask_c, 0, 0, 1, 1); 340 XRenderFillRectangle (dpy, PictOpSrc, src, &mask_c, 0, 0, 1, 1);
165 341
166 XRenderComposite (dpy, PictOpAdd, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 342 XRenderComposite (dpy, PictOpAdd, src, None, dst, 0, 0, 0, 0, 0, 0, w, h);
343
344 XRenderFreePicture (dpy, src);
345 XRenderFreePicture (dpy, dst);
167} 346}
168 347
169void 348void
170rxvt_img::contrast (double r, double g, double b, double a) 349rxvt_img::contrast (unsigned short r, unsigned short g, unsigned short b, unsigned short a)
171{ 350{
172 if (!(s->display->flags & DISPLAY_HAS_RENDER_MUL)) 351 if (!(s->display->flags & DISPLAY_HAS_RENDER_MUL))
173 return; 352 return;
174 353
175 Display *dpy = s->display->dpy; 354 Display *dpy = s->display->dpy;
176 Picture src = create_xrender_mask (dpy, pm, True); 355 Picture src = create_xrender_mask (dpy, pm, True);
177 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0); 356 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);
178 357
179 XRenderColor mask_c; 358 XRenderColor mask_c;
180 mask_c.red = float_to_component (r); 359 mask_c.red = r;
181 mask_c.green = float_to_component (g); 360 mask_c.green = g;
182 mask_c.blue = float_to_component (b); 361 mask_c.blue = b;
183 mask_c.alpha = float_to_component (a); 362 mask_c.alpha = a;
184 XRenderFillRectangle (dpy, PictOpSrc, src, &mask_c, 0, 0, 1, 1); 363 XRenderFillRectangle (dpy, PictOpSrc, src, &mask_c, 0, 0, 1, 1);
185 364
186 XRenderComposite (dpy, PictOpMultiply, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 365 XRenderComposite (dpy, PictOpMultiply, src, None, dst, 0, 0, 0, 0, 0, 0, w, h);
187}
188 366
189void 367 XRenderFreePicture (dpy, src);
190rxvt_img::render (GdkPixbuf *pixbuf, int src_x, int src_y, int width, int height, int dst_x, int dst_y) 368 XRenderFreePicture (dpy, dst);
191{
192 //TODO
193} 369}
194 370
195rxvt_img * 371rxvt_img *
196rxvt_img::copy () 372rxvt_img::clone ()
197{ 373{
198 GC gc = XCreateGC (s->display->dpy, pm, 0, 0); 374 return new rxvt_img (*this);
199 Pixmap pm2 = XCreatePixmap (s->display->dpy, pm, w, h, format->depth);
200 XCopyArea (s->display->dpy, pm, pm2, gc, 0, 0, w, h, 0, 0);
201 XFreeGC (s->display->dpy, gc);
202 return new rxvt_img (s, format, w, h, pm2);
203} 375}
204 376
377static XRenderPictFormat *
378find_alpha_format_for (Display *dpy, XRenderPictFormat *format)
379{
380 if (format->direct.alphaMask)
381 return format; // already has alpha
382
383 // try to find a suitable alpha format, one bit alpha is enough for our purposes
384 if (format->type == PictTypeDirect)
385 for (int n = 0; XRenderPictFormat *f = XRenderFindFormat (dpy, 0, 0, n); ++n)
386 if (f->direct.alphaMask
387 && f->type == PictTypeDirect
388 && ecb_popcount32 (f->direct.redMask ) >= ecb_popcount32 (format->direct.redMask )
389 && ecb_popcount32 (f->direct.greenMask) >= ecb_popcount32 (format->direct.greenMask)
390 && ecb_popcount32 (f->direct.blueMask ) >= ecb_popcount32 (format->direct.blueMask ))
391 return f;
392
393 // should be a very good fallback
394 return XRenderFindStandardFormat (dpy, PictStandardARGB32);
395}
396
205rxvt_img * 397rxvt_img *
398rxvt_img::reify ()
399{
400 if (x == 0 && y == 0 && w == ref->w && h == ref->h)
401 return clone ();
402
403 Display *dpy = s->display->dpy;
404
405 bool alpha = !format->direct.alphaMask
406 && (x || y)
407 && repeat == RepeatNone;
408
409 rxvt_img *img = new rxvt_img (s, alpha ? find_alpha_format_for (dpy, format) : format, 0, 0, w, h, repeat);
410 img->alloc ();
411
412 Picture src = src_picture ();
413 Picture dst = XRenderCreatePicture (dpy, img->pm, img->format, 0, 0);
414
415 if (alpha)
416 {
417 XRenderColor rc = { 0, 0, 0, 0 };
418 XRenderFillRectangle (dpy, PictOpSrc, dst, &rc, 0, 0, w, h);//TODO: split into four fillrectangles
419 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, -x, -y, ref->w, ref->h);
420 }
421 else
422 XRenderComposite (dpy, PictOpSrc, src, None, dst, x, y, 0, 0, 0, 0, w, h);
423
424 XRenderFreePicture (dpy, src);
425 XRenderFreePicture (dpy, dst);
426
427 return img;
428}
429
430rxvt_img *
431rxvt_img::sub_rect (int x, int y, int width, int height)
432{
433 rxvt_img *img = clone ();
434
435 img->x += x;
436 img->y += y;
437
438 if (w != width || h != height)
439 {
440 img->w = width;
441 img->h = height;
442
443 rxvt_img *img2 = img->reify ();
444 delete img;
445 img = img2;
446 }
447
448 return img;
449}
450
451rxvt_img *
206rxvt_img::transform (int new_width, int new_height, double matrix[16]) 452rxvt_img::transform (int new_width, int new_height, double matrix[9])
207{ 453{
208 //TODO 454 rxvt_img *img = new rxvt_img (s, format, 0, 0, new_width, new_height, repeat);
455 img->alloc ();
456
457 Display *dpy = s->display->dpy;
458 Picture src = src_picture ();
459 Picture dst = XRenderCreatePicture (dpy, img->pm, img->format, 0, 0);
460
461 XTransform xfrm;
462
463 for (int i = 0; i < 3; ++i)
464 for (int j = 0; j < 3; ++j)
465 xfrm.matrix [i][j] = XDoubleToFixed (matrix [i * 3 + j]);
466
467#if 0
468 xfrm.matrix [0][2] -= XDoubleToFixed (x);//TODO
469 xfrm.matrix [1][2] -= XDoubleToFixed (y);
470#endif
471
472 XRenderSetPictureFilter (dpy, src, "good", 0, 0);
473 XRenderSetPictureTransform (dpy, src, &xfrm);
474 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, new_width, new_height);
475
476 XRenderFreePicture (dpy, src);
477 XRenderFreePicture (dpy, dst);
478
479 return img;
209} 480}
210 481
211rxvt_img * 482rxvt_img *
212rxvt_img::scale (int new_width, int new_height) 483rxvt_img::scale (int new_width, int new_height)
213{ 484{
214 // use transform 485 if (w == new_width && h == new_height)
215 //TODO 486 return clone ();
216}
217 487
488 double matrix[9] = {
489 w / (double)new_width, 0, 0,
490 0, h / (double)new_height, 0,
491 0, 0, 1
492 };
493
494 int old_repeat_mode = repeat;
495 repeat = RepeatPad; // not right, but xrender can't proeprly scale it seems
496
497 rxvt_img *img = transform (new_width, new_height, matrix);
498
499 repeat = old_repeat_mode;
500 img->repeat = repeat;
501
502 return img;
503}
504
218rxvt_img * 505rxvt_img *
506rxvt_img::rotate (int new_width, int new_height, int x, int y, double phi)
507{
508 double s = sin (phi);
509 double c = cos (phi);
510
511 double matrix[9] = {
512 c, -s, -c * x + s * y + x,
513 s, c, -s * x - c * y + y,
514 0, 0, 1
515 };
516
517 return transform (new_width, new_height, matrix);
518}
519
520rxvt_img *
219rxvt_img::convert_to (XRenderPictFormat *new_format) 521rxvt_img::convert_format (XRenderPictFormat *new_format, const rxvt_color &bg)
220{ 522{
523 if (new_format == format)
524 return clone ();
525
221 rxvt_img *img = new rxvt_img (s,new_format,w, h); 526 rxvt_img *img = new rxvt_img (s, new_format, x, y, w, h, repeat);
527 img->alloc ();
222 528
223 Display *dpy = s->display->dpy; 529 Display *dpy = s->display->dpy;
224 Picture src = XRenderCreatePicture (dpy, pm, format, 0, 0); 530 Picture src = src_picture ();
225 Picture dst = XRenderCreatePicture (dpy, img->pm, new_format, 0, 0); 531 Picture dst = XRenderCreatePicture (dpy, img->pm, new_format, 0, 0);
532 int op = PictOpSrc;
226 533
534 if (format->direct.alphaMask && !new_format->direct.alphaMask)
535 {
536 // does it have to be that complicated
537 rgba c;
538 bg.get (c);
539
540 XRenderColor rc = { c.r, c.g, c.b, 0xffff };
541 XRenderFillRectangle (dpy, PictOpSrc, dst, &rc, 0, 0, w, h);
542
543 op = PictOpOver;
544 }
545
227 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 546 XRenderComposite (dpy, op, src, None, dst, 0, 0, 0, 0, 0, 0, w, h);
228 547
229 XRenderFreePicture (dpy, src);
230 XRenderFreePicture (dpy, dst); 548 XRenderFreePicture (dpy, src);
549 XRenderFreePicture (dpy, dst);
231 550
551 return img;
552}
553
554rxvt_img *
555rxvt_img::blend (rxvt_img *img, double factor)
556{
557 rxvt_img *img2 = clone ();
558 Display *dpy = s->display->dpy;
559 Picture src = img->src_picture ();
560 Picture dst = XRenderCreatePicture (dpy, img2->pm, img2->format, 0, 0);
561 Picture mask = create_xrender_mask (dpy, img->pm, False);
562
563 XRenderColor mask_c;
564
565 mask_c.alpha = float_to_component (factor);
566 mask_c.red =
567 mask_c.green =
568 mask_c.blue = 0;
569 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
570
571 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, w, h);
572
573 XRenderFreePicture (dpy, src);
574 XRenderFreePicture (dpy, dst);
575 XRenderFreePicture (dpy, mask);
576
232 return img; 577 return img2;
233} 578}
234 579
235#endif 580#endif
236 581

Diff Legend

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