/ - Diff - gvSIG data provider for GPE - gvSIG

     <?xml version="1.0" encoding="ISO-8859-1"?>
     <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
       <modelVersion>4.0.0</modelVersion>
       <artifactId>org.gvsig.gpe.exportto</artifactId>
       <packaging>pom</packaging>
       <parent>
           <groupId>org.gvsig</groupId>
           <artifactId>org.gvsig.gpe</artifactId>
           <version>2.1.58</version>
       </parent>
       <modules>
         <module>org.gvsig.gpe.exportto.kml</module>
         <module>org.gvsig.gpe.exportto.generic</module>
       </modules>
     </project>

     package org.gvsig.gpe.exportto.generic.util;
     import java.io.IOException;
     import org.gvsig.fmap.geom.primitive.Point;
     import org.gvsig.gpe.lib.api.parser.ICoordinateIterator;
     import org.gvsig.gpe.lib.api.writer.ICoordinateSequence;
     public class CoordinatesSequencePoint implements
     ICoordinateSequence, ICoordinateIterator {
     	double[] points = null;
     	int index = 0;
     	public CoordinatesSequencePoint(Point point) {
     	    if (point.getDimension() == 3) {
                 // 2dZ
     	        this.points = new double[3];
     	        points[0] = point.getX();
     	        points[1] = point.getY();
     	        points[2] = point.getCoordinateAt(2);
     	        index = 3;
     	    } else {
     	        // 2d
     	        this.points = new double[2];
     	        points[0] = point.getX();
     	        points[1] = point.getY();
     	        index = 2;
+    	    }
+    	}
     	public int getSize() {
     		return 1;
+    	}
     	public ICoordinateIterator iterator() {
     		return this;
+    	}
     	public int getDimension() {
     		return points.length;
+    	}
     	public boolean hasNext() throws IOException {
     		return (index > 0);
+    	}
     	public void next(double[] buffer) throws IOException {
     		buffer[0] = points[0];
     		buffer[1] = points[1];
     		if ((buffer.length == 3) && (points.length == 3)){
     			buffer[2] = points[2];
+    		}
     		index--;
+    	}
+    }

     package org.gvsig.gpe.exportto.generic.util;
     import java.awt.geom.Rectangle2D;
     import java.io.IOException;
     import org.gvsig.gpe.lib.api.parser.ICoordinateIterator;
     import org.gvsig.gpe.lib.api.writer.ICoordinateSequence;
     public class CoordinatesSequenceBbox implements
     ICoordinateSequence, ICoordinateIterator {
     	Rectangle2D bbox = null;
     	int index = 0;
     	public CoordinatesSequenceBbox(Rectangle2D bbox){
     		this.bbox = bbox;
+    	}
     	public int getSize() {
     		return 2;
+    	}
     	public ICoordinateIterator iterator() {
     		return this;
+    	}
     	public int getDimension() {
     		return 2;
+    	}
     	public boolean hasNext() throws IOException {
     		if (index <=1){
     			return true;
+    		}
     		return false;
+    	}
     	public void next(double[] buffer) throws IOException {
     		if (index == 0){
     			buffer[0] = bbox.getMinX();
     			buffer[1] = bbox.getMinY();
     		}else if (index == 1){
     			buffer[0] = bbox.getMaxX();
     			buffer[1] = bbox.getMaxY();
+    		}
     		index++;
+    	}
+    }

     package org.gvsig.gpe.exportto.generic.util;
     import java.awt.geom.PathIterator;
     import java.io.IOException;
     import org.gvsig.gpe.lib.api.parser.ICoordinateIterator;
     import org.gvsig.gpe.lib.api.writer.ICoordinateSequence;
     public class CoordinatesSequenceGeneralPath implements
     ICoordinateSequence, ICoordinateIterator {
     	private PathIterator it = null;
     	int size = 0;
     	boolean hasMoreGeoemtries = true;
     	public CoordinatesSequenceGeneralPath(PathIterator it) {
     		super();
     		this.it = it;
+    	}
     	public int getSize() {
     		return size;
+    	}
     	public void initialize(){
     		size = 0;
+    	}
     	public boolean hasMoreGeometries(){
     		return hasMoreGeoemtries;
+    	}
     	public ICoordinateIterator iterator() {
     		return this;
+    	}
     	public int getDimension() {
     		return 2;
+    	}
     	public boolean hasNext() throws IOException {
     		if (it.isDone()){
     			hasMoreGeoemtries = false;
     			return false;
+    		}
     		double[] coords = new double[2];
     		int type = it.currentSegment(coords);
     		/*
     		if (type == PathIterator.SEG_CLOSE){
     			hasMoreGeoemtries = false;
+    		}
     		*/
     		return ((type != PathIterator.SEG_MOVETO) || (size == 0));
+    	}
     	public void next(double[] buffer) throws IOException {
     		it.currentSegment(buffer);
     		it.next();
     		size++;
+    	}
+    }

     package org.gvsig.gpe.exportto.generic.util;
     import java.awt.geom.PathIterator;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     import org.gvsig.fmap.geom.Geometry;
     import org.gvsig.fmap.geom.GeometryLocator;
     import org.gvsig.fmap.geom.aggregate.MultiCurve;
     import org.gvsig.fmap.geom.aggregate.MultiPoint;
     import org.gvsig.fmap.geom.aggregate.MultiSurface;
     import org.gvsig.fmap.geom.exception.CreateGeometryException;
     import org.gvsig.fmap.geom.primitive.Curve;
     import org.gvsig.fmap.geom.primitive.Envelope;
     import org.gvsig.fmap.geom.primitive.Point;
     import org.gvsig.fmap.geom.primitive.Surface;
     import org.gvsig.gpe.lib.api.writer.IGPEWriterHandler;
     import org.gvsig.tools.locator.LocatorException;
     /**
+     *
      * Utility class to write gvSIG geometries in a GPE writer.
+     *
      * @author jldominguez (I have removed the reprojection methods/fields)
      */
     public class GeometryToGPEWriter {
         private static Logger logger = LoggerFactory.getLogger(GeometryToGPEWriter.class);
     	private IGPEWriterHandler writer = null;
     	//To know if the geometry is multiple
     	// private boolean isMultiple = false;
     	//To reproject geometries
     	/*
     	private IProjection projOrig = null;
     	private IProjection projDest = null;
     	private ICoordTrans coordTrans = null;
     	*/
     	private String srs = null;
     	public GeometryToGPEWriter(IGPEWriterHandler writer) {
     		this.writer = writer;
+    	}
         public String getCrs() {
             return srs;
+        }
         public void setCrs(String thesrs) {
             this.srs = thesrs;
+        }
         /**
     	 * It writes a geometry
     	 * @param geom
     	 * The geometry to write
     	 * @param crs
     	 * The coordinates reference system
     	 */
     	public void writeGeometry(Geometry geom, boolean addLabelPoint) {
     	    if (geom == null) {
     	        logger.error("GPE Writer cannot write geometry.",
     	            new Exception("Geometry is NULL"));
     	        return;
+    	    }
     	    // ====================================================
     		if (geom instanceof MultiPoint) {
     			writeMultiPoint((MultiPoint) geom);
     			return;
+    		}
             if (geom instanceof MultiCurve) {
                 writeMultiLine((MultiCurve) geom, addLabelPoint);
                 return;
+            }
             if (geom instanceof MultiSurface) {
                 writeMultiPolygon((MultiSurface) geom, addLabelPoint);
                 return;
+            }
             // ====================================================
             if (geom instanceof Point) {
                 writePoint((Point) geom);
                 return;
+            }
             if (geom instanceof Curve) {
                 writeLine((Curve) geom, addLabelPoint);
                 return;
+            }
             if (geom instanceof Surface) {
                 writePolygon((Surface) geom, addLabelPoint);
                 return;
+            }
             // ====================================================
             logger.error("GPE Writer cannot write geometry",
                 new Exception("Unexpected geometry: " + geom.getClass().getName()));
+    	}
     	/**
     	 * Writes a point in 2D
     	 * @param point
     	 * The point to write
     	 * @param crs
     	 * The coordinates reference system
     	 */
     	private void writePoint(Point point) {
     		writer.startPoint(null, new CoordinatesSequencePoint(point), srs);
     		writer.endPoint();
+    	}
     	/**
     	 * Writes a multipoint in 2D
     	 * @param point
     	 * The point to write
     	 * @param crs
     	 * The coordinates reference system
     	 */
     	private void writeMultiPoint(MultiPoint multi){
     		writer.startMultiPoint(null, srs);
     		for (int i=0 ; i<multi.getPrimitivesNumber() ; i++) {
     		    Point p = multi.getPointAt(i);
     			writePoint(p);
+    		}
     		writer.endMultiPoint();
+    	}
     	/**
     	 * Writes a line in 2D
     	 * @param line
     	 * The line to write
     	 * @param crs
     	 * The coordinates reference system
     	 * @param geometries
     	 * The parsed geometries
     	 */
     	private void writeLine(Curve curve, boolean addLabelPoint) {
     		boolean ismulti = isMultiple(curve.getPathIterator(null));
     		/*
              * Start ===================================================
              */
             if (addLabelPoint) {
                 Point po = null;
                 try {
                     po = getLabelPoint(curve.getPathIterator(null), curve.getEnvelope());
                 } catch (Exception ex) {
                     logger.info("While getting label point.", ex);
                     return;
+                }
                 writer.startMultiGeometry(null, srs);
                 CoordinatesSequencePoint pseq = new CoordinatesSequencePoint(po);
                 writer.startPoint(null, pseq, srs);
                 writer.endPoint();
             } else {
                 if (ismulti) {
                     writer.startMultiLineString(null, srs);
+                }
+            }
             /*
              * Body ===================================================
              */
             CoordinatesSequenceGeneralPath sequence =
     		    new CoordinatesSequenceGeneralPath(curve.getPathIterator(null));
     		writer.startLineString(null, sequence, srs);
     		writer.endLineString();
     		if (ismulti) {
     	        while (sequence.hasMoreGeometries()){
     	            sequence.initialize();
     	            writer.startLineString(null, sequence, srs);
     	            writer.endLineString();
+    	        }
+    		}
     		/*
              * End ===================================================
              */
     		if (addLabelPoint) {
                 writer.endMultiGeometry();
             } else {
                 if (ismulti) {
                     writer.endMultiLineString();
+                }
+            }
+    	}
         private void writeMultiLine(MultiCurve mcurve, boolean addLabelPoint) {
             if (addLabelPoint) {
                 Point po = null;
                 try {
                     po = getLabelPoint(mcurve.getPathIterator(null), mcurve.getEnvelope());
                 } catch (Exception exc) {
                     logger.info("While getting label point.", exc);
                     return;
+                }
                 writer.startMultiGeometry(null, srs);
                 CoordinatesSequencePoint pseq = new CoordinatesSequencePoint(po);
                 writer.startPoint(null, pseq, srs);
                 writer.endPoint();
             } else {
                 writer.startMultiLineString(null, srs);
+            }
             /*
              * Body =======================================
              */
             CoordinatesSequenceGeneralPath sequence =
                 new CoordinatesSequenceGeneralPath(mcurve.getPathIterator(null));
             writer.startLineString(null, sequence, srs);
             writer.endLineString();
             while (sequence.hasMoreGeometries()){
                 sequence.initialize();
                 writer.startLineString(null, sequence, srs);
                 writer.endLineString();
+            }
             /*
              * End ======================================
              */
             if (addLabelPoint) {
                 writer.endMultiGeometry();
             } else {
                 writer.endMultiLineString();
+            }
+        }
     	/**
     	 * Writes a polygon in 2D
     	 * @param polygon
     	 * The polygon to write
     	 * @param crs
     	 * The coordinates reference system
     	 * @param geometries
     	 * The parsed geometries
     	 */
     	private void writePolygon(Surface surface, boolean addLabelPoint) {
     	    boolean ismulti = isMultiple(surface.getPathIterator(null));
     	    CoordinatesSequenceGeneralPath sequence = null;
     	    /*
              * Start ===================================================
              */
     	    if (addLabelPoint) {
     	        Point po = null;
     	        try {
     	            po = surface.getInteriorPoint();
     	        } catch (Exception ex) {
     	            logger.info("While getting label point.", ex);
     	            return;
+    	        }
                 writer.startMultiGeometry(null, srs);
     	        CoordinatesSequencePoint pseq = new CoordinatesSequencePoint(po);
     	        writer.startPoint(null, pseq, srs);
     	        writer.endPoint();
     	    } else {
     	        if (ismulti) {
     	            writer.startMultiPolygon(null, srs);
+    	        }
+    	    }
     		/*
     		 * Body ===================================================
     		 */
     		sequence = new CoordinatesSequenceGeneralPath(surface.getPathIterator(null));
     		writer.startPolygon(null, sequence, srs);
     		writer.endPolygon();
             if (ismulti) {
                 while (sequence.hasMoreGeometries()){
                     sequence.initialize();
                     writer.startPolygon(null, sequence, srs);
                     writer.endPolygon();
+                }
+            }
             /*
              * End ===================================================
              */
     		if (addLabelPoint) {
     		    writer.endMultiGeometry();
     		} else {
     		    if (ismulti) {
     		        writer.endMultiPolygon();
+    		    }
+    		}
+    	}
         private Point getLabelPoint(PathIterator pathIterator, Envelope envelope) throws
         Exception {
             if (pathIterator == null || envelope == null) {
                 throw new Exception("Null iterator or envelope");
+            }
             double bestx = 0;
             double besty = 0;
             double cx = envelope.getCenter(0);
             double cy = envelope.getCenter(1);
             double dist = Double.MAX_VALUE;
             double auxdist = 0;
             double[] coords = new double[6];
             while (!pathIterator.isDone()) {
                 pathIterator.currentSegment(coords);
                 auxdist = getDist2(cx, cy, coords[0], coords[1]);
                 if (auxdist < dist) {
                     dist = auxdist;
                     bestx = coords[0];
                     besty = coords[1];
+                }
                 pathIterator.next();
+            }
             Point resp = GeometryLocator.getGeometryManager().createPoint(
                 bestx, besty, Geometry.SUBTYPES.GEOM2D);
             return resp;
+        }
         private Point getLabelPoint(MultiSurface msurf) throws Exception {
             if (msurf == null) {
                 throw new Exception("Surface is Null");
+            }
             int n = msurf.getPrimitivesNumber();
             Surface surf = null;
             Surface bigsurf = null;
             double importance = 0;
             double auximportance = 0;
             Envelope env = null;
             long nverts = 0;
             for (int i=0; i<n; i++) {
                 surf = (Surface) msurf.getPrimitiveAt(i);
                 nverts = surf.getNumVertices();
                 env = surf.getEnvelope();
                 auximportance = nverts * env.getLength(0) * env.getLength(1);
                 if (auximportance >= importance) {
                     importance = auximportance;
                     bigsurf = surf;
+                }
+            }
             if (bigsurf != null) {
                 return bigsurf.getInteriorPoint();
             } else {
                 return msurf.getInteriorPoint();
+            }
+        }
         /**
          * Returns (dist ^ 2) between points a and b
          * @param ax
          * @param ay
          * @param bx
          * @param by
          * @return
          */
         private double getDist2(
             double ax, double ay,
             double bx, double by) {
             double dx = bx - ax;
             double dy = by - ay;
             return (dx * dx) + (dy * dy);
+        }
         private void writeMultiPolygon(MultiSurface msurface, boolean addLabelPoint) {
             if (addLabelPoint) {
                 Point po = null;
                 try {
                     po = getLabelPoint(msurface);
                 } catch (Exception ex) {
                     logger.info("While getting label point.", ex);
                     return;
+                }
                 writer.startMultiGeometry(null, srs);
                 CoordinatesSequencePoint pseq = new CoordinatesSequencePoint(po);
                 writer.startPoint(null, pseq, srs);
                 writer.endPoint();
             } else {
                 writer.startMultiPolygon(null, srs);
+            }
             /*
              * Body ==============================================
              */
             CoordinatesSequenceGeneralPath sequence =
                 new CoordinatesSequenceGeneralPath(msurface.getPathIterator(null));
             writer.startPolygon(null, sequence, srs);
             writer.endPolygon();
             while (sequence.hasMoreGeometries()){
                 sequence.initialize();
                 writer.startPolygon(null, sequence, srs);
                 writer.endPolygon();
+            }
             /*
              * End ==============================================
              */
             if (addLabelPoint) {
                 writer.endMultiGeometry();
             } else {
                 writer.endMultiPolygon();
+            }
+        }
     	/**
     	 * Return if the geometry is multiple
     	 * @param path
     	 * @return
     	 */
     	public boolean isMultiple(PathIterator path){
     		double[] coords = new double[2];
     		int type = 0;
     		int numGeometries = 0;
     		while (!path.isDone()){
     			type = path.currentSegment(coords);
     			 switch (type) {
     			 	case PathIterator.SEG_MOVETO:
     			 		numGeometries++;
     			 		if (numGeometries == 2){
     			 			return true;
+    			 		}
     			 		break;
     			 	default:
     			 		break;
+    			 }
     			 path.next();
+    		}
     		return false;
+    	}
+    }

     /**
      * 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.
      */
     package org.gvsig.gpe.exportto.generic;
     import org.gvsig.gpe.lib.api.GPELibrary;
     import org.gvsig.tools.library.AbstractLibrary;
     import org.gvsig.tools.library.LibraryException;
     /**
      * Library with common things to be used by
      * GPE export libraries
+     *
      * @author gvSIG Team
      * @version $Id$
      */
     public class ExporttoGPEGenericLibrary extends AbstractLibrary {
         public void doRegistration() {
             require(GPELibrary.class);
+        }
         protected void doInitialize() throws LibraryException {
             // Nothing to do
+        }
         protected void doPostInitialize() throws LibraryException {
+        }
+    }

org.gvsig.gpe/library/tags/org.gvsig.gpe-2.1.58/org.gvsig.gpe.exportto/org.gvsig.gpe.exportto.generic/src/main/resources/META-INF/services/org.gvsig.tools.library.Library
	1	org.gvsig.gpe.exportto.generic.ExporttoGPEGenericLibrary

     <?xml version="1.0" encoding="ISO-8859-1"?>
     <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
       <modelVersion>4.0.0</modelVersion>
       <artifactId>org.gvsig.gpe.exportto.generic</artifactId>
       <packaging>jar</packaging>
       <name>${project.artifactId}</name>
       <parent>
         <groupId>org.gvsig</groupId>
         <artifactId>org.gvsig.gpe.exportto</artifactId>
         <version>2.1.58</version>
       </parent>
       <dependencies>
         <dependency>
           <groupId>org.gvsig</groupId>
           <artifactId>org.gvsig.gpe.lib.api</artifactId>
           <scope>compile</scope>
         </dependency>
         <dependency>
             <groupId>org.gvsig</groupId>
             <artifactId>org.gvsig.tools.lib</artifactId>
             <scope>compile</scope>
         </dependency>
         <dependency>
             <groupId>org.gvsig</groupId>
             <artifactId>org.gvsig.fmap.geometry.api</artifactId>
             <scope>compile</scope>
         </dependency>
       </dependencies>
     </project>

     /**
      * 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.
      */
     package org.gvsig.gpe.exportto.kml;
     import org.cresques.cts.IProjection;
     import org.gvsig.exportto.swing.ExporttoSwingManager;
     import org.gvsig.exportto.swing.prov.file.AbstractExporttoFileProviderFactory;
     import org.gvsig.fmap.dal.DataTypes;
     import org.gvsig.fmap.dal.feature.FeatureStore;
     import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;
     import org.gvsig.tools.ToolsLocator;
     import org.gvsig.tools.dynobject.DynObject;
     import org.gvsig.tools.service.ServiceException;
     import org.gvsig.tools.service.spi.Provider;
     import org.gvsig.tools.service.spi.ProviderServices;
     /**
      * Factory of file {@link ExportoProvider} objects.
+     *
      * @author gvSIG Team
      * @version $Id$
      */
     public class ExporttoKMLProviderFactory extends
         AbstractExporttoFileProviderFactory {
         private static final String PROVIDER_NAME = "KML";
         protected static final String PARAMETER_LAYER = "FLyrVect";
         public ExporttoKMLProviderFactory() {
             super(new int[] {
             		ExporttoSwingManager.VECTORIAL_TABLE_WITH_GEOMETRY
             });
+        }
         public void initialize() {
             parametersDefinition =
                 ToolsLocator.getDynObjectManager().createDynClass(getName(),
                     getDescription());
             parametersDefinition.addDynField(PARAMETER_FEATURESTORE)
                 .setType(DataTypes.OBJECT).setMandatory(true)
                 .setClassOfValue(FeatureStore.class);
             parametersDefinition.addDynField(PARAMETER_PROJECTION)
                 .setType(DataTypes.CRS).setMandatory(false);
             parametersDefinition.addDynField(PARAMETER_LAYER)
             .setType(DataTypes.OBJECT).setMandatory(false)
             .setClassOfValue(FLyrVect.class);
+        }
         public Provider create(DynObject parameters, ProviderServices services)
             throws ServiceException {
             return new ExporttoKMLProvider(services,
                 (FLyrVect) parameters.getDynValue(PARAMETER_LAYER));
+        }
         public String getName() {
             return PROVIDER_NAME;
+        }
+    }

     /**
      * 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.
      */
     package org.gvsig.gpe.exportto.kml.panel;
     import java.awt.BorderLayout;
     import java.awt.FlowLayout;
     import java.awt.GridBagConstraints;
     import java.awt.GridBagLayout;
     import java.awt.Insets;
     import java.util.ArrayList;
     import javax.swing.JCheckBox;
     import javax.swing.JComboBox;
     import javax.swing.JComponent;
     import javax.swing.JLabel;
     import javax.swing.JPanel;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     import org.gvsig.exportto.swing.ExporttoSwingLocator;
     import org.gvsig.exportto.swing.ExporttoSwingManager;
     import org.gvsig.exportto.swing.spi.ExporttoPanelValidationException;
     import org.gvsig.exportto.swing.spi.ExporttoSwingProviderPanel;
     import org.gvsig.gpe.lib.api.writer.IGPEWriterHandler;
     import org.gvsig.gpe.lib.spi.GPEProviderLocator;
     /**
+     *
      * This addditional panel lets user choose KML
      * version and other options.
+     *
      * @author gvSIG Team
      * @version $Id$
+     *
      */
     public class KMLOptionsPanel extends JPanel implements ExporttoSwingProviderPanel {
         private static final long serialVersionUID = -3278172717881233447L;
         private static final Logger LOG = LoggerFactory
             .getLogger(KMLOptionsPanel.class);
         private static final ExporttoSwingManager EXPORTTO_SWING_MANAGER =
             ExporttoSwingLocator.getSwingManager();
         private boolean offerLabels = false;
         private boolean offerReproj = false;
         private JCheckBox labelsChk = null;
         private JCheckBox reproChk = null;
         private JCheckBox balloonsChk = null;
         private JComboBox versionCombo = null;
         public KMLOptionsPanel(boolean ofrLabels, boolean ofrReproj) {
             super();
             offerLabels = ofrLabels;
             offerReproj = ofrReproj;
             init();
+        }
         private void init() {
             this.setLayout(new BorderLayout());
             FlowLayout fl = new FlowLayout(FlowLayout.LEFT);
             JPanel topPanel = new JPanel(fl);
             // ====================================================
             JPanel gridPanel = new JPanel();
             gridPanel.setLayout(new GridBagLayout());
             GridBagConstraints gbc = new GridBagConstraints();
             gbc.anchor = GridBagConstraints.WEST;
             gbc.insets = new Insets(3, 3, 3, 3);
             gbc.gridx = 0;
             gbc.gridy = 0;
             gbc.gridwidth = 3;
             gridPanel.add(new JLabel(EXPORTTO_SWING_MANAGER.getTranslation("_Choose_KML_version")), gbc);
             gbc.gridx = 3;
             gbc.gridwidth = 3;
             gridPanel.add(getVersionsCombo(), gbc);
             // =====================
             gbc.gridx = 0;
             gbc.gridy = 1;
             gbc.gridwidth = 1;
             gridPanel.add(getBalloonsCheckbox(), gbc);
             gbc.gridx = 1;
             gbc.gridwidth = 5;
             gridPanel.add(new JLabel(EXPORTTO_SWING_MANAGER.getTranslation(
                     "_Show_attributes_in_balloon")), gbc);
             // =====================
             gbc.gridx = 0;
             gbc.gridy = 2;
             gbc.gridwidth = 1;
             gridPanel.add(getLabelsCheckbox(offerLabels), gbc);
             gbc.gridx = 1;
             gbc.gridwidth = 5;
             JLabel lbl_lbl = new JLabel(EXPORTTO_SWING_MANAGER.getTranslation("" +
             		"_Use_labels_Label_point_will_be_added_to_non_points"));
             lbl_lbl.setEnabled(offerLabels);
             gridPanel.add(lbl_lbl, gbc);
             // ====================================================
             gbc.gridx = 0;
             gbc.gridy = 3;
             gbc.gridwidth = 1;
             gridPanel.add(getReproCheckbox(offerReproj), gbc);
             gbc.gridx = 1;
             gbc.gridwidth = 5;
             JLabel rep_lbl = new JLabel(EXPORTTO_SWING_MANAGER.getTranslation(
                 "_Force_to_EPSG_4326"));
             rep_lbl.setEnabled(offerReproj);
             gridPanel.add(rep_lbl, gbc);
             // ====================================================
             topPanel.add(gridPanel);
             this.add(topPanel, BorderLayout.NORTH);
+        }
         private JCheckBox getLabelsCheckbox(boolean enabled) {
             if (labelsChk == null) {
                 labelsChk = new JCheckBox("");
                 labelsChk.setSelected(false);
                 labelsChk.setEnabled(enabled);
+            }
             return labelsChk;
+        }
         private JCheckBox getReproCheckbox(boolean enabled) {
             if (reproChk == null) {
                 reproChk = new JCheckBox("");
                 reproChk.setSelected(true);
                 reproChk.setEnabled(enabled);
+            }
             return reproChk;
+        }
         private JCheckBox getBalloonsCheckbox() {
             if (balloonsChk == null) {
                 balloonsChk = new JCheckBox("");
                 balloonsChk.setSelected(false);
+            }
             return balloonsChk;
+        }
         private JComboBox getVersionsCombo() {
             if (versionCombo == null) {
                 versionCombo = new JComboBox();
                 ArrayList list = GPEProviderLocator.getGPEProviderManager().getWriterHandlerByFormat("kml");
                 IGPEWriterHandler item = null;
                 String longn = null;
                 String shortn = null;
                 for (int i=0; i<list.size(); i++) {
                     item = (IGPEWriterHandler) list.get(i);
                     longn = item.getFormat();
                     shortn = getShortWithVersion(longn);
                     if (longn != null && shortn != null) {
                         versionCombo.addItem(new FormatListItem(longn, shortn));
+                    }
+                }
+            }
             return versionCombo;
+        }
         public String getPanelTitle() {
             return EXPORTTO_SWING_MANAGER.getTranslation("_KML_options");
+        }
         public boolean isValidPanel() throws ExporttoPanelValidationException {
             return getLongFormat() != null;
+        }
         /**
          * Returns null if not valid format
          */
         private String getShortWithVersion(String fmt) {
             // Example: "text/xml; subtype=gml/2.1.2" => "gml"
             if (fmt == null) {
                 return null;
+            }
             String[] parts = fmt.split(";");
             String aux = "";
             if (parts.length > 1) {
                 aux = parts[1].trim();
             } else {
                 return null;
+            }
             parts = aux.split("=");
             if (parts.length > 1) {
                 aux = parts[1].trim();
                 // Example: aux = "gml/2.1.2"
                 aux = aux.replaceAll("/", " ");
                 return aux.toUpperCase();
             } else {
                 return null;
+            }
+        }
         public void enterPanel() {
+        }
         public JComponent asJComponent() {
             return this;
+        }
         public class FormatListItem {
             private String longName = "";
             private String shortName = "";
             public FormatListItem(String longname, String shortname) {
                 longName = longname;
                 shortName = shortname;
+            }
             public String toString() {
                 return shortName;
+            }
             public String getLongFormat() {
                 return longName;
+            }
+        }
         // ==================================================
         // ==================================================
         public String getLongFormat() {
             Object obj = this.getVersionsCombo().getSelectedItem();
             if (obj instanceof FormatListItem) {
                 return ((FormatListItem) obj).getLongFormat();
             } else {
                 return null;
+            }
+        }
         public boolean useLabels() {
             return this.getLabelsCheckbox(false).isSelected();
+        }
         public boolean useBalloons() {
             return this.getBalloonsCheckbox().isSelected();
+        }
         public boolean mustReprojectToEpsg4326() {
             return this.getReproCheckbox(true).isSelected();
+        }
+    }

     package org.gvsig.gpe.exportto.kml.style;
     import java.io.IOException;
     import java.util.ArrayList;
     import java.util.List;
     import org.gvsig.xmlpull.lib.api.stream.IXmlStreamWriter;
     public class KmlCompoundStyle extends KmlStyle {
     	protected KmlIconStyle iconStyle = null;
     	protected KmlLineStyle lineStyle = null;
     	protected KmlPolygonStyle polygonStyle = null;
     	protected KmlLabelStyle labelStyle = null;
     	// protected KmlBalloonStyle balloonStyle = null;
     	public void writeXml(IXmlStreamWriter writer) throws IOException {
     		if (iconStyle != null)
     			iconStyle.writeXml(writer);
     		if (lineStyle != null)
     			lineStyle.writeXml(writer);
     		if (polygonStyle != null)
     			polygonStyle.writeXml(writer);
     		if (labelStyle != null)
     			labelStyle.writeXml(writer);
     		/*
             if (balloonStyle != null)
                 balloonStyle.writeXml(writer);
                 */
+    	}
     	public void addStyles(List<KmlStyle> list) {
     	    if (list != null) {
     	        for (int i=0; i<list.size(); i++) {
     	            addStyle(list.get(i));
+    	        }
+    	    }
+    	}
     	public List<KmlStyle> getStyles() {
     	    List<KmlStyle> resp = new ArrayList<KmlStyle>();
     	    if (iconStyle != null) {
     	        resp.add(iconStyle);
+    	    }
             if (lineStyle != null) {
                 resp.add(lineStyle);
+            }
             if (polygonStyle != null) {
                 resp.add(polygonStyle);
+            }
             if (labelStyle != null) {
                 resp.add(labelStyle);
+            }
     	    return resp;
+        }
     	public void addStyle(KmlStyle sty) {
     	    if (sty instanceof KmlIconStyle) {
     	        this.iconStyle = (KmlIconStyle) sty;
     	        return;
+    	    }
             if (sty instanceof KmlLineStyle) {
                 this.lineStyle = (KmlLineStyle) sty;
                 return;
+            }
             if (sty instanceof KmlPolygonStyle) {
                 this.polygonStyle = (KmlPolygonStyle) sty;
                 return;
+            }
             if (sty instanceof KmlLabelStyle) {
                 this.labelStyle = (KmlLabelStyle) sty;
                 return;
+            }
             if (sty instanceof KmlCompoundStyle) {
                 this.addStyles(((KmlCompoundStyle) sty).getStyles());
                 return;
+            }
+    	}
     	public KmlIconStyle getIconStyle() {
     		return iconStyle;
+    	}
     	public KmlLineStyle getLineStyle() {
     		return lineStyle;
+    	}
     	public KmlPolygonStyle getPolygonStyle() {
     		return polygonStyle;
+    	}
     	public KmlLabelStyle getLabelStyle() {
     		return labelStyle;
+    	}
     	/*
         public KmlBalloonStyle getBalloonStyle() {
             return balloonStyle;
+        }
         */
+    }

     package org.gvsig.gpe.exportto.kml.style;
     import java.io.IOException;
     import org.gvsig.gpe.prov.kml.utils.Kml2_1_Tags;
     import org.gvsig.xmlpull.lib.api.stream.IXmlStreamWriter;
     /**
      * Balloon style to show when user clicks on marker.
      * Currently not used because CDDATA is not written properly
      * (writer escapes it)
+     *
      * @author jldominguez
+     *
      */
     public class KmlBalloonStyle extends KmlStyle {
         private String[] fields = new String[0];
         public KmlBalloonStyle(String[] flds, String id) {
             setId(id);
             if (flds != null) {
                 fields = flds;
+            }
+        }
         public void writeXml(IXmlStreamWriter writer) throws IOException {
             writer.writeStartElement(Kml2_1_Tags.BALLOON_STYLE);
             writer.writeStartElement(Kml2_1_Tags.TEXT);
             // ====================================
             String cddata = "<![CDATA[";
             cddata = cddata + htmlTable();
             cddata = cddata + "]]>";
             // ====================================
             writer.writeValue(cddata);
             writer.writeEndElement();
             writer.writeEndElement();
             /*
       <Style id="golf-balloon-style">
         <BalloonStyle>
           <text>
             <![CDATA[
               <table>
               <tr><td>This is $[name]</td><td> : </td><td>This is $[name]</td></tr>
               <tr><td>This is hole $[holeNumber]</td><td> : </td><td>This is $[name]</td></tr>
               <tr><td>The par for this hole is $[holePar]</td><td> : </td><td>This is $[name]</td></tr>
               <tr><td>The yardage is $[holeYardage]</td><td> : </td><td><b>This is $[name]</b></td></tr>
               </table>
             ]]>
           </text>
         </BalloonStyle>
       </Style>
                */
+        }
         private String htmlTable() {
             String resp = "<table>\n";
             String aux = null;
             String auxrep = null;
             for (int i=0; i<fields.length; i++) {
                 aux = fields[i];
                 auxrep = aux.replace(' ', '_');
                 auxrep = "$[" + auxrep + "]";
                 resp = resp + "<tr><td>" + aux + "</td><td> : </td><td><b>" + auxrep + "</b></td></tr>\n";
+            }
             resp = resp + "</table>\n";
             return resp;
+        }
+    }

     package org.gvsig.gpe.exportto.kml.style;
     import java.io.IOException;
     import org.gvsig.gpe.prov.kml.utils.Kml2_1_Tags;
     import org.gvsig.gpe.prov.kml.utils.KmlUtilsParser;
     import org.gvsig.xmlpull.lib.api.stream.IXmlStreamWriter;
     public class KmlLineStyle extends KmlColorStyle {
     	public float getWidth() {
     		return width;
+    	}
     	public void setWidth(float width) {
     		this.width = width;
+    	}
     	protected float width = 1;
     	@Override
     	public void writeXml(IXmlStreamWriter writer) throws IOException {
     		writer.writeStartElement(Kml2_1_Tags.LINE_STYLE);
     		writer.writeStartElement(Kml2_1_Tags.COLOR);
     		writer.writeValue(KmlUtilsParser.fromColorToABGR(color));
     		writer.writeEndElement();
     		writer.writeStartElement(Kml2_1_Tags.WIDTH);
     		writer.writeValue(width);
     		writer.writeEndElement();
     		writer.writeEndElement();
+    	}
+    }

     package org.gvsig.gpe.exportto.kml.style;
     import java.io.IOException;
     import org.gvsig.gpe.prov.kml.utils.Kml2_1_Tags;
     import org.gvsig.gpe.prov.kml.utils.KmlUtilsParser;
     import org.gvsig.xmlpull.lib.api.stream.IXmlStreamWriter;
     /**
      * @author Francisco Jos? Pe?arrubia (fjp@scolab.es)
+     *
      * To convert from a symbol to a polygon style we will need a PolygonStyle
      * and a LineStyle if the outline has some width or to specify the color
      * @see @KmlCompoundStyle
      */
     public class KmlPolygonStyle extends KmlColorStyle {
     	protected boolean fill = true;
     	protected boolean outline;
     	public boolean isFill() {
     		return fill;
+    	}
     	public void setFill(boolean fill) {
     		this.fill = fill;
+    	}
     	public boolean isOutline() {
     		return outline;
+    	}
     	public void setOutline(boolean outline) {
     		this.outline = outline;
+    	}
     	@Override
     	public void writeXml(IXmlStreamWriter writer) throws IOException {
     		writer.writeStartElement(Kml2_1_Tags.POLY_STYLE);
     		writer.writeStartElement(Kml2_1_Tags.COLOR);
     		writer.writeValue(KmlUtilsParser.fromColorToABGR(color));
     		writer.writeEndElement();
     		if (!fill) {
     			writer.writeStartElement(Kml2_1_Tags.POLY_FILL);
     			writer.writeValue(0);
     			writer.writeEndElement();
+    		}
     		if (outline) {
     			writer.writeStartElement(Kml2_1_Tags.POLY_OUTLINE);
     			writer.writeValue(1);
     			writer.writeEndElement();
+    		}
     		writer.writeEndElement();
+    	}
+    }

     package org.gvsig.gpe.exportto.kml.style;
     import java.io.IOException;
     import org.gvsig.gpe.prov.kml.utils.Kml2_1_Tags;
     import org.gvsig.gpe.prov.kml.utils.KmlUtilsParser;
     import org.gvsig.xmlpull.lib.api.stream.IXmlStreamWriter;
     public class KmlIconStyle extends KmlColorStyle {
     	protected float heading = 0;
     	protected String href = null;
     	protected float scale = 1;
     	public float getScale() {
     		return scale;
+    	}
     	public void setScale(float scale) {
     		this.scale = scale;
+    	}
     	public void writeXml(IXmlStreamWriter writer) throws IOException {
     		writer.writeStartElement(Kml2_1_Tags.ICON_STYLE);
     		writer.writeStartElement(Kml2_1_Tags.COLOR);
     		writer.writeValue(KmlUtilsParser.fromColorToABGR(color));
     		writer.writeEndElement();
     		writer.writeStartElement(Kml2_1_Tags.HEADING);
     		writer.writeValue(heading);
     		writer.writeEndElement();
     		if (scale != 1) {
     			writer.writeStartElement(Kml2_1_Tags.SCALE);
     			writer.writeValue(scale);
     			writer.writeEndElement();

Application: gvSIG desktop » gvSIG data provider for GPE

Revision 760