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.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

import java.util.List;

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

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

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

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

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 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 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}.

     */

    public DefaultMapControl3D(MapContext theMapContext, TYPE type) {

        super(new BorderLayout());

        this.mapContext = theMapContext;

        this.type = type;

        this.cancellable = getCancellable();

        this.observableHelper = new ObservableHelper();

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

            addLayers();

        } catch (BaseException e) {

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

        }

    }

    private void addGvSIGLayer(FLayer layer) throws DataException {

        LayerConverter converter = new DefaultLayerConverter();

        // TODO Check load mode to create WW Layer

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

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

    }

    private void addLayers() throws BaseException {

        mapContext.getLayers().accept(new LayersVisitor() {

            public void visit(Object obj) throws VisitCanceledException,

                BaseException {

                throw new UnsupportedOperationException();

            }

            public void visit(FLayer layer) throws BaseException {

                // TODO Make new threads to add layers

                if (layer.isAvailable() && layer.isVisible()) {

                    addGvSIGLayer(layer);

                }

            }

        });

        getWwd().redraw();

    }

    @SuppressWarnings("rawtypes")

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

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

    }

    protected WorldWindowGLJPanel getWwd() {

        if (this.wwd == null) {

            intializeWWPanel();

        }

        return this.wwd;

    }

    private void disposeWwd() {

        if (getWwd() != null) {

            this.wwd = null;

        }

    }

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

                addWWLayer(SkyGradientLayer.class);

            } else if (globe instanceof EarthFlat) {

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

                addWWLayer(SkyColorLayer.class);

            }

        } catch (Exception e) {

            LOG.warn("Can't add {} or {} to {}",

                new Object[] { SkyGradientLayer.class.getCanonicalName(),

                    SkyColorLayer.class.getCanonicalName(),

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

        }

    }

    public void showMiniMap() {

        try {

            addWWLayer(WorldMapLayer.class);

        } catch (Exception e) {

            LOG.warn("Can't add {} to {}",

                new Object[] { WorldMapLayer.class.getCanonicalName(),

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

        }

    }

    public void showNortIndicator() {

        try {

            addWWLayer(CompassLayer.class);

        } catch (Exception e) {

            LOG.warn("Can't add {} to {}",

                new Object[] { CompassLayer.class.getCanonicalName(),

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

        }

    }

    public void showScale() {

        try {

            addWWLayer(ScalebarLayer.class);

        } catch (Exception e) {

            LOG.warn("Can't add {} to {}",

                new Object[] { ScalebarLayer.class.getCanonicalName(),

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

        }

    }

    public void showStarBackgroundLayer() {

        try {

            addWWLayer(StarsLayer.class);

        } catch (Exception e) {

            LOG.warn("Can't add {} to {}",

                new Object[] { StarsLayer.class.getCanonicalName(),

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

        }

    }

    public void synchronizeLayers() {

        // TODO

        throw new UnsupportedOperationException();

    }

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

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

        if (isAlreadyAdded(layerList, SkyGradientLayer.class)

            || isAlreadyAdded(layerList, SkyColorLayer.class)) {

            return true;

        }

        return false;

    }

    public boolean isMinimapVisible() {

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

        if (isAlreadyAdded(layerList, WorldMapLayer.class)) {

            return true;

        }

        return false;

    }

    public boolean isNorthIndicatorVisible() {

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

        if (isAlreadyAdded(layerList, CompassLayer.class)) {

            return true;

        }

        return false;

    }

    public boolean isStartBackgroundVisible(){

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

        if (isAlreadyAdded(layerList, StarsLayer.class)) {

            return true;

        }

        return false;

    }

    public boolean isScaleVisible() {

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

        if (isAlreadyAdded(layerList, ScalebarLayer.class)) {

            return true;

        }

        return false;

    }

}