--- rxvt-unicode/src/xpm.C	2007/08/08 22:39:49	1.63
+++ rxvt-unicode/src/xpm.C	2007/09/12 19:51:41	1.76
@@ -26,6 +26,23 @@
 #include "../config.h"		/* NECESSARY */
 #include "rxvt.h"		/* NECESSARY */
 
+#define DO_TIMING_TEST 0
+
+#if DO_TIMING_TEST
+#define TIMING_TEST_START(id) \
+	struct timeval timing_test_##id##_stv;\
+  gettimeofday (&timing_test_##id##_stv, NULL);
+  
+#define TIMING_TEST_PRINT_RESULT(id) \
+  do{ struct timeval tv;gettimeofday (&tv, NULL); tv.tv_sec -= (timing_test_##id##_stv).tv_sec;\
+      fprintf (stderr, "%s: %s: %d: elapsed  %ld usec\n", #id, __FILE__, __LINE__,\
+               tv.tv_sec * 1000000 + tv.tv_usec - (timing_test_##id##_stv).tv_usec);}while (0)
+
+#else
+#define TIMING_TEST_START(id) do{}while (0)
+#define TIMING_TEST_PRINT_RESULT(id) do{}while (0)
+#endif
+
 /*
  * Pixmap geometry string interpretation :
  * Each geometry string contains zero or one scale/position
@@ -79,14 +96,32 @@
   if (original_asim != NULL)
 #  endif
     {
-      if (h_scale != 0 || v_scale != 0)
+      if (h_scale != 0 || v_scale != 0
+          || h_align != 0 || v_align != 0)
         return true;
     }
 # endif
 # ifdef ENABLE_TRANSPARENCY
-  if (flags & bgPmap_Transparent)
+  if (flags & isTransparent)
+    return true;
+# endif
+  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 & blurServerSide))
+          || ((flags & tintNeeded) && !(flags & tintServerSide)))
+        return true;    
+    }
+# endif
   return false;
 }
 
@@ -162,13 +197,13 @@
 }
 
 bool
-bgPixmap_t::handle_geometry (const char *geom)
+bgPixmap_t::set_geometry (const char *geom)
 {
   int geom_flags = 0, changed = 0;
   int x = 0, y = 0;
   unsigned int w = 0, h = 0;
   unsigned int n;
-  unsigned long new_flags = (flags&(~bgPmap_geometryFlags));
+  unsigned long new_flags = (flags & (~geometryFlags));
   char *p;
 #  define MAXLEN_GEOM		256 /* could be longer then regular geometry string */
 
@@ -177,17 +212,6 @@
 
   char str[MAXLEN_GEOM];
 
-  if (!strcmp (geom, "?"))
-    {
-      if (target)
-        {
-          sprintf (str, "[%dx%d+%d+%d]",	/* can't presume snprintf () ! */
-                   min (h_scale, 32767), min (v_scale, 32767),
-                   min (h_align, 32767), min (v_align, 32767));
-          target->process_xterm_seq (XTerm_title, str, CHAR_ST);
-        }
-      return false;
-    }
   while (isspace(*geom)) ++geom;
   if ((p = strchr (geom, ';')) == NULL)
     p = strchr (geom, '\0');
@@ -196,7 +220,7 @@
   if (n < MAXLEN_GEOM)
     {
       char *ops;
-      new_flags |= bgPmap_geometrySet;
+      new_flags |= geometrySet;
 
       strncpy (str, geom, n);
       str[n] = '\0';
@@ -227,7 +251,7 @@
               geom_flags |= YValue;
             }
 
-          if (flags & bgPmap_geometrySet)
+          if (flags & geometrySet)
             {/* new geometry is an adjustment to the old one ! */
               if ((geom_flags & WidthValue) && (geom_flags & HeightValue))
                 {
@@ -255,14 +279,14 @@
             {
               if (!(geom_flags & XValue))
                 {/* use default geometry - centered */
-                  x = y = bgPmap_defaultAlign;
+                  x = y = defaultAlign;
                 }
               else if (!(geom_flags & YValue))
                 y = x;
 
               if ((geom_flags & (WidthValue|HeightValue)) == 0)
                 {/* use default geometry - scaled */
-                  w = h = bgPmap_defaultScale;
+                  w = h = defaultScale;
                 }
               else if (geom_flags & WidthValue)
                 {
@@ -273,13 +297,13 @@
                 w = h;
             }
         } /* done parsing geometry string */
-      else if (!(flags & bgPmap_geometrySet))
+      else if (!(flags & geometrySet))
         { /* default geometry - scaled and centered */
-          x = y = bgPmap_defaultAlign;
-          w = h = bgPmap_defaultScale;
+          x = y = defaultAlign;
+          w = h = defaultScale;
         }
         
-      if (!(flags & bgPmap_geometrySet))
+      if (!(flags & geometrySet))
         geom_flags |= WidthValue|HeightValue|XValue|YValue;
 
       if (ops)
@@ -300,7 +324,7 @@
                       w = 100;
                       geom_flags |= WidthValue;
                     }
-                  new_flags |= bgPmap_propScale;
+                  new_flags |= propScale;
                 }
               else if (CHECK_GEOM_OPS("hscale"))
                 {
@@ -372,6 +396,8 @@
   int w = h_scale * target_width / 100;
   int h = v_scale * target_height / 100;
 
+  TIMING_TEST_START (asim);
+
   if (original_asim)
     {
       x = make_align_position (h_align, target_width, w > 0 ? w : (int)original_asim->width);
@@ -485,6 +511,7 @@
           free (layers);
         }
     }
+  TIMING_TEST_PRINT_RESULT (asim);
 
   if (pixmap)
     {
@@ -540,163 +567,729 @@
         destroy_asimage (&result);
 
       XFreeGC (target->dpy, gc);
-      if (background)
-        flags |= bgPmap_Transparent;
-      else
-        flags &= ~bgPmap_Transparent;
+      TIMING_TEST_PRINT_RESULT (asim);
     }
 
   return true;
 }
 #  endif /* HAVE_AFTERIMAGE */
 
-void
-rxvt_term::resize_pixmap ()
-{
-
-#  ifdef ENABLE_TRANSPARENCY
-  if (option(Opt_transparent) && am_transparent)
-    {
-      /*  we need to re-generate transparency pixmap in that case ! */
-      check_our_parents ();
-      return;      
-    }
-#  endif
-#  ifdef HAVE_AFTERIMAGE
-  bgPixmap.render_asim(NULL, TINT_LEAVE_SAME);
-  bgPixmap.apply_background();
-#  endif
-}
-
-void
-rxvt_term::set_bgPixmap (const char *file)
+bool
+bgPixmap_t::set_file (const char *file)
 {
   char *f;
 
   assert (file != NULL);
 
-  if (bgPixmap.pixmap != None)
-    {
-      XFreePixmap (dpy, bgPixmap.pixmap);
-      bgPixmap.pixmap = None;
-    }
-
-  XSetWindowBackground (dpy, vt, pix_colors[Color_bg]);
   if (*file != '\0')
     {
 #  ifdef HAVE_AFTERIMAGE
-      if (asimman == NULL)
-        asimman = create_generic_imageman(rs[Rs_path]);
+      if (target->asimman == NULL)
+        target->asimman = create_generic_imageman (target->rs[Rs_path]);
       if ((f = strchr (file, ';')) == NULL)
-        bgPixmap.original_asim = get_asimage( asimman, file, 0xFFFFFFFF, 100 );
+        original_asim = get_asimage (target->asimman, file, 0xFFFFFFFF, 100);
       else
         {
           size_t len = f - file;
           f = (char *)malloc (len + 1);
           strncpy (f, file, len);
           f[len] = '\0';
-          bgPixmap.original_asim = get_asimage( asimman, f, 0xFFFFFFFF, 100 );
-          free( f );
+          original_asim = get_asimage (target->asimman, f, 0xFFFFFFFF, 100);
+          free (f);
         }
+      return (original_asim != NULL);
 #  endif    
     }
-    resize_pixmap (); /* TODO: temporary fix - should be done by the caller! */
+  return false;
 }
 
 # endif	/* XPM_BACKGROUND */
 
 # ifdef ENABLE_TRANSPARENCY
+bool 
+bgPixmap_t::set_transparent ()
+{
+  if (!(flags & isTransparent))
+    {
+      flags |= isTransparent;
+      return true;
+    }
+  return false;
+}
+
+bool
+bgPixmap_t::set_blur_radius (const char *geom)
+{
+  int changed = 0;
+  unsigned int hr, vr;
+  int junk;
+  int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr);
+
+  if (!(geom_flags&WidthValue))
+    hr = 1;
+  if (!(geom_flags&HeightValue))
+    vr = hr;
+
+  if (h_blurRadius != hr)
+    {
+      ++changed;
+      h_blurRadius = hr;
+    }
+
+  if (v_blurRadius != vr)
+    {
+      ++changed;
+      v_blurRadius = vr;
+    }
+    
+  if (v_blurRadius == 0 && h_blurRadius == 0)
+    flags &= ~blurNeeded;
+  else
+    flags |= blurNeeded;
+
+  return (changed>0);
+}
+
+static inline unsigned long
+compute_tint_shade_flags (rxvt_color *tint, int shade)
+{
+  unsigned long flags = 0;
+  rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
+
+  if (tint)
+    {
+      tint->get (c);
+#  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::tintWholesome;
+#  undef  IS_COMPONENT_WHOLESOME
+    }
+
+  if ((shade > 0 && shade < 100) || (shade > 100 && shade < 200))
+    flags |= bgPixmap_t::tintNeeded;
+  else if (tint)
+    {
+      if ((c.r > 0x000700 || c.g > 0x000700 || c.b > 0x000700)
+          && (c.r < 0x00f700 || c.g < 0x00f700 || c.b < 0x00f700))
+      {
+        flags |= bgPixmap_t::tintNeeded;
+      }
+    }
+    
+  if (flags & bgPixmap_t::tintNeeded)
+    {
+      if (flags & bgPixmap_t::tintWholesome)
+        flags |= bgPixmap_t::tintServerSide;
+#if XFT
+      flags |= bgPixmap_t::tintServerSide;
+#endif
+    }
+
+  return flags;
+}
+
+bool
+bgPixmap_t::set_tint (rxvt_color &new_tint)
+{
+  if (tint != new_tint)
+    {
+      unsigned long new_flags = compute_tint_shade_flags (&new_tint, shade);
+      tint = new_tint;
+      flags = (flags & ~tintFlags) | new_flags | tintSet;
+      return true;
+    }
+  return false;
+}
+
+bool
+bgPixmap_t::unset_tint ()
+{
+  unsigned long new_flags = compute_tint_shade_flags (NULL, shade);
+
+  if (new_flags != (flags & tintFlags))
+    {
+     flags = (flags&~tintFlags)|new_flags;
+     return true;
+    }
+  return false;
+}
+
+bool
+bgPixmap_t::set_shade (const char *shade_str)
+{
+  int new_shade = (shade_str) ? atoi (shade_str) : 0;
+
+  if (new_shade == 100)
+    new_shade = 0;
+
+  if (new_shade != shade)
+    {
+      unsigned long new_flags = compute_tint_shade_flags ((flags & tintSet) ? &tint : NULL, new_shade);
+      shade = new_shade;
+      flags = (flags & ~tintFlags) | new_flags;
+      return true;
+    }
+  return false;
+}
+
 /* make_transparency_pixmap() 
  * Builds a pixmap sized the same as terminal window, with depth same as the root window
  * that pixmap contains tiled portion of the root pixmap that is supposed to be covered by 
  * our window.
  */
-#if 0
-bool
-bgPixmap_t::make_transparency_pixmap()
+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 :
+   */
+  Window root = target->display->root;
+  int screen = target->display->screen;
+  Display *dpy = target->dpy;
+  int root_width = DisplayWidth (dpy, screen);
+  int root_height = DisplayHeight (dpy, screen);
+  unsigned int root_pmap_width, root_pmap_height;
+  int window_width = target->szHint.width;
+  int window_height = target->szHint.height;
   int sx, sy;
-  Window cr;
-  XTranslateCoordinates (target->dpy, target->parent[0], target->display->root,
-                          0, 0, &sx, &sy, &cr);
+  XGCValues gcv;
 
-    /* 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 )
-    return false ;
-  
-  XWindowAttributes wattr, wrootattr;
+  TIMING_TEST_START (tp);
+  target->get_window_origin (sx, sy);
 
-  XGetWindowAttributes (dpy, display->root, &wrootattr);
- 
-  /*
-   * Make the frame window set by the window manager have
-   * the root background. Some window managers put multiple nested frame
-   * windows for each client, so we have to take care about that.
-   */
-  i = (xa[XA_XROOTPMAP_ID]
-       && XGetWindowProperty (dpy, display->root, xa[XA_XROOTPMAP_ID],
-                              0L, 1L, False, XA_PIXMAP, &atype, &aformat,
-                              &nitems, &bytes_after, &prop) == Success);
+  /* 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 0;
 
-  if (!i || prop == NULL)
-     i = (xa[XA_ESETROOT_PMAP_ID]
-          && XGetWindowProperty (dpy, display->root, xa[XA_ESETROOT_PMAP_ID],
-                                 0L, 1L, False, XA_PIXMAP, &atype, &aformat,
-                                 &nitems, &bytes_after, &prop) == Success);
+  if (root_pixmap != None)
+    {/* we want to validate the pixmap and get it's size at the same time : */
+      int junk;
+      unsigned int ujunk;
+      /* root pixmap may be bad - allow a error */
+      target->allowedxerror = -1;
 
-  if (!i || prop == NULL)
-    rootpixmap = None;
+      if (!XGetGeometry (dpy, root_pixmap, &root, &junk, &junk, &root_pmap_width, &root_pmap_height, &ujunk, &ujunk))
+        root_pixmap = None;
+
+      target->allowedxerror = 0;
+    }
+
+  Pixmap tiled_root_pmap = XCreatePixmap (dpy, root, window_width, window_height, root_depth);
+  GC gc = NULL;
+
+  if (tiled_root_pmap == None) /* something really bad happened - abort */
+    return 0;
+
+  if (root_pixmap == None)
+    { /* use tricks to obtain the root background image :*/
+      /* we want to create Overrideredirect window overlapping out window
+         with background type of Parent Relative and then grab it */
+      XSetWindowAttributes attr;
+      Window src;
+      bool success = false;
+
+      attr.background_pixmap = ParentRelative;
+      attr.backing_store = Always;
+      attr.event_mask = ExposureMask;
+      attr.override_redirect = True;
+  	  src = XCreateWindow (dpy, root, sx, sy, window_width, window_height, 0,
+                           CopyFromParent, CopyFromParent, CopyFromParent,
+                           CWBackPixmap|CWBackingStore|CWOverrideRedirect|CWEventMask,
+                           &attr);
+
+      if (src != None)
+        {
+          XEvent event;
+          int ev_count = 0;
+          XGrabServer (dpy);
+          XMapRaised (dpy, src);
+          XSync (dpy, False);
+
+          /* XSync should get window where it's properly exposed,
+           * but to be on the safe side - let's check for the actuall event to arrive : */
+          while (XCheckWindowEvent (dpy, src, ExposureMask, &event))
+            ++ev_count;
+
+          if (ev_count > 0);
+            { /* hooray! - we can grab the image! */
+              gc = XCreateGC (dpy, root, 0, NULL);
+              if (gc)
+                {
+                  XCopyArea (dpy, src, tiled_root_pmap, gc, 0, 0, window_width, window_height, 0, 0);
+                  success = true;
+                }
+            }
+          XDestroyWindow (dpy, src);
+          XUngrabServer (dpy);
+          //fprintf (stderr, "%s:%d: ev_count = %d\n", __FUNCTION__, __LINE__, ev_count);
+        }
+
+        if (!success)
+          {
+            XFreePixmap (dpy, tiled_root_pmap);
+            tiled_root_pmap = None;
+          }
+        else
+          result |= transpPmapTiled;
+    }
+  else
+    {/* strightforward pixmap copy */
+      gcv.tile = root_pixmap;
+      gcv.fill_style = FillTiled;
+
+      while (sx < 0) sx += (int)window_width;
+      while (sy < 0) sy += (int)window_height;
+
+      gcv.ts_x_origin = -sx;
+      gcv.ts_y_origin = -sy;
+      gc = XCreateGC (dpy, root, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
+
+      if (gc)
+        {
+          XFillRectangle (dpy, tiled_root_pmap, gc, 0, 0, window_width, window_height);
+          result |= transpPmapTiled;
+        }
+    }
+  TIMING_TEST_PRINT_RESULT (tp);
+
+  if (tiled_root_pmap != None)
+    {
+      if (!need_client_side_rendering ()) 
+        {
+          if ((flags & tintNeeded)) 
+            {
+              if (flags & tintWholesome)
+                {
+                  /* 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;
+                    }
+                }
+              else
+                {
+#  if XFT
+                  Picture back_pic = 0;
+                  rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
+
+                  if (flags & tintSet)
+                    tint.get (c);
+
+                  if (shade > 0 && shade < 100)
+                    {
+                      c.r = (c.r * shade) / 100;
+                      c.g = (c.g * shade) / 100;
+                      c.b = (c.b * shade) / 100;
+                    }
+                  else if( shade > 100 && shade < 200)
+                    {
+                      c.r = (c.r * (200 - shade)) / 100;
+                      c.g = (c.g * (200 - shade)) / 100;
+                      c.b = (c.b * (200 - shade)) / 100;
+                    }
+
+                  XRenderPictFormat pf;
+                  pf.type = PictTypeDirect;
+                  pf.depth = 32;
+                  pf.direct.redMask = 0xff;
+                  pf.direct.greenMask = 0xff;
+                  pf.direct.blueMask = 0xff;
+                  pf.direct.alphaMask = 0xff;
+
+                  XRenderPictFormat *solid_format = XRenderFindFormat (dpy,
+                                                    					        (PictFormatType|
+					                                                             PictFormatDepth|
+					                                                             PictFormatRedMask|
+					                                                             PictFormatGreenMask|
+					                                                             PictFormatBlueMask|
+					                                                             PictFormatAlphaMask),
+					                                                            &pf,
+					                                                            0);
+                  XRenderPictFormat *root_format = XRenderFindVisualFormat (dpy, DefaultVisualOfScreen (ScreenOfDisplay (dpy, target->display->screen)));
+                  XRenderPictureAttributes pa ;
+
+                  back_pic = XRenderCreatePicture (dpy, tiled_root_pmap, root_format, 0, &pa);
+
+                  pa.repeat = True;
+
+                  Pixmap overlay_pmap = XCreatePixmap (dpy, root, 1, 1, 32);
+                  Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
+                  XFreePixmap (dpy, overlay_pmap);
+
+                  pa.component_alpha = True;              
+                  Pixmap mask_pmap = XCreatePixmap (dpy, root, 1, 1, 32);
+                  Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat|CPComponentAlpha, &pa);
+                  XFreePixmap (dpy, mask_pmap);
+
+                  if (mask_pic && overlay_pic && back_pic)
+                    {
+                      XRenderColor mask_c;
+
+                      memset (&mask_c, (shade > 100) ? 0xFF : 0x0, sizeof (mask_c));
+                      mask_c.alpha = 0xffff;
+                      XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
+                      memset (&mask_c,  0x0, sizeof (mask_c));
+                      mask_c.alpha = 0;
+
+                      if (c.r == c.b && c.b == c.g) /* pure shading */
+                        {
+                          mask_c.red = mask_c.green = mask_c.blue = 0xffff - c.r;
+                          XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
+                          XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, window_width, window_height);
+                        }
+                      else
+                        {
+                          mask_c.red = 0xffff - c.r;
+                          XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
+                          XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, window_width, window_height);
+                          mask_c.red = 0;
+                          mask_c.green = 0xffff - c.g;
+                          XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
+                          XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, window_width, window_height);
+                          mask_c.green = 0;
+                          mask_c.blue = 0xffff - c.b;
+                          XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
+                          XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, window_width, window_height);
+                        }
+                        result |= transpPmapTinted;
+                    }
+                  XRenderFreePicture (dpy, mask_pic);
+                  XRenderFreePicture (dpy, overlay_pic);
+                  XRenderFreePicture (dpy, back_pic);
+#   if DO_TIMING_TEST
+                  XSync (dpy, False);
+#   endif                  
+#  endif
+                }
+             }
+        } /* server side rendering completed */
 
+      if (pixmap)
+        XFreePixmap (dpy, pixmap);
+
+      pixmap = tiled_root_pmap;
+      pmap_width = window_width;
+      pmap_height = window_height;
+      pmap_depth = root_depth;
+    }
+      
+  if (gc)
+    XFreeGC (dpy, gc);
+
+  TIMING_TEST_PRINT_RESULT (tp);
+    
+  return result;    
+}
+
+bool
+bgPixmap_t::set_root_pixmap ()
+{
+  Pixmap new_root_pixmap = None;
+  
+  new_root_pixmap = target->get_pixmap_property (XA_XROOTPMAP_ID);
+  if (new_root_pixmap == None)
+    new_root_pixmap = target->get_pixmap_property (XA_ESETROOT_PMAP_ID);
+
+  if (new_root_pixmap != root_pixmap)
+    {
+      root_pixmap = new_root_pixmap;
+      return true;
+    }
+  return false;
 }
-#endif /* 0 */
 # 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 ()
+{
+  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 ! */
+      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
+  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;      
+}
+
+bool 
+bgPixmap_t::set_target (rxvt_term *new_target)
+{
+  if (new_target)
+    if (target != new_target)
+      {
+        target = new_target;
+# ifdef ENABLE_TRANSPARENCY
+        root_depth = DefaultDepthOfScreen (ScreenOfDisplay (target->dpy, target->display->screen));
+# endif
+        return true;
+      }
+  return false;
+}
+
 void
-bgPixmap_t::apply_background()
+bgPixmap_t::apply()
 {
   if (target)
     {
+      flags &= ~isVtOrigin;
       if (pixmap != None)
         { /* set target's background to pixmap */
 # ifdef ENABLE_TRANSPARENCY
-          if (flags & bgPmap_Transparent)
+          if (flags & isTransparent)
             {
               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
             {
+              flags |= isVtOrigin;
               /* 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);
+      /* do want Expose on the vt, so we get refreshed properly */
+      XClearArea (target->dpy, target->vt, 0, 0, 0, 0, True);
+
+# if HAVE_SCROLLBARS
+      if (target->scrollBar.win)
+        {
+          target->scrollBar.setIdle ();
+          target->scrollbar_show (0);
+        }
+# endif
     }
 }
-#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
+rxvt_term::get_pixmap_property (int prop_id)
+{
+  if (prop_id > 0 && prop_id < NUM_XA)
+    if (xa[prop_id])
+      {
+        int aformat;
+        unsigned long nitems, bytes_after;
+        Atom atype;
+        unsigned char *prop = NULL;
+        int result = XGetWindowProperty (dpy, display->root, xa[prop_id],
+                                         0L, 1L, False, XA_PIXMAP, &atype, &aformat,
+                                         &nitems, &bytes_after, &prop);
+        if (result == Success && prop && atype == XA_PIXMAP)
+          {
+            return *(Pixmap *)prop;
+          }
+      }
+  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;
@@ -713,7 +1306,10 @@
 
   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;
@@ -926,23 +1522,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;
@@ -957,17 +1543,6 @@
   if (!option (Opt_transparent))
     return;	/* Don't try any more */
 
-#if 0
-  struct timeval stv;
-	gettimeofday (&stv,NULL);
-#define PRINT_BACKGROUND_OP_TIME do{ struct timeval tv;gettimeofday (&tv,NULL); tv.tv_sec-= stv.tv_sec;\
-                                     fprintf (stderr,"%d: elapsed  %ld usec\n",__LINE__,\
-                                              tv.tv_sec*1000000+tv.tv_usec-stv.tv_usec );}while(0)
-#else                                           
-#define PRINT_BACKGROUND_OP_TIME do{}while(0)                                          
-#endif
- 
-
   XGetWindowAttributes (dpy, display->root, &wrootattr);
   rootdepth = wrootattr.depth;
 
@@ -1049,40 +1624,11 @@
                       && IS_COMPONENT_WHOLESOME(c.b));
       no_tint = (c.r >= 0x00f700 && c.g >= 0x00f700 && c.b >= 0x00f700);
 #undef  IS_COMPONENT_WHOLESOME
-      /* theer are no performance advantages to reusing same pixmap */
-      if (bgPixmap.pixmap != None)
-        XFreePixmap (dpy, bgPixmap.pixmap);
-      bgPixmap.pixmap = XCreatePixmap (dpy, vt, szHint.width, szHint.height, rootdepth);
-      bgPixmap.pmap_width = szHint.width;
-      bgPixmap.pmap_height = szHint.height;
-      bgPixmap.pmap_depth = rootdepth;
-
-#if 0 /* TODO : identify cases where this will be detrimental to performance : */
-      /* we want to tile root pixmap into our own pixmap in this cases :
-       * 1) rootpixmap does not cover our window entirely
-       * 2) whole_tint - we can use server-side tinting or tinting disabled
-       */
-      if ( whole_tint || no_tint || pmap_w < sx + szHint.width || pmap_h < sy + szHint.height)
-        {
-        }
-#endif
-      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, bgPixmap.pixmap, gc, 0, 0, szHint.width, szHint.height);
+
+      bgPixmap.make_transparency_pixmap();
 
       if (whole_tint && !no_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, bgPixmap.pixmap, gc, 0, 0, szHint.width, szHint.height);
         }
       success = True;
 #ifdef HAVE_AFTERIMAGE
@@ -1139,7 +1685,6 @@
           success = False;
           if (image != NULL)
             {
-              PRINT_BACKGROUND_OP_TIME;
               if (gc == NULL)
                 gc = XCreateGC (dpy, vt, 0UL, &gcvalue);
               if (ISSET_PIXCOLOR (Color_tint) || shade != 100)
@@ -1150,12 +1695,11 @@
             }
         }
 #endif  /* HAVE_AFTERIMAGE */
-      PRINT_BACKGROUND_OP_TIME;
 
       if (gc != NULL)
         XFreeGC (dpy, gc);
       
-      bgPixmap.apply_background();
+      bgPixmap.apply();
       if (!success)
           am_pixmap_trans = 0;
       else
@@ -1180,4 +1724,4 @@
         }
     }
 }
-#endif
+#endif