| 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 org.gvsig.wms.fmap.layers;

import java.awt.Dimension;

import java.awt.Graphics2D;

import java.awt.Image;

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.io.File;

import java.io.IOException;

import java.lang.ref.WeakReference;

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

import java.util.Map;

import java.util.Vector;

import java.util.prefs.Preferences;

import javax.print.attribute.PrintRequestAttributeSet;

import javax.swing.ImageIcon;

import org.cresques.cts.ICoordTrans;

import org.cresques.geo.ViewPortData;

import org.cresques.px.Extent;

import org.exolab.castor.xml.ValidationException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.messages.NotificationManager;

import org.gvsig.compat.net.ICancellable;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.exception.ReadException;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.exception.CreateEnvelopeException;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.fmap.mapcontext.exceptions.ConnectionErrorLayerException;

import org.gvsig.fmap.mapcontext.exceptions.LoadLayerException;

import org.gvsig.fmap.mapcontext.exceptions.URLLayerException;

import org.gvsig.fmap.mapcontext.exceptions.UnsupportedVersionLayerException;

import org.gvsig.fmap.mapcontext.layers.FLayer;

import org.gvsig.fmap.mapcontext.layers.Tiling;

import org.gvsig.fmap.mapcontext.layers.operations.ComposedLayer;

import org.gvsig.fmap.mapcontext.layers.operations.IHasImageLegend;

import org.gvsig.fmap.mapcontext.rendering.legend.ILegend;

import org.gvsig.fmap.raster.layers.FLyrRasterSE;

import org.gvsig.fmap.raster.layers.IRasterLayerActions;

import org.gvsig.fmap.raster.layers.IStatusRaster;

import org.gvsig.raster.dataset.CompositeDataset;

import org.gvsig.raster.dataset.IBuffer;

import org.gvsig.raster.dataset.MosaicNotValidException;

import org.gvsig.raster.dataset.MultiRasterDataset;

import org.gvsig.raster.dataset.NotSupportedExtensionException;

import org.gvsig.raster.dataset.RasterDriverException;

import org.gvsig.raster.grid.GridPalette;

import org.gvsig.raster.grid.GridTransparency;

import org.gvsig.raster.grid.filter.FilterTypeException;

import org.gvsig.raster.grid.filter.RasterFilterList;

import org.gvsig.raster.grid.filter.RasterFilterListManager;

import org.gvsig.raster.grid.filter.bands.ColorTableFilter;

import org.gvsig.raster.grid.filter.bands.ColorTableListManager;

import org.gvsig.remoteclient.utils.Utilities;

import org.gvsig.remoteclient.wms.WMSStatus;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObjectSet;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.task.Cancellable;

import org.gvsig.wmc.WebMapContextTags;

import org.gvsig.wmc.XmlBuilder;

import org.gvsig.wms.fmap.WMSDriverExceptionType;

import org.gvsig.wms.fmap.drivers.wms.FMapWMSDriver;

import org.gvsig.wms.fmap.drivers.wms.FMapWMSDriverFactory;

import org.gvsig.wms.fmap.drivers.wms.WMSException;

import org.gvsig.wms.fmap.layers.WMSLayerNode.FMapWMSStyle;

/**

 * FMap's WMS Layer class.

 *

 * Las capas WMS son tileadas para descargarlas del servidor. Esto quiere decir que

 * est?n formadas por multiples ficheros raster. Por esto la fuente de datos raster (IRasterDatasource)

 * de la capa FLyrWMS es un objeto de tipo CompositeDataset. Este objeto est? compuesto por un array

 * bidimensional de MultiRasterDataset. Cada uno de los MultiRasterDataset corresponde con un tile

 * salvado en disco. Estos MultiRasterDataset se crean cada vez que se repinta ya que en WMS a cada

 * zoom varian los ficheros fuente. La secuencia de creaci?n de un CompositeDataset ser?a la siguiente:

 * <UL>

 * <LI>Se hace una petici?n de dibujado por parte del usuario llamando al m?todo draw de FLyrWMS</LI>

 * <LI>Se tilea la petici?n</LI>

 * <LI>Cada tile se dibuja abriendo una FLyerRaster para ese tile</LI>

 * <LI>Si es el primer dibujado se guarda una referencia en la capa WMS a las propiedades de renderizado, orden de bandas,

 * transparencia, filtros aplicados, ...</LI>

 * <LI>Si no es el primer dibujado se asignan las propiedades de renderizado cuya referencia se guarda en la capa WMS</LI>

 * <LI>Se guarda el MultiRasterDataset de cada tile</LI>

 * <LI>Al acabar todos los tiles creamos un CompositeDataset con los MultiRasterDataset de todos los tiles</LI>

 * <LI>Asignamos a la capa la referencia de las propiedades de renderizado que tenemos almacenadas. De esta forma si hay

 * alguna modificaci?n desde el cuadro de propiedades ser? efectiva sobre los tiles que se dibujan.</LI>

 * </UL>

 *

 *

 * @author Jaume Dominguez Faus

 *

 */

public class FLyrWMS extends FLyrRasterSE implements IHasImageLegend{

        public static final String     PERSISTENT_NAME        = "FLyrWMS_Persistent";

        public static final String     PERSISTENT_DESCRIPTION = "FLyrWMS Persistent Definition";

        private static final GeometryManager geomManager = GeometryLocator.getGeometryManager();

        private static final Logger                 logger = LoggerFactory.getLogger(FLyrWMS.class);

        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 boolean                                                wmsTransparency;

        private Vector<String>                                styles;

        private Vector<String>                                dimensions;

        private boolean                                                firstLoad = false;

        private Map<String,String>                    onlineResources = new Hashtable<String,String>();

        private Dimension                                         fixedSize;

        private boolean                                         queryable = true;

        private VisualStatus                                visualStatus = new VisualStatus();

        /**

         * Lista de filtros aplicada en la renderizaci?n

         */

        private RasterFilterList            filterList = null;

        private GridTransparency                        transparency = null;

        private int[]                       renderBands = null;

        private FLyrRasterSE[]                                layerRaster = null;

        private List<String>                filterArguments = null;

        private List<WeakReference<Thread>>        disableUpdateDrawVersion;

        private int                         lastNColumns = 0;

        private int                         lastNRows = 0;

        //FIXME DynValue???

        private Envelope                                        fullEnvelope=null;

        private class MyCancellable implements ICancellable

        {

                private Cancellable original;

                public MyCancellable(Cancellable cancelOriginal)

                {

                        this.original = cancelOriginal;

                }

                public boolean isCanceled() {

                        if (original == null) {

                                return false;

                        }

                        return original.isCanceled();

                }

                public Object getID() {

                        return this;

                }

        }

        public FLyrWMS(){

                super();

                this.updateDrawVersion();

        }

        public FLyrWMS(Map args) throws LoadLayerException{

                this.updateDrawVersion();

                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 URLLayerException(getName(),e);

                }

                try {

                        drv = this.getDriver();

                } catch (IllegalStateException e) {

                        throw new LoadLayerException(getName(),e);

                } catch (ValidationException e) {

                        throw new LoadLayerException(getName(),e);

                } catch (IOException e) {

                        throw new ConnectionErrorLayerException(getName(),e);

                }

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

                        if (!drv.connect(null)) {

                                throw new ConnectionErrorLayerException(getName(),null);

                        }

                        WMSLayerNode wmsNode = drv.getLayer(sLayer);

                        if (wmsNode == null){

                                throw new LoadLayerException(getName(),null);

                        }

                        if( sFormat == null ) {

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

                        }

                        // SRS

                        Vector allSrs = wmsNode.getAllSrs();

                        boolean isSRSSupported = false;

                        if( sSRS != null ) {

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

                                        if (((String)allSrs.get(i)).compareTo(sSRS) == 0){

                                                isSRSSupported = true;

                                        }

                                }

                        }

                        if(!isSRSSupported) {

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

                                        if (((String)wmsNode.getAllSrs().get(i)).compareTo("EPSG:4326") == 0){

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

                                        }

                                }

                                if (sSRS==null){

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

                                }

                        }

                        if( fullExtent == null ) {

                                fullExtent = drv.getLayersExtent(sLayers,sSRS);

                        }

                }

                this.setFullExtent(fullExtent);

                this.setFormat(sFormat);

                this.setLayerQuery(sLayer);

                this.setInfoLayerQuery("");

                this.setSRS(sSRS);

                this.setName(sLayer);

                this.setOnlineResources(drv.getOnlineResources());

                load();

        }

        /**

         * 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 VisualStatus{

                /**

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

                 * el ancho y alto del viewPort

                 */

                private double                                                minX = 0D;

                private double                                                minY = 0D;

                private double                                                maxX = 0D;

                private double                                                maxY = 0D;

                /**

                 * Lista de nombre de fichero que componen toda la visualizaci?n.

                 */

                private String[]                                        fileNames = null;

                public Object clone() {

                        VisualStatus s = new VisualStatus();

                        s.maxX = maxX;

                        s.maxY = maxY;

                        s.minX = minX;

                        s.minY = minY;

                        s.fileNames = new String[fileNames.length];

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

                                s.fileNames[i] = fileNames[i];

                        return s;

                }

        }

        @Override

        public void loadFromState(PersistentState state)

        throws PersistenceException {

                super.loadFromState(state);

                this.fullEnvelope = (Envelope) state.get("fullExtent");

                // Host

                host = (URL) state.get("host");

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

                // layer names, or other not listed bellow

                infoLayerQuery = state.getString("infoLayerQuery");

                // Part of the query containing the layer names

                layerQuery = state.getString("layerQuery");

                // Format

                m_Format = state.getString("format");

                // SRS

                m_SRS = state.getString("srs");

                // Transparency

                if (state.hasValue("wms_transparency")) {

                        wmsTransparency = state.getBoolean("wms_transparency");

                }

                // Styles

                if (state.hasValue("styles")){

                        styles = new Vector(state.getList("styles"));

                }

                // Dimensions

                if (state.hasValue("dimensions")){

                        dimensions = new Vector(state.getList("dimensions"));

                }

                // OnlineResources

                if (state.hasValue("onlineResources")) {

                        onlineResources = new Hashtable(state.getMap("onlineResources"));

                }

                // Queryable

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

                if (state.hasValue("queryable")) {

                        queryable = state.getBoolean("queryable");

                }

                // fixedSize

                if (state.hasValue("fixedSize")) {

                        fixedSize = (Dimension) state.get("fixedSize");

                } else {

                        fixedSize = null;

                }

                firstLoad = true;

        }

        @Override

        public void saveToState(PersistentState state) throws PersistenceException {

                super.saveToState(state);

                state.set("fullEnvelope", this.fullEnvelope);

                // Host

                state.set("host", host);

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

                // layer names, or other not listed bellow

                state.set("infoLayerQuery", infoLayerQuery);

                // Part of the query containing the layer names

                state.set("layerQuery", layerQuery);

                // Format

                state.set("format", m_Format);

                // SRS

                state.set("srs", m_SRS);

                // Transparency

                state.set("wms_transparency", wmsTransparency);

                // Styles

                if (styles!=null){

                        state.set("styles", styles);

                }

                // Dimensions

                if (dimensions!=null){

                        state.set("dimensions", dimensions);

                }

                // OnlineResources

                state.set("onlineResources", onlineResources);

                // Queryable

                state.set("queryable", queryable);

                // fixedSize

                if (isSizeFixed()) {

                        state.set("fixedSize", fixedSize);

                }

        }

        public static void registerPersistent() {

                PersistenceManager manager = ToolsLocator.getPersistenceManager();

                DynStruct definition = manager.getDefinition(PERSISTENT_NAME);

                if( definition == null ) {

                        FLyrRasterSE.registerPersistent();

                        definition = manager.addDefinition(

                                        FLyrWMS.class,

                                        PERSISTENT_NAME,

                                        PERSISTENT_DESCRIPTION,

                                        null, 

                                        null

                        );

                        definition.extend(

                                        (DynClass)ToolsLocator.getPersistenceManager()

                                                .getDefinition(FLyrRasterSE.class)

                        );

                        definition.addDynFieldObject("fullExtent")

                                .setType(DataTypes.ENVELOPE)

                                .setMandatory(true);

                        definition.addDynFieldURL("host")

                                .setMandatory(true);

                        definition.addDynFieldString("infoLayerQuery").setMandatory(true);                

                        definition.addDynFieldString("layerQuery").setMandatory(true);

                        definition.addDynFieldString("format").setMandatory(true);

                        definition.addDynFieldString("srs").setMandatory(true);

                        definition.addDynFieldBoolean("wms_transparency").setMandatory(true);

                        definition.addDynFieldList("styles")

                                .setClassOfItems(String.class)

                                .setMandatory(false);

                        definition.addDynFieldList("dimensions")

                                .setClassOfItems(String.class)

                                .setMandatory(false);

                        definition.addDynFieldMap("onlineResources")

                                .setClassOfItems(String.class)

                                .setMandatory(true);

                        definition.addDynFieldBoolean("queryable").setMandatory(false);

                        definition.addDynFieldObject("fixedSize")

                                .setClassOfValue(Dimension.class)

                                .setMandatory(false);

                }

        }

        //        /**

        //         * @throws ReadDriverException

        //         * @throws LoadLayerException

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

        //         */

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

        //                        throws ReadException {

        //                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(this.getRectable2DFromEnvelope(vp

        //                                                .getAdjustedExtent()));

        //                                wmsStatus.setHeight(vp.getImageHeight());

        //                                wmsStatus.setWidth(vp.getImageWidth());

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

        //

        //

        //                                wmsStatus.setFormat( m_Format );

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

        //                                wmsStatus.setSrs(m_SRS);

        //                                wmsStatus.setStyles(styles);

        //                                wmsStatus.setDimensions(dimensions);

        //                                wmsStatus.setTransparency(wmsTransparency);

        //                                wmsStatus.setSrs(m_SRS);

        //                                MyCancellable c = new MyCancellable(cancellable);

        //                                try {

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

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

        //                                } catch (UnsupportedVersionLayerException e) {

        //                                        throw new ReadException(FMapWMSDriver.class.getName()

        //                                                        + "::" + getName()

        //                                                        + " - UnsupportedVersionLayerException", e);

        //                                } catch (IllegalStateException e) {

        //                                        throw new ReadException(FMapWMSDriver.class.getName()

        //                                                        + "::" + getName() + " - IllegalStateException", e);

        //                                }

        //                                return item;

        //                        }

        //                        else

        //                        {

        //                                JOptionPane.showMessageDialog((Component)PluginServices.getMainFrame(),this.getName() + " " +

        //                                                PluginServices.getText(this,"layer_not_queryable"));

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

        //                                return item;

        //                                //return null;

        //                        }

        //                } catch (WMSException  e) {

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

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

        //                        return item;

        //                } catch (ValidationException e) {

        //                        throw new ReadException(FMapWMSDriver.class.getName() + "::"

        //                                        + getName() + " - ValidationException", e);

        //                } catch (IOException e) {

        //                        throw new ReadException(FMapWMSDriver.class.getName() + "::"

        //                                        + getName() + " - IOException", e);

        //                } catch (NoninvertibleTransformException e) {

        //                        NotificationManager.addError("NotinvertibleTransform", e);

        //                }

        //                return null;

        //        }

        /*

         *

         * @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 ReadException {

                callCount = 0; // mess code

                lastNColumns = lastNRows = 0;

                enableStopped();

                closeAndFree();

                if (isWithinScale(scale)){

                        Point2D p = viewPort.getOffset();

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

                        // the Layout.

                        Envelope vpEnvelope = viewPort.getAdjustedExtent();

                        visualStatus.minX = vpEnvelope.getMinimum(0);

                        visualStatus.minY = vpEnvelope.getMinimum(1);

                        visualStatus.maxX = vpEnvelope.getMaximum(0);

                        visualStatus.maxY = vpEnvelope.getMaximum(1);

                        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

                                try {

                                        visualStatus.fileNames = new String[1];

                                        layerRaster = new FLyrRasterSE[1];

                                        drawFixedSize(g, viewPort, cancel, scale);

                                        if(layerRaster != null && layerRaster[0] != null) {

                                                dataset = layerRaster[0].getDataSource();

                                                initializeRasterLayer(null, new IBuffer[][]{{layerRaster[0].getRender().getLastRenderBuffer()}});

                                                getRender().setLastRenderBuffer(layerRaster[0].getRender().getLastRenderBuffer());

                                        }

                                } catch (LoadLayerException e) {

                                        // TODO Auto-generated catch block

                                        e.printStackTrace();

                                } 

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

                                        visualStatus.fileNames = new String[tiles.getNumTiles()];

                                        MultiRasterDataset[][] datasets = new MultiRasterDataset[tiles.getNumRows()][tiles.getNumCols()];

                                        IBuffer[][] buf = new IBuffer[tiles.getNumRows()][tiles.getNumCols()];

                                        layerRaster = new FLyrRasterSE[tiles.getNumTiles()];

                                        lastNColumns = tiles.getNumCols();

                                        lastNRows = tiles.getNumRows();

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

                                                // drawing part

                                                try {

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

                                                        boolean painted = drawTile(g, vp, cancel, tileNr, scale, tileNr);

                                                        if(        layerRaster != null && 

                                                                        layerRaster[tileNr] != null && 

                                                                        painted) {

                                                                datasets[(int)(tileNr / tiles.getNumCols())][tileNr % tiles.getNumCols()] = (MultiRasterDataset)layerRaster[tileNr].getDataSource().newDataset();

                                                                buf[(int)(tileNr / tiles.getNumCols())][tileNr % tiles.getNumCols()] = layerRaster[tileNr].getRender().getLastRenderBuffer();

                                                        }

                                                } catch (NoninvertibleTransformException e) {

                                                        e.printStackTrace();

                                                } catch (LoadLayerException e) {

                                                        // TODO Auto-generated catch block

                                                        e.printStackTrace();

                                                }

                                        }

                                        try {

                                                if(datasets != null && datasets[0][0] != null) {

                                                        dataset = new CompositeDataset(datasets);

                                                        initializeRasterLayer(datasets, buf);

                                                        buf = null;

                                                }

                                        } catch (MosaicNotValidException e) {

                                                throw new ReadException(

                                                                "No hay continuidad en el mosaico.", e);

                                        } catch (LoadLayerException e) {

                                                throw new ReadException("Error inicializando la capa.",

                                                                e);

                                        }

                                } else {

                                        try {

                                                layerRaster = new FLyrRasterSE[1];

                                                visualStatus.fileNames = new String[1];

                                                drawTile(g, viewPort, cancel, 0, scale, 0);

                                                if(layerRaster != null && layerRaster[0] != null) {

                                                        dataset = layerRaster[0].getDataSource();

                                                        getRender().setLastRenderBuffer(layerRaster[0].getRender().getLastRenderBuffer());

                                                        initializeRasterLayer(null, new IBuffer[][]{{layerRaster[0].getRender().getLastRenderBuffer()}});

                                                }

                                        } catch (LoadLayerException e) {

                                                // TODO Auto-generated catch block

                                                e.printStackTrace();

                                        }

                                }

                        }

                }

                disableStopped();

                /*Runtime r = Runtime.getRuntime();

                System.err.println("********************WMS**********************");

                System.err.println("Memoria Total: " + (r.totalMemory() / 1024) +"KB");

                System.err.println("Memoria Usada: " + ((r.totalMemory() - r.freeMemory()) / 1024) +"KB");

                System.err.println("Memoria Libre: " + (r.freeMemory() / 1024) +"KB");

                System.err.println("Memoria MaxMemory: " + (r.maxMemory() / 1024) +"KB");

                System.err.println("*********************************************");*/

        }

        /**

         * Closes files and releases memory (pointers to null)

         */

        private void closeAndFree() {

                while(readingData != null && readingData.compareTo(Thread.currentThread().toString()) != 0)

                        try {

                                Thread.sleep(100);

                        } catch (InterruptedException e) {

                        }

                        if(dataset != null) {

                                dataset.close();

                                dataset = null;

                        }

                        //Cerramos el dataset asociado a la capa si est? abierto.

                        if(layerRaster != null) {

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

                                        if(layerRaster[i] != null) {

                                                layerRaster[i].setRemoveRasterFlag(true);

                                                layerRaster[i].getDataSource().close();

                                                layerRaster[i].getRender().free();

                                                layerRaster[i].getBufferFactory().free();

                                                layerRaster[i] = null;

                                        }

                                }

                        }

                        getRender().free();

                        System.gc();

        }

        /**

         * Acciones que se realizan despu?s de asignar la fuente de datos a

         * la capa raster.

         *

         * @throws LoadLayerException

         */

        private void initializeRasterLayer(MultiRasterDataset[][] datasets, IBuffer[][] buf) throws LoadLayerException {

                if(this.filterList != null)

                        getRender().setFilterList(filterList);

                if(this.transparency != null)

                        getRender().setLastTransparency(transparency);

                if(this.renderBands != null)

                        getRender().setRenderBands(renderBands);

                if(datasets != null) {

                        String[][] names = new String[datasets.length][datasets[0].length];

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

                                for (int j = 0; j < datasets[i].length; j++) {

                                        if(datasets[i][j] != null)

                                                names[i][j] = datasets[i][j].getDataset(0)[0].getFName();

                                }

                        }

                        super.setLoadParams(names);

                }

                super.init();

                if(buf != null && buf[0][0] != null) {

                        int drawablesBandCount = layerRaster[0].getDataSource().getBands().getDrawableBandsCount();

                        IBuffer buff = null;

                        if(dataset instanceof CompositeDataset)

                                buff = ((CompositeDataset)dataset).generateBuffer(buf, drawablesBandCount);

                        else

                                buff = buf[0][0];

                        if(getRender().getLastRenderBuffer() != null)

                                getRender().getLastRenderBuffer().free();

                        getRender().setLastRenderBuffer(buff);

                }

        }

        private void drawFixedSize(Graphics2D g, ViewPort vp, Cancellable cancel,

                        double scale) throws ReadException, LoadLayerException {

                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 = getRectable2DFromEnvelope(getFullEnvelope());

                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 = getWorldFile(f.getPath());

                        org.gvsig.andami.Utilities.createTemp(nameWorldFile, this.getDataWorldFile(bBox, fixedSize));

                        IStatusRaster status = getStatus();

                        if(status!=null && firstLoad){

                                try {

                                        status.applyStatus(this);

                                } catch (NotSupportedExtensionException e) {

                                        throw new ReadException("", e);

                                } catch (RasterDriverException e) {

                                        throw new ReadException("", e);

                                } catch (FilterTypeException e) {

                                        throw new ReadException("", e);

                                }

                                firstLoad = false;

                        }

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

                        // to draw to.

                        Rectangle2D extent = new Rectangle2D.Double();

                        Envelope vpEnv = vp.getAdjustedExtent();

                        Rectangle2D.Double vpExtent = this.getRectable2DFromEnvelope(vpEnv);

                        Rectangle2D.intersect(vpExtent, bBox, extent);

                        ViewPortData vpData = new ViewPortData(

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

                        vpData.setMat(vp.getAffineTransform());

                        String filePath = f.getAbsolutePath();

                        visualStatus.fileNames[0] = filePath;

                        try {

                                rasterProcess(filePath, g, vp, scale, cancel, 0);

                                this.updateDrawVersion();

                        } catch (FilterTypeException e) {

                        }

                } catch (ValidationException e) {

                        if (!c.isCanceled())

                        {

                                LoadLayerException exception = new LoadLayerException(getName(),e);

                                throw exception;

                        }

                } 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, scale); // 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 ConnectionErrorLayerException(getName(),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, scale); // mess code

                                } // mess code

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

                                        if (!isPrinting) {

                                                this.setVisible(false);

                                        }

                                        throw new LoadLayerException(getName(),e);

                                } // mess code

                        }

                }

                callCount--; // mess code

        }

        /**

         * Carga y dibuja el raster usando la librer?a

         *

         * @param filePath

         *            Ruta al fichero en disco

         * @param g

         *            Graphics2D

         * @param vp

         *            ViewPort

         * @param scale

         *            Escala para el draw

         * @param cancel

         *            Cancelaci?n para el draw

         * @throws ReadException

         * @throws LoadLayerException

         * @throws ReadException 

         */

        private void rasterProcess(String filePath, Graphics2D g, ViewPort vp, double scale, Cancellable cancel, int nLyr) throws LoadLayerException, FilterTypeException, ReadException {

                //Cargamos el dataset con el raster de disco.

                layerRaster[nLyr] = FLyrRasterSE.createLayer("", filePath, vp.getProjection());

                //layerRaster[nLyr].getRender().setBufferFactory(layerRaster[nLyr].getBufferFactory());

                layerRaster[nLyr].setNoDataValue(getNoDataValue());

                layerRaster[nLyr].setNoDataType(getNoDataType());

                //Obtenemos la tabla de color del raster abierto ya que se le va a sustituir la lista

                //de filtros y el de tabla de color no queremos sustituirlo.

                RasterFilterList rasterFilterList = layerRaster[nLyr].getRender().getFilterList();

                ColorTableFilter ct = (ColorTableFilter)rasterFilterList.getFilterByBaseClass(ColorTableFilter.class);

                Object param = null;

                if(ct != null)

                        param = ct.getParam("colorTable");

                //En caso de cargar un proyecto con XMLEntity se crean los filtros

                if(filterArguments != null) {

                        RasterFilterList fl = new RasterFilterList();

                        fl.addEnvParam("IStatistics", layerRaster[nLyr].getDataSource().getStatistics());

                        fl.addEnvParam("MultiRasterDataset", layerRaster[nLyr].getDataSource());

                        fl.setInitDataType(layerRaster[nLyr].getDataType()[0]);

                        RasterFilterListManager filterListManager = new RasterFilterListManager(fl);

                        filterListManager.createFilterListFromStrings((ArrayList) filterArguments);

                        filterArguments = null;

                        filterList = fl;

                }

                //Como el raster se carga a cada zoom el render se crea nuevamente y la lista de

                //filtros siempre estar? vacia a cada visualizaci?n. Para evitarlo tenemos que

                //guardar la lista de filtro aplicada en la visualizaci?n anterior.

                if(this.filterList != null) {

                        this.disableUpdateDrawVersion();

                        //Si ten?a tabla de color le asignamos la original

                        if(param != null && param instanceof GridPalette) {

                                this.filterList.remove(ColorTableFilter.class);

                                RasterFilterListManager filterManager = new RasterFilterListManager(filterList);

                                ColorTableListManager ctm = new ColorTableListManager(filterManager);

                                ctm.addColorTableFilter((GridPalette)param);

                                filterList.move(ColorTableFilter.class, 0);

                                filterList.controlTypes();

                        }

                        layerRaster[nLyr].getRender().setFilterList(filterList);

                        this.enableUpdateDrawVersion();

                }

                if(this.transparency != null)

                        layerRaster[nLyr].getRender().setLastTransparency(transparency);

                if(this.renderBands != null)

                        layerRaster[nLyr].getRender().setRenderBands(renderBands);

                //Dibujamos

                disableUpdateDrawVersion();

                layerRaster[nLyr].draw(null, g, vp, cancel, scale);

                enableUpdateDrawVersion();

                //La primera vez asignamos la lista de filtros asociada al renderizador. Guardamos una referencia

                //en esta clase para que a cada zoom no se pierda.

                if (this.filterList == null)

                        filterList = layerRaster[nLyr].getRender().getFilterList();

                if (this.transparency == null)

                        transparency = layerRaster[nLyr].getRender().getLastTransparency();

                if (this.renderBands == null)

                        renderBands = layerRaster[nLyr].getRender().getRenderBands();

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.raster.IRasterRendering#getRenderFilterList()

         */

        public RasterFilterList getRenderFilterList(){

                return (filterList != null) ? filterList : getRender().getFilterList();

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.hierarchy.IRasterRendering#setRenderFilterList(org.gvsig.raster.grid.filter.RasterFilterList)

         */

        public void setRenderFilterList(RasterFilterList filterList) {

                if (filterList == this.filterList){

                        return;

                }

                this.filterList = filterList;

                this.updateDrawVersion();

                super.getRender().setFilterList(filterList);

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.raster.IRasterRendering#getRenderTransparency()

         */

        public GridTransparency getRenderTransparency() {

                return (transparency != null) ? transparency : getRender().getLastTransparency();

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.hierarchy.IRasterRendering#getRenderBands()

         */

        public int[] getRenderBands() {

                return (renderBands != null) ? renderBands : getRender().getRenderBands();

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.hierarchy.IRasterRendering#setRenderBands(int[])

         */

        public void setRenderBands(int[] renderBands) {

                //TODO: Comprobar si hay cambios

                this.renderBands = renderBands;

                this.updateDrawVersion();

                getRender().setRenderBands(renderBands);

        }

        /**

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

         *

         * @throws LoadLayerException

         * @throws ReadException

         * @return true when a tile has been painted

         */

        private boolean drawTile(Graphics2D g, ViewPort vp, Cancellable cancel,

                        int tile, double scale, int nLyr) throws LoadLayerException, ReadException {

                callCount++;

                // Compute the query geometry

                // 1. Check if it is within borders

                Envelope envelope = getFullEnvelope();

                Envelope vpEnv = vp.getAdjustedExtent();

                if (!vpEnv.intersects(envelope)) {

                        return false;

                }

                // 2. Compute extent to be requested.

                Rectangle2D bBox = new Rectangle2D.Double();

                Rectangle2D.intersect(getRectable2DFromEnvelope(vpEnv),

                                getRectable2DFromEnvelope(envelope), 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 false;

                }

                MyCancellable c = new MyCancellable(cancel);

                try {

                        sz = new Dimension(wImg, hImg);

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

                        }

                        String nameWordFile = getWorldFile(f.getPath());

                        org.gvsig.andami.Utilities.createTemp(nameWordFile, this.getDataWorldFile(bBox, sz));

                        ViewPortData vpData = new ViewPortData(

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

                        vpData.setMat(vp.getAffineTransform());

                        String filePath = f.getAbsolutePath();

                        visualStatus.fileNames[tile] = filePath;

                        try {

                                rasterProcess(filePath, g, vp, scale, cancel, nLyr);

                                //                                this.updateDrawVersion();

                        } catch (FilterTypeException e) {

                        }

                } catch (ValidationException e) {

                        if (!c.isCanceled())

                        {

                                LoadLayerException exception = new LoadLayerException(getName(),e);

                                throw exception;

                        }

                } 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, scale); // mess code

                                } // mess code

                        }

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

                                throw new ConnectionErrorLayerException(getName(),e);

                        }//if

                } catch (WMSException e) {

                        if (!c.isCanceled()) {

                                if (callCount<MAX_RETRY_TIMES) { // mess code

                                        logger.warn("\n[ FLyrWMS.drawFixedSize() ]  Failed in trying " + callCount + "/" + MAX_RETRY_TIMES + ")\n"); // 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, tile, scale, nLyr);

                                } // 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 LoadLayerException(getName(),e);

                                } //if

                        }//if

                }//catch

                callCount--;

                return true;

        }

        /**

         * Gets the georeferencing file name form a raster file

         * @param file

         * a raster file

         * @return

         * a georeferencing file

         */

        private String getWorldFile(String file){                

                String worldFile = file;

                int index = file.lastIndexOf(".");

                if (index > 0){                        

                        worldFile = file.substring(0, index) + getExtensionWorldFile();

                }

                return worldFile;

        }        

        /**

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

                }

                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.getMaxY()+"\n");

                return data.toString();

        }

        /**

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

        throws ReadException {

                closeAndFree();

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

                                visualStatus.fileNames = new String[tiles.getNumTiles()];

                                layerRaster = new FLyrRasterSE[tiles.getNumTiles()];

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

                                        // Parte que dibuja

                                        try {

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

                                                drawTile(g, vp, cancel, tileNr, scale, tileNr);

                                        } catch (NoninvertibleTransformException e) {

                                                e.printStackTrace();

                                        } catch (LoadLayerException e) {

                                                // TODO Auto-generated catch block

                                                e.printStackTrace();

                                        }

                                }