Application: gvSIG desktop

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

	<appender name="CONSOLE" class="org.apache.log4j.ConsoleAppender">

		<layout class="org.apache.log4j.PatternLayout">

			<param name="ConversionPattern" value="%d{HH:mm:ss,SSS} %-5p [%c{2}.%M()]\n  %m%n" />

		</layout>

	</appender>

	<category name="org.gvsig.tools">

		<priority value="DEBUG" />

	</category>

	<category name="org.gvsig.fmap.mapcontext">

		<priority value="DEBUG" /> 

	</category>

	<root>

		<priority value="INFO" />

		<appender-ref ref="CONSOLE" />

	</root>

</log4j:configuration>

/* gvSIG. Geographic Information System of the Valencian Government

 *

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

 * of the Valencian Government (CIT)

 * 

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

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

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

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

 * 

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

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

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

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

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

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

 * MA  02110-1301, USA.

 * 

 */

/*

 * AUTHORS (In addition to CIT):

 * 2009 {DiSiD Technologies}  {Create Manager to register MapContextDrawer implementation}

 */

package org.gvsig.fmap.mapcontext;

import java.awt.Color;

import java.awt.Font;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.mapcontext.exceptions.LoadLayerException;

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

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

import org.gvsig.fmap.mapcontext.rendering.legend.ILegend;

import org.gvsig.fmap.mapcontext.rendering.legend.IVectorLegend;

import org.gvsig.fmap.mapcontext.rendering.legend.driver.ILegendReader;

import org.gvsig.fmap.mapcontext.rendering.legend.driver.ILegendWriter;

import org.gvsig.fmap.mapcontext.rendering.legend.styling.ILabelingStrategy;

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

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

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

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

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

/**

 * Manager of the MapContext library.

 * 

 * Holds the default implementation of the {@link MapContextDrawer}.

 * 

 * @author <a href="mailto:cordinyana@gvsig.org">C?sar Ordi?ana</a>

 * @author <a href="mailto:jjdelcerro@gvsig.org">Joaquin Jose del Cerro</a>

 */

public interface MapContextManager {

	/**

	 * Create a new layer from the data parameters passed as parameter.

	 * 

	 * @param layerName name used in for the new layer. 

	 * @param parameters used for create the {@link DataStore} of the new layer

	 * 

	 * @return the new FLayer

	 * 

	 * @throws LoadLayerException

	 */

	public FLayer createLayer(String layerName,

			DataStoreParameters parameters) throws LoadLayerException;

	/**

	 * Create a layer from a {@link DataStore}.

	 * 

	 * @param layerName name used in for the new layer. 

	 * @param store used for the new layer

	 * 

	 * @return the new FLayer

	 * 

	 * @throws LoadLayerException

	 */

	public FLayer createLayer(String layerName, DataStore store)

			throws LoadLayerException;

	/**

	 * Create a layer to be used as the {@link GraphicLayer}.

	 * 

	 * @param projection used in the layer.

	 * 

	 * @return the new {@link GraphicLayer}.

	 */

	public GraphicLayer createGraphicsLayer(IProjection projection);

	/**

	 * Returns the current {@link SymbolManager}.

	 * 

	 * @return the {@link SymbolManager}

	 */

	SymbolManager getSymbolManager();

	/**

	 * Sets the class to use as the default implementation for the

	 * {@link MapContextDrawer}.

	 * 

	 * @param drawerClazz

	 *            the {@link MapContextDrawer} class to use

	 * @throws MapContextException

	 *             if there is any error setting the class

	 */

	public void setDefaultMapContextDrawer(Class drawerClazz)

			throws MapContextException;

	public void validateMapContextDrawer(Class drawerClazz) throws MapContextException;

	/**

	 * Creates a new instance of the default {@link MapContextDrawer}

	 * implementation.

	 * 

	 * @return the new {@link MapContextDrawer} instance

	 * @throws MapContextException

	 *             if there is an error creating the new object instance

	 */

	public MapContextDrawer createDefaultMapContextDrawerInstance()

			throws MapContextException;

	/**

	 * Creates a new instance of the provided {@link MapContextDrawer}

	 * implementation.

	 * 

	 * @param drawerClazz

	 *            the {@link MapContextDrawer} implementation class

	 * @return the new {@link MapContextDrawer} instance

	 * @throws MapContextException

	 *             if there is an error creating the new object instance

	 */

	public MapContextDrawer createMapContextDrawerInstance(Class drawerClazz)

			throws MapContextException;

	void registerLegend(String legendName, Class legendClass)

			throws MapContextRuntimeException;

	ILegend createLegend(String legendName) throws MapContextRuntimeException;

	void setDefaultVectorLegend(String legendName);

	IVectorLegend createDefaultVectorLegend(int shapeType)

			throws MapContextRuntimeException;

	void registerLegendWriter(String legendName, String format,

			Class writerClass) throws MapContextRuntimeException;

	void registerLegendReader(String format, Class readerClass)

			throws MapContextRuntimeException;

	ILegendWriter createLegendWriter(String legendName, String format)

			throws MapContextException;

	ILegendReader createLegendReader(String format)

			throws MapContextRuntimeException;

	/**

	 * @deprecated to be removed in gvSIG 2.0

	 * @see {@link SymbolPreferences}.

	 */

	int getDefaultCartographicSupportMeasureUnit();

	/**

	 * @deprecated to be removed in gvSIG 2.0

	 * @see {@link SymbolPreferences}.

	 */

	void setDefaultCartographicSupportMeasureUnit(

			int defaultCartographicSupportMeasureUnit);

	/**

	 * @deprecated to be removed in gvSIG 2.0

	 * @see {@link SymbolPreferences}.

	 */

	int getDefaultCartographicSupportReferenceSystem();

	/**

	 * @deprecated to be removed in gvSIG 2.0

	 * @see {@link SymbolPreferences}.

	 */

	void setDefaultCartographicSupportReferenceSystem(

			int defaultCartographicSupportReferenceSystem);

	/**

	 * @deprecated to be removed in gvSIG 2.0

	 * @see {@link SymbolPreferences}.

	 */

	Color getDefaultSymbolColor();

	/**

	 * @deprecated to be removed in gvSIG 2.0

	 * @see {@link SymbolPreferences}.

	 */

	void setDefaultSymbolColor(Color defaultSymbolColor);

	/**

	 * @deprecated to be removed in gvSIG 2.0

	 * @see {@link SymbolPreferences}.

	 */

	void resetDefaultSymbolColor();

	/**

	 * @deprecated to be removed in gvSIG 2.0

	 * @see {@link SymbolPreferences}.

	 */

	Color getDefaultSymbolFillColor();

	/**

	 * @deprecated to be removed in gvSIG 2.0

	 * @see {@link SymbolPreferences}.

	 */

	void setDefaultSymbolFillColor(Color defaultSymbolFillColor);

	/**

	 * @deprecated to be removed in gvSIG 2.0

	 * @see {@link SymbolPreferences}.

	 */

	void resetDefaultSymbolFillColor();

	/**

	 * @deprecated to be removed in gvSIG 2.0

	 * @see {@link SymbolPreferences}.

	 */

	boolean isDefaultSymbolFillColorAleatory();

	/**

	 * @deprecated to be removed in gvSIG 2.0

	 * @see {@link SymbolPreferences}.

	 */

	void setDefaultSymbolFillColorAleatory(

			boolean defaultSymbolFillColorAleatory);

	/**

	 * @deprecated to be removed in gvSIG 2.0

	 * @see {@link SymbolPreferences}.

	 */

	void resetDefaultSymbolFillColorAleatory();

	/**

	 * @deprecated to be removed in gvSIG 2.0

	 * @see {@link SymbolPreferences}.

	 */

	Font getDefaultSymbolFont();

	/**

	 * @deprecated to be removed in gvSIG 2.0

	 * @see {@link SymbolPreferences}.

	 */

	void setDefaultSymbolFont(Font defaultSymbolFont);

	/**

	 * @deprecated to be removed in gvSIG 2.0

	 * @see {@link SymbolPreferences}.

	 */

	void resetDefaultSymbolFont();

	/**

	 * @deprecated to be removed in gvSIG 2.0

	 * @see {@link SymbolPreferences}.

	 */

	String getSymbolLibraryPath();

	/**

	 * @deprecated to be removed in gvSIG 2.0

	 * @see {@link SymbolPreferences}.

	 */

	void setSymbolLibraryPath(String symbolLibraryPath);

	/**

	 * @deprecated to be removed in gvSIG 2.0

	 * @see {@link SymbolPreferences}.

	 */

	void resetSymbolLibraryPath();

	/**

	 * @deprecated to be removed in gvSIG 2.0 @see {@link SymbolManager}

	 */

	ISymbol createSymbol(String symbolName) throws MapContextRuntimeException;

	/**

	 * @deprecated to be removed in gvSIG 2.0 @see {@link SymbolManager}

	 */

	ISymbol createSymbol(int shapeType) throws MapContextRuntimeException;

	/**

	 * @deprecated to be removed in gvSIG 2.0 @see {@link SymbolManager}

	 */

	ISymbol createSymbol(String symbolName, Color color)

			throws MapContextRuntimeException;

	/**

	 * @deprecated to be removed in gvSIG 2.0 @see {@link SymbolManager}

	 */

	ISymbol createSymbol(int shapeType, Color color)

			throws MapContextRuntimeException;

	/**

	 * @deprecated to be removed in gvSIG 2.0 @see {@link SymbolManager}

	 */

	IMultiLayerSymbol createMultiLayerSymbol(String symbolName)

			throws MapContextRuntimeException;

	/**

	 * @deprecated to be removed in gvSIG 2.0 @see {@link SymbolManager}

	 */

	IMultiLayerSymbol createMultiLayerSymbol(int shapeType)

			throws MapContextRuntimeException;

	/**

	 * @deprecated to be removed in gvSIG 2.0 @see {@link SymbolManager}

	 */

	void registerSymbol(String symbolName, Class symbolClass)

			throws MapContextRuntimeException;

	/**

	 * @deprecated to be removed in gvSIG 2.0 @see {@link SymbolManager}

	 */

	void registerSymbol(String symbolName, int[] shapeTypes, Class symbolClass)

			throws MapContextException;

	/**

	 * @deprecated to be removed in gvSIG 2.0 @see {@link SymbolManager}

	 */

	void registerMultiLayerSymbol(String symbolName, Class symbolClass)

			throws MapContextRuntimeException;

	/**

	 * @deprecated to be removed in gvSIG 2.0 @see {@link SymbolManager}

	 */

	void registerMultiLayerSymbol(String symbolName, int[] shapeTypes,

			Class symbolClass) throws MapContextRuntimeException;

	/**

	 * @deprecated to be removed in gvSIG 2.0 @see {@link SymbolManager}

	 */

	IWarningSymbol getWarningSymbol(String message, String symbolDesc,

			int symbolDrawExceptionType) throws MapContextRuntimeException;

	/**

	 * It returns the legend associated with a {@link DataStore}.

	 * If the legend doesn't exist it returns <code>null</code>.

	 * @param dataStore

	 * the store that could have a legend.

	 * @return

	 * the legend or <code>null</code>.

	 */

	ILegend getLegend(DataStore dataStore);	

	/**

     * It returns the labeling strategy associated with a {@link DataStore}.

     * If the labeling strategy doesn't exist it returns <code>null</code>.

     * @param dataStore

     * the store that could have a labeling strategy.

     * @return

     * the labeling strategy or <code>null</code>.

     */

	ILabelingStrategy getLabelingStrategy(DataStore dataStore);

	void registerIconLayer(String store, String iconName);

	String getIconLayer(DataStore store);

    // TODO:

    // DynObjectModel getFeatureTypeUIModel(DataStore store,

    // FeatureType featureType);

	/**

	 * Returns the default CRS.

	 * This is NOT taken from the app

	 * preferences because this is a library. It is a

	 * "hard-coded" default CRS, used as a last resort.

	 * @return the default CRS

	 */

	IProjection getDefaultCRS();

}

/* 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 org.gvsig.fmap.dal.DataSet;

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

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

import org.gvsig.fmap.geom.primitive.Envelope;

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

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

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

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.visitor.NotSupportedOperationException;

import org.gvsig.tools.visitor.Visitable;

import org.gvsig.tools.visitor.Visitor;

/**

 * Visitor de zoom a lo seleccionado.

 *

 * @author Vicente Caballero Navarro

 */

public class SelectedZoomVisitor implements LayersVisitor, Visitor {

	private Envelope rectangle = null;

	/**

	 * Devuelve el Extent de los shapes seleccionados, y si no hay ning?n shape

	 * seleccionado devuelve null.

	 *

	 * @return Extent de los shapes seleccionados.

	 */

	public Envelope getSelectBound() {

		return rectangle;

	}

	public String getProcessDescription() {

		return "Defining rectangle to zoom from selected geometries";

	}

	public void visit(Feature feature) throws BaseException {

		if (rectangle == null) {

			rectangle = (feature.getDefaultGeometry()).getEnvelope();

		} else {

			rectangle.add((feature.getDefaultGeometry())

					.getEnvelope());

		}

	}

	public void visit(FeatureReference featureRefence) throws BaseException {

		this.visit(featureRefence.getFeature());

	}

	public void visit(Object obj) throws BaseException {

		if (obj instanceof FeatureReference) {

			this.visit((FeatureReference) obj);

			return;

		}

		if (obj instanceof Feature) {

			this.visit((Feature) obj);

			return;

		}

		if (obj instanceof FLayer) {

			this.visit((FLayer) obj);

			return;

		}

		throw new NotSupportedOperationException(this, obj);

	}

	public void visit(FLayer layer) throws BaseException {

		if (!(layer instanceof SingleLayer)) {

			return;

		} else if (!layer.isActive()) {

			return;

		}

		DataSet selection = ((SingleLayer) layer).getDataStore()

				.getSelection();

		if (selection instanceof Visitable) {

			((Visitable) selection).accept(this);

		}

	}

}

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

public interface Record {

    int getFieldCount() ;

    String getFieldName(int index) ;

    String getFieldValue(int index) ;

}

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

import java.awt.Toolkit;

import java.awt.geom.AffineTransform;

import java.awt.geom.NoninvertibleTransformException;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.util.ArrayList;

import org.cresques.cts.GeoCalc;

import org.cresques.cts.IProjection;

import org.cresques.cts.UTM;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.exception.CreateEnvelopeException;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.geom.primitive.Point;

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

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

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

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

import org.gvsig.timesupport.Time;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.lang.Cloneable;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.util.Callable;

/**

 * <p>

 * <code>ViewPort</code> class represents the logic needed to transform a

 * rectangular area of a map to the available area in screen to display it.

 * </p>

 * 

 * <p>

 * Includes an affine transformation, between the rectangular area selected of

 * the external map, in its own <i>map coordinates</i>, to the rectangular area

 * available of a view in <i>screen coordinates</i>.

 * </p>

 * 

 * <p>

 * Elements:

 * <ul>

 * <li><i>extent</i>: the area selected of the map, in <i>map coordinates</i>.

 * <li><i>imageSize</i>: width and height in pixels (<i>screen coordinates</i>)

 * of the area available in screen to display the area selected of the map.

 * <li><i>adjustedExtent</i>: the area selected must be an scale of

 * <i>imageSize</i>.<br>

 * This implies adapt the extent, preserving and centering it, and adding around

 * the needed area to fill all the image size. That added area will be extracted

 * from the original map, wherever exists, and filled with the background color

 * wherever not.

 * <li><i>scale</i>: the scale between the adjusted extent and the image size.

 * <li><i>backColor</i>: the default background color in the view, if there is

 * no map.

 * <li><i>trans</i>: the affine transformation.

 * <li><i>proj</i>: map projection used in this view.

 * <li><i>distanceUnits</i>: distance measurement units, of data in screen.

 * <li><i>mapUnits</i>: measurement units, of data in map.

 * <li><i>extents</i>: an {@link ExtentHistory ExtentHistory} with the last

 * previous extents.

 * <li><i>offset</i>: position in pixels of the available rectangular area,

 * where start drawing the map.

 * <li><i>dist1pixel</i>: the distance in <i>world coordinates</i> equivalent to

 * 1 pixel in the view with the current extent.

 * <li><i>dist3pixel</i>: the distance in <i>world coordinates</i> equivalent to

 * 3 pixels in the view with the current extent.

 * <li><i>listeners</i>: list with the {@link ViewPortListener ViewPortListener}

 * registered.

 * </ul>

 * </p>

 * 

 * @author Vicente Caballero Navarro

 */

public class ViewPort implements Persistent, Cloneable {

    private static final String FIELD_DISTANCE_AREA = "distanceArea";

    private static final String FIELD_IMAGE_SIZE = "imageSize";

    private static final String FIELD_PROJ = "proj";

    private static final String FIELD_OFFSET = "offset";

    private static final String FIELD_MAP_UNITS = "mapUnits";

    private static final String FIELD_EXTENT = "extent";

    private static final String FIELD_EXTENTS = "extents";

    private static final String FIELD_DISTANCE_UNITS = "distanceUnits";

    private static final String FIELD_DIST3PIXEL = "dist3pixel";

    private static final String FIELD_DIST1PIXEL = "dist1pixel";

    private static final String FIELD_CLIP = "clip";

    private static final String FIELD_BACK_COLOR = "backColor";

    private static final String FIELD_ADJUSTED_EXTENT = "adjustedExtent";

    private static final GeometryManager geomManager =

        GeometryLocator.getGeometryManager();

    private static final Logger logger =

        LoggerFactory.getLogger(ViewPort.class);

    /**

     * <p>

     * Screen resolution in <i>dots-per-inch</i>. Useful to calculate the

     * geographic scale of the view.

     * </p>

     * 

     * @see Toolkit#getScreenResolution()

     * @see #getScale()

     */

    private static int dpi = java.awt.Toolkit.getDefaultToolkit()

        .getScreenResolution();

    /**

     * <p>

     * Area selected by user using some tool.

     * </p>

     * 

     * <p>

     * When the zoom changes (for instance when using the zoom in or zoom out

     * tools, but also zooming to a selected feature or shape) the extent that

     * covers that area is the value returned by this method. It is not the

     * actual area shown in the view because it does not care about the aspect

     * ratio of the available area. However, any part of the real world

     * contained in this extent is shown in the view.

     * </p>

     * <p>

     * Probably this is not what you are looking for. If you are looking for the

     * complete extent currently shown, you must use

     * {@linkplain #getAdjustedExtent()} method which returns the extent that

     * contains this one but regarding the current view's aspect ratio.

     * </p>

     * 

     * @see #getExtent()

     * @see #setEnvelope(Envelope)

     */

    protected Rectangle2D extent;

    protected Time time;

    /**

     * <p>

     * Location and dimensions of the extent adjusted to the image size.

     * </p>

     * 

     * @see #getAdjustedExtent()

     */

    protected Rectangle2D adjustedExtent;

    /**

     * Draw version of the context. It's used for know when de componend has

     * changed any visualization property

     * 

     * @see getDrawVersion

     * @see updateDrawVersion

     */

    private long drawVersion = 0L;

    /**

     * <p>

     * History with the last extents of the view.

     * </p>

     * 

     * @see #setPreviousExtent()

     * @see #getExtents()

     */

    protected ExtentHistory extents = new ExtentHistory();

    /**

     * <p>

     * Size in <i>screen coordinates</i> of the rectangle where the image is

     * displayed.

     * </p>

     * <p>

     * Used by {@linkplain #calculateAffineTransform()} to calculate:<br>

     * 

     * <ul>

     * <li>The new {@link #scale scale} .

     * <li>The new {@link #adjustedExtent adjustableExtent} .

     * <li>The new {@link #trans trans} .

     * <li>The new real world coordinates equivalent to 1 pixel (

     * {@link #dist1pixel dist1pixel}) .

     * <li>The new real world coordinates equivalent to 3 pixels (

     * {@link #dist3pixel dist3pixel}) .

     * </ul>

     * </p>

     * 

     * @see #getImageSize()

     * @see #getImageHeight()

     * @see #getImageWidth()

     * @see #setImageSize(Dimension)

     */

    private Dimension imageSize;

    /**

     * <p>

     * the affine transformation between the {@link #extent extent} in <i>map 2D

     * coordinates</i> to the image area in the screen, in <i>screen 2D

     * coordinates</i> (pixels).

     * </p>

     * 

     * @see AffineTransform

     * 

     * @see #getAffineTransform()

     * @see #setAffineTransform(AffineTransform)

     * @see #calculateAffineTransform()

     */

    private AffineTransform trans = new AffineTransform();

    /**

     * <p>

     * Measurement unit used for measuring distances and displaying information.

     * </p>

     * 

     * @see #getDistanceUnits()

     * @see #setDistanceUnits(int)

     */

    private int distanceUnits = 1;

    /**

     * <p>

     * Measurement unit used for measuring areas and displaying information.

     * </p>

     * 

     * @see #getDistanceArea()

     * @see #setDistanceArea(int)

     */

    private int distanceArea = 1;

    /**

     * <p>

     * Measurement unit used by this view port for the map.

     * </p>

     * 

     * @see #getMapUnits()

     * @see #setMapUnits(int)

     */

    private int mapUnits = 1;

    /**

     * <p>

     * Array with the {@link ViewPortListener ViewPortListener}s registered to

     * this view port.

     * </p>

     * 

     * @see #addViewPortListener(ViewPortListener)

     * @see #removeViewPortListener(ViewPortListener)

     */

    private ArrayList listeners = new ArrayList();

    /**

     * <p>

     * The offset is the position where start drawing the map.

     * </p>

     * <p>

     * The offset of a <a href="http://www.gvsig.gva.es/">gvSIG</a>'s

     * <i>View</i> is always (0, 0) because the drawing area fits with the full

     * window area. But in a <a href="http://www.gvsig.gva.es/">gvSIG</a>'s

     * <i>Layout</i> it's up to the place where the <code>FFrameView</code> is

     * located.

     * </p>

     * 

     * @see #getOffset()

     * @see #setOffset(Point2D)

     */

    private Point2D offset = new Point2D.Double(0, 0);

    /**

     * <p>

     * Clipping area.

     * </p>

     */

    // private Rectangle2D clip;

    /**

     * <p>

     * Background color of this view.

     * </p>

     * 

     * @see #getBackColor()

     * @see #setBackColor(Color)

     */

    private Color backColor = null; // Color.WHITE;

    /**

     * <p>

     * Information about the map projection used in this view.

     * </p>

     * 

     * @see #getProjection()

     * @see #setProjection(IProjection)

     */

    private IProjection proj;

    /**

     * <p>

     * Represents the distance in <i>world coordinates</i> equivalent to 1 pixel

     * in the view with the current extent.

     * </p>

     * 

     * @see #getDist1pixel()

     * @see #setDist1pixel(double)

     */

    private double dist1pixel;

    /**

     * <p>

     * Represents the distance in <i>world coordinates</i> equivalent to 3

     * pixels in the view with the current extent.

     * </p>

     * 

     * @see #getDist3pixel()

     * @see #setDist3pixel(double)

     */

    private double dist3pixel;

    /**

     * <p>

     * Ratio between the size of <code>imageSize</code> and <code>extent</code>:

     * <br>

     * <i>

     * 

     * <pre>

     * min{(imageSize.getHeight()/extent.getHeight(), imageSize.getWidth()/extent.getWidth())}

     * </pre>

     * 

     * </i>

     * </p>

     */

    private double scale;

    /**

     * <p>

     * Clipping area.

     * </p>

     * 

     * @see #setClipRect(Rectangle2D)

     */

    private Rectangle2D cliprect;

    /**

     * <p>

     * Enables or disables the <i>"adjustable extent"</i> mode.

     * </p>

     * 

     * <p>

     * When calculates the affine transform, if

     * <ul>

     * <li><i>enabled</i>: the new <code>adjustedExtent</code> will have the (X,

     * Y) coordinates of the <code>extent</code> and an area that will be an

     * scale of the image size. That area will have different height or width

     * (not both) of the extent according the least ratio (height or width) in

     * 

     * <pre>

     * image.size/extent.size"

     * </pre>.

     * <li><i>disabled</i>: the new <code>adjustedExtent</code> will be like

     * <code>extent</code>.

     * </ul>

     * </p>

     * 

     * @see #setAdjustable(boolean)

     */

    private boolean adjustableExtent = true;

    public ViewPort() {

    }

    /**

     * <p>

     * Creates a new view port with the information of the projection in

     * <code>proj</code> argument, and default configuration:

     * </p>

     * <p>

     * <ul>

     * <li><i><code>distanceUnits</code></i> = meters

     * <li><i><code>mapUnits</code></i> = meters

     * <li><i><code>backColor</code></i> = <i>undefined</i>

     * <li><i><code>offset</code></i> = <code>new Point2D.Double(0, 0);</code>

     * </ul>

     * </p>

     * 

     * @param proj

     *            information of the projection for this view port

     */

    public ViewPort(IProjection proj) {

        // Por defecto

        this.proj = proj;

    }

    /**

     * <p>

     * Changes the status of the <i>"adjustable extent"</i> option to enabled or

     * disabled.

     * </p>

     * 

     * <p>

     * If view port isn't adjustable, won't bear in mind the aspect ratio of the

     * available rectangular area to calculate the affine transform from the

     * original map in real coordinates. (Won't scale the image to adapt it to

     * the available rectangular area).

     * </p>

     * 

     * @param boolean the boolean to be set

     */

    public void setAdjustable(boolean adjustable) {

        if (adjustable == adjustableExtent) {

            return;

        }

        adjustableExtent = adjustable;

        this.updateDrawVersion();

    }

    /**

     * <p>

     * Appends the specified {@link ViewPortListener ViewPortListener} listener

     * if weren't.

     * </p>

     * 

     * @param arg0

     *            the listener to add

     * 

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

     * 

     * @see #removeViewPortListener(ViewPortListener)

     */

    public boolean addViewPortListener(ViewPortListener arg0) {

        if (!listeners.contains(arg0)) {

            return listeners.add(arg0);

        }

        return false;

    }

    /**

     * <p>

     * Removes the specified {@link ViewPortListener ViewPortListener} listener,

     * if existed.

     * </p>

     * 

     * @param arg0

     *            the listener to remove

     * 

     * @return <code>true</code> if the contained the specified listener.

     * 

     * @see #addViewPortListener(ViewPortListener)

     */

    public boolean removeViewPortListener(ViewPortListener arg0) {

        return listeners.remove(arg0);

    }

    /**

     * <p>

     * Converts and returns the distance <code>d</code>, that is in <i>map

     * coordinates</i> to <i>screen coordinates</i> using a <i>delta

     * transform</i> with the transformation affine information in the

     * {@link #trans #trans} attribute.

     * </p>

     * 

     * @param d

     *            distance in <i>map coordinates</i>

     * 

     * @return distance equivalent in <i>screen coordinates</i>

     * 

     * @see #toMapDistance(int)

     * @see AffineTransform#deltaTransform(Point2D, Point2D)S

     */

    public int fromMapDistance(double d) {

        Point2D.Double pWorld = new Point2D.Double(1, 1);

        Point2D.Double pScreen = new Point2D.Double();

        try {

            trans.deltaTransform(pWorld, pScreen);

        } catch (Exception e) {

            System.err.print(e.getMessage());

        }

        return (int) (d * pScreen.x);

    }

    /**

     * <p>

     * Converts and returns the 2D point <code>(x,y)</code>, that is in <i>map

     * coordinates</i> to <i>screen coordinates</i> (pixels) using the affine

     * transformation in the {@link #trans #trans} attribute.

     * </p>

     * 

     * @param x

     *            the <code>x</code> <i>map coordinate</i> of a 2D point

     * @param y

     *            the <code>y</code> <i>map coordinate</i> of a 2D point

     * 

     * @return 2D point equivalent in <i>screen coordinates</i> (pixels)

     * 

     * @see #fromMapPoint(Point2D)

     * @see AffineTransform#transform(Point2D, Point2D)

     */

    public Point2D fromMapPoint(double x, double y) {

        Point2D.Double pWorld = new Point2D.Double(x, y);

        Point2D.Double pScreen = new Point2D.Double();

        try {

            trans.transform(pWorld, pScreen);

        } catch (Exception e) {

            System.err.print(e.getMessage());

        }

        return pScreen;

    }

    /**

     * <p>

     * Converts and returns the 2D point argument, that is in <i>map

     * coordinates</i> to <i>screen coordinates</i> (pixels) using the affine

     * transformation in the {@link #trans #trans} attribute.

     * </p>

     * 

     * @param point

     *            the 2D point in <i>map coordinates</i>

     * 

     * @return 2D point equivalent in <i>screen coordinates</i> (pixels)

     * 

     * @see #toMapPoint(Point2D)

     * @see #fromMapPoint(double, double)

     */

    public Point2D fromMapPoint(Point2D point) {

        return fromMapPoint(point.getX(), point.getY());

    }

    /**

     * <p>

     * Converts and returns the 2D point <code>(x,y)</code>, that is in

     * <i>screen coordinates</i> (pixels) to <i>map coordinates</i> using the

     * affine transformation in the {@link #trans #trans} attribute.

     * </p>

     * 

     * @param x

     *            the <code>x</code> <i>screen coordinate</i> of a 2D point

     * @param y

     *            the <code>y</code> <i>screen coordinate</i> of a 2D point

     * 

     * @return 2D point equivalent in <i>map coordinates</i>

     * 

     * @see #toMapPoint(Point2D)

     * @see #fromMapPoint(double, double)

     * @deprecated use {@link #convertToMapPoint(int, int)}

     */

    public Point2D toMapPoint(int x, int y) {

        Point2D pScreen = new Point2D.Double(x, y);

        return toMapPoint(pScreen);

    }

    /**

     * <p>

     * Converts and returns the {@link Rectangle2D Rectangle2D}, that is in

     * <i>screen coordinates</i> (pixels) to <i>map coordinates</i> using

     * {@linkplain #toMapDistance(int)}, and {@linkplain #toMapPoint(int, int)}.

     * </p>

     * 

     * @param r

     *            the 2D rectangle in <i>screen coordinates</i> (pixels)

     * @return 2D rectangle equivalent in <i>map coordinates</i>

     * 

     * @see #fromMapRectangle(Rectangle2D)

     * @see #toMapDistance(int)

     * @see #toMapPoint(int, int)

     */

    public Rectangle2D toMapRectangle(Rectangle2D r) {

        Rectangle2D rect = new Rectangle2D.Double();

        Point2D p1 = toMapPoint((int) r.getX(), (int) r.getY());

        Point2D p2 = toMapPoint((int) r.getMaxX(), (int) r.getMaxY());

        rect.setFrameFromDiagonal(p1, p2);

        return rect;

    }

    /**

     * <p>

     * Converts and returns the distance <code>d</code>, that is in <i>screen

     * coordinates</i> to <i>map coordinates</i> using the transformation affine

     * information in the {@link #trans #trans} attribute.

     * </p>

     * 

     * @param d

     *            distance in pixels

     * 

     * @return distance equivalent in <i>map coordinates</i>

     * 

     * @see #fromMapDistance(double)

     * @see AffineTransform

     */

    public double toMapDistance(int d) {

        double dist = d / trans.getScaleX();

        return dist;

    }

    /**

     * <p>

     * Converts and returns the 2D point argument, that is in <i>screen

     * coordinates</i> (pixels) to <i>map coordinates</i> using the inverse

     * affine transformation of the {@link #trans #trans} attribute.

     * </p>

     * 

     * @param pScreen

     *            the 2D point in <i>screen coordinates</i> (pixels)

     * 

     * @return 2D point equivalent in <i>map coordinates</i>

     * 

     * @see #toMapPoint(int, int)

     * @see AffineTransform#createInverse()

     * @see AffineTransform#transform(Point2D, Point2D)

     * @deprecated use {@link #convertToMapPoint(Point2D)}

     */

    public Point2D toMapPoint(Point2D pScreen) {

        Point2D.Double pWorld = new Point2D.Double();

        AffineTransform at;

        try {

            at = trans.createInverse();

            at.transform(pScreen, pWorld);

        } catch (NoninvertibleTransformException e) {

            throw new RuntimeException("Non invertible transform Exception", e);

        }

        return pWorld;

    }

    public Point convertToMapPoint(Point2D pScreen) {

    	Point2D p = toMapPoint(pScreen);

		try {

			return geomManager.createPoint(

				p.getX(), 

				p.getY(), 

				Geometry.SUBTYPES.GEOM2D

			);

		} catch (CreateGeometryException e) {

			// FIXME: Use a most especific exception.

			throw new RuntimeException(e);

		}

    }

    public Point convertToMapPoint(int x, int y) {

        Point2D pScreen = new Point2D.Double(x, y);

        return convertToMapPoint(pScreen);

    }

    /**

     * <p>

     * Returns the real distance (in <i>world coordinates</i>) at the graphic

     * layers of two 2D points (in <i>map coordinates</i>) of the plane where is

     * selected the <i>extent</i>.

     * </p>

     * <p>

     * If the projection of this view is UTM, considers the Earth curvature.

     * </p>

     * 

     * @param pt1

     *            a 2D point in <i>map coordinates</i>

     * @param pt2

     *            another 2D point in <i>map coordinates</i>

     * 

     * @return the distance in meters between the two points 2D

     * 

     * @see GeoCalcImpl#distanceVincenty(Point2D, Point2D)

     */

    public double distanceWorld(Point2D pt1, Point2D pt2) {

        double dist = -1;

        dist = pt1.distance(pt2);

        if ((proj != null) && !(proj instanceof UTM)) {

            dist =

                new GeoCalc(proj).distanceVincenty(proj.toGeo(pt1),

                    proj.toGeo(pt2));

            return dist;

        }

        return (dist * MapContext.getDistanceTrans2Meter()[getMapUnits()]);

    }

    /**

     * <p>

     * Sets as extent and adjusted extent of this view port, the previous.

     * Recalculating its parameters.

     * </p>

     * 

     * @see #getExtents()

     * @see #calculateAffineTransform()

     * @deprecated use {@link ViewPort#setPreviousEnvelope()}

     */

    public void setPreviousExtent() {

        setPreviousEnvelope();

    }

    /**

     * <p>

     * Sets as envelope and adjusted envelope of this view port, the previous.

     * Recalculating its parameters.

     * </p>

     * 

     * @see #getExtents()

     * @see #calculateAffineTransform()

     */

    public void setPreviousEnvelope() {

        this.updateDrawVersion();

        extent = extents.removePrev();

        // Calcula la transformaci�n af�n

        calculateAffineTransform();

        // Lanzamos los eventos de extent cambiado

        callExtentChanged(getAdjustedExtent());

    }

    /**

     * <p>

     * Gets the area selected by user using some tool.

     * </p>

     * 

     * <p>

     * When the zoom changes (for instance using the <i>zoom in</i> or <i>zoom

     * out</i> tools, but also zooming to a selected feature or shape) the

     * extent that covers that area is the value returned by this method. It is

     * not the actual area shown because it doesn't care about the aspect ratio

     * of the image size of the view. However, any part of the real world

     * contained in this extent is shown in the view.

     * </p>

     * 

     * <p>

     * If you are looking for the complete extent currently shown, you must use

     * the {@linkplain #getAdjustedExtent()} method.

     * </p>

     * 

     * @return the current extent

     * 

     * @see #setEnvelope(Envelope)

     * @see #getAdjustedExtent()

     * @see #setPreviousExtent()

     * @see #getExtents()

     * 

     * @deprecated use {@link ViewPort#getEnvelope()}

     */

    public Rectangle2D getExtent() {

        return extent;

    }

    /**

     * <p>

     * Gets the envelope selected by user using some tool.

     * </p>

     * 

     * <p>

     * When the zoom changes (for instance using the <i>zoom in</i> or <i>zoom

     * out</i> tools, but also zooming to a selected feature or shape) the

     * envelope that covers that area is the value returned by this method. It

     * is not the actual envelope shown because it doesn't care about the aspect

     * ratio of the image size of the view. However, any part of the real world

     * contained in this envelope is shown in the view.

     * </p>

     * 

     * <p>

     * If you are looking for the complete extent currently shown, you must use

     * the {@linkplain #getAdjustedEnvelope()} method.

     * </p>

     * 

     * @return the current envelope

     * 

     * @see #setEnvelope(Envelope)

     * @see #getAdjustedEnvelope()

     * @see #setPreviousEnvelope()

     * @see #getEnvelopes()

     */

    public Envelope getEnvelope() {

        if (this.extent == null) {

            return null;

        }

        try {

            return geomManager.createEnvelope(extent.getMinX(),

                extent.getMinY(),

                extent.getMaxX(),

                extent.getMaxY(),

                SUBTYPES.GEOM2D);

            // This class has to use Envelope instead of Rectangle2D. This catch

            // will disappear

        } catch (CreateEnvelopeException e) {

            logger.error("Error creating the envelope");

        }

        return null;

    }

    /**

     * <p>

     * Changes the <i>extent</i> and <i>adjusted extent</i> of this view port:<br>

     * <ul>

     * <li>Stores the previous extent.

     * <li>Calculates the new extent using <code>r</code>:

     * 

     * <pre>

     * extent =

     *     new Rectangle2D.Double(r.getMinX() - 0.1,

     *         r.getMinY() - 0.1,

     *         r.getWidth() + 0.2,

     *         r.getHeight() + 0.2);

     * </pre>

     * 

     * <li>Executes {@linkplain #calculateAffineTransform()}: getting the new

     * scale, adjusted extent, affine transformation between map and screen

     * coordinates, the real world coordinates equivalent to 1 pixel, and the

     * real world coordinates equivalent to 3 pixels.

     * <li>Notifies all {@link ViewPortListener ViewPortListener} registered

     * that the extent has changed.

     * </ul>

     * </p>

     * 

     * @param r

     *            the new extent

     * 

     * @see #getExtent()

     * @see #getExtents()

     * @see #calculateAffineTransform()

     * @see #setPreviousExtent()

     */

    public void setEnvelope(Envelope r) {

        Rectangle2D newExtent = null;

        // Esto comprueba que el extent no es de anchura o altura = "0"

        // y si es as� lo redimensiona.

        if (r != null) {

            if ((r.getMaximum(0) - r.getMinimum(0) == 0)

                || (r.getMaximum(1) - r.getMinimum(1) == 0)) {

                newExtent =

                    new Rectangle2D.Double(r.getMinimum(0) - 0.1,

                        r.getMinimum(1) - 0.1,

                        r.getMaximum(0) - r.getMinimum(0) + 0.2,

                        r.getMaximum(1) - r.getMinimum(1) + 0.2);

            } else {

                newExtent =

                    new Rectangle2D.Double(r.getMinimum(0),

                        r.getMinimum(1),

                        Math.abs(r.getMaximum(0) - r.getMinimum(0)),

                        Math.abs(r.getMaximum(1) - r.getMinimum(1)));

            }

        }

        if (this.extent != null && this.extent.equals(newExtent)) {

            return;

        }

        if (extent != null) {

            extents.put(extent);

        }

        this.updateDrawVersion();

        this.extent = newExtent;