Back to index...

	/*
	* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/
	package javax.swing.plaf.basic;

	import java.beans.*;
	import java.awt.*;
	import java.awt.event.KeyEvent;
	import java.awt.event.InputEvent;
	import javax.swing.*;
	import javax.swing.event.DocumentEvent;
	import javax.swing.text.*;
	import javax.swing.plaf.*;

	/**
	* Provides the look and feel for a plain text editor. In this
	* implementation the default UI is extended to act as a simple
	* view factory.
	* <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™
	* has been added to the <code>java.beans</code> package.
	* Please see {@link java.beans.XMLEncoder}.
	*
	* @author Timothy Prinzing
	*/
	public class BasicTextAreaUI extends BasicTextUI {

	/**
	* Creates a UI for a JTextArea.
	*
	* @param ta a text area
	* @return the UI
	*/
	public static ComponentUI createUI(JComponent ta) {
	return new BasicTextAreaUI();
	}

	/**
	* Constructs a new BasicTextAreaUI object.
	*/
	public BasicTextAreaUI() {
	super();
	}

	/**
	* Fetches the name used as a key to look up properties through the
	* UIManager. This is used as a prefix to all the standard
	* text properties.
	*
	* @return the name ("TextArea")
	*/
	protected String getPropertyPrefix() {
	return "TextArea";
	}

	protected void installDefaults() {
	super.installDefaults();
	//the fix for 4785160 is undone
	}

	/**
	* 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.
	* This is implemented to rebuild the View when the
	* <em>WrapLine</em> or the <em>WrapStyleWord</em> property changes.
	*
	* @param evt the property change event
	*/
	protected void propertyChange(PropertyChangeEvent evt) {
	super.propertyChange(evt);
	if (evt.getPropertyName().equals("lineWrap") \|\|
	evt.getPropertyName().equals("wrapStyleWord") \|\|
	evt.getPropertyName().equals("tabSize")) {
	// rebuild the view
	modelChanged();
	} else if ("editable".equals(evt.getPropertyName())) {
	updateFocusTraversalKeys();
	}
	}


	/**
	* The method is overridden to take into account caret width.
	*
	* @param c the editor component
	* @return the preferred size
	* @throws IllegalArgumentException if invalid value is passed
	*
	* @since 1.5
	*/
	public Dimension getPreferredSize(JComponent c) {
	return super.getPreferredSize(c);
	//the fix for 4785160 is undone
	}

	/**
	* The method is overridden to take into account caret width.
	*
	* @param c the editor component
	* @return the minimum size
	* @throws IllegalArgumentException if invalid value is passed
	*
	* @since 1.5
	*/
	public Dimension getMinimumSize(JComponent c) {
	return super.getMinimumSize(c);
	//the fix for 4785160 is undone
	}

	/**
	* Creates the view for an element. Returns a WrappedPlainView or
	* PlainView.
	*
	* @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)) {
	// build a view that support bidi
	return createI18N(elem);
	} else {
	JTextComponent c = getComponent();
	if (c instanceof JTextArea) {
	JTextArea area = (JTextArea) c;
	View v;
	if (area.getLineWrap()) {
	v = new WrappedPlainView(elem, area.getWrapStyleWord());
	} else {
	v = new PlainView(elem);
	}
	return v;
	}
	}
	return null;
	}

	View createI18N(Element elem) {
	String kind = elem.getName();
	if (kind != null) {
	if (kind.equals(AbstractDocument.ContentElementName)) {
	return new PlainParagraph(elem);
	} else if (kind.equals(AbstractDocument.ParagraphElementName)) {
	return new BoxView(elem, View.Y_AXIS);
	}
	}
	return null;
	}

	/**
	* Returns the baseline.
	*
	* @throws NullPointerException {@inheritDoc}
	* @throws IllegalArgumentException {@inheritDoc}
	* @see javax.swing.JComponent#getBaseline(int, int)
	* @since 1.6
	*/
	public int getBaseline(JComponent c, int width, int height) {
	super.getBaseline(c, width, height);
	Object i18nFlag = ((JTextComponent)c).getDocument().
	getProperty("i18n");
	Insets insets = c.getInsets();
	if (Boolean.TRUE.equals(i18nFlag)) {
	View rootView = getRootView((JTextComponent)c);
	if (rootView.getViewCount() > 0) {
	height = height - insets.top - insets.bottom;
	int baseline = insets.top;
	int fieldBaseline = BasicHTML.getBaseline(
	rootView.getView(0), width - insets.left -
	insets.right, height);
	if (fieldBaseline < 0) {
	return -1;
	}
	return baseline + fieldBaseline;
	}
	return -1;
	}
	FontMetrics fm = c.getFontMetrics(c.getFont());
	return insets.top + fm.getAscent();
	}

	/**
	* Returns an enum indicating how the baseline of the component
	* changes as the size changes.
	*
	* @throws NullPointerException {@inheritDoc}
	* @see javax.swing.JComponent#getBaseline(int, int)
	* @since 1.6
	*/
	public Component.BaselineResizeBehavior getBaselineResizeBehavior(
	JComponent c) {
	super.getBaselineResizeBehavior(c);
	return Component.BaselineResizeBehavior.CONSTANT_ASCENT;
	}


	/**
	* Paragraph for representing plain-text lines that support
	* bidirectional text.
	*/
	static class PlainParagraph extends ParagraphView {

	PlainParagraph(Element elem) {
	super(elem);
	layoutPool = new LogicalView(elem);
	layoutPool.setParent(this);
	}

	public void setParent(View parent) {
	super.setParent(parent);
	if (parent != null) {
	setPropertiesFromAttributes();
	}
	}

	protected void setPropertiesFromAttributes() {
	Component c = getContainer();
	if ((c != null) && (! c.getComponentOrientation().isLeftToRight())) {
	setJustification(StyleConstants.ALIGN_RIGHT);
	} else {
	setJustification(StyleConstants.ALIGN_LEFT);
	}
	}

	/**
	* Fetch the constraining span to flow against for
	* the given child index.
	*/
	public int getFlowSpan(int index) {
	Component c = getContainer();
	if (c instanceof JTextArea) {
	JTextArea area = (JTextArea) c;
	if (! area.getLineWrap()) {
	// no limit if unwrapped
	return Integer.MAX_VALUE;
	}
	}
	return super.getFlowSpan(index);
	}

	protected SizeRequirements calculateMinorAxisRequirements(int axis,
	SizeRequirements r) {
	SizeRequirements req = super.calculateMinorAxisRequirements(axis, r);
	Component c = getContainer();
	if (c instanceof JTextArea) {
	JTextArea area = (JTextArea) c;
	if (! area.getLineWrap()) {
	// min is pref if unwrapped
	req.minimum = req.preferred;
	} else {
	req.minimum = 0;
	req.preferred = getWidth();
	if (req.preferred == Integer.MAX_VALUE) {
	// We have been initially set to MAX_VALUE, but we
	// don't want this as our preferred.
	req.preferred = 100;
	}
	}
	}
	return req;
	}

	/**
	* Sets the size of the view. If the size has changed, layout
	* is redone. The size is the full size of the view including
	* the inset areas.
	*
	* @param width the width >= 0
	* @param height the height >= 0
	*/
	public void setSize(float width, float height) {
	if ((int) width != getWidth()) {
	preferenceChanged(null, true, true);
	}
	super.setSize(width, height);
	}

	/**
	* This class can be used to represent a logical view for
	* a flow. It keeps the children updated to reflect the state
	* of the model, gives the logical child views access to the
	* view hierarchy, and calculates a preferred span. It doesn't
	* do any rendering, layout, or model/view translation.
	*/
	static class LogicalView extends CompositeView {

	LogicalView(Element elem) {
	super(elem);
	}

	protected int getViewIndexAtPosition(int pos) {
	Element elem = getElement();
	if (elem.getElementCount() > 0) {
	return elem.getElementIndex(pos);
	}
	return 0;
	}

	protected boolean updateChildren(DocumentEvent.ElementChange ec,
	DocumentEvent e, ViewFactory f) {
	return false;
	}

	protected void loadChildren(ViewFactory f) {
	Element elem = getElement();
	if (elem.getElementCount() > 0) {
	super.loadChildren(f);
	} else {
	View v = new GlyphView(elem);
	append(v);
	}
	}

	public float getPreferredSpan(int axis) {
	if( getViewCount() != 1 )
	throw new Error("One child view is assumed.");

	View v = getView(0);
	return v.getPreferredSpan(axis);
	}

	/**
	* Forward the DocumentEvent to the given child view. This
	* is implemented to reparent the child to the logical view
	* (the children may have been parented by a row in the flow
	* if they fit without breaking) and then execute the superclass
	* behavior.
	*
	* @param v the child view to forward the event to.
	* @param e 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 #forwardUpdate
	* @since 1.3
	*/
	protected void forwardUpdateToView(View v, DocumentEvent e,
	Shape a, ViewFactory f) {
	v.setParent(this);
	super.forwardUpdateToView(v, e, a, f);
	}

	// The following methods don't do anything useful, they
	// simply keep the class from being abstract.

	public void paint(Graphics g, Shape allocation) {
	}

	protected boolean isBefore(int x, int y, Rectangle alloc) {
	return false;
	}

	protected boolean isAfter(int x, int y, Rectangle alloc) {
	return false;
	}

	protected View getViewAtPoint(int x, int y, Rectangle alloc) {
	return null;
	}

	protected void childAllocation(int index, Rectangle a) {
	}
	}
	}

	}

Back to index...