--- rxvt-unicode/src/xpm.C	2007/06/30 23:31:29	1.43
+++ rxvt-unicode/src/xpm.C	2007/07/27 14:41:15	1.51
@@ -28,7 +28,155 @@
 
 #ifdef XPM_BACKGROUND
 
-static void      rxvt_pixmap_incr                 (unsigned int *wh, unsigned int *xy, float *incr, float *p, unsigned int widthheight, unsigned int xpmwidthheight);
+#ifndef HAVE_AFTERIMAGE
+/*
+ * search for FILE in the current working directory, and within the
+ * colon-delimited PATHLIST, adding the file extension EXT if required.
+ *
+ * FILE is either semi-colon or zero terminated
+ */
+static char *
+rxvt_File_search_path (const char *pathlist, const char *file, const char *ext)
+{
+  int             maxpath, len;
+  const char     *p, *path;
+  char            name[256];
+
+  if (!access (file, R_OK))	/* found (plain name) in current directory */
+    return strdup (file);
+
+  /* semi-colon delimited */
+  if ((p = strchr (file, ';')))
+    len = (p - file);
+  else
+    len = strlen (file);
+
+  /* leave room for an extra '/' and trailing '\0' */
+  maxpath = sizeof (name) - (len + (ext ? strlen (ext) : 0) + 2);
+  if (maxpath <= 0)
+    return NULL;
+
+  /* check if we can find it now */
+  strncpy (name, file, len);
+  name[len] = '\0';
+
+  if (!access (name, R_OK))
+    return strdup (name);
+  if (ext)
+    {
+      strcat (name, ext);
+      if (!access (name, R_OK))
+        return strdup (name);
+    }
+  for (path = pathlist; path != NULL && *path != '\0'; path = p)
+    {
+      int             n;
+
+      /* colon delimited */
+      if ((p = strchr (path, ':')) == NULL)
+        p = strchr (path, '\0');
+
+      n = (p - path);
+      if (*p != '\0')
+        p++;
+
+      if (n > 0 && n <= maxpath)
+        {
+          strncpy (name, path, n);
+          if (name[n - 1] != '/')
+            name[n++] = '/';
+          name[n] = '\0';
+          strncat (name, file, len);
+
+          if (!access (name, R_OK))
+            return strdup (name);
+          if (ext)
+            {
+              strcat (name, ext);
+              if (!access (name, R_OK))
+                return strdup (name);
+            }
+        }
+    }
+  return NULL;
+}
+
+/*
+ * Calculate tiling sizes and increments
+ * At start, p == 0, incr == xpmwidthheight
+ */
+static void
+rxvt_pixmap_incr (unsigned int *wh, unsigned int *xy, float *incr, float *p, unsigned int widthheight, unsigned int xpmwidthheight)
+{
+  unsigned int    cwh, cxy;
+  float           cincr, cp;
+
+  cp = 0;
+  cincr = (float)xpmwidthheight;
+  cxy = *xy;
+  cwh = *wh;
+  if (cwh == 1)
+    {	/* display one image, no horizontal/vertical scaling */
+      cincr = (float)widthheight;
+      if (xpmwidthheight <= widthheight)
+        {
+          cwh = xpmwidthheight;
+          cxy = (cxy * (widthheight - cwh)) / 100;	/* beware! order */
+          cwh += cxy;
+        }
+      else
+        {
+          cxy = 0;
+          cwh = widthheight;
+        }
+    }
+  else if (cwh < 10)
+    {	/* fit WH images across/down screen */
+      cincr *= cwh;
+      cxy = 0;
+      cwh = widthheight;
+    }
+  else
+    {
+      cincr *= 100.0 / cwh;
+      if (cwh < 100)
+        {	/* contract */
+          float           pos;
+
+          cwh = (cwh * widthheight) / 100;
+          pos = (float)cxy / 100 * widthheight - (cwh / 2);
+
+          cxy = (widthheight - cwh);
+          if (pos <= 0)
+            cxy = 0;
+          else if (pos < cxy)
+            cxy = (int) pos;
+          cwh += cxy;
+        }
+      else
+        {	/* expand */
+          if (cxy > 0)
+            {	/* position */
+              float           pos;
+
+              pos = (float)cxy / 100 * xpmwidthheight - (cincr / 2);
+              cp = xpmwidthheight - cincr;
+              if (pos <= 0)
+                cp = 0;
+              else if (pos < cp)
+                cp = pos;
+            }
+          cxy = 0;
+          cwh = widthheight;
+        }
+    }
+  cincr /= widthheight;
+  *wh = cwh;
+  *xy = cxy;
+  *incr = cincr;
+  *p = cp;
+}
+#endif
 
 /*
  * These GEOM strings indicate absolute size/position:
@@ -85,18 +233,18 @@
       strncpy (str, geom, n);
       str[n] = '\0';
 
-      if (strcmp(str, "auto") == 0) 
+      if (strcmp(str, "auto") == 0)
         {
-          if (!bgpixmap->auto_resize) 
+          if (!bgpixmap->auto_resize)
             changed++;
-          bgpixmap->auto_resize = True ; 
-          w = szHint.width ; 
+          bgpixmap->auto_resize = True ;
+          w = szHint.width ;
           h = szHint.height ;
           flags = WidthValue|HeightValue ;
         }
       else
         {
-          bgpixmap->auto_resize = False ;  				
+          bgpixmap->auto_resize = False ;
           flags = XParseGeometry (str, &x, &y, &w, &h);
         }
 
@@ -211,11 +359,11 @@
       unsigned int xpmh = xpmAttr.height,
                    xpmw = xpmAttr.width;
 
-      if (bgPixmap.auto_resize) 
+      if (bgPixmap.auto_resize)
         {
-          w = szHint.width ; 
+          w = szHint.width ;
           h = szHint.height ;
-        }	
+        }
       /*
        * don't zoom pixmap too much nor expand really small pixmaps
        */
@@ -242,11 +390,11 @@
       /* will do that in check_our_parents otherwise */
 #endif
         {
-          ASImage *scaled_im = scale_asimage( display->asv, original_asim, w, h, ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT );
-          if (scaled_im) 
+          ASImage *scaled_im = scale_asimage (asv, original_asim, w, h, ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
+          if (scaled_im)
             {
-              pixmap = asimage2pixmap( display->asv, display->root, scaled_im, gc, True );
-              destroy_asimage( &scaled_im );
+              pixmap = asimage2pixmap(asv, display->root, scaled_im, gc, True);
+              destroy_asimage (&scaled_im);
             }
         }
 #else   /* HAVE_AFTERIMAGE */
@@ -305,82 +453,6 @@
 #endif
 }
 
-/*
- * Calculate tiling sizes and increments
- * At start, p == 0, incr == xpmwidthheight
- */
-static void
-rxvt_pixmap_incr (unsigned int *wh, unsigned int *xy, float *incr, float *p, unsigned int widthheight, unsigned int xpmwidthheight)
-{
-  unsigned int    cwh, cxy;
-  float           cincr, cp;
-
-  cp = 0;
-  cincr = (float)xpmwidthheight;
-  cxy = *xy;
-  cwh = *wh;
-  if (cwh == 1)
-    {	/* display one image, no horizontal/vertical scaling */
-      cincr = (float)widthheight;
-      if (xpmwidthheight <= widthheight)
-        {
-          cwh = xpmwidthheight;
-          cxy = (cxy * (widthheight - cwh)) / 100;	/* beware! order */
-          cwh += cxy;
-        }
-      else
-        {
-          cxy = 0;
-          cwh = widthheight;
-        }
-    }
-  else if (cwh < 10)
-    {	/* fit WH images across/down screen */
-      cincr *= cwh;
-      cxy = 0;
-      cwh = widthheight;
-    }
-  else
-    {
-      cincr *= 100.0 / cwh;
-      if (cwh < 100)
-        {	/* contract */
-          float           pos;
-
-          cwh = (cwh * widthheight) / 100;
-          pos = (float)cxy / 100 * widthheight - (cwh / 2);
-
-          cxy = (widthheight - cwh);
-          if (pos <= 0)
-            cxy = 0;
-          else if (pos < cxy)
-            cxy = (int) pos;
-          cwh += cxy;
-        }
-      else
-        {	/* expand */
-          if (cxy > 0)
-            {	/* position */
-              float           pos;
-
-              pos = (float)cxy / 100 * xpmwidthheight - (cincr / 2);
-              cp = xpmwidthheight - cincr;
-              if (pos <= 0)
-                cp = 0;
-              else if (pos < cp)
-                cp = pos;
-            }
-          cxy = 0;
-          cwh = widthheight;
-        }
-    }
-  cincr /= widthheight;
-  *wh = cwh;
-  *xy = cxy;
-  *incr = cincr;
-  *p = cp;
-}
-
 Pixmap
 rxvt_term::set_bgPixmap (const char *file)
 {
@@ -406,24 +478,24 @@
       /*      XGetWindowAttributes (dpy, vt, &attr); */
 
 #ifdef HAVE_AFTERIMAGE
-      if (asimman == NULL) 
-        asimman = create_generic_imageman(rs[Rs_path]);		
+      if (asimman == NULL)
+        asimman = create_generic_imageman(rs[Rs_path]);
       if ((f = strchr (file, ';')) == NULL)
-        original_asim = get_asimage( asimman, file, 0xFFFFFFFF, 100 ); 	  
+        original_asim = get_asimage( asimman, file, 0xFFFFFFFF, 100 );
       else
         {
           size_t len = f - file;
           f = (char *)malloc (len + 1);
           strncpy (f, file, len);
           f[len] = '\0';
-          original_asim = get_asimage( asimman, f, 0xFFFFFFFF, 100 ); 	  
+          original_asim = get_asimage( asimman, f, 0xFFFFFFFF, 100 );
           free( f );
         }
       if (original_asim)
         {
-          bgPixmap.pixmap = asimage2pixmap( display->asv, display->root, original_asim, NULL, True );
-          xpmAttr.width = original_asim->width ; 
-          xpmAttr.height = original_asim->height ; 
+          bgPixmap.pixmap = asimage2pixmap (asv, display->root, original_asim, NULL, True);
+          xpmAttr.width = original_asim->width ;
+          xpmAttr.height = original_asim->height ;
         }
 #else /* HAVE_AFTERIMAGE */
       xpmAttr.closeness = 30000;
@@ -434,7 +506,7 @@
                            | XpmDepth | XpmSize | XpmReturnPixels);
 
       /* search environment variables here too */
-      f = (char *)rxvt_File_find (file, ".xpm", rs[Rs_path]);
+      f = rxvt_File_search_path (rs[Rs_path], file, ".xpm");
       if (f == NULL
           || XpmReadFileToPixmap (dpy, display->root, f,
                                   &bgPixmap.pixmap, NULL,
@@ -745,8 +817,8 @@
                           0, 0, &sx, &sy, &cr);
 
     /* check if we are outside of the visible part of the virtual screen : */
-  if( sx + (int)szHint.width <= 0 || sy + (int)szHint.height <= 0 
-      || sx >= wrootattr.width || sy >= wrootattr.height ) 
+  if( sx + (int)szHint.width <= 0 || sy + (int)szHint.height <= 0
+      || sx >= wrootattr.width || sy >= wrootattr.height )
     return /* 0 */ ;
   /*
    * Make the frame window set by the window manager have
@@ -783,39 +855,40 @@
 
   if (have_pixmap)
     {
-      Bool success = False ; 
+      Bool success = False;
       GC gc = NULL;
       XGCValues gcvalue;
+      unsigned int pmap_w = 0, pmap_h = 0;
+
 #ifdef HAVE_AFTERIMAGE
       {
-        Pixmap tmp_pmap = None ; 
+        Pixmap tmp_pmap = None;
         ShadingInfo shade;
-        ARGB32 tint ;
-        unsigned int pmap_w = 0, pmap_h = 0;
+        ARGB32 tint;
 
-        if (get_drawable_size( rootpixmap, &pmap_w, &pmap_h ))
-          {			
+        if (get_dpy_drawable_size (dpy, rootpixmap, &pmap_w, &pmap_h))
+          {
             int root_x = 0, root_y = 0;
- 
-  	         shade.shading = rs[Rs_shade] ? atoi (rs[Rs_shade]) : 100; 
+
+  	        shade.shading = rs[Rs_shade] ? atoi (rs[Rs_shade]) : 100;
             if (ISSET_PIXCOLOR (Color_tint))
               {
                 rgba c;
                 pix_colors_focused [Color_tint].get (c);
-                shade.tintColor.red = c.r; 
-                shade.tintColor.green = c.g; 
-                shade.tintColor.blue = c.b; 
+                shade.tintColor.red = c.r;
+                shade.tintColor.green = c.g;
+                shade.tintColor.blue = c.b;
               }
             else
               shade.tintColor.red = shade.tintColor.green = shade.tintColor.blue = 0xFFFF;
-            tint = shading2tint32( &shade );
+            tint = shading2tint32 (&shade);
             gc = XCreateGC (dpy, vt, 0UL, &gcvalue);
-            if (GetWinPosition (parent[0], &root_x, &root_y)  )
+            if (get_dpy_window_position (dpy, display->root, parent[0], NULL, NULL, &root_x, &root_y))
               {
-                ASImageLayer *layers = create_image_layers( 2 );
+                ASImageLayer *layers = create_image_layers (2);
                 ASImage *merged_im = NULL;
                 int back_x, back_y, back_w, back_h;
-                /* merge_layers does good job at tiling background appropriately, 
+                /* merge_layers does good job at tiling background appropriately,
                    so all we need is to cut out smallest possible piece : */
 #define MAKE_ROOTPMAP_GEOM(xy,wh,widthheight) \
           do{ while( root_##xy < 0 ) root_##xy += (int)wrootattr.widthheight; \
@@ -827,11 +900,11 @@
                     back_##xy = 0; \
                     back_##wh = pmap_##wh; \
                   }}while(0)
-    
+
                 MAKE_ROOTPMAP_GEOM(x,w,width);
                 MAKE_ROOTPMAP_GEOM(y,h,height);
 
-                layers[0].im = pixmap2asimage (display->asv, rootpixmap, back_x, back_y, back_w, back_h, AllPlanes, ASA_ASImage, 100);
+                layers[0].im = pixmap2asimage (asv, rootpixmap, back_x, back_y, back_w, back_h, AllPlanes, ASA_ASImage, 100);
                 layers[0].clip_x = (back_w == pmap_w)?root_x:0;
                 layers[0].clip_y = (back_h == pmap_h)?root_y:0;
                 layers[0].clip_width = szHint.width;
@@ -840,10 +913,10 @@
                 if (rs[Rs_blurradius] && layers[0].im)
                   {
                     double r = atof(rs[Rs_blurradius]);
-                    ASImage* tmp = blur_asimage_gauss(display->asv, layers[0].im, r, r, 0xFFFFFFFF, ASA_ASImage, 100, ASIMAGE_QUALITY_DEFAULT );
-                    if( tmp )
+                    ASImage* tmp = blur_asimage_gauss (asv, layers[0].im, r, r, 0xFFFFFFFF, ASA_ASImage, 100, ASIMAGE_QUALITY_DEFAULT);
+                    if (tmp)
                       {
-                        destroy_asimage( &layers[0].im );
+                        destroy_asimage (&layers[0].im);
                         layers[0].im = tmp;
                       }
                   }
@@ -851,7 +924,7 @@
                   {
                     int fore_w, fore_h;
                     layers[1].im = original_asim;
-                    if( bgPixmap.auto_resize )
+                    if (bgPixmap.auto_resize)
                       {
                         fore_w = szHint.width;
                         fore_h = szHint.height;
@@ -864,11 +937,11 @@
                     if (fore_w != original_asim->width
                         || fore_h != original_asim->height)
                       {
-                        layers[1].im = scale_asimage( display->asv,
+                        layers[1].im = scale_asimage (asv,
                                                       original_asim,
                                                       fore_w, fore_h,
                                                       ASA_ASImage, 100,
-                                                      ASIMAGE_QUALITY_DEFAULT );
+                                                      ASIMAGE_QUALITY_DEFAULT);
                       }
 
                     layers[1].clip_width = szHint.width;
@@ -876,23 +949,23 @@
 
                     if (rs[Rs_blendtype])
                       {
-                        layers[1].merge_scanlines = blend_scanlines_name2func(rs[Rs_blendtype]);
-                        if( layers[1].merge_scanlines == NULL )
+                        layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
+                        if (layers[1].merge_scanlines == NULL)
                           layers[1].merge_scanlines = alphablend_scanlines;
                       }
-                  }                    
-                merged_im = merge_layers( display->asv, layers, layers[1].im?2:1,
+                  }
+                merged_im = merge_layers (asv, layers, layers[1].im?2:1,
                                           szHint.width, szHint.height,
-                                          ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT );
+                                          ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
                 if (layers[1].im != original_asim)
-                  destroy_asimage( &(layers[1].im) );
-                destroy_asimage( &(layers[0].im) );
+                  destroy_asimage (&(layers[1].im));
+                destroy_asimage (&(layers[0].im));
                 if (merged_im != NULL)
                   {
-                    tmp_pmap = asimage2pixmap( display->asv, DefaultRootWindow(dpy), merged_im, gc, True );
-                    destroy_asimage( &merged_im );
+                    tmp_pmap = asimage2pixmap (asv, DefaultRootWindow(dpy), merged_im, gc, True);
+                    destroy_asimage (&merged_im);
                   }
-                free( layers );
+                free (layers);
               }
           }
         if (tmp_pmap != None)
@@ -908,64 +981,86 @@
       /*
        * Copy display->root pixmap transparency
        */
-        int nx, ny;
-        unsigned int nw, nh;
-        XImage *image;
-
-        nw = (unsigned int)szHint.width;
-        nh = (unsigned int)szHint.height;
-        nx = ny = 0;
-
-        if (sx < 0)
-          {
-            nw += sx;
-            nx = -sx;
-            sx = 0;
-          }
-
-        if (sy < 0)
+        Window wjunk;
+        int junk;
+        unsigned int ujunk;
+        /* root pixmap may be bad - allow a error */
+        allowedxerror = -1;
+        if (XGetGeometry (dpy, rootpixmap, &wjunk, &junk, &junk, &pmap_w, &pmap_h, &ujunk, &ujunk))
           {
-            nh += sy;
-            ny = -sy;
-            sy = 0;
-          }
-
-        min_it (nw, (unsigned int) (wrootattr.width - sx));
-        min_it (nh, (unsigned int) (wrootattr.height - sy));
+            XImage *image = NULL;
+            int shade = 100;
+            rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
+            Bool whole_tint = False;
 
-        XSync (dpy, False);
-        allowedxerror = -1;
-        image = XGetImage (dpy, rootpixmap, sx, sy, nw, nh, AllPlanes, ZPixmap);
+            while (sx < 0) sx += (int)wrootattr.width;
+            while (sy < 0) sy += (int)wrootattr.height;
 
-        /* XXX: handle BadMatch - usually because we're outside the pixmap */
-        /* XXX: may need a delay here? */
-        allowedxerror = 0;
-        if (image != NULL)
-          {
             if (pixmap != None)
               XFreePixmap (dpy, pixmap);
+            pixmap = XCreatePixmap (dpy, vt, szHint.width, szHint.height, rootdepth);
 
 #if TINTING
+            if (rs[Rs_shade])
+              shade = atoi (rs[Rs_shade]);
             if (ISSET_PIXCOLOR (Color_tint))
+              pix_colors_focused [Color_tint].get (c);
+#define IS_COMPONENT_WHOLESOME(c)  ((c) <=0x000700 || (c)>=0x00f700)
+            if (shade >= 100)
+              whole_tint = (IS_COMPONENT_WHOLESOME(c.r)
+                            && IS_COMPONENT_WHOLESOME(c.g)
+                            && IS_COMPONENT_WHOLESOME(c.b));
+#undef  IS_COMPONENT_WHOLESOME
+
+            /* If No tinting to be done - simply tile root pixmap on our pixmap -
+             * no need in XImage at all, thus following if() only for case with tinting */
+            if (whole_tint || pmap_w < sx + szHint.width || pmap_h < sy + szHint.height)
+#endif /* TINTING */
               {
-                int shade = rs[Rs_shade] ? atoi (rs[Rs_shade]) : 100;
-
-                rgba c;
-                pix_colors_focused [Color_tint].get (c);
-                ShadeXImage (this, image, shade, c.r, c.g, c.b);
+                gcvalue.tile = rootpixmap;
+                gcvalue.fill_style = FillTiled;
+                gcvalue.ts_x_origin = -sx;
+                gcvalue.ts_y_origin = -sy;
+                gc = XCreateGC (dpy, rootpixmap, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcvalue);
+                XFillRectangle (dpy, pixmap, gc, 0, 0, szHint.width, szHint.height);
+#if TINTING
+                if (whole_tint)
+                  {
+                    /* In this case we can tint image server-side getting significant
+                     * performance improvements, as we eliminate XImage transfer
+                     */
+                    gcvalue.foreground = Pixel (pix_colors_focused [Color_tint]);
+                    gcvalue.function = GXand;
+                    gcvalue.fill_style = FillSolid;
+                    XChangeGC (dpy, gc, GCFillStyle | GCForeground | GCFunction, &gcvalue);
+                    XFillRectangle (dpy, pixmap, gc, 0, 0, szHint.width, szHint.height);
+                    success = True;
+                  }
+                else
+                  image = XGetImage (dpy, pixmap, 0, 0, szHint.width, szHint.height, AllPlanes, ZPixmap);
+#else
+                success = True;
+#endif /* TINTING */
+              }
+#if TINTING
+            if (!success && image == NULL)
+                image = XGetImage (dpy, rootpixmap, sx, sy, szHint.width, szHint.height, AllPlanes, ZPixmap);
+            if (image != NULL)
+              {
+                if (gc == NULL)
+                  gc = XCreateGC (dpy, vt, 0UL, &gcvalue);
+                if (ISSET_PIXCOLOR (Color_tint) || shade != 100)
+                  ShadeXImage (this, image, shade, c.r, c.g, c.b);
+                XPutImage (dpy, pixmap, gc, image, 0, 0, 0, 0, image->width, image->height);
+                XDestroyImage (image);
+                success = True;
               }
 #endif
-
-            pixmap = XCreatePixmap (dpy, vt, szHint.width, szHint.height, image->depth);
-            gc = XCreateGC (dpy, vt, 0UL, &gcvalue);
-            XPutImage (dpy, pixmap, gc, image, 0, 0,
-                       nx, ny, image->width, image->height);
-            XDestroyImage (image);
-            success = True ;
           }
+        allowedxerror = 0;
       }
 #endif  /* HAVE_AFTERIMAGE */
-      if (gc != NULL) 
+      if (gc != NULL)
         XFreeGC (dpy, gc);
 
       if (!success)