Application: gvSIG desktop » gvSIG data provider for GPE

org.gvsig.gpe.exportto.kml.ExporttoKMLProviderLibrary

/**

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

/**

 * @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));

		writer.writeEndElement();

		if (scale != 1) {

			writer.writeStartElement(Kml2_1_Tags.SCALE);

			writer.writeValue(scale);

			writer.writeEndElement();

		}

		writer.writeEndElement();

	}

}

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

import java.io.IOException;

import org.gvsig.xmlpull.lib.api.stream.IXmlStreamWriter;

/**

 * @author Francisco Jos? Pe?arrubia (fjp@scolab.es)

 *

 * Useful to extend it and support writing styles and exchanging info from and to

 * outside of the library (in order to avoid dependencies)

 */

public abstract class KmlStyle {

	protected String id;

	public String getId() {

		return id;

	}

	public void setId(String id) {

		this.id = id;

	}

	public abstract void writeXml(IXmlStreamWriter writer) throws IOException;

}

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();

		}

		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;

	}

}

/**

 * 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.ICoordTrans;

import org.cresques.cts.IProjection;

import org.gvsig.exportto.ExporttoService;

import org.gvsig.exportto.swing.prov.file.AbstractExporttoFileProvider;

import org.gvsig.exportto.swing.spi.ExporttoSwingProvider;

import org.gvsig.exportto.swing.spi.ExporttoSwingProviderPanel;

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

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

import org.gvsig.gpe.exportto.kml.panel.KMLOptionsPanel;

import org.gvsig.tools.service.spi.ProviderServices;

/**

 * Exporto provider which gets Exporto from a file.

 * 

 * @author gvSIG Team

 * @version $Id$

 */

public class ExporttoKMLProvider extends AbstractExporttoFileProvider implements

    ExporttoSwingProvider {

    private FLyrVect vectorLayer = null;

    private KMLOptionsPanel optPanel = null;

    /**

     * 

     * Constructor.

     */

    public ExporttoKMLProvider(

        ProviderServices providerServices,

        FLyrVect vlayer) {

        super(

            providerServices,

            vlayer.getFeatureStore(),

            getTargetProjection(vlayer));

        vectorLayer = vlayer;

        IProjection viewProj = getTargetProjection(vlayer);

        boolean viewIs4326 = (viewProj.getAbrev().compareToIgnoreCase("epsg:4326") == 0);

        optPanel = new KMLOptionsPanel(vlayer.isLabeled(), !viewIs4326);

    }

    private static IProjection getTargetProjection(FLyrVect vlayer) {

        ICoordTrans ct = vlayer.getCoordTrans();

        if (ct == null) {

            return vlayer.getProjection();

        } else {

            return ct.getPDest();

        }

    }

    public ExporttoService createExporttoService() {

        return new ExporttoKMLService(

            selectFileOptionPanel.getSelectedFile(),

            featureStore,

            vectorLayer,

            optPanel.getLongFormat(),

            optPanel.useLabels(),

            optPanel.useBalloons(),

            optPanel.mustReprojectToEpsg4326());

    }

    public int getPanelCount() {

        return 2;

    }

    public ExporttoSwingProviderPanel getPanelAt(int index) {

        switch (index) {

        case 0:

            return optPanel;

        case 1:

            return selectFileOptionPanel;

        }

        return null;

    }}

/**

 * 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.gvsig.exportto.swing.ExporttoSwingLibrary;

import org.gvsig.exportto.swing.spi.ExporttoSwingProviderLocator;

import org.gvsig.gpe.exportto.generic.ExporttoGPEGenericLibrary;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

import org.gvsig.tools.service.spi.ProviderManager;

/**

 * Library to initialize and register the file Exporto provider

 * implementation.

 * 

 * @author gvSIG Team

 * @version $Id$

 */

public class ExporttoKMLProviderLibrary extends AbstractLibrary {

    public void doRegistration() {

        registerAsServiceOf(ExporttoSwingLibrary.class);

        require(ExporttoGPEGenericLibrary.class);

    }

    protected void doInitialize() throws LibraryException {

        // Nothing to do

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

        ProviderManager providerManager =

            ExporttoSwingProviderLocator.getManager();

        providerManager.addProviderFactory(new ExporttoKMLProviderFactory());

    }

}

/**

 * 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 java.awt.geom.Rectangle2D;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.exportto.ExporttoService;

import org.gvsig.exportto.ExporttoServiceException;

import org.gvsig.exportto.ExporttoServiceFinishAction;

import org.gvsig.exportto.swing.prov.file.AbstractExporttoFileService;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.spi.DataManagerProviderServices;

import org.gvsig.fmap.geom.DataTypes;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.exception.CreateEnvelopeException;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.mapcontext.MapContextException;

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

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

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

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

import org.gvsig.gpe.exportto.generic.util.CoordinatesSequenceBbox;

import org.gvsig.gpe.exportto.generic.util.GeometryToGPEWriter;

import org.gvsig.gpe.exportto.kml.style.KmlStyle;

import org.gvsig.gpe.exportto.kml.style.StyleUtils;

import org.gvsig.gpe.lib.api.GPELocator;

import org.gvsig.gpe.lib.api.writer.IGPEWriterHandler;

import org.gvsig.gpe.lib.api.writer.IGPEWriterHandlerImplementor;

import org.gvsig.gpe.prov.kml.utils.Kml2_1_Tags;

import org.gvsig.gpe.prov.kml.writer.GPEKmlWriterHandlerImplementor;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.task.AbstractMonitorableTask;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.xmlpull.lib.api.stream.IXmlStreamWriter;

/**

 * @author gvSIG Team

 * @version $Id$

 * 

 */

public class ExporttoKMLService extends AbstractMonitorableTask implements

    ExporttoService {

    private static Logger logger = LoggerFactory.getLogger(ExporttoKMLService.class);

    private FeatureStore featureStore = null;

    private FLyrVect vectorLayer = null;

    private List<ICoordTrans> transfList = new ArrayList<ICoordTrans>();

    private String mimeType = null;

    private File outFile = null;

    private boolean useLabels = false;

    private boolean attsAsBalloon = false;

    private boolean reprojectTo4326 = false;

    private IProjection targetproj = null;

    private NewFeatureStoreParameters newFeatureStoreParameters;

    private ExporttoServiceFinishAction exporttoServiceFinishAction;

    public ExporttoKMLService(

        File kmlFile,

        FeatureStore fstore,

        FLyrVect vlayer,

        String mtype,

        boolean doLabels,

        boolean balloon,

        boolean reproject4326) {

        super("Export to KML");

        outFile = kmlFile;

        featureStore = fstore;

        vectorLayer = vlayer;

        mimeType = mtype;

        useLabels = doLabels;

        attsAsBalloon = balloon;

        reprojectTo4326 = reproject4326;

        ICoordTrans ct = vlayer.getCoordTrans(); 

        if (reprojectTo4326) {

            targetproj = CRSFactory.getCRS("EPSG:4326");

            if (ct == null) {

                transfList.add(vlayer.getProjection().getCT(targetproj));

            } else {

                transfList.add(ct);

                transfList.add(ct.getPDest().getCT(targetproj));

            }

        } else {

            if (ct == null) {

                targetproj = vectorLayer.getProjection();

            } else {

                targetproj = ct.getPDest();

                transfList.add(ct);

            }

        }

    }

    public NewFeatureStoreParameters getNewFeatureStoreParameters() {

        return newFeatureStoreParameters;

    }

    public void addParameters(

        NewFeatureStoreParameters newFeatureStoreParameters) {

        newFeatureStoreParameters.setDynValue("CRS", targetproj);

    }

    public String getFileExtension() {

        return "kml";

    }

    public void export(FeatureSet featureSet) throws ExporttoServiceException {

        IGPEWriterHandler wh = null;

        FileOutputStream fos = null;

        String srs = targetproj.getAbrev();

        String[] fldNames = null;

        Envelope env = null;

        long count = 0;

        try {

            count = featureSet.getSize();

            this.taskStatus.setRangeOfValues(0, count);

            fldNames = getAttributes(featureStore.getDefaultFeatureType());

            env = this.featureStore.getEnvelope();

        } catch (DataException e) {

            throw new ExporttoServiceException(e);

        }

        try {

            env = reproject(env);

        } catch (CreateEnvelopeException cee) {

            throw new ExporttoServiceException(cee);

        }

        Rectangle2D rect = new Rectangle2D.Double(

            env.getMinimum(0),

            env.getMinimum(1),

            env.getLength(0),

            env.getLength(1));

        File fixedFile = outFile;

        try {

            if (!outFile.getAbsolutePath().toLowerCase().endsWith(

                "." + this.getFileExtension().toLowerCase())) {

                fixedFile = new File(outFile.getAbsolutePath() + "." + getFileExtension());

            }

            wh = GPELocator.getGPEManager().createWriterByMimeType(mimeType);

            fos = new FileOutputStream(fixedFile);

            wh.setOutputStream(fos);

            wh.initialize();

            // ==========================================

            wh.startLayer(null, null, fixedFile.getName(), null, srs);

            // ==============     Styles    =============

            Map<ISymbol, KmlStyle> symsty = null;

            IXmlStreamWriter xmlw = getXmlStreamWriter(wh);

            if (true && xmlw != null) {

                symsty = StyleUtils.getSymbolStyles(

                    vectorLayer,

                    featureSet,

                    attsAsBalloon,

                    fldNames);

                Iterator<KmlStyle> iter = symsty.values().iterator();

                KmlStyle sty = null;

                while (iter.hasNext()) {

                    sty = iter.next();

                    writeStyle(xmlw, sty);

                }

            }

            // ==========================================

            wh.startBbox(null, new CoordinatesSequenceBbox(rect), srs);

            wh.endBbox();

            // ============= Writing feature ============

            writeFeatures(wh, xmlw, featureSet, fldNames, symsty,

                (IVectorLegend) vectorLayer.getLegend());

            // ==========================================

            wh.endLayer();

            // ==========================================

            wh.close();

            fos.close();

        } catch (Exception exc) {

            throw new ExporttoServiceException(exc);

        }

        this.taskStatus.setCurValue(count);

        this.taskStatus.terminate();

        this.finishAction(fixedFile, this.targetproj);

    }

    private Envelope reproject(Envelope env) throws CreateEnvelopeException {

        int sz = transfList.size(); 

        if (sz == 0) {

            return env;

        } else {

            Envelope resp = env;

            try {

                for (int i=0; i<sz; i++) {

                    resp = resp.convert(transfList.get(i));

                }

            } catch (Exception exc) {

                // If this process fails, we'll use "emergency values":

                GeometryManager gm = GeometryLocator.getGeometryManager();

                double[] min = new double[2];

                double[] max = new double[2];

                if (targetproj.isProjected()) {

                    min = new double[]{-20000000, -20000000};

                    max = new double[]{ 20000000,  20000000};

                } else {

                    min = new double[]{-180, -90};

                    max = new double[]{ 180,  90};

                }

                resp = gm.createEnvelope(

                    min[0], min[1],

                    max[0], max[1],

                    Geometry.SUBTYPES.GEOM2D);

            }

            return resp;

        }

    }

    private void writeStyle(IXmlStreamWriter xmlw, KmlStyle sty) throws IOException {

        xmlw.writeStartElement(Kml2_1_Tags.STYLE);

        xmlw.writeStartAttribute(Kml2_1_Tags.ID);

        xmlw.writeValue(sty.getId());           

        xmlw.writeEndAttributes();    

        sty.writeXml(xmlw);

        xmlw.writeEndElement();        

    }

    private IXmlStreamWriter getXmlStreamWriter(IGPEWriterHandler wh) {

        IGPEWriterHandlerImplementor imple = wh.getImplementor();

        if (!(imple instanceof GPEKmlWriterHandlerImplementor)) {

            /*

             * Unexpected class

             */

            return null;

        }

        GPEKmlWriterHandlerImplementor kmlimple = null;

        kmlimple = (GPEKmlWriterHandlerImplementor) imple;

        IXmlStreamWriter xmlw = kmlimple.getXMLStreamWriter();   

        return xmlw;

    }

    private void finishAction(File kmlfile, IProjection proj)

    throws ExporttoServiceException {

        if (exporttoServiceFinishAction != null) {

            /*

             * Export is done. We notify with a SHPStoreParameters,

             * not with the NewSHPParameters we have used:

             */

            DataManagerProviderServices dataman =

                (DataManagerProviderServices) DALLocator.getDataManager();

            DataStoreParameters dsp = null;

            try {

                dsp = dataman.createStoreParameters("GPE");

            } catch (Exception e) {

                throw new ExporttoServiceException(

                    "Cannot add resulting kml file to view", e);

            }

            dsp.setDynValue("File", kmlfile);

            dsp.setDynValue("CRS", proj);

            try {

                dsp.validate();

            } catch (ValidateDataParametersException e) {

                throw new ExporttoServiceException(e);

            }

            exporttoServiceFinishAction.finished(kmlfile.getName(), dsp);

        }

    }    

    private String[] getAttributes(FeatureType ftype) {

        FeatureAttributeDescriptor[] atts =  ftype.getAttributeDescriptors();

        FeatureAttributeDescriptor desc = null;

        List<String> list = new ArrayList<String>();

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

            desc = atts[i];

            if (desc.getDataType().getType() != DataTypes.GEOMETRY) {

                list.add(desc.getName());

            }

        }

        return list.toArray(new String[0]);

    }

    private void writeFeatures(

        IGPEWriterHandler gwh,

        IXmlStreamWriter xmlw,

        FeatureSet fset,

        String[] fieldNames,

        Map<ISymbol, KmlStyle> symsty,

        IVectorLegend lege) throws Exception {

        GeometryToGPEWriter gw = new GeometryToGPEWriter(gwh);