/trunk/libraries/libFMap/src/com/iver/cit/gvsig/fmap/layers/FLyrDefault.java - | gvSIG desktop 1 - gvSIG

root / trunk / libraries / libFMap / src / com / iver / cit / gvsig / fmap / layers / FLyrDefault.java @ 5908

History | View | Annotate | Download (12.9 KB)

       /* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana
+       *
        * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.
+       *
        * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.
+       *
        * For more information, contact:
+       *
        *  Generalitat Valenciana
        *   Conselleria d'Infraestructures i Transport
        *   Av. Blasco Ib??ez, 50
        *   46010 VALENCIA
        *   SPAIN
+       *
        *      +34 963862235
        *   gvsig@gva.es
        *      www.gvsig.gva.es
+       *
        *    or
+       *
        *   IVER T.I. S.A
        *   Salamanca 50
        *   46005 Valencia
        *   Spain
+       *
        *   +34 963163400
        *   dac@iver.es
        */
       package com.iver.cit.gvsig.fmap.layers;
       import java.util.ArrayList;
       import java.util.Hashtable;
       import java.util.Iterator;
       import javax.swing.ImageIcon;
       import org.apache.log4j.Logger;
       import org.cresques.cts.ICoordTrans;
       import org.cresques.cts.IProjection;
       import org.cresques.cts.ProjectionPool;
       import org.cresques.cts.gt2.CoordSys;
       import org.cresques.cts.gt2.CoordTrans;
       import com.iver.cit.gvsig.fmap.DriverException;
       import com.iver.cit.gvsig.fmap.FMap;
       import com.iver.cit.gvsig.fmap.drivers.DriverIOException;
       import com.iver.cit.gvsig.fmap.edition.EditionException;
       import com.iver.cit.gvsig.fmap.edition.VectorialEditableAdapter;
       import com.iver.cit.gvsig.fmap.operations.strategies.Strategy;
       import com.iver.utiles.XMLEntity;
       /**
        * Implementaci?n de las caracter?sticas de alto nivel de las capas:
        * visibilidad, activaci?n, nombre, ...
        */
       public abstract class FLyrDefault implements FLayer {
               //private PropertyChangeSupport lnkPropertyChangeSupport;
           private static Logger logger = Logger.getLogger(FLyrDefault.class);
               /** Path de la capa en el arbol de capas */
               private FLayers parentLayer = null;
               private FLayers virtualLayers = null;
               private FLyrText layerText = null;
               private String name;
               private IProjection projection;
               private boolean visible = true;
               private boolean active;
               private int transparency = 0;
               private ICoordTrans ct;
               private double minScale = -1; // -1 indica que no se usa
               private double maxScale = -1;
               private boolean isInTOC = true;
               protected ArrayList layerListeners = new ArrayList();
           private Strategy privateStrategy = null;
               private boolean isediting;
               private Hashtable properties = new Hashtable();
               public Object getProperty(Object key)
+              {
                       return properties.get(key);
+              }
               public void setProperty (Object key, Object val){
                       properties.put(key, val);
+              }
               /**
                * @see com.iver.cit.gvsig.fmap.layers.FLayer#setActive(boolean)
                */
               public void setActive(boolean selected) {
                       active = selected;
                       callActivationChanged(LayerEvent.createActivationChangedEvent(this, "active"));
+              }
               /**
                * @see com.iver.cit.gvsig.fmap.layers.FLayer#isActive()
                */
               public boolean isActive() {
                       return active;
+              }
               /**
                * @see com.iver.cit.gvsig.fmap.layers.FLayer#setName(java.lang.String)
                */
               public void setName(String name) {
                       this.name = name;
                       callNameChanged(LayerEvent.createNameChangedEvent(this, "name"));
+              }
               /**
                * @see com.iver.cit.gvsig.fmap.layers.FLayer#getName()
                */
               public String getName() {
                       return name;
+              }
               /*
                * @see com.iver.cit.gvsig.fmap.layers.FLayer#load()
                */
               public void load() throws DriverIOException {
+              }
               /**
                * @see com.iver.cit.gvsig.fmap.layers.FLayer#setVisible(boolean)
                */
               public void setVisible(boolean visibility) {
                       visible = visibility;
                       callVisibilityChanged(LayerEvent.createVisibilityChangedEvent(this, "visible"));
+              }
               /**
                * @see com.iver.cit.gvsig.fmap.layers.FLayer#isVisible()
                */
               public boolean isVisible() {
                       return visible;
+              }
               /**
                * Devuelve la capa padre de la actual.
+               *
                * @return FLayers padre.
                */
               public FLayers getParentLayer() {
                       return parentLayer;
+              }
               /**
                * Inserta la capa padre.
+               *
                * @param root capa padre.
                */
               public void setParentLayer(FLayers root) {
                       this.parentLayer = root;
+              }
               /**
                * Inserta una proyecci?n.
+               *
                * @param proj Proyecci?n.
                */
               public void setProjection(IProjection proj) {
                       projection = proj;
               // Comprobar que la proyecci?n es la misma que la de FMap
               // Si no lo es, es una capa que est? reproyectada al vuelo
               if ((proj != null) && (getFMap() != null))
                   if (proj != getFMap().getProjection())
+                  {
                       ICoordTrans ct = new CoordTrans((CoordSys) proj,
                               (CoordSys) getFMap().getProjection());
                       setCoordTrans(ct);
                       logger.debug("Cambio proyecci?n: FMap con " + getFMap().getProjection().getAbrev()
                               + " y capa " + getName() + " con " + proj.getAbrev());
+                  }
+              }
               /**
                * @see org.cresques.geo.Projected#getProjection()
                */
               public IProjection getProjection() {
                       return projection;
+              }
               /**
                * @see org.cresques.geo.Projected#reProject(org.cresques.cts.ICoordTrans)
                */
               public void reProject(ICoordTrans arg0) {
+              }
               /**
                * Devuelve el nivel de transparencia de la capa.
+               *
                * @return Entero que representa el nivel de transparencia.
                */
               public int getTransparency() {
                       return transparency;
+              }
               /**
                * Inserta el nivel de transparencia de la capa.
+               *
                * @param trans Nivel de transparencia.
                */
               public void setTransparency(int trans) {
                       transparency = trans;
+              }
               /**
                * Devuelve el XMLEntity a partir del objeto.
+               *
                * @return XMLEntity.
                * @throws XMLException
                */
               public XMLEntity getXMLEntity() throws XMLException {
                       XMLEntity xml = new XMLEntity();
                       xml.putProperty("className",this.getClass().getName());
                       if (this instanceof FLayers) {
+                      }
                       xml.putProperty("active", active);
                       xml.putProperty("name", name);
                       xml.putProperty("minScale",minScale);
                       xml.putProperty("maxScale",maxScale);
                       //TODO xml.addChild(parentLayer.getXMLEntity());
                       xml.putProperty("visible", visible);
                       if (projection != null) {
                               xml.putProperty("proj", projection.getAbrev());
+                      }
                       xml.putProperty("transparency", transparency);
                       xml.putProperty("isInTOC", isInTOC);
                       return xml;
+              }
               /*
                * Inserta los valores de los atributos del XMLEntity al objeto.
+               *
                * @param xml XMLEntity.
+               *
                * @throws XMLException
                * @throws DriverException
                * @throws DriverIOException
+               *
               public void setXMLEntity03(XMLEntity xml)
                       throws XMLException {
                       active = xml.getBooleanProperty("active");
                       name = xml.getStringProperty("name");
                       minScale=xml.getDoubleProperty("minScale");
                       maxScale=xml.getDoubleProperty("maxScale");
                       visible = xml.getBooleanProperty("visible");
                       if (xml.contains("proj")) {
                               setProjection(ProjectionPool.get(xml.getStringProperty("proj")));
+                      }
                       if (xml.contains("transparency"))
                               transparency = xml.getIntProperty("transparency");
               }*/
               /**
                * Inserta los valores de los atributos del XMLEntity al objeto.
+               *
                * @param xml XMLEntity.
+               *
                * @throws XMLException
                * @throws DriverException
                * @throws DriverIOException
                */
               public void setXMLEntity(XMLEntity xml)
                       throws XMLException {
                       active = xml.getBooleanProperty("active");
                       name = xml.getStringProperty("name");
                       minScale=xml.getDoubleProperty("minScale");
                       maxScale=xml.getDoubleProperty("maxScale");
                       visible = xml.getBooleanProperty("visible");
                       if (xml.contains("proj")) {
                               setProjection(ProjectionPool.get(xml.getStringProperty("proj")));
+                      }
                       if (xml.contains("transparency"))
                               transparency = xml.getIntProperty("transparency");
                       if (xml.contains("isInTOC"))
                               isInTOC = xml.getBooleanProperty("isInTOC");
+              }
               /**
                * Inserta los valores de los atributos del XMLEntity al objeto.
+               *
                * @param xml XMLEntity.
+               *
                * @throws XMLException
                * @throws DriverException
                * @throws DriverIOException
                */
               public void setXMLEntity03(XMLEntity xml)
                       throws XMLException {
                       active = xml.getBooleanProperty("active");
                       name = xml.getStringProperty("name");
                       minScale=xml.getDoubleProperty("minScale");
                       maxScale=xml.getDoubleProperty("maxScale");
                       visible = xml.getBooleanProperty("visible");
                       if (xml.contains("proj")) {
                               setProjection(ProjectionPool.get(xml.getStringProperty("proj")));
+                      }
                       if (xml.contains("transparency"))
                               transparency = xml.getIntProperty("transparency");
+              }
               /**
                * @see com.iver.cit.gvsig.fmap.layers.FLayer#getFMap()
                */
               public FMap getFMap() {
                       if (getParentLayer() != null) {
                               return getParentLayer().getFMap();
                       } else {
                               return null;
+                      }
+              }
               /**
                * A?ade a la lista de listener un nuevo LayerListener.
+               *
                * @param o LayerListener.
+               *
                * @return boolean.
                */
               public boolean addLayerListener(LayerListener o) {
                       if (layerListeners.contains(o))
                               return false;
                       return layerListeners.add(o);
+              }
               public LayerListener[] getLayerListeners() {
                       return (LayerListener[])layerListeners.toArray(new LayerListener[0]);
+              }
               /**
                * Borra de la lista de listeners el que se pasa como par?metro.
+               *
                * @param o LayerListener a borrar.
+               *
                * @return True si ha sido correcto el borrado del Listener.
                */
               public boolean removeLayerListener(LayerListener o) {
                       return layerListeners.remove(o);
+              }
               /**
                * Llamada al metodo nameChanged de los Listeners dados de alta.
+               *
                * @param e LayerEvent.
                */
               private void callNameChanged(LayerEvent e) {
                       for (Iterator iter = layerListeners.iterator(); iter.hasNext();) {
                               LayerListener listener = (LayerListener) iter.next();
                               listener.nameChanged(e);
+                      }
+              }
               /**
                * Llamada al m?todo visibilityChanged de los Listeners.
+               *
                * @param e LayerEvent.
                */
               private void callVisibilityChanged(LayerEvent e) {
                       for (Iterator iter = layerListeners.iterator(); iter.hasNext();) {
                               LayerListener listener = (LayerListener) iter.next();
                               listener.visibilityChanged(e);
+                      }
+              }
               /**
                * Llamada al m?todo activationChanged de los Listener.
+               *
                * @param e LayerEvent.
                */
               private void callActivationChanged(LayerEvent e) {
                       for (Iterator iter = layerListeners.iterator(); iter.hasNext();) {
                               LayerListener listener = (LayerListener) iter.next();
                               listener.activationChanged(e);
+                      }
+              }
               /**
                * Devuelve las capas virtuales.
+               *
                * @return FLayers.
                */
               public FLayers getVirtualLayers() {
                       return virtualLayers;
+              }
               /**
                * Inserta las capas virtuales.
+               *
                * @param virtualLayers FLayers.
                */
               public void setVirtualLayers(FLayers virtualLayers) {
                       this.virtualLayers = virtualLayers;
+              }
               /**
                * Devuelve la capa de texto.
+               *
                * @return capa de texto.
                */
               public FLyrText getLayerText() {
                       return layerText;
+              }
               /**
                * Inserta la capa de texto.
+               *
                * @param layerText Capa de texto.
                */
               public void setLayerText(FLyrText layerText) {
                       this.layerText = layerText;
+              }
               /**
                * Inserta la Transformaci?n de coordenadas.
+               *
                * @param ct Transformaci?n de coordenadas.
                */
               public void setCoordTrans(ICoordTrans ct) {
                       this.ct = ct;
+              }
               /**
                * Devuelve las transformaci?n de coordenadas.
+               *
                * @return ct.
                */
               public ICoordTrans getCoordTrans() {
                       return ct;
+              }
               /**
                * M?todo que es llamado por Flayers para notificar a la capa que
                * va a ser a?adida. Esta previa notificaci?n es util para las capas que
                * necesitan hacer algo antes de ser a?adida. Por ejemplo, el raster necesita
                * volver a abrir el fichero que ha podido ser cerrado con anterioridad.
                * Si no se redefine este m?todo no se har? nada ya que este es vacio.
                */
               public void wakeUp(){}
           public double getMinScale() {
               return minScale;
+          }
           /* (non-Javadoc)
            * @see com.iver.cit.gvsig.fmap.layers.FLayer#getMaxScale()
            */
           public double getMaxScale() {
               return maxScale;
+          }
           public void setMinScale(double minScale)
+          {
               this.minScale = minScale;
+          }
           public void setMaxScale(double maxScale)
+          {
               this.maxScale = maxScale;
+          }
           public boolean isWithinScale(double scale)
+          {
               boolean bVisible = true;
               if (getMinScale() != -1)
+              {
                   if (scale < getMinScale())
                       bVisible = false;
+              }
               if (getMaxScale() != -1)
+              {
                   if (scale > getMaxScale())
                       bVisible = false;
+              }
               return bVisible;
+          }
           public Strategy getStrategy()
+          {
               return privateStrategy;
+          }
           public void setStrategy(Strategy s)
+          {
               privateStrategy = s;
+          }
               public void setEditing(boolean b) throws EditionException {
                       isediting=b;
+              }
               protected void callEditionChanged(LayerEvent e) {
                       for (Iterator iter = layerListeners.iterator(); iter.hasNext();) {
                               LayerListener listener = (LayerListener) iter.next();
                               listener.editionChanged(e);
+                      }
+              }
               public boolean isEditing(){
                       return isediting;
+              }
           public ImageIcon getTocImageIcon() {
                   return null;
+          }
           public boolean isInTOC() {
                   return isInTOC;
+          }
+      }