| gvSIG desktop 1

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

*

* Copyright (C) 2004 IVER T.I. 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

*

*   IVER T.I. S.A

*   Salamanca 50

*   46005 Valencia

*   Spain

*

*   +34 963163400

*   dac@iver.es

*/

package com.iver.cit.gvsig.fmap.layers;

import java.awt.Component;

import java.awt.Dimension;

import java.awt.Graphics2D;

import java.awt.Point;

import java.awt.Rectangle;

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

import java.util.Iterator;

import java.util.Map;

import java.util.Vector;

import javax.swing.ImageIcon;

import javax.swing.JOptionPane;

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.px.Extent;

import org.cresques.px.PxRaster;

import org.exolab.castor.xml.ValidationException;

import org.gvsig.remoteClient.utils.Utilities;

import org.gvsig.remoteClient.wms.ICancellable;

import org.gvsig.remoteClient.wms.WMSStatus;

import com.iver.andami.PluginServices;

import com.iver.andami.messages.NotificationManager;

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

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

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

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

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

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

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

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

import com.iver.cit.gvsig.fmap.drivers.wms.FMapWMSDriver;

import com.iver.cit.gvsig.fmap.drivers.wms.FMapWMSDriverFactory;

import com.iver.cit.gvsig.fmap.drivers.wms.WMSException;

import com.iver.cit.gvsig.fmap.layers.WMSLayerNode.FMapWMSStyle;

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.cit.gvsig.fmap.rendering.XmlBuilder;

import com.iver.cit.gvsig.wmc.WebMapContextTags;

import com.iver.utiles.StringUtilities;

import com.iver.utiles.XMLEntity;

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

/**

* FMap's WMS Layer class.

*

* @author Jaume Dominguez Faus

*                   Nacho Brodin

*

*/

public class FLyrWMS extends FLyrDefault implements InfoByPoint, RasterOperations {

        private boolean                                         isPrinting = false;

        private boolean                                         mustTileDraw = true;

        private boolean                                         mustTilePrint = true;

        private final int                                         maxTileDrawWidth = 1023;

        private final int                                         maxTileDrawHeight = 1023;

        private final int                                         maxTilePrintWidth = 1023;

        private final int                                         maxTilePrintHeight = 1023;

        private final int                                        minTilePrintWidth = 12;

        private final int                                        minTilePrintHeight = 12;

    public URL                                                         host;

    public String                                                 m_Format;

        private String                                                 m_SRS;

        private String                                                 layerQuery;

        private String                                                 infoLayerQuery;

        private FMapWMSDriver                                 wms;

        private WMSStatus                                         wmsStatus = new WMSStatus();

        private Rectangle2D                                 fullExtent;

        private boolean                                                wmsTransparency;

    private Vector                                                 styles;

    private Vector                                                 dimensions;

        private StatusRasterInterface                status = null;

        private int                                                 posX = 0, posY = 0;

        private double                                                 posXWC = 0, posYWC = 0;

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

        private GeoRasterFile                                 rasterFile = null;

        private PxRaster                                         raster = null;

        private RasterFilterStack                         filterStack = null;

        private boolean                                                firstLoad = false;

        private int                                                 transparency = -1;

        private int                                                 rband = 0, gband = 1, bband = 2;

        private RasterFilterStackManager        stackManager = null;

        private Hashtable                                         onlineResources = new Hashtable();

        private Dimension                                         fixedSize;

        private boolean                                         queryable = true;

        private VisualStatusWMS                                visualStatus = new VisualStatusWMS();

        private class MyCancellable implements ICancellable

        {

                private Cancellable original;

                public MyCancellable(Cancellable cancelOriginal)

                {

                        this.original = cancelOriginal;

                }

                public boolean isCanceled() {

                        return original.isCanceled();

                }

        }

        public FLyrWMS(){

                super();

        }

        public FLyrWMS(Map args) throws DriverIOException{

                FMapWMSDriver drv = null;

                String host = (String)args.get("host");

                String sLayer = (String)args.get("layer");

                Rectangle2D fullExtent = (Rectangle2D)args.get("FullExtent");

                String sSRS = (String)args.get("SRS");

                String sFormat = (String)args.get("Format");

                String[] sLayers = sLayer.split(",");

                try {

                        this.setHost(new URL(host));

                } catch (MalformedURLException e) {

                        //e.printStackTrace();

                        throw new DriverIOException("Malformed host URL, '" + host + "' (" + e.toString() + ").");

                }

                try {

                        drv = this.getDriver();

                } catch (Exception e) {

                        // e.printStackTrace();

                        throw new DriverIOException("Can't get driver to host '" + host + "' (" + e.toString() + ").");

                }

                if( sFormat == null || sSRS == null || fullExtent == null ) {

                        if (!drv.connect(null))

                                throw new DriverIOException("Can't connect to host '" + host + "'.");

                        WMSLayerNode wmsNode = drv.getLayer(sLayer);

                        if (wmsNode == null){

                                throw new DriverIOException("The server '" + host + "' doesn't has the layer '" + sLayer + "'.");

                        }

                        if( sFormat == null ) {

                                sFormat = this.getGreatFormat(drv.getFormats());

                        }

                     if( sSRS == null ) {

                             sSRS = (String)wmsNode.getAllSrs().get(0);

                     }

                        if( fullExtent == null ) {

                                fullExtent = drv.getLayersExtent(sLayers,(String)wmsNode.getAllSrs().get(0));

                        }

                }

                this.setFullExtent(fullExtent);

                this.setFormat(sFormat);

                this.setLayerQuery(sLayer);

                this.setInfoLayerQuery("");

                this.setSRS(sSRS);

                this.setName(sLayer);

        }

        /**

         * It choose the best format to load different maps if the server

         * supports it. This format could be png, because it supports

         * transparency.

         * @param formats

         * Arraywith all the formats supported by the server

         * @return

         */

        private String getGreatFormat(Vector formats){

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

                String format = (String) formats.get(i);

                    if (format.equals("image/jpg")){

                    return format;

                    }

                    if (format.equals("image/jpeg")){

                    return format;

                    }

            }

            return (String)formats.get(0);

        }

        /**

         * Clase que contiene los datos de visualizaci?n de WMS.

         * @author Nacho Brodin (brodin_ign@gva.es)

         */

        private class VisualStatusWMS{

                /**

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

        }

        /**

         * Devuelve el XMLEntity con la informaci?n necesaria para reproducir la

         * capa.

         *

         * @return XMLEntity.

         * @throws XMLException

         */

        public XMLEntity getXMLEntity() throws XMLException {

                XMLEntity xml = super.getXMLEntity();

                // Full extent

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

                // Host

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

                // Part of the query that is not the host, or the

                // layer names, or other not listed bellow

                xml.putProperty("infoLayerQuery", infoLayerQuery);

                // Part of the query containing the layer names

                xml.putProperty("layerQuery", layerQuery);

                // Format

                xml.putProperty("format", m_Format);

                // SRS

                xml.putProperty("srs", m_SRS);

                if (status!=null)

                        status.getXMLEntity(xml, true, this);

                else{

                        status = new StatusLayerRaster();

                        status.getXMLEntity(xml, true, this);

                }

        // Transparency

        xml.putProperty("wms_transparency", wmsTransparency);

        // Styles

        if (styles!=null){

            String stylePr = "";

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

                stylePr += (String) styles.get(i);

                if (i<styles.size()-1)

                    stylePr += ",";

            }

            if (stylePr.endsWith(","))

                    stylePr += " ";

            xml.putProperty("styles", stylePr);

        }

        // Dimensions

        if (dimensions!=null){

            String dim = "";

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

                dim += (String) dimensions.get(i);

                if (i<dimensions.size()-1)

                    dim += ",";

            }

            if (dim.endsWith(","))

                    dim += " ";

            xml.putProperty("dimensions", dim);

        }

        // OnlineResources

        Iterator it = onlineResources.keySet().iterator();

        String strOnlines = "";

        while (it.hasNext()) {

                String key = (String) it.next();

                String value = (String) onlineResources.get(key);

                strOnlines = key+"~##SEP2##~"+value;

                if (it.hasNext())

                        strOnlines += "~##SEP1##~";

        }

        xml.putProperty("onlineResources", strOnlines);

        // Queryable

        xml.putProperty("queryable", queryable);

        // fixedSize

        if (isSizeFixed()) {

                xml.putProperty("fixedSize", true);

                xml.putProperty("fixedWidth", fixedSize.width);

                xml.putProperty("fixedHeight", fixedSize.height);

        }

        return xml;

        }

        /**

         * A partir del XMLEntity reproduce la capa.

         *

         * @param xml XMLEntity

         *

         * @throws XMLException

         * @throws DriverException

         * @throws DriverIOException

         */

        public void setXMLEntity03(XMLEntity xml)

                throws XMLException {

                super.setXMLEntity(xml);

                fullExtent = StringUtilities.string2Rect(xml.getStringProperty(

                                        "fullExtent"));

                try {

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

                } catch (MalformedURLException e) {

                        throw new XMLException(e);

                }

                infoLayerQuery = xml.getStringProperty("infoLayerQuery");

                layerQuery = xml.getStringProperty("layerQuery");

                m_Format = xml.getStringProperty("format");

                m_SRS = xml.getStringProperty("srs");

        }

        /**

         * A partir del XMLEntity reproduce la capa.

         *

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

                // Host

                try {

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

                } catch (MalformedURLException e) {

                        throw new XMLException(e);

                }

                // Part of the query that is not the host, or the

                // layer names, or other not listed bellow

                infoLayerQuery = xml.getStringProperty("infoLayerQuery");

                // Part of the query containing the layer names

                layerQuery = xml.getStringProperty("layerQuery");

                // Format

                m_Format = xml.getStringProperty("format");

                // SRS

                m_SRS = xml.getStringProperty("srs");

                String claseStr = StatusLayerRaster.defaultClass;

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

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

                }

                // Transparency

        if (xml.contains("wms_transparency"))

            wmsTransparency = xml.getBooleanProperty("wms_transparency");

        // Styles

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

            styles = new Vector();

            String[] stl = xml.getStringProperty("styles").split(",");

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

                    if (stl[i].equals(" "))

                            stl[i]="";

                styles.add(stl[i]);

            }

        }

        // Dimensions

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

            dimensions = new Vector();

            String[] dims = xml.getStringProperty("dimensions").split(",");

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

                    if (dims[i].equals(" "))

                            dims[i]="";

                dimensions.add(dims[i]);

            }

        }

        // OnlineResources

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

                String[] operations = xml.getStringProperty("onlineResources").split("~##SEP1##~");

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

                                String[] resources = operations[i].split("~##SEP2##~");

                                if (resources.length==2 && resources[1]!="")

                                        onlineResources.put(resources[0], resources[1]);

                        }

        }

        // Queryable

        queryable = true; // let's assume that the layer is queryable by default

        if (xml.contains("queryable"))

                queryable = xml.getBooleanProperty("queryable");

        // fixedSize

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

                fixedSize = new Dimension(xml.getIntProperty("fixedWidth"),

                                                  xml.getIntProperty("fixedHeight"));

        }

                if(status!=null)

                        status.setXMLEntity(xml, this);

                else{

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

                                        exc.printStackTrace();

                                }catch(InstantiationException exc){

                                        exc.printStackTrace();

                                }catch(IllegalAccessException exc){

                                        exc.printStackTrace();

                                }catch(NoSuchMethodException exc){

                                        exc.printStackTrace();

                                }catch(InvocationTargetException exc){

                                        exc.printStackTrace();

                                }

                        }

                }

                firstLoad = true;

        }

        /**

         * @see com.iver.cit.gvsig.fmap.layers.layerOperations.InfoByPoint#queryByPoint(com.iver.cit.gvsig.fmap.operations.QueriedPoint)

         */

        public XMLItem[] getInfo(Point p, double tolerance) throws DriverException {

                XMLItem[] item =  new XMLItem[1];

                try {

                        if (queryable)

                        {

                                //TODO

                                // check if there are layers which are not queryable

                                ViewPort viewPort = getMapContext().getViewPort();

                                Point tiledPoint = new Point((int) p.getX() % maxTilePrintWidth, (int) p.getY() % maxTilePrintHeight);

                                Rectangle rect = new Rectangle(0, 0, viewPort.getImageWidth() - 1, viewPort.getImageHeight() - 1);

                                Tiling tiles = new Tiling(maxTilePrintWidth, maxTilePrintHeight, rect);

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

                                int nCols = tiles.getNumCols();

                                int col = (int) p.getX() / maxTilePrintWidth;

                                int row = (int) p.getY() / maxTilePrintHeight;

                                int tileIndex = (row*nCols) + col;

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

                                wmsStatus.setExtent(vp.getExtent());

                                wmsStatus.setHeight(vp.getImageHeight());

                                wmsStatus.setWidth(vp.getImageWidth());

                                wmsStatus.setOnlineResource((String) onlineResources.get("GetFeatureInfo"));

                                item[0] = new StringXMLItem(new String(getDriver()

                                                .getFeatureInfo(wmsStatus, (int) tiledPoint.getX(), (int) tiledPoint.getY(), Integer.MAX_VALUE)),this);

                                return item;

                        }

                        else

                        {

                                JOptionPane.showMessageDialog((Component)PluginServices.getMainFrame(),

                                                PluginServices.getText(this, "wms_not_queryable"));

                                item[0] =  new StringXMLItem("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?><info></info>",this);

                                return item;

                        }

                } catch (WMSException  e) {

                        item[0] = new StringXMLItem("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?><exception>" +

                        e.getMessage() + "</exception>", this);

                        return item;

                }

                /*azabala

                catch (ValidationException e) {

                        throw new DriverException(PluginServices.getText(this, "unknown_response_format"), e);

                } catch (UnsupportedVersionException e) {

                        throw new DriverException(PluginServices.getText(this, "version_conflict"), e);

                } catch (IOException e) {

                        throw new DriverException(PluginServices.getText(this, "connect_error"), e);

                }

                */

                catch (ValidationException e) {

                        UnknownResponseFormatExceptionType type =

                                new UnknownResponseFormatExceptionType();

                        type.setLayerName(getName());

                        try {

                                type.setDriverName("WMS Driver");

                        } catch (Exception e1) {

                                e1.printStackTrace();

                        }

                        type.setFormat(m_Format);

                        type.setHost(host);

                        type.setProtocol("WMS");

                        DriverException exception = new DriverException("unknown_response_format", type);

                        throw exception;

                } catch (UnsupportedVersionException e) {

                        UnsuportedProtocolVersionExceptionType type =

                                new UnsuportedProtocolVersionExceptionType();

                        type.setLayerName(getName());

                        try {

                                type.setDriverName("WMS Driver");

                        } catch (Exception ex){

                        }

                        type.setUrl(host);

                        throw new DriverException(PluginServices.getText(this, "version_conflict"), e, type);

                } catch (IOException e) {

                        ConnectionErrorExceptionType type = new ConnectionErrorExceptionType();

                        type.setLayerName(getName());

                        try {

                                type.setDriverName("WMS Driver");

                        } catch (Exception e1) {

                        }

                        type.setHost(host);

                        throw new DriverException(PluginServices.

                                        getText(this, "connect_error"), e, type);

                }

                catch (NoninvertibleTransformException e) {

                        NotificationManager.addError("NotinvertibleTransform", e);

                }

                return null;

        }

        /**

         * @see com.iver.cit.gvsig.fmap.layers.FLayer#getFullExtent()

         */

        public Rectangle2D getFullExtent() {

                return fullExtent;

        }

        /**

         *

         * @see com.iver.cit.gvsig.fmap.layers.FLayer#draw(java.awt.image.BufferedImage,

         *                 java.awt.Graphics2D, com.iver.cit.gvsig.fmap.ViewPort,

         *                 com.iver.cit.gvsig.fmap.operations.Cancellable)

         */

        private int callCount; // mess code, represents the amount of times the methods drawFixedSize or drawTile where tried for an extent

        private static final int MAX_RETRY_TIMES = 5; // mess code, represents the max amount of retries allowed.

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

                        Cancellable cancel,double scale) throws DriverException {

                callCount = 0; // mess code

                if (isWithinScale(scale)){

                        Point2D p = viewPort.getOffset();

                        // p will be (0, 0) when drawing a view or other when painting onto

                        // the Layout.

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

                        if (isSizeFixed()) {

                                // This condition handles those situations in which the server can

                                // only give static extent and resolution maps despite we need

                                // a specific BBOX and pixel WIDTH and HEIGHT

                                drawFixedSize(g, viewPort, cancel);

                        } else {

                                if(mustTileDraw){

                                        Rectangle r = new Rectangle((int) p.getX(), (int) p.getY(), viewPort.getImageWidth(), viewPort.getImageHeight());

                                        Tiling tiles = new Tiling(maxTileDrawWidth, maxTileDrawHeight, r);

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

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

                                                // drawing part

                                                try {

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

                                                        drawTile(g, vp, cancel);

                                                } catch (NoninvertibleTransformException e) {

                                                        e.printStackTrace();

                                                }

                                        }

                                }else

                                        drawTile(g, viewPort, cancel);

                        }

                }

//                Runtime r = Runtime.getRuntime();

//                long mem = r.totalMemory() - r.freeMemory();

//                System.err.println("Memoria total: " + (mem / 1024) +"KB");

        }

        private void drawFixedSize(Graphics2D g, ViewPort vp, Cancellable cancel) throws DriverException {

                callCount++; // mess code, it is not unusual a wms server to response an error which is completely

                                         // temporal and the response is available if we retry requesting.

                                         //

                // This is the extent that will be requested

                Rectangle2D bBox = getFullExtent();

                MyCancellable c = new MyCancellable(cancel);

                try {

                        wmsStatus.setExtent( bBox );

                        wmsStatus.setFormat( m_Format );

                        wmsStatus.setHeight( fixedSize.height );

                        wmsStatus.setWidth( fixedSize.width );

                        wmsStatus.setLayerNames(Utilities.createVector(layerQuery,","));

                        wmsStatus.setSrs(m_SRS);

                        wmsStatus.setStyles(styles);

                        wmsStatus.setDimensions(dimensions);

                        wmsStatus.setTransparency(wmsTransparency);

                        wmsStatus.setOnlineResource((String) onlineResources.get("GetMap"));

                        File f = getDriver().getMap(wmsStatus, c);

                        if (f == null)

                                return;

                        String nameWorldFile = f.getPath() + getExtensionWorldFile();

                        com.iver.andami.Utilities.createTemp(nameWorldFile, this.getDataWorldFile(bBox, fixedSize));

                        if(status!=null && firstLoad){

                                status.applyStatus(this);

                                firstLoad = false;

                        }

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

                        // to draw to.

                        Rectangle2D extent = new Rectangle2D.Double();

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

                        ViewPortData vpData = new ViewPortData(

                                vp.getProjection(), new Extent(extent), fixedSize );

                        vpData.setMat(vp.getAffineTransform());

                        rasterProcess(g, vpData, f);

                } catch (ValidationException e) {

                        if (!c.isCanceled())

                        {

                                UnknownResponseFormatExceptionType type =

                                        new UnknownResponseFormatExceptionType();

                                type.setLayerName(getName());

                                try {

                                        type.setDriverName("WMS Driver");

                                } catch (Exception e1) {

                                        e1.printStackTrace();

                                }

                                type.setFormat(m_Format);

                                type.setHost(host);

                                type.setProtocol("WMS");

                                DriverException exception = new DriverException("unknown_response_format", type);

                                throw exception;

                        }

//        azabala                        throw new DriverException(PluginServices.getText(this, "unknown_response_format"), e);

                } catch (UnsupportedVersionException e) {

                        if (!c.isCanceled()){

                                UnsuportedProtocolVersionExceptionType type =

                                        new UnsuportedProtocolVersionExceptionType();

                                type.setLayerName(getName());

                                try {

                                        type.setDriverName("WMS Driver");

                                } catch (Exception ex){

                                }

                                type.setUrl(host);

                                throw new DriverException(PluginServices.getText(this, "version_conflict"), e, type);

                        }

//        azabala                throw new DriverException(PluginServices.getText(this, "version_conflict"), e);

                } catch (IOException e) {

                        if (!c.isCanceled())

                                if (callCount<MAX_RETRY_TIMES) { // mess code

                                        NotificationManager.addWarning("\n[ FLyrWMS.drawFixedSize() ]  Failed in trying " + callCount + "/" + MAX_RETRY_TIMES + ")\n", null); // mess code

                                        // I'll try again requesting up to MAX_RETRY_TIMES times before throw an error // mess code

                                        // (this is mess code, should be replaced by a layer status handler which is scheduled for version > 1.0) // mess code

                                        drawFixedSize(g, vp, cancel); // mess code

                                } // mess code

                                if (callCount == 1) { // mess code

                                        ConnectionErrorExceptionType type = new ConnectionErrorExceptionType();

                                        type.setLayerName(getName());

                                        try {

                                                type.setDriverName("WMS Driver");

                                        } catch (Exception e1) {

                                        }

                                        type.setHost(host);

                                        throw new DriverException(PluginServices.

                                                        getText(this, "connect_error"), e, type);

//        azabala        throw new DriverException(PluginServices.getText(this, "connect_error"), e);

                                } // mess code

                } catch (WMSException e) {

                        if (!c.isCanceled()) {

                                if (callCount<MAX_RETRY_TIMES) { // mess code

                                        NotificationManager.addWarning("\n[ FLyrWMS.drawFixedSize() ]  Failed in trying " + callCount + "/" + MAX_RETRY_TIMES + ")\n", null); // mess code

                                        // I'll try again requesting up to MAX_RETRY_TIMES times before throw an error // mess code

                                        // (this is mess code, should be replaced by a layer status handler which is scheduled for version > 1.0) // mess code

                                        drawFixedSize(g, vp, cancel); // mess code

                                } // mess code

                                if (callCount == 1) { // mess code

//                azabala                        JOptionPane.showMessageDialog((Component)PluginServices.getMainFrame(), e.getMessage());

                                        WMSDriverExceptionType type = new WMSDriverExceptionType();

                                        type.setLayerName(getName());

                                        try {

                                                type.setDriverName("WMS Driver");

                                        } catch (Exception e1) {

                                        }

                                        type.setWcsStatus(this.wmsStatus);

                                        if (!isPrinting)

                                                this.setVisible(false);

                                        throw new DriverException("Error WMS", e,  type);

                                } // mess code

                        }

                }

                callCount--; // mess code

        }

        /**

         * This is the method used to draw a tile in a WMS mosaic layer.

         */

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

                callCount++;

                // Compute the query geometry

                // 1. Check if it is within borders

                Rectangle2D extent = getFullExtent();

        if ((vp.getAdjustedExtent().getMinX() > extent.getMaxX()) ||

                (vp.getAdjustedExtent().getMinY() > extent.getMaxY()) ||

                (vp.getAdjustedExtent().getMaxX() < extent.getMinX()) ||

                (vp.getAdjustedExtent().getMaxY() < extent.getMinY())) {

            return;

        }

        // 2. Compute extent to be requested.

        Rectangle2D bBox = new Rectangle2D.Double();

        Rectangle2D.intersect(vp.getExtent(), extent, bBox);

        // 3. Compute size in pixels

        double scalex = vp.getAffineTransform().getScaleX();

        double scaley = vp.getAffineTransform().getScaleY();

        int wImg = (int) Math.ceil(Math.abs(bBox.getWidth() * scalex) + 1);

        int hImg = (int) Math.ceil(Math.abs(bBox.getHeight() * scaley) + 1);

        Dimension sz = new Dimension(wImg, hImg);

        if ((wImg <= 0) || (hImg <= 0)) {

            return;

        }

        MyCancellable c = new MyCancellable(cancel);

                try {

//                        wImg = vp.getImageWidth();

//                        hImg = vp.getImageHeight();

                        sz = new Dimension(wImg, hImg);

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

                        wmsStatus.setExtent( bBox );

                        wmsStatus.setFormat(m_Format);

                        wmsStatus.setHeight( hImg );

                        wmsStatus.setWidth( wImg );

                        wmsStatus.setLayerNames(Utilities.createVector(layerQuery,","));

                        wmsStatus.setSrs(m_SRS);

                        wmsStatus.setStyles(styles);

                        wmsStatus.setDimensions(dimensions);

                        wmsStatus.setTransparency(wmsTransparency);

                        wmsStatus.setOnlineResource((String) onlineResources.get("GetMap"));

                        // begin patch; Avoid to request too small tiles. 

                        // This generally occurs when printing 

                        if (wImg < minTilePrintWidth) {

                                double wScale = (double) minTilePrintWidth / wImg;

                                wmsStatus.setWidth(minTilePrintWidth);

                                Rectangle2D sExtent = wmsStatus.getExtent();

                                Point2D initialPoint = new Point2D.Double(sExtent.getX(), sExtent.getY());

                                sExtent.setRect(sExtent.getX()*wScale, sExtent.getY(), sExtent.getWidth()*wScale, sExtent.getHeight());

                                if (!bBox.contains(initialPoint)) {

                                        sExtent.setRect(sExtent.getX() - initialPoint.getX(), sExtent.getY(), sExtent.getWidth(), sExtent.getHeight());

                                }

                        }

                        if (hImg < minTilePrintHeight) {

                                double hScale = (double) minTilePrintHeight / hImg;

                                wmsStatus.setHeight(minTilePrintHeight);

                                Rectangle2D sExtent = wmsStatus.getExtent();

                                Point2D initialPoint = new Point2D.Double(sExtent.getX(), sExtent.getY());

                                sExtent.setRect(sExtent.getX(), sExtent.getY()*hScale, sExtent.getWidth(), sExtent.getHeight()*hScale);

                                if (!bBox.contains(initialPoint)) {

                                        sExtent.setRect(sExtent.getX(), sExtent.getY() - initialPoint.getY(), sExtent.getWidth(), sExtent.getHeight());

                                }

                        }

                        // end patch

                        File f = getDriver().getMap(wmsStatus, c);

                        if (f == null)

                                return;

                        String nameWordFile = f.getPath() + getExtensionWorldFile();

                        com.iver.andami.Utilities.createTemp(nameWordFile, this.getDataWorldFile(bBox, sz));

                        ViewPortData vpData = new ViewPortData(

                                vp.getProjection(), new Extent(bBox), sz );

                        vpData.setMat(vp.getAffineTransform());

                        rasterProcess(g, vpData, f);

                } catch (ValidationException e) {

                //azabala

//                        if (!c.isCanceled())

//                                throw new DriverException(PluginServices.getText(this, "unknown_response_format"), e);

                        if (!c.isCanceled())

                        {

                                UnknownResponseFormatExceptionType type =

                                        new UnknownResponseFormatExceptionType();

                                type.setLayerName(getName());

                                try {

                                        type.setDriverName("WMS Driver");

                                } catch (Exception e1) {

                                        e1.printStackTrace();

                                }

                                type.setFormat(m_Format);

                                type.setHost(host);

                                type.setProtocol("WMS");

                                DriverException exception = new DriverException("unknown_response_format", type);

                                throw exception;

                        }

                } catch (UnsupportedVersionException e) {

//                        if (!c.isCanceled())

//                                throw new DriverException(PluginServices.getText(this, "version_conflict"), e);

                        if (!c.isCanceled()){

                                UnsuportedProtocolVersionExceptionType type =

                                        new UnsuportedProtocolVersionExceptionType();

                                type.setLayerName(getName());

                                try {

                                        type.setDriverName("WMS Driver");

                                } catch (Exception ex){

                                }

                                type.setUrl(host);

                                throw new DriverException(PluginServices.getText(this, "version_conflict"), e, type);

                        }

                } catch (IOException e) {

                        /*azabala

                        if (!c.isCanceled())

                                if (callCount<MAX_RETRY_TIMES) {

                                        NotificationManager.addWarning("\n[ FLyrWMS.drawFixedSize() ]  Failed in trying " + callCount + "/" + MAX_RETRY_TIMES + ")\n", null);

                                        // I'll try again requesting up to MAX_RETRY_TIMES times before throw an error

                                        // (this is mess code, should be replaced by a layer status handler which is scheduled for version > 1.0)

                                        drawTile(g, vp, cancel);

                                }

                                if (callCount == 1) {

                                        throw new DriverException(PluginServices.getText(this, "connect_error"), e);

                                }

                        */

                        if (!c.isCanceled()){

                                if (callCount<MAX_RETRY_TIMES) { // mess code

                                        NotificationManager.addWarning("\n[ FLyrWMS.drawFixedSize() ]  Failed in trying " + callCount + "/" + MAX_RETRY_TIMES + ")\n", null); // mess code

                                        // I'll try again requesting up to MAX_RETRY_TIMES times before throw an error // mess code

                                        // (this is mess code, should be replaced by a layer status handler which is scheduled for version > 1.0) // mess code

                                        //FIXME Aqu? deberiamos llamar a drawTile o a drawFixedSize????

                                        drawFixedSize(g, vp, cancel); // mess code

                                } // mess code

                        }

                        if (callCount == 1) { // mess code

                                ConnectionErrorExceptionType type = new ConnectionErrorExceptionType();

                                type.setLayerName(getName());

                                try {

                                        type.setDriverName("WMS Driver");

                                } catch (Exception e1) {}

                                type.setHost(host);

                                throw new DriverException(PluginServices.

                                                        getText(this, "connect_error"), e, type);

                        }//if

                } catch (WMSException e) {

                        /*azabala

                        if (!c.isCanceled()) {

                                if (callCount<MAX_RETRY_TIMES) {

                                        NotificationManager.addWarning("\n[ FLyrWMS.drawTile() ] Failed in trying " + callCount + "/" + MAX_RETRY_TIMES +" \n", null);

                                        // I'll try again requesting up to MAX_RETRY_TIMES times before throw an error

                                        // (this is mess code, should be replaced by a layer status handler which is scheduled for version > 1.0)

                                        drawTile(g, vp, cancel);

                                }

                                if (callCount == 1) {

                                        if (!isPrinting) {

                                                JOptionPane.showMessageDialog((Component)PluginServices.getMainFrame(), e.getMessage());

                                                this.setVisible(false);

                                        }

                                }

                        }

                        */

                        if (!c.isCanceled()) {

                                if (callCount<MAX_RETRY_TIMES) { // mess code

                                        NotificationManager.addWarning("\n[ FLyrWMS.drawFixedSize() ]  Failed in trying " + callCount + "/" + MAX_RETRY_TIMES + ")\n", null); // mess code

                                        // I'll try again requesting up to MAX_RETRY_TIMES times before throw an error // mess code

                                        // (this is mess code, should be replaced by a layer status handler which is scheduled for version > 1.0) // mess code

                                        drawTile(g, vp, cancel);

                                } // mess code

                                if (callCount == 1) { // mess code

//                azabala                        JOptionPane.showMessageDialog((Component)PluginServices.getMainFrame(), e.getMessage());

                                        WMSDriverExceptionType type = new WMSDriverExceptionType();

                                        type.setLayerName(getName());

                                        try {

                                                type.setDriverName("WMS Driver");

                                        } catch (Exception e1) {

                                        }

                                        type.setWcsStatus(this.wmsStatus);

                                        if (!isPrinting)

                                                this.setVisible(false);

                                        throw new DriverException("Error WMS", e,  type);

                                } //if

                        }//if

                }//catch

                callCount--;

        }

        /**

         * Obtiene la extensi?n del fichero de georreferenciaci?n

         * @return String con la extensi?n del fichero de georreferenciaci?n dependiendo

         * del valor del formato obtenido del servidor. Por defecto asignaremos un .wld

         */

        private String getExtensionWorldFile(){

                String extWorldFile = ".wld";

            if(m_Format.equals("image/tif") || m_Format.equals("image/tiff"))

                    extWorldFile = ".tfw";

            if(m_Format.equals("image/jpeg"))

                    extWorldFile = ".jpgw";

            return extWorldFile;

        }

        /**

         * Calcula el contenido del fichero de georreferenciaci?n de una imagen.

         * @param bBox Tama?o y posici?n de la imagen (en coordenadas de usuario)

         * @param sz Tama?o de la imagen en pixeles.

         * @return el 'WorldFile', como 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");

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

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

            return data.toString();

        }

        /**

         * Dibuja una imagen usando PxRaster

         * @param g        Graphics2D en el que hay que dibujar.

         * @param vpData Par?metros de visualizaci?n

         * @param file La imagen en cuesti?n.

         */

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

                //Creamos el PxRaster

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

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

                if(status!=null && firstLoad){

                        status.applyStatus(this);

                        firstLoad = false;

                }

                //Recuperamos la pila de filtros si ya hubiese sido cargado antes

                if(this.filterStack!=null)

                        raster.filterStack = this.filterStack;

                raster.setTransparency(false);

                //Asignamos transparencia y orden de bandas

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

                //Despues del primer pxRaster asignamos el stackManager guardado para los siguientes.

                //Con esto conseguimos asignar los cambios que se hayan producido desde el cuadro de

                //propiedades cuando creamos un nuevo pxRaster

                if(this.stackManager != null)

                        raster.setStackManager(this.stackManager);

                if(visualStatus != null){

                        visualStatus.bandCount = raster.getBandCount();

                        visualStatus.dataType = raster.getDataType();

                }

                raster.draw(g, vpData);

                //En el primer pxRaster de una imagen obtenemos el Stack Manager para poder modificarlo

                //si queremos desde las propiedades

                if(this.stackManager == null)

                        this.stackManager = raster.getStackManager();

                if(this.filterStack == null)

                        this.filterStack = raster.filterStack;

                //rasterFile.close();

        }

        /**

         * @see com.iver.cit.gvsig.fmap.layers.FLayer#print(java.awt.Graphics2D,

         *                 com.iver.cit.gvsig.fmap.ViewPort,

         *                 com.iver.cit.gvsig.fmap.operations.Cancellable)

         */

        public void print(Graphics2D g, ViewPort viewPort, Cancellable cancel,double scale)

                throws DriverException {

                if (isVisible() && isWithinScale(scale)){

                isPrinting = true;

                if (!mustTilePrint) {

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

                } else {

                // Para no pedir imagenes demasiado grandes, vamos

                // a hacer lo mismo que hace EcwFile: chunkear.

                // Llamamos a drawView con cuadraditos m?s peque?os

                // del BufferedImage ni caso, cuando se imprime viene con null

                        Tiling tiles = new Tiling(maxTilePrintWidth, maxTilePrintHeight, g.getClipBounds());

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

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

                            // Parte que dibuja

                            try {

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

                                drawTile(g, vp, cancel);

                                } catch (NoninvertibleTransformException e) {

                                        e.printStackTrace();

                                }

                }

                }

            isPrinting = false;

                }

        }

        public void _print(Graphics2D g, ViewPort viewPort, Cancellable cancel,double scale)

                throws DriverException {

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

        }

        /**

         * Devuelve el FMapWMSDriver.

         *

         * @return FMapWMSDriver

         *

         * @throws IllegalStateException

         * @throws ValidationException

         * @throws UnsupportedVersionException

         * @throws IOException

         */

        private FMapWMSDriver getDriver()

                throws IllegalStateException, ValidationException,

                        UnsupportedVersionException, IOException {

                return FMapWMSDriverFactory.getFMapDriverForURL(host);

        }

        /**

         * Devuelve el FMapWMSDriver.

         *

         * @return FMapWMSDriver

         *

         * @throws IllegalStateException

         * @throws ValidationException

         * @throws UnsupportedVersionException

         * @throws IOException

         */

        public void setDriver(FMapWMSDriver drv) {

                wms = drv;

        }

        /**

         * Devuelve el URL.

         *

         * @return URL.

         */

        public URL getHost() {

                return host;

        }

        /**

         * Inserta el URL.

         *

         * @param host URL.

         */

        public void setHost(URL host) {

                this.host = host;

        }

        /**

         * Devuelve la informaci?n de la consulta.

         *

         * @return String.

         */

        public String getInfoLayerQuery() {

                return infoLayerQuery;

        }

        /**

         * Inserta la informaci?n de la consulta.

         *

         * @param infoLayerQuery String.

         */

        public void setInfoLayerQuery(String infoLayerQuery) {

                this.infoLayerQuery = infoLayerQuery;

        }

        /**

         * Devuelve la consulta.

         *

         * @return String.

         */

        public String getLayerQuery() {

                return layerQuery;

        }

        /**

         * Inserta la consulta.

         *

         * @param layerQuery consulta.

         */

        public void setLayerQuery(String layerQuery) {

                this.layerQuery = layerQuery;

        }

        /**

         * Devuelve el formato.

         *

         * @return Formato.

         */

        public String getFormat() {

                return m_Format;

        }

        /**

         * Inserta el formato.

         *

         * @param format Formato.

         */

        public void setFormat(String format) {

                m_Format = format;

        }

        /**

         * Devuelve el SRS.

         *

         * @return SRS.

         */

        public String getSRS() {

                return m_SRS;

        }

        /**

         * Inserta el SRS.

         *

         * @param m_srs SRS.

         */

        public void setSRS(String m_srs) {

                m_SRS = m_srs;

        }

        /**

         * Inserta la extensi?n total de la capa.

         *

         * @param fullExtent Rect?ngulo.

         */

        public void setFullExtent(Rectangle2D fullExtent) {