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

Diff Legend

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