home *** CD-ROM | disk | FTP | other *** search
/ Chip 1998 November / Chip_1998-11_cd.bin / tema / Cafe / jfc.bin / Box.java < prev    next >
Text File  |  1998-02-26  |  36KB  |  1,084 lines
  1. /*
  2.  * @(#)Box.java    1.24 98/02/02
  3.  *
  4.  * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * This software is the confidential and proprietary information of Sun
  7.  * Microsystems, Inc. ("Confidential Information").  You shall not
  8.  * disclose such Confidential Information and shall use it only in
  9.  * accordance with the terms of the license agreement you entered into
  10.  * with Sun.
  11.  *
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  13.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  14.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  15.  * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
  16.  * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
  17.  * THIS SOFTWARE OR ITS DERIVATIVES.
  18.  *
  19.  */
  20.  
  21.  
  22. package com.sun.java.swing;
  23.  
  24. import java.awt.*;
  25. import java.awt.event.*;
  26. import java.beans.PropertyChangeListener;
  27. import java.util.Locale;
  28. import java.io.Serializable;
  29. import com.sun.java.accessibility.*;
  30.  
  31. /**
  32.  * A lightweight container 
  33.  * that uses a BoxLayout object as its layout manager.
  34.  * Box provides several class methods
  35.  * that are useful for containers using BoxLayout --
  36.  * even non-Box containers.
  37.  *
  38.  * <p>
  39.  *
  40.  * The Box class can create several kinds
  41.  * of invisible components 
  42.  * that affect layout:
  43.  * glue, struts, and rigid areas.
  44.  * If all the components your Box contains 
  45.  * have a fixed size,
  46.  * you might want to use a glue component
  47.  * (returned by <code>createGlue</code>)
  48.  * to control the components' positions.
  49.  * If you need a fixed amount of space between two components,
  50.  * try using a strut
  51.  * (<code>createHorizontalStrut</code> or <code>createVerticalStrut</code>).
  52.  * If you need an invisible component
  53.  * that always takes up the same amount of space,
  54.  * get it by invoking <code>createRigidArea</code>.
  55.  * <p>
  56.  * Warning: serialized objects of this class will not be compatible with
  57.  * future swing releases.  The current serialization support is appropriate 
  58.  * for short term storage or RMI between Swing1.0 applications.  It will
  59.  * not be possible to load serialized Swing1.0 objects with future releases
  60.  * of Swing.  The JDK1.2 release of Swing will be the compatibility
  61.  * baseline for the serialized form of Swing objects.
  62.  *
  63.  * @see BoxLayout
  64.  *
  65.  * @author  Timothy Prinzing
  66.  * @version 1.24 02/02/98
  67.  */
  68. public class Box extends Container implements Accessible {
  69.  
  70.     /**
  71.      * Creates a <code>Box</code> that displays its components
  72.      * along the the specified axis.
  73.      *
  74.      * @param axis  can be either <code>BoxLayout.X_AXIS</code>
  75.      *              (to display components from left to right) or
  76.      *              <code>BoxLayout.Y_AXIS</code>
  77.      *              (to display them from top to bottom)
  78.      * @see #createHorizontalBox
  79.      * @see #createVerticalBox
  80.      */
  81.     public Box(int axis) {
  82.     super();
  83.     setName(base + nameCounter++);
  84.     super.setLayout(new BoxLayout(this, axis));
  85.     }
  86.  
  87.     /**
  88.      * Creates a <code>Box</code> that displays its components
  89.      * from left to right.
  90.      */
  91.     public static Box createHorizontalBox() {
  92.     return new Box(BoxLayout.X_AXIS);
  93.     }
  94.  
  95.     /**
  96.      * Creates a <code>Box</code> that displays its components
  97.      * from top to bottom.
  98.      */
  99.     public static Box createVerticalBox() {
  100.     return new Box(BoxLayout.Y_AXIS);
  101.     }
  102.  
  103.     /**
  104.      * Creates an invisible component that's always the specified size.
  105.      * <!-- WHEN WOULD YOU USE THIS AS OPPOSED TO A STRUT? -->
  106.      *
  107.      * @param d the dimensions of the invisible component
  108.      *
  109.      * @see #createGlue
  110.      * @see #createHorizontalStrut
  111.      * @see #createVerticalStrut
  112.      */
  113.     public static Component createRigidArea(Dimension d) {
  114.     return new Filler(d, d, d);
  115.     }
  116.  
  117.     /**
  118.      * Creates an invisible, fixed-width component.
  119.      * In a horizontal box, 
  120.      * you typically use this method 
  121.      * to force a certain amount of space between two components.
  122.      * In a vertical box,
  123.      * you might use this method 
  124.      * to force the box to be at least the specified width.
  125.      * The invisible component has no height
  126.      * unless excess space is available,
  127.      * in which case it takes its share of available space,
  128.      * just like any other component that has no maximum height.
  129.      *
  130.      * @param width the width of the invisible component, in pixels
  131.      *
  132.      * @see #createVerticalStrut
  133.      * @see #createGlue
  134.      * @see #createRigidArea
  135.      */
  136.     public static Component createHorizontalStrut(int width) {
  137.     // PENDING(jeff) change to Integer.MAX_VALUE. This hasn't been done
  138.     // to date because BoxLayout alignment breaks.
  139.     return new Filler(new Dimension(width,0), new Dimension(width,0), 
  140.               new Dimension(width, Short.MAX_VALUE));
  141.     }
  142.  
  143.     /**
  144.      * Creates an invisible, fixed-height component.
  145.      * In a vertical box, 
  146.      * you typically use this method
  147.      * to force a certain amount of space between two components.
  148.      * In a horizontal box,
  149.      * you might use this method 
  150.      * to force the box to be at least the specified height.
  151.      * The invisible component has no width
  152.      * unless excess space is available,
  153.      * in which case it takes its share of available space,
  154.      * just like any other component that has no maximum width.
  155.      *
  156.      * @param height the height of the invisible component, in pixels
  157.      *
  158.      * @see #createHorizontalStrut
  159.      * @see #createGlue
  160.      * @see #createRigidArea
  161.      */
  162.     public static Component createVerticalStrut(int height) {
  163.     // PENDING(jeff) change to Integer.MAX_VALUE. This hasn't been done
  164.     // to date because BoxLayout alignment breaks.
  165.     return new Filler(new Dimension(0,height), new Dimension(0,height), 
  166.               new Dimension(Short.MAX_VALUE, height));
  167.     }
  168.  
  169.     /**
  170.      * Creates an invisible "glue" component 
  171.      * that can be useful in a Box
  172.      * whose visible components have a maximum width
  173.      * (for a horizontal box)
  174.      * or height (for a vertical box).
  175.      * You can think of the glue component
  176.      * as being a gooey substance
  177.      * that expands as much as necessary
  178.      * to fill the space between its neighboring components.
  179.      *
  180.      * <p>
  181.      *
  182.      * For example, suppose you have
  183.      * a horizontal box that contains two fixed-size components.
  184.      * If the box gets extra space,
  185.      * the fixed-size components won't become larger,
  186.      * so where does the extra space go?
  187.      * Without glue,
  188.      * the extra space goes to the right of the second component.
  189.      * If you put glue between the fixed-size components,
  190.      * then the extra space goes there.
  191.      * If you put glue before the first fixed-size component,
  192.      * the extra space goes there,
  193.      * and the fixed-size components are shoved against the right
  194.      * edge of the box.
  195.      * If you put glue before the first fixed-size component
  196.      * and after the second fixed-size component,
  197.      * the fixed-size components are centered in the box.
  198.      *
  199.      * <p>
  200.      *
  201.      * To use glue,
  202.      * call <code>Box.createGlue</code>
  203.      * and add the returned component to a container.
  204.      * The glue component has no minimum or preferred size,
  205.      * so it takes no space unless excess space is available.
  206.      * If excess space is available, 
  207.      * then the glue component takes its share of available
  208.      * horizontal or vertical space,
  209.      * just like any other component that has no maximum width or height.
  210.      */
  211.     public static Component createGlue() {
  212.     // PENDING(jeff) change to Integer.MAX_VALUE. This hasn't been done
  213.     // to date because BoxLayout alignment breaks.
  214.     return new Filler(new Dimension(0,0), new Dimension(0,0), 
  215.               new Dimension(Short.MAX_VALUE, Short.MAX_VALUE));
  216.     }
  217.  
  218.     public static Component createHorizontalGlue() {
  219.     // PENDING(jeff) change to Integer.MAX_VALUE. This hasn't been done
  220.     // to date because BoxLayout alignment breaks.
  221.     return new Filler(new Dimension(0,0), new Dimension(0,0), 
  222.               new Dimension(Short.MAX_VALUE, 0));
  223.     }
  224.  
  225.     public static Component createVerticalGlue() {
  226.     // PENDING(jeff) change to Integer.MAX_VALUE. This hasn't been done
  227.     // to date because BoxLayout alignment breaks.
  228.     return new Filler(new Dimension(0,0), new Dimension(0,0), 
  229.               new Dimension(0, Short.MAX_VALUE));
  230.     }
  231.  
  232.     /**
  233.      * Throws an AWTError, since a Box can use only a BoxLayout.
  234.      */
  235.     public void setLayout(LayoutManager l) {
  236.     throw new AWTError("Illegal request");
  237.     }
  238.  
  239.     private static final String base = "box";
  240.     private static int nameCounter = 0;
  241.  
  242.  
  243.     /**
  244.      * An implementation of a lightweight component that participates in
  245.      * layout but has no view.
  246.      * <p>
  247.      * Warning: serialized objects of this class will not be compatible with
  248.      * future swing releases.  The current serialization support is appropriate
  249.      * for short term storage or RMI between Swing1.0 applications.  It will
  250.      * not be possible to load serialized Swing1.0 objects with future releases
  251.      * of Swing.  The JDK1.2 release of Swing will be the compatibility
  252.      * baseline for the serialized form of Swing objects.
  253.      */
  254.     public static class Filler extends Component {
  255.  
  256.     /**
  257.      * Constructor to create shape with the given size ranges.
  258.      *
  259.      * @param min   Minimum size
  260.      * @param pref  Preferred size
  261.      * @param max   Maximum size
  262.      */
  263.         public Filler(Dimension min, Dimension pref, Dimension max) {
  264.         reqMin = min;
  265.         reqPref = pref;
  266.         reqMax = max;
  267.     }
  268.  
  269.     /**
  270.      * Change the size requests for this shape.  An invalidate() is
  271.      * propagated upward as a result so that layout will eventually
  272.      * happen with using the new sizes.
  273.      *
  274.      * @param min   Value to return for getMinimumSize
  275.      * @param pref  Value to return for getPreferredSize
  276.      * @param max   Value to return for getMaximumSize
  277.      */
  278.         public void changeShape(Dimension min, Dimension pref, Dimension max) {
  279.         reqMin = min;
  280.         reqPref = pref;
  281.         reqMax = max;
  282.         invalidate();
  283.     }
  284.  
  285.     // ---- Component methods ------------------------------------------
  286.  
  287.         public Dimension getMinimumSize() {
  288.         return reqMin;
  289.     }
  290.  
  291.         public Dimension getPreferredSize() {
  292.         return reqPref;
  293.     }
  294.  
  295.         public Dimension getMaximumSize() {
  296.         return reqMax;
  297.     }
  298.  
  299.     // ---- member variables ---------------------------------------
  300.  
  301.         private Dimension reqMin;
  302.         private Dimension reqPref;
  303.         private Dimension reqMax;
  304.  
  305. /////////////////
  306. // Accessibility support for Box$Filler
  307. ////////////////
  308.  
  309.         protected AccessibleContext accessibleContext = null;
  310.  
  311.         /**
  312.          * Get the AccessibleContext associated with this Component
  313.          *
  314.          * @return the AccessibleContext of this Component
  315.          */
  316.         public AccessibleContext getAccessibleContext() {
  317.         if (accessibleContext == null) {
  318.         accessibleContext = new AccessibleBoxFiller();
  319.         }
  320.         return accessibleContext;
  321.         }
  322.  
  323.     protected class AccessibleBoxFiller extends AccessibleContext
  324.         implements Serializable, AccessibleComponent {
  325.  
  326.             // AccessibleContext methods
  327.             //
  328.             /**
  329.              * Get the role of this object.
  330.              *
  331.              * @return an instance of AccessibleRole describing the role of
  332.              * the object
  333.              * @see AccessibleRole
  334.              */
  335.             public AccessibleRole getAccessibleRole() {
  336.                 return AccessibleRole.FILLER;
  337.             }
  338.  
  339.             /**
  340.              * Get the state of this object.
  341.              *
  342.              * @return an instance of AccessibleStateSet containing the current 
  343.              * state set of the object
  344.              * @see AccessibleState
  345.              */
  346.             public AccessibleStateSet getAccessibleStateSet() {
  347.                 return SwingUtilities.getAccessibleStateSet(Filler.this);
  348.             }
  349.     
  350.             /**
  351.              * Get the Accessible parent of this object.  If the parent of this
  352.              * object implements Accessible, this method should simply return
  353.              * getParent().
  354.              *
  355.              * @return the Accessible parent of this object -- can be null if this
  356.              * object does not have an Accessible parent
  357.              */
  358.             public Accessible getAccessibleParent() {
  359.                 Container parent = getParent();
  360.                 if (parent instanceof Accessible) {
  361.                     return (Accessible) parent;
  362.                 } else {
  363.                     return null;
  364.                 }
  365.             }
  366.     
  367.             /**
  368.              * Get the index of this object in its accessible parent. 
  369.              *
  370.              * @return the index of this object in its parent; -1 if this 
  371.              * object does not have an accessible parent.
  372.              * @see #getAccessibleParent
  373.              */
  374.             public int getAccessibleIndexInParent() {
  375.                 return SwingUtilities.getAccessibleIndexInParent(Filler.this);
  376.             }
  377.     
  378.             /**
  379.              * Returns the number of accessible children in the object.  If all
  380.              * of the children of this object implement Accessible, than this
  381.              * method should return the number of children of this object.
  382.              *
  383.              * @return the number of accessible children in the object.
  384.              */
  385.             public int getAccessibleChildrenCount() {
  386.                 return SwingUtilities.getAccessibleChildrenCount(Filler.this);
  387.             }
  388.     
  389.             /**
  390.              * Return the nth Accessible child of the object.  
  391.              *
  392.              * @param i zero-based index of child
  393.              * @return the nth Accessible child of the object
  394.              */
  395.             public Accessible getAccessibleChild(int i) {
  396.                 return SwingUtilities.getAccessibleChild(Filler.this,i);
  397.             }
  398.         
  399.             /**
  400.              * Return the locale of this object.
  401.              *
  402.              * @return the locale of this object
  403.              */
  404.             public Locale getLocale() {
  405.                 return Filler.this.getLocale();
  406.             }
  407.     
  408.             /**
  409.              * Get the AccessibleComponent associated with this object if one
  410.              * exists.  Otherwise return null.
  411.              */
  412.         public AccessibleComponent getAccessibleComponent() {
  413.         return this;
  414.         }
  415.     
  416.     
  417.             // AccessibleComponent methods
  418.             //
  419.             /**
  420.              * Get the background color of this object.
  421.              *
  422.              * @return the background color, if supported, of the object; 
  423.              * otherwise, null
  424.              */
  425.             public Color getBackground() {
  426.                 return Filler.this.getBackground();
  427.             }
  428.     
  429.             /**
  430.              * Set the background color of this object.
  431.              *
  432.              * @param c the new Color for the background
  433.              */
  434.             public void setBackground(Color c) {
  435.                 Filler.this.setBackground(c);
  436.             }
  437.     
  438.             /**
  439.              * Get the foreground color of this object.
  440.              *
  441.              * @return the foreground color, if supported, of the object; 
  442.              * otherwise, null
  443.              */
  444.             public Color getForeground() {
  445.                 return Filler.this.getForeground();
  446.             }
  447.     
  448.             /**
  449.              * Set the foreground color of this object.
  450.              *
  451.              * @param c the new Color for the foreground
  452.              */
  453.             public void setForeground(Color c) {
  454.                 Filler.this.setForeground(c);
  455.             }
  456.     
  457.             /**
  458.              * Get the Cursor of this object.
  459.              *
  460.              * @return the Cursor, if supported, of the object; otherwise, null
  461.              */
  462.             public Cursor getCursor() {
  463.                 return Filler.this.getCursor();
  464.             }
  465.     
  466.             /**
  467.              * Set the Cursor of this object.
  468.              *
  469.              * @param c the new Cursor for the object
  470.              */
  471.             public void setCursor(Cursor cursor) {
  472.                 Filler.this.setCursor(cursor);
  473.             }
  474.     
  475.             /**
  476.              * Get the Font of this object.
  477.              *
  478.              * @return the Font,if supported, for the object; otherwise, null
  479.              */
  480.             public Font getFont() {
  481.                 return Filler.this.getFont();
  482.             }
  483.     
  484.             /**
  485.              * Set the Font of this object.
  486.              *
  487.              * @param f the new Font for the object
  488.              */
  489.             public void setFont(Font f) {
  490.                 Filler.this.setFont(f);
  491.             }
  492.     
  493.             /**
  494.              * Get the FontMetrics of this object.
  495.              *
  496.              * @param f the Font
  497.              * @return the FontMetrics, if supported, the object; otherwise, null
  498.              * @see getFont
  499.              */
  500.             public FontMetrics getFontMetrics(Font f) {
  501.                 return Filler.this.getFontMetrics(f);
  502.             }
  503.     
  504.             /**
  505.              * Determine if the object is enabled.
  506.              *
  507.              * @return true if object is enabled; otherwise, false
  508.              */
  509.             public boolean isEnabled() {
  510.                 return Filler.this.isEnabled();
  511.             }
  512.     
  513.             /**
  514.              * Set the enabled state of the object.
  515.              *
  516.              * @param b if true, enables this object; otherwise, disables it 
  517.              */
  518.             public void setEnabled(boolean b) {
  519.                 Filler.this.setEnabled(b);
  520.             }
  521.             
  522.             /**
  523.              * Determine if the object is visible.  Note: this means that the
  524.              * object intends to be visible; however, it may not in fact be
  525.              * showing on the screen because one of the objects that this object
  526.              * is contained by is not visible.  To determine if an object is
  527.              * showing on the screen, use isShowing().
  528.              *
  529.              * @return true if object is visible; otherwise, false
  530.              */
  531.             public boolean isVisible() {
  532.                 return Filler.this.isVisible();
  533.             }
  534.     
  535.             /**
  536.              * Set the visible state of the object.
  537.              *
  538.              * @param b if true, shows this object; otherwise, hides it 
  539.              */
  540.             public void setVisible(boolean b) {
  541.                 Filler.this.setVisible(b);
  542.             }
  543.     
  544.             /**
  545.              * Determine if the object is showing.  This is determined by checking
  546.              * the visibility of the object and ancestors of the object.  Note: 
  547.              * this will return true even if the object is obscured by another 
  548.              * (for example, it happens to be underneath a menu that was pulled 
  549.              * down).
  550.              *
  551.              * @return true if object is showing; otherwise, false
  552.              */
  553.             public boolean isShowing() {
  554.                 return Filler.this.isShowing();
  555.             }
  556.     
  557.             /** 
  558.              * Checks whether the specified point is within this object's bounds,
  559.              * where the point's x and y coordinates are defined to be relative to 
  560.              * the coordinate system of the object. 
  561.              *
  562.              * @param p the Point relative to the coordinate system of the object
  563.              * @return true if object contains Point; otherwise false
  564.              */
  565.             public boolean contains(Point p) {
  566.                 return Filler.this.contains(p);
  567.             }
  568.         
  569.             /** 
  570.              * Returns the location of the object on the screen.
  571.              *
  572.              * @return location of object on screen -- can be null if this object
  573.              * is not on the screen
  574.              */
  575.             public Point getLocationOnScreen() {
  576.                 return Filler.this.getLocationOnScreen();
  577.             }
  578.     
  579.             /** 
  580.              * Gets the location of the object relative to the parent in the form 
  581.              * of a point specifying the object's top-left corner in the screen's 
  582.              * coordinate space.
  583.              *
  584.              * @return An instance of Point representing the top-left corner of 
  585.              * the objects's bounds in the coordinate space of the screen; null if
  586.              * this object or its parent are not on the screen
  587.              */
  588.             public Point getLocation() {
  589.                 return Filler.this.getLocation();
  590.             }
  591.     
  592.             /** 
  593.              * Sets the location of the object relative to the parent.
  594.              */
  595.             public void setLocation(Point p) {
  596.                 Filler.this.setLocation(p);
  597.             }
  598.     
  599.             /** 
  600.              * Gets the bounds of this object in the form of a Rectangle object. 
  601.              * The bounds specify this object's width, height, and location
  602.              * relative to its parent. 
  603.              *
  604.              * @return A rectangle indicating this component's bounds; null if 
  605.              * this object is not on the screen.
  606.              */
  607.             public Rectangle getBounds() {
  608.                 return Filler.this.getBounds();
  609.             }
  610.     
  611.             /** 
  612.              * Sets the bounds of this object in the form of a Rectangle object. 
  613.              * The bounds specify this object's width, height, and location
  614.              * relative to its parent.
  615.              *      
  616.              * @param A rectangle indicating this component's bounds
  617.              */
  618.             public void setBounds(Rectangle r) {
  619.                 Filler.this.setBounds(r);
  620.             }
  621.     
  622.             /** 
  623.              * Returns the size of this object in the form of a Dimension object. 
  624.              * The height field of the Dimension object contains this objects's
  625.              * height, and the width field of the Dimension object contains this 
  626.              * object's width. 
  627.              *
  628.              * @return A Dimension object that indicates the size of this 
  629.              * component; null if this object is not on the screen
  630.              */
  631.             public Dimension getSize() {
  632.                 return Filler.this.getSize();
  633.             }
  634.     
  635.             /** 
  636.              * Resizes this object so that it has width width and height. 
  637.              *      
  638.              * @param d - The dimension specifying the new size of the object. 
  639.              */
  640.             public void setSize(Dimension d) {
  641.                 Filler.this.setSize(d);
  642.             }
  643.     
  644.             /**
  645.              * Returns the Accessible child, if one exists, contained at the local
  646.              * coordinate Point.
  647.              *
  648.              * @param p The point defining the top-left corner of the Accessible, 
  649.              * given in the coordinate space of the object's parent. 
  650.              * @return the Accessible, if it exists, at the specified location; 
  651.              * else null
  652.              */
  653.             public Accessible getAccessibleAt(Point p) {
  654.                 return SwingUtilities.getAccessibleAt(Filler.this,p);
  655.             }
  656.     
  657.             /**
  658.              * Returns whether this object can accept focus or not.
  659.              *
  660.              * @return true if object can accept focus; otherwise false
  661.              */
  662.             public boolean isFocusTraversable() {
  663.                 return Filler.this.isFocusTraversable();
  664.             }
  665.     
  666.             /**
  667.              * Requests focus for this object.
  668.              */
  669.             public void requestFocus() {
  670.                 Filler.this.requestFocus();
  671.             }
  672.     
  673.             /**
  674.              * Adds the specified focus listener to receive focus events from this 
  675.              * component. 
  676.              *
  677.              * @param l the focus listener
  678.              */
  679.             public void addFocusListener(FocusListener l) {
  680.                 Filler.this.addFocusListener(l);
  681.             }
  682.     
  683.             /**
  684.              * Removes the specified focus listener so it no longer receives focus 
  685.              * events from this component.
  686.              *
  687.              * @param l the focus listener
  688.              */
  689.             public void removeFocusListener(FocusListener l) {
  690.                 Filler.this.removeFocusListener(l);
  691.             }
  692.         }
  693.     }
  694.  
  695. /////////////////
  696. // Accessibility support for Box
  697. ////////////////
  698.  
  699.     protected AccessibleContext accessibleContext = null;
  700.  
  701.     /**
  702.      * Get the AccessibleContext associated with this JComponent
  703.      *
  704.      * @return the AccessibleContext of this JComponent
  705.      */
  706.     public AccessibleContext getAccessibleContext() {
  707.     if (accessibleContext == null) {
  708.         accessibleContext = new AccessibleBox();
  709.     }
  710.     return accessibleContext;
  711.     }
  712.  
  713.     protected class AccessibleBox extends AccessibleContext
  714.     implements Serializable, AccessibleComponent {
  715.  
  716.         // AccessibleContext methods
  717.         //
  718.         /**
  719.          * Get the role of this object.
  720.          *
  721.          * @return an instance of AccessibleRole describing the role of the 
  722.      * object
  723.          * @see AccessibleRole
  724.          */
  725.         public AccessibleRole getAccessibleRole() {
  726.             return AccessibleRole.FILLER;
  727.         }
  728.  
  729.         /**
  730.          * Get the state of this object.
  731.          *
  732.          * @return an instance of AccessibleStateSet containing the current 
  733.      * state set of the object
  734.          * @see AccessibleState
  735.          */
  736.         public AccessibleStateSet getAccessibleStateSet() {
  737.         return SwingUtilities.getAccessibleStateSet(Box.this);
  738.         }
  739.  
  740.         /**
  741.          * Get the Accessible parent of this object.  If the parent of this
  742.          * object implements Accessible, this method should simply return
  743.          * getParent().
  744.          *
  745.          * @return the Accessible parent of this object -- can be null if this
  746.          * object does not have an Accessible parent
  747.          */
  748.         public Accessible getAccessibleParent() {
  749.             Container parent = getParent();
  750.             if (parent instanceof Accessible) {
  751.                 return (Accessible) parent;
  752.             } else {
  753.                 return null;
  754.             }
  755.         }
  756.  
  757.         /**
  758.          * Get the index of this object in its accessible parent. 
  759.          *
  760.          * @return the index of this object in its parent; -1 if this 
  761.          * object does not have an accessible parent.
  762.          * @see #getAccessibleParent
  763.          */
  764.         public int getAccessibleIndexInParent() {
  765.         return SwingUtilities.getAccessibleIndexInParent(Box.this);
  766.         }
  767.  
  768.         /**
  769.          * Returns the number of accessible children in the object.  If all
  770.          * of the children of this object implement Accessible, than this
  771.          * method should return the number of children of this object.
  772.          *
  773.          * @return the number of accessible children in the object.
  774.          */
  775.         public int getAccessibleChildrenCount() {
  776.         return SwingUtilities.getAccessibleChildrenCount(Box.this);
  777.         }
  778.  
  779.         /**
  780.          * Return the nth Accessible child of the object.  
  781.          *
  782.          * @param i zero-based index of child
  783.          * @return the nth Accessible child of the object
  784.          */
  785.         public Accessible getAccessibleChild(int i) {
  786.             return SwingUtilities.getAccessibleChild(Box.this,i);
  787.         }
  788.  
  789.         /**
  790.          * Return the locale of this object.
  791.      *
  792.          * @return the locale of this object
  793.          */
  794.         public Locale getLocale() {
  795.             return Box.this.getLocale();
  796.         }
  797.  
  798.         /**
  799.          * Get the AccessibleComponent associated with this object if one
  800.          * exists.  Otherwise return null.
  801.          */
  802.     public AccessibleComponent getAccessibleComponent() {
  803.         return this;
  804.     }
  805.  
  806.  
  807.         // AccessibleComponent methods
  808.         //
  809.         /**
  810.          * Get the background color of this object.
  811.          *
  812.          * @return the background color, if supported, of the object; 
  813.          * otherwise, null
  814.          */
  815.         public Color getBackground() {
  816.         return Box.this.getBackground();
  817.     }
  818.  
  819.         /**
  820.          * Set the background color of this object.
  821.          *
  822.          * @param c the new Color for the background
  823.          */
  824.         public void setBackground(Color c) {
  825.         Box.this.setBackground(c);
  826.     }
  827.  
  828.         /**
  829.          * Get the foreground color of this object.
  830.          *
  831.          * @return the foreground color, if supported, of the object; 
  832.          * otherwise, null
  833.          */
  834.         public Color getForeground() {
  835.         return Box.this.getForeground();
  836.     }
  837.  
  838.         /**
  839.          * Set the foreground color of this object.
  840.          *
  841.          * @param c the new Color for the foreground
  842.          */
  843.         public void setForeground(Color c) {
  844.         Box.this.setForeground(c);
  845.     }
  846.  
  847.         /**
  848.          * Get the Cursor of this object.
  849.          *
  850.          * @return the Cursor, if supported, of the object; otherwise, null
  851.          */
  852.         public Cursor getCursor() {
  853.         return Box.this.getCursor();
  854.     }
  855.  
  856.         /**
  857.          * Set the Cursor of this object.
  858.          *
  859.          * @param c the new Cursor for the object
  860.          */
  861.         public void setCursor(Cursor cursor) {
  862.         Box.this.setCursor(cursor);
  863.     }
  864.  
  865.         /**
  866.          * Get the Font of this object.
  867.          *
  868.          * @return the Font,if supported, for the object; otherwise, null
  869.          */
  870.         public Font getFont() {
  871.         return Box.this.getFont();
  872.     }
  873.  
  874.         /**
  875.          * Set the Font of this object.
  876.          *
  877.          * @param f the new Font for the object
  878.          */
  879.         public void setFont(Font f) {
  880.         Box.this.setFont(f);
  881.     }
  882.  
  883.         /**
  884.          * Get the FontMetrics of this object.
  885.          *
  886.          * @param f the Font
  887.          * @return the FontMetrics, if supported, the object; otherwise, null
  888.          * @see getFont
  889.          */
  890.         public FontMetrics getFontMetrics(Font f) {
  891.         return Box.this.getFontMetrics(f);
  892.     }
  893.  
  894.         /**
  895.          * Determine if the object is enabled.
  896.          *
  897.          * @return true if object is enabled; otherwise, false
  898.          */
  899.         public boolean isEnabled() {
  900.         return Box.this.isEnabled();
  901.     }
  902.  
  903.         /**
  904.          * Set the enabled state of the object.
  905.          *
  906.          * @param b if true, enables this object; otherwise, disables it 
  907.          */
  908.         public void setEnabled(boolean b) {
  909.         Box.this.setEnabled(b);
  910.     }
  911.     
  912.         /**
  913.          * Determine if the object is visible.  Note: this means that the
  914.          * object intends to be visible; however, it may not in fact be
  915.          * showing on the screen because one of the objects that this object
  916.          * is contained by is not visible.  To determine if an object is
  917.          * showing on the screen, use isShowing().
  918.          *
  919.          * @return true if object is visible; otherwise, false
  920.          */
  921.         public boolean isVisible() {
  922.         return Box.this.isVisible();
  923.     }
  924.  
  925.         /**
  926.          * Set the visible state of the object.
  927.          *
  928.          * @param b if true, shows this object; otherwise, hides it 
  929.          */
  930.         public void setVisible(boolean b) {
  931.         Box.this.setVisible(b);
  932.     }
  933.  
  934.         /**
  935.          * Determine if the object is showing.  This is determined by checking
  936.          * the visibility of the object and ancestors of the object.  Note: 
  937.      * this will return true even if the object is obscured by another 
  938.      * (for example, it happens to be underneath a menu that was pulled 
  939.      * down).
  940.          *
  941.          * @return true if object is showing; otherwise, false
  942.          */
  943.         public boolean isShowing() {
  944.         return Box.this.isShowing();
  945.     }
  946.  
  947.         /** 
  948.          * Checks whether the specified point is within this object's bounds,
  949.          * where the point's x and y coordinates are defined to be relative to 
  950.      * the coordinate system of the object. 
  951.          *
  952.          * @param p the Point relative to the coordinate system of the object
  953.          * @return true if object contains Point; otherwise false
  954.          */
  955.         public boolean contains(Point p) {
  956.         return Box.this.contains(p);
  957.     }
  958.     
  959.         /** 
  960.          * Returns the location of the object on the screen.
  961.          *
  962.          * @return location of object on screen -- can be null if this object
  963.          * is not on the screen
  964.          */
  965.         public Point getLocationOnScreen() {
  966.         return Box.this.getLocationOnScreen();
  967.     }
  968.  
  969.         /** 
  970.          * Gets the location of the object relative to the parent in the form 
  971.          * of a point specifying the object's top-left corner in the screen's 
  972.          * coordinate space.
  973.          *
  974.          * @return An instance of Point representing the top-left corner of 
  975.      * the objects's bounds in the coordinate space of the screen; null if
  976.          * this object or its parent are not on the screen
  977.          */
  978.     public Point getLocation() {
  979.         return Box.this.getLocation();
  980.     }
  981.  
  982.         /** 
  983.          * Sets the location of the object relative to the parent.
  984.          */
  985.         public void setLocation(Point p) {
  986.         Box.this.setLocation(p);
  987.     }
  988.  
  989.         /** 
  990.          * Gets the bounds of this object in the form of a Rectangle object. 
  991.          * The bounds specify this object's width, height, and location
  992.          * relative to its parent. 
  993.          *
  994.          * @return A rectangle indicating this component's bounds; null if 
  995.      * this object is not on the screen.
  996.          */
  997.         public Rectangle getBounds() {
  998.         return Box.this.getBounds();
  999.     }
  1000.  
  1001.         /** 
  1002.          * Sets the bounds of this object in the form of a Rectangle object. 
  1003.          * The bounds specify this object's width, height, and location
  1004.          * relative to its parent.
  1005.          *    
  1006.          * @param A rectangle indicating this component's bounds
  1007.          */
  1008.         public void setBounds(Rectangle r) {
  1009.         Box.this.setBounds(r);
  1010.     }
  1011.  
  1012.         /** 
  1013.          * Returns the size of this object in the form of a Dimension object. 
  1014.          * The height field of the Dimension object contains this objects's
  1015.          * height, and the width field of the Dimension object contains this 
  1016.      * object's width. 
  1017.          *
  1018.          * @return A Dimension object that indicates the size of this 
  1019.      * component; null if this object is not on the screen
  1020.          */
  1021.         public Dimension getSize() {
  1022.         return Box.this.getSize();
  1023.     }
  1024.  
  1025.         /** 
  1026.          * Resizes this object so that it has width width and height. 
  1027.          *    
  1028.          * @param d - The dimension specifying the new size of the object. 
  1029.          */
  1030.         public void setSize(Dimension d) {
  1031.         Box.this.setSize(d);
  1032.     }
  1033.  
  1034.         /**
  1035.          * Returns the Accessible child, if one exists, contained at the local
  1036.      * coordinate Point.
  1037.          *
  1038.          * @param p The point defining the top-left corner of the Accessible, 
  1039.      * given in the coordinate space of the object's parent. 
  1040.          * @return the Accessible, if it exists, at the specified location; 
  1041.      * else null
  1042.          */
  1043.         public Accessible getAccessibleAt(Point p) {
  1044.         return SwingUtilities.getAccessibleAt(Box.this,p);
  1045.     }
  1046.  
  1047.         /**
  1048.          * Returns whether this object can accept focus or not.
  1049.          *
  1050.          * @return true if object can accept focus; otherwise false
  1051.          */
  1052.         public boolean isFocusTraversable() {
  1053.         return Box.this.isFocusTraversable();
  1054.     }
  1055.  
  1056.         /**
  1057.          * Requests focus for this object.
  1058.          */
  1059.         public void requestFocus() {
  1060.         Box.this.requestFocus();
  1061.         }
  1062.  
  1063.         /**
  1064.          * Adds the specified focus listener to receive focus events from this 
  1065.          * component. 
  1066.          *
  1067.          * @param l the focus listener
  1068.          */
  1069.         public void addFocusListener(FocusListener l) {
  1070.         Box.this.addFocusListener(l);
  1071.     }
  1072.  
  1073.         /**
  1074.          * Removes the specified focus listener so it no longer receives focus 
  1075.          * events from this component.
  1076.          *
  1077.          * @param l the focus listener
  1078.          */
  1079.         public void removeFocusListener(FocusListener l) {
  1080.         Box.this.removeFocusListener(l);
  1081.     }
  1082.     } // inner class AccessibleBox
  1083. }
  1084.