Application: gvSIG desktop » gvSIG 3D

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

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

 *

 */

package org.gvsig.gvsig3d.impl.map3d;

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

import org.gvsig.gvsig3d.map3d.Layer3DProps;

import org.gvsig.osgvp.terrain.Layer;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DelegatedDynObject;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.util.Callable;

/**

 * @author gvSIG Team

 * @version $Id$

 * 

 */

public class Layer3DPropsImpl implements Layer3DProps, Persistent {

        public static final String PARAMETERS_DEFINITION_NAME = "Layer3DPropsImpl";

        public static final String OPACITY = "opacity";

        public static final String VERTICAL_EX = "verticalExageration";

        public static final String HEIGHT = "height";

        public static final String TYPE = "type";

        public static final String TERRAIN_LAYER = "terrainLayer";

        public static final String LAYER = "layer";

        public static final String EDITING = "editing";

        private static final String FIELD_DESCRIPTION = "description";

        private static final String BAND_ELEVATION = "bandElevation";

        private long drawVersion = 0;

        private boolean newLayerOSG = false;

        protected float _opacity = 1.0f; // Opacity of layer default 1.0

        protected float _verticalEx = 1.0f; // Opacity of layer default 1.0

        protected int _bandElev = 0;

        protected float _height = 5; // Opacity of layer default 1.0

        protected int _type; // see type enumeration above

        protected Layer _terrainLayer;

        protected FLayer _layer;

        protected String _cacheName = "default";

        private boolean _bChooseType = true;

        private boolean _zEnable = false;

        private boolean _isGeometryDirty = false ;

        // used by FLayers3D (3D group layer) to flag when they are actually hooked

        // to TOC or not

        private boolean _hooked = false;

        private boolean isEditing = false;

        private int option;

        private DelegatedDynObject _delegatedDynObject = null;

        private String _description = "";

        protected static DynClass DYNCLASS = null;

        public Layer3DPropsImpl() {

        }

        public Layer3DPropsImpl(FLayer layer) {

                _layer = layer;

        }

        // private VectorLayerMenu vectorLayerMenu;

        // TRY TO NOT USE STATIC METHODS. PROBLEMS WITH API/IMPL SEPARATION

        // public static Layer3DProps getLayer3DProps(FLayer layer) {

        // FLyrDefault baseLayer = (FLyrDefault) layer;

        // Object propsObj = baseLayer.getProperty("3DLayerExtension");

        // Layer3DPropsImpl props3D = null;

        // if (propsObj != null) {

        // try {

        // props3D = (Layer3DPropsImpl) propsObj;

        // if (props3D.drawVersion == 0)

        // props3D.drawVersion = layer.getDrawVersion();

        // } catch (Exception e) {

        // props3D = null;

        // }

        // }

        // return props3D;

        // }

        public String getClassName() {

                return this.getClass().getName();

        }

        public float getHeight() {

                return _height;

        }

        public boolean getHooked() {

                return _hooked;

        }

        public float getOpacity() {

                return _opacity;

        }

        public Layer getTerrainLayer() {

                return _terrainLayer;

        }

        public int getType() {

                return _type;

        }

        public float getVerticalEx() {

                return _verticalEx;

        }

        public int getElevationBand(){

                return _bandElev;

        }

        public boolean isEditing() {

                return isEditing;

        }

        public boolean isNewLayerOSG() {

                return newLayerOSG;

        }

        public boolean isZEnable() {

                return _zEnable;

        }

        public void setChooseType(boolean bChoose) {

                _bChooseType = bChoose;

        }

        public void setDescription(String desc) {

                this._description = desc;

        }

        public String getDescription() {

                return _description;

        }

        public void setEditing(boolean isEditing) {

                this.isEditing = isEditing;

        }

        public void setHeight(float heigth) {

                this._height = heigth;

                setDirtyGeometry(true);

        }

        public void setHooked(boolean hooked) {

                _hooked = hooked;

        }

        public void setLayer(FLayer layer) {

                if (_layer == layer)

                        return;

                _layer = layer;

                // find out data type

                if (_bChooseType) {

                        _bChooseType = false;

                        _type = layer3DImage;

                        boolean bCanBeElev = false;

                        // if (layer instanceof FLyrWMS) {

                        // FLyrWMS wmsLayer = (FLyrWMS) layer;

                        // String format = wmsLayer.getFormat();

                        // if (format.regionMatches(true, 0, "image/geotiff", 0, 13)

                        // || format.regionMatches(true, 0, "image/tiff", 0, 10))

                        // bCanBeElev = true;

                        // } else

                        // if (layer instanceof FLyrWCS) {

                        // FLyrWCS wcsLayer = (FLyrWCS) layer;

                        // Hashtable props = wcsLayer.getProperties();

                        // String format = (String) props.get("format");

                        // String params = (String) props.get("parameter");

                        // if (format.compareToIgnoreCase("GEOTIFF_INT16") == 0

                        // && params.compareToIgnoreCase("bands=1") == 0)

                        // bCanBeElev = true;

                        // }

                        // FEATURES

                        // else /**/if (layer instanceof ClassifiableVectorial) {

                        //

                        // if (this.getType() != layer3DOSG) {

                        // vectorLayerMenu = new VectorLayerMenu(this, layer.getName());

                        // vectorLayerMenu.setModal(true);

                        // vectorLayerMenu.pack();

                        // vectorLayerMenu.setVisible(true);

                        // }

                        //

                        // } else if (layer instanceof FLyrRasterSE) {

                        // FLyrRasterSE rasterLayer = (FLyrRasterSE) layer;

                        // if (rasterLayer.getBandCount() == 1)

                        // bCanBeElev = true;

                        //

                        // }

                        //

                        // if (_type == layer3DImage && bCanBeElev) {

                        // option = JOptionPane.showConfirmDialog(

                        // (Component) PluginServices.getMainFrame(),

                        // PluginServices

                        // .getText(this, "Elevation_layer_question"),

                        // PluginServices.getText(this, "Layer_options"),

                        // JOptionPane.YES_NO_OPTION);

                        //

                        // if (option == JOptionPane.YES_OPTION) {

                        // _type = layer3DElevation;

                        // }

                        // }

                }

        }

        public void setNewLayerOSG(boolean newLayerOSG) {

                this.newLayerOSG = newLayerOSG;

        }

        public void setOpacity(float mOpacity) {

                this._opacity = mOpacity;

        }

        public void setTerrainLayer(Layer terrainLayer) {

                _terrainLayer = terrainLayer;

        }

        public void setType(int type) {

                _type = type;

                //We need to persist in the layer properties if the layer is rasterized or not.

                _layer.setProperty("layerType", type);

        }

        public void setVerticalEx(float ex) {

                _verticalEx = ex;

        }

        public void setElevationBand(int band){

                _bandElev = band;

        }

        public void setZEnable(boolean zEnable) {

                _zEnable = zEnable;

        }

        public void setDrawVersion(long version) {

                drawVersion = version;

        }

        public long getDrawVersion() {

                return drawVersion;

        }

        public void loadFromState(PersistentState state)

                        throws PersistenceException {

                // setDescription(state.getString(FIELD_DESCRIPTION));

                _opacity = state.getFloat(OPACITY);

                _verticalEx = state.getFloat(VERTICAL_EX);

                _height = state.getFloat(HEIGHT);

                _type = state.getInt(TYPE);

//                _terrainLayer = (Layer) state.get(TERRAIN_LAYER);

                _layer = (FLayer) state.get(LAYER);

                isEditing = state.getBoolean(EDITING);

        }

        public void saveToState(PersistentState state) throws PersistenceException {

                // state.set(FIELD_DESCRIPTION, getDescription());

                state.set(OPACITY, _opacity);

                state.set(VERTICAL_EX, _verticalEx);

                state.set(HEIGHT, _height);

                state.set(TYPE, _type);

//                if (_terrainLayer != null)

//                        state.set(TERRAIN_LAYER, _terrainLayer);

                if (_layer != null)

                        state.set(LAYER, _layer);

                state.set(EDITING, isEditing);

        }

        public static class RegisterPersistence implements Callable {

                public Object call() throws Exception {

                        PersistenceManager manager = ToolsLocator.getPersistenceManager();

                        if (manager.getDefinition(PARAMETERS_DEFINITION_NAME) == null) {

                                DynStruct definition = manager.addDefinition(

                                                Layer3DPropsImpl.class, PARAMETERS_DEFINITION_NAME,

                                                PARAMETERS_DEFINITION_NAME + " Persistence definition",

                                                null, null);

                                // Description

                                definition.addDynFieldFloat(OPACITY).setMandatory(false);

                                definition.addDynFieldFloat(VERTICAL_EX).setMandatory(false);

                                definition.addDynFieldFloat(HEIGHT).setMandatory(false);

                                definition.addDynFieldInt(TYPE).setMandatory(false);

//                                definition.addDynFieldObject(TERRAIN_LAYER)

//                                                .setClassOfValue(Layer.class).setMandatory(false);

                                definition.addDynFieldObject(LAYER)

                                                .setClassOfValue(FLayer.class).setMandatory(false);

                                definition.addDynFieldBoolean(EDITING).setMandatory(false);

                        }

                        return Boolean.TRUE;

                }

        }

        public void setDirtyGeometry(boolean dirty) {

                _isGeometryDirty = dirty;        

        }

        public boolean isGeometryDirty()

        {

                return _isGeometryDirty;

        }

}