Application: gvSIG desktop » gvSIG data provider for GPE

<?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.37</version>

  </parent>

  <modules>

    <module>org.gvsig.gpe.exportto.kml</module>  

    <module>org.gvsig.gpe.exportto.generic</module>  

  </modules>

</project>

org.gvsig.gpe.exportto.generic.ExporttoGPEGenericLibrary

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;

	}

}

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++;

	}

}

/**

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

    }

}

<?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.37</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.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 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();

		}

		if (href != null) {

			writer.writeStartElement(Kml2_1_Tags.ICON);

			writer.writeStartElement(Kml2_1_Tags.HREF);

			writer.writeValue(href);

			writer.writeEndElement();

			writer.writeEndElement();

		}

		writer.writeEndElement();

	}

	public float getHeading() {

		return heading;

	}

	public void setHeading(float heading) {

		this.heading = heading;

	}

	public String getHref() {

		return href;

	}

	public void setHref(String href) {

		this.href = href;

	}

}

package org.gvsig.gpe.exportto.kml.style;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

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

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

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

import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;

import org.gvsig.fmap.mapcontext.rendering.legend.IClassifiedVectorLegend;

import org.gvsig.fmap.mapcontext.rendering.legend.IVectorLegend;

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.fill.IFillSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.line.ILineSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.IMarkerSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.IPictureMarkerSymbol;

import org.gvsig.tools.dispose.DisposableIterator;

public class StyleUtils {

    public static Map<ISymbol, KmlStyle> getSymbolStyles(

        FLyrVect vlayer,

        FeatureSet fset,

        boolean balloon,

        String[] flds) throws Exception {

        boolean preventMarker = false;

        IVectorLegend leg = (IVectorLegend) vlayer.getLegend();

        Map<ISymbol, KmlStyle> resp = new HashMap<ISymbol, KmlStyle>();

        ISymbol defaultSym = leg.getDefaultSymbol();

        KmlStyle defaultStyle = getStyle(defaultSym);

        if (defaultSym != null && defaultStyle != null) {

            /*

             * This is used to set an empty icon style because

             * the geometry is not originally a point or multipoint 

             */

            preventMarker = !(defaultStyle instanceof KmlIconStyle);

            KmlCompoundStyle cs = new KmlCompoundStyle(); 

            cs.addStyle(defaultStyle);

            if (balloon) {

                // Not used, see javadoc of KmlBalloonStyle 

                // cs.addStyle(new KmlBalloonStyle(flds, "balloonStyle"));

            }

            if (preventMarker) {

                cs.addStyle(new KmlIconStyle());

            }

            cs.setId("defaultStyle");

            resp.put(defaultSym, cs);

        }

        if (leg instanceof IClassifiedVectorLegend) {

            IClassifiedVectorLegend cLeg = (IClassifiedVectorLegend) leg;

            ISymbol[] symbolsAux = cLeg.getSymbols();

            if (fset == null || symbolsAux.length < fset.getSize()) {

                for (int i=0; i < symbolsAux.length; i++) {

                    ISymbol s = symbolsAux[i];

                    KmlStyle style = getStyle(s);

                    if (s != null && style != null) {

                        preventMarker = !(style instanceof KmlIconStyle);

                        KmlCompoundStyle cs = new KmlCompoundStyle(); 

                        cs.addStyle(style);

                        if (balloon) {

                            // Not used, see javadoc of KmlBalloonStyle 

                            // cs.addStyle(new KmlBalloonStyle(flds, "bs" + Integer.toString(i)));

                        }

                        if (preventMarker) {

                            cs.addStyle(new KmlIconStyle());

                        }

                        cs.setId(Integer.toString(i));

                        resp.put(s, cs);

                    }

                }

            } else {

                DisposableIterator diter = null;

                diter = fset.fastIterator();

                Feature feat = null;

                int ind = 0;

                while (diter.hasNext()) {

                    feat = (Feature) diter.next();

                    ISymbol s = leg.getSymbolByFeature(feat);

                    KmlStyle style = getStyle(s);

                    if (s != null && style != null) {

                        preventMarker = !(style instanceof KmlIconStyle);

                        KmlCompoundStyle cs = new KmlCompoundStyle(); 

                        cs.addStyle(style);

                        if (balloon) {

                            // Not used, see javadoc of KmlBalloonStyle 

                            // cs.addStyle(new KmlBalloonStyle(flds, "bs" + Integer.toString(ind)));

                        }

                        if (preventMarker) {

                            cs.addStyle(new KmlIconStyle());

                        }

                        cs.setId(Integer.toString(ind));

                        resp.put(s, cs);

                        ind++;

                    }

                }

            }

        }

        return resp;

    }

    /**

     * Returns null if it cannot be rendered in KML

     * 

     * @param s

     * @return

     */

    public static KmlStyle getStyle(ISymbol s) {

        if (s == null) {

            return null;

        }

        if (s instanceof IPictureMarkerSymbol) {

            IPictureMarkerSymbol pms = (IPictureMarkerSymbol) s;

            String str = pms.getSource().toString();

            if (str != null && str.indexOf("http") == 0) {

                KmlIconStyle icoStyle = new KmlIconStyle();

                icoStyle.setColor(((IMarkerSymbol) s).getColor());

                icoStyle.setHref(str);

                float angKml = (float) radToKmlDeg(((IMarkerSymbol) s).getRotation());

                icoStyle.setHeading(angKml);

                return icoStyle;

            } else {

                // Simple marker not supported

                return null;

            }

        }

        if (s instanceof ILineSymbol) {

            ILineSymbol lSym = (ILineSymbol) s;

            KmlLineStyle lStyle = new KmlLineStyle();

            lStyle.setColor(lSym.getColor());

            lStyle.setWidth((float) lSym.getLineWidth());

            return lStyle;

        }

        if (s instanceof IFillSymbol) {

            IFillSymbol fSym = (IFillSymbol) s;

            KmlCompoundStyle cStyle = new KmlCompoundStyle();

            KmlLineStyle lStyle = new KmlLineStyle();

            ILineSymbol lSym = fSym.getOutline();

            lStyle.setColor(lSym.getColor());

            lStyle.setWidth((float) lSym.getLineWidth());

            KmlPolygonStyle fStyle = new KmlPolygonStyle();

            fStyle.setColor(fSym.getFillColor());

            fStyle.setOutline(fSym.hasOutline());

            fStyle.setFill(fSym.hasFill());

            cStyle.addStyle(lStyle);

            cStyle.addStyle(fStyle);

            return cStyle;

        }

        // Not supported

        return null;

    }

    public static double kmlDegToRad(double angleDegree) {

        double deg = 90 - angleDegree;

        return Math.toRadians(deg);

    }

    public static double radToKmlDeg(double rad) {

        double angleDegree = Math.toDegrees(rad);

        double deg = 90 - angleDegree;

        if (deg >= 360) {

            deg = deg - 360;

        }

        if (deg < 0) {

            deg = deg + 360;

        }

        return deg;

    }    

}

package org.gvsig.gpe.exportto.kml.style;

import java.awt.Color;

public abstract class KmlColorStyle extends KmlStyle {

	protected Color color = new Color(220, 10, 20, 80);

	public Color getColor() {

		return color;

	}

	public void setColor(Color color) {

		this.color = color;

	}

}

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)

 *

 * Labels are exported as features. Google Earth will render the attribute <name>

 * with this color.

 */

public class KmlLabelStyle extends KmlColorStyle {

	protected float scale = 1;

	public float getScale() {

		return scale;

	}

	public void setScale(float scale) {

		this.scale = scale;

	}

	@Override

	public void writeXml(IXmlStreamWriter writer) throws IOException {

		writer.writeStartElement(Kml2_1_Tags.LABEL_STYLE);

		writer.writeStartElement(Kml2_1_Tags.COLOR);

		writer.writeValue(KmlUtilsParser.fromColorToABGR(color));