Application: gvSIG desktop » gvSIG raster

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

                return definition;

        }

        /*@SuppressWarnings("unchecked")

        @Override

        public void loadFromState(PersistentState state)

                        throws PersistenceException {

                super.loadFromState(state);

                if (state.hasValue(FIELD_STYLES)) {

                        List<RemoteWMSStyle> styleList = state.getList(FIELD_STYLES);

                        if(styleList != null) {

                                Vector<RemoteWMSStyle> v = new Vector<RemoteWMSStyle>();

                                v.addAll(styleList);

                                setStyles(v);

                        }

                }

                if (state.hasValue(FIELD_DIMENSIONS)) {

                        List<String> dimList = state.getList(FIELD_DIMENSIONS);

                        if(dimList != null) {

                                Vector<String> v = new Vector<String>();

                                v.addAll(dimList);

                                setDimensions(v);

                        }

                }

                if(state.getMap(FIELD_ONLINERESOURC) != null)

                        setOnlineResources(new Hashtable<String, String>(state.getMap(FIELD_ONLINERESOURC)));

                if (state.hasValue(FIELD_FIXEDSIZE)) {

                        setFixedSize((Dimension) state.get(FIELD_FIXEDSIZE));

                } else {

                        setFixedSize(null);

                }

                setExtent((Rectangle2D)state.get(FIELD_EXTENT));

        }*/

        /**

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

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

        }

}