Merge pull request #1621 from twpayne/clean-ups

Miscellaneous clean-ups

src/ol/browserfeature.js

@@ -23,6 +23,24 @@ ol.ENABLE_CANVAS = true;
 ol.ENABLE_DOM = true;
 
 
+/**
+ * @define {boolean} Whether to enable rendering of image layers.
+ */
+ol.ENABLE_IMAGE = true;
+
+
+/**
+ * @define {boolean} Whether to enable rendering of tile layers.
+ */
+ol.ENABLE_TILE = true;
+
+
+/**
+ * @define {boolean} Whether to enable rendering of vector layers.
+ */
+ol.ENABLE_VECTOR = true;
+
+
 /**
  * @define {boolean} Whether to enable WebGL.
  */

src/ol/control/zoomtoextentcontrol.js

@@ -2,6 +2,7 @@
 
 goog.provide('ol.control.ZoomToExtent');
 
+goog.require('goog.asserts');
 goog.require('goog.dom');
 goog.require('goog.dom.TagName');
 goog.require('goog.events');
@@ -61,8 +62,10 @@ ol.control.ZoomToExtent.prototype.handleZoomToExtent_ = function(browserEvent) {
   // prevent #zoomExtent anchor from getting appended to the url
   browserEvent.preventDefault();
   var map = this.getMap();
-  var view = map.getView().getView2D();
+  var view = map.getView();
+  goog.asserts.assert(goog.isDef(view));
+  var view2D = view.getView2D();
   var extent = goog.isNull(this.extent_) ?
-      view.getProjection().getExtent() : this.extent_;
-  view.fitExtent(extent, map.getSize());
+      view2D.getProjection().getExtent() : this.extent_;
+  view2D.fitExtent(extent, map.getSize());
 };

src/ol/dom/input.js

@@ -116,10 +116,11 @@ goog.exportProperty(
  * @private
  */
 ol.dom.Input.prototype.handleInputChanged_ = function() {
-  if (this.target_.type === 'checkbox' || this.target_.type === 'radio') {
-    this.setChecked(this.target_.checked);
+  var target = this.target_;
+  if (target.type === 'checkbox' || target.type === 'radio') {
+    this.setChecked(target.checked);
   } else {
-    this.setValue(this.target_.value);
+    this.setValue(target.value);
   }
 };
 

src/ol/events/condition.js

@@ -1,6 +1,7 @@
 goog.provide('ol.events.ConditionType');
 goog.provide('ol.events.condition');
 
+goog.require('goog.asserts');
 goog.require('goog.dom.TagName');
 goog.require('goog.functions');
 goog.require('ol.MapBrowserEvent.EventType');
@@ -107,8 +108,9 @@ ol.events.condition.shiftKeyOnly = function(mapBrowserEvent) {
  * @todo stability experimental
  */
 ol.events.condition.targetNotEditable = function(mapBrowserEvent) {
-  var browserEvent = mapBrowserEvent.browserEvent;
-  var tagName = browserEvent.target.tagName;
+  var target = mapBrowserEvent.browserEvent.target;
+  goog.asserts.assertInstanceof(target, Element);
+  var tagName = target.tagName;
   return (
       tagName !== goog.dom.TagName.INPUT &&
       tagName !== goog.dom.TagName.SELECT &&

src/ol/format/polylineformat.js

@@ -97,6 +97,7 @@ ol.format.Polyline.decodeDeltas = function(encoded, dimension, opt_factor) {
   var factor = goog.isDef(opt_factor) ? opt_factor : 1e5;
   var d;
 
+  /** @type {Array.<number>} */
   var lastNumbers = new Array(dimension);
   for (d = 0; d < dimension; ++d) {
     lastNumbers[d] = 0;

src/ol/geom/circle.js

@@ -159,6 +159,7 @@ ol.geom.Circle.prototype.setCenterAndRadius =
     if (goog.isNull(this.flatCoordinates)) {
       this.flatCoordinates = [];
     }
+    /** @type {Array.<number>} */
     var flatCoordinates = this.flatCoordinates;
     var offset = ol.geom.flat.deflateCoordinate(
         flatCoordinates, 0, center, this.stride);

src/ol/geom/simplifygeom.js

@@ -82,8 +82,8 @@ ol.geom.simplify.douglasPeucker = function(flatCoordinates, offset, end,
     }
     return simplifiedOffset;
   }
-  var MarkerArray = goog.global['Uint8Array'] ? Uint8Array : Array;
-  var markers = new MarkerArray(n);
+  /** @type {Array.<number>} */
+  var markers = new Array(n);
   markers[0] = 1;
   markers[n - 1] = 1;
   /** @type {Array.<number>} */

src/ol/interaction/keyboardpaninteraction.js

@@ -45,7 +45,7 @@ ol.interaction.KeyboardPan = function(opt_options) {
    * @private
    * @type {number}
    */
-  this.delta_ = goog.isDef(options.delta) ? options.delta : 128;
+  this.pixelDelta_ = goog.isDef(options.pixelDelta) ? options.pixelDelta : 128;
 
 };
 goog.inherits(ol.interaction.KeyboardPan, ol.interaction.Interaction);
@@ -71,7 +71,7 @@ ol.interaction.KeyboardPan.prototype.handleMapBrowserEvent =
       var view = map.getView();
       goog.asserts.assertInstanceof(view, ol.View2D);
       var view2DState = view.getView2DState();
-      var mapUnitsDelta = view2DState.resolution * this.delta_;
+      var mapUnitsDelta = view2DState.resolution * this.pixelDelta_;
       var deltaX = 0, deltaY = 0;
       if (keyCode == goog.events.KeyCodes.DOWN) {
         deltaY = -mapUnitsDelta;

src/ol/interaction/selectinteraction.js

@@ -38,12 +38,22 @@ ol.interaction.Select = function(opt_options) {
     layerFilter = options.layerFilter;
   } else if (goog.isDef(options.layer)) {
     var layer = options.layer;
-    layerFilter = function(l) {
+    layerFilter =
+        /**
+         * @param {ol.layer.Layer} l Layer.
+         * @return {boolean} Include.
+         */
+        function(l) {
       return l === layer;
     };
   } else if (goog.isDef(options.layers)) {
     var layers = options.layers;
-    layerFilter = function(layer) {
+    layerFilter =
+        /**
+         * @param {ol.layer.Layer} layer Layer.
+         * @return {boolean} Include.
+         */
+        function(layer) {
       return goog.array.indexOf(layers, layer) != -1;
     };
   } else {
@@ -102,6 +112,7 @@ ol.interaction.Select.prototype.handleMapBrowserEvent =
                 }
               }, undefined, this.layerFilter_);
         } else {
+          /** @type {ol.Feature|undefined} */
           var feature = map.forEachFeatureAtPixel(mapBrowserEvent.pixel,
               /**
                * @param {ol.Feature} feature Feature.

src/ol/map.js

@@ -376,6 +376,7 @@ ol.Map = function(options) {
   this.controls_.forEach(
       /**
        * @param {ol.control.Control} control Control.
+       * @this {ol.Map}
        */
       function(control) {
         control.setMap(this);
@@ -384,6 +385,7 @@ ol.Map = function(options) {
   this.interactions_.forEach(
       /**
        * @param {ol.interaction.Interaction} interaction Interaction.
+       * @this {ol.Map}
        */
       function(interaction) {
         interaction.setMap(this);
@@ -392,6 +394,7 @@ ol.Map = function(options) {
   this.overlays_.forEach(
       /**
        * @param {ol.Overlay} overlay Overlay.
+       * @this {ol.Map}
        */
       function(overlay) {
         overlay.setMap(this);
@@ -1342,21 +1345,21 @@ ol.Map.createOptionsInternal = function(options) {
     rendererHints = ol.DEFAULT_RENDERER_HINTS;
   }
 
-  var n = rendererHints.length;
-  var i, rendererHint;
-  for (i = 0; i < n; ++i) {
-    rendererHint = rendererHints[i];
-    if (rendererHint == ol.RendererHint.CANVAS) {
+  var i, ii;
+  for (i = 0, ii = rendererHints.length; i < ii; ++i) {
+    /** @type {ol.RendererHint} */
+    var rendererHint = rendererHints[i];
+    if (ol.ENABLE_CANVAS && rendererHint == ol.RendererHint.CANVAS) {
       if (ol.BrowserFeature.HAS_CANVAS) {
         rendererConstructor = ol.renderer.canvas.Map;
         break;
       }
-    } else if (rendererHint == ol.RendererHint.DOM) {
+    } else if (ol.ENABLE_DOM && rendererHint == ol.RendererHint.DOM) {
       if (ol.BrowserFeature.HAS_DOM) {
         rendererConstructor = ol.renderer.dom.Map;
         break;
       }
-    } else if (rendererHint == ol.RendererHint.WEBGL) {
+    } else if (ol.ENABLE_WEBGL && rendererHint == ol.RendererHint.WEBGL) {
       if (ol.BrowserFeature.HAS_WEBGL) {
         rendererConstructor = ol.renderer.webgl.Map;
         break;

src/ol/object.js

@@ -235,9 +235,13 @@ ol.Object.prototype.bindTo = function(key, target, opt_targetKey) {
 
   // listen for change:targetkey events
   var eventType = ol.Object.getChangeEventType(targetKey);
-  this.listeners_[key] = goog.events.listen(target, eventType, function() {
-    this.notifyInternal_(key);
-  }, undefined, this);
+  this.listeners_[key] = goog.events.listen(target, eventType,
+      /**
+       * @this {ol.Object}
+       */
+      function() {
+        this.notifyInternal_(key);
+      }, undefined, this);
 
   // listen for beforechange events and relay if key matches
   this.beforeChangeListeners_[key] = goog.events.listen(target,

src/ol/renderer/canvas/canvasmaprenderer.js

@@ -72,11 +72,11 @@ goog.inherits(ol.renderer.canvas.Map, ol.renderer.Map);
  * @inheritDoc
  */
 ol.renderer.canvas.Map.prototype.createLayerRenderer = function(layer) {
-  if (layer instanceof ol.layer.Image) {
+  if (ol.ENABLE_IMAGE && layer instanceof ol.layer.Image) {
     return new ol.renderer.canvas.ImageLayer(this, layer);
-  } else if (layer instanceof ol.layer.Tile) {
+  } else if (ol.ENABLE_TILE && layer instanceof ol.layer.Tile) {
     return new ol.renderer.canvas.TileLayer(this, layer);
-  } else if (layer instanceof ol.layer.Vector) {
+  } else if (ol.ENABLE_VECTOR && layer instanceof ol.layer.Vector) {
     return new ol.renderer.canvas.VectorLayer(this, layer);
   } else {
     goog.asserts.fail();

src/ol/renderer/dom/dommaprenderer.js

@@ -53,10 +53,10 @@ goog.inherits(ol.renderer.dom.Map, ol.renderer.Map);
  */
 ol.renderer.dom.Map.prototype.createLayerRenderer = function(layer) {
   var layerRenderer;
-  if (layer instanceof ol.layer.Tile) {
-    layerRenderer = new ol.renderer.dom.TileLayer(this, layer);
-  } else if (layer instanceof ol.layer.Image) {
+  if (ol.ENABLE_IMAGE && layer instanceof ol.layer.Image) {
     layerRenderer = new ol.renderer.dom.ImageLayer(this, layer);
+  } else if (ol.ENABLE_TILE && layer instanceof ol.layer.Tile) {
+    layerRenderer = new ol.renderer.dom.TileLayer(this, layer);
   } else {
     goog.asserts.fail();
     return null;

src/ol/renderer/webgl/webglmaprenderer.js

@@ -258,10 +258,10 @@ ol.renderer.webgl.Map.prototype.bindTileTexture =
  * @inheritDoc
  */
 ol.renderer.webgl.Map.prototype.createLayerRenderer = function(layer) {
-  if (layer instanceof ol.layer.Tile) {
-    return new ol.renderer.webgl.TileLayer(this, layer);
-  } else if (layer instanceof ol.layer.Image) {
+  if (ol.ENABLE_IMAGE && layer instanceof ol.layer.Image) {
     return new ol.renderer.webgl.ImageLayer(this, layer);
+  } else if (ol.ENABLE_TILE && layer instanceof ol.layer.Tile) {
+    return new ol.renderer.webgl.TileLayer(this, layer);
   } else {
     goog.asserts.fail();
     return null;