| /* Copyright (C) 1999, 2000 Free Software Foundation |
| |
| This file is part of libjava. |
| |
| This software is copyrighted work licensed under the terms of the |
| Libjava License. Please consult the file "LIBJAVA_LICENSE" for |
| details. */ |
| |
| package java.awt; |
| |
| import java.awt.event.*; |
| import java.io.PrintStream; |
| import java.io.PrintWriter; |
| import java.util.EventListener; |
| import java.awt.peer.ComponentPeer; |
| import java.awt.peer.ContainerPeer; |
| import java.awt.peer.LightweightPeer; |
| |
| /* A somewhat incomplete class. */ |
| |
| public class Container extends Component |
| { |
| /* Serialized fields from the serialization spec. */ |
| int ncomponents; |
| Component[] component; |
| LayoutManager layoutMgr; |
| /* LightweightDispatcher dispatcher; */ // wtf? |
| Dimension maxSize; |
| int containerSerializedDataVersion; |
| |
| /* Anything else is non-serializable, and should be declared "transient". */ |
| transient ContainerListener containerListener; |
| |
| public Container() |
| { |
| } |
| |
| public int getComponentCount() |
| { |
| return ncomponents; |
| } |
| |
| /** @deprecated Use getComponentCount() instead. */ |
| public int countComponents() |
| { |
| return ncomponents; |
| } |
| |
| public Component getComponent (int n) |
| { |
| if (n < 0 || n >= ncomponents) |
| throw new ArrayIndexOutOfBoundsException("no such component"); |
| return component[n]; |
| } |
| |
| public Component[] getComponents() |
| { |
| Component[] result = new Component[ncomponents]; |
| if (ncomponents > 0) |
| System.arraycopy(component, 0, result, 0, ncomponents); |
| return result; |
| } |
| |
| public Insets getInsets() |
| { |
| if (peer == null) |
| return new Insets(0, 0, 0, 0); |
| |
| return ((ContainerPeer) peer).getInsets(); |
| } |
| |
| /** @deprecated Use getInsets() instead. */ |
| public Insets insets() |
| { |
| return getInsets(); |
| } |
| |
| public Component add (Component comp) |
| { |
| addImpl (comp, null, -1); |
| return comp; |
| } |
| |
| public Component add (String name, Component comp) |
| { |
| addImpl (comp, name, -1); |
| return comp; |
| } |
| |
| public Component add (Component comp, int index) |
| { |
| addImpl (comp, null, index); |
| return comp; |
| } |
| |
| public void add (Component comp, Object constraints) |
| { |
| addImpl (comp, constraints, -1); |
| } |
| |
| public void add (Component comp, Object constraints, int index) |
| { |
| addImpl (comp, constraints, index); |
| } |
| |
| protected void addImpl (Component comp, Object constraints, int index) |
| { |
| if (index > ncomponents |
| || comp instanceof Window |
| || (comp instanceof Container |
| && ((Container) comp).isAncestorOf (this))) |
| throw new IllegalArgumentException (); |
| |
| // Reparent component, and make sure component is instantiated if |
| // we are. |
| if (comp.parent != null) |
| comp.parent.remove (comp); |
| comp.parent = this; |
| if (peer != null) |
| { |
| comp.addNotify (); |
| |
| if (comp.isLightweight()) |
| enableEvents(comp.eventMask); |
| } |
| |
| invalidate (); |
| |
| if (component == null) |
| component = new Component[4]; // FIXME, better initial size? |
| |
| // This isn't the most efficient implementation. We could do less |
| // copying when growing the array. It probably doesn't matter. |
| if (ncomponents >= component.length) |
| { |
| int nl = component.length * 2; |
| Component[] c = new Component[nl]; |
| System.arraycopy (component, 0, c, 0, ncomponents); |
| component = c; |
| } |
| if (index == -1) |
| component[ncomponents++] = comp; |
| else |
| { |
| System.arraycopy (component, index, component, index + 1, |
| ncomponents - index); |
| component[index] = comp; |
| ++ncomponents; |
| } |
| |
| // Notify the layout manager. |
| if (layoutMgr != null) |
| { |
| if (constraints != null && layoutMgr instanceof LayoutManager2) |
| { |
| LayoutManager2 lm2 = (LayoutManager2) layoutMgr; |
| lm2.addLayoutComponent (comp, constraints); |
| } |
| else |
| layoutMgr.addLayoutComponent ((String) constraints, comp); |
| } |
| |
| ContainerEvent ce = new ContainerEvent (this, |
| ContainerEvent.COMPONENT_ADDED, |
| comp); |
| dispatchEvent (ce); |
| } |
| |
| public void remove (int index) |
| { |
| Component r = component[index]; |
| |
| r.removeNotify (); |
| |
| System.arraycopy (component, index + 1, component, index, |
| ncomponents - index - 1); |
| component[--ncomponents] = null; |
| |
| invalidate (); |
| |
| if (layoutMgr != null) |
| layoutMgr.removeLayoutComponent (r); |
| |
| ContainerEvent ce = new ContainerEvent (this, |
| ContainerEvent.COMPONENT_REMOVED, |
| r); |
| dispatchEvent (ce); |
| } |
| |
| public void remove (Component comp) |
| { |
| for (int i = 0; i < ncomponents; ++i) |
| { |
| if (component[i] == comp) |
| { |
| remove (i); |
| break; |
| } |
| } |
| } |
| |
| public void removeAll() |
| { |
| while (ncomponents > 0) |
| remove (0); |
| } |
| |
| public LayoutManager getLayout() |
| { |
| return layoutMgr; |
| } |
| |
| public void setLayout(LayoutManager mgr) |
| { |
| layoutMgr = mgr; |
| invalidate (); |
| } |
| |
| public void doLayout() |
| { |
| if (layoutMgr != null) |
| layoutMgr.layoutContainer (this); |
| } |
| |
| /** @deprecated Use doLayout() instead. */ |
| public void layout() |
| { |
| doLayout(); |
| } |
| |
| public void invalidate() |
| { |
| super.invalidate (); |
| } |
| |
| public void validate() |
| { |
| if (! isValid ()) |
| { |
| validateTree (); |
| } |
| } |
| |
| protected void validateTree() |
| { |
| if (valid) return; |
| |
| ContainerPeer cPeer = null; |
| if ((peer != null) && !(peer instanceof LightweightPeer)) |
| { |
| cPeer = (ContainerPeer) peer; |
| cPeer.beginValidate(); |
| } |
| |
| doLayout (); |
| for (int i = 0; i < ncomponents; ++i) |
| { |
| Component comp = component[i]; |
| if (comp instanceof Container) |
| { |
| ((Container) comp).validateTree(); |
| } |
| else |
| { |
| component[i].validate(); |
| } |
| } |
| |
| /* children will call invalidate() when they are layed out. It |
| is therefore imporant that valid is not set to true |
| before after the children has been layed out. */ |
| valid = true; |
| |
| if (cPeer != null) |
| cPeer.endValidate(); |
| } |
| |
| public void setFont(Font f) |
| { |
| super.setFont(f); |
| // FIXME, should invalidate all children with font == null |
| } |
| |
| public Dimension getPreferredSize() |
| { |
| if (layoutMgr != null) |
| return layoutMgr.preferredLayoutSize (this); |
| else |
| return super.getPreferredSize (); |
| } |
| |
| /** @deprecated Use getPreferredSize() instead */ |
| public Dimension preferredSize() |
| { |
| return getPreferredSize(); |
| } |
| |
| public Dimension getMinimumSize() |
| { |
| if (layoutMgr != null) |
| return layoutMgr.minimumLayoutSize (this); |
| else |
| return super.getMinimumSize (); |
| } |
| |
| /** @deprecated Use getMinimumSize() instead */ |
| public Dimension minimumSize() |
| { |
| return getMinimumSize(); |
| } |
| |
| public Dimension getMaximumSize() |
| { |
| if (layoutMgr != null && layoutMgr instanceof LayoutManager2) |
| { |
| LayoutManager2 lm2 = (LayoutManager2) layoutMgr; |
| return lm2.maximumLayoutSize (this); |
| } |
| else |
| return super.getMaximumSize (); |
| } |
| |
| public float getAlignmentX() |
| { |
| if (layoutMgr instanceof LayoutManager2) |
| { |
| LayoutManager2 lm2 = (LayoutManager2) layoutMgr; |
| return lm2.getLayoutAlignmentX (this); |
| } |
| else |
| return CENTER_ALIGNMENT; |
| } |
| |
| public float getAlignmentY() |
| { |
| if (layoutMgr instanceof LayoutManager2) |
| { |
| LayoutManager2 lm2 = (LayoutManager2) layoutMgr; |
| return lm2.getLayoutAlignmentY (this); |
| } |
| else |
| return CENTER_ALIGNMENT; |
| } |
| |
| public void paint(Graphics g) |
| { |
| if (!isShowing()) |
| return; |
| super.paint(g); |
| visitChildren(g, GfxPaintVisitor.INSTANCE, true); |
| } |
| |
| /** |
| * Perform a graphics operation on the children of this container. |
| * For each applicable child, the visitChild() method will be called |
| * to perform the graphics operation. |
| * |
| * @param gfx The graphics object that will be used to derive new |
| * graphics objects for the children. |
| * |
| * @param visitor Object encapsulating the graphics operation that |
| * should be performed. |
| * |
| * @param lightweightOnly If true, only lightweight components will |
| * be visited. |
| */ |
| private void visitChildren(Graphics gfx, GfxVisitor visitor, |
| boolean lightweightOnly) |
| { |
| // FIXME: do locking |
| |
| for (int i = 0; i < ncomponents; ++i) |
| { |
| Component comp = component[i]; |
| boolean applicable = comp.isVisible() |
| && (comp.isLightweight() || !lightweightOnly); |
| |
| if (applicable) |
| visitChild(gfx, visitor, comp); |
| } |
| } |
| |
| /** |
| * Perform a graphics operation on a child. A translated and clipped |
| * graphics object will be created, and the visit() method of the |
| * visitor will be called to perform the operation. |
| * |
| * @param gfx The graphics object that will be used to derive new |
| * graphics objects for the child. |
| * |
| * @param visitor Object encapsulating the graphics operation that |
| * should be performed. |
| * |
| * @param comp The child component that should be visited. |
| */ |
| private void visitChild(Graphics gfx, GfxVisitor visitor, |
| Component comp) |
| { |
| Rectangle bounds = comp.getBounds(); |
| Rectangle clip = gfx.getClipBounds().intersection(bounds); |
| |
| if (clip.isEmpty()) return; |
| |
| Graphics gfx2 = gfx.create(); |
| gfx2.setClip(clip.x, clip.y, clip.width, clip.height); |
| gfx2.translate(bounds.x, bounds.y); |
| |
| visitor.visit(comp, gfx2); |
| } |
| |
| public void update(Graphics g) |
| { |
| super.update(g); |
| } |
| |
| public void print(Graphics g) |
| { |
| super.print(g); |
| visitChildren(g, GfxPrintVisitor.INSTANCE, true); |
| } |
| |
| public void paintComponents(Graphics g) |
| { |
| super.paint(g); |
| visitChildren(g, GfxPaintAllVisitor.INSTANCE, true); |
| } |
| |
| public void printComponents(Graphics g) |
| { |
| super.paint(g); |
| visitChildren(g, GfxPrintAllVisitor.INSTANCE, true); |
| } |
| |
| void dispatchEventImpl(AWTEvent e) |
| { |
| if ((e.id <= ContainerEvent.CONTAINER_LAST |
| && e.id >= ContainerEvent.CONTAINER_FIRST) |
| && (containerListener != null |
| || (eventMask & AWTEvent.CONTAINER_EVENT_MASK) != 0)) |
| processEvent(e); |
| else super.dispatchEventImpl(e); |
| } |
| |
| public void addContainerListener(ContainerListener l) |
| { |
| containerListener = AWTEventMulticaster.add (containerListener, l); |
| } |
| |
| public void removeContainerListener(ContainerListener l) |
| { |
| containerListener = AWTEventMulticaster.remove(containerListener, l); |
| } |
| |
| /** @since 1.3 */ |
| public EventListener[] getListeners(Class listenerType) |
| { |
| if (listenerType == ContainerListener.class) |
| return getListenersImpl(listenerType, containerListener); |
| else return super.getListeners(listenerType); |
| } |
| |
| protected void processEvent(AWTEvent e) |
| { |
| if (e instanceof ContainerEvent) |
| processContainerEvent((ContainerEvent) e); |
| else super.processEvent(e); |
| } |
| |
| protected void processContainerEvent(ContainerEvent e) |
| { |
| if (containerListener == null) |
| return; |
| switch (e.id) |
| { |
| case ContainerEvent.COMPONENT_ADDED: |
| containerListener.componentAdded(e); |
| break; |
| |
| case ContainerEvent.COMPONENT_REMOVED: |
| containerListener.componentRemoved(e); |
| break; |
| } |
| } |
| |
| /** @deprecated */ |
| public void deliverEvent(Event e) |
| { |
| } |
| |
| public Component getComponentAt (int x, int y) |
| { |
| if (! contains (x, y)) |
| return null; |
| for (int i = 0; i < ncomponents; ++i) |
| { |
| // Ignore invisible children... |
| if (!component[i].isVisible()) |
| continue; |
| |
| int x2 = x - component[i].x; |
| int y2 = y - component[i].y; |
| if (component[i].contains (x2, y2)) |
| return component[i]; |
| } |
| return this; |
| } |
| |
| /** @deprecated Use getComponentAt() instead */ |
| public Component locate(int x, int y) |
| { |
| return getComponentAt(x, y); |
| } |
| |
| public Component getComponentAt(Point p) |
| { |
| return getComponentAt(p.x, p.y); |
| } |
| |
| public Component findComponentAt (int x, int y) |
| { |
| if (! contains (x, y)) |
| return null; |
| |
| for (int i = 0; i < ncomponents; ++i) |
| { |
| // Ignore invisible children... |
| if (!component[i].isVisible()) |
| continue; |
| |
| int x2 = x - component[i].x; |
| int y2 = y - component[i].y; |
| // We don't do the contains() check right away because |
| // findComponentAt would redundantly do it first thing. |
| if (component[i] instanceof Container) |
| { |
| Container k = (Container) component[i]; |
| Component r = k.findComponentAt (x2, y2); |
| if (r != null) |
| return r; |
| } |
| else if (component[i].contains (x2, y2)) |
| return component[i]; |
| } |
| |
| return this; |
| } |
| |
| public Component findComponentAt(Point p) |
| { |
| return findComponentAt(p.x, p.y); |
| } |
| |
| public void addNotify () |
| { |
| super.addNotify(); |
| } |
| |
| void addNotifyContainerChildren() |
| { |
| for (int i = ncomponents; --i >= 0; ) |
| { |
| component[i].addNotify(); |
| if (component[i].isLightweight()) |
| enableEvents(component[i].eventMask); |
| } |
| } |
| |
| public void removeNotify() |
| { |
| for (int i = 0; i < ncomponents; ++i) |
| component[i].removeNotify (); |
| super.removeNotify(); |
| } |
| |
| public boolean isAncestorOf (Component comp) |
| { |
| for (;;) |
| { |
| if (comp == null) |
| return false; |
| if (comp == this) |
| return true; |
| comp = comp.getParent(); |
| } |
| } |
| |
| protected String paramString() |
| { |
| String param = super.paramString(); |
| if (layoutMgr != null) |
| param = param + "," + layoutMgr.getClass().getName(); |
| |
| return param; |
| } |
| |
| public void list (PrintStream out, int indent) |
| { |
| super.list (out, indent); |
| for (int i = 0; i < ncomponents; ++i) |
| component[i].list (out, indent + 2); |
| } |
| |
| public void list(PrintWriter out, int indent) |
| { |
| super.list (out, indent); |
| for (int i = 0; i < ncomponents; ++i) |
| component[i].list (out, indent + 2); |
| } |
| |
| |
| /* The following classes are used in concert with the |
| visitChildren() method to implement all the graphics operations |
| that requires traversal of the containment hierarchy. */ |
| |
| abstract static class GfxVisitor |
| { |
| public abstract void visit(Component c, Graphics gfx); |
| } |
| |
| static class GfxPaintVisitor extends GfxVisitor |
| { |
| public void visit(Component c, Graphics gfx) { c.paint(gfx); } |
| public static final GfxVisitor INSTANCE = new GfxPaintVisitor(); |
| } |
| |
| static class GfxPrintVisitor extends GfxVisitor |
| { |
| public void visit(Component c, Graphics gfx) { c.print(gfx); } |
| public static final GfxVisitor INSTANCE = new GfxPrintVisitor(); |
| } |
| |
| static class GfxPaintAllVisitor extends GfxVisitor |
| { |
| public void visit(Component c, Graphics gfx) { c.paintAll(gfx); } |
| public static final GfxVisitor INSTANCE = new GfxPaintAllVisitor(); |
| } |
| |
| static class GfxPrintAllVisitor extends GfxVisitor |
| { |
| public void visit(Component c, Graphics gfx) { c.printAll(gfx); } |
| public static final GfxVisitor INSTANCE = new GfxPrintAllVisitor(); |
| } |
| |
| // This is used to implement Component.transferFocus. |
| Component findNextFocusComponent (Component child) |
| { |
| int start, end; |
| if (child != null) |
| { |
| for (start = 0; start < ncomponents; ++start) |
| { |
| if (component[start] == child) |
| break; |
| } |
| end = start; |
| // This special case lets us be sure to terminate. |
| if (end == 0) |
| end = ncomponents; |
| ++start; |
| } |
| else |
| { |
| start = 0; |
| end = ncomponents; |
| } |
| |
| for (int j = start; j != end; ++j) |
| { |
| if (j >= ncomponents) |
| { |
| // The JCL says that we should wrap here. However, that |
| // seems wrong. To me it seems that focus order should be |
| // global within in given window. So instead if we reach |
| // the end we try to look in our parent, if we have one. |
| if (parent != null) |
| return parent.findNextFocusComponent (this); |
| j -= ncomponents; |
| } |
| if (component[j] instanceof Container) |
| { |
| Component c = component[j]; |
| c = c.findNextFocusComponent (null); |
| if (c != null) |
| return c; |
| } |
| else if (component[j].isFocusTraversable ()) |
| return component[j]; |
| } |
| |
| return null; |
| } |
| } |