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.144 by sf-exg, Fri Jan 28 00:20:47 2011 UTC vs.
Revision 1.208 by sf-exg, Fri May 11 08:16:58 2012 UTC

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

Diff Legend

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