ScriptEditUndoActions.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.textedit.scripteditor;
 
import java.util.HashMap;
import java.util.Map;
import javax.swing.Action;
import javax.swing.event.UndoableEditListener;
import javax.swing.text.Document;
import javax.swing.undo.CannotRedoException;
import javax.swing.undo.CannotUndoException;
import javax.swing.undo.UndoManager;
import javax.swing.undo.UndoableEdit;
import net.sf.gridarta.utils.ActionBuilderUtils;
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 ScriptEditUndoActions {
 
    @NotNull
    private static final ActionBuilder ACTION_BUILDER = ActionBuilderFactory.getInstance().getActionBuilder("net.sf.gridarta");
 
    @NotNull
    private final Action aUndo = ACTION_BUILDER.createAction(true, "scriptEditUndo", this);
 
    @NotNull
    private final Action aRedo = ACTION_BUILDER.createAction(true, "scriptEditRedo", this);
 
    @NotNull
    private final Map<Document, UndoManager> undo = new HashMap<>();
 
    @Nullable
    private Document currentDocument;
 
    @NotNull
    private final UndoableEditListener undoableEditListener = e -> {
        getUndoManager((Document) e.getSource()).addEdit(e.getEdit());
        refresh();
    };
 
    public void addDocument(@NotNull final Document document) {
        assert !undo.containsKey(document);
        document.addUndoableEditListener(undoableEditListener);
        undo.put(document, new UndoManager());
    }
 
    public void removeDocument(@NotNull final Document document) {
        assert undo.containsKey(document);
        undo.remove(document);
        document.removeUndoableEditListener(undoableEditListener);
        if (currentDocument == document) {
            setCurrentDocument(null);
        }
    }
 
    public void resetUndo(@NotNull final Document document) {
        getUndoManager(document).discardAllEdits();
    }
 
    @ActionMethod
    public void scriptEditUndo() {
        final UndoManager undoManager = getCurrentUndoManager();
        try {
            if (undoManager != null && undoManager.canUndo()) {
                undoManager.undo();
                refresh();
            }
        } catch (final CannotUndoException ignored) {
            // ignore
        }
    }
 
    @ActionMethod
    public void scriptEditRedo() {
        final UndoManager undoManager = getCurrentUndoManager();
        try {
            if (undoManager != null && undoManager.canRedo()) {
                undoManager.redo();
                refresh();
            }
        } catch (final CannotRedoException ignored) {
        }
    }
 
    private void refresh() {
        final UndoableEdit undoManager = getCurrentUndoManager();
 
        final boolean canUndo = undoManager != null && undoManager.canUndo();
        aUndo.setEnabled(canUndo);
        if (canUndo) {
            aUndo.putValue(Action.NAME, ACTION_BUILDER.format("scriptEditUndo.name", undoManager.getUndoPresentationName()));
        } else {
            aUndo.putValue(Action.NAME, ActionBuilderUtils.getString(ACTION_BUILDER, "scriptEditUndo.text"));
        }
 
        final boolean canRedo = undoManager != null && undoManager.canRedo();
        aRedo.setEnabled(canRedo);
        if (canRedo) {
            aRedo.putValue(Action.NAME, ACTION_BUILDER.format("scriptEditRedo.name", undoManager.getRedoPresentationName()));
        } else {
            aRedo.putValue(Action.NAME, ActionBuilderUtils.getString(ACTION_BUILDER, "scriptEditRedo.text"));
        }
    }
 
    public void setCurrentDocument(@Nullable final Document currentDocument) {
        if (this.currentDocument != currentDocument) {
            this.currentDocument = currentDocument;
            refresh();
        }
    }
 
    @NotNull
    private UndoManager getUndoManager(@NotNull final Document document) {
        final UndoManager result = undo.get(document);
        assert result != null;
        return result;
    }
 
    @Nullable
    private UndoManager getCurrentUndoManager() {
        return currentDocument == null ? null : getUndoManager(currentDocument);
    }
 
}