AbstractMapViewSettings.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.model.mapviewsettings;
 
import java.util.Collection;
import java.util.concurrent.CopyOnWriteArrayList;
import net.sf.gridarta.model.baseobject.BaseObject;
import net.sf.gridarta.model.match.ViewGameObjectMatcherManager;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public abstract class AbstractMapViewSettings implements MapViewSettings {
 
    private boolean gridVisible = loadGridVisible();
 
    private boolean lightVisible = loadLightVisible();
 
    private boolean smoothing = loadSmoothing();
 
    private boolean tileStretching = loadTileStretching();
 
    private boolean doubleFaces = loadDoubleFaces();
 
    private int alphaType = loadAlphaType();
 
    private int editType = loadEditType();
 
    private boolean autojoin = loadAutojoin();
 
    // TODO: use this field (it looks unused but usage is planned)
    @Nullable
    private final ViewGameObjectMatcherManager transparencyManager = null;
 
    // TODO: use this field (it looks unused but usage is planned)
    @Nullable
    private final ViewGameObjectMatcherManager visibilityManager = null;
 
    @NotNull
    private final Collection<MapViewSettingsListener> listenerList = new CopyOnWriteArrayList<>();
 
    @Override
    public void addMapViewSettingsListener(@NotNull final MapViewSettingsListener listener) {
        listenerList.add(listener);
    }
 
    @Override
    public void removeMapViewSettingsListener(@NotNull final MapViewSettingsListener listener) {
        listenerList.remove(listener);
    }
 
    @Override
    public boolean isGridVisible() {
        return gridVisible;
    }
 
    @Override
    public void setGridVisible(final boolean gridVisible) {
        if (this.gridVisible == gridVisible) {
            return;
        }
 
        this.gridVisible = gridVisible;
        saveGridVisible(gridVisible);
        fireGridVisibleChanged();
    }
 
    @Override
    public boolean isLightVisible() {
        return lightVisible;
    }
 
    @Override
    public void setLightVisible(final boolean lightVisible) {
        if (this.lightVisible == lightVisible) {
            return;
        }
 
        this.lightVisible = lightVisible;
        saveLightVisible(lightVisible);
        fireLightVisibleChanged();
    }
 
    @Override
    public boolean isSmoothing() {
        return smoothing;
    }
 
    @Override
    public void setSmoothing(final boolean smoothing) {
        if (this.smoothing == smoothing) {
            return;
        }
 
        this.smoothing = smoothing;
        saveSmoothing(smoothing);
        fireSmoothingChanged();
    }
 
    @Override
    public boolean isTileStretching() {
        return tileStretching;
    }
 
    @Override
    public void setTileStretching(final boolean tileStretching) {
        if (this.tileStretching == tileStretching) {
            return;
        }
 
        this.tileStretching = tileStretching;
        saveTileStretching(tileStretching);
        fireTileStretchingChanged();
    }
 
    @Override
    public boolean isDoubleFaces() {
        return doubleFaces;
    }
 
    @Override
    public void setDoubleFaces(final boolean doubleFaces) {
        if (this.doubleFaces == doubleFaces) {
            return;
        }
 
        this.doubleFaces = doubleFaces;
        saveDoubleFaces(doubleFaces);
        fireDoubleFacesChanged();
    }
 
    @Override
    public boolean isAlphaType(final int v) {
        return v > 0 && (alphaType & v) == v;
    }
 
    @Override
    public void setAlphaType(final int v, final boolean state) {
        if (state) {
            alphaType |= v;
        } else {
            alphaType &= ~v;
        }
        saveAlphaType(alphaType);
        fireAlphaTypeChanged();
    }
 
    @Override
    public void clearAlpha() {
        alphaType = 0;
        saveAlphaType(alphaType);
        fireAlphaTypeChanged();
    }
 
    @Override
    public int getEditType() {
        return editType;
    }
 
    private void setEditType(final int editType) {
        if ((this.editType & editType) == editType) {
            return;
        }
 
        this.editType |= editType;
        fireEditTypeChanged();
    }
 
    @Override
    public void unsetEditType(final int editType) {
        if ((this.editType & editType) == 0) {
            return;
        }
 
        this.editType &= ~editType;
        fireEditTypeChanged();
    }
 
    @Override
    public boolean isEditType(final int editType) {
        final int mask = editType == 0 ? BaseObject.EDIT_TYPE_NONE : editType;
        return (this.editType & mask) != 0;
    }
 
    @Override
    public boolean isEditType(@NotNull final BaseObject<?, ?, ?, ?> gameObject) {
        return editType == 0 || isEditType(gameObject.getEditType());
    }
 
    @Override
    public boolean isEditTypeSet() {
        return (editType & BaseObject.EDIT_TYPE_NONE) == 0 && editType != 0;
    }
 
    @Override
    public void toggleEditType(final int editType) {
        if (isEditType(editType)) {
            unsetEditType(editType);
        } else {
            setEditType(editType);
        }
    }
 
    @Override
    public boolean isAutojoin() {
        return autojoin;
    }
 
    @Override
    public void setAutojoin(final boolean autojoin) {
        if (this.autojoin == autojoin) {
            return;
        }
 
        this.autojoin = autojoin;
        saveAutojoin(autojoin);
        fireAutojoinChanged();
    }
 
    private void fireGridVisibleChanged() {
        for (final MapViewSettingsListener listener : listenerList) {
            listener.gridVisibleChanged(gridVisible);
        }
    }
 
    private void fireLightVisibleChanged() {
        for (final MapViewSettingsListener listener : listenerList) {
            listener.lightVisibleChanged(lightVisible);
        }
    }
 
    private void fireSmoothingChanged() {
        for (final MapViewSettingsListener listener : listenerList) {
            listener.smoothingChanged(smoothing);
        }
    }
 
    private void fireTileStretchingChanged() {
        for (final MapViewSettingsListener listener : listenerList) {
            listener.tileStretchingChanged(tileStretching);
        }
    }
 
    private void fireDoubleFacesChanged() {
        for (final MapViewSettingsListener listener : listenerList) {
            listener.doubleFacesChanged(doubleFaces);
        }
    }
 
    private void fireAlphaTypeChanged() {
        for (final MapViewSettingsListener listener : listenerList) {
            listener.alphaTypeChanged(alphaType);
        }
    }
 
    private void fireEditTypeChanged() {
        for (final MapViewSettingsListener listener : listenerList) {
            listener.editTypeChanged(editType);
        }
    }
 
    private void fireAutojoinChanged() {
        for (final MapViewSettingsListener listener : listenerList) {
            listener.autojoinChanged(autojoin);
        }
    }
 
    protected abstract boolean loadGridVisible();
 
    protected abstract void saveGridVisible(boolean gridVisible);
 
    protected abstract boolean loadLightVisible();
 
    protected abstract void saveLightVisible(boolean lightVisible);
 
    protected abstract boolean loadSmoothing();
 
    protected abstract void saveSmoothing(boolean smoothing);
 
    protected abstract boolean loadTileStretching();
 
    protected abstract void saveTileStretching(boolean tileStretching);
 
    protected abstract boolean loadDoubleFaces();
 
    protected abstract void saveDoubleFaces(boolean doubleFaces);
 
    protected abstract int loadAlphaType();
 
    protected abstract void saveAlphaType(int alphaType);
 
    protected abstract int loadEditType();
 
    protected abstract boolean loadAutojoin();
 
    protected abstract void saveAutojoin(boolean autojoin);
 
}