MapActions.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.map.mapactions;
 
import java.awt.Frame;
import java.awt.Point;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.Set;
import javax.swing.Action;
import javax.swing.filechooser.FileFilter;
import net.sf.gridarta.gui.dialog.mapproperties.MapPropertiesDialogFactory;
import net.sf.gridarta.gui.dialog.shrinkmapsize.ShrinkMapSizeDialogManager;
import net.sf.gridarta.gui.map.mapview.MapView;
import net.sf.gridarta.gui.map.mapview.MapViewManager;
import net.sf.gridarta.gui.map.mapview.MapViewManagerListener;
import net.sf.gridarta.gui.map.mapview.MapViewsManager;
import net.sf.gridarta.gui.panel.selectedsquare.SelectedSquareModel;
import net.sf.gridarta.model.archetype.Archetype;
import net.sf.gridarta.model.direction.Direction;
import net.sf.gridarta.model.exitconnector.ExitMatcher;
import net.sf.gridarta.model.gameobject.GameObject;
import net.sf.gridarta.model.maparchobject.MapArchObject;
import net.sf.gridarta.model.maparchobject.MapArchObjectListener;
import net.sf.gridarta.model.mapcontrol.MapControl;
import net.sf.gridarta.model.mapcursor.MapCursorListener;
import net.sf.gridarta.model.mapmanager.MapManager;
import net.sf.gridarta.model.mapmanager.MapManagerListener;
import net.sf.gridarta.model.mapmodel.FilterGameObjectIterator;
import net.sf.gridarta.model.mapmodel.MapFile;
import net.sf.gridarta.model.mapmodel.MapModel;
import net.sf.gridarta.model.mapmodel.MapModelListener;
import net.sf.gridarta.model.mapmodel.MapPathUtils;
import net.sf.gridarta.model.mapmodel.MapSquare;
import net.sf.gridarta.model.mapmodel.TopLevelGameObjectIterator;
import net.sf.gridarta.model.mapviewsettings.MapViewSettings;
import net.sf.gridarta.model.mapviewsettings.MapViewSettingsListener;
import net.sf.gridarta.model.settings.ProjectSettings;
import net.sf.gridarta.model.validation.ErrorCollector;
import net.sf.gridarta.utils.EditorAction;
import net.sf.gridarta.utils.Size2D;
import net.sf.japi.swing.action.ActionBuilder;
import net.sf.japi.swing.action.ActionBuilderFactory;
import net.sf.japi.swing.action.ActionMethod;
import net.sf.japi.swing.action.ToggleAction;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public class MapActions<G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> implements EditorAction, MapCursorListener<G, A, R>, MapViewManagerListener<G, A, R> {
 
    @NotNull
    private static final ActionBuilder ACTION_BUILDER = ActionBuilderFactory.getInstance().getActionBuilder("net.sf.gridarta");
 
    @NotNull
    private final String @NotNull [] directionsMap = { "North", "East", "South", "West", "NorthEast", "SouthEast", "SouthWest", "NorthWest", "Up", "Down" };
 
    @Nullable
    private ToggleAction aGridVisible;
 
    @Nullable
    private ToggleAction aSmoothing;
 
    @Nullable
    private ToggleAction aDoubleFaces;
 
    @Nullable
    private ToggleAction aTileShow;
 
    @Nullable
    private ToggleAction aTileStretching;
 
    @Nullable
    private Action aMapCreateView;
 
    @Nullable
    private Action aMapProperties;
 
    @Nullable
    private ToggleAction aAutoJoin;
 
    @Nullable
    private Action aShrinkMapSize;
 
    @Nullable
    private Action aEnterExit;
 
    @Nullable
    private Action aNextExit;
 
    @Nullable
    private Action aPrevExit;
 
    @Nullable
    private Action aDeleteUnknownObjects;
 
    @Nullable
    private final Action @NotNull [] aDirections = new Action[directionsMap.length];
 
    @Nullable
    private final Action @NotNull [] aCreateTiles = new Action[directionsMap.length];
 
    @NotNull
    private final Frame helpParent;
 
    @NotNull
    private final ExitMatcher<G, A, R> exitMatcher;
 
    @NotNull
    private final FileFilter mapFileFilter;
 
    @NotNull
    private final SelectedSquareModel<G, A, R> selectedSquareModel;
 
    @NotNull
    private final EnterMap<G, A, R> enterMap;
 
    @NotNull
    private final ShrinkMapSizeDialogManager<G, A, R> shrinkMapSizeDialogManager;
 
    private final boolean allowRandomMapParameters;
 
    @NotNull
    private final MapPropertiesDialogFactory<G, A, R> mapPropertiesDialogFactory;
 
    @NotNull
    private final MapViewSettings mapViewSettings;
 
    @NotNull
    private final MapViewsManager<G, A, R> mapViewsManager;
 
    @Nullable
    private MapView<G, A, R> currentMapView;
 
    @NotNull
    private final MapManager<G, A, R> mapManager;
 
    @NotNull
    private final ProjectSettings projectSettings;
 
    @NotNull
    private final MapViewSettingsListener mapViewSettingsListener = new MapViewSettingsListener() {
 
        @Override
        public void gridVisibleChanged(final boolean gridVisible) {
            updateActions();
        }
 
        @Override
        public void lightVisibleChanged(final boolean lightVisible) {
            updateActions();
        }
 
        @Override
        public void smoothingChanged(final boolean smoothing) {
            updateActions();
        }
 
        @Override
        public void tileStretchingChanged(final boolean tileStretchingChanged) {
            updateActions();
        }
 
        @Override
        public void doubleFacesChanged(final boolean doubleFaces) {
            updateActions();
        }
 
        @Override
        public void alphaTypeChanged(final int alphaType) {
            // ignore
        }
 
        @Override
        public void editTypeChanged(final int editType) {
            // ignore
        }
 
        @Override
        public void autojoinChanged(final boolean autojoin) {
            updateActions();
        }
 
    };
 
    @NotNull
    private final MapManagerListener<G, A, R> mapManagerListener = new MapManagerListener<G, A, R>() {
 
        @Override
        public void currentMapChanged(@Nullable final MapControl<G, A, R> mapControl) {
            updateActions();
        }
 
        @Override
        public void mapCreated(@NotNull final MapControl<G, A, R> mapControl, final boolean interactive) {
            // ignore
        }
 
        @Override
        public void mapClosing(@NotNull final MapControl<G, A, R> mapControl) {
            // ignore
        }
 
        @Override
        public void mapClosed(@NotNull final MapControl<G, A, R> mapControl) {
            // ignore
        }
 
    };
 
    @NotNull
    private final MapArchObjectListener mapArchObjectListener = new MapArchObjectListener() {
 
        @Override
        public void mapMetaChanged() {
            updateActions();
        }
 
        @Override
        public void mapSizeChanged(@NotNull final Size2D mapSize) {
            // ignore
        }
 
    };
 
    @NotNull
    private final MapModelListener<G, A, R> mapModelListener = new MapModelListener<G, A, R>() {
 
        @Override
        public void mapSizeChanged(@NotNull final Size2D newSize) {
            // ignore
        }
 
        @Override
        public void mapSquaresChanged(@NotNull final Set<MapSquare<G, A, R>> mapSquares) {
            // ignore
        }
 
        @Override
        public void mapObjectsChanged(@NotNull final Set<G> gameObjects, @NotNull final Set<G> transientGameObjects) {
            updateActions();
        }
 
        @Override
        public void errorsChanged(@NotNull final ErrorCollector<G, A, R> errors) {
            // ignore
        }
 
        @Override
        public void mapFileChanged(@Nullable final MapFile oldMapFile) {
            // ignore
        }
 
        @Override
        public void modifiedChanged() {
            // ignore
        }
 
    };
 
    public MapActions(@NotNull final Frame helpParent, @NotNull final MapManager<G, A, R> mapManager, @NotNull final MapViewManager<G, A, R> mapViewManager, @NotNull final ExitMatcher<G, A, R> exitMatcher, @NotNull final FileFilter mapFileFilter, @NotNull final SelectedSquareModel<G, A, R> selectedSquareModel, final boolean allowRandomMapParameters, @NotNull final MapPropertiesDialogFactory<G, A, R> mapPropertiesDialogFactory, @NotNull final MapViewSettings mapViewSettings, @NotNull final MapViewsManager<G, A, R> mapViewsManager, @NotNull final EnterMap<G, A, R> enterMap, @NotNull final ProjectSettings projectSettings) {
        this.helpParent = helpParent;
        this.exitMatcher = exitMatcher;
        this.mapFileFilter = mapFileFilter;
        this.selectedSquareModel = selectedSquareModel;
        this.enterMap = enterMap;
        this.allowRandomMapParameters = allowRandomMapParameters;
        this.mapPropertiesDialogFactory = mapPropertiesDialogFactory;
        this.mapViewSettings = mapViewSettings;
        this.mapViewsManager = mapViewsManager;
        this.mapManager = mapManager;
        this.projectSettings = projectSettings;
        shrinkMapSizeDialogManager = new ShrinkMapSizeDialogManager<>(mapViewManager);
        mapViewSettings.addMapViewSettingsListener(mapViewSettingsListener);
        mapManager.addMapManagerListener(mapManagerListener);
    }
 
    @ActionMethod
    public boolean isGridVisible() {
        return doGridVisible(false, false) && mapViewSettings.isGridVisible();
    }
 
    @ActionMethod
    public void setGridVisible(final boolean gridVisible) {
        doGridVisible(true, gridVisible);
    }
 
    @ActionMethod
    public boolean isSmoothing() {
        return doSmoothing(false, false) && mapViewSettings.isSmoothing();
    }
 
    @ActionMethod
    public void setSmoothing(final boolean smoothing) {
        doSmoothing(true, smoothing);
    }
 
    @ActionMethod
    public boolean isDoubleFaces() {
        return doDoubleFaces(false, false) && mapViewSettings.isDoubleFaces();
    }
 
    @ActionMethod
    public void setDoubleFaces(final boolean doubleFaces) {
        doDoubleFaces(true, doubleFaces);
    }
 
    @ActionMethod
    public boolean isTileShow() {
        return /*doTileShow(false, false) && */false; // XXX: not yet implemented
    }
 
    @ActionMethod
    public boolean isTileStretching() {
        return doTileStretching(false, false) && mapViewSettings.isTileStretching();
    }
 
    @ActionMethod
    public void setTileStretching(final boolean tileStretching) {
        doTileStretching(true, tileStretching);
    }
 
    @ActionMethod
    public void setTileShow(final boolean tileShow) {
        doTileShow(true, tileShow);
    }
 
    @ActionMethod
    public void mapCreateView() {
        doMapCreateView(true);
    }
 
    @ActionMethod
    public void mapProperties() {
        doMapProperties(true);
    }
 
    @ActionMethod
    public void shrinkMapSize() {
        doShrinkMapSize(true);
    }
 
    @ActionMethod
    public boolean isAutoJoin() {
        return doAutoJoin(false, false) && mapViewSettings.isAutojoin();
    }
 
    @ActionMethod
    public void setAutoJoin(final boolean autoJoin) {
        doAutoJoin(true, autoJoin);
    }
 
    @ActionMethod
    public void enterExit() {
        doEnterExit(true);
    }
 
    @ActionMethod
    public void nextExit() {
        doNextExit(true);
    }
 
    @ActionMethod
    public void prevExit() {
        doPrevExit(true);
    }
 
    private void selectExit(@NotNull final MapView<G, A, R> mapView, final int direction) {
        final TopLevelGameObjectIterator<G, A, R> gameObjectIterator = new TopLevelGameObjectIterator<>(mapView.getMapControl().getMapModel(), mapView.getMapCursor().getLocation(), direction, true);
        final Iterator<G> exitIterator = new FilterGameObjectIterator<>(gameObjectIterator, exitMatcher);
        if (exitIterator.hasNext()) {
            mapView.setCursorLocation(exitIterator.next().getMapSquare().getMapLocation());
        }
    }
 
    @ActionMethod
    public void enterNorthMap() {
        doEnterMap(true, Direction.NORTH);
    }
 
    @ActionMethod
    public void enterNorthEastMap() {
        doEnterMap(true, Direction.NORTH_EAST);
    }
 
    @ActionMethod
    public void enterEastMap() {
        doEnterMap(true, Direction.EAST);
    }
 
    @ActionMethod
    public void enterSouthEastMap() {
        doEnterMap(true, Direction.SOUTH_EAST);
    }
 
    @ActionMethod
    public void enterSouthMap() {
        doEnterMap(true, Direction.SOUTH);
    }
 
    @ActionMethod
    public void enterSouthWestMap() {
        doEnterMap(true, Direction.SOUTH_WEST);
    }
 
    @ActionMethod
    public void enterWestMap() {
        doEnterMap(true, Direction.WEST);
    }
 
    @ActionMethod
    public void enterNorthWestMap() {
        doEnterMap(true, Direction.NORTH_WEST);
    }
 
    @ActionMethod
    public void enterUpMap() {
        doEnterMap(true, Direction.UP);
    }
 
    @ActionMethod
    public void enterDownMap() {
        doEnterMap(true, Direction.DOWN);
    }
 
    @ActionMethod
    public void createTileNorth() {
        doCreateTile(true, Direction.NORTH);
    }
 
    @ActionMethod
    public void createTileEast() {
        doCreateTile(true, Direction.EAST);
    }
 
    @ActionMethod
    public void createTileSouth() {
        doCreateTile(true, Direction.SOUTH);
    }
 
    @ActionMethod
    public void createTileWest() {
        doCreateTile(true, Direction.WEST);
    }
 
    @ActionMethod
    public void createTileNorthEast() {
        doCreateTile(true, Direction.NORTH_EAST);
    }
 
    @ActionMethod
    public void createTileSouthEast() {
        doCreateTile(true, Direction.SOUTH_EAST);
    }
 
    @ActionMethod
    public void createTileSouthWest() {
        doCreateTile(true, Direction.SOUTH_WEST);
    }
 
    @ActionMethod
    public void createTileNorthWest() {
        doCreateTile(true, Direction.NORTH_WEST);
    }
 
    @ActionMethod
    public void createTileUp() {
        doCreateTile(true, Direction.UP);
    }
 
    @ActionMethod
    public void createTileDown() {
        doCreateTile(true, Direction.DOWN);
    }
 
    @ActionMethod
    public void deleteUnknownObjects() {
        doDeleteUnknownObjects(true);
    }
 
    public void enterMap(@NotNull final MapFile mapFile, @Nullable final Point destinationPoint) {
        enterMap.enterMap(currentMapView, mapFile, destinationPoint, Direction.NORTH);
    }
 
    private void updateActions() {
        if (aGridVisible != null) {
            aGridVisible.setEnabled(doGridVisible(false, false));
            aGridVisible.setSelected(isGridVisible());
        }
        if (aSmoothing != null) {
            aSmoothing.setEnabled(doSmoothing(false, false));
            aSmoothing.setSelected(isSmoothing());
        }
        if (aDoubleFaces != null) {
            aDoubleFaces.setEnabled(doDoubleFaces(false, false));
            aDoubleFaces.setSelected(isDoubleFaces());
        }
        if (aTileShow != null) {
            aTileShow.setEnabled(doTileShow(false, false));
            aTileShow.setSelected(isTileShow());
        }
        if (aTileStretching != null) {
            aTileStretching.setEnabled(doTileStretching(false, false));
            aTileStretching.setSelected(isTileStretching());
        }
        if (aMapCreateView != null) {
            aMapCreateView.setEnabled(doMapCreateView(false));
        }
        if (aMapProperties != null) {
            aMapProperties.setEnabled(doMapProperties(false));
        }
        if (aAutoJoin != null) {
            aAutoJoin.setEnabled(doAutoJoin(false, false));
            aAutoJoin.setSelected(isAutoJoin());
        }
        if (aEnterExit != null) {
            aEnterExit.setEnabled(doEnterExit(false));
        }
        if (aNextExit != null) {
            aNextExit.setEnabled(doNextExit(false));
        }
        if (aPrevExit != null) {
            aPrevExit.setEnabled(doPrevExit(false));
        }
        if (aDeleteUnknownObjects != null) {
            aDeleteUnknownObjects.setEnabled(doDeleteUnknownObjects(false));
        }
        for (final Direction direction : Direction.values()) {
            if (aDirections[direction.ordinal()] != null) {
                aDirections[direction.ordinal()].setEnabled(doEnterMap(false, direction));
            }
        }
        for (final Direction direction : Direction.values()) {
            if (aCreateTiles[direction.ordinal()] != null) {
                aCreateTiles[direction.ordinal()].setEnabled(doCreateTile(false, direction));
            }
        }
        if (aShrinkMapSize != null) {
            aShrinkMapSize.setEnabled(doShrinkMapSize(false));
        }
    }
 
    private boolean doGridVisible(final boolean performAction, final boolean gridVisible) {
        if (performAction) {
            mapViewSettings.setGridVisible(gridVisible);
        }
 
        return true;
    }
 
    private boolean doSmoothing(final boolean performAction, final boolean smoothing) {
        if (performAction) {
            mapViewSettings.setSmoothing(smoothing);
        }
 
        return true;
    }
 
    private boolean doTileStretching(final boolean performAction, final boolean tileStretching) {
        if (performAction) {
            mapViewSettings.setTileStretching(tileStretching);
        }
 
        return true;
    }
 
    private boolean doDoubleFaces(final boolean performAction, final boolean doubleFaces) {
        if (performAction) {
            mapViewSettings.setDoubleFaces(doubleFaces);
        }
 
        return true;
    }
 
    private boolean doTileShow(final boolean performAction, final boolean tileShow) {
        return false; // XXX: not yet implemented
    }
 
    private boolean doMapCreateView(final boolean performAction) {
        final MapView<G, A, R> mapView = currentMapView;
        if (mapView == null) {
            return false;
        }
 
        if (performAction) {
            mapViewsManager.newMapView(mapView.getMapControl(), mapView.getScrollPane().getViewport().getViewPosition());
        }
 
        return true;
    }
 
    private boolean doMapProperties(final boolean performAction) {
        final MapView<G, A, R> mapView = currentMapView;
        if (mapView == null) {
            return false;
        }
 
        if (performAction) {
            mapPropertiesDialogFactory.showDialog(mapView.getComponent(), helpParent, mapView.getMapControl().getMapModel(), mapFileFilter);
        }
 
        return true;
    }
 
    private boolean doAutoJoin(final boolean performAction, final boolean autoJoin) {
        if (performAction) {
            mapViewSettings.setAutojoin(autoJoin);
        }
 
        return true;
    }
 
    private boolean doEnterExit(final boolean performAction) {
        final MapView<G, A, R> mapView = currentMapView;
        if (mapView == null) {
            return false;
        }
 
        final GameObject<G, A, R> exit;
        final GameObject<G, A, R> selectedExit = exitMatcher.getValidExit(selectedSquareModel.getSelectedGameObject());
        if (selectedExit == null) {
            final GameObject<G, A, R> cursorExit = exitMatcher.getValidExit(mapView.getMapControl().getMapModel(), mapView.getMapCursor().getLocation());
            if (cursorExit == null) {
                return false;
            }
 
            exit = cursorExit;
        } else {
            exit = selectedExit;
        }
 
        if (performAction) {
            if (!enterMap.enterExit(mapView, exit, allowRandomMapParameters)) {
                return false;
            }
        }
 
        return true;
    }
 
    private boolean doNextExit(final boolean performAction) {
        final MapView<G, A, R> mapView = currentMapView;
        if (mapView == null) {
            return false;
        }
 
        if (performAction) {
            selectExit(mapView, 1);
        }
 
        return true;
    }
 
    private boolean doPrevExit(final boolean performAction) {
        final MapView<G, A, R> mapView = currentMapView;
        if (mapView == null) {
            return false;
        }
 
        if (performAction) {
            selectExit(mapView, -1);
        }
 
        return true;
    }
 
    private boolean doDeleteUnknownObjects(final boolean performAction) {
        final MapView<G, A, R> mapView = currentMapView;
        if (mapView == null) {
            return false;
        }
 
        if (performAction) {
            final MapControl<G, A, R> mapControl = mapView.getMapControl();
            final MapModel<G, A, R> mapModel = mapControl.getMapModel();
            final Collection<G> gameObjectsToDelete = new ArrayList<>();
            for (final Iterable<G> mapSquare : mapModel) {
                for (final G gameObject : mapSquare) {
                    if (gameObject.isHead() && gameObject.hasUndefinedArchetype()) {
                        gameObjectsToDelete.add(gameObject);
                    }
                }
            }
            if (!gameObjectsToDelete.isEmpty()) {
                mapModel.beginTransaction("delete undefined objects");
                try {
                    for (final G gameObject : gameObjectsToDelete) {
                        mapModel.removeGameObject(gameObject, false);
                    }
                } finally {
                    mapModel.endTransaction();
                }
            }
        }
 
        return true;
    }
 
    public boolean doEnterMap(final boolean performAction, @NotNull final Direction direction) {
        final MapView<G, A, R> mapView = currentMapView;
        if (mapView == null) {
            return false;
        }
 
        final String path = mapView.getMapControl().getMapModel().getMapArchObject().getTilePath(direction);
        if (path.isEmpty()) {
            return false;
        }
 
        if (performAction) {
            if (!enterMap.enterMap(mapView, MapPathUtils.newMapPath(path), direction, null)) {
                return false;
            }
        }
 
        return true;
    }
 
    private boolean doCreateTile(final boolean performAction, @NotNull final Direction direction) {
        final MapView<G, A, R> mapView = currentMapView;
        if (mapView == null) {
            return false;
        }
 
        final MapModel<G, A, R> currentMapModel = mapView.getMapControl().getMapModel();
        final A currentMapArchObj = currentMapModel.getMapArchObject();
        final String path = currentMapArchObj.getTilePath(direction);
        if (!path.isEmpty()) {
            return false;
        }
 
        if (currentMapModel.getMapFile() == null) {
            return false;
        }
 
        final String newPath = currentMapArchObj.calculateTilePath(direction, currentMapModel.getMapFile());
        final MapFile mapFile = new MapFile(currentMapModel.getMapFile(), MapPathUtils.newMapPath(newPath));
 
        if (mapFile.getFile().isDirectory()) {
            return false;
        }
        if (mapFile.getFile().exists()) {
            return false;
        }
 
        if (performAction) {
            final File dir = mapFile.getFile().getParentFile();
            if (!dir.exists()) {
                if (!dir.mkdirs()) {
                    ACTION_BUILDER.showMessageDialog(mapView.getComponent(), "createTileErrorMakeDirectories", dir.toString());
                    return false;
                }
            }
 
            final A mapArchObject = currentMapArchObj.createClone();
 
            // Avoid cloning tile paths, as they will be incorrect anyway. In
            // Atrinik, automatic tile linking will take care of this issue.
            for (final Direction direction2 : Direction.values()) {
                mapArchObject.setTilePath(direction2, "");
            }
 
            final MapControl<G, A, R> mapControl = mapManager.newMap(null, mapArchObject, mapFile, true);
            try {
                mapControl.save();
            } catch (final IOException ex) {
                return false;
            } finally {
                mapManager.release(mapControl);
            }
 
            currentMapArchObj.calculateTilePaths(currentMapModel.getMapFile(), projectSettings.getMapsDirectory());
            doEnterMap(true, direction);
        }
 
        return true;
    }
 
    private boolean doShrinkMapSize(final boolean performAction) {
        final MapView<G, A, R> mapView = currentMapView;
        if (mapView == null) {
            return false;
        }
 
        if (performAction) {
            shrinkMapSizeDialogManager.showDialog(mapView);
        }
 
        return true;
    }
 
    @Override
    public void setAction(@NotNull final Action action, @NotNull final String name) {
        switch (name) {
        case "mapCreateView":
            aMapCreateView = action;
            break;
 
        case "mapProperties":
            aMapProperties = action;
            break;
 
        case "autoJoin":
            aAutoJoin = (ToggleAction) action;
            break;
 
        case "shrinkMapSize":
            aShrinkMapSize = action;
            break;
 
        case "enterExit":
            aEnterExit = action;
            break;
 
        case "nextExit":
            aNextExit = action;
            break;
 
        case "prevExit":
            aPrevExit = action;
            break;
 
        case "deleteUnknownObjects":
            aDeleteUnknownObjects = action;
            break;
 
        case "gridVisible":
            aGridVisible = (ToggleAction) action;
            break;
 
        case "smoothing":
            aSmoothing = (ToggleAction) action;
            break;
 
        case "doubleFaces":
            aDoubleFaces = (ToggleAction) action;
            break;
 
        case "tileShow":
            aTileShow = (ToggleAction) action;
            break;
 
        case "tileStretching":
            aTileStretching = (ToggleAction) action;
            break;
 
        default:
            int i;
            for (i = 0; i < directionsMap.length; i++) {
                if (name.equals("enter" + directionsMap[i] + "Map")) {
                    aDirections[i] = action;
                    break;
                }
 
                if (name.equals("createTile" + directionsMap[i])) {
                    aCreateTiles[i] = action;
                    break;
                }
            }
            if (i >= directionsMap.length) {
                throw new IllegalArgumentException("unsupported action name: " + name);
            }
            break;
        }
        updateActions();
    }
 
    @Override
    public void activeMapViewChanged(@Nullable final MapView<G, A, R> mapView) {
        if (currentMapView != null) {
            currentMapView.getMapControl().getMapModel().getMapArchObject().removeMapArchObjectListener(mapArchObjectListener);
            currentMapView.getMapControl().getMapModel().removeMapModelListener(mapModelListener);
        }
        currentMapView = mapView;
        if (currentMapView != null) {
            currentMapView.getMapControl().getMapModel().getMapArchObject().addMapArchObjectListener(mapArchObjectListener);
            currentMapView.getMapControl().getMapModel().addMapModelListener(mapModelListener);
        }
        updateActions();
    }
 
    @Override
    public void mapViewCreated(@NotNull final MapView<G, A, R> mapView) {
        // ignore
    }
 
    @Override
    public void mapViewClosing(@NotNull final MapView<G, A, R> mapView) {
        // ignore
    }
 
    @Override
    public void mapCursorChangedPos(@NotNull final Point location) {
        updateActions();
    }
 
    @Override
    public void mapCursorChangedMode() {
        // ignore
    }
 
    @Override
    public void mapCursorChangedGameObject(@Nullable final MapSquare<G, A, R> mapSquare, @Nullable final G gameObject) {
        // ignore
    }
 
    @Override
    public void mapCursorChangedSize() {
        // ignore
    }
 
}