UndoControl.java

Go to the documentation of this file.

/*
 * Gridarta MMORPG map editor for Crossfire, Daimonin and similar games.
 * Copyright (C) 2000-2015 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.undo;

import java.util.IdentityHashMap;
import java.util.Map;
import javax.swing.Action;
import net.sf.gridarta.actions.UndoActions;
import net.sf.gridarta.model.archetype.Archetype;
import net.sf.gridarta.model.gameobject.GameObject;
import net.sf.gridarta.model.gameobject.GameObjectFactory;
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.model.mapmodel.MapModel;
import net.sf.gridarta.model.mapmodel.MapTransactionListener;
import net.sf.gridarta.model.mapmodel.SavedSquares;
import net.sf.gridarta.model.match.GameObjectMatchers;
import net.sf.gridarta.model.undo.UndoModel;
import net.sf.gridarta.model.undo.UndoState;
import net.sf.gridarta.utils.ActionBuilderUtils;
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.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

public class UndoControl<G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> implements EditorAction {

    @NotNull
    private static final ActionBuilder ACTION_BUILDER = ActionBuilderFactory.getInstance().getActionBuilder("net.sf.gridarta");

    @NotNull
    private final Map<MapModel<G, A, R>, UndoModel<G, A, R>> undoModels = new IdentityHashMap<>();

    @Nullable
    private MapModel<G, A, R> mapModel;

    private int maxUndoStates = 100;

    @Nullable
    private Action aUndo;

    @Nullable
    private Action aRedo;

    public UndoControl(@NotNull final MapManager<G, A, R> mapManager, @NotNull final GameObjectFactory<G, A, R> gameObjectFactory, @NotNull final GameObjectMatchers gameObjectMatchers) {
        final MapManagerListener<G, A, R> mapManagerListener = new MapManagerListener<G, A, R>() {

            @Override
            public void currentMapChanged(@Nullable final MapControl<G, A, R> mapControl) {
                mapModel = mapControl == null ? null : mapControl.getMapModel();
                refreshMenus();
            }

            @Override
            public void mapCreated(@NotNull final MapControl<G, A, R> mapControl, final boolean interactive) {
                final MapModel<G, A, R> mapModel = mapControl.getMapModel();
                final MapTransactionListener<G, A, R> mapTransactionListener = new MapTransactionListener<G, A, R>() {

                    @Nullable
                    private UndoState<G, A, R> undoState;

                    @Nullable
                    private UndoModel<G, A, R> undoModel;

                    @Override
                    public void preBeginTransaction() {
                        // ignore
                    }

                    @Override
                    public void beginTransaction(@NotNull final String name) {
                        undoModel = undoModels.get(mapModel);
                        undoState = new UndoState<>(name, mapModel.getMapArchObject().createClone());
                    }

                    @Override
                    public void endTransaction(@NotNull final SavedSquares<G, A, R> savedSquares) {
                        final UndoState<G, A, R> savedUndoState = undoState;
                        assert savedUndoState != null;
                        final UndoModel<G, A, R> savedUndoModel = undoModel;
                        assert savedUndoModel != null;
                        if (savedSquares.isEmpty() && savedUndoState.getMapArchObject().equals(mapModel.getMapArchObject())) {
                            return;
                        }

                        final SavedSquares<G, A, R> clonedSavedSquares = savedSquares.cloneAndClear();
                        clonedSavedSquares.removeEmptySquares(savedUndoState.getMapArchObject().getMapSize());
                        savedUndoState.setSavedSquares(clonedSavedSquares);
                        savedUndoModel.finish(savedUndoState);
                        if (maxUndoStates > 0) {
                            savedUndoModel.trimToSize(maxUndoStates);
                        }

                        refreshMenus();
                    }

                    @Override
                    public void postEndTransaction() {
                        // ignore
                    }

                };

                mapModel.addMapTransactionListener(mapTransactionListener);
                undoModels.put(mapModel, new UndoModel<>(gameObjectFactory, gameObjectMatchers, mapTransactionListener));
            }

            @Override
            public void mapClosing(@NotNull final MapControl<G, A, R> mapControl) {
                // ignore
            }

            @Override
            public void mapClosed(@NotNull final MapControl<G, A, R> mapControl) {
                final UndoModel<G, A, R> undoModel = undoModels.remove(mapControl.getMapModel());
                assert undoModel != null;
                mapControl.getMapModel().removeMapTransactionListener(undoModel.getMapTransactionListener());
            }

        };
        mapManager.addMapManagerListener(mapManagerListener);

        refreshMenus();
    }

    private void refreshMenus() {
        if (aUndo != null) {
            final boolean undoEnabled = doUndo(false);
            //noinspection ConstantConditions
            aUndo.setEnabled(undoEnabled);
            if (undoEnabled) {
                final UndoModel<G, A, R> undoModel = undoModels.get(mapModel);
                assert undoModel != null;
                //noinspection ConstantConditions
                aUndo.putValue(Action.NAME, ACTION_BUILDER.format("undo.name", undoModel.undoName()));
            } else {
                //noinspection ConstantConditions
                aUndo.putValue(Action.NAME, ActionBuilderUtils.getString(ACTION_BUILDER, "undo.text"));
            }
        }

        if (aRedo != null) {
            final boolean redoEnabled = doRedo(false);
            //noinspection ConstantConditions
            aRedo.setEnabled(redoEnabled);
            if (redoEnabled) {
                final UndoModel<G, A, R> redoModel = undoModels.get(mapModel);
                assert redoModel != null;
                //noinspection ConstantConditions
                aRedo.putValue(Action.NAME, ACTION_BUILDER.format("redo.name", redoModel.redoName()));
            } else {
                //noinspection ConstantConditions
                aRedo.putValue(Action.NAME, ActionBuilderUtils.getString(ACTION_BUILDER, "redo.text"));
            }
        }
    }

    @ActionMethod
    public void undo() {
        doUndo(true);
    }

    @ActionMethod
    public void redo() {
        doRedo(true);
    }

    public int getMaxUndoStates() {
        return maxUndoStates;
    }

    public void setMaxUndoStates(final int maxUndoStates) {
        this.maxUndoStates = maxUndoStates;

        if (maxUndoStates > 0) {
            for (final UndoModel<G, A, R> undoModel : undoModels.values()) {
                undoModel.trimToSize(maxUndoStates);
            }
        }
    }

    private boolean doUndo(final boolean performAction) {
        final MapModel<G, A, R> tmpMapModel = mapModel;
        if (tmpMapModel == null) {
            return false;
        }

        final UndoModel<G, A, R> undoModel = undoModels.get(tmpMapModel);
        if (undoModel == null) {
            // XXX: should be "assert undoModel != null"; this does not work
            // because MapViewManager.activateMapView() calls
            // mainControl.setCurrentLevel() which then generates a
            // currentMapChanged() event before a mapCreated() event
            return false;
        }

        if (!undoModel.canUndo()) {
            return false;
        }

        if (performAction) {
            UndoActions.undo(undoModel, tmpMapModel);
            refreshMenus();
        }

        return true;
    }

    private boolean doRedo(final boolean performAction) {
        final MapModel<G, A, R> tmpMapModel = mapModel;
        if (tmpMapModel == null) {
            return false;
        }

        final UndoModel<G, A, R> undoModel = undoModels.get(tmpMapModel);
        if (undoModel == null) {
            // XXX: should be "assert undoModel != null"; this does not work
            // because MapViewManager.activateMapView() calls
            // mainControl.setCurrentLevel() which then generates a
            // currentMapChanged() event before a mapCreated() event
            return false;
        }

        if (!undoModel.canRedo()) {
            return false;
        }

        if (performAction) {
            UndoActions.redo(undoModel, tmpMapModel);
            refreshMenus();
        }

        return true;
    }

    @Override
    public void setAction(@NotNull final Action action, @NotNull final String name) {
        if (name.equals("undo")) {
            aUndo = action;
        } else if (name.equals("redo")) {
            aRedo = action;
        } else {
            throw new IllegalArgumentException();
        }
    }

}