/branches/v2_0_0_prep/libraries/libFMap_controls/src/org/gvsig/fmap/mapcontrol/MapControl.java - Diff - | gvSIG desktop 1 - gvSIG

Revision 30327 branches/v2_0_0_prep/libraries/libFMap_controls/src/org/gvsig/fmap/mapcontrol/MapControl.java

     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.Set;
     import java.util.TreeMap;
     import java.util.prefs.Preferences;
     import javax.swing.JComponent;
-...
     import org.gvsig.utils.exceptionHandling.ExceptionListener;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     import java.util.TreeMap;
     import java.util.Comparator;
     /**
      * <p>A component that includes a {@link MapContext MapContext} with support for use it as a particular {@link Behavior Behavior}.</p>
+     *
-...
      *   <ul>
      *    <li>Register each tool as:
      *     <ul>
      *      <li>A single behavior: {@link #addMapTool(String, Behavior) #addMapTool(String, Behavior)}.</li>
      *      <li>Or, a compound behavior: {@link #addMapTool(String, Behavior) #addMapTool(String, Behavior)}.</li>
      *      <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>
-...
      * </p>
+     *
      * @see CancelDraw
      * @see Drawer2
      * @see Drawer
      * @see MapContextListener
      * @see MapToolListener
+     *
-...
      * @author Pablo Piqueras Bartolom? (pablo.piqueras@iver.es)
      */
     public class MapControl extends JComponent implements ComponentListener, Observer {
     	private static final GeometryManager geomManager = GeometryLocator.getGeometryManager();
     	private static final Logger logger = LoggerFactory.getLogger(GeometryManager.class);
     	protected static final GeometryManager geomManager = GeometryLocator.getGeometryManager();
     	protected static final Logger logger = LoggerFactory.getLogger(GeometryManager.class);
     	/**
     	 * <p>One of the possible status of <code>MapControl</code>. Determines that all visible information has been
-...
     	 */
     	public static final int ONLY_GRAPHICS = 2;
         /**
          * <p>Determines if the drawer can update this <code>MapControl</code> instance when the timer launches an event.</p>
          */
         private static boolean drawAnimationEnabled = true;
         // public static final int FAST_PAINT = 3;
     	//private static Logger logger = Logger.getLogger(MapControl.class.getName());
         /**
          * <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>
-...
          */
         private MapContext mapContext = null;
         //private boolean drawerAlive = false;
     	/**
         /**
     	 * <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 #addMapTool(String, Behavior)
     	 * @see #addMapTool(String, Behavior[])
     	 * @see #addBehavior(String, Behavior)
     	 * @see #addBehavior(String, Behavior[])
     	 * @see #getMapTool(String)
     	 * @see #getMapToolsKeySet()
     	 * @see #getNamesMapTools()
-...
     	 */
         protected ViewPort vp;
         //private Drawer drawer;
     	/**
     	 * <p>Manager of all <code>MapControl</code> painting requests.</p>
     	 */
         private Drawer2 drawer2;
         private Drawer drawer;
         // private boolean firstDraw = true;
     	/**
     	 * <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 #addMapTool(String, Behavior)
     	 * @see #addMapTool(String, Behavior[])
     	 * @see #addBehavior(String, Behavior)
     	 * @see #addBehavior(String, Behavior[])
     	 * @see #getMapTool(String)
     	 * @see #getMapToolsKeySet()
     	 * @see #getNamesMapTools()
-...
     	 * <p>Tool that will be used combined with the current tool of this <code>MapControl</code>.</p>
     	 */
     	private Behavior combinedTool = null;
     	/**
          * We need this to avoid not wanted refresh. REMEMBER TO SET TO TRUE!!
          */
         // private boolean paintEnabled = false;
     	/**
     	 * Edition preferences.
     	 */
     	private static Preferences prefs = Preferences.userRoot().node( "cadtooladapter" );
     	/**
     	 * Optional grid that could be applied on the <code>MapControl</code>'s view port.
+    	 *
     	 * @see #getGrid()
-...
     	 *  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;
     	/**
     	 * A light yellow color for the tool tip text box associated to the point indicated by the mouse's cursor.
     	 */
     	private Color theTipColor = new Color(255, 255, 155);
     	/**
     	 * Determines if the snap tools are enabled or disabled.
-...
     	 */
     	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) {
-...
     	});
     	public static int tolerance=4;
     	/**
     	 * Represents the cursor's point selected in <i>map coordinates</i>.
+    	 *
-...
     	private Point2D mapAdjustedPoint;
     	/**
     	 * Renderer used to draw the layers.
     	 */
     	private MapControlDrawer mapControlDrawer = null;
     	/**
     	 * <p>Creates a new <code>MapControl</code> instance with the following characteristics:
     	 * <ul>
     	 *  <li><i>Name</i>: MapControl .</li>
-...
     		this.addMouseMotionListener(mapToolListener);
     		this.addMouseWheelListener(mapToolListener);
             this.drawer2 = new Drawer2();
             this.drawer = new Drawer();
     		//Timer para mostrar el redibujado mientras se dibuja
     		timer = new Timer(1000/MapContext.getDrawFrameRate(),
     				new ActionListener() {
-...
     		} else {
     			vp = mapContext.getViewPort();
     			cadgrid.setViewPort(vp);
     			// vp.setImageSize(new Dimension(getWidth(), getHeight()));
     			//System.err.println("Viewport en setMapContext:" + 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
-...
     	 * @param name name to identify the behavior to add
     	 * @param tool the behavior to add
+    	 *
     	 * @see #addMapTool(String, Behavior[])
     	 * @see #addBehavior(String, Behavior[])
     	 * @see #getNamesMapTools()
     	 * @see #getMapToolsKeySet()
     	 * @see #hasTool(String)
     	 */
     	public void addMapTool(String name, Behavior tool) {
     	public void addBehavior(String name, Behavior tool) {
     		namesMapTools.put(name, tool);
     		tool.setMapControl(this);
+    	}
-...
     	 * @param name name to identify the compound behavior to add
     	 * @param tools the compound behavior to add
+    	 *
     	 * @see #addMapTool(String, Behavior)
     	 * @see #addBehavior(String, Behavior)
     	 * @see #getNamesMapTools()
     	 * @see #getMapToolsKeySet()
     	 * @see #hasTool(String)
     	 */
     	public void addMapTool(String name, Behavior[] tools){
     	public void addBehavior(String name, Behavior[] tools){
     		CompoundBehavior tool = new CompoundBehavior(tools);
     		addMapTool(name, tool);
     		addBehavior(name, tool);
+    	}
     	/**
-...
     	 * @return tool the registered behavior in this component as <code>name</code>, or <code>null</code> if
     	 *  no one has that identifier
+    	 *
     	 * @see #addMapTool(String, Behavior)
     	 * @see #addMapTool(String, Behavior[])
     	 * @see #addBehavior(String, Behavior)
     	 * @see #addBehavior(String, Behavior[])
     	 * @see #hasTool(String)
     	 */
     	public Behavior getMapTool(String name) {
-...
     	 * @see HashMap#keySet()
+    	 *
     	 * @see #getNamesMapTools()
      	 * @see #addMapTool(String, Behavior)
      	 * @see #addMapTool(String, Behavior[])
      	 * @see #addBehavior(String, Behavior)
      	 * @see #addBehavior(String, Behavior[])
     	 */
     	public Set getMapToolsKeySet() {
     		return namesMapTools.keySet();
-...
+    	 *
     	 * @return <code>true</code> if this component contains a tool identified by <code>toolName</code>; otherwise <code>false</code>
+    	 *
     	 * @see #addMapTool(String, Behavior)
     	 * @see #addMapTool(String, Behavior[])
     	 * @see #addBehavior(String, Behavior)
     	 * @see #addBehavior(String, Behavior[])
     	 */
     	public boolean hasTool(String toolName) {
     		return namesMapTools.containsKey(toolName);
-...
       	 * @see Drawer2
     	 */
     	protected void paintComponent(Graphics g) {
             adaptToImageSize();
             /* if (status == FAST_PAINT) {
                 System.out.println("FAST_PAINT");
                 g.drawImage(image,0,0,null);
                 status = ACTUALIZADO;
                 return;
             } */
             // System.out.println("PINTANDO MAPCONTROL" + this);
     		adaptToImageSize();
     		mapControlDrawer.setGraphics(g);
     		mapControlDrawer.setViewPort(getMapContext().getViewPort());
     		if (status == ACTUALIZADO) {
     			// LWS logger.debug("Dibujando la imagen obtenida");
     			/*
     			 * Si hay un behaviour y la imagen es distinta de null se delega el dibujado
     			 * en dicho behaviour
     			 */
                 if (image != null)
+                {
                     if (currentMapTool != null) {
     					currentMapTool.paintComponent(g);
     			if (image != null)
+    			{
     				if (currentMapTool != null) {
     					currentMapTool.paintComponent(mapControlDrawer);
     				} else {
     					g.drawImage(image,0,0,null);
+    				}
     				// System.out.println("Pinto ACTUALIZADO");
     					mapControlDrawer.drawImage(image,0,0);
+    				}
+    			}
     		} else if ((status == DESACTUALIZADO)
                     || (status == ONLY_GRAPHICS)) {
     			// LWS System.out.println("DESACTUALIZADO: Obteniendo la imagen de la cartograf?a");
     			/* if (isOpaque())
+    			{
     			    if (image==null)
+    			    {
     			        g.setColor(vp.getBackColor());
     			        g.fillRect(0,0,getWidth(), getHeight());
+    			    }
     			    // else g.drawImage(image,0,0,null);
     			} */
                 // cancelDrawing();
     			//Se crea la imagen con el color de fonde deseado
     			/* if (image == null)
+    			{
     				image = new BufferedImage(this.getWidth(), this.getHeight(),
     						BufferedImage.TYPE_INT_ARGB);
     				vp.setImageSize(new Dimension(getWidth(), getHeight()));
     				Graphics gTemp = image.createGraphics();
     			    Color theBackColor = vp.getBackColor();
     			    if (theBackColor == null)
     			        gTemp.setColor(Color.WHITE);
     			    else
     			        gTemp.setColor(theBackColor);
     				|| (status == ONLY_GRAPHICS)) {
     			mapControlDrawer.drawImage(image,0,0);
     				gTemp.fillRect(0,0,getWidth(), getHeight());
     				gTemp.dispose();
     				// g.drawImage(image,0,0,null);
     				System.out.println("Imagen con null en DESACTUALIZADO. Width = " + this.getWidth());
     			} */
                 // else
                 // {
                 // if (image != null)
                 //  {
                     g.drawImage(image,0,0,null);
                     drawer2.put(new PaintingRequest());
                     timer.start();
                 /* }
                 else
                     return; */
                 // }
                 /* if (drawerAlive == false)
+                {
                     drawer = new Drawer(image, canceldraw);
                     drawer.start();
     			//Se lanza el tread de dibujado
                 } */
     			// status = ACTUALIZADO;
     			drawer.put(new PaintingRequest());
     			timer.start();
+    		}
     		cadgrid.drawGrid(g);
     		drawCursor(g);
-...
+         *
          * @author fjp
          */
         public class Drawer2
         public class Drawer
+        {
             // Una mini cola de 2. No acumulamos peticiones de dibujado
             // dibujamos solo lo ?ltimo que nos han pedido.
-...
              *  </ul>
              * </p>
              */
             public Drawer2()
             public Drawer()
+            {
                 paintingRequest = null;
                 waitingRequest = null;
-...
+                }
+            }
+        }
     	/**
     	 * <p><code>Drawer</code> is implemented for drawing the layers of a <code>MapControl</code>'s <i>MapContext</i> instance
     	 *  as a <i>thread</i> of execution.</p>
+    	 *
     	 * <p>Draws <code>MapControl</code> according its <i>status</i>:
     	 *  <ul>
     	 *   <li><code><i>ONLY_GRAPHICS</i></code>: refreshes only the graphical layer, changing the status to <code><i>UPDATED</i></code>, via
     	 *    {@linkplain MapContext#drawGraphics(BufferedImage, Graphics2D, Cancellable, double) MapContext#drawGraphics(BufferedImage, Graphics2D, Cancellable, double)}.</li>
     	 *   <li><code><i>OUTDATED</i></code>: refreshes all layers, changing the status to <code><i>UPDATED</i></code>, via
     	 *    {@linkplain MapContext#draw(BufferedImage, Graphics2D, Cancellable, double) MapContext#draw(BufferedImage, Graphics2D, Cancellable, double)}.</li>
     	 *  <ul>
     	 * </p>
+    	 *
     	 * <p>This drawing process is accelerated by a <code>BufferedImage</code>, and can be canceled.</p>
+    	 *
     	 * <p>Once the drawing process has finished, the timer stops and this component gets repainted.</p>
+    	 *
     	 * @deprecated
     	 * @author Vicente Caballero Navarro
     	 */
     	public class Drawer extends Thread {
     		//private Graphics g;
     		/**
     		 * <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
     		 */
     		private BufferedImage image = null;
     		/**
     		 * <p>Object to store the flag that notifies the drawing must be canceled or can continue with the process.</p>
+    		 *
     		 * <p>At last resort, the particular implementation of each layer in a <code>MapControl</code>'s <code>MapContrext</code>
              *   will be which will draw the graphical information, and, if supports, which could cancel its drawing subprocess.</p>
     		 */
     		private CancelDraw cancel;
     		//private boolean threadCancel = false;
     		/**
     		 * <p>Creates a new <code>Drawer</code> instance.</p>
     		 */
     		public Drawer(BufferedImage image, CancelDraw cancel)
+            {
     			this.image = image;
     			this.cancel = cancel;
              //   drawerAlive = true;
+    		}
     		/**
     		 * @see java.lang.Runnable#run()
     		 * @see MapContext#draw(BufferedImage, Graphics2D, Cancellable, double)
     		 * @see MapContext#drawGraphics(BufferedImage, Graphics2D, Cancellable, double)
     		 */
     		public void run() {
     			try {
     				// synchronized (Drawer.class) {
     				    Graphics2D g = image.createGraphics();
     				    ViewPort viewPort = mapContext.getViewPort();
                         if (status == DESACTUALIZADO)
+                        {
         				    Color theBackColor = viewPort.getBackColor();
         				    if (theBackColor == null) {
     							g.setColor(Color.WHITE);
     						} else {
     							g.setColor(theBackColor);
+    						}
         					g.fillRect(0, 0, viewPort.getImageWidth(), viewPort.getImageHeight());
                             status = ACTUALIZADO;
                             mapContext.draw(image, g, cancel,mapContext.getScaleView());
+                        }
                         else if (status == ONLY_GRAPHICS)
+                        {
                             status = ACTUALIZADO;
                             mapContext.drawGraphics(image, g, cancel,mapContext.getScaleView());
+                        }
     					timer.stop();
                         // status = FAST_PAINT;
                       //  drawerAlive = false;
     					repaint();
     				// }
     			} catch (Throwable e) {
     			    timer.stop();
     				//isCancelled = true;
                     e.printStackTrace();
     				throwException(e);
     			} finally {
+    			}
+    		}
+    	}
     	/**
     	 * <p>An instance of <code>CancelDraw</code> will be shared by all this <code>MapControl</code>'s <code>MapContext</code> layers,
     	 *  allowing receive a notification that, when they're been drawn, to be cancelled.</p>
+    	 *
-...
     		 * @see Behavior#mouseEntered(MouseEvent)
     		 */
     		public void mouseEntered(MouseEvent e) {
     			clearMouseImage();
     			setToolMouse();
     			try {
     				if (currentMapTool != null) {
     					currentMapTool.mouseEntered(e);
-...
     			} catch (BehaviorException t) {
     				throwException(t);
+    			}
     			//Remove the snapping image if exist
     			usedSnap = null;
     			repaint();
+    		}
     		/**
-...
+    	 *
     	 * @return registered <code>Behavior</code> to this <code>MapControl</code>
+    	 *
     	 * @see #addMapTool(String, Behavior)
     	 * @see #addMapTool(String, Behavior[])
     	 * @see #addBehavior(String, Behavior)
     	 * @see #addBehavior(String, Behavior[])
     	 * @see #getMapToolsKeySet()
     	 * @see #hasTool(String)
     	 */
-...
+    	 *
     	 * <p>Exchanges the previous tool with the current one.</p>
+    	 *
     	 * @see #addMapTool(String, Behavior)
     	 * @see #addMapTool(String, Behavior[])
     	 * @see #addBehavior(String, Behavior)
     	 * @see #addBehavior(String, Behavior[])
     	 * @see #setTool(String)
     	 */
     	public void setPrevTool() {
-...
     	 * @see #getCurrentTool()
     	 * @see #setTool(String)
     	 * @see #setPrevTool()
     	 * @see #addMapTool(String, Behavior)
     	 * @see #addMapTool(String, Behavior[])
     	 * @see #addBehavior(String, Behavior)
     	 * @see #addBehavior(String, Behavior[])
     	 */
     	public void setCurrentMapTool(Behavior mapTool ){
     		currentMapTool = mapTool;
-...
+    	 *
     	 * @param tool a new tool to be used combined with the current tool
     	 */
     	public void addCombinedTool(Behavior tool) {
     	public void addCombinedBehavior(Behavior tool) {
     		if (combinedTool == null) {
     			combinedTool = tool;
+    		}
-...
     	 * </p>
     	 */
     	public void initializeGrid(){
     		Preferences prefs = mapControlManager.getEditionPreferences();
     		boolean showGrid = prefs.getBoolean("grid.showgrid",cadgrid.isShowGrid());
     		boolean adjustGrid = prefs.getBoolean("grid.adjustgrid",cadgrid.isAdjustGrid());
-...
     		cadgrid.setViewPort(getViewPort());
     		this.repaint();
+    	}
     	/**
     	 * Uses like a mouse pointer the image that provides the
     	 * selected tool.
     	 */
     	private void setToolMouse(){
     		Image cursor=getCurrentMapTool().getImageCursor();
     		Toolkit toolkit = Toolkit.getDefaultToolkit();
     		Cursor c = toolkit.createCustomCursor(cursor ,
     				new Point(16, 16), "img");
     		setCursor (c);
+    	}
     	/**
     	 * Makes the mouse pointer transparent.
     	 */
     	private void setTransparentMouse(){
     		Image cursor=getCurrentMapTool().getImageCursor();
     		Toolkit toolkit = Toolkit.getDefaultToolkit();
     		Cursor transparentCursor = Toolkit.getDefaultToolkit()
     		.createCustomCursor(Toolkit.getDefaultToolkit().createImage(new MemoryImageSource(
 , 16, new int[16 * 16], 0, 16)),
     				new Point(0, 0), "invisiblecursor");
     		setCursor (transparentCursor);
+    	}
     	/**
     	 * <p>Draws a 31x31 pixels cross round the mouse's cursor with an small geometry centered:
     	 *  <ul>
     	 *   <li><i>an square centered</i>: if isn't over a <i>control point</i>.
-...
     	 * @param g <code>MapControl</code>'s graphics where the data will be drawn
     	 */
     	private void drawCursor(Graphics g) {
     		Image cursor=getCurrentMapTool().getImageCursor();
     		g.setColor(Color.black);
     		Point2D p = adjustedPoint;
     		if (p == null) {
     			cadgrid.setViewPort(vp);
     		if (adjustedPoint == null){
     			return;
+    		}
     		g.drawImage(cursor, (int)p.getX()-16, (int)p.getY()-16, this);
     //		int size1 = 15;
     //		int size2 = 3;
     //		g.drawLine((int) (p.getX() - size1), (int) (p.getY()),
     //				(int) (p.getX() + size1), (int) (p.getY()));
     //		g.drawLine((int) (p.getX()), (int) (p.getY() - size1),
     //				(int) (p.getX()), (int) (p.getY() + size1));
     //
     //		// getMapControl().setToolTipText(null);
     //		if (adjustedPoint != null) {
     //			if (bForceCoord) {
     //				/* g.setColor(Color.ORANGE);
     //				g.drawRect((int) (adjustedPoint.getX() - 6),
     //						(int) (adjustedPoint.getY() - 6), 12, 12);
     //				g.drawRect((int) (adjustedPoint.getX() - 3),
     //						(int) (adjustedPoint.getY() - 3), 6, 6);
     //				g.setColor(Color.MAGENTA);
     //				g.drawRect((int) (adjustedPoint.getX() - 4),
     //						(int) (adjustedPoint.getY() - 4), 8, 8); */
     //				if (usedSnap != null)
     //				{
     //					usedSnap.draw(g, adjustedPoint);
     //
     //					Graphics2D g2 = (Graphics2D) g;
     //			        FontMetrics metrics = g2.getFontMetrics();
     //			        int w = metrics.stringWidth(usedSnap.getToolTipText()) + 5;
     //			        int h = metrics.getMaxAscent() + 5;
     //			        int x = (int)p.getX()+9;
     //			        int y = (int)p.getY()- 7;
     //
     //			        g2.setColor(theTipColor );
     //			        g2.fillRect(x, y-h, w, h);
     //			        g2.setColor(Color.BLACK);
     //			        g2.drawRect(x, y-h, w, h);
     //					g2.drawString(usedSnap.getToolTipText(), x+3, y-3);
     //
     //
     //					// getMapControl().setToolTipText(usedSnap.getToolTipText());
     //				}
     //
     //				bForceCoord = false;
     //			} else {
     //				g.drawRect((int) (p.getX() - size2), (int) (p.getY() - size2),
     //						(int) (size2 * 2), (int) (size2 * 2));
     //			}
     //		}
     //		repaint();
     		if (usedSnap != null){
     			usedSnap.draw(g, adjustedPoint);
     			setTransparentMouse();
     		}else{
     			setToolMouse();
+    		}
+    	}
     	/**
     	 * Hides the mouse's cursor.
     	 */
     	private void clearMouseImage() {
     		int[] pixels = new int[16 * 16];
     		Image image = Toolkit.getDefaultToolkit().createImage(
     				new MemoryImageSource(16, 16, pixels, 0, 16));
     		Cursor transparentCursor = Toolkit.getDefaultToolkit()
     				.createCustomCursor(image, new Point(0, 0), "invisiblecursor");
     		setCursor(transparentCursor);
+    	}
     	/**
     	 * <p>Adjusts the <code>point</code> to the grid if its enabled, and
     	 *  sets <code>mapHandlerAdjustedPoint</code> with that new value.</p>
+    	 *
-...
             if (!isRefentEnabled())
                 return Double.MAX_VALUE;
             ArrayList snappers=new ArrayList(selected.keySet());
             ArrayList layersToSnap = getMapContext().getLayersToSnap();
             double mapTolerance = vp.toMapDistance(MapControl.tolerance);
             double mapTolerance = vp.toMapDistance(mapControlManager.getTolerance());
             double minDist = mapTolerance;
             double middleTol=mapTolerance * 0.5;
             Point2D mapPoint = point;
-...
                     java.util.List geoms = cache.query(e);
                     for (int n=0; n < geoms.size(); n++) {
                         Geometry geom = (Geometry) geoms.get(n);
                         for (int i = 0; i < snappers.size(); i++)
                         for (int i = 0; i < mapControlManager.getSnapperCount(); i++)
+                        {
                             ISnapper theSnapper = (ISnapper) snappers.get(i);
                             ISnapper theSnapper = mapControlManager.getSnapperAt(i);
                             if (usedSnap != null)
+                            {
-...
+    	{
     		return bRefent;
+    	}
     	public void initializeSnapping() {
     		ArrayList snappers=getMapContext().getSnappers();
             for (int n = 0; n < snappers.size(); n++) {
                 ISnapper snp = (ISnapper) snappers.get(n);
                 String nameClass=snp.getClass().getName();
                 nameClass=nameClass.substring(nameClass.lastIndexOf('.'));
                 boolean select = prefs.getBoolean("snapper_activated" + nameClass, false);
                 if (select) {
     				selected.put(snp, new Boolean(select));
+    			}
                 int priority = prefs.getInt("snapper_priority" + nameClass,3);
                 snp.setPriority(priority);
+            }
     //        applySnappers = prefs.getBoolean("apply-snappers",true);
     //        snapConfig.setApplySnappers(applySnappers);
     //        snapConfig.selectSnappers(selected);
+        }
     	/**
     	 * Enables the snapping.
     	 */
     	public void enableSnapping() {
     		mapControlManager.disableSnapping();
+    	}
     	/**
     	 * Disables the snapping.
     	 */
     	public void disableSnapping(){
     		mapControlManager.clearSnappers();
+    	}
     	/**
     	 * <p>Tries to find the nearest geometry or grid control point by the position of the current snap tool.</p>
+    	 *
     	 * <p>Prioritizes the grid control points than the geometries ones.</p>
-...
+    	 *
     	 * @param point current mouse 2D position
     	 */
     	public Point2D calculateSnapPoint(Point point) {
     	public void calculateSnapPoint(Point point) {
     		// Se comprueba el ajuste a rejilla
     		Point2D gridAdjustedPoint = vp.toMapPoint(
-...
     		if (minDistance == Double.MAX_VALUE) {
     			adjustedPoint = point;
     			mapAdjustedPoint = null;
+    		}
     		return mapAdjustedPoint;
+    		}
+    	}
     	/**
     	 * Sets the snap tools enabled or disabled.
+    	 *
-...
     		return cadgrid;
+    	}
     	public static TreeMap getSelectedSnapppers() {
     		return selected;
+    	}
     	public void update(Observable observable, Object notification) {
     		DataStoreNotification ddsn=(DataStoreNotification)notification;
     		String type=ddsn.getType();
-...
     				type.equals(FeatureStoreNotification.AFTER_REDO)){
     			repaint();
+    		}
+    	}
     	/**
     	 * @return the adjustedPoint
     	 */
     	public Point2D getAdjustedPoint() {
     		return adjustedPoint;
+    	}
     	/**
     	 * @return the mapAdjustedPoint
     	 */
     	public Point2D getMapAdjustedPoint() {
     		return mapAdjustedPoint;
+    	}
     	/**
     	 * Gets the selected point. If the snapping is enabled
     	 * it returns the selected point.
     	 * @return
     	 * The selected point
     	 */
     	public Point2D getPoint(){
     		if (mapAdjustedPoint != null) {
     			return mapAdjustedPoint;
     		} else {
     			return getViewPort().toMapPoint(adjustedPoint);
+    		}
+    	}
+    }

Also available in: Unified diff