Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

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

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

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

/*

 * AUTHORS (In addition to CIT):

 * 2010 {}  {{Task}}

 */

package org.gvsig.fmap.mapcontrol.dal.feature.swing;

import javax.swing.DefaultListSelectionModel;

import javax.swing.ListSelectionModel;

import javax.swing.event.EventListenerList;

import javax.swing.event.ListSelectionEvent;

import javax.swing.event.ListSelectionListener;

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.exception.ConcurrentDataModificationException;

import org.gvsig.fmap.mapcontrol.dal.feature.swing.table.FeatureTableModel;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.Observer;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * @author 2010- C?sar Ordi?ana - gvSIG team

 */

@SuppressWarnings("Convert2Lambda")

public class FeatureSelectionModel implements ListSelectionModel, Observer {

  private static final Logger LOGGER= LoggerFactory.getLogger(FeatureSelectionModel.class);

  protected EventListenerList listenerList = new EventListenerList();

  private final FeatureTableModel featureTableModel;

  private int selectionMode = SINGLE_INTERVAL_SELECTION;

  private boolean isAdjusting = false;

  private int anchor = -1;

  private int lead = -1;

  private int currentFirst = -1;

  private int currentLast = -1;

  private ListSelectionModel selectionModelDelegated;

  /**

   * Creates a new {@link FeatureSelectionModel} with a

   * {@link FeatureTableModel} used to get the {@link Feature}s by position in

   * the table.

   *

   * @param featureTableModel to get Features from

   * @throws DataException if there is an error getting the store selection

   */

  @SuppressWarnings("LeakingThisInConstructor")

  public FeatureSelectionModel(FeatureTableModel featureTableModel)

          throws DataException {

    this.featureTableModel = featureTableModel;

    FeatureStore store = this.featureTableModel.getFeatureStore();

    store.addObserver(this);

    if( !store.getFeatureSelection().isAvailable() ) {

      this.selectionModelDelegated = new DefaultListSelectionModel();

    }

  }

  @Override

  public int getAnchorSelectionIndex() {

    if( this.selectionModelDelegated!=null ) {

      return this.selectionModelDelegated.getAnchorSelectionIndex();

    }

    return anchor;

  }

  @Override

  public int getLeadSelectionIndex() {

    if( this.selectionModelDelegated!=null ) {

      return this.selectionModelDelegated.getLeadSelectionIndex();

    }

    return lead;

  }

  @Override

  public int getMaxSelectionIndex() {

    if( this.selectionModelDelegated!=null ) {

      return this.selectionModelDelegated.getMaxSelectionIndex();

    }

    int resp = this.getSelectionIndex(true);

    return resp;

    /*

             *

             * The call to "featureTableModel.getFeatureAt(i)"

             * causes a lot of reloadPage all over

             *

                FeatureSelection selection = getFeatureSelection();

                try {

                        if (!selection.isEmpty()) {

                                for (int i = featureTableModel.getRowCount() - 1; i >= 0; i--) {

                                        if (selection.isSelected(featureTableModel.getFeatureAt(i))) {

                                                return i;

                                        }

                                }

                        }

                } catch (DataException e) {

                        throw new SelectionChangeException(e);

                }

                return -1;

     */

  }

  @Override

  public int getMinSelectionIndex() {

    if( this.selectionModelDelegated!=null ) {

      return this.selectionModelDelegated.getMinSelectionIndex();

    }

    int resp = this.getSelectionIndex(false);

    return resp;

    /*

             *

         * The call to "featureTableModel.getFeatureAt(i)"

         * causes a lot of reloadPage all over

             *

                try {

                    int ii = 0;

                    FeatureSelection selection = this.getFeatureSelection();

            for (int i = 0; i < featureTableModel.getRowCount(); i++) {

                if (selection.isSelected(featureTableModel.getFeatureAt(i))) {

                    ii = i;

                }

            }

                } catch (Exception e) {

                        throw new SelectionChangeException(e);

                }

     */

  }

  @Override

  @SuppressWarnings("UnnecessaryReturnStatement")

  public void insertIndexInterval(int index, int length, boolean before) {

    if( this.selectionModelDelegated!=null ) {

      this.selectionModelDelegated.insertIndexInterval(index, length, before);

      return;

    }

    // Nothing to do

  }

  @Override

  @SuppressWarnings("UnnecessaryReturnStatement")

  public void removeIndexInterval(int index0, int index1) {

    if( this.selectionModelDelegated!=null ) {

      this.selectionModelDelegated.removeIndexInterval(index0, index1);

      return;

    }

    // Nothing to do

  }

  @Override

  public void setAnchorSelectionIndex(int index) {

    if( this.selectionModelDelegated!=null ) {

      this.selectionModelDelegated.setAnchorSelectionIndex(index);

      return;

    }

    this.anchor = index;

  }

  @Override

  public void setLeadSelectionIndex(int index) {

    if( this.selectionModelDelegated!=null ) {

      this.selectionModelDelegated.setLeadSelectionIndex(index);

      return;

    }

    this.lead = index;

  }

  @Override

  public void addSelectionInterval(int index0, int index1) {

    if( this.selectionModelDelegated!=null ) {

      this.selectionModelDelegated.addSelectionInterval(index0, index1);

      return;

    }

    if ( featureTableModel.isSelectionLocked() ) {

       return;

    }

    doWithSelection(new FeatureSelectionOperation() {

      @Override

      public void doWithSelection(FeatureSelection selection, int first,

              int last) throws DataException {

        for (int i = first; i <= last; i++) {

          Feature feature = getFeature(i);

          if (!selection.isSelected(feature)) {

            selection.select(feature);

          }

        }

      }

    }, index0, index1, true);

  }

  @Override

  public void setSelectionInterval(int index0, int index1) {

    if( this.selectionModelDelegated!=null ) {

      this.selectionModelDelegated.setSelectionInterval(index0, index1);

      return;

    }

    if ( featureTableModel.isSelectionLocked() ) {

       return;

    }

    doWithSelection(new FeatureSelectionOperation() {

      @Override

      public void doWithSelection(FeatureSelection selection, int first,

              int last) throws DataException {

        selection.deselectAll();

        for (int i = first; i <= last; i++) {

          Feature feature = getFeature(i);

          selection.select(feature);

        }

      }

    }, index0, index1, true);

  }

  @Override

  public void removeSelectionInterval(int index0, int index1) {

    if( this.selectionModelDelegated!=null ) {

      this.selectionModelDelegated.removeSelectionInterval(index0, index1);

      return;

    }

    if ( featureTableModel.isSelectionLocked() ) {

       return;

    }

    doWithSelection(new FeatureSelectionOperation() {

      @Override

      public void doWithSelection(FeatureSelection selection, int first,

              int last) throws DataException {

        for (int i = first; i <= last; i++) {

          Feature feature = getFeature(i);

          if (selection.isSelected(feature)) {

            selection.deselect(feature);

          }

        }

      }

    }, index0, index1, false);

  }

  @Override

  public void clearSelection() {

    if( this.selectionModelDelegated!=null ) {

      this.selectionModelDelegated.clearSelection();

      return;

    }

    if ( featureTableModel.isSelectionLocked() ) {

       return;

    }

    try {

      getFeatureSelection().deselectAll();

    } catch (DataException e) {

      throw new SelectionChangeException(e);

    }

  }

  @Override

  public boolean isSelectedIndex(int index) {

    if( this.selectionModelDelegated!=null ) {

      return this.selectionModelDelegated.isSelectedIndex(index);

    }

    if (index == -1) {

      return false;

    }

    Feature feature = featureTableModel.getFeatureAt(index);

    return getFeatureSelection().isSelected(feature);

  }

  @Override

  public boolean isSelectionEmpty() {

    if( this.selectionModelDelegated!=null ) {

      return this.selectionModelDelegated.isSelectionEmpty();

    }

    try {

      return getFeatureSelection().isEmpty();

    } catch (Exception ex) {

      throw new SelectionChangeException(ex);

    }

  }

  @Override

  public boolean getValueIsAdjusting() {

    if( this.selectionModelDelegated!=null ) {

      return this.selectionModelDelegated.getValueIsAdjusting();

    }

    return isAdjusting;

  }

  @Override

  public void setValueIsAdjusting(boolean valueIsAdjusting) {

    if( this.selectionModelDelegated!=null ) {

      this.selectionModelDelegated.setValueIsAdjusting(valueIsAdjusting);

      return;

    }

    if (this.isAdjusting != valueIsAdjusting) {

      this.isAdjusting = valueIsAdjusting;

      if (this.isAdjusting) {

        getFeatureSelection().beginComplexNotification();

      } else {

        getFeatureSelection().endComplexNotification();

      }

    }

  }

  @Override

  public int getSelectionMode() {

    if( this.selectionModelDelegated!=null ) {

      return this.selectionModelDelegated.getSelectionMode();

    }

    return selectionMode;

  }

  @Override

  public void setSelectionMode(int selectionMode) {

    if( this.selectionModelDelegated!=null ) {

      this.selectionModelDelegated.setSelectionMode(selectionMode);

      return ;

    }

    this.selectionMode = selectionMode;

  }

  @Override

  public void addListSelectionListener(ListSelectionListener listener) {

    if( this.selectionModelDelegated!=null ) {

      this.selectionModelDelegated.addListSelectionListener(listener);

      return ;

    }

    listenerList.add(ListSelectionListener.class, listener);

  }

  @Override

  public void removeListSelectionListener(ListSelectionListener listener) {

    if( this.selectionModelDelegated!=null ) {

      this.selectionModelDelegated.removeListSelectionListener(listener);

      return ;

    }

    listenerList.remove(ListSelectionListener.class, listener);

  }

  @Override

  public void update(Observable observable, Object notification) {

    if (notification instanceof FeatureStoreNotification) {

      FeatureStoreNotification fnotification

              = (FeatureStoreNotification) notification;

      if (!fnotification.getSource().equals(getFeatureStore())) {

        return;

      }

      if (FeatureStoreNotification.SELECTION_CHANGE.equals(fnotification.getType())) {

        try {

          fireValueChanged(-1, -1, false);

        } catch (ConcurrentDataModificationException e) {

          LOGGER.warn("The store has been updated and the selection can not be refreshed", e);

        }

      }

    }

  }

  private FeatureSelection getFeatureSelection() {

    try {

      return (FeatureSelection) getFeatureStore().getSelection();

    } catch (DataException ex) {

      throw new SelectionChangeException(ex);

    }

  }

  /**

   * @param operation

   * @param index0

   * @param index1

   */

  private void doWithSelection(FeatureSelectionOperation operation,

          int index0, int index1, boolean select) {

    // Set the anchor and lead

    anchor = index0;

    lead = index1;

    // As index0 <= index1 is no guaranteed, calculate the first and second

    // values

    int first = (index0 <= index1) ? index0 : index1;

    int last = (index0 <= index1) ? index1 : index0;

    //If the new selection is not updated don't continue

    if ((currentFirst == first) && (currentLast == last)) {

      return;

    }

    int oldFirst = currentFirst;

    int oldLast = currentLast;

    currentFirst = first;

    currentLast = last;

    FeatureSelection selection = getFeatureSelection();

    // Perform the selection operation into a complex notification

    selection.beginComplexNotification();

    try {

      // Is a full select or deselect

      if (first == 00 && last == featureTableModel.getRowCount() - 1) {

        if (select) {

          selection.selectAll();

        } else {

          selection.deselectAll();

        }

      } else {

        operation.doWithSelection(selection, first, last);

      }

    } catch (DataException e) {

      throw new SelectionChangeException(e);

    } finally {

      selection.endComplexNotification();

    }

    // Para no lanzar dos veces el fireValueChanged sobre las mismas filas de la selecci?n

    if (oldFirst <= first) {

      if (oldLast < first) { //No intersectan los rangos

        fireValueChanged(oldFirst, oldLast, isAdjusting);

        fireValueChanged(first, last, isAdjusting);

      } else { // Intersectan los rangos oldFirst - first - ...

        if (last > oldLast) { // Intersectan los rangos oldFirst - first - oldLast - last

          fireValueChanged(oldFirst, last, isAdjusting);

        } else { // Intersectan los rangos oldFirst - first - last - oldLast

          fireValueChanged(oldFirst, oldLast, isAdjusting);

        }

      }

    }

    if (first <= oldFirst) {

      if (last < oldFirst) { //No intersectan los rangos

        fireValueChanged(oldFirst, oldLast, isAdjusting);

        fireValueChanged(first, last, isAdjusting);

      } else { // Intersectan los rangos first - oldFirst - ...

        if (last > oldLast) { // Intersectan los rangos first - oldFirst - oldLast - last

          fireValueChanged(first, last, isAdjusting);

        } else { // Intersectan los rangos first - oldFirst - last - oldLast

          fireValueChanged(first, oldLast, isAdjusting);

        }

      }

    }

  }

  /**

   * Returns a Feature by table row position.

   */

  private Feature getFeature(int index) {

    return featureTableModel.getFeatureAt(index);

  }

  /**

   * Returns the FeatureStore.

   */

  private FeatureStore getFeatureStore() {

    return featureTableModel.getFeatureStore();

  }

  /**

   * @param firstIndex the first index in the interval

   * @param lastIndex the last index in the interval

   * @param isAdjusting true if this is the final change in a series of

   * adjustments

   * @see EventListenerList

   */

  protected void fireValueChanged(int firstIndex, int lastIndex,

          boolean isAdjusting) {

    Object[] listeners = listenerList.getListenerList();

    ListSelectionEvent e = null;

    for (int i = listeners.length - 2; i >= 0; i -= 2) {

      if (listeners[i] == ListSelectionListener.class) {

        if (e == null) {

          e

                  = new ListSelectionEvent(this, firstIndex, lastIndex,

                          isAdjusting);

        }

        ((ListSelectionListener) listeners[i + 1]).valueChanged(e);

      }

    }

  }

  private interface FeatureSelectionOperation {

    void doWithSelection(FeatureSelection selection, int first, int last)

            throws DataException;

  }

  /**

   *

   * Return the index of the the first (last) selected feature

   *

   * @param last whether to return the index of the last selected feature

   * @return

   */

  private int getSelectionIndex(boolean last) {

    int ind = -1;

    int resp = -1;

    FeatureSet fs = null;

    DisposableIterator diter = null;

    try {

      FeatureSelection selection = getFeatureSelection();

      if (!selection.isEmpty()) {

        FeatureStore store = getFeatureStore();

        FeatureQuery query = store.createFeatureQuery();

        query.addEssentialAttributeNames(store);

        fs = store.getFeatureSet(query);

        diter = fs.fastIterator();

        Feature feat;

        while (diter.hasNext()) {

          ind++;

          feat = (Feature) diter.next();

          if (selection.isSelected(feat)) {

            resp = ind;

            if (!last) {

              break;

            }

          }

        }

      }

    } catch (DataException e) {

      throw new SelectionChangeException(e);

    } finally {

      if (diter != null) {

        diter.dispose();

      }

      if (fs != null) {

        fs.dispose();

      }

    }

    return resp;

  }

}