Gui.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.gui;
 
import com.realtime.crossfire.jxclient.gui.keybindings.KeyBindings;
import com.realtime.crossfire.jxclient.gui.keybindings.KeyEvent2;
import com.realtime.crossfire.jxclient.gui.log.GUIMessageLog;
import com.realtime.crossfire.jxclient.gui.misc.GUIDialogBackground;
import com.realtime.crossfire.jxclient.gui.misc.GUIPicture;
import com.realtime.crossfire.jxclient.util.SwingUtilities2;
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.event.KeyEvent;
import java.util.Collection;
import java.util.EnumSet;
import javax.swing.JComponent;
import javax.swing.JFrame;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public class Gui {
 
    @NotNull
    private final JComponent component = new JComponent() {
 
        private static final long serialVersionUID = 1L;
 
    };
 
    @NotNull
    private final KeyBindings keyBindings;
 
    @Nullable
    private Extent autoSize;
 
    private boolean saveDialog;
 
    private boolean modal;
 
    private boolean userResizable;
 
    @NotNull
    private final Collection<RendererGuiState> hideInStates = EnumSet.noneOf(RendererGuiState.class);
 
    @Nullable
    private ActivatableGUIElement forcedActive;
 
    @Nullable
    private ActivatableGUIElement activeElement;
 
    private boolean initialPositionSet;
 
    @Nullable
    private GuiAutoCloseListener guiAutoCloseListener;
 
    @Nullable
    private Expression defaultX;
 
    @Nullable
    private Expression defaultY;
 
    @Nullable
    private GUIPicture help;
 
    public Gui(@NotNull final String name, @NotNull final KeyBindings keyBindings) {
        this.keyBindings = keyBindings;
        component.setName(name);
    }
 
    @NotNull
    public JComponent getComponent() {
        return component;
    }
 
    public void setAutoSize(@Nullable final Extent autoSize) {
        this.autoSize = autoSize;
    }
 
    public boolean isAutoSize() {
        return autoSize != null;
    }
 
    public void setModal(final boolean modal) {
        this.modal = modal;
    }
 
    public boolean isModal() {
        return modal;
    }
 
    public void setUserResizable(final boolean userResizable) {
        this.userResizable = userResizable;
    }
 
    public boolean isUserResizable() {
        return userResizable;
    }
 
    @Nullable
    private ActivatableGUIElement getDefaultElement() {
        final int count = component.getComponentCount();
        for (int i = 0; i < count; i++) {
            final Component component = this.component.getComponent(i);
            if (component.isVisible() && component instanceof final ActivatableGUIElement element && element.isDefault()) {
                return element;
            }
        }
 
        return null;
    }
 
    public void activateDefaultElement() {
        final ActivatableGUIElement defaultElement = getDefaultElement();
        if (defaultElement != null) {
            defaultElement.setActive(true);
        }
    }
 
    @Nullable
    public <T extends GUIElement> T getFirstElementEndingWith(@NotNull final Class<T> class_, @NotNull final String ending) {
        final int count = component.getComponentCount();
        for (int i = 0; i < count; i++) {
            final Component component = this.component.getComponent(i);
            if (component.isVisible() && component instanceof final GUIElement element && class_.isAssignableFrom(element.getClass()) && element.getName().endsWith(ending)) {
                return class_.cast(element);
            }
        }
 
        return null;
    }
 
    @Nullable
    public <T extends GUIElement> T getFirstElementNotEndingWith(@NotNull final Class<T> class_, @NotNull final String ending) {
        final int count = component.getComponentCount();
        for (int i = 0; i < count; i++) {
            final Component component = this.component.getComponent(i);
            if (component.isVisible() && component instanceof final GUIElement element && class_.isAssignableFrom(element.getClass()) && !element.getName().endsWith(ending)) {
                return class_.cast(element);
            }
        }
 
        return null;
    }
 
    @Nullable
    public <T extends GUIElement> T getFirstElement(@NotNull final Class<T> class_) {
        final int count = component.getComponentCount();
        for (int i = 0; i < count; i++) {
            final Component component = this.component.getComponent(i);
            if (component.isVisible() && component instanceof final GUIElement element && class_.isAssignableFrom(element.getClass())) {
                return class_.cast(element);
            }
        }
 
        return null;
    }
 
    @Nullable
    public AbstractGUIElement getElementFromPoint(final int x, final int y) {
        Component component = this.component.findComponentAt(x, y);
        while (component != null) {
            if (component instanceof AbstractGUIElement) {
                return (AbstractGUIElement)component;
            }
            component = component.getParent();
        }
        return null;
    }
 
    public void setActiveElement(@NotNull final ActivatableGUIElement activeElement, final boolean active) {
        final ActivatableGUIElement previousActiveElement = this.activeElement;
        if (active) {
            if (forcedActive != null && forcedActive != activeElement) {
                return;
            }
 
            if (isActiveElement(activeElement)) {
                return;
            }
 
            this.activeElement = activeElement;
            if (previousActiveElement != null) {
                previousActiveElement.activeChanged();
            }
            assert this.activeElement != null;
            this.activeElement.activeChanged();
 
            guiAutoCloseListener = null;
        } else {
            if (!isActiveElement(activeElement)) {
                return;
            }
 
            this.activeElement = null;
            assert previousActiveElement != null;
            previousActiveElement.activeChanged();
 
            if (guiAutoCloseListener != null) {
                final GuiAutoCloseListener listener = guiAutoCloseListener;
                guiAutoCloseListener = null;
                listener.autoClosed();
            }
        }
    }
 
    public boolean isActiveElement(@Nullable final ActivatableGUIElement activeElement) {
        return this.activeElement != null && this.activeElement == activeElement;
    }
 
    public void setActiveElementActive(final boolean active) {
        if (activeElement != null) {
            activeElement.setActive(active);
        }
    }
 
    public boolean handleKeyPress(@NotNull final KeyEvent2 e) {
        if (activeElement instanceof KeyPressedHandler && ((KeyPressedHandler)activeElement).keyPressed(e)) {
            return true;
        }
 
        switch (e.getKeyCode()) {
        case KeyEvent.VK_ENTER:
        case KeyEvent.VK_SPACE:
            final ActivatableGUIElement defaultElement = getDefaultElement();
            if (defaultElement != null) {
                defaultElement.execute();
                return true;
            }
            break;
 
        case KeyEvent.VK_TAB:
            if (activeElement != null) {
                switch (e.getModifiers()&KeyEvent2.MASK) {
                case KeyEvent2.NONE:
                    activeElement.activateNextElement();
                    return true;
 
                case KeyEvent2.SHIFT:
                    activeElement.activatePrevElement();
                    return true;
                }
            }
            break;
        }
 
        return keyBindings.handleKeyPress(e);
    }
 
    public boolean deactivateCommandInput() {
        if (activeElement == null) {
            return false;
        }
 
        final GUIElement textArea = activeElement;
        if (!textArea.getName().equals("command")) {
            return false;
        }
 
        assert activeElement != null;
        activeElement.setActive(false);
        return true;
    }
 
    @Nullable
    public <T extends GUIElement> T getFirstElement(@NotNull final Class<T> class_, @NotNull final String name) {
        final int count = component.getComponentCount();
        for (int i = 0; i < count; i++) {
            final Component component = this.component.getComponent(i);
            if (component.isVisible() && component instanceof final GUIElement element && class_.isAssignableFrom(element.getClass()) && element.getName().equals(name)) {
                return class_.cast(element);
            }
        }
        return null;
    }
 
    @NotNull
    public KeyBindings getKeyBindings() {
        return keyBindings;
    }
 
    public void hideInState(@NotNull final RendererGuiState state) {
        hideInStates.add(state);
    }
 
    public boolean isHidden(@NotNull final RendererGuiState state) {
        return hideInStates.contains(state);
    }
 
    public void setGuiAutoCloseListener(@Nullable final GuiAutoCloseListener guiAutoCloseListener) {
        this.guiAutoCloseListener = guiAutoCloseListener;
    }
 
    public boolean isWithinDrawingArea(final int x, final int y) {
        return component.getX() <= x && x < component.getX()+component.getWidth() && component.getY() <= y && y < component.getY()+component.getHeight();
    }
 
    public void setForcedActive(@Nullable final ActivatableGUIElement forcedActive) {
        this.forcedActive = forcedActive;
    }
 
    @NotNull
    @Override
    public String toString() {
        final String name = component.getName();
        return (name == null ? "" : name)+"["+component.getWidth()+"x"+component.getHeight()+"]";
    }
 
    public void autoSize(final int screenWidth, final int screenHeight) {
        SwingUtilities2.invokeAndWait(() -> {
            final int x;
            final int y;
            final int w;
            final int h;
            final Extent extent = autoSize;
            if (extent != null) {
                final Dimension preferredSize = component.getPreferredSize();
                x = extent.getX(screenWidth, screenHeight, preferredSize.width, preferredSize.height);
                y = extent.getY(screenWidth, screenHeight, preferredSize.width, preferredSize.height);
                w = extent.getW(screenWidth, screenHeight, preferredSize.width, preferredSize.height);
                h = extent.getH(screenWidth, screenHeight, preferredSize.width, preferredSize.height);
            } else if (initialPositionSet) {
                x = component.getX();
                y = component.getY();
                w = component.getWidth();
                h = component.getHeight();
            } else {
                final Dimension preferredSize = component.getPreferredSize();
                //noinspection IfMayBeConditional
                if (defaultX == null) {
                    x = screenWidth/2-preferredSize.width;
                } else {
                    x = defaultX.evaluate(screenWidth, screenHeight, preferredSize.width, preferredSize.height)-preferredSize.width/2;
                }
                //noinspection IfMayBeConditional
                if (defaultY == null) {
                    y = screenHeight/2-preferredSize.height;
                } else {
                    y = defaultY.evaluate(screenWidth, screenHeight, preferredSize.width, preferredSize.height)-preferredSize.height/2;
                }
                w = preferredSize.width;
                h = preferredSize.height;
            }
            setBounds(x, y, w, h, screenWidth, screenHeight);
        });
    }
 
    public void setDefaultPosition(@NotNull final Expression defaultX, @NotNull final Expression defaultY) {
        this.defaultX = defaultX;
        this.defaultY = defaultY;
    }
 
    public boolean isSaveDialog() {
        return saveDialog;
    }
 
    public void setSaveDialog() {
        saveDialog = true;
    }
 
    public void notifyOpen() {
        if (help != null) {
            help.notifyOpen();
        }
 
        final int count = component.getComponentCount();
        for (int i = 0; i < count; i++) {
            final Component component = this.component.getComponent(i);
            if (component.isVisible() && component instanceof final GUIElement element) {
                element.notifyOpen();
            }
        }
    }
 
    @Nullable
    public GUIPicture getHelp() {
        return help;
    }
 
    public void setHelp(@NotNull final GUIPicture help) {
        this.help = help;
    }
 
    public void setBounds(final int x, final int y, final int width, final int height, final int windowWidth, final int windowHeight) {
        int newWidth = width;
        int newHeight = height;
        final Dimension maximumSize = component.getMaximumSize();
        if (maximumSize != null) {
            if (newWidth > maximumSize.width) {
                newWidth = maximumSize.width;
            }
            if (newHeight > maximumSize.height) {
                newHeight = maximumSize.height;
            }
        }
        final Dimension minimumSize = component.getMinimumSize();
        if (minimumSize != null) {
            if (newWidth < minimumSize.width) {
                newWidth = minimumSize.width;
            }
            if (newHeight < minimumSize.height) {
                newHeight = minimumSize.height;
            }
        }
        final int newX = Math.max(Math.min(x, windowWidth-newWidth), 0);
        final int newY = Math.max(Math.min(y, windowHeight-newHeight), 0);
        component.setBounds(newX, newY, newWidth, newHeight);
        initialPositionSet = true;
        validate();
    }
 
    private void validate() {
        Container c = component;
        while (c != null) {
            c = c.getParent();
            if (c instanceof JFrame) {
                c.validate();
                break;
            }
        }
    }
 
    public void repaint() {
        SwingUtilities2.invokeLater(component::repaint);
    }
 
    public void setOpaqueDialogBackground(final boolean opaque) {
        final int count = component.getComponentCount();
        for (int i = 0; i < count; i++) {
            final Component component = this.component.getComponent(i);
            if (component.isVisible() && component instanceof final GUIDialogBackground dialogBackground) {
                dialogBackground.setOpaqueDialogBackground(opaque);
            }
        }
    }
 
    public void setShowSentCommands(final boolean showSentCommands) {
        final int count = component.getComponentCount();
        for (int i = 0; i < count; i++) {
            final Component component = this.component.getComponent(i);
            if (component.isVisible() && component instanceof final GUIMessageLog messageLog) {
                messageLog.setShowSentCommands(showSentCommands);
            }
        }
    }
 
    public void setShowTimestamps(final boolean showTimestamps) {
        final int count = component.getComponentCount();
        for (int i = 0; i < count; i++) {
            final Component component = this.component.getComponent(i);
            if (component.isVisible() && component instanceof final GUIMessageLog messageLog) {
                messageLog.setShowTimestamps(showTimestamps);
            }
        }
    }
 
}