GuiManager.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.window;
 
import com.realtime.crossfire.jxclient.gui.commandlist.CommandList;
import com.realtime.crossfire.jxclient.gui.gui.Gui;
import com.realtime.crossfire.jxclient.gui.gui.RendererGuiState;
import com.realtime.crossfire.jxclient.gui.keybindings.KeybindingsManager;
import com.realtime.crossfire.jxclient.gui.label.AbstractLabel;
import com.realtime.crossfire.jxclient.gui.label.GUILabelFailure;
import com.realtime.crossfire.jxclient.gui.label.TooltipManagerImpl;
import com.realtime.crossfire.jxclient.gui.list.GUICharacterList;
import com.realtime.crossfire.jxclient.gui.log.GUILabelLog;
import com.realtime.crossfire.jxclient.gui.misc.JXCWindowRenderer;
import com.realtime.crossfire.jxclient.gui.textinput.GUIText;
import com.realtime.crossfire.jxclient.gui.textinput.NoSuchCommandException;
import com.realtime.crossfire.jxclient.guistate.ClientSocketState;
import com.realtime.crossfire.jxclient.guistate.GuiStateListener;
import com.realtime.crossfire.jxclient.guistate.GuiStateManager;
import com.realtime.crossfire.jxclient.protocol.MessageType;
import com.realtime.crossfire.jxclient.server.crossfire.CrossfireDrawextinfoListener;
import com.realtime.crossfire.jxclient.server.crossfire.CrossfireFailureListener;
import com.realtime.crossfire.jxclient.server.crossfire.CrossfireQueryListener;
import com.realtime.crossfire.jxclient.server.crossfire.CrossfireServerConnection;
import com.realtime.crossfire.jxclient.settings.Settings;
import com.realtime.crossfire.jxclient.settings.SettingsEntries;
import com.realtime.crossfire.jxclient.skin.skin.GuiFactory;
import com.realtime.crossfire.jxclient.skin.skin.JXCSkin;
import com.realtime.crossfire.jxclient.skin.skin.JXCSkinException;
import com.realtime.crossfire.jxclient.util.SwingUtilities2;
import java.util.Collection;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public class GuiManager {
 
    @Nullable
    private JXCSkin skin;
 
    @NotNull
    private final JXCWindowRenderer windowRenderer;
 
    @Nullable
    private Gui queryDialog;
 
    @Nullable
    private Gui keybindDialog;
 
    @NotNull
    private final KeybindingsManager keybindingsManager;
 
    @Nullable
    private Gui dialogQuit;
 
    @Nullable
    private Gui dialogDisconnect;
 
    @Nullable
    private Gui dialogConnect;
 
    @Nullable
    private AbstractLabel dialogConnectLabel;
 
    private boolean currentQueryDialogIsNamePrompt;
 
    @NotNull
    private final TooltipManagerImpl tooltipManager;
 
    @NotNull
    private final Settings settings;
 
    @NotNull
    private final JXCConnection connection;
 
    @NotNull
    private final CrossfireServerConnection server;
 
    @NotNull
    private final Map<String, Gui> dialogs = new HashMap<>();
 
    @NotNull
    private final CrossfireDrawextinfoListener crossfireDrawextinfoListener = new CrossfireDrawextinfoListener() {
 
        @Override
        public void commandDrawextinfoReceived(final int color, final int type, final int subtype, @NotNull final String message) {
            if (skin == null) {
                throw new IllegalStateException("no skin set");
            }
 
            @Nullable final Gui dialog;
            String effectiveMessage = message;
            switch (type) {
            case MessageType.MSG_TYPE_BOOK:
                dialog = skin.getDialogBook(1);
                final AbstractLabel title = dialog.getFirstElementEndingWith(AbstractLabel.class, "_title");
                if (title != null) {
                    final String[] tmp = message.split("\n", 2);
                    title.setText(tmp[0]);
                    effectiveMessage = tmp.length >= 2 ? tmp[1] : "";
                }
                break;
 
            case MessageType.MSG_TYPE_CARD:
            case MessageType.MSG_TYPE_PAPER:
            case MessageType.MSG_TYPE_SIGN:
            case MessageType.MSG_TYPE_MONUMENT:
            case MessageType.MSG_TYPE_DIALOG:
                dialog = null;
                break;
 
            case MessageType.MSG_TYPE_MOTD:
                /*
                 * We do not display a MOTD dialog, because it interferes with the
                 * query dialog that gets displayed just after it.
                 */
                dialog = null;
                break;
 
            case MessageType.MSG_TYPE_ADMIN:
            case MessageType.MSG_TYPE_SHOP:
            case MessageType.MSG_TYPE_COMMAND:
            case MessageType.MSG_TYPE_ATTRIBUTE:
            case MessageType.MSG_TYPE_SKILL:
            case MessageType.MSG_TYPE_APPLY:
            case MessageType.MSG_TYPE_ATTACK:
            case MessageType.MSG_TYPE_COMMUNICATION:
            case MessageType.MSG_TYPE_SPELL:
            case MessageType.MSG_TYPE_ITEM:
            case MessageType.MSG_TYPE_MISC:
            case MessageType.MSG_TYPE_VICTIM:
            case MessageType.MSG_TYPE_CLIENT:
                dialog = null;
                break;
 
            default:
                dialog = null;
                break;
            }
 
            if (dialog == null) {
                return;
            }
 
            final AbstractLabel label = dialog.getFirstElementNotEndingWith(AbstractLabel.class, "_title");
            if (label == null) {
                final GUILabelLog log = dialog.getFirstElement(GUILabelLog.class);
                if (log != null) {
                    log.updateText(effectiveMessage, type, subtype);
                }
            } else {
                label.setText(effectiveMessage);
            }
            openDialog(dialog, false);
        }
 
        @Override
        public void setDebugMode(final boolean printMessageTypes) {
            // ignore
        }
 
    };
 
    @NotNull
    private final CrossfireFailureListener crossfireFailureListener = new CrossfireFailureListener() {
 
        @Override
        public void failure(@NotNull final String command, @NotNull final String arguments) {
            if (command.equals("accountlogin") && skin != null) {
                try {
                    final Gui dialog = skin.getDialog("account_login");
                    final GUIText passwordField = dialog.getFirstElement(GUIText.class, "account_password");
                    if (passwordField != null) {
                        passwordField.setText("");
                        passwordField.setActive(true);
                    }
                } catch (final JXCSkinException ignored) {
                    // ignore if dialog doesn't exist
                }
            } else if (command.equals("accountaddplayer") && skin != null) {
                try {
                    final Gui dialog = skin.getDialog("account_link");
                    final GUIText loginField = dialog.getFirstElement(GUIText.class, "character_login");
                    final GUIText passwordField = dialog.getFirstElement(GUIText.class, "character_password");
                    final String argumentsLower = arguments.toLowerCase(Locale.ENGLISH);
                    if (argumentsLower.contains("password")) {
                        if (passwordField != null) {
                            passwordField.setText("");
                            passwordField.setActive(true);
                        }
                    } else if (argumentsLower.contains("character")) {
                        if (loginField != null) {
                            loginField.setActive(true);
                        }
                    } else {
                        if (passwordField != null) {
                            passwordField.setActive(true);
                        }
                    }
                } catch (final JXCSkinException ignored) {
                    // ignore if dialog doesn't exist
                }
            } else if (command.equals("accountnew") && skin != null) {
                try {
                    final Gui dialog = skin.getDialog("account_create");
                    final GUIText loginField = dialog.getFirstElement(GUIText.class, "account_login");
                    final GUIText passwordField = dialog.getFirstElement(GUIText.class, "account_password");
                    final GUIText passwordConfirmField = dialog.getFirstElement(GUIText.class, "account_password_confirm");
                    final String argumentsLower = arguments.toLowerCase(Locale.ENGLISH);
                    if (argumentsLower.contains("password")) {
                        if (passwordField != null) {
                            passwordField.setText("");
                            passwordField.setActive(true);
                        }
                        if (passwordConfirmField != null) {
                            passwordConfirmField.setText("");
                        }
                    } else if (argumentsLower.contains("account")) {
                        if (loginField != null) {
                            loginField.setActive(true);
                        }
                    } else {
                        if (passwordField != null) {
                            passwordField.setActive(true);
                        }
                    }
                } catch (final JXCSkinException ignored) {
                    // ignore if dialog doesn't exist
                }
            } else if (command.equals("createplayer") && skin != null) {
                try {
                    final Gui dialog = skin.getDialog("account_character_new");
                    final GUIText loginField = dialog.getFirstElement(GUIText.class, "account_character_create");
                    if (loginField != null) {
                        loginField.setActive(true);
                    }
                } catch (final JXCSkinException ignored) {
                    // ignore if dialog doesn't exist
                }
            }
        }
 
        @Override
        public void clearFailure() {
            // ignore
        }
 
    };
 
    @NotNull
    @SuppressWarnings("FieldCanBeLocal")
    private final GuiStateListener guiStateListener = new GuiStateListener() {
 
        @Override
        public void start() {
            closeTransientDialogs(false);
            server.removeCrossfireDrawextinfoListener(crossfireDrawextinfoListener);
            server.removeCrossfireFailureListener(crossfireFailureListener);
            windowRenderer.setGuiState(RendererGuiState.START);
            showGUIStart();
        }
 
        @Override
        public void metaserver() {
            closeTransientDialogs(false);
            server.removeCrossfireDrawextinfoListener(crossfireDrawextinfoListener);
            server.removeCrossfireFailureListener(crossfireFailureListener);
            windowRenderer.setGuiState(RendererGuiState.META);
            showGUIMeta();
            activateMetaserverGui();
        }
 
        @Override
        public void preConnecting(@NotNull final String serverInfo) {
            // ignore
        }
 
        @Override
        public void connecting(@NotNull final String serverInfo) {
            if (skin == null) {
                throw new IllegalStateException("no skin set");
            }
 
            closeTransientDialogs(false);
            windowRenderer.updateServerSettings();
            server.addCrossfireDrawextinfoListener(crossfireDrawextinfoListener);
            server.addCrossfireFailureListener(crossfireFailureListener);
            windowRenderer.setGuiState(RendererGuiState.LOGIN);
            showGUIMain();
            if (dialogConnect != null) {
                openDialog(dialogConnect, false);
                updateConnectLabel(ClientSocketState.CONNECTING, null);
            }
        }
 
        @Override
        public void connecting(@NotNull final ClientSocketState clientSocketState, @NotNull final String param) {
            updateConnectLabel(clientSocketState, param);
        }
 
        @Override
        public void connected() {
            closeTransientDialogs(true);
        }
 
        @Override
        public void connectFailed(@NotNull final String reason) {
            closeTransientDialogs(false);
            if (dialogConnect != null) {
                openDialog(dialogConnect, false);
                updateConnectLabel(ClientSocketState.CONNECT_FAILED, reason);
            }
        }
 
    };
 
    public GuiManager(@NotNull final GuiStateManager guiStateManager, @NotNull final TooltipManagerImpl tooltipManager, @NotNull final Settings settings, @NotNull final CrossfireServerConnection server, @NotNull final JXCWindowRenderer windowRenderer, @NotNull final GuiFactory guiFactory, @NotNull final KeybindingsManager keybindingsManager, @NotNull final JXCConnection connection) {
        this.tooltipManager = tooltipManager;
        this.settings = settings;
        this.server = server;
        this.windowRenderer = windowRenderer;
        this.keybindingsManager = keybindingsManager;
        this.connection = connection;
        guiStateManager.addGuiStateListener(guiStateListener);
        windowRenderer.setCurrentGui(guiFactory.newGui("empty"));
        queryDialog = guiFactory.newGui("query");
        keybindDialog = guiFactory.newGui("keybind");
    }
 
    public void addDialog(@NotNull final String name, @NotNull final Gui dialog) {
        dialogs.put(name, dialog);
    }
 
    public void playerReceived() {
        if (windowRenderer.getGuiState() == RendererGuiState.NEW_CHAR) {
            openDialogByName("messages"); // hack for race selection
        }
        windowRenderer.setGuiState(RendererGuiState.PLAYING);
    }
 
    public void manageAccount() {
        if (dialogConnect != null) {
            closeDialog(dialogConnect);
        }
        windowRenderer.setGuiState(RendererGuiState.ACCOUNT);
        hideAccountWindows();
        openDialogByName("account_login");
    }
 
    public void showCharacters(final int count) {
        if (windowRenderer.getGuiState() != RendererGuiState.ACCOUNT) {
            windowRenderer.setGuiState(RendererGuiState.ACCOUNT);
        }
        hideAccountWindows();
        if (count == 0) {
            openDialogByName("account_character_new");
        } else {
            openDialogByName("account_characters");
        }
    }
 
    public void hideAccountWindows() {
        closeDialogByName("account_login");
        closeDialogByName("account_create");
        closeDialogByName("account_characters");
        closeDialogByName("account_link");
        closeDialogByName("account_character_new");
        closeDialogByName("account_password");
    }
 
    public boolean openQuitDialog() {
        if (keybindingsManager.windowClosing()) {
            closeKeybindDialog();
        }
 
        if (dialogQuit == null) {
            return false;
        }
 
        if (dialogDisconnect != null) {
            closeDialog(dialogDisconnect);
        }
        assert dialogQuit != null;
        openDialog(dialogQuit, false);
        return true;
    }
 
    @SuppressWarnings("StatementWithEmptyBody")
    public EscAction escPressed(final boolean connected) {
        if (keybindingsManager.escPressed()) {
            assert keybindDialog != null;
            closeDialog(keybindDialog);
        } else if (windowRenderer.deactivateCommandInput()) {
            // ignore
        } else if (skin != null && closeDialog(skin.getDialogBook(1))) {
            // ignore
        } else if (connected) {
            if (dialogDisconnect == null) {
                return EscAction.DISCONNECT;
            }
            if (openDialog(dialogDisconnect, false)) {
                if (dialogQuit != null) {
                    closeDialog(dialogQuit);
                }
            } else {
                assert dialogDisconnect != null;
                closeDialog(dialogDisconnect);
            }
        } else {
            if (dialogQuit == null) {
                return EscAction.QUIT;
            }
            if (openDialog(dialogQuit, false)) {
                if (dialogDisconnect != null) {
                    closeDialog(dialogDisconnect);
                }
            } else {
                assert dialogQuit != null;
                closeDialog(dialogQuit);
            }
        }
        return EscAction.IGNORE;
    }
 
    public void openQueryDialog(@NotNull final String prompt, final int queryType) {
        if (queryDialog == null) {
            throw new IllegalStateException("query dialog not set");
        }
 
        openDialog(queryDialog, false);
        setHideInput((queryType&CrossfireQueryListener.HIDE_INPUT) != 0);
        currentQueryDialogIsNamePrompt = prompt.startsWith("What is your name?");
        if (currentQueryDialogIsNamePrompt) {
            final String hostname = connection.getHostname();
            if (hostname != null) {
                final String playerName = settings.getString(SettingsEntries.getPlayerSettingsEntry(hostname));
                if (!playerName.isEmpty()) {
                    assert queryDialog != null;
                    final GUIText textArea = queryDialog.getFirstElement(GUIText.class);
                    if (textArea != null) {
                        textArea.setText(playerName);
                    }
                }
            }
        } else if (prompt.startsWith("[y] to roll new stats") || prompt.startsWith("Welcome, Brave New Warrior!")) {
            windowRenderer.setGuiState(RendererGuiState.NEW_CHAR);
            if (openDialogByName("new_char")) {
                closeDialogByName("messages");
                closeDialogByName("status");
            } else {
                // fallback: open both message and status dialogs if this skin
                // does not define a login dialog
                openDialogByName("messages");
                openDialogByName("status");
            }
            assert queryDialog != null;
            openDialog(queryDialog, false); // raise dialog
        }
    }
 
    public void openDialog(@NotNull final String name) {
        final Gui dialog = dialogs.get(name);
        if (dialog != null) {
            openDialog(dialog, false);
        }
    }
 
    private boolean openDialog(@NotNull final Gui dialog, final boolean autoCloseOnDeactivate) {
        final AtomicBoolean result = new AtomicBoolean();
        SwingUtilities2.invokeAndWait(() -> {
            result.set(windowRenderer.openDialog(dialog, autoCloseOnDeactivate));
            if (dialog == queryDialog) {
                setHideInput(false);
            } else {
                final AbstractLabel labelFailure = dialog.getFirstElement(GUILabelFailure.class);
                if (labelFailure != null) {
                    labelFailure.setText("");
                }
 
                final String name = dialog.getComponent().getName();
                if (name != null) {
                    switch (name) {
                    case "account_login":
                        final GUIText loginField = dialog.getFirstElement(GUIText.class, "account_login");
                        if (loginField == null) {
                            final GUIText passwordField = dialog.getFirstElement(GUIText.class, "account_password");
                            if (passwordField != null) {
                                passwordField.setText("");
                            }
                        } else {
                            final String hostname = connection.getHostname();
                            if (hostname != null) {
                                final String accountName = settings.getString(SettingsEntries.getLoginAccountSettingsEntry(hostname));
                                if (accountName.isEmpty()) {
                                    loginField.setText("");
                                    loginField.setActive(true);
 
                                    final GUIText passwordField = dialog.getFirstElement(GUIText.class, "account_password");
                                    if (passwordField != null) {
                                        passwordField.setText("");
                                    }
                                } else {
                                    loginField.setText(accountName);
 
                                    final GUIText passwordField = dialog.getFirstElement(GUIText.class, "account_password");
                                    if (passwordField != null) {
                                        passwordField.setText("");
                                        passwordField.setActive(true);
                                    }
                                }
                            }
                        }
                        break;
 
                    case "account_characters":
                        final GUICharacterList characterList = dialog.getFirstElement(GUICharacterList.class);
                        if (characterList != null) {
                            final String accountName = server.getAccountName();
                            if (accountName != null) {
                                final String hostname = connection.getHostname();
                                if (hostname != null) {
                                    final String characterName = settings.getString(SettingsEntries.getLoginAccountSettingsEntry(hostname, accountName));
                                    if (!characterName.isEmpty()) {
                                        characterList.setCharacter(characterName);
                                    }
                                }
                            }
                        }
                        break;
 
                    case "account_character_new":
                        final GUIText characterField = dialog.getFirstElement(GUIText.class, "account_character_create");
                        if (characterField != null) {
                            characterField.setText("");
                            characterField.setActive(true);
                        }
                        break;
                    }
                }
            }
        });
        return result.get();
    }
 
    public void toggleDialog(@NotNull final String name) {
        final Gui dialog = dialogs.get(name);
        if (dialog != null && windowRenderer.toggleDialog(dialog) && dialog == queryDialog) {
            setHideInput(false);
        }
    }
 
    public void closeQueryDialog() {
        if (queryDialog == null) {
            throw new IllegalStateException("query dialog not set");
        }
 
        closeDialog(queryDialog);
    }
 
    private boolean openDialogByName(@NotNull final String name) {
        if (skin == null) {
            throw new IllegalStateException("skin not set");
        }
 
        final Gui dialog;
        try {
            dialog = skin.getDialog(name);
        } catch (final JXCSkinException ignored) {
            //System.err.println(ex.getLocalizedMessage());
            return false;
        }
 
        openDialog(dialog, false);
        return true;
    }
 
    private void closeDialogByName(@NotNull final String name) {
        if (skin == null) {
            throw new IllegalStateException("skin not set");
        }
 
        final Gui dialog;
        try {
            dialog = skin.getDialog(name);
        } catch (final JXCSkinException ignored) {
            // ignore
            return;
        }
        closeDialog(dialog);
    }
 
    private void closeTransientDialogs(final boolean ignoreQueryDialog) {
        if (queryDialog == null) {
            throw new IllegalStateException("query dialog not set");
        }
        if (skin == null) {
            throw new IllegalStateException("skin not set");
        }
 
        if (dialogDisconnect != null) {
            closeDialog(dialogDisconnect);
        }
        if (dialogQuit != null) {
            closeDialog(dialogQuit);
        }
        if (dialogConnect != null) {
            closeDialog(dialogConnect);
        }
        if (!ignoreQueryDialog) {
            assert queryDialog != null;
            closeDialog(queryDialog);
        }
        assert skin != null;
        closeDialog(skin.getDialogBook(1));
    }
 
    private void activateMetaserverGui() {
        final String serverName = settings.getString(SettingsEntries.SERVER);
        if (!serverName.isEmpty()) {
            windowRenderer.setSelectedHostname(serverName);
        }
    }
 
    private void openKeybindDialog() {
        if (keybindDialog == null) {
            throw new IllegalStateException("keybinding dialog not set");
        }
 
        openDialog(keybindDialog, false);
    }
 
    public void closeKeybindDialog() {
        if (keybindDialog == null) {
            throw new IllegalStateException("keybinding dialog not set");
        }
 
        closeDialog(keybindDialog);
    }
 
    public void closeDialog(@NotNull final String name) {
        final Gui dialog = dialogs.get(name);
        if (dialog != null) {
            windowRenderer.closeDialog(dialog);
        }
    }
 
    private boolean closeDialog(@NotNull final Gui dialog) {
        return windowRenderer.closeDialog(dialog);
    }
 
    public void updatePlayerName(@NotNull final String playerName) {
        if (currentQueryDialogIsNamePrompt) {
            final String hostname = connection.getHostname();
            if (hostname != null) {
                settings.putString(SettingsEntries.getPlayerSettingsEntry(hostname), playerName);
            }
        }
    }
 
    @Nullable
    private GUIText activateCommandInput() {
        // check visible dialogs
        final GUIText textArea1 = windowRenderer.activateCommandInput();
        if (textArea1 != null) {
            return textArea1;
        }
 
        // check invisible dialogs
        assert skin != null;
        for (Gui dialog : skin) {
            final GUIText textArea3 = JXCWindowRenderer.activateCommandInput(dialog);
            if (textArea3 != null) {
                openDialog(dialog, true);
                return textArea3;
            }
        }
 
        return null;
    }
 
    public void activateCommandInput(@Nullable final String newText) {
        final GUIText textArea = activateCommandInput();
        if (textArea != null && newText != null && !newText.isEmpty()) {
            textArea.setText(newText);
        }
    }
 
    public void unsetSkin() {
        if (skin != null) {
            skin.detach();
            windowRenderer.setTooltip(null);
            skin = null;
        }
 
        queryDialog = null;
        keybindDialog = null;
        dialogQuit = null;
        dialogDisconnect = null;
    }
 
    public void setSkin(@NotNull final JXCSkin skin) {
        this.skin = skin;
        skin.attach(tooltipManager);
        windowRenderer.setTooltip(skin.getTooltipLabel());
        queryDialog = skin.getDialogQuery();
        keybindDialog = skin.getDialogKeyBind();
        dialogQuit = skin.getDialogQuit();
        dialogDisconnect = skin.getDialogDisconnect();
        dialogConnect = skin.getDialogConnect();
        dialogConnectLabel = dialogConnect == null ? null : dialogConnect.getFirstElement(AbstractLabel.class, "message");
    }
 
    private void showGUIStart() {
        assert skin != null;
        windowRenderer.clearGUI(skin.getStartInterface());
        tooltipManager.reset();
    }
 
    private void showGUIMeta() {
        assert skin != null;
        final Gui gui = skin.getMetaInterface();
        windowRenderer.clearGUI(gui);
        gui.activateDefaultElement();
        tooltipManager.reset();
    }
 
    private void showGUIMain() {
        assert skin != null;
        windowRenderer.clearGUI(skin.getMainInterface());
        tooltipManager.reset();
    }
 
    public void term() {
        windowRenderer.endRendering();
        if (skin != null) {
            DialogStateParser.save(skin, windowRenderer);
        }
        keybindingsManager.saveGlobalKeybindings();
    }
 
    private void updateConnectLabel(@NotNull final ClientSocketState clientSocketState, @Nullable final String param) {
        if (dialogConnectLabel != null) {
            String message = null;
            switch (clientSocketState) {
            case CONNECTING:
                message = "Connecting...";
                break;
 
            case VERSION:
                message = "Exchanging version...";
                break;
 
            case SETUP:
                message = "Exchanging configuration...";
                break;
 
            case REQUESTINFO:
                message = param == null || param.isEmpty() ? "Requesting information" : "Requesting information: "+param;
                break;
 
            case ACCOUNT_INFO:
                message = "Starting account session...";
                break;
 
            case ADDME:
                message = "Joining the game...";
                break;
 
            case CONNECTED:
                message = "Done.";
                break;
 
            case CONNECT_FAILED:
                message = "Cannot connect to Crossfire server:\n"+param;
                break;
            }
 
            assert message != null;
            dialogConnectLabel.setText(message);
        }
    }
 
    public boolean createKeyBinding(final boolean perCharacter, @NotNull final CommandList cmdList) {
        final boolean result = keybindingsManager.createKeyBinding(perCharacter, cmdList);
        if (result) {
            openKeybindDialog();
        }
        return result;
    }
 
    public boolean removeKeyBinding(final boolean perCharacter) {
        final boolean result = keybindingsManager.removeKeyBinding(perCharacter);
        if (result) {
            openKeybindDialog();
        }
        return result;
    }
 
    public void updateWindowSize(final int width, final int height) {
        if (skin != null) {
            skin.setScreenSize(width, height);
            assert skin != null;
            SwingUtilities2.invokeAndWait(() -> {
                for (Gui dialog : skin) {
                    dialog.autoSize(width, height);
                }
                tooltipManager.setScreenSize(width, height);
            });
        }
    }
 
    @NotNull
    public CommandList getCommandList(@NotNull final String args) throws NoSuchCommandException {
        if (skin == null) {
            throw new IllegalStateException("skin not set");
        }
 
        try {
            return skin.getCommandList(args);
        } catch (final JXCSkinException ex) {
            throw new NoSuchCommandException(ex.getMessage(), ex);
        }
    }
 
    @NotNull
    public Collection<String> getCommandListNames() {
        if (skin == null) {
            throw new IllegalStateException("skin not set");
        }
 
        return skin.getCommandListNames();
    }
 
    public void setAccountName(@NotNull final String accountName) {
        final String hostname = connection.getHostname();
        if (hostname != null) {
            settings.putString(SettingsEntries.getLoginAccountSettingsEntry(hostname), accountName);
        }
    }
 
    public void selectCharacter(@NotNull final String accountName, @NotNull final String characterName) {
        final String hostname = connection.getHostname();
        if (hostname != null) {
            settings.putString(SettingsEntries.getLoginAccountSettingsEntry(hostname, accountName), characterName);
        }
    }
 
    private void setHideInput(final boolean hideInput) {
        assert queryDialog != null;
        final GUIText textArea = queryDialog.getFirstElement(GUIText.class);
        if (textArea != null) {
            textArea.setHideInput(hideInput);
        }
    }
 
    public void setOpaqueDialogBackground(final boolean opaque) {
        for (final Gui dialog : dialogs.values()) {
            dialog.setOpaqueDialogBackground(opaque);
        }
    }
 
    public void setShowSentCommands(final boolean showSentCommands) {
        for (final Gui dialog : dialogs.values()) {
            dialog.setShowSentCommands(showSentCommands);
        }
    }
 
    public void setShowTimestamps(final boolean showTimestamps) {
        for (final Gui dialog : dialogs.values()) {
            dialog.setShowTimestamps(showTimestamps);
        }
    }
 
}