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.91 by sf-exg, Mon Oct 18 16:10:35 2010 UTC vs.
Revision 1.221 by sf-exg, Fri May 25 09:27:35 2012 UTC

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

Diff Legend

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