Application: gvSIG desktop » gvSIG legends: base legends

org.gvsig.symbology.library.ProportionalSymbolsLibrary

<!--

    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>

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2005 IVER T.I. and Generalitat Valenciana.

 *

 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

package org.gvsig.symbology.fmap.rendering;

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

import org.gvsig.fmap.mapcontext.MapContextManager;

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

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.IMultiLayerSymbol;

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

import org.gvsig.i18n.Messages;

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

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.fill.impl.MarkerFillSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.fill.impl.MultiLayerFillSymbol;

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

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

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.style.SimpleMarkerFillPropertiesStyle;

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 which represents the quantitative information

 * (numeric values). This representation is possible thanks to a symbol

 * whose size is different each time (depending on the numeric values

 * and if we want to use normalization or not).

 *

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

 * @author jldominguez

 */

public class ProportionalSymbolsLegend extends VectorialUniqueValueLegend  {

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

    public static final String

    PROPORTIONAL_SYMBOL_LEGEND_NAME =

        "PROPORTIONAL_SYMBOL_LEGEND";

    public static final String

    PROPORTIONAL_SYMBOL_LEGEND_PERSISTENCE_DEFINITION_NAME =

        "PROPORTIONAL_SYMBOL_LEGEND_PERSISTENCE_DEFINITION";

	public void setClassifyingFieldNames(String[] fNames) {

		super.setClassifyingFieldNames(fNames);

		valueField = fNames[0];

		normalizationField = fNames[1];

	}

	private ISymbol backgroundSymbol;

	private String valueField;

	private String normalizationField;

	private double minSize;

	private double maxSize;

	private int templateShapeType;

	private boolean useNormalization;

	private double maxFeature, minFeature;

	private ZSort zSort = null;

	public ISymbol getSymbolByValue(Object key) {

		return null;

	}

	public ISymbol getSymbolByFeature(Feature feat) {

		ISymbol theSymbol = getDefaultSymbol();

		ISymbol auxSymbol;

		double value = 0;

		double normValue = 0;

		double size;

		double separation = maxSize-minSize;

		if (separation == 0) {

			separation = 1;

		}

		try {

			value = feat.getDouble(this.valueField);

			if (useNormalization) {

			    normValue = feat.getDouble(this.normalizationField);

			    if (normValue == 0) {

			        size = (value >= 0) ?

			            Double.POSITIVE_INFINITY :

			            Double.NEGATIVE_INFINITY;

			    } else {

	                value = value / normValue;

	                size = minSize + (value * separation) ;

			    }

			} else {

				double difFeat = maxFeature - minFeature;

				double step = difFeat/separation;

				size = minSize + ((value - minFeature)/step);

			}

		} catch (Exception e) {

			logger.info("Error while getting value in ProportionalSymbolsLegend.", e);

			return null;

		}

		if (size == Double.NaN || size == Double.POSITIVE_INFINITY

		    || size == Double.NEGATIVE_INFINITY) {

            // logger.info("The symbol size is NaN or INFINITE.");

			return null;

		}

		Geometry defgeom = feat.getDefaultGeometry();

		int def_geom_type = defgeom.getGeometryType().getType();

		if (isPolygonal(def_geom_type) && theSymbol instanceof IMarkerSymbol) {

			MarkerFillSymbol aux = new MarkerFillSymbol();

			((IMarkerSymbol) theSymbol).setSize(size);

			aux.setMarker((IMarkerSymbol) theSymbol);

			SimpleMarkerFillPropertiesStyle p = new SimpleMarkerFillPropertiesStyle();

			p.setFillStyle(SimpleMarkerFillPropertiesStyle.SINGLE_CENTERED_SYMBOL);

			aux.setMarkerFillProperties(p);

			theSymbol = aux;

		}

		else if (isLinear(def_geom_type)) {

			ILineSymbol line = (ILineSymbol) theSymbol;

			line.setLineWidth(size);

			theSymbol = line;

		}

		else if (isPoint(def_geom_type)) {

			IMarkerSymbol marker = (IMarkerSymbol) theSymbol;

			marker.setSize(size);

			theSymbol = marker;

		}

		if (backgroundSymbol != null) {

			MultiLayerFillSymbol multi = new MultiLayerFillSymbol() ;

			multi.addLayer(backgroundSymbol);

			multi.addLayer(theSymbol);

			return multi;

		}

		auxSymbol = theSymbol;

		return auxSymbol;

	}

    public static boolean isPolygonal(int ty) {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

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

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

    }

    public static boolean isLinear(int ty) {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

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

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

    }

    public static boolean isPoint(int ty) {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

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

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

    }

	/**

	 * Gets the background symbol which only can appear when the shapetype of the layer

	 * is polygonal

	 *

	 * @return ISymbol the symbol for the background

	 */

	public ISymbol getBackgroundSymbol() {return backgroundSymbol;}

	/**

	 * Sets the background symbol which is used only when the shapetype of the layer is polygonal

	 *

	 * @param backgroundSymbol the symbol for the background

	 */

	public void setBackgroundSymbol(ISymbol backgroundSymbol) {this.backgroundSymbol = backgroundSymbol;}

	/**

	 * Obtains the classifying field name to be used to calculate the size of the symbol

	 *

	 * @return String  the name of the field

	 * @throws ReadDriverException

	 */

	public String getValueField() {

//		try {

//			// TODO:

//			// Por los alias, al guardar un proyecto no podemos

//			// permitir que se guarde con campos que luego

//			// no van a existir.

////			int id = dataSource.getFieldIndexByName(valueField);

////			valueField = dataSource.getFieldName(id);

//		} catch (ReadDriverException e) {

//			e.printStackTrace();

//			throw new RuntimeException(e);

//		}

		return valueField;

	}

	/**

	 * Sets the classifying field name to be used to calculate the size of the symbol

	 *

	 * @param String  the name of the field

	 */

	public void setValueField(String valueField) {this.valueField = valueField;}

	/**

	 * Obtains the classifying field name to be used to calculate the size of the symbol when the

	 * user is doing it with a normalization value.

	 *

	 * @return String  the name of the field

	 */

	public String getNormalizationField() {

		return normalizationField;

	}

	/**

	 * Sets the classifying field name to be used to calculate the size of the symbol when the

	 * user is doing it with a normalization value.

	 *

	 * @param String  the name of the field

	 */

	public void setNormalizationField(String normalizationField) {this.normalizationField = normalizationField;}

	/**

	 * Obtains the minimum size for the symbol

	 *

	 * @return double  the minimum size for the symbol

	 */

	public double getMinSize() {return minSize;}

	/**

	 * Sets the minimum size for the symbol

	 *

	 * @param minSize  the minimum size for the symbol

	 */

	public void setMinSize(double minSize) {this.minSize = minSize;}

	/**

	 * Obtains the maximum size for the symbol

	 *

	 * @return double  the minimum size for the symbol

	 */

	public double getMaxSize() {return maxSize;}

	/**

	 * Sets the maximum size for the symbol

	 *

	 * @param maxSize  the minimum size for the symbol

	 */

	public void setMaxSize(double maxSize) {this.maxSize = maxSize;}

	/**

	 * Obtains the shapetype of the template symbol

	 *

	 * @return int shape type for the template symbol

	 */

	public int getTemplateShapeType() {return templateShapeType;}

	/**

	 * Sets the shapetype of the template symbol

	 *

	 * @param templateShapeType shape type for the template symbol

	 */

	public void setTemplateShapeType(int tst) {

		if (isPolygonal(getShapeType())) {

			if (isPoint(tst) || isPolygonal(tst)) {

			    this.templateShapeType = tst;

			}

		} else {

		    if ((isPoint(tst) && isPoint(getShapeType()))

		        || (isLinear(tst) && isLinear(getShapeType()))) {

		        // || (getShapeType() == Geometry.TYPES.NULL)) {

		        this.templateShapeType = tst;

		    }

		}

	}

	/**

	 * Obtains the boolean which is true if the user wants to calculate the size of the

	 * symbol using a normalization field.

	 *

	 * @return boolean true if the user wants normalization.Otherwise, false.

	 */

	public boolean getUseNormalization() {return useNormalization;}

	/**

	 * Sets the boolean which is true if the user wants to calculate the size of the

	 * symbol using a normalization field.

	 *

	 * @param useNormalization true if the user wants normalization.Otherwise, false.

	 */

	public void setUseNormalization(boolean useNormalization) {this.useNormalization = useNormalization;}

	/**

	 * Obtains the variable which represents the maximum value of the classifying field that is used

	 * to calculate the size of the symbol

	 *

	 * @return double  the maximum value of the classifying field

	 */

	public double getMaxFeature() {return maxFeature;}

	/**

	 * Sets the variable which represents the maximum value of the classifying field that is used

	 * to calculate the size of the symbol

	 *

	 * @param maxFeature

	 */

	public void setMaxFeature(double maxFeature) {this.maxFeature = maxFeature;}

	/**

	 * Obtains the variable which represents the minimum value of the classifying field that is used

	 * to calculate the size of the symbol

	 *

	 * @return double  the minimum value of the classifying field

	 */

	public double getMinFeature() {return minFeature;}

	/**

	 * Sets the variable which represents the minimum value of the classifying field that is used

	 * to calculate the size of the symbol

	 *

	 * @param minFeature

	 */

	public void setMinFeature(double minFeature) {this.minFeature = minFeature;}

	public ISymbol[] getSymbols() {

		ISymbol[] auxSymbols=super.getSymbols();

		if(backgroundSymbol != null){

			ISymbol[] symbols=new ISymbol[auxSymbols.length+1];

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

				symbols[i]=auxSymbols[i];

			}

			symbols[symbols.length-1]=backgroundSymbol;

			return symbols;

		} else {

			return auxSymbols;

		}

	}

	public ZSort getZSort() {

		if (zSort == null){

			zSort = new MyZSort(this);

		}

		return zSort;

	}

	public void setZSort(ZSort zSort){

		return;

	}

	private class MyZSort extends ZSort {

		public MyZSort(ILegend legend) {

			super(legend);

		}

		public void legendChanged(LegendChangedEvent e) {

		}

		public String getClassName() {

			return getClass().getName();

		}

		public int getLevelCount() {

			int levels = 0;

			if (backgroundSymbol!=null){

				if(backgroundSymbol instanceof IMultiLayerSymbol){

					levels += ((IMultiLayerSymbol)backgroundSymbol).getLayerCount();

				} else {

					levels += 1;

				}

			}

			ISymbol sym = getDefaultSymbol();

			if(getDefaultSymbol() instanceof IMultiLayerSymbol){

				levels += ((IMultiLayerSymbol)sym).getLayerCount();

			} else {

				levels += 1;

			}

			return levels+1;

		}

		public void setUsingZSort(boolean usingZSort) {

		}

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

		}

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

		}

		public int[] getLevels(ISymbol sym) {

			return getLevels(0);

		}

		public int[] getLevels(int row) {

			int levelsCount = getLevelCount();

			int[] levels = new int[levelsCount];

			int bgLevels = 1;

			if (backgroundSymbol!=null){

				if(backgroundSymbol instanceof IMultiLayerSymbol){

					bgLevels = ((IMultiLayerSymbol)backgroundSymbol).getLayerCount();

				}

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

					levels[i]=i;

				}

			}

			ISymbol sym = getDefaultSymbol();

			int frLevels = 1;

			if(getDefaultSymbol() instanceof IMultiLayerSymbol){

				frLevels = ((IMultiLayerSymbol)sym).getLayerCount();

			}

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

				levels[i+bgLevels]=i+bgLevels;

			}

			levels[frLevels+bgLevels]=frLevels+bgLevels;

			return levels;

		}

		public boolean isUsingZSort() {

			return backgroundSymbol!=null;

		}

		public ISymbol[] getSymbols() {

			return getSymbols();

		}

		public String[] getDescriptions() {

			return getDescriptions();

		}

		public int getTopLevelIndexAllowed() {

			return getLevelCount();

		}

		@Override

		public String toString() {

			String out = "ZSort for ProportionalSymbolLegend";

			return out;

		}

		public boolean symbolChanged(SymbolLegendEvent e) {

			return true;

		}

		public boolean classifiedSymbolChange(SymbolLegendEvent e) {

			return true;

		}

		public boolean intervalChange(IntervalLegendEvent e) {

			return false;

		}

		public boolean valueChange(ValueLegendEvent e) {

			return false;

		}

		// TODO should not exist here

		public boolean labelFieldChange(LabelLegendEvent e) {

			return false;

		}

		public void legendCleared(LegendClearEvent event) {

		}

	}

    public void loadFromState(PersistentState state)

        throws PersistenceException {

        int[] ft = state.getIntArray("fieldTypes");

        this.setClassifyingFieldTypes(ft);

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

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

        this.templateShapeType = state.getInt("templateShapeType");

        this.maxSize = state.getDouble("maxSize");

        this.minSize = state.getDouble("minSize");

        this.maxFeature = state.getDouble("maxFeature");

        this.minFeature = state.getDouble("minFeature");

        this.useNormalization = state.getBoolean("useNormalization");

        ISymbol sym = (ISymbol) state.get("defaultSymbol");

        this.setDefaultSymbol(sym);

        sym = (ISymbol) state.get("backgroundSymbol");

        this.setBackgroundSymbol(sym);

        String[] fieldNames = new String[2];

        fieldNames[0]= valueField;

        if (normalizationField.compareTo(Messages.getText("none")) == 0) {

            fieldNames[1]= fieldNames[0];

        } else {

            fieldNames[1] = normalizationField;

        }

        setClassifyingFieldNames(fieldNames);

    }

    public void saveToState(PersistentState state) throws PersistenceException {

        int[] ft = this.getClassifyingFieldTypes();

        state.set("fieldTypes", ft);

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

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

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

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

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

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

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

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

        state.set("defaultSymbol", this.getDefaultSymbol());

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

    }

    public static class RegisterPersistence implements Callable {

        public Object call() throws Exception {

            PersistenceManager manager = ToolsLocator.getPersistenceManager();

            if (manager

                .getDefinition(PROPORTIONAL_SYMBOL_LEGEND_PERSISTENCE_DEFINITION_NAME) == null) {

                DynStruct definition =

                    manager

                        .addDefinition(

                            ProportionalSymbolsLegend.class,

                            PROPORTIONAL_SYMBOL_LEGEND_PERSISTENCE_DEFINITION_NAME,

                            PROPORTIONAL_SYMBOL_LEGEND_PERSISTENCE_DEFINITION_NAME

                                + " Persistence definition", null, null);

                definition.addDynFieldString("valueField").setMandatory(true);

                definition.addDynFieldString("normalizationField").setMandatory(true);

                definition.addDynFieldInt("templateShapeType").setMandatory(true);

                definition.addDynFieldArray("fieldTypes").setClassOfItems(Integer.class).setMandatory(true);

                definition.addDynFieldDouble("maxSize").setMandatory(true);

                definition.addDynFieldDouble("minSize").setMandatory(true);

                definition.addDynFieldDouble("maxFeature").setMandatory(true);

                definition.addDynFieldDouble("minFeature").setMandatory(true);

                definition.addDynFieldBoolean("useNormalization").setMandatory(true);

                definition.addDynFieldObject("defaultSymbol")

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

                definition.addDynFieldObject("backgroundSymbol")

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

            }

            return Boolean.TRUE;

        }

    }

    public static class RegisterLegend implements Callable {

        public Object call() throws Exception {

            MapContextManager manager =

                MapContextLocator.getMapContextManager();

            manager.registerLegend(

                PROPORTIONAL_SYMBOL_LEGEND_NAME,

                ProportionalSymbolsLegend.class);

            return Boolean.TRUE;

        }

    }

}

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2005 IVER T.I. and Generalitat Valenciana.

 *

 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

package org.gvsig.symbology.gui.layerproperties;

import java.awt.BorderLayout;

import java.awt.Color;

import java.awt.Dimension;

import java.awt.FlowLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.BorderFactory;

import javax.swing.DefaultComboBoxModel;

import javax.swing.ImageIcon;

import javax.swing.JComboBox;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.andami.IconThemeHelper;

import org.gvsig.app.ApplicationLocator;

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.mapcontext.MapContextLocator;

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

import org.gvsig.fmap.mapcontext.layers.operations.ClassifiableVectorial;

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

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

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

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

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

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

import org.gvsig.i18n.Messages;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.fill.impl.MarkerFillSymbol;

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

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

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

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

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.style.IMarkerFillPropertiesStyle;

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

import org.gvsig.tools.dispose.DisposableIterator;

/**

 * Implements the panel for the legend of proportional symbols.In the interface will be

 * options to select the value field, the normalization field (if the user wants to use it) and

 * options to select the symbol an its minimum and maximum size.

 *

 * Also there will be possible to select a background symbol (only when the shapetype of the layer is

 * polygonal).

 *

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

 * @author jldominguez

 */

public class ProportionalSymbolsPanel extends JPanel implements ILegendPanel {

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

	private static final long serialVersionUID = 7394720230276170902L;

	private JPanel symbolPanel;

	private JPanel backgroundPanel;

	private JSymbolPreviewButton tmplateSymbol;

	private JSymbolPreviewButton backSymbol;

	private JComboBox cmbValue;

	private JComboBox cmbNormalization;

	private JNumberSpinner txtMinSize;

	private JNumberSpinner txtMaxSize;

	private ClassifiableVectorial myLayer;

	private ProportionalSymbolsLegend auxLegend;

	private String[] fieldNames;

	private int templateShapeType = 0;

	private String noNormalization = Messages.getText("none");

	private boolean useNormalization = true;

	/**

	 * Default constructor

	 */

	public ProportionalSymbolsPanel() {

		initialize();

	}

	/**

	 * This method initializes this

	 */

	private void initialize() {

		setLayout(new BorderLayout());

		JPanel aux = new JPanel(new BorderLayout());

		JPanel fieldsPanel = new JPanel(new FlowLayout());

		fieldsPanel.setBorder(BorderFactory.

				createTitledBorder(null,

				    Messages.getText("fields")

						));

		fieldsPanel.setPreferredSize(new Dimension(300,60));

		cmbValue = new JComboBox();

		cmbValue.setActionCommand("VALUE_SELECTED");

		cmbNormalization = new JComboBox();

		cmbNormalization.setActionCommand("NORMALIZATION_SELECTED");

		fieldsPanel.add(new JLabel(

		    Messages.getText("value")

		    +":" ));

		fieldsPanel.add(cmbValue);

		fieldsPanel.add(new JLabel(

		    Messages.getText("normalization")

		    +":" ));

		fieldsPanel.add(cmbNormalization);

		symbolPanel = new JPanel(new FlowLayout(FlowLayout.LEADING, 3,2));

		symbolPanel.setBorder(BorderFactory.

				createTitledBorder(null,

				    Messages.getText("symbol")

						));

		GridBagLayoutPanel aux2 = new GridBagLayoutPanel();

		aux2.addComponent(new JLabel(

		    Messages.getText("size")

		    ));

		aux2.addComponent(new JBlank(10,10));

		aux2.addComponent(

		    Messages.getText("from")

		    +":",

				getTxtMinSize());

		aux2.addComponent(

		    Messages.getText("to")

		    +":",

				getTxtMaxSize());

		JPanel templatePanel = new JPanel();

		templatePanel.setBorder(BorderFactory.createTitledBorder(null,

		    Messages.getText("template")

				));

		templatePanel.add(getTemplSymbol());

		symbolPanel.add(new JBlank(10,10));

		symbolPanel.add(aux2);

		symbolPanel.add(new JBlank(10,10));

		symbolPanel.add(templatePanel);

		aux.add(fieldsPanel, BorderLayout.NORTH);

		aux.add(symbolPanel, BorderLayout.CENTER);

		this.add(aux, BorderLayout.CENTER);

		cmbValue.addActionListener(action);

		cmbNormalization.addActionListener(action);

		tmplateSymbol.addActionListener(action);

	}

	/**

	 * Creates the panel where the button for the background symbol will be placed

	 *

	 * @return JPanel panel

	 */

	private JPanel getBackgroundPanel() {

		backgroundPanel = new JPanel();

		backgroundPanel.setBorder(BorderFactory.createTitledBorder(null,

		    Messages.getText("background")

				));

		backgroundPanel.add(getBtnBackground());

		return backgroundPanel;

	}

	/**

	 * Creates a JNumberSpinner which is used to select the maximum size for the symbol

	 *

	 * @return JNumberSpinner

	 */

	private JNumberSpinner getTxtMaxSize() {

		if (txtMaxSize == null) {

			txtMaxSize = new JNumberSpinner(25.0,7,0.0,100.0,1.0,2);

			txtMaxSize.addActionListener(action);

		}

		return txtMaxSize;

	}

	/**

	 * Creates a JNumberSpinner which is used to select the minimum size for the symbol

	 *

	 * @return JNumberSpinner

	 */

	private JNumberSpinner getTxtMinSize() {

		if (txtMinSize == null) {

			txtMinSize = new JNumberSpinner(3.0,7,0.0,100.0,1.0,2);

			txtMinSize.addActionListener(action);

		}

		return txtMinSize;

	}

	/**

	 * Creates a JSymbolPreviewButton which is used to select the template symbol

	 *

	 * @return JSymbolPreviewButton

	 */

	private JSymbolPreviewButton getTemplSymbol() {

		if (tmplateSymbol == null) {

			int tst = ProportionalSymbolsLegend.isPolygonal(this.templateShapeType) ?

			    Geometry.TYPES.POINT

			    : this.templateShapeType;

			tmplateSymbol = new JSymbolPreviewButton(tst);

		}

		tmplateSymbol.setPreferredSize(new Dimension(100, 45));

		return tmplateSymbol;

	}

	/**

	 * Creates a JSymbolPreviewButton which is used to select the background symbol

	 *

	 * @return JSymbolPreviewButton

	 */

	private JSymbolPreviewButton getBtnBackground() {

		if (backSymbol == null) {

			backSymbol = new JSymbolPreviewButton(Geometry.TYPES.SURFACE);

			backSymbol.setPreferredSize(new Dimension(100, 45));

            ISymbol fillsym = MapContextLocator.getSymbolManager().createSymbol(

                Geometry.TYPES.SURFACE, Color.ORANGE);

            backSymbol.setSymbol(fillsym);

		}

		return backSymbol;

	}

	/**

	 * Creates a new symbol of an specific shapetype with a concrete size

	 *

	 * @param shapeType

	 * @param size

	 *

	 * @return ISymbol symbol created

	 */

	private ISymbol newSymbol(int shapeType, double size) {

		if (getTemplSymbol().getSymbol() == null) {

			ISymbol templateSymbol;

            GeometryManager geomManager = GeometryLocator.getGeometryManager();

            if( geomManager.isSubtype(Geometry.TYPES.POINT, shapeType) ||

                geomManager.isSubtype(Geometry.TYPES.MULTIPOINT, shapeType) ||

                geomManager.isSubtype(Geometry.TYPES.SURFACE, shapeType) ||

                geomManager.isSubtype(Geometry.TYPES.MULTISURFACE, shapeType) ) {

				templateSymbol = new SimpleMarkerSymbol();

				((SimpleMarkerSymbol) templateSymbol).setSize(size);

				((SimpleMarkerSymbol) templateSymbol).setColor(Color.DARK_GRAY);

            } else if( geomManager.isSubtype(Geometry.TYPES.CURVE, shapeType) ||

                geomManager.isSubtype(Geometry.TYPES.MULTICURVE, shapeType) ) {

				templateSymbol = new SimpleLineSymbol();

				((SimpleLineSymbol) templateSymbol).setLineWidth(size);

				((SimpleLineSymbol) templateSymbol).setLineColor(Color.DARK_GRAY);

            } else {

				throw new RuntimeException("Unknown symbol type");

            }

			getTemplSymbol().setSymbol(templateSymbol);

			return newSymbol(shapeType, size);

		} else {

			// clone symbol

			ISymbol mySymbol = getTemplSymbol().getSymbol();

			try {

                mySymbol = (ISymbol) mySymbol.clone();

            } catch (CloneNotSupportedException e) {

                logger.info("Error while cloning symbol", e);

                ApplicationLocator.getManager().messageDialog(

                    Messages.getText("_Unable_to_clone_symbol"),

                    Messages.getText("error"),

                    JOptionPane.ERROR_MESSAGE);

            }

			if (mySymbol instanceof ILineSymbol) {

				ILineSymbol lSym = (ILineSymbol) mySymbol;

				lSym.setLineWidth(size);

			}

			if (mySymbol instanceof IMarkerSymbol) {

				IMarkerSymbol mSym = (IMarkerSymbol) mySymbol;

				mSym.setSize(size);

				if (ProportionalSymbolsLegend.isPolygonal(shapeType)) {

					// this is to allow using in Polygon layers

					MarkerFillSymbol fillSymbol = new MarkerFillSymbol();

					fillSymbol.setOutline(null);

					fillSymbol.setFillColor(null);

					fillSymbol.getMarkerFillProperties().

					setFillStyle(IMarkerFillPropertiesStyle.SINGLE_CENTERED_SYMBOL);

					fillSymbol.setMarker(mSym);

				}

			}

			return mySymbol;

		}

	}

	/**

	 * Fills the comboboxes that are placed in the panel with the classifying field names of the layer

	 * which contain numerical information

	 *

	 */

	private void fillFieldNames() {

		// SelectableDataSource rs;

		try {

		    FeatureStore fsto = (FeatureStore) ((FLyrVect) myLayer).getDataStore();

		    FeatureType fty = fsto.getDefaultFeatureType();

		    FeatureAttributeDescriptor[] atts = fty.getAttributeDescriptors();

			int cont = 0;

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

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

                    cont++;

			    }

			}

			String[] nomFields = new String[cont];

			cont = 0;

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

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

                    nomFields[cont] = atts[i].getName();

                    cont++;

                }

            }

			this.fieldNames = nomFields;

			DefaultComboBoxModel cMValue = new DefaultComboBoxModel(this.fieldNames);

			DefaultComboBoxModel cMNormalization = new DefaultComboBoxModel(this.fieldNames);

			cmbValue.setModel(cMValue);

			cmbNormalization.setModel(cMNormalization);

			cmbNormalization.addItem(noNormalization);

		} catch (DataException e) {

		    logger.info("Error while getting fields", e);

		    ApplicationLocator.getManager().messageDialog(

		        Messages.getText("_Error_while_getting_fields"),

                Messages.getText("error"),

		        JOptionPane.ERROR_MESSAGE);

			// NotificationManager.addError(PluginServices.getText(this, "recovering_recordset"), e);

		}

	}

	public void setData(FLayer lyr, ILegend legend) {

		this.myLayer = (ClassifiableVectorial) lyr;

		fillFieldNames();

	    int myt = Geometry.TYPES.GEOMETRY;

	    try {

	        myt = this.myLayer.getGeometryType().getType();

	    } catch (ReadException re) {

	        logger.info("Error while getting geometry type", re);

	        ApplicationLocator.getManager().message(

	            "Error getting geometry type",

	            JOptionPane.ERROR_MESSAGE);

	    }

		templateShapeType =

		    ProportionalSymbolsLegend.isPolygonal(myt) ?

		    Geometry.TYPES.POINT : myt;

		getTemplSymbol().setShapeType(templateShapeType);

		if (ProportionalSymbolsLegend.isPolygonal(myt) && backgroundPanel == null) {

		    symbolPanel.add(getBackgroundPanel());

		}

		if (ProportionalSymbolsLegend.class.equals(legend.getClass())) {

            auxLegend = (ProportionalSymbolsLegend) legend.cloneLegend();

			cmbValue.setSelectedItem(auxLegend.getClassifyingFieldNames()[0]);

			ISymbol defSymbol = auxLegend.getDefaultSymbol();

			if(((ProportionalSymbolsLegend) auxLegend).getUseNormalization())

				cmbNormalization.setSelectedItem(auxLegend.getClassifyingFieldNames()[1]);

			else cmbNormalization.setSelectedItem(noNormalization);

			txtMaxSize.setDouble(auxLegend.getMaxSize());

			txtMinSize.setDouble(auxLegend.getMinSize());

			if (ProportionalSymbolsLegend.isLinear(templateShapeType)) {

			    ((ILineSymbol)defSymbol).setLineWidth(2);

			} else {

                ((IMarkerSymbol)defSymbol).setSize(15);

			}

			getTemplSymbol().setSymbol(defSymbol);

			if(((ProportionalSymbolsLegend) auxLegend).getBackgroundSymbol() != null)

				getBtnBackground().setSymbol(((ProportionalSymbolsLegend) auxLegend).getBackgroundSymbol());

		} else {

			auxLegend = new ProportionalSymbolsLegend();

			auxLegend.setTemplateShapeType(templateShapeType);

			if (ProportionalSymbolsLegend.isLinear(templateShapeType)) {

	            auxLegend.setDefaultSymbol(newSymbol(templateShapeType, 2));

			} else {

	            auxLegend.setDefaultSymbol(newSymbol(templateShapeType, 15));

			}

			getTemplSymbol().setSymbol(auxLegend.getDefaultSymbol());

			if (ProportionalSymbolsLegend.isLinear(templateShapeType)) {

                txtMinSize.setDouble(3);

                txtMaxSize.setDouble(3);

			} else {

                txtMinSize.setDouble(10);

                txtMaxSize.setDouble(10);

			}

		}

	}

	public ILegend getLegend() {

		ProportionalSymbolsLegend theLegend = new ProportionalSymbolsLegend();

		String[] fieldNames = new String[2];

		fieldNames[0]= cmbValue.getSelectedItem().toString();

		if(!useNormalization)

			fieldNames[1]= fieldNames[0];

		else fieldNames[1]= cmbNormalization.getSelectedItem().toString();

		auxLegend.setTemplateShapeType(templateShapeType);

		auxLegend.setValueField(cmbValue.getSelectedItem().toString());

		auxLegend.setNormalizationField(cmbNormalization.getSelectedItem().toString());

		auxLegend.setUseNormalization(useNormalization);

		auxLegend.setMinSize(txtMinSize.getDouble());

		auxLegend.setMaxSize(txtMaxSize.getDouble());

		ISymbol symbol = getTemplSymbol().getSymbol();

		symbol.setDescription(getSymbolDescription());

		auxLegend.setDefaultSymbol(symbol);

        auxLegend.clear();

		auxLegend.addSymbol("defaultSymbol", symbol);

		if(auxLegend.isPolygonal(this.templateShapeType)){

		    auxLegend.setBackgroundSymbol(getBtnBackground().getSymbol());

		}

		auxLegend.setClassifyingFieldNames(fieldNames);

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

		FLyrVect vect = (FLyrVect) myLayer;

		FeatureStore fsto = null;

		FeatureType fty = null;

		FeatureAttributeDescriptor[] atts = null;

		try {

		    fsto = (FeatureStore) vect.getDataStore();

		    fty = fsto.getDefaultFeatureType();

		    int[] fieldTyp = new int[2];

		    fieldTyp[0] = fty.getAttributeDescriptor(fieldNames[0]).getType();

            fieldTyp[1] = fty.getAttributeDescriptor(fieldNames[1]).getType();

            auxLegend.setClassifyingFieldTypes(fieldTyp);

		    FeatureSet fset = fsto.getFeatureSet();

		    DisposableIterator diter = fset.fastIterator();

		    Feature fitem = null;

		    double[] maxs = new double[fieldNames.length];

            double[] mins = new double[fieldNames.length];

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

                // init to worst values

                maxs[i] = -Double.MAX_VALUE;

                mins[i] = Double.MAX_VALUE;

            }

            double aux_dob = 0;

		    while (diter.hasNext()) {

		        fitem = (Feature) diter.next();

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

		            aux_dob = fitem.getDouble(fieldNames[i]);

		            if (aux_dob > maxs[i]) {

		                maxs[i] = aux_dob;

		            }

                    if (aux_dob < mins[i]) {

                        mins[i] = aux_dob;

                    }

		        }

		    }

            auxLegend.setMinFeature(mins[0]);

            auxLegend.setMaxFeature(maxs[0]);

		} catch (DataException e) {

		    logger.info("Error while creating ProportionalSymbols legend", e);

		    ApplicationLocator.getManager().message(

		        Messages.getText("_Error_while_creating_legend"),

		        JOptionPane.ERROR_MESSAGE);

		}

        theLegend = (ProportionalSymbolsLegend) auxLegend.cloneLegend();

        // theLegend.addSymbol("defaultSymbol", symbol);

		return theLegend;

	}

	/**

	 * Creates the String which will be the description of the symbol. If the selected normalization field

	 * is not "None", then the String created will have this structure ValueField/NormalizationField. Else,

	 * if the user select "None" for the normalization field,the string will show the ValueField only.

	 *

	 * @return String	description for the symbol

	 */

	private String getSymbolDescription() {

		String description = "";

		if (cmbValue.getSelectedItem() != null)

			description += cmbValue.getSelectedItem().toString();

		if (cmbNormalization.getSelectedItem().toString().compareTo(noNormalization) != 0 )

			description += " / "+cmbNormalization.getSelectedItem().toString();

		return description;

	}

	public String getDescription() {

		return Messages.getText(

		    "draw_quantities_using_symbol_size_to_show_exact_values");

	}

	public ImageIcon getIcon() {

	    return IconThemeHelper.getImageIcon(

	        "legend-overview-proportional-symbols");

	}

	public Class getParentClass() {

		return Quantities.class;

	}

	public String getTitle() {

	    return Messages.getText("proportional_symbols");

	}

	public Class getLegendClass() {

		return ProportionalSymbolsLegend.class;

	}

	public boolean isSuitableFor(FLayer layer) {

		if (layer instanceof FLyrVect) {

			FLyrVect lyr = (FLyrVect) layer;

			try {

				if (lyr.getShapeType() == Geometry.TYPES.GEOMETRY)

					return false;

				FeatureStore fsto = (FeatureStore) lyr.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 (DataException e) {

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

			    ApplicationLocator.getManager().message(

			        Messages.getText("_Error_while_checking_suitability"),

			        JOptionPane.ERROR_MESSAGE);

				return false;

			}

		}

		return false;

	}

	public JPanel getPanel() {

		return this;

	}

	private ActionListener action = new ActionListener() {

		public void actionPerformed(ActionEvent e) {

			if (e.getSource().equals(cmbValue)) {

				JComboBox cb = (JComboBox) e.getSource();

				auxLegend.setValueField(cb.getSelectedItem().toString());

			}

			if (e.getSource().equals(cmbNormalization)) {

				JComboBox cb = (JComboBox) e.getSource();

				if(cb.getSelectedItem().toString().compareTo(noNormalization) == 0) {

					useNormalization = false;

					auxLegend.setNormalizationField(cmbValue.getSelectedItem().toString());

				}

				else {

					useNormalization = true;

					auxLegend.setNormalizationField(cb.getSelectedItem().toString());

				}

				auxLegend.setUseNormalization(useNormalization);

			}

			if (e.getSource().equals(txtMinSize)) {

//				ISymbol sym = tmplateSymbol.getSymbol();

//				if(sym != null) {

//					if(sym instanceof ILineSymbol) {

//						ILineSymbol line = (ILineSymbol)sym;

//						line.setLineWidth(txtMinSize.getDouble());

//						tmplateSymbol.setSymbol(line);

//					}

//

//					if(sym instanceof IMarkerSymbol) {

//						IMarkerSymbol point = (IMarkerSymbol)sym;

//						point.setSize(txtMinSize.getDouble());

//						tmplateSymbol.setSymbol(point);

//					}

//					tmplateSymbol.repaint();

//				}

				if(txtMaxSize.getDouble() < txtMinSize.getDouble())

					txtMaxSize.setDouble(txtMinSize.getDouble());

			}

			if(e.getSource().equals(txtMaxSize)) {

				if(txtMaxSize.getDouble() < txtMinSize.getDouble())

					txtMinSize.setDouble(txtMaxSize.getDouble());

			}

//			if(e.getSource().equals(tmplateSymbol)) {

//				ISymbol sym = tmplateSymbol.getSymbol();

//				if(sym != null) {

//					if(sym instanceof ILineSymbol) {

//						ILineSymbol line = (ILineSymbol)sym;

//						txtMinSize.setDouble(((int)line.getLineWidth()));

//						txtMaxSize.setDouble(((int)line.getLineWidth()));

//					}

//

//					if(sym instanceof IMarkerSymbol) {

//						IMarkerSymbol point = (IMarkerSymbol)sym;

//						txtMinSize.setDouble(((int)point.getSize()));

//						txtMaxSize.setDouble(((int)point.getSize()));

//

//					}

//				}

//			}

		}

	};

}

/* 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.ProportionalSymbolsLegend;

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

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 proportional symbols legend

 * 

 * @author jldominguez

 *

 */

public class ProportionalSymbolsLibrary extends AbstractLibrary {

    public void doRegistration() {

        registerAsImplementationOf(ProportionalSymbolsLibrary.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", "legend-overview-proportional-symbols", this);

        Caller caller = new DefaultCaller();

        caller.add(new ProportionalSymbolsLegend.RegisterLegend());

        caller.add(new ProportionalSymbolsLegend.RegisterPersistence());

        /*

         * Do register of all

         */

        if( !caller.call() ) {

            throw new LibraryException(

                ProportionalSymbolsLibrary.class,

                caller.getExceptions());

        }

        LegendManager.addLegendPage(ProportionalSymbolsPanel.class);

    }

}