GameObjectAttributesControl.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.panel.gameobjectattributes;
 
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Container;
import java.awt.GridLayout;
import java.util.Collection;
import java.util.HashSet;
import java.util.IdentityHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.CopyOnWriteArrayList;
import javax.swing.Action;
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTabbedPane;
import javax.swing.SwingConstants;
import net.sf.gridarta.gui.dialog.gameobjectattributes.GameObjectAttributesDialogFactory;
import net.sf.gridarta.gui.panel.objectchooser.ObjectChooser;
import net.sf.gridarta.gui.panel.selectedsquare.SelectedSquareModel;
import net.sf.gridarta.gui.panel.selectedsquare.SelectedSquareModelListener;
import net.sf.gridarta.gui.utils.Severity;
import net.sf.gridarta.model.archetype.Archetype;
import net.sf.gridarta.model.baseobject.BaseObject;
import net.sf.gridarta.model.gameobject.GameObject;
import net.sf.gridarta.model.gameobject.GameObjectFactory;
import net.sf.gridarta.model.maparchobject.MapArchObject;
import net.sf.gridarta.model.mapcontrol.MapControl;
import net.sf.gridarta.model.mapmanager.MapManager;
import net.sf.gridarta.model.mapmanager.MapManagerListener;
import net.sf.gridarta.model.mapmodel.MapFile;
import net.sf.gridarta.model.mapmodel.MapModel;
import net.sf.gridarta.model.mapmodel.MapModelListener;
import net.sf.gridarta.model.mapmodel.MapSquare;
import net.sf.gridarta.model.mapmodel.MapTransactionListener;
import net.sf.gridarta.model.mapmodel.SavedSquares;
import net.sf.gridarta.model.mapviewsettings.MapViewSettings;
import net.sf.gridarta.model.validation.ErrorCollector;
import net.sf.gridarta.utils.ActionBuilderUtils;
import net.sf.gridarta.utils.Size2D;
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 GameObjectAttributesControl<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 GameObjectAttributesDialogFactory<G, A, R> gameObjectAttributesDialogFactory;
 
    @NotNull
    private final ObjectChooser<G, A, R> objectChooser;
 
    @NotNull
    private final SelectedSquareModel<G, A, R> selectedSquareModel;
 
    @NotNull
    private final GameObjectFactory<G, A, R> gameObjectFactory;
 
    @NotNull
    private final MapViewSettings mapViewSettings;
 
    @NotNull
    private final JTabbedPane panelDesktop = new JTabbedPane(SwingConstants.TOP);
 
    @NotNull
    private final GameObjectAttributesModel<G, A, R> gameObjectAttributesModel;
 
    @NotNull
    private final Collection<GameObjectAttributesControlListener> listeners = new CopyOnWriteArrayList<>();
 
    @Nullable
    private MapControl<G, A, R> currentMapControl;
 
    private boolean isInAutoApplyArchPanelChanges;
 
    @NotNull
    private Severity severity = Severity.DEFAULT;
 
    @NotNull
    private final Action aMapArchAddInv = ACTION_BUILDER.createAction(false, "mapArchAddInv", this);
 
    @NotNull
    private final Action aMapArchAddEnv = ACTION_BUILDER.createAction(false, "mapArchAddEnv", this);
 
    @NotNull
    private final Action aMapArchAttribute = ACTION_BUILDER.createAction(false, "mapArchAttrib", this);
 
    @NotNull
    private final Collection<GameObjectAttributesTab<G, A, R>> tabs = new HashSet<>();
 
    @NotNull
    private final Map<GameObjectAttributesTab<G, A, R>, Integer> tabIndex = new IdentityHashMap<>();
 
    @NotNull
    private final Map<Component, GameObjectAttributesTab<G, A, R>> componentTabs = new IdentityHashMap<>();
 
    @Nullable
    private G selectedGameObject;
 
    private boolean isInMapTransaction;
 
    @NotNull
    private final MapManagerListener<G, A, R> mapManagerListener = new MapManagerListener<G, A, R>() {
 
        @Override
        public void currentMapChanged(@Nullable final MapControl<G, A, R> mapControl) {
            if (currentMapControl != null) {
                final MapModel<G, A, R> mapModel = currentMapControl.getMapModel();
                mapModel.removeMapModelListener(mapModelListener);
                mapModel.removeMapTransactionListener(mapTransactionListener);
            }
            currentMapControl = mapControl;
            if (currentMapControl != null) {
                final MapModel<G, A, R> mapModel = currentMapControl.getMapModel();
                mapModel.addMapModelListener(mapModelListener);
                mapModel.addMapTransactionListener(mapTransactionListener);
            }
        }
 
        @Override
        public void mapCreated(@NotNull final MapControl<G, A, R> mapControl, final boolean interactive) {
            // ignore
        }
 
        @Override
        public void mapClosing(@NotNull final MapControl<G, A, R> mapControl) {
            // ignore
        }
 
        @Override
        public void mapClosed(@NotNull final MapControl<G, A, R> mapControl) {
            // ignore
        }
 
    };
 
    @NotNull
    private final MapModelListener<G, A, R> mapModelListener = new MapModelListener<G, A, R>() {
 
        @Override
        public void mapSizeChanged(@NotNull final Size2D newSize) {
            // ignore
        }
 
        @Override
        public void mapSquaresChanged(@NotNull final Set<MapSquare<G, A, R>> mapSquares) {
            if (selectedGameObject == null) {
                return;
            }
 
            final G topGameObject = selectedGameObject.getTopContainer();
            for (final Iterable<G> mapSquare : mapSquares) {
                for (final G gameObject : mapSquare) {
                    if (gameObject == topGameObject) {
                        refreshDisplay();
                    }
                }
            }
        }
 
        @Override
        public void mapObjectsChanged(@NotNull final Set<G> gameObjects, @NotNull final Set<G> transientGameObjects) {
            for (final GameObject<G, A, R> gameObject : gameObjects) {
                if (selectedGameObject == gameObject.getHead()) {
                    refreshDisplay();
                }
            }
        }
 
        @Override
        public void errorsChanged(@NotNull final ErrorCollector<G, A, R> errors) {
            // ignore
        }
 
        @Override
        public void mapFileChanged(@Nullable final MapFile oldMapFile) {
            // ignore
        }
 
        @Override
        public void modifiedChanged() {
            // ignore
        }
 
    };
 
    @NotNull
    private final MapTransactionListener<G, A, R> mapTransactionListener = new MapTransactionListener<G, A, R>() {
 
        @Override
        public void preBeginTransaction() {
            autoApplyArchPanelChanges();
            isInMapTransaction = true;
        }
 
        @Override
        public void beginTransaction(@NotNull final String name) {
            // ignore
        }
 
        @Override
        public void endTransaction(@NotNull final SavedSquares<G, A, R> savedSquares) {
            // ignore
        }
 
        @Override
        public void postEndTransaction() {
            isInMapTransaction = false;
        }
 
    };
 
    @NotNull
    private final SelectedSquareModelListener<G, A, R> selectedSquareModelListener = new SelectedSquareModelListener<G, A, R>() {
 
        @Override
        public void selectionChanged(@Nullable final MapSquare<G, A, R> mapSquare, @Nullable final G gameObject) {
            gameObjectAttributesModel.setSelectedGameObject(gameObject);
        }
 
    };
 
    @NotNull
    private final GameObjectAttributesModelListener<G, A, R> gameObjectAttributesModelListener = new GameObjectAttributesModelListener<G, A, R>() {
 
        @Override
        public void selectedGameObjectChanged(@Nullable final G selectedGameObject) {
            autoApplyArchPanelChanges();
            GameObjectAttributesControl.this.selectedGameObject = selectedGameObject;
            refreshDisplay();
        }
 
        @Override
        public void refreshSelectedGameObject() {
            // ignore
        }
 
    };
 
    @NotNull
    private final GameObjectAttributesTabListener<G, A, R> gameObjectAttributesTabListener = new GameObjectAttributesTabListener<G, A, R>() {
 
        @Override
        public void tabSeverityChanged(@NotNull final GameObjectAttributesTab<G, A, R> tab, @NotNull final Severity tabSeverity) {
            setTabSeverity(tab, tabSeverity);
        }
 
        @Override
        public void apply() {
            autoApplyArchPanelChanges();
        }
 
    };
 
    public GameObjectAttributesControl(@NotNull final GameObjectAttributesModel<G, A, R> gameObjectAttributesModel, @NotNull final GameObjectAttributesDialogFactory<G, A, R> gameObjectAttributesDialogFactory, @NotNull final ObjectChooser<G, A, R> objectChooser, @NotNull final MapManager<G, A, R> mapManager, @NotNull final SelectedSquareModel<G, A, R> selectedSquareModel, @NotNull final GameObjectFactory<G, A, R> gameObjectFactory, @NotNull final MapViewSettings mapViewSettings) {
        super(new BorderLayout());
        this.gameObjectAttributesModel = gameObjectAttributesModel;
        this.gameObjectAttributesDialogFactory = gameObjectAttributesDialogFactory;
        this.objectChooser = objectChooser;
        this.selectedSquareModel = selectedSquareModel;
        this.gameObjectFactory = gameObjectFactory;
        this.mapViewSettings = mapViewSettings;
 
        final Container mapArchPanel = new JPanel();
        mapArchPanel.setLayout(new BorderLayout());
        add(mapArchPanel, BorderLayout.CENTER);
 
        final Container buttonPanel = createButtonPanel();
        buttonPanel.setLayout(new GridLayout(0, 1));
        mapArchPanel.add(buttonPanel, BorderLayout.WEST);
        mapArchPanel.add(panelDesktop, BorderLayout.CENTER);
 
        selectedSquareModel.addSelectedSquareListener(selectedSquareModelListener);
        gameObjectAttributesModel.addGameObjectAttributesModelListener(gameObjectAttributesModelListener); // this listener must be registered before any tab, including TextEditorTab
 
        selectedGameObject = gameObjectAttributesModel.getSelectedGameObject();
        refreshDisplay();
        currentMapControl = mapManager.getCurrentMap();
        if (currentMapControl != null) {
            final MapModel<G, A, R> mapModel = currentMapControl.getMapModel();
            mapModel.addMapModelListener(mapModelListener);
            mapModel.addMapTransactionListener(mapTransactionListener);
        }
        mapManager.addMapManagerListener(mapManagerListener);
    }
 
    public void addGameObjectAttributesControlListener(@NotNull final GameObjectAttributesControlListener listener) {
        listeners.add(listener);
    }
 
    public void removeGameObjectAttributesControlListener(@NotNull final GameObjectAttributesControlListener listener) {
        listeners.remove(listener);
    }
 
    public void addTab(@NotNull final GameObjectAttributesTab<G, A, R> tab) {
        tabIndex.put(tab, panelDesktop.getTabCount());
        addTabInt(tab);
        panelDesktop.add(tab.getPanel(), ActionBuilderUtils.getString(ACTION_BUILDER, "mapArchTab" + tab.getClass().getSimpleName() + ".text"));
        setTabSeverity(tab, tab.getTabSeverity());
    }
 
    private void addTabInt(final GameObjectAttributesTab<G, A, R> tab) {
        tabs.add(tab);
        componentTabs.put(tab.getPanel(), tab);
        tab.addGameObjectAttributesTabListener(gameObjectAttributesTabListener);
    }
 
    public void selectTab(@NotNull final GameObjectAttributesTab<G, A, R> tab) {
        if (!tabs.contains(tab)) {
            throw new IllegalArgumentException("undefined tab: " + tab);
        }
 
        panelDesktop.setSelectedComponent(tab.getPanel());
    }
 
    @NotNull
    public GameObjectAttributesTab<G, A, R> getSelectedTab() {
        final Component component = panelDesktop.getSelectedComponent();
        final GameObjectAttributesTab<G, A, R> tab = componentTabs.get(component);
        assert tab != null;
        return tab;
    }
 
    private void setTabSeverity(@NotNull final GameObjectAttributesTab<G, A, R> tab, @NotNull final Severity tabSeverity) {
        final Integer index = tabIndex.get(tab);
        if (index == null) {
            return;
        }
 
        /* panelDesktop.setForegroundAt() doesn't work with Nimbus, so use a (dirty) workaround. */
        final JLabel title = new JLabel(panelDesktop.getTitleAt(index));
        title.setForeground(tabSeverity.getColor());
        panelDesktop.setTabComponentAt(index, title);
 
        Severity mainSeverity = tabSeverity;
        for (final Entry<GameObjectAttributesTab<G, A, R>, Integer> pair2 : tabIndex.entrySet()) {
            final Severity tmpSeverity = pair2.getKey().getTabSeverity();
            if (tmpSeverity.getLevel() > mainSeverity.getLevel()) {
                mainSeverity = tmpSeverity;
            }
        }
        if (severity == mainSeverity) {
            return;
        }
        severity = mainSeverity;
        for (final GameObjectAttributesControlListener listener : listeners) {
            listener.severityChanged(mainSeverity);
        }
    }
 
    @NotNull
    public Severity getSeverity() {
        return severity;
    }
 
    private void refreshDisplay() {
        aMapArchAddInv.setEnabled(selectedGameObject != null);
        aMapArchAddEnv.setEnabled(selectedGameObject != null);
        aMapArchAttribute.setEnabled(selectedGameObject != null);
        gameObjectAttributesModel.fireRefreshSelectedGameObject();
    }
 
    @ActionMethod
    public void mapArchAttrib() {
        if (selectedGameObject != null) {
            gameObjectAttributesDialogFactory.showAttributeDialog(selectedGameObject);
        }
    }
 
    @ActionMethod
    public void mapArchAddInv() {
        final BaseObject<G, A, R, ?> arch = objectChooser.getSelection();
        if (arch == null) { // nothing selected?
            return;
        }
 
        final GameObject<G, A, R> gameObject = selectedGameObject;
        if (gameObject == null) {
            return;
        }
 
        final G invNew = arch.newInstance(gameObjectFactory);
 
        final MapModel<G, A, R> mapModel = gameObject.getMapSquare().getMapModel();
        mapModel.beginTransaction("Add to inventory");
        try {
            gameObject.addLast(invNew);
            if (arch instanceof Archetype) {
                gameObjectFactory.createInventory(invNew, arch);
            }
        } finally {
            mapModel.endTransaction();
        }
    }
 
    @ActionMethod
    public void mapArchAddEnv() {
        final BaseObject<G, A, R, ?> baseObject = objectChooser.getSelection();
        if (baseObject == null) {
            return;
        }
 
        final G prevGameObject = selectedGameObject;
        if (prevGameObject == null) {
            return;
        }
 
        final MapSquare<G, A, R> mapSquare = prevGameObject.getMapSquare();
        final MapModel<G, A, R> mapModel = mapSquare.getMapModel();
        mapModel.beginTransaction("Add to environment"); // TODO; I18N/L10N
        try {
            final G insertedGameObject = mapModel.insertArchToMap(baseObject, prevGameObject, mapSquare.getMapLocation(), mapViewSettings.isAutojoin());
            if (insertedGameObject != null) {
                mapModel.removeGameObject(prevGameObject, mapViewSettings.isAutojoin());
                insertedGameObject.addLast(prevGameObject);
                selectedSquareModel.setSelectedGameObject(insertedGameObject);
            }
        } finally {
            mapModel.endTransaction();
        }
    }
 
    private void autoApplyArchPanelChanges() {
        if (selectedGameObject == null || isInAutoApplyArchPanelChanges || isInMapTransaction) {
            return;
        }
 
        isInAutoApplyArchPanelChanges = true;
        try {
            applyArchPanelChanges();
        } finally {
            isInAutoApplyArchPanelChanges = false;
        }
    }
 
    private void applyArchPanelChanges() {
        final GameObject<G, A, R> gameObject = selectedGameObject;
        if (gameObject == null) {
            return;
        }
 
        final MapSquare<G, A, R> mapSquare = gameObject.getMapSquareOptional();
        if (mapSquare == null) {
            // auto-apply of deleted game object
            return;
        }
 
        // suppress unwanted map transactions if nothing has changed
        boolean canApply = false;
        for (final GameObjectAttributesTab<G, A, R> tab : tabs) {
            if (tab.canApply()) {
                canApply = true;
                break;
            }
        }
        if (!canApply) {
            return;
        }
 
        final MapModel<G, A, R> mapModel = mapSquare.getMapModel();
        mapModel.beginTransaction("Change object attributes");
        try {
            for (final GameObjectAttributesTab<G, A, R> tab : tabs) {
                if (tab.canApply()) {
                    tab.apply();
                }
            }
        } finally {
            mapModel.endTransaction();
        }
    }
 
    @NotNull
    private Container createButtonPanel() {
        final Container buttonPanel = new JPanel();
        buttonPanel.add(new JButton(aMapArchAddInv));
        buttonPanel.add(new JButton(aMapArchAddEnv));
        buttonPanel.add(new JButton(aMapArchAttribute));
        return buttonPanel;
    }
 
}