Source for java.awt.Label

   1: /* Label.java -- Java label widget
   2:    Copyright (C) 1999, 2000, 2002, 2004, 2005, 2006,  Free Software 
   3:    Foundation, Inc.
   4: 
   5: This file is part of GNU Classpath.
   6: 
   7: GNU Classpath is free software; you can redistribute it and/or modify
   8: it under the terms of the GNU General Public License as published by
   9: the Free Software Foundation; either version 2, or (at your option)
  10: any later version.
  11: 
  12: GNU Classpath is distributed in the hope that it will be useful, but
  13: WITHOUT ANY WARRANTY; without even the implied warranty of
  14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15: General Public License for more details.
  16: 
  17: You should have received a copy of the GNU General Public License
  18: along with GNU Classpath; see the file COPYING.  If not, write to the
  19: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  20: 02110-1301 USA.
  21: 
  22: Linking this library statically or dynamically with other modules is
  23: making a combined work based on this library.  Thus, the terms and
  24: conditions of the GNU General Public License cover the whole
  25: combination.
  26: 
  27: As a special exception, the copyright holders of this library give you
  28: permission to link this library with independent modules to produce an
  29: executable, regardless of the license terms of these independent
  30: modules, and to copy and distribute the resulting executable under
  31: terms of your choice, provided that you also meet, for each linked
  32: independent module, the terms and conditions of the license of that
  33: module.  An independent module is a module which is not derived from
  34: or based on this library.  If you modify this library, you may extend
  35: this exception to your version of the library, but you are not
  36: obligated to do so.  If you do not wish to do so, delete this
  37: exception statement from your version. */
  38: 
  39: 
  40: package java.awt;
  41: 
  42: import java.awt.peer.LabelPeer;
  43: 
  44: import javax.accessibility.Accessible;
  45: import javax.accessibility.AccessibleContext;
  46: import javax.accessibility.AccessibleRole;
  47: 
  48: /**
  49:  * This component is used for displaying simple text strings that cannot
  50:  * be edited by the user.
  51:  *
  52:  * @author Aaron M. Renn (arenn@urbanophile.com)
  53:  * @author Tom Tromey (tromey@cygnus.com)
  54:  * @author Andrew John Hughes  (gnu_andrew@member.fsf.org)
  55:  */
  56: public class Label extends Component implements Accessible
  57: {
  58: 
  59:   /**
  60:    * Alignment constant aligning the text to the left of its window.
  61:    */
  62:   public static final int LEFT = 0;
  63: 
  64:   /**
  65:    * Alignment constant aligning the text in the center of its window.
  66:    */
  67:   public static final int CENTER = 1;
  68: 
  69:   /**
  70:    * Alignment constant aligning the text to the right of its window.
  71:    */
  72:   public static final int RIGHT = 2;
  73: 
  74:   // Serialization version constant:
  75:   private static final long serialVersionUID = 3094126758329070636L;
  76: 
  77:   /**
  78:    * @serial Indicates the alignment of the text within this label's window.
  79:    * This is one of the constants in this class.  The default value is 
  80:    * <code>LEFT</code>.
  81:    */
  82:   private int alignment;
  83: 
  84:   /**
  85:    * @serial The text displayed in the label
  86:    */
  87:   private String text;
  88: 
  89:   /**
  90:    * Initializes a new instance of <code>Label</code> with no text.
  91:    *
  92:    * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true.
  93:    */
  94:   public Label()
  95:   {
  96:     this("", LEFT);
  97:   }
  98: 
  99:   /**
 100:    * Initializes a new instance of <code>Label</code> with the specified
 101:    * text that is aligned to the left.
 102:    *
 103:    * @param text The text of the label.
 104:    *
 105:    * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true.
 106:    */
 107:   public Label(String text)
 108:   {
 109:     this(text, LEFT);
 110:   }
 111: 
 112:   /**
 113:    * Initializes a new instance of <code>Label</code> with the specified
 114:    * text and alignment.
 115:    *
 116:    * @param text The text of the label.
 117:    * @param alignment The desired alignment for the text in this label,
 118:    * which must be one of <code>LEFT</code>, <code>CENTER</code>, or
 119:    * <code>RIGHT</code>.
 120:    *
 121:    * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true.
 122:    */
 123:   public Label(String text, int alignment)
 124:   {
 125:     setAlignment(alignment);
 126:     setText(text);
 127: 
 128:     if (GraphicsEnvironment.isHeadless())
 129:       throw new HeadlessException();
 130:   }
 131: 
 132:   /**
 133:    * Returns the constant indicating the alignment of the text in this
 134:    * label.  The value returned will be one of the alignment constants
 135:    * from this class.
 136:    *
 137:    * @return The alignment of the text in the label.
 138:    */
 139:   public int getAlignment()
 140:   {
 141:     return(alignment);
 142:   }
 143: 
 144:   /**
 145:    * Sets the text alignment of this label to the specified value.
 146:    *
 147:    * @param alignment The desired alignment for the text in this label,
 148:    * which must be one of <code>LEFT</code>, <code>CENTER</code>, or
 149:    * <code>RIGHT</code>.
 150:    */
 151:   public synchronized void setAlignment(int alignment)
 152:   {
 153:     if (alignment != CENTER && alignment != LEFT && alignment != RIGHT)
 154:       throw new IllegalArgumentException("invalid alignment: " + alignment);
 155:     this.alignment = alignment;
 156:     if (peer != null)
 157:       {
 158:         LabelPeer lp = (LabelPeer) peer;
 159:         lp.setAlignment(alignment);
 160:       }
 161:   }
 162: 
 163:   /**
 164:    * Returns the text displayed in this label.
 165:    *
 166:    * @return The text for this label.
 167:    */
 168:   public String getText()
 169:   {
 170:     return text;
 171:   }
 172: 
 173:   /**
 174:    * Sets the text in this label to the specified value.
 175:    *
 176:    * @param text The new text for this label.
 177:    */
 178:   public synchronized void setText(String text)
 179:   {
 180:     if ((this.text == null && text != null)
 181:         || (this.text != null && ! this.text.equals(text)))
 182:       {
 183:         this.text = text;
 184: 
 185:         if (peer != null)
 186:          {
 187:            LabelPeer lp = (LabelPeer) peer;
 188:            lp.setText(text);
 189:          }
 190:        invalidate();
 191:       }
 192:   }
 193: 
 194:   /**
 195:    * Notifies this label that it has been added to a container, causing
 196:    * the peer to be created.  This method is called internally by the AWT
 197:    * system.
 198:    */
 199:   public void addNotify()
 200:   {
 201:     if (peer == null)
 202:       peer = getToolkit().createLabel(this);
 203:     super.addNotify();
 204:   }
 205: 
 206:   /**
 207:    * Returns a parameter string useful for debugging.
 208:    *
 209:    * @return A debugging string.
 210:    */
 211:   protected String paramString()
 212:   {
 213:     return ("text=" + getText() + ",alignment=" +
 214:         getAlignment() + "," + super.paramString());
 215:   }
 216: 
 217:   /**
 218:    * This class provides accessibility support for the label.
 219:    */
 220:   protected class AccessibleAWTLabel
 221:     extends AccessibleAWTComponent
 222:   {
 223:     /**
 224:      * For compatability with Sun's JDK 1.4.2 rev. 5
 225:      */
 226:     private static final long serialVersionUID = -3568967560160480438L;
 227: 
 228:     /**
 229:      * Constructor for the accessible label.
 230:      */
 231:     public AccessibleAWTLabel()
 232:     {
 233:     }
 234: 
 235:     /**
 236:      * Returns the accessible name for the label.  This is
 237:      * the text used in the label.
 238:      *
 239:      * @return a <code>String</code> containing the accessible
 240:      *         name for this label.
 241:      */
 242:     public String getAccessibleName()
 243:     {
 244:       return getText();
 245:     }
 246: 
 247:     /**
 248:      * Returns the accessible role for the label.
 249:      *
 250:      * @return an instance of <code>AccessibleRole</code>, describing
 251:      *         the role of the label.
 252:      */
 253:     public AccessibleRole getAccessibleRole()
 254:     {
 255:       return AccessibleRole.LABEL;
 256:     }
 257: 
 258:   }
 259: 
 260:   /**
 261:    * Gets the AccessibleContext associated with this <code>Label</code>.
 262:    * The context is created, if necessary.
 263:    *
 264:    * @return the associated context
 265:    */
 266:   public AccessibleContext getAccessibleContext()
 267:   {
 268:     /* Create the context if this is the first request */
 269:     if (accessibleContext == null)
 270:       accessibleContext = new AccessibleAWTLabel();
 271:     return accessibleContext;
 272:   }
 273: 
 274:   /**
 275:    * Generate a unique name for this button.
 276:    *
 277:    * @return A unique name for this button.
 278:    */
 279:   String generateName()
 280:   {
 281:     return "label" + getUniqueLong();
 282:   }
 283:   
 284:   /**
 285:    * The number used to generate the name returned by getName.
 286:    */
 287:   private static transient long nextLabelNumber;
 288: 
 289:   private static synchronized long getUniqueLong()
 290:   {
 291:     return nextLabelNumber++;
 292:   }
 293: 
 294: }