DefaultObjectChooser.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.objectchooser;
 
import java.awt.BorderLayout;
import java.awt.Point;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import javax.swing.JPanel;
import javax.swing.JTabbedPane;
import javax.swing.SwingConstants;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import net.sf.gridarta.gui.map.mapview.MapView;
import net.sf.gridarta.gui.mapfiles.PickmapState;
import net.sf.gridarta.gui.panel.objectchoicedisplay.ObjectChoiceDisplay;
import net.sf.gridarta.gui.panel.pickmapchooser.PickmapChooserModel;
import net.sf.gridarta.gui.panel.pickmapchooser.PickmapChooserModelListener;
import net.sf.gridarta.model.archetype.Archetype;
import net.sf.gridarta.model.archetypechooser.ArchetypeChooserFolder;
import net.sf.gridarta.model.archetypechooser.ArchetypeChooserModel;
import net.sf.gridarta.model.archetypechooser.ArchetypeChooserModelListener;
import net.sf.gridarta.model.archetypechooser.ArchetypeChooserPanel;
import net.sf.gridarta.model.archetypechooser.DisplayMode;
import net.sf.gridarta.model.archetypetype.ArchetypeTypeSet;
import net.sf.gridarta.model.baseobject.BaseObject;
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.mapcursor.MapCursor;
import net.sf.gridarta.model.mapcursor.MapCursorListener;
import net.sf.gridarta.model.mapmodel.MapModel;
import net.sf.gridarta.model.mapmodel.MapSquare;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public class DefaultObjectChooser<G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> extends JPanel implements ObjectChooser<G, A, R> {
 
    private static final long serialVersionUID = 1L;
 
    @NotNull
    private final ObjectChooserTab<G, A, R> pickmapChooserControl;
 
    @NotNull
    private final ArchetypeChooserModel<G, A, R> archetypeChooserModel;
 
    @NotNull
    private final ObjectChoiceDisplay objectChoiceDisplay;
 
    @NotNull
    private final JTabbedPane tabbedPane = new JTabbedPane(SwingConstants.TOP);
 
    @NotNull
    private final List<ObjectChooserTab<G, A, R>> tabs = new ArrayList<>();
 
    @NotNull
    private final Collection<ObjectChooserListener<G, A, R>> listeners = new ArrayList<>();
 
    @Nullable
    private ObjectChooserTab<G, A, R> activeTab;
 
    @Nullable
    private PickmapState<G, A, R> activePickmapState;
 
    @Nullable
    private MapView<G, A, R> activePickmapView;
 
    @Nullable
    private BaseObject<G, A, R, ?> cursorSelection;
 
    private int selectedIndex = -2;
 
    @NotNull
    private final MapCursorListener<G, A, R> mapCursorListener = new MapCursorListener<G, A, R>() {
 
        @Override
        public void mapCursorChangedPos(@NotNull final Point location) {
            updatePickmapInfo(activePickmapView == null ? null : activePickmapView.getMapCursor());
        }
 
        @Override
        public void mapCursorChangedMode() {
            // ignore
        }
 
        @Override
        public void mapCursorChangedGameObject(@Nullable final MapSquare<G, A, R> mapSquare, @Nullable final G gameObject) {
            // ignore
        }
 
        @Override
        public void mapCursorChangedSize() {
            // ignore
        }
 
    };
 
    public DefaultObjectChooser(@NotNull final ObjectChooserTab<G, A, R> archetypeChooserControl, @NotNull final ObjectChooserTab<G, A, R> pickmapChooserControl, @NotNull final ArchetypeChooserModel<G, A, R> archetypeChooserModel, @NotNull final PickmapChooserModel<G, A, R> pickmapChooserModel, @NotNull final ArchetypeTypeSet archetypeTypeSet) {
        super(new BorderLayout());
        this.pickmapChooserControl = pickmapChooserControl;
        this.archetypeChooserModel = archetypeChooserModel;
        objectChoiceDisplay = new ObjectChoiceDisplay(archetypeTypeSet);
 
        cursorSelection = getSelection();
 
        addTab(archetypeChooserControl);
        addTab(pickmapChooserControl);
 
        final ChangeListener changeListener = new ChangeListener() {
 
            @Override
            public void stateChanged(final ChangeEvent e) {
                updateSelectedIndex();
            }
 
        };
        tabbedPane.addChangeListener(changeListener);
 
        updateSelectedIndex();
        add(tabbedPane, BorderLayout.CENTER);
        add(objectChoiceDisplay, BorderLayout.SOUTH);
 
        final ArchetypeChooserModelListener<G, A, R> archetypeChooserModelListener = new ArchetypeChooserModelListener<G, A, R>() {
 
            @Override
            public void selectedPanelChanged(@NotNull final ArchetypeChooserPanel<G, A, R> selectedPanel) {
                // ignore
            }
 
            @Override
            public void selectedFolderChanged(@NotNull final ArchetypeChooserFolder<G, A, R> selectedFolder) {
                // ignore
            }
 
            @Override
            public void selectedArchetypeChanged(@Nullable final R selectedArchetype) {
                if (!isPickmapActive()) {
                    fireSelectionChanged(selectedArchetype);
                }
            }
 
            @Override
            public void directionChanged(@Nullable final Integer direction) {
                // ignore
            }
 
            @Override
            public void displayModeChanged(@NotNull final DisplayMode<G, A, R> displayMode) {
                // ignore
            }
 
        };
        archetypeChooserModel.addArchetypeChooserModelListener(archetypeChooserModelListener);
 
        final PickmapChooserModelListener<G, A, R> pickmapChooserModelListener = new PickmapChooserModelListener<G, A, R>() {
 
            @Override
            public void activePickmapChanged(@Nullable final PickmapState<G, A, R> pickmapState) {
                if (activePickmapState != pickmapState) { // ignore non-changes
                    updateActivePickmap(pickmapState);
                }
            }
 
            @Override
            public void pickmapReverted(@NotNull final PickmapState<G, A, R> pickmapState) {
                if (activePickmapState == pickmapState) { // ignore unless active pickmap was reverted
                    updateActivePickmap(pickmapState);
                }
            }
 
            @Override
            public void pickmapModifiedChanged(final int index, @NotNull final PickmapState<G, A, R> pickmapState) {
                // ignore
            }
 
        };
        pickmapChooserModel.addPickmapChooserListener(pickmapChooserModelListener);
 
        objectChoiceDisplay.showObjectChooserQuickObject(cursorSelection, isPickmapActive());
    }
 
    private void addTab(@NotNull final ObjectChooserTab<G, A, R> tab) {
        tabs.add(tab);
        tabbedPane.addTab(tab.getTitle(), tab.getComponent());
    }
 
    private void setActiveTab(final int index) {
        @Nullable ObjectChooserTab<G, A, R> tab;
        try {
            tab = tabs.get(index);
        } catch (final IndexOutOfBoundsException ignored) {
            tab = null;
        }
        if (activeTab == tab) {
            return;
        }
 
        if (activeTab != null) {
            activeTab.setActive(false);
        }
        activeTab = tab;
        if (activeTab != null) {
            activeTab.setActive(true);
        }
        for (final ObjectChooserListener<G, A, R> listener : listeners) {
            listener.pickmapActiveChanged(isPickmapActive());
        }
        if (isPickmapActive()) {
            updatePickmapInfo(activePickmapView == null ? null : activePickmapView.getMapCursor());
        } else {
            final ArchetypeChooserPanel<G, A, R> selectedPanel = archetypeChooserModel.getSelectedPanel();
            fireSelectionChanged(selectedPanel == null ? null : selectedPanel.getSelectedFolder().getSelectedArchetype());
        }
    }
 
    @Override
    public final boolean isPickmapActive() {
        return activeTab == pickmapChooserControl;
    }
 
    @Override
    public boolean isMatching(@NotNull final G gameObject) {
        return activeTab != null && activeTab.isMatching(gameObject);
    }
 
    @Override
    public void addObjectChooserListener(@NotNull final ObjectChooserListener<G, A, R> listener) {
        listeners.add(listener);
    }
 
    @Override
    public void removeObjectChooserListener(@NotNull final ObjectChooserListener<G, A, R> listener) {
        listeners.remove(listener);
    }
 
    @Override
    public void moveArchetypeChooserToFront() {
        tabbedPane.setSelectedIndex(0);
    }
 
    @Override
    public void movePickmapChooserToFront() {
        tabbedPane.setSelectedIndex(1);
    }
 
    @Nullable
    @Override
    public BaseObject<G, A, R, ?> getCursorSelection() {
        return cursorSelection;
    }
 
    @Nullable
    @Override
    public final BaseObject<G, A, R, ?> getSelection() {
        return activeTab == null ? null : activeTab.getSelection();
    }
 
    @NotNull
    @Override
    public List<? extends BaseObject<G, A, R, ?>> getSelections() {
        return activeTab == null ? Collections.<G>emptyList() : activeTab.getSelections();
    }
 
    private void updateSelectedIndex() {
        final int index = tabbedPane.getSelectedIndex();
        if (index != selectedIndex) {
            selectedIndex = index;
            setActiveTab(index);
        }
    }
 
    private void updateActivePickmap(@Nullable final PickmapState<G, A, R> pickmapState) {
        if (activePickmapView != null) {
            activePickmapView.getMapCursor().removeMapCursorListener(mapCursorListener);
        }
        activePickmapState = pickmapState;
        updateActivePickmap();
        if (activePickmapView != null) {
            activePickmapView.getMapCursor().addMapCursorListener(mapCursorListener);
        }
    }
 
    private void updateActivePickmap() {
        activePickmapView = activePickmapState == null ? null : activePickmapState.getMapView();
        updatePickmapInfo(activePickmapView == null ? null : activePickmapView.getMapCursor());
    }
 
    private void updatePickmapInfo(@Nullable final MapCursor<G, A, R> mapCursor) {
        if (isPickmapActive()) {
            @Nullable final BaseObject<G, A, R, ?> gameObject;
            if (mapCursor == null) {
                gameObject = null;
            } else {
                final Point location = mapCursor.getLocation();
                if (activePickmapState == null) {
                    gameObject = null;
                } else {
                    final MapControl<G, A, R> pickmap = activePickmapState.getPickmap();
                    if (pickmap == null) {
                        gameObject = null;
                    } else {
                        final MapModel<G, A, R> mapModel = pickmap.getMapModel();
                        gameObject = mapModel.getMapSquare(location).getFirst();
                    }
                }
            }
            fireSelectionChanged(gameObject);
        }
    }
 
    private void fireSelectionChanged(@Nullable final BaseObject<G, A, R, ?> gameObject) {
        if (cursorSelection == gameObject) {
            return;
        }
        cursorSelection = gameObject;
 
        for (final ObjectChooserListener<G, A, R> listener : listeners) {
            listener.selectionChanged(gameObject);
        }
 
        objectChoiceDisplay.showObjectChooserQuickObject(gameObject, isPickmapActive());
    }
 
}