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.text;

	import java.awt.*;
	import java.beans.PropertyChangeEvent;
	import java.beans.PropertyChangeListener;
	import java.util.Set;
	import javax.swing.SwingUtilities;
	import javax.swing.event.*;

	/**
	* Component decorator that implements the view interface. The
	* entire element is used to represent the component. This acts
	* as a gateway from the display-only View implementations to
	* interactive lightweight components (ie it allows components
	* to be embedded into the View hierarchy).
	* <p>
	* The component is placed relative to the text baseline
	* according to the value returned by
	* <code>Component.getAlignmentY</code>. For Swing components
	* this value can be conveniently set using the method
	* <code>JComponent.setAlignmentY</code>. For example, setting
	* a value of <code>0.75</code> will cause 75 percent of the
	* component to be above the baseline, and 25 percent of the
	* component to be below the baseline.
	* <p>
	* This class is implemented to do the extra work necessary to
	* work properly in the presence of multiple threads (i.e. from
	* asynchronous notification of model changes for example) by
	* ensuring that all component access is done on the event thread.
	* <p>
	* The component used is determined by the return value of the
	* createComponent method. The default implementation of this
	* method is to return the component held as an attribute of
	* the element (by calling StyleConstants.getComponent). A
	* limitation of this behavior is that the component cannot
	* be used by more than one text component (i.e. with a shared
	* model). Subclasses can remove this constraint by implementing
	* the createComponent to actually create a component based upon
	* some kind of specification contained in the attributes. The
	* ObjectView class in the html package is an example of a
	* ComponentView implementation that supports multiple component
	* views of a shared model.
	*
	* @author Timothy Prinzing
	*/
	public class ComponentView extends View {

	/**
	* Creates a new ComponentView object.
	*
	* @param elem the element to decorate
	*/
	public ComponentView(Element elem) {
	super(elem);
	}

	/**
	* Create the component that is associated with
	* this view. This will be called when it has
	* been determined that a new component is needed.
	* This would result from a call to setParent or
	* as a result of being notified that attributes
	* have changed.
	*/
	protected Component createComponent() {
	AttributeSet attr = getElement().getAttributes();
	Component comp = StyleConstants.getComponent(attr);
	return comp;
	}

	/**
	* Fetch the component associated with the view.
	*/
	public final Component getComponent() {
	return createdC;
	}

	// --- View methods ---------------------------------------------

	/**
	* The real paint behavior occurs naturally from the association
	* that the component has with its parent container (the same
	* container hosting this view). This is implemented to do nothing.
	*
	* @param g the graphics context
	* @param a the shape
	* @see View#paint
	*/
	public void paint(Graphics g, Shape a) {
	if (c != null) {
	Rectangle alloc = (a instanceof Rectangle) ?
	(Rectangle) a : a.getBounds();
	c.setBounds(alloc.x, alloc.y, alloc.width, alloc.height);
	}
	}

	/**
	* Determines the preferred span for this view along an
	* axis. This is implemented to return the value
	* returned by Component.getPreferredSize along the
	* axis of interest.
	*
	* @param axis may be either View.X_AXIS or View.Y_AXIS
	* @return the span the view would like to be rendered into >=0.
	* Typically the view is told to render into the span
	* that is returned, although there is no guarantee.
	* The parent may choose to resize or break the view.
	* @exception IllegalArgumentException for an invalid axis
	*/
	public float getPreferredSpan(int axis) {
	if ((axis != X_AXIS) && (axis != Y_AXIS)) {
	throw new IllegalArgumentException("Invalid axis: " + axis);
	}
	if (c != null) {
	Dimension size = c.getPreferredSize();
	if (axis == View.X_AXIS) {
	return size.width;
	} else {
	return size.height;
	}
	}
	return 0;
	}

	/**
	* Determines the minimum span for this view along an
	* axis. This is implemented to return the value
	* returned by Component.getMinimumSize along the
	* axis of interest.
	*
	* @param axis may be either View.X_AXIS or View.Y_AXIS
	* @return the span the view would like to be rendered into >=0.
	* Typically the view is told to render into the span
	* that is returned, although there is no guarantee.
	* The parent may choose to resize or break the view.
	* @exception IllegalArgumentException for an invalid axis
	*/
	public float getMinimumSpan(int axis) {
	if ((axis != X_AXIS) && (axis != Y_AXIS)) {
	throw new IllegalArgumentException("Invalid axis: " + axis);
	}
	if (c != null) {
	Dimension size = c.getMinimumSize();
	if (axis == View.X_AXIS) {
	return size.width;
	} else {
	return size.height;
	}
	}
	return 0;
	}

	/**
	* Determines the maximum span for this view along an
	* axis. This is implemented to return the value
	* returned by Component.getMaximumSize along the
	* axis of interest.
	*
	* @param axis may be either View.X_AXIS or View.Y_AXIS
	* @return the span the view would like to be rendered into >=0.
	* Typically the view is told to render into the span
	* that is returned, although there is no guarantee.
	* The parent may choose to resize or break the view.
	* @exception IllegalArgumentException for an invalid axis
	*/
	public float getMaximumSpan(int axis) {
	if ((axis != X_AXIS) && (axis != Y_AXIS)) {
	throw new IllegalArgumentException("Invalid axis: " + axis);
	}
	if (c != null) {
	Dimension size = c.getMaximumSize();
	if (axis == View.X_AXIS) {
	return size.width;
	} else {
	return size.height;
	}
	}
	return 0;
	}

	/**
	* Determines the desired alignment for this view along an
	* axis. This is implemented to give the alignment of the
	* embedded component.
	*
	* @param axis may be either View.X_AXIS or View.Y_AXIS
	* @return the desired alignment. This should be a value
	* between 0.0 and 1.0 where 0 indicates alignment at the
	* origin and 1.0 indicates alignment to the full span
	* away from the origin. An alignment of 0.5 would be the
	* center of the view.
	*/
	public float getAlignment(int axis) {
	if (c != null) {
	switch (axis) {
	case View.X_AXIS:
	return c.getAlignmentX();
	case View.Y_AXIS:
	return c.getAlignmentY();
	}
	}
	return super.getAlignment(axis);
	}

	/**
	* Sets the parent for a child view.
	* The parent calls this on the child to tell it who its
	* parent is, giving the view access to things like
	* the hosting Container. The superclass behavior is
	* executed, followed by a call to createComponent if
	* the parent view parameter is non-null and a component
	* has not yet been created. The embedded components parent
	* is then set to the value returned by <code>getContainer</code>.
	* If the parent view parameter is null, this view is being
	* cleaned up, thus the component is removed from its parent.
	* <p>
	* The changing of the component hierarchy will
	* touch the component lock, which is the one thing
	* that is not safe from the View hierarchy. Therefore,
	* this functionality is executed immediately if on the
	* event thread, or is queued on the event queue if
	* called from another thread (notification of change
	* from an asynchronous update).
	*
	* @param p the parent
	*/
	public void setParent(View p) {
	super.setParent(p);
	if (SwingUtilities.isEventDispatchThread()) {
	setComponentParent();
	} else {
	Runnable callSetComponentParent = new Runnable() {
	public void run() {
	Document doc = getDocument();
	try {
	if (doc instanceof AbstractDocument) {
	((AbstractDocument)doc).readLock();
	}
	setComponentParent();
	Container host = getContainer();
	if (host != null) {
	preferenceChanged(null, true, true);
	host.repaint();
	}
	} finally {
	if (doc instanceof AbstractDocument) {
	((AbstractDocument)doc).readUnlock();
	}
	}
	}
	};
	SwingUtilities.invokeLater(callSetComponentParent);
	}
	}

	/**
	* Set the parent of the embedded component
	* with assurance that it is thread-safe.
	*/
	void setComponentParent() {
	View p = getParent();
	if (p != null) {
	Container parent = getContainer();
	if (parent != null) {
	if (c == null) {
	// try to build a component
	Component comp = createComponent();
	if (comp != null) {
	createdC = comp;
	c = new Invalidator(comp);
	}
	}
	if (c != null) {
	if (c.getParent() == null) {
	// components associated with the View tree are added
	// to the hosting container with the View as a constraint.
	parent.add(c, this);
	parent.addPropertyChangeListener("enabled", c);
	}
	}
	}
	} else {
	if (c != null) {
	Container parent = c.getParent();
	if (parent != null) {
	// remove the component from its hosting container
	parent.remove(c);
	parent.removePropertyChangeListener("enabled", c);
	}
	}
	}
	}

	/**
	* Provides a mapping from the coordinate space of the model to
	* that of the view.
	*
	* @param pos the position to convert >=0
	* @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
	* @see View#modelToView
	*/
	public Shape modelToView(int pos, Shape a, Position.Bias b) throws BadLocationException {
	int p0 = getStartOffset();
	int p1 = getEndOffset();
	if ((pos >= p0) && (pos <= p1)) {
	Rectangle r = a.getBounds();
	if (pos == p1) {
	r.x += r.width;
	}
	r.width = 0;
	return r;
	}
	throw new BadLocationException(pos + " not in range " + p0 + "," + p1, pos);
	}

	/**
	* Provides a mapping from the view coordinate space to the logical
	* coordinate space of the model.
	*
	* @param x the X coordinate >=0
	* @param y the Y coordinate >=0
	* @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 x, float y, Shape a, Position.Bias[] bias) {
	Rectangle alloc = (Rectangle) a;
	if (x < alloc.x + (alloc.width / 2)) {
	bias[0] = Position.Bias.Forward;
	return getStartOffset();
	}
	bias[0] = Position.Bias.Backward;
	return getEndOffset();
	}

	// --- member variables ------------------------------------------------

	private Component createdC;
	private Invalidator c;

	/**
	* This class feeds the invalidate back to the
	* hosting View. This is needed to get the View
	* hierarchy to consider giving the component
	* a different size (i.e. layout may have been
	* cached between the associated view and the
	* container hosting this component).
	*/
	class Invalidator extends Container implements PropertyChangeListener {

	// NOTE: When we remove this class we are going to have to some
	// how enforce setting of the focus traversal keys on the children
	// so that they don't inherit them from the JEditorPane. We need
	// to do this as JEditorPane has abnormal bindings (it is a focus cycle
	// root) and the children typically don't want these bindings as well.

	Invalidator(Component child) {
	setLayout(null);
	add(child);
	cacheChildSizes();
	}

	/**
	* The components invalid layout needs
	* to be propagated through the view hierarchy
	* so the views (which position the component)
	* can have their layout recomputed.
	*/
	public void invalidate() {
	super.invalidate();
	if (getParent() != null) {
	preferenceChanged(null, true, true);
	}
	}

	public void doLayout() {
	cacheChildSizes();
	}

	public void setBounds(int x, int y, int w, int h) {
	super.setBounds(x, y, w, h);
	if (getComponentCount() > 0) {
	getComponent(0).setSize(w, h);
	}
	cacheChildSizes();
	}

	public void validateIfNecessary() {
	if (!isValid()) {
	validate();
	}
	}

	private void cacheChildSizes() {
	if (getComponentCount() > 0) {
	Component child = getComponent(0);
	min = child.getMinimumSize();
	pref = child.getPreferredSize();
	max = child.getMaximumSize();
	yalign = child.getAlignmentY();
	xalign = child.getAlignmentX();
	} else {
	min = pref = max = new Dimension(0, 0);
	}
	}

	/**
	* Shows or hides this component depending on the value of parameter
	* <code>b</code>.
	* @param b If <code>true</code>, shows this component;
	* otherwise, hides this component.
	* @see #isVisible
	* @since JDK1.1
	*/
	public void setVisible(boolean b) {
	super.setVisible(b);
	if (getComponentCount() > 0) {
	getComponent(0).setVisible(b);
	}
	}

	/**
	* Overridden to fix 4759054. Must return true so that content
	* is painted when inside a CellRendererPane which is normally
	* invisible.
	*/
	public boolean isShowing() {
	return true;
	}

	public Dimension getMinimumSize() {
	validateIfNecessary();
	return min;
	}

	public Dimension getPreferredSize() {
	validateIfNecessary();
	return pref;
	}

	public Dimension getMaximumSize() {
	validateIfNecessary();
	return max;
	}

	public float getAlignmentX() {
	validateIfNecessary();
	return xalign;
	}

	public float getAlignmentY() {
	validateIfNecessary();
	return yalign;
	}

	public Set<AWTKeyStroke> getFocusTraversalKeys(int id) {
	return KeyboardFocusManager.getCurrentKeyboardFocusManager().
	getDefaultFocusTraversalKeys(id);
	}

	public void propertyChange(PropertyChangeEvent ev) {
	Boolean enable = (Boolean) ev.getNewValue();
	if (getComponentCount() > 0) {
	getComponent(0).setEnabled(enable);
	}
	}

	Dimension min;
	Dimension pref;
	Dimension max;
	float yalign;
	float xalign;

	}

	}

Back to index...