| /* BasicTextUI.java -- | |
| Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. | |
| This file is part of GNU Classpath. | |
| GNU Classpath is free software; you can redistribute it and/or modify | |
| it under the terms of the GNU General Public License as published by | |
| the Free Software Foundation; either version 2, or (at your option) | |
| any later version. | |
| GNU Classpath 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 for more details. | |
| You should have received a copy of the GNU General Public License | |
| along with GNU Classpath; see the file COPYING. If not, write to the | |
| Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA | |
| 02110-1301 USA. | |
| Linking this library statically or dynamically with other modules is | |
| making a combined work based on this library. Thus, the terms and | |
| conditions of the GNU General Public License cover the whole | |
| combination. | |
| As a special exception, the copyright holders of this library give you | |
| permission to link this library with independent modules to produce an | |
| executable, regardless of the license terms of these independent | |
| modules, and to copy and distribute the resulting executable under | |
| terms of your choice, provided that you also meet, for each linked | |
| independent module, the terms and conditions of the license of that | |
| module. An independent module is a module which is not derived from | |
| or based on this library. If you modify this library, you may extend | |
| this exception to your version of the library, but you are not | |
| obligated to do so. If you do not wish to do so, delete this | |
| exception statement from your version. */ | |
| package javax.swing.plaf.basic; | |
| import gnu.classpath.SystemProperties; | |
| import java.awt.Color; | |
| import java.awt.Container; | |
| import java.awt.Dimension; | |
| import java.awt.Graphics; | |
| import java.awt.HeadlessException; | |
| import java.awt.Insets; | |
| import java.awt.Point; | |
| import java.awt.Rectangle; | |
| import java.awt.Shape; | |
| import java.awt.Toolkit; | |
| import java.awt.datatransfer.Clipboard; | |
| import java.awt.datatransfer.StringSelection; | |
| import java.awt.event.FocusEvent; | |
| import java.awt.event.FocusListener; | |
| import java.beans.PropertyChangeEvent; | |
| import java.beans.PropertyChangeListener; | |
| import javax.swing.Action; | |
| import javax.swing.ActionMap; | |
| import javax.swing.InputMap; | |
| import javax.swing.JComponent; | |
| import javax.swing.LookAndFeel; | |
| import javax.swing.SwingConstants; | |
| import javax.swing.SwingUtilities; | |
| import javax.swing.TransferHandler; | |
| import javax.swing.UIManager; | |
| import javax.swing.event.DocumentEvent; | |
| import javax.swing.event.DocumentListener; | |
| import javax.swing.plaf.ActionMapUIResource; | |
| import javax.swing.plaf.InputMapUIResource; | |
| import javax.swing.plaf.TextUI; | |
| import javax.swing.plaf.UIResource; | |
| import javax.swing.text.AbstractDocument; | |
| import javax.swing.text.AttributeSet; | |
| import javax.swing.text.BadLocationException; | |
| import javax.swing.text.Caret; | |
| import javax.swing.text.DefaultCaret; | |
| import javax.swing.text.DefaultEditorKit; | |
| import javax.swing.text.DefaultHighlighter; | |
| import javax.swing.text.Document; | |
| import javax.swing.text.EditorKit; | |
| import javax.swing.text.Element; | |
| import javax.swing.text.Highlighter; | |
| import javax.swing.text.JTextComponent; | |
| import javax.swing.text.Keymap; | |
| import javax.swing.text.Position; | |
| import javax.swing.text.View; | |
| import javax.swing.text.ViewFactory; | |
| /** | |
| * The abstract base class from which the UI classes for Swings text | |
| * components are derived. This provides most of the functionality for | |
| * the UI classes. | |
| * | |
| * @author original author unknown | |
| * @author Roman Kennke (roman@kennke.org) | |
| */ | |
| public abstract class BasicTextUI extends TextUI | |
| implements ViewFactory | |
| { | |
| /** | |
| * A {@link DefaultCaret} that implements {@link UIResource}. | |
| */ | |
| public static class BasicCaret extends DefaultCaret implements UIResource | |
| { | |
| public BasicCaret() | |
| { | |
| // Nothing to do here. | |
| } | |
| } | |
| /** | |
| * A {@link DefaultHighlighter} that implements {@link UIResource}. | |
| */ | |
| public static class BasicHighlighter extends DefaultHighlighter | |
| implements UIResource | |
| { | |
| public BasicHighlighter() | |
| { | |
| // Nothing to do here. | |
| } | |
| } | |
| private static class FocusHandler | |
| implements FocusListener | |
| { | |
| public void focusGained(FocusEvent e) | |
| { | |
| // Nothing to do here. | |
| } | |
| public void focusLost(FocusEvent e) | |
| { | |
| JTextComponent textComponent = (JTextComponent) e.getComponent(); | |
| // Integrates Swing text components with the system clipboard: | |
| // The idea is that if one wants to copy text around X11-style | |
| // (select text and middle-click in the target component) the focus | |
| // will move to the new component which gives the old focus owner the | |
| // possibility to paste its selection into the clipboard. | |
| if (!e.isTemporary() | |
| && textComponent.getSelectionStart() | |
| != textComponent.getSelectionEnd()) | |
| { | |
| SecurityManager sm = System.getSecurityManager(); | |
| try | |
| { | |
| if (sm != null) | |
| sm.checkSystemClipboardAccess(); | |
| Clipboard cb = Toolkit.getDefaultToolkit().getSystemSelection(); | |
| if (cb != null) | |
| { | |
| StringSelection selection = new StringSelection( | |
| textComponent.getSelectedText()); | |
| cb.setContents(selection, selection); | |
| } | |
| } | |
| catch (SecurityException se) | |
| { | |
| // Not allowed to access the clipboard: Ignore and | |
| // do not access it. | |
| } | |
| catch (HeadlessException he) | |
| { | |
| // There is no AWT: Ignore and do not access the | |
| // clipboard. | |
| } | |
| catch (IllegalStateException ise) | |
| { | |
| // Clipboard is currently unavaible. | |
| } | |
| } | |
| } | |
| } | |
| /** | |
| * This FocusListener triggers repaints on focus shift. | |
| */ | |
| private static FocusListener focusListener; | |
| /** | |
| * Receives notifications when properties of the text component change. | |
| */ | |
| private class Handler | |
| implements PropertyChangeListener, DocumentListener | |
| { | |
| /** | |
| * Notifies when a property of the text component changes. | |
| * | |
| * @param event the PropertyChangeEvent describing the change | |
| */ | |
| public void propertyChange(PropertyChangeEvent event) | |
| { | |
| if (event.getPropertyName().equals("document")) | |
| { | |
| // Document changed. | |
| Object oldValue = event.getOldValue(); | |
| if (oldValue != null) | |
| { | |
| Document oldDoc = (Document) oldValue; | |
| oldDoc.removeDocumentListener(handler); | |
| } | |
| Object newValue = event.getNewValue(); | |
| if (newValue != null) | |
| { | |
| Document newDoc = (Document) newValue; | |
| newDoc.addDocumentListener(handler); | |
| } | |
| modelChanged(); | |
| } | |
| BasicTextUI.this.propertyChange(event); | |
| } | |
| /** | |
| * Notification about a document change event. | |
| * | |
| * @param ev the DocumentEvent describing the change | |
| */ | |
| public void changedUpdate(DocumentEvent ev) | |
| { | |
| // Updates are forwarded to the View even if 'getVisibleEditorRect' | |
| // method returns null. This means the View classes have to be | |
| // aware of that possibility. | |
| rootView.changedUpdate(ev, getVisibleEditorRect(), | |
| rootView.getViewFactory()); | |
| } | |
| /** | |
| * Notification about a document insert event. | |
| * | |
| * @param ev the DocumentEvent describing the insertion | |
| */ | |
| public void insertUpdate(DocumentEvent ev) | |
| { | |
| // Updates are forwarded to the View even if 'getVisibleEditorRect' | |
| // method returns null. This means the View classes have to be | |
| // aware of that possibility. | |
| rootView.insertUpdate(ev, getVisibleEditorRect(), | |
| rootView.getViewFactory()); | |
| } | |
| /** | |
| * Notification about a document removal event. | |
| * | |
| * @param ev the DocumentEvent describing the removal | |
| */ | |
| public void removeUpdate(DocumentEvent ev) | |
| { | |
| // Updates are forwarded to the View even if 'getVisibleEditorRect' | |
| // method returns null. This means the View classes have to be | |
| // aware of that possibility. | |
| rootView.removeUpdate(ev, getVisibleEditorRect(), | |
| rootView.getViewFactory()); | |
| } | |
| } | |
| /** | |
| * This view forms the root of the View hierarchy. However, it delegates | |
| * most calls to another View which is the real root of the hierarchy. | |
| * The purpose is to make sure that all Views in the hierarchy, including | |
| * the (real) root have a well-defined parent to which they can delegate | |
| * calls like {@link #preferenceChanged}, {@link #getViewFactory} and | |
| * {@link #getContainer}. | |
| */ | |
| private class RootView extends View | |
| { | |
| /** The real root view. */ | |
| private View view; | |
| /** | |
| * Creates a new RootView. | |
| */ | |
| public RootView() | |
| { | |
| super(null); | |
| } | |
| /** | |
| * Returns the ViewFactory for this RootView. If the current EditorKit | |
| * provides a ViewFactory, this is used. Otherwise the TextUI itself | |
| * is returned as a ViewFactory. | |
| * | |
| * @return the ViewFactory for this RootView | |
| */ | |
| public ViewFactory getViewFactory() | |
| { | |
| ViewFactory factory = null; | |
| EditorKit editorKit = BasicTextUI.this.getEditorKit(getComponent()); | |
| factory = editorKit.getViewFactory(); | |
| if (factory == null) | |
| factory = BasicTextUI.this; | |
| return factory; | |
| } | |
| /** | |
| * Indicates that the preferences of one of the child view has changed. | |
| * This calls revalidate on the text component. | |
| * | |
| * @param v the child view which's preference has changed | |
| * @param width <code>true</code> if the width preference has changed | |
| * @param height <code>true</code> if the height preference has changed | |
| */ | |
| public void preferenceChanged(View v, boolean width, boolean height) | |
| { | |
| textComponent.revalidate(); | |
| } | |
| /** | |
| * Sets the real root view. | |
| * | |
| * @param v the root view to set | |
| */ | |
| public void setView(View v) | |
| { | |
| if (view != null) | |
| view.setParent(null); | |
| if (v != null) | |
| v.setParent(this); | |
| view = v; | |
| } | |
| /** | |
| * Returns the real root view, regardless of the index. | |
| * | |
| * @param index not used here | |
| * | |
| * @return the real root view, regardless of the index. | |
| */ | |
| public View getView(int index) | |
| { | |
| return view; | |
| } | |
| /** | |
| * Returns <code>1</code> since the RootView always contains one | |
| * child, that is the real root of the View hierarchy. | |
| * | |
| * @return <code>1</code> since the RootView always contains one | |
| * child, that is the real root of the View hierarchy | |
| */ | |
| public int getViewCount() | |
| { | |
| int count = 0; | |
| if (view != null) | |
| count = 1; | |
| return count; | |
| } | |
| /** | |
| * Returns the <code>Container</code> that contains this view. This | |
| * normally will be the text component that is managed by this TextUI. | |
| * | |
| * @return the <code>Container</code> that contains this view | |
| */ | |
| public Container getContainer() | |
| { | |
| return textComponent; | |
| } | |
| /** | |
| * Sets the size of the renderer. This is synchronized because that | |
| * potentially triggers layout and we don't want more than one thread | |
| * playing with the layout information. | |
| */ | |
| public synchronized void setSize(float w, float h) | |
| { | |
| if (view != null) | |
| view.setSize(w, h); | |
| } | |
| /** | |
| * Paints the view. This is delegated to the real root view. | |
| * | |
| * @param g the <code>Graphics</code> context to paint to | |
| * @param s the allocation for the View | |
| */ | |
| public void paint(Graphics g, Shape s) | |
| { | |
| if (view != null) | |
| { | |
| Rectangle b = s instanceof Rectangle ? (Rectangle) s : s.getBounds(); | |
| setSize(b.width, b.height); | |
| view.paint(g, s); | |
| } | |
| } | |
| /** | |
| * Maps a position in the document into the coordinate space of the View. | |
| * The output rectangle usually reflects the font height but has a width | |
| * of zero. | |
| * | |
| * This is delegated to the real root view. | |
| * | |
| * @param position the position of the character in the model | |
| * @param a the area that is occupied by the view | |
| * @param bias either {@link Position.Bias#Forward} or | |
| * {@link Position.Bias#Backward} depending on the preferred | |
| * direction bias. If <code>null</code> this defaults to | |
| * <code>Position.Bias.Forward</code> | |
| * | |
| * @return a rectangle that gives the location of the document position | |
| * inside the view coordinate space | |
| * | |
| * @throws BadLocationException if <code>pos</code> is invalid | |
| * @throws IllegalArgumentException if b is not one of the above listed | |
| * valid values | |
| */ | |
| public Shape modelToView(int position, Shape a, Position.Bias bias) | |
| throws BadLocationException | |
| { | |
| return view.modelToView(position, a, bias); | |
| } | |
| /** | |
| * Maps coordinates from the <code>View</code>'s space into a position | |
| * in the document model. | |
| * | |
| * @param x the x coordinate in the view space | |
| * @param y the y coordinate in the view space | |
| * @param a the allocation of this <code>View</code> | |
| * @param b the bias to use | |
| * | |
| * @return the position in the document that corresponds to the screen | |
| * coordinates <code>x, y</code> | |
| */ | |
| public int viewToModel(float x, float y, Shape a, Position.Bias[] b) | |
| { | |
| return view.viewToModel(x, y, a, b); | |
| } | |
| /** | |
| * Notification about text insertions. These are forwarded to the | |
| * real root view. | |
| * | |
| * @param ev the DocumentEvent describing the change | |
| * @param shape the current allocation of the view's display | |
| * @param vf the ViewFactory to use for creating new Views | |
| */ | |
| public void insertUpdate(DocumentEvent ev, Shape shape, ViewFactory vf) | |
| { | |
| if (view != null) | |
| view.insertUpdate(ev, shape, vf); | |
| } | |
| /** | |
| * Notification about text removals. These are forwarded to the | |
| * real root view. | |
| * | |
| * @param ev the DocumentEvent describing the change | |
| * @param shape the current allocation of the view's display | |
| * @param vf the ViewFactory to use for creating new Views | |
| */ | |
| public void removeUpdate(DocumentEvent ev, Shape shape, ViewFactory vf) | |
| { | |
| if (view != null) | |
| view.removeUpdate(ev, shape, vf); | |
| } | |
| /** | |
| * Notification about text changes. These are forwarded to the | |
| * real root view. | |
| * | |
| * @param ev the DocumentEvent describing the change | |
| * @param shape the current allocation of the view's display | |
| * @param vf the ViewFactory to use for creating new Views | |
| */ | |
| public void changedUpdate(DocumentEvent ev, Shape shape, ViewFactory vf) | |
| { | |
| if (view != null) | |
| view.changedUpdate(ev, shape, vf); | |
| } | |
| /** | |
| * Returns the document position that is (visually) nearest to the given | |
| * document position <code>pos</code> in the given direction <code>d</code>. | |
| * | |
| * @param pos the document position | |
| * @param b the bias for <code>pos</code> | |
| * @param a the allocation for the view | |
| * @param d the direction, must be either {@link SwingConstants#NORTH}, | |
| * {@link SwingConstants#SOUTH}, {@link SwingConstants#WEST} or | |
| * {@link SwingConstants#EAST} | |
| * @param biasRet an array of {@link Position.Bias} that can hold at least | |
| * one element, which is filled with the bias of the return position | |
| * on method exit | |
| * | |
| * @return the document position that is (visually) nearest to the given | |
| * document position <code>pos</code> in the given direction | |
| * <code>d</code> | |
| * | |
| * @throws BadLocationException if <code>pos</code> is not a valid offset in | |
| * the document model | |
| */ | |
| public int getNextVisualPositionFrom(int pos, Position.Bias b, Shape a, | |
| int d, Position.Bias[] biasRet) | |
| throws BadLocationException | |
| { | |
| return view.getNextVisualPositionFrom(pos, b, a, d, biasRet); | |
| } | |
| /** | |
| * Returns the startOffset of this view, which is always the beginning | |
| * of the document. | |
| * | |
| * @return the startOffset of this view | |
| */ | |
| public int getStartOffset() | |
| { | |
| return 0; | |
| } | |
| /** | |
| * Returns the endOffset of this view, which is always the end | |
| * of the document. | |
| * | |
| * @return the endOffset of this view | |
| */ | |
| public int getEndOffset() | |
| { | |
| return getDocument().getLength(); | |
| } | |
| /** | |
| * Returns the document associated with this view. | |
| * | |
| * @return the document associated with this view | |
| */ | |
| public Document getDocument() | |
| { | |
| return textComponent.getDocument(); | |
| } | |
| /** | |
| * Returns the attributes, which is null for the RootView. | |
| */ | |
| public AttributeSet getAttributes() | |
| { | |
| return null; | |
| } | |
| /** | |
| * Overridden to forward to the view. | |
| */ | |
| public float getPreferredSpan(int axis) | |
| { | |
| // The RI returns 10 in the degenerate case. | |
| float span = 10; | |
| if (view != null) | |
| span = view.getPreferredSpan(axis); | |
| return span; | |
| } | |
| /** | |
| * Overridden to forward to the real view. | |
| */ | |
| public float getMinimumSpan(int axis) | |
| { | |
| // The RI returns 10 in the degenerate case. | |
| float span = 10; | |
| if (view != null) | |
| span = view.getMinimumSpan(axis); | |
| return span; | |
| } | |
| /** | |
| * Overridden to return Integer.MAX_VALUE. | |
| */ | |
| public float getMaximumSpan(int axis) | |
| { | |
| // The RI returns Integer.MAX_VALUE here, regardless of the real view's | |
| // maximum size. | |
| return Integer.MAX_VALUE; | |
| } | |
| } | |
| /** | |
| * The EditorKit used by this TextUI. | |
| */ | |
| private static EditorKit kit; | |
| /** | |
| * The combined event handler for text components. | |
| * | |
| * This is package private to avoid accessor methods. | |
| */ | |
| Handler handler; | |
| /** | |
| * The root view. | |
| * | |
| * This is package private to avoid accessor methods. | |
| */ | |
| RootView rootView; | |
| /** | |
| * The text component that we handle. | |
| */ | |
| JTextComponent textComponent; | |
| /** | |
| * Creates a new <code>BasicTextUI</code> instance. | |
| */ | |
| public BasicTextUI() | |
| { | |
| // Nothing to do here. | |
| } | |
| /** | |
| * Creates a {@link Caret} that should be installed into the text component. | |
| * | |
| * @return a caret that should be installed into the text component | |
| */ | |
| protected Caret createCaret() | |
| { | |
| return new BasicCaret(); | |
| } | |
| /** | |
| * Creates a {@link Highlighter} that should be installed into the text | |
| * component. | |
| * | |
| * @return a <code>Highlighter</code> for the text component | |
| */ | |
| protected Highlighter createHighlighter() | |
| { | |
| return new BasicHighlighter(); | |
| } | |
| /** | |
| * The text component that is managed by this UI. | |
| * | |
| * @return the text component that is managed by this UI | |
| */ | |
| protected final JTextComponent getComponent() | |
| { | |
| return textComponent; | |
| } | |
| /** | |
| * Installs this UI on the text component. | |
| * | |
| * @param c the text component on which to install the UI | |
| */ | |
| public void installUI(final JComponent c) | |
| { | |
| textComponent = (JTextComponent) c; | |
| if (rootView == null) | |
| rootView = new RootView(); | |
| installDefaults(); | |
| installFixedDefaults(); | |
| // These listeners must be installed outside of installListeners(), | |
| // because overriding installListeners() doesn't prevent installing | |
| // these in the RI, but overriding isntallUI() does. | |
| if (handler == null) | |
| handler = new Handler(); | |
| textComponent.addPropertyChangeListener(handler); | |
| Document doc = textComponent.getDocument(); | |
| if (doc == null) | |
| { | |
| // The Handler takes care of installing the necessary listeners | |
| // on the document here. | |
| doc = getEditorKit(textComponent).createDefaultDocument(); | |
| textComponent.setDocument(doc); | |
| } | |
| else | |
| { | |
| // Must install the document listener. | |
| doc.addDocumentListener(handler); | |
| modelChanged(); | |
| } | |
| installListeners(); | |
| installKeyboardActions(); | |
| } | |
| /** | |
| * Installs UI defaults on the text components. | |
| */ | |
| protected void installDefaults() | |
| { | |
| String prefix = getPropertyPrefix(); | |
| // Install the standard properties. | |
| LookAndFeel.installColorsAndFont(textComponent, prefix + ".background", | |
| prefix + ".foreground", prefix + ".font"); | |
| LookAndFeel.installBorder(textComponent, prefix + ".border"); | |
| // Some additional text component only properties. | |
| Color color = textComponent.getCaretColor(); | |
| if (color == null || color instanceof UIResource) | |
| { | |
| color = UIManager.getColor(prefix + ".caretForeground"); | |
| textComponent.setCaretColor(color); | |
| } | |
| // Fetch the colors for enabled/disabled text components. | |
| color = textComponent.getDisabledTextColor(); | |
| if (color == null || color instanceof UIResource) | |
| { | |
| color = UIManager.getColor(prefix + ".inactiveForeground"); | |
| textComponent.setDisabledTextColor(color); | |
| } | |
| color = textComponent.getSelectedTextColor(); | |
| if (color == null || color instanceof UIResource) | |
| { | |
| color = UIManager.getColor(prefix + ".selectionForeground"); | |
| textComponent.setSelectedTextColor(color); | |
| } | |
| color = textComponent.getSelectionColor(); | |
| if (color == null || color instanceof UIResource) | |
| { | |
| color = UIManager.getColor(prefix + ".selectionBackground"); | |
| textComponent.setSelectionColor(color); | |
| } | |
| Insets margin = textComponent.getMargin(); | |
| if (margin == null || margin instanceof UIResource) | |
| { | |
| margin = UIManager.getInsets(prefix + ".margin"); | |
| textComponent.setMargin(margin); | |
| } | |
| } | |
| /** | |
| * Installs defaults that can't be overridden by overriding | |
| * installDefaults(). | |
| */ | |
| private void installFixedDefaults() | |
| { | |
| String prefix = getPropertyPrefix(); | |
| Caret caret = textComponent.getCaret(); | |
| if (caret == null || caret instanceof UIResource) | |
| { | |
| caret = createCaret(); | |
| textComponent.setCaret(caret); | |
| caret.setBlinkRate(UIManager.getInt(prefix + ".caretBlinkRate")); | |
| } | |
| Highlighter highlighter = textComponent.getHighlighter(); | |
| if (highlighter == null || highlighter instanceof UIResource) | |
| textComponent.setHighlighter(createHighlighter()); | |
| } | |
| /** | |
| * Install all listeners on the text component. | |
| */ | |
| protected void installListeners() | |
| { | |
| // | |
| if (SystemProperties.getProperty("gnu.swing.text.no-xlike-clipboard") | |
| == null) | |
| { | |
| if (focusListener == null) | |
| focusListener = new FocusHandler(); | |
| textComponent.addFocusListener(focusListener); | |
| } | |
| } | |
| /** | |
| * Returns the name of the keymap for this type of TextUI. | |
| * | |
| * This is implemented so that the classname of this TextUI | |
| * without the package prefix is returned. This way subclasses | |
| * don't have to override this method. | |
| * | |
| * @return the name of the keymap for this TextUI | |
| */ | |
| protected String getKeymapName() | |
| { | |
| String fullClassName = getClass().getName(); | |
| int index = fullClassName.lastIndexOf('.'); | |
| String className = fullClassName.substring(index + 1); | |
| return className; | |
| } | |
| /** | |
| * Creates the {@link Keymap} that is installed on the text component. | |
| * | |
| * @return the {@link Keymap} that is installed on the text component | |
| */ | |
| protected Keymap createKeymap() | |
| { | |
| String keymapName = getKeymapName(); | |
| Keymap keymap = JTextComponent.getKeymap(keymapName); | |
| if (keymap == null) | |
| { | |
| Keymap parentMap = | |
| JTextComponent.getKeymap(JTextComponent.DEFAULT_KEYMAP); | |
| keymap = JTextComponent.addKeymap(keymapName, parentMap); | |
| Object val = UIManager.get(getPropertyPrefix() + ".keyBindings"); | |
| if (val != null && val instanceof JTextComponent.KeyBinding[]) | |
| { | |
| JTextComponent.KeyBinding[] bindings = | |
| (JTextComponent.KeyBinding[]) val; | |
| JTextComponent.loadKeymap(keymap, bindings, | |
| getComponent().getActions()); | |
| } | |
| } | |
| return keymap; | |
| } | |
| /** | |
| * Installs the keyboard actions on the text components. | |
| */ | |
| protected void installKeyboardActions() | |
| { | |
| // This is only there for backwards compatibility. | |
| textComponent.setKeymap(createKeymap()); | |
| // load any bindings for the newer InputMap / ActionMap interface | |
| SwingUtilities.replaceUIInputMap(textComponent, JComponent.WHEN_FOCUSED, | |
| getInputMap()); | |
| SwingUtilities.replaceUIActionMap(textComponent, getActionMap()); | |
| } | |
| /** | |
| * Creates an ActionMap to be installed on the text component. | |
| * | |
| * @return an ActionMap to be installed on the text component | |
| */ | |
| private ActionMap getActionMap() | |
| { | |
| // Note: There are no .actionMap entries in the standard L&Fs. However, | |
| // with the RI it is possible to install action maps via such keys, so | |
| // we must load them too. It can be observed that when there is no | |
| // .actionMap entry in the UIManager, one gets installed after a text | |
| // component of that type has been loaded. | |
| String prefix = getPropertyPrefix(); | |
| String amName = prefix + ".actionMap"; | |
| ActionMap am = (ActionMap) UIManager.get(amName); | |
| if (am == null) | |
| { | |
| am = createActionMap(); | |
| UIManager.put(amName, am); | |
| } | |
| ActionMap map = new ActionMapUIResource(); | |
| map.setParent(am); | |
| return map; | |
| } | |
| /** | |
| * Creates a default ActionMap for text components that have no UI default | |
| * for this (the standard for the built-in L&Fs). The ActionMap is copied | |
| * from the text component's getActions() method. | |
| * | |
| * @returna default ActionMap | |
| */ | |
| private ActionMap createActionMap() | |
| { | |
| ActionMap am = new ActionMapUIResource(); | |
| Action[] actions = textComponent.getActions(); | |
| for (int i = actions.length - 1; i >= 0; i--) | |
| { | |
| Action action = actions[i]; | |
| am.put(action.getValue(Action.NAME), action); | |
| } | |
| // Add TransferHandler's actions here. They don't seem to be in the | |
| // JTextComponent's default actions, and I can't make up a better place | |
| // to add them. | |
| Action copyAction = TransferHandler.getCopyAction(); | |
| am.put(copyAction.getValue(Action.NAME), copyAction); | |
| Action cutAction = TransferHandler.getCutAction(); | |
| am.put(cutAction.getValue(Action.NAME), cutAction); | |
| Action pasteAction = TransferHandler.getPasteAction(); | |
| am.put(pasteAction.getValue(Action.NAME), pasteAction); | |
| return am; | |
| } | |
| /** | |
| * Gets the input map for the specified <code>condition</code>. | |
| * | |
| * @return the InputMap for the specified condition | |
| */ | |
| private InputMap getInputMap() | |
| { | |
| InputMap im = new InputMapUIResource(); | |
| String prefix = getPropertyPrefix(); | |
| InputMap shared = | |
| (InputMap) SharedUIDefaults.get(prefix + ".focusInputMap"); | |
| if (shared != null) | |
| im.setParent(shared); | |
| return im; | |
| } | |
| /** | |
| * Uninstalls this TextUI from the text component. | |
| * | |
| * @param component the text component to uninstall the UI from | |
| */ | |
| public void uninstallUI(final JComponent component) | |
| { | |
| textComponent.removePropertyChangeListener(handler); | |
| textComponent.getDocument().removeDocumentListener(handler); | |
| rootView.setView(null); | |
| uninstallDefaults(); | |
| uninstallFixedDefaults(); | |
| uninstallListeners(); | |
| uninstallKeyboardActions(); | |
| textComponent = null; | |
| } | |
| /** | |
| * Uninstalls all default properties that have previously been installed by | |
| * this UI. | |
| */ | |
| protected void uninstallDefaults() | |
| { | |
| if (textComponent.getCaretColor() instanceof UIResource) | |
| textComponent.setCaretColor(null); | |
| if (textComponent.getSelectionColor() instanceof UIResource) | |
| textComponent.setSelectionColor(null); | |
| if (textComponent.getDisabledTextColor() instanceof UIResource) | |
| textComponent.setDisabledTextColor(null); | |
| if (textComponent.getSelectedTextColor() instanceof UIResource) | |
| textComponent.setSelectedTextColor(null); | |
| LookAndFeel.uninstallBorder(textComponent); | |
| if (textComponent.getMargin() instanceof UIResource) | |
| textComponent.setMargin(null); | |
| } | |
| /** | |
| * Uninstalls additional fixed defaults that were installed | |
| * by installFixedDefaults(). | |
| */ | |
| private void uninstallFixedDefaults() | |
| { | |
| if (textComponent.getCaret() instanceof UIResource) | |
| textComponent.setCaret(null); | |
| if (textComponent.getHighlighter() instanceof UIResource) | |
| textComponent.setHighlighter(null); | |
| } | |
| /** | |
| * Uninstalls all listeners that have previously been installed by | |
| * this UI. | |
| */ | |
| protected void uninstallListeners() | |
| { | |
| // Don't nullify the focusListener field, as it is static and shared | |
| // between components. | |
| if (focusListener != null) | |
| textComponent.removeFocusListener(focusListener); | |
| } | |
| /** | |
| * Uninstalls all keyboard actions that have previously been installed by | |
| * this UI. | |
| */ | |
| protected void uninstallKeyboardActions() | |
| { | |
| SwingUtilities.replaceUIInputMap(textComponent, JComponent.WHEN_FOCUSED, | |
| null); | |
| SwingUtilities.replaceUIActionMap(textComponent, null); | |
| } | |
| /** | |
| * Returns the property prefix by which the text component's UIDefaults | |
| * are looked up. | |
| * | |
| * @return the property prefix by which the text component's UIDefaults | |
| * are looked up | |
| */ | |
| protected abstract String getPropertyPrefix(); | |
| /** | |
| * Returns the preferred size of the text component. | |
| * | |
| * @param c not used here | |
| * | |
| * @return the preferred size of the text component | |
| */ | |
| public Dimension getPreferredSize(JComponent c) | |
| { | |
| Dimension d = c.getSize(); | |
| Insets i = c.getInsets(); | |
| // We need to lock here, since we require the view hierarchy to _not_ | |
| // change in between. | |
| float w; | |
| float h; | |
| Document doc = textComponent.getDocument(); | |
| if (doc instanceof AbstractDocument) | |
| ((AbstractDocument) doc).readLock(); | |
| try | |
| { | |
| if (d.width > (i.left + i.right) && d.height > (i.top + i.bottom)) | |
| { | |
| rootView.setSize(d.width - i.left - i.right, | |
| d.height - i.top - i.bottom); | |
| } | |
| else | |
| { | |
| // Not laid out yet. Force some pseudo size. | |
| rootView.setSize(Integer.MAX_VALUE, Integer.MAX_VALUE); | |
| } | |
| w = rootView.getPreferredSpan(View.X_AXIS); | |
| h = rootView.getPreferredSpan(View.Y_AXIS); | |
| } | |
| finally | |
| { | |
| if (doc instanceof AbstractDocument) | |
| ((AbstractDocument) doc).readUnlock(); | |
| } | |
| Dimension size = new Dimension((int) w + i.left + i.right, | |
| (int) h + i.top + i.bottom); | |
| return size; | |
| } | |
| /** | |
| * Returns the maximum size for text components that use this UI. | |
| * | |
| * This returns (Integer.MAX_VALUE, Integer.MAX_VALUE). | |
| * | |
| * @param c not used here | |
| * | |
| * @return the maximum size for text components that use this UI | |
| */ | |
| public Dimension getMaximumSize(JComponent c) | |
| { | |
| Dimension d = new Dimension(); | |
| Insets i = c.getInsets(); | |
| Document doc = textComponent.getDocument(); | |
| // We need to lock here, since we require the view hierarchy to _not_ | |
| // change in between. | |
| if (doc instanceof AbstractDocument) | |
| ((AbstractDocument) doc).readLock(); | |
| try | |
| { | |
| // Check for overflow here. | |
| d.width = (int) Math.min((long) rootView.getMaximumSpan(View.X_AXIS) | |
| + i.left + i.right, Integer.MAX_VALUE); | |
| d.height = (int) Math.min((long) rootView.getMaximumSpan(View.Y_AXIS) | |
| + i.top + i.bottom, Integer.MAX_VALUE); | |
| } | |
| finally | |
| { | |
| if (doc instanceof AbstractDocument) | |
| ((AbstractDocument) doc).readUnlock(); | |
| } | |
| return d; | |
| } | |
| /** | |
| * Returns the minimum size for text components. This returns the size | |
| * of the component's insets. | |
| * | |
| * @return the minimum size for text components | |
| */ | |
| public Dimension getMinimumSize(JComponent c) | |
| { | |
| Dimension d = new Dimension(); | |
| Document doc = textComponent.getDocument(); | |
| // We need to lock here, since we require the view hierarchy to _not_ | |
| // change in between. | |
| if (doc instanceof AbstractDocument) | |
| ((AbstractDocument) doc).readLock(); | |
| try | |
| { | |
| d.width = (int) rootView.getMinimumSpan(View.X_AXIS); | |
| d.height = (int) rootView.getMinimumSpan(View.Y_AXIS); | |
| } | |
| finally | |
| { | |
| if (doc instanceof AbstractDocument) | |
| ((AbstractDocument) doc).readUnlock(); | |
| } | |
| Insets i = c.getInsets(); | |
| d.width += i.left + i.right; | |
| d.height += i.top + i.bottom; | |
| return d; | |
| } | |
| /** | |
| * Paints the text component. This acquires a read lock on the model and then | |
| * calls {@link #paintSafely(Graphics)} in order to actually perform the | |
| * painting. | |
| * | |
| * @param g the <code>Graphics</code> context to paint to | |
| * @param c not used here | |
| */ | |
| public final void paint(Graphics g, JComponent c) | |
| { | |
| try | |
| { | |
| Document doc = textComponent.getDocument(); | |
| if (doc instanceof AbstractDocument) | |
| { | |
| AbstractDocument aDoc = (AbstractDocument) doc; | |
| aDoc.readLock(); | |
| } | |
| paintSafely(g); | |
| } | |
| finally | |
| { | |
| Document doc = textComponent.getDocument(); | |
| if (doc instanceof AbstractDocument) | |
| { | |
| AbstractDocument aDoc = (AbstractDocument) doc; | |
| aDoc.readUnlock(); | |
| } | |
| } | |
| } | |
| /** | |
| * This paints the text component while beeing sure that the model is not | |
| * modified while painting. | |
| * | |
| * The following is performed in this order: | |
| * <ol> | |
| * <li>If the text component is opaque, the background is painted by | |
| * calling {@link #paintBackground(Graphics)}.</li> | |
| * <li>If there is a highlighter, the highlighter is painted.</li> | |
| * <li>The view hierarchy is painted.</li> | |
| * <li>The Caret is painter.</li> | |
| * </ol> | |
| * | |
| * @param g the <code>Graphics</code> context to paint to | |
| */ | |
| protected void paintSafely(Graphics g) | |
| { | |
| Caret caret = textComponent.getCaret(); | |
| Highlighter highlighter = textComponent.getHighlighter(); | |
| if (textComponent.isOpaque()) | |
| paintBackground(g); | |
| // Try painting with the highlighter without checking whether there | |
| // is a selection because a highlighter can be used to do more than | |
| // marking selected text. | |
| if (highlighter != null) | |
| { | |
| // Handle restoring of the color here to prevent | |
| // drawing problems when the Highlighter implementor | |
| // forgets to restore it. | |
| Color oldColor = g.getColor(); | |
| highlighter.paint(g); | |
| g.setColor(oldColor); | |
| } | |
| rootView.paint(g, getVisibleEditorRect()); | |
| if (caret != null && textComponent.hasFocus()) | |
| caret.paint(g); | |
| } | |
| /** | |
| * Paints the background of the text component. | |
| * | |
| * @param g the <code>Graphics</code> context to paint to | |
| */ | |
| protected void paintBackground(Graphics g) | |
| { | |
| Color old = g.getColor(); | |
| g.setColor(textComponent.getBackground()); | |
| g.fillRect(0, 0, textComponent.getWidth(), textComponent.getHeight()); | |
| g.setColor(old); | |
| } | |
| /** | |
| * Overridden for better control over background painting. This now simply | |
| * calls {@link #paint} and this delegates the background painting to | |
| * {@link #paintBackground}. | |
| * | |
| * @param g the graphics to use | |
| * @param c the component to be painted | |
| */ | |
| public void update(Graphics g, JComponent c) | |
| { | |
| paint(g, c); | |
| } | |
| /** | |
| * Marks the specified range inside the text component's model as | |
| * damaged and queues a repaint request. | |
| * | |
| * @param t the text component | |
| * @param p0 the start location inside the document model of the range that | |
| * is damaged | |
| * @param p1 the end location inside the document model of the range that | |
| * is damaged | |
| */ | |
| public void damageRange(JTextComponent t, int p0, int p1) | |
| { | |
| damageRange(t, p0, p1, Position.Bias.Forward, Position.Bias.Backward); | |
| } | |
| /** | |
| * Marks the specified range inside the text component's model as | |
| * damaged and queues a repaint request. This variant of this method | |
| * allows a {@link Position.Bias} object to be specified for the start | |
| * and end location of the range. | |
| * | |
| * @param t the text component | |
| * @param p0 the start location inside the document model of the range that | |
| * is damaged | |
| * @param p1 the end location inside the document model of the range that | |
| * is damaged | |
| * @param firstBias the bias for the start location | |
| * @param secondBias the bias for the end location | |
| */ | |
| public void damageRange(JTextComponent t, int p0, int p1, | |
| Position.Bias firstBias, Position.Bias secondBias) | |
| { | |
| Rectangle alloc = getVisibleEditorRect(); | |
| if (alloc != null) | |
| { | |
| Document doc = t.getDocument(); | |
| // Acquire lock here to avoid structural changes in between. | |
| if (doc instanceof AbstractDocument) | |
| ((AbstractDocument) doc).readLock(); | |
| try | |
| { | |
| rootView.setSize(alloc.width, alloc.height); | |
| Shape damage = rootView.modelToView(p0, firstBias, p1, secondBias, | |
| alloc); | |
| Rectangle r = damage instanceof Rectangle ? (Rectangle) damage | |
| : damage.getBounds(); | |
| textComponent.repaint(r.x, r.y, r.width, r.height); | |
| } | |
| catch (BadLocationException ex) | |
| { | |
| // Lets ignore this as it causes no serious problems. | |
| // For debugging, comment this out. | |
| // ex.printStackTrace(); | |
| } | |
| finally | |
| { | |
| // Release lock. | |
| if (doc instanceof AbstractDocument) | |
| ((AbstractDocument) doc).readUnlock(); | |
| } | |
| } | |
| } | |
| /** | |
| * Returns the {@link EditorKit} used for the text component that is managed | |
| * by this UI. | |
| * | |
| * @param t the text component | |
| * | |
| * @return the {@link EditorKit} used for the text component that is managed | |
| * by this UI | |
| */ | |
| public EditorKit getEditorKit(JTextComponent t) | |
| { | |
| if (kit == null) | |
| kit = new DefaultEditorKit(); | |
| return kit; | |
| } | |
| /** | |
| * Gets the next position inside the document model that is visible on | |
| * screen, starting from <code>pos</code>. | |
| * | |
| * @param t the text component | |
| * @param pos the start positionn | |
| * @param b the bias for pos | |
| * @param direction the search direction | |
| * @param biasRet filled by the method to indicate the bias of the return | |
| * value | |
| * | |
| * @return the next position inside the document model that is visible on | |
| * screen | |
| */ | |
| public int getNextVisualPositionFrom(JTextComponent t, int pos, | |
| Position.Bias b, int direction, | |
| Position.Bias[] biasRet) | |
| throws BadLocationException | |
| { | |
| int offset = -1; | |
| Document doc = textComponent.getDocument(); | |
| if (doc instanceof AbstractDocument) | |
| ((AbstractDocument) doc).readLock(); | |
| try | |
| { | |
| Rectangle alloc = getVisibleEditorRect(); | |
| if (alloc != null) | |
| { | |
| rootView.setSize(alloc.width, alloc.height); | |
| offset = rootView.getNextVisualPositionFrom(pos, b, alloc, | |
| direction, biasRet); | |
| } | |
| } | |
| finally | |
| { | |
| if (doc instanceof AbstractDocument) | |
| ((AbstractDocument) doc).readUnlock(); | |
| } | |
| return offset; | |
| } | |
| /** | |
| * Returns the root {@link View} of a text component. | |
| * | |
| * @return the root {@link View} of a text component | |
| */ | |
| public View getRootView(JTextComponent t) | |
| { | |
| return rootView; | |
| } | |
| /** | |
| * Maps a position in the document into the coordinate space of the View. | |
| * The output rectangle usually reflects the font height but has a width | |
| * of zero. A bias of {@link Position.Bias#Forward} is used in this method. | |
| * | |
| * @param t the text component | |
| * @param pos the position of the character in the model | |
| * | |
| * @return a rectangle that gives the location of the document position | |
| * inside the view coordinate space | |
| * | |
| * @throws BadLocationException if <code>pos</code> is invalid | |
| * @throws IllegalArgumentException if b is not one of the above listed | |
| * valid values | |
| */ | |
| public Rectangle modelToView(JTextComponent t, int pos) | |
| throws BadLocationException | |
| { | |
| return modelToView(t, pos, Position.Bias.Forward); | |
| } | |
| /** | |
| * Maps a position in the document into the coordinate space of the View. | |
| * The output rectangle usually reflects the font height but has a width | |
| * of zero. | |
| * | |
| * @param t the text component | |
| * @param pos the position of the character in the model | |
| * @param bias either {@link Position.Bias#Forward} or | |
| * {@link Position.Bias#Backward} depending on the preferred | |
| * direction bias. If <code>null</code> this defaults to | |
| * <code>Position.Bias.Forward</code> | |
| * | |
| * @return a rectangle that gives the location of the document position | |
| * inside the view coordinate space | |
| * | |
| * @throws BadLocationException if <code>pos</code> is invalid | |
| * @throws IllegalArgumentException if b is not one of the above listed | |
| * valid values | |
| */ | |
| public Rectangle modelToView(JTextComponent t, int pos, Position.Bias bias) | |
| throws BadLocationException | |
| { | |
| // We need to read-lock here because we depend on the document | |
| // structure not beeing changed in between. | |
| Document doc = textComponent.getDocument(); | |
| if (doc instanceof AbstractDocument) | |
| ((AbstractDocument) doc).readLock(); | |
| Rectangle rect = null; | |
| try | |
| { | |
| Rectangle r = getVisibleEditorRect(); | |
| if (r != null) | |
| { | |
| rootView.setSize(r.width, r.height); | |
| Shape s = rootView.modelToView(pos, r, bias); | |
| if (s != null) | |
| rect = s.getBounds(); | |
| } | |
| } | |
| finally | |
| { | |
| if (doc instanceof AbstractDocument) | |
| ((AbstractDocument) doc).readUnlock(); | |
| } | |
| return rect; | |
| } | |
| /** | |
| * Maps a point in the <code>View</code> coordinate space to a position | |
| * inside a document model. | |
| * | |
| * @param t the text component | |
| * @param pt the point to be mapped | |
| * | |
| * @return the position inside the document model that corresponds to | |
| * <code>pt</code> | |
| */ | |
| public int viewToModel(JTextComponent t, Point pt) | |
| { | |
| return viewToModel(t, pt, new Position.Bias[1]); | |
| } | |
| /** | |
| * Maps a point in the <code>View</code> coordinate space to a position | |
| * inside a document model. | |
| * | |
| * @param t the text component | |
| * @param pt the point to be mapped | |
| * @param biasReturn filled in by the method to indicate the bias of the | |
| * return value | |
| * | |
| * @return the position inside the document model that corresponds to | |
| * <code>pt</code> | |
| */ | |
| public int viewToModel(JTextComponent t, Point pt, Position.Bias[] biasReturn) | |
| { | |
| int offset = -1; | |
| Document doc = textComponent.getDocument(); | |
| if (doc instanceof AbstractDocument) | |
| ((AbstractDocument) doc).readLock(); | |
| try | |
| { | |
| Rectangle alloc = getVisibleEditorRect(); | |
| if (alloc != null) | |
| { | |
| rootView.setSize(alloc.width, alloc.height); | |
| offset = rootView.viewToModel(pt.x, pt.y, alloc, biasReturn); | |
| } | |
| } | |
| finally | |
| { | |
| if (doc instanceof AbstractDocument) | |
| ((AbstractDocument) doc).readUnlock(); | |
| } | |
| return offset; | |
| } | |
| /** | |
| * Creates a {@link View} for the specified {@link Element}. | |
| * | |
| * @param elem the <code>Element</code> to create a <code>View</code> for | |
| * | |
| * @see ViewFactory | |
| */ | |
| public View create(Element elem) | |
| { | |
| // Subclasses have to implement this to get this functionality. | |
| return null; | |
| } | |
| /** | |
| * Creates a {@link View} for the specified {@link Element}. | |
| * | |
| * @param elem the <code>Element</code> to create a <code>View</code> for | |
| * @param p0 the start offset | |
| * @param p1 the end offset | |
| * | |
| * @see ViewFactory | |
| */ | |
| public View create(Element elem, int p0, int p1) | |
| { | |
| // Subclasses have to implement this to get this functionality. | |
| return null; | |
| } | |
| /** | |
| * A cached Insets instance to be reused below. | |
| */ | |
| private Insets cachedInsets; | |
| /** | |
| * Returns the allocation to give the root view. | |
| * | |
| * @return the allocation to give the root view | |
| * | |
| * @specnote The allocation has nothing to do with visibility. According | |
| * to the specs the naming of this method is unfortunate and | |
| * has historical reasons | |
| */ | |
| protected Rectangle getVisibleEditorRect() | |
| { | |
| int width = textComponent.getWidth(); | |
| int height = textComponent.getHeight(); | |
| // Return null if the component has no valid size. | |
| if (width <= 0 || height <= 0) | |
| return null; | |
| Insets insets = textComponent.getInsets(cachedInsets); | |
| return new Rectangle(insets.left, insets.top, | |
| width - insets.left - insets.right, | |
| height - insets.top - insets.bottom); | |
| } | |
| /** | |
| * Sets the root view for the text component. | |
| * | |
| * @param view the <code>View</code> to be set as root view | |
| */ | |
| protected final void setView(View view) | |
| { | |
| rootView.setView(view); | |
| textComponent.revalidate(); | |
| textComponent.repaint(); | |
| } | |
| /** | |
| * Indicates that the model of a text component has changed. This | |
| * triggers a rebuild of the view hierarchy. | |
| */ | |
| protected void modelChanged() | |
| { | |
| if (textComponent == null || rootView == null) | |
| return; | |
| ViewFactory factory = rootView.getViewFactory(); | |
| if (factory == null) | |
| return; | |
| Document doc = textComponent.getDocument(); | |
| if (doc == null) | |
| return; | |
| Element elem = doc.getDefaultRootElement(); | |
| if (elem == null) | |
| return; | |
| View view = factory.create(elem); | |
| setView(view); | |
| } | |
| /** | |
| * Receives notification whenever one of the text component's bound | |
| * properties changes. This default implementation does nothing. | |
| * It is a hook that enables subclasses to react to property changes | |
| * on the text component. | |
| * | |
| * @param ev the property change event | |
| */ | |
| protected void propertyChange(PropertyChangeEvent ev) | |
| { | |
| // The default implementation does nothing. | |
| } | |
| } |