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-2017,2019-2023 Andreas Kirschbaum
 * Copyright (C) 2010-2012,2014-2018,2020-2023 Nicolas Weeger
 */
 
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.commandlist.GUICommandFactory;
import java.awt.event.KeyEvent;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.NoSuchFileException;
import java.nio.file.Path;
import java.util.Collection;
import java.util.TreeSet;
import java.util.function.Predicate;
import java.util.stream.Collectors;
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 TreeSet<>();
 
    private boolean modified;
 
    @Nullable
    private final Path fileVersion2;
 
    @Nullable
    private final Path fileVersion1;
 
    @Nullable
    private KeyCodeMap keyCodeMap;
 
    public KeyBindings(@Nullable final Path fileVersion2, @Nullable final Path fileVersion1, @NotNull final GUICommandFactory guiCommandFactory) {
        this.fileVersion2 = fileVersion2;
        this.fileVersion1 = fileVersion1;
        this.guiCommandFactory = guiCommandFactory;
    }
 
    public void addKeyBinding(@NotNull final KeyEvent2 keyEvent, @NotNull final CommandList cmdList, final boolean isDefault) {
        addKeyBinding(new KeyBinding(keyEvent, cmdList, isDefault));
        saveKeyBindings();
    }
 
    private void addKeyBinding(@NotNull final KeyBinding keyBinding) {
        keybindings.remove(keyBinding);
        keybindings.add(keyBinding);
        modified = true;
    }
 
    public void deleteKeyBinding(@NotNull final KeyEvent2 keyEvent) {
        deleteKeyBinding(getKeyBinding(keyEvent));
    }
 
    private void deleteKeyBinding(@Nullable final KeyBinding keyBinding) {
        if (keyBinding != null) {
            keybindings.remove(keyBinding);
            modified = true;
            saveKeyBindings();
        }
    }
 
    public void loadKeyBindings() {
        modified = false;
 
        final Path file;
        if (fileVersion2 != null && Files.exists(fileVersion2)) {
            file = fileVersion2;
        } else if (fileVersion1 != null && Files.exists(fileVersion1)) {
            file = fileVersion1;
        } else {
            return;
        }
 
        try {
            try (BufferedReader reader = Files.newBufferedReader(file, StandardCharsets.UTF_8)) {
                while (true) {
                    final String line = reader.readLine();
                    if (line == null) {
                        break;
                    }
 
                    try {
                        parseKeyBinding(line, false);
                    } catch (final InvalidKeyBindingException ex) {
                        System.err.println("ignoring invalid key binding ("+ex.getMessage()+"): "+line);
                    }
                }
            }
        } catch (final NoSuchFileException ignored) {
            // no error message
            keybindings.clear();
        } catch (final IOException ex) {
            keybindings.clear();
            modified = false;
            System.err.println("Cannot read keybindings file "+file+": "+ex.getMessage());
        }
 
        modified = false;
    }
 
    public void saveKeyBindings() {
        if (fileVersion2 == null || !modified) {
            return;
        }
 
        if (keybindings.size() <= 0) {
            try {
                Files.deleteIfExists(fileVersion2);
            } catch (final IOException ex) {
                System.err.println("Cannot write keybindings file "+fileVersion2+": "+ex.getMessage());
            }
            return;
        }
 
        try {
            try (BufferedWriter bw = Files.newBufferedWriter(fileVersion2, StandardCharsets.UTF_8)) {
                for (KeyBinding keyBinding : keybindings) {
                    //noinspection StatementWithEmptyBody
                    if (keyBinding.isDefault()) {
                        // ignore
                    } else {
                        if (keyCodeMap == null) {
                            keyCodeMap = new KeyCodeMap();
                        }
 
                        final KeyEvent2 keyEvent = keyBinding.getKeyEvent2();
                        final int code = keyEvent.getKeyCode();
                        if (code == KeyEvent.VK_UNDEFINED) {
                            bw.write("char ");
                            bw.write(Integer.toString(keyEvent.getKeyChar()));
                        } else {
                            bw.write("code ");
                            bw.write(keyCodeMap.getKeyName(code));
                            bw.write(' ');
                            bw.write(KeyEvent2.modifiersToString(keyEvent.getModifiers()));
                        }
                        bw.write(' ');
                        bw.write(guiCommandFactory.encode(keyBinding.getCommandString()));
                        bw.newLine();
                    }
                }
            }
        } catch (final IOException ex) {
            System.err.println("Cannot write keybindings file "+fileVersion2+": "+ex.getMessage());
        }
 
        modified = false;
    }
 
    @Nullable
    private KeyBinding getKeyBinding(@NotNull final KeyEvent2 keyEvent) {
        for (KeyBinding keyBinding : keybindings) {
            if (keyBinding.getKeyEvent2().equals(keyEvent)) {
                return keyBinding;
            }
        }
 
        return null;
    }
 
    public void parseKeyBinding(@NotNull final String line, final boolean isDefault) throws InvalidKeyBindingException {
        if (line.startsWith("char ")) {
            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]));
                addKeyBinding(new KeyBinding(new KeyEvent2(KeyEvent.VK_UNDEFINED, keyChar, 0), 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;
            }
            if (keyCode == KeyEvent.VK_UNDEFINED) {
                throw new InvalidKeyBindingException("invalid key code: "+tmp[0]);
            }
 
            int modifiers;
            try {
                modifiers = KeyEvent2.convertModifiers(Integer.parseInt(tmp[1]));
            } catch (final NumberFormatException ignored) {
                modifiers = KeyEvent2.stringToModifiers(tmp[1]);
            }
 
            final CommandList commandList = new CommandList(CommandListType.AND);
            commandList.add(guiCommandFactory.createCommandDecode(tmp[2]));
            addKeyBinding(new KeyBinding(new KeyEvent2(keyCode, KeyEvent.CHAR_UNDEFINED, modifiers), commandList, isDefault));
        } else {
            throw new InvalidKeyBindingException("syntax error");
        }
    }
 
    public boolean handleKeyPress(@NotNull final KeyEvent2 e) {
        for (KeyBinding keyBinding : keybindings) {
            if (keyBinding.matchesKeyEvent(e)) {
                executeKeyBinding(keyBinding);
                return true;
            }
        }
 
        return false;
    }
 
    private static void executeKeyBinding(@NotNull final KeyBinding keyBinding) {
        keyBinding.getCommands().execute();
    }
 
    @NotNull
    public Collection<KeyBinding> getBindings(@NotNull final Predicate<KeyBinding> predicate) {
        return keybindings.stream().filter(predicate).collect(Collectors.toSet());
    }
 
}