| /* DefaultEditorKit.java -- |
| Copyright (C) 2002, 2004, 2005 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.text; |
| |
| import java.awt.Point; |
| import java.awt.Toolkit; |
| import java.awt.event.ActionEvent; |
| |
| import java.io.BufferedReader; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.InputStreamReader; |
| import java.io.OutputStream; |
| import java.io.OutputStreamWriter; |
| import java.io.Reader; |
| import java.io.Writer; |
| |
| import javax.swing.Action; |
| import javax.swing.SwingConstants; |
| |
| /** |
| * The default implementation of {@link EditorKit}. This <code>EditorKit</code> |
| * a plain text <code>Document</code> and several commands that together |
| * make up a basic editor, like cut / copy + paste. |
| * |
| * @author original author unknown |
| * @author Roman Kennke (roman@kennke.org) |
| * @author Robert Schuster (robertschuster@fsfe.org) |
| */ |
| public class DefaultEditorKit extends EditorKit |
| { |
| static class SelectionPreviousWordAction |
| extends TextAction |
| { |
| SelectionPreviousWordAction() |
| { |
| super(selectionPreviousWordAction); |
| } |
| |
| public void actionPerformed(ActionEvent event) |
| { |
| try |
| { |
| JTextComponent t = getTextComponent(event); |
| |
| if (t != null) |
| { |
| int offs = Utilities.getPreviousWord(t, t.getCaretPosition()); |
| |
| Caret c = t.getCaret(); |
| c.moveDot(offs); |
| c.setMagicCaretPosition(t.modelToView(offs).getLocation()); |
| } |
| } |
| catch(BadLocationException ble) |
| { |
| // Can't happen. |
| } |
| } |
| } |
| |
| static class SelectionNextWordAction |
| extends TextAction |
| { |
| SelectionNextWordAction() |
| { |
| super(selectionNextWordAction); |
| } |
| |
| public void actionPerformed(ActionEvent event) |
| { |
| try |
| { |
| JTextComponent t = getTextComponent(event); |
| |
| if (t != null) |
| { |
| int offs = Utilities.getNextWord(t, t.getCaretPosition()); |
| |
| Caret c = t.getCaret(); |
| c.moveDot(offs); |
| c.setMagicCaretPosition(t.modelToView(offs).getLocation()); |
| } |
| } |
| catch(BadLocationException ble) |
| { |
| // Can't happen. |
| } |
| } |
| } |
| |
| static class SelectionBeginWordAction extends TextAction |
| { |
| SelectionBeginWordAction() |
| { |
| super(selectionBeginWordAction); |
| } |
| |
| public void actionPerformed(ActionEvent event) |
| { |
| try |
| { |
| JTextComponent t = getTextComponent(event); |
| |
| if (t != null) |
| { |
| int offs = Utilities.getWordStart(t, t.getCaretPosition()); |
| |
| Caret c = t.getCaret(); |
| c.moveDot(offs); |
| c.setMagicCaretPosition(t.modelToView(offs).getLocation()); |
| } |
| } |
| catch(BadLocationException ble) |
| { |
| // Can't happen. |
| } |
| } |
| } |
| |
| static class SelectionEndWordAction extends TextAction |
| { |
| SelectionEndWordAction() |
| { |
| super(selectionEndWordAction); |
| } |
| |
| public void actionPerformed(ActionEvent event) |
| { |
| try |
| { |
| JTextComponent t = getTextComponent(event); |
| |
| if (t != null) |
| { |
| int offs = Utilities.getWordEnd(t, t.getCaretPosition()); |
| |
| Caret c = t.getCaret(); |
| c.moveDot(offs); |
| c.setMagicCaretPosition(t.modelToView(offs).getLocation()); |
| } |
| } |
| catch(BadLocationException ble) |
| { |
| // Can't happen. |
| } |
| } |
| } |
| |
| static class BeginWordAction extends TextAction |
| { |
| BeginWordAction() |
| { |
| super(beginWordAction); |
| } |
| |
| public void actionPerformed(ActionEvent event) |
| { |
| try |
| { |
| JTextComponent t = getTextComponent(event); |
| |
| if (t != null) |
| { |
| int offs = Utilities.getWordStart(t, t.getCaretPosition()); |
| |
| Caret c = t.getCaret(); |
| c.setDot(offs); |
| c.setMagicCaretPosition(t.modelToView(offs).getLocation()); |
| } |
| } |
| catch(BadLocationException ble) |
| { |
| // Can't happen. |
| } |
| } |
| } |
| |
| static class EndWordAction extends TextAction |
| { |
| EndWordAction() |
| { |
| super(endWordAction); |
| } |
| |
| public void actionPerformed(ActionEvent event) |
| { |
| try |
| { |
| JTextComponent t = getTextComponent(event); |
| |
| if (t != null) |
| { |
| int offs = Utilities.getWordEnd(t, t.getCaretPosition()); |
| |
| Caret c = t.getCaret(); |
| c.setDot(offs); |
| c.setMagicCaretPosition(t.modelToView(offs).getLocation()); |
| } |
| } |
| catch(BadLocationException ble) |
| { |
| // Can't happen. |
| } |
| } |
| } |
| |
| static class PreviousWordAction |
| extends TextAction |
| { |
| PreviousWordAction() |
| { |
| super(previousWordAction); |
| } |
| |
| public void actionPerformed(ActionEvent event) |
| { |
| try |
| { |
| JTextComponent t = getTextComponent(event); |
| |
| if (t != null) |
| { |
| int offs = Utilities.getPreviousWord(t, t.getCaretPosition()); |
| |
| Caret c = t.getCaret(); |
| c.setDot(offs); |
| c.setMagicCaretPosition(t.modelToView(offs).getLocation()); |
| } |
| } |
| catch(BadLocationException ble) |
| { |
| // Can't happen. |
| } |
| } |
| } |
| |
| static class NextWordAction |
| extends TextAction |
| { |
| NextWordAction() |
| { |
| super(nextWordAction); |
| } |
| |
| public void actionPerformed(ActionEvent event) |
| { |
| try |
| { |
| JTextComponent t = getTextComponent(event); |
| |
| if (t != null) |
| { |
| int offs = Utilities.getNextWord(t, t.getCaretPosition()); |
| |
| Caret c = t.getCaret(); |
| c.setDot(offs); |
| c.setMagicCaretPosition(t.modelToView(offs).getLocation()); |
| } |
| } |
| catch(BadLocationException ble) |
| { |
| // Can't happen. |
| } |
| } |
| } |
| |
| static class SelectAllAction |
| extends TextAction |
| { |
| SelectAllAction() |
| { |
| super(selectAllAction); |
| } |
| |
| public void actionPerformed(ActionEvent event) |
| { |
| JTextComponent t = getTextComponent(event); |
| int offs = t.getDocument().getLength(); |
| Caret c = t.getCaret(); |
| c.setDot(0); |
| c.moveDot(offs); |
| |
| try |
| { |
| c.setMagicCaretPosition(t.modelToView(offs).getLocation()); |
| } |
| catch(BadLocationException ble) |
| { |
| // Can't happen. |
| } |
| } |
| } |
| |
| static class SelectionBeginAction |
| extends TextAction |
| { |
| SelectionBeginAction() |
| { |
| super(selectionBeginAction); |
| } |
| |
| public void actionPerformed(ActionEvent event) |
| { |
| JTextComponent t = getTextComponent(event); |
| Caret c = t.getCaret(); |
| c.moveDot(0); |
| try |
| { |
| c.setMagicCaretPosition(t.modelToView(0).getLocation()); |
| } |
| catch(BadLocationException ble) |
| { |
| // Can't happen. |
| } |
| } |
| } |
| |
| static class SelectionEndAction |
| extends TextAction |
| { |
| SelectionEndAction() |
| { |
| super(selectionEndAction); |
| } |
| |
| public void actionPerformed(ActionEvent event) |
| { |
| JTextComponent t = getTextComponent(event); |
| int offs = t.getDocument().getLength(); |
| Caret c = t.getCaret(); |
| c.moveDot(offs); |
| try |
| { |
| c.setMagicCaretPosition(t.modelToView(offs).getLocation()); |
| } |
| catch(BadLocationException ble) |
| { |
| // Can't happen. |
| } |
| } |
| } |
| |
| static class SelectionBeginLineAction |
| extends TextAction |
| { |
| |
| SelectionBeginLineAction() |
| { |
| super(selectionBeginLineAction); |
| } |
| |
| public void actionPerformed(ActionEvent event) |
| { |
| JTextComponent t = getTextComponent(event); |
| Caret c = t.getCaret(); |
| try |
| { |
| int offs = Utilities.getRowStart(t, c.getDot()); |
| c.setMagicCaretPosition(t.modelToView(offs).getLocation()); |
| } |
| catch(BadLocationException ble) |
| { |
| // Can't happen. |
| } |
| |
| } |
| } |
| |
| static class SelectionEndLineAction |
| extends TextAction |
| { |
| SelectionEndLineAction() |
| { |
| super(selectionEndLineAction); |
| } |
| |
| public void actionPerformed(ActionEvent event) |
| { |
| JTextComponent t = getTextComponent(event); |
| Caret c = t.getCaret(); |
| try |
| { |
| int offs = Utilities.getRowEnd(t, c.getDot()); |
| c.setMagicCaretPosition(t.modelToView(offs).getLocation()); |
| } |
| catch(BadLocationException ble) |
| { |
| // Can't happen. |
| } |
| |
| } |
| } |
| |
| static class SelectLineAction extends TextAction |
| { |
| SelectLineAction() |
| { |
| super(selectLineAction); |
| } |
| |
| public void actionPerformed(ActionEvent event) |
| { |
| JTextComponent t = getTextComponent(event); |
| Caret c = t.getCaret(); |
| try |
| { |
| int offs1 = Utilities.getRowStart(t, c.getDot()); |
| int offs2 = Utilities.getRowEnd(t, c.getDot()); |
| |
| c.setDot(offs2); |
| c.moveDot(offs1); |
| |
| c.setMagicCaretPosition(t.modelToView(offs2).getLocation()); |
| } |
| catch(BadLocationException ble) |
| { |
| // Can't happen. |
| } |
| } |
| } |
| |
| static class SelectWordAction extends TextAction |
| { |
| SelectWordAction() |
| { |
| super(selectWordAction); |
| } |
| |
| public void actionPerformed(ActionEvent event) |
| { |
| JTextComponent t = getTextComponent(event); |
| Caret c = t.getCaret(); |
| int dot = c.getDot(); |
| |
| try |
| { |
| int wordStart = Utilities.getWordStart(t, dot); |
| |
| if (dot == wordStart) |
| { |
| // Current cursor position is on the first character in a word. |
| c.setDot(wordStart); |
| c.moveDot(Utilities.getWordEnd(t, wordStart)); |
| } |
| else |
| { |
| // Current cursor position is not on the first character |
| // in a word. |
| int nextWord = Utilities.getNextWord(t, dot); |
| int previousWord = Utilities.getPreviousWord(t, dot); |
| int previousWordEnd = Utilities.getWordEnd(t, previousWord); |
| |
| // Cursor position is in the space between two words. In such a |
| // situation just select the space. |
| if (dot >= previousWordEnd && dot <= nextWord) |
| { |
| c.setDot(previousWordEnd); |
| c.moveDot(nextWord); |
| } |
| else |
| { |
| // Cursor position is inside a word. Just select it then. |
| c.setDot(previousWord); |
| c.moveDot(previousWordEnd); |
| } |
| } |
| |
| // If the position was updated change the magic caret position |
| // as well. |
| if (c.getDot() != dot) |
| c.setMagicCaretPosition(t.modelToView(c.getDot()).getLocation()); |
| |
| } |
| catch(BadLocationException ble) |
| { |
| // Can't happen. |
| } |
| } |
| } |
| |
| static class SelectionDownAction |
| extends TextAction.VerticalMovementAction |
| { |
| SelectionDownAction() |
| { |
| super(selectionDownAction, SwingConstants.SOUTH); |
| } |
| |
| protected void actionPerformedImpl(Caret c, int offs) |
| { |
| c.moveDot(offs); |
| } |
| |
| } |
| |
| static class SelectionUpAction |
| extends TextAction.VerticalMovementAction |
| { |
| SelectionUpAction() |
| { |
| super(selectionUpAction, SwingConstants.NORTH); |
| } |
| |
| protected void actionPerformedImpl(Caret c, int offs) |
| { |
| c.moveDot(offs); |
| } |
| |
| } |
| |
| static class SelectionForwardAction |
| extends TextAction.HorizontalMovementAction |
| { |
| SelectionForwardAction() |
| { |
| super(selectionForwardAction, SwingConstants.EAST); |
| } |
| |
| protected void actionPerformedImpl(Caret c, int offs) |
| { |
| c.moveDot(offs); |
| } |
| } |
| |
| static class SelectionBackwardAction |
| extends TextAction.HorizontalMovementAction |
| { |
| SelectionBackwardAction() |
| { |
| super(selectionBackwardAction, SwingConstants.WEST); |
| } |
| |
| protected void actionPerformedImpl(Caret c, int offs) |
| { |
| c.moveDot(offs); |
| } |
| } |
| |
| static class DownAction |
| extends TextAction.VerticalMovementAction |
| { |
| DownAction() |
| { |
| super(downAction, SwingConstants.SOUTH); |
| } |
| |
| protected void actionPerformedImpl(Caret c, int offs) |
| { |
| c.setDot(offs); |
| } |
| } |
| |
| static class UpAction |
| extends TextAction.VerticalMovementAction |
| { |
| UpAction() |
| { |
| super(upAction, SwingConstants.NORTH); |
| } |
| |
| protected void actionPerformedImpl(Caret c, int offs) |
| { |
| c.setDot(offs); |
| } |
| |
| } |
| |
| static class ForwardAction |
| extends TextAction.HorizontalMovementAction |
| { |
| ForwardAction() |
| { |
| super(forwardAction, SwingConstants.EAST); |
| } |
| |
| protected void actionPerformedImpl(Caret c, int offs) |
| { |
| c.setDot(offs); |
| } |
| |
| } |
| |
| static class BackwardAction |
| extends TextAction.HorizontalMovementAction |
| { |
| BackwardAction() |
| { |
| super(backwardAction, SwingConstants.WEST); |
| } |
| |
| protected void actionPerformedImpl(Caret c, int offs) |
| { |
| c.setDot(offs); |
| } |
| |
| } |
| |
| static class DeletePrevCharAction |
| extends TextAction |
| { |
| DeletePrevCharAction() |
| { |
| super(deletePrevCharAction); |
| } |
| |
| public void actionPerformed(ActionEvent event) |
| { |
| JTextComponent t = getTextComponent(event); |
| if (t != null) |
| { |
| try |
| { |
| int pos = t.getSelectionStart(); |
| int len = t.getSelectionEnd() - pos; |
| |
| if (len > 0) |
| t.getDocument().remove(pos, len); |
| else if (pos > 0) |
| { |
| pos--; |
| t.getDocument().remove(pos, 1); |
| Caret c = t.getCaret(); |
| c.setDot(pos); |
| c.setMagicCaretPosition(t.modelToView(pos).getLocation()); |
| } |
| } |
| catch (BadLocationException e) |
| { |
| // FIXME: we're not authorized to throw this.. swallow it? |
| } |
| } |
| } |
| } |
| |
| static class DeleteNextCharAction |
| extends TextAction |
| { |
| DeleteNextCharAction() |
| { |
| super(deleteNextCharAction); |
| } |
| |
| public void actionPerformed(ActionEvent event) |
| { |
| JTextComponent t = getTextComponent(event); |
| if (t != null) |
| { |
| try |
| { |
| int pos = t.getSelectionStart(); |
| int len = t.getSelectionEnd() - pos; |
| |
| if (len > 0) |
| t.getDocument().remove(pos, len); |
| else if (pos < t.getDocument().getLength()) |
| t.getDocument().remove(pos, 1); |
| |
| Caret c = t.getCaret(); |
| c.setDot(pos); |
| c.setMagicCaretPosition(t.modelToView(pos).getLocation()); |
| } |
| catch (BadLocationException e) |
| { |
| // FIXME: we're not authorized to throw this.. swallow it? |
| } |
| } |
| } |
| } |
| |
| static class EndLineAction |
| extends TextAction |
| { |
| EndLineAction() |
| { |
| super(endLineAction); |
| } |
| |
| public void actionPerformed(ActionEvent event) |
| { |
| JTextComponent t = getTextComponent(event); |
| try |
| { |
| int offs = Utilities.getRowEnd(t, t.getCaretPosition()); |
| |
| if (offs > -1) |
| { |
| Caret c = t.getCaret(); |
| c.setDot(offs); |
| c.setMagicCaretPosition(t.modelToView(offs).getLocation()); |
| } |
| } |
| catch (BadLocationException ble) |
| { |
| // Nothing to do here |
| } |
| } |
| } |
| |
| static class BeginLineAction |
| extends TextAction |
| { |
| BeginLineAction() |
| { |
| super(beginLineAction); |
| } |
| |
| public void actionPerformed(ActionEvent event) |
| { |
| JTextComponent t = getTextComponent(event); |
| try |
| { |
| int offs = Utilities.getRowStart(t, t.getCaretPosition()); |
| |
| if (offs > -1) |
| { |
| Caret c = t.getCaret(); |
| c.setDot(offs); |
| c.setMagicCaretPosition(t.modelToView(offs).getLocation()); |
| } |
| } |
| catch (BadLocationException ble) |
| { |
| // Do nothing here. |
| } |
| } |
| } |
| |
| static class BeginAction extends TextAction |
| { |
| |
| BeginAction() |
| { |
| super(beginAction); |
| } |
| |
| public void actionPerformed(ActionEvent event) |
| { |
| JTextComponent t = getTextComponent(event); |
| Caret c = t.getCaret(); |
| c.setDot(0); |
| try |
| { |
| c.setMagicCaretPosition(t.modelToView(0).getLocation()); |
| } |
| catch(BadLocationException ble) |
| { |
| // Can't happen. |
| } |
| } |
| } |
| |
| static class EndAction extends TextAction |
| { |
| |
| EndAction() |
| { |
| super(endAction); |
| } |
| |
| public void actionPerformed(ActionEvent event) |
| { |
| JTextComponent t = getTextComponent(event); |
| int offs = t.getDocument().getLength(); |
| Caret c = t.getCaret(); |
| c.setDot(offs); |
| try |
| { |
| c.setMagicCaretPosition(t.modelToView(offs).getLocation()); |
| } |
| catch(BadLocationException ble) |
| { |
| // Can't happen. |
| } |
| } |
| } |
| |
| /** |
| * Creates a beep on the PC speaker. |
| * |
| * @see Toolkit#beep() |
| */ |
| public static class BeepAction extends TextAction |
| { |
| /** |
| * Creates a new <code>BeepAction</code>. |
| */ |
| public BeepAction() |
| { |
| super(beepAction); |
| } |
| |
| /** |
| * Performs the <code>Action</code>. |
| * |
| * @param event the action event describing the user action |
| */ |
| public void actionPerformed(ActionEvent event) |
| { |
| Toolkit.getDefaultToolkit().beep(); |
| } |
| } |
| |
| /** |
| * Copies the selected content into the system clipboard. |
| * |
| * @see Toolkit#getSystemClipboard() |
| * @see CutAction |
| * @see PasteAction |
| */ |
| public static class CopyAction extends TextAction |
| { |
| |
| /** |
| * Create a new <code>CopyAction</code>. |
| */ |
| public CopyAction() |
| { |
| super(copyAction); |
| } |
| |
| /** |
| * Performs the <code>Action</code>. |
| * |
| * @param event the action event describing the user action |
| */ |
| public void actionPerformed(ActionEvent event) |
| { |
| getTextComponent(event).copy(); |
| } |
| } |
| |
| |
| /** |
| * Copies the selected content into the system clipboard and deletes the |
| * selection. |
| * |
| * @see Toolkit#getSystemClipboard() |
| * @see CopyAction |
| * @see PasteAction |
| */ |
| public static class CutAction extends TextAction |
| { |
| |
| /** |
| * Create a new <code>CutAction</code>. |
| */ |
| public CutAction() |
| { |
| super(cutAction); |
| } |
| |
| /** |
| * Performs the <code>Action</code>. |
| * |
| * @param event the action event describing the user action |
| */ |
| public void actionPerformed(ActionEvent event) |
| { |
| getTextComponent(event).cut(); |
| } |
| } |
| |
| /** |
| * Copies content from the system clipboard into the editor. |
| * |
| * @see Toolkit#getSystemClipboard() |
| * @see CopyAction |
| * @see CutAction |
| */ |
| public static class PasteAction extends TextAction |
| { |
| |
| /** |
| * Create a new <code>PasteAction</code>. |
| */ |
| public PasteAction() |
| { |
| super(pasteAction); |
| } |
| |
| /** |
| * Performs the <code>Action</code>. |
| * |
| * @param event the action event describing the user action |
| */ |
| public void actionPerformed(ActionEvent event) |
| { |
| getTextComponent(event).paste(); |
| } |
| } |
| |
| /** |
| * This action is executed as default action when a KEY_TYPED |
| * event is received and no keymap entry exists for that. The purpose |
| * of this action is to filter out a couple of characters. This includes |
| * the control characters and characters with the ALT-modifier. |
| * |
| * If an event does not get filtered, it is inserted into the document |
| * of the text component. If there is some text selected in the text |
| * component, this text will be replaced. |
| */ |
| public static class DefaultKeyTypedAction |
| extends TextAction |
| { |
| |
| /** |
| * Creates a new <code>DefaultKeyTypedAction</code>. |
| */ |
| public DefaultKeyTypedAction() |
| { |
| super(defaultKeyTypedAction); |
| } |
| |
| /** |
| * Performs the <code>Action</code>. |
| * |
| * @param event the action event describing the user action |
| */ |
| public void actionPerformed(ActionEvent event) |
| { |
| // first we filter the following events: |
| // - control characters |
| // - key events with the ALT modifier (FIXME: filter that too!) |
| int cp = event.getActionCommand().codePointAt(0); |
| if (Character.isISOControl(cp)) |
| return; |
| |
| JTextComponent t = getTextComponent(event); |
| if (t != null && t.isEnabled() && t.isEditable()) |
| t.replaceSelection(event.getActionCommand()); |
| } |
| } |
| |
| /** |
| * This action inserts a newline character into the document |
| * of the text component. This is typically triggered by hitting |
| * ENTER on the keyboard. |
| */ |
| public static class InsertBreakAction extends TextAction |
| { |
| |
| /** |
| * Creates a new <code>InsertBreakAction</code>. |
| */ |
| public InsertBreakAction() |
| { |
| super(insertBreakAction); |
| } |
| |
| /** |
| * Performs the <code>Action</code>. |
| * |
| * @param event the action event describing the user action |
| */ |
| public void actionPerformed(ActionEvent event) |
| { |
| JTextComponent t = getTextComponent(event); |
| t.replaceSelection("\n"); |
| } |
| } |
| |
| /** |
| * Places content into the associated editor. If there currently is a |
| * selection, this selection is replaced. |
| */ |
| // FIXME: Figure out what this Action is supposed to do. Obviously text |
| // that is entered by the user is inserted through DefaultKeyTypedAction. |
| public static class InsertContentAction extends TextAction |
| { |
| |
| /** |
| * Creates a new <code>InsertContentAction</code>. |
| */ |
| public InsertContentAction() |
| { |
| super(insertContentAction); |
| } |
| |
| /** |
| * Performs the <code>Action</code>. |
| * |
| * @param event the action event describing the user action |
| */ |
| public void actionPerformed(ActionEvent event) |
| { |
| // FIXME: Figure out what this Action is supposed to do. Obviously text |
| // that is entered by the user is inserted through DefaultKeyTypedAction. |
| } |
| } |
| |
| /** |
| * Inserts a TAB character into the text editor. |
| */ |
| public static class InsertTabAction extends TextAction |
| { |
| |
| /** |
| * Creates a new <code>TabAction</code>. |
| */ |
| public InsertTabAction() |
| { |
| super(insertTabAction); |
| } |
| |
| /** |
| * Performs the <code>Action</code>. |
| * |
| * @param event the action event describing the user action |
| */ |
| public void actionPerformed(ActionEvent event) |
| { |
| JTextComponent t = getTextComponent(event); |
| t.replaceSelection("\t"); |
| } |
| } |
| |
| /** |
| * The serial version of DefaultEditorKit. |
| */ |
| private static final long serialVersionUID = 9017245433028523428L; |
| |
| /** |
| * The name of the <code>Action</code> that moves the caret one character |
| * backwards. |
| * |
| * @see #getActions() |
| */ |
| public static final String backwardAction = "caret-backward"; |
| |
| /** |
| * The name of the <code>Action</code> that creates a beep in the speaker. |
| * |
| * @see #getActions() |
| */ |
| public static final String beepAction = "beep"; |
| |
| /** |
| * The name of the <code>Action</code> that moves the caret to the beginning |
| * of the <code>Document</code>. |
| * |
| * @see #getActions() |
| */ |
| public static final String beginAction = "caret-begin"; |
| |
| /** |
| * The name of the <code>Action</code> that moves the caret to the beginning |
| * of the current line. |
| * |
| * @see #getActions() |
| */ |
| public static final String beginLineAction = "caret-begin-line"; |
| |
| /** |
| * The name of the <code>Action</code> that moves the caret to the beginning |
| * of the current paragraph. |
| * |
| * @see #getActions() |
| */ |
| public static final String beginParagraphAction = "caret-begin-paragraph"; |
| |
| /** |
| * The name of the <code>Action</code> that moves the caret to the beginning |
| * of the current word. |
| * |
| * @see #getActions() |
| */ |
| public static final String beginWordAction = "caret-begin-word"; |
| |
| /** |
| * The name of the <code>Action</code> that copies the selected content |
| * into the system clipboard. |
| * |
| * @see #getActions() |
| */ |
| public static final String copyAction = "copy-to-clipboard"; |
| |
| /** |
| * The name of the <code>Action</code> that copies the selected content |
| * into the system clipboard and removes the selection. |
| * |
| * @see #getActions() |
| */ |
| public static final String cutAction = "cut-to-clipboard"; |
| |
| /** |
| * The name of the <code>Action</code> that is performed by default if |
| * a key is typed and there is no keymap entry. |
| * |
| * @see #getActions() |
| */ |
| public static final String defaultKeyTypedAction = "default-typed"; |
| |
| /** |
| * The name of the <code>Action</code> that deletes the character that |
| * follows the current caret position. |
| * |
| * @see #getActions() |
| */ |
| public static final String deleteNextCharAction = "delete-next"; |
| |
| /** |
| * The name of the <code>Action</code> that deletes the character that |
| * precedes the current caret position. |
| * |
| * @see #getActions() |
| */ |
| public static final String deletePrevCharAction = "delete-previous"; |
| |
| /** |
| * The name of the <code>Action</code> that moves the caret one line down. |
| * |
| * @see #getActions() |
| */ |
| public static final String downAction = "caret-down"; |
| |
| /** |
| * The name of the <code>Action</code> that moves the caret to the end |
| * of the <code>Document</code>. |
| * |
| * @see #getActions() |
| */ |
| public static final String endAction = "caret-end"; |
| |
| /** |
| * The name of the <code>Action</code> that moves the caret to the end |
| * of the current line. |
| * |
| * @see #getActions() |
| */ |
| public static final String endLineAction = "caret-end-line"; |
| |
| /** |
| * When a document is read and an CRLF is encountered, then we add a property |
| * with this name and a value of "\r\n". |
| */ |
| public static final String EndOfLineStringProperty = "__EndOfLine__"; |
| |
| /** |
| * The name of the <code>Action</code> that moves the caret to the end |
| * of the current paragraph. |
| * |
| * @see #getActions() |
| */ |
| public static final String endParagraphAction = "caret-end-paragraph"; |
| |
| /** |
| * The name of the <code>Action</code> that moves the caret to the end |
| * of the current word. |
| * |
| * @see #getActions() |
| */ |
| public static final String endWordAction = "caret-end-word"; |
| |
| /** |
| * The name of the <code>Action</code> that moves the caret one character |
| * forward. |
| * |
| * @see #getActions() |
| */ |
| public static final String forwardAction = "caret-forward"; |
| |
| /** |
| * The name of the <code>Action</code> that inserts a line break. |
| * |
| * @see #getActions() |
| */ |
| public static final String insertBreakAction = "insert-break"; |
| |
| /** |
| * The name of the <code>Action</code> that inserts some content. |
| * |
| * @see #getActions() |
| */ |
| public static final String insertContentAction = "insert-content"; |
| |
| /** |
| * The name of the <code>Action</code> that inserts a TAB. |
| * |
| * @see #getActions() |
| */ |
| public static final String insertTabAction = "insert-tab"; |
| |
| /** |
| * The name of the <code>Action</code> that moves the caret to the beginning |
| * of the next word. |
| * |
| * @see #getActions() |
| */ |
| public static final String nextWordAction = "caret-next-word"; |
| |
| /** |
| * The name of the <code>Action</code> that moves the caret one page down. |
| * |
| * @see #getActions() |
| */ |
| public static final String pageDownAction = "page-down"; |
| |
| /** |
| * The name of the <code>Action</code> that moves the caret one page up. |
| * |
| * @see #getActions() |
| */ |
| public static final String pageUpAction = "page-up"; |
| |
| /** |
| * The name of the <code>Action</code> that copies content from the system |
| * clipboard into the document. |
| * |
| * @see #getActions() |
| */ |
| public static final String pasteAction = "paste-from-clipboard"; |
| |
| /** |
| * The name of the <code>Action</code> that moves the caret to the beginning |
| * of the previous word. |
| * |
| * @see #getActions() |
| */ |
| public static final String previousWordAction = "caret-previous-word"; |
| |
| /** |
| * The name of the <code>Action</code> that sets the editor in read only |
| * mode. |
| * |
| * @see #getActions() |
| */ |
| public static final String readOnlyAction = "set-read-only"; |
| |
| /** |
| * The name of the <code>Action</code> that selects the whole document. |
| * |
| * @see #getActions() |
| */ |
| public static final String selectAllAction = "select-all"; |
| |
| /** |
| * The name of the <code>Action</code> that moves the caret one character |
| * backwards, possibly extending the current selection. |
| * |
| * @see #getActions() |
| */ |
| public static final String selectionBackwardAction = "selection-backward"; |
| |
| /** |
| * The name of the <code>Action</code> that moves the caret to the beginning |
| * of the document, possibly extending the current selection. |
| * |
| * @see #getActions() |
| */ |
| public static final String selectionBeginAction = "selection-begin"; |
| |
| /** |
| * The name of the <code>Action</code> that moves the caret to the beginning |
| * of the current line, possibly extending the current selection. |
| * |
| * @see #getActions() |
| */ |
| public static final String selectionBeginLineAction = "selection-begin-line"; |
| |
| /** |
| * The name of the <code>Action</code> that moves the caret to the beginning |
| * of the current paragraph, possibly extending the current selection. |
| * |
| * @see #getActions() |
| */ |
| public static final String selectionBeginParagraphAction = |
| "selection-begin-paragraph"; |
| |
| /** |
| * The name of the <code>Action</code> that moves the caret to the beginning |
| * of the current word, possibly extending the current selection. |
| * |
| * @see #getActions() |
| */ |
| public static final String selectionBeginWordAction = "selection-begin-word"; |
| |
| /** |
| * The name of the <code>Action</code> that moves the caret one line down, |
| * possibly extending the current selection. |
| * |
| * @see #getActions() |
| */ |
| public static final String selectionDownAction = "selection-down"; |
| |
| /** |
| * The name of the <code>Action</code> that moves the caret to the end |
| * of the document, possibly extending the current selection. |
| * |
| * @see #getActions() |
| */ |
| public static final String selectionEndAction = "selection-end"; |
| |
| /** |
| * The name of the <code>Action</code> that moves the caret to the end |
| * of the current line, possibly extending the current selection. |
| * |
| * @see #getActions() |
| */ |
| public static final String selectionEndLineAction = "selection-end-line"; |
| |
| /** |
| * The name of the <code>Action</code> that moves the caret to the end |
| * of the current paragraph, possibly extending the current selection. |
| * |
| * @see #getActions() |
| */ |
| public static final String selectionEndParagraphAction = |
| "selection-end-paragraph"; |
| |
| /** |
| * The name of the <code>Action</code> that moves the caret to the end |
| * of the current word, possibly extending the current selection. |
| * |
| * @see #getActions() |
| */ |
| public static final String selectionEndWordAction = "selection-end-word"; |
| |
| /** |
| * The name of the <code>Action</code> that moves the caret one character |
| * forwards, possibly extending the current selection. |
| * |
| * @see #getActions() |
| */ |
| public static final String selectionForwardAction = "selection-forward"; |
| |
| /** |
| * The name of the <code>Action</code> that moves the caret to the beginning |
| * of the next word, possibly extending the current selection. |
| * |
| * @see #getActions() |
| */ |
| public static final String selectionNextWordAction = "selection-next-word"; |
| |
| /** |
| * The name of the <code>Action</code> that moves the caret to the beginning |
| * of the previous word, possibly extending the current selection. |
| * |
| * @see #getActions() |
| */ |
| public static final String selectionPreviousWordAction = |
| "selection-previous-word"; |
| |
| /** |
| * The name of the <code>Action</code> that moves the caret one line up, |
| * possibly extending the current selection. |
| * |
| * @see #getActions() |
| */ |
| public static final String selectionUpAction = "selection-up"; |
| |
| /** |
| * The name of the <code>Action</code> that selects the line around the |
| * caret. |
| * |
| * @see #getActions() |
| */ |
| public static final String selectLineAction = "select-line"; |
| |
| /** |
| * The name of the <code>Action</code> that selects the paragraph around the |
| * caret. |
| * |
| * @see #getActions() |
| */ |
| public static final String selectParagraphAction = "select-paragraph"; |
| |
| /** |
| * The name of the <code>Action</code> that selects the word around the |
| * caret. |
| * |
| * @see #getActions() |
| */ |
| public static final String selectWordAction = "select-word"; |
| |
| /** |
| * The name of the <code>Action</code> that moves the caret one line up. |
| * |
| * @see #getActions() |
| */ |
| public static final String upAction = "caret-up"; |
| |
| /** |
| * The name of the <code>Action</code> that sets the editor in read-write |
| * mode. |
| * |
| * @see #getActions() |
| */ |
| public static final String writableAction = "set-writable"; |
| |
| /** |
| * Creates a new <code>DefaultEditorKit</code>. |
| */ |
| public DefaultEditorKit() |
| { |
| // Nothing to do here. |
| } |
| |
| /** |
| * The <code>Action</code>s that are supported by the |
| * <code>DefaultEditorKit</code>. |
| */ |
| private static Action[] defaultActions = |
| new Action[] { |
| // These classes are public because they are so in the RI. |
| new BeepAction(), |
| new CopyAction(), |
| new CutAction(), |
| new DefaultKeyTypedAction(), |
| new InsertBreakAction(), |
| new InsertContentAction(), |
| new InsertTabAction(), |
| new PasteAction(), |
| |
| // These are (package-)private inner classes. |
| new DeleteNextCharAction(), |
| new DeletePrevCharAction(), |
| |
| new BeginLineAction(), |
| new SelectionBeginLineAction(), |
| |
| new EndLineAction(), |
| new SelectionEndLineAction(), |
| |
| new BackwardAction(), |
| new SelectionBackwardAction(), |
| |
| new ForwardAction(), |
| new SelectionForwardAction(), |
| |
| new UpAction(), |
| new SelectionUpAction(), |
| |
| new DownAction(), |
| new SelectionDownAction(), |
| |
| new NextWordAction(), |
| new SelectionNextWordAction(), |
| |
| new PreviousWordAction(), |
| new SelectionPreviousWordAction(), |
| |
| new BeginAction(), |
| new SelectionBeginAction(), |
| |
| new EndAction(), |
| new SelectionEndAction(), |
| |
| new BeginWordAction(), |
| new SelectionBeginWordAction(), |
| |
| new EndWordAction(), |
| new SelectionEndWordAction(), |
| |
| new SelectAllAction(), |
| new SelectLineAction(), |
| new SelectWordAction() |
| }; |
| |
| /** |
| * Creates the <code>Caret</code> for this <code>EditorKit</code>. This |
| * returns a {@link DefaultCaret} in this case. |
| * |
| * @return the <code>Caret</code> for this <code>EditorKit</code> |
| */ |
| public Caret createCaret() |
| { |
| return new DefaultCaret(); |
| } |
| |
| /** |
| * Creates the default {@link Document} that this <code>EditorKit</code> |
| * supports. This is a {@link PlainDocument} in this case. |
| * |
| * @return the default {@link Document} that this <code>EditorKit</code> |
| * supports |
| */ |
| public Document createDefaultDocument() |
| { |
| return new PlainDocument(); |
| } |
| |
| /** |
| * Returns the <code>Action</code>s supported by this <code>EditorKit</code>. |
| * |
| * @return the <code>Action</code>s supported by this <code>EditorKit</code> |
| */ |
| public Action[] getActions() |
| { |
| return defaultActions; |
| } |
| |
| /** |
| * Returns the content type that this <code>EditorKit</code> supports. |
| * The <code>DefaultEditorKit</code> supports the content type |
| * <code>text/plain</code>. |
| * |
| * @return the content type that this <code>EditorKit</code> supports |
| */ |
| public String getContentType() |
| { |
| return "text/plain"; |
| } |
| |
| /** |
| * Returns a {@link ViewFactory} that is able to create {@link View}s for |
| * the <code>Element</code>s that are used in this <code>EditorKit</code>'s |
| * model. This returns null which lets the UI of the text component supply |
| * <code>View</code>s. |
| * |
| * @return a {@link ViewFactory} that is able to create {@link View}s for |
| * the <code>Element</code>s that are used in this |
| * <code>EditorKit</code>'s model |
| */ |
| public ViewFactory getViewFactory() |
| { |
| return null; |
| } |
| |
| /** |
| * Reads a document of the supported content type from an {@link InputStream} |
| * into the actual {@link Document} object. |
| * |
| * @param in the stream from which to read the document |
| * @param document the document model into which the content is read |
| * @param offset the offset inside to document where the content is inserted |
| * |
| * @throws BadLocationException if <code>offset</code> is an invalid location |
| * inside <code>document</code> |
| * @throws IOException if something goes wrong while reading from |
| * <code>in</code> |
| */ |
| public void read(InputStream in, Document document, int offset) |
| throws BadLocationException, IOException |
| { |
| read(new InputStreamReader(in), document, offset); |
| } |
| |
| /** |
| * Reads a document of the supported content type from a {@link Reader} |
| * into the actual {@link Document} object. |
| * |
| * @param in the reader from which to read the document |
| * @param document the document model into which the content is read |
| * @param offset the offset inside to document where the content is inserted |
| * |
| * @throws BadLocationException if <code>offset</code> is an invalid location |
| * inside <code>document</code> |
| * @throws IOException if something goes wrong while reading from |
| * <code>in</code> |
| */ |
| public void read(Reader in, Document document, int offset) |
| throws BadLocationException, IOException |
| { |
| BufferedReader reader = new BufferedReader(in); |
| |
| String line; |
| StringBuffer content = new StringBuffer(); |
| |
| while ((line = reader.readLine()) != null) |
| { |
| content.append(line); |
| content.append("\n"); |
| } |
| |
| document.insertString(offset, content.substring(0, content.length() - 1), |
| SimpleAttributeSet.EMPTY); |
| } |
| |
| /** |
| * Writes the <code>Document</code> (or a fragment of the |
| * <code>Document</code>) to an {@link OutputStream} in the |
| * supported content type format. |
| * |
| * @param out the stream to write to |
| * @param document the document that should be written out |
| * @param offset the beginning offset from where to write |
| * @param len the length of the fragment to write |
| * |
| * @throws BadLocationException if <code>offset</code> or |
| * <code>offset + len</code>is an invalid location inside |
| * <code>document</code> |
| * @throws IOException if something goes wrong while writing to |
| * <code>out</code> |
| */ |
| public void write(OutputStream out, Document document, int offset, int len) |
| throws BadLocationException, IOException |
| { |
| write(new OutputStreamWriter(out), document, offset, len); |
| } |
| |
| /** |
| * Writes the <code>Document</code> (or a fragment of the |
| * <code>Document</code>) to a {@link Writer} in the |
| * supported content type format. |
| * |
| * @param out the writer to write to |
| * @param document the document that should be written out |
| * @param offset the beginning offset from where to write |
| * @param len the length of the fragment to write |
| * |
| * @throws BadLocationException if <code>offset</code> is an |
| * invalid location inside <code>document</code>. |
| * @throws IOException if something goes wrong while writing to |
| * <code>out</code> |
| */ |
| public void write(Writer out, Document document, int offset, int len) |
| throws BadLocationException, IOException |
| { |
| // Throw a BLE if offset is invalid |
| if (offset < 0 || offset > document.getLength()) |
| throw new BadLocationException("Tried to write to invalid location", |
| offset); |
| |
| // If they gave an overly large len, just adjust it |
| if (offset + len > document.getLength()) |
| len = document.getLength() - offset; |
| |
| out.write(document.getText(offset, len)); |
| } |
| } |
