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

Diff Legend

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