* gnu/gcj/awt/ComponentDataBlitOp.java: New file.

	* gnu/gcj/awt/GLightweightPeer.java: New file.
	* java/awt/BorderLayout.java: Implemented all methods.
	* java/awt/Button.java (actionListener, actionCommand): Renamed
	and modifier change.
	(addNotify): Call super.
	(dispatchEventImpl): New method.
	(getListeners): New method.
	(label): Made package-private, not private.
	* java/awt/Canvas.java: Implemented class body.
	* java/awt/Color.java (brighter): New method.
	(darker): New method.
	(hashCode): New method.
	* java/awt/Component.java (visible, enabled, eventMask): Set defaults.
	(getGraphicsConfiguration): Delegate to
	getGraphicsConfigurationImpl().
	(getGraphicsConfigurationImpl): New method.
	(getToolkit): Only return value from peer if not null.
	(isDisplayable): Check with parent.
	(isShowing): No parent implies not showing.
	(getForeground): Check parent property if local is null.
	(getBackground): Likewise.
	(getFont): Likewise.
	(setForeground): Inform peer.
	(setBackground): Likewise
	(setLocale): Invalidate component.
	(getColorModel): Implemented.
	(setLocation): Invalidate, or ignore if no change.
	(setSize): Invalidate, or ignore if no change.
	(setBounds): Invalidate, or ignore if no change.
	(isOpaque): By default, heavyweight implies opaque.
	(isLightweight): Implemented.
	(getMaximumSize): Implemented.
	(doLayout): Implemented, NOP.
	(validate): Implemented, NOP.
	(invalidate): Only propagate to parent if parent was valid.
	(getGraphics): Implemented.
	(getFontMetrics): Implemented.
	(update): Implemented.
	(paintAll): Implemented.
	(repaint): Implemented all repaint methods.
	(print): Implemented.
	(printAll): Implemented.
	(createImage): Implemented.
	(dispatchEvent): Give the peer a chance to handle the event.
	(dispatchEventImpl): Dispatch paint events.
	(enableEvents): Lightweights enable events on parent component.
	(coalesceEvents): Coalesce paint events, and select event type
	using a switch.
	(coalescePaintEvents): New method.
	(processEvent): Fix unfortunate ordering of statements, and call
	correct method for MOUSE_CLICKED.
	(processPaintEvent): New method.
	(addNotify): Allow container to notify children before event
	mask is set in peer.
	(addNotifyContainerChildren): New method.
	(removeNotify): Visibility should not change on removeNotify.
	(paramString): Implemented.
	(list): Implemented two of the list methods.
	* Container (myInsets): Removed, insets are managed by peer.
	(getInsets): Query peer.
	(addImpl): Fix reparenting, enable events for lightweights,
	initialize component array.
	(validate): Call doLayout in validateTree() instead.
	(validateTree): Do nothing if already valid. Call beginValidate(),
	endValidate() on peer. Call validateTree() instead of validate()
	for children that are containers. Mark valid after validation of
	children.
	(setFont): Partial implementation.
	(paint): Implemented.
	(visitChildren): New method.
	(visitChild): New method.
	(update): Implemented.
	(print): Implemented.
	(paintComponents): Implemented.
	(printComponents): Consider translation and clipping.
	(getComponentAt): Ignore invisible children. Return this if no
	child match.
	(addNotify): Call super.
	(addNotifyContainerChildren): New method.
	(paramString): Implemented.
	(list): Implemented.
	* java/awt/EventQueue (invokeAndWait): Get system event queue the
	right way.
	(invokeLater): Likewise.
	(isDispatchThread): Likewise.
	* java/awt/FontMetrics (getLeading): Formula change.
	(getDescent): Consider leading also.
	(getMaxAscent): Default to getAscent().
	(getMaxDescent): Default to getDescent.
	(getMaxAdvance): Return value signifying unknown.
	(charWidth): Both methods implemented.
	(charsWidth): Implemented.
	(bytesWidth): Implemented.
	(getWidths): Implemented.
	* java/awt/Frame.java (NORMAL, ICONIFIED, iconImage, isResizable,
	state): New fields.
	(Frame): Rearragend constuctor chaining to disallow null being
	passed as a graphics configuration.
	(getTitle): Return empty string if null.
	(dispose): Removed.
	(getIconImage): New method.
	(setIconImage): New method.
	(finalize): New method.
	(setMenuBar): Notify peer.
	(isResizable): New method.
	(setResizable): New method.
	(getState): New method.
	(getFont): Removed.
	(remove): Implemented.
	(removeNotify): New method.
	(getFrames): New method.
	* java/awt/Graphics.java: Implemented body of class.
	* java/awt/Graphics2D.java: New file.
	* java/awt/GraphicsConfiguration.java: Enabled part of the API.
	* java/awt/Image.java: Implemented body of class.
	* java/awt/Panel.java (Panel): Call correct super constructor.
	(addNotify): Implemented.
	* java/awt/Rectangle.java (isEmpty): Fixed reversed logic.
	* java/awt/RenderingHints.java: New file.
	* java/awt/Toolkit.java (createComponent): Implemented.
	(getSystemEventQueue): Delegate to getSystemEventQueueImpl().
	* java/awt/Window.java (Window): Two new constructors. Reordered
	constructor chaining.
	(getGraphicsConfigurationImpl): New method.
	(finalize): Call super.
	(addNotify): Call super.
	(pack): Do layout stuff.
	(show): Ensure that peer exists and that component is valid.
	(dispose): Dispose owned children.
	(getOwner): Simplify code, casting null pointers is valid.
	(getGraphicsConfiguration): Ask peer if local value is null.
	* java/awt/event/ActionEvent.java (getActionCommand): Renamed from
	getcmd().
	* java/awt/image/BufferedImage.java: New file.
	* java/awt/image/RasterOp.java: New file.
	* java/awt/peer/ComponentPeer.java (getGraphicsConfiguration):
	More powerfull replacement for getColorModel().
	(getColorModel) Removed.
	(setEventMask) New method.
	* Makefile.am: Added new files.
	* Makefile.in: Rebuilt.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@35748 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 227 insertions, 24 deletions

diff --git a/libjava/java/awt/BorderLayout.java b/libjava/java/awt/BorderLayout.java
index 6f4cb5cdb4c..0d779c1a752 100644
--- a/libjava/java/awt/BorderLayout.java
+++ b/libjava/java/awt/BorderLayout.java
@@ -8,12 +8,25 @@ details.  */
 
 package java.awt;
 
-/* A very incomplete placeholder. */
-
-public class BorderLayout implements LayoutManager2
+public class BorderLayout implements LayoutManager2, java.io.Serializable
 {
+  public static final String NORTH  = "North",
+                             SOUTH  = "South",
+                             EAST   = "East",
+                             WEST   = "West",
+                             CENTER = "Center";
+  
+  // FIXME: use these too
+  public static final String BEFORE_FIRST_LINE = "First",
+                             AFTER_LAST_LINE = "Last",
+                             BEFORE_LINE_BEGINS = "Before",
+                             AFTER_LINE_ENDS = "After";
+
+
+  // FIXME: check serialization of fields
   int hgap;
   int vgap;
+  Component north, south, east, west, center;
 
   public BorderLayout ()
   {
@@ -26,26 +39,216 @@ public class BorderLayout implements LayoutManager2
     this.vgap = vgap;
   }
 
-  public void addLayoutComponent (String name, Component comp)
-  { /* FIXME */ }
-  public void layoutContainer (Container parent)
-  { /* FIXME */ }
-  public Dimension minimumLayoutSize (Container parent)
-  { /* FIXME */ return null; }
-  public Dimension preferredLayoutSize (Container parent)
-  { /* FIXME */ return null; }
-  public void removeLayoutComponent (Component comp)
-  { /* FIXME */ }
-
-  public void addLayoutComponent (Component comp, Object constraints)
-  { /* FIXME */ }
-  public float getLayoutAlignmentX (Container target)
-  { /* FIXME */ return (float) 0.0; }
-  public float getLayoutAlignmentY (Container target)
-  { /* FIXME */ return (float) 0.0; }
-  public void invalidateLayout (Container target)
-  { /* FIXME */ }
-  public Dimension maximumLayoutSize (Container target)
-  { /* FIXME */ return null; }
+  public int getHgap()
+  {
+    return hgap;
+  }    
+
+  public void setHgap(int hgap)
+  {
+    this.hgap = hgap;
+  }
+
+  public int getVgap()
+  {
+    return vgap;
+  }    
+
+  public void setVgap(int vgap)
+  {
+    this.vgap = vgap;
+  }
+  
+  public void addLayoutComponent(Component comp, Object constraints)
+  {
+    if ((constraints == null) || CENTER.equals(constraints))
+      {
+	center = comp; 
+      }
+    else if (NORTH.equals(constraints))
+      {
+	north = comp;
+      }
+    else if (SOUTH.equals(constraints))
+      {
+	south = comp;
+      }
+    else if (EAST.equals(constraints))
+      {
+	east = comp;
+      }
+    else if (WEST.equals(constraints))
+      {
+	west = comp;
+      }
+  }
+    
+  public void addLayoutComponent(String name, Component comp)
+  {
+    addLayoutComponent(comp, name);
+  }
+
+  public void removeLayoutComponent(Component comp)
+  {
+    if (center == comp)
+      {
+	center = null;
+      }
+    else if (north == comp)
+      {
+	north = null;
+      }
+    else if (south == comp)
+      {
+	south = null;
+      }
+    else if (east == comp)
+      {
+	east = null;
+      }
+    else if (west == comp)
+      {
+	west = null;
+      }
+  }
+
+  public Dimension minimumLayoutSize(Container target)
+  {
+    return calcSize(getMinimumSize(center),
+		    getMinimumSize(north),
+		    getMinimumSize(south),
+		    getMinimumSize(east),
+		    getMinimumSize(west),
+		    target);
+  }
+
+  public Dimension preferredLayoutSize(Container target)
+  {
+    return calcSize(getPreferredSize(center),
+		    getPreferredSize(north),
+		    getPreferredSize(south),
+		    getPreferredSize(east),
+		    getPreferredSize(west),
+		    target);	
+  }
+    
+  /**
+   * Completely disregards the requested maximum sizes of the
+   * components, and states that the container has no upper size
+   * limit.
+   *
+   * @return a dimension of width and height Integer.MAX_VALUE.
+   */
+  public Dimension maximumLayoutSize(Container target)
+  {
+    return (Dimension) DIM_MAX.clone();
+  }	
+
+  public float getLayoutAlignmentX(Container parent)
+  {
+    return Component.CENTER_ALIGNMENT;
+  }
+
+  public float getLayoutAlignmentY(Container parent)
+  {
+    return Component.CENTER_ALIGNMENT;
+  }
+    
+  public void invalidateLayout(Container target)
+  {
+    // TODO... implement caching?
+  }
+
+  public void layoutContainer(Container target)
+  {
+    Insets i = target.getInsets();
+    Dimension c = getPreferredSize(center);
+    Dimension n = getPreferredSize(north);
+    Dimension s = getPreferredSize(south);
+    Dimension e = getPreferredSize(east);
+    Dimension w = getPreferredSize(west);
+    Dimension t = target.getSize();
+    
+    /*
+             <-> hgap     <-> hgap
+      +----------------------------+          }
+      |t                           |          } i.top
+      |  +----------------------+  |  --- y1  }
+      |  |n                     |  |
+      |  +----------------------+  |          } vgap
+      |  +---+ +----------+ +---+  |  --- y2  }        }
+      |  |w  | |c         | |e  |  |                   } hh
+      |  +---+ +----------+ +---+  |          } vgap   }
+      |  +----------------------+  |  --- y3  }
+      |  |s                     |  |
+      |  +----------------------+  |          }
+      |                            |          } i.bottom
+      +----------------------------+          }
+         |x1   |x2          |x3
+         <---------------------->
+      <-->         ww           <-->
+     i.left                    i.right
+    */
+
+    int x1 = i.left;
+    int x2 = x1 + w.width + hgap;
+    int x3 = t.width - i.right - e.width;
+    int ww = t.width - i.right - i.left;
+
+    int y1 = i.top;
+    int y2 = y1 + n.height + vgap;
+    int y3 = t.height - i.bottom - s.height;
+    int hh = y3-y2-vgap;
+
+    setBounds(center, x2, y2, x3-x2-hgap, hh);
+    setBounds(north, x1, y1, ww, n.height);
+    setBounds(south, x1, y3, ww, s.height);
+    setBounds(west, x1, y2, w.width, hh);
+    setBounds(east, x3, y2, e.width, hh);
+  }
+  
+  public String toString()
+  {
+    return getClass().getName() + "[hgap=" + hgap + ",vgap=" + vgap + "]";
+  }
 
+
+  // Support:
+
+  static final Dimension DIM_0   = new Dimension(0, 0);
+  static final Dimension DIM_MAX = new Dimension(Integer.MAX_VALUE,
+						 Integer.MAX_VALUE);
+
+  void setBounds(Component comp, int x, int y, int w, int h)
+  {
+    if (comp == null)
+      return;
+    comp.setBounds(x, y, w, h);
+  }
+
+  Dimension getMinimumSize(Component comp)
+  {
+    if (comp == null)
+      return DIM_0;
+    return comp.getMinimumSize();
+  }
+
+  Dimension getPreferredSize(Component comp)
+  {
+    if (comp == null)
+      return DIM_0;
+    return comp.getPreferredSize();
+  }
+
+  Dimension calcSize(Dimension c, Dimension n, Dimension s,
+		     Dimension e, Dimension w, Container target)
+  {
+    Insets i = target.getInsets();
+    
+    return new Dimension(c.width + e.width + w.width + hgap*2 +
+			 i.left + i.right,
+			 c.height + n.height + s.height + vgap*2 +
+			 i.top + i.bottom
+			 );
+  }
 }