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.161 by sf-exg, Thu Aug 11 08:39:10 2011 UTC vs.
Revision 1.204 by sf-exg, Tue Apr 10 15:19:22 2012 UTC

… …
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 */
52 40
53#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
54void 60void
55rxvt_term::bg_destroy () 61rxvt_term::bg_destroy ()
56{ 62{
57#ifdef HAVE_AFTERIMAGE
58 if (original_asim)
59 safe_asimage_destroy (original_asim);
60 if (asv)
61 destroy_asvisual (asv, 0);
62 if (asimman)
63 destroy_image_manager (asimman, 0);
64#endif
65
66#ifdef HAVE_PIXBUF 63#ifdef HAVE_PIXBUF
67 if (pixbuf) 64 if (pixbuf)
68 g_object_unref (pixbuf); 65 g_object_unref (pixbuf);
69#endif 66#endif
70 67
… …
123 120
124 return false; 121 return false;
125} 122}
126 123
127# ifdef BG_IMAGE_FROM_FILE 124# ifdef BG_IMAGE_FROM_FILE
128static inline bool
129check_set_scale_value (int geom_flags, int flag, unsigned int &scale, unsigned int new_value)
130{
131 if (geom_flags & flag)
132 {
133 if (new_value > 1000)
134 new_value = 1000;
135 if (new_value != scale)
136 {
137 scale = new_value;
138 return true;
139 }
140 }
141 return false;
142}
143
144static inline bool
145check_set_align_value (int geom_flags, int flag, int &align, int new_value)
146{
147 if (geom_flags & flag)
148 {
149 if (new_value < -100)
150 new_value = -100;
151 else if (new_value > 200)
152 new_value = 200;
153 if (new_value != align)
154 {
155 align = new_value;
156 return true;
157 }
158 }
159 return false;
160}
161
162static inline int 125static inline int
163make_align_position (int align, int window_size, int image_size) 126make_align_position (int align, int window_size, int image_size)
164{ 127{
165 int diff = window_size - image_size; 128 int diff = window_size - image_size;
166 int smaller = min (image_size, window_size); 129 int smaller = min (image_size, window_size);
167 130
168 if (align >= 0 && align <= 100) 131 if (align >= 0 && align <= 100)
169 return diff * align / 100; 132 return diff * align / 100;
170 else if (align > 100 && align <= 200) 133 else if (align > 100 && align <= 200)
171 return ((align - 100) * smaller / 100) + window_size - smaller; 134 return (align - 100) * smaller / 100 + window_size - smaller;
172 else if (align >= -100 && align < 0) 135 else if (align >= -100 && align < 0)
173 return ((align + 100) * smaller / 100) - image_size; 136 return (align + 100) * smaller / 100 - image_size;
174 return 0; 137 return 0;
175} 138}
176 139
177static inline int 140static inline int
178make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size) 141make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)
… …
185 src_pos = -pos; 148 src_pos = -pos;
186 dst_pos = 0; 149 dst_pos = 0;
187 dst_size += pos; 150 dst_size += pos;
188 } 151 }
189 152
190 if (dst_pos + dst_size > target_size)
191 dst_size = target_size - dst_pos; 153 min_it (dst_size, target_size - dst_pos);
192 return src_pos; 154 return src_pos;
193} 155}
194 156
195bool 157bool
196rxvt_term::bg_set_geometry (const char *geom, bool update) 158rxvt_term::bg_set_geometry (const char *geom, bool update)
197{ 159{
198 bool changed = false; 160 bool changed = false;
199 int geom_flags = 0; 161 int geom_flags = 0;
200 int x = 0, y = 0; 162 int x = h_align;
163 int y = v_align;
201 unsigned int w = 0, h = 0; 164 unsigned int w = h_scale;
202 unsigned int n; 165 unsigned int h = v_scale;
203 unsigned long new_flags = (bg_flags & (~BG_GEOMETRY_FLAGS)); 166 unsigned long new_flags = 0;
204 const char *ops;
205 167
206 if (geom == NULL) 168 if (geom == NULL)
207 return false; 169 return false;
208 170
209 char str[256]; 171 if (geom[0])
210
211 ops = strchr (geom, ':');
212 if (ops == NULL)
213 n = strlen (geom);
214 else
215 n = ops - geom;
216
217 if (n >= sizeof (str))
218 return false;
219
220 memcpy (str, geom, n);
221 str[n] = '\0';
222 rxvt_strtrim (str);
223
224 if (str[0])
225 { 172 {
226 /* we have geometry string - let's handle it prior to applying ops */ 173 char **arr = rxvt_strsplit (':', geom);
174
175 for (int i = 0; arr[i]; i++)
176 {
177 if (!strcasecmp (arr[i], "style=tiled"))
178 {
179 new_flags = BG_TILE;
180 w = h = noScale;
181 x = y = 0;
182 geom_flags = WidthValue|HeightValue|XValue|YValue;
183 }
184 else if (!strcasecmp (arr[i], "style=aspect-stretched"))
185 {
186 new_flags = BG_KEEP_ASPECT;
187 w = h = windowScale;
188 x = y = centerAlign;
189 geom_flags = WidthValue|HeightValue|XValue|YValue;
190 }
191 else if (!strcasecmp (arr[i], "style=stretched"))
192 {
193 new_flags = 0;
194 w = h = windowScale;
195 geom_flags = WidthValue|HeightValue;
196 }
197 else if (!strcasecmp (arr[i], "style=centered"))
198 {
199 new_flags = 0;
200 w = h = noScale;
201 x = y = centerAlign;
202 geom_flags = WidthValue|HeightValue|XValue|YValue;
203 }
204 else if (!strcasecmp (arr[i], "style=root-tiled"))
205 {
206 new_flags = BG_TILE|BG_ROOT_ALIGN;
207 w = h = noScale;
208 geom_flags = WidthValue|HeightValue;
209 }
210 else if (!strcasecmp (arr[i], "op=tile"))
211 new_flags |= BG_TILE;
212 else if (!strcasecmp (arr[i], "op=keep-aspect"))
213 new_flags |= BG_KEEP_ASPECT;
214 else if (!strcasecmp (arr[i], "op=root-align"))
215 new_flags |= BG_ROOT_ALIGN;
216
217 // deprecated
218 else if (!strcasecmp (arr[i], "tile"))
219 {
220 new_flags |= BG_TILE;
221 w = h = noScale;
222 geom_flags |= WidthValue|HeightValue;
223 }
224 else if (!strcasecmp (arr[i], "propscale"))
225 {
226 new_flags |= BG_KEEP_ASPECT;
227 w = h = windowScale;
228 geom_flags |= WidthValue|HeightValue;
229 }
230 else if (!strcasecmp (arr[i], "hscale"))
231 {
232 new_flags |= BG_TILE;
233 w = windowScale;
234 h = noScale;
235 geom_flags |= WidthValue|HeightValue;
236 }
237 else if (!strcasecmp (arr[i], "vscale"))
238 {
239 new_flags |= BG_TILE;
240 h = windowScale;
241 w = noScale;
242 geom_flags |= WidthValue|HeightValue;
243 }
244 else if (!strcasecmp (arr[i], "scale"))
245 {
246 w = h = windowScale;
247 geom_flags |= WidthValue|HeightValue;
248 }
249 else if (!strcasecmp (arr[i], "auto"))
250 {
251 w = h = windowScale;
252 x = y = centerAlign;
253 geom_flags |= WidthValue|HeightValue|XValue|YValue;
254 }
255 else if (!strcasecmp (arr[i], "root"))
256 {
257 new_flags |= BG_TILE|BG_ROOT_ALIGN;
258 w = h = noScale;
259 geom_flags |= WidthValue|HeightValue;
260 }
261
262 else
227 geom_flags = XParseGeometry (str, &x, &y, &w, &h); 263 geom_flags |= XParseGeometry (arr[i], &x, &y, &w, &h);
228 } /* done parsing geometry string */ 264 } /* done parsing ops */
265
266 rxvt_free_strsplit (arr);
267 }
268
269 new_flags |= bg_flags & ~BG_GEOMETRY_FLAGS;
229 270
230 if (!update) 271 if (!update)
231 { 272 {
232 if (!(geom_flags & XValue)) 273 if (!(geom_flags & XValue))
233 x = y = defaultAlign; 274 x = y = defaultAlign;
… …
238 w = h = defaultScale; 279 w = h = defaultScale;
239 else if (!(geom_flags & HeightValue)) 280 else if (!(geom_flags & HeightValue))
240 h = w; 281 h = w;
241 else if (!(geom_flags & WidthValue)) 282 else if (!(geom_flags & WidthValue))
242 w = h; 283 w = h;
243
244 geom_flags |= WidthValue|HeightValue|XValue|YValue;
245 }
246
247 if (ops)
248 { 284 }
249 char **arr = rxvt_strsplit (':', ops + 1);
250 285
251 for (int i = 0; arr[i]; i++) 286 min_it (w, 1000);
252 { 287 min_it (h, 1000);
253 if (!strcasecmp (arr[i], "style=tiled")) 288 clamp_it (x, -100, 200);
254 { 289 clamp_it (y, -100, 200);
255 new_flags = BG_TILE;
256 w = h = noScale;
257 x = y = 0;
258 geom_flags = WidthValue|HeightValue|XValue|YValue;
259 }
260 else if (!strcasecmp (arr[i], "style=aspect-stretched"))
261 {
262 new_flags = BG_PROP_SCALE;
263 x = y = centerAlign;
264 geom_flags = XValue|YValue;
265 }
266 else if (!strcasecmp (arr[i], "style=stretched"))
267 {
268 new_flags = 0;
269 w = h = windowScale;
270 geom_flags = WidthValue|HeightValue;
271 }
272 else if (!strcasecmp (arr[i], "style=centered"))
273 {
274 new_flags = 0;
275 w = h = noScale;
276 x = y = centerAlign;
277 geom_flags = WidthValue|HeightValue|XValue|YValue;
278 }
279 else if (!strcasecmp (arr[i], "style=root-tiled"))
280 {
281 new_flags = BG_TILE|BG_ROOT_ALIGN;
282 w = h = noScale;
283 geom_flags = WidthValue|HeightValue;
284 }
285 else if (!strcasecmp (arr[i], "op=tile"))
286 new_flags |= BG_TILE;
287 else if (!strcasecmp (arr[i], "op=pscale"))
288 new_flags |= BG_PROP_SCALE;
289 else if (!strcasecmp (arr[i], "op=root"))
290 new_flags |= BG_ROOT_ALIGN;
291 290
292 // deprecated 291 if (bg_flags != new_flags
293 else if (!strcasecmp (arr[i], "tile")) 292 || h_scale != w
294 { 293 || v_scale != h
295 new_flags |= BG_TILE; 294 || h_align != x
296 w = h = noScale; 295 || v_align != y)
297 geom_flags |= WidthValue|HeightValue;
298 }
299 else if (!strcasecmp (arr[i], "propscale"))
300 {
301 new_flags |= BG_PROP_SCALE;
302 }
303 else if (!strcasecmp (arr[i], "hscale"))
304 {
305 w = windowScale;
306 h = noScale;
307 geom_flags |= WidthValue|HeightValue;
308 }
309 else if (!strcasecmp (arr[i], "vscale"))
310 {
311 h = windowScale;
312 w = noScale;
313 geom_flags |= WidthValue|HeightValue;
314 }
315 else if (!strcasecmp (arr[i], "scale"))
316 {
317 w = h = windowScale;
318 geom_flags |= WidthValue|HeightValue;
319 }
320 else if (!strcasecmp (arr[i], "auto"))
321 {
322 w = h = windowScale;
323 x = y = centerAlign;
324 geom_flags |= WidthValue|HeightValue|XValue|YValue;
325 }
326 else if (!strcasecmp (arr[i], "root"))
327 {
328 new_flags |= BG_TILE|BG_ROOT_ALIGN;
329 w = h = noScale;
330 geom_flags |= WidthValue|HeightValue;
331 }
332 } /* done parsing ops */
333
334 rxvt_free_strsplit (arr);
335 }
336
337 if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true;
338 if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true;
339 if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true;
340 if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true;
341
342 if (new_flags != bg_flags)
343 { 296 {
344 bg_flags = new_flags; 297 bg_flags = new_flags;
298 h_scale = w;
299 v_scale = h;
300 h_align = x;
301 v_align = y;
345 changed = true; 302 changed = true;
346 } 303 }
347 304
348 return changed; 305 return changed;
349} 306}
… …
352rxvt_term::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y) 309rxvt_term::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y)
353{ 310{
354 int target_width = szHint.width; 311 int target_width = szHint.width;
355 int target_height = szHint.height; 312 int target_height = szHint.height;
356 313
314 w = h_scale * target_width / 100;
315 h = v_scale * target_height / 100;
316
357 if (bg_flags & BG_PROP_SCALE) 317 if (bg_flags & BG_KEEP_ASPECT)
358 { 318 {
359 float scale = (float)target_width / image_width; 319 float scale = (float)w / image_width;
360 min_it (scale, (float)target_height / image_height); 320 min_it (scale, (float)h / image_height);
361 w = image_width * scale + 0.5; 321 w = image_width * scale + 0.5;
362 h = image_height * scale + 0.5; 322 h = image_height * scale + 0.5;
363 } 323 }
364 else
365 {
366 w = h_scale * target_width / 100;
367 h = v_scale * target_height / 100;
368 }
369 324
370 if (!w) w = image_width; 325 if (!w) w = image_width;
371 if (!h) h = image_height; 326 if (!h) h = image_height;
372 327
373 if (bg_flags & BG_ROOT_ALIGN) 328 if (bg_flags & BG_ROOT_ALIGN)
… …
379 { 334 {
380 x = make_align_position (h_align, target_width, w); 335 x = make_align_position (h_align, target_width, w);
381 y = make_align_position (v_align, target_height, h); 336 y = make_align_position (v_align, target_height, h);
382 } 337 }
383 338
384 bg_flags &= ~BG_IS_SIZE_SENSITIVE;
385 if (!(bg_flags & BG_TILE) 339 if (!(bg_flags & BG_TILE)
386 || (bg_flags & BG_PROP_SCALE) || h_scale || v_scale 340 || h_scale || v_scale
387 || (!(bg_flags & BG_ROOT_ALIGN) && (h_align || v_align)) 341 || (!(bg_flags & BG_ROOT_ALIGN) && (h_align || v_align))
388 || w > target_width || h > target_height) 342 || image_width > target_width || image_height > target_height)
389 bg_flags |= BG_IS_SIZE_SENSITIVE; 343 bg_flags |= BG_IS_SIZE_SENSITIVE;
390}
391
392# ifdef HAVE_AFTERIMAGE
393bool
394rxvt_term::render_image (unsigned long tr_flags)
395{
396 init_asv ();
397
398 ASImage *background = NULL;
399 ARGB32 background_tint = TINT_LEAVE_SAME;
400
401# ifdef ENABLE_TRANSPARENCY
402 if (tr_flags)
403 background = pixmap2ximage (asv, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, 100);
404
405 if (tr_flags & BG_NEEDS_TINT)
406 {
407 ShadingInfo as_shade;
408 as_shade.shading = shade;
409
410 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
411 if (bg_flags & BG_TINT_SET)
412 tint.get (c);
413 as_shade.tintColor.red = c.r;
414 as_shade.tintColor.green = c.g;
415 as_shade.tintColor.blue = c.b;
416
417 background_tint = shading2tint32 (&as_shade);
418 }
419
420 if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)
421 {
422 ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,
423 (original_asim == NULL || tint == TINT_LEAVE_SAME) ? ASA_XImage : ASA_ASImage,
424 100, ASIMAGE_QUALITY_DEFAULT);
425 if (tmp)
426 {
427 destroy_asimage (&background);
428 background = tmp;
429 }
430 }
431# endif
432
433 ASImage *result = 0;
434
435 int target_width = szHint.width;
436 int target_height = szHint.height;
437 int new_pmap_width = target_width;
438 int new_pmap_height = target_height;
439
440 int x = 0;
441 int y = 0;
442 int w = 0;
443 int h = 0;
444
445 if (original_asim)
446 get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
447
448 if (!original_asim
449 || (!(bg_flags & BG_ROOT_ALIGN)
450 && (x >= target_width
451 || y >= target_height
452 || (x + w <= 0)
453 || (y + h <= 0))))
454 {
455 if (background)
456 {
457 new_pmap_width = background->width;
458 new_pmap_height = background->height;
459 result = background;
460
461 if (background_tint != TINT_LEAVE_SAME)
462 {
463 ASImage *tmp = tile_asimage (asv, background, 0, 0,
464 target_width, target_height, background_tint,
465 ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
466 if (tmp)
467 result = tmp;
468 }
469 }
470 else
471 new_pmap_width = new_pmap_height = 0;
472 }
473 else 344 else
474 { 345 bg_flags &= ~BG_IS_SIZE_SENSITIVE;
475 result = original_asim;
476
477 if ((w != original_asim->width)
478 || (h != original_asim->height))
479 {
480 result = scale_asimage (asv, original_asim,
481 w, h,
482 background ? ASA_ASImage : ASA_XImage,
483 100, ASIMAGE_QUALITY_DEFAULT);
484 }
485
486 if (background == NULL)
487 {
488 if (bg_flags & BG_TILE)
489 {
490 /* if tiling - pixmap has to be sized exactly as the image,
491 but there is no need to make it bigger than the window! */
492 new_pmap_width = min (result->width, target_width);
493 new_pmap_height = min (result->height, target_height);
494
495 /* we also need to tile our image in both directions */
496 ASImage *tmp = tile_asimage (asv, result,
497 (int)result->width - x,
498 (int)result->height - y,
499 new_pmap_width,
500 new_pmap_height,
501 TINT_LEAVE_SAME, ASA_XImage,
502 100, ASIMAGE_QUALITY_DEFAULT);
503 if (tmp)
504 {
505 if (result != original_asim)
506 destroy_asimage (&result);
507
508 result = tmp;
509 }
510 }
511 }
512 else
513 {
514 /* if blending background and image - pixmap has to be sized same as target window */
515 ASImageLayer *layers = create_image_layers (2);
516
517 layers[0].im = background;
518 layers[0].clip_width = target_width;
519 layers[0].clip_height = target_height;
520 layers[0].tint = background_tint;
521 layers[1].im = result;
522
523 if (bg_flags & BG_TILE)
524 {
525 /* tile horizontally */
526 while (x > 0) x -= (int)result->width;
527 layers[1].dst_x = x;
528 layers[1].clip_width = result->width+target_width;
529 }
530 else
531 {
532 /* clip horizontally */
533 layers[1].dst_x = x;
534 layers[1].clip_width = result->width;
535 }
536
537 if (bg_flags & BG_TILE)
538 {
539 while (y > 0) y -= (int)result->height;
540 layers[1].dst_y = y;
541 layers[1].clip_height = result->height + target_height;
542 }
543 else
544 {
545 layers[1].dst_y = y;
546 layers[1].clip_height = result->height;
547 }
548
549 if (rs[Rs_blendtype])
550 {
551 layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
552 if (layers[1].merge_scanlines == NULL)
553 layers[1].merge_scanlines = alphablend_scanlines;
554 }
555
556 ASImage *tmp = merge_layers (asv, layers, 2, target_width, target_height,
557 ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
558
559 if (tmp)
560 {
561 if (result != original_asim)
562 destroy_asimage (&result);
563
564 result = tmp;
565 }
566
567 free (layers);
568 }
569 }
570
571 bool ret = false;
572
573 if (result)
574 {
575 XGCValues gcv;
576 GC gc;
577
578 /* create Pixmap */
579 if (bg_pixmap == None
580 || bg_pmap_width != new_pmap_width
581 || bg_pmap_height != new_pmap_height)
582 {
583 if (bg_pixmap)
584 XFreePixmap (dpy, bg_pixmap);
585 bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
586 bg_pmap_width = new_pmap_width;
587 bg_pmap_height = new_pmap_height;
588 }
589 /* fill with background color (if result's not completely overlapping it) */
590 gcv.foreground = pix_colors[Color_bg];
591 gc = XCreateGC (dpy, vt, GCForeground, &gcv);
592
593 int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
594 int dst_width = result->width, dst_height = result->height;
595 if (background == NULL)
596 {
597 if (!(bg_flags & BG_TILE))
598 {
599 src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );
600 src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
601 }
602
603 if (dst_x > 0 || dst_y > 0
604 || dst_x + dst_width < new_pmap_width
605 || dst_y + dst_height < new_pmap_height)
606 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
607 }
608
609 /* put result on pixmap */
610 if (dst_x < new_pmap_width && dst_y < new_pmap_height)
611 asimage2drawable (asv, bg_pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);
612
613 if (result != background && result != original_asim)
614 destroy_asimage (&result);
615
616 XFreeGC (dpy, gc);
617
618 ret = true;
619 }
620
621 if (background)
622 destroy_asimage (&background);
623
624 return ret;
625} 346}
626# endif /* HAVE_AFTERIMAGE */
627 347
628# ifdef HAVE_PIXBUF 348# ifdef HAVE_PIXBUF
629bool 349bool
630rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc, 350rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
631 int src_x, int src_y, int dst_x, int dst_y, 351 int src_x, int src_y, int dst_x, int dst_y,
… …
708 XDestroyImage (ximage); 428 XDestroyImage (ximage);
709 return true; 429 return true;
710} 430}
711 431
712bool 432bool
713rxvt_term::render_image (unsigned long tr_flags) 433rxvt_term::render_image (bool transparent)
714{ 434{
715 if (!pixbuf) 435 if (!pixbuf)
716 return false; 436 return false;
717 437
718 if (tr_flags 438 if (transparent
719 && !(bg_flags & BG_HAS_RENDER)) 439 && !(bg_flags & BG_HAS_RENDER))
720 return false; 440 return false;
721 441
722 GdkPixbuf *result; 442 GdkPixbuf *result;
723 443
… …
737 get_image_geometry (image_width, image_height, w, h, x, y); 457 get_image_geometry (image_width, image_height, w, h, x, y);
738 458
739 if (!(bg_flags & BG_ROOT_ALIGN) 459 if (!(bg_flags & BG_ROOT_ALIGN)
740 && (x >= target_width 460 && (x >= target_width
741 || y >= target_height 461 || y >= target_height
742 || (x + w <= 0) 462 || x + w <= 0
743 || (y + h <= 0))) 463 || y + h <= 0))
744 return false; 464 return false;
745 465
746 result = pixbuf; 466 result = pixbuf;
747 467
748 if ((w != image_width) 468 if (w != image_width
749 || (h != image_height)) 469 || h != image_height)
750 { 470 {
751 result = gdk_pixbuf_scale_simple (pixbuf, 471 result = gdk_pixbuf_scale_simple (pixbuf,
752 w, h, 472 w, h,
753 GDK_INTERP_BILINEAR); 473 GDK_INTERP_BILINEAR);
754 } 474 }
… …
763 Pixmap root_pmap; 483 Pixmap root_pmap;
764 484
765 image_width = gdk_pixbuf_get_width (result); 485 image_width = gdk_pixbuf_get_width (result);
766 image_height = gdk_pixbuf_get_height (result); 486 image_height = gdk_pixbuf_get_height (result);
767 487
768 if (tr_flags) 488 if (transparent)
769 { 489 {
770 root_pmap = bg_pixmap; 490 root_pmap = bg_pixmap;
771 bg_pixmap = None; 491 bg_pixmap = None;
772 } 492 }
773 else 493 else
… …
831 dst_x, dst_y, 551 dst_x, dst_y,
832 dst_width, dst_height); 552 dst_width, dst_height);
833 } 553 }
834 554
835#if XRENDER 555#if XRENDER
836 if (tr_flags) 556 if (transparent)
837 { 557 {
838 XRenderPictureAttributes pa;
839
840 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, visual); 558 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
559
841 Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa); 560 Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
842 561
843 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
844 Picture dst = XRenderCreatePicture (dpy, bg_pixmap, dst_format, 0, &pa); 562 Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
845 563
846 pa.repeat = True; 564 Picture mask = create_xrender_mask (dpy, vt, False, False);
847 Pixmap mask_pmap = XCreatePixmap (dpy, vt, 1, 1, 8);
848 XRenderPictFormat *mask_format = XRenderFindStandardFormat (dpy, PictStandardA8);
849 Picture mask = XRenderCreatePicture (dpy, mask_pmap, mask_format, CPRepeat, &pa);
850 XFreePixmap (dpy, mask_pmap);
851 565
852 XRenderColor mask_c; 566 XRenderColor mask_c;
853 567
854 mask_c.alpha = 0x8000; 568 mask_c.alpha = 0x8000;
855 mask_c.red = 0; 569 mask_c.red =
856 mask_c.green = 0; 570 mask_c.green =
857 mask_c.blue = 0; 571 mask_c.blue = 0;
858 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1); 572 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
573
859 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height); 574 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
860 575
861 XRenderFreePicture (dpy, src); 576 XRenderFreePicture (dpy, src);
862 XRenderFreePicture (dpy, dst); 577 XRenderFreePicture (dpy, dst);
863 XRenderFreePicture (dpy, mask); 578 XRenderFreePicture (dpy, mask);
… …
870 } 585 }
871 586
872 if (result != pixbuf) 587 if (result != pixbuf)
873 g_object_unref (result); 588 g_object_unref (result);
874 589
875 if (tr_flags) 590 if (transparent)
876 XFreePixmap (dpy, root_pmap); 591 XFreePixmap (dpy, root_pmap);
877 592
878 return ret; 593 return ret;
879} 594}
880# endif /* HAVE_PIXBUF */ 595# endif /* HAVE_PIXBUF */
… …
883rxvt_term::bg_set_file (const char *file) 598rxvt_term::bg_set_file (const char *file)
884{ 599{
885 if (!file || !*file) 600 if (!file || !*file)
886 return false; 601 return false;
887 602
603 bool ret = false;
888 if (const char *p = strchr (file, ';')) 604 const char *p = strchr (file, ';');
605
606 if (p)
889 { 607 {
890 size_t len = p - file; 608 size_t len = p - file;
891 char *f = rxvt_temp_buf<char> (len + 1); 609 char *f = rxvt_temp_buf<char> (len + 1);
892 memcpy (f, file, len); 610 memcpy (f, file, len);
893 f[len] = '\0'; 611 f[len] = '\0';
894 file = f; 612 file = f;
895 } 613 }
896 614
897# ifdef HAVE_AFTERIMAGE
898 if (!asimman)
899 asimman = create_generic_imageman (rs[Rs_path]);
900 ASImage *image = get_asimage (asimman, file, 0xFFFFFFFF, 100);
901 if (image)
902 {
903 if (original_asim)
904 safe_asimage_destroy (original_asim);
905 original_asim = image;
906 bg_flags |= BG_IS_FROM_FILE | BG_CLIENT_RENDER;
907 return true;
908 }
909# endif
910
911# ifdef HAVE_PIXBUF 615# ifdef HAVE_PIXBUF
912 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL); 616 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
913 if (image) 617 if (image)
914 { 618 {
915 if (pixbuf) 619 if (pixbuf)
916 g_object_unref (pixbuf); 620 g_object_unref (pixbuf);
917 pixbuf = image; 621 pixbuf = image;
918 bg_flags |= BG_IS_FROM_FILE; 622 bg_flags |= BG_IS_FROM_FILE;
919 return true; 623 ret = true;
920 } 624 }
921# endif 625# endif
922 626
627 if (ret)
628 {
629 if (p)
630 bg_set_geometry (p + 1);
631 else
632 bg_set_default_geometry ();
633 }
634
923 return false; 635 return ret;
924} 636}
925 637
926# endif /* BG_IMAGE_FROM_FILE */ 638# endif /* BG_IMAGE_FROM_FILE */
927 639
928# ifdef ENABLE_TRANSPARENCY 640# ifdef ENABLE_TRANSPARENCY
… …
964 { 676 {
965 changed = true; 677 changed = true;
966 v_blurRadius = vr; 678 v_blurRadius = vr;
967 } 679 }
968 680
969 if (v_blurRadius == 0 && h_blurRadius == 0) 681 if (h_blurRadius && v_blurRadius)
682 bg_flags |= BG_NEEDS_BLUR;
683 else
970 bg_flags &= ~BG_NEEDS_BLUR; 684 bg_flags &= ~BG_NEEDS_BLUR;
971 else
972 bg_flags |= BG_NEEDS_BLUR;
973 685
974 return changed; 686 return changed;
975} 687}
976 688
977void 689void
978rxvt_term::set_tint_shade_flags () 690rxvt_term::set_tint_shade_flags ()
979{ 691{
980 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 692 if (shade != 100 || (bg_flags & BG_TINT_SET))
981 bool has_shade = shade != 100; 693 bg_flags |= BG_NEEDS_TINT;
694 else
695 bg_flags &= ~BG_NEEDS_TINT;
696}
982 697
698bool
699rxvt_term::bg_set_tint (rxvt_color &new_tint)
700{
701 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
702 {
703 tint = new_tint;
983 bg_flags &= ~BG_TINT_FLAGS; 704 bg_flags |= BG_TINT_SET;
984 705
985 if (bg_flags & BG_TINT_SET) 706 rgba c;
986 {
987 tint.get (c); 707 tint.get (c);
988 if (!has_shade
989 && (c.r <= 0x00ff || c.r >= 0xff00) 708 if ((c.r <= 0x00ff || c.r >= 0xff00)
990 && (c.g <= 0x00ff || c.g >= 0xff00) 709 && (c.g <= 0x00ff || c.g >= 0xff00)
991 && (c.b <= 0x00ff || c.b >= 0xff00)) 710 && (c.b <= 0x00ff || c.b >= 0xff00))
992 bg_flags |= BG_TINT_BITAND; 711 bg_flags |= BG_TINT_BITAND;
993 } 712 else
994
995 if (has_shade || (bg_flags & BG_TINT_SET))
996 bg_flags |= BG_NEEDS_TINT;
997}
998
999bool
1000rxvt_term::bg_set_tint (rxvt_color &new_tint)
1001{
1002 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
1003 {
1004 tint = new_tint;
1005 bg_flags |= BG_TINT_SET; 713 bg_flags &= ~BG_TINT_BITAND;
714
1006 set_tint_shade_flags (); 715 set_tint_shade_flags ();
1007 return true; 716 return true;
1008 } 717 }
1009 718
1010 return false; 719 return false;
1011} 720}
1012 721
1013bool 722bool
1014rxvt_term::bg_set_shade (const char *shade_str) 723rxvt_term::bg_set_shade (const char *shade_str)
1015{ 724{
1016 int new_shade = (shade_str) ? atoi (shade_str) : 100; 725 int new_shade = atoi (shade_str);
1017 726
1018 clamp_it (new_shade, -100, 200); 727 clamp_it (new_shade, -100, 200);
1019 if (new_shade < 0) 728 if (new_shade < 0)
1020 new_shade = 200 - (100 + new_shade); 729 new_shade = 200 - (100 + new_shade);
1021 730
… …
1051 params[i+2] = XDoubleToFixed (kernel[i] / sum); 760 params[i+2] = XDoubleToFixed (kernel[i] / sum);
1052} 761}
1053#endif 762#endif
1054 763
1055bool 764bool
1056rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 765rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height, int depth)
1057{ 766{
1058 bool ret = false; 767 bool ret = false;
1059#if XRENDER 768#if XRENDER
769 if (!(bg_flags & BG_HAS_RENDER_CONV))
770 return false;
771
1060 int size = max (h_blurRadius, v_blurRadius) * 2 + 1; 772 int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1061 double *kernel = (double *)malloc (size * sizeof (double)); 773 double *kernel = (double *)malloc (size * sizeof (double));
1062 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 774 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1063 775
1064 XRenderPictureAttributes pa; 776 XRenderPictureAttributes pa;
1065 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 777 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1066 778
779 pa.repeat = RepeatPad;
1067 Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 780 Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
781 Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1068 Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 782 Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
783 XFreePixmap (dpy, tmp);
1069 784
1070 if (kernel && params) 785 if (kernel && params)
1071 { 786 {
1072 if (h_blurRadius)
1073 {
1074 size = h_blurRadius * 2 + 1; 787 size = h_blurRadius * 2 + 1;
1075 get_gaussian_kernel (h_blurRadius, size, kernel, params); 788 get_gaussian_kernel (h_blurRadius, size, kernel, params);
1076 789
1077 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 790 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1078 XRenderComposite (dpy, 791 XRenderComposite (dpy,
1079 PictOpSrc, 792 PictOpSrc,
1080 src, 793 src,
1081 None, 794 None,
1082 dst, 795 dst,
1083 0, 0, 796 0, 0,
1084 0, 0, 797 0, 0,
1085 0, 0, 798 0, 0,
1086 width, height); 799 width, height);
1087 }
1088 800
1089 if (v_blurRadius) 801 ::swap (src, dst);
1090 { 802
1091 size = v_blurRadius * 2 + 1; 803 size = v_blurRadius * 2 + 1;
1092 get_gaussian_kernel (v_blurRadius, size, kernel, params); 804 get_gaussian_kernel (v_blurRadius, size, kernel, params);
1093 ::swap (params[0], params[1]); 805 ::swap (params[0], params[1]);
1094 806
1095 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 807 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1096 XRenderComposite (dpy, 808 XRenderComposite (dpy,
1097 PictOpSrc, 809 PictOpSrc,
1098 src, 810 src,
1099 None, 811 None,
1100 dst, 812 dst,
1101 0, 0, 813 0, 0,
1102 0, 0, 814 0, 0,
1103 0, 0, 815 0, 0,
1104 width, height); 816 width, height);
1105 }
1106 817
1107 ret = true; 818 ret = true;
1108 } 819 }
1109 820
1110 free (kernel); 821 free (kernel);
… …
1118bool 829bool
1119rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 830rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1120{ 831{
1121 bool ret = false; 832 bool ret = false;
1122 833
1123 if (bg_flags & BG_TINT_BITAND) 834 if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1124 { 835 {
1125 XGCValues gcv; 836 XGCValues gcv;
1126 GC gc; 837 GC gc;
1127 838
1128 /* In this case we can tint image server-side getting significant 839 /* In this case we can tint image server-side getting significant
… …
1137 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height); 848 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1138 ret = true; 849 ret = true;
1139 XFreeGC (dpy, gc); 850 XFreeGC (dpy, gc);
1140 } 851 }
1141 } 852 }
1142 else
1143 {
1144# if XRENDER 853# if XRENDER
854 else if (bg_flags & BG_HAS_RENDER)
855 {
1145 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC); 856 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1146 857
1147 if (bg_flags & BG_TINT_SET) 858 if (bg_flags & BG_TINT_SET)
1148 tint.get (c); 859 tint.get (c);
1149 860
… …
1158 c.r = c.r * (200 - shade) / 100; 869 c.r = c.r * (200 - shade) / 100;
1159 c.g = c.g * (200 - shade) / 100; 870 c.g = c.g * (200 - shade) / 100;
1160 c.b = c.b * (200 - shade) / 100; 871 c.b = c.b * (200 - shade) / 100;
1161 } 872 }
1162 873
1163 XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1164 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 874 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1165 XRenderPictureAttributes pa;
1166 875
1167 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 876 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1168 877
1169 pa.repeat = True; 878 Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1170 879
1171 Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32); 880 Picture mask_pic = create_xrender_mask (dpy, pixmap, True, True);
1172 Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1173 XFreePixmap (dpy, overlay_pmap);
1174
1175 pa.component_alpha = True;
1176 Pixmap mask_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
1177 Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat | CPComponentAlpha, &pa);
1178 XFreePixmap (dpy, mask_pmap);
1179 881
1180 XRenderColor mask_c; 882 XRenderColor mask_c;
1181 883
1182 mask_c.alpha = 0xffff; 884 mask_c.alpha = 0xffff;
1183 mask_c.red = 885 mask_c.red =
… …
1188 mask_c.alpha = 0; 890 mask_c.alpha = 0;
1189 mask_c.red = 0xffff - c.r; 891 mask_c.red = 0xffff - c.r;
1190 mask_c.green = 0xffff - c.g; 892 mask_c.green = 0xffff - c.g;
1191 mask_c.blue = 0xffff - c.b; 893 mask_c.blue = 0xffff - c.b;
1192 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1); 894 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
895
1193 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height); 896 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1194 897
1195 if (shade > 100) 898 if (shade > 100)
1196 { 899 {
1197 mask_c.red = mask_c.green = mask_c.blue = 0xffff * (shade - 100) / 100;
1198 mask_c.alpha = 0; 900 mask_c.alpha = 0;
901 mask_c.red =
902 mask_c.green =
903 mask_c.blue = 0xffff * (shade - 100) / 100;
1199 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1); 904 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1200 905
1201 XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height); 906 XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1202 } 907 }
1203 908
1204 ret = true; 909 ret = true;
1205 910
1206 XRenderFreePicture (dpy, mask_pic); 911 XRenderFreePicture (dpy, mask_pic);
1207 XRenderFreePicture (dpy, overlay_pic); 912 XRenderFreePicture (dpy, overlay_pic);
1208 XRenderFreePicture (dpy, back_pic); 913 XRenderFreePicture (dpy, back_pic);
914 }
1209# endif 915# endif
1210 }
1211 916
1212 return ret; 917 return ret;
1213} 918}
1214 919
1215/* 920/*
1216 * Builds a pixmap of the same size as the terminal window that contains 921 * Builds a pixmap of the same size as the terminal window that contains
1217 * the tiled portion of the root pixmap that is supposed to be covered by 922 * the tiled portion of the root pixmap that is supposed to be covered by
1218 * our window. 923 * our window.
1219 */ 924 */
1220unsigned long 925bool
1221rxvt_term::make_transparency_pixmap () 926rxvt_term::make_transparency_pixmap ()
1222{ 927{
1223 unsigned long result = 0; 928 bool ret = false;
1224 929
1225 /* root dimensions may change from call to call - but Display structure should 930 /* root dimensions may change from call to call - but Display structure should
1226 * be always up-to-date, so let's use it : 931 * be always up-to-date, so let's use it :
1227 */ 932 */
1228 int screen = display->screen; 933 int screen = display->screen;
… …
1266#if XRENDER 971#if XRENDER
1267 if (bg_flags & BG_HAS_RENDER) 972 if (bg_flags & BG_HAS_RENDER)
1268 { 973 {
1269 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth); 974 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1270 975
1271 XRenderPictureAttributes pa;
1272
1273 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen)); 976 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1274 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa); 977 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1275 978
1276 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual); 979 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1277 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa); 980 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1278 981
1279 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height); 982 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
1280 983
1281 XRenderFreePicture (dpy, src); 984 XRenderFreePicture (dpy, src);
1282 XRenderFreePicture (dpy, dst); 985 XRenderFreePicture (dpy, dst);
… …
1299 bg_pmap_width = window_width; 1002 bg_pmap_width = window_width;
1300 bg_pmap_height = window_height; 1003 bg_pmap_height = window_height;
1301 } 1004 }
1302 1005
1303 /* straightforward pixmap copy */ 1006 /* straightforward pixmap copy */
1304 while (sx < 0) sx += root_width; 1007 while (sx < 0) sx += root_pmap_width;
1305 while (sy < 0) sy += root_height; 1008 while (sy < 0) sy += root_pmap_height;
1306 1009
1307 gcv.tile = recoded_root_pmap; 1010 gcv.tile = recoded_root_pmap;
1308 gcv.fill_style = FillTiled; 1011 gcv.fill_style = FillTiled;
1309 gcv.ts_x_origin = -sx; 1012 gcv.ts_x_origin = -sx;
1310 gcv.ts_y_origin = -sy; 1013 gcv.ts_y_origin = -sy;
1311 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); 1014 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1312 1015
1313 if (gc) 1016 if (gc)
1314 { 1017 {
1315 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height); 1018 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1316 result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS); 1019 ret = true;
1020 unsigned long tr_flags = bg_flags & BG_EFFECTS_FLAGS;
1021
1022 if (!(bg_flags & BG_CLIENT_RENDER))
1023 {
1024 if (bg_flags & BG_NEEDS_BLUR)
1025 {
1026 if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth))
1027 tr_flags &= ~BG_NEEDS_BLUR;
1028 }
1029 if (bg_flags & BG_NEEDS_TINT)
1030 {
1031 if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1032 tr_flags &= ~BG_NEEDS_TINT;
1033 }
1034 if (tr_flags & BG_NEEDS_TINT)
1035 {
1036 XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1037 if (ximage)
1038 {
1039 /* our own client-side tinting */
1040 tint_ximage (DefaultVisual (dpy, display->screen), ximage);
1041
1042 XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
1043 XDestroyImage (ximage);
1044 }
1045 }
1046 } /* server side rendering completed */
1047
1317 XFreeGC (dpy, gc); 1048 XFreeGC (dpy, gc);
1318
1319 if (!(bg_flags & BG_CLIENT_RENDER))
1320 {
1321 if ((bg_flags & BG_NEEDS_BLUR)
1322 && (bg_flags & BG_HAS_RENDER_CONV))
1323 {
1324 if (blur_pixmap (bg_pixmap, visual, window_width, window_height))
1325 result &= ~BG_NEEDS_BLUR;
1326 }
1327 if ((bg_flags & BG_NEEDS_TINT)
1328 && (bg_flags & (BG_TINT_BITAND | BG_HAS_RENDER)))
1329 {
1330 if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1331 result &= ~BG_NEEDS_TINT;
1332 }
1333 } /* server side rendering completed */
1334 } 1049 }
1335 1050
1336 if (recoded_root_pmap != root_pixmap) 1051 if (recoded_root_pmap != root_pixmap)
1337 XFreePixmap (dpy, recoded_root_pmap); 1052 XFreePixmap (dpy, recoded_root_pmap);
1338 1053
1339 return result; 1054 return ret;
1340} 1055}
1341 1056
1342void 1057void
1343rxvt_term::bg_set_root_pixmap () 1058rxvt_term::bg_set_root_pixmap ()
1344{ 1059{
… …
1348 1063
1349 root_pixmap = new_root_pixmap; 1064 root_pixmap = new_root_pixmap;
1350} 1065}
1351# endif /* ENABLE_TRANSPARENCY */ 1066# endif /* ENABLE_TRANSPARENCY */
1352 1067
1353#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1354static void shade_ximage (Visual *visual, XImage *ximage, int shade, const rgba &c);
1355# endif
1356
1357bool 1068bool
1358rxvt_term::bg_render () 1069rxvt_term::bg_render ()
1359{ 1070{
1360 unsigned long tr_flags = 0; 1071 bool transparent = false;
1361 1072
1362 bg_invalidate (); 1073 bg_invalidate ();
1363# ifdef ENABLE_TRANSPARENCY 1074# ifdef ENABLE_TRANSPARENCY
1364 if (bg_flags & BG_IS_TRANSPARENT) 1075 if (bg_flags & BG_IS_TRANSPARENT)
1365 { 1076 {
1366 /* we need to re-generate transparency pixmap in that case ! */ 1077 /* we need to re-generate transparency pixmap in that case ! */
1367 tr_flags = make_transparency_pixmap (); 1078 transparent = make_transparency_pixmap ();
1368 if (tr_flags == 0) 1079 if (transparent)
1369 return false;
1370 else if (!(tr_flags & BG_EFFECTS_FLAGS))
1371 bg_flags |= BG_IS_VALID; 1080 bg_flags |= BG_IS_VALID;
1372 } 1081 }
1373# endif 1082# endif
1374 1083
1375# ifdef BG_IMAGE_FROM_FILE 1084# ifdef BG_IMAGE_FROM_FILE
1376 if ((bg_flags & BG_IS_FROM_FILE) 1085 if (bg_flags & BG_IS_FROM_FILE)
1377 || (tr_flags & BG_EFFECTS_FLAGS))
1378 { 1086 {
1379 if (render_image (tr_flags)) 1087 if (render_image (transparent))
1380 bg_flags |= BG_IS_VALID; 1088 bg_flags |= BG_IS_VALID;
1381 }
1382# endif
1383
1384# if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1385 XImage *result = NULL;
1386
1387 if (tr_flags && !(bg_flags & BG_IS_VALID))
1388 {
1389 result = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1390 }
1391
1392 if (result)
1393 {
1394 /* our own client-side tinting */
1395 if (tr_flags & BG_NEEDS_TINT)
1396 {
1397 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1398 if (bg_flags & BG_TINT_SET)
1399 tint.get (c);
1400 shade_ximage (DefaultVisual (dpy, display->screen), result, shade, c);
1401 }
1402
1403 GC gc = XCreateGC (dpy, vt, 0UL, NULL);
1404
1405 if (gc)
1406 {
1407 XPutImage (dpy, bg_pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1408
1409 XFreeGC (dpy, gc);
1410 bg_flags |= BG_IS_VALID;
1411 }
1412
1413 XDestroyImage (result);
1414 } 1089 }
1415# endif 1090# endif
1416 1091
1417 if (!(bg_flags & BG_IS_VALID)) 1092 if (!(bg_flags & BG_IS_VALID))
1418 { 1093 {
… …
1455#endif 1130#endif
1456} 1131}
1457 1132
1458#endif /* HAVE_BG_PIXMAP */ 1133#endif /* HAVE_BG_PIXMAP */
1459 1134
1460#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) 1135#ifdef ENABLE_TRANSPARENCY
1461/* taken from aterm-0.4.2 */ 1136/* based on code from aterm-0.4.2 */
1462 1137
1463static void 1138static inline void
1464shade_ximage (Visual *visual, XImage *ximage, int shade, const rgba &c) 1139fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
1140{
1141 for (int i = 0; i <= mask >> sh; i++)
1142 {
1143 uint32_t tmp;
1144 tmp = i * high;
1145 tmp += (mask >> sh) * low;
1146 lookup[i] = (tmp / 0xffff) << sh;
1147 }
1148}
1149
1150void
1151rxvt_term::tint_ximage (Visual *visual, XImage *ximage)
1465{ 1152{
1466 int sh_r, sh_g, sh_b; 1153 int sh_r, sh_g, sh_b;
1467 uint32_t mask_r, mask_g, mask_b; 1154 uint32_t mask_r, mask_g, mask_b;
1468 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b; 1155 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1469 rgba low; 1156 unsigned short low;
1470 rgba high;
1471 int i;
1472 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst; 1157 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1473 1158
1474 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return; 1159 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;
1475 1160
1476 /* for convenience */ 1161 /* for convenience */
… …
1535 break; 1220 break;
1536 default: 1221 default:
1537 return; /* we do not support this color depth */ 1222 return; /* we do not support this color depth */
1538 } 1223 }
1539 1224
1225 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1226
1227 if (bg_flags & BG_TINT_SET)
1228 tint.get (c);
1229
1540 /* prepare limits for color transformation (each channel is handled separately) */ 1230 /* prepare limits for color transformation (each channel is handled separately) */
1541 if (shade > 100) 1231 if (shade > 100)
1542 { 1232 {
1543 shade = 200 - shade;
1544
1545 high.r = c.r * shade / 100;
1546 high.g = c.g * shade / 100;
1547 high.b = c.b * shade / 100;
1548
1549 low.r = 65535 * (100 - shade) / 100; 1233 c.r = c.r * (200 - shade) / 100;
1550 low.g = 65535 * (100 - shade) / 100; 1234 c.g = c.g * (200 - shade) / 100;
1551 low.b = 65535 * (100 - shade) / 100; 1235 c.b = c.b * (200 - shade) / 100;
1236
1237 low = 0xffff * (shade - 100) / 100;
1552 } 1238 }
1553 else 1239 else
1554 { 1240 {
1555 high.r = c.r * shade / 100; 1241 c.r = c.r * shade / 100;
1556 high.g = c.g * shade / 100; 1242 c.g = c.g * shade / 100;
1557 high.b = c.b * shade / 100; 1243 c.b = c.b * shade / 100;
1558 1244
1559 low.r = low.g = low.b = 0; 1245 low = 0;
1560 } 1246 }
1561 1247
1562 /* fill our lookup tables */ 1248 /* fill our lookup tables */
1563 for (i = 0; i <= mask_r>>sh_r; i++) 1249 fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1564 { 1250 fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1565 uint32_t tmp; 1251 fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1566 tmp = i * high.r;
1567 tmp += (mask_r>>sh_r) * low.r;
1568 lookup_r[i] = (tmp/65535)<<sh_r;
1569 }
1570 for (i = 0; i <= mask_g>>sh_g; i++)
1571 {
1572 uint32_t tmp;
1573 tmp = i * high.g;
1574 tmp += (mask_g>>sh_g) * low.g;
1575 lookup_g[i] = (tmp/65535)<<sh_g;
1576 }
1577 for (i = 0; i <= mask_b>>sh_b; i++)
1578 {
1579 uint32_t tmp;
1580 tmp = i * high.b;
1581 tmp += (mask_b>>sh_b) * low.b;
1582 lookup_b[i] = (tmp/65535)<<sh_b;
1583 }
1584 1252
1585 /* apply table to input image (replacing colors by newly calculated ones) */ 1253 /* apply table to input image (replacing colors by newly calculated ones) */
1586 if (ximage->bits_per_pixel == 32 1254 if (ximage->bits_per_pixel == 32
1587 && (ximage->depth == 24 || ximage->depth == 32) 1255 && (ximage->depth == 24 || ximage->depth == 32)
1588 && ximage->byte_order == host_byte_order) 1256 && ximage->byte_order == host_byte_order)
… …
1618 } 1286 }
1619 } 1287 }
1620 1288
1621 free (lookup); 1289 free (lookup);
1622} 1290}
1623#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */ 1291#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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