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.194 by sf-exg, Sun Jan 1 17:43:47 2012 UTC vs.
Revision 1.208 by sf-exg, Fri May 11 08:16:58 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>
31#endif 31#endif
32 32
33#ifndef FilterConvolution 33#ifndef FilterConvolution
34#define FilterConvolution "convolution" 34#define FilterConvolution "convolution"
35#endif
36
37#ifndef RepeatPad
38#define RepeatPad True
35#endif 39#endif
36 40
37#ifdef HAVE_BG_PIXMAP 41#ifdef HAVE_BG_PIXMAP
38# if XRENDER 42# if XRENDER
39static Picture 43static Picture
… …
54# endif 58# endif
55 59
56void 60void
57rxvt_term::bg_destroy () 61rxvt_term::bg_destroy ()
58{ 62{
59#ifdef HAVE_AFTERIMAGE
60 if (original_asim)
61 safe_asimage_destroy (original_asim);
62 if (asv)
63 destroy_asvisual (asv, 0);
64 if (asimman)
65 destroy_image_manager (asimman, 0);
66#endif
67
68#ifdef HAVE_PIXBUF 63#ifdef HAVE_PIXBUF
69 if (pixbuf) 64 if (pixbuf)
70 g_object_unref (pixbuf); 65 g_object_unref (pixbuf);
71#endif 66#endif
72 67
… …
125 120
126 return false; 121 return false;
127} 122}
128 123
129# ifdef BG_IMAGE_FROM_FILE 124# ifdef BG_IMAGE_FROM_FILE
130static inline bool
131check_set_scale_value (int geom_flags, int flag, unsigned int &scale, unsigned int new_value)
132{
133 if (geom_flags & flag)
134 {
135 if (new_value > 1000)
136 new_value = 1000;
137 if (new_value != scale)
138 {
139 scale = new_value;
140 return true;
141 }
142 }
143 return false;
144}
145
146static inline bool
147check_set_align_value (int geom_flags, int flag, int &align, int new_value)
148{
149 if (geom_flags & flag)
150 {
151 if (new_value < -100)
152 new_value = -100;
153 else if (new_value > 200)
154 new_value = 200;
155 if (new_value != align)
156 {
157 align = new_value;
158 return true;
159 }
160 }
161 return false;
162}
163
164static inline int 125static inline int
165make_align_position (int align, int window_size, int image_size) 126make_align_position (int align, int window_size, int image_size)
166{ 127{
167 int diff = window_size - image_size;
168 int smaller = min (image_size, window_size);
169
170 if (align >= 0 && align <= 100) 128 if (align >= 0 && align <= 100)
171 return diff * align / 100; 129 return lerp (0, window_size - image_size, align);
172 else if (align > 100 && align <= 200) 130 else if (align > 100)
173 return (align - 100) * smaller / 100 + window_size - smaller; 131 return lerp (window_size - image_size, window_size, align - 100);
174 else if (align >= -100 && align < 0) 132 else
175 return (align + 100) * smaller / 100 - image_size; 133 return lerp (-image_size, 0, align + 100);
176 return 0;
177} 134}
178 135
179static inline int 136static inline int
180make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size) 137make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)
181{ 138{
… …
187 src_pos = -pos; 144 src_pos = -pos;
188 dst_pos = 0; 145 dst_pos = 0;
189 dst_size += pos; 146 dst_size += pos;
190 } 147 }
191 148
192 if (dst_pos + dst_size > target_size)
193 dst_size = target_size - dst_pos; 149 min_it (dst_size, target_size - dst_pos);
194 return src_pos; 150 return src_pos;
195} 151}
196 152
197bool 153bool
198rxvt_term::bg_set_geometry (const char *geom, bool update) 154rxvt_term::bg_set_geometry (const char *geom, bool update)
199{ 155{
200 bool changed = false; 156 bool changed = false;
201 int geom_flags = 0; 157 int geom_flags = 0;
202 int x = 0, y = 0; 158 int x = h_align;
159 int y = v_align;
203 unsigned int w = 0, h = 0; 160 unsigned int w = h_scale;
161 unsigned int h = v_scale;
204 unsigned long new_flags = 0; 162 unsigned long new_flags = 0;
205 163
206 if (geom == NULL) 164 if (geom == NULL)
207 return false; 165 return false;
208 166
… …
317 w = h = defaultScale; 275 w = h = defaultScale;
318 else if (!(geom_flags & HeightValue)) 276 else if (!(geom_flags & HeightValue))
319 h = w; 277 h = w;
320 else if (!(geom_flags & WidthValue)) 278 else if (!(geom_flags & WidthValue))
321 w = h; 279 w = h;
322
323 geom_flags |= WidthValue|HeightValue|XValue|YValue;
324 } 280 }
325 281
326 if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true; 282 min_it (w, 1000);
327 if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true; 283 min_it (h, 1000);
328 if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true; 284 clamp_it (x, -100, 200);
329 if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true; 285 clamp_it (y, -100, 200);
330 286
331 if (new_flags != bg_flags) 287 if (bg_flags != new_flags
288 || h_scale != w
289 || v_scale != h
290 || h_align != x
291 || v_align != y)
332 { 292 {
333 bg_flags = new_flags; 293 bg_flags = new_flags;
294 h_scale = w;
295 v_scale = h;
296 h_align = x;
297 v_align = y;
334 changed = true; 298 changed = true;
335 } 299 }
336 300
337 return changed; 301 return changed;
338} 302}
… …
366 { 330 {
367 x = make_align_position (h_align, target_width, w); 331 x = make_align_position (h_align, target_width, w);
368 y = make_align_position (v_align, target_height, h); 332 y = make_align_position (v_align, target_height, h);
369 } 333 }
370 334
371 bg_flags &= ~BG_IS_SIZE_SENSITIVE;
372 if (!(bg_flags & BG_TILE) 335 if (!(bg_flags & BG_TILE)
373 || h_scale || v_scale 336 || h_scale || v_scale
374 || (!(bg_flags & BG_ROOT_ALIGN) && (h_align || v_align)) 337 || (!(bg_flags & BG_ROOT_ALIGN) && (h_align || v_align))
375 || w > target_width || h > target_height) 338 || image_width > target_width || image_height > target_height)
376 bg_flags |= BG_IS_SIZE_SENSITIVE; 339 bg_flags |= BG_IS_SIZE_SENSITIVE;
377}
378
379# ifdef HAVE_AFTERIMAGE
380bool
381rxvt_term::render_image (unsigned long tr_flags)
382{
383 init_asv ();
384
385 ASImage *background = NULL;
386 ARGB32 background_tint = TINT_LEAVE_SAME;
387
388# ifdef ENABLE_TRANSPARENCY
389 if (tr_flags)
390 background = pixmap2ximage (asv, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, 100);
391
392 if (tr_flags & BG_NEEDS_TINT)
393 {
394 ShadingInfo as_shade;
395 as_shade.shading = shade;
396
397 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
398 if (bg_flags & BG_TINT_SET)
399 tint.get (c);
400 as_shade.tintColor.red = c.r;
401 as_shade.tintColor.green = c.g;
402 as_shade.tintColor.blue = c.b;
403
404 background_tint = shading2tint32 (&as_shade);
405 }
406
407 if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)
408 {
409 ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,
410 ASA_XImage,
411 100, ASIMAGE_QUALITY_DEFAULT);
412 if (tmp)
413 {
414 destroy_asimage (&background);
415 background = tmp;
416 }
417 }
418# endif
419
420 ASImage *result = 0;
421
422 int target_width = szHint.width;
423 int target_height = szHint.height;
424 int new_pmap_width = target_width;
425 int new_pmap_height = target_height;
426
427 int x = 0;
428 int y = 0;
429 int w = 0;
430 int h = 0;
431
432 if (original_asim)
433 get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
434
435 if (!original_asim
436 || (!(bg_flags & BG_ROOT_ALIGN)
437 && (x >= target_width
438 || y >= target_height
439 || x + w <= 0
440 || y + h <= 0)))
441 {
442 if (background)
443 {
444 new_pmap_width = background->width;
445 new_pmap_height = background->height;
446 result = background;
447
448 if (background_tint != TINT_LEAVE_SAME)
449 {
450 ASImage *tmp = tile_asimage (asv, background, 0, 0,
451 target_width, target_height, background_tint,
452 ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
453 if (tmp)
454 result = tmp;
455 }
456 }
457 else
458 new_pmap_width = new_pmap_height = 0;
459 }
460 else 340 else
461 { 341 bg_flags &= ~BG_IS_SIZE_SENSITIVE;
462 result = original_asim;
463
464 if (w != original_asim->width
465 || h != original_asim->height)
466 {
467 result = scale_asimage (asv, original_asim,
468 w, h,
469 ASA_XImage,
470 100, ASIMAGE_QUALITY_DEFAULT);
471 }
472
473 if (background == NULL)
474 {
475 if (bg_flags & BG_TILE)
476 {
477 /* if tiling - pixmap has to be sized exactly as the image,
478 but there is no need to make it bigger than the window! */
479 new_pmap_width = min (result->width, target_width);
480 new_pmap_height = min (result->height, target_height);
481
482 /* we also need to tile our image in both directions */
483 ASImage *tmp = tile_asimage (asv, result,
484 (int)result->width - x,
485 (int)result->height - y,
486 new_pmap_width,
487 new_pmap_height,
488 TINT_LEAVE_SAME, ASA_XImage,
489 100, ASIMAGE_QUALITY_DEFAULT);
490 if (tmp)
491 {
492 if (result != original_asim)
493 destroy_asimage (&result);
494
495 result = tmp;
496 }
497 }
498 }
499 else
500 {
501 /* if blending background and image - pixmap has to be sized same as target window */
502 ASImageLayer *layers = create_image_layers (2);
503
504 layers[0].im = background;
505 layers[0].clip_width = target_width;
506 layers[0].clip_height = target_height;
507 layers[0].tint = background_tint;
508 layers[1].im = result;
509
510 if (bg_flags & BG_TILE)
511 {
512 /* tile horizontally */
513 while (x > 0) x -= (int)result->width;
514 layers[1].dst_x = x;
515 layers[1].clip_width = result->width+target_width;
516 }
517 else
518 {
519 /* clip horizontally */
520 layers[1].dst_x = x;
521 layers[1].clip_width = result->width;
522 }
523
524 if (bg_flags & BG_TILE)
525 {
526 while (y > 0) y -= (int)result->height;
527 layers[1].dst_y = y;
528 layers[1].clip_height = result->height + target_height;
529 }
530 else
531 {
532 layers[1].dst_y = y;
533 layers[1].clip_height = result->height;
534 }
535
536 if (rs[Rs_blendtype])
537 {
538 layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
539 if (layers[1].merge_scanlines == NULL)
540 layers[1].merge_scanlines = alphablend_scanlines;
541 }
542
543 ASImage *tmp = merge_layers (asv, layers, 2, target_width, target_height,
544 ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
545
546 if (tmp)
547 {
548 if (result != original_asim)
549 destroy_asimage (&result);
550
551 result = tmp;
552 }
553
554 free (layers);
555 }
556 }
557
558 bool ret = false;
559
560 if (result)
561 {
562 XGCValues gcv;
563 GC gc;
564
565 /* create Pixmap */
566 if (bg_pixmap == None
567 || bg_pmap_width != new_pmap_width
568 || bg_pmap_height != new_pmap_height)
569 {
570 if (bg_pixmap)
571 XFreePixmap (dpy, bg_pixmap);
572 bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
573 bg_pmap_width = new_pmap_width;
574 bg_pmap_height = new_pmap_height;
575 }
576 /* fill with background color (if result's not completely overlapping it) */
577 gcv.foreground = pix_colors[Color_bg];
578 gc = XCreateGC (dpy, vt, GCForeground, &gcv);
579
580 int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
581 int dst_width = result->width, dst_height = result->height;
582 if (background == NULL)
583 {
584 if (!(bg_flags & BG_TILE))
585 {
586 src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );
587 src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
588 }
589
590 if (dst_x > 0 || dst_y > 0
591 || dst_x + dst_width < new_pmap_width
592 || dst_y + dst_height < new_pmap_height)
593 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
594 }
595
596 /* put result on pixmap */
597 if (dst_x < new_pmap_width && dst_y < new_pmap_height)
598 asimage2drawable (asv, bg_pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);
599
600 if (result != background && result != original_asim)
601 destroy_asimage (&result);
602
603 XFreeGC (dpy, gc);
604
605 ret = true;
606 }
607
608 if (background)
609 destroy_asimage (&background);
610
611 return ret;
612} 342}
613# endif /* HAVE_AFTERIMAGE */
614 343
615# ifdef HAVE_PIXBUF 344# ifdef HAVE_PIXBUF
616bool 345bool
617rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc, 346rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
618 int src_x, int src_y, int dst_x, int dst_y, 347 int src_x, int src_y, int dst_x, int dst_y,
619 unsigned int width, unsigned int height) 348 unsigned int width, unsigned int height)
620{ 349{
621 XImage *ximage; 350 XImage *ximage;
622 char *data, *line; 351 char *data, *line;
623 int bytes_per_pixel; 352 int bytes_per_pixel;
624 int width_r, width_g, width_b; 353 int width_r, width_g, width_b, width_a;
625 int sh_r, sh_g, sh_b; 354 int sh_r, sh_g, sh_b, sh_a;
355 uint32_t alpha_mask;
626 int rowstride; 356 int rowstride;
627 int channels; 357 int channels;
628 unsigned char *row; 358 unsigned char *row;
629 359
630 if (visual->c_class != TrueColor) 360 if (visual->c_class != TrueColor)
631 return false; 361 return false;
362
363#if XRENDER
364 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
365 if (format)
366 alpha_mask = (uint32_t)format->direct.alphaMask << format->direct.alpha;
367 else
368#endif
369 alpha_mask = 0;
632 370
633 if (depth == 24 || depth == 32) 371 if (depth == 24 || depth == 32)
634 bytes_per_pixel = 4; 372 bytes_per_pixel = 4;
635 else if (depth == 15 || depth == 16) 373 else if (depth == 15 || depth == 16)
636 bytes_per_pixel = 2; 374 bytes_per_pixel = 2;
… …
638 return false; 376 return false;
639 377
640 width_r = ecb_popcount32 (visual->red_mask); 378 width_r = ecb_popcount32 (visual->red_mask);
641 width_g = ecb_popcount32 (visual->green_mask); 379 width_g = ecb_popcount32 (visual->green_mask);
642 width_b = ecb_popcount32 (visual->blue_mask); 380 width_b = ecb_popcount32 (visual->blue_mask);
381 width_a = ecb_popcount32 (alpha_mask);
643 382
644 if (width_r > 8 || width_g > 8 || width_b > 8) 383 if (width_r > 8 || width_g > 8 || width_b > 8 || width_a > 8)
645 return false; 384 return false;
646 385
647 sh_r = ecb_ctz32 (visual->red_mask); 386 sh_r = ecb_ctz32 (visual->red_mask);
648 sh_g = ecb_ctz32 (visual->green_mask); 387 sh_g = ecb_ctz32 (visual->green_mask);
649 sh_b = ecb_ctz32 (visual->blue_mask); 388 sh_b = ecb_ctz32 (visual->blue_mask);
389 sh_a = ecb_ctz32 (alpha_mask);
650 390
651 if (width > INT_MAX / height / bytes_per_pixel) 391 if (width > INT_MAX / height / bytes_per_pixel)
652 return false; 392 return false;
653 393
654 data = (char *)malloc (width * height * bytes_per_pixel); 394 data = (char *)malloc (width * height * bytes_per_pixel);
… …
668 rowstride = gdk_pixbuf_get_rowstride (pixbuf); 408 rowstride = gdk_pixbuf_get_rowstride (pixbuf);
669 channels = gdk_pixbuf_get_n_channels (pixbuf); 409 channels = gdk_pixbuf_get_n_channels (pixbuf);
670 row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels; 410 row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels;
671 line = data; 411 line = data;
672 412
413 rgba c (0, 0, 0);
414
415 if (channels == 4 && alpha_mask == 0)
416 {
417 pix_colors[Color_bg].get (c);
418 c.r >>= 8;
419 c.g >>= 8;
420 c.b >>= 8;
421 }
422
673 for (int y = 0; y < height; y++) 423 for (int y = 0; y < height; y++)
674 { 424 {
675 for (int x = 0; x < width; x++) 425 for (int x = 0; x < width; x++)
676 { 426 {
677 unsigned char *pixel = row + x * channels; 427 unsigned char *pixel = row + x * channels;
678 uint32_t value; 428 uint32_t value;
429 unsigned char r, g, b, a;
679 430
431 if (channels == 4)
432 {
433 a = pixel[3];
434 r = (pixel[0] * a + c.r * (0xff - a)) / 0xff;
435 g = (pixel[1] * a + c.g * (0xff - a)) / 0xff;
436 b = (pixel[2] * a + c.b * (0xff - a)) / 0xff;
437 }
438 else
439 {
440 a = 0xff;
441 r = pixel[0];
442 g = pixel[1];
443 b = pixel[2];
444 }
445
680 value = ((pixel[0] >> (8 - width_r)) << sh_r) 446 value = ((r >> (8 - width_r)) << sh_r)
681 | ((pixel[1] >> (8 - width_g)) << sh_g) 447 | ((g >> (8 - width_g)) << sh_g)
682 | ((pixel[2] >> (8 - width_b)) << sh_b); 448 | ((b >> (8 - width_b)) << sh_b)
449 | ((a >> (8 - width_a)) << sh_a);
683 450
684 if (bytes_per_pixel == 4) 451 if (bytes_per_pixel == 4)
685 ((uint32_t *)line)[x] = value; 452 ((uint32_t *)line)[x] = value;
686 else 453 else
687 ((uint16_t *)line)[x] = value; 454 ((uint16_t *)line)[x] = value;
… …
695 XDestroyImage (ximage); 462 XDestroyImage (ximage);
696 return true; 463 return true;
697} 464}
698 465
699bool 466bool
700rxvt_term::render_image (unsigned long tr_flags) 467rxvt_term::render_image (bool transparent)
701{ 468{
702 if (!pixbuf) 469 if (!pixbuf)
703 return false; 470 return false;
704 471
705 if (tr_flags 472 if (transparent
706 && !(bg_flags & BG_HAS_RENDER)) 473 && !(bg_flags & BG_HAS_RENDER))
707 return false; 474 return false;
708 475
709 GdkPixbuf *result; 476 GdkPixbuf *result;
710 477
… …
750 Pixmap root_pmap; 517 Pixmap root_pmap;
751 518
752 image_width = gdk_pixbuf_get_width (result); 519 image_width = gdk_pixbuf_get_width (result);
753 image_height = gdk_pixbuf_get_height (result); 520 image_height = gdk_pixbuf_get_height (result);
754 521
755 if (tr_flags) 522 if (transparent)
756 { 523 {
757 root_pmap = bg_pixmap; 524 root_pmap = bg_pixmap;
758 bg_pixmap = None; 525 bg_pixmap = None;
759 } 526 }
760 else 527 else
… …
818 dst_x, dst_y, 585 dst_x, dst_y,
819 dst_width, dst_height); 586 dst_width, dst_height);
820 } 587 }
821 588
822#if XRENDER 589#if XRENDER
823 if (tr_flags) 590 if (transparent)
824 { 591 {
825 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 592 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
826 593
827 Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0); 594 Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
828 595
… …
852 } 619 }
853 620
854 if (result != pixbuf) 621 if (result != pixbuf)
855 g_object_unref (result); 622 g_object_unref (result);
856 623
857 if (tr_flags) 624 if (transparent)
858 XFreePixmap (dpy, root_pmap); 625 XFreePixmap (dpy, root_pmap);
859 626
860 return ret; 627 return ret;
861} 628}
862# endif /* HAVE_PIXBUF */ 629# endif /* HAVE_PIXBUF */
… …
877 memcpy (f, file, len); 644 memcpy (f, file, len);
878 f[len] = '\0'; 645 f[len] = '\0';
879 file = f; 646 file = f;
880 } 647 }
881 648
882# ifdef HAVE_AFTERIMAGE
883 if (!asimman)
884 asimman = create_generic_imageman (rs[Rs_path]);
885 ASImage *image = get_asimage (asimman, file, 0xFFFFFFFF, 100);
886 if (image)
887 {
888 if (original_asim)
889 safe_asimage_destroy (original_asim);
890 original_asim = image;
891 bg_flags |= BG_IS_FROM_FILE | BG_CLIENT_RENDER;
892 ret = true;
893 }
894# endif
895
896# ifdef HAVE_PIXBUF 649# ifdef HAVE_PIXBUF
897 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL); 650 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
898 if (image) 651 if (image)
899 { 652 {
900 if (pixbuf) 653 if (pixbuf)
… …
957 { 710 {
958 changed = true; 711 changed = true;
959 v_blurRadius = vr; 712 v_blurRadius = vr;
960 } 713 }
961 714
962 if (h_blurRadius == 0 || v_blurRadius == 0) 715 if (h_blurRadius && v_blurRadius)
716 bg_flags |= BG_NEEDS_BLUR;
717 else
963 bg_flags &= ~BG_NEEDS_BLUR; 718 bg_flags &= ~BG_NEEDS_BLUR;
964 else
965 bg_flags |= BG_NEEDS_BLUR;
966 719
967 return changed; 720 return changed;
968} 721}
969 722
970void 723void
971rxvt_term::set_tint_shade_flags () 724rxvt_term::set_tint_shade_flags ()
972{ 725{
726 if (shade != 100 || (bg_flags & BG_TINT_SET))
727 bg_flags |= BG_NEEDS_TINT;
728 else
729 bg_flags &= ~BG_NEEDS_TINT;
730}
731
732bool
733rxvt_term::bg_set_tint (rxvt_color &new_tint)
734{
735 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
736 {
737 tint = new_tint;
738 bg_flags |= BG_TINT_SET;
739
973 rgba c; 740 rgba c;
974 bool has_shade = shade != 100;
975
976 bg_flags &= ~BG_TINT_FLAGS;
977
978 if (bg_flags & BG_TINT_SET)
979 {
980 tint.get (c); 741 tint.get (c);
981 if (!has_shade
982 && (c.r <= 0x00ff || c.r >= 0xff00) 742 if ((c.r <= 0x00ff || c.r >= 0xff00)
983 && (c.g <= 0x00ff || c.g >= 0xff00) 743 && (c.g <= 0x00ff || c.g >= 0xff00)
984 && (c.b <= 0x00ff || c.b >= 0xff00)) 744 && (c.b <= 0x00ff || c.b >= 0xff00))
985 bg_flags |= BG_TINT_BITAND; 745 bg_flags |= BG_TINT_BITAND;
986 } 746 else
987
988 if (has_shade || (bg_flags & BG_TINT_SET))
989 bg_flags |= BG_NEEDS_TINT;
990}
991
992bool
993rxvt_term::bg_set_tint (rxvt_color &new_tint)
994{
995 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
996 {
997 tint = new_tint;
998 bg_flags |= BG_TINT_SET; 747 bg_flags &= ~BG_TINT_BITAND;
748
999 set_tint_shade_flags (); 749 set_tint_shade_flags ();
1000 return true; 750 return true;
1001 } 751 }
1002 752
1003 return false; 753 return false;
… …
1044 params[i+2] = XDoubleToFixed (kernel[i] / sum); 794 params[i+2] = XDoubleToFixed (kernel[i] / sum);
1045} 795}
1046#endif 796#endif
1047 797
1048bool 798bool
1049rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 799rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height, int depth)
1050{ 800{
1051 bool ret = false; 801 bool ret = false;
1052#if XRENDER 802#if XRENDER
1053 if (!(bg_flags & BG_HAS_RENDER_CONV)) 803 if (!(bg_flags & BG_HAS_RENDER_CONV))
1054 return false; 804 return false;
1055 805
1056 int size = max (h_blurRadius, v_blurRadius) * 2 + 1; 806 int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1057 double *kernel = (double *)malloc (size * sizeof (double)); 807 double *kernel = (double *)malloc (size * sizeof (double));
1058 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 808 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1059 809
810 XRenderPictureAttributes pa;
1060 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 811 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1061 812
813 pa.repeat = RepeatPad;
1062 Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, 0); 814 Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
815 Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1063 Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, 0); 816 Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
817 XFreePixmap (dpy, tmp);
1064 818
1065 if (kernel && params) 819 if (kernel && params)
1066 { 820 {
1067 size = h_blurRadius * 2 + 1; 821 size = h_blurRadius * 2 + 1;
1068 get_gaussian_kernel (h_blurRadius, size, kernel, params); 822 get_gaussian_kernel (h_blurRadius, size, kernel, params);
… …
1076 0, 0, 830 0, 0,
1077 0, 0, 831 0, 0,
1078 0, 0, 832 0, 0,
1079 width, height); 833 width, height);
1080 834
835 ::swap (src, dst);
836
1081 size = v_blurRadius * 2 + 1; 837 size = v_blurRadius * 2 + 1;
1082 get_gaussian_kernel (v_blurRadius, size, kernel, params); 838 get_gaussian_kernel (v_blurRadius, size, kernel, params);
1083 ::swap (params[0], params[1]); 839 ::swap (params[0], params[1]);
1084 840
1085 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 841 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
… …
1107bool 863bool
1108rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 864rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1109{ 865{
1110 bool ret = false; 866 bool ret = false;
1111 867
1112 if (bg_flags & BG_TINT_BITAND) 868 if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1113 { 869 {
1114 XGCValues gcv; 870 XGCValues gcv;
1115 GC gc; 871 GC gc;
1116 872
1117 /* In this case we can tint image server-side getting significant 873 /* In this case we can tint image server-side getting significant
… …
1198/* 954/*
1199 * Builds a pixmap of the same size as the terminal window that contains 955 * Builds a pixmap of the same size as the terminal window that contains
1200 * the tiled portion of the root pixmap that is supposed to be covered by 956 * the tiled portion of the root pixmap that is supposed to be covered by
1201 * our window. 957 * our window.
1202 */ 958 */
1203unsigned long 959bool
1204rxvt_term::make_transparency_pixmap () 960rxvt_term::make_transparency_pixmap ()
1205{ 961{
1206 unsigned long result = 0; 962 bool ret = false;
1207 963
1208 /* root dimensions may change from call to call - but Display structure should 964 /* root dimensions may change from call to call - but Display structure should
1209 * be always up-to-date, so let's use it : 965 * be always up-to-date, so let's use it :
1210 */ 966 */
1211 int screen = display->screen; 967 int screen = display->screen;
… …
1292 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); 1048 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1293 1049
1294 if (gc) 1050 if (gc)
1295 { 1051 {
1296 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height); 1052 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1297 result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS); 1053 ret = true;
1054 unsigned long tr_flags = bg_flags & BG_EFFECTS_FLAGS;
1298 1055
1299 if (!(bg_flags & BG_CLIENT_RENDER)) 1056 if (!(bg_flags & BG_CLIENT_RENDER))
1300 { 1057 {
1301 if (bg_flags & BG_NEEDS_BLUR) 1058 if (bg_flags & BG_NEEDS_BLUR)
1302 { 1059 {
1303 if (blur_pixmap (bg_pixmap, visual, window_width, window_height)) 1060 if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth))
1304 result &= ~BG_NEEDS_BLUR; 1061 tr_flags &= ~BG_NEEDS_BLUR;
1305 } 1062 }
1306 if (bg_flags & BG_NEEDS_TINT) 1063 if (bg_flags & BG_NEEDS_TINT)
1307 { 1064 {
1308 if (tint_pixmap (bg_pixmap, visual, window_width, window_height)) 1065 if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1309 result &= ~BG_NEEDS_TINT; 1066 tr_flags &= ~BG_NEEDS_TINT;
1310 } 1067 }
1311# ifndef HAVE_AFTERIMAGE
1312 if (result & BG_NEEDS_TINT) 1068 if (tr_flags & BG_NEEDS_TINT)
1313 { 1069 {
1314 XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap); 1070 XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1315 if (ximage) 1071 if (ximage)
1316 { 1072 {
1317 /* our own client-side tinting */ 1073 /* our own client-side tinting */
… …
1319 1075
1320 XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height); 1076 XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
1321 XDestroyImage (ximage); 1077 XDestroyImage (ximage);
1322 } 1078 }
1323 } 1079 }
1324# endif
1325 } /* server side rendering completed */ 1080 } /* server side rendering completed */
1326 1081
1327 XFreeGC (dpy, gc); 1082 XFreeGC (dpy, gc);
1328 } 1083 }
1329 1084
1330 if (recoded_root_pmap != root_pixmap) 1085 if (recoded_root_pmap != root_pixmap)
1331 XFreePixmap (dpy, recoded_root_pmap); 1086 XFreePixmap (dpy, recoded_root_pmap);
1332 1087
1333 return result; 1088 return ret;
1334} 1089}
1335 1090
1336void 1091void
1337rxvt_term::bg_set_root_pixmap () 1092rxvt_term::bg_set_root_pixmap ()
1338{ 1093{
… …
1345# endif /* ENABLE_TRANSPARENCY */ 1100# endif /* ENABLE_TRANSPARENCY */
1346 1101
1347bool 1102bool
1348rxvt_term::bg_render () 1103rxvt_term::bg_render ()
1349{ 1104{
1350 unsigned long tr_flags = 0; 1105 bool transparent = false;
1351 1106
1352 bg_invalidate (); 1107 bg_invalidate ();
1353# ifdef ENABLE_TRANSPARENCY 1108# ifdef ENABLE_TRANSPARENCY
1354 if (bg_flags & BG_IS_TRANSPARENT) 1109 if (bg_flags & BG_IS_TRANSPARENT)
1355 { 1110 {
1356 /* we need to re-generate transparency pixmap in that case ! */ 1111 /* we need to re-generate transparency pixmap in that case ! */
1357 tr_flags = make_transparency_pixmap (); 1112 transparent = make_transparency_pixmap ();
1358 if (tr_flags == 0) 1113 if (transparent)
1359 return false;
1360 bg_flags |= BG_IS_VALID; 1114 bg_flags |= BG_IS_VALID;
1361 } 1115 }
1362# endif 1116# endif
1363 1117
1364# ifdef BG_IMAGE_FROM_FILE 1118# ifdef BG_IMAGE_FROM_FILE
1365 if ((bg_flags & BG_IS_FROM_FILE) 1119 if (bg_flags & BG_IS_FROM_FILE)
1366 || (tr_flags & BG_EFFECTS_FLAGS))
1367 { 1120 {
1368 if (render_image (tr_flags)) 1121 if (render_image (transparent))
1369 bg_flags |= BG_IS_VALID; 1122 bg_flags |= BG_IS_VALID;
1370 } 1123 }
1371# endif 1124# endif
1372 1125
1373 if (!(bg_flags & BG_IS_VALID)) 1126 if (!(bg_flags & BG_IS_VALID))
… …
1411#endif 1164#endif
1412} 1165}
1413 1166
1414#endif /* HAVE_BG_PIXMAP */ 1167#endif /* HAVE_BG_PIXMAP */
1415 1168
1416#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) 1169#ifdef ENABLE_TRANSPARENCY
1417/* based on code from aterm-0.4.2 */ 1170/* based on code from aterm-0.4.2 */
1418 1171
1419static inline void 1172static inline void
1420fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high) 1173fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
1421{ 1174{
… …
1534 /* apply table to input image (replacing colors by newly calculated ones) */ 1287 /* apply table to input image (replacing colors by newly calculated ones) */
1535 if (ximage->bits_per_pixel == 32 1288 if (ximage->bits_per_pixel == 32
1536 && (ximage->depth == 24 || ximage->depth == 32) 1289 && (ximage->depth == 24 || ximage->depth == 32)
1537 && ximage->byte_order == host_byte_order) 1290 && ximage->byte_order == host_byte_order)
1538 { 1291 {
1539 uint32_t *p1, *pf, *p, *pl; 1292 char *line = ximage->data;
1540 p1 = (uint32_t *) ximage->data;
1541 pf = (uint32_t *) (ximage->data + ximage->height * ximage->bytes_per_line);
1542 1293
1543 while (p1 < pf) 1294 for (int y = 0; y < ximage->height; y++)
1544 { 1295 {
1545 p = p1; 1296 uint32_t *p = (uint32_t *)line;
1546 pl = p1 + ximage->width; 1297 for (int x = 0; x < ximage->width; x++)
1547 for (; p < pl; p++)
1548 { 1298 {
1549 *p = lookup_r[(*p & 0xff0000) >> 16] | 1299 *p = lookup_r[(*p & 0xff0000) >> 16] |
1550 lookup_g[(*p & 0x00ff00) >> 8] | 1300 lookup_g[(*p & 0x00ff00) >> 8] |
1551 lookup_b[(*p & 0x0000ff)] | 1301 lookup_b[(*p & 0x0000ff)] |
1552 (*p & 0xff000000); 1302 (*p & 0xff000000);
1553 } 1303 p++;
1554 p1 = (uint32_t *) ((char *) p1 + ximage->bytes_per_line); 1304 }
1305 line += ximage->bytes_per_line;
1555 } 1306 }
1556 } 1307 }
1557 else 1308 else
1558 { 1309 {
1559 for (int y = 0; y < ximage->height; y++) 1310 for (int y = 0; y < ximage->height; y++)
… …
1567 } 1318 }
1568 } 1319 }
1569 1320
1570 free (lookup); 1321 free (lookup);
1571} 1322}
1572#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */ 1323#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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