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 java.awt.BorderLayout;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.util.List;

import javax.swing.JComponent;

import javax.swing.JPanel;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.mapcontext.MapContext;

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.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.loadingmodes.NwwLoaderFactory;

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

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

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.exceptions.ConversionLayerException;

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

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

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

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

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

import gov.nasa.worldwind.util.StatusBar;

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

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

/**

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

    private ObservableHelper observableHelper;

    private MapContext mapContext;

    private MapControlProperties3D properties;

    private ExtendedPropertiesSupport viewProperties;

    private WorldWindowGLJPanel wwd;

    private PropertyChangeListener verticalExaggerationPropertyListener;

    private PropertyChangeListener propertiesChangeListener;

    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.viewProperties = viewProperties;

        // Set mode before instantiation

        if (type == TYPE.SPHERE) {

            setSpherePanelConfiguration();

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

            setFlatPanelConfiguration();

        }

        View3DSwingManager swingManager = View3DSwingLocator.getManager();

        this.properties = swingManager.getMapControl3DProperties(viewProperties);

        // Set pre configurations before instance WWD component

        preConfiguration();

        // Instance WWD component

        getWwd();

//        this.synchronizer = new DefaultSynchronizer(this, this.mapContext, getWwd());

        // Set post configurations after instance WWD component

        postConfiguration();

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

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

        this.synchronizer = new DefaultSynchronizer(this, this.mapContext, getWwd());

        try {

            addGvSIGLayers(mapContext.getLayers());

        } catch (BaseException e) {

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

        }

    }

    private void preConfiguration() {

            // WWD Mode

            if (type == TYPE.SPHERE) {

                setSpherePanelConfiguration();

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

                setFlatPanelConfiguration();

            }

            // Enable or disable anaglyph mode

            setAnaglyphMode(this.properties.getAnaglyphMode());

        }

    private void postConfiguration() {

        setGeneral3DProperties();

        this.properties.addPropertyChangeListener(getPropertiesChangeListener());

        setMapControl3DProperties();

        getWwd().getSceneController().addPropertyChangeListener(

            getVerticalExaggerationPropertyListener());

        getWwd().getView().getViewInputHandler().setStopOnFocusLost(false);

    }

    private PropertyChangeListener getPropertiesChangeListener() {

        if (this.propertiesChangeListener == null) {

            this.propertiesChangeListener = 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);

                    }

                }

            };

        }

        return this.propertiesChangeListener;

    }

    private PropertyChangeListener getVerticalExaggerationPropertyListener() {

        if (this.verticalExaggerationPropertyListener == null) {

            this.verticalExaggerationPropertyListener = 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);

                        }

                    }

                }

            };

        }

        return this.verticalExaggerationPropertyListener;

    }

    private void setAnaglyphMode(boolean flag) {

        if (flag) {

            System.setProperty("gov.nasa.worldwind.stereo.mode", "redblue");

        } else {

            System.setProperty("gov.nasa.worldwind.stereo.mode", "");

        }

    }

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

//                }

//            }

//        });

//

//    }

    protected void addGvSIGLayer(FLayer layer) throws ConversionLayerException {

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

        addGvSIGLayer(layer, layers.size());

    }

    protected void addGvSIGLayer(FLayer layer, int index) throws ConversionLayerException {

        LayerConverter converter = new DefaultLayerConverter();

        View3DManager manager = View3DLocator.getManager();

        NwwLoaderFactory layerLoadingFactory = manager.getLayerLoadingFactory(layer);

        LayerProperties3D layerProperties = manager.getLayerProperties(layer, layerLoadingFactory);

        if (layerProperties instanceof ElevationLayerProperties3D) {

            // elevation layers are particular ones

            ElevationLayerProperties3D new_name = (ElevationLayerProperties3D) layerProperties;

            ElevationModel elevationModel = converter.convertToElevationModel(this, layer);

            this.synchronizer.registerLayer(layer, elevationModel);

            CompoundElevationModel cem = (CompoundElevationModel) getWwd().getModel().getGlobe().getElevationModel();

            cem.addElevationModel(elevationModel);

        } else {

            // for any other case a Layer object is created

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

            nwwLayer.setEnabled(layer.isVisible());

            this.synchronizer.registerLayer(layer, nwwLayer);

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

        }

    }

//    private boolean isValidLayer(FLayer layer) {

//

//        // Checks if layer envelope is valid or not.

//        GeometryManager geoManager = GeometryLocator.getGeometryManager();

//        double[] degreesArray = Sector.FULL_SPHERE.asDegreesArray();

//        Envelope fullSphereEnvelope = null;

//

//        try {

//            fullSphereEnvelope = geoManager.createEnvelope(degreesArray[2], degreesArray[0], degreesArray[3],

//                degreesArray[1], SUBTYPES.GEOM2D);

//

//            Envelope fullEnvelope = layer.getFullEnvelope();

//            // return fullSphereEnvelope.contains(fullEnvelope);

//

//            return (fullEnvelope.getMinimum(1) >= -90 & fullEnvelope.getMinimum(1) <= 90

//                && fullEnvelope.getMaximum(1) >= -90 & fullEnvelope.getMaximum(1) <= 90);

//        } catch (CreateEnvelopeException e) {

//            LOG.error("Can't create envelope with this parameters {} {} {} {} {}",

//                new Object[] { degreesArray[2], degreesArray[3], degreesArray[0], degreesArray[1], SUBTYPES.GEOM2D });

//            return false;

//        } catch (ReadException e) {

//            LOG.error("Can't get envelope of {}. Can't determinate if layer is valid or not.");

//            return false;

//        }

//    }

    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;

//                    }

//                }

                if (beforeDisposeNotification.isCanceled()) {

                    LOG.warn("Dispose action canceled by some observer");

                    return;

                }

                if(WorldWind.getRetrievalService().hasActiveTasks()){

                    WorldWind.getRetrievalService().shutdown(true);

                }

                if(WorldWind.getRemoteRetrievalService().hasActiveTasks()){

                    WorldWind.getRemoteRetrievalService().shutdown(true);

                                 }

                // Remove change properties listener

                getWwd().getSceneController().removePropertyChangeListener(

                    getVerticalExaggerationPropertyListener());

                properties.removePropertyChangeListener(getPropertiesChangeListener());

                // Dispose WWD component

                disposeWwd();

                // Remove properties from view

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

                    viewProperties.getExtendedProperties().remove("sphereMapControl3D");

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

                    viewProperties.getExtendedProperties().remove("flatMapControl3D");

                }

                synchronizer.dispose();

                synchronizer = null;

                properties = null;

                mapContext = null;

                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;

    }

    public TYPE getType() {

        return this.type;

    }

    public double getVerticalExaggeration() {

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

    }

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

        Model auxModel = (Model) WorldWind.createConfigurationComponent(AVKey.MODEL_CLASS_NAME);

        this.wwd.getModel().setLayers(auxModel.getLayers());

        setGeneral3DProperties();

        setMapControl3DProperties();

        addNavigation();

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

        boolean anaglyphMode = this.properties.getAnaglyphMode();

        if (anaglyphMode) {

        }

    }

    private void setSpherePanelConfiguration() {

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

        Configuration.setValue(AVKey.VIEW_CLASS_NAME, BasicOrbitView.class.getName());

    }

    private 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 void synchronizeLayers() {

//        this.synchronizer.synchronizeLayers();

//    }

    public void synchronizeViewPorts() {

        this.synchronizer.synchronizeViewPorts();

    }

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

//                    }

//                }

//            }

//        });

//    }

//    public void setViewPortEnvelope(Envelope envelope) {

//        this.synchronizer.setViewPortEnvelope(envelope);

//    }

    @Override

    public Object getUnderLineComponent() {

        return this.getWwd();

    }

}