/* * @(#)BasicTextFieldUI.java	1.92 03/03/17 * * Copyright 2003 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */package javax.swing.plaf.basic;import java.awt.*;import java.awt.event.KeyEvent;import java.awt.event.FocusEvent;import java.awt.event.InputEvent;import java.beans.PropertyChangeEvent;import java.io.Reader;import javax.swing.*;import javax.swing.border.*;import javax.swing.event.*;import javax.swing.text.*;import javax.swing.plaf.*;/** * Basis of a look and feel for a JTextField. * <p> * <strong>Warning:</strong> * Serialized objects of this class will not be compatible with * future Swing releases. The current serialization support is * appropriate for short term storage or RMI between applications running * the same version of Swing.  As of 1.4, support for long term storage * of all JavaBeans<sup><font size="-2">TM</font></sup> * has been added to the <code>java.beans</code> package. * Please see {@link java.beans.XMLEncoder}. * * @author  Timothy Prinzing * @version 1.92 03/17/03 */public class BasicTextFieldUI extends BasicTextUI {    /**     * Creates a UI for a JTextField.     *     * @param c the text field     * @return the UI     */    public static ComponentUI createUI(JComponent c) {        return new BasicTextFieldUI();    }    /**     * Creates a new BasicTextFieldUI.     */    public BasicTextFieldUI() {	super();    }    public void installUI(JComponent c) {        super.installUI(c);	editableChanged(c, ((JTextComponent)c).isEditable());    }    /**     * This method gets called when a bound property is changed     * on the associated JTextComponent.  This is a hook     * which UI implementations may change to reflect how the     * UI displays bound properties of JTextComponent subclasses.     *     * @param evt the property change event     */    protected void propertyChange(PropertyChangeEvent evt) {        if (evt.getPropertyName().equals("editable")) {	    JComponent source = (JComponent)evt.getSource();	    Color background = source.getBackground();	    boolean editable =  ((Boolean)evt.getNewValue()).booleanValue();	    editableChanged( source, editable);        }    }    private void editableChanged(JComponent c, boolean editable) {	Color background = c.getBackground();	if (background instanceof UIResource) {	    if (editable == false) {		c.setBackground(UIManager.getColor("TextField.inactiveBackground"));	    } else {		c.setBackground(UIManager.getColor("TextField.background"));	    }	}    }    /**     * Fetches the name used as a key to lookup properties through the     * UIManager.  This is used as a prefix to all the standard     * text properties.     *     * @return the name ("TextField")     */    protected String getPropertyPrefix() {	return "TextField";    }    /**     * Creates a view (FieldView) based on an element.     *     * @param elem the element     * @return the view     */    public View create(Element elem) {	Document doc = elem.getDocument();	Object i18nFlag = doc.getProperty("i18n"/*AbstractDocument.I18NProperty*/);	if ((i18nFlag != null) && i18nFlag.equals(Boolean.TRUE)) {	    // To support bidirectional text, we build a more heavyweight	    // representation of the field.	    String kind = elem.getName();	    if (kind != null) {		if (kind.equals(AbstractDocument.ContentElementName)) {		    return new GlyphView(elem);		} else if (kind.equals(AbstractDocument.ParagraphElementName)) {		    return new I18nFieldView(elem);		}	    }	    // this shouldn't happen, should probably throw in this case.	}	return new FieldView(elem);    }    /**     * A field view that support bidirectional text via the     * support provided by ParagraphView.     */    static class I18nFieldView extends ParagraphView {	I18nFieldView(Element elem) {	    super(elem);	}	/**	 * Fetch the constraining span to flow against for	 * the given child index.  There is no limit for	 * a field since it scrolls, so this is implemented to	 * return <code>Integer.MAX_VALUE</code>.	 */        public int getFlowSpan(int index) {	    return Integer.MAX_VALUE;	}	protected void setJustification(int j) {	    // Justification is done in adjustAllocation(), so disable 	    // ParagraphView's justification handling by doing nothing here.	}	static boolean isLeftToRight( java.awt.Component c ) {	    return c.getComponentOrientation().isLeftToRight();	}	/**	 * Adjusts the allocation given to the view	 * to be a suitable allocation for a text field.	 * If the view has been allocated more than the 	 * preferred span vertically, the allocation is	 * changed to be centered vertically.  Horizontally	 * the view is adjusted according to the horizontal	 * alignment property set on the associated JTextField	 * (if that is the type of the hosting component).	 *	 * @param a the allocation given to the view, which may need	 *  to be adjusted.	 * @return the allocation that the superclass should use.	 */        Shape adjustAllocation(Shape a) {	    if (a != null) {		Rectangle bounds = a.getBounds();		int vspan = (int) getPreferredSpan(Y_AXIS);		int hspan = (int) getPreferredSpan(X_AXIS);		if (bounds.height != vspan) {		    int slop = bounds.height - vspan;		    bounds.y += slop / 2;		    bounds.height -= slop;		}				// horizontal adjustments		Component c = getContainer();		if (c instanceof JTextField) {		    JTextField field = (JTextField) c;		    BoundedRangeModel vis = field.getHorizontalVisibility();		    int max = Math.max(hspan, bounds.width);		    int value = vis.getValue();		    int extent = Math.min(max, bounds.width - 1);		    if ((value + extent) > max) {			value = max - extent;		    }		    vis.setRangeProperties(value, extent, vis.getMinimum(),					   max, false);		    if (hspan < bounds.width) {			// horizontally align the interior			int slop = bounds.width - 1 - hspan;						int align = ((JTextField)c).getHorizontalAlignment();			if(isLeftToRight(c)) {			    if(align==LEADING) {				align = LEFT;			    }			    else if(align==TRAILING) {				align = RIGHT;			    }			}			else {			    if(align==LEADING) {				align = RIGHT;			    }			    else if(align==TRAILING) {				align = LEFT;			    }			}			switch (align) {			case SwingConstants.CENTER:			    bounds.x += slop / 2;			    bounds.width -= slop;			    break;			case SwingConstants.RIGHT:			    bounds.x += slop;			    bounds.width -= slop;			    break;			}		    } else {			// adjust the allocation to match the bounded range.			bounds.width = hspan;			bounds.x -= vis.getValue();		    }		}		return bounds;	    }	    return null;	}	/**	 * Update the visibility model with the associated JTextField	 * (if there is one) to reflect the current visibility as a	 * result of changes to the document model.  The bounded	 * range properties are updated.  If the view hasn't yet been	 * shown the extent will be zero and we just set it to be full	 * until determined otherwise.	 */	void updateVisibilityModel() {	    Component c = getContainer();	    if (c instanceof JTextField) {		JTextField field = (JTextField) c;		BoundedRangeModel vis = field.getHorizontalVisibility();		int hspan = (int) getPreferredSpan(X_AXIS);		int extent = vis.getExtent();		int maximum = Math.max(hspan, extent);		extent = (extent == 0) ? maximum : extent;		int value = maximum - extent;		int oldValue = vis.getValue();		if ((oldValue + extent) > maximum) {		    oldValue = maximum - extent;		}		value = Math.max(0, Math.min(value, oldValue));		vis.setRangeProperties(value, extent, 0, maximum, false);	    }	}	// --- View methods -------------------------------------------		/**	 * Renders using the given rendering surface and area on that surface.	 * The view may need to do layout and create child views to enable	 * itself to render into the given allocation.	 *	 * @param g the rendering surface to use	 * @param a the allocated region to render into	 *	 * @see View#paint	 */        public void paint(Graphics g, Shape a) {	    Rectangle r = (Rectangle) a;	    g.clipRect(r.x, r.y, r.width, r.height);	    super.paint(g, adjustAllocation(a));	}		/**	 * Determines the resizability of the view along the	 * given axis.  A value of 0 or less is not resizable.	 *	 * @param axis View.X_AXIS or View.Y_AXIS	 * @return the weight -> 1 for View.X_AXIS, else 0	 */        public int getResizeWeight(int axis) {	    if (axis == View.X_AXIS) {		return 1;	    }	    return 0;	}		/**	 * Provides a mapping from the document model coordinate space	 * to the coordinate space of the view mapped to it.	 *	 * @param pos the position to convert >= 0	 * @param a the allocated region to render into	 * @return the bounding box of the given position	 * @exception BadLocationException  if the given position does not	 *   represent a valid location in the associated document	 * @see View#modelToView	 */        public Shape modelToView(int pos, Shape a, Position.Bias b) throws BadLocationException {	    return super.modelToView(pos, adjustAllocation(a), b);	}	        /**         * Provides a mapping from the document model coordinate space         * to the coordinate space of the view mapped to it.         *         * @param p0 the position to convert >= 0         * @param b0 the bias toward the previous character or the         *  next character represented by p0, in case the          *  position is a boundary of two views.          * @param p1 the position to convert >= 0         * @param b1 the bias toward the previous character or the         *  next character represented by p1, in case the          *  position is a boundary of two views.          * @param a the allocated region to render into         * @return the bounding box of the given position is returned         * @exception BadLocationException  if the given position does         *   not represent a valid location in the associated document         * @exception IllegalArgumentException for an invalid bias argument         * @see View#viewToModel         */        public Shape modelToView(int p0, Position.Bias b0,                                  int p1, Position.Bias b1, Shape a)             throws BadLocationException         {            return super.modelToView(p0, b0, p1, b1, adjustAllocation(a));        }	/**	 * Provides a mapping from the view coordinate space to the logical	 * coordinate space of the model.	 *	 * @param fx the X coordinate >= 0.0f	 * @param fy the Y coordinate >= 0.0f	 * @param a the allocated region to render into	 * @return the location within the model that best represents the	 *  given point in the view	 * @see View#viewToModel	 */        public int viewToModel(float fx, float fy, Shape a, Position.Bias[] bias) {	    return super.viewToModel(fx, fy, adjustAllocation(a), bias);	}		/**	 * Gives notification that something was inserted into the document	 * in a location that this view is responsible for.	 *	 * @param changes the change information from the associated document	 * @param a the current allocation of the view	 * @param f the factory to use to rebuild if the view has children	 * @see View#insertUpdate	 */        public void insertUpdate(DocumentEvent changes, Shape a, ViewFactory f) {	    super.insertUpdate(changes, adjustAllocation(a), f);	    updateVisibilityModel();	}		/**	 * Gives notification that something was removed from the document	 * in a location that this view is responsible for.	 *	 * @param changes the change information from the associated document	 * @param a the current allocation of the view	 * @param f the factory to use to rebuild if the view has children	 * @see View#removeUpdate	 */        public void removeUpdate(DocumentEvent changes, Shape a, ViewFactory f) {	    super.removeUpdate(changes, adjustAllocation(a), f);	    updateVisibilityModel();	}	    }}