/ - Diff - | gvSIG desktop 1 - gvSIG

     import java.util.List;
     import java.util.Map;
     import javax.swing.event.TableModelEvent;
     import org.gvsig.fmap.dal.DataTypes;
     import org.gvsig.fmap.dal.exception.DataException;
     import org.gvsig.fmap.dal.feature.EditableFeature;
-...
             order.clear();
             order.add(name, ascending);
             getHelper().reload();
             fireTableDataChanged();
     		fireTableChanged(new TableModelEvent(this, 0, getRowCount() - 1));
+        }
         @Override

      */
     package org.gvsig.fmap.mapcontrol.dal.feature.swing.table;
     import javax.swing.event.TableModelEvent;
     import javax.swing.table.AbstractTableModel;
     import org.gvsig.fmap.dal.DALLocator;
     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.FeatureStoreNotification;
     import org.gvsig.fmap.dal.feature.FeatureType;
     import org.gvsig.fmap.dal.feature.paging.FeaturePagingHelper;
     import org.gvsig.fmap.dal.feature.paging.impl.FeaturePagingHelperImpl;
     import org.gvsig.tools.exception.BaseException;
     import org.gvsig.tools.observer.Observable;
     import org.gvsig.tools.observer.Observer;
-...
          * @throws DataException
          *             if there is an error reading data from the FeatureStore
          */
         public FeatureTableModel(FeatureStore featureStore,
                 FeatureQuery featureQuery) throws DataException {
             this(featureStore, featureQuery, FeaturePagingHelper.DEFAULT_PAGE_SIZE);
+        }
     	public FeatureTableModel(FeatureStore featureStore,
     			FeatureQuery featureQuery) throws DataException {
     		this(featureStore, featureQuery, FeaturePagingHelper.DEFAULT_PAGE_SIZE);
+    	}
         /**
          * Constructs a TableModel from the features of a FeatureStore, with the
-...
          * @throws DataException
          *             if there is an error reading data from the FeatureStore
          */
         public FeatureTableModel(FeatureStore featureStore,
                 FeatureQuery featureQuery, int pageSize) throws DataException {
             this(new FeaturePagingHelperImpl(featureStore, featureQuery, pageSize));
+        }
     	public FeatureTableModel(FeatureStore featureStore,
     			FeatureQuery featureQuery, int pageSize) throws DataException {
     		this(DALLocator.getDataManager().createFeaturePagingHelper(
     				featureStore, featureQuery, pageSize));
+    	}
         /**
          * Constructs a TableModel from a FeatureCollection and a Paging helper.
-...
             fireTableStructureChanged();
+        }
     	/**
     	 * Sets that the selected Features get returned first.
     	 */
     	public void setSelectionUp(boolean selectionUp) {
     		getHelper().setSelectionUp(selectionUp);
     		fireTableChanged(new TableModelEvent(this, 0, getRowCount() - 1));
+    	}
         public void update(Observable observable, Object notification) {
             if (observable.equals(getFeatureStore())
                     && notification instanceof FeatureStoreNotification) {

+    	}
     	/**
     	 * Sets that the selected Features to be viewed first.
     	 */
     	public void setSelectionUp(boolean selectionUp) {
     		getTablePanel().setSelectionUp(selectionUp);
+    	}
     	/**
     	 * Returns the internal Table Model for the Features of the FeatureStore.
+    	 *
     	 * @return the internal Table Model

     /* gvSIG. Geographic Information System of the Valencian Government
+     *
      * Copyright (C) 2007-2008 Infrastructures and Transports Department
      * of the Valencian Government (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):
      * 2010 {}  {{Task}}
      */
     package org.gvsig.fmap.mapcontrol.dal.feature.swing;
     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.FeatureSelection;
     import org.gvsig.fmap.dal.feature.FeatureStore;
     import org.gvsig.fmap.dal.feature.FeatureStoreNotification;
     import org.gvsig.fmap.mapcontrol.dal.feature.swing.table.FeatureTableModel;
     import org.gvsig.tools.observer.Observable;
     import org.gvsig.tools.observer.Observer;
     /**
      * @author 2010- C?sar Ordi?ana - gvSIG team
      */
     public class FeatureSelectionModelNew implements ListSelectionModel, Observer {
     	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;
     	/**
     	 * Creates a new {@link FeatureSelectionModelNew} 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
     	 */
     	public FeatureSelectionModelNew(FeatureTableModel featureTableModel)
     			throws DataException {
     		this.featureTableModel = featureTableModel;
     		this.featureTableModel.getFeatureStore().addObserver(this);
+    	}
     	public int getAnchorSelectionIndex() {
     		return anchor;
+    	}
     	public int getLeadSelectionIndex() {
     		return lead;
+    	}
     	public int getMaxSelectionIndex() {
     		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;
+    	}
     	public int getMinSelectionIndex() {
     		FeatureSelection selection = getFeatureSelection();
     		try {
     			if (!selection.isEmpty()) {
     				for (int i = 0; i < featureTableModel.getRowCount(); i++) {
     					if (selection.isSelected(featureTableModel.getFeatureAt(i))) {
     						return i;
+    					}
+    				}
+    			}
     		} catch (DataException e) {
     			throw new SelectionChangeException(e);
+    		}
     		return -1;
+    	}
     	public void insertIndexInterval(int index, int length, boolean before) {
     		// Nothing to do
+    	}
     	public void removeIndexInterval(int index0, int index1) {
     		// Nothing to do
+    	}
     	public void setAnchorSelectionIndex(int index) {
     		this.anchor = index;
+    	}
     	public void setLeadSelectionIndex(int index) {
     		this.lead = index;
+    	}
     	public void addSelectionInterval(int index0, int index1) {
     		doWithSelection(new FeatureSelectionOperation() {
     			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);
+    	}
     	public void setSelectionInterval(int index0, int index1) {
     		doWithSelection(new FeatureSelectionOperation() {
     			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);
+    	}
     	public void removeSelectionInterval(int index0, int index1) {
     		doWithSelection(new FeatureSelectionOperation() {
     			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);
+    	}
     	public void clearSelection() {
     		try {
     			getFeatureSelection().deselectAll();
     		} catch (DataException e) {
     			throw new SelectionChangeException(e);
+    		}
+    	}
     	public boolean isSelectedIndex(int index) {
     		if (index == -1) {
     			return false;
+    		}
     		Feature feature = featureTableModel.getFeatureAt(index);
     		return getFeatureSelection().isSelected(feature);
+    	}
     	public boolean isSelectionEmpty() {
     		try {
     			return getFeatureSelection().isEmpty();
     		} catch (DataException ex) {
     			throw new SelectionChangeException(ex);
+    		}
+    	}
     	public boolean getValueIsAdjusting() {
     		return isAdjusting;
+    	}
     	public void setValueIsAdjusting(boolean valueIsAdjusting) {
     		if (this.isAdjusting != valueIsAdjusting) {
     			this.isAdjusting = valueIsAdjusting;
     			if (this.isAdjusting) {
     				getFeatureSelection().beginComplexNotification();
     			} else {
     				getFeatureSelection().endComplexNotification();
+    			}
+    		}
+    	}
     	public int getSelectionMode() {
     		return selectionMode;
+    	}
     	public void setSelectionMode(int selectionMode) {
     		this.selectionMode = selectionMode;
+    	}
     	public void addListSelectionListener(ListSelectionListener listener) {
     		listenerList.add(ListSelectionListener.class, listener);
+    	}
     	public void removeListSelectionListener(ListSelectionListener listener) {
     		listenerList.remove(ListSelectionListener.class, listener);
+    	}
     	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())) {
     				fireValueChanged(-1, -1, false);
+    			}
+    		}
+    	}
     	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;
     		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();
+    		}
     		fireValueChanged(first, last, 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;
+    	}
+    }

                         throw new SelectionChangeException(ex);
+                    }
                 } else {
                 	FeatureSelection selection;
     				FeatureSelection selection = getSelection();
     				selection.beginComplexNotification();
     				try {
     					selection = this.getFeatureStore().createFeatureSelection();
     					selection.deselectAll();
     					for (int i = first; i <= last; i++) {
     						selectFeatureAt(i, select, selection);
+    					}
     				} catch (DataException e) {
     					throw new SelectionChangeException(e);
+    				}
     				for (int i = first; i <= last; i++) {
     					selectFeatureAt(i, select, selection);
+                    }
     				try {
     					this.getFeatureStore().setSelection(selection);
     				} catch (DataException e) {
     					throw new SelectionChangeException(e);
+    				}
     				selection.endComplexNotification();
+                }
+            }
+        }

             headerCellRenderer.deleteObservers();
+        }
     	/**
     	 * Sets that the selected Features to be viewed first.
     	 */
     	public void setSelectionUp(boolean selectionUp) {
     		((FeatureTableModel) getModel()).setSelectionUp(selectionUp);
     		scrollRectToVisible(getCellRect(0, 0, true));
+    	}
         // @Override
         // public void tableChanged(TableModelEvent e) {
         // super.tableChanged(e);
-...
             // through the FeatureTableModel
             setRowSelectionAllowed(true);
             setColumnSelectionAllowed(false);
             setSelectionModel(new FeatureSelectionModel(featureTableModel));
     		//setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
     		setSelectionModel(new FeatureSelectionModelNew(featureTableModel));
     		// setSelectionModel(new FeatureSelectionModel(featureTableModel));
     		headerCellRenderer = new JToggleButtonHeaderCellRenderer(this);
     		getTableHeader().setDefaultRenderer(headerCellRenderer);

     		return getTableModel().getFeatureStore();
+    	}
     	/**
     	 * Sets that the selected Features to be viewed first.
     	 */
     	public void setSelectionUp(boolean selectionUp) {
     		try {
     			getTable().setSelectionUp(selectionUp);
     		} catch (DataException e) {
     			// TODO: create and throw a SetSelectionUpException
     			e.printStackTrace();
+    		}
+    	}
     	private static ConfigurableFeatureTableModel createModel(
     			FeatureStore featureStore, FeatureQuery featureQuery)
     			throws DataException {

     			<groupId>org.gvsig</groupId>
     			<artifactId>org.gvsig.tools.lib</artifactId>
     		</dependency>
             <dependency>
                 <groupId>org.gvsig</groupId>
                 <artifactId>org.gvsig.compat</artifactId>
                 <version>2.0-SNAPSHOT</version>
             </dependency>
     		<dependency>
     			<groupId>org.gvsig</groupId>
     			<artifactId>org.gvsig.metadata</artifactId>
-...
     			<classifier>tests</classifier>
     			<scope>test</scope>
     		</dependency>
             <dependency>
                 <groupId>org.gvsig</groupId>
                 <artifactId>org.gvsig.compat</artifactId>
                 <version>2.0-SNAPSHOT</version>
                 <classifier>se</classifier>
                 <scope>test</scope>
             </dependency>
     		<dependency>
     			<groupId>org.gvsig</groupId>
     			<artifactId>org.gvsig.metadata</artifactId>

     /* gvSIG. Geographic Information System of the Valencian Government
+     *
      * Copyright (C) 2007-2008 Infrastructures and Transports Department
      * of the Valencian Government (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}  {{Task}}
      */
     package org.gvsig.fmap.dal.feature.paging;
     import org.easymock.MockControl;
     import org.gvsig.fmap.dal.feature.FeatureQuery;
     import org.gvsig.fmap.dal.feature.FeatureSet;
     import org.gvsig.fmap.dal.feature.FeatureStore;
     import org.gvsig.fmap.dal.feature.FeatureType;
     import org.gvsig.fmap.dal.feature.paging.impl.FeaturePagingHelperImpl;
     import org.gvsig.tools.dynobject.DynObjectPagingHelper;
     import org.gvsig.tools.dynobject.DynObjectPagingHelperTest;
     /**
      * @author <a href="mailto:cordin@disid.com">C?sar Ordi?ana</a>
      */
     public class FeaturePagingHelperTest extends DynObjectPagingHelperTest {
     	private MockControl fsetControl;
     	private FeatureSet fsetMock;
     	private MockControl storeControl;
     	private FeatureStore storeMock;
     	private MockControl queryControl;
     	private FeatureQuery queryMock;
     	private FeatureType featureTypeMock;
     	private MockControl fTypeControl;
     	protected DynObjectPagingHelper createDynObjectPagingHelper()
     			throws Exception {
     		fsetControl = MockControl.createNiceControl(FeatureSet.class);
     		fsetMock = (FeatureSet) fsetControl.getMock();
     		storeControl = MockControl.createNiceControl(FeatureStore.class);
     		storeMock = (FeatureStore) storeControl.getMock();
     		queryControl = MockControl.createNiceControl(FeatureQuery.class);
     		queryMock = (FeatureQuery) queryControl.getMock();
     		fTypeControl = MockControl.createNiceControl(FeatureType.class);
     		featureTypeMock = (FeatureType) fTypeControl.getMock();
     		storeControl.expectAndReturn(storeMock.getDefaultFeatureType(),
     				featureTypeMock);
     		storeControl.expectAndReturn(storeMock.createFeatureQuery(), queryMock,
     				MockControl.ZERO_OR_MORE);
     		storeControl.expectAndReturn(storeMock.getFeatureSet(queryMock),
     				fsetMock, MockControl.ZERO_OR_MORE);
     		fsetControl.expectAndReturn(fsetMock.getSize(), 10,
     				MockControl.ZERO_OR_MORE);
     		storeControl.replay();
     		fsetControl.replay();
     		return new FeaturePagingHelperImpl(storeMock);
+    	}
     	protected void tearDown() throws Exception {
     		super.tearDown();
+    	}
     	/**
     	 * Test method for
     	 * {@link org.gvsig.fmap.dal.feature.paging.FeaturePagingHelper#getTotalSize()}
     	 * .
     	 */
     	public void testGetTotalSize() throws Exception {
     		assertEquals("El n? total de features no es el de la Colecci?n", 10,
     				getHelper().getTotalSize());
     		storeControl.verify();
     		fsetControl.verify();
+    	}
+    }

     /* gvSIG. Geographic Information System of the Valencian Government
+     *
      * Copyright (C) 2007-2008 Infrastructures and Transports Department
      * of the Valencian Government (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):
      * 2010 {}  {{Task}}
      */
     package org.gvsig.fmap.dal.feature.paging.impl;
     /**
      * Unit tests for the {@link OneSubsetOneSetPagingCalculator} class.
+     *
      * @author 2010- C?sar Ordi?ana - gvSIG team
      */
     public class OneSubsetOneSetPagingCalculatorTest extends AbstractPagingCalculatorTest {
     	private static final int MAX_PAGE_SIZE = 4;
     	private TestSizeable sizeable1 = new TestSizeable(6);
     	private TestSizeable sizeable2 = new TestSizeable(17);
     	private OneSubsetOneSetPagingCalculator calculator;
     	protected void setUp() throws Exception {
     		super.setUp();
     		calculator =
     				new OneSubsetOneSetPagingCalculator(MAX_PAGE_SIZE, sizeable1, sizeable2);
+    	}
     	/**
     	 * Test method for
     	 * {@link org.gvsig.fmap.dal.feature.paging.impl.OneSubsetOneSetPagingCalculator#getFirstSetSize()}
     	 * .
     	 */
     	public void testGetFirstSetSize() {
     		assertEquals(sizeable1.getSize(), calculator.getFirstSetSize());
+    	}
     	/**
     	 * Test method for
     	 * {@link org.gvsig.fmap.dal.feature.paging.impl.OneSubsetOneSetPagingCalculator#getSecondSetSize()}
     	 * .
     	 */
     	public void testGetSecondSetSize() {
     		assertEquals(sizeable2.getSize() - sizeable1.getSize(), calculator.getSecondSetSize());
+    	}
     	/**
     	 * Test method for
     	 * {@link org.gvsig.fmap.dal.feature.paging.impl.OneSubsetOneSetPagingCalculator#getFirstSetInitialIndex()}
     	 * .
     	 */
     	public void testGetFirstSetInitialIndex() {
     		calculator.setCurrentPage(0);
     		assertEquals(0, calculator.getFirstSetInitialIndex());
     		calculator.setCurrentPage(1);
     		assertEquals(0 + MAX_PAGE_SIZE, calculator.getFirstSetInitialIndex());
     		calculator.setCurrentPage(2);
     		assertEquals(-1, calculator.getFirstSetInitialIndex());
     		calculator.setCurrentPage(3);
     		assertEquals(-1, calculator.getFirstSetInitialIndex());
     		calculator.setCurrentPage(calculator.getNumPages() - 1);
     		assertEquals(-1, calculator.getFirstSetInitialIndex());
     		// Change values so all data fits into a single page
     		sizeable1.setSize(1l);
     		sizeable2.setSize(15l);
     		calculator.setMaxPageSize(20);
     		calculator.setCurrentPage(0);
     		assertEquals(0, calculator.getFirstSetInitialIndex());
+    	}
     	/**
     	 * Test method for
     	 * {@link org.gvsig.fmap.dal.feature.paging.impl.OneSubsetOneSetPagingCalculator#getSecondSetInitialIndex()}
     	 * .
     	 */
     	public void testGetSecondSetInitialIndex() {
     		calculator.setCurrentPage(0);
     		assertEquals(-1, calculator.getSecondSetInitialIndex());
     		calculator.setCurrentPage(1);
     		assertEquals(0, calculator.getSecondSetInitialIndex());
     		calculator.setCurrentPage(2);
     		assertEquals(2, calculator.getSecondSetInitialIndex());
     		calculator.setCurrentPage(3);
     		assertEquals(2 + MAX_PAGE_SIZE, calculator.getSecondSetInitialIndex());
     		calculator.setCurrentPage(calculator.getNumPages() - 1);
     		assertEquals(2 + ((calculator.getNumPages() - 3) * MAX_PAGE_SIZE),
     				calculator.getSecondSetInitialIndex());
     		// Change values so all data fits into a single page
     		sizeable1.setSize(1l);
     		sizeable2.setSize(15l);
     		calculator.setMaxPageSize(20);
     		calculator.setCurrentPage(0);
     		assertEquals(0, calculator.getSecondSetInitialIndex());
     		// Set the two sets equal, so all elements in the first set are
     		// contained in the second one
     		sizeable1.setSize(15l);
     		sizeable2.setSize(15l);
     		calculator.setMaxPageSize(4);
     		calculator.setCurrentPage(0);
     		assertEquals(-1, calculator.getSecondSetInitialIndex());
     		calculator.setCurrentPage(1);
     		assertEquals(-1, calculator.getSecondSetInitialIndex());
     		calculator.setCurrentPage(2);
     		assertEquals(-1, calculator.getSecondSetInitialIndex());
     		calculator.setCurrentPage(3);
     		assertEquals(-1, calculator.getSecondSetInitialIndex());
+    	}
     	/**
     	 * Test method for
     	 * {@link org.gvsig.fmap.dal.feature.paging.impl.OneSubsetOneSetPagingCalculator#getFirstSetHowMany()}
     	 * .
     	 */
     	public void testGetFirstSetHowMany() {
     		calculator.setCurrentPage(0);
     		assertEquals(MAX_PAGE_SIZE, calculator.getFirstSetHowMany());
     		calculator.setCurrentPage(1);
     		assertEquals(2, calculator.getFirstSetHowMany());
     		calculator.setCurrentPage(2);
     		assertEquals(0, calculator.getFirstSetHowMany());
     		calculator.setCurrentPage(3);
     		assertEquals(0, calculator.getFirstSetHowMany());
     		calculator.setCurrentPage(calculator.getNumPages() - 1);
     		assertEquals(0, calculator.getFirstSetHowMany());
     		// Change values so all data fits into a single page
     		sizeable1.setSize(1l);
     		sizeable2.setSize(15l);
     		calculator.setMaxPageSize(20);
     		calculator.setCurrentPage(0);
     		assertEquals(1, calculator.getFirstSetHowMany());
     		// Change values so all data is available into the first set
     		sizeable1.setSize(25l);
     		sizeable2.setSize(25l);
     		calculator.setMaxPageSize(20);
     		calculator.setCurrentPage(0);
     		assertEquals(20, calculator.getFirstSetHowMany());
     		calculator.setCurrentPage(1);
     		assertEquals(5, calculator.getFirstSetHowMany());
+    	}
     	/**
     	 * Test method for
     	 * {@link org.gvsig.fmap.dal.feature.paging.impl.OneSubsetOneSetPagingCalculator#getSecondSetHowMany()}
     	 * .
     	 */
     	public void testGetSecondSetHowMany() {
     		calculator.setCurrentPage(0);
     		assertEquals(0l, calculator.getSecondSetHowMany());
     		calculator.setCurrentPage(1);
     		assertEquals(2l, calculator.getSecondSetHowMany());
     		calculator.setCurrentPage(2);
     		assertEquals(MAX_PAGE_SIZE, calculator.getSecondSetHowMany());
     		calculator.setCurrentPage(3);
     		assertEquals(MAX_PAGE_SIZE, calculator.getSecondSetHowMany());
     		calculator.setCurrentPage(calculator.getNumPages() - 1);
     		assertEquals(1l, calculator.getSecondSetHowMany());
     		// Change values so all data fits into a single page
     		sizeable1.setSize(1l);
     		sizeable2.setSize(15l);
     		calculator.setMaxPageSize(20);
     		calculator.setCurrentPage(0);
     		assertEquals(14l, calculator.getSecondSetHowMany());
     		// Set the two sets equal, so all elements in the first set are
     		// contained in the second one
     		sizeable1.setSize(15l);
     		sizeable2.setSize(15l);
     		calculator.setMaxPageSize(4);
     		calculator.setCurrentPage(0);
     		assertEquals(0l, calculator.getSecondSetHowMany());
     		calculator.setCurrentPage(1);
     		assertEquals(0l, calculator.getSecondSetHowMany());
     		calculator.setCurrentPage(2);
     		assertEquals(0l, calculator.getSecondSetHowMany());
     		calculator.setCurrentPage(3);
     		assertEquals(0l, calculator.getSecondSetHowMany());
+    	}
     	/**
     	 * Test method for
     	 * {@link org.gvsig.fmap.dal.feature.paging.impl.OneSubsetOneSetPagingCalculator#hasCurrentPageAllValuesInFirstSet()}
     	 * .
     	 */
     	public void testHasCurrentPageAllValuesInFirstSet() {
     		calculator.setCurrentPage(0);
     		assertTrue(calculator.hasCurrentPageAllValuesInFirstSet());
     		calculator.setCurrentPage(1);
     		assertFalse(calculator.hasCurrentPageAllValuesInFirstSet());
     		calculator.setCurrentPage(2);
     		assertFalse(calculator.hasCurrentPageAllValuesInFirstSet());
     		calculator.setCurrentPage(3);
     		assertFalse(calculator.hasCurrentPageAllValuesInFirstSet());
     		calculator.setCurrentPage(calculator.getNumPages() - 1);
     		assertFalse(calculator.hasCurrentPageAllValuesInFirstSet());
     		// Change values so all data fits into a single page
     		sizeable1.setSize(1l);
     		sizeable2.setSize(15l);
     		calculator.setMaxPageSize(20);
     		calculator.setCurrentPage(0);
     		assertFalse(calculator.hasCurrentPageAllValuesInFirstSet());
+    	}
     	/**
     	 * Test method for
     	 * {@link org.gvsig.fmap.dal.feature.paging.impl.OneSubsetOneSetPagingCalculator#hasCurrentPageAnyValuesInFirstSet()}
     	 * .
     	 */
     	public void testHasCurrentPageAnyValuesInFirstSet() {
     		calculator.setCurrentPage(0);
     		assertTrue(calculator.hasCurrentPageAnyValuesInFirstSet());
     		calculator.setCurrentPage(1);
     		assertTrue(calculator.hasCurrentPageAnyValuesInFirstSet());
     		calculator.setCurrentPage(2);
     		assertFalse(calculator.hasCurrentPageAnyValuesInFirstSet());
     		calculator.setCurrentPage(3);
     		assertFalse(calculator.hasCurrentPageAnyValuesInFirstSet());
     		calculator.setCurrentPage(calculator.getNumPages() - 1);
     		assertFalse(calculator.hasCurrentPageAnyValuesInFirstSet());
     		// Change values so all data fits into a single page
     		sizeable1.setSize(1l);
     		sizeable2.setSize(15l);
     		calculator.setMaxPageSize(20);
     		calculator.setCurrentPage(0);
     		assertTrue(calculator.hasCurrentPageAnyValuesInFirstSet());
+    	}
     	/**
     	 * Test method for
     	 * {@link org.gvsig.fmap.dal.feature.paging.impl.OneSubsetOneSetPagingCalculator#hasCurrentPageAnyValuesInSecondSet()}
     	 * .
     	 */
     	public void testHasCurrentPageAnyValuesInSecondSet() {
     		calculator.setCurrentPage(0);
     		assertFalse(calculator.hasCurrentPageAnyValuesInSecondSet());
     		calculator.setCurrentPage(1);
     		assertTrue(calculator.hasCurrentPageAnyValuesInSecondSet());
     		calculator.setCurrentPage(2);
     		assertTrue(calculator.hasCurrentPageAnyValuesInSecondSet());
     		calculator.setCurrentPage(3);
     		assertTrue(calculator.hasCurrentPageAnyValuesInSecondSet());
     		calculator.setCurrentPage(calculator.getNumPages() - 1);
     		assertTrue(calculator.hasCurrentPageAnyValuesInSecondSet());
     		// Change values so all data fits into a single page
     		sizeable1.setSize(1l);
     		sizeable2.setSize(15l);
     		calculator.setMaxPageSize(20);
     		calculator.setCurrentPage(0);
     		assertTrue(calculator.hasCurrentPageAnyValuesInSecondSet());
     		// Set the two sets equal, so all elements in the first set are
     		// contained in the second one
     		sizeable1.setSize(15l);
     		sizeable2.setSize(15l);
     		calculator.setMaxPageSize(4);
     		calculator.setCurrentPage(0);
     		assertFalse(calculator.hasCurrentPageAnyValuesInSecondSet());
     		calculator.setCurrentPage(1);
     		assertFalse(calculator.hasCurrentPageAnyValuesInSecondSet());
     		calculator.setCurrentPage(2);
     		assertFalse(calculator.hasCurrentPageAnyValuesInSecondSet());
     		calculator.setCurrentPage(3);
     		assertFalse(calculator.hasCurrentPageAnyValuesInSecondSet());
+    	}
     	private class TestSizeable implements PagingCalculator.Sizeable {
     		private long size;
     		public TestSizeable(long size) {
     			this.size = size;
+    		}
     		public long getSize() {
     			return size;
+    		}
     		public void setSize(long size) {
     			this.size = size;
+    		}
+    	}
+    }

     /* gvSIG. Geographic Information System of the Valencian Government
+     *
      * Copyright (C) 2007-2008 Infrastructures and Transports Department
      * of the Valencian Government (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.
+     *
      */
     package org.gvsig.fmap.dal.feature.paging.impl;
     import junit.framework.TestCase;
     /**
      * Unit tests for the {@link AbstractPagingCalculator} class.
+     *
      * @author 2010- C?sar Ordi?ana - gvSIG team
      */
     public class AbstractPagingCalculatorTest extends TestCase {
     	private AbstractPagingCalculator calculator;
     	private static final long SIZE = 22;
     	private static final int MAX_PAGE_SIZE = 4;
     	protected void setUp() throws Exception {
     		super.setUp();
     		calculator = createCalculator();
+    	}
     	protected AbstractPagingCalculator createCalculator() {
     		return new TestPagingCalculator(MAX_PAGE_SIZE, SIZE);
+    	}
     	/**
     	 * Test method for
     	 * {@link org.gvsig.fmap.dal.feature.paging.impl.AbstractPagingCalculator#getMaxPageSize()}
     	 * and
     	 * {@link org.gvsig.fmap.dal.feature.paging.impl.AbstractPagingCalculator#setMaxPageSize(int)}
     	 * .
     	 */
     	public void testMaxPageSize() {
     		assertEquals(MAX_PAGE_SIZE, calculator.getMaxPageSize());
     		calculator.setMaxPageSize(100);
     		assertEquals(100, calculator.getMaxPageSize());
     		try {
     			calculator.setMaxPageSize(-10);
     			fail("Calculator accepts a negative max page size value");
     		} catch (Exception ex) {
     			// works as expected
+    		}
+    	}
     	/**
     	 * Test method for
     	 * {@link org.gvsig.fmap.dal.feature.paging.impl.AbstractPagingCalculator#getCurrentPage()}
     	 * and
     	 * {@link org.gvsig.fmap.dal.feature.paging.impl.AbstractPagingCalculator#setCurrentPage(long)}
     	 * .
     	 */
     	public void testCurrentPage() {
     		assertEquals(0, calculator.getCurrentPage());
     		long page = calculator.getNumPages() - 1;
     		calculator.setCurrentPage(page);
     		assertEquals(page, calculator.getCurrentPage());
     		try {
     			calculator.setCurrentPage(-10);
     			fail("Calculator accepts a negative current page value");
     		} catch (Exception ex) {
     			// works as expected
+    		}
+    	}
     	/**
     	 * Test method for
     	 * {@link org.gvsig.fmap.dal.feature.paging.impl.AbstractPagingCalculator#getInitialIndex()}
     	 * .
     	 */
     	public void testGetInitialIndex() {
     		calculator.setCurrentPage(0l);
     		assertEquals(0, calculator.getInitialIndex());
     		calculator.setCurrentPage(2);
     		assertEquals(2 * calculator.getMaxPageSize(),
     				calculator.getInitialIndex());
+    	}
     	/**
     	 * Test method for
     	 * {@link org.gvsig.fmap.dal.feature.paging.impl.AbstractPagingCalculator#getNumPages()}
     	 * .
     	 */
     	public void testGetNumPages() {
     		assertEquals(6, calculator.getNumPages());
+    	}
     	/**
     	 * Test method for
     	 * {@link org.gvsig.fmap.dal.feature.paging.impl.AbstractPagingCalculator#getCurrentPageSize()}
     	 * .
     	 */
     	public void testGetCurrentPageSize() {
     		for (int i = 0; i < calculator.getNumPages() - 1; i++) {
     			calculator.setCurrentPage(i);
     			assertEquals(MAX_PAGE_SIZE, calculator.getCurrentPageSize());
+    		}
     		calculator.setCurrentPage(calculator.getNumPages() - 1);
     		assertEquals(SIZE % MAX_PAGE_SIZE, calculator.getCurrentPageSize());
+    	}
     	private class TestPagingCalculator extends AbstractPagingCalculator {
     		private final long size;
     		public TestPagingCalculator(int maxPageSize, long size) {
     			super(maxPageSize);
     			this.size = size;
+    		}
     		public TestPagingCalculator(int maxPageSize, long currentPage, long size) {
     			super(maxPageSize, currentPage);
     			this.size = size;
+    		}
     		public long getTotalSize() {
     			return size;
+    		}
+    	}
+    }

     import org.gvsig.fmap.dal.DataSelection;
     import org.gvsig.fmap.dal.exception.DataException;
     import org.gvsig.tools.observer.ComplexObservable;
     import org.gvsig.tools.observer.Observer;
     import org.gvsig.tools.observer.WeakReferencingObservable;
     import org.gvsig.tools.persistence.Persistent;
-...
      * @author <a href="mailto:cordin@disid.com">C?sar Ordi?ana</a>
      */
     public interface FeatureReferenceSelection extends DataSelection, Observer,
             WeakReferencingObservable, Persistent {
     		WeakReferencingObservable, ComplexObservable, Persistent {
         /**
          * Adds a feature to the selection.

     import org.gvsig.tools.persistence.PersistenceManager;
     import org.gvsig.tools.persistence.PersistentState;
     import org.gvsig.tools.persistence.exception.PersistenceException;
     import org.gvsig.tools.visitor.VisitCanceledException;
     import org.gvsig.tools.visitor.Visitor;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
-...
     /**
      * Default implementation of the FeatureSelection interface. Internally, only
      * FeatureReference values are stored.
+     *
+     *
      * This implementation performs better if used with the selection related
      * methods: select, deselect and isSelected ones.
+     *
+     *
      * @author <a href="mailto:cordin@disid.com">C?sar Ordi?ana</a>
      */
     public class DefaultFeatureSelection extends DefaultFeatureReferenceSelection
             implements FeatureSelection {
     		implements FeatureSelection {
         private static final Logger LOGGER = LoggerFactory
                 .getLogger(DefaultFeatureSelection.class);
     	private static final Logger LOG = LoggerFactory
     			.getLogger(DefaultFeatureSelection.class);
         private Map featureTypeCounts = new HashMap(1);
     	private Map featureTypeCounts = new HashMap(1);
         /**
          * Creates a DefaultFeatureSelection, with a FeatureStore.
+         *
          * @param featureStore
          *            the FeatureStore to load Features from
          * @throws DataException
          *             if there is an error while getting the total number of
          *             Features of the Store.
          * @see AbstractSetBasedDataSelection#DefaultSelection(int)
          */
         public DefaultFeatureSelection(DefaultFeatureStore featureStore)
                 throws DataException {
             super(featureStore);
+        }
     	/**
     	 * Creates a DefaultFeatureSelection, with a FeatureStore.
+    	 *
     	 * @param featureStore
     	 *            the FeatureStore to load Features from
     	 * @throws DataException
     	 *             if there is an error while getting the total number of
     	 *             Features of the Store.
     	 * @see AbstractSetBasedDataSelection#DefaultSelection(int)
     	 */
     	public DefaultFeatureSelection(DefaultFeatureStore featureStore)
     			throws DataException {
     		super(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
          * @param helper
          *            to get some information of the Store
          * @throws DataException
          *             if there is an error while getting the total number of
          *             Features of the Store.
          */
         public DefaultFeatureSelection(FeatureStore featureStore,
                 FeatureSelectionHelper helper) throws DataException {
             super(featureStore, helper);
+        }
     	/**
     	 * 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
     	 * @param helper
     	 *            to get some information of the Store
     	 * @throws DataException
     	 *             if there is an error while getting the total number of
     	 *             Features of the Store.
     	 */
     	public DefaultFeatureSelection(FeatureStore featureStore,
     			FeatureSelectionHelper helper) throws DataException {
     		super(featureStore, helper);
+    	}
     	/**
     	 * Constructor used by the persistence manager. Don't use directly. After to
-...
     		super();
+    	}
         public boolean select(Feature feature) {
             return select(feature, true);
+        }
     	public boolean select(Feature feature) {
     		return select(feature, true);
+    	}
         /**
          * @see #select(Feature)
          * @param undoable
          *            if the action must be undoable
          */
         public boolean select(Feature feature, boolean undoable) {
             // TODO: should we check if the feature is from the same FeatureStore??
             if (feature == null) {
                 return false;
+            }
     	/**
     	 * @see #select(Feature)
     	 * @param undoable
     	 *            if the action must be undoable
     	 */
     	public boolean select(Feature feature, boolean undoable) {
     		// TODO: should we check if the feature is from the same FeatureStore??
     		if (feature == null) {
     			return false;
+    		}
     //        LOGGER.debug("Selected feature: {}", feature);
     		// LOGGER.debug("Selected feature: {}", feature);
             if (isReversed()) {
                 removeFeatureTypeCount(feature.getType());
             } else {
                 addFeatureTypeCount(feature.getType());
+            }
             return select(feature.getReference(), undoable);
+        }
     		if (isReversed()) {
     			removeFeatureTypeCount(feature.getType());
     		} else {
     			addFeatureTypeCount(feature.getType());
+    		}
     		return select(feature.getReference(), undoable);
+    	}
         public boolean select(FeatureSet features) throws DataException {
             return select(features, true);
+        }
     	public boolean select(FeatureSet features) throws DataException {
     		return select(features, true);
+    	}
         /**
          * @see #select(FeatureSet)
          * @param undoable
          *            if the action must be undoable
          */
         public boolean select(FeatureSet features, boolean undoable)
                 throws DataException {
             boolean change = false;
             boolean inComplex = false;
             if (undoable && getFeatureStore().isEditing()
     	/**
     	 * @see #select(FeatureSet)
     	 * @param undoable
     	 *            if the action must be undoable
     	 */
     	public boolean select(FeatureSet features, boolean undoable)
     			throws DataException {
     		boolean change = false;
     		boolean inComplex = false;
     		if (undoable && getFeatureStore().isEditing()
     				&& !getCommands().inComplex()) {
     			inComplex = getCommands().inComplex();
     			getCommands().startComplex("_selectionSelectFeatureSet");
+            }
+    		}
             disableNotifications();
     		disableNotifications();
     		DisposableIterator iter = null;
     		try {
     			for (iter = features.fastIterator(); iter.hasNext();) {
-...
+    			}
     		} finally {
     			dispose(iter);
+            }
             enableNotifications();
             if (undoable && getFeatureStore().isEditing() && !inComplex) {
                 getCommands().endComplex();
+            }
             if (change) {
                 notifyObservers(DataStoreNotification.SELECTION_CHANGE);
+            }
             return change;
+        }
+    		}
     		enableNotifications();
     		if (undoable && getFeatureStore().isEditing() && !inComplex) {
     			getCommands().endComplex();
+    		}
     		if (change) {
     			notifyObservers(DataStoreNotification.SELECTION_CHANGE);
+    		}
     		return change;
+    	}
         public boolean deselect(Feature feature) {
             return deselect(feature, true);
+        }
     	public boolean deselect(Feature feature) {
     		return deselect(feature, true);
+    	}
         /**
          * @see #deselect(Feature)
          * @param undoable
          *            if the action must be undoable
          */
         public boolean deselect(Feature feature, boolean undoable) {
             if (feature == null) {
                 return false;
+            }
     	/**
     	 * @see #deselect(Feature)
     	 * @param undoable
     	 *            if the action must be undoable
     	 */
     	public boolean deselect(Feature feature, boolean undoable) {
     		if (feature == null) {
     			return false;
+    		}
             LOGGER.debug("Deselected feature: {}", feature);
     		LOG.debug("Deselected feature: {}", feature);
             if (isReversed()) {
                 addFeatureTypeCount(feature.getType());
             } else {
                 removeFeatureTypeCount(feature.getType());
+            }
             return deselect(feature.getReference(), undoable);
+        }
     		if (isReversed()) {
     			addFeatureTypeCount(feature.getType());
     		} else {
     			removeFeatureTypeCount(feature.getType());
+    		}
     		return deselect(feature.getReference(), undoable);
+    	}
         public boolean deselect(FeatureSet features) throws DataException {
             return deselect(features, true);
+        }
     	public boolean deselect(FeatureSet features) throws DataException {
     		return deselect(features, true);
+    	}
         /**
          * @see #deselect(FeatureSet)
          * @param undoable
          *            if the action must be undoable
          */
         public boolean deselect(FeatureSet features, boolean undoable)
                 throws DataException {
             boolean change = false;
             if (undoable && getFeatureStore().isEditing()) {
                 getCommands().startComplex("_selectionDeselectFeatureSet");
+            }
             disableNotifications();
     	/**
     	 * @see #deselect(FeatureSet)
     	 * @param undoable
     	 *            if the action must be undoable
     	 */
     	public boolean deselect(FeatureSet features, boolean undoable)
     			throws DataException {
     		boolean change = false;
     		if (undoable && getFeatureStore().isEditing()) {
     			getCommands().startComplex("_selectionDeselectFeatureSet");
+    		}
     		disableNotifications();
     		DisposableIterator iter = null;

| gvSIG desktop 1

Revision 33378