--- rxvt-unicode/src/xpm.C	2007/08/10 22:10:36	1.65
+++ rxvt-unicode/src/xpm.C	2007/08/17 22:01:33	1.71
@@ -90,6 +90,23 @@
   return false;
 }
 
+bool bgPixmap_t::need_client_side_rendering ()
+{
+# ifdef HAVE_AFTERIMAGE
+  if (original_asim != NULL)
+    return true;
+# endif
+# ifdef ENABLE_TRANSPARENCY
+  if (flags & isTransparent)
+    {
+      if ((flags & blurNeeded)
+          || ((flags & tintNeeded) && !(flags & tintServerSide)))
+        return true;    
+    }
+# endif
+  return false;
+}
+
 # ifdef XPM_BACKGROUND
 static inline bool
 check_set_scale_value (int geom_flags, int flag, unsigned int &scale, unsigned int new_value)
@@ -599,6 +616,10 @@
       ++changed;
       v_blurRadius = vr;
     }
+  if (v_blurRadius == 0 && h_blurRadius == 0)
+    flags &= ~blurNeeded;
+  else
+    flags |= blurNeeded;
   return (changed>0);
 }
 
@@ -614,17 +635,16 @@
       rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
       tint->get (c);
 
-      flags |= bgPixmap_t::tintNeeded;
       if ((c.r > 0x000700 || c.g > 0x000700 || c.b > 0x000700)
           && (c.r < 0x00f700 || c.g < 0x00f700 || c.b < 0x00f700))
       {
          flags |= bgPixmap_t::tintNeeded;
-#define IS_COMPONENT_WHOLESOME(cmp)  ((cmp) <= 0x000700 || (cmp) >= 0x00f700)
+#  define IS_COMPONENT_WHOLESOME(cmp)  ((cmp) <= 0x000700 || (cmp) >= 0x00f700)
           if (IS_COMPONENT_WHOLESOME (c.r)
               && IS_COMPONENT_WHOLESOME (c.g)
               && IS_COMPONENT_WHOLESOME (c.b))
             flags |= bgPixmap_t::tintServerSide;
-#undef  IS_COMPONENT_WHOLESOME
+#  undef  IS_COMPONENT_WHOLESOME
       }
     }
   return flags;
@@ -680,11 +700,13 @@
  * that pixmap contains tiled portion of the root pixmap that is supposed to be covered by 
  * our window.
  */
-bool
+unsigned long
 bgPixmap_t::make_transparency_pixmap ()
 {
+  unsigned long result = 0;
+
   if (target == NULL)
-    return false;
+    return 0;
 
   /* root dimentions may change from call to call - but Display structure should
    * be always up-to-date, so let's use it :
@@ -705,7 +727,7 @@
   /* check if we are outside of the visible part of the virtual screen : */
   if (sx + window_width <= 0 || sy + window_height <= 0
       || sx >= root_width || sy >= root_height)
-    return false;
+    return 0;
 
   if (root_pixmap != None)
     {/* we want to validate the pixmap and get it's size at the same time : */
@@ -722,7 +744,7 @@
   GC gc = NULL;
 
   if (tiled_root_pmap == None) /* something really bad happened - abort */
-    return false;
+    return 0;
 
   if (root_pixmap == None)
     { /* use tricks to obtain the root background image :*/
@@ -755,8 +777,11 @@
           if (ev_count > 0);
             { /* hooray! - we can grab the image! */
               gc = XCreateGC (dpy, root, 0, NULL);
-              XCopyArea (dpy, src, tiled_root_pmap, gc, 0, 0, window_width, window_height, 0, 0);
-              success = true;
+              if (gc)
+                {
+                  XCopyArea (dpy, src, tiled_root_pmap, gc, 0, 0, window_width, window_height, 0, 0);
+                  success = true;
+                }
             }
           XDestroyWindow (dpy, src);
           XUngrabServer (dpy);
@@ -767,6 +792,8 @@
             XFreePixmap (dpy, tiled_root_pmap);
             tiled_root_pmap = None;
           }
+        else
+          result |= transpPmapTiled;
     }
   else
     {/* strightforward pixmap copy */
@@ -777,30 +804,31 @@
       gcv.ts_x_origin = -sx;
       gcv.ts_y_origin = -sy;
       gc = XCreateGC (dpy, root, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
-      XFillRectangle (dpy, tiled_root_pmap, gc, 0, 0, window_width, window_height);
+      if (gc)
+        {
+          XFillRectangle (dpy, tiled_root_pmap, gc, 0, 0, window_width, window_height);
+          result |= transpPmapTiled;
+        }
     }
 
     if (tiled_root_pmap != None)
       {
-        if (flags & tintNeeded) 
+        if (flags & tintNeeded && !need_client_side_rendering ()) 
           {
-            if ((flags & tintServerSide)
-                && h_blurRadius <= 1  && v_blurRadius <= 1
-# ifdef HAVE_AFTERIMAGE
-                && original_asim == NULL
-# endif
-               )
-              { /* In this case we can tint image server-side getting significant
-                 * performance improvements, as we eliminate XImage transfer
-                 */
-                gcv.foreground = Pixel (tint);
-                gcv.function = GXand;
-                gcv.fill_style = FillSolid;
-                if (gc)
-                  XChangeGC (dpy, gc, GCFillStyle | GCForeground | GCFunction, &gcv);
-                else
-                  gc = XCreateGC (dpy, root, GCFillStyle | GCForeground | GCFunction, &gcv);
+            /* In this case we can tint image server-side getting significant
+             * performance improvements, as we eliminate XImage transfer
+             */
+            gcv.foreground = Pixel (tint);
+            gcv.function = GXand;
+            gcv.fill_style = FillSolid;
+            if (gc)
+              XChangeGC (dpy, gc, GCFillStyle | GCForeground | GCFunction, &gcv);
+            else
+              gc = XCreateGC (dpy, root, GCFillStyle | GCForeground | GCFunction, &gcv);
+            if (gc)
+              {
                 XFillRectangle (dpy, tiled_root_pmap, gc, 0, 0, window_width, window_height);
+                result |= transpPmapTinted;
               }
            }
         if (pixmap)
@@ -813,6 +841,8 @@
       
     if (gc)
       XFreeGC (dpy, gc);
+    
+    return result;    
 }
 
 bool
@@ -833,24 +863,141 @@
 }
 # endif /* ENABLE_TRANSPARENCY */
 
+# ifndef HAVE_AFTERIMAGE
+static void ShadeXImage(rxvt_term *term, XImage* srcImage, int shade, int rm, int gm, int bm);
+# endif
+
+
 bool
-bgPixmap_t::render_background ()
+bgPixmap_t::render ()
 {
-  /* TODO: temporary implementation - need to move check_parents stuff in here */
+  unsigned long background_flags = 0;
+
+  if (target == NULL)
+    return false;
+
+  invalidate();
 # ifdef ENABLE_TRANSPARENCY
   if (flags & isTransparent)
     {
       /*  we need to re-generate transparency pixmap in that case ! */
-      target->check_our_parents ();
-      return true;      
+      background_flags = make_transparency_pixmap ();
+      if (background_flags == 0)
+        return false;
+      else if ((background_flags & transpTransformations) == (flags & transpTransformations)
+                && pmap_depth == target->depth)
+        flags = flags & ~isInvalid;
     }
 # endif
+
+  XImage *result = NULL;
 # ifdef HAVE_AFTERIMAGE
-  render_asim (NULL, TINT_LEAVE_SAME);
-  apply_background ();
+  if (original_asim
+      || (background_flags & transpTransformations) != (flags & transpTransformations))
+    {
+      ASImage *background = NULL;
+      ARGB32 as_tint = TINT_LEAVE_SAME;
+      if (background_flags)
+          background = pixmap2ximage (target->asv, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, 100);
+
+#  ifdef ENABLE_TRANSPARENCY
+      if (!(background_flags & transpPmapTinted) && (flags & tintNeeded))
+        {
+          ShadingInfo as_shade;
+          as_shade.shading = (shade == 0) ? 100 : shade;
+
+          rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
+          if (flags & tintSet)
+            tint.get (c);
+          as_shade.tintColor.red = c.r;
+          as_shade.tintColor.green = c.g;
+          as_shade.tintColor.blue = c.b;
+
+          as_tint = shading2tint32 (&as_shade);
+        }
+      if (!(background_flags & transpPmapBlured) && (flags & blurNeeded) && background != NULL)
+        {
+          ASImage* tmp = blur_asimage_gauss (target->asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,
+                                             (original_asim == NULL || tint == TINT_LEAVE_SAME)?ASA_XImage:ASA_ASImage,
+                                             100, ASIMAGE_QUALITY_DEFAULT);
+          if (tmp)
+            {
+              destroy_asimage (&background);
+              background = tmp;
+            }
+        }
+#  endif
+
+      if (render_asim (background, as_tint))
+        flags = flags & ~isInvalid;
+      if (background)
+          destroy_asimage (&background);
+    }
+  else if (background_flags && pmap_depth != target->depth)
+    {
+      result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap);
+    }
+# else /* our own client-side tinting */
+  if (background_flags && (flags & isInvalid))
+    {
+      result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap);
+      if (result != NULL && !(background_flags & transpPmapTinted) && (flags & tintNeeded))
+        {
+          rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
+          if (flags & tintSet)
+            tint.get (c);
+          ShadeXImage (target, result, shade, c.r, c.g, c.b);
+        }
+    }
+# endif /* HAVE_AFTERIMAGE */
+  if (result != NULL)
+    {
+      GC gc = XCreateGC (target->dpy, target->vt, 0UL, NULL);
+      if (gc)
+        {
+          if (/*pmap_depth != target->depth &&*/ pixmap != None)
+            {
+              XFreePixmap (target->dpy, pixmap);
+              pixmap = None;
+            }
+          if (pixmap == None)
+            {
+              pixmap = XCreatePixmap (target->dpy, target->vt, result->width, result->height, target->depth);
+              pmap_width = result->width;
+              pmap_height = result->height;
+              pmap_depth = target->depth;
+            }
+          if (pmap_depth != result->depth)
+            { /* Bad Match error will ensue ! stupid X !!!! */
+              if( result->depth == 24 && pmap_depth == 32)
+                result->depth = 32;
+              else if( result->depth == 32 && pmap_depth == 24)
+                result->depth = 24;
+              else
+                {
+                  /* TODO: implement image recoding */
+                }
+            }
+          if (pmap_depth == result->depth)
+            XPutImage (target->dpy, pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
+          XFreeGC (target->dpy, gc);
+          flags = flags & ~isInvalid;
+        }
+        XDestroyImage (result);
+    }
+
+  if (flags & isInvalid)
+    {
+      if (pixmap != None)
+        {
+          XFreePixmap (target->dpy, pixmap);
+          pixmap = None;
+        }
+    }
+
+  apply ();
+
   return true;      
-# endif
-  return false;
 }
 
 bool 
@@ -869,7 +1016,7 @@
 }
 
 void
-bgPixmap_t::apply_background()
+bgPixmap_t::apply()
 {
   if (target)
     {
@@ -880,38 +1027,61 @@
             {
               XSetWindowBackgroundPixmap (target->dpy, target->parent[0], pixmap);
               XSetWindowBackgroundPixmap (target->dpy, target->vt, ParentRelative);
+#  if HAVE_SCROLLBARS
               if (target->scrollBar.win)
                 XSetWindowBackgroundPixmap (target->dpy, target->scrollBar.win, ParentRelative);
+#  endif
             }
           else
 # endif
             {
               /* force old pixmap dereference in case it was transparent before :*/
-              XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_bg]);
+              XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
               XSetWindowBackgroundPixmap (target->dpy, target->vt, pixmap);
               /* do we also need to set scrollbar's background here ? */
+# if HAVE_SCROLLBARS
+              if (target->scrollBar.win)
+                  XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);
+# endif
             }
         }
       else
         { /* set target background to a pixel */
-          XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_bg]);
+          XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
           XSetWindowBackground (target->dpy, target->vt, target->pix_colors[Color_bg]);
           /* do we also need to set scrollbar's background here ? */
+# if HAVE_SCROLLBARS
+          if (target->scrollBar.win)
+              XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);
+# endif
         }
       /* don't want Expose on the parent */
       XClearArea (target->dpy, target->parent[0], 0, 0, 0, 0, False);
       /* do want Expose on the vt */
       XClearArea (target->dpy, target->parent[0], 0, 0, 0, 0, True);
+# if HAVE_SCROLLBARS
+      if (target->scrollBar.win)
+        {
+          target->scrollBar.setIdle ();
+          target->scrollbar_show (0);
+        }
+# endif
+      /* Is that really neccessary? we did a XClearArea to generate Expose events alreday ! */
+      target->want_refresh = 1;
+# ifdef ENABLE_TRANSPARENCY
+      target->want_full_refresh = 1;
+# endif
+      /* TODO: why do we need a flush here ??? It causes segfault on resize ! */
+//      target->flush ();
     }
 }
-#endif				/* HAVE_BG_PIXMAP */
-
 
 void
 rxvt_term::get_window_origin (int &x, int &y)
 {
   Window cr;
   XTranslateCoordinates (dpy, parent[0], display->root, 0, 0, &x, &y, &cr);
+/*  fprintf( stderr, "origin is %+d%+d\n", x, y);*/
 }
 
 Pixmap
@@ -935,9 +1105,38 @@
   return None;
 }
 
+/*
+ * Check our parents are still who we think they are.
+ * Do transparency updates if required
+ */
+int
+rxvt_term::update_background ()
+{
+  bgPixmap.invalidate();
+  /* no chance of real time refresh if we are blurring ! */
+  if (bgPixmap.invalid_since + 0.5 < NOW && !(bgPixmap.flags & bgPixmap_t::blurNeeded))
+    bgPixmap.render();
+  else
+    {
+      update_background_ev.stop ();
+      if (!bgPixmap.need_client_side_rendering())
+        update_background_ev.start (NOW + .05);
+      else if (bgPixmap.flags & bgPixmap_t::blurNeeded)
+        update_background_ev.start (NOW + .2); /* very slow !!! */
+      else
+        update_background_ev.start (NOW + .07);
+    }
+  return 0;
+}
+
+void
+rxvt_term::update_background_cb (time_watcher &w)
+{
+  bgPixmap.render ();
+}
+#endif    /* HAVE_BG_PIXMAP */
 
-#ifdef ENABLE_TRANSPARENCY
-#ifndef HAVE_AFTERIMAGE
+#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
 /* taken from aterm-0.4.2 */
 
 typedef uint32_t RUINT32T;
@@ -954,8 +1153,11 @@
 
   Visual *visual = term->visual;
 
-  if( visual->c_class != TrueColor || srcImage->format != ZPixmap ) return ;
+  if (visual->c_class != TrueColor || srcImage->format != ZPixmap) return ;
 
+  if (shade == 0)
+    shade = 100;
+    
   /* for convenience */
   mask_r = visual->red_mask;
   mask_g = visual->green_mask;
@@ -1167,23 +1369,13 @@
 
   free (lookup);
 }
-#endif
-
-/*
- * Check our parents are still who we think they are.
- * Do transparency updates if required
- */
-int
-rxvt_term::check_our_parents ()
-{
-  check_our_parents_ev.stop ();
-  check_our_parents_ev.start (NOW + .1);
-  return 0;
-}
+#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */
 
+#if 0  /* replaced by a bgPixmap_t::render() - leve here temporarily for reference */
 void
 rxvt_term::check_our_parents_cb (time_watcher &w)
 {
+
   int i, aformat, rootdepth;
   unsigned long nitems, bytes_after;
   Atom atype;
@@ -1366,7 +1558,7 @@
       if (gc != NULL)
         XFreeGC (dpy, gc);
       
-      bgPixmap.apply_background();
+      bgPixmap.apply();
       if (!success)
           am_pixmap_trans = 0;
       else
@@ -1391,4 +1583,4 @@
         }
     }
 }
-#endif
+#endif