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:   // FIXME: disable to make libjava compile; visibility rules are broken
  64:   protected class AccessibleBox // extends Container.AccessibleAWTContainer
  65:   {
  66:     private static final long serialVersionUID = -7775079816389931944L;
  67:   
  68:     protected AccessibleBox()
  69:     {
  70:     }
  71:     
  72:     public AccessibleRole getAccessibleRole()
  73:     {
  74:       return null;
  75:     }
  76:   }
  77: 
  78:   /**
  79:    * A component that servers as a filler in BoxLayout controlled containers.
  80:    */
  81:   public static class Filler extends JComponent implements Accessible
  82:   {
  83:     private static final long serialVersionUID = -1204263191910183998L;
  84:   
  85:     // FIXME: disable to make libjava compile; visibility rules are broken
  86:     protected class AccessibleBoxFiller // extends Component.AccessibleAWTComponent
  87:     {
  88:       private static final long serialVersionUID = 164963348357479321L;
  89:       
  90:       protected AccessibleBoxFiller()
  91:       {
  92:       }
  93:       
  94:       public AccessibleRole getAccessibleRole()
  95:       {
  96:         return null;
  97:       }
  98:     }
  99:     
 100:     protected AccessibleContext accessibleContext;
 101:     
 102:     private transient Dimension min, pref, max;
 103:     
 104:     /**
 105:      * Creates a new instance of Filler.
 106:      *
 107:      * @param min the minimum size of the filler.
 108:      * @param pref the preferred size of the filler.
 109:      * @param max the maximum size of the filler.
 110:      */
 111:     public Filler(Dimension min, Dimension pref, Dimension max)
 112:     {
 113:       changeShape(min, pref, max);
 114:     }
 115:     
 116:     /**
 117:      * Changes the dimensions of this Filler.
 118:      *
 119:      * @param min the new minimum size of the filler.
 120:      * @param pref the new preferred size of the filler.
 121:      * @param max the new maximum size of the filler.
 122:      */
 123:     public void changeShape(Dimension min, Dimension pref, Dimension max)
 124:     {
 125:       this.min = min;
 126:       this.pref = pref;
 127:       this.max = max;    
 128:     }
 129:     
 130:     public AccessibleContext getAccessibleContext()
 131:     {
 132:       // FIXME: disable to make libjava compile; visibility rules are broken      
 133:       //      if (accessibleContext == null)
 134:       //        accessibleContext = new AccessibleBoxFiller();
 135:       return accessibleContext;
 136:     }
 137:     
 138:     /**
 139:      * Returns the maximum size of this Filler.
 140:      *
 141:      * @return the maximum size of this Filler.
 142:      */
 143:     public Dimension getMaximumSize()
 144:     {
 145:       return max;
 146:     }
 147:     
 148:     /**
 149:      * Returns the minimum size of this Filler.
 150:      *
 151:      * @return the minimum size of this Filler.
 152:      */
 153:     public Dimension getMinimumSize()
 154:     {
 155:       return min;
 156:     }
 157:     
 158:     /**
 159:      * Returns the preferred size of this Filler.
 160:      *
 161:      * @return the preferred size of this Filler.
 162:      */
 163:     public Dimension getPreferredSize()
 164:     {
 165:       return pref;
 166:     }
 167:   }
 168:   
 169:   /**
 170:    * Creates a new Box component, that lays out its children according
 171:    * to the <code>axis</code> parameter.
 172:    *
 173:    * @param axis the orientation of the BoxLayout.
 174:    *
 175:    * @see BoxLayout#X_AXIS
 176:    * @see BoxLayout#Y_AXIS
 177:    * @see BoxLayout#LINE_AXIS
 178:    * @see BoxLayout#PAGE_AXIS
 179:    */
 180:   public Box(int axis)
 181:   {
 182:     super.setLayout(new BoxLayout(this, axis));    
 183:   }
 184:   
 185:   /**
 186:    * Creates a filler component which acts as glue between components.
 187:    * It does not take space unless some extra space is available. If extra
 188:    * space is available, this component can expand in both X and Y directions.
 189:    *
 190:    * @return a glue-like filler component.
 191:    */
 192:   public static Component createGlue()
 193:   {
 194:     Filler glue = new Filler(new Dimension(0,0), new Dimension(0,0),
 195:                              new Dimension(Short.MAX_VALUE,Short.MAX_VALUE)
 196:                              );
 197:     return glue;
 198:   }
 199:   
 200:   public static Box createHorizontalBox()
 201:   {
 202:     return new Box(BoxLayout.X_AXIS);
 203:   }
 204:   
 205:   /**
 206:    * Creates a filler component which acts as glue between components.
 207:    * It does not take space unless some extra space is available. If extra
 208:    * space is available, this component can expand in the X direction.
 209:    *
 210:    * @return a glue-like filler component.
 211:    */
 212:   public static Component createHorizontalGlue()
 213:   {
 214:     Filler glue = new Filler(new Dimension(0,0), new Dimension(0,0),
 215:                              new Dimension(Short.MAX_VALUE, 0)
 216:                              );
 217:     return glue;
 218:   }
 219:   
 220:   /**
 221:    * Creates a filler component which acts as strut between components.
 222:    * It will fill exactly the specified horizontal size.
 223:    *
 224:    * @param width the width of this strut in pixels.
 225:    *
 226:    * @return a strut-like filler component.
 227:    */
 228:   public static Component createHorizontalStrut(int width)
 229:   {
 230:     Filler strut = new Filler(new Dimension(width, 0),
 231:                               new Dimension(width, 0),
 232:                               new Dimension(width, Integer.MAX_VALUE));
 233:     return strut;
 234:   }
 235:   
 236:   public static Component createRigidArea(Dimension d)
 237:   {
 238:     return new Filler(d, d, d);
 239:   }
 240:   
 241:   public static Box createVerticalBox()
 242:   {
 243:     return new Box(BoxLayout.Y_AXIS);
 244:   }
 245:   
 246:   /**
 247:    * Creates a filler component which acts as glue between components.
 248:    * It does not take space unless some extra space is available. If extra
 249:    * space is available, this component can expand in the Y direction.
 250:    *
 251:    * @return a glue-like filler component.
 252:    */
 253:   public static Component createVerticalGlue()
 254:   {
 255:     return createGlue();
 256:   }
 257:   
 258:   /**
 259:    * Creates a filler component which acts as strut between components.
 260:    * It will fill exactly the specified vertical size.
 261:    *
 262:    * @param height the height of this strut in pixels.
 263:    *
 264:    * @return a strut-like filler component.
 265:    */
 266:   public static Component createVerticalStrut(int height)
 267:   {
 268:     Filler strut = new Filler(new Dimension(0, height),
 269:                               new Dimension(0, height),
 270:                               new Dimension(Integer.MAX_VALUE, height));
 271:     return strut;
 272:   }
 273:   
 274:   public void setLayout(LayoutManager l)
 275:   {
 276:     throw new AWTError("Not allowed to set layout managers for boxes.");
 277:   }
 278:   
 279:   public AccessibleContext getAccessibleContext()
 280:   {
 281:     //     if (accessibleContext == null)
 282:     //       accessibleContext = new AccessibleBox();
 283:     return accessibleContext;
 284:   }
 285:   
 286:   
 287: }