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.10 by sf-exg, Mon Jun 4 06:59:50 2012 UTC vs.
Revision 1.68 by root, Sat Jun 9 11:14:35 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{
… …
147 XFreePixmap (dpy, pixmap); 329 XFreePixmap (dpy, pixmap);
148 330
149 return mask; 331 return mask;
150} 332}
151 333
334static void
335extract (int32_t cl0, int32_t cl1, int32_t &c, unsigned short &xc)
336{
337 int32_t x = clamp (c, cl0, cl1);
338 c -= x;
339 xc = x;
340}
341
342static bool
343extract (int32_t cl0, int32_t cl1, int32_t &r, int32_t &g, int32_t &b, int32_t &a, unsigned short &xr, unsigned short &xg, unsigned short &xb, unsigned short &xa)
344{
345 extract (cl0, cl1, r, xr);
346 extract (cl0, cl1, g, xg);
347 extract (cl0, cl1, b, xb);
348 extract (cl0, cl1, a, xa);
349
350 return xr | xg | xb | xa;
351}
352
152void 353void
153rxvt_img::brightness (double r, double g, double b, double a) 354rxvt_img::brightness (int32_t r, int32_t g, int32_t b, int32_t a)
154{ 355{
356 unshare ();
357
358 Display *dpy = s->display->dpy;
359 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);
360
361 while (r | g | b | a)
362 {
363 unsigned short xr, xg, xb, xa;
364 XRenderColor mask_c;
365
366 if (extract (0, 65535, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha))
367 XRenderFillRectangle (dpy, PictOpAdd, dst, &mask_c, 0, 0, w, h);
368
369 if (extract (-65535, 0, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha))
370 {
371 XRenderColor mask_w = { 65535, 65535, 65535, 65535 };
372 XRenderFillRectangle (dpy, PictOpDifference, dst, &mask_w, 0, 0, w, h);
373 mask_c.red = -mask_c.red;
374 mask_c.green = -mask_c.green;
375 mask_c.blue = -mask_c.blue;
376 mask_c.alpha = -mask_c.alpha;
377 XRenderFillRectangle (dpy, PictOpAdd, dst, &mask_c, 0, 0, w, h);
378 XRenderFillRectangle (dpy, PictOpDifference, dst, &mask_w, 0, 0, w, h);
379 }
380 }
381
382
383 XRenderFreePicture (dpy, dst);
384}
385
386void
387rxvt_img::contrast (int32_t r, int32_t g, int32_t b, int32_t a)
388{
389 if (!(s->display->flags & DISPLAY_HAS_RENDER_MUL))
390 {
391 rxvt_warn ("rxvt_img::contrast operation not supported on this display, RENDER extension too old.\n");
392 return;
393 }
394
395 unshare ();
396
155 Display *dpy = s->display->dpy; 397 Display *dpy = s->display->dpy;
156 Picture src = create_xrender_mask (dpy, pm, True); 398 Picture src = create_xrender_mask (dpy, pm, True);
157 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0); 399 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);
158 400
159 XRenderColor mask_c; 401 XRenderColor mask_c;
160 mask_c.red = float_to_component (r); 402 mask_c.red = r;
161 mask_c.green = float_to_component (g); 403 mask_c.green = g;
162 mask_c.blue = float_to_component (b); 404 mask_c.blue = b;
163 mask_c.alpha = float_to_component (a); 405 mask_c.alpha = a;
164 XRenderFillRectangle (dpy, PictOpSrc, src, &mask_c, 0, 0, 1, 1); 406 XRenderFillRectangle (dpy, PictOpSrc, src, &mask_c, 0, 0, 1, 1);
165 407
166 XRenderComposite (dpy, PictOpAdd, src, None, dst, 0, 0, 0, 0, 0, 0, w, h);
167}
168
169void
170rxvt_img::contrast (double r, double g, double b, double a)
171{
172 if (!(s->display->flags & DISPLAY_HAS_RENDER_MUL))
173 return;
174
175 Display *dpy = s->display->dpy;
176 Picture src = create_xrender_mask (dpy, pm, True);
177 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);
178
179 XRenderColor mask_c;
180 mask_c.red = float_to_component (r);
181 mask_c.green = float_to_component (g);
182 mask_c.blue = float_to_component (b);
183 mask_c.alpha = float_to_component (a);
184 XRenderFillRectangle (dpy, PictOpSrc, src, &mask_c, 0, 0, 1, 1);
185
186 XRenderComposite (dpy, PictOpMultiply, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 408 XRenderComposite (dpy, PictOpMultiply, src, None, dst, 0, 0, 0, 0, 0, 0, w, h);
187}
188
189void
190rxvt_img::render (GdkPixbuf *pixbuf, int src_x, int src_y, int width, int height, int dst_x, int dst_y)
191{
192 //TODO
193}
194
195rxvt_img *
196rxvt_img::copy ()
197{
198 GC gc = XCreateGC (s->display->dpy, pm, 0, 0);
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}
204
205rxvt_img *
206rxvt_img::transform (int new_width, int new_height, double matrix[16])
207{
208 //TODO
209}
210
211rxvt_img *
212rxvt_img::scale (int new_width, int new_height)
213{
214 // use transform
215 //TODO
216}
217
218rxvt_img *
219rxvt_img::convert_to (XRenderPictFormat *new_format)
220{
221 rxvt_img *img = new rxvt_img (s, new_format, w, h);
222
223 Display *dpy = s->display->dpy;
224 Picture src = XRenderCreatePicture (dpy, pm, format, 0, 0);
225 Picture dst = XRenderCreatePicture (dpy, img->pm, new_format, 0, 0);
226
227 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, w, h);
228 409
229 XRenderFreePicture (dpy, src); 410 XRenderFreePicture (dpy, src);
230 XRenderFreePicture (dpy, dst); 411 XRenderFreePicture (dpy, dst);
412}
231 413
414rxvt_img *
415rxvt_img::clone ()
416{
417 return new rxvt_img (*this);
418}
419
420static XRenderPictFormat *
421find_alpha_format_for (Display *dpy, XRenderPictFormat *format)
422{
423 if (format->direct.alphaMask)
424 return format; // already has alpha
425
426 // try to find a suitable alpha format, one bit alpha is enough for our purposes
427 if (format->type == PictTypeDirect)
428 for (int n = 0; XRenderPictFormat *f = XRenderFindFormat (dpy, 0, 0, n); ++n)
429 if (f->direct.alphaMask
430 && f->type == PictTypeDirect
431 && ecb_popcount32 (f->direct.redMask ) >= ecb_popcount32 (format->direct.redMask )
432 && ecb_popcount32 (f->direct.greenMask) >= ecb_popcount32 (format->direct.greenMask)
433 && ecb_popcount32 (f->direct.blueMask ) >= ecb_popcount32 (format->direct.blueMask ))
434 return f;
435
436 // should be a very good fallback
437 return XRenderFindStandardFormat (dpy, PictStandardARGB32);
438}
439
440rxvt_img *
441rxvt_img::reify ()
442{
443 if (x == 0 && y == 0 && w == ref->w && h == ref->h)
444 return clone ();
445
446 Display *dpy = s->display->dpy;
447
448 // add an alpha channel if...
449 bool alpha = !format->direct.alphaMask // pixmap has none yet
450 && (x || y) // we need one because of non-zero offset
451 && repeat == RepeatNone; // and we have no good pixels to fill with
452
453 rxvt_img *img = new rxvt_img (s, alpha ? find_alpha_format_for (dpy, format) : format, 0, 0, w, h, repeat);
454 img->alloc ();
455
456 Picture src = src_picture ();
457 Picture dst = XRenderCreatePicture (dpy, img->pm, img->format, 0, 0);
458
459 if (alpha)
460 {
461 XRenderColor rc = { 0, 0, 0, 0 };
462 XRenderFillRectangle (dpy, PictOpSrc, dst, &rc, 0, 0, w, h);//TODO: split into four fillrectangles
463 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, -x, -y, ref->w, ref->h);
464 }
465 else
466 XRenderComposite (dpy, PictOpSrc, src, None, dst, x, y, 0, 0, 0, 0, w, h);
467
468 XRenderFreePicture (dpy, src);
469 XRenderFreePicture (dpy, dst);
470
471 return img;
472}
473
474rxvt_img *
475rxvt_img::sub_rect (int x, int y, int width, int height)
476{
477 rxvt_img *img = clone ();
478
479 img->x += x;
480 img->y += y;
481
482 if (w != width || h != height)
483 {
484 img->w = width;
485 img->h = height;
486
487 rxvt_img *img2 = img->reify ();
488 delete img;
489 img = img2;
490 }
491
492 return img;
493}
494
495rxvt_img *
496rxvt_img::transform (int new_width, int new_height, double matrix[9])
497{
498 rxvt_img *img = new rxvt_img (s, format, 0, 0, new_width, new_height, repeat);
499 img->alloc ();
500
501 Display *dpy = s->display->dpy;
502 Picture src = src_picture ();
503 Picture dst = XRenderCreatePicture (dpy, img->pm, img->format, 0, 0);
504
505 XTransform xfrm;
506
507 for (int i = 0; i < 3; ++i)
508 for (int j = 0; j < 3; ++j)
509 xfrm.matrix [i][j] = XDoubleToFixed (matrix [i * 3 + j]);
510
511 xfrm.matrix [0][2] -= XDoubleToFixed (x);//TODO
512 xfrm.matrix [1][2] -= XDoubleToFixed (y);
513
514 XRenderSetPictureFilter (dpy, src, "good", 0, 0);
515 XRenderSetPictureTransform (dpy, src, &xfrm);
516 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, new_width, new_height);
517
518 XRenderFreePicture (dpy, src);
519 XRenderFreePicture (dpy, dst);
520
521 return img;
522}
523
524rxvt_img *
525rxvt_img::scale (int new_width, int new_height)
526{
527 if (w == new_width && h == new_height)
528 return clone ();
529
530 double matrix[9] = {
531 w / (double)new_width, 0, 0,
532 0, h / (double)new_height, 0,
533 0, 0, 1
534 };
535
536 int old_repeat_mode = repeat;
537 repeat = RepeatPad; // not right, but xrender can't proeprly scale it seems
538
539 rxvt_img *img = transform (new_width, new_height, matrix);
540
541 repeat = old_repeat_mode;
542 img->repeat = repeat;
543
544 return img;
545}
546
547rxvt_img *
548rxvt_img::rotate (int new_width, int new_height, int x, int y, double phi)
549{
550 double s = sin (phi);
551 double c = cos (phi);
552
553 double matrix[9] = {
554 c, -s, -c * x + s * y + x,
555 s, c, -s * x - c * y + y,
556 0, 0, 1
557 };
558
559 return transform (new_width, new_height, matrix);
560}
561
562rxvt_img *
563rxvt_img::convert_format (XRenderPictFormat *new_format, const rxvt_color &bg)
564{
565 if (new_format == format)
566 return clone ();
567
568 rxvt_img *img = new rxvt_img (s, new_format, x, y, w, h, repeat);
569 img->alloc ();
570
571 Display *dpy = s->display->dpy;
572 Picture src = src_picture ();
573 Picture dst = XRenderCreatePicture (dpy, img->pm, new_format, 0, 0);
574 int op = PictOpSrc;
575
576 if (format->direct.alphaMask && !new_format->direct.alphaMask)
577 {
578 // does it have to be that complicated
579 rgba c;
580 bg.get (c);
581
582 XRenderColor rc = { c.r, c.g, c.b, 0xffff };
583 XRenderFillRectangle (dpy, PictOpSrc, dst, &rc, 0, 0, w, h);
584
585 op = PictOpOver;
586 }
587
588 XRenderComposite (dpy, op, src, None, dst, 0, 0, 0, 0, 0, 0, w, h);
589
590 XRenderFreePicture (dpy, src);
591 XRenderFreePicture (dpy, dst);
592
593 return img;
594}
595
596rxvt_img *
597rxvt_img::blend (rxvt_img *img, double factor)
598{
599 rxvt_img *img2 = clone ();
600 Display *dpy = s->display->dpy;
601 Picture src = img->src_picture ();
602 Picture dst = XRenderCreatePicture (dpy, img2->pm, img2->format, 0, 0);
603 Picture mask = create_xrender_mask (dpy, img->pm, False);
604
605 XRenderColor mask_c;
606
607 mask_c.alpha = float_to_component (factor);
608 mask_c.red =
609 mask_c.green =
610 mask_c.blue = 0;
611 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
612
613 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, w, h);
614
615 XRenderFreePicture (dpy, src);
616 XRenderFreePicture (dpy, dst);
617 XRenderFreePicture (dpy, mask);
618
232 return img; 619 return img2;
233} 620}
234 621
235#endif 622#endif
236 623

Diff Legend

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