Application: gvSIG desktop » gvSIG raster

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

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

	<modelVersion>4.0.0</modelVersion>

	<artifactId>org.gvsig.raster.wms</artifactId>

	<packaging>pom</packaging>

	<version>2.2.19</version>

	<name>${project.artifactId}</name>

	<description>wms client</description>

	<inceptionYear>2011</inceptionYear>

	<parent>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.desktop</artifactId>

      <version>2.0.111</version>

  </parent>

        <properties>

            <!-- El plugin versions:use-latest-versions falla con scope import -->

            <!-- asi que toca usar el versions:update-properties que si que funciona -->

            <org.gvsig.raster.version>2.2.21</org.gvsig.raster.version>

        </properties>

    <repositories>

      <repository>

        <id>gvsig-public-http-repository</id>

        <name>gvSIG maven public HTTP repository</name>

        <url>http://devel.gvsig.org/m2repo/j2se</url>

        <releases>

          <enabled>true</enabled>

          <updatePolicy>daily</updatePolicy>

          <checksumPolicy>warn</checksumPolicy>

        </releases>

        <snapshots>

          <enabled>true</enabled>

          <updatePolicy>daily</updatePolicy>

          <checksumPolicy>warn</checksumPolicy>

        </snapshots>

      </repository>

    </repositories>

    <scm>

        <connection>scm:svn:https://devel.gvsig.org/svn/gvsig-raster/org.gvsig.raster.wms/tags/org.gvsig.raster.wms-2.2.19</connection>

        <developerConnection>scm:svn:https://devel.gvsig.org/svn/gvsig-raster/org.gvsig.raster.wms/tags/org.gvsig.raster.wms-2.2.19</developerConnection>

        <url>https://devel.gvsig.org/redmine/projects/gvsig-raster/repository/show/org.gvsig.raster.wms/tags/org.gvsig.raster.wms-2.2.19</url>

    </scm>

    <build>

        <plugins>

            <plugin>

                <groupId>org.apache.maven.plugins</groupId>

                <artifactId>maven-release-plugin</artifactId>

                <configuration>

                    <tagBase>https://devel.gvsig.org/svn/gvsig-raster/org.gvsig.raster.wms/tags/</tagBase>

                    <goals>deploy</goals>

                </configuration>

            </plugin>

        </plugins>

    </build>

    <dependencyManagement>

		<dependencies>

                        <dependency>

                                <groupId>org.gvsig</groupId>

                                <artifactId>org.gvsig.raster</artifactId>

                                <version>${org.gvsig.raster.version}</version>

                                <type>pom</type>

                                <scope>import</scope>

                        </dependency>

			<dependency>

				<groupId>org.gvsig</groupId>

				<artifactId>org.gvsig.raster.wms.io</artifactId>

				<version>2.2.19</version>

			</dependency>

			<dependency>

				<groupId>org.gvsig</groupId>

				<artifactId>org.gvsig.raster.wms.remoteclient</artifactId>

				<version>2.2.19</version>

			</dependency>

			<dependency>

				<groupId>org.gvsig</groupId>

				<artifactId>org.gvsig.raster.wms.app.wmsclient</artifactId>

				<version>2.2.19</version>

			</dependency>

		</dependencies>

	</dependencyManagement>

	<modules>

		<module>org.gvsig.raster.wms.remoteclient</module>

		<module>org.gvsig.raster.wms.io</module>

		<module>org.gvsig.raster.wms.app.wmsclient</module>

	</modules>

</project>

<assembly>

    <id>gvsig-plugin-package</id>

    <formats>

        <format>zip</format>

    </formats>

    <baseDirectory>${project.artifactId}</baseDirectory>

    <includeBaseDirectory>true</includeBaseDirectory>

    <files>

        <file>

            <source>target/${project.artifactId}-${project.version}.jar</source>

            <outputDirectory>lib</outputDirectory>

        </file>

        <file>

            <source>target/package.info</source>

        </file>

    </files>

    <fileSets>

        <fileSet>

            <directory>src/main/resources-plugin</directory>

            <outputDirectory>.</outputDirectory>

        </fileSet>

    </fileSets>

    <dependencySets>

        <dependencySet>

            <useProjectArtifact>false</useProjectArtifact>

            <useTransitiveDependencies>false</useTransitiveDependencies>

            <outputDirectory>lib</outputDirectory>

            <includes> 

                <include>org.gvsig:org.gvsig.raster.wms.remoteclient:jar</include>

                <include>org.gvsig:org.gvsig.raster.wms.io:jar</include>

            </includes>

        </dependencySet>

    </dependencySets>

</assembly>

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

 *

 */

package org.gvsig.raster.wms.app.wmsclient.layer;

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynObjectManager;

import org.gvsig.tools.dynobject.DynObjectSet;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.Observer;

import org.gvsig.tools.observer.impl.BaseWeakReferencingObservable;

import org.gvsig.tools.visitor.Visitor;

/**

 * {@link DynObject} implementation to facade of a {@link FeatureSet} and allow

 * to be used as a {@link DynObjectSet}.

 * 

 * @author Nacho Brodin (nachobrodin@gmail.com)

 * @version $Id$

 */

public class DynObjectSetWMSInfo extends BaseWeakReferencingObservable

    implements DynObjectSet, Observer {

	//public static final int             TYPE_TEXT = 0;

	//public static final int             TYPE_HTML = 1;

	//public static final int             TYPE_XML  = 2;

	private DynObjectIteratorWMSInfo    ite       = null;

	private DynObject                   dynObject = null;

	private String                      type      = "text/plain";

	public static void registerDynClass() {

		DynObjectManager manager = ToolsLocator.getDynObjectManager();

    	DynClass dynClass = manager.add("WMSInfoByPoint", "WMS InfoByPoint");

    	dynClass.setNamespace("InfoByPoint");

    	dynClass.addDynFieldString("info");

	}

    /**

     * Creates a new facade over a given info, with fast dynobject

     * iteration.

     */

    public DynObjectSetWMSInfo(String txt, String type) {

    	DynObjectManager manager = ToolsLocator.getDynObjectManager();

    	dynObject = manager.createDynObject("WMSInfoByPoint");

    	dynObject.setDynValue("info", txt);

    	ite = new DynObjectIteratorWMSInfo(dynObject);

    	this.type = type;

    	/*if(type == TYPE_HTML)

    		this.type = "text/html";

    	if(type == TYPE_XML)

    		this.type = "text/xml";

    	if(type == TYPE_TEXT)

    		this.type = "text/plain";*/

    }

    public String getTypeInfo() {

    	return this.type;

    }

    public String getInfoElement() {

    	return (String)dynObject.getDynValue("info");

    }

    public void dispose() {

    }

    public void accept(final Visitor visitor, long firstValueIndex) throws BaseException {

    	while(ite.hasNext()) {

    		visitor.visit(ite.next());

    	}

    }

    public void accept(final Visitor visitor) throws BaseException {

    	while(ite.hasNext()) {

    		visitor.visit(ite.next());

    	}

    }

    public long getSize() throws BaseException {

       return ite.getSize();

    }

    public DisposableIterator iterator(long index) throws BaseException {

        return iterator();

    }

    public DisposableIterator iterator() throws BaseException {

    	return ite;

    }

    public boolean isEmpty() throws BaseException {

    	return (getSize() == 0);

    }

    public boolean isDeleteEnabled() {

    	return true;

    }

    public void delete(DynObject dynObject) throws BaseException {

    }

    public boolean isUpdateEnabled() {

    	return true;

    }

    public void update(DynObject dynObject) throws BaseException {

    	System.out.println();

    }

    public void update(Observable observable, Object notification) {

    	System.out.println();

    }

}

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

* 

*/

package org.gvsig.raster.wms.app.wmsclient.layer;

import java.awt.Dimension;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.Point;

import java.awt.Rectangle;

import java.awt.geom.AffineTransform;

import java.awt.geom.NoninvertibleTransformException;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import java.lang.ref.WeakReference;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Vector;

import java.util.prefs.Preferences;

import javax.print.attribute.PrintRequestAttributeSet;

import javax.swing.JOptionPane;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.gvsig.andami.PluginServices;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataParameters;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.coverage.RasterLocator;

import org.gvsig.fmap.dal.coverage.RasterManager;

import org.gvsig.fmap.dal.coverage.datastruct.Extent;

import org.gvsig.fmap.dal.coverage.datastruct.ViewPortData;

import org.gvsig.fmap.dal.coverage.exception.FilePaletteException;

import org.gvsig.fmap.dal.coverage.exception.InfoByPointException;

import org.gvsig.fmap.dal.coverage.exception.ProcessInterruptedException;

import org.gvsig.fmap.dal.coverage.exception.QueryException;

import org.gvsig.fmap.dal.coverage.exception.RasterDriverException;

import org.gvsig.fmap.dal.coverage.grid.RasterFilter;

import org.gvsig.fmap.dal.coverage.store.RasterDataStore;

import org.gvsig.fmap.dal.coverage.store.parameter.RasterDataParameters;

import org.gvsig.fmap.dal.coverage.store.parameter.RemoteStoreParameters;

import org.gvsig.fmap.dal.coverage.store.parameter.TileDataParameters;

import org.gvsig.fmap.dal.coverage.store.props.ColorInterpretation;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.exception.InitializeException;

import org.gvsig.fmap.dal.exception.ProviderNotRegisteredException;

import org.gvsig.fmap.dal.exception.ReadException;

import org.gvsig.fmap.dal.exception.ValidateDataParametersException;

import org.gvsig.fmap.dal.spi.DataManagerProviderServices;

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

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

import org.gvsig.fmap.mapcontext.ViewPort;

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

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

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

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

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

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

import org.gvsig.gui.beans.Messages;

import org.gvsig.raster.fmap.layers.DefaultFLyrRaster;

import org.gvsig.raster.fmap.layers.IRasterLayerActions;

import org.gvsig.raster.fmap.layers.NotAvailableStateException;

import org.gvsig.raster.fmap.legend.ImageLegend;

import org.gvsig.raster.util.CancelTaskImpl;

import org.gvsig.raster.wms.app.wmsclient.wmc.WebMapContextTags;

import org.gvsig.raster.wms.app.wmsclient.wmc.XmlBuilder;

import org.gvsig.raster.wms.io.RemoteWMSStyle;

import org.gvsig.raster.wms.io.WMSDataParameters;

import org.gvsig.raster.wms.io.WMSLayerNode;

import org.gvsig.raster.wms.io.WMSServerExplorer;

import org.gvsig.raster.wms.io.WMSServerExplorerParameters;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynObjectSet;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.task.Cancellable;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.task.TaskStatusManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * FMap's WMS Layer class.

 *

 * Las capas WMS son tileadas para descargarlas del servidor. Esto quiere decir que

 * est?n formadas por multiples ficheros raster. Por esto la fuente de datos raster (IRasterDatasource)

 * de la capa FLyrWMS es un objeto de tipo CompositeDataset. Este objeto est? compuesto por un array

 * bidimensional de MultiRasterDataset. Cada uno de los MultiRasterDataset corresponde con un tile

 * salvado en disco. Estos MultiRasterDataset se crean cada vez que se repinta ya que en WMS a cada

 * zoom varian los ficheros fuente. La secuencia de creaci?n de un CompositeDataset ser?a la siguiente:

 * <UL>

 * <LI>Se hace una petici?n de dibujado por parte del usuario llamando al m?todo draw de FLyrWMS</LI>

 * <LI>Se tilea la petici?n</LI>

 * <LI>Cada tile se dibuja abriendo una FLyerRaster para ese tile</LI>

 * <LI>Si es el primer dibujado se guarda una referencia en la capa WMS a las propiedades de renderizado, orden de bandas,

 * transparencia, filtros aplicados, ...</LI>

 * <LI>Si no es el primer dibujado se asignan las propiedades de renderizado cuya referencia se guarda en la capa WMS</LI>

 * <LI>Se guarda el MultiRasterDataset de cada tile</LI>

 * <LI>Al acabar todos los tiles creamos un CompositeDataset con los MultiRasterDataset de todos los tiles</LI>

 * <LI>Asignamos a la capa la referencia de las propiedades de renderizado que tenemos almacenadas. De esta forma si hay

 * alguna modificaci?n desde el cuadro de propiedades ser? efectiva sobre los tiles que se dibujan.</LI>

 * </UL>

 *

 *

 * @author Jaume Dominguez Faus

 *

 */

@SuppressWarnings("deprecation")

public class FLyrWMS extends DefaultFLyrRaster {

	public static final String           PERSISTENT_NAME           = "FLyrWMS_Persistent";

	public static final String           PERSISTENT_DESCRIPTION    = "FLyrWMS Persistent Definition";

	private static final GeometryManager geomManager               = GeometryLocator.getGeometryManager();

	private static final Logger          logger                    = LoggerFactory.getLogger(FLyrWMS.class);

	private boolean 					 mustSplitRequest          = false;

	private final int 					 maxTileDrawWidth          = 1023;

	private final int 					 maxTileDrawHeight         = 1023;

	private final int 					 maxTilePrintWidth         = 1023;

	private final int 					 maxTilePrintHeight        = 1023;

	private List<WeakReference<Thread>>	 disableUpdateDrawVersion;

	//private Envelope					 fullEnvelope              = null;

	private boolean						 firstLoad                 = false;

	private RasterManager                rManager                  = RasterLocator.getManager();

	//private WMSServerExplorer            explorer                  = null;

	private boolean                      deleteCache               = false;

	public FLyrWMS() {

		super();

		this.updateDrawVersion();

		try {

			enableAwake();

		} catch (NotAvailableStateException e) {

			logger.error("Fallo el estado de open. Closed=" + isClosed() + " Awake=" + isAwake(), this, e);

		}

	}

   public FLyrWMS(DataStoreParameters dataStoreParameters) throws Exception {

        this();

        //Create the explorer and connect

        DataManager dataManager = DALLocator.getDataManager();

        WMSServerExplorerParameters explorerParams = (WMSServerExplorerParameters) 

               dataManager.createServerExplorerParameters(WMSServerExplorer.NAME);

        explorerParams.setHost((String)dataStoreParameters.getDynValue("uri"));        

        WMSServerExplorer wmsServerExplorer = 

            (WMSServerExplorer) dataManager.openServerExplorer(WMSServerExplorer.NAME, explorerParams);

        wmsServerExplorer.connect(null, ((RemoteStoreParameters)dataStoreParameters).isDeletingCache());

        //Set the parameters

        setParameters((WMSDataParameters)dataStoreParameters);

        setExplorer(wmsServerExplorer);

    }

	public static DataStore createDataStore(String host, IProjection srs) throws InitializeException {

		DataManagerProviderServices dataman = (DataManagerProviderServices) DALLocator.getDataManager();

		RasterDataParameters params = null;

		try {

			params = (RasterDataParameters)dataman.createServerExplorerParameters(WMSServerExplorer.NAME);

		} catch (InitializeException e) {

			return null;

		} catch (ProviderNotRegisteredException e) {

			return null;

		}

		params.setURI(host);

		params.setSRS(srs);

		try {

			return dataman.openStore(params.getDataStoreName(), params);

		} catch (ValidateDataParametersException e) {

			throw new InitializeException(e);

		} catch (ProviderNotRegisteredException e) {

			throw new InitializeException(e);

		}

	}

	public void setDataStore(DataStore dataStore) throws LoadLayerException {

		this.dataStore = (RasterDataStore) dataStore;

		try {

			this.dataStore.isOpen();

			if(!isOpen())

				enableOpen();

		} catch (NotAvailableStateException e) {

			logger.error("Fallo el estado de open. Closed=" + isClosed() + " Awake=" + isAwake(), this, e);

		}

		setProjection(this.dataStore.getProjection());

	}

	/**

	 * It choose the best format to load different maps if the server

	 * supports it. This format could be png, because it supports

	 * transparency.

	 * @param formats

	 * Arraywith all the formats supported by the server

	 * @return

	 */

	@SuppressWarnings("unused")

	private String getGreatFormat(Vector<String> formats){

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

			String format = (String) formats.get(i);

			if (format.equals("image/jpg")){

				return format;

			}

			if (format.equals("image/jpeg")){

				return format;

			}

		}

		return (String)formats.get(0);

	}

	public static void registerPersistent() {

		PersistenceManager manager = ToolsLocator.getPersistenceManager();

		DynStruct definition = manager.getDefinition("FLyrWMS_Persistent");

		if( definition == null ) {

			if (manager.getDefinition(DefaultFLyrRaster.class) == null) {

				DefaultFLyrRaster.registerPersistence();

			}

			definition = manager.addDefinition(

					FLyrWMS.class,

					"FLyrWMS_Persistent",

					"FLyrWMS Persistent Definition",

					null, 

					null

			);

			definition.extend(PersistenceManager.PERSISTENCE_NAMESPACE, DefaultFLyrRaster.PERSISTENT_NAME);

		}

		DefaultFLyrRaster.registerPersistence(definition);

	}

	public void draw(BufferedImage image, Graphics2D g, ViewPort viewPort,

			Cancellable cancel, double scale) throws ReadException {

		TaskStatusManager manager = ToolsLocator.getTaskStatusManager();

		SimpleTaskStatus taskStatus = new RasterTaskStatus("Drawing " + getName() + "...", cancel);

		manager.add(taskStatus);

		taskStatus.setAutoremove(true);

		splitRequestCalculation(viewPort.getImageWidth(), viewPort.getImageHeight());

		if(!firstLoad) {

			try {

				initFilters();

				try {

					if(!isOpen())

						enableOpen();

				} catch (NotAvailableStateException e) {

					throw new ReadException("Fallo el estado de open. Closed=" + isClosed() + " Awake=" + isAwake(), e);

				}

			} catch (FilePaletteException e) {

				logger.error(e.getMessage(), this, e);

			}

			firstLoad = true;

		}

		enableStopped();

		if(recalcLevel) {

			double pixelSize = viewPort.getEnvelope().getLength(0) / (double)viewPort.getImageWidth();

			zoomLevel = dataStore.getNearestLevel(pixelSize);

		}

		recalcLevel = true;

		if (isWithinScale(scale)) {

			if(mustSplitRequest) {

				Point2D p = viewPort.getOffset();

				Rectangle r = new Rectangle((int) p.getX(), (int) p.getY(), viewPort.getImageWidth(), viewPort.getImageHeight());

				Tiling tiles = new Tiling(maxTileDrawWidth, maxTileDrawHeight, r);

				tiles.setAffineTransform((AffineTransform) viewPort.getAffineTransform().clone());

				for (int tileNr = 0; tileNr < tiles.getNumTiles(); tileNr++) {

					// drawing part

					try {

						ViewPort vp = tiles.getTileViewPort(viewPort, tileNr);

						drawTile(g, vp, taskStatus, scale);

					} catch (LoadLayerException e) {

						throw new ReadException(e.getMessage(), e);

					} catch (NoninvertibleTransformException e) {

						throw new ReadException(e.getMessage(), e);

					}

				}

			} else {

				try {

					drawTile(g, viewPort, taskStatus, scale);

				} catch (LoadLayerException e) {

					setAvailable(false);

					logger.error("Server error:" + e.getMessage(), e);

				}

			}

		}

		disableStopped();

	}

	/**

	 * This is the method used to draw a tile in a WMS mosaic layer.

	 * @throws LoadLayerException

	 * @throws ReadDriverException

	 * @return true when a tile has been painted

	 */

	private void drawTile(Graphics2D g, ViewPort vp, SimpleTaskStatus taskStatus, double scale) throws LoadLayerException, ReadException {

		// Compute the query geometry

		// 1. Check if it is within borders

		Envelope layerEnv = getFullEnvelope();

		Envelope vpEnv = vp.getAdjustedEnvelope();

		if (!vpEnv.intersects(layerEnv)) {

			return;

		}

		try {

			Rectangle2D vpRect = getRectable2DFromEnvelope(vpEnv);

			Rectangle2D layerRect = getRectable2DFromEnvelope(layerEnv);

			// 2. Intersect layer and viewport extents to get the area of interest

			Rectangle2D requestedRect = new Rectangle2D.Double(); 

			Rectangle2D.intersect(layerRect, vpRect, requestedRect);

			// 3. Compute image size in pixels from the requested Extent

			double scalex = vp.getAffineTransform().getScaleX();

			double scaley = vp.getAffineTransform().getScaleY();

			int wImg = (int) Math.ceil(Math.abs(requestedRect.getWidth() * scalex));

			int hImg = (int) Math.ceil(Math.abs(requestedRect.getHeight() * scaley));

			if ((wImg <= 0) || (hImg <= 0)) {

				return;

			}

			// 4. compute exactly the requested extent (from the rounded image size)

			// ensuring we are still within the layer extent

			double worldWidth = Math.abs((double)wImg/scalex);

			double worldHeigh = Math.abs((double)hImg/scaley);

			double worldX;

			if (requestedRect.getX()+worldWidth>layerEnv.getMaximum(0)) {

				// we've got outside of layer extent due to rounding

				worldX = layerEnv.getMaximum(0)-worldWidth;

			}

			else {

				worldX = requestedRect.getX();

			}

			double worldY;

			if (requestedRect.getY()+worldHeigh>layerEnv.getMaximum(1)) {  // FIXME: test with different CRSs

				worldY = layerEnv.getMaximum(1)-worldHeigh;

			}

			else {

				worldY = requestedRect.getMinY();

			}

			requestedRect.setRect(worldX, worldY, worldWidth, worldHeigh); 

			Envelope requestedEnvelope = geomManager.createEnvelope(requestedRect.getMinX(),

					requestedRect.getMinY(),

					requestedRect.getMaxX(),

					requestedRect.getMaxY(),

					SUBTYPES.GEOM2D);

			Extent requestedExtent = rManager.getDataStructFactory().createExtent(

					requestedEnvelope.getMinimum(0), 

					requestedEnvelope.getMaximum(1), 

					requestedEnvelope.getMaximum(0), 

					requestedEnvelope.getMinimum(1));

			// 5. compute the new AffineTransform (ViewPort class can do it for us

			// if we provide the image size, extent and offset)

			ViewPort auxVp = (ViewPort) vp.clone();

			Dimension sz = new Dimension(wImg, hImg);

			auxVp.setImageSize(sz);

			auxVp.setEnvelope(requestedEnvelope);

			// 6. compute tile offeset. It is the sum of the original viewport offset

			// plus the offset introduced by intersecting layer and viewport extents

			double offsetX = vp.getOffset().getX();

			if (requestedEnvelope.getMinimum(0)-vpEnv.getMinimum(0)>0) {

				offsetX = offsetX + (requestedEnvelope.getMinimum(0)-vpEnv.getMinimum(0))*auxVp.getAffineTransform().getScaleX();

			}

			double offsetY = vp.getOffset().getY(); // FIXME: test with different CRSs

			if (requestedEnvelope.getMaximum(1)-vpEnv.getMaximum(1)<0) {

				offsetY = offsetY + (requestedEnvelope.getMaximum(1)-vpEnv.getMaximum(1))*auxVp.getAffineTransform().getScaleY();

			}

			// 7. Compute again the AffineTransform considering also the offset

			auxVp.setOffset(new Point2D.Double(offsetX, offsetY));

			auxVp.refreshExtent(); // necessary after updating the offset

			ViewPortData vpData = rManager.getDataStructFactory().createViewPortData(auxVp.getProjection(), requestedExtent, sz);

			vpData.setMat(auxVp.getAffineTransform());

			vpData.setDPI((int)auxVp.getDPI());

			getParameters().setExtent(requestedRect);

			if(getParameters().isSizeFixed()) {

				getParameters().setWidth((int)getParameters().getFixedSize().getWidth());

				getParameters().setHeight((int)getParameters().getFixedSize().getHeight());

			} else {

				getParameters().setWidth(wImg);

				getParameters().setHeight(hImg);

			}

			if(getDataStore().getParameters() instanceof WMSDataParameters) {

				getRender().draw(g, vpData, taskStatus);

			} else {

				Extent vpExtent = rManager.getDataStructFactory().createExtent(

						vpEnv.getMinimum(0),

						vpEnv.getMaximum(1),

						vpEnv.getMaximum(0),

						vpEnv.getMinimum(1));

				ViewPortData vp2 = rManager.getDataStructFactory().createViewPortData(vp.getProjection(), vpExtent, vp.getImageSize() );

				vp2.setMat(vp.getAffineTransform());

				vp2.setDPI((int)vp.getDPI());

				getParameters().setExtent(vpExtent.toRectangle2D());

				getRender().drawTiledService(g, vp2, vp.getImageSize(), taskStatus);

			}

		} catch (ProcessInterruptedException e) {

		} catch (CloneNotSupportedException e) {

			drawingError(e);

		}

		catch (QueryException e) {

			drawingError(e);

		} catch (CreateEnvelopeException e) {

			drawingError(e);

		} finally {

			taskStatus.terminate();				

		}

	}

	private void drawingError(Exception e) {

		setAvailable(false);

		JOptionPane.showMessageDialog(null, "Problems drawing this layer:" + e.getMessage(), Messages.getText("Error"), JOptionPane.ERROR_MESSAGE);

		logger.info("Problems drawing this layer:" + e.getMessage(), e);

	}	

	/**

	 * @see com.iver.cit.gvsig.fmap.layers.FLayer#print(java.awt.Graphics2D,

	 * 		com.iver.cit.gvsig.fmap.ViewPort,

	 * 		com.iver.cit.gvsig.fmap.operations.Cancellable)

	 */

	public void print(Graphics2D g, ViewPort viewPort, Cancellable cancel, double scale, PrintRequestAttributeSet properties)

	throws ReadException {

		TaskStatusManager manager = ToolsLocator.getTaskStatusManager();

		SimpleTaskStatus taskStatus = new RasterTaskStatus("Printing " + getName() + "...", cancel);

		manager.add(taskStatus);

		taskStatus.setAutoremove(true);

		splitRequestCalculation(viewPort.getImageWidth(), viewPort.getImageHeight());

		if (isVisible() && isWithinScale(scale)){

			if (!mustSplitRequest) {

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

			} else {

				Tiling tiles = new Tiling(maxTilePrintWidth, maxTilePrintHeight, g.getClipBounds());

				tiles.setAffineTransform((AffineTransform) viewPort.getAffineTransform().clone());

				for (int tileNr = 0; tileNr < tiles.getNumTiles(); tileNr++) {

					// Parte que dibuja

					try {

						ViewPort vp = tiles.getTileViewPort(viewPort, tileNr);

						drawTile(g, vp, taskStatus, scale);

					} catch (NoninvertibleTransformException e) {

						throw new ReadException(e.getMessage(), e);

					} catch (LoadLayerException e) {

						throw new ReadException(e.getMessage(), e);

					}

				}

			}

		}

		taskStatus.terminate();

	}

	public void _print(Graphics2D g, ViewPort viewPort, Cancellable cancel,

			double scale) throws ReadException {

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

	}

	public HashMap<String, Object> getProperties() {

		HashMap<String, Object> info = new HashMap<String, Object>();

		String[] layerNames = getParameters().getLayerQuery().split(",");

		Vector<WMSLayerNode> layers = new Vector<WMSLayerNode>(layerNames.length);

		try {

			//explorer.connect(null);

			for (int i = 0; i < layerNames.length; i++) {

				layers.add(i, getExplorer().getLayer(layerNames[i]));

			}

			info.put("name", getName());

			info.put("selectedLayers", layers);

			info.put("host", getParameters().getURI());

			info.put("srs", getParameters().getSRSCode());

			info.put("format", getParameters().getFormat());

			info.put("infoformat", getParameters().getInfoFormat());

			info.put("wmsTransparency", new Boolean(getParameters().isWmsTransparent()));

			info.put("styles", getParameters().getStyles());

			info.put("dimensions", getParameters().getDimensions());

			info.put("fixedSize", getParameters().getFixedSize());

			return info;

		} catch (Exception e) {

			e.printStackTrace();

		}

		return null;

	}

	/**

	 * Creates the part of a OGC's MapContext document that would describe this

	 * layer(s).

	 * @param version, The desired version of the resulting document. (1.1.0)

	 * @return String containing the xml.

	 * @throws UnsupportedVersionLayerException

	 */

	@SuppressWarnings({ "unchecked", "rawtypes" })

	public String toMapContext(String mapContextVersion) {

		XmlBuilder xml = new XmlBuilder();

		String query = getParameters().getLayerQuery();

		String[] layerNames = query.split(",");

		List<RemoteWMSStyle> styleList = getParameters().getStyles();

		for (int i = 0; i < layerNames.length; i++) {

			WMSLayerNode layer = getExplorer().getLayer(layerNames[i]);

			HashMap xmlAttrs = new HashMap();

			// <Layer>

			xmlAttrs.put(WebMapContextTags.HIDDEN, !isVisible() + "");

			xmlAttrs.put(WebMapContextTags.QUERYABLE, getExplorer().isQueryable() + "");

			xml.openTag(WebMapContextTags.LAYER, xmlAttrs);

			xmlAttrs.clear();

			if (mapContextVersion.equals("1.1.0") || mapContextVersion.equals("1.0.0")) {

				// <Server>

				xmlAttrs.put(WebMapContextTags.SERVICE, WebMapContextTags.WMS);

				xmlAttrs.put(WebMapContextTags.VERSION, getExplorer().getVersion());

				xmlAttrs.put(WebMapContextTags.SERVER_TITLE, getExplorer().getServiceTitle());

				xml.openTag(WebMapContextTags.SERVER, xmlAttrs);

				xmlAttrs.clear();

				// <OnlineResource>

				xmlAttrs.put(WebMapContextTags.XLINK_TYPE, "simple");

				xmlAttrs.put(WebMapContextTags.XLINK_HREF, getParameters().getURI().toString());

				xml.writeTag(WebMapContextTags.ONLINE_RESOURCE, xmlAttrs);

				xmlAttrs.clear();

				// </OnlineResource>

				xml.closeTag();

				// </Server>

				// <Name>

				xml.writeTag(WebMapContextTags.NAME, layer.getName().trim());

				// </Name>

				// <Title>

				xml.writeTag(WebMapContextTags.TITLE, layer.getTitle().trim());

				//?xml.writeTag(WebMapContextTags.TITLE, getName().trim());

				// </Title>

				// <Abstract>

				if (layer.getAbstract() != null) {

					xml.writeTag(WebMapContextTags.ABSTRACT, layer.getAbstract());

					// </Abstract>

				}

				// <SRS> (a list of available SRS for the enclosing layer)

				String[] strings = (String[]) layer.getAllSrs().toArray(new String[0]);

				String mySRS = strings[0];

				for (int j = 1; j < strings.length; j++) {

					mySRS += ","+strings[j];

				}

				xml.writeTag(WebMapContextTags.SRS, mySRS);

				// </SRS>

				// <FormatList>

				xml.openTag(WebMapContextTags.FORMAT_LIST);

				strings = getExplorer().getFormats();

				for (int j = 0; j < strings.length; j++) {

					// <Format>

					String str = strings[j].trim();

					if (str.equals(getParameters().getFormat())) {

						xml.writeTag(WebMapContextTags.FORMAT, str, WebMapContextTags.CURRENT, "1");

					} else {

						xml.writeTag(WebMapContextTags.FORMAT, str);

						// </Format>

					}

				}

				xml.closeTag();

				// </FormatList>

				// <StyleList>

				xml.openTag(WebMapContextTags.STYLE_LIST);

				if (layer.getStyles().size() > 0) {

					for (int j = 0; j < layer.getStyles().size(); j++) {

						// <Style>

						RemoteWMSStyle st = layer.getStyles().get(j);

						if (st.getName().equals(styleList.get(i).getName())) {

							xmlAttrs.put(WebMapContextTags.CURRENT, "1");

						}

						xml.openTag(WebMapContextTags.STYLE, xmlAttrs);

						xmlAttrs.clear();

						// <Name>

						xml.writeTag(WebMapContextTags.NAME, st.getName());

						// </Name>

						// <Title>

						xml.writeTag(WebMapContextTags.TITLE, st.getTitle());

						// </Title>

						// <LegendURL width="180" format="image/gif" height="50">

						// <OnlineResource xlink:type="simple" xlink:href="http://globe.digitalearth.gov/globe/en/icons/colorbars/NATIONAL.gif"/>

						// </OnlineResource>

						// </LegendURL>

						xml.closeTag();

						// </Style>

					}

				} else {

					// Create fake style (for compatibility issues)

					xmlAttrs.put(WebMapContextTags.CURRENT, "1");

					// <Style>

					xml.openTag(WebMapContextTags.STYLE, xmlAttrs);

					xmlAttrs.clear();

					// <Name>

					xml.writeTag(WebMapContextTags.NAME, "default");

					// </Name>

					// <Title>

					xml.writeTag(WebMapContextTags.TITLE, "default");

					xml.closeTag();

				}

				// </StyleList>

				xml.closeTag();

				if (mapContextVersion.compareTo("1.0.0") > 0) {

					// <DimensionList>

					xml.openTag(WebMapContextTags.DIMENSION_LIST);

					// <Dimension>

					// </Dimension>

					xml.closeTag();

					// </DimensionList>

				}

			} else {

				xml.writeTag("ERROR", PluginServices.getText(this, "unsupported_map_context_version"));

			}

			// </Layer>

			xml.closeTag();

		}

		return xml.getXML();

	}

	public String getTocImageIcon() {

		return "icon-layer-wms";

	}

	public int[] getTileSize() {

		int[] size = {maxTileDrawWidth, maxTileDrawHeight};

		return size;

	}

	public boolean isTiled() {

		return mustSplitRequest;

	}

	private void splitRequestCalculation(int width, int height) {

            RasterDataStore store = this.getDataStore();

            if( store == null ) {

                String msg = "Can't get RasterDataStore associated to this layer ("+this.toString()+").";

                logger.warn(msg);

                throw new RuntimeException(msg);

            }

            mustSplitRequest = (!store.isTiled() && (width > maxTileDrawWidth || height > maxTileDrawHeight));

	}

	public ComposedLayer newComposedLayer() {

		Preferences prefs = Preferences.userRoot().node("gvsig.wms");

		/*

		 * from java.util.prefs import Preferences

		 * prefs = Preferences.userRoot().node("gvsig.wms")

		 * prefs.put("useComposedLayer","true")

		 */

		String str = prefs.get("useComposedLayer","false");

		Boolean useComposedLayer = Boolean.TRUE; // por defecto ya se usan

		try {

			useComposedLayer = Boolean.valueOf(str);

		} catch (Exception e) {

		}

		if (useComposedLayer.booleanValue()) {

			return new ComposedLayerWMS();

		} else {

			return null;

		}

	}

	/*

	 * Checks if can make a single petition for the two layers to the server

	 * @see com.iver.cit.gvsig.fmap.layers.ComposedLayerWMS#canAdd(com.iver.cit.gvsig.fmap.layers.FLayer)

	 */

	boolean isComposedLayerCompatible(FLayer layer) {

		FLyrWMS aLayer;

		if (!(layer instanceof FLyrWMS)) {

			return false;

		}

		aLayer = (FLyrWMS)layer;

		if (!getParameters().getURI().equals(aLayer.getParameters().getURI())) {

			return false;

		}

		WMSDataParameters p = getWMSParameters(getDataStore().getParameters()); 

		if (!p.getFormat().equals(aLayer.getParameters().getFormat())) {

			return false;

		}

		if (!p.getSRS().equals(aLayer.getParameters().getSRS())) {

			return false;

		}

		if (p.getInfoLayerQuery() != null) {

			if (!p.getInfoLayerQuery().equals(aLayer.getParameters().getInfoLayerQuery())) {

				return false;

			}

		}else if (p.getInfoLayerQuery() != null) {

			return false;

		}

		// isFixedSize es privado

		if ((getParameters().getFixedSize() != null) &&

				(aLayer.getParameters().getFixedSize() != null)) {

			if (getParameters().getFixedSize().equals(aLayer.getParameters().getFixedSize())) {

				return false;

			}

		} else if ((getParameters().getFixedSize() != null) != (aLayer.getParameters().getFixedSize() != null)) {

			return false;

		}

		// time elevation (dimensions)

		if ((p.getDimensions() != null) &&

				(aLayer.getParameters().getDimensions() != null)) {

			if (p.getDimensions().size() != aLayer.getParameters().getDimensions().size()) {

				return false;

			} else {

				Iterator<String> iter = p.getDimensions().iterator();

				while (iter.hasNext()) {

					if (!aLayer.getParameters().getDimensions().contains(iter.next())) {

						return false;

					}

				}

			}

		} else if ((p.getDimensions() != null) != (aLayer.getParameters().getDimensions() != null)) {

			return false;

		}

		return true;

	}

	public boolean isActionEnabled(int action) {

		switch (action) {

		case IRasterLayerActions.ZOOM_PIXEL_RESOLUTION:

		case IRasterLayerActions.FLYRASTER_BAR_TOOLS:

		case IRasterLayerActions.BANDS_FILE_LIST:

		case IRasterLayerActions.COLOR_TABLE:

		case IRasterLayerActions.GEOLOCATION:

		case IRasterLayerActions.PANSHARPENING:

		case IRasterLayerActions.SAVE_COLORINTERP:

		case IRasterLayerActions.SAVEAS:

		case IRasterLayerActions.BANDS_RGB:

		case IRasterLayerActions.ENHANCED:

		case IRasterLayerActions.STATS:

		case IRasterLayerActions.NODATA:

			return false;

		case IRasterLayerActions.REMOTE_ACTIONS:

			return true;

		}

		return super.isActionEnabled(action);

	}

	public ILegend getLegend() {

		if(getDataStore() != null) {

			Image img = getDataStore().getImageLegend();

			if(img != null)

				return new ImageLegend(img);

		}

		return null;

	}

	public boolean isRemote() {

		return true;

	}

	public boolean overviewsSupport() {

		return false;

	}

	protected void updateDrawVersion() {

		if (this.disableUpdateDrawVersion != null){

			Thread curThread = Thread.currentThread();

			Thread aThread;

			Iterator<WeakReference<Thread>> iter = this.disableUpdateDrawVersion.iterator();

			while (iter.hasNext()){

				aThread = (Thread) ((WeakReference<?>)iter.next()).get();

				if (aThread == null){

					iter.remove();

				} else if(aThread.equals(curThread)){

					return;

				}

			}

		}

		//		Exception ex = new Exception();

		//		ex.printStackTrace();

		super.updateDrawVersion();

	}

	protected void disableUpdateDrawVersion() {

		if (this.disableUpdateDrawVersion == null) {

			this.disableUpdateDrawVersion = new ArrayList<WeakReference<Thread>>();

		}

		this.disableUpdateDrawVersion.add(new WeakReference<Thread>(Thread.currentThread()));

	}

	protected void enableUpdateDrawVersion() {

		if (this.disableUpdateDrawVersion == null){

			return;

		}

		Thread curThread = Thread.currentThread();

		Thread aThread;

		Iterator<WeakReference<Thread>> iter = this.disableUpdateDrawVersion.iterator();

		while (iter.hasNext()) {

			aThread = (Thread) ((WeakReference<?>)iter.next()).get();

			if (aThread == null) {

				iter.remove();

			} else if(aThread.equals(curThread)) {

				iter.remove();

				break;

			}

		}

	}

	private Rectangle2D.Double getRectable2DFromEnvelope(Envelope env) {

		return new Rectangle2D.Double(env.getMinimum(0), env.getMinimum(1), env

				.getLength(0), env.getLength(1));

	}

	/*private Envelope getEnvelopeFromRectable2D(Rectangle2D rect) {

		try {

			return geomManager.createEnvelope(rect.getMinX(), rect.getMinY(),

					rect.getMaxX(), rect.getMaxY(),

					SUBTYPES.GEOM2D);

		} catch (CreateEnvelopeException e) {

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

		}

		return null;

	}*/

	@Override

	public String getFileFormat() {

		return "WMS";

	}

	@Override

	public FLayer getFileLayer() throws RasterDriverException {

		/*if(getDataStore() instanceof DefaultRemoteRasterStore) {

			RemoteRasterProvider prov = (RemoteRasterProvider)((DefaultRemoteRasterStore)getDataStore()).getProvider(0);

			File file = null;

			if(getParameters().isSizeFixed()) {

				file = prov.getFileLayer();

			} else {

				file = prov.getLastRequest();

			}

			if(file == null)

				return null;

			try {

				return DefaultFLyrRaster.createLayer("tmp", file);

			} catch (LoadLayerException e) {

				throw new RasterDriverException(e.getMessage(), e);

			}

		}*/

		return null;

	}

	/**

	 * Devuelve el envelope en la proyeccion de la vista

	 */

	public Envelope getFullEnvelope() {

		Extent e1 = getDataStore().getExtent();

		Envelope rAux = null;

		try {

			rAux = geomManager.createEnvelope(e1.getMin().getX(), e1.getMin().getY(), e1.getMax().getX(), e1.getMax().getY(), SUBTYPES.GEOM2D);

		} catch (CreateEnvelopeException exc) {

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

		}

		// Esto es para cuando se crea una capa nueva con el fullExtent de ancho

		// y alto 0.

		if (rAux == null || rAux.getMaximum(0) - rAux.getMinimum(0) == 0

				&& rAux.getMaximum(1) - rAux.getMinimum(1) == 0) {

			try {

				rAux = geomManager.createEnvelope(0, 0, 100, 100, SUBTYPES.GEOM2D);

			} catch (CreateEnvelopeException e) {

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

			}

		}

		// Si existe reproyecci?n, reproyectar el extent

		ICoordTrans ct = getCoordTrans();

		if (ct != null) {

			Point2D pt1 = new Point2D.Double(rAux.getMinimum(0), rAux

					.getMinimum(1));

			Point2D pt2 = new Point2D.Double(rAux.getMaximum(0), rAux

					.getMaximum(1));

			pt1 = ct.convert(pt1, null);

			pt2 = ct.convert(pt2, null);

			try {

				rAux = geomManager.createEnvelope(pt1.getX(), pt1.getY(), pt2

						.getX(), pt2.getY(), SUBTYPES.GEOM2D);

			} catch (CreateEnvelopeException e) {

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

			}// new

			// Rectangle2D.Double();

		}

		return rAux;

	}

	public Extent getFullRasterExtent() {

		return getExtentFromEnvelope(getFullEnvelope());

	}

	public DynObjectSet getInfo(org.gvsig.fmap.geom.primitive.Point p, double tolerance) throws LoadLayerException, DataException {

		Point p1 = new Point((int)p.getX(), (int)p.getY());

		return getInfo(p1, tolerance, null, false);

	}

	@Override

	public DynObjectSet getInfo(Point p, double tolerance, Cancellable cancel,

			boolean fast) throws LoadLayerException, DataException {

		//try {

		ViewPort viewPort = getMapContext().getViewPort();

		getParameters().setExtent(this.getRectable2DFromEnvelope(viewPort.getAdjustedEnvelope()));

		if(getParameters().isSizeFixed()) {

			getParameters().setWidth((int)getParameters().getFixedSize().getWidth());

			getParameters().setHeight((int)getParameters().getFixedSize().getHeight());

		} else {

			getParameters().setWidth(viewPort.getImageWidth());

			getParameters().setHeight(viewPort.getImageHeight());

		}

		CancelTaskImpl cancellable = new CancelTaskImpl(cancel);

		getParameters().setCancellable(cancellable);

		String fInfo;

		try {

			//Point2D pt = new Point2D.Double();

			//try {

				//viewPort.getAffineTransform().transform(p, pt);

			/*} catch (NoninvertibleTransformException e) {

				return null;

			}*/

			Extent bbox = getExtentFromEnvelope(viewPort.getAdjustedEnvelope());

			fInfo = getDataStore().getInfoByPoint(p.getX(), 

					p.getY(), 

					bbox, 

					viewPort.getImageWidth(), 

					viewPort.getImageHeight(), 

					cancellable);

		} catch (InfoByPointException e) {

			throw new LoadLayerException("Error in getInfoByPoint", e);

		}

		return new DynObjectSetWMSInfo(fInfo, getParameters().getInfoFormat());

	}

	private Extent getExtentFromEnvelope(Envelope env) {

		double minx = env.getMinimum(0);

		double miny = env.getMinimum(1);

		double maxx = env.getMaximum(0);

		double maxy = env.getMaximum(1);

		Point2D ul = new Point2D.Double(minx, maxy);

		Point2D ur = new Point2D.Double(maxx, maxy);

		Point2D ll = new Point2D.Double(minx, miny);

		Point2D lr = new Point2D.Double(maxx, miny);

		return rManager.getDataStructFactory().createExtent(ul, lr, ur, ll);

	}

    /**

     * Sets the data store parameters

     * @param params

     * @throws InitializeException

     */

    public void setParameters(DataStoreParameters params) throws InitializeException {

    	if(params instanceof TileDataParameters) {

			((TileDataParameters)params).deleteCache(deleteCache);

		}

    	DataManagerProviderServices dataman = (DataManagerProviderServices) DALLocator.getDataManager();

		try {

			DataStore dStore = dataman.openStore(params.getDataStoreName(), params);

			this.setDataStore(dStore);

			if(params instanceof WMSDataParameters) {

				this.setName(((WMSDataParameters)params).getURI());

			}

			if(params instanceof TileDataParameters) {

				DataParameters p = ((TileDataParameters) params).getDataParameters();

				if(p instanceof WMSDataParameters) {

					this.setName(((WMSDataParameters) p).getURI());

				}

			}

		} catch (ValidateDataParametersException e) {

			throw new InitializeException(e);

		} catch (ProviderNotRegisteredException e) {

			throw new InitializeException(e);

		} catch (LoadLayerException e) {

			throw new InitializeException(e);

		}

    }

	public WMSDataParameters getParameters() {

		return getWMSParameters(getDataStore().getParameters());

    }

    /**

     * Gets <code>WMSDataParameters</code>

     * @param parameters

     * @return

     */

    private WMSDataParameters getWMSParameters(DataStoreParameters parameters) {

    	WMSDataParameters params = null;

    	if(parameters instanceof WMSDataParameters) {

			params = (WMSDataParameters) parameters;

		}

		if(parameters instanceof TileDataParameters) {

			DataParameters p = ((TileDataParameters) parameters).getDataParameters();

			if(p instanceof WMSDataParameters) {

				params = (WMSDataParameters) p;

			}

		}

		return params;

    }

    /**

	 * Assigns the flag to delete this layer from the cache

	 * @param selected

	 */

	public void deleteCache(boolean deleteCache) {

		this.deleteCache = deleteCache;

	}

    /**

     * Sets the explorer

     * @param explorer

     */

    public void setExplorer(WMSServerExplorer explorer) {

    	if(getDataStore() != null)

    		getDataStore().setExplorer(explorer);

    }

    /**

     * Gets the explorer

     * @return

     */

    public WMSServerExplorer getExplorer() {

    	try {

			return (WMSServerExplorer)getDataStore().getExplorer();

		} catch (ValidateDataParametersException e) {

			logger.debug("Error getting the explorer", e);

		} catch (DataException e) {

			logger.debug("Error getting the explorer", e);

		}

    	return null;

    }

	public FLayer cloneLayer() throws Exception {

		RasterDataStore  ds = dataStore.cloneDataStore();

		FLyrWMS newLayer = new FLyrWMS();

		newLayer.setName(getName());

		newLayer.setOpenRasterStore(ds);

		//newLayer.firstLoad = firstLoad;

		newLayer.setExplorer(getExplorer());

		List<RasterFilter> filters = getRender().getFilterList().getStatusCloned();

		//Hacemos una copia de las bandas a renderizar

		ColorInterpretation ci = getRender().getRenderColorInterpretation();

		if(ci != null) {

			newLayer.getRender().setRenderColorInterpretation(ci.cloneColorInterpretation());

		}

		//Asignamos el entorno

		if(newLayer.getRender().getFilterList() == null)

			newLayer.getRender().setFilterList(RasterLocator.getManager().createEmptyFilterList(getRender().getFilterList().getInitDataType()));

		newLayer.getRender().getFilterList().setEnv(getRender().getFilterList().getEnv());

		newLayer.getRender().getFilterList().setStatus(filters);

		// Asignamos los valores noData del original

		newLayer.setNoDataValue(getNoDataValue());

		if(dataStore.getNoDataValue().isDefined())

			newLayer.setNoDataTransparent(true);

		newLayer.enableOpen();

		return newLayer;

	}

	@Override

	public boolean isInside(Point2D p) {

		// Don't call the data store isInside method, as the data store

		// parameters change for every WMS tile that is drawn, so it does not

		// return sensible results.

		return rManager.getRasterUtils().isInside(p, getDataStore().getExtent());

	}

}

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

 *

 */

package org.gvsig.raster.wms.app.wmsclient.layer;

import java.awt.Graphics2D;

import java.awt.image.BufferedImage;

import java.util.List;

import org.gvsig.compat.print.PrintAttributes;

import org.gvsig.fmap.dal.exception.ReadException;

import org.gvsig.fmap.mapcontext.ViewPort;

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

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

import org.gvsig.raster.wms.io.RemoteWMSStyle;

import org.gvsig.tools.task.Cancellable;

/**

 * Group WMS layers to make a single request to the

 * server for all layers.

 *

 * It is posible only if almost all params are the same. For this

 * comparasion, ComposedLayerWMS uses the method

 * {@link org.gvsig.wms.fmap.layers.FLyrWMS#isComposedLayerCompatible(com.iver.cit.gvsig.fmap.layers.FLayer)}

 *