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

import gov.nasa.worldwind.WorldWind;

import gov.nasa.worldwind.avlist.AVKey;

import gov.nasa.worldwind.awt.WorldWindowGLJPanel;

import gov.nasa.worldwind.globes.Earth;

import gov.nasa.worldwind.globes.EarthFlat;

import gov.nasa.worldwind.globes.Globe;

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.util.StatusBar;

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

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

import java.awt.BorderLayout;

import java.awt.Dimension;

import java.io.File;

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

import java.net.URL;

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.view3d.swing.api.MapControl3D;

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

/**

 * @author llmarques

 *

 */

public class DefaultMapControl3D extends JPanel implements MapControl3D {

    private static final long serialVersionUID = 2024899922367896097L;

    private static final Logger logger = LoggerFactory

        .getLogger(DefaultMapControl3D.class);

    private MapContext mapContext;

    private WorldWindowGLJPanel wwd;

    private TYPE type;

    public DefaultMapControl3D(MapContext theMapContext, TYPE type) {

        super(new BorderLayout());

        this.mapContext = theMapContext;

        this.type = type;

        // Load configuration file

        URL configURL = this.getClass().getResource("/config/worldwind.xml");

        if (configURL != null) {

            File configFile = new File(configURL.getPath());

            Configuration.insertConfigurationDocument(configFile

                .getAbsolutePath());

        }

        // Set mode before instantiation

        if (type == TYPE.SPHERE) {

            setSpherePanelConfiguration();

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

            setFlatPanelConfiguration();

        }

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

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

        // add(this.mapContext.getLayers());

    }

    @SuppressWarnings("rawtypes")

    private void addLayer(Class layerClazz) throws InstantiationException,

        IllegalAccessException, IllegalArgumentException,

        InvocationTargetException {

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

        if (isAlreadyAdded(layerList, layerClazz)) {

            return;

        }

        Constructor[] constructors = layerClazz.getConstructors();

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

            if (constructors[i].getParameterTypes().length == 0) {

                layerList.add((Layer) constructors[i].newInstance());

            }

        }

    }

    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 MapContext getMapContext() {

        return this.mapContext;

    }

    private StatusBar getStatusBar() {

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

    }

    protected WorldWindowGLJPanel getWwd() {

        if (this.wwd == null) {

            intializeWWPanel();

        }

        return this.wwd;

    }

    public void hideAtmosphere() {

        hideLayer(SkyGradientLayer.class);

    }

    @SuppressWarnings("rawtypes")

    private void hideLayer(Class layerClazz) {

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

        List<Layer> layersByClass = layers.getLayersByClass(layerClazz);

        layers.removeAll(layersByClass);

    }

    public void hideMiniMap() {

        hideLayer(WorldMapLayer.class);

    }

    public void hideNorthIndicator() {

        hideLayer(CompassLayer.class);

    }

    public void hideScale() {

        hideLayer(ScalebarLayer.class);

    }

    public void hideStarBackground() {

        hideLayer(StarsLayer.class);

    }

    private void intializeWWPanel() {

        wwd = new WorldWindowGLJPanel();

        wwd.setPreferredSize(new Dimension(800, 600));

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

    }

    private boolean isAlreadyAdded(LayerList layerList,

        @SuppressWarnings("rawtypes") Class clazz) {

        List<Layer> layersByClass = layerList.getLayersByClass(clazz);

        return layersByClass.size() > 0;

    }

    public void reloadLayers() {

        // TODO

        throw new UnsupportedOperationException();

    }

    private void removeAllLayers() {

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

    }

    private void setFlatPanelConfiguration() {

        Configuration.setValue(AVKey.GLOBE_CLASS_NAME,

            EarthFlat.class.getName());

        Configuration.setValue(AVKey.VIEW_CLASS_NAME,

            FlatOrbitView.class.getName());

    }

    public void setMapContext(MapContext theMapContext) {

        this.mapContext = theMapContext;

    }

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

        getWwd().getSceneController().setVerticalExaggeration(

            verticalExaggeration);

    }

    public void showAtmosphere() {

        try {

            Globe globe = getWwd().getModel().getGlobe();

            if (globe instanceof Earth) {

                getWwd().getModel().getLayers().add(new SkyGradientLayer());

                addLayer(SkyGradientLayer.class);

            } else if (globe instanceof EarthFlat) {

                getWwd().getModel().getLayers().add(new SkyColorLayer());

                addLayer(SkyColorLayer.class);

            }

        } catch (Exception e) {

            logger.warn(

                "Can't add " + SkyGradientLayer.class.getCanonicalName()

                    + " or " + SkyColorLayer.class.getCanonicalName() + " to "

                    + getWwd().getModel().toString(), e);

        }

    }

    public void showMiniMap() {

        try {

            addLayer(WorldMapLayer.class);

        } catch (Exception e) {

            logger.warn("Can't add " + WorldMapLayer.class.getCanonicalName()

                + "to " + getWwd().getModel().toString(), e);

        }

    }

    public void showNortIndicator() {

        try {

            addLayer(CompassLayer.class);

        } catch (Exception e) {

            logger.warn("Can't add " + CompassLayer.class.getCanonicalName()

                + " to " + getWwd().getModel().toString(), e);

        }

    }

    public void showScale() {

        try {

            addLayer(ScalebarLayer.class);

        } catch (Exception e) {

            logger.warn("Can't add " + ScalebarLayer.class.getCanonicalName()

                + " to " + getWwd().getModel().toString(), e);

        }

    }

    public void showStarBackgroundLayer() {

        try {

            addLayer(StarsLayer.class);

        } catch (Exception e) {

            logger.warn("Can't add " + StarsLayer.class.getCanonicalName()

                + " to " + getWwd().getModel().toString(), e);

        }

    }

    public void synchronizeLayers() {

        // TODO

        throw new UnsupportedOperationException();

    }

    public void synchronizeViewPorts() {

        // TODO

        throw new UnsupportedOperationException();

    }

}