/ - Diff - Application: gvSIG desktop - gvSIG

Revision 39986

     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 java.util.Map;
     import java.util.prefs.Preferences;
     import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;
     import org.gvsig.fmap.mapcontrol.swing.dynobject.LayersDynObjectSetComponent;
     import org.gvsig.fmap.mapcontrol.tools.snapping.snappers.ISnapper;
     import org.gvsig.tools.dynobject.DynObject;
     import org.gvsig.tools.dynobject.DynObjectSet;
     /**
      * <p>
      * This class is the manager of the MapControl library. It is used to
      * manage all the properties related with the drawing of objects
      * in a map, including default symbols used to draw objects
      * in a map, the tolerance used by the selection or edition tools...
      * </p>
      * <p>
      * It also holds the implementations of the {@link MapControlDrawer}'s,
      * that is the responsible to draw graphical objects in a map.
      * </p>
      * @author <a href="mailto:jpiera@gvsig.org">Jorge Piera</a>
      */
     public interface MapControlManager {
     	public MapControl createJMapControlPanel() throws MapControlCreationException;
     	/**
     	 * Register a <code>MapControlDrawer</code> by name.
     	 * @param name
     	 * Name of the <code>MapControlDrawer</code>.
     	 * @param mapControolDrawerClass
     	 * Class used to draw graphical objects on a map.
     	 */
     	public void registerMapControlDrawer(String name, Class mapControolDrawerClass);
     	/**
     	 * Creates a <code>MapControlDrawer</code> from a name.
     	 * @param name
     	 * Name of the <code>MapControlDrawer</code>.
     	 * @return
     	 * A <code>MapControlDrawer</code>.
     	 * @throws MapControlCreationException
     	 */
     	public MapControlDrawer createMapControlDrawer(String name) throws MapControlCreationException;
     	/**
     	 * It registers the default implementation for the <code>MapControlDrawer</code>.
     	 * @param mapControlDrawerClass
     	 * A <code>MapControlDrawer</code>.
     	 */
     	public void registerDefaultMapControlDrawer(Class mapControlDrawerClass);
     	/**
     	 * It returns the default implementation for the <code>MapControlDrawer</code>.
     	 * @return
     	 * The default <code>MapControlDrawer</code>.
     	 * @throws MapControlCreationException
     	 */
     	public MapControlDrawer createDefaultMapControlDrawer() throws MapControlCreationException;
     	/**
     	 * Returns a snapper in a concrete position;
     	 * @param index
     	 * Snapper position.
     	 * @return
     	 * A snapper.
     	 */
     	public ISnapper getSnapperAt(int index);
     	/**
     	 * Returns the number of registered snappers.
     	 * @return
     	 * The number of registered snappers.
     	 */
     	public int getSnapperCount();
     	/**
     	 * Add a snapper.
     	 * @param snapper
     	 */
     	public void registerSnapper(String name, Class snapperClass);
     	public Preferences getEditionPreferences();
     	/**
     	 * Tolerance (in pixels) that has to be used by the tools
     	 * that use snapping.
     	 * @return
     	 * The distance in pixels.
     	 */
     	public int getTolerance();
     	/**
     	 * Sets the tolerance (in pixels) that has to be used by the
     	 * tools that use snapping.
     	 * @param tolerance
     	 * The tolerance to apply
     	 */
     	public void setTolerance(int tolerance);
     	/**
     	 * Sets the symbol that has to be used to draw a geometry when
     	 * it is selected.
     	 * @param selectionSymbol
     	 * The symbol to apply.
     	 * @deprecated the symbol for edition is the selection symbol
     	 */
     	public void setSelectionSymbol(ISymbol selectionSymbol);
     	/**
     	 * Gets the symbol used to draw the selected geometries.
     	 * @return
     	 * The symbol used to draw the selected geometries.
     	 * @deprecated the symbol for edition is the selection symbol
     	 */
     	public ISymbol getSelectionSymbol();
     	/**
     	 * Sets the symbol that has to be used to draw a geometry that
     	 * represent the axis of a geometry.
     	 * @param axisReferencesSymbol
     	 * The symbol to apply.
     	 */
     	public void setAxisReferenceSymbol(ISymbol axisReferencesSymbol);
     	/**
     	 * Gets the symbol used to draw the axis of a geometry.
     	 * @return
     	 * The symbol used to draw the axis of a geometry.
     	 */
     	public ISymbol getAxisReferenceSymbol();
     	/**
     	 * Sets the symbol that has to be used to draw a geometry when
     	 * it is selected.
     	 * @param geometrySelectionSymbol
     	 * The symbol to apply.
     	 */
     	public void setGeometrySelectionSymbol(ISymbol geometrySelectionSymbol);
     	/**
     	 * Gets the symbol used to draw the selected geometries.
     	 * @return
     	 * The symbol used to draw the selected geometries.
     	 */
     	public ISymbol getGeometrySelectionSymbol();
     	/**
     	 * Sets the symbol that has to be used to draw the handlers.
     	 * @param handlerSymbol
     	 * The symbol to apply.
     	 */
     	public void setHandlerSymbol(ISymbol handlerSymbol);
     	/**
     	 * Gets the symbol used to draw the handlers.
     	 * @return
     	 * The symbol used to draw the handlers.
     	 */
     	public ISymbol getHandlerSymbol();
         /**
          * Creates a readonly component to view information of a set of layers. The
          * information must be provided as a set of {@link DynObject}s, through a
          * {@link DynObjectSet}.
+         *
          * @param layerName2InfoByPoint
          *            the map of {@link DynObjectSet} for each layer.
          * @return the component to view the information
          */
         public LayersDynObjectSetComponent createLayersDynObjectSetComponent(
             Map<String, DynObjectSet> layerName2InfoByPoint);
         /**
          * Creates a component to view information of a set of layers. The
          * information must be provided as a set of {@link DynObject}s, through a
          * {@link DynObjectSet}.
+         *
          * @param layerName2InfoByPoint
          *            the map of {@link DynObjectSet} for each layer.
          * @param writable
          *            if the DynObjects loaded must be able to be edited
          * @return the component to view the information
          */
         public LayersDynObjectSetComponent createLayersDynObjectSetComponent(
             Map<String, DynObjectSet> layerName2InfoByPoint, boolean writable);
+    }

     /* 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}
+         *
          * @see MapContext#setProjection(IProjection)
          * @see MapControl#getProjection()
          */
         public void setProjection(IProjection proj) {
             getMapContext().setProjection(proj);
+        }
         /**
          * <p>
          * Gets this component's <code>MapContext</code>, with 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 display it in the available area.
          * </p>
+         *
          * @return this component's <code>MapContext</code>, that includes the
          *         <code>ViewPort</code> used to project the
          *         graphical information, and display it in the available area
+         *
          * @see MapContext
+         *
          * @see MapControl#setMapContext(MapContext)
          */
         public MapContext getMapContext() {
             return mapContext;
+        }
         /**
          * <p>
          * Registers a new behavior to this component.
          * </p>
+         *
          * <p>
          * According the nature of the {@link Behavior Behavior}, different events
          * will be generated. Those events can be caught by a particular
          * {@link ToolListener ToolListener}, allowing user to interact with this
          * <code>MapControl</code> object as a <i>tool</i>.
          * </p>
+         *
          * @param name
          *            name to identify the behavior to add
          * @param tool
          *            the behavior to add
+         *
          * @see #addBehavior(String, Behavior[])
          * @see #getNamesMapTools()
          * @see #getMapToolsKeySet()
          * @see #hasTool(String)
          */
         public void addBehavior(String name, Behavior tool) {
             namesMapTools.put(name, tool);
             tool.setMapControl(this);
+        }
         /**
          * <p>
          * Registers a new behavior to this component as a {@link CompoundBehavior
          * CompoundBehavior} made up of <code>tools</code>.
          * </p>
+         *
          * <p>
          * According the nature of the behaviors registered, different events will
          * be generated. Those events can be caught by a particular
          * {@link ToolListener ToolListener}, allowing user to interact with this
          * <code>MapControl</code> object as a <i>tool</i>.
          * </p>
+         *
          * @param name
          *            name to identify the compound behavior to add
          * @param tools
          *            the compound behavior to add
+         *
          * @see #addBehavior(String, Behavior)
          * @see #getNamesMapTools()
          * @see #getMapToolsKeySet()
          * @see #hasTool(String)
          */
         public void addBehavior(String name, Behavior[] tools) {
             CompoundBehavior tool = new CompoundBehavior(tools);
             addBehavior(name, tool);
+        }
         /**
          * <p>
          * Gets the <code>Behavior</code> registered in this component, identified
          * by <code>name</code>.
          * </p>
+         *
          * @param name
          *            name of a registered behavior
+         *
          * @return tool the registered behavior in this component as
          *         <code>name</code>, or <code>null</code> if
          *         no one has that identifier
+         *
          * @see #addBehavior(String, Behavior)
          * @see #addBehavior(String, Behavior[])
          * @see #hasTool(String)
          */
         public Behavior getMapTool(String name) {
             return (Behavior) namesMapTools.get(name);
+        }
         /**
          * <p>
          * Returns a set view of the keys that identified the tools registered.
          * </p>
+         *
          * @return a set view of the keys that identified the tools registered
+         *
          * @see HashMap#keySet()
+         *
          * @see #getNamesMapTools()
          * @see #addBehavior(String, Behavior)
          * @see #addBehavior(String, Behavior[])
          */
         public Set getMapToolsKeySet() {
             return namesMapTools.keySet();
+        }
         /**
          * <p>
          * Returns <code>true</code> if this component contains a tool identified by
          * <code>toolName</code>.
          * </p>
+         *
          * @param toolName
          *            identifier of the tool
+         *
          * @return <code>true</code> if this component contains a tool identified by
          *         <code>toolName</code>; otherwise <code>false</code>
+         *
          * @see #addBehavior(String, Behavior)
          * @see #addBehavior(String, Behavior[])
          */
         public boolean hasTool(String toolName) {
             return namesMapTools.containsKey(toolName);
+        }
         /**
          * <p>
          * Sets as current active <code>Behavior</code> associated to this
          * component, that one which is registered and identified by
          * <code>toolName</code>.
          * </p>
+         *
          * <p>
          * Changing the current active behavior for this <code>MapControl</code>,
          * implies also updating the previous <i>behavior</i> tool, and the current
          * cursor.
          * </p>
+         *
          * @param toolName
          *            name of a registered behavior
+         *
          * @see #getCurrentMapTool()
          * @see #getCurrentTool()
          */
         public void setTool(String toolName) {
             prevTool = getCurrentTool();
             Behavior mapTool = (Behavior) namesMapTools.get(toolName);
             currentMapTool = mapTool;
             currentTool = toolName;
             if (combinedTool != null) {
                 if (mapTool instanceof CompoundBehavior) {
                     ((CompoundBehavior) mapTool).addMapBehavior(combinedTool, true);
                 } else {
                     currentMapTool =
                         new CompoundBehavior(new Behavior[] { currentMapTool });
                     ((CompoundBehavior) currentMapTool).addMapBehavior(
                         combinedTool, true);
+                }
+            }
             // this.setCursor(mapTool.getCursor());
+        }
         /**
          * <p>
          * Gets as current active <code>Behavior</code> associated to this
          * component, that one which is registered and identified by
          * <code>toolName</code>.
          * </p>
+         *

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff