libjava/javax/swing/JTextField.java

   1 /* JTextField.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., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 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 package javax.swing;
  39
  40 import java.awt.Dimension;
  41 import java.awt.Font;
  42 import java.awt.FontMetrics;
  43 import java.awt.event.ActionEvent;
  44 import java.awt.event.ActionListener;
  45 import java.beans.PropertyChangeEvent;
  46 import java.beans.PropertyChangeListener;
  47
  48 import javax.accessibility.AccessibleStateSet;
  49 import javax.swing.text.Document;
  50 import javax.swing.text.JTextComponent;
  51 import javax.swing.text.PlainDocument;
  52
  53
  54 public class JTextField extends JTextComponent
  55   implements SwingConstants
  56 {
  57   /**
  58    * AccessibleJTextField
  59    */
  60   protected class AccessibleJTextField extends AccessibleJTextComponent
  61   {
  62     private static final long serialVersionUID = 8255147276740453036L;
  63
  64     /**
  65      * Constructor AccessibleJTextField
  66      */
  67     protected AccessibleJTextField()
  68     {
  69     }
  70
  71     /**
  72      * getAccessibleStateSet
  73      * @return AccessibleStateSet
  74      */
  75     public AccessibleStateSet getAccessibleStateSet()
  76     {
  77       return null;
  78     }
  79   }
  80
  81   private static final long serialVersionUID = 353853209832607592L;
  82
  83   public static final String notifyAction = "notify-field-accept";
  84
  85   private int columns;
  86
  87   private int align;
  88
  89   private int scrollOffset;
  90
  91   /** @since 1.3 */
  92   private Action action;
  93
  94   /** @since 1.3 */
  95   private String actionCommand;
  96
  97   private PropertyChangeListener actionPropertyChangeListener;
  98
  99   /**
 100    * Creates a new instance of <code>JTextField</code>.
 101    */
 102   public JTextField()
 103   {
 104     this(null, null, 0);
 105   }
 106
 107   /**
 108    * Creates a new instance of <code>JTextField</code>.
 109    *
 110    * @param text the initial text
 111    */
 112   public JTextField(String text)
 113   {
 114     this(null, text, 0);
 115   }
 116
 117   /**
 118    * Creates a new instance of <code>JTextField</code>.
 119    *
 120    * @param columns the number of columns
 121    *
 122    * @exception IllegalArgumentException if columns %lt; 0
 123    */
 124   public JTextField(int columns)
 125   {
 126     this(null, null, columns);
 127   }
 128
 129   /**
 130    * Creates a new instance of <code>JTextField</code>.
 131    *
 132    * @param text the initial text
 133    * @param columns the number of columns
 134    *
 135    * @exception IllegalArgumentException if columns %lt; 0
 136    */
 137   public JTextField(String text, int columns)
 138   {
 139     this(null, text, columns);
 140   }
 141
 142   /**
 143    * Creates a new instance of <code>JTextField</code>.
 144    *
 145    * @param doc the document to use
 146    * @param text the initial text
 147    * @param columns the number of columns
 148    *
 149    * @exception IllegalArgumentException if columns %lt; 0
 150    */
 151   public JTextField(Document doc, String text, int columns)
 152   {
 153     if (columns < 0)
 154       throw new IllegalArgumentException();
 155
 156     this.columns = columns;
 157
 158     setDocument(doc == null ? createDefaultModel() : doc);
 159
 160     if (text != null)
 161       setText(text);
 162   }
 163
 164   /**
 165    * Creates the default model for this text field.
 166    * This implementation returns an instance of <code>PlainDocument</code>.
 167    *
 168    * @return a new instance of the default model
 169    */
 170   protected Document createDefaultModel()
 171   {
 172     return new PlainDocument();
 173   }
 174
 175   /**
 176    * Returns the class ID for the UI.
 177    *
 178    * @return "TextFieldUI";
 179    */
 180   public String getUIClassID()
 181   {
 182     return "TextFieldUI";
 183   }
 184
 185   /**
 186    * Adds a new listener object to this text field.
 187    *
 188    * @param listener the listener to add
 189    */
 190   public void addActionListener(ActionListener listener)
 191   {
 192     listenerList.add(ActionListener.class, listener);
 193   }
 194
 195   /**
 196    * Removes a listener object from this text field.
 197    *
 198    * @param listener the listener to remove
 199    */
 200   public void removeActionListener(ActionListener listener)
 201   {
 202     listenerList.remove(ActionListener.class, listener);
 203   }
 204
 205   /**
 206    * Returns all registered <code>ActionListener</code> objects.
 207    *
 208    * @return an array of listeners
 209    *
 210    * @since 1.4
 211    */
 212   public ActionListener[] getActionListeners()
 213   {
 214     return (ActionListener[]) getListeners(ActionListener.class);
 215   }
 216
 217   /**
 218    * Sends an action event to all registered
 219    * <code>ActionListener</code> objects.
 220    */
 221   protected void fireActionPerformed()
 222   {
 223     ActionEvent event = new ActionEvent(this, 0, notifyAction);
 224     ActionListener[] listeners = getActionListeners();
 225
 226     for (int index = 0; index < listeners.length; ++index)
 227       listeners[index].actionPerformed(event);
 228   }
 229
 230   /**
 231    * Returns the number of columns of this text field.
 232    *
 233    * @return the number of columns
 234    */
 235   public int getColumns()
 236   {
 237     return columns;
 238   }
 239
 240   public void setColumns(int columns)
 241   {
 242     if (columns < 0)
 243       throw new IllegalArgumentException();
 244
 245     this.columns = columns;
 246     invalidate();
 247     repaint();
 248   }
 249
 250   public int getHorizontalAlignment()
 251   {
 252     return align;
 253   }
 254
 255   public void setHorizontalAlignment(int newAlign)
 256   {
 257     if (align == newAlign)
 258       return;
 259
 260     int oldAlign = align;
 261     align = newAlign;
 262     firePropertyChange("horizontalAlignment", oldAlign, newAlign);
 263     invalidate();
 264     repaint();
 265   }
 266
 267   public void setFont(Font newFont)
 268   {
 269     super.setFont(newFont);
 270     revalidate();
 271   }
 272
 273   public Dimension getPreferredSize()
 274   {
 275     Dimension size;
 276     FontMetrics fm = getFontMetrics(getFont());
 277     int fontHeight = fm.getMaxAscent() + fm.getMaxDescent();
 278     int columnWidth = fm.charWidth('m');
 279
 280     if (columns != 0)
 281       {
 282         size = new Dimension(columns * columnWidth + 4, fontHeight + 4);
 283       }
 284     else
 285       {
 286         size = new Dimension(10, 10);
 287       }
 288
 289     return size;
 290   }
 291
 292   /**
 293    * Returns the scroll offset in pixels.
 294    *
 295    * @return the scroll offset
 296    */
 297   public int getScrollOffset()
 298   {
 299     return scrollOffset;
 300   }
 301
 302   /**
 303    * Sets the scroll offset in pixels.
 304    *
 305    * @param offset the scroll offset
 306    */
 307   public void setScrollOffset(int offset)
 308   {
 309     scrollOffset = offset;
 310   }
 311
 312   public void postActionEvent()
 313   {
 314     ActionEvent event = new ActionEvent(this, 0, actionCommand);
 315     ActionListener[] listeners = getActionListeners();
 316
 317     for (int index = 0; index < listeners.length; ++index)
 318       listeners[index].actionPerformed(event);
 319   }
 320
 321   /**
 322    * @since 1.3
 323    */
 324   public Action getAction()
 325   {
 326     return action;
 327   }
 328
 329   /**
 330    * @since 1.3
 331    */
 332   public void setAction(Action newAction)
 333   {
 334     if (action == newAction)
 335       return;
 336
 337     if (action != null)
 338       {
 339         removeActionListener(action);
 340         action.removePropertyChangeListener(actionPropertyChangeListener);
 341         actionPropertyChangeListener = null;
 342       }
 343
 344     Action oldAction = action;
 345     action = newAction;
 346
 347     if (action != null)
 348       {
 349         addActionListener(action);
 350         actionPropertyChangeListener =
 351           createActionPropertyChangeListener(action);
 352         action.addPropertyChangeListener(actionPropertyChangeListener);
 353       }
 354
 355     firePropertyChange("horizontalAlignment", oldAction, newAction);
 356   }
 357
 358   /**
 359    * @since 1.3
 360    */
 361   public String getActionCommand()
 362   {
 363     return actionCommand;
 364   }
 365
 366   /**
 367    * @since 1.3
 368    */
 369   public void setActionCommand(String command)
 370   {
 371     this.actionCommand = command;
 372   }
 373
 374   /**
 375    * @since 1.3
 376    */
 377   protected PropertyChangeListener createActionPropertyChangeListener(Action action)
 378   {
 379     return new PropertyChangeListener()
 380       {
 381         public void propertyChange(PropertyChangeEvent event)
 382         {
 383           // Update properties "action" and "horizontalAlignment".
 384           String name = event.getPropertyName();
 385
 386           if (name.equals("enabled"))
 387             {
 388               boolean enabled = ((Boolean) event.getNewValue()).booleanValue();
 389               JTextField.this.setEnabled(enabled);
 390             }
 391           else if (name.equals(Action.SHORT_DESCRIPTION))
 392             {
 393               JTextField.this.setToolTipText((String) event.getNewValue());
 394             }
 395         }
 396       };
 397   }
 398
 399   /**
 400    * @since 1.3
 401    */
 402   protected void configurePropertiesFromAction(Action action)
 403   {
 404     if (action != null)
 405       {
 406         setEnabled(action.isEnabled());
 407         setToolTipText((String) action.getValue(Action.SHORT_DESCRIPTION));
 408       }
 409     else
 410       {
 411         setEnabled(true);
 412         setToolTipText(null);
 413       }
 414   }
 415
 416   protected int getColumnWidth()
 417   {
 418     FontMetrics metrics = getToolkit().getFontMetrics(getFont());
 419     return metrics.charWidth('m');
 420   }
 421 }