Application: gvSIG desktop » gvSIG legends: base legends

<!--

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

bitmap_and_svg_image_files=Im\u00e1genes SVG y de mapa de bits

boolean_value=Valor booleano

browse=Examinar

buffered=Forma del pol\u00edgono

cancel=Cancelar

cannot_apply_to_a_non_polygon_layer=No puede aplicarse a una capa no poligonal

cannot_be_null=No puede ser nulo

cannot_exist_two_label_classes_with_the_same_name=No pueden existir dos etiquetas con el mismo nombre

cannot_install_labeling_method=No se puede instalar el m\u00e9todo de etiquetado

cant_draw_preview=No se puede dibujar la previsualizaci\u00f3n

Capa=Capa

change_location=Cambiar ubicaci\u00f3n

character_marker=Marcador de car\u00e1cter

character_marker_symbol=S\u00edmbolo de Marcador de car\u00e1cter

choose_marker=Seleccionar marcador

circular=Circular

class=Clase

classes=Clases

classifying_field_name_not_found=Campo de clasificaci\u00f3n no encontrado

clear=Limpiar

color=Color\:

color_field=Campo de colores

color_ramp=Rampa de color

confirmation_dialog=Di\u00e1logo de confirmaci\u00f3n

constant=constante

correct_expression=Expresion correcta

could_not_get_shape_type=No se pudo obtener el tipo de geometr\u00eda.

could_not_restore_color_field=No se pudo recuperar el campo para el color del texto.

could_not_restore_rotation_field=No se pudo recuperar el campo para la rotaci\u00f3n del texto.

could_not_restore_text_field=No se pudo recuperar el campo del texto.

could_not_restore_text_height_field=No se pudo recuperar el campo para la altura del texto.

could_not_retreive_layer_field_names=

could_not_setup_legend=No se puede cargar la leyenda

date_value=Valor fecha

default=Por defecto

define_classes_of_features_and_label_each_differently=Definir diferentes clases de entidades y etiquetarlas de manera diferente

Defines_a_dot_density_symbol_based_on_a_field_value=Define una leyenda de densidad de puntos basada en el valor de un determinado campo.

delete=Eliminar

delete_class=Eliminar clase

delete_filter_expression=Eliminar expresi\u00f3n de filtrado

densities=Densidades

depth_factor=

description=Descripci\u00f3n

divided_by_0=Divisi\u00f3n por 0

dont_show_labels_when_zoomed=No mostrar las etiquetas cuando se haga zoom

dot_density=Densidad de puntos

dot_size=Tama\u00f1o de punto

dot_value=Valor del punto

draw_quantities_for_each_category=Representa cantidades para cada categor\u00eda.

draw_quantities_using_symbol_size_to_show_exact_values=Representa cantidades a trav\u00e9s del tama\u00f1o del s\u00edmbolo mostrando valores exactos

draw_quantities_using_symbol_size_to_show_relative_values=Representa cantidades mediante el tama\u00f1o de un s\u00edmbolo mostrando valores relativos.

duplicate_labels=Etiquetas repetidas

edit_expression=Editar expresi\u00f3n

enable_labeling=Habilitar etiquetado

Enable_layer_preview=Activar previsualizaci\u00f3n de capa

enter_new_name=Introduzca el nuevo nombre

error=Error

error\ accessing\ to\ the\ layer=

error_coding_filter_query=Error codificando la consulta SQL

error_trying_to_access_to_the_layer=Error intentando acceder a la capa

error_validating_filter_query=Error validando la consulta SQL

Etiquetados=Etiquetados

expression=Expresi\u00f3n

expression_creator=Crear expresi\u00f3n de filtrado

expressions=Expresiones

failed_acessing_files=

failed_applying_following_line_will_use_default_confg=Fallo aplicando el etiquetado siguiendo la l\u00ednea. Se utilizar\u00e1 la configuraci\u00f3n por defecto

failed_computing_intervals=Fallo calculando intervalos

false=Falso

features=Objetos

field_number=N\u00famero de campo

field_to_be_labeled=Campo a etiquetar

fields=Campos

fields_exp=Campos

fill_color=Color de relleno

fill_properties=Propiedades de relleno

filter=Filtro

filtered_features=Elementos filtrados

fit_inside_polygon=Acoplar dentro del pol\u00edgono

fit_on_text_area=Ajustar al area de texto

fixed_color=Color fijo

fixed_height=Tama\u00f1o fijo

fixed_text_size=Tama\u00f1o fijo del texto

following_line=Siguiendo la l\u00ednea

font=Fuente

foreground_alpha=

format=Formato

from=Desde

fuente=Fuente

general=General

GeneralLabeling.sample_text=

generating_intervals=Generando Intervalos

getting_layer_shape_type=Obteniendo el tipo de shape

gradient_color=Color gradiente

gradient_fill=Relleno gradiente

gradient_fill_symbol=S\u00edmbolo de relleno gradiente

graduated_symbols=S\u00edmbolos graduados

grid=Malla

high=Alta

horizontal=Horizontal

ignore_zero_values=

in_beyond=Por debajo de

in_layer=en capa

in_the_middle=En mitad

in_the_world=en el mundo

incompatible_types_to_calculate_the_normalization=

incorrect_expression=Expresi\u00f3n incorrecta

intervals=Intervalos

invalid_filter_expression=

invalid_url=Localizador de servidor WFS con formato no v\u00e1lido.

it_will_not_be_added=No ser\u00e1 a\u00f1adida

label-point-priority-help=Prioridad\: 0 \= Bloqueado, 1 \= M\u00e1s alta, 3 \= M\u00e1s baja

label_attributes_defined_in_table=Atributos de la etiqueta definidos en tabla

label_class_properties=Propiedades de la clase de etiquetado

label_expression=Expresi\u00f3n de etiquetado

label_expression_editor=Editor de expresiones de etiqueta

label_expression_help=

label_features_in_the_same_way=Etiquetar todas las entidades de la misma manera

label_features_in_this_class=Etiquetar entidades dentro de esta clase

label_only_when_selected=Etiquetar solamente cuando sus entidades est\u00e9n seleccionadas

label_priority=Prioridad en el etiquetado

label_style_could_not_be_painted=

label_styles=Estilos de etiqueta

labeled_point=

labeling=Etiquetado

labeling_field=Campo de etiquetado

layer_name=Nombre de la capa

layer_Selector=Selector de capa

line=L\u00ednea

line_fill=Relleno l\u00edneas

line_fill_symbol=S\u00edmbolo de relleno de l\u00edneas

line_settings=Configuraci\u00f3n de l\u00ednea

lineal=Lineal

lines=L\u00edneas

location=Ubicaci\u00f3n

location_along_the_lines=Ubicaci\u00f3n a lo largo de las l\u00edneas

looks_like_too_low_value_for_this_field_may_cause_system_to_run_slow=Parece un valor para el punto demasiado bajo, puede causar que el sistema responda muy lentamente.

low=Baja

malformed_or_empty_expression=Expresi\u00f3n vac\u00eda o err\u00f3nea

marker_fill=Relleno de marcadores

marker_fill_symbol=S\u00edmbolo de Relleno de marcadores

marker_line=L\u00ednea de marcadores

marker_line_symbol=S\u00edmbolo de L\u00ednea de marcadores

mas_de_100_simbolos=M\u00e1s 100 de s\u00edmbolos no suelen aportar informaci\u00f3n en un plano.

max_scale=Escala m\u00e1x

medium=Media

method=Operaci\u00f3n

min_scale=Escala m\u00edn

minimum_angle_to_draw=

modify_filter_expression=Modificar expresi\u00f3n de filtrado

move_down=Bajar

move_up=Subir

name=Nombre

names_and_types_count_are_disctint=N\u00famero de campos y n\u00famero de tipos de campo distintos

new_filter_expression=Nueva expresi\u00f3n de filtrado

no=No

no_expression_defined=Expresion no definida

no_style=Sin estilo

no_symbol_especified=S\u00edmbolo no especificado

none=None

normalization=Normalizaci\u00f3n

not_save_empty_legend=Leyenda vac\u00eda no se guardar\u00e1.

numeric_or_boolean_value=valor num\u00e9rico o boolean

numeric_value=Valor num\u00e9rico

offset=Desplazamiento

offset_label=Desplazar etiqueta

offset_labels_horizontally=Desplazar etiquetas horizontalmente alrededor del punto.

offset_labels_on_top_of_the_points=Situar etiquetas sobre los puntos.

on_the_line=Sobre la l\u00ednea

operand=operando

operation_not_allowed_for_SingleLabelingStrategy=Operaci\u00f3n no permitida para la estrategia de etiquetado simple

operators=Operadores

options=Opciones

orientation=Orientaci\u00f3n

orientation_system=Orientaci\u00f3n

out_beyond=Por encima de

outline=Borde

outline_opacity=Opacidad del borde

outline_width=Ancho del borde

page=P\u00e1gina

parallel=Paralela

pattern=Patr\u00f3n

percentage=Porcentaje

perpedicular=Perpendicular

picture_file=Fichero imagen

picture_fill=Relleno de imagen

picture_fill_symbol=S\u00edmbolo de Relleno de imagen

picture_line_symbol=S\u00edmbolo de L\u00ednea de imagen

picture_marker=Marcador de imagen

picture_marker_symbol=S\u00edmbolo de marcador de imagen

pie_properties=

piechart_3D=

piechart_3D_legend_desc=

place_one_label_per_feature=Situar \u00fanicamente una etiqueta por entidad

place_one_label_per_feature_part=Situar una etiqueta por cada parte de la entidad

placement=Colocaci\u00f3n

placement_priorities_selector=Selector de prioridades de colocaci\u00f3n

placement_properties=Propiedades de colocaci\u00f3n

point_settings=Configuraci\u00f3n de punto

points=Puntos

polygon=Pol\u00edgono

polygon_settings=Configuraci\u00f3n de pol\u00edgono

position=Posici\u00f3n

prefer_top_right_all_allowed=Preferiblemente arriba a la derecha, pero permitiendo cualquier posici\u00f3n

preview=Previsualizaci\u00f3n

preview_not_available=Vista previa no disponible

properties=Propiedades

proportional_symbols=S\u00edmbolos proporcionales

quantity_by_category=Cantidades por categor\u00eda

quiere_continuar=\u00bfEst\u00e1 seguro de que quiere continuar?

Quitar=Quitar

Quitar_todos=Quitar todos

random=Aleatorio

recovering_recordset=Recuperando recordset.

rectangular=Rectangular

remane_class=Renombrar clase

remove=Quitar

remove_duplicate_labels=Eliminar etiquetas repetidas

resto_valores=Resto de valores

rotation_height=Rotaci\u00f3n

scale=Escalar

scale_range_window_title=Rango de escalas

select=Seleccionar

select_one_row=Selecciona una fila

selection_picture_file=Imagen de selecci\u00f3n

separation=Separaci\u00f3n

set_forbidden_precedence=Establecer precedencia nula

set_high_precedence=Establecer m\u00e1xima precedencia

set_low_precedence=Establecer baja precedencia

set_normal_precedence=Establecer precedencia normal

shows_the_elements_of_the_layer_depending_on_the_value_of_a_filter_expression=Muestra los elementos de la capa en funci\u00f3n de una determinada expresi\u00f3n de filtrado

simple_marker=Marcador simple

single_labeling=Etiquetado simple

single_labeling_setup=Configuraci\u00f3n del etiquetado simple

size=Tama\u00f1o

SLD_grammar=Gram\u00e1tica SLD

some_arguments_are_incorrect=Algunos argumentos son incorrectos

specify_the_range_of_scales_at_which_labels_will_be_shown=Especificar el rango de escalas en el que las etiquetas ser\u00e1n mostradas

SQL_query=Sentencia SQL

statistics=Estad\u00edsticas

string_value=Valor String

style=Estilo

style_selector=Selector de estilos

symbol=S\u00edmbolo

symbol_field=Campo de s\u00edmbolo graduado

symbol_shapetype_mismatch=

syntax_error=Error de sintaxis

template=Plantilla

text=Texto

text_field=Texto

text_fields=Campos de texto

text_height_field=Altura del texto

text_string=Texto

text_symbol=S\u00edmbolo de texto

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

the_number_or_arguments_is_incorrect=El n\u00famero de argumentos no es correcto

the_result_is_not_a_boolean_value=El resultado no es un boolean

to=Hasta

Tools_Select=Selecci\u00f3n de herramientas

true=Verdadero

units=Unidades

URL=

use_default_symbol=S\u00edmbolo por defecto

use_outline=Usar borde

use_the_same_scale_range_as_the_feature_layer=Usar el mismo rango de escalas que el elemento de la capa

user_defined_labels=Etiquetas definidas por el usuario

usupported_layer_type=Tipo de capa no soportado

value=Valor

value_fields=Campos de valores

variation_by=Variaci\u00f3n por

verify=Verificar

visible=Visible

visualization=Visualizaci\u00f3n

warning=Aviso

width=Ancho

x_offset=Desplazamiento en X

y_offset=Desplazamiento en Y

yes=Si

_Unable_to_clone_symbol=No se pudo clonar s?mbolo

_Error_while_getting_fields=Error obteniendo campos

_Unable_to_set_legend=No se pudo asociar leyenda

_Unable_to_get_legend=No se pudo crear leyenda

_Unable_to_get_symbol=No se pudo crear s?mbolo