Application: gvSIG desktop » gvSIG raster

	<parent>

      <groupId>org.gvsig</groupId>

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

  </parent>

        <properties>

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

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

        </properties>

    <repositories>

*

* 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

* MA  02110-1301, USA.

*/

package org.gvsig.raster.wms.app.wmsclient.gui.panel;

import java.awt.Component;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.lang.reflect.InvocationTargetException;

import java.util.AbstractCollection;

import java.util.ArrayList;

import java.util.Hashtable;

		this.setBounds(0, 0, 510, 427);

		this.add(getJTabbedPane(), null);

	}

	public boolean isUpdatingCache() {

		return updating;

	}

		return jTxtNomCapa;

	}

	/**

	 * This method initializes jPanel1

	 *

		}

		return jPanelSrsSelection;

	}

	/**

	 * This method initializes jPanel6

	 *

		}

		return chkTransparency;

	}

	/**

	 * This method initializes jScrollPane2

	 *

		return jScrollPane2;

	}

	/**

	 * This method initializes jScrollPane3

	 *

						public void valueChanged(

								javax.swing.event.TreeSelectionEvent e) {

							TreePath[] selecciones = getTreeLayers()

									.getSelectionPaths();

							if (selecciones != null) {

		boolean b;

		this.repaint();

								getLstInfoFormats().getModel().getSize() == 0);

		if ((getLstSRSs().getSelectedIndex() != -1)

				&& (getLstFormats().getSelectedIndex() != -1)

		}

		return lstSRSs;

	}

	/**

	 * This method initializes lstSRSs

	 *

	public String getFormat() {

		return (String) getLstFormats().getSelectedValue();

	}

	public String getInfoFormat() {

		return (String) getLstInfoFormats().getSelectedValue();

	}

		}

		return -1;

	}

	/**

	 * Returns the index of the format within the formats list.

	 *

	public void setTransparent(boolean b) {

		getChkTransparency().setSelected(b);

	}

	/**

	 * Returns true if the WMS protocol version in use is

	 * >= 1.3.0, and false otherwise.

		WMSLayerNode[] layers = selectedLayersToArray();

		Vector<RemoteWMSStyle> v = new Vector<RemoteWMSStyle>(layers.length);

		int posInsertion = 0;

		for (int i = layers.length - 1; i >= 0; i--) {

			RemoteWMSStyle sty = layers[i].getSelectedStyle();

			if(sty != null)

			par.setFixedSize(getFixedSize());

			par.setQueryable(explorer.isQueryable());

			par.setName(node.getTitle());

			par.setXyAxisOrder(getXYAxisorder());

			FLyrWMS layer = new FLyrWMS();

			try {

				layer.setParameters(parameters);

			return getLayerPlain(cached);

		}

	}

	public FLayer getLayer() throws InitializeException {

		return getLayer(lastCached);

	}

	 * layer tree in WMS

	 *

	 * @return

	 */

	protected FLayer getLayerTree() throws InitializeException {

		LayerTree layerTree = getLayerStructure();

		if (node.getChildren().size() > 0) {

			FLayers l = null;

			if (this.getMapCtrl() == null) {

						(AbstractViewPanel) PluginServices.getMDIManager().getActiveWindow();

				l = new FLayers();

				l.setMapContext(v.getMapControl().getMapContext());

			return l;

		} else {

			if (nodeSelected(selection, node)) {

				DataStoreParameters parameters = explorer.getStoredParameters();

				WMSDataParameters par = null;

				if(parameters instanceof WMSDataParameters) {

				par.setFixedSize(getFixedSize());

				par.setQueryable(node.isQueryable());

				par.setName(node.getTitle());

				par.deleteCache(updating);

				par.setXyAxisOrder(getXYAxisorder());

				FLyrWMS layer = new FLyrWMS();

				layer.setParameters(parameters);

				layer.setName(node.getName());

	protected FLayer getLayerPlain(boolean cached) throws InitializeException {

		WMSDataParameters par = (WMSDataParameters)explorer.getStoredParameters();

		DataStoreParameters parameters = par;

		if(cached) {

			DataManager manager = DALLocator.getDataManager();

			TileDataParameters tileParams = null;

			tileParams.setDataParameters(par);

			parameters = tileParams;

		}

		par.setFormat(getFormat());

		par.setInfoFormat(getInfoFormat());

		par.setLayerQuery(getLayersQuery());

		par.setFixedSize(getFixedSize());

		par.setQueryable(explorer.isQueryable());

		par.setName(getLayerName());

		par.setXyAxisOrder(getXYAxisorder());

		FLyrWMS layer = new FLyrWMS();

		layer.setParameters(parameters);

		layer.setExplorer(explorer);

	}

	/**

	 * of this exception is returned by the server

	 * @param e

	 * @return

				t = ex.getCause();

			} else if(ex instanceof InvocationTargetException) {

				t = ((InvocationTargetException)ex).getTargetException();

			if(t == null)

				return null;

			else

	public void close() {

		// Nothing to do

	}

	public WMSServerExplorer getExplorer() {

		return explorer;

	}

*

* 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

* MA  02110-1301, USA.

*/

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

import java.awt.Component;

			// the project.

//			dstView = ProjectFactory.createView(null);

			dstView = (DefaultViewDocument) ProjectManager.getInstance().createDocument(ViewManager.TYPENAME);

			dstView.setName(wmc.title);

			dstView.setComment("Created from WebMapContext file: " + wmcFile.getName());

			if (wmc.layerList.get(i) instanceof FLyrWMS) {

				FLyrWMS layer = wmc.layerList.get(i);

				WMSDataParameters params = wmc.paramsList.get(i);

				DataManager datamanager = DALLocator.getDataManager();

				/*

				 * will connect to get the online resources defined by

				 * server, because WMC only defines the original URL for

				 */

				try {

					WMSServerExplorerParameters explorerParams = (WMSServerExplorerParameters) datamanager.createServerExplorerParameters(WMSServerExplorer.NAME);

					WMSServerExplorer explorer = (WMSServerExplorer) datamanager.createServerExplorer(explorerParams);

					layer.setExplorer(explorer);

					params.setOverrideHost(false);

					explorer.connect(null, true);

					params.setOnlineResources(explorer.getOnlineResources());

					layer.setParameters(params);

					Rectangle2D rec = wmc.bBox;

					Envelope envelope = GeometryLocator.getGeometryManager().createEnvelope(rec.getX(),rec.getY(),rec.getMaxX(),rec.getMaxY(), Geometry.SUBTYPES.GEOM2D);

					dstView.getMapContext().getViewPort().setEnvelope(envelope);

					" ["+new Date(System.currentTimeMillis()).toString()+"]",

					e);

				}

				dstView.getMapContext().getLayers().addLayer(layer);

			}

		}

*

* 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

* MA  02110-1301, USA.

*/

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

import java.awt.Dimension;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.project.documents.view.DefaultViewDocument;

import org.gvsig.fmap.crs.CRSFactory;

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

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

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

import org.kxml2.io.KXmlParser;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

 */

public class WebMapContext {

	public final static String FILE_EXTENSION = ".cml";

	static final ArrayList<String> supportedVersions = new ArrayList<String>();

	static public final ArrayList<String> exportVersions    = new ArrayList<String>();

	static private HashSet supportedLayers = new HashSet();

	List<WMSDataParameters>  paramsList = null;

	Hashtable<Object, String[]>  srsList = null;

	/**

	 * key: server URL (URL)

	 * value: server title (String)

		}

		return fileVersion;

	}

	private void readEnconding(File file) {

		FileReader fr = null;

		try {

	@SuppressWarnings("unchecked")

	private void parseLayer1_1_0(KXmlParser parser, FLyrWMS layer, WMSDataParameters dataParameters) throws XmlPullParserException, IOException {

		boolean end = false;

		String queryable = parser.getAttributeValue("", WebMapContextTags.QUERYABLE);

		dataParameters.setQueryable(queryable!=null && (queryable.equals("1") || queryable.toLowerCase().equals("true")));

		List<RemoteWMSStyle> styles = new ArrayList<RemoteWMSStyle>();

		String hidden = parser.getAttributeValue("", WebMapContextTags.HIDDEN);

		layer.setVisible(hidden == null || !hidden.equals("1") || !hidden.toLowerCase().equals("true"));

    	int tag = parser.next();

        				String serverTitle = parser.getAttributeValue("", WebMapContextTags.TITLE.toLowerCase());

        				parser.nextTag();

        				if (parser.getName().compareTo(WebMapContextTags.ONLINE_RESOURCE) == 0) {

        					if (serverTitles == null) {

								serverTitles = new Hashtable<String, String>();

							}

        				}

        			} else if (parser.getName().compareTo(WebMapContextTags.TITLE) == 0) {

        				layer.setName(parser.nextText());

    		}

    		tag = parser.next();

    	}

    	RemoteWMSStyle sty = new RemoteWMSStyle();

    	sty.setName(styleName);

    	sty.setTitle(styleTitle);

*

* 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

* MA  02110-1301, USA.

*/

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

import java.awt.Dimension;

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 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.tools.task.Cancellable;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.task.TaskStatusManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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;

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

               dataManager.createServerExplorerParameters(WMSServerExplorer.NAME);

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

		} catch (ProviderNotRegisteredException e) {

			return null;

		}

		params.setSRS(srs);

		try {

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

		} catch (ValidateDataParametersException e) {

		}

		return (String)formats.get(0);

	}

	public static void registerPersistent() {

		PersistenceManager manager = ToolsLocator.getPersistenceManager();

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

					FLyrWMS.class,

					"FLyrWMS_Persistent",

					"FLyrWMS Persistent Definition",

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

		manager.add(taskStatus);

		taskStatus.setAutoremove(true);

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

		if(!firstLoad) {

			try {

				initFilters();

			}

			firstLoad = true;

		}

		enableStopped();

		if(recalcLevel) {

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

			zoomLevel = dataStore.getNearestLevel(pixelSize);

		}

		disableStopped();

	}

	/**

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

	 * @throws LoadLayerException

			Rectangle2D vpRect = getRectable2DFromEnvelope(vpEnv);

			Rectangle2D layerRect = getRectable2DFromEnvelope(layerEnv);

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

			Rectangle2D.intersect(layerRect, vpRect, requestedRect);

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

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

			else {

				worldY = requestedRect.getMinY();

			}

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

					requestedRect.getMinY(),

					requestedRect.getMaxX(),

					requestedRect.getMaxY(),

					SUBTYPES.GEOM2D);

			Extent requestedExtent = rManager.getDataStructFactory().createExtent(

					requestedEnvelope.getMinimum(1));

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

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

		} catch (CreateEnvelopeException e) {

			drawingError(e);

		} finally {

		}

	}

	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,

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

	public boolean isTiled() {

		return mustSplitRequest;

	}

	private void splitRequestCalculation(int width, int height) {

            RasterDataStore store = this.getDataStore();

            if( store == null ) {

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

			return false;

		}

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

			return false;

		}

		}

		return null;

	}

	public boolean isRemote() {

		return true;

	}

		}

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

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

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

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

		}

		CancelTaskImpl cancellable = new CancelTaskImpl(cancel);

		getParameters().setCancellable(cancellable);

		String fInfo;

		try {

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

			/*} catch (NoninvertibleTransformException e) {

				return null;

			}*/

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

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

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

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

	}

    /**

     * Sets the data store parameters

     * @param params

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

			}

			if(params instanceof TileDataParameters) {

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

				if(p instanceof WMSDataParameters) {

				}

			}

		} catch (ValidateDataParametersException e) {

			throw new InitializeException(e);

		}

    }

	public WMSDataParameters getParameters() {

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

    }

    /**

     * Gets <code>WMSDataParameters</code>

     * @param parameters

    	if(parameters instanceof WMSDataParameters) {

			params = (WMSDataParameters) parameters;

		}

		if(parameters instanceof TileDataParameters) {

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

			if(p instanceof WMSDataParameters) {

		}

		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

    	if(getDataStore() != null)

    		getDataStore().setExplorer(explorer);

    }

    /**

     * Gets the explorer

     * @return

		}

    	return null;

    }

	public FLayer cloneLayer() throws Exception {

		RasterDataStore  ds = dataStore.cloneDataStore();

		FLyrWMS newLayer = new FLyrWMS();

		newLayer.setOpenRasterStore(ds);

		//newLayer.firstLoad = firstLoad;

		newLayer.setExplorer(getExplorer());

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

		//Hacemos una copia de las bandas a renderizar

		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

import java.io.IOException;

import java.io.InputStream;

import java.net.MalformedURLException;

import java.net.URL;

import java.net.URLConnection;

import java.util.ArrayList;

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

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

import org.gvsig.i18n.Messages;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

	private WMSConnector                connector                = null;

	private WMSServerExplorerParameters parameters               = null;

	private Logger                      log                      = LoggerFactory.getLogger(WMSServerExplorer.class);

	public WMSServerExplorer(

			WMSServerExplorerParameters parameters,

			DataServerExplorerProviderServices services)

			throws InitializeException {

		this.parameters = parameters;

	}

	/**

	 * Gets the provider's name

	 * @return

	public String getDataStoreProviderName() {

		return WMSProvider.NAME;

	}

	public String getDescription() {

		return WMSProvider.DESCRIPTION;

	}

	public boolean add(String provider, NewDataStoreParameters parameters,

			boolean overwrite) throws DataException {

		return false;

	}

	public void remove(DataStoreParameters parameters) throws DataException {

	}

	public void dispose() {

	}

	public String getProviderName() {

		return null;

	}

	//**********************************************

	//Connector

	//**********************************************

	public DataStoreParameters getStoredParameters() {

		DataManager manager = DALLocator.getDataManager();

		WMSDataParameters params = null;

		try {

			params = (WMSDataParameters) manager.createStoreParameters(this.getDataStoreProviderName());

			/*if(WMSProvider.TILED) {

				TileDataParameters tileParams = (TileDataParameters) manager.createStoreParameters("Tile Store");

				tileParams.setDataParameters(params);

			log.debug("Error initializating parameters", e);

		} catch (ProviderNotRegisteredException e) {

			log.debug("Error getting parameters", e);

		return params;

	}

	}

	/**

	 * the basic information to make requests.

	 */

	public void connect(ICancellable cancellable, boolean updateCache) throws ConnectException {

		URL url = null;

		try {

			url = new URL(parameters.getHost());

		} catch (Exception e) {

        } catch (IOException e) {

			throw new ConnectException(Messages.getText("error_connecting"), e);

		}

	}

	/**

	 * Checks if the network and host are reachable

	 * @param timeout for the host

		} catch (IOException e) {

			return false;

		}

		return true;

	}

		}

		return null;

	}

	/**

	 * Gets the list of raster information formats supported by the server

	 * @return

	 * @return

	 */

	public String getServerType() {

			return "WMS";

        return "WMS "+ getVersion();

	}

	/**

	 * Gets the online resources

	 * @return

		}

		return null;

	}

    public Rectangle2D getLayersExtent(String[] layerName, String srs) {

    	return connector.getLayersExtent(layerName, srs);

    }

    /**

	 * Gets a layer using its name

	 * @param layerName

	public String getHost() {

		return parameters.getHost();

	}

	public Rectangle2D getBoundingBox(String[] layerNames, String srs) {

		return connector.getLayersExtent(layerNames, srs);

    }

	public boolean isQueryable() {

    	return connector.isQueryable();

    }

	/**

	 * Gets the title

	 * @return

	public String getTitle() {

		return null;

	}

    /**

     * @return The title of the service offered by the WMS server.

     */

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

*/

public class WMSTileServer implements TileServer {

	private Downloader                 downloader           = null;

	private RasterDataStore            store                = null;

	private String                     suffix               = ".tif";

	public WMSTileServer(RasterDataStore store) {

		this.store = store;

		this.suffix = ((RasterProvider)store.getProvider()).getFileSuffix();

	}

	public Downloader getDownloader() {

		if(downloader == null ||

		   ((TileDownloaderForWMS)downloader).getTileSize()[0] != TileCacheLibrary.ALTERNATIVE_TILESIZE ||

		   ((TileDownloaderForWMS)downloader).getTileSize()[1] != TileCacheLibrary.ALTERNATIVE_TILESIZE) {

			try {

				downloader = new TileDownloaderForWMS(

						TileCacheLibrary.ALTERNATIVE_TILESIZE);

			} catch (RemoteServiceException e) {

				return null;

	public CacheStruct getStruct() {

		if(struct == null) {

			TileCacheManager  manager = TileCacheLocator.getManager();

			int coordinates = CacheStruct.FLAT;

			if(store.getProjection() != null)

				coordinates = (store.getProjection() != null && store.getProjection().isProjected()) ? CacheStruct.FLAT : CacheStruct.GEOGRAFIC;

			else {

				Extent e = store.getExtent();

					e.getULY() >= -90 && e.getULY() <= 90 && e.getLRY() >= -90 && e.getLRY() <= 90) {

					coordinates = CacheStruct.GEOGRAFIC;

				}

			}

			String epsg = null;

			IProjection proj = store.getProjection();

			if(proj != null)

				epsg = proj.getAbrev();

					TileCacheLibrary.ALTERNATIVE_TILESIZE,

					((WMSProvider)store.getProvider()).getParameters().getLayerQuery(),

					TileCacheLibrary.DEFAULT_STRUCTURE,

					RasterLibrary.pathTileCache,

		}

		return struct;

	}

	public void setStruct(CacheStruct struct) {

		if(struct != null) {

			this.struct = struct;

			if(struct.getTileSizeByLevel(0) != null) {

				try {

							struct.getTileSizeByLevel(0)[1]);

				} catch (RemoteServiceException ex) {

					logger.error("Constructing TileDownloaderForWCS: " + ex.getMessage());

			}

		}

	}

	public String getFileSuffix() {

		return suffix;

	}

	public void setFileSuffix(String extension) {

		this.suffix = extension;

	}

import java.awt.geom.Rectangle2D;

import java.io.File;

import java.io.IOException;

import java.net.URL;

import java.util.Hashtable;

import java.util.List;

import javax.swing.ImageIcon;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.gvsig.compat.net.ICancellable;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.DALLocator;

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.remoteclient.utils.Utilities;

import org.gvsig.remoteclient.wms.WMSStatus;

import org.gvsig.tools.ToolsLocator;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

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

	private static final int            FIXED_SIZE               = 800;

	private Extent                      viewRequest              = null;

	                                    drivers                  = new Hashtable<String, WMSConnector> ();

	private boolean                     open                     = false;

	private DataStoreTransparency       fileTransparency         = null;

	private File                        fileLayerPixelSize       = null;

	private File                        lastRequest              = null;

	private AbstractRasterProvider       lastRequestProvider      = null;

	public static void register() {

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

		if (dataman != null && !dataman.getStoreProviders().contains(NAME)) {

		}

		dataman.registerStoreFactory(NAME, DefaultStoreFactory.class);

	}

	public WMSProvider() throws NotSupportedExtensionException {

		super();

	}

	public void registerTileProviderFormats(Class<RasterProvider> c) {

	}

	/**

	 * Constructor. Abre el dataset.

	 * @param proj Proyecci?n

	 * @param fName Nombre del fichero

	 * @throws NotSupportedExtensionException

	 */

	public WMSProvider(WMSDataParameters params,

			DataStoreProviderServices storeServices) throws InitializeException {

		super(params, storeServices, ToolsLocator.getDynObjectManager()

								DataStore.METADATA_DEFINITION_NAME)));

		init(params, storeServices);

	}

	/**

	 * Gets the connector from the URL

	 * @return

		WMSDataParameters p = (WMSDataParameters)parameters;

		URL url = null;

		try {

		} catch (Exception e) {

			throw new RemoteServiceException("Malformed URL",e);

		}

			throw new RemoteServiceException("Error getting the connector",e);

		}

	}