Application: gvSIG desktop » gvSIG legends: base legends

#Mon Mar 04 00:02:02 CET 2024

buildNumber=246

org.gvsig.symbology.library.DotDensityLibrary

<!--

    gvSIG. Desktop Geographic Information System.

    Copyright (C) 2007-2013 gvSIG Association.

    This program is free software; you can redistribute it and/or

    modify it under the terms of the GNU General Public License

    as published by the Free Software Foundation; either version 3

    of the License, or (at your option) any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program; if not, write to the Free Software

    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

    MA  02110-1301, USA.

    For any additional information, do not hesitate to contact us

    at info AT gvsig.com, or visit our website www.gvsig.com.

-->

<assembly>

  <id>gvsig-plugin-package</id>

  <formats>

    <format>zip</format>

  </formats>

  <baseDirectory>${project.artifactId}</baseDirectory>

  <includeBaseDirectory>true</includeBaseDirectory>

  <files>

    <file>

      <source>target/${project.artifactId}-${project.version}.jar</source>

      <outputDirectory>lib</outputDirectory>

    </file>

    <file>

      <source>target/package.info</source>

    </file>

  </files>

  <fileSets>

    <fileSet>

      <directory>src/main/resources-plugin</directory>

      <outputDirectory>.</outputDirectory>

    </fileSet>

  </fileSets>

<!-- No dependencies

  <dependencySets>

    <dependencySet>

      <useProjectArtifact>false</useProjectArtifact>

      <useTransitiveDependencies>false</useTransitiveDependencies>

      <outputDirectory>lib</outputDirectory>

      <includes>

		<include>...</include>

      </includes>

    </dependencySet>

  </dependencySets>

-->

</assembly>

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

 *

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

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

package org.gvsig.symbology.fmap.symbols;

import java.awt.Color;

import java.awt.Graphics2D;

import java.awt.Rectangle;

import java.awt.geom.AffineTransform;

import java.util.Random;

import javax.print.attribute.PrintRequestAttributeSet;

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.geom.primitive.Point;

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

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

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.task.Cancellable;

import org.gvsig.tools.util.Callable;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * <p>

 * Symbol that draws a set of points within a polygon. The amount of points is

 * defined by the field dotCount.<br>

 * </p>

 * <p>

 * This symbol only draws the points. The outline and the fill of the polygon is

 * handled by a SimpleFillSymboll where a DotDensityFillSymbol should be

 * embedded.<br>

 * </p>

 *

 */

public class DotDensityFillSymbol extends AbstractFillSymbol {

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

    public static final String

    DOT_DENSITY_FILL_SYMBOL_PERSISTENCE_DEFINITION_NAME =

        "DOT_DENSITY_FILL_SYMBOL_PERSISTENCE_DEFINITION_NAME";

	private int  dotCount;

	private double dotSize;

	private double dotSpacing;

	private Color dotColor = Color.BLACK;

	public DotDensityFillSymbol() {

		super();

	}

    @Override

	public ISymbol getSymbolForSelection() {

		return this; // the selection color is applied in the SimpleFillSymbol

	}

    @Override

    public void draw(Graphics2D g, AffineTransform atr,

        Geometry theGeom, Feature f, Cancellable cancel, Rectangle r) {

        if(r != null){

            theGeom = getSampleGeometry(r);

        }

        try {

            Geometry clo_geo = theGeom.cloneGeometry();

            clo_geo.transform(atr);

            GeometryManager geoManager=GeometryLocator.getGeometryManager();

            Point interiorPoint=geoManager.createPoint(0, 0, Geometry.SUBTYPES.GEOM2D);

            int maxIntentos = 35;

            int width = clo_geo.getBounds().width;

            int height = clo_geo.getBounds().height;

            int minx = clo_geo.getBounds().x;

            int miny = clo_geo.getBounds().y;

            Random random = new Random();

            g.setClip(clo_geo.getShape());

            g.setColor(getDotColor());

            g.setBackground(null);

            int size = (int) dotSize;

            for (int i = 0; (cancel==null || !cancel.isCanceled()) && i < dotCount; i++) {

                int x,y;

                int intentos = 0;

                /* Introducimos este bucle para procurar que los puntos

                 * queden dentro del shape. Le ponemos adem?s un

                 * numero m?ximo de intentos para evitar las posibilidad de

                 * un bucle infinito o excesivamente reiterativo.

                 */

                do{

                    x = (int) Math.abs(random.nextDouble() * width);

                    y = (int) Math.abs(random.nextDouble() * height);

                    x = x + minx;

                    y = y + miny;

                    intentos++;

                    interiorPoint.setX(x);

                    interiorPoint.setY(y);

                }  while (intentos<maxIntentos && !clo_geo.contains(interiorPoint));

                if(!clo_geo.contains(interiorPoint)){

                    interiorPoint = clo_geo.getInteriorPoint();

                    x = (int) interiorPoint.getX();

                    y = (int) interiorPoint.getY();

                }

                g.fillRect(x, y, size, size);

            }

            g.setClip(null);

        } catch (Exception e) {

            logger.warn("An error has been produced drawing density points for : "+theGeom.toString());

        }

	}

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        super.saveToState(state);

        // color

        Color c = getDotColor();

        if (c == null) {

            c = Color.BLACK;

        }

        state.set("dotColor", c);

        state.set("dotCount", dotCount);

        state.set("dotSize", dotSize);

        state.set("dotSpacing", dotSpacing);

    }

    @Override

	public int getSymbolType() {

		return Geometry.TYPES.SURFACE;

	}

    @Override

    public void loadFromState(PersistentState state)

        throws PersistenceException {

        super.loadFromState(state);

        Object obj_col = state.get("dotColor");

        this.setDotColor((Color) obj_col);

        this.setDotCount(state.getInt("dotCount"));

        this.setDotSize(state.getDouble("dotSize"));

        this.setDotSpacing(state.getDouble("dotSpacing"));

    }

	/**

	 * @return

	 * @uml.property  name="dotCount"

	 */

	public int getDotCount() {

		return dotCount;

	}

	/**

	 * @param dotCount

	 * @uml.property  name="dotCount"

	 */

	public void setDotCount(int dotCount) {

		this.dotCount = dotCount;

	}

	/**

	 * @return

	 * @uml.property  name="dotSize"

	 */

	public double getDotSize() {

		return dotSize;

	}

	public void setDotSize(double dotSize) {

		this.dotSize = dotSize;

	}

	/**

	 * @return

	 * @uml.property  name="dotSpacing"

	 */

	public double getDotSpacing() {

		return dotSpacing;

	}

	/**

	 * @param dotSpacing

	 * @uml.property  name="dotSpacing"

	 */

	public void setDotSpacing(double dotSpacing) {

		this.dotSpacing = dotSpacing;

	}

	public Color getDotColor() {

		return dotColor;

	}

	public void setDotColor(Color dotColor) {

		this.dotColor = dotColor;

	}

    public static class RegisterPersistence implements Callable {

        @Override

        public Object call() throws Exception {

            PersistenceManager manager = ToolsLocator.getPersistenceManager();

            if( manager.getDefinition(

                DOT_DENSITY_FILL_SYMBOL_PERSISTENCE_DEFINITION_NAME)==null ) {

                DynStruct definition = manager.addDefinition(

                    DotDensityFillSymbol.class,

                        DOT_DENSITY_FILL_SYMBOL_PERSISTENCE_DEFINITION_NAME,

                        DOT_DENSITY_FILL_SYMBOL_PERSISTENCE_DEFINITION_NAME +

                        " Persistence definition",

                        null,

                        null

                );

                // Extend the Symbol base definition

                definition.extend(manager.getDefinition(

                    AbstractFillSymbol.FILL_SYMBOL_PERSISTENCE_DEFINITION_NAME));

                definition.addDynFieldObject("dotColor").setMandatory(true)

                .setClassOfValue(Color.class);

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

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

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

            }

            return Boolean.TRUE;

        }

    }

}

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

 *

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

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 */

package org.gvsig.symbology.fmap.rendering;

import java.awt.Color;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

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

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

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.fill.IFillSymbol;

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

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

import org.gvsig.symbology.fmap.symbols.DotDensityFillSymbol;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.util.Callable;

/**

 *

 * Implements a legend where the magnitudes of a specific area of the

 * map are represented by the density of the points that are distributed

 * in the surface.

 *

 *

 */

public class DotDensityLegend extends VectorialUniqueValueLegend {

    private static Logger logger = LoggerFactory.getLogger(

        DotDensityLegend.class);

    public static final String

    DOT_DENSITY_LEGEND_PERSISTENCE_DEFINITION_NAME = 

    "DOT_DENSITY_LEGEND_PERSISTENCE_DEFINITION_NAME";

    public static final String

    DOT_DENSITY_LEGEND_NAME = "DOT_DENSITY_LEGEND_NAME";

	private double dotValue;

	private Color dotColor = Color.BLACK;

	private Color backgroundColor = Color.WHITE;

	private static final int SIMPLE_FILL_LAYER_INDEX = 0;

	private static final int DOT_DENSITY_LAYER_INDEX = 1;

	public ISymbol getSymbolByValue(Object val) {

		MultiLayerFillSymbol sym = (MultiLayerFillSymbol) getDefaultSymbol();

		DotDensityFillSymbol densitySym = (DotDensityFillSymbol) sym.getLayer(DOT_DENSITY_LAYER_INDEX);

		if (val instanceof Number) {

		    Number dou = (Number) val;

	        densitySym.setDotCount(

	            (int) (dou.doubleValue()/dotValue));

	        return sym;

		} else {

		    logger.info("Error: Unexpected value in dot density legend: " + val);

		    return null;

		}

	}

	public ISymbol getSymbolByFeature(Feature feat) {

	    String[] ff = this.getClassifyingFieldNames();

	    Object val = feat.get(ff[0]);

	    return this.getSymbolByValue(val);

	}

	/**

	 * Establishes the value for the dot used in the dot density legend

	 *

	 * @param dotValue

	 */

	public void setDotValue(double dotValue) {

		this.dotValue = dotValue;

	}

    public void saveToState(PersistentState state) throws PersistenceException {

        super.saveToState(state);

        state.set("dotValue", dotValue);

        state.set("dotColor", getDotColor());

        state.set("bgColor", getBGColor());

    }

    public void loadFromState(PersistentState state)

        throws PersistenceException {

        super.loadFromState(state);

        dotValue = state.getDouble("dotValue");

        Object obj_col = state.get("dotColor");

        this.setDotColor((Color) obj_col);

        obj_col = state.get("bgColor");

        this.setBGColor((Color) obj_col);

    }

	/**

	 * Returns the outline

	 *

	 * @return

	 */

	public ILineSymbol getOutline() {

		// defined by the SimpleFillSymbol layer

		ISymbol symbol = getDefaultSymbol();

		if (!(symbol instanceof IFillSymbol)){

			return null;

		}

		IFillSymbol fillsym = (IFillSymbol) symbol;

		if (fillsym instanceof MultiLayerFillSymbol){

			fillsym = (IFillSymbol) ((MultiLayerFillSymbol) fillsym).

			getLayer(SIMPLE_FILL_LAYER_INDEX);

		}

		if (fillsym == null){

			return null;

		}

		return fillsym.getOutline();

	}

	/**

	 * Returns the color for the dot used in the dot density legend.

	 * @return

	 */

	public Color getDotColor() {

//		try {

//			// defined by the DotDensitySymbol layer

//			DotDensityFillSymbol sym = (DotDensityFillSymbol) ((MultiLayerFillSymbol) getDefaultSymbol()).

//			getLayer(DOT_DENSITY_LAYER_INDEX);

//			return sym.getDotColor();

//		} catch (NullPointerException npE) {

//			return null;

//		}

		return dotColor;

	}

	/**

	 * Sets the color for the dot used in the dot density legend.

	 * @return

	 */

	public void setDotColor(Color color){

//		DotDensityFillSymbol sym = (DotDensityFillSymbol) ((MultiLayerFillSymbol) getDefaultSymbol()).

//		getLayer(DOT_DENSITY_LAYER_INDEX);

//		sym.setDotColor(color);

		this.dotColor = color;

	}

	/**

	 * Obtains the background color for the dot density legend

	 * @return

	 */

	public Color getBGColor() {

//		try {

//			// defined by the SimpleFillSymbol layer

//			IFillSymbol symbol = (IFillSymbol) ((MultiLayerFillSymbol) getDefaultSymbol()).

//			getLayer(SIMPLE_FILL_LAYER_INDEX);

//			return symbol.getFillColor();

//		} catch (NullPointerException npE) {

//			return null;

//		}

		return backgroundColor;

	}

	/**

	 * Sets the background color for the dot density legend

	 * @return

	 */

	public void setBGColor(Color color) {

		this.backgroundColor = color;

	}

	/**

	 * Returns the value for the dot that is used in the dot density legend

	 * @return

	 */

	public double getDotValue() {

	    return this.dotValue;

	}

	/**

	 * Obtains the size of the dot that is used in the dot density legend

	 * @return

	 */

	public double getDotSize() {

		// defined by the SimpleFillSymbol layer

		ISymbol symbol = getDefaultSymbol();

		if (symbol == null){

			return -1;

		}

		if (symbol instanceof DotDensityFillSymbol){

			return ((DotDensityFillSymbol)symbol).getDotSize();

		}

		if (!(symbol instanceof IFillSymbol)){

			return -1;

		}

		IFillSymbol fillsym = (IFillSymbol) symbol;

		if (fillsym instanceof MultiLayerFillSymbol){

			fillsym = (DotDensityFillSymbol) ((MultiLayerFillSymbol) fillsym).

			getLayer(DOT_DENSITY_LAYER_INDEX);

		}

		if (fillsym instanceof DotDensityFillSymbol){

			return ((DotDensityFillSymbol)fillsym).getDotSize();

		}

		return -1;

	}

	/**

	 * Sets the size of the dot that is used in the dot density legend

	 */

	public void setDotSize(double value) {

		DotDensityFillSymbol sym = (DotDensityFillSymbol) ((MultiLayerFillSymbol) getDefaultSymbol()).

		getLayer(DOT_DENSITY_LAYER_INDEX);

		sym.setDotSize(value);

	}

    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 class RegisterPersistence implements Callable {

        public Object call() throws Exception {

            PersistenceManager manager = ToolsLocator.getPersistenceManager();

            if (manager.getDefinition(

                DOT_DENSITY_LEGEND_PERSISTENCE_DEFINITION_NAME) == null) {

                DynStruct definition = manager

                    .addDefinition(DotDensityLegend.class,

                        DOT_DENSITY_LEGEND_PERSISTENCE_DEFINITION_NAME,

                        DOT_DENSITY_LEGEND_PERSISTENCE_DEFINITION_NAME

                        + " Persistence definition", null, null);

                definition.extend(manager.getDefinition(

                    VectorialUniqueValueLegend

                    .VECTORIAL_UNIQUE_VALUE_LEGEND_PERSISTENCE_DEFINITION_NAME));

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

                definition.addDynFieldObject("dotColor")

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

                definition.addDynFieldObject("bgColor")

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

            }

            return Boolean.TRUE;

        }

    }

    public static class RegisterLegend implements Callable {

        public Object call() throws Exception {

            MapContextManager manager =

                MapContextLocator.getMapContextManager();

            manager.registerLegend(

                DOT_DENSITY_LEGEND_NAME,

                DotDensityLegend.class);

            return Boolean.TRUE;

        }

    }

    public Object clone() throws CloneNotSupportedException {

        DotDensityLegend resp = (DotDensityLegend) super.clone();

        resp.setDotColor(this.getDotColor());

        resp.setDotSize(this.getDotSize());

        resp.setDotValue(this.getDotValue());

        return resp;

    }

    public String[] getDescriptions() {

        try {

            return new String[]{String.format("%s, %.3f",getClassifyingFieldNames()[0], getDotValue())};

        }catch (Exception ex){

            return new String[]{"Dot density"};

        }

    }

}

/* 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: DotDensity.java 15647 2007-10-30 12:03:52Z jmvivo $

 * $Log$

 * Revision 1.11  2007-09-19 15:47:10  jaume

 * refactor name IVectorialLegend -> IVectorLegend and a method name as well

 *

 * Revision 1.10  2007/09/04 14:13:01  jaume

 * *** empty log message ***

 *

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

 * *** empty log message ***

 *

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

 * *** empty log message ***

 *

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

 * Refactored legend interface names

 *

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

 * *** empty log message ***

 *

 * Revision 1.5  2007/04/20 07:54:39  jaume

 * *** empty log message ***

 *

 * Revision 1.4  2007/04/20 07:24:56  jaume

 * *** empty log message ***

 *

 * Revision 1.3  2007/04/17 06:53:46  bsanchez

 * - Corregido fallo de Double.MIN_VALUE por Double.NEGATIVE_INFINITY comentado por Victor Olaya.

 *

 * 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/12 15:14:41  jaume

 * refactored interval legend and added graduated symbol legend

 *

 * Revision 1.1.2.2  2007/02/09 11:00:03  jaume

 * *** empty log message ***

 *

 * Revision 1.1.2.1  2007/01/26 13:49:03  jaume

 * *** empty log message ***

 *

 * Revision 1.4  2006/11/17 13:53:45  cesar

 * *** empty log message ***

 *

 * Revision 1.3  2006/11/17 12:50:36  jaume

 * tama�o de punto defecto 2

 *

 * Revision 1.2  2006/11/15 12:57:31  jaume

 * *** empty log message ***

 *

 * Revision 1.1  2006/11/14 11:10:27  jaume

 * *** empty log message ***

 *

 *

 */

package org.gvsig.symbology.gui.layerproperties;

import java.awt.BorderLayout;

import java.awt.Color;

import java.awt.ComponentOrientation;

import java.awt.Dimension;

import java.awt.FlowLayout;

import java.awt.GridLayout;

import java.awt.LayoutManager;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.ItemEvent;

import java.awt.event.ItemListener;

import java.text.NumberFormat;

import javax.swing.BorderFactory;

import javax.swing.BoxLayout;

import javax.swing.ButtonGroup;

import javax.swing.Icon;

import javax.swing.ImageIcon;

import javax.swing.JComboBox;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import javax.swing.JRadioButton;

import javax.swing.JSlider;

import javax.swing.event.ChangeEvent;

import javax.swing.event.ChangeListener;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.andami.IconThemeHelper;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.gui.panels.ColorChooserPanel;

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

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

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

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

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

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

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

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

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

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

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

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

import org.gvsig.symbology.fmap.symbols.DotDensityFillSymbol;

import org.gvsig.tools.dispose.DisposableIterator;

/**

 * This panel lets the user choose the dot density legend settings (numeric

 * field, density of points, etc)

 *

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

 * @param <JNumberSpinner>

 *

 */

public class DotDensityPanel extends JPanel implements ILegendPanel {

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

    private static final int MAX_VALUE_COUNT = 300;

    private FLyrVect layer;

    private JPanel northPanel = null;

    private GridBagLayoutPanel densityButtonsPanel = null;

    private JPanel pnlDensities = null;

    private JComboBox cmbLegendField = null;

    private JRadioButton rdBtnHigh = null;

    private JRadioButton rdBtnMedium = null;

    private JRadioButton rdBtnLow = null;

    private JNumberSpinner numDotSize = null;

    private JNumberSpinner nmbrDotValue = null;

    private JLabel lblLabellingField = null;

    private DotDensityLegend legend;

    private String theFieldName;

    private int theFieldType;

    private boolean initializing;

    private double max;

    private double maxDotSize = 0;

    private double b, a; // line function params where: y = bx + a

    private int theValueCount;

    private NumberFormat nf = NumberFormat.getInstance();

    {

        nf.setMaximumFractionDigits(3);

    }

    private MyListener cmbAction = new MyListener();

    private class MyListener implements ItemListener, ActionListener {

        public void itemStateChanged(ItemEvent e) {

            if (!initializing) {

                doIt();

            }

        }

        public void actionPerformed(ActionEvent e) {

            if (!initializing) {

                doIt();

            }

        }

        private void doIt() {

            int index = cmbLegendField.getSelectedIndex();

            try {

                FeatureStore fsto = (FeatureStore) layer.getDataStore();

                FeatureSet fset = fsto.getFeatureSet();

                FeatureType fty = fsto.getDefaultFeatureType();

                if (index != -1) {

                    theFieldName = (String) cmbLegendField.getSelectedItem();

                } else {

                    theFieldName = (String) cmbLegendField.getItemAt(0);

                }

                FeatureAttributeDescriptor att

                        = fty.getAttributeDescriptor(theFieldName);

                theFieldType = att.getDataType().getType();

                long vc = 0;

                double maxValue = -Double.MAX_VALUE;

                double minValue = Double.MAX_VALUE;

                DisposableIterator disp = fset.fastIterator();

                Feature fitem = null;

                double value = 0;

                int i = 0;

                while (i < MAX_VALUE_COUNT && disp.hasNext()) {

                    fitem = (Feature) disp.next();

                    value = fitem.getDouble(theFieldName);

                    if (value < minValue) {

                        minValue = value;

                    }

                    if (value > maxValue) {

                        maxValue = value;

                    }

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

                    i++;

                }

                disp.dispose();

                theValueCount = i;

                if (theValueCount == 0) {

                    b = 0;

                    a = minValue;

                } else {

                    b = (maxValue - minValue) / (theValueCount);

                    a = minValue;

                }

                buttonsListener.actionPerformed(null);

            } catch (Exception ex) {

                logger.info("Error while computing a,b.", ex);

                ApplicationLocator.getManager().message(

                        Messages.getText("error")

                        + " (" + Messages.getText("dot_density") + ")\n\n"

                        + ex.getMessage(),

                        JOptionPane.ERROR_MESSAGE);

            }

        }

    }

    private ActionListener buttonsListener = new ActionListener() {

        public void actionPerformed(ActionEvent e) {

            int oldValue = getSldDensity().getValue();

            int newValue = 0;

            if (getRdBtnHigh().isSelected()) {

                newValue = 33;

            } else if (getRdBtnLow().isSelected()) {

                newValue = 66;

            } else if (getRdBtnMedium().isSelected()) {

                newValue = 50;

            }

            if (oldValue == newValue) {

                sldListener.stateChanged(null);

            } else {

                getSldDensity().setValue(newValue);

            }

        }

    };

    private JPanel centerPanel = null;

    private JSlider sldDensity = null;

    private boolean dotValueChanging = false;

    private ChangeListener sldListener = new ChangeListener() {

        public void stateChanged(ChangeEvent e) {

            if (dotValueChanging) {

                return;

            }

            dotValueChanging = true;

            double d = sldValueToDotValue(getSldDensity().getValue());

            nmbrDotValue.setDouble(d);

            dotValueChanging = false;

        }

    };

    private ActionListener nmbrDotValueListener = new ActionListener() {

        public void actionPerformed(ActionEvent e) {

            if (dotValueChanging) {

                return;

            }

            dotValueChanging = true;

            double dotValue = getNmbrDotValue().getDouble();

            if (dotValue < 0) {

                dotValue = 0;

            }

            int result = dotValueToSldValue(dotValue);

            getSldDensity().setValue(result);

            dotValueChanging = false;

        }

    };

    private ColorChooserPanel jcc;

    private ILegend oldLegend;

    private JSymbolPreviewButton btnOutline;

    private ColorChooserPanel jccBackground;

    public DotDensityPanel() {

        super();

        initialize();

    }

    /**

     * This method initializes this

     *

     */

    private void initialize() {

        this.setLayout(new BorderLayout());

        this.setSize(new java.awt.Dimension(492, 278));

        this.add(getNorthPanel(), java.awt.BorderLayout.NORTH);

        this.add(getCenterPanel(), java.awt.BorderLayout.CENTER);

    }

    private double sldValueToDotValue(int value) {

        int quantileIndex = (theValueCount * value) / 100;

        double d = (b * quantileIndex + a); // /50; // ?por qu? el 50?

        return d;

    }

    private int dotValueToSldValue(double value) {

        int quantileIndex = (int) Math.round((value - a) / b);

        int result = 100 * quantileIndex / theValueCount;

        return result;

    }

    public void setData(FLayer lyr, ILegend legend) {

        this.layer = (FLyrVect) lyr;

        this.oldLegend = legend.cloneLegend();

        try {

            // Para evitar los campos no pertenecientes a la fuente original de la capa.

            // SelectableDataSource sds = layer.getSource().getRecordset();

            // FJP: Otra vez con soporte del join

            // SelectableDataSource sds = layer.getRecordset();

            FeatureStore fsto = (FeatureStore) layer.getDataStore();

            FeatureType fty = fsto.getDefaultFeatureType();

            FeatureAttributeDescriptor[] atts = fty.getAttributeDescriptors();

            initializing = true; // silents events to the combo box

            cmbLegendField.removeAllItems();

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

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

                    cmbLegendField.addItem(atts[i].getName());

                }

            }

            if (!(legend instanceof DotDensityLegend)) {

                legend = new DotDensityLegend();

                ((DotDensityLegend) legend).setClassifyingFieldNames(

                        new String[]{(String) cmbLegendField.getItemAt(0)});

                ((DotDensityLegend) legend).setShapeType(layer.getShapeType());

            }

            DotDensityLegend theLegend = (DotDensityLegend) legend;

            initializing = false; // enables events to the combo box

            cmbLegendField.setSelectedItem(theLegend.getClassifyingFieldNames()[0]);

            try {

                getDotColorChooserPanel().setColor(theLegend.getDotColor());

            } catch (NullPointerException npEx) {

                getDotColorChooserPanel().setColor(Color.RED);

            }

            try {

                getBackgroundColorChooserPanel().setColor(theLegend.getBGColor());

            } catch (NullPointerException npEx) {

                getDotColorChooserPanel().setColor(Color.WHITE);

            }

            getBtnOutline().setSymbol(theLegend.getOutline());

            try {

                double dotValue = theLegend.getDotValue();

                if (dotValue <= 0) {

                    dotValue = sldValueToDotValue(50);//100;

                }

                getNmbrDotValue().setDouble(dotValue);

                dotValueChanging = true;

                getSldDensity().setValue(dotValueToSldValue(dotValue));

                dotValueChanging = false;

            } catch (NullPointerException npEx) {

                getSldDensity().setValue(50);

            }

            try {

                double dotSize = theLegend.getDotSize();

                if (dotSize <= 0) {

                    dotSize = 2;

                }

                getNumDotSize().setDouble(dotSize);

            } catch (NullPointerException npEx) {

                getNumDotSize().setDouble(3);

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

    public ILegend getLegend() {

        try {

            int shapeType = layer.getShapeType();

            // shapeType should be always polygon

            if (!DotDensityLegend.isPolygonal(shapeType)) {

                ApplicationLocator.getManager().message(

                        Messages.getText("cannot_apply_to_a_non_polygon_layer"),

                        JOptionPane.ERROR_MESSAGE);

                return null;

            }

            // gather values

            double dotValue;

            double dotSize;

            try {

                dotValue = nmbrDotValue.getDouble();

            } catch (Exception e) {

                dotValue = nmbrDotValue.getDouble();

            }

            if (dotValue == 0) {

                dotValue = 1;

            }

            try {

                dotSize = numDotSize.getDouble();

            } catch (Exception e) {

                dotSize = numDotSize.getDouble();

            }

            if (max / dotValue > 50000) {

                int option = JOptionPane.showConfirmDialog(this,

                        Messages.getText("looks_like_too_low_value_for_this_field_may_cause_system_to_run_slow"),

                        Messages.getText("warning"),

                        JOptionPane.OK_CANCEL_OPTION);

                if (option == JOptionPane.CANCEL_OPTION) {

                    return oldLegend;

                }

            }

            // create the density symbol with the values set above

            DotDensityFillSymbol densitySymbol = new DotDensityFillSymbol();

            densitySymbol.setDotSize(dotSize);

            densitySymbol.setDotColor(getDotColorChooserPanel().getColor());

            // create a simple-fill symbol over which the dot density will be drawn

            SimpleFillSymbol fillSymbol = new SimpleFillSymbol();

            fillSymbol.setFillColor(getBackgroundColorChooserPanel().getColor());

            fillSymbol.setOutline((ILineSymbol) getBtnOutline().getSymbol());

            // combine both the DotDensitySymbol and the SimpleFillSymbol in

            // MultiLayerSymbol so they will be paint as a unique ISymbol

            MultiLayerFillSymbol symbol = new MultiLayerFillSymbol();

            symbol.setDescription(

                    "DotDensitySymbol" + Messages.getText("in_layer")

                    + ": '" + layer.getName() + "'");

            symbol.addLayer(fillSymbol);

            symbol.addLayer(densitySymbol);

            legend = new DotDensityLegend();

            legend.setClassifyingFieldNames(new String[]{theFieldName});

            legend.setClassifyingFieldTypes(new int[]{theFieldType});

            legend.addSymbol(0, symbol);

            legend.setDefaultSymbol(symbol);

            legend.setDotValue(dotValue);

            legend.setBGColor(getBackgroundColorChooserPanel().getColor());

            legend.setDotColor(getDotColorChooserPanel().getColor());

        } catch (Exception e) {

            logger.warn(Messages.getText("could_not_setup_legend"), e);

        }

        return legend;

    }

    /**

     * This method initializes centerPanel

     *

     * @return javax.swing.JPanel

     */

    private JPanel getNorthPanel() {

        if (northPanel == null) {

            lblLabellingField = new JLabel();

            lblLabellingField.setText(Messages.getText("labeling_field") + ".");

            northPanel = new JPanel(new FlowLayout(FlowLayout.LEADING, 15, 0));

            northPanel.add(lblLabellingField, null);

            northPanel.add(getCmbLegendField(), null);

        }

        return northPanel;

    }

    private ColorChooserPanel getDotColorChooserPanel() {

        if (jcc == null) {

            jcc = new ColorChooserPanel();

            jcc.setAlpha(255);

        }

        return jcc;

    }

    /**

     * This method initializes southPanel

     *

     * @return javax.swing.JPanel

     */

    private JPanel getDensityButtonsPanel() {

        if (densityButtonsPanel == null) {

            densityButtonsPanel = new GridBagLayoutPanel();

            LayoutManager layout = new FlowLayout(FlowLayout.LEADING, 0, 0);

            JPanel aux = new JPanel(layout);

            aux.add(getNumDotSize());

            densityButtonsPanel.addComponent(

                    Messages.getText("dot_size"), aux);

            aux = new JPanel(layout);

            aux.add(getNmbrDotValue());

            densityButtonsPanel.addComponent(

                    Messages.getText("dot_value"), aux);

            aux = new JPanel(layout);

            aux.add(getDotColorChooserPanel());

            densityButtonsPanel.addComponent(

                    Messages.getText("color"), aux);

            aux = new JPanel(layout);

            aux.add(getBackgroundColorChooserPanel());

            densityButtonsPanel.addComponent(

                    Messages.getText("background_color"), aux);

            aux = new JPanel(layout);

            aux.add(getBtnOutline());

            densityButtonsPanel.addComponent(

                    Messages.getText("outline"), aux);

        }

        return densityButtonsPanel;

    }

    private ColorChooserPanel getBackgroundColorChooserPanel() {

        if (jccBackground == null) {

            jccBackground = new ColorChooserPanel();

            jccBackground.setColor(Color.WHITE);

            jccBackground.setAlpha(255);

        }

        return jccBackground;

    }

    private JSymbolPreviewButton getBtnOutline() {

        if (btnOutline == null) {

            btnOutline = new JSymbolPreviewButton(Geometry.TYPES.CURVE);

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

        }

        return btnOutline;

    }

    /**

     * This method initializes pnlDensities

     *

     * @return javax.swing.JPanel

     */

    private JPanel getPnlDensities() {

        if (pnlDensities == null) {

            pnlDensities = new JPanel(new BorderLayout(5, 0));

            pnlDensities.setBorder(BorderFactory.createTitledBorder(null,

                    Messages.getText("densities")));

            JPanel aux2 = new JPanel();

            JPanel aux;

            aux = new JPanel(new GridLayout(1, 3));

            aux.add(new JLabel(Messages.getText("low")));

            aux.add(new JLabel(Messages.getText("medium")));

            aux.add(new JLabel(Messages.getText("high")));

            aux2.add(aux);

            aux = new JPanel(new GridLayout(1, 3));

            aux.add(getRdBtnLow());

            aux.add(getRdBtnMedium());

            aux.add(getRdBtnHigh());

            aux2.add(aux);

            aux2.setLayout(new BoxLayout(aux2, BoxLayout.Y_AXIS));

            pnlDensities.add(aux2, BorderLayout.NORTH);

            pnlDensities.add(getSldDensity(), BorderLayout.CENTER);

            pnlDensities.add(getDensityButtonsPanel(), BorderLayout.SOUTH);

            ButtonGroup group = new ButtonGroup();

            group.add(getRdBtnHigh());

            group.add(getRdBtnLow());

            group.add(getRdBtnMedium());

            getRdBtnMedium().setSelected(true);

        }

        return pnlDensities;

    }

    /**

     * This method initializes cmbLegendField

     *

     * @return javax.swing.JComboBox

     */

    private JComboBox getCmbLegendField() {

        if (cmbLegendField == null) {

            cmbLegendField = new JComboBox();

            cmbLegendField.addActionListener(cmbAction);

        }

        return cmbLegendField;

    }

    /**

     * This method initializes rdBtnHigh

     *

     * @return javax.swing.JRadioButton

     */

    private JRadioButton getRdBtnHigh() {

        if (rdBtnHigh == null) {

            Icon ic = IconThemeHelper.getImageIcon(

                    "legend-dot-density-high-density-sample");

            rdBtnHigh = new JRadioButton(ic);

            rdBtnHigh.addActionListener(buttonsListener);

        }

        return rdBtnHigh;

    }

    /**

     * This method initializes rdBtnMedium

     *

     * @return javax.swing.JRadioButton

     */

    private JRadioButton getRdBtnMedium() {

        if (rdBtnMedium == null) {

            Icon ic = IconThemeHelper.getImageIcon(

                    "legend-dot-density-medium-density-sample");

            rdBtnMedium = new JRadioButton(ic);

            rdBtnMedium.addActionListener(buttonsListener);

        }

        return rdBtnMedium;

    }

    /**

     * This method initializes rdBtnMax

     *

     * @return javax.swing.JRadioButton

     */

    private JRadioButton getRdBtnLow() {

        if (rdBtnLow == null) {

            Icon ic = IconThemeHelper.getImageIcon(

                    "legend-dot-density-low-density-sample");

            rdBtnLow = new JRadioButton(ic);

            rdBtnLow.addActionListener(buttonsListener);

        }

        return rdBtnLow;

    }

    /**

     * This method initializes numDotSize

     *

     * @return de.ios.framework.swing.JNumberField

     */

    private JNumberSpinner getNumDotSize() {

        if (numDotSize == null) {

            numDotSize = new JNumberSpinner(1.0, 4, 0.0, Double.MAX_VALUE, 1.0, 2);

        }

        return numDotSize;

    }

    /**

     * This method initializes nmbrDotValue

     *

     * @return de.ios.framework.swing.JNumberField

     */

    private JNumberSpinner getNmbrDotValue() {

        if (nmbrDotValue == null) {

            nmbrDotValue = new JNumberSpinner(1.0, 15, 0.01, Double.MAX_VALUE, 1.0, 2);

            nmbrDotValue.addActionListener(nmbrDotValueListener);

        }

        return nmbrDotValue;

    }

    /**

     * This method initializes centerPanel

     *

     * @return javax.swing.JPanel

     */

    private JPanel getCenterPanel() {

        if (centerPanel == null) {

            centerPanel = new JPanel();

            centerPanel.setLayout(new BorderLayout(5, 5));

            centerPanel.add(getPnlDensities(), java.awt.BorderLayout.WEST);

        }

        return centerPanel;

    }

    /**

     * This method initializes sldDensity

     *

     * @return javax.swing.JSlider

     */

    private JSlider getSldDensity() {

        if (sldDensity == null) {

            sldDensity = new JSlider();

            sldDensity.setComponentOrientation(ComponentOrientation.RIGHT_TO_LEFT);

            sldDensity.addChangeListener(sldListener);

        }

        return sldDensity;

    }

    public String getDescription() {

        return Messages.getText("Defines_a_dot_density_symbol_based_on_a_field_value") + ".";

    }

    public ImageIcon getIcon() {

        ImageIcon ic = IconThemeHelper.getImageIcon(

                "legend-overview-dot-density");

        return ic;

    }

    public Class getParentClass() {

        return Quantities.class;

    }

    public String getTitle() {

        return Messages.getText("dot_density");

    }

    public JPanel getPanel() {

        return this;

    }

    public Class getLegendClass() {

        return DotDensityLegend.class;

    }

    public boolean isSuitableFor(FLayer layer) {

        if (layer instanceof FLyrVect) {

            try {

                FLyrVect lyr = (FLyrVect) layer;

                if (!DotDensityLegend.isPolygonal(lyr.getShapeType())) {

                    return false;

                }

                FeatureStore fsto = (FeatureStore) lyr.getDataStore();

                FeatureType fty = fsto.getDefaultFeatureType();

                FeatureAttributeDescriptor[] atts = fty.getAttributeDescriptors();

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

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

                        return true;

                    }

                }

            } catch (Exception e) {

                ApplicationLocator.getManager().messageDialog(

                        Messages.getText("error_trying_to_access_to_the_layer"),

                        Messages.getText("error"),

                        JOptionPane.ERROR_MESSAGE);

                return false;

            }

        }

        return false;

    }

}

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2013 gvSIG Association

 *

 * This program is free software; you can redistribute it and/or