2006-07-27 Roman Kennke <kennke@aicas.com>

	* java/awt/Component.java
	(getToolkit): Search for heavyweight parent and query the
	heavyweight's peer.
	(checkImage(Image,int,int,ImageObserver)): Likewise.
	(checkImage(ImageProducer)): Likewise.
	(createImage(int,int)): Likewise.
	(createVolatileImage(int,int)): Likewise.
	(createVolatileImage(int,int,ImageCapabilities)): Likewise.
	(getFontMetrics): Likewise.
	(getGraphics): Likewise.
	(getLocationOnScreen): Likewise.
	(prepareImage): Likewise.
	(setCursor): Likewise.
	(repaint): Added null check.
	(addNotify): Send hierarchy event.
	(removeNotify): Send hierarchy event.
	(disableEvents): Update hierarchy listener counters.
	(enableEvents): Update hierarchy listener counters.
	(isHierarchyVisible): New helper method.
	(notifyReshape): Do Container specific handling in
	Container.
	* java/awt/Container.java
	(insets): For lightweights, return (0,0,0,0).
	* java/awt/Toolkit.java
	(lightweightPeer): New static field.
	(createComponent): Return shared instance of GLightweightPeer.
	(notifyReshape): Override Component method to add some handling
	that is specific for Container.
	(removeAll): Also send hierarchy and container events here.
	Update the hierarchy listener counters.
	* gnu/java/awt/peer/GLightweightPeer.java: Made all methods
	stubs and added comment.

5 files changed, 538 insertions, 181 deletions

diff --git a/ChangeLog b/ChangeLog
index f827469b1..1698a3ceb 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,38 @@
+2006-07-27  Roman Kennke  <kennke@aicas.com>
+
+	* java/awt/Component.java
+	(getToolkit): Search for heavyweight parent and query the
+	heavyweight's peer.
+	(checkImage(Image,int,int,ImageObserver)): Likewise.
+	(checkImage(ImageProducer)): Likewise.
+	(createImage(int,int)): Likewise.
+	(createVolatileImage(int,int)): Likewise.
+	(createVolatileImage(int,int,ImageCapabilities)): Likewise.
+	(getFontMetrics): Likewise.
+	(getGraphics): Likewise.
+	(getLocationOnScreen): Likewise.
+	(prepareImage): Likewise.
+	(setCursor): Likewise.
+	(repaint): Added null check.
+	(addNotify): Send hierarchy event.
+	(removeNotify): Send hierarchy event.
+	(disableEvents): Update hierarchy listener counters.
+	(enableEvents): Update hierarchy listener counters.
+	(isHierarchyVisible): New helper method.
+	(notifyReshape): Do Container specific handling in
+	Container.
+	* java/awt/Container.java
+	(insets): For lightweights, return (0,0,0,0).
+	* java/awt/Toolkit.java
+	(lightweightPeer): New static field.
+	(createComponent): Return shared instance of GLightweightPeer.
+	(notifyReshape): Override Component method to add some handling
+	that is specific for Container.
+	(removeAll): Also send hierarchy and container events here.
+	Update the hierarchy listener counters.
+	* gnu/java/awt/peer/GLightweightPeer.java: Made all methods
+	stubs and added comment.
+
 2006-07-27  Sven de Marothy  <sven@physto.se>
 
 	* java/math/BigDecimal.java
diff --git a/gnu/java/awt/peer/GLightweightPeer.java b/gnu/java/awt/peer/GLightweightPeer.java
index 88733b92f..3029502ff 100644
--- a/gnu/java/awt/peer/GLightweightPeer.java
+++ b/gnu/java/awt/peer/GLightweightPeer.java
@@ -54,25 +54,14 @@ import java.awt.Insets;
 import java.awt.Point;
 import java.awt.Rectangle;
 import java.awt.Toolkit;
-import java.awt.event.MouseAdapter;
-import java.awt.event.MouseEvent;
 import java.awt.event.PaintEvent;
 import java.awt.image.ColorModel;
 import java.awt.image.ImageObserver;
 import java.awt.image.ImageProducer;
 import java.awt.image.VolatileImage;
-import java.awt.peer.ComponentPeer;
 import java.awt.peer.ContainerPeer;
 import java.awt.peer.LightweightPeer;
 
-/*
- * Another possible implementation strategy for lightweight peers is
- * to make GLightweightPeer a placeholder class that implements
- * LightweightPeer.  Then the Component and Container classes could
- * identify a peer as lightweight and handle it specially.  The
- * current approach is probably more clear but less efficient.
- */
-
 /**
  * A stub class that implements the ComponentPeer and ContainerPeer
  * interfaces using callbacks into the Component and Container
@@ -85,47 +74,48 @@ import java.awt.peer.LightweightPeer;
 public class GLightweightPeer 
   implements LightweightPeer, ContainerPeer
 {
-  private Component comp;
-
-  private Insets containerInsets;
-
-  public GLightweightPeer(Component comp)
+  public GLightweightPeer()
   {
-    this.comp = comp;
+    // Nothing to do here.
   }
 
   // -------- java.awt.peer.ContainerPeer implementation:
   
   public Insets insets()
   {
-    return getInsets ();
+    // Nothing to do here for lightweights.
+    return null;
   }
   
   public Insets getInsets()
   {
-    if (containerInsets == null)
-      containerInsets = new Insets (0,0,0,0);
-    return containerInsets;
+    // Nothing to do here for lightweights.
+    return null;
   }
   
   public void beginValidate()
   {
+    // Nothing to do here for lightweights.
   }
   
   public void endValidate()
   {
+    // Nothing to do here for lightweights.
   }
   
   public void beginLayout()
   {
+    // Nothing to do here for lightweights.
   }
   
   public void endLayout()
   {
+    // Nothing to do here for lightweights.
   }
   
   public boolean isPaintPending()
   {
+    // Nothing to do here for lightweights.
     return false;
   }
 
@@ -133,122 +123,162 @@ public class GLightweightPeer
 
   public int checkImage(Image img, int width, int height, ImageObserver o)
   {
-    return comp.getToolkit().checkImage(img, width, height, o);
+    // Nothing to do here for lightweights.
+    return -1;
   }
 
   public Image createImage(ImageProducer prod)
   {
-    return comp.getToolkit().createImage(prod);
+    // Nothing to do here for lightweights.
+    return null;
   }
 
   /* This method is not called. */
   public Image createImage(int width, int height)
   {
+    // Nothing to do here for lightweights.
     return null;
   }
 
-  public void disable() {}
+  public void disable()
+  {
+    // Nothing to do here for lightweights.
+  }
 
-  public void dispose() {}
+  public void dispose()
+  {
+    // Nothing to do here for lightweights.
+  }
 
-  public void enable() {}
+  public void enable()
+  {
+    // Nothing to do here for lightweights.
+  }
 
   public GraphicsConfiguration getGraphicsConfiguration()
   {
+    // Nothing to do here for lightweights.
     return null;
   }
 
   public FontMetrics getFontMetrics(Font f)
   {
-    return comp.getToolkit().getFontMetrics(f);
+    // Nothing to do here for lightweights.
+    return null;
   }
 
   /* Returning null here tells the Component object that called us to
    * use its parent's Graphics. */
   public Graphics getGraphics()
   {
+    // Nothing to do here for lightweights.
     return null;
   }
 
   public Point getLocationOnScreen()
   {
-    Point parentLocation = comp.getParent().getLocationOnScreen();
-    return new Point (parentLocation.x + comp.getX(),
-                      parentLocation.y + comp.getY());
+    // Nothing to do here for lightweights.
+    return null;
   }
 
   public Dimension getMinimumSize()
   {
-    return new Dimension(comp.getWidth(), comp.getHeight());
+    return minimumSize();
   }
 
-  /* A lightweight component's preferred size is equivalent to its
-   * Component width and height values. */
   public Dimension getPreferredSize()
   {
-    return new Dimension(comp.getWidth(), comp.getHeight());
+    return preferredSize();
   }
 
   /* Returning null here tells the Component object that called us to
    * use its parent's Toolkit. */
   public Toolkit getToolkit()
   {
+    // Nothing to do here for lightweights.
     return null;
   }
 
-  public void handleEvent(AWTEvent e) {}
+  public void handleEvent(AWTEvent e)
+  {
+    // Nothing to do here for lightweights.
+  }
 
-  public void hide() {}
+  public void hide()
+  {
+    // Nothing to do here for lightweights.
+  }
 
   public boolean isFocusable() 
   {
+    // Nothing to do here for lightweights.
     return false;
   }
 
   public boolean isFocusTraversable()
   {
+    // Nothing to do here for lightweights.
     return false;
   }
 
   public Dimension minimumSize()
   {
-    return getMinimumSize();
+    return new Dimension(0, 0);
   }
 
   public Dimension preferredSize()
   {
-    return getPreferredSize();
+    return new Dimension(0, 0);
   }
 
-  public void paint(Graphics graphics) {}
+  public void paint(Graphics graphics)
+  {
+    // Nothing to do here for lightweights.
+  }
 
   public boolean prepareImage(Image img, int width, int height,
 			      ImageObserver o)
   {
-    return comp.getToolkit().prepareImage(img, width, height, o);
+    // Nothing to do here for lightweights.
+    return false;
   }
 
-  public void print(Graphics graphics) {}
+  public void print(Graphics graphics)
+  {
+    // Nothing to do here for lightweights.
+  }
 
   public void repaint(long tm, int x, int y, int width, int height)
   {
-    Component p = comp.getParent();
-    if (p != null)
-      p.repaint(tm, x + comp.getX(), y + comp.getY(), width, height);
+    // Nothing to do here for lightweights.
   }
 
-  public void requestFocus() {}
+  public void requestFocus()
+  {
+    // Nothing to do here for lightweights.
+  }
 
-  public boolean requestFocus(Component source, boolean bool1, boolean bool2, long x)
+  public boolean requestFocus(Component source, boolean bool1, boolean bool2,
+                              long x)
   {
+    // Nothing to do here for lightweights.
     return false;
   }
 
-  public void reshape(int x, int y, int width, int height) {}
+  public void reshape(int x, int y, int width, int height)
+  {
+    // Nothing to do here for lightweights.
+  }
 
-  public void setBackground(Color color) {}
+  public void setBackground(Color color)
+  {
+    // Nothing to do here for lightweights.
+  }
 
-  public void setBounds(int x, int y, int width, int height) {}
+  public void setBounds(int x, int y, int width, int height)
+  {
+    // Nothing to do here for lightweights.
+  }
 
   /**
    * Sets the cursor on the heavy-weight parent peer.
@@ -256,110 +286,141 @@ public class GLightweightPeer
    */
   public void setCursor(Cursor cursor)
   {
-    Component p = comp.getParent();
-    while (p != null && p.isLightweight())
-      p = p.getParent();
-
-    if (p != null)
-      {
-	// Don't actually change the cursor of the component
-	// otherwise other childs inherit this cursor.
-	ComponentPeer peer = p.getPeer();
-	if (peer != null)
-	  peer.setCursor(cursor);
-      }
+    // Nothing to do here for lightweights.
   }
 
-  public void setEnabled(boolean enabled) {}
+  public void setEnabled(boolean enabled)
+  {
+    // Nothing to do here for lightweights.
+  }
 
-  public void setEventMask(long eventMask) {}
+  public void setEventMask(long eventMask)
+  {
+    // Nothing to do here for lightweights.
+  }
 
-  public void setFont(Font font) {}
+  public void setFont(Font font)
+  {
+    // Nothing to do here for lightweights.
+  }
 
-  public void setForeground(Color color) {}
+  public void setForeground(Color color)
+  {
+    // Nothing to do here for lightweights.
+  }
 
-  public void setVisible(boolean visible) {}
+  public void setVisible(boolean visible)
+  {
+    // Nothing to do here for lightweights.
+  }
 
-  public void show() {}
+  public void show()
+  {
+    // Nothing to do here for lightweights.
+  }
 
-  public ColorModel getColorModel ()
+  public ColorModel getColorModel()
   {
-    return comp.getColorModel ();
+    // Nothing to do here for lightweights.
+    return null;
   }
 
   public boolean isObscured()
   {
+    // Nothing to do here for lightweights.
     return false;
   }
 
   public boolean canDetermineObscurity()
   {
+    // Nothing to do here for lightweights.
     return false;
   }
 
-  public void coalescePaintEvent(PaintEvent e) { }
+  public void coalescePaintEvent(PaintEvent e)
+  {
+    // Nothing to do here for lightweights.
+  }
 
-  public void updateCursorImmediately() { }
+  public void updateCursorImmediately()
+  {
+    // Nothing to do here for lightweights.
+  }
 
   public VolatileImage createVolatileImage(int width, int height) 
   { 
+    // Nothing to do here for lightweights.
     return null; 
   }
 
   public boolean handlesWheelScrolling()
   {
+    // Nothing to do here for lightweights.
     return false;
   }
 
   public void createBuffers(int x, BufferCapabilities capabilities) 
-    throws AWTException { }
+    throws AWTException
+  {
+    // Nothing to do here for lightweights.
+  }
 
   public Image getBackBuffer()
   {
+    // Nothing to do here for lightweights.
     return null;
   }
 
-  public void flip(BufferCapabilities.FlipContents contents) { }
+  public void flip(BufferCapabilities.FlipContents contents)
+  {
+    // Nothing to do here for lightweights.
+  }
 
-  public void destroyBuffers() { }
+  public void destroyBuffers()
+  {
+    // Nothing to do here for lightweights.
+  }
 
   public boolean isRestackSupported()
   {
+    // Nothing to do here for lightweights.
     return false;
   }
 
   public void cancelPendingPaint(int x, int y, int width, int height)
   {
-    
+    // Nothing to do here for lightweights.
   }
 
   public void restack()
   {
-    
+    // Nothing to do here for lightweights.
   }
 
   public Rectangle getBounds()
   {
+    // Nothing to do here for lightweights.
     return null;
   }
 
   public void reparent(ContainerPeer parent)
   {
-    
+    // Nothing to do here for lightweights.
   }
 
   public void setBounds(int x, int y, int z, int width, int height)
   {
-    
+    // Nothing to do here for lightweights.
   }
 
   public boolean isReparentSupported()
   {
-    return false;
+    // Nothing to do here for lightweights.
+    return true;
   }
 
   public void layout()
   {
-    
+    // Nothing to do here for lightweights.
   }
 }
diff --git a/java/awt/Component.java b/java/awt/Component.java
index 624659f3e..0e29a84fc 100644
--- a/java/awt/Component.java
+++ b/java/awt/Component.java
@@ -741,16 +741,23 @@ public abstract class Component
    */
   public Toolkit getToolkit()
   {
-    if (peer != null)
+    // Only heavyweight peers can handle this.
+    ComponentPeer p = peer;
+    Component comp = this;
+    while (p instanceof LightweightPeer)
       {
-        Toolkit tk = peer.getToolkit();
-        if (tk != null)
-          return tk;
+        comp = comp.parent;
+        p = comp == null ? null : comp.peer;
       }
-    // Get toolkit for lightweight component.
-    if (parent != null)
-      return parent.getToolkit();
-    return Toolkit.getDefaultToolkit();
+
+    Toolkit tk = null;
+    if (p != null)
+      {
+        tk = peer.getToolkit();
+      }
+    if (tk == null)
+      tk = Toolkit.getDefaultToolkit();
+    return tk;
   }
 
   /**
@@ -1033,7 +1040,7 @@ public abstract class Component
             visible = false;
 
             // Avoid NullPointerExceptions by creating a local reference.
-            ComponentPeer currentPeer=peer;
+            ComponentPeer currentPeer = peer;
             if (currentPeer != null)
               {
                 currentPeer.hide();
@@ -1292,8 +1299,26 @@ public abstract class Component
     // component.
     synchronized (getTreeLock())
       {
-        // We know peer != null here.
-        return peer.getLocationOnScreen();
+        // Only a heavyweight peer can answer the question for the screen
+        // location. So we are going through the hierarchy until we find
+        // one and add up the offsets while doing so.
+        int offsX = 0;
+        int offsY = 0;
+        ComponentPeer p = peer;
+        Component comp = this;
+        while (p instanceof LightweightPeer)
+          {
+            offsX += comp.x;
+            offsY += comp.y;
+            comp = comp.parent;
+            p = comp == null ? null: comp.peer;
+          }
+        // Now we have a heavyweight component.
+        assert ! (p instanceof LightweightPeer);
+        Point loc = p.getLocationOnScreen();
+        loc.x += offsX;
+        loc.y += offsY;
+        return loc;
       }
   }
 
@@ -1533,7 +1558,17 @@ public abstract class Component
       }
   }
 
-  private void notifyReshape(boolean resized, boolean moved)
+  /**
+   * Sends notification to interested listeners about resizing and/or moving
+   * the component. If this component has interested
+   * component listeners or the corresponding event mask enabled, then
+   * COMPONENT_MOVED and/or COMPONENT_RESIZED events are posted to the event
+   * queue.
+   *
+   * @param resized true if the component has been resized, false otherwise
+   * @param moved true if the component has been moved, false otherwise
+   */
+  void notifyReshape(boolean resized, boolean moved)
   {
     // Only post an event if this component actually has a listener
     // or has this event explicitly enabled.
@@ -1544,43 +1579,16 @@ public abstract class Component
         if (moved)
           {
             ComponentEvent ce = new ComponentEvent(this,
-                                           ComponentEvent.COMPONENT_MOVED);
+                                               ComponentEvent.COMPONENT_MOVED);
             getToolkit().getSystemEventQueue().postEvent(ce);
           }
         if (resized)
           {
             ComponentEvent ce = new ComponentEvent(this,
-                                         ComponentEvent.COMPONENT_RESIZED);
+                                             ComponentEvent.COMPONENT_RESIZED);
             getToolkit().getSystemEventQueue().postEvent(ce);
           }
       }
-    else
-      {
-        // Otherwise we might need to notify child components when this is
-        // a Container.
-        if (this instanceof Container)
-          {
-            Container cont = (Container) this;
-            if (resized)
-              {
-                for (int i = 0; i < cont.getComponentCount(); i++)
-                  {
-                    Component child = cont.getComponent(i);
-                    child.fireHierarchyEvent(HierarchyEvent.ANCESTOR_RESIZED,
-                                             this, parent, 0);
-                  }
-              }
-            if (moved)
-              {
-                for (int i = 0; i < cont.getComponentCount(); i++)
-                  {
-                    Component child = cont.getComponent(i);
-                    child.fireHierarchyEvent(HierarchyEvent.ANCESTOR_MOVED,
-                                             this, parent, 0);
-                  }
-              }
-          }
-      }
   }
 
   /**
@@ -2063,21 +2071,29 @@ public abstract class Component
    */
   public Graphics getGraphics()
   {
-    if (peer != null)
+    // Only heavyweight peers can handle this.
+    ComponentPeer p = peer;
+    Component comp = this;
+    int offsX = 0;
+    int offsY = 0;
+    while (p instanceof LightweightPeer)
       {
-        Graphics gfx = peer.getGraphics();
-        // Create peer for lightweights.
-        if (gfx == null && parent != null)
-          {
-            gfx = parent.getGraphics();
-            gfx.clipRect(getX(), getY(), getWidth(), getHeight());
-            gfx.translate(getX(), getY());
-            return gfx;
-          }
+        offsX += comp.x;
+        offsY += comp.y;
+        comp = comp.parent;
+        p = comp == null ? null : comp.peer;
+      }
+
+    Graphics gfx = null;
+    if (p != null)
+      {
+        assert ! (p instanceof LightweightPeer);
+        gfx = p.getGraphics();
+        gfx.translate(offsX, offsY);
+        gfx.clipRect(0, 0, width, height);
         gfx.setFont(font);
-        return gfx;
       }
-    return null;
+    return gfx;
   }
 
   /**
@@ -2091,8 +2107,16 @@ public abstract class Component
    */
   public FontMetrics getFontMetrics(Font font)
   {
-    return peer == null ? getToolkit().getFontMetrics(font)
-      : peer.getFontMetrics(font);
+    ComponentPeer p = peer;
+    Component comp = this;
+    while (p instanceof LightweightPeer)
+      {
+        comp = comp.parent;
+        p = comp == null ? null : comp.peer;
+      }
+
+    return p == null ? getToolkit().getFontMetrics(font)
+           : p.getFontMetrics(font);
   }
 
   /**
@@ -2111,8 +2135,18 @@ public abstract class Component
   public void setCursor(Cursor cursor)
   {
     this.cursor = cursor;
-    if (peer != null)
-      peer.setCursor(cursor);
+
+    // Only heavyweight peers handle this.
+    ComponentPeer p = peer;
+    Component comp = this;
+    while (p instanceof LightweightPeer)
+      {
+        comp = comp.parent;
+        p = comp == null ? null : comp.peer;
+      }
+
+    if (p != null)
+      p.setCursor(cursor);
   }
 
   /**
@@ -2283,7 +2317,7 @@ public abstract class Component
         pw = Math.min(pw, par.width);
         ph = Math.min(ph, par.height);
         par = par.parent;
-        p = par.peer;
+        p = par == null ? null : par.peer;
       }
 
     // Now send an UPDATE event to the heavyweight component that we've found.
@@ -2381,11 +2415,22 @@ public abstract class Component
    */
   public Image createImage(ImageProducer producer)
   {
+    // Only heavyweight peers can handle this.
+    ComponentPeer p = peer;
+    Component comp = this;
+    while (p instanceof LightweightPeer)
+      {
+        comp = comp.parent;
+        p = comp == null ? null : comp.peer;
+      }
+
     // Sun allows producer to be null.
-    if (peer != null)
-      return peer.createImage(producer);
+    Image im;
+    if (p != null)
+      im = p.createImage(producer);
     else
-      return getToolkit().createImage(producer);
+      im = getToolkit().createImage(producer);
+    return im;
   }
 
   /**
@@ -2401,10 +2446,16 @@ public abstract class Component
     Image returnValue = null;
     if (!GraphicsEnvironment.isHeadless ())
       {
-	if (isLightweight () && parent != null)
-	  returnValue = parent.createImage (width, height);
-	else if (peer != null)
-	  returnValue = peer.createImage (width, height);
+        // Only heavyweight peers can handle this.
+        ComponentPeer p = peer;
+        Component comp = this;
+        while (p instanceof LightweightPeer)
+          {
+            comp = comp.parent;
+            p = comp == null ? null : comp.peer;
+          }
+
+        returnValue = p.createImage(width, height);
       }
     return returnValue;
   }
@@ -2420,9 +2471,19 @@ public abstract class Component
    */
   public VolatileImage createVolatileImage(int width, int height)
   {
-    if (peer != null)
-      return peer.createVolatileImage(width, height);
-    return null;
+    // Only heavyweight peers can handle this.
+    ComponentPeer p = peer;
+    Component comp = this;
+    while (p instanceof LightweightPeer)
+      {
+        comp = comp.parent;
+        p = comp == null ? null : comp.peer;
+      }
+
+    VolatileImage im = null;
+    if (p != null)
+      im = p.createVolatileImage(width, height);
+    return im;
   }
 
   /**
@@ -2441,9 +2502,19 @@ public abstract class Component
                                            ImageCapabilities caps)
     throws AWTException
   {
-    if (peer != null)
-      return peer.createVolatileImage(width, height);
-    return null;
+    // Only heavyweight peers can handle this.
+    ComponentPeer p = peer;
+    Component comp = this;
+    while (p instanceof LightweightPeer)
+      {
+        comp = comp.parent;
+        p = comp == null ? null : comp.peer;
+      }
+
+    VolatileImage im = null;
+    if (p != null)
+      im = peer.createVolatileImage(width, height);
+    return im;
   }
 
   /**
@@ -2473,10 +2544,21 @@ public abstract class Component
   public boolean prepareImage(Image image, int width, int height,
                               ImageObserver observer)
   {
-    if (peer != null)
-	return peer.prepareImage(image, width, height, observer);
+    // Only heavyweight peers handle this.
+    ComponentPeer p = peer;
+    Component comp = this;
+    while (p instanceof LightweightPeer)
+      {
+        comp = comp.parent;
+        p = comp == null ? null : comp.peer;
+      }
+
+    boolean retval;
+    if (p != null)
+	retval = p.prepareImage(image, width, height, observer);
     else
-	return getToolkit().prepareImage(image, width, height, observer);
+	retval = getToolkit().prepareImage(image, width, height, observer);
+    return retval;
   }
 
   /**
@@ -2510,9 +2592,21 @@ public abstract class Component
   public int checkImage(Image image, int width, int height,
                         ImageObserver observer)
   {
-    if (peer != null)
-      return peer.checkImage(image, width, height, observer);
-    return getToolkit().checkImage(image, width, height, observer);
+    // Only heavyweight peers handle this.
+    ComponentPeer p = peer;
+    Component comp = this;
+    while (p instanceof LightweightPeer)
+      {
+        comp = comp.parent;
+        p = comp == null ? null : comp.peer;
+      }
+
+    int retval;
+    if (p != null)
+      retval = p.checkImage(image, width, height, observer);
+    else
+      retval = getToolkit().checkImage(image, width, height, observer);
+    return retval;
   }
 
   /**
@@ -2957,7 +3051,7 @@ public abstract class Component
       case HierarchyEvent.ANCESTOR_RESIZED:
         enabled = hierarchyBoundsListener != null
                   || (eventMask & AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK) != 0;
-          break;
+        break;
       default:
         assert false : "Should not reach here";
     }
@@ -3303,18 +3397,48 @@ public abstract class Component
    */
   protected final void enableEvents(long eventsToEnable)
   {
+    // Update the counter for hierarchy (bounds) listeners.
+    if ((eventsToEnable & AWTEvent.HIERARCHY_EVENT_MASK) != 0
+        && (eventMask & AWTEvent.HIERARCHY_EVENT_MASK) == 0)
+      {
+        // Need to lock the tree, otherwise we might end up inconsistent.
+        synchronized (getTreeLock())
+          {
+            numHierarchyListeners++;
+            if (parent != null)
+              parent.updateHierarchyListenerCount
+                                                (AWTEvent.HIERARCHY_EVENT_MASK,
+                                                 1);
+          }
+      }
+    if ((eventsToEnable & AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK) != 0
+        && (eventMask & AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK) == 0)
+      {
+        // Need to lock the tree, otherwise we might end up inconsistent.
+        synchronized (getTreeLock())
+          {
+            numHierarchyBoundsListeners++;
+            if (parent != null)
+              parent.updateHierarchyListenerCount
+                                         (AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK,
+                                          1);
+          }
+      }
+
     eventMask |= eventsToEnable;
-    // TODO: Unlike Sun's implementation, I think we should try and
-    // enable/disable events at the peer (gtk/X) level. This will avoid
-    // clogging the event pipeline with useless mousemove events that
-    // we arn't interested in, etc. This will involve extending the peer
-    // interface, but thats okay because the peer interfaces have been
-    // deprecated for a long time, and no longer feature in the
-    // API specification at all.
-    if (isLightweight() && parent != null)
-      parent.enableEvents(eventsToEnable);
-    else if (peer != null)
-      peer.setEventMask(eventMask);
+
+    // Only heavyweight peers handle this.
+    ComponentPeer p = peer;
+    Component comp = this;
+    while (p instanceof LightweightPeer)
+      {
+        comp = comp.parent;
+        p = comp == null ? null : comp.peer;
+      }
+
+    if (p != null)
+      p.setEventMask(eventMask);
+
   }
 
   /**
@@ -3327,8 +3451,48 @@ public abstract class Component
    */
   protected final void disableEvents(long eventsToDisable)
   {
+    // Update the counter for hierarchy (bounds) listeners.
+    if ((eventsToDisable & AWTEvent.HIERARCHY_EVENT_MASK) != 0
+        && (eventMask & AWTEvent.HIERARCHY_EVENT_MASK) != 0)
+      {
+        // Need to lock the tree, otherwise we might end up inconsistent.
+        synchronized (getTreeLock())
+          {
+            numHierarchyListeners--;
+            if (parent != null)
+              parent.updateHierarchyListenerCount
+                                                (AWTEvent.HIERARCHY_EVENT_MASK,
+                                                 -1);
+          }
+      }
+    if ((eventsToDisable & AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK) != 0
+        && (eventMask & AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK) != 0)
+      {
+        // Need to lock the tree, otherwise we might end up inconsistent.
+        synchronized (getTreeLock())
+          {
+            numHierarchyBoundsListeners--;
+            if (parent != null)
+              parent.updateHierarchyListenerCount
+                                         (AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK,
+                                          -1);
+          }
+      }
+
     eventMask &= ~eventsToDisable;
-    // forward new event mask to peer?
+
+    // Only heavyweight peers handle this.
+    ComponentPeer p = peer;
+    Component comp = this;
+    while (p instanceof LightweightPeer)
+      {
+        comp = comp.parent;
+        p = comp == null ? null : comp.peer;
+      }
+
+    if (p != null)
+      p.setEventMask(eventMask);
+
   }
 
   /**
@@ -3888,6 +4052,13 @@ public abstract class Component
        etc. */
        if (dropTarget != null) 
          dropTarget.addNotify(peer);
+
+       // Notify hierarchy listeners.
+       long flags = HierarchyEvent.DISPLAYABILITY_CHANGED;
+       if (isHierarchyVisible())
+         flags |= HierarchyEvent.SHOWING_CHANGED;
+       fireHierarchyEvent(HierarchyEvent.HIERARCHY_CHANGED, this, parent,
+                          flags);
       }
   }
 
@@ -3917,6 +4088,13 @@ public abstract class Component
             tmp.hide();
             tmp.dispose();
           }
+
+        // Notify hierarchy listeners.
+        long flags = HierarchyEvent.DISPLAYABILITY_CHANGED;
+        if (isHierarchyVisible())
+          flags |= HierarchyEvent.SHOWING_CHANGED;
+        fireHierarchyEvent(HierarchyEvent.HIERARCHY_CHANGED, this, parent,
+                           flags);
       }
   }
 
@@ -5494,6 +5672,26 @@ p   * <li>the set of backward traversal keys
   }
 
   /**
+   * Returns <code>true</code> when this component and all of its ancestors
+   * are visible, <code>false</code> otherwise.
+   *
+   * @return <code>true</code> when this component and all of its ancestors
+   *         are visible, <code>false</code> otherwise
+   */
+  boolean isHierarchyVisible()
+  {
+    boolean visible = isVisible();
+    Component comp = parent;
+    while (comp != null && visible)
+      {
+        comp = comp.parent;
+        if (comp != null)
+          visible = visible && comp.isVisible();
+      }
+    return visible;
+  }
+
+  /**
    * Coalesce paint events. Current heuristic is: Merge if the union of
    * areas is less than twice that of the sum of the areas. The X server
    * tend to create a lot of paint events that are adjacent but not
diff --git a/java/awt/Container.java b/java/awt/Container.java
index 409d164a1..8f508aa76 100644
--- a/java/awt/Container.java
+++ b/java/awt/Container.java
@@ -208,10 +208,12 @@ public class Container extends Component
    */
   public Insets insets()
   {
-    if (peer == null)
-      return new Insets (0, 0, 0, 0);
-
-    return ((ContainerPeer) peer).getInsets ();
+    Insets i;
+    if (peer == null || peer instanceof LightweightPeer)
+      i = new Insets (0, 0, 0, 0);
+    else
+      i = ((ContainerPeer) peer).getInsets ();
+    return i;
   }
 
   /**
@@ -506,26 +508,43 @@ public class Container extends Component
             
             r.removeNotify();
 
+            // Update the counter for Hierarchy(Bounds)Listeners.
+            int childHierarchyListeners = r.numHierarchyListeners;
+            if (childHierarchyListeners > 0)
+              updateHierarchyListenerCount(AWTEvent.HIERARCHY_EVENT_MASK,
+                                           -childHierarchyListeners);
+            int childHierarchyBoundsListeners = r.numHierarchyBoundsListeners;
+            if (childHierarchyBoundsListeners > 0)
+              updateHierarchyListenerCount(AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK,
+                                           -childHierarchyListeners);
+
             if (layoutMgr != null)
               layoutMgr.removeLayoutComponent(r);
 
             r.parent = null;
 
-            if (isShowing ())
+            // Send ContainerEvent if necessary.
+            if (containerListener != null
+                || (eventMask & AWTEvent.CONTAINER_EVENT_MASK) != 0)
               {
                 // Post event to notify of removing the component.
                 ContainerEvent ce
                   = new ContainerEvent(this,
                                        ContainerEvent.COMPONENT_REMOVED,
                                        r);
-                
-                getToolkit().getSystemEventQueue().postEvent(ce);
+                dispatchEvent(ce);
               }
-            }
-          
+
+            // Send HierarchyEvent if necessary.
+            fireHierarchyEvent(HierarchyEvent.HIERARCHY_CHANGED, r, this,
+                               HierarchyEvent.PARENT_CHANGED);
+
+          }
+
+        if (valid)
           invalidate();
         
-          ncomponents = 0;
+        ncomponents = 0;
       }
   }
 
@@ -2004,6 +2023,43 @@ public class Container extends Component
       parent.updateHierarchyListenerCount(type, delta);
   }
 
+  /**
+   * Notifies interested listeners about resizing or moving the container.
+   * This performs the super behaviour (sending component events) and
+   * additionally notifies any hierarchy bounds listeners on child components.
+   *
+   * @param resized true if the component has been resized, false otherwise
+   * @param moved true if the component has been moved, false otherwise
+   */
+  void notifyReshape(boolean resized, boolean moved)
+  {
+    // Notify component listeners.
+    super.notifyReshape(resized, moved);
+
+    if (ncomponents > 0)
+      {
+        // Notify hierarchy bounds listeners.
+        if (resized)
+          {
+            for (int i = 0; i < getComponentCount(); i++)
+              {
+                Component child = getComponent(i);
+                child.fireHierarchyEvent(HierarchyEvent.ANCESTOR_RESIZED,
+                                         this, parent, 0);
+              }
+          }
+        if (moved)
+          {
+            for (int i = 0; i < getComponentCount(); i++)
+              {
+                Component child = getComponent(i);
+                child.fireHierarchyEvent(HierarchyEvent.ANCESTOR_MOVED,
+                                         this, parent, 0);
+              }
+          }
+      }
+  }
+
   private void addNotifyContainerChildren()
   {
     synchronized (getTreeLock ())
diff --git a/java/awt/Toolkit.java b/java/awt/Toolkit.java
index 2842091c1..08c0cc67f 100644
--- a/java/awt/Toolkit.java
+++ b/java/awt/Toolkit.java
@@ -131,6 +131,11 @@ public abstract class Toolkit
   AWTEventListenerProxy[] awtEventListeners;
 
   /**
+   * The shared peer for all lightweight components.
+   */
+  private GLightweightPeer lightweightPeer;
+
+  /**
    * Default constructor for subclasses.
    */
   public Toolkit()
@@ -379,7 +384,9 @@ public abstract class Toolkit
    */
   protected LightweightPeer createComponent(Component target)
   {
-    return new GLightweightPeer(target);
+    if (lightweightPeer == null)
+      lightweightPeer = new GLightweightPeer();
+    return lightweightPeer;
   }
 
   /**