/*
* (c) Copyright 2010-2011 AgileBirds
*
* This file is part of OpenFlexo.
*
* OpenFlexo 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 3 of the License, or
* (at your option) any later version.
*
* OpenFlexo 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 OpenFlexo. If not, see <http://www.gnu.org/licenses/>.
*
*/
package org.openflexo.jedit;
/*
* InputHandler.java - Manages key bindings and executes actions
* Copyright (C) 1999 Slava Pestov
*
* You may use and modify this package for any purpose. Redistribution is
* permitted, in both source and binary form, provided that this notice
* remains intact in all source distributions of this package.
*/
import java.awt.Component;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.util.Enumeration;
import java.util.EventObject;
import java.util.Hashtable;
import java.util.Vector;
import javax.swing.JMenuItem;
import javax.swing.JPopupMenu;
import javax.swing.text.BadLocationException;
import org.openflexo.localization.FlexoLocalization;
import org.openflexo.toolbox.StringUtils;
/**
* An input handler converts the user's key strokes into concrete actions. It also takes care of macro recording and action repetition.
* <p>
*
* This class provides all the necessary support code for an input handler, but doesn't actually do any key binding logic. It is up to the
* implementations of this class to do so.
*
* @author Slava Pestov
* @version $Id: InputHandler.java,v 1.2 2011/09/12 11:47:11 gpolet Exp $
* @see org.gjt.sp.jedit.textarea.DefaultInputHandler
*/
public abstract class InputHandler extends KeyAdapter {
/**
* If this client property is set to Boolean.TRUE on the text area, the home/end keys will support 'smart' BRIEF-like behaviour (one
* press = start/end of line, two presses = start/end of viewscreen, three presses = start/end of document). By default, this property
* is not set.
*/
public static final String SMART_HOME_END_PROPERTY = "InputHandler.homeEnd";
public static final ActionListener BACKSPACE = new backspace();
public static final ActionListener BACKSPACE_WORD = new backspace_word();
public static final ActionListener DELETE = new delete();
public static final ActionListener DELETE_WORD = new delete_word();
public static final ActionListener END = new end(false);
public static final ActionListener DOCUMENT_END = new document_end(false);
public static final ActionListener SELECT_END = new end(true);
public static final ActionListener SELECT_DOC_END = new document_end(true);
public static final ActionListener INSERT_BREAK = new insert_break();
public static final ActionListener INSERT_TAB = new insert_tab();
public static final ActionListener HOME = new home(false);
public static final ActionListener DOCUMENT_HOME = new document_home(false);
public static final ActionListener SELECT_HOME = new home(true);
public static final ActionListener SELECT_DOC_HOME = new document_home(true);
public static final ActionListener SELECT_ALL = new select_all();
public static final ActionListener NEXT_CHAR = new next_char(false);
public static final ActionListener NEXT_LINE = new next_line(false);
public static final ActionListener NEXT_PAGE = new next_page(false);
public static final ActionListener NEXT_WORD = new next_word(false);
public static final ActionListener SELECT_NEXT_CHAR = new next_char(true);
public static final ActionListener SELECT_NEXT_LINE = new next_line(true);
public static final ActionListener SELECT_NEXT_PAGE = new next_page(true);
public static final ActionListener SELECT_NEXT_WORD = new next_word(true);
public static final ActionListener OVERWRITE = new overwrite();
public static final ActionListener PREV_CHAR = new prev_char(false);
public static final ActionListener PREV_LINE = new prev_line(false);
public static final ActionListener PREV_PAGE = new prev_page(false);
public static final ActionListener PREV_WORD = new prev_word(false);
public static final ActionListener SELECT_PREV_CHAR = new prev_char(true);
public static final ActionListener SELECT_PREV_LINE = new prev_line(true);
public static final ActionListener SELECT_PREV_PAGE = new prev_page(true);
public static final ActionListener SELECT_PREV_WORD = new prev_word(true);
public static final ActionListener REPEAT = new repeat();
public static final ActionListener TOGGLE_RECT = new toggle_rect();
public static final ActionListener TOGGLE_SYNTAX_COLORING = new ToggleSyntaxColoring();
public static final ActionListener FIND = new Find();
public static final ActionListener GOTOLINE = new GotoLine();
public static final ActionListener COPY = new copy();
public static final ActionListener CUT = new cut();
public static final ActionListener PASTE = new paste();
public static final ActionListener COPY_LINE_UP = new copy_line_up();
public static final ActionListener COPY_LINE_DOWN = new copy_line_down();
public static final ActionListener MOVE_LINE_UP = new move_line_up();
public static final ActionListener MOVE_LINE_DOWN = new move_line_down();
/*public static final ActionListener UNDO = new undo();
public static final ActionListener REDO = new redo();*/
public static class Find implements ActionListener, InputHandler.NonRecordable {
@Override
public void actionPerformed(ActionEvent e) {
JEditTextArea textArea = getTextArea(e);
textArea.showFindDialog();
}
}
public static class GotoLine implements ActionListener, InputHandler.NonRecordable {
@Override
public void actionPerformed(ActionEvent e) {
JEditTextArea textArea = getTextArea(e);
textArea.showGotoLineDialog();
}
}
public static class copy implements ActionListener, InputHandler.NonRecordable {
@Override
public void actionPerformed(ActionEvent evt) {
// System.out.println("copy");
JEditTextArea textArea = getTextArea(evt);
textArea.copy();
}
}
public static class cut implements ActionListener, InputHandler.NonRecordable {
@Override
public void actionPerformed(ActionEvent evt) {
// System.out.println("cut");
JEditTextArea textArea = getTextArea(evt);
textArea.cut();
}
}
public static class paste implements ActionListener, InputHandler.NonRecordable {
@Override
public void actionPerformed(ActionEvent evt) {
// System.out.println("paste");
JEditTextArea textArea = getTextArea(evt);
textArea.paste();
}
}
/*public static class undo implements ActionListener,
InputHandler.NonRecordable
{
public void actionPerformed(ActionEvent evt)
{
//System.out.println("paste");
JEditTextArea textArea = getTextArea(evt);
textArea.undo();
}
}
public static class redo implements ActionListener,
InputHandler.NonRecordable
{
public void actionPerformed(ActionEvent evt)
{
//System.out.println("paste");
JEditTextArea textArea = getTextArea(evt);
textArea.redo();
}
}*/
// Default action
public static final ActionListener INSERT_CHAR = new insert_char();
private static Hashtable<String, ActionListener> actions;
static {
actions = new Hashtable<String, ActionListener>();
actions.put("backspace", BACKSPACE);
actions.put("backspace-word", BACKSPACE_WORD);
actions.put("delete", DELETE);
actions.put("delete-word", DELETE_WORD);
actions.put("end", END);
actions.put("select-end", SELECT_END);
actions.put("document-end", DOCUMENT_END);
actions.put("select-doc-end", SELECT_DOC_END);
actions.put("insert-break", INSERT_BREAK);
actions.put("insert-tab", INSERT_TAB);
actions.put("home", HOME);
actions.put("select-home", SELECT_HOME);
actions.put("document-home", DOCUMENT_HOME);
actions.put("select-doc-home", SELECT_DOC_HOME);
actions.put("next-char", NEXT_CHAR);
actions.put("next-line", NEXT_LINE);
actions.put("next-page", NEXT_PAGE);
actions.put("next-word", NEXT_WORD);
actions.put("select-next-char", SELECT_NEXT_CHAR);
actions.put("select-next-line", SELECT_NEXT_LINE);
actions.put("select-next-page", SELECT_NEXT_PAGE);
actions.put("select-next-word", SELECT_NEXT_WORD);
actions.put("overwrite", OVERWRITE);
actions.put("prev-char", PREV_CHAR);
actions.put("prev-line", PREV_LINE);
actions.put("prev-page", PREV_PAGE);
actions.put("prev-word", PREV_WORD);
actions.put("select-prev-char", SELECT_PREV_CHAR);
actions.put("select-prev-line", SELECT_PREV_LINE);
actions.put("select-prev-page", SELECT_PREV_PAGE);
actions.put("select-prev-word", SELECT_PREV_WORD);
actions.put("repeat", REPEAT);
actions.put("toggle-rect", TOGGLE_RECT);
actions.put("insert-char", INSERT_CHAR);
}
/**
* Returns a named text area action.
*
* @param name
* The action name
*/
public static ActionListener getAction(String name) {
return actions.get(name);
}
/**
* Returns the name of the specified text area action.
*
* @param listener
* The action
*/
public static String getActionName(ActionListener listener) {
Enumeration en = getActions();
while (en.hasMoreElements()) {
String name = (String) en.nextElement();
ActionListener _listener = getAction(name);
if (_listener == listener) {
return name;
}
}
return null;
}
/**
* Returns an enumeration of all available actions.
*/
public static Enumeration getActions() {
return actions.keys();
}
/**
* Adds the default key bindings to this input handler. This should not be called in the constructor of this input handler, because
* applications might load the key bindings from a file, etc.
*/
public abstract void addDefaultKeyBindings();
/**
* Adds a key binding to this input handler.
*
* @param keyBinding
* The key binding (the format of this is input-handler specific)
* @param action
* The action
*/
public abstract void addKeyBinding(String keyBinding, ActionListener action);
/**
* Removes a key binding from this input handler.
*
* @param keyBinding
* The key binding
*/
public abstract void removeKeyBinding(String keyBinding);
/**
* Removes all key bindings from this input handler.
*/
public abstract void removeAllKeyBindings();
/**
* Grabs the next key typed event and invokes the specified action with the key as a the action command.
*
* @param action
* The action
*/
public void grabNextKeyStroke(ActionListener listener) {
grabAction = listener;
}
/**
* Returns if repeating is enabled. When repeating is enabled, actions will be executed multiple times. This is usually invoked with a
* special key stroke in the input handler.
*/
public boolean isRepeatEnabled() {
return repeat;
}
/**
* Enables repeating. When repeating is enabled, actions will be executed multiple times. Once repeating is enabled, the input handler
* should read a number from the keyboard.
*/
public void setRepeatEnabled(boolean repeat) {
this.repeat = repeat;
}
/**
* Returns the number of times the next action will be repeated.
*/
public int getRepeatCount() {
return repeat ? Math.max(1, repeatCount) : 1;
}
/**
* Sets the number of times the next action will be repeated.
*
* @param repeatCount
* The repeat count
*/
public void setRepeatCount(int repeatCount) {
this.repeatCount = repeatCount;
}
/**
* Returns the macro recorder. If this is non-null, all executed actions should be forwarded to the recorder.
*/
public InputHandler.MacroRecorder getMacroRecorder() {
return recorder;
}
/**
* Sets the macro recorder. If this is non-null, all executed actions should be forwarded to the recorder.
*
* @param recorder
* The macro recorder
*/
public void setMacroRecorder(InputHandler.MacroRecorder recorder) {
this.recorder = recorder;
}
/**
* Returns a copy of this input handler that shares the same key bindings. Setting key bindings in the copy will also set them in the
* original.
*/
public abstract InputHandler copy();
/**
* Executes the specified action, repeating and recording it as necessary.
*
* @param listener
* The action listener
* @param source
* The event source
* @param actionCommand
* The action command
*/
public void executeAction(ActionListener listener, Object source, String actionCommand) {
// create event
ActionEvent evt = new ActionEvent(source, ActionEvent.ACTION_PERFORMED, actionCommand);
// don't do anything if the action is a wrapper
// (like EditAction.Wrapper)
if (listener instanceof Wrapper) {
listener.actionPerformed(evt);
return;
}
// remember old values, in case action changes them
boolean _repeat = repeat;
int _repeatCount = getRepeatCount();
// execute the action
if (listener instanceof InputHandler.NonRepeatable) {
listener.actionPerformed(evt);
} else {
for (int i = 0; i < Math.max(1, repeatCount); i++) {
listener.actionPerformed(evt);
}
}
// do recording. Notice that we do no recording whatsoever
// for actions that grab keys
if (grabAction == null) {
if (recorder != null) {
if (!(listener instanceof InputHandler.NonRecordable)) {
if (_repeatCount != 1) {
recorder.actionPerformed(REPEAT, String.valueOf(_repeatCount));
}
recorder.actionPerformed(listener, actionCommand);
}
}
// If repeat was true originally, clear it
// Otherwise it might have been set by the action, etc
if (_repeat) {
repeat = false;
repeatCount = 0;
}
}
// JEditTextArea textArea = getTextArea(evt);
// textArea.retain();
}
/**
* Returns the text area that fired the specified event.
*
* @param evt
* The event
*/
public static JEditTextArea getTextArea(EventObject evt) {
if (evt != null) {
Object o = evt.getSource();
if (o instanceof Component) {
// find the parent text area
Component c = (Component) o;
for (;;) {
if (c instanceof JEditTextArea) {
return (JEditTextArea) c;
} else if (c == null) {
break;
}
if (c instanceof JPopupMenu) {
c = ((JPopupMenu) c).getInvoker();
} else {
c = c.getParent();
}
}
}
}
// this shouldn't happen
System.err.println("BUG: getTextArea() returning null");
System.err.println("Report this to Slava Pestov <sp@gjt.org>");
return null;
}
// protected members
/**
* If a key is being grabbed, this method should be called with the appropriate key event. It executes the grab action with the typed
* character as the parameter.
*/
protected void handleGrabAction(KeyEvent evt) {
// Clear it *before* it is executed so that executeAction()
// resets the repeat count
ActionListener _grabAction = grabAction;
grabAction = null;
executeAction(_grabAction, evt.getSource(), String.valueOf(evt.getKeyChar()));
}
// protected members
protected ActionListener grabAction;
protected boolean repeat;
protected int repeatCount;
protected InputHandler.MacroRecorder recorder;
/**
* If an action implements this interface, it should not be repeated. Instead, it will handle the repetition itself.
*/
public interface NonRepeatable {
}
/**
* If an action implements this interface, it should not be recorded by the macro recorder. Instead, it will do its own recording.
*/
public interface NonRecordable {
}
/**
* For use by EditAction.Wrapper only.
*
* @since jEdit 2.2final
*/
public interface Wrapper {
}
/**
* Macro recorder.
*/
public interface MacroRecorder {
void actionPerformed(ActionListener listener, String actionCommand);
}
public static class backspace implements ActionListener {
@Override
public void actionPerformed(ActionEvent evt) {
JEditTextArea textArea = getTextArea(evt);
if (!textArea.isEditable()) {
textArea.getToolkit().beep();
return;
}
if (textArea.getSelectionStart() != textArea.getSelectionEnd()) {
textArea.setSelectedText("");
} else {
int caret = textArea.getCaretPosition();
if (caret == 0) {
textArea.getToolkit().beep();
return;
}
try {
textArea.getDocument().remove(caret - 1, 1);
} catch (BadLocationException bl) {
bl.printStackTrace();
}
}
}
}
public static class backspace_word implements ActionListener {
@Override
public void actionPerformed(ActionEvent evt) {
JEditTextArea textArea = getTextArea(evt);
int start = textArea.getSelectionStart();
if (start != textArea.getSelectionEnd()) {
textArea.setSelectedText("");
}
int line = textArea.getCaretLine();
int lineStart = textArea.getLineStartOffset(line);
int caret = start - lineStart;
String lineText = textArea.getLineText(textArea.getCaretLine());
if (caret == 0) {
if (lineStart == 0) {
textArea.getToolkit().beep();
return;
}
caret--;
} else {
String noWordSep = (String) textArea.getDocument().getProperty("noWordSep");
caret = TextUtilities.findWordStart(lineText, caret, noWordSep);
}
try {
textArea.getDocument().remove(caret + lineStart, start - (caret + lineStart));
} catch (BadLocationException bl) {
bl.printStackTrace();
}
}
}
public static class delete implements ActionListener {
@Override
public void actionPerformed(ActionEvent evt) {
JEditTextArea textArea = getTextArea(evt);
if (!textArea.isEditable()) {
textArea.getToolkit().beep();
return;
}
if (textArea.getSelectionStart() != textArea.getSelectionEnd()) {
textArea.setSelectedText("");
} else {
int caret = textArea.getCaretPosition();
if (caret == textArea.getDocumentLength()) {
textArea.getToolkit().beep();
return;
}
try {
textArea.getDocument().remove(caret, 1);
} catch (BadLocationException bl) {
bl.printStackTrace();
}
}
}
}
public static class delete_word implements ActionListener {
@Override
public void actionPerformed(ActionEvent evt) {
JEditTextArea textArea = getTextArea(evt);
int start = textArea.getSelectionStart();
if (start != textArea.getSelectionEnd()) {
textArea.setSelectedText("");
}
int line = textArea.getCaretLine();
int lineStart = textArea.getLineStartOffset(line);
int caret = start - lineStart;
String lineText = textArea.getLineText(textArea.getCaretLine());
if (caret == lineText.length()) {
if (lineStart + caret == textArea.getDocumentLength()) {
textArea.getToolkit().beep();
return;
}
caret++;
} else {
String noWordSep = (String) textArea.getDocument().getProperty("noWordSep");
caret = TextUtilities.findWordEnd(lineText, caret, noWordSep);
}
try {
textArea.getDocument().remove(start, caret + lineStart - start);
} catch (BadLocationException bl) {
bl.printStackTrace();
}
}
}
public static class end implements ActionListener {
private boolean select;
public end(boolean select) {
this.select = select;
}
@Override
public void actionPerformed(ActionEvent evt) {
JEditTextArea textArea = getTextArea(evt);
int caret = textArea.getCaretPosition();
int lastOfLine = textArea.getLineEndOffset(textArea.getCaretLine()) - 1;
int lastVisibleLine = textArea.getFirstLine() + textArea.getVisibleLines();
if (lastVisibleLine >= textArea.getLineCount()) {
lastVisibleLine = Math.min(textArea.getLineCount() - 1, lastVisibleLine);
} else {
lastVisibleLine -= textArea.getElectricScroll() + 1;
}
int lastVisible = textArea.getLineEndOffset(lastVisibleLine) - 1;
int lastDocument = textArea.getDocumentLength();
if (caret == lastDocument) {
textArea.getToolkit().beep();
return;
} else if (!Boolean.TRUE.equals(textArea.getClientProperty(SMART_HOME_END_PROPERTY))) {
caret = lastOfLine;
} else if (caret == lastVisible) {
caret = lastDocument;
} else if (caret == lastOfLine) {
caret = lastVisible;
} else {
caret = lastOfLine;
}
if (select) {
textArea.select(textArea.getMarkPosition(), caret);
} else {
textArea.setCaretPosition(caret);
}
}
}
public static class document_end implements ActionListener {
private boolean select;
public document_end(boolean select) {
this.select = select;
}
@Override
public void actionPerformed(ActionEvent evt) {
JEditTextArea textArea = getTextArea(evt);
if (select) {
textArea.select(textArea.getMarkPosition(), textArea.getDocumentLength());
} else {
textArea.setCaretPosition(textArea.getDocumentLength());
}
}
}
public static class home implements ActionListener {
private boolean select;
public home(boolean select) {
this.select = select;
}
@Override
public void actionPerformed(ActionEvent evt) {
JEditTextArea textArea = getTextArea(evt);
int caret = textArea.getCaretPosition();
int firstLine = textArea.getFirstLine();
int firstOfLine = textArea.getLineStartOffset(textArea.getCaretLine());
int firstVisibleLine = firstLine == 0 ? 0 : firstLine + textArea.getElectricScroll();
int firstVisible = textArea.getLineStartOffset(firstVisibleLine);
if (caret == 0) {
textArea.getToolkit().beep();
return;
} else if (!Boolean.TRUE.equals(textArea.getClientProperty(SMART_HOME_END_PROPERTY))) {
caret = firstOfLine;
} else if (caret == firstVisible) {
caret = 0;
} else if (caret == firstOfLine) {
caret = firstVisible;
} else {
caret = firstOfLine;
}
if (select) {
textArea.select(textArea.getMarkPosition(), caret);
} else {
textArea.setCaretPosition(caret);
}
}
}
public static class document_home implements ActionListener {
private boolean select;
public document_home(boolean select) {
this.select = select;
}
@Override
public void actionPerformed(ActionEvent evt) {
JEditTextArea textArea = getTextArea(evt);
if (select) {
textArea.select(textArea.getMarkPosition(), 0);
} else {
textArea.setCaretPosition(0);
}
}
}
public static class insert_break implements ActionListener {
@Override
public void actionPerformed(ActionEvent evt) {
JEditTextArea textArea = getTextArea(evt);
if (!textArea.isEditable()) {
textArea.getToolkit().beep();
return;
}
String str = StringUtils.LINE_SEPARATOR;
String s = textArea.getLineText(textArea.getSelectionStartLine());
int end = 0;
while (end < s.length() && s.charAt(end) <= ' ') {
end++;
}
if (end > 0) {
str = str + s.substring(0, end);
}
textArea.setSelectedText(str);
}
}
public static class insert_tab implements ActionListener {
@Override
public void actionPerformed(ActionEvent evt) {
JEditTextArea textArea = getTextArea(evt);
if (!textArea.isEditable()) {
textArea.getToolkit().beep();
return;
}
textArea.overwriteSetSelectedText("\t");
}
}
public static class next_char implements ActionListener {
private boolean select;
public next_char(boolean select) {
this.select = select;
}
@Override
public void actionPerformed(ActionEvent evt) {
JEditTextArea textArea = getTextArea(evt);
int caret = textArea.getCaretPosition();
if (caret == textArea.getDocumentLength()) {
textArea.getToolkit().beep();
return;
}
if (select) {
textArea.select(textArea.getMarkPosition(), caret + 1);
} else {
textArea.setCaretPosition(caret + 1);
}
}
}
public static class next_line implements ActionListener {
private boolean select;
public next_line(boolean select) {
this.select = select;
}
@Override
public void actionPerformed(ActionEvent evt) {
JEditTextArea textArea = getTextArea(evt);
int caret = textArea.getCaretPosition();
int line = textArea.getCaretLine();
if (line == textArea.getLineCount() - 1) {
textArea.getToolkit().beep();
return;
}
int magic = textArea.getMagicCaretPosition();
if (magic == -1) {
magic = textArea.offsetToX(line, caret - textArea.getLineStartOffset(line));
}
caret = textArea.getLineStartOffset(line + 1) + textArea.xToOffset(line + 1, magic);
if (select) {
textArea.select(textArea.getMarkPosition(), caret);
} else {
textArea.setCaretPosition(caret);
}
textArea.setMagicCaretPosition(magic);
}
}
public static class next_page implements ActionListener {
private boolean select;
public next_page(boolean select) {
this.select = select;
}
@Override
public void actionPerformed(ActionEvent evt) {
JEditTextArea textArea = getTextArea(evt);
int lineCount = textArea.getLineCount();
int firstLine = textArea.getFirstLine();
int visibleLines = textArea.getVisibleLines();
int line = textArea.getCaretLine();
firstLine += visibleLines;
if (firstLine + visibleLines >= lineCount - 1) {
firstLine = lineCount - visibleLines;
}
textArea.setFirstLine(firstLine);
int caret = textArea.getLineStartOffset(Math.min(textArea.getLineCount() - 1, line + visibleLines));
if (select) {
textArea.select(textArea.getMarkPosition(), caret);
} else {
textArea.setCaretPosition(caret);
}
}
}
public static class next_word implements ActionListener {
private boolean select;
public next_word(boolean select) {
this.select = select;
}
@Override
public void actionPerformed(ActionEvent evt) {
JEditTextArea textArea = getTextArea(evt);
int caret = textArea.getCaretPosition();
int line = textArea.getCaretLine();
int lineStart = textArea.getLineStartOffset(line);
caret -= lineStart;
String lineText = textArea.getLineText(textArea.getCaretLine());
if (caret == lineText.length()) {
if (lineStart + caret == textArea.getDocumentLength()) {
textArea.getToolkit().beep();
return;
}
caret++;
} else {
String noWordSep = (String) textArea.getDocument().getProperty("noWordSep");
caret = TextUtilities.findWordEnd(lineText, caret, noWordSep);
}
if (select) {
textArea.select(textArea.getMarkPosition(), lineStart + caret);
} else {
textArea.setCaretPosition(lineStart + caret);
}
}
}
public static class overwrite implements ActionListener {
@Override
public void actionPerformed(ActionEvent evt) {
JEditTextArea textArea = getTextArea(evt);
textArea.setOverwriteEnabled(!textArea.isOverwriteEnabled());
}
}
public static class prev_char implements ActionListener {
private boolean select;
public prev_char(boolean select) {
this.select = select;
}
@Override
public void actionPerformed(ActionEvent evt) {
JEditTextArea textArea = getTextArea(evt);
int caret = textArea.getCaretPosition();
if (caret == 0) {
textArea.getToolkit().beep();
return;
}
if (select) {
textArea.select(textArea.getMarkPosition(), caret - 1);
} else {
textArea.setCaretPosition(caret - 1);
}
}
}
public static class prev_line implements ActionListener {
private boolean select;
public prev_line(boolean select) {
this.select = select;
}
@Override
public void actionPerformed(ActionEvent evt) {
JEditTextArea textArea = getTextArea(evt);
int caret = textArea.getCaretPosition();
int line = textArea.getCaretLine();
if (line == 0) {
textArea.getToolkit().beep();
return;
}
int magic = textArea.getMagicCaretPosition();
if (magic == -1) {
magic = textArea.offsetToX(line, caret - textArea.getLineStartOffset(line));
}
caret = textArea.getLineStartOffset(line - 1) + textArea.xToOffset(line - 1, magic);
if (select) {
textArea.select(textArea.getMarkPosition(), caret);
} else {
textArea.setCaretPosition(caret);
}
textArea.setMagicCaretPosition(magic);
}
}
public static class prev_page implements ActionListener {
private boolean select;
public prev_page(boolean select) {
this.select = select;
}
@Override
public void actionPerformed(ActionEvent evt) {
JEditTextArea textArea = getTextArea(evt);
int firstLine = textArea.getFirstLine();
int visibleLines = textArea.getVisibleLines();
int line = textArea.getCaretLine();
if (firstLine < visibleLines) {
firstLine = visibleLines;
}
textArea.setFirstLine(firstLine - visibleLines);
int caret = textArea.getLineStartOffset(Math.max(0, line - visibleLines));
if (select) {
textArea.select(textArea.getMarkPosition(), caret);
} else {
textArea.setCaretPosition(caret);
}
}
}
public static class prev_word implements ActionListener {
private boolean select;
public prev_word(boolean select) {
this.select = select;
}
@Override
public void actionPerformed(ActionEvent evt) {
JEditTextArea textArea = getTextArea(evt);
int caret = textArea.getCaretPosition();
int line = textArea.getCaretLine();
int lineStart = textArea.getLineStartOffset(line);
caret -= lineStart;
String lineText = textArea.getLineText(textArea.getCaretLine());
if (caret == 0) {
if (lineStart == 0) {
textArea.getToolkit().beep();
return;
}
caret--;
} else {
String noWordSep = (String) textArea.getDocument().getProperty("noWordSep");
caret = TextUtilities.findWordStart(lineText, caret, noWordSep);
}
if (select) {
textArea.select(textArea.getMarkPosition(), lineStart + caret);
} else {
textArea.setCaretPosition(lineStart + caret);
}
}
}
public static class repeat implements ActionListener, InputHandler.NonRecordable {
@Override
public void actionPerformed(ActionEvent evt) {
JEditTextArea textArea = getTextArea(evt);
textArea.getInputHandler().setRepeatEnabled(true);
String actionCommand = evt.getActionCommand();
if (actionCommand != null) {
textArea.getInputHandler().setRepeatCount(Integer.parseInt(actionCommand));
}
}
}
public static class toggle_rect implements ActionListener {
@Override
public void actionPerformed(ActionEvent evt) {
JEditTextArea textArea = getTextArea(evt);
textArea.setSelectionRectangular(!textArea.isSelectionRectangular());
}
}
public static class insert_char implements ActionListener, InputHandler.NonRepeatable {
@Override
public void actionPerformed(ActionEvent evt) {
JEditTextArea textArea = getTextArea(evt);
String str = evt.getActionCommand();
int repeatCount = textArea.getInputHandler().getRepeatCount();
if (textArea.isEditable()) {
StringBuffer buf = new StringBuffer();
for (int i = 0; i < repeatCount; i++) {
buf.append(str);
}
textArea.overwriteSetSelectedText(buf.toString());
} else {
textArea.getToolkit().beep();
}
}
}
public static class select_all implements ActionListener {
public select_all() {
}
@Override
public void actionPerformed(ActionEvent evt) {
JEditTextArea textArea = getTextArea(evt);
textArea.selectAll();
}
}
public static class ToggleSyntaxColoring implements ActionListener {
public ToggleSyntaxColoring() {
}
@Override
public void actionPerformed(ActionEvent evt) {
JEditTextArea textArea = getTextArea(evt);
textArea.toggleSyntaxColoring();
if (evt.getSource() instanceof JMenuItem) {
((JMenuItem) evt.getSource())
.setText(FlexoLocalization.localizedForKey(textArea.isSyntaxColoringEnabled() ? "disable_syntax_coloring"
: "enable_syntax_coloring"));
}
}
}
public static class copy_line_up extends copy_line {
public copy_line_up() {
super(false);
}
}
public static class copy_line_down extends copy_line {
public copy_line_down() {
super(true);
}
}
static class copy_line implements ActionListener {
private boolean copyDown = true;
public copy_line() {
this(true);
}
public copy_line(boolean copyDown) {
this.copyDown = copyDown;
}
@Override
public void actionPerformed(ActionEvent evt) {
JEditTextArea textArea = getTextArea(evt);
textArea.copyLine(copyDown);
}
}
public static class move_line_up extends move_line {
public move_line_up() {
super(false);
}
}
public static class move_line_down extends move_line {
public move_line_down() {
super(true);
}
}
static class move_line implements ActionListener {
private boolean moveDown = true;
public move_line() {
this(true);
}
public move_line(boolean moveDown) {
this.moveDown = moveDown;
}
@Override
public void actionPerformed(ActionEvent evt) {
JEditTextArea textArea = getTextArea(evt);
textArea.moveLine(moveDown);
}
}
private Vector<InputListener> _listeners = new Vector<InputListener>();
public void addToInputListener(InputListener l) {
_listeners.add(l);
}
public void removeFromInputListener(InputListener l) {
_listeners.remove(l);
}
protected void notifyEnterPressed(KeyEvent event) {
for (InputListener l : _listeners) {
l.enterPressed(event);
}
}
public static interface InputListener {
public void enterPressed(KeyEvent event);
}
}