PickmapChooserView.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.panel.pickmapchooser;

import java.awt.Component;
import java.io.File;
import java.io.IOException;
import javax.swing.BorderFactory;
import javax.swing.JPopupMenu;
import javax.swing.JTabbedPane;
import javax.swing.SwingConstants;
import javax.swing.event.ChangeListener;
import net.sf.gridarta.gui.map.mapview.MapView;
import net.sf.gridarta.gui.mapfiles.DuplicatePickmapException;
import net.sf.gridarta.gui.mapfiles.InvalidNameException;
import net.sf.gridarta.gui.mapfiles.MapFolder;
import net.sf.gridarta.gui.mapfiles.MapFolderListener;
import net.sf.gridarta.gui.mapfiles.MapFolderTree;
import net.sf.gridarta.gui.mapfiles.MapFolderTreeListener;
import net.sf.gridarta.gui.mapfiles.PickmapState;
import net.sf.gridarta.model.archetype.Archetype;
import net.sf.gridarta.model.gameobject.GameObject;
import net.sf.gridarta.model.io.MapReaderFactory;
import net.sf.gridarta.model.maparchobject.MapArchObject;
import net.sf.gridarta.model.maparchobject.MapArchObjectFactory;
import net.sf.gridarta.model.mapcontrol.MapControl;
import net.sf.gridarta.model.mapmanager.MapManager;
import net.sf.gridarta.model.mapmodel.MapFile;
import net.sf.gridarta.model.mapmodel.MapPathUtils;
import net.sf.gridarta.utils.CommonConstants;
import net.sf.gridarta.utils.Size2D;
import org.apache.log4j.Category;
import org.apache.log4j.Logger;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

public class PickmapChooserView<G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> {

    @NotNull
    private static final Category LOG = Logger.getLogger(PickmapChooserView.class);

    @NotNull
    private final PickmapChooserModel<G, A, R> pickmapChooserModel;

    @NotNull
    private final MapFolderTree<G, A, R> mapFolderTree;

    @NotNull
    private final MapArchObjectFactory<A> mapArchObjectFactory;

    @NotNull
    private final MapReaderFactory<G, A> mapReaderFactory;

    @NotNull
    private final MapManager<G, A, R> pickmapManager;

    @NotNull
    private final JTabbedPane pickmapPanel = new JTabbedPane(SwingConstants.TOP);

    @Nullable
    private MapFolder<G, A, R> activeMapFolder;

    @NotNull
    private final MapFolderTreeListener<G, A, R> mapFolderTreeListener = new MapFolderTreeListener<G, A, R>() {

        @Override
        public void activeMapFolderChanged(@Nullable final MapFolder<G, A, R> mapFolder) {
            if (activeMapFolder != null) {
                activeMapFolder.removeFolderListener(mapFolderListener);
            }
            activeMapFolder = mapFolder;
            if (activeMapFolder != null) {
                activeMapFolder.addFolderListener(mapFolderListener);
            }

            synchronized (mapFolderTree) {
                pickmapChooserModel.clear();
                pickmapPanel.removeAll();
                if (activeMapFolder != null) {
                    for (final PickmapState<G, A, R> pickmapState : activeMapFolder) {
                        addPickmap(pickmapState);
                    }
                }
            }
        }

        @Override
        public void folderAdded(@NotNull final MapFolder<G, A, R> mapFolder) {
            // ignore
        }

        @Override
        public void folderRemoved(@NotNull final MapFolder<G, A, R> mapFolder) {
            // ignore
        }

    };

    @NotNull
    private final MapFolderListener<G, A, R> mapFolderListener = new MapFolderListener<G, A, R>() {

        @Override
        public void pickmapAdded(@NotNull final PickmapState<G, A, R> pickmapState) {
            addPickmap(pickmapState);
        }

        @Override
        public void pickmapRemoved(@NotNull final PickmapState<G, A, R> pickmapState) {
            removePickmap(pickmapState);
        }

        @Override
        public void pickmapReverted(@NotNull final PickmapState<G, A, R> pickmapState, @NotNull final MapControl<G, A, R> oldPickmap) {
            revertPickmap(pickmapState, oldPickmap);
        }

    };

    @NotNull
    private final PickmapChooserModelListener<G, A, R> pickmapChooserModelListener = new PickmapChooserModelListener<G, A, R>() {

        @Override
        public void activePickmapChanged(@Nullable final PickmapState<G, A, R> pickmapState) {
        }

        @Override
        public void pickmapReverted(@NotNull final PickmapState<G, A, R> pickmapState) {
        }

        @Override
        public void pickmapModifiedChanged(final int index, @NotNull final PickmapState<G, A, R> pickmapState) {
            pickmapPanel.setTitleAt(index, getTitle(pickmapState));
        }

    };

    public PickmapChooserView(@NotNull final PickmapChooserModel<G, A, R> pickmapChooserModel, @NotNull final MapFolderTree<G, A, R> mapFolderTree, @NotNull final MapArchObjectFactory<A> mapArchObjectFactory, @NotNull final MapReaderFactory<G, A> mapReaderFactory, @NotNull final MapManager<G, A, R> pickmapManager) {
        this.pickmapChooserModel = pickmapChooserModel;
        this.mapFolderTree = mapFolderTree;
        this.mapArchObjectFactory = mapArchObjectFactory;
        this.mapReaderFactory = mapReaderFactory;
        this.pickmapManager = pickmapManager;
        pickmapChooserModel.addPickmapChooserListener(pickmapChooserModelListener);
        pickmapPanel.setBorder(BorderFactory.createEmptyBorder(CommonConstants.SPACE_PICKMAP_ARCHETYPE_TOP, 0, 0, 0));
        mapFolderTree.addModelListener(mapFolderTreeListener);
        //noinspection SynchronizationOnLocalVariableOrMethodParameter
        synchronized (mapFolderTree) {
            mapFolderTreeListener.activeMapFolderChanged(mapFolderTree.getActiveMapFolder());
        }
    }

    public void setPopupMenu(@NotNull final JPopupMenu popupMenu) {
        pickmapPanel.setComponentPopupMenu(popupMenu);
    }

    public void addChangeListener(@NotNull final ChangeListener changeListener) {
        pickmapPanel.addChangeListener(changeListener);
    }

    private void addPickmap(@NotNull final PickmapState<G, A, R> pickmapState) {
        try {
            pickmapState.loadPickmap();
        } catch (final IOException ex) {
            LOG.warn("cannot load pickmap " + pickmapState.getFile() + ": " + ex.getMessage());
            return;
        }

        final int index = pickmapChooserModel.addMapFile(pickmapState);
        final MapView<G, A, R> mapView = pickmapState.getMapView();
        pickmapPanel.insertTab(getTitle(pickmapState), null, mapView == null ? null : mapView.getScrollPane(), null, index);
    }

    private void removePickmap(@NotNull final PickmapState<G, A, R> pickmapState) {
        final int index = pickmapChooserModel.removeMapFile(pickmapState);
        if (index >= 0) {
            pickmapPanel.remove(index);
        }
    }

    private void revertPickmap(@NotNull final PickmapState<G, A, R> pickmapState, @NotNull final MapControl<G, A, R> oldPickmap) {
        final int index = pickmapChooserModel.revertMapFile(oldPickmap, pickmapState);
        if (index == -1) {
            return;
        }
        pickmapPanel.setTitleAt(index, getTitle(pickmapState));
        final MapView<G, A, R> mapView = pickmapState.getMapView();
        pickmapPanel.setComponentAt(index, mapView == null ? null : mapView.getScrollPane());
    }

    public void setActivePickmap(@NotNull final PickmapState<G, A, R> pickmapState) {
        final int index = pickmapChooserModel.indexOf(pickmapState);
        if (index == -1) {
            return;
        }
        pickmapPanel.setSelectedIndex(index);
    }

    @NotNull
    public String getTitle(@NotNull final PickmapState<G, A, R> pickmapState) {
        final String name = pickmapState.getFile().getName();
        final MapControl<G, A, R> mapControl = pickmapState.getPickmap();
        final boolean modified = mapControl != null && mapControl.getMapModel().isModified();
        return modified ? name + " *" : name;
    }

    @NotNull
    public Component getPickmapPanel() {
        return pickmapPanel;
    }

    public int getSelectedIndex() {
        return pickmapPanel.getSelectedIndex();
    }

    public void newPickmap(@NotNull final Size2D mapSize, @NotNull final String pickmapName) throws DuplicatePickmapException, IOException {
        final MapFolder<G, A, R> activeMapFolder = this.activeMapFolder;
        if (activeMapFolder == null) {
            return;
        }

        if (!PickmapState.isValidPickmapName(pickmapName)) {
            throw new IOException("invalid pickmap name: " + pickmapName);
        }

        for (final PickmapState<G, A, R> pickmapState : activeMapFolder) {
            if (pickmapName.equals(pickmapState.getFile().getName())) {
                throw new DuplicatePickmapException(pickmapName);
            }
        }
        final MapFile mapFile2 = new MapFile(new MapFile(activeMapFolder.getDir()), MapPathUtils.newMapPath(pickmapName));

        if (mapFile2.getFile().isDirectory()) {
            throw new IOException("pickmap file is a directory: " + mapFile2);
        }
        if (mapFile2.getFile().exists()) {
            throw new IOException("pickmap file exists: " + mapFile2);
        }

        final File dir = mapFile2.getFile().getParentFile();
        if (!dir.exists()) {
            if (!dir.mkdirs()) {
                throw new IOException("cannot create directory: " + dir);
            }
        }

        final A mapArchObject = mapArchObjectFactory.newMapArchObject(true);
        mapArchObject.setMapSize(mapSize);
        mapArchObject.setMapName(pickmapName);
        final MapControl<G, A, R> mapControl = pickmapManager.newMap(null, mapArchObject, mapFile2, false);
        try {
            mapControl.save();
        } finally {
            pickmapManager.release(mapControl);
        }

        final PickmapState<G, A, R> pickmapState;
        try {
            pickmapState = activeMapFolder.addPickmap(pickmapName, mapReaderFactory, pickmapManager);
        } catch (final InvalidNameException ex) {
            throw new AssertionError(ex); // the name has been checked before
        }
        setActivePickmap(pickmapState);
    }

}