AbstractMapTilePane.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.map.maptilepane;
 
import java.awt.Component;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.io.File;
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JPanel;
import javax.swing.border.CompoundBorder;
import javax.swing.filechooser.FileFilter;
import net.sf.gridarta.actions.AttachTiledMaps;
import net.sf.gridarta.actions.CannotLoadMapFileException;
import net.sf.gridarta.actions.CannotSaveMapFileException;
import net.sf.gridarta.actions.MapSizeMismatchException;
import net.sf.gridarta.gui.utils.DirectionLayout;
import net.sf.gridarta.gui.utils.GUIConstants;
import net.sf.gridarta.model.archetype.Archetype;
import net.sf.gridarta.model.direction.Direction;
import net.sf.gridarta.model.gameobject.GameObject;
import net.sf.gridarta.model.maparchobject.MapArchObject;
import net.sf.gridarta.model.mapmanager.MapManager;
import net.sf.gridarta.model.mapmodel.MapFile;
import net.sf.gridarta.model.mapmodel.MapModel;
import net.sf.gridarta.model.mapmodel.UnsavedMapException;
import net.sf.gridarta.model.settings.ProjectSettings;
import net.sf.gridarta.model.tiles.MapLink;
import net.sf.gridarta.model.tiles.TileLink;
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;
 
public abstract class AbstractMapTilePane<G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> extends JPanel {
 
    private static final long serialVersionUID = 1L;
 
    @NotNull
    private static final ActionBuilder ACTION_BUILDER = ActionBuilderFactory.getInstance().getActionBuilder("net.sf.gridarta");
 
    @NotNull
    private final ProjectSettings projectSettings;
 
    @NotNull
    private final MapModel<G, A, R> mapModel;
 
    @NotNull
    private final MapArchObject<A> mapArchObject;
 
    @NotNull
    private final TileLink @NotNull [] tileLinks;
 
    private final int @NotNull [] nextFocus;
 
    @NotNull
    private final FileFilter mapFileFilter;
 
    private final MapTilePanel @NotNull [] tilePaths;
 
    @NotNull
    private final AttachTiledMaps<G, A, R> attachTiledMaps;
 
    private final boolean canAttachMaps;
 
    protected AbstractMapTilePane(@NotNull final MapManager<G, A, R> mapManager, @NotNull final ProjectSettings projectSettings, @NotNull final MapModel<G, A, R> mapModel, @NotNull final MapLink @NotNull [] @NotNull [] tileLink, @NotNull final Direction @NotNull [] directionMapping, final int @NotNull [] nextFocus, @NotNull final FileFilter mapFileFilter) {
        this.projectSettings = projectSettings;
        this.mapModel = mapModel;
        this.nextFocus = nextFocus.clone();
        this.mapFileFilter = mapFileFilter;
        assert tileLink.length == 10;
        tileLinks = new TileLink[] { //
            newTileLink("mapNorth", tileLink[0], Direction.SOUTH), //
            newTileLink("mapEast", tileLink[1], Direction.WEST), //
            newTileLink("mapSouth", tileLink[2], Direction.NORTH), //
            newTileLink("mapWest", tileLink[3], Direction.EAST), //
            newTileLink("mapNorthEast", tileLink[4], Direction.SOUTH_WEST), //
            newTileLink("mapSouthEast", tileLink[5], Direction.NORTH_WEST), //
            newTileLink("mapSouthWest", tileLink[6], Direction.NORTH_EAST), //
            newTileLink("mapNorthWest", tileLink[7], Direction.SOUTH_EAST), //
            newTileLink("mapUp", tileLink[8], Direction.DOWN), //
            newTileLink("mapDown", tileLink[9], Direction.UP) //
        };
        attachTiledMaps = new AttachTiledMaps<>(mapManager, tileLinks);
        canAttachMaps = tileLink[0].length + tileLink[1].length + tileLink[2].length + tileLink[3].length + tileLink[4].length + tileLink[5].length + tileLink[6].length + tileLink[7].length + tileLink[8].length + tileLink[9].length > 0;
        mapArchObject = mapModel.getMapArchObject();
        tilePaths = buildComponents(directionMapping);
    }
 
    @NotNull
    private static TileLink newTileLink(@NotNull final String key, @NotNull final MapLink @NotNull [] mapLinks, @NotNull final Direction revLink) {
        return new TileLink(ActionBuilderUtils.getString(ACTION_BUILDER, key), mapLinks, revLink);
    }
 
    @NotNull
    private MapTilePanel @NotNull [] buildComponents(@NotNull final Direction @NotNull [] directionMapping) {
        setLayout(new GridBagLayout());
        final GridBagConstraints gbc = new GridBagConstraints();
        gbc.gridwidth = GridBagConstraints.REMAINDER;
        gbc.weightx = 1.0;
        gbc.fill = GridBagConstraints.BOTH;
        final MapTilePanel[] tilePanels = createTilePanels(directionMapping.length);
        add(buildTilePanels(tilePanels, directionMapping), gbc);
        add(buildSubPanel(), gbc);
        return tilePanels;
    }
 
    @NotNull
    private MapTilePanel @NotNull [] createTilePanels(final int directions) {
        final MapTilePanel[] tilePanels = new MapTilePanel[directions];
        for (int index = 0; index < tilePanels.length; index++) {
            final File mapDir = projectSettings.getMapsDirectory();
            final MapFile mapFile = mapModel.getMapFile();
            final TilePanel tilePanel = new TilePanel(mapFileFilter, mapArchObject.getTilePath(Direction.values()[index]), mapFile == null ? null : mapFile.getFile(), mapDir);
            tilePanels[index] = new MapTilePanel(index, nextFocus, tilePanel, tileLinks[index].getName());
        }
        return tilePanels;
    }
 
    @NotNull
    private static Component buildTilePanels(@NotNull final MapTilePanel @NotNull [] tilePanels, @NotNull final Direction @NotNull [] directionMapping) {
        final JComponent panel = new JPanel(new DirectionLayout());
        panel.setBorder(new CompoundBorder(BorderFactory.createTitledBorder(ActionBuilderUtils.getString(ACTION_BUILDER, "mapTiles")), GUIConstants.DIALOG_BORDER));
        for (int index = 0; index < tilePanels.length; index++) {
            panel.add(tilePanels[index].getTilePanel(), directionMapping[index]);
        }
        return panel;
    }
 
    @NotNull
    private Component buildSubPanel() {
        final JComponent subPanel = new JPanel(new GridBagLayout());
        subPanel.setBorder(new CompoundBorder(BorderFactory.createTitledBorder(ActionBuilderUtils.getString(ACTION_BUILDER, "mapControl")), GUIConstants.DIALOG_BORDER));
        final GridBagConstraints gbc = new GridBagConstraints();
        gbc.fill = GridBagConstraints.NONE;
        gbc.weightx = 1.0;
        gbc.weighty = 1.0;
        if (canAttachMaps) {
            gbc.anchor = GridBagConstraints.EAST;
            subPanel.add(new JButton(ACTION_BUILDER.createAction(false, "mapTilesAttach", this)), gbc);
        }
        gbc.gridwidth = GridBagConstraints.REMAINDER;
        gbc.anchor = canAttachMaps ? GridBagConstraints.WEST : GridBagConstraints.CENTER;
        subPanel.add(new JButton(ACTION_BUILDER.createAction(false, "mapTilesClear", this)), gbc);
        return subPanel;
    }
 
    @ActionMethod
    public void mapTilesAttach() {
        final String[] tmpTilePaths = new String[tilePaths.length];
        for (int i = 0; i < tmpTilePaths.length; i++) {
            tmpTilePaths[i] = tilePaths[i].getTilePanel().getText();
        }
        final File mapsDirectory = projectSettings.getMapsDirectory();
        try {
            attachTiledMaps.attachTiledMaps(mapModel, tmpTilePaths, mapsDirectory, true);
        } catch (final CannotLoadMapFileException ex) {
            ACTION_BUILDER.showMessageDialog(this, "mapErrorPath2", ex.getMapPath()); // XXX: ignores ex.getMessage()
            return;
        } catch (final CannotSaveMapFileException ex) {
            ACTION_BUILDER.showMessageDialog(this, "mapErrorFatalWrite", ex.getMessage()); // XXX: ignores ex.getMapFile()
            return;
        } catch (final MapSizeMismatchException ex) {
            ACTION_BUILDER.showMessageDialog(this, "mapErrorDifferentSize", mapModel.getMapArchObject().getMapName(), ex.getMapSize().getWidth(), ex.getMapSize().getHeight(), ex.getMapFile(), ex.getOtherMapSize().getWidth(), ex.getOtherMapSize().getHeight());
            return;
        } catch (final UnsavedMapException ignored) {
            ACTION_BUILDER.showMessageDialog(this, "mapErrorUnsaved");
            return;
        }
        for (int i = 0; i < tmpTilePaths.length; i++) {
            tilePaths[i].getTilePanel().setText(tmpTilePaths[i], true);
        }
    }
 
    @ActionMethod
    public void mapTilesClear() {
        for (final MapTilePanel tilePath : tilePaths) {
            tilePath.getTilePanel().setText("", true);
        }
    }
 
    public void modifyMapProperties() {
        for (int i = 0; i < tilePaths.length; i++) {
            mapArchObject.setTilePath(Direction.values()[i], tilePaths[i].getTilePanel().getText());
        }
    }
 
    public void restoreMapProperties() {
        for (final MapTilePanel tilePath : tilePaths) {
            tilePath.getTilePanel().mapTileRevert();
        }
    }
 
    @NotNull
    public MapTilePanel getTilePath(final int direction) {
        return tilePaths[direction];
    }
 
}