Application: gvSIG desktop

 * 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 3 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., 51

 * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 * For any additional information, do not hesitate to contact us at info AT

 * gvsig.com, or visit our website www.gvsig.com.

 * <p>

 * Represents a generic collection of layers, that can be represented as a node

 * in a tree of nodes of layers.</p>

 * <p>

 * Adapts the basic functionality implemented for a layer in the abstract class

 * <code>FLyrDefault</code>, to a collection of layers, implementing, as well,

 * specific methods for this kind of object, defined in the interfaces

 * <code>VectorialData</code>, <code>LayerCollection</code>, and

 * <code>InfoByPoint</code>.</p>

        InfoByPoint {

    /**

     * List with all listeners registered for this kind of node.

     *

     * @see #addLayerCollectionListener(LayerCollectionListener)

     * @see #removeLayerCollectionListener(LayerCollectionListener)

     * @see #callLayerAdded(LayerCollectionEvent)

     * @see #callLayerAdding(LayerCollectionEvent)

     * @see #callLayerMoved(LayerPositionEvent)

     * @see #callLayerMoving(LayerPositionEvent)

     * @see #callLayerRemoved(LayerCollectionEvent)

     * @see #callLayerRemoving(LayerCollectionEvent)

     */

    protected ArrayList layerCollectionListeners = null;

    /**

     * A synchronized list with the layers.

     *

     * @see #setAllVisibles(boolean)

     * @see #addLayer(FLayer)

     * @see #addLayer(int, FLayer)

     * @see #moveTo(int, int)

     * @see #removeLayer(FLayer)

     * @see #removeLayer(int)

     * @see #removeLayer(String)

     * @see #replaceLayer(String, FLayer)

     * @see #getVisibles()

     * @see #getLayer(int)

     * @see #getLayer(String)

     * @see #getLayersCount()

     * @see #getFullEnvelope()

     */

    protected List layers = null;

    /**

     * The model of the layer.

     *

     * @see #getMapContext()

     */

    protected MapContext fmap;

    /**

     * Useful for debug the problems during the implementation.

     */

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

    public FLayers() {

        super();

        layerCollectionListeners = new ArrayList();

        layers = Collections.synchronizedList(new ArrayList());

        logger = LoggerFactory.getLogger(FLayers.class);

    }

    /*

     * (non-Javadoc)

     * @see com.iver.cit.gvsig.fmap.layers.layerOperations.LayerCollection#addLayerCollectionListener(com.iver.cit.gvsig.fmap.layers.LayerCollectionListener)

     */

    public void addLayerCollectionListener(LayerCollectionListener listener) {

        if (!layerCollectionListeners.contains(listener)) {

            layerCollectionListeners.add(listener);

        }

    }

    /*

     * (non-Javadoc)

     * @see com.iver.cit.gvsig.fmap.layers.layerOperations.LayerCollection#setAllVisibles(boolean)

     */

    public void setAllVisibles(boolean visible) {

        FLayer lyr;

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

            lyr = ((FLayer) layers.get(i));

            lyr.setVisible(visible);

            if (lyr instanceof LayerCollection) {

                ((LayerCollection) lyr).setAllVisibles(visible);

            }

        }

    }

    /*

     * (non-Javadoc)

     * @see com.iver.cit.gvsig.fmap.layers.layerOperations.LayerCollection#removeLayerCollectionListener(com.iver.cit.gvsig.fmap.layers.LayerCollectionListener)

     */

    public void removeLayerCollectionListener(LayerCollectionListener listener) {

        layerCollectionListeners.remove(listener);

    }

    /**

     * Adds a layer on an specified position in this node.

     *

     * @param pos position in the inner list where the layer will be added

     * @param layer a layer

     */

    private void doAddLayer(int pos, FLayer layer) {

        layers.add(pos, layer);

        ToolsLocator.getDisposableManager().bind(layer);

        layer.setParentLayer(this);

        IProjection layerProj = layer.getProjection();

        if (layerProj != null && fmap != null) {

            IProjection mapContextProj = fmap.getProjection();

            // Esta condici?n puede que no fuese exacta para todos los casos

            if (!layerProj.getAbrev().equals(mapContextProj.getAbrev())) {

                ICoordTrans ct = layerProj.getCT(mapContextProj);

                layer.setCoordTrans(ct);

            } else {

                layer.setCoordTrans(null);

            }

        }

        this.updateDrawVersion();

    }

    /*

     * (non-Javadoc)

     * @see com.iver.cit.gvsig.fmap.layers.layerOperations.LayerCollection#addLayer(com.iver.cit.gvsig.fmap.layers.FLayer)

     */

    public void addLayer(FLayer layer) {

        MapContext mco = this.getMapContext();

        if (mco != null) {

            /*

             * Get order manager from map context

             */

            int position = mco.getOrderManager().getPosition(this, layer);

            addLayer(position, layer);

        } else {

            /*

             * This happens when FLayers object is not in a

             * map context, so no order manager is available.

             */

            addLayer(layers.size(), layer);

        }

    }

    /**

     * Adds a layer in an specified position in this node.

     *

     * @param layer a layer

     */

    public void addLayer(int pos, FLayer layer) {

        try {

            //Notificamos a la capa que va a ser a?adida

            if (layer instanceof FLyrDefault) {

                ((FLyrDefault) layer).wakeUp();

            }

            if (layer instanceof FLayers) {

                FLayers layers = (FLayers) layer;

                fmap.addAsCollectionListener(layers);

            }

            callLayerAdding(LayerCollectionEvent.createLayerAddingEvent(layer));

            doAddLayer(pos, layer);

            callLayerAdded(LayerCollectionEvent.createLayerAddedEvent(layer));

        } catch (CancelationException e) {

            logger.warn(e.getMessage());

        } catch (LoadLayerException e) {

            layer.setAvailable(false);

            layer.addError(e);

        }

    }

    /*

     * (non-Javadoc)

     * @see com.iver.cit.gvsig.fmap.layers.layerOperations.LayerCollection#moveTo(int, int)

     */

    public void moveTo(int from, int to) throws CancelationException {

        int newfrom = layers.size() - from - 1;

        int newto = layers.size() - to - 1;

        if (newfrom < 0 || newfrom >= layers.size() || newto < 0 || newto >= layers.size()) {

            return;

        }

        FLayer aux = (FLayer) layers.get(newfrom);

        callLayerMoving(LayerPositionEvent.createLayerMovingEvent(aux, newfrom, newto));

        layers.remove(newfrom);

        layers.add(newto, aux);

        this.updateDrawVersion();

        callLayerMoved(LayerPositionEvent.createLayerMovedEvent(aux, newfrom, newto));

    }

    /**

     * Removes an inner layer.

     *

     * @param lyr a layer

     */

    private void doRemoveLayer(FLayer lyr) {

        layers.remove(lyr);

        lyr.dispose();

        this.updateDrawVersion();

    }

    /*

     * (non-Javadoc)

     * @see com.iver.cit.gvsig.fmap.layers.layerOperations.LayerCollection#removeLayer(com.iver.cit.gvsig.fmap.layers.FLayer)

     */

    public void removeLayer(FLayer lyr) throws CancelationException {

        callLayerRemoving(LayerCollectionEvent.createLayerRemovingEvent(lyr));

        doRemoveLayer(lyr);

        callLayerRemoved(LayerCollectionEvent.createLayerRemovedEvent(lyr));

    }

    /*

     * (non-Javadoc)

     * @see com.iver.cit.gvsig.fmap.layers.layerOperations.LayerCollection#removeLayer(int)

     */

    public void removeLayer(int idLayer) {

        FLayer lyr = (FLayer) layers.get(idLayer);

        callLayerRemoving(LayerCollectionEvent.createLayerRemovingEvent(lyr));

        this.doRemoveLayer(lyr);

        callLayerRemoved(LayerCollectionEvent.createLayerRemovedEvent(lyr));

    }

    /*

     * (non-Javadoc)

     * @see com.iver.cit.gvsig.fmap.layers.layerOperations.LayerCollection#removeLayer(java.lang.String)

     */

    public void removeLayer(String layerName) {

        FLayer lyr;

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

            lyr = ((FLayer) layers.get(i));

            if (lyr.getName().compareToIgnoreCase(layerName) == 0) {

                removeLayer(i);

                break;

            }

        }

    }

    /**

     * Replace a layer identified by its name, by another.

     *

     * @param layerName the name of the layer to be replaced

     * @param layer the new layer

     * @deprecated use {@link FLayers#replaceLayer(FLayer, FLayer)}

     */

    public void replaceLayer(String layerName, FLayer layer) throws LoadLayerException {

        replaceLayer(getLayer(layerName), layer);

    }

    /**

     * Replace a layer by another layer. It search recursively by all the

     * @param layer the layer to be replaced

     * @param newLayer the new layer

    public void replaceLayer(FLayer layer, FLayer newLayer) throws LoadLayerException {

     * Replace a layer by other layer. It search recursively by all the

     *

     * @param parentLayer the parent layer

     * @param layer the layer to be replaced

     * @param newLayer the new layer

    private void replaceLayer(FLayers parentLayer, FLayer layer, FLayer newLayer) throws LoadLayerException {

        FLayer lyr;

            if (lyr.equals(layer)) {

                parentLayer.removeLayer(i);

                parentLayer.addLayer(i, newLayer);

            if (lyr instanceof LayerCollection) {

                replaceLayer((FLayers) lyr, layer, newLayer);

    /*

     * (non-Javadoc)

     * @see com.iver.cit.gvsig.fmap.layers.layerOperations.LayerCollection#getVisibles()

     */

    public FLayer[] getVisibles() {

        ArrayList array = new ArrayList();

        LayersIterator iter = new LayersIterator(this) {

            public boolean evaluate(FLayer layer) {

                return layer.isVisible();

            }

        };

        while (iter.hasNext()) {

            array.add(iter.nextLayer());

        }

        return (FLayer[]) array.toArray(new FLayer[0]);

    }

    /*

     * (non-Javadoc)

     * @see com.iver.cit.gvsig.fmap.layers.layerOperations.LayerCollection#getLayer(int)

     */

    public FLayer getLayer(int index) {

        return (FLayer) layers.get(index);

    }

    /*

     * (non-Javadoc)

     * @see com.iver.cit.gvsig.fmap.layers.layerOperations.LayerCollection#getLayer(java.lang.String)

     */

    public FLayer getLayer(String layerName) {

        FLayer lyr;

        FLayer lyr2;

        ArrayList layerList;

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

            lyr = ((FLayer) layers.get(i));

            if (lyr.getName().compareToIgnoreCase(layerName) == 0) {

                return lyr;

            }

            layerList = new ArrayList();

            splitLayerGroup(lyr, layerList);

            for (int j = 0; j < layerList.size(); j++) {

                lyr2 = ((FLayer) layerList.get(j));

                if (lyr2.getName().compareToIgnoreCase(layerName) == 0) {

                    return lyr2;

                }

            }

        }

        return null;

    }

    /**

     * <p>

     * Splits up a layer group in order to get a layer by name when there are

     * layer groups</p>

     *

     * <p>

     * In <code>result</code> always will be at least one layer.</p>

     *

     * @param layer the layer we are looking for

     * @param result an array list that will have the results of the search

     */

    private void splitLayerGroup(FLayer layer, ArrayList result) {

        int i;

        FLayers layerGroup;

        if (layer instanceof FLayers) {

            layerGroup = (FLayers) layer;

            for (i = 0; i < layerGroup.getLayersCount(); i++) {

                splitLayerGroup(layerGroup.getLayer(i), result);

            }

        } else {

            result.add(layer);

        }

    }

    /*

     * (non-Javadoc)

     * @see com.iver.cit.gvsig.fmap.layers.layerOperations.LayerCollection#getLayersCount()

     */

    public int getLayersCount() {

        return layers.size();

    }

    /*

     * (non-Javadoc)

     * @see com.iver.cit.gvsig.fmap.layers.FLayer#draw(java.awt.image.BufferedImage, java.awt.Graphics2D, com.iver.cit.gvsig.fmap.ViewPort, com.iver.utiles.swing.threads.Cancellable, double)

     */

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

            Cancellable cancel, double scale) throws ReadException {

        // FIXME Arreglar este error

        throw new RuntimeException("Esto no deberia de llamarse");

    }

    /*

     * (non-Javadoc)

     *

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

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

     * com.iver.utiles.swing.threads.Cancellable, double,

     * javax.print.attribute.PrintAttributes)

     */

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

            double scale, PrintAttributes properties)

            throws ReadException {

        throw new RuntimeException("No deberia pasar por aqui");

    }

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

            double scale, PrintAttributes properties)

            throws ReadException {

        this.print_old(g, viewPort, cancel, scale, properties, null);

    }

    /**

     * <p>

     * Checks all layers (each one as a sub-node of this node <i>collection of

     * layers</i>) of this collection and draws their requested properties. If a

     * node is a group of layers (<code>ComposedLayer</code>), executes it's

     * drawn.</p>

     *

     * <p>

     * All nodes which could group with the composed layer <code>group</code>,

     * will be drawn together. And once the <code>

     * group</code> is drawn, will be set to <code>null</code> if hasn't a

     * parent layer.</p>

     *

     * <p>

     * The particular implementation depends on the kind of each layer and

     * composed layer. And this process can be cancelled at any time by the

     * shared object <code>cancel</code>.</p>

     *

     * <p>

     * According the print quality, labels will be printed in different

     * resolution:

     * <ul>

     * <li><b>PrintQuality.DRAFT</b>: 72 dpi (dots per inch).</li>

     * <li><b>PrintQuality.NORMAL</b>: 300 dpi (dots per inch).</li>

     * <li><b>PrintQuality.HIGH</b>: 600 dpi (dots per inch).</li>

     * </ul>

     * </p>

     *

     * @param g for rendering 2-dimensional shapes, text and images on the

     * Java(tm) platform

     * @param viewPort the information for drawing the layers

     * @param cancel shared object that determines if this layer can continue

     * being drawn

     * @param scale the scale of the view. Must be between

     * {@linkplain FLayer#getMinScale()} and {@linkplain FLayer#getMaxScale()}.

     * @param properties properties that will be print

     * @param group a composed layer pending to paint; if this parameter is

     * <code>null</code>, the composed layer

     *

     * @return <code>null</code> if the layers in <code>group</code> had been

     * drawn or were <code>null</code>; otherwise, the <code>group</code>

     *

     * @see FLayer#print(Graphics2D, ViewPort, Cancellable, double,

     * PrintAttributes)

     *

     * @throws ReadDriverException if fails the driver reading the data.

     */

    public ComposedLayer print_old(Graphics2D g, ViewPort viewPort, Cancellable cancel, double scale, PrintAttributes properties, ComposedLayer group)

            throws ReadException {

        double dpi = 72;

        int resolution = properties.getPrintQuality();

        if (resolution == PrintAttributes.PRINT_QUALITY_NORMAL) {

            dpi = 300;

        } else if (resolution == PrintAttributes.PRINT_QUALITY_HIGH) {

            dpi = 600;

        } else if (resolution == PrintAttributes.PRINT_QUALITY_DRAFT) {

            dpi = 72;

        }

        // calculando la escala en pantalla, no para el layout.

        // Revisar esto.

        // TODO: We have to check when we have to call the drawLabels method when exists a ComposedLayer group.

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

            FLayer lyr = (FLayer) layers.get(i);

            if (!lyr.isVisible() || !lyr.isWithinScale(scale)) {

                continue;

            }

            try {

                // Checks for draw group (ComposedLayer)

                if (group != null) {

                    if (lyr instanceof FLayers) {

                        group = ((FLayers) lyr).print_old(g, viewPort, cancel, scale, properties, group);

                    } else {

                        // If layer can be added to the group, does it

                        if (lyr instanceof ILabelable

                                && ((ILabelable) lyr).isLabeled()

                                && ((ILabelable) lyr).getLabelingStrategy() != null

                                && ((ILabelable) lyr).getLabelingStrategy().shouldDrawLabels(scale)) {

                            group.add(lyr);

                        } else {

                            // draw the 'pending to draw' layer group

                            group.print(g, viewPort, cancel, scale, properties);

                            // gets a new group instance

                            if (lyr instanceof ILabelable

                                    && ((ILabelable) lyr).isLabeled()

                                    && ((ILabelable) lyr).getLabelingStrategy() != null

                                    && ((ILabelable) lyr).getLabelingStrategy().shouldDrawLabels(scale)) {

                                group = lyr.newComposedLayer();

                            } else {

                                group = null;

                            }

                            // if layer hasn't group, draws it inmediately

                            if (group == null) {

                                if (lyr instanceof FLayers) {

                                    group = ((FLayers) lyr).print_old(g, viewPort, cancel, scale, properties, group);

                                } else {

                                    lyr.print(g, viewPort, cancel, scale, properties);

                                    if (lyr instanceof ILabelable

                                            && ((ILabelable) lyr).isLabeled()

                                            && ((ILabelable) lyr).getLabelingStrategy() != null

                                            && ((ILabelable) lyr).getLabelingStrategy().shouldDrawLabels(scale)) {

                                        ILabelable lLayer = (ILabelable) lyr;

                                        lLayer.drawLabels(null, g, viewPort, cancel, scale, dpi);

                                    }

                                }

                            } else {

                                // add the layer to the group

                                group.setMapContext(fmap);

                                group.add(lyr);

                            }

                        }

                    }

                } else {

                    // gets a new group instance

                    group = lyr.newComposedLayer();

                    // if layer hasn't group, draws it inmediately

                    if (group == null) {

                        if (lyr instanceof FLayers) {

                            group = ((FLayers) lyr).print_old(g, viewPort, cancel, scale, properties, group);

                        } else {

                            lyr.print(g, viewPort, cancel, scale, properties);

                            if (lyr instanceof ILabelable && ((ILabelable) lyr).isLabeled()) {

                                ILabelable lLayer = (ILabelable) lyr;

                                lLayer.drawLabels(null, g, viewPort, cancel, scale, dpi);

                            }

                        }

                    } else {

                        // add the layer to the group

                        group.setMapContext(fmap);

                        group.add(lyr);

                    }

                }

                ///// CHEMA ComposedLayer

            } catch (Exception e) {

                String mesg = Messages.getString("error_printing_layer") + " " + lyr.getName() + ": " + e.getMessage();

                fmap.addLayerError(mesg);

                logger.error(mesg, e);

            }

        }

        ///// CHEMA ComposedLayer

        if (group != null && this.getParentLayer() == null) {

            //si tenemos un grupo pendiente de pintar, pintamos

            group.print(g, viewPort, cancel, scale, properties);

            group = null;

        }

        //			getVirtualLayers().print( g, viewPort, cancel, scale, properties);

        //		}

        ///// CHEMA ComposedLayer

        return group;

        ///// CHEMA ComposedLayer

    }

    /*

     * (non-Javadoc)

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

     */

    public Envelope getFullEnvelope() {

        Envelope rAux = null;

        boolean first = true;

        for (Iterator iter = layers.iterator(); iter.hasNext();) {

            FLayer capa = (FLayer) iter.next();

            try {

                if (first) {

                    rAux = (Envelope) capa.getFullEnvelope().clone();

                    first = false;

                } else {

                    rAux.add(capa.getFullEnvelope());

                }

            } catch (Exception e) {

                e.printStackTrace();//TODO hay que revisar para determinar el comportamiento que espera el usuario.

            }

        }

        return rAux;

    }

    /**

     * Notifies all listeners associated to this collection of layers, that

     * another layer is going to be added or replaced in the internal list of

     * layers.

     *

     * @param e a layer collection event with the new layer

     */

    protected void callLayerAdding(LayerCollectionEvent event)

            throws CancelationException {

        ArrayList aux = (ArrayList) layerCollectionListeners.clone();

        for (Iterator iter = aux.iterator(); iter.hasNext();) {

            ((LayerCollectionListener) iter.next()).layerAdding(event);

        }

    }

    /**

     * Notifies all listeners associated to this collection of layers, that a

     * layer is going to be removed from the internal list of layers.

     *

     * @param event a layer collection event with the layer being removed

     *

     * @throws CancelationException any exception produced during the

     * cancellation of the driver.

     */

    protected void callLayerRemoving(LayerCollectionEvent event)

            throws CancelationException {

        ArrayList aux = (ArrayList) layerCollectionListeners.clone();

        for (Iterator iter = aux.iterator(); iter.hasNext();) {

            ((LayerCollectionListener) iter.next()).layerRemoving(event);

        }

    }

    /**

     * Notifies all listeners associated to this collection of layers, that a

     * layer is going to be moved in the internal list of layers.

     *

     * @param event a layer collection event with the layer being moved, and the

     * initial and final positions

     *

     * @throws CancelationException any exception produced during the

     * cancellation of the driver.

     */

    protected void callLayerMoving(LayerPositionEvent event)

            throws CancelationException {

        ArrayList aux = (ArrayList) layerCollectionListeners.clone();

        for (Iterator iter = aux.iterator(); iter.hasNext();) {

            ((LayerCollectionListener) iter.next()).layerMoving(event);

        }

    }

    /**

     * Notifies all listeners associated to this collection of layers, that

     * another layer has been added or replaced in the internal list of layers.

     *

     * @param e a layer collection event with the new layer

     */

    protected void callLayerAdded(LayerCollectionEvent event) {

        ArrayList aux = (ArrayList) layerCollectionListeners.clone();

        for (Iterator iter = aux.iterator(); iter.hasNext();) {

            ((LayerCollectionListener) iter.next()).layerAdded(event);

        }

    }

    /**

     * Notifies all listeners associated to this collection of layers, that

     * another layer has been removed from the internal list of layers.

     *

     * @param e a layer collection event with the layer removed

     */

    protected void callLayerRemoved(LayerCollectionEvent event) {

        ArrayList aux = (ArrayList) layerCollectionListeners.clone();

        for (Iterator iter = aux.iterator(); iter.hasNext();) {

            ((LayerCollectionListener) iter.next()).layerRemoved(event);

        }

    }

    /**

     * Notifies all listeners associated to this collection of layers, that

     * another layer has been moved in the internal list of layers.

     *

     * @param e a layer collection event with the layer moved, and the initial

     * and final positions

     */

    protected void callLayerMoved(LayerPositionEvent event) {

        ArrayList aux = (ArrayList) layerCollectionListeners.clone();

        for (Iterator iter = aux.iterator(); iter.hasNext();) {

            ((LayerCollectionListener) iter.next()).layerMoved(event);

        }

    }

    public void saveToState(PersistentState state) throws PersistenceException {

        super.saveToState(state);

        state.set("mapContext", fmap);

        List layersToSave = new ArrayList();

        Iterator iter = this.layers.iterator();

        while (iter.hasNext()) {

            FLayer layer = (FLayer) iter.next();

            if (!layer.isTemporary()) {

                layersToSave.add(layer);

            }

        }

        state.set("layers", layersToSave);

    }

    public void loadFromState(PersistentState state) throws PersistenceException {

        super.loadFromState(state);

        setMapContext((MapContext) state.get("mapContext"));

        Iterator iter = state.getIterator("layers");

        while (iter.hasNext()) {

            FLayer item = (FLayer) iter.next();

            layers.add(item);

        }

    }

    /*

     * (non-Javadoc)

     * @see com.iver.cit.gvsig.fmap.layers.FLyrDefault#getMapContext()

     */

    public MapContext getMapContext() {

        return fmap;

    }

    /*

     * I don't think this implementation makes any sense.

     * We can group layers with different transformations,

     * we cannot set the ICoordTrans for all (?)

     * 

     public void setCoordTrans(ICoordTrans ct) {

     super.setCoordTrans(ct);

     for (Iterator iter = layers.iterator(); iter.hasNext();) {

     FLayer layer = (FLayer) iter.next();

     layer.setCoordTrans(ct);

     }

     }

     */

    /*

     * (non-Javadoc)

     * @see com.iver.cit.gvsig.fmap.layers.layerOperations.LayerCollection#setAllActives(boolean)

     */

    public void setAllActives(boolean active) {

        FLayer lyr;

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

            lyr = ((FLayer) layers.get(i));

            lyr.setActive(active);

            if (lyr instanceof LayerCollection) {

                ((LayerCollection) lyr).setAllActives(active);

            }

        }

    }

    /*

     * (non-Javadoc)

     * @see com.iver.cit.gvsig.fmap.layers.layerOperations.LayerCollection#getActives()

     */

    public FLayer[] getActives() {

        ArrayList ret = new ArrayList();

        LayersIterator it = new LayersIterator(this) {