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 org.gvsig.fmap.mapcontext;

import java.awt.Color;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.RenderingHints;

import java.awt.Toolkit;

import java.awt.geom.Point2D;

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 org.gvsig.fmap.core.geometries.IGeometry;

import org.gvsig.fmap.drivers.exceptions.VisitorException;

import org.gvsig.fmap.drivers.reading.adapters.VectorialAdapter;

import org.gvsig.fmap.mapcontext.events.ErrorEvent;

import org.gvsig.fmap.mapcontext.events.listeners.AtomicEventListener;

import org.gvsig.fmap.mapcontext.events.listeners.ErrorListener;

import org.gvsig.fmap.mapcontext.events.listeners.EventBuffer;

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.mapcontext.layers.operations.AlphanumericData;

import org.gvsig.fmap.mapcontext.layers.operations.Classifiable;

import org.gvsig.fmap.mapcontext.layers.operations.Selectable;

import org.gvsig.fmap.mapcontext.rendering.legend.events.listeners.LegendListener;

import org.gvsig.fmap.mapcontext.rendering.strategies.FeatureVisitor;

import org.gvsig.fmap.mapcontext.rendering.strategies.SelectedZoomVisitor;

import org.gvsig.fmap.mapcontrol.MapControl;

import com.hardcode.gdbms.driver.exceptions.ReadDriverException;

import com.hardcode.gdbms.engine.data.driver.DriverException;

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 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 com.iver.cit.gvsig.fmap.layers.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>

         *@deprecated use getDistanceTrans2Meter()

         */

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

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

        public static ArrayList AREANAMES=new ArrayList();

        public static ArrayList AREAABBR=new ArrayList();

        public static ArrayList AREATRANS2METER=new ArrayList();

        public static ArrayList DISTANCENAMES=new ArrayList();

        public static ArrayList DISTANCEABBR=new ArrayList();

        public static ArrayList DISTANCETRANS2METER=new ArrayList();

        static{

                MapContext.addDistanceUnit("Kilometros","Km",1000);

            MapContext.addDistanceUnit("Metros","m",1);

            MapContext.addDistanceUnit("Centimetros","cm",0.01);

            MapContext.addDistanceUnit("Milimetros","mm",0.001);

            MapContext.addDistanceUnit("Millas","mi",1609.344);

            MapContext.addDistanceUnit("Yardas","Ya",0.9144);

            MapContext.addDistanceUnit("Pies","ft",0.3048);

            MapContext.addDistanceUnit("Pulgadas","inche",0.0254);

            MapContext.addDistanceUnit("Grados","?",1/8.983152841195214E-6);

            MapContext.addAreaUnit("Kilometros","Km",true,1000);

            MapContext.addAreaUnit("Metros","m",true,1);

            MapContext.addAreaUnit("Centimetros","cm",true,0.01);

            MapContext.addAreaUnit("Milimetros","mm",true,0.001);

            MapContext.addAreaUnit("Millas","mi",true,1609.344);

            MapContext.addAreaUnit("Yardas","Ya",true,0.9144);

            MapContext.addAreaUnit("Pies","ft",true,0.3048);

            MapContext.addAreaUnit("Pulgadas","inche",true,0.0254);

            MapContext.addAreaUnit("Grados","?",true,1/8.983152841195214E-6);

    }

        public static void addAreaUnit(String name, String abbr,boolean isLinear,double trans2meter){

                AREANAMES.add(name);

                String pow="";

                if (isLinear)

                        pow=String.valueOf((char)178);

                AREAABBR.add(abbr+pow);

                AREATRANS2METER.add(new Double(trans2meter));

        }

        public static String[] getAreaNames(){

                return (String[])AREANAMES.toArray(new String[0]);

        }

        public static String[] getAreaAbbr(){

                return (String[])AREAABBR.toArray(new String[0]);

        }

        public static double[] getAreaTrans2Meter(){

                int size=AREATRANS2METER.size();

                double[] trans2meters=new double[size];

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

                        trans2meters[i]=((Double)AREATRANS2METER.get(i)).doubleValue();

                }

                return trans2meters;

        }

        public static String getOfLinear(int i) {

                if (((String)AREAABBR.get(i)).toLowerCase().endsWith(String.valueOf((char)178))){

                        return String.valueOf((char)178);

                }

                return "";

        }

        public static void addDistanceUnit(String name, String abbr,double trans2meter){

                DISTANCENAMES.add(name);

                DISTANCEABBR.add(abbr);

                DISTANCETRANS2METER.add(new Double(trans2meter));

        }

        public static String[] getDistanceNames(){

                return (String[])DISTANCENAMES.toArray(new String[0]);

        }

        public static String[] getDistanceAbbr(){

                return (String[])DISTANCEABBR.toArray(new String[0]);

        }

        public static double[] getDistanceTrans2Meter(){

                int size=DISTANCETRANS2METER.size();

                double[] trans2meters=new double[size];

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

                        trans2meters[i]=((Double)DISTANCETRANS2METER.get(i)).doubleValue();

                }

                return trans2meters;

        }

        public static int getDistancePosition(String s){

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

                        if (DISTANCENAMES.get(i).equals(s)){

                                return i;

                        }

                }

                return 0;

        }

        /**

         * <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[1]</code>: meter

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

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

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

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

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

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

         *

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

         * The value of <code>MapContext.CHANGE[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.CHANGE[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.CHANGE[8]</code>.</p>

         * @deprecated use getDistanceTrans2Meter() * 100

         */

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

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

        /**

         * <p>Gets the name of all distance measurements supported by <code>MapContext</code>.</p>

         */

//        public static final String[] NAMES= {

//                Messages.getString("Kilometros"),

//                Messages.getString("Metros"),

//                Messages.getString("Centimetros"),

//                Messages.getString("Milimetros"),

//                Messages.getString("Millas"),

//                Messages.getString("Yardas"),

//                Messages.getString("Pies"),

//                Messages.getString("Pulgadas"),

//                Messages.getString("Grados"),

//        };

        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 <i>zoom in</i> 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 <i>zoom out</i> 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>Color used to represent the selections.</p>

         */

        private static Color selectionColor = Color.YELLOW;

        /**

         * <p>Gets the color used to represent the selections.</p>

         *

         * @return color used to represent the selections

         */

        public static Color getSelectionColor() {

                return selectionColor;

        }

        /**

         * <p>Sets the color used to represent the selections.</p>

         *

         * @param selectionColor color used to represent the selections

         */

        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>

         *

         * @param vp information for drawing the layers of this map in the available rectangular area according a projection

         */

        public MapContext(ViewPort vp) {

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

                this.layers.setMapContext(this);

                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 in the available rectangular area according a projection

         */

        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 called 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);

                }

                errorListeners.clear();

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

                if (getLayers().getLayersCount() > 0)

                        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 ReadDriverException if fails reading with 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 ReadDriverException {

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

                        public boolean isCanceled() {

                                return false;

                        }

                        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 <code>MapContext</code> instance with the information of the <code>vp</code> argument, and the layers of this map.</p>

         *

         * @param vp information for drawing the layers of this map in the available rectangular area according a projection

         *

         * @return a new <code>MapContext</code> instance projected by <code>vp</code>

         */

        public MapContext createNewFMap(ViewPort vp) {

                MapContext ret = new MapContext(vp);

                ret.layers = this.layers;

                return ret;

        }

        /**

         * <p>Creates a new independent <code>MapContext</code> instance, 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 <code>MapContext</code> instance

         *

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

                aux.setMapContext(ret);

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

                {

                        FLayer lyr = antLayers.getLayer(i);

                        try {

                                aux.addLayer(lyr.cloneLayer());

                        } catch (Exception e) {

                                // TODO Auto-generated catch block

                                e.printStackTrace();

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

                double dpi = getScreenDPI();

                IProjection proj = viewPort.getProjection();

                if (viewPort.getImageSize() == null)

                        return -1;

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

                        return 0;

                }

                double[] trans2Meter=getDistanceTrans2Meter();

                if (proj == null) {

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

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

                                        .getMapUnits()]);

                }

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

                                (viewPort.getAdjustedExtent().getMaxX()*trans2Meter[getViewPort().getMapUnits()]), 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();

                double dpi = getScreenDPI();

                if (viewPort.getImageSize() == null)

                        return;

                IProjection proj = viewPort.getProjection();

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

                        return;

                }

                double[] trans2Meter=getDistanceTrans2Meter();

                Rectangle2D rec=proj.getExtent(viewPort.getAdjustedExtent(),scale,viewPort.getImageWidth(),viewPort.getImageHeight(),100*getDistanceTrans2Meter()[getViewPort().getMapUnits()],trans2Meter[getViewPort().getDistanceUnits()],dpi);

                getViewPort().setExtent(rec);

        }

        /**

         * <p>Returns the screen resolution (Dots Per Inch) as it was defined by the user's preference, or

         * by default as it is defined in the default Toolkit.</p>

         *

         * @return double with the screen's dpi

         */

        public static double getScreenDPI() {

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

                Toolkit kit = Toolkit.getDefaultToolkit();

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

                return dpi;

        }

        /**

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

         */

        public void setVectorial(VectorialAdapter v) {

        }

        /**

         * @see org.gvsig.fmap.mapcontext.rendering.strategies.Strategy#process(com.iver.cit.gvsig.fmap.FeatureSelectorVisitor)

         */

        public void process(FeatureVisitor visitor) {

        }

        /**

         * @see org.gvsig.fmap.mapcontext.rendering.strategies.Strategy#processSelected(com.iver.cit.gvsig.fmap.FeatureVisitor)

         */

        public void processSelected(FeatureVisitor visitor) {

        }

        /**

         * @see org.gvsig.fmap.mapcontext.rendering.strategies.Strategy#select(com.iver.cit.gvsig.fmap.FeatureSelectorVisitor,

         *      VectorialSubSet)

         */

        public void select(FeatureVisitor visitor) {

        }

        /**

         * @see org.gvsig.fmap.mapcontext.rendering.strategies.Strategy#selectFromSelection()

         */

        public void selectFromSelection() {

        }

        /**

         * @see org.gvsig.fmap.mapcontext.rendering.strategies.Strategy#createIndex()

         */

        public void createIndex() {

        }

        /**

         * @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#selectByPoint(java.awt.geom.Point2D,

         *      double)

         */

        /*

         * public void selectByPoint(Point2D p, double tolerance) throws

         * DriverException { Point2D mapPoint = viewPort.toMapPoint((int) p.getX(),

         * (int) p.getY()); SelectByPointVisitor visitor = new

         * SelectByPointVisitor(); visitor.setQueriedPoint(mapPoint);

         * visitor.setTolerance(getViewPort().toMapDistance(3));

         *

         * try { layers.process(visitor); } catch (VisitException e) { throw new

         * RuntimeException("No se espera que SelectByPointVisitor lance esta

         * excepci?n", e); } }

         */

        /**

         * @see com.iver.cit.gvsig.fmap.operations.strategies.Strategy#selectByRect(java.awt.geom.Rectangle2D)

         */

        /*

         * public void selectByRect(Rectangle2D rect) throws DriverException {

         * FLayer[] actives = layers.getActives(); for (int i=0; i < actives.length;

         * i++) { if (actives[i] instanceof FLyrVect) { FLyrVect lyrVect =

         * (FLyrVect) actives[i]; FBitSet oldBitSet = lyrVect.getSelection();

         * FBitSet newBitSet = lyrVect.queryByRect(rect); newBitSet.xor(oldBitSet);

         * lyrVect.setSelection(newBitSet); } }

         *  }

         */

        /**

         * @see org.gvsig.fmap.mapcontext.rendering.strategies.Strategy#selectByShape(com.iver.cit.gvsig.fmap.fshape.IGeometry,

         *      int)

         */

        public void selectByShape(IGeometry g, int relationship) {

        }

        /**

         * @see org.gvsig.fmap.mapcontext.rendering.strategies.Strategy#queryByPoint(Point2D,

         *      double)

         */

        public Record[] queryByPoint(Point2D p, double tolerance) {

                return null;

        }

        /**

         * @see org.gvsig.fmap.mapcontext.rendering.strategies.Strategy#queryByRect(java.awt.geom.Rectangle2D)

         */

        public Record[] queryByRect(Rectangle2D rect) {

                return null;

        }

        /**

         * @see org.gvsig.fmap.mapcontext.rendering.strategies.Strategy#queryByShape(com.iver.cit.gvsig.fmap.fshape.IGeometry,

         *      int)

         */

        public Record[] queryByShape(IGeometry g, int relationship) {

                return null;

        }

        /**

         * @see org.gvsig.fmap.mapcontext.rendering.strategies.Strategy#getSelectionBounds()

         *

         * @see SelectedZoomVisitor#getSelectBound()

         */

        public Rectangle2D getSelectionBounds() {

                SelectedZoomVisitor visitor = new SelectedZoomVisitor();

                try {

                        layers.process(visitor);

                } catch (ReadDriverException e1) {

                        throw new RuntimeException(

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

                                        e1);

                } catch (VisitorException 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 by 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 shared object that determines if this layer can continue being drawn

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

         * @throws ReadDriverException if fails reading with the driver.

         */

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

                        double scale) throws ReadDriverException {

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

        }

        /**

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

        {

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

                {

                        FLayer lyr = parent.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);

                        }

                }

        }

        /**

         * <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 shared object that determines if this layer can continue being drawn

         * @param scale value that represents the scale

         * @throws ReadDriverException if fails reading with the driver.

         *

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

         */

        public void drawGraphics(BufferedImage image, Graphics2D g,

                        Cancellable cancel, double scale) throws ReadDriverException {

                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 ReadDriverException if the driver fails reading.

         *

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

         */

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

                        throws ReadDriverException {

                layers.setDirty(true);

                draw(image, g, new Cancellable() {

                        /**

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

                         */

                        public boolean isCanceled() {

                                return false;

                        }

                        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