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

Diff Legend

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