Application: gvSIG desktop

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0

                      http://maven.apache.org/xsd/maven-4.0.0.xsd">

	<modelVersion>4.0.0</modelVersion>

	<artifactId>org.gvsig.fmap.control</artifactId>

	<packaging>jar</packaging>

	<version>2.0-SNAPSHOT</version>

	<name>libFMap_controls</name>

	<parent>

		<groupId>org.gvsig</groupId>

		<artifactId>gvsig-base-library-pom</artifactId>

		<version>2.0-SNAPSHOT</version>

	</parent>	

	<properties>

		<build-dir>${basedir}/../build</build-dir>

        <eclipse.project.name>libFMap_controls</eclipse.project.name>

	</properties>

	<dependencies>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.tools.lib</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.tools.swing.api</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.tools.swing.impl</artifactId>

            <scope>runtime</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.tools.swing.spi</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.tools.swing.serv.field</artifactId>

            <scope>runtime</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.tools.swing.serv.jform</artifactId>

            <scope>runtime</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.tools.swing.serv.jlist</artifactId>

            <scope>runtime</scope>

        </dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.utils</artifactId>

            <scope>compile</scope>

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.fmap.dal</artifactId>

            <scope>compile</scope>

		</dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.geometry</artifactId>

            <scope>compile</scope>

        </dependency>        

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.geometry</artifactId>

            <classifier>operation</classifier>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.metadata.lib.basic.api</artifactId>

            <scope>compile</scope>

        </dependency>        

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.projection</artifactId>

            <scope>compile</scope>

        </dependency>

		<dependency>

    		<!-- TODO: remove -->

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.fmap.dal</artifactId>

			<classifier>impl</classifier>

            <scope>compile</scope>

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.fmap.mapcontext</artifactId>

            <scope>compile</scope>

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.fmap.mapcontext</artifactId>

			<classifier>operation</classifier>

            <scope>compile</scope>

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.tools.lib</artifactId>

			<type>test-jar</type>

			<scope>test</scope>

		</dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.i18n</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.slf4j</groupId>

            <artifactId>slf4j-api</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>com.vividsolutions</groupId>

            <artifactId>jts</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.tools.swing.api</artifactId>

            <scope>compile</scope>

        </dependency>

		<!-- TODO: uncomment when mapcontexts tests work again 

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.fmap.mapcontext</artifactId>

            <type>test-jar</type>

			<scope>test</scope>

		</dependency>

		 -->

	    <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.timesupport.lib.api</artifactId>

            <scope>compile</scope>

        </dependency>

	</dependencies>

	<build>

		<sourceDirectory>src</sourceDirectory>

		<testSourceDirectory>src-test</testSourceDirectory>

		<resources>

			<resource>

				<filtering>false</filtering>

				<directory>${basedir}/resources</directory>

			</resource>

		</resources>

		<!-- TODO: MAKE TESTS WORK AND REMOVE THIS OPTION -->

		<plugins>

			<plugin>

				<groupId>org.apache.maven.plugins</groupId>

				<artifactId>maven-surefire-plugin</artifactId>

				<configuration>

					<skipTests>true</skipTests>

				</configuration>

			</plugin>

      		<plugin>

				<groupId>org.apache.maven.plugins</groupId>

				<artifactId>maven-compiler-plugin</artifactId>

				<configuration>

					<testExcludes>

						<exclude>**</exclude>

					</testExcludes>

				</configuration>

			</plugin>		

		</plugins>

	</build>

</project>

registros_seleccionados_total=Celkem zvolen\u00fdch z\u00e1znam\u016f

registros_seleccionados_total=Total registres s\u00e9lectionn\u00e9s

registros_seleccionados_total=Alle ausgew\u00e4hlten register

registros_seleccionados_total=Hautatutako erregistroak guztira

registros_seleccionados_total=Totale registri selezionati

Visible=Visible

Nombre=Nombre

Alias=Alias

Error_editar_geometria=Error al editar la geometr?a

Geometria_no_editable_WKT=Geometr?a no editable en formato WKT, valor demasiado grande.

geometry_to_wkt_exception=Error al convertir la geometr?a de la celda a formato WKT

features_data_reload_exception=Error al recargar los fen?menos (features)

get_feature_at_exception=Error al obtener el fen?meno de la fila = %(rowIndex)

get_row_count_exception=Error al obtener el n?mero total de filas en la tabla

set_feature_value_exception=Error al establecer el valor de la celda en la fila = %(rowIndex) y columna = %(columnIndex) con el valor = %(value)

wkt_to_geometry_exception=Error al convertir a geometr?a el valor en WKT: %(wkt)

table_selection_change_exception=Error al cambiar la selecci?n en la tabla de fen?menos (features)

registros_seleccionados_total=Total registros seleccionados

up=Subir

down=Bajar

remove=Eliminar

_Invalid_value=Valor no v?lido

_Unable_to_show_value=No se ha podido mostrar valor

_Show_as_text=Mostrar como texto

registros_seleccionados_total=\u5df2\u9009\u5b9a\u8bb0\u5f55\u603b\u6570

Visible=Visible

Nombre=Name

Alias=Alias

Error_editar_geometria=Error while editing the geometry

Geometria_no_editable_WKT=Geometry not editable on WKT format, text value too big.

geometry_to_wkt_exception=Error getting the geometry value of the cell as WKT

features_data_reload_exception=Error reloading the features

get_feature_at_exception=Error getting the feature at row = %(rowIndex)

get_row_count_exception=Error getting the total table row count

set_feature_value_exception=Error setting the value of the cell at row = %(rowIndex) and column = %(columnIndex) with the value = %(value)

wkt_to_geometry_exception=Error getting the geometry value of the WKT value %(wkt)

table_selection_change_exception=Error while changing the selection on the list of Features

registros_seleccionados_total=Total of selected records

up=Up

down=Down

_Invalid_value=Invalid Value

_Unable_to_show_value=Unable to show value

_Show_as_text=Show as text

registros_seleccionados_total=Total rexistros seleccionados

registros_seleccionados_total=Total registres seleccionats

registros_seleccionados_total=Total de registos seleccionados

org.gvsig.fmap.mapcontrol.MapControlLibrary

org.gvsig.fmap.mapcontrol.impl.DefaultMapControlLibrary

package org.gvsig.fmap.mapcontrol.tools;

import java.awt.geom.Point2D;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.fmap.mapcontrol.MapControl;

import org.gvsig.tools.junit.AbstractLibraryAutoInitTestCase;

public class AreaListenerTest extends AbstractLibraryAutoInitTestCase {

	private IProjection projectionUTM = CRSFactory.getCRS("EPSG:23030");

	private IProjection projectionGeo = CRSFactory.getCRS("EPSG:4230");

	@Override

	protected void doSetUp() throws Exception {

		// Nothing to do	

	}

	public void test1() {

		AreaListenerImpl areaListenerUTM=new AreaListenerImpl(newMapControlUTM());

		AreaListenerImpl areaListenerGeo=new AreaListenerImpl(newMapControlGeo());

		Double[] xsUTM=new Double[] {new Double(731292),new Double(731901),new Double(730138)};

		Double[] ysUTM=new Double[] {new Double(4351223),new Double(4350768),new Double(4349232)};

		double areaUTM=areaListenerUTM.returnCoordsArea(xsUTM,ysUTM,new Point2D.Double(730138,4349232));

		Double[] xsGeo=new Double[] {new Double(-0.31888183),new Double(-0.31173131),new Double(-0.33268401)};

		Double[] ysGeo=new Double[] {new Double(39.27871741),new Double(39.27464327),new Double(39.26117368)};

		double areaGeo=areaListenerGeo.returnGeoCArea(xsGeo,ysGeo,new Point2D.Double(-0.33268401,39.26117368));

		assertTrue("Area UTM igual a Geo",areaUTM<(areaGeo+1000)&& areaUTM>(areaGeo-1000));

	}

	private MapControl newMapControlUTM() {

		ViewPort vp = new ViewPort(projectionUTM);

		MapControl mc=new MapControl();

		mc.setMapContext(new MapContext(vp));

		return mc;

	}

	private MapControl newMapControlGeo() {

		ViewPort vp = new ViewPort(projectionGeo);

		MapControl mc=new MapControl();

		mc.setMapContext(new MapContext(vp));

		return mc;

	}

}

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

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.i18n.Messages;

import org.gvsig.utils.swing.JComboBox;

/**

 * <p>Class representing a JComboBox with the measure units handled by the application.

 * It takes values from Attributes.NAMES and Attributes.CHANGE static fields. So, to

 * add more measure units, you must edit Attributes class and change will be automatically

 * reflected in the combo box.</p>

 *

 * <p>The internatiolanization of the field is automatically handled by the system</p>

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

 */

public class JComboBoxUnits extends JComboBox {

	private static final long serialVersionUID = 8015263853737441433L;

	/**

	 * Creates a new instance of JUnitComboBox including "pixel" units and

	 * setting them as automatically pre-selected.

	 */

	public JComboBoxUnits() {

		this(true);

	}

	/**

	 *

	 * Creates a new instance of JUnitComboBox. If includePixel is true

	 * then pixel units are included in the list and they are automatically

	 * pre-selected. Otherwise, meters are preselected.

	 *

	 */

	public JComboBoxUnits(boolean includePixel) {

		super();

		String[] names=MapContext.getDistanceNames();

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

			super.addItem(Messages.getText(names[i]));

		}

		if (includePixel) {

			super.addItem(Messages.getText("pixels"));

			setSelectedItem(Messages.getText("pixels"));

		} else {

			setSelectedIndex(1);

		}

		setMaximumRowCount(10);

	}

	/**

	 * Returns the conversion factor from the <b>unit selected in the combo box</b>

	 * to <b>meters</b> or <b>0</b> if pixels have been selected as the size unit.

	 * @return

	 */

	public double getUnitConversionFactor() {

			double unitFactor;

			try {

				unitFactor = MapContext.getDistanceTrans2Meter()[getSelectedIndex()];

			} catch (ArrayIndexOutOfBoundsException aioobEx) { //jijiji

				unitFactor = 0; // which represents size in pixel

			}

			return unitFactor;

	}

	/**

	 * the use of this method is not allowed in this combo box.

	 * @deprecated

	 */

	public void addItem(Object anObject) {

		throw new Error("Operation not allowed");

	}

	/**

	 * the use of this method is not allowed for this combo box.

	 * @deprecated

	 */

	public void removeAllItems() {

		throw new Error("Operation not allowed");

	}

	public int getSelectedUnitIndex() {

		int i = getSelectedIndex();

		if (i>MapContext.getDistanceNames().length-1)

			return -1;

		else return i;

	}

	public void setSelectedUnitIndex(int unitIndex) {

		if (unitIndex == -1) {

			setSelectedIndex(getItemCount()-1);

		} else {

			setSelectedIndex(unitIndex);

		}

	}

}

package org.gvsig.fmap;

import java.awt.Image;

import javax.swing.ImageIcon;

import org.gvsig.tools.swing.api.ToolsSwingLocator;

import org.gvsig.tools.swing.icontheme.IconTheme;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class IconThemeHelper {

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

	public static void registerIcon(String group, String name, Object obj) {

		String resourceName;

		ClassLoader loader;

		IconTheme iconTheme = ToolsSwingLocator.getIconThemeManager().getCurrent();

		if( group == null || group.trim().length()==0 ) {

			resourceName = "images/"+name+".png";

		} else {

			resourceName = "images/"+group+"/"+name+".png";

		}

		if( obj instanceof Class ) {

			loader = ((Class) obj).getClassLoader();

		} else {

			loader = obj.getClass().getClassLoader();

		}

		try {

			iconTheme.registerDefault("mapcontrol", group, name, null, loader.getResource(resourceName));

		} catch( Throwable e) {

			logger.info(e.getMessage());

		}

	}

	public static ImageIcon getImageIcon(String iconName) {

		IconTheme iconTheme = ToolsSwingLocator.getIconThemeManager().getCurrent();

		return iconTheme.get(iconName);

	}

	public static Image getImage(String iconName) {

		IconTheme iconTheme = ToolsSwingLocator.getIconThemeManager().getCurrent();

		return iconTheme.get(iconName).getImage();

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

*

* Copyright (C) 2007-2008 Infrastructures and Transports Department

* of the Valencian Government (CIT)

* 

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

* 

*/

/*

* AUTHORS (In addition to CIT):

* 2009 {Iver T.I.}   {Task}

*/

package org.gvsig.fmap.mapcontrol;

import org.gvsig.tools.exception.BaseException;

/**

 * @author <a href="mailto:jpiera@gvsig.org">Jorge Piera</a>

 */

public class MapControlException extends BaseException {

	private static final long serialVersionUID = 981894833703125550L;

	/**

     * @see BaseException#BaseException(String, String, long)

     */

    public MapControlException(String message, String key, long code) {

        super(message, key, code);

    }

    /**

     * @see BaseException#BaseException(String, Throwable, String, long)

     */

    public MapControlException(String message, Throwable cause, String key,

            long code) {

        super(message, cause, key, code);

    }

}

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

 *

 * Copyright (C) 2004 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.fmap.mapcontrol;

import java.awt.Color;

import java.awt.Cursor;

import java.awt.Dimension;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.Point;

import java.awt.Toolkit;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.ComponentEvent;

import java.awt.event.ComponentListener;

import java.awt.event.MouseEvent;

import java.awt.event.MouseListener;

import java.awt.event.MouseMotionListener;

import java.awt.event.MouseWheelEvent;

import java.awt.event.MouseWheelListener;

import java.awt.geom.Point2D;

import java.awt.image.BufferedImage;

import java.awt.image.MemoryImageSource;

import java.util.ArrayList;

import java.util.Comparator;

import java.util.HashMap;

import java.util.List;

import java.util.Set;

import java.util.TreeMap;

import java.util.prefs.Preferences;

import javax.swing.JComponent;

import javax.swing.SwingUtilities;

import javax.swing.Timer;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.dal.DataStoreNotification;

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.exception.CreateEnvelopeException;

import org.gvsig.fmap.geom.operation.GeometryOperationContext;

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

import org.gvsig.fmap.geom.operation.tojts.ToJTS;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.fmap.mapcontext.events.AtomicEvent;

import org.gvsig.fmap.mapcontext.events.listeners.AtomicEventListener;

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

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

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

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

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

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

import org.gvsig.fmap.mapcontrol.tools.BehaviorException;

import org.gvsig.fmap.mapcontrol.tools.CompoundBehavior;

import org.gvsig.fmap.mapcontrol.tools.Behavior.Behavior;

import org.gvsig.fmap.mapcontrol.tools.Listeners.ToolListener;

import org.gvsig.fmap.mapcontrol.tools.grid.Grid;

import org.gvsig.fmap.mapcontrol.tools.snapping.snappers.ISnapper;

import org.gvsig.fmap.mapcontrol.tools.snapping.snappers.ISnapperGeometriesVectorial;

import org.gvsig.fmap.mapcontrol.tools.snapping.snappers.ISnapperRaster;

import org.gvsig.fmap.mapcontrol.tools.snapping.snappers.ISnapperVectorial;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.Disposable;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.Observer;

import org.gvsig.tools.task.Cancellable;

import org.gvsig.utils.exceptionHandling.ExceptionHandlingSupport;

import org.gvsig.utils.exceptionHandling.ExceptionListener;

/**

 * <p>

 * A component that includes a {@link MapContext MapContext} with support for

 * use it as a particular {@link Behavior Behavior}.

 * </p>

 * 

 * <p>

 * A developer can register a set of <code>Behavior</code>, but only one (that

 * can be a composition of several) of them can be active. The active one

 * defines the way to work and access with its <code>MapContext</code>'s layers.

 * The active behavior, in combination with the appropriate {@link ToolListener

 * ToolListener} will allow user work with a particular <i>tool</i>.

 * </p>

 * 

 * <p>

 * All mouse events produced on this component will be delegated to the current

 * active behavior, the <i>currentMapTool</i>.

 * </p>

 * 

 * <p>

 * <b>Drawing process:</b>

 * </p>

 * 

 * <p>

 * Uses a double buffer for the drawing process of <code>MapContext</code>'s

 * information.

 * </p>

 * 

 * <p>

 * If the double buffer wasn't created, creates a new one.

 * </p>

 * 

 * <p>

 * Paints the component according the following algorithm: <br>

 * &nbsp If <i>status</i> is <i>UPDATED</i>:<br>

 * &nbsp &nbsp If there is a <i>double buffer</i>:<br>

 * &nbsp &nbsp &nbsp If there is a <i>behavior</i> for managing the

 * <code>MapControl</code> instance, delegates the drawing process to that

 * behavior, calling: <code><i>behavior_instance</i>.paintComponent(g)</code>.<br>

 * &nbsp &nbsp &nbsp Else, repaints the current graphical information quickly

 * calling: <code>g.drawImage(image,0,0,null)</code>.<br>

 * &nbsp Else, (<i>status</i> is <i>OUTDATED</i>, or <i>ONLY_GRAPHICS</i>):

 * executes a quickly repaint of the previous information calling

 * <code>g.drawImage(image,0,0,null)</code>, and creates a <i>painting

 * request</i> to delegate the heavy drawing process to the {@link Drawer2

 * Drawer2}'s worker thread, according the <i>SingleWorketThread</i> pattern,

 * starting a timer to update (invoking <code>repaint()</code>) the view every

 * delay of <code>1000 / drawFrameRate</code> ms. during that heavy drawing

 * process, and if its enabled <code>drawAnimationEnabled</code>. The

 * <i>painting request</i> once is being attended, invokes

 * <code>MapContext</code> to draw the layers:

 * <code>mapContext.draw(image, g, cancel,mapContext.getScaleView());</code>

 * <br>

 * <p>

 * Some notes:

 * <ul>

 * <li>The painting process can be cancelled calling {@link #cancelDrawing()

 * #cancelDrawing()}.</li>

 * <li>At last resort, the particular implementation of each layer in a

 * <code>MapControl</code>'s <code>MapContrext</code> will be that one which

 * will draw the graphical information, and, if supports, which could cancel its

 * drawing subprocess.</li>

 * <li>It's possible to force repaint all layers, calling

 * {@link #drawMap(boolean doClear) #drawMap(boolean)}.</li>

 * <li>It's possible repaint only the dirty layers, calling

 * {@link #rePaintDirtyLayers() #rePaintDirtyLayers()}.</li>

 * <li>It's possible repaint only the {@link GraphicLayer GraphicLayer}, calling

 * {@link #drawGraphics() #drawGraphics()}.</li>

 * </ul>

 * </p>

 * 

 * <p>

 * <b>Tools:</b>

 * </p>

 * 

 * <p>

 * A developer can:

 * <ul>

 * <li>Register each tool as:

 * <ul>

 * <li>A single behavior: {@link #addBehavior(String, Behavior)

 * #addMapTool(String, Behavior)}.</li>

 * <li>Or, a compound behavior: {@link #addBehavior(String, Behavior)

 * #addMapTool(String, Behavior)}.</li>

 * </ul>

 * </li>

 * <li>Get the current active tool: {@link #getCurrentMapTool()

 * #getCurrentMapTool()}.</li>

 * <li>Get the current active tool name: {@link #getCurrentTool()

 * #getCurrentTool()}.</li>

 * <li>Get a registered tool: {@link #getMapTool(String) #getMapTool(String)}.</li>

 * <li>Get the name of all tools registered: {@link #getMapToolsKeySet()

 * #getMapToolsKeySet()}.</li>

 * <li>Get all tools registered, including the name they were registered:

 * {@link #getNamesMapTools() #getNamesMapTools()}.</li>

 * <li>Determine if has a tool registered: {@link #hasTool(String)

 * #hasTool(String)}.</li>

 * <li>Set as an active tool, one of the registered: {@link #setTool(String)

 * #setTool(String)}.</li>

 * <li>Set as active tool, the previous used: {@link #setPrevTool()

 * #setPrevTool()}.</li>

 * <li>Set the current tool: {@link #setCurrentMapTool(Behavior)

 * #setCurrentMapTool(Behavior)}.</li>

 * <li>Change the draw frame rate: {@link #setDrawFrameRate(int)

 * #setDrawFrameRate(int)} and {@link #applyFrameRate() #applyFrameRate()}.</li>

 * <li>Get the draw frame rate: {@link #getDrawFrameRate() #getDrawFrameRate()}.

 * </li>

 * <li>Determine if will repaint this component each time timer finishes:

 * {@link #isDrawAnimationEnabled() #isDrawAnimationEnabled()}.</li>

 * <li>Change if will repaint this component each time timer finishes:

 * {@link #setDrawAnimationEnabled(boolean) #setDrawAnimationEnabled(boolean)}.</li>

 * <li>Get the shared object that determines if a drawing process must be

 * cancelled or can continue: {@link #getCanceldraw() #getCanceldraw()}.</li>

 * <li>Get the combined tool: {@link #getCombinedTool() #getCombinedTool()}.</li>

 * <li>Set a combined tool: {@link #setCombinedTool(Behavior)

 * #setCombinedTool(Behavior)}.</li>

 * <li>Remove the combined tool: {@link #removeCombinedTool()

 * #removeCombinedTool()}.</li>

 * </ul>

 * </p>

 * 

 * <p>

 * <b>Exception listener:</b>

 * </p>

 * 

 * <p>

 * Adding an <code>ExceptionListener</code>, can get notification about any

 * exception produced:

 * <ul>

 * <li>Attending a <i>painting request</i>.</li>

 * <li>Working with the active tool.</li>

 * <li>Applying a <i>zoom in</i> or <i>zoom out</i> operation.</li>

 * </ul>

 * </p>

 * 

 * <p>

 * <b>Other:</b>

 * </p>

 * 

 * <p>

 * Other useful capabilities of <code>MapControl</code>:

 * <ul>

 * <li>Cancel the current drawing process (notifying it also to the inner

 * <code>MapContext</code> instance and its layers): {@link #cancelDrawing()

 * #cancelDrawing()}.</li>

 * <li>Applying a <i>zoom in</i> operation centered at mouse position (without a

 * <code>ToolListener</code>): {@link #zoomIn() #zoomIn()}.</li>

 * <li>Applying a <i>zoom out</i> operation centered at mouse position (without

 * a <code>ToolListener</code>): {@link #zoomOut() #zoomOut()}.</li>

 * </ul>

 * </p>

 * 

 * @see CancelDraw

 * @see Drawer

 * @see MapContextListener

 * @see MapToolListener

 * 

 * @author Fernando Gonz?lez Cort?s

 * @author Pablo Piqueras Bartolom? (pablo.piqueras@iver.es)

 */

public class MapControl extends JComponent implements ComponentListener,

    Observer, Disposable {

    protected static final GeometryManager geomManager =

        GeometryLocator.getGeometryManager();

    private static final Logger LOG =

        LoggerFactory.getLogger(GeometryManager.class);

    /**

     * <p>

     * One of the possible status of <code>MapControl</code>. Determines that

     * all visible information has been drawn and its updated.

     * </p>

     */

    public static final int ACTUALIZADO = 0;

    /**

     * <p>

     * One of the possible status of <code>MapControl</code>. Determines that

     * not all visible information has been drawn or isn't updated.

     * </p>

     */

    public static final int DESACTUALIZADO = 1;

    /**

     * <p>

     * Determines if the drawer can update this <code>MapControl</code> instance

     * when the timer launches an event.

     * </p>

     */

    private static boolean drawAnimationEnabled = true;

    /**

     * <p>

     * Inner model with the layers, event support for drawing them, and the

     * <code>ViewPort</code> with information to adapt to the bounds available

     * in <i>image coordinates</i>.

     * </p>

     * 

     * @see #getMapContext()

     * @see #setMapContext(MapContext)

     */

    private MapContext mapContext = null;

    /**

     * <p>

     * All registered <code>Behavior</code> that can define a way to work with

     * this <code>MapControl</code>.

     * </p>

     * 

     * <p>

     * Only one of them can be active at a given moment.

     * </p>

     * 

     * @see #addBehavior(String, Behavior)

     * @see #addBehavior(String, Behavior[])

     * @see #getMapTool(String)

     * @see #getMapToolsKeySet()

     * @see #getNamesMapTools()

     */

    protected HashMap namesMapTools = new HashMap();

    /**

     * <p>

     * Active {@link Behavior Behavior} that will generate events according a

     * criterion, and then, with a {@link ToolListener ToolListener} associated,

     * will simulate to user that works with this component as a particular

     * tool.

     * </p>

     * 

     * @see #getCurrentMapTool()

     * @see #getCurrentTool()

     * @see #setTool(String)

     */

    protected Behavior currentMapTool = null;

    /**

     * <p>

     * Determines which's the current drawn status of this component:

     * <ul>

     * <li><b>OUTDATED</b>: all visible information has been drawn or isn't

     * updated.</li>

     * <li><b>UTDATED</b>: all visible information has been drawn and its

     * updated.</li>

     * <li><b>ONLY_GRAPHICS</b>: only the graphical layer must be drawn /

     * updated.</li>

     * </ul>

     * </p>

     * 

     * <p>

     * The <code>MapControl</code> drawing process will consider the value of

     * this parameter to decide which elements will be updated or drawn.

     * </p>

     */

    private int status = DESACTUALIZADO;

    /**

     * <p>

     * Image with a buffer to accelerate the draw the changes of the graphical

     * items in this component.

     * </p>

     * 

     * <p>

     * Firstly, information will be drawn in the buffer, and, when is outright

     * drawn, that information will be displayed. Meanwhile, the previous image

     * can be kept showed.

     * </p>

     * 

     * @see BufferedImage

     * 

     * @see #getImage()

     */

    private BufferedImage image = null;

    /**

     * <p>

     * Name of the tool used currently to interact with this component.

     * </p>

     * 

     * @see #getCurrentTool()

     * @see #setTool(String)

     */

    protected String currentTool;

    /**

     * <p>

     * Object to store the flag that notifies a drawing thread task and

     * <code>MapContext</code>'s layers, that must be canceled or can continue

     * with the process.

     * </p>

     * 

     * @see #cancelDrawing()

     */

    private CancelDraw canceldraw;

    // private boolean isCancelled = true;

    /**

     * <p>

     * Fires an action events after a specified delay.

     * </p>

     * 

     * <p>

     * <code>MapControl</code> will use the timer to update its visible

     * graphical information during a drawing process, or allowing to cancel

     * that process.

     * </p>

     * 

     * <p>

     * This is very useful to pretend faster interactivity to user when

     * <code>MapControl</code> has lots of layers, and / or layers with heavy

     * graphical elements, that need a long time to finish drawing all its data.

     * </p>

     */

    private Timer timer;

    /**

     * <p>

     * Reference to the {@link ViewPort ViewPort} of the {@link MapContext

     * MapContext} of this component.

     * </p>

     * 

     * <p>

     * After, the view port will change adapting itself according the current

     * projection and the extent.

     * </p>

     * 

     * @see #getViewPort()

     * 

     * @see ViewPort

     */

    protected ViewPort vp;

    /**

     * <p>

     * Manager of all <code>MapControl</code> painting requests.

     * </p>

     */

    private Drawer drawer;

    /**

     * <p>

     * Listener of all kind of mouse events produced in this component.

     * </p>

     * 

     * <p>

     * Delegates each mouse event to the current map tool.

     * </p>

     * 

     * @see #addBehavior(String, Behavior)

     * @see #addBehavior(String, Behavior[])

     * @see #getMapTool(String)

     * @see #getMapToolsKeySet()

     * @see #getNamesMapTools()

     * @see #setTool(String)

     */

    protected MapToolListener mapToolListener = new MapToolListener();

    /**

     * <p>

     * Listener of all events produced in a this component's

     * <code>MapContext</code> object during an atomic period of time.

     * </p>

     */

    private MapContextListener mapContextListener = new MapContextListener();

    /**

     * <p>

     * Group of <code>ExceptionListener</code> that, in whatever moment could be

     * notified a Throwable Java error or exception.

     * </p>

     * 

     * @see #addExceptionListener(ExceptionListener)

     * @see #removeExceptionListener(ExceptionListener)

     */

    private ExceptionHandlingSupport exceptionHandlingSupport =

        new ExceptionHandlingSupport();

    /**

     * <p>

     * Name of the previous tool used.

     * </p>

     */

    protected String prevTool;

    /**

     * <p>

     * Tool that will be used combined with the current tool of this

     * <code>MapControl</code>.

     * </p>

     */

    private Behavior combinedTool = null;

    /**

     * Optional grid that could be applied on the <code>MapControl</code>'s view

     * port.

     * 

     * @see #getGrid()

     * @see #setAdjustGrid(boolean)

     */

    private Grid cadgrid = new Grid();

    /**

     * Represents the cursor's point selected in <i>screen coordinates</i>.

     * 

     * @see ViewPort#fromMapPoint(Point2D)

     */

    private Point2D adjustedPoint;

    /**

     * <p>

     * Determines if the position of the snap of the mouse's cursor on the

     * <code>MapControl</code> is within the area around a control point of a

     * geometry.

     * </p>

     * 

     * <p>

     * The area is calculated as a circle centered at the control point and with

     * radius the pixels tolerance defined in the preferences.

     * </p>

     */

    private boolean bForceCoord = false;

    /**

     * Kind of geometry drawn to identify the kind of control point selected by

     * the cursor's mouse.

     */

    private ISnapper usedSnap = null;

    /**

     * Determines if the snap tools are enabled or disabled.

     * 

     * @see #isRefentEnabled()

     * @see #setRefentEnabled(boolean)

     */

    private boolean bRefent = true;

    /**

     * Stores the 2D map coordinates of the last point added.

     */

    private double[] previousPoint = null;

    protected static MapControlManager mapControlManager =

        MapControlLocator.getMapControlManager();

    private static TreeMap selected = new TreeMap(new Comparator() {

        public int compare(Object o1, Object o2) {

            if (o1.getClass().equals(o2.getClass()))

                return 0;

            if (((ISnapper) o1).getPriority() > ((ISnapper) o2).getPriority())

                return 1;

            else

                return -1;

        }

    });

    /**

     * Represents the cursor's point selected in <i>map coordinates</i>.

     * 

     * @see MapControl#toMapPoint

     */

    private Point2D mapAdjustedPoint;

    /**

     * Renderer used to draw the layers.

     */

    private MapControlDrawer mapControlDrawer = null;

	private Cursor transparentCursor;

	private boolean disposed = false;

    /**

     * <p>

     * Creates a new <code>MapControl</code> instance with the following

     * characteristics:

     * <ul>

     * <li><i>Name</i>: MapControl .</li>

     * <li>Disables the double buffer of <code>JComponent</code> .</li>

     * <li>Sets opaque <i>(see {@link JComponent#setOpaque(boolean)} )</i>.</li>

     * <li>Sets its status to <code>OUTDATED</code> .</li>

     * <li>Creates a new {@link CancelDraw CancelDraw} object to notify

     * <code>MapContext</code>'s layers if can continue processing the drawn or

     * must cancel it.</li>

     * <li>Creates a new {@link MapContext MapContext} with a new

     * {@link ViewPort ViewPort} in the default projection.</li>

     * <li>Creates a new {@link CommandListener CommandListener} for edition

     * operations.</li>

     * <li>Creates a new {@link MapToolListener MapToolListener}, and associates

     * it as a listener of whatever kind of mouse events produced in this

     * component.</li>

     * <li>Creates a new {@link Drawer2 Drawer2} for managing the painting

     * requests.</li>

     * <li>Creates a new timer that will invoke refresh this component

     * <code>drawFrameRate</code> per second, when is running a drawing process,

     * and its enabled <code>drawAnimationEnabled</code>.</li>

     * </ul>

     * </p>

     */

    public MapControl() {

        this.setName("MapControl");

        Toolkit toolkit = Toolkit.getDefaultToolkit();

        Image imageTransparentCursor = toolkit.createImage(new MemoryImageSource(16, 16, new int[16 * 16], 0,16));

        transparentCursor =

            toolkit.createCustomCursor(imageTransparentCursor, new Point(0, 0), "invisiblecursor");

        setDoubleBuffered(false);

        setOpaque(true);

        status = DESACTUALIZADO;

        // Clase usada para cancelar el dibujado

        canceldraw = new CancelDraw();

        /*

         * We are not accessing the user preferences here.

         * This is an early initialization and is supposed

         * to be reset afterwards from a higher level (plugin)

         */

        MapContextManager mcm = MapContextLocator.getMapContextManager();

        vp = new ViewPort(mcm.getDefaultCRS());

        setMapContext(new MapContext(vp));

        // eventos

        this.addComponentListener(this);

        this.addMouseListener(mapToolListener);

        this.addMouseMotionListener(mapToolListener);

        this.addMouseWheelListener(mapToolListener);

        this.drawer = new Drawer();

        // Timer para mostrar el redibujado mientras se dibuja

        timer =

            new Timer(1000 / MapContext.getDrawFrameRate(),

                new ActionListener() {

                    public void actionPerformed(ActionEvent e) {

                        if (drawAnimationEnabled) {

                            MapControl.this.repaint();

                        }

                    }

                });

        initializeGrid();

        if(ToolsLocator.getDisposableManager() != null) {

			ToolsLocator.getDisposableManager().bind(this);

		} else {

			LOG.warn("Can't retrieve the disposable manager,");

		}

    }

    /**

     * <p>

     * Sets a <code>MapContext</code> to this component.

     * </p>

     * 

     * <p>

     * The <code>MapContext</code> has the <i>model</i>, and most of the

     * <i>view</i>, and <i>control</i> logic of the layers of this component,

     * including a {@link ViewPort ViewPort} to adapt the information to the

     * projection, and to display it in the available area.

     * </p>

     * 

     * <p>

     * If <code>model</code> hadn't a <code>ViewPort</code>, assigns the current

     * one to it, otherwise, use its <code>ViewPort</code>.

     * </p>

     * 

     * <p>

     * After assigning the <code>MapContext</code> and <code>ViewPort</code>,

     * sets the same {@link MapContextListener MapContextListener} that was

     * using, and changes the <i>status</i> to <code>OUTDATED</code>.

     * </p>

     * 

     * @param model

     *            this component's <code>MapContext</code>, that includes the

     *            <code>ViewPort</code>.

     * 

     * @see MapContext

     * 

     * @see #getMapContext()

     */

    public void setMapContext(MapContext model) {

        if (mapContext != null) {

            mapContext.removeAtomicEventListener(mapContextListener);

            mapContext.dispose();

        }

        mapContext = model;

        if (mapContext.getViewPort() == null) {

            mapContext.setViewPort(vp);

        } else {

            vp = mapContext.getViewPort();

            cadgrid.setViewPort(vp);

        }

        mapContext.addAtomicEventListener(mapContextListener);

        status = DESACTUALIZADO;

    }

    /**

     * @return the mapControlDrawer

     */

    public MapControlDrawer getMapControlDrawer() {

        return mapControlDrawer;

    }

    /**

     * @param mapControlDrawer

     *            the mapControlDrawer to set

     */

    public void setMapControlDrawer(MapControlDrawer mapControlDrawer) {

        this.mapControlDrawer = mapControlDrawer;

        this.mapControlDrawer.setViewPort(vp);

    }

    /**

     * <p>

     * Gets this component's {@link MapContext MapContext} projection.

     * </p>

     * 

     * @return this component's {@link MapContext MapContext} projection

     * 

     * @see MapContext#getProjection()

     * @see MapControl#setProjection(IProjection)

     */

    public IProjection getProjection() {

        return getMapContext().getProjection();

    }

    /**

     * <p>

     * Sets the projection to this component's {@link MapContext MapContext}.

     * </p>

     * 

     * @param proj

     *            the kind of projection to this component's {@link MapContext

     *            MapContext}

     *