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.174 by sf-exg, Wed Nov 23 16:53:53 2011 UTC vs.
Revision 1.218 by sf-exg, Mon May 21 12:29:22 2012 UTC

… …
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 <schmorp@schmorp.de> 6 * Copyright (c) 2005-2008 Marc Lehmann <schmorp@schmorp.de>
7 * Copyright (c) 2007 Sasha Vasko <sasha@aftercode.net> 7 * Copyright (c) 2007 Sasha Vasko <sasha@aftercode.net>
8 * Copyright (c) 2010 Emanuele Giaquinta <e.giaquinta@glauco.it> 8 * Copyright (c) 2010-2012 Emanuele Giaquinta <e.giaquinta@glauco.it>
9 * 9 *
10 * This program is free software; you can redistribute it and/or modify 10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by 11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or 12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version. 13 * (at your option) any later version.
… …
20 * You should have received a copy of the GNU General Public License 20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software 21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 *---------------------------------------------------------------------*/ 23 *---------------------------------------------------------------------*/
24 24
25#include <cmath> 25#include <math.h>
26#include "../config.h" /* NECESSARY */ 26#include "../config.h" /* NECESSARY */
27#include "rxvt.h" /* NECESSARY */ 27#include "rxvt.h" /* NECESSARY */
28 28
29#if XRENDER 29#if XRENDER
30# include <X11/extensions/Xrender.h> 30# include <X11/extensions/Xrender.h>
… …
32 32
33#ifndef FilterConvolution 33#ifndef FilterConvolution
34#define FilterConvolution "convolution" 34#define FilterConvolution "convolution"
35#endif 35#endif
36 36
37#ifndef RepeatPad
38#define RepeatPad True
39#endif
40
37#ifdef HAVE_BG_PIXMAP 41#ifdef HAVE_BG_PIXMAP
42# if XRENDER
43static Picture
44create_xrender_mask (Display *dpy, Drawable drawable, Bool argb, Bool component_alpha)
45{
46 Pixmap pixmap = XCreatePixmap (dpy, drawable, 1, 1, argb ? 32 : 8);
47
48 XRenderPictFormat *format = XRenderFindStandardFormat (dpy, argb ? PictStandardARGB32 : PictStandardA8);
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}
58# endif
59
38void 60void
39rxvt_term::bg_destroy () 61rxvt_term::bg_destroy ()
40{ 62{
41#ifdef HAVE_AFTERIMAGE
42 if (original_asim)
43 safe_asimage_destroy (original_asim);
44 if (asv)
45 destroy_asvisual (asv, 0);
46 if (asimman)
47 destroy_image_manager (asimman, 0);
48#endif
49
50#ifdef HAVE_PIXBUF
51 if (pixbuf)
52 g_object_unref (pixbuf);
53#endif
54
55 if (bg_pixmap) 63 if (bg_pixmap)
56 XFreePixmap (dpy, bg_pixmap); 64 XFreePixmap (dpy, bg_pixmap);
57} 65}
58 66
59bool 67bool
… …
77 if (bg_flags & BG_IS_TRANSPARENT) 85 if (bg_flags & BG_IS_TRANSPARENT)
78 return true; 86 return true;
79# endif 87# endif
80 88
81# ifdef BG_IMAGE_FROM_FILE 89# ifdef BG_IMAGE_FROM_FILE
82 if (bg_flags & BG_IS_FROM_FILE) 90 if (bg_image.flags & IM_IS_SET)
83 { 91 {
84 if (bg_flags & BG_IS_SIZE_SENSITIVE) 92 if ((bg_image.flags & IM_IS_SIZE_SENSITIVE)
93 || bg_image.width () > szHint.width
94 || bg_image.height () > szHint.height)
85 return true; 95 return true;
86 } 96 }
87# endif 97# endif
88 98
89 return false; 99 return false;
… …
96 if (bg_flags & BG_IS_TRANSPARENT) 106 if (bg_flags & BG_IS_TRANSPARENT)
97 return true; 107 return true;
98# endif 108# endif
99 109
100# ifdef BG_IMAGE_FROM_FILE 110# ifdef BG_IMAGE_FROM_FILE
101 if (bg_flags & BG_IS_FROM_FILE) 111 if (bg_image.flags & IM_IS_SET)
102 { 112 {
103 if (bg_flags & BG_ROOT_ALIGN) 113 if (bg_image.flags & IM_ROOT_ALIGN)
104 return true; 114 return true;
105 } 115 }
106# endif 116# endif
107 117
108 return false; 118 return false;
109} 119}
110 120
111# ifdef BG_IMAGE_FROM_FILE 121# ifdef BG_IMAGE_FROM_FILE
112static inline bool
113check_set_scale_value (int geom_flags, int flag, unsigned int &scale, unsigned int new_value)
114{
115 if (geom_flags & flag)
116 {
117 if (new_value > 1000)
118 new_value = 1000;
119 if (new_value != scale)
120 {
121 scale = new_value;
122 return true;
123 }
124 }
125 return false;
126}
127
128static inline bool
129check_set_align_value (int geom_flags, int flag, int &align, int new_value)
130{
131 if (geom_flags & flag)
132 {
133 if (new_value < -100)
134 new_value = -100;
135 else if (new_value > 200)
136 new_value = 200;
137 if (new_value != align)
138 {
139 align = new_value;
140 return true;
141 }
142 }
143 return false;
144}
145
146static inline int 122static inline int
147make_align_position (int align, int window_size, int image_size) 123make_align_position (int align, int window_size, int image_size)
148{ 124{
149 int diff = window_size - image_size;
150 int smaller = min (image_size, window_size);
151
152 if (align >= 0 && align <= 100) 125 if (align >= 0 && align <= 100)
153 return diff * align / 100; 126 return lerp (0, window_size - image_size, align);
154 else if (align > 100 && align <= 200) 127 else if (align > 100)
155 return (align - 100) * smaller / 100 + window_size - smaller; 128 return lerp (window_size - image_size, window_size, align - 100);
156 else if (align >= -100 && align < 0) 129 else
157 return (align + 100) * smaller / 100 - image_size; 130 return lerp (-image_size, 0, align + 100);
158 return 0;
159} 131}
160 132
161static inline int 133static inline int
162make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size) 134make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)
163{ 135{
… …
169 src_pos = -pos; 141 src_pos = -pos;
170 dst_pos = 0; 142 dst_pos = 0;
171 dst_size += pos; 143 dst_size += pos;
172 } 144 }
173 145
174 if (dst_pos + dst_size > target_size)
175 dst_size = target_size - dst_pos; 146 min_it (dst_size, target_size - dst_pos);
176 return src_pos; 147 return src_pos;
177} 148}
178 149
179bool 150bool
180rxvt_term::bg_set_geometry (const char *geom, bool update) 151rxvt_image::set_geometry (const char *geom, bool update)
181{ 152{
182 bool changed = false; 153 bool changed = false;
183 int geom_flags = 0; 154 int geom_flags = 0;
184 int x = 0, y = 0; 155 int x = h_align;
156 int y = v_align;
185 unsigned int w = 0, h = 0; 157 unsigned int w = h_scale;
186 unsigned long new_flags = bg_flags & ~BG_GEOMETRY_FLAGS; 158 unsigned int h = v_scale;
159 unsigned long new_flags = 0;
187 160
188 if (geom == NULL) 161 if (geom == NULL)
189 return false; 162 return false;
190 163
191 if (geom[0]) 164 if (geom[0])
… …
194 167
195 for (int i = 0; arr[i]; i++) 168 for (int i = 0; arr[i]; i++)
196 { 169 {
197 if (!strcasecmp (arr[i], "style=tiled")) 170 if (!strcasecmp (arr[i], "style=tiled"))
198 { 171 {
199 new_flags = BG_TILE; 172 new_flags = IM_TILE;
200 w = h = noScale; 173 w = h = noScale;
201 x = y = 0; 174 x = y = 0;
202 geom_flags = WidthValue|HeightValue|XValue|YValue; 175 geom_flags = WidthValue|HeightValue|XValue|YValue;
203 } 176 }
204 else if (!strcasecmp (arr[i], "style=aspect-stretched")) 177 else if (!strcasecmp (arr[i], "style=aspect-stretched"))
205 { 178 {
206 new_flags = BG_PROP_SCALE; 179 new_flags = IM_KEEP_ASPECT;
207 w = h = windowScale; 180 w = h = windowScale;
208 x = y = centerAlign; 181 x = y = centerAlign;
209 geom_flags = WidthValue|HeightValue|XValue|YValue; 182 geom_flags = WidthValue|HeightValue|XValue|YValue;
210 } 183 }
211 else if (!strcasecmp (arr[i], "style=stretched")) 184 else if (!strcasecmp (arr[i], "style=stretched"))
… …
221 x = y = centerAlign; 194 x = y = centerAlign;
222 geom_flags = WidthValue|HeightValue|XValue|YValue; 195 geom_flags = WidthValue|HeightValue|XValue|YValue;
223 } 196 }
224 else if (!strcasecmp (arr[i], "style=root-tiled")) 197 else if (!strcasecmp (arr[i], "style=root-tiled"))
225 { 198 {
226 new_flags = BG_TILE|BG_ROOT_ALIGN; 199 new_flags = IM_TILE|IM_ROOT_ALIGN;
227 w = h = noScale; 200 w = h = noScale;
228 geom_flags = WidthValue|HeightValue; 201 geom_flags = WidthValue|HeightValue;
229 } 202 }
230 else if (!strcasecmp (arr[i], "op=tile")) 203 else if (!strcasecmp (arr[i], "op=tile"))
231 new_flags |= BG_TILE; 204 new_flags |= IM_TILE;
232 else if (!strcasecmp (arr[i], "op=pscale")) 205 else if (!strcasecmp (arr[i], "op=keep-aspect"))
233 new_flags |= BG_PROP_SCALE; 206 new_flags |= IM_KEEP_ASPECT;
234 else if (!strcasecmp (arr[i], "op=root")) 207 else if (!strcasecmp (arr[i], "op=root-align"))
235 new_flags |= BG_ROOT_ALIGN; 208 new_flags |= IM_ROOT_ALIGN;
236 209
237 // deprecated 210 // deprecated
238 else if (!strcasecmp (arr[i], "tile")) 211 else if (!strcasecmp (arr[i], "tile"))
239 { 212 {
240 new_flags |= BG_TILE; 213 new_flags |= IM_TILE;
241 w = h = noScale; 214 w = h = noScale;
242 geom_flags |= WidthValue|HeightValue; 215 geom_flags |= WidthValue|HeightValue;
243 } 216 }
244 else if (!strcasecmp (arr[i], "propscale")) 217 else if (!strcasecmp (arr[i], "propscale"))
245 { 218 {
246 new_flags |= BG_PROP_SCALE; 219 new_flags |= IM_KEEP_ASPECT;
220 w = h = windowScale;
221 geom_flags |= WidthValue|HeightValue;
247 } 222 }
248 else if (!strcasecmp (arr[i], "hscale")) 223 else if (!strcasecmp (arr[i], "hscale"))
249 { 224 {
250 new_flags |= BG_TILE; 225 new_flags |= IM_TILE;
251 w = windowScale; 226 w = windowScale;
252 h = noScale; 227 h = noScale;
253 geom_flags |= WidthValue|HeightValue; 228 geom_flags |= WidthValue|HeightValue;
254 } 229 }
255 else if (!strcasecmp (arr[i], "vscale")) 230 else if (!strcasecmp (arr[i], "vscale"))
256 { 231 {
257 new_flags |= BG_TILE; 232 new_flags |= IM_TILE;
258 h = windowScale; 233 h = windowScale;
259 w = noScale; 234 w = noScale;
260 geom_flags |= WidthValue|HeightValue; 235 geom_flags |= WidthValue|HeightValue;
261 } 236 }
262 else if (!strcasecmp (arr[i], "scale")) 237 else if (!strcasecmp (arr[i], "scale"))
… …
270 x = y = centerAlign; 245 x = y = centerAlign;
271 geom_flags |= WidthValue|HeightValue|XValue|YValue; 246 geom_flags |= WidthValue|HeightValue|XValue|YValue;
272 } 247 }
273 else if (!strcasecmp (arr[i], "root")) 248 else if (!strcasecmp (arr[i], "root"))
274 { 249 {
275 new_flags |= BG_TILE|BG_ROOT_ALIGN; 250 new_flags |= IM_TILE|IM_ROOT_ALIGN;
276 w = h = noScale; 251 w = h = noScale;
277 geom_flags |= WidthValue|HeightValue; 252 geom_flags |= WidthValue|HeightValue;
278 } 253 }
279 254
280 else 255 else
281 geom_flags |= XParseGeometry (arr[i], &x, &y, &w, &h); 256 geom_flags |= XParseGeometry (arr[i], &x, &y, &w, &h);
282 } /* done parsing ops */ 257 } /* done parsing ops */
283 258
284 rxvt_free_strsplit (arr); 259 rxvt_free_strsplit (arr);
285 } 260 }
261
262 new_flags |= flags & ~IM_GEOMETRY_FLAGS;
286 263
287 if (!update) 264 if (!update)
288 { 265 {
289 if (!(geom_flags & XValue)) 266 if (!(geom_flags & XValue))
290 x = y = defaultAlign; 267 x = y = defaultAlign;
… …
295 w = h = defaultScale; 272 w = h = defaultScale;
296 else if (!(geom_flags & HeightValue)) 273 else if (!(geom_flags & HeightValue))
297 h = w; 274 h = w;
298 else if (!(geom_flags & WidthValue)) 275 else if (!(geom_flags & WidthValue))
299 w = h; 276 w = h;
300
301 geom_flags |= WidthValue|HeightValue|XValue|YValue;
302 }
303
304 if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)
305 || check_set_scale_value (geom_flags, HeightValue, v_scale, h)
306 || check_set_align_value (geom_flags, XValue, h_align, x)
307 || check_set_align_value (geom_flags, YValue, v_align, y))
308 changed = true;
309
310 if (new_flags != bg_flags)
311 { 277 }
278
279 clamp_it (x, -100, 200);
280 clamp_it (y, -100, 200);
281
282 if (flags != new_flags
283 || h_scale != w
284 || v_scale != h
285 || h_align != x
286 || v_align != y)
287 {
312 bg_flags = new_flags; 288 flags = new_flags;
289 h_scale = w;
290 v_scale = h;
291 h_align = x;
292 v_align = y;
313 changed = true; 293 changed = true;
314 } 294 }
315 295
296 if (!(flags & IM_TILE)
297 || h_scale || v_scale
298 || (!(flags & IM_ROOT_ALIGN) && (h_align || v_align)))
299 flags |= IM_IS_SIZE_SENSITIVE;
300 else
301 flags &= ~IM_IS_SIZE_SENSITIVE;
302
316 return changed; 303 return changed;
317} 304}
318 305
319void 306void
320rxvt_term::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y) 307rxvt_term::get_image_geometry (rxvt_image &image, int &w, int &h, int &x, int &y)
321{ 308{
309 int image_width = image.width ();
310 int image_height = image.height ();
322 int target_width = szHint.width; 311 int target_width = szHint.width;
323 int target_height = szHint.height; 312 int target_height = szHint.height;
313 int h_scale = min (image.h_scale, 32767 * 100 / target_width);
314 int v_scale = min (image.v_scale, 32767 * 100 / target_height);
324 315
325 w = h_scale * target_width / 100; 316 w = h_scale * target_width / 100;
326 h = v_scale * target_height / 100; 317 h = v_scale * target_height / 100;
327 318
328 if (bg_flags & BG_PROP_SCALE) 319 if (image.flags & IM_KEEP_ASPECT)
329 { 320 {
330 float scale = (float)w / image_width; 321 float scale = (float)w / image_width;
331 min_it (scale, (float)h / image_height); 322 min_it (scale, (float)h / image_height);
332 w = image_width * scale + 0.5; 323 w = image_width * scale + 0.5;
333 h = image_height * scale + 0.5; 324 h = image_height * scale + 0.5;
334 } 325 }
335 326
336 if (!w) w = image_width; 327 if (!w) w = image_width;
337 if (!h) h = image_height; 328 if (!h) h = image_height;
338 329
339 if (bg_flags & BG_ROOT_ALIGN) 330 if (image.flags & IM_ROOT_ALIGN)
340 { 331 {
341 x = -target_x; 332 x = -target_x;
342 y = -target_y; 333 y = -target_y;
343 } 334 }
344 else 335 else
345 { 336 {
346 x = make_align_position (h_align, target_width, w); 337 x = make_align_position (image.h_align, target_width, w);
347 y = make_align_position (v_align, target_height, h); 338 y = make_align_position (image.v_align, target_height, h);
348 }
349
350 bg_flags &= ~BG_IS_SIZE_SENSITIVE;
351 if (!(bg_flags & BG_TILE)
352 || h_scale || v_scale
353 || (!(bg_flags & BG_ROOT_ALIGN) && (h_align || v_align))
354 || w > target_width || h > target_height)
355 bg_flags |= BG_IS_SIZE_SENSITIVE;
356}
357
358# ifdef HAVE_AFTERIMAGE
359bool
360rxvt_term::render_image (unsigned long tr_flags)
361{
362 init_asv ();
363
364 ASImage *background = NULL;
365 ARGB32 background_tint = TINT_LEAVE_SAME;
366
367# ifdef ENABLE_TRANSPARENCY
368 if (tr_flags)
369 background = pixmap2ximage (asv, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, 100);
370
371 if (tr_flags & BG_NEEDS_TINT)
372 { 339 }
373 ShadingInfo as_shade; 340}
374 as_shade.shading = shade;
375 341
376 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 342# ifdef HAVE_PIXBUF
377 if (bg_flags & BG_TINT_SET) 343bool
378 tint.get (c); 344rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
379 as_shade.tintColor.red = c.r; 345 int src_x, int src_y, int dst_x, int dst_y,
380 as_shade.tintColor.green = c.g; 346 unsigned int width, unsigned int height, bool argb)
381 as_shade.tintColor.blue = c.b; 347{
348 XImage *ximage;
349 char *line;
350 int width_r, width_g, width_b, width_a;
351 int sh_r, sh_g, sh_b, sh_a;
352 uint32_t red_mask, green_mask, blue_mask, alpha_mask;
353 int rowstride;
354 int channels;
355 unsigned char *row;
382 356
383 background_tint = shading2tint32 (&as_shade); 357 if (visual->c_class != TrueColor)
358 return false;
359
360 if (argb)
384 } 361 {
385 362 red_mask = 0xff << 16;
386 if ((tr_flags & BG_NEEDS_BLUR) && background != NULL) 363 green_mask = 0xff << 8;
364 blue_mask = 0xff;
365 alpha_mask = 0xff << 24;
387 { 366 }
388 ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF, 367 else
389 ASA_XImage, 368 {
390 100, ASIMAGE_QUALITY_DEFAULT); 369 red_mask = visual->red_mask;
370 green_mask = visual->green_mask;
371 blue_mask = visual->blue_mask;
372#if XRENDER
373 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
391 if (tmp) 374 if (format)
375 alpha_mask = (uint32_t)format->direct.alphaMask << format->direct.alpha;
376 else
377#endif
378 alpha_mask = 0;
379 }
380
381 width_r = ecb_popcount32 (red_mask);
382 width_g = ecb_popcount32 (green_mask);
383 width_b = ecb_popcount32 (blue_mask);
384 width_a = ecb_popcount32 (alpha_mask);
385
386 if (width_r > 8 || width_g > 8 || width_b > 8 || width_a > 8)
387 return false;
388
389 sh_r = ecb_ctz32 (red_mask);
390 sh_g = ecb_ctz32 (green_mask);
391 sh_b = ecb_ctz32 (blue_mask);
392 sh_a = ecb_ctz32 (alpha_mask);
393
394 if (width > 32767 || height > 32767)
395 return false;
396
397 ximage = XCreateImage (dpy, visual, argb ? 32 : depth, ZPixmap, 0, 0,
398 width, height, 32, 0);
399 if (!ximage)
400 return false;
401
402 if (height > INT_MAX / ximage->bytes_per_line
403 || !(ximage->data = (char *)malloc (height * ximage->bytes_per_line)))
404 {
405 XDestroyImage (ximage);
406 return false;
407 }
408
409 ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
410
411 rowstride = gdk_pixbuf_get_rowstride (pixbuf);
412 channels = gdk_pixbuf_get_n_channels (pixbuf);
413 row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels;
414 line = ximage->data;
415
416 rgba c (0, 0, 0);
417
418 if (channels == 4 && alpha_mask == 0)
419 {
420 pix_colors[Color_bg].get (c);
421 c.r >>= 8;
422 c.g >>= 8;
423 c.b >>= 8;
424 }
425
426 for (int y = 0; y < height; y++)
427 {
428 for (int x = 0; x < width; x++)
429 {
430 unsigned char *pixel = row + x * channels;
431 uint32_t value;
432 unsigned char r, g, b, a;
433
434 if (channels == 4)
392 { 435 {
393 destroy_asimage (&background); 436 a = pixel[3];
394 background = tmp; 437 r = (pixel[0] * a + c.r * (0xff - a)) / 0xff;
438 g = (pixel[1] * a + c.g * (0xff - a)) / 0xff;
439 b = (pixel[2] * a + c.b * (0xff - a)) / 0xff;
440 }
441 else
442 {
443 a = 0xff;
444 r = pixel[0];
445 g = pixel[1];
446 b = pixel[2];
447 }
448
449 value = ((r >> (8 - width_r)) << sh_r)
450 | ((g >> (8 - width_g)) << sh_g)
451 | ((b >> (8 - width_b)) << sh_b)
452 | ((a >> (8 - width_a)) << sh_a);
453
454 if (ximage->bits_per_pixel == 32)
455 ((uint32_t *)line)[x] = value;
456 else
457 XPutPixel (ximage, x, y, value);
395 } 458 }
396 }
397# endif
398 459
399 ASImage *result = 0; 460 row += rowstride;
461 line += ximage->bytes_per_line;
462 }
463
464 XPutImage (dpy, pixmap, gc, ximage, 0, 0, dst_x, dst_y, width, height);
465 XDestroyImage (ximage);
466 return true;
467}
468
469bool
470rxvt_term::render_image (rxvt_image &image)
471{
472 GdkPixbuf *pixbuf = image.pixbuf;
473 if (!pixbuf)
474 return false;
475
476 bool need_blend = bg_flags & BG_IS_VALID;
477
478 if (need_blend
479 && !(bg_flags & BG_HAS_RENDER))
480 return false;
481
482 GdkPixbuf *result;
483
484 int image_width = gdk_pixbuf_get_width (pixbuf);
485 int image_height = gdk_pixbuf_get_height (pixbuf);
400 486
401 int target_width = szHint.width; 487 int target_width = szHint.width;
402 int target_height = szHint.height; 488 int target_height = szHint.height;
403 int new_pmap_width = target_width; 489 int new_pmap_width = target_width;
404 int new_pmap_height = target_height; 490 int new_pmap_height = target_height;
… …
406 int x = 0; 492 int x = 0;
407 int y = 0; 493 int y = 0;
408 int w = 0; 494 int w = 0;
409 int h = 0; 495 int h = 0;
410 496
411 if (original_asim) 497 get_image_geometry (image, w, h, x, y);
412 get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
413 498
414 if (!original_asim 499 if (!(image.flags & IM_ROOT_ALIGN)
415 || (!(bg_flags & BG_ROOT_ALIGN)
416 && (x >= target_width 500 && (x >= target_width
417 || y >= target_height 501 || y >= target_height
418 || x + w <= 0 502 || x + w <= 0
419 || y + h <= 0))) 503 || y + h <= 0))
504 return false;
505
506 result = pixbuf;
507
508 if (w != image_width
509 || h != image_height)
510 {
511 result = gdk_pixbuf_scale_simple (pixbuf,
512 w, h,
513 GDK_INTERP_BILINEAR);
420 { 514 }
421 if (background)
422 {
423 new_pmap_width = background->width;
424 new_pmap_height = background->height;
425 result = background;
426 515
427 if (background_tint != TINT_LEAVE_SAME) 516 if (!result)
517 return false;
518
519 bool ret = false;
520
521 XGCValues gcv;
522 GC gc;
523 Pixmap tmp_pixmap;
524
525 image_width = gdk_pixbuf_get_width (result);
526 image_height = gdk_pixbuf_get_height (result);
527
528 if (need_blend)
529 tmp_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, 32);
530 else
531 {
532 if (image.flags & IM_TILE)
428 { 533 {
429 ASImage *tmp = tile_asimage (asv, background, 0, 0, 534 new_pmap_width = min (image_width, target_width);
430 target_width, target_height, background_tint, 535 new_pmap_height = min (image_height, target_height);
431 ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
432 if (tmp)
433 result = tmp;
434 }
435 } 536 }
436 else
437 new_pmap_width = new_pmap_height = 0;
438 }
439 else
440 {
441 result = original_asim;
442 537
443 if (w != original_asim->width
444 || h != original_asim->height)
445 {
446 result = scale_asimage (asv, original_asim,
447 w, h,
448 ASA_XImage,
449 100, ASIMAGE_QUALITY_DEFAULT);
450 }
451
452 if (background == NULL)
453 {
454 if (bg_flags & BG_TILE)
455 {
456 /* if tiling - pixmap has to be sized exactly as the image,
457 but there is no need to make it bigger than the window! */
458 new_pmap_width = min (result->width, target_width);
459 new_pmap_height = min (result->height, target_height);
460
461 /* we also need to tile our image in both directions */
462 ASImage *tmp = tile_asimage (asv, result,
463 (int)result->width - x,
464 (int)result->height - y,
465 new_pmap_width,
466 new_pmap_height,
467 TINT_LEAVE_SAME, ASA_XImage,
468 100, ASIMAGE_QUALITY_DEFAULT);
469 if (tmp)
470 {
471 if (result != original_asim)
472 destroy_asimage (&result);
473
474 result = tmp;
475 }
476 }
477 }
478 else
479 {
480 /* if blending background and image - pixmap has to be sized same as target window */
481 ASImageLayer *layers = create_image_layers (2);
482
483 layers[0].im = background;
484 layers[0].clip_width = target_width;
485 layers[0].clip_height = target_height;
486 layers[0].tint = background_tint;
487 layers[1].im = result;
488
489 if (bg_flags & BG_TILE)
490 {
491 /* tile horizontally */
492 while (x > 0) x -= (int)result->width;
493 layers[1].dst_x = x;
494 layers[1].clip_width = result->width+target_width;
495 }
496 else
497 {
498 /* clip horizontally */
499 layers[1].dst_x = x;
500 layers[1].clip_width = result->width;
501 }
502
503 if (bg_flags & BG_TILE)
504 {
505 while (y > 0) y -= (int)result->height;
506 layers[1].dst_y = y;
507 layers[1].clip_height = result->height + target_height;
508 }
509 else
510 {
511 layers[1].dst_y = y;
512 layers[1].clip_height = result->height;
513 }
514
515 if (rs[Rs_blendtype])
516 {
517 layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
518 if (layers[1].merge_scanlines == NULL)
519 layers[1].merge_scanlines = alphablend_scanlines;
520 }
521
522 ASImage *tmp = merge_layers (asv, layers, 2, target_width, target_height,
523 ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
524
525 if (tmp)
526 {
527 if (result != original_asim)
528 destroy_asimage (&result);
529
530 result = tmp;
531 }
532
533 free (layers);
534 }
535 }
536
537 bool ret = false;
538
539 if (result)
540 {
541 XGCValues gcv;
542 GC gc;
543
544 /* create Pixmap */
545 if (bg_pixmap == None 538 if (bg_pixmap == None
546 || bg_pmap_width != new_pmap_width 539 || bg_pmap_width != new_pmap_width
547 || bg_pmap_height != new_pmap_height) 540 || bg_pmap_height != new_pmap_height)
548 { 541 {
549 if (bg_pixmap) 542 if (bg_pixmap)
550 XFreePixmap (dpy, bg_pixmap); 543 XFreePixmap (dpy, bg_pixmap);
551 bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth); 544 bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
552 bg_pmap_width = new_pmap_width; 545 bg_pmap_width = new_pmap_width;
553 bg_pmap_height = new_pmap_height; 546 bg_pmap_height = new_pmap_height;
554 } 547 }
555 /* fill with background color (if result's not completely overlapping it) */
556 gcv.foreground = pix_colors[Color_bg];
557 gc = XCreateGC (dpy, vt, GCForeground, &gcv);
558 548
559 int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
560 int dst_width = result->width, dst_height = result->height;
561 if (background == NULL)
562 {
563 if (!(bg_flags & BG_TILE))
564 {
565 src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );
566 src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
567 }
568
569 if (dst_x > 0 || dst_y > 0
570 || dst_x + dst_width < new_pmap_width
571 || dst_y + dst_height < new_pmap_height)
572 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
573 }
574
575 /* put result on pixmap */
576 if (dst_x < new_pmap_width && dst_y < new_pmap_height)
577 asimage2drawable (asv, bg_pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);
578
579 if (result != background && result != original_asim)
580 destroy_asimage (&result);
581
582 XFreeGC (dpy, gc);
583
584 ret = true;
585 }
586
587 if (background)
588 destroy_asimage (&background);
589
590 return ret;
591}
592# endif /* HAVE_AFTERIMAGE */
593
594# ifdef HAVE_PIXBUF
595bool
596rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
597 int src_x, int src_y, int dst_x, int dst_y,
598 unsigned int width, unsigned int height)
599{
600 XImage *ximage;
601 char *data, *line;
602 int bytes_per_pixel;
603 int width_r, width_g, width_b;
604 int sh_r, sh_g, sh_b;
605 int rowstride;
606 int channels;
607 unsigned char *row;
608
609 if (visual->c_class != TrueColor)
610 return false;
611
612 if (depth == 24 || depth == 32)
613 bytes_per_pixel = 4;
614 else if (depth == 15 || depth == 16)
615 bytes_per_pixel = 2;
616 else
617 return false;
618
619 width_r = ecb_popcount32 (visual->red_mask);
620 width_g = ecb_popcount32 (visual->green_mask);
621 width_b = ecb_popcount32 (visual->blue_mask);
622
623 if (width_r > 8 || width_g > 8 || width_b > 8)
624 return false;
625
626 sh_r = ecb_ctz32 (visual->red_mask);
627 sh_g = ecb_ctz32 (visual->green_mask);
628 sh_b = ecb_ctz32 (visual->blue_mask);
629
630 if (width > INT_MAX / height / bytes_per_pixel)
631 return false;
632
633 data = (char *)malloc (width * height * bytes_per_pixel);
634 if (!data)
635 return false;
636
637 ximage = XCreateImage (dpy, visual, depth, ZPixmap, 0, data,
638 width, height, bytes_per_pixel * 8, 0);
639 if (!ximage)
640 {
641 free (data);
642 return false;
643 }
644
645 ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
646
647 rowstride = gdk_pixbuf_get_rowstride (pixbuf);
648 channels = gdk_pixbuf_get_n_channels (pixbuf);
649 row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels;
650 line = data;
651
652 for (int y = 0; y < height; y++)
653 {
654 for (int x = 0; x < width; x++)
655 {
656 unsigned char *pixel = row + x * channels;
657 uint32_t value;
658
659 value = ((pixel[0] >> (8 - width_r)) << sh_r)
660 | ((pixel[1] >> (8 - width_g)) << sh_g)
661 | ((pixel[2] >> (8 - width_b)) << sh_b);
662
663 if (bytes_per_pixel == 4)
664 ((uint32_t *)line)[x] = value;
665 else
666 ((uint16_t *)line)[x] = value;
667 }
668
669 row += rowstride;
670 line += ximage->bytes_per_line;
671 }
672
673 XPutImage (dpy, pixmap, gc, ximage, 0, 0, dst_x, dst_y, width, height);
674 XDestroyImage (ximage);
675 return true;
676}
677
678bool
679rxvt_term::render_image (unsigned long tr_flags)
680{
681 if (!pixbuf)
682 return false;
683
684 if (tr_flags
685 && !(bg_flags & BG_HAS_RENDER))
686 return false;
687
688 GdkPixbuf *result;
689
690 int image_width = gdk_pixbuf_get_width (pixbuf);
691 int image_height = gdk_pixbuf_get_height (pixbuf);
692
693 int target_width = szHint.width;
694 int target_height = szHint.height;
695 int new_pmap_width = target_width;
696 int new_pmap_height = target_height;
697
698 int x = 0;
699 int y = 0;
700 int w = 0;
701 int h = 0;
702
703 get_image_geometry (image_width, image_height, w, h, x, y);
704
705 if (!(bg_flags & BG_ROOT_ALIGN)
706 && (x >= target_width
707 || y >= target_height
708 || x + w <= 0
709 || y + h <= 0))
710 return false;
711
712 result = pixbuf;
713
714 if (w != image_width
715 || h != image_height)
716 {
717 result = gdk_pixbuf_scale_simple (pixbuf,
718 w, h,
719 GDK_INTERP_BILINEAR);
720 }
721
722 if (!result)
723 return false;
724
725 bool ret = false;
726
727 XGCValues gcv;
728 GC gc;
729 Pixmap root_pmap;
730
731 image_width = gdk_pixbuf_get_width (result);
732 image_height = gdk_pixbuf_get_height (result);
733
734 if (tr_flags)
735 {
736 root_pmap = bg_pixmap; 549 tmp_pixmap = bg_pixmap;
737 bg_pixmap = None;
738 }
739 else
740 {
741 if (bg_flags & BG_TILE)
742 {
743 new_pmap_width = min (image_width, target_width);
744 new_pmap_height = min (image_height, target_height);
745 }
746 }
747
748 if (bg_pixmap == None
749 || bg_pmap_width != new_pmap_width
750 || bg_pmap_height != new_pmap_height)
751 {
752 if (bg_pixmap)
753 XFreePixmap (dpy, bg_pixmap);
754 bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
755 bg_pmap_width = new_pmap_width;
756 bg_pmap_height = new_pmap_height;
757 } 550 }
758 551
759 gcv.foreground = pix_colors[Color_bg]; 552 gcv.foreground = pix_colors[Color_bg];
760 gc = XCreateGC (dpy, vt, GCForeground, &gcv); 553 gc = XCreateGC (dpy, tmp_pixmap, GCForeground, &gcv);
761 554
762 if (gc) 555 if (gc)
763 { 556 {
764 if (bg_flags & BG_TILE) 557 if (image.flags & IM_TILE)
765 { 558 {
766 Pixmap tile = XCreatePixmap (dpy, vt, image_width, image_height, depth); 559 Pixmap tile = XCreatePixmap (dpy, vt, image_width, image_height, need_blend ? 32 : depth);
767 pixbuf_to_pixmap (result, tile, gc, 560 pixbuf_to_pixmap (result, tile, gc,
768 0, 0, 561 0, 0,
769 0, 0, 562 0, 0,
770 image_width, image_height); 563 image_width, image_height, need_blend);
771 564
772 gcv.tile = tile; 565 gcv.tile = tile;
773 gcv.fill_style = FillTiled; 566 gcv.fill_style = FillTiled;
774 gcv.ts_x_origin = x; 567 gcv.ts_x_origin = x;
775 gcv.ts_y_origin = y; 568 gcv.ts_y_origin = y;
776 XChangeGC (dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); 569 XChangeGC (dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
777 570
778 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height); 571 XFillRectangle (dpy, tmp_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
779 XFreePixmap (dpy, tile); 572 XFreePixmap (dpy, tile);
780 } 573 }
781 else 574 else
782 { 575 {
783 int src_x, src_y, dst_x, dst_y; 576 int src_x, src_y, dst_x, dst_y;
… …
787 src_y = make_clip_rectangle (y, image_height, new_pmap_height, dst_y, dst_height); 580 src_y = make_clip_rectangle (y, image_height, new_pmap_height, dst_y, dst_height);
788 581
789 if (dst_x > 0 || dst_y > 0 582 if (dst_x > 0 || dst_y > 0
790 || dst_x + dst_width < new_pmap_width 583 || dst_x + dst_width < new_pmap_width
791 || dst_y + dst_height < new_pmap_height) 584 || dst_y + dst_height < new_pmap_height)
792 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height); 585 XFillRectangle (dpy, tmp_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
793 586
794 if (dst_x < new_pmap_width && dst_y < new_pmap_height) 587 if (dst_x < new_pmap_width && dst_y < new_pmap_height)
795 pixbuf_to_pixmap (result, bg_pixmap, gc, 588 pixbuf_to_pixmap (result, tmp_pixmap, gc,
796 src_x, src_y, 589 src_x, src_y,
797 dst_x, dst_y, 590 dst_x, dst_y,
798 dst_width, dst_height); 591 dst_width, dst_height, need_blend);
799 } 592 }
800 593
801#if XRENDER 594#if XRENDER
802 if (tr_flags) 595 if (need_blend)
803 { 596 {
804 XRenderPictureAttributes pa; 597 XRenderPictFormat *argb_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
805
806 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, visual); 598 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
599
807 Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa); 600 Picture src = XRenderCreatePicture (dpy, tmp_pixmap, argb_format, 0, 0);
808 601
809 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
810 Picture dst = XRenderCreatePicture (dpy, bg_pixmap, dst_format, 0, &pa); 602 Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
811 603
812 pa.repeat = True; 604 Picture mask = create_xrender_mask (dpy, vt, False, False);
813 Pixmap mask_pmap = XCreatePixmap (dpy, vt, 1, 1, 8);
814 XRenderPictFormat *mask_format = XRenderFindStandardFormat (dpy, PictStandardA8);
815 Picture mask = XRenderCreatePicture (dpy, mask_pmap, mask_format, CPRepeat, &pa);
816 XFreePixmap (dpy, mask_pmap);
817 605
818 XRenderColor mask_c; 606 XRenderColor mask_c;
819 607
820 mask_c.alpha = 0x8000; 608 mask_c.alpha = 0x8000;
821 mask_c.red = 0; 609 mask_c.red =
822 mask_c.green = 0; 610 mask_c.green =
823 mask_c.blue = 0; 611 mask_c.blue = 0;
824 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1); 612 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
613
825 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height); 614 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
826 615
827 XRenderFreePicture (dpy, src); 616 XRenderFreePicture (dpy, src);
828 XRenderFreePicture (dpy, dst); 617 XRenderFreePicture (dpy, dst);
829 XRenderFreePicture (dpy, mask); 618 XRenderFreePicture (dpy, mask);
… …
836 } 625 }
837 626
838 if (result != pixbuf) 627 if (result != pixbuf)
839 g_object_unref (result); 628 g_object_unref (result);
840 629
841 if (tr_flags) 630 if (need_blend)
842 XFreePixmap (dpy, root_pmap); 631 XFreePixmap (dpy, tmp_pixmap);
843 632
844 return ret; 633 return ret;
845} 634}
846# endif /* HAVE_PIXBUF */ 635# endif /* HAVE_PIXBUF */
847 636
848bool 637bool
849rxvt_term::bg_set_file (const char *file) 638rxvt_image::set_file (const char *file)
850{ 639{
851 if (!file || !*file) 640 if (!file || !*file)
852 return false; 641 return false;
853 642
854 bool ret = false; 643 bool ret = false;
… …
861 memcpy (f, file, len); 650 memcpy (f, file, len);
862 f[len] = '\0'; 651 f[len] = '\0';
863 file = f; 652 file = f;
864 } 653 }
865 654
866# ifdef HAVE_AFTERIMAGE
867 if (!asimman)
868 asimman = create_generic_imageman (rs[Rs_path]);
869 ASImage *image = get_asimage (asimman, file, 0xFFFFFFFF, 100);
870 if (image)
871 {
872 if (original_asim)
873 safe_asimage_destroy (original_asim);
874 original_asim = image;
875 bg_flags |= BG_IS_FROM_FILE | BG_CLIENT_RENDER;
876 ret = true;
877 }
878# endif
879
880# ifdef HAVE_PIXBUF 655# ifdef HAVE_PIXBUF
881 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL); 656 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
882 if (image) 657 if (image)
883 { 658 {
884 if (pixbuf) 659 if (pixbuf)
885 g_object_unref (pixbuf); 660 g_object_unref (pixbuf);
886 pixbuf = image; 661 pixbuf = image;
887 bg_flags |= BG_IS_FROM_FILE;
888 ret = true; 662 ret = true;
889 } 663 }
890# endif 664# endif
891 665
892 if (ret) 666 if (ret)
893 { 667 {
668 flags = IM_IS_SET | IM_IS_SIZE_SENSITIVE;
669 h_scale = v_scale = defaultScale;
670 h_align = v_align = defaultAlign;
671
894 if (p) 672 if (p)
895 bg_set_geometry (p + 1); 673 set_geometry (p + 1);
896 else
897 bg_set_default_geometry ();
898 } 674 }
899 675
900 return ret; 676 return ret;
901} 677}
902 678
903# endif /* BG_IMAGE_FROM_FILE */ 679# endif /* BG_IMAGE_FROM_FILE */
904 680
905# ifdef ENABLE_TRANSPARENCY 681# ifdef ENABLE_TRANSPARENCY
906bool
907rxvt_term::bg_set_transparent ()
908{
909 if (!(bg_flags & BG_IS_TRANSPARENT))
910 {
911 bg_flags |= BG_IS_TRANSPARENT;
912 return true;
913 }
914
915 return false;
916}
917
918bool 682bool
919rxvt_term::bg_set_blur (const char *geom) 683rxvt_term::bg_set_blur (const char *geom)
920{ 684{
921 bool changed = false; 685 bool changed = false;
922 unsigned int hr, vr; 686 unsigned int hr, vr;
… …
941 { 705 {
942 changed = true; 706 changed = true;
943 v_blurRadius = vr; 707 v_blurRadius = vr;
944 } 708 }
945 709
946 if (v_blurRadius == 0 && h_blurRadius == 0)
947 bg_flags &= ~BG_NEEDS_BLUR;
948 else
949 bg_flags |= BG_NEEDS_BLUR;
950
951 return changed; 710 return changed;
952} 711}
953 712
954void 713bool
955rxvt_term::set_tint_shade_flags () 714rxvt_term::bg_set_tint (rxvt_color &new_tint)
956{ 715{
957 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 716 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
958 bool has_shade = shade != 100; 717 {
959 718 tint = new_tint;
960 bg_flags &= ~BG_TINT_FLAGS; 719 bg_flags |= BG_TINT_SET;
961 720
962 if (bg_flags & BG_TINT_SET) 721 rgba c;
963 {
964 tint.get (c); 722 tint.get (c);
965 if (!has_shade
966 && (c.r <= 0x00ff || c.r >= 0xff00) 723 if ((c.r <= 0x00ff || c.r >= 0xff00)
967 && (c.g <= 0x00ff || c.g >= 0xff00) 724 && (c.g <= 0x00ff || c.g >= 0xff00)
968 && (c.b <= 0x00ff || c.b >= 0xff00)) 725 && (c.b <= 0x00ff || c.b >= 0xff00))
969 bg_flags |= BG_TINT_BITAND; 726 bg_flags |= BG_TINT_BITAND;
970 } 727 else
971
972 if (has_shade || (bg_flags & BG_TINT_SET))
973 bg_flags |= BG_NEEDS_TINT;
974}
975
976bool
977rxvt_term::bg_set_tint (rxvt_color &new_tint)
978{
979 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
980 {
981 tint = new_tint;
982 bg_flags |= BG_TINT_SET; 728 bg_flags &= ~BG_TINT_BITAND;
983 set_tint_shade_flags (); 729
984 return true; 730 return true;
985 } 731 }
986 732
987 return false; 733 return false;
988} 734}
989 735
990bool 736bool
991rxvt_term::bg_set_shade (const char *shade_str) 737rxvt_term::bg_set_shade (const char *shade_str)
992{ 738{
993 int new_shade = (shade_str) ? atoi (shade_str) : 100; 739 int new_shade = atoi (shade_str);
994 740
995 clamp_it (new_shade, -100, 200); 741 clamp_it (new_shade, -100, 200);
996 if (new_shade < 0) 742 if (new_shade < 0)
997 new_shade = 200 - (100 + new_shade); 743 new_shade = 200 - (100 + new_shade);
998 744
999 if (new_shade != shade) 745 if (new_shade != shade)
1000 { 746 {
1001 shade = new_shade; 747 shade = new_shade;
1002 set_tint_shade_flags ();
1003 return true; 748 return true;
1004 } 749 }
1005 750
1006 return false; 751 return false;
1007} 752}
… …
1028 params[i+2] = XDoubleToFixed (kernel[i] / sum); 773 params[i+2] = XDoubleToFixed (kernel[i] / sum);
1029} 774}
1030#endif 775#endif
1031 776
1032bool 777bool
1033rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 778rxvt_term::blur_pixmap (Pixmap pixmap, int width, int height)
1034{ 779{
1035 bool ret = false; 780 bool ret = false;
1036#if XRENDER 781#if XRENDER
782 if (!(bg_flags & BG_HAS_RENDER_CONV))
783 return false;
784
1037 int size = max (h_blurRadius, v_blurRadius) * 2 + 1; 785 int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1038 double *kernel = (double *)malloc (size * sizeof (double)); 786 double *kernel = (double *)malloc (size * sizeof (double));
1039 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 787 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1040 788
1041 XRenderPictureAttributes pa; 789 XRenderPictureAttributes pa;
1042 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 790 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1043 791
792 pa.repeat = RepeatPad;
1044 Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 793 Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
794 Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1045 Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 795 Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
796 XFreePixmap (dpy, tmp);
1046 797
1047 if (kernel && params) 798 if (kernel && params)
1048 { 799 {
1049 if (h_blurRadius)
1050 {
1051 size = h_blurRadius * 2 + 1; 800 size = h_blurRadius * 2 + 1;
1052 get_gaussian_kernel (h_blurRadius, size, kernel, params); 801 get_gaussian_kernel (h_blurRadius, size, kernel, params);
1053 802
1054 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 803 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1055 XRenderComposite (dpy, 804 XRenderComposite (dpy,
1056 PictOpSrc, 805 PictOpSrc,
1057 src, 806 src,
1058 None, 807 None,
1059 dst, 808 dst,
1060 0, 0, 809 0, 0,
1061 0, 0, 810 0, 0,
1062 0, 0, 811 0, 0,
1063 width, height); 812 width, height);
1064 }
1065 813
1066 if (v_blurRadius) 814 ::swap (src, dst);
1067 { 815
1068 size = v_blurRadius * 2 + 1; 816 size = v_blurRadius * 2 + 1;
1069 get_gaussian_kernel (v_blurRadius, size, kernel, params); 817 get_gaussian_kernel (v_blurRadius, size, kernel, params);
1070 ::swap (params[0], params[1]); 818 ::swap (params[0], params[1]);
1071 819
1072 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 820 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1073 XRenderComposite (dpy, 821 XRenderComposite (dpy,
1074 PictOpSrc, 822 PictOpSrc,
1075 src, 823 src,
1076 None, 824 None,
1077 dst, 825 dst,
1078 0, 0, 826 0, 0,
1079 0, 0, 827 0, 0,
1080 0, 0, 828 0, 0,
1081 width, height); 829 width, height);
1082 }
1083 830
1084 ret = true; 831 ret = true;
1085 } 832 }
1086 833
1087 free (kernel); 834 free (kernel);
… …
1091#endif 838#endif
1092 return ret; 839 return ret;
1093} 840}
1094 841
1095bool 842bool
1096rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 843rxvt_term::tint_pixmap (Pixmap pixmap, int width, int height)
1097{ 844{
1098 bool ret = false; 845 bool ret = false;
1099 846
1100 if (bg_flags & BG_TINT_BITAND) 847 if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1101 { 848 {
1102 XGCValues gcv; 849 XGCValues gcv;
1103 GC gc; 850 GC gc;
1104 851
1105 /* In this case we can tint image server-side getting significant 852 /* In this case we can tint image server-side getting significant
… …
1114 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height); 861 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1115 ret = true; 862 ret = true;
1116 XFreeGC (dpy, gc); 863 XFreeGC (dpy, gc);
1117 } 864 }
1118 } 865 }
1119 else
1120 {
1121# if XRENDER 866# if XRENDER
867 else if (bg_flags & BG_HAS_RENDER)
868 {
1122 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC); 869 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1123 870
1124 if (bg_flags & BG_TINT_SET) 871 if (bg_flags & BG_TINT_SET)
1125 tint.get (c); 872 tint.get (c);
1126 873
… …
1135 c.r = c.r * (200 - shade) / 100; 882 c.r = c.r * (200 - shade) / 100;
1136 c.g = c.g * (200 - shade) / 100; 883 c.g = c.g * (200 - shade) / 100;
1137 c.b = c.b * (200 - shade) / 100; 884 c.b = c.b * (200 - shade) / 100;
1138 } 885 }
1139 886
1140 XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1141 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 887 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1142 XRenderPictureAttributes pa;
1143 888
1144 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 889 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1145 890
1146 pa.repeat = True; 891 Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1147 892
1148 Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32); 893 Picture mask_pic = create_xrender_mask (dpy, pixmap, True, True);
1149 Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1150 XFreePixmap (dpy, overlay_pmap);
1151
1152 pa.component_alpha = True;
1153 Pixmap mask_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
1154 Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat | CPComponentAlpha, &pa);
1155 XFreePixmap (dpy, mask_pmap);
1156 894
1157 XRenderColor mask_c; 895 XRenderColor mask_c;
1158 896
1159 mask_c.alpha = 0xffff; 897 mask_c.alpha = 0xffff;
1160 mask_c.red = 898 mask_c.red =
… …
1165 mask_c.alpha = 0; 903 mask_c.alpha = 0;
1166 mask_c.red = 0xffff - c.r; 904 mask_c.red = 0xffff - c.r;
1167 mask_c.green = 0xffff - c.g; 905 mask_c.green = 0xffff - c.g;
1168 mask_c.blue = 0xffff - c.b; 906 mask_c.blue = 0xffff - c.b;
1169 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1); 907 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
908
1170 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height); 909 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1171 910
1172 if (shade > 100) 911 if (shade > 100)
1173 { 912 {
1174 mask_c.red = mask_c.green = mask_c.blue = 0xffff * (shade - 100) / 100;
1175 mask_c.alpha = 0; 913 mask_c.alpha = 0;
914 mask_c.red =
915 mask_c.green =
916 mask_c.blue = 0xffff * (shade - 100) / 100;
1176 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1); 917 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1177 918
1178 XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height); 919 XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1179 } 920 }
1180 921
1181 ret = true; 922 ret = true;
1182 923
1183 XRenderFreePicture (dpy, mask_pic); 924 XRenderFreePicture (dpy, mask_pic);
1184 XRenderFreePicture (dpy, overlay_pic); 925 XRenderFreePicture (dpy, overlay_pic);
1185 XRenderFreePicture (dpy, back_pic); 926 XRenderFreePicture (dpy, back_pic);
927 }
1186# endif 928# endif
1187 }
1188 929
1189 return ret; 930 return ret;
1190} 931}
1191 932
1192/* 933/*
1193 * Builds a pixmap of the same size as the terminal window that contains 934 * Builds a pixmap of the same size as the terminal window that contains
1194 * the tiled portion of the root pixmap that is supposed to be covered by 935 * the tiled portion of the root pixmap that is supposed to be covered by
1195 * our window. 936 * our window.
1196 */ 937 */
1197unsigned long 938bool
1198rxvt_term::make_transparency_pixmap () 939rxvt_term::make_transparency_pixmap ()
1199{ 940{
1200 unsigned long result = 0; 941 bool ret = false;
1201 942
1202 /* root dimensions may change from call to call - but Display structure should 943 /* root dimensions may change from call to call - but Display structure should
1203 * be always up-to-date, so let's use it : 944 * be always up-to-date, so let's use it :
1204 */ 945 */
1205 int screen = display->screen; 946 int screen = display->screen;
… …
1243#if XRENDER 984#if XRENDER
1244 if (bg_flags & BG_HAS_RENDER) 985 if (bg_flags & BG_HAS_RENDER)
1245 { 986 {
1246 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth); 987 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1247 988
1248 XRenderPictureAttributes pa;
1249
1250 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen)); 989 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1251 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa); 990 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1252 991
1253 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual); 992 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1254 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa); 993 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1255 994
1256 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height); 995 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
1257 996
1258 XRenderFreePicture (dpy, src); 997 XRenderFreePicture (dpy, src);
1259 XRenderFreePicture (dpy, dst); 998 XRenderFreePicture (dpy, dst);
… …
1276 bg_pmap_width = window_width; 1015 bg_pmap_width = window_width;
1277 bg_pmap_height = window_height; 1016 bg_pmap_height = window_height;
1278 } 1017 }
1279 1018
1280 /* straightforward pixmap copy */ 1019 /* straightforward pixmap copy */
1281 while (sx < 0) sx += root_width; 1020 while (sx < 0) sx += root_pmap_width;
1282 while (sy < 0) sy += root_height; 1021 while (sy < 0) sy += root_pmap_height;
1283 1022
1284 gcv.tile = recoded_root_pmap; 1023 gcv.tile = recoded_root_pmap;
1285 gcv.fill_style = FillTiled; 1024 gcv.fill_style = FillTiled;
1286 gcv.ts_x_origin = -sx; 1025 gcv.ts_x_origin = -sx;
1287 gcv.ts_y_origin = -sy; 1026 gcv.ts_y_origin = -sy;
1288 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); 1027 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1289 1028
1290 if (gc) 1029 if (gc)
1291 { 1030 {
1292 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height); 1031 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1293 result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS); 1032 ret = true;
1033 bool need_blur = h_blurRadius && v_blurRadius;
1034 bool need_tint = shade != 100 || (bg_flags & BG_TINT_SET);
1035
1036 if (!(bg_flags & BG_CLIENT_RENDER))
1037 {
1038 if (need_blur)
1039 {
1040 if (blur_pixmap (bg_pixmap, window_width, window_height))
1041 need_blur = false;
1042 }
1043 if (need_tint)
1044 {
1045 if (tint_pixmap (bg_pixmap, window_width, window_height))
1046 need_tint = false;
1047 }
1048 if (need_tint)
1049 {
1050 XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1051 if (ximage)
1052 {
1053 /* our own client-side tinting */
1054 tint_ximage (ximage);
1055
1056 XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
1057 XDestroyImage (ximage);
1058 }
1059 }
1060 } /* server side rendering completed */
1061
1294 XFreeGC (dpy, gc); 1062 XFreeGC (dpy, gc);
1295
1296 if (!(bg_flags & BG_CLIENT_RENDER))
1297 {
1298 if ((bg_flags & BG_NEEDS_BLUR)
1299 && (bg_flags & BG_HAS_RENDER_CONV))
1300 {
1301 if (blur_pixmap (bg_pixmap, visual, window_width, window_height))
1302 result &= ~BG_NEEDS_BLUR;
1303 }
1304 if ((bg_flags & BG_NEEDS_TINT)
1305 && (bg_flags & (BG_TINT_BITAND | BG_HAS_RENDER)))
1306 {
1307 if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1308 result &= ~BG_NEEDS_TINT;
1309 }
1310 } /* server side rendering completed */
1311 } 1063 }
1312 1064
1313 if (recoded_root_pmap != root_pixmap) 1065 if (recoded_root_pmap != root_pixmap)
1314 XFreePixmap (dpy, recoded_root_pmap); 1066 XFreePixmap (dpy, recoded_root_pmap);
1315 1067
1316 return result; 1068 return ret;
1317} 1069}
1318 1070
1319void 1071void
1320rxvt_term::bg_set_root_pixmap () 1072rxvt_term::bg_set_root_pixmap ()
1321{ 1073{
… …
1325 1077
1326 root_pixmap = new_root_pixmap; 1078 root_pixmap = new_root_pixmap;
1327} 1079}
1328# endif /* ENABLE_TRANSPARENCY */ 1080# endif /* ENABLE_TRANSPARENCY */
1329 1081
1330#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1331static void shade_ximage (Visual *visual, XImage *ximage, int shade, const rgba &c);
1332# endif
1333
1334bool 1082bool
1335rxvt_term::bg_render () 1083rxvt_term::bg_render ()
1336{ 1084{
1337 unsigned long tr_flags = 0;
1338
1339 bg_invalidate (); 1085 bg_invalidate ();
1340# ifdef ENABLE_TRANSPARENCY 1086# ifdef ENABLE_TRANSPARENCY
1341 if (bg_flags & BG_IS_TRANSPARENT) 1087 if (bg_flags & BG_IS_TRANSPARENT)
1342 { 1088 {
1343 /* we need to re-generate transparency pixmap in that case ! */ 1089 /* we need to re-generate transparency pixmap in that case ! */
1344 tr_flags = make_transparency_pixmap (); 1090 if (make_transparency_pixmap ())
1345 if (tr_flags == 0)
1346 return false;
1347 bg_flags |= BG_IS_VALID; 1091 bg_flags |= BG_IS_VALID;
1348 } 1092 }
1349# endif 1093# endif
1350 1094
1351# ifdef BG_IMAGE_FROM_FILE 1095# ifdef BG_IMAGE_FROM_FILE
1352 if ((bg_flags & BG_IS_FROM_FILE) 1096 if (bg_image.flags & IM_IS_SET)
1353 || (tr_flags & BG_EFFECTS_FLAGS))
1354 { 1097 {
1355 if (render_image (tr_flags)) 1098 if (render_image (bg_image))
1356 bg_flags |= BG_IS_VALID; 1099 bg_flags |= BG_IS_VALID;
1357 }
1358# endif
1359
1360# if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1361 XImage *result = NULL;
1362
1363 if (tr_flags & BG_NEEDS_TINT)
1364 {
1365 result = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1366 }
1367
1368 if (result)
1369 {
1370 /* our own client-side tinting */
1371 //if (tr_flags & BG_NEEDS_TINT)
1372 if (1)
1373 {
1374 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1375 if (bg_flags & BG_TINT_SET)
1376 tint.get (c);
1377 shade_ximage (DefaultVisual (dpy, display->screen), result, shade, c);
1378 }
1379
1380 GC gc = XCreateGC (dpy, vt, 0UL, NULL);
1381
1382 if (gc)
1383 {
1384 XPutImage (dpy, bg_pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1385
1386 XFreeGC (dpy, gc);
1387 }
1388
1389 XDestroyImage (result);
1390 } 1100 }
1391# endif 1101# endif
1392 1102
1393 if (!(bg_flags & BG_IS_VALID)) 1103 if (!(bg_flags & BG_IS_VALID))
1394 { 1104 {
… …
1431#endif 1141#endif
1432} 1142}
1433 1143
1434#endif /* HAVE_BG_PIXMAP */ 1144#endif /* HAVE_BG_PIXMAP */
1435 1145
1436#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) 1146#ifdef ENABLE_TRANSPARENCY
1437/* based on code from aterm-0.4.2 */ 1147/* based on code from aterm-0.4.2 */
1438 1148
1439static void 1149static inline void
1440shade_ximage (Visual *visual, XImage *ximage, int shade, const rgba &c) 1150fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
1441{ 1151{
1152 for (int i = 0; i <= mask >> sh; i++)
1153 {
1154 uint32_t tmp;
1155 tmp = i * high;
1156 tmp += (mask >> sh) * low;
1157 lookup[i] = (tmp / 0xffff) << sh;
1158 }
1159}
1160
1161void
1162rxvt_term::tint_ximage (XImage *ximage)
1163{
1164 unsigned int size_r, size_g, size_b;
1442 int sh_r, sh_g, sh_b; 1165 int sh_r, sh_g, sh_b;
1443 uint32_t mask_r, mask_g, mask_b; 1166 uint32_t mask_r, mask_g, mask_b;
1444 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b; 1167 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1445 rgba low; 1168 unsigned short low;
1446 rgba high;
1447 int i;
1448 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst; 1169 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1449 1170
1450 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return; 1171 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;
1451 1172
1452 /* for convenience */ 1173 /* for convenience */
1453 mask_r = visual->red_mask; 1174 mask_r = visual->red_mask;
1454 mask_g = visual->green_mask; 1175 mask_g = visual->green_mask;
1455 mask_b = visual->blue_mask; 1176 mask_b = visual->blue_mask;
1456 1177
1457 /* boring lookup table pre-initialization */ 1178 /* boring lookup table pre-initialization */
1458 switch (ximage->depth) 1179 sh_r = ecb_ctz32 (mask_r);
1459 { 1180 sh_g = ecb_ctz32 (mask_g);
1460 case 15: 1181 sh_b = ecb_ctz32 (mask_b);
1461 if ((mask_r != 0x7c00) || 1182
1462 (mask_g != 0x03e0) || 1183 size_r = mask_r >> sh_r;
1463 (mask_b != 0x001f)) 1184 size_g = mask_g >> sh_g;
1185 size_b = mask_b >> sh_b;
1186
1187 if (size_r++ > 255 || size_g++ > 255 || size_b++ > 255)
1464 return; 1188 return;
1465 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+32+32)); 1189
1190 lookup = (uint32_t *)malloc (sizeof (uint32_t) * (size_r + size_g + size_b));
1466 lookup_r = lookup; 1191 lookup_r = lookup;
1467 lookup_g = lookup+32; 1192 lookup_g = lookup + size_r;
1468 lookup_b = lookup+32+32; 1193 lookup_b = lookup + size_r + size_g;
1469 sh_r = 10; 1194
1470 sh_g = 5; 1195 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1471 sh_b = 0; 1196
1472 break; 1197 if (bg_flags & BG_TINT_SET)
1473 case 16: 1198 tint.get (c);
1474 if ((mask_r != 0xf800) ||
1475 (mask_g != 0x07e0) ||
1476 (mask_b != 0x001f))
1477 return;
1478 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+64+32));
1479 lookup_r = lookup;
1480 lookup_g = lookup+32;
1481 lookup_b = lookup+32+64;
1482 sh_r = 11;
1483 sh_g = 5;
1484 sh_b = 0;
1485 break;
1486 case 24:
1487 if ((mask_r != 0xff0000) ||
1488 (mask_g != 0x00ff00) ||
1489 (mask_b != 0x0000ff))
1490 return;
1491 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(256+256+256));
1492 lookup_r = lookup;
1493 lookup_g = lookup+256;
1494 lookup_b = lookup+256+256;
1495 sh_r = 16;
1496 sh_g = 8;
1497 sh_b = 0;
1498 break;
1499 case 32:
1500 if ((mask_r != 0xff0000) ||
1501 (mask_g != 0x00ff00) ||
1502 (mask_b != 0x0000ff))
1503 return;
1504 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(256+256+256));
1505 lookup_r = lookup;
1506 lookup_g = lookup+256;
1507 lookup_b = lookup+256+256;
1508 sh_r = 16;
1509 sh_g = 8;
1510 sh_b = 0;
1511 break;
1512 default:
1513 return; /* we do not support this color depth */
1514 }
1515 1199
1516 /* prepare limits for color transformation (each channel is handled separately) */ 1200 /* prepare limits for color transformation (each channel is handled separately) */
1517 if (shade > 100) 1201 if (shade > 100)
1518 { 1202 {
1519 shade = 200 - shade;
1520
1521 high.r = c.r * shade / 100;
1522 high.g = c.g * shade / 100;
1523 high.b = c.b * shade / 100;
1524
1525 low.r = 65535 * (100 - shade) / 100; 1203 c.r = c.r * (200 - shade) / 100;
1526 low.g = 65535 * (100 - shade) / 100; 1204 c.g = c.g * (200 - shade) / 100;
1527 low.b = 65535 * (100 - shade) / 100; 1205 c.b = c.b * (200 - shade) / 100;
1206
1207 low = 0xffff * (shade - 100) / 100;
1528 } 1208 }
1529 else 1209 else
1530 { 1210 {
1531 high.r = c.r * shade / 100; 1211 c.r = c.r * shade / 100;
1532 high.g = c.g * shade / 100; 1212 c.g = c.g * shade / 100;
1533 high.b = c.b * shade / 100; 1213 c.b = c.b * shade / 100;
1534 1214
1535 low.r = low.g = low.b = 0; 1215 low = 0;
1536 } 1216 }
1537 1217
1538 /* fill our lookup tables */ 1218 /* fill our lookup tables */
1539 for (i = 0; i <= mask_r>>sh_r; i++) 1219 fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1540 { 1220 fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1541 uint32_t tmp; 1221 fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1542 tmp = i * high.r;
1543 tmp += (mask_r>>sh_r) * low.r;
1544 lookup_r[i] = (tmp/65535)<<sh_r;
1545 }
1546 for (i = 0; i <= mask_g>>sh_g; i++)
1547 {
1548 uint32_t tmp;
1549 tmp = i * high.g;
1550 tmp += (mask_g>>sh_g) * low.g;
1551 lookup_g[i] = (tmp/65535)<<sh_g;
1552 }
1553 for (i = 0; i <= mask_b>>sh_b; i++)
1554 {
1555 uint32_t tmp;
1556 tmp = i * high.b;
1557 tmp += (mask_b>>sh_b) * low.b;
1558 lookup_b[i] = (tmp/65535)<<sh_b;
1559 }
1560 1222
1561 /* apply table to input image (replacing colors by newly calculated ones) */ 1223 /* apply table to input image (replacing colors by newly calculated ones) */
1562 if (ximage->bits_per_pixel == 32 1224 if (ximage->bits_per_pixel == 32
1563 && (ximage->depth == 24 || ximage->depth == 32)
1564 && ximage->byte_order == host_byte_order) 1225 && ximage->byte_order == host_byte_order)
1565 { 1226 {
1566 uint32_t *p1, *pf, *p, *pl; 1227 char *line = ximage->data;
1567 p1 = (uint32_t *) ximage->data;
1568 pf = (uint32_t *) (ximage->data + ximage->height * ximage->bytes_per_line);
1569 1228
1570 while (p1 < pf) 1229 for (int y = 0; y < ximage->height; y++)
1571 {
1572 p = p1;
1573 pl = p1 + ximage->width;
1574 for (; p < pl; p++)
1575 { 1230 {
1576 *p = lookup_r[(*p & 0xff0000) >> 16] | 1231 uint32_t *p = (uint32_t *)line;
1577 lookup_g[(*p & 0x00ff00) >> 8] | 1232 for (int x = 0; x < ximage->width; x++)
1578 lookup_b[(*p & 0x0000ff)] |
1579 (*p & 0xff000000);
1580 } 1233 {
1581 p1 = (uint32_t *) ((char *) p1 + ximage->bytes_per_line); 1234 *p = lookup_r[(*p & mask_r) >> sh_r] |
1235 lookup_g[(*p & mask_g) >> sh_g] |
1236 lookup_b[(*p & mask_b) >> sh_b];
1237 p++;
1238 }
1239 line += ximage->bytes_per_line;
1582 } 1240 }
1583 } 1241 }
1584 else 1242 else
1585 { 1243 {
1586 for (int y = 0; y < ximage->height; y++) 1244 for (int y = 0; y < ximage->height; y++)
… …
1594 } 1252 }
1595 } 1253 }
1596 1254
1597 free (lookup); 1255 free (lookup);
1598} 1256}
1599#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */ 1257#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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