Application: gvSIG desktop » gvSIG 3D

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2015 gvSIG Association

 *

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

 */

package org.gvsig.view3d.swing.impl;

import gov.nasa.worldwind.Configuration;

import gov.nasa.worldwind.Factory;

import gov.nasa.worldwind.Model;

import gov.nasa.worldwind.WorldWind;

import gov.nasa.worldwind.avlist.AVKey;

import gov.nasa.worldwind.avlist.AVList;

import gov.nasa.worldwind.avlist.AVListImpl;

import gov.nasa.worldwind.awt.WorldWindowGLJPanel;

import gov.nasa.worldwind.globes.Earth;

import gov.nasa.worldwind.globes.EarthFlat;

import gov.nasa.worldwind.globes.ElevationModel;

import gov.nasa.worldwind.layers.CompassLayer;

import gov.nasa.worldwind.layers.Layer;

import gov.nasa.worldwind.layers.LayerList;

import gov.nasa.worldwind.layers.ScalebarLayer;

import gov.nasa.worldwind.layers.SkyColorLayer;

import gov.nasa.worldwind.layers.SkyGradientLayer;

import gov.nasa.worldwind.layers.StarsLayer;

import gov.nasa.worldwind.layers.ViewControlsLayer;

import gov.nasa.worldwind.layers.ViewControlsSelectListener;

import gov.nasa.worldwind.layers.WorldMapLayer;

import gov.nasa.worldwind.terrain.CompoundElevationModel;

import gov.nasa.worldwind.terrain.ZeroElevationModel;

import gov.nasa.worldwind.util.StatusBar;

import gov.nasa.worldwind.view.orbit.BasicOrbitView;

import gov.nasa.worldwind.view.orbit.FlatOrbitView;

import java.awt.BorderLayout;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import javax.swing.JComponent;

import javax.swing.JPanel;

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

import org.gvsig.fmap.mapcontext.MapContext;

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.observer.BaseNotification;

import org.gvsig.tools.observer.Notification;

import org.gvsig.tools.observer.ObservableHelper;

import org.gvsig.tools.observer.Observer;

import org.gvsig.tools.task.Cancellable;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.view3d.lib.api.View3DLocator;

import org.gvsig.view3d.lib.api.View3DManager;

import org.gvsig.view3d.lib.api.properties.LayerProperties3D;

import org.gvsig.view3d.lib.api.properties.RasterLayerProperties3D;

import org.gvsig.view3d.lib.api.properties.VectorialLayerProperties3D;

import org.gvsig.view3d.swing.api.MapControl3D;

import org.gvsig.view3d.swing.api.View3DSwingLocator;

import org.gvsig.view3d.swing.api.View3DSwingManager;

import org.gvsig.view3d.swing.api.View3DSwingManager.TYPE;

import org.gvsig.view3d.swing.api.properties.GeneralProperties3D;

import org.gvsig.view3d.swing.api.properties.MapControlProperties3D;

import org.gvsig.view3d.swing.impl.data.DefaultLayerConverter;

import org.gvsig.view3d.swing.impl.data.DefaultTiledImageLayer;

import org.gvsig.view3d.swing.impl.data.LayerConverter;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Default implementation of {@link MapControl3D}.

 * 

 * @author <a href="mailto:lmarques@disid.com">Lluis Marques</a>

 */

@SuppressWarnings("deprecation")

public class DefaultMapControl3D extends JPanel implements MapControl3D {

    private static final long serialVersionUID = 2024899922367896097L;

    private static final Logger LOG = LoggerFactory

        .getLogger(DefaultMapControl3D.class);

    private Map<FLayer, Long> drawLayerStatus;

    private ObservableHelper observableHelper;

    /**

     * Name of gvSIG MapContext property

     */

    public static final String GVSIG_MAPCONTROL3D =

        "org.gvsig.view3d.swing.api.MapControl3D";

    /**

     * Name of gvSIG Layer property

     */

    public static final String GVSIG_LAYER =

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

    private MapContext mapContext;

    private MapControlProperties3D properties;

    private ExtendedPropertiesSupport viewProperties;

    private WorldWindowGLJPanel wwd;

    private StatusBar statusBar;

    private TYPE type;

    private Cancellable cancellable;

    /**

     * Default constructor of {@link DefaultMapControl3D}. Initializes local

     * fileds, sets configuration depends on {@link TYPE} and adds

     * <code>MapContext</code> layers.

     * 

     * @param theMapContext

     *            associated <code>MapContext</code>

     * @param type

     *            Type of this {@link DefaultMapControl3D}. See {@link TYPE}.

     * @param viewProperties

     *            View properties to register this <code>MapControl3D</code>

     */

    public DefaultMapControl3D(MapContext theMapContext, TYPE type,

        ExtendedPropertiesSupport viewProperties) {

        super(new BorderLayout());

        this.mapContext = theMapContext;

        this.type = type;

        this.cancellable = getCancellable();

        this.observableHelper = new ObservableHelper();

        this.drawLayerStatus = new HashMap<FLayer, Long>();

        this.viewProperties = viewProperties;

        // Set mode before instantiation

        if (type == TYPE.SPHERE) {

            setSpherePanelConfiguration();

        } else if (type == TYPE.FLAT) {

            setFlatPanelConfiguration();

        }

        super.add(getWwd(), BorderLayout.CENTER);

        super.add(getStatusBar(), BorderLayout.SOUTH);

        try {

            addGvSIGLayers(mapContext.getLayers());

        } catch (BaseException e) {

            LOG.info("Can't add MapControl layers", e);

        }

        addLayerCollectionListener(mapContext.getLayers());

        addLayerListener(mapContext.getLayers());

        setGeneral3DProperties();

        View3DSwingManager swingManager = View3DSwingLocator.getManager();

        this.properties = swingManager.getMapControl3DProperties(viewProperties);

        addChangePropertyListener(this.properties);

        setMapControl3DProperties();

        addVerticalExaggerationChangeProperyListener();

    }

    private void setGeneral3DProperties() {

        View3DSwingManager swingManager = View3DSwingLocator.getManager();

        GeneralProperties3D general3DProperties =

            swingManager.getGeneral3DProperties();

        this.setAtmosphereVisibility(general3DProperties

            .getAtmosphereVisibility());

        this.setMiniMapVisibility(general3DProperties.getMinimapVisibility());

        this.setNorthIndicatorVisibility(general3DProperties

            .getNorthIndicatorVisibility());

        this.setStarsBackgroundVisibility(general3DProperties

            .getStarsBackgroundVisibility());

        this.setScaleVisibility(general3DProperties.getScaleVisibility());

    }

    private void addChangePropertyListener(MapControlProperties3D properties) {

        properties.addPropertyChangeListener(new PropertyChangeListener() {

            public void propertyChange(PropertyChangeEvent evt) {

                String propertyName = evt.getPropertyName();

                if (MapControlProperties3D.SPHERE_VERTICAL_EXAGGERATION_PROPERTY_NAME

                    .equals(propertyName) && getType() == TYPE.SPHERE) {

                    setVerticalExaggeration((Double) evt.getNewValue());

                } else if (MapControlProperties3D.FLAT_VERTICAL_EXAGGERATION_PROPERTY_NAME

                    .equals(propertyName) && getType() == TYPE.FLAT) {

                    setVerticalExaggeration((Double) evt.getNewValue());

                } else if (MapControlProperties3D.BLUE_MARBEL_VISIBILITY_PROPERTY_NAME

                    .equals(propertyName)) {

                    boolean visibility = (Boolean) evt.getNewValue();

                    setBlueMarbelLayerVisibility(visibility);

                } else if (MapControlProperties3D.NASA_LANDSAT_VISIBILITY_PROPERTY_NAME

                    .equals(propertyName)) {

                    boolean visibility = (Boolean) evt.getNewValue();

                    setNasaLandsatLayerVisibility(visibility);

                } else if (MapControlProperties3D.DEFAULT_ELEVATION_VISIBILITY_PROPERTY_NAME

                    .equals(propertyName)) {

                    boolean visibility = (Boolean) evt.getNewValue();

                    setDefaultElevationVisibility(visibility);

                }

            }

        });

    }

    private void addLayerCollectionListener(FLayers layers) {

        if (layers == null) {

            return;

        }

        layers.addLayerCollectionListener(new LayerCollectionListener() {

            public void visibilityChanged(LayerCollectionEvent e)

                throws CancelationException {

            }

            public void layerRemoving(LayerCollectionEvent e)

                throws CancelationException {

            }

            public void layerRemoved(LayerCollectionEvent e) {

                if(properties.getAutoLayerSynchronize()){

                    synchronizeLayers();

                }

            }

            public void layerMoving(LayerPositionEvent e)

                throws CancelationException {

            }

            public void layerMoved(LayerPositionEvent e) {

                int oldPos = e.getOldPos();

                int newPos = e.getNewPos();

                FLayer layer = e.getAffectedLayer();

                LayerList layers = getWwd().getModel().getLayers();

                Layer tileImageLayer = getTileImageLayer(layer);

                int tiledIndex = layers.indexOf(tileImageLayer);

                layers.remove(tiledIndex);

                layers.add(tiledIndex + (newPos - oldPos), tileImageLayer);

            }

            public void layerAdding(LayerCollectionEvent e)

                throws CancelationException {

            }

            public void layerAdded(LayerCollectionEvent e) {

                FLayer affectedLayer = e.getAffectedLayer();

                affectedLayer.addLayerListener(getLayerListener());

                if(properties.getAutoLayerSynchronize()){

                    synchronizeLayers();

                }

            }

        });

    }

    private void addLayerListener(FLayer layer) {

        if (layer == null) {

            return;

        }

        layer.addLayerListener(getLayerListener());

    }

    private LayerListener getLayerListener() {

        return new LayerListener() {

            public void visibilityChanged(LayerEvent e) {

                if(properties.getAutoLayerSynchronize()){

                    FLayer layer = e.getSource();

                    Layer tiledImageLayer = getTileImageLayer(layer);

                    if (tiledImageLayer != null) {

                        tiledImageLayer.setEnabled(layer.isVisible());

                    }

                }

            }

            public void nameChanged(LayerEvent e) {

            }

            public void editionChanged(LayerEvent e) {

            }

            public void drawValueChanged(LayerEvent e) {

                MapControlProperties3D properties = getProperties();

                if (properties.getAutoLayerSynchronize()) {

                    FLayer layer = e.getSource();

                    if (layer.isAvailable()) {

                        synchronizeLayers();

                    }

                }

            }

            public void activationChanged(LayerEvent e) {

            }

        };

    }

    private void addGvSIGLayer(FLayer layer) throws DataException {

        LayerList layers = getWwd().getModel().getLayers();

        addGvSIGLayer(layer, layers.size());

    }

    private void addGvSIGLayer(FLayer layer, int index) throws DataException {

        LayerConverter converter = new DefaultLayerConverter();

        View3DManager manager = View3DLocator.getManager();

        LayerProperties3D layerProperties = manager.getLayerProperties(layer);

        if (layerProperties.getElevation() == false) {

            if ((layerProperties instanceof VectorialLayerProperties3D && ((VectorialLayerProperties3D) layerProperties)

                .getRasterized() == true)

                || layerProperties instanceof RasterLayerProperties3D) {

                Layer rasterTiledLayer = converter.convertToLayer(this, layer);

                rasterTiledLayer.setEnabled(layer.isVisible());

                getWwd().getModel().getLayers().add(index, rasterTiledLayer);

                drawLayerStatus.put(layer, layer.getDrawVersion());

            } else {

                return; // TODO Convert to 3D vectorial layer

            }

        } else {

            ElevationModel elevationModel =

                converter.convertToElevationModel(this, layer);

            CompoundElevationModel cem =

                (CompoundElevationModel) getWwd().getModel().getGlobe()

                    .getElevationModel();

            cem.addElevationModel(elevationModel);

        }

    }

    private void addGvSIGLayers(FLayers layers) throws BaseException {

        if (layers == null) {

            return;

        }

        layers.accept(new LayersVisitor() {

            public void visit(Object obj) throws VisitCanceledException,

                BaseException {

                throw new UnsupportedOperationException();

            }

            public void visit(FLayer layer) throws BaseException {

                if (layer.isAvailable()) {

                    addGvSIGLayer(layer);

                }

            }

        });

        getWwd().redraw();

    }

    private void setBlueMarbelLayerVisibility(boolean visibility) {

        if(visibility == getBlueMarbleLayerVisibility()){

            return;

        }

        setWWLayerVisibility("Blue Marble May 2004", visibility);

        getProperties().setBlueMarbleLayerVisibility(visibility);

    }

    private boolean getBlueMarbleLayerVisibility(){

        return isWWLayerVisible("Blue Marble May 2004");

    }

    protected void setDefaultElevationVisibility(boolean visibility) {

        ElevationModel elevationModel =

            getWwd().getModel().getGlobe().getElevationModel();

        CompoundElevationModel compoundElevationModel =

            (CompoundElevationModel) elevationModel;

        List<ElevationModel> elevationModels =

            compoundElevationModel.getElevationModels();

        if(visibility == getDefaultElevationModelVisiblility()){

            return;

        }

        if (visibility) {

            for (ElevationModel eModel : elevationModels) {

                if (eModel instanceof ZeroElevationModel) {

                    compoundElevationModel.removeElevationModel(eModel);

                    compoundElevationModel

                        .addElevationModel(0,getDefaultElevationModel());

                    return;

                }

            }

        } else {

            for (ElevationModel eModel : elevationModels) {

                if (eModel.getName().equals("USA 10m, World 30m, Ocean 900m")) {

                    compoundElevationModel.removeElevationModel(eModel);

                    compoundElevationModel.addElevationModel(0,

                        new ZeroElevationModel());

                    return;

                }

            }

        }

        getProperties().setDefaultElevationVisibility(visibility);

    }

    private boolean getDefaultElevationModelVisiblility(){

        ElevationModel elevationModel =

            getWwd().getModel().getGlobe().getElevationModel();

        CompoundElevationModel compoundElevationModel =

            (CompoundElevationModel) elevationModel;

        List<ElevationModel> elevationModels =

            compoundElevationModel.getElevationModels();

        for (ElevationModel eModel : elevationModels) {

            if (eModel.getName().equals("USA 10m, World 30m, Ocean 900m")) {

                return true;

            }

        }

        return false;

    }

    private ElevationModel getDefaultElevationModel(){

        Factory elevationFactory =

            (Factory) WorldWind.createConfigurationComponent(AVKey.ELEVATION_MODEL_FACTORY);

        String defaultModelFile = Configuration.getStringValue(AVKey.EARTH_ELEVATION_MODEL_CONFIG_FILE);

        CompoundElevationModel elevationModel = (CompoundElevationModel) elevationFactory.createFromConfigSource(

            defaultModelFile, new AVListImpl());

        return elevationModel.getElevationModels().get(0);

    }

    private void setNasaLandsatLayerVisibility(boolean visibility) {

        if(visibility == getNasaLandsatLayerVisibility()){

            return;

        }

        setWWLayerVisibility("i-cubed Landsat", visibility);

        getProperties().setNasaLandsatVisibility(visibility);

    }

    private boolean getNasaLandsatLayerVisibility(){

        return isWWLayerVisible("i-cubed Landsat");

    }

    @SuppressWarnings("rawtypes")

    private void setWWLayerVisibility(Class layerClazz, boolean visiblity) {

        List<Layer> layersByClass =

            getWwd().getModel().getLayers().getLayersByClass(layerClazz);

        for (Layer layer : layersByClass) {

            layer.setEnabled(visiblity);

        }

    };

    private void setWWLayerVisibility(String layerName, boolean visibilty) {

        Layer layer = getWwd().getModel().getLayers().getLayerByName(layerName);

        if (layer != null) {

            layer.setEnabled(visibilty);

        }

    };

    private void addNavigation() {

        ViewControlsLayer controlsLayer = new ViewControlsLayer();

        Model model = getWwd().getModel();

        model.getLayers().add(controlsLayer);

        getWwd().addSelectListener(

            new ViewControlsSelectListener(wwd, controlsLayer));

    }

    public JComponent asJComponent() {

        return this;

    }

    public void dispose() {

        Thread disposeThread = new Thread(new Runnable() {

            public void run() {

                Notification beforeDisposeNotification =

                    new BaseNotification(

                        MapControl3D.BEFORE_DISPOSE_MAPCONTEX3D_NOTIFICATION,

                        null);

                observableHelper.notifyObservers(DefaultMapControl3D.this,

                    beforeDisposeNotification);

                while (WorldWind.getRetrievalService().hasActiveTasks()) {

                    try {

                        Thread.sleep(100);

                    } catch (InterruptedException e) {

                        LOG.warn("This thread has been interrupted, dispose action can not be performed");

                        return;

                    }

                }

                disposeWwd();

                if (getType() == TYPE.SPHERE) {

                    viewProperties.getExtendedProperties().remove(

                        "spehereMapControl3D");

                } else if (getType() == TYPE.FLAT) {

                    viewProperties.getExtendedProperties().remove(

                        "flatMapControl3D");

                }

                Notification afterDisposeNotification =

                    new BaseNotification(

                        MapControl3D.AFTER_DISPOSE_MAPCONTEX3D_NOTIFICATION,

                        null);

                observableHelper.notifyObservers(DefaultMapControl3D.this,

                    afterDisposeNotification);

            }

        }, "Dispose World Wind thread");

        disposeThread.start();

    }

    public Cancellable getCancellable() {

        if (this.cancellable == null) {

            this.cancellable = new Cancellable() {

                private boolean cancel = false;

                public void setCanceled(boolean canceled) {

                    this.cancel = canceled;

                }

                public boolean isCanceled() {

                    return cancel;

                }

            };

        }

        return this.cancellable;

    }

    public MapContext getMapContext() {

        return this.mapContext;

    }

    private StatusBar getStatusBar() {

        if (statusBar == null) {

            statusBar = new StatusBar();

            this.add(statusBar, BorderLayout.PAGE_END);

            statusBar.setEventSource(wwd);

        }

        return statusBar;

    }

    private Layer getTileImageLayer(FLayer layer) {

        List<Layer> layers =

            getWwd().getModel().getLayers()

                .getLayersByClass(DefaultTiledImageLayer.class);

        for (Layer tiledLayer : layers) {

            AVList constructionParams =

                (AVList) tiledLayer.getValue(AVKey.CONSTRUCTION_PARAMETERS);

            if (constructionParams != null) {

                FLayer likedLayer =

                    (FLayer) constructionParams.getValue(GVSIG_LAYER);

                if (layer.equals(likedLayer)) {

                    return tiledLayer;

                }

            }

        }

        return null;

    }

    public TYPE getType() {

        return this.type;

    }

    public double getVerticalExaggeration() {

        return getWwd().getSceneController().getVerticalExaggeration();

    }

    protected WorldWindowGLJPanel getWwd() {

        if (this.wwd == null) {

            intializeWWPanel();

        }

        return this.wwd;

    }

    private void disposeWwd() {

        if (getWwd() != null) {

            this.wwd = null;

        }

    }

    public void setAtmosphereVisibility(boolean visibility) {

        if (getType() == TYPE.SPHERE) {

            setWWLayerVisibility(SkyGradientLayer.class, visibility);

        } else if (getType() == TYPE.FLAT) {

            setWWLayerVisibility(SkyColorLayer.class, visibility);

        }

    }

    public void setMiniMapVisibility(boolean visiblity) {

        setWWLayerVisibility(WorldMapLayer.class, visiblity);

    }

    public void setNorthIndicatorVisibility(boolean visibility) {

        setWWLayerVisibility(CompassLayer.class, visibility);

    }

    public void setScaleVisibility(boolean visibility) {

        setWWLayerVisibility(ScalebarLayer.class, visibility);

    }

    public void setStarsBackgroundVisibility(boolean visibility) {

        setWWLayerVisibility(StarsLayer.class, visibility);

    }

    private void intializeWWPanel() {

        wwd = new WorldWindowGLJPanel();

        // Create the default model as described in the current worldwind

        // properties.

        Model m =

            (Model) WorldWind

                .createConfigurationComponent(AVKey.MODEL_CLASS_NAME);

        getWwd().setModel(m);

        // Add view control layer

        addNavigation();

    }

    public void reloadLayers() {

        getWwd().getModel().getLayers().removeAll();

        if (this.mapContext != null && this.mapContext.getLayers() != null) {

            try {

                addGvSIGLayers(mapContext.getLayers());

            } catch (BaseException e) {

                LOG.error("Can't add MapContext layers of {}",

                    mapContext.getLayers(), e);

            }

        }

    }

    private void setFlatPanelConfiguration() {

        Configuration.setValue(AVKey.GLOBE_CLASS_NAME,

            EarthFlat.class.getName());

        Configuration.setValue(AVKey.VIEW_CLASS_NAME,

            FlatOrbitView.class.getName());

    }

    private void setMapControl3DProperties() {

        double verticalExaggeration = 0;

        if (getType() == TYPE.SPHERE) {

            verticalExaggeration =

                this.properties.getSphereVerticalExaggeration();

        } else if (getType() == TYPE.FLAT) {

            verticalExaggeration =

                this.properties.getFlatVerticalExaggeration();

        }

        setVerticalExaggeration(verticalExaggeration);

        boolean visibility = this.properties.getBlueMarbleLayerVisibility();

        setBlueMarbelLayerVisibility(visibility);

        visibility = this.properties.getNasaLandsatLayerVisibility();

        setNasaLandsatLayerVisibility(visibility);

        visibility = this.properties.getDefaultElevationVisibility();

        setDefaultElevationVisibility(visibility);

    }

    private void setSpherePanelConfiguration() {

        Configuration.setValue(AVKey.GLOBE_CLASS_NAME, Earth.class.getName());

        Configuration.setValue(AVKey.VIEW_CLASS_NAME,

            BasicOrbitView.class.getName());

    }

    public void setVerticalExaggeration(double verticalExaggeration) {

        if (getVerticalExaggeration() == verticalExaggeration) {

            return;

        }

        getWwd().getSceneController().setVerticalExaggeration(

            verticalExaggeration);

        if (getType() == TYPE.SPHERE) {

            getProperties().setSphereVerticalExaggeration(verticalExaggeration);

        } else if (getType() == TYPE.FLAT) {

            getProperties().setFlatVerticalExaggeration(verticalExaggeration);

        }

    }

    public synchronized void synchronizeLayers() {

        FLayers layers = this.mapContext.getLayers();

        // Remove old layers

        List<FLayer> layersRemoved = new ArrayList<FLayer>();

        for (FLayer layer : drawLayerStatus.keySet()) {

            if (layers.getLayer(layer.getName()) == null) {

                int index = removeGvSIGLayer(layer);

                if(index >= 0){

                    layersRemoved.add(layer);

                }

            }

        }

        for (FLayer fLayer : layersRemoved) {

            drawLayerStatus.remove(fLayer);

        }

        // Add new layers

        try {

            layers.accept(new LayersVisitor() {

                public void visit(Object obj) throws VisitCanceledException,

                    BaseException {

                    throw new UnsupportedOperationException();

                }

                public void visit(FLayer layer) throws BaseException {

                    if(!drawLayerStatus.containsKey(layer)){

                        drawLayerStatus.put(layer, layer.getDrawVersion());

                        addGvSIGLayer(layer);

                    }

                }

            });

        } catch (BaseException e) {

            LOG.error("Can't synchronize layers. Can't visit layers of {}",

                mapContext.toString(), e);

        }

        // Update registered layers

        for (FLayer layer : drawLayerStatus.keySet()) {

            if (layer instanceof FLyrDefault) {

                FLyrDefault defaultLayer = (FLyrDefault) layer;

                if (defaultLayer.hasChangedForDrawing(drawLayerStatus

                    .get(layer))) {

                    replaceGvSIGLayer(defaultLayer);

                }

            }

        }

    }

    private int removeGvSIGLayer(FLayer layer) {

        List<Layer> loadedLayers = getWwd().getModel().getLayers();

        Layer tiledImageLayer = getTileImageLayer(layer);

        if (tiledImageLayer == null) {

            return -1;

        }

        int layerIndex = loadedLayers.indexOf(tiledImageLayer);

        getWwd().getModel().getLayers().remove(tiledImageLayer);

        return layerIndex;

    }

    private void replaceGvSIGLayer(FLayer layer) {

        // Remove layer without update drawLayerStatus map.

        List<Layer> loadedLayers = getWwd().getModel().getLayers();

        Layer tiledImageLayer = getTileImageLayer(layer);

        if (tiledImageLayer == null) {

            return;

        }

        int layerIndex = loadedLayers.indexOf(tiledImageLayer);

        getWwd().getModel().getLayers().remove(tiledImageLayer);

        // Add new layer at the same index

        if (layerIndex >= 0) {

            try {

                addGvSIGLayer(layer, layerIndex);

            } catch (DataException e) {

                LOG.error("Can't add {} at {}", new Object[] { layer.getName(),

                    layerIndex }, e);

            }

        }

    }

    public void synchronizeViewPorts() {

        // TODO

        throw new UnsupportedOperationException();

    }

    public void addObserver(Observer o) {

        if (observableHelper != null) {

            observableHelper.addObserver(o);

        }

    }

    public void deleteObserver(Observer o) {

        if (observableHelper != null) {

            observableHelper.deleteObserver(o);

        }

    }

    public void deleteObservers() {

        if (observableHelper != null) {

            observableHelper.deleteObservers();

        }

    }

    public boolean getAtmosphereVisibility() {

        if (isWWLayerVisible(SkyGradientLayer.class)

            || isWWLayerVisible(SkyColorLayer.class)) {

            return true;

        }

        return false;

    }

    public boolean getMinimapVisibility() {

        if (isWWLayerVisible(WorldMapLayer.class)) {

            return true;

        }

        return false;

    }

    public boolean getNorthIndicatorVisibility() {

        if (isWWLayerVisible(CompassLayer.class)) {

            return true;

        }

        return false;

    }

    public boolean getStarBackgroundVisibility() {

        if (isWWLayerVisible(StarsLayer.class)) {

            return true;

        }

        return false;

    }

    public boolean getScaleVisibility() {

        if (isWWLayerVisible(ScalebarLayer.class)) {

            return true;

        }

        return false;

    }

    @SuppressWarnings("rawtypes")

    private boolean isWWLayerVisible(Class clazz) {

        List<Layer> layersByClass =

            getWwd().getModel().getLayers().getLayersByClass(clazz);

        for (Layer layer : layersByClass) {

            return layer.isEnabled();

        }

        return false;

    }

    private boolean isWWLayerVisible(String name) {

        Layer layer = getWwd().getModel().getLayers().getLayerByName(name);

        if(layer != null){

            return layer.isEnabled();

        }

        return false;

    }

    public MapControlProperties3D getProperties() {

        return properties;

    }

    private void addVerticalExaggerationChangeProperyListener() {

        getWwd().getSceneController().addPropertyChangeListener(new PropertyChangeListener() {

            public void propertyChange(PropertyChangeEvent evt) {

                String propertyName = evt.getPropertyName();

                if(propertyName.equals(AVKey.VERTICAL_EXAGGERATION)){

                    Double value = (Double) evt.getNewValue();

                    if(getType() == TYPE.SPHERE){

                        getProperties().setSphereVerticalExaggeration(value);

                    } else if(getType() == TYPE.FLAT){

                        getProperties().setFlatVerticalExaggeration(value);

                    }

                }

            }

        });

    }

}