Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

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

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

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

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

 *

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

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

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

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

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

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

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

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

 */

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.Comparator;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

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.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.primitive.Envelope;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.MapContextLocator;

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.FLayer;

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.swing.api.ActionListenerSupport;

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

import org.gvsig.tools.task.Cancellable;

import org.gvsig.utils.exceptionHandling.ExceptionHandlingSupport;

import org.gvsig.utils.exceptionHandling.ExceptionListener;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

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

    public class AddLayerEvent extends ActionEvent {

        private static final long serialVersionUID = -1857839388303164091L;

        private FLayer layer;

        public AddLayerEvent(FLayer layer, Object source, int id, String command) {

            super(source, id, command);

            this.layer = layer;

        }

        public FLayer getLayer() {

            return this.layer;

        }

        public void setLayer(FLayer layer) {

            this.layer = layer;

        }

    }

    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;

    public static final int PAINT_PARTIAL_DRAWING_LAYERS = 0;

    public static final int PAINT_WHEN_DRAW_LAYERS_IS_COMPLETED = 1;

    private int paintMode = PAINT_PARTIAL_DRAWING_LAYERS;

    /**

     * <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 Map<String,Behavior> namesMapTools = new HashMap<String,Behavior>();

    /**

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

     */

    protected 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;

    private boolean defaultMouseWheelEnabled = true;

    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

     */

    protected Point2D mapAdjustedPoint;

    /**

     * Renderer used to draw the layers.

     */

    private MapControlDrawer mapControlDrawer = null;

        private Cursor transparentCursor;

        private boolean disposed = false;

    private ActionListenerSupport addLayerHelper;

    /**

     * <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(null);

    }

    public MapControl(MapContext theMapContext) {

        if( theMapContext == null ) {

            theMapContext = new MapContext(new ViewPort(MapContextLocator.getMapContextManager().getDefaultCRS()));

        }

        this.setName("MapControl");

        this.addLayerHelper = ToolsSwingLocator.getToolsSwingManager().createActionListenerSupport();

        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();

        vp = theMapContext.getViewPort();

        setMapContext(theMapContext);

        // 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() {

                    @Override

                    public void actionPerformed(ActionEvent e) {

                        if ( paintMode!=PAINT_WHEN_DRAW_LAYERS_IS_COMPLETED && drawAnimationEnabled) {

                            MapControl.this.repaint();

                        }

                    }

                }

        );

        initializeGrid();

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

                        ToolsLocator.getDisposableManager().bind(this);

                } else {

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

                }

    }

    public void addLayer(FLayer layer) {

        AddLayerEvent event = new AddLayerEvent(layer, this, 1, "addLayer");

        this.addLayerHelper.fireActionEvent(event);

        this.mapContext.getLayers().add(event.getLayer());

    }

    public void addLayerListener(ActionListener al) {

        this.addLayerHelper.addActionListener(al);

    }

    public void setPaintMode(int paintMode) {

        this.paintMode = paintMode;

    }

    public int getPaintMode() {

        return this.paintMode;

    }

    /**

     * <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);

        tool.setMapControl(this);

        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);

                currentMapTool.setMapControl(this);

            }

        }

        // 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;

    }

    /**

     * <p>

     * Returns the name of the current selected tool on this MapControl

     * </p>

     *

     * @return the name of the current's behavior tool associated to this

     *         component

     *

     * @see #getCurrentMapTool()

     * @see #setTool(String)

     */

    public String getCurrentTool() {

        return currentTool;

    }

    /**

     * <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) {

         * if (!drawer.isAlive()) {

         * return;

         * }

         * }

         */

        canceldraw.setCanceled(true);

        /*

         * while (!isCancelled) {

         * if (!drawer.isAlive()) {

         * // Si hemos llegado aqu� con un thread vivo, seguramente

         * // no estamos actualizados.

         *

         * break;

         * }

         *

         * }

         * canceldraw.setCancel(false);

         * isCancelled = false;

         * 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())) {

            image = new BufferedImage(this.getWidth(), this.getHeight(),

                    BufferedImage.TYPE_INT_ARGB);

            vp.setImageSize(new Dimension(getWidth(), getHeight()));

            getMapContext().getViewPort().refreshExtent();

            clearImage(image);

            status = DESACTUALIZADO;

            return true;

        }

        return false;

    }

    private void clearImage(BufferedImage image) {

        if( image == null ) {

            return;

        }

        Graphics gTemp = image.createGraphics();

        Color theBackColor = vp.getBackColor();

        if (theBackColor == null) {

            gTemp.setColor(Color.WHITE);

        } else {

            gTemp.setColor(theBackColor);

        }

        gTemp.fillRect(0, 0, getWidth(), getHeight());

        gTemp.dispose();

    }

    /**

     * <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();

        try {

            mapControlDrawer.startDrawing(this);

        } catch (InterruptedException e) {

            LOG.info("Error locking the MapControlDrawer", e);

        }

        mapControlDrawer.setGraphics(g);

        mapControlDrawer.stopDrawing(this);

        mapControlDrawer.setViewPort(getMapContext().getViewPort());

        if (status == ACTUALIZADO) {

            /*

             * 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(mapControlDrawer,true);

                } else {

                    mapControlDrawer.drawImage(image, 0, 0);

                }

            }

                } else if ((status == DESACTUALIZADO)) {

                        mapControlDrawer.drawImage(image, 0, 0);

                        drawer.put(new PaintingRequest());

                        timer.start();

                }

        cadgrid.drawGrid(mapControlDrawer);

        drawCursor();

    }

    private String getStatusLabel(int status ) {

        switch(status) {

            case ACTUALIZADO:

                return "ACTUALIZADO";

            case DESACTUALIZADO:

                return "DESACTUALIZADO";

            default:

                return Integer.toString(status);

        }

    }

    /**

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

    }

    /**

     * <p>

     * Forces repaint all visible graphical information in this component.

     * </p>

     *

     * <p>

     * If <code>doClear == true</code>, before repainting, clears the background

     * color, with the inner viewport's background color.

     * </p>

     *

     * @param doClear

     *            <code>true</code> if needs clearing the background color

     *            before drawing the map

     *

     * @see #cancelDrawing()

     * @see FLayers#setDirty(boolean)

     */

    public void drawMap(boolean doClear) {

        cancelDrawing();

        status = DESACTUALIZADO;

        if (doClear) {

            clearImage(image);

        }

        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();

        status = DESACTUALIZADO;

        repaint();

    }

    /**

     * @deprecated use {@link #drawMap(boolean)} instead, or even

     * better {@link #getMapContext()}.invalidate().

     */

    public void drawGraphics() {

        drawMap(false);

    }

    /**

     * @see java.awt.event.ComponentListener#componentHidden(java.awt.event.ComponentEvent)

     */

    public void componentHidden(ComponentEvent e) {

    }

    /**

     * @see java.awt.event.ComponentListener#componentMoved(java.awt.event.ComponentEvent)

     */

    public void componentMoved(ComponentEvent e) {

    }

    /**

     * @see java.awt.event.ComponentListener#componentResized(java.awt.event.ComponentEvent)

     */

    public void componentResized(ComponentEvent e) {

        /*

         * image = new BufferedImage(this.getWidth(), this.getHeight(),

         * BufferedImage.TYPE_INT_ARGB);

         * Graphics gTemp = image.createGraphics();

         * gTemp.setColor(vp.getBackColor());

         * gTemp.fillRect(0,0,getWidth(), getHeight());

         * System.out.println("MapControl resized");

         * // image = null;

         * vp.setImageSize(new Dimension(getWidth(), getHeight()));

         * getMapContext().getViewPort().setScale();

         */

        // drawMap(true);

    }

    /**

     * @see java.awt.event.ComponentListener#componentShown(java.awt.event.ComponentEvent)

     */

    public void componentShown(ComponentEvent e) {

    }

    /**

     * @see ExceptionHandlingSupport#addExceptionListener(ExceptionListener)

     */

    public void addExceptionListener(ExceptionListener o) {

        exceptionHandlingSupport.addExceptionListener(o);

    }

    /**

     * @see ExceptionHandlingSupport#removeExceptionListener(ExceptionListener)

     */

    public boolean removeExceptionListener(ExceptionListener o) {

        return exceptionHandlingSupport.removeExceptionListener(o);

    }

    /**

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