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

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.49 by sf-exg, Tue Aug 31 15:12:49 2010 UTC vs.
Revision 1.63 by sf-exg, Sun Oct 3 21:44:39 2010 UTC

  * adjustment and may optionally be followed by a colon and one or more
  * colon-delimited pixmap operations.
  * The following table shows the valid geometry strings and their
  * effects on the background image :
  *
- * WxH+X+Y  	Set scaling to W% by H%, and position to X% by Y%.
+ * WxH+X+Y    Set scaling to W% by H%, and position to X% by Y%.
  *            W and H are percentages of the terminal window size.
  *            X and Y are also percentages; e.g., +50+50 centers
  *            the image in the window.
- * WxH+X 	    Assumes Y == X
+ * WxH+X      Assumes Y == X
- * WxH 	      Assumes Y == X == 50 (centers the image)
+ * WxH        Assumes Y == X == 50 (centers the image)
- * W+X+Y 	    Assumes H == W
+ * W+X+Y      Assumes H == W
- * W+X 	      Assumes H == W and Y == X
+ * W+X        Assumes H == W and Y == X
- * W 	        Assumes H == W and Y == X == 50
+ * W          Assumes H == W and Y == X == 50
  *
  * Adjusting position only :
- * =+X+Y 	    Set position to X% by Y% (absolute).
+ * =+X+Y      Set position to X% by Y% (absolute).
- * =+X 	      Set position to X% by X%.
+ * =+X        Set position to X% by X%.
- * +X+Y 	    Adjust position horizontally X% and vertically Y%
+ * +X+Y       Adjust position horizontally X% and vertically Y%
  *            from current position (relative).
- * +X   	    Adjust position horizontally X% and vertically X%
+ * +X         Adjust position horizontally X% and vertically X%
  *            from current position.
  *
  * Adjusting scale only :
- * Wx0 	      Multiply horizontal scaling factor by W%
+ * Wx0        Multiply horizontal scaling factor by W%
- * 0xH 	      Multiply vertical scaling factor by H%
+ * 0xH        Multiply vertical scaling factor by H%
- * 0x0 	      No scaling (show image at normal size).
+ * 0x0        No scaling (show image at normal size).
  *
  * Pixmap Operations : (should be prepended by a colon)
- * tile 	    Tile image. Scaling/position modifiers above will affect
+ * tile       Tile image. Scaling/position modifiers above will affect
  *            the tile size and origin.
- * propscale 	When scaling, scale proportionally. That is, maintain the
+ * propscale  When scaling, scale proportionally. That is, maintain the
  *            proper aspect ratio for the image. Any portion of the
  *            background not covered by the image is filled with the
  *            current background color.
  * hscale     Scale horizontally, tile vertically ?
  * vscale     Tile horizontally, scale vertically ?
 {
   // this is basically redundant as bgPixmap_t is only used in
   // zero_initialised-derived structs
 #ifdef HAVE_AFTERIMAGE
   original_asim = NULL;
+#endif
+#ifdef HAVE_PIXBUF
+  pixbuf = NULL;
 #endif
 #ifdef BG_IMAGE_FROM_FILE
   have_image = false;
   h_scale = v_scale = 0;
   h_align = v_align = 0;
 #ifdef HAVE_AFTERIMAGE
   if (original_asim)
     safe_asimage_destroy (original_asim);
 #endif
+#ifdef HAVE_PIXBUF
+  if (pixbuf)
+    g_object_unref (pixbuf);
+#endif
   if (pixmap && target)
     XFreePixmap (target->dpy, pixmap);
 }
 bool
 # endif
 # ifdef BG_IMAGE_FROM_FILE
   if (have_image)
     {
-      if (h_scale != 0 || v_scale != 0
+      if (flags & sizeSensitive)
-          || h_align != 0 || v_align != 0)
         return true;
     }
 # endif
   return false;
 # endif
 # ifdef BG_IMAGE_FROM_FILE
   if (have_image)
     {
-      if (h_align == rootAlign || v_align == rootAlign)
+      if (flags & rootAlign)
         return true;
     }
 # endif
   return false;
 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;
         }
 static inline int
 make_align_position (int align, int window_size, int image_size)
 {
   int diff = window_size - image_size;
-  int smaller = MIN (image_size,window_size);
+  int smaller = min (image_size, window_size);
   if (align >= 0 && align <= 50)
     return diff * align / 100;
   else if (align > 50 && align <= 100)
     return window_size - image_size - diff * (100 - align) / 100;
 make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)
 {
   int src_pos = 0;
   dst_pos = 0;
   dst_size = size;
-  if (pos < 0 && size > target_size)
+  if (pos < 0)
     {
       src_pos = -pos;
       dst_size += pos;
     }
   else if (pos > 0)
                   w = h = noScale;
                   geom_flags |= WidthValue|HeightValue;
                 }
               else if (CHECK_GEOM_OPS ("propscale"))
                 {
-                  if (w == 0 && h == 0)
-                    {
-                      w = windowScale;
-                      geom_flags |= WidthValue;
-                    }
                   new_flags |= propScale;
                 }
               else if (CHECK_GEOM_OPS ("hscale"))
                 {
                   if (w == 0) w = windowScale;
                   x = y = centerAlign;
                   geom_flags |= WidthValue|HeightValue|XValue|YValue;
                 }
               else if (CHECK_GEOM_OPS ("root"))
                 {
+                  new_flags |= rootAlign;
                   w = h = noScale;
-                  x = y = rootAlign;
-                  geom_flags |= WidthValue|HeightValue|XValue|YValue;
+                  geom_flags |= WidthValue|HeightValue;
                 }
 #  undef CHECK_GEOM_OPS
               while (*ops != ':' && *ops != '\0') ++ops;
             } /* done parsing ops */
   //fprintf (stderr, "flags = %lX, scale = %ux%u, align=%+d%+d\n",
   //         flags, h_scale, v_scale, h_align, v_align);
   return (changed > 0);
 }
+void
+bgPixmap_t::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y)
+{
+  int target_width = target->szHint.width;
+  int target_height = target->szHint.height;
+  if (flags & propScale)
+    {
+      float scale = (float)target_width / image_width;
+      min_it (scale, (float)target_height / image_height);
+      w = image_width * scale + 0.5;
+      h = image_height * scale + 0.5;
+    }
+  else
+    {
+      w = h_scale * target_width / 100;
+      h = v_scale * target_height / 100;
+    }
+  if (flags & rootAlign)
+    {
+      target->get_window_origin (x, y);
+      x = -x;
+      y = -y;
+    }
+  else
+    {
+      x = make_align_position (h_align, target_width, w > 0 ? w : image_width);
+      y = make_align_position (v_align, target_height, h > 0 ? h : image_height);
+    }
+  flags &= ~sizeSensitive;
+  if (h_scale != 0 || v_scale != 0
+      || h_align != 0 || v_align != 0
+      || image_width > target_width || image_height > target_height)
+    flags |= sizeSensitive;
+}
 #  ifdef HAVE_AFTERIMAGE
 bool
-bgPixmap_t::render_asim (unsigned long background_flags)
+bgPixmap_t::render_image (unsigned long background_flags)
 {
   if (target == NULL)
     return false;
   target->init_asv ();
   int new_pmap_width  = target_width;
   int new_pmap_height = target_height;
   int x = 0;
   int y = 0;
-  int w = h_scale * target_width / 100;
+  int w = 0;
-  int h = v_scale * target_height / 100;
+  int h = 0;
   TIMING_TEST_START (asim);
   if (original_asim)
-    {
+    get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
-      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);
-      if (v_align != rootAlign)
-        y = make_align_position (v_align, target_height, h > 0 ? h : (int)original_asim->height);
-    }
   if (!original_asim
       || x >= target_width
       || y >= target_height
       || (w > 0 && x + w <= 0)
                                   100, ASIMAGE_QUALITY_DEFAULT);
         }
       if (background == NULL)
         {
-          /* 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 = min (result->width, target_width);
-          if (v_scale == 0)
-            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)
             {
+              /* if tiling - pixmap has to be sized exactly as the image,
+                 but there is no need to make it bigger than the window! */
+              new_pmap_width = min (result->width, target_width);
+              new_pmap_height = min (result->height, target_height);
+              /* we also need to tile our image in both directions */
               ASImage *tmp = tile_asimage (target->asv, result,
-                                           (h_scale > 0) ? 0 : (int)result->width - x,
+                                           (int)result->width - x,
-                                           (v_scale > 0) ? 0 : (int)result->height - y,
+                                           (int)result->height - y,
                                            new_pmap_width,
                                            new_pmap_height,
                                            TINT_LEAVE_SAME, ASA_XImage,
                                            100, ASIMAGE_QUALITY_DEFAULT);
               if (tmp)
           free (layers);
         }
     }
   TIMING_TEST_PRINT_RESULT (asim);
-  if (pixmap)
+  bool ret = false;
-    {
-      if (result == NULL
-          || pmap_width != new_pmap_width
-          || pmap_height != new_pmap_height
-          || pmap_depth != target->depth)
-        {
-          XFreePixmap (target->dpy, pixmap);
-          pixmap = None;
-        }
-    }
   if (result)
     {
       XGCValues gcv;
       GC gc;
+      if (pixmap)
+        {
+          if (pmap_width != new_pmap_width
+              || pmap_height != new_pmap_height
+              || pmap_depth != target->depth)
+            {
+              XFreePixmap (target->dpy, pixmap);
+              pixmap = None;
+            }
+        }
       /* create Pixmap */
       if (pixmap == None)
         {
           pixmap = XCreatePixmap (target->dpy, target->vt, new_pmap_width, new_pmap_height, target->depth);
       int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
       int dst_width = result->width, dst_height = result->height;
       if (background == NULL)
         {
+          if (!(h_scale == 0 || v_scale == 0))
+            {
-          if (h_scale > 0) src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );
+              src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );
-          if (v_scale > 0) src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
+              src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
+            }
           if (dst_x > 0 || dst_y > 0
               || dst_x + dst_width < new_pmap_width
               || dst_y + dst_height < new_pmap_height)
             XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
       if (result != background && result != original_asim)
         destroy_asimage (&result);
       XFreeGC (target->dpy, gc);
       TIMING_TEST_PRINT_RESULT (asim);
+      ret = true;
     }
   if (background)
     destroy_asimage (&background);
-  return true;
+  return ret;
 }
 #  endif /* HAVE_AFTERIMAGE */
+#  ifdef HAVE_PIXBUF
+bool
+bgPixmap_t::render_image (unsigned long background_flags)
+{
+  if (target == NULL)
+    return false;
+  if (!pixbuf)
+    return false;
+  // TODO: add alpha blending
+  if (background_flags)
+    return false;
+  GdkPixbuf *result;
+  int image_width = gdk_pixbuf_get_width (pixbuf);
+  int image_height = gdk_pixbuf_get_height (pixbuf);
+  int target_width    = target->szHint.width;
+  int target_height   = target->szHint.height;
+  int new_pmap_width  = target_width;
+  int new_pmap_height = target_height;
+  int x = 0;
+  int y = 0;
+  int w = 0;
+  int h = 0;
+  get_image_geometry (image_width, image_height, w, h, x, y);
+  if (x >= target_width
+      || y >= target_height
+      || (w > 0 && x + w <= 0)
+      || (h > 0 && y + h <= 0))
+    return false;
+  result = pixbuf;
+  if ((w > 0 && w != image_width)
+      || (h > 0 && h != image_height))
+    {
+      result = gdk_pixbuf_scale_simple (pixbuf,
+                                        w > 0 ? w : image_width,
+                                        h > 0 ? h : image_height,
+                                        GDK_INTERP_BILINEAR);
+    }
+  bool ret = false;
+  if (result)
+    {
+      XGCValues gcv;
+      GC gc;
+      image_width = gdk_pixbuf_get_width (result);
+      image_height = gdk_pixbuf_get_height (result);
+      if (h_scale == 0 || v_scale == 0)
+        {
+          new_pmap_width = min (image_width, target_width);
+          new_pmap_height = min (image_height, target_height);
+        }
+      if (pixmap)
+        {
+          if (pmap_width != new_pmap_width
+              || pmap_height != new_pmap_height
+              || pmap_depth != target->depth)
+            {
+              XFreePixmap (target->dpy, pixmap);
+              pixmap = None;
+            }
+        }
+      if (pixmap == None)
+        {
+          pixmap = XCreatePixmap (target->dpy, target->vt, new_pmap_width, new_pmap_height, target->depth);
+          pmap_width = new_pmap_width;
+          pmap_height = new_pmap_height;
+          pmap_depth = target->depth;
+        }
+      gcv.foreground = target->pix_colors[Color_bg];
+      gc = XCreateGC (target->dpy, target->vt, GCForeground, &gcv);
+      if (h_scale == 0 || v_scale == 0)
+        {
+          Pixmap tile = XCreatePixmap (target->dpy, target->vt, image_width, image_height, target->depth);
+          gdk_pixbuf_xlib_render_to_drawable (result, tile, gc,
+                                              0, 0,
+                                              0, 0,
+                                              image_width, image_height,
+                                              XLIB_RGB_DITHER_NONE,
+                                              0, 0);
+          gcv.tile = tile;
+          gcv.fill_style = FillTiled;
+          gcv.ts_x_origin = x;
+          gcv.ts_y_origin = y;
+          XChangeGC (target->dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
+          XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
+          XFreePixmap (target->dpy, tile);
+        }
+      else
+        {
+          int src_x, src_y, dst_x, dst_y;
+          int dst_width, dst_height;
+          src_x = make_clip_rectangle (x, image_width , new_pmap_width , dst_x, dst_width );
+          src_y = make_clip_rectangle (y, image_height, new_pmap_height, dst_y, dst_height);
+          if (dst_x > 0 || dst_y > 0
+              || dst_x + dst_width < new_pmap_width
+              || dst_y + dst_height < new_pmap_height)
+            XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
+          if (dst_x < new_pmap_width && dst_y < new_pmap_height)
+            gdk_pixbuf_xlib_render_to_drawable (result, pixmap, gc,
+                                                src_x, src_y,
+                                                dst_x, dst_y,
+                                                dst_width, dst_height,
+                                                XLIB_RGB_DITHER_NONE,
+                                                0, 0);
+        }
+      if (result != pixbuf)
+        g_object_unref (result);
+      XFreeGC (target->dpy, gc);
+      ret = true;
+    }
+  return ret;
+}
+#  endif /* HAVE_PIXBUF */
 bool
 bgPixmap_t::set_file (const char *file)
 {
   assert (file);
       original_asim = get_asimage (target->asimman, file, 0xFFFFFFFF, 100);
       if (original_asim)
         have_image = true;
       return have_image;
 #  endif
+#  ifdef HAVE_PIXBUF
+      pixbuf = gdk_pixbuf_new_from_file (file, NULL);
+      if (pixbuf)
+        have_image = true;
+      return have_image;
+#  endif
     }
   return false;
 }
   int changed = 0;
   unsigned int hr, vr;
   int junk;
   int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr);
-  if (!(geom_flags&WidthValue))
+  if (!(geom_flags & WidthValue))
     hr = 1;
-  if (!(geom_flags&HeightValue))
+  if (!(geom_flags & HeightValue))
     vr = hr;
   if (h_blurRadius != hr)
     {
       ++changed;
   if (v_blurRadius == 0 && h_blurRadius == 0)
     flags &= ~blurNeeded;
   else
     flags |= blurNeeded;
-  return (changed>0);
+  return (changed > 0);
 }
 static inline unsigned long
 compute_tint_shade_flags (rxvt_color *tint, int shade)
 {
 {
   unsigned long new_flags = compute_tint_shade_flags (NULL, shade);
   if (new_flags != (flags & tintFlags))
     {
-      flags = (flags&~tintFlags)|new_flags;
+      flags = (flags & ~tintFlags) | new_flags;
       return true;
     }
   return false;
 }
                && pmap_depth == target->depth)
         flags = flags & ~isInvalid;
     }
 # endif
-# ifdef HAVE_AFTERIMAGE
+# ifdef BG_IMAGE_FROM_FILE
-  if (original_asim
+  if (have_image
       || (background_flags & transpTransformations) != (flags & transpTransformations))
     {
-      if (render_asim (background_flags))
+      if (render_image (background_flags))
         flags = flags & ~isInvalid;
     }
 # endif
   XImage *result = NULL;
   if (background_flags && (flags & isInvalid))
     {
       result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap);
+    }
+  if (result)
+    {
 #  if !defined(HAVE_AFTERIMAGE) && !XFT
       /* our own client-side tinting */
       /* ATTENTION: We ASSUME that XFT will let us do all the tinting necessary server-side.
          This may need to be changed in need_client_side_rendering() logic is altered !!! */
-      if (result != NULL && !(background_flags & transpPmapTinted) && (flags & tintNeeded))
+      if (!(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
-    }
-  if (result)
-    {
       GC gc = XCreateGC (target->dpy, target->vt, 0UL, NULL);
       if (gc)
         {
           if (/*pmap_depth != target->depth &&*/ pixmap != None)

Diff Legend

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

Comparing rxvt-unicode/src/background.C (file contents): Revision 1.49 by sf-exg, Tue Aug 31 15:12:49 2010 UTC vs. Revision 1.63 by sf-exg, Sun Oct 3 21:44:39 2010 UTC

Diff Legend

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.49 by sf-exg, Tue Aug 31 15:12:49 2010 UTC vs.
Revision 1.63 by sf-exg, Sun Oct 3 21:44:39 2010 UTC