MapDesktop.java

Go to the documentation of this file.

/*
 * Gridarta MMORPG map editor for Crossfire, Daimonin and similar games.
 * Copyright (C) 2000-2023 The Gridarta Developers.
 *
 * This program 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.
 *
 * This program 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 this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
package net.sf.gridarta.gui.mapdesktop;
 
import java.awt.Component;
import java.beans.PropertyVetoException;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.Map;
import javax.swing.Action;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JDesktopPane;
import javax.swing.JInternalFrame;
import javax.swing.JMenu;
import javax.swing.event.InternalFrameEvent;
import javax.swing.event.InternalFrameListener;
import net.sf.gridarta.gui.map.mapview.MapView;
import net.sf.gridarta.gui.map.mapview.MapViewManager;
import net.sf.gridarta.gui.map.mapview.MapViewsListener;
import net.sf.gridarta.gui.map.mapview.MapViewsManager;
import net.sf.gridarta.gui.mapimagecache.MapImageCache;
import net.sf.gridarta.gui.mapimagecache.MapImageCacheListener;
import net.sf.gridarta.model.archetype.Archetype;
import net.sf.gridarta.model.gameobject.GameObject;
import net.sf.gridarta.model.maparchobject.MapArchObject;
import net.sf.gridarta.model.mapcontrol.MapControl;
import net.sf.gridarta.model.mapmanager.MapManager;
import net.sf.gridarta.model.mapmanager.MapManagerListener;
import net.sf.gridarta.utils.EditorAction;
import net.sf.japi.swing.action.ActionBuilder;
import net.sf.japi.swing.action.ActionBuilderFactory;
import net.sf.japi.swing.action.ActionMethod;
import org.apache.log4j.Category;
import org.apache.log4j.Logger;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public class MapDesktop<G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> implements EditorAction {
 
    @NotNull
    private static final Category LOG = Logger.getLogger(MapDesktop.class);
 
    @NotNull
    private static final ActionBuilder ACTION_BUILDER = ActionBuilderFactory.getInstance().getActionBuilder("net.sf.gridarta");
 
    private static final long serialVersionUID = 1L;
 
    @NotNull
    private final MapViewManager<G, A, R> mapViewManager;
 
    @NotNull
    private final MapManager<G, A, R> mapManager;
 
    @NotNull
    private final MapImageCache<G, A, R> mapImageCache;
 
    @NotNull
    private final MapViewsManager<G, A, R> mapViewsManager;
 
    @NotNull
    private final JDesktopPane desktopPane = new JDesktopPane();
 
    @Nullable
    private Action aPrevWindow;
 
    @Nullable
    private Action aNextWindow;
 
    @NotNull
    private final Map<MapView<G, A, R>, WindowAction<G, A, R>> windowActions = new IdentityHashMap<>();
 
    @NotNull
    private final Map<MapView<G, A, R>, MapViewFrameListener> mapViewFrameListeners = new IdentityHashMap<>();
 
    @NotNull
    private final MapManagerListener<G, A, R> mapManagerListener = new MapManagerListener<G, A, R>() {
 
        @Override
        public void currentMapChanged(@Nullable final MapControl<G, A, R> mapControl) {
            // ignore
        }
 
        @Override
        public void mapCreated(@NotNull final MapControl<G, A, R> mapControl, final boolean interactive) {
            mapViewsManager.addMapViewsListener(mapControl, mapViewsListener);
        }
 
        @Override
        public void mapClosing(@NotNull final MapControl<G, A, R> mapControl) {
            // ignore
        }
 
        @Override
        public void mapClosed(@NotNull final MapControl<G, A, R> mapControl) {
            mapViewsManager.removeMapViewsListener(mapControl, mapViewsListener);
        }
 
    };
 
    @NotNull
    private final MapViewsListener<G, A, R> mapViewsListener = new MapViewsListener<G, A, R>() {
 
        @Override
        public void mapViewCreated(@NotNull final MapView<G, A, R> mapView) {
            addMapView(mapView);
        }
 
        @Override
        public void mapViewRaise(@NotNull final MapView<G, A, R> mapView) {
            setCurrentMapView(mapView);
        }
 
        @Override
        public void mapViewClosing(@NotNull final MapView<G, A, R> mapView) {
            removeMapView(mapView);
        }
 
    };
 
    @NotNull
    private final MapImageCacheListener<G, A, R> mapImageCacheListener = new MapImageCacheListener<G, A, R>() {
 
        @Override
        public void iconChanged(@NotNull final MapControl<G, A, R> mapControl) {
            final Iterator<MapView<G, A, R>> it = mapViewsManager.getMapViewIterator(mapControl);
            while (it.hasNext()) {
                updateFrameIcon(it.next());
            }
        }
 
    };
 
    public MapDesktop(@NotNull final MapViewManager<G, A, R> mapViewManager, @NotNull final MapManager<G, A, R> mapManager, @NotNull final MapImageCache<G, A, R> mapImageCache, @NotNull final MapViewsManager<G, A, R> mapViewsManager) {
        this.mapViewManager = mapViewManager;
        this.mapManager = mapManager;
        this.mapImageCache = mapImageCache;
        this.mapViewsManager = mapViewsManager;
        mapManager.addMapManagerListener(mapManagerListener);
        mapImageCache.addMapImageCacheListener(mapImageCacheListener);
        updateFocus(false);
    }
 
    @NotNull
    public Component getComponent() {
        return desktopPane;
    }
 
    public void setCurrentMapView(@NotNull final MapView<G, A, R> mapView) {
        mapViewManager.setActiveMapView(mapView);
        // De-iconify if necessary
        final JInternalFrame internalFrame = mapView.getInternalFrame();
        if (internalFrame.isIcon()) {
            try {
                internalFrame.setIcon(false);
            } catch (final PropertyVetoException e) {
                LOG.warn(ACTION_BUILDER.format("logUnexpectedException", e));
            }
            mapView.activate();
            return;
        }
        updateFocus(true);
        internalFrame.requestFocus();
        internalFrame.restoreSubcomponentFocus();
    }
 
    private void removeMapView(@NotNull final MapView<G, A, R> mapView) {
        final JInternalFrame internalFrame = mapView.getInternalFrame();
        internalFrame.removeInternalFrameListener(mapViewFrameListeners.remove(mapView));
        mapViewManager.removeMapView(mapView);
        if (windowActions.remove(mapView) == null) {
            assert false;
        }
        try {
            internalFrame.setSelected(false);
        } catch (final PropertyVetoException ignored) {
        }
        try {
            internalFrame.setClosed(true);
        } catch (final PropertyVetoException ignored) {
        }
        desktopPane.remove(internalFrame);
        internalFrame.dispose();
        desktopPane.repaint();
 
        updateFocus(true);
        refreshMenus();
    }
 
    private void addMapView(@NotNull final MapView<G, A, R> mapView) {
        final WindowAction<G, A, R> windowAction = new WindowAction<>(this, mapView, mapManager);
        windowActions.put(mapView, windowAction);
        updateFrameIcon(mapView);
 
        final JInternalFrame internalFrame = mapView.getInternalFrame();
        final MapViewFrameListener mapViewFrameListener = new MapViewFrameListener(mapView);
        if (mapViewFrameListeners.put(mapView, mapViewFrameListener) != null) {
            assert false;
        }
        internalFrame.addInternalFrameListener(mapViewFrameListener);
        desktopPane.add(internalFrame);
        mapViewManager.addMapView(mapView);
        setCurrentMapView(mapView);
        internalFrame.setVisible(true);
        internalFrame.setBounds(0, 0, desktopPane.getWidth(), desktopPane.getHeight());
        try {
            internalFrame.setMaximum(true);
        } catch (final PropertyVetoException e) {
            LOG.error("PropertyVetoException: " + e);
        }
        refreshMenus();
    }
 
    private void updateFrameIcon(@NotNull final MapView<G, A, R> mapView) {
        final Action windowAction = windowActions.get(mapView);
        assert windowAction != null;
        final Icon icon = new ImageIcon(mapImageCache.getOrCreateIcon(mapView.getMapControl()));
        mapView.getInternalFrame().setFrameIcon(icon);
        windowAction.putValue(Action.SMALL_ICON, icon);
    }
 
    public void addWindowAction(@NotNull final JMenu menu, @NotNull final MapView<G, A, R> mapView, final int index) {
        final WindowAction<G, A, R> windowAction = windowActions.get(mapView);
        assert windowAction != null;
        windowAction.setIndex(index);
        menu.add(windowAction);
    }
 
    private void activateAndRaiseMapView(@NotNull final MapView<G, A, R> mapView) {
        mapManager.setCurrentMap(mapView.getMapControl());
        mapView.activate();
        final JInternalFrame internalFrame = mapView.getInternalFrame();
        internalFrame.moveToFront();
        try {
            internalFrame.setSelected(true);
        } catch (final PropertyVetoException ignored) {
        }
    }
 
    private void mapViewFocusLostNotify(@NotNull final MapView<G, A, R> mapView) {
        mapViewManager.deactivateMapView(mapView);
        updateFocus(true);
    }
 
    private void mapViewFocusGainedNotify(@NotNull final MapView<G, A, R> mapView) {
        mapViewManager.activateMapView(mapView);
        mapViewsManager.setFocus(mapView);
        mapManager.setCurrentMap(mapView.getMapControl());
    }
 
    private void updateFocus(final boolean careAboutIconification) {
        // Show the next map (if such exists)
        for (final MapView<G, A, R> mapView : mapViewManager) {
            final JInternalFrame internalFrame = mapView.getInternalFrame();
            if (internalFrame.isIcon()) {
                if (!careAboutIconification) {
                    try {
                        internalFrame.setIcon(false);
                    } catch (final PropertyVetoException e) {
                        LOG.warn(ACTION_BUILDER.format("logUnexpectedException", e));
                    }
                    activateAndRaiseMapView(mapView);
                    return;
                }
            } else {
                activateAndRaiseMapView(mapView);
                return;
            }
        }
 
        // No non-iconified map windows found
        mapManager.setCurrentMap(null);
    }
 
    @ActionMethod
    public void prevWindow() {
        doPrevWindow(true);
    }
 
    @ActionMethod
    public void nextWindow() {
        doNextWindow(true);
    }
 
    private void refreshMenus() {
        if (aPrevWindow != null) {
            aPrevWindow.setEnabled(doPrevWindow(false));
        }
        if (aNextWindow != null) {
            aNextWindow.setEnabled(doNextWindow(false));
        }
    }
 
    private boolean doPrevWindow(final boolean performAction) {
        if (!mapViewManager.doPrevWindow(performAction)) {
            return false;
        }
 
        if (performAction) {
            updateFocus(false);
        }
 
        return true;
    }
 
    private boolean doNextWindow(final boolean performAction) {
        if (!mapViewManager.doNextWindow(performAction)) {
            return false;
        }
 
        if (performAction) {
            updateFocus(false);
        }
 
        return true;
    }
 
    @Override
    public void setAction(@NotNull final Action action, @NotNull final String name) {
        if (name.equals("prevWindow")) {
            aPrevWindow = action;
        } else if (name.equals("nextWindow")) {
            aNextWindow = action;
        } else {
            throw new IllegalArgumentException("unsupported action name: " + name);
        }
        refreshMenus();
    }
 
    private class MapViewFrameListener implements InternalFrameListener {
 
        @NotNull
        private final MapView<G, A, R> mapView;
 
        private MapViewFrameListener(@NotNull final MapView<G, A, R> mapView) {
            this.mapView = mapView;
        }
 
        @Override
        public void internalFrameActivated(@NotNull final InternalFrameEvent e) {
            // ignore
        }
 
        @Override
        public void internalFrameClosed(@NotNull final InternalFrameEvent e) {
            // ignore
        }
 
        @Override
        public void internalFrameClosing(@NotNull final InternalFrameEvent e) {
            mapViewsManager.closeMapView(mapView);
        }
 
        @Override
        public void internalFrameDeactivated(@NotNull final InternalFrameEvent e) {
            // ignore
        }
 
        @Override
        public void internalFrameDeiconified(@NotNull final InternalFrameEvent e) {
            mapViewFocusGainedNotify(mapView);
        }
 
        @Override
        public void internalFrameIconified(@NotNull final InternalFrameEvent e) {
            mapViewFocusLostNotify(mapView);
        }
 
        @Override
        public void internalFrameOpened(@NotNull final InternalFrameEvent e) {
            // ignore
        }
 
    }
 
}