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

Diff Legend

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