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.101 by sf-exg, Sun Oct 31 08:28:04 2010 UTC vs.
Revision 1.222 by sf-exg, Sat May 26 08:10:25 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-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#define DO_TIMING_TEST 0 29#if XRENDER
30 30# include <X11/extensions/Xrender.h>
31#if DO_TIMING_TEST
32# include <sys/time.h>
33#define TIMING_TEST_START(id) \
34 struct timeval timing_test_##id##_stv; \
35 gettimeofday (&timing_test_##id##_stv, NULL);
36
37#define TIMING_TEST_PRINT_RESULT(id) \
38 do { \
39 struct timeval tv; \
40 gettimeofday (&tv, NULL); \
41 tv.tv_sec -= (timing_test_##id##_stv).tv_sec; \
42 fprintf (stderr, "%s: %s: %d: elapsed %ld usec\n", #id, __FILE__, __LINE__, \
43 tv.tv_sec * 1000000 + tv.tv_usec - (timing_test_##id##_stv).tv_usec); \
44 } while (0)
45
46#else
47#define TIMING_TEST_START(id) do {} while (0)
48#define TIMING_TEST_PRINT_RESULT(id) do {} while (0)
49#endif 31#endif
50 32
51/* 33#ifndef FilterConvolution
52 * Pixmap geometry string interpretation : 34#define FilterConvolution "convolution"
53 * Each geometry string contains zero or one scale/position 35#endif
54 * adjustment and may optionally be followed by a colon and one or more 36
55 * colon-delimited pixmap operations. 37#ifndef RepeatPad
56 * The following table shows the valid geometry strings and their 38#define RepeatPad True
57 * effects on the background image : 39#endif
58 *
59 * WxH+X+Y Set scaling to W% by H%, and position to X% by Y%.
60 * W and H are percentages of the terminal window size.
61 * X and Y are also percentages; e.g., +50+50 centers
62 * the image in the window.
63 * WxH+X Assumes Y == X
64 * WxH Assumes Y == X == 50 (centers the image)
65 * W+X+Y Assumes H == W
66 * W+X Assumes H == W and Y == X
67 * W Assumes H == W and Y == X == 50
68 *
69 * Adjusting position only :
70 * =+X+Y Set position to X% by Y% (absolute).
71 * =+X Set position to X% by X%.
72 * +X+Y Adjust position horizontally X% and vertically Y%
73 * from current position (relative).
74 * +X Adjust position horizontally X% and vertically X%
75 * from current position.
76 *
77 * Adjusting scale only :
78 * Wx0 Multiply horizontal scaling factor by W%
79 * 0xH Multiply vertical scaling factor by H%
80 * 0x0 No scaling (show image at normal size).
81 *
82 * Pixmap Operations : (should be prepended by a colon)
83 * tile Tile image. Scaling/position modifiers above will affect
84 * the tile size and origin.
85 * propscale When scaling, scale proportionally. That is, maintain the
86 * proper aspect ratio for the image. Any portion of the
87 * background not covered by the image is filled with the
88 * current background color.
89 * hscale Scale horizontally, tile vertically ?
90 * vscale Tile horizontally, scale vertically ?
91 * scale Scale both up and down
92 * auto Same as 100x100+50+50
93 */
94 40
95#ifdef HAVE_BG_PIXMAP 41#ifdef HAVE_BG_PIXMAP
96bgPixmap_t::bgPixmap_t () 42# if XRENDER
43static Picture
44create_xrender_mask (Display *dpy, Drawable drawable, Bool argb, Bool component_alpha)
97{ 45{
98 // this is basically redundant as bgPixmap_t is only used in 46 Pixmap pixmap = XCreatePixmap (dpy, drawable, 1, 1, argb ? 32 : 8);
99 // zero_initialised-derived structs 47
100#ifdef HAVE_AFTERIMAGE 48 XRenderPictFormat *format = XRenderFindStandardFormat (dpy, argb ? PictStandardARGB32 : PictStandardA8);
101 original_asim = NULL; 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}
102#endif 58# endif
103#ifdef HAVE_PIXBUF
104 pixbuf = NULL;
105#endif
106#ifdef BG_IMAGE_FROM_FILE
107 have_image = false;
108 h_scale = v_scale = 0;
109 h_align = v_align = 0;
110#endif
111#ifdef ENABLE_TRANSPARENCY
112 shade = 100;
113#endif
114 flags = 0;
115 pixmap = None;
116 valid_since = invalid_since = 0;
117 target = 0;
118}
119 59
120void 60void
121bgPixmap_t::destroy () 61rxvt_term::bg_destroy ()
122{ 62{
123#ifdef HAVE_AFTERIMAGE 63# ifdef BG_IMAGE_FROM_FILE
124 if (original_asim) 64 for (vector<rxvt_image>::iterator bg_image = image_vec.begin (); bg_image < image_vec.end (); bg_image++)
125 safe_asimage_destroy (original_asim); 65 bg_image->destroy ();
126#endif 66# endif
127 67
128#ifdef HAVE_PIXBUF 68 if (bg_pixmap)
129 if (pixbuf)
130 g_object_unref (pixbuf);
131#endif
132
133 if (pixmap && target)
134 XFreePixmap (target->dpy, pixmap); 69 XFreePixmap (dpy, bg_pixmap);
135} 70}
136 71
137bool 72bool
138bgPixmap_t::window_size_sensitive () 73rxvt_term::bg_set_position (int x, int y)
74{
75
76 if (target_x != x
77 || target_y != y)
78 {
79 target_x = x;
80 target_y = y;
81 return true;
82 }
83 return false;
84}
85
86bool
87rxvt_term::bg_window_size_sensitive ()
139{ 88{
140# ifdef ENABLE_TRANSPARENCY 89# ifdef ENABLE_TRANSPARENCY
141 if (flags & isTransparent) 90 if (bg_flags & BG_IS_TRANSPARENT)
142 return true; 91 return true;
143# endif 92# endif
144 93
145# ifdef BG_IMAGE_FROM_FILE 94# ifdef BG_IMAGE_FROM_FILE
146 if (have_image) 95 for (vector<rxvt_image>::iterator bg_image = image_vec.begin (); bg_image < image_vec.end (); bg_image++)
147 { 96 {
148 if (flags & sizeSensitive) 97 if ((bg_image->flags & IM_IS_SIZE_SENSITIVE)
98 || bg_image->width () > szHint.width
99 || bg_image->height () > szHint.height)
149 return true; 100 return true;
150 } 101 }
151# endif 102# endif
152 103
153 return false; 104 return false;
154} 105}
155 106
156bool 107bool
157bgPixmap_t::window_position_sensitive () 108rxvt_term::bg_window_position_sensitive ()
158{ 109{
159# ifdef ENABLE_TRANSPARENCY 110# ifdef ENABLE_TRANSPARENCY
160 if (flags & isTransparent) 111 if (bg_flags & BG_IS_TRANSPARENT)
161 return true; 112 return true;
162# endif 113# endif
163 114
164# ifdef BG_IMAGE_FROM_FILE 115# ifdef BG_IMAGE_FROM_FILE
165 if (have_image) 116 for (vector<rxvt_image>::iterator bg_image = image_vec.begin (); bg_image < image_vec.end (); bg_image++)
166 { 117 {
167 if (flags & rootAlign) 118 if (bg_image->flags & IM_ROOT_ALIGN)
168 return true; 119 return true;
169 } 120 }
170# endif 121# endif
171 122
172 return false; 123 return false;
173};
174
175bool bgPixmap_t::need_client_side_rendering ()
176{
177# ifdef HAVE_AFTERIMAGE
178 if (original_asim)
179 return true;
180# endif
181 return false;
182} 124}
183 125
184# ifdef BG_IMAGE_FROM_FILE 126# ifdef BG_IMAGE_FROM_FILE
185static inline bool
186check_set_scale_value (int geom_flags, int flag, unsigned int &scale, unsigned int new_value)
187{
188 if (geom_flags & flag)
189 {
190 if (new_value > 1000)
191 new_value = 1000;
192 if (new_value != scale)
193 {
194 scale = new_value;
195 return true;
196 }
197 }
198 return false;
199}
200
201static inline bool
202check_set_align_value (int geom_flags, int flag, int &align, int new_value)
203{
204 if (geom_flags & flag)
205 {
206 if (new_value < -100)
207 new_value = -100;
208 else if (new_value > 200)
209 new_value = 200;
210 if (new_value != align)
211 {
212 align = new_value;
213 return true;
214 }
215 }
216 return false;
217}
218
219static inline int 127static inline int
220make_align_position (int align, int window_size, int image_size) 128make_align_position (int align, int window_size, int image_size)
221{ 129{
222 int diff = window_size - image_size;
223 int smaller = min (image_size, window_size);
224
225 if (align >= 0 && align <= 100) 130 if (align >= 0 && align <= 100)
226 return diff * align / 100; 131 return lerp (0, window_size - image_size, align);
227 else if (align > 100 && align <= 200) 132 else if (align > 100)
228 return ((align - 100) * smaller / 100) + window_size - smaller; 133 return lerp (window_size - image_size, window_size, align - 100);
229 else if (align >= -100 && align < 0) 134 else
230 return ((align + 100) * smaller / 100) - image_size; 135 return lerp (-image_size, 0, align + 100);
231 return 0;
232} 136}
233 137
234static inline int 138static inline int
235make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size) 139make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)
236{ 140{
… …
242 src_pos = -pos; 146 src_pos = -pos;
243 dst_pos = 0; 147 dst_pos = 0;
244 dst_size += pos; 148 dst_size += pos;
245 } 149 }
246 150
247 if (dst_pos + dst_size > target_size)
248 dst_size = target_size - dst_pos; 151 min_it (dst_size, target_size - dst_pos);
249 return src_pos; 152 return src_pos;
250} 153}
251 154
252bool 155static void
253bgPixmap_t::set_geometry (const char *geom) 156parse_style (const char *style, int &x, int &y, unsigned int &w, unsigned int &h, uint8_t &flags)
254{ 157{
158 if (!strcasecmp (style, "tiled"))
159 {
160 flags = IM_TILE;
161 w = h = noScale;
162 x = y = 0;
163 }
164 else if (!strcasecmp (style, "aspect-stretched"))
165 {
166 flags = IM_KEEP_ASPECT;
167 w = h = windowScale;
168 x = y = centerAlign;
169 }
170 else if (!strcasecmp (style, "stretched"))
171 {
172 flags = 0;
173 w = h = windowScale;
174 x = y = centerAlign;
175 }
176 else if (!strcasecmp (style, "centered"))
177 {
178 flags = 0;
179 w = h = noScale;
180 x = y = centerAlign;
181 }
182 else if (!strcasecmp (style, "root-tiled"))
183 {
184 flags = IM_TILE|IM_ROOT_ALIGN;
185 w = h = noScale;
186 x = y = 0;
187 }
188}
189
190bool
191rxvt_image::set_geometry (const char *geom, bool update)
192{
193 bool changed = false;
255 int geom_flags = 0, changed = 0; 194 int geom_flags = 0;
256 int x = 0, y = 0; 195 int x = h_align;
196 int y = v_align;
257 unsigned int w = 0, h = 0; 197 unsigned int w = h_scale;
258 unsigned int n; 198 unsigned int h = v_scale;
259 unsigned long new_flags = (flags & (~geometryFlags)); 199 uint8_t new_flags = 0;
260 const char *p;
261# define MAXLEN_GEOM 256 /* could be longer than regular geometry string */
262 200
263 if (geom == NULL) 201 if (geom == NULL)
264 return false; 202 return false;
265 203
266 char str[MAXLEN_GEOM]; 204 if (geom[0])
267
268 while (isspace(*geom)) ++geom;
269 if ((p = strchr (geom, ';')) == NULL)
270 p = strchr (geom, '\0');
271
272 n = (p - geom);
273 if (n < MAXLEN_GEOM)
274 { 205 {
275 char *ops; 206 char **arr = rxvt_strsplit (':', geom);
276 new_flags |= geometrySet;
277 207
278 memcpy (str, geom, n); 208 for (int i = 0; arr[i]; i++)
279 str[n] = '\0';
280 if (str[0] == ':')
281 ops = &str[0];
282 else if (str[0] != 'x' && str[0] != 'X' && isalpha(str[0]))
283 ops = &str[0];
284 else
285 { 209 {
286 char *tmp; 210 if (!strncasecmp (arr[i], "style=", 6))
287 ops = strchr (str, ':');
288 if (ops != NULL)
289 { 211 {
290 for (tmp = ops-1; tmp >= str && isspace(*tmp); --tmp); 212 parse_style (arr[i] + 6, x, y, w, h, new_flags);
291 *(++tmp) = '\0'; 213 geom_flags = WidthValue|HeightValue|XValue|YValue;
292 if (ops == tmp) ++ops;
293 } 214 }
294 } 215 else if (!strcasecmp (arr[i], "op=tile"))
216 new_flags |= IM_TILE;
217 else if (!strcasecmp (arr[i], "op=keep-aspect"))
218 new_flags |= IM_KEEP_ASPECT;
219 else if (!strcasecmp (arr[i], "op=root-align"))
220 new_flags |= IM_ROOT_ALIGN;
295 221
296 if (ops > str || ops == NULL) 222 // deprecated
297 { 223 else if (!strcasecmp (arr[i], "tile"))
298 /* we have geometry string - let's handle it prior to applying ops */
299 geom_flags = XParseGeometry (str, &x, &y, &w, &h);
300
301 if ((geom_flags & XValue) && !(geom_flags & YValue))
302 { 224 {
303 y = x; 225 new_flags |= IM_TILE;
226 w = h = noScale;
304 geom_flags |= YValue; 227 geom_flags |= WidthValue|HeightValue;
305 } 228 }
306 229 else if (!strcasecmp (arr[i], "propscale"))
307 if (flags & geometrySet)
308 { 230 {
309 /* new geometry is an adjustment to the old one ! */ 231 new_flags |= IM_KEEP_ASPECT;
232 w = h = windowScale;
310 if ((geom_flags & WidthValue) && (geom_flags & HeightValue)) 233 geom_flags |= WidthValue|HeightValue;
311 {
312 if (w == 0 && h != 0)
313 {
314 w = h_scale;
315 h = (v_scale * h) / 100;
316 }
317 else if (h == 0 && w != 0)
318 {
319 w = (h_scale * w) / 100;
320 h = v_scale;
321 }
322 }
323 if (geom_flags & XValue)
324 {
325 if (str[0] != '=')
326 {
327 y += v_align;
328 x += h_align;
329 }
330 }
331 } 234 }
332 else /* setting up geometry from scratch */ 235 else if (!strcasecmp (arr[i], "hscale"))
333 { 236 {
334 if (!(geom_flags & XValue)) 237 new_flags |= IM_TILE;
335 { 238 w = windowScale;
336 /* use default geometry - centered */
337 x = y = defaultAlign;
338 }
339 else if (!(geom_flags & YValue))
340 y = x; 239 h = noScale;
341
342 if ((geom_flags & (WidthValue|HeightValue)) == 0) 240 geom_flags |= WidthValue|HeightValue;
343 {
344 /* use default geometry - scaled */
345 w = h = defaultScale;
346 }
347 else if (geom_flags & WidthValue)
348 {
349 if (!(geom_flags & HeightValue))
350 h = w;
351 }
352 else
353 w = h;
354 } 241 }
355 } /* done parsing geometry string */ 242 else if (!strcasecmp (arr[i], "vscale"))
356 else if (!(flags & geometrySet))
357 {
358 /* default geometry - scaled and centered */
359 x = y = defaultAlign;
360 w = h = defaultScale;
361 }
362
363 if (!(flags & geometrySet))
364 geom_flags |= WidthValue|HeightValue|XValue|YValue;
365
366 if (ops)
367 {
368 while (*ops)
369 { 243 {
370 while (*ops == ':' || isspace(*ops)) ++ops; 244 new_flags |= IM_TILE;
371 245 h = windowScale;
372# define CHECK_GEOM_OPS(op_str) (strncasecmp (ops, (op_str), sizeof (op_str) - 1) == 0)
373 if (CHECK_GEOM_OPS ("tile"))
374 {
375 w = h = noScale; 246 w = noScale;
376 geom_flags |= WidthValue|HeightValue; 247 geom_flags |= WidthValue|HeightValue;
377 } 248 }
378 else if (CHECK_GEOM_OPS ("propscale")) 249 else if (!strcasecmp (arr[i], "scale"))
379 { 250 {
380 new_flags |= propScale;
381 }
382 else if (CHECK_GEOM_OPS ("hscale"))
383 {
384 if (w == 0) w = windowScale;
385
386 h = noScale; 251 w = h = windowScale;
387 geom_flags |= WidthValue|HeightValue; 252 geom_flags |= WidthValue|HeightValue;
388 } 253 }
389 else if (CHECK_GEOM_OPS ("vscale")) 254 else if (!strcasecmp (arr[i], "auto"))
390 { 255 {
391 if (h == 0) h = windowScale;
392
393 w = noScale;
394 geom_flags |= WidthValue|HeightValue;
395 }
396 else if (CHECK_GEOM_OPS ("scale"))
397 {
398 if (h == 0) h = windowScale;
399 if (w == 0) w = windowScale;
400
401 geom_flags |= WidthValue|HeightValue;
402 }
403 else if (CHECK_GEOM_OPS ("auto"))
404 {
405 w = h = windowScale; 256 w = h = windowScale;
406 x = y = centerAlign; 257 x = y = centerAlign;
407 geom_flags |= WidthValue|HeightValue|XValue|YValue; 258 geom_flags |= WidthValue|HeightValue|XValue|YValue;
408 } 259 }
409 else if (CHECK_GEOM_OPS ("root")) 260 else if (!strcasecmp (arr[i], "root"))
410 { 261 {
411 new_flags |= rootAlign; 262 new_flags |= IM_TILE|IM_ROOT_ALIGN;
412 w = h = noScale; 263 w = h = noScale;
413 geom_flags |= WidthValue|HeightValue; 264 geom_flags |= WidthValue|HeightValue;
414 } 265 }
415# undef CHECK_GEOM_OPS
416 266
417 while (*ops != ':' && *ops != '\0') ++ops; 267 else
268 geom_flags |= XParseGeometry (arr[i], &x, &y, &w, &h);
418 } /* done parsing ops */ 269 } /* done parsing ops */
419 }
420 270
421 if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) ++changed; 271 rxvt_free_strsplit (arr);
422 if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) ++changed; 272 }
423 if (check_set_align_value (geom_flags, XValue, h_align, x)) ++changed; 273
424 if (check_set_align_value (geom_flags, YValue, v_align, y)) ++changed; 274 new_flags |= flags & ~IM_GEOMETRY_FLAGS;
275
276 if (!update)
425 } 277 {
278 if (!(geom_flags & XValue))
279 x = y = defaultAlign;
280 else if (!(geom_flags & YValue))
281 y = x;
426 282
427 if (new_flags != flags) 283 if (!(geom_flags & (WidthValue|HeightValue)))
284 w = h = defaultScale;
285 else if (!(geom_flags & HeightValue))
286 h = w;
287 else if (!(geom_flags & WidthValue))
288 w = h;
289 }
290
291 clamp_it (x, -100, 200);
292 clamp_it (y, -100, 200);
293
294 if (flags != new_flags
295 || h_scale != w
296 || v_scale != h
297 || h_align != x
298 || v_align != y)
428 { 299 {
429 flags = new_flags; 300 flags = new_flags;
301 h_scale = w;
302 v_scale = h;
303 h_align = x;
304 v_align = y;
430 changed++; 305 changed = true;
431 } 306 }
432 307
308 if (!(flags & IM_TILE)
309 || h_scale || v_scale
310 || (!(flags & IM_ROOT_ALIGN) && (h_align || v_align)))
311 flags |= IM_IS_SIZE_SENSITIVE;
312 else
313 flags &= ~IM_IS_SIZE_SENSITIVE;
314
433 return (changed > 0); 315 return changed;
434} 316}
435 317
436void 318void
437bgPixmap_t::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y) 319rxvt_term::get_image_geometry (rxvt_image &image, int &w, int &h, int &x, int &y)
438{ 320{
321 int image_width = image.width ();
322 int image_height = image.height ();
439 int target_width = target->szHint.width; 323 int target_width = szHint.width;
440 int target_height = target->szHint.height; 324 int target_height = szHint.height;
325 int h_scale = min (image.h_scale, 32767 * 100 / target_width);
326 int v_scale = min (image.v_scale, 32767 * 100 / target_height);
441 327
442 if (flags & propScale) 328 w = h_scale * target_width / 100;
329 h = v_scale * target_height / 100;
330
331 if (image.flags & IM_KEEP_ASPECT)
443 { 332 {
444 float scale = (float)target_width / image_width; 333 float scale = (float)w / image_width;
445 min_it (scale, (float)target_height / image_height); 334 min_it (scale, (float)h / image_height);
446 w = image_width * scale + 0.5; 335 w = image_width * scale + 0.5;
447 h = image_height * scale + 0.5; 336 h = image_height * scale + 0.5;
448 } 337 }
449 else
450 {
451 w = h_scale * target_width / 100;
452 h = v_scale * target_height / 100;
453 }
454 338
455 if (!w) w = image_width; 339 if (!w) w = image_width;
456 if (!h) h = image_height; 340 if (!h) h = image_height;
457 341
458 if (flags & rootAlign) 342 if (image.flags & IM_ROOT_ALIGN)
459 { 343 {
460 target->get_window_origin (x, y);
461 x = -x; 344 x = -target_x;
462 y = -y; 345 y = -target_y;
463 } 346 }
464 else 347 else
465 { 348 {
466 x = make_align_position (h_align, target_width, w); 349 x = make_align_position (image.h_align, target_width, w);
467 y = make_align_position (v_align, target_height, h); 350 y = make_align_position (image.v_align, target_height, h);
468 } 351 }
469
470 flags &= ~sizeSensitive;
471 if ((flags & propScale) || h_scale || v_scale
472 || (!(flags & rootAlign) && (h_align || v_align))
473 || w > target_width || h > target_height)
474 flags |= sizeSensitive;
475} 352}
476 353
477# ifdef HAVE_AFTERIMAGE 354# ifdef HAVE_PIXBUF
478bool 355bool
479bgPixmap_t::render_image (unsigned long background_flags) 356rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
357 int src_x, int src_y, int dst_x, int dst_y,
358 unsigned int width, unsigned int height, bool argb)
480{ 359{
481 if (target == NULL) 360 XImage *ximage;
361 char *line;
362 int width_r, width_g, width_b, width_a;
363 int sh_r, sh_g, sh_b, sh_a;
364 uint32_t red_mask, green_mask, blue_mask, alpha_mask;
365 int rowstride;
366 int channels;
367 unsigned char *row;
368
369 if (visual->c_class != TrueColor)
482 return false; 370 return false;
483 371
484 target->init_asv (); 372 if (argb)
485
486 ASImage *background = NULL;
487 ARGB32 background_tint = TINT_LEAVE_SAME;
488
489# ifdef ENABLE_TRANSPARENCY
490 if (background_flags)
491 background = pixmap2ximage (target->asv, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, 100);
492
493 if (!(background_flags & transpPmapTinted) && (flags & tintNeeded))
494 {
495 ShadingInfo as_shade;
496 as_shade.shading = shade;
497
498 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
499 if (flags & tintSet)
500 tint.get (c);
501 as_shade.tintColor.red = c.r;
502 as_shade.tintColor.green = c.g;
503 as_shade.tintColor.blue = c.b;
504
505 background_tint = shading2tint32 (&as_shade);
506 } 373 {
507 374 red_mask = 0xff << 16;
508 if (!(background_flags & transpPmapBlurred) && (flags & blurNeeded) && background != NULL) 375 green_mask = 0xff << 8;
376 blue_mask = 0xff;
377 alpha_mask = 0xff << 24;
509 { 378 }
510 ASImage *tmp = blur_asimage_gauss (target->asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF, 379 else
511 (original_asim == NULL || tint == TINT_LEAVE_SAME) ? ASA_XImage : ASA_ASImage, 380 {
512 100, ASIMAGE_QUALITY_DEFAULT); 381 red_mask = visual->red_mask;
382 green_mask = visual->green_mask;
383 blue_mask = visual->blue_mask;
384#if XRENDER
385 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
513 if (tmp) 386 if (format)
387 alpha_mask = (uint32_t)format->direct.alphaMask << format->direct.alpha;
388 else
389#endif
390 alpha_mask = 0;
391 }
392
393 width_r = ecb_popcount32 (red_mask);
394 width_g = ecb_popcount32 (green_mask);
395 width_b = ecb_popcount32 (blue_mask);
396 width_a = ecb_popcount32 (alpha_mask);
397
398 if (width_r > 8 || width_g > 8 || width_b > 8 || width_a > 8)
399 return false;
400
401 sh_r = ecb_ctz32 (red_mask);
402 sh_g = ecb_ctz32 (green_mask);
403 sh_b = ecb_ctz32 (blue_mask);
404 sh_a = ecb_ctz32 (alpha_mask);
405
406 if (width > 32767 || height > 32767)
407 return false;
408
409 ximage = XCreateImage (dpy, visual, argb ? 32 : depth, ZPixmap, 0, 0,
410 width, height, 32, 0);
411 if (!ximage)
412 return false;
413
414 if (height > INT_MAX / ximage->bytes_per_line
415 || !(ximage->data = (char *)malloc (height * ximage->bytes_per_line)))
416 {
417 XDestroyImage (ximage);
418 return false;
419 }
420
421 ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
422
423 rowstride = gdk_pixbuf_get_rowstride (pixbuf);
424 channels = gdk_pixbuf_get_n_channels (pixbuf);
425 row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels;
426 line = ximage->data;
427
428 rgba c (0, 0, 0);
429
430 if (channels == 4 && alpha_mask == 0)
431 {
432 pix_colors[Color_bg].get (c);
433 c.r >>= 8;
434 c.g >>= 8;
435 c.b >>= 8;
436 }
437
438 for (int y = 0; y < height; y++)
439 {
440 for (int x = 0; x < width; x++)
441 {
442 unsigned char *pixel = row + x * channels;
443 uint32_t value;
444 unsigned char r, g, b, a;
445
446 if (channels == 4)
514 { 447 {
515 destroy_asimage (&background); 448 a = pixel[3];
516 background = tmp; 449 r = (pixel[0] * a + c.r * (0xff - a)) / 0xff;
450 g = (pixel[1] * a + c.g * (0xff - a)) / 0xff;
451 b = (pixel[2] * a + c.b * (0xff - a)) / 0xff;
452 }
453 else
454 {
455 a = 0xff;
456 r = pixel[0];
457 g = pixel[1];
458 b = pixel[2];
459 }
460
461 value = ((r >> (8 - width_r)) << sh_r)
462 | ((g >> (8 - width_g)) << sh_g)
463 | ((b >> (8 - width_b)) << sh_b)
464 | ((a >> (8 - width_a)) << sh_a);
465
466 if (ximage->bits_per_pixel == 32)
467 ((uint32_t *)line)[x] = value;
468 else
469 XPutPixel (ximage, x, y, value);
517 } 470 }
518 }
519# endif
520 471
521 ASImage *result = 0; 472 row += rowstride;
473 line += ximage->bytes_per_line;
474 }
522 475
476 XPutImage (dpy, pixmap, gc, ximage, 0, 0, dst_x, dst_y, width, height);
477 XDestroyImage (ximage);
478 return true;
479}
480
481bool
482rxvt_term::render_image (rxvt_image &image)
483{
484 GdkPixbuf *pixbuf = image.pixbuf;
485 if (!pixbuf)
486 return false;
487
488 bool need_blend = bg_flags & BG_IS_VALID;
489
490 if (need_blend
491 && !(bg_flags & BG_HAS_RENDER))
492 return false;
493
494 GdkPixbuf *result;
495
496 int image_width = gdk_pixbuf_get_width (pixbuf);
497 int image_height = gdk_pixbuf_get_height (pixbuf);
498
523 int target_width = target->szHint.width; 499 int target_width = szHint.width;
524 int target_height = target->szHint.height; 500 int target_height = szHint.height;
525 int new_pmap_width = target_width; 501 int new_pmap_width = target_width;
526 int new_pmap_height = target_height; 502 int new_pmap_height = target_height;
527 503
528 int x = 0; 504 int x = 0;
529 int y = 0; 505 int y = 0;
530 int w = 0; 506 int w = 0;
531 int h = 0; 507 int h = 0;
532 508
533 if (original_asim) 509 get_image_geometry (image, w, h, x, y);
534 get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
535 510
536 if (!original_asim 511 if (!(image.flags & IM_ROOT_ALIGN)
537 || (!(flags & rootAlign)
538 && (x >= target_width
539 || y >= target_height
540 || (x + w <= 0)
541 || (y + h <= 0))))
542 {
543 if (background)
544 {
545 new_pmap_width = background->width;
546 new_pmap_height = background->height;
547 result = background;
548
549 if (background_tint != TINT_LEAVE_SAME)
550 {
551 ASImage *tmp = tile_asimage (target->asv, background, 0, 0,
552 target_width, target_height, background_tint,
553 ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
554 if (tmp)
555 result = tmp;
556 }
557 }
558 else
559 new_pmap_width = new_pmap_height = 0;
560 }
561 else
562 {
563 result = original_asim;
564
565 if ((w != original_asim->width)
566 || (h != original_asim->height))
567 {
568 result = scale_asimage (target->asv, original_asim,
569 w, h,
570 background ? ASA_ASImage : ASA_XImage,
571 100, ASIMAGE_QUALITY_DEFAULT);
572 }
573
574 if (background == NULL)
575 {
576 if (h_scale == 0 || v_scale == 0)
577 {
578 /* if tiling - pixmap has to be sized exactly as the image,
579 but there is no need to make it bigger than the window! */
580 new_pmap_width = min (result->width, target_width);
581 new_pmap_height = min (result->height, target_height);
582
583 /* we also need to tile our image in both directions */
584 ASImage *tmp = tile_asimage (target->asv, result,
585 (int)result->width - x,
586 (int)result->height - y,
587 new_pmap_width,
588 new_pmap_height,
589 TINT_LEAVE_SAME, ASA_XImage,
590 100, ASIMAGE_QUALITY_DEFAULT);
591 if (tmp)
592 {
593 if (result != original_asim)
594 destroy_asimage (&result);
595
596 result = tmp;
597 }
598 }
599 }
600 else
601 {
602 /* if blending background and image - pixmap has to be sized same as target window */
603 ASImageLayer *layers = create_image_layers (2);
604
605 layers[0].im = background;
606 layers[0].clip_width = target_width;
607 layers[0].clip_height = target_height;
608 layers[0].tint = background_tint;
609 layers[1].im = result;
610
611 if (h_scale == 0 || v_scale == 0)
612 {
613 /* tile horizontally */
614 while (x > 0) x -= (int)result->width;
615 layers[1].dst_x = x;
616 layers[1].clip_width = result->width+target_width;
617 }
618 else
619 {
620 /* clip horizontally */
621 layers[1].dst_x = x;
622 layers[1].clip_width = result->width;
623 }
624
625 if (h_scale == 0 || v_scale == 0)
626 {
627 while (y > 0) y -= (int)result->height;
628 layers[1].dst_y = y;
629 layers[1].clip_height = result->height + target_height;
630 }
631 else
632 {
633 layers[1].dst_y = y;
634 layers[1].clip_height = result->height;
635 }
636
637 if (target->rs[Rs_blendtype])
638 {
639 layers[1].merge_scanlines = blend_scanlines_name2func (target->rs[Rs_blendtype]);
640 if (layers[1].merge_scanlines == NULL)
641 layers[1].merge_scanlines = alphablend_scanlines;
642 }
643
644 ASImage *tmp = merge_layers (target->asv, layers, 2, target_width, target_height,
645 ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
646
647 if (tmp)
648 {
649 if (result != original_asim)
650 destroy_asimage (&result);
651
652 result = tmp;
653 }
654
655 free (layers);
656 }
657 }
658
659 bool ret = false;
660
661 if (result)
662 {
663 XGCValues gcv;
664 GC gc;
665
666 if (pixmap)
667 {
668 if (pmap_width != new_pmap_width
669 || pmap_height != new_pmap_height
670 || pmap_depth != target->depth)
671 {
672 XFreePixmap (target->dpy, pixmap);
673 pixmap = None;
674 }
675 }
676
677 /* create Pixmap */
678 if (pixmap == None)
679 {
680 pixmap = XCreatePixmap (target->dpy, target->vt, new_pmap_width, new_pmap_height, target->depth);
681 pmap_width = new_pmap_width;
682 pmap_height = new_pmap_height;
683 pmap_depth = target->depth;
684 }
685 /* fill with background color (if result's not completely overlapping it) */
686 gcv.foreground = target->pix_colors[Color_bg];
687 gc = XCreateGC (target->dpy, target->vt, GCForeground, &gcv);
688
689 int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
690 int dst_width = result->width, dst_height = result->height;
691 if (background == NULL)
692 {
693 if (!(h_scale == 0 || v_scale == 0))
694 {
695 src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );
696 src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
697 }
698
699 if (dst_x > 0 || dst_y > 0
700 || dst_x + dst_width < new_pmap_width
701 || dst_y + dst_height < new_pmap_height)
702 XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
703 }
704
705 /* put result on pixmap */
706 if (dst_x < new_pmap_width && dst_y < new_pmap_height)
707 asimage2drawable (target->asv, pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);
708
709 if (result != background && result != original_asim)
710 destroy_asimage (&result);
711
712 XFreeGC (target->dpy, gc);
713
714 ret = true;
715 }
716
717 if (background)
718 destroy_asimage (&background);
719
720 return ret;
721}
722# endif /* HAVE_AFTERIMAGE */
723
724# ifdef HAVE_PIXBUF
725bool
726bgPixmap_t::render_image (unsigned long background_flags)
727{
728 if (target == NULL)
729 return false;
730
731 if (!pixbuf)
732 return false;
733
734#if !XRENDER
735 if (background_flags)
736 return false;
737#endif
738
739 GdkPixbuf *result;
740
741 int image_width = gdk_pixbuf_get_width (pixbuf);
742 int image_height = gdk_pixbuf_get_height (pixbuf);
743
744 int target_width = target->szHint.width;
745 int target_height = target->szHint.height;
746 int new_pmap_width = target_width;
747 int new_pmap_height = target_height;
748
749 int x = 0;
750 int y = 0;
751 int w = 0;
752 int h = 0;
753
754 get_image_geometry (image_width, image_height, w, h, x, y);
755
756 if (!(flags & rootAlign)
757 && (x >= target_width 512 && (x >= target_width
758 || y >= target_height 513 || y >= target_height
759 || (x + w <= 0) 514 || x + w <= 0
760 || (y + h <= 0))) 515 || y + h <= 0))
761 return false; 516 return false;
762 517
763 result = pixbuf; 518 result = pixbuf;
764 519
765 if ((w != image_width) 520 if (w != image_width
766 || (h != image_height)) 521 || h != image_height)
767 { 522 {
768 result = gdk_pixbuf_scale_simple (pixbuf, 523 result = gdk_pixbuf_scale_simple (pixbuf,
769 w, h, 524 w, h,
770 GDK_INTERP_BILINEAR); 525 GDK_INTERP_BILINEAR);
771 } 526 }
772 527
528 if (!result)
529 return false;
530
773 bool ret = false; 531 bool ret = false;
774 532
775 if (result)
776 {
777 XGCValues gcv; 533 XGCValues gcv;
778 GC gc; 534 GC gc;
779 Pixmap root_pmap; 535 Pixmap tmp_pixmap;
780 536
781 image_width = gdk_pixbuf_get_width (result); 537 image_width = gdk_pixbuf_get_width (result);
782 image_height = gdk_pixbuf_get_height (result); 538 image_height = gdk_pixbuf_get_height (result);
783 539
784 if (background_flags) 540 if (need_blend)
541 tmp_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, 32);
542 else
543 {
544 // optimise bg pixmap size when tiling, but only if there are no
545 // other pixbufs to render. Otherwise, the bg pixmap size must
546 // be equal to the window size.
547 if ((image.flags & IM_TILE)
548 && image_vec.size () == 1)
785 { 549 {
786 root_pmap = pixmap; 550 new_pmap_width = min (image_width, target_width);
787 pixmap = None; 551 new_pmap_height = min (image_height, target_height);
788 } 552 }
789 else 553
790 { 554 if (bg_pixmap == None
791 if (h_scale == 0 || v_scale == 0) 555 || bg_pmap_width != new_pmap_width
556 || bg_pmap_height != new_pmap_height)
792 { 557 {
793 new_pmap_width = min (image_width, target_width); 558 if (bg_pixmap)
794 new_pmap_height = min (image_height, target_height); 559 XFreePixmap (dpy, bg_pixmap);
795 } 560 bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
561 bg_pmap_width = new_pmap_width;
562 bg_pmap_height = new_pmap_height;
796 } 563 }
797 564
798 if (pixmap) 565 tmp_pixmap = bg_pixmap;
799 { 566 }
800 if (pmap_width != new_pmap_width 567
801 || pmap_height != new_pmap_height 568 gcv.foreground = pix_colors[Color_bg];
802 || pmap_depth != target->depth) 569 gc = XCreateGC (dpy, tmp_pixmap, GCForeground, &gcv);
803 { 570
804 XFreePixmap (target->dpy, pixmap); 571 if (gc)
805 pixmap = None; 572 {
806 } 573 if (image.flags & IM_TILE)
807 } 574 {
808
809 if (pixmap == None)
810 {
811 pixmap = XCreatePixmap (target->dpy, target->vt, new_pmap_width, new_pmap_height, target->depth);
812 pmap_width = new_pmap_width;
813 pmap_height = new_pmap_height;
814 pmap_depth = target->depth;
815 }
816
817 gcv.foreground = target->pix_colors[Color_bg];
818 gc = XCreateGC (target->dpy, target->vt, GCForeground, &gcv);
819
820 if (h_scale == 0 || v_scale == 0)
821 {
822 Pixmap tile = XCreatePixmap (target->dpy, target->vt, image_width, image_height, target->depth); 575 Pixmap tile = XCreatePixmap (dpy, vt, image_width, image_height, need_blend ? 32 : depth);
823 gdk_pixbuf_xlib_render_to_drawable (result, tile, gc, 576 pixbuf_to_pixmap (result, tile, gc,
824 0, 0, 577 0, 0,
825 0, 0, 578 0, 0,
826 image_width, image_height, 579 image_width, image_height, need_blend);
827 XLIB_RGB_DITHER_NONE,
828 0, 0);
829 580
830 gcv.tile = tile; 581 gcv.tile = tile;
831 gcv.fill_style = FillTiled; 582 gcv.fill_style = FillTiled;
832 gcv.ts_x_origin = x; 583 gcv.ts_x_origin = x;
833 gcv.ts_y_origin = y; 584 gcv.ts_y_origin = y;
834 XChangeGC (target->dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); 585 XChangeGC (dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
835 586
836 XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height); 587 XFillRectangle (dpy, tmp_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
837 XFreePixmap (target->dpy, tile); 588 XFreePixmap (dpy, tile);
838 } 589 }
839 else 590 else
840 { 591 {
841 int src_x, src_y, dst_x, dst_y; 592 int src_x, src_y, dst_x, dst_y;
842 int dst_width, dst_height; 593 int dst_width, dst_height;
… …
845 src_y = make_clip_rectangle (y, image_height, new_pmap_height, dst_y, dst_height); 596 src_y = make_clip_rectangle (y, image_height, new_pmap_height, dst_y, dst_height);
846 597
847 if (dst_x > 0 || dst_y > 0 598 if (dst_x > 0 || dst_y > 0
848 || dst_x + dst_width < new_pmap_width 599 || dst_x + dst_width < new_pmap_width
849 || dst_y + dst_height < new_pmap_height) 600 || dst_y + dst_height < new_pmap_height)
850 XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height); 601 XFillRectangle (dpy, tmp_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
851 602
852 if (dst_x < new_pmap_width && dst_y < new_pmap_height) 603 if (dst_x < new_pmap_width && dst_y < new_pmap_height)
853 gdk_pixbuf_xlib_render_to_drawable (result, pixmap, gc, 604 pixbuf_to_pixmap (result, tmp_pixmap, gc,
854 src_x, src_y, 605 src_x, src_y,
855 dst_x, dst_y, 606 dst_x, dst_y,
856 dst_width, dst_height, 607 dst_width, dst_height, need_blend);
857 XLIB_RGB_DITHER_NONE,
858 0, 0);
859 } 608 }
860 609
861#if XRENDER 610#if XRENDER
862 if (background_flags) 611 if (need_blend)
863 { 612 {
864 Display *dpy = target->dpy;
865 XRenderPictureAttributes pa;
866
867 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, target->display->screen));
868 Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa);
869
870 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, target->visual);
871 Picture dst = XRenderCreatePicture (dpy, pixmap, dst_format, 0, &pa);
872
873 pa.repeat = True;
874 Pixmap mask_pmap = XCreatePixmap (dpy, target->vt, 1, 1, 8);
875 XRenderPictFormat *mask_format = XRenderFindStandardFormat (dpy, PictStandardA8); 613 XRenderPictFormat *argb_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
614 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
615
876 Picture mask = XRenderCreatePicture (dpy, mask_pmap, mask_format, CPRepeat, &pa); 616 Picture src = XRenderCreatePicture (dpy, tmp_pixmap, argb_format, 0, 0);
877 XFreePixmap (dpy, mask_pmap);
878 617
879 if (src && dst && mask) 618 Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
880 { 619
620 Picture mask = create_xrender_mask (dpy, vt, False, False);
621
881 XRenderColor mask_c; 622 XRenderColor mask_c;
882 623
883 mask_c.alpha = 0x8000; 624 mask_c.alpha = gdk_pixbuf_get_has_alpha (image.pixbuf) ? 0xffff : image.alpha;
884 mask_c.red = 0; 625 mask_c.red =
885 mask_c.green = 0; 626 mask_c.green =
886 mask_c.blue = 0; 627 mask_c.blue = 0;
887 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1); 628 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
629
888 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height); 630 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
889 }
890 631
891 XRenderFreePicture (dpy, src); 632 XRenderFreePicture (dpy, src);
892 XRenderFreePicture (dpy, dst); 633 XRenderFreePicture (dpy, dst);
893 XRenderFreePicture (dpy, mask); 634 XRenderFreePicture (dpy, mask);
894
895 XFreePixmap (dpy, root_pmap);
896 } 635 }
897#endif 636#endif
898 637
899 if (result != pixbuf)
900 g_object_unref (result);
901
902 XFreeGC (target->dpy, gc); 638 XFreeGC (dpy, gc);
903 639
904 ret = true; 640 ret = true;
905 } 641 }
906 642
643 if (result != pixbuf)
644 g_object_unref (result);
645
646 if (need_blend)
647 XFreePixmap (dpy, tmp_pixmap);
648
907 return ret; 649 return ret;
908} 650}
909# endif /* HAVE_PIXBUF */ 651# endif /* HAVE_PIXBUF */
910 652
911bool 653# ifndef NO_RESOURCES
912bgPixmap_t::set_file (const char *file) 654static int
655rxvt_define_image (XrmDatabase *database ecb_unused,
656 XrmBindingList bindings ecb_unused,
657 XrmQuarkList quarks,
658 XrmRepresentation *type ecb_unused,
659 XrmValue *value,
660 XPointer closure ecb_unused)
913{ 661{
914 assert (file); 662 int size;
915 663
916 if (*file) 664 for (size = 0; quarks[size] != NULLQUARK; size++)
917 { 665 ;
918 if (const char *p = strchr (file, ';'))
919 {
920 size_t len = p - file;
921 char *f = rxvt_temp_buf<char> (len + 1);
922 memcpy (f, file, len);
923 f[len] = '\0';
924 file = f;
925 }
926 666
927# ifdef HAVE_AFTERIMAGE 667 if (size >= 2)
928 if (!target->asimman) 668 {
929 target->asimman = create_generic_imageman (target->rs[Rs_path]); 669 int id = strtol (XrmQuarkToString (quarks[size-2]), 0, 0);
930 ASImage *image = get_asimage (target->asimman, file, 0xFFFFFFFF, 100); 670 if (id >= 1)
931 if (image) 671 GET_R->parse_image (id, XrmQuarkToString (quarks[size-1]), (char *)value->addr);
932 { 672 }
933 if (original_asim) 673 return False;
934 safe_asimage_destroy (original_asim); 674}
935 original_asim = image; 675
936 have_image = true; 676void
937 return true; 677rxvt_term::parse_image (int id, const char *type, const char *arg)
938 } 678{
679 if (image_vec.size () < id + 1)
680 image_vec.resize (id + 1);
681
682 rxvt_image *image = &image_vec[id];
683}
939# endif 684# endif
940 685
686rxvt_image::rxvt_image ()
687{
688 alpha =
689 flags =
690 h_scale =
691 v_scale =
692 h_align =
693 v_align = 0;
694
941# ifdef HAVE_PIXBUF 695# ifdef HAVE_PIXBUF
942 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL); 696 pixbuf = 0;
943 if (image)
944 {
945 if (pixbuf)
946 g_object_unref (pixbuf);
947 pixbuf = image;
948 have_image = true;
949 return true;
950 }
951# endif 697# endif
952 } 698}
953 699
700bool
701rxvt_image::set_file_geometry (const char *file)
702{
703 if (!file || !*file)
954 return false; 704 return false;
705
706 const char *p = strchr (file, ';');
707
708 if (p)
709 {
710 size_t len = p - file;
711 char *f = rxvt_temp_buf<char> (len + 1);
712 memcpy (f, file, len);
713 f[len] = '\0';
714 file = f;
715 }
716
717 bool ret = set_file (file);
718 alpha = 0x8000;
719 if (ret && p)
720 set_geometry (p + 1);
721 return ret;
722}
723
724bool
725rxvt_image::set_file (const char *file)
726{
727 bool ret = false;
728
729# ifdef HAVE_PIXBUF
730 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
731 if (image)
732 {
733 if (pixbuf)
734 g_object_unref (pixbuf);
735 pixbuf = image;
736 ret = true;
737 }
738# endif
739
740 if (ret)
741 {
742 alpha = 0xffff;
743 flags = IM_IS_SET | IM_IS_SIZE_SENSITIVE;
744 h_scale = v_scale = defaultScale;
745 h_align = v_align = defaultAlign;
746 }
747
748 return ret;
955} 749}
956 750
957# endif /* BG_IMAGE_FROM_FILE */ 751# endif /* BG_IMAGE_FROM_FILE */
958 752
959# ifdef ENABLE_TRANSPARENCY 753# ifdef ENABLE_TRANSPARENCY
960bool 754bool
961bgPixmap_t::set_transparent () 755rxvt_term::bg_set_blur (const char *geom)
962{ 756{
963 if (!(flags & isTransparent)) 757 bool changed = false;
964 {
965 flags |= isTransparent;
966 return true;
967 }
968
969 return false;
970}
971
972bool
973bgPixmap_t::set_blur_radius (const char *geom)
974{
975 int changed = 0;
976 unsigned int hr, vr; 758 unsigned int hr, vr;
977 int junk; 759 int junk;
978 int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr); 760 int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr);
979 761
980 if (!(geom_flags & WidthValue)) 762 if (!(geom_flags & WidthValue))
… …
985 min_it (hr, 128); 767 min_it (hr, 128);
986 min_it (vr, 128); 768 min_it (vr, 128);
987 769
988 if (h_blurRadius != hr) 770 if (h_blurRadius != hr)
989 { 771 {
990 ++changed; 772 changed = true;
991 h_blurRadius = hr; 773 h_blurRadius = hr;
992 } 774 }
993 775
994 if (v_blurRadius != vr) 776 if (v_blurRadius != vr)
995 { 777 {
996 ++changed; 778 changed = true;
997 v_blurRadius = vr; 779 v_blurRadius = vr;
998 } 780 }
999 781
1000 if (v_blurRadius == 0 && h_blurRadius == 0)
1001 flags &= ~blurNeeded;
1002 else
1003 flags |= blurNeeded;
1004
1005#if XRENDER
1006 XFilters *filters = XRenderQueryFilters (target->dpy, target->display->root);
1007 if (filters)
1008 {
1009 for (int i = 0; i < filters->nfilter; i++)
1010 if (!strcmp (filters->filter[i], FilterConvolution))
1011 flags |= bgPixmap_t::blurServerSide;
1012
1013 XFree (filters);
1014 }
1015#endif
1016
1017 return (changed > 0); 782 return changed;
1018} 783}
1019 784
1020static inline unsigned long 785bool
1021compute_tint_shade_flags (rxvt_color *tint, int shade) 786rxvt_term::bg_set_tint (rxvt_color &new_tint)
1022{ 787{
1023 unsigned long flags = 0; 788 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
1024 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1025 bool has_shade = shade != 100;
1026
1027 if (tint)
1028 { 789 {
790 tint = new_tint;
791 bg_flags |= BG_TINT_SET;
792
793 rgba c;
1029 tint->get (c); 794 tint.get (c);
1030# define IS_COMPONENT_WHOLESOME(cmp) ((cmp) <= 0x000700 || (cmp) >= 0x00f700) 795 if ((c.r <= 0x00ff || c.r >= 0xff00)
1031 if (!has_shade && IS_COMPONENT_WHOLESOME (c.r) 796 && (c.g <= 0x00ff || c.g >= 0xff00)
1032 && IS_COMPONENT_WHOLESOME (c.g) 797 && (c.b <= 0x00ff || c.b >= 0xff00))
1033 && IS_COMPONENT_WHOLESOME (c.b)) 798 bg_flags |= BG_TINT_BITAND;
1034 flags |= bgPixmap_t::tintWholesome;
1035# undef IS_COMPONENT_WHOLESOME
1036 }
1037
1038 if (has_shade)
1039 flags |= bgPixmap_t::tintNeeded;
1040 else if (tint)
1041 {
1042 if ((c.r > 0x000700 || c.g > 0x000700 || c.b > 0x000700)
1043 && (c.r < 0x00f700 || c.g < 0x00f700 || c.b < 0x00f700))
1044 {
1045 flags |= bgPixmap_t::tintNeeded;
1046 }
1047 }
1048
1049 if (flags & bgPixmap_t::tintNeeded)
1050 {
1051 if (flags & bgPixmap_t::tintWholesome)
1052 flags |= bgPixmap_t::tintServerSide;
1053 else 799 else
1054 { 800 bg_flags &= ~BG_TINT_BITAND;
1055#if XRENDER
1056 flags |= bgPixmap_t::tintServerSide;
1057#endif
1058 }
1059 }
1060 801
1061 return flags;
1062}
1063
1064bool
1065bgPixmap_t::set_tint (rxvt_color &new_tint)
1066{
1067 if (!(flags & tintSet) || tint != new_tint)
1068 {
1069 unsigned long new_flags = compute_tint_shade_flags (&new_tint, shade);
1070 tint = new_tint;
1071 flags = (flags & ~tintFlags) | new_flags | tintSet;
1072 return true; 802 return true;
1073 } 803 }
1074 804
1075 return false; 805 return false;
1076} 806}
1077 807
1078bool 808bool
1079bgPixmap_t::unset_tint ()
1080{
1081 unsigned long new_flags = compute_tint_shade_flags (NULL, shade);
1082
1083 if (new_flags != (flags & tintFlags))
1084 {
1085 flags = (flags & ~tintFlags) | new_flags;
1086 return true;
1087 }
1088
1089 return false;
1090}
1091
1092bool
1093bgPixmap_t::set_shade (const char *shade_str) 809rxvt_term::bg_set_shade (const char *shade_str)
1094{ 810{
1095 int new_shade = (shade_str) ? atoi (shade_str) : 100; 811 int new_shade = atoi (shade_str);
1096 812
1097 clamp_it (new_shade, -100, 200); 813 clamp_it (new_shade, -100, 200);
1098 if (new_shade < 0) 814 if (new_shade < 0)
1099 new_shade = 200 - (100 + new_shade); 815 new_shade = 200 - (100 + new_shade);
1100 816
1101 if (new_shade != shade) 817 if (new_shade != shade)
1102 { 818 {
1103 unsigned long new_flags = compute_tint_shade_flags ((flags & tintSet) ? &tint : NULL, new_shade);
1104 shade = new_shade; 819 shade = new_shade;
1105 flags = (flags & (~tintFlags | tintSet)) | new_flags;
1106 return true; 820 return true;
1107 } 821 }
1108 822
1109 return false; 823 return false;
1110} 824}
… …
1131 params[i+2] = XDoubleToFixed (kernel[i] / sum); 845 params[i+2] = XDoubleToFixed (kernel[i] / sum);
1132} 846}
1133#endif 847#endif
1134 848
1135bool 849bool
1136bgPixmap_t::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 850rxvt_term::blur_pixmap (Pixmap pixmap, int width, int height)
1137{ 851{
1138 bool ret = false; 852 bool ret = false;
1139#if XRENDER 853#if XRENDER
854 if (!(bg_flags & BG_HAS_RENDER_CONV))
855 return false;
856
1140 int size = max (h_blurRadius, v_blurRadius) * 2 + 1; 857 int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1141 double *kernel = (double *)malloc (size * sizeof (double)); 858 double *kernel = (double *)malloc (size * sizeof (double));
1142 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 859 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1143 860
1144 Display *dpy = target->dpy;
1145 XRenderPictureAttributes pa; 861 XRenderPictureAttributes pa;
1146 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 862 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1147 863
864 pa.repeat = RepeatPad;
1148 Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 865 Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
866 Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1149 Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 867 Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
868 XFreePixmap (dpy, tmp);
1150 869
1151 if (kernel && params && src && dst) 870 if (kernel && params)
1152 { 871 {
1153 if (h_blurRadius)
1154 {
1155 size = h_blurRadius * 2 + 1; 872 size = h_blurRadius * 2 + 1;
1156 get_gaussian_kernel (h_blurRadius, size, kernel, params); 873 get_gaussian_kernel (h_blurRadius, size, kernel, params);
1157 874
1158 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 875 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1159 XRenderComposite (dpy, 876 XRenderComposite (dpy,
1160 PictOpSrc, 877 PictOpSrc,
1161 src, 878 src,
1162 None, 879 None,
1163 dst, 880 dst,
1164 0, 0, 881 0, 0,
1165 0, 0, 882 0, 0,
1166 0, 0, 883 0, 0,
1167 width, height); 884 width, height);
1168 }
1169 885
1170 if (v_blurRadius) 886 ::swap (src, dst);
1171 { 887
1172 size = v_blurRadius * 2 + 1; 888 size = v_blurRadius * 2 + 1;
1173 get_gaussian_kernel (v_blurRadius, size, kernel, params); 889 get_gaussian_kernel (v_blurRadius, size, kernel, params);
1174 swap (params[0], params[1]); 890 ::swap (params[0], params[1]);
1175 891
1176 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 892 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1177 XRenderComposite (dpy, 893 XRenderComposite (dpy,
1178 PictOpSrc, 894 PictOpSrc,
1179 src, 895 src,
1180 None, 896 None,
1181 dst, 897 dst,
1182 0, 0, 898 0, 0,
1183 0, 0, 899 0, 0,
1184 0, 0, 900 0, 0,
1185 width, height); 901 width, height);
1186 }
1187 902
1188 ret = true; 903 ret = true;
1189 } 904 }
1190 905
1191 free (kernel); 906 free (kernel);
… …
1195#endif 910#endif
1196 return ret; 911 return ret;
1197} 912}
1198 913
1199bool 914bool
1200bgPixmap_t::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 915rxvt_term::tint_pixmap (Pixmap pixmap, int width, int height)
1201{ 916{
1202 Display *dpy = target->dpy;
1203 bool ret = false; 917 bool ret = false;
1204 918
1205 if (flags & tintWholesome) 919 if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1206 { 920 {
1207 XGCValues gcv; 921 XGCValues gcv;
1208 GC gc; 922 GC gc;
1209 923
1210 /* In this case we can tint image server-side getting significant 924 /* In this case we can tint image server-side getting significant
… …
1219 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height); 933 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1220 ret = true; 934 ret = true;
1221 XFreeGC (dpy, gc); 935 XFreeGC (dpy, gc);
1222 } 936 }
1223 } 937 }
1224 else
1225 {
1226# if XRENDER 938# if XRENDER
939 else if (bg_flags & BG_HAS_RENDER)
940 {
1227 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 941 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1228 942
1229 if (flags & tintSet) 943 if (bg_flags & BG_TINT_SET)
1230 tint.get (c); 944 tint.get (c);
1231 945
1232 if (shade <= 100) 946 if (shade <= 100)
1233 { 947 {
1234 c.r = (c.r * shade) / 100; 948 c.r = c.r * shade / 100;
1235 c.g = (c.g * shade) / 100; 949 c.g = c.g * shade / 100;
1236 c.b = (c.b * shade) / 100; 950 c.b = c.b * shade / 100;
1237 } 951 }
1238 else 952 else
1239 { 953 {
1240 c.r = ((0xffff - c.r) * (200 - shade)) / 100; 954 c.r = c.r * (200 - shade) / 100;
1241 c.g = ((0xffff - c.g) * (200 - shade)) / 100; 955 c.g = c.g * (200 - shade) / 100;
1242 c.b = ((0xffff - c.b) * (200 - shade)) / 100; 956 c.b = c.b * (200 - shade) / 100;
1243 } 957 }
1244 958
1245 XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1246 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 959 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1247 XRenderPictureAttributes pa;
1248 960
1249 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 961 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1250 962
1251 pa.repeat = True; 963 Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1252 964
1253 Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32); 965 Picture mask_pic = create_xrender_mask (dpy, pixmap, True, True);
1254 Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1255 XFreePixmap (dpy, overlay_pmap);
1256 966
1257 pa.component_alpha = True;
1258 Pixmap mask_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
1259 Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat|CPComponentAlpha, &pa);
1260 XFreePixmap (dpy, mask_pmap);
1261
1262 if (mask_pic && overlay_pic && back_pic)
1263 {
1264 XRenderColor mask_c; 967 XRenderColor mask_c;
1265 968
1266 memset (&mask_c, (shade > 100) ? 0xFF : 0x0, sizeof (mask_c));
1267 mask_c.alpha = 0xffff; 969 mask_c.alpha = 0xffff;
970 mask_c.red =
971 mask_c.green =
972 mask_c.blue = 0;
973 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
974
975 mask_c.alpha = 0;
976 mask_c.red = 0xffff - c.r;
977 mask_c.green = 0xffff - c.g;
978 mask_c.blue = 0xffff - c.b;
979 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
980
981 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
982
983 if (shade > 100)
984 {
985 mask_c.alpha = 0;
986 mask_c.red =
987 mask_c.green =
988 mask_c.blue = 0xffff * (shade - 100) / 100;
1268 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1); 989 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1269 990
1270 mask_c.alpha = 0;
1271 mask_c.red = 0xffff - c.r;
1272 mask_c.green = 0xffff - c.g;
1273 mask_c.blue = 0xffff - c.b;
1274 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
1275 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height); 991 XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1276 ret = true;
1277 } 992 }
993
994 ret = true;
1278 995
1279 XRenderFreePicture (dpy, mask_pic); 996 XRenderFreePicture (dpy, mask_pic);
1280 XRenderFreePicture (dpy, overlay_pic); 997 XRenderFreePicture (dpy, overlay_pic);
1281 XRenderFreePicture (dpy, back_pic); 998 XRenderFreePicture (dpy, back_pic);
999 }
1282# endif 1000# endif
1283 }
1284 1001
1285 return ret; 1002 return ret;
1286} 1003}
1287 1004
1288/* make_transparency_pixmap() 1005/*
1289 * Builds a pixmap of the same size as the terminal window that contains 1006 * Builds a pixmap of the same size as the terminal window that contains
1290 * the tiled portion of the root pixmap that is supposed to be covered by 1007 * the tiled portion of the root pixmap that is supposed to be covered by
1291 * our window. 1008 * our window.
1292 */ 1009 */
1293unsigned long 1010bool
1294bgPixmap_t::make_transparency_pixmap () 1011rxvt_term::make_transparency_pixmap ()
1295{ 1012{
1296 unsigned long result = 0; 1013 bool ret = false;
1297
1298 if (target == NULL)
1299 return 0;
1300 1014
1301 /* root dimensions may change from call to call - but Display structure should 1015 /* root dimensions may change from call to call - but Display structure should
1302 * be always up-to-date, so let's use it : 1016 * be always up-to-date, so let's use it :
1303 */ 1017 */
1304 Window root = target->display->root;
1305 int screen = target->display->screen; 1018 int screen = display->screen;
1306 Display *dpy = target->dpy; 1019 int root_depth = DefaultDepth (dpy, screen);
1307 int root_width = DisplayWidth (dpy, screen); 1020 int root_width = DisplayWidth (dpy, screen);
1308 int root_height = DisplayHeight (dpy, screen); 1021 int root_height = DisplayHeight (dpy, screen);
1022 unsigned int root_pmap_width, root_pmap_height;
1309 int window_width = target->szHint.width; 1023 int window_width = szHint.width;
1310 int window_height = target->szHint.height; 1024 int window_height = szHint.height;
1311 int sx, sy; 1025 int sx, sy;
1312 XGCValues gcv; 1026 XGCValues gcv;
1313 GC gc; 1027 GC gc;
1314 1028
1315 target->get_window_origin (sx, sy); 1029 sx = target_x;
1030 sy = target_y;
1316 1031
1317 /* check if we are outside of the visible part of the virtual screen : */ 1032 /* check if we are outside of the visible part of the virtual screen : */
1318 if (sx + window_width <= 0 || sy + window_height <= 0 1033 if (sx + window_width <= 0 || sy + window_height <= 0
1319 || sx >= root_width || sy >= root_height) 1034 || sx >= root_width || sy >= root_height)
1320 return 0; 1035 return 0;
1321 1036
1322 if (root_pixmap == None) 1037 // validate root pixmap and get its size
1323 return 0;
1324
1325 Pixmap tiled_root_pmap = XCreatePixmap (dpy, root, window_width, window_height, root_depth);
1326
1327 if (tiled_root_pmap == None) /* something really bad happened - abort */
1328 return 0;
1329
1330 /* straightforward pixmap copy */
1331 gcv.tile = root_pixmap;
1332 gcv.fill_style = FillTiled;
1333
1334 while (sx < 0) sx += (int)root_width;
1335 while (sy < 0) sy += (int)root_height;
1336
1337 gcv.ts_x_origin = -sx;
1338 gcv.ts_y_origin = -sy;
1339 gc = XCreateGC (dpy, root, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1340
1341 if (gc)
1342 {
1343 XFillRectangle (dpy, tiled_root_pmap, gc, 0, 0, window_width, window_height);
1344 result |= transpPmapTiled;
1345 XFreeGC (dpy, gc);
1346 }
1347
1348 if (tiled_root_pmap != None)
1349 {
1350 if (!need_client_side_rendering ())
1351 {
1352 if (flags & (blurNeeded | blurServerSide))
1353 {
1354 if (blur_pixmap (tiled_root_pmap, DefaultVisual (dpy, screen), window_width, window_height))
1355 result |= transpPmapBlurred;
1356 }
1357 if (flags & (tintNeeded | tintServerSide))
1358 {
1359 if (tint_pixmap (tiled_root_pmap, DefaultVisual (dpy, screen), window_width, window_height))
1360 result |= transpPmapTinted;
1361 }
1362 } /* server side rendering completed */
1363
1364 if (pixmap)
1365 XFreePixmap (dpy, pixmap);
1366
1367 pixmap = tiled_root_pmap;
1368 pmap_width = window_width;
1369 pmap_height = window_height;
1370 pmap_depth = root_depth;
1371 }
1372
1373 return result;
1374}
1375
1376void
1377bgPixmap_t::set_root_pixmap ()
1378{
1379 Pixmap new_root_pixmap = target->get_pixmap_property (XA_XROOTPMAP_ID);
1380 if (new_root_pixmap == None)
1381 new_root_pixmap = target->get_pixmap_property (XA_ESETROOT_PMAP_ID);
1382
1383 root_pixmap = new_root_pixmap;
1384
1385 // validate root pixmap
1386 if (root_pixmap != None) 1038 if (root_pixmap != None)
1387 { 1039 {
1388 unsigned int width, height;
1389 Window wdummy; 1040 Window wdummy;
1390 int idummy; 1041 int idummy;
1391 unsigned int udummy; 1042 unsigned int udummy;
1392 1043
1393 target->allowedxerror = -1; 1044 allowedxerror = -1;
1394 1045
1395 if (!XGetGeometry (target->dpy, root_pixmap, &wdummy, &idummy, &idummy, &width, &height, &udummy, &udummy)) 1046 if (!XGetGeometry (dpy, root_pixmap, &wdummy, &idummy, &idummy, &root_pmap_width, &root_pmap_height, &udummy, &udummy))
1396 root_pixmap = None; 1047 root_pixmap = None;
1397 1048
1398 target->allowedxerror = 0; 1049 allowedxerror = 0;
1399 }
1400}
1401# endif /* ENABLE_TRANSPARENCY */
1402
1403# ifndef HAVE_AFTERIMAGE
1404static void ShadeXImage(Visual *visual, XImage *srcImage, int shade, int rm, int gm, int bm);
1405# endif
1406
1407bool
1408bgPixmap_t::render ()
1409{
1410 unsigned long background_flags = 0;
1411
1412 if (target == NULL)
1413 return false;
1414
1415 invalidate ();
1416# ifdef ENABLE_TRANSPARENCY
1417 if (flags & isTransparent)
1418 { 1050 }
1419 /* we need to re-generate transparency pixmap in that case ! */ 1051
1420 background_flags = make_transparency_pixmap (); 1052 Pixmap recoded_root_pmap = root_pixmap;
1421 if (background_flags == 0) 1053
1422 return false; 1054 if (root_pixmap != None && root_depth != depth)
1423 else if ((background_flags & transpTransformations) == (flags & transpTransformations)
1424 && pmap_depth == target->depth)
1425 flags = flags & ~isInvalid;
1426 } 1055 {
1427# endif 1056#if XRENDER
1428 1057 if (bg_flags & BG_HAS_RENDER)
1429# ifdef BG_IMAGE_FROM_FILE
1430 if (have_image
1431 || (background_flags & transpTransformations) != (flags & transpTransformations))
1432 {
1433 if (render_image (background_flags))
1434 flags = flags & ~isInvalid;
1435 }
1436# endif
1437
1438 XImage *result = NULL;
1439
1440 if (background_flags && (flags & isInvalid))
1441 {
1442 result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap);
1443 }
1444
1445 if (result)
1446 {
1447# if !defined(HAVE_AFTERIMAGE) && !XRENDER
1448 /* our own client-side tinting */
1449 if (!(background_flags & transpPmapTinted) && (flags & tintNeeded))
1450 { 1058 {
1451 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 1059 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1452 if (flags & tintSet) 1060
1453 tint.get (c); 1061 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1454 ShadeXImage (DefaultVisual (target->dpy, target->display->screen), result, shade, c.r, c.g, c.b); 1062 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1063
1064 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1065 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1066
1067 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
1068
1069 XRenderFreePicture (dpy, src);
1070 XRenderFreePicture (dpy, dst);
1455 } 1071 }
1072 else
1456# endif 1073#endif
1074 recoded_root_pmap = None;
1075 }
1457 1076
1458 GC gc = XCreateGC (target->dpy, target->vt, 0UL, NULL); 1077 if (recoded_root_pmap == None)
1078 return 0;
1459 1079
1080 if (bg_pixmap == None
1081 || bg_pmap_width != window_width
1082 || bg_pmap_height != window_height)
1083 {
1084 if (bg_pixmap)
1085 XFreePixmap (dpy, bg_pixmap);
1086 bg_pixmap = XCreatePixmap (dpy, vt, window_width, window_height, depth);
1087 bg_pmap_width = window_width;
1088 bg_pmap_height = window_height;
1089 }
1090
1091 /* straightforward pixmap copy */
1092 while (sx < 0) sx += root_pmap_width;
1093 while (sy < 0) sy += root_pmap_height;
1094
1095 gcv.tile = recoded_root_pmap;
1096 gcv.fill_style = FillTiled;
1097 gcv.ts_x_origin = -sx;
1098 gcv.ts_y_origin = -sy;
1099 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1100
1460 if (gc) 1101 if (gc)
1102 {
1103 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1104 ret = true;
1105 bool need_blur = h_blurRadius && v_blurRadius;
1106 bool need_tint = shade != 100 || (bg_flags & BG_TINT_SET);
1107
1108 if (!(bg_flags & BG_CLIENT_RENDER))
1461 { 1109 {
1462 if (/*pmap_depth != target->depth &&*/ pixmap != None) 1110 if (need_blur)
1463 { 1111 {
1464 XFreePixmap (target->dpy, pixmap); 1112 if (blur_pixmap (bg_pixmap, window_width, window_height))
1465 pixmap = None; 1113 need_blur = false;
1466 } 1114 }
1467 1115 if (need_tint)
1468 if (pixmap == None)
1469 { 1116 {
1470 pixmap = XCreatePixmap (target->dpy, target->vt, result->width, result->height, target->depth); 1117 if (tint_pixmap (bg_pixmap, window_width, window_height))
1471 pmap_width = result->width; 1118 need_tint = false;
1472 pmap_height = result->height;
1473 pmap_depth = target->depth;
1474 } 1119 }
1475 1120 if (need_tint)
1476 if (pmap_depth != result->depth)
1477 { 1121 {
1478 /* Bad Match error will ensue ! stupid X !!!! */ 1122 XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1479 if (result->depth == 24 && pmap_depth == 32) 1123 if (ximage)
1480 result->depth = 32;
1481 else if (result->depth == 32 && pmap_depth == 24)
1482 result->depth = 24;
1483 else
1484 { 1124 {
1485 /* TODO: implement image recoding */ 1125 /* our own client-side tinting */
1126 tint_ximage (ximage);
1127
1128 XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
1129 XDestroyImage (ximage);
1486 } 1130 }
1487 } 1131 }
1132 } /* server side rendering completed */
1488 1133
1489 if (pmap_depth == result->depth)
1490 XPutImage (target->dpy, pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1491
1492 XFreeGC (target->dpy, gc); 1134 XFreeGC (dpy, gc);
1493 flags = flags & ~isInvalid; 1135 }
1136
1137 if (recoded_root_pmap != root_pixmap)
1138 XFreePixmap (dpy, recoded_root_pmap);
1139
1140 return ret;
1141}
1142
1143void
1144rxvt_term::bg_set_root_pixmap ()
1145{
1146 Pixmap new_root_pixmap = get_pixmap_property (xa[XA_XROOTPMAP_ID]);
1147 if (new_root_pixmap == None)
1148 new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]);
1149
1150 root_pixmap = new_root_pixmap;
1151}
1152# endif /* ENABLE_TRANSPARENCY */
1153
1154bool
1155rxvt_term::bg_render ()
1156{
1157 bg_invalidate ();
1158# ifdef ENABLE_TRANSPARENCY
1159 if (bg_flags & BG_IS_TRANSPARENT)
1160 {
1161 /* we need to re-generate transparency pixmap in that case ! */
1162 if (make_transparency_pixmap ())
1163 bg_flags |= BG_IS_VALID;
1164 }
1165# endif
1166
1167# ifdef BG_IMAGE_FROM_FILE
1168 for (vector<rxvt_image>::iterator bg_image = image_vec.begin (); bg_image < image_vec.end (); bg_image++)
1169 {
1170 if (render_image (*bg_image))
1171 bg_flags |= BG_IS_VALID;
1172 }
1173# endif
1174
1175 if (!(bg_flags & BG_IS_VALID))
1176 {
1177 if (bg_pixmap != None)
1178 {
1179 XFreePixmap (dpy, bg_pixmap);
1180 bg_pixmap = None;
1494 } 1181 }
1495
1496 XDestroyImage (result);
1497 }
1498
1499 if (flags & isInvalid)
1500 { 1182 }
1501 if (pixmap != None)
1502 {
1503 XFreePixmap (target->dpy, pixmap);
1504 pixmap = None;
1505 }
1506 }
1507 1183
1508 apply (); 1184 scr_recolour (false);
1185 bg_flags |= BG_NEEDS_REFRESH;
1509 1186
1510 valid_since = ev::now (); 1187 bg_valid_since = ev::now ();
1511 1188
1512 return true; 1189 return true;
1513} 1190}
1514 1191
1515bool 1192void
1516bgPixmap_t::set_target (rxvt_term *new_target) 1193rxvt_term::bg_init ()
1517{ 1194{
1518 if (new_target)
1519 if (target != new_target)
1520 {
1521 target = new_target;
1522# ifdef ENABLE_TRANSPARENCY 1195#ifdef ENABLE_TRANSPARENCY
1523 root_depth = DefaultDepthOfScreen (ScreenOfDisplay (target->dpy, target->display->screen)); 1196 shade = 100;
1197#endif
1198
1199 bg_flags &= ~(BG_HAS_RENDER | BG_HAS_RENDER_CONV);
1200#if XRENDER
1201 int major, minor;
1202 if (XRenderQueryVersion (dpy, &major, &minor))
1203 bg_flags |= BG_HAS_RENDER;
1204 XFilters *filters = XRenderQueryFilters (dpy, vt);
1205 if (filters)
1206 {
1207 for (int i = 0; i < filters->nfilter; i++)
1208 if (!strcmp (filters->filter[i], FilterConvolution))
1209 bg_flags |= BG_HAS_RENDER_CONV;
1210
1211 XFree (filters);
1212 }
1213#endif
1214
1215#ifdef BG_IMAGE_FROM_FILE
1216 if (rs[Rs_backgroundPixmap])
1217 {
1218 rxvt_image *image = new_image ();
1219 if (!image->set_file_geometry (rs[Rs_backgroundPixmap]))
1220 image_vec.pop_back ();
1221 }
1222
1223# ifndef NO_RESOURCES
1224 find_resources ("image", "Image", XrmEnumAllLevels, rxvt_define_image);
1225 vector<rxvt_image>::iterator bg_image = image_vec.begin ();
1226 while (bg_image != image_vec.end ())
1227 {
1228 if (!(bg_image->flags & IM_IS_SET))
1229 bg_image = image_vec.erase (bg_image);
1230 else
1231 bg_image++;
1232 }
1524# endif 1233# endif
1525 return true; 1234
1235 if (image_vec.size () > 0
1236 && !bg_window_position_sensitive ())
1237 update_background ();
1238#endif
1239}
1240
1241#endif /* HAVE_BG_PIXMAP */
1242
1243#ifdef ENABLE_TRANSPARENCY
1244/* based on code from aterm-0.4.2 */
1245
1246static inline void
1247fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
1248{
1249 for (int i = 0; i <= mask >> sh; i++)
1250 {
1251 uint32_t tmp;
1252 tmp = i * high;
1253 tmp += (mask >> sh) * low;
1254 lookup[i] = (tmp / 0xffff) << sh;
1526 } 1255 }
1527
1528 return false;
1529} 1256}
1530 1257
1531void 1258void
1532bgPixmap_t::apply () 1259rxvt_term::tint_ximage (XImage *ximage)
1533{ 1260{
1534 if (target) 1261 unsigned int size_r, size_g, size_b;
1535 {
1536 if (pixmap != None)
1537 {
1538 /* set target's background to pixmap */
1539# ifdef ENABLE_TRANSPARENCY
1540 if (flags & isTransparent)
1541 {
1542 XSetWindowBackgroundPixmap (target->dpy, target->parent[0], pixmap);
1543 XSetWindowBackgroundPixmap (target->dpy, target->vt, ParentRelative);
1544
1545 if (target->scrollBar.win)
1546 XSetWindowBackgroundPixmap (target->dpy, target->scrollBar.win, ParentRelative);
1547 }
1548 else
1549# endif
1550 {
1551 /* force old pixmap dereference in case it was transparent before :*/
1552 XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
1553 XSetWindowBackgroundPixmap (target->dpy, target->vt, pixmap);
1554 /* do we also need to set scrollbar's background here ? */
1555
1556 if (target->scrollBar.win)
1557 XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);
1558 }
1559 }
1560 else
1561 {
1562 /* set target background to a pixel */
1563 XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
1564 XSetWindowBackground (target->dpy, target->vt, target->pix_colors[Color_bg]);
1565 /* do we also need to set scrollbar's background here ? */
1566 if (target->scrollBar.win)
1567 XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);
1568 }
1569
1570 /* don't want Expose on the parent or vt. It is better to use
1571 scr_touch or we get a great deal of flicker otherwise: */
1572 XClearWindow (target->dpy, target->parent[0]);
1573
1574 if (target->scrollBar.state && target->scrollBar.win)
1575 {
1576 target->scrollBar.state = STATE_IDLE;
1577 target->scrollBar.show (0);
1578 }
1579
1580 target->want_refresh = 1;
1581 flags |= hasChanged;
1582 }
1583}
1584
1585#endif /* HAVE_BG_PIXMAP */
1586
1587#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) && !XRENDER
1588/* taken from aterm-0.4.2 */
1589
1590static void
1591ShadeXImage(Visual *visual, XImage *srcImage, int shade, int rm, int gm, int bm)
1592{
1593 int sh_r, sh_g, sh_b; 1262 int sh_r, sh_g, sh_b;
1594 uint32_t mask_r, mask_g, mask_b; 1263 uint32_t mask_r, mask_g, mask_b;
1595 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b; 1264 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1596 unsigned int lower_lim_r, lower_lim_g, lower_lim_b; 1265 unsigned short low;
1597 unsigned int upper_lim_r, upper_lim_g, upper_lim_b;
1598 int i;
1599 int host_byte_order = byteorder.big_endian () ? MSBFirst : LSBFirst; 1266 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1600 1267
1601 if (visual->c_class != TrueColor || srcImage->format != ZPixmap) return; 1268 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;
1602 1269
1603 /* for convenience */ 1270 /* for convenience */
1604 mask_r = visual->red_mask; 1271 mask_r = visual->red_mask;
1605 mask_g = visual->green_mask; 1272 mask_g = visual->green_mask;
1606 mask_b = visual->blue_mask; 1273 mask_b = visual->blue_mask;
1607 1274
1608 /* boring lookup table pre-initialization */ 1275 /* boring lookup table pre-initialization */
1609 switch (srcImage->depth) 1276 sh_r = ecb_ctz32 (mask_r);
1610 { 1277 sh_g = ecb_ctz32 (mask_g);
1611 case 15: 1278 sh_b = ecb_ctz32 (mask_b);
1612 if ((mask_r != 0x7c00) || 1279
1613 (mask_g != 0x03e0) || 1280 size_r = mask_r >> sh_r;
1614 (mask_b != 0x001f)) 1281 size_g = mask_g >> sh_g;
1282 size_b = mask_b >> sh_b;
1283
1284 if (size_r++ > 255 || size_g++ > 255 || size_b++ > 255)
1615 return; 1285 return;
1616 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+32+32)); 1286
1287 lookup = (uint32_t *)malloc (sizeof (uint32_t) * (size_r + size_g + size_b));
1617 lookup_r = lookup; 1288 lookup_r = lookup;
1618 lookup_g = lookup+32; 1289 lookup_g = lookup + size_r;
1619 lookup_b = lookup+32+32; 1290 lookup_b = lookup + size_r + size_g;
1620 sh_r = 10; 1291
1621 sh_g = 5; 1292 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1622 sh_b = 0; 1293
1623 break; 1294 if (bg_flags & BG_TINT_SET)
1624 case 16: 1295 tint.get (c);
1625 if ((mask_r != 0xf800) ||
1626 (mask_g != 0x07e0) ||
1627 (mask_b != 0x001f))
1628 return;
1629 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+64+32));
1630 lookup_r = lookup;
1631 lookup_g = lookup+32;
1632 lookup_b = lookup+32+64;
1633 sh_r = 11;
1634 sh_g = 5;
1635 sh_b = 0;
1636 break;
1637 case 24:
1638 if ((mask_r != 0xff0000) ||
1639 (mask_g != 0x00ff00) ||
1640 (mask_b != 0x0000ff))
1641 return;
1642 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(256+256+256));
1643 lookup_r = lookup;
1644 lookup_g = lookup+256;
1645 lookup_b = lookup+256+256;
1646 sh_r = 16;
1647 sh_g = 8;
1648 sh_b = 0;
1649 break;
1650 case 32:
1651 if ((mask_r != 0xff0000) ||
1652 (mask_g != 0x00ff00) ||
1653 (mask_b != 0x0000ff))
1654 return;
1655 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(256+256+256));
1656 lookup_r = lookup;
1657 lookup_g = lookup+256;
1658 lookup_b = lookup+256+256;
1659 sh_r = 16;
1660 sh_g = 8;
1661 sh_b = 0;
1662 break;
1663 default:
1664 return; /* we do not support this color depth */
1665 }
1666 1296
1667 /* prepare limits for color transformation (each channel is handled separately) */ 1297 /* prepare limits for color transformation (each channel is handled separately) */
1668 if (shade > 100) 1298 if (shade > 100)
1669 { 1299 {
1670 shade = 200 - shade; 1300 c.r = c.r * (200 - shade) / 100;
1301 c.g = c.g * (200 - shade) / 100;
1302 c.b = c.b * (200 - shade) / 100;
1671 1303
1672 lower_lim_r = 65535-rm; 1304 low = 0xffff * (shade - 100) / 100;
1673 lower_lim_g = 65535-gm;
1674 lower_lim_b = 65535-bm;
1675
1676 lower_lim_r = 65535-(unsigned int)(((uint32_t)lower_lim_r)*((uint32_t)shade)/100);
1677 lower_lim_g = 65535-(unsigned int)(((uint32_t)lower_lim_g)*((uint32_t)shade)/100);
1678 lower_lim_b = 65535-(unsigned int)(((uint32_t)lower_lim_b)*((uint32_t)shade)/100);
1679
1680 upper_lim_r = upper_lim_g = upper_lim_b = 65535;
1681 } 1305 }
1682 else 1306 else
1683 { 1307 {
1308 c.r = c.r * shade / 100;
1309 c.g = c.g * shade / 100;
1310 c.b = c.b * shade / 100;
1684 1311
1685 lower_lim_r = lower_lim_g = lower_lim_b = 0; 1312 low = 0;
1686
1687 upper_lim_r = (unsigned int)((((uint32_t)rm)*((uint32_t)shade))/100);
1688 upper_lim_g = (unsigned int)((((uint32_t)gm)*((uint32_t)shade))/100);
1689 upper_lim_b = (unsigned int)((((uint32_t)bm)*((uint32_t)shade))/100);
1690 } 1313 }
1691 1314
1692 /* fill our lookup tables */ 1315 /* fill our lookup tables */
1693 for (i = 0; i <= mask_r>>sh_r; i++) 1316 fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1694 { 1317 fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1695 uint32_t tmp; 1318 fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1696 tmp = ((uint32_t)i)*((uint32_t)(upper_lim_r-lower_lim_r));
1697 tmp += ((uint32_t)(mask_r>>sh_r))*((uint32_t)lower_lim_r);
1698 lookup_r[i] = (tmp/65535)<<sh_r;
1699 }
1700 for (i = 0; i <= mask_g>>sh_g; i++)
1701 {
1702 uint32_t tmp;
1703 tmp = ((uint32_t)i)*((uint32_t)(upper_lim_g-lower_lim_g));
1704 tmp += ((uint32_t)(mask_g>>sh_g))*((uint32_t)lower_lim_g);
1705 lookup_g[i] = (tmp/65535)<<sh_g;
1706 }
1707 for (i = 0; i <= mask_b>>sh_b; i++)
1708 {
1709 uint32_t tmp;
1710 tmp = ((uint32_t)i)*((uint32_t)(upper_lim_b-lower_lim_b));
1711 tmp += ((uint32_t)(mask_b>>sh_b))*((uint32_t)lower_lim_b);
1712 lookup_b[i] = (tmp/65535)<<sh_b;
1713 }
1714 1319
1715 /* apply table to input image (replacing colors by newly calculated ones) */ 1320 /* apply table to input image (replacing colors by newly calculated ones) */
1716 if (srcImage->bits_per_pixel == 32 1321 if (ximage->bits_per_pixel == 32
1717 && (srcImage->depth == 24 || srcImage->depth == 32)
1718 && srcImage->byte_order == host_byte_order) 1322 && ximage->byte_order == host_byte_order)
1719 { 1323 {
1720 uint32_t *p1, *pf, *p, *pl; 1324 char *line = ximage->data;
1721 p1 = (uint32_t *) srcImage->data;
1722 pf = (uint32_t *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
1723 1325
1724 while (p1 < pf) 1326 for (int y = 0; y < ximage->height; y++)
1725 { 1327 {
1726 p = p1; 1328 uint32_t *p = (uint32_t *)line;
1727 pl = p1 + srcImage->width; 1329 for (int x = 0; x < ximage->width; x++)
1728 for (; p < pl; p++)
1729 { 1330 {
1730 *p = lookup_r[(*p & 0xff0000) >> 16] | 1331 *p = lookup_r[(*p & mask_r) >> sh_r] |
1731 lookup_g[(*p & 0x00ff00) >> 8] | 1332 lookup_g[(*p & mask_g) >> sh_g] |
1732 lookup_b[(*p & 0x0000ff)] | 1333 lookup_b[(*p & mask_b) >> sh_b];
1733 (*p & 0xff000000); 1334 p++;
1734 } 1335 }
1735 p1 = (uint32_t *) ((char *) p1 + srcImage->bytes_per_line); 1336 line += ximage->bytes_per_line;
1736 } 1337 }
1737 } 1338 }
1738 else 1339 else
1739 { 1340 {
1740 for (int y = 0; y < srcImage->height; y++) 1341 for (int y = 0; y < ximage->height; y++)
1741 for (int x = 0; x < srcImage->width; x++) 1342 for (int x = 0; x < ximage->width; x++)
1742 { 1343 {
1743 unsigned long pixel = XGetPixel (srcImage, x, y); 1344 unsigned long pixel = XGetPixel (ximage, x, y);
1744 pixel = lookup_r[(pixel & mask_r) >> sh_r] | 1345 pixel = lookup_r[(pixel & mask_r) >> sh_r] |
1745 lookup_g[(pixel & mask_g) >> sh_g] | 1346 lookup_g[(pixel & mask_g) >> sh_g] |
1746 lookup_b[(pixel & mask_b) >> sh_b]; 1347 lookup_b[(pixel & mask_b) >> sh_b];
1747 XPutPixel (srcImage, x, y, pixel); 1348 XPutPixel (ximage, x, y, pixel);
1748 } 1349 }
1749 } 1350 }
1750 1351
1751 free (lookup); 1352 free (lookup);
1752} 1353}
1753#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */ 1354#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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