| gvSIG desktop 1

/* gvSIG. Geographic Information System of the Valencian Government

 *

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

 * of the Valencian Government (CIT)

 * 

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

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

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

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

 * 

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

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

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

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

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

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

 * MA  02110-1301, USA.

 * 

 */

package org.gvsig.editing.gui.cad;

import java.awt.Color;

import java.awt.Cursor;

import java.awt.Graphics;

import java.awt.Image;

import java.awt.Point;

import java.awt.Toolkit;

import java.awt.event.InputEvent;

import java.awt.event.MouseEvent;

import java.awt.event.MouseWheelEvent;

import java.awt.geom.Point2D;

import java.awt.image.BufferedImage;

import java.awt.image.MemoryImageSource;

import java.util.HashMap;

import java.util.Stack;

import java.util.prefs.Preferences;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.messages.NotificationManager;

import org.gvsig.andami.ui.mdiFrame.MainFrame;

import org.gvsig.andami.ui.mdiManager.IWindow;

import org.gvsig.app.project.documents.view.gui.DefaultViewPanel;

import org.gvsig.app.project.documents.view.toolListeners.StatusBarListener;

import org.gvsig.editing.CADExtension;

import org.gvsig.editing.EditionManager;

import org.gvsig.editing.gui.cad.tools.SelectionCADTool;

import org.gvsig.editing.layers.ILayerEdited;

import org.gvsig.editing.layers.VectorialLayerEdited;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.exception.ReadException;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.dal.feature.FeatureSelection;

import org.gvsig.fmap.dal.feature.FeatureSet;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.dal.feature.exception.NeedEditingModeException;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.type.GeometryType;

import org.gvsig.fmap.geom.util.UtilFunctions;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

import org.gvsig.fmap.mapcontrol.MapControl;

import org.gvsig.fmap.mapcontrol.MapControlDrawer;

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

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

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

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.utils.console.JConsole;

/**

 * <p>

 * Allows user interact with different CAD tools, on a layer being edited.

 * </p>

 * 

 * <p>

 * There are two ways of interacting:

 * <ul>

 * <li><b>With the mouse</b> : user selects any {@link CADTool CADTool} that

 * produces mouse events as consequence of the actions working with the layer

 * being edited.</li>

 * <li><b>Writing commands in the edition console</b> : most of the

 * {@link CADTool CADTool} mouse actions can also be called writing a command or

 * a command's parameter in the associated edition console, and pressing the key

 * <code>Enter</code>. If the command isn't valid, will notify it.</li>

 * </ul>

 * </p>

 * 

 * <p>

 * The edition has been implemented as a <i>finite machine</i>, with three kind

 * of transitions between states according the parameters introduced:

 * <ul>

 * <li><i>First transition type: <b>Point</i></b>: if <code>text</code> matches

 * with any pattern of parameters needed for any kind of point coordinates.<br>

 * There are eight ways of introducing point 2D coordinates:

 * <ul>

 * <li><i>X,Y</i> : absolute cardinal 2D coordinate from the center <i>(0,0)</i>

 * of the CCS <i>Current Coordinate System</i>.</li>

 * <li><i>@X,Y</i> : relative cardinal 2D distances from the last point added of

 * the CCS. If it's the first point of the geometry, works like <i>X,Y</i>.</li>

 * <li><i>length< angle</i> : absolute polar 2D coordinate from the center

 * <i>(0,0)</i> of the CCS <i>Current Coordinate System</i>, using <i>angle</i>

 * from the <i>X</i> axis of CCS, and <i>length</i> far away.</li>

 * <li><i>@length< angle</i> : relative polar 2D coordinate from the last point

 * added of the CCS <i>Current Coordinate System</i>, using <i>angle</i> from

 * the <i>X</i> axis of CCS, and <i>length</i> far away. If it's the first point

 * of the geometry, works like <i>length< angle</i>.</li>

 * <li><i>*X,Y</i> : like <i>X,Y</i> but using UCS <i>Universal Coordinate

 * System</i> as reference.</li>

 * <li><i>@*X,Y</i> : like <i>@X,Y</i> but using UCS <i>Universal Coordinate

 * System</i> as reference. If it's the first point of the geometry, works like

 * <i>*X,Y</i>.</li>

 * <li><i>*length< angle</i> : like <i>length< angle</i> but using UCS

 * <i>Universal Coordinate System</i> as reference.</li>

 * <li><i>@*length< angle</i> : like <i>@length< angle</i> but using UCS

 * <i>Universal Coordinate System</i> as reference. If it's the first point of

 * the geometry, works like <i>*length< angle</i>.</li>

 * </ul>

 * </li>

 * <li><i>Second transition type: <b>Value</i></b>: if recognizes it as a single

 * number.</li>

 * <li><i>Third transition type: <b>Option</i></b>: by default, if can't

 * classify the information as a single number neither as a point. This

 * information will be an <code>String</code> and dealt as an option of the

 * current tool state. Ultimately, if isn't valid, <code>text</code> will be

 * rewritten in the console notifying the user that isn't correct.</li>

 * </ul>

 * </p>

 * 

 * @see Behavior

 * @see MapControl

 */

public class CADToolAdapter extends Behavior {

    private static Logger logger = LoggerFactory

        .getLogger(CADToolAdapter.class);

    /**

     * Stores the CAD tools to edit the layers of the associated

     * <code>MapControl</code>.

     * 

     * @see #addCADTool(String, CADTool)

     * @see #getCadTool()

     * @see #getCADTool(String)

     */

    private static HashMap namesCadTools = new HashMap();

    /**

     * Reference to the object used to manage the edition of the layers of the

     * associated <code>MapControl</code>.

     * 

     * @see EditionManager

     * @see #getEditionManager()

     */

    private EditionManager editionManager = new EditionManager();

    /**

     * Reference to the MapContext library manager, used to create symbols

     * and legends.

     */

    private MapContextManager mapContextManager = MapContextLocator

        .getMapContextManager();

    /**

     * Identifies that the data are absolute coordinates of the new point from

     * the (0, 0) position.

     */

    public static final int ABSOLUTE = 0;

    /**

     * Equivalent to {@link CADToolAdapter#ABSOLUTE CADToolAdapter#ABSOLUTE}.

     */

    public static final int RELATIVE_SCP = 1;

    /**

     * Identifies that the data are relative distances of the new point from the

     * previous introduced.

     */

    public static final int RELATIVE_SCU = 2;

    /**

     * Identifies that the data are relative polar distances (longitude of the

     * line and angle given in degrees) of the new point from the previous

     * introduced.

     */

    public static final int POLAR_SCP = 3;

    /**

     * Identifies that the data are relative polar distances (longitude of the

     * line and angle given in radians) of the new point from the previous

     * introduced.

     */

    public static final int POLAR_SCU = 4;

    /**

     * Stores the 2D map coordinates of the last point added.

     */

    private double[] previousPoint = null;

    /**

     * <i>Stack with CAD tools.</i>

     * 

     * <i>For each CAD tool we use, the last item added in this stack will

     * display a different icon according to the current operation and its

     * status.</i>

     */

    private Stack cadToolStack = new Stack();

    /**

     * X coordinate of the last dragging or moving mouse event.

     */

    private int lastX;

    /**

     * Y coordinate of the last dragging or moving mouse event.

     */

    private int lastY;

    /**

     * Unused attribute.

     */

    private ISymbol symbol = mapContextManager.getSymbolManager().createSymbol(

        Geometry.TYPES.POINT, Color.RED);

    /**

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

     * 

     * @see MapControl#toMapPoint

     */

    private Point2D mapAdjustedPoint;

    /**

     * Kind of geometry drawn to identify the kind of control point selected by

     * the cursor's mouse.

     */

    // private ISnapper usedSnap = null;

    /**

     * Determines if has displayed at the edition console, the question for the

     * operations that can do the user with the current CAD tool, in its current

     * state.

     */

    private boolean questionAsked = false;

    /**

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

     * 

     * @see ViewPort#fromMapPoint(Point2D)

     */

    private Point2D adjustedPoint;

    /**

     * Determines if the snap tools are enabled or disabled.

     * 

     * @see #isRefentEnabled()

     * @see #setRefentEnabled(boolean)

     */

    // private boolean bRefent = true;

    /**

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

    /**

     * Optional grid that could be applied on the <code>MapControl</code>'s

     * view port.

     * 

     * @see #getGrid()

     * @see #setAdjustGrid(boolean)

     */

    // private CADGrid cadgrid = new CADGrid();

    /**

     * Determines is is enabled or not the <i>Orto</i> mode.

     */

    private boolean bOrtoMode;

    /**

     * A light yellow color for the tool tip text box associated to the point

     * indicated by the mouse's cursor.

     */

    private Color theTipColor = new Color(255, 255, 155);

    /**

     * Last question asked to the user in the CAD console.

     */

    private Object lastQuestion;

    /**

     * Maximum tolerance in the approximation of a curved line by a polyline.

     * 

     * @see #initializeFlatness()

     */

    private static boolean flatnessInitialized = false;

    /**

     * Listener to display the coordinates in the current application's status

     * bar.

     */

    private StatusBarListener sbl = null;

    /*

     * (non-Javadoc)

     * 

     * @see

     * com.iver.cit.gvsig.fmap.tools.Behavior.Behavior#setMapControl(com.iver

     * .cit.gvsig.fmap.MapControl)

     */

    public void setMapControl(MapControl mc) {

        super.setMapControl(mc);

        sbl = new StatusBarListener(getMapControl());

    }

    private static final Image imageCursor = new BufferedImage(32, 32,

        BufferedImage.TYPE_INT_ARGB);

    static {

        Graphics g = imageCursor.getGraphics();

        int size1 = 15;

        int size2 = 3;

        int x = 16;

        int y = 16;

        g.setColor(Color.MAGENTA);

        g.drawLine((x - size1), (y), (x + size1), (y));

        g.drawLine((x), (y - size1), (x), (y + size1));

        // g.setColor(Color.MAGENTA);

        g.drawRect((x - 6), (y - 6), 12, 12);

        g.drawRect((x - 3), (y - 3), 6, 6);

        // // getMapControl().setToolTipText(null);

        // if (adjustedPoint != null) {

        // if (bForceCoord) {

        // /* g.setColor(Color.ORANGE);

        // g.drawRect((int) (adjustedPoint.getX() - 6),

        // (int) (adjustedPoint.getY() - 6), 12, 12);

        // g.drawRect((int) (adjustedPoint.getX() - 3),

        // (int) (adjustedPoint.getY() - 3), 6, 6);

        // g.setColor(Color.MAGENTA);

        // g.drawRect((int) (adjustedPoint.getX() - 4),

        // (int) (adjustedPoint.getY() - 4), 8, 8); */

        // if (usedSnap != null)

        // {

        // usedSnap.draw(g, adjustedPoint);

        //

        // Graphics2D g2 = (Graphics2D) g;

        // FontMetrics metrics = g2.getFontMetrics();

        // int w = metrics.stringWidth(usedSnap.getToolTipText()) + 5;

        // int h = metrics.getMaxAscent() + 5;

        // int x = (int)p.getX()+9;

        // int y = (int)p.getY()- 7;

        //

        // g2.setColor(theTipColor );

        // g2.fillRect(x, y-h, w, h);

        // g2.setColor(Color.BLACK);

        // g2.drawRect(x, y-h, w, h);

        // g2.drawString(usedSnap.getToolTipText(), x+3, y-3);

        //

        //

        // // getMapControl().setToolTipText(usedSnap.getToolTipText());

        // }

        //

        // bForceCoord = false;

        // } else {

        // g.drawRect((int) (p.getX() - size2), (int) (p.getY() - size2),

        // (int) (size2 * 2), (int) (size2 * 2));

        // }

        // }

    }

    /**

     * <p>

     * Draws the selected geometries to edit. And, if the <i>snapping</i> is

     * enabled, draws also its effect over them.

     * </p>

     * 

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

     */

    public void paintComponent(MapControlDrawer mapControlDrawer) {

        super.paintComponent(mapControlDrawer);

        if (CADExtension.getCADToolAdapter() != this) {

            return;

        }

        if (adjustedPoint != null) {

            Point2D p = null;

            p = getMapControl().getViewPort().toMapPoint(adjustedPoint);

            /*

             * We are going to draw.

             * Is mapAdjustedPoint better in any situation?

             * 

            if (mapAdjustedPoint != null) {

                p = mapAdjustedPoint;

            } else {

                p = getMapControl().getViewPort().toMapPoint(adjustedPoint);

            }

            */

            // If the stack is empty, return

            if (cadToolStack.isEmpty()) {

                return;

            }

            if (((CADTool) cadToolStack.peek()).getVLE() == null) {

                return;

            }

            ((CADTool) cadToolStack.peek()).drawOperation(mapControlDrawer,

                p.getX(), p.getY());

        }

    }

    /**

     * <p>

     * Responds two kind of mouse click events:

     * <ul>

     * <li><b><i>One click of the third mouse's button</i></b>: displays a popup

     * with edition options.</li>

     * <li><b><i>Two clicks of the first mouse's button</i></b>: ends the last

     * cad tool setting as end transition point the event's one.</li>

     * </ul>

     * </p>

     * 

     * 

     * @see com.iver.cit.gvsig.fmap.tools.Behavior.Behavior#mouseClicked(java.awt.event.MouseEvent)

     * @see CADExtension#showPopup(MouseEvent)

     */

    public void mouseClicked(MouseEvent e) throws BehaviorException {

        if (e.getButton() == MouseEvent.BUTTON3) {

            CADExtension.showPopup(e);

        } else

            if (e.getButton() == MouseEvent.BUTTON1 && e.getClickCount() == 2) {

                questionAsked = true;

                if (!cadToolStack.isEmpty()) {

                    CADTool ct = (CADTool) cadToolStack.peek();

                    ViewPort vp = getMapControl().getMapContext().getViewPort();

                    Point2D p;

                    if (mapAdjustedPoint != null) {

                        p = mapAdjustedPoint;

                    } else {

                        p = vp.toMapPoint(adjustedPoint);

                    }

                    ct.endTransition(p.getX(), p.getY(), e);

                    previousPoint = new double[] { p.getX(), p.getY() };

                }

            }

    }

    /*

     * (non-Javadoc)

     * 

     * @see

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

     * .event.MouseEvent)

     */

    public void mouseEntered(MouseEvent e) throws BehaviorException {

        clearMouseImage();

    }

    /*

     * (non-Javadoc)

     * 

     * @see

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

     * event.MouseEvent)

     */

    public void mouseExited(MouseEvent e) throws BehaviorException {

    }

    /**

     * Selects the vertex of a geometry at the point selected on the

     * <code>MapControl</code> by pressing the first mouse's button.

     * 

     * @see com.iver.cit.gvsig.fmap.tools.Behavior.Behavior#mousePressed(java.awt.event.MouseEvent)

     */

    public void mousePressed(MouseEvent e) throws BehaviorException {

        if (e.getButton() == MouseEvent.BUTTON1) {

            ViewPort vp = getMapControl().getMapContext().getViewPort();

            Point2D p;

            mapAdjustedPoint = getMapControl().getMapAdjustedPoint();

            if (mapAdjustedPoint != null) {

                p = mapAdjustedPoint;

            } else {

                p = vp.toMapPoint(adjustedPoint);

            }

            transition(new double[] { p.getX(), p.getY() }, e, ABSOLUTE);

        }

    }

    // /**

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

    // */

    // private double adjustToHandler(Point2D point,

    // Point2D mapHandlerAdjustedPoint) {

    //

    // if (!isRefentEnabled())

    // return Double.MAX_VALUE;

    //

    // ILayerEdited aux =

    // CADExtension.getEditionManager().getActiveLayerEdited();

    // if (!(aux instanceof VectorialLayerEdited))

    // return Double.MAX_VALUE;

    // VectorialLayerEdited vle = (VectorialLayerEdited) aux;

    //

    // ArrayList snappers = vle.getSnappers();

    // ArrayList layersToSnap = vle.getLayersToSnap();

    //

    //

    // ViewPort vp = getMapControl().getViewPort();

    //

    // snappers=SnapConfigPage.getActivesSnappers();

    //

    // double mapTolerance = vp.toMapDistance(SelectionCADTool.tolerance);

    // double minDist = mapTolerance;

    // // double rw = getMapControl().getViewPort().toMapDistance(5);

    // Point2D mapPoint = point;

    // double middleTol=mapTolerance * 0.5;

    // org.gvsig.fmap.geom.primitive.Envelope r = new

    // DefaultEnvelope(mapPoint.getX() - middleTol,

    // mapPoint.getY() - middleTol,

    // mapPoint.getX() + middleTol,

    // mapPoint.getY() + middleTol);

    //

    // Envelope e = Converter.convertEnvelopeToJTS(r);

    //

    // usedSnap = null;

    // Point2D lastPoint = null;

    // if (previousPoint != null)

    // {

    // lastPoint = new Point2D.Double(previousPoint[0], previousPoint[1]);

    // }

    // for (int j = 0; j < layersToSnap.size(); j++)

    // {

    // FLyrVect lyrVect = (FLyrVect) layersToSnap.get(j);

    // SpatialCache cache = lyrVect.getSpatialCache();

    // if (lyrVect.isVisible())

    // {

    // // La lista de snappers est� siempre ordenada por prioridad. Los de

    // mayor

    // // prioridad est�n primero.

    // for (int i = 0; i < snappers.size(); i++)

    // {

    // ISnapper theSnapper = (ISnapper) snappers.get(i);

    //

    // if (usedSnap != null)

    // {

    // // Si ya tenemos un snap y es de alta prioridad, cogemos ese. (A no ser

    // que en otra capa encontremos un snapper mejor)

    // if (theSnapper.getPriority() < usedSnap.getPriority())

    // break;

    // }

    // SnappingVisitor snapVisitor = null;

    // Point2D theSnappedPoint = null;

    //

    // if (theSnapper instanceof ISnapperVectorial)

    // {

    // if (theSnapper instanceof ISnapperGeometriesVectorial) {

    // snapVisitor=new GeometriesSnappingVisitor((ISnapperGeometriesVectorial)

    // theSnapper,point,mapTolerance,lastPoint);

    // }else {

    // snapVisitor = new SnappingVisitor((ISnapperVectorial) theSnapper, point,

    // mapTolerance, lastPoint);

    // }

    // // System.out.println("Cache size = " + cache.size());

    // cache.query(e, snapVisitor);

    // theSnappedPoint = snapVisitor.getSnapPoint();

    //

    // }

    // if (theSnapper instanceof ISnapperRaster)

    // {

    // ISnapperRaster snapRaster = (ISnapperRaster) theSnapper;

    // theSnappedPoint = snapRaster.getSnapPoint(getMapControl(), point,

    // mapTolerance, lastPoint);

    // }

    //

    //

    // if (theSnappedPoint != null) {

    // double distAux = theSnappedPoint.distance(point);

    // if (minDist > distAux)

    // {

    // minDist = distAux;

    // usedSnap = theSnapper;

    // mapHandlerAdjustedPoint.setLocation(theSnappedPoint);

    // }

    // }

    // }

    // } // visible

    // }

    // if (usedSnap != null)

    // return minDist;

    // return Double.MAX_VALUE;

    //

    // }

    /*

     * (non-Javadoc)

     * 

     * @see

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

     * .event.MouseEvent)

     */

    public void mouseReleased(MouseEvent e) throws BehaviorException {

        getMapControl().repaint();

    }

    /*

     * (non-Javadoc)

     * 

     * @see

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

     * .event.MouseEvent)

     */

    public void mouseDragged(MouseEvent e) throws BehaviorException {

        lastX = e.getX();

        lastY = e.getY();

        adjustedPoint = e.getPoint();

        // calculateSnapPoint(e.getPoint());

    }

    /*

     * (non-Javadoc)

     * 

     * @see

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

     * .MouseEvent)

     */

    public void mouseMoved(MouseEvent e) throws BehaviorException {

        lastX = e.getX();

        lastY = e.getY();

        adjustedPoint = e.getPoint();

        // calculateSnapPoint(e.getPoint());

        showCoords(e.getPoint());

        getMapControl().repaint();

    }

    /**

     * Displays the current coordinates of the mouse's cursor on the associated

     * <code>MapControl</code> object, at the status bar of the application's

     * main frame.

     * 

     * @param pPix

     *            current 2D mouse's cursor coordinates on the

     *            <code>MapControl</code>

     */

    private void showCoords(Point2D pPix) {

        String[] axisText = new String[2];

        axisText[0] = "X = ";

        axisText[1] = "Y = ";

        // NumberFormat nf = NumberFormat.getInstance();

        MapControl mapControl = getMapControl();

        ViewPort vp = mapControl.getMapContext().getViewPort();

        IProjection iProj = vp.getProjection();

        // if (iProj.getAbrev().equals("EPSG:4326") ||

        // iProj.getAbrev().equals("EPSG:4230")) {

        // axisText[0] = "Lon = ";

        // axisText[1] = "Lat = ";

        // nf.setMaximumFractionDigits(8);

        // } else {

        // axisText[0] = "X = ";

        // axisText[1] = "Y = ";

        // nf.setMaximumFractionDigits(2);

        // }

        Point2D p;

        if (mapAdjustedPoint == null) {

            p = vp.toMapPoint(pPix);

        } else {

            p = mapAdjustedPoint;

        }

        sbl.setFractionDigits(p);

        axisText = sbl.setCoorDisplayText(axisText);

        MainFrame mF = PluginServices.getMainFrame();

        if (mF != null) {

            mF.getStatusBar().setMessage(

                "units",

                PluginServices.getText(this,

                    MapContext.getDistanceNames()[vp.getDistanceUnits()]));

            mF.getStatusBar().setControlValue("scale",

                String.valueOf(mapControl.getMapContext().getScaleView()));

            mF.getStatusBar().setMessage("projection", iProj.getAbrev());

            String[] coords = sbl.getCoords(p);

            mF.getStatusBar().setMessage("x", axisText[0] + coords[0]);

            mF.getStatusBar().setMessage("y", axisText[1] + coords[1]);

        }

    }

    /**

     * Hides the mouse's cursor.

     */

    private void clearMouseImage() {

        int[] pixels = new int[16 * 16];

        Image image =

            Toolkit.getDefaultToolkit().createImage(

                new MemoryImageSource(16, 16, pixels, 0, 16));

        Cursor transparentCursor =

            Toolkit.getDefaultToolkit().createCustomCursor(image,

                new Point(0, 0), "invisiblecursor");

        getMapControl().setCursor(transparentCursor);

    }

    /**

     * <p>

     * Draws a 31x31 pixels cross round the mouse's cursor with an small

     * geometry centered:

     * <ul>

     * <li><i>an square centered</i>: if isn't over a <i>control point</i>.

     * <li><i>an small geometry centered according to the kind of control

     * point</i>: if it's over a control point. In this case, the small geometry

     * is drawn by a {@link ISnapper ISnapper} type object.<br>

     * 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

     */

    // private void drawCursor(Graphics g) {

    // g.setColor(Color.black);

    // Point2D p = adjustedPoint;

    //

    // if (p == null) {

    // getGrid().setViewPort(getMapControl().getViewPort());

    //

    // return;

    // }

    //

    // int size1 = 15;

    // int size2 = 3;

    // g.drawLine((int) (p.getX() - size1), (int) (p.getY()),

    // (int) (p.getX() + size1), (int) (p.getY()));

    // g.drawLine((int) (p.getX()), (int) (p.getY() - size1),

    // (int) (p.getX()), (int) (p.getY() + size1));

    //

    // // getMapControl().setToolTipText(null);

    // if (adjustedPoint != null) {

    // if (bForceCoord) {

    // /* g.setColor(Color.ORANGE);

    // g.drawRect((int) (adjustedPoint.getX() - 6),

    // (int) (adjustedPoint.getY() - 6), 12, 12);

    // g.drawRect((int) (adjustedPoint.getX() - 3),

    // (int) (adjustedPoint.getY() - 3), 6, 6);

    // g.setColor(Color.MAGENTA);

    // g.drawRect((int) (adjustedPoint.getX() - 4),

    // (int) (adjustedPoint.getY() - 4), 8, 8); */

    // if (usedSnap != null)

    // {

    // usedSnap.draw(g, adjustedPoint);

    //

    // Graphics2D g2 = (Graphics2D) g;

    // FontMetrics metrics = g2.getFontMetrics();

    // int w = metrics.stringWidth(usedSnap.getToolTipText()) + 5;

    // int h = metrics.getMaxAscent() + 5;

    // int x = (int)p.getX()+9;

    // int y = (int)p.getY()- 7;

    //

    // g2.setColor(theTipColor );

    // g2.fillRect(x, y-h, w, h);

    // g2.setColor(Color.BLACK);

    // g2.drawRect(x, y-h, w, h);

    // g2.drawString(usedSnap.getToolTipText(), x+3, y-3);

    //

    //

    // // getMapControl().setToolTipText(usedSnap.getToolTipText());

    // }

    //

    // bForceCoord = false;

    // } else {

    // g.drawRect((int) (p.getX() - size2), (int) (p.getY() - size2),

    // (int) (size2 * 2), (int) (size2 * 2));

    // }

    // }

    // }

    /**

     * <p>

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

     * of the current snap tool.

     * </p>

     * 

     * <p>

     * Prioritizes the grid control points than the geometries ones.

     * </p>

     * 

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

     */

    // private void calculateSnapPoint(Point point) {

    // // Se comprueba el ajuste a rejilla

    //

    // Point2D gridAdjustedPoint = getMapControl().getViewPort().toMapPoint(

    // point);

    // double minDistance = Double.MAX_VALUE;

    // CADTool ct = (CADTool) cadToolStack.peek();

    // if (ct instanceof SelectionCADTool

    // && ((SelectionCADTool) ct).getStatus().equals(

    // "Selection.FirstPoint")) {

    // mapAdjustedPoint = gridAdjustedPoint;

    // adjustedPoint = (Point2D) point.clone();

    // } else {

    //

    // minDistance = getGrid().adjustToGrid(gridAdjustedPoint);

    // if (minDistance < Double.MAX_VALUE) {

    // adjustedPoint = getMapControl().getViewPort().fromMapPoint(

    // gridAdjustedPoint);

    // mapAdjustedPoint = gridAdjustedPoint;

    // } else {

    // mapAdjustedPoint = null;

    // }

    // }

    // Point2D handlerAdjustedPoint = null;

    //

    // // Se comprueba el ajuste a los handlers

    // if (mapAdjustedPoint != null) {

    // handlerAdjustedPoint = (Point2D) mapAdjustedPoint.clone(); //

    // getMapControl().getViewPort().toMapPoint(point);

    // } else {

    // handlerAdjustedPoint = getMapControl().getViewPort().toMapPoint(

    // point);

    // }

    //

    // Point2D mapPoint = new Point2D.Double();

    // double distance = adjustToHandler(handlerAdjustedPoint, mapPoint);

    //

    // if (distance < minDistance) {

    // bForceCoord = true;

    // adjustedPoint = getMapControl().getViewPort().fromMapPoint(mapPoint);

    // mapAdjustedPoint = mapPoint;

    // minDistance = distance;

    // }

    //

    // // Si no hay ajuste

    // if (minDistance == Double.MAX_VALUE) {

    // adjustedPoint = point;

    // mapAdjustedPoint = null;

    // }

    //

    // }

    /*

     * (non-Javadoc)

     * 

     * @see

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

     * awt.event.MouseWheelEvent)

     */

    public void mouseWheelMoved(MouseWheelEvent e) throws BehaviorException {

    }

    /**

     * <p>

     * Process the information written by the user about the next point

     * coordinate, determining the kind of <i>transition</i> according the

     * parameters written.

     * </p>

     * 

     * <p>

     * After, invokes one of the three possible <i>transition</i> methods of the

     * <i>finite machine</i> of edition:

     * <ul>

     * <li><i>First transition type: <b>Point</i></b>: if <code>text</code>

     * matches with any pattern of parameters needed for any kind of point

     * coordinates.<br>

     * There are eight ways of introducing point 2D coordinates:

     * <ul>

     * <li><i>X,Y</i> : absolute cardinal 2D coordinate from the center

     * <i>(0,0)</i> of the CCS <i>Current Coordinate System</i>.</li>

     * <li><i>@X,Y</i> : relative cardinal 2D distances from the last point

     * added of the CCS. If it's the first point of the geometry, works like

     * <i>X,Y</i>.</li>

     * <li><i>length< angle</i> : absolute polar 2D coordinate from the center

     * <i>(0,0)</i> of the CCS <i>Current Coordinate System</i>, using

     * <i>angle</i> from the <i>X</i> axis of CCS, and <i>length</i> far away.</li>

     * <li><i>@length< angle</i> : relative polar 2D coordinate from the last

     * point added of the CCS <i>Current Coordinate System</i>, using

     * <i>angle</i> from the <i>X</i> axis of CCS, and <i>length</i> far away.

     * If it's the first point of the geometry, works like <i>length< angle</i>.

     * </li>

     * <li><i>*X,Y</i> : like <i>X,Y</i> but using UCS <i>Universal Coordinate

     * System</i> as reference.</li>

     * <li><i>@*X,Y</i> : like <i>@X,Y</i> but using UCS <i>Universal Coordinate

     * System</i> as reference. If it's the first point of the geometry, works

     * like <i>*X,Y</i>.</li>

     * <li><i>*length< angle</i> : like <i>length< angle</i> but using UCS

     * <i>Universal Coordinate System</i> as reference.</li>

     * <li><i>@*length< angle</i> : like <i>@length< angle</i> but using UCS

     * <i>Universal Coordinate System</i> as reference. If it's the first point

     * of the geometry, works like <i>*length< angle</i>.</li>

     * </ul>

     * </li>

     * <li><i>Second transition type: <b>Value</i></b>: if recognizes it as a

     * single number.</li>

     * <li><i>Third transition type: <b>Option</i></b>: by default, if can't

     * classify the information as a single number neither as a point. This

     * information will be an <code>String</code> and dealt as an option of the

     * current tool state. Ultimately, if isn't valid, <code>text</code> will be

     * rewritten in the console notifying the user that isn't correct.</li>

     * </ul>

     * </p>

     * 

     * @param text

     *            command written by user in the edition's console

     */

    public void textEntered(String text) {

        if (text == null) {

            transition(PluginServices.getText(this, "cancel"));

        } else {

            /*

             * if ("".equals(text)) { transition("aceptar"); } else {

             */

            text = text.trim();

            int type = ABSOLUTE;

            String[] numbers = new String[1];

            numbers[0] = text;

            if (text.indexOf(",") != -1) {

                numbers = text.split(",");

                if (numbers[0].substring(0, 1).equals("@")) {

                    numbers[0] = numbers[0].substring(1, numbers[0].length());

                    type = RELATIVE_SCU;

                    if (numbers[0].substring(0, 1).equals("*")) {

                        type = RELATIVE_SCP;

                        numbers[0] =

                            numbers[0].substring(1, numbers[0].length());

                    }

                }

            } else

                if (text.indexOf("<") != -1) {

                    type = POLAR_SCP;

                    numbers = text.split("<");

                    if (numbers[0].substring(0, 1).equals("@")) {

                        numbers[0] =

                            numbers[0].substring(1, numbers[0].length());

                        type = POLAR_SCU;

                        if (numbers[0].substring(0, 1).equals("*")) {

                            type = POLAR_SCP;

                            numbers[0] =

                                numbers[0].substring(1, numbers[0].length());

                        }

                    }

                }

            double[] values = null;

            try {

                if (numbers.length == 2) {

                    // punto

                    values =

                        new double[] { Double.parseDouble(numbers[0]),

                            Double.parseDouble(numbers[1]) };

                    transition(values, null, type);

                } else

                    if (numbers.length == 1) {

                        // valor

                        values =

                            new double[] { Double.parseDouble(numbers[0]) };

                        transition(values[0]);

                    }

            } catch (NumberFormatException e) {

                transition(text);

            } catch (NullPointerException e) {

                transition(text);

            }

            // }

        }

        getMapControl().repaint();

    }

    /**

     * If there are options related with the <code>CADTool</code> at the peek

     * of the CAD tool stack, displays them as a popup.

     */

    public void configureMenu() {

        String[] desc = ((CADTool) cadToolStack.peek()).getDescriptions();

        // String[] labels = ((CADTool)

        // cadToolStack.peek()).getCurrentTransitions();

        CADExtension.clearMenu();

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

            if (desc[i] != null) {

                CADExtension

                    .addMenuEntry(PluginServices.getText(this, desc[i]));// ,

                // labels[i]);

            }

        }

    }

    /**

     * <p>

     * One of the three kind of transaction methods of the <i>finite machine</i>

     * of edition.

     * </p>

     * 

     * <p>

     * This one deals <code>values</code> as two numbers that, according

     * <code>type</code> calculate a new point 2D in the current layer edited in

     * the associated <code>MapControl</code>.

     * </p>

     * 

     * <p>

     * There are different ways of calculating the new point 2D coordinates,

     * according the value of <code>type</code>, see

     * {@link #textEntered(String) #textEntered(String)}.

     * </p>

     * 

     * <p>

     * After applying the changes, updates the controls available for managing

     * the current data.

     * </p>

     * 

     * @param values

     *            numbers needed to calculate the new point coordinates

     *            according <code>type</code>

     * @param event

     *            event which generated this invocation (a

     *            <code>MouseEvent</code> or a <code>KeyEvent</code>)

     * @param type

     *            kind of information that is <code>values</code>. According

     *            this parameter, will calculate the new point in a different

     *            way

     * 

     * @see CADTool#transition(double, double, InputEvent)

     * @see #transition(double)

     * @see #transition(String)

     */

    private void transition(double[] values, InputEvent event, int type) {

        questionAsked = true;

        if (!cadToolStack.isEmpty()) {

            CADTool ct = (CADTool) cadToolStack.peek();

            switch (type) {

            case ABSOLUTE:

                ct.transition(values[0], values[1], event);

                previousPoint = values;

                break;

            case RELATIVE_SCU:

                // Comprobar que tenemos almacenado el punto anterior

                // y crear nuevo con coordenadas relativas a �l.

                double[] auxSCU = values;

                if (previousPoint != null) {

                    auxSCU[0] = previousPoint[0] + values[0];

                    auxSCU[1] = previousPoint[1] + values[1];

                }

                ct.transition(auxSCU[0], auxSCU[1], event);

                previousPoint = auxSCU;

                break;

            case RELATIVE_SCP:

                // TODO de momento no implementado.

                ct.transition(values[0], values[1], event);

                previousPoint = values;

                break;

            case POLAR_SCU:// Relativo

                // Comprobar que tenemos almacenado el punto anterior

                // y crear nuevo con coordenadas relativas a �l.

                double[] auxPolarSCU = values;

                if (previousPoint != null) {

                    Point2D point =

                        UtilFunctions.getPoint(new Point2D.Double(

                            previousPoint[0], previousPoint[1]), Math

                            .toRadians(values[1]), values[0]);

                    auxPolarSCU[0] = point.getX();

                    auxPolarSCU[1] = point.getY();

                    ct.transition(auxPolarSCU[0], auxPolarSCU[1], event);

                } else {

                    Point2D point =

                        UtilFunctions.getPoint(new Point2D.Double(0, 0),

                            Math.toRadians(values[1]), values[0]);

                    auxPolarSCU[0] = point.getX();

                    auxPolarSCU[1] = point.getY();

                    ct.transition(auxPolarSCU[0], auxPolarSCU[1], event);

                }

                previousPoint = auxPolarSCU;

                break;

            case POLAR_SCP:// Absoluto

                double[] auxPolarSCP = values;

                if (previousPoint != null) {

                    Point2D point =

                        UtilFunctions.getPoint(new Point2D.Double(0, 0),

                            Math.toRadians(values[1]), values[0]);

                    auxPolarSCP[0] = point.getX();

                    auxPolarSCP[1] = point.getY();

                    ct.transition(auxPolarSCP[0], auxPolarSCP[1], event);

                } else {

                    Point2D point =

                        UtilFunctions.getPoint(new Point2D.Double(0, 0),

                            values[1], values[0]);

                    auxPolarSCP[0] = point.getX();

                    auxPolarSCP[1] = point.getY();

                    ct.transition(auxPolarSCP[0], auxPolarSCP[1], event);

                }

                previousPoint = auxPolarSCP;

                break;

            default:

                break;

            }

            askQuestion();

        }

        configureMenu();

        PluginServices.getMainFrame().enableControls();

    }

    /**

     * <p>

     * One of the three kind of transaction methods of the <i>finite machine</i>

     * of edition.

     * </p>

     * 

     * <p>

     * This one deals <code>value</code> as a single number used as a parameter

     * for the current tool state. Ultimately, if isn't valid,

     * <code>number</code> will be rewritten in the console notifying the user

     * that isn't correct.

     * </p>

     * 

     * <p>

     * After applying the changes, updates the controls available for managing

     * the current data.

     * </p>

     * 

     * @param value

     *            value for the current tool state

     * 

     * @see CADTool#transition(double)

     * @see #transition(double[], InputEvent, int)

     * @see #transition(String)

     */

    private void transition(double value) {

        questionAsked = true;

        if (!cadToolStack.isEmpty()) {

            CADTool ct = (CADTool) cadToolStack.peek();

            ct.transition(value);

            askQuestion();

        }

        configureMenu();

        PluginServices.getMainFrame().enableControls();

    }

    /**

     * <p>

     * One of the three kind of transaction methods of the <i>finite machine</i>

     * of edition.

     * </p>

     * 

     * <p>

     * This one deals <code>option</code> as an option of the current tool

     * state. Ultimately, if isn't valid, <code>option</code> will be rewritten

     * in the console notifying the user that isn't correct.

     * </p>

     * 

     * @param option

     *            option for the current tool state

     * 

     * @see CADTool#transition(String)

     * @see #transition(double[], InputEvent, int)

     * @see #transition(double)

     */

    public void transition(String option) {

        questionAsked = true;

        if (!cadToolStack.isEmpty()) {

            CADTool ct = (CADTool) cadToolStack.peek();

            try {

                ct.transition(option);

            } catch (Exception e) {

                IWindow window =

                    PluginServices.getMDIManager().getActiveWindow();

                if (window instanceof DefaultViewPanel) {

                    ((DefaultViewPanel) window).getConsolePanel().addText(

                        "\n" + PluginServices.getText(this, "incorrect_option")

                            + " : " + option, JConsole.ERROR);

                }

            }

            askQuestion();

        }

        configureMenu();

        PluginServices.getMainFrame().enableControls();

    }

    /**

     * Shows or hides a grid on the <code>ViewPort</code> of the associated

     * <code>MapControl</code>.

     * 

     * @param value

     *            <code>true</code> to make the grid visible; <code>false</code>

     *            to make it invisible

     */

    // public void setGridVisibility(boolean value) {

    // getGrid().setShowGrid(value);

    // getGrid().setViewPort(getMapControl().getViewPort());

    // getMapControl().repaint();

    // }

    // /**

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

    // bRefent = activated;

    // }

    //

    // /**

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

    // {

    // return bRefent;

    // }

    /*

     * (non-Javadoc)

     * 

     * @see com.iver.cit.gvsig.fmap.tools.Behavior.Behavior#getListener()

     */

    public ToolListener getListener() {

        return new ToolListener() {

            /**

             * @see com.iver.cit.gvsig.fmap.tools.Listeners.ToolListener#getCursor()

             */

            public Image getImageCursor() {

                return imageCursor;

            }

            /**

             * @see com.iver.cit.gvsig.fmap.tools.Listeners.ToolListener#cancelDrawing()

             */

            public boolean cancelDrawing() {

                return false;

            }

        };

    }

    /**

     * Returns the {@link CADTool CADTool} at the top of the stack without

     * removing it from the CAD tool stack.

     * 

     * @return the {@link CADTool CADTool} at the top of the stack

     * 

     * @see #pushCadTool(CADTool)

     * @see #popCadTool()

     * @see #setCadTool(CADTool)

     */

    public CADTool getCadTool() {

        return (CADTool) cadToolStack.peek();

    }

    /**

     * <p>