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.157 by sf-exg, Tue Aug 9 21:48:00 2011 UTC vs.
Revision 1.195 by sf-exg, Mon Jan 2 19:31:00 2012 UTC

… …
32 32
33#ifndef FilterConvolution 33#ifndef FilterConvolution
34#define FilterConvolution "convolution" 34#define FilterConvolution "convolution"
35#endif 35#endif
36 36
37/* 37#ifndef RepeatPad
38 * Pixmap geometry string interpretation : 38#define RepeatPad True
39 * Each geometry string contains zero or one scale/position 39#endif
40 * adjustment and may optionally be followed by a colon and one or more
41 * colon-delimited pixmap operations.
42 * The following table shows the valid geometry strings and their
43 * effects on the background image :
44 *
45 * WxH+X+Y Set scaling to W% by H%, and position to X% by Y%.
46 * W and H are percentages of the terminal window size.
47 * X and Y are also percentages; e.g., +50+50 centers
48 * the image in the window.
49 *
50 * Pixmap Operations : (should be prepended by a colon)
51 * tile Tile image. Scaling/position modifiers above will affect
52 * the tile size and origin.
53 * propscale When scaling, scale proportionally. That is, maintain the
54 * proper aspect ratio for the image. Any portion of the
55 * background not covered by the image is filled with the
56 * current background color.
57 * hscale Scale horizontally, tile vertically ?
58 * vscale Tile horizontally, scale vertically ?
59 * scale Scale both up and down
60 */
61 40
62#ifdef HAVE_BG_PIXMAP 41#ifdef HAVE_BG_PIXMAP
42# if XRENDER
43static Picture
44create_xrender_mask (Display *dpy, Drawable drawable, Bool argb, Bool component_alpha)
45{
46 Pixmap pixmap = XCreatePixmap (dpy, drawable, 1, 1, argb ? 32 : 8);
47
48 XRenderPictFormat *format = XRenderFindStandardFormat (dpy, argb ? PictStandardARGB32 : PictStandardA8);
49 XRenderPictureAttributes pa;
50 pa.repeat = True;
51 pa.component_alpha = component_alpha;
52 Picture mask = XRenderCreatePicture (dpy, pixmap, format, CPRepeat | CPComponentAlpha, &pa);
53
54 XFreePixmap (dpy, pixmap);
55
56 return mask;
57}
58# endif
59
63void 60void
64rxvt_term::bg_destroy () 61rxvt_term::bg_destroy ()
65{ 62{
66#ifdef HAVE_AFTERIMAGE 63#ifdef HAVE_AFTERIMAGE
67 if (original_asim) 64 if (original_asim)
… …
175 int smaller = min (image_size, window_size); 172 int smaller = min (image_size, window_size);
176 173
177 if (align >= 0 && align <= 100) 174 if (align >= 0 && align <= 100)
178 return diff * align / 100; 175 return diff * align / 100;
179 else if (align > 100 && align <= 200) 176 else if (align > 100 && align <= 200)
180 return ((align - 100) * smaller / 100) + window_size - smaller; 177 return (align - 100) * smaller / 100 + window_size - smaller;
181 else if (align >= -100 && align < 0) 178 else if (align >= -100 && align < 0)
182 return ((align + 100) * smaller / 100) - image_size; 179 return (align + 100) * smaller / 100 - image_size;
183 return 0; 180 return 0;
184} 181}
185 182
186static inline int 183static inline int
187make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size) 184make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)
… …
206{ 203{
207 bool changed = false; 204 bool changed = false;
208 int geom_flags = 0; 205 int geom_flags = 0;
209 int x = 0, y = 0; 206 int x = 0, y = 0;
210 unsigned int w = 0, h = 0; 207 unsigned int w = 0, h = 0;
211 unsigned int n; 208 unsigned long new_flags = 0;
212 unsigned long new_flags = (bg_flags & (~BG_GEOMETRY_FLAGS));
213 const char *ops;
214 209
215 if (geom == NULL) 210 if (geom == NULL)
216 return false; 211 return false;
217 212
218 char str[256]; 213 if (geom[0])
219
220 ops = strchr (geom, ':');
221 if (ops == NULL)
222 n = strlen (geom);
223 else
224 n = ops - geom;
225
226 if (n >= sizeof (str))
227 return false;
228
229 memcpy (str, geom, n);
230 str[n] = '\0';
231 rxvt_strtrim (str);
232
233 if (str[0])
234 { 214 {
235 /* we have geometry string - let's handle it prior to applying ops */ 215 char **arr = rxvt_strsplit (':', geom);
216
217 for (int i = 0; arr[i]; i++)
218 {
219 if (!strcasecmp (arr[i], "style=tiled"))
220 {
221 new_flags = BG_TILE;
222 w = h = noScale;
223 x = y = 0;
224 geom_flags = WidthValue|HeightValue|XValue|YValue;
225 }
226 else if (!strcasecmp (arr[i], "style=aspect-stretched"))
227 {
228 new_flags = BG_KEEP_ASPECT;
229 w = h = windowScale;
230 x = y = centerAlign;
231 geom_flags = WidthValue|HeightValue|XValue|YValue;
232 }
233 else if (!strcasecmp (arr[i], "style=stretched"))
234 {
235 new_flags = 0;
236 w = h = windowScale;
237 geom_flags = WidthValue|HeightValue;
238 }
239 else if (!strcasecmp (arr[i], "style=centered"))
240 {
241 new_flags = 0;
242 w = h = noScale;
243 x = y = centerAlign;
244 geom_flags = WidthValue|HeightValue|XValue|YValue;
245 }
246 else if (!strcasecmp (arr[i], "style=root-tiled"))
247 {
248 new_flags = BG_TILE|BG_ROOT_ALIGN;
249 w = h = noScale;
250 geom_flags = WidthValue|HeightValue;
251 }
252 else if (!strcasecmp (arr[i], "op=tile"))
253 new_flags |= BG_TILE;
254 else if (!strcasecmp (arr[i], "op=keep-aspect"))
255 new_flags |= BG_KEEP_ASPECT;
256 else if (!strcasecmp (arr[i], "op=root-align"))
257 new_flags |= BG_ROOT_ALIGN;
258
259 // deprecated
260 else if (!strcasecmp (arr[i], "tile"))
261 {
262 new_flags |= BG_TILE;
263 w = h = noScale;
264 geom_flags |= WidthValue|HeightValue;
265 }
266 else if (!strcasecmp (arr[i], "propscale"))
267 {
268 new_flags |= BG_KEEP_ASPECT;
269 w = h = windowScale;
270 geom_flags |= WidthValue|HeightValue;
271 }
272 else if (!strcasecmp (arr[i], "hscale"))
273 {
274 new_flags |= BG_TILE;
275 w = windowScale;
276 h = noScale;
277 geom_flags |= WidthValue|HeightValue;
278 }
279 else if (!strcasecmp (arr[i], "vscale"))
280 {
281 new_flags |= BG_TILE;
282 h = windowScale;
283 w = noScale;
284 geom_flags |= WidthValue|HeightValue;
285 }
286 else if (!strcasecmp (arr[i], "scale"))
287 {
288 w = h = windowScale;
289 geom_flags |= WidthValue|HeightValue;
290 }
291 else if (!strcasecmp (arr[i], "auto"))
292 {
293 w = h = windowScale;
294 x = y = centerAlign;
295 geom_flags |= WidthValue|HeightValue|XValue|YValue;
296 }
297 else if (!strcasecmp (arr[i], "root"))
298 {
299 new_flags |= BG_TILE|BG_ROOT_ALIGN;
300 w = h = noScale;
301 geom_flags |= WidthValue|HeightValue;
302 }
303
304 else
236 geom_flags = XParseGeometry (str, &x, &y, &w, &h); 305 geom_flags |= XParseGeometry (arr[i], &x, &y, &w, &h);
237 } /* done parsing geometry string */ 306 } /* done parsing ops */
307
308 rxvt_free_strsplit (arr);
309 }
310
311 new_flags |= bg_flags & ~BG_GEOMETRY_FLAGS;
238 312
239 if (!update) 313 if (!update)
240 { 314 {
241 if (!(geom_flags & XValue)) 315 if (!(geom_flags & XValue))
242 x = y = defaultAlign; 316 x = y = defaultAlign;
… …
251 w = h; 325 w = h;
252 326
253 geom_flags |= WidthValue|HeightValue|XValue|YValue; 327 geom_flags |= WidthValue|HeightValue|XValue|YValue;
254 } 328 }
255 329
256 if (ops)
257 {
258 char **arr = rxvt_strsplit (':', ops + 1);
259
260 for (int i = 0; arr[i]; i++)
261 {
262 if (!strcasecmp (arr[i], "tile"))
263 {
264 new_flags |= BG_TILE;
265 w = h = noScale;
266 geom_flags |= WidthValue|HeightValue;
267 }
268 else if (!strcasecmp (arr[i], "propscale"))
269 {
270 new_flags |= BG_PROP_SCALE;
271 }
272 else if (!strcasecmp (arr[i], "hscale"))
273 {
274 if (w == 0) w = windowScale;
275
276 h = noScale;
277 geom_flags |= WidthValue|HeightValue;
278 }
279 else if (!strcasecmp (arr[i], "vscale"))
280 {
281 if (h == 0) h = windowScale;
282
283 w = noScale;
284 geom_flags |= WidthValue|HeightValue;
285 }
286 else if (!strcasecmp (arr[i], "scale"))
287 {
288 if (h == 0) h = windowScale;
289 if (w == 0) w = windowScale;
290
291 geom_flags |= WidthValue|HeightValue;
292 }
293 else if (!strcasecmp (arr[i], "root"))
294 {
295 new_flags |= BG_TILE|BG_ROOT_ALIGN;
296 w = h = noScale;
297 geom_flags |= WidthValue|HeightValue;
298 }
299 } /* done parsing ops */
300
301 rxvt_free_strsplit (arr);
302 }
303
304 if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true; 330 if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true;
305 if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true; 331 if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true;
306 if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true; 332 if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true;
307 if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true; 333 if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true;
308 334
… …
319rxvt_term::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y) 345rxvt_term::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y)
320{ 346{
321 int target_width = szHint.width; 347 int target_width = szHint.width;
322 int target_height = szHint.height; 348 int target_height = szHint.height;
323 349
350 w = h_scale * target_width / 100;
351 h = v_scale * target_height / 100;
352
324 if (bg_flags & BG_PROP_SCALE) 353 if (bg_flags & BG_KEEP_ASPECT)
325 { 354 {
326 float scale = (float)target_width / image_width; 355 float scale = (float)w / image_width;
327 min_it (scale, (float)target_height / image_height); 356 min_it (scale, (float)h / image_height);
328 w = image_width * scale + 0.5; 357 w = image_width * scale + 0.5;
329 h = image_height * scale + 0.5; 358 h = image_height * scale + 0.5;
330 } 359 }
331 else
332 {
333 w = h_scale * target_width / 100;
334 h = v_scale * target_height / 100;
335 }
336 360
337 if (!w) w = image_width; 361 if (!w) w = image_width;
338 if (!h) h = image_height; 362 if (!h) h = image_height;
339 363
340 if (bg_flags & BG_ROOT_ALIGN) 364 if (bg_flags & BG_ROOT_ALIGN)
… …
348 y = make_align_position (v_align, target_height, h); 372 y = make_align_position (v_align, target_height, h);
349 } 373 }
350 374
351 bg_flags &= ~BG_IS_SIZE_SENSITIVE; 375 bg_flags &= ~BG_IS_SIZE_SENSITIVE;
352 if (!(bg_flags & BG_TILE) 376 if (!(bg_flags & BG_TILE)
353 || (bg_flags & BG_PROP_SCALE) || h_scale || v_scale 377 || h_scale || v_scale
354 || (!(bg_flags & BG_ROOT_ALIGN) && (h_align || v_align)) 378 || (!(bg_flags & BG_ROOT_ALIGN) && (h_align || v_align))
355 || w > target_width || h > target_height) 379 || w > target_width || h > target_height)
356 bg_flags |= BG_IS_SIZE_SENSITIVE; 380 bg_flags |= BG_IS_SIZE_SENSITIVE;
357} 381}
358 382
… …
385 } 409 }
386 410
387 if ((tr_flags & BG_NEEDS_BLUR) && background != NULL) 411 if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)
388 { 412 {
389 ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF, 413 ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,
390 (original_asim == NULL || tint == TINT_LEAVE_SAME) ? ASA_XImage : ASA_ASImage, 414 ASA_XImage,
391 100, ASIMAGE_QUALITY_DEFAULT); 415 100, ASIMAGE_QUALITY_DEFAULT);
392 if (tmp) 416 if (tmp)
393 { 417 {
394 destroy_asimage (&background); 418 destroy_asimage (&background);
395 background = tmp; 419 background = tmp;
… …
414 438
415 if (!original_asim 439 if (!original_asim
416 || (!(bg_flags & BG_ROOT_ALIGN) 440 || (!(bg_flags & BG_ROOT_ALIGN)
417 && (x >= target_width 441 && (x >= target_width
418 || y >= target_height 442 || y >= target_height
419 || (x + w <= 0) 443 || x + w <= 0
420 || (y + h <= 0)))) 444 || y + h <= 0)))
421 { 445 {
422 if (background) 446 if (background)
423 { 447 {
424 new_pmap_width = background->width; 448 new_pmap_width = background->width;
425 new_pmap_height = background->height; 449 new_pmap_height = background->height;
… …
439 } 463 }
440 else 464 else
441 { 465 {
442 result = original_asim; 466 result = original_asim;
443 467
444 if ((w != original_asim->width) 468 if (w != original_asim->width
445 || (h != original_asim->height)) 469 || h != original_asim->height)
446 { 470 {
447 result = scale_asimage (asv, original_asim, 471 result = scale_asimage (asv, original_asim,
448 w, h, 472 w, h,
449 background ? ASA_ASImage : ASA_XImage, 473 ASA_XImage,
450 100, ASIMAGE_QUALITY_DEFAULT); 474 100, ASIMAGE_QUALITY_DEFAULT);
451 } 475 }
452 476
453 if (background == NULL) 477 if (background == NULL)
454 { 478 {
… …
704 get_image_geometry (image_width, image_height, w, h, x, y); 728 get_image_geometry (image_width, image_height, w, h, x, y);
705 729
706 if (!(bg_flags & BG_ROOT_ALIGN) 730 if (!(bg_flags & BG_ROOT_ALIGN)
707 && (x >= target_width 731 && (x >= target_width
708 || y >= target_height 732 || y >= target_height
709 || (x + w <= 0) 733 || x + w <= 0
710 || (y + h <= 0))) 734 || y + h <= 0))
711 return false; 735 return false;
712 736
713 result = pixbuf; 737 result = pixbuf;
714 738
715 if ((w != image_width) 739 if (w != image_width
716 || (h != image_height)) 740 || h != image_height)
717 { 741 {
718 result = gdk_pixbuf_scale_simple (pixbuf, 742 result = gdk_pixbuf_scale_simple (pixbuf,
719 w, h, 743 w, h,
720 GDK_INTERP_BILINEAR); 744 GDK_INTERP_BILINEAR);
721 } 745 }
… …
800 } 824 }
801 825
802#if XRENDER 826#if XRENDER
803 if (tr_flags) 827 if (tr_flags)
804 { 828 {
805 XRenderPictureAttributes pa;
806
807 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, visual); 829 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
830
808 Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa); 831 Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
809 832
810 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
811 Picture dst = XRenderCreatePicture (dpy, bg_pixmap, dst_format, 0, &pa); 833 Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
812 834
813 pa.repeat = True; 835 Picture mask = create_xrender_mask (dpy, vt, False, False);
814 Pixmap mask_pmap = XCreatePixmap (dpy, vt, 1, 1, 8);
815 XRenderPictFormat *mask_format = XRenderFindStandardFormat (dpy, PictStandardA8);
816 Picture mask = XRenderCreatePicture (dpy, mask_pmap, mask_format, CPRepeat, &pa);
817 XFreePixmap (dpy, mask_pmap);
818 836
819 XRenderColor mask_c; 837 XRenderColor mask_c;
820 838
821 mask_c.alpha = 0x8000; 839 mask_c.alpha = 0x8000;
822 mask_c.red = 0; 840 mask_c.red =
823 mask_c.green = 0; 841 mask_c.green =
824 mask_c.blue = 0; 842 mask_c.blue = 0;
825 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1); 843 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
844
826 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height); 845 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
827 846
828 XRenderFreePicture (dpy, src); 847 XRenderFreePicture (dpy, src);
829 XRenderFreePicture (dpy, dst); 848 XRenderFreePicture (dpy, dst);
830 XRenderFreePicture (dpy, mask); 849 XRenderFreePicture (dpy, mask);
… …
850rxvt_term::bg_set_file (const char *file) 869rxvt_term::bg_set_file (const char *file)
851{ 870{
852 if (!file || !*file) 871 if (!file || !*file)
853 return false; 872 return false;
854 873
874 bool ret = false;
855 if (const char *p = strchr (file, ';')) 875 const char *p = strchr (file, ';');
876
877 if (p)
856 { 878 {
857 size_t len = p - file; 879 size_t len = p - file;
858 char *f = rxvt_temp_buf<char> (len + 1); 880 char *f = rxvt_temp_buf<char> (len + 1);
859 memcpy (f, file, len); 881 memcpy (f, file, len);
860 f[len] = '\0'; 882 f[len] = '\0';
… …
869 { 891 {
870 if (original_asim) 892 if (original_asim)
871 safe_asimage_destroy (original_asim); 893 safe_asimage_destroy (original_asim);
872 original_asim = image; 894 original_asim = image;
873 bg_flags |= BG_IS_FROM_FILE | BG_CLIENT_RENDER; 895 bg_flags |= BG_IS_FROM_FILE | BG_CLIENT_RENDER;
874 return true; 896 ret = true;
875 } 897 }
876# endif 898# endif
877 899
878# ifdef HAVE_PIXBUF 900# ifdef HAVE_PIXBUF
879 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL); 901 GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
… …
881 { 903 {
882 if (pixbuf) 904 if (pixbuf)
883 g_object_unref (pixbuf); 905 g_object_unref (pixbuf);
884 pixbuf = image; 906 pixbuf = image;
885 bg_flags |= BG_IS_FROM_FILE; 907 bg_flags |= BG_IS_FROM_FILE;
886 return true; 908 ret = true;
887 } 909 }
888# endif 910# endif
889 911
912 if (ret)
913 {
914 if (p)
915 bg_set_geometry (p + 1);
916 else
917 bg_set_default_geometry ();
918 }
919
890 return false; 920 return ret;
891} 921}
892 922
893# endif /* BG_IMAGE_FROM_FILE */ 923# endif /* BG_IMAGE_FROM_FILE */
894 924
895# ifdef ENABLE_TRANSPARENCY 925# ifdef ENABLE_TRANSPARENCY
… …
931 { 961 {
932 changed = true; 962 changed = true;
933 v_blurRadius = vr; 963 v_blurRadius = vr;
934 } 964 }
935 965
936 if (v_blurRadius == 0 && h_blurRadius == 0) 966 if (h_blurRadius == 0 || v_blurRadius == 0)
937 bg_flags &= ~BG_NEEDS_BLUR; 967 bg_flags &= ~BG_NEEDS_BLUR;
938 else 968 else
939 bg_flags |= BG_NEEDS_BLUR; 969 bg_flags |= BG_NEEDS_BLUR;
940 970
941 return changed; 971 return changed;
942} 972}
943 973
944void 974void
945rxvt_term::set_tint_shade_flags () 975rxvt_term::set_tint_shade_flags ()
946{ 976{
947 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 977 rgba c;
948 bool has_shade = shade != 100; 978 bool has_shade = shade != 100;
949 979
950 bg_flags &= ~BG_TINT_FLAGS; 980 bg_flags &= ~BG_TINT_FLAGS;
951 981
952 if (bg_flags & BG_TINT_SET) 982 if (bg_flags & BG_TINT_SET)
… …
978} 1008}
979 1009
980bool 1010bool
981rxvt_term::bg_set_shade (const char *shade_str) 1011rxvt_term::bg_set_shade (const char *shade_str)
982{ 1012{
983 int new_shade = (shade_str) ? atoi (shade_str) : 100; 1013 int new_shade = atoi (shade_str);
984 1014
985 clamp_it (new_shade, -100, 200); 1015 clamp_it (new_shade, -100, 200);
986 if (new_shade < 0) 1016 if (new_shade < 0)
987 new_shade = 200 - (100 + new_shade); 1017 new_shade = 200 - (100 + new_shade);
988 1018
… …
1022bool 1052bool
1023rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 1053rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1024{ 1054{
1025 bool ret = false; 1055 bool ret = false;
1026#if XRENDER 1056#if XRENDER
1057 if (!(bg_flags & BG_HAS_RENDER_CONV))
1058 return false;
1059
1027 int size = max (h_blurRadius, v_blurRadius) * 2 + 1; 1060 int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1028 double *kernel = (double *)malloc (size * sizeof (double)); 1061 double *kernel = (double *)malloc (size * sizeof (double));
1029 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 1062 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1030 1063
1031 XRenderPictureAttributes pa; 1064 XRenderPictureAttributes pa;
1032 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 1065 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1033 1066
1067 pa.repeat = RepeatPad;
1034 Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 1068 Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
1035 Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 1069 Picture dst = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
1036 1070
1037 if (kernel && params) 1071 if (kernel && params)
1038 { 1072 {
1039 if (h_blurRadius)
1040 {
1041 size = h_blurRadius * 2 + 1; 1073 size = h_blurRadius * 2 + 1;
1042 get_gaussian_kernel (h_blurRadius, size, kernel, params); 1074 get_gaussian_kernel (h_blurRadius, size, kernel, params);
1043 1075
1044 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 1076 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1045 XRenderComposite (dpy, 1077 XRenderComposite (dpy,
1046 PictOpSrc, 1078 PictOpSrc,
1047 src, 1079 src,
1048 None, 1080 None,
1049 dst, 1081 dst,
1050 0, 0, 1082 0, 0,
1051 0, 0, 1083 0, 0,
1052 0, 0, 1084 0, 0,
1053 width, height); 1085 width, height);
1054 }
1055 1086
1056 if (v_blurRadius)
1057 {
1058 size = v_blurRadius * 2 + 1; 1087 size = v_blurRadius * 2 + 1;
1059 get_gaussian_kernel (v_blurRadius, size, kernel, params); 1088 get_gaussian_kernel (v_blurRadius, size, kernel, params);
1060 ::swap (params[0], params[1]); 1089 ::swap (params[0], params[1]);
1061 1090
1062 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 1091 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1063 XRenderComposite (dpy, 1092 XRenderComposite (dpy,
1064 PictOpSrc, 1093 PictOpSrc,
1065 src, 1094 src,
1066 None, 1095 None,
1067 dst, 1096 dst,
1068 0, 0, 1097 0, 0,
1069 0, 0, 1098 0, 0,
1070 0, 0, 1099 0, 0,
1071 width, height); 1100 width, height);
1072 }
1073 1101
1074 ret = true; 1102 ret = true;
1075 } 1103 }
1076 1104
1077 free (kernel); 1105 free (kernel);
… …
1104 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height); 1132 XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1105 ret = true; 1133 ret = true;
1106 XFreeGC (dpy, gc); 1134 XFreeGC (dpy, gc);
1107 } 1135 }
1108 } 1136 }
1109 else
1110 {
1111# if XRENDER 1137# if XRENDER
1138 else if (bg_flags & BG_HAS_RENDER)
1139 {
1112 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC); 1140 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1113 1141
1114 if (bg_flags & BG_TINT_SET) 1142 if (bg_flags & BG_TINT_SET)
1115 tint.get (c); 1143 tint.get (c);
1116 1144
… …
1125 c.r = c.r * (200 - shade) / 100; 1153 c.r = c.r * (200 - shade) / 100;
1126 c.g = c.g * (200 - shade) / 100; 1154 c.g = c.g * (200 - shade) / 100;
1127 c.b = c.b * (200 - shade) / 100; 1155 c.b = c.b * (200 - shade) / 100;
1128 } 1156 }
1129 1157
1130 XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1131 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); 1158 XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1132 XRenderPictureAttributes pa;
1133 1159
1134 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa); 1160 Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1135 1161
1136 pa.repeat = True; 1162 Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1137 1163
1138 Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32); 1164 Picture mask_pic = create_xrender_mask (dpy, pixmap, True, True);
1139 Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1140 XFreePixmap (dpy, overlay_pmap);
1141
1142 pa.component_alpha = True;
1143 Pixmap mask_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
1144 Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat | CPComponentAlpha, &pa);
1145 XFreePixmap (dpy, mask_pmap);
1146 1165
1147 XRenderColor mask_c; 1166 XRenderColor mask_c;
1148 1167
1149 mask_c.alpha = 0xffff; 1168 mask_c.alpha = 0xffff;
1150 mask_c.red = 1169 mask_c.red =
… …
1155 mask_c.alpha = 0; 1174 mask_c.alpha = 0;
1156 mask_c.red = 0xffff - c.r; 1175 mask_c.red = 0xffff - c.r;
1157 mask_c.green = 0xffff - c.g; 1176 mask_c.green = 0xffff - c.g;
1158 mask_c.blue = 0xffff - c.b; 1177 mask_c.blue = 0xffff - c.b;
1159 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1); 1178 XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
1179
1160 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height); 1180 XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1161 1181
1162 if (shade > 100) 1182 if (shade > 100)
1163 { 1183 {
1164 mask_c.red = mask_c.green = mask_c.blue = 0xffff * (shade - 100) / 100;
1165 mask_c.alpha = 0; 1184 mask_c.alpha = 0;
1185 mask_c.red =
1186 mask_c.green =
1187 mask_c.blue = 0xffff * (shade - 100) / 100;
1166 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1); 1188 XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1167 1189
1168 XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height); 1190 XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1169 } 1191 }
1170 1192
1171 ret = true; 1193 ret = true;
1172 1194
1173 XRenderFreePicture (dpy, mask_pic); 1195 XRenderFreePicture (dpy, mask_pic);
1174 XRenderFreePicture (dpy, overlay_pic); 1196 XRenderFreePicture (dpy, overlay_pic);
1175 XRenderFreePicture (dpy, back_pic); 1197 XRenderFreePicture (dpy, back_pic);
1198 }
1176# endif 1199# endif
1177 }
1178 1200
1179 return ret; 1201 return ret;
1180} 1202}
1181 1203
1182/* 1204/*
… …
1233#if XRENDER 1255#if XRENDER
1234 if (bg_flags & BG_HAS_RENDER) 1256 if (bg_flags & BG_HAS_RENDER)
1235 { 1257 {
1236 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth); 1258 recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1237 1259
1238 XRenderPictureAttributes pa;
1239
1240 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen)); 1260 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1241 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa); 1261 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1242 1262
1243 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual); 1263 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1244 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa); 1264 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1245 1265
1246 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height); 1266 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
1247 1267
1248 XRenderFreePicture (dpy, src); 1268 XRenderFreePicture (dpy, src);
1249 XRenderFreePicture (dpy, dst); 1269 XRenderFreePicture (dpy, dst);
… …
1266 bg_pmap_width = window_width; 1286 bg_pmap_width = window_width;
1267 bg_pmap_height = window_height; 1287 bg_pmap_height = window_height;
1268 } 1288 }
1269 1289
1270 /* straightforward pixmap copy */ 1290 /* straightforward pixmap copy */
1271 while (sx < 0) sx += root_width; 1291 while (sx < 0) sx += root_pmap_width;
1272 while (sy < 0) sy += root_height; 1292 while (sy < 0) sy += root_pmap_height;
1273 1293
1274 gcv.tile = recoded_root_pmap; 1294 gcv.tile = recoded_root_pmap;
1275 gcv.fill_style = FillTiled; 1295 gcv.fill_style = FillTiled;
1276 gcv.ts_x_origin = -sx; 1296 gcv.ts_x_origin = -sx;
1277 gcv.ts_y_origin = -sy; 1297 gcv.ts_y_origin = -sy;
… …
1279 1299
1280 if (gc) 1300 if (gc)
1281 { 1301 {
1282 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height); 1302 XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1283 result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS); 1303 result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS);
1284 XFreeGC (dpy, gc);
1285 1304
1286 if (!(bg_flags & BG_CLIENT_RENDER)) 1305 if (!(bg_flags & BG_CLIENT_RENDER))
1287 { 1306 {
1288 if ((bg_flags & BG_NEEDS_BLUR) 1307 if (bg_flags & BG_NEEDS_BLUR)
1289 && (bg_flags & BG_HAS_RENDER_CONV))
1290 { 1308 {
1291 if (blur_pixmap (bg_pixmap, visual, window_width, window_height)) 1309 if (blur_pixmap (bg_pixmap, visual, window_width, window_height))
1292 result &= ~BG_NEEDS_BLUR; 1310 result &= ~BG_NEEDS_BLUR;
1293 } 1311 }
1294 if ((bg_flags & BG_NEEDS_TINT) 1312 if (bg_flags & BG_NEEDS_TINT)
1295 && (bg_flags & (BG_TINT_BITAND | BG_HAS_RENDER)))
1296 { 1313 {
1297 if (tint_pixmap (bg_pixmap, visual, window_width, window_height)) 1314 if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1298 result &= ~BG_NEEDS_TINT; 1315 result &= ~BG_NEEDS_TINT;
1299 } 1316 }
1317# ifndef HAVE_AFTERIMAGE
1318 if (result & BG_NEEDS_TINT)
1319 {
1320 XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1321 if (ximage)
1322 {
1323 /* our own client-side tinting */
1324 tint_ximage (DefaultVisual (dpy, display->screen), ximage);
1325
1326 XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
1327 XDestroyImage (ximage);
1328 }
1329 }
1330# endif
1300 } /* server side rendering completed */ 1331 } /* server side rendering completed */
1332
1333 XFreeGC (dpy, gc);
1301 } 1334 }
1302 1335
1303 if (recoded_root_pmap != root_pixmap) 1336 if (recoded_root_pmap != root_pixmap)
1304 XFreePixmap (dpy, recoded_root_pmap); 1337 XFreePixmap (dpy, recoded_root_pmap);
1305 1338
… …
1314 new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]); 1347 new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]);
1315 1348
1316 root_pixmap = new_root_pixmap; 1349 root_pixmap = new_root_pixmap;
1317} 1350}
1318# endif /* ENABLE_TRANSPARENCY */ 1351# endif /* ENABLE_TRANSPARENCY */
1319
1320#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1321static void shade_ximage (Visual *visual, XImage *ximage, int shade, const rgba &c);
1322# endif
1323 1352
1324bool 1353bool
1325rxvt_term::bg_render () 1354rxvt_term::bg_render ()
1326{ 1355{
1327 unsigned long tr_flags = 0; 1356 unsigned long tr_flags = 0;
… …
1332 { 1361 {
1333 /* we need to re-generate transparency pixmap in that case ! */ 1362 /* we need to re-generate transparency pixmap in that case ! */
1334 tr_flags = make_transparency_pixmap (); 1363 tr_flags = make_transparency_pixmap ();
1335 if (tr_flags == 0) 1364 if (tr_flags == 0)
1336 return false; 1365 return false;
1337 else if (!(tr_flags & BG_EFFECTS_FLAGS))
1338 bg_flags |= BG_IS_VALID; 1366 bg_flags |= BG_IS_VALID;
1339 } 1367 }
1340# endif 1368# endif
1341 1369
1342# ifdef BG_IMAGE_FROM_FILE 1370# ifdef BG_IMAGE_FROM_FILE
1343 if ((bg_flags & BG_IS_FROM_FILE) 1371 if ((bg_flags & BG_IS_FROM_FILE)
1344 || (tr_flags & BG_EFFECTS_FLAGS)) 1372 || (tr_flags & BG_EFFECTS_FLAGS))
1345 { 1373 {
1346 if (render_image (tr_flags)) 1374 if (render_image (tr_flags))
1347 bg_flags |= BG_IS_VALID; 1375 bg_flags |= BG_IS_VALID;
1348 }
1349# endif
1350
1351# if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1352 XImage *result = NULL;
1353
1354 if (tr_flags && !(bg_flags & BG_IS_VALID))
1355 {
1356 result = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1357 }
1358
1359 if (result)
1360 {
1361 /* our own client-side tinting */
1362 if (tr_flags & BG_NEEDS_TINT)
1363 {
1364 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1365 if (bg_flags & BG_TINT_SET)
1366 tint.get (c);
1367 shade_ximage (DefaultVisual (dpy, display->screen), result, shade, c);
1368 }
1369
1370 GC gc = XCreateGC (dpy, vt, 0UL, NULL);
1371
1372 if (gc)
1373 {
1374 XPutImage (dpy, bg_pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1375
1376 XFreeGC (dpy, gc);
1377 bg_flags |= BG_IS_VALID;
1378 }
1379
1380 XDestroyImage (result);
1381 } 1376 }
1382# endif 1377# endif
1383 1378
1384 if (!(bg_flags & BG_IS_VALID)) 1379 if (!(bg_flags & BG_IS_VALID))
1385 { 1380 {
… …
1423} 1418}
1424 1419
1425#endif /* HAVE_BG_PIXMAP */ 1420#endif /* HAVE_BG_PIXMAP */
1426 1421
1427#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) 1422#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1428/* taken from aterm-0.4.2 */ 1423/* based on code from aterm-0.4.2 */
1429 1424
1430static void 1425static inline void
1431shade_ximage (Visual *visual, XImage *ximage, int shade, const rgba &c) 1426fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
1427{
1428 for (int i = 0; i <= mask >> sh; i++)
1429 {
1430 uint32_t tmp;
1431 tmp = i * high;
1432 tmp += (mask >> sh) * low;
1433 lookup[i] = (tmp / 0xffff) << sh;
1434 }
1435}
1436
1437void
1438rxvt_term::tint_ximage (Visual *visual, XImage *ximage)
1432{ 1439{
1433 int sh_r, sh_g, sh_b; 1440 int sh_r, sh_g, sh_b;
1434 uint32_t mask_r, mask_g, mask_b; 1441 uint32_t mask_r, mask_g, mask_b;
1435 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b; 1442 uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1436 rgba low; 1443 unsigned short low;
1437 rgba high;
1438 int i;
1439 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst; 1444 int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1440 1445
1441 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return; 1446 if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;
1442 1447
1443 /* for convenience */ 1448 /* for convenience */
… …
1502 break; 1507 break;
1503 default: 1508 default:
1504 return; /* we do not support this color depth */ 1509 return; /* we do not support this color depth */
1505 } 1510 }
1506 1511
1512 rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1513
1514 if (bg_flags & BG_TINT_SET)
1515 tint.get (c);
1516
1507 /* prepare limits for color transformation (each channel is handled separately) */ 1517 /* prepare limits for color transformation (each channel is handled separately) */
1508 if (shade > 100) 1518 if (shade > 100)
1509 { 1519 {
1510 shade = 200 - shade;
1511
1512 high.r = c.r * shade / 100;
1513 high.g = c.g * shade / 100;
1514 high.b = c.b * shade / 100;
1515
1516 low.r = 65535 * (100 - shade) / 100; 1520 c.r = c.r * (200 - shade) / 100;
1517 low.g = 65535 * (100 - shade) / 100; 1521 c.g = c.g * (200 - shade) / 100;
1518 low.b = 65535 * (100 - shade) / 100; 1522 c.b = c.b * (200 - shade) / 100;
1523
1524 low = 0xffff * (shade - 100) / 100;
1519 } 1525 }
1520 else 1526 else
1521 { 1527 {
1522 high.r = c.r * shade / 100; 1528 c.r = c.r * shade / 100;
1523 high.g = c.g * shade / 100; 1529 c.g = c.g * shade / 100;
1524 high.b = c.b * shade / 100; 1530 c.b = c.b * shade / 100;
1525 1531
1526 low.r = low.g = low.b = 0; 1532 low = 0;
1527 } 1533 }
1528 1534
1529 /* fill our lookup tables */ 1535 /* fill our lookup tables */
1530 for (i = 0; i <= mask_r>>sh_r; i++) 1536 fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1531 { 1537 fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1532 uint32_t tmp; 1538 fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1533 tmp = i * high.r;
1534 tmp += (mask_r>>sh_r) * low.r;
1535 lookup_r[i] = (tmp/65535)<<sh_r;
1536 }
1537 for (i = 0; i <= mask_g>>sh_g; i++)
1538 {
1539 uint32_t tmp;
1540 tmp = i * high.g;
1541 tmp += (mask_g>>sh_g) * low.g;
1542 lookup_g[i] = (tmp/65535)<<sh_g;
1543 }
1544 for (i = 0; i <= mask_b>>sh_b; i++)
1545 {
1546 uint32_t tmp;
1547 tmp = i * high.b;
1548 tmp += (mask_b>>sh_b) * low.b;
1549 lookup_b[i] = (tmp/65535)<<sh_b;
1550 }
1551 1539
1552 /* apply table to input image (replacing colors by newly calculated ones) */ 1540 /* apply table to input image (replacing colors by newly calculated ones) */
1553 if (ximage->bits_per_pixel == 32 1541 if (ximage->bits_per_pixel == 32
1554 && (ximage->depth == 24 || ximage->depth == 32) 1542 && (ximage->depth == 24 || ximage->depth == 32)
1555 && ximage->byte_order == host_byte_order) 1543 && ximage->byte_order == host_byte_order)

Diff Legend

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