Application: gvSIG desktop

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

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 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 org.apache.log4j.Logger;

import org.cresques.geo.ViewPortData;

import org.cresques.io.GdalFile;

import org.cresques.io.GeoRasterFile;

import org.cresques.cts.IProjection;

import org.cresques.filter.RasterFilterStack;

import org.cresques.filter.RasterFilterStackManager;

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 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 org.gvsig.remoteClient.wms.ICancellable;

/**

 * This class implements an ArcIMS raster layer.

 * 

 * @author jldominguez

 */

public class FRasterLyrArcIMS extends FLyrDefault implements RasterOperations, InfoByPoint {

        private MyCancellable myCanc;

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

        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, gband = 1, bband = 2;

        private RasterFilterStackManager stackManager = null;

        private RasterFilterStack filterStack = null;

        private int posX = 0, posY = 0;

        private double posXWC = 0, posYWC = 0;

        private int r = 0, g = 0, b = 0;

        private ArrayList actionListeners = new ArrayList();

        private int maxTileWidth = 1023;

        private int maxTileHeight = 1023;

        private boolean nameQueryChange = false;

        private ArrayList listeners = new ArrayList();

        private boolean tiled = false;

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

        public static final String SCALE_CHANGED_COMMAND = "SCALE_HAS_CHANGED";

        private ActionEvent scaleChangedEvent = new ActionEvent(this, ActionEvent.ACTION_PERFORMED, SCALE_CHANGED_COMMAND);

        public FRasterLyrArcIMS() {

                myCanc = new MyCancellable(new DefaultCancellableMonitorable());

        }

        /**

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

                        if (status != null && firstLoad) {

                                status.applyStatus(this);

                                firstLoad = false;

                        }

                        // And finally, obtain the extent intersecting the view and the BBox

                        // to draw to.

                        // ------------------------------ START (?)

                        // Rectangle2D extent = new Rectangle2D.Double();

                        // Rectangle2D.intersect(vp.getAdjustedExtent(), bBox, extent);

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

                        // new Extent(extent), sz);

                        // vpData.setMat(vp.getAffineTransform());

                        // ------------------------------ END (?)

                        // ------------------------------ 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

                rasterFile = new GdalFile(vpData.getProjection(), file

                                .getAbsolutePath());

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

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

        }

        private class VisualStatusArcIms {

                /**

                 * Ancho y alto de la imagen o del conjunto de tiles si los tiene. Coincide con 

                 * el ancho y alto del viewPort

                 */

                private        int                                                        width = 0, height = 0;

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

                private int                                                 bandCount = 0;

                private int                                                        dataType = DataBuffer.TYPE_UNDEFINED;

        }

        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;

                }

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

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

                return resp;

        }

        public boolean isTiled() {

                return tiled;

        }

        public int[] getTileSize() {

                return tileSize;

        }

        /**

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

                }

        }        

        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;

        }

}