Source for javax.swing.Box

   1: /* Box.java --
   2:    Copyright (C) 2002, 2004 Free Software Foundation, Inc.
   3: 
   4: This file is part of GNU Classpath.
   5: 
   6: GNU Classpath is free software; you can redistribute it and/or modify
   7: it under the terms of the GNU General Public License as published by
   8: the Free Software Foundation; either version 2, or (at your option)
   9: any later version.
  10: 
  11: GNU Classpath is distributed in the hope that it will be useful, but
  12: WITHOUT ANY WARRANTY; without even the implied warranty of
  13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14: General Public License for more details.
  15: 
  16: You should have received a copy of the GNU General Public License
  17: along with GNU Classpath; see the file COPYING.  If not, write to the
  18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19: 02110-1301 USA.
  20: 
  21: Linking this library statically or dynamically with other modules is
  22: making a combined work based on this library.  Thus, the terms and
  23: conditions of the GNU General Public License cover the whole
  24: combination.
  25: 
  26: As a special exception, the copyright holders of this library give you
  27: permission to link this library with independent modules to produce an
  28: executable, regardless of the license terms of these independent
  29: modules, and to copy and distribute the resulting executable under
  30: terms of your choice, provided that you also meet, for each linked
  31: independent module, the terms and conditions of the license of that
  32: module.  An independent module is a module which is not derived from
  33: or based on this library.  If you modify this library, you may extend
  34: this exception to your version of the library, but you are not
  35: obligated to do so.  If you do not wish to do so, delete this
  36: exception statement from your version. */
  37: 
  38: 
  39: package javax.swing;
  40: 
  41: import java.awt.AWTError;
  42: import java.awt.Component;
  43: import java.awt.Dimension;
  44: import java.awt.LayoutManager;
  45: 
  46: import javax.accessibility.Accessible;
  47: import javax.accessibility.AccessibleContext;
  48: import javax.accessibility.AccessibleRole;
  49: 
  50: /**
  51:  * A component that uses a {@link BoxLayout} as Layout Manager.
  52:  *
  53:  * In addition to that, this class provides a set of static methods for
  54:  * creating some filler components ('struts' and 'glue') for use in
  55:  * containers that are laid out using BoxLayout.
  56:  *
  57:  * @author Ronald Veldema (rveldema@cs.vu.nl)
  58:  */
  59: public class Box extends JComponent implements Accessible
  60: {
  61:   private static final long serialVersionUID = 1525417495883046342L;
  62:   
  63:   /**
  64:    * Provides accessibility support for <code>Box</code>es.
  65:    */
  66:   // FIXME: disable to make libjava compile; visibility rules are broken
  67:   protected class AccessibleBox // extends Container.AccessibleAWTContainer
  68:   {
  69:     private static final long serialVersionUID = -7775079816389931944L;
  70:   
  71:     protected AccessibleBox()
  72:     {
  73:     }
  74:     
  75:     public AccessibleRole getAccessibleRole()
  76:     {
  77:       return null;
  78:     }
  79:   }
  80: 
  81:   /**
  82:    * A component that servers as a filler in BoxLayout controlled containers.
  83:    */
  84:   public static class Filler extends JComponent implements Accessible
  85:   {
  86:     private static final long serialVersionUID = -1204263191910183998L;
  87:   
  88:     /**
  89:      * Provides accessibility support for <code>Box.Filler</code>.
  90:      */
  91:     // FIXME: disable to make libjava compile; visibility rules are broken
  92:     protected class AccessibleBoxFiller // extends Component.AccessibleAWTComponent
  93:     {
  94:       private static final long serialVersionUID = 164963348357479321L;
  95:       
  96:       protected AccessibleBoxFiller()
  97:       {
  98:       }
  99:       
 100:       public AccessibleRole getAccessibleRole()
 101:       {
 102:         return null;
 103:       }
 104:     }
 105:     
 106:     protected AccessibleContext accessibleContext;
 107:     
 108:     private transient Dimension min, pref, max;
 109:     
 110:     /**
 111:      * Creates a new instance of Filler.
 112:      *
 113:      * @param min the minimum size of the filler.
 114:      * @param pref the preferred size of the filler.
 115:      * @param max the maximum size of the filler.
 116:      */
 117:     public Filler(Dimension min, Dimension pref, Dimension max)
 118:     {
 119:       changeShape(min, pref, max);
 120:     }
 121:     
 122:     /**
 123:      * Changes the dimensions of this Filler.
 124:      *
 125:      * @param min the new minimum size of the filler.
 126:      * @param pref the new preferred size of the filler.
 127:      * @param max the new maximum size of the filler.
 128:      */
 129:     public void changeShape(Dimension min, Dimension pref, Dimension max)
 130:     {
 131:       this.min = min;
 132:       this.pref = pref;
 133:       this.max = max;    
 134:     }
 135:     
 136:     public AccessibleContext getAccessibleContext()
 137:     {
 138:       // FIXME: disable to make libjava compile; visibility rules are broken      
 139:       //      if (accessibleContext == null)
 140:       //        accessibleContext = new AccessibleBoxFiller();
 141:       return accessibleContext;
 142:     }
 143:     
 144:     /**
 145:      * Returns the maximum size of this Filler.
 146:      *
 147:      * @return the maximum size of this Filler.
 148:      */
 149:     public Dimension getMaximumSize()
 150:     {
 151:       return max;
 152:     }
 153:     
 154:     /**
 155:      * Returns the minimum size of this Filler.
 156:      *
 157:      * @return the minimum size of this Filler.
 158:      */
 159:     public Dimension getMinimumSize()
 160:     {
 161:       return min;
 162:     }
 163:     
 164:     /**
 165:      * Returns the preferred size of this Filler.
 166:      *
 167:      * @return the preferred size of this Filler.
 168:      */
 169:     public Dimension getPreferredSize()
 170:     {
 171:       return pref;
 172:     }
 173:   }
 174:   
 175:   /**
 176:    * Creates a new Box component, that lays out its children according
 177:    * to the <code>axis</code> parameter.
 178:    *
 179:    * @param axis the orientation of the BoxLayout.
 180:    *
 181:    * @see BoxLayout#X_AXIS
 182:    * @see BoxLayout#Y_AXIS
 183:    * @see BoxLayout#LINE_AXIS
 184:    * @see BoxLayout#PAGE_AXIS
 185:    */
 186:   public Box(int axis)
 187:   {
 188:     super.setLayout(new BoxLayout(this, axis));    
 189:   }
 190:   
 191:   /**
 192:    * Creates a filler component which acts as glue between components.
 193:    * It does not take space unless some extra space is available. If extra
 194:    * space is available, this component can expand in both X and Y directions.
 195:    *
 196:    * @return a glue-like filler component.
 197:    */
 198:   public static Component createGlue()
 199:   {
 200:     Filler glue = new Filler(new Dimension(0,0), new Dimension(0,0),
 201:                              new Dimension(Short.MAX_VALUE,Short.MAX_VALUE)
 202:                              );
 203:     return glue;
 204:   }
 205:   
 206:   public static Box createHorizontalBox()
 207:   {
 208:     return new Box(BoxLayout.X_AXIS);
 209:   }
 210:   
 211:   /**
 212:    * Creates a filler component which acts as glue between components.
 213:    * It does not take space unless some extra space is available. If extra
 214:    * space is available, this component can expand in the X direction.
 215:    *
 216:    * @return a glue-like filler component.
 217:    */
 218:   public static Component createHorizontalGlue()
 219:   {
 220:     Filler glue = new Filler(new Dimension(0,0), new Dimension(0,0),
 221:                              new Dimension(Short.MAX_VALUE, 0)
 222:                              );
 223:     return glue;
 224:   }
 225:   
 226:   /**
 227:    * Creates a filler component which acts as strut between components.
 228:    * It will fill exactly the specified horizontal size.
 229:    *
 230:    * @param width the width of this strut in pixels.
 231:    *
 232:    * @return a strut-like filler component.
 233:    */
 234:   public static Component createHorizontalStrut(int width)
 235:   {
 236:     Filler strut = new Filler(new Dimension(width, 0),
 237:                               new Dimension(width, 0),
 238:                               new Dimension(width, Integer.MAX_VALUE));
 239:     return strut;
 240:   }
 241:   
 242:   public static Component createRigidArea(Dimension d)
 243:   {
 244:     return new Filler(d, d, d);
 245:   }
 246:   
 247:   public static Box createVerticalBox()
 248:   {
 249:     return new Box(BoxLayout.Y_AXIS);
 250:   }
 251:   
 252:   /**
 253:    * Creates a filler component which acts as glue between components.
 254:    * It does not take space unless some extra space is available. If extra
 255:    * space is available, this component can expand in the Y direction.
 256:    *
 257:    * @return a glue-like filler component.
 258:    */
 259:   public static Component createVerticalGlue()
 260:   {
 261:     return createGlue();
 262:   }
 263:   
 264:   /**
 265:    * Creates a filler component which acts as strut between components.
 266:    * It will fill exactly the specified vertical size.
 267:    *
 268:    * @param height the height of this strut in pixels.
 269:    *
 270:    * @return a strut-like filler component.
 271:    */
 272:   public static Component createVerticalStrut(int height)
 273:   {
 274:     Filler strut = new Filler(new Dimension(0, height),
 275:                               new Dimension(0, height),
 276:                               new Dimension(Integer.MAX_VALUE, height));
 277:     return strut;
 278:   }
 279:   
 280:   public void setLayout(LayoutManager l)
 281:   {
 282:     throw new AWTError("Not allowed to set layout managers for boxes.");
 283:   }
 284:   
 285:   public AccessibleContext getAccessibleContext()
 286:   {
 287:     //     if (accessibleContext == null)
 288:     //       accessibleContext = new AccessibleBox();
 289:     return accessibleContext;
 290:   }
 291:   
 292:   
 293: }