| 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.data.feature.impl;

import java.util.Collections;

import java.util.HashSet;

import java.util.Iterator;

import java.util.Set;

import org.gvsig.fmap.data.DataStore;

import org.gvsig.fmap.data.DataStoreNotification;

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

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

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

import org.gvsig.fmap.data.feature.FeatureStore;

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

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

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.observer.Observable;

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

import org.gvsig.tools.persistence.AbstractPersistenceManager;

import org.gvsig.tools.persistence.PersistenceException;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.visitor.Visitor;

/**

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

        implements FeatureReferenceSelection {

    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.

     *

     * Takes by default Integer.MAX_VALUE as the total size of elements that may

     * be selected.

     *

     * @param featureStore

     *            the FeatureStore of the selected FeatureReferences

     */

    public DefaultFeatureReferenceSelection(FeatureStore featureStore) {

        this(featureStore, Long.MAX_VALUE);

    }

    /**

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

     * selection will be performed.

     *

     * Takes by default Integer.MAX_VALUE as the total size of elements that may

     * be selected.

     *

     * @param featureStore

     *            the FeatureStore of the selected FeatureReferences

     * @param totalSize

     *            the total size of elements (selected and not selected)

     */

    public DefaultFeatureReferenceSelection(FeatureStore featureStore,

            long totalSize) {

        super();

        this.totalSize = totalSize;

        this.featureStore = (DefaultFeatureStore) featureStore;

    }

    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() {

            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() {

            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);

    }

    /**

     * Usage of this method only has sense if you don't use the

     * {@link #reverse()} method or if you use the Constructor with the total

     * size parameter. Otherwise, it will return Long.MAX_VALUE minus the number

     * of selected values if the selection is reversed.

     */

    public long getSelectedCount() {

        if (reversed) {

            return totalSize - selected.size();

        } else {

            return selected.size();

        }

    }

    public Iterator referenceIterator() {

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

    }

    public void dispose() {

        deselectAll();

    }

    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(Observable 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 FeatureStore 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);

        }

    protected AbstractCommandsRecord getCommands() {

                try {

                        return (AbstractCommandsRecord) getFeatureStore()

                                        .getCommandsRecord();

                } catch (DataException e) {

                        // Ignore

                        return null;

                }

        }

}