/home/leaf/crossfire/jxclient/trunk/gui/src/main/java/com/realtime/crossfire/jxclient/gui/keybindings/KeyBindings.java

Go to the documentation of this file.

/*
 * This file is part of JXClient, the Fullscreen Java Crossfire Client.
 *
 * JXClient 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 of the License, or
 * (at your option) any later version.
 *
 * JXClient 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 JXClient; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Copyright (C) 2005-2008 Yann Chachkoff.
 * Copyright (C) 2006-2011 Andreas Kirschbaum.
 */

package com.realtime.crossfire.jxclient.gui.keybindings;

import com.realtime.crossfire.jxclient.gui.commandlist.CommandList;
import com.realtime.crossfire.jxclient.gui.commandlist.CommandListType;
import com.realtime.crossfire.jxclient.gui.textinput.GUICommandFactory;
import java.awt.event.KeyEvent;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.LineNumberReader;
import java.io.OutputStreamWriter;
import java.util.Collection;
import java.util.HashSet;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

public class KeyBindings {

    @NotNull
    private final GUICommandFactory guiCommandFactory;

    @NotNull
    private final Collection<KeyBinding> keybindings = new HashSet<KeyBinding>();

    private boolean modified = false;

    @Nullable
    private final File file;

    @Nullable
    private KeyCodeMap keyCodeMap = null;

    public KeyBindings(@Nullable final File file, @NotNull final GUICommandFactory guiCommandFactory) {
        this.file = file;
        this.guiCommandFactory = guiCommandFactory;
    }

    @Nullable
    public File getFile() {
        return file;
    }

    public void addKeyBindingAsKeyCode(final int keyCode, final int modifiers, @NotNull final CommandList cmdList, final boolean isDefault) {
        addKeyBinding(new KeyCodeKeyBinding(keyCode, modifiers, cmdList, isDefault));
    }

    public void addKeyBindingAsKeyChar(final char keyChar, @NotNull final CommandList cmdList, final boolean isDefault) {
        addKeyBinding(new KeyCharKeyBinding(keyChar, cmdList, isDefault));
    }

    private void addKeyBinding(@NotNull final KeyBinding keyBinding) {
        keybindings.remove(keyBinding);
        keybindings.add(keyBinding);
        modified = true;
        try {
            saveKeyBindings();
        } catch (final IOException ex) {
            System.err.println("Cannot write keybindings file "+file+": "+ex.getMessage());
        }
    }

    public void deleteKeyBindingAsKeyCode(final int keyCode, final int modifiers) {
        deleteKeyBinding(getKeyBindingAsKeyCode(keyCode, modifiers));
    }

    private void deleteKeyBinding(@Nullable final KeyBinding keyBinding) {
        if (keyBinding != null) {
            keybindings.remove(keyBinding);
            modified = true;
            try {
                saveKeyBindings();
            } catch (final IOException ex) {
                System.err.println("Cannot write keybindings file "+file+": "+ex.getMessage());
            }
        }
    }

    public void loadKeyBindings() throws IOException {
        modified = false;

        if (file == null) {
            return;
        }

        try {
            final FileInputStream fis = new FileInputStream(file);
            try {
                final InputStreamReader isr = new InputStreamReader(fis, "UTF-8");
                try {
                    final LineNumberReader lnr = new LineNumberReader(isr);
                    try {
                        while (true) {
                            final String line = lnr.readLine();
                            if (line == null) {
                                break;
                            }

                            try {
                                parseKeyBinding(line, false);
                            } catch (final InvalidKeyBindingException ex) {
                                System.err.println("ignoring invalid key binding ("+ex.getMessage()+"): "+line);
                            }
                        }
                    } finally {
                        lnr.close();
                    }
                } finally {
                    isr.close();
                }
            } finally {
                fis.close();
            }
        } catch (final FileNotFoundException ignored) {
            // no error message
            keybindings.clear();
        } catch (final IOException ex) {
            keybindings.clear();
            modified = false;
            throw ex;
        }

        modified = false;
    }

    public void saveKeyBindings() throws IOException {
        if (file == null || !modified) {
            return;
        }

        if (keybindings.size() <= 0) {
            if (!file.delete()) {
                throw new IOException("cannot delete file");
            }
            return;
        }

        final FileOutputStream fos = new FileOutputStream(file);
        try {
            final OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
            try {
                final BufferedWriter bw = new BufferedWriter(osw);
                try {
                    for (final KeyBinding keyBinding : keybindings) {
                        if (keyBinding.isDefault()) {
                            // ignore
                        } else if (keyBinding instanceof KeyCodeKeyBinding) {
                            if (keyCodeMap == null) {
                                keyCodeMap = new KeyCodeMap();
                            }

                            final KeyCodeKeyBinding keyCodeKeyBinding = (KeyCodeKeyBinding)keyBinding;
                            bw.write("code ");
                            bw.write(keyCodeMap.getKeyName(keyCodeKeyBinding.getKeyCode()));
                            bw.write(' ');
                            bw.write(Integer.toString(keyCodeKeyBinding.getModifiers()));
                            bw.write(' ');
                            bw.write(GUICommandFactory.encode(keyCodeKeyBinding.getCommandString()));
                            bw.newLine();
                        } else {
                            throw new AssertionError("Cannot encode "+keyBinding.getClass().getName());
                        }
                    }
                } finally {
                    bw.close();
                }
            } finally {
                osw.close();
            }
        } finally {
            fos.close();
        }
    }

    @Nullable
    private KeyBinding getKeyBindingAsKeyCode(final int keyCode, final int modifiers) {
        for (final KeyBinding keyBinding : keybindings) {
            if (keyBinding.matchesKeyCode(keyCode, modifiers)) {
                return keyBinding;
            }
        }

        return null;
    }

    @Nullable
    private KeyBinding getKeyBindingAsKeyChar(final char keyChar) {
        for (final KeyBinding keyBinding : keybindings) {
            if (keyBinding.matchesKeyChar(keyChar)) {
                return keyBinding;
            }
        }

        return null;
    }

    public void parseKeyBinding(@NotNull final String line, final boolean isDefault) throws InvalidKeyBindingException {
        if (line.startsWith("char ")) {
            if (!isDefault) {
                // ignore "key char" definitions in user keybindings files --
                // these are not supported anymore.
                return;
            }

            final String[] tmp = line.substring(5).split(" +", 2);
            if (tmp.length != 2) {
                throw new InvalidKeyBindingException("syntax error");
            }

            try {
                final char keyChar = (char)Integer.parseInt(tmp[0]);
                final CommandList commandList = new CommandList(CommandListType.AND);
                commandList.add(guiCommandFactory.createCommandDecode(tmp[1]));
                addKeyBindingAsKeyChar(keyChar, commandList, isDefault);
            } catch (final NumberFormatException ex) {
                final InvalidKeyBindingException keyBindingException = new InvalidKeyBindingException("syntax error");
                keyBindingException.initCause(ex);
                throw keyBindingException;
            }
        } else if (line.startsWith("code ")) {
            final String[] tmp = line.substring(5).split(" +", 3);
            if (tmp.length != 3) {
                throw new InvalidKeyBindingException("syntax error");
            }

            if (keyCodeMap == null) {
                keyCodeMap = new KeyCodeMap();
            }

            final int keyCode;
            try {
                keyCode = keyCodeMap.getKeyCode(tmp[0]);
            } catch (final NoSuchKeyCodeException ex) {
                final InvalidKeyBindingException keyBindingException = new InvalidKeyBindingException("invalid key code: "+tmp[0]);
                keyBindingException.initCause(ex);
                throw keyBindingException;
            }

            final int modifiers;
            try {
                modifiers = Integer.parseInt(tmp[1]);
            } catch (final NumberFormatException ex) {
                final InvalidKeyBindingException keyBindingException = new InvalidKeyBindingException("invalid modifier: "+tmp[1]);
                keyBindingException.initCause(ex);
                throw keyBindingException;
            }

            final CommandList commandList = new CommandList(CommandListType.AND);
            commandList.add(guiCommandFactory.createCommandDecode(tmp[2]));
            addKeyBindingAsKeyCode(keyCode, modifiers, commandList, isDefault);
        } else {
            throw new InvalidKeyBindingException("syntax error");
        }
    }

    public boolean handleKeyPress(@NotNull final KeyEvent e) {
        final KeyBinding keyBindingCode = getKeyBindingAsKeyCode(e.getKeyCode(), e.getModifiers());
        if (keyBindingCode != null) {
            executeKeyBinding(keyBindingCode);
            return true;
        }

        final KeyBinding keyBindingChar = getKeyBindingAsKeyChar(e.getKeyChar());
        if (keyBindingChar != null) {
            executeKeyBinding(keyBindingChar);
            return true;
        }

        return false;
    }

    private static void executeKeyBinding(@NotNull final KeyBinding keyBinding) {
        keyBinding.getCommands().execute();
    }

    public Collection<KeyBinding> getBindingsForPartialCommand(@NotNull final String commandStart) {
        final Collection<KeyBinding> matches = new HashSet<KeyBinding>();

        for (final KeyBinding binding : keybindings) {
            if (binding.getCommandString().startsWith(commandStart)) {
                matches.add(binding);
            }
        }

        return matches;
    }
}

---