1 /*----------------------------------------------------------------------*
2 * File: background.C - former xpm.C
3 *----------------------------------------------------------------------*
5 * All portions of code are copyright by their respective author/s.
6 * Copyright (c) 2005-2008 Marc Lehmann <pcg@goof.com>
7 * Copyright (c) 2007 Sasha Vasko <sasha@aftercode.net>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 *---------------------------------------------------------------------*/
24 #include "../config.h" /* NECESSARY */
25 #include "rxvt.h" /* NECESSARY */
27 #define DO_TIMING_TEST 0
30 # include <sys/time.h>
31 #define TIMING_TEST_START(id) \
32 struct timeval timing_test_##id##_stv;\
33 gettimeofday (&timing_test_##id##_stv, NULL);
35 #define TIMING_TEST_PRINT_RESULT(id) \
36 do{ struct timeval tv;gettimeofday (&tv, NULL); tv.tv_sec -= (timing_test_##id##_stv).tv_sec;\
37 fprintf (stderr, "%s: %s: %d: elapsed %ld usec\n", #id, __FILE__, __LINE__,\
38 tv.tv_sec * 1000000 + tv.tv_usec - (timing_test_##id##_stv).tv_usec);}while (0)
41 #define TIMING_TEST_START(id) do{}while (0)
42 #define TIMING_TEST_PRINT_RESULT(id) do{}while (0)
46 * Pixmap geometry string interpretation :
47 * Each geometry string contains zero or one scale/position
48 * adjustment and may optionally be followed by a colon and one or more
49 * colon-delimited pixmap operations.
50 * The following table shows the valid geometry strings and their
51 * affects on the background image :
53 * WxH+X+Y Set scaling to W% by H%, and position to X% by Y%.
54 * W and H are percentages of the terminal window size.
55 * X and Y are also percentages; e.g., +50+50 centers
56 * the image in the window.
57 * WxH+X Assumes Y == X
58 * WxH Assumes Y == X == 50 (centers the image)
59 * W+X+Y Assumes H == W
60 * W+X Assumes H == W and Y == X
61 * W Assumes H == W and Y == X == 50
63 * Adjusting position only :
64 * =+X+Y Set position to X% by Y% (absolute).
65 * =+X Set position to X% by X%.
66 * +X+Y Adjust position horizontally X% and vertically Y%
67 * from current position (relative).
68 * +X Adjust position horizontally X% and vertically X%
69 * from current position.
71 * Adjusting scale only :
72 * Wx0 Multiply horizontal scaling factor by W%
73 * 0xH Multiply vertical scaling factor by H%
74 * 0x0 No scaling (show image at normal size).
76 * Pixmap Operations : (should be prepended by a colon)
77 * tile Tile image. Scaling/position modifiers above will affect
78 * the tile size and origin.
79 * propscale When scaling, scale proportionally. That is, maintain the
80 * proper aspect ratio for the image. Any portion of the
81 * background not covered by the image is filled with the
82 * current background color.
83 * hscale Scale horizontally, tile vertically ?
84 * vscale Tile horizontally, scale vertically ?
85 * scale Scale both up and down
86 * auto Same as 100x100+50+50
90 bgPixmap_t::bgPixmap_t ()
92 // this is basically redundant as bgPixmap_t is only used in
93 // zero_initialised-derived structs
94 #ifdef HAVE_AFTERIMAGE
97 #ifdef BG_IMAGE_FROM_FILE
98 h_scale = v_scale = 0;
99 h_align = v_align = 0;
103 valid_since = invalid_since = 0;
108 bgPixmap_t::destroy ()
110 #ifdef HAVE_AFTERIMAGE
112 safe_asimage_destroy (original_asim);
115 if (pixmap && target)
116 XFreePixmap (target->dpy, pixmap);
120 bgPixmap_t::window_size_sensitive ()
122 # ifdef ENABLE_TRANSPARENCY
123 if (flags & isTransparent)
127 # ifdef BG_IMAGE_FROM_FILE
128 # ifdef HAVE_AFTERIMAGE
132 if (h_scale != 0 || v_scale != 0
133 || h_align != 0 || v_align != 0)
142 bgPixmap_t::window_position_sensitive ()
144 # ifdef ENABLE_TRANSPARENCY
145 if (flags & isTransparent)
149 # ifdef BG_IMAGE_FROM_FILE
150 # ifdef HAVE_AFTERIMAGE
154 if (h_align == rootAlign || v_align == rootAlign)
162 bool bgPixmap_t::need_client_side_rendering ()
164 # ifdef HAVE_AFTERIMAGE
168 # ifdef ENABLE_TRANSPARENCY
169 if (flags & isTransparent)
171 # ifdef HAVE_AFTERIMAGE // can't blur without libAI anyways
172 if ((flags & blurNeeded) && !(flags & blurServerSide))
175 if ((flags & tintNeeded) && !(flags & tintServerSide))
182 # ifdef BG_IMAGE_FROM_FILE
184 check_set_scale_value (int geom_flags, int flag, unsigned int &scale, unsigned int new_value)
186 if (geom_flags & flag)
188 if (new_value > 1000)
190 if (new_value != scale)
200 check_set_align_value (int geom_flags, int flag, int &align, int new_value)
202 if (geom_flags & flag)
204 if (new_value != bgPixmap_t::rootAlign)
206 if (new_value < -100)
208 else if (new_value > 200)
211 if (new_value != align)
221 make_align_position (int align, int window_size, int image_size)
223 int diff = window_size - image_size;
224 int smaller = MIN (image_size,window_size);
226 if (align >= 0 && align <= 50)
227 return diff * align / 100;
228 else if (align > 50 && align <= 100)
229 return window_size - image_size - diff * (100 - align) / 100;
230 else if (align > 100 && align <= 200 )
231 return ((align - 100) * smaller / 100) + window_size - smaller;
232 else if (align > -100 && align < 0)
233 return ((align + 100) * smaller / 100) - image_size;
238 make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)
243 if (pos < 0 && size > target_size)
251 if (dst_pos + dst_size > target_size)
252 dst_size = target_size - dst_pos;
257 bgPixmap_t::set_geometry (const char *geom)
259 int geom_flags = 0, changed = 0;
261 unsigned int w = 0, h = 0;
263 unsigned long new_flags = (flags & (~geometryFlags));
265 # define MAXLEN_GEOM 256 /* could be longer than regular geometry string */
270 char str[MAXLEN_GEOM];
272 while (isspace(*geom)) ++geom;
273 if ((p = strchr (geom, ';')) == NULL)
274 p = strchr (geom, '\0');
280 new_flags |= geometrySet;
282 memcpy (str, geom, n);
286 else if (str[0] != 'x' && str[0] != 'X' && isalpha(str[0]))
291 ops = strchr (str, ':');
294 for (tmp = ops-1; tmp >= str && isspace(*tmp); --tmp);
296 if (ops == tmp) ++ops;
300 if (ops > str || ops == NULL)
302 /* we have geometry string - let's handle it prior to applying ops */
303 geom_flags = XParseGeometry (str, &x, &y, &w, &h);
305 if ((geom_flags & XValue) && !(geom_flags & YValue))
308 geom_flags |= YValue;
311 if (flags & geometrySet)
313 /* new geometry is an adjustment to the old one ! */
314 if ((geom_flags & WidthValue) && (geom_flags & HeightValue))
316 if (w == 0 && h != 0)
319 h = (v_scale * h) / 100;
321 else if (h == 0 && w != 0)
323 w = (h_scale * w) / 100;
327 if (geom_flags & XValue)
336 else /* setting up geometry from scratch */
338 if (!(geom_flags & XValue))
340 /* use default geometry - centered */
341 x = y = defaultAlign;
343 else if (!(geom_flags & YValue))
346 if ((geom_flags & (WidthValue|HeightValue)) == 0)
348 /* use default geometry - scaled */
349 w = h = defaultScale;
351 else if (geom_flags & WidthValue)
353 if (!(geom_flags & HeightValue))
359 } /* done parsing geometry string */
360 else if (!(flags & geometrySet))
362 /* default geometry - scaled and centered */
363 x = y = defaultAlign;
364 w = h = defaultScale;
367 if (!(flags & geometrySet))
368 geom_flags |= WidthValue|HeightValue|XValue|YValue;
374 while (*ops == ':' || isspace(*ops)) ++ops;
376 # define CHECK_GEOM_OPS(op_str) (strncasecmp (ops, (op_str), sizeof (op_str) - 1) == 0)
377 if (CHECK_GEOM_OPS ("tile"))
380 geom_flags |= WidthValue|HeightValue;
382 else if (CHECK_GEOM_OPS ("propscale"))
384 if (w == 0 && h == 0)
387 geom_flags |= WidthValue;
389 new_flags |= propScale;
391 else if (CHECK_GEOM_OPS ("hscale"))
393 if (w == 0) w = windowScale;
396 geom_flags |= WidthValue|HeightValue;
398 else if (CHECK_GEOM_OPS ("vscale"))
400 if (h == 0) h = windowScale;
403 geom_flags |= WidthValue|HeightValue;
405 else if (CHECK_GEOM_OPS ("scale"))
407 if (h == 0) h = windowScale;
408 if (w == 0) w = windowScale;
410 geom_flags |= WidthValue|HeightValue;
412 else if (CHECK_GEOM_OPS ("auto"))
416 geom_flags |= WidthValue|HeightValue|XValue|YValue;
418 else if (CHECK_GEOM_OPS ("root"))
422 geom_flags |= WidthValue|HeightValue|XValue|YValue;
424 # undef CHECK_GEOM_OPS
426 while (*ops != ':' && *ops != '\0') ++ops;
427 } /* done parsing ops */
430 if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) ++changed;
431 if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) ++changed;
432 if (check_set_align_value (geom_flags, XValue, h_align, x)) ++changed;
433 if (check_set_align_value (geom_flags, YValue, v_align, y)) ++changed;
436 if (new_flags != flags)
442 //fprintf (stderr, "flags = %lX, scale = %ux%u, align=%+d%+d\n",
443 // flags, h_scale, v_scale, h_align, v_align);
444 return (changed > 0);
447 # ifdef HAVE_AFTERIMAGE
449 bgPixmap_t::render_asim (ASImage *background, ARGB32 background_tint)
458 int target_width = target->szHint.width;
459 int target_height = target->szHint.height;
460 int new_pmap_width = target_width;
461 int new_pmap_height = target_height;
465 int w = h_scale * target_width / 100;
466 int h = v_scale * target_height / 100;
468 TIMING_TEST_START (asim);
472 if (h_align == rootAlign || v_align == rootAlign)
474 target->get_window_origin(x, y);
479 if (h_align != rootAlign)
480 x = make_align_position (h_align, target_width, w > 0 ? w : (int)original_asim->width);
482 if (v_align != rootAlign)
483 y = make_align_position (v_align, target_height, h > 0 ? h : (int)original_asim->height);
488 || y >= target_height
489 || (w > 0 && x + w <= 0)
490 || (h > 0 && y + h <= 0))
494 new_pmap_width = background->width;
495 new_pmap_height = background->height;
498 if (background_tint != TINT_LEAVE_SAME)
500 ASImage* tmp = tile_asimage (target->asv, background, 0, 0,
501 target_width, target_height, background_tint,
502 ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
508 new_pmap_width = new_pmap_height = 0;
512 result = original_asim;
514 if ((w > 0 && w != original_asim->width)
515 || (h > 0 && h != original_asim->height))
517 result = scale_asimage (target->asv, original_asim,
518 w > 0 ? w : original_asim->width,
519 h > 0 ? h : original_asim->height,
520 background ? ASA_ASImage : ASA_XImage,
521 100, ASIMAGE_QUALITY_DEFAULT);
524 if (background == NULL)
526 /* if tiling - pixmap has to be sized exactly as the image,
527 but there is no need to make it bigger than the window! */
529 new_pmap_width = min (result->width, target_width);
531 new_pmap_height = min (result->height, target_height);
532 /* we also need to tile our image in one or both directions */
533 if (h_scale == 0 || v_scale == 0)
535 ASImage *tmp = tile_asimage (target->asv, result,
536 (h_scale > 0) ? 0 : (int)result->width - x,
537 (v_scale > 0) ? 0 : (int)result->height - y,
540 TINT_LEAVE_SAME, ASA_XImage,
541 100, ASIMAGE_QUALITY_DEFAULT);
544 if (result != original_asim)
545 destroy_asimage (&result);
553 /* if blending background and image - pixmap has to be sized same as target window */
554 ASImageLayer *layers = create_image_layers (2);
555 ASImage *merged_im = NULL;
557 layers[0].im = background;
558 layers[0].clip_width = target_width;
559 layers[0].clip_height = target_height;
560 layers[0].tint = background_tint;
561 layers[1].im = result;
565 /* tile horizontally */
566 while (x > 0) x -= (int)result->width;
568 layers[1].clip_width = result->width+target_width;
572 /* clip horizontally */
574 layers[1].clip_width = result->width;
579 while (y > 0) y -= (int)result->height;
581 layers[1].clip_height = result->height + target_height;
586 layers[1].clip_height = result->height;
589 if (target->rs[Rs_blendtype])
591 layers[1].merge_scanlines = blend_scanlines_name2func (target->rs[Rs_blendtype]);
592 if (layers[1].merge_scanlines == NULL)
593 layers[1].merge_scanlines = alphablend_scanlines;
596 ASImage *tmp = merge_layers (target->asv, layers, 2, target_width, target_height,
597 ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
601 if (result != original_asim)
602 destroy_asimage (&result);
610 TIMING_TEST_PRINT_RESULT (asim);
615 || pmap_width != new_pmap_width
616 || pmap_height != new_pmap_height
617 || pmap_depth != target->depth)
619 XFreePixmap (target->dpy, pixmap);
632 pixmap = XCreatePixmap (target->dpy, target->vt, new_pmap_width, new_pmap_height, target->depth);
633 pmap_width = new_pmap_width;
634 pmap_height = new_pmap_height;
635 pmap_depth = target->depth;
637 /* fill with background color ( if result's not completely overlapping it)*/
638 gcv.foreground = target->pix_colors[Color_bg];
639 gc = XCreateGC (target->dpy, target->vt, GCForeground, &gcv);
641 int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
642 int dst_width = result->width, dst_height = result->height;
643 if (background == NULL)
645 if (h_scale > 0) src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );
646 if (v_scale > 0) src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
648 if (dst_x > 0 || dst_y > 0
649 || dst_x + dst_width < new_pmap_width
650 || dst_y + dst_height < new_pmap_height)
651 XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
654 /* put result on pixmap */
655 if (dst_x < new_pmap_width && dst_y < new_pmap_height)
656 asimage2drawable (target->asv, pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);
658 if (result != background && result != original_asim)
659 destroy_asimage (&result);
661 XFreeGC (target->dpy, gc);
662 TIMING_TEST_PRINT_RESULT (asim);
667 # endif /* HAVE_AFTERIMAGE */
670 bgPixmap_t::set_file (const char *file)
676 # ifdef HAVE_AFTERIMAGE
677 if (!target->asimman)
678 target->asimman = create_generic_imageman (target->rs[Rs_path]);
680 if (const char *p = strchr (file, ';'))
682 size_t len = p - file;
683 char *f = (char *)malloc (len + 1);
684 memcpy (f, file, len);
686 original_asim = get_asimage (target->asimman, f, 0xFFFFFFFF, 100);
690 original_asim = get_asimage (target->asimman, file, 0xFFFFFFFF, 100);
692 return original_asim;
699 # endif /* BG_IMAGE_FROM_FILE */
701 # ifdef ENABLE_TRANSPARENCY
703 bgPixmap_t::set_transparent ()
705 if (!(flags & isTransparent))
707 flags |= isTransparent;
715 bgPixmap_t::set_blur_radius (const char *geom)
720 int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr);
722 if (!(geom_flags&WidthValue))
724 if (!(geom_flags&HeightValue))
727 if (h_blurRadius != hr)
733 if (v_blurRadius != vr)
739 if (v_blurRadius == 0 && h_blurRadius == 0)
740 flags &= ~blurNeeded;
747 static inline unsigned long
748 compute_tint_shade_flags (rxvt_color *tint, int shade)
750 unsigned long flags = 0;
751 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
752 bool has_shade = (shade > 0 && shade < 100) || (shade > 100 && shade < 200);
757 # define IS_COMPONENT_WHOLESOME(cmp) ((cmp) <= 0x000700 || (cmp) >= 0x00f700)
758 if (!has_shade && IS_COMPONENT_WHOLESOME (c.r)
759 && IS_COMPONENT_WHOLESOME (c.g)
760 && IS_COMPONENT_WHOLESOME (c.b))
761 flags |= bgPixmap_t::tintWholesome;
762 # undef IS_COMPONENT_WHOLESOME
766 flags |= bgPixmap_t::tintNeeded;
769 if ((c.r > 0x000700 || c.g > 0x000700 || c.b > 0x000700)
770 && (c.r < 0x00f700 || c.g < 0x00f700 || c.b < 0x00f700))
772 flags |= bgPixmap_t::tintNeeded;
776 if (flags & bgPixmap_t::tintNeeded)
778 if (flags & bgPixmap_t::tintWholesome)
779 flags |= bgPixmap_t::tintServerSide;
783 flags |= bgPixmap_t::tintServerSide;
792 bgPixmap_t::set_tint (rxvt_color &new_tint)
794 if (tint != new_tint)
796 unsigned long new_flags = compute_tint_shade_flags (&new_tint, shade);
798 flags = (flags & ~tintFlags) | new_flags | tintSet;
806 bgPixmap_t::unset_tint ()
808 unsigned long new_flags = compute_tint_shade_flags (NULL, shade);
810 if (new_flags != (flags & tintFlags))
812 flags = (flags&~tintFlags)|new_flags;
820 bgPixmap_t::set_shade (const char *shade_str)
822 int new_shade = (shade_str) ? atoi (shade_str) : 0;
824 if (new_shade < 0 && new_shade > -100)
825 new_shade = 200 - (100 + new_shade);
826 else if (new_shade == 100)
829 if (new_shade != shade)
831 unsigned long new_flags = compute_tint_shade_flags ((flags & tintSet) ? &tint : NULL, new_shade);
833 flags = (flags & (~tintFlags | tintSet)) | new_flags;
840 /* make_transparency_pixmap()
841 * Builds a pixmap sized the same as terminal window, with depth same as the root window
842 * that pixmap contains tiled portion of the root pixmap that is supposed to be covered by
846 bgPixmap_t::make_transparency_pixmap ()
848 unsigned long result = 0;
853 /* root dimentions may change from call to call - but Display structure should
854 * be always up-to-date, so let's use it :
856 Window root = target->display->root;
857 int screen = target->display->screen;
858 Display *dpy = target->dpy;
859 int root_width = DisplayWidth (dpy, screen);
860 int root_height = DisplayHeight (dpy, screen);
861 unsigned int root_pmap_width, root_pmap_height;
862 int window_width = target->szHint.width;
863 int window_height = target->szHint.height;
867 TIMING_TEST_START (tp);
868 target->get_window_origin (sx, sy);
870 /* check if we are outside of the visible part of the virtual screen : */
871 if (sx + window_width <= 0 || sy + window_height <= 0
872 || sx >= root_width || sy >= root_height)
875 if (root_pixmap != None)
877 /* we want to validate the pixmap and get it's size at the same time : */
880 /* root pixmap may be bad - allow a error */
881 target->allowedxerror = -1;
883 if (!XGetGeometry (dpy, root_pixmap, &root, &junk, &junk, &root_pmap_width, &root_pmap_height, &ujunk, &ujunk))
886 target->allowedxerror = 0;
889 Pixmap tiled_root_pmap = XCreatePixmap (dpy, root, window_width, window_height, root_depth);
892 if (tiled_root_pmap == None) /* something really bad happened - abort */
895 if (root_pixmap == None)
897 /* use tricks to obtain the root background image :*/
898 /* we want to create Overrideredirect window overlapping out window
899 with background type of Parent Relative and then grab it */
900 XSetWindowAttributes attr;
902 bool success = false;
904 attr.background_pixmap = ParentRelative;
905 attr.backing_store = Always;
906 attr.event_mask = ExposureMask;
907 attr.override_redirect = True;
908 src = XCreateWindow (dpy, root, sx, sy, window_width, window_height, 0,
909 CopyFromParent, CopyFromParent, CopyFromParent,
910 CWBackPixmap|CWBackingStore|CWOverrideRedirect|CWEventMask,
918 XMapRaised (dpy, src);
921 /* XSync should get window where it's properly exposed,
922 * but to be on the safe side - let's check for the actual event to arrive : */
923 while (XCheckWindowEvent (dpy, src, ExposureMask, &event))
928 /* hooray! - we can grab the image! */
929 gc = XCreateGC (dpy, root, 0, NULL);
932 XCopyArea (dpy, src, tiled_root_pmap, gc, 0, 0, window_width, window_height, 0, 0);
937 XDestroyWindow (dpy, src);
939 //fprintf (stderr, "%s:%d: ev_count = %d\n", __FUNCTION__, __LINE__, ev_count);
944 XFreePixmap (dpy, tiled_root_pmap);
945 tiled_root_pmap = None;
948 result |= transpPmapTiled;
952 /* strightforward pixmap copy */
953 gcv.tile = root_pixmap;
954 gcv.fill_style = FillTiled;
956 while (sx < 0) sx += (int)root_width;
957 while (sy < 0) sy += (int)root_height;
959 gcv.ts_x_origin = -sx;
960 gcv.ts_y_origin = -sy;
961 gc = XCreateGC (dpy, root, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
965 XFillRectangle (dpy, tiled_root_pmap, gc, 0, 0, window_width, window_height);
966 result |= transpPmapTiled;
969 TIMING_TEST_PRINT_RESULT (tp);
971 if (tiled_root_pmap != None)
973 if (!need_client_side_rendering ())
975 if ((flags & tintNeeded))
977 if (flags & tintWholesome)
979 /* In this case we can tint image server-side getting significant
980 * performance improvements, as we eliminate XImage transfer
982 gcv.foreground = Pixel (tint);
983 gcv.function = GXand;
984 gcv.fill_style = FillSolid;
986 XChangeGC (dpy, gc, GCFillStyle | GCForeground | GCFunction, &gcv);
988 gc = XCreateGC (dpy, root, GCFillStyle | GCForeground | GCFunction, &gcv);
991 XFillRectangle (dpy, tiled_root_pmap, gc, 0, 0, window_width, window_height);
992 result |= transpPmapTinted;
998 Picture back_pic = 0;
999 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1001 if (flags & tintSet)
1004 if (shade > 0 && shade < 100)
1006 c.r = (c.r * shade) / 100;
1007 c.g = (c.g * shade) / 100;
1008 c.b = (c.b * shade) / 100;
1010 else if (shade > 100 && shade < 200)
1012 c.r = (c.r * (200 - shade)) / 100;
1013 c.g = (c.g * (200 - shade)) / 100;
1014 c.b = (c.b * (200 - shade)) / 100;
1017 XRenderPictFormat pf;
1018 pf.type = PictTypeDirect;
1020 pf.direct.redMask = 0xff;
1021 pf.direct.greenMask = 0xff;
1022 pf.direct.blueMask = 0xff;
1023 pf.direct.alphaMask = 0xff;
1025 XRenderPictFormat *solid_format = XRenderFindFormat (dpy,
1029 PictFormatGreenMask|
1031 PictFormatAlphaMask),
1034 XRenderPictFormat *root_format = XRenderFindVisualFormat (dpy, DefaultVisualOfScreen (ScreenOfDisplay (dpy, target->display->screen)));
1035 XRenderPictureAttributes pa ;
1037 back_pic = XRenderCreatePicture (dpy, tiled_root_pmap, root_format, 0, &pa);
1041 Pixmap overlay_pmap = XCreatePixmap (dpy, root, 1, 1, 32);
1042 Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1043 XFreePixmap (dpy, overlay_pmap);
1045 pa.component_alpha = True;
1046 Pixmap mask_pmap = XCreatePixmap (dpy, root, 1, 1, 32);
1047 Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat|CPComponentAlpha, &pa);
1048 XFreePixmap (dpy, mask_pmap);
1050 if (mask_pic && overlay_pic && back_pic)
1052 XRenderColor mask_c;
1054 memset (&mask_c, (shade > 100) ? 0xFF : 0x0, sizeof (mask_c));
1055 mask_c.alpha = 0xffff;
1056 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1059 mask_c.red = 0xffff - c.r;
1060 mask_c.green = 0xffff - c.g;
1061 mask_c.blue = 0xffff - c.b;
1062 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
1063 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, window_width, window_height);
1064 result |= transpPmapTinted;
1067 XRenderFreePicture (dpy, mask_pic);
1068 XRenderFreePicture (dpy, overlay_pic);
1069 XRenderFreePicture (dpy, back_pic);
1076 } /* server side rendering completed */
1079 XFreePixmap (dpy, pixmap);
1081 pixmap = tiled_root_pmap;
1082 pmap_width = window_width;
1083 pmap_height = window_height;
1084 pmap_depth = root_depth;
1090 TIMING_TEST_PRINT_RESULT (tp);
1096 bgPixmap_t::set_root_pixmap ()
1098 Pixmap new_root_pixmap = target->get_pixmap_property (XA_XROOTPMAP_ID);
1099 if (new_root_pixmap == None)
1100 new_root_pixmap = target->get_pixmap_property (XA_ESETROOT_PMAP_ID);
1102 if (new_root_pixmap != root_pixmap)
1104 root_pixmap = new_root_pixmap;
1110 # endif /* ENABLE_TRANSPARENCY */
1112 # ifndef HAVE_AFTERIMAGE
1113 static void ShadeXImage(rxvt_term *term, XImage* srcImage, int shade, int rm, int gm, int bm);
1117 bgPixmap_t::render ()
1119 unsigned long background_flags = 0;
1124 TIMING_TEST_START (tp);
1127 # ifdef ENABLE_TRANSPARENCY
1128 if (flags & isTransparent)
1130 /* we need to re-generate transparency pixmap in that case ! */
1131 background_flags = make_transparency_pixmap ();
1132 if (background_flags == 0)
1134 else if ((background_flags & transpTransformations) == (flags & transpTransformations)
1135 && pmap_depth == target->depth)
1136 flags = flags & ~isInvalid;
1140 XImage *result = NULL;
1141 # ifdef HAVE_AFTERIMAGE
1143 || (background_flags & transpTransformations) != (flags & transpTransformations))
1145 target->init_asv ();
1147 ASImage *background = NULL;
1148 ARGB32 as_tint = TINT_LEAVE_SAME;
1149 if (background_flags)
1150 background = pixmap2ximage (target->asv, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, 100);
1152 # ifdef ENABLE_TRANSPARENCY
1153 if (!(background_flags & transpPmapTinted) && (flags & tintNeeded))
1155 ShadingInfo as_shade;
1156 as_shade.shading = (shade == 0) ? 100 : shade;
1158 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1159 if (flags & tintSet)
1161 as_shade.tintColor.red = c.r;
1162 as_shade.tintColor.green = c.g;
1163 as_shade.tintColor.blue = c.b;
1165 as_tint = shading2tint32 (&as_shade);
1168 if (!(background_flags & transpPmapBlured) && (flags & blurNeeded) && background != NULL)
1170 ASImage* tmp = blur_asimage_gauss (target->asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,
1171 (original_asim == NULL || tint == TINT_LEAVE_SAME)?ASA_XImage:ASA_ASImage,
1172 100, ASIMAGE_QUALITY_DEFAULT);
1175 destroy_asimage (&background);
1181 if (render_asim (background, as_tint))
1182 flags = flags & ~isInvalid;
1184 destroy_asimage (&background);
1186 else if (background_flags && pmap_depth != target->depth)
1187 result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap);
1189 # elif !XFT /* our own client-side tinting */
1191 /* ATTENTION: We ASSUME that XFT will let us do all the tinting neccessary server-side.
1192 This may need to be changed in need_client_side_rendering() logic is altered !!! */
1194 if (background_flags && (flags & isInvalid))
1196 result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap);
1198 if (result != NULL && !(background_flags & transpPmapTinted) && (flags & tintNeeded))
1200 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1201 if (flags & tintSet)
1203 ShadeXImage (target, result, shade, c.r, c.g, c.b);
1206 # endif /* HAVE_AFTERIMAGE */
1210 GC gc = XCreateGC (target->dpy, target->vt, 0UL, NULL);
1214 if (/*pmap_depth != target->depth &&*/ pixmap != None)
1216 XFreePixmap (target->dpy, pixmap);
1222 pixmap = XCreatePixmap (target->dpy, target->vt, result->width, result->height, target->depth);
1223 pmap_width = result->width;
1224 pmap_height = result->height;
1225 pmap_depth = target->depth;
1228 if (pmap_depth != result->depth)
1230 /* Bad Match error will ensue ! stupid X !!!! */
1231 if (result->depth == 24 && pmap_depth == 32)
1233 else if (result->depth == 32 && pmap_depth == 24)
1237 /* TODO: implement image recoding */
1241 if (pmap_depth == result->depth)
1242 XPutImage (target->dpy, pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1244 XFreeGC (target->dpy, gc);
1245 flags = flags & ~isInvalid;
1248 XDestroyImage (result);
1251 if (flags & isInvalid)
1255 XFreePixmap (target->dpy, pixmap);
1262 XSync (target->dpy, False);
1263 valid_since = ev::now ();
1265 TIMING_TEST_PRINT_RESULT (tp);
1271 bgPixmap_t::set_target (rxvt_term *new_target)
1274 if (target != new_target)
1276 target = new_target;
1277 # ifdef ENABLE_TRANSPARENCY
1278 root_depth = DefaultDepthOfScreen (ScreenOfDisplay (target->dpy, target->display->screen));
1287 bgPixmap_t::apply ()
1291 flags &= ~isVtOrigin;
1295 /* set target's background to pixmap */
1296 # ifdef ENABLE_TRANSPARENCY
1297 if (flags & isTransparent)
1299 XSetWindowBackgroundPixmap (target->dpy, target->parent[0], pixmap);
1300 XSetWindowBackgroundPixmap (target->dpy, target->vt, ParentRelative);
1302 if (target->scrollBar.win)
1303 XSetWindowBackgroundPixmap (target->dpy, target->scrollBar.win, ParentRelative);
1308 flags |= isVtOrigin;
1309 /* force old pixmap dereference in case it was transparent before :*/
1310 XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
1311 XSetWindowBackgroundPixmap (target->dpy, target->vt, pixmap);
1312 /* do we also need to set scrollbar's background here ? */
1314 if (target->scrollBar.win)
1315 XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);
1320 /* set target background to a pixel */
1321 XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
1322 XSetWindowBackground (target->dpy, target->vt, target->pix_colors[Color_bg]);
1323 /* do we also need to set scrollbar's background here ? */
1324 if (target->scrollBar.win)
1325 XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);
1328 /* don't want Expose on the parent or vt. It is better to use
1329 scr_touch or we get a great deal of flicker otherwise: */
1330 XClearWindow (target->dpy, target->parent[0]);
1332 if (target->scrollBar.state && target->scrollBar.win)
1334 target->scrollBar.state = STATE_IDLE;
1335 target->scrollBar.show (0);
1338 target->want_refresh = 1;
1339 flags |= hasChanged;
1343 #endif /* HAVE_BG_PIXMAP */
1345 #if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) && !XFT
1346 /* taken from aterm-0.4.2 */
1348 typedef uint32_t RUINT32T;
1351 ShadeXImage(rxvt_term *term, XImage* srcImage, int shade, int rm, int gm, int bm)
1353 int sh_r, sh_g, sh_b;
1354 RUINT32T mask_r, mask_g, mask_b;
1355 RUINT32T *lookup, *lookup_r, *lookup_g, *lookup_b;
1356 unsigned int lower_lim_r, lower_lim_g, lower_lim_b;
1357 unsigned int upper_lim_r, upper_lim_g, upper_lim_b;
1360 Visual *visual = term->visual;
1362 if (visual->c_class != TrueColor || srcImage->format != ZPixmap) return ;
1367 /* for convenience */
1368 mask_r = visual->red_mask;
1369 mask_g = visual->green_mask;
1370 mask_b = visual->blue_mask;
1372 /* boring lookup table pre-initialization */
1373 switch (srcImage->bits_per_pixel) {
1375 if ((mask_r != 0x7c00) ||
1376 (mask_g != 0x03e0) ||
1379 lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(32+32+32));
1381 lookup_g = lookup+32;
1382 lookup_b = lookup+32+32;
1388 if ((mask_r != 0xf800) ||
1389 (mask_g != 0x07e0) ||
1392 lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(32+64+32));
1394 lookup_g = lookup+32;
1395 lookup_b = lookup+32+64;
1401 if ((mask_r != 0xff0000) ||
1402 (mask_g != 0x00ff00) ||
1403 (mask_b != 0x0000ff))
1405 lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(256+256+256));
1407 lookup_g = lookup+256;
1408 lookup_b = lookup+256+256;
1414 if ((mask_r != 0xff0000) ||
1415 (mask_g != 0x00ff00) ||
1416 (mask_b != 0x0000ff))
1418 lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(256+256+256));
1420 lookup_g = lookup+256;
1421 lookup_b = lookup+256+256;
1427 return; /* we do not support this color depth */
1430 /* prepare limits for color transformation (each channel is handled separately) */
1433 if (shade < 0) shade = 0;
1434 if (shade > 100) shade = 100;
1436 lower_lim_r = 65535-rm;
1437 lower_lim_g = 65535-gm;
1438 lower_lim_b = 65535-bm;
1440 lower_lim_r = 65535-(unsigned int)(((RUINT32T)lower_lim_r)*((RUINT32T)shade)/100);
1441 lower_lim_g = 65535-(unsigned int)(((RUINT32T)lower_lim_g)*((RUINT32T)shade)/100);
1442 lower_lim_b = 65535-(unsigned int)(((RUINT32T)lower_lim_b)*((RUINT32T)shade)/100);
1444 upper_lim_r = upper_lim_g = upper_lim_b = 65535;
1446 if (shade < 0) shade = 0;
1447 if (shade > 100) shade = 100;
1449 lower_lim_r = lower_lim_g = lower_lim_b = 0;
1451 upper_lim_r = (unsigned int)((((RUINT32T)rm)*((RUINT32T)shade))/100);
1452 upper_lim_g = (unsigned int)((((RUINT32T)gm)*((RUINT32T)shade))/100);
1453 upper_lim_b = (unsigned int)((((RUINT32T)bm)*((RUINT32T)shade))/100);
1456 /* switch red and blue bytes if necessary, we need it for some weird XServers like XFree86 3.3.3.1 */
1457 if ((srcImage->bits_per_pixel == 24) && (mask_r >= 0xFF0000 ))
1462 lower_lim_r = lower_lim_b;
1466 upper_lim_r = upper_lim_b;
1470 /* fill our lookup tables */
1471 for (i = 0; i <= mask_r>>sh_r; i++)
1474 tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_r-lower_lim_r));
1475 tmp += ((RUINT32T)(mask_r>>sh_r))*((RUINT32T)lower_lim_r);
1476 lookup_r[i] = (tmp/65535)<<sh_r;
1478 for (i = 0; i <= mask_g>>sh_g; i++)
1481 tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_g-lower_lim_g));
1482 tmp += ((RUINT32T)(mask_g>>sh_g))*((RUINT32T)lower_lim_g);
1483 lookup_g[i] = (tmp/65535)<<sh_g;
1485 for (i = 0; i <= mask_b>>sh_b; i++)
1488 tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_b-lower_lim_b));
1489 tmp += ((RUINT32T)(mask_b>>sh_b))*((RUINT32T)lower_lim_b);
1490 lookup_b[i] = (tmp/65535)<<sh_b;
1493 /* apply table to input image (replacing colors by newly calculated ones) */
1494 switch (srcImage->bits_per_pixel)
1498 unsigned short *p1, *pf, *p, *pl;
1499 p1 = (unsigned short *) srcImage->data;
1500 pf = (unsigned short *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
1504 pl = p1 + srcImage->width;
1507 *p = lookup_r[(*p & 0x7c00)>>10] |
1508 lookup_g[(*p & 0x03e0)>> 5] |
1509 lookup_b[(*p & 0x001f)];
1511 p1 = (unsigned short *) ((char *) p1 + srcImage->bytes_per_line);
1517 unsigned short *p1, *pf, *p, *pl;
1518 p1 = (unsigned short *) srcImage->data;
1519 pf = (unsigned short *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
1523 pl = p1 + srcImage->width;
1526 *p = lookup_r[(*p & 0xf800)>>11] |
1527 lookup_g[(*p & 0x07e0)>> 5] |
1528 lookup_b[(*p & 0x001f)];
1530 p1 = (unsigned short *) ((char *) p1 + srcImage->bytes_per_line);
1536 unsigned char *p1, *pf, *p, *pl;
1537 p1 = (unsigned char *) srcImage->data;
1538 pf = (unsigned char *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
1542 pl = p1 + srcImage->width * 3;
1543 for (; p < pl; p += 3)
1545 p[0] = lookup_r[(p[0] & 0xff0000)>>16];
1546 p[1] = lookup_r[(p[1] & 0x00ff00)>> 8];
1547 p[2] = lookup_r[(p[2] & 0x0000ff)];
1549 p1 = (unsigned char *) ((char *) p1 + srcImage->bytes_per_line);
1555 RUINT32T *p1, *pf, *p, *pl;
1556 p1 = (RUINT32T *) srcImage->data;
1557 pf = (RUINT32T *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
1562 pl = p1 + srcImage->width;
1565 *p = lookup_r[(*p & 0xff0000)>>16] |
1566 lookup_g[(*p & 0x00ff00)>> 8] |
1567 lookup_b[(*p & 0x0000ff)] |
1570 p1 = (RUINT32T *) ((char *) p1 + srcImage->bytes_per_line);
1578 #endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */