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

Diff Legend

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