/trunk/libraries/libFMap/src/com/iver/cit/gvsig/fmap/MapControl.java - Diff - Application: gvSIG desktop - gvSIG

Revision 20098 trunk/libraries/libFMap/src/com/iver/cit/gvsig/fmap/MapControl.java

     /**
      * MapControl.
      * <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 #addMapTool(String, Behavior) #addMapTool(String, Behavior)}.</li>
      *      <li>Or, a compound behavior: {@link #addMapTool(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>
      *   </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 Drawer2
      * @see MapContextListener
      * @see MapToolListener
+     *
      * @author Fernando Gonz?lez Cort?s
      */
     public class MapControl extends JComponent implements ComponentListener,
     			CommandListener {
     	/** Cuando la vista est? actualizada. */
     public class MapControl extends JComponent implements ComponentListener, CommandListener {
     	/**
     	 * <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;
     	/** Cuando la vista est? desactualizada. */
     	/**
     	 * <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;
         public static final int ONLY_GRAPHICS = 2;
     	/**
     	 * <p>One of the possible status of <code>MapControl</code>. Determines that only the graphical layer must
     	 * be drawn / updated.</p>
     	 */
     	public static final int ONLY_GRAPHICS = 2;
     	/**
     	 * <p>Determines the number of frames.</p>
+    	 *
     	 * <p>Number of updates per second that the timer will invoke repaint this component.</p>
     	 */
         private static int drawFrameRate = 3;
         /**
          * <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());
     	private MapContext mapContext = null;
         /**
          * <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;
         //private boolean drawerAlive = false;
     	protected HashMap namesMapTools = new HashMap();
     	protected Behavior currentMapTool = null;
     	private int status = DESACTUALIZADO;
     	private BufferedImage image = null;
     	protected String currentTool;
     	private CancelDraw canceldraw;
     	//private boolean isCancelled = true;
     	private Timer timer;
     	protected ViewPort vp;
     	//private Drawer drawer;
     	/**
     	 * <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 #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>The view port once is created an instance of <code>MapControl</code>,
     	 *  is obtained from the <i>EPSG:23030</i> projection, that's the default projection for 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;
         //private Drawer drawer;
     	/**
     	 * <p>Manager of all <code>MapControl</code> painting requests.</p>
     	 */
         private Drawer2 drawer2;
         // private boolean firstDraw = true;
     	protected MapToolListener mapToolListener = new MapToolListener();
     	private MapContextListener mapContextListener = new MapContextListener();
     	private ExceptionHandlingSupport exceptionHandlingSupport = new ExceptionHandlingSupport();
     	/**
     	 * <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 #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;
     	/**
-...
         // private boolean paintEnabled = false;
     	/**
     	 * Crea un nuevo NewMapControl.
     	 * <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 projection <i>"EPSG:23030"</i> .</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");
-...
+    	}
     	/**
     	 * Inserta el modelo.
+    	 *
     	 * @param model FMap.
     	 * <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) {
-...
+    	}
     	/**
     	 * Devuelve la proyecci?n.
     	 * <p>Gets this component's {@link MapContext MapContext} projection.</p>
+    	 *
     	 * @return Proyecci?n.
     	 * @return this component's {@link MapContext MapContext} projection
+    	 *
     	 * @see MapContext#getProjection()
     	 * @see MapControl#setProjection(IProjection)
     	 */
     	public IProjection getProjection() {
     		return getMapContext().getProjection();
+    	}
     	/**
     	 * Inserta una proyecci?n.
     	 * <p>Sets the projection to this component's {@link MapContext MapContext}.</p>
+    	 *
     	 * @param proj Proyecci?n.
     	 * @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);
+    	}
     	/**
     	 * Devuelve el modelo.
+    	 *
     	 * @return FMap.
     	 * <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;
+    	}
     	/**
     	 * Registra una herramienta (tool).
     	 * <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 Nombre de la herramienta.
     	 * @param tool Herramienta.
     	 * @param name name to identify the behavior to add
     	 * @param tool the behavior to add
+    	 *
     	 * @see #addMapTool(String, Behavior[])
     	 * @see #getNamesMapTools()
     	 * @see #getMapToolsKeySet()
     	 * @see #hasTool(String)
     	 */
     	public void addMapTool(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 #addMapTool(String, Behavior)
     	 * @see #getNamesMapTools()
     	 * @see #getMapToolsKeySet()
     	 * @see #hasTool(String)
     	 */
     	public void addMapTool(String name, Behavior[] tools){
     		CompoundBehavior tool = new CompoundBehavior(tools);
     		addMapTool(name, tool);
+    	}
     	/**
     	 * Devuelve una herramienta (tool) registrada.
     	 * <p>Gets the <code>Behavior</code> registered in this component, identified
     	 *  by <code>name</code>.</p>
+    	 *
     	 * @param name Nombre de la herramienta.
     	 * @return tool Herramienta.
     	 * @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 #addMapTool(String, Behavior)
     	 * @see #addMapTool(String, Behavior[])
     	 * @see #hasTool(String)
     	 */
     	public Behavior getMapTool(String name) {
     		return (Behavior)namesMapTools.get(name);
+    	}
     	/**
     	 * Devuelve los nombres de herramientas (tool) registradas.
     	 * <p>Returns a set view of the keys that identified the tools
     	 *  registered.</p>
+    	 *
     	 * @return Set (String) nombres de las herramientas.
     	 * @return a set view of the keys that identified the tools registered
+    	 *
     	 * @see HashMap#keySet()
+    	 *
     	 * @see #getNamesMapTools()
      	 * @see #addMapTool(String, Behavior)
      	 * @see #addMapTool(String, Behavior[])
     	 */
     	public Set getMapToolsKeySet() {
     		return namesMapTools.keySet();
+    	}
     	/**
     	 * Returns true if this map control contains a tool named with the value
     	 * passed in the toolName parameter. If you have added two tools with the
     	 * same name, the last tool will overwrite the previous ones.
     	 * @param toolName
     	 * @return true if the map control contains a tool with the same name than
     	 * 		toolName. False, otherwise.
     	 * <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 #addMapTool(String, Behavior)
     	 * @see #addMapTool(String, Behavior[])
     	 */
     	public boolean hasTool(String toolName) {
     		return namesMapTools.containsKey(toolName);
+    	}
     	/**
     	 * DOCUMENT ME!
+    	 *
     	 * @param toolName DOCUMENT ME!
     	 * <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();
-...
     		currentTool = toolName;
     		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>
+    	 *
     	 * <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 #getCurrentTool()
     	 * @see #setTool(String)
     	 */
     	public Behavior getCurrentMapTool(){
     		return currentMapTool;
+    	}
     	/**
     	 * Returns the name of the current selected tool on this MapControl
     	 * <p>Returns the name of the current selected tool on this MapControl</p>
+    	 *
     	 * @return A tool name.
     	 * @return the name of the current's behavior tool associated to this component
+    	 *
     	 * @see #getCurrentMapTool()
     	 * @see #setTool(String)
     	 */
     	public String getCurrentTool() {
     		return currentTool;
+    	}
     	/**
     	 * Cancela el dibujado. Se espera a que la cancelaci?n surta efecto
     	 * <p>Determines that current drawing process of <code>MapControl</code>'s <code>MapContext</code>'s data must be canceled.</p>
+    	 *
     	 * <p>It has no effects if now isn't drawing that graphical information.</p>
+    	 *
     	 * <p>At last resort, the particular implementation of each layer in this <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.</p>
     	 */
     	public void cancelDrawing() {
     		/* if (drawer != null) {
-...
             drawerAlive = false; */
+    	}
     	/**
     	 * <p>Creates a {@link BufferedImage BufferedImage} image if there was no buffered image, or if
     	 *  its viewport's image height or width is different from this component's size. Once has created
     	 *  a double-buffer, fills it with the vieport's background color, or with <i>white</i> if it had no background color.</p>
+    	 *
     	 * <p>If no double-buffered existed, creates a {@link BufferedImage BufferedImage} with the size of this component,
     	 * and as an image with 8-bit RGBA color components packed into integer pixels. That image has a <code>DirectColorModel</code> with alpha.
     	 * The color data in that image is considered not to be premultiplied with alpha.</p>
+    	 *
     	 * <p>Once has created and filled the new inner <code>MapControl</code>'s double-buffer, changes the status to
     	 * <code>OUTDATED</code>.</p>
+    	 *
     	 * @return <code>true</code> if has created and filled a new double-buffer for this <code>MapControl</code> instance; otherwise <code>false</code>
     	 */
         private boolean adaptToImageSize()
+        {
             if ((image == null) || (vp.getImageWidth() != this.getWidth()) || (vp.getImageHeight() != this.getHeight()))
-...
             return false;
+        }
     	/*
     	 * @see javax.swing.JComponent#paintComponent(java.awt.Graphics)
     	/**
     	 * <p>Paints the graphical information of this component using a double buffer.</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 no <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> &nbsp .<br>
     	 *  &nbsp &nbsp &nbsp Else, repaints the current graphical information quickly calling: <code>g.drawImage(image,0,0,null)</code> &nbsp .<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> that comprises invoke this method) the view every delay of 360 ms. during the the process drawing.</p>
+    	 *
       	 * @see javax.swing.JComponent#paintComponent(java.awt.Graphics)
       	 * @see Drawer2
     	 */
     	protected void paintComponent(Graphics g) {
             adaptToImageSize();
-...
+    	}
     	/**
     	 * Devuelve la imagen de la vista.
+    	 *
     	 * @return imagen.
     	 * <p>Gets the {@link BufferedImage BufferedImage} used to accelerate the draw of new ''frames'' with changes,
     	 * or new graphical items in this component.</p>
+    	 *
     	 * @return double buffered image used by this component to accelerate the draw of its graphical information, or
     	 * <code>null</code> if isn't already created
+    	 *
     	 * @see BufferedImage
     	 */
     	public BufferedImage getImage() {
     		return image;
+    	}
     	/**
     	 * Marca el mapa para que en el pr?ximo redibujado se acceda a la
     	 * cartograf?a para reobtener la imagen
     	 * @param doClear Solo deber?a ser true cuando se llama desde pan
     	 * <p>Forces repaint all visible graphical information in this component.</p>
+    	 *
     	 * <p>If <code>doClear == true</code>, before repainting, clears all graphics before repainting.</p>
+    	 *
     	 * @param doClear <code>true</code> if needs clearing graphics drawn on the map
+    	 *
     	 * @see #cancelDrawing()
     	 * @see FLayers#setDirty(boolean)
     	 */
     	public void drawMap(boolean doClear) {
     		cancelDrawing();
-...
             getMapContext().getLayers().setDirty(true);
     		if (doClear)
+            {
                 // image = null; // Se usa para el PAN
     //            // image = null; // Se usa para el PAN
                 if (image != null)
+                {
                     Graphics2D g = image.createGraphics();
                     Color theBackColor = vp.getBackColor();
                     if (theBackColor == null)
                         g.setColor(Color.WHITE);
                     else
                         g.setColor(theBackColor);
                     g.fillRect(0, 0, vp.getImageWidth(), vp.getImageHeight());
                     g.setColor(Color.BLACK);
     ////                Color theBackColor = vp.getBackColor();
     ////                if (theBackColor == null)
     ////                    g.setColor(Color.WHITE);
     ////                else
     ////                    g.setColor(theBackColor);
     //                g.fillRect(0, 0, vp.getImageWidth(), vp.getImageHeight());
                     g.dispose();
+                }
+            }
     		repaint();
+    	}
     	/**
     	 * <p>Cancels any current drawing process, changing the status to <code>OUTDATED</code>, and forcing
     	 * repaint only the layers dirty.</p>
+    	 *
     	 * @see #cancelDrawing()
     	 */
     	public void rePaintDirtyLayers()
+    	{
     		cancelDrawing();
-...
             repaint();
+    	}
     	/**
     	 * <p>Cancels any current drawing process, changing the status to <code>ONLY_GRAPHICS</code>, and forcing
     	 * repaint only the graphical layer of the <code>MapContext</code>.</p>
     	 */
         public void drawGraphics() {
             status = ONLY_GRAPHICS;
             repaint();
-...
+    	}
     	/**
     	 * A?ade un listener de tipo ExceptionListener.
+    	 *
     	 * @param o ExceptionListener.
     	 * @see ExceptionHandlingSupport#addExceptionListener(ExceptionListener)
     	 */
     	public void addExceptionListener(ExceptionListener o) {
     		exceptionHandlingSupport.addExceptionListener(o);
+    	}
     	/**
     	 * Borra la ExceptioListener que se pasa como par?metro.
+    	 *
     	 * @param o ExceptionListener.
+    	 *
     	 * @return True si se borra correctamente.
     	 * @see ExceptionHandlingSupport#removeExceptionListener(ExceptionListener)
     	 */
     	public boolean removeExceptionListener(ExceptionListener o) {
     		return exceptionHandlingSupport.removeExceptionListener(o);
+    	}
     	/**
     	 * Lanza una Excepci?n.
+    	 *
     	 * @param t Excepci?n.
     	 * @see ExceptionHandlingSupport#throwException(Throwable)
     	 */
     	protected void throwException(Throwable t) {
     		exceptionHandlingSupport.throwException(t);
+    	}
     	/**
     	 * <p>Represents each <code>MapControl</code>'s data painting request.</p>
+    	 *
     	 * <p>The request will be attended by a <code>Drawer2</code>, which will hold it since the <code>Drawer2</code>'s worker
     	 *  takes it, or arrives a new painting request, which will replace it.</p>
     	 */
         private class PaintingRequest
+        {
         	/**
         	 * <p>Creates a new <code>PaintingRequest</p> instance.</p>
         	 */
             public PaintingRequest()
+            {
+            }
             /**
              * <p><code>MapControl</code> paint process:</p>
+             *
              * <p>
              *  <ul>
              *   <li><i>1.- </i>Cancels all previous <code>MapControl</code>'s drawing processes.</li>
              *   <li><i>2.- </i>If <i>status</i> was OUTDATED:
              *    <ul>
              *     <li><i>2.1.- </i>Fills the background color with viewport's background color, or <i>white</i> if it was undefined.</li>
              *     <li><i>2.2.- </i>Notifies <i>MapContext</i> to be drawn invoking: <code>mapContext.draw(double-buffer, double-buffer's buffer, shared cancel-draw object, mapContext.getScaleView());</code>.</li>
              *     <li><i>2.3.- </i>If <code>canceldraw.isCanceled()</code>
              *      <ul>
              *       <li><i>2.3.1.- </i>Sets <i>status</i> to OUTDATED.</li>
              *       <li><i>2.3.2.- </i>Sets <i>dirty</i> all layers stored in <i>MapContext</i>.</li>
              *      </ul>
              *     </li>
              *     <li><i>2.4.- </i>Else, sets <i>status</i> to UPDATED.</li>
              *    </ul>
              *   </li>
              *   <li><i>3.- </i>Else, if <i>status</i> was ONLY_GRAPHICS:
              *    <ul>
              *     <li><i>3.1.- </i>Sets <i>status</i> to UPDATED.</li>
              *     <li><i>3.2.- </i>Notifies <i>MapContext</i> to be drawn invoking: <code>mapContext.drawGraphics(double-buffer, double-buffer's buffer, shared cancel-draw object, mapContext.getScaleView());</code>.</li>
              *    </ul>
              *   </li>
              *   <li><i>4.- </i>Stops the <i>timer</i>.</li>
              *   <li><i>5.- </i>Repaints this component invoking: <code>repaint();</code></li>
              *  </ul>
              * </p>
+             *
              * @see #cancelDrawing()
              * @see MapContext#draw(BufferedImage, Graphics2D, Cancellable, double)
              * @see MapContext#drawGraphics(BufferedImage, Graphics2D, Cancellable, double)
+             *
              * @see ViewPort
              */
             public void paint()
+            {
                 try
-...
                     throwException(e);
                 } finally {
+                }
+            }
+        }
+        }
        /**
         /**
          * <p>An instance of <code>Drawer2</code> could manage all <code>MapControl</code> painting requests.</p>
+         *
          * <p>Based on the <i>WorkerThread</i> software pattern, creates a worker thread that will attend sequentially
          *  the current waiting painting request, after finishing the previous (that could be by a cancel action).</p>
+         *
          * <p>All new {@link PaintingRequest PaintingRequest} generated will be stored as <i>waiting requests</i> since the worker
          * attends it.</p>
+         *
          * <p>If a worker finished and there was no <i>painting request</i>, the worker would be set to wait until any
          *  <i>painting request</i> would be put.</p>
+         *
          * @author fjp
+         *
          * Basasdo en el patr?n WorkerThread
+         *
          */
         public class Drawer2
+        {
             // Una mini cola de 2. No acumulamos peticiones de dibujado
             // dibujamos solo lo ?ltimo que nos han pedido.
             private PaintingRequest paintingRequest;
             private PaintingRequest waitingRequest;
         	/**
         	 * <p>Painting request that's been attended by the <code>Drawer2</code>'s worker.</p>
+        	 *
         	 * @see #put(com.iver.cit.gvsig.fmap.MapControl.PaintingRequest)
         	 * @see #take()
         	 */
         	private PaintingRequest paintingRequest;
         	/**
         	 * <p>Painting request waiting to be attended by the <code>Drawer2</code>'s worker.</p>
+        	 *
         	 * @see #put(com.iver.cit.gvsig.fmap.MapControl.PaintingRequest)
         	 * @see #take()
         	 */
         	private PaintingRequest waitingRequest;
         	/**
         	 * <p>Determines that the <code>Drawer2</code>'s worker is busy attending a painting request.</p>
+         	 *
         	 * @see #put(com.iver.cit.gvsig.fmap.MapControl.PaintingRequest)
         	 * @see #take()
         	 */
             private boolean waiting;
         	/**
         	 * <p>Notifies the <code>Drawer2</code>'s worker to finish or continue with its process.</p>
+        	 *
         	 * @see #setShutdown(boolean)
         	 */
             private boolean shutdown;
             /**
              * <p>Sets this <code>Drawer2</code>'s worker to finish or continue with its process.</p>
+             *
              * @param isShutdown a boolean value
              */
             public void setShutdown(boolean isShutdown)
+            {
                 shutdown = isShutdown;
+            }
             /**
              * <p>Creates a new drawer for managing all data painting requests in <code>MapControl</code>.</p>
+             *
              * <p>Includes the following steps:
              *  <ul>
              *   <li>By default, there is no <i>current painting request</i>.</li>
              *   <li>By default, there is no <i>waiting painting request</i>.</li>
              *   <li>By default, the worker thread is waiting no <i>painting request</i>.</li>
              *   <li>By default, the worker thread is running.</li>
              *   <li>Creates and starts a worker thread for attending the <i>painting requests</i>.</li>
              *  </ul>
              * </p>
              */
             public Drawer2()
+            {
                 paintingRequest = null;
-...
                 new Thread(new Worker()).start();
+            }
             /**
              * <p>Sets a <code>PaintingRequest</code> to be attended by the worker thread of this object. If
              *  this one was waiting, wakes up.</p>
+             *
              * <p>All waiting threads will be notified synchronized.</p>
+             *
              * @param newPaintRequest
+             *
              * @see #take()
              */
             public void put(PaintingRequest newPaintRequest)
+            {
                 waitingRequest = newPaintRequest;
-...
+                }
+            }
             /**
              * <p>Used by this object's worker, returns the current waiting drawing request, causing current thread
              *  to wait until another thread invokes {@link #put(com.iver.cit.gvsig.fmap.MapControl.PaintingRequest) #put(com.iver.cit.gvsig.fmap.MapControl.PaintingRequest)},
              *  if there was no waiting request.</p>
+             *
              * <p>All threads will access synchronized to the waiting request.</p>
+             *
              * @return <code>PaintingRequest</code> that was waiting to be attended
+             *
              * @see #put(com.iver.cit.gvsig.fmap.MapControl.PaintingRequest)
              */
             public PaintingRequest take()
+            {
                 if (waitingRequest == null)
-...
                 return paintingRequest;
+            }
             /**
              * <p>Thread for attending painting requests.</p>
+             *
              * <p>If there was no double buffer, sets the status to <code>OUTDATED</code> and finishes, otherwise
              *  takes the painting request (it's probably that would wait some time), cancel the previous drawing
              *  process, and starts processing the request.</p>
+             *
              * @see Thread
              */
             private class Worker implements Runnable
+            {
                 public void run()
             	/*
             	 * (non-Javadoc)
             	 * @see java.lang.Runnable#run()
             	 */
             	public void run()
+                {
                     while (!shutdown)
+                    {
-...
+        }
     	/**
     	 * Clase utilizada para dibujar las capas.
     	 * <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;
     		/**
     		 * Crea un nuevo Drawer.
+    		 *
     		 * <p>Creates a new <code>Drawer</code> instance.</p>
     		 */
     		public Drawer(BufferedImage image, CancelDraw cancel)
+            {
-...
     		/**
     		 * @see java.lang.Runnable#run()
     		 * @see MapContext#draw(BufferedImage, Graphics2D, Cancellable, double)
     		 * @see MapContext#drawGraphics(BufferedImage, Graphics2D, Cancellable, double)
     		 */
     		public void run() {
     			try {
-...
+    	}
     	/**
     	 * Clase para cancelar el dibujado.
     	 * <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 Cancellable
+    	 *
     	 * @author Fernando Gonz?lez Cort?s
     	 */
     	public class CancelDraw implements Cancellable {
     		/**
     		 * <p>Determines if the drawing task must be canceled or not.</p>
+    		 *
     		 * @see #isCanceled()
     		 * @see #setCanceled(boolean)
     		 */
     		private boolean cancel = false;
     		/**
     		 * Crea un nuevo CancelDraw.
     		 * Creates a new <code>CancelDraw</code> object.
     		 */
     		public CancelDraw() {
+    		}
     		/**
     		 * Insertar si se debe cancelar el dibujado.
+    		 *
     		 * @param b true si se debe cancelar el dibujado.
     		/*
     		 * (non-Javadoc)
     		 * @see com.iver.utiles.swing.threads.Cancellable#setCanceled(boolean)
     		 */
     		public void setCanceled(boolean b) {
     			cancel = b;
+    		}
     		/**
     		/*
     		 * (non-Javadoc)
     		 * @see com.iver.utiles.swing.threads.Cancellable#isCanceled()
     		 */
     		public boolean isCanceled() {
-...
+    		}
+    	}
     	/**
     	 * Listener del MapTool.
     	 * <p>Listens all kind of mouse events produced in {@link MapControl MapControl}, and invokes its current
     	 *  map tool <i>({@link MapControl#getCurrentMapTool() MapControl#getCurrentMapTool()}</i> to simulate a behavior.</p>
+    	 *
     	 * <p>Mouse wheel moved events produce a <i>zoom in</i> operation if wheel rotation is negative, or a <i>zoom out</i>
     	 *  if its positive. Both will be centered in the position of the mouse, but, meanwhile <i>zoom in</i> operation
     	 *  applies a factor of 0.9, <i>zoom out</i> operation applies a factor of 1.2</p>
+    	 *
     	 * <p>Mouse wheel moved events can be produced as much frequently, that between each one, the drawing process could
     	 *  hadn't finished. This is the reason that, in this situation, cancels always the previous drawing process before
     	 *  applying a <i>zoom</i> operation, and ignores all new mouse positions that are produced before 1 second.</p>
+    	 *
     	 * @author Fernando Gonz?lez Cort?s
     	 */
     	public class MapToolListener implements MouseListener, MouseWheelListener,
     		MouseMotionListener {
     		/**
     		 * <p>Used to avoid mouse wheel move events closed.</p>
+    		 *
     		 * <p>If a mouse wheel move event is produced
     		 */
     		long t1;
     		/**
     		 * <p>Position of the mouse, in map coordinates.</p>
+    		 *
     		 * <p>This point coordinates will be used as center of the <i>zoom</i> operation.</p>
     		 */
     		Point2D pReal;
     		/**
     		 * @see java.awt.event.MouseListener#mouseClicked(java.awt.event.MouseEvent)
     		 * @see Behavior#mouseClicked(MouseEvent)
     		 */
     		public void mouseClicked(MouseEvent e) {
     			try {
-...
     		/**
     		 * @see java.awt.event.MouseListener#mouseEntered(java.awt.event.MouseEvent)
     		 * @see Behavior#mouseEntered(MouseEvent)
     		 */
     		public void mouseEntered(MouseEvent e) {
     			try {
-...
     		/**
     		 * @see java.awt.event.MouseListener#mouseExited(java.awt.event.MouseEvent)
     		 * @see Behavior#mouseExited(MouseEvent)
     		 */
     		public void mouseExited(MouseEvent e) {
     			try {
-...
     		/**
     		 * @see java.awt.event.MouseListener#mousePressed(java.awt.event.MouseEvent)
     		 * @see Behavior#mousePressed(MouseEvent)
     		 */
     		public void mousePressed(MouseEvent e) {
     			try {
-...
     		/**
     		 * @see java.awt.event.MouseListener#mouseReleased(java.awt.event.MouseEvent)
     		 * @see Behavior#mouseReleased(MouseEvent)
     		 */
     		public void mouseReleased(MouseEvent e) {
     			try {
-...
     		/**
     		 * @see java.awt.event.MouseWheelListener#mouseWheelMoved(java.awt.event.MouseWheelEvent)
     		 * @see Behavior#mouseWheelMoved(MouseWheelEvent)
     		 */
     		public void mouseWheelMoved(MouseWheelEvent e) {
     			try {
-...
     		/**
     		 * @see java.awt.event.MouseMotionListener#mouseDragged(java.awt.event.MouseEvent)
     		 * @see Behavior#mouseDragged(MouseEvent)
     		 */
     		public void mouseDragged(MouseEvent e) {
     			try {
-...
     		/**
     		 * @see java.awt.event.MouseMotionListener#mouseMoved(java.awt.event.MouseEvent)
     		 * @see Behavior#mouseMoved(MouseEvent)
     		 */
     		public void mouseMoved(MouseEvent e) {
     			try {
-...
+    	}
     	/**
     	 * Listener sobre el MapContext.
     	 * <p<code>MapContextListener</code> listens all events produced in a <code>MapControl</code>'s <code>MapContext</code>
     	 * object during an atomic period of time, and sets it to dirty, <i>executing <code>drawMap(false)</code>, if any of the
     	 * following conditions is accomplished</i>:
     	 * <ul>
     	 *  <li>Any of the <code>LayerEvent</code> in the <code>AtomicEvent</code> parameter notifies a <i>visibility change</i>.</li>
     	 *  <li>There is at least one <code>ColorEvent</code> in the <code>AtomicEvent</code> parameter.</li>
     	 *  <li>There is at least one <code>ExtentEvent</code> in the <code>AtomicEvent</code> parameter.</li>
     	 *  <li>Any of the <code>LayerCollectionEvent</code> in the <code>AtomicEvent</code> parameter notifies that a driver's layer has reloaded it successfully.</li>
     	 *  <li>There is at least one <code>LegendEvent</code> in the <code>AtomicEvent</code> parameter.</li>
     	 *  <li>There is at least one <code>SelectionEvent</code> in the <code>AtomicEvent</code> parameter.</li>
     	 * </ul>
     	 * </p>
+    	 *
     	 * @author Fernando Gonz?lez Cort?s
     	 */
-...
+    			}
+    		}
+    	}
     	/**
     	 * <p>Gets the <code>ViewPort</code> of this component's {@link MapContext MapContext} .</p>
+    	 *
     	 * @see MapContext#getViewPort()
     	 */
     	public ViewPort getViewPort() {
     		return vp;
+    	}
     	/**
     	 * Returns a HashMap with the tools that have been registered
     	 * in the Mapcontrol.
     	 * <p>Returns all registered <code>Behavior</code> that can define a way to work with this <code>MapControl</code>.</p>
+    	 *
     	 * @return registered <code>Behavior</code> to this <code>MapControl</code>
+    	 *
     	 * @see #addMapTool(String, Behavior)
     	 * @see #addMapTool(String, Behavior[])
     	 * @see #getMapToolsKeySet()
     	 * @see #hasTool(String)
     	 */
     	public HashMap getNamesMapTools() {
     		return namesMapTools;
+    	}
     	/*
     	 * (non-Javadoc)
     	 * @see com.iver.cit.gvsig.fmap.edition.commands.CommandListener#commandRepaint()
     	 */
     	public void commandRepaint() {
     		drawMap(false);
+    	}
     	/*
     	 * (non-Javadoc)
     	 * @see com.iver.cit.gvsig.fmap.edition.commands.CommandListener#commandRefresh()
     	 */
     	public void commandRefresh() {
     		// TODO Auto-generated method stub
+    	}
     	/**
     	 * <p>Equivalent operation to <i>undo</i>.</p>
+    	 *
     	 * <p>Exchanges the previous tool with the current one.</p>
+    	 *
     	 * @see #addMapTool(String, Behavior)
     	 * @see #addMapTool(String, Behavior[])
     	 * @see #setTool(String)
     	 */
     	public void setPrevTool() {
     		setTool(prevTool);
+    	}
     	/**
     	 * <p>Executes a <i>zoom in</i> operation centered at the center of the extent.</p>
+    	 *
     	 * <p>This implementation is designed for being invoked outside a <code>Behavior</code>, for example
     	 *  by an action of pressing a button; and simulates that the event has been produced by
     	 *  releasing the <i>button 1</i> of the mouse using the registered <code>Behavior</code> in this
     	 *  <code>MapControl</code> object that's responsible for the <i>zoom in</i> operation.</p>
+    	 *
     	 * @see #zoomOut()
     	 */
     	public void zoomIn() {
     		getMapContext().clearAllCachingImageDrawnLayers();
     		Behavior mapTool = (Behavior) namesMapTools.get("zoomIn");
-...
     			throwException(t);
+    		}
+    	}
     	/**
     	 * <p>Executes a <i>zoom out</i> operation centered at the center of the extent.</p>
+    	 *
     	 * <p>This implementation is thought for being invoked outside a <code>Behavior</code>, for example
     	 *  by an action of pressing a button, and simulates that the event has been produced by
     	 *  releasing the <i>button 1</i> of the mouse using the registered <code>Behavior</code> in this
     	 *  <code>MapControl</code> object that's responsible for the <i>zoom out</i> operation.</p>
+    	 *
     	 * @see #zoomIn()
     	 */
     	public void zoomOut() {
     		getMapContext().clearAllCachingImageDrawnLayers();
     		Behavior mapTool = (Behavior) namesMapTools.get("zoomOut");
-...
     			throwException(t);
+    		}
+    	}
     	/**
     	 * <p>Returns the listener used to catch all mouse events produced in this <code>MapControl</code> instance
     	 *  and that redirects the calls to the current map tool.</p>
+    	 *
     	 * @return the map tool listener used
     	 */
     	public MapToolListener getMapToolListener() {
     		return mapToolListener;
+    	}
     //	 mapTool can be null, for instance, in 3D's navigation tools
     	/**
     	 * <p>Sets <code>mapTool</code> as this <code>MapControl</code>'s current map tool.
+    	 *
     	 * @param mapTool a map tool, or <code>null</code> to disable the interaction with the user
+    	 *
     	 * @see #getCurrentMapTool()
     	 * @see #getCurrentTool()
     	 * @see #setTool(String)
     	 * @see #setPrevTool()
     	 * @see #addMapTool(String, Behavior)
     	 * @see #addMapTool(String, Behavior[])
     	 */
     	public void setCurrentMapTool(Behavior mapTool ){
     		currentMapTool = mapTool;
+    	}
     	/**
     	 * <p>Sets the delay to the timer that refreshes this <code>MapControl</code> instance.</p>
+    	 *
     	 * <p><code>Delay (in ms) = 1000 / getDrawFrameRate()</code></p>
+    	 *
     	 * @see #getDrawFrameRate()
     	 * @see #setDrawFrameRate(int)
     	 */
     	public void applyFrameRate() {
     		if (getDrawFrameRate()>0) {
     			timer.setDelay(1000/getDrawFrameRate());
+    		}
+    	}
     	/**
     	 * <p>Returns the draw frame rate.</p>
+    	 *
     	 * <p>Draw frame rate is the number of repaints of this <code>MapControl</code> instance that timer invokes per second.</p>
+    	 *
     	 * @return number of repaints of this <code>MapControl</code> instance that timer invokes per second
+    	 *
     	 * @see #applyFrameRate()
     	 * @see #setDrawFrameRate(int)
     	 */
     	public static int getDrawFrameRate() {
     		return drawFrameRate;
+    	}
     	/**
     	 * <p>Sets the draw frame rate.</p>
+    	 *
     	 * <p>Draw frame rate is the number of repaints of this <code>MapControl</code> instance that timer invokes per second.</p>
+    	 *
     	 * @param drawFrameRate number of repaints of this <code>MapControl</code> instance that timer invokes per second
+    	 *
     	 * @see #applyFrameRate()
     	 * @see #getDrawFrameRate()
     	 */
     	public static void setDrawFrameRate(int drawFrameRate) {
     		MapControl.drawFrameRate = drawFrameRate;
+    	}
     	/**
     	 * <p>Determines if its enabled the repaint that invokes the timer according to {@link #getDrawFrameRate() #getDrawFrameRate()}.</p>
+    	 *
     	 * @return <code>true</code> if its enabled; otherwise <code>false</code>
     	 */
     	public static boolean isDrawAnimationEnabled() {
     		return drawAnimationEnabled;
+    	}
     	/**
     	 * <p>Sets if its enabled the repaint that invokes the timer according to {@link #getDrawFrameRate() #getDrawFrameRate()}.</p>
+    	 *
     	 * @param drawAnimationEnabled <code>true</code> to enable the mode; otherwise <code>false</code>
     	 */
     	public static void setDrawAnimationEnabled(boolean drawAnimationEnabled) {
     		MapControl.drawAnimationEnabled = drawAnimationEnabled;
+    	}
     	/**
     	 * <p>Gets the shared object that determines if a drawing process must be cancelled or can continue.</p>
+    	 *
     	 * @return the shared object that determines if a drawing process must be cancelled or can continue
     	 */
     	public CancelDraw getCanceldraw() {
     		return canceldraw;
+    	}

Also available in: Unified diff