--- /dev/null
+// CardLayout.java - Card-based layout engine
+
+/* Copyright (C) 2000 Free Software Foundation
+
+ This file is part of libgcj.
+
+This software is copyrighted work licensed under the terms of the
+Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
+details. */
+
+package java.awt;
+
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.io.Serializable;
+
+/** This class implements a card-based layout scheme. Each included
+ * component is treated as a card. Only one card can be shown at a
+ * time. This class includes methods for changing which card is
+ * shown.
+ *
+ * @verson 0.0
+ * @author Tom Tromey <tromey@redhat.com>
+ * @date December 2, 2000
+ */
+public class CardLayout implements LayoutManager2, Serializable
+{
+ /** Create a new CardLayout object with both gaps zero. */
+ public CardLayout ()
+ {
+ this (0, 0);
+ }
+
+ /** Create a new CardLayout object with the specified horizontal and
+ * vertical gaps.
+ * @param hgap The horizontal gap
+ * @param vgap The vertical gap
+ */
+ public CardLayout (int hgap, int vgap)
+ {
+ this.hgap = hgap;
+ this.vgap = vgap;
+ this.map = new Hashtable ();
+ }
+
+ /** Add a new component to the layout. The constraint must be a
+ * string which is used to name the component. This string can
+ * later be used to refer to the particular component.
+ * @param comp The component to add
+ * @param constraints The name by which the component can later be called
+ * @exception IllegalArgumentException If `constraints' is not a string
+ */
+ public void addLayoutComponent (Component comp, Object constraints)
+ {
+ if (! (constraints instanceof String))
+ throw new IllegalArgumentException ("Object " + constraints
+ + " is not a string");
+ map.put (constraints, comp);
+ }
+
+ /** Add a new component to the layout. The name can be used later
+ * to refer to the component.
+ * @param name The name by which the component can later be called
+ * @param comp The component to add
+ * @deprecated
+ */
+ public void addLayoutComponent (String name, Component comp)
+ {
+ addLayoutComponent (comp, name);
+ }
+
+ /** Cause the first component in the container to be displayed.
+ * @param parent The parent container
+ */
+ public void first (Container parent)
+ {
+ gotoComponent (parent, FIRST, null);
+ }
+
+ /** Return this layout manager's horizontal gap. */
+ public int getHgap ()
+ {
+ return hgap;
+ }
+
+ /** Return this layout manager's x alignment. This method always
+ * returns Component.CENTER_ALIGNMENT.
+ * @param parent Container using this layout manager instance
+ */
+ public float getLayoutAlignmentX (Container parent)
+ {
+ return Component.CENTER_ALIGNMENT;
+ }
+
+ /** Returns this layout manager's y alignment. This method always
+ * returns Component.CENTER_ALIGNMENT.
+ * @param parent Container using this layout manager instance
+ */
+ public float getLayoutAlignmentY (Container parent)
+ {
+ return Component.CENTER_ALIGNMENT;
+ }
+
+ /** Return this layout manager's vertical gap. */
+ public int getVgap ()
+ {
+ return vgap;
+ }
+
+ /** Invalidate this layout manager's state. */
+ public void invalidateLayout (Container target)
+ {
+ // Do nothing.
+ }
+
+ /** Cause the last component in the container to be displayed.
+ * @param parent The parent container
+ */
+ public void last (Container parent)
+ {
+ gotoComponent (parent, LAST, null);
+ }
+
+ /** Lay out the container's components based on the current
+ * settings.
+ * @param parent The parent container
+ */
+ public void layoutContainer (Container parent)
+ {
+ // FIXME: can we just use the width and height fields of parent?
+ // Or will that break with subclassing?
+ Dimension d = parent.getSize ();
+
+ Insets ins = parent.getInsets ();
+
+ int num = parent.getComponentCount ();
+ // This is more efficient than calling getComponents().
+ Component[] comps = parent.component;
+
+ for (int i = 0; i < num; ++i)
+ {
+ if (comps[i].isVisible ())
+ {
+ // Only resize the one we care about.
+ comps[i].setBounds (hgap + ins.left, vgap + ins.top,
+ d.width - 2 * hgap - ins.left - ins.right,
+ d.height - 2 * vgap - ins.top - ins.bottom);
+ break;
+ }
+ }
+ }
+
+ /** Get the maximum layout size of the container.
+ * @param target The parent container
+ */
+ public Dimension maximumLayoutSize (Container target)
+ {
+ // The JCL says that this returns Integer.MAX_VALUE for both
+ // dimensions. But that just seems wrong to me.
+ return getSize (target, MAX);
+ }
+
+ /** Get the minimum layout size of the container.
+ * @param target The parent container
+ */
+ public Dimension minimumLayoutSize (Container target)
+ {
+ return getSize (target, MIN);
+ }
+
+ /** Cause the next component in the container to be displayed.
+ * @param parent The parent container
+ */
+ public void next (Container parent)
+ {
+ gotoComponent (parent, NEXT, null);
+ }
+
+ /** Get the preferred layout size of the container.
+ * @param target The parent container
+ */
+ public Dimension preferredLayoutSize (Container parent)
+ {
+ return getSize (parent, PREF);
+ }
+
+ /** Cause the previous component in the container to be displayed.
+ * @param parent The parent container
+ */
+ public void previous (Container parent)
+ {
+ gotoComponent (parent, PREV, null);
+ }
+
+ /** Remove the indicated component from this layout manager.
+ * @param comp The component to remove
+ */
+ public void removeLayoutComponent (Component comp)
+ {
+ Enumeration e = map.keys ();
+ while (e.hasMoreElements ())
+ {
+ Object key = e.nextElement ();
+ if (map.get (key) == comp)
+ {
+ map.remove (key);
+ break;
+ }
+ }
+ }
+
+ /** Set this layout manager's horizontal gap.
+ * @param hgap The new gap
+ */
+ public void setHgap (int hgap)
+ {
+ this.hgap = hgap;
+ }
+
+ /** Set this layout manager's vertical gap.
+ * @param vgap The new gap
+ */
+ public void setVgap (int vgap)
+ {
+ this.vgap = vgap;
+ }
+
+ /** Cause the named component to be shown. If the component name is
+ * unknown, this method does nothing.
+ * @param parent The parent container
+ * @param name The name of the component to show
+ */
+ public void show (Container parent, String name)
+ {
+ Object target = map.get (name);
+ if (target != null)
+ gotoComponent (parent, NONE, (Component) target);
+ }
+
+ public String toString ()
+ {
+ return getClass ().getName () + "[" + hgap + "," + vgap + "]";
+ }
+
+ // This implements first(), last(), next(), and previous().
+ private void gotoComponent (Container parent, int what,
+ Component target)
+ {
+ int num = parent.getComponentCount ();
+ // This is more efficient than calling getComponents().
+ Component[] comps = parent.component;
+ int choice = -1;
+
+ if (what == FIRST)
+ choice = 0;
+ else if (what == LAST)
+ choice = num;
+ else if (what >= 0)
+ choice = what;
+
+ for (int i = 0; i < num; ++i)
+ {
+ // If TARGET is set then we are looking for a specific
+ // component.
+ if (target != null)
+ {
+ if (target == comps[i])
+ choice = i;
+ }
+
+ if (comps[i].isVisible ())
+ {
+ if (what == NEXT)
+ {
+ choice = i + 1;
+ if (choice == num)
+ choice = num - 1;
+ }
+ else if (what == PREV)
+ {
+ choice = i - 1;
+ if (choice < 0)
+ choice = 0;
+ }
+ else
+ {
+ // Do nothing if we're already looking at the right
+ // component.
+ if (choice == i)
+ return;
+ }
+ comps[i].setVisible (false);
+
+ if (choice >= 0)
+ break;
+ }
+ }
+
+ comps[choice].setVisible (true);
+ }
+
+ // Compute the size according to WHAT.
+ private Dimension getSize (Container parent, int what)
+ {
+ int w = 0, h = 0, num = parent.getComponentCount ();
+ // This is more efficient than calling getComponents().
+ Component[] comps = parent.component;
+
+ for (int i = 0; i < num; ++i)
+ {
+ // FIXME: can we just directly read the fields in Component?
+ // Or will that not work with subclassing?
+ Dimension d;
+
+ if (what == MIN)
+ d = comps[i].getMinimumSize ();
+ else if (what == MAX)
+ d = comps[i].getMaximumSize ();
+ else
+ d = comps[i].getPreferredSize ();
+
+ w = Math.max (d.width, w);
+ h = Math.max (d.height, h);
+ }
+
+ Insets i = parent.getInsets ();
+ w += 2 * hgap + i.right + i.left;
+ h += 2 * vgap + i.bottom + i.top;
+
+ // Handle overflow.
+ if (w < 0)
+ w = Integer.MAX_VALUE;
+ if (h < 0)
+ h = Integer.MAX_VALUE;
+
+ return new Dimension (w, h);
+ }
+
+ // The gaps.
+ private int hgap;
+ private int vgap;
+
+ // This hashtable maps a name to a component.
+ private Hashtable map;
+
+ // These constants are used by the private gotoComponent method.
+ private int FIRST = 0;
+ private int LAST = 1;
+ private int NEXT = 2;
+ private int PREV = 3;
+ private int NONE = 4;
+
+ // These constants are used by the private getSize method.
+ private int MIN = 0;
+ private int MAX = 1;
+ private int PREF = 2;
+}
projects / gcc.git / commitdiff