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

Diff Legend

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