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

 * 2008 {DiSiD Technologies}  {Create a JTable TableModel for a FeatureCollection}

 */

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

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.SwingUtilities;

import javax.swing.Timer;

import javax.swing.event.TableModelEvent;

import javax.swing.table.AbstractTableModel;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.EditingNotification;

import org.gvsig.fmap.dal.EditingNotificationManager;

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.paging.FeaturePagingHelper;

import org.gvsig.fmap.dal.swing.DALSwingLocator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dispose.SupportDisposable;

import org.gvsig.tools.dispose.impl.DisposableHelper;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.logger.FilteredLogger;

import org.gvsig.tools.observer.ComplexNotification;

import org.gvsig.tools.observer.ComplexObserver;

import org.gvsig.tools.observer.Observable;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * TableModel to access data of Features.

 *

 * This table model can't handle a FeatureSet with more than Integer.MAX_VALUE

 * elements. In that case, only the first Integer.MAX_VALUE elements will be

 * shown.

 *

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

 */

@SuppressWarnings("UseSpecificCatch")

public class FeatureTableModel extends AbstractTableModel implements ComplexObserver, SupportDisposable {

    private static final Logger LOGGER = LoggerFactory

            .getLogger(FeatureTableModel.class);

    private static final long serialVersionUID = -2488157521902851301L;

    private FeaturePagingHelper pagingHelper;

    private final DisposableHelper disposableHelper;

    /**

     * Used to know if a modification in the FeatureStore is created by us.

     */

    private EditableFeature editableFeature;

    private boolean selectionLocked = false;

    private final FilteredLogger filterlogger;

    private static final int STATUS_OK = 0;

    private static final int STATUS_ERR_LOADFEATURES = 1;

    private static final int STATUS_ERR_LOADFEATURETYPE = 2;

    private int status;

    /**

     * Constructs a TableModel from the features of a FeatureStore, with the

     * default page size.

     *

     * @param featureStore to extract the features from

     * @param featureQuery the query to get the features from the store

     * @throws BaseException if there is an error reading data from the

     * FeatureStore

     */

    public FeatureTableModel(FeatureStore featureStore,

            FeatureQuery featureQuery) throws BaseException {

        this(featureStore, featureQuery, FeaturePagingHelper.DEFAULT_PAGE_SIZE);

    }

    /**

     * Constructs a TableModel from the features of a FeatureStore, with the

     * default page size.

     *

     * @param featureStore to extract the features from

     * @param featureQuery the query to get the features from the store

     * @param pageSize the number of elements per page data

     * @throws BaseException if there is an error reading data from the

     * FeatureStore

     */

    public FeatureTableModel(FeatureStore featureStore,

            FeatureQuery featureQuery, int pageSize) throws BaseException {

        this(DALLocator.getDataManager().createFeaturePagingHelper(

                featureStore, featureQuery, pageSize));

    }

    /**

     * Constructs a TableModel from a FeatureCollection and a Paging pagingHelper.

     *

     * @param helper

     */

    @SuppressWarnings("OverridableMethodCallInConstructor")

    protected FeatureTableModel(FeaturePagingHelper helper) {

        this.disposableHelper = new DisposableHelper(this);

        this.status = STATUS_OK;

        this.pagingHelper = helper;

        this.filterlogger = new FilteredLogger(LOGGER, "SimpleFeaturesTableModel", 30000L);

        initialize();

    }

    @Override

    public int getColumnCount() {

        switch(this.status) {

            case STATUS_OK:

            case STATUS_ERR_LOADFEATURES:

                break;

            case STATUS_ERR_LOADFEATURETYPE:

                return 0;

        }

        // Return the number of fields of the Features

        FeatureType featureType = getFeatureType();

        return featureType.size();

    }

    @Override

    public int getRowCount() {

        switch(this.status) {

            case STATUS_OK:

                break;

            case STATUS_ERR_LOADFEATURETYPE:

            case STATUS_ERR_LOADFEATURES:

                return 0;

        }

        // Return the total size of the collection

        // If the size is bigger than INTEGER.MAX_VALUE, return that instead

        try {

            long totalSize = getHelper().getTotalSize();

            if (totalSize > Integer.MAX_VALUE) {

                return Integer.MAX_VALUE;

            } else {

                return (int) totalSize;

            }

        } catch (ConcurrentDataModificationException e) {

            LOGGER.debug("Error while getting the total size of the set", e);

            this.delayAction.addAction(DelayAction.ACTION_RELOADALL);

            return 0;

        }

    }

    @Override

    public Object getValueAt(int rowIndex, int columnIndex) {

        switch(this.status) {

            case STATUS_OK:

                break;

            case STATUS_ERR_LOADFEATURETYPE:

            case STATUS_ERR_LOADFEATURES:

                return null;

        }

        // Get the Feature at row "rowIndex", and return the value of the

        // attribute at "columnIndex"

        try {

            Feature feature = getFeatureAt(rowIndex);

            if (feature == null) {

                return null;

            }

            Object value;

            value = getFeatureValue(feature, columnIndex);

            return value;

        } catch (Throwable ex) {

            filterlogger.warn("Not been able to retrieve feature value", ex);

            return null;

        }

    }

    /**

     * Returns the value for a row position.

     *

     * @param rowIndex the row position

     * @return the Feature

     */

    public Feature getFeatureAt(int rowIndex) {

        try {

            return getHelper().getFeatureAt(rowIndex);

        } catch (BaseException ex) {

            throw new GetFeatureAtException(rowIndex, ex);

        }

    }

    @Override

    public Class<?> getColumnClass(int columnIndex) {

        // Return the class of the FeatureAttributeDescriptor for the value

        FeatureAttributeDescriptor attributeDesc

                = internalGetFeatureDescriptorForColumn(columnIndex);

        if (attributeDesc == null) {

            return super.getColumnClass(columnIndex);

        }

        Class<?> clazz = attributeDesc.getObjectClass();

        return (clazz == null ? super.getColumnClass(columnIndex) : clazz);

    }

    @Override

    public String getColumnName(int column) {

        // Return the Feature attribute name

        FeatureAttributeDescriptor attributeDesc

                = internalGetFeatureDescriptorForColumn(column);

        return attributeDesc.getName();

    }

    @Override

    public boolean isCellEditable(int rowIndex, int columnIndex) {

        if (getFeatureStore().isEditing()) {

            FeatureAttributeDescriptor attributeDesc

                    = internalGetFeatureDescriptorForColumn(columnIndex);

            return !attributeDesc.isReadOnly();

        }

        return false;

    }

    @Override

    public void setValueAt(Object value, int rowIndex, int columnIndex) {

        // Get the feature at rowIndex

        Feature feature = getFeatureAt(rowIndex);

        // Only set the value if the feature exists

        if (feature != null) {

            // We only need to update if the value to set is not equal to the

            // current value

            Object currentValue = getFeatureValue(feature, columnIndex);

            if (value != currentValue

                    && (value == null || !value.equals(currentValue))) {

                try {

                    // Store the editable feature to ignore the related store

                    // change notification

                    editableFeature

                            = setFeatureValue(feature, columnIndex, value);

                    EditingNotificationManager editingNotificationManager = DALSwingLocator.getEditingNotificationManager();

                    EditingNotification notification = editingNotificationManager.notifyObservers(

                            this,

                            EditingNotification.BEFORE_UPDATE_FEATURE,

                            null,

                            this.getHelper().getFeatureStore(),

                            editableFeature);

                    if (notification.isCanceled()) {

                        return;

                    }

                    if (notification.shouldValidateTheFeature()) {

                        if (!editingNotificationManager.validateFeature(feature)) {

                            return;

                        }

                    }

                    this.getHelper().update(editableFeature);

                    // We'll have already received the event, so we can forget

                    // about it

                    getHelper().reloadCurrentPage();

                    fireTableCellUpdated(rowIndex, columnIndex);

                    editingNotificationManager.notifyObservers(

                            this,

                            EditingNotification.AFTER_UPDATE_FEATURE,

                            null,

                            this.getHelper().getFeatureStore(),

                            editableFeature);

                    editableFeature = null;

                } catch (BaseException ex) {

                    throw new SetFeatureValueException(rowIndex, columnIndex,

                            value, ex);

                } finally {

                    // Just in case

                    editableFeature = null;

                }

            }

        }

    }

    /**

     * Returns a reference to the Paging Helper used to load the data from the

     * DataStore.

     *

     * @return the paging pagingHelper

     */

    public FeaturePagingHelper getHelper() {

        return pagingHelper;

    }

    /**

     * Sets the FeatureType to show in the table. Used for FeatureStores with

     * many simultaneous FeatureTypes supported. Will cause a reload of the

     * current data.

     *

     * @param featureType the FeatureType of the Features

     */

    public void setFeatureType(FeatureType featureType) {

        getFeatureQuery().setFeatureType(featureType);

        reloadFeatures();

        //Selection must be locked to avoid losing it when the table is refreshed

        selectionLocked = true;

        //The table is refreshed

        try {

            fireTableStructureChanged();

        } catch (Exception e) {

            LOGGER.warn("Couldn't reload changed table");

        } finally {

            //The locked selection is unlocked.

            selectionLocked = false;

        }

    }

    /**

     * Sets that the selected Features get returned first.

     *

     * @param selectionUp

     */

    public void setSelectionUp(boolean selectionUp) {

        if (selectionUp) {

            delayAction.addAction(DelayAction.ACTION_ENABLE_SELECTION_UP);

        } else {

            delayAction.addAction(DelayAction.ACTION_DISABLE_SELECTION_UP);

        }

    }

    protected void fireTableChanged() {

//        LOGGER.info("fireTableChanged()");

        fireTableChanged(new TableModelEvent(this, 0, getRowCount() - 1));

    }

    public static class Bitmask  {

        private int mask;

        public Bitmask(int initialmask) {

            this.mask = initialmask;

        }

        public boolean isSetBit(int pos) {

            return (mask & (1<<pos)) != 0;

        }

        public boolean isSet(int bits) {

            return (mask & bits) == bits;

        }

        public boolean isSetAny() {

            return mask!=0;

        }

        public boolean isCleanAll() {

            return mask == 0;

        }

        public void set(int bits) {

            mask = mask | bits;

        }

        public int get() {

            return mask;

        }

        public void clear(int bits) {

            mask = ~bits & mask;

        }

        public void clearBit(int pos) {

            mask = ~(1<<pos) & mask;

        }

        public void clearAll() {

            mask = 0;

        }

    }

    private class DelayAction extends Timer implements ActionListener, Runnable {

        private static final int ACTION_NONE = 0;

        private static final int ACTION_RELOADALL = 1;

        private static final int ACTION_RELOAD_IF_FEATURE_COUNT_CHANGED = 2;

        private static final int ACTION_RELOAD_IF_FEATURE_UPDATED = 4;

        private static final int ACTION_RELOAD_IF_FEATURE_TYPE_CHANGED = 8;

        private static final int ACTION_RELOAD_FEATURE_TYPE = 16;

        private static final int ACTION_ENABLE_SELECTION_UP = 32;

        private static final int ACTION_RELOAD_ALL_FEATURES = 64;

        private static final int ACTION_DISABLE_SELECTION_UP = 128;

        private static final int ACTION_UPDATE_SELECTION = 256;

        private final Bitmask current_actions = new Bitmask(ACTION_NONE);

        private Feature feature;

        private FeatureType featureType;

        @SuppressWarnings("OverridableMethodCallInConstructor")

        public DelayAction() {

            super(1000, null);

            this.setRepeats(false);

            this.reset();

            this.addActionListener(this);

        }

        public final void reset() {

            this.current_actions.clearAll();

            this.feature = null;

            this.featureType = null;

        }

        @Override

        public void actionPerformed(ActionEvent ae) {

            this.run();

        }

        @SuppressWarnings("UnusedAssignment")

        private String getActionsLabel(Bitmask actions) {

            if( actions.isCleanAll() ) {

                return "NONE";

            }

            StringBuilder builder = new StringBuilder();

            boolean needSeparator = false;

            if( actions.isSet(ACTION_RELOADALL) ) {

                if( needSeparator ) {

                    builder.append("|");

                }

                needSeparator = true;

                builder.append("RELOADALL");

            }

            if( actions.isSet(ACTION_RELOAD_IF_FEATURE_COUNT_CHANGED) ) {

                if( needSeparator ) {

                    builder.append("|");

                }

                needSeparator = true;

                builder.append("RELOAD_IF_FEATURE_COUNT_CHANGED");

            }

            if( actions.isSet(ACTION_RELOAD_IF_FEATURE_UPDATED) ) {

                if( needSeparator ) {

                    builder.append("|");

                }

                needSeparator = true;

                builder.append("RELOAD_IF_FEATURE_UPDATED");

            }

            if( actions.isSet(ACTION_RELOAD_IF_FEATURE_TYPE_CHANGED) ) {

                if( needSeparator ) {

                    builder.append("|");

                }

                needSeparator = true;

                builder.append("RELOAD_IF_FEATURE_TYPE_CHANGED");

            }

            if( actions.isSet(ACTION_RELOAD_FEATURE_TYPE) ) {

                if( needSeparator ) {

                    builder.append("|");

                }

                needSeparator = true;

                builder.append("RELOAD_FEATURE_TYPE");

            }

            if( actions.isSet(ACTION_RELOAD_ALL_FEATURES) ) {

                if( needSeparator ) {

                    builder.append("|");

                }

                needSeparator = true;

                builder.append("RELOAD_ALL_FEATURES");

            }

            if( actions.isSet(ACTION_DISABLE_SELECTION_UP) ) {

                if( needSeparator ) {

                    builder.append("|");

                }

                needSeparator = true;

                builder.append("DISABLE_SELECTION_UP");

            }

            if( actions.isSet(ACTION_ENABLE_SELECTION_UP) ) {

                if( needSeparator ) {

                    builder.append("|");

                }

                needSeparator = true;

                builder.append("ENABLE_SELECTION_UP");

            }

            if( actions.isSet(ACTION_UPDATE_SELECTION) ) {

                if( needSeparator ) {

                    builder.append("|");

                }

                needSeparator = true;

                builder.append("UPDATE_SELECTION");

            }

            if( !needSeparator ) {

                builder.append(actions.get());

            }

            return builder.toString();

        }

        @Override

        public void run() {

            if (!SwingUtilities.isEventDispatchThread()) {

                SwingUtilities.invokeLater(this);

                return;

            }

            this.stop();

//            LOGGER.info("DelayAction.run begin ["+ getActionsLabel(this.current_actions) + "]");

            boolean needFireTableChanged = false;

            if( this.current_actions.isSet(ACTION_RELOADALL) ) {

                this.current_actions.clear(

                        ACTION_RELOADALL |

                        ACTION_RELOAD_FEATURE_TYPE |

                        ACTION_RELOAD_ALL_FEATURES |

                        ACTION_RELOAD_IF_FEATURE_COUNT_CHANGED |

                        ACTION_RELOAD_IF_FEATURE_UPDATED |

                        ACTION_RELOAD_IF_FEATURE_TYPE_CHANGED

                );

                reloadAll();

            }

            if( this.current_actions.isSet(ACTION_RELOAD_FEATURE_TYPE) ) {

                this.current_actions.clear(

                        ACTION_RELOAD_FEATURE_TYPE |

                        ACTION_RELOAD_ALL_FEATURES |

                        ACTION_RELOAD_IF_FEATURE_COUNT_CHANGED |

                        ACTION_RELOAD_IF_FEATURE_UPDATED |

                        ACTION_RELOAD_IF_FEATURE_TYPE_CHANGED

                );

                reloadFeatureType();

                updatePaginHelperWithHiddenColums();

            }

            if( this.current_actions.isSet(ACTION_RELOAD_ALL_FEATURES) ) {

                this.current_actions.clear(

                        ACTION_RELOAD_ALL_FEATURES |

                        ACTION_RELOAD_IF_FEATURE_TYPE_CHANGED |

                        ACTION_RELOAD_IF_FEATURE_COUNT_CHANGED |

                        ACTION_RELOAD_IF_FEATURE_UPDATED

                );

                reloadFeatures();

                needFireTableChanged = true;

            }

            if( this.current_actions.isSet(ACTION_RELOAD_IF_FEATURE_TYPE_CHANGED) ) {

                if( reloadFeatureTypeIfTypeChanged(featureType) ) {

                    this.current_actions.clear(

                            ACTION_RELOAD_IF_FEATURE_TYPE_CHANGED |

                            ACTION_RELOAD_IF_FEATURE_COUNT_CHANGED |

                            ACTION_RELOAD_IF_FEATURE_UPDATED

                    );

                }

            }

            if( this.current_actions.isSet(ACTION_RELOAD_IF_FEATURE_COUNT_CHANGED) ) {

                if( reloadFeaturesIfFeatureCountChanged(feature) ) {

                    this.current_actions.clear(

                            ACTION_RELOAD_IF_FEATURE_COUNT_CHANGED |

                            ACTION_RELOAD_IF_FEATURE_UPDATED

                    );

                }

            }

            if( this.current_actions.isSet(ACTION_RELOAD_IF_FEATURE_UPDATED) ) {

                if( reloadFeaturesIfFeatureUpdated(feature) ) {

                    this.current_actions.clear(

                            ACTION_RELOAD_IF_FEATURE_UPDATED

                    );

                    needFireTableChanged = true;

                }

            }

            if( this.current_actions.isSet(ACTION_ENABLE_SELECTION_UP) ) {

                if (!getHelper().isSelectionUp()) {

                    getHelper().setSelectionUp(true);

                    this.current_actions.clear(

                        ACTION_UPDATE_SELECTION

                    );

                }

                this.current_actions.clear(

                        ACTION_ENABLE_SELECTION_UP |

                        ACTION_DISABLE_SELECTION_UP

                );

                needFireTableChanged = true;

            } else if( this.current_actions.isSet(ACTION_DISABLE_SELECTION_UP) ) {

                if (getHelper().isSelectionUp()) {

                    getHelper().setSelectionUp(false);

                    this.current_actions.clear(

                        ACTION_UPDATE_SELECTION

                    );

                }

                this.current_actions.clear(

                        ACTION_ENABLE_SELECTION_UP |

                        ACTION_DISABLE_SELECTION_UP

                );

                needFireTableChanged = true;

            }

            if( this.current_actions.isSet(ACTION_UPDATE_SELECTION) ) {

                if (getHelper().isSelectionUp()) {

                    // Se ha a?adido o quitado elementos de la seleccion, y estamos

                    // en "seleccion arriba", asi que forzamos un refresco.

                    try {

                        getHelper().reloadCurrentPage();

                    } catch(Throwable th) {

                        LOGGER.debug("No se ha podido recargar la pagina actual de la tabla", th);

                    }

                }

                needFireTableChanged = true;

            }

            if( needFireTableChanged ) {

                fireTableChanged();

            }

            this.reset();

//            LOGGER.info("DelayAction.run end ["+ getActionsLabel(this.current_actions) + "]");

        }

        public void addAction(int action) {

            this.addAction(action, null, null);

        }

        public void addAction(int action, Feature feature) {

            this.addAction(action, feature, null);

        }

        public void addAction(int action, FeatureType featureType) {

            this.addAction(action, null, featureType);

        }

        public void addAction(int action, Feature feature, FeatureType featureType) {

            this.feature = feature;

            this.featureType = featureType;

            this.current_actions.set(action);

//            LOGGER.info("addAction: "+ this.getActionsLabel(current_actions));

            if ( this.current_actions.isSetAny() ) {

//                LOGGER.info("addAction: start");

                this.start();

            }

        }

    }

    private final DelayAction delayAction = new DelayAction();

    @Override

    public void update(final Observable observable, final Object notification) {

//        LOGGER.info("update: " +

//                (observable==null? "null":observable.getClass().getSimpleName()) +

//                ", " +

//                (notification==null? "null":notification.getClass().getSimpleName())

//        );

        if (notification instanceof ComplexNotification) {

            // A lot of things might have happened in the store, so don't

            // bother looking into each notification.

            this.delayAction.addAction(DelayAction.ACTION_RELOADALL);

        } else if (observable.equals(getFeatureStore())

                && notification instanceof FeatureStoreNotification) {

            FeatureStoreNotification fsNotification

                    = (FeatureStoreNotification) notification;

            String type = fsNotification.getType();

//            LOGGER.info("update: "+type);

            switch(type) {

                case FeatureStoreNotification.AFTER_DELETE:

                case FeatureStoreNotification.AFTER_INSERT:

                    this.delayAction.addAction(DelayAction.ACTION_RELOAD_IF_FEATURE_COUNT_CHANGED, fsNotification.getFeature());

                    break;

                case FeatureStoreNotification.AFTER_UPDATE:

                    this.delayAction.addAction(DelayAction.ACTION_RELOAD_IF_FEATURE_UPDATED, fsNotification.getFeature());

                    break;

                case FeatureStoreNotification.AFTER_UPDATE_TYPE:

                    this.delayAction.addAction(DelayAction.ACTION_RELOAD_IF_FEATURE_TYPE_CHANGED, fsNotification.getFeatureType());

                    break;

                case FeatureStoreNotification.TRANSFORM_CHANGE:

                case FeatureStoreNotification.AFTER_UNDO:

                case FeatureStoreNotification.AFTER_REDO:

                case FeatureStoreNotification.AFTER_REFRESH:

                    this.delayAction.addAction(DelayAction.ACTION_RELOADALL);

                    break;

                case FeatureStoreNotification.AFTER_FINISHEDITING:

                case FeatureStoreNotification.AFTER_STARTEDITING:

                case FeatureStoreNotification.AFTER_CANCELEDITING:

                    /*

                    No tengo nada claro por que es necesario llamar al reloadFeatureType

                    pero si no se incluye hay problemas si durante la edicion se a?aden

                    campos a la tabla. Sin esto, al cerrar la edicion, los campos a?adidos

                    desaparecen de la tabla aunque estan en el fichero.

                    Ver ticket #2434 https://devel.gvsig.org/redmine/issues/2434

                     */

                    this.delayAction.addAction(DelayAction.ACTION_RELOAD_FEATURE_TYPE, fsNotification.getFeatureType());

                    break;

                case FeatureStoreNotification.SELECTION_CHANGE:

                    this.delayAction.addAction(DelayAction.ACTION_UPDATE_SELECTION);

                    break;

                default:

                    LOGGER.debug("update: skip notification("+type+")");

            }

        }

    }

    protected void updatePaginHelperWithHiddenColums() {

        FeatureQuery query = this.getHelper().getFeatureQuery();

        if (this.getHelper().getFeatureStore().isEditing()) {

            if (query.hasConstantsAttributeNames()) {

                query.clearConstantsAttributeNames();

            }

        } else {

            query.setConstantsAttributeNames(this.getHiddenColumnNames());

        }

        try {

            this.getHelper().reload();

        } catch (BaseException ex) {

            LOGGER.warn("Can't reload paging-helper.", ex);

        }

    }

    protected String[] getHiddenColumnNames() {

        return null;

    }

    /**

     * Returns the FeatureStore of the Collection.

     *

     * @return the FeatureStore

     */

    public FeatureStore getFeatureStore() {

        return getHelper().getFeatureStore();

    }

    /**

     * Returns the descriptor of a Feature attribute for a table column.

     *

     * @param columnIndex, the column index

     * @return

     */

    public FeatureAttributeDescriptor getDescriptorForColumn(int columnIndex) {

        return internalGetFeatureDescriptorForColumn(columnIndex);

    }

    /**

     * @param columnIndex

     * @return

     */

    protected FeatureAttributeDescriptor internalGetFeatureDescriptorForColumn(

            int columnIndex) {

        FeatureType featureType = getFeatureType();

        return featureType == null ? null : featureType

                .getAttributeDescriptor(columnIndex);

    }

    /**

     * Initialize the TableModel

     */

    protected void initialize() {

        // Add as observable to the FeatureStore, to detect data and selection

        // changes

        pagingHelper.getFeatureStore().addObserver(this);

    }

    /**

     * Returns the value of a Feature attribute, at the given position.

     *

     * @param feature the feature to get the value from

     * @param columnIndex the Feature attribute position

     * @return the value

     */

    protected Object getFeatureValue(Feature feature, int columnIndex) {

        return feature.get(columnIndex);

    }

    /**

     * Sets the value of an Feature attribute at the given position.

     *

     * @param feature the feature to update

     * @param columnIndex the attribute position

     * @param value the value to set

     * @return

     */

    protected EditableFeature setFeatureValue(Feature feature, int columnIndex,

            Object value) {

        EditableFeature theEditableFeature = feature.getEditable();

        theEditableFeature.set(columnIndex, value);

        return theEditableFeature;

    }

    /**

     * Returns the FeatureQuery used to get the Features.

     *

     * @return the FeatureQuery

     */

    public FeatureQuery getFeatureQuery() {

        return getHelper().getFeatureQuery();

    }

    /**

     * Returns the type of the

     *

     * @return features.

     */

    protected FeatureType getFeatureType() {

        return getHelper().getFeatureType();

    }

    /**

     * Reloads the table data if a feature has been changed, not through the

     * table.

     */

    private boolean reloadFeaturesIfFeatureCountChanged(Feature feature) {

        // Is any data is changed in the FeatureStore, notify the model

        // listeners. Ignore the case where the updated feature is

        // changed through us.

        if (editableFeature == null || !editableFeature.equals(feature)) {

            reloadFeatures();

            //Selection must be locked to avoid losing it when the table is refreshed

            selectionLocked = true;

            //The table is refreshed

            try {

                fireTableDataChanged();

            } catch (Exception e) {

                LOGGER.warn("Couldn't reload changed table");

            } finally {

                //The locked selection is unlocked.

                selectionLocked = false;

            }

            return true;

        }

        return false;

    }

    private boolean reloadFeaturesIfFeatureUpdated(Feature feature) {

        // Is any data is changed in the FeatureStore, notify the model

        // listeners. Ignore the case where the updated feature is

        // changed through us.

        if (editableFeature == null || !editableFeature.equals(feature)) {

            reloadFeatures();

            return true;

        }

        return false;

    }

    /**

     * Reloads data and structure if the {@link FeatureType} of the features

     * being shown has changed.

     */

    private boolean reloadFeatureTypeIfTypeChanged(FeatureType updatedType) {

        // If the updated featured type is the one currently being

        // shown, reload the table.

        if (updatedType != null && updatedType.getId().equals(getFeatureType().getId())) {

            setFeatureType(updatedType);

            return true;

        }

        return false;

    }

    private void reloadAll() {

        reloadFeatureType();

    }

    private void reloadFeatureType() {

        try {

            String ftypeid = getHelper().getFeatureType().getId();

            FeatureType ftype = getHelper().getFeatureStore().getFeatureType(ftypeid);

            setFeatureType(ftype);

        } catch (DataException e) {

            LOGGER.warn("Can't reload featuretype",e);

            this.status = STATUS_ERR_LOADFEATURETYPE;

//            throw new FeaturesDataReloadException(e);

        }

    }

    /**

     * Reloads the features shown on the table.

     */

    private void reloadFeatures() {

        switch(this.status) {

            case STATUS_OK:

            case STATUS_ERR_LOADFEATURES:

                break;

            case STATUS_ERR_LOADFEATURETYPE:

                return;

        }

        try {

            getHelper().reload();

        } catch (BaseException ex) {

            LOGGER.warn("Can't reload features",ex);

            this.status = STATUS_ERR_LOADFEATURES;

//            throw new FeaturesDataReloadException(ex);

        }

    }

    /**

     * Returns true if selection must not be changed.

     *

     * @return

     */

    public boolean isSelectionLocked() {

        return selectionLocked;

    }

    @Override

    public void dispose() {

        this.disposableHelper.dispose(this);

    }

    @Override

    public void doDispose() throws BaseException {

        DisposeUtils.disposeQuietly(this.pagingHelper);

        this.pagingHelper = null;

    }

}