/home/leaf/crossfire/jxclient/trunk/gui/src/main/java/com/realtime/crossfire/jxclient/gui/label/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-2011 Andreas Kirschbaum.
 */

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

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.GuiAutoCloseListener;
import com.realtime.crossfire.jxclient.gui.gui.RendererGuiState;
import com.realtime.crossfire.jxclient.gui.gui.RendererGuiStateListener;
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 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.image.BufferStrategy;
import java.io.IOException;
import java.io.Writer;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.ListIterator;
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 = null;

    @NotNull
    private final Container layeredPane = new JLayeredPane() {

        private static final long serialVersionUID = 1L;

        @Override
        public void paint(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 MouseInputListener mouseInputListener = new MouseInputListener() {

        @Override
        public void mouseClicked(final MouseEvent e) {
            // ignore
        }

        @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);
        }

    };

    @Nullable
    private BufferStrategy bufferStrategy = null;

    private int windowWidth = 0;

    private int windowHeight = 0;

    @NotNull
    private final CopyOnWriteArrayList<Gui> openDialogs = new CopyOnWriteArrayList<Gui>();

    @NotNull
    private final EventListenerList2<RendererGuiStateListener> rendererGuiStateListeners = new EventListenerList2<RendererGuiStateListener>(RendererGuiStateListener.class);

    @Nullable
    private Gui currentGui = null;

    @NotNull
    private final Collection<GUIMap> maps = new CopyOnWriteArrayList<GUIMap>();

    @NotNull
    private final Collection<GUIFloorList> floorLists = new CopyOnWriteArrayList<GUIFloorList>();

    @Nullable
    private Component tooltip = null;

    private int offsetX = 0;

    private int offsetY = 0;

    private boolean isFullScreen = false;

    private boolean wasDisplayed = false;

    @NotNull
    private RendererGuiState rendererGuiState = RendererGuiState.START;

    @NotNull
    private final DateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss,SSS ");

    @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 = graphicsDevice.getDisplayMode();
    }

    public boolean setFullScreenMode(@NotNull final JFrame frame, @Nullable final Resolution resolution) {
        debugScreenWrite("setFullScreenMode: resolution="+(resolution == null ? "default" : resolution));

        final DisplayMode currentDisplayMode = graphicsDevice.getDisplayMode();
        debugScreenWrite("setResolutionPre: current display mode="+currentDisplayMode.getWidth()+"x"+currentDisplayMode.getHeight());
        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());
        } else {
            dimension = new Dimension(resolution.getWidth(), resolution.getHeight());
        }
        debugScreenWrite("setFullScreenMode: full-screen requested, dimension="+dimension);
        frame.setPreferredSize(dimension);
        frame.setResizable(false);
        frame.setUndecorated(true);

        // full-screen switch must happen before display mode change
        if (!graphicsDevice.isFullScreenSupported()) {
            debugScreenWrite("setFullScreenMode: full-screen mode is not supported");
            graphicsDevice.setFullScreenWindow(null);
            isFullScreen = false;
            debugScreenWrite("setFullScreenMode: failure");
            return false;
        }

        debugScreenWrite("setFullScreenMode: entering full-screen mode");
        graphicsDevice.setFullScreenWindow(frame);
        isFullScreen = true;

        if (resolution == null || resolution.equalsDisplayMode(currentDisplayMode)) {
            debugScreenWrite("setFullScreenMode: requested resolution matches screen resolution");
        } else {
            if (!graphicsDevice.isDisplayChangeSupported()) {
                debugScreenWrite("setFullScreenMode: screen resolution change is not supported");
                graphicsDevice.setFullScreenWindow(null);
                isFullScreen = false;
                debugScreenWrite("setFullScreenMode: failure");
                return false;
            }

            final DisplayMode newDisplayMode = new DisplayMode(resolution.getWidth(), resolution.getHeight(), DisplayMode.BIT_DEPTH_MULTI, DisplayMode.REFRESH_RATE_UNKNOWN);
            try {
                debugScreenWrite("setFullScreenMode: setting screen resolution to "+newDisplayMode.getWidth()+"x"+newDisplayMode.getHeight());
                graphicsDevice.setDisplayMode(newDisplayMode);
            } catch (final IllegalArgumentException ex) {
                debugScreenWrite("setFullScreenMode: setting screen resolution failed: "+ex.getMessage());
                isFullScreen = false;
                debugScreenWrite("setFullScreenMode: resetting screen resolution to "+defaultDisplayMode.getWidth()+"x"+defaultDisplayMode.getHeight());
                graphicsDevice.setDisplayMode(defaultDisplayMode);
                debugScreenWrite("setFullScreenMode: leaving full-screen mode");
                graphicsDevice.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)+", fixedSize="+fixedSize);

        final DisplayMode currentDisplayMode = graphicsDevice.getDisplayMode();
        debugScreenWrite("setResolutionPre: current display mode="+currentDisplayMode.getWidth()+"x"+currentDisplayMode.getHeight());
        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 = graphicsEnvironment.getCenterPoint();
        debugScreenWrite("setResolutionPre: screen center point is "+centerPoint);
        final Dimension dimension;
        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="+frameInsets);

        final Dimension maxDimension = getMaxWindowDimension(frameInsets);
        debugScreenWrite("setResolutionPre: maximal window dimension="+maxDimension);
        if (dimension.width > maxDimension.width || dimension.height > maxDimension.height) {
            //noinspection VariableNotUsedInsideIf
            if (resolution == null) {
                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 exceeds maximum allowed size, reducing window size to "+dimension.width+"x"+dimension.height);
            } else {
                debugScreenWrite("setResolutionPre: window size exceeds maximum allowed size, 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 "+x2+"/"+y2+" "+dimension.width+"x"+dimension.height);
            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) {
            debugScreenWrite("setResolutionPre: resetting screen resolution to "+defaultDisplayMode.getWidth()+"x"+defaultDisplayMode.getHeight());
            graphicsDevice.setDisplayMode(defaultDisplayMode);
        }
        debugScreenWrite("setResolutionPre: leaving full-screen mode");
        graphicsDevice.setFullScreenWindow(null);
        isFullScreen = false;

        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);

        debugScreenWrite("setResolutionPost: requesting focus");
        frame.requestFocusInWindow();

        updateWindowSize(dimension.width, dimension.height);

        frame.add(layeredPane);
        if (currentGui != null) {
            addToLayeredPane(currentGui, 0, -1);
            if (windowWidth > 0 && windowHeight > 0) {
                assert currentGui != null;
                currentGui.setSize(windowWidth, windowHeight);
            }

            frame.validate();
            updateServerSettings();
        } else {
            frame.validate();
        }

        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.setSize(windowWidth, windowHeight);
        }
        if (frame != null) {
            frame.validate();
        }
    }

    @NotNull
    private Dimension getMaxWindowDimension(@NotNull final Insets frameInsets) {
        final Rectangle maximumWindowBounds = graphicsEnvironment.getMaximumWindowBounds();
        debugScreenWrite("getMaxWindowDimension: maximum window bounds="+maximumWindowBounds);

        final GraphicsConfiguration graphicsConfiguration = graphicsDevice.getDefaultConfiguration();
        final Insets screenInsets = Toolkit.getDefaultToolkit().getScreenInsets(graphicsConfiguration);
        debugScreenWrite("getMaxWindowDimension: screen insets="+screenInsets);

        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);
            }
            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) {
            return false;
        }

        if (!openDialogsRemove(dialog)) {
            dialog.activateDefaultElement();
            @Nullable final GuiAutoCloseListener guiAutoCloseListener;
            if (autoCloseOnDeactivate) {
                guiAutoCloseListener = new GuiAutoCloseListener() {

                    @Override
                    public void autoClosed() {
                        closeDialog(dialog);
                    }

                };

            } else {
                guiAutoCloseListener = null;
            }
            dialog.setGuiAutoCloseListener(guiAutoCloseListener);
        }
        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) {
            return;
        }

        if (!isDialogOpen(dialog)) {
            return;
        }

        if (!openDialogsRemove(dialog)) {
            assert false;
        }
        openDialogsAdd(dialog);
        updateServerSettings();
    }

    public boolean isDialogOpen(@NotNull final Gui dialog) {
        return openDialogs.contains(dialog);
    }

    @NotNull
    public Iterable<Gui> getOpenDialogs() {
        return new Iterable<Gui>() {

            @Override
            public Iterator<Gui> iterator() {
                return new OpenDialogsIterator();
            }

        };
    }

    @SuppressWarnings("NullableProblems")
    public void setCurrentGui(@NotNull final Gui gui) {
        if (frame != null && currentGui != null) {
            removeFromLayeredPane(currentGui);
        }
        currentGui = gui;
        //noinspection VariableNotUsedInsideIf
        if (frame != null) {
            addToLayeredPane(currentGui, 0, -1);
        }

        if (windowWidth > 0 && windowHeight > 0) {
            assert currentGui != null;
            currentGui.setSize(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;
        }

        this.rendererGuiState = rendererGuiState;
        for (final Gui dialog : openDialogs) {
            removeFromLayeredPane(dialog);
            if (!dialog.isHidden(rendererGuiState)) {
                addToLayeredPane(dialog, 1, 0);
            }
        }
        if (frame != null) {
            frame.validate();
        }
        updateServerSettings();
        for (final RendererGuiStateListener listener : rendererGuiStateListeners.getListeners()) {
            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;
        }

        dialog.autoSize(windowWidth, windowHeight);

        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);
            }
        }
    }

    private void openDialogInt(@NotNull final Gui dialog) {
        addToLayeredPane(dialog, 1, 0);
        final Dimension preferredSize = dialog.getPreferredSize();
        final Dimension size;
        if (preferredSize == null) {
            size = new Dimension(320, 200);
        } else {
            size = new Dimension(Math.min(preferredSize.width, windowWidth), Math.min(preferredSize.height, windowHeight));
        }
        dialog.setSize(size);
        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);
            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);
                if (frame != null) {
                    frame.validate();
                    // @todo too aggressive?
                    assert frame != null;
                    frame.repaint();
                }
                mouseTracker.mouseEntered(findElement(mouseEvent), mouseEvent);
            } else {
                openDialogs.remove(dialog);
                removeFromLayeredPane(dialog);
                if (frame != null) {
                    frame.validate();
                    // @todo too aggressive?
                    assert frame != null;
                    frame.repaint();
                }
            }
        }

        return true;
    }

    public boolean deactivateCommandInput() {
        for (final 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 (final 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 (final 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 KeyEvent 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();
        }

        @SuppressWarnings("IteratorNextCanNotThrowNoSuchElementException")
        @NotNull
        @Override
        public Gui next() {
            return it.previous();
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException();
        }

    }

    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 JViewport) {
                final JViewport viewport = (JViewport)result;
                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 (final Gui dialog : openDialogs) {
            if (!dialog.isHidden(rendererGuiState)) {
                elected = getElementFromPoint(dialog, eX-dialog.getX(), eY-dialog.getY());
                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(simpleDateFormat.format(new Date()));
            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();
        }
    }

    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) {
        component.addMouseListener(mouseInputListener);
        component.addMouseMotionListener(mouseInputListener);
    }

    private void removeMouseTracker(@NotNull final Component component) {
        component.removeMouseListener(mouseInputListener);
        component.removeMouseMotionListener(mouseInputListener);
    }

    private void addMouseTrackerRecursively(@NotNull final Component component) {
        addMouseTracker(component);
        if (component instanceof Container) {
            final Container container = (Container)component;
            for (int i = 0; i < container.getComponentCount(); i++) {
                addMouseTrackerRecursively(container.getComponent(i));
            }
        }
    }

    private void removeMouseTrackerRecursively(@NotNull final Component component) {
        removeMouseTracker(component);
        if (component instanceof Container) {
            final Container container = (Container)component;
            for (int i = 0; i < container.getComponentCount(); i++) {
                removeMouseTrackerRecursively(container.getComponent(i));
            }
        }
    }

    private void addComponent(@NotNull final Component component) {
        if (component instanceof GUIMap) {
            final GUIMap map = (GUIMap)component;
            maps.add(map);
        }
        if (component instanceof GUIFloorList) {
            final GUIFloorList floorList = (GUIFloorList)component;
            floorLists.add(floorList);
        }
        if (component instanceof Container) {
            final Container container = (Container)component;
            for (int i = 0; i < container.getComponentCount(); i++) {
                addComponent(container.getComponent(i));
            }
        }
    }

    private void removeComponent(@NotNull final Component component) {
        if (component instanceof GUIMap) {
            final GUIMap map = (GUIMap)component;
            maps.remove(map);
        }
        if (component instanceof GUIFloorList) {
            final GUIFloorList floorList = (GUIFloorList)component;
            floorLists.remove(floorList);
        }
        if (component instanceof Container) {
            final Container container = (Container)component;
            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 (final 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 (final 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;
    }

}

---