Application: gvSIG desktop » gvSIG legends: base legends

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

  <parent>

    <groupId>org.gvsig</groupId>

    <artifactId>org.gvsig.legend.urbanhorizontalsignage</artifactId>

    <version>1.0.1</version>

  </parent>

  <groupId>org.gvsig</groupId>

  <artifactId>org.gvsig.legend.urbanhorizontalsignage.app</artifactId>

  <packaging>pom</packaging>

  <name>org.gvsig.legend.urbanhorizontalsignage.app</name>

  <modules>

    <module>org.gvsig.legend.urbanhorizontalsignage.app.mainplugin</module>

  </modules>

</project>

#Thu Jul 01 12:56:58 CEST 2021

buildNumber=89

<!-- 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. -->

<assembly>

  <id>gvsig-plugin-package</id>

  <formats>

    <format>zip</format>

  </formats>

  <baseDirectory>${project.artifactId}</baseDirectory>

  <includeBaseDirectory>true</includeBaseDirectory>

  <files>

    <file>

      <source>target/${project.artifactId}-${project.version}.jar</source>

      <outputDirectory>lib</outputDirectory>

    </file>

    <file>

      <source>target/package.info</source>

    </file>

  </files>

  <fileSets>

    <fileSet>

      <directory>src/main/resources-plugin</directory>

      <outputDirectory>.</outputDirectory>

    </fileSet>

  </fileSets>

  <dependencySets>

    <dependencySet>

      <useProjectArtifact>false</useProjectArtifact>

      <useTransitiveDependencies>false</useTransitiveDependencies>

      <outputDirectory>lib</outputDirectory>

      <includes>

        <include>org.gvsig:org.gvsig.legend.urbanhorizontalsignage.lib.api</include>

        <include>org.gvsig:org.gvsig.legend.urbanhorizontalsignage.lib.impl</include>

        <include>org.gvsig:org.gvsig.legend.urbanhorizontalsignage.swing.api</include>

        <include>org.gvsig:org.gvsig.legend.urbanhorizontalsignage.swing.impl</include>

      </includes>

    </dependencySet>

  </dependencySets>

</assembly>

package org.gvsig.legend.urbanhorizontalsignage.app;

import java.io.File;

import java.util.UUID;

import javax.swing.JOptionPane;

import org.gvsig.andami.IconThemeHelper;

import org.gvsig.andami.plugins.Extension;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.ApplicationManager;

import org.gvsig.app.project.documents.view.ViewDocument;

import org.gvsig.app.project.documents.view.ViewManager;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.store.jdbc.JDBCNewStoreParameters;

import org.gvsig.fmap.dal.store.jdbc.JDBCServerExplorer;

import org.gvsig.fmap.dal.store.jdbc.JDBCServerExplorerParameters;

import org.gvsig.fmap.geom.DataTypes;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.aggregate.MultiPolygon;

import org.gvsig.fmap.mapcontext.MapContext;

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

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.CONTINUITY_MODE_CONT_DISC;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.CONTINUITY_MODE_DISC;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.CONTINUITY_MODE_DISC_CONT;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.CONTINUITY_MODE_DISC_DISC;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageLegend;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageLocator;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageManager;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.folders.FoldersManager;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.util.HasAFile;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class UrbanHorizontalSignageExtension extends Extension {

    private static final Logger LOGGER = LoggerFactory.getLogger(UrbanHorizontalSignageExtension.class);

    @Override

    public void initialize() {

        IconThemeHelper.registerIcon("legend", "legend-overview-vectorial-urbanhorizontalsignage", this);

        IconThemeHelper.registerIcon("action", "layer-modify-clipboard-copy-as-polygons", this);

    }

    @Override

    public void execute(String actionCommand) {

        if (actionCommand.compareToIgnoreCase("layer-modify-clipboard-copy-as-polygons") != 0) {

            return;

        }

        DataManager dataManager = DALLocator.getDataManager();

        ApplicationManager application = ApplicationLocator.getManager();

        ViewDocument viewdoc = (ViewDocument) application.getActiveDocument(ViewManager.TYPENAME);

        if (viewdoc == null) {

            return;

        }

        MapContext mapContext = viewdoc.getMapContext();

        FLyrVect layer = mapContext.getLayers().getFirstActiveVectorLayer();

        if (layer == null) {

            return;

        }

        UrbanHorizontalSignageManager uhsManager = UrbanHorizontalSignageLocator.getUrbanHorizontalSignageManager();

        UrbanHorizontalSignageLegend legend = (UrbanHorizontalSignageLegend) layer.getLegend();

        EditableFeatureType targetFeatureType = createTargetFeatureType(layer.getFeatureStore());

        FeatureStore targetStore = createTemporalStore(targetFeatureType);

        FeatureSet featureSet = null;

        try {

            targetStore.edit(FeatureStore.MODE_APPEND);

            FeatureSelection selection = layer.getFeatureStore().getFeatureSelection();

            for (Feature feature : selection) {

                Geometry originalGeometry = feature.getDefaultGeometry();

                UrbanHorizontalSignageData data = legend.getValues(feature);

                uhsManager.calculateGeometries(originalGeometry, data);

                MultiPolygon multiGeom = data.getSegmentsGeometry();

                if (multiGeom != null && multiGeom.getPrimitivesNumber() > 0) {

                    for (Geometry geometry : multiGeom) {

                        EditableFeature targetFeature = targetStore.createNewFeature();

                        targetFeature.copyFrom(feature, (FeatureAttributeDescriptor t) -> !(t.isPrimaryKey() || (t.isIndexed() && !t.allowIndexDuplicateds()) || t.getType() == DataTypes.GEOMETRY));

                        targetFeature.setDefaultGeometry(geometry);

                        targetStore.insert(targetFeature);

                    }

                }

                switch (data.getContinuity()) {

                    case CONTINUITY_MODE_CONT_DISC:

                    case CONTINUITY_MODE_DISC_CONT:

                    case CONTINUITY_MODE_DISC:

                    case CONTINUITY_MODE_DISC_DISC:

                        if (data.isPaintHoles()) {

                            multiGeom = data.getHolesGeometry();

                            if (multiGeom != null && multiGeom.getPrimitivesNumber() > 0) {

                                for (Geometry geometry : multiGeom) {

                                    EditableFeature targetFeature = targetStore.createNewFeature();

                                    targetFeature.copyFrom(feature, (FeatureAttributeDescriptor t) -> !(t.isPrimaryKey() || (t.isIndexed() && !t.allowIndexDuplicateds()) || t.getType() == DataTypes.GEOMETRY));

                                    targetFeature.setDefaultGeometry(geometry);

                                    targetStore.insert(targetFeature);

                                }

                            }

                        }

                }

            }

            targetStore.finishEditing();

            featureSet = targetStore.getFeatureSet();

            I18nManager i18n = ToolsLocator.getI18nManager();

            int n = application.confirmDialog(

                    "_Number_of_geometries_to_be_copied_to_the_clipboard" + " " + featureSet.getSize() + "\n" + "_Do_you_want_to_continue",

                    i18n.getTranslation("_Copy_selected_features_as_polygons_to_clipboard"),

                    JOptionPane.YES_NO_OPTION,

                    JOptionPane.QUESTION_MESSAGE);

            if (n == JOptionPane.YES_OPTION) {

                dataManager.putFeaturesInClipboard(featureSet);

            }

        } catch (Exception e) {

            LOGGER.warn("Can't get the selection as JSON.", e);

        } finally {

            DisposeUtils.disposeQuietly(targetStore);

            DisposeUtils.disposeQuietly(featureSet);

        }

    }

    private EditableFeatureType createTargetFeatureType(FeatureStore store) {

        DataManager dataManager = DALLocator.getDataManager();

        EditableFeatureType featureType = dataManager.createFeatureType();

        featureType.addAll(store.getDefaultFeatureTypeQuietly());

        EditableFeatureAttributeDescriptor attr = (EditableFeatureAttributeDescriptor) featureType.getDefaultGeometryAttribute();

        attr.setGeometryType(Geometry.TYPES.POLYGON, Geometry.SUBTYPES.GEOM2D);

        return featureType;

    }

    private FeatureStore createTemporalStore(EditableFeatureType featType) {

        if (featType.getStore() != null) {

            throw new IllegalArgumentException("Can't create temporal store from a feature type of a already existent store.");

        }

        try {

            // crear ruta de archivo temporal

            FoldersManager foldersManager = ToolsLocator.getFoldersManager();

            File tempFile = foldersManager.getUniqueTemporaryFile("urbanHorizontalSignage_temporal_store_" + UUID.randomUUID().toString());

            // crear SERVER STORE

            DataManager dataManager = DALLocator.getDataManager();

            JDBCServerExplorerParameters serverParameters = (JDBCServerExplorerParameters) dataManager.createServerExplorerParameters("H2Spatial");

            ((HasAFile) serverParameters).setFile(tempFile);

            JDBCServerExplorer serverExplorer = (JDBCServerExplorer) dataManager.openServerExplorer("H2Spatial", serverParameters);

            //Crear tablas en server store

            JDBCNewStoreParameters parametersResults = serverExplorer.getAddParameters();

            parametersResults.setDynValue("Table", "results");

            parametersResults.setDefaultFeatureType(featType);

            serverExplorer.add("H2Spatial", parametersResults, true);

            DataStoreParameters storeParametersResults = dataManager.createStoreParameters("H2Spatial");

            storeParametersResults.setDynValue("database_file", tempFile);

            storeParametersResults.setDynValue("Table", "results");

            //Creaci?n del store con los resultados

            FeatureStore storeResults = (FeatureStore) dataManager.openStore("H2Spatial", storeParametersResults);

            return storeResults;

        } catch (Exception ex) {

            LOGGER.debug("Can't create temporal store.", ex);

            return null;

        }

    }

    @Override

    public boolean isEnabled() {

        // it's enabled if there is exactly one vector layer in the active view

        // and it has a selection

        ApplicationManager application = ApplicationLocator.getManager();

        ViewDocument viewdoc = (ViewDocument) application.getActiveDocument(ViewManager.TYPENAME);

        if (viewdoc == null) {

            return false;

        }

        MapContext mapContext = viewdoc.getMapContext();

        FLyrVect layer = mapContext.getLayers().getFirstActiveVectorLayer();

        if (layer == null) {

            return false;

        }

        if (!layer.isAvailable()) {

            // This can happen when opening a persisted project

            // and there is a "slow" layer (GeoDB)

            return false;

        }

        try {

            FeatureStore store = layer.getFeatureStore();

            FeatureSelection selection = store.getFeatureSelection();

            if (selection.isEmpty()) {

                return false;

            }

            return (layer.getLegend() instanceof UrbanHorizontalSignageLegend);

//            return !selection.isEmpty();

        } catch (Exception ex) {

            LOGGER.warn("Can't get selection from layer '" + layer.getName() + "'.", ex);

            return false;

        }

    }

    @Override

    public boolean isVisible() {

        ApplicationManager application = ApplicationLocator.getManager();

        return application.getActiveDocument(ViewManager.TYPENAME) != null;

    }

}

<?xml version="1.0" encoding="ISO-8859-1"?>

<!-- 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. -->

<plugin-config>

  <depends plugin-name="org.gvsig.app.mainplugin" />

  <resourceBundle name="text" />

  <libraries library-dir="lib" />

  <extensions>

      <extension class-name="org.gvsig.legend.urbanhorizontalsignage.app.UrbanHorizontalSignageExtension"

                 description="" active="true" priority="1">

          <action

              name="layer-modify-clipboard-copy-as-polygons"

              label="_Copy_selected_features_as_polygons_to_clipboard"

              tooltip="_Copy_selected_features_as_polygons_to_clipboard"

              position="601105001"

              action-command="layer-modify-clipboard-copy-as-polygons"

              icon="layer-modify-clipboard-copy-as-polygons"

              accelerator=""

          />

          <menu

              name="layer-modify-clipboard-copy-as-polygons"

              text="Layer/Modify/_Copy_selected_features_as_polygons_to_clipboard"

          />

<!--          <tool-bar name="edit">

              <action-tool

                  name="layer-modify-clipboard-copy-as-polygons"

              />

          </tool-bar>-->

      </extension>

  </extensions>

</plugin-config>

<?xml version="1.0"?>

<!--

Definitions of plugin persistence org.gvsig.aggregatelegend.app.mainplugin

 -->

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="org.gvsig.legend.urbanhorizontalsignage.app.mainplugin">

      <extends>

      </extends>

      <description>Persistence of the legend of urban horizontal signage</description>

      <fields>

      </fields>

    </class>

  </classes>

</definitions>  

_Urban_horizontal_signage_legend_description=Urban horizontal signage legend

_Urban_horizontal_signage_legend=Urban horizontal signage

_Width_field=Width field

_Continuity_field=Continuity field

_Segments_color_field=Segments color field

_Segments_length_field=Segments length field

_Paint_holes_field=Paint holes field

_Holes_color_field=Holes color field

_Holes_length_field=Holes length field

_Round_vertex_field=Round vertex field

_Gap_width_between_lines=Gap width between lines

_Copy_selected_features_as_polygons_to_clipboard=Copy selected features as polygons to clipboard

_Number_of_geometries_to_be_copied_to_the_clipboard=Number of geometries to be copied to the clipboard

_Do_you_want_to_continue=Do you want to continue?

_Urban_horizontal_signage_legend_description=Leyenda para la se\u00f1alizaci\u00f3n urbana horizontal

_Urban_horizontal_signage_legend=Se\u00f1alizaci\u00f3n urbana horizontal

_Width_field=Campo para la anchura

_Continuity_field=Campo para la continuidad

_Segments_color_field=Campo para el color de los segmentos

_Segments_length_field=Campo para la longitud de los segmentos

_Paint_holes_field=Campo para el pintado de los huecos

_Holes_color_field=Campo para el color de los huecos

_Holes_length_field=Campo para la longitud de los huecos

_Round_vertex_field=Campo para el redondeo de los v\u00e9rtices

_Gap_width_between_lines=Separaci\u00f3n entre l\u00edneas

_Copy_selected_features_as_polygons_to_clipboard=Copiar elementos seleccionados como pol\u00edgonos al portapapeles

_Number_of_geometries_to_be_copied_to_the_clipboard=N\u00famero de geometr\u00edas a ser copiadas al portapapeles

_Do_you_want_to_continue=\u00bfDesea continuar?

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

  <parent>

    <groupId>org.gvsig</groupId>

    <artifactId>org.gvsig.legend.urbanhorizontalsignage.app</artifactId>

    <version>1.0.1</version>

  </parent>

  <groupId>org.gvsig</groupId>

  <artifactId>org.gvsig.legend.urbanhorizontalsignage.app.mainplugin</artifactId>

  <version>1.0.1</version>

  <name>org.gvsig.legend.urbanhorizontalsignage.app.mainplugin</name>

    <properties>

    <!-- Package info property values -->

    <gvsig.package.info.state>testing</gvsig.package.info.state>

    <gvsig.package.info.dependencies>required: org.gvsig.app.mainplugin -ge 2.4.0-A</gvsig.package.info.dependencies>

    <gvsig.package.info.official>true</gvsig.package.info.official>

    <gvsig.package.info.name>Vector legend: urban horizaontal signage</gvsig.package.info.name>

    <gvsig.package.info.description>Legend for urban horizaontal signage.</gvsig.package.info.description>

    <gvsig.package.info.categories>View,Vector,Symbology</gvsig.package.info.categories>

    <gvsig.package.info.javaVM>j1_8</gvsig.package.info.javaVM>

    <gvsig.package.info.poolURL>https://devel.gvsig.org/download/projects/gvsig-base-legends/pool</gvsig.package.info.poolURL>

  </properties>

  <dependencies>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.andami</artifactId>

      <scope>compile</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.legend.urbanhorizontalsignage.swing.api</artifactId>

      <scope>compile</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.legend.urbanhorizontalsignage.lib.api</artifactId>

      <scope>compile</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.legend.urbanhorizontalsignage.lib.impl</artifactId>

      <scope>runtime</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.legend.urbanhorizontalsignage.swing.impl</artifactId>

      <scope>runtime</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.app.mainplugin</artifactId>

      <scope>compile</scope>

    </dependency>

  </dependencies>

</project>

package org.gvsig.legend.urbanhorizontalsignage.lib.impl;

import java.util.List;

import junit.framework.TestCase;

import org.gvsig.fmap.geom.GeometryUtils;

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

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

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageLocator;

import org.gvsig.tools.library.impl.DefaultLibrariesInitializer;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class Test01CalculateGeometries extends TestCase {

    private static final Logger LOGGER = LoggerFactory.getLogger(Test01CalculateGeometries.class);

    public Test01CalculateGeometries(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp();

        new DefaultLibrariesInitializer().fullInitialize();

    }

    @Override

    protected void tearDown() throws Exception {

        super.tearDown();

    }

    // TODO add test methods here. The name must begin with 'test'. For example:

    // public void testHello() {}

    public void test01CalculateIntermediatePoint() {

        final String testid = "calculateIntermediatePoint";

        Point p1 = GeometryUtils.createPoint(0,0);

        Point p2 = GeometryUtils.createPoint(10,0);

        DefaultUrbanHorizontalSignageManager uhsManager = (DefaultUrbanHorizontalSignageManager)UrbanHorizontalSignageLocator.getUrbanHorizontalSignageManager();

        try {

            for (double lambda = 0; lambda <= 1; lambda += 0.1) {

                Point intermediatePoint = uhsManager.calculateIntermediatePoint(p1, p2, lambda);

                assertEquals(10*lambda, intermediatePoint.getCoordinateAt(0));

                assertEquals(0.0, intermediatePoint.getCoordinateAt(1));

            }

        } catch (Exception ex) {

            //TODO:

            fail(ex.getMessage());

        }

    }

    public void test02SplitLine() throws Exception {

        final String testid = "splitLine";

        Point p1 = GeometryUtils.createPoint(0,0);

        Point p2 = GeometryUtils.createPoint(10,0);

        Line line = GeometryUtils.createLine(p1, p2, 0);

        DefaultUrbanHorizontalSignageManager uhsManager = (DefaultUrbanHorizontalSignageManager)UrbanHorizontalSignageLocator.getUrbanHorizontalSignageManager();

//        UrbanHorizontalSignageData data = uhsManager.createUrbanHorizontalSignageData();

//        data.setWidth(20);

//        data.setContinuity(UrbanHorizontalSignageData.DEFAULT_CONTINUITY_VALUE);

//        data.setSegmentsLength(100);

//        data.setHolesLength(50);

//        data.setGapWith(10);

//        data.setSegmentsColor(Color.RED);

//        data.setHolesColor(Color.BLACK);

//        data.setRoundVertex(false);

//        data.setPaintHoles(true);

        DefaultUrbanHorizontalSignageManager.SplittedLine splittedLine = uhsManager.splitLine(line, 1, 0.5);

        List<Line> segments = splittedLine.getSegments();

        List<Line> holes = splittedLine.getHoles();

        assertEquals(7, segments.size());

        assertEquals(6, holes.size());

        double x = 0;

        for (Line segment : segments) {

            assertEquals(x, segment.getVertex(0).getX());

            assertEquals(x+1.0, segment.getVertex(1).getX());

            x += 1.50;

        }

        x = 1.0;

        for (Line hole : holes) {

            assertEquals(x, hole.getVertex(0).getX());

            assertEquals(x+0.5, hole.getVertex(1).getX());

            x += 1.50;

        }

    }

}

<?xml version="1.0"?>

<definitions>

    <version>1.0.0</version>

    <classes>

        <class name="DefaultUrbanHorizontalSignageLegend">

            <extends>

                <class name="VectorialLegend" namespace="persistence"/>

            </extends>

            <fields>

                <field name="widthFieldName" type="String" defaultValue="">

                    <description></description>

                </field>

                <field name="continuityFieldName" type="String" defaultValue="">

                    <description></description>

                </field>

                <field name="segmentsColorFieldName" type="String" defaultValue="">

                    <description></description>

                </field>

                <field name="segmentsLengthFieldName" type="String" defaultValue="">

                    <description></description>

                </field>

                <field name="holesLengthFieldName" type="String" defaultValue="">

                    <description></description>

                </field>

                <field name="paintHolesFieldName" type="String" defaultValue="">

                    <description></description>

                </field>

                <field name="holesColorFieldName" type="String" defaultValue="">

                    <description></description>

                </field>

                <field name="roundVertexFieldName" type="String" defaultValue="">

                    <description></description>

                </field>

                <field name="gapWidth" type="Integer" defaultValue="15">

                    <description></description>

                </field>

            </fields>

        </class>

        <class name="UrbanHorizontalSignageSymbol">

            <extends>

                <class name="Symbol" namespace="persistence"/>

            </extends>

            <fields>

                <field name="width" type="Double" defaultValue="0.15" mandatory="false">

                    <description></description>

                </field>

                <field name="continuity" type="Integer" defaultValue="1" mandatory="false">

                    <description></description>

                </field>

                <field name="segmentsColor" type="Object" ClassOfValue="java.awt.Color" defaultValue="blue" mandatory="false">

                    <description></description>

                </field>

                <field name="segmentsLength" type="Double" defaultValue="0.5" mandatory="false">

                    <description></description>

                </field>

                <field name="holesColor" type="Object" ClassOfValue="java.awt.Color" defaultValue="black" mandatory="false">

                    <description></description>

                </field>

                <field name="holesLength" type="Double" defaultValue="0.5" mandatory="false">

                    <description></description>

                </field>

                <field name="paintHoles" type="Boolean" defaultValue="false" mandatory="false">

                    <description></description>

                </field>

                <field name="gapWidth" type="Double" defaultValue="0.15" mandatory="false">

                    <description></description>

                </field>

                <field name="roundVertex" type="Boolean" defaultValue="false" mandatory="false">

                    <description></description>

                </field>

                <field name="transparency" type="Double" defaultValue="1.0" mandatory="false">

                    <description></description>

                </field>

                <field name="mustDrawOriginalGeometry" type="Boolean" defaultValue="false" mandatory="false">

                    <description></description>

                </field>

                <field name="colorForOriginalGeometry" type="Object" ClassOfValue="java.awt.Color" defaultValue="yellow" mandatory="false">

                    <description></description>

                </field>

            </fields>

        </class>

    </classes>

</definitions>

org.gvsig.legend.urbanhorizontalsignage.lib.impl.UrbanHorizontalSignageLibraryImpl

/**

 * 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.legend.urbanhorizontalsignage.lib.impl;

import java.awt.Color;

import java.awt.Graphics2D;

import java.awt.Rectangle;

import java.awt.geom.AffineTransform;

import java.util.concurrent.Callable;

import org.gvsig.compat.print.PrintAttributes;

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.GeometryUtils;

import org.gvsig.fmap.geom.aggregate.MultiPolygon;

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

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

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

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.ViewPort;

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

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

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

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

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.CONTINUITY_MODE_CONT_DISC;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.CONTINUITY_MODE_DISC;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.CONTINUITY_MODE_DISC_CONT;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.CONTINUITY_MODE_DISC_DISC;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageLocator;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageManager;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.impl.AbstractSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.impl.CartographicSupportToolkit;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.swing.api.TransparencySupport;

import org.gvsig.tools.task.Cancellable;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class UrbanHorizontalSignageSymbol extends AbstractSymbol implements ISymbol_v2, TransparencySupport {

    private static final Logger LOG = LoggerFactory.getLogger(UrbanHorizontalSignageSymbol.class);

    private static final String SYMBOL_NAME = "UrbanHorizontalSignageSymbol";

    private static final String URBAN_HORIZONTAL_SIGNAGE_SYMBOL_PERSISTENCE_DEFINITION_NAME = "UrbanHorizontalSignageSymbol";

    private static final String FIELD_WIDTH = "width";

    private static final String FIELD_CONTINUITY = "continuity";

    private static final String FIELD_SEGMENTS_COLOR = "segmentsColor";

    private static final String FIELD_SEGMENTS_LENGTH = "segmentsLength";

    private static final String FIELD_HOLES_COLOR = "holesColor";

    private static final String FIELD_HOLES_LENGTH = "holesLength";

    private static final String FIELD_PAINT_HOLES = "paintHoles";

    private static final String FIELD_GAP_WIDTH = "gapWidth";

    private static final String FIELD_ROUND_VERTEX = "roundVertex";

    private static final String FIELD_SEGMENTS_GEOMETRY = "segmentsGeometry";

    private static final String FIELD_HOLES_GEOMETRY = "holesGeometry";

    private static final String FIELD_TRANSPARENCY = "transparency";

    private static final String FIELD_MUST_DRAW_ORIGINAL_GEOMETRY = "mustDrawOriginalGeometry";

    private static final String FIELD_COLOR_FOR_ORIGINAL_GEOMETRY = "colorForOriginalGeometry";

//    private static final String FIELD_SYMBOL_FOR_SELECTION = "symbolForSelection";

    private UrbanHorizontalSignageData data;

    transient private UrbanHorizontalSignageSymbol symbolForSelection;

    private boolean mustDrawOriginalGeometry;

    private Color colorForOriginalGeometry;

    private double cartographicSize;

    private double transparency; //[0.0, 1.0]

    public UrbanHorizontalSignageSymbol() {

        super();

        this.mustDrawOriginalGeometry = false;

        this.transparency = 1.0;

    }

    public void setData(UrbanHorizontalSignageData data) {

        this.data = data;

    }

    public UrbanHorizontalSignageData getData() {

        return data;

    }

    /**

     * Sets the transparency for symbol. The valid values are in [0.0, 1.0]

     * 

     * @param transparency 

     */

    @Override

    public void setTransparency(double transparency) {

        if(transparency < 0 || transparency > 1.0){

            throw new IllegalArgumentException("Transparency value must be in [0.0, 1.0] ("+transparency+")");

        }

        this.transparency = transparency;

    }

    @Override

    public double getTransparency() {

        return transparency;

    }

    @Override

    public ISymbol getSymbolForSelection() {

        if (symbolForSelection == null) {

            symbolForSelection = (UrbanHorizontalSignageSymbol) cloneForSelection();

            symbolForSelection.mustDrawOriginalGeometry = true;

        } else {

            symbolForSelection.setColor(MapContext.getSelectionColor());

        }

        return symbolForSelection;

    }

    @Override

    public void draw(Graphics2D g, AffineTransform affineTransform,

            Geometry originalGeometry, Feature feature, Cancellable cancel) {

        if (true) {

            // Esto deberia ser para optimizar el pintado de 

            // geometrias grandes.

            try {

                Geometry env = originalGeometry.getEnvelope().getGeometry();

                env.transform(affineTransform);

                Envelope env2 = env.getEnvelope();

                if (env2.getLength(0) < 1.5 && env2.getLength(1) < 1.5) {

                    Color color = data.getSegmentsColor();

                    Color transparentColor = new Color(color.getRed(), color.getGreen(), color.getBlue(), (int)(transparency*color.getAlpha()));

                    g.setColor(transparentColor);

                    Point upperCorner = env2.getUpperCorner();

                    int x = (int) upperCorner.getX();

                    int y = (int) upperCorner.getY();

                    g.drawLine(x, y, x, y);

                    return;

                }

            } catch (Exception ex) {

                LOG.warn("Error optimizing the drawing of the geometry. Continues with normal drawing.", ex);

                // Do nothing, continue with the draw of the original geometry

            }

        }

        UrbanHorizontalSignageManager uhsManager = UrbanHorizontalSignageLocator.getUrbanHorizontalSignageManager();

        uhsManager.calculateGeometries(originalGeometry, data);

        MultiPolygon geom = data.getSegmentsGeometry();

        if (geom != null && geom.getPrimitivesNumber() > 0) {

            Color color = data.getSegmentsColor();

            Color transparentColor = new Color(color.getRed(), color.getGreen(), color.getBlue(), (int)(transparency*color.getAlpha()));

            g.setColor(transparentColor);

            g.fill(geom.getShape(affineTransform));

        }

        switch (data.getContinuity()) {

            case CONTINUITY_MODE_CONT_DISC:

            case CONTINUITY_MODE_DISC_CONT:

            case CONTINUITY_MODE_DISC:

            case CONTINUITY_MODE_DISC_DISC:

                if (data.isPaintHoles()) {

                    geom = data.getHolesGeometry();

                    if (geom != null && geom.getPrimitivesNumber() > 0) {

                        Color color = data.getHolesColor();

                        Color transparentColor = new Color(color.getRed(), color.getGreen(), color.getBlue(), (int)(transparency*color.getAlpha()));

                        g.setColor(transparentColor);

                        g.fill(geom.getShape(affineTransform));

                    }

                }

        }

        //For debug purposse only

        if(mustDrawOriginalGeometry){

            g.setColor(getColor());

            g.draw(originalGeometry.getShape(affineTransform));

        }

    }

    @Override

    public int getOnePointRgb() {

        return data.getSegmentsColor().getRGB();

    }

    @Override

    public void drawInsideRectangle(Graphics2D g,

            AffineTransform scaleInstance, Rectangle r, PrintAttributes properties) throws SymbolDrawingException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        final int hGap = (int) (r.getWidth() * 0.1); // the left and right margins

        final int vPos = 1; 						 // the top and bottom margins

        final int splitCount = 3; 					 // number of lines

        final int splitHSize = (r.width - hGap - hGap) / splitCount;

        int hPos = hGap;

        boolean swap = false;

        Line geom = GeometryUtils.createLine(Geometry.SUBTYPES.GEOM2D);

        geom.addVertex(r.x + hPos, r.y + r.height - vPos);

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

            swap = !swap;

            geom.addVertex(r.x + hPos + splitHSize, (swap ? vPos : r.height - vPos) + r.y);

            hPos += splitHSize;

        }

        try {

            if (properties == null) {

                draw(g, new AffineTransform(), geom, null, null);

            } else {

                print(g, new AffineTransform(), geom, properties);

            }

        } catch (Exception e) {

            throw new SymbolDrawingException(SymbolDrawingException.UNSUPPORTED_SET_OF_SETTINGS);

        }

    }

    @Override

    public Object clone() throws CloneNotSupportedException {

        UrbanHorizontalSignageSymbol copy = (UrbanHorizontalSignageSymbol) super.clone();

        if (symbolForSelection != null) {

            copy.symbolForSelection = (UrbanHorizontalSignageSymbol) symbolForSelection

                    .clone();

        }

        return copy;

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        // Set parent style properties

        super.loadFromState(state);

        UrbanHorizontalSignageData data = new DefaultUrbanHorizontalSignageData();

        data.setWidth(state.getDouble(FIELD_WIDTH, UrbanHorizontalSignageData.DEFAULT_WIDTH_VALUE));

        data.setContinuity(state.getInt(FIELD_CONTINUITY, UrbanHorizontalSignageData.DEFAULT_CONTINUITY_VALUE));

        Color color = (Color) state.get(FIELD_SEGMENTS_COLOR);

        data.setSegmentsColor(color != null ? color : UrbanHorizontalSignageData.DEFAULT_SEGMENT_COLOR_VALUE);

        data.setSegmentsLength(state.getDouble(FIELD_SEGMENTS_LENGTH, UrbanHorizontalSignageData.DEFAULT_SEGMENT_LENGTH_VALUE));

        color = (Color) state.get(FIELD_HOLES_COLOR);

        data.setHolesColor(color != null ? color : UrbanHorizontalSignageData.DEFAULT_HOLES_COLOR_VALUE);

        data.setHolesLength(state.getDouble(FIELD_HOLES_LENGTH, UrbanHorizontalSignageData.DEFAULT_HOLES_LENGTH_VALUE));

        data.setGapWidth(state.getDouble(FIELD_GAP_WIDTH, UrbanHorizontalSignageData.DEFAULT_GAP_WIDTH_VALUE));

        data.setRoundVertex(state.getBoolean(FIELD_ROUND_VERTEX, UrbanHorizontalSignageData.DEFAULT_ROUND_VERTEX_VALUE));

        this.transparency = state.getDouble(FIELD_TRANSPARENCY, 1.0);

        this.mustDrawOriginalGeometry = state.getBoolean(FIELD_MUST_DRAW_ORIGINAL_GEOMETRY, false);

        color = (Color) state.get(FIELD_COLOR_FOR_ORIGINAL_GEOMETRY);

        this.colorForOriginalGeometry = color != null ? color : MapContext.getSelectionColor();

        this.data = data;

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        // Save parent fill symbol properties

        super.saveToState(state);

        // Save own properties

        if(data != null){

            state.set(FIELD_WIDTH, data.getWidth());

            state.set(FIELD_CONTINUITY, data.getContinuity());

            state.set(FIELD_SEGMENTS_COLOR, data.getSegmentsColor());

            state.set(FIELD_SEGMENTS_LENGTH, data.getSegmentsLength());

            state.set(FIELD_HOLES_COLOR, data.getHolesColor());

            state.set(FIELD_HOLES_LENGTH, data.getHolesLength());

            state.set(FIELD_PAINT_HOLES, data.isPaintHoles());

            state.set(FIELD_GAP_WIDTH, data.getGapWidth());

            state.set(FIELD_ROUND_VERTEX, data.isRoundVertex());

        }

        state.set(FIELD_MUST_DRAW_ORIGINAL_GEOMETRY, mustDrawOriginalGeometry);

        state.set(FIELD_COLOR_FOR_ORIGINAL_GEOMETRY, colorForOriginalGeometry);

        state.set(FIELD_TRANSPARENCY, this.getTransparency());

    }

    @Override

    public void getPixExtentPlus(Geometry geom, float[] distances, ViewPort viewPort, int dpi) {

        float cs = (float) getCartographicSize(viewPort, dpi, geom);

        // TODO and add the line offset

        distances[0] = cs;

        distances[1] = cs;

    }

    @Override

    public int getSymbolType() {

        return Geometry.TYPES.CURVE;

    }

    @Override

    public boolean isSuitableFor(Geometry geom) {

        return geom.getGeometryType().isTypeOf(Geometry.TYPES.CURVE);

    }

    @Override

    public Color getColor() {

        return this.colorForOriginalGeometry;

    }

    @Override

    public void setColor(Color color) {

        this.colorForOriginalGeometry = color;

    }

    @Override

    public void print(Graphics2D g, AffineTransform at, Geometry shape, PrintAttributes properties) {

        draw(g, at, shape, null, null);

//		double originalSize = getLineWidth();

//		double size=originalSize;

//		// scale it to size

//		int pq = properties.getPrintQuality();

//		if (pq == PrintAttributes.PRINT_QUALITY_NORMAL){

//			size *= (double) 300/72;

//		}else if (pq == PrintAttributes.PRINT_QUALITY_HIGH){

//			size *= (double) 600/72;

//		}else if (pq == PrintAttributes.PRINT_QUALITY_DRAFT){

//			// size *= 72/72; // (which is the same than doing nothing)

//		}

//		setLineWidth(size);

//		draw(g,at,geom,null, null);

//		setLineWidth(originalSize);

    }

    @Override

    public double toCartographicSize(ViewPort viewPort, double dpi, Geometry geom) {

        double oldSize = getData().getWidth();

        setCartographicSize(getCartographicSize(

                viewPort,

                dpi,

                geom),

                geom);

        return oldSize;

//        return 0;

    }

    @Override

    public void setCartographicSize(double cartographicSize, Geometry geom) {

        //DO NOTHING

        this.getData().setWidth(cartographicSize);

    }

    @Override

    public double getCartographicSize(ViewPort viewPort, double dpi, Geometry geom) {

        return CartographicSupportToolkit.getCartographicLength(

                this,

                getData().getWidth(),

                viewPort,

                dpi

        );

//        return 0;

    }

//    public static class RegisterPersistence implements Callable {

//

//        @Override

//        public Object call() throws Exception {

//            PersistenceManager manager = ToolsLocator.getPersistenceManager();

//            if (manager.getDefinition(URBAN_HORIZONTAL_SIGNAGE_SYMBOL_PERSISTENCE_DEFINITION_NAME) == null) {

//                DynStruct definition = manager.addDefinition(

//                        UrbanHorizontalSignageSymbol.class,

//                        URBAN_HORIZONTAL_SIGNAGE_SYMBOL_PERSISTENCE_DEFINITION_NAME,

//                        URBAN_HORIZONTAL_SIGNAGE_SYMBOL_PERSISTENCE_DEFINITION_NAME + " Persistence definition",

//                        null,

//                        null

//                );

//                // Extend the LineSymbol base definition

//                definition.extend(manager.getDefinition(AbstractSymbol.SYMBOL_PERSISTENCE_DEFINITION_NAME));

//                

//                definition.addDynFieldDouble(FIELD_WIDTH).setMandatory(false);

//                definition.addDynFieldInt(FIELD_CONTINUITY).setMandatory(false);

//                definition.addDynFieldObject(FIELD_SEGMENTS_COLOR).setClassOfValue(Color.class).setMandatory(false);

//                definition.addDynFieldDouble(FIELD_SEGMENTS_LENGTH).setMandatory(false);

//                definition.addDynFieldObject(FIELD_HOLES_COLOR).setClassOfValue(Color.class).setMandatory(false);

//                definition.addDynFieldDouble(FIELD_HOLES_LENGTH).setMandatory(false);

//                definition.addDynFieldBoolean(FIELD_PAINT_HOLES).setMandatory(false);

//                definition.addDynFieldDouble(FIELD_GAP_WIDTH).setMandatory(false);

//                definition.addDynFieldBoolean(FIELD_ROUND_VERTEX).setMandatory(false);

//                definition.addDynFieldDouble(FIELD_TRANSPARENCY).setMandatory(false);

//                definition.addDynFieldBoolean(FIELD_MUST_DRAW_ORIGINAL_GEOMETRY).setMandatory(false);

//                definition.addDynFieldObject(FIELD_COLOR_FOR_ORIGINAL_GEOMETRY).setClassOfValue(Color.class).setMandatory(false);

//            }

//            return Boolean.TRUE;

//        }

//

//    }

    public static class RegisterSymbol implements Callable {

        @Override

        public Object call() throws Exception {

            int[] shapeTypes;

            SymbolManager manager = MapContextLocator.getSymbolManager();

            shapeTypes = new int[]{Geometry.TYPES.CURVE, Geometry.TYPES.ARC,

                Geometry.TYPES.MULTICURVE, Geometry.TYPES.CIRCUMFERENCE,

                Geometry.TYPES.PERIELLIPSE, Geometry.TYPES.SPLINE,

                Geometry.TYPES.LINE, Geometry.TYPES.MULTILINE};

            manager.registerSymbol(SYMBOL_NAME,

                    shapeTypes,

                    UrbanHorizontalSignageSymbol.class);

            return Boolean.TRUE;

        }

    }

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2015 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 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * 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.legend.urbanhorizontalsignage.lib.impl;

import java.io.InputStream;

import java.util.Map;

import org.gvsig.fmap.mapcontext.MapContextLibrary;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageLibrary;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageLocator;

import org.gvsig.symbology.impl.SymbologyDefaultImplLibrary;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

import org.gvsig.tools.persistence.PersistenceManager;

public class UrbanHorizontalSignageLibraryImpl extends AbstractLibrary {

    @Override

    public void doRegistration() {

        registerAsImplementationOf(UrbanHorizontalSignageLibrary.class);

        this.require(MapContextLibrary.class);

        this.require(SymbologyDefaultImplLibrary.class);

    }

    @Override

    protected void doInitialize() throws LibraryException {

        UrbanHorizontalSignageLocator.registerUrbanHorizontalSignageManager(DefaultUrbanHorizontalSignageManager.class);

        MapContextManager mcmanager = MapContextLocator.getMapContextManager();

        mcmanager.registerLegend("UrbanHorizontalSignageLegend", DefaultUrbanHorizontalSignageLegend.class);

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

        PersistenceManager persistenceManager = ToolsLocator.getPersistenceManager();

        InputStream is = this.getClass().getResourceAsStream("UrbanHorizontalSignagePersistence.xml");

        Map<String,DynStruct> definitions;

        try {

            definitions = ToolsLocator.getDynObjectManager().importDynClassDefinitions(is, this.getClass().getClassLoader());

        } catch (Exception ex) {

            throw new LibraryException(this.getClass(), ex);

        }

        persistenceManager.addDefinition(

                DefaultUrbanHorizontalSignageLegend.class,

                "DefaultUrbanHorizontalSignageLegend",

                definitions,

                null,

                null);

        persistenceManager.addDefinition(

                UrbanHorizontalSignageSymbol.class,

                "UrbanHorizontalSignageSymbol",

                definitions,

                null,

                null);

    }

}

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.legend.urbanhorizontalsignage.lib.impl;

import java.awt.Color;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.aggregate.MultiPolygon;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData;

/**

 *

 * @author fdiaz

 */

public class DefaultUrbanHorizontalSignageData implements UrbanHorizontalSignageData {

    private double width;

    private int continuity;

    private Color segmentsColor;

    private double segmentsLength;

    private MultiPolygon segmentsGeometry;

    private boolean isPaintHoles;

    private Color holesColor;

    private double holesLength;

    private MultiPolygon holesGeometry;

    private double gapWidth;

    private Geometry originalGeometry;

    private boolean roundVertex;

    public DefaultUrbanHorizontalSignageData() {

        width = DEFAULT_WIDTH_VALUE;

        continuity = DEFAULT_CONTINUITY_VALUE;

        segmentsColor = DEFAULT_SEGMENT_COLOR_VALUE;

        segmentsLength = DEFAULT_SEGMENT_LENGTH_VALUE;

        isPaintHoles = DEFAULT_PAINT_HOLES_VALUE;

        holesColor = DEFAULT_HOLES_COLOR_VALUE;

        holesLength = DEFAULT_HOLES_LENGTH_VALUE;

        gapWidth = DEFAULT_GAP_WIDTH_VALUE;

        roundVertex = DEFAULT_ROUND_VERTEX_VALUE;

    }

    @Override

    public double getWidth() {

        return this.width;

    }

    @Override

    public void setWidth(double value) {

        this.width = value;

    }

    @Override

    public int getContinuity() {

        return this.continuity;

    }

    @Override

    public void setContinuity(int value) {

        this.continuity = value;

    }

    @Override

    public Color getSegmentsColor() {

        return this.segmentsColor;

    }

    @Override

    public void setSegmentsColor(Color value) {

        this.segmentsColor = value;

    }

    @Override

    public double getSegmentsLength() {

        return this.segmentsLength;

    }

    @Override

    public void setSegmentsLength(double value) {

        this.segmentsLength = value;

    }

    @Override

    public MultiPolygon getSegmentsGeometry() {

        return this.segmentsGeometry;

    }

    @Override

    public void setSegmentsGeometry(MultiPolygon value) {

        this.segmentsGeometry = value;

    }

    @Override

    public boolean isPaintHoles() {

        return this.isPaintHoles;

    }

    @Override

    public void setPaintHoles(boolean value) {

        this.isPaintHoles = value;

    }

    @Override

    public Color getHolesColor() {

        return this.holesColor;

    }

    @Override

    public void setHolesColor(Color value) {

        this.holesColor = value;

    }

    @Override

    public double getHolesLength() {

        return this.holesLength;

    }

    @Override

    public void setHolesLength(double value) {

        this.holesLength = value;

    }

    @Override

    public MultiPolygon getHolesGeometry() {

        return this.holesGeometry;

    }

    @Override

    public void setHolesGeometry(MultiPolygon value) {

        this.holesGeometry = value;

    }

    @Override

    public double getGapWidth() {

        return this.gapWidth;

    }

    @Override

    public void setGapWidth(double value) {

        this.gapWidth = value;

    }

    public boolean isRoundVertex(){

        return this.roundVertex;

    }

    public void setRoundVertex(boolean value){

        this.roundVertex = value;

    }

}

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2015 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 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * 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.legend.urbanhorizontalsignage.lib.impl;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import org.apache.commons.lang3.tuple.MutablePair;

import org.gvsig.fmap.geom.Geometry;

import static org.gvsig.fmap.geom.Geometry.JOIN_STYLE_BEVEL;

import static org.gvsig.fmap.geom.Geometry.JOIN_STYLE_MITRE;

import static org.gvsig.fmap.geom.Geometry.JOIN_STYLE_ROUND;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.aggregate.MultiLine;

import org.gvsig.fmap.geom.aggregate.MultiPolygon;

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

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

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

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

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

import org.gvsig.fmap.geom.type.GeometryType;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.CONTINUITY_MODE_CONT;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.CONTINUITY_MODE_CONT_CONT;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.CONTINUITY_MODE_CONT_DISC;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.CONTINUITY_MODE_DISC;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.CONTINUITY_MODE_DISC_CONT;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.CONTINUITY_MODE_DISC_DISC;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageLegend;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageManager;