? java/awt/semantic.cache
Index: java/awt/Component.java
===================================================================
RCS file: /cvsroot/classpath/classpath/java/awt/Component.java,v
retrieving revision 1.69
diff -u -r1.69 Component.java
--- java/awt/Component.java	5 Aug 2005 15:26:08 -0000	1.69
+++ java/awt/Component.java	12 Aug 2005 11:44:51 -0000
@@ -1404,9 +1404,6 @@
     // Erase old bounds and repaint new bounds for lightweights.
     if (isLightweight() && isShowing ())
       {
-        boolean shouldRepaintParent = false;
-        boolean shouldRepaintSelf = false;
-
         if (parent != null)
           {
             Rectangle parentBounds = parent.getBounds();
@@ -1416,14 +1413,11 @@
             Rectangle newBounds = new Rectangle(parent.getX() + x,
                                                 parent.getY() + y,
                                                 width, height);
-            shouldRepaintParent = parentBounds.intersects(oldBounds);
-            shouldRepaintSelf = parentBounds.intersects(newBounds);
+            Rectangle destroyed = oldBounds.union(newBounds);
+            if (!destroyed.isEmpty())
+              parent.repaint(0, destroyed.x, destroyed.y, destroyed.width,
+                             destroyed.height);
           }
-
-        if (shouldRepaintParent && parent != null)
-          parent.repaint(oldx, oldy, oldwidth, oldheight);
-        if (shouldRepaintSelf)
-          repaint();
       }
 
     // Only post event if this component is visible and has changed size.
@@ -1830,9 +1824,8 @@
    */
   public void paint(Graphics g)
   {
-    // Paint the heavyweight peer
-    if (!isLightweight() && peer != null)
-      peer.paint(g);
+    // This is a callback method and is meant to be overridden by subclasses
+    // that want to perform custom painting.
   }
 
   /**
@@ -1858,7 +1851,8 @@
   {
     // Tests show that the clearing of the background is only done in
     // two cases:
-    // - If the component is lightwight (yes this is in contrast to the spec).
+    // - If the component is lightweight (yes this is in contrast to the spec).
+    // or
     // - If the component is a toplevel container.
     if (isLightweight() || getParent() == null)
       {
@@ -1943,14 +1937,18 @@
    */
   public void repaint(long tm, int x, int y, int width, int height)
   {
-    // Handle lightweight repainting by forwarding to native parent
-    if (isLightweight() && parent != null)
+    if(!isShowing())
       {
-        if (parent != null)
-          parent.repaint(tm, x + getX(), y + getY(), width, height);
+        Component p = parent;
+        if (p != null)
+          p.repaint(tm, x + getX(), y + getY(), width, height);
+      }
+    else
+      {
+        ComponentPeer p = peer;
+        if (p != null)
+          p.repaint(tm, x, y, width, height);
       }
-    else if (peer != null)
-      peer.repaint(tm, x, y, width, height);
   }
 
   /**
@@ -2011,7 +2009,7 @@
   public boolean imageUpdate(Image img, int flags, int x, int y, int w, int h)
   {
     if ((flags & (FRAMEBITS | ALLBITS)) != 0)
-      repaint ();
+      repaint();
     else if ((flags & SOMEBITS) != 0)
       {
 	if (incrementalDraw)
@@ -2021,10 +2019,10 @@
 		long tm = redrawRate.longValue();
 		if (tm < 0)
 		  tm = 0;
-		repaint (tm);
+                repaint(tm);
 	      }
 	    else
-	      repaint (100);
+              repaint(100);
 	  }
       }
     return (flags & (ALLBITS | ABORT | ERROR)) == 0;
@@ -2322,8 +2320,6 @@
     // Some subclasses in the AWT package need to override this behavior,
     // hence the use of dispatchEventImpl().
     dispatchEventImpl(e);
-    if (peer != null && ! e.consumed)
-      peer.handleEvent(e);
   }
 
   /**
@@ -4786,7 +4782,7 @@
    * @param e the event to dispatch
    */
 
-  void dispatchEventImpl (AWTEvent e)
+  void dispatchEventImpl(AWTEvent e)
   {
     Event oldEvent = translateEvent (e);
 
@@ -4820,7 +4816,10 @@
                 break;
               }
           }
-        processEvent (e);
+        if (e.id == PaintEvent.PAINT || e.id == PaintEvent.UPDATE)
+          peer.handleEvent(e);
+        else
+          processEvent(e);
       }
   }
 
Index: java/awt/Container.java
===================================================================
RCS file: /cvsroot/classpath/classpath/java/awt/Container.java,v
retrieving revision 1.58
diff -u -r1.58 Container.java
--- java/awt/Container.java	10 Aug 2005 12:43:30 -0000	1.58
+++ java/awt/Container.java	12 Aug 2005 11:44:51 -0000
@@ -42,6 +42,7 @@
 import java.awt.event.ContainerListener;
 import java.awt.event.KeyEvent;
 import java.awt.event.MouseEvent;
+import java.awt.peer.ComponentPeer;
 import java.awt.peer.ContainerPeer;
 import java.awt.peer.LightweightPeer;
 import java.beans.PropertyChangeListener;
@@ -757,11 +758,10 @@
   {
     if (!isShowing())
       return;
-    // Paint self first.
-    super.paint(g);
+
     // Visit heavyweights as well, in case they were
     // erased when we cleared the background for this container.
-    visitChildren(g, GfxPaintVisitor.INSTANCE, true);
+    visitChildren(g, GfxPaintVisitor.INSTANCE, false);
   }
 
   /**
@@ -776,17 +776,26 @@
    * @specnote The specification suggests that this method forwards the
    *           update() call to all its lightweight children. Tests show
    *           that this is not done either in the JDK. The exact behaviour
-   *           seems to be that top-level container call super.update()
-   *           (causing the background to be cleared), and all other containers
+   *           seems to be that the background is cleared in heavyweight
+   *           Containers, and all other containers
    *           directly call paint(), causing the (lightweight) children to
    *           be painted.
    */
   public void update(Graphics g)
   {
-    if (getParent() == null)
-      super.update(g);
-    else
-      paint(g);
+    // It seems that the JDK clears the background of containers like Panel
+    // and Window (within this method) but not of 'plain' Containers or
+    // JComponents. This could
+    // lead to the assumption that it only clears heavyweight containers.
+    // However that is not quite true. In a test with a custom Container
+    // that overrides isLightweight() to return false, the background is
+    // also not cleared. So we do a check on !(peer instanceof LightweightPeer)
+    // instead.
+    ComponentPeer p = peer;
+    if (p != null && !(p instanceof LightweightPeer))
+      g.clearRect(0, 0, getWidth(), getHeight());
+
+    paint(g);
   }
 
   /**