ExportMapAsImageDialog.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.dialog.exportmap;
 
import java.awt.EventQueue;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.File;
import java.util.prefs.Preferences;
import java.util.regex.Pattern;
import javax.swing.AbstractButton;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JDialog;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JProgressBar;
import javax.swing.WindowConstants;
import net.sf.gridarta.MainControl;
import net.sf.gridarta.action.exportmap.ExportMapAsImageAction;
import net.sf.gridarta.action.exportmap.ExportMapProgress;
import net.sf.gridarta.gui.utils.GUIConstants;
import net.sf.gridarta.gui.utils.JFileField;
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.mapcontrol.MapControl;
import net.sf.gridarta.model.mapmodel.MapFile;
import net.sf.gridarta.model.mapmodel.MapModel;
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;
 
@SuppressWarnings("ThisEscapedInObjectConstruction")
public class ExportMapAsImageDialog<G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> extends JOptionPane {
 
    private static final int PREVIEW_SIZE = 256;
 
    private static final long serialVersionUID = 1L;
 
    @NotNull
    private static final ActionBuilder ACTION_BUILDER = ActionBuilderFactory.getInstance().getActionBuilder("net.sf.gridarta");
 
    @NotNull
    protected static final Preferences PREFERENCES = Preferences.userNodeForPackage(MainControl.class);
 
    @NotNull
    private static final Pattern PATTERN_PATH = Pattern.compile(".*/");
 
    @NotNull
    private final ExportMapAsImageAction<G, A, R> exportMapAsImageAction;
 
    @NotNull
    private final MapControl<G, A, R> mapControl;
 
    @NotNull
    private final JButton exportButton = new JButton(ACTION_BUILDER.createAction(false, "exportMapAsImageExport", this));
 
    @NotNull
    private final JButton cancelButton = new JButton(ACTION_BUILDER.createAction(false, "exportMapAsImageCancel", this));
 
    @NotNull
    private final JButton cancelExportButton = new JButton(ACTION_BUILDER.createAction(false, "exportMapAsImageCancelExport", this));
 
    @NotNull
    private final JDialog dialog;
 
    @NotNull
    private final AbstractButton includeTiledMapsCheckbox = new JCheckBox(ACTION_BUILDER.createToggle(false, "exportMapAsImageIncludeTiledMaps", this));
 
    @NotNull
    private final JFileField outputFileField;
 
    @NotNull
    private final JLabel progressLabel = new JLabel();
 
    @NotNull
    private final JProgressBar progressBar = new JProgressBar();
 
    @NotNull
    private final JLabel previewLabel = new JLabel();
 
    @NotNull
    private final JLabel previewImage = new JLabel();
 
    private boolean includeTiledMaps = true;
 
    private volatile boolean cancelExport;
 
    public ExportMapAsImageDialog(@NotNull final JFrame parent, @NotNull final ExportMapAsImageAction<G, A, R> exportMapAsImageAction, @NotNull final MapControl<G, A, R> mapControl) {
        this.exportMapAsImageAction = exportMapAsImageAction;
        this.mapControl = mapControl;
        exportButton.setDefaultCapable(true);
        final MapFile mapFile = mapControl.getMapModel().getMapFile();
        final File file;
        if (mapFile == null) {
            file = new File(System.getProperty("user.dir")).getAbsoluteFile();
        } else {
            final File mapsDir = mapFile.getMapsDir();
            file = new File(new File(mapsDir, "images"), PATTERN_PATH.matcher(mapFile.getMapPath().getPath()).replaceAll("") + ".png");
        }
        outputFileField = new JFileField(this, "exportMapAsImageOutputFile", null, file, JFileChooser.FILES_ONLY | JFileChooser.SAVE_DIALOG);
        previewImage.setIcon(new ImageIcon(new BufferedImage(PREVIEW_SIZE, PREVIEW_SIZE, BufferedImage.TYPE_INT_ARGB)));
        cancelExportButton.setEnabled(false);
        setOptions(new Object[] { exportButton, cancelButton, cancelExportButton });
        setMessage(createPanel());
 
        dialog = createDialog(parent, ACTION_BUILDER.format("exportMapAsImageTitle"));
        dialog.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
        dialog.getRootPane().setDefaultButton(exportButton);
        dialog.setModal(false);
        dialog.pack();
        dialog.setVisible(true);
    }
 
    @NotNull
    public File getOutputFile() {
        return outputFileField.getFile();
    }
 
    @ActionMethod
    public boolean isIncludeTiledMaps() {
        return includeTiledMapsCheckbox.isSelected();
    }
 
    @NotNull
    private JPanel createPanel() {
        final JPanel panel = new JPanel();
        panel.setLayout(new GridBagLayout());
        panel.setBorder(GUIConstants.DIALOG_BORDER);
        final GridBagConstraints gbc = new GridBagConstraints();
        gbc.gridx = 0;
        gbc.fill = GridBagConstraints.HORIZONTAL;
        gbc.anchor = GridBagConstraints.LINE_START;
        final MapModel<G, A, R> mapModel = mapControl.getMapModel();
        if (mapModel.getMapFile() != null) {
            final A mapArchObject = mapModel.getMapArchObject();
            for (final Direction direction : Direction.values()) {
                if (!mapArchObject.getTilePath(direction).isEmpty()) {
                    includeTiledMapsCheckbox.setSelected(true);
                    panel.add(includeTiledMapsCheckbox, gbc);
                    break;
                }
            }
        }
        panel.add(ActionBuilderUtils.newLabel(ACTION_BUILDER, "exportMapAsImageOutputLabel"), gbc);
        panel.add(outputFileField, gbc);
        panel.add(progressLabel, gbc);
        panel.add(progressBar, gbc);
        panel.add(previewLabel, gbc);
        panel.add(previewImage, gbc);
        return panel;
    }
 
    @ActionMethod
    public void exportMapAsImageExport() {
        final ExportMapProgress progress = new ExportMapProgress() {
 
            @Override
            public void setMax(final int max) {
                EventQueue.invokeLater(() -> {
                    progressLabel.setText(max + " tiled " + (max == 1 ? "map" : "maps"));
                    progressBar.setMaximum(max);
                    dialog.pack();
                });
            }
 
            @Override
            public void setValue(final int value, @NotNull final BufferedImage image) {
                EventQueue.invokeLater(() -> {
                    progressBar.setIndeterminate(false);
                    progressBar.setStringPainted(true);
                    progressBar.setValue(value);
                    previewLabel.setText(image.getWidth() + "x" + image.getHeight() + " pixels");
                    previewImage.setIcon(new ImageIcon(image.getScaledInstance(PREVIEW_SIZE, PREVIEW_SIZE, Image.SCALE_DEFAULT)));
                    dialog.pack();
                });
            }
 
            @Override
            public boolean cancel() {
                return cancelExport;
            }
 
        };
        final Runnable runnable = () -> {
            final boolean ok = exportMapAsImageAction.exportMap(mapControl, includeTiledMaps, outputFileField.getFile(), progress);
            EventQueue.invokeLater(() -> {
                setValue(ok ? exportButton : UNINITIALIZED_VALUE);
                includeTiledMapsCheckbox.setEnabled(true);
                outputFileField.setEnabled(true);
                progressBar.setIndeterminate(false);
                progressBar.setStringPainted(false);
                progressBar.setMinimum(0);
                progressBar.setMaximum(1);
                progressBar.setValue(0);
                cancelExportButton.setEnabled(false);
                exportButton.setEnabled(true);
                dialog.pack();
            });
        };
        includeTiledMapsCheckbox.setEnabled(false);
        outputFileField.setEnabled(false);
        progressLabel.setText("");
        progressBar.setIndeterminate(true);
        progressBar.setValue(0);
        progressBar.setMaximum(0);
        progressBar.setStringPainted(false);
        previewLabel.setText("");
        previewImage.setIcon(new ImageIcon(new BufferedImage(PREVIEW_SIZE, PREVIEW_SIZE, BufferedImage.TYPE_INT_ARGB)));
        cancelExportButton.setEnabled(true);
        exportButton.setEnabled(false);
        dialog.pack();
        cancelExport = false;
        final Thread thread = new Thread(runnable, "Map Exporter Thread");
        thread.setDaemon(true);
        thread.start();
    }
 
    @ActionMethod
    public void exportMapAsImageCancel() {
        setValue(cancelButton);
    }
 
    @ActionMethod
    public void exportMapAsImageCancelExport() {
        setValue(UNINITIALIZED_VALUE);
    }
 
    @Override
    public void setValue(@Nullable final Object newValue) {
        super.setValue(newValue);
        cancelExport = true;
        if (newValue != UNINITIALIZED_VALUE) {
            dialog.dispose();
        }
    }
 
    @ActionMethod
    public boolean isExportMapAsImageIncludeTiledMaps() {
        return includeTiledMaps;
    }
 
    public void setExportMapAsImageIncludeTiledMaps(final boolean includeTiledMaps) {
        includeTiledMapsCheckbox.setSelected(includeTiledMaps);
        this.includeTiledMaps = includeTiledMaps;
    }
 
}