DefaultFilterControl.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.filter;
 
import java.util.Collection;
import java.util.concurrent.CopyOnWriteArrayList;
import javax.swing.JMenu;
import javax.swing.JMenuItem;
import net.sf.gridarta.model.archetype.Archetype;
import net.sf.gridarta.model.filter.Filter;
import net.sf.gridarta.model.filter.FilterConfig;
import net.sf.gridarta.model.filter.FilterConfigChangeType;
import net.sf.gridarta.model.filter.FilterConfigDecoder;
import net.sf.gridarta.model.filter.FilterConfigEncoder;
import net.sf.gridarta.model.filter.FilterConfigListener;
import net.sf.gridarta.model.filter.NamedFilter;
import net.sf.gridarta.model.filter.NamedFilterConfig;
import net.sf.gridarta.model.gameobject.GameObject;
import net.sf.gridarta.model.maparchobject.MapArchObject;
import net.sf.gridarta.model.settings.EditorSettings;
import net.sf.gridarta.model.settings.EditorSettingsKey;
import net.sf.gridarta.utils.ActionBuilderUtils;
import net.sf.japi.swing.action.ActionBuilder;
import net.sf.japi.swing.action.ActionBuilderFactory;
import org.apache.log4j.Category;
import org.apache.log4j.Logger;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
//TODO allow implementation of own filter
public class DefaultFilterControl<G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> implements FilterControl<G, A, R> {
 
    @NotNull
    private static final Category LOG = Logger.getLogger(DefaultFilterControl.class);
 
    @NotNull
    private static final ActionBuilder ACTION_BUILDER = ActionBuilderFactory.getInstance().getActionBuilder("net.sf.gridarta");
 
    @NotNull
    private final NamedFilter filterList;
 
    @NotNull
    private final NamedFilterConfig filterOutConfig;
 
    @NotNull
    private final EditorSettings editorSettings;
 
    @NotNull
    private final NamedFilterConfig @NotNull [] highlightConfig;
 
    @NotNull
    private final Collection<FilterConfigListener> configListeners = new CopyOnWriteArrayList<>();
 
    @NotNull
    private final FilterConfigListener filterConfigListener = new FilterConfigListener() {
 
        @Override
        public void configChanged(@NotNull final FilterConfigChangeType filterConfigChangeType, @NotNull final FilterConfig<?, ?> filterConfig) {
            @Nullable final EditorSettingsKey key;
            @Nullable final FilterConfig<?, ?> valueFilterConfig;
            if (isFilterConfig(filterConfig, filterOutConfig)) {
                key = EditorSettingsKey.ANALYZE_FILTER_OUT;
                valueFilterConfig = filterOutConfig;
            } else if (isFilterConfig(filterConfig, highlightConfig[0])) {
                key = EditorSettingsKey.ANALYZE_HIGHLIGHT0;
                valueFilterConfig = highlightConfig[0];
            } else if (isFilterConfig(filterConfig, highlightConfig[1])) {
                key = EditorSettingsKey.ANALYZE_HIGHLIGHT1;
                valueFilterConfig = highlightConfig[1];
            } else if (isFilterConfig(filterConfig, highlightConfig[2])) {
                key = EditorSettingsKey.ANALYZE_HIGHLIGHT2;
                valueFilterConfig = highlightConfig[2];
            } else {
                LOG.warn("filter config " + filterConfig + " not found");
                key = null;
                valueFilterConfig = null;
            }
            if (key != null && valueFilterConfig != null) {
                editorSettings.setKey(key, new FilterConfigEncoder().encode(valueFilterConfig));
            }
            for (final FilterConfigListener listener : configListeners) {
                listener.configChanged(filterConfigChangeType, filterConfig);
            }
        }
 
    };
 
    public DefaultFilterControl(@NotNull final NamedFilter filterList, @NotNull final EditorSettings editorSettings) {
        this.filterList = filterList;
        filterOutConfig = filterList.createConfig();
        this.editorSettings = editorSettings;
        highlightConfig = new NamedFilterConfig[MAX_HIGHLIGHT];
        for (int i = 0; i < MAX_HIGHLIGHT; i++) {
            highlightConfig[i] = filterList.createConfig();
        }
        filterOutConfig.addConfigChangeListener(filterConfigListener);
        for (int i = 0; i < MAX_HIGHLIGHT; i++) {
            highlightConfig[i].addConfigChangeListener(filterConfigListener);
        }
 
        final FilterConfigDecoder decoder = new FilterConfigDecoder();
        decoder.decode(editorSettings.getKey(EditorSettingsKey.ANALYZE_FILTER_OUT, ""), filterOutConfig);
        decoder.decode(editorSettings.getKey(EditorSettingsKey.ANALYZE_HIGHLIGHT0, ""), highlightConfig[0]);
        decoder.decode(editorSettings.getKey(EditorSettingsKey.ANALYZE_HIGHLIGHT1, ""), highlightConfig[1]);
        decoder.decode(editorSettings.getKey(EditorSettingsKey.ANALYZE_HIGHLIGHT2, ""), highlightConfig[2]);
    }
 
    @Override
    public void addConfigListener(@NotNull final FilterConfigListener listener) {
        configListeners.add(listener);
    }
 
    @Override
    public void removeConfigListener(@NotNull final FilterConfigListener listener) {
        configListeners.remove(listener);
    }
 
    @Override
    public void createMenuEntries(@NotNull final JMenu menu) {
        final JMenuItem menuItem = new MenuItemCreator(filterOutConfig).getMenuItem();
        menuItem.setText(ActionBuilderUtils.getString(ACTION_BUILDER, "filterView.text"));
        menu.add(menuItem);
        menu.addSeparator();
        for (int i = 0; i < MAX_HIGHLIGHT; i++) {
            final JMenuItem menuItem2 = new MenuItemCreator(highlightConfig[i]).getMenuItem();
            menuItem2.setText(ActionBuilderUtils.format(ACTION_BUILDER, "filterViewHighlight.text", i));
            menu.add(menuItem2);
        }
    }
 
    @Override
    public void newSquare(@NotNull final FilterState filterState) {
        for (int i = 0; i < MAX_HIGHLIGHT; i++) {
            if (highlightConfig[i].isEnabled()) {
                filterList.reset(highlightConfig[i]);
            }
        }
        filterState.reset();
    }
 
    @Override
    public boolean isHighlightedSquare(@NotNull final FilterState filterState, final int path) {
        return highlightConfig[path].isEnabled() && filterState.isHighlightedSquare(path);
    }
 
    @Override
    public void objectInSquare(@NotNull final FilterState filterState, @NotNull final G gameObject) {
        for (int i = 0; i < MAX_HIGHLIGHT; i++) {
            if (highlightConfig[i].isEnabled()) {
                if (!filterState.isHighlightedSquare(i)) {
                    filterState.setHighlightedSquare(i, filterList.match(highlightConfig[i], gameObject));
                }
            }
        }
    }
 
    @Override
    public boolean canShow(@NotNull final G gameObject) {
        return !filterOutConfig.isEnabled() || filterList.canShow(gameObject, filterOutConfig);
    }
 
    @Override
    public void addFilter(@NotNull final String name, @NotNull final Filter<?, ?> filter) {
        filterList.addFilter(name, filter);
    }
 
    @Override
    public void removeFilter(@NotNull final String name) {
        filterList.removeFilter(name);
    }
 
    private static boolean isFilterConfig(@NotNull final FilterConfig<?, ?> filterConfig, @NotNull final NamedFilterConfig expectedFilterConfig) {
        if (filterConfig == expectedFilterConfig) {
            return true;
        }
        for (final FilterConfig<?, ?> subFilterConfig : expectedFilterConfig.getEntries().values()) {
            if (filterConfig == subFilterConfig) {
                return true;
            }
        }
        return false;
    }
 
}