Shuffling resources; better variable names; better type declarations.

src/ol/events/MapEvent.js

@@ -1,25 +1,43 @@
-goog.provide('ol.MapEvent');
+goog.provide('ol.events.MapEvent');
+goog.provide('ol.events.MapEventType');
 
 goog.require('goog.events.Event');
 
+
+/**
+ * @enum {string}
+ */
+ol.events.MapEventType = {
+    // drag handler
+    DRAGSTART: 'dragstart',
+    DRAG: 'drag',
+    DRAGEND: 'dragend',
+
+    // mousewheel handler
+    MOUSEWHEEL: 'mousewheel',
+
+    // click handler
+    CLICK: 'click'
+};
+
 /**
  * @constructor
  * @extends {goog.events.Event}
  * @param {string} type Event type.
  * @param {goog.events.Event} evt The wrapped event.
  */
-ol.MapEvent = function(type, evt) {
+ol.events.MapEvent = function(type, evt) {
     goog.base(this, type);
 
     /**
-     * X displacement relative to previous drag.
+     * X displacement relative to the previous drag event, if any.
      *
      * @type {number|undefined}
      */
     this.deltaX = undefined;
 
     /**
-     * Y displacement relative to previous drag.
+     * Y displacement relative to the previous drag event, if any.
      *
      * @type {number|undefined}
      */
@@ -33,4 +51,4 @@ ol.MapEvent = function(type, evt) {
      */
     this.event_ = evt;
 };
-goog.inherits(ol.MapEvent, goog.events.Event);
+goog.inherits(ol.events.MapEvent, goog.events.Event);

src/ol/handler/Click.js

@@ -9,8 +9,9 @@
 
 goog.provide('ol.handler.Click');
 
-goog.require('ol.MapEvent');
+goog.require('ol.handler.states');
-goog.require('ol.MapEventType');
+goog.require('ol.events.MapEvent');
+goog.require('ol.events.MapEventType');
 
 goog.require('goog.asserts');
 goog.require('goog.events');
@@ -22,10 +23,10 @@ goog.require('goog.Disposable');
  * @constructor
  * @extends {goog.Disposable}
  * @param {ol.Map} map The map instance.
- * @param {Element} elt The element we listen to mousewheel on.
+ * @param {Element} element The element we listen for click on.
  * @param {Object} states An object for the handlers to share states.
  */
-ol.handler.Click = function(map, elt, states) {
+ol.handler.Click = function(map, element, states) {
     goog.base(this);
 
     /**
@@ -36,14 +37,14 @@ ol.handler.Click = function(map, elt, states) {
     /**
      * @type {Element}
      */
-    this.elt_ = elt;
+    this.element_ = element;
 
     /**
      * @type {Object}
      */
     this.states_ = states;
 
-    goog.events.listen(this.elt_, goog.events.EventType.CLICK,
+    goog.events.listen(this.element_, goog.events.EventType.CLICK,
                        this.handleClick, undefined, this);
 };
 goog.inherits(ol.handler.Click, goog.Disposable);
@@ -52,7 +53,7 @@ goog.inherits(ol.handler.Click, goog.Disposable);
  * @inheritDoc
  */
 ol.handler.Click.prototype.disposeInternal = function() {
-    goog.events.unlisten(this.elt_, goog.events.EventType.CLICK,
+    goog.events.unlisten(this.element_, goog.events.EventType.CLICK,
                          this.handleClick, undefined, this);
 };
 
@@ -62,7 +63,7 @@ ol.handler.Click.prototype.disposeInternal = function() {
 ol.handler.Click.prototype.handleClick = function(e) {
     // do not emit a map click event after a drag
     if (!this.states_.dragged) {
-        var newE = new ol.MapEvent(ol.MapEventType.CLICK, e);
+        var newE = new ol.events.MapEvent(ol.events.MapEventType.CLICK, e);
         goog.events.dispatchEvent(this.map_, newE);
     }
 };

src/ol/handler/Drag.js

@@ -9,8 +9,9 @@
 
 goog.provide('ol.handler.Drag');
 
-goog.require('ol.MapEvent');
+goog.require('ol.handler.states');
-goog.require('ol.MapEventType');
+goog.require('ol.events.MapEvent');
+goog.require('ol.events.MapEventType');
 
 goog.require('goog.asserts');
 goog.require('goog.events');
@@ -23,10 +24,10 @@ goog.require('goog.fx.Dragger');
  * @constructor
  * @extends {goog.Disposable}
  * @param {ol.Map} map The map instance.
- * @param {Element} elt The element that will be dragged.
+ * @param {Element} element The element that will be dragged.
  * @param {Object} states An object for the handlers to share states.
  */
-ol.handler.Drag = function(map, elt, states) {
+ol.handler.Drag = function(map, element, states) {
     goog.base(this);
 
     /**
@@ -37,7 +38,7 @@ ol.handler.Drag = function(map, elt, states) {
     /**
      * @type {Element}
      */
-    this.elt_ = elt;
+    this.element_ = element;
 
     /**
      * @type {Object}
@@ -47,7 +48,7 @@ ol.handler.Drag = function(map, elt, states) {
     /**
      * @type {goog.fx.Dragger}
      */
-    this.dragger_ = new goog.fx.Dragger(elt);
+    this.dragger_ = new goog.fx.Dragger(element);
 
     var dragger = this.dragger_;
     dragger.defaultAction = function() {};
@@ -80,7 +81,7 @@ goog.inherits(ol.handler.Drag, goog.Disposable);
 ol.handler.Drag.prototype.disposeInternal = function() {
     goog.base(this, 'disposeInternal');
     goog.dispose(this.dragger_);
-    goog.events.unlisten(this.elt_,
+    goog.events.unlisten(this.element_,
                          [goog.events.EventType.TOUCHMOVE,
                           goog.events.EventType.MOUSEMOVE],
                          goog.events.Event.preventDefault, false, this);
@@ -94,11 +95,11 @@ ol.handler.Drag.prototype.handleDragStart = function(e) {
     this.states_.dragged = false;
     this.prevX_ = e.clientX;
     this.prevY_ = e.clientY;
-    var newE = new ol.MapEvent(ol.MapEventType.DRAGSTART, e);
+    var newE = new ol.events.MapEvent(ol.events.MapEventType.DRAGSTART, e);
     goog.events.dispatchEvent(this.map_, newE);
 
     // this is to prevent page scrolling
-    goog.events.listen(this.elt_,
+    goog.events.listen(this.element_,
                        [goog.events.EventType.TOUCHMOVE,
                         goog.events.EventType.MOUSEMOVE],
                        goog.events.Event.preventDefault, false, this);
@@ -110,9 +111,9 @@ ol.handler.Drag.prototype.handleDragStart = function(e) {
  */
 ol.handler.Drag.prototype.handleDrag = function(e) {
     this.states_.dragged = true;
-    var newE = new ol.MapEvent(ol.MapEventType.DRAG, e);
+    var newE = new ol.events.MapEvent(ol.events.MapEventType.DRAG, e);
-    newE.deltaX = e.clientX - this.prevX_;
+    newE.delementaX = e.clientX - this.prevX_;
-    newE.deltaY = e.clientY - this.prevY_;
+    newE.delementaY = e.clientY - this.prevY_;
     this.prevX_ = e.clientX;
     this.prevY_ = e.clientY;
     var rt = goog.events.dispatchEvent(this.map_, newE);
@@ -122,21 +123,21 @@ ol.handler.Drag.prototype.handleDrag = function(e) {
 };
 
 /**
- * @param {ol.MapEvent} e
+ * @param {ol.events.MapEvent} e
  */
 ol.handler.Drag.prototype.defaultBehavior = function(e) {
-    var deltaX = /** @type {number} */ e.deltaX;
+    var delementaX = /** @type {number} */ e.delementaX;
-    var deltaY = /** @type {number} */ e.deltaY;
+    var delementaY = /** @type {number} */ e.delementaY;
-    this.map_.moveByViewportPx(deltaX, deltaY);
+    this.map_.moveByViewportPx(delementaX, delementaY);
 };
 
 /**
  * @param {goog.fx.DragEvent} e
  */
 ol.handler.Drag.prototype.handleDragEnd = function(e) {
-    var newE = new ol.MapEvent(ol.MapEventType.DRAGEND, e);
+    var newE = new ol.events.MapEvent(ol.events.MapEventType.DRAGEND, e);
     goog.events.dispatchEvent(this.map_, newE);
-    goog.events.unlisten(this.elt_,
+    goog.events.unlisten(this.element_,
                          [goog.events.EventType.TOUCHMOVE,
                           goog.events.EventType.MOUSEMOVE],
                          goog.events.Event.preventDefault, false, this);
@@ -146,7 +147,7 @@ ol.handler.Drag.prototype.handleDragEnd = function(e) {
  * @param {goog.fx.DragEvent} e
  */
 ol.handler.Drag.prototype.handleDragEarlyCancel = function(e) {
-    goog.events.unlisten(this.elt_,
+    goog.events.unlisten(this.element_,
                          [goog.events.EventType.TOUCHMOVE,
                           goog.events.EventType.MOUSEMOVE],
                          goog.events.Event.preventDefault, false, this);

src/ol/handler/MouseWheel.js

@@ -9,8 +9,9 @@
 
 goog.provide('ol.handler.MouseWheel');
 
-goog.require('ol.MapEvent');
+goog.require('ol.handler.states');
-goog.require('ol.MapEventType');
+goog.require('ol.events.MapEvent');
+goog.require('ol.events.MapEventType');
 
 goog.require('goog.asserts');
 goog.require('goog.events');
@@ -24,10 +25,10 @@ goog.require('goog.events.MouseWheelHandler.EventType');
  * @constructor
  * @extends {goog.Disposable}
  * @param {ol.Map} map The map instance.
- * @param {Element} elt The element we listen to mousewheel on.
+ * @param {Element} element The element we listen to mousewheel on.
  * @param {Object} states An object for the handlers to share states.
  */
-ol.handler.MouseWheel = function(map, elt, states) {
+ol.handler.MouseWheel = function(map, element, states) {
     goog.base(this);
 
     /**
@@ -38,9 +39,9 @@ ol.handler.MouseWheel = function(map, elt, states) {
     /**
      * @type {Element}
      */
-    this.elt_ = elt;
+    this.element_ = element;
 
-    var handler = new goog.events.MouseWheelHandler(elt);
+    var handler = new goog.events.MouseWheelHandler(element);
     this.registerDisposable(handler);
 
     goog.events.listen(handler,
@@ -54,8 +55,8 @@ goog.inherits(ol.handler.MouseWheel, goog.Disposable);
  * @param {goog.events.MouseWheelEvent} e
  */
 ol.handler.MouseWheel.prototype.handleMouseWheel = function(e) {
-    var newE = new ol.MapEvent(ol.MapEventType.MOUSEWHEEL, e);
+    var newE = new ol.events.MapEvent(ol.events.MapEventType.MOUSEWHEEL, e);
-    var rt = goog.events.dispatchEvent(this.map_, e);
+    var rt = goog.events.dispatchEvent(this.map_, newE);
     if (rt) {
         this.defaultBehavior(e);
     }
@@ -76,7 +77,7 @@ ol.handler.MouseWheel.prototype.defaultBehavior = function(e) {
     var map = me.map_,
         step = e.deltaY / Math.abs(e.deltaY);
     map.setZoom(map.getZoom() - step,
-                goog.style.getRelativePosition(e, this.elt_));
+                goog.style.getRelativePosition(e, this.element_));
 
     // We don't want the page to scroll.
     // (MouseWheelEvent is a BrowserEvent)

src/ol/handler/handler.js

@@ -0,0 +1,13 @@
+goog.provide('ol.handler.states');
+
+/**
+ * Type definition for shared states between handlers. The following states
+ * are defined:
+ *
+ * * dragged {boolean} - Set by the Drag handler when we are dragging. Read by
+ *   the click handler to determine if a click is a real click or the result
+ *   of a mouseup/touchend at the end of a drag sequence.
+ *
+ * @typedef {{dragged: boolean}}
+ */
+ol.handler.states;

src/ol/mapeventtype.js

@@ -1,17 +0,0 @@
-goog.provide('ol.MapEventType');
-
-/**
- * @enum {string}
- */
-ol.MapEventType = {
-    // drag handler
-    DRAGSTART: 'dragstart',
-    DRAG: 'drag',
-    DRAGEND: 'dragend',
-
-    // mousewheel handler
-    MOUSEWHEEL: 'mousewheel',
-
-    // click handler
-    CLICK: 'click'
-};