[ViewVC] Diff of: cvs/rxvt-unicode/src/background.C

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.9 by sasha, Mon Oct 29 13:39:43 2007 UTC vs.
Revision 1.24 by ayin, Mon Jan 7 12:41:31 2008 UTC

 /*----------------------------------------------------------------------*
  * File:	background.C - former xpm.C
  *----------------------------------------------------------------------*
  *
  * All portions of code are copyright by their respective author/s.
- * Copyright (c) 1997      Carsten Haitzler <raster@zip.com.au>
- * Copyright (c) 1997,1998 Oezguer Kesim <kesim@math.fu-berlin.de>
- * Copyright (c) 1998-2001 Geoff Wing <gcw@pobox.com>
  * Copyright (c) 2005-2006 Marc Lehmann <pcg@goof.com>
  * Copyright (c) 2007      Sasha Vasko <sasha@aftercode.net>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
 #include "rxvt.h"		/* NECESSARY */
 #define DO_TIMING_TEST 0
 #if DO_TIMING_TEST
+# include <sys/time.h>
 #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)
  * scale      Scale both up and down
  * auto       Same as 100x100+50+50
  */
 #ifdef HAVE_BG_PIXMAP
-bgPixmap_t::bgPixmap_t()
+bgPixmap_t::bgPixmap_t ()
 {
 #ifdef HAVE_AFTERIMAGE
   original_asim = NULL;
 #endif
 #ifdef BG_IMAGE_FROM_FILE
   h_scale = v_scale = 0;
   h_align = v_align = 0;
 #endif
   flags = 0;
   pixmap = None;
+  valid_since = invalid_since = 0;
 }
+void
+bgPixmap_t::destroy ()
+{
+#ifdef HAVE_AFTERIMAGE
+  if (original_asim)
+    safe_asimage_destroy (original_asim);
+#endif
+  if (pixmap && target)
+    XFreePixmap (target->dpy, pixmap);
+}
 bool
 bgPixmap_t::window_size_sensitive ()
 {
+# ifdef ENABLE_TRANSPARENCY
+  if (flags & isTransparent)
+    return true;
+# endif
 # ifdef BG_IMAGE_FROM_FILE
 #  ifdef HAVE_AFTERIMAGE
   if (original_asim != NULL)
 #  endif
     {
       if (h_scale != 0 || v_scale != 0
           || h_align != 0 || v_align != 0)
         return true;
     }
 # endif
+  return false;
+}
+bool
+bgPixmap_t::window_position_sensitive ()
+{
 # ifdef ENABLE_TRANSPARENCY
   if (flags & isTransparent)
     return true;
 # endif
+# ifdef BG_IMAGE_FROM_FILE
+#  ifdef HAVE_AFTERIMAGE
+  if (original_asim != NULL)
+#  endif
+    {
+      if (h_align == rootAlign || v_align == rootAlign)
+        return true;
+    }
+# endif
   return false;
-}
+};
 bool bgPixmap_t::need_client_side_rendering ()
 {
 # ifdef HAVE_AFTERIMAGE
   if (original_asim != NULL)
 static inline bool
 check_set_align_value (int geom_flags, int flag, int &align, int new_value)
 {
   if (geom_flags & flag)
     {
+      if (new_value != bgPixmap_t::rootAlign)
+        {
-      if (new_value < -100)
+          if (new_value < -100)
-        new_value = -100;
+            new_value = -100;
-      else if (new_value > 200)
+          else if (new_value > 200)
-        new_value = 200;
+            new_value = 200;
+        }
       if (new_value != align)
         {
           align = new_value;
           return true;
         }
   int x = 0, y = 0;
   unsigned int w = 0, h = 0;
   unsigned int n;
   unsigned long new_flags = (flags & (~geometryFlags));
   char *p;
-#  define MAXLEN_GEOM		256 /* could be longer then regular geometry string */
+#  define MAXLEN_GEOM		256 /* could be longer than regular geometry string */
   if (geom == NULL)
     return false;
   char str[MAXLEN_GEOM];
   if (n < MAXLEN_GEOM)
     {
       char *ops;
       new_flags |= geometrySet;
-      strncpy (str, geom, n);
+      memcpy (str, geom, n);
       str[n] = '\0';
       if (str[0] == ':')
         ops = &str[0];
       else if (str[0] != 'x' && str[0] != 'X' && isalpha(str[0]))
         ops = &str[0];
               y = x;
               geom_flags |= YValue;
             }
           if (flags & geometrySet)
+            {
-            {/* new geometry is an adjustment to the old one ! */
+              /* new geometry is an adjustment to the old one ! */
               if ((geom_flags & WidthValue) && (geom_flags & HeightValue))
                 {
                   if (w == 0 && h != 0)
                     {
                       w = h_scale;
                 }
             }
           else /* setting up geometry from scratch */
             {
               if (!(geom_flags & XValue))
+                {
-                {/* use default geometry - centered */
+                  /* use default geometry - centered */
                   x = y = defaultAlign;
                 }
               else if (!(geom_flags & YValue))
                 y = x;
               if ((geom_flags & (WidthValue|HeightValue)) == 0)
+                {
-                {/* use default geometry - scaled */
+                  /* use default geometry - scaled */
                   w = h = defaultScale;
                 }
               else if (geom_flags & WidthValue)
                 {
                   if (!(geom_flags & HeightValue))
               else
                 w = h;
             }
         } /* done parsing geometry string */
       else if (!(flags & geometrySet))
+        {
-        { /* default geometry - scaled and centered */
+          /* default geometry - scaled and centered */
           x = y = defaultAlign;
           w = h = defaultScale;
         }
       if (!(flags & geometrySet))
         geom_flags |= WidthValue|HeightValue|XValue|YValue;
       if (ops)
         {
             {
               while (*ops == ':' || isspace(*ops)) ++ops;
 #  define CHECK_GEOM_OPS(op_str)  (strncasecmp (ops, (op_str), sizeof(op_str)-1) == 0)
               if (CHECK_GEOM_OPS("tile"))
                 {
-                  w = h = 0;
+                  w = h = noScale;
                   geom_flags |= WidthValue|HeightValue;
                 }
               else if (CHECK_GEOM_OPS("propscale"))
                 {
                   if (w == 0 && h == 0)
                     {
-                      w = 100;
+                      w = windowScale;
                       geom_flags |= WidthValue;
                     }
                   new_flags |= propScale;
                 }
               else if (CHECK_GEOM_OPS("hscale"))
                 {
                   if (w == 0)
-                    w = 100;
+                    w = windowScale;
-                  h = 0;
+                  h = noScale;
                   geom_flags |= WidthValue|HeightValue;
                 }
               else if (CHECK_GEOM_OPS("vscale"))
                 {
                   if (h == 0)
-                    h = 100;
+                    h = windowScale;
-                  w = 0;
+                  w = noScale;
                   geom_flags |= WidthValue|HeightValue;
                 }
               else if (CHECK_GEOM_OPS("scale"))
                 {
                   if (h == 0)
-                    h = 100;
+                    h = windowScale;
                   if (w == 0)
-                    w = 100;
+                    w = windowScale;
                   geom_flags |= WidthValue|HeightValue;
                 }
               else if (CHECK_GEOM_OPS("auto"))
                 {
+                  w = h = windowScale;
+                  x = y = centerAlign;
+                  geom_flags |= WidthValue|HeightValue|XValue|YValue;
+                }
+              else if (CHECK_GEOM_OPS("root"))
+                {
-                  w = h = 100;
+                  w = h = noScale;
-                  x = y = 50;
+                  x = y = rootAlign;
                   geom_flags |= WidthValue|HeightValue|XValue|YValue;
                 }
 #  undef CHECK_GEOM_OPS
               while (*ops != ':' && *ops != '\0') ++ops;
             } /* done parsing ops */
   if (new_flags != flags)
     {
       flags = new_flags;
       changed++;
     }
-//fprintf( stderr, "flags = %lX, scale = %ux%u, align=%+d%+d\n",
+//fprintf (stderr, "flags = %lX, scale = %ux%u, align=%+d%+d\n",
 //         flags, h_scale, v_scale, h_align, v_align);
   return (changed > 0);
 }
 #  ifdef HAVE_AFTERIMAGE
   TIMING_TEST_START (asim);
   if (original_asim)
     {
+      if (h_align == rootAlign || v_align == rootAlign)
+        {
+          target->get_window_origin(x, y);
+          x = -x;
+          y = -y;
+        }
+      if (h_align != rootAlign)
-      x = make_align_position (h_align, target_width, w > 0 ? w : (int)original_asim->width);
+        x = make_align_position (h_align, target_width, w > 0 ? w : (int)original_asim->width);
+      if (v_align != rootAlign)
-      y = make_align_position (v_align, target_height, h > 0 ? h : (int)original_asim->height);
+        y = make_align_position (v_align, target_height, h > 0 ? h : (int)original_asim->height);
     }
   if (original_asim == NULL
       || x >= target_width
       || y >= target_height
     {
       result = original_asim;
       if ((w > 0 && w != original_asim->width)
           || (h > 0 && h != original_asim->height))
         {
           result = scale_asimage (target->asv, original_asim,
                                   w > 0 ? w : original_asim->width,
                                   h > 0 ? h : original_asim->height,
                                   background ? ASA_ASImage : ASA_XImage,
                                   100, ASIMAGE_QUALITY_DEFAULT);
         }
       if (background == NULL)
+        {
-        {/* if tiling - pixmap has to be sized exactly as the image */
+          /* if tiling - pixmap has to be sized exactly as the image,
+             but there is no need to make it bigger than the window! */
           if (h_scale == 0)
-            new_pmap_width = result->width;
+            new_pmap_width = min (result->width, target_width);
           if (v_scale == 0)
-            new_pmap_height = result->height;
+            new_pmap_height = min (result->height, target_height);
           /* we also need to tile our image in one or both directions */
           if (h_scale == 0 || v_scale == 0)
             {
               ASImage *tmp = tile_asimage (target->asv, result,
                                             (h_scale > 0) ? 0 : (int)result->width - x,
                                             (v_scale > 0) ? 0 : (int)result->height - y,
+                                            new_pmap_width,
-                                            result->width, result->height,
+                                            new_pmap_height,
                                             TINT_LEAVE_SAME, ASA_XImage,
                                             100, ASIMAGE_QUALITY_DEFAULT);
               if (tmp)
                 {
                   if (result != original_asim)
                   result = tmp;
                 }
             }
         }
       else
+        {
-        {/* if blending background and image - pixmap has to be sized same as target window */
+          /* if blending background and image - pixmap has to be sized same as target window */
           ASImageLayer *layers = create_image_layers (2);
           ASImage *merged_im = NULL;
           layers[0].im = background;
           layers[0].clip_width = target_width;
           layers[0].clip_height = target_height;
           layers[0].tint = background_tint;
           layers[1].im = result;
           if (w <= 0)
+            {
-            {/* tile horizontally */
+              /* tile horizontally */
               while (x > 0) x -= (int)result->width;
               layers[1].dst_x = x;
               layers[1].clip_width = result->width+target_width;
             }
           else
+            {
-            {/* clip horizontally */
+              /* clip horizontally */
               layers[1].dst_x = x;
               layers[1].clip_width = result->width;
             }
           if (h <= 0)
             {
         }
       /* put result on pixmap */
       if (dst_x < new_pmap_width && dst_y < new_pmap_height)
         asimage2drawable (target->asv, pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);
       if (result != background && result != original_asim)
         destroy_asimage (&result);
       XFreeGC (target->dpy, gc);
       TIMING_TEST_PRINT_RESULT (asim);
         original_asim = get_asimage (target->asimman, file, 0xFFFFFFFF, 100);
       else
         {
           size_t len = f - file;
           f = (char *)malloc (len + 1);
-          strncpy (f, file, len);
+          memcpy (f, file, len);
           f[len] = '\0';
           original_asim = get_asimage (target->asimman, f, 0xFFFFFFFF, 100);
           free (f);
         }
       return (original_asim != NULL);
 #  endif
     }
   return false;
 }
-# endif	/* BG_IMAGE_FROM_FILE */
+# endif /* BG_IMAGE_FROM_FILE */
 # ifdef ENABLE_TRANSPARENCY
 bool
 bgPixmap_t::set_transparent ()
 {
   if (!(flags & isTransparent))
     {
       flags |= isTransparent;
   if (v_blurRadius != vr)
     {
       ++changed;
       v_blurRadius = vr;
     }
   if (v_blurRadius == 0 && h_blurRadius == 0)
     flags &= ~blurNeeded;
   else
     flags |= blurNeeded;
           && (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;
       else
       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 ()
   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 < 0 && new_shade > -100)
-		new_shade = 200 - (100 + new_shade);
+    new_shade = 200 - (100 + new_shade);
   else 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 | tintSet)) | 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.
  */
 unsigned long
 bgPixmap_t::make_transparency_pixmap ()
 {
   if (sx + window_width <= 0 || sy + window_height <= 0
       || sx >= root_width || sy >= root_height)
     return 0;
   if (root_pixmap != None)
+    {
-    {/* we want to validate the pixmap and get it's size at the same time : */
+      /* 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 (tiled_root_pmap == None) /* something really bad happened - abort */
     return 0;
   if (root_pixmap == None)
+    {
-    { /* use tricks to obtain the root background image :*/
+      /* 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;
           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 : */
+           * but to be on the safe side - let's check for the actual event to arrive : */
           while (XCheckWindowEvent (dpy, src, ExposureMask, &event))
             ++ev_count;
           if (ev_count > 0);
+            {
-            { /* hooray! - we can grab the image! */
+              /* 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);
         }
           }
         else
           result |= transpPmapTiled;
     }
   else
+    {
-    {/* strightforward pixmap copy */
+      /* strightforward pixmap copy */
       gcv.tile = root_pixmap;
       gcv.fill_style = FillTiled;
       while (sx < 0) sx += (int)root_width;
       while (sy < 0) sy += (int)root_height;
     }
   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
                     {
                       c.r = (c.r * shade) / 100;
                       c.g = (c.g * shade) / 100;
                       c.b = (c.b * shade) / 100;
                     }
-                  else if( shade > 100 && shade < 200)
+                  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;
                     }
                   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)
                       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 */
       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);
+  Pixmap 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 /* 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;
           ShadeXImage (target, result, shade, c.r, c.g, c.b);
         }
     }
 # endif /* HAVE_AFTERIMAGE */
-  if (result != NULL)
+  if (result)
     {
       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_width  = result->width;
               pmap_height = result->height;
-              pmap_depth = target->depth;
+              pmap_depth  = target->depth;
             }
           if (pmap_depth != result->depth)
+            {
-            { /* Bad Match error will ensue ! stupid X !!!! */
+              /* Bad Match error will ensue ! stupid X !!!! */
-              if( result->depth == 24 && pmap_depth == 32)
+              if (result->depth == 24 && pmap_depth == 32)
                 result->depth = 32;
-              else if( result->depth == 32 && pmap_depth == 24)
+              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)
     {
         }
     }
   apply ();
+  XSync (target->dpy, False);
+  valid_since = ev::now ();
   TIMING_TEST_PRINT_RESULT (tp);
   return true;
 }
 bool
 bgPixmap_t::set_target (rxvt_term *new_target)
 {
   if (new_target)
     if (target != new_target)
       {
       }
   return false;
 }
 void
-bgPixmap_t::apply()
+bgPixmap_t::apply ()
 {
   if (target)
     {
       flags &= ~isVtOrigin;
       if (pixmap != None)
+        {
-        { /* set target's background to pixmap */
+          /* set target's background to pixmap */
 # ifdef ENABLE_TRANSPARENCY
           if (flags & isTransparent)
             {
               XSetWindowBackgroundPixmap (target->dpy, target->parent[0], pixmap);
               XSetWindowBackgroundPixmap (target->dpy, target->vt, ParentRelative);
                   XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);
 # endif
             }
         }
       else
+        {
-        { /* set target background to a pixel */
+          /* set target background to a pixel */
           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 or vt. It is better to use
          scr_touch or we get a great deal of flicker otherwise: */
       XClearWindow (target->dpy, target->parent[0]);
 # if HAVE_SCROLLBARS
       if (target->scrollBar.win)
       target->want_refresh = 1;
       flags |= hasChanged;
     }
 }
-#endif    /* HAVE_BG_PIXMAP */
+#endif /* HAVE_BG_PIXMAP */
 #if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) && !XFT
 /* taken from aterm-0.4.2 */
 typedef uint32_t RUINT32T;

Diff Legend

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

Comparing rxvt-unicode/src/background.C (file contents): Revision 1.9 by sasha, Mon Oct 29 13:39:43 2007 UTC vs. Revision 1.24 by ayin, Mon Jan 7 12:41:31 2008 UTC

Diff Legend

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.9 by sasha, Mon Oct 29 13:39:43 2007 UTC vs.
Revision 1.24 by ayin, Mon Jan 7 12:41:31 2008 UTC