JXCWindowRenderer.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.misc;
 
import com.realtime.crossfire.jxclient.gui.gui.AbstractGUIElement;
import com.realtime.crossfire.jxclient.gui.gui.GUIElement;
import com.realtime.crossfire.jxclient.gui.gui.Gui;
import com.realtime.crossfire.jxclient.gui.gui.RendererGuiState;
import com.realtime.crossfire.jxclient.gui.gui.RendererGuiStateListener;
import com.realtime.crossfire.jxclient.gui.keybindings.KeyEvent2;
import com.realtime.crossfire.jxclient.gui.list.GUIFloorList;
import com.realtime.crossfire.jxclient.gui.list.GUIItemList;
import com.realtime.crossfire.jxclient.gui.list.GUIMetaElementList;
import com.realtime.crossfire.jxclient.gui.log.Buffer;
import com.realtime.crossfire.jxclient.gui.log.GUILog;
import com.realtime.crossfire.jxclient.gui.log.GUIMessageLog;
import com.realtime.crossfire.jxclient.gui.map.GUIMap;
import com.realtime.crossfire.jxclient.gui.textinput.GUIText;
import com.realtime.crossfire.jxclient.server.crossfire.CrossfireServerConnection;
import com.realtime.crossfire.jxclient.util.EventListenerList2;
import com.realtime.crossfire.jxclient.util.Resolution;
import com.realtime.crossfire.jxclient.util.SwingUtilities2;
import java.awt.Color;
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.DisplayMode;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.Insets;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Toolkit;
import java.awt.Window;
import java.awt.event.ComponentEvent;
import java.awt.event.ComponentListener;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import java.awt.event.MouseWheelEvent;
import java.awt.event.MouseWheelListener;
import java.awt.image.BufferStrategy;
import java.io.IOException;
import java.io.Writer;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Locale;
import java.util.concurrent.CopyOnWriteArrayList;
import javax.swing.JFrame;
import javax.swing.JLayeredPane;
import javax.swing.JViewport;
import javax.swing.RootPaneContainer;
import javax.swing.event.MouseInputListener;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public class JXCWindowRenderer {
 
    private static final int DEFAULT_NUM_LOOK_OBJECTS = 50;
 
    private static final int DEFAULT_MAP_WIDTH = 9;
 
    private static final int DEFAULT_MAP_HEIGHT = 9;
 
    @Nullable
    private JFrame frame;
 
    @NotNull
    private final Container layeredPane = new JLayeredPane() {
 
        private static final long serialVersionUID = 1L;
 
        @Override
        public void paint(@NotNull final Graphics g) {
            super.paint(g);
            mouseTracker.paintActiveComponent(g);
        }
 
    };
 
    @NotNull
    private final MouseTracker mouseTracker;
 
    @NotNull
    private final CrossfireServerConnection crossfireServerConnection;
 
    @Nullable
    private final Writer debugScreen;
 
    @NotNull
    private final GraphicsEnvironment graphicsEnvironment;
 
    @NotNull
    private final GraphicsDevice graphicsDevice;
 
    @NotNull
    private final DisplayMode defaultDisplayMode;
 
    @NotNull
    private final Rectangle maximumWindowBounds = GraphicsEnvironment.getLocalGraphicsEnvironment().getMaximumWindowBounds(); // This call hangs on Solaris when called from the EDT.
 
    @NotNull
    private final MouseInputListener mouseInputListener = new MouseInputListener() {
 
        @Override
        public void mouseClicked(final MouseEvent e) {
            mouseTracker.mouseClicked(findElement(e.getComponent(), e), e);
        }
 
        @Override
        public void mousePressed(final MouseEvent e) {
            mouseTracker.mousePressed(findElement(e.getComponent(), e), e);
        }
 
        @Override
        public void mouseReleased(final MouseEvent e) {
            mouseTracker.mouseReleased(findElement(e.getComponent(), e), e);
        }
 
        @Override
        public void mouseEntered(final MouseEvent e) {
            mouseTracker.mouseEntered(findElement(e.getComponent(), e), e);
        }
 
        @Override
        public void mouseExited(final MouseEvent e) {
            mouseTracker.mouseExited(e);
        }
 
        @Override
        public void mouseDragged(final MouseEvent e) {
            mouseTracker.mouseDragged(findElement(e.getComponent(), e), e);
        }
 
        @Override
        public void mouseMoved(final MouseEvent e) {
            mouseTracker.mouseMoved(findElement(e.getComponent(), e), e);
        }
 
    };
 
    @NotNull
    private final MouseWheelListener mouseWheelListener = new MouseWheelListener() {
 
        @Override
        public void mouseWheelMoved(final MouseWheelEvent e) {
            mouseTracker.mouseWheelMoved(findElement(e.getComponent(), e), e);
        }
 
    };
 
    @Nullable
    private BufferStrategy bufferStrategy;
 
    private int windowWidth;
 
    private int windowHeight;
 
    @NotNull
    private final List<Gui> openDialogs = new CopyOnWriteArrayList<>();
 
    @NotNull
    private final EventListenerList2<RendererGuiStateListener> rendererGuiStateListeners = new EventListenerList2<>();
 
    @Nullable
    private Gui currentGui;
 
    @NotNull
    private final Collection<GUIMap> maps = new CopyOnWriteArrayList<>();
 
    @NotNull
    private final Collection<GUIFloorList> floorLists = new CopyOnWriteArrayList<>();
 
    @Nullable
    private Component tooltip;
 
    private int offsetX;
 
    private int offsetY;
 
    private boolean isFullScreen;
 
    private boolean wasDisplayed;
 
    @NotNull
    private RendererGuiState rendererGuiState = RendererGuiState.START;
 
    @NotNull
    private static final DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss,SSS ", Locale.ENGLISH);
 
    @NotNull
    private final ComponentListener componentListener = new ComponentListener() {
 
        @Override
        public void componentResized(final ComponentEvent e) {
            final RootPaneContainer tmpFrame = frame;
            assert tmpFrame != null;
            final int width = tmpFrame.getContentPane().getWidth();
            final int height = tmpFrame.getContentPane().getHeight();
            updateWindowSize(width, height);
            updateServerSettings();
        }
 
        @Override
        public void componentMoved(final ComponentEvent e) {
            // ignore
        }
 
        @Override
        public void componentShown(final ComponentEvent e) {
            updateServerSettings();
        }
 
        @Override
        public void componentHidden(final ComponentEvent e) {
            // ignore
        }
 
    };
 
    public JXCWindowRenderer(@NotNull final MouseTracker mouseTracker, @NotNull final CrossfireServerConnection crossfireServerConnection, @Nullable final Writer debugScreen) {
        this.mouseTracker = mouseTracker;
        this.crossfireServerConnection = crossfireServerConnection;
        this.debugScreen = debugScreen;
        graphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
        graphicsDevice = graphicsEnvironment.getDefaultScreenDevice();
        defaultDisplayMode = getDisplayMode();
        debugScreenWrite("getMaxWindowDimension: maximum window bounds="+maximumWindowBounds.width+"x"+maximumWindowBounds.height+"+"+maximumWindowBounds.x+"+"+maximumWindowBounds.y);
    }
 
    public boolean setFullScreenMode(@NotNull final JFrame frame, @Nullable final Resolution resolution) {
        debugScreenWrite("setFullScreenMode: resolution="+(resolution == null ? "default" : resolution));
 
        final DisplayMode currentDisplayMode = getDisplayMode();
        if (frame == this.frame && isFullScreen && bufferStrategy != null && (resolution == null || resolution.getWidth() == windowWidth && resolution.getHeight() == windowHeight)) {
            debugScreenWrite("setResolutionPre: no change needed");
            debugScreenWrite("setResolutionPre: success");
            return true;
        }
 
        setResolutionPre(frame);
 
        final Dimension dimension;
        if (resolution == null) {
            dimension = new Dimension(currentDisplayMode.getWidth(), currentDisplayMode.getHeight());
            debugScreenWrite("setFullScreenMode: full-screen requested, dimension="+dimension+" [using current display resolution]");
        } else {
            dimension = new Dimension(resolution.getWidth(), resolution.getHeight());
            debugScreenWrite("setFullScreenMode: full-screen requested, dimension="+dimension+" [using user-specified resolution]");
        }
        frame.setPreferredSize(dimension);
        frame.setResizable(false);
        frame.setUndecorated(true);
 
        // full-screen switch must happen before display mode change
        if (!isFullScreenSupported()) {
            setFullScreenWindow(null);
            debugScreenWrite("setFullScreenMode: failure");
            return false;
        }
 
        setFullScreenWindow(frame);
 
        if (resolution == null || resolution.equalsDisplayMode(currentDisplayMode)) {
            debugScreenWrite("setFullScreenMode: requested resolution matches screen resolution");
        } else {
            if (!isDisplayChangeSupported()) {
                setFullScreenWindow(null);
                debugScreenWrite("setFullScreenMode: failure");
                return false;
            }
 
            final DisplayMode newDisplayMode = new DisplayMode(resolution.getWidth(), resolution.getHeight(), DisplayMode.BIT_DEPTH_MULTI, DisplayMode.REFRESH_RATE_UNKNOWN);
            try {
                setDisplayMode(newDisplayMode);
            } catch (final IllegalArgumentException ex) {
                debugScreenWrite("setFullScreenMode: setting screen resolution failed: "+ex.getMessage());
                setDisplayMode(defaultDisplayMode);
                setFullScreenWindow(null);
                debugScreenWrite("setFullScreenMode: failure");
                return false;
            }
        }
 
        setResolutionPost(frame, dimension);
        if (this.frame != null) {
            this.frame.removeComponentListener(componentListener);
        }
        this.frame = frame;
        this.frame.addComponentListener(componentListener);
        addMouseTracker(frame);
        addMouseTrackerRecursively(frame);
        return true;
    }
 
    public void setWindowMode(@NotNull final JFrame frame, @Nullable final Resolution resolution, @NotNull final Resolution minResolution, final boolean fixedSize) {
        debugScreenWrite("setWindowMode: resolution="+(resolution == null ? "default" : resolution)+", minResolution="+minResolution+", fixedSize="+fixedSize);
 
        final DisplayMode currentDisplayMode = getDisplayMode();
        if (frame == this.frame && !isFullScreen && bufferStrategy != null && (resolution == null || resolution.getWidth() == windowWidth && resolution.getHeight() == windowHeight)) {
            debugScreenWrite("setResolutionPre: no change needed");
            debugScreenWrite("setResolutionPre: success");
            return;
        }
 
        setResolutionPre(frame);
 
        debugScreenWrite("setResolutionPre: windowed mode requested");
        frame.setUndecorated(false);
        frame.setResizable(!fixedSize);
        final Point centerPoint = getCenterPoint();
        final Dimension dimension;
        //noinspection IfMayBeConditional
        if (resolution == null) {
            dimension = new Dimension(currentDisplayMode.getWidth(), currentDisplayMode.getHeight());
        } else {
            dimension = resolution.asDimension();
        }
        final int x = centerPoint.x-dimension.width/2;
        final int y = centerPoint.y-dimension.height/2;
        if (!wasDisplayed) {
            frame.setLocation(x, y); // try to minimize display movements
        }
        frame.setVisible(true);
        final Insets frameInsets = frame.getInsets();
        debugScreenWrite("setResolutionPre: frame insets: top="+frameInsets.top+", bottom="+frameInsets.bottom+", left="+frameInsets.left+", right="+frameInsets.right);
 
        final Dimension maxDimension = getMaxWindowDimension(frameInsets);
        debugScreenWrite("setResolutionPre: maximum window dimension: "+maxDimension.width+"x"+maxDimension.height);
        if (dimension.width > maxDimension.width || dimension.height > maxDimension.height) {
            //noinspection VariableNotUsedInsideIf
            if (resolution == null) {
                final int tmpWidth = dimension.width;
                final int tmpHeight = dimension.height;
                dimension.width = Math.max(minResolution.getWidth()+frameInsets.left+frameInsets.right, maxDimension.width);
                dimension.height = Math.max(minResolution.getHeight()+frameInsets.top+frameInsets.bottom, maxDimension.height);
                debugScreenWrite("setResolutionPre: window size "+tmpWidth+"x"+tmpHeight+" exceeds maximum allowed size "+maxDimension.width+"x"+maxDimension.height+", reducing to "+dimension.width+"x"+dimension.height);
            } else {
                debugScreenWrite("setResolutionPre: window size "+dimension.width+"x"+dimension.height+" exceeds maximum allowed size "+maxDimension.width+"x"+maxDimension.height+", ignoring");
            }
        }
 
        if (wasDisplayed) {
            debugScreenWrite("setResolutionPre: resizing window to "+dimension);
            frame.setPreferredSize(dimension);
            frame.setSize(dimension);
        } else {
            wasDisplayed = true;
            final int x2 = centerPoint.x-dimension.width/2-frameInsets.left;
            final int y2 = centerPoint.y-dimension.height/2-frameInsets.top;
            debugScreenWrite("setResolutionPre: moving window to ("+frameInsets.left+"+"+dimension.width+"+"+frameInsets.right+")x("+frameInsets.top+"+"+dimension.height+"+"+frameInsets.bottom+")+"+x2+"+"+y2);
            frame.setBounds(x2, y2, dimension.width+frameInsets.left+frameInsets.right, dimension.height+frameInsets.top+frameInsets.bottom);
        }
 
        setResolutionPost(frame, dimension);
        if (this.frame != null) {
            this.frame.removeComponentListener(componentListener);
        }
        this.frame = frame;
        this.frame.addComponentListener(componentListener);
        addMouseTracker(frame);
        addMouseTrackerRecursively(frame);
    }
 
    private void setResolutionPre(@NotNull final Window frame) {
        // disable full-screen since switching from full-screen to full-screen
        // does not work reliably
        if (isFullScreen) {
            setDisplayMode(defaultDisplayMode);
        }
        setFullScreenWindow(null);
 
        debugScreenWrite("setResolutionPre: disposing frame");
        frame.dispose();
    }
 
    private void setResolutionPost(@NotNull final Window frame, @NotNull final Dimension dimension) {
        debugScreenWrite("setResolutionPost: creating buffer strategy");
        frame.createBufferStrategy(2);
        bufferStrategy = frame.getBufferStrategy();
 
        final Insets insets = frame.getInsets();
        offsetX = insets.left;
        offsetY = insets.top;
        debugScreenWrite("setResolutionPost: offset="+offsetX+"x"+offsetY+" insets: top="+insets.top+", bottom="+insets.bottom+", left="+insets.left+", right="+insets.right);
 
        debugScreenWrite("setResolutionPost: requesting focus");
        frame.requestFocusInWindow();
 
        updateWindowSize(dimension.width, dimension.height);
 
        frame.add(layeredPane);
        if (currentGui == null) {
            frame.validate();
        } else {
            addToLayeredPane(currentGui.getComponent(), 0, -1);
            if (windowWidth > 0 && windowHeight > 0) {
                assert currentGui != null;
                currentGui.getComponent().setSize(windowWidth, windowHeight);
            }
 
            frame.validate();
            updateServerSettings();
        }
 
        debugScreenWrite("setResolutionPost: success");
    }
 
    private void updateWindowSize(final int windowWidth, final int windowHeight) {
        if (this.windowWidth == windowWidth && this.windowHeight == windowHeight) {
            return;
        }
        this.windowWidth = windowWidth;
        this.windowHeight = windowHeight;
        debugScreenWrite("updateWindowSize: gui size="+this.windowWidth+"x"+this.windowHeight);
        if (currentGui != null) {
            currentGui.getComponent().setSize(windowWidth, windowHeight);
        }
        if (frame != null) {
            frame.validate();
        }
    }
 
    @NotNull
    private Dimension getMaxWindowDimension(@NotNull final Insets frameInsets) {
        final GraphicsConfiguration graphicsConfiguration = graphicsDevice.getDefaultConfiguration();
        final Insets screenInsets = Toolkit.getDefaultToolkit().getScreenInsets(graphicsConfiguration);
        debugScreenWrite("getMaxWindowDimension: screen insets: top="+screenInsets.top+", bottom="+screenInsets.bottom+", left="+screenInsets.left+", right="+screenInsets.right);
 
        final int maxWidth = maximumWindowBounds.width-screenInsets.left-screenInsets.right-frameInsets.left-frameInsets.right;
        final int maxHeight = maximumWindowBounds.height-screenInsets.top-screenInsets.bottom-frameInsets.top-frameInsets.bottom;
        debugScreenWrite("getMaxWindowDimension: maximum window dimension: "+maxWidth+"x"+maxHeight);
        return new Dimension(maxWidth, maxHeight);
    }
 
    public void endRendering() {
        if (isFullScreen && frame != null) {
            if (currentGui != null) {
                removeFromLayeredPane(currentGui.getComponent());
            }
            final Resolution minResolution = new Resolution(1, 1);
            assert frame != null;
            setWindowMode(frame, null, minResolution, false);
            assert frame != null;
            removeMouseTracker(frame);
            assert frame != null;
            removeMouseTrackerRecursively(frame);
            assert frame != null;
            frame.removeComponentListener(componentListener);
            frame = null;
        }
    }
 
    public void redraw(@NotNull final Graphics g) {
        layeredPane.paint(g);
    }
 
    public void clearGUI(@NotNull final Gui gui) {
        setCurrentGui(gui);
        for (int ig = 0; ig < 3; ig++) {
            assert bufferStrategy != null;
            final Graphics g = bufferStrategy.getDrawGraphics();
            redrawBlack(g);
            g.dispose();
            assert bufferStrategy != null;
            bufferStrategy.show();
        }
    }
 
    private void redrawBlack(@NotNull final Graphics g) {
        g.setColor(Color.BLACK);
        assert frame != null;
        final int width = frame.getWidth();
        assert frame != null;
        final int height = frame.getHeight();
        g.fillRect(0, 0, width, height);
    }
 
    public boolean openDialog(@NotNull final Gui dialog, final boolean autoCloseOnDeactivate) {
        if (dialog == currentGui) {
            return false;
        }
 
        if (!openDialogs.isEmpty() && openDialogs.get(openDialogs.size()-1) == dialog) {
            dialog.autoSize(windowWidth, windowHeight);
            return false;
        }
 
        if (!openDialogsRemove(dialog)) {
            dialog.activateDefaultElement();
            dialog.setGuiAutoCloseListener(autoCloseOnDeactivate ? () -> closeDialog(dialog) : null);
        }
        openDialogsAdd(dialog);
        updateServerSettings();
        return true;
    }
 
    public void raiseDialog(@NotNull final Gui dialog) {
        if (dialog == currentGui) {
            return;
        }
 
        if (!openDialogs.isEmpty() && openDialogs.get(openDialogs.size()-1) == dialog) {
            dialog.autoSize(windowWidth, windowHeight);
            return;
        }
 
        if (!openDialogs.contains(dialog)) {
            return;
        }
 
        dialog.autoSize(windowWidth, windowHeight);
        layeredPane.add(dialog.getComponent(), 1, 0);
        openDialogs.remove(dialog);
        openDialogs.add(dialog);
        if (frame != null) {
            frame.validate();
        }
 
        updateServerSettings();
    }
 
    public boolean isDialogOpen(@NotNull final Gui dialog) {
        return openDialogs.contains(dialog);
    }
 
    @NotNull
    public Iterable<Gui> getOpenDialogs() {
        return OpenDialogsIterator::new;
    }
 
    public void setCurrentGui(@NotNull final Gui gui) {
        SwingUtilities2.invokeAndWait(() -> {
            if (frame != null && currentGui != null) {
                removeFromLayeredPane(currentGui.getComponent());
            }
            currentGui = gui;
            //noinspection VariableNotUsedInsideIf
            if (frame != null) {
                addToLayeredPane(currentGui.getComponent(), 0, -1);
            }
 
            if (windowWidth > 0 && windowHeight > 0) {
                assert currentGui != null;
                currentGui.getComponent().setBounds(0, 0, windowWidth, windowHeight);
            }
            if (frame != null) {
                frame.validate();
            }
        });
        updateServerSettings();
    }
 
    public boolean closeDialog(@NotNull final Gui dialog) {
        if (!openDialogsRemove(dialog)) {
            return false;
        }
 
        dialog.setActiveElementActive(false);
        updateServerSettings();
        return true;
    }
 
    public boolean toggleDialog(@NotNull final Gui dialog) {
        if (dialog == currentGui) {
            return true;
        }
 
        if (openDialogsRemove(dialog)) {
            dialog.setActiveElementActive(false);
            updateServerSettings();
            return false;
        }
 
        dialog.setGuiAutoCloseListener(null);
        openDialogsAdd(dialog);
        dialog.activateDefaultElement();
        updateServerSettings();
        return true;
    }
 
    public void setTooltip(@Nullable final Component tooltip) {
        if (this.tooltip != null) {
            layeredPane.remove(this.tooltip);
        }
        this.tooltip = tooltip;
        if (this.tooltip != null) {
            layeredPane.add(this.tooltip, 2, -1);
        }
    }
 
    public void setGuiState(@NotNull final RendererGuiState rendererGuiState) {
        if (this.rendererGuiState == rendererGuiState) {
            return;
        }
 
        final RendererGuiState prevRendererGuiState = this.rendererGuiState;
        this.rendererGuiState = rendererGuiState;
        SwingUtilities2.invokeAndWait(() -> {
            for (Gui dialog : openDialogs) {
                removeFromLayeredPane(dialog.getComponent());
                if (!dialog.isHidden(rendererGuiState)) {
                    addToLayeredPane(dialog.getComponent(), 1, 0);
                    if (dialog.isHidden(prevRendererGuiState)) {
                        dialog.notifyOpen();
                    }
                }
            }
            if (frame != null) {
                frame.validate();
            }
        });
        updateServerSettings();
        for (RendererGuiStateListener listener : rendererGuiStateListeners) {
            listener.guiStateChanged(rendererGuiState);
        }
    }
 
    @NotNull
    public RendererGuiState getGuiState() {
        return rendererGuiState;
    }
 
    public void addGuiStateListener(@NotNull final RendererGuiStateListener listener) {
        rendererGuiStateListeners.add(listener);
    }
 
    private void openDialogsAdd(@NotNull final Gui dialog) {
        if (openDialogs.contains(dialog)) {
            raiseDialog(dialog);
            return;
        }
 
        final Point mouse = frame == null ? null : frame.getMousePosition(true);
        if (mouse == null || dialog.isHidden(rendererGuiState)) {
            openDialogs.add(dialog);
            if (!dialog.isHidden(rendererGuiState)) {
                openDialogInt(dialog);
            }
        } else {
            if (dialog.isWithinDrawingArea(mouse.x, mouse.y)) {
                final MouseEvent mouseEvent = new MouseEvent(frame, 0, System.currentTimeMillis(), 0, mouse.x, mouse.y, 0, false);
                mouseTracker.mouseExited(mouseEvent);
                openDialogs.add(dialog);
                assert !dialog.isHidden(rendererGuiState);
                openDialogInt(dialog);
                mouseTracker.mouseEntered(findElement(mouseEvent), mouseEvent);
            } else {
                openDialogs.add(dialog);
                assert !dialog.isHidden(rendererGuiState);
                openDialogInt(dialog);
            }
        }
 
        dialog.autoSize(windowWidth, windowHeight);
        dialog.notifyOpen();
    }
 
    private void openDialogInt(@NotNull final Gui dialog) {
        addToLayeredPane(dialog.getComponent(), 1, 0);
        if (frame != null) {
            frame.validate();
        }
    }
 
    private boolean openDialogsRemove(@NotNull final Gui dialog) {
        if (!openDialogs.contains(dialog)) {
            return false;
        }
 
        final Point mouse = frame == null ? null : frame.getMousePosition(true);
        if (mouse == null) {
            openDialogs.remove(dialog);
            removeFromLayeredPane(dialog.getComponent());
            if (frame != null) {
                frame.validate();
                // @todo too aggressive?
                assert frame != null;
                frame.repaint();
            }
        } else {
            if (dialog.isWithinDrawingArea(mouse.x, mouse.y)) {
                final MouseEvent mouseEvent = new MouseEvent(frame, 0, System.currentTimeMillis(), 0, mouse.x, mouse.y, 0, false);
                mouseTracker.mouseExited(mouseEvent);
                openDialogs.remove(dialog);
                removeFromLayeredPane(dialog.getComponent());
                if (frame != null) {
                    frame.validate();
                    // @todo too aggressive?
                    assert frame != null;
                    frame.repaint();
                }
                mouseTracker.mouseEntered(findElement(mouseEvent), mouseEvent);
            } else {
                openDialogs.remove(dialog);
                removeFromLayeredPane(dialog.getComponent());
                if (frame != null) {
                    frame.validate();
                    // @todo too aggressive?
                    assert frame != null;
                    frame.repaint();
                }
            }
        }
 
        return true;
    }
 
    public boolean deactivateCommandInput() {
        for (Gui dialog : openDialogs) {
            if (!dialog.isHidden(rendererGuiState)) {
                if (dialog.deactivateCommandInput()) {
                    return true;
                }
                if (dialog.isModal()) {
                    return false;
                }
            }
        }
 
        assert currentGui != null;
        return currentGui.deactivateCommandInput();
    }
 
    @Nullable
    public Buffer getActiveMessageBuffer() {
        for (Gui dialog : openDialogs) {
            if (!dialog.isHidden(rendererGuiState)) {
                final Buffer buffer = getActiveMessageBuffer(dialog);
                if (buffer != null) {
                    return buffer;
                }
                if (dialog.isModal()) {
                    return null;
                }
            }
        }
 
        assert currentGui != null;
        return getActiveMessageBuffer(currentGui);
    }
 
    @Nullable
    private static Buffer getActiveMessageBuffer(@NotNull final Gui gui) {
        final GUILog buffer = gui.getFirstElement(GUIMessageLog.class);
        return buffer == null ? null : buffer.getBuffer();
    }
 
    public void setSelectedHostname(@NotNull final String serverName) {
        assert currentGui != null;
        final GUIMetaElementList metaElementList = currentGui.getFirstElement(GUIMetaElementList.class);
        if (metaElementList != null) {
            metaElementList.setSelectedHostname(serverName);
        }
    }
 
    @Nullable
    public GUIText activateCommandInput() {
        // check main gui
        assert currentGui != null;
        final GUIText textArea1 = activateCommandInput(currentGui);
        if (textArea1 != null) {
            return textArea1;
        }
 
        // check visible dialogs
        for (Gui dialog : openDialogs) {
            if (!dialog.isHidden(rendererGuiState)) {
                final GUIText textArea2 = activateCommandInput(dialog);
                if (textArea2 != null) {
                    openDialog(dialog, false); // raise dialog
                    return textArea2;
                }
            }
            if (dialog.isModal()) {
                return null;
            }
        }
 
        return null;
    }
 
    public boolean handleKeyPress(@NotNull final KeyEvent2 e) {
        assert currentGui != null;
        return currentGui.handleKeyPress(e);
    }
 
    private class OpenDialogsIterator implements Iterator<Gui> {
 
        @NotNull
        private final ListIterator<Gui> it = openDialogs.listIterator(openDialogs.size());
 
        @Override
        public boolean hasNext() {
            return it.hasPrevious();
        }
 
        @NotNull
        @Override
        public Gui next() {
            return it.previous();
        }
 
        @Override
        public void remove() {
            throw new UnsupportedOperationException("remove() not implemented");
        }
 
    }
 
    public int getWindowWidth() {
        return windowWidth;
    }
 
    public int getWindowHeight() {
        return windowHeight;
    }
 
    @Nullable
    private static AbstractGUIElement findElement(@NotNull final Component component, @NotNull final MouseEvent mouseEvent) {
        for (Component result = component; result != null; result = result.getParent()) {
            if (result instanceof AbstractGUIElement) {
                return (AbstractGUIElement)result;
            }
            if (result instanceof final JViewport viewport) {
                final Point position = viewport.getViewPosition();
                mouseEvent.translatePoint(-position.x, -position.y);
            }
        }
        return null;
    }
 
    @Nullable
    private AbstractGUIElement findElement(@NotNull final MouseEvent e) {
        final MouseEvent ce = e;//convertEvent(e);
        AbstractGUIElement elected = null;
 
        final int eX = ce.getX();
        final int eY = ce.getY();
        for (Gui dialog : openDialogs) {
            if (!dialog.isHidden(rendererGuiState)) {
                elected = getElementFromPoint(dialog, eX-dialog.getComponent().getX(), eY-dialog.getComponent().getY());
                //noinspection VariableNotUsedInsideIf
                if (elected != null) {
                    break;
                }
            }
            if (dialog.isModal()) {
                return null;
            }
        }
 
        if (elected == null) {
            assert currentGui != null;
            elected = getElementFromPoint(currentGui, eX, eY);
        }
 
        return elected;
    }
 
    @Nullable
    private AbstractGUIElement getElementFromPoint(@NotNull final Gui gui, final int eX, final int eY) {
        final int x = eX-offsetX;
        final int y = eY-offsetY;
        return gui.getElementFromPoint(x, y);
    }
 
    private void debugScreenWrite(@NotNull final CharSequence message) {
        if (debugScreen == null) {
            return;
        }
 
        try {
            debugScreen.append(FORMATTER.format(LocalDateTime.now()));
            debugScreen.append(message);
            debugScreen.append("\n");
            debugScreen.flush();
        } catch (final IOException ex) {
            System.err.println("Cannot write screen debug: "+ex.getMessage());
            System.exit(1);
            throw new AssertionError(ex);
        }
    }
 
    private void addToLayeredPane(@NotNull final Component component, final int layer, final int index) {
        layeredPane.add(component, layer, index);
        addMouseTrackerRecursively(component);
        addComponent(component);
    }
 
    private void removeFromLayeredPane(@NotNull final Component component) {
        layeredPane.remove(component);
        removeMouseTrackerRecursively(component);
        removeComponent(component);
    }
 
    private void addMouseTracker(@NotNull final Component component) {
        if (component instanceof AbstractGUIElement && ((AbstractGUIElement)component).isIgnore()) {
            return;
        }
 
        component.addMouseListener(mouseInputListener);
        component.addMouseMotionListener(mouseInputListener);
        component.addMouseWheelListener(mouseWheelListener);
    }
 
    private void removeMouseTracker(@NotNull final Component component) {
        if (component instanceof AbstractGUIElement && ((AbstractGUIElement)component).isIgnore()) {
            return;
        }
 
        component.removeMouseListener(mouseInputListener);
        component.removeMouseMotionListener(mouseInputListener);
        component.removeMouseWheelListener(mouseWheelListener);
    }
 
    private void addMouseTrackerRecursively(@NotNull final Component component) {
        addMouseTracker(component);
        if (component instanceof final Container container) {
            for (int i = 0; i < container.getComponentCount(); i++) {
                addMouseTrackerRecursively(container.getComponent(i));
            }
        }
    }
 
    private void removeMouseTrackerRecursively(@NotNull final Component component) {
        removeMouseTracker(component);
        if (component instanceof final Container container) {
            for (int i = 0; i < container.getComponentCount(); i++) {
                removeMouseTrackerRecursively(container.getComponent(i));
            }
        }
    }
 
    private void addComponent(@NotNull final Component component) {
        //noinspection ChainOfInstanceofChecks
        if (component instanceof final GUIMap map) {
            maps.add(map);
        }
        if (component instanceof final GUIFloorList floorList) {
            floorLists.add(floorList);
        }
        if (component instanceof final Container container) {
            for (int i = 0; i < container.getComponentCount(); i++) {
                addComponent(container.getComponent(i));
            }
        }
    }
 
    private void removeComponent(@NotNull final Component component) {
        //noinspection ChainOfInstanceofChecks
        if (component instanceof final GUIMap map) {
            maps.remove(map);
        }
        if (component instanceof final GUIFloorList floorList) {
            floorLists.remove(floorList);
        }
        if (component instanceof final Container container) {
            for (int i = 0; i < container.getComponentCount(); i++) {
                removeComponent(container.getComponent(i));
            }
        }
    }
 
    public void updateServerSettings() {
        if (frame == null || !frame.isVisible()) {
            return;
        }
 
        final Dimension mapSize = getMapSize();
        crossfireServerConnection.setPreferredMapSize(mapSize.width, mapSize.height);
        crossfireServerConnection.setPreferredNumLookObjects(getNumLookObjects());
    }
 
    @NotNull
    private Dimension getMapSize() {
        int width = DEFAULT_MAP_WIDTH;
        int height = DEFAULT_MAP_HEIGHT;
        for (GUIMap map : maps) {
            width = Math.max(width, map.getPreferredMapWidth());
            height = Math.max(height, map.getPreferredMapHeight());
        }
        return new Dimension(width, height);
    }
 
    private int getNumLookObjects() {
        int minNumLookObjects = Integer.MAX_VALUE;
        for (GUIFloorList floorList : floorLists) {
            minNumLookObjects = Math.min(minNumLookObjects, floorList.getNumLookObjects());
        }
        if (minNumLookObjects < Integer.MAX_VALUE) {
            return minNumLookObjects;
        }
 
        return DEFAULT_NUM_LOOK_OBJECTS;
    }
 
    @Nullable
    public static GUIText activateCommandInput(@NotNull final Gui gui) {
        final GUIText textArea = gui.getFirstElement(GUIText.class);
        if (textArea == null) {
            return null;
        }
 
        if (!textArea.getName().equals("command")) {
            return null;
        }
 
        textArea.setActive(true);
        return textArea;
    }
 
    private boolean isDisplayChangeSupported() {
        final boolean result = graphicsDevice.isDisplayChangeSupported();
        debugScreenWrite("isDisplayChangeSupported()="+(result ? "yes" : "no"));
        return result;
    }
 
    private void setDisplayMode(@NotNull final DisplayMode displayMode) {
        debugScreenWrite("setDisplayMode("+displayMode.getWidth()+"x"+displayMode.getHeight()+")");
        graphicsDevice.setDisplayMode(displayMode);
    }
 
    @NotNull
    private DisplayMode getDisplayMode() {
        final DisplayMode displayMode = graphicsDevice.getDisplayMode();
        debugScreenWrite("getDisplayMode: "+displayMode.getWidth()+"x"+displayMode.getHeight());
        return displayMode;
    }
 
    private boolean isFullScreenSupported() {
        final boolean result = graphicsDevice.isFullScreenSupported();
        debugScreenWrite("isFullScreenSupported()="+(result ? "yes" : "no"));
        return result;
    }
 
    private void setFullScreenWindow(@Nullable final Window window) {
        isFullScreen = window != null;
        debugScreenWrite("setFullScreenWindow("+(isFullScreen ? "enter full-screen mode" : "leave full-screen mode")+")");
        graphicsDevice.setFullScreenWindow(window);
    }
 
    @NotNull
    private Point getCenterPoint() {
        final Point result = graphicsEnvironment.getCenterPoint();
        debugScreenWrite("getCenterPoint: "+result.x+"/"+result.y);
        return result;
    }
 
}