ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/rxvt-unicode/src/xpm.C
(Generate patch)

Comparing rxvt-unicode/src/xpm.C (file contents):
Revision 1.46 by sasha, Thu Jul 12 22:33:16 2007 UTC vs.
Revision 1.51 by ayin, Fri Jul 27 14:41:15 2007 UTC

… …
231 if (n < MAXLEN_GEOM) 231 if (n < MAXLEN_GEOM)
232 { 232 {
233 strncpy (str, geom, n); 233 strncpy (str, geom, n);
234 str[n] = '\0'; 234 str[n] = '\0';
235 235
236 if (strcmp(str, "auto") == 0) 236 if (strcmp(str, "auto") == 0)
237 { 237 {
238 if (!bgpixmap->auto_resize) 238 if (!bgpixmap->auto_resize)
239 changed++; 239 changed++;
240 bgpixmap->auto_resize = True ; 240 bgpixmap->auto_resize = True ;
241 w = szHint.width ; 241 w = szHint.width ;
242 h = szHint.height ; 242 h = szHint.height ;
243 flags = WidthValue|HeightValue ; 243 flags = WidthValue|HeightValue ;
244 } 244 }
245 else 245 else
246 { 246 {
247 bgpixmap->auto_resize = False ; 247 bgpixmap->auto_resize = False ;
248 flags = XParseGeometry (str, &x, &y, &w, &h); 248 flags = XParseGeometry (str, &x, &y, &w, &h);
249 } 249 }
250 250
251 if (!flags) 251 if (!flags)
252 { 252 {
… …
357 unsigned int w = bgPixmap.w, h = bgPixmap.h, 357 unsigned int w = bgPixmap.w, h = bgPixmap.h,
358 x = bgPixmap.x, y = bgPixmap.y; 358 x = bgPixmap.x, y = bgPixmap.y;
359 unsigned int xpmh = xpmAttr.height, 359 unsigned int xpmh = xpmAttr.height,
360 xpmw = xpmAttr.width; 360 xpmw = xpmAttr.width;
361 361
362 if (bgPixmap.auto_resize) 362 if (bgPixmap.auto_resize)
363 { 363 {
364 w = szHint.width ; 364 w = szHint.width ;
365 h = szHint.height ; 365 h = szHint.height ;
366 } 366 }
367 /* 367 /*
368 * don't zoom pixmap too much nor expand really small pixmaps 368 * don't zoom pixmap too much nor expand really small pixmaps
369 */ 369 */
370 if (w > 32767 || h > 32767) 370 if (w > 32767 || h > 32767)
371 w = 1; 371 w = 1;
… …
388#ifdef ENABLE_TRANSPARENCY 388#ifdef ENABLE_TRANSPARENCY
389 if (!option(Opt_transparent) || !am_transparent) 389 if (!option(Opt_transparent) || !am_transparent)
390 /* will do that in check_our_parents otherwise */ 390 /* will do that in check_our_parents otherwise */
391#endif 391#endif
392 { 392 {
393 ASImage *scaled_im = scale_asimage( asv, original_asim, w, h, ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT ); 393 ASImage *scaled_im = scale_asimage (asv, original_asim, w, h, ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
394 if (scaled_im) 394 if (scaled_im)
395 { 395 {
396 pixmap = AFTERIMAGE_DPY_OP(asimage2pixmap( asv, display->root, scaled_im, gc, True )); 396 pixmap = asimage2pixmap(asv, display->root, scaled_im, gc, True);
397 destroy_asimage( &scaled_im ); 397 destroy_asimage (&scaled_im);
398 } 398 }
399 } 399 }
400#else /* HAVE_AFTERIMAGE */ 400#else /* HAVE_AFTERIMAGE */
401 { 401 {
402 float incr, p; 402 float incr, p;
… …
476 * we already have the required attributes 476 * we already have the required attributes
477 */ 477 */
478 /* XGetWindowAttributes (dpy, vt, &attr); */ 478 /* XGetWindowAttributes (dpy, vt, &attr); */
479 479
480#ifdef HAVE_AFTERIMAGE 480#ifdef HAVE_AFTERIMAGE
481 if (asimman == NULL) 481 if (asimman == NULL)
482 asimman = create_generic_imageman(rs[Rs_path]); 482 asimman = create_generic_imageman(rs[Rs_path]);
483 if ((f = strchr (file, ';')) == NULL) 483 if ((f = strchr (file, ';')) == NULL)
484 original_asim = get_asimage( asimman, file, 0xFFFFFFFF, 100 ); 484 original_asim = get_asimage( asimman, file, 0xFFFFFFFF, 100 );
485 else 485 else
486 { 486 {
487 size_t len = f - file; 487 size_t len = f - file;
488 f = (char *)malloc (len + 1); 488 f = (char *)malloc (len + 1);
489 strncpy (f, file, len); 489 strncpy (f, file, len);
490 f[len] = '\0'; 490 f[len] = '\0';
491 original_asim = get_asimage( asimman, f, 0xFFFFFFFF, 100 ); 491 original_asim = get_asimage( asimman, f, 0xFFFFFFFF, 100 );
492 free( f ); 492 free( f );
493 } 493 }
494 if (original_asim) 494 if (original_asim)
495 { 495 {
496 bgPixmap.pixmap = AFTERIMAGE_DPY_OP(asimage2pixmap( asv, display->root, original_asim, NULL, True )); 496 bgPixmap.pixmap = asimage2pixmap (asv, display->root, original_asim, NULL, True);
497 xpmAttr.width = original_asim->width ; 497 xpmAttr.width = original_asim->width ;
498 xpmAttr.height = original_asim->height ; 498 xpmAttr.height = original_asim->height ;
499 } 499 }
500#else /* HAVE_AFTERIMAGE */ 500#else /* HAVE_AFTERIMAGE */
501 xpmAttr.closeness = 30000; 501 xpmAttr.closeness = 30000;
502 xpmAttr.colormap = cmap; 502 xpmAttr.colormap = cmap;
503 xpmAttr.visual = visual; 503 xpmAttr.visual = visual;
… …
815 815
816 XTranslateCoordinates (dpy, parent[0], display->root, 816 XTranslateCoordinates (dpy, parent[0], display->root,
817 0, 0, &sx, &sy, &cr); 817 0, 0, &sx, &sy, &cr);
818 818
819 /* check if we are outside of the visible part of the virtual screen : */ 819 /* check if we are outside of the visible part of the virtual screen : */
820 if( sx + (int)szHint.width <= 0 || sy + (int)szHint.height <= 0 820 if( sx + (int)szHint.width <= 0 || sy + (int)szHint.height <= 0
821 || sx >= wrootattr.width || sy >= wrootattr.height ) 821 || sx >= wrootattr.width || sy >= wrootattr.height )
822 return /* 0 */ ; 822 return /* 0 */ ;
823 /* 823 /*
824 * Make the frame window set by the window manager have 824 * Make the frame window set by the window manager have
825 * the root background. Some window managers put multiple nested frame 825 * the root background. Some window managers put multiple nested frame
826 * windows for each client, so we have to take care about that. 826 * windows for each client, so we have to take care about that.
… …
853 XFree (prop); 853 XFree (prop);
854 } 854 }
855 855
856 if (have_pixmap) 856 if (have_pixmap)
857 { 857 {
858 Bool success = False ; 858 Bool success = False;
859 GC gc = NULL; 859 GC gc = NULL;
860 XGCValues gcvalue; 860 XGCValues gcvalue;
861 unsigned int pmap_w = 0, pmap_h = 0;
862
861#ifdef HAVE_AFTERIMAGE 863#ifdef HAVE_AFTERIMAGE
862 { 864 {
863 Pixmap tmp_pmap = None ; 865 Pixmap tmp_pmap = None;
864 ShadingInfo shade; 866 ShadingInfo shade;
865 ARGB32 tint ; 867 ARGB32 tint;
866 unsigned int pmap_w = 0, pmap_h = 0;
867 868
868 if (get_drawable_size( rootpixmap, &pmap_w, &pmap_h )) 869 if (get_dpy_drawable_size (dpy, rootpixmap, &pmap_w, &pmap_h))
869 { 870 {
870 int root_x = 0, root_y = 0; 871 int root_x = 0, root_y = 0;
871 872
872 shade.shading = rs[Rs_shade] ? atoi (rs[Rs_shade]) : 100; 873 shade.shading = rs[Rs_shade] ? atoi (rs[Rs_shade]) : 100;
873 if (ISSET_PIXCOLOR (Color_tint)) 874 if (ISSET_PIXCOLOR (Color_tint))
874 { 875 {
875 rgba c; 876 rgba c;
876 pix_colors_focused [Color_tint].get (c); 877 pix_colors_focused [Color_tint].get (c);
877 shade.tintColor.red = c.r; 878 shade.tintColor.red = c.r;
878 shade.tintColor.green = c.g; 879 shade.tintColor.green = c.g;
879 shade.tintColor.blue = c.b; 880 shade.tintColor.blue = c.b;
880 } 881 }
881 else 882 else
882 shade.tintColor.red = shade.tintColor.green = shade.tintColor.blue = 0xFFFF; 883 shade.tintColor.red = shade.tintColor.green = shade.tintColor.blue = 0xFFFF;
883 tint = shading2tint32( &shade ); 884 tint = shading2tint32 (&shade);
884 gc = XCreateGC (dpy, vt, 0UL, &gcvalue); 885 gc = XCreateGC (dpy, vt, 0UL, &gcvalue);
885 if (GetWinPosition (parent[0], &root_x, &root_y) ) 886 if (get_dpy_window_position (dpy, display->root, parent[0], NULL, NULL, &root_x, &root_y))
886 { 887 {
887 ASImageLayer *layers = create_image_layers( 2 ); 888 ASImageLayer *layers = create_image_layers (2);
888 ASImage *merged_im = NULL; 889 ASImage *merged_im = NULL;
889 int back_x, back_y, back_w, back_h; 890 int back_x, back_y, back_w, back_h;
890 /* merge_layers does good job at tiling background appropriately, 891 /* merge_layers does good job at tiling background appropriately,
891 so all we need is to cut out smallest possible piece : */ 892 so all we need is to cut out smallest possible piece : */
892#define MAKE_ROOTPMAP_GEOM(xy,wh,widthheight) \ 893#define MAKE_ROOTPMAP_GEOM(xy,wh,widthheight) \
893 do{ while( root_##xy < 0 ) root_##xy += (int)wrootattr.widthheight; \ 894 do{ while( root_##xy < 0 ) root_##xy += (int)wrootattr.widthheight; \
894 back_##xy = root_##xy % pmap_##wh; /* that gives us left side of the closest tile : */ \ 895 back_##xy = root_##xy % pmap_##wh; /* that gives us left side of the closest tile : */ \
895 if( pmap_##wh >= back_##xy + szHint.widthheight ) \ 896 if( pmap_##wh >= back_##xy + szHint.widthheight ) \
… …
897 else \ 898 else \
898 { /* small background - need the whole of it for successfull tiling :*/ \ 899 { /* small background - need the whole of it for successfull tiling :*/ \
899 back_##xy = 0; \ 900 back_##xy = 0; \
900 back_##wh = pmap_##wh; \ 901 back_##wh = pmap_##wh; \
901 }}while(0) 902 }}while(0)
902 903
903 MAKE_ROOTPMAP_GEOM(x,w,width); 904 MAKE_ROOTPMAP_GEOM(x,w,width);
904 MAKE_ROOTPMAP_GEOM(y,h,height); 905 MAKE_ROOTPMAP_GEOM(y,h,height);
905 906
906 layers[0].im = AFTERIMAGE_DPY_OP(pixmap2asimage (asv, rootpixmap, back_x, back_y, back_w, back_h, AllPlanes, ASA_ASImage, 100)); 907 layers[0].im = pixmap2asimage (asv, rootpixmap, back_x, back_y, back_w, back_h, AllPlanes, ASA_ASImage, 100);
907 layers[0].clip_x = (back_w == pmap_w)?root_x:0; 908 layers[0].clip_x = (back_w == pmap_w)?root_x:0;
908 layers[0].clip_y = (back_h == pmap_h)?root_y:0; 909 layers[0].clip_y = (back_h == pmap_h)?root_y:0;
909 layers[0].clip_width = szHint.width; 910 layers[0].clip_width = szHint.width;
910 layers[0].clip_height = szHint.height; 911 layers[0].clip_height = szHint.height;
911 layers[0].tint = tint; 912 layers[0].tint = tint;
912 if (rs[Rs_blurradius] && layers[0].im) 913 if (rs[Rs_blurradius] && layers[0].im)
913 { 914 {
914 double r = atof(rs[Rs_blurradius]); 915 double r = atof(rs[Rs_blurradius]);
915 ASImage* tmp = blur_asimage_gauss(asv, layers[0].im, r, r, 0xFFFFFFFF, ASA_ASImage, 100, ASIMAGE_QUALITY_DEFAULT ); 916 ASImage* tmp = blur_asimage_gauss (asv, layers[0].im, r, r, 0xFFFFFFFF, ASA_ASImage, 100, ASIMAGE_QUALITY_DEFAULT);
916 if( tmp ) 917 if (tmp)
917 { 918 {
918 destroy_asimage( &layers[0].im ); 919 destroy_asimage (&layers[0].im);
919 layers[0].im = tmp; 920 layers[0].im = tmp;
920 } 921 }
921 } 922 }
922 if (original_asim != NULL) 923 if (original_asim != NULL)
923 { 924 {
924 int fore_w, fore_h; 925 int fore_w, fore_h;
925 layers[1].im = original_asim; 926 layers[1].im = original_asim;
926 if( bgPixmap.auto_resize ) 927 if (bgPixmap.auto_resize)
927 { 928 {
928 fore_w = szHint.width; 929 fore_w = szHint.width;
929 fore_h = szHint.height; 930 fore_h = szHint.height;
930 } 931 }
931 else 932 else
… …
934 fore_h = bgPixmap.h; 935 fore_h = bgPixmap.h;
935 } 936 }
936 if (fore_w != original_asim->width 937 if (fore_w != original_asim->width
937 || fore_h != original_asim->height) 938 || fore_h != original_asim->height)
938 { 939 {
939 layers[1].im = scale_asimage( asv, 940 layers[1].im = scale_asimage (asv,
940 original_asim, 941 original_asim,
941 fore_w, fore_h, 942 fore_w, fore_h,
942 ASA_ASImage, 100, 943 ASA_ASImage, 100,
943 ASIMAGE_QUALITY_DEFAULT ); 944 ASIMAGE_QUALITY_DEFAULT);
944 } 945 }
945 946
946 layers[1].clip_width = szHint.width; 947 layers[1].clip_width = szHint.width;
947 layers[1].clip_height = szHint.height; 948 layers[1].clip_height = szHint.height;
948 949
949 if (rs[Rs_blendtype]) 950 if (rs[Rs_blendtype])
950 { 951 {
951 layers[1].merge_scanlines = blend_scanlines_name2func(rs[Rs_blendtype]); 952 layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
952 if( layers[1].merge_scanlines == NULL ) 953 if (layers[1].merge_scanlines == NULL)
953 layers[1].merge_scanlines = alphablend_scanlines; 954 layers[1].merge_scanlines = alphablend_scanlines;
954 } 955 }
955 } 956 }
956 merged_im = merge_layers( asv, layers, layers[1].im?2:1, 957 merged_im = merge_layers (asv, layers, layers[1].im?2:1,
957 szHint.width, szHint.height, 958 szHint.width, szHint.height,
958 ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT ); 959 ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
959 if (layers[1].im != original_asim) 960 if (layers[1].im != original_asim)
960 destroy_asimage( &(layers[1].im) ); 961 destroy_asimage (&(layers[1].im));
961 destroy_asimage( &(layers[0].im) ); 962 destroy_asimage (&(layers[0].im));
962 if (merged_im != NULL) 963 if (merged_im != NULL)
963 { 964 {
964 tmp_pmap = AFTERIMAGE_DPY_OP(asimage2pixmap( asv, DefaultRootWindow(dpy), merged_im, gc, True )); 965 tmp_pmap = asimage2pixmap (asv, DefaultRootWindow(dpy), merged_im, gc, True);
965 destroy_asimage( &merged_im ); 966 destroy_asimage (&merged_im);
966 } 967 }
967 free( layers ); 968 free (layers);
968 } 969 }
969 } 970 }
970 if (tmp_pmap != None) 971 if (tmp_pmap != None)
971 { 972 {
972 success = True; 973 success = True;
… …
978#else /* HAVE_AFTERIMAGE */ 979#else /* HAVE_AFTERIMAGE */
979 { 980 {
980 /* 981 /*
981 * Copy display->root pixmap transparency 982 * Copy display->root pixmap transparency
982 */ 983 */
984 Window wjunk;
983 int nx, ny; 985 int junk;
984 unsigned int nw, nh; 986 unsigned int ujunk;
985 XImage *image; 987 /* root pixmap may be bad - allow a error */
986 988 allowedxerror = -1;
987 nw = (unsigned int)szHint.width; 989 if (XGetGeometry (dpy, rootpixmap, &wjunk, &junk, &junk, &pmap_w, &pmap_h, &ujunk, &ujunk))
988 nh = (unsigned int)szHint.height;
989 nx = ny = 0;
990
991 if (sx < 0)
992 { 990 {
993 nw += sx; 991 XImage *image = NULL;
994 nx = -sx;
995 sx = 0; 992 int shade = 100;
996 } 993 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
994 Bool whole_tint = False;
997 995
998 if (sy < 0) 996 while (sx < 0) sx += (int)wrootattr.width;
999 { 997 while (sy < 0) sy += (int)wrootattr.height;
1000 nh += sy;
1001 ny = -sy;
1002 sy = 0;
1003 }
1004 998
1005 min_it (nw, (unsigned int) (wrootattr.width - sx));
1006 min_it (nh, (unsigned int) (wrootattr.height - sy));
1007
1008 XSync (dpy, False);
1009 allowedxerror = -1;
1010 image = XGetImage (dpy, rootpixmap, sx, sy, nw, nh, AllPlanes, ZPixmap);
1011
1012 /* XXX: handle BadMatch - usually because we're outside the pixmap */
1013 /* XXX: may need a delay here? */
1014 allowedxerror = 0;
1015 if (image != NULL)
1016 {
1017 if (pixmap != None) 999 if (pixmap != None)
1018 XFreePixmap (dpy, pixmap); 1000 XFreePixmap (dpy, pixmap);
1001 pixmap = XCreatePixmap (dpy, vt, szHint.width, szHint.height, rootdepth);
1019 1002
1020#if TINTING 1003#if TINTING
1004 if (rs[Rs_shade])
1005 shade = atoi (rs[Rs_shade]);
1021 if (ISSET_PIXCOLOR (Color_tint)) 1006 if (ISSET_PIXCOLOR (Color_tint))
1007 pix_colors_focused [Color_tint].get (c);
1008#define IS_COMPONENT_WHOLESOME(c) ((c) <=0x000700 || (c)>=0x00f700)
1009 if (shade >= 100)
1010 whole_tint = (IS_COMPONENT_WHOLESOME(c.r)
1011 && IS_COMPONENT_WHOLESOME(c.g)
1012 && IS_COMPONENT_WHOLESOME(c.b));
1013#undef IS_COMPONENT_WHOLESOME
1014
1015 /* If No tinting to be done - simply tile root pixmap on our pixmap -
1016 * no need in XImage at all, thus following if() only for case with tinting */
1017 if (whole_tint || pmap_w < sx + szHint.width || pmap_h < sy + szHint.height)
1018#endif /* TINTING */
1022 { 1019 {
1023 int shade = rs[Rs_shade] ? atoi (rs[Rs_shade]) : 100; 1020 gcvalue.tile = rootpixmap;
1024 1021 gcvalue.fill_style = FillTiled;
1022 gcvalue.ts_x_origin = -sx;
1023 gcvalue.ts_y_origin = -sy;
1024 gc = XCreateGC (dpy, rootpixmap, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcvalue);
1025 XFillRectangle (dpy, pixmap, gc, 0, 0, szHint.width, szHint.height);
1026#if TINTING
1027 if (whole_tint)
1025 rgba c; 1028 {
1026 pix_colors_focused [Color_tint].get (c); 1029 /* In this case we can tint image server-side getting significant
1030 * performance improvements, as we eliminate XImage transfer
1031 */
1032 gcvalue.foreground = Pixel (pix_colors_focused [Color_tint]);
1033 gcvalue.function = GXand;
1034 gcvalue.fill_style = FillSolid;
1035 XChangeGC (dpy, gc, GCFillStyle | GCForeground | GCFunction, &gcvalue);
1036 XFillRectangle (dpy, pixmap, gc, 0, 0, szHint.width, szHint.height);
1037 success = True;
1038 }
1039 else
1040 image = XGetImage (dpy, pixmap, 0, 0, szHint.width, szHint.height, AllPlanes, ZPixmap);
1041#else
1042 success = True;
1043#endif /* TINTING */
1044 }
1045#if TINTING
1046 if (!success && image == NULL)
1047 image = XGetImage (dpy, rootpixmap, sx, sy, szHint.width, szHint.height, AllPlanes, ZPixmap);
1048 if (image != NULL)
1049 {
1050 if (gc == NULL)
1051 gc = XCreateGC (dpy, vt, 0UL, &gcvalue);
1052 if (ISSET_PIXCOLOR (Color_tint) || shade != 100)
1027 ShadeXImage (this, image, shade, c.r, c.g, c.b); 1053 ShadeXImage (this, image, shade, c.r, c.g, c.b);
1054 XPutImage (dpy, pixmap, gc, image, 0, 0, 0, 0, image->width, image->height);
1055 XDestroyImage (image);
1056 success = True;
1028 } 1057 }
1029#endif 1058#endif
1030
1031 pixmap = XCreatePixmap (dpy, vt, szHint.width, szHint.height, image->depth);
1032 gc = XCreateGC (dpy, vt, 0UL, &gcvalue);
1033 XPutImage (dpy, pixmap, gc, image, 0, 0,
1034 nx, ny, image->width, image->height);
1035 XDestroyImage (image);
1036 success = True ;
1037 } 1059 }
1060 allowedxerror = 0;
1038 } 1061 }
1039#endif /* HAVE_AFTERIMAGE */ 1062#endif /* HAVE_AFTERIMAGE */
1040 if (gc != NULL) 1063 if (gc != NULL)
1041 XFreeGC (dpy, gc); 1064 XFreeGC (dpy, gc);
1042 1065
1043 if (!success) 1066 if (!success)
1044 { 1067 {
1045 if (am_transparent && am_pixmap_trans) 1068 if (am_transparent && am_pixmap_trans)

Diff Legend

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