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.145 by sf-exg, Fri Jan 28 00:21:10 2011 UTC vs.
Revision 1.214 by sf-exg, Thu May 17 10:18:32 2012 UTC

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

Diff Legend

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