Application: gvSIG desktop » gvSIG legends: base legends

#Fri Mar 08 00:41:27 CET 2024

buildNumber=245

<!--

    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

 */

/* CVS MESSAGES:

 *

 * $Id: GraduatedSymbolLegend.java 16187 2007-11-08 16:13:44Z jdominguez $

 * $Log$

 * Revision 1.3  2007-05-17 09:32:06  jaume

 * *** empty log message ***

 *

 * Revision 1.2  2007/03/09 11:20:56  jaume

 * Advanced symbology (start committing)

 *

 * Revision 1.1.2.4  2007/02/15 16:23:44  jaume

 * *** empty log message ***

 *

 * Revision 1.1.2.3  2007/02/14 15:53:35  jaume

 * *** empty log message ***

 *

 * Revision 1.1.2.2  2007/02/13 16:19:19  jaume

 * graduated symbol legends (start commiting)

 *

 * Revision 1.1.2.1  2007/02/12 15:15:20  jaume

 * refactored interval legend and added graduated symbol legend

 *

 *

 */

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.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.symbols.ISymbol;

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.fill.impl.MarkerFillSymbol;

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

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;

/**

 * <p>GraduatedSymbolLegend is a legend that allows to classify ranges of

 * values using a value with symbol sizes.<b>

 * </p>

 * <p>

 * The symbol size will be calculated according the min size, the

 * max size and the amount of intervals. So for a min size of 1, a max size

 * of 5, and 5 intervals, symbol sizes will be [1, 2, 3, 4, 5].

 * </p>

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

 */

public class GraduatedSymbolsLegend extends VectorialIntervalLegend {

    private static Logger logger = LoggerFactory.getLogger(

        GraduatedSymbolsLegend.class);

    public static final String

    GRADUATED_SYMBOL_LEGEND_NAME =

        "GRADUATED_SYMBOL_LEGEND";  

    public static final String

    GRADUATED_SYMBOL_LEGEND_PERSISTENCE_DEFINITION_NAME =

        "GRADUATED_SYMBOL_LEGEND_PERSISTENCE_DEFINITION";  

	private double maxSymbolSize;

	private double minSymbolSize;

	private ISymbol backgroundSymbol;

	private int templateShapeType;

	/**

	 * DefaultConstructor

	 */

	public GraduatedSymbolsLegend() {

		super();

	}

	/**

	 * Convenience constructor.

	 *

	 * Creates a new instance of GraduatedSymbolLegend from a VectorialIntervalLegend by

	 * taking the same fields.

	 * @param leg

	 */

	public GraduatedSymbolsLegend(VectorialIntervalLegend leg) {

		this();

        this.setShapeType(leg.getShapeType());

        Object[] _keys = leg.getValues();

        ISymbol[] _syms = leg.getSymbols();

        if (_keys == null || _syms == null) {

            logger.info("Warning: inconsistent VectorialIntervalLegend (keys or syms is null)");

        } else {

            if (_keys.length != _syms.length) {

                logger.info("Warning: inconsistent VectorialIntervalLegend (keys and syms have dif length)");

            } else {

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

                    this.addSymbol(_keys[i], _syms[i]);

                }

            }

        }

        this.setClassifyingFieldNames(leg.getClassifyingFieldNames());

        this.setClassifyingFieldTypes(leg.getClassifyingFieldTypes());

        this.setDefaultSymbol(leg.getDefaultSymbol());

        this.setIntervalType(leg.getIntervalType());

        this.useDefaultSymbol(leg.isUseDefaultSymbol());

	}

	/**

	 * Returns the max symbol size. Combined with the min symbol size and

	 * the interval count, will produce the symbol sizes.

	 * @return double, the max size.

	 */

	public double getMaxSymbolSize() {

		return maxSymbolSize;

	}

	/**

	 * Returns the min symbol size. Combined with the max symbol size and

	 * the interval count, will produce the symbol sizes.

	 * @return double, the min size.

	 */

	public double getMinSymbolSize() {

		return minSymbolSize;

	}

	/**

	 * Sets the max symbol size. Combined with the min symbol size and

	 * the interval count, will produce the symbol sizes.

	 */

	public void setMaxSymbolSize(double size) {

		this.maxSymbolSize = size;

	}

	/**

	 * Sets the min symbol size. Combined with the max symbol size and

	 * the interval count, will produce the symbol sizes.

	 */

	public void setMinSymbolSize(double size) {

		this.minSymbolSize = size;

	}

	public ISymbol getSymbolByFeature(Feature feat) throws MapContextException {

		ISymbol theSymbol = super.getSymbolByFeature(feat);

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

			// transform it to a fill symbol

            theSymbol = toFillSymbol(theSymbol);

		}

		if (backgroundSymbol != null) {

			MultiLayerFillSymbol multi = new MultiLayerFillSymbol() ;

			multi.addLayer(backgroundSymbol);

			multi.addLayer(theSymbol);

			return multi;

		}

		return theSymbol;

	}

	@Override

	public ISymbol getSymbolByInterval(IInterval key) {

		ISymbol theSymbol = super.getSymbolByInterval(key);

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

			// transform it to a fill symbol

			theSymbol = toFillSymbol(theSymbol);

		}

		return theSymbol;

	}

	/**

	 * Obtains the background symbol

	 */

	public ISymbol getBackgroundSymbol() {

		return backgroundSymbol;

	}

	/**

	 * Sets the background symbol.

	 * @param symbol

	 */

	public void setBackgroundSymbol(ISymbol symbol) {

		this.backgroundSymbol = symbol;

	}

	public ISymbol getDefaultSymbol() {

		return defaultSymbol;

	}

	@Override

	public boolean isSuitableForShapeType(int st) {

		return areSameBasicType(getShapeType(), st)

		    ||

		    (isPoint(getTemplateShapeType()) && isPolygonal(st));

	}

	/**

	 * Obtains the shapetype of the background symbol

	 */

	public int getTemplateShapeType() {

		return templateShapeType;

	}

	/**

	 * Sets the shapetype of the background symbol

	 */

	public void setTemplateShapeType(int tst) {

		if (isPolygonal(getShapeType())) {

			if(isPoint(tst))

				this.templateShapeType = tst;

		}

		else if(areSameBasicType(tst, getShapeType())) {

			this.templateShapeType = tst;

		}

	}

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

    }

    public static boolean areSameBasicType(int ta, int tb) {

        if (isPoint(ta) && isPoint(tb)) {

            return true;

        }

        if (isLinear(ta) && isLinear(tb)) {

            return true;

        }

        if (isPolygonal(ta) && isPolygonal(tb)) {

            return true;

        }

        return false;

    }

    public void loadFromState(PersistentState state)

        throws PersistenceException {

        super.loadFromState(state);

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

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

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

        if (state.hasValue("backgroundSymbol")) {

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

        }

    }

    public void saveToState(PersistentState state) throws PersistenceException {

        super.saveToState(state);

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

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

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

        if (this.backgroundSymbol != null) {

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

        }

    }

    public static class RegisterPersistence implements Callable {

        public Object call() throws Exception {

            PersistenceManager manager = ToolsLocator.getPersistenceManager();

            if (manager

                .getDefinition(GRADUATED_SYMBOL_LEGEND_PERSISTENCE_DEFINITION_NAME) == null) {

                DynStruct definition =

                    manager

                        .addDefinition(

                            GraduatedSymbolsLegend.class,

                            GRADUATED_SYMBOL_LEGEND_PERSISTENCE_DEFINITION_NAME,

                            GRADUATED_SYMBOL_LEGEND_PERSISTENCE_DEFINITION_NAME

                                + " Persistence definition", null, null);

                definition.extend(

                    manager.getDefinition(

                        VectorialIntervalLegend.

                        VECTORIAL_INTERVAL_LEGEND_PERSISTENCE_DEFINITION_NAME));

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

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

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

                definition.addDynFieldObject("backgroundSymbol")

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

            }

            return Boolean.TRUE;

        }

    }

    public static class RegisterLegend implements Callable {

        public Object call() throws Exception {

            MapContextManager manager =

                MapContextLocator.getMapContextManager();

            manager.registerLegend(

                GRADUATED_SYMBOL_LEGEND_NAME,

                GraduatedSymbolsLegend.class);

            return Boolean.TRUE;

        }

    }

    public static IFillSymbol toFillSymbol(ISymbol sym) {

        if (sym instanceof IFillSymbol) {

            return (IFillSymbol) sym;

        } else if (sym instanceof IMarkerSymbol) {

            MarkerFillSymbol aux = new MarkerFillSymbol();

            aux.setMarker((IMarkerSymbol) sym);

            SimpleMarkerFillPropertiesStyle p = new SimpleMarkerFillPropertiesStyle();

            p.setFillStyle(SimpleMarkerFillPropertiesStyle.SINGLE_CENTERED_SYMBOL);

            aux.setMarkerFillProperties(p);

            return aux;

        } else {

            return null;

        }

    }

}

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

 */

/* CVS MESSAGES:

 *

 * $Id: GraduatedSymbols.java 16232 2007-11-09 13:36:35Z jdominguez $

 * $Log$

 * Revision 1.8  2007-09-19 15:44:44  jaume

 * new signal catched (legend error)

 *

 * Revision 1.7  2007/05/21 10:38:27  jaume

 * *** empty log message ***

 *

 * Revision 1.6  2007/05/17 09:32:37  jaume

 * *** empty log message ***

 *

 * Revision 1.5  2007/05/10 09:46:45  jaume

 * Refactored legend interface names

 *

 * Revision 1.4  2007/05/08 15:45:31  jaume

 * *** empty log message ***

 *

 * Revision 1.3  2007/03/21 08:03:03  jaume

 * refactored to use ISymbol instead of FSymbol

 *

 * Revision 1.2  2007/03/09 11:25:00  jaume

 * Advanced symbology (start committing)

 *

 * Revision 1.1.2.4  2007/02/21 07:35:14  jaume

 * *** empty log message ***

 *

 * Revision 1.1.2.3  2007/02/14 09:59:17  jaume

 * *** empty log message ***

 *

 * Revision 1.1.2.2  2007/02/13 16:19:19  jaume

 * graduated symbol legends (start commiting)

 *

 * Revision 1.1.2.1  2007/02/12 15:14:41  jaume

 * refactored interval legend and added graduated symbol legend

 *

 *

 */

package org.gvsig.symbology.gui.layerproperties;

import java.awt.Color;

import java.awt.Dimension;

import java.awt.FlowLayout;

import java.text.NumberFormat;

import java.util.ArrayList;

import java.util.List;

import javax.swing.BorderFactory;

import javax.swing.ImageIcon;

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.app.project.documents.view.legend.gui.SymbolTable;

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

import org.gvsig.fmap.mapcontext.exceptions.LegendLayerException;

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

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

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.swing.GridBagLayoutPanel;

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

import org.gvsig.i18n.Messages;

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

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

/**

 * Implements the interface that shows the information of a legend which

 * draws quantities using symbol size to show relative values.

 *

 * @author Pepe Vidal Salvador - jose.vidal.salvador@iver.es

 *

 */

public class GraduatedSymbolsPanel extends VectorialInterval implements ILegendPanel {

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

	private static final long serialVersionUID = -263195536343912694L;

	static final double DEFAULT_SYMBOL_MAX_SIZE = 7;

	private static final double DEFAULT_SYMBOL_MIN_SIZE = 1;

	private JNumberSpinner txtMinSize;

	private JNumberSpinner txtMaxSize;

	private JSymbolPreviewButton btnTemplate;

	private JSymbolPreviewButton btnBackground;

	private int shapeType;

	private GridBagLayoutPanel aux;

	private int templateShapeType = 0 ;

	private boolean showBackground = true;

	public GraduatedSymbolsPanel() {

		super();

		this.showBackground = true;

	}

	public GraduatedSymbolsPanel(boolean showBackground) {

		super();

		this.showBackground = showBackground;

	}

	@Override

	public JPanel getOptionPanel() {

		if (optionPanel == null) {

			optionPanel = new JPanel(new FlowLayout(FlowLayout.LEADING));

			optionPanel.setBorder(BorderFactory.

					createTitledBorder(null,

					    Messages.getText("symbol")));

			aux = new GridBagLayoutPanel();

			aux.addComponent(new JLabel(Messages.getText("size")));

			aux.addComponent(Messages.getText("from")+":",

					getTxtMinSize());

			aux.addComponent(Messages.getText("to")+":",

					getTxtMaxSize());

			aux.addComponent(Messages.getText("template"), getBtnTemplate());

			optionPanel.add(aux);

		}

		return optionPanel;

	}

	/**

	 * Adds the button that allows the user to select a background for the graduated symbol.

	 */

	private void getBackgroundPanel() {

		aux.addComponent(Messages.getText("background"), getBtnBackground());

	}

	/**

	 * Creates the JSymbolPreviewButton for the background of the graduated symbol.

	 */

	private JSymbolPreviewButton getBtnBackground() {

		if (btnBackground == null) {

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

			btnBackground.setPreferredSize(new Dimension(100, 35));

			ISymbol fillsym = MapContextLocator.getSymbolManager().createSymbol(

			    Geometry.TYPES.SURFACE, Color.ORANGE);

			btnBackground.setSymbol(fillsym);

		}

		return btnBackground;

	}

	/**

	 * Creates the JSymbolPreviewButton for the graduated symbol.

	 */

	private JSymbolPreviewButton getBtnTemplate() {

		if (btnTemplate == null) {

			templateShapeType =

			    GraduatedSymbolsLegend.isPolygonal(shapeType) ?

			        Geometry.TYPES.POINT : shapeType;

			btnTemplate = new JSymbolPreviewButton(templateShapeType);

			btnTemplate.setPreferredSize(new Dimension(100, 35));

		}

		return btnTemplate;

	}

	/**

	 * Creates the JIncrementalNumberField which is used to specify the maximum size of the

	 * graduated symbol

	 */

	private JNumberSpinner getTxtMaxSize() {

		if (txtMaxSize == null) {

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

		}

		return txtMaxSize;

	}

	/**

	 * Creates the JIncrementalNumberField which is used to specify the minimum size of the

	 * graduated symbol

	 */

	private JNumberSpinner getTxtMinSize() {

		if (txtMinSize == null) {

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

		}

		return txtMinSize;

	}

	@Override

	public void setData(FLayer lyr, ILegend legend) {

		this.layer = (FLyrVect) lyr;

		try {

            shapeType = this.layer.getGeometryType().getType();

        } catch (ReadException e) {

            logger.info("Unable to get shapetype while setting data", e);

            ApplicationLocator.getManager().messageDialog(

                Messages.getText("_Unable_to_set_legend"),

                Messages.getText("error"),

                JOptionPane.ERROR_MESSAGE);

        }

        templateShapeType =

            GraduatedSymbolsLegend.isPolygonal(shapeType) ?

                Geometry.TYPES.POINT : shapeType;

		getBtnTemplate().setShapeType(templateShapeType);

		if(showBackground){

			if(GraduatedSymbolsLegend.isPolygonal(shapeType) && btnBackground == null) {

				getBackgroundPanel();

				getBtnBackground().setShapeType(Geometry.TYPES.SURFACE);

			}

		}

		if (symbolTable != null)

			pnlCenter.remove(symbolTable);

		getDefaultSymbolPrev(templateShapeType);

		symbolTable = new SymbolTable(

		    this, SymbolTable.INTERVALS_TYPE, templateShapeType);

		pnlCenter.add(symbolTable);

		fillFieldNames();

		if (legend instanceof GraduatedSymbolsLegend) {

            auxLegend = (GraduatedSymbolsLegend) legend.cloneLegend();

			getChkDefaultvalues().setSelected(auxLegend.isUseDefaultSymbol());

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

			fillTableSkipDefault(auxLegend);

			getTxtMaxSize().setDouble(((GraduatedSymbolsLegend) auxLegend).getMaxSymbolSize());

			getTxtMinSize().setDouble(((GraduatedSymbolsLegend) auxLegend).getMinSymbolSize());

			if (auxLegend.getSymbols().length > 0){

				getBtnTemplate().setSymbol(((GraduatedSymbolsLegend) auxLegend).getSymbols()[auxLegend.getSymbols().length-1]);

			} else {

				getBtnTemplate().setSymbol(newSymbol(shapeType,

				    GraduatedSymbolsLegend.isLinear(shapeType) ? 3 : 10));

			}

			if(showBackground){

				if (GraduatedSymbolsLegend.isPolygonal(shapeType))

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

			}

			if (auxLegend.isUseDefaultSymbol())

				txtNumIntervals.setText(String.valueOf(auxLegend.getSymbols().length - 1));

			else

				txtNumIntervals.setText(String.valueOf(auxLegend.getSymbols().length));

		} else {

			// Si la capa viene con otro tipo de leyenda, creamos

			// una nueva del tipo que maneja este panel

			auxLegend = new GraduatedSymbolsLegend();

			getTxtMaxSize().setDouble(DEFAULT_SYMBOL_MAX_SIZE);

			getTxtMinSize().setDouble(DEFAULT_SYMBOL_MIN_SIZE);

			auxLegend.setDefaultSymbol(newSymbol(shapeType,

			    GraduatedSymbolsLegend.isLinear(shapeType) ? 3 : 10));

			getBtnTemplate().setSymbol(auxLegend.getDefaultSymbol());

			((GraduatedSymbolsLegend) auxLegend).setTemplateShapeType(templateShapeType);

		}

		cmbIntervalType.setSelectedIndex(auxLegend.getIntervalType());

		defaultSymbolPrev.setSymbol(auxLegend.getDefaultSymbol());

	}

	@Override

	public String getDescription() {

		return Messages.getText(

		    "draw_quantities_using_symbol_size_to_show_relative_values");

	}

	@Override

	public ILegend getLegend() {

	    GraduatedSymbolsLegend gsl =

		    new GraduatedSymbolsLegend((VectorialIntervalLegend) super.getLegend());

		double minSize = getTxtMinSize().getDouble();

		gsl.setMinSymbolSize(minSize);

		gsl.setMaxSymbolSize(getTxtMaxSize().getDouble());

        try {

            gsl.setShapeType(layer.getGeometryType().getType());

        } catch (ReadException e) {

            logger.info("Unable to get shapetype while getting legend", e);

            ApplicationLocator.getManager().messageDialog(

                Messages.getText("_Unable_to_get_legend"),

                Messages.getText("error"),

                JOptionPane.ERROR_MESSAGE);

        }

		ISymbol sym = getBtnTemplate().getSymbol();

		if (sym != null){

			gsl.setTemplateShapeType(sym.getSymbolType());

			gsl.setDefaultSymbol(sym);

		} else {

			gsl.setTemplateShapeType(templateShapeType);

		}

		gsl.useDefaultSymbol(getChkDefaultvalues().isSelected());

		if(defaultSymbolPrev.getSymbol() != null)

			gsl.setDefaultSymbol(defaultSymbolPrev.getSymbol());

		if (this.showBackground){

			if (GraduatedSymbolsLegend.isPolygonal(shapeType))

				gsl.setBackgroundSymbol(btnBackground.getSymbol());

		}

		return gsl;

	}

	@Override

	public ImageIcon getIcon() {

	    return

	        IconThemeHelper.getImageIcon("legend-overview-graduated-symbols");

	}

	@Override

	public Class getParentClass() {

		return Quantities.class;

	}

	@Override

	public String getTitle() {

		return Messages.getText("graduated_symbols");

	}

	@Override

	public JPanel getPanel() {

		return this;

	}

	@Override

	public Class getLegendClass() {

		return GraduatedSymbolsLegend.class;

	}

	@Override

	public boolean isSuitableFor(FLayer layer) {

		if ( super.isSuitableFor(layer)) {

			FLyrVect lVect = (FLyrVect) layer;

            try {

                return lVect.getGeometryType().getType()

                    != Geometry.TYPES.GEOMETRY;

            } catch (ReadException e) {

                ApplicationLocator.getManager().message(

                    Messages.getText("error_trying_to_access_to_the_layer"),

                    JOptionPane.ERROR_MESSAGE);

                return false;

            }

		}

		return false;

	}

	private ISymbol newSymbol(int st, double size) {

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

			ISymbol templateSymbol;

            if (GraduatedSymbolsLegend.isLinear(st)) {

                templateSymbol = new SimpleLineSymbol();

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

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

            } else {

                templateSymbol = new SimpleMarkerSymbol();

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

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

			}

			getBtnTemplate().setSymbol(templateSymbol);

			return newSymbol(st, size);

		} else {

			// clone symbol

			ISymbol mySymbol = null;

			try {

                mySymbol = (ISymbol) getBtnTemplate().getSymbol().clone();

            } catch (CloneNotSupportedException e) {

                ApplicationLocator.getManager().message(

                    Messages.getText("_Unable_to_get_symbol"),

                    JOptionPane.ERROR_MESSAGE);

                logger.info("Error: Could not clone symbol", e);

            }

			if (mySymbol instanceof ILineSymbol) {

				ILineSymbol lSym = (ILineSymbol) mySymbol;

				lSym.setLineWidth(size);

			}

			if (mySymbol instanceof IMarkerSymbol) {

				IMarkerSymbol mSym = (IMarkerSymbol) mySymbol;

				mSym.setSize(size);

				if (GraduatedSymbolsLegend.isPolygonal(st)) {

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

		}

	}

	@Override

	protected void fillTableValues() {

		symbolTable.removeAllItems();

		try {

		    IInterval[] arrayIntervalos = calculateIntervals();

			if (arrayIntervalos == null)

				return;

			IInterval interval;

			NumberFormat.getInstance().setMaximumFractionDigits(2);

			auxLegend.clear();

			float minSize = (float) getTxtMinSize().getDouble();

			float maxSize = (float) getTxtMaxSize().getDouble();

			ISymbol theSymbol;

			this.shapeType = layer.getGeometryType().getType();

			if (GraduatedSymbolsLegend.isPolygonal(this.shapeType)) {

			    this.templateShapeType = Geometry.TYPES.POINT;

			}

			MapContextManager mcm =

			    MapContextLocator.getMapContextManager();

			auxLegend = (IVectorialIntervalLegend)

			    mcm.createLegend(

			    IVectorialIntervalLegend.LEGEND_NAME);

			auxLegend.setShapeType(this.shapeType);

			auxLegend.setIntervalType(this.cmbIntervalType.getSelectedIndex());

			if (chkdefaultvalues.isSelected()) {

				auxLegend.getDefaultSymbol().setDescription("Default");

				auxLegend.addSymbol("Default",

				    mcm.getSymbolManager().createSymbol(

				        this.templateShapeType));

			}

			int symbolType;

			symbolType = layer.getGeometryType().getType();

			int numSymbols = 0;

			double step = (maxSize - minSize) / arrayIntervalos.length;

			double size = minSize;

			for (int k = 0; k < arrayIntervalos.length; k++) {

				interval = arrayIntervalos[k];

				theSymbol = newSymbol(symbolType, size);

				auxLegend.addSymbol(interval, theSymbol);

				numSymbols++;

				if (numSymbols > 100) {

					int resp = JOptionPane.showConfirmDialog(this,

					    Messages.getText("mas_de_100_simbolos"),

					    Messages.getText("quiere_continuar"),

					    JOptionPane.YES_NO_OPTION,

					    JOptionPane.WARNING_MESSAGE);

					if ((resp == JOptionPane.NO_OPTION) ||

							(resp == JOptionPane.DEFAULT_OPTION)) {

						return;

					}

				}

				theSymbol.setDescription(NumberFormat.getInstance().format(interval.getMin()) +

						" - " +

						NumberFormat.getInstance().format(interval.getMax()));

				size = size + step;

			} // for

			fillTableSkipDefault(auxLegend);

		} catch (ReadException re) {

		    logger.info("Error could_not_get_shape_type", re);

            ApplicationLocator.getManager().messageDialog(

                Messages.getText("could_not_get_shape_type"),

                Messages.getText("error"),

                JOptionPane.ERROR_MESSAGE);

		} catch (LegendLayerException lle) {

            logger.info("Error failed_computing_intervals", lle);

            ApplicationLocator.getManager().messageDialog(

                Messages.getText("failed_computing_intervals"),

                Messages.getText("error"),

                JOptionPane.ERROR_MESSAGE);

		}

		bDelAll.setEnabled(true);

		bDel.setEnabled(true);

	}

	public void setShowBackground(boolean sb){

		this.showBackground = sb;

	}

	public boolean getShowBackground(){

		return this.showBackground;

	}

    private void fillTableSkipDefault(IVectorialIntervalLegend 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]));

    }

}  //  @jve:decl-index=0:visual-constraint="10,10"

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

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

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

 * 

 * @author jldominguez

 *

 */

public class GraduatedSymbolsLibrary extends AbstractLibrary {

    public void doRegistration() {

        registerAsImplementationOf(GraduatedSymbolsLibrary.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-graduated-symbols", this);

        Caller caller = new DefaultCaller();

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

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

        /*

         * Do register of all

         */

        if( !caller.call() ) {

            throw new LibraryException(

                GraduatedSymbolsLibrary.class,

                caller.getExceptions());

        }

        LegendManager.addLegendPage(GraduatedSymbolsPanel.class);

    }

}

#Translations for language [it]

#Mon Sep 21 10:02:12 CEST 2009

a_default_symbol_will_be_used=Sar\u00e0 utilizzato un simbolo predefinito

above=Sopra

accept=Accetta

accessing_file_structure=Analizzo struttura dei file

add=Aggiungi

add_class=Aggiungi classe

add_expression=Aggiungi espressione

add_field=Agguingi campo

add_operator=Aggiungi operatore

add_text_area=Aggiungi campo di testo

all_features=Tutti gli elementi

all_supported_background_image_formats=Tutte le immagini di sfondo supportate

allow_label_overlapping=Permetti sovrapposizione delle etichette

always_circular=

always_horizontal=Sempre orizzontale

always_straight=Sempre dritto

angle=Angolo

anticlockwise=

apply_visual_correction_to_glyph_for_precise_size_and_position=Applica correzione visiva ai caratteri per dimensione e posizionamento precisi

arguments_added_to_a_costant=Argomento aggiunto a una costante

at_begin=All'inizio

at_best=Al meglio

at_end=Alla fine

at_fields=nei campi

background=

background_color=Colore sfondo

background_style=Stile sfondo

barchar3d_legend=

barchar3d_legend_desc=

barchart_3D=

below=Sotto

bitmap_and_svg_image_files=File immagine Bitmap e SVG

boolean_value=Valore boleano

browse=Sfoglia

buffered=Buffered

cancel=Cancella

cannot_apply_to_a_non_polygon_layer=Impossibile applicare a un Livello non poligonale

cannot_be_null=Non pu\u00f2 essere nullo

cannot_exist_two_label_classes_with_the_same_name=Non possono esistere due etichette con lo stesso nome

cannot_install_labeling_method=Impossibile installare il metodo di etichettatura

cant_draw_preview=Impossibile disegnare anteprima

change_location=Modifica posizione

character_marker=Marker carattere

character_marker_symbol=Simbolo marker carattere

choose_marker=Seleziona marker

circular=Circolare

class=Classe

classes=Classi

classifying_field_name_not_found=Campo di classificazione non trovato

clear=Pulisci

color=Colore\:

color_field=Campo colore

color_ramp=Scala colori

confirmation_dialog=Dialog di conferma

constant=Costante

correct_expression=Espressione corretta

could_not_get_shape_type=Impossibile individuare il tipo di geometria.

could_not_retreive_layer_field_names=

could_not_setup_legend=Impossibile configurare legenda

date_value=Valore della data

default=Default

define_classes_of_features_and_label_each_differently=Definire classi di elementi ed etichettatura indipendentemente

Defines_a_dot_density_symbol_based_on_a_field_value=Definisce un simbolo di densit\u00e0 di punti basato sul valore di un determinato campo

delete=Elimina

delete_class=Elimina classe

delete_filter_expression=Elimina espressione di filtro

densities=Densit\u00e0

depth_factor=

description=Descrizione

divided_by_0=Divisione per 0

dont_show_labels_when_zoomed=Non mostrare etichette quando zoomato

dot_density=Densit\u00e0 puntuale

dot_size=Dimensione del punto

dot_value=Valore del punto

draw_quantities_for_each_category=Rappresenta quantit\u00e0 per ogni categoria.

draw_quantities_using_symbol_size_to_show_exact_values=Rappresenta le quantit\u00e0 utilizzando le dimensioni del simbolo per mostrare i valori esatti.

draw_quantities_using_symbol_size_to_show_relative_values=Rappresenta le quantit\u00e0 utilizzando le dimensioni del simbolo per mostrare i valori relativi.

duplicate_labels=Etichette ripetute

edit_expression=Modifica espressione

Enable_layer_preview=Abilita anteprima del Livello

enter_new_name=Inserire il nuovo nome

error=Errore

error\ accessing\ to\ the\ layer=

error_coding_filter_query=Filtro con formato errato\: errore di codifica

error_trying_to_access_to_the_layer=Errore d'accesso al Livello

error_validating_filter_query=Errore di validazione query SQL

expression=Espressione

expression_creator=Creatore di espressioni per filtri

expressions=Espressioni

failed_acessing_files=

failed_applying_following_line_will_use_default_confg=FALLITA Applicazione dell'etichettatura seguendo la linea. Verr\u00e0 utilizzata la configurazione predefinita

failed_computing_intervals=FALLITO Calcolo intervalli

features=Elementi

field_number=Numero campo

fields=Campi

fields_exp=Campi

fill_color=Colore di riempimento

fill_properties=Propriet\u00e0 di riempimento

filter=Filtro

filtered_features=Elementi filtrati

fit_inside_polygon=Adatta all'interno del poligono

fit_on_text_area=Adatta all'area del testo

fixed_text_size=Dimensione fissa del testo

following_line=Seguendo la linea

font=Font

foreground_alpha=

format=Formato

from=Da\:

fuente=Font

GeneralLabeling.sample_text=

generating_intervals=Elaborazione intervalli

getting_layer_shape_type=Recupero tipologia forme dal Livello in corso

gradient_color=Colore gradiente

gradient_fill=Riempimento gradiente

gradient_fill_symbol=Simbolo del riempimento gradiente

graduated_symbols=Simboli graduati

grid=Griglia

high=Alto

horizontal=Orizzontale

ignore_zero_values=

in_beyond=Al di sotto

in_layer=nel Livello

in_the_middle=Nel mezzo

incompatible_types_to_calculate_the_normalization=

incorrect_expression=Espressione errata

intervals=Intervalli

invalid_filter_expression=

invalid_url=URL del server con formato errato

it_will_not_be_added=Non verr\u00e0 aggiunto

label-point-priority-help=Priorit\u00e0\: 0 \= Bloccato, 1 \= Massima, 3 \= Minima

label_class_properties=Propriet\u00e0 della classe etichetta

label_expression=Espressione di etichetta

label_expression_editor=Editor di espressioni d'etichetta

label_expression_help=

label_features_in_the_same_way=Etichettare tutti gli elementi nello stesso modo

label_features_in_this_class=Etichettare gli elementi in questa classe

label_only_when_selected=Etichettare solo quando l'elemento \u00e8 selezionato

label_priority=Priorit\u00e0 nell'etichettare

label_style_could_not_be_painted=

label_styles=Stile dell'etichetta

labeled_point=

labeling=Etichettato

labeling_field=Campo d'etichettatura

layer_name=Nome del layer

line=Linea

line_fill=Riempimento Linee

line_fill_symbol=Simbolo di riempimento linee

line_settings=Impostazioni Linea

lineal=Lineare

lines=Linee

location=Ubicazione

location_along_the_lines=Ubicazione lungo le linee

looks_like_too_low_value_for_this_field_may_cause_system_to_run_slow=Il valore per il punto appare troppo basso. E' possibile che il sistema risponda molto lentamente.

low=Bassa

malformed_or_empty_expression=Espressione nulla o incorretta

marker_fill=Riempimento dei marcatori

marker_fill_symbol=Simbolo di riempimento dei marcatori

marker_line=Linea dei marcatori

marker_line_symbol=Simbolo della linea dei marcatori

mas_de_100_simbolos=Pi\u00fa di 100 simboli non apportano informazioni al piano

max_scale=Scala massima

medium=Mezzo

method=Operazione

min_scale=Scala min

minimum_angle_to_draw=

modify_filter_expression=Modifica l'espressione di filtro

move_down=Sposta in gi\u00f9

move_up=Muovi in alto

name=Nome

names_and_types_count_are_disctint=Numero dei campi e numero delle tipologia di campo distinte.

new_filter_expression=Nuova espressione di filtro

no=No

no_expression_defined=Espressione non definita

no_style=Senza stile

no_symbol_especified=Simbolo non specificato

none=Nessuno

normalization=Normalizzazione

not_save_empty_legend=Legende vuote non verranno salvate.

numeric_value=Valore numerico

offset=Spostamento

offset_label=Sposta etichetta

offset_labels_horizontally=Sposta etichette orizzontalmente attorno al punto

offset_labels_on_top_of_the_points=Posiziona etichette sui punti

on_the_line=Sulla linea

operators=Operatori

options=Opzioni

orientation=Orientazione

orientation_system=Sistema di orientamento

out_beyond=Out beyond

outline=Bordo

outline_opacity=Trasparenza bordo

outline_width=Larghezza bordo

page=Pagina

parallel=Parallela

pattern=Modello

percentage=Percentuale

perpedicular=Perpendicolare

picture_file=File immagine

picture_fill=Riempimento immagine

picture_fill_symbol=Motivo di riempimento immagine

picture_line_symbol=Motivo della linea dell'immagine

picture_marker=Marcatore dell'immagine

picture_marker_symbol=Simbolo del marcatore dell'immagine

pie_properties=

piechart_3D=

piechart_3D_legend_desc=

place_one_label_per_feature=Posiziona un'etichetta per elemento

place_one_label_per_feature_part=Posiziona un'etichetta per ciascuna parte dell'elemento

placement=Collocazione

placement_priorities_selector=Selettore di priorit\u00e0 di collocazione

placement_properties=Propriet\u00e0 di collocazione

point_settings=Configurazione del punto

points=Punti

polygon=Poligono

polygon_settings=Configurazione poligono

position=Posizione

prefer_top_right_all_allowed=Preferibilmente all'angolo alto a destra, ma qualunque posizione ammessa

preview=Anteprima

preview_not_available=Anteprima non disponibile

properties=Propriet\u00e1

proportional_symbols=Simboli proporzionali

quantity_by_category=Quantit\u00e0 per categoria

quiere_continuar=Sei sicuro di voler continuare?

Quitar=Rimuovi

Quitar_todos=Elimina tutto

random=Casuale

recovering_recordset=Recupero recordset in corso.

rectangular=Rettangolare

remane_class=Rinomina classe

remove=Rimuovi

remove_duplicate_labels=Elimina etichette doppie

resto_valores=Resto dei valori

scale=Scala

scale_range_window_title=Intervallo scale

select=Seleziona

select_one_row=Seleziona una riga

selection_picture_file=Immagine di selezione

separation=Separazione

set_forbidden_precedence=Imposta priorit\u00e0 nulla

set_high_precedence=Imposta alta priorit\u00e0

set_low_precedence=Imposta bassa priorit\u00e0

set_normal_precedence=Imposta priorit\u00e0 normale

shows_the_elements_of_the_layer_depending_on_the_value_of_a_filter_expression=Mostra gli elementi del Livello in funzione di una determinata espressione di selezione

size=Dimensione

SLD_grammar=Grammatica SLD

some_arguments_are_incorrect=Alcuni argomenti errati

specify_the_range_of_scales_at_which_labels_will_be_shown=Specificare l'intervallo delle scale nel quale le etichette saranno mostrate

SQL_query=Query SQL

statistics=Statistica

string_value=Valore stringa

style=Stile

style_selector=Selettore di stili

symbol=Simbolo

symbol_field=Campo del simbolo graduato

symbol_shapetype_mismatch=

syntax_error=Errore di sintassi

template=Template

text=Testo

text_field=Testo

text_fields=Campi di testo

text_string=Testo

text_symbol=Simbolo di testo

the\ size\ for\ the\ symbol\ is\ equal\ to\ NaN\ =

the_number_or_arguments_is_incorrect=Numero di argomenti non corretto

the_result_is_not_a_boolean_value=Il risultato non \u00e8 booleano

to=A\:

URL=

use_outline=Utilizza bordo

use_the_same_scale_range_as_the_feature_layer=Utilizza lo stesso intervallo di scale dell'elemento del Livello

user_defined_labels=Etichette definite dall'utente

usupported_layer_type=Tipologia di Livello non supportata

value=Valore

value_fields=Campi dei valori

variation_by=Variazione per

verify=Verifica

visible=Visibile

visualization=Visualizzazione

warning=Attenzione

width=Larghezza

x_offset=Spostamento X

y_offset=Spostamento in Y

yes=Si

#Translations for language [es]

#Mon Sep 21 10:02:12 CEST 2009

a_default_symbol_will_be_used=Ser\u00e1 utilizado un s\u00edmbolo por defecto

above=Arriba

accept=Aceptar

accessing_file_structure=Accediendo a la estructura del fichero

add=A\u00f1adir

add_class=A\u00f1adir clase

add_expression=A\u00f1adir Expresi\u00f3n

add_field=A\u00f1adir campo

add_operator=A\u00f1adir Operador

add_text_area=A\u00f1adir campo de texto

all_features=Todos los elementos

all_supported_background_image_formats=Todos los formatos de imagen de fondo soportados

allow_label_overlapping=Permitir superposici\u00f3n de las etiquetas

always_circular=

always_horizontal=Siempre horizontal

always_straight=Siempre recto

angle=\u00c1ngulo

anticlockwise=

apply_visual_correction_to_glyph_for_precise_size_and_position=Aplicar correcci\u00f3n visual al car\u00e1cter para precisi\u00f3n en tama\u00f1o y posici\u00f3n.

arguments_added_to_a_costant=Argumento a\u00f1adido a una constante

at_begin=Al principio

at_best=En la mejor

at_end=Al final

at_field=en el campo

at_fields=en los campos

background=Fondo

background_color=Color de fondo

background_style=Estilo de fondo

barchar3d_legend=

barchar3d_legend_desc=

barchart_3D=

below=Abajo