| gvSIG desktop 1

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Gobernment (CIT)

 *

 * 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.

 *

 */

/*

 * AUTHORS (In addition to CIT):

 * 2008 {DiSiD Technologies}  {Implement data selection}

 */

package org.gvsig.fmap.dal.feature.impl;

import java.util.*;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreNotification;

import org.gvsig.fmap.dal.exceptions.DataException;

import org.gvsig.fmap.dal.feature.FeatureReference;

import org.gvsig.fmap.dal.feature.FeatureReferenceSelection;

import org.gvsig.fmap.dal.feature.FeatureStoreNotification;

import org.gvsig.fmap.dal.feature.impl.commands.AbstractCommandsRecord;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.observer.WeakReferencingObservable;

import org.gvsig.tools.observer.impl.BaseWeakReferencingObservable;

import org.gvsig.tools.persistence.AbstractPersistenceManager;

import org.gvsig.tools.persistence.PersistenceException;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.visitor.Visitor;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Default implementation of a FeatureReferenceSelection, based on the usage of

 * a java.util.Set to store individual selected or not selected

 * FeatureReferences, depending on the usage of the {@link #reverse()} method.

 * 

 * @author <a href="mailto:cordin@disid.com">C?sar Ordi?ana</a>

 */

public class DefaultFeatureReferenceSelection extends

        BaseWeakReferencingObservable implements FeatureReferenceSelection {

    private static final Logger LOGGER = LoggerFactory

            .getLogger(DefaultFeatureReferenceSelection.class);

    private Set selected = new HashSet();

    /**

     * Sets how the Set of selected values has to be dealt.

     * <p>

     * If selected is FALSE, then values into the Set are the selected ones,

     * anything else is not selected.

     * </p>

     * <p>

     * If selected is TRUE, then values into the Set are values not selected,

     * anything else is selected.

     * </p>

     */

    private boolean reversed = false;

    private long totalSize;

    private DefaultFeatureStore featureStore;

    /**

     * Creates a new Selection with the total size of Features from which the

     * selection will be performed.

     * 

     * @param featureStore

     *            the FeatureStore of the selected FeatureReferences

     * @throws DataException

     *             if there is an error while getting the total number of

     *             Features of the Store.

     */

    public DefaultFeatureReferenceSelection(DefaultFeatureStore featureStore)

            throws DataException {

        super();

        this.featureStore = featureStore;

        this.totalSize = getFeatureStoreTotalSize();

    }

    public boolean select(FeatureReference reference) {

        if (getFeatureStore().isEditing()) {

            getCommands().select(this, reference);

        }

        boolean change = false;

        if (reversed) {

            change = selected.remove(reference);

        } else {

            change = selected.add(reference);

        }

        if (change) {

            notifyObservers(DataStoreNotification.SELECTION_CHANGE);

        }

        return change;

    }

    public boolean deselect(FeatureReference reference) {

        if (getFeatureStore().isEditing()) {

            getCommands().deselect(this, reference);

        }

        boolean change = false;

        if (reversed) {

            change = selected.add(reference);

        } else {

            change = selected.remove(reference);

        }

        if (change) {

            notifyObservers(DataStoreNotification.SELECTION_CHANGE);

        }

        return change;

    }

    public void selectAll() throws DataException {

        if (getFeatureStore().isEditing()) {

            getCommands().startComplex("_selectionSelectAll");

            getCommands().selectAll(this);

        }

        if (!reversed) {

            reverse();

        }

        selected.clear();

        if (getFeatureStore().isEditing()) {

            getCommands().endComplex();

        }

        notifyObservers(DataStoreNotification.SELECTION_CHANGE);

    }

    public void deselectAll() throws DataException {

        if (getFeatureStore().isEditing()) {

            getCommands().startComplex("_selectionDeselectAll");

            getCommands().deselectAll(this);

        }

        if (reversed) {

            reverse();

        }

        selected.clear();

        if (getFeatureStore().isEditing()) {

            getCommands().endComplex();

        }

        notifyObservers(DataStoreNotification.SELECTION_CHANGE);

    }

    public boolean isSelected(FeatureReference reference) {

        if (reversed) {

            return !selected.contains(reference);

        } else {

            return selected.contains(reference);

        }

    }

    public void reverse() {

        if (getFeatureStore().isEditing()) {

            getCommands().selectionReverse(this);

        }

        reversed = !reversed;

        notifyObservers(DataStoreNotification.SELECTION_CHANGE);

    }

    public long getSelectedCount() {

        if (reversed) {

            // If the FeatureManager is present, and the store is in editing

            // mode, the number of current Features may have changed.

            FeatureManager featureManager = getFeatureStore()

                    .getFeatureManager();

            if (featureStore.isEditing() && featureManager != null) {

                return totalSize - selected.size()

                        + featureManager.getDeltaSize();

            } else {

                return totalSize - selected.size();

            }

        } else {

            return selected.size();

        }

    }

    public Iterator referenceIterator() {

        return Collections.unmodifiableSet(selected).iterator();

    }

    public void dispose() {

        try {

            deselectAll();

        } catch (DataException ex) {

            LOGGER.error("Error on dispose(), deselecting all selected values",

                    ex);

        }

    }

    public boolean isFromStore(DataStore store) {

        return featureStore.equals(store);

    }

    public void accept(Visitor visitor) throws BaseException {

        for (Iterator iter = selected.iterator(); iter.hasNext();) {

            visitor.visit(iter.next());

        }

    }

    public void update(WeakReferencingObservable observable, Object notification) {

        // If a Feature is deleted, remove it from the selection Set.

        if (notification instanceof FeatureStoreNotification) {

            FeatureStoreNotification storeNotif = (FeatureStoreNotification) notification;

            if (FeatureStoreNotification.AFTER_DELETE

                    .equalsIgnoreCase(storeNotif.getType())) {

                selected.remove(storeNotif.getFeature().getReference());

            }

        }

    }

    /**

     * Returns the FeatureStore of the selected FeatureReferences.

     * 

     * @return the featureStore

     */

    protected DefaultFeatureStore getFeatureStore() {

        return featureStore;

    }

    public void loadState(PersistentState state) throws PersistenceException {

        state.set("reversed", reversed);

        state.set("totalSize", totalSize);

        state.set("selected", selected.iterator());

    }

    public void setState(PersistentState state) throws PersistenceException {

        this.reversed = state.getBoolean("reversed");

        this.totalSize = state.getLong("totalSize");

        Iterator it = state.getIterator("selected");

        // FIXME: Esto no funcionara bien. Hay que darle una pensada mas.

        while (it.hasNext()) {

            DefaultFeatureReference ref = new DefaultFeatureReference(

                    this.featureStore);

            ref.setState((PersistentState) it.next());

            this.selected.add(ref);

        }

    }

    public PersistentState getState() throws PersistenceException {

        return AbstractPersistenceManager.getState(this);

    }

    private long getFeatureStoreTotalSize() throws DataException {

        return getFeatureStore().getFeatureSet().getSize();

    }

    protected AbstractCommandsRecord getCommands() {

        try {

            return (AbstractCommandsRecord) getFeatureStore()

                    .getCommandsRecord();

        } catch (DataException e) {

            // Ignore

            return null;

        }

    }

}