MainActions.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.mainactions;
 
import java.awt.Point;
import java.awt.Rectangle;
import java.util.ArrayList;
import java.util.Collection;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.swing.Action;
import javax.swing.JFrame;
import net.sf.gridarta.gui.copybuffer.CopyBuffer;
import net.sf.gridarta.gui.dialog.find.FindDialogManager;
import net.sf.gridarta.gui.dialog.replace.ReplaceDialogManager;
import net.sf.gridarta.gui.map.mapview.MapView;
import net.sf.gridarta.gui.map.mapview.MapViewManagerListener;
import net.sf.gridarta.gui.misc.ShiftProcessor;
import net.sf.gridarta.gui.panel.objectchooser.ObjectChooser;
import net.sf.gridarta.model.archetype.Archetype;
import net.sf.gridarta.model.archetypeset.ArchetypeSet;
import net.sf.gridarta.model.direction.Direction;
import net.sf.gridarta.model.floodfill.FillUtils;
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.mapgrid.MapGrid;
import net.sf.gridarta.model.mapgrid.MapGridEvent;
import net.sf.gridarta.model.mapgrid.MapGridListener;
import net.sf.gridarta.model.mapgrid.SelectionMode;
import net.sf.gridarta.model.mapmanager.MapManager;
import net.sf.gridarta.model.mapmanager.MapManagerListener;
import net.sf.gridarta.model.mapmodel.InsertionMode;
import net.sf.gridarta.model.mapmodel.InsertionModeSet;
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.MapSquare;
import net.sf.gridarta.model.mapviewsettings.MapViewSettings;
import net.sf.gridarta.model.select.ArchetypeNameMatchCriteria;
import net.sf.gridarta.model.select.MatchCriteria;
import net.sf.gridarta.model.select.ObjectNameMatchCriteria;
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.ActionMethod;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public class MainActions<G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> implements EditorAction, MapViewManagerListener<G, A, R> {
 
    @NotNull
    private final FindDialogManager<G, A, R> findDialogManager;
 
    @NotNull
    private final ReplaceDialogManager<G, A, R> replaceDialogManager;
 
    @NotNull
    private final JFrame parent;
 
    @NotNull
    private final MapViewSettings mapViewSettings;
 
    @NotNull
    private final CopyBuffer<G, A, R> copyBuffer;
 
    @NotNull
    private final ObjectChooser<G, A, R> objectChooser;
 
    @NotNull
    private final InsertionModeSet<G, A, R> insertionModeSet;
 
    @Nullable
    private Action aClear;
 
    @Nullable
    private Action aCut;
 
    @Nullable
    private Action aCopy;
 
    @Nullable
    private Action aShiftNorth;
 
    @Nullable
    private Action aShiftNorthEast;
 
    @Nullable
    private Action aShiftEast;
 
    @Nullable
    private Action aShiftSouthEast;
 
    @Nullable
    private Action aShiftSouth;
 
    @Nullable
    private Action aShiftSouthWest;
 
    @Nullable
    private Action aShiftWest;
 
    @Nullable
    private Action aShiftNorthWest;
 
    @Nullable
    private Action aPaste;
 
    @Nullable
    private Action aPasteTiled;
 
    @Nullable
    private Action aFind;
 
    @Nullable
    private Action aFindNext;
 
    @Nullable
    private Action aFindPrev;
 
    @Nullable
    private Action aReplace;
 
    @Nullable
    private Action aFillAuto;
 
    @Nullable
    private Action aFillAbove;
 
    @Nullable
    private Action aFillBelow;
 
    @Nullable
    private Action aRandFillAuto;
 
    @Nullable
    private Action aRandFillAbove;
 
    @Nullable
    private Action aRandFillBelow;
 
    @Nullable
    private Action aFloodFill;
 
    @Nullable
    private Action aMassChange;
 
    @Nullable
    private Action aSelectAll;
 
    @Nullable
    private Action aInvertSelection;
 
    @Nullable
    private Action aExpandEmptySelection;
 
    @Nullable
    private Action aTileStretchingSet;
 
    @Nullable
    private Action aTileStretchingClear;
 
    @Nullable
    private Action aTileStretchingIncrease;
 
    @Nullable
    private Action aTileStretchingDecrease;
 
    @NotNull
    private final RandomFillDialog randomFillDialog = new RandomFillDialog();
 
    @NotNull
    private final TileStretchingDialog tileStretchingDialog = new TileStretchingDialog();
 
    @NotNull
    private final MassChangeDialog massChangeDialog = new MassChangeDialog();
 
    @Nullable
    private MapControl<G, A, R> currentMapControl;
 
    @Nullable
    private MapView<G, A, R> currentMapView;
 
    @NotNull
    private final MapGridListener mapGridListener = new MapGridListener() {
 
        @Override
        public void mapGridChanged(@NotNull final MapGridEvent e) {
            refreshMenus(); // selection state may have changed
        }
 
        @Override
        public void mapGridResized(@NotNull final MapGridEvent e) {
            // ignore
        }
 
    };
 
    public MainActions(@NotNull final FindDialogManager<G, A, R> findDialogManager, @NotNull final ReplaceDialogManager<G, A, R> replaceDialogManager, @NotNull final JFrame parent, @NotNull final MapViewSettings mapViewSettings, @NotNull final ArchetypeSet<G, A, R> archetypeSet, @NotNull final CopyBuffer<G, A, R> copyBuffer, @NotNull final ObjectChooser<G, A, R> objectChooser, @NotNull final MapManager<G, A, R> mapManager, @NotNull final InsertionModeSet<G, A, R> insertionModeSet) {
        this.findDialogManager = findDialogManager;
        this.replaceDialogManager = replaceDialogManager;
        this.parent = parent;
        this.mapViewSettings = mapViewSettings;
        this.copyBuffer = copyBuffer;
        this.objectChooser = objectChooser;
        this.insertionModeSet = insertionModeSet;
 
        mapManager.addMapManagerListener(newMapManagerListener());
        currentMapControl = mapManager.getCurrentMap();
 
        archetypeSet.addArchetypeSetListener(this::refreshMenus);
        copyBuffer.addMapModelListener(newMapModelListener());
    }
 
    @NotNull
    private MapManagerListener<G, A, R> newMapManagerListener() {
        return new MapManagerListener<G, A, R>() {
 
            @Override
            public void currentMapChanged(@Nullable final MapControl<G, A, R> mapControl) {
                currentMapControl = mapControl;
                refreshMenus();
            }
 
            @Override
            public void mapCreated(@NotNull final MapControl<G, A, R> mapControl, final boolean interactive) {
                // ignore: a current map changed event will be generated
            }
 
            @Override
            public void mapClosing(@NotNull final MapControl<G, A, R> mapControl) {
                // ignore: a current map changed event will be generated
            }
 
            @Override
            public void mapClosed(@NotNull final MapControl<G, A, R> mapControl) {
                // ignore: a current map changed event will be generated
            }
 
        };
    }
 
    @NotNull
    private MapModelListener<G, A, R> newMapModelListener() {
        return 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) {
                refreshMenus();
            }
 
            @Override
            public void mapObjectsChanged(@NotNull final Set<G> gameObjects, @NotNull final Set<G> transientGameObjects) {
                // ignore
            }
 
            @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
            }
 
        };
    }
 
    private void refreshMenus() {
        if (aClear != null) {
            aClear.setEnabled(doClear(false));
        }
        if (aCut != null) {
            aCut.setEnabled(doCut(false));
        }
        if (aCopy != null) {
            aCopy.setEnabled(doCopy(false));
        }
        if (aPaste != null) {
            aPaste.setEnabled(doPaste(false));
        }
        if (aPasteTiled != null) {
            aPasteTiled.setEnabled(doPasteTiled(false));
        }
        if (aShiftNorth != null) {
            aShiftNorth.setEnabled(doShift(false, Direction.NORTH));
        }
        if (aShiftNorthEast != null) {
            aShiftNorthEast.setEnabled(doShift(false, Direction.NORTH_EAST));
        }
        if (aShiftEast != null) {
            aShiftEast.setEnabled(doShift(false, Direction.EAST));
        }
        if (aShiftSouthEast != null) {
            aShiftSouthEast.setEnabled(doShift(false, Direction.SOUTH_EAST));
        }
        if (aShiftSouth != null) {
            aShiftSouth.setEnabled(doShift(false, Direction.SOUTH));
        }
        if (aShiftSouthWest != null) {
            aShiftSouthWest.setEnabled(doShift(false, Direction.SOUTH_WEST));
        }
        if (aShiftWest != null) {
            aShiftWest.setEnabled(doShift(false, Direction.WEST));
        }
        if (aShiftNorthWest != null) {
            aShiftNorthWest.setEnabled(doShift(false, Direction.NORTH_WEST));
        }
        if (aFind != null) {
            aFind.setEnabled(doFind(false));
        }
        if (aFindNext != null) {
            aFindNext.setEnabled(doFindNext(false));
        }
        if (aFindPrev != null) {
            aFindPrev.setEnabled(doFindPrev(false));
        }
        if (aReplace != null) {
            aReplace.setEnabled(doReplace(false));
        }
        if (aFillAuto != null) {
            aFillAuto.setEnabled(doFillAuto(false));
        }
        if (aFillAbove != null) {
            aFillAbove.setEnabled(doFillAbove(false));
        }
        if (aFillBelow != null) {
            aFillBelow.setEnabled(doFillBelow(false));
        }
        if (aRandFillAuto != null) {
            aRandFillAuto.setEnabled(doRandFillAuto(false));
        }
        if (aRandFillAbove != null) {
            aRandFillAbove.setEnabled(doRandFillAbove(false));
        }
        if (aRandFillBelow != null) {
            aRandFillBelow.setEnabled(doRandFillBelow(false));
        }
        if (aFloodFill != null) {
            aFloodFill.setEnabled(doFloodFill(false));
        }
        if (aMassChange != null) {
            aMassChange.setEnabled(doMassChange(false));
        }
        if (aSelectAll != null) {
            aSelectAll.setEnabled(doSelectAll(false));
        }
        if (aInvertSelection != null) {
            aInvertSelection.setEnabled(doInvertSelection(false));
        }
        if (aExpandEmptySelection != null) {
            aExpandEmptySelection.setEnabled(doExpandEmptySelection(false));
        }
        if (aTileStretchingSet != null) {
            aTileStretchingSet.setEnabled(doTileStretchingChangeSet(false));
        }
        if (aTileStretchingClear != null) {
            aTileStretchingClear.setEnabled(doTileStretchingChange(false, 0, true));
        }
        if (aTileStretchingIncrease != null) {
            aTileStretchingIncrease.setEnabled(doTileStretchingChange(false, 1, false));
        }
        if (aTileStretchingDecrease != null) {
            aTileStretchingDecrease.setEnabled(doTileStretchingChange(false, -1, false));
        }
    }
 
    @ActionMethod
    public void clear() {
        doClear(true);
    }
 
    @ActionMethod
    public void cut() {
        doCut(true);
    }
 
    @ActionMethod
    public void copy() {
        doCopy(true);
    }
 
    @ActionMethod
    public void paste() {
        doPaste(true);
    }
 
    @ActionMethod
    public void pasteTiled() {
        doPasteTiled(true);
    }
 
    @ActionMethod
    public void shiftNorth() {
        doShift(true, Direction.NORTH);
    }
 
    @ActionMethod
    public void shiftNorthEast() {
        doShift(true, Direction.NORTH_EAST);
    }
 
    @ActionMethod
    public void shiftEast() {
        doShift(true, Direction.EAST);
    }
 
    @ActionMethod
    public void shiftSouthEast() {
        doShift(true, Direction.SOUTH_EAST);
    }
 
    @ActionMethod
    public void shiftSouth() {
        doShift(true, Direction.SOUTH);
    }
 
    @ActionMethod
    public void shiftSouthWest() {
        doShift(true, Direction.SOUTH_WEST);
    }
 
    @ActionMethod
    public void shiftWest() {
        doShift(true, Direction.WEST);
    }
 
    @ActionMethod
    public void shiftNorthWest() {
        doShift(true, Direction.NORTH_WEST);
    }
 
    @ActionMethod
    public void find() {
        doFind(true);
    }
 
    @ActionMethod
    public void findNext() {
        doFindNext(true);
    }
 
    @ActionMethod
    public void findPrev() {
        doFindPrev(true);
    }
 
    @ActionMethod
    public void replace() {
        doReplace(true);
    }
 
    @ActionMethod
    public void fillAuto() {
        doFillAuto(true);
    }
 
    @ActionMethod
    public void fillAbove() {
        doFillAbove(true);
    }
 
    @ActionMethod
    public void fillBelow() {
        doFillBelow(true);
    }
 
    @ActionMethod
    public void randFillAuto() {
        doRandFillAuto(true);
    }
 
    @ActionMethod
    public void randFillAbove() {
        doRandFillAbove(true);
    }
 
    @ActionMethod
    public void randFillBelow() {
        doRandFillBelow(true);
    }
 
    @ActionMethod
    public void floodFill() {
        doFloodFill(true);
    }
 
    @ActionMethod
    public void massChange() {
        doMassChange(true);
    }
 
    @ActionMethod
    public void selectAll() {
        doSelectAll(true);
    }
 
    @ActionMethod
    public void invertSelection() {
        doInvertSelection(true);
    }
 
    @ActionMethod
    public void expandEmptySelection() {
        doExpandEmptySelection(true);
    }
 
    @ActionMethod
    public void tileStretchingSet() {
        doTileStretchingChangeSet(true);
    }
 
    @ActionMethod
    public void tileStretchingClear() {
        doTileStretchingChange(true, 0, true);
    }
 
    @ActionMethod
    public void tileStretchingIncrease() {
        doTileStretchingChange(true, 1, false);
    }
 
    @ActionMethod
    public void tileStretchingDecrease() {
        doTileStretchingChange(true, -1, false);
    }
 
    @Nullable
    private MapView<G, A, R> getSelection() {
        return currentMapView != null && currentMapView.getMapGrid().getSelectedRec() != null ? currentMapView : null;
    }
 
    private boolean doFind(final boolean performAction) {
        final MapView<G, A, R> mapView = currentMapView;
        if (mapView == null) {
            return false;
        }
 
        if (performAction) {
            findDialogManager.showDialog(mapView);
        }
 
        return true;
    }
 
    private boolean doFindNext(final boolean performAction) {
        final MapView<G, A, R> mapView = currentMapView;
        return mapView != null && findDialogManager.findNext(mapView, performAction);
    }
 
    private boolean doFindPrev(final boolean performAction) {
        final MapView<G, A, R> mapView = currentMapView;
        return mapView != null && findDialogManager.findPrev(mapView, performAction);
    }
 
    private boolean doReplace(final boolean performAction) {
        final MapView<G, A, R> mapView = currentMapView;
        if (mapView == null) {
            return false;
        }
 
        if (performAction) {
            replaceDialogManager.showDialog(mapView);
        }
 
        return true;
    }
 
    private boolean doClear(final boolean performAction) {
        final MapView<G, A, R> mapView = currentMapView;
        if (mapView == null) {
            return false;
        }
 
        final Rectangle selectedRec = mapView.getMapGrid().getSelectedRec();
        if (selectedRec == null) {
            return false;
        }
 
        if (performAction) {
            copyBuffer.clear(mapView, selectedRec);
        }
 
        return true;
    }
 
    private boolean doCut(final boolean performAction) {
        final MapView<G, A, R> mapView = currentMapView;
        if (mapView == null) {
            return false;
        }
 
        final Rectangle selectedRec = mapView.getMapGrid().getSelectedRec();
        if (selectedRec == null) {
            return false;
        }
 
        if (performAction) {
            copyBuffer.cut(mapView, selectedRec);
        }
 
        return true;
    }
 
    private boolean doCopy(final boolean performAction) {
        final MapView<G, A, R> mapView = currentMapView;
        if (mapView == null) {
            return false;
        }
 
        final Rectangle selectedRec = mapView.getMapGrid().getSelectedRec();
        if (selectedRec == null) {
            return false;
        }
 
        if (performAction) {
            copyBuffer.copy(mapView, selectedRec);
        }
 
        return true;
    }
 
    private boolean doPaste(final boolean performAction) {
        final MapView<G, A, R> mapView = currentMapView;
        if (mapView == null) {
            return false;
        }
 
        final Point startLocation = mapView.getMapCursor().getLocation();
        if (copyBuffer.isEmpty()) {
            return false;
        }
 
        if (performAction) {
            copyBuffer.paste(mapView, startLocation);
        }
 
        return true;
    }
 
    private boolean doPasteTiled(final boolean performAction) {
        final MapView<G, A, R> mapView = currentMapView;
        if (mapView == null) {
            return false;
        }
 
        if (copyBuffer.isEmpty()) {
            return false;
        }
 
        final List<MapSquare<G, A, R>> selectedSquares = mapView.getSelectedSquares();
        if (selectedSquares.isEmpty()) {
            return false;
        }
 
        final MapGrid mapGrid = mapView.getMapGrid();
        final Rectangle selectedRec = mapGrid.getSelectedRec();
        if (selectedRec == null) {
            return false;
        }
 
        if (performAction) {
            final Point cursorLocation = mapView.getMapCursor().getLocation();
            copyBuffer.pasteTiled(mapView, selectedSquares, cursorLocation);
        }
 
        return true;
    }
 
    private boolean doShift(final boolean performAction, @NotNull final Direction direction) {
        final MapControl<G, A, R> mapControl = currentMapControl;
        if (mapControl == null) {
            return false;
        }
 
        final MapView<G, A, R> mapView = currentMapView;
        if (mapView == null) {
            return false;
        }
 
        final ShiftProcessor<G, A, R> shiftProcessor = new ShiftProcessor<>(mapViewSettings, mapView, mapControl.getMapModel(), insertionModeSet);
        if (!shiftProcessor.canShift(direction)) {
            return false;
        }
 
        if (performAction) {
            shiftProcessor.shift(direction);
        }
 
        return true;
    }
 
    private boolean doFillAuto(final boolean performAction) {
        final MapView<G, A, R> mapView = getSelection();
        if (mapView == null) {
            return false;
        }
 
        if (performAction) {
            fill(mapView, insertionModeSet.getAutoInsertionMode());
        }
 
        return true;
    }
 
    private boolean doFillAbove(final boolean performAction) {
        final MapView<G, A, R> mapView = getSelection();
        if (mapView == null) {
            return false;
        }
 
        if (performAction) {
            fill(mapView, insertionModeSet.getTopmostInsertionMode());
        }
 
        return true;
    }
 
    private boolean doFillBelow(final boolean performAction) {
        final MapView<G, A, R> mapView = getSelection();
        if (mapView == null) {
            return false;
        }
 
        if (performAction) {
            fill(mapView, insertionModeSet.getBottommostInsertionMode());
        }
 
        return true;
    }
 
    private boolean doRandFillAuto(final boolean performAction) {
        final MapView<G, A, R> mapView = getSelection();
        if (mapView == null) {
            return false;
        }
 
        if (performAction) {
            fillRandom(mapView, insertionModeSet.getAutoInsertionMode());
        }
 
        return true;
    }
 
    private boolean doRandFillAbove(final boolean performAction) {
        final MapView<G, A, R> mapView = getSelection();
        if (mapView == null) {
            return false;
        }
 
        if (performAction) {
            fillRandom(mapView, insertionModeSet.getTopmostInsertionMode());
        }
 
        return true;
    }
 
    private boolean doRandFillBelow(final boolean performAction) {
        final MapView<G, A, R> mapView = getSelection();
        if (mapView == null) {
            return false;
        }
 
        if (performAction) {
            fillRandom(mapView, insertionModeSet.getBottommostInsertionMode());
        }
 
        return true;
    }
 
    private boolean doFloodFill(final boolean performAction) {
        final MapView<G, A, R> mapView = currentMapView;
        if (mapView == null) {
            return false;
        }
 
        final Point mapCursorLocation = mapView.getMapCursor().getLocation();
        if (performAction) {
            FillUtils.floodFill(mapView.getMapControl().getMapModel(), mapCursorLocation, objectChooser.getSelections(), insertionModeSet);
        }
 
        return true;
    }
 
    private boolean doMassChange(final boolean performAction) {
        final MapView<G, A, R> mapView = getSelection();
        if (mapView == null) {
            return false;
        }
 
        if (performAction) {
            if (!massChangeDialog.showMassChangeDialog(parent)) {
                return false;
            }
 
            final String[] archNames = massChangeDialog.getArchNames();
            final String[] names = massChangeDialog.getNames();
            final Integer[] layers = massChangeDialog.getLayers();
            final Integer[] subLayers = massChangeDialog.getSubLayers();
            final String changes = massChangeDialog.getChanges();
 
            final Collection<MatchCriteria<G, A, R>> matchCriteriaArch = new ArrayList<>(archNames.length);
            for (final String archName : archNames) {
                matchCriteriaArch.add(new ArchetypeNameMatchCriteria<>(archName));
            }
 
            final Collection<MatchCriteria<G, A, R>> matchCriteriaName = new ArrayList<>(names.length);
            for (final String name : names) {
                matchCriteriaName.add(new ObjectNameMatchCriteria<>(name));
            }
 
            final MapModel<G, A, R> mapModel = mapView.getMapControl().getMapModel();
 
            mapModel.beginTransaction("Mass change"); // TODO; I18N/L10N
            try {
                for (final MapSquare<G, A, R> mapSquare : mapView.getSelectedSquares()) {
                    for (final GameObject<G, A, R> gameObject : mapSquare) {
                        boolean doModify = false;
 
                        if (matchCriteriaArch.isEmpty() && matchCriteriaName.isEmpty()) {
                            doModify = true;
                        }
 
                        for (final MatchCriteria<G, A, R> matchCriteria : matchCriteriaArch) {
                            if (matchCriteria.matches(gameObject.getHead())) {
                                doModify = true;
                                break;
                            }
                        }
 
                        for (final MatchCriteria<G, A, R> matchCriteria : matchCriteriaName) {
                            if (!matchCriteria.matches(gameObject.getHead())) {
                                doModify = true;
                                break;
                            }
                        }
 
                        if (!doModify) {
                            continue;
                        }
 
                        gameObject.applyMassChange(layers, subLayers, changes);
                    }
                }
            } finally {
                mapModel.endTransaction();
            }
        }
 
        return true;
    }
 
    private boolean doSelectAll(final boolean performAction) {
        if (currentMapView == null) {
            return false;
        }
 
        if (performAction) {
            currentMapView.getMapGrid().selectAll();
        }
 
        return true;
    }
 
    private boolean doInvertSelection(final boolean performAction) {
        if (currentMapView == null) {
            return false;
        }
 
        if (performAction) {
            currentMapView.getMapGrid().invertSelection();
        }
 
        return true;
    }
 
    private boolean doExpandEmptySelection(final boolean performAction) {
        final MapView<G, A, R> mapView = getSelection();
        if (mapView == null) {
            return false;
        }
 
        boolean foundEmptySelectedSquare = false;
        final List<MapSquare<G, A, R>> selectedSquares = mapView.getSelectedSquares();
        for (final MapSquare<G, A, R> selectedSquare : selectedSquares) {
            if (selectedSquare.isEmpty()) {
                foundEmptySelectedSquare = true;
                break;
            }
        }
        if (!foundEmptySelectedSquare) {
            return false;
        }
 
        if (performAction) {
            final Map<MapSquare<G, A, R>, Void> newSelection = new IdentityHashMap<>();
            Map<MapSquare<G, A, R>, Void> todo = new IdentityHashMap<>();
            for (final MapSquare<G, A, R> mapSquare : selectedSquares) {
                todo.put(mapSquare, null);
                newSelection.put(mapSquare, null);
            }
            final MapModel<G, A, R> mapModel = mapView.getMapControl().getMapModel();
            final MapArchObject<A> mapArchObject = mapModel.getMapArchObject();
            final Point point = new Point();
            while (!todo.isEmpty()) {
                final Map<MapSquare<G, A, R>, Void> tmp = new IdentityHashMap<>();
                for (final MapSquare<G, A, R> mapSquare : todo.keySet()) {
                    for (int dy = -1; dy <= 1; dy++) {
                        for (int dx = -1; dx <= 1; dx++) {
                            if (dx != 0 || dy != 0) {
                                mapSquare.getMapLocation(point, dx, dy);
                                if (mapArchObject.isPointValid(point)) {
                                    final MapSquare<G, A, R> newMapSquare = mapModel.getMapSquare(point);
                                    if (newMapSquare.isEmpty() && !newSelection.containsKey(newMapSquare)) {
                                        tmp.put(newMapSquare, null);
                                        newSelection.put(newMapSquare, null);
                                    }
                                }
                            }
                        }
                    }
                }
                todo = tmp;
            }
            final MapGrid mapGrid = mapView.getMapGrid();
            mapGrid.beginTransaction();
            try {
                mapGrid.unSelect();
                for (final MapSquare<G, A, R> mapSquare : newSelection.keySet()) {
                    mapSquare.getMapLocation(point);
                    mapGrid.select(point, SelectionMode.ADD);
                }
            } finally {
                mapGrid.endTransaction();
            }
        }
 
        return true;
    }
 
    private boolean doTileStretchingChangeSet(final boolean performAction) {
        final MapView<G, A, R> mapView = getSelection();
        if (mapView == null) {
            return false;
        }
 
        if (performAction) {
            if (!tileStretchingDialog.showTileStretchingDialog(parent)) {
                return false;
            }
 
            final int heightValue = tileStretchingDialog.getHeightValue();
            final Integer[] subLayers = tileStretchingDialog.getSubLayers();
            final boolean isAbsolute = tileStretchingDialog.isTileStretchingAbsolute();
            tileStretching(mapView, heightValue, isAbsolute, subLayers);
        }
 
        return true;
    }
 
    private boolean doTileStretchingChange(final boolean performAction, final int heightValue, final boolean isAbsolute) {
        final MapView<G, A, R> mapView = getSelection();
        if (mapView == null) {
            return false;
        }
 
        if (performAction) {
            tileStretching(mapView, heightValue, isAbsolute, null);
        }
 
        return true;
    }
 
    private void fill(@NotNull final MapView<G, A, R> mapView, @NotNull final InsertionMode insertionMode) {
        FillUtils.fill(mapView.getMapControl().getMapModel(), mapView.getSelectedSquares(), insertionMode, objectChooser.getSelections(), -1, false);
    }
 
    private void fillRandom(@NotNull final MapView<G, A, R> mapView, @NotNull final InsertionMode insertionMode) {
        if (!randomFillDialog.showRandomFillDialog(parent)) {
            return;
        }
 
        final int fillDensity = randomFillDialog.getFillDensity();
        final boolean noAdjacent = randomFillDialog.isRandomFillSkipAdjacentSquares();
        FillUtils.fill(mapView.getMapControl().getMapModel(), mapView.getSelectedSquares(), insertionMode, objectChooser.getSelections(), fillDensity, noAdjacent);
    }
 
    private void tileStretching(@NotNull final MapView<G, A, R> mapView, final int heightValue, final boolean isAbsolute, @NotNull final Integer @Nullable [] subLayers) {
        final MapModel<G, A, R> mapModel = mapView.getMapControl().getMapModel();
 
        mapModel.beginTransaction("Tile stretching"); // TODO; I18N/L10N
        try {
            for (final MapSquare<G, A, R> mapSquare : mapView.getSelectedSquares()) {
                for (final GameObject<G, A, R> gameObject : mapSquare) {
                    gameObject.updateTileStretch(heightValue, isAbsolute, subLayers);
                }
            }
        } finally {
            mapModel.endTransaction();
        }
    }
 
    @Override
    public void setAction(@NotNull final Action action, @NotNull final String name) {
        switch (name) {
        case "clear":
            aClear = action;
            break;
 
        case "cut":
            aCut = action;
            break;
 
        case "copy":
            aCopy = action;
            break;
 
        case "paste":
            aPaste = action;
            break;
 
        case "pasteTiled":
            aPasteTiled = action;
            break;
 
        case "shiftNorth":
            aShiftNorth = action;
            break;
 
        case "shiftNorthEast":
            aShiftNorthEast = action;
            break;
 
        case "shiftEast":
            aShiftEast = action;
            break;
 
        case "shiftSouthEast":
            aShiftSouthEast = action;
            break;
 
        case "shiftSouth":
            aShiftSouth = action;
            break;
 
        case "shiftSouthWest":
            aShiftSouthWest = action;
            break;
 
        case "shiftWest":
            aShiftWest = action;
            break;
 
        case "shiftNorthWest":
            aShiftNorthWest = action;
            break;
 
        case "find":
            aFind = action;
            break;
 
        case "findNext":
            aFindNext = action;
            break;
 
        case "findPrev":
            aFindPrev = action;
            break;
 
        case "replace":
            aReplace = action;
            break;
 
        case "fillAuto":
            aFillAuto = action;
            break;
 
        case "fillAbove":
            aFillAbove = action;
            break;
 
        case "fillBelow":
            aFillBelow = action;
            break;
 
        case "randFillAuto":
            aRandFillAuto = action;
            break;
 
        case "randFillAbove":
            aRandFillAbove = action;
            break;
 
        case "randFillBelow":
            aRandFillBelow = action;
            break;
 
        case "floodFill":
            aFloodFill = action;
            break;
 
        case "massChange":
            aMassChange = action;
            break;
 
        case "selectAll":
            aSelectAll = action;
            break;
 
        case "invertSelection":
            aInvertSelection = action;
            break;
 
        case "expandEmptySelection":
            aExpandEmptySelection = action;
            break;
 
        case "tileStretchingSet":
            aTileStretchingSet = action;
            break;
 
        case "tileStretchingClear":
            aTileStretchingClear = action;
            break;
 
        case "tileStretchingIncrease":
            aTileStretchingIncrease = action;
            break;
 
        case "tileStretchingDecrease":
            aTileStretchingDecrease = action;
            break;
 
        default:
            throw new IllegalArgumentException("unsupported action name: " + name);
        }
        refreshMenus();
    }
 
    @Override
    public void activeMapViewChanged(@Nullable final MapView<G, A, R> mapView) {
        currentMapView = mapView;
        refreshMenus();
    }
 
    @Override
    public void mapViewCreated(@NotNull final MapView<G, A, R> mapView) {
        mapView.getMapGrid().addMapGridListener(mapGridListener);
    }
 
    @Override
    public void mapViewClosing(@NotNull final MapView<G, A, R> mapView) {
        mapView.getMapGrid().removeMapGridListener(mapGridListener);
    }
 
}