Application: gvSIG desktop » gvSIG legends: base legends

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

	<modelVersion>4.0.0</modelVersion>

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

	<name>Vector legend: Quantity by category</name>

	<version>1.0.75</version>

  <parent>

      <groupId>org.gvsig</groupId>

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

      <version>2.0.241</version>

  </parent>

	<url>https://devel.gvsig.org/redmine/projects/gvsig-base-legends</url>

    <scm>

        <connection>scm:svn:https://devel.gvsig.org/svn/gvsig-base-legends/org.gvsig.legend.quantitybycategory.app.mainplugin/tags/org.gvsig.legend.quantitybycategory.app.mainplugin-1.0.75</connection>

        <developerConnection>scm:svn:https://devel.gvsig.org/svn/gvsig-base-legends/org.gvsig.legend.quantitybycategory.app.mainplugin/tags/org.gvsig.legend.quantitybycategory.app.mainplugin-1.0.75</developerConnection>

        <url>scm:svn:https://devel.gvsig.org/svn/gvsig-base-legends/org.gvsig.legend.quantitybycategory.app.mainplugin/tags/org.gvsig.legend.quantitybycategory.app.mainplugin-1.0.75</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>

	<description>Vector legend: Quantity by category. This legend draws quantities for each category.</description>

	<build>

        <plugins>

		    <plugin>

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

		      <version>2.0</version>

		      <configuration>

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

		      </configuration>

		    </plugin>			

        </plugins>        

	</build>

	<dependencies>

		<dependency>

			<groupId>org.gvsig</groupId>

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

		</dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

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

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

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

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

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

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

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

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

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

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.utils</artifactId>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

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

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.i18n</artifactId>

        </dependency>

		<dependency>

            <groupId>org.gvsig</groupId>

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

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

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

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.ui</artifactId>

        </dependency>        

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.projection.api</artifactId>

        </dependency>        

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.metadata.lib.basic.api</artifactId>

        </dependency>        

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.compat.api</artifactId>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

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

            <version>1.0.1</version>

        </dependency>

	</dependencies>

	<properties>

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

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

        <gvsig.package.info.dependencies>required: org.gvsig.app.mainplugin -ge 2,required: org.gvsig.legend.graduatedsymbols.app.mainplugin -ge 1</gvsig.package.info.dependencies>

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

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

	</properties>

</project>

#Sun Mar 03 13:16:06 CET 2019

buildNumber=78

org.gvsig.symbology.library.QuantityByCategoryLibrary

<!--

    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>

<!-- No dependencies

  <dependencySets>

    <dependencySet>

      <useProjectArtifact>false</useProjectArtifact>

      <useTransitiveDependencies>false</useTransitiveDependencies>

      <outputDirectory>lib</outputDirectory>

      <includes>

		<include>...</include>

      </includes>

    </dependencySet>

  </dependencySets>

-->

</assembly>

package org.gvsig.symbology.fmap.rendering;

import java.util.ArrayList;

import java.util.List;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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.mapcontext.MapContextException;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

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

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

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

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

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

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

import org.gvsig.tools.util.Callable;

/**

 * Implements a legend where the user can compare two different characteristics

 * of a region in the map. These two "fields" will be compared, on one side,

 * using a color for the region and , on the other side, using a graduated symbol.

 * Both methods will change (the color or the size of the symbol) depending on

 * the value of the fields.

 *

 * @author jaume dominguez faus - jaume.dominguez@iver.es

 */

public class QuantityByCategoryLegend extends AbstractClassifiedVectorLegend {

    private static final Logger logger =

        LoggerFactory.getLogger(QuantityByCategoryLegend.class);

    public static final String

    QUANTITY_BY_CATEGORY_LEGEND_PERSISTENCE_DEFINITION_NAME =

    "QUANTITY_BY_CATEGORY_LEGEND_PERSISTENCE_DEFINITION_NAME";

    public static final String

    QUANTITY_BY_CATEGORY_LEGEND_NAME = "QUANTITY_BY_CATEGORY_LEGEND_NAME";

	private GraduatedSymbolsLegend graduatedSymbol;

	private VectorialIntervalLegend colorRamp;

	private ISymbol defaultSymbol = null;

	private int shapeType = Geometry.TYPES.SURFACE;

	private boolean isUseDefaultSymbol;

	// private DataSource ds;

	public QuantityByCategoryLegend() {

		graduatedSymbol = new GraduatedSymbolsLegend();

		colorRamp = new VectorialIntervalLegend(getShapeType());

		this.setShapeType(Geometry.TYPES.SURFACE);

		ISymbol def = MapContextLocator.getSymbolManager().

            createSymbol(getShapeType());

		this.setDefaultSymbol(def);

	}

	public void clear() {

		colorRamp.clear();

		graduatedSymbol.clear();

	}

	public String[] getClassifyingFieldNames() {

		ArrayList<String> l = new ArrayList<String>();

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

			l.add(graduatedSymbol.getClassifyingFieldNames()[i]);

		}

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

			l.add(colorRamp.getClassifyingFieldNames()[i]);

		}

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

	}

	@Override

	public int[] getClassifyingFieldTypes() {

        ArrayList<Integer> l = new ArrayList<Integer>();

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

            l.add(graduatedSymbol.getClassifyingFieldTypes()[i]);

        }

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

            l.add(colorRamp.getClassifyingFieldTypes()[i]);

        }

        int len = l.size();

        int[] resp = new int[len];

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

            resp[i] = l.get(i).intValue();

        }

        return resp;

	}

	public void setClassifyingFieldTypes(int[] fieldTypes) {

		if (fieldTypes.length == 2) {

	        colorRamp.setClassifyingFieldTypes(new int[] {fieldTypes[1]});

	        graduatedSymbol.setClassifyingFieldTypes(new int[] {fieldTypes[0]});

		} else {

		    logger.info("Error: Unexpected array size (should be 2)");

		}

		super.setClassifyingFieldTypes(fieldTypes);

	}

	/**

	 * Sets the field names required to build this legend. In this case

	 * fieldNames is an array of length 2 where the first element is

	 * the field name for the embedded GraduatedSymbolLegend, and the

	 * second is the field name for the embedded colorRamp (VectorialIntervalLegend)

	 * legend.

	 */

	public void setClassifyingFieldNames(String[] fieldNames) {

		if (fieldNames.length == 2) {

	        colorRamp.setClassifyingFieldNames(new String[] {fieldNames[1]});

	        graduatedSymbol.setClassifyingFieldNames(new String[] {fieldNames[0]});

		} else {

            logger.info("Error: Unexpected array size (should be 2)");

		}

		super.setClassifyingFieldNames(fieldNames);

	}

	public void addSymbol(Object key, ISymbol symbol) {

//		System.out.println("adding "+key+"["+symbol+"]");

		if(symbol instanceof IFillSymbol)

			colorRamp.addSymbol(key, symbol);

		else if(symbol instanceof IMarkerSymbol)

			graduatedSymbol.addSymbol(key, symbol);

		fireClassifiedSymbolChangeEvent(

		    new SymbolLegendEvent(null, symbol));

	}

	public void delSymbol(Object key) {

		colorRamp.delSymbol(key);

		graduatedSymbol.delSymbol(key);

		fireClassifiedSymbolChangeEvent(

				new SymbolLegendEvent(

						null,

						null));

	}

	public String[] getDescriptions() {

		String[] desc1 = colorRamp.getDescriptions();

		String[] desc2 = graduatedSymbol.getDescriptions();

        Object[] objects1 = colorRamp.getValues();

        Object[] objects2 = graduatedSymbol.getValues();

        List descriptionsList = new ArrayList<String>();

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

            //Pretend?a saltar el valor por defecto pero no es necesario si en getValues se pone como clave null

//            if(objects1[i] instanceof IInterval){

                descriptionsList.add(desc1[i]);

//            }

        }

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

            //Pretend?a saltar el valor por defecto pero no es necesario si en getValues se pone como clave null

//            if(objects2[i] instanceof IInterval){

                descriptionsList.add(desc2[i]);

//            }

        }

        String[] descriptions = new String[descriptionsList.size()];

        descriptions = (String[]) descriptionsList.toArray(descriptions);

        return descriptions;

	}

	public ISymbol[] getSymbols() {

		ISymbol[] symbols1 = colorRamp.getSymbols();

		ISymbol[] symbols2 = graduatedSymbol.getSymbols();

	    Object[] objects1 = colorRamp.getValues();

	    Object[] objects2 = graduatedSymbol.getValues();

        List symbolsList = new ArrayList<ISymbol>();

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

            //Pretend?a saltar el valor por defecto pero no es necesario si en getValues se pone como clave null

//            if(objects1[i] instanceof IInterval){

                symbolsList.add(symbols1[i]);

//            }

        }

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

            //Pretend?a saltar el valor por defecto pero no es necesario si en getValues se pone como clave null

//            if(objects2[i] instanceof IInterval){

                symbolsList.add(symbols2[i]);

//            }

        }

        ISymbol[] symbols = new ISymbol[symbolsList.size()];

        symbols = (ISymbol[]) symbolsList.toArray(symbols);

        return symbols;

	}

	public Object[] getValues() {

		Object[] objects1 = colorRamp.getValues();

		Object[] objects2 = graduatedSymbol.getValues();

		List objectsList = new ArrayList<IInterval>();

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

            if(objects1[i] instanceof IInterval){

                objectsList.add(objects1[i]);

            } else {

                objectsList.add(null); //Si no es un IInterval es el valor por defecto

            }

        }

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

            if(objects2[i] instanceof IInterval){

                objectsList.add(objects2[i]);

            } else {

                objectsList.add(null); //Si no es un IInterval es el valor por defecto

            }

        }

        Object[] objects = new IInterval[objectsList.size()];

        objects = objectsList.toArray(objects);

		return objects;

	}

	public Object clone() throws CloneNotSupportedException {

	    QuantityByCategoryLegend resp =

	        (QuantityByCategoryLegend) super.clone();

        resp.setShapeType(this.getShapeType());

	    resp.useDefaultSymbol(this.isUseDefaultSymbol());

	    ISymbol defsym = this.getDefaultSymbol();

	    defsym = (ISymbol) defsym.clone();

	    resp.setDefaultSymbol(defsym);

	    GraduatedSymbolsLegend gleg = this.getGraduatedSymbolsLegend();

	    gleg = (GraduatedSymbolsLegend) gleg.cloneLegend();

	    resp.setGraduateSymbolLegend(gleg);

	    VectorialIntervalLegend interleg = this.getColorRampLegend();

	    interleg = (VectorialIntervalLegend) interleg.cloneLegend();

	    resp.setColorRampLegend(interleg);

		return resp;

	}

	/**

	 * Obtains the GraduatedSymbolLegend

	 *

	 * @return GraduatedSymbolLegend

	 */

	public GraduatedSymbolsLegend getGraduatedSymbolsLegend() {

		return graduatedSymbol;

	}

	/**

	 * Obtains the VectorialIntervalLegend

	 *

	 * @return VectorialIntervalLegend

	 */

	public VectorialIntervalLegend getColorRampLegend() {

		return colorRamp;

	}

	/*

	public void setDataSource(DataSource ds) throws FieldNotFoundException, ReadDriverException {

		// TODO remove it when FLyrVect.forTestOnlyVariableUseIterators_REMOVE_THIS_FIELD is removed

//		if (FLyrVect.forTestOnlyVariableUseIterators_REMOVE_THIS_FIELD) {

			this.ds = ds;

//		}

		graduatedSymbol.setDataSource(ds);

		colorRamp.setDataSource(ds);

	}

	*/

	/*

	public ISymbol getSymbol(int i) {

		IMarkerSymbol sym1 = (IMarkerSymbol) graduatedSymbol.getSymbol(i);

		ISymbol sym2 =  colorRamp.getSymbol(i);

		IMultiLayerSymbol multiSym = null;

		int shpt = this.getShapeType();

		if (isPolygonal(shpt)) {

            // symbol from the GraduatedSymbolLegend is a marker, but

            // what we need is a fill symbol. Will use a MarkerFillSymbol

            // to enable support for Polygons

            MarkerFillSymbol aux = new MarkerFillSymbol();

            // tell the fill style to draw the IMarkerSymbol

            // as a IFillSymbol centering it in the shape polygon

            // centroid and applying offset (if any).

            aux.setMarker(sym1);

            SimpleMarkerFillPropertiesStyle p =

                new SimpleMarkerFillPropertiesStyle();

            p.setFillStyle(SimpleMarkerFillPropertiesStyle.SINGLE_CENTERED_SYMBOL);

            aux.setMarkerFillProperties(p);

            multiSym = MapContextLocator.getSymbolManager().

                createMultiLayerSymbol(Geometry.TYPES.SURFACE);

            multiSym.addLayer(sym2);

            multiSym.addLayer(aux);

            break;

		} else {

		    logger.info("Error: unexpected shape type (should be surface): " + shpt);

		}

		return multiSym;

	}

	*/

	public ISymbol getSymbolByFeature(Feature feat) throws MapContextException {

		ISymbol sym1 = null, sym2 = null;

		sym1 = graduatedSymbol.getSymbolByFeature(feat);

		// Ensure fill symbol

		sym1 = GraduatedSymbolsLegend.toFillSymbol(sym1);

		sym2 = colorRamp.getSymbolByFeature(feat);

		IMultiLayerSymbol multiSym = null;

		int shpt = this.getShapeType();

		if (isPolygonal(shpt)) {

            multiSym = MapContextLocator.getSymbolManager().

                createMultiLayerSymbol(Geometry.TYPES.SURFACE);

            if (sym2 != null) multiSym.addLayer(sym2);

            if (sym1 != null) multiSym.addLayer(sym1);

		} else {

		    logger.info("Error: unexpected shape type (should be surface): " + shpt);

		}

		return multiSym;

	}

	public void setShapeType(int shpt) {

	    this.shapeType = shpt;

	    ISymbol sym = null;

		graduatedSymbol.setShapeType(Geometry.TYPES.POINT);

		sym = MapContextLocator.getSymbolManager().createSymbol(

		    Geometry.TYPES.POINT);

		graduatedSymbol.setDefaultSymbol(sym);

		colorRamp.setShapeType(shpt);

		sym = MapContextLocator.getSymbolManager().createSymbol(shpt);

		colorRamp.setDefaultSymbol(sym);

	}

	public boolean isUseDefaultSymbol() {

		return isUseDefaultSymbol;

	}

	public void useDefaultSymbol(boolean b) {

		this.isUseDefaultSymbol = b;

	}

	public void setGraduateSymbolLegend(GraduatedSymbolsLegend legend) {

		this.graduatedSymbol = legend;

	}

	public void setColorRampLegend(VectorialIntervalLegend legend) {

		this.colorRamp = legend;

	}

	public String getClassName() {

		return getClass().getName();

	}

	public void replace(ISymbol oldSymbol, ISymbol newSymbol) {

		ISymbol[] symbols;

		// look first in the graduated symbol legend

		symbols = graduatedSymbol.getSymbols();

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

			if (symbols[i].equals(oldSymbol)) {

				graduatedSymbol.replace(oldSymbol, newSymbol);

				return;

			}

		}

		// if the symbol wasn't found yet, proceed with color ramp

		symbols = colorRamp.getSymbols();

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

			if (symbols[i].equals(oldSymbol)) {

				colorRamp.replace(oldSymbol, newSymbol);

				return;

			}

		}

	}

    public static boolean isPolygonal(int ty) {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        return geomManager.isSubtype(Geometry.TYPES.MULTISURFACE, ty) || 

            geomManager.isSubtype(Geometry.TYPES.SURFACE, ty);

    }

    public ISymbol getDefaultSymbol() {

        return this.defaultSymbol;

    }

    public int getShapeType() {

        return this.shapeType;

    }

    public void setDefaultSymbol(ISymbol s) {

        this.defaultSymbol = s;

    }

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

    public static class RegisterPersistence implements Callable {

        public Object call() throws Exception {

            PersistenceManager manager = ToolsLocator.getPersistenceManager();

            if (manager.getDefinition(

                QUANTITY_BY_CATEGORY_LEGEND_PERSISTENCE_DEFINITION_NAME) == null) {

                DynStruct definition = manager

                    .addDefinition(QuantityByCategoryLegend.class,

                        QUANTITY_BY_CATEGORY_LEGEND_PERSISTENCE_DEFINITION_NAME,

                        QUANTITY_BY_CATEGORY_LEGEND_PERSISTENCE_DEFINITION_NAME

                        + " Persistence definition", null, null);

                definition.extend(manager.getDefinition(

                    AbstractClassifiedVectorLegend

                    .CLASSIFIED_VECTOR_LEGEND_PERSISTENCE_DEFINITION_NAME));

                definition.addDynFieldBoolean("useDefaultSymbol")

                .setMandatory(true);

                definition.addDynFieldObject("graduatedLegend")

                .setClassOfValue(ILegend.class).setMandatory(true);

                definition.addDynFieldObject("rampLegend")

                .setClassOfValue(ILegend.class).setMandatory(true);

            }

            return Boolean.TRUE;

        }

    }

    public static class RegisterLegend implements Callable {

        public Object call() throws Exception {

            MapContextManager manager =

                MapContextLocator.getMapContextManager();

            manager.registerLegend(

                QUANTITY_BY_CATEGORY_LEGEND_NAME,

                QuantityByCategoryLegend.class);

            return Boolean.TRUE;

        }

    }

    public void saveToState(PersistentState state) throws PersistenceException {

        super.saveToState(state);

        state.set("useDefaultSymbol", this.isUseDefaultSymbol());

        state.set("graduatedLegend", this.getGraduatedSymbolsLegend());

        state.set("rampLegend", this.getColorRampLegend());

    }

    public void loadFromState(PersistentState state)

        throws PersistenceException {

        super.loadFromState(state);

        Boolean b = state.getBoolean("useDefaultSymbol");

        this.useDefaultSymbol(b);

        ILegend leg = (ILegend) state.get("graduatedLegend");

        if (leg instanceof GraduatedSymbolsLegend) {

            this.setGraduateSymbolLegend((GraduatedSymbolsLegend) leg);

        } else {

            throw new PersistenceException(new ClassCastException(

                "Unexpected legend type (" + leg + "). Should be GraduatedSymbolsLegend"));

        }

        leg = (ILegend) state.get("rampLegend");

        if (leg instanceof VectorialIntervalLegend) {

            this.setColorRampLegend((VectorialIntervalLegend) leg);

        } else {

            throw new PersistenceException(new ClassCastException(

                "Unexpected legend type (" + leg + "). Should be VectorialIntervalLegend"));

        }

    }

}

package org.gvsig.symbology.gui.layerproperties;

import java.awt.BorderLayout;

import java.awt.GridLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.util.ArrayList;

import java.util.List;

import javax.swing.BorderFactory;

import javax.swing.DefaultComboBoxModel;

import javax.swing.ImageIcon;

import javax.swing.JButton;

import javax.swing.JComboBox;

import javax.swing.JComponent;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.andami.IconThemeHelper;

import org.gvsig.andami.ui.mdiManager.IWindow;

import org.gvsig.andami.ui.mdiManager.WindowInfo;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.project.documents.view.legend.gui.ILegendPanel;

import org.gvsig.app.project.documents.view.legend.gui.MultipleAttributes;

import org.gvsig.app.project.documents.view.legend.gui.SymbolTable;

import org.gvsig.app.project.documents.view.legend.gui.VectorialInterval;

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

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.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.layers.FLayer;

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

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

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

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

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

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

import org.gvsig.gui.beans.AcceptCancelPanel;

import org.gvsig.gui.beans.swing.GridBagLayoutPanel;

import org.gvsig.i18n.Messages;

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

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

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

import org.gvsig.symbology.fmap.rendering.GraduatedSymbolsLegend;

import org.gvsig.symbology.fmap.rendering.QuantityByCategoryLegend;

/**

 * Implements the panel of a legend where the user can compare two different characteristics

 * of a region in the map. These two "fields" will be compared, on one side,

 * using a color for the region and , on the other side, using a graduated symbol.

 * Both methods will change (the color or the size of the symbol) depending on

 * the value of the fields.

 *

 * @author jaume dominguez faus - jaume.dominguez@iver.es

 */

public class QuantityByCategoryPanel extends JPanel

implements ILegendPanel, ActionListener {

	private static final long serialVersionUID = 5098346573350040756L;

	private static final Logger logger =

	    LoggerFactory.getLogger(QuantityByCategoryPanel.class);

	private JPanel pnlNorth;

	private JPanel pnlSouth;

	private JPanel pnlButtons;

	private GridBagLayoutPanel pnlFields;

	private JPanel pnlColorAndSymbol;

	private JComboBox cmbColorField;

	private JComboBox cmbGraduatedSymbolField;

	private JButton btnColor;

	private JButton btnSymbol;

//	private JButton btnDelete;

//	private JButton btnDeleteAll;

	private QuantityByCategoryLegend legend;

	private QuantityByCategoryLegend oldLegend;

	private FLayer layer;

	private SymbolTable symbolTable;

	/**

	 * Constructor method

	 */

	public QuantityByCategoryPanel() {

		super();

		initialize();

	}

	/**

	 * This method initializes this

	 */

	private void initialize() {

		this.setLayout(new BorderLayout());

		this.setSize(490, 300);

		this.add(getPnlNorth(), BorderLayout.NORTH);

		this.add(getPnlSouth(),BorderLayout.CENTER);

//		this.add(getPnlButtons(),BorderLayout.SOUTH);

	}

	/**

	 * Obtains the south panel

	 *

	 * @return JPanel

	 */

	private JPanel getPnlSouth() {

		if (pnlSouth == null) {

			pnlSouth = new JPanel();

			pnlSouth.setLayout(new BorderLayout());

		}

		return pnlSouth;

	}

	/**

	 * Obtains the panel where the buttons will be placed

	 *

	 * @return JPanel

	 */

//	private JPanel getPnlButtons() {

//		if(pnlButtons == null) {

//			pnlButtons = new JPanel();

//			pnlButtons.add(getButDel());

//			pnlButtons.add(getButDelAll());

//		}

//		return pnlButtons;

//	}

	/**

	 * Obtains the button that is used to delete all the rows of the symbolTable

	 *

	 * @return JButton

	 */

//	private JButton getButDelAll() {

//		if (btnDeleteAll == null) {

//			btnDeleteAll = new JButton();

//			btnDeleteAll.addActionListener(this);

//			btnDeleteAll.setText(PluginServices.getText(this, "Quitar_todos"));

//		}

//		return btnDeleteAll;

//	}

	/**

	 * Obtains the button that is used to delete a row of the symbolTable

	 *

	 * @return JButton

	 */

//	private JButton getButDel() {

//		if (btnDelete == null) {

//			btnDelete = new JButton();

//			btnDelete.addActionListener(this);

//			btnDelete.setText(PluginServices.getText(this, "Quitar"));

//		}

//

//		return btnDelete;

//	}

	/**

	 * Obtains the north panel

	 *

	 * @return JPanel

	 */

	private JPanel getPnlNorth() {

		if (pnlNorth == null) {

			pnlNorth = new JPanel(new GridLayout(1, 2));

			pnlNorth.add(getPnlFields());

			pnlNorth.add(getPnlColorAndSymbol());

		}

		return pnlNorth;

	}

	/**

	 * Obtains the panel where the user has the options to select the variation to be applied

	 *

	 * @return JPanel

	 */

	private JPanel getPnlColorAndSymbol() {

		if (pnlColorAndSymbol == null) {

			pnlColorAndSymbol = new JPanel();

			pnlColorAndSymbol.setBorder(

					BorderFactory.createTitledBorder(

							null, Messages.getText("variation_by")));

			pnlColorAndSymbol.add(getBtnColor());

			pnlColorAndSymbol.add(getBtnSymbol());

		}

		return pnlColorAndSymbol;

	}

	/**

	 * Creates the button which is used to selecte the variation by symbol

	 *

	 * @return JButton

	 */

	private JButton getBtnSymbol() {

		if (btnSymbol == null) {

			btnSymbol = new JButton(Messages.getText("symbol"));

			btnSymbol.addActionListener(this);

		}

		return btnSymbol;

	}

	/**

	 * Creates the button which is used to selecte the variation by color ramp

	 *

	 * @return JButton

	 */

	private JButton getBtnColor() {

		if (btnColor == null) {

			btnColor = new JButton(Messages.getText("color_ramp"));

			btnColor.addActionListener(this);

		}

		return btnColor;

	}

	/**

	 * Creates the panel where the JComboBoxes to select the fields for the variation will be placed

	 *

	 * @return GridBagLayoutPanel

	 */

	private GridBagLayoutPanel getPnlFields() {

		if (pnlFields == null) {

			pnlFields = new GridBagLayoutPanel();

			pnlFields.setBorder(

					BorderFactory.createTitledBorder(

							null, Messages.getText("value_fields")));

			pnlFields.addComponent(

			    Messages.getText("color_field"), getCmbColorField());

			pnlFields.addComponent(

			    Messages.getText("symbol_field") ,getCmbGraduatedField());

		}

		return pnlFields;

	}

	/**

	 * Creates a JComboBox where the user will select the field for the symbol variation

	 *

	 * @return JComboBox

	 */

	private JComboBox getCmbGraduatedField() {

		if (cmbGraduatedSymbolField == null) {

			cmbGraduatedSymbolField = new JComboBox();

			cmbGraduatedSymbolField.addActionListener(this);

		}

		return cmbGraduatedSymbolField;

	}

	/**

	 * Creates a JComboBox where the user will select the field for the color ramp variation

	 *

	 * @return JComboBox

	 */

	private JComboBox getCmbColorField() {

		if (cmbColorField == null) {

			cmbColorField = new JComboBox();

			cmbColorField.addActionListener(this);

		}

		return cmbColorField;

	}

	public void setData(FLayer lyr, ILegend legend) {

		this.layer = lyr;

		this.oldLegend = null;

		if (symbolTable != null)

			pnlSouth.remove(symbolTable);

		symbolTable = new SymbolTable(

		    this, SymbolTable.INTERVALS_TYPE, Geometry.TYPES.GEOMETRY);

		pnlSouth.add(symbolTable,BorderLayout.CENTER);

		fillFieldNames();

		if (legend instanceof QuantityByCategoryLegend) {

            this.oldLegend = (QuantityByCategoryLegend) legend.cloneLegend();

			cmbColorField.setSelectedItem(this.oldLegend.getColorRampLegend().getClassifyingFieldNames()[0]);

			cmbGraduatedSymbolField.setSelectedItem(

			    this.oldLegend.getGraduatedSymbolsLegend()

			    .getClassifyingFieldNames()[0]);

			symbolTable.removeAllItems();

			this.fillTableSkipDefault(this.oldLegend);

		} else {

			this.oldLegend = new QuantityByCategoryLegend();

			String[] fnn = {

                (String) getCmbColorField().getSelectedItem(),

                (String) getCmbGraduatedField().getSelectedItem() };

			this.oldLegend.setClassifyingFieldNames(fnn);

            try {

                FLyrVect lv = (FLyrVect) lyr;

                this.setFieldTypesFromFieldNames(lv, this.oldLegend, fnn);

                this.oldLegend.setShapeType(lv.getShapeType());

            } catch (Exception exc) {

                logger.info("Error while setting data in legend panel", exc);

                ApplicationLocator.getManager().messageDialog(

                    Messages.getText("error_trying_to_access_to_the_layer"),

                    Messages.getText("error"),

                    JOptionPane.ERROR_MESSAGE);

            }

		}

	}

	private void setFieldTypesFromFieldNames(

	    FLyrVect vect,

	    QuantityByCategoryLegend leg,

	    String[] nn) throws DataException {

        FeatureStore fsto = (FeatureStore) vect.getDataStore();

        FeatureType fty = fsto.getDefaultFeatureType();

        int[] fieldTypes  = new int[nn.length];

        FeatureAttributeDescriptor attdesc = null;

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

            attdesc = fty.getAttributeDescriptor(nn[i]);

            fieldTypes[i]= attdesc.getDataType().getType();

        }

        leg.setClassifyingFieldTypes(fieldTypes);

	}

	private void fillSymbolListFromTable() {

		ISymbol theSymbol;

		IInterval theInterval = null;

		// Borramos las anteriores listas:

		this.oldLegend.clear();

		FLyrVect vect = (FLyrVect) layer;

		try {

		    String[] fNames = this.oldLegend.getClassifyingFieldNames();

			if (fNames != null) {

			    setFieldTypesFromFieldNames(vect, this.oldLegend, fNames);

			}

		} catch (DataException e) {

            logger.info("Error while fillSymbolListFromTablel", e);

            ApplicationLocator.getManager().messageDialog(

                Messages.getText("could_not_setup_legend"),

                Messages.getText("error"),

                JOptionPane.ERROR_MESSAGE);

            return;

		}

		for (int row = 0; row < symbolTable.getRowCount(); row++) {

			theInterval = (IInterval) symbolTable.getFieldValue(row, 1);

			theSymbol = (ISymbol) symbolTable.getFieldValue(row, 0);

			theSymbol.setDescription((String) symbolTable.getFieldValue(

					row, 2));

			if (theSymbol instanceof IFillSymbol) {

				this.oldLegend.getColorRampLegend().addSymbol(theInterval, theSymbol);

			} else if (theSymbol instanceof IMarkerSymbol){

				this.oldLegend.getGraduatedSymbolsLegend().addSymbol(theInterval, theSymbol);

			}

		}

		if(oldLegend.getColorRampLegend().isUseDefaultSymbol())

			this.oldLegend.getColorRampLegend().addSymbol(

			    null, oldLegend.getColorRampLegend().getDefaultSymbol());

		if(oldLegend.getGraduatedSymbolsLegend().isUseDefaultSymbol())

			this.oldLegend.getGraduatedSymbolsLegend().addSymbol(

			    null, oldLegend.getGraduatedSymbolsLegend().getDefaultSymbol());

	}

	public ILegend getLegend() {

		fillSymbolListFromTable();

        this.legend = (QuantityByCategoryLegend) this.oldLegend.cloneLegend();

		return this.legend;

	}

	public String getDescription() {

		return Messages.getText("draw_quantities_for_each_category");

	}

	public ImageIcon getIcon() {

	    ImageIcon ii = IconThemeHelper.getImageIcon(

	        "legend-overview-quantity-by-category");

	    return ii;

	}

	public Class getParentClass() {

		return MultipleAttributes.class;

	}

	public String getTitle() {

		return Messages.getText("quantity_by_category");

	}

	public JPanel getPanel() {

		return this;

	}

	public Class getLegendClass() {

		return QuantityByCategoryLegend.class;

	}

	public void actionPerformed(ActionEvent e) {

		JComponent c = (JComponent) e.getSource();

		if (c.equals(getBtnColor())) {

			VectorialIntervalLegend colorRamp = this.oldLegend.getColorRampLegend();

			String fieldName = (String) getCmbColorField().getSelectedItem();

			if (!fieldName.equals(colorRamp.getClassifyingFieldNames()[0])) {

				// if classification field has changed, clear the legend

				colorRamp.setClassifyingFieldNames(new String[] {fieldName});

				colorRamp.clear();

			}

			// create a new modal window to edit the color ramp legend

			VectorialInterval legPanel = new VectorialInterval();

			legPanel.setData(layer, colorRamp);

			InnerWindow window = new InnerWindow(legPanel);

			ApplicationLocator.getManager().getUIManager().addWindow(window);

			cmbColorField.setSelectedItem(colorRamp.getClassifyingFieldNames()[0].toString());

			ILegend newLegend = window.getLegend();

			if (newLegend != null) {

				if (newLegend instanceof VectorialIntervalLegend) {

	                this.oldLegend.getColorRampLegend().clear();

	                this.oldLegend.setColorRampLegend(

	                    (VectorialIntervalLegend) newLegend);

				} else {

		            ApplicationLocator.getManager().messageDialog(

		                Messages.getText("could_not_setup_legend"),

		                Messages.getText("error"),

		                JOptionPane.ERROR_MESSAGE);

				}

			}

			symbolTable.removeAllItems();

			this.fillTableSkipDefault(this.oldLegend);

		} else if (c.equals(getBtnSymbol())) {

			GraduatedSymbolsLegend graduatedSymbol =

			    this.oldLegend.getGraduatedSymbolsLegend();

			String fieldName = (String) getCmbGraduatedField().getSelectedItem();

			if (!fieldName.equals(graduatedSymbol.getClassifyingFieldNames()[0])) {

				// if classification field has changed, clear the legend

				graduatedSymbol.setClassifyingFieldNames(new String[] {fieldName});

		        ISymbol def = MapContextLocator.getSymbolManager().

		            createSymbol(Geometry.TYPES.POINT);

				graduatedSymbol.setDefaultSymbol(def);

				graduatedSymbol.setMinSymbolSize(1);

				graduatedSymbol.setMaxSymbolSize(14);

				graduatedSymbol.clear();

			}

			// create a new modal window to edit the graduated symbol legend

			GraduatedSymbolsPanel legPanel = new GraduatedSymbolsPanel(false);

			legPanel.setData(layer, graduatedSymbol);

			InnerWindow window = new InnerWindow(legPanel);

			ApplicationLocator.getManager().getUIManager().addWindow(window);

			cmbGraduatedSymbolField.setSelectedItem(graduatedSymbol.getClassifyingFieldNames()[0].toString());

			ILegend newLegend = window.getLegend();

			if(newLegend != null) {

			    if (newLegend instanceof GraduatedSymbolsLegend) {

	                this.oldLegend.getGraduatedSymbolsLegend().clear();

	                this.oldLegend.setGraduateSymbolLegend(

	                    (GraduatedSymbolsLegend) newLegend);

			    } else {

                    ApplicationLocator.getManager().messageDialog(

                        Messages.getText("could_not_setup_legend"),

                        Messages.getText("error"),

                        JOptionPane.ERROR_MESSAGE);

			    }

			}

			symbolTable.removeAllItems();

			this.fillTableSkipDefault(this.oldLegend);

		}

		else if (c.equals(getCmbColorField())) {

			symbolTable.removeAllItems();

			this.fillTableSkipDefault(

			    this.oldLegend.getGraduatedSymbolsLegend().getSymbols(),

			    this.oldLegend.getGraduatedSymbolsLegend().getValues(),

			    this.oldLegend.getDescriptions());

		}

		else if (c.equals(getCmbGraduatedField())) {

			symbolTable.removeAllItems();

			this.fillTableSkipDefault(

			    this.oldLegend.getColorRampLegend().getSymbols(),

			    this.oldLegend.getColorRampLegend().getValues(),

			    this.oldLegend.getDescriptions());

		}

//		if (c.equals(getButDel())) {

//			symbolTable.removeSelectedRows();

//		}

//

//		else if(c.equals(getButDelAll())) {

//			symbolTable.removeAllItems();

//		}

	}

	private class InnerWindow extends JPanel implements IWindow {

		private ActionListener okAction = new ActionListener() {

			public void actionPerformed(ActionEvent e) {

				legend = panel.getLegend();

				ApplicationLocator.getManager().getUIManager()

				.closeWindow(InnerWindow.this);

			}

		}, cancelAction = new ActionListener() {

			public void actionPerformed(ActionEvent e) {

                ApplicationLocator.getManager().getUIManager()

                .closeWindow(InnerWindow.this);

			}

		};

		private ILegend legend;

		private ILegendPanel panel;

		private WindowInfo wi;

		public InnerWindow(ILegendPanel panel) {

			this.panel = panel;

			this.setLayout(new BorderLayout());

			add((JComponent) panel, BorderLayout.NORTH);

			add(new AcceptCancelPanel(okAction, cancelAction), BorderLayout.SOUTH);

		}

		public ILegend getLegend() {

			return legend;

		}

		public WindowInfo getWindowInfo() {

			if (wi == null) {

				wi = new WindowInfo(WindowInfo.MODALDIALOG | WindowInfo.RESIZABLE);

				JComponent c = (JComponent) panel;

				wi.setWidth(c.getWidth());

				wi.setHeight(c.getHeight());

				wi.setTitle(panel.getTitle());

			}

			return wi;

		}

		public Object getWindowProfile() {

			return WindowInfo.DIALOG_PROFILE;

		}

	}

	/**

	 * Fills the comboboxes that are placed in the panel with the

	 * classifying field names of the layer

	 *

	 */

	protected void fillFieldNames() {

		ArrayList<String> nomFields = null;

		FLyrVect vect = null;

		try {

            FeatureStore fsto = null;

            FeatureType fty = null;

            FeatureAttributeDescriptor[] atts = null;

			if (layer instanceof FLyrVect) {

			    vect = (FLyrVect) layer;

	            fsto = (FeatureStore) vect.getDataStore();

	            fty = fsto.getDefaultFeatureType();

	            atts = fty.getAttributeDescriptors();

			} else {

	            ApplicationLocator.getManager().messageDialog(

	                Messages.getText("error_trying_to_access_to_the_layer"),

	                Messages.getText("error"),

	                JOptionPane.ERROR_MESSAGE);

	            logger.info("Error while fillFieldNames, Unexpected layer class: "

	                + layer);

	            return;

			}

			nomFields = new ArrayList<String>();

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

			    if (atts[i].getDataType().isNumeric()) {

                    nomFields.add(atts[i].getName());

			    }

			}

		} catch (DataException e) {

            ApplicationLocator.getManager().messageDialog(

                Messages.getText("error_trying_to_access_to_the_layer"),

                Messages.getText("error"),

                JOptionPane.ERROR_MESSAGE);

            logger.info("Error while fillFieldNames", e);

            nomFields = new ArrayList<String>();

		}

		DefaultComboBoxModel cM = new DefaultComboBoxModel(nomFields.toArray());

		cmbColorField.setModel(cM);

		cM = new DefaultComboBoxModel(nomFields.toArray());

		cmbGraduatedSymbolField.setModel(cM);

		symbolTable.removeAllItems();

	}

	public boolean isSuitableFor(FLayer layer) {

		if (layer instanceof FLyrVect) {

			try {

				FLyrVect vect = (FLyrVect) layer;

				int shpt = vect.getGeometryType().getType();

				if (!QuantityByCategoryLegend.isPolygonal(shpt)) {

				    return false;

				}

                FeatureStore fsto = (FeatureStore) vect.getDataStore();

                FeatureType fty = fsto.getDefaultFeatureType();

                FeatureAttributeDescriptor[] atts = fty.getAttributeDescriptors();

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

				    if (atts[i].getDataType().isNumeric()) {

				        return true;

				    }

				}

			} catch (Exception e) {

			    logger.info("Error while isSuitableFor.", e);

	            ApplicationLocator.getManager().message(

	                Messages.getText("error"),

	                JOptionPane.ERROR_MESSAGE);

				return false;

			}

		}

		return false;

	}

	// reemplazar esto por arriba

    private void fillTableSkipDefault(

        IClassifiedLegend leg) {

        Object[] src_expr = leg.getValues();

        ISymbol[] src_syms = leg.getSymbols();

        String[] src_descs = leg.getDescriptions();

        List syms = new ArrayList();

        List vals = new ArrayList();

        List descs = new ArrayList();

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

            if (src_expr[i] instanceof IInterval) {

                syms.add(src_syms[i]);

                vals.add(src_expr[i]);

                descs.add(src_descs[i]);

            }

        }

        symbolTable.fillTableFromSymbolList(

            (ISymbol[]) syms.toArray(new ISymbol[0]),

            (Object[]) vals.toArray(new Object[0]),

            (String[]) descs.toArray(new String[0]));

    }

    private void fillTableSkipDefault(

        ISymbol[] src_syms,

        Object[] src_expr,

        String[] src_descs) {

        List syms = new ArrayList();

        List vals = new ArrayList();

        List descs = new ArrayList();

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

            if (src_expr[i] instanceof IInterval) {

                syms.add(src_syms[i]);

                vals.add(src_expr[i]);

                descs.add(src_descs[i]);

            }

        }

        symbolTable.fillTableFromSymbolList(

            (ISymbol[]) syms.toArray(new ISymbol[0]),

            (Object[]) vals.toArray(new Object[0]),

            (String[]) descs.toArray(new String[0]));

    }

}

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 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 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.symbology.library;

import org.gvsig.andami.IconThemeHelper;

import org.gvsig.app.project.documents.view.legend.gui.LegendManager;

import org.gvsig.symbology.SymbologyLibrary;

import org.gvsig.symbology.fmap.rendering.QuantityByCategoryLegend;

import org.gvsig.symbology.gui.layerproperties.QuantityByCategoryPanel;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

import org.gvsig.tools.persistence.xml.XMLPersistenceLibrary;

import org.gvsig.tools.util.Caller;

import org.gvsig.tools.util.impl.DefaultCaller;

/**

 * Simple library to register Quantity by category legend

 * 

 * @author jldominguez

 *

 */

public class QuantityByCategoryLibrary extends AbstractLibrary {

    public void doRegistration() {

        registerAsImplementationOf(QuantityByCategoryLibrary.class);

        /*

         * This checks map context library registration

         */

        require(SymbologyLibrary.class);

        /*

         * This is because we need to use persistence manager

         */

        require(XMLPersistenceLibrary.class);

    }

    protected void doInitialize() throws LibraryException {

    }

    protected void doPostInitialize() throws LibraryException {

        IconThemeHelper.registerIcon("legend",