Application: gvSIG desktop

import java.awt.Cursor;

import java.awt.FontMetrics;

import java.awt.Image;

import java.awt.Point;

import java.awt.Toolkit;

import java.awt.image.MemoryImageSource;

import java.util.ArrayList;

import java.util.prefs.Preferences;

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

import org.gvsig.fmap.mapcontext.layers.SpatialCache;

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

import org.gvsig.fmap.mapcontrol.tools.grid.Grid;

import org.gvsig.fmap.mapcontrol.tools.snapping.GeometriesSnappingVisitor;

import org.gvsig.fmap.mapcontrol.tools.snapping.SnappingVisitor;

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;

	/**

	 * Edition preferences.

	 */

	private static Preferences prefs = Preferences.userRoot().node( "cadtooladapter" );

	/**

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

	 *

	 * @see #getGrid()

	 * @see #setAdjustGrid(boolean)

	 */

	private Grid cadgrid = new Grid();

	/**

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

	 *

	 * @see ViewPort#fromMapPoint(Point2D)

	 */

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

	/**

	 * A light yellow color for the tool tip text box associated to the point indicated by the mouse's cursor.

	 */

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

	 * Determines if the snap tools are enabled or disabled.

	 *

	 * @see #isRefentEnabled()

	 * @see #setRefentEnabled(boolean)

	 */

	private boolean bRefent = true;

	/**

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

	 */

	private double[] previousPoint = null;

	private static HashMap selected = new HashMap();

	private static int tolerance=4;

	/**

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

	 *

	 * @see MapControl#toMapPoint

	 */

	private Point2D mapAdjustedPoint;

	/**

		initializeGrid();

			cadgrid.setViewPort(vp);

//		this.setCursor(mapTool.getCursor());

		cadgrid.drawGrid(g);

		drawCursor(g);

			clearMouseImage();

			calculateSnapPoint(e.getPoint());

			repaint();

			calculateSnapPoint(e.getPoint());

			repaint();

	/**

	 * <p>Updates the grid on the <code>ViewPort</code> of the associated <code>MapControl</code>

	 *  object according the values in the {@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>

	 *   <li>Show/hide the grid.</li>

	 *   <li>Adjust or not the grid.</li>

	 *   <li>Horizontal ( X ) line separation.</li>

	 *   <li>Vertical ( Y ) line separation.</li>

	 *  </ul>

	 * </p>

	 */

	public void initializeGrid(){

		boolean showGrid = prefs.getBoolean("grid.showgrid",cadgrid.isShowGrid());

		boolean adjustGrid = prefs.getBoolean("grid.adjustgrid",cadgrid.isAdjustGrid());

		double dx = prefs.getDouble("grid.distancex",cadgrid.getGridSizeX());

		double dy = prefs.getDouble("grid.distancey",cadgrid.getGridSizeY());

		setGridVisibility(showGrid);

		setAdjustGrid(adjustGrid);

		cadgrid.setGridSizeX(dx);

		cadgrid.setGridSizeY(dy);

	}

	public void setAdjustGrid(boolean adjustGrid) {

		cadgrid.setAdjustGrid(adjustGrid);

	}

	public void setGridVisibility(boolean showGrid) {

		cadgrid.setShowGrid(showGrid);

		cadgrid.setViewPort(getViewPort());

		this.repaint();

	}

	/**

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

		Image cursor=getCurrentMapTool().getImageCursor();

		g.setColor(Color.black);

		Point2D p = adjustedPoint;

		if (p == null) {

			cadgrid.setViewPort(vp);

			return;

		}

		g.drawImage(cursor, (int)p.getX()-16, (int)p.getY()-16, this);

//		int size1 = 15;

//		int size2 = 3;

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

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

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

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

//

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

//		if (adjustedPoint != null) {

//			if (bForceCoord) {

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

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

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

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

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

//				g.setColor(Color.MAGENTA);

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

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

//				if (usedSnap != null)

//				{

//					usedSnap.draw(g, adjustedPoint);

//

//					Graphics2D g2 = (Graphics2D) g;

//			        FontMetrics metrics = g2.getFontMetrics();

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

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

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

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

//

//			        g2.setColor(theTipColor );

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

//			        g2.setColor(Color.BLACK);

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

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

//

//

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

//				}

//

//				bForceCoord = false;

//			} else {

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

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

//			}

//		}

//		repaint();

	}

	/**

	 * Hides the mouse's cursor.

	 */

	private void clearMouseImage() {

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

		Image image = Toolkit.getDefaultToolkit().createImage(

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

		Cursor transparentCursor = Toolkit.getDefaultToolkit()

				.createCustomCursor(image, new Point(0, 0), "invisiblecursor");

		setCursor(transparentCursor);

	}

	/**

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

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

	 *

	 * <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 layersToSnap = getMapContext().getLayersToSnap();

		ArrayList snappers=new ArrayList(selected.keySet());

		double mapTolerance = vp.toMapDistance(MapControl.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);

		com.vividsolutions.jts.geom.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(this, 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;

	}

	/**

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

	}

	public void initializeSnapping() {

		ArrayList snappers=getMapContext().getSnappers();

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

            ISnapper snp = (ISnapper) snappers.get(n);

            String nameClass=snp.getClass().getName();

            nameClass=nameClass.substring(nameClass.lastIndexOf('.'));

            boolean select = prefs.getBoolean("snapper_activated" + nameClass, false);

            if (select)

            	selected.put(snp, new Boolean(select));

            int priority = prefs.getInt("snapper_priority" + nameClass,3);

            snp.setPriority(priority);

        }

//        applySnappers = prefs.getBoolean("apply-snappers",true);

//        snapConfig.setApplySnappers(applySnappers);

//        snapConfig.selectSnappers(selected);

    }

	/**

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

	 */

	public Point2D calculateSnapPoint(Point point) {

		// Se comprueba el ajuste a rejilla

		Point2D gridAdjustedPoint = vp.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 = cadgrid.adjustToGrid(gridAdjustedPoint);

			if (minDistance < Double.MAX_VALUE) {

				adjustedPoint = vp.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 = vp.toMapPoint(

					point);

		}

		Point2D mapPoint = new Point2D.Double();

		double distance = adjustToHandler(handlerAdjustedPoint, mapPoint);

		if (distance < minDistance) {

			bForceCoord = true;

			adjustedPoint = vp.fromMapPoint(mapPoint);

			mapAdjustedPoint = mapPoint;

			minDistance = distance;

		}

		// Si no hay ajuste

		if (minDistance == Double.MAX_VALUE) {

			adjustedPoint = point;

			mapAdjustedPoint = null;

		}

		return mapAdjustedPoint;

	}

	/**

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

	}

	public Grid getGrid() {

		return cadgrid;

	}

	public static HashMap getSelectedSnapppers() {

		return selected;

	}