Application: gvSIG desktop

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2006 Prodevelop and Generalitat Valenciana.

 *

 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *   Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *   +34 963862235

 *   gvsig@gva.es

 *   www.gvsig.gva.es

 *

 *    or

 *

 *   Prodevelop Integraci?n de Tecnolog?as SL

 *   Conde Salvatierra de ?lava , 34-10

 *   46004 Valencia

 *   Spain

 *

 *   +34 963 510 612

 *   +34 963 510 968

 *   gis@prodevelop.es

 *   http://www.prodevelop.es

 */

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

import com.hardcode.driverManager.DriverLoadException;

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

import com.iver.andami.PluginServices;

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;

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 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 javax.print.attribute.PrintRequestAttributeSet;

import javax.swing.ImageIcon;

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

    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;

        IGeometry 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, PrintRequestAttributeSet properties)

        throws DriverException {

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

    }

    /**

     *

     */

    public String queryByPoint(Point p) throws DriverException {

        Point2D screenCoords;

        Point2D geoCoords;

        double screenTol;

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

        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;

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

    }

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

            }

    }

    */

    public ImageIcon getTocImageIcon() {

        ImageIcon resp = null;

        try {

            resp = createImageIcon("images/esrilogo.png");

        }

        catch (Exception ex) {

        }

        if (resp == null) {

            return super.getTocImageIcon();

        }

        else {

            return resp;

        }

    }

    protected ImageIcon createImageIcon(String path) {

        java.net.URL imgURL = createExtensionUrl(path);

        if (imgURL != null) {

            return new ImageIcon(imgURL);

        }

        else {

            logger.error("File not found: " + path);

            return null;

        }

    }

    protected java.net.URL createExtensionUrl(String path) {

        return PluginServices.getPluginServices(

            "es.prodevelop.cit.gvsig.arcims").getClassLoader().getResource(path);

        // return getClass().getClassLoader().getResource(path);

    }

    /**

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

        protected int height = 0;

        protected double minX = 0D;

        protected double minY = 0D;

        protected double maxX = 0D;

        protected double maxY = 0D;

    }

}