1 /*
2 * Copyright (c) 1997, 2008, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25 package javax.swing.plaf.basic;
26
27 import java.util.*;
28 import java.awt.*;
29 import java.awt.event.*;
30 import java.awt.datatransfer.*;
31 import java.awt.im.InputContext;
32 import java.beans.*;
33 import java.io.*;
34 import javax.swing.*;
35 import javax.swing.plaf.*;
36 import javax.swing.text.*;
37 import javax.swing.event.*;
38 import javax.swing.border.Border;
39 import javax.swing.plaf.UIResource;
40 import javax.swing.plaf.synth.SynthUI;
41 import sun.swing.DefaultLookup;
42 import sun.awt.AppContext;
43 import javax.swing.plaf.basic.DragRecognitionSupport.BeforeDrag;
44
45 /**
46 * <p>
47 * Basis of a text components look-and-feel. This provides the
48 * basic editor view and controller services that may be useful
49 * when creating a look-and-feel for an extension of
50 * <code>JTextComponent</code>.
51 * <p>
52 * Most state is held in the associated <code>JTextComponent</code>
53 * as bound properties, and the UI installs default values for the
54 * various properties. This default will install something for
55 * all of the properties. Typically, a LAF implementation will
56 * do more however. At a minimum, a LAF would generally install
57 * key bindings.
58 * <p>
59 * This class also provides some concurrency support if the
60 * <code>Document</code> associated with the JTextComponent is a subclass of
61 * <code>AbstractDocument</code>. Access to the View (or View hierarchy) is
62 * serialized between any thread mutating the model and the Swing
63 * event thread (which is expected to render, do model/view coordinate
64 * translation, etc). <em>Any access to the root view should first
65 * acquire a read-lock on the AbstractDocument and release that lock
66 * in a finally block.</em>
67 * <p>
68 * An important method to define is the {@link #getPropertyPrefix} method
69 * which is used as the basis of the keys used to fetch defaults
70 * from the UIManager. The string should reflect the type of
71 * TextUI (eg. TextField, TextArea, etc) without the particular
72 * LAF part of the name (eg Metal, Motif, etc).
73 * <p>
74 * To build a view of the model, one of the following strategies
75 * can be employed.
76 * <ol>
77 * <li>
78 * One strategy is to simply redefine the
79 * ViewFactory interface in the UI. By default, this UI itself acts
80 * as the factory for View implementations. This is useful
81 * for simple factories. To do this reimplement the
82 * {@link #create} method.
83 * <li>
84 * A common strategy for creating more complex types of documents
85 * is to have the EditorKit implementation return a factory. Since
86 * the EditorKit ties all of the pieces necessary to maintain a type
87 * of document, the factory is typically an important part of that
88 * and should be produced by the EditorKit implementation.
89 * </ol>
90 * <p>
91 * <strong>Warning:</strong>
92 * Serialized objects of this class will not be compatible with
93 * future Swing releases. The current serialization support is
94 * appropriate for short term storage or RMI between applications running
95 * the same version of Swing. As of 1.4, support for long term storage
96 * of all JavaBeans<sup><font size="-2">TM</font></sup>
97 * has been added to the <code>java.beans</code> package.
98 * Please see {@link java.beans.XMLEncoder}.
99 *
100 * @author Timothy Prinzing
101 * @author Shannon Hickey (drag and drop)
102 */
103 public abstract class BasicTextUI extends TextUI implements ViewFactory {
104
105 /**
106 * Creates a new UI.
107 */
108 public BasicTextUI() {
109 painted = false;
110 }
111
112 /**
113 * Creates the object to use for a caret. By default an
114 * instance of BasicCaret is created. This method
115 * can be redefined to provide something else that implements
116 * the InputPosition interface or a subclass of JCaret.
117 *
118 * @return the caret object
119 */
120 protected Caret createCaret() {
121 return new BasicCaret();
122 }
123
124 /**
125 * Creates the object to use for adding highlights. By default
126 * an instance of BasicHighlighter is created. This method
127 * can be redefined to provide something else that implements
128 * the Highlighter interface or a subclass of DefaultHighlighter.
129 *
130 * @return the highlighter
131 */
132 protected Highlighter createHighlighter() {
133 return new BasicHighlighter();
134 }
135
136 /**
137 * Fetches the name of the keymap that will be installed/used
138 * by default for this UI. This is implemented to create a
139 * name based upon the classname. The name is the the name
140 * of the class with the package prefix removed.
141 *
142 * @return the name
143 */
144 protected String getKeymapName() {
145 String nm = getClass().getName();
146 int index = nm.lastIndexOf('.');
147 if (index >= 0) {
148 nm = nm.substring(index+1, nm.length());
149 }
150 return nm;
151 }
152
153 /**
154 * Creates the keymap to use for the text component, and installs
155 * any necessary bindings into it. By default, the keymap is
156 * shared between all instances of this type of TextUI. The
157 * keymap has the name defined by the getKeymapName method. If the
158 * keymap is not found, then DEFAULT_KEYMAP from JTextComponent is used.
159 * <p>
160 * The set of bindings used to create the keymap is fetched
161 * from the UIManager using a key formed by combining the
162 * {@link #getPropertyPrefix} method
163 * and the string <code>.keyBindings</code>. The type is expected
164 * to be <code>JTextComponent.KeyBinding[]</code>.
165 *
166 * @return the keymap
167 * @see #getKeymapName
168 * @see javax.swing.text.JTextComponent
169 */
170 protected Keymap createKeymap() {
171 String nm = getKeymapName();
172 Keymap map = JTextComponent.getKeymap(nm);
173 if (map == null) {
174 Keymap parent = JTextComponent.getKeymap(JTextComponent.DEFAULT_KEYMAP);
175 map = JTextComponent.addKeymap(nm, parent);
176 String prefix = getPropertyPrefix();
177 Object o = DefaultLookup.get(editor, this,
178 prefix + ".keyBindings");
179 if ((o != null) && (o instanceof JTextComponent.KeyBinding[])) {
180 JTextComponent.KeyBinding[] bindings = (JTextComponent.KeyBinding[]) o;
181 JTextComponent.loadKeymap(map, bindings, getComponent().getActions());
182 }
183 }
184 return map;
185 }
186
187 /**
188 * This method gets called when a bound property is changed
189 * on the associated JTextComponent. This is a hook
190 * which UI implementations may change to reflect how the
191 * UI displays bound properties of JTextComponent subclasses.
192 * This is implemented to do nothing (i.e. the response to
193 * properties in JTextComponent itself are handled prior
194 * to calling this method).
195 *
196 * This implementation updates the background of the text
197 * component if the editable and/or enabled state changes.
198 *
199 * @param evt the property change event
200 */
201 protected void propertyChange(PropertyChangeEvent evt) {
202 if (evt.getPropertyName().equals("editable") ||
203 evt.getPropertyName().equals("enabled")) {
204
205 updateBackground((JTextComponent)evt.getSource());
206 }
207 }
208
209 /**
210 * Updates the background of the text component based on whether the
211 * text component is editable and/or enabled.
212 *
213 * @param c the JTextComponent that needs its background color updated
214 */
215 private void updateBackground(JTextComponent c) {
216 // This is a temporary workaround.
217 // This code does not correctly deal with Synth (Synth doesn't use
218 // properties like this), nor does it deal with the situation where
219 // the developer grabs the color from a JLabel and sets it as
220 // the background for a JTextArea in all look and feels. The problem
221 // scenario results if the Color obtained for the Label and TextArea
222 // is ==, which is the case for the windows look and feel.
223 // Until an appropriate solution is found, the code is being
224 // reverted to what it was before the original fix.
225 if (this instanceof SynthUI || (c instanceof JTextArea)) {
226 return;
227 }
228 Color background = c.getBackground();
229 if (background instanceof UIResource) {
230 String prefix = getPropertyPrefix();
231
232 Color disabledBG =
233 DefaultLookup.getColor(c, this, prefix + ".disabledBackground", null);
234 Color inactiveBG =
235 DefaultLookup.getColor(c, this, prefix + ".inactiveBackground", null);
236 Color bg =
237 DefaultLookup.getColor(c, this, prefix + ".background", null);
238
239 /* In an ideal situation, the following check would not be necessary
240 * and we would replace the color any time the previous color was a
241 * UIResouce. However, it turns out that there is existing code that
242 * uses the following inadvisable pattern to turn a text area into
243 * what appears to be a multi-line label:
244 *
245 * JLabel label = new JLabel();
246 * JTextArea area = new JTextArea();
247 * area.setBackground(label.getBackground());
248 * area.setEditable(false);
249 *
250 * JLabel's default background is a UIResource. As such, just
251 * checking for UIResource would have us always changing the
252 * background away from what the developer wanted.
253 *
254 * Therefore, for JTextArea/JEditorPane, we'll additionally check
255 * that the color we're about to replace matches one that was
256 * installed by us from the UIDefaults.
257 */
258 if ((c instanceof JTextArea || c instanceof JEditorPane)
259 && background != disabledBG
260 && background != inactiveBG
261 && background != bg) {
262
263 return;
264 }
265
266 Color newColor = null;
267 if (!c.isEnabled()) {
268 newColor = disabledBG;
269 }
270 if (newColor == null && !c.isEditable()) {
271 newColor = inactiveBG;
272 }
273 if (newColor == null) {
274 newColor = bg;
275 }
276 if (newColor != null && newColor != background) {
277 c.setBackground(newColor);
278 }
279 }
280 }
281
282 /**
283 * Gets the name used as a key to look up properties through the
284 * UIManager. This is used as a prefix to all the standard
285 * text properties.
286 *
287 * @return the name
288 */
289 protected abstract String getPropertyPrefix();
290
291 /**
292 * Initializes component properties, such as font, foreground,
293 * background, caret color, selection color, selected text color,
294 * disabled text color, and border color. The font, foreground, and
295 * background properties are only set if their current value is either null
296 * or a UIResource, other properties are set if the current
297 * value is null.
298 *
299 * @see #uninstallDefaults
300 * @see #installUI
301 */
302 protected void installDefaults()
303 {
304 String prefix = getPropertyPrefix();
305 Font f = editor.getFont();
306 if ((f == null) || (f instanceof UIResource)) {
307 editor.setFont(UIManager.getFont(prefix + ".font"));
308 }
309
310 Color bg = editor.getBackground();
311 if ((bg == null) || (bg instanceof UIResource)) {
312 editor.setBackground(UIManager.getColor(prefix + ".background"));
313 }
314
315 Color fg = editor.getForeground();
316 if ((fg == null) || (fg instanceof UIResource)) {
317 editor.setForeground(UIManager.getColor(prefix + ".foreground"));
318 }
319
320 Color color = editor.getCaretColor();
321 if ((color == null) || (color instanceof UIResource)) {
322 editor.setCaretColor(UIManager.getColor(prefix + ".caretForeground"));
323 }
324
325 Color s = editor.getSelectionColor();
326 if ((s == null) || (s instanceof UIResource)) {
327 editor.setSelectionColor(UIManager.getColor(prefix + ".selectionBackground"));
328 }
329
330 Color sfg = editor.getSelectedTextColor();
331 if ((sfg == null) || (sfg instanceof UIResource)) {
332 editor.setSelectedTextColor(UIManager.getColor(prefix + ".selectionForeground"));
333 }
334
335 Color dfg = editor.getDisabledTextColor();
336 if ((dfg == null) || (dfg instanceof UIResource)) {
337 editor.setDisabledTextColor(UIManager.getColor(prefix + ".inactiveForeground"));
338 }
339
340 Border b = editor.getBorder();
341 if ((b == null) || (b instanceof UIResource)) {
342 editor.setBorder(UIManager.getBorder(prefix + ".border"));
343 }
344
345 Insets margin = editor.getMargin();
346 if (margin == null || margin instanceof UIResource) {
347 editor.setMargin(UIManager.getInsets(prefix + ".margin"));
348 }
349
350 updateCursor();
351 }
352
353 private void installDefaults2() {
354 editor.addMouseListener(dragListener);
355 editor.addMouseMotionListener(dragListener);
356
357 String prefix = getPropertyPrefix();
358
359 Caret caret = editor.getCaret();
360 if (caret == null || caret instanceof UIResource) {
361 caret = createCaret();
362 editor.setCaret(caret);
363
364 int rate = DefaultLookup.getInt(getComponent(), this, prefix + ".caretBlinkRate", 500);
365 caret.setBlinkRate(rate);
366 }
367
368 Highlighter highlighter = editor.getHighlighter();
369 if (highlighter == null || highlighter instanceof UIResource) {
370 editor.setHighlighter(createHighlighter());
371 }
372
373 TransferHandler th = editor.getTransferHandler();
374 if (th == null || th instanceof UIResource) {
375 editor.setTransferHandler(getTransferHandler());
376 }
377 }
378
379 /**
380 * Sets the component properties that have not been explicitly overridden
381 * to {@code null}. A property is considered overridden if its current
382 * value is not a {@code UIResource}.
383 *
384 * @see #installDefaults
385 * @see #uninstallUI
386 */
387 protected void uninstallDefaults()
388 {
389 editor.removeMouseListener(dragListener);
390 editor.removeMouseMotionListener(dragListener);
391
392 if (editor.getCaretColor() instanceof UIResource) {
393 editor.setCaretColor(null);
394 }
395
396 if (editor.getSelectionColor() instanceof UIResource) {
397 editor.setSelectionColor(null);
398 }
399
400 if (editor.getDisabledTextColor() instanceof UIResource) {
401 editor.setDisabledTextColor(null);
402 }
403
404 if (editor.getSelectedTextColor() instanceof UIResource) {
405 editor.setSelectedTextColor(null);
406 }
407
408 if (editor.getBorder() instanceof UIResource) {
409 editor.setBorder(null);
410 }
411
412 if (editor.getMargin() instanceof UIResource) {
413 editor.setMargin(null);
414 }
415
416 if (editor.getCaret() instanceof UIResource) {
417 editor.setCaret(null);
418 }
419
420 if (editor.getHighlighter() instanceof UIResource) {
421 editor.setHighlighter(null);
422 }
423
424 if (editor.getTransferHandler() instanceof UIResource) {
425 editor.setTransferHandler(null);
426 }
427
428 if (editor.getCursor() instanceof UIResource) {
429 editor.setCursor(null);
430 }
431 }
432
433 /**
434 * Installs listeners for the UI.
435 */
436 protected void installListeners() {
437 }
438
439 /**
440 * Uninstalls listeners for the UI.
441 */
442 protected void uninstallListeners() {
443 }
444
445 protected void installKeyboardActions() {
446 // backward compatibility support... keymaps for the UI
447 // are now installed in the more friendly input map.
448 editor.setKeymap(createKeymap());
449
450 InputMap km = getInputMap();
451 if (km != null) {
452 SwingUtilities.replaceUIInputMap(editor, JComponent.WHEN_FOCUSED,
453 km);
454 }
455
456 ActionMap map = getActionMap();
457 if (map != null) {
458 SwingUtilities.replaceUIActionMap(editor, map);
459 }
460
461 updateFocusAcceleratorBinding(false);
462 }
463
464 /**
465 * Get the InputMap to use for the UI.
466 */
467 InputMap getInputMap() {
468 InputMap map = new InputMapUIResource();
469
470 InputMap shared =
471 (InputMap)DefaultLookup.get(editor, this,
472 getPropertyPrefix() + ".focusInputMap");
473 if (shared != null) {
474 map.setParent(shared);
475 }
476 return map;
477 }
478
479 /**
480 * Invoked when the focus accelerator changes, this will update the
481 * key bindings as necessary.
482 */
483 void updateFocusAcceleratorBinding(boolean changed) {
484 char accelerator = editor.getFocusAccelerator();
485
486 if (changed || accelerator != '\0') {
487 InputMap km = SwingUtilities.getUIInputMap
488 (editor, JComponent.WHEN_IN_FOCUSED_WINDOW);
489
490 if (km == null && accelerator != '\0') {
491 km = new ComponentInputMapUIResource(editor);
492 SwingUtilities.replaceUIInputMap(editor, JComponent.
493 WHEN_IN_FOCUSED_WINDOW, km);
494 ActionMap am = getActionMap();
495 SwingUtilities.replaceUIActionMap(editor, am);
496 }
497 if (km != null) {
498 km.clear();
499 if (accelerator != '\0') {
500 km.put(KeyStroke.getKeyStroke(accelerator,
501 ActionEvent.ALT_MASK),
502 "requestFocus");
503 }
504 }
505 }
506 }
507
508
509 /**
510 * Invoked when editable property is changed.
511 *
512 * removing 'TAB' and 'SHIFT-TAB' from traversalKeysSet in case
513 * editor is editable
514 * adding 'TAB' and 'SHIFT-TAB' to traversalKeysSet in case
515 * editor is non editable
516 */
517
518 void updateFocusTraversalKeys() {
519 /*
520 * Fix for 4514331 Non-editable JTextArea and similar
521 * should allow Tab to keyboard - accessibility
522 */
523 EditorKit editorKit = getEditorKit(editor);
524 if ( editorKit != null
525 && editorKit instanceof DefaultEditorKit) {
526 Set<AWTKeyStroke> storedForwardTraversalKeys = editor.
527 getFocusTraversalKeys(KeyboardFocusManager.
528 FORWARD_TRAVERSAL_KEYS);
529 Set<AWTKeyStroke> storedBackwardTraversalKeys = editor.
530 getFocusTraversalKeys(KeyboardFocusManager.
531 BACKWARD_TRAVERSAL_KEYS);
532 Set<AWTKeyStroke> forwardTraversalKeys =
533 new HashSet<AWTKeyStroke>(storedForwardTraversalKeys);
534 Set<AWTKeyStroke> backwardTraversalKeys =
535 new HashSet<AWTKeyStroke>(storedBackwardTraversalKeys);
536 if (editor.isEditable()) {
537 forwardTraversalKeys.
538 remove(KeyStroke.getKeyStroke(KeyEvent.VK_TAB, 0));
539 backwardTraversalKeys.
540 remove(KeyStroke.getKeyStroke(KeyEvent.VK_TAB,
541 InputEvent.SHIFT_MASK));
542 } else {
543 forwardTraversalKeys.add(KeyStroke.
544 getKeyStroke(KeyEvent.VK_TAB, 0));
545 backwardTraversalKeys.
546 add(KeyStroke.
547 getKeyStroke(KeyEvent.VK_TAB, InputEvent.SHIFT_MASK));
548 }
549 LookAndFeel.installProperty(editor,
550 "focusTraversalKeysForward",
551 forwardTraversalKeys);
552 LookAndFeel.installProperty(editor,
553 "focusTraversalKeysBackward",
554 backwardTraversalKeys);
555 }
556
557 }
558
559 /**
560 * As needed updates cursor for the target editor.
561 */
562 private void updateCursor() {
563 if ((! editor.isCursorSet())
564 || editor.getCursor() instanceof UIResource) {
565 Cursor cursor = (editor.isEditable()) ? textCursor : null;
566 editor.setCursor(cursor);
567 }
568 }
569
570 /**
571 * Returns the <code>TransferHandler</code> that will be installed if
572 * their isn't one installed on the <code>JTextComponent</code>.
573 */
574 TransferHandler getTransferHandler() {
575 return defaultTransferHandler;
576 }
577
578 /**
579 * Fetch an action map to use.
580 */
581 ActionMap getActionMap() {
582 String mapName = getPropertyPrefix() + ".actionMap";
583 ActionMap map = (ActionMap)UIManager.get(mapName);
584
585 if (map == null) {
586 map = createActionMap();
587 if (map != null) {
588 UIManager.getLookAndFeelDefaults().put(mapName, map);
589 }
590 }
591 ActionMap componentMap = new ActionMapUIResource();
592 componentMap.put("requestFocus", new FocusAction());
593 /*
594 * fix for bug 4515750
595 * JTextField & non-editable JTextArea bind return key - default btn not accessible
596 *
597 * Wrap the return action so that it is only enabled when the
598 * component is editable. This allows the default button to be
599 * processed when the text component has focus and isn't editable.
600 *
601 */
602 if (getEditorKit(editor) instanceof DefaultEditorKit) {
603 if (map != null) {
604 Object obj = map.get(DefaultEditorKit.insertBreakAction);
605 if (obj != null
606 && obj instanceof DefaultEditorKit.InsertBreakAction) {
607 Action action = new TextActionWrapper((TextAction)obj);
608 componentMap.put(action.getValue(Action.NAME),action);
609 }
610 }
611 }
612 if (map != null) {
613 componentMap.setParent(map);
614 }
615 return componentMap;
616 }
617
618 /**
619 * Create a default action map. This is basically the
620 * set of actions found exported by the component.
621 */
622 ActionMap createActionMap() {
623 ActionMap map = new ActionMapUIResource();
624 Action[] actions = editor.getActions();
625 //System.out.println("building map for UI: " + getPropertyPrefix());
626 int n = actions.length;
627 for (int i = 0; i < n; i++) {
628 Action a = actions[i];
629 map.put(a.getValue(Action.NAME), a);
630 //System.out.println(" " + a.getValue(Action.NAME));
631 }
632 map.put(TransferHandler.getCutAction().getValue(Action.NAME),
633 TransferHandler.getCutAction());
634 map.put(TransferHandler.getCopyAction().getValue(Action.NAME),
635 TransferHandler.getCopyAction());
636 map.put(TransferHandler.getPasteAction().getValue(Action.NAME),
637 TransferHandler.getPasteAction());
638 return map;
639 }
640
641 protected void uninstallKeyboardActions() {
642 editor.setKeymap(null);
643 SwingUtilities.replaceUIInputMap(editor, JComponent.
644 WHEN_IN_FOCUSED_WINDOW, null);
645 SwingUtilities.replaceUIActionMap(editor, null);
646 }
647
648 /**
649 * Paints a background for the view. This will only be
650 * called if isOpaque() on the associated component is
651 * true. The default is to paint the background color
652 * of the component.
653 *
654 * @param g the graphics context
655 */
656 protected void paintBackground(Graphics g) {
657 g.setColor(editor.getBackground());
658 g.fillRect(0, 0, editor.getWidth(), editor.getHeight());
659 }
660
661 /**
662 * Fetches the text component associated with this
663 * UI implementation. This will be null until
664 * the ui has been installed.
665 *
666 * @return the editor component
667 */
668 protected final JTextComponent getComponent() {
669 return editor;
670 }
671
672 /**
673 * Flags model changes.
674 * This is called whenever the model has changed.
675 * It is implemented to rebuild the view hierarchy
676 * to represent the default root element of the
677 * associated model.
678 */
679 protected void modelChanged() {
680 // create a view hierarchy
681 ViewFactory f = rootView.getViewFactory();
682 Document doc = editor.getDocument();
683 Element elem = doc.getDefaultRootElement();
684 setView(f.create(elem));
685 }
686
687 /**
688 * Sets the current root of the view hierarchy and calls invalidate().
689 * If there were any child components, they will be removed (i.e.
690 * there are assumed to have come from components embedded in views).
691 *
692 * @param v the root view
693 */
694 protected final void setView(View v) {
695 rootView.setView(v);
696 painted = false;
697 editor.revalidate();
698 editor.repaint();
699 }
700
701 /**
702 * Paints the interface safely with a guarantee that
703 * the model won't change from the view of this thread.
704 * This does the following things, rendering from
705 * back to front.
706 * <ol>
707 * <li>
708 * If the component is marked as opaque, the background
709 * is painted in the current background color of the
710 * component.
711 * <li>
712 * The highlights (if any) are painted.
713 * <li>
714 * The view hierarchy is painted.
715 * <li>
716 * The caret is painted.
717 * </ol>
718 *
719 * @param g the graphics context
720 */
721 protected void paintSafely(Graphics g) {
722 painted = true;
723 Highlighter highlighter = editor.getHighlighter();
724 Caret caret = editor.getCaret();
725
726 // paint the background
727 if (editor.isOpaque()) {
728 paintBackground(g);
729 }
730
731 // paint the highlights
732 if (highlighter != null) {
733 highlighter.paint(g);
734 }
735
736 // paint the view hierarchy
737 Rectangle alloc = getVisibleEditorRect();
738 if (alloc != null) {
739 rootView.paint(g, alloc);
740 }
741
742 // paint the caret
743 if (caret != null) {
744 caret.paint(g);
745 }
746
747 if (dropCaret != null) {
748 dropCaret.paint(g);
749 }
750 }
751
752 // --- ComponentUI methods --------------------------------------------
753
754 /**
755 * Installs the UI for a component. This does the following
756 * things.
757 * <ol>
758 * <li>
759 * Sets the associated component to opaque if the opaque property
760 * has not already been set by the client program. This will cause the
761 * component's background color to be painted.
762 * <li>
763 * Installs the default caret and highlighter into the
764 * associated component. These properties are only set if their
765 * current value is either {@code null} or an instance of
766 * {@link UIResource}.
767 * <li>
768 * Attaches to the editor and model. If there is no
769 * model, a default one is created.
770 * <li>
771 * Creates the view factory and the view hierarchy used
772 * to represent the model.
773 * </ol>
774 *
775 * @param c the editor component
776 * @see ComponentUI#installUI
777 */
778 public void installUI(JComponent c) {
779 if (c instanceof JTextComponent) {
780 editor = (JTextComponent) c;
781
782 // common case is background painted... this can
783 // easily be changed by subclasses or from outside
784 // of the component.
785 LookAndFeel.installProperty(editor, "opaque", Boolean.TRUE);
786 LookAndFeel.installProperty(editor, "autoscrolls", Boolean.TRUE);
787
788 // install defaults
789 installDefaults();
790 installDefaults2();
791
792 // attach to the model and editor
793 editor.addPropertyChangeListener(updateHandler);
794 Document doc = editor.getDocument();
795 if (doc == null) {
796 // no model, create a default one. This will
797 // fire a notification to the updateHandler
798 // which takes care of the rest.
799 editor.setDocument(getEditorKit(editor).createDefaultDocument());
800 } else {
801 doc.addDocumentListener(updateHandler);
802 modelChanged();
803 }
804
805 // install keymap
806 installListeners();
807 installKeyboardActions();
808
809 LayoutManager oldLayout = editor.getLayout();
810 if ((oldLayout == null) || (oldLayout instanceof UIResource)) {
811 // by default, use default LayoutManger implementation that
812 // will position the components associated with a View object.
813 editor.setLayout(updateHandler);
814 }
815
816 updateBackground(editor);
817 } else {
818 throw new Error("TextUI needs JTextComponent");
819 }
820 }
821
822 /**
823 * Deinstalls the UI for a component. This removes the listeners,
824 * uninstalls the highlighter, removes views, and nulls out the keymap.
825 *
826 * @param c the editor component
827 * @see ComponentUI#uninstallUI
828 */
829 public void uninstallUI(JComponent c) {
830 // detach from the model
831 editor.removePropertyChangeListener(updateHandler);
832 editor.getDocument().removeDocumentListener(updateHandler);
833
834 // view part
835 painted = false;
836 uninstallDefaults();
837 rootView.setView(null);
838 c.removeAll();
839 LayoutManager lm = c.getLayout();
840 if (lm instanceof UIResource) {
841 c.setLayout(null);
842 }
843
844 // controller part
845 uninstallKeyboardActions();
846 uninstallListeners();
847
848 editor = null;
849 }
850
851 /**
852 * Superclass paints background in an uncontrollable way
853 * (i.e. one might want an image tiled into the background).
854 * To prevent this from happening twice, this method is
855 * reimplemented to simply paint.
856 * <p>
857 * <em>NOTE:</em> NOTE: Superclass is also not thread-safe in its
858 * rendering of the background, although that is not an issue with the
859 * default rendering.
860 */
861 public void update(Graphics g, JComponent c) {
862 paint(g, c);
863 }
864
865 /**
866 * Paints the interface. This is routed to the
867 * paintSafely method under the guarantee that
868 * the model won't change from the view of this thread
869 * while it's rendering (if the associated model is
870 * derived from AbstractDocument). This enables the
871 * model to potentially be updated asynchronously.
872 *
873 * @param g the graphics context
874 * @param c the editor component
875 */
876 public final void paint(Graphics g, JComponent c) {
877 if ((rootView.getViewCount() > 0) && (rootView.getView(0) != null)) {
878 Document doc = editor.getDocument();
879 if (doc instanceof AbstractDocument) {
880 ((AbstractDocument)doc).readLock();
881 }
882 try {
883 paintSafely(g);
884 } finally {
885 if (doc instanceof AbstractDocument) {
886 ((AbstractDocument)doc).readUnlock();
887 }
888 }
889 }
890 }
891
892 /**
893 * Gets the preferred size for the editor component. If the component
894 * has been given a size prior to receiving this request, it will
895 * set the size of the view hierarchy to reflect the size of the component
896 * before requesting the preferred size of the view hierarchy. This
897 * allows formatted views to format to the current component size before
898 * answering the request. Other views don't care about currently formatted
899 * size and give the same answer either way.
900 *
901 * @param c the editor component
902 * @return the size
903 */
904 public Dimension getPreferredSize(JComponent c) {
905 Document doc = editor.getDocument();
906 Insets i = c.getInsets();
907 Dimension d = c.getSize();
908
909 if (doc instanceof AbstractDocument) {
910 ((AbstractDocument)doc).readLock();
911 }
912 try {
913 if ((d.width > (i.left + i.right)) && (d.height > (i.top + i.bottom))) {
914 rootView.setSize(d.width - i.left - i.right, d.height - i.top - i.bottom);
915 }
916 else if (d.width == 0 && d.height == 0) {
917 // Probably haven't been layed out yet, force some sort of
918 // initial sizing.
919 rootView.setSize(Integer.MAX_VALUE, Integer.MAX_VALUE);
920 }
921 d.width = (int) Math.min((long) rootView.getPreferredSpan(View.X_AXIS) +
922 (long) i.left + (long) i.right, Integer.MAX_VALUE);
923 d.height = (int) Math.min((long) rootView.getPreferredSpan(View.Y_AXIS) +
924 (long) i.top + (long) i.bottom, Integer.MAX_VALUE);
925 } finally {
926 if (doc instanceof AbstractDocument) {
927 ((AbstractDocument)doc).readUnlock();
928 }
929 }
930 return d;
931 }
932
933 /**
934 * Gets the minimum size for the editor component.
935 *
936 * @param c the editor component
937 * @return the size
938 */
939 public Dimension getMinimumSize(JComponent c) {
940 Document doc = editor.getDocument();
941 Insets i = c.getInsets();
942 Dimension d = new Dimension();
943 if (doc instanceof AbstractDocument) {
944 ((AbstractDocument)doc).readLock();
945 }
946 try {
947 d.width = (int) rootView.getMinimumSpan(View.X_AXIS) + i.left + i.right;
948 d.height = (int) rootView.getMinimumSpan(View.Y_AXIS) + i.top + i.bottom;
949 } finally {
950 if (doc instanceof AbstractDocument) {
951 ((AbstractDocument)doc).readUnlock();
952 }
953 }
954 return d;
955 }
956
957 /**
958 * Gets the maximum size for the editor component.
959 *
960 * @param c the editor component
961 * @return the size
962 */
963 public Dimension getMaximumSize(JComponent c) {
964 Document doc = editor.getDocument();
965 Insets i = c.getInsets();
966 Dimension d = new Dimension();
967 if (doc instanceof AbstractDocument) {
968 ((AbstractDocument)doc).readLock();
969 }
970 try {
971 d.width = (int) Math.min((long) rootView.getMaximumSpan(View.X_AXIS) +
972 (long) i.left + (long) i.right, Integer.MAX_VALUE);
973 d.height = (int) Math.min((long) rootView.getMaximumSpan(View.Y_AXIS) +
974 (long) i.top + (long) i.bottom, Integer.MAX_VALUE);
975 } finally {
976 if (doc instanceof AbstractDocument) {
977 ((AbstractDocument)doc).readUnlock();
978 }
979 }
980 return d;
981 }
982
983 // ---- TextUI methods -------------------------------------------
984
985
986 /**
987 * Gets the allocation to give the root View. Due
988 * to an unfortunate set of historical events this
989 * method is inappropriately named. The Rectangle
990 * returned has nothing to do with visibility.
991 * The component must have a non-zero positive size for
992 * this translation to be computed.
993 *
994 * @return the bounding box for the root view
995 */
996 protected Rectangle getVisibleEditorRect() {
997 Rectangle alloc = editor.getBounds();
998 if ((alloc.width > 0) && (alloc.height > 0)) {
999 alloc.x = alloc.y = 0;
1000 Insets insets = editor.getInsets();
1001 alloc.x += insets.left;
1002 alloc.y += insets.top;
1003 alloc.width -= insets.left + insets.right;
1004 alloc.height -= insets.top + insets.bottom;
1005 return alloc;
1006 }
1007 return null;
1008 }
1009
1010 /**
1011 * Converts the given location in the model to a place in
1012 * the view coordinate system.
1013 * The component must have a non-zero positive size for
1014 * this translation to be computed.
1015 *
1016 * @param tc the text component for which this UI is installed
1017 * @param pos the local location in the model to translate >= 0
1018 * @return the coordinates as a rectangle, null if the model is not painted
1019 * @exception BadLocationException if the given position does not
1020 * represent a valid location in the associated document
1021 * @see TextUI#modelToView
1022 */
1023 public Rectangle modelToView(JTextComponent tc, int pos) throws BadLocationException {
1024 return modelToView(tc, pos, Position.Bias.Forward);
1025 }
1026
1027 /**
1028 * Converts the given location in the model to a place in
1029 * the view coordinate system.
1030 * The component must have a non-zero positive size for
1031 * this translation to be computed.
1032 *
1033 * @param tc the text component for which this UI is installed
1034 * @param pos the local location in the model to translate >= 0
1035 * @return the coordinates as a rectangle, null if the model is not painted
1036 * @exception BadLocationException if the given position does not
1037 * represent a valid location in the associated document
1038 * @see TextUI#modelToView
1039 */
1040 public Rectangle modelToView(JTextComponent tc, int pos, Position.Bias bias) throws BadLocationException {
1041 Document doc = editor.getDocument();
1042 if (doc instanceof AbstractDocument) {
1043 ((AbstractDocument)doc).readLock();
1044 }
1045 try {
1046 Rectangle alloc = getVisibleEditorRect();
1047 if (alloc != null) {
1048 rootView.setSize(alloc.width, alloc.height);
1049 Shape s = rootView.modelToView(pos, alloc, bias);
1050 if (s != null) {
1051 return s.getBounds();
1052 }
1053 }
1054 } finally {
1055 if (doc instanceof AbstractDocument) {
1056 ((AbstractDocument)doc).readUnlock();
1057 }
1058 }
1059 return null;
1060 }
1061
1062 /**
1063 * Converts the given place in the view coordinate system
1064 * to the nearest representative location in the model.
1065 * The component must have a non-zero positive size for
1066 * this translation to be computed.
1067 *
1068 * @param tc the text component for which this UI is installed
1069 * @param pt the location in the view to translate. This
1070 * should be in the same coordinate system as the mouse events.
1071 * @return the offset from the start of the document >= 0,
1072 * -1 if not painted
1073 * @see TextUI#viewToModel
1074 */
1075 public int viewToModel(JTextComponent tc, Point pt) {
1076 return viewToModel(tc, pt, discardBias);
1077 }
1078
1079 /**
1080 * Converts the given place in the view coordinate system
1081 * to the nearest representative location in the model.
1082 * The component must have a non-zero positive size for
1083 * this translation to be computed.
1084 *
1085 * @param tc the text component for which this UI is installed
1086 * @param pt the location in the view to translate. This
1087 * should be in the same coordinate system as the mouse events.
1088 * @return the offset from the start of the document >= 0,
1089 * -1 if the component doesn't yet have a positive size.
1090 * @see TextUI#viewToModel
1091 */
1092 public int viewToModel(JTextComponent tc, Point pt,
1093 Position.Bias[] biasReturn) {
1094 int offs = -1;
1095 Document doc = editor.getDocument();
1096 if (doc instanceof AbstractDocument) {
1097 ((AbstractDocument)doc).readLock();
1098 }
1099 try {
1100 Rectangle alloc = getVisibleEditorRect();
1101 if (alloc != null) {
1102 rootView.setSize(alloc.width, alloc.height);
1103 offs = rootView.viewToModel(pt.x, pt.y, alloc, biasReturn);
1104 }
1105 } finally {
1106 if (doc instanceof AbstractDocument) {
1107 ((AbstractDocument)doc).readUnlock();
1108 }
1109 }
1110 return offs;
1111 }
1112
1113 /**
1114 * {@inheritDoc}
1115 */
1116 public int getNextVisualPositionFrom(JTextComponent t, int pos,
1117 Position.Bias b, int direction, Position.Bias[] biasRet)
1118 throws BadLocationException{
1119 Document doc = editor.getDocument();
1120 if (doc instanceof AbstractDocument) {
1121 ((AbstractDocument)doc).readLock();
1122 }
1123 try {
1124 if (painted) {
1125 Rectangle alloc = getVisibleEditorRect();
1126 if (alloc != null) {
1127 rootView.setSize(alloc.width, alloc.height);
1128 }
1129 return rootView.getNextVisualPositionFrom(pos, b, alloc, direction,
1130 biasRet);
1131 }
1132 } finally {
1133 if (doc instanceof AbstractDocument) {
1134 ((AbstractDocument)doc).readUnlock();
1135 }
1136 }
1137 return -1;
1138 }
1139
1140 /**
1141 * Causes the portion of the view responsible for the
1142 * given part of the model to be repainted. Does nothing if
1143 * the view is not currently painted.
1144 *
1145 * @param tc the text component for which this UI is installed
1146 * @param p0 the beginning of the range >= 0
1147 * @param p1 the end of the range >= p0
1148 * @see TextUI#damageRange
1149 */
1150 public void damageRange(JTextComponent tc, int p0, int p1) {
1151 damageRange(tc, p0, p1, Position.Bias.Forward, Position.Bias.Backward);
1152 }
1153
1154 /**
1155 * Causes the portion of the view responsible for the
1156 * given part of the model to be repainted.
1157 *
1158 * @param p0 the beginning of the range >= 0
1159 * @param p1 the end of the range >= p0
1160 */
1161 public void damageRange(JTextComponent t, int p0, int p1,
1162 Position.Bias p0Bias, Position.Bias p1Bias) {
1163 if (painted) {
1164 Rectangle alloc = getVisibleEditorRect();
1165 if (alloc != null) {
1166 Document doc = t.getDocument();
1167 if (doc instanceof AbstractDocument) {
1168 ((AbstractDocument)doc).readLock();
1169 }
1170 try {
1171 rootView.setSize(alloc.width, alloc.height);
1172 Shape toDamage = rootView.modelToView(p0, p0Bias,
1173 p1, p1Bias, alloc);
1174 Rectangle rect = (toDamage instanceof Rectangle) ?
1175 (Rectangle)toDamage : toDamage.getBounds();
1176 editor.repaint(rect.x, rect.y, rect.width, rect.height);
1177 } catch (BadLocationException e) {
1178 } finally {
1179 if (doc instanceof AbstractDocument) {
1180 ((AbstractDocument)doc).readUnlock();
1181 }
1182 }
1183 }
1184 }
1185 }
1186
1187 /**
1188 * Fetches the EditorKit for the UI.
1189 *
1190 * @param tc the text component for which this UI is installed
1191 * @return the editor capabilities
1192 * @see TextUI#getEditorKit
1193 */
1194 public EditorKit getEditorKit(JTextComponent tc) {
1195 return defaultKit;
1196 }
1197
1198 /**
1199 * Fetches a View with the allocation of the associated
1200 * text component (i.e. the root of the hierarchy) that
1201 * can be traversed to determine how the model is being
1202 * represented spatially.
1203 * <p>
1204 * <font color=red><b>NOTE:</b>The View hierarchy can
1205 * be traversed from the root view, and other things
1206 * can be done as well. Things done in this way cannot
1207 * be protected like simple method calls through the TextUI.
1208 * Therefore, proper operation in the presence of concurrency
1209 * must be arranged by any logic that calls this method!
1210 * </font>
1211 *
1212 * @param tc the text component for which this UI is installed
1213 * @return the view
1214 * @see TextUI#getRootView
1215 */
1216 public View getRootView(JTextComponent tc) {
1217 return rootView;
1218 }
1219
1220
1221 /**
1222 * Returns the string to be used as the tooltip at the passed in location.
1223 * This forwards the method onto the root View.
1224 *
1225 * @see javax.swing.text.JTextComponent#getToolTipText
1226 * @see javax.swing.text.View#getToolTipText
1227 * @since 1.4
1228 */
1229 public String getToolTipText(JTextComponent t, Point pt) {
1230 if (!painted) {
1231 return null;
1232 }
1233 Document doc = editor.getDocument();
1234 String tt = null;
1235 Rectangle alloc = getVisibleEditorRect();
1236
1237 if (alloc != null) {
1238 if (doc instanceof AbstractDocument) {
1239 ((AbstractDocument)doc).readLock();
1240 }
1241 try {
1242 tt = rootView.getToolTipText(pt.x, pt.y, alloc);
1243 } finally {
1244 if (doc instanceof AbstractDocument) {
1245 ((AbstractDocument)doc).readUnlock();
1246 }
1247 }
1248 }
1249 return tt;
1250 }
1251
1252 // --- ViewFactory methods ------------------------------
1253
1254 /**
1255 * Creates a view for an element.
1256 * If a subclass wishes to directly implement the factory
1257 * producing the view(s), it should reimplement this
1258 * method. By default it simply returns null indicating
1259 * it is unable to represent the element.
1260 *
1261 * @param elem the element
1262 * @return the view
1263 */
1264 public View create(Element elem) {
1265 return null;
1266 }
1267
1268 /**
1269 * Creates a view for an element.
1270 * If a subclass wishes to directly implement the factory
1271 * producing the view(s), it should reimplement this
1272 * method. By default it simply returns null indicating
1273 * it is unable to represent the part of the element.
1274 *
1275 * @param elem the element
1276 * @param p0 the starting offset >= 0
1277 * @param p1 the ending offset >= p0
1278 * @return the view
1279 */
1280 public View create(Element elem, int p0, int p1) {
1281 return null;
1282 }
1283
1284 public static class BasicCaret extends DefaultCaret implements UIResource {}
1285
1286 public static class BasicHighlighter extends DefaultHighlighter implements UIResource {}
1287
1288 static class BasicCursor extends Cursor implements UIResource {
1289 BasicCursor(int type) {
1290 super(type);
1291 }
1292
1293 BasicCursor(String name) {
1294 super(name);
1295 }
1296 }
1297
1298 private static BasicCursor textCursor = new BasicCursor(Cursor.TEXT_CURSOR);
1299 // ----- member variables ---------------------------------------
1300
1301 private static final EditorKit defaultKit = new DefaultEditorKit();
1302 transient JTextComponent editor;
1303 transient boolean painted;
1304 transient RootView rootView = new RootView();
1305 transient UpdateHandler updateHandler = new UpdateHandler();
1306 private static final TransferHandler defaultTransferHandler = new TextTransferHandler();
1307 private final DragListener dragListener = getDragListener();
1308 private static final Position.Bias[] discardBias = new Position.Bias[1];
1309 private DefaultCaret dropCaret;
1310
1311 /**
1312 * Root view that acts as a gateway between the component
1313 * and the View hierarchy.
1314 */
1315 class RootView extends View {
1316
1317 RootView() {
1318 super(null);
1319 }
1320
1321 void setView(View v) {
1322 View oldView = view;
1323 view = null;
1324 if (oldView != null) {
1325 // get rid of back reference so that the old
1326 // hierarchy can be garbage collected.
1327 oldView.setParent(null);
1328 }
1329 if (v != null) {
1330 v.setParent(this);
1331 }
1332 view = v;
1333 }
1334
1335 /**
1336 * Fetches the attributes to use when rendering. At the root
1337 * level there are no attributes. If an attribute is resolved
1338 * up the view hierarchy this is the end of the line.
1339 */
1340 public AttributeSet getAttributes() {
1341 return null;
1342 }
1343
1344 /**
1345 * Determines the preferred span for this view along an axis.
1346 *
1347 * @param axis may be either X_AXIS or Y_AXIS
1348 * @return the span the view would like to be rendered into.
1349 * Typically the view is told to render into the span
1350 * that is returned, although there is no guarantee.
1351 * The parent may choose to resize or break the view.
1352 */
1353 public float getPreferredSpan(int axis) {
1354 if (view != null) {
1355 return view.getPreferredSpan(axis);
1356 }
1357 return 10;
1358 }
1359
1360 /**
1361 * Determines the minimum span for this view along an axis.
1362 *
1363 * @param axis may be either X_AXIS or Y_AXIS
1364 * @return the span the view would like to be rendered into.
1365 * Typically the view is told to render into the span
1366 * that is returned, although there is no guarantee.
1367 * The parent may choose to resize or break the view.
1368 */
1369 public float getMinimumSpan(int axis) {
1370 if (view != null) {
1371 return view.getMinimumSpan(axis);
1372 }
1373 return 10;
1374 }
1375
1376 /**
1377 * Determines the maximum span for this view along an axis.
1378 *
1379 * @param axis may be either X_AXIS or Y_AXIS
1380 * @return the span the view would like to be rendered into.
1381 * Typically the view is told to render into the span
1382 * that is returned, although there is no guarantee.
1383 * The parent may choose to resize or break the view.
1384 */
1385 public float getMaximumSpan(int axis) {
1386 return Integer.MAX_VALUE;
1387 }
1388
1389 /**
1390 * Specifies that a preference has changed.
1391 * Child views can call this on the parent to indicate that
1392 * the preference has changed. The root view routes this to
1393 * invalidate on the hosting component.
1394 * <p>
1395 * This can be called on a different thread from the
1396 * event dispatching thread and is basically unsafe to
1397 * propagate into the component. To make this safe,
1398 * the operation is transferred over to the event dispatching
1399 * thread for completion. It is a design goal that all view
1400 * methods be safe to call without concern for concurrency,
1401 * and this behavior helps make that true.
1402 *
1403 * @param child the child view
1404 * @param width true if the width preference has changed
1405 * @param height true if the height preference has changed
1406 */
1407 public void preferenceChanged(View child, boolean width, boolean height) {
1408 editor.revalidate();
1409 }
1410
1411 /**
1412 * Determines the desired alignment for this view along an axis.
1413 *
1414 * @param axis may be either X_AXIS or Y_AXIS
1415 * @return the desired alignment, where 0.0 indicates the origin
1416 * and 1.0 the full span away from the origin
1417 */
1418 public float getAlignment(int axis) {
1419 if (view != null) {
1420 return view.getAlignment(axis);
1421 }
1422 return 0;
1423 }
1424
1425 /**
1426 * Renders the view.
1427 *
1428 * @param g the graphics context
1429 * @param allocation the region to render into
1430 */
1431 public void paint(Graphics g, Shape allocation) {
1432 if (view != null) {
1433 Rectangle alloc = (allocation instanceof Rectangle) ?
1434 (Rectangle)allocation : allocation.getBounds();
1435 setSize(alloc.width, alloc.height);
1436 view.paint(g, allocation);
1437 }
1438 }
1439
1440 /**
1441 * Sets the view parent.
1442 *
1443 * @param parent the parent view
1444 */
1445 public void setParent(View parent) {
1446 throw new Error("Can't set parent on root view");
1447 }
1448
1449 /**
1450 * Returns the number of views in this view. Since
1451 * this view simply wraps the root of the view hierarchy
1452 * it has exactly one child.
1453 *
1454 * @return the number of views
1455 * @see #getView
1456 */
1457 public int getViewCount() {
1458 return 1;
1459 }
1460
1461 /**
1462 * Gets the n-th view in this container.
1463 *
1464 * @param n the number of the view to get
1465 * @return the view
1466 */
1467 public View getView(int n) {
1468 return view;
1469 }
1470
1471 /**
1472 * Returns the child view index representing the given position in
1473 * the model. This is implemented to return the index of the only
1474 * child.
1475 *
1476 * @param pos the position >= 0
1477 * @return index of the view representing the given position, or
1478 * -1 if no view represents that position
1479 * @since 1.3
1480 */
1481 public int getViewIndex(int pos, Position.Bias b) {
1482 return 0;
1483 }
1484
1485 /**
1486 * Fetches the allocation for the given child view.
1487 * This enables finding out where various views
1488 * are located, without assuming the views store
1489 * their location. This returns the given allocation
1490 * since this view simply acts as a gateway between
1491 * the view hierarchy and the associated component.
1492 *
1493 * @param index the index of the child
1494 * @param a the allocation to this view.
1495 * @return the allocation to the child
1496 */
1497 public Shape getChildAllocation(int index, Shape a) {
1498 return a;
1499 }
1500
1501 /**
1502 * Provides a mapping from the document model coordinate space
1503 * to the coordinate space of the view mapped to it.
1504 *
1505 * @param pos the position to convert
1506 * @param a the allocated region to render into
1507 * @return the bounding box of the given position
1508 */
1509 public Shape modelToView(int pos, Shape a, Position.Bias b) throws BadLocationException {
1510 if (view != null) {
1511 return view.modelToView(pos, a, b);
1512 }
1513 return null;
1514 }
1515
1516 /**
1517 * Provides a mapping from the document model coordinate space
1518 * to the coordinate space of the view mapped to it.
1519 *
1520 * @param p0 the position to convert >= 0
1521 * @param b0 the bias toward the previous character or the
1522 * next character represented by p0, in case the
1523 * position is a boundary of two views.
1524 * @param p1 the position to convert >= 0
1525 * @param b1 the bias toward the previous character or the
1526 * next character represented by p1, in case the
1527 * position is a boundary of two views.
1528 * @param a the allocated region to render into
1529 * @return the bounding box of the given position is returned
1530 * @exception BadLocationException if the given position does
1531 * not represent a valid location in the associated document
1532 * @exception IllegalArgumentException for an invalid bias argument
1533 * @see View#viewToModel
1534 */
1535 public Shape modelToView(int p0, Position.Bias b0, int p1, Position.Bias b1, Shape a) throws BadLocationException {
1536 if (view != null) {
1537 return view.modelToView(p0, b0, p1, b1, a);
1538 }
1539 return null;
1540 }
1541
1542 /**
1543 * Provides a mapping from the view coordinate space to the logical
1544 * coordinate space of the model.
1545 *
1546 * @param x x coordinate of the view location to convert
1547 * @param y y coordinate of the view location to convert
1548 * @param a the allocated region to render into
1549 * @return the location within the model that best represents the
1550 * given point in the view
1551 */
1552 public int viewToModel(float x, float y, Shape a, Position.Bias[] bias) {
1553 if (view != null) {
1554 int retValue = view.viewToModel(x, y, a, bias);
1555 return retValue;
1556 }
1557 return -1;
1558 }
1559
1560 /**
1561 * Provides a way to determine the next visually represented model
1562 * location that one might place a caret. Some views may not be visible,
1563 * they might not be in the same order found in the model, or they just
1564 * might not allow access to some of the locations in the model.
1565 *
1566 * @param pos the position to convert >= 0
1567 * @param a the allocated region to render into
1568 * @param direction the direction from the current position that can
1569 * be thought of as the arrow keys typically found on a keyboard.
1570 * This may be SwingConstants.WEST, SwingConstants.EAST,
1571 * SwingConstants.NORTH, or SwingConstants.SOUTH.
1572 * @return the location within the model that best represents the next
1573 * location visual position.
1574 * @exception BadLocationException
1575 * @exception IllegalArgumentException for an invalid direction
1576 */
1577 public int getNextVisualPositionFrom(int pos, Position.Bias b, Shape a,
1578 int direction,
1579 Position.Bias[] biasRet)
1580 throws BadLocationException {
1581 if( view != null ) {
1582 int nextPos = view.getNextVisualPositionFrom(pos, b, a,
1583 direction, biasRet);
1584 if(nextPos != -1) {
1585 pos = nextPos;
1586 }
1587 else {
1588 biasRet[0] = b;
1589 }
1590 }
1591 return pos;
1592 }
1593
1594 /**
1595 * Gives notification that something was inserted into the document
1596 * in a location that this view is responsible for.
1597 *
1598 * @param e the change information from the associated document
1599 * @param a the current allocation of the view
1600 * @param f the factory to use to rebuild if the view has children
1601 */
1602 public void insertUpdate(DocumentEvent e, Shape a, ViewFactory f) {
1603 if (view != null) {
1604 view.insertUpdate(e, a, f);
1605 }
1606 }
1607
1608 /**
1609 * Gives notification that something was removed from the document
1610 * in a location that this view is responsible for.
1611 *
1612 * @param e the change information from the associated document
1613 * @param a the current allocation of the view
1614 * @param f the factory to use to rebuild if the view has children
1615 */
1616 public void removeUpdate(DocumentEvent e, Shape a, ViewFactory f) {
1617 if (view != null) {
1618 view.removeUpdate(e, a, f);
1619 }
1620 }
1621
1622 /**
1623 * Gives notification from the document that attributes were changed
1624 * in a location that this view is responsible for.
1625 *
1626 * @param e the change information from the associated document
1627 * @param a the current allocation of the view
1628 * @param f the factory to use to rebuild if the view has children
1629 */
1630 public void changedUpdate(DocumentEvent e, Shape a, ViewFactory f) {
1631 if (view != null) {
1632 view.changedUpdate(e, a, f);
1633 }
1634 }
1635
1636 /**
1637 * Returns the document model underlying the view.
1638 *
1639 * @return the model
1640 */
1641 public Document getDocument() {
1642 return editor.getDocument();
1643 }
1644
1645 /**
1646 * Returns the starting offset into the model for this view.
1647 *
1648 * @return the starting offset
1649 */
1650 public int getStartOffset() {
1651 if (view != null) {
1652 return view.getStartOffset();
1653 }
1654 return getElement().getStartOffset();
1655 }
1656
1657 /**
1658 * Returns the ending offset into the model for this view.
1659 *
1660 * @return the ending offset
1661 */
1662 public int getEndOffset() {
1663 if (view != null) {
1664 return view.getEndOffset();
1665 }
1666 return getElement().getEndOffset();
1667 }
1668
1669 /**
1670 * Gets the element that this view is mapped to.
1671 *
1672 * @return the view
1673 */
1674 public Element getElement() {
1675 if (view != null) {
1676 return view.getElement();
1677 }
1678 return editor.getDocument().getDefaultRootElement();
1679 }
1680
1681 /**
1682 * Breaks this view on the given axis at the given length.
1683 *
1684 * @param axis may be either X_AXIS or Y_AXIS
1685 * @param len specifies where a break is desired in the span
1686 * @param the current allocation of the view
1687 * @return the fragment of the view that represents the given span
1688 * if the view can be broken, otherwise null
1689 */
1690 public View breakView(int axis, float len, Shape a) {
1691 throw new Error("Can't break root view");
1692 }
1693
1694 /**
1695 * Determines the resizability of the view along the
1696 * given axis. A value of 0 or less is not resizable.
1697 *
1698 * @param axis may be either X_AXIS or Y_AXIS
1699 * @return the weight
1700 */
1701 public int getResizeWeight(int axis) {
1702 if (view != null) {
1703 return view.getResizeWeight(axis);
1704 }
1705 return 0;
1706 }
1707
1708 /**
1709 * Sets the view size.
1710 *
1711 * @param width the width
1712 * @param height the height
1713 */
1714 public void setSize(float width, float height) {
1715 if (view != null) {
1716 view.setSize(width, height);
1717 }
1718 }
1719
1720 /**
1721 * Fetches the container hosting the view. This is useful for
1722 * things like scheduling a repaint, finding out the host
1723 * components font, etc. The default implementation
1724 * of this is to forward the query to the parent view.
1725 *
1726 * @return the container
1727 */
1728 public Container getContainer() {
1729 return editor;
1730 }
1731
1732 /**
1733 * Fetches the factory to be used for building the
1734 * various view fragments that make up the view that
1735 * represents the model. This is what determines
1736 * how the model will be represented. This is implemented
1737 * to fetch the factory provided by the associated
1738 * EditorKit unless that is null, in which case this
1739 * simply returns the BasicTextUI itself which allows
1740 * subclasses to implement a simple factory directly without
1741 * creating extra objects.
1742 *
1743 * @return the factory
1744 */
1745 public ViewFactory getViewFactory() {
1746 EditorKit kit = getEditorKit(editor);
1747 ViewFactory f = kit.getViewFactory();
1748 if (f != null) {
1749 return f;
1750 }
1751 return BasicTextUI.this;
1752 }
1753
1754 private View view;
1755
1756 }
1757
1758 /**
1759 * Handles updates from various places. If the model is changed,
1760 * this class unregisters as a listener to the old model and
1761 * registers with the new model. If the document model changes,
1762 * the change is forwarded to the root view. If the focus
1763 * accelerator changes, a new keystroke is registered to request
1764 * focus.
1765 */
1766 class UpdateHandler implements PropertyChangeListener, DocumentListener, LayoutManager2, UIResource {
1767
1768 // --- PropertyChangeListener methods -----------------------
1769
1770 /**
1771 * This method gets called when a bound property is changed.
1772 * We are looking for document changes on the editor.
1773 */
1774 public final void propertyChange(PropertyChangeEvent evt) {
1775 Object oldValue = evt.getOldValue();
1776 Object newValue = evt.getNewValue();
1777 String propertyName = evt.getPropertyName();
1778 if ((oldValue instanceof Document) || (newValue instanceof Document)) {
1779 if (oldValue != null) {
1780 ((Document)oldValue).removeDocumentListener(this);
1781 i18nView = false;
1782 }
1783 if (newValue != null) {
1784 ((Document)newValue).addDocumentListener(this);
1785 if ("document" == propertyName) {
1786 setView(null);
1787 BasicTextUI.this.propertyChange(evt);
1788 modelChanged();
1789 return;
1790 }
1791 }
1792 modelChanged();
1793 }
1794 if ("focusAccelerator" == propertyName) {
1795 updateFocusAcceleratorBinding(true);
1796 } else if ("componentOrientation" == propertyName) {
1797 // Changes in ComponentOrientation require the views to be
1798 // rebuilt.
1799 modelChanged();
1800 } else if ("font" == propertyName) {
1801 modelChanged();
1802 } else if ("dropLocation" == propertyName) {
1803 dropIndexChanged();
1804 } else if ("editable" == propertyName) {
1805 updateCursor();
1806 modelChanged();
1807 }
1808 BasicTextUI.this.propertyChange(evt);
1809 }
1810
1811 private void dropIndexChanged() {
1812 if (editor.getDropMode() == DropMode.USE_SELECTION) {
1813 return;
1814 }
1815
1816 JTextComponent.DropLocation dropLocation = editor.getDropLocation();
1817
1818 if (dropLocation == null) {
1819 if (dropCaret != null) {
1820 dropCaret.deinstall(editor);
1821 editor.repaint(dropCaret);
1822 dropCaret = null;
1823 }
1824 } else {
1825 if (dropCaret == null) {
1826 dropCaret = new BasicCaret();
1827 dropCaret.install(editor);
1828 dropCaret.setVisible(true);
1829 }
1830
1831 dropCaret.setDot(dropLocation.getIndex(),
1832 dropLocation.getBias());
1833 }
1834 }
1835
1836 // --- DocumentListener methods -----------------------
1837
1838 /**
1839 * The insert notification. Gets sent to the root of the view structure
1840 * that represents the portion of the model being represented by the
1841 * editor. The factory is added as an argument to the update so that
1842 * the views can update themselves in a dynamic (not hardcoded) way.
1843 *
1844 * @param e The change notification from the currently associated
1845 * document.
1846 * @see DocumentListener#insertUpdate
1847 */
1848 public final void insertUpdate(DocumentEvent e) {
1849 Document doc = e.getDocument();
1850 Object o = doc.getProperty("i18n");
1851 if (o instanceof Boolean) {
1852 Boolean i18nFlag = (Boolean) o;
1853 if (i18nFlag.booleanValue() != i18nView) {
1854 // i18n flag changed, rebuild the view
1855 i18nView = i18nFlag.booleanValue();
1856 modelChanged();
1857 return;
1858 }
1859 }
1860
1861 // normal insert update
1862 Rectangle alloc = (painted) ? getVisibleEditorRect() : null;
1863 rootView.insertUpdate(e, alloc, rootView.getViewFactory());
1864 }
1865
1866 /**
1867 * The remove notification. Gets sent to the root of the view structure
1868 * that represents the portion of the model being represented by the
1869 * editor. The factory is added as an argument to the update so that
1870 * the views can update themselves in a dynamic (not hardcoded) way.
1871 *
1872 * @param e The change notification from the currently associated
1873 * document.
1874 * @see DocumentListener#removeUpdate
1875 */
1876 public final void removeUpdate(DocumentEvent e) {
1877 Rectangle alloc = (painted) ? getVisibleEditorRect() : null;
1878 rootView.removeUpdate(e, alloc, rootView.getViewFactory());
1879 }
1880
1881 /**
1882 * The change notification. Gets sent to the root of the view structure
1883 * that represents the portion of the model being represented by the
1884 * editor. The factory is added as an argument to the update so that
1885 * the views can update themselves in a dynamic (not hardcoded) way.
1886 *
1887 * @param e The change notification from the currently associated
1888 * document.
1889 * @see DocumentListener#changedUpdate(DocumentEvent)
1890 */
1891 public final void changedUpdate(DocumentEvent e) {
1892 Rectangle alloc = (painted) ? getVisibleEditorRect() : null;
1893 rootView.changedUpdate(e, alloc, rootView.getViewFactory());
1894 }
1895
1896 // --- LayoutManager2 methods --------------------------------
1897
1898 /**
1899 * Adds the specified component with the specified name to
1900 * the layout.
1901 * @param name the component name
1902 * @param comp the component to be added
1903 */
1904 public void addLayoutComponent(String name, Component comp) {
1905 // not supported
1906 }
1907
1908 /**
1909 * Removes the specified component from the layout.
1910 * @param comp the component to be removed
1911 */
1912 public void removeLayoutComponent(Component comp) {
1913 if (constraints != null) {
1914 // remove the constraint record
1915 constraints.remove(comp);
1916 }
1917 }
1918
1919 /**
1920 * Calculates the preferred size dimensions for the specified
1921 * panel given the components in the specified parent container.
1922 * @param parent the component to be laid out
1923 *
1924 * @see #minimumLayoutSize
1925 */
1926 public Dimension preferredLayoutSize(Container parent) {
1927 // should not be called (JComponent uses UI instead)
1928 return null;
1929 }
1930
1931 /**
1932 * Calculates the minimum size dimensions for the specified
1933 * panel given the components in the specified parent container.
1934 * @param parent the component to be laid out
1935 * @see #preferredLayoutSize
1936 */
1937 public Dimension minimumLayoutSize(Container parent) {
1938 // should not be called (JComponent uses UI instead)
1939 return null;
1940 }
1941
1942 /**
1943 * Lays out the container in the specified panel. This is
1944 * implemented to position all components that were added
1945 * with a View object as a constraint. The current allocation
1946 * of the associated View is used as the location of the
1947 * component.
1948 * <p>
1949 * A read-lock is acquired on the document to prevent the
1950 * view tree from being modified while the layout process
1951 * is active.
1952 *
1953 * @param parent the component which needs to be laid out
1954 */
1955 public void layoutContainer(Container parent) {
1956 if ((constraints != null) && (! constraints.isEmpty())) {
1957 Rectangle alloc = getVisibleEditorRect();
1958 if (alloc != null) {
1959 Document doc = editor.getDocument();
1960 if (doc instanceof AbstractDocument) {
1961 ((AbstractDocument)doc).readLock();
1962 }
1963 try {
1964 rootView.setSize(alloc.width, alloc.height);
1965 Enumeration<Component> components = constraints.keys();
1966 while (components.hasMoreElements()) {
1967 Component comp = components.nextElement();
1968 View v = (View) constraints.get(comp);
1969 Shape ca = calculateViewPosition(alloc, v);
1970 if (ca != null) {
1971 Rectangle compAlloc = (ca instanceof Rectangle) ?
1972 (Rectangle) ca : ca.getBounds();
1973 comp.setBounds(compAlloc);
1974 }
1975 }
1976 } finally {
1977 if (doc instanceof AbstractDocument) {
1978 ((AbstractDocument)doc).readUnlock();
1979 }
1980 }
1981 }
1982 }
1983 }
1984
1985 /**
1986 * Find the Shape representing the given view.
1987 */
1988 Shape calculateViewPosition(Shape alloc, View v) {
1989 int pos = v.getStartOffset();
1990 View child = null;
1991 for (View parent = rootView; (parent != null) && (parent != v); parent = child) {
1992 int index = parent.getViewIndex(pos, Position.Bias.Forward);
1993 alloc = parent.getChildAllocation(index, alloc);
1994 child = parent.getView(index);
1995 }
1996 return (child != null) ? alloc : null;
1997 }
1998
1999 /**
2000 * Adds the specified component to the layout, using the specified
2001 * constraint object. We only store those components that were added
2002 * with a constraint that is of type View.
2003 *
2004 * @param comp the component to be added
2005 * @param constraint where/how the component is added to the layout.
2006 */
2007 public void addLayoutComponent(Component comp, Object constraint) {
2008 if (constraint instanceof View) {
2009 if (constraints == null) {
2010 constraints = new Hashtable<Component, Object>(7);
2011 }
2012 constraints.put(comp, constraint);
2013 }
2014 }
2015
2016 /**
2017 * Returns the maximum size of this component.
2018 * @see java.awt.Component#getMinimumSize()
2019 * @see java.awt.Component#getPreferredSize()
2020 * @see LayoutManager
2021 */
2022 public Dimension maximumLayoutSize(Container target) {
2023 // should not be called (JComponent uses UI instead)
2024 return null;
2025 }
2026
2027 /**
2028 * Returns the alignment along the x axis. This specifies how
2029 * the component would like to be aligned relative to other
2030 * components. The value should be a number between 0 and 1
2031 * where 0 represents alignment along the origin, 1 is aligned
2032 * the furthest away from the origin, 0.5 is centered, etc.
2033 */
2034 public float getLayoutAlignmentX(Container target) {
2035 return 0.5f;
2036 }
2037
2038 /**
2039 * Returns the alignment along the y axis. This specifies how
2040 * the component would like to be aligned relative to other
2041 * components. The value should be a number between 0 and 1
2042 * where 0 represents alignment along the origin, 1 is aligned
2043 * the furthest away from the origin, 0.5 is centered, etc.
2044 */
2045 public float getLayoutAlignmentY(Container target) {
2046 return 0.5f;
2047 }
2048
2049 /**
2050 * Invalidates the layout, indicating that if the layout manager
2051 * has cached information it should be discarded.
2052 */
2053 public void invalidateLayout(Container target) {
2054 }
2055
2056 /**
2057 * The "layout constraints" for the LayoutManager2 implementation.
2058 * These are View objects for those components that are represented
2059 * by a View in the View tree.
2060 */
2061 private Hashtable<Component, Object> constraints;
2062
2063 private boolean i18nView = false;
2064 }
2065
2066 /**
2067 * Wrapper for text actions to return isEnabled false in case editor is non editable
2068 */
2069 class TextActionWrapper extends TextAction {
2070 public TextActionWrapper(TextAction action) {
2071 super((String)action.getValue(Action.NAME));
2072 this.action = action;
2073 }
2074 /**
2075 * The operation to perform when this action is triggered.
2076 *
2077 * @param e the action event
2078 */
2079 public void actionPerformed(ActionEvent e) {
2080 action.actionPerformed(e);
2081 }
2082 public boolean isEnabled() {
2083 return (editor == null || editor.isEditable()) ? action.isEnabled() : false;
2084 }
2085 TextAction action = null;
2086 }
2087
2088
2089 /**
2090 * Registered in the ActionMap.
2091 */
2092 class FocusAction extends AbstractAction {
2093
2094 public void actionPerformed(ActionEvent e) {
2095 editor.requestFocus();
2096 }
2097
2098 public boolean isEnabled() {
2099 return editor.isEditable();
2100 }
2101 }
2102
2103 private static DragListener getDragListener() {
2104 synchronized(DragListener.class) {
2105 DragListener listener =
2106 (DragListener)AppContext.getAppContext().
2107 get(DragListener.class);
2108
2109 if (listener == null) {
2110 listener = new DragListener();
2111 AppContext.getAppContext().put(DragListener.class, listener);
2112 }
2113
2114 return listener;
2115 }
2116 }
2117
2118 /**
2119 * Listens for mouse events for the purposes of detecting drag gestures.
2120 * BasicTextUI will maintain one of these per AppContext.
2121 */
2122 static class DragListener extends MouseInputAdapter
2123 implements BeforeDrag {
2124
2125 private boolean dragStarted;
2126
2127 public void dragStarting(MouseEvent me) {
2128 dragStarted = true;
2129 }
2130
2131 public void mousePressed(MouseEvent e) {
2132 JTextComponent c = (JTextComponent)e.getSource();
2133 if (c.getDragEnabled()) {
2134 dragStarted = false;
2135 if (isDragPossible(e) && DragRecognitionSupport.mousePressed(e)) {
2136 e.consume();
2137 }
2138 }
2139 }
2140
2141 public void mouseReleased(MouseEvent e) {
2142 JTextComponent c = (JTextComponent)e.getSource();
2143 if (c.getDragEnabled()) {
2144 if (dragStarted) {
2145 e.consume();
2146 }
2147
2148 DragRecognitionSupport.mouseReleased(e);
2149 }
2150 }
2151
2152 public void mouseDragged(MouseEvent e) {
2153 JTextComponent c = (JTextComponent)e.getSource();
2154 if (c.getDragEnabled()) {
2155 if (dragStarted || DragRecognitionSupport.mouseDragged(e, this)) {
2156 e.consume();
2157 }
2158 }
2159 }
2160
2161 /**
2162 * Determines if the following are true:
2163 * <ul>
2164 * <li>the component is enabled
2165 * <li>the press event is located over a selection
2166 * </ul>
2167 */
2168 protected boolean isDragPossible(MouseEvent e) {
2169 JTextComponent c = (JTextComponent)e.getSource();
2170 if (c.isEnabled()) {
2171 Caret caret = c.getCaret();
2172 int dot = caret.getDot();
2173 int mark = caret.getMark();
2174 if (dot != mark) {
2175 Point p = new Point(e.getX(), e.getY());
2176 int pos = c.viewToModel(p);
2177
2178 int p0 = Math.min(dot, mark);
2179 int p1 = Math.max(dot, mark);
2180 if ((pos >= p0) && (pos < p1)) {
2181 return true;
2182 }
2183 }
2184 }
2185 return false;
2186 }
2187 }
2188
2189 static class TextTransferHandler extends TransferHandler implements UIResource {
2190
2191 private JTextComponent exportComp;
2192 private boolean shouldRemove;
2193 private int p0;
2194 private int p1;
2195
2196 /**
2197 * Whether or not this is a drop using
2198 * <code>DropMode.INSERT</code>.
2199 */
2200 private boolean modeBetween = false;
2201
2202 /**
2203 * Whether or not this is a drop.
2204 */
2205 private boolean isDrop = false;
2206
2207 /**
2208 * The drop action.
2209 */
2210 private int dropAction = MOVE;
2211
2212 /**
2213 * The drop bias.
2214 */
2215 private Position.Bias dropBias;
2216
2217 /**
2218 * Try to find a flavor that can be used to import a Transferable.
2219 * The set of usable flavors are tried in the following order:
2220 * <ol>
2221 * <li>First, an attempt is made to find a flavor matching the content type
2222 * of the EditorKit for the component.
2223 * <li>Second, an attempt to find a text/plain flavor is made.
2224 * <li>Third, an attempt to find a flavor representing a String reference
2225 * in the same VM is made.
2226 * <li>Lastly, DataFlavor.stringFlavor is searched for.
2227 * </ol>
2228 */
2229 protected DataFlavor getImportFlavor(DataFlavor[] flavors, JTextComponent c) {
2230 DataFlavor plainFlavor = null;
2231 DataFlavor refFlavor = null;
2232 DataFlavor stringFlavor = null;
2233
2234 if (c instanceof JEditorPane) {
2235 for (int i = 0; i < flavors.length; i++) {
2236 String mime = flavors[i].getMimeType();
2237 if (mime.startsWith(((JEditorPane)c).getEditorKit().getContentType())) {
2238 return flavors[i];
2239 } else if (plainFlavor == null && mime.startsWith("text/plain")) {
2240 plainFlavor = flavors[i];
2241 } else if (refFlavor == null && mime.startsWith("application/x-java-jvm-local-objectref")
2242 && flavors[i].getRepresentationClass() == java.lang.String.class) {
2243 refFlavor = flavors[i];
2244 } else if (stringFlavor == null && flavors[i].equals(DataFlavor.stringFlavor)) {
2245 stringFlavor = flavors[i];
2246 }
2247 }
2248 if (plainFlavor != null) {
2249 return plainFlavor;
2250 } else if (refFlavor != null) {
2251 return refFlavor;
2252 } else if (stringFlavor != null) {
2253 return stringFlavor;
2254 }
2255 return null;
2256 }
2257
2258
2259 for (int i = 0; i < flavors.length; i++) {
2260 String mime = flavors[i].getMimeType();
2261 if (mime.startsWith("text/plain")) {
2262 return flavors[i];
2263 } else if (refFlavor == null && mime.startsWith("application/x-java-jvm-local-objectref")
2264 && flavors[i].getRepresentationClass() == java.lang.String.class) {
2265 refFlavor = flavors[i];
2266 } else if (stringFlavor == null && flavors[i].equals(DataFlavor.stringFlavor)) {
2267 stringFlavor = flavors[i];
2268 }
2269 }
2270 if (refFlavor != null) {
2271 return refFlavor;
2272 } else if (stringFlavor != null) {
2273 return stringFlavor;
2274 }
2275 return null;
2276 }
2277
2278 /**
2279 * Import the given stream data into the text component.
2280 */
2281 protected void handleReaderImport(Reader in, JTextComponent c, boolean useRead)
2282 throws BadLocationException, IOException {
2283 if (useRead) {
2284 int startPosition = c.getSelectionStart();
2285 int endPosition = c.getSelectionEnd();
2286 int length = endPosition - startPosition;
2287 EditorKit kit = c.getUI().getEditorKit(c);
2288 Document doc = c.getDocument();
2289 if (length > 0) {
2290 doc.remove(startPosition, length);
2291 }
2292 kit.read(in, doc, startPosition);
2293 } else {
2294 char[] buff = new char[1024];
2295 int nch;
2296 boolean lastWasCR = false;
2297 int last;
2298 StringBuffer sbuff = null;
2299
2300 // Read in a block at a time, mapping \r\n to \n, as well as single
2301 // \r to \n.
2302 while ((nch = in.read(buff, 0, buff.length)) != -1) {
2303 if (sbuff == null) {
2304 sbuff = new StringBuffer(nch);
2305 }
2306 last = 0;
2307 for(int counter = 0; counter < nch; counter++) {
2308 switch(buff[counter]) {
2309 case '\r':
2310 if (lastWasCR) {
2311 if (counter == 0) {
2312 sbuff.append('\n');
2313 } else {
2314 buff[counter - 1] = '\n';
2315 }
2316 } else {
2317 lastWasCR = true;
2318 }
2319 break;
2320 case '\n':
2321 if (lastWasCR) {
2322 if (counter > (last + 1)) {
2323 sbuff.append(buff, last, counter - last - 1);
2324 }
2325 // else nothing to do, can skip \r, next write will
2326 // write \n
2327 lastWasCR = false;
2328 last = counter;
2329 }
2330 break;
2331 default:
2332 if (lastWasCR) {
2333 if (counter == 0) {
2334 sbuff.append('\n');
2335 } else {
2336 buff[counter - 1] = '\n';
2337 }
2338 lastWasCR = false;
2339 }
2340 break;
2341 }
2342 }
2343 if (last < nch) {
2344 if (lastWasCR) {
2345 if (last < (nch - 1)) {
2346 sbuff.append(buff, last, nch - last - 1);
2347 }
2348 } else {
2349 sbuff.append(buff, last, nch - last);
2350 }
2351 }
2352 }
2353 if (lastWasCR) {
2354 sbuff.append('\n');
2355 }
2356 c.replaceSelection(sbuff != null ? sbuff.toString() : "");
2357 }
2358 }
2359
2360 // --- TransferHandler methods ------------------------------------
2361
2362 /**
2363 * This is the type of transfer actions supported by the source. Some models are
2364 * not mutable, so a transfer operation of COPY only should
2365 * be advertised in that case.
2366 *
2367 * @param c The component holding the data to be transfered. This
2368 * argument is provided to enable sharing of TransferHandlers by
2369 * multiple components.
2370 * @return This is implemented to return NONE if the component is a JPasswordField
2371 * since exporting data via user gestures is not allowed. If the text component is
2372 * editable, COPY_OR_MOVE is returned, otherwise just COPY is allowed.
2373 */
2374 public int getSourceActions(JComponent c) {
2375 if (c instanceof JPasswordField &&
2376 c.getClientProperty("JPasswordField.cutCopyAllowed") !=
2377 Boolean.TRUE) {
2378 return NONE;
2379 }
2380
2381 return ((JTextComponent)c).isEditable() ? COPY_OR_MOVE : COPY;
2382 }
2383
2384 /**
2385 * Create a Transferable to use as the source for a data transfer.
2386 *
2387 * @param comp The component holding the data to be transfered. This
2388 * argument is provided to enable sharing of TransferHandlers by
2389 * multiple components.
2390 * @return The representation of the data to be transfered.
2391 *
2392 */
2393 protected Transferable createTransferable(JComponent comp) {
2394 exportComp = (JTextComponent)comp;
2395 shouldRemove = true;
2396 p0 = exportComp.getSelectionStart();
2397 p1 = exportComp.getSelectionEnd();
2398 return (p0 != p1) ? (new TextTransferable(exportComp, p0, p1)) : null;
2399 }
2400
2401 /**
2402 * This method is called after data has been exported. This method should remove
2403 * the data that was transfered if the action was MOVE.
2404 *
2405 * @param source The component that was the source of the data.
2406 * @param data The data that was transferred or possibly null
2407 * if the action is <code>NONE</code>.
2408 * @param action The actual action that was performed.
2409 */
2410 protected void exportDone(JComponent source, Transferable data, int action) {
2411 // only remove the text if shouldRemove has not been set to
2412 // false by importData and only if the action is a move
2413 if (shouldRemove && action == MOVE) {
2414 TextTransferable t = (TextTransferable)data;
2415 t.removeText();
2416 }
2417
2418 exportComp = null;
2419 }
2420
2421 public boolean importData(TransferSupport support) {
2422 isDrop = support.isDrop();
2423
2424 if (isDrop) {
2425 modeBetween =
2426 ((JTextComponent)support.getComponent()).getDropMode() == DropMode.INSERT;
2427
2428 dropBias = ((JTextComponent.DropLocation)support.getDropLocation()).getBias();
2429
2430 dropAction = support.getDropAction();
2431 }
2432
2433 try {
2434 return super.importData(support);
2435 } finally {
2436 isDrop = false;
2437 modeBetween = false;
2438 dropBias = null;
2439 dropAction = MOVE;
2440 }
2441 }
2442
2443 /**
2444 * This method causes a transfer to a component from a clipboard or a
2445 * DND drop operation. The Transferable represents the data to be
2446 * imported into the component.
2447 *
2448 * @param comp The component to receive the transfer. This
2449 * argument is provided to enable sharing of TransferHandlers by
2450 * multiple components.
2451 * @param t The data to import
2452 * @return true if the data was inserted into the component, false otherwise.
2453 */
2454 public boolean importData(JComponent comp, Transferable t) {
2455 JTextComponent c = (JTextComponent)comp;
2456
2457 int pos = modeBetween
2458 ? c.getDropLocation().getIndex() : c.getCaretPosition();
2459
2460 // if we are importing to the same component that we exported from
2461 // then don't actually do anything if the drop location is inside
2462 // the drag location and set shouldRemove to false so that exportDone
2463 // knows not to remove any data
2464 if (dropAction == MOVE && c == exportComp && pos >= p0 && pos <= p1) {
2465 shouldRemove = false;
2466 return true;
2467 }
2468
2469 boolean imported = false;
2470 DataFlavor importFlavor = getImportFlavor(t.getTransferDataFlavors(), c);
2471 if (importFlavor != null) {
2472 try {
2473 boolean useRead = false;
2474 if (comp instanceof JEditorPane) {
2475 JEditorPane ep = (JEditorPane)comp;
2476 if (!ep.getContentType().startsWith("text/plain") &&
2477 importFlavor.getMimeType().startsWith(ep.getContentType())) {
2478 useRead = true;
2479 }
2480 }
2481 InputContext ic = c.getInputContext();
2482 if (ic != null) {
2483 ic.endComposition();
2484 }
2485 Reader r = importFlavor.getReaderForText(t);
2486
2487 if (modeBetween) {
2488 Caret caret = c.getCaret();
2489 if (caret instanceof DefaultCaret) {
2490 ((DefaultCaret)caret).setDot(pos, dropBias);
2491 } else {
2492 c.setCaretPosition(pos);
2493 }
2494 }
2495
2496 handleReaderImport(r, c, useRead);
2497
2498 if (isDrop) {
2499 c.requestFocus();
2500 Caret caret = c.getCaret();
2501 if (caret instanceof DefaultCaret) {
2502 int newPos = caret.getDot();
2503 Position.Bias newBias = ((DefaultCaret)caret).getDotBias();
2504
2505 ((DefaultCaret)caret).setDot(pos, dropBias);
2506 ((DefaultCaret)caret).moveDot(newPos, newBias);
2507 } else {
2508 c.select(pos, c.getCaretPosition());
2509 }
2510 }
2511
2512 imported = true;
2513 } catch (UnsupportedFlavorException ufe) {
2514 } catch (BadLocationException ble) {
2515 } catch (IOException ioe) {
2516 }
2517 }
2518 return imported;
2519 }
2520
2521 /**
2522 * This method indicates if a component would accept an import of the given
2523 * set of data flavors prior to actually attempting to import it.
2524 *
2525 * @param comp The component to receive the transfer. This
2526 * argument is provided to enable sharing of TransferHandlers by
2527 * multiple components.
2528 * @param flavors The data formats available
2529 * @return true if the data can be inserted into the component, false otherwise.
2530 */
2531 public boolean canImport(JComponent comp, DataFlavor[] flavors) {
2532 JTextComponent c = (JTextComponent)comp;
2533 if (!(c.isEditable() && c.isEnabled())) {
2534 return false;
2535 }
2536 return (getImportFlavor(flavors, c) != null);
2537 }
2538
2539 /**
2540 * A possible implementation of the Transferable interface
2541 * for text components. For a JEditorPane with a rich set
2542 * of EditorKit implementations, conversions could be made
2543 * giving a wider set of formats. This is implemented to
2544 * offer up only the active content type and text/plain
2545 * (if that is not the active format) since that can be
2546 * extracted from other formats.
2547 */
2548 static class TextTransferable extends BasicTransferable {
2549
2550 TextTransferable(JTextComponent c, int start, int end) {
2551 super(null, null);
2552
2553 this.c = c;
2554
2555 Document doc = c.getDocument();
2556
2557 try {
2558 p0 = doc.createPosition(start);
2559 p1 = doc.createPosition(end);
2560
2561 plainData = c.getSelectedText();
2562
2563 if (c instanceof JEditorPane) {
2564 JEditorPane ep = (JEditorPane)c;
2565
2566 mimeType = ep.getContentType();
2567
2568 if (mimeType.startsWith("text/plain")) {
2569 return;
2570 }
2571
2572 StringWriter sw = new StringWriter(p1.getOffset() - p0.getOffset());
2573 ep.getEditorKit().write(sw, doc, p0.getOffset(), p1.getOffset() - p0.getOffset());
2574
2575 if (mimeType.startsWith("text/html")) {
2576 htmlData = sw.toString();
2577 } else {
2578 richText = sw.toString();
2579 }
2580 }
2581 } catch (BadLocationException ble) {
2582 } catch (IOException ioe) {
2583 }
2584 }
2585
2586 void removeText() {
2587 if ((p0 != null) && (p1 != null) && (p0.getOffset() != p1.getOffset())) {
2588 try {
2589 Document doc = c.getDocument();
2590 doc.remove(p0.getOffset(), p1.getOffset() - p0.getOffset());
2591 } catch (BadLocationException e) {
2592 }
2593 }
2594 }
2595
2596 // ---- EditorKit other than plain or HTML text -----------------------
2597
2598 /**
2599 * If the EditorKit is not for text/plain or text/html, that format
2600 * is supported through the "richer flavors" part of BasicTransferable.
2601 */
2602 protected DataFlavor[] getRicherFlavors() {
2603 if (richText == null) {
2604 return null;
2605 }
2606
2607 try {
2608 DataFlavor[] flavors = new DataFlavor[3];
2609 flavors[0] = new DataFlavor(mimeType + ";class=java.lang.String");
2610 flavors[1] = new DataFlavor(mimeType + ";class=java.io.Reader");
2611 flavors[2] = new DataFlavor(mimeType + ";class=java.io.InputStream;charset=unicode");
2612 return flavors;
2613 } catch (ClassNotFoundException cle) {
2614 // fall through to unsupported (should not happen)
2615 }
2616
2617 return null;
2618 }
2619
2620 /**
2621 * The only richer format supported is the file list flavor
2622 */
2623 protected Object getRicherData(DataFlavor flavor) throws UnsupportedFlavorException {
2624 if (richText == null) {
2625 return null;
2626 }
2627
2628 if (String.class.equals(flavor.getRepresentationClass())) {
2629 return richText;
2630 } else if (Reader.class.equals(flavor.getRepresentationClass())) {
2631 return new StringReader(richText);
2632 } else if (InputStream.class.equals(flavor.getRepresentationClass())) {
2633 return new StringBufferInputStream(richText);
2634 }
2635 throw new UnsupportedFlavorException(flavor);
2636 }
2637
2638 Position p0;
2639 Position p1;
2640 String mimeType;
2641 String richText;
2642 JTextComponent c;
2643 }
2644
2645 }
2646
2647 }