/*
 * @(#)BasicTextFieldUI.java	1.90 01/12/03
 *
 * Copyright 2002 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.90 12/03/01
 */
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;
	}

	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();
	}
	
    }

}
