Application: gvSIG desktop

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

package com.iver.cit.gvsig.fmap;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.RenderingHints;

import java.awt.Toolkit;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import java.util.ArrayList;

import java.util.List;

import java.util.prefs.Preferences;

import javax.print.attribute.PrintRequestAttributeSet;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.cresques.geo.Projected;

import com.iver.cit.gvsig.fmap.layers.CancelationException;

import com.iver.cit.gvsig.fmap.layers.FLayer;

import com.iver.cit.gvsig.fmap.layers.FLayers;

import com.iver.cit.gvsig.fmap.layers.GraphicLayer;

import com.iver.cit.gvsig.fmap.layers.LayerCollectionEvent;

import com.iver.cit.gvsig.fmap.layers.LayerCollectionListener;

import com.iver.cit.gvsig.fmap.layers.LayerDrawEvent;

import com.iver.cit.gvsig.fmap.layers.LayerDrawingListener;

import com.iver.cit.gvsig.fmap.layers.LayerPositionEvent;

import com.iver.cit.gvsig.fmap.layers.LegendListener;

import com.iver.cit.gvsig.fmap.layers.XMLException;

import com.iver.cit.gvsig.fmap.layers.layerOperations.AlphanumericData;

import com.iver.cit.gvsig.fmap.layers.layerOperations.Classifiable;

import com.iver.cit.gvsig.fmap.layers.layerOperations.Selectable;

import com.iver.cit.gvsig.fmap.operations.strategies.SelectedZoomVisitor;

import com.iver.cit.gvsig.fmap.operations.strategies.VisitException;

import com.iver.utiles.XMLEntity;

import com.iver.utiles.swing.threads.Cancellable;

/**

 * <p>The <code>MapContext</code> class represents the model and a part of the control 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 com.iver.cit.gvsig.fmap.rendering.LegendListener LegendListener}s

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

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

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

 * </ul>

 * </p>

 *

 * @author Fernando Gonz?lez Cort?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[1]</code>: meter

         *  <li><code>MapContext.CHANGEM[2]</code>: centimeter

         *  <li><code>MapContext.CHANGEM[3]</code>: millimeter

         *  <li><code>MapContext.CHANGEM[4]</code>: international statute mile

         *  <li><code>MapContext.CHANGEM[5]</code>: yard

         *  <li><code>MapContext.CHANGEM[6]</code>: foot

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

         * 

         * <p><h3>Grade conversion value: <code>MapContext.CHANGEM[8]</code></h3> 

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

         *  points on the Earth surface that are 1 grade far each other of the center of the Earth. This value has been calculated using 

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

         * <h4>Explanation:</h4>

         * We get an isosceles triangle with the center of the Earth and the 2 points on the surface. This triangle can be divided into

         * two rectangle triangles. We know two values, the angle of 1 grade, that will be 0.50 grades in each triangle, and the Earth radius that

         * is the hypotenuse. Then we apply trigonometry and get the distance <i>D</i> between both points on the Earth surface.</p>

         * <p>Now we only must invert that value to obtain <code>MapContext.CHANGEM[8]</code>.</p>

         */

        public static final double[] CHANGEM = { 1000, 1, 0.01, 0.001, 1609.344,

                        0.9144, 0.3048, 0.0254, 1/8.983152841195214E-6 };

        /**

         * <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.CHANGEM[0]</code>: kilometer

         *  <li><code>MapContext.CHANGEM[1]</code>: meter

         *  <li><code>MapContext.CHANGEM[2]</code>: centimeter

         *  <li><code>MapContext.CHANGEM[3]</code>: millimeter

         *  <li><code>MapContext.CHANGEM[4]</code>: international statute mile

         *  <li><code>MapContext.CHANGEM[5]</code>: yard

         *  <li><code>MapContext.CHANGEM[6]</code>: foot

         *  <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 centimeters</pre>

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

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

         * </p>

         * 

         * <p><h3>Grade conversion value: <code>MapContext.CHANGEM[8]</code></h3> 

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

         *  points on the Earth surface that are 1 grade far each other of the center of the Earth. This value has been calculated using 

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

         * <h4>Explanation:</h4>

         * We get an isosceles triangle with the center of the Earth and the 2 points on the surface. This triangle can be divided into

         * two rectangle triangles. We know two values, the angle of 1 grade, that will be 0.50 grades in each triangle, and the Earth radius that

         * is the hypotenuse. Then we apply trigonometry and get the distance <i>D</i> between both points on the Earth surface.</p>

         * <p>Now we only must invert that value to obtain <code>MapContext.CHANGEM[8]</code>.</p>

         */

        public static final double[] CHANGE = { 100000, 100, 1, 0.1, 160934.4,

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

        /**

         * 

         */

        public static final int EQUALS = 0;

        /**

         * 

         */

        public static final int DISJOINT = 1;

        /**

         * 

         */

        public static final int INTERSECTS = 2;

        /**

         * 

         */

        public static final int TOUCHES = 3;

        /**

         * 

         */

        public static final int CROSSES = 4;

        /**

         * 

         */

        public static final int WITHIN = 5;

        /**

         * 

         */

        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)

         */

        private ViewPort viewPort;

        // private ArrayList invalidationListeners = new ArrayList();

        /**

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

         * 

         * @see #addLayerListener(LegendListener)

         * @see #removeLayerListener(LegendListener)

         * @see #callLegendChanged()

         */

        private ArrayList legendListeners = new ArrayList();

        /**

         * 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>Layer collection events.

         *  <li>View port events.

         *  <li>Atomic events.

         *  <li>Layer events.

         *  <li>Legend events on a {@link Classificable Classificable} layer.

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

         * @see #reportDriverExceptions(String, List)

         */

        private ArrayList errorListeners = new ArrayList();

        // public static ResourceBundle myResourceBundle =

        // ResourceBundle.getBundle("FMap");

        /**

         * <p>Default zoom in factor.</p>

         * <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>Default zoom out factor.</p>

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

        /**

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

         *  without layers.</p>

         *

         * @param vp information for drawing the layers of this map as a view

         */

        public MapContext(ViewPort vp) {

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

                layerEventListener = new LayerEventListener();

                layers.addLayerCollectionListener(layerEventListener);

                layers.addLayerCollectionListener(eventBuffer);

                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

         * @param vp information for drawing the layers of this map as a view

         */

        public MapContext(FLayers fLayers, ViewPort vp) {

                this.layers = fLayers;

                layerEventListener = new LayerEventListener();

                layers.addLayerCollectionListener(layerEventListener);

                layers.addLayerCollectionListener(eventBuffer);

                setViewPort(vp);

        }

        /**

         * <p>Reports to all driver error listeners registered of a bundle of driver exceptions caused in the same map atomic transaction.</p> 

         * 

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

         */

        public synchronized void reportDriverExceptions(String introductoryText,

                                                                                                        List driverExceptions){

                for (int i = 0; i < errorListeners.size(); i++) {

                        ((ErrorListener) errorListeners.get(i)).

                                reportDriverExceptions(introductoryText, driverExceptions);

                }

        }

        /**

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

         */

        public void addLayerListener(LegendListener listener) {

                if (!legendListeners.contains(listener))

                        legendListeners.add(listener);

        }

        // SUGERENCIA DE PABLO

        //        public void addLegendListener(LegendListener listener) {

        //                if (!legendListeners.contains(listener))

        //                        legendListeners.add(listener);

        //        }

        /**

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

         */

        public void removeErrorListener(LegendListener listener) {

                legendListeners.remove(listener);

        }

        // SUGERENCIA DE PABLO:

        //public void removeErrorListener(ErrorListener listener) {

        //        errorListeners.remove(listener);

        //}

        /**

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

         * <p>This method must be call only if it's wanted to reflect a legend change.</p>

         * 

         * @see #addLayerListener(LegendListener)

         * @see #removeLayerListener(LegendListener)

         */

        public synchronized void callLegendChanged() {

                for (int i = 0; i < legendListeners.size(); i++) {

                        ((LegendListener) legendListeners.get(i)).legendChanged(null);

                }

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

         * @see #removeLayerDrawListener(LayerDrawingListener)

         */

        public synchronized void fireLayerDrawingEvent(LayerDrawEvent e) {

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

                {

                        LayerDrawingListener listener = (LayerDrawingListener) layerDrawingListeners.get(i);

                        switch (e.getEventType())

                        {

                                case LayerDrawEvent.LAYER_BEFORE_DRAW:

                                        listener.beforeLayerDraw(e);

                                        break;

                                case LayerDrawEvent.LAYER_AFTER_DRAW:

                                        listener.afterLayerDraw(e);

                                        break;

                                case LayerDrawEvent.GRAPHICLAYER_BEFORE_DRAW:

                                        listener.beforeGraphicLayerDraw(e);

                                        break;

                                case LayerDrawEvent.GRAPHICLAYER_AFTER_DRAW:

                                        listener.afterLayerGraphicDraw(e);

                                        break;

                        }

                }

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

         */

        public synchronized void callNewErrorEvent(ErrorEvent e) {

                for (int i = 0; i < errorListeners.size(); i++) {

                        ((ErrorListener) errorListeners.get(i)).errorThrown(e);

                }

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

        }

        /**

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

         * 

         * @param listener the listener to remove

         * 

         * @see #addLayerListener(LegendListener)

         * @see #callLegendChanged()

         */

        public void removeLayerListener(LegendListener listener) {

                legendListeners.remove(listener);

        }

        // SUGERENCIA DE PABLO:

        // public void removeLegendListener(LegendListener listener) {

        //         legendListeners.remove(listener);

        // }

        /**

         * <p>Returns the hierarchy of {@link FLayers FLayers} nodes stored in this map.</p>

         *

         * @return the hierarchy of nodes of layers stored in this map

         */

        public FLayers getLayers() {

                return layers;

        }

        /**

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

         *

         * @param b image with an accessible buffer of image data

         */

        public void drawLabels(BufferedImage b) {

        }

        /**

         * @see #redraw()

         */

        public void invalidate() {

                // SUGERENCIA DE PABLO:

                // redraw();

                getLayers().moveTo(0, 0);

        }

        /**

         * <p>Prints the layers of this map using the {@link Graphics2D Graphics2D} argument, that usually is

         * the {@link Graphics Graphics} of the printer.</p>

         *

         * @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()}.

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

         *

         * @throws DriverException if fails using some driver.

         * 

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

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

         */

        public void print(Graphics2D g, double scale, PrintRequestAttributeSet properties) throws DriverException {

                RenderingHints renderHints = new RenderingHints(

                                RenderingHints.KEY_ANTIALIASING,

                                RenderingHints.VALUE_ANTIALIAS_ON);

                renderHints.put(RenderingHints.KEY_RENDERING,

                                RenderingHints.VALUE_RENDER_QUALITY);

                g.setRenderingHints(renderHints);

                Cancellable cancel = new Cancellable() {

                        /*

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

                         */

                        public boolean isCanceled() {

                                return false;

                        }

                        /*

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

                         */

                        public void setCanceled(boolean canceled) {

                                // No queremos que se pueda cancelar la impresi?n.

                        }

                };

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

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

        }

        /**

         * <p>Returns a new map with the information of the <code>vp</code> argument, and the layers of this map.</p>

         *

         * @param vp information for drawing the layers

         *

         * @return a new map

         */

        public MapContext createNewFMap(ViewPort vp) {

                MapContext ret = new MapContext(vp);

                ret.layers = this.layers;

                return ret;

        }

        /**

         * <p>Creates a new independent map, that has a clone of the layers and the view port of this one.</p>

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

         *

         * @return the new map

         *

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

         * 

         * @see FLayer#cloneLayer()

         * @see ViewPort#cloneViewPort()

         */

        public MapContext cloneFMap() throws XMLException {

                ViewPort vp = getViewPort().cloneViewPort();

                FLayers antLayers = getLayers();

                MapContext ret = new MapContext(vp);

                FLayers aux = new FLayers(ret, null);

                for (int i=0; i < antLayers.getLayersCount(); i++)

                {

                        FLayer lyr = antLayers.getLayer(i);

                        try {

                                aux.addLayer(lyr.cloneLayer());

                        } catch (Exception e) {

                                throw new XMLException(e);

                        }

                }

                ret.layers = aux;

                return ret;

//                return createFromXML(getXMLEntity());

        }

        /**

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

         * 

         * @return the new map

         */

        public MapContext cloneToDraw() {

                ViewPort vp = getViewPort().cloneViewPort();

                MapContext mapContext=new MapContext(getLayers(),vp);

                return mapContext;

        }

        /**

         * A?ade la capa que se pasa como par?metro al nodo que se pasa como

         * parametro y lanza ProjectionMismatchException si no est?n todas las capas

         * de este FMap en la misma proyecci?n. Lanza un ChildNotAllowedException si

         * la capa no es un FLayers y no permite hijos

         *

         * @param vectorial

         *            DOCUMENT ME!

         */

        /*

         * public void addLayer(LayerPath parent, FLayer layer) throws

         * ProjectionMismatchException, ChildrenNotAllowedException {

         * layers.addLayer(parent, layer); } public void removeLayer(LayerPath

         * parent)throws ChildrenNotAllowedException{ layers.removeLayer(parent); }

         */

        /**

         * <p>Adds a layer to the group of layers that are at a upper level in the tree.</p>

         *

         * @param vectorial the layer to add

         */

        public void addToTrackLayer(FLayer vectorial) {

        }

        /**

         * <p>Returns the scale of the view in the screen.</p>

         *

         * @return one of this values:

         * <ul>

         * <li>the scale of the adjusted extent scale of the view in the screen

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

         */

        public long getScaleView() {

                Preferences prefsResolution = Preferences.userRoot().node( "gvsig.configuration.screen" );

                Toolkit kit = Toolkit.getDefaultToolkit();

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

                IProjection proj = viewPort.getProjection();

                if (viewPort.getImageSize() == null)

                        return -1;

                if (viewPort.getAdjustedExtent() == null) {

                        return 0;

                }

                if (proj == null) {

                        double w = ((viewPort.getImageSize().getWidth() / dpi) * 2.54);

                        return (long) (viewPort.getAdjustedExtent().getWidth() / w * CHANGEM[getViewPort()

                                        .getMapUnits()]/CHANGEM[getViewPort().getDistanceUnits()]);

                }

                if (proj.isProjected())

                return Math.round(proj.getScale((viewPort.getAdjustedExtent().getMinX()*CHANGEM[getViewPort().getMapUnits()])/CHANGEM[getViewPort().getDistanceUnits()],

                                (viewPort.getAdjustedExtent().getMaxX()*CHANGEM[getViewPort().getMapUnits()])/CHANGEM[getViewPort().getDistanceUnits()], viewPort.getImageSize()

                                                .getWidth(), dpi));

                return Math.round(proj.getScale((viewPort.getAdjustedExtent().getMinX()*CHANGEM[1])/CHANGEM[getViewPort().getDistanceUnits()],

                                (viewPort.getAdjustedExtent().getMaxX()*CHANGEM[1])/CHANGEM[getViewPort().getDistanceUnits()], viewPort.getImageSize()

                                                .getWidth(), dpi));

        }

        /**

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

         */

        public void setScaleView(long scale) {

                clearAllCachingImageDrawnLayers();

                Preferences prefsResolution = Preferences.userRoot().node( "gvsig.configuration.screen" );

                Toolkit kit = Toolkit.getDefaultToolkit();

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

                if (viewPort.getImageSize() == null)

                        return;

                IProjection proj = viewPort.getProjection();

                if (viewPort.getAdjustedExtent() == null) {

                        return;

                }

                Rectangle2D rec=proj.getExtent(

                                viewPort.getAdjustedExtent(),

                                scale,viewPort.getImageWidth(),

                                viewPort.getImageHeight(),

                                CHANGE[getViewPort().getMapUnits()],

//                                CHANGEM[getViewPort().getDistanceUnits()],

                                dpi);

//                double dif=CHANGEM[getViewPort().getDistanceUnits()];

//                double w=rec.getWidth()/dif;

//                double h=rec.getHeight()/dif;

//                rec.setRect(rec.getCenterX()-w/2,rec.getCenterY()-h/2,w,h);

                getViewPort().setExtent(rec);

        }

        /**

         * @see org.cresques.geo.Projected#getProjection()

         * 

         * @see ViewPort#getProjection()

         * @see #setProjection(IProjection)

         * @see #reProject(ICoordTrans)

         */

        public IProjection getProjection() {

                return getViewPort().getProjection();

        }

        /**

         * <p>Sets the new projection.</p>

         *

         * @param proj the new projection

         * 

         * @see #getProjection()

         * @see ViewPort#setProjection(IProjection)

         * @see #reProject(ICoordTrans)

         */

        public void setProjection(IProjection proj) {

                if (getViewPort() != null) {

                        getViewPort().setProjection(proj);

                }

        }

        /*

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

         */

        public void reProject(ICoordTrans arg0) {

                // TODO implementar reprojecci?n (lo que sea eso)

        }

        /**

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

         * 

         * @see SelectedZoomVisitor#getSelectBound()

         */

        public Rectangle2D getSelectionBounds() {

                SelectedZoomVisitor visitor = new SelectedZoomVisitor();

                try {

                        layers.process(visitor);

                } catch (DriverException e1) {

                        throw new RuntimeException(

                                        "No se espera que SelectByPointVisitor lance esta excepci?n",

                                        e1);

                } catch (VisitException e) {

                        throw new RuntimeException(

                                        "No se espera que SelectByPointVisitor lance esta excepci?n",

                                        e);

                }

                return visitor.getSelectBound();

        }

        /**

         * <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>Sets quality: antialiasing por text and images, and quality rendering. 

         * <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 cancel an object thread that implements the {@link Cancellable Cancellable} interface, and will allow to cancel the draw

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

         * @throws DriverException if fails using some driver.

         */

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

                        double scale) throws DriverException {

                if (viewPort.getExtent() == null) {

                        // System.err.println("viewPort.getExtent() = null");

                        return;

                }

                System.out.println("Viewport despues: " + viewPort.toString());

                /*

                 * if ((viewPort.getImageWidth() <=0) || (viewPort.getImageHeight() <=

                 * 0)) { return; }

                 */

                prepareDrawing(image, g, scale);

                // M?s c?lidad al texto

                RenderingHints renderHints = new RenderingHints(

                                RenderingHints.KEY_ANTIALIASING,

                                RenderingHints.VALUE_ANTIALIAS_ON);

                renderHints.put(RenderingHints.KEY_RENDERING,

                                RenderingHints.VALUE_RENDER_QUALITY);

                renderHints.put(RenderingHints.KEY_TEXT_ANTIALIASING,

                                RenderingHints.VALUE_TEXT_ANTIALIAS_ON);

                g.setRenderingHints(renderHints);

                long t1 = System.currentTimeMillis();

                layers.draw(image, g, viewPort, cancel, scale);

                LayerDrawEvent beforeTracLayerEvent = new LayerDrawEvent(tracLayer,

                                g, viewPort, LayerDrawEvent.GRAPHICLAYER_BEFORE_DRAW);

                fireLayerDrawingEvent(beforeTracLayerEvent);

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

                LayerDrawEvent afterTracLayerEvent = new LayerDrawEvent(tracLayer,

                                g, viewPort, LayerDrawEvent.GRAPHICLAYER_AFTER_DRAW);

                fireLayerDrawingEvent(afterTracLayerEvent);

                //layers.setDirty(false);

                long t2 = System.currentTimeMillis();

                System.err.println("Tiempo de dibujado:" + (t2 - t1) +

                                " mseg. Memoria libre:" + Runtime.getRuntime().freeMemory() / 1024  + " KB");

                /*

                 * g.setColor(Color.BLUE); GeneralPath shpR = new

                 * GeneralPath(viewPort.getExtent());

                 * shpR.transform(viewPort.getAffineTransform()); g.draw(shpR);

                 */

                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)

         */

        private void prepareDrawing(BufferedImage image, Graphics2D g, double scale) {

                // Primera pasada: si alguna capa necesita repintarse por debajo

                // de la que tiene la cache, TODAS necesitan

                // ser repintadas.

                boolean bNeedRepaint = false;

                boolean bMayExistAceleration = false;

                for (int i = 0; i < layers.getLayersCount(); i++)

                {

                        FLayer lyr = layers.getLayer(i);

                        if (lyr.isCachingDrawnLayers() && (lyr.getCacheImageDrawnLayers() != null))

                        {

                                bMayExistAceleration = true;

                        }

                        else

                        {

                                if (lyr.isDirty())

                                        bNeedRepaint = true;

                        }

                }

                if (bMayExistAceleration==false)

                        bNeedRepaint = true;

                if (bNeedRepaint)

                        layers.setDirty(true);

                else

                        recursivePrepareDrawing(layers, 0);

        }

        /**

         * <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 layers a node with layers 

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

         * 

         * @see #recursivePrepareDrawing(FLayers, int)

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

         */

        private void validatePreviousLayers(FLayers layers, int index)

        {

                // TODO: Aqu? quiz?s habr?a que explorar los padres de las capas

                // para marcar y/o asignar la imagen cacheada.

                for (int i = 0; i < index; i++)

                {

                        FLayer lyr = layers.getLayer(i);

                        lyr.setDirty(false);

                }

                // Las de arriba las marcamos como sucias

//                for (int i = index; i < layers.getLayersCount(); i++)

//                {

//                        FLayer lyr = layers.getLayer(i);

//                        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, int indexInParent)

        {

//       SUGERENCIA (de Pablo): Intentar evitar que pueda revalidar varias veces las mismas capas, dado

//                  que la imagen de anteriores capas dibujadas contendr? todas las capas previas, y con ello

//                  obtener un ligero aumento de velocidad.

//

//                boolean validated = false;

//                FLayer lyr;

//                

//                for (int i = parent.getLayersCount()-1; i >= indexInParent; i--) {

//                        lyr = layers.getLayer(i);

//

//                        if ((!validated) && (lyr.isCachingDrawnLayers()) && (lyr.getCacheImageDrawnLayers() != null))

//                        {

//                                // les decimos a las anteriores que est?n validadas (not dirty)

//                                // para que no se dibujen.

//                                if (lyr.isDirty()) {

//                                        validatePreviousLayers(parent, i);

//                                        validated = true;

//                                }

//                        }

//

//                        if (lyr instanceof FLayers)

//                        {

//                                recursivePrepareDrawing((FLayers)lyr, 0);

//                        }

//                }

                for (int i = indexInParent; i < parent.getLayersCount(); i++)

                {

                        FLayer lyr = layers.getLayer(i);

                        if (lyr.isCachingDrawnLayers() && (lyr.getCacheImageDrawnLayers() != null))

                        {

                                // les decimos a las anteriores que est?n validadas (not dirty)

                                // para que no se dibujen.

                                if (lyr.isDirty())

                                        validatePreviousLayers(parent, i);

                        }

                        if (lyr instanceof FLayers)

                        {

                                recursivePrepareDrawing((FLayers)lyr, 0);

                        }

                }

        }

        /**

         * <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 cancel an object thread that implements the {@link Cancellable Cancellable} interface, and will allow to cancel the draw

         * @param scale value that represents the scale

         * @throws DriverException if fails using some driver.

         * 

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

         */

        public void drawGraphics(BufferedImage image, Graphics2D g,

                        Cancellable cancel, double scale) throws DriverException {

                if (viewPort == null)

                        return;

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

        }

        /**

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

         * 

         * @throws DriverException if fails using some driver.

         * 

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

         */

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

                        throws DriverException {

                layers.setDirty(true);

                draw(image, g, new Cancellable() {

                        /*

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

                         */

                        public boolean isCanceled() {

                                return false;

                        }

                        /*

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

                         */

                        public void setCanceled(boolean canceled) {

                                // TODO Auto-generated method stub

                        }

                }, scale);

        }

        /**

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

         *

         * @return the view port

         * 

         * @see #setViewPort(ViewPort)

         */

        public ViewPort getViewPort() {

                return viewPort;

        }

        /**

         * <p>Sets a {@link ViewPort ViewPort} with the drawing information

         *  of this map.</p>

         * <p>If there was a previous view port, removes its {@link EventBuffer EventBuffer} and

         *  adds the new one.</p>

         *

         * @param viewPort the viewPort

         * 

         * @see #getViewPort()

         */

        public void setViewPort(ViewPort viewPort) {

                if (this.viewPort != null) {

                        this.viewPort.removeViewPortListener(eventBuffer);

                }

                this.viewPort = viewPort;

                if (viewPort != null)

                        viewPort.addViewPortListener(eventBuffer);

        }

        /**

         * <p>Sets the given extent to the {@link ViewPort ViewPort} and updates the view with the new zoom.</p>

         *

         * @param extent the extent of the new zoom

         */

        public void zoomToExtent(Rectangle2D extent) {

            if (extent!=null)

                    getViewPort().setExtent(extent);

        }

        /**

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

         *

         * @return full extent of layers of this map

         * @throws DriverException if fails using a driver.

         * 

         * @see FLayers#getFullExtent()

         */

        public Rectangle2D getFullExtent() throws DriverException {

                return layers.getFullExtent();

        }

        /**

         * <p>Returns an XML entity with the name of this class as a property, and two children branches:<br>

         * <ul>

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

         * @see FLayers#getXMLEntity()

         */

        public XMLEntity getXMLEntity() throws XMLException {

                XMLEntity xml = new XMLEntity();

                xml.putProperty("className", this.getClass().getName());

                xml.addChild(viewPort.getXMLEntity());

                xml.addChild(layers.getXMLEntity());

                return xml;

        }

        /**

         * <p>Creates a new <code>MapContext</code> from an XML entity, with

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

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

         *

         * @param xml an XML entity

         *

         * @return the new <code>MapContext</code>

         *

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

         * 

         * @see #getXMLEntity()

         * @see #createFromXML(XMLEntity)

         * @see ViewPort#createFromXML03(XMLEntity)

         * @see FLayers#setXMLEntity03(XMLEntity)

         */

        public static MapContext createFromXML03(XMLEntity xml) throws XMLException {

                ViewPort vp = ViewPort.createFromXML03(xml.getChild(0));

                MapContext fmap = new MapContext(vp);

                fmap.layers.setXMLEntity03(xml.getChild(1));

                return fmap;

        }

        /**

         * <p>Creates a new <code>MapContext</code> from an XML entity, with

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

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

         *

         * @param xml an XML entity

         *

         * @return the new <code>MapContext</code>

         *

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

         * 

         * @see #getXMLEntity()

         * @see #createFromXML03(XMLEntity)

         * @see ViewPort#createFromXML(XMLEntity)

         * @see FLayers#setXMLEntity(XMLEntity)

         */

        public static MapContext createFromXML(XMLEntity xml) throws XMLException {

                ViewPort vp = ViewPort.createFromXML(xml.getChild(0));

                MapContext fmap = new MapContext(vp);

                fmap.layers.setXMLEntity(xml.getChild(1));

                return fmap;

        }

        /**

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

         *

         * @param listener the new listener

         *

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

         * 

         * @see #removeAtomicEventListener(AtomicEventListener) 

         * @see EventBuffer#addAtomicEventListener(AtomicEventListener)

         */

        public boolean addAtomicEventListener(AtomicEventListener listener) {

                return eventBuffer.addAtomicEventListener(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)

         */

        public boolean removeAtomicEventListener(AtomicEventListener listener) {

                return eventBuffer.removeAtomicEventListener(listener);

        }

        /**

         * @see EventBuffer#beginAtomicEvent()

         * 

         * @see #endAtomicEvent()

         */

        public void beginAtomicEvent() {

                eventBuffer.beginAtomicEvent();

        }

        /**

         * @see EventBuffer#endAtomicEvent()

         * 

         * @see #beginAtomicEvent()

         */

        public void endAtomicEvent() {

                eventBuffer.endAtomicEvent();

        }

        /**

         * <p>The class <code>LayerEventListener</code> implements the methods of {@link LayerCollectionListener LayerCollectionListener}

         *  that handles the "layer added" or "layer removed" events in a map.</p>

         * <p>Is designed as a listener for all layers in a {@link MapContext MapContext}.</p>

         *

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

                        // Si es la primera capa, fijamos su extent al ViewPort

                        // if (getLayers().getLayersCount() == 1) {

                        if (getViewPort().getExtent() == null) {

                                FLayer lyr = e.getAffectedLayer();

                                try {

                                        getViewPort().setExtent(lyr.getFullExtent());

                                } catch (DriverException e1) {

                                }

                        }

                        // Registramos al FMap como listener del legend de las capas

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

                 * {@link AlphanumericData AlphanumericData}, and {@link FLayers FLayers} layers, and for each one, 

                 * registers, for their specific listeners, the <code>eventBuffer</code> as a listener.</p> 

                 * 

                 * @param the layer or layers

                 */

                private void selectionListener(FLayer lyr){

                        lyr.addLayerListener(eventBuffer);

                        if (lyr instanceof Classifiable) {

                                Classifiable c = (Classifiable) lyr;

                                c.addLegendListener(eventBuffer);

                        }

                        if (lyr instanceof AlphanumericData) {

                                Selectable s=null;

                                try {

                                        s = ((AlphanumericData) lyr).getRecordset();

                                        if (s!=null) {

                                                s.addSelectionListener(eventBuffer);

                                        }

                                } catch (DriverException e1) {

                                        // TODO Auto-generated catch block

                                        e1.printStackTrace();

                                }

                        }

                        if (lyr instanceof FLayers){

                                FLayers lyrs=(FLayers)lyr;

                                for(int i=0;i<lyrs.getLayersCount();i++){

                                        selectionListener(lyrs.getLayer(i));

                                }

                        }

                }

                /*

                 * @see com.iver.cit.gvsig.fmap.layers.LayerCollectionListener#layerMoved(com.iver.cit.gvsig.fmap.layers.LayerPositionEvent)

                 */

                public void layerMoved(LayerPositionEvent e) {

                }

                /*

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

                 */

                public void layerRemoved(LayerCollectionEvent e) {

                        FLayer lyr = e.getAffectedLayer();

                        lyr.removeLayerListener(eventBuffer);

                        if (lyr instanceof Classifiable) {

                                Classifiable c = (Classifiable) lyr;

                                c.removeLegendListener(eventBuffer);

                        }

                        if (lyr instanceof Selectable) {

                                Selectable s = (Selectable) lyr;

                                s.addSelectionListener(eventBuffer);

                        }

                }

                /*

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

                 */

                public void layerAdding(LayerCollectionEvent e)

                                throws CancelationException {

                }

                /*

                 * @see com.iver.cit.gvsig.fmap.layers.LayerCollectionListener#layerMoving(com.iver.cit.gvsig.fmap.layers.LayerPositionEvent)

                 */

                public void layerMoving(LayerPositionEvent e)

                                throws CancelationException {

                }

                /*

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

                 */

                public void layerRemoving(LayerCollectionEvent e)