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

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.174 by sf-exg, Wed Nov 23 16:53:53 2011 UTC vs.
Revision 1.214 by sf-exg, Thu May 17 10:18:32 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>
… …
32 32
33#ifndef FilterConvolution 33#ifndef FilterConvolution
34#define FilterConvolution "convolution" 34#define FilterConvolution "convolution"
35#endif 35#endif
36 36
37#ifndef RepeatPad
38#define RepeatPad True
39#endif
40
37#ifdef HAVE_BG_PIXMAP 41#ifdef HAVE_BG_PIXMAP
42# if XRENDER
43static Picture
44create_xrender_mask (Display *dpy, Drawable drawable, Bool argb, Bool component_alpha)
45{
46 Pixmap pixmap = XCreatePixmap (dpy, drawable, 1, 1, argb ? 32 : 8);
47
48 XRenderPictFormat *format = XRenderFindStandardFormat (dpy, argb ? PictStandardARGB32 : PictStandardA8);
49 XRenderPictureAttributes pa;
50 pa.repeat = True;
51 pa.component_alpha = component_alpha;
52 Picture mask = XRenderCreatePicture (dpy, pixmap, format, CPRepeat | CPComponentAlpha, &pa);
53
54 XFreePixmap (dpy, pixmap);
55
56 return mask;
57}
58# endif
59
38void 60void
39rxvt_term::bg_destroy () 61rxvt_term::bg_destroy ()
40{ 62{
41#ifdef HAVE_AFTERIMAGE
42 if (original_asim)
43 safe_asimage_destroy (original_asim);
44 if (asv)
45 destroy_asvisual (asv, 0);
46 if (asimman)
47 destroy_image_manager (asimman, 0);
48#endif
49
50#ifdef HAVE_PIXBUF
51 if (pixbuf)
52 g_object_unref (pixbuf);
53#endif
54
55 if (bg_pixmap) 63 if (bg_pixmap)
56 XFreePixmap (dpy, bg_pixmap); 64 XFreePixmap (dpy, bg_pixmap);
57} 65}
58 66
59bool 67bool
… …
77 if (bg_flags & BG_IS_TRANSPARENT) 85 if (bg_flags & BG_IS_TRANSPARENT)
78 return true; 86 return true;
79# endif 87# endif
80 88
81# ifdef BG_IMAGE_FROM_FILE 89# ifdef BG_IMAGE_FROM_FILE
82 if (bg_flags & BG_IS_FROM_FILE) 90 if (bg_image.flags & IM_IS_SET)
83 { 91 {
84 if (bg_flags & BG_IS_SIZE_SENSITIVE) 92 if ((bg_image.flags & IM_IS_SIZE_SENSITIVE)
93 || bg_image.width () > szHint.width
94 || bg_image.height () > szHint.height)
85 return true; 95 return true;
86 } 96 }
87# endif 97# endif
88 98
89 return false; 99 return false;
… …
96 if (bg_flags & BG_IS_TRANSPARENT) 106 if (bg_flags & BG_IS_TRANSPARENT)
97 return true; 107 return true;
98# endif 108# endif
99 109
100# ifdef BG_IMAGE_FROM_FILE 110# ifdef BG_IMAGE_FROM_FILE
101 if (bg_flags & BG_IS_FROM_FILE) 111 if (bg_image.flags & IM_IS_SET)
102 { 112 {
103 if (bg_flags & BG_ROOT_ALIGN) 113 if (bg_image.flags & IM_ROOT_ALIGN)
104 return true; 114 return true;
105 } 115 }
106# endif 116# endif
107 117
108 return false; 118 return false;
109} 119}
110 120
111# ifdef BG_IMAGE_FROM_FILE 121# ifdef BG_IMAGE_FROM_FILE
112static inline bool
113check_set_scale_value (int geom_flags, int flag, unsigned int &scale, unsigned int new_value)
114{
115 if (geom_flags & flag)
116 {
117 if (new_value > 1000)
118 new_value = 1000;
119 if (new_value != scale)
120 {
121 scale = new_value;
122 return true;
123 }
124 }
125 return false;
126}
127
128static inline bool
129check_set_align_value (int geom_flags, int flag, int &align, int new_value)
130{
131 if (geom_flags & flag)
132 {
133 if (new_value < -100)
134 new_value = -100;
135 else if (new_value > 200)
136 new_value = 200;
137 if (new_value != align)
138 {
139 align = new_value;
140 return true;
141 }
142 }
143 return false;
144}
145
146static inline int 122static inline int
147make_align_position (int align, int window_size, int image_size) 123make_align_position (int align, int window_size, int image_size)
148{ 124{
149 int diff = window_size - image_size;
150 int smaller = min (image_size, window_size);
151
152 if (align >= 0 && align <= 100) 125 if (align >= 0 && align <= 100)
153 return diff * align / 100; 126 return lerp (0, window_size - image_size, align);
154 else if (align > 100 && align <= 200) 127 else if (align > 100)
155 return (align - 100) * smaller / 100 + window_size - smaller; 128 return lerp (window_size - image_size, window_size, align - 100);
156 else if (align >= -100 && align < 0) 129 else
157 return (align + 100) * smaller / 100 - image_size; 130 return lerp (-image_size, 0, align + 100);
158 return 0;
159} 131}
160 132
161static inline int 133static inline int
162make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size) 134make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)
163{ 135{
… …
169 src_pos = -pos; 141 src_pos = -pos;
170 dst_pos = 0; 142 dst_pos = 0;
171 dst_size += pos; 143 dst_size += pos;
172 } 144 }
173 145
174 if (dst_pos + dst_size > target_size)
175 dst_size = target_size - dst_pos; 146 min_it (dst_size, target_size - dst_pos);
176 return src_pos; 147 return src_pos;
177} 148}
178 149
179bool 150bool
180rxvt_term::bg_set_geometry (const char *geom, bool update) 151rxvt_image::set_geometry (const char *geom, bool update)
181{ 152{
182 bool changed = false; 153 bool changed = false;
183 int geom_flags = 0; 154 int geom_flags = 0;
184 int x = 0, y = 0; 155 int x = h_align;
156 int y = v_align;
185 unsigned int w = 0, h = 0; 157 unsigned int w = h_scale;
186 unsigned long new_flags = bg_flags & ~BG_GEOMETRY_FLAGS; 158 unsigned int h = v_scale;
159 unsigned long new_flags = 0;
187 160
188 if (geom == NULL) 161 if (geom == NULL)
189 return false; 162 return false;
190 163
191 if (geom[0]) 164 if (geom[0])
… …
194 167
195 for (int i = 0; arr[i]; i++) 168 for (int i = 0; arr[i]; i++)
196 { 169 {
197 if (!strcasecmp (arr[i], "style=tiled")) 170 if (!strcasecmp (arr[i], "style=tiled"))
198 { 171 {
199 new_flags = BG_TILE; 172 new_flags = IM_TILE;
200 w = h = noScale; 173 w = h = noScale;
201 x = y = 0; 174 x = y = 0;
202 geom_flags = WidthValue|HeightValue|XValue|YValue; 175 geom_flags = WidthValue|HeightValue|XValue|YValue;
203 } 176 }
204 else if (!strcasecmp (arr[i], "style=aspect-stretched")) 177 else if (!strcasecmp (arr[i], "style=aspect-stretched"))
205 { 178 {
206 new_flags = BG_PROP_SCALE; 179 new_flags = IM_KEEP_ASPECT;
207 w = h = windowScale; 180 w = h = windowScale;
208 x = y = centerAlign; 181 x = y = centerAlign;
209 geom_flags = WidthValue|HeightValue|XValue|YValue; 182 geom_flags = WidthValue|HeightValue|XValue|YValue;
210 } 183 }
211 else if (!strcasecmp (arr[i], "style=stretched")) 184 else if (!strcasecmp (arr[i], "style=stretched"))
… …
221 x = y = centerAlign; 194 x = y = centerAlign;
222 geom_flags = WidthValue|HeightValue|XValue|YValue; 195 geom_flags = WidthValue|HeightValue|XValue|YValue;
223 } 196 }
224 else if (!strcasecmp (arr[i], "style=root-tiled")) 197 else if (!strcasecmp (arr[i], "style=root-tiled"))
225 { 198 {
226 new_flags = BG_TILE|BG_ROOT_ALIGN; 199 new_flags = IM_TILE|IM_ROOT_ALIGN;
227 w = h = noScale; 200 w = h = noScale;
228 geom_flags = WidthValue|HeightValue; 201 geom_flags = WidthValue|HeightValue;
229 } 202 }
230 else if (!strcasecmp (arr[i], "op=tile")) 203 else if (!strcasecmp (arr[i], "op=tile"))
231 new_flags |= BG_TILE; 204 new_flags |= IM_TILE;
232 else if (!strcasecmp (arr[i], "op=pscale")) 205 else if (!strcasecmp (arr[i], "op=keep-aspect"))
233 new_flags |= BG_PROP_SCALE; 206 new_flags |= IM_KEEP_ASPECT;
234 else if (!strcasecmp (arr[i], "op=root")) 207 else if (!strcasecmp (arr[i], "op=root-align"))
235 new_flags |= BG_ROOT_ALIGN; 208 new_flags |= IM_ROOT_ALIGN;
236 209
237 // deprecated 210 // deprecated
238 else if (!strcasecmp (arr[i], "tile")) 211 else if (!strcasecmp (arr[i], "tile"))
239 { 212 {
240 new_flags |= BG_TILE; 213 new_flags |= IM_TILE;
241 w = h = noScale; 214 w = h = noScale;
242 geom_flags |= WidthValue|HeightValue; 215 geom_flags |= WidthValue|HeightValue;
243 } 216 }
244 else if (!strcasecmp (arr[i], "propscale")) 217 else if (!strcasecmp (arr[i], "propscale"))
245 { 218 {
246 new_flags |= BG_PROP_SCALE; 219 new_flags |= IM_KEEP_ASPECT;
220 w = h = windowScale;
221 geom_flags |= WidthValue|HeightValue;
247 } 222 }
248 else if (!strcasecmp (arr[i], "hscale")) 223 else if (!strcasecmp (arr[i], "hscale"))
249 { 224 {
250 new_flags |= BG_TILE; 225 new_flags |= IM_TILE;
251 w = windowScale; 226 w = windowScale;
252 h = noScale; 227 h = noScale;
253 geom_flags |= WidthValue|HeightValue; 228 geom_flags |= WidthValue|HeightValue;
254 } 229 }
255 else if (!strcasecmp (arr[i], "vscale")) 230 else if (!strcasecmp (arr[i], "vscale"))
256 { 231 {
257 new_flags |= BG_TILE; 232 new_flags |= IM_TILE;
258 h = windowScale; 233 h = windowScale;
259 w = noScale; 234 w = noScale;
260 geom_flags |= WidthValue|HeightValue; 235 geom_flags |= WidthValue|HeightValue;
261 } 236 }
262 else if (!strcasecmp (arr[i], "scale")) 237 else if (!strcasecmp (arr[i], "scale"))
… …
270 x = y = centerAlign; 245 x = y = centerAlign;
271 geom_flags |= WidthValue|HeightValue|XValue|YValue; 246 geom_flags |= WidthValue|HeightValue|XValue|YValue;
272 } 247 }
273 else if (!strcasecmp (arr[i], "root")) 248 else if (!strcasecmp (arr[i], "root"))
274 { 249 {
275 new_flags |= BG_TILE|BG_ROOT_ALIGN; 250 new_flags |= IM_TILE|IM_ROOT_ALIGN;
276 w = h = noScale; 251 w = h = noScale;
277 geom_flags |= WidthValue|HeightValue; 252 geom_flags |= WidthValue|HeightValue;
278 } 253 }
279 254
280 else 255 else
281 geom_flags |= XParseGeometry (arr[i], &x, &y, &w, &h); 256 geom_flags |= XParseGeometry (arr[i], &x, &y, &w, &h);
282 } /* done parsing ops */ 257 } /* done parsing ops */
283 258
284 rxvt_free_strsplit (arr); 259 rxvt_free_strsplit (arr);
285 } 260 }
261
262 new_flags |= flags & ~IM_GEOMETRY_FLAGS;
286 263
287 if (!update) 264 if (!update)
288 { 265 {
289 if (!(geom_flags & XValue)) 266 if (!(geom_flags & XValue))
290 x = y = defaultAlign; 267 x = y = defaultAlign;
… …
295 w = h = defaultScale; 272 w = h = defaultScale;
296 else if (!(geom_flags & HeightValue)) 273 else if (!(geom_flags & HeightValue))
297 h = w; 274 h = w;
298 else if (!(geom_flags & WidthValue)) 275 else if (!(geom_flags & WidthValue))
299 w = h; 276 w = h;
300
301 geom_flags |= WidthValue|HeightValue|XValue|YValue;
302 }
303
304 if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)
305 || check_set_scale_value (geom_flags, HeightValue, v_scale, h)
306 || check_set_align_value (geom_flags, XValue, h_align, x)
307 || check_set_align_value (geom_flags, YValue, v_align, y))
308 changed = true;
309
310 if (new_flags != bg_flags)
311 { 277 }
278
279 min_it (w, 1000);
280 min_it (h, 1000);
281 clamp_it (x, -100, 200);
282 clamp_it (y, -100, 200);
283
284 if (flags != new_flags
285 || h_scale != w
286 || v_scale != h
287 || h_align != x
288 || v_align != y)
289 {
312 bg_flags = new_flags; 290 flags = new_flags;
291 h_scale = w;
292 v_scale = h;
293 h_align = x;
294 v_align = y;
313 changed = true; 295 changed = true;
314 } 296 }
315 297
298 if (!(flags & IM_TILE)
299 || h_scale || v_scale
300 || (!(flags & IM_ROOT_ALIGN) && (h_align || v_align)))
301 flags |= IM_IS_SIZE_SENSITIVE;
302 else
303 flags &= ~IM_IS_SIZE_SENSITIVE;
304
316 return changed; 305 return changed;
317} 306}
318 307
319void 308void
320rxvt_term::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y) 309rxvt_term::get_image_geometry (rxvt_image &image, int &w, int &h, int &x, int &y)
321{ 310{
311 int image_width = image.width ();
312 int image_height = image.height ();
322 int target_width = szHint.width; 313 int target_width = szHint.width;
323 int target_height = szHint.height; 314 int target_height = szHint.height;
324 315
325 w = h_scale * target_width / 100; 316 w = image.h_scale * target_width / 100;
326 h = v_scale * target_height / 100; 317 h = image.v_scale * target_height / 100;
327 318
328 if (bg_flags & BG_PROP_SCALE) 319 if (image.flags & IM_KEEP_ASPECT)
329 { 320 {
330 float scale = (float)w / image_width; 321 float scale = (float)w / image_width;
331 min_it (scale, (float)h / image_height); 322 min_it (scale, (float)h / image_height);
332 w = image_width * scale + 0.5; 323 w = image_width * scale + 0.5;
333 h = image_height * scale + 0.5; 324 h = image_height * scale + 0.5;
334 } 325 }
335 326
336 if (!w) w = image_width; 327 if (!w) w = image_width;
337 if (!h) h = image_height; 328 if (!h) h = image_height;
338 329
339 if (bg_flags & BG_ROOT_ALIGN) 330 if (image.flags & IM_ROOT_ALIGN)
340 { 331 {
341 x = -target_x; 332 x = -target_x;
342 y = -target_y; 333 y = -target_y;
343 } 334 }
344 else 335 else
345 { 336 {
346 x = make_align_position (h_align, target_width, w); 337 x = make_align_position (image.h_align, target_width, w);
347 y = make_align_position (v_align, target_height, h); 338 y = make_align_position (image.v_align, target_height, h);
348 }
349
350 bg_flags &= ~BG_IS_SIZE_SENSITIVE;
351 if (!(bg_flags & BG_TILE)
352 || h_scale || v_scale
353 || (!(bg_flags & BG_ROOT_ALIGN) && (h_align || v_align))
354 || w > target_width || h > target_height)
355 bg_flags |= BG_IS_SIZE_SENSITIVE;
356}
357
358# ifdef HAVE_AFTERIMAGE
359bool
360rxvt_term::render_image (unsigned long tr_flags)
361{
362 init_asv ();
363
364 ASImage *background = NULL;
365 ARGB32 background_tint = TINT_LEAVE_SAME;
366
367# ifdef ENABLE_TRANSPARENCY
368 if (tr_flags)
369 background = pixmap2ximage (asv, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, 100);
370
371 if (tr_flags & BG_NEEDS_TINT)
372 { 339 }
373 ShadingInfo as_shade; 340}
374 as_shade.shading = shade;
375 341
376 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 342# ifdef HAVE_PIXBUF
377 if (bg_flags & BG_TINT_SET) 343bool
378 tint.get (c); 344rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
379 as_shade.tintColor.red = c.r; 345 int src_x, int src_y, int dst_x, int dst_y,
380 as_shade.tintColor.green = c.g; 346 unsigned int width, unsigned int height)
381 as_shade.tintColor.blue = c.b; 347{
348 XImage *ximage;
349 char *line;
350 int width_r, width_g, width_b, width_a;
351 int sh_r, sh_g, sh_b, sh_a;
352 uint32_t alpha_mask;
353 int rowstride;
354 int channels;
355 unsigned char *row;
382 356
383 background_tint = shading2tint32 (&as_shade); 357 if (visual->c_class != TrueColor)
358 return false;
359
360#if XRENDER
361 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
362 if (format)
363 alpha_mask = (uint32_t)format->direct.alphaMask << format->direct.alpha;
364 else
365#endif
366 alpha_mask = 0;
367
368 width_r = ecb_popcount32 (visual->red_mask);
369 width_g = ecb_popcount32 (visual->green_mask);
370 width_b = ecb_popcount32 (visual->blue_mask);
371 width_a = ecb_popcount32 (alpha_mask);
372
373 if (width_r > 8 || width_g > 8 || width_b > 8 || width_a > 8)
374 return false;
375
376 sh_r = ecb_ctz32 (visual->red_mask);
377 sh_g = ecb_ctz32 (visual->green_mask);
378 sh_b = ecb_ctz32 (visual->blue_mask);
379 sh_a = ecb_ctz32 (alpha_mask);
380
381 if (width > 32767 || height > 32767)
382 return false;
383
384 ximage = XCreateImage (dpy, visual, depth, ZPixmap, 0, 0,
385 width, height, 32, 0);
386 if (!ximage)
387 return false;
388
389 if (height > INT_MAX / ximage->bytes_per_line
390 || !(ximage->data = (char *)malloc (height * ximage->bytes_per_line)))
384 } 391 {
385 392 XDestroyImage (ximage);
386 if ((tr_flags & BG_NEEDS_BLUR) && background != NULL) 393 return false;
387 { 394 }
388 ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF, 395
389 ASA_XImage, 396 ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
390 100, ASIMAGE_QUALITY_DEFAULT); 397
391 if (tmp) 398 rowstride = gdk_pixbuf_get_rowstride (pixbuf);
399 channels = gdk_pixbuf_get_n_channels (pixbuf);
400 row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels;
401 line = ximage->data;
402
403 rgba c (0, 0, 0);
404
405 if (channels == 4 && alpha_mask == 0)
406 {
407 pix_colors[Color_bg].get (c);
408 c.r >>= 8;
409 c.g >>= 8;
410 c.b >>= 8;
411 }
412
413 for (int y = 0; y < height; y++)
414 {
415 for (int x = 0; x < width; x++)
416 {
417 unsigned char *pixel = row + x * channels;
418 uint32_t value;
419 unsigned char r, g, b, a;
420
421 if (channels == 4)
392 { 422 {
393 destroy_asimage (&background); 423 a = pixel[3];
394 background = tmp; 424 r = (pixel[0] * a + c.r * (0xff - a)) / 0xff;
425 g = (pixel[1] * a + c.g * (0xff - a)) / 0xff;
426 b = (pixel[2] * a + c.b * (0xff - a)) / 0xff;
427 }
428 else
429 {
430 a = 0xff;
431 r = pixel[0];
432 g = pixel[1];
433 b = pixel[2];
434 }
435
436 value = ((r >> (8 - width_r)) << sh_r)
437 | ((g >> (8 - width_g)) << sh_g)
438 | ((b >> (8 - width_b)) << sh_b)
439 | ((a >> (8 - width_a)) << sh_a);
440
441 if (ximage->bits_per_pixel == 32)
442 ((uint32_t *)line)[x] = value;
443 else
444 XPutPixel (ximage, x, y, value);
395 } 445 }
396 }
397# endif
398 446
399 ASImage *result = 0; 447 row += rowstride;
448 line += ximage->bytes_per_line;
449 }
450
451 XPutImage (dpy, pixmap, gc, ximage, 0, 0, dst_x, dst_y, width, height);
452 XDestroyImage (ximage);
453 return true;
454}
455
456bool
457rxvt_term::render_image (rxvt_image &image, bool transparent)
458{
459 GdkPixbuf *pixbuf = image.pixbuf;
460 if (!pixbuf)
461 return false;
462
463 if (transparent
464 && !(bg_flags & BG_HAS_RENDER))
465 return false;
466
467 GdkPixbuf *result;
468
469 int image_width = gdk_pixbuf_get_width (pixbuf);
470 int image_height = gdk_pixbuf_get_height (pixbuf);
400 471
401 int target_width = szHint.width; 472 int target_width = szHint.width;
402 int target_height = szHint.height; 473 int target_height = szHint.height;
403 int new_pmap_width = target_width; 474 int new_pmap_width = target_width;
404 int new_pmap_height = target_height; 475 int new_pmap_height = target_height;
… …
406 int x = 0; 477 int x = 0;
407 int y = 0; 478 int y = 0;
408 int w = 0; 479 int w = 0;
409 int h = 0; 480 int h = 0;
410 481
411 if (original_asim) 482 get_image_geometry (image, w, h, x, y);
412 get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
413 483
414 if (!original_asim
415 || (!(bg_flags & BG_ROOT_ALIGN)
416 && (x >= target_width
417 || y >= target_height
418 || x + w <= 0
419 || y + h <= 0)))
420 {
421 if (background)
422 {
423 new_pmap_width = background->width;
424 new_pmap_height = background->height;
425 result = background;
426
427 if (background_tint != TINT_LEAVE_SAME)
428 {
429 ASImage *tmp = tile_asimage (asv, background, 0, 0,
430 target_width, target_height, background_tint,
431 ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
432 if (tmp)
433 result = tmp;
434 }
435 }
436 else
437 new_pmap_width = new_pmap_height = 0;
438 }
439 else
440 {
441 result = original_asim;
442
443 if (w != original_asim->width
444 || h != original_asim->height)
445 {
446 result = scale_asimage (asv, original_asim,
447 w, h,
448 ASA_XImage,
449 100, ASIMAGE_QUALITY_DEFAULT);
450 }
451
452 if (background == NULL)
453 {
454 if (bg_flags & BG_TILE)
455 {
456 /* if tiling - pixmap has to be sized exactly as the image,
457 but there is no need to make it bigger than the window! */
458 new_pmap_width = min (result->width, target_width);
459 new_pmap_height = min (result->height, target_height);
460
461 /* we also need to tile our image in both directions */
462 ASImage *tmp = tile_asimage (asv, result,
463 (int)result->width - x,
464 (int)result->height - y,
465 new_pmap_width,
466 new_pmap_height,
467 TINT_LEAVE_SAME, ASA_XImage,
468 100, ASIMAGE_QUALITY_DEFAULT);
469 if (tmp)
470 {
471 if (result != original_asim)
472 destroy_asimage (&result);
473
474 result = tmp;
475 }
476 }
477 }
478 else
479 {
480 /* if blending background and image - pixmap has to be sized same as target window */
481 ASImageLayer *layers = create_image_layers (2);
482
483 layers[0].im = background;
484 layers[0].clip_width = target_width;
485 layers[0].clip_height = target_height;
486 layers[0].tint = background_tint;
487 layers[1].im = result;
488
489 if (bg_flags & BG_TILE)
490 {
491 /* tile horizontally */
492 while (x > 0) x -= (int)result->width;
493 layers[1].dst_x = x;
494 layers[1].clip_width = result->width+target_width;
495 }
496 else
497 {
498 /* clip horizontally */
499 layers[1].dst_x = x;
500 layers[1].clip_width = result->width;
501 }
502
503 if (bg_flags & BG_TILE)
504 {
505 while (y > 0) y -= (int)result->height;
506 layers[1].dst_y = y;
507 layers[1].clip_height = result->height + target_height;
508 }
509 else
510 {
511 layers[1].dst_y = y;
512 layers[1].clip_height = result->height;
513 }
514
515 if (rs[Rs_blendtype])
516 {
517 layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
518 if (layers[1].merge_scanlines == NULL)
519 layers[1].merge_scanlines = alphablend_scanlines;
520 }
521
522 ASImage *tmp = merge_layers (asv, layers, 2, target_width, target_height,
523 ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
524
525 if (tmp)
526 {
527 if (result != original_asim)
528 destroy_asimage (&result);
529
530 result = tmp;
531 }
532
533 free (layers);
534 }
535 }
536
537 bool ret = false;
538
539 if (result)
540 {
541 XGCValues gcv;
542 GC gc;
543
544 /* create Pixmap */
545 if (bg_pixmap == None
546 || bg_pmap_width != new_pmap_width
547 || bg_pmap_height != new_pmap_height)
548 {
549 if (bg_pixmap)
550 XFreePixmap (dpy, bg_pixmap);
551 bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
552 bg_pmap_width = new_pmap_width;
553 bg_pmap_height = new_pmap_height;
554 }
555 /* fill with background color (if result's not completely overlapping it) */
556 gcv.foreground = pix_colors[Color_bg];
557 gc = XCreateGC (dpy, vt, GCForeground, &gcv);
558
559 int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
560 int dst_width = result->width, dst_height = result->height;
561 if (background == NULL)
562 {
563 if (!(bg_flags & BG_TILE))
564 {
565 src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );
566 src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
567 }
568
569 if (dst_x > 0 || dst_y > 0
570 || dst_x + dst_width < new_pmap_width
571 || dst_y + dst_height < new_pmap_height)
572 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
573 }
574
575 /* put result on pixmap */
576 if (dst_x < new_pmap_width && dst_y < new_pmap_height)
577 asimage2drawable (asv, bg_pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);
578
579 if (result != background && result != original_asim)
580 destroy_asimage (&result);
581
582 XFreeGC (dpy, gc);
583
584 ret = true;
585 }
586
587 if (background)
588 destroy_asimage (&background);
589
590 return ret;
591}
592# endif /* HAVE_AFTERIMAGE */
593
594# ifdef HAVE_PIXBUF
595bool
596rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
597 int src_x, int src_y, int dst_x, int dst_y,
598 unsigned int width, unsigned int height)
599{
600 XImage *ximage;
601 char *data, *line;
602 int bytes_per_pixel;
603 int width_r, width_g, width_b;
604 int sh_r, sh_g, sh_b;
605 int rowstride;
606 int channels;
607 unsigned char *row;
608
609 if (visual->c_class != TrueColor)
610 return false;
611
612 if (depth == 24 || depth == 32)
613 bytes_per_pixel = 4;
614 else if (depth == 15 || depth == 16)
615 bytes_per_pixel = 2;
616 else
617 return false;
618
619 width_r = ecb_popcount32 (visual->red_mask);
620 width_g = ecb_popcount32 (visual->green_mask);
621 width_b = ecb_popcount32 (visual->blue_mask);
622
623 if (width_r > 8 || width_g > 8 || width_b > 8)
624 return false;
625
626 sh_r = ecb_ctz32 (visual->red_mask);
627 sh_g = ecb_ctz32 (visual->green_mask);
628 sh_b = ecb_ctz32 (visual->blue_mask);
629
630 if (width > INT_MAX / height / bytes_per_pixel)
631 return false;
632
633 data = (char *)malloc (width * height * bytes_per_pixel);
634 if (!data)
635 return false;
636
637 ximage = XCreateImage (dpy, visual, depth, ZPixmap, 0, data,
638 width, height, bytes_per_pixel * 8, 0);
639 if (!ximage)
640 {
641 free (data);
642 return false;
643 }
644
645 ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
646
647 rowstride = gdk_pixbuf_get_rowstride (pixbuf);
648 channels = gdk_pixbuf_get_n_channels (pixbuf);
649 row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels;
650 line = data;
651
652 for (int y = 0; y < height; y++)
653 {
654 for (int x = 0; x < width; x++)
655 {
656 unsigned char *pixel = row + x * channels;
657 uint32_t value;
658
659 value = ((pixel[0] >> (8 - width_r)) << sh_r)
660 | ((pixel[1] >> (8 - width_g)) << sh_g)
661 | ((pixel[2] >> (8 - width_b)) << sh_b);
662
663 if (bytes_per_pixel == 4)
664 ((uint32_t *)line)[x] = value;
665 else
666 ((uint16_t *)line)[x] = value;
667 }
668
669 row += rowstride;
670 line += ximage->bytes_per_line;
671 }
672
673 XPutImage (dpy, pixmap, gc, ximage, 0, 0, dst_x, dst_y, width, height);
674 XDestroyImage (ximage);
675 return true;
676}
677
678bool
679rxvt_term::render_image (unsigned long tr_flags)
680{
681 if (!pixbuf)
682 return false;
683
684 if (tr_flags
685 && !(bg_flags & BG_HAS_RENDER))
686 return false;
687
688 GdkPixbuf *result;
689
690 int image_width = gdk_pixbuf_get_width (pixbuf);
691 int image_height = gdk_pixbuf_get_height (pixbuf);
692
693 int target_width = szHint.width;
694 int target_height = szHint.height;
695 int new_pmap_width = target_width;
696 int new_pmap_height = target_height;
697
698 int x = 0;
699 int y = 0;
700 int w = 0;
701 int h = 0;
702
703 get_image_geometry (image_width, image_height, w, h, x, y);
704
705 if (!(bg_flags & BG_ROOT_ALIGN) 484 if (!(image.flags & IM_ROOT_ALIGN)
706 && (x >= target_width 485 && (x >= target_width
707 || y >= target_height 486 || y >= target_height
708 || x + w <= 0 487 || x + w <= 0
709 || y + h <= 0)) 488 || y + h <= 0))
710 return false; 489 return false;
… …
729 Pixmap root_pmap; 508 Pixmap root_pmap;
730 509
731 image_width = gdk_pixbuf_get_width (result); 510 image_width = gdk_pixbuf_get_width (result);
732 image_height = gdk_pixbuf_get_height (result); 511 image_height = gdk_pixbuf_get_height (result);
733 512
734 if (tr_flags) 513 if (transparent)
735 { 514 {
736 root_pmap = bg_pixmap; 515 root_pmap = bg_pixmap;
737 bg_pixmap = None; 516 bg_pixmap = None;
738 } 517 }
739 else 518 else
740 { 519 {
741 if (bg_flags & BG_TILE) 520 if (image.flags & IM_TILE)
742 { 521 {
743 new_pmap_width = min (image_width, target_width); 522 new_pmap_width = min (image_width, target_width);
744 new_pmap_height = min (image_height, target_height); 523 new_pmap_height = min (image_height, target_height);
745 } 524 }
746 } 525 }
… …
759 gcv.foreground = pix_colors[Color_bg]; 538 gcv.foreground = pix_colors[Color_bg];
760 gc = XCreateGC (dpy, vt, GCForeground, &gcv); 539 gc = XCreateGC (dpy, vt, GCForeground, &gcv);
761 540
762 if (gc) 541 if (gc)
763 { 542 {
764 if (bg_flags & BG_TILE) 543 if (image.flags & IM_TILE)
765 { 544 {
766 Pixmap tile = XCreatePixmap (dpy, vt, image_width, image_height, depth); 545 Pixmap tile = XCreatePixmap (dpy, vt, image_width, image_height, depth);
767 pixbuf_to_pixmap (result, tile, gc, 546 pixbuf_to_pixmap (result, tile, gc,
768 0, 0, 547 0, 0,
769 0, 0, 548 0, 0,
… …
797 dst_x, dst_y, 576 dst_x, dst_y,
798 dst_width, dst_height); 577 dst_width, dst_height);
799 } 578 }
800 579
801#if XRENDER 580#if XRENDER
802 if (tr_flags) 581 if (transparent)
803 { 582 {
804 XRenderPictureAttributes pa;
805
806 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, visual); 583 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
584
807 Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa); 585 Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
808 586
809 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
810 Picture dst = XRenderCreatePicture (dpy, bg_pixmap, dst_format, 0, &pa); 587 Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
811 588
812 pa.repeat = True; 589 Picture mask = create_xrender_mask (dpy, vt, False, False);
813 Pixmap mask_pmap = XCreatePixmap (dpy, vt, 1, 1, 8);
814 XRenderPictFormat *mask_format = XRenderFindStandardFormat (dpy, PictStandardA8);
815 Picture mask = XRenderCreatePicture (dpy, mask_pmap, mask_format, CPRepeat, &pa);
816 XFreePixmap (dpy, mask_pmap);
817 590
818 XRenderColor mask_c; 591 XRenderColor mask_c;
819 592
820 mask_c.alpha = 0x8000; 593 mask_c.alpha = 0x8000;
821 mask_c.red = 0; 594 mask_c.red =
822 mask_c.green = 0; 595 mask_c.green =
823 mask_c.blue = 0; 596 mask_c.blue = 0;
824 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1); 597 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
598
825 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height); 599 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
826 600
827 XRenderFreePicture (dpy, src); 601 XRenderFreePicture (dpy, src);
828 XRenderFreePicture (dpy, dst); 602 XRenderFreePicture (dpy, dst);
829 XRenderFreePicture (dpy, mask); 603 XRenderFreePicture (dpy, mask);
… …
836 } 610 }
837 611
838 if (result != pixbuf) 612 if (result != pixbuf)
839 g_object_unref (result); 613 g_object_unref (result);
840 614
841 if (tr_flags) 615 if (transparent)
842 XFreePixmap (dpy, root_pmap); 616 XFreePixmap (dpy, root_pmap);
843 617
844 return ret; 618 return ret;
845} 619}
846# endif /* HAVE_PIXBUF */ 620# endif /* HAVE_PIXBUF */
847 621
848bool 622bool
849rxvt_term::bg_set_file (const char *file) 623rxvt_image::set_file (const char *file)
850{ 624{
851 if (!file || !*file) 625 if (!file || !*file)
852 return false; 626 return false;
853 627
854 bool ret = false; 628 bool ret = false;
… …
861 memcpy (f, file, len); 635 memcpy (f, file, len);
862 f[len] = '\0'; 636 f[len] = '\0';
863 file = f; 637 file = f;
864 } 638 }
865 639
866# ifdef HAVE_AFTERIMAGE
867 if (!asimman)
868 asimman = create_generic_imageman (rs[Rs_path]);
869 ASImage *image = get_asimage (asimman, file, 0xFFFFFFFF, 100);
870 if (image)
871 {
872 if (original_asim)
873 safe_asimage_destroy (original_asim);
874 original_asim = image;
875 bg_flags |= BG_IS_FROM_FILE | BG_CLIENT_RENDER;
876 ret = true;
877 }
878# endif
879
880# ifdef HAVE_PIXBUF 640# ifdef HAVE_PIXBUF
881 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL); 641 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
882 if (image) 642 if (image)
883 { 643 {
884 if (pixbuf) 644 if (pixbuf)
885 g_object_unref (pixbuf); 645 g_object_unref (pixbuf);
886 pixbuf = image; 646 pixbuf = image;
887 bg_flags |= BG_IS_FROM_FILE; 647 flags |= IM_IS_SET;
888 ret = true; 648 ret = true;
889 } 649 }
890# endif 650# endif
891 651
892 if (ret) 652 if (ret)
893 { 653 {
894 if (p) 654 if (p)
895 bg_set_geometry (p + 1); 655 set_geometry (p + 1);
896 else 656 else
897 bg_set_default_geometry (); 657 set_default_geometry ();
898 } 658 }
899 659
900 return ret; 660 return ret;
901} 661}
902 662
903# endif /* BG_IMAGE_FROM_FILE */ 663# endif /* BG_IMAGE_FROM_FILE */
904 664
905# ifdef ENABLE_TRANSPARENCY 665# ifdef ENABLE_TRANSPARENCY
906bool
907rxvt_term::bg_set_transparent ()
908{
909 if (!(bg_flags & BG_IS_TRANSPARENT))
910 {
911 bg_flags |= BG_IS_TRANSPARENT;
912 return true;
913 }
914
915 return false;
916}
917
918bool 666bool
919rxvt_term::bg_set_blur (const char *geom) 667rxvt_term::bg_set_blur (const char *geom)
920{ 668{
921 bool changed = false; 669 bool changed = false;
922 unsigned int hr, vr; 670 unsigned int hr, vr;
… …
941 { 689 {
942 changed = true; 690 changed = true;
943 v_blurRadius = vr; 691 v_blurRadius = vr;
944 } 692 }
945 693
946 if (v_blurRadius == 0 && h_blurRadius == 0)
947 bg_flags &= ~BG_NEEDS_BLUR;
948 else
949 bg_flags |= BG_NEEDS_BLUR;
950
951 return changed; 694 return changed;
952} 695}
953 696
954void 697bool
955rxvt_term::set_tint_shade_flags () 698rxvt_term::bg_set_tint (rxvt_color &new_tint)
956{ 699{
957 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 700 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
958 bool has_shade = shade != 100; 701 {
959 702 tint = new_tint;
960 bg_flags &= ~BG_TINT_FLAGS; 703 bg_flags |= BG_TINT_SET;
961 704
962 if (bg_flags & BG_TINT_SET) 705 rgba c;
963 {
964 tint.get (c); 706 tint.get (c);
965 if (!has_shade
966 && (c.r <= 0x00ff || c.r >= 0xff00) 707 if ((c.r <= 0x00ff || c.r >= 0xff00)
967 && (c.g <= 0x00ff || c.g >= 0xff00) 708 && (c.g <= 0x00ff || c.g >= 0xff00)
968 && (c.b <= 0x00ff || c.b >= 0xff00)) 709 && (c.b <= 0x00ff || c.b >= 0xff00))
969 bg_flags |= BG_TINT_BITAND; 710 bg_flags |= BG_TINT_BITAND;
970 } 711 else
971
972 if (has_shade || (bg_flags & BG_TINT_SET))
973 bg_flags |= BG_NEEDS_TINT;
974}
975
976bool
977rxvt_term::bg_set_tint (rxvt_color &new_tint)
978{
979 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
980 {
981 tint = new_tint;
982 bg_flags |= BG_TINT_SET; 712 bg_flags &= ~BG_TINT_BITAND;
983 set_tint_shade_flags (); 713
984 return true; 714 return true;
985 } 715 }
986 716
987 return false; 717 return false;
988} 718}
989 719
990bool 720bool
991rxvt_term::bg_set_shade (const char *shade_str) 721rxvt_term::bg_set_shade (const char *shade_str)
992{ 722{
993 int new_shade = (shade_str) ? atoi (shade_str) : 100; 723 int new_shade = atoi (shade_str);
994 724
995 clamp_it (new_shade, -100, 200); 725 clamp_it (new_shade, -100, 200);
996 if (new_shade < 0) 726 if (new_shade < 0)
997 new_shade = 200 - (100 + new_shade); 727 new_shade = 200 - (100 + new_shade);
998 728
999 if (new_shade != shade) 729 if (new_shade != shade)
1000 { 730 {
1001 shade = new_shade; 731 shade = new_shade;
1002 set_tint_shade_flags ();
1003 return true; 732 return true;
1004 } 733 }
1005 734
1006 return false; 735 return false;
1007} 736}
… …
1028 params[i+2] = XDoubleToFixed (kernel[i] / sum); 757 params[i+2] = XDoubleToFixed (kernel[i] / sum);
1029} 758}
1030#endif 759#endif
1031 760
1032bool 761bool
1033rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 762rxvt_term::blur_pixmap (Pixmap pixmap, int width, int height)
1034{ 763{
1035 bool ret = false; 764 bool ret = false;
1036#if XRENDER 765#if XRENDER
766 if (!(bg_flags & BG_HAS_RENDER_CONV))
767 return false;
768
1037 int size = max (h_blurRadius, v_blurRadius) * 2 + 1; 769 int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1038 double *kernel = (double *)malloc (size * sizeof (double)); 770 double *kernel = (double *)malloc (size * sizeof (double));
1039 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 771 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1040 772
1041 XRenderPictureAttributes pa; 773 XRenderPictureAttributes pa;
1042 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 774 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1043 775
776 pa.repeat = RepeatPad;
1044 Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 777 Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
778 Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1045 Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 779 Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
780 XFreePixmap (dpy, tmp);
1046 781
1047 if (kernel && params) 782 if (kernel && params)
1048 { 783 {
1049 if (h_blurRadius)
1050 {
1051 size = h_blurRadius * 2 + 1; 784 size = h_blurRadius * 2 + 1;
1052 get_gaussian_kernel (h_blurRadius, size, kernel, params); 785 get_gaussian_kernel (h_blurRadius, size, kernel, params);
1053 786
1054 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 787 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1055 XRenderComposite (dpy, 788 XRenderComposite (dpy,
1056 PictOpSrc, 789 PictOpSrc,
1057 src, 790 src,
1058 None, 791 None,
1059 dst, 792 dst,
1060 0, 0, 793 0, 0,
1061 0, 0, 794 0, 0,
1062 0, 0, 795 0, 0,
1063 width, height); 796 width, height);
1064 }
1065 797
1066 if (v_blurRadius) 798 ::swap (src, dst);
1067 { 799
1068 size = v_blurRadius * 2 + 1; 800 size = v_blurRadius * 2 + 1;
1069 get_gaussian_kernel (v_blurRadius, size, kernel, params); 801 get_gaussian_kernel (v_blurRadius, size, kernel, params);
1070 ::swap (params[0], params[1]); 802 ::swap (params[0], params[1]);
1071 803
1072 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 804 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1073 XRenderComposite (dpy, 805 XRenderComposite (dpy,
1074 PictOpSrc, 806 PictOpSrc,
1075 src, 807 src,
1076 None, 808 None,
1077 dst, 809 dst,
1078 0, 0, 810 0, 0,
1079 0, 0, 811 0, 0,
1080 0, 0, 812 0, 0,
1081 width, height); 813 width, height);
1082 }
1083 814
1084 ret = true; 815 ret = true;
1085 } 816 }
1086 817
1087 free (kernel); 818 free (kernel);
… …
1091#endif 822#endif
1092 return ret; 823 return ret;
1093} 824}
1094 825
1095bool 826bool
1096rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 827rxvt_term::tint_pixmap (Pixmap pixmap, int width, int height)
1097{ 828{
1098 bool ret = false; 829 bool ret = false;
1099 830
1100 if (bg_flags & BG_TINT_BITAND) 831 if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1101 { 832 {
1102 XGCValues gcv; 833 XGCValues gcv;
1103 GC gc; 834 GC gc;
1104 835
1105 /* In this case we can tint image server-side getting significant 836 /* In this case we can tint image server-side getting significant
… …
1114 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height); 845 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1115 ret = true; 846 ret = true;
1116 XFreeGC (dpy, gc); 847 XFreeGC (dpy, gc);
1117 } 848 }
1118 } 849 }
1119 else
1120 {
1121# if XRENDER 850# if XRENDER
851 else if (bg_flags & BG_HAS_RENDER)
852 {
1122 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC); 853 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1123 854
1124 if (bg_flags & BG_TINT_SET) 855 if (bg_flags & BG_TINT_SET)
1125 tint.get (c); 856 tint.get (c);
1126 857
… …
1135 c.r = c.r * (200 - shade) / 100; 866 c.r = c.r * (200 - shade) / 100;
1136 c.g = c.g * (200 - shade) / 100; 867 c.g = c.g * (200 - shade) / 100;
1137 c.b = c.b * (200 - shade) / 100; 868 c.b = c.b * (200 - shade) / 100;
1138 } 869 }
1139 870
1140 XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1141 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 871 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1142 XRenderPictureAttributes pa;
1143 872
1144 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 873 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1145 874
1146 pa.repeat = True; 875 Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1147 876
1148 Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32); 877 Picture mask_pic = create_xrender_mask (dpy, pixmap, True, True);
1149 Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1150 XFreePixmap (dpy, overlay_pmap);
1151
1152 pa.component_alpha = True;
1153 Pixmap mask_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
1154 Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat | CPComponentAlpha, &pa);
1155 XFreePixmap (dpy, mask_pmap);
1156 878
1157 XRenderColor mask_c; 879 XRenderColor mask_c;
1158 880
1159 mask_c.alpha = 0xffff; 881 mask_c.alpha = 0xffff;
1160 mask_c.red = 882 mask_c.red =
… …
1165 mask_c.alpha = 0; 887 mask_c.alpha = 0;
1166 mask_c.red = 0xffff - c.r; 888 mask_c.red = 0xffff - c.r;
1167 mask_c.green = 0xffff - c.g; 889 mask_c.green = 0xffff - c.g;
1168 mask_c.blue = 0xffff - c.b; 890 mask_c.blue = 0xffff - c.b;
1169 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1); 891 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
892
1170 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height); 893 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1171 894
1172 if (shade > 100) 895 if (shade > 100)
1173 { 896 {
1174 mask_c.red = mask_c.green = mask_c.blue = 0xffff * (shade - 100) / 100;
1175 mask_c.alpha = 0; 897 mask_c.alpha = 0;
898 mask_c.red =
899 mask_c.green =
900 mask_c.blue = 0xffff * (shade - 100) / 100;
1176 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1); 901 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1177 902
1178 XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height); 903 XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1179 } 904 }
1180 905
1181 ret = true; 906 ret = true;
1182 907
1183 XRenderFreePicture (dpy, mask_pic); 908 XRenderFreePicture (dpy, mask_pic);
1184 XRenderFreePicture (dpy, overlay_pic); 909 XRenderFreePicture (dpy, overlay_pic);
1185 XRenderFreePicture (dpy, back_pic); 910 XRenderFreePicture (dpy, back_pic);
911 }
1186# endif 912# endif
1187 }
1188 913
1189 return ret; 914 return ret;
1190} 915}
1191 916
1192/* 917/*
1193 * Builds a pixmap of the same size as the terminal window that contains 918 * Builds a pixmap of the same size as the terminal window that contains
1194 * the tiled portion of the root pixmap that is supposed to be covered by 919 * the tiled portion of the root pixmap that is supposed to be covered by
1195 * our window. 920 * our window.
1196 */ 921 */
1197unsigned long 922bool
1198rxvt_term::make_transparency_pixmap () 923rxvt_term::make_transparency_pixmap ()
1199{ 924{
1200 unsigned long result = 0; 925 bool ret = false;
1201 926
1202 /* root dimensions may change from call to call - but Display structure should 927 /* root dimensions may change from call to call - but Display structure should
1203 * be always up-to-date, so let's use it : 928 * be always up-to-date, so let's use it :
1204 */ 929 */
1205 int screen = display->screen; 930 int screen = display->screen;
… …
1243#if XRENDER 968#if XRENDER
1244 if (bg_flags & BG_HAS_RENDER) 969 if (bg_flags & BG_HAS_RENDER)
1245 { 970 {
1246 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth); 971 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1247 972
1248 XRenderPictureAttributes pa;
1249
1250 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen)); 973 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1251 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa); 974 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1252 975
1253 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual); 976 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1254 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa); 977 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1255 978
1256 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height); 979 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
1257 980
1258 XRenderFreePicture (dpy, src); 981 XRenderFreePicture (dpy, src);
1259 XRenderFreePicture (dpy, dst); 982 XRenderFreePicture (dpy, dst);
… …
1276 bg_pmap_width = window_width; 999 bg_pmap_width = window_width;
1277 bg_pmap_height = window_height; 1000 bg_pmap_height = window_height;
1278 } 1001 }
1279 1002
1280 /* straightforward pixmap copy */ 1003 /* straightforward pixmap copy */
1281 while (sx < 0) sx += root_width; 1004 while (sx < 0) sx += root_pmap_width;
1282 while (sy < 0) sy += root_height; 1005 while (sy < 0) sy += root_pmap_height;
1283 1006
1284 gcv.tile = recoded_root_pmap; 1007 gcv.tile = recoded_root_pmap;
1285 gcv.fill_style = FillTiled; 1008 gcv.fill_style = FillTiled;
1286 gcv.ts_x_origin = -sx; 1009 gcv.ts_x_origin = -sx;
1287 gcv.ts_y_origin = -sy; 1010 gcv.ts_y_origin = -sy;
1288 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); 1011 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1289 1012
1290 if (gc) 1013 if (gc)
1291 { 1014 {
1292 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height); 1015 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1293 result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS); 1016 ret = true;
1017 bool need_blur = h_blurRadius && v_blurRadius;
1018 bool need_tint = shade != 100 || (bg_flags & BG_TINT_SET);
1019
1020 if (!(bg_flags & BG_CLIENT_RENDER))
1021 {
1022 if (need_blur)
1023 {
1024 if (blur_pixmap (bg_pixmap, window_width, window_height))
1025 need_blur = false;
1026 }
1027 if (need_tint)
1028 {
1029 if (tint_pixmap (bg_pixmap, window_width, window_height))
1030 need_tint = false;
1031 }
1032 if (need_tint)
1033 {
1034 XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1035 if (ximage)
1036 {
1037 /* our own client-side tinting */
1038 tint_ximage (ximage);
1039
1040 XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
1041 XDestroyImage (ximage);
1042 }
1043 }
1044 } /* server side rendering completed */
1045
1294 XFreeGC (dpy, gc); 1046 XFreeGC (dpy, gc);
1295
1296 if (!(bg_flags & BG_CLIENT_RENDER))
1297 {
1298 if ((bg_flags & BG_NEEDS_BLUR)
1299 && (bg_flags & BG_HAS_RENDER_CONV))
1300 {
1301 if (blur_pixmap (bg_pixmap, visual, window_width, window_height))
1302 result &= ~BG_NEEDS_BLUR;
1303 }
1304 if ((bg_flags & BG_NEEDS_TINT)
1305 && (bg_flags & (BG_TINT_BITAND | BG_HAS_RENDER)))
1306 {
1307 if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1308 result &= ~BG_NEEDS_TINT;
1309 }
1310 } /* server side rendering completed */
1311 } 1047 }
1312 1048
1313 if (recoded_root_pmap != root_pixmap) 1049 if (recoded_root_pmap != root_pixmap)
1314 XFreePixmap (dpy, recoded_root_pmap); 1050 XFreePixmap (dpy, recoded_root_pmap);
1315 1051
1316 return result; 1052 return ret;
1317} 1053}
1318 1054
1319void 1055void
1320rxvt_term::bg_set_root_pixmap () 1056rxvt_term::bg_set_root_pixmap ()
1321{ 1057{
… …
1325 1061
1326 root_pixmap = new_root_pixmap; 1062 root_pixmap = new_root_pixmap;
1327} 1063}
1328# endif /* ENABLE_TRANSPARENCY */ 1064# endif /* ENABLE_TRANSPARENCY */
1329 1065
1330#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1331static void shade_ximage (Visual *visual, XImage *ximage, int shade, const rgba &c);
1332# endif
1333
1334bool 1066bool
1335rxvt_term::bg_render () 1067rxvt_term::bg_render ()
1336{ 1068{
1337 unsigned long tr_flags = 0; 1069 bool transparent = false;
1338 1070
1339 bg_invalidate (); 1071 bg_invalidate ();
1340# ifdef ENABLE_TRANSPARENCY 1072# ifdef ENABLE_TRANSPARENCY
1341 if (bg_flags & BG_IS_TRANSPARENT) 1073 if (bg_flags & BG_IS_TRANSPARENT)
1342 { 1074 {
1343 /* we need to re-generate transparency pixmap in that case ! */ 1075 /* we need to re-generate transparency pixmap in that case ! */
1344 tr_flags = make_transparency_pixmap (); 1076 transparent = make_transparency_pixmap ();
1345 if (tr_flags == 0) 1077 if (transparent)
1346 return false;
1347 bg_flags |= BG_IS_VALID; 1078 bg_flags |= BG_IS_VALID;
1348 } 1079 }
1349# endif 1080# endif
1350 1081
1351# ifdef BG_IMAGE_FROM_FILE 1082# ifdef BG_IMAGE_FROM_FILE
1352 if ((bg_flags & BG_IS_FROM_FILE) 1083 if (bg_image.flags & IM_IS_SET)
1353 || (tr_flags & BG_EFFECTS_FLAGS))
1354 { 1084 {
1355 if (render_image (tr_flags)) 1085 if (render_image (bg_image, transparent))
1356 bg_flags |= BG_IS_VALID; 1086 bg_flags |= BG_IS_VALID;
1357 }
1358# endif
1359
1360# if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1361 XImage *result = NULL;
1362
1363 if (tr_flags & BG_NEEDS_TINT)
1364 {
1365 result = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1366 }
1367
1368 if (result)
1369 {
1370 /* our own client-side tinting */
1371 //if (tr_flags & BG_NEEDS_TINT)
1372 if (1)
1373 {
1374 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1375 if (bg_flags & BG_TINT_SET)
1376 tint.get (c);
1377 shade_ximage (DefaultVisual (dpy, display->screen), result, shade, c);
1378 }
1379
1380 GC gc = XCreateGC (dpy, vt, 0UL, NULL);
1381
1382 if (gc)
1383 {
1384 XPutImage (dpy, bg_pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1385
1386 XFreeGC (dpy, gc);
1387 }
1388
1389 XDestroyImage (result);
1390 } 1087 }
1391# endif 1088# endif
1392 1089
1393 if (!(bg_flags & BG_IS_VALID)) 1090 if (!(bg_flags & BG_IS_VALID))
1394 { 1091 {
… …
1431#endif 1128#endif
1432} 1129}
1433 1130
1434#endif /* HAVE_BG_PIXMAP */ 1131#endif /* HAVE_BG_PIXMAP */
1435 1132
1436#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) 1133#ifdef ENABLE_TRANSPARENCY
1437/* based on code from aterm-0.4.2 */ 1134/* based on code from aterm-0.4.2 */
1438 1135
1439static void 1136static inline void
1440shade_ximage (Visual *visual, XImage *ximage, int shade, const rgba &c) 1137fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
1441{ 1138{
1139 for (int i = 0; i <= mask >> sh; i++)
1140 {
1141 uint32_t tmp;
1142 tmp = i * high;
1143 tmp += (mask >> sh) * low;
1144 lookup[i] = (tmp / 0xffff) << sh;
1145 }
1146}
1147
1148void
1149rxvt_term::tint_ximage (XImage *ximage)
1150{
1151 unsigned int size_r, size_g, size_b;
1442 int sh_r, sh_g, sh_b; 1152 int sh_r, sh_g, sh_b;
1443 uint32_t mask_r, mask_g, mask_b; 1153 uint32_t mask_r, mask_g, mask_b;
1444 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b; 1154 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1445 rgba low; 1155 unsigned short low;
1446 rgba high;
1447 int i;
1448 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst; 1156 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1449 1157
1450 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return; 1158 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;
1451 1159
1452 /* for convenience */ 1160 /* for convenience */
1453 mask_r = visual->red_mask; 1161 mask_r = visual->red_mask;
1454 mask_g = visual->green_mask; 1162 mask_g = visual->green_mask;
1455 mask_b = visual->blue_mask; 1163 mask_b = visual->blue_mask;
1456 1164
1457 /* boring lookup table pre-initialization */ 1165 /* boring lookup table pre-initialization */
1458 switch (ximage->depth) 1166 sh_r = ecb_ctz32 (mask_r);
1459 { 1167 sh_g = ecb_ctz32 (mask_g);
1460 case 15: 1168 sh_b = ecb_ctz32 (mask_b);
1461 if ((mask_r != 0x7c00) || 1169
1462 (mask_g != 0x03e0) || 1170 size_r = mask_r >> sh_r;
1463 (mask_b != 0x001f)) 1171 size_g = mask_g >> sh_g;
1172 size_b = mask_b >> sh_b;
1173
1174 if (size_r++ > 255 || size_g++ > 255 || size_b++ > 255)
1464 return; 1175 return;
1465 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+32+32)); 1176
1177 lookup = (uint32_t *)malloc (sizeof (uint32_t) * (size_r + size_g + size_b));
1466 lookup_r = lookup; 1178 lookup_r = lookup;
1467 lookup_g = lookup+32; 1179 lookup_g = lookup + size_r;
1468 lookup_b = lookup+32+32; 1180 lookup_b = lookup + size_r + size_g;
1469 sh_r = 10; 1181
1470 sh_g = 5; 1182 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1471 sh_b = 0; 1183
1472 break; 1184 if (bg_flags & BG_TINT_SET)
1473 case 16: 1185 tint.get (c);
1474 if ((mask_r != 0xf800) ||
1475 (mask_g != 0x07e0) ||
1476 (mask_b != 0x001f))
1477 return;
1478 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+64+32));
1479 lookup_r = lookup;
1480 lookup_g = lookup+32;
1481 lookup_b = lookup+32+64;
1482 sh_r = 11;
1483 sh_g = 5;
1484 sh_b = 0;
1485 break;
1486 case 24:
1487 if ((mask_r != 0xff0000) ||
1488 (mask_g != 0x00ff00) ||
1489 (mask_b != 0x0000ff))
1490 return;
1491 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(256+256+256));
1492 lookup_r = lookup;
1493 lookup_g = lookup+256;
1494 lookup_b = lookup+256+256;
1495 sh_r = 16;
1496 sh_g = 8;
1497 sh_b = 0;
1498 break;
1499 case 32:
1500 if ((mask_r != 0xff0000) ||
1501 (mask_g != 0x00ff00) ||
1502 (mask_b != 0x0000ff))
1503 return;
1504 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(256+256+256));
1505 lookup_r = lookup;
1506 lookup_g = lookup+256;
1507 lookup_b = lookup+256+256;
1508 sh_r = 16;
1509 sh_g = 8;
1510 sh_b = 0;
1511 break;
1512 default:
1513 return; /* we do not support this color depth */
1514 }
1515 1186
1516 /* prepare limits for color transformation (each channel is handled separately) */ 1187 /* prepare limits for color transformation (each channel is handled separately) */
1517 if (shade > 100) 1188 if (shade > 100)
1518 { 1189 {
1519 shade = 200 - shade;
1520
1521 high.r = c.r * shade / 100;
1522 high.g = c.g * shade / 100;
1523 high.b = c.b * shade / 100;
1524
1525 low.r = 65535 * (100 - shade) / 100; 1190 c.r = c.r * (200 - shade) / 100;
1526 low.g = 65535 * (100 - shade) / 100; 1191 c.g = c.g * (200 - shade) / 100;
1527 low.b = 65535 * (100 - shade) / 100; 1192 c.b = c.b * (200 - shade) / 100;
1193
1194 low = 0xffff * (shade - 100) / 100;
1528 } 1195 }
1529 else 1196 else
1530 { 1197 {
1531 high.r = c.r * shade / 100; 1198 c.r = c.r * shade / 100;
1532 high.g = c.g * shade / 100; 1199 c.g = c.g * shade / 100;
1533 high.b = c.b * shade / 100; 1200 c.b = c.b * shade / 100;
1534 1201
1535 low.r = low.g = low.b = 0; 1202 low = 0;
1536 } 1203 }
1537 1204
1538 /* fill our lookup tables */ 1205 /* fill our lookup tables */
1539 for (i = 0; i <= mask_r>>sh_r; i++) 1206 fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1540 { 1207 fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1541 uint32_t tmp; 1208 fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1542 tmp = i * high.r;
1543 tmp += (mask_r>>sh_r) * low.r;
1544 lookup_r[i] = (tmp/65535)<<sh_r;
1545 }
1546 for (i = 0; i <= mask_g>>sh_g; i++)
1547 {
1548 uint32_t tmp;
1549 tmp = i * high.g;
1550 tmp += (mask_g>>sh_g) * low.g;
1551 lookup_g[i] = (tmp/65535)<<sh_g;
1552 }
1553 for (i = 0; i <= mask_b>>sh_b; i++)
1554 {
1555 uint32_t tmp;
1556 tmp = i * high.b;
1557 tmp += (mask_b>>sh_b) * low.b;
1558 lookup_b[i] = (tmp/65535)<<sh_b;
1559 }
1560 1209
1561 /* apply table to input image (replacing colors by newly calculated ones) */ 1210 /* apply table to input image (replacing colors by newly calculated ones) */
1562 if (ximage->bits_per_pixel == 32 1211 if (ximage->bits_per_pixel == 32
1563 && (ximage->depth == 24 || ximage->depth == 32)
1564 && ximage->byte_order == host_byte_order) 1212 && ximage->byte_order == host_byte_order)
1565 { 1213 {
1566 uint32_t *p1, *pf, *p, *pl; 1214 char *line = ximage->data;
1567 p1 = (uint32_t *) ximage->data;
1568 pf = (uint32_t *) (ximage->data + ximage->height * ximage->bytes_per_line);
1569 1215
1570 while (p1 < pf) 1216 for (int y = 0; y < ximage->height; y++)
1571 {
1572 p = p1;
1573 pl = p1 + ximage->width;
1574 for (; p < pl; p++)
1575 { 1217 {
1576 *p = lookup_r[(*p & 0xff0000) >> 16] | 1218 uint32_t *p = (uint32_t *)line;
1577 lookup_g[(*p & 0x00ff00) >> 8] | 1219 for (int x = 0; x < ximage->width; x++)
1578 lookup_b[(*p & 0x0000ff)] |
1579 (*p & 0xff000000);
1580 } 1220 {
1581 p1 = (uint32_t *) ((char *) p1 + ximage->bytes_per_line); 1221 *p = lookup_r[(*p & mask_r) >> sh_r] |
1222 lookup_g[(*p & mask_g) >> sh_g] |
1223 lookup_b[(*p & mask_b) >> sh_b];
1224 p++;
1225 }
1226 line += ximage->bytes_per_line;
1582 } 1227 }
1583 } 1228 }
1584 else 1229 else
1585 { 1230 {
1586 for (int y = 0; y < ximage->height; y++) 1231 for (int y = 0; y < ximage->height; y++)
… …
1594 } 1239 }
1595 } 1240 }
1596 1241
1597 free (lookup); 1242 free (lookup);
1598} 1243}
1599#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */ 1244#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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