Application: gvSIG desktop » gvSIG raster

org.gvsig.raster.wms.io.DefaultWMSIOLibrary

error_connecting=Error conectando con el servidor

malformed_url=URL mal formada

error_connecting=Error connecting with the server

malformed_url=Malformed URL

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

import java.awt.Dimension;

import java.awt.geom.Rectangle2D;

import java.util.Hashtable;

import java.util.List;

import java.util.Map;

import java.util.Vector;

import org.gvsig.compat.net.ICancellable;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

import org.gvsig.raster.impl.store.AbstractRasterDataParameters;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DelegatedDynObject;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

/**

 * Parameters for the WMS provider

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

 */

public class WMSDataParametersImpl extends AbstractRasterDataParameters implements WMSDataParameters {

	private static final String      FIELD_FORMAT          = "format";

	private static final String      FIELD_INFOFORMAT      = "infoformat";

	private static final String      FIELD_LAYERQUERY      = "layer_query";

	private static final String      FIELD_NAME            = "name";

	private static final String      FIELD_SRSSTR          = "srsstr";

	private static final String      FIELD_TRANSPARENCY    = "transparency";

	private static final String      FIELD_INFOLAYERQUERY  = "infolayerquery";

	private static final String      FIELD_QUERYABLE       = "queryable";

	private static final String      FIELD_OVERRIDE        = "override";

	private static final String      FIELD_STYLES          = "styles";

	private static final String      FIELD_DIMENSIONS      = "dimensions";

	private static final String      FIELD_ONLINERESOURC   = "onlineresources";

	private static final String      FIELD_FIXEDSIZE       = "fixedsize";

	private static final String      FIELD_EXTENT          = "extent";

	private static final String      FIELD_WIDTH           = "width";

	private static final String      FIELD_HEIGHT          = "height";

	private static final String      FIELD_DELETECACHE     = "deletecache";

	private static final String      FIELD_ASSUMEXYAXISORDER = "assumeXY";

	private DelegatedDynObject       delegatedDynObject    = null;

	protected static DynClass        DYNCLASS              = null;

	private ICancellable             cancel                = null;

	public WMSDataParametersImpl() {

		super();

		initialize();

	}

	protected void initialize() {

		this.delegatedDynObject = (DelegatedDynObject) ToolsLocator

				.getDynObjectManager().createDynObject(registerDynClass());

	}

	public static DynStruct registerDynClass() {

		PersistenceManager manager = ToolsLocator.getPersistenceManager();

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

		if( definition == null ) {

			definition = manager.addDefinition(

					WMSDataParametersImpl.class,

					"WMSDataParameters_Persistent",

					"WMS DataParameters Persistency",

					null, 

					null

			);

		}

		AbstractRasterDataParameters.registerDynClass(definition);

		definition.addDynFieldObject(FIELD_EXTENT)

		.setDescription("Bounding box")

		.setClassOfValue(Rectangle2D.class)

		.setMandatory(false);

		definition.addDynFieldInt(FIELD_WIDTH)

		.setDescription("Width")

		.setMandatory(false);

		definition.addDynFieldInt(FIELD_HEIGHT)

		.setDescription("Height")

		.setMandatory(false);

		definition.addDynFieldString(FIELD_FORMAT)

		.setDescription("Format")

		.setMandatory(false);

		definition.addDynFieldString(FIELD_INFOFORMAT)

		.setDescription("Info by point format")

		.setMandatory(false);

		definition.addDynFieldString(FIELD_LAYERQUERY)

		.setDescription("Layer Query")

		.setMandatory(false);

		definition.addDynFieldString(FIELD_NAME)

		.setDescription("Name")

		.setMandatory(false);			

		definition.addDynFieldString(FIELD_SRSSTR)

		.setDescription("String that represents the SRS")

		.setMandatory(false);

		definition.addDynFieldBoolean(FIELD_TRANSPARENCY)

		.setDescription("Transparency")

		.setMandatory(false);

		definition.addDynFieldString(FIELD_INFOLAYERQUERY)

		.setDescription("InfoLayerQuery")

		.setMandatory(false);

		definition.addDynFieldBoolean(FIELD_QUERYABLE)

		.setDescription("Queryable")

		.setMandatory(false);

		definition.addDynFieldBoolean(FIELD_OVERRIDE)

		.setDescription("Override a host capabilities")

		.setMandatory(false);

		definition.addDynFieldList(FIELD_STYLES)

		.setDescription("Styles")

		.setClassOfItems(RemoteWMSStyle.class)

		.setMandatory(false);

		definition.addDynFieldList(FIELD_DIMENSIONS)

		.setDescription("Dimensions")

		.setClassOfItems(String.class)

		.setMandatory(false);

		definition.addDynFieldMap(FIELD_ONLINERESOURC)

		.setDescription("online resources")

		.setClassOfItems(String.class)

		.setMandatory(false);

		definition.addDynFieldObject(FIELD_FIXEDSIZE)

		.setDescription("Fixed size")

		.setClassOfValue(Dimension.class)

		.setMandatory(false);

		definition.addDynFieldBoolean(FIELD_DELETECACHE)

		.setDescription("Flag to delete cache the next request")

		.setMandatory(false);

		definition.addDynFieldBoolean(FIELD_ASSUMEXYAXISORDER)

		.setDescription("Flag to decide the axis order behaviour")

		.setMandatory(false);

		return definition;

	}

	/**

	 * Gets the format

	 * @return

	 */

	public String getFormat() {

		return (String) this.getDynValue(FIELD_FORMAT);

	}

	/**

	 * Sets the format

	 * @param format

	 */

	public void setFormat(String format) {

		this.setDynValue(FIELD_FORMAT, format);

	}

	/**

	 * Gets the info by point format

	 * @return

	 */

	public String getInfoFormat() {

		String o = (String) this.getDynValue(FIELD_INFOFORMAT);

		if(o == null)

			return "text/plain";

		return o;

	}

	/**

	 * Sets the info by point format

	 */

	public void setInfoFormat(String format) {

		this.setDynValue(FIELD_INFOFORMAT, format);

	}

	public String getLayerQuery() {

		return (String) this.getDynValue(FIELD_LAYERQUERY);

	}

	public void setLayerQuery(String layerQuery) {

		this.setDynValue(FIELD_LAYERQUERY, layerQuery);

	}

	/**

	 * Devuelve el SRS.

	 * @return SRS.

	 */

	public String getSRSCode() {

		return (String) this.getDynValue(FIELD_SRSSTR);

	}

	/**

	 * Inserta el SRS.

	 * @param m_srs SRS.

	 */

	public void setSRS(String m_srs) {

		this.setDynValue(FIELD_SRSSTR, m_srs);

		if(m_srs.equals("CRS:84"))

			m_srs = "EPSG:4326";

		setSRS(CRSFactory.getCRS(m_srs));

	}

	public void setSRSID(String srsid) {

		if (srsid == null) {

			setDynValue(FIELD_SRSSTR, null);

		} else {

			setDynValue(FIELD_SRSSTR, CRSFactory.getCRS(srsid));

		}

	}

	public String getName() {

		return (String) this.getDynValue(FIELD_NAME);

	}

	public void setName(String name) {

		this.setDynValue(FIELD_NAME, name);

	}

	public boolean isWmsTransparent() {

		Boolean b = (Boolean)getDynValue(FIELD_TRANSPARENCY);

		if(b != null)

			return ((Boolean)b).booleanValue();

		return false;

	}

	/**

	 * @param wmsTransparency The wmsTransparency to set.

	 */

	public void setWmsTransparency(boolean wmsTransparency) {

		this.setDynValue(FIELD_TRANSPARENCY, new Boolean(wmsTransparency));

	}

	public String getInfoLayerQuery() {

		return (String) this.getDynValue(FIELD_INFOLAYERQUERY);

	}

	public void setInfoLayerQuery(String infoLayerQuery) {

		this.setDynValue(FIELD_INFOLAYERQUERY, infoLayerQuery);

	}

	/**

	 * If it is true, this layer accepts GetFeatureInfo operations. This WMS operations

	 * maps to FMap's infoByPoint(p) operation.

	 * @param b

	 */

	public void setQueryable(boolean b) {

		this.setDynValue(FIELD_QUERYABLE, new Boolean(b));

	}

	public void setCancellable(ICancellable cancel) {

		this.cancel = cancel;

	}

	public ICancellable getCancellable() {

		return cancel;

	}

	public boolean isQueryable() {

		Boolean b = (Boolean)getDynValue(FIELD_QUERYABLE);

		if(b != null)

			return ((Boolean)b).booleanValue();

		return false;

	}

	public boolean isOverridingHost() {

		Boolean b = (Boolean)getDynValue(FIELD_OVERRIDE);

		if(b != null)

			return ((Boolean)b).booleanValue();

		return false;

	}

	public void setOverrideHost(boolean over) {

		this.setDynValue(FIELD_OVERRIDE, new Boolean(over));;

	}

	public void setStyles(List<RemoteWMSStyle> styles) {

		this.setDynValue(FIELD_STYLES, styles);

	}

	/**

	 * @param styles

	 */

	@SuppressWarnings("unchecked")

	public List<RemoteWMSStyle> getStyles() {

		return (List<RemoteWMSStyle>) this.getDynValue(FIELD_STYLES);

	}

	public void setDimensions(Vector<String> dimensions) {

		this.setDynValue(FIELD_DIMENSIONS, dimensions);

	}

	/**

	 * Gets the dimension vector that is a list of key-value pairs containing

	 * the name of the dimension and the value for it

	 * @return

	 */

	@SuppressWarnings("unchecked")

	public Vector<String> getDimensions() {

		return (Vector<String>) this.getDynValue(FIELD_DIMENSIONS);

	}

	public void setOnlineResources(Map<String, String> onlineResources) {

		this.setDynValue(FIELD_ONLINERESOURC, onlineResources);

	}

	public String getOnlineResource(String operation) {

		return (String) getOnlineResource().get(operation);

	}

	@SuppressWarnings("unchecked")

	public Map<String,String> getOnlineResource() {

		return (Map<String,String>) this.getDynValue(FIELD_ONLINERESOURC);

	}

	/**

	 * When a server is not fully featured and it only can serve constant map

	 * sizes this value must be set. It expresses the size in pixels (width, height)

	 * that the map will be requested.

	 * @param Dimension sz

	 */

	public void setFixedSize(Dimension sz) {

		this.setDynValue(FIELD_FIXEDSIZE, sz);

	}

	/**

	 * Tells whether if this layer must deal with the server with the constant-size

	 * limitations or not.

	 * @return boolean.

	 */

	public boolean isSizeFixed() {

		return (getDynValue(FIELD_FIXEDSIZE) != null);

	}

	/**

	 * Gets the value of the fixed size

	 * @return

	 */

	public Dimension getFixedSize() {

		return (Dimension) this.getDynValue(FIELD_FIXEDSIZE);

	}

	/**

	 * Assigns the extent. 

	 * When a provider is initialized this will need to know what is the extent before the request.

	 * 

	 * @param bBox

	 */

	public void setExtent(Rectangle2D bBox) {

		this.setDynValue(FIELD_EXTENT, bBox);

	}

	public void setWidth(int w) {

		this.setDynValue(FIELD_WIDTH, new Integer(w));

	}

	public void setHeight(int h) {

		this.setDynValue(FIELD_HEIGHT, new Integer(h));

	}

	/**

	 * Gets the bounding box

	 * @return

	 */

	public Rectangle2D getExtent() {

		return (Rectangle2D)getDynValue(FIELD_EXTENT);

	}

	/**

	 * Gets the width

	 * @return

	 */

	public int getWidth() {

		Integer b = (Integer)getDynValue(FIELD_WIDTH);

		if(b != null)

			return ((Integer)b).intValue();

		return 0;

	}

	/**

	 * Gets the height

	 * @return

	 */

	public int getHeight() {

		Integer b = (Integer)getDynValue(FIELD_HEIGHT);

		if(b != null)

			return ((Integer)b).intValue();

		return 0;

	}

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

	public String getDataStoreName() {

		return WMSProvider.NAME;

	}

	public String getDescription() {

		return WMSProvider.DESCRIPTION;

	}

	public String getExplorerName() {

		return WMSServerExplorer.NAME;

	}

	public boolean isValid() {

		return (this.getURI() != null);

	}

	protected DelegatedDynObject getDelegatedDynObject() {

		return delegatedDynObject;

	}

	public void deleteCache(boolean deleteCache) {

		this.setDynValue(FIELD_DELETECACHE, new Boolean(deleteCache));

	}

	public boolean isDeletingCache() {

		return ((Boolean)getDynValue(FIELD_DELETECACHE)).booleanValue();

	}

	@SuppressWarnings("unchecked")

	public WMSDataParameters clone() {

		WMSDataParametersImpl p = new WMSDataParametersImpl();

		p.setFormat(getFormat());

		p.setFixedSize(getFixedSize());

		p.setHeight(getHeight());

		p.setWidth(getWidth());

		p.setExtent(getExtent());

		p.setURI(getURI());

		p.setInfoLayerQuery(getInfoLayerQuery());

		p.setLayerQuery(getLayerQuery());

		p.setName(getName());

		p.setOnlineResources((Hashtable<String, String>)this.getDynValue(FIELD_ONLINERESOURC));

		p.setOverrideHost(isOverridingHost());

		p.setQueryable(isQueryable());

		p.setSRS(getSRS());

		p.setSRS(getSRSCode());

		p.setStyles(getStyles());

		p.setWmsTransparency(isWmsTransparent());

		p.setDimensions(getDimensions());

		p.setCancellable(getCancellable());

		p.setXyAxisOrder(isXyAxisOrder());

		return p;

	}

	public void assignFields(RasterDataParameters par, RasterDataServerExplorer explorer) {

		super.assignFields(par, explorer);

		WMSDataParametersImpl p = null;

		if(par instanceof WMSDataParametersImpl)

			p = (WMSDataParametersImpl)par;

		else

			return;

		setFormat(p.getFormat());

		setFixedSize(p.getFixedSize());

		setHeight(p.getHeight());

		setWidth(p.getWidth());

		setExtent(p.getExtent());

		setURI(p.getURI());

		setInfoLayerQuery(p.getInfoLayerQuery());

		setLayerQuery(p.getLayerQuery());

		setName(getName());

		setOnlineResources((Map<String, String>)p.getDynValue(FIELD_ONLINERESOURC));

		setOverrideHost(p.isOverridingHost());

		setQueryable(p.isQueryable());

		setSRS(p.getSRSCode());

		setStyles(p.getStyles());

		setWmsTransparency(p.isWmsTransparent());

		setDimensions(p.getDimensions());

		setCancellable(p.getCancellable());

		setXyAxisOrder(p.isXyAxisOrder());

	}

	public boolean isXyAxisOrder() {

		Boolean b = (Boolean)getDynValue(FIELD_ASSUMEXYAXISORDER);

		if(b != null)

			return b.booleanValue();

		return false;

	}

	public void setXyAxisOrder(boolean assumeXY) {

		setDynValue(FIELD_ASSUMEXYAXISORDER, assumeXY);

	}

}

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

import org.gvsig.i18n.Messages;

import org.gvsig.raster.wms.io.time.DefaultDimension;

import org.gvsig.raster.wms.io.time.TimeDimension;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

/**

 *

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

 */

public class DefaultWMSIOLibrary extends AbstractLibrary {

	/*public DefaultWMSIOLibrary() {

		super(DefaultWMSIOLibrary.class,Library.TYPE.IMPL);

		require(ToolsLibrary.class);

		require(DALLibrary.class);

		require(DALFileLibrary.class);

	}*/

	@Override

	protected void doInitialize() throws LibraryException {

		//RasterLibrary.wakeUp();

		WMSLayerNode.registerPersistent();

		RemoteWMSStyle.registerPersistent();

		DefaultDimension.registerPersistent();

		TimeDimension.registerPersistent();

		Messages.addResourceFamily("org.gvsig.raster.wms.io.i18n.text",

				DefaultWMSIOLibrary.class.getClassLoader(),

				DefaultWMSIOLibrary.class.getClass().getName());

	}

	@Override

	protected void doPostInitialize() throws LibraryException {

		WMSServerExplorerParameters.registerDynClass();

		WMSDataParametersImpl.registerDynClass();

		WMSProvider.register();

	}

}

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

import java.awt.Dimension;

import java.util.ArrayList;

import java.util.List;

import org.gvsig.raster.wms.io.time.DefaultDimension;

import org.gvsig.raster.wms.io.time.RemoteTimeDimension;

import org.gvsig.raster.wms.io.time.TimeDimension;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

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;

/**

 * Class defining the node of the layer tree of a common WMS service.

 * @author jaume

 */

@SuppressWarnings("unchecked")

public class WMSLayerNode implements Persistent {

    private String                         _name              = null;

    private String                         _title             = null;

	private List<String>                   srs                = null;

    private boolean                        queryable;

    private boolean                        transparency;

    private String                         lAbstract          = null;

    private String                         latLonBox          = null;

    private int                            selectedStyleIndex = 0;

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

    private List<RemoteTimeDimension>      dimensions         = null;

    private List<String>                   keywords           = null;

    private List<WMSLayerNode>             children           = new ArrayList<WMSLayerNode>();

    private WMSLayerNode                   _parent            = null;

	private Dimension                      fixedSize          = null;

	public void loadFromState(PersistentState state) throws PersistenceException {

		this._name = state.getString("_name");

		this._title = state.getString("_title");

		this.srs = state.getList("srs");

		this.queryable = state.getBoolean("queryable");

		this.transparency = state.getBoolean("transparency");

		this.lAbstract = state.getString("lAbstract");

		this.latLonBox = state.getString("latLonBox");

		this.selectedStyleIndex = state.getInt("selectedStyleIndex");

		this.styles = state.getList("styles");

		this.dimensions = state.getList("dimensions");

		this.keywords = state.getList("keywords");

		this.children = state.getList("children");

		this._parent = (WMSLayerNode)state.get("_parent");

		this.fixedSize = (Dimension)state.get("fixedSize");

	}

	public void saveToState(PersistentState state) throws PersistenceException {

		state.set("_name", _name);

		state.set("_title", _title);

		state.set("srs", srs);

		state.set("queryable", queryable);

		state.set("transparency", transparency);

		state.set("lAbstract", lAbstract);

		state.set("latLonBox", latLonBox);

		state.set("selectedStyleIndex", selectedStyleIndex);

		state.set("styles", styles);

		state.set("dimensions", dimensions);

		state.set("keywords", keywords);

		state.set("children", children);

		state.set("_parent", _parent);

		state.set("fixedSize", fixedSize);

	}	

    public static void registerPersistent() {

		PersistenceManager manager = ToolsLocator.getPersistenceManager();

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

		if( definition == null ) {

			definition = manager.addDefinition(

					WMSLayerNode.class,

					"WMSLayerNode_Persistent",

					"WMSLayerNode Persistence",

					null, 

					null

			);

		}

		definition.addDynFieldString("_name").setMandatory(false);

		definition.addDynFieldString("_title").setMandatory(false);

		definition.addDynFieldList("srs").setClassOfItems(String.class).setMandatory(false);

		definition.addDynFieldBoolean("queryable").setMandatory(false);

		definition.addDynFieldBoolean("transparency").setMandatory(false);

		definition.addDynFieldString("lAbstract").setMandatory(false);

		definition.addDynFieldString("latLonBox").setMandatory(false);		

		definition.addDynFieldInt("selectedStyleIndex").setMandatory(false);

		definition.addDynFieldList("styles").setClassOfItems(RemoteWMSStyle.class).setMandatory(false);

		definition.addDynFieldList("dimensions").setClassOfItems(RemoteTimeDimension.class).setMandatory(false);

		definition.addDynFieldList("keywords").setClassOfItems(String.class).setMandatory(false);

		definition.addDynFieldList("children").setClassOfItems(WMSLayerNode.class).setMandatory(false);

		definition.addDynFieldObject("_parent").setClassOfValue(WMSLayerNode.class).setMandatory(false);

		definition.addDynFieldObject("fixedSize").setClassOfValue(Dimension.class).setMandatory(false);

	}

	/**

     * @return Returns the name.

     */

    public String getName() {

        return _name;

    }

    public List<WMSLayerNode> getChildren() {

        return children;

    }

    /**

     * @param name The name to set.

     */

    public void setName(String name) {

        this._name = name;

    }

    /**

     * @return Returns the namedStyles.

     */

    public List<RemoteWMSStyle> getStyles() {

        return styles;

    }

    public List<String> getKeywords() {

    	return keywords;

    }

    /**

     * @return Returns the queryable.

     */

    public boolean isQueryable() {

        return queryable;

    }

    /**

     * @param queryable The queryable to set.

     */

    public void setQueryable(boolean queryable) {

        this.queryable = queryable;

    }

    /**

     * @return Returns the srs.

     */

    public List<String> getAllSrs() {

        if ((srs.size() == 0) && _parent!=null)

            return _parent.getAllSrs();

        return srs;

    }

    /**

     * @param srs The srs to set.

     */

    public void setSrs(List<String> srs) {

        this.srs = srs;

    }

    /**

     * @return Returns the title.

     */

    public String getTitle() {

        return _title;

    }

    public void setTitle(String title) {

        this._title = title.trim();

    }

    /**

     * @return Returns the transparency.

     */

    public boolean isTransparent() {

        return transparency;

    }

    /**

     * @param transparency The transparency to set.

     */

    public void setTransparency(boolean transparency) {

        this.transparency = transparency;

    }

    /**

     * Sets the list of sons of this layer.

     * @param children

     */

    public void setChildren(List<WMSLayerNode> children) {

        this.children = children;

    }

    public WMSLayerNode getParent() {

        return _parent;

    }

    public void setParent(WMSLayerNode parentNode) {

        this._parent = parentNode;

    }

    public List<RemoteTimeDimension> getDimensions() {

        return dimensions;

    }

    /**

     * Gets the layer abstract.

     *

     * @return Returns the abstract.

     */

    public String getAbstract() {

        return lAbstract;

    }

    /**

     * Sets the layer abstract.

     *

     * @param abstract The abstract to set.

     */

    public void setAbstract(String _abstract) {

        lAbstract = _abstract;

    }

    /**

     * @param name

     * @param units

     * @param unitSymbol

     * @param dimensionExpression

     */

    public void addDimension(String name, String units, String unitSymbol, String dimExpression) {

    	if (dimensions == null)

    		dimensions = new ArrayList<RemoteTimeDimension>();

    	if (name.equalsIgnoreCase("time")) {

    		try {

    			dimensions.add(new TimeDimension(units, unitSymbol,

    					dimExpression));

    		} catch (IllegalArgumentException e) {

    			// The TIME class does not yet support this kind of time so it

    			// will be treated as a DefaultDimension

    			dimensions.add(new DefaultDimension(name.toUpperCase(),

    					units, unitSymbol, dimExpression));

    		}

    	} else if (name.equalsIgnoreCase("sequence")) {

    		// TODO Not yet implemented

    		return;

    	} else {

    		dimensions.add(new DefaultDimension(name.toUpperCase(), units,

    				unitSymbol, dimExpression));

    	}

    }

    public void setLatLonBox(String _latLonBox) {

        latLonBox = _latLonBox;

    }

    public String getLatLonBox() {

        return latLonBox;

    }

    /**

     * When a server cannot renderize images but just server them in constant size and

     * BBox, the layer must have this value set in order to correctly work.

     *

     * @param fixedWidth - the constant value for the image width

     * @param fixedHeight - the constant value for the image height

     */

    public void setFixedSize(int fixedWidth, int fixedHeight) {

		fixedSize = new Dimension(fixedWidth, fixedHeight);

	}

	public Dimension getFixedSize() {

		return fixedSize;

	}

	public boolean isSizeFixed() {

		return fixedSize            != null &&

		       fixedSize.getWidth()  > 0    &&

		       fixedSize.getHeight() > 0;

	}

    /**

     *

     * @param _name

     * @param _title

     * @param _abstract

     */

    public void addStyle(org.gvsig.remoteclient.wms.WMSStyle style) {

    	if (style.getName().equalsIgnoreCase("default"))

    		selectedStyleIndex = styles.size();

        if (styles == null)

            styles = new ArrayList<RemoteWMSStyle>();

        styles.add(new RemoteWMSStyle(style, this));

    }

    public RemoteWMSStyle getSelectedStyle() {

    	if (styles == null || selectedStyleIndex > styles.size() - 1 || selectedStyleIndex == -1)

    		return null;

    	return (RemoteWMSStyle) styles.get(selectedStyleIndex);

    }

    public void setSelectedStyleByIndex(int index) {

		selectedStyleIndex = index;

	}

	public void setSelectedStyleByName(String styName) {

		if (styName == null || styName.equals(""))

			setSelectedStyleByIndex(-1);

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

			RemoteWMSStyle sty = (RemoteWMSStyle) styles.get(i);

			if (sty.name.equalsIgnoreCase(styName)) {

				setSelectedStyleByIndex(i);

				return;

			}

		}

		setSelectedStyleByIndex(-1);

	}

	public void addKeyword(String keyword) {

		if (keywords == null)

			keywords = new ArrayList<String>();

		keywords.add(keyword);

	}

    public String toString(){

    	String str;

    	if (getName()==null)

    		str = getTitle();

    	else

    		str = "["+getName()+"] "+getTitle();

        return str;

    }

    public Object clone() throws CloneNotSupportedException {

        WMSLayerNode clone       = new WMSLayerNode();

        clone._name              = this._name;

        clone.queryable          = this.queryable;

        clone.srs                = this.srs;

        clone._title             = this._title;

        clone.transparency       = this.transparency;

        clone.styles             = new ArrayList<RemoteWMSStyle>();

        clone.lAbstract          = this.lAbstract;

        clone.latLonBox          = this.latLonBox;

        clone.selectedStyleIndex = this.selectedStyleIndex;

        if (keywords != null) {

        	clone.keywords = new ArrayList<String>(keywords.size());

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

				clone.keywords.add((String) keywords.get(i));

			}

        }

        if (styles != null)

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

        		RemoteWMSStyle sty = (RemoteWMSStyle) this.styles.get(i).clone();

        		((RemoteWMSStyle)sty).parent = this;

        		clone.styles.add(sty);

        	}

        if (dimensions!=null)

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

        		clone.dimensions = new ArrayList<RemoteTimeDimension>();

        		clone.dimensions.add((RemoteTimeDimension) this.dimensions.get(i));

        	}

        return clone;

    }

}

/* 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 IVER T.I   {{Task}}

*/

package org.gvsig.raster.wms.io;

import java.awt.geom.Rectangle2D;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.net.MalformedURLException;

import java.net.URI;

import java.net.URISyntaxException;

import java.net.URL;

import java.net.URLConnection;

import java.util.ArrayList;

import java.util.Hashtable;

import java.util.List;

import java.util.Vector;

import org.gvsig.compat.net.ICancellable;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.NewDataStoreParameters;

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

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

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

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.spi.AbstractDataServerExplorer;

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

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

import org.gvsig.i18n.Messages;

import org.gvsig.remoteclient.utils.Utilities;

import org.gvsig.tools.task.Cancellable;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Explorer for a WMS server

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

 */

public class WMSServerExplorer extends AbstractDataServerExplorer implements RasterDataServerExplorer, DataServerExplorerProvider {

	public static final String          NAME                     = WMSProvider.NAME;

	private WMSConnector                connector                = null;

//	private WMSServerExplorerParameters parameters               = null;

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

	public WMSServerExplorer(

			WMSServerExplorerParameters parameters,

			DataServerExplorerProviderServices services)

			throws InitializeException {

                super(parameters, services);

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

		return false;

	}

	public boolean canAdd(String storeName) throws DataException {

		return false;

	}

	public NewDataStoreParameters getAddParameters(String storeName)

			throws DataException {

		return null;

	}

	public List<String> getDataStoreProviderNames() {

		return null;

	}

	public WMSServerExplorerParameters getParameters() {

		return (WMSServerExplorerParameters) super.getParameters();

	}

	public List<DataStoreParameters> list() throws DataException {

		return null;

	}

	public List<DataStoreParameters> list(int mode) throws DataException {

		return null;

	}

	public void remove(DataStoreParameters parameters) throws DataException {

	}

	public String getProviderName() {

		return null;

	}

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

	//Connector

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

	public DataStoreParameters getStoredParameters() {

		DataManager manager = DALLocator.getDataManager();

		WMSDataParameters params = null;

		try {

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

			params.setURI(new URI(getParameters().getHost()));

			/*if(WMSProvider.TILED) {

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

				tileParams.setDataParameters(params);

				return tileParams;

			} */

		} catch (InitializeException e) {

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

		} catch (ProviderNotRegisteredException e) {

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

		} catch (URISyntaxException e) {

            log.debug("Can't create URI from "+getParameters().getHost(), e);

        }

		return params;

	}

	public void connect(ICancellable cancellable) throws ConnectException {

		connect(cancellable, false);

	}

	/**

	 * Connects to the server and throws a getCapabilities. This loads

	 * the basic information to make requests.

	 * @throws RemoteServiceException

	 */

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

		URL url = null;

		try {

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

		} catch (Exception e) {

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

		}

        try {

        	connector = WMSProvider.getConnectorFromURL(url, updateCache);

        	if (!connector.connect(this.getParameters(), updateCache, cancellable))

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

        } catch (IOException e) {

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

		}

	}

	/**

	 * Checks if the network and host are reachable

	 * @param timeout for the host

	 * @return true if both are reachable and false if they are not

	 */

	public boolean isHostReachable(int timeout) {

		URL url = null;

		try {

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

			File file = Utilities.downloadFile(url, "checkhost.dat", null);

		} catch (Exception e) {

			return false;

		}

		return true;

	}

	/**

	 * Checks if the network and host are reachable

	 * @return true if both are reachable and false if they are not

	 */

	public boolean isHostReachable() {

		int timeout = 10000;

		return isHostReachable(timeout);

	}

	/**

	 * Returns true if this provider is connected to the server

	 * @return

	 */

	public boolean isConnected() {

		if(connector != null)

			return true;

		return false;

	}

	/**

	 * Gets the description of this service

	 * @return

	 */

	public String getAbstract() {

		if(connector != null)

			return connector.getAbstract();

		return null;

	}

	/**

	 * Gets the list of raster formats supported by the server

	 * @return

	 */

	@SuppressWarnings("unchecked")

	public String[] getFormats() {

		if(connector != null) {

			Vector f = connector.getFormats();

			ArrayList formatos = new ArrayList();

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

				formatos.add(f.elementAt(i));

			}

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

		}

		return null;

	}

	/**

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

	 * @return

	 */

	@SuppressWarnings("unchecked")

	public String[] getInfoFormats() {

		if(connector != null) {

			Vector f = connector.getInfoFormats();

			ArrayList formatos = new ArrayList();

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

				formatos.add(f.elementAt(i));

			}

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

		}

		return null;

	}

	/**

	 * Gets a tree of nodes which represents the server information

	 * @return

	 */

	public WMSLayerNode getLayerTree() {

		if(connector != null) {

			return connector.getLayersTree();

		}

		return null;

	}

	/**

	 * Gets the server title

	 * @return

	 */

	public String getServerType() {

		if (getVersion() == null)

			return "WMS";

        return "WMS "+ getVersion();

	}

	/**

	 * Gets the online resources

	 * @return

	 */

	public Hashtable getOnlineResources() {

		if(connector != null) {

			return connector.getOnlineResources();

		}

		return null;

	}

	/**

	 * Gets the protocol supported by the server

	 * @return

	 */

	public String getVersion() {

		if(connector != null) {

			return (connector.getVersion() == null) ? "" : connector.getVersion();

		}

		return null;

	}

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

    	return connector.getLayersExtent(layerName, srs);

    }

    /**

	 * Gets a layer using its name

	 * @param layerName

	 * @return

	 */

    public WMSLayerNode getLayer(String layerName) {

    	return connector.getLayer(layerName);

    }

    /**

	 * Gets the host URI

	 * @return

	 */

	public String getHost() {

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

     */

    public String getServiceTitle() {

		return connector.getServiceTitle();

    }

	public DataServerExplorerProviderServices getServerExplorerProviderServices() {

		return null;

	}

}

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

import java.awt.geom.Rectangle2D;

import java.io.File;

import java.io.IOException;

import java.util.List;

import java.util.Vector;

import org.cresques.cts.IProjection;

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

import org.gvsig.fmap.dal.coverage.dataset.Buffer;

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

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.exception.RasterDriverException;

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

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

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

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

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

import org.gvsig.raster.cache.tile.Tile;

import org.gvsig.raster.cache.tile.exception.TileGettingException;

import org.gvsig.raster.impl.DefaultRasterManager;

import org.gvsig.raster.impl.provider.RasterProvider;

import org.gvsig.raster.impl.provider.tile.BaseTileDownloader;

import org.gvsig.raster.util.DefaultProviderServices;

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

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

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

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

import org.gvsig.remoteclient.utils.Utilities;

import org.gvsig.remoteclient.wms.WMSStatus;

import org.gvsig.tools.locator.LocatorException;

/** 

 * Tile getter 

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

 */

public class TileDownloaderForWMS extends BaseTileDownloader {

	private WMSConnector             connector  = null;

	private Extent                   lyrExtent  = null;

	public TileDownloaderForWMS(RasterDataStore store,

			int tilePxWidth,

			int tilePxHeight) throws RemoteServiceException {

		super(store, tilePxWidth, tilePxHeight);

		this.connector = ((WMSProvider)store.getProvider()).getConnector();

		lyrExtent = store.getExtent();

	}

	public synchronized Tile downloadTile(Tile tile) throws TileGettingException {

		try {

			Rectangle2D r = new Rectangle2D.Double(tile.getExtent().getMinX(), 

					tile.getExtent().getMinY() - tile.getExtent().getHeight(), 

					tile.getExtent().getWidth(), 

					tile.getExtent().getHeight());

			//Extent tileExtent = RasterLocator.getManager().getDataStructFactory().createExtent(r);

			WMSDataParameters p = (WMSDataParameters)store.getParameters();

			WMSStatus wmsStatus = new WMSStatus();

			wmsStatus.setLayerNames(Utilities.createVector(p.getLayerQuery(), ","));

			wmsStatus.setSrs(p.getSRSCode());