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.iver.andami.PluginServices;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import com.iver.utiles.StringUtilities;

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.ArcImsDriver;

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

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

import es.prodevelop.cit.gvsig.arcims.fmap.listeners.FRasterLyrArcIMSListener;

import org.apache.log4j.Logger;

import org.cresques.cts.IProjection;

import org.cresques.filter.RasterFilterStack;

import org.cresques.filter.RasterFilterStackManager;

import org.cresques.geo.ViewPortData;

import org.cresques.io.GdalFile;

import org.cresques.io.GeoRasterFile;

import org.cresques.io.data.Grid;

import org.cresques.io.exceptions.NotSupportedExtensionException;

import org.cresques.px.Extent;

import org.cresques.px.PxRaster;

import org.gvsig.remoteClient.arcims.ArcImsClientP;

import org.gvsig.remoteClient.arcims.ArcImsProtImageHandler;

import org.gvsig.remoteClient.arcims.ArcImsProtocolHandler;

import org.gvsig.remoteClient.arcims.ArcImsStatus;

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

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.ServiceInformationLayer;

import org.gvsig.remoteClient.utils.Utilities;

import org.gvsig.remoteClient.wms.ICancellable;

import java.awt.Color;

import java.awt.Dimension;

import java.awt.Graphics2D;

import java.awt.Point;

import java.awt.Rectangle;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

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.awt.image.DataBuffer;

import java.io.File;

import java.io.IOException;

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

import java.net.MalformedURLException;

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;

/**

 * This class implements an ArcIMS raster layer.

 *

 * @author jldominguez

 */

public class FRasterLyrArcIMS extends FLyrDefault implements RasterOperations,

    InfoByPoint {

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

    public static final String SCALE_CHANGED_COMMAND = "SCALE_HAS_CHANGED";

    private MyCancellable myCanc;

    private URL host;

    private String service;

    private String serviceType;

    private Rectangle2D fullExtent;

    private boolean firstLoad = false;

    private ArcImsStatus arcimsStatus = new ArcImsStatus();

    private String SRS;

    private String layerQuery;

    private ArcImsDriver driver;

    private VisualStatusArcIms visualStatus = new VisualStatusArcIms();

    private int transparency = -1;

    private boolean arcImsTransparency = true;

    private String format;

    private StatusRasterInterface status = null;

    private GeoRasterFile rasterFile = null;

    private PxRaster raster = null;

    private int rband = 0;

    private int gband = 1;

    private int bband = 2;

    private RasterFilterStackManager stackManager = null;

    private RasterFilterStack filterStack = null;

    private int posX = 0;

    private int posY = 0;

    private double posXWC = 0;

    private double posYWC = 0;

    private int r = 0;

    private int g = 0;

    private int b = 0;

    private ArrayList actionListeners = new ArrayList();

    private int maxTileWidth = 1023;

    private int maxTileHeight = 1023;

    private Grid grid = null;

    private boolean nameQueryChange = false;

    private ArrayList listeners = new ArrayList();

    private boolean tiled = false;

    private int[] tileSize = new int[2];

    private ActionEvent scaleChangedEvent = new ActionEvent(this,

            ActionEvent.ACTION_PERFORMED, SCALE_CHANGED_COMMAND);

    public FRasterLyrArcIMS() {

        myCanc = new MyCancellable(new DefaultCancellableMonitorable());

    }

    /**

     * 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, example:

     *                                         "http://www.geographynetwork.com")

     * "service_name", String (remote service name)

     * "srs", String (coordinate system)

     * "layer_name", String (local layer's name)

     *

     * @return a FRasterLyrArcIMS layer

     */

    public FRasterLyrArcIMS(Map m) throws ConnectionException {

        myCanc = new MyCancellable(new DefaultCancellableMonitorable());

        String _host = "";

        try {

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

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

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

            String _image_format = "JPG";

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

            // in case layer_name is missing or equals the empty string:

            if ((_layer_name == null) || (_layer_name.length() == 0)) {

                _layer_name = _service_name;

            }

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

            URL _true_host = ArcImsProtocolHandler.getUrlWithServlet(new URL(

                        _host));

            IProjection _true_srs = CRSFactory.getCRS(_srs);

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

                    _service_name, ServiceInfoTags.vIMAGESERVICE);

            if (!_drv.connect(myCanc)) {

                throw new ConnectionException("Unable to connect to host ",

                    new Exception(_host));

            }

            setDriver(_drv);

            setHost(_true_host);

            setService(_service_name);

            setServiceType(ServiceInfoTags.vIMAGESERVICE);

            setServiceInformationInStatus(_drv.getClient()

                                              .getServiceInformation());

            ServiceInformation _si = getArcimsStatus().getServiceInfo();

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

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

                _si.setFeaturecoordsys(_true_srs.getAbrev()

                                                .substring(ServiceInfoTags.vINI_SRS.length())

                                                .trim());

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

            }

            setFullExtent(((ArcImsProtImageHandler) _drv.getClient().getHandler()).getServiceExtent(

                    _true_srs, getArcimsStatus()));

            //  JPG

            setFormat(_image_format);

            setTransparency(0);

            // =================================== query

            int layercount = _si.getLayers().size();

            String _layer_query = "";

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

                if (isTrueString(

                            ((ServiceInformationLayer) _si.getLayer(i)).getVisible())) {

                    _layer_query = _layer_query + "," +

                        ((ServiceInformationLayer) _si.getLayer(i)).getId();

                }

            }

            if (_layer_query.length() == 0) {

                throw new Exception("No layers are visible by default ");

            }

            else {

                _layer_query = _layer_query.substring(1);

            }

            // ===================================

            setLayerQuery(_layer_query);

            setProjection(_true_srs);

            setName(_layer_name);

        }

        catch (Exception e) {

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

        }

    }

    /**

     * Gets the driver object onto which <tt>getMap()</tt> and

     * <tt>getFeatureInfo()</tt> requests are passed. If the driver was not

     * created, this methdo creates it with the server's URL and the service

     * name.

     *

     * @return the driver that actually performs the requests.

     */

    public ArcImsDriver getDriver() {

        if (driver == null) {

            driver = new FMapRasterArcImsDriver(host.toString(), service,

                    this.serviceType);

        }

        return driver;

    }

    public void setDriver(FMapRasterArcImsDriver d) {

        driver = d;

    }

    /**

     * Gets the transformation matrix to be written in the georeference file.

     * The second and the third coefficients will always be zero (it doesn't

     * implement image rotation)

     *

     * @param bBox

     *            Image's size and position (user's coordinates)

     * @param sz

     *            Images' size in pixels

     * @return the worldfile, as a String

     * @throws IOException

     */

    public String getDataWorldFile(Rectangle2D bBox, Dimension sz)

        throws IOException {

        StringBuffer data = new StringBuffer();

        data.append(((bBox.getMaxX() - bBox.getMinX()) / (sz.getWidth() - 1)) +

            "\n");

        data.append("0.0\n");

        data.append("0.0\n");

        data.append("-" +

            ((bBox.getMaxY() - bBox.getMinY()) / (sz.getHeight() - 1)) + "\n");

        // guardalo por si acaso :)

        // data.append((bBox.getMaxY() - bBox.getMinY()) / (sz.getHeight() - 1) + "\n");

        data.append("" + bBox.getMinX() + "\n");

        // data.append("" + bBox.getMinY() + "\n");

        data.append("" + bBox.getMaxY() + "\n");

        return data.toString();

    }

    /**

     * Gets the raster status

     *

     * @return the raster status

     */

    public StatusRasterInterface getStatus() {

        return this.status;

    }

    public void setStatus(StatusRasterInterface s) {

        this.status = s;

    }

    /**

     * This method must be invoqued with <b>true</b> if the layer must show its

     * transparency. The level of transparency is set by another method.

     *

     * @param t

     *            Whether or not the transparency must be shown.

     */

    public void setArcImsTransparency(boolean t) {

        this.arcImsTransparency = t;

    }

    /**

     * Drawing method invoqued from outside the plugin.

     *

     * @param g

     *            graphic object on which drawing is made.

     * @param vp

     *            the view

     * @param cancel

     *            allows drawing abortion

     * @throws DriverException

     */

    private void drawTile(Graphics2D g, ViewPort vp, Cancellable cancel)

        throws DriverException {

        // This is the extent that will be requested

        Rectangle2D bBox = vp.getAdjustedExtent(); // getFullExtent();

        Dimension sz = vp.getImageSize();

        try {

            arcimsStatus.setExtent(bBox);

            arcimsStatus.setFormat(getFormat());

            arcimsStatus.setHeight(vp.getImageHeight());

            arcimsStatus.setWidth(vp.getImageWidth());

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

            arcimsStatus.setServer(host.toString());

            arcimsStatus.setService(service);

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

            arcimsStatus.setTransparency(this.arcImsTransparency);

            // We need to cast because driver returns an Object

            File f = (File) getDriver().getMap(arcimsStatus);

            int lastp = f.getPath().lastIndexOf(".");

            String noext = f.getPath().substring(0, lastp);

            String nameWorldFile = noext + getExtensionWordFile(getFormat());

            com.iver.andami.Utilities.createTemp(nameWorldFile,

                this.getDataWorldFile(bBox, sz));

            // ------------------------------ START

            ViewPortData vpData = new ViewPortData(vp.getProjection(),

                    new Extent(bBox), sz);

            vpData.setMat(vp.getAffineTransform());

            // ------------------------------ END

            rasterProcess(g, vpData, f);

        }

        catch (IOException e) {

            DriverException de = new DriverException("connect_error");

            logger.error("While connecting ", e);

            throw de;

        }

        catch (ArcImsException e) {

            logger.error("While drawing ", e);

            this.setVisible(false);

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

            throw de;

        }

    }

    /**

     * Drawing method invoqued from gvSIG to draw this layer. Uses a <tt>Tiling</tt>

     * object to prevent downloading images too large to be retrieved

     * (pixel count limit)

     *

     * @param image

     *            used to speed up drawing process

     * @param g

     *            graphic object on which drawing is make

     * @param viewPort

     *            the view's properties

     * @param cancel

     *            allows drawing abortion

     * @param scale the current scale

     *

     * @throws DriverException

     */

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

        Cancellable cancel, double scale) throws DriverException {

        if (!isVisible()) {

            return;

        }

        if (!isWithinScale(scale)) {

            return;

        }

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

        setTileDimensions(viewPort);

        Point2D p = viewPort.getOffset();

        Rectangle r = new Rectangle((int) p.getX(), (int) p.getY(),

                viewPort.getImageWidth() - 1, viewPort.getImageHeight() - 1);

        Tiling tiles = new Tiling(maxTileWidth, maxTileHeight, r);

        tiles.setAffineTransform((AffineTransform) viewPort.getAffineTransform()

                                                           .clone());

        tiled = false;

        if (tiles.getNumTiles() > 1) {

            tiled = true;

            tileSize[0] = tiles.getMaxTileWidth();

            tileSize[1] = tiles.getMaxTileHeight();

        }

        for (int tileNr = 0; tileNr < tiles.getNumTiles(); tileNr++) {

            // drawing part

            try {

                ViewPort vp = tiles.getTileViewPort(viewPort, tileNr);

                drawTile(g, vp, cancel);

            }

            catch (NoninvertibleTransformException e) {

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

            }

        }

        // the status needs to be reset because the drawTile

        // method had changed its extent and dimension:

        arcimsStatus.setExtent(viewPort.getAdjustedExtent());

        arcimsStatus.setHeight(viewPort.getImageHeight());

        arcimsStatus.setWidth(viewPort.getImageWidth());

        callActionListeners(scaleChangedEvent);

        if (nameQueryChange) {

            callNameOrQueryListeners();

            nameQueryChange = false;

        }

    }

    private void setTileDimensions(ViewPort vp) {

        maxTileHeight = vp.getImageHeight();

        try {

            maxTileWidth = Integer.parseInt(arcimsStatus.getServiceInfo()

                                                        .getImagelimit_pixelcount()) / maxTileHeight;

            maxTileWidth--;

        }

        catch (NumberFormatException nfe) {

            logger.error("getImagelimit_pixelcount() returned a non parseable string. maxTileWidth was set to 100.",

                nfe);

            maxTileWidth = 100;

        }

        logger.info("Tile size = [ " + maxTileWidth + " , " + maxTileHeight +

            " ]");

    }

    /**

     * Gets the georeference file extension depending on the image's format.

     *

     * @param f

     *            raster file format

     * @return georeference file extension (".wld", ".tfw", etc)

     */

    private String getExtensionWordFile(String f) {

        String extWorldFile = ".wld";

        if (f.equals("tif") || f.equals("tiff")) {

            extWorldFile = ".tfw";

        }

        if (f.equals("jpeg")) {

            extWorldFile = ".jpgw";

        }

        return extWorldFile;

    }

    /**

     * Draws an image using PxRaster

     *

     * @param g

     *            graphics object on which drawing will be made

     * @param vpData

     *            viewport's properties

     * @param file

     *            the image file

     */

    private void rasterProcess(Graphics2D g, ViewPortData vpData, File file) {

        // PxRaster is created

        try {

            rasterFile = new GdalFile(vpData.getProjection(),

                    file.getAbsolutePath());

        }

        catch (NotSupportedExtensionException ex) {

            logger.error("While creating GdalFile: " + ex.getMessage(), ex);

        }

        raster = new PxRaster(rasterFile, null, rasterFile.getExtent());

        grid = new Grid(rasterFile);

        grid.addRenderizer(raster);

        if ((status != null) && firstLoad) {

            status.applyStatus(this);

            firstLoad = false;

        }

        if (this.filterStack != null) {

            raster.filterStack = this.filterStack;

        }

        raster.setTransparency(false);

        if ((this.transparency == -1) && !firstLoad) {

            ;

        }

        else

        {

            raster.setTransparency(this.transparency);

        }

        raster.setBand(GeoRasterFile.RED_BAND, rband);

        raster.setBand(GeoRasterFile.GREEN_BAND, gband);

        raster.setBand(GeoRasterFile.BLUE_BAND, bband);

        if (this.stackManager != null) {

            raster.setStackManager(this.stackManager);

        }

        if (visualStatus != null) {

            visualStatus.bandCount = raster.getBandCount();

            visualStatus.dataType = raster.getDataType();

        }

        raster.draw(g, vpData);

        // We get the Stack Manager with the first pxRaster of an image

        // so we can modify it afterwards from the properties dialog

        if (this.stackManager == null) {

            this.stackManager = raster.getStackManager();

        }

        if (this.filterStack == null) {

            this.filterStack = raster.filterStack;

        }

    }

    public void repaintRaster(Graphics2D g, ViewPortData vpData, File file) {

        rasterProcess(g, vpData, file);

    }

    public String getFormat() {

        return format;

    }

    public void setFormat(String format) {

        this.format = format;

    }

    /**

     * Gets a series of attributes that describe the layer's raster: Filename,

     * Filesize, Height, Width and Bands.

     *

     * @return A list of 2-element arrays { "Attribute name" , Value }

     */

    public ArrayList getAttributes() {

        if (rasterFile != null) {

            ArrayList attr = new ArrayList();

            Object[][] a = {

                    {

                        "Filename",

                        rasterFile.getName()

                                  .substring(rasterFile.getName()

                                                       .lastIndexOf("/") + 1,

                            rasterFile.getName().length())

                    },

                    { "Filesize", new Long(rasterFile.getFileSize()) },

                    {

                        "Width",

                        new Integer((new Double(this.getWidth())).intValue())

                    },

                    {

                        "Height",

                        new Integer((new Double(this.getHeight())).intValue())

                    },

                    { "Bands", new Integer(rasterFile.getBandCount()) }

                };

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

                attr.add(a[i]);

            }

            return attr;

        }

        return null;

    }

    /**

     *

    /**

     * Invoqued from gvSIG to draw this layer on a printable map. Uses a

     * <tt>Tiling</tt> object to prevent downloading images too large to be

     * retrieved (pixel count limit).

     *

     * @param g

     *            graphic object on which drawing is make

     * @param viewPort

     *            the view's properties

     * @param cancel

     *            allows drawing abortion

     * @param scale the current scale

     *

     * @throws DriverException

     */

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

        double scale, PrintRequestAttributeSet properties)

        throws DriverException {

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

    }

    public HashMap getProperties() {

        HashMap info = new HashMap();

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

        Vector layers = new Vector(layerNames.length);

        try {

            if (((FMapRasterArcImsDriver) getDriver()).connect(myCanc)) {

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

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

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

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

                info.put("format", this.format);

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

                    layers.add(layerNames[i]);

                info.put("layerIds", layers);

                return info;

            }

        }

        catch (Exception e) {

            logger.error("Error while reading FRasterLyrArcIMS properties. ", e);

        }

        return null;

    }

    public RasterFilterStack getFilterStack() {

        if (raster != null) {

            return raster.filterStack;

        }

        return null;

    }

    public double getHeight() {

        return visualStatus.height;

    }

    public double getMaxX() {

        return visualStatus.maxX;

    }

    public double getMaxY() {

        return visualStatus.maxY;

    }

    public double getMinX() {

        return visualStatus.minX;

    }

    public double getMinY() {

        return visualStatus.minY;

    }

    public int[] getPixel(double wcx, double wcy) {

        if (getPxRaster() != null) {

            return getPxRaster().getPixel(wcx, wcy);

        }

        return null;

    }

    public RasterAdapter getSource() {

        return null;

    }

    public double getWidth() {

        return visualStatus.width;

    }

    public void setBand(int flag, int nBand) {

        switch (flag) {

        case GeoRasterFile.RED_BAND:

            setBandR(nBand);

            break;

        case GeoRasterFile.GREEN_BAND:

            setBandG(nBand);

            break;

        case GeoRasterFile.BLUE_BAND:

            setBandB(nBand);

            break;

        }

    }

    public void setFilterStack(RasterFilterStack stack) {

        this.filterStack = stack;

    }

    public void setPos(int x, int y) {

        this.posX = x;

        this.posY = y;

    }

    public void setPosWC(double x, double y) {

        this.posXWC = x;

        this.posYWC = y;

    }

    public void setRGB(int r, int g, int b) {

        this.r = r;

        this.g = g;

        this.b = b;

    }

    public Color getRGB() {

        return new Color(r, g, b);

    }

    public void setSource(RasterAdapter ra) {

    }

    /**

     * @return Returns the raster.

     */

    public PxRaster getPxRaster() {

        return raster;

    }

    /**

     * @return Returns the rasterFile.

     */

    public GeoRasterFile getGeoRasterFile() {

        return rasterFile;

    }

    /**

     * Sets the R-band.

     *

     * @param r

     */

    public void setBandR(int r) {

        this.rband = r;

    }

    /**

     * Sets the G-band.

     *

     * @param g

     */

    public void setBandG(int g) {

        this.gband = g;

    }

    /**

     * Sets the B-band.

     *

     * @param b

     */

    public void setBandB(int b) {

        this.bband = b;

    }

    /**

     *

     * @return XMLEntity.

     * @throws XMLException

     */

    public XMLEntity getXMLEntity() throws XMLException {

        XMLEntity xml = super.getXMLEntity();

        xml.putProperty("fullExtent", StringUtilities.rect2String(fullExtent));

        xml.putProperty("host", host.toExternalForm());

        xml.putProperty("serviceName", service);

        xml.putProperty("serviceType", serviceType);

        xml.putProperty("layerQuery", layerQuery);

        xml.putProperty("format", format);

        if (status != null) {

            status.getXMLEntity(xml, true, this);

        }

        else {

            status = new StatusLayerRaster();

            status.getXMLEntity(xml, true, this);

        }

        xml.putProperty("arcims_transparency", arcImsTransparency);

        return xml;

    }

    /**

     *

     * @param xml

     *            XMLEntity

     *

     * @throws XMLException

     * @throws DriverException

     * @throws DriverIOException

     */

    public void setXMLEntity(XMLEntity xml) throws XMLException {

        super.setXMLEntity(xml);

        fullExtent = StringUtilities.string2Rect(xml.getStringProperty(

                    "fullExtent"));

        try {

            host = new URL(xml.getStringProperty("host"));

        }

        catch (MalformedURLException e) {

            logger.error("Whle reading XML file ", e);

            throw new XMLException(e);

        }

        this.layerQuery = xml.getStringProperty("layerQuery");

        this.service = xml.getStringProperty("serviceName");

        this.serviceType = xml.getStringProperty("serviceType");

        this.format = xml.getStringProperty("format");

        FMapRasterArcImsDriver drv = new FMapRasterArcImsDriver(host.toString(),

                service, serviceType);

        if (!drv.connect(myCanc)) {

            logger.error("Error while loading service information. ");

        }

        ArcImsClientP cli = (ArcImsClientP) drv.getClient();

        ServiceInformation si = cli.getServiceInformation();

        this.arcimsStatus.setServiceInformation(si);

        if (xml.contains("arcims_transparency")) {

            this.arcImsTransparency = xml.getBooleanProperty(

                    "arcims_transparency");

        }

        String claseStr = StatusLayerRaster.defaultClass;

        if (xml.contains("raster.class")) {

            claseStr = xml.getStringProperty("raster.class");

        }

        if (status != null) {

            status.setXMLEntity(xml, this);

        }

        else {

            // When we load a project

            if ((claseStr != null) && !claseStr.equals("")) {

                try {

                    Class clase = Class.forName(claseStr);

                    Constructor constr = clase.getConstructor(null);

                    status = (StatusRasterInterface) constr.newInstance(null);

                    if (status != null) {

                        status.setXMLEntity(xml, this);

                    }

                }

                catch (ClassNotFoundException exc) {

                    logger.error("Whle reading XML file ", exc);

                }

                catch (InstantiationException exc) {

                    logger.error("Whle reading XML file ", exc);

                }

                catch (IllegalAccessException exc) {

                    logger.error("Whle reading XML file ", exc);

                }

                catch (NoSuchMethodException exc) {

                    logger.error("Whle reading XML file ", exc);

                }

                catch (InvocationTargetException exc) {

                    logger.error("Whle reading XML file ", exc);

                }

            }

        }

        firstLoad = true;

    }

    public Vector getLayerScaleInfoVector() {

        Vector v = new Vector();

        String id;

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

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

            v.add(getScaleInfo(id));

        }

        return v;

    }

    public LayerScaleData getScaleInfo(String theId) {

        ServiceInformation si;

        ServiceInformationLayer sil;

        int noflayers;

        long true_max_scale;

        long true_min_scale;

        LayerScaleData theLayerScaleData = null;

        si = arcimsStatus.getServiceInfo();

        int _dpi = si.getScreen_dpi();

        String mapUnits = si.getMapunits();

        noflayers = si.getLayers().size();

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

            sil = (ServiceInformationLayer) si.getLayer(i);

            if ((sil.getId().compareTo(theId)) == 0) {

                true_max_scale = LayerScaleData.getTrueScaleFromRelativeScaleAndMapUnits(sil.getMaxscale(),

                        mapUnits, _dpi);

                true_min_scale = LayerScaleData.getTrueScaleFromRelativeScaleAndMapUnits(sil.getMinscale(),

                        mapUnits, _dpi);

                theLayerScaleData = new LayerScaleData(sil.getName(),

                        sil.getId(), true_min_scale, true_max_scale,

                        sil.getType());

            }

        }

        return theLayerScaleData;

    }

    public void addActionlistener(ActionListener al) {

        if (actionListeners.contains(al)) {

            return;

        }

        actionListeners.add(al);

    }

    public void removeActionlistener(ActionListener al) {

        actionListeners.remove(al);

    }

    private void callActionListeners(ActionEvent ae) {

        ActionListener al;

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

            al = (ActionListener) actionListeners.get(i);

            al.actionPerformed(ae);

        }

    }

    public long getScale() {

        return getMapContext().getScaleView();

    }

    public int getMaxTileHeight() {

        return maxTileHeight;

    }

    public void setMaxTileHeight(int maxTileHeight) {

        this.maxTileHeight = maxTileHeight;

    }

    public int getMaxTileWidth() {

        return maxTileWidth;

    }

    public void setMaxTileWidth(int maxTileWidth) {

        this.maxTileWidth = maxTileWidth;

    }

    public void setServiceInformationInStatus(ServiceInformation si) {

        this.arcimsStatus.setServiceInformation(si);

    }

    /**

     * This is the <tt>getDriver</tt> method. The <tt>getDriver</tt>

     * method will be implemented by sub-classes.

     *

     * @param d the new driver.

     */

    public void setDriver(ArcImsDriver d) {

        driver = d;

    }

    public ArcImsStatus getArcimsStatus() {

        return arcimsStatus;

    }

    public void setArcimsStatus(ArcImsStatus 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 void setFullExtent(Rectangle2D fullExtent) {

        this.fullExtent = fullExtent;

    }

    public Rectangle2D getFullExtent() {

        return fullExtent;

    }

    public boolean getArcImsTransparency() {

        return arcImsTransparency;

    }

    public int getTransparency() {

        return transparency;

    }

    public void setTransparency(int transparency) {

        this.transparency = transparency;

    }

    public int getPosX() {

        return posX;

    }

    public void setPosX(int posX) {

        this.posX = posX;

    }

    public double getPosXWC() {

        return posXWC;

    }

    public void setPosXWC(double posXWC) {

        this.posXWC = posXWC;

    }

    public int getPosY() {

        return posY;

    }

    public void setPosY(int posY) {

        this.posY = posY;

    }

    public double getPosYWC() {

        return posYWC;

    }

    public void setPosYWC(double posYWC) {

        this.posYWC = posYWC;

    }

    public void setFormatInStatus(String imgFormat) {

        arcimsStatus.setFormat(imgFormat);

    }

    /**

     * This method invoques the <tt>FMapRasterArcImsDriver</tt>'s

     * <tt>getFeatureInfo</tt> method with the given coordinates as a

     * parameter

     *

     * @param p

     *            the corrdinates of the screen pixel to be queried

     *

     * @return the data retrieved for that pixel

     * @throws DriverException

     */

    public XMLItem[] getInfo(Point p, double tolerance, Cancellable cancel)

        throws DriverException {

        StringXMLItem[] resp = new StringXMLItem[1];

        String respStr;

        if (((FMapRasterArcImsDriver) driver).isQueryable()) {

            try {

                respStr = ((FMapRasterArcImsDriver) driver).getFeatureInfo(arcimsStatus,

                        (int) p.getX(), (int) p.getY(), Integer.MAX_VALUE);

            }

            catch (ArcImsException e) {

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

                logger.error("In query by point ", e);

                throw de;

            }

        }

        else {

            DriverException de = new DriverException("layer_not_queriable");

            throw de;

        }

        resp[0] = new StringXMLItem(respStr, this);

        return resp;

    }

    public boolean isTiled() {

        return tiled;

    }

    public int[] getTileSize() {

        return tileSize;

    }

    private boolean isTrueString(String visible) {

        if (visible.compareToIgnoreCase("true") == 0) {

            return true;

        }

        return false;

    }

    public void callNameOrQueryListeners() {

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

            ((FRasterLyrArcIMSListener) listeners.get(i)).thingsHaveChanged(getLayerQuery(),

                getName());

        }

    }

    public void addNameOrQueryListener(FRasterLyrArcIMSListener l) {

        if (!listeners.contains(l)) {

            listeners.add(l);

        }

    }

    public void removeNameOrQueryListener(FRasterLyrArcIMSListener l) {

        listeners.remove(l);

    }

    public void setNameQueryChange(boolean c) {

        nameQueryChange = c;

    }

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

    }

    public int getDataType() {

        return rasterFile.getDataType();