| /* |
| * Copyright (c) 1997, 2008, 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; |
| |
| } |
| |
| } |
