Application: gvSIG desktop

package es.prodevelop.cit.gvsig.arcims.fmap.layers;

import java.awt.Color;

import java.awt.Graphics2D;

import java.awt.Point;

import java.awt.geom.AffineTransform;

import java.awt.geom.NoninvertibleTransformException;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import java.io.IOException;

import java.net.MalformedURLException;

import java.net.ProtocolException;

import java.net.URL;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Map;

import java.util.Vector;

import org.apache.log4j.Logger;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.gvsig.remoteClient.arcims.ArcImsClientP;

import org.gvsig.remoteClient.arcims.ArcImsFeatureClient;

import org.gvsig.remoteClient.arcims.ArcImsProtocolHandler;

import org.gvsig.remoteClient.arcims.ArcImsVectStatus;

import org.gvsig.remoteClient.arcims.exceptions.ArcImsException;

import org.gvsig.remoteClient.arcims.utils.FieldInformation;

import org.gvsig.remoteClient.arcims.utils.MyCancellable;

import org.gvsig.remoteClient.arcims.utils.ServiceInfoTags;

import org.gvsig.remoteClient.arcims.utils.ServiceInformation;

import org.gvsig.remoteClient.arcims.utils.ServiceInformationLayerFeatures;

import org.gvsig.remoteClient.utils.Utilities;

import com.hardcode.driverManager.DriverLoadException;

import com.hardcode.gdbms.engine.data.DataSource;

import com.iver.cit.gvsig.fmap.DriverException;

import com.iver.cit.gvsig.fmap.MapContext;

import com.iver.cit.gvsig.fmap.ViewPort;

import com.iver.cit.gvsig.fmap.core.DefaultFeature;

import com.iver.cit.gvsig.fmap.core.IGeometry;

import com.iver.cit.gvsig.fmap.core.ISymbol;

import com.iver.cit.gvsig.fmap.core.v02.FSymbol;

import com.iver.cit.gvsig.fmap.crs.CRSFactory;

import com.iver.cit.gvsig.fmap.drivers.DriverIOException;

import com.iver.cit.gvsig.fmap.edition.VectorialEditableAdapter;

import com.iver.cit.gvsig.fmap.layers.FBitSet;

import com.iver.cit.gvsig.fmap.layers.FLyrText;

import com.iver.cit.gvsig.fmap.layers.FLyrVect;

import com.iver.cit.gvsig.fmap.layers.LegendListener;

import com.iver.cit.gvsig.fmap.layers.XMLException;

import com.iver.cit.gvsig.fmap.layers.layerOperations.InfoByPoint;

import com.iver.cit.gvsig.fmap.operations.Cancel;

import com.iver.cit.gvsig.fmap.rendering.Legend;

import com.iver.cit.gvsig.fmap.rendering.LegendChangedEvent;

import com.iver.cit.gvsig.fmap.rendering.VectorialLegend;

import com.iver.utiles.XMLEntity;

import com.iver.utiles.connections.ConnectionException;

import com.iver.utiles.swing.threads.Cancellable;

import com.iver.utiles.swing.threads.DefaultCancellableMonitorable;

import es.prodevelop.cit.gvsig.arcims.fmap.drivers.ArcImsInMemoryAttsTableDriver;

import es.prodevelop.cit.gvsig.arcims.fmap.drivers.ArcImsVectorialAdapter;

import es.prodevelop.cit.gvsig.arcims.fmap.drivers.FMapFeatureArcImsDriver;

public class FFeatureLyrArcIMS extends FLyrVect implements InfoByPoint, LegendListener {

        // ClassifiableVectorial, Selectable, AlphanumericData, VectorialData,

        // Labelable, SingleLayer, RandomVectorialData {

        private static Logger logger = Logger.getLogger(FFeatureLyrArcIMS.class.getName());

        private URL host;

        private String service;

        private String serviceType;

        private Rectangle2D fullExtent;

        private boolean firstLoad = true;

        private ArcImsVectStatus arcimsStatus = new ArcImsVectStatus();

        private String SRS;

        private String srsAbrev;

        private String layerQuery;

        private VisualStatusArcIms visualStatus = new VisualStatusArcIms();

        private int transparency = -1;

        private boolean arcImsTransparency = true;

        private int shapeType = 0;

//        private ArrayList initialColors = new ArrayList();

        private ArrayList geometries;

        private MyCancellable myCanc;

        // from ancestor FLyrVect:

        // private VectorialAdapter source;

        // private SelectableDataSource sds; --> is created like this --> new SelectableDataSource(source.getRecordSet()) 

        /**

         * Constructor needs ArcImsVectorialAdapter.

         * 

         * @param vectAdapter

         */

        public FFeatureLyrArcIMS(VectorialEditableAdapter vectAdapter) {

                myCanc = new MyCancellable(new DefaultCancellableMonitorable());

                setSource(vectAdapter);

//                try {

//                        // setRecordset(((FMapFeatureArcImsDriver) getSource().getDriver()).getRecordSet());

//                        shapeType = vectAdapter.getShapeType();

//                        // ((VectorialLegend) getLegend()).setShapeType(shapeType);

//                } catch (Exception e) {

//                        logger.error("Unexpected error while getting shape type ", e);

//                }

                addLegendListener(this);

//                loadInitialColors();

        }

        public FFeatureLyrArcIMS() {

        }

        public void setShapeType(int shpType) {

                shapeType = shpType;

        }

        public void setAdapter(VectorialEditableAdapter edapter) {

                setSource(edapter);

                try {

                        shapeType = edapter.getShapeType();

                        // ((VectorialLegend) getLegend()).setShapeType(shapeType);

                } catch (DriverIOException e) {

                        logger.error("Unexpected error while getting shape type ", e);

                }

                addLegendListener(this);

                myCanc = new MyCancellable(new DefaultCancellableMonitorable());

//                loadInitialColors();

        }

        /*

        public void setLegend(VectorialLegend r)

                throws DriverException, FieldNotFoundException {

                VectorialLegend oldLegend = legend;

                legend = r;

                try {

                        legend.setDataSource(getRecordset());

                        if (legend.getLabelField() != null) {

                            // sds.start();

                                // int idLabelField = getRecordset().getFieldIndexByName(legend.getLabelField());

                                createLabelLayer(sds);

                                // sds.stop();

                        }

                        else

                            removeLabels();

                } catch (DriverException e) {

                        throw new DriverException(e);

                } catch (FieldNotFoundException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

        }

                LegendChangedEvent e = LegendChangedEvent.createLegendChangedEvent(oldLegend, legend);

                callLegendChanged(e);

        }

         */

//        private void loadInitialColors() {

//                // Color[] cols = 

//                initialColors.add(new Color(179, 226, 205));

//                initialColors.add(new Color(253, 205, 172));

//                initialColors.add(new Color(203, 213, 232));

//                initialColors.add(new Color(230, 245, 201));

//                initialColors.add(new Color(141, 211, 199));

//                initialColors.add(new Color(255, 255, 179));

//                initialColors.add(new Color(190, 186, 218));

//                initialColors.add(new Color(251, 128, 114));

//                initialColors.add(new Color(128, 177, 211));

//        }

        /**

         * 

         */

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

                        Cancellable cancel, double scale) throws DriverException {

                if (!isVisible()) return;

                if (!isWithinScale(scale)) return;

                // In case gvSIG calls the getVisualStatus method... (?)

                visualStatus.width = viewPort.getImageWidth();

                visualStatus.height = viewPort.getImageHeight();

                visualStatus.minX = viewPort.getAdjustedExtent().getMinX();

                visualStatus.minY = viewPort.getAdjustedExtent().getMinY();

                visualStatus.maxX = viewPort.getAdjustedExtent().getMaxX();

                visualStatus.maxY = viewPort.getAdjustedExtent().getMaxY();

                IGeometry geom, clonedGeom;

                ICoordTrans layerTransf = getCoordTrans();

                Rectangle2D bBox = viewPort.getAdjustedExtent();

                // CSV-WKT   or   LIBARCIMS

                boolean test = false;

                if (test) {

                        // -------------------------- TEST START ---------------------------------

                        // geometries = ((FMapFeatureArcImsDriver) getSource().getDriver()).getGeometries();

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

                                geom = (IGeometry) geometries.get(i);

                                if (geom.intersects(bBox)) {

                                        clonedGeom = geom.cloneGeometry();

                                        ISymbol symbol = (ISymbol) ((VectorialLegend) getLegend()).getSymbol(i);

                                        // FSymbol symbol = ((VectorialLegend) getLegend()).getSymbol(i);

                                        if (layerTransf != null) geom.reProject(layerTransf);

                                        clonedGeom.draw(g, viewPort, symbol);

                                }

                        }

                        // -------------------------- TEST END   ---------------------------------

                } else {

                        // -------------------------- NOT TEST START ---------------------------------

                        arcimsStatus.setExtent(bBox);

                        arcimsStatus.setHeight(viewPort.getImageHeight());

                        arcimsStatus.setWidth(viewPort.getImageWidth());

                        // one-item vector:

                        arcimsStatus.setLayerIds(Utilities.createVector(layerQuery, ","));

                        arcimsStatus.setServer(host.toString());

                        arcimsStatus.setService(service);

                        arcimsStatus.setSrs(this.getProjection().getAbrev());

                        arcimsStatus.setTransparency(this.arcImsTransparency);

                        FMapFeatureArcImsDriver drv = (FMapFeatureArcImsDriver) getSource().getDriver();

                        try {

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

                                // first item in query must contain ID or #ALL#

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

                                geometries = (ArrayList) drv.getMap(arcimsStatus);

                        } catch (ProtocolException e) {

                                DriverException de = new DriverException(e.getMessage());

                                logger.error("While getting map (ArrayList of geometries) ", e);

                                throw de;

                        } catch (ArcImsException e) {

                                DriverException de = new DriverException(e.getMessage());

                                logger.error("While getting map (ArrayList of geometries) ", e);

                                throw de;

                        } catch (IOException e) {

                                DriverException de = new DriverException(e.getMessage());

                                logger.error("While getting map (ArrayList of geometries) ", e);

                                throw de;

                        } 

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

                                geom = (IGeometry) ((DefaultFeature) geometries.get(i)).getGeometry();

                                if (geom == null) {

                                        logger.error("Retrieved null geometry ");

                                } else {

                                        clonedGeom = geom.cloneGeometry();

                                        int ov_index = drv.getOverallIndex(i);

                                        ISymbol symbol = (ISymbol) getSymbolOrSelected(ov_index,

                                                        (FSymbol) ((VectorialLegend) getLegend()).getSymbol(ov_index));

                                        // FSymbol symbol = getSymbolOrSelected(ov_index, ((VectorialLegend) getLegend()).getSymbol(ov_index));

                                        if (layerTransf != null)

                                                geom.reProject(layerTransf);

                                        clonedGeom.draw(g, viewPort, symbol);

                                }

                        }

                        FLyrText possibleLabels = getLayerText(); 

                        if (possibleLabels != null) {

                                possibleLabels.createLabels(this);

                                possibleLabels.draw(image, g, viewPort, cancel, scale);

                        }

                        // -------------------------- NOT TEST END   ---------------------------------

                }

        }

        private FSymbol getSymbolOrSelected(int i, FSymbol symbol) {

                boolean sel = false;

                try {

                        sel = getRecordset().getSelectionSupport().isSelected(i);

                } catch (DriverException e) {

                        logger.error("While getting selection", e);

                }

                if (sel) {

                        return new FSymbol(shapeType, Color.YELLOW);

                } else {

                        return symbol;

                }

        }

        /**

         * 

         */

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

                        double scale) throws DriverException {

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

        }

        /**

         * 

         */

        public String queryByPoint(Point p) throws DriverException {

                Point2D screenCoords, geoCoords;

                double screenTol, geoTol;

                screenCoords = new Point2D.Double(p.getX(), p.getY());

                geoCoords = new Point2D.Double(p.getX(), p.getY());

                AffineTransform af = getMapContext().getViewPort().getAffineTransform();

                try {

                        af.inverseTransform(screenCoords, geoCoords);

                } catch (NoninvertibleTransformException e) {

                        logger.error("Non invertible AffineTransform ", e);

                }

                screenTol = 2.0; geoTol = 1.0;                

                geoTol = screenTol / af.getScaleX();

                FBitSet fbs = queryByPoint(geoCoords, geoTol);

                // this invoques the client to get attrs.

                try {

                        ((ArcImsVectorialAdapter) getSource()).requestFeatureAttributes(fbs);

                } catch (ArcImsException e) {

                        DriverException de = new DriverException(e.getMessage());

                        logger.error("While querying by point ", de);

                        throw de;

                }

                String resp = getFormattedFieldsFromSetFeatures(fbs);

                System.err.println(resp); //TODO BORRAR ESTO

                return resp;

        }

        // TODO: move this to another class:

        private String getFormattedFieldsFromSetFeatures(FBitSet fbs) {

                String r = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>";

                r = r + "<FeatureInfoResponse>";

                r = r + "<LAYER ID=\"" + layerQuery + "\" NAME=\"" + getName() + "\">";

                for(int i=fbs.nextSetBit(0); i>=0; i=fbs.nextSetBit(i+1)) {

                        r = r + getFormattedFieldsFromFeature(i);

                }

                r = r + "</LAYER>";

                r = r + "</FeatureInfoResponse>";

                return r;

        }

        // TODO: move this to another class:

        private String getFormattedFieldsFromFeature(int j) {

                String r = "<FIELDS ";

                String fieldName, fieldValue;

                DataSource ds = null;

                try {

                        ds = getSource().getRecordset();

                } catch (DriverLoadException e1) {

                        logger.error("DriverException while getting field values. ", e1);

                }

                int count;

                try {

                        count = ds.getFieldCount();

                        for (int i=0; i<count; i++) {

                                fieldName = ds.getFieldName(i);

                                fieldName = ArcImsInMemoryAttsTableDriver.replaceUnwantedCharacters(fieldName);

                                fieldValue = restoreSpecialChars(ds.getFieldValue((long) j, i).toString());

                                logger.debug("fieldvalue = " + fieldValue);

                                r = r + " " + fieldName + "=" + "\"" + fieldValue + "\"";

                        }

                        // <FIELDS NOMBRE="LR-542" OBSERVACIO="" TIPO="CAUT3" _SHAPE_="[Geometry]" _ID_="1975" />

                        r = r + "/>";

                } catch (com.hardcode.gdbms.engine.data.driver.DriverException e) {

                        logger.error("DriverException while getting field values. ", e);

                }

                return r;

        }

        private String restoreSpecialChars(String str) {

                /*

                 * < 60 3c, > 62 3e, & 38 26, " 34 22, ' 39 27

                 */

                String resp = str.replaceAll("\\x26", "&");

                resp = resp.replaceAll("\\x3c", "<");

                resp = resp.replaceAll("\\x3e", ">");

                resp = resp.replaceAll("\\x22", """);

                resp = resp.replaceAll("\\x27", "'");

                return resp;

        }

        public void setInitialLegend() {

                FMapFeatureArcImsDriver drv = (FMapFeatureArcImsDriver) getSource()

                                .getDriver();

                //Try to get the legend from the service information

                try {

                        Legend initialleg = drv.getClient().getLegend(

                                        (String) this.arcimsStatus.getLayerIds().get(0));

                        if (initialleg != null) {

                                setLegend((VectorialLegend) initialleg);

                        }

                        return;

                } catch (Exception e) {

                        logger.error("While setting initial legend ", e);

                }

//                //If no legend is returned create a default legend

//                if (drv.getShapeType() == FShape.MULTIPOINT) {

//                        SingleSymbolLegend initialleg = new SingleSymbolLegend();

//                        initialleg.setShapeType(drv.getShapeType());

//                        try {

//                                setLegend(initialleg);

//                        } catch (Exception e) {

//                                logger.error("While setting initial legend ", e);

//                        }

//                        return;

//                }

//

//                try {

//                        int colorind = (int) (System.currentTimeMillis() % ((long) initialColors

//                                        .size()));

//                        FSymbol symb = new FSymbol(drv.getShapeType(),

//                                        (Color) initialColors.get(colorind));

//                        SingleSymbolLegend initialleg = new SingleSymbolLegend(symb);

//                        initialleg.setShapeType(drv.getShapeType());

//                        setLegend(initialleg);

//                } catch (FieldNotFoundException e) {

//                        logger.error("Whuile setting initial legend ", e);

//                } catch (DriverException e) {

//                        logger.error("Whuile setting initial legend ", e);

//                }

        }

        // Classifiable

        public int getShapeType() throws DriverException {

                FMapFeatureArcImsDriver drv = (FMapFeatureArcImsDriver) getSource().getDriver();

                return drv.getShapeType();

        }

        /**

         * Keeps the image's height and width or the image's tiles' height and

         * width, if any. These values are the same as the viewPort's height and

         * width,

         */

        private class VisualStatusArcIms {

                protected int width = 0, height = 0;

                protected double minX = 0D, minY = 0D, maxX = 0D, maxY = 0D;

        }

        public void setServiceInformationInStatus(ServiceInformation si) {

                this.arcimsStatus.setServiceInformation(si);

        }

        public ArcImsVectStatus getArcimsStatus() {

                return arcimsStatus;

        }

        public void setArcimsStatus(ArcImsVectStatus arcimsStatus) {

                this.arcimsStatus = arcimsStatus;

        }

        public boolean isFirstLoad() {

                return firstLoad;

        }

        public void setFirstLoad(boolean firstLoad) {

                this.firstLoad = firstLoad;

        }

        public URL getHost() {

                return host;

        }

        public void setHost(URL host) {

                this.host = host;

        }

        public String getLayerQuery() {

                return layerQuery;

        }

        public void setLayerQuery(String lQuery) {

                this.layerQuery = lQuery;

                if (layerQuery.substring(0, 1).compareTo(",") == 0)

                        layerQuery = layerQuery.substring(1);

        }

        public String getService() {

                return service;

        }

        public void setService(String service) {

                this.service = service;

        }

        public String getServiceType() {

                return serviceType;

        }

        public void setServiceType(String serviceType) {

                this.serviceType = serviceType;

        }

        public String getSRS() {

                return SRS;

        }

        public void setSRS(String srs) {

                SRS = srs;

        }

        public boolean getArcImsTransparency() {

                return arcImsTransparency;

        }

        public void setArcImsTransparency(boolean arcImsTransparency) {

                this.arcImsTransparency = arcImsTransparency;

        }

        public int getTransparency() {

                return transparency;

        }

        public void setTransparency(int transparency) {

                this.transparency = transparency;

        }

        public HashMap getProperties() {

                HashMap info = new HashMap();

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

                Vector layers = new Vector(layerNames.length);

                FMapFeatureArcImsDriver drv = (FMapFeatureArcImsDriver) getSource()

                .getDriver();

                try {

                        if (drv.connect(myCanc)) {

                                info.put("layerName", this.getName());

                                info.put("serverUrl", this.getHost());

                                info.put("serviceName", this.getService());

                                info.put("serviceType", this.getServiceType());

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

                                        layers.add(layerNames[i]);

                                info.put("layerIds", layers);

                                return info;

                        }

                } catch (Exception e) {

                        logger.error("Error in FRasterLyrArcIMS.getProperties() ", e);

                }

                return null;

        }

        public void setLayerIdsInStatus(Vector idsv) {

                arcimsStatus.setLayerIds(idsv);

        }

        public void setProjectionInStatus(String abbrev_srs) {

                arcimsStatus.setSrs(abbrev_srs);

        }

        public void setHostInStatus(URL url) {

                arcimsStatus.setServer(url.toString());

        }

        public void setServiceInStatus(String srv) {

                arcimsStatus.setService(srv);

        }

        public void setSubfieldsInStatus() {

                String[] subfields = new String[2];

                String id = (String) arcimsStatus.getLayerIds().get(0);

                ServiceInformationLayerFeatures silf = (ServiceInformationLayerFeatures) arcimsStatus.getServiceInfo().getLayerById(id);

                FieldInformation fi = (FieldInformation) silf.getFieldInformationByType(FieldInformation.ID).get(0);

                subfields[1] = fi.getName();

                fi = (FieldInformation) silf.getFieldInformationByType(FieldInformation.SHAPE).get(0);

                subfields[0] = fi.getName();

                arcimsStatus.setSubfields(subfields);

        }

        public void legendChanged(LegendChangedEvent e) {

                MapContext fmap = getMapContext();

                if (fmap != null) {

                        fmap.invalidate();

                }

        }

        public void setXMLEntity(XMLEntity xml) throws XMLException {

                try {

                        setHost(new URL(xml.getStringProperty("_host")));

                } catch (MalformedURLException e) {

                        logger.error("Bad url ", e);

                }

                setService(xml.getStringProperty("_service"));

                setLayerQuery(xml.getStringProperty("layerQuery"));

                setSrsAbrev(xml.getStringProperty("srs_abrev"));

                FMapFeatureArcImsDriver drv = new FMapFeatureArcImsDriver(host.toString(), service, layerQuery);

                if (!(drv.connect(myCanc))) {

                        throw new XMLException(new DriverException("Unable to connect to server"));

                }

                drv.setLayer(this);

                Vector ids = new Vector();

                ids.add(getLayerQuery());

                setLayerIdsInStatus(ids);

                ArcImsClientP cli = drv.getClient();

                ServiceInformation si = cli.getServiceInformation();

                arcimsStatus.setServiceInformation(si);

                String srs = getSrsAbrev();

                arcimsStatus.setSrs(srs);

                if ((si.getFeaturecoordsys() == null) || (si.getFeaturecoordsys().equals(""))) {

                        si.setFeaturecoordsys(srs.substring(ServiceInfoTags.vINI_SRS.length()).trim());

                        logger.warn("Server provides no SRS. ");

                } 

                Rectangle2D fext = null;

                try {

                        fext = ((ArcImsFeatureClient) drv.getClient()).getLayerExtent(arcimsStatus);

                } catch (Exception e) {

                        logger.error("While loading ArcIMS layer ", e);

                }

                arcimsStatus.setExtent(fext);

                drv.setFullExtent(fext);

                setSubfieldsInStatus();

                // drv.loadRecordSet();

                ArcImsVectorialAdapter oldadapter = new ArcImsVectorialAdapter(drv);

                VectorialEditableAdapter adapter = new VectorialEditableAdapter();

                String recordsetName = xml.getStringProperty("recordset-name");

                try {

                        adapter.setOriginalDataSource(drv.getRecordSet(recordsetName));

                } catch (com.hardcode.gdbms.engine.data.driver.DriverException e) {

                        logger.error("While setting original data source ", e);

                }

                adapter.setOriginalVectorialAdapter(oldadapter);

                setAdapter(adapter);

                drv.setAdapter(adapter);

                setInitialLegend();

                try {

                        setRecordset(((FMapFeatureArcImsDriver) getSource().getDriver()).getRecordSet());

                } catch (Exception e) {

                        logger.error("While setting data source ", e);

                }

                super.setXMLEntity(xml);

        }

        public XMLEntity getXMLEntity() throws XMLException {

                XMLEntity resp = super.getXMLEntity();

                // PluginServices.getMDIManager().addView(null);

                resp.putProperty("srs_abrev", getMapContext().getProjection().getAbrev());

                resp.putProperty("_host", host.toString());

                resp.putProperty("_service", service);

                resp.putProperty("layerQuery", layerQuery);

                return resp;

        }

        public String getSrsAbrev() {

                return srsAbrev;

        }

        public void setSrsAbrev(String srsAbrev) {

                this.srsAbrev = srsAbrev;

        }

        /**

         * The extCatalogYNomenclator needs this creator.

         * 

         * @param p a Map object with the following keys:

         * 

         * (key, object type returned)

         * ---------------------------

         * "host", String (with or without the servlet path)

         * "service_name", String (remote service name)

         * "srs", String (coordinate system)

         * "layer_id", String (*single* remote layer's ID)

         * "layer_name", String (local layer name)

         * 

         * @return a FRasterLyrArcIMS layer

         * @throws ConnectionException 

         */

        /*

        public FFeatureLyrArcIMS(Map m) throws ConnectionException {

                String _host = (String) m.get("host");

                try {

                        String _layer_id = (String) m.get("layer_id");

                        String _service_name = (String) m.get("service_name");

                        String _layer_name = (String) m.get("layer_name");

                        String _srs = (String) m.get("srs");

                        // ----------------------------------

                        URL _true_host = ArcImsProtocolHandler.getUrlWithServlet(new URL(_host));

                        IProjection _true_srs = CRSFactory.getCRS(_srs);

                        FMapFeatureArcImsDriver _drv = new FMapFeatureArcImsDriver(_true_host.toString(),

                                        _service_name, _layer_id);

                        if (!(_drv.connect(myCanc))) throw new Exception();

                        ArcImsVectorialAdapter _oldadapter = new ArcImsVectorialAdapter(_drv);

                        VectorialEditableAdapter _adapter = new VectorialEditableAdapter();

                        _drv.setLayer(this);

                        ServiceInformation _si = _drv.getClient().getServiceInformation();

                        ServiceInformationLayerFeatures _silf = (ServiceInformationLayerFeatures)

                        _si.getLayerById(_layer_id);

                        setProjectionInStatus(_true_srs.getAbrev());

                        setHostInStatus(_true_host);

                        setServiceInStatus(_service_name);

                        String _units = _si.getMapunits();

                        int _theDpi = _si.getScreen_dpi();

                        long _scale;

                        if (_silf.getMaxscale()!=-1) {

                                _scale = LayerScaleData.getTrueScaleFromRelativeScaleAndMapUnits(

                                                _silf.getMaxscale(), _units, _theDpi);

                                setMaxScale((double) _scale);

                        }

                        if (_silf.getMinscale()!=-1) {

                                _scale = LayerScaleData.getTrueScaleFromRelativeScaleAndMapUnits(

                                                _silf.getMinscale(), _units, _theDpi);

                                setMinScale((double) _scale);                        

                        }

                        setServiceInformationInStatus(_si);

                        Vector _ids = new Vector(); _ids.add(_layer_id);

                        setLayerIdsInStatus((Vector) _ids.clone());

                        setSubfieldsInStatus();

                        setHost(_true_host);

                        setService(_service_name);

                        setServiceType(ServiceInfoTags.vFEATURESERVICE);

                        setTransparency(0);

                        setLayerQuery(_layer_id);

                        setProjection(_true_srs);

                        setName(_layer_name);

                        Rectangle2D _fext = ((ArcImsFeatureClient)

                                        _drv.getClient()).getLayerExtent(getArcimsStatus());

                        _drv.setFullExtent(_fext);

                        // individualLayers[i].setF. setFullExtent(((ArcImsProtImageHandler) drv.getClient().getHandler()).getServiceExtent(srs, individualLayers[i].getArcimsStatus()));

                        // ------ -------------

                        _drv.setAdapter(_adapter);

                        // adapter.setRecordSet(drv.getRecordSet());

                        _adapter.setOriginalDataSource(_drv.getRecordSet());

                        _adapter.setOriginalVectorialAdapter(_oldadapter);

                        _drv.declareTable();

                        setSource(_adapter);

                        _adapter.setDriver(_drv);

                        getSource().setDriver(_drv);

                        setInitialLegend();

                        setShapeType(_adapter.getShapeType());

                        setRecordset(_drv.getRecordSet());

                        // ------ -------------

                        if ((_si.getFeaturecoordsys() == null) ||

                                        (_si.getFeaturecoordsys().equals(""))) {

                                _si.setFeaturecoordsys(_true_srs.getAbrev().substring(ServiceInfoTags.vINI_SRS.length()).trim());

                                logger.warn("Server provides no SRS. ");

                        }

                } catch (Exception e) {

                        throw new ConnectionException("Unable to connect to host " + _host, e);

                }

        }

        */

}