libjava/javax/swing/JTextField.java

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