DefaultInputHandler.java

Go to the documentation of this file.

/*
 * DefaultInputHandler.java - Default implementation of an input handler
 * Copyright (C) 1999 Slava Pestov
 * Copyright (C) 2000-2015 The Gridarta Developers.
 *
 * 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.
 */

package net.sf.gridarta.textedit.textarea;

import java.awt.event.ActionListener;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import java.util.HashMap;
import java.util.Map;
import javax.swing.KeyStroke;
import net.sf.gridarta.textedit.scripteditor.MenuEntries;
import net.sf.gridarta.textedit.scripteditor.ScriptEditControl;
import net.sf.gridarta.textedit.textarea.actions.InputActions;
import org.apache.log4j.Category;
import org.apache.log4j.Logger;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

public class DefaultInputHandler extends InputHandler {

    @NotNull
    private final Map<KeyStroke, ActionListener> bindings;

    private static final Category LOG = Logger.getLogger(DefaultInputHandler.class);

    @NotNull
    private final InputActions inputActions;

    public DefaultInputHandler(@NotNull final ScriptEditControl scriptEditControl, @NotNull final MenuEntries menuEntries) {
        inputActions = new InputActions(scriptEditControl, menuEntries);
        bindings = new HashMap<>();
    }

    @Override
    public void addDefaultKeyBindings() {
        addKeyBinding("BACK_SPACE", inputActions.backspace);
        addKeyBinding("C+BACK_SPACE", inputActions.backspaceWord);
        addKeyBinding("DELETE", inputActions.delete);
        addKeyBinding("C+DELETE", inputActions.deleteWord);

        addKeyBinding("ENTER", inputActions.insertBreak);
        addKeyBinding("TAB", inputActions.insertTab);

        addKeyBinding("INSERT", inputActions.overwrite);
        addKeyBinding("C+\\", inputActions.toggleRectangle);

        addKeyBinding("HOME", inputActions.home);
        addKeyBinding("END", inputActions.end);
        addKeyBinding("S+HOME", inputActions.selectHome);
        addKeyBinding("S+END", inputActions.selectEnd);
        addKeyBinding("C+HOME", inputActions.documentHome);
        addKeyBinding("C+END", inputActions.documentEnd);
        addKeyBinding("CS+HOME", inputActions.selectDocHome);
        addKeyBinding("CS+END", inputActions.selectDocEnd);

        addKeyBinding("PAGE_UP", inputActions.prevPage);
        addKeyBinding("PAGE_DOWN", inputActions.nextPage);
        addKeyBinding("S+PAGE_UP", inputActions.selectPrevPage);
        addKeyBinding("S+PAGE_DOWN", inputActions.selectNextPage);

        addKeyBinding("LEFT", inputActions.prevChar);
        addKeyBinding("S+LEFT", inputActions.selectPrevChar);
        addKeyBinding("C+LEFT", inputActions.prevWord);
        addKeyBinding("CS+LEFT", inputActions.selectPrevWord);
        addKeyBinding("RIGHT", inputActions.nextChar);
        addKeyBinding("S+RIGHT", inputActions.selectNextChar);
        addKeyBinding("C+RIGHT", inputActions.nextWord);
        addKeyBinding("CS+RIGHT", inputActions.selectNextWord);
        addKeyBinding("UP", inputActions.prevLine);
        addKeyBinding("S+UP", inputActions.selectPrevLine);
        addKeyBinding("DOWN", inputActions.nextLine);
        addKeyBinding("S+DOWN", inputActions.selectNextLine);

        addKeyBinding("C+ENTER", inputActions.repeat);

        addKeyBinding(".", inputActions.functionMenu);
    }

    private void addKeyBinding(final String keyBinding, final ActionListener action) {
        final KeyStroke keyStroke = parseKeyStroke(keyBinding);
        if (keyStroke != null) {
            bindings.put(keyStroke, action);
        }
    }

    @Override
    public InputHandler copy() {
        return new DefaultInputHandler(this);
    }

    @Override
    public void keyPressed(final KeyEvent e) {
        final int keyCode = e.getKeyCode();
        final int modifiers = e.getModifiers();

        if (keyCode == KeyEvent.VK_CONTROL || keyCode == KeyEvent.VK_SHIFT || keyCode == KeyEvent.VK_ALT || keyCode == KeyEvent.VK_META) {
            return;
        }

        if ((modifiers & ~InputEvent.SHIFT_MASK) != 0 || e.isActionKey() || keyCode == KeyEvent.VK_BACK_SPACE || keyCode == KeyEvent.VK_DELETE || keyCode == KeyEvent.VK_ENTER || keyCode == KeyEvent.VK_TAB || keyCode == KeyEvent.VK_ESCAPE) {
            if (handleGrabAction(e)) {
                return;
            }

            final KeyStroke keyStroke = KeyStroke.getKeyStroke(keyCode, modifiers);
            final ActionListener actionListener = bindings.get(keyStroke);
            if (actionListener != null) {
                executeAction(actionListener, e.getSource(), null);
                e.consume();
            }
        }
    }

    @Override
    public void keyReleased(final KeyEvent e) {
    }

    @Override
    public void keyTyped(final KeyEvent e) {
        final int modifiers = e.getModifiers();
        final char c = e.getKeyChar();

        if (c != KeyEvent.CHAR_UNDEFINED && (modifiers & InputEvent.ALT_MASK) == 0) {
            if (c >= (char) 0x20 && c != (char) 0x7f) {
                final KeyStroke keyStroke = KeyStroke.getKeyStroke(Character.toUpperCase(c));
                final ActionListener actionListener = bindings.get(keyStroke);

                if (actionListener != null) {
                    executeAction(actionListener, e.getSource(), String.valueOf(c));
                    return;
                }

                if (handleGrabAction(e)) {
                    return;
                }

                // 0-9 adds another 'digit' to the repeat number
                if (isRepeatEnabled() && Character.isDigit(c)) {
                    repeatCount *= 10;
                    repeatCount += (int) c - (int) '0';
                    return;
                }

                executeAction(inputActions.insertChar, e.getSource(), String.valueOf(e.getKeyChar()));

                repeatCount = 0;
                setRepeatEnabled(false);
            }
        }
    }

    @Nullable
    private static KeyStroke parseKeyStroke(final String keyStroke) {
        if (keyStroke == null) {
            return null;
        }

        int modifiers = 0;
        final int index = keyStroke.indexOf('+');
        if (index != -1) {
            for (int i = 0; i < index; i++) {
                switch (Character.toUpperCase(keyStroke.charAt(i))) {
                case 'A':
                    modifiers |= InputEvent.ALT_MASK;
                    break;
                case 'C':
                    modifiers |= InputEvent.CTRL_MASK;
                    break;
                case 'M':
                    modifiers |= InputEvent.META_MASK;
                    break;
                case 'S':
                    modifiers |= InputEvent.SHIFT_MASK;
                    break;
                }
            }
        }

        final String key = keyStroke.substring(index + 1);
        if (key.length() == 1) {
            final char ch = Character.toUpperCase(key.charAt(0));
            if (modifiers == 0) {
                return KeyStroke.getKeyStroke(ch);
            } else {
                return KeyStroke.getKeyStroke(ch, modifiers);
            }
        } else if (key.isEmpty()) {
            LOG.error("Invalid key stroke: " + keyStroke);
            return null;
        } else {
            final int ch;

            try {
                ch = KeyEvent.class.getField("VK_" + key).getInt(null);
            } catch (final IllegalAccessException ignored) {
                LOG.error("Invalid key stroke: " + keyStroke);
                return null;
            } catch (final NoSuchFieldException ignored) {
                LOG.error("Invalid key stroke: " + keyStroke);
                return null;
            }

            return KeyStroke.getKeyStroke(ch, modifiers);
        }
    }

    private DefaultInputHandler(final DefaultInputHandler copy) {
        inputActions = copy.inputActions;
        bindings = copy.bindings;
    }

}