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.200 by sf-exg, Thu Jan 19 13:33:43 2012 UTC vs.
Revision 1.208 by sf-exg, Fri May 11 08:16:58 2012 UTC

… …
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 *data, *line;
600 int bytes_per_pixel; 352 int bytes_per_pixel;
601 int width_r, width_g, width_b; 353 int width_r, width_g, width_b, width_a;
602 int sh_r, sh_g, sh_b; 354 int sh_r, sh_g, sh_b, sh_a;
355 uint32_t alpha_mask;
603 int rowstride; 356 int rowstride;
604 int channels; 357 int channels;
605 unsigned char *row; 358 unsigned char *row;
606 359
607 if (visual->c_class != TrueColor) 360 if (visual->c_class != TrueColor)
608 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;
609 370
610 if (depth == 24 || depth == 32) 371 if (depth == 24 || depth == 32)
611 bytes_per_pixel = 4; 372 bytes_per_pixel = 4;
612 else if (depth == 15 || depth == 16) 373 else if (depth == 15 || depth == 16)
613 bytes_per_pixel = 2; 374 bytes_per_pixel = 2;
… …
615 return false; 376 return false;
616 377
617 width_r = ecb_popcount32 (visual->red_mask); 378 width_r = ecb_popcount32 (visual->red_mask);
618 width_g = ecb_popcount32 (visual->green_mask); 379 width_g = ecb_popcount32 (visual->green_mask);
619 width_b = ecb_popcount32 (visual->blue_mask); 380 width_b = ecb_popcount32 (visual->blue_mask);
381 width_a = ecb_popcount32 (alpha_mask);
620 382
621 if (width_r > 8 || width_g > 8 || width_b > 8) 383 if (width_r > 8 || width_g > 8 || width_b > 8 || width_a > 8)
622 return false; 384 return false;
623 385
624 sh_r = ecb_ctz32 (visual->red_mask); 386 sh_r = ecb_ctz32 (visual->red_mask);
625 sh_g = ecb_ctz32 (visual->green_mask); 387 sh_g = ecb_ctz32 (visual->green_mask);
626 sh_b = ecb_ctz32 (visual->blue_mask); 388 sh_b = ecb_ctz32 (visual->blue_mask);
389 sh_a = ecb_ctz32 (alpha_mask);
627 390
628 if (width > INT_MAX / height / bytes_per_pixel) 391 if (width > INT_MAX / height / bytes_per_pixel)
629 return false; 392 return false;
630 393
631 data = (char *)malloc (width * height * bytes_per_pixel); 394 data = (char *)malloc (width * height * bytes_per_pixel);
… …
645 rowstride = gdk_pixbuf_get_rowstride (pixbuf); 408 rowstride = gdk_pixbuf_get_rowstride (pixbuf);
646 channels = gdk_pixbuf_get_n_channels (pixbuf); 409 channels = gdk_pixbuf_get_n_channels (pixbuf);
647 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;
648 line = data; 411 line = data;
649 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
650 for (int y = 0; y < height; y++) 423 for (int y = 0; y < height; y++)
651 { 424 {
652 for (int x = 0; x < width; x++) 425 for (int x = 0; x < width; x++)
653 { 426 {
654 unsigned char *pixel = row + x * channels; 427 unsigned char *pixel = row + x * channels;
655 uint32_t value; 428 uint32_t value;
429 unsigned char r, g, b, a;
656 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
657 value = ((pixel[0] >> (8 - width_r)) << sh_r) 446 value = ((r >> (8 - width_r)) << sh_r)
658 | ((pixel[1] >> (8 - width_g)) << sh_g) 447 | ((g >> (8 - width_g)) << sh_g)
659 | ((pixel[2] >> (8 - width_b)) << sh_b); 448 | ((b >> (8 - width_b)) << sh_b)
449 | ((a >> (8 - width_a)) << sh_a);
660 450
661 if (bytes_per_pixel == 4) 451 if (bytes_per_pixel == 4)
662 ((uint32_t *)line)[x] = value; 452 ((uint32_t *)line)[x] = value;
663 else 453 else
664 ((uint16_t *)line)[x] = value; 454 ((uint16_t *)line)[x] = value;
… …
672 XDestroyImage (ximage); 462 XDestroyImage (ximage);
673 return true; 463 return true;
674} 464}
675 465
676bool 466bool
677rxvt_term::render_image (unsigned long tr_flags) 467rxvt_term::render_image (bool transparent)
678{ 468{
679 if (!pixbuf) 469 if (!pixbuf)
680 return false; 470 return false;
681 471
682 if (tr_flags 472 if (transparent
683 && !(bg_flags & BG_HAS_RENDER)) 473 && !(bg_flags & BG_HAS_RENDER))
684 return false; 474 return false;
685 475
686 GdkPixbuf *result; 476 GdkPixbuf *result;
687 477
… …
727 Pixmap root_pmap; 517 Pixmap root_pmap;
728 518
729 image_width = gdk_pixbuf_get_width (result); 519 image_width = gdk_pixbuf_get_width (result);
730 image_height = gdk_pixbuf_get_height (result); 520 image_height = gdk_pixbuf_get_height (result);
731 521
732 if (tr_flags) 522 if (transparent)
733 { 523 {
734 root_pmap = bg_pixmap; 524 root_pmap = bg_pixmap;
735 bg_pixmap = None; 525 bg_pixmap = None;
736 } 526 }
737 else 527 else
… …
795 dst_x, dst_y, 585 dst_x, dst_y,
796 dst_width, dst_height); 586 dst_width, dst_height);
797 } 587 }
798 588
799#if XRENDER 589#if XRENDER
800 if (tr_flags) 590 if (transparent)
801 { 591 {
802 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 592 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
803 593
804 Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0); 594 Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
805 595
… …
829 } 619 }
830 620
831 if (result != pixbuf) 621 if (result != pixbuf)
832 g_object_unref (result); 622 g_object_unref (result);
833 623
834 if (tr_flags) 624 if (transparent)
835 XFreePixmap (dpy, root_pmap); 625 XFreePixmap (dpy, root_pmap);
836 626
837 return ret; 627 return ret;
838} 628}
839# endif /* HAVE_PIXBUF */ 629# endif /* HAVE_PIXBUF */
… …
854 memcpy (f, file, len); 644 memcpy (f, file, len);
855 f[len] = '\0'; 645 f[len] = '\0';
856 file = f; 646 file = f;
857 } 647 }
858 648
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 649# ifdef HAVE_PIXBUF
874 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL); 650 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
875 if (image) 651 if (image)
876 { 652 {
877 if (pixbuf) 653 if (pixbuf)
… …
934 { 710 {
935 changed = true; 711 changed = true;
936 v_blurRadius = vr; 712 v_blurRadius = vr;
937 } 713 }
938 714
939 if (h_blurRadius == 0 || v_blurRadius == 0) 715 if (h_blurRadius && v_blurRadius)
716 bg_flags |= BG_NEEDS_BLUR;
717 else
940 bg_flags &= ~BG_NEEDS_BLUR; 718 bg_flags &= ~BG_NEEDS_BLUR;
941 else
942 bg_flags |= BG_NEEDS_BLUR;
943 719
944 return changed; 720 return changed;
945} 721}
946 722
947void 723void
948rxvt_term::set_tint_shade_flags () 724rxvt_term::set_tint_shade_flags ()
949{ 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
950 rgba c; 740 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); 741 tint.get (c);
958 if (!has_shade
959 && (c.r <= 0x00ff || c.r >= 0xff00) 742 if ((c.r <= 0x00ff || c.r >= 0xff00)
960 && (c.g <= 0x00ff || c.g >= 0xff00) 743 && (c.g <= 0x00ff || c.g >= 0xff00)
961 && (c.b <= 0x00ff || c.b >= 0xff00)) 744 && (c.b <= 0x00ff || c.b >= 0xff00))
962 bg_flags |= BG_TINT_BITAND; 745 bg_flags |= BG_TINT_BITAND;
963 } 746 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; 747 bg_flags &= ~BG_TINT_BITAND;
748
976 set_tint_shade_flags (); 749 set_tint_shade_flags ();
977 return true; 750 return true;
978 } 751 }
979 752
980 return false; 753 return false;
… …
1090bool 863bool
1091rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 864rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1092{ 865{
1093 bool ret = false; 866 bool ret = false;
1094 867
1095 if (bg_flags & BG_TINT_BITAND) 868 if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1096 { 869 {
1097 XGCValues gcv; 870 XGCValues gcv;
1098 GC gc; 871 GC gc;
1099 872
1100 /* In this case we can tint image server-side getting significant 873 /* In this case we can tint image server-side getting significant
… …
1181/* 954/*
1182 * 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
1183 * 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
1184 * our window. 957 * our window.
1185 */ 958 */
1186unsigned long 959bool
1187rxvt_term::make_transparency_pixmap () 960rxvt_term::make_transparency_pixmap ()
1188{ 961{
1189 unsigned long result = 0; 962 bool ret = false;
1190 963
1191 /* 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
1192 * be always up-to-date, so let's use it : 965 * be always up-to-date, so let's use it :
1193 */ 966 */
1194 int screen = display->screen; 967 int screen = display->screen;
… …
1275 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); 1048 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1276 1049
1277 if (gc) 1050 if (gc)
1278 { 1051 {
1279 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height); 1052 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1280 result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS); 1053 ret = true;
1054 unsigned long tr_flags = bg_flags & BG_EFFECTS_FLAGS;
1281 1055
1282 if (!(bg_flags & BG_CLIENT_RENDER)) 1056 if (!(bg_flags & BG_CLIENT_RENDER))
1283 { 1057 {
1284 if (bg_flags & BG_NEEDS_BLUR) 1058 if (bg_flags & BG_NEEDS_BLUR)
1285 { 1059 {
1286 if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth)) 1060 if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth))
1287 result &= ~BG_NEEDS_BLUR; 1061 tr_flags &= ~BG_NEEDS_BLUR;
1288 } 1062 }
1289 if (bg_flags & BG_NEEDS_TINT) 1063 if (bg_flags & BG_NEEDS_TINT)
1290 { 1064 {
1291 if (tint_pixmap (bg_pixmap, visual, window_width, window_height)) 1065 if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1292 result &= ~BG_NEEDS_TINT; 1066 tr_flags &= ~BG_NEEDS_TINT;
1293 } 1067 }
1294# ifndef HAVE_AFTERIMAGE
1295 if (result & BG_NEEDS_TINT) 1068 if (tr_flags & BG_NEEDS_TINT)
1296 { 1069 {
1297 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);
1298 if (ximage) 1071 if (ximage)
1299 { 1072 {
1300 /* our own client-side tinting */ 1073 /* our own client-side tinting */
… …
1302 1075
1303 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);
1304 XDestroyImage (ximage); 1077 XDestroyImage (ximage);
1305 } 1078 }
1306 } 1079 }
1307# endif
1308 } /* server side rendering completed */ 1080 } /* server side rendering completed */
1309 1081
1310 XFreeGC (dpy, gc); 1082 XFreeGC (dpy, gc);
1311 } 1083 }
1312 1084
1313 if (recoded_root_pmap != root_pixmap) 1085 if (recoded_root_pmap != root_pixmap)
1314 XFreePixmap (dpy, recoded_root_pmap); 1086 XFreePixmap (dpy, recoded_root_pmap);
1315 1087
1316 return result; 1088 return ret;
1317} 1089}
1318 1090
1319void 1091void
1320rxvt_term::bg_set_root_pixmap () 1092rxvt_term::bg_set_root_pixmap ()
1321{ 1093{
… …
1328# endif /* ENABLE_TRANSPARENCY */ 1100# endif /* ENABLE_TRANSPARENCY */
1329 1101
1330bool 1102bool
1331rxvt_term::bg_render () 1103rxvt_term::bg_render ()
1332{ 1104{
1333 unsigned long tr_flags = 0; 1105 bool transparent = false;
1334 1106
1335 bg_invalidate (); 1107 bg_invalidate ();
1336# ifdef ENABLE_TRANSPARENCY 1108# ifdef ENABLE_TRANSPARENCY
1337 if (bg_flags & BG_IS_TRANSPARENT) 1109 if (bg_flags & BG_IS_TRANSPARENT)
1338 { 1110 {
1339 /* we need to re-generate transparency pixmap in that case ! */ 1111 /* we need to re-generate transparency pixmap in that case ! */
1340 tr_flags = make_transparency_pixmap (); 1112 transparent = make_transparency_pixmap ();
1341 if (tr_flags) 1113 if (transparent)
1342 bg_flags |= BG_IS_VALID; 1114 bg_flags |= BG_IS_VALID;
1343 } 1115 }
1344# endif 1116# endif
1345 1117
1346# ifdef BG_IMAGE_FROM_FILE 1118# ifdef BG_IMAGE_FROM_FILE
1347 if ((bg_flags & BG_IS_FROM_FILE) 1119 if (bg_flags & BG_IS_FROM_FILE)
1348 || (tr_flags & BG_EFFECTS_FLAGS))
1349 { 1120 {
1350 if (render_image (tr_flags)) 1121 if (render_image (transparent))
1351 bg_flags |= BG_IS_VALID; 1122 bg_flags |= BG_IS_VALID;
1352 } 1123 }
1353# endif 1124# endif
1354 1125
1355 if (!(bg_flags & BG_IS_VALID)) 1126 if (!(bg_flags & BG_IS_VALID))
… …
1393#endif 1164#endif
1394} 1165}
1395 1166
1396#endif /* HAVE_BG_PIXMAP */ 1167#endif /* HAVE_BG_PIXMAP */
1397 1168
1398#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) 1169#ifdef ENABLE_TRANSPARENCY
1399/* based on code from aterm-0.4.2 */ 1170/* based on code from aterm-0.4.2 */
1400 1171
1401static inline void 1172static inline void
1402fill_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)
1403{ 1174{
… …
1516 /* apply table to input image (replacing colors by newly calculated ones) */ 1287 /* apply table to input image (replacing colors by newly calculated ones) */
1517 if (ximage->bits_per_pixel == 32 1288 if (ximage->bits_per_pixel == 32
1518 && (ximage->depth == 24 || ximage->depth == 32) 1289 && (ximage->depth == 24 || ximage->depth == 32)
1519 && ximage->byte_order == host_byte_order) 1290 && ximage->byte_order == host_byte_order)
1520 { 1291 {
1521 uint32_t *p1, *pf, *p, *pl; 1292 char *line = ximage->data;
1522 p1 = (uint32_t *) ximage->data;
1523 pf = (uint32_t *) (ximage->data + ximage->height * ximage->bytes_per_line);
1524 1293
1525 while (p1 < pf) 1294 for (int y = 0; y < ximage->height; y++)
1526 { 1295 {
1527 p = p1; 1296 uint32_t *p = (uint32_t *)line;
1528 pl = p1 + ximage->width; 1297 for (int x = 0; x < ximage->width; x++)
1529 for (; p < pl; p++)
1530 { 1298 {
1531 *p = lookup_r[(*p & 0xff0000) >> 16] | 1299 *p = lookup_r[(*p & 0xff0000) >> 16] |
1532 lookup_g[(*p & 0x00ff00) >> 8] | 1300 lookup_g[(*p & 0x00ff00) >> 8] |
1533 lookup_b[(*p & 0x0000ff)] | 1301 lookup_b[(*p & 0x0000ff)] |
1534 (*p & 0xff000000); 1302 (*p & 0xff000000);
1535 } 1303 p++;
1536 p1 = (uint32_t *) ((char *) p1 + ximage->bytes_per_line); 1304 }
1305 line += ximage->bytes_per_line;
1537 } 1306 }
1538 } 1307 }
1539 else 1308 else
1540 { 1309 {
1541 for (int y = 0; y < ximage->height; y++) 1310 for (int y = 0; y < ximage->height; y++)
… …
1549 } 1318 }
1550 } 1319 }
1551 1320
1552 free (lookup); 1321 free (lookup);
1553} 1322}
1554#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */ 1323#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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