MapMenu.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.mapmenu;
 
import java.io.IOException;
import java.util.ArrayDeque;
import java.util.Deque;
import javax.swing.JTree;
import javax.swing.event.TreeModelEvent;
import javax.swing.event.TreeModelListener;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.MutableTreeNode;
import javax.swing.tree.TreeNode;
import javax.swing.tree.TreePath;
import net.sf.gridarta.gui.mapmenu.MapMenuLoader.Result;
import net.sf.gridarta.gui.mapmenu.MapMenuLoader.Type;
import net.sf.gridarta.model.io.PathManager;
import net.sf.gridarta.utils.StringUtils;
import org.apache.log4j.Category;
import org.apache.log4j.Logger;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public class MapMenu {
 
    @NotNull
    private static final Category LOG = Logger.getLogger(MapMenu.class);
 
    @NotNull
    private final MapMenuLoader mapMenuLoader;
 
    @NotNull
    private final DefaultMutableTreeNode root = new DefaultMutableTreeNode(new MapMenuEntryDir("Bookmarks"), true);
 
    @NotNull
    private final DefaultTreeModel treeModel = new DefaultTreeModel(root);
 
    @NotNull
    private final Deque<DeletedNode> deletedNodes = new ArrayDeque<>();
 
    private boolean treeModelModified;
 
    @NotNull
    private final TreeModelListener treeModelListener = new TreeModelListener() {
 
        @Override
        public void treeNodesChanged(final TreeModelEvent e) {
            treeModelModified = true;
        }
 
        @Override
        public void treeNodesInserted(final TreeModelEvent e) {
            treeModelModified = true;
        }
 
        @Override
        public void treeNodesRemoved(final TreeModelEvent e) {
            treeModelModified = true;
        }
 
        @Override
        public void treeStructureChanged(final TreeModelEvent e) {
            treeModelModified = true;
        }
 
    };
 
    public MapMenu(@NotNull final String key, @NotNull final PathManager pathManager) {
        if (LOG.isDebugEnabled()) {
            //noinspection ThisEscapedInObjectConstruction
            LOG.debug(System.identityHashCode(this) + " new " + key);
        }
        mapMenuLoader = new MapMenuLoader(key, pathManager);
        treeModel.addTreeModelListener(treeModelListener);
    }
 
    public void load() {
        final int num = mapMenuLoader.loadNumEntries();
        if (LOG.isDebugEnabled()) {
            LOG.debug(System.identityHashCode(this) + " load: root.removeAllChildren");
        }
        root.removeAllChildren();
        for (int i = 0; i < num; i++) {
            final Result result;
            try {
                result = mapMenuLoader.loadEntry(i);
            } catch (final IOException ex) {
                LOG.warn("dropping invalid bookmark: " + ex.getMessage());
                continue;
            }
            addMapMenuEntry(result.getDirectory(), result.getMapMenuEntry());
        }
        treeModelModified = false;
    }
 
    public void save() {
        if (!treeModelModified) {
            return;
        }
        treeModelModified = false;
 
        saveAlways();
    }
 
    public void saveAlways() {
        final int prevNum = mapMenuLoader.loadNumEntries();
        final int num = saveEntries(root, 0, "");
        mapMenuLoader.saveNumEntries(num);
        for (int i = num; i < prevNum; i++) {
            mapMenuLoader.removeEntry(i);
        }
    }
 
    private int saveEntries(@NotNull final DefaultMutableTreeNode treeNode, final int startIndex, @NotNull final String directory) {
        final int[] index = { startIndex };
        for (int i = 0; i < treeModel.getChildCount(treeNode); i++) {
            final DefaultMutableTreeNode childTreeNode = (DefaultMutableTreeNode) treeModel.getChild(treeNode, i);
            final MapMenuEntry childMapMenuEntry = (MapMenuEntry) childTreeNode.getUserObject();
            final String title = childMapMenuEntry.getTitle();
            final MapMenuEntryVisitor mapMenuEntryVisitor = new MapMenuEntryVisitor() {
 
                @Override
                public void visit(@NotNull final MapMenuEntryDir mapMenuEntry) {
                    mapMenuLoader.saveEntry(index[0]++, childMapMenuEntry.getTitle(), "", directory, Type.DIR);
                    index[0] = saveEntries(childTreeNode, index[0], directory.isEmpty() ? title : directory + "/" + title);
                }
 
                @Override
                public void visit(@NotNull final MapMenuEntryMap mapMenuEntry) {
                    final MapMenuEntryMap mapMenuEntryMap = (MapMenuEntryMap) childMapMenuEntry;
                    mapMenuLoader.saveEntry(index[0]++, title, mapMenuEntryMap.getMapFile().getFile().getPath(), directory, Type.MAP);
                }
 
            };
            childMapMenuEntry.visit(mapMenuEntryVisitor);
        }
        return index[0];
    }
 
    public void addMapMenuEntry(@NotNull final String directory, @NotNull final MapMenuEntry mapMenuEntry) {
        addMapMenuEntry(directory, new DefaultMutableTreeNode(mapMenuEntry, mapMenuEntry.allowsChildren()));
    }
 
    @NotNull
    @SuppressWarnings("TypeMayBeWeakened")
    public TreePath addMapMenuEntry(@NotNull final String directory, @NotNull final DefaultMutableTreeNode treeNode) {
        if (LOG.isDebugEnabled()) {
            LOG.debug(System.identityHashCode(this) + " addMapMenuEntry(" + directory + ", " + treeNode + ")");
        }
        final String[] paths = StringUtils.PATTERN_SLASH.split(directory);
        DefaultMutableTreeNode dir2 = root;
        for (final String path : paths) {
            if (!path.isEmpty()) {
                dir2 = getOrCreateDirectory(dir2, path);
            }
        }
        treeModel.insertNodeInto(treeNode, dir2, dir2.getChildCount());
        return new TreePath(treeModel.getPathToRoot(treeNode));
    }
 
    @NotNull
    public DefaultMutableTreeNode getOrCreateDirectory(@NotNull final MutableTreeNode this2, @NotNull final String path) {
        if (!MapMenuEntryDir.isValidDirectory(path)) {
            if (LOG.isDebugEnabled()) {
                LOG.debug(System.identityHashCode(this) + " getOrCreateDirectory(" + this2 + ", " + path + ")=invalid directory name");
            }
            throw new IllegalArgumentException("invalid directory name '" + path + "'");
        }
 
        for (int i = this2.getChildCount() - 1; i >= 0; i--) {
            final DefaultMutableTreeNode treeNode = (DefaultMutableTreeNode) this2.getChildAt(i);
            final MapMenuEntry mapMenuEntry = (MapMenuEntry) treeNode.getUserObject();
            if (mapMenuEntry.allowsChildren() && mapMenuEntry.getTitle().equals(path)) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug(System.identityHashCode(this) + " getOrCreateDirectory(" + this2 + ", " + path + ")=existing " + treeNode);
                }
                return treeNode;
            }
        }
 
        final DefaultMutableTreeNode new2 = new DefaultMutableTreeNode(new MapMenuEntryDir(path), true);
        treeModel.insertNodeInto(new2, this2, this2.getChildCount());
        if (LOG.isDebugEnabled()) {
            LOG.debug(System.identityHashCode(this) + " getOrCreateDirectory(" + this2 + ", " + path + ")=new " + new2);
        }
        return new2;
    }
 
    @NotNull
    public TreePath insertNodeInto(@NotNull final MapMenuEntry mapEntry, @NotNull final DefaultMutableTreeNode parent, final int index) {
        if (LOG.isDebugEnabled()) {
            LOG.debug(System.identityHashCode(this) + " insertNodeInto(" + mapEntry + ", " + parent + ", " + index + ")");
        }
        final DefaultMutableTreeNode treeNode = new DefaultMutableTreeNode(mapEntry, mapEntry.allowsChildren());
        treeModel.insertNodeInto(treeNode, parent, index);
        save();
        return new TreePath(treeModel.getPathToRoot(treeNode));
    }
 
    public void removeNode(@NotNull final DefaultMutableTreeNode treeNode) {
        if (treeNode == root) {
            if (LOG.isDebugEnabled()) {
                LOG.debug(System.identityHashCode(this) + " removeNode: not removing root " + treeNode);
            }
        } else {
            if (LOG.isDebugEnabled()) {
                LOG.debug(System.identityHashCode(this) + " removeNode " + treeNode);
            }
            final String directory = getDirectory(treeNode);
            treeModel.removeNodeFromParent(treeNode);
            deletedNodes.addFirst(new DeletedNode(directory, treeNode));
            while (deletedNodes.size() > 10) {
                deletedNodes.removeLast();
            }
            save();
        }
    }
 
    @NotNull
    private String getDirectory(@NotNull final TreeNode treeNode) {
        final TreeNode[] treePath = treeModel.getPathToRoot(treeNode);
        if (treePath == null) {
            throw new IllegalArgumentException("tree node not found: " + treeNode);
        }
        final StringBuilder sb = new StringBuilder();
        for (int i = 1; i + 1 < treePath.length; i++) {
            final TreeNode tmp = treePath[i];
            final MapMenuEntry mapMenuEntry = (MapMenuEntry) ((DefaultMutableTreeNode) tmp).getUserObject();
            if (sb.length() > 0) {
                sb.append('/');
            }
            sb.append(mapMenuEntry.getTitle());
        }
        return sb.toString();
    }
 
    @Nullable
    public DeletedNode getDeletedNode(final boolean delete) {
        return delete ? deletedNodes.pollFirst() : deletedNodes.peekFirst();
    }
 
    public int size() {
        return size(root);
    }
 
    private int size(@NotNull final TreeNode root) {
        final int childCount = treeModel.getChildCount(root);
        int result = childCount;
        for (int i = 0; i < childCount; i++) {
            final DefaultMutableTreeNode childTreeNode = (DefaultMutableTreeNode) treeModel.getChild(root, i);
            final MapMenuEntry mapMenuEntry = (MapMenuEntry) childTreeNode.getUserObject();
            if (mapMenuEntry.allowsChildren()) {
                result += size(childTreeNode);
            }
        }
        if (LOG.isDebugEnabled()) {
            LOG.debug(System.identityHashCode(this) + " size(" + root + ")=" + result);
        }
        return result;
    }
 
    @NotNull
    public JTree newTree() {
        return new AutoscrollJTree(treeModel);
    }
 
    @NotNull
    public DefaultMutableTreeNode getRoot() {
        return root;
    }
 
    public static class DeletedNode {
 
        @NotNull
        private final String directory;
 
        @NotNull
        private final DefaultMutableTreeNode treeNode;
 
        private DeletedNode(@NotNull final String directory, @NotNull final DefaultMutableTreeNode treeNode) {
            this.directory = directory;
            this.treeNode = treeNode;
        }
 
        @NotNull
        public String getDirectory() {
            return directory;
        }
 
        @NotNull
        public DefaultMutableTreeNode getTreeNode() {
            return treeNode;
        }
 
    }
 
}