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

Diff Legend

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