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>

  <groupId>org.gvsig</groupId>

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

  <version>1.0.37</version>

  <packaging>pom</packaging>

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

  <description>Legend for urban horizontal signage.</description>

  <parent>

    <groupId>org.gvsig</groupId>

    <artifactId>org.gvsig.desktop</artifactId>

    <version>2.0.424</version>

  </parent>

  <url>https://devel.gvsig.org/sites/org.gvsig.legend.picturemarkersymboltable/${project.version}</url>

  <scm>

    <connection>scm:svn:https://devel.gvsig.org/svn/gvsig-base-legends/org.gvsig.legend.picturemarkersymboltable/tags/org.gvsig.legend.picturemarkersymboltable-1.0.37</connection>

    <developerConnection>scm:svn:https://devel.gvsig.org/svn/gvsig-base-legends/org.gvsig.legend.picturemarkersymboltable/tags/org.gvsig.legend.picturemarkersymboltable-1.0.37</developerConnection>

    <url>https://devel.gvsig.org/redmine/projects/gvsig-base-legends/repository/show/org.gvsig.legend.picturemarkersymboltable/tags/org.gvsig.legend.picturemarkersymboltable-1.0.37</url>

  </scm>

  <repositories>

    <repository>

      <id>gvsig-public-http-repository</id>

      <name>gvSIG maven public HTTP repository</name>

      <url>http://devel.gvsig.org/m2repo/j2se</url>

      <releases>

        <enabled>true</enabled>

        <updatePolicy>daily</updatePolicy>

        <checksumPolicy>warn</checksumPolicy>

      </releases>

      <snapshots>

        <enabled>true</enabled>

        <updatePolicy>daily</updatePolicy>

        <checksumPolicy>warn</checksumPolicy>

      </snapshots>

    </repository>

  </repositories>

  <distributionManagement>

    <site>

      <id>gvsig-repository</id>

      <url>dav:https://devel.gvsig.org/download/projects/gvsig-base-legends/pool/${project.artifactId}/${project.version}</url>

    </site>

  </distributionManagement>

  <build>

    <plugins>

      <plugin>

        <groupId>org.apache.maven.plugins</groupId>

        <artifactId>maven-release-plugin</artifactId>

        <configuration>

          <tagBase>https://devel.gvsig.org/svn/gvsig-base-legends/org.gvsig.legend.picturemarkersymboltable/tags</tagBase>

        </configuration>

      </plugin>

    </plugins>

  </build>

  <dependencyManagement>

    <dependencies>

      <dependency>

        <groupId>org.gvsig</groupId>

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

        <version>1.0.37</version>

      </dependency>

      <dependency>

        <groupId>org.gvsig</groupId>

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

        <version>1.0.37</version>

      </dependency>

      <dependency>

        <groupId>org.gvsig</groupId>

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

        <version>1.0.37</version>

      </dependency>

      <dependency>

        <groupId>org.gvsig</groupId>

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

        <version>1.0.37</version>

      </dependency>

      <dependency>

        <groupId>org.gvsig</groupId>

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

        <version>1.0.37</version>

      </dependency>

    </dependencies>

  </dependencyManagement>

  <modules>

    <module>org.gvsig.legend.picturemarkersymboltable.lib</module>

    <module>org.gvsig.legend.picturemarkersymboltable.swing</module>

    <module>org.gvsig.legend.picturemarkersymboltable.app</module>

  </modules>

</project>

<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.picturemarkersymboltable</artifactId>

    <version>1.0.37</version>

  </parent>

  <groupId>org.gvsig</groupId>

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

  <packaging>pom</packaging>

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

  <modules>

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

  </modules>

</project>

<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.picturemarkersymboltable.app</artifactId>

    <version>1.0.37</version>

  </parent>

  <groupId>org.gvsig</groupId>

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

  <version>1.0.37</version>

  <name>org.gvsig.legend.picturemarkersymboltable.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.6.0-A</gvsig.package.info.dependencies>

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

    <gvsig.package.info.name>Vector legend: Picture marker symbols in a table</gvsig.package.info.name>

    <gvsig.package.info.description>Legend for work with picture marker symbols in a table.</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.picturemarkersymboltable.swing.api</artifactId>

      <scope>compile</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

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

      <scope>compile</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

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

      <scope>runtime</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

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

      <scope>runtime</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

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

      <scope>compile</scope>

    </dependency>

  </dependencies>

</project>

#Mon Jul 03 19:17:55 CEST 2023

buildNumber=39

# ---------------------------------------

# Picture marker symbol table legend

#

_Picture_marker_symbol_table_legend=Valores \u00fanicos de marcador de imagen en tabla

_Legend_table_fields=Campos de la tabla de la leyenda

_Images_table_fields=Campos de la tabla de las imagenes

_Unit=Unidad

_Line_to_offset_color=Color de la linea al offset

_Draw_line_to_offset=Pinta la linea al offset

_Classifying_field=Campo para clasificar

_OffsetX_field=Campo para el offset X

_OffsetY_field=Campo para el offset Y

_Rotation_field=Campo para la rotaci\u00f3n

_Line_to_offset_color_field=Campo para el color de la linea al offset

_Table_name=Nombre de tabla

_Image_field=Campo de la imagen

_Image_selected_field=Campo de la imagen seleccionada

# ---------------------------------------

# Picture marker symbol table legend

#

_Picture_marker_symbol_table_legend=Picture marker unique values in table

_Legend_table_fields=Legend table fields

_Images_table_fields=Images table fields

_Unit=Unit

_Line_to_offset_color=Line to offset color

_Draw_line_to_offset=Draw line to offset

_Classifying_field=Classifying field

_OffsetX_field=OffsetX field

_OffsetY_field=OffsetY field

_Rotation_field=Rotation field

_Line_to_offset_color_field=Line to offset color field

_Table_name=Table name

_Image_field=Image field

_Image_selected_field=Image selected field

<?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.andami.LibraryExtension"

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

      </extension>

  </extensions>

</plugin-config>

<?xml version="1.0"?>

<!--

Definitions of plugin persistence org.gvsig.legend.picturemarkersymboltable.app.mainplugin

 -->

<definitions>

  <version>1.0.0</version>

  <classes>

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

      <extends>

      </extends>

      <description>Persistence of the legend of picture marker symbols in a table</description>

      <fields>

      </fields>

    </class>

  </classes>

</definitions>  

<!-- 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.picturemarkersymboltable.lib.api</include>

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

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

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

      </includes>

    </dependencySet>

  </dependencySets>

</assembly>

org.gvsig.legend.picturemarkersymboltable.lib.api.PictureMarkerSymbolTableLibrary

package org.gvsig.legend.picturemarkersymboltable.lib.api;

import java.awt.Color;

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

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

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

public interface PictureMarkerSymbolTableLegend 

        extends IVectorLegend, IClassifiedLegend, ISingleSymbolLegend 

    {

    public static final int DEFAULT_IMAGE_SIZE = 15;

    public double getImageSize();

    public int getUnits();

    public boolean isDrawLineToOffset();

    public Color getDefaultLineToOffsetColor();

    public String getClassifyingFieldName();

    public String getOffsetXFieldName();

    public String getOffsetYFieldName();

    public String getRotationFieldName();

    public String getLineToOffsetColorFieldName();

    public String getImagesTableName();

    public String getImageFieldName();

    public String getImageSelectedFieldName();

    public String getImagesTableClassifyingFieldName();

    public double getScale();

    public void setImageSize(double size);

    public void setUnits(int unit);

    public void setDefaultLineToOffsetColor(Color color);

    public void setDrawLineToOffset(boolean drawLineToOffset);

    public void setLineToOffsetColorFieldName(String fieldName);

    public void setOffsetXFieldName(String fieldName);

    public void setOffsetYFieldName(String fieldName);

    public void setRotationFieldName(String fieldName);

    public void setClassifyingFieldName(String classifyingFieldName);

    public void setImagesTableName(String imagesTableName);

    public void setImageFieldName(String imageFieldName);

    public void setImageSelectedFieldName(String imageSelectedFieldName);

    public void setImagesTableClassifyingFieldName(String imagesTableClassifyingFieldName);

    public void setScale(double scale);

    public void setReverseDirectionOfAngle(boolean reverse);

    public boolean isReverseDirectionOfAngle();

}

/* 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.picturemarkersymboltable.lib.api;

import org.gvsig.tools.locator.AbstractLocator;

import org.gvsig.tools.locator.Locator;

import org.gvsig.tools.locator.LocatorException;

public class PictureMarkerSymbolTableLocator extends AbstractLocator {

    /**

     * HeatmapLegend locator name

     */

    private static final String LOCATOR_NAME = "PictureMarkerSymbolTableLocator";

    /**

     * HeatmapLegend manager name

     */

    public static final String MANAGER_NAME = "PictureMarkerSymbolTableManager";

    /**

     * HeatmapLegend manager description

     */

    private static final String MANAGER_DESCRIPTION =

        "PictureMarkerSymbolTable Manager of gvSIG";

    /**

     * Unique instance

     */

    private static final PictureMarkerSymbolTableLocator instance = new PictureMarkerSymbolTableLocator();

    @Override

    public String getLocatorName() {

        return LOCATOR_NAME;

    }

    /**

     * Registers the Class implementing the UrbanHorizontalSignageManager interface.

     *

     * @param clazz

     *            implementing the UrbanHorizontalSignageManager interface

     */

    public static void registerPictureMarkerSymbolTableManager(Class clazz){

        getInstance().register(MANAGER_NAME, MANAGER_DESCRIPTION, clazz);

    }

    public static void registerDefaultPictureMarkerSymbolTableManager(Class clazz){

        getInstance().registerDefault(MANAGER_NAME, MANAGER_DESCRIPTION, clazz);

    }

    public static PictureMarkerSymbolTableManager getPictureMarkerSymbolTableManager() throws LocatorException {

        return (PictureMarkerSymbolTableManager) getInstance().get(MANAGER_NAME);

    }

    /**

     * @return

     */

    public static Locator getInstance() {

        return instance;

    }

}

/* 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.picturemarkersymboltable.lib.api;

import org.gvsig.fmap.mapcontext.rendering.legend.driver.ILegendWriter;

import org.gvsig.symbology.SymbologyLocator;

import org.gvsig.symbology.SymbologyManager;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

import org.gvsig.tools.locator.ReferenceNotRegisteredException;

public class PictureMarkerSymbolTableLibrary extends AbstractLibrary {

    @Override

    protected void doInitialize() throws LibraryException {

        registerAsAPI(PictureMarkerSymbolTableLibrary.class);

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

        // Validate there is any implementation registered.

        PictureMarkerSymbolTableManager manager = PictureMarkerSymbolTableLocator.getPictureMarkerSymbolTableManager();

        if (manager == null) {

            throw new ReferenceNotRegisteredException(

                PictureMarkerSymbolTableLocator.MANAGER_NAME, PictureMarkerSymbolTableLocator.getInstance());

        }

        SymbologyManager symbolManager = SymbologyLocator.getSymbologyManager();

        ILegendWriter legendWriter = symbolManager.getDefaultLegendWriter();

    }

}

/* 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 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.picturemarkersymboltable.lib.api;

public interface PictureMarkerSymbolTableManager {

    public PictureMarkerSymbolTableLegend createPictureMarkerSymbolTableLegend();

    public Class<? extends PictureMarkerSymbolTableLegend> getPictureMarkerSymbolTableLegendClass();

}

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

  <groupId>org.gvsig</groupId>

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

  <name>org.gvsig.legend.picturemarkersymboltable.lib.api</name>

  <parent>

    <groupId>org.gvsig</groupId>

    <artifactId>org.gvsig.legend.picturemarkersymboltable.lib</artifactId>

    <version>1.0.37</version>

  </parent>

  <build>

    <plugins>

      <plugin>

        <groupId>org.apache.maven.plugins</groupId>

        <artifactId>maven-jar-plugin</artifactId>

        <configuration>

        </configuration>

        <executions>

          <!-- Generates a jar file only with the test classes -->

          <execution>

            <goals>

              <goal>test-jar</goal>

            </goals>

          </execution>

        </executions>

      </plugin>

    </plugins>

  </build>

  <dependencies>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.tools.lib</artifactId>

      <scope>compile</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.fmap.mapcontext.api</artifactId>

      <scope>compile</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.symbology.lib.api</artifactId>

    </dependency>

  </dependencies>

</project>

<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.picturemarkersymboltable</artifactId>

    <version>1.0.37</version>

  </parent>

  <groupId>org.gvsig</groupId>

  <artifactId>org.gvsig.legend.picturemarkersymboltable.lib</artifactId>

  <packaging>pom</packaging>

  <modules>

    <module>org.gvsig.legend.picturemarkersymboltable.lib.api</module>

    <module>org.gvsig.legend.picturemarkersymboltable.lib.impl</module>

  </modules>

</project>

/* 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.picturemarkersymboltable.lib.impl;

import org.gvsig.legend.picturemarkersymboltable.lib.api.PictureMarkerSymbolTableLegend;

import org.gvsig.legend.picturemarkersymboltable.lib.api.PictureMarkerSymbolTableManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SuppressWarnings("UseSpecificCatch")

public class DefaultPictureMarkerSymbolTableManager implements PictureMarkerSymbolTableManager {

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

    @Override

    public PictureMarkerSymbolTableLegend createPictureMarkerSymbolTableLegend() {

        return new DefaultPictureMarkerSymbolTableLegend();

    }

    @Override

    public Class<? extends PictureMarkerSymbolTableLegend> getPictureMarkerSymbolTableLegendClass() {

        return DefaultPictureMarkerSymbolTableLegend.class;

    }

}

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

import java.awt.Color;

import java.awt.geom.Point2D;

import java.awt.image.BufferedImage;

import java.net.URL;

import java.util.ArrayList;

import java.util.List;

import javax.annotation.processing.SupportedSourceVersion;

import javax.lang.model.SourceVersion;

import org.apache.commons.collections4.map.LRUMap;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.StoresRepository;

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

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryUtils;

import org.gvsig.fmap.mapcontext.MapContextException;

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

import org.gvsig.fmap.mapcontext.rendering.legend.events.IntervalLegendEvent;

import org.gvsig.fmap.mapcontext.rendering.legend.events.LabelLegendEvent;

import org.gvsig.fmap.mapcontext.rendering.legend.events.LegendChangedEvent;

import org.gvsig.fmap.mapcontext.rendering.legend.events.LegendClearEvent;

import org.gvsig.fmap.mapcontext.rendering.legend.events.SymbolLegendEvent;

import org.gvsig.fmap.mapcontext.rendering.legend.events.ValueLegendEvent;

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

import org.gvsig.legend.picturemarkersymboltable.lib.api.PictureMarkerSymbolTableLegend;

import org.gvsig.symbology.SymbologyLocator;

import org.gvsig.symbology.SymbologyManager;

import org.gvsig.symbology.fmap.mapcontext.rendering.legend.impl.AbstractVectorialLegend;

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.Coercion;

import org.gvsig.tools.persistence.PersistentState;

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

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SupportedSourceVersion(SourceVersion.RELEASE_8)

@SuppressWarnings("UseSpecificCatch")

public class DefaultPictureMarkerSymbolTableLegend 

        extends AbstractVectorialLegend 

        implements PictureMarkerSymbolTableLegend 

{

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

    private static final int IMAGESCACHE_SIZE = 100;

    /** 

     * defaultSimbol no se usa para nada. 

     * Lo inicializamos en el constructor a SimpleMarkerSymbol por si a caso 

     * alguien lo consulta, por ejemplo al persistir el ImageMarkerSimbol.

     */

    transient private final ISimpleMarkerSymbol defaultSymbol;

    transient private final Coercion toColor;

    transient private FeatureStore imagesStore;

    transient private ExpressionBuilder expressionBuilder;

    transient private final LRUMap<Object, BufferedImage[]> imagesCache;

    private double size;

    private int units;

    private Color lineToOffsetColor;

    private boolean drawLineToOffset;

    private String classifyingFieldName;

    private String offsetXFieldName;

    private String offsetYFieldName;

    private String rotationFieldName;

    private String lineToOffsetColorFieldlName;

    private String imagesTableName;

    private String imagesTableClassifyingFieldName;

    private String imageFieldName;

    private String imageSelectedFieldName;

    private SimpleImage imageNotFound;

    private double scale;

    private boolean reverseDirectionOfAngle;

    private class MyZSort extends ZSort {

	public MyZSort() {

		super();

	}

        @Override

	public void legendChanged(LegendChangedEvent e) throws MapContextException {

//		symbols.clear();

//		usingZSort = false;

//		initialize(e.getNewLegend());

	}

        @Override

	public String getClassName() {

		return getClass().getName();

	}

        @Override

	public int getLevelCount() {

		return 2;

	}

        @Override

	public void setUsingZSort(boolean usingZSort) {

	}

        @Override

	public void setLevels(ISymbol sym, int[] values) {

	}

        @Override

	public void setLevels(int row, int[] values) {

	}

        @Override

	public int[] getLevels(ISymbol sym) {

		return new int[]{0,1};

	}

        @Override

	public int[] getLevels(int row) {

		return null;

	}

        @Override

	public boolean isUsingZSort() {

		return true;

	}

        @Override

	public ISymbol[] getSymbols() {

		return null;

	}

        @Override

	public String[] getDescriptions() {

            return new String[] {"line", "Image"};

	}

        @Override

	public int getTopLevelIndexAllowed() {

		return 0;

	}

        @Override

	public String toString() {

            return "Line, Image";

	}

        @Override

	public boolean symbolChanged(SymbolLegendEvent e) {

		return true;

	}

        @Override

	public boolean classifiedSymbolChange(SymbolLegendEvent e) {

		return true;

	}

        @Override

	public boolean intervalChange(IntervalLegendEvent e) {

		return false;

	}

        @Override

	public boolean valueChange(ValueLegendEvent e) {

		return false;

	}

	// TODO should not exist here

        @Override

	public boolean labelFieldChange(LabelLegendEvent e) {

		return false;

	}

        @Override

	public void legendCleared(LegendClearEvent event) {

	}

    }

    public DefaultPictureMarkerSymbolTableLegend() {

        SymbologyManager symbologyManager = SymbologyLocator.getSymbologyManager();

        this.scale = 1;

        this.defaultSymbol = symbologyManager.createSimpleMarkerSymbol();

        this.toColor = ToolsLocator.getDataTypesManager().getCoercion(DataTypes.COLOR);

        this.size = DEFAULT_IMAGE_SIZE;

        this.drawLineToOffset = true;

        this.lineToOffsetColor = Color.DARK_GRAY;

        this.imagesCache = new LRUMap<>(IMAGESCACHE_SIZE);

        this.reverseDirectionOfAngle = false;

        this.setZSort(new MyZSort());

    }

    @Override

    public ISymbol getDefaultSymbol() {

        return this.defaultSymbol;

    }

    @Override

    public void setDefaultSymbol(ISymbol is) {

        //DO NOTHING

    }

    private Color getColor(Feature feature, String attrname, Color defaultValue) {

        if( StringUtils.isBlank(attrname) ) {

            return defaultValue;

        }

        try {

            return (Color) toColor.coerce(feature.get(attrname));

        } catch(Exception ex) {

            return defaultValue;

        }

    }

    @Override

    public ISymbol getSymbolByFeature(Feature feature) throws MapContextException {

        ImageMarkerSymbol symbol = new ImageMarkerSymbol();

        Point2D.Double offset = new Point2D.Double(0,0);

        if( StringUtils.isNotBlank(this.offsetXFieldName)) {

            offset.x = feature.getDouble(this.offsetXFieldName)*this.scale;

        }

        if( StringUtils.isNotBlank(this.offsetYFieldName)) {

            offset.y = feature.getDouble(this.offsetYFieldName)*this.scale;

        }

        symbol.setOffset(offset);

        if( StringUtils.isNotBlank(this.rotationFieldName)) {

            if( this.isReverseDirectionOfAngle() ) {

                symbol.setRotation(360 - feature.getDouble(this.rotationFieldName));            

            } else {

                symbol.setRotation(feature.getDouble(this.rotationFieldName));

            }

        } else {

            symbol.setRotation(0);

        }

        if( drawLineToOffset && (offset.x!=0 || offset.y!=0))    {

            symbol.setDrawLineToOffset(true);

            symbol.setLineToOffsetColor(

                    getColor(

                            feature, 

                            this.lineToOffsetColorFieldlName, 

                            this.lineToOffsetColor

                    )

            );

        } else {

            symbol.setDrawLineToOffset(false);

            symbol.setLineToOffsetColor(Color.DARK_GRAY);

        }

        symbol.setSize(this.size*this.scale);

        symbol.setUnit(this.units);

        Object classifyingValue = feature.get(this.classifyingFieldName);

        BufferedImage[] images = this.getImages(classifyingValue);

        symbol.setImage(images[0]);

        symbol.setImageSel(images[1]);

        return symbol;

    }

    @Override

    public int getShapeType() {

        return Geometry.TYPES.POINT;

    }

    private BufferedImage[] getImages(Object classifyingValue) {

        BufferedImage[] images;

        images = this.imagesCache.get(classifyingValue);

        if( images!=null ) {

            return images;

        }

        images = new BufferedImage[] { null, null };        

        try {

            FeatureStore store = this.getImagesStore();

            FeatureType featureType = store.getDefaultFeatureTypeQuietly();

            FeatureAttributeDescriptor attr = featureType.getAttributeDescriptor(this.imagesTableClassifyingFieldName);

            Object value = attr.coerce(classifyingValue);

            ExpressionBuilder builder = this.getExpressionBuilder();

            String filter = builder.eq(

                    builder.column(this.imagesTableClassifyingFieldName),

                    builder.constant(value)

            ).toString();

            Feature f = store.findFirst(filter);

            if( f==null ) {

                SimpleImage image = getImageNotFound();

                images[0] = image.getBufferedImage();

                images[1] = images[0];

            } else {

                SimpleImage image = (SimpleImage) f.getFromProfile(this.imageFieldName);

                if( image != null ) {

                    images[0] = image.getBufferedImage();

                    images[1] = images[0];

                }

                image = (SimpleImage) f.getFromProfile(this.imageSelectedFieldName);

                if( image != null && !image.isEmpty() ) {

                    images[1] = image.getBufferedImage();

                }

            }

        } catch(Exception ex) {

            LOGGER.debug("Can't retrieve images from table '"+this.imagesTableName+"'", ex);

        }

        this.imagesCache.put(classifyingValue, images);

        return images;

    }

    private SimpleImage getImageNotFound() {

        if(this.imageNotFound == null){

            URL url = this.getClass().getResource("/images/picturemarkersymboltablelegend/image-not-found.png");

            this.imageNotFound = ToolsSwingLocator.getToolsSwingManager().createSimpleImage(url);

        }

        return this.imageNotFound;

    }

    private ExpressionBuilder getExpressionBuilder() {

        if( this.expressionBuilder == null ) {

            this.expressionBuilder = ExpressionUtils.createExpressionBuilder();

        }

        return this.expressionBuilder;

    }

    private FeatureStore getImagesStore() {

        if( this.imagesStore == null ) {

            StoresRepository repository = DALLocator.getDataManager().getStoresRepository();

            this.imagesStore = (FeatureStore) repository.getStore(this.imagesTableName);

        }

        return this.imagesStore;

    }

    @Override

    public void setShapeType(int i) {

    }

    @Override

    public boolean isUseDefaultSymbol() {

        return true;

    }

    @Override

    public void useDefaultSymbol(boolean bln) {

    }

    @Override

    public boolean isSuitableForShapeType(int shapeType) {

        return GeometryUtils.isSubtype(Geometry.TYPES.POINT, shapeType);

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        super.loadFromState(state);

        this.scale = state.getDouble("scale",1.0);

        this.size = state.getDouble("size",DEFAULT_IMAGE_SIZE);

        this.units = state.getInt("units",-1);

        this.lineToOffsetColor = (Color) state.get("lineToOffsetColor");

        this.drawLineToOffset = state.getBoolean("drawLineToOffset",true);

        this.reverseDirectionOfAngle = state.getBoolean("reverseDirectionOfAngle",false);

        this.classifyingFieldName = state.getString("classifyingFieldName");

        this.offsetXFieldName = state.getString("offsetXFieldName");

        this.offsetYFieldName = state.getString("offsetYFieldName");

        this.rotationFieldName = state.getString("rotationFieldName");

        this.lineToOffsetColorFieldlName = state.getString("lineToOffsetColorFieldlName");

        this.imagesTableName = state.getString("imagesTableName");

        this.imagesTableClassifyingFieldName = state.getString("imagesTableClassifyingFieldName");

        this.imageFieldName = state.getString("imageFieldName");

        this.imageSelectedFieldName = state.getString("imageSelectedFieldName");

        setZSort(new MyZSort());

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        super.saveToState(state);

        state.set("scale", this.scale);

        state.set("size", this.size);

        state.set("units", this.units);

        state.set("lineToOffsetColor", this.lineToOffsetColor);

        state.set("drawLineToOffset", this.drawLineToOffset);

        state.set("reverseDirectionOfAngle", this.reverseDirectionOfAngle);

        state.set("classifyingFieldName", this.classifyingFieldName);

        state.set("offsetXFieldName", this.offsetXFieldName);

        state.set("offsetYFieldName", this.offsetYFieldName);

        state.set("rotationFieldName", this.rotationFieldName);

        state.set("lineToOffsetColorFieldlName", this.lineToOffsetColorFieldlName);

        state.set("imagesTableName", this.imagesTableName);

        state.set("imagesTableClassifyingFieldName", this.imagesTableClassifyingFieldName);

        state.set("imageFieldName", this.imageFieldName);

        state.set("imageSelectedFieldName", this.imageSelectedFieldName);

    }

    @Override

    protected String[] getRequiredFeatureAttributeNames(FeatureStore fs) throws DataException {

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

        if( StringUtils.isNotBlank(this.classifyingFieldName)) {

            attributes.add(this.classifyingFieldName);

        }

        if( StringUtils.isNotBlank(this.offsetXFieldName)) {

            attributes.add(this.offsetXFieldName);

        }

        if( StringUtils.isNotBlank(this.offsetYFieldName)) {

            attributes.add(this.offsetYFieldName);

        }

        if( StringUtils.isNotBlank(this.rotationFieldName)) {

            attributes.add(this.rotationFieldName);

        }

        if( StringUtils.isNotBlank(this.lineToOffsetColorFieldlName)) {

            attributes.add(this.lineToOffsetColorFieldlName);

        }

        attributes.add( fs.getDefaultFeatureType().getDefaultGeometryAttributeName() );

        return attributes.toArray(new String[attributes.size()]);

    }

    @Override

    public Color getDefaultLineToOffsetColor() {

        return this.lineToOffsetColor;

    }

    @Override

    public void setDefaultLineToOffsetColor(Color color) {

        this.lineToOffsetColor = color;

    }

    @Override

    public boolean isDrawLineToOffset() {

        return this.drawLineToOffset;

    }

    @Override

    public void setDrawLineToOffset(boolean drawLineToOffset) {

        this.drawLineToOffset = drawLineToOffset;

    }

    @Override

    public double getImageSize() {

        return this.size;

    }

    @Override

    public void setImageSize(double size) {

        this.size = size;

    }

    @Override

    public String getLineToOffsetColorFieldName() {

        return this.lineToOffsetColorFieldlName;

    }

    @Override

    public void setLineToOffsetColorFieldName(String fieldName) {

        this.lineToOffsetColorFieldlName = fieldName;

    }

    @Override

    public String getOffsetXFieldName() {

        return this.offsetXFieldName;

    }

    @Override

    public void setOffsetXFieldName(String fieldName) {

        this.offsetXFieldName = fieldName;

    }

    @Override

    public String getOffsetYFieldName() {

        return this.offsetYFieldName;

    }

    @Override

    public void setOffsetYFieldName(String fieldName) {

        this.offsetYFieldName = fieldName;

    }

    @Override

    public String getRotationFieldName() {

        return this.rotationFieldName;

    }

    @Override

    public void setRotationFieldName(String fieldName) {

        this.rotationFieldName = fieldName;

    }

    @Override

    public String getImagesTableName() {

        return imagesTableName;

    }

    @Override

    public void setImagesTableName(String imagesTableName) {

        this.imagesTableName = imagesTableName;

        this.imagesCache.clear();

    }

    @Override

    public String getImageFieldName() {

        return imageFieldName;

    }

    @Override

    public void setImageFieldName(String imageFieldName) {

        this.imageFieldName = imageFieldName;

        this.imagesCache.clear();

    }

    @Override

    public String getClassifyingFieldName() {

        return classifyingFieldName;

    }

    @Override

    public void setClassifyingFieldName(String classifyingFieldName) {

        this.classifyingFieldName = classifyingFieldName;

        this.imagesCache.clear();

    }

    @Override

    public String getImageSelectedFieldName() {

        return imageSelectedFieldName;

    }

    @Override

    public void setImageSelectedFieldName(String imageSelectedFieldName) {

        this.imageSelectedFieldName = imageSelectedFieldName;

        this.imagesCache.clear();

    }

    @Override

    public String getImagesTableClassifyingFieldName() {

        return imagesTableClassifyingFieldName;

    }

    @Override

    public void setImagesTableClassifyingFieldName(String imagesTableClassifyingFieldName) {

        this.imagesTableClassifyingFieldName = imagesTableClassifyingFieldName;

        this.imagesCache.clear();

    }

    @Override

    public String[] getDescriptions() {

        return new String[] { this.classifyingFieldName + "->" + this.imagesTableName};

    }

    @Override

    public ISymbol[] getSymbols() {

        return new ISymbol[] { this.defaultSymbol };

    }

    @Override

    public Object[] getValues() {

        return new Object[] { "" } ;

    }

    @Override

    public int getUnits() {

        return units;

    }

    @Override

    public void setUnits(int units) {

        this.units = units;

    }

    @Override

    public double getScale() {

        return scale;

    }

    @Override

    public void setScale(double scale) {

        this.scale = scale;

    }

    @Override

    public void setReverseDirectionOfAngle(boolean reverse) {

        this.reverseDirectionOfAngle = reverse;

    }

    @Override

    public boolean isReverseDirectionOfAngle() {

        return this.reverseDirectionOfAngle;

    }

}

/**

 * 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.picturemarkersymboltable.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.picturemarkersymboltable.lib.api.PictureMarkerSymbolTableLibrary;

import org.gvsig.legend.picturemarkersymboltable.lib.api.PictureMarkerSymbolTableLocator;

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 PictureMarkerSymbolTableLibraryImpl extends AbstractLibrary {

    @Override

    public void doRegistration() {

        registerAsImplementationOf(PictureMarkerSymbolTableLibrary.class);

        this.require(MapContextLibrary.class);

        this.require(SymbologyDefaultImplLibrary.class);

    }

    @Override

    protected void doInitialize() throws LibraryException {

        PictureMarkerSymbolTableLocator.registerPictureMarkerSymbolTableManager(DefaultPictureMarkerSymbolTableManager.class);

        MapContextManager mapContextManager = MapContextLocator.getMapContextManager();

        mapContextManager.registerLegend("PictureMarkerSymbolTableLegend", DefaultPictureMarkerSymbolTableLegend.class);

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

        PersistenceManager persistenceManager = ToolsLocator.getPersistenceManager();

        InputStream is = this.getClass().getResourceAsStream("PictureMarkerSymbolTablePersistence.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(

                DefaultPictureMarkerSymbolTableLegend.class,

                "DefaultPictureMarkerSymbolTableLegend",

                definitions,

                null,

                null

        );

    }

}

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

import java.awt.Graphics2D;

import java.awt.Rectangle;

import java.awt.geom.AffineTransform;

import java.awt.geom.Point2D;

import java.awt.image.BufferedImage;

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

import org.gvsig.fmap.geom.Geometry;

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

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

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.ViewPort;

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

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

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

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.line.impl.AbstractLineSymbol;

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

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.impl.AbstractMarkerSymbol;

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

import org.gvsig.tools.task.Cancellable;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author gvSIG Team

 */

@SuppressWarnings("UseSpecificCatch")

public class ImageMarkerSymbol extends AbstractMarkerSymbol implements  IMarkerSymbol, IMultiLayerSymbol, TransparencySupport {

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

    private ImageMarkerSymbol selectionSym;

    private boolean selected;

    private BufferedImage image;

    private BufferedImage imagesel;

    private ISymbol[] layers;