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.198 by sf-exg, Wed Jan 11 13:51:07 2012 UTC vs.
Revision 1.212 by sf-exg, Sun May 13 15:50:18 2012 UTC

… …
3 *----------------------------------------------------------------------* 3 *----------------------------------------------------------------------*
4 * 4 *
5 * All portions of code are copyright by their respective author/s. 5 * All portions of code are copyright by their respective author/s.
6 * Copyright (c) 2005-2008 Marc Lehmann <schmorp@schmorp.de> 6 * Copyright (c) 2005-2008 Marc Lehmann <schmorp@schmorp.de>
7 * Copyright (c) 2007 Sasha Vasko <sasha@aftercode.net> 7 * Copyright (c) 2007 Sasha Vasko <sasha@aftercode.net>
8 * Copyright (c) 2010 Emanuele Giaquinta <e.giaquinta@glauco.it> 8 * Copyright (c) 2010-2012 Emanuele Giaquinta <e.giaquinta@glauco.it>
9 * 9 *
10 * This program is free software; you can redistribute it and/or modify 10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by 11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or 12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version. 13 * (at your option) any later version.
… …
20 * You should have received a copy of the GNU General Public License 20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software 21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 *---------------------------------------------------------------------*/ 23 *---------------------------------------------------------------------*/
24 24
25#include <cmath> 25#include <math.h>
26#include "../config.h" /* NECESSARY */ 26#include "../config.h" /* NECESSARY */
27#include "rxvt.h" /* NECESSARY */ 27#include "rxvt.h" /* NECESSARY */
28 28
29#if XRENDER 29#if XRENDER
30# include <X11/extensions/Xrender.h> 30# include <X11/extensions/Xrender.h>
… …
58# endif 58# endif
59 59
60void 60void
61rxvt_term::bg_destroy () 61rxvt_term::bg_destroy ()
62{ 62{
63#ifdef HAVE_AFTERIMAGE
64 if (original_asim)
65 safe_asimage_destroy (original_asim);
66 if (asv)
67 destroy_asvisual (asv, 0);
68 if (asimman)
69 destroy_image_manager (asimman, 0);
70#endif
71
72#ifdef HAVE_PIXBUF 63#ifdef HAVE_PIXBUF
73 if (pixbuf) 64 if (pixbuf)
74 g_object_unref (pixbuf); 65 g_object_unref (pixbuf);
75#endif 66#endif
76 67
… …
132 123
133# ifdef BG_IMAGE_FROM_FILE 124# ifdef BG_IMAGE_FROM_FILE
134static inline int 125static inline int
135make_align_position (int align, int window_size, int image_size) 126make_align_position (int align, int window_size, int image_size)
136{ 127{
137 int diff = window_size - image_size;
138 int smaller = min (image_size, window_size);
139
140 if (align >= 0 && align <= 100) 128 if (align >= 0 && align <= 100)
141 return diff * align / 100; 129 return lerp (0, window_size - image_size, align);
142 else if (align > 100 && align <= 200) 130 else if (align > 100)
143 return (align - 100) * smaller / 100 + window_size - smaller; 131 return lerp (window_size - image_size, window_size, align - 100);
144 else if (align >= -100 && align < 0) 132 else
145 return (align + 100) * smaller / 100 - image_size; 133 return lerp (-image_size, 0, align + 100);
146 return 0;
147} 134}
148 135
149static inline int 136static inline int
150make_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)
151{ 138{
… …
343 { 330 {
344 x = make_align_position (h_align, target_width, w); 331 x = make_align_position (h_align, target_width, w);
345 y = make_align_position (v_align, target_height, h); 332 y = make_align_position (v_align, target_height, h);
346 } 333 }
347 334
348 bg_flags &= ~BG_IS_SIZE_SENSITIVE;
349 if (!(bg_flags & BG_TILE) 335 if (!(bg_flags & BG_TILE)
350 || h_scale || v_scale 336 || h_scale || v_scale
351 || (!(bg_flags & BG_ROOT_ALIGN) && (h_align || v_align)) 337 || (!(bg_flags & BG_ROOT_ALIGN) && (h_align || v_align))
352 || w > target_width || h > target_height) 338 || image_width > target_width || image_height > target_height)
353 bg_flags |= BG_IS_SIZE_SENSITIVE; 339 bg_flags |= BG_IS_SIZE_SENSITIVE;
354}
355
356# ifdef HAVE_AFTERIMAGE
357bool
358rxvt_term::render_image (unsigned long tr_flags)
359{
360 init_asv ();
361
362 ASImage *background = NULL;
363 ARGB32 background_tint = TINT_LEAVE_SAME;
364
365# ifdef ENABLE_TRANSPARENCY
366 if (tr_flags)
367 background = pixmap2ximage (asv, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, 100);
368
369 if (tr_flags & BG_NEEDS_TINT)
370 {
371 ShadingInfo as_shade;
372 as_shade.shading = shade;
373
374 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
375 if (bg_flags & BG_TINT_SET)
376 tint.get (c);
377 as_shade.tintColor.red = c.r;
378 as_shade.tintColor.green = c.g;
379 as_shade.tintColor.blue = c.b;
380
381 background_tint = shading2tint32 (&as_shade);
382 }
383
384 if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)
385 {
386 ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,
387 ASA_XImage,
388 100, ASIMAGE_QUALITY_DEFAULT);
389 if (tmp)
390 {
391 destroy_asimage (&background);
392 background = tmp;
393 }
394 }
395# endif
396
397 ASImage *result = 0;
398
399 int target_width = szHint.width;
400 int target_height = szHint.height;
401 int new_pmap_width = target_width;
402 int new_pmap_height = target_height;
403
404 int x = 0;
405 int y = 0;
406 int w = 0;
407 int h = 0;
408
409 if (original_asim)
410 get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
411
412 if (!original_asim
413 || (!(bg_flags & BG_ROOT_ALIGN)
414 && (x >= target_width
415 || y >= target_height
416 || x + w <= 0
417 || y + h <= 0)))
418 {
419 if (background)
420 {
421 new_pmap_width = background->width;
422 new_pmap_height = background->height;
423 result = background;
424
425 if (background_tint != TINT_LEAVE_SAME)
426 {
427 ASImage *tmp = tile_asimage (asv, background, 0, 0,
428 target_width, target_height, background_tint,
429 ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
430 if (tmp)
431 result = tmp;
432 }
433 }
434 else
435 new_pmap_width = new_pmap_height = 0;
436 }
437 else 340 else
438 { 341 bg_flags &= ~BG_IS_SIZE_SENSITIVE;
439 result = original_asim;
440
441 if (w != original_asim->width
442 || h != original_asim->height)
443 {
444 result = scale_asimage (asv, original_asim,
445 w, h,
446 ASA_XImage,
447 100, ASIMAGE_QUALITY_DEFAULT);
448 }
449
450 if (background == NULL)
451 {
452 if (bg_flags & BG_TILE)
453 {
454 /* if tiling - pixmap has to be sized exactly as the image,
455 but there is no need to make it bigger than the window! */
456 new_pmap_width = min (result->width, target_width);
457 new_pmap_height = min (result->height, target_height);
458
459 /* we also need to tile our image in both directions */
460 ASImage *tmp = tile_asimage (asv, result,
461 (int)result->width - x,
462 (int)result->height - y,
463 new_pmap_width,
464 new_pmap_height,
465 TINT_LEAVE_SAME, ASA_XImage,
466 100, ASIMAGE_QUALITY_DEFAULT);
467 if (tmp)
468 {
469 if (result != original_asim)
470 destroy_asimage (&result);
471
472 result = tmp;
473 }
474 }
475 }
476 else
477 {
478 /* if blending background and image - pixmap has to be sized same as target window */
479 ASImageLayer *layers = create_image_layers (2);
480
481 layers[0].im = background;
482 layers[0].clip_width = target_width;
483 layers[0].clip_height = target_height;
484 layers[0].tint = background_tint;
485 layers[1].im = result;
486
487 if (bg_flags & BG_TILE)
488 {
489 /* tile horizontally */
490 while (x > 0) x -= (int)result->width;
491 layers[1].dst_x = x;
492 layers[1].clip_width = result->width+target_width;
493 }
494 else
495 {
496 /* clip horizontally */
497 layers[1].dst_x = x;
498 layers[1].clip_width = result->width;
499 }
500
501 if (bg_flags & BG_TILE)
502 {
503 while (y > 0) y -= (int)result->height;
504 layers[1].dst_y = y;
505 layers[1].clip_height = result->height + target_height;
506 }
507 else
508 {
509 layers[1].dst_y = y;
510 layers[1].clip_height = result->height;
511 }
512
513 if (rs[Rs_blendtype])
514 {
515 layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
516 if (layers[1].merge_scanlines == NULL)
517 layers[1].merge_scanlines = alphablend_scanlines;
518 }
519
520 ASImage *tmp = merge_layers (asv, layers, 2, target_width, target_height,
521 ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
522
523 if (tmp)
524 {
525 if (result != original_asim)
526 destroy_asimage (&result);
527
528 result = tmp;
529 }
530
531 free (layers);
532 }
533 }
534
535 bool ret = false;
536
537 if (result)
538 {
539 XGCValues gcv;
540 GC gc;
541
542 /* create Pixmap */
543 if (bg_pixmap == None
544 || bg_pmap_width != new_pmap_width
545 || bg_pmap_height != new_pmap_height)
546 {
547 if (bg_pixmap)
548 XFreePixmap (dpy, bg_pixmap);
549 bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
550 bg_pmap_width = new_pmap_width;
551 bg_pmap_height = new_pmap_height;
552 }
553 /* fill with background color (if result's not completely overlapping it) */
554 gcv.foreground = pix_colors[Color_bg];
555 gc = XCreateGC (dpy, vt, GCForeground, &gcv);
556
557 int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
558 int dst_width = result->width, dst_height = result->height;
559 if (background == NULL)
560 {
561 if (!(bg_flags & BG_TILE))
562 {
563 src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );
564 src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
565 }
566
567 if (dst_x > 0 || dst_y > 0
568 || dst_x + dst_width < new_pmap_width
569 || dst_y + dst_height < new_pmap_height)
570 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
571 }
572
573 /* put result on pixmap */
574 if (dst_x < new_pmap_width && dst_y < new_pmap_height)
575 asimage2drawable (asv, bg_pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);
576
577 if (result != background && result != original_asim)
578 destroy_asimage (&result);
579
580 XFreeGC (dpy, gc);
581
582 ret = true;
583 }
584
585 if (background)
586 destroy_asimage (&background);
587
588 return ret;
589} 342}
590# endif /* HAVE_AFTERIMAGE */
591 343
592# ifdef HAVE_PIXBUF 344# ifdef HAVE_PIXBUF
593bool 345bool
594rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc, 346rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
595 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,
596 unsigned int width, unsigned int height) 348 unsigned int width, unsigned int height)
597{ 349{
598 XImage *ximage; 350 XImage *ximage;
599 char *data, *line; 351 char *line;
600 int bytes_per_pixel;
601 int width_r, width_g, width_b; 352 int width_r, width_g, width_b, width_a;
602 int sh_r, sh_g, sh_b; 353 int sh_r, sh_g, sh_b, sh_a;
354 uint32_t alpha_mask;
603 int rowstride; 355 int rowstride;
604 int channels; 356 int channels;
605 unsigned char *row; 357 unsigned char *row;
606 358
607 if (visual->c_class != TrueColor) 359 if (visual->c_class != TrueColor)
608 return false; 360 return false;
609 361
610 if (depth == 24 || depth == 32) 362#if XRENDER
611 bytes_per_pixel = 4; 363 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
612 else if (depth == 15 || depth == 16) 364 if (format)
613 bytes_per_pixel = 2; 365 alpha_mask = (uint32_t)format->direct.alphaMask << format->direct.alpha;
614 else 366 else
615 return false; 367#endif
368 alpha_mask = 0;
616 369
617 width_r = ecb_popcount32 (visual->red_mask); 370 width_r = ecb_popcount32 (visual->red_mask);
618 width_g = ecb_popcount32 (visual->green_mask); 371 width_g = ecb_popcount32 (visual->green_mask);
619 width_b = ecb_popcount32 (visual->blue_mask); 372 width_b = ecb_popcount32 (visual->blue_mask);
373 width_a = ecb_popcount32 (alpha_mask);
620 374
621 if (width_r > 8 || width_g > 8 || width_b > 8) 375 if (width_r > 8 || width_g > 8 || width_b > 8 || width_a > 8)
622 return false; 376 return false;
623 377
624 sh_r = ecb_ctz32 (visual->red_mask); 378 sh_r = ecb_ctz32 (visual->red_mask);
625 sh_g = ecb_ctz32 (visual->green_mask); 379 sh_g = ecb_ctz32 (visual->green_mask);
626 sh_b = ecb_ctz32 (visual->blue_mask); 380 sh_b = ecb_ctz32 (visual->blue_mask);
381 sh_a = ecb_ctz32 (alpha_mask);
627 382
628 if (width > INT_MAX / height / bytes_per_pixel) 383 if (width > 32767 || height > 32767)
629 return false; 384 return false;
630 385
631 data = (char *)malloc (width * height * bytes_per_pixel); 386 ximage = XCreateImage (dpy, visual, depth, ZPixmap, 0, 0,
632 if (!data) 387 width, height, 32, 0);
388 if (!ximage)
633 return false; 389 return false;
634 390
635 ximage = XCreateImage (dpy, visual, depth, ZPixmap, 0, data, 391 if (height > INT_MAX / ximage->bytes_per_line
636 width, height, bytes_per_pixel * 8, 0); 392 || !(ximage->data = (char *)malloc (height * ximage->bytes_per_line)))
637 if (!ximage)
638 { 393 {
639 free (data); 394 XDestroyImage (ximage);
640 return false; 395 return false;
641 } 396 }
642 397
643 ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst; 398 ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
644 399
645 rowstride = gdk_pixbuf_get_rowstride (pixbuf); 400 rowstride = gdk_pixbuf_get_rowstride (pixbuf);
646 channels = gdk_pixbuf_get_n_channels (pixbuf); 401 channels = gdk_pixbuf_get_n_channels (pixbuf);
647 row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels; 402 row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels;
648 line = data; 403 line = ximage->data;
404
405 rgba c (0, 0, 0);
406
407 if (channels == 4 && alpha_mask == 0)
408 {
409 pix_colors[Color_bg].get (c);
410 c.r >>= 8;
411 c.g >>= 8;
412 c.b >>= 8;
413 }
649 414
650 for (int y = 0; y < height; y++) 415 for (int y = 0; y < height; y++)
651 { 416 {
652 for (int x = 0; x < width; x++) 417 for (int x = 0; x < width; x++)
653 { 418 {
654 unsigned char *pixel = row + x * channels; 419 unsigned char *pixel = row + x * channels;
655 uint32_t value; 420 uint32_t value;
421 unsigned char r, g, b, a;
656 422
423 if (channels == 4)
424 {
425 a = pixel[3];
426 r = (pixel[0] * a + c.r * (0xff - a)) / 0xff;
427 g = (pixel[1] * a + c.g * (0xff - a)) / 0xff;
428 b = (pixel[2] * a + c.b * (0xff - a)) / 0xff;
429 }
430 else
431 {
432 a = 0xff;
433 r = pixel[0];
434 g = pixel[1];
435 b = pixel[2];
436 }
437
657 value = ((pixel[0] >> (8 - width_r)) << sh_r) 438 value = ((r >> (8 - width_r)) << sh_r)
658 | ((pixel[1] >> (8 - width_g)) << sh_g) 439 | ((g >> (8 - width_g)) << sh_g)
659 | ((pixel[2] >> (8 - width_b)) << sh_b); 440 | ((b >> (8 - width_b)) << sh_b)
441 | ((a >> (8 - width_a)) << sh_a);
660 442
661 if (bytes_per_pixel == 4) 443 if (ximage->bits_per_pixel == 32)
662 ((uint32_t *)line)[x] = value; 444 ((uint32_t *)line)[x] = value;
663 else 445 else
664 ((uint16_t *)line)[x] = value; 446 XPutPixel (ximage, x, y, value);
665 } 447 }
666 448
667 row += rowstride; 449 row += rowstride;
668 line += ximage->bytes_per_line; 450 line += ximage->bytes_per_line;
669 } 451 }
… …
672 XDestroyImage (ximage); 454 XDestroyImage (ximage);
673 return true; 455 return true;
674} 456}
675 457
676bool 458bool
677rxvt_term::render_image (unsigned long tr_flags) 459rxvt_term::render_image (bool transparent)
678{ 460{
679 if (!pixbuf) 461 if (!pixbuf)
680 return false; 462 return false;
681 463
682 if (tr_flags 464 if (transparent
683 && !(bg_flags & BG_HAS_RENDER)) 465 && !(bg_flags & BG_HAS_RENDER))
684 return false; 466 return false;
685 467
686 GdkPixbuf *result; 468 GdkPixbuf *result;
687 469
… …
727 Pixmap root_pmap; 509 Pixmap root_pmap;
728 510
729 image_width = gdk_pixbuf_get_width (result); 511 image_width = gdk_pixbuf_get_width (result);
730 image_height = gdk_pixbuf_get_height (result); 512 image_height = gdk_pixbuf_get_height (result);
731 513
732 if (tr_flags) 514 if (transparent)
733 { 515 {
734 root_pmap = bg_pixmap; 516 root_pmap = bg_pixmap;
735 bg_pixmap = None; 517 bg_pixmap = None;
736 } 518 }
737 else 519 else
… …
795 dst_x, dst_y, 577 dst_x, dst_y,
796 dst_width, dst_height); 578 dst_width, dst_height);
797 } 579 }
798 580
799#if XRENDER 581#if XRENDER
800 if (tr_flags) 582 if (transparent)
801 { 583 {
802 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 584 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
803 585
804 Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0); 586 Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
805 587
… …
829 } 611 }
830 612
831 if (result != pixbuf) 613 if (result != pixbuf)
832 g_object_unref (result); 614 g_object_unref (result);
833 615
834 if (tr_flags) 616 if (transparent)
835 XFreePixmap (dpy, root_pmap); 617 XFreePixmap (dpy, root_pmap);
836 618
837 return ret; 619 return ret;
838} 620}
839# endif /* HAVE_PIXBUF */ 621# endif /* HAVE_PIXBUF */
… …
854 memcpy (f, file, len); 636 memcpy (f, file, len);
855 f[len] = '\0'; 637 f[len] = '\0';
856 file = f; 638 file = f;
857 } 639 }
858 640
859# ifdef HAVE_AFTERIMAGE
860 if (!asimman)
861 asimman = create_generic_imageman (rs[Rs_path]);
862 ASImage *image = get_asimage (asimman, file, 0xFFFFFFFF, 100);
863 if (image)
864 {
865 if (original_asim)
866 safe_asimage_destroy (original_asim);
867 original_asim = image;
868 bg_flags |= BG_IS_FROM_FILE | BG_CLIENT_RENDER;
869 ret = true;
870 }
871# endif
872
873# ifdef HAVE_PIXBUF 641# ifdef HAVE_PIXBUF
874 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL); 642 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
875 if (image) 643 if (image)
876 { 644 {
877 if (pixbuf) 645 if (pixbuf)
… …
895 663
896# endif /* BG_IMAGE_FROM_FILE */ 664# endif /* BG_IMAGE_FROM_FILE */
897 665
898# ifdef ENABLE_TRANSPARENCY 666# ifdef ENABLE_TRANSPARENCY
899bool 667bool
900rxvt_term::bg_set_transparent ()
901{
902 if (!(bg_flags & BG_IS_TRANSPARENT))
903 {
904 bg_flags |= BG_IS_TRANSPARENT;
905 return true;
906 }
907
908 return false;
909}
910
911bool
912rxvt_term::bg_set_blur (const char *geom) 668rxvt_term::bg_set_blur (const char *geom)
913{ 669{
914 bool changed = false; 670 bool changed = false;
915 unsigned int hr, vr; 671 unsigned int hr, vr;
916 int junk; 672 int junk;
… …
934 { 690 {
935 changed = true; 691 changed = true;
936 v_blurRadius = vr; 692 v_blurRadius = vr;
937 } 693 }
938 694
939 if (h_blurRadius == 0 || v_blurRadius == 0)
940 bg_flags &= ~BG_NEEDS_BLUR;
941 else
942 bg_flags |= BG_NEEDS_BLUR;
943
944 return changed; 695 return changed;
945} 696}
946 697
947void 698bool
948rxvt_term::set_tint_shade_flags () 699rxvt_term::bg_set_tint (rxvt_color &new_tint)
949{ 700{
701 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
702 {
703 tint = new_tint;
704 bg_flags |= BG_TINT_SET;
705
950 rgba c; 706 rgba c;
951 bool has_shade = shade != 100;
952
953 bg_flags &= ~BG_TINT_FLAGS;
954
955 if (bg_flags & BG_TINT_SET)
956 {
957 tint.get (c); 707 tint.get (c);
958 if (!has_shade
959 && (c.r <= 0x00ff || c.r >= 0xff00) 708 if ((c.r <= 0x00ff || c.r >= 0xff00)
960 && (c.g <= 0x00ff || c.g >= 0xff00) 709 && (c.g <= 0x00ff || c.g >= 0xff00)
961 && (c.b <= 0x00ff || c.b >= 0xff00)) 710 && (c.b <= 0x00ff || c.b >= 0xff00))
962 bg_flags |= BG_TINT_BITAND; 711 bg_flags |= BG_TINT_BITAND;
963 } 712 else
964
965 if (has_shade || (bg_flags & BG_TINT_SET))
966 bg_flags |= BG_NEEDS_TINT;
967}
968
969bool
970rxvt_term::bg_set_tint (rxvt_color &new_tint)
971{
972 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
973 {
974 tint = new_tint;
975 bg_flags |= BG_TINT_SET; 713 bg_flags &= ~BG_TINT_BITAND;
976 set_tint_shade_flags (); 714
977 return true; 715 return true;
978 } 716 }
979 717
980 return false; 718 return false;
981} 719}
… …
990 new_shade = 200 - (100 + new_shade); 728 new_shade = 200 - (100 + new_shade);
991 729
992 if (new_shade != shade) 730 if (new_shade != shade)
993 { 731 {
994 shade = new_shade; 732 shade = new_shade;
995 set_tint_shade_flags ();
996 return true; 733 return true;
997 } 734 }
998 735
999 return false; 736 return false;
1000} 737}
… …
1090bool 827bool
1091rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 828rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1092{ 829{
1093 bool ret = false; 830 bool ret = false;
1094 831
1095 if (bg_flags & BG_TINT_BITAND) 832 if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1096 { 833 {
1097 XGCValues gcv; 834 XGCValues gcv;
1098 GC gc; 835 GC gc;
1099 836
1100 /* In this case we can tint image server-side getting significant 837 /* In this case we can tint image server-side getting significant
… …
1181/* 918/*
1182 * Builds a pixmap of the same size as the terminal window that contains 919 * Builds a pixmap of the same size as the terminal window that contains
1183 * the tiled portion of the root pixmap that is supposed to be covered by 920 * the tiled portion of the root pixmap that is supposed to be covered by
1184 * our window. 921 * our window.
1185 */ 922 */
1186unsigned long 923bool
1187rxvt_term::make_transparency_pixmap () 924rxvt_term::make_transparency_pixmap ()
1188{ 925{
1189 unsigned long result = 0; 926 bool ret = false;
1190 927
1191 /* root dimensions may change from call to call - but Display structure should 928 /* root dimensions may change from call to call - but Display structure should
1192 * be always up-to-date, so let's use it : 929 * be always up-to-date, so let's use it :
1193 */ 930 */
1194 int screen = display->screen; 931 int screen = display->screen;
… …
1275 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); 1012 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1276 1013
1277 if (gc) 1014 if (gc)
1278 { 1015 {
1279 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height); 1016 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1280 result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS); 1017 ret = true;
1018 bool need_blur = h_blurRadius && v_blurRadius;
1019 bool need_tint = shade != 100 || (bg_flags & BG_TINT_SET);
1281 1020
1282 if (!(bg_flags & BG_CLIENT_RENDER)) 1021 if (!(bg_flags & BG_CLIENT_RENDER))
1283 { 1022 {
1284 if (bg_flags & BG_NEEDS_BLUR) 1023 if (need_blur)
1285 { 1024 {
1286 if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth)) 1025 if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth))
1287 result &= ~BG_NEEDS_BLUR; 1026 need_blur = false;
1288 } 1027 }
1289 if (bg_flags & BG_NEEDS_TINT) 1028 if (need_tint)
1290 { 1029 {
1291 if (tint_pixmap (bg_pixmap, visual, window_width, window_height)) 1030 if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1292 result &= ~BG_NEEDS_TINT; 1031 need_tint = false;
1293 } 1032 }
1294# ifndef HAVE_AFTERIMAGE 1033 if (need_tint)
1295 if (result & BG_NEEDS_TINT)
1296 { 1034 {
1297 XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap); 1035 XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1298 if (ximage) 1036 if (ximage)
1299 { 1037 {
1300 /* our own client-side tinting */ 1038 /* our own client-side tinting */
… …
1302 1040
1303 XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height); 1041 XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
1304 XDestroyImage (ximage); 1042 XDestroyImage (ximage);
1305 } 1043 }
1306 } 1044 }
1307# endif
1308 } /* server side rendering completed */ 1045 } /* server side rendering completed */
1309 1046
1310 XFreeGC (dpy, gc); 1047 XFreeGC (dpy, gc);
1311 } 1048 }
1312 1049
1313 if (recoded_root_pmap != root_pixmap) 1050 if (recoded_root_pmap != root_pixmap)
1314 XFreePixmap (dpy, recoded_root_pmap); 1051 XFreePixmap (dpy, recoded_root_pmap);
1315 1052
1316 return result; 1053 return ret;
1317} 1054}
1318 1055
1319void 1056void
1320rxvt_term::bg_set_root_pixmap () 1057rxvt_term::bg_set_root_pixmap ()
1321{ 1058{
… …
1328# endif /* ENABLE_TRANSPARENCY */ 1065# endif /* ENABLE_TRANSPARENCY */
1329 1066
1330bool 1067bool
1331rxvt_term::bg_render () 1068rxvt_term::bg_render ()
1332{ 1069{
1333 unsigned long tr_flags = 0; 1070 bool transparent = false;
1334 1071
1335 bg_invalidate (); 1072 bg_invalidate ();
1336# ifdef ENABLE_TRANSPARENCY 1073# ifdef ENABLE_TRANSPARENCY
1337 if (bg_flags & BG_IS_TRANSPARENT) 1074 if (bg_flags & BG_IS_TRANSPARENT)
1338 { 1075 {
1339 /* we need to re-generate transparency pixmap in that case ! */ 1076 /* we need to re-generate transparency pixmap in that case ! */
1340 tr_flags = make_transparency_pixmap (); 1077 transparent = make_transparency_pixmap ();
1341 if (tr_flags == 0) 1078 if (transparent)
1342 return false;
1343 bg_flags |= BG_IS_VALID; 1079 bg_flags |= BG_IS_VALID;
1344 } 1080 }
1345# endif 1081# endif
1346 1082
1347# ifdef BG_IMAGE_FROM_FILE 1083# ifdef BG_IMAGE_FROM_FILE
1348 if ((bg_flags & BG_IS_FROM_FILE) 1084 if (bg_flags & BG_IS_FROM_FILE)
1349 || (tr_flags & BG_EFFECTS_FLAGS))
1350 { 1085 {
1351 if (render_image (tr_flags)) 1086 if (render_image (transparent))
1352 bg_flags |= BG_IS_VALID; 1087 bg_flags |= BG_IS_VALID;
1353 } 1088 }
1354# endif 1089# endif
1355 1090
1356 if (!(bg_flags & BG_IS_VALID)) 1091 if (!(bg_flags & BG_IS_VALID))
… …
1394#endif 1129#endif
1395} 1130}
1396 1131
1397#endif /* HAVE_BG_PIXMAP */ 1132#endif /* HAVE_BG_PIXMAP */
1398 1133
1399#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) 1134#ifdef ENABLE_TRANSPARENCY
1400/* based on code from aterm-0.4.2 */ 1135/* based on code from aterm-0.4.2 */
1401 1136
1402static inline void 1137static inline void
1403fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high) 1138fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
1404{ 1139{
… …
1412} 1147}
1413 1148
1414void 1149void
1415rxvt_term::tint_ximage (Visual *visual, XImage *ximage) 1150rxvt_term::tint_ximage (Visual *visual, XImage *ximage)
1416{ 1151{
1152 unsigned int size_r, size_g, size_b;
1417 int sh_r, sh_g, sh_b; 1153 int sh_r, sh_g, sh_b;
1418 uint32_t mask_r, mask_g, mask_b; 1154 uint32_t mask_r, mask_g, mask_b;
1419 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b; 1155 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1420 unsigned short low; 1156 unsigned short low;
1421 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst; 1157 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
… …
1426 mask_r = visual->red_mask; 1162 mask_r = visual->red_mask;
1427 mask_g = visual->green_mask; 1163 mask_g = visual->green_mask;
1428 mask_b = visual->blue_mask; 1164 mask_b = visual->blue_mask;
1429 1165
1430 /* boring lookup table pre-initialization */ 1166 /* boring lookup table pre-initialization */
1431 switch (ximage->depth) 1167 sh_r = ecb_ctz32 (mask_r);
1432 { 1168 sh_g = ecb_ctz32 (mask_g);
1433 case 15: 1169 sh_b = ecb_ctz32 (mask_b);
1434 if ((mask_r != 0x7c00) || 1170
1435 (mask_g != 0x03e0) || 1171 size_r = mask_r >> sh_r;
1436 (mask_b != 0x001f)) 1172 size_g = mask_g >> sh_g;
1173 size_b = mask_b >> sh_b;
1174
1175 if (size_r++ > 255 || size_g++ > 255 || size_b++ > 255)
1437 return; 1176 return;
1438 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+32+32)); 1177
1178 lookup = (uint32_t *)malloc (sizeof (uint32_t) * (size_r + size_g + size_b));
1439 lookup_r = lookup; 1179 lookup_r = lookup;
1440 lookup_g = lookup+32; 1180 lookup_g = lookup + size_r;
1441 lookup_b = lookup+32+32; 1181 lookup_b = lookup + size_r + size_g;
1442 sh_r = 10;
1443 sh_g = 5;
1444 sh_b = 0;
1445 break;
1446 case 16:
1447 if ((mask_r != 0xf800) ||
1448 (mask_g != 0x07e0) ||
1449 (mask_b != 0x001f))
1450 return;
1451 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+64+32));
1452 lookup_r = lookup;
1453 lookup_g = lookup+32;
1454 lookup_b = lookup+32+64;
1455 sh_r = 11;
1456 sh_g = 5;
1457 sh_b = 0;
1458 break;
1459 case 24:
1460 if ((mask_r != 0xff0000) ||
1461 (mask_g != 0x00ff00) ||
1462 (mask_b != 0x0000ff))
1463 return;
1464 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(256+256+256));
1465 lookup_r = lookup;
1466 lookup_g = lookup+256;
1467 lookup_b = lookup+256+256;
1468 sh_r = 16;
1469 sh_g = 8;
1470 sh_b = 0;
1471 break;
1472 case 32:
1473 if ((mask_r != 0xff0000) ||
1474 (mask_g != 0x00ff00) ||
1475 (mask_b != 0x0000ff))
1476 return;
1477 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(256+256+256));
1478 lookup_r = lookup;
1479 lookup_g = lookup+256;
1480 lookup_b = lookup+256+256;
1481 sh_r = 16;
1482 sh_g = 8;
1483 sh_b = 0;
1484 break;
1485 default:
1486 return; /* we do not support this color depth */
1487 }
1488 1182
1489 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC); 1183 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1490 1184
1491 if (bg_flags & BG_TINT_SET) 1185 if (bg_flags & BG_TINT_SET)
1492 tint.get (c); 1186 tint.get (c);
… …
1514 fill_lut (lookup_g, mask_g, sh_g, low, c.g); 1208 fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1515 fill_lut (lookup_b, mask_b, sh_b, low, c.b); 1209 fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1516 1210
1517 /* apply table to input image (replacing colors by newly calculated ones) */ 1211 /* apply table to input image (replacing colors by newly calculated ones) */
1518 if (ximage->bits_per_pixel == 32 1212 if (ximage->bits_per_pixel == 32
1519 && (ximage->depth == 24 || ximage->depth == 32)
1520 && ximage->byte_order == host_byte_order) 1213 && ximage->byte_order == host_byte_order)
1521 { 1214 {
1522 uint32_t *p1, *pf, *p, *pl; 1215 char *line = ximage->data;
1523 p1 = (uint32_t *) ximage->data;
1524 pf = (uint32_t *) (ximage->data + ximage->height * ximage->bytes_per_line);
1525 1216
1526 while (p1 < pf) 1217 for (int y = 0; y < ximage->height; y++)
1527 {
1528 p = p1;
1529 pl = p1 + ximage->width;
1530 for (; p < pl; p++)
1531 { 1218 {
1532 *p = lookup_r[(*p & 0xff0000) >> 16] | 1219 uint32_t *p = (uint32_t *)line;
1533 lookup_g[(*p & 0x00ff00) >> 8] | 1220 for (int x = 0; x < ximage->width; x++)
1534 lookup_b[(*p & 0x0000ff)] |
1535 (*p & 0xff000000);
1536 } 1221 {
1537 p1 = (uint32_t *) ((char *) p1 + ximage->bytes_per_line); 1222 *p = lookup_r[(*p & mask_r) >> sh_r] |
1223 lookup_g[(*p & mask_g) >> sh_g] |
1224 lookup_b[(*p & mask_b) >> sh_b];
1225 p++;
1226 }
1227 line += ximage->bytes_per_line;
1538 } 1228 }
1539 } 1229 }
1540 else 1230 else
1541 { 1231 {
1542 for (int y = 0; y < ximage->height; y++) 1232 for (int y = 0; y < ximage->height; y++)
… …
1550 } 1240 }
1551 } 1241 }
1552 1242
1553 free (lookup); 1243 free (lookup);
1554} 1244}
1555#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */ 1245#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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