Adding mapbox-gl branch

2015-03-16 18:50:27 +01:00
parent 7985f030fa
commit 57ee7f52fd
3109 changed files with 943365 additions and 0 deletions
@@ -0,0 +1,159 @@
+// Copyright 2014 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/**
+ * @fileoverview This event wrapper will dispatch an event when the user uses
+ * the wheel on an element. The event provides details of the unit type (pixel /
+ * line / page) and deltas in those units in up to 3 dimensions. Additionally,
+ * simplified pixel deltas are provided for code that doesn't need to handle the
+ * different units differently. This is not to be confused with the scroll
+ * event, where an element in the dom can report that it was scrolled.
+ *
+ * This class aims to smooth out inconsistencies between browser platforms with
+ * regards to wheel events, but we do not cover every possible software/hardware
+ * combination out there, some of which occasionally produce very large deltas
+ * in wheel events, especially when the device supports acceleration.
+ *
+ * Relevant standard:
+ * http://www.w3.org/TR/2014/WD-DOM-Level-3-Events-20140925/#interface-WheelEvent
+ *
+ * Clients of this code should be aware that some input devices only fire a few
+ * discrete events (such as a mouse wheel without acceleration) whereas some can
+ * generate a large number of events for a single interaction (such as a
+ * touchpad with acceleration). There is no signal in the events to reliably
+ * distinguish between these.
+ *
+ * @author arv@google.com (Erik Arvidsson)
+ * @see ../demos/wheelhandler.html
+ */
+
+goog.provide('goog.events.WheelHandler');
+
+goog.require('goog.dom');
+goog.require('goog.events');
+goog.require('goog.events.EventTarget');
+goog.require('goog.events.WheelEvent');
+goog.require('goog.style');
+goog.require('goog.userAgent');
+goog.require('goog.userAgent.product');
+goog.require('goog.userAgent.product.isVersion');
+
+
+
+/**
+ * This event handler allows you to catch wheel events in a consistent manner.
+ * @param {!Element|!Document} element The element to listen to the wheel event
+ *     on.
+ * @param {boolean=} opt_capture Whether to handle the wheel event in capture
+ *     phase.
+ * @constructor
+ * @extends {goog.events.EventTarget}
+ */
+goog.events.WheelHandler = function(element, opt_capture) {
+  goog.events.WheelHandler.base(this, 'constructor');
+
+  /**
+   * This is the element that we will listen to the real wheel events on.
+   * @private {!Element|!Document}
+   */
+  this.element_ = element;
+
+  var rtlElement = goog.dom.isElement(this.element_) ?
+      /** @type {!Element} */ (this.element_) :
+      /** @type {!Document} */ (this.element_).body;
+
+  /**
+   * True if the element exists and is RTL, false otherwise.
+   * @private {boolean}
+   */
+  this.isRtl_ = !!rtlElement && goog.style.isRightToLeft(rtlElement);
+
+  /**
+   * The key returned from the goog.events.listen.
+   * @private {goog.events.Key}
+   */
+  this.listenKey_ = goog.events.listen(
+      this.element_, goog.events.WheelHandler.getDomEventType(),
+      this, opt_capture);
+};
+goog.inherits(goog.events.WheelHandler, goog.events.EventTarget);
+
+
+/**
+ * Returns the dom event type.
+ * @return {string} The dom event type.
+ */
+goog.events.WheelHandler.getDomEventType = function() {
+  // Prefer to use wheel events whenever supported.
+  if (goog.userAgent.GECKO && goog.userAgent.isVersionOrHigher(17) ||
+      goog.userAgent.IE && goog.userAgent.isVersionOrHigher(9) ||
+      goog.userAgent.product.CHROME && goog.userAgent.product.isVersion(31)) {
+    return 'wheel';
+  }
+
+  // Legacy events. Still the best we have on Opera and Safari.
+  return goog.userAgent.GECKO ? 'DOMMouseScroll' : 'mousewheel';
+};
+
+
+/**
+ * Handles the events on the element.
+ * @param {!goog.events.BrowserEvent} e The underlying browser event.
+ */
+goog.events.WheelHandler.prototype.handleEvent = function(e) {
+  var deltaMode = goog.events.WheelEvent.DeltaMode.PIXEL;
+  var deltaX = 0;
+  var deltaY = 0;
+  var deltaZ = 0;
+  var be = e.getBrowserEvent();
+  if (be.type == 'wheel') {
+    deltaMode = be.deltaMode;
+    deltaX = be.deltaX;
+    deltaY = be.deltaY;
+    deltaZ = be.deltaZ;
+  } else if (be.type == 'mousewheel') {
+    // Assume that these are still comparable to pixels. This may not be true
+    // for all old browsers.
+    if (goog.isDef(be.wheelDeltaX)) {
+      deltaX = -be.wheelDeltaX;
+      deltaY = -be.wheelDeltaY;
+    } else {
+      deltaY = -be.wheelDelta;
+    }
+  } else { // Historical Gecko
+    // Gecko returns multiple of 3 (representing the number of lines)
+    deltaMode = goog.events.WheelEvent.DeltaMode.LINE;
+    // Firefox 3.1 adds an axis field to the event to indicate axis.
+    if (goog.isDef(be.axis) && be.axis === be.HORIZONTAL_AXIS) {
+      deltaX = be.detail;
+    } else {
+      deltaY = be.detail;
+    }
+  }
+  // For horizontal deltas we need to flip the value for RTL grids.
+  if (this.isRtl_) {
+    deltaX = -deltaX;
+  }
+  var newEvent = new goog.events.WheelEvent(
+      be, deltaMode, deltaX, deltaY, deltaZ);
+  this.dispatchEvent(newEvent);
+};
+
+
+/** @override */
+goog.events.WheelHandler.prototype.disposeInternal = function() {
+  goog.events.WheelHandler.superClass_.disposeInternal.call(this);
+  goog.events.unlistenByKey(this.listenKey_);
+  this.listenKey_ = null;
+};