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.196 by sf-exg, Tue Jan 10 18:50:14 2012 UTC vs.
Revision 1.211 by sf-exg, Sun May 13 15:28:44 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
… …
129 120
130 return false; 121 return false;
131} 122}
132 123
133# ifdef BG_IMAGE_FROM_FILE 124# ifdef BG_IMAGE_FROM_FILE
134static inline bool
135check_set_scale_value (int geom_flags, int flag, unsigned int &scale, unsigned int new_value)
136{
137 if (geom_flags & flag)
138 {
139 if (new_value > 1000)
140 new_value = 1000;
141 if (new_value != scale)
142 {
143 scale = new_value;
144 return true;
145 }
146 }
147 return false;
148}
149
150static inline bool
151check_set_align_value (int geom_flags, int flag, int &align, int new_value)
152{
153 if (geom_flags & flag)
154 {
155 if (new_value < -100)
156 new_value = -100;
157 else if (new_value > 200)
158 new_value = 200;
159 if (new_value != align)
160 {
161 align = new_value;
162 return true;
163 }
164 }
165 return false;
166}
167
168static inline int 125static inline int
169make_align_position (int align, int window_size, int image_size) 126make_align_position (int align, int window_size, int image_size)
170{ 127{
171 int diff = window_size - image_size;
172 int smaller = min (image_size, window_size);
173
174 if (align >= 0 && align <= 100) 128 if (align >= 0 && align <= 100)
175 return diff * align / 100; 129 return lerp (0, window_size - image_size, align);
176 else if (align > 100 && align <= 200) 130 else if (align > 100)
177 return (align - 100) * smaller / 100 + window_size - smaller; 131 return lerp (window_size - image_size, window_size, align - 100);
178 else if (align >= -100 && align < 0) 132 else
179 return (align + 100) * smaller / 100 - image_size; 133 return lerp (-image_size, 0, align + 100);
180 return 0;
181} 134}
182 135
183static inline int 136static inline int
184make_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)
185{ 138{
… …
191 src_pos = -pos; 144 src_pos = -pos;
192 dst_pos = 0; 145 dst_pos = 0;
193 dst_size += pos; 146 dst_size += pos;
194 } 147 }
195 148
196 if (dst_pos + dst_size > target_size)
197 dst_size = target_size - dst_pos; 149 min_it (dst_size, target_size - dst_pos);
198 return src_pos; 150 return src_pos;
199} 151}
200 152
201bool 153bool
202rxvt_term::bg_set_geometry (const char *geom, bool update) 154rxvt_term::bg_set_geometry (const char *geom, bool update)
203{ 155{
204 bool changed = false; 156 bool changed = false;
205 int geom_flags = 0; 157 int geom_flags = 0;
206 int x = 0, y = 0; 158 int x = h_align;
159 int y = v_align;
207 unsigned int w = 0, h = 0; 160 unsigned int w = h_scale;
161 unsigned int h = v_scale;
208 unsigned long new_flags = 0; 162 unsigned long new_flags = 0;
209 163
210 if (geom == NULL) 164 if (geom == NULL)
211 return false; 165 return false;
212 166
… …
321 w = h = defaultScale; 275 w = h = defaultScale;
322 else if (!(geom_flags & HeightValue)) 276 else if (!(geom_flags & HeightValue))
323 h = w; 277 h = w;
324 else if (!(geom_flags & WidthValue)) 278 else if (!(geom_flags & WidthValue))
325 w = h; 279 w = h;
326
327 geom_flags |= WidthValue|HeightValue|XValue|YValue;
328 } 280 }
329 281
330 if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true; 282 min_it (w, 1000);
331 if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true; 283 min_it (h, 1000);
332 if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true; 284 clamp_it (x, -100, 200);
333 if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true; 285 clamp_it (y, -100, 200);
334 286
335 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)
336 { 292 {
337 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;
338 changed = true; 298 changed = true;
339 } 299 }
340 300
341 return changed; 301 return changed;
342} 302}
… …
370 { 330 {
371 x = make_align_position (h_align, target_width, w); 331 x = make_align_position (h_align, target_width, w);
372 y = make_align_position (v_align, target_height, h); 332 y = make_align_position (v_align, target_height, h);
373 } 333 }
374 334
375 bg_flags &= ~BG_IS_SIZE_SENSITIVE;
376 if (!(bg_flags & BG_TILE) 335 if (!(bg_flags & BG_TILE)
377 || h_scale || v_scale 336 || h_scale || v_scale
378 || (!(bg_flags & BG_ROOT_ALIGN) && (h_align || v_align)) 337 || (!(bg_flags & BG_ROOT_ALIGN) && (h_align || v_align))
379 || w > target_width || h > target_height) 338 || image_width > target_width || image_height > target_height)
380 bg_flags |= BG_IS_SIZE_SENSITIVE; 339 bg_flags |= BG_IS_SIZE_SENSITIVE;
381}
382
383# ifdef HAVE_AFTERIMAGE
384bool
385rxvt_term::render_image (unsigned long tr_flags)
386{
387 init_asv ();
388
389 ASImage *background = NULL;
390 ARGB32 background_tint = TINT_LEAVE_SAME;
391
392# ifdef ENABLE_TRANSPARENCY
393 if (tr_flags)
394 background = pixmap2ximage (asv, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, 100);
395
396 if (tr_flags & BG_NEEDS_TINT)
397 {
398 ShadingInfo as_shade;
399 as_shade.shading = shade;
400
401 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
402 if (bg_flags & BG_TINT_SET)
403 tint.get (c);
404 as_shade.tintColor.red = c.r;
405 as_shade.tintColor.green = c.g;
406 as_shade.tintColor.blue = c.b;
407
408 background_tint = shading2tint32 (&as_shade);
409 }
410
411 if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)
412 {
413 ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,
414 ASA_XImage,
415 100, ASIMAGE_QUALITY_DEFAULT);
416 if (tmp)
417 {
418 destroy_asimage (&background);
419 background = tmp;
420 }
421 }
422# endif
423
424 ASImage *result = 0;
425
426 int target_width = szHint.width;
427 int target_height = szHint.height;
428 int new_pmap_width = target_width;
429 int new_pmap_height = target_height;
430
431 int x = 0;
432 int y = 0;
433 int w = 0;
434 int h = 0;
435
436 if (original_asim)
437 get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
438
439 if (!original_asim
440 || (!(bg_flags & BG_ROOT_ALIGN)
441 && (x >= target_width
442 || y >= target_height
443 || x + w <= 0
444 || y + h <= 0)))
445 {
446 if (background)
447 {
448 new_pmap_width = background->width;
449 new_pmap_height = background->height;
450 result = background;
451
452 if (background_tint != TINT_LEAVE_SAME)
453 {
454 ASImage *tmp = tile_asimage (asv, background, 0, 0,
455 target_width, target_height, background_tint,
456 ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
457 if (tmp)
458 result = tmp;
459 }
460 }
461 else
462 new_pmap_width = new_pmap_height = 0;
463 }
464 else 340 else
465 { 341 bg_flags &= ~BG_IS_SIZE_SENSITIVE;
466 result = original_asim;
467
468 if (w != original_asim->width
469 || h != original_asim->height)
470 {
471 result = scale_asimage (asv, original_asim,
472 w, h,
473 ASA_XImage,
474 100, ASIMAGE_QUALITY_DEFAULT);
475 }
476
477 if (background == NULL)
478 {
479 if (bg_flags & BG_TILE)
480 {
481 /* if tiling - pixmap has to be sized exactly as the image,
482 but there is no need to make it bigger than the window! */
483 new_pmap_width = min (result->width, target_width);
484 new_pmap_height = min (result->height, target_height);
485
486 /* we also need to tile our image in both directions */
487 ASImage *tmp = tile_asimage (asv, result,
488 (int)result->width - x,
489 (int)result->height - y,
490 new_pmap_width,
491 new_pmap_height,
492 TINT_LEAVE_SAME, ASA_XImage,
493 100, ASIMAGE_QUALITY_DEFAULT);
494 if (tmp)
495 {
496 if (result != original_asim)
497 destroy_asimage (&result);
498
499 result = tmp;
500 }
501 }
502 }
503 else
504 {
505 /* if blending background and image - pixmap has to be sized same as target window */
506 ASImageLayer *layers = create_image_layers (2);
507
508 layers[0].im = background;
509 layers[0].clip_width = target_width;
510 layers[0].clip_height = target_height;
511 layers[0].tint = background_tint;
512 layers[1].im = result;
513
514 if (bg_flags & BG_TILE)
515 {
516 /* tile horizontally */
517 while (x > 0) x -= (int)result->width;
518 layers[1].dst_x = x;
519 layers[1].clip_width = result->width+target_width;
520 }
521 else
522 {
523 /* clip horizontally */
524 layers[1].dst_x = x;
525 layers[1].clip_width = result->width;
526 }
527
528 if (bg_flags & BG_TILE)
529 {
530 while (y > 0) y -= (int)result->height;
531 layers[1].dst_y = y;
532 layers[1].clip_height = result->height + target_height;
533 }
534 else
535 {
536 layers[1].dst_y = y;
537 layers[1].clip_height = result->height;
538 }
539
540 if (rs[Rs_blendtype])
541 {
542 layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
543 if (layers[1].merge_scanlines == NULL)
544 layers[1].merge_scanlines = alphablend_scanlines;
545 }
546
547 ASImage *tmp = merge_layers (asv, layers, 2, target_width, target_height,
548 ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
549
550 if (tmp)
551 {
552 if (result != original_asim)
553 destroy_asimage (&result);
554
555 result = tmp;
556 }
557
558 free (layers);
559 }
560 }
561
562 bool ret = false;
563
564 if (result)
565 {
566 XGCValues gcv;
567 GC gc;
568
569 /* create Pixmap */
570 if (bg_pixmap == None
571 || bg_pmap_width != new_pmap_width
572 || bg_pmap_height != new_pmap_height)
573 {
574 if (bg_pixmap)
575 XFreePixmap (dpy, bg_pixmap);
576 bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
577 bg_pmap_width = new_pmap_width;
578 bg_pmap_height = new_pmap_height;
579 }
580 /* fill with background color (if result's not completely overlapping it) */
581 gcv.foreground = pix_colors[Color_bg];
582 gc = XCreateGC (dpy, vt, GCForeground, &gcv);
583
584 int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
585 int dst_width = result->width, dst_height = result->height;
586 if (background == NULL)
587 {
588 if (!(bg_flags & BG_TILE))
589 {
590 src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );
591 src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
592 }
593
594 if (dst_x > 0 || dst_y > 0
595 || dst_x + dst_width < new_pmap_width
596 || dst_y + dst_height < new_pmap_height)
597 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
598 }
599
600 /* put result on pixmap */
601 if (dst_x < new_pmap_width && dst_y < new_pmap_height)
602 asimage2drawable (asv, bg_pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);
603
604 if (result != background && result != original_asim)
605 destroy_asimage (&result);
606
607 XFreeGC (dpy, gc);
608
609 ret = true;
610 }
611
612 if (background)
613 destroy_asimage (&background);
614
615 return ret;
616} 342}
617# endif /* HAVE_AFTERIMAGE */
618 343
619# ifdef HAVE_PIXBUF 344# ifdef HAVE_PIXBUF
620bool 345bool
621rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc, 346rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
622 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,
623 unsigned int width, unsigned int height) 348 unsigned int width, unsigned int height)
624{ 349{
625 XImage *ximage; 350 XImage *ximage;
626 char *data, *line; 351 char *line;
627 int bytes_per_pixel;
628 int width_r, width_g, width_b; 352 int width_r, width_g, width_b, width_a;
629 int sh_r, sh_g, sh_b; 353 int sh_r, sh_g, sh_b, sh_a;
354 uint32_t alpha_mask;
630 int rowstride; 355 int rowstride;
631 int channels; 356 int channels;
632 unsigned char *row; 357 unsigned char *row;
633 358
634 if (visual->c_class != TrueColor) 359 if (visual->c_class != TrueColor)
635 return false; 360 return false;
636 361
637 if (depth == 24 || depth == 32) 362#if XRENDER
638 bytes_per_pixel = 4; 363 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
639 else if (depth == 15 || depth == 16) 364 if (format)
640 bytes_per_pixel = 2; 365 alpha_mask = (uint32_t)format->direct.alphaMask << format->direct.alpha;
641 else 366 else
642 return false; 367#endif
368 alpha_mask = 0;
643 369
644 width_r = ecb_popcount32 (visual->red_mask); 370 width_r = ecb_popcount32 (visual->red_mask);
645 width_g = ecb_popcount32 (visual->green_mask); 371 width_g = ecb_popcount32 (visual->green_mask);
646 width_b = ecb_popcount32 (visual->blue_mask); 372 width_b = ecb_popcount32 (visual->blue_mask);
373 width_a = ecb_popcount32 (alpha_mask);
647 374
648 if (width_r > 8 || width_g > 8 || width_b > 8) 375 if (width_r > 8 || width_g > 8 || width_b > 8 || width_a > 8)
649 return false; 376 return false;
650 377
651 sh_r = ecb_ctz32 (visual->red_mask); 378 sh_r = ecb_ctz32 (visual->red_mask);
652 sh_g = ecb_ctz32 (visual->green_mask); 379 sh_g = ecb_ctz32 (visual->green_mask);
653 sh_b = ecb_ctz32 (visual->blue_mask); 380 sh_b = ecb_ctz32 (visual->blue_mask);
381 sh_a = ecb_ctz32 (alpha_mask);
654 382
655 if (width > INT_MAX / height / bytes_per_pixel) 383 if (width > 32767 || height > 32767)
656 return false; 384 return false;
657 385
658 data = (char *)malloc (width * height * bytes_per_pixel); 386 ximage = XCreateImage (dpy, visual, depth, ZPixmap, 0, 0,
659 if (!data) 387 width, height, 32, 0);
388 if (!ximage)
660 return false; 389 return false;
661 390
662 ximage = XCreateImage (dpy, visual, depth, ZPixmap, 0, data, 391 if (height > INT_MAX / ximage->bytes_per_line
663 width, height, bytes_per_pixel * 8, 0); 392 || !(ximage->data = (char *)malloc (height * ximage->bytes_per_line)))
664 if (!ximage)
665 { 393 {
666 free (data); 394 XDestroyImage (ximage);
667 return false; 395 return false;
668 } 396 }
669 397
670 ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst; 398 ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
671 399
672 rowstride = gdk_pixbuf_get_rowstride (pixbuf); 400 rowstride = gdk_pixbuf_get_rowstride (pixbuf);
673 channels = gdk_pixbuf_get_n_channels (pixbuf); 401 channels = gdk_pixbuf_get_n_channels (pixbuf);
674 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;
675 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 }
676 414
677 for (int y = 0; y < height; y++) 415 for (int y = 0; y < height; y++)
678 { 416 {
679 for (int x = 0; x < width; x++) 417 for (int x = 0; x < width; x++)
680 { 418 {
681 unsigned char *pixel = row + x * channels; 419 unsigned char *pixel = row + x * channels;
682 uint32_t value; 420 uint32_t value;
421 unsigned char r, g, b, a;
683 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
684 value = ((pixel[0] >> (8 - width_r)) << sh_r) 438 value = ((r >> (8 - width_r)) << sh_r)
685 | ((pixel[1] >> (8 - width_g)) << sh_g) 439 | ((g >> (8 - width_g)) << sh_g)
686 | ((pixel[2] >> (8 - width_b)) << sh_b); 440 | ((b >> (8 - width_b)) << sh_b)
441 | ((a >> (8 - width_a)) << sh_a);
687 442
688 if (bytes_per_pixel == 4) 443 if (ximage->bits_per_pixel == 32)
689 ((uint32_t *)line)[x] = value; 444 ((uint32_t *)line)[x] = value;
690 else 445 else
691 ((uint16_t *)line)[x] = value; 446 XPutPixel (ximage, x, y, value);
692 } 447 }
693 448
694 row += rowstride; 449 row += rowstride;
695 line += ximage->bytes_per_line; 450 line += ximage->bytes_per_line;
696 } 451 }
… …
699 XDestroyImage (ximage); 454 XDestroyImage (ximage);
700 return true; 455 return true;
701} 456}
702 457
703bool 458bool
704rxvt_term::render_image (unsigned long tr_flags) 459rxvt_term::render_image (bool transparent)
705{ 460{
706 if (!pixbuf) 461 if (!pixbuf)
707 return false; 462 return false;
708 463
709 if (tr_flags 464 if (transparent
710 && !(bg_flags & BG_HAS_RENDER)) 465 && !(bg_flags & BG_HAS_RENDER))
711 return false; 466 return false;
712 467
713 GdkPixbuf *result; 468 GdkPixbuf *result;
714 469
… …
754 Pixmap root_pmap; 509 Pixmap root_pmap;
755 510
756 image_width = gdk_pixbuf_get_width (result); 511 image_width = gdk_pixbuf_get_width (result);
757 image_height = gdk_pixbuf_get_height (result); 512 image_height = gdk_pixbuf_get_height (result);
758 513
759 if (tr_flags) 514 if (transparent)
760 { 515 {
761 root_pmap = bg_pixmap; 516 root_pmap = bg_pixmap;
762 bg_pixmap = None; 517 bg_pixmap = None;
763 } 518 }
764 else 519 else
… …
822 dst_x, dst_y, 577 dst_x, dst_y,
823 dst_width, dst_height); 578 dst_width, dst_height);
824 } 579 }
825 580
826#if XRENDER 581#if XRENDER
827 if (tr_flags) 582 if (transparent)
828 { 583 {
829 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 584 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
830 585
831 Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0); 586 Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
832 587
… …
856 } 611 }
857 612
858 if (result != pixbuf) 613 if (result != pixbuf)
859 g_object_unref (result); 614 g_object_unref (result);
860 615
861 if (tr_flags) 616 if (transparent)
862 XFreePixmap (dpy, root_pmap); 617 XFreePixmap (dpy, root_pmap);
863 618
864 return ret; 619 return ret;
865} 620}
866# endif /* HAVE_PIXBUF */ 621# endif /* HAVE_PIXBUF */
… …
881 memcpy (f, file, len); 636 memcpy (f, file, len);
882 f[len] = '\0'; 637 f[len] = '\0';
883 file = f; 638 file = f;
884 } 639 }
885 640
886# ifdef HAVE_AFTERIMAGE
887 if (!asimman)
888 asimman = create_generic_imageman (rs[Rs_path]);
889 ASImage *image = get_asimage (asimman, file, 0xFFFFFFFF, 100);
890 if (image)
891 {
892 if (original_asim)
893 safe_asimage_destroy (original_asim);
894 original_asim = image;
895 bg_flags |= BG_IS_FROM_FILE | BG_CLIENT_RENDER;
896 ret = true;
897 }
898# endif
899
900# ifdef HAVE_PIXBUF 641# ifdef HAVE_PIXBUF
901 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL); 642 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
902 if (image) 643 if (image)
903 { 644 {
904 if (pixbuf) 645 if (pixbuf)
… …
922 663
923# endif /* BG_IMAGE_FROM_FILE */ 664# endif /* BG_IMAGE_FROM_FILE */
924 665
925# ifdef ENABLE_TRANSPARENCY 666# ifdef ENABLE_TRANSPARENCY
926bool 667bool
927rxvt_term::bg_set_transparent ()
928{
929 if (!(bg_flags & BG_IS_TRANSPARENT))
930 {
931 bg_flags |= BG_IS_TRANSPARENT;
932 return true;
933 }
934
935 return false;
936}
937
938bool
939rxvt_term::bg_set_blur (const char *geom) 668rxvt_term::bg_set_blur (const char *geom)
940{ 669{
941 bool changed = false; 670 bool changed = false;
942 unsigned int hr, vr; 671 unsigned int hr, vr;
943 int junk; 672 int junk;
… …
961 { 690 {
962 changed = true; 691 changed = true;
963 v_blurRadius = vr; 692 v_blurRadius = vr;
964 } 693 }
965 694
966 if (h_blurRadius == 0 || v_blurRadius == 0) 695 if (h_blurRadius && v_blurRadius)
696 bg_flags |= BG_NEEDS_BLUR;
697 else
967 bg_flags &= ~BG_NEEDS_BLUR; 698 bg_flags &= ~BG_NEEDS_BLUR;
968 else
969 bg_flags |= BG_NEEDS_BLUR;
970 699
971 return changed; 700 return changed;
972} 701}
973 702
974void 703void
975rxvt_term::set_tint_shade_flags () 704rxvt_term::set_tint_shade_flags ()
976{ 705{
706 if (shade != 100 || (bg_flags & BG_TINT_SET))
707 bg_flags |= BG_NEEDS_TINT;
708 else
709 bg_flags &= ~BG_NEEDS_TINT;
710}
711
712bool
713rxvt_term::bg_set_tint (rxvt_color &new_tint)
714{
715 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
716 {
717 tint = new_tint;
718 bg_flags |= BG_TINT_SET;
719
977 rgba c; 720 rgba c;
978 bool has_shade = shade != 100;
979
980 bg_flags &= ~BG_TINT_FLAGS;
981
982 if (bg_flags & BG_TINT_SET)
983 {
984 tint.get (c); 721 tint.get (c);
985 if (!has_shade
986 && (c.r <= 0x00ff || c.r >= 0xff00) 722 if ((c.r <= 0x00ff || c.r >= 0xff00)
987 && (c.g <= 0x00ff || c.g >= 0xff00) 723 && (c.g <= 0x00ff || c.g >= 0xff00)
988 && (c.b <= 0x00ff || c.b >= 0xff00)) 724 && (c.b <= 0x00ff || c.b >= 0xff00))
989 bg_flags |= BG_TINT_BITAND; 725 bg_flags |= BG_TINT_BITAND;
990 } 726 else
991
992 if (has_shade || (bg_flags & BG_TINT_SET))
993 bg_flags |= BG_NEEDS_TINT;
994}
995
996bool
997rxvt_term::bg_set_tint (rxvt_color &new_tint)
998{
999 if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
1000 {
1001 tint = new_tint;
1002 bg_flags |= BG_TINT_SET; 727 bg_flags &= ~BG_TINT_BITAND;
728
1003 set_tint_shade_flags (); 729 set_tint_shade_flags ();
1004 return true; 730 return true;
1005 } 731 }
1006 732
1007 return false; 733 return false;
… …
1117bool 843bool
1118rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 844rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1119{ 845{
1120 bool ret = false; 846 bool ret = false;
1121 847
1122 if (bg_flags & BG_TINT_BITAND) 848 if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1123 { 849 {
1124 XGCValues gcv; 850 XGCValues gcv;
1125 GC gc; 851 GC gc;
1126 852
1127 /* In this case we can tint image server-side getting significant 853 /* In this case we can tint image server-side getting significant
… …
1208/* 934/*
1209 * Builds a pixmap of the same size as the terminal window that contains 935 * Builds a pixmap of the same size as the terminal window that contains
1210 * the tiled portion of the root pixmap that is supposed to be covered by 936 * the tiled portion of the root pixmap that is supposed to be covered by
1211 * our window. 937 * our window.
1212 */ 938 */
1213unsigned long 939bool
1214rxvt_term::make_transparency_pixmap () 940rxvt_term::make_transparency_pixmap ()
1215{ 941{
1216 unsigned long result = 0; 942 bool ret = false;
1217 943
1218 /* root dimensions may change from call to call - but Display structure should 944 /* root dimensions may change from call to call - but Display structure should
1219 * be always up-to-date, so let's use it : 945 * be always up-to-date, so let's use it :
1220 */ 946 */
1221 int screen = display->screen; 947 int screen = display->screen;
… …
1302 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); 1028 gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1303 1029
1304 if (gc) 1030 if (gc)
1305 { 1031 {
1306 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height); 1032 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1307 result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS); 1033 ret = true;
1034 unsigned long tr_flags = bg_flags & BG_EFFECTS_FLAGS;
1308 1035
1309 if (!(bg_flags & BG_CLIENT_RENDER)) 1036 if (!(bg_flags & BG_CLIENT_RENDER))
1310 { 1037 {
1311 if (bg_flags & BG_NEEDS_BLUR) 1038 if (bg_flags & BG_NEEDS_BLUR)
1312 { 1039 {
1313 if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth)) 1040 if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth))
1314 result &= ~BG_NEEDS_BLUR; 1041 tr_flags &= ~BG_NEEDS_BLUR;
1315 } 1042 }
1316 if (bg_flags & BG_NEEDS_TINT) 1043 if (bg_flags & BG_NEEDS_TINT)
1317 { 1044 {
1318 if (tint_pixmap (bg_pixmap, visual, window_width, window_height)) 1045 if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1319 result &= ~BG_NEEDS_TINT; 1046 tr_flags &= ~BG_NEEDS_TINT;
1320 } 1047 }
1321# ifndef HAVE_AFTERIMAGE
1322 if (result & BG_NEEDS_TINT) 1048 if (tr_flags & BG_NEEDS_TINT)
1323 { 1049 {
1324 XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap); 1050 XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1325 if (ximage) 1051 if (ximage)
1326 { 1052 {
1327 /* our own client-side tinting */ 1053 /* our own client-side tinting */
… …
1329 1055
1330 XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height); 1056 XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
1331 XDestroyImage (ximage); 1057 XDestroyImage (ximage);
1332 } 1058 }
1333 } 1059 }
1334# endif
1335 } /* server side rendering completed */ 1060 } /* server side rendering completed */
1336 1061
1337 XFreeGC (dpy, gc); 1062 XFreeGC (dpy, gc);
1338 } 1063 }
1339 1064
1340 if (recoded_root_pmap != root_pixmap) 1065 if (recoded_root_pmap != root_pixmap)
1341 XFreePixmap (dpy, recoded_root_pmap); 1066 XFreePixmap (dpy, recoded_root_pmap);
1342 1067
1343 return result; 1068 return ret;
1344} 1069}
1345 1070
1346void 1071void
1347rxvt_term::bg_set_root_pixmap () 1072rxvt_term::bg_set_root_pixmap ()
1348{ 1073{
… …
1355# endif /* ENABLE_TRANSPARENCY */ 1080# endif /* ENABLE_TRANSPARENCY */
1356 1081
1357bool 1082bool
1358rxvt_term::bg_render () 1083rxvt_term::bg_render ()
1359{ 1084{
1360 unsigned long tr_flags = 0; 1085 bool transparent = false;
1361 1086
1362 bg_invalidate (); 1087 bg_invalidate ();
1363# ifdef ENABLE_TRANSPARENCY 1088# ifdef ENABLE_TRANSPARENCY
1364 if (bg_flags & BG_IS_TRANSPARENT) 1089 if (bg_flags & BG_IS_TRANSPARENT)
1365 { 1090 {
1366 /* we need to re-generate transparency pixmap in that case ! */ 1091 /* we need to re-generate transparency pixmap in that case ! */
1367 tr_flags = make_transparency_pixmap (); 1092 transparent = make_transparency_pixmap ();
1368 if (tr_flags == 0) 1093 if (transparent)
1369 return false;
1370 bg_flags |= BG_IS_VALID; 1094 bg_flags |= BG_IS_VALID;
1371 } 1095 }
1372# endif 1096# endif
1373 1097
1374# ifdef BG_IMAGE_FROM_FILE 1098# ifdef BG_IMAGE_FROM_FILE
1375 if ((bg_flags & BG_IS_FROM_FILE) 1099 if (bg_flags & BG_IS_FROM_FILE)
1376 || (tr_flags & BG_EFFECTS_FLAGS))
1377 { 1100 {
1378 if (render_image (tr_flags)) 1101 if (render_image (transparent))
1379 bg_flags |= BG_IS_VALID; 1102 bg_flags |= BG_IS_VALID;
1380 } 1103 }
1381# endif 1104# endif
1382 1105
1383 if (!(bg_flags & BG_IS_VALID)) 1106 if (!(bg_flags & BG_IS_VALID))
… …
1421#endif 1144#endif
1422} 1145}
1423 1146
1424#endif /* HAVE_BG_PIXMAP */ 1147#endif /* HAVE_BG_PIXMAP */
1425 1148
1426#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) 1149#ifdef ENABLE_TRANSPARENCY
1427/* based on code from aterm-0.4.2 */ 1150/* based on code from aterm-0.4.2 */
1428 1151
1429static inline void 1152static inline void
1430fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high) 1153fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
1431{ 1154{
… …
1439} 1162}
1440 1163
1441void 1164void
1442rxvt_term::tint_ximage (Visual *visual, XImage *ximage) 1165rxvt_term::tint_ximage (Visual *visual, XImage *ximage)
1443{ 1166{
1167 unsigned int size_r, size_g, size_b;
1444 int sh_r, sh_g, sh_b; 1168 int sh_r, sh_g, sh_b;
1445 uint32_t mask_r, mask_g, mask_b; 1169 uint32_t mask_r, mask_g, mask_b;
1446 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b; 1170 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1447 unsigned short low; 1171 unsigned short low;
1448 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst; 1172 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
… …
1453 mask_r = visual->red_mask; 1177 mask_r = visual->red_mask;
1454 mask_g = visual->green_mask; 1178 mask_g = visual->green_mask;
1455 mask_b = visual->blue_mask; 1179 mask_b = visual->blue_mask;
1456 1180
1457 /* boring lookup table pre-initialization */ 1181 /* boring lookup table pre-initialization */
1458 switch (ximage->depth) 1182 sh_r = ecb_ctz32 (mask_r);
1459 { 1183 sh_g = ecb_ctz32 (mask_g);
1460 case 15: 1184 sh_b = ecb_ctz32 (mask_b);
1461 if ((mask_r != 0x7c00) || 1185
1462 (mask_g != 0x03e0) || 1186 size_r = mask_r >> sh_r;
1463 (mask_b != 0x001f)) 1187 size_g = mask_g >> sh_g;
1188 size_b = mask_b >> sh_b;
1189
1190 if (size_r++ > 255 || size_g++ > 255 || size_b++ > 255)
1464 return; 1191 return;
1465 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+32+32)); 1192
1193 lookup = (uint32_t *)malloc (sizeof (uint32_t) * (size_r + size_g + size_b));
1466 lookup_r = lookup; 1194 lookup_r = lookup;
1467 lookup_g = lookup+32; 1195 lookup_g = lookup + size_r;
1468 lookup_b = lookup+32+32; 1196 lookup_b = lookup + size_r + size_g;
1469 sh_r = 10;
1470 sh_g = 5;
1471 sh_b = 0;
1472 break;
1473 case 16:
1474 if ((mask_r != 0xf800) ||
1475 (mask_g != 0x07e0) ||
1476 (mask_b != 0x001f))
1477 return;
1478 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+64+32));
1479 lookup_r = lookup;
1480 lookup_g = lookup+32;
1481 lookup_b = lookup+32+64;
1482 sh_r = 11;
1483 sh_g = 5;
1484 sh_b = 0;
1485 break;
1486 case 24:
1487 if ((mask_r != 0xff0000) ||
1488 (mask_g != 0x00ff00) ||
1489 (mask_b != 0x0000ff))
1490 return;
1491 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(256+256+256));
1492 lookup_r = lookup;
1493 lookup_g = lookup+256;
1494 lookup_b = lookup+256+256;
1495 sh_r = 16;
1496 sh_g = 8;
1497 sh_b = 0;
1498 break;
1499 case 32:
1500 if ((mask_r != 0xff0000) ||
1501 (mask_g != 0x00ff00) ||
1502 (mask_b != 0x0000ff))
1503 return;
1504 lookup = (uint32_t *) malloc (sizeof (uint32_t)*(256+256+256));
1505 lookup_r = lookup;
1506 lookup_g = lookup+256;
1507 lookup_b = lookup+256+256;
1508 sh_r = 16;
1509 sh_g = 8;
1510 sh_b = 0;
1511 break;
1512 default:
1513 return; /* we do not support this color depth */
1514 }
1515 1197
1516 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC); 1198 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1517 1199
1518 if (bg_flags & BG_TINT_SET) 1200 if (bg_flags & BG_TINT_SET)
1519 tint.get (c); 1201 tint.get (c);
… …
1541 fill_lut (lookup_g, mask_g, sh_g, low, c.g); 1223 fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1542 fill_lut (lookup_b, mask_b, sh_b, low, c.b); 1224 fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1543 1225
1544 /* apply table to input image (replacing colors by newly calculated ones) */ 1226 /* apply table to input image (replacing colors by newly calculated ones) */
1545 if (ximage->bits_per_pixel == 32 1227 if (ximage->bits_per_pixel == 32
1546 && (ximage->depth == 24 || ximage->depth == 32)
1547 && ximage->byte_order == host_byte_order) 1228 && ximage->byte_order == host_byte_order)
1548 { 1229 {
1549 uint32_t *p1, *pf, *p, *pl; 1230 char *line = ximage->data;
1550 p1 = (uint32_t *) ximage->data;
1551 pf = (uint32_t *) (ximage->data + ximage->height * ximage->bytes_per_line);
1552 1231
1553 while (p1 < pf) 1232 for (int y = 0; y < ximage->height; y++)
1554 {
1555 p = p1;
1556 pl = p1 + ximage->width;
1557 for (; p < pl; p++)
1558 { 1233 {
1559 *p = lookup_r[(*p & 0xff0000) >> 16] | 1234 uint32_t *p = (uint32_t *)line;
1560 lookup_g[(*p & 0x00ff00) >> 8] | 1235 for (int x = 0; x < ximage->width; x++)
1561 lookup_b[(*p & 0x0000ff)] |
1562 (*p & 0xff000000);
1563 } 1236 {
1564 p1 = (uint32_t *) ((char *) p1 + ximage->bytes_per_line); 1237 *p = lookup_r[(*p & mask_r) >> sh_r] |
1238 lookup_g[(*p & mask_g) >> sh_g] |
1239 lookup_b[(*p & mask_b) >> sh_b];
1240 p++;
1241 }
1242 line += ximage->bytes_per_line;
1565 } 1243 }
1566 } 1244 }
1567 else 1245 else
1568 { 1246 {
1569 for (int y = 0; y < ximage->height; y++) 1247 for (int y = 0; y < ximage->height; y++)
… …
1577 } 1255 }
1578 } 1256 }
1579 1257
1580 free (lookup); 1258 free (lookup);
1581} 1259}
1582#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */ 1260#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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