Application: gvSIG desktop

 *

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

 * of the Valencian Government (CIT)

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

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

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

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

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

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

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

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

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

 * MA  02110-1301, USA.

 */

import java.awt.Color;

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

/**

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

 */

public class CircleSelectionBehavior extends CircleBehavior {

    /**

	 */

    private CircleListener listener;

    /*

     * (non-Javadoc)

     * @see

     * com.iver.cit.gvsig.fmap.tools.Behavior.Behavior#paintComponent(java.awt

     * .Graphics)

     */

    public void paintComponent(Graphics g) {

        double radio;

        g.setColor(Color.black);

        g.setXORMode(Color.white);

        if ((m_FirstPoint != null) && (m_LastPoint != null)) {

    /*

     * (non-Javadoc)

     * @see

     * com.iver.cit.gvsig.fmap.tools.Behavior.Behavior#mousePressed(java.awt

     * .event.MouseEvent)

    /*

     * (non-Javadoc)

     * @see

     * com.iver.cit.gvsig.fmap.tools.Behavior.Behavior#mouseReleased(java.awt

     * .event.MouseEvent)

    /*

     * (non-Javadoc)

     * @see

     * com.iver.cit.gvsig.fmap.tools.Behavior.Behavior#mouseDragged(java.awt

     * .event.MouseEvent)

    /*

     * (non-Javadoc)

     * @see

     * com.iver.cit.gvsig.fmap.tools.Behavior.Behavior#mouseMoved(java.awt.event

     * .MouseEvent)

 * 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

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

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

 * </ul>

 * </p>

 * <p>

 * <b>Tools:</b>

 * </p>

 * <p>

 * A developer can:

 * <ul>

 * #removeCombinedTool()}.</li>

 * </ul>

 * </p>

 * <p>

 * <b>Exception listener:</b>

 * </p>

 * <p>

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

 * exception produced:

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

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

 */

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

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

     * </p>

     * @see #getMapContext()

     * @see #setMapContext(MapContext)

     */

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

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

     * tool.

     * </p>

     * @see #getCurrentMapTool()

     * @see #getCurrentTool()

     * @see #setTool(String)

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

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

     */

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

     * with the process.

     * </p>

     * @see #cancelDrawing()

     */

    private CancelDraw canceldraw;

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

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

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

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

     */

    /**

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

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

    /**

     * Determines if the snap tools are enabled or disabled.

     * @see #isRefentEnabled()

     * @see #setRefentEnabled(boolean)

     */

    /**

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

     * @see MapControl#toMapPoint

     */

    protected Point2D mapAdjustedPoint;

     */

    private MapControlDrawer mapControlDrawer = null;

	private Cursor transparentCursor;

	private boolean disposed = false;

    /**

    public MapControl() {

        this(null);

    }

    public MapControl(MapContext theMapContext) {

        if( theMapContext == null ) {

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

        canceldraw = new CancelDraw();

        vp = theMapContext.getViewPort();

        setMapContext(theMapContext);

        // eventos

                    }

                });

        initializeGrid();

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

			ToolsLocator.getDisposableManager().bind(this);

		} else {

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

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

     */

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

     */

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

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

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

     */

    public void addBehavior(String name, Behavior[] tools) {

        CompoundBehavior tool = new CompoundBehavior(tools);

        addBehavior(name, tool);

    }

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

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

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

     */

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

     */

                    new CompoundBehavior(new Behavior[] { currentMapTool });

                ((CompoundBehavior) currentMapTool).addMapBehavior(

                    combinedTool, true);

            }

        }

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

     */

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

     */

     * 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

         * if (!drawer.isAlive()) {

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

         * // no estamos actualizados.

         * break;

         * }

         * }

         * canceldraw.setCancel(false);

         * isCancelled = false;

     * 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

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

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

     * 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

     */

             */

            if (image != null) {

                if (currentMapTool != null) {

                } else {

                    mapControlDrawer.drawImage(image, 0, 0);

                }

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

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

     */

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

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

         * <p>

         * <code>MapControl</code> paint process:

         * </p>

         * <p>

         * <ul>

         * <li><i>1.- </i>Cancels all previous <code>MapControl</code>'s drawing

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

                timer.stop();

                LOG.warn("Problems drawing mapcontext.",e);

                throwException(e);

        }

    }

     * 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

     */

    public class Drawer {

         * Painting request that's been attended by the <code>Drawer2</code>'s

         * worker.

         * </p>

         * @see #put(org.gvsig.fmap.mapcontrol.MapControl.PaintingRequest)

         * @see #take()

         */

         * Painting request waiting to be attended by the <code>Drawer2</code>'s

         * worker.

         * </p>

         * @see #put(org.gvsig.fmap.mapcontrol.MapControl.PaintingRequest)

         * @see #take()

         */

         * Determines that the <code>Drawer2</code>'s worker is busy attending a

         * painting request.

         * </p>

         * @see #put(org.gvsig.fmap.mapcontrol.MapControl.PaintingRequest)

         * @see #take()

         */

         * Notifies the <code>Drawer2</code>'s worker to finish or continue with

         * its process.

         * </p>

         * @see #setShutdown(boolean)

         */

        private boolean shutdown;

         * Sets this <code>Drawer2</code>'s worker to finish or continue with

         * its process.

         * </p>

         * @param isShutdown

         *            a boolean value

         */

         * Creates a new drawer for managing all data painting requests in

         * <code>MapControl</code>.

         * </p>

         * <p>

         * Includes the following steps:

         * <ul>

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

         * #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(org.gvsig.fmap.mapcontrol.MapControl.PaintingRequest)

         */

        public PaintingRequest take() {

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

            /*

             * (non-Javadoc)

             * @see java.lang.Runnable#run()

             */

            public void run() {

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

         */

        /*

         * (non-Javadoc)

         * @see com.iver.utiles.swing.threads.Cancellable#setCanceled(boolean)

         */

        public void setCanceled(boolean b) {

        /*

         * (non-Javadoc)

         * @see com.iver.utiles.swing.threads.Cancellable#isCanceled()

         */

        public boolean isCanceled() {

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

     * 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

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

         * <p>

         * Used to avoid mouse wheel move events closed.

         * </p>

         * <p>

         * If a mouse wheel move event is produced

         */

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

                } else {

                    p = vp.toMapPoint(adjustedPoint);

            } catch (BehaviorException t) {

                throwException(t);

            }

     * <code>AtomicEvent</code> parameter.</li>

     * </ul>

     * </p>

     * @author Fernando Gonz�lez Cort�s

     */

    public class MapContextListener implements AtomicEventListener {

     * Gets the <code>ViewPort</code> of this component's {@link MapContext

     * MapContext} .

     * </p>

     * @see MapContext#getViewPort()

     */

    public ViewPort getViewPort() {

     * 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 #addBehavior(String, Behavior)

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

     * @see #getMapToolsKeySet()

    /*

     * (non-Javadoc)

     * @see

     * com.iver.cit.gvsig.fmap.edition.commands.CommandListener#commandRepaint()

     */

    /*

     * (non-Javadoc)

     * @see

     * com.iver.cit.gvsig.fmap.edition.commands.CommandListener#commandRefresh()

     */

     * <p>

     * Equivalent operation to <i>undo</i>.

     * </p>

     * <p>

     * Exchanges the previous tool with the current one.

     * </p>

     * @see #addBehavior(String, Behavior)

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

     * @see #setTool(String)

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

     * <code>MapControl</code> object that's responsible for the <i>zoom in</i>

     * operation.

     * </p>

     * @see #zoomOut()

     */

    public void zoomIn() {

     * 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

     * <code>MapControl</code> object that's responsible for the <i>zoom out</i>

     * operation.

     * </p>

     * @see #zoomIn()

     */

    public void zoomOut() {

     * <code>MapControl</code> instance and that redirects the calls to the

     * current map tool.

     * </p>

     * @return the map tool listener used

     */

    public MapToolListener getMapToolListener() {

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

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

     */

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

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

     * 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

     */

     * Gets the tool used in combination with the current tool of this

     * <code>MapControl</code>.

     * </p>

     * @return the tool used in combination with the <code>currentMapTool</code>

     *         ; <code>null</code> if there is

     *         no combined tool

     * Sets a tool to be used in combination with the current tool of this

     * <code>MapControl</code>.

     * </p>

     * @param combinedTool

     *            a tool to be used in combination with the current tool of

     *            <code>MapControl</code>

     * If <code>tool</code> was already stored as a combined tool, doesn't adds

     * it.

     * </p>

     * @param tool

     *            a new tool to be used combined with the current tool

     */

                combinedTool =

                    new CompoundBehavior(new Behavior[] { combinedTool });

                ((CompoundBehavior) combinedTool).addMapBehavior(tool, true);

            }

        }

     * {@link com.iver.cit.gvsig.gui.cad.CADToolAdapter.prefs.Preferences

     * com.iver.cit.gvsig.gui.cad.CADToolAdapter.prefs.Preferences}.

     * </p>

     * <p>

     * The preferences are:

     * <ul>

    /**

     * Uses like a mouse pointer the image that provides the

     * selected tool.

     */

    private Image lastImageCursor = null;

     * On the other hand, a light-yellowed background tool tip text with the

     * type of <i>control point</i> will be displayed.</li>

     * </p>

     * @param g

     *            <code>MapControl</code>'s graphics where the data will be

     *            drawn

     * Adjusts the <code>point</code> to the grid if its enabled, and sets

     * <code>mapHandlerAdjustedPoint</code> with that new value.

     * </p>

     * <p>

     * The value returned is the distance between those points: the original and

     * the adjusted one.

     * </p>

     * @param point

     *            point to adjust

     * @param mapHandlerAdjustedPoint

     *            <code>point</code> adjusted

     * @return distance from <code>point</code> to the adjusted one. If there is

     *         no

     *         adjustment, returns <code>Double.MAX_VALUE</code>.

                // de mayor

                // prioridad est�n primero.

                List geoms = cache.query(r);

                for (int i = 0; i < mapControlManager.getSnapperCount(); i++)

                {

                    ISnapper theSnapper = mapControlManager.getSnapperAt(i);

                    if (theSnapper instanceof ISnapperGeometriesVectorial)

                    {

                    }

                for (int n = 0; n < geoms.size(); n++) {

                    Geometry geom = (Geometry) geoms.get(n);

                    for (int i = 0; i < mapControlManager.getSnapperCount(); i++) {

    /**

     * Determines if snap tools are enabled or disabled.

     * @return <code>true</code> to enable the snap tools; <code>false</code> to

     *         disable them

     * @see #setRefentEnabled(boolean)

     */

    public boolean isRefentEnabled() {

     * Tries to find the nearest geometry or grid control point by the position

     * of the current snap tool.

     * </p>

     * <p>

     * Prioritizes the grid control points than the geometries ones.

     * </p>

     * <p>

     * If finds any near, stores the <i>map</i> and <i>pixel</i> coordinates for

     * the snap, and enables the <code>bForceCoord</code> attribute for the next

     * draw of the mouse's cursor.

     * </p>

     * @param point

     *            current mouse 2D position

     */

    /**

     * Sets the snap tools enabled or disabled.

     * @param activated

     *            <code>true</code> to enable the snap tools; <code>false</code>

     *            to disable them

     * @see #isRefentEnabled()

     */

    public void setRefentEnabled(boolean activated) {

    /**

     * Gets the selected point. If the snapping is enabled

     * it returns the selected point.

     * @return

     *         The selected point

     */

import java.awt.event.MouseWheelEvent;

import java.util.ArrayList;

import org.gvsig.fmap.mapcontrol.MapControl;

import org.gvsig.fmap.mapcontrol.MapControlDrawer;

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

 * @author Fernando Gonz?lez Cort?s

 * @author Pablo Piqueras Bartolom?

 */

	/**

	 * List of all behaviors that compound this one.

	 */

	 * @param tools atomic behaviors that will compound this one</code>

	 */

	public CompoundBehavior(Behavior[] behaviors){

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

            if (behaviors[i] == null) {

                throw new IllegalArgumentException("behaviors");

            }

        }

        boolean first = true;

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

		    if (!containsBehavior(behaviors[i])) {

		        this.behaviors.add(behaviors[i]);

		        /*

	 * @param draw flag determining if will be real-time drawn or no

	 */

	public void addMapBehavior(Behavior mt, boolean draw){

	    if (mt == null) {

	        throw new IllegalArgumentException("mt");

	    }

	    if (!containsBehavior(mt)) {

	        behaviors.add(mt);

	        draws.add(new Boolean(draw));

	 * @see com.iver.cit.gvsig.fmap.tools.Behavior.Behavior#paintComponent(java.awt.Graphics)

	 */

	public void paintComponent(MapControlDrawer renderer) {

	}

	/**

	 * Sets a tool listener to work with a <code>MapControl</code> instance using these behaviors.

	 *

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

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

import org.gvsig.fmap.mapcontext.ViewPort;

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

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;