diff --git a/user/javadoc/com/google/gwt/examples/ImageExample.java b/user/javadoc/com/google/gwt/examples/ImageExample.java
index 41d640c..7777d98 100644
--- a/user/javadoc/com/google/gwt/examples/ImageExample.java
+++ b/user/javadoc/com/google/gwt/examples/ImageExample.java
@@ -22,35 +22,59 @@
 import com.google.gwt.user.client.ui.RootPanel;
 import com.google.gwt.user.client.ui.VerticalPanel;
 import com.google.gwt.user.client.ui.Widget;
+import com.google.gwt.user.client.ui.Button;
+import com.google.gwt.user.client.ui.ClickListener;
 
 public class ImageExample implements EntryPoint {
 
   private Label lbl = new Label();
+  private Button btn = new Button("Clip this image");
+  private Button btn2 = new Button("Restore image");
 
   public void onModuleLoad() {
-    // Create an image, not yet referencing a URL.
-    Image image = new Image();
+    // Create an image, not yet referencing a URL. We make it final so that we
+    // can manipulate the image object within the ClickHandlers for the buttons
+    final Image image = new Image();
 
     // Hook up a load listener, so that we can find out when it loads (or
-    // fails to, as the case may be).
+    // fails to, as the case may be). Once the image loads, we can enable the
+    // buttons that are used to manipulate the images
     image.addLoadListener(new LoadListener() {
-      public void onLoad(Widget sender) {
-        lbl.setText("Done loading.");
-      }
-    
       public void onError(Widget sender) {
         lbl.setText("An error occurred while loading.");
       }
+
+      // This event may not fire if the image is already cached
+      public void onLoad(Widget sender) {
+        lbl.setText("Done loading.");
+      }
     });
 
     // Point the image at a real URL.
     lbl.setText("Loading...");
     image.setUrl("http://www.google.com/images/logo.gif");
 
-    // Add the image & label to the root panel.
+    // When the user clicks this button, we want to clip the image
+    btn.addClickListener(new ClickListener() {
+      public void onClick(Widget sender) {
+        image.setVisibleRect(70, 0, 47, 100);
+      }
+    });
+
+    // When the user clicks this button, we want to restore the image to its
+    // unclipped state
+    btn2.addClickListener(new ClickListener() {
+      public void onClick(Widget sender) {
+        image.setUrl("http://www.google.com/images/logo.gif");
+      }
+    });
+
+    // Add the image, label, and clip/restore buttons to the root panel.
     VerticalPanel panel = new VerticalPanel();
     panel.add(lbl);
     panel.add(image);
+    panel.add(btn);
+    panel.add(btn2);
     RootPanel.get().add(panel);
   }
-}
\ No newline at end of file
+}
diff --git a/user/src/com/google/gwt/user/ClippedImage.gwt.xml b/user/src/com/google/gwt/user/ClippedImage.gwt.xml
new file mode 100644
index 0000000..c4ba233
--- /dev/null
+++ b/user/src/com/google/gwt/user/ClippedImage.gwt.xml
@@ -0,0 +1,25 @@
+<!--                                                                        -->
+<!-- Copyright 2007 Google Inc. All Rights Reserved.                        -->
+<!--                                                                        -->
+<!-- This module is required in order to use an Image in its clipped state, -->
+<!-- or an ImageBundle.                                                     -->
+<!--                                                                        -->
+<!-- The implementation differs between Internet Explorer and other         -->
+<!-- browsers, so we use deferred binding to create the correct instance of -->
+<!-- the class based on the user's browser.                                 -->
+<!--                                                                        -->
+<!-- This module is interited by the User module, so it will be available   -->
+<!-- to all GWT applications.                                               -->
+
+<module>
+	<inherits name="com.google.gwt.core.Core" />
+	<inherits name="com.google.gwt.user.UserAgent" />
+
+	<!-- IE needs a different implementation -->
+	<replace-with
+		class="com.google.gwt.user.client.ui.impl.ClippedImageImplIE6">
+		<when-type-is
+			class="com.google.gwt.user.client.ui.impl.ClippedImageImpl" />
+		<when-property-is name="user.agent" value="ie6" />
+	</replace-with>
+</module>
diff --git a/user/src/com/google/gwt/user/User.gwt.xml b/user/src/com/google/gwt/user/User.gwt.xml
index adbf794..5ce6852 100644
--- a/user/src/com/google/gwt/user/User.gwt.xml
+++ b/user/src/com/google/gwt/user/User.gwt.xml
@@ -14,4 +14,5 @@
    <inherits name="com.google.gwt.user.Form"/>
    <inherits name="com.google.gwt.user.TextBox"/>
    <inherits name="com.google.gwt.user.Focus"/>
+   <inherits name="com.google.gwt.user.ClippedImage"/>
 </module>
diff --git a/user/src/com/google/gwt/user/client/ui/AbstractImagePrototype.java b/user/src/com/google/gwt/user/client/ui/AbstractImagePrototype.java
new file mode 100644
index 0000000..8656716
--- /dev/null
+++ b/user/src/com/google/gwt/user/client/ui/AbstractImagePrototype.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2007 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.user.client.ui;
+
+/**
+ * An opaque representation of a particular image such that the image can be
+ * accessed either as an HTML fragment or as an {@link Image} object. An image
+ * protype can be thought of as an abstract image factory with additional
+ * capabilities.
+ * 
+ * <p>
+ * The {@link #applyTo(Image)} method provides an efficient way to replace the
+ * contents of an existing <code>Image</code>. This is useful in cases where
+ * an image changes its appearance based on a user's action. Instead of creating
+ * two <code>Image</code> objects then alternately hiding/showing them, one
+ * can use the {@link #applyTo(Image)} method of two
+ * <code>AbstractImagePrototype</code> objects to transform a single
+ * <code>Image</code> object between two (or more) visual representations. The
+ * use of <code>AbstractImagePrototypes</code> results in an cleaner and more
+ * efficient implementation.
+ * </p>
+ * 
+ * <p>
+ * This class is also a useful way to encapsulate complex HTML that represents
+ * an image without actually instantiating <code>Image</code> objects. When
+ * constructing large HTML fragments, especially those that contain many images,
+ * {@link #getHTML()} can be much more efficient.
+ * </p>
+ */
+public abstract class AbstractImagePrototype {
+
+  /**
+   * Transforms an existing {@link Image} into the image represented by this
+   * prototype.
+   * 
+   * @param image the instance to be transformed to match this prototype
+   */
+  public abstract void applyTo(Image image);
+
+  /**
+   * Creates a new {@link Image} instance based on the image represented by this
+   * prototype.
+   * 
+   * @return a new <code>Image</code> based on this prototype
+   */
+  public abstract Image createImage();
+
+  /**
+   * Gets an HTML fragment that displays the image represented by this
+   * prototype. The HTML returned is not necessarily a simple
+   * <code>&lt;img&gt;</code> element. It may be a more complex structure that
+   * should be treated opaquely.
+   * 
+   * @return the HTML representation of this prototype
+   */
+  public abstract String getHTML();
+}
diff --git a/user/src/com/google/gwt/user/client/ui/Image.java b/user/src/com/google/gwt/user/client/ui/Image.java
index 331d54d..37330b1 100644
--- a/user/src/com/google/gwt/user/client/ui/Image.java
+++ b/user/src/com/google/gwt/user/client/ui/Image.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2006 Google Inc.
+ * Copyright 2007 Google Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
@@ -16,19 +16,46 @@
 package com.google.gwt.user.client.ui;
 
 import com.google.gwt.user.client.DOM;
+import com.google.gwt.user.client.DeferredCommand;
+import com.google.gwt.user.client.Command;
 import com.google.gwt.user.client.Element;
 import com.google.gwt.user.client.Event;
+import com.google.gwt.user.client.ui.impl.ClippedImageImpl;
+import com.google.gwt.core.client.GWT;
 
 import java.util.HashMap;
 
 /**
- * A widget that displays the image at a given URL.
+ * A widget that displays the image at a given URL. The image can be in
+ * 'unclipped' mode (the default) or 'clipped' mode. In clipped mode, a viewport
+ * is overlaid on top of the image so that a subset of the image will be
+ * displayed. In unclipped mode, there is no viewport - the entire image will be
+ * visible. Whether an image is in clipped or unclipped mode depends on how the
+ * image is constructed, and how it is transformed after construction. Methods
+ * will operate differently depending on the mode that the image is in. These
+ * differences are detailed in the documentation for each method.
+ * 
+ * <p>
+ * If an image transitions between clipped mode and unclipped mode, any
+ * {@link Element}-specific attributes added by the user (including style
+ * attributes, style names, and style modifiers), except for event listeners,
+ * will be lost.
+ * </p>
  * 
  * <h3>CSS Style Rules</h3>
  * <ul class="css">
  * <li>.gwt-Image { }</li>
  * </ul>
  * 
+ * Tranformations between clipped and unclipped state will result in a loss of
+ * any style names that were set/added; the only style names that are preserved
+ * are those that are mentioned in the static CSS style rules. Due to
+ * browser-specific HTML constructions needed to achieve the clipping effect,
+ * certain CSS attributes, such as padding and background, may not work as
+ * expected when an image is in clipped mode. These limitations can usually be
+ * easily worked around by encapsulating the image in a container widget that
+ * can itself be styled.
+ * 
  * <p>
  * <h3>Example</h3>
  * {@example com.google.gwt.examples.ImageExample}
@@ -38,6 +65,206 @@
     SourcesMouseEvents, SourcesLoadEvents {
 
   /**
+   * Abstract class which is used to hold the state associated with an image
+   * object.
+   */
+  private abstract static class State {
+
+    public abstract int getHeight(Image image);
+
+    public abstract int getOriginLeft();
+
+    public abstract int getOriginTop();
+
+    public abstract String getUrl(Image image);
+
+    public abstract int getWidth(Image image);
+
+    public abstract void setUrl(Image image, String url);
+
+    public abstract void setUrlAndVisibleRect(Image image, String url,
+        int left, int top, int width, int height);
+
+    public abstract void setVisibleRect(Image image, int left, int top,
+        int width, int height);
+
+    // This method is used only by unit tests.
+    protected abstract String getStateName();
+  }
+
+  /**
+   * Implementation of behaviors associated with the unclipped state of an
+   * image.
+   */
+  private static class UnclippedState extends State {
+
+    UnclippedState(Image image) {
+      image.setElement(DOM.createImg());
+      image.sinkEvents(Event.ONCLICK | Event.MOUSEEVENTS | Event.ONLOAD
+          | Event.ONERROR);
+    }
+
+    UnclippedState(Image image, String url) {
+      this(image);
+      setUrl(image, url);
+    }
+
+    public int getHeight(Image image) {
+      return DOM.getIntAttribute(image.getElement(), "height");
+    }
+
+    public int getOriginLeft() {
+      return 0;
+    }
+
+    public int getOriginTop() {
+      return 0;
+    }
+
+    public String getUrl(Image image) {
+      return DOM.getAttribute(image.getElement(), "src");
+    }
+
+    public int getWidth(Image image) {
+      return DOM.getIntAttribute(image.getElement(), "width");
+    }
+
+    public void setUrl(Image image, String url) {
+      DOM.setAttribute(image.getElement(), "src", url);
+    }
+
+    public void setUrlAndVisibleRect(Image image, String url, int left,
+        int top, int width, int height) {
+      image.changeState(new ClippedState(image, url, left, top, width, height));
+    }
+
+    public void setVisibleRect(Image image, int left, int top, int width,
+        int height) {
+      image.changeState(new ClippedState(image, getUrl(image), left, top,
+          width, height));
+    }
+
+    // This method is used only by unit tests.
+    protected String getStateName() {
+      return "unclipped";
+    }
+  }
+
+  /**
+   * Implementation of behaviors associated with the clipped state of an image.
+   */
+  private static class ClippedState extends State {
+
+    private static final ClippedImageImpl impl = (ClippedImageImpl) GWT.create(ClippedImageImpl.class);
+
+    private int left = 0;
+    private int top = 0;
+    private int width = 0;
+    private int height = 0;
+    private String url = null;
+
+    ClippedState(Image image, String url, int left, int top, int width,
+        int height) {
+      this.left = left;
+      this.top = top;
+      this.width = width;
+      this.height = height;
+      this.url = url;
+      image.setElement(impl.createStructure(url, left, top, width, height));
+      image.sinkEvents(Event.ONCLICK | Event.MOUSEEVENTS);
+      fireSyntheticLoadEvent(image);
+    }
+
+    private void fireSyntheticLoadEvent(final Image image) {
+      /*
+       * We need to synthesize a load event, because the native events that are
+       * fired would correspond to the loading of clear.cache.gif, which is
+       * incorrect. A native event would not even fire in Internet Explorer,
+       * because the root element is a wrapper element around the <img> element.
+       * Since we are synthesizing a load event, we do not need to sink the
+       * onload event.
+       * 
+       * We use a deferred command here to simulate the native version of the
+       * load event as closely as possible. In the native event case, it is
+       * unlikely that a second load event would occur while you are in the load
+       * event handler.
+       */
+      DeferredCommand.add(new Command() {
+        public void execute() {
+          if (image.loadListeners != null) {
+            image.loadListeners.fireLoad(image);
+          }
+        }
+      });
+    }
+
+    public int getHeight(Image image) {
+      return height;
+    }
+
+    public int getOriginLeft() {
+      return left;
+    }
+
+    public int getOriginTop() {
+      return top;
+    }
+
+    public String getUrl(Image image) {
+      return url;
+    }
+
+    public int getWidth(Image image) {
+      return width;
+    }
+
+    public void setUrl(Image image, String url) {
+      image.changeState(new UnclippedState(image, url));
+    }
+
+    public void setUrlAndVisibleRect(Image image, String url, int left,
+        int top, int width, int height) {
+      if (!url.equals(url) || this.left != left || this.top != top
+          || this.width != width || this.height != height) {
+
+        this.url = url;
+        this.left = left;
+        this.top = top;
+        this.width = width;
+        this.height = height;
+
+        impl.adjust(image.getElement(), url, left, top, width, height);
+        fireSyntheticLoadEvent(image);
+      }
+    }
+
+    public void setVisibleRect(Image image, int left, int top, int width,
+        int height) {
+      /*
+       * In the event that the clipping rectangle has not changed, we want to
+       * skip all of the work required with a getImpl().adjust, and we do not
+       * want to fire a load event.
+       */
+      if (this.left != left || this.top != top || this.width != width
+          || this.height != height) {
+
+        this.left = left;
+        this.top = top;
+        this.width = width;
+        this.height = height;
+
+        impl.adjust(image.getElement(), url, left, top, width, height);
+        fireSyntheticLoadEvent(image);
+      }
+    }
+
+    /* This method is used only by unit tests */
+    protected String getStateName() {
+      return "clipped";
+    }
+  }
+
+  /**
    * This map is used to store prefetched images. If a reference is not kept to
    * the prefetched image objects, they can get garbage collected, which
    * sometimes keeps them from getting fully fetched.
@@ -59,23 +286,48 @@
   private LoadListenerCollection loadListeners;
   private MouseListenerCollection mouseListeners;
 
+  private State state;
+
   /**
    * Creates an empty image.
    */
   public Image() {
-    setElement(DOM.createImg());
-    sinkEvents(Event.ONCLICK | Event.MOUSEEVENTS | Event.ONLOAD | Event.ONERROR);
+    changeState(new UnclippedState(this));
     setStyleName("gwt-Image");
   }
 
   /**
-   * Creates an image with a specified URL.
+   * Creates an image with a specified URL. The load event will be fired once
+   * the image at the given URL has been retrieved by the browser.
    * 
    * @param url the URL of the image to be displayed
    */
   public Image(String url) {
-    this();
-    setUrl(url);
+    changeState(new UnclippedState(this, url));
+    setStyleName("gwt-Image");
+  }
+
+  /**
+   * Creates a clipped image with a specified URL and visibility rectangle. The
+   * visibility rectangle is declared relative to the the rectangle which
+   * encompasses the entire image, which has an upper-left vertex of (0,0). The
+   * load event will be fired immediately after the object has been constructed
+   * (i.e. potentially before the image has been loaded in the browser). Since
+   * the width and height are specified explicitly by the user, this behavior
+   * will not cause problems with retrieving the width and height of a clipped
+   * image in a load event handler.
+   * 
+   * @param url the URL of the image to be displayed
+   * @param left the horizontal co-ordinate of the upper-left vertex of the
+   *          visibility rectangle
+   * @param top the vertical co-ordinate of the upper-left vertex of the
+   *          visibility rectangle
+   * @param width the width of the visibility rectangle
+   * @param height the height of the visibility rectangle
+   */
+  public Image(String url, int left, int top, int width, int height) {
+    changeState(new ClippedState(this, url, left, top, width, height));
+    setStyleName("gwt-Image");
   }
 
   public void addClickListener(ClickListener listener) {
@@ -100,12 +352,62 @@
   }
 
   /**
-   * Gets the URL of the image.
+   * Gets the height of the image. When the image is in the unclipped state, the
+   * height of the image is not known until the image has been loaded (i.e. load
+   * event has been fired for the image).
+   * 
+   * @return the height of the image, or 0 if the height is unknown
+   */
+  public int getHeight() {
+    return state.getHeight(this);
+  }
+
+  /**
+   * Gets the horizontal co-ordinate of the upper-left vertex of the image's
+   * visibility rectangle. If the image is in the unclipped state, then the
+   * visibility rectangle is assumed to be the rectangle which encompasses the
+   * entire image, which has an upper-left vertex of (0,0).
+   * 
+   * @return the horizontal co-ordinate of the upper-left vertex of the image's
+   *         visibility rectangle
+   */
+  public int getOriginLeft() {
+    return state.getOriginLeft();
+  }
+
+  /**
+   * Gets the vertical co-ordinate of the upper-left vertex of the image's
+   * visibility rectangle. If the image is in the unclipped state, then the
+   * visibility rectangle is assumed to be the rectangle which encompasses the
+   * entire image, which has an upper-left vertex of (0,0).
+   * 
+   * @return the vertical co-ordinate of the upper-left vertex of the image's
+   *         visibility rectangle
+   */
+  public int getOriginTop() {
+    return state.getOriginTop();
+  }
+
+  /**
+   * Gets the URL of the image. The URL that is returned is not necessarily the
+   * URL that was passed in by the user. It may have been transformed to an
+   * absolute URL.
    * 
    * @return the image URL
    */
   public String getUrl() {
-    return DOM.getAttribute(getElement(), "src");
+    return state.getUrl(this);
+  }
+
+  /**
+   * Gets the width of the image. When the image is in the unclipped state, the
+   * width of the image is not known until the image has been loaded (i.e. load
+   * event has been fired for the image).
+   * 
+   * @return the width of the image, or 0 if the width is unknown
+   */
+  public int getWidth() {
+    return state.getWidth(this);
   }
 
   public void onBrowserEvent(Event event) {
@@ -160,11 +462,60 @@
   }
 
   /**
-   * Sets the URL of the image to be displayed.
+   * Sets the URL of the image to be displayed. If the image is in the clipped
+   * state, a call to this method will cause a transition of the image to the
+   * unclipped state. Regardless of whether or not the image is in the clipped
+   * or unclipped state, a load event will be fired.
    * 
    * @param url the image URL
    */
   public void setUrl(String url) {
-    DOM.setAttribute(getElement(), "src", url);
+    state.setUrl(this, url);
   }
-}
\ No newline at end of file
+
+  /**
+   * Sets the url and the visibility rectangle for the image at the same time. A
+   * single load event will be fired if either the incoming url or visiblity
+   * rectangle co-ordinates differ from the image's current url or current
+   * visibility rectangle co-ordinates. If the image is currently in the
+   * unclipped state, a call to this method will cause a transition to the
+   * clipped state.
+   * 
+   * @param url the image URL
+   * @param left the horizontal coordinate of the upper-left vertex of the
+   *          visibility rectangle
+   * @param top the vertical coordinate of the upper-left vertex of the
+   *          visibility rectangle
+   * @param width the width of the visibility rectangle
+   * @param height the height of the visibility rectangle
+   */
+  public void setUrlAndVisibleRect(String url, int left, int top, int width,
+      int height) {
+    state.setUrlAndVisibleRect(this, url, left, top, width, height);
+  }
+
+  /**
+   * Sets the visibility rectangle of an image. The visibility rectangle is
+   * declared relative to the the rectangle which encompasses the entire image,
+   * which has an upper-left vertex of (0,0). Provided that any of the left,
+   * top, width, and height parameters are different than the those values that
+   * are currently set for the image, a load event will be fired. If the image
+   * is in the unclipped state, a call to this method will cause a transition of
+   * the image to the clipped state. This transition will cause a load event to
+   * fire.
+   * 
+   * @param left the horizontal coordinate of the upper-left vertex of the
+   *          visibility rectangle
+   * @param top the vertical coordinate of the upper-left vertex of the
+   *          visibility rectangle
+   * @param width the width of the visibility rectangle
+   * @param height the height of the visibility rectangle
+   */
+  public void setVisibleRect(int left, int top, int width, int height) {
+    state.setVisibleRect(this, left, top, width, height);
+  }
+
+  private void changeState(State newState) {
+    state = newState;
+  }
+}
diff --git a/user/src/com/google/gwt/user/client/ui/UIObject.java b/user/src/com/google/gwt/user/client/ui/UIObject.java
index 0d4d4aa..f969059 100644
--- a/user/src/com/google/gwt/user/client/ui/UIObject.java
+++ b/user/src/com/google/gwt/user/client/ui/UIObject.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2006 Google Inc.
+ * Copyright 2007 Google Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
@@ -340,10 +340,27 @@
   /**
    * Sets this object's browser element. UIObject subclasses must call this
    * method before attempting to call any other methods.
+   *
+   * If the browser element has already been set, then the current element's
+   * position is located in the DOM and removed. The new element is added into
+   * the previous element's position.
    * 
    * @param elem the object's new element
    */
   protected void setElement(Element elem) {
+    if (this.element != null) {
+      // replace this.element in its parent with elem.
+      replaceNode(this.element, elem);
+    }
     this.element = elem;
   }
+
+  private native void replaceNode(Element node, Element newNode) /*-{
+    var p = node.parentNode;
+    if (!p) {
+      return;
+    }
+    p.insertBefore(newNode, node);
+    p.removeChild(node);
+  }-*/;
 }
diff --git a/user/src/com/google/gwt/user/client/ui/Widget.java b/user/src/com/google/gwt/user/client/ui/Widget.java
index b9f6005..2d4a2ee 100644
--- a/user/src/com/google/gwt/user/client/ui/Widget.java
+++ b/user/src/com/google/gwt/user/client/ui/Widget.java
@@ -18,6 +18,7 @@
 import com.google.gwt.user.client.DOM;
 import com.google.gwt.user.client.Event;
 import com.google.gwt.user.client.EventListener;
+import com.google.gwt.user.client.Element;
 
 /**
  * The base class for the majority of user-interface objects. Widget adds
@@ -115,6 +116,34 @@
   }
 
   /**
+    * Sets this object's browser element. Widget subclasses must call this
+    * method before attempting to call any other methods.
+    *
+    * If a browser element has already been attached, then it is replaced with
+    * the new element. The old event listeners are removed from the old browser
+    * element, and the event listeners are set up on the new browser element.
+    *
+    * @param elem the object's new element
+    */
+   protected void setElement(Element elem) {
+     if (attached) {
+       // Remove old event listener to avoid leaking. onDetach will not do this
+       // for us, because it is only called the widget itself is detached from
+       // the document.
+       DOM.setEventListener(getElement(), null);
+     }
+
+     super.setElement(elem);
+
+     if (attached) {
+       // Hook the event listener back up on the new element. onAttach will not
+       // do this for us, because it is only called when the widget itself is
+       // attached to the document.
+       DOM.setEventListener(elem, this);
+     }
+   }
+
+  /**
    * Gets the panel-defined layout data associated with this widget.
    * 
    * @return the widget's layout data
diff --git a/user/src/com/google/gwt/user/client/ui/impl/ClippedImageImpl.java b/user/src/com/google/gwt/user/client/ui/impl/ClippedImageImpl.java
new file mode 100644
index 0000000..6d6f2cb
--- /dev/null
+++ b/user/src/com/google/gwt/user/client/ui/impl/ClippedImageImpl.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2007 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.user.client.ui.impl;
+
+import com.google.gwt.user.client.DOM;
+import com.google.gwt.user.client.Element;
+
+/**
+ * Uses a combination of a clear image and a background image to clip all except
+ * a desired portion of an underlying image.
+ *
+ * Do not use this class - it is used for implementation only, and its methods
+ * may change in the future.
+ */
+public class ClippedImageImpl {
+
+  public void adjust(Element img, String url, int left, int top, int width,
+                     int height) {
+    String style = "url(" + url + ") no-repeat " + (-left + "px ")
+        + (-top + "px");
+    DOM.setStyleAttribute(img, "background", style);
+    DOM.setStyleAttribute(img, "width", width + "px");
+    DOM.setStyleAttribute(img, "height", height + "px");
+  }
+
+  public Element createStructure(String url, int left, int top, int width,
+                                 int height) {
+    Element tmp = DOM.createSpan();
+    DOM.setInnerHTML(tmp, getHTML(url, left, top, width, height));
+    return DOM.getFirstChild(tmp);
+  }
+
+  public String getHTML(String url, int left, int top, int width, int height) {
+    String style = "width: " + width + "px; height: " + height
+        + "px; background: url(" + url + ") no-repeat " + (-left + "px ")
+        + (-top + "px");
+
+    String clippedImgHtml = "<img src='clear.cache.gif' style='"
+        + style + "' border='0'>";
+
+    return clippedImgHtml;
+  }
+}
diff --git a/user/src/com/google/gwt/user/client/ui/impl/ClippedImageImplIE6.java b/user/src/com/google/gwt/user/client/ui/impl/ClippedImageImplIE6.java
new file mode 100644
index 0000000..d6f0fbb
--- /dev/null
+++ b/user/src/com/google/gwt/user/client/ui/impl/ClippedImageImplIE6.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2007 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.user.client.ui.impl;
+
+import com.google.gwt.user.client.DOM;
+import com.google.gwt.user.client.Element;
+
+/**
+ * Implements the clipped image as a IMG inside a custom tag because we can't
+ * use the IE PNG transparency filter on background-image images.
+ *
+ * Do not use this class - it is used for implementation only, and its methods
+ * may change in the future.
+ */
+public class ClippedImageImplIE6 extends ClippedImageImpl {
+  
+  public void adjust(Element clipper, String url, int left, int top, int width,
+      int height) {
+
+    DOM.setStyleAttribute(clipper, "width", width + "px");
+    DOM.setStyleAttribute(clipper, "height", height + "px");
+
+    // Update the nested image's url.
+    Element img = DOM.getFirstChild(clipper);
+    DOM.setStyleAttribute(img, "filter",
+        "progid:DXImageTransform.Microsoft.AlphaImageLoader(src='" + url
+            + "',sizingMethod='crop')");
+    DOM.setStyleAttribute(img, "marginLeft", -left + "px");
+    DOM.setStyleAttribute(img, "marginTop", -top + "px");
+
+    // AlphaImageLoader requires that we size the image explicitly.
+    // It really only needs to be enough to show the revealed portion.
+    int imgWidth = left + width;
+    int imgHeight = top + height;
+    DOM.setIntAttribute(img, "width", imgWidth);
+    DOM.setIntAttribute(img, "height", imgHeight);
+  }
+
+  public String getHTML(String url, int left, int top, int width, int height) {
+    String clipperStyle = "overflow: hidden; width: " + width + "px; height: "
+        + height + "px; padding: 0px";
+
+    String imgStyle =
+        "filter: progid:DXImageTransform.Microsoft.AlphaImageLoader(src='"
+        + url + "',sizingMethod='crop'); margin-left: "
+        + -left + "px; margin-top: " + -top + "px" + "border: 0px";
+
+    String clippedImgHtml = "<gwt:clipper style=\""
+        + clipperStyle + "\"><img src='clear.cache.gif' style=\"" + imgStyle
+        + "\" width=" + (left + width) + " height=" + (top + height)
+        + " border='0'></gwt:clipper>";
+
+    return clippedImgHtml;
+  }
+}
diff --git a/user/src/com/google/gwt/user/client/ui/impl/ClippedImagePrototype.java b/user/src/com/google/gwt/user/client/ui/impl/ClippedImagePrototype.java
new file mode 100644
index 0000000..159d00c
--- /dev/null
+++ b/user/src/com/google/gwt/user/client/ui/impl/ClippedImagePrototype.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2007 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.user.client.ui.impl;
+
+import com.google.gwt.user.client.ui.Image;
+import com.google.gwt.user.client.ui.AbstractImagePrototype;
+import com.google.gwt.core.client.GWT;
+
+/**
+ * Implementation of {@link AbstractImagePrototype} for a clipped image. This
+ * class is used internally by the image bundle generator and is not intended
+ * for general use. It is subject to change without warning.
+ */
+public class ClippedImagePrototype extends AbstractImagePrototype {
+
+  private static final ClippedImageImpl impl = (ClippedImageImpl) GWT.create(ClippedImageImpl.class);
+
+  private int left = 0;
+  private int top = 0;
+  private int width = 0;
+  private int height = 0;
+  private String url = null;
+
+  public ClippedImagePrototype(String url, int left, int top, int width,
+      int height) {
+    this.url = url;
+    this.left = left;
+    this.top = top;
+    this.width = width;
+    this.height = height;
+  }
+
+  public void applyTo(Image image) {
+    image.setUrlAndVisibleRect(url, left, top, width, height);
+  }
+
+  public Image createImage() {
+    return new Image(url, left, top, width, height);
+  }
+
+  public String getHTML() {
+    return impl.getHTML(url, left, top, width, height);
+  }
+}
diff --git a/user/src/com/google/gwt/user/public/clear.cache.gif b/user/src/com/google/gwt/user/public/clear.cache.gif
new file mode 100644
index 0000000..e565824
--- /dev/null
+++ b/user/src/com/google/gwt/user/public/clear.cache.gif
Binary files differ