Application: gvSIG desktop » gvSIG legends: base legends

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

    public static final String

    PROPORTIONAL_SYMBOL_LEGEND_NAME =

    public static final String

    PROPORTIONAL_SYMBOL_LEGEND_PERSISTENCE_DEFINITION_NAME =

	public void setClassifyingFieldNames(String[] fNames) {

		super.setClassifyingFieldNames(fNames);

		valueField = fNames[0];

	}

	public ISymbol getSymbolByFeature(Feature feat) {

		ISymbol theSymbol = getDefaultSymbol();

		ISymbol auxSymbol;

		double value = 0;

		double normValue = 0;

		double size;

		double separation = maxSize-minSize;

		if (separation == 0) {

			separation = 1;

		}

			value = feat.getDouble(this.valueField);

			if (useNormalization) {

			    normValue = feat.getDouble(this.normalizationField);

			    if (normValue == 0) {

			        size = (value >= 0) ?

			            Double.POSITIVE_INFINITY :

			    } else {

	                value = value / normValue;

	                size = minSize + (value * separation) ;

			    }

			} else {

				double difFeat = maxFeature - minFeature;

				double step = difFeat/separation;

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

		    || size == Double.NEGATIVE_INFINITY) {

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

			return null;

		}

		Geometry defgeom = feat.getDefaultGeometry();

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

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

			MarkerFillSymbol aux = new MarkerFillSymbol();

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

			aux.setMarker((IMarkerSymbol) theSymbol);

			theSymbol = aux;

		}

		else if (isLinear(def_geom_type)) {

			ILineSymbol line = (ILineSymbol) theSymbol;

			line.setLineWidth(size);

			theSymbol = line;

			marker.setSize(size);

			theSymbol = marker;

		}

		if (backgroundSymbol != null) {

			MultiLayerFillSymbol multi = new MultiLayerFillSymbol() ;

			multi.addLayer(backgroundSymbol);

            return false;

        }

	}

	public static boolean isPoint(int ty) {

        if (ty == Geometry.TYPES.POINT

            || ty == Geometry.TYPES.MULTIPOINT

    }

	/**

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

	 * is polygonal

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

	 *

	 * @return String  the name of the field

	 */

	public String getValueField() {

//		try {

	 * @param templateShapeType shape type for the template symbol

	 */

	public void setTemplateShapeType(int tst) {

		if (isPolygonal(getShapeType())) {

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

			    this.templateShapeType = tst;

			}

		} else {

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

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

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

		        this.templateShapeType = tst;

		    }

		}

	}

	/**

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

	 * symbol using a normalization field.

		}

	}

    public void loadFromState(PersistentState state)

        throws PersistenceException {

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

        this.setClassifyingFieldTypes(ft);

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

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

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

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

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

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

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

        this.setDefaultSymbol(sym);

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

        this.setBackgroundSymbol(sym);

        String[] fieldNames = new String[2];

        fieldNames[0]= valueField;

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

    public static class RegisterPersistence implements Callable {

        public Object call() throws Exception {

            PersistenceManager manager = ToolsLocator.getPersistenceManager();

            if (manager

                .getDefinition(PROPORTIONAL_SYMBOL_LEGEND_PERSISTENCE_DEFINITION_NAME) == null) {

                            PROPORTIONAL_SYMBOL_LEGEND_PERSISTENCE_DEFINITION_NAME,

                            PROPORTIONAL_SYMBOL_LEGEND_PERSISTENCE_DEFINITION_NAME

                                + " Persistence definition", null, null);

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

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

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

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

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

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

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

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

                definition.addDynFieldObject("defaultSymbol")

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

                definition.addDynFieldObject("backgroundSymbol")