Application: gvSIG desktop » gvSIG legends: base legends

#Thu Aug 04 11:53:34 CEST 2016

buildNumber=39

<!--

    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.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) {

        if (ty == Geometry.TYPES.MULTISURFACE

            || ty == Geometry.TYPES.SURFACE

            ) {

            return true;

        } else {

            return false;

        }

    }

    public static boolean isLinear(int ty) {

        if (ty == Geometry.TYPES.CIRCLE

            || ty == Geometry.TYPES.ARC

            || ty == Geometry.TYPES.CURVE

            || ty == Geometry.TYPES.ELLIPSE

            || ty == Geometry.TYPES.ELLIPTICARC

            || ty == Geometry.TYPES.SPLINE

            || ty == Geometry.TYPES.MULTICURVE

            ) {

            return true;

        } else {

            return false;

        }

    }

    public static boolean isPoint(int ty) {

        if (ty == Geometry.TYPES.POINT

            || ty == Geometry.TYPES.MULTIPOINT

            ) {

            return true;

        } else {

            return false;

        }

    }

    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 = null;

			if (GraduatedSymbolsLegend.isPoint(st)

			    || GraduatedSymbolsLegend.isPolygonal(st)) {

                templateSymbol = new SimpleMarkerSymbol();

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

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

			} else {

	            if (GraduatedSymbolsLegend.isLinear(st)) {

	                templateSymbol = new SimpleLineSymbol();

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

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

	            } else {

	                ApplicationLocator.getManager().message(

	                    Messages.getText("usupported_layer_type"),

	                    JOptionPane.ERROR_MESSAGE);

	                logger.info("Error: Unknown symbol type");

	            }

			}

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

    }

}

<?xml version="1.0" encoding="ISO-8859-1"?>

<plugin-config>

	<libraries library-dir="lib/"/>

	<depends plugin-name="org.gvsig.app.mainplugin"/>

	<resourceBundle name="text"/>

	<extensions>

	   <extension class-name="org.gvsig.andami.LibraryExtension" active="false"/>

	</extensions>

</plugin-config>

#Translations for language [pt_BR]

#Mon Sep 21 10:02:12 CEST 2009

a_default_symbol_will_be_used=S\u00edmbolo utilizado por padr\u00e3o.

above=Acima

accept=Aceitar

accessing_file_structure=Acessando estrutura do arquivo

add=Adicionar

add_class=Adicionar classe

add_expression=Adicionar express\u00e3o

add_field=Adicionar campo

add_operator=Adicionar operador

add_text_area=Adicionar campo de texto

all_features=Todas as caracter\u00edsticas

all_supported_background_image_formats=Todos os formatos de imagem suportados

allow_label_overlapping=Permitir sobreposi\u00e7\u00e3o de r\u00f3tulos

always_circular=

always_horizontal=Sempre horizontal

always_straight=Sempre reto

angle=\u00c2ngulo

anticlockwise=

apply_visual_correction_to_glyph_for_precise_size_and_position=Aplique a corre\u00e7\u00e3o visual para ter precis\u00e3o no tamanho e posi\u00e7\u00e3o 

arguments_added_to_a_costant=Argumento inserido na mesma constante.

at_begin=Ao principio

at_best=Ao melhor

at_end=Ao final

at_fields=nos campos

background=

background_color=Cor de fundo

background_style=Estilo de fundo

barchar3d_legend=

barchar3d_legend_desc=

barchart_3D=

below=Abaixo

bitmap_and_svg_image_files=Arquivos de imagem Bitmaps e SVG

boolean_value=Valor booleano

browse=Procurar

buffered=Forma do pol\u00edgono

cancel=Cancelar

cannot_apply_to_a_non_polygon_layer=N\u00e3o \u00e9 possivel aplicar em um plano de informa\u00e7\u00e3o que n\u00e3o seja poligonal

cannot_be_null=N\u00e3o pode ser nulo

cannot_exist_two_label_classes_with_the_same_name=N\u00e3o pode existir duas etiquetas com o mesmo nome

cannot_install_labeling_method=N\u00e3o \u00e9 possivel instalar o m\u00e9todo de etiqueta

cant_draw_preview=N\u00e3o \u00e9 possivel visualizar

change_location=Alterar localiza\u00e7\u00e3o

character_marker=Marcador de car\u00e1cter

character_marker_symbol=S\u00edmbolo do Marcador de car\u00e1cter

choose_marker=Selecionar marcador

circular=Circular

class=Classe

classes=Classes

classifying_field_name_not_found=Campo de classifica\u00e7\u00e3o n\u00e3o encontrado

clear=Limpar

color=Cor\:

color_field=Campo de cores

color_ramp=Rampa de cor

confirmation_dialog=Di\u00e1logo de configura\u00e7\u00e3o

constant=constante

correct_expression=Express\u00e3o correta

could_not_get_shape_type=N\u00e3o \u00e9 possivel obter o tipo de geometria.

could_not_retreive_layer_field_names=

could_not_setup_legend=N\u00e3o \u00e9 poss\u00edvel carregar a legenda.

date_value=Valor da data

default=Padr\u00e3o

define_classes_of_features_and_label_each_differently=Definir diferentes classes de entidades e etiqueta-las de maneira diferente

Defines_a_dot_density_symbol_based_on_a_field_value=Define uma lejenda de densidade de pontos baseada no valor de um determinado campo.

delete=Apagar

delete_class=Apagar classe

delete_filter_expression=Apagar expre\u00e7\u00e3o filtrada

densities=Densidades

depth_factor=

description=Descri\u00e7\u00e3o

divided_by_0=Divis\u00e3o por 0

dont_show_labels_when_zoomed=N\u00e3o mostrar as etiquetas quando dar o zoom

dot_density=Densidade de pontos

dot_size=Tamanho do ponto

dot_value=Valor do ponto

draw_quantities_for_each_category=Representar quantidades para cada categoria.

draw_quantities_using_symbol_size_to_show_exact_values=Representa quantidade atrav\u00e9s do tamanho do s\u00edmbolo mostrando valores exatos.

draw_quantities_using_symbol_size_to_show_relative_values=Representar quantidades mediante o tamanho de um s\u00edmbolo mostrando valores relativos.

duplicate_labels=Etiquetas repetidas

edit_expression=Editar express\u00e3o

Enable_layer_preview=Ativar pr\u00e9-visualiza\u00e7\u00e3o do plano de informa\u00e7\u00e3o

enter_new_name=Entre com o novo nome

error=Erro

error\ accessing\ to\ the\ layer=

error_coding_filter_query=Erro codificando a consulta SQL.

error_trying_to_access_to_the_layer=Erro tentando acessar o plano de informa\u00e7\u00e3o.

error_validating_filter_query=Erro validando a consulta SQL

expression=Express\u00e3o

expression_creator=Criador de express\u00e3o

expressions=Express\u00f5es

failed_acessing_files=

failed_applying_following_line_will_use_default_confg=Falha aplicando etiqueta seguindo a linha. Foi utilizada a configura\u00e7\u00e3o padr\u00e3o.

failed_computing_intervals=Falha calculando intervalos.

features=Objetos

field_number=N\u00famero do campo

fields=Campos

fields_exp=Campos

fill_color=Cor de preenchimento

fill_properties=Propriedades do preenchimento

filter=Filtro

filtered_features=Elementos filtrados

fit_inside_polygon=Acoplar dentro do pol\u00edgono

fit_on_text_area=Ajustar a \u00e1rea do texto

fixed_text_size=Tamanho fixo do texto

following_line=Seguindo a linha

font=Fontes

foreground_alpha=

format=Formato

from=De

fuente=Fonte

GeneralLabeling.sample_text=

generating_intervals=Gerando intervalos

getting_layer_shape_type=Obtendo o tipo de shape

gradient_color=Cor gradiente

gradient_fill=Preenchimento gradiente

gradient_fill_symbol=S\u00edmbolo de preenchimento gradiente

graduated_symbols=S\u00edmbolos graduados

grid=Grade

high=Alta

horizontal=Horizontal

ignore_zero_values=

in_beyond=Por baixo de

in_layer=no plano de informa\u00e7\u00e3o

in_the_middle=No meio

incompatible_types_to_calculate_the_normalization=

incorrect_expression=Express\u00e3o incorreta

intervals=Intervalos

invalid_filter_expression=

invalid_url=Localizador de servidor WFS com formato inv\u00e1lido

it_will_not_be_added=N\u00e3o ser\u00e1 inser\u00edda.

label-point-priority-help=Prioridade\: 0 \= Bloqueado, 1 \= Mais alta, 3 \= Mais baixa

label_class_properties=Propriedade da classe de etiquetas

label_expression=Express\u00e3o de etiquetas

label_expression_editor=Editor de express\u00e3o de etiqueta

label_expression_help=

label_features_in_the_same_way=Etiquetar todas as entidades da mesma maneira

label_features_in_this_class=Etiquetar entidades dentro desta classe

label_only_when_selected=Etiquetar somente quando suas entidades estejam selecioandas

label_priority=Prioridade da etiqueta

label_style_could_not_be_painted=

label_styles=Estilo de etiqueta

labeled_point=

labeling=Etiquetando

labeling_field=Campo de etiquetado

layer_name=Nome do Plano de informa\u00e7\u00e3o

line=Linha

line_fill=Preenchimento da linha

line_fill_symbol=S\u00edmbolo de preenchimento da linha

line_settings=Configura\u00e7\u00e3o da linha

lineal=Linear

lines=Linhas

location=Localiza\u00e7\u00e3o

location_along_the_lines=Localizador de acordo com as linhas

looks_like_too_low_value_for_this_field_may_cause_system_to_run_slow=Parece um valor para o ponto muito baixo, pode ocorrer que o sistema responda lentamente.

low=Baixo

malformed_or_empty_expression=Express\u00e3o vazia ou errada

marker_fill=Preenchimento de marcadores

marker_fill_symbol=S\u00edmbolo de preenchimento de marcadores

marker_line=Linah de marcadores.

marker_line_symbol=S\u00edmbolo de linha de marcadores.

mas_de_100_simbolos=Mais de 100 s\u00edmbolos n\u00e3o contribuem para uma clara informa\u00e7\u00e3o de um mapa.

max_scale=Escala m\u00e1xima

medium=M\u00e9dia

method=Opera\u00e7\u00e3o

min_scale=Escala m\u00ednima

minimum_angle_to_draw=

modify_filter_expression=Modificar filtro de express\u00e3o 

move_down=Mover para cima.

move_up=Subir

name=Nome

names_and_types_count_are_disctint=N\u00famero de campos e n\u00famero de tipos de campos distintos

new_filter_expression=Novo filtro de express\u00e3o

no=N\u00e3o

no_expression_defined=Express\u00e3o n\u00e3o definida

no_style=Sem est\u00edlo

no_symbol_especified=S\u00edmbolo n\u00e3o especificado

none=Nenhum

normalization=Normaliza\u00e7\u00e3o

not_save_empty_legend=Legenda vaz\u00eda n\u00e3o ser\u00e1 salva.

numeric_value=Valor num\u00e9rico

offset=Deslocamento

offset_label=Deslocar etiqueta

offset_labels_horizontally=Deslocar etiquetas horizontalmente ao redor do ponto

offset_labels_on_top_of_the_points=Situar etiqueta sobre os pontos.

on_the_line=Sobre a linha

operators=Operadores

options=Op\u00e7\u00f5es

orientation=Orienta\u00e7\u00e3o

orientation_system=Sistema de orienta\u00e7\u00e3o

out_beyond=Por cima de

outline=Borda

outline_opacity=Opacidade da borda

outline_width=Largura da borda

page=P\u00e1gina

parallel=Paralela

pattern=Padr\u00e3o

percentage=Porcentagem

perpedicular=Perpendicular

picture_file=Arquivo de imagem

picture_fill=Preencher imagem

picture_fill_symbol=S\u00edmbolo de preenchimento de imagem

picture_line_symbol=S\u00edmbolo de linha de imagem

picture_marker=Marcador de imagem

picture_marker_symbol=S\u00edmbolo de marcador de imagem

pie_properties=

piechart_3D=

piechart_3D_legend_desc=

place_one_label_per_feature=Situar unicamente uma etiqueta por entidade

place_one_label_per_feature_part=Situar uma etiqueta a cada parte da entidade

placement=Coloca\u00e7\u00e3o

placement_priorities_selector=Seletor de propriedades de coloca\u00e7\u00e3o

placement_properties=Propriedades de coloca\u00e7\u00e3o

point_settings=Configura\u00e7\u00e3o de ponto

points=Pontos

polygon=Pol\u00edgono

polygon_settings=Configura\u00e7\u00e3o do pol\u00edgono

position=Posi\u00e7\u00e3o

prefer_top_right_all_allowed=Preferencialmente encima a direita, por\u00e9m permitindo qualquer posi\u00e7\u00e3o

preview=Previsualiza\u00e7\u00e3o

preview_not_available=Pr\u00e9visualiza\u00e7\u00e3o n\u00e3o dispon\u00edvel

properties=Propriedades

proportional_symbols=S\u00edmbolos proporcionais

quantity_by_category=Quantidades por categoria

quiere_continuar=Tem certeza de que quer continuar?

Quitar=Remover

Quitar_todos=Remover tudo

random=Aleat\u00f3rio

recovering_recordset=Recuperando recordset

rectangular=Ret\u00e2ngular

remane_class=Renomear classe

remove=Remover

remove_duplicate_labels=Apagar etiquetas repetidas

resto_valores=Resto de valores

scale=Escala

scale_range_window_title=Gama de escalas

select=Selecioanr

select_one_row=Selecione uma linha

selection_picture_file=Imagem de sele\u00e7\u00e3o

separation=Separa\u00e7\u00e3o

set_forbidden_precedence=Estabelecer preced\u00eancia nula

set_high_precedence=Estabelecer m\u00e1xima preced\u00eancia

set_low_precedence=Estabelecer baixa prioridade

set_normal_precedence=Estabelecer proced\u00eancia normal

shows_the_elements_of_the_layer_depending_on_the_value_of_a_filter_expression=Mostra os elementos do plano de informa\u00e7\u00e3o em fun\u00e7\u00e3o de um determinado filtro de expre\u00e7\u00e3o

size=Tamanho

SLD_grammar=Gram\u00e1tica SLD

some_arguments_are_incorrect=Alguns argumentos s\u00e3o incorretos.

specify_the_range_of_scales_at_which_labels_will_be_shown=Especifique o intervalo de escalas em que os r\u00f3tulos ser\u00e3o mostrados

SQL_query=Consulta SQL

statistics=Estat\u00edsticas

string_value=Valor String

style=Estilo

style_selector=Seletor de estilos

symbol=S\u00edmbolo

symbol_field=Campo de s\u00edmbolo graduado

symbol_shapetype_mismatch=

syntax_error=Erro de sintaxe

template=Modelo

text=Texto

text_field=Texto

text_fields=Campos de texto

text_string=Texto

text_symbol=S\u00edmbolo do texto

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

the_number_or_arguments_is_incorrect=O n\u00famero de argumentos n\u00e3o \u00e9 correto

the_result_is_not_a_boolean_value=O resultado n\u00e3o \u00e9 um boolean

to=At\u00e9

URL=

use_outline=Usar borda

use_the_same_scale_range_as_the_feature_layer=Usar a mesma gama de escalas que o elemento do plano de informa\u00e7\u00e3o

user_defined_labels=Etiquetas definidas pelo usu\u00e1rio