| gvSIG desktop 1

/**

 * <p>The <code>MapContext</code> class represents the model and a part of the control and view around graphical layers

 * used by {@link MapControl MapControl}.</p>

 * <p>An instance of <code>MapContext</code> is made up with:

 * <ul>

 * <li>a hierarchy of {@link FLayers FLayers} nodes

 * <li>a {@link GraphicLayer GraphicLayer} layer

 * <li>a {@link ViewPort ViewPort}

 * <li>an {@link EventBuffer EventButter}

 * <li>some {@link LayerDrawingListener LayerDrawingListener}s

 * <li>some {@link LayerEventListener LayerEventListener}s

 * <li>some {@link ErrorListener ErrorListener}s

public class MapContext implements Projected {

	/**

	 * <p>Defines the value which a unit of a distance measurement must be divided to obtain its equivalent <b>in meters</b>.</p>

	 * <p><b><i>Conversion values of distance measurements:</i></b>

	 * <ul>

	 *  <li><code>MapContext.CHANGEM[0]</code>: kilometer

	 *  <li><code>MapContext.CHANGEM[7]</code>: inch

	 *  <li><code>MapContext.CHANGEM[8]</code>: grade

	 * </ul>

	 * <p><h3>Examples:</h3>

	 * <pre>1 international statute mile / MapContext.CHANGEM[4] = X meters</pre>

	 * <pre>1 kilometer / MapContext.CHANGEM[0] = X meters</pre>

	 * <pre>1 grade / MapContext.CHANGEM[8] = X meters</pre>

	 * </p>

	 * The value of <code>MapContext.CHANGEM[8]</code> represents the meters of a straight line between two

	 *  a radius approximated of R<sub>Earth</sub>=6.37846082678100774672e6 meters, according these equations:

	 * <pre>D = 2 * (sin (1)) * R<sub>Earth</sub></pre>

	 * <pre>MapContext.CHANGEM[8] = 1 / D</pre>

	/**

	 * <p>Defines the value which a unit of a distance measurement must be divided to obtain its equivalent <b>in centimeters</b>.</p>

	 * <p><b><i>Conversion values of distance measurements:</i></b>

	 * <ul>

	 *  <li><code>MapContext.CHANGE[0]</code>: kilometer

	 *  <li><code>MapContext.CHANGE[7]</code>: inch

	 *  <li><code>MapContext.CHANGE[8]</code>: grade

	 * </ul>

	 * <p><h3>Examples:</h3>

	 * <pre>1 international statute mile / MapContext.CHANGE[4] = X centimeters</pre>

	 * <pre>1 kilometer / MapContext.CHANGE[0] = X centimeters</pre>

	 * <pre>1 grade / MapContext.CHANGE[8] = X centimeters</pre>

	 * </p>

	 * The value of <code>MapContext.CHANGE[8]</code> represents the centimeters of a straight line between two

	 *  a radius approximated of R<sub>Earth</sub>=6.37846082678100774672e6 meters, according these equations:

	 * <pre>D = 2 * (sin (1)) * R<sub>Earth</sub></pre>

	 * <pre>MapContext.CHANGE[8] = 1 / D</pre>

			91.44, 30.48, 2.54, 1/8.983152841195214E-4 };

	/* Do not alter the order and the values of this array, if you need append values.*/

	public static final String[] NAMES= {

		Messages.getString("Kilometros"),

		Messages.getString("Metros"),

	public static final int CONTAINS = 6;

	public static final int OVERLAPS = 7;

	/**

	 * A hierarchy of {@link FLayers FLayers} nodes.

	 * @see #getLayers()

	 * @see #print(Graphics2D, double, PrintRequestAttributeSet)

	 */

	protected FLayers layers;

	/**

	 * A layer with graphical items: geometries and symbols.

	 * @see #getGraphicsLayer()

	 * @see #setGraphicsLayer(GraphicLayer)

	 * @see #drawGraphics(BufferedImage, Graphics2D, Cancellable, double)

	 * @see #print(Graphics2D, double, PrintRequestAttributeSet)

	 */

	private GraphicLayer tracLayer = new GraphicLayer();

	/**

	 * Information for draw layers in a view.

	 * @see #getViewPort()

	 * @see #setViewPort(ViewPort)

	 */

	/**

	 * Array list with all {@link LegendListener LegendListener} registered to this map.

	 * @see #addLayerListener(LegendListener)

	 * @see #removeLayerListener(LegendListener)

	 * @see #callLegendChanged()

	/**

	 * Array list with all {@link LayerDrawingListener LayerDrawingListener} registered to this map.

	 * @see #addLayerDrawingListener(LayerDrawingListener)

	 * @see #removeLayerDrawListener(LayerDrawingListener)

	 * @see #fireLayerDrawingEvent(LayerDrawEvent)

	 */

	private ArrayList layerDrawingListeners = new ArrayList();

	/**

	 * <p>Buffer that is used to store and eject events produced on this map:

	 * <ul>

	 *  <li>Selection events on an {@link AlphanumericData AlphanumericData} data layer.

	 * </ul>

	 * </p>

	 * @see #addAtomicEventListener(AtomicEventListener)

	 * @see #removeAtomicEventListener(AtomicEventListener)

	 * @see #beginAtomicEvent()

	 * @see #endAtomicEvent()

	 */

	private EventBuffer eventBuffer = new EventBuffer();

	/**

	 * Event listener for the collection of layers of this map.

	 */

	private LayerEventListener layerEventListener = null;

	/**

	 * List with information of all errors produced on all layers.

	 * @see #addLayerError(String)

	 * @see #getLayersError()

	 * @see #clearErrors()

	 */

	private ArrayList layersError = new ArrayList();

	/**

	 * Array list with all {@link ErrorListener ErrorListener} registered to this map.

	 * @see #addErrorListener(ErrorListener)

	 * @see #removeErrorListener(LegendListener)

	 * @see #callNewErrorEvent(ErrorEvent)

	// ResourceBundle.getBundle("FMap");

	/**

	 * <p>Doing a <i>zoom in</i> operation, decreases the focal distance and increases the eyesight angle to the surface. This allows view an smaller

	 * area but with the items bigger.</p>

	 */

	public static double ZOOMINFACTOR=2;

	/**

	 * <p>Doing a <i>zoom out</i> operation, increases the focal distance and decreases the eyesight angle to the surface. This allows view a bigger

	 * area but with the items smaller.</p>

	 */

	public static double ZOOMOUTFACTOR=0.5;

	private static Color selectionColor = Color.YELLOW;

	/**

	 *

	 */

	public static Color getSelectionColor() {

		return selectionColor;

	}

	/**

	 *

	 */

	public static void setSelectionColor(Color selectionColor) {

		MapContext.selectionColor = selectionColor;

	}

	/**

	 * <p>Creates a new map context with the drawing information defined in the view port argument, and

	 *  without layers.</p>

	 *

	 */

	public MapContext(ViewPort vp) {

		this.layers = new FLayers();//(this,null);

		setViewPort(vp);

	}

	/**

	 * <p>Creates a new map context with the layers and the drawing information defined in the view port arguments.</p>

	 * @param fLayers the initial hierarchy of nodes of layers that this map will have

	 */

	public MapContext(FLayers fLayers, ViewPort vp) {

		this.layers = fLayers;

	}

	/**

	 * @param introductoryText introductory text specified by developer. If <code>null</code>, use ""

	 * @param driverExceptions list with a bundle of driver exceptions caught during an atomic event

	 * @see #addErrorListener(ErrorListener)

	 * @see #removeErrorListener(LegendListener)

	 * @see #callNewErrorEvent(ErrorEvent)

		}

	}

	/**

	 * <p>Adds the specified legend listener (if didn't exist) to receive legend events from this map.</p>

	 *

	 * @param listener the legend listener

	 * @see #removeLayerListener(LegendListener)

	 * @see #callLegendChanged()

	 */

	/**

	 * <p>Adds the specified layer drawing listener to catch and handle drawing events from layers of this map.</p>

	 * @param listener the listener to add

	 * @see #removeLayerDrawListener(LayerDrawingListener)

	 * @see #fireLayerDrawingEvent(LayerDrawEvent)

	 */

	public void addLayerDrawingListener(LayerDrawingListener listener) {

		layerDrawingListeners.add(listener);

	}

	/**

	 * <p>Removes the specified layer drawing listener from this map.</p>

	 * @param listener the listener to remove

	 * @see #addLayerDrawingListener(LayerDrawingListener)

	 * @see #fireLayerDrawingEvent(LayerDrawEvent)

	 */

	public void removeLayerDrawListener(LayerDrawingListener listener) {

		layerDrawingListeners.remove(listener);

	}

	/**

	 * <p>Adds the specified error listener to receive error events from this map.</p>

	 * @param listener the listener to add

	 * @see #removeErrorListener(LegendListener)

	 * @see #callNewErrorEvent(ErrorEvent)

	 * @see #reportDriverExceptions(String, List)

	public void addErrorListener(ErrorListener listener) {

		errorListeners.add(listener);

	}

	/**

	 * <p>Removes the specified error listener from this map.</p>

	 * @param listener the listener to remove

	 * @see #addErrorListener(ErrorListener)

	 * @see #callNewErrorEvent(ErrorEvent)

	 * @see #reportDriverExceptions(String, List)

	/**

	 * <p>Notifies to all legend listeners registered, that one legend has changed.</p>

	 * @see #addLayerListener(LegendListener)

	 * @see #removeLayerListener(LegendListener)

	 */

		}

		// getLayers().moveTo(0,0);

	}

	/**

	 * <p>Fires a layer drawing event to all {@link LayerDrawingListener LayerDrawingListener} listeners registered,

	 *  distinguishing the kind of event.</p>

	 * @param e the event

	 *

	 * @see #addLayerDrawingListener(LayerDrawingListener)

		}

		// getLayers().moveTo(0,0);

	}

	/**

	 * <p>Notifies to all error listeners registered, that one error has been produced.</p>

	 * @param e the event with information of the error

	 * @see #addErrorListener(ErrorListener)

	 * @see #removeErrorListener(LegendListener)

	 * @see #reportDriverExceptions(String, List)

	/**

	 * <p>Removes the specified layer listener from this map.</p>

	 * @param listener the listener to remove

	 * @see #addLayerListener(LegendListener)

	 * @see #callLegendChanged()

	 */

		return layers;

	}

	/**

	 * <p>Draws the visible layers of this map according its view port, on the image parameter.</p>

	 *

	 * @param scale the scale of the view. Must be between {@linkplain FLayer#getMinScale()} and {@linkplain FLayer#getMaxScale()}.

	 * @param properties a set with the settings to be applied to a whole print job and to all the documents in the print job

	 *

	 * @see FLayers#print(Graphics2D, ViewPort, Cancellable, double, PrintRequestAttributeSet)

	 * @see GraphicLayer#draw(BufferedImage, Graphics2D, ViewPort, Cancellable, double)

	 */

		layers.print(g, viewPort, cancel, scale, properties);

		tracLayer.draw(null, g, viewPort, cancel, scale);

	}

	/**

	 *

	 *

	 */

	public MapContext createNewFMap(ViewPort vp) {

		MapContext ret = new MapContext(vp);

	}

	/**

	 * <p>The new map will have the same data source drivers to avoid waste memory, and work faster.</p>

	 *

	 *

	 * @throws XMLException if fails cloning the view port or a layer

	 * @see FLayer#cloneLayer()

	 * @see ViewPort#cloneViewPort()

	 */

//		return createFromXML(getXMLEntity());

	}

	/**

	 * Like {@linkplain #cloneFMap()}, but now doesn't clone the layers, rather copies them.

	 * @return the new map

	 */

	public MapContext cloneToDraw() {

	 * <li><code>-1</code> if there is no image

	 * <li><code>0</code> if there is no extent defined for the image

	 * </ul>

	 * @see #setScaleView(long)

	 * @see ViewPort#getAdjustedExtent()

	 * @see IProjection#getScale(double, double, double, double)

	}

	/**

	 * <p>Sets the new extent of the view, calculated using the scale argument.</p>

	 * <p>Doesn't updates the scale if there isn't information about the dimension of the image or the

	 *  adjusted extent.</p>

	 *

	 * @param scale the new scale for the view

	 * @see ViewPort#setProjection(IProjection)

	 * @see #getScaleView()

	 */

	}

	/**

	 * @return double with the screen's dpi

	 */

	public static double getScreenDPI() {

		double dpi = prefsResolution.getInt("dpi",kit.getScreenResolution());

		return dpi;

	}

	/**

	 * @see com.iver.cit.gvsig.fmap.operations.strategies.Strategy#setVectorial(com.iver.cit.gvsig.fmap.VectorialAdapter)

	 */

		}

	}

	 * @see org.cresques.geo.Projected#reProject(org.cresques.cts.ICoordTrans)

	 */

	public void reProject(ICoordTrans arg0) {

	 * <p>Draws this map if its {@link ViewPort ViewPort} has an extent defined:<br>

	 * <ol>

	 * <li>Selects only the layers that have to be drawn: {@linkplain #prepareDrawing(BufferedImage, Graphics2D, double)}.

	 * <li>Draws the layers.

	 * <li>Fires a <code>LayerDrawEvent.GRAPHICLAYER_BEFORE_DRAW</code>.

	 * <li>Draws the graphic layer.

	 * <li>Fires a <code>LayerDrawEvent.GRAPHICLAYER_AFTER_DRAW</code>.

	 * <li>Invokes the garbage collector and memory clean.

	 * </ol></p>

	 * @param image buffer used sometimes instead <code>g</code> to accelerate the draw. For example, if two points are as closed that can't be distinguished, draws only one.

	 * @param g for rendering 2-dimensional shapes, text and images on the Java(tm) platform

	 * @param scale the scale of the view. Must be between {@linkplain FLayer#getMinScale()} and {@linkplain FLayer#getMaxScale()}.

	 */

	public void draw(BufferedImage image, Graphics2D g, Cancellable cancel,

			double scale) throws ReadDriverException {

		 */

		System.gc();

	}

	/**

	 * <p>Checks out layers that need to be repainted.</p>

	 * <p>If one layer node uses a cache with previous image drawn, but hasn't any, or if it's dirty, then,

	 *  that layer must be repainted. </p>

	 * <p>If one layer node needn't to be repainted, checks out it recursively.</p>

	 * <p><i>The cache of "previous image drawn" allows accelerate the repaint process.</i></p>

	 * @see #draw(BufferedImage, Graphics2D, Cancellable, double)

	 * @see #recursivePrepareDrawing(FLayers, int)

	 */

		else

			recursivePrepareDrawing(layers);

	}

	/**

	 * <p>Invoked by {@linkplain MapContext#recursivePrepareDrawing(FLayers, int)}. Sets all previous layer nodes

	 *  in the argument as not dirty, what means that don't need to be repainted.</p>

	 * <p>Each layer node can decide validate or not it's sub-layers according its implementation.</p>

	 * <p>This is useful when it's editing, for accelerate the draw, because the layers of a {@link FLayers FLayers} node

	 * are painted according its index in the collection, and each one upper the previous.</p>

	 * @param index index of the current layer in the internal list of layers

	 * @see #recursivePrepareDrawing(FLayers, int)

	 * @see #prepareDrawing(BufferedImage, Graphics2D, double)

	 */

//			lyr.setDirty(true);

//		}

	}

	/**

	 * <p>Checks out recursively, layers that have a cache with an image of previous layers drawn, and if are dirty

	 * notify the previous layers that are valid.</p>

	 * @param parent node that contains the layers

	 * @param indexInParent the least layer index in the <code>parent</code> argument. This allows reduce the time processing

	 *  if is known that the first layers aren't a collection and will (or won't) be validated

	 * @see #prepareDrawing(BufferedImage, Graphics2D, double)

	 */

	private void recursivePrepareDrawing(FLayers parent)

	/**

	 * <p>Draws only the internal graphic layer using the information of the {@link ViewPort ViewPort} of this map.</p>

	 * @param image image used to accelerate the screen draw

	 * @param g for rendering 2-dimensional shapes, text and images on the Java(tm) platform

	 * @param scale value that represents the scale

	 * @see GraphicLayer#draw(BufferedImage, Graphics2D, ViewPort, Cancellable, double)

	 */

	public void drawGraphics(BufferedImage image, Graphics2D g,

	/**

	 * <p>Like {@linkplain MapContext#draw(BufferedImage, Graphics2D, Cancellable, double)}, but creating

	 *  the task as cancellable.</p>

	 * @param image buffer used sometimes instead <code>g</code> to accelerate the draw. For example, if two points are as closed that can't be distinguished, draws only one.

	 * @param g for rendering 2-dimensional shapes, text and images on the Java(tm) platform

	 * @param scale the scale of the view. Must be between {@linkplain FLayer#getMinScale()} and {@linkplain FLayer#getMaxScale()}.

	 * @see #draw(BufferedImage, Graphics2D, Cancellable, double)

	 */

	public void draw(BufferedImage image, Graphics2D g, double scale)

	 * <p>Gets the {@link ViewPort ViewPort} associated to this map.</p>

	 *

	 * @return the view port

	 * @see #setViewPort(ViewPort)

	 */

	public ViewPort getViewPort() {

	 *  adds the new one.</p>

	 *

	 * @param viewPort the viewPort

	 * @see #getViewPort()

	 */

	public void setViewPort(ViewPort viewPort) {

	 * <p>Returns the union of all extents of all layers of this map.</p>

	 *

	 * @return full extent of layers of this map

	 * @see FLayers#getFullExtent()

	 */

	public Rectangle2D getFullExtent() throws ReadDriverException {

	 * <li>XML entity of the internal {@link ViewPort ViewPort}.

	 * <li>XML entity of the internal {@link FLayers FLayers}.

	 * </ul>

	 * @return XMLEntity the XML entity

	 * @throws XMLException if there is any error creating the XML from the map.

	 * @see #createFromXML(XMLEntity)

	 * @see #createFromXML03(XMLEntity)

	 * @see ViewPort#getXMLEntity()

		return xml;

	}

	/**

	 *  the data of the {@link ViewPort ViewPort} and

	 *  {@link FLayers FLayers}.</p>

	 *

	 * @param xml an XML entity

	 *

	 *

	 * @throws XMLException if there is any error creating the map from the XML.

	 * @see #getXMLEntity()

	 * @see #createFromXML(XMLEntity)

	 * @see ViewPort#createFromXML03(XMLEntity)

	}

	/**

	 *  with the data of the {@link ViewPort ViewPort} and

	 *  {@link FLayers FLayers}.</p>

	 *

	 * @param xml an XML entity

	 *

	 *

	 * @throws XMLException if there is any error creating the map from the XML.

	 * @see #getXMLEntity()

	 * @see #createFromXML03(XMLEntity)

	 * @see ViewPort#createFromXML(XMLEntity)

	 * @param listener the new listener

	 *

	 * @return <code>true</code> if has added the listener successfully

	 * @see EventBuffer#addAtomicEventListener(AtomicEventListener)

	 */

	public boolean addAtomicEventListener(AtomicEventListener listener) {

	 * <p>Removes a listener of atomic events from the internal {@link EventBuffer EventBuffer}.</p>

	 *

	 * @param listener the listener to remove

     * @return <tt>true</tt> if the list contained the specified element

	 * @see #addAtomicEventListener(AtomicEventListener)

	 * @see EventBuffer#removeAtomicEventListener(AtomicEventListener)

	 */

	/**

	 * @see EventBuffer#beginAtomicEvent()

	 * @see #endAtomicEvent()

	 */

	public void beginAtomicEvent() {

	/**

	 * @see EventBuffer#endAtomicEvent()

	 * @see #beginAtomicEvent()

	 */

	public void endAtomicEvent() {

	 * @author Fernando Gonz?lez Cort?s

	 */

	public class LayerEventListener implements LayerCollectionListener {

		 * @see com.iver.cit.gvsig.fmap.layers.LayerCollectionListener#layerAdded(com.iver.cit.gvsig.fmap.layers.LayerCollectionEvent)

		 */

		public void layerAdded(LayerCollectionEvent e) {

			FLayer lyr = e.getAffectedLayer();

			selectionListener(lyr);

		}

		/**

		 * <p>Registers an event buffer as a listener for all layers as argument.</p>

		 *

		 * <p>Each {@link FLayer FLayer} of this map must have an event buffer for all kind

		 * of specific listeners of that layer. This method distinguish between {@link Classifiable Classifiable},

		 * @param the layer or layers

		 */

		private void selectionListener(FLayer lyr){

				throws CancelationException {

		}

	}

	/**

	 * @param a collection of layers

	 */

	public void addAsCollectionListener(FLayers layers2) {

		layers2.addLayerCollectionListener(layerEventListener);

	}

	/**

	 * <p>Returns the internal {@link GraphicLayer GraphicLayer}.</p>

	 * @return the graphic layer of this map

	 * @see #setGraphicsLayer(GraphicLayer)

	 */

	public GraphicLayer getGraphicsLayer() {

	/**

	 * <p>Sets a new {@link GraphicLayer GraphicLayer} to this map.</p>

	 * @param graphicLayer the new graphic layer

	 * @see #getGraphicsLayer()

	 */

	public void setGraphicsLayer(GraphicLayer graphicLayer) {

		tracLayer = graphicLayer;

	}

	/**

	 * <p>Indicates whether some other object is "equal to" this map.</p>

	 * <p>Returns <code>true</code> if success one of this options:

	 * <li>Both objects are equal according to {@linkplain Object#equals(Object)}.

	 * <li>Both maps have the same layers.

	 * <li>Both maps have the same number of layers and with the same name.

	 * </p>

	 * @param obj the reference object with which to compare.

	 * @see Object#equals(Object)

	 */

	public boolean equals(Object arg0) {

		}

		return isEqual;

	}

	/**

	 * <p>Registers the message of an error associated to this map.</p>

	 * @param stringProperty the error message

	 * @see #getLayersError()

	 * @see #clearErrors()

	 */

	public void addLayerError(String stringProperty) {

		layersError.add(stringProperty);

	}

	/**

	 * @return the list of errors registered to this map

	 * @see #addLayerError(String)

	 * @see #clearErrors()

	 */

	public ArrayList getLayersError() {

		return layersError;

	}

	/**

	 * <p>Removes all error messages associated to this map.</p>

	 * @see #addLayerError(String)

	 * @see #getLayersError()

	 */

	public void clearErrors() {

		layersError.clear();

	}

	/**

	 * <p>Removes from this map, all caching images of drawn layers, registered.</p>

	 * @see #clearCachingImageDrawnLayers(FLayers)

	 */

	public void clearAllCachingImageDrawnLayers() {

		clearCachingImageDrawnLayers(this.layers);

	}

	/**

	 * <p>Removes from the layer collection argument, all caching images of drawn layers, registered.</p>

	 * @param layers a layer collection

	 * @see #clearAllCachingImageDrawnLayers()

	 */

	private void clearCachingImageDrawnLayers(FLayers layers){

		}

	}

	public FLayers getNewGroupLayer(FLayers parent) {

		FLayers group1 = new FLayers();//(this,parent);

		group1.setMapContext(this);