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.103 by sf-exg, Sun Oct 31 11:15:29 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 return (changed > 0); 314 return changed;
434} 315}
435 316
436void 317void
437bgPixmap_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)
438{ 319{
439 int target_width = target->szHint.width; 320 int target_width = szHint.width;
440 int target_height = target->szHint.height; 321 int target_height = szHint.height;
441 322
442 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)
443 { 327 {
444 float scale = (float)target_width / image_width; 328 float scale = (float)w / image_width;
445 min_it (scale, (float)target_height / image_height); 329 min_it (scale, (float)h / image_height);
446 w = image_width * scale + 0.5; 330 w = image_width * scale + 0.5;
447 h = image_height * scale + 0.5; 331 h = image_height * scale + 0.5;
448 } 332 }
449 else
450 {
451 w = h_scale * target_width / 100;
452 h = v_scale * target_height / 100;
453 }
454 333
455 if (!w) w = image_width; 334 if (!w) w = image_width;
456 if (!h) h = image_height; 335 if (!h) h = image_height;
457 336
458 if (flags & rootAlign) 337 if (bg_flags & BG_ROOT_ALIGN)
459 { 338 {
460 target->get_window_origin (x, y);
461 x = -x; 339 x = -target_x;
462 y = -y; 340 y = -target_y;
463 } 341 }
464 else 342 else
465 { 343 {
466 x = make_align_position (h_align, target_width, w); 344 x = make_align_position (h_align, target_width, w);
467 y = make_align_position (v_align, target_height, h); 345 y = make_align_position (v_align, target_height, h);
468 } 346 }
469 347
470 flags &= ~sizeSensitive; 348 bg_flags &= ~BG_IS_SIZE_SENSITIVE;
471 if ((flags & propScale) || h_scale || v_scale 349 if (!(bg_flags & BG_TILE)
350 || h_scale || v_scale
472 || (!(flags & rootAlign) && (h_align || v_align)) 351 || (!(bg_flags & BG_ROOT_ALIGN) && (h_align || v_align))
473 || w > target_width || h > target_height) 352 || w > target_width || h > target_height)
474 flags |= sizeSensitive; 353 bg_flags |= BG_IS_SIZE_SENSITIVE;
475} 354}
476 355
477# ifdef HAVE_AFTERIMAGE 356# ifdef HAVE_AFTERIMAGE
478bool 357bool
479bgPixmap_t::render_image (unsigned long background_flags) 358rxvt_term::render_image (unsigned long tr_flags)
480{ 359{
481 if (target == NULL)
482 return false;
483
484 target->init_asv (); 360 init_asv ();
485 361
486 ASImage *background = NULL; 362 ASImage *background = NULL;
487 ARGB32 background_tint = TINT_LEAVE_SAME; 363 ARGB32 background_tint = TINT_LEAVE_SAME;
488 364
489# ifdef ENABLE_TRANSPARENCY 365# ifdef ENABLE_TRANSPARENCY
490 if (background_flags) 366 if (tr_flags)
491 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);
492 368
493 if (!(background_flags & transpPmapTinted) && (flags & tintNeeded)) 369 if (tr_flags & BG_NEEDS_TINT)
494 { 370 {
495 ShadingInfo as_shade; 371 ShadingInfo as_shade;
496 as_shade.shading = shade; 372 as_shade.shading = shade;
497 373
498 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 374 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
499 if (flags & tintSet) 375 if (bg_flags & BG_TINT_SET)
500 tint.get (c); 376 tint.get (c);
501 as_shade.tintColor.red = c.r; 377 as_shade.tintColor.red = c.r;
502 as_shade.tintColor.green = c.g; 378 as_shade.tintColor.green = c.g;
503 as_shade.tintColor.blue = c.b; 379 as_shade.tintColor.blue = c.b;
504 380
505 background_tint = shading2tint32 (&as_shade); 381 background_tint = shading2tint32 (&as_shade);
506 } 382 }
507 383
508 if (!(background_flags & transpPmapBlurred) && (flags & blurNeeded) && background != NULL) 384 if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)
509 { 385 {
510 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,
511 (original_asim == NULL || tint == TINT_LEAVE_SAME) ? ASA_XImage : ASA_ASImage, 387 ASA_XImage,
512 100, ASIMAGE_QUALITY_DEFAULT); 388 100, ASIMAGE_QUALITY_DEFAULT);
513 if (tmp) 389 if (tmp)
514 { 390 {
515 destroy_asimage (&background); 391 destroy_asimage (&background);
516 background = tmp; 392 background = tmp;
… …
518 } 394 }
519# endif 395# endif
520 396
521 ASImage *result = 0; 397 ASImage *result = 0;
522 398
523 int target_width = target->szHint.width; 399 int target_width = szHint.width;
524 int target_height = target->szHint.height; 400 int target_height = szHint.height;
525 int new_pmap_width = target_width; 401 int new_pmap_width = target_width;
526 int new_pmap_height = target_height; 402 int new_pmap_height = target_height;
527 403
528 int x = 0; 404 int x = 0;
529 int y = 0; 405 int y = 0;
… …
532 408
533 if (original_asim) 409 if (original_asim)
534 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);
535 411
536 if (!original_asim 412 if (!original_asim
537 || (!(flags & rootAlign) 413 || (!(bg_flags & BG_ROOT_ALIGN)
538 && (x >= target_width 414 && (x >= target_width
539 || y >= target_height 415 || y >= target_height
540 || (x + w <= 0) 416 || x + w <= 0
541 || (y + h <= 0)))) 417 || y + h <= 0)))
542 { 418 {
543 if (background) 419 if (background)
544 { 420 {
545 new_pmap_width = background->width; 421 new_pmap_width = background->width;
546 new_pmap_height = background->height; 422 new_pmap_height = background->height;
547 result = background; 423 result = background;
548 424
549 if (background_tint != TINT_LEAVE_SAME) 425 if (background_tint != TINT_LEAVE_SAME)
550 { 426 {
551 ASImage *tmp = tile_asimage (target->asv, background, 0, 0, 427 ASImage *tmp = tile_asimage (asv, background, 0, 0,
552 target_width, target_height, background_tint, 428 target_width, target_height, background_tint,
553 ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT); 429 ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
554 if (tmp) 430 if (tmp)
555 result = tmp; 431 result = tmp;
556 } 432 }
… …
560 } 436 }
561 else 437 else
562 { 438 {
563 result = original_asim; 439 result = original_asim;
564 440
565 if ((w != original_asim->width) 441 if (w != original_asim->width
566 || (h != original_asim->height)) 442 || h != original_asim->height)
567 { 443 {
568 result = scale_asimage (target->asv, original_asim, 444 result = scale_asimage (asv, original_asim,
569 w, h, 445 w, h,
570 background ? ASA_ASImage : ASA_XImage, 446 ASA_XImage,
571 100, ASIMAGE_QUALITY_DEFAULT); 447 100, ASIMAGE_QUALITY_DEFAULT);
572 } 448 }
573 449
574 if (background == NULL) 450 if (background == NULL)
575 { 451 {
576 if (h_scale == 0 || v_scale == 0) 452 if (bg_flags & BG_TILE)
577 { 453 {
578 /* if tiling - pixmap has to be sized exactly as the image, 454 /* if tiling - pixmap has to be sized exactly as the image,
579 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! */
580 new_pmap_width = min (result->width, target_width); 456 new_pmap_width = min (result->width, target_width);
581 new_pmap_height = min (result->height, target_height); 457 new_pmap_height = min (result->height, target_height);
582 458
583 /* we also need to tile our image in both directions */ 459 /* we also need to tile our image in both directions */
584 ASImage *tmp = tile_asimage (target->asv, result, 460 ASImage *tmp = tile_asimage (asv, result,
585 (int)result->width - x, 461 (int)result->width - x,
586 (int)result->height - y, 462 (int)result->height - y,
587 new_pmap_width, 463 new_pmap_width,
588 new_pmap_height, 464 new_pmap_height,
589 TINT_LEAVE_SAME, ASA_XImage, 465 TINT_LEAVE_SAME, ASA_XImage,
… …
606 layers[0].clip_width = target_width; 482 layers[0].clip_width = target_width;
607 layers[0].clip_height = target_height; 483 layers[0].clip_height = target_height;
608 layers[0].tint = background_tint; 484 layers[0].tint = background_tint;
609 layers[1].im = result; 485 layers[1].im = result;
610 486
611 if (h_scale == 0 || v_scale == 0) 487 if (bg_flags & BG_TILE)
612 { 488 {
613 /* tile horizontally */ 489 /* tile horizontally */
614 while (x > 0) x -= (int)result->width; 490 while (x > 0) x -= (int)result->width;
615 layers[1].dst_x = x; 491 layers[1].dst_x = x;
616 layers[1].clip_width = result->width+target_width; 492 layers[1].clip_width = result->width+target_width;
… …
620 /* clip horizontally */ 496 /* clip horizontally */
621 layers[1].dst_x = x; 497 layers[1].dst_x = x;
622 layers[1].clip_width = result->width; 498 layers[1].clip_width = result->width;
623 } 499 }
624 500
625 if (h_scale == 0 || v_scale == 0) 501 if (bg_flags & BG_TILE)
626 { 502 {
627 while (y > 0) y -= (int)result->height; 503 while (y > 0) y -= (int)result->height;
628 layers[1].dst_y = y; 504 layers[1].dst_y = y;
629 layers[1].clip_height = result->height + target_height; 505 layers[1].clip_height = result->height + target_height;
630 } 506 }
… …
632 { 508 {
633 layers[1].dst_y = y; 509 layers[1].dst_y = y;
634 layers[1].clip_height = result->height; 510 layers[1].clip_height = result->height;
635 } 511 }
636 512
637 if (target->rs[Rs_blendtype]) 513 if (rs[Rs_blendtype])
638 { 514 {
639 layers[1].merge_scanlines = blend_scanlines_name2func (target->rs[Rs_blendtype]); 515 layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
640 if (layers[1].merge_scanlines == NULL) 516 if (layers[1].merge_scanlines == NULL)
641 layers[1].merge_scanlines = alphablend_scanlines; 517 layers[1].merge_scanlines = alphablend_scanlines;
642 } 518 }
643 519
644 ASImage *tmp = merge_layers (target->asv, layers, 2, target_width, target_height, 520 ASImage *tmp = merge_layers (asv, layers, 2, target_width, target_height,
645 ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT); 521 ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
646 522
647 if (tmp) 523 if (tmp)
648 { 524 {
649 if (result != original_asim) 525 if (result != original_asim)
… …
661 if (result) 537 if (result)
662 { 538 {
663 XGCValues gcv; 539 XGCValues gcv;
664 GC gc; 540 GC gc;
665 541
666 if (pixmap)
667 {
668 if (pmap_width != new_pmap_width
669 || pmap_height != new_pmap_height
670 || pmap_depth != target->depth)
671 {
672 XFreePixmap (target->dpy, pixmap);
673 pixmap = None;
674 }
675 }
676
677 /* create Pixmap */ 542 /* create Pixmap */
678 if (pixmap == None) 543 if (bg_pixmap == None
544 || bg_pmap_width != new_pmap_width
545 || bg_pmap_height != new_pmap_height)
679 { 546 {
547 if (bg_pixmap)
548 XFreePixmap (dpy, bg_pixmap);
680 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);
681 pmap_width = new_pmap_width; 550 bg_pmap_width = new_pmap_width;
682 pmap_height = new_pmap_height; 551 bg_pmap_height = new_pmap_height;
683 pmap_depth = target->depth;
684 } 552 }
685 /* fill with background color (if result's not completely overlapping it) */ 553 /* fill with background color (if result's not completely overlapping it) */
686 gcv.foreground = target->pix_colors[Color_bg]; 554 gcv.foreground = pix_colors[Color_bg];
687 gc = XCreateGC (target->dpy, target->vt, GCForeground, &gcv); 555 gc = XCreateGC (dpy, vt, GCForeground, &gcv);
688 556
689 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;
690 int dst_width = result->width, dst_height = result->height; 558 int dst_width = result->width, dst_height = result->height;
691 if (background == NULL) 559 if (background == NULL)
692 { 560 {
693 if (!(h_scale == 0 || v_scale == 0)) 561 if (!(bg_flags & BG_TILE))
694 { 562 {
695 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 );
696 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);
697 } 565 }
698 566
699 if (dst_x > 0 || dst_y > 0 567 if (dst_x > 0 || dst_y > 0
700 || dst_x + dst_width < new_pmap_width 568 || dst_x + dst_width < new_pmap_width
701 || dst_y + dst_height < new_pmap_height) 569 || dst_y + dst_height < new_pmap_height)
702 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);
703 } 571 }
704 572
705 /* put result on pixmap */ 573 /* put result on pixmap */
706 if (dst_x < new_pmap_width && dst_y < new_pmap_height) 574 if (dst_x < new_pmap_width && dst_y < new_pmap_height)
707 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);
708 576
709 if (result != background && result != original_asim) 577 if (result != background && result != original_asim)
710 destroy_asimage (&result); 578 destroy_asimage (&result);
711 579
712 XFreeGC (target->dpy, gc); 580 XFreeGC (dpy, gc);
713 581
714 ret = true; 582 ret = true;
715 } 583 }
716 584
717 if (background) 585 if (background)
… …
721} 589}
722# endif /* HAVE_AFTERIMAGE */ 590# endif /* HAVE_AFTERIMAGE */
723 591
724# ifdef HAVE_PIXBUF 592# ifdef HAVE_PIXBUF
725bool 593bool
726bgPixmap_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)
727{ 597{
728 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)
729 return false; 608 return false;
730 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{
731 if (!pixbuf) 679 if (!pixbuf)
732 return false; 680 return false;
733 681
734#if !XRENDER 682 if (tr_flags
735 if (background_flags) 683 && !(bg_flags & BG_HAS_RENDER))
736 return false; 684 return false;
737#endif
738 685
739 GdkPixbuf *result; 686 GdkPixbuf *result;
740 687
741 int image_width = gdk_pixbuf_get_width (pixbuf); 688 int image_width = gdk_pixbuf_get_width (pixbuf);
742 int image_height = gdk_pixbuf_get_height (pixbuf); 689 int image_height = gdk_pixbuf_get_height (pixbuf);
743 690
744 int target_width = target->szHint.width; 691 int target_width = szHint.width;
745 int target_height = target->szHint.height; 692 int target_height = szHint.height;
746 int new_pmap_width = target_width; 693 int new_pmap_width = target_width;
747 int new_pmap_height = target_height; 694 int new_pmap_height = target_height;
748 695
749 int x = 0; 696 int x = 0;
750 int y = 0; 697 int y = 0;
751 int w = 0; 698 int w = 0;
752 int h = 0; 699 int h = 0;
753 700
754 get_image_geometry (image_width, image_height, w, h, x, y); 701 get_image_geometry (image_width, image_height, w, h, x, y);
755 702
756 if (!(flags & rootAlign) 703 if (!(bg_flags & BG_ROOT_ALIGN)
757 && (x >= target_width 704 && (x >= target_width
758 || y >= target_height 705 || y >= target_height
759 || (x + w <= 0) 706 || x + w <= 0
760 || (y + h <= 0))) 707 || y + h <= 0))
761 return false; 708 return false;
762 709
763 result = pixbuf; 710 result = pixbuf;
764 711
765 if ((w != image_width) 712 if (w != image_width
766 || (h != image_height)) 713 || h != image_height)
767 { 714 {
768 result = gdk_pixbuf_scale_simple (pixbuf, 715 result = gdk_pixbuf_scale_simple (pixbuf,
769 w, h, 716 w, h,
770 GDK_INTERP_BILINEAR); 717 GDK_INTERP_BILINEAR);
771 } 718 }
772 719
720 if (!result)
721 return false;
722
773 bool ret = false; 723 bool ret = false;
774 724
775 if (result)
776 {
777 XGCValues gcv; 725 XGCValues gcv;
778 GC gc; 726 GC gc;
779 Pixmap root_pmap; 727 Pixmap root_pmap;
780 728
781 image_width = gdk_pixbuf_get_width (result); 729 image_width = gdk_pixbuf_get_width (result);
782 image_height = gdk_pixbuf_get_height (result); 730 image_height = gdk_pixbuf_get_height (result);
783 731
784 if (background_flags) 732 if (tr_flags)
785 { 733 {
786 root_pmap = pixmap; 734 root_pmap = bg_pixmap;
787 pixmap = None; 735 bg_pixmap = None;
736 }
737 else
738 {
739 if (bg_flags & BG_TILE)
788 } 740 {
789 else
790 {
791 if (h_scale == 0 || v_scale == 0)
792 {
793 new_pmap_width = min (image_width, target_width); 741 new_pmap_width = min (image_width, target_width);
794 new_pmap_height = min (image_height, target_height); 742 new_pmap_height = min (image_height, target_height);
795 } 743 }
796 } 744 }
797 745
746 if (bg_pixmap == None
747 || bg_pmap_width != new_pmap_width
748 || bg_pmap_height != new_pmap_height)
749 {
798 if (pixmap) 750 if (bg_pixmap)
799 {
800 if (pmap_width != new_pmap_width
801 || pmap_height != new_pmap_height
802 || pmap_depth != target->depth)
803 {
804 XFreePixmap (target->dpy, pixmap); 751 XFreePixmap (dpy, bg_pixmap);
805 pixmap = None;
806 }
807 }
808
809 if (pixmap == None)
810 {
811 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);
812 pmap_width = new_pmap_width; 753 bg_pmap_width = new_pmap_width;
813 pmap_height = new_pmap_height; 754 bg_pmap_height = new_pmap_height;
814 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)
815 } 763 {
816
817 gcv.foreground = target->pix_colors[Color_bg];
818 gc = XCreateGC (target->dpy, target->vt, GCForeground, &gcv);
819
820 if (h_scale == 0 || v_scale == 0)
821 {
822 Pixmap tile = XCreatePixmap (target->dpy, target->vt, image_width, image_height, target->depth); 764 Pixmap tile = XCreatePixmap (dpy, vt, image_width, image_height, depth);
823 gdk_pixbuf_xlib_render_to_drawable (result, tile, gc, 765 pixbuf_to_pixmap (result, tile, gc,
824 0, 0, 766 0, 0,
825 0, 0, 767 0, 0,
826 image_width, image_height, 768 image_width, image_height);
827 XLIB_RGB_DITHER_NONE,
828 0, 0);
829 769
830 gcv.tile = tile; 770 gcv.tile = tile;
831 gcv.fill_style = FillTiled; 771 gcv.fill_style = FillTiled;
832 gcv.ts_x_origin = x; 772 gcv.ts_x_origin = x;
833 gcv.ts_y_origin = y; 773 gcv.ts_y_origin = y;
834 XChangeGC (target->dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); 774 XChangeGC (dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
835 775
836 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);
837 XFreePixmap (target->dpy, tile); 777 XFreePixmap (dpy, tile);
838 } 778 }
839 else 779 else
840 { 780 {
841 int src_x, src_y, dst_x, dst_y; 781 int src_x, src_y, dst_x, dst_y;
842 int dst_width, dst_height; 782 int dst_width, dst_height;
… …
845 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);
846 786
847 if (dst_x > 0 || dst_y > 0 787 if (dst_x > 0 || dst_y > 0
848 || dst_x + dst_width < new_pmap_width 788 || dst_x + dst_width < new_pmap_width
849 || dst_y + dst_height < new_pmap_height) 789 || dst_y + dst_height < new_pmap_height)
850 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);
851 791
852 if (dst_x < new_pmap_width && dst_y < new_pmap_height) 792 if (dst_x < new_pmap_width && dst_y < new_pmap_height)
853 gdk_pixbuf_xlib_render_to_drawable (result, pixmap, gc, 793 pixbuf_to_pixmap (result, bg_pixmap, gc,
854 src_x, src_y, 794 src_x, src_y,
855 dst_x, dst_y, 795 dst_x, dst_y,
856 dst_width, dst_height, 796 dst_width, dst_height);
857 XLIB_RGB_DITHER_NONE,
858 0, 0);
859 } 797 }
860 798
861#if XRENDER 799#if XRENDER
862 if (background_flags) 800 if (tr_flags)
863 { 801 {
864 Display *dpy = target->dpy;
865 XRenderPictureAttributes pa;
866
867 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, target->visual); 802 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
803
868 Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa); 804 Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
869 805
870 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, target->visual);
871 Picture dst = XRenderCreatePicture (dpy, pixmap, dst_format, 0, &pa); 806 Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
872 807
873 pa.repeat = True; 808 Picture mask = create_xrender_mask (dpy, vt, False, False);
874 Pixmap mask_pmap = XCreatePixmap (dpy, target->vt, 1, 1, 8);
875 XRenderPictFormat *mask_format = XRenderFindStandardFormat (dpy, PictStandardA8);
876 Picture mask = XRenderCreatePicture (dpy, mask_pmap, mask_format, CPRepeat, &pa);
877 XFreePixmap (dpy, mask_pmap);
878 809
879 if (src && dst && mask)
880 {
881 XRenderColor mask_c; 810 XRenderColor mask_c;
882 811
883 mask_c.alpha = 0x8000; 812 mask_c.alpha = 0x8000;
884 mask_c.red = 0; 813 mask_c.red =
885 mask_c.green = 0; 814 mask_c.green =
886 mask_c.blue = 0; 815 mask_c.blue = 0;
887 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1); 816 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
817
888 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);
889 }
890 819
891 XRenderFreePicture (dpy, src); 820 XRenderFreePicture (dpy, src);
892 XRenderFreePicture (dpy, dst); 821 XRenderFreePicture (dpy, dst);
893 XRenderFreePicture (dpy, mask); 822 XRenderFreePicture (dpy, mask);
894
895 XFreePixmap (dpy, root_pmap);
896 } 823 }
897#endif 824#endif
898 825
899 if (result != pixbuf)
900 g_object_unref (result);
901
902 XFreeGC (target->dpy, gc); 826 XFreeGC (dpy, gc);
903 827
904 ret = true; 828 ret = true;
905 } 829 }
906 830
831 if (result != pixbuf)
832 g_object_unref (result);
833
834 if (tr_flags)
835 XFreePixmap (dpy, root_pmap);
836
907 return ret; 837 return ret;
908} 838}
909# endif /* HAVE_PIXBUF */ 839# endif /* HAVE_PIXBUF */
910 840
911bool 841bool
912bgPixmap_t::set_file (const char *file) 842rxvt_term::bg_set_file (const char *file)
913{ 843{
914 assert (file); 844 if (!file || !*file)
845 return false;
915 846
916 if (*file) 847 bool ret = false;
917 {
918 if (const char *p = strchr (file, ';')) 848 const char *p = strchr (file, ';');
919 { 849
850 if (p)
851 {
920 size_t len = p - file; 852 size_t len = p - file;
921 char *f = rxvt_temp_buf<char> (len + 1); 853 char *f = rxvt_temp_buf<char> (len + 1);
922 memcpy (f, file, len); 854 memcpy (f, file, len);
923 f[len] = '\0'; 855 f[len] = '\0';
924 file = f; 856 file = f;
925 } 857 }
926 858
927# ifdef HAVE_AFTERIMAGE 859# ifdef HAVE_AFTERIMAGE
928 if (!target->asimman) 860 if (!asimman)
929 target->asimman = create_generic_imageman (target->rs[Rs_path]); 861 asimman = create_generic_imageman (rs[Rs_path]);
930 ASImage *image = get_asimage (target->asimman, file, 0xFFFFFFFF, 100); 862 ASImage *image = get_asimage (asimman, file, 0xFFFFFFFF, 100);
931 if (image) 863 if (image)
932 { 864 {
933 if (original_asim) 865 if (original_asim)
934 safe_asimage_destroy (original_asim); 866 safe_asimage_destroy (original_asim);
935 original_asim = image; 867 original_asim = image;
936 have_image = true; 868 bg_flags |= BG_IS_FROM_FILE | BG_CLIENT_RENDER;
937 return true; 869 ret = true;
938 } 870 }
939# endif 871# endif
940 872
941# ifdef HAVE_PIXBUF 873# ifdef HAVE_PIXBUF
942 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL); 874 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
943 if (image) 875 if (image)
944 { 876 {
945 if (pixbuf) 877 if (pixbuf)
946 g_object_unref (pixbuf); 878 g_object_unref (pixbuf);
947 pixbuf = image; 879 pixbuf = image;
948 have_image = true; 880 bg_flags |= BG_IS_FROM_FILE;
949 return true; 881 ret = true;
950 } 882 }
951# endif 883# endif
884
885 if (ret)
952 } 886 {
887 if (p)
888 bg_set_geometry (p + 1);
889 else
890 bg_set_default_geometry ();
891 }
953 892
954 return false; 893 return ret;
955} 894}
956 895
957# endif /* BG_IMAGE_FROM_FILE */ 896# endif /* BG_IMAGE_FROM_FILE */
958 897
959# ifdef ENABLE_TRANSPARENCY 898# ifdef ENABLE_TRANSPARENCY
960bool 899bool
961bgPixmap_t::set_transparent () 900rxvt_term::bg_set_transparent ()
962{ 901{
963 if (!(flags & isTransparent)) 902 if (!(bg_flags & BG_IS_TRANSPARENT))
964 { 903 {
965 flags |= isTransparent; 904 bg_flags |= BG_IS_TRANSPARENT;
966 return true; 905 return true;
967 } 906 }
968 907
969 return false; 908 return false;
970} 909}
971 910
972bool 911bool
973bgPixmap_t::set_blur_radius (const char *geom) 912rxvt_term::bg_set_blur (const char *geom)
974{ 913{
975 int changed = 0; 914 bool changed = false;
976 unsigned int hr, vr; 915 unsigned int hr, vr;
977 int junk; 916 int junk;
978 int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr); 917 int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr);
979 918
980 if (!(geom_flags & WidthValue)) 919 if (!(geom_flags & WidthValue))
… …
985 min_it (hr, 128); 924 min_it (hr, 128);
986 min_it (vr, 128); 925 min_it (vr, 128);
987 926
988 if (h_blurRadius != hr) 927 if (h_blurRadius != hr)
989 { 928 {
990 ++changed; 929 changed = true;
991 h_blurRadius = hr; 930 h_blurRadius = hr;
992 } 931 }
993 932
994 if (v_blurRadius != vr) 933 if (v_blurRadius != vr)
995 { 934 {
996 ++changed; 935 changed = true;
997 v_blurRadius = vr; 936 v_blurRadius = vr;
998 } 937 }
999 938
1000 if (v_blurRadius == 0 && h_blurRadius == 0) 939 if (h_blurRadius == 0 || v_blurRadius == 0)
1001 flags &= ~blurNeeded; 940 bg_flags &= ~BG_NEEDS_BLUR;
1002 else 941 else
1003 flags |= blurNeeded; 942 bg_flags |= BG_NEEDS_BLUR;
1004 943
1005#if XRENDER
1006 XFilters *filters = XRenderQueryFilters (target->dpy, target->vt);
1007 if (filters)
1008 {
1009 for (int i = 0; i < filters->nfilter; i++)
1010 if (!strcmp (filters->filter[i], FilterConvolution))
1011 flags |= bgPixmap_t::blurServerSide;
1012
1013 XFree (filters);
1014 }
1015#endif
1016
1017 return (changed > 0); 944 return changed;
1018} 945}
1019 946
1020static inline unsigned long 947void
1021compute_tint_shade_flags (rxvt_color *tint, int shade) 948rxvt_term::set_tint_shade_flags ()
1022{ 949{
1023 unsigned long flags = 0; 950 rgba c;
1024 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1025 bool has_shade = shade != 100; 951 bool has_shade = shade != 100;
1026 952
1027 if (tint) 953 bg_flags &= ~BG_TINT_FLAGS;
954
955 if (bg_flags & BG_TINT_SET)
1028 { 956 {
1029 tint->get (c); 957 tint.get (c);
1030# define IS_COMPONENT_WHOLESOME(cmp) ((cmp) <= 0x000700 || (cmp) >= 0x00f700)
1031 if (!has_shade && IS_COMPONENT_WHOLESOME (c.r)
1032 && IS_COMPONENT_WHOLESOME (c.g)
1033 && IS_COMPONENT_WHOLESOME (c.b))
1034 flags |= bgPixmap_t::tintWholesome;
1035# undef IS_COMPONENT_WHOLESOME
1036 }
1037
1038 if (has_shade) 958 if (!has_shade
1039 flags |= bgPixmap_t::tintNeeded; 959 && (c.r <= 0x00ff || c.r >= 0xff00)
1040 else if (tint) 960 && (c.g <= 0x00ff || c.g >= 0xff00)
961 && (c.b <= 0x00ff || c.b >= 0xff00))
962 bg_flags |= BG_TINT_BITAND;
1041 { 963 }
1042 if ((c.r > 0x000700 || c.g > 0x000700 || c.b > 0x000700)
1043 && (c.r < 0x00f700 || c.g < 0x00f700 || c.b < 0x00f700))
1044 {
1045 flags |= bgPixmap_t::tintNeeded;
1046 }
1047 }
1048 964
1049 if (flags & bgPixmap_t::tintNeeded) 965 if (has_shade || (bg_flags & BG_TINT_SET))
1050 { 966 bg_flags |= BG_NEEDS_TINT;
1051 if (flags & bgPixmap_t::tintWholesome)
1052 flags |= bgPixmap_t::tintServerSide;
1053 else
1054 {
1055#if XRENDER
1056 flags |= bgPixmap_t::tintServerSide;
1057#endif
1058 }
1059 }
1060
1061 return flags;
1062} 967}
1063 968
1064bool 969bool
1065bgPixmap_t::set_tint (rxvt_color &new_tint) 970rxvt_term::bg_set_tint (rxvt_color &new_tint)
1066{ 971{
1067 if (!(flags & tintSet) || tint != new_tint) 972 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
1068 { 973 {
1069 unsigned long new_flags = compute_tint_shade_flags (&new_tint, shade);
1070 tint = new_tint; 974 tint = new_tint;
1071 flags = (flags & ~tintFlags) | new_flags | tintSet; 975 bg_flags |= BG_TINT_SET;
976 set_tint_shade_flags ();
1072 return true; 977 return true;
1073 } 978 }
1074 979
1075 return false; 980 return false;
1076} 981}
1077 982
1078bool 983bool
1079bgPixmap_t::unset_tint ()
1080{
1081 unsigned long new_flags = compute_tint_shade_flags (NULL, shade);
1082
1083 if (new_flags != (flags & tintFlags))
1084 {
1085 flags = (flags & ~tintFlags) | new_flags;
1086 return true;
1087 }
1088
1089 return false;
1090}
1091
1092bool
1093bgPixmap_t::set_shade (const char *shade_str) 984rxvt_term::bg_set_shade (const char *shade_str)
1094{ 985{
1095 int new_shade = (shade_str) ? atoi (shade_str) : 100; 986 int new_shade = atoi (shade_str);
1096 987
1097 clamp_it (new_shade, -100, 200); 988 clamp_it (new_shade, -100, 200);
1098 if (new_shade < 0) 989 if (new_shade < 0)
1099 new_shade = 200 - (100 + new_shade); 990 new_shade = 200 - (100 + new_shade);
1100 991
1101 if (new_shade != shade) 992 if (new_shade != shade)
1102 { 993 {
1103 unsigned long new_flags = compute_tint_shade_flags ((flags & tintSet) ? &tint : NULL, new_shade);
1104 shade = new_shade; 994 shade = new_shade;
1105 flags = (flags & (~tintFlags | tintSet)) | new_flags; 995 set_tint_shade_flags ();
1106 return true; 996 return true;
1107 } 997 }
1108 998
1109 return false; 999 return false;
1110} 1000}
… …
1131 params[i+2] = XDoubleToFixed (kernel[i] / sum); 1021 params[i+2] = XDoubleToFixed (kernel[i] / sum);
1132} 1022}
1133#endif 1023#endif
1134 1024
1135bool 1025bool
1136bgPixmap_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)
1137{ 1027{
1138 bool ret = false; 1028 bool ret = false;
1139#if XRENDER 1029#if XRENDER
1030 if (!(bg_flags & BG_HAS_RENDER_CONV))
1031 return false;
1032
1140 int size = max (h_blurRadius, v_blurRadius) * 2 + 1; 1033 int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1141 double *kernel = (double *)malloc (size * sizeof (double)); 1034 double *kernel = (double *)malloc (size * sizeof (double));
1142 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 1035 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1143 1036
1144 Display *dpy = target->dpy;
1145 XRenderPictureAttributes pa; 1037 XRenderPictureAttributes pa;
1146 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 1038 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1147 1039
1040 pa.repeat = RepeatPad;
1148 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);
1149 Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 1043 Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
1044 XFreePixmap (dpy, tmp);
1150 1045
1151 if (kernel && params && src && dst) 1046 if (kernel && params)
1152 { 1047 {
1153 if (h_blurRadius)
1154 {
1155 size = h_blurRadius * 2 + 1; 1048 size = h_blurRadius * 2 + 1;
1156 get_gaussian_kernel (h_blurRadius, size, kernel, params); 1049 get_gaussian_kernel (h_blurRadius, size, kernel, params);
1157 1050
1158 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 1051 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1159 XRenderComposite (dpy, 1052 XRenderComposite (dpy,
1160 PictOpSrc, 1053 PictOpSrc,
1161 src, 1054 src,
1162 None, 1055 None,
1163 dst, 1056 dst,
1164 0, 0, 1057 0, 0,
1165 0, 0, 1058 0, 0,
1166 0, 0, 1059 0, 0,
1167 width, height); 1060 width, height);
1168 }
1169 1061
1170 if (v_blurRadius) 1062 ::swap (src, dst);
1171 { 1063
1172 size = v_blurRadius * 2 + 1; 1064 size = v_blurRadius * 2 + 1;
1173 get_gaussian_kernel (v_blurRadius, size, kernel, params); 1065 get_gaussian_kernel (v_blurRadius, size, kernel, params);
1174 swap (params[0], params[1]); 1066 ::swap (params[0], params[1]);
1175 1067
1176 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 1068 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1177 XRenderComposite (dpy, 1069 XRenderComposite (dpy,
1178 PictOpSrc, 1070 PictOpSrc,
1179 src, 1071 src,
1180 None, 1072 None,
1181 dst, 1073 dst,
1182 0, 0, 1074 0, 0,
1183 0, 0, 1075 0, 0,
1184 0, 0, 1076 0, 0,
1185 width, height); 1077 width, height);
1186 }
1187 1078
1188 ret = true; 1079 ret = true;
1189 } 1080 }
1190 1081
1191 free (kernel); 1082 free (kernel);
… …
1195#endif 1086#endif
1196 return ret; 1087 return ret;
1197} 1088}
1198 1089
1199bool 1090bool
1200bgPixmap_t::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 1091rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1201{ 1092{
1202 Display *dpy = target->dpy;
1203 bool ret = false; 1093 bool ret = false;
1204 1094
1205 if (flags & tintWholesome) 1095 if (bg_flags & BG_TINT_BITAND)
1206 { 1096 {
1207 XGCValues gcv; 1097 XGCValues gcv;
1208 GC gc; 1098 GC gc;
1209 1099
1210 /* In this case we can tint image server-side getting significant 1100 /* In this case we can tint image server-side getting significant
… …
1219 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height); 1109 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1220 ret = true; 1110 ret = true;
1221 XFreeGC (dpy, gc); 1111 XFreeGC (dpy, gc);
1222 } 1112 }
1223 } 1113 }
1224 else
1225 {
1226# if XRENDER 1114# if XRENDER
1115 else if (bg_flags & BG_HAS_RENDER)
1116 {
1227 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 1117 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1228 1118
1229 if (flags & tintSet) 1119 if (bg_flags & BG_TINT_SET)
1230 tint.get (c); 1120 tint.get (c);
1231 1121
1232 if (shade <= 100) 1122 if (shade <= 100)
1233 { 1123 {
1234 c.r = (c.r * shade) / 100; 1124 c.r = c.r * shade / 100;
1235 c.g = (c.g * shade) / 100; 1125 c.g = c.g * shade / 100;
1236 c.b = (c.b * shade) / 100; 1126 c.b = c.b * shade / 100;
1237 } 1127 }
1238 else 1128 else
1239 { 1129 {
1240 c.r = ((0xffff - c.r) * (200 - shade)) / 100; 1130 c.r = c.r * (200 - shade) / 100;
1241 c.g = ((0xffff - c.g) * (200 - shade)) / 100; 1131 c.g = c.g * (200 - shade) / 100;
1242 c.b = ((0xffff - c.b) * (200 - shade)) / 100; 1132 c.b = c.b * (200 - shade) / 100;
1243 } 1133 }
1244 1134
1245 XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1246 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 1135 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1247 XRenderPictureAttributes pa;
1248 1136
1249 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 1137 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1250 1138
1251 pa.repeat = True; 1139 Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1252 1140
1253 Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32); 1141 Picture mask_pic = create_xrender_mask (dpy, pixmap, True, True);
1254 Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1255 XFreePixmap (dpy, overlay_pmap);
1256 1142
1257 pa.component_alpha = True;
1258 Pixmap mask_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
1259 Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat|CPComponentAlpha, &pa);
1260 XFreePixmap (dpy, mask_pmap);
1261
1262 if (mask_pic && overlay_pic && back_pic)
1263 {
1264 XRenderColor mask_c; 1143 XRenderColor mask_c;
1265 1144
1266 memset (&mask_c, (shade > 100) ? 0xFF : 0x0, sizeof (mask_c));
1267 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;
1268 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1); 1165 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1269 1166
1270 mask_c.alpha = 0;
1271 mask_c.red = 0xffff - c.r;
1272 mask_c.green = 0xffff - c.g;
1273 mask_c.blue = 0xffff - c.b;
1274 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
1275 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
1276 ret = true; 1170 ret = true;
1277 }
1278 1171
1279 XRenderFreePicture (dpy, mask_pic); 1172 XRenderFreePicture (dpy, mask_pic);
1280 XRenderFreePicture (dpy, overlay_pic); 1173 XRenderFreePicture (dpy, overlay_pic);
1281 XRenderFreePicture (dpy, back_pic); 1174 XRenderFreePicture (dpy, back_pic);
1175 }
1282# endif 1176# endif
1283 }
1284 1177
1285 return ret; 1178 return ret;
1286} 1179}
1287 1180
1288/* make_transparency_pixmap() 1181/*
1289 * Builds a pixmap of the same size as the terminal window that contains 1182 * Builds a pixmap of the same size as the terminal window that contains
1290 * the 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
1291 * our window. 1184 * our window.
1292 */ 1185 */
1293unsigned long 1186unsigned long
1294bgPixmap_t::make_transparency_pixmap () 1187rxvt_term::make_transparency_pixmap ()
1295{ 1188{
1296 unsigned long result = 0; 1189 unsigned long result = 0;
1297
1298 if (target == NULL)
1299 return 0;
1300 1190
1301 /* 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
1302 * be always up-to-date, so let's use it : 1192 * be always up-to-date, so let's use it :
1303 */ 1193 */
1304 int screen = target->display->screen; 1194 int screen = display->screen;
1305 Display *dpy = target->dpy;
1306 int root_depth = DefaultDepth (dpy, screen); 1195 int root_depth = DefaultDepth (dpy, screen);
1307 int root_width = DisplayWidth (dpy, screen); 1196 int root_width = DisplayWidth (dpy, screen);
1308 int root_height = DisplayHeight (dpy, screen); 1197 int root_height = DisplayHeight (dpy, screen);
1309 unsigned int root_pmap_width, root_pmap_height; 1198 unsigned int root_pmap_width, root_pmap_height;
1310 int window_width = target->szHint.width; 1199 int window_width = szHint.width;
1311 int window_height = target->szHint.height; 1200 int window_height = szHint.height;
1312 int sx, sy; 1201 int sx, sy;
1313 XGCValues gcv; 1202 XGCValues gcv;
1314 GC gc; 1203 GC gc;
1315 1204
1316 target->get_window_origin (sx, sy); 1205 sx = target_x;
1206 sy = target_y;
1317 1207
1318 /* 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 : */
1319 if (sx + window_width <= 0 || sy + window_height <= 0 1209 if (sx + window_width <= 0 || sy + window_height <= 0
1320 || sx >= root_width || sy >= root_height) 1210 || sx >= root_width || sy >= root_height)
1321 return 0; 1211 return 0;
… …
1325 { 1215 {
1326 Window wdummy; 1216 Window wdummy;
1327 int idummy; 1217 int idummy;
1328 unsigned int udummy; 1218 unsigned int udummy;
1329 1219
1330 target->allowedxerror = -1; 1220 allowedxerror = -1;
1331 1221
1332 if (!XGetGeometry (dpy, root_pixmap, &wdummy, &idummy, &idummy, &root_pmap_width, &root_pmap_height, &udummy, &udummy)) 1222 if (!XGetGeometry (dpy, root_pixmap, &wdummy, &idummy, &idummy, &root_pmap_width, &root_pmap_height, &udummy, &udummy))
1333 root_pixmap = None; 1223 root_pixmap = None;
1334 1224
1335 target->allowedxerror = 0; 1225 allowedxerror = 0;
1336 } 1226 }
1337 1227
1338 Pixmap recoded_root_pmap = root_pixmap; 1228 Pixmap recoded_root_pmap = root_pixmap;
1339 1229
1340 if (root_pixmap != None && root_depth != target->depth) 1230 if (root_pixmap != None && root_depth != depth)
1341 { 1231 {
1342#if XRENDER 1232#if XRENDER
1343 XRenderPictureAttributes pa; 1233 if (bg_flags & BG_HAS_RENDER)
1234 {
1235 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1344 1236
1345 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen)); 1237 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1346 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa); 1238 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1347 1239
1348 recoded_root_pmap = XCreatePixmap (dpy, target->vt, root_pmap_width, root_pmap_height, target->depth);
1349 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, target->visual); 1240 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1350 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa); 1241 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1351 1242
1352 if (src && dst)
1353 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height); 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 }
1354 else 1248 else
1355 root_pixmap = None;
1356
1357 XRenderFreePicture (dpy, src);
1358 XRenderFreePicture (dpy, dst);
1359#else
1360 root_pixmap = None;
1361#endif 1249#endif
1250 recoded_root_pmap = None;
1362 } 1251 }
1363 1252
1364 if (root_pixmap == None) 1253 if (recoded_root_pmap == None)
1365 return 0; 1254 return 0;
1366 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);
1367 Pixmap tiled_root_pmap = XCreatePixmap (dpy, target->vt, window_width, window_height, target->depth); 1262 bg_pixmap = XCreatePixmap (dpy, vt, window_width, window_height, depth);
1368 1263 bg_pmap_width = window_width;
1369 if (tiled_root_pmap == None) /* something really bad happened - abort */ 1264 bg_pmap_height = window_height;
1370 return 0; 1265 }
1371 1266
1372 /* straightforward pixmap copy */ 1267 /* straightforward pixmap copy */
1268 while (sx < 0) sx += root_pmap_width;
1269 while (sy < 0) sy += root_pmap_height;
1270
1373 gcv.tile = recoded_root_pmap; 1271 gcv.tile = recoded_root_pmap;
1374 gcv.fill_style = FillTiled; 1272 gcv.fill_style = FillTiled;
1375
1376 while (sx < 0) sx += (int)root_width;
1377 while (sy < 0) sy += (int)root_height;
1378
1379 gcv.ts_x_origin = -sx; 1273 gcv.ts_x_origin = -sx;
1380 gcv.ts_y_origin = -sy; 1274 gcv.ts_y_origin = -sy;
1381 gc = XCreateGC (dpy, target->vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); 1275 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1382 1276
1383 if (gc) 1277 if (gc)
1384 { 1278 {
1385 XFillRectangle (dpy, tiled_root_pmap, gc, 0, 0, window_width, window_height); 1279 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1386 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
1387 XFreeGC (dpy, gc); 1310 XFreeGC (dpy, gc);
1388 }
1389
1390 if (tiled_root_pmap != None)
1391 {
1392 if (!need_client_side_rendering ())
1393 {
1394 if (flags & (blurNeeded | blurServerSide))
1395 {
1396 if (blur_pixmap (tiled_root_pmap, target->visual, window_width, window_height))
1397 result |= transpPmapBlurred;
1398 }
1399 if (flags & (tintNeeded | tintServerSide))
1400 {
1401 if (tint_pixmap (tiled_root_pmap, target->visual, window_width, window_height))
1402 result |= transpPmapTinted;
1403 }
1404 } /* server side rendering completed */
1405
1406 if (pixmap)
1407 XFreePixmap (dpy, pixmap);
1408
1409 pixmap = tiled_root_pmap;
1410 pmap_width = window_width;
1411 pmap_height = window_height;
1412 pmap_depth = target->depth;
1413 } 1311 }
1414 1312
1415 if (recoded_root_pmap != root_pixmap) 1313 if (recoded_root_pmap != root_pixmap)
1416 XFreePixmap (dpy, recoded_root_pmap); 1314 XFreePixmap (dpy, recoded_root_pmap);
1417 1315
1418 return result; 1316 return result;
1419} 1317}
1420 1318
1421void 1319void
1422bgPixmap_t::set_root_pixmap () 1320rxvt_term::bg_set_root_pixmap ()
1423{ 1321{
1424 Pixmap new_root_pixmap = target->get_pixmap_property (XA_XROOTPMAP_ID); 1322 Pixmap new_root_pixmap = get_pixmap_property (xa[XA_XROOTPMAP_ID]);
1425 if (new_root_pixmap == None) 1323 if (new_root_pixmap == None)
1426 new_root_pixmap = target->get_pixmap_property (XA_ESETROOT_PMAP_ID); 1324 new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]);
1427 1325
1428 root_pixmap = new_root_pixmap; 1326 root_pixmap = new_root_pixmap;
1429} 1327}
1430# endif /* ENABLE_TRANSPARENCY */ 1328# endif /* ENABLE_TRANSPARENCY */
1431 1329
1432# ifndef HAVE_AFTERIMAGE 1330bool
1433static void ShadeXImage(Visual *visual, XImage *srcImage, int shade, int rm, int gm, int bm); 1331rxvt_term::bg_render ()
1332{
1333 unsigned long tr_flags = 0;
1334
1335 bg_invalidate ();
1336# ifdef ENABLE_TRANSPARENCY
1337 if (bg_flags & BG_IS_TRANSPARENT)
1338 {
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 }
1434# endif 1344# endif
1435 1345
1436bool 1346# ifdef BG_IMAGE_FROM_FILE
1437bgPixmap_t::render () 1347 if ((bg_flags & BG_IS_FROM_FILE)
1438{ 1348 || (tr_flags & BG_EFFECTS_FLAGS))
1439 unsigned long background_flags = 0;
1440
1441 if (target == NULL)
1442 return false;
1443
1444 invalidate ();
1445# ifdef ENABLE_TRANSPARENCY
1446 if (flags & isTransparent)
1447 { 1349 {
1448 /* we need to re-generate transparency pixmap in that case ! */ 1350 if (render_image (tr_flags))
1449 background_flags = make_transparency_pixmap (); 1351 bg_flags |= BG_IS_VALID;
1450 if (background_flags == 0)
1451 return false;
1452 else if ((background_flags & transpTransformations) == (flags & transpTransformations))
1453 flags = flags & ~isInvalid;
1454 } 1352 }
1455# endif 1353# endif
1456 1354
1457# ifdef BG_IMAGE_FROM_FILE 1355 if (!(bg_flags & BG_IS_VALID))
1458 if (have_image
1459 || (background_flags & transpTransformations) != (flags & transpTransformations))
1460 {
1461 if (render_image (background_flags))
1462 flags = flags & ~isInvalid;
1463 } 1356 {
1464# endif
1465
1466 XImage *result = NULL;
1467
1468 if (background_flags && (flags & isInvalid))
1469 {
1470 result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap);
1471 }
1472
1473 if (result)
1474 {
1475# if !defined(HAVE_AFTERIMAGE) && !XRENDER
1476 /* our own client-side tinting */
1477 if (!(background_flags & transpPmapTinted) && (flags & tintNeeded))
1478 {
1479 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1480 if (flags & tintSet)
1481 tint.get (c);
1482 ShadeXImage (DefaultVisual (target->dpy, target->display->screen), result, shade, c.r, c.g, c.b);
1483 }
1484# endif
1485
1486 GC gc = XCreateGC (target->dpy, target->vt, 0UL, NULL);
1487
1488 if (gc)
1489 {
1490 XPutImage (target->dpy, pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1491
1492 XFreeGC (target->dpy, gc);
1493 flags = flags & ~isInvalid;
1494 }
1495
1496 XDestroyImage (result);
1497 }
1498
1499 if (flags & isInvalid)
1500 {
1501 if (pixmap != None) 1357 if (bg_pixmap != None)
1502 { 1358 {
1503 XFreePixmap (target->dpy, pixmap); 1359 XFreePixmap (dpy, bg_pixmap);
1504 pixmap = None; 1360 bg_pixmap = None;
1505 } 1361 }
1506 } 1362 }
1507 1363
1508 apply (); 1364 scr_recolour (false);
1365 bg_flags |= BG_NEEDS_REFRESH;
1509 1366
1510 valid_since = ev::now (); 1367 bg_valid_since = ev::now ();
1511 1368
1512 return true; 1369 return true;
1513} 1370}
1514 1371
1515bool
1516bgPixmap_t::set_target (rxvt_term *new_target)
1517{
1518 if (new_target)
1519 if (target != new_target)
1520 {
1521 target = new_target;
1522 return true;
1523 }
1524
1525 return false;
1526}
1527
1528void 1372void
1529bgPixmap_t::apply () 1373rxvt_term::bg_init ()
1530{ 1374{
1531 if (target)
1532 {
1533 if (pixmap != None)
1534 {
1535 /* set target's background to pixmap */
1536# ifdef ENABLE_TRANSPARENCY 1375#ifdef ENABLE_TRANSPARENCY
1537 if (flags & isTransparent) 1376 shade = 100;
1538 {
1539 XSetWindowBackgroundPixmap (target->dpy, target->parent[0], pixmap);
1540 XSetWindowBackgroundPixmap (target->dpy, target->vt, ParentRelative);
1541
1542 if (target->scrollBar.win)
1543 XSetWindowBackgroundPixmap (target->dpy, target->scrollBar.win, ParentRelative);
1544 }
1545 else
1546# endif 1377#endif
1547 {
1548 /* force old pixmap dereference in case it was transparent before :*/
1549 XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
1550 XSetWindowBackgroundPixmap (target->dpy, target->vt, pixmap);
1551 /* do we also need to set scrollbar's background here ? */
1552 1378
1553 if (target->scrollBar.win) 1379 bg_flags &= ~(BG_HAS_RENDER | BG_HAS_RENDER_CONV);
1554 XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]); 1380#if XRENDER
1555 } 1381 int major, minor;
1556 } 1382 if (XRenderQueryVersion (dpy, &major, &minor))
1557 else 1383 bg_flags |= BG_HAS_RENDER;
1558 { 1384 XFilters *filters = XRenderQueryFilters (dpy, vt);
1559 /* set target background to a pixel */ 1385 if (filters)
1560 XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
1561 XSetWindowBackground (target->dpy, target->vt, target->pix_colors[Color_bg]);
1562 /* do we also need to set scrollbar's background here ? */
1563 if (target->scrollBar.win)
1564 XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);
1565 }
1566
1567 /* don't want Expose on the parent or vt. It is better to use
1568 scr_touch or we get a great deal of flicker otherwise: */
1569 XClearWindow (target->dpy, target->parent[0]);
1570
1571 if (target->scrollBar.state && target->scrollBar.win)
1572 {
1573 target->scrollBar.state = STATE_IDLE;
1574 target->scrollBar.show (0);
1575 }
1576
1577 target->want_refresh = 1;
1578 flags |= hasChanged;
1579 } 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
1580} 1394}
1581 1395
1582#endif /* HAVE_BG_PIXMAP */ 1396#endif /* HAVE_BG_PIXMAP */
1583 1397
1584#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) && !XRENDER 1398#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1585/* taken from aterm-0.4.2 */ 1399/* based on code from aterm-0.4.2 */
1586 1400
1587static void 1401static inline void
1588ShadeXImage(Visual *visual, 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)
1589{ 1415{
1590 int sh_r, sh_g, sh_b; 1416 int sh_r, sh_g, sh_b;
1591 uint32_t mask_r, mask_g, mask_b; 1417 uint32_t mask_r, mask_g, mask_b;
1592 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b; 1418 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1593 unsigned int lower_lim_r, lower_lim_g, lower_lim_b; 1419 unsigned short low;
1594 unsigned int upper_lim_r, upper_lim_g, upper_lim_b;
1595 int i;
1596 int host_byte_order = byteorder.big_endian () ? MSBFirst : LSBFirst; 1420 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1597 1421
1598 if (visual->c_class != TrueColor || srcImage->format != ZPixmap) return; 1422 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;
1599 1423
1600 /* for convenience */ 1424 /* for convenience */
1601 mask_r = visual->red_mask; 1425 mask_r = visual->red_mask;
1602 mask_g = visual->green_mask; 1426 mask_g = visual->green_mask;
1603 mask_b = visual->blue_mask; 1427 mask_b = visual->blue_mask;
1604 1428
1605 /* boring lookup table pre-initialization */ 1429 /* boring lookup table pre-initialization */
1606 switch (srcImage->depth) 1430 switch (ximage->depth)
1607 { 1431 {
1608 case 15: 1432 case 15:
1609 if ((mask_r != 0x7c00) || 1433 if ((mask_r != 0x7c00) ||
1610 (mask_g != 0x03e0) || 1434 (mask_g != 0x03e0) ||
1611 (mask_b != 0x001f)) 1435 (mask_b != 0x001f))
… …
1659 break; 1483 break;
1660 default: 1484 default:
1661 return; /* we do not support this color depth */ 1485 return; /* we do not support this color depth */
1662 } 1486 }
1663 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
1664 /* prepare limits for color transformation (each channel is handled separately) */ 1493 /* prepare limits for color transformation (each channel is handled separately) */
1665 if (shade > 100) 1494 if (shade > 100)
1666 { 1495 {
1667 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;
1668 1499
1669 lower_lim_r = 65535-rm; 1500 low = 0xffff * (shade - 100) / 100;
1670 lower_lim_g = 65535-gm;
1671 lower_lim_b = 65535-bm;
1672
1673 lower_lim_r = 65535-(unsigned int)(((uint32_t)lower_lim_r)*((uint32_t)shade)/100);
1674 lower_lim_g = 65535-(unsigned int)(((uint32_t)lower_lim_g)*((uint32_t)shade)/100);
1675 lower_lim_b = 65535-(unsigned int)(((uint32_t)lower_lim_b)*((uint32_t)shade)/100);
1676
1677 upper_lim_r = upper_lim_g = upper_lim_b = 65535;
1678 } 1501 }
1679 else 1502 else
1680 { 1503 {
1504 c.r = c.r * shade / 100;
1505 c.g = c.g * shade / 100;
1506 c.b = c.b * shade / 100;
1681 1507
1682 lower_lim_r = lower_lim_g = lower_lim_b = 0; 1508 low = 0;
1683
1684 upper_lim_r = (unsigned int)((((uint32_t)rm)*((uint32_t)shade))/100);
1685 upper_lim_g = (unsigned int)((((uint32_t)gm)*((uint32_t)shade))/100);
1686 upper_lim_b = (unsigned int)((((uint32_t)bm)*((uint32_t)shade))/100);
1687 } 1509 }
1688 1510
1689 /* fill our lookup tables */ 1511 /* fill our lookup tables */
1690 for (i = 0; i <= mask_r>>sh_r; i++) 1512 fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1691 { 1513 fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1692 uint32_t tmp; 1514 fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1693 tmp = ((uint32_t)i)*((uint32_t)(upper_lim_r-lower_lim_r));
1694 tmp += ((uint32_t)(mask_r>>sh_r))*((uint32_t)lower_lim_r);
1695 lookup_r[i] = (tmp/65535)<<sh_r;
1696 }
1697 for (i = 0; i <= mask_g>>sh_g; i++)
1698 {
1699 uint32_t tmp;
1700 tmp = ((uint32_t)i)*((uint32_t)(upper_lim_g-lower_lim_g));
1701 tmp += ((uint32_t)(mask_g>>sh_g))*((uint32_t)lower_lim_g);
1702 lookup_g[i] = (tmp/65535)<<sh_g;
1703 }
1704 for (i = 0; i <= mask_b>>sh_b; i++)
1705 {
1706 uint32_t tmp;
1707 tmp = ((uint32_t)i)*((uint32_t)(upper_lim_b-lower_lim_b));
1708 tmp += ((uint32_t)(mask_b>>sh_b))*((uint32_t)lower_lim_b);
1709 lookup_b[i] = (tmp/65535)<<sh_b;
1710 }
1711 1515
1712 /* apply table to input image (replacing colors by newly calculated ones) */ 1516 /* apply table to input image (replacing colors by newly calculated ones) */
1713 if (srcImage->bits_per_pixel == 32 1517 if (ximage->bits_per_pixel == 32
1714 && (srcImage->depth == 24 || srcImage->depth == 32) 1518 && (ximage->depth == 24 || ximage->depth == 32)
1715 && srcImage->byte_order == host_byte_order) 1519 && ximage->byte_order == host_byte_order)
1716 { 1520 {
1717 uint32_t *p1, *pf, *p, *pl; 1521 uint32_t *p1, *pf, *p, *pl;
1718 p1 = (uint32_t *) srcImage->data; 1522 p1 = (uint32_t *) ximage->data;
1719 pf = (uint32_t *) (srcImage->data + srcImage->height * srcImage->bytes_per_line); 1523 pf = (uint32_t *) (ximage->data + ximage->height * ximage->bytes_per_line);
1720 1524
1721 while (p1 < pf) 1525 while (p1 < pf)
1722 { 1526 {
1723 p = p1; 1527 p = p1;
1724 pl = p1 + srcImage->width; 1528 pl = p1 + ximage->width;
1725 for (; p < pl; p++) 1529 for (; p < pl; p++)
1726 { 1530 {
1727 *p = lookup_r[(*p & 0xff0000) >> 16] | 1531 *p = lookup_r[(*p & 0xff0000) >> 16] |
1728 lookup_g[(*p & 0x00ff00) >> 8] | 1532 lookup_g[(*p & 0x00ff00) >> 8] |
1729 lookup_b[(*p & 0x0000ff)] | 1533 lookup_b[(*p & 0x0000ff)] |
1730 (*p & 0xff000000); 1534 (*p & 0xff000000);
1731 } 1535 }
1732 p1 = (uint32_t *) ((char *) p1 + srcImage->bytes_per_line); 1536 p1 = (uint32_t *) ((char *) p1 + ximage->bytes_per_line);
1733 } 1537 }
1734 } 1538 }
1735 else 1539 else
1736 { 1540 {
1737 for (int y = 0; y < srcImage->height; y++) 1541 for (int y = 0; y < ximage->height; y++)
1738 for (int x = 0; x < srcImage->width; x++) 1542 for (int x = 0; x < ximage->width; x++)
1739 { 1543 {
1740 unsigned long pixel = XGetPixel (srcImage, x, y); 1544 unsigned long pixel = XGetPixel (ximage, x, y);
1741 pixel = lookup_r[(pixel & mask_r) >> sh_r] | 1545 pixel = lookup_r[(pixel & mask_r) >> sh_r] |
1742 lookup_g[(pixel & mask_g) >> sh_g] | 1546 lookup_g[(pixel & mask_g) >> sh_g] |
1743 lookup_b[(pixel & mask_b) >> sh_b]; 1547 lookup_b[(pixel & mask_b) >> sh_b];
1744 XPutPixel (srcImage, x, y, pixel); 1548 XPutPixel (ximage, x, y, pixel);
1745 } 1549 }
1746 } 1550 }
1747 1551
1748 free (lookup); 1552 free (lookup);
1749} 1553}

Diff Legend

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