gov/nasa/worldwind/layers/AbstractLayer.java

   1 /*
   2 Copyright (C) 2001, 2006 United States Government
   3 as represented by the Administrator of the
   4 National Aeronautics and Space Administration.
   5 All Rights Reserved.
   6 */
   7 package gov.nasa.worldwind.layers;
   8
   9 import gov.nasa.worldwind.WWObjectImpl;
  10 import gov.nasa.worldwind.avlist.AVKey;
  11 import gov.nasa.worldwind.geom.Position;
  12 import gov.nasa.worldwind.render.DrawContext;
  13 import gov.nasa.worldwind.util.Logging;
  14
  15 /**
  16  * @author tag
  17  * @version $Id: AbstractLayer.java 2471 2007-07-31 21:50:57Z tgaskins $
  18  */
  19 public abstract class AbstractLayer extends WWObjectImpl implements Layer
  20 {
  21     private boolean enabled = true;
  22     private boolean pickable = true;
  23     private double opacity = 1d;
  24     private double minActiveAltitude = -Double.MAX_VALUE;
  25     private double maxActiveAltitude = Double.MAX_VALUE;
  26
  27     public boolean isEnabled()
  28     {
  29         return this.enabled;
  30     }
  31
  32     public boolean isPickEnabled()
  33     {
  34         return pickable;
  35     }
  36
  37     public void setPickEnabled(boolean pickable)
  38     {
  39         this.pickable = pickable;
  40     }
  41
  42     public void setEnabled(boolean enabled)
  43     {
  44         this.enabled = enabled;
  45     }
  46
  47     public String getName()
  48     {
  49         Object n = this.getValue(AVKey.DISPLAY_NAME);
  50
  51         return n != null ? n.toString() : this.toString();
  52     }
  53
  54     public void setName(String name)
  55     {
  56         this.setValue(AVKey.DISPLAY_NAME, name);
  57     }
  58
  59     public String toString()
  60     {
  61         Object n = this.getValue(AVKey.DISPLAY_NAME);
  62
  63         return n != null ? n.toString() : super.toString();
  64     }
  65
  66     public double getOpacity()
  67     {
  68         return opacity;
  69     }
  70
  71     public void setOpacity(double opacity)
  72     {
  73         this.opacity = opacity;
  74     }
  75
  76     public double getMinActiveAltitude()
  77     {
  78         return minActiveAltitude;
  79     }
  80
  81     public void setMinActiveAltitude(double minActiveAltitude)
  82     {
  83         this.minActiveAltitude = minActiveAltitude;
  84     }
  85
  86     public double getMaxActiveAltitude()
  87     {
  88         return maxActiveAltitude;
  89     }
  90
  91     public void setMaxActiveAltitude(double maxActiveAltitude)
  92     {
  93         this.maxActiveAltitude = maxActiveAltitude;
  94     }
  95
  96     /**
  97      * Indicates whether the layer is in the view. The method implemented here is a default indicating the layer is in
  98      * view. Subclasses able to determine their presence in the view should override this implementation.
  99      *
 100      * @param dc the current draw context
 101      * @return <code>true</code> if the layer is in the view, <code>false</code> otherwise.
 102      */
 103     public boolean isLayerInView(DrawContext dc)
 104     {
 105         if (dc == null)
 106         {
 107             String message = Logging.getMessage("nullValue.DrawContextIsNull");
 108             Logging.logger().severe(message);
 109             throw new IllegalStateException(message);
 110         }
 111
 112         return true;
 113     }
 114
 115     /**
 116      * Indicates whether the layer is active based on arbitrary criteria. The method implemented here is a default
 117      * indicating the layer is active if the current altitude is within the layer's min and max active altitudes.
 118      * Subclasses able to consider more criteria should override this implementation.
 119      *
 120      * @param dc the current draw context
 121      * @return <code>true</code> if the layer is active, <code>false</code> otherwise.
 122      */
 123     public boolean isLayerActive(DrawContext dc)
 124     {
 125         if (dc == null)
 126         {
 127             String message = Logging.getMessage("nullValue.DrawContextIsNull");
 128             Logging.logger().severe(message);
 129             throw new IllegalStateException(message);
 130         }
 131
 132         if (null == dc.getView())
 133         {
 134             String message = Logging.getMessage("layers.AbstractLayer.NoViewSpecifiedInDrawingContext");
 135             Logging.logger().severe(message);
 136             throw new IllegalStateException(message);
 137         }
 138
 139         Position eyePos = dc.getView().getEyePosition();
 140         if (eyePos == null)
 141             return false;
 142
 143         double altitude = eyePos.getElevation();
 144         return altitude >= this.minActiveAltitude && altitude <= this.maxActiveAltitude;
 145     }
 146
 147     /**
 148      * @param dc the current draw context
 149      * @throws IllegalArgumentException if <code>dc</code> is null, or <code>dc</code>'s <code>Globe</code> or
 150      *                                  <code>View</code> is null
 151      */
 152     public void render(DrawContext dc)
 153     {
 154         if (!this.enabled)
 155             return; // Don't check for arg errors if we're disabled
 156
 157         if (null == dc)
 158         {
 159             String message = Logging.getMessage("nullValue.DrawContextIsNull");
 160             Logging.logger().severe(message);
 161             throw new IllegalStateException(message);
 162         }
 163
 164         if (null == dc.getGlobe())
 165         {
 166             String message = Logging.getMessage("layers.AbstractLayer.NoGlobeSpecifiedInDrawingContext");
 167             Logging.logger().severe(message);
 168             throw new IllegalStateException(message);
 169         }
 170
 171         if (null == dc.getView())
 172         {
 173             String message = Logging.getMessage("layers.AbstractLayer.NoViewSpecifiedInDrawingContext");
 174             Logging.logger().severe(message);
 175             throw new IllegalStateException(message);
 176         }
 177
 178         if (!this.isLayerActive(dc))
 179             return;
 180
 181         if (!this.isLayerInView(dc))
 182             return;
 183
 184         this.doRender(dc);
 185     }
 186
 187     public void pick(DrawContext dc, java.awt.Point point)
 188     {
 189         if (!this.enabled)
 190             return; // Don't check for arg errors if we're disabled
 191
 192         if (null == dc)
 193         {
 194             String message = Logging.getMessage("nullValue.DrawContextIsNull");
 195             Logging.logger().severe(message);
 196             throw new IllegalStateException(message);
 197         }
 198
 199         if (null == dc.getGlobe())
 200         {
 201             String message = Logging.getMessage("layers.AbstractLayer.NoGlobeSpecifiedInDrawingContext");
 202             Logging.logger().severe(message);
 203             throw new IllegalStateException(message);
 204         }
 205
 206         if (null == dc.getView())
 207         {
 208             String message = Logging.getMessage("layers.AbstractLayer.NoViewSpecifiedInDrawingContext");
 209             Logging.logger().severe(message);
 210             throw new IllegalStateException(message);
 211         }
 212
 213         if (!this.isLayerActive(dc))
 214             return;
 215
 216         if (!this.isLayerInView(dc))
 217             return;
 218
 219         this.doPick(dc, point);
 220     }
 221
 222     protected void doPick(DrawContext dc, java.awt.Point point)
 223     {
 224         // any state that could change the color needs to be disabled, such as GL_TEXTURE, GL_LIGHTING or GL_FOG.
 225         // re-draw with unique colors
 226         // store the object info in the selectable objects table
 227         // read the color under the coursor
 228         // use the color code as a key to retrieve a selected object from the selectable objects table
 229         // create an instance of the PickedObject and add to the dc via the dc.addPickedObject() method
 230     }
 231
 232     public void dispose() // override if disposal is a supported operation
 233     {
 234     }
 235
 236     protected abstract void doRender(DrawContext dc);
 237 }