/ - Diff - gvSIG tools: Vector editing - gvSIG

           "Center", "Center position of circle", TYPE.POSITION);
       private EditingServiceParameter radius = new DefaultEditingServiceParameter(
           "Radius", "Radius of circle", TYPE.VALUE);
           "Radius", "Radius of circle", TYPE.POSITION, TYPE.VALUE);
       private Map<EditingServiceParameter, Object> values;

      */
     package org.gvsig.vectorediting.lib.api;
     import java.util.List;
     public interface EditingServiceParameter {
       public enum TYPE {
-...
       /**
        * @return
        */
       public TYPE getType();
       public List<TYPE> getTypes();
       /**
        * @return

      */
     package org.gvsig.vectorediting.lib.spi;
     import java.util.Arrays;
     import java.util.List;
     import org.gvsig.vectorediting.lib.api.EditingServiceParameter;
     public class DefaultEditingServiceParameter implements EditingServiceParameter {
-...
       private String description;
       private TYPE type;
       private List<TYPE> types;
       public DefaultEditingServiceParameter(String name, String description, TYPE type) {
       public DefaultEditingServiceParameter(String name, String description, TYPE... types) {
         this.name = name;
         this.description = description;
         this.type = type;
         this.types = Arrays.asList(types);
+      }
       public TYPE getType() {
         return type;
       public List<TYPE> getTypes() {
         return types;
+      }
       public String getName() {

     import java.awt.event.MouseEvent;
     import java.awt.geom.Point2D;
     import java.awt.image.BufferedImage;
     import java.util.ArrayList;
     import java.util.HashMap;
     import java.util.Iterator;
     import java.util.List;
     import java.util.Map;
     import org.cresques.cts.IProjection;
     import org.gvsig.andami.PluginServices;
     import org.gvsig.andami.ui.mdiFrame.MainFrame;
     import org.gvsig.app.project.documents.view.toolListeners.StatusBarListener;
     import org.gvsig.fmap.dal.exception.DataException;
     import org.gvsig.fmap.geom.Geometry;
     import org.gvsig.fmap.geom.exception.CreateGeometryException;
     import org.gvsig.fmap.geom.primitive.Point;
-...
     import org.gvsig.fmap.mapcontrol.tools.BehaviorException;
     import org.gvsig.fmap.mapcontrol.tools.Behavior.Behavior;
     import org.gvsig.fmap.mapcontrol.tools.Listeners.ToolListener;
     import org.gvsig.tools.exception.BaseException;
     import org.gvsig.utils.console.JConsole;
     import org.gvsig.utils.console.JDockPanel;
     import org.gvsig.utils.console.ResponseListener;
-...
     import org.gvsig.vectorediting.lib.api.EditingService;
     import org.gvsig.vectorediting.lib.api.EditingServiceParameter;
     import org.gvsig.vectorediting.lib.api.EditingServiceParameter.TYPE;
     import org.gvsig.vectorediting.lib.prov.circlecr.CircleCREditingProvider;
     import org.gvsig.vectorediting.swing.api.EditingBehavior;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     import com.vividsolutions.jts.geomgraph.Position;
     public class DefaultEditingBehavior extends Behavior implements EditingBehavior {
     	private static final Logger logger = LoggerFactory.getLogger(DefaultEditingBehavior.class);
     	private Map<FLyrVect, EditingService> serviceRegistration;
     	private MapControl mapControl;
-...
     			public void acceptResponse(String response) {
     				try {
     					textEntered(response);
     				} catch (RuntimeException ex) {
     				} catch (InvalidEntryException ex) {
     					getConsolePanel().addText(ex.getMessage(), JConsole.ERROR);
     					getNextParameter();
+    				}
-...
+    	}
     	public void mouseClicked(MouseEvent e) throws BehaviorException {
     		// TODO Auto-generated method stub
     		ViewPort vp = mapControl.getViewPort();
     		if (activeService != null) {
     			if (currentParam != null) {
     				switch (currentParam.getType()) {
     				case POSITION:
     				case VALUE:
     				List<TYPE> typesOfParam = currentParam.getTypes();
     				if (typesOfParam.contains(TYPE.POSITION)) {
     					Point point;
     					point = vp.convertToMapPoint(e.getX(), e.getY());
     					this.activeService.value(point);
     				case LIST_POSITIONS:
     				case OPTION:
     				case SELECTION:
     				case GEOMETRY:
+    				}
     				getNextParameter();
     				// TODO: Comprobar el resto de casos:
     				// TYPE.VALUE,
     				// TYPE.LIST_POSITIONS,
     				// TYPE.OPTION, TYPE.SELECTION,
     				// TYPE.GEOMETRY:
+    			}
     			getNextParameter();
+    		}
+    	}
-...
+    	}
     	private void textEntered(String response) {
     	private void textEntered(String response) throws InvalidEntryException {
     		if (response == null) {
     			cleanBehavior();
     		} else {
     			TYPE type = currentParam.getType();
     			try {
     			List<TYPE> types = currentParam.getTypes();
     				Point point = null;
     				Double value = null;
     				switch (type) {
     				case POSITION:
     					point = parsePoint(response);
     					if (point != null){
     						this.activeService.value(point);
+    					}
     					break;
     				case VALUE:
     				boolean insertedValue = false;
     				if (!insertedValue && types.contains(TYPE.POSITION)) {
     					try {
     						point = parsePoint(response);
     					} catch (Exception e) {
     						// Do nothing
     					} catch (BaseException e) {
     						logger.info("Can't parse string as a point", e);
     						point = null;
+    					}
     					if (point != null){
     					if (point != null) {
     						this.activeService.value(point);
     						break;
     						insertedValue = true;
+    					}
     					value = Double.valueOf(response);
     					this.activeService.value(value);
     					break;
     				case LIST_POSITIONS:
     				case OPTION:
     				case SELECTION:
     				case GEOMETRY:
+    				}
     				if (!insertedValue && types.contains(TYPE.VALUE)) {
     					try {
     						value = Double.valueOf(response);
     					} catch (NumberFormatException e) {
     						logger.info(e.getMessage(), e);
     						value = null;
+    					}
     					if(value != null){
     						this.activeService.value(value);
     						insertedValue = true;
+    					}
+    				}
     				// TODO: contemplar el resto de casos
     				// TYPE.LIST_POSITIONS,
     				// TYPE.OPTION,
     				// TYPE.SELECTION,
     				// TYPE.GEOMETRY
     				if(!insertedValue){
     					throw new InvalidEntryException("Invalid entry: " + response, null);
+    				}
     				getNextParameter();
     			} catch (Exception e) {
     				throw new RuntimeException("Datos inv?lidos: " + response);
+    			}
+    		}
+    	}
     	private Point parsePoint(String response){
     	private Point parsePoint(String response) throws CreateGeometryException,
     			ParsePointException, DataException {
     		String[] numbers = new String[1];
     		numbers[0] = response;
     		numbers = response.split(",");
-...
     					Double.parseDouble(numbers[1]) };
     			Point point;
     			try {
     				point = geomManager.createPoint(values[0], values[1],
     						Geometry.SUBTYPES.GEOM2D);
     				 // TODO: Maybe do util class to get type and subtype of a featureStore
     				return point;
     			} catch (CreateGeometryException e) {
     				new RuntimeException("Can't create a point" + response);
+    			}
     			point = geomManager.createPoint(
     					values[0],
     					values[1],
     					currentLayer.getFeatureStore().getDefaultFeatureType().getDefaultGeometryAttribute().getGeomType().getSubType());
     			// TODO: Maybe do util class to get type and subtype of a featureStore or a method in manager
     			return point;
     		} else {
     			throw new RuntimeException("Can't parse a point" + response);
     			throw new ParsePointException("Can't create a point", null);
+    		}
     		return null;
+    	}
     	private JDockPanel getDockConsole() {

     package org.gvsig.vectorediting.swing.impl;
     import org.gvsig.tools.exception.BaseException;
     public class ParsePointException extends BaseException {
         /**
+    	 *
     	 */
     	private static final long serialVersionUID = -5644073447564880045L;
     	private static final String MESSAGE =
             "Can't parse a point.";
         private static final String KEY = "_ParsePointException";
     	private String description;
         public ParsePointException(String description, Throwable ex) {
     		super(MESSAGE, ex, KEY, serialVersionUID);
     		this.description= description;
+    	}
     	public String getDescription() {
     		return description;
+    	}
+    }

     package org.gvsig.vectorediting.swing.impl;
     import org.gvsig.tools.exception.BaseException;
     public class InvalidEntryException extends BaseException {
     	/**
+    	 *
     	 */
     	private static final long serialVersionUID = 1490897907277930987L;
     	private static final String MESSAGE =
             "Invalid entry.";
         private static final String KEY = "_InvalidEntryException";
     	private String description;
         public InvalidEntryException(String description, Throwable ex) {
     		super(MESSAGE, ex, KEY, serialVersionUID);
     		this.description= description;
+    	}
     	public String getDescription() {
     		return description;
+    	}
+    }

Application: gvSIG desktop » gvSIG tools: Vector editing

Revision 53