diff --git a/Makefile b/Makefile index 3e9fb34c42..5ae4e9291f 100644 --- a/Makefile +++ b/Makefile @@ -181,7 +181,7 @@ build/timestamps/check-%-timestamp: $(BUILD_HOSTED)/examples/%.html \ $(BUILD_HOSTED)/build/ol.js \ $(BUILD_HOSTED)/css/ol.css @mkdir -p $(@D) - ./node_modules/.bin/phantomjs --ssl-protocol=any --ignore-ssl-errors=true bin/check-example.js $< + ./node_modules/.bin/phantomjs --local-to-remote-url-access=true --ssl-protocol=any --ignore-ssl-errors=true bin/check-example.js $< @touch $@ build/timestamps/check-requires-timestamp: $(SRC_JS) $(EXAMPLES_JS) \ diff --git a/externs/closure-compiler.js b/externs/closure-compiler.js index 7894661c23..d51b19d762 100644 --- a/externs/closure-compiler.js +++ b/externs/closure-compiler.js @@ -15,3 +15,13 @@ * @see http://www.w3.org/TR/pointerevents/#the-touch-action-css-property */ CSSProperties.prototype.touchAction; + +/** + * @type {number} + */ +WheelEvent.DOM_DELTA_LINE; + +/** + * @type {number} + */ +WheelEvent.DOM_DELTA_PIXEL; diff --git a/externs/readme.md b/externs/readme.md index 992c354fe3..3c1880d689 100644 --- a/externs/readme.md +++ b/externs/readme.md @@ -28,7 +28,7 @@ In the source file (`src/ol/MapBrowserEvent.js`), the class needs to implement t * @constructor * @implements {oli.MapBrowserEvent} */ -ol.MapBrowserEvent = function(type, map, browserEvent, opt_frameState) { +ol.MapBrowserEvent = function(type, map, originalEvent, opt_frameState) { // ... diff --git a/src/ol/collection.js b/src/ol/collection.js index fff2bcd803..cdb3c73276 100644 --- a/src/ol/collection.js +++ b/src/ol/collection.js @@ -7,7 +7,7 @@ goog.provide('ol.Collection'); goog.provide('ol.CollectionEvent'); goog.provide('ol.CollectionEventType'); -goog.require('goog.events.Event'); +goog.require('ol.events.Event'); goog.require('ol.Object'); @@ -36,7 +36,7 @@ ol.CollectionEventType = { * type. * * @constructor - * @extends {goog.events.Event} + * @extends {ol.events.Event} * @implements {oli.CollectionEvent} * @param {ol.CollectionEventType} type Type. * @param {*=} opt_element Element. @@ -54,7 +54,7 @@ ol.CollectionEvent = function(type, opt_element, opt_target) { this.element = opt_element; }; -goog.inherits(ol.CollectionEvent, goog.events.Event); +goog.inherits(ol.CollectionEvent, ol.events.Event); /** diff --git a/src/ol/control/attributioncontrol.js b/src/ol/control/attributioncontrol.js index 7bbe152f72..2aec3d73c8 100644 --- a/src/ol/control/attributioncontrol.js +++ b/src/ol/control/attributioncontrol.js @@ -5,8 +5,8 @@ goog.provide('ol.control.Attribution'); goog.require('goog.asserts'); goog.require('goog.dom'); goog.require('goog.dom.classlist'); -goog.require('goog.events'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.EventType'); goog.require('goog.object'); goog.require('goog.style'); goog.require('ol'); @@ -95,8 +95,7 @@ ol.control.Attribution = function(opt_options) { 'title': tipLabel }, activeLabel); - goog.events.listen(button, goog.events.EventType.CLICK, - this.handleClick_, false, this); + ol.events.listen(button, ol.events.EventType.CLICK, this.handleClick_, this); var cssClasses = className + ' ' + ol.css.CLASS_UNSELECTABLE + ' ' + ol.css.CLASS_CONTROL + @@ -328,7 +327,7 @@ ol.control.Attribution.prototype.insertLogos_ = function(frameState) { /** - * @param {goog.events.BrowserEvent} event The event to handle + * @param {Event} event The event to handle * @private */ ol.control.Attribution.prototype.handleClick_ = function(event) { diff --git a/src/ol/control/control.js b/src/ol/control/control.js index 20350fc5b4..13465598c5 100644 --- a/src/ol/control/control.js +++ b/src/ol/control/control.js @@ -1,7 +1,7 @@ goog.provide('ol.control.Control'); goog.require('goog.dom'); -goog.require('goog.events'); +goog.require('ol.events'); goog.require('ol'); goog.require('ol.MapEventType'); goog.require('ol.Object'); @@ -60,7 +60,7 @@ ol.control.Control = function(options) { /** * @protected - * @type {!Array.} + * @type {!Array.} */ this.listenerKeys = []; @@ -107,18 +107,18 @@ ol.control.Control.prototype.setMap = function(map) { if (this.map_) { goog.dom.removeNode(this.element); } - if (this.listenerKeys.length > 0) { - this.listenerKeys.forEach(goog.events.unlistenByKey); - this.listenerKeys.length = 0; + for (var i = 0, ii = this.listenerKeys.length; i < ii; ++i) { + ol.events.unlistenByKey(this.listenerKeys[i]); } + this.listenerKeys.length = 0; this.map_ = map; if (this.map_) { var target = this.target_ ? this.target_ : map.getOverlayContainerStopEvent(); target.appendChild(this.element); if (this.render !== ol.nullFunction) { - this.listenerKeys.push(goog.events.listen(map, - ol.MapEventType.POSTRENDER, this.render, false, this)); + this.listenerKeys.push(ol.events.listen(map, + ol.MapEventType.POSTRENDER, this.render, this)); } map.render(); } diff --git a/src/ol/control/fullscreencontrol.js b/src/ol/control/fullscreencontrol.js index f0a5046202..af7a210437 100644 --- a/src/ol/control/fullscreencontrol.js +++ b/src/ol/control/fullscreencontrol.js @@ -5,8 +5,8 @@ goog.require('goog.dom'); goog.require('goog.dom.classlist'); goog.require('goog.dom.fullscreen'); goog.require('goog.dom.fullscreen.EventType'); -goog.require('goog.events'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.EventType'); goog.require('ol'); goog.require('ol.control.Control'); goog.require('ol.css'); @@ -64,12 +64,12 @@ ol.control.FullScreen = function(opt_options) { 'title': tipLabel }, this.labelNode_); - goog.events.listen(button, goog.events.EventType.CLICK, - this.handleClick_, false, this); + ol.events.listen(button, ol.events.EventType.CLICK, + this.handleClick_, this); - goog.events.listen(goog.global.document, + ol.events.listen(goog.global.document, goog.dom.fullscreen.EventType.CHANGE, - this.handleFullScreenChange_, false, this); + this.handleFullScreenChange_, this); var cssClasses = this.cssClassName_ + ' ' + ol.css.CLASS_UNSELECTABLE + ' ' + ol.css.CLASS_CONTROL + ' ' + @@ -98,7 +98,7 @@ goog.inherits(ol.control.FullScreen, ol.control.Control); /** - * @param {goog.events.BrowserEvent} event The event to handle + * @param {Event} event The event to handle * @private */ ol.control.FullScreen.prototype.handleClick_ = function(event) { diff --git a/src/ol/control/mousepositioncontrol.js b/src/ol/control/mousepositioncontrol.js index d2f18b4aee..7a558a042a 100644 --- a/src/ol/control/mousepositioncontrol.js +++ b/src/ol/control/mousepositioncontrol.js @@ -3,8 +3,8 @@ goog.provide('ol.control.MousePosition'); goog.require('goog.dom'); -goog.require('goog.events'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.EventType'); goog.require('ol.CoordinateFormatType'); goog.require('ol.Object'); goog.require('ol.Pixel'); @@ -53,9 +53,9 @@ ol.control.MousePosition = function(opt_options) { target: options.target }); - goog.events.listen(this, + ol.events.listen(this, ol.Object.getChangeEventType(ol.control.MousePositionProperty.PROJECTION), - this.handleProjectionChanged_, false, this); + this.handleProjectionChanged_, this); if (options.coordinateFormat) { this.setCoordinateFormat(options.coordinateFormat); @@ -154,21 +154,21 @@ ol.control.MousePosition.prototype.getProjection = function() { /** - * @param {goog.events.BrowserEvent} browserEvent Browser event. + * @param {Event} event Browser event. * @protected */ -ol.control.MousePosition.prototype.handleMouseMove = function(browserEvent) { +ol.control.MousePosition.prototype.handleMouseMove = function(event) { var map = this.getMap(); - this.lastMouseMovePixel_ = map.getEventPixel(browserEvent.getBrowserEvent()); + this.lastMouseMovePixel_ = map.getEventPixel(event); this.updateHTML_(this.lastMouseMovePixel_); }; /** - * @param {goog.events.BrowserEvent} browserEvent Browser event. + * @param {Event} event Browser event. * @protected */ -ol.control.MousePosition.prototype.handleMouseOut = function(browserEvent) { +ol.control.MousePosition.prototype.handleMouseOut = function(event) { this.updateHTML_(null); this.lastMouseMovePixel_ = null; }; @@ -183,10 +183,10 @@ ol.control.MousePosition.prototype.setMap = function(map) { if (map) { var viewport = map.getViewport(); this.listenerKeys.push( - goog.events.listen(viewport, goog.events.EventType.MOUSEMOVE, - this.handleMouseMove, false, this), - goog.events.listen(viewport, goog.events.EventType.MOUSEOUT, - this.handleMouseOut, false, this) + ol.events.listen(viewport, ol.events.EventType.MOUSEMOVE, + this.handleMouseMove, this), + ol.events.listen(viewport, ol.events.EventType.MOUSEOUT, + this.handleMouseOut, this) ); } }; diff --git a/src/ol/control/overviewmapcontrol.js b/src/ol/control/overviewmapcontrol.js index 1490832597..33e4a6a6d5 100644 --- a/src/ol/control/overviewmapcontrol.js +++ b/src/ol/control/overviewmapcontrol.js @@ -3,8 +3,8 @@ goog.provide('ol.control.OverviewMap'); goog.require('goog.asserts'); goog.require('goog.dom'); goog.require('goog.dom.classlist'); -goog.require('goog.events'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.EventType'); goog.require('goog.math.Size'); goog.require('goog.style'); goog.require('ol'); @@ -83,8 +83,8 @@ ol.control.OverviewMap = function(opt_options) { 'title': tipLabel }, activeLabel); - goog.events.listen(button, goog.events.EventType.CLICK, - this.handleClick_, false, this); + ol.events.listen(button, ol.events.EventType.CLICK, + this.handleClick_, this); var ovmapDiv = goog.dom.createDom('DIV', 'ol-overviewmap-map'); @@ -159,9 +159,9 @@ ol.control.OverviewMap.prototype.setMap = function(map) { goog.base(this, 'setMap', map); if (map) { - this.listenerKeys.push(goog.events.listen( + this.listenerKeys.push(ol.events.listen( map, ol.ObjectEventType.PROPERTYCHANGE, - this.handleMapPropertyChange_, false, this)); + this.handleMapPropertyChange_, this)); // TODO: to really support map switching, this would need to be reworked if (this.ovmap_.getLayers().getLength() === 0) { @@ -203,9 +203,9 @@ ol.control.OverviewMap.prototype.handleMapPropertyChange_ = function(event) { * @private */ ol.control.OverviewMap.prototype.bindView_ = function(view) { - goog.events.listen(view, + ol.events.listen(view, ol.Object.getChangeEventType(ol.ViewProperty.ROTATION), - this.handleRotationChanged_, false, this); + this.handleRotationChanged_, this); }; @@ -215,9 +215,9 @@ ol.control.OverviewMap.prototype.bindView_ = function(view) { * @private */ ol.control.OverviewMap.prototype.unbindView_ = function(view) { - goog.events.unlisten(view, + ol.events.unlisten(view, ol.Object.getChangeEventType(ol.ViewProperty.ROTATION), - this.handleRotationChanged_, false, this); + this.handleRotationChanged_, this); }; @@ -432,7 +432,7 @@ ol.control.OverviewMap.prototype.calculateCoordinateRotate_ = function( /** - * @param {goog.events.BrowserEvent} event The event to handle + * @param {Event} event The event to handle * @private */ ol.control.OverviewMap.prototype.handleClick_ = function(event) { @@ -459,11 +459,11 @@ ol.control.OverviewMap.prototype.handleToggle_ = function() { if (!this.collapsed_ && !ovmap.isRendered()) { ovmap.updateSize(); this.resetExtent_(); - goog.events.listenOnce(ovmap, ol.MapEventType.POSTRENDER, + ol.events.listenOnce(ovmap, ol.MapEventType.POSTRENDER, function(event) { this.updateBox_(); }, - false, this); + this); } }; diff --git a/src/ol/control/rotatecontrol.js b/src/ol/control/rotatecontrol.js index 378a47f4c6..6c6fd9086f 100644 --- a/src/ol/control/rotatecontrol.js +++ b/src/ol/control/rotatecontrol.js @@ -2,8 +2,8 @@ goog.provide('ol.control.Rotate'); goog.require('goog.dom'); goog.require('goog.dom.classlist'); -goog.require('goog.events'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.EventType'); goog.require('ol'); goog.require('ol.animation'); goog.require('ol.control.Control'); @@ -53,8 +53,8 @@ ol.control.Rotate = function(opt_options) { 'title': tipLabel }, this.label_); - goog.events.listen(button, goog.events.EventType.CLICK, - ol.control.Rotate.prototype.handleClick_, false, this); + ol.events.listen(button, ol.events.EventType.CLICK, + ol.control.Rotate.prototype.handleClick_, this); var cssClasses = className + ' ' + ol.css.CLASS_UNSELECTABLE + ' ' + ol.css.CLASS_CONTROL; @@ -97,7 +97,7 @@ goog.inherits(ol.control.Rotate, ol.control.Control); /** - * @param {goog.events.BrowserEvent} event The event to handle + * @param {Event} event The event to handle * @private */ ol.control.Rotate.prototype.handleClick_ = function(event) { diff --git a/src/ol/control/scalelinecontrol.js b/src/ol/control/scalelinecontrol.js index d1d22e34ec..a5d0b3f650 100644 --- a/src/ol/control/scalelinecontrol.js +++ b/src/ol/control/scalelinecontrol.js @@ -4,7 +4,7 @@ goog.provide('ol.control.ScaleLineUnits'); goog.require('goog.asserts'); goog.require('goog.dom'); -goog.require('goog.events'); +goog.require('ol.events'); goog.require('goog.style'); goog.require('ol'); goog.require('ol.Object'); @@ -109,9 +109,9 @@ ol.control.ScaleLine = function(opt_options) { target: options.target }); - goog.events.listen( + ol.events.listen( this, ol.Object.getChangeEventType(ol.control.ScaleLineProperty.UNITS), - this.handleUnitsChanged_, false, this); + this.handleUnitsChanged_, this); this.setUnits(/** @type {ol.control.ScaleLineUnits} */ (options.units) || ol.control.ScaleLineUnits.METRIC); diff --git a/src/ol/control/zoomcontrol.js b/src/ol/control/zoomcontrol.js index 8dc740e447..d5418a3f85 100644 --- a/src/ol/control/zoomcontrol.js +++ b/src/ol/control/zoomcontrol.js @@ -1,8 +1,8 @@ goog.provide('ol.control.Zoom'); goog.require('goog.dom'); -goog.require('goog.events'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.EventType'); goog.require('ol.animation'); goog.require('ol.control.Control'); goog.require('ol.css'); @@ -42,9 +42,9 @@ ol.control.Zoom = function(opt_options) { 'title': zoomInTipLabel }, zoomInLabel); - goog.events.listen(inElement, - goog.events.EventType.CLICK, goog.partial( - ol.control.Zoom.prototype.handleClick_, delta), false, this); + ol.events.listen(inElement, + ol.events.EventType.CLICK, goog.partial( + ol.control.Zoom.prototype.handleClick_, delta), this); var outElement = goog.dom.createDom('BUTTON', { 'class': className + '-out', @@ -52,9 +52,9 @@ ol.control.Zoom = function(opt_options) { 'title': zoomOutTipLabel }, zoomOutLabel); - goog.events.listen(outElement, - goog.events.EventType.CLICK, goog.partial( - ol.control.Zoom.prototype.handleClick_, -delta), false, this); + ol.events.listen(outElement, + ol.events.EventType.CLICK, goog.partial( + ol.control.Zoom.prototype.handleClick_, -delta), this); var cssClasses = className + ' ' + ol.css.CLASS_UNSELECTABLE + ' ' + ol.css.CLASS_CONTROL; @@ -78,7 +78,7 @@ goog.inherits(ol.control.Zoom, ol.control.Control); /** * @param {number} delta Zoom delta. - * @param {goog.events.BrowserEvent} event The event to handle + * @param {Event} event The event to handle * @private */ ol.control.Zoom.prototype.handleClick_ = function(delta, event) { diff --git a/src/ol/control/zoomslidercontrol.js b/src/ol/control/zoomslidercontrol.js index cfc7a3f807..a68dc1a140 100644 --- a/src/ol/control/zoomslidercontrol.js +++ b/src/ol/control/zoomslidercontrol.js @@ -4,14 +4,12 @@ goog.provide('ol.control.ZoomSlider'); goog.require('goog.asserts'); goog.require('goog.dom'); -goog.require('goog.events'); -goog.require('goog.events.Event'); -goog.require('goog.events.EventType'); -goog.require('goog.fx.DragEvent'); -goog.require('goog.fx.Dragger'); -goog.require('goog.fx.Dragger.EventType'); goog.require('goog.math.Rect'); goog.require('goog.style'); +goog.require('ol.events'); +goog.require('ol.events.Event'); +goog.require('ol.events.EventType'); +goog.require('ol.pointer.PointerEventHandler'); goog.require('ol.Size'); goog.require('ol.ViewHint'); goog.require('ol.animation'); @@ -55,6 +53,30 @@ ol.control.ZoomSlider = function(opt_options) { */ this.direction_ = ol.control.ZoomSlider.direction.VERTICAL; + /** + * @type {boolean} + */ + this.dragging_; + /** + * @type {Array.} + */ + this.dragListenerKeys_; + + /** + * @type {goog.math.Rect} + */ + this.limits_; + + /** + * @type {number|undefined} + */ + this.previousX_; + + /** + * @type {number|undefined} + */ + this.previousY_; + /** * The calculated thumb size (border box plus margins). Set when initSlider_ * is called. @@ -85,24 +107,20 @@ ol.control.ZoomSlider = function(opt_options) { [className, ol.css.CLASS_UNSELECTABLE, ol.css.CLASS_CONTROL], thumbElement); - /** - * @type {goog.fx.Dragger} - * @private - */ - this.dragger_ = new goog.fx.Dragger(thumbElement); - this.registerDisposable(this.dragger_); + var dragger = new ol.pointer.PointerEventHandler(containerElement); + this.registerDisposable(dragger); - goog.events.listen(this.dragger_, goog.fx.Dragger.EventType.START, - this.handleDraggerStart_, false, this); - goog.events.listen(this.dragger_, goog.fx.Dragger.EventType.DRAG, - this.handleDraggerDrag_, false, this); - goog.events.listen(this.dragger_, goog.fx.Dragger.EventType.END, - this.handleDraggerEnd_, false, this); + ol.events.listen(dragger, ol.pointer.EventType.POINTERDOWN, + this.handleDraggerStart_, this); + ol.events.listen(dragger, ol.pointer.EventType.POINTERMOVE, + this.handleDraggerDrag_, this); + ol.events.listen(dragger, ol.pointer.EventType.POINTERUP, + this.handleDraggerEnd_, this); - goog.events.listen(containerElement, goog.events.EventType.CLICK, - this.handleContainerClick_, false, this); - goog.events.listen(thumbElement, goog.events.EventType.CLICK, - goog.events.Event.stopPropagation); + ol.events.listen(containerElement, ol.events.EventType.CLICK, + this.handleContainerClick_, this); + ol.events.listen(thumbElement, ol.events.EventType.CLICK, + ol.events.Event.stopPropagation); var render = options.render ? options.render : ol.control.ZoomSlider.render; @@ -167,7 +185,7 @@ ol.control.ZoomSlider.prototype.initSlider_ = function() { this.direction_ = ol.control.ZoomSlider.direction.VERTICAL; limits = new goog.math.Rect(0, 0, 0, height); } - this.dragger_.setLimits(limits); + this.limits_ = limits; this.sliderInitialized_ = true; }; @@ -196,10 +214,10 @@ ol.control.ZoomSlider.render = function(mapEvent) { /** - * @param {goog.events.BrowserEvent} browserEvent The browser event to handle. + * @param {Event} event The browser event to handle. * @private */ -ol.control.ZoomSlider.prototype.handleContainerClick_ = function(browserEvent) { +ol.control.ZoomSlider.prototype.handleContainerClick_ = function(event) { var map = this.getMap(); var view = map.getView(); var currentResolution = view.getResolution(); @@ -211,8 +229,8 @@ ol.control.ZoomSlider.prototype.handleContainerClick_ = function(browserEvent) { easing: ol.easing.easeOut })); var relativePosition = this.getRelativePosition_( - browserEvent.offsetX - this.thumbSize_[0] / 2, - browserEvent.offsetY - this.thumbSize_[1] / 2); + event.offsetX - this.thumbSize_[0] / 2, + event.offsetY - this.thumbSize_[1] / 2); var resolution = this.getResolutionForPosition_(relativePosition); view.setResolution(view.constrainResolution(resolution)); }; @@ -220,45 +238,79 @@ ol.control.ZoomSlider.prototype.handleContainerClick_ = function(browserEvent) { /** * Handle dragger start events. - * @param {goog.fx.DragEvent} event The drag event. + * @param {ol.pointer.PointerEvent} event The drag event. * @private */ ol.control.ZoomSlider.prototype.handleDraggerStart_ = function(event) { - this.getMap().getView().setHint(ol.ViewHint.INTERACTING, 1); + if (!this.dragging_ && + event.originalEvent.target === this.element.firstElementChild) { + this.getMap().getView().setHint(ol.ViewHint.INTERACTING, 1); + this.previousX_ = event.clientX; + this.previousY_ = event.clientY; + this.dragging_ = true; + + if (!this.dragListenerKeys_) { + var drag = this.handleDraggerDrag_; + var end = this.handleDraggerEnd_; + this.dragListenerKeys_ = [ + ol.events.listen(document, ol.events.EventType.MOUSEMOVE, drag, this), + ol.events.listen(document, ol.events.EventType.TOUCHMOVE, drag, this), + ol.events.listen(document, ol.pointer.EventType.POINTERMOVE, drag, this), + ol.events.listen(document, ol.events.EventType.MOUSEUP, end, this), + ol.events.listen(document, ol.events.EventType.TOUCHEND, end, this), + ol.events.listen(document, ol.pointer.EventType.POINTERUP, end, this) + ]; + } + } }; /** * Handle dragger drag events. * - * @param {goog.fx.DragEvent} event The drag event. + * @param {ol.pointer.PointerEvent|Event} event The drag event. * @private */ ol.control.ZoomSlider.prototype.handleDraggerDrag_ = function(event) { - var relativePosition = this.getRelativePosition_(event.left, event.top); - this.currentResolution_ = this.getResolutionForPosition_(relativePosition); - this.getMap().getView().setResolution(this.currentResolution_); + if (this.dragging_) { + var element = this.element.firstElementChild; + var deltaX = event.clientX - this.previousX_ + parseInt(element.style.left, 10); + var deltaY = event.clientY - this.previousY_ + parseInt(element.style.top, 10); + var relativePosition = this.getRelativePosition_(deltaX, deltaY); + this.currentResolution_ = this.getResolutionForPosition_(relativePosition); + this.getMap().getView().setResolution(this.currentResolution_); + this.setThumbPosition_(this.currentResolution_); + this.previousX_ = event.clientX; + this.previousY_ = event.clientY; + } }; /** * Handle dragger end events. - * @param {goog.fx.DragEvent} event The drag event. + * @param {ol.pointer.PointerEvent|Event} event The drag event. * @private */ ol.control.ZoomSlider.prototype.handleDraggerEnd_ = function(event) { - var map = this.getMap(); - var view = map.getView(); - view.setHint(ol.ViewHint.INTERACTING, -1); - goog.asserts.assert(this.currentResolution_, - 'this.currentResolution_ should be defined'); - map.beforeRender(ol.animation.zoom({ - resolution: this.currentResolution_, - duration: this.duration_, - easing: ol.easing.easeOut - })); - var resolution = view.constrainResolution(this.currentResolution_); - view.setResolution(resolution); + if (this.dragging_) { + var map = this.getMap(); + var view = map.getView(); + view.setHint(ol.ViewHint.INTERACTING, -1); + goog.asserts.assert(this.currentResolution_, + 'this.currentResolution_ should be defined'); + map.beforeRender(ol.animation.zoom({ + resolution: this.currentResolution_, + duration: this.duration_, + easing: ol.easing.easeOut + })); + var resolution = view.constrainResolution(this.currentResolution_); + view.setResolution(resolution); + this.dragging_ = false; + this.previousX_ = undefined; + this.previousY_ = undefined; + this.dragListenerKeys_.forEach(ol.events.unlistenByKey); + this.dragListenerKeys_ = null; + } }; @@ -270,15 +322,14 @@ ol.control.ZoomSlider.prototype.handleDraggerEnd_ = function(event) { */ ol.control.ZoomSlider.prototype.setThumbPosition_ = function(res) { var position = this.getPositionForResolution_(res); - var dragger = this.dragger_; var thumb = goog.dom.getFirstElementChild(this.element); if (this.direction_ == ol.control.ZoomSlider.direction.HORIZONTAL) { - var left = dragger.limits.left + dragger.limits.width * position; + var left = this.limits_.left + this.limits_.width * position; goog.style.setPosition(thumb, left); } else { - var top = dragger.limits.top + dragger.limits.height * position; - goog.style.setPosition(thumb, dragger.limits.left, top); + var top = this.limits_.top + this.limits_.height * position; + goog.style.setPosition(thumb, this.limits_.left, top); } }; @@ -294,7 +345,7 @@ ol.control.ZoomSlider.prototype.setThumbPosition_ = function(res) { * @private */ ol.control.ZoomSlider.prototype.getRelativePosition_ = function(x, y) { - var draggerLimits = this.dragger_.limits; + var draggerLimits = this.limits_; var amount; if (this.direction_ === ol.control.ZoomSlider.direction.HORIZONTAL) { amount = (x - draggerLimits.left) / draggerLimits.width; diff --git a/src/ol/control/zoomtoextentcontrol.js b/src/ol/control/zoomtoextentcontrol.js index 90758326da..f9b5f8f0e1 100644 --- a/src/ol/control/zoomtoextentcontrol.js +++ b/src/ol/control/zoomtoextentcontrol.js @@ -2,8 +2,8 @@ goog.provide('ol.control.ZoomToExtent'); goog.require('goog.asserts'); goog.require('goog.dom'); -goog.require('goog.events'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.EventType'); goog.require('ol.control.Control'); goog.require('ol.css'); @@ -38,8 +38,8 @@ ol.control.ZoomToExtent = function(opt_options) { 'title': tipLabel }, label); - goog.events.listen(button, goog.events.EventType.CLICK, - this.handleClick_, false, this); + ol.events.listen(button, ol.events.EventType.CLICK, + this.handleClick_, this); var cssClasses = className + ' ' + ol.css.CLASS_UNSELECTABLE + ' ' + ol.css.CLASS_CONTROL; @@ -54,7 +54,7 @@ goog.inherits(ol.control.ZoomToExtent, ol.control.Control); /** - * @param {goog.events.BrowserEvent} event The event to handle + * @param {Event} event The event to handle * @private */ ol.control.ZoomToExtent.prototype.handleClick_ = function(event) { diff --git a/src/ol/deviceorientation.js b/src/ol/deviceorientation.js index 1be3f7ac34..faa1e92d1a 100644 --- a/src/ol/deviceorientation.js +++ b/src/ol/deviceorientation.js @@ -1,7 +1,7 @@ goog.provide('ol.DeviceOrientation'); goog.provide('ol.DeviceOrientationProperty'); -goog.require('goog.events'); +goog.require('ol.events'); goog.require('ol'); goog.require('ol.Object'); goog.require('ol.has'); @@ -83,13 +83,13 @@ ol.DeviceOrientation = function(opt_options) { /** * @private - * @type {goog.events.Key} + * @type {?ol.events.Key} */ this.listenerKey_ = null; - goog.events.listen(this, + ol.events.listen(this, ol.Object.getChangeEventType(ol.DeviceOrientationProperty.TRACKING), - this.handleTrackingChanged_, false, this); + this.handleTrackingChanged_, this); this.setTracking(options.tracking !== undefined ? options.tracking : false); @@ -108,11 +108,10 @@ ol.DeviceOrientation.prototype.disposeInternal = function() { /** * @private - * @param {goog.events.BrowserEvent} browserEvent Event. + * @param {Event} originalEvent Event. */ -ol.DeviceOrientation.prototype.orientationChange_ = function(browserEvent) { - var event = /** @type {DeviceOrientationEvent} */ - (browserEvent.getBrowserEvent()); +ol.DeviceOrientation.prototype.orientationChange_ = function(originalEvent) { + var event = /** @type {DeviceOrientationEvent} */ (originalEvent); if (event.alpha !== null) { var alpha = ol.math.toRadians(event.alpha); this.set(ol.DeviceOrientationProperty.ALPHA, alpha); @@ -208,10 +207,10 @@ ol.DeviceOrientation.prototype.handleTrackingChanged_ = function() { if (ol.has.DEVICE_ORIENTATION) { var tracking = this.getTracking(); if (tracking && !this.listenerKey_) { - this.listenerKey_ = goog.events.listen(goog.global, 'deviceorientation', - this.orientationChange_, false, this); - } else if (!tracking && this.listenerKey_) { - goog.events.unlistenByKey(this.listenerKey_); + this.listenerKey_ = ol.events.listen(goog.global, 'deviceorientation', + this.orientationChange_, this); + } else if (!tracking && this.listenerKey_ !== null) { + ol.events.unlistenByKey(this.listenerKey_); this.listenerKey_ = null; } } diff --git a/src/ol/events.js b/src/ol/events.js new file mode 100644 index 0000000000..0b01ff656e --- /dev/null +++ b/src/ol/events.js @@ -0,0 +1,338 @@ +goog.provide('ol.events'); +goog.provide('ol.events.EventType'); +goog.provide('ol.events.KeyCode'); + +goog.require('goog.object'); + + +/** + * @enum {string} + * @const + */ +ol.events.EventType = { + /** + * Generic change event. + * @event ol.events.Event#change + * @api + */ + CHANGE: 'change', + + CLICK: 'click', + DBLCLICK: 'dblclick', + DRAGENTER: 'dragenter', + DRAGOVER: 'dragover', + DROP: 'drop', + ERROR: 'error', + KEYDOWN: 'keydown', + KEYPRESS: 'keypress', + LOAD: 'load', + MOUSEDOWN: 'mousedown', + MOUSEMOVE: 'mousemove', + MOUSEOUT: 'mouseout', + MOUSEUP: 'mouseup', + MOUSEWHEEL: 'mousewheel', + MSPOINTERDOWN: 'mspointerdown', + RESIZE: 'resize', + TOUCHSTART: 'touchstart', + TOUCHMOVE: 'touchmove', + TOUCHEND: 'touchend', + WHEEL: 'wheel' +}; + + +/** + * @enum {number} + * @const + */ +ol.events.KeyCode = { + LEFT: 37, + UP: 38, + RIGHT: 39, + DOWN: 40 +}; + + +/** + * Property name on an event target for the listener map associated with the + * event target. + * @const {string} + * @private + */ +ol.events.LISTENER_MAP_PROP_ = 'olm_' + ((Math.random() * 1e4) | 0); + + +/** + * @typedef {EventTarget|ol.events.EventTarget| + * {addEventListener: function(string, Function, boolean=), + * removeEventListener: function(string, Function, boolean=), + * dispatchEvent: function(string)}} + */ +ol.events.EventTargetLike; + + +/** + * Key to use with {@link ol.Observable#unByKey}. + * + * @typedef {ol.events.ListenerObjType} + * @api + */ +ol.events.Key; + + +/** + * Listener function. This function is called with an event object as argument. + * When the function returns `false`, event propagation will stop. + * + * @typedef {function(ol.events.Event)|function(ol.events.Event): boolean} + * @api + */ +ol.events.ListenerFunctionType; + + +/** + * @typedef {{bindTo: (Object|undefined), + * boundListener: (ol.events.ListenerFunctionType|undefined), + * callOnce: boolean, + * deleteIndex: (number|undefined), + * listener: ol.events.ListenerFunctionType, + * target: (EventTarget|ol.events.EventTarget), + * type: string}} + */ +ol.events.ListenerObjType; + + +/** + * @param {ol.events.ListenerObjType} listenerObj Listener object. + * @return {ol.events.ListenerFunctionType} Bound listener. + */ +ol.events.bindListener_ = function(listenerObj) { + var boundListener = function(evt) { + var rv = listenerObj.listener.call(listenerObj.bindTo, evt); + if (listenerObj.callOnce) { + ol.events.unlistenByKey(listenerObj); + } + return rv; + } + listenerObj.boundListener = boundListener; + return boundListener; +}; + + +/** + * Finds the matching {@link ol.events.ListenerObjType} in the given listener + * array. + * + * @param {!Array} listeners Array of listeners. + * @param {!Function} listener The listener function. + * @param {Object=} opt_this The `this` value inside the listener. + * @param {boolean=} opt_setDeleteIndex Set the deleteIndex on the matching + * listener, for {@link ol.events.unlistenByKey}. + * @return {ol.events.ListenerObjType|undefined} The matching listener object. + * @private + */ +ol.events.findListener_ = function(listeners, listener, opt_this, + opt_setDeleteIndex) { + var listenerObj; + for (var i = 0, ii = listeners.length; i < ii; ++i) { + listenerObj = listeners[i]; + if (listenerObj.listener === listener && + listenerObj.bindTo === opt_this) { + if (opt_setDeleteIndex) { + listenerObj.deleteIndex = i; + } + return listenerObj; + } + } + return undefined; +}; + + +/** + * @param {ol.events.EventTargetLike} target Target. + * @param {string} type Type. + * @return {Array.|undefined} Listeners. + */ +ol.events.getListeners = function(target, type) { + var listenerMap = target[ol.events.LISTENER_MAP_PROP_]; + return listenerMap ? listenerMap[type] : undefined; +}; + + +/** + * Get the lookup of listeners. If one does not exist on the target, it is + * created. + * @param {ol.events.EventTargetLike} target Target. + * @return {!Object.>} Map of + * listeners by event type. + * @private + */ +ol.events.getListenerMap_ = function(target) { + var listenerMap = target[ol.events.LISTENER_MAP_PROP_]; + if (!listenerMap) { + listenerMap = target[ol.events.LISTENER_MAP_PROP_] = {}; + } + return listenerMap; +}; + + +/** + * Clean up all listener objects of the given type. All properties on the + * listener objects will be removed, and if no listeners remain in the listener + * map, it will be removed from the target. + * @param {ol.events.EventTargetLike} target Target. + * @param {string} type Type. + * @private + */ +ol.events.removeListeners_ = function(target, type) { + var listeners = ol.events.getListeners(target, type); + if (listeners) { + for (var i = 0, ii = listeners.length; i < ii; ++i) { + target.removeEventListener(type, listeners[i].boundListener); + goog.object.clear(listeners[i]) + } + listeners.length = 0; + var listenerMap = target[ol.events.LISTENER_MAP_PROP_]; + if (listenerMap) { + delete listenerMap[type]; + if (Object.keys(listenerMap).length === 0) { + delete target[ol.events.LISTENER_MAP_PROP_]; + } + } + } +}; + + +/** + * Registers an event listener on an event target. Inspired by + * {@link https://google.github.io/closure-library/api/source/closure/goog/events/events.js.src.html} + * + * This function efficiently binds a `listener` to a `this` object, and returns + * a key for use with {@link ol.events.unlistenByKey}. + * + * @param {ol.events.EventTargetLike} target Event target. + * @param {string} type Event type. + * @param {ol.events.ListenerFunctionType} listener Listener. + * @param {Object=} opt_this Object referenced by the `this` keyword in the + * listener. Default is the `target`. + * @param {boolean=} opt_once If true, add the listener as one-off listener. + * @return {ol.events.Key} Unique key for the listener. + */ +ol.events.listen = function(target, type, listener, opt_this, opt_once) { + var listenerMap = ol.events.getListenerMap_(target); + var listeners = listenerMap[type]; + if (!listeners) { + listeners = listenerMap[type] = []; + } + var listenerObj = ol.events.findListener_(listeners, listener, opt_this, + false); + if (listenerObj) { + if (!opt_once) { + // Turn one-off listener into a permanent one. + listenerObj.callOnce = false; + } + } else { + listenerObj = /** @type {ol.events.ListenerObjType} */ ({ + bindTo: opt_this, + callOnce: !!opt_once, + listener: listener, + target: target, + type: type + }); + target.addEventListener(type, ol.events.bindListener_(listenerObj)); + listeners.push(listenerObj); + } + + return listenerObj; +}; + + +/** + * Registers a one-off event listener on an event target. Inspired by + * {@link https://google.github.io/closure-library/api/source/closure/goog/events/events.js.src.html} + * + * This function efficiently binds a `listener` as self-unregistering listener + * to a `this` object, and returns a key for use with + * {@link ol.events.unlistenByKey} in case the listener needs to be unregistered + * before it is called. + * + * When {@link ol.events.listen} is called with the same arguments after this + * function, the self-unregistering listener will be turned into a permanent + * listener. + * + * @param {ol.events.EventTargetLike} target Event target. + * @param {string} type Event type. + * @param {ol.events.ListenerFunctionType} listener Listener. + * @param {Object=} opt_this Object referenced by the `this` keyword in the + * listener. Default is the `target`. + * @return {ol.events.Key} Key for unlistenByKey. + */ +ol.events.listenOnce = function( + target, type, listener, opt_this) { + return ol.events.listen(target, type, listener, opt_this, true); +}; + + +/** + * Unregisters an event listener on an event target. Inspired by + * {@link https://google.github.io/closure-library/api/source/closure/goog/events/events.js.src.html} + * + * To return a listener, this function needs to be called with the exact same + * arguments that were used for a previous {@link ol.events.listen} call. + * + * @param {ol.events.EventTargetLike} target Event target. + * @param {string} type Event type. + * @param {ol.events.ListenerFunctionType} listener Listener. + * @param {Object=} opt_this Object referenced by the `this` keyword in the + * listener. Default is the `target`. + */ +ol.events.unlisten = function(target, type, listener, opt_this) { + var listeners = ol.events.getListeners(target, type); + if (listeners) { + var listenerObj = ol.events.findListener_(listeners, listener, opt_this, + true); + if (listenerObj) { + ol.events.unlistenByKey(listenerObj); + } + } +}; + + +/** + * Unregisters event listeners on an event target. Inspired by + * {@link https://google.github.io/closure-library/api/source/closure/goog/events/events.js.src.html} + * + * The argument passed to this function is the key returned from + * {@link ol.events.listen} or {@link ol.events.listenOnce}. + * + * @param {ol.events.Key} key The key. + */ +ol.events.unlistenByKey = function(key) { + if (key && key.target) { + key.target.removeEventListener(key.type, key.boundListener); + var listeners = ol.events.getListeners(key.target, key.type); + if (listeners) { + var i = 'deleteIndex' in key ? key.deleteIndex : listeners.indexOf(key); + if (i !== -1) { + listeners.splice(i, 1); + } + if (listeners.length === 0) { + ol.events.removeListeners_(key.target, key.type); + } + } + goog.object.clear(key); + } +}; + + +/** + * Unregisters all event listeners on an event target. Inspired by + * {@link https://google.github.io/closure-library/api/source/closure/goog/events/events.js.src.html} + * + * @param {ol.events.EventTargetLike} target Target. + */ +ol.events.unlistenAll = function(target) { + var listenerMap = ol.events.getListenerMap_(target); + for (var type in listenerMap) { + ol.events.removeListeners_(target, type); + } +}; diff --git a/src/ol/events/condition.js b/src/ol/events/condition.js index 51a17385ef..d6fba5543d 100644 --- a/src/ol/events/condition.js +++ b/src/ol/events/condition.js @@ -26,11 +26,11 @@ ol.events.ConditionType; * @api stable */ ol.events.condition.altKeyOnly = function(mapBrowserEvent) { - var browserEvent = mapBrowserEvent.browserEvent; + var originalEvent = mapBrowserEvent.originalEvent; return ( - browserEvent.altKey && - !browserEvent.platformModifierKey && - !browserEvent.shiftKey); + originalEvent.altKey && + !(originalEvent.metaKey || originalEvent.ctrlKey) && + !originalEvent.shiftKey); }; @@ -43,11 +43,11 @@ ol.events.condition.altKeyOnly = function(mapBrowserEvent) { * @api stable */ ol.events.condition.altShiftKeysOnly = function(mapBrowserEvent) { - var browserEvent = mapBrowserEvent.browserEvent; + var originalEvent = mapBrowserEvent.originalEvent; return ( - browserEvent.altKey && - !browserEvent.platformModifierKey && - browserEvent.shiftKey); + originalEvent.altKey && + !(originalEvent.metaKey || originalEvent.ctrlKey) && + originalEvent.shiftKey); }; @@ -74,6 +74,22 @@ ol.events.condition.click = function(mapBrowserEvent) { }; +/** + * Return `true` if the event has an "action"-producing mouse button. + * + * By definition, this includes left-click on windows/linux, and left-click + * without the ctrl key on Macs. + * + * @param {ol.MapBrowserEvent} mapBrowserEvent Map browser event. + * @return {boolean} The result. + */ +ol.events.condition.mouseActionButton = function(mapBrowserEvent) { + var originalEvent = mapBrowserEvent.originalEvent; + return originalEvent.button == 0 && + !(goog.userAgent.WEBKIT && ol.has.MAC && originalEvent.ctrlKey); +}; + + /** * Return always false. * @@ -131,11 +147,11 @@ ol.events.condition.doubleClick = function(mapBrowserEvent) { * @api stable */ ol.events.condition.noModifierKeys = function(mapBrowserEvent) { - var browserEvent = mapBrowserEvent.browserEvent; + var originalEvent = mapBrowserEvent.originalEvent; return ( - !browserEvent.altKey && - !browserEvent.platformModifierKey && - !browserEvent.shiftKey); + !originalEvent.altKey && + !(originalEvent.metaKey || originalEvent.ctrlKey) && + !originalEvent.shiftKey); }; @@ -149,11 +165,11 @@ ol.events.condition.noModifierKeys = function(mapBrowserEvent) { * @api stable */ ol.events.condition.platformModifierKeyOnly = function(mapBrowserEvent) { - var browserEvent = mapBrowserEvent.browserEvent; + var originalEvent = mapBrowserEvent.originalEvent; return ( - !browserEvent.altKey && - browserEvent.platformModifierKey && - !browserEvent.shiftKey); + !originalEvent.altKey && + (ol.has.MAC ? originalEvent.metaKey : originalEvent.ctrlKey) && + !originalEvent.shiftKey); }; @@ -166,11 +182,11 @@ ol.events.condition.platformModifierKeyOnly = function(mapBrowserEvent) { * @api stable */ ol.events.condition.shiftKeyOnly = function(mapBrowserEvent) { - var browserEvent = mapBrowserEvent.browserEvent; + var originalEvent = mapBrowserEvent.originalEvent; return ( - !browserEvent.altKey && - !browserEvent.platformModifierKey && - browserEvent.shiftKey); + !originalEvent.altKey && + !(originalEvent.metaKey || originalEvent.ctrlKey) && + originalEvent.shiftKey); }; @@ -183,7 +199,7 @@ ol.events.condition.shiftKeyOnly = function(mapBrowserEvent) { * @api */ ol.events.condition.targetNotEditable = function(mapBrowserEvent) { - var target = mapBrowserEvent.browserEvent.target; + var target = mapBrowserEvent.originalEvent.target; goog.asserts.assertInstanceof(target, Element, 'target should be an Element'); var tagName = target.tagName; diff --git a/src/ol/events/event.js b/src/ol/events/event.js new file mode 100644 index 0000000000..84cf18c82c --- /dev/null +++ b/src/ol/events/event.js @@ -0,0 +1,60 @@ +goog.provide('ol.events.Event'); + + +/** + * @classdesc + * Stripped down implementation of the W3C DOM Level 2 Event interface. + * @see {@link https://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-interface} + * + * This implementation only provides `type` and `target` properties, and + * `stopPropagation` and `preventDefault` methods. It is meant as base class + * for higher level events defined in the library, and works with + * {@link ol.events.EventTarget}. + * + * @constructor + * @param {string} type Type. + * @param {Object=} opt_target Target. + */ +ol.events.Event = function(type, opt_target) { + + /** + * @type {boolean} + */ + this.propagationStopped; + + /** + * @type {string} + */ + this.type = type; + + /** + * @type {Object|undefined} + */ + this.target = opt_target; + +}; + + +/** + * Stop event propagation + */ +ol.events.Event.prototype.preventDefault = +ol.events.Event.prototype.stopPropagation = function() { + this.propagationStopped = true; +}; + + +/** + * @param {Event|ol.events.Event} evt Event + */ +ol.events.Event.stopPropagation = function(evt) { + evt.stopPropagation(); +}; + + +/** + * @param {Event|ol.events.Event} evt Event + */ +ol.events.Event.preventDefault = function(evt) { + evt.preventDefault(); +}; diff --git a/src/ol/events/eventtarget.js b/src/ol/events/eventtarget.js new file mode 100644 index 0000000000..3f7b6fcb36 --- /dev/null +++ b/src/ol/events/eventtarget.js @@ -0,0 +1,123 @@ +goog.provide('ol.events.EventTarget'); + +goog.require('goog.Disposable'); +goog.require('ol.events'); +goog.require('ol.events.Event'); + +/** + * @classdesc + * A simplified implementation of the W3C DOM Level 2 EventTarget interface. + * @see {@link https://www.w3.org/TR/2000/REC-DOM-Level-2-Events-20001113/events.html#Events-EventTarget} + * + * There are two important simplifications compared to the specification: + * + * 1. The handling of `useCapture` in `addEventListener` and + * `removeEventListener`. There is no real capture model. + * 2. The handling of `stopPropagation` and `preventDefault` on `dispatchEvent`. + * There is no event target hierarchy. When a listener calls + * `stopPropagation` or `preventDefault` on an event object, it means that no + * more listeners after this one will be called. Same as when the listener + * returns false. + * + * @constructor + * @extends {goog.Disposable} + */ +ol.events.EventTarget = function() { + + goog.base(this); + + /** + * @private + * @type {!Object.>} + */ + this.listeners_ = {}; + +}; +goog.inherits(ol.events.EventTarget, goog.Disposable); + + +/** + * @param {string} type Type. + * @param {ol.events.ListenerFunctionType} listener Listener. + */ +ol.events.EventTarget.prototype.addEventListener = function(type, listener) { + var listeners = this.listeners_[type]; + if (!listeners) { + listeners = this.listeners_[type] = []; + } + if (listeners.indexOf(listener) === -1) { + listeners.unshift(listener); + } +}; + + +/** + * @param {{type: string, + * target: (EventTarget|ol.events.EventTarget|undefined)}|ol.events.Event| + * string} event Event or event type. + * @return {boolean|undefined} `false` if anyone called preventDefault on the + * event object or if any of the listeners returned false. + */ +ol.events.EventTarget.prototype.dispatchEvent = function(event) { + var evt = goog.isString(event) ? new ol.events.Event(event) : event; + var type = evt.type; + evt.target = this; + var listeners = this.listeners_[type]; + if (listeners) { + for (var i = listeners.length - 1; i >= 0; --i) { + if (listeners[i].call(this, evt) === false || + evt.propagationStopped) { + return false; + } + } + } +}; + + +/** + * @inheritDoc + */ +ol.events.EventTarget.prototype.disposeInternal = function() { + ol.events.unlistenAll(this); + goog.base(this, 'disposeInternal'); +}; + + +/** + * Get the listeners for a specified event type. Listeners are returned in the + * opposite order that they will be called in. + * + * @param {string} type Type. + * @return {Array.} Listeners. + */ +ol.events.EventTarget.prototype.getListeners = function(type) { + return this.listeners_[type]; +}; + + +/** + * @param {string=} opt_type Type. If not provided, + * `true` will be returned if this EventTarget has any listeners. + * @return {boolean} Has listeners. + */ +ol.events.EventTarget.prototype.hasListener = function(opt_type) { + return opt_type ? + opt_type in this.listeners_ : + Object.keys(this.listeners_).length > 0; +}; + + +/** + * @param {string} type Type. + * @param {ol.events.ListenerFunctionType} listener Listener. + */ +ol.events.EventTarget.prototype.removeEventListener = function(type, listener) { + var listeners = this.listeners_[type]; + if (listeners) { + var index = listeners.indexOf(listener); + listeners.splice(index, 1); + if (listeners.length === 0) { + delete this.listeners_[type]; + } + } +}; diff --git a/src/ol/feature.js b/src/ol/feature.js index 3ef0523f5e..a99ff3747d 100644 --- a/src/ol/feature.js +++ b/src/ol/feature.js @@ -2,8 +2,8 @@ goog.provide('ol.Feature'); goog.provide('ol.FeatureStyleFunction'); goog.require('goog.asserts'); -goog.require('goog.events'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.EventType'); goog.require('ol'); goog.require('ol.Object'); goog.require('ol.geom.Geometry'); @@ -87,13 +87,13 @@ ol.Feature = function(opt_geometryOrProperties) { /** * @private - * @type {goog.events.Key} + * @type {?ol.events.Key} */ this.geometryChangeKey_ = null; - goog.events.listen( + ol.events.listen( this, ol.Object.getChangeEventType(this.geometryName_), - this.handleGeometryChanged_, false, this); + this.handleGeometryChanged_, this); if (opt_geometryOrProperties !== undefined) { if (opt_geometryOrProperties instanceof ol.geom.Geometry || @@ -209,13 +209,13 @@ ol.Feature.prototype.handleGeometryChange_ = function() { */ ol.Feature.prototype.handleGeometryChanged_ = function() { if (this.geometryChangeKey_) { - goog.events.unlistenByKey(this.geometryChangeKey_); + ol.events.unlistenByKey(this.geometryChangeKey_); this.geometryChangeKey_ = null; } var geometry = this.getGeometry(); if (geometry) { - this.geometryChangeKey_ = goog.events.listen(geometry, - goog.events.EventType.CHANGE, this.handleGeometryChange_, false, this); + this.geometryChangeKey_ = ol.events.listen(geometry, + ol.events.EventType.CHANGE, this.handleGeometryChange_, this); } this.changed(); }; @@ -273,13 +273,13 @@ ol.Feature.prototype.setId = function(id) { * @api stable */ ol.Feature.prototype.setGeometryName = function(name) { - goog.events.unlisten( + ol.events.unlisten( this, ol.Object.getChangeEventType(this.geometryName_), - this.handleGeometryChanged_, false, this); + this.handleGeometryChanged_, this); this.geometryName_ = name; - goog.events.listen( + ol.events.listen( this, ol.Object.getChangeEventType(this.geometryName_), - this.handleGeometryChanged_, false, this); + this.handleGeometryChanged_, this); this.handleGeometryChanged_(); }; diff --git a/src/ol/featureloader.js b/src/ol/featureloader.js index 247bc5c5b7..08fc907d77 100644 --- a/src/ol/featureloader.js +++ b/src/ol/featureloader.js @@ -3,10 +3,6 @@ goog.provide('ol.FeatureUrlFunction'); goog.provide('ol.featureloader'); goog.require('goog.asserts'); -goog.require('goog.events'); -goog.require('goog.net.EventType'); -goog.require('goog.net.XhrIo'); -goog.require('goog.net.XhrIo.ResponseType'); goog.require('ol.TileState'); goog.require('ol.VectorTile'); goog.require('ol.format.FormatType'); @@ -67,59 +63,47 @@ ol.featureloader.loadFeaturesXhr = function(url, format, success, failure) { * @this {ol.source.Vector|ol.VectorTile} */ function(extent, resolution, projection) { - var xhrIo = new goog.net.XhrIo(); - xhrIo.setResponseType( - format.getType() == ol.format.FormatType.ARRAY_BUFFER ? - goog.net.XhrIo.ResponseType.ARRAY_BUFFER : - goog.net.XhrIo.ResponseType.TEXT); - goog.events.listen(xhrIo, goog.net.EventType.COMPLETE, - /** - * @param {Event} event Event. - * @private - * @this {ol.source.Vector} - */ - function(event) { - var xhrIo = event.target; - goog.asserts.assertInstanceof(xhrIo, goog.net.XhrIo, - 'event.target/xhrIo is an instance of goog.net.XhrIo'); - if (xhrIo.isSuccess()) { - var type = format.getType(); - /** @type {Document|Node|Object|string|undefined} */ - var source; - if (type == ol.format.FormatType.JSON) { - source = xhrIo.getResponseText(); - } else if (type == ol.format.FormatType.TEXT) { - source = xhrIo.getResponseText(); - } else if (type == ol.format.FormatType.XML) { - if (!goog.userAgent.IE) { - source = xhrIo.getResponseXml(); - } - if (!source) { - source = ol.xml.parse(xhrIo.getResponseText()); - } - } else if (type == ol.format.FormatType.ARRAY_BUFFER) { - source = xhrIo.getResponse(); - } else { - goog.asserts.fail('unexpected format type'); - } - if (source) { - success.call(this, format.readFeatures(source, - {featureProjection: projection}), - format.readProjection(source)); - } else { - goog.asserts.fail('undefined or null source'); - } - } else { - failure.call(this); - } - goog.dispose(xhrIo); - }, false, this); - if (goog.isFunction(url)) { - xhrIo.send(url(extent, resolution, projection)); - } else { - xhrIo.send(url); + var xhr = new XMLHttpRequest(); + xhr.open('GET', + goog.isFunction(url) ? url(extent, resolution, projection) : url, + true); + if (format.getType() == ol.format.FormatType.ARRAY_BUFFER) { + xhr.responseType = 'arraybuffer'; } - + /** + * @param {Event} event Event. + * @private + */ + xhr.onload = function(event) { + if (xhr.status >= 200 && xhr.status < 300) { + var type = format.getType(); + /** @type {Document|Node|Object|string|undefined} */ + var source; + if (type == ol.format.FormatType.JSON || + type == ol.format.FormatType.TEXT) { + source = /** @type {string} */ (xhr.responseText); + } else if (type == ol.format.FormatType.XML) { + source = xhr.responseXML; + if (!source) { + source = ol.xml.parse(xhr.responseText); + } + } else if (type == ol.format.FormatType.ARRAY_BUFFER) { + source = /** @type {ArrayBuffer} */ (xhr.response); + } else { + goog.asserts.fail('unexpected format type'); + } + if (source) { + success.call(this, format.readFeatures(source, + {featureProjection: projection}), + format.readProjection(source)); + } else { + goog.asserts.fail('undefined or null source'); + } + } else { + failure.call(this); + } + }.bind(this); + xhr.send(); }); }; diff --git a/src/ol/geolocation.js b/src/ol/geolocation.js index 13c6e8f11f..325d973207 100644 --- a/src/ol/geolocation.js +++ b/src/ol/geolocation.js @@ -3,8 +3,8 @@ goog.provide('ol.Geolocation'); goog.provide('ol.GeolocationProperty'); -goog.require('goog.events'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.EventType'); goog.require('ol.Coordinate'); goog.require('ol.Object'); goog.require('ol.geom.Geometry'); @@ -83,12 +83,12 @@ ol.Geolocation = function(opt_options) { */ this.watchId_ = undefined; - goog.events.listen( + ol.events.listen( this, ol.Object.getChangeEventType(ol.GeolocationProperty.PROJECTION), - this.handleProjectionChanged_, false, this); - goog.events.listen( + this.handleProjectionChanged_, this); + ol.events.listen( this, ol.Object.getChangeEventType(ol.GeolocationProperty.TRACKING), - this.handleTrackingChanged_, false, this); + this.handleTrackingChanged_, this); if (options.projection !== undefined) { this.setProjection(ol.proj.get(options.projection)); @@ -189,9 +189,9 @@ ol.Geolocation.prototype.positionChange_ = function(position) { * @param {GeolocationPositionError} error error object. */ ol.Geolocation.prototype.positionError_ = function(error) { - error.type = goog.events.EventType.ERROR; + error.type = ol.events.EventType.ERROR; this.setTracking(false); - this.dispatchEvent(error); + this.dispatchEvent(/** @type {{type: string}} */ (error)); }; diff --git a/src/ol/geom/geometrycollection.js b/src/ol/geom/geometrycollection.js index 68a24133a0..02063c551b 100644 --- a/src/ol/geom/geometrycollection.js +++ b/src/ol/geom/geometrycollection.js @@ -1,7 +1,7 @@ goog.provide('ol.geom.GeometryCollection'); -goog.require('goog.events'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.EventType'); goog.require('goog.object'); goog.require('ol.extent'); goog.require('ol.geom.Geometry'); @@ -56,9 +56,9 @@ ol.geom.GeometryCollection.prototype.unlistenGeometriesChange_ = function() { return; } for (i = 0, ii = this.geometries_.length; i < ii; ++i) { - goog.events.unlisten( - this.geometries_[i], goog.events.EventType.CHANGE, - this.changed, false, this); + ol.events.unlisten( + this.geometries_[i], ol.events.EventType.CHANGE, + this.changed, this); } }; @@ -72,9 +72,9 @@ ol.geom.GeometryCollection.prototype.listenGeometriesChange_ = function() { return; } for (i = 0, ii = this.geometries_.length; i < ii; ++i) { - goog.events.listen( - this.geometries_[i], goog.events.EventType.CHANGE, - this.changed, false, this); + ol.events.listen( + this.geometries_[i], ol.events.EventType.CHANGE, + this.changed, this); } }; diff --git a/src/ol/has.js b/src/ol/has.js index 91fe1c07b0..95e407052c 100644 --- a/src/ol/has.js +++ b/src/ol/has.js @@ -5,6 +5,28 @@ goog.require('ol.dom'); goog.require('ol.webgl'); +var ua = typeof navigator !== 'undefined' ? + navigator.userAgent.toLowerCase() : ''; + +/** + * User agent string says we are dealing with Firefox as browser. + * @type {boolean} + */ +ol.has.FIREFOX = ua.indexOf('firefox') !== -1; + +/** + * User agent string says we are dealing with Safari as browser. + * @type {boolean} + */ +ol.has.SAFARI = ua.indexOf('safari') !== -1 && ua.indexOf('chrom') === -1; + +/** + * User agent string says we are dealing with a Mac as platform. + * @type {boolean} + */ +ol.has.MAC = ua.indexOf('Macintosh') !== -1; + + /** * The ratio between physical pixels and device-independent pixels * (dips) on the device (`window.devicePixelRatio`). diff --git a/src/ol/image.js b/src/ol/image.js index 5dbab13edb..36d1036e03 100644 --- a/src/ol/image.js +++ b/src/ol/image.js @@ -1,8 +1,8 @@ goog.provide('ol.Image'); goog.require('goog.asserts'); -goog.require('goog.events'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.EventType'); goog.require('goog.object'); goog.require('ol.ImageBase'); goog.require('ol.ImageState'); @@ -49,7 +49,7 @@ ol.Image = function(extent, resolution, pixelRatio, attributions, src, /** * @private - * @type {Array.} + * @type {Array.} */ this.imageListenerKeys_ = null; @@ -131,10 +131,10 @@ ol.Image.prototype.load = function() { goog.asserts.assert(!this.imageListenerKeys_, 'this.imageListenerKeys_ should be null'); this.imageListenerKeys_ = [ - goog.events.listenOnce(this.image_, goog.events.EventType.ERROR, - this.handleImageError_, false, this), - goog.events.listenOnce(this.image_, goog.events.EventType.LOAD, - this.handleImageLoad_, false, this) + ol.events.listenOnce(this.image_, ol.events.EventType.ERROR, + this.handleImageError_, this), + ol.events.listenOnce(this.image_, ol.events.EventType.LOAD, + this.handleImageLoad_, this) ]; this.imageLoadFunction_(this, this.src_); } @@ -157,6 +157,6 @@ ol.Image.prototype.setImage = function(image) { ol.Image.prototype.unlistenImage_ = function() { goog.asserts.assert(this.imageListenerKeys_, 'this.imageListenerKeys_ should not be null'); - this.imageListenerKeys_.forEach(goog.events.unlistenByKey); + this.imageListenerKeys_.forEach(ol.events.unlistenByKey); this.imageListenerKeys_ = null; }; diff --git a/src/ol/imagebase.js b/src/ol/imagebase.js index 25c922b355..f30e9ef364 100644 --- a/src/ol/imagebase.js +++ b/src/ol/imagebase.js @@ -2,8 +2,8 @@ goog.provide('ol.ImageBase'); goog.provide('ol.ImageState'); goog.require('goog.asserts'); -goog.require('goog.events.EventTarget'); -goog.require('goog.events.EventType'); +goog.require('ol.events.EventTarget'); +goog.require('ol.events.EventType'); goog.require('ol.Attribution'); goog.require('ol.Extent'); @@ -21,7 +21,7 @@ ol.ImageState = { /** * @constructor - * @extends {goog.events.EventTarget} + * @extends {ol.events.EventTarget} * @param {ol.Extent} extent Extent. * @param {number|undefined} resolution Resolution. * @param {number} pixelRatio Pixel ratio. @@ -63,14 +63,14 @@ ol.ImageBase = function(extent, resolution, pixelRatio, state, attributions) { this.state = state; }; -goog.inherits(ol.ImageBase, goog.events.EventTarget); +goog.inherits(ol.ImageBase, ol.events.EventTarget); /** * @protected */ ol.ImageBase.prototype.changed = function() { - this.dispatchEvent(goog.events.EventType.CHANGE); + this.dispatchEvent(ol.events.EventType.CHANGE); }; diff --git a/src/ol/imagetile.js b/src/ol/imagetile.js index ed2562ae44..c92037f553 100644 --- a/src/ol/imagetile.js +++ b/src/ol/imagetile.js @@ -1,8 +1,8 @@ goog.provide('ol.ImageTile'); goog.require('goog.asserts'); -goog.require('goog.events'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.EventType'); goog.require('goog.object'); goog.require('ol.Tile'); goog.require('ol.TileCoord'); @@ -48,7 +48,7 @@ ol.ImageTile = function(tileCoord, state, src, crossOrigin, tileLoadFunction) { /** * @private - * @type {Array.} + * @type {Array.} */ this.imageListenerKeys_ = null; @@ -146,10 +146,10 @@ ol.ImageTile.prototype.load = function() { goog.asserts.assert(!this.imageListenerKeys_, 'this.imageListenerKeys_ should be null'); this.imageListenerKeys_ = [ - goog.events.listenOnce(this.image_, goog.events.EventType.ERROR, - this.handleImageError_, false, this), - goog.events.listenOnce(this.image_, goog.events.EventType.LOAD, - this.handleImageLoad_, false, this) + ol.events.listenOnce(this.image_, ol.events.EventType.ERROR, + this.handleImageError_, this), + ol.events.listenOnce(this.image_, ol.events.EventType.LOAD, + this.handleImageLoad_, this) ]; this.tileLoadFunction_(this, this.src_); } @@ -164,6 +164,6 @@ ol.ImageTile.prototype.load = function() { ol.ImageTile.prototype.unlistenImage_ = function() { goog.asserts.assert(this.imageListenerKeys_, 'this.imageListenerKeys_ should not be null'); - this.imageListenerKeys_.forEach(goog.events.unlistenByKey); + this.imageListenerKeys_.forEach(ol.events.unlistenByKey); this.imageListenerKeys_ = null; }; diff --git a/src/ol/interaction/doubleclickzoominteraction.js b/src/ol/interaction/doubleclickzoominteraction.js index 2844090ee6..e5d93d4a7f 100644 --- a/src/ol/interaction/doubleclickzoominteraction.js +++ b/src/ol/interaction/doubleclickzoominteraction.js @@ -49,7 +49,7 @@ goog.inherits(ol.interaction.DoubleClickZoom, ol.interaction.Interaction); */ ol.interaction.DoubleClickZoom.handleEvent = function(mapBrowserEvent) { var stopEvent = false; - var browserEvent = mapBrowserEvent.browserEvent; + var browserEvent = mapBrowserEvent.originalEvent; if (mapBrowserEvent.type == ol.MapBrowserEvent.EventType.DBLCLICK) { var map = mapBrowserEvent.map; var anchor = mapBrowserEvent.coordinate; diff --git a/src/ol/interaction/draganddropinteraction.js b/src/ol/interaction/draganddropinteraction.js index 5b2a4f5b60..bab371d51e 100644 --- a/src/ol/interaction/draganddropinteraction.js +++ b/src/ol/interaction/draganddropinteraction.js @@ -4,12 +4,10 @@ goog.provide('ol.interaction.DragAndDrop'); goog.provide('ol.interaction.DragAndDropEvent'); goog.require('goog.asserts'); -goog.require('goog.events'); -goog.require('goog.events.Event'); -goog.require('goog.events.FileDropHandler'); -goog.require('goog.events.FileDropHandler.EventType'); -goog.require('goog.fs.FileReader'); goog.require('goog.functions'); +goog.require('ol.events'); +goog.require('ol.events.Event'); +goog.require('ol.events.EventType'); goog.require('ol.interaction.Interaction'); goog.require('ol.proj'); @@ -48,54 +46,50 @@ ol.interaction.DragAndDrop = function(opt_options) { /** * @private - * @type {goog.events.FileDropHandler} + * @type {Array.} */ - this.fileDropHandler_ = null; - - /** - * @private - * @type {goog.events.Key|undefined} - */ - this.dropListenKey_ = undefined; + this.dropListenKeys_ = null; }; goog.inherits(ol.interaction.DragAndDrop, ol.interaction.Interaction); /** - * @inheritDoc + * @param {Event} event Event. + * @this {ol.interaction.DragAndDrop} + * @private */ -ol.interaction.DragAndDrop.prototype.disposeInternal = function() { - if (this.dropListenKey_) { - goog.events.unlistenByKey(this.dropListenKey_); +ol.interaction.DragAndDrop.handleDrop_ = function(event) { + var files = event.dataTransfer.files; + var i, ii, file; + for (i = 0, ii = files.length; i < ii; ++i) { + file = files.item(i); + var reader = new FileReader(); + reader.addEventListener(ol.events.EventType.LOAD, + goog.partial(this.handleResult_, file).bind(this)); + reader.readAsText(file); } - goog.base(this, 'disposeInternal'); }; /** - * @param {goog.events.BrowserEvent} event Event. + * @param {Event} event Event. * @private */ -ol.interaction.DragAndDrop.prototype.handleDrop_ = function(event) { - var files = event.getBrowserEvent().dataTransfer.files; - var i, ii, file; - for (i = 0, ii = files.length; i < ii; ++i) { - file = files[i]; - // The empty string param is a workaround for - // https://code.google.com/p/closure-library/issues/detail?id=524 - var reader = goog.fs.FileReader.readAsText(file, ''); - reader.addCallback(goog.partial(this.handleResult_, file), this); - } +ol.interaction.DragAndDrop.handleStop_ = function(event) { + event.stopPropagation(); + event.preventDefault(); + event.dataTransfer.dropEffect = 'copy'; }; /** * @param {File} file File. - * @param {string} result Result. + * @param {Event} event Load event. * @private */ -ol.interaction.DragAndDrop.prototype.handleResult_ = function(file, result) { +ol.interaction.DragAndDrop.prototype.handleResult_ = function(file, event) { + var result = event.target.result; var map = this.getMap(); goog.asserts.assert(map, 'map must be set'); var projection = this.projection_; @@ -149,22 +143,23 @@ ol.interaction.DragAndDrop.handleEvent = goog.functions.TRUE; * @inheritDoc */ ol.interaction.DragAndDrop.prototype.setMap = function(map) { - if (this.dropListenKey_) { - goog.events.unlistenByKey(this.dropListenKey_); - this.dropListenKey_ = undefined; + if (this.dropListenKeys_) { + this.dropListenKeys_.forEach(ol.events.unlistenByKey); + this.dropListenKeys_ = null; } - if (this.fileDropHandler_) { - goog.dispose(this.fileDropHandler_); - this.fileDropHandler_ = null; - } - goog.asserts.assert(this.dropListenKey_ === undefined, - 'this.dropListenKey_ should be undefined'); goog.base(this, 'setMap', map); if (map) { - this.fileDropHandler_ = new goog.events.FileDropHandler(map.getViewport()); - this.dropListenKey_ = goog.events.listen( - this.fileDropHandler_, goog.events.FileDropHandler.EventType.DROP, - this.handleDrop_, false, this); + var dropArea = map.getViewport(); + this.dropListenKeys_ = [ + ol.events.listen(dropArea, ol.events.EventType.DROP, + ol.interaction.DragAndDrop.handleDrop_, this), + ol.events.listen(dropArea, ol.events.EventType.DRAGENTER, + ol.interaction.DragAndDrop.handleStop_, this), + ol.events.listen(dropArea, ol.events.EventType.DRAGOVER, + ol.interaction.DragAndDrop.handleStop_, this), + ol.events.listen(dropArea, ol.events.EventType.DROP, + ol.interaction.DragAndDrop.handleStop_, this) + ] } }; @@ -203,7 +198,7 @@ ol.interaction.DragAndDropEventType = { * of this type. * * @constructor - * @extends {goog.events.Event} + * @extends {ol.events.Event} * @implements {oli.interaction.DragAndDropEvent} * @param {ol.interaction.DragAndDropEventType} type Type. * @param {Object} target Target. @@ -237,4 +232,4 @@ ol.interaction.DragAndDropEvent = function(type, target, file, opt_features, opt this.projection = opt_projection; }; -goog.inherits(ol.interaction.DragAndDropEvent, goog.events.Event); +goog.inherits(ol.interaction.DragAndDropEvent, ol.events.Event); diff --git a/src/ol/interaction/dragboxinteraction.js b/src/ol/interaction/dragboxinteraction.js index e37e62ce42..49248b8ff2 100644 --- a/src/ol/interaction/dragboxinteraction.js +++ b/src/ol/interaction/dragboxinteraction.js @@ -2,7 +2,7 @@ goog.provide('ol.DragBoxEvent'); goog.provide('ol.interaction.DragBox'); -goog.require('goog.events.Event'); +goog.require('ol.events.Event'); goog.require('ol'); goog.require('ol.events.ConditionType'); goog.require('ol.events.condition'); @@ -54,7 +54,7 @@ ol.DragBoxEventType = { * @param {string} type The event type. * @param {ol.Coordinate} coordinate The event coordinate. * @param {ol.MapBrowserEvent} mapBrowserEvent Originating event. - * @extends {goog.events.Event} + * @extends {ol.events.Event} * @constructor * @implements {oli.DragBoxEvent} */ @@ -77,7 +77,7 @@ ol.DragBoxEvent = function(type, coordinate, mapBrowserEvent) { this.mapBrowserEvent = mapBrowserEvent; }; -goog.inherits(ol.DragBoxEvent, goog.events.Event); +goog.inherits(ol.DragBoxEvent, ol.events.Event); /** @@ -234,8 +234,8 @@ ol.interaction.DragBox.handleDownEvent_ = function(mapBrowserEvent) { return false; } - var browserEvent = mapBrowserEvent.browserEvent; - if (browserEvent.isMouseActionButton() && this.condition_(mapBrowserEvent)) { + if (ol.events.condition.mouseActionButton(mapBrowserEvent) && + this.condition_(mapBrowserEvent)) { this.startPixel_ = mapBrowserEvent.pixel; this.box_.setMap(mapBrowserEvent.map); this.box_.setPixels(this.startPixel_, this.startPixel_); diff --git a/src/ol/interaction/dragrotateinteraction.js b/src/ol/interaction/dragrotateinteraction.js index 270f6158d2..bdf59c903f 100644 --- a/src/ol/interaction/dragrotateinteraction.js +++ b/src/ol/interaction/dragrotateinteraction.js @@ -112,8 +112,8 @@ ol.interaction.DragRotate.handleDownEvent_ = function(mapBrowserEvent) { return false; } - var browserEvent = mapBrowserEvent.browserEvent; - if (browserEvent.isMouseActionButton() && this.condition_(mapBrowserEvent)) { + if (ol.events.condition.mouseActionButton(mapBrowserEvent) && + this.condition_(mapBrowserEvent)) { var map = mapBrowserEvent.map; map.getView().setHint(ol.ViewHint.INTERACTING, 1); map.render(); diff --git a/src/ol/interaction/drawinteraction.js b/src/ol/interaction/drawinteraction.js index 6daeed903c..79eab3e955 100644 --- a/src/ol/interaction/drawinteraction.js +++ b/src/ol/interaction/drawinteraction.js @@ -5,8 +5,8 @@ goog.provide('ol.interaction.DrawGeometryFunctionType'); goog.provide('ol.interaction.DrawMode'); goog.require('goog.asserts'); -goog.require('goog.events'); -goog.require('goog.events.Event'); +goog.require('ol.events'); +goog.require('ol.events.Event'); goog.require('ol.Collection'); goog.require('ol.Coordinate'); goog.require('ol.Feature'); @@ -55,7 +55,7 @@ ol.interaction.DrawEventType = { * this type. * * @constructor - * @extends {goog.events.Event} + * @extends {ol.events.Event} * @implements {oli.DrawEvent} * @param {ol.interaction.DrawEventType} type Type. * @param {ol.Feature} feature The feature drawn. @@ -72,7 +72,7 @@ ol.interaction.DrawEvent = function(type, feature) { this.feature = feature; }; -goog.inherits(ol.interaction.DrawEvent, goog.events.Event); +goog.inherits(ol.interaction.DrawEvent, ol.events.Event); /** @@ -300,9 +300,9 @@ ol.interaction.Draw = function(options) { this.freehandCondition_ = options.freehandCondition ? options.freehandCondition : ol.events.condition.shiftKeyOnly; - goog.events.listen(this, + ol.events.listen(this, ol.Object.getChangeEventType(ol.interaction.InteractionProperty.ACTIVE), - this.updateState_, false, this); + this.updateState_, this); }; goog.inherits(ol.interaction.Draw, ol.interaction.Pointer); diff --git a/src/ol/interaction/keyboardpaninteraction.js b/src/ol/interaction/keyboardpaninteraction.js index 9a2df3beba..44eaf415a1 100644 --- a/src/ol/interaction/keyboardpaninteraction.js +++ b/src/ol/interaction/keyboardpaninteraction.js @@ -1,12 +1,12 @@ goog.provide('ol.interaction.KeyboardPan'); goog.require('goog.asserts'); -goog.require('goog.events.KeyCodes'); -goog.require('goog.events.KeyHandler.EventType'); goog.require('goog.functions'); goog.require('ol'); goog.require('ol.coordinate'); goog.require('ol.events.ConditionType'); +goog.require('ol.events.EventType'); +goog.require('ol.events.KeyCode'); goog.require('ol.events.condition'); goog.require('ol.interaction.Interaction'); @@ -73,25 +73,24 @@ goog.inherits(ol.interaction.KeyboardPan, ol.interaction.Interaction); */ ol.interaction.KeyboardPan.handleEvent = function(mapBrowserEvent) { var stopEvent = false; - if (mapBrowserEvent.type == goog.events.KeyHandler.EventType.KEY) { - var keyEvent = /** @type {goog.events.KeyEvent} */ - (mapBrowserEvent.browserEvent); + if (mapBrowserEvent.type == ol.events.EventType.KEYDOWN) { + var keyEvent = mapBrowserEvent.originalEvent; var keyCode = keyEvent.keyCode; if (this.condition_(mapBrowserEvent) && - (keyCode == goog.events.KeyCodes.DOWN || - keyCode == goog.events.KeyCodes.LEFT || - keyCode == goog.events.KeyCodes.RIGHT || - keyCode == goog.events.KeyCodes.UP)) { + (keyCode == ol.events.KeyCode.DOWN || + keyCode == ol.events.KeyCode.LEFT || + keyCode == ol.events.KeyCode.RIGHT || + keyCode == ol.events.KeyCode.UP)) { var map = mapBrowserEvent.map; var view = map.getView(); goog.asserts.assert(view, 'map must have view'); var mapUnitsDelta = view.getResolution() * this.pixelDelta_; var deltaX = 0, deltaY = 0; - if (keyCode == goog.events.KeyCodes.DOWN) { + if (keyCode == ol.events.KeyCode.DOWN) { deltaY = -mapUnitsDelta; - } else if (keyCode == goog.events.KeyCodes.LEFT) { + } else if (keyCode == ol.events.KeyCode.LEFT) { deltaX = -mapUnitsDelta; - } else if (keyCode == goog.events.KeyCodes.RIGHT) { + } else if (keyCode == ol.events.KeyCode.RIGHT) { deltaX = mapUnitsDelta; } else { deltaY = mapUnitsDelta; diff --git a/src/ol/interaction/keyboardzoominteraction.js b/src/ol/interaction/keyboardzoominteraction.js index f99afabd1d..431b7fe737 100644 --- a/src/ol/interaction/keyboardzoominteraction.js +++ b/src/ol/interaction/keyboardzoominteraction.js @@ -1,8 +1,8 @@ goog.provide('ol.interaction.KeyboardZoom'); goog.require('goog.asserts'); -goog.require('goog.events.KeyHandler.EventType'); goog.require('ol.events.ConditionType'); +goog.require('ol.events.EventType'); goog.require('ol.events.condition'); goog.require('ol.interaction.Interaction'); @@ -66,9 +66,9 @@ goog.inherits(ol.interaction.KeyboardZoom, ol.interaction.Interaction); */ ol.interaction.KeyboardZoom.handleEvent = function(mapBrowserEvent) { var stopEvent = false; - if (mapBrowserEvent.type == goog.events.KeyHandler.EventType.KEY) { - var keyEvent = /** @type {goog.events.KeyEvent} */ - (mapBrowserEvent.browserEvent); + if (mapBrowserEvent.type == ol.events.EventType.KEYDOWN || + mapBrowserEvent.type == ol.events.EventType.KEYPRESS) { + var keyEvent = mapBrowserEvent.originalEvent; var charCode = keyEvent.charCode; if (this.condition_(mapBrowserEvent) && (charCode == '+'.charCodeAt(0) || charCode == '-'.charCodeAt(0))) { diff --git a/src/ol/interaction/modifyinteraction.js b/src/ol/interaction/modifyinteraction.js index 5b33daf68d..de89fa523c 100644 --- a/src/ol/interaction/modifyinteraction.js +++ b/src/ol/interaction/modifyinteraction.js @@ -2,9 +2,9 @@ goog.provide('ol.interaction.Modify'); goog.provide('ol.interaction.ModifyEvent'); goog.require('goog.asserts'); -goog.require('goog.events'); -goog.require('goog.events.Event'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.Event'); +goog.require('ol.events.EventType'); goog.require('goog.functions'); goog.require('ol'); goog.require('ol.Collection'); @@ -55,7 +55,7 @@ ol.ModifyEventType = { * this type. * * @constructor - * @extends {goog.events.Event} + * @extends {ol.events.Event} * @implements {oli.ModifyEvent} * @param {ol.ModifyEventType} type Type. * @param {ol.Collection.} features The features modified. @@ -80,7 +80,7 @@ ol.interaction.ModifyEvent = function(type, features, mapBrowserPointerEvent) { */ this.mapBrowserPointerEvent = mapBrowserPointerEvent; }; -goog.inherits(ol.interaction.ModifyEvent, goog.events.Event); +goog.inherits(ol.interaction.ModifyEvent, ol.events.Event); /** @@ -229,10 +229,10 @@ ol.interaction.Modify = function(options) { this.features_ = options.features; this.features_.forEach(this.addFeature_, this); - goog.events.listen(this.features_, ol.CollectionEventType.ADD, - this.handleFeatureAdd_, false, this); - goog.events.listen(this.features_, ol.CollectionEventType.REMOVE, - this.handleFeatureRemove_, false, this); + ol.events.listen(this.features_, ol.CollectionEventType.ADD, + this.handleFeatureAdd_, this); + ol.events.listen(this.features_, ol.CollectionEventType.REMOVE, + this.handleFeatureRemove_, this); }; goog.inherits(ol.interaction.Modify, ol.interaction.Pointer); @@ -251,8 +251,8 @@ ol.interaction.Modify.prototype.addFeature_ = function(feature) { if (map) { this.handlePointerAtPixel_(this.lastPixel_, map); } - goog.events.listen(feature, goog.events.EventType.CHANGE, - this.handleFeatureChange_, false, this); + ol.events.listen(feature, ol.events.EventType.CHANGE, + this.handleFeatureChange_, this); }; @@ -281,8 +281,8 @@ ol.interaction.Modify.prototype.removeFeature_ = function(feature) { this.overlay_.getSource().removeFeature(this.vertexFeature_); this.vertexFeature_ = null; } - goog.events.unlisten(feature, goog.events.EventType.CHANGE, - this.handleFeatureChange_, false, this); + ol.events.unlisten(feature, ol.events.EventType.CHANGE, + this.handleFeatureChange_, this); }; @@ -330,7 +330,7 @@ ol.interaction.Modify.prototype.handleFeatureAdd_ = function(evt) { /** - * @param {goog.events.Event} evt Event. + * @param {ol.events.Event} evt Event. * @private */ ol.interaction.Modify.prototype.handleFeatureChange_ = function(evt) { diff --git a/src/ol/interaction/mousewheelzoominteraction.js b/src/ol/interaction/mousewheelzoominteraction.js index cc27f6e647..bb3840345e 100644 --- a/src/ol/interaction/mousewheelzoominteraction.js +++ b/src/ol/interaction/mousewheelzoominteraction.js @@ -1,10 +1,9 @@ goog.provide('ol.interaction.MouseWheelZoom'); goog.require('goog.asserts'); -goog.require('goog.events.MouseWheelEvent'); -goog.require('goog.events.MouseWheelHandler.EventType'); goog.require('ol'); goog.require('ol.Coordinate'); +goog.require('ol.events.EventType'); goog.require('ol.interaction.Interaction'); goog.require('ol.math'); @@ -76,18 +75,36 @@ goog.inherits(ol.interaction.MouseWheelZoom, ol.interaction.Interaction); */ ol.interaction.MouseWheelZoom.handleEvent = function(mapBrowserEvent) { var stopEvent = false; - if (mapBrowserEvent.type == - goog.events.MouseWheelHandler.EventType.MOUSEWHEEL) { + if (mapBrowserEvent.type == ol.events.EventType.WHEEL || + mapBrowserEvent.type == ol.events.EventType.MOUSEWHEEL) { var map = mapBrowserEvent.map; - var mouseWheelEvent = mapBrowserEvent.browserEvent; - goog.asserts.assertInstanceof(mouseWheelEvent, goog.events.MouseWheelEvent, - 'mouseWheelEvent should be of type MouseWheelEvent'); + var wheelEvent = /** @type {WheelEvent} */ (mapBrowserEvent.originalEvent); if (this.useAnchor_) { this.lastAnchor_ = mapBrowserEvent.coordinate; } - this.delta_ += mouseWheelEvent.deltaY; + // Delta normalisation inspired by + // https://github.com/mapbox/mapbox-gl-js/blob/001c7b9/js/ui/handler/scroll_zoom.js + //TODO There's more good stuff in there for inspiration to improve this interaction. + var delta; + if (mapBrowserEvent.type == ol.events.EventType.WHEEL) { + delta = wheelEvent.deltaY; + if (ol.has.FIREFOX && + wheelEvent.deltaMode === goog.global.WheelEvent.DOM_DELTA_PIXEL) { + delta /= ol.has.DEVICE_PIXEL_RATIO; + } + if (wheelEvent.deltaMode === goog.global.WheelEvent.DOM_DELTA_LINE) { + delta *= 40; + } + } else if (mapBrowserEvent.type == ol.events.EventType.MOUSEWHEEL) { + delta = -wheelEvent.wheelDeltaY; + if (ol.has.SAFARI) { + delta /= 3; + } + } + + this.delta_ += delta; if (this.startTime_ === undefined) { this.startTime_ = Date.now(); diff --git a/src/ol/interaction/selectinteraction.js b/src/ol/interaction/selectinteraction.js index a11231a5bc..47247ce55b 100644 --- a/src/ol/interaction/selectinteraction.js +++ b/src/ol/interaction/selectinteraction.js @@ -4,8 +4,8 @@ goog.provide('ol.interaction.SelectEventType'); goog.provide('ol.interaction.SelectFilterFunction'); goog.require('goog.asserts'); -goog.require('goog.events'); -goog.require('goog.events.Event'); +goog.require('ol.events'); +goog.require('ol.events.Event'); goog.require('goog.functions'); goog.require('goog.object'); goog.require('ol.CollectionEventType'); @@ -53,7 +53,7 @@ ol.interaction.SelectFilterFunction; * @param {ol.MapBrowserEvent} mapBrowserEvent Associated * {@link ol.MapBrowserEvent}. * @implements {oli.SelectEvent} - * @extends {goog.events.Event} + * @extends {ol.events.Event} * @constructor */ ol.interaction.SelectEvent = function(type, selected, deselected, mapBrowserEvent) { @@ -80,7 +80,7 @@ ol.interaction.SelectEvent = function(type, selected, deselected, mapBrowserEven */ this.mapBrowserEvent = mapBrowserEvent; }; -goog.inherits(ol.interaction.SelectEvent, goog.events.Event); +goog.inherits(ol.interaction.SelectEvent, ol.events.Event); /** @@ -208,10 +208,10 @@ ol.interaction.Select = function(opt_options) { this.featureLayerAssociation_ = {}; var features = this.featureOverlay_.getSource().getFeaturesCollection(); - goog.events.listen(features, ol.CollectionEventType.ADD, - this.addFeature_, false, this); - goog.events.listen(features, ol.CollectionEventType.REMOVE, - this.removeFeature_, false, this); + ol.events.listen(features, ol.CollectionEventType.ADD, + this.addFeature_, this); + ol.events.listen(features, ol.CollectionEventType.REMOVE, + this.removeFeature_, this); }; goog.inherits(ol.interaction.Select, ol.interaction.Interaction); diff --git a/src/ol/interaction/snapinteraction.js b/src/ol/interaction/snapinteraction.js index cb63622736..eb8598ade6 100644 --- a/src/ol/interaction/snapinteraction.js +++ b/src/ol/interaction/snapinteraction.js @@ -2,8 +2,8 @@ goog.provide('ol.interaction.Snap'); goog.provide('ol.interaction.SnapProperty'); goog.require('goog.asserts'); -goog.require('goog.events'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.EventType'); goog.require('goog.object'); goog.require('ol'); goog.require('ol.Collection'); @@ -68,19 +68,19 @@ ol.interaction.Snap = function(opt_options) { this.features_ = options.features ? options.features : null; /** - * @type {Array.} + * @type {Array.} * @private */ this.featuresListenerKeys_ = []; /** - * @type {Object.} + * @type {Object.} * @private */ this.geometryChangeListenerKeys_ = {}; /** - * @type {Object.} + * @type {Object.} * @private */ this.geometryModifyListenerKeys_ = {}; @@ -168,11 +168,13 @@ ol.interaction.Snap.prototype.addFeature = function(feature, opt_listen) { segmentWriter.call(this, feature, geometry); if (listen) { - this.geometryModifyListenerKeys_[feature_uid] = geometry.on( - goog.events.EventType.CHANGE, + this.geometryModifyListenerKeys_[feature_uid] = ol.events.listen( + geometry, + ol.events.EventType.CHANGE, this.handleGeometryModify_.bind(this, feature), this); - this.geometryChangeListenerKeys_[feature_uid] = feature.on( + this.geometryChangeListenerKeys_[feature_uid] = ol.events.listen( + feature, ol.Object.getChangeEventType(feature.getGeometryName()), this.handleGeometryChange_, this); } @@ -249,11 +251,11 @@ ol.interaction.Snap.prototype.handleFeatureRemove_ = function(evt) { /** - * @param {goog.events.Event} evt Event. + * @param {ol.events.Event} evt Event. * @private */ ol.interaction.Snap.prototype.handleGeometryChange_ = function(evt) { - var feature = evt.currentTarget; + var feature = evt.target; goog.asserts.assertInstanceof(feature, ol.Feature); this.removeFeature(feature, true); this.addFeature(feature, true); @@ -262,7 +264,7 @@ ol.interaction.Snap.prototype.handleGeometryChange_ = function(evt) { /** * @param {ol.Feature} feature Feature which geometry was modified. - * @param {goog.events.Event} evt Event. + * @param {ol.events.Event} evt Event. * @private */ ol.interaction.Snap.prototype.handleGeometryModify_ = function(feature, evt) { diff --git a/src/ol/interaction/translateinteraction.js b/src/ol/interaction/translateinteraction.js index 9c7a0843b4..9393fe9440 100644 --- a/src/ol/interaction/translateinteraction.js +++ b/src/ol/interaction/translateinteraction.js @@ -1,8 +1,8 @@ goog.provide('ol.interaction.Translate'); goog.provide('ol.interaction.TranslateEvent'); -goog.require('goog.events'); -goog.require('goog.events.Event'); +goog.require('ol.events'); +goog.require('ol.events.Event'); goog.require('ol.array'); goog.require('ol.interaction.Pointer'); @@ -38,7 +38,7 @@ ol.interaction.TranslateEventType = { * this type. * * @constructor - * @extends {goog.events.Event} + * @extends {ol.events.Event} * @implements {oli.interaction.TranslateEvent} * @param {ol.interaction.TranslateEventType} type Type. * @param {ol.Collection.} features The features translated. @@ -63,7 +63,7 @@ ol.interaction.TranslateEvent = function(type, features, coordinate) { */ this.coordinate = coordinate; }; -goog.inherits(ol.interaction.TranslateEvent, goog.events.Event); +goog.inherits(ol.interaction.TranslateEvent, ol.events.Event); /** diff --git a/src/ol/layer/heatmaplayer.js b/src/ol/layer/heatmaplayer.js index 73ad1c0512..a5daba97ea 100644 --- a/src/ol/layer/heatmaplayer.js +++ b/src/ol/layer/heatmaplayer.js @@ -1,7 +1,7 @@ goog.provide('ol.layer.Heatmap'); goog.require('goog.asserts'); -goog.require('goog.events'); +goog.require('ol.events'); goog.require('goog.object'); goog.require('ol'); goog.require('ol.Object'); @@ -72,9 +72,9 @@ ol.layer.Heatmap = function(opt_options) { */ this.styleCache_ = null; - goog.events.listen(this, + ol.events.listen(this, ol.Object.getChangeEventType(ol.layer.HeatmapLayerProperty.GRADIENT), - this.handleGradientChanged_, false, this); + this.handleGradientChanged_, this); this.setGradient(options.gradient ? options.gradient : ol.layer.Heatmap.DEFAULT_GRADIENT); @@ -83,10 +83,12 @@ ol.layer.Heatmap = function(opt_options) { this.setRadius(options.radius !== undefined ? options.radius : 8); - goog.events.listen(this, [ - ol.Object.getChangeEventType(ol.layer.HeatmapLayerProperty.BLUR), - ol.Object.getChangeEventType(ol.layer.HeatmapLayerProperty.RADIUS) - ], this.handleStyleChanged_, false, this); + ol.events.listen(this, + ol.Object.getChangeEventType(ol.layer.HeatmapLayerProperty.BLUR), + this.handleStyleChanged_, this); + ol.events.listen(this, + ol.Object.getChangeEventType(ol.layer.HeatmapLayerProperty.RADIUS), + this.handleStyleChanged_, this); this.handleStyleChanged_(); @@ -129,8 +131,7 @@ ol.layer.Heatmap = function(opt_options) { // The render order is not relevant for a heatmap representation. this.setRenderOrder(null); - goog.events.listen(this, ol.render.EventType.RENDER, - this.handleRender_, false, this); + ol.events.listen(this, ol.render.EventType.RENDER, this.handleRender_, this); }; goog.inherits(ol.layer.Heatmap, ol.layer.Vector); diff --git a/src/ol/layer/layer.js b/src/ol/layer/layer.js index 2d5c2c256c..61ae7a32c0 100644 --- a/src/ol/layer/layer.js +++ b/src/ol/layer/layer.js @@ -1,7 +1,7 @@ goog.provide('ol.layer.Layer'); -goog.require('goog.events'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.EventType'); goog.require('goog.object'); goog.require('ol'); goog.require('ol.Object'); @@ -41,19 +41,19 @@ ol.layer.Layer = function(options) { /** * @private - * @type {goog.events.Key} + * @type {?ol.events.Key} */ this.mapPrecomposeKey_ = null; /** * @private - * @type {goog.events.Key} + * @type {?ol.events.Key} */ this.mapRenderKey_ = null; /** * @private - * @type {goog.events.Key} + * @type {?ol.events.Key} */ this.sourceChangeKey_ = null; @@ -61,9 +61,9 @@ ol.layer.Layer = function(options) { this.setMap(options.map); } - goog.events.listen(this, + ol.events.listen(this, ol.Object.getChangeEventType(ol.layer.LayerProperty.SOURCE), - this.handleSourcePropertyChange_, false, this); + this.handleSourcePropertyChange_, this); var source = options.source ? options.source : null; this.setSource(source); @@ -139,13 +139,13 @@ ol.layer.Layer.prototype.handleSourceChange_ = function() { */ ol.layer.Layer.prototype.handleSourcePropertyChange_ = function() { if (this.sourceChangeKey_) { - goog.events.unlistenByKey(this.sourceChangeKey_); + ol.events.unlistenByKey(this.sourceChangeKey_); this.sourceChangeKey_ = null; } var source = this.getSource(); if (source) { - this.sourceChangeKey_ = goog.events.listen(source, - goog.events.EventType.CHANGE, this.handleSourceChange_, false, this); + this.sourceChangeKey_ = ol.events.listen(source, + ol.events.EventType.CHANGE, this.handleSourceChange_, this); } this.changed(); }; @@ -164,24 +164,28 @@ ol.layer.Layer.prototype.handleSourcePropertyChange_ = function() { * @api */ ol.layer.Layer.prototype.setMap = function(map) { - goog.events.unlistenByKey(this.mapPrecomposeKey_); - this.mapPrecomposeKey_ = null; + if (this.mapPrecomposeKey_) { + ol.events.unlistenByKey(this.mapPrecomposeKey_); + this.mapPrecomposeKey_ = null; + } if (!map) { this.changed(); } - goog.events.unlistenByKey(this.mapRenderKey_); - this.mapRenderKey_ = null; + if (this.mapRenderKey_) { + ol.events.unlistenByKey(this.mapRenderKey_); + this.mapRenderKey_ = null; + } if (map) { - this.mapPrecomposeKey_ = goog.events.listen( + this.mapPrecomposeKey_ = ol.events.listen( map, ol.render.EventType.PRECOMPOSE, function(evt) { var layerState = this.getLayerState(); layerState.managed = false; layerState.zIndex = Infinity; evt.frameState.layerStatesArray.push(layerState); evt.frameState.layerStates[goog.getUid(this)] = layerState; - }, false, this); - this.mapRenderKey_ = goog.events.listen( - this, goog.events.EventType.CHANGE, map.render, false, map); + }, this); + this.mapRenderKey_ = ol.events.listen( + this, ol.events.EventType.CHANGE, map.render, map); this.changed(); } }; diff --git a/src/ol/layer/layergroup.js b/src/ol/layer/layergroup.js index e942e6d34f..291ee58e7c 100644 --- a/src/ol/layer/layergroup.js +++ b/src/ol/layer/layergroup.js @@ -1,8 +1,8 @@ goog.provide('ol.layer.Group'); goog.require('goog.asserts'); -goog.require('goog.events'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.EventType'); goog.require('goog.object'); goog.require('ol.Collection'); goog.require('ol.CollectionEvent'); @@ -46,19 +46,19 @@ ol.layer.Group = function(opt_options) { /** * @private - * @type {Array.} + * @type {Array.} */ this.layersListenerKeys_ = []; /** * @private - * @type {Object.>} + * @type {Object.>} */ this.listenerKeys_ = {}; - goog.events.listen(this, + ol.events.listen(this, ol.Object.getChangeEventType(ol.layer.GroupProperty.LAYERS), - this.handleLayersChanged_, false, this); + this.handleLayersChanged_, this); if (layers) { if (goog.isArray(layers)) { @@ -89,22 +89,22 @@ ol.layer.Group.prototype.handleLayerChange_ = function() { /** - * @param {goog.events.Event} event Event. + * @param {ol.events.Event} event Event. * @private */ ol.layer.Group.prototype.handleLayersChanged_ = function(event) { - this.layersListenerKeys_.forEach(goog.events.unlistenByKey); + this.layersListenerKeys_.forEach(ol.events.unlistenByKey); this.layersListenerKeys_.length = 0; var layers = this.getLayers(); this.layersListenerKeys_.push( - goog.events.listen(layers, ol.CollectionEventType.ADD, - this.handleLayersAdd_, false, this), - goog.events.listen(layers, ol.CollectionEventType.REMOVE, - this.handleLayersRemove_, false, this)); + ol.events.listen(layers, ol.CollectionEventType.ADD, + this.handleLayersAdd_, this), + ol.events.listen(layers, ol.CollectionEventType.REMOVE, + this.handleLayersRemove_, this)); goog.object.forEach(this.listenerKeys_, function(keys) { - keys.forEach(goog.events.unlistenByKey); + keys.forEach(ol.events.unlistenByKey); }); goog.object.clear(this.listenerKeys_); @@ -113,10 +113,10 @@ ol.layer.Group.prototype.handleLayersChanged_ = function(event) { for (i = 0, ii = layersArray.length; i < ii; i++) { layer = layersArray[i]; this.listenerKeys_[goog.getUid(layer).toString()] = [ - goog.events.listen(layer, ol.ObjectEventType.PROPERTYCHANGE, - this.handleLayerChange_, false, this), - goog.events.listen(layer, goog.events.EventType.CHANGE, - this.handleLayerChange_, false, this) + ol.events.listen(layer, ol.ObjectEventType.PROPERTYCHANGE, + this.handleLayerChange_, this), + ol.events.listen(layer, ol.events.EventType.CHANGE, + this.handleLayerChange_, this) ]; } @@ -134,10 +134,10 @@ ol.layer.Group.prototype.handleLayersAdd_ = function(collectionEvent) { goog.asserts.assert(!(key in this.listenerKeys_), 'listeners already registered'); this.listenerKeys_[key] = [ - goog.events.listen(layer, ol.ObjectEventType.PROPERTYCHANGE, - this.handleLayerChange_, false, this), - goog.events.listen(layer, goog.events.EventType.CHANGE, - this.handleLayerChange_, false, this) + ol.events.listen(layer, ol.ObjectEventType.PROPERTYCHANGE, + this.handleLayerChange_, this), + ol.events.listen(layer, ol.events.EventType.CHANGE, + this.handleLayerChange_, this) ]; this.changed(); }; @@ -151,7 +151,7 @@ ol.layer.Group.prototype.handleLayersRemove_ = function(collectionEvent) { var layer = /** @type {ol.layer.Base} */ (collectionEvent.element); var key = goog.getUid(layer).toString(); goog.asserts.assert(key in this.listenerKeys_, 'no listeners to unregister'); - this.listenerKeys_[key].forEach(goog.events.unlistenByKey); + this.listenerKeys_[key].forEach(ol.events.unlistenByKey); delete this.listenerKeys_[key]; this.changed(); }; diff --git a/src/ol/map.js b/src/ol/map.js index 700ec6754e..9397724a4f 100644 --- a/src/ol/map.js +++ b/src/ol/map.js @@ -6,20 +6,10 @@ goog.provide('ol.Map'); goog.provide('ol.MapProperty'); goog.require('goog.asserts'); -goog.require('goog.async.AnimationDelay'); goog.require('goog.async.nextTick'); goog.require('goog.debug.Console'); goog.require('goog.dom'); -goog.require('goog.dom.ViewportSizeMonitor'); goog.require('goog.dom.classlist'); -goog.require('goog.events'); -goog.require('goog.events.BrowserEvent'); -goog.require('goog.events.Event'); -goog.require('goog.events.EventType'); -goog.require('goog.events.KeyHandler'); -goog.require('goog.events.KeyHandler.EventType'); -goog.require('goog.events.MouseWheelHandler'); -goog.require('goog.events.MouseWheelHandler.EventType'); goog.require('goog.functions'); goog.require('goog.log'); goog.require('goog.log.Level'); @@ -46,6 +36,9 @@ goog.require('ol.View'); goog.require('ol.ViewHint'); goog.require('ol.array'); goog.require('ol.control'); +goog.require('ol.events'); +goog.require('ol.events.Event'); +goog.require('ol.events.EventType'); goog.require('ol.extent'); goog.require('ol.has'); goog.require('ol.interaction'); @@ -205,11 +198,17 @@ ol.Map = function(options) { /** * @private - * @type {goog.async.AnimationDelay} + * @type {number|undefined} */ - this.animationDelay_ = - new goog.async.AnimationDelay(this.renderFrame_, undefined, this); - this.registerDisposable(this.animationDelay_); + this.animationDelayKey_; + + /** + * @private + */ + this.animationDelay_ = function() { + this.animationDelayKey_ = undefined; + this.renderFrame_.call(this, Date.now()); + }.bind(this); /** * @private @@ -244,13 +243,13 @@ ol.Map = function(options) { /** * @private - * @type {goog.events.Key} + * @type {?ol.events.Key} */ this.viewPropertyListenerKey_ = null; /** * @private - * @type {Array.} + * @type {Array.} */ this.layerGroupPropertyListenerKeys_ = null; @@ -285,21 +284,26 @@ ol.Map = function(options) { */ this.overlayContainerStopEvent_ = document.createElement('DIV'); this.overlayContainerStopEvent_.className = 'ol-overlaycontainer-stopevent'; - goog.events.listen(this.overlayContainerStopEvent_, [ - goog.events.EventType.CLICK, - goog.events.EventType.DBLCLICK, - goog.events.EventType.MOUSEDOWN, - goog.events.EventType.TOUCHSTART, - goog.events.EventType.MSPOINTERDOWN, + var overlayEvents = [ + ol.events.EventType.CLICK, + ol.events.EventType.DBLCLICK, + ol.events.EventType.MOUSEDOWN, + ol.events.EventType.TOUCHSTART, + ol.events.EventType.MSPOINTERDOWN, ol.MapBrowserEvent.EventType.POINTERDOWN, - goog.userAgent.GECKO ? 'DOMMouseScroll' : 'mousewheel' - ], goog.events.Event.stopPropagation); + goog.userAgent.GECKO ? 'DOMMouseScroll' : ol.events.EventType.MOUSEWHEEL + ]; + for (var i = 0, ii = overlayEvents.length; i < ii; ++i) { + ol.events.listen(this.overlayContainerStopEvent_, overlayEvents[i], + ol.events.Event.stopPropagation); + } this.viewport_.appendChild(this.overlayContainerStopEvent_); var mapBrowserEventHandler = new ol.MapBrowserEventHandler(this); - goog.events.listen(mapBrowserEventHandler, - goog.object.getValues(ol.MapBrowserEvent.EventType), - this.handleMapBrowserEvent, false, this); + for (var key in ol.MapBrowserEvent.EventType) { + ol.events.listen(mapBrowserEventHandler, ol.MapBrowserEvent.EventType[key], + this.handleMapBrowserEvent, this); + } this.registerDisposable(mapBrowserEventHandler); /** @@ -310,18 +314,14 @@ ol.Map = function(options) { /** * @private - * @type {goog.events.KeyHandler} + * @type {Array.} */ - this.keyHandler_ = new goog.events.KeyHandler(); - goog.events.listen(this.keyHandler_, goog.events.KeyHandler.EventType.KEY, - this.handleBrowserEvent, false, this); - this.registerDisposable(this.keyHandler_); + this.keyHandlerKeys_ = null; - var mouseWheelHandler = new goog.events.MouseWheelHandler(this.viewport_); - goog.events.listen(mouseWheelHandler, - goog.events.MouseWheelHandler.EventType.MOUSEWHEEL, - this.handleBrowserEvent, false, this); - this.registerDisposable(mouseWheelHandler); + ol.events.listen(this.viewport_, ol.events.EventType.WHEEL, + this.handleBrowserEvent, this); + ol.events.listen(this.viewport_, ol.events.EventType.MOUSEWHEEL, + this.handleBrowserEvent, this); /** * @type {ol.Collection.} @@ -357,17 +357,10 @@ ol.Map = function(options) { this.registerDisposable(this.renderer_); /** - * @type {goog.dom.ViewportSizeMonitor} + * @type {function(Event)|undefined} * @private */ - this.viewportSizeMonitor_ = new goog.dom.ViewportSizeMonitor(); - this.registerDisposable(this.viewportSizeMonitor_); - - /** - * @type {goog.events.Key} - * @private - */ - this.viewportResizeListenerKey_ = null; + this.handleResize_; /** * @private @@ -402,15 +395,15 @@ ol.Map = function(options) { */ this.skippedFeatureUids_ = {}; - goog.events.listen( + ol.events.listen( this, ol.Object.getChangeEventType(ol.MapProperty.LAYERGROUP), - this.handleLayerGroupChanged_, false, this); - goog.events.listen(this, ol.Object.getChangeEventType(ol.MapProperty.VIEW), - this.handleViewChanged_, false, this); - goog.events.listen(this, ol.Object.getChangeEventType(ol.MapProperty.SIZE), - this.handleSizeChanged_, false, this); - goog.events.listen(this, ol.Object.getChangeEventType(ol.MapProperty.TARGET), - this.handleTargetChanged_, false, this); + this.handleLayerGroupChanged_, this); + ol.events.listen(this, ol.Object.getChangeEventType(ol.MapProperty.VIEW), + this.handleViewChanged_, this); + ol.events.listen(this, ol.Object.getChangeEventType(ol.MapProperty.SIZE), + this.handleSizeChanged_, this); + ol.events.listen(this, ol.Object.getChangeEventType(ol.MapProperty.TARGET), + this.handleTargetChanged_, this); // setProperties will trigger the rendering of the map if the map // is "defined" already. @@ -425,21 +418,21 @@ ol.Map = function(options) { control.setMap(this); }, this); - goog.events.listen(this.controls_, ol.CollectionEventType.ADD, + ol.events.listen(this.controls_, ol.CollectionEventType.ADD, /** * @param {ol.CollectionEvent} event Collection event. */ function(event) { event.element.setMap(this); - }, false, this); + }, this); - goog.events.listen(this.controls_, ol.CollectionEventType.REMOVE, + ol.events.listen(this.controls_, ol.CollectionEventType.REMOVE, /** * @param {ol.CollectionEvent} event Collection event. */ function(event) { event.element.setMap(null); - }, false, this); + }, this); this.interactions_.forEach( /** @@ -450,33 +443,33 @@ ol.Map = function(options) { interaction.setMap(this); }, this); - goog.events.listen(this.interactions_, ol.CollectionEventType.ADD, + ol.events.listen(this.interactions_, ol.CollectionEventType.ADD, /** * @param {ol.CollectionEvent} event Collection event. */ function(event) { event.element.setMap(this); - }, false, this); + }, this); - goog.events.listen(this.interactions_, ol.CollectionEventType.REMOVE, + ol.events.listen(this.interactions_, ol.CollectionEventType.REMOVE, /** * @param {ol.CollectionEvent} event Collection event. */ function(event) { event.element.setMap(null); - }, false, this); + }, this); this.overlays_.forEach(this.addOverlayInternal_, this); - goog.events.listen(this.overlays_, ol.CollectionEventType.ADD, + ol.events.listen(this.overlays_, ol.CollectionEventType.ADD, /** * @param {ol.CollectionEvent} event Collection event. */ function(event) { this.addOverlayInternal_(/** @type {ol.Overlay} */ (event.element)); - }, false, this); + }, this); - goog.events.listen(this.overlays_, ol.CollectionEventType.REMOVE, + ol.events.listen(this.overlays_, ol.CollectionEventType.REMOVE, /** * @param {ol.CollectionEvent} event Collection event. */ @@ -486,7 +479,7 @@ ol.Map = function(options) { delete this.overlayIdIndex_[id.toString()]; } event.element.setMap(null); - }, false, this); + }, this); }; goog.inherits(ol.Map, ol.Object); @@ -583,6 +576,19 @@ ol.Map.prototype.removePreRenderFunction = function(preRenderFunction) { * @inheritDoc */ ol.Map.prototype.disposeInternal = function() { + ol.events.unlisten(this.viewport_, ol.events.EventType.WHEEL, + this.handleBrowserEvent, this); + ol.events.unlisten(this.viewport_, ol.events.EventType.MOUSEWHEEL, + this.handleBrowserEvent, this); + if (this.handleResize_ !== undefined) { + goog.global.removeEventListener(ol.events.EventType.RESIZE, + this.handleResize_, false); + this.handleResize_ = undefined; + } + if (this.animationDelayKey_) { + goog.global.cancelAnimationFrame(this.animationDelayKey_); + this.animationDelayKey_ = undefined; + } goog.dom.removeNode(this.viewport_); goog.base(this, 'disposeInternal'); }; @@ -949,7 +955,7 @@ ol.Map.prototype.getTilePriority = function(tile, tileSourceKey, tileCenter, til /** - * @param {goog.events.BrowserEvent} browserEvent Browser event. + * @param {Event} browserEvent Browser event. * @param {string=} opt_type Type. */ ol.Map.prototype.handleBrowserEvent = function(browserEvent, opt_type) { @@ -1059,25 +1065,36 @@ ol.Map.prototype.handleTargetChanged_ = function() { var targetElement = this.getTargetElement(); - this.keyHandler_.detach(); + if (this.keyHandlerKeys_) { + for (var i = 0, ii = this.keyHandlerKeys_.length; i < ii; ++i) { + ol.events.unlistenByKey(this.keyHandlerKeys_[i]); + } + this.keyHandlerKeys_ = null; + } if (!targetElement) { goog.dom.removeNode(this.viewport_); - if (this.viewportResizeListenerKey_) { - goog.events.unlistenByKey(this.viewportResizeListenerKey_); - this.viewportResizeListenerKey_ = null; + if (this.handleResize_ !== undefined) { + goog.global.removeEventListener(ol.events.EventType.RESIZE, + this.handleResize_, false); + this.handleResize_ = undefined; } } else { targetElement.appendChild(this.viewport_); var keyboardEventTarget = !this.keyboardEventTarget_ ? targetElement : this.keyboardEventTarget_; - this.keyHandler_.attach(keyboardEventTarget); + this.keyHandlerKeys_ = [ + ol.events.listen(keyboardEventTarget, ol.events.EventType.KEYDOWN, + this.handleBrowserEvent, this), + ol.events.listen(keyboardEventTarget, ol.events.EventType.KEYPRESS, + this.handleBrowserEvent, this) + ]; - if (!this.viewportResizeListenerKey_) { - this.viewportResizeListenerKey_ = goog.events.listen( - this.viewportSizeMonitor_, goog.events.EventType.RESIZE, - this.updateSize, false, this); + if (!this.handleResize_) { + this.handleResize_ = this.updateSize.bind(this); + goog.global.addEventListener(ol.events.EventType.RESIZE, + this.handleResize_, false); } } @@ -1108,25 +1125,25 @@ ol.Map.prototype.handleViewPropertyChanged_ = function() { */ ol.Map.prototype.handleViewChanged_ = function() { if (this.viewPropertyListenerKey_) { - goog.events.unlistenByKey(this.viewPropertyListenerKey_); + ol.events.unlistenByKey(this.viewPropertyListenerKey_); this.viewPropertyListenerKey_ = null; } var view = this.getView(); if (view) { - this.viewPropertyListenerKey_ = goog.events.listen( + this.viewPropertyListenerKey_ = ol.events.listen( view, ol.ObjectEventType.PROPERTYCHANGE, - this.handleViewPropertyChanged_, false, this); + this.handleViewPropertyChanged_, this); } this.render(); }; /** - * @param {goog.events.Event} event Event. + * @param {ol.events.Event} event Event. * @private */ ol.Map.prototype.handleLayerGroupMemberChanged_ = function(event) { - goog.asserts.assertInstanceof(event, goog.events.Event, + goog.asserts.assertInstanceof(event, ol.events.Event, 'event should be an Event'); this.render(); }; @@ -1148,18 +1165,18 @@ ol.Map.prototype.handleLayerGroupPropertyChanged_ = function(event) { */ ol.Map.prototype.handleLayerGroupChanged_ = function() { if (this.layerGroupPropertyListenerKeys_) { - this.layerGroupPropertyListenerKeys_.forEach(goog.events.unlistenByKey); + this.layerGroupPropertyListenerKeys_.forEach(ol.events.unlistenByKey); this.layerGroupPropertyListenerKeys_ = null; } var layerGroup = this.getLayerGroup(); if (layerGroup) { this.layerGroupPropertyListenerKeys_ = [ - goog.events.listen( + ol.events.listen( layerGroup, ol.ObjectEventType.PROPERTYCHANGE, - this.handleLayerGroupPropertyChanged_, false, this), - goog.events.listen( - layerGroup, goog.events.EventType.CHANGE, - this.handleLayerGroupMemberChanged_, false, this) + this.handleLayerGroupPropertyChanged_, this), + ol.events.listen( + layerGroup, ol.events.EventType.CHANGE, + this.handleLayerGroupMemberChanged_, this) ]; } this.render(); @@ -1204,7 +1221,10 @@ ol.Map.prototype.isRendered = function() { * @api stable */ ol.Map.prototype.renderSync = function() { - this.animationDelay_.fire(); + if (this.animationDelayKey_) { + goog.global.cancelAnimationFrame(this.animationDelayKey_); + } + this.animationDelay_(); }; @@ -1213,8 +1233,9 @@ ol.Map.prototype.renderSync = function() { * @api stable */ ol.Map.prototype.render = function() { - if (!this.animationDelay_.isActive()) { - this.animationDelay_.start(); + if (this.animationDelayKey_ === undefined) { + this.animationDelayKey_ = goog.global.requestAnimationFrame( + this.animationDelay_); } }; diff --git a/src/ol/mapbrowserevent.js b/src/ol/mapbrowserevent.js index 7ac9799128..f6eef67ffd 100644 --- a/src/ol/mapbrowserevent.js +++ b/src/ol/mapbrowserevent.js @@ -4,10 +4,9 @@ goog.provide('ol.MapBrowserEventHandler'); goog.provide('ol.MapBrowserPointerEvent'); goog.require('goog.asserts'); -goog.require('goog.events'); -goog.require('goog.events.BrowserEvent'); -goog.require('goog.events.EventTarget'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.EventTarget'); +goog.require('ol.events.EventType'); goog.require('goog.object'); goog.require('ol'); goog.require('ol.Coordinate'); @@ -27,7 +26,7 @@ goog.require('ol.pointer.PointerEventHandler'); * @implements {oli.MapBrowserEvent} * @param {string} type Event type. * @param {ol.Map} map Map. - * @param {goog.events.BrowserEvent} browserEvent Browser event. + * @param {Event} browserEvent Browser event. * @param {boolean=} opt_dragging Is the map currently being dragged? * @param {?olx.FrameState=} opt_frameState Frame state. */ @@ -36,26 +35,20 @@ ol.MapBrowserEvent = function(type, map, browserEvent, opt_dragging, goog.base(this, type, map, opt_frameState); - /** - * @const - * @type {goog.events.BrowserEvent} - */ - this.browserEvent = browserEvent; - /** * The original browser event. * @const * @type {Event} * @api stable */ - this.originalEvent = browserEvent.getBrowserEvent(); + this.originalEvent = browserEvent; /** * The pixel of the original browser event. * @type {ol.Pixel} * @api stable */ - this.pixel = map.getEventPixel(this.originalEvent); + this.pixel = map.getEventPixel(browserEvent); /** * The coordinate of the original browser event. @@ -85,7 +78,7 @@ goog.inherits(ol.MapBrowserEvent, ol.MapEvent); */ ol.MapBrowserEvent.prototype.preventDefault = function() { goog.base(this, 'preventDefault'); - this.browserEvent.preventDefault(); + this.originalEvent.preventDefault(); }; @@ -97,7 +90,7 @@ ol.MapBrowserEvent.prototype.preventDefault = function() { */ ol.MapBrowserEvent.prototype.stopPropagation = function() { goog.base(this, 'stopPropagation'); - this.browserEvent.stopPropagation(); + this.originalEvent.stopPropagation(); }; @@ -113,7 +106,7 @@ ol.MapBrowserEvent.prototype.stopPropagation = function() { ol.MapBrowserPointerEvent = function(type, map, pointerEvent, opt_dragging, opt_frameState) { - goog.base(this, type, map, pointerEvent.browserEvent, opt_dragging, + goog.base(this, type, map, pointerEvent.originalEvent, opt_dragging, opt_frameState); /** @@ -129,7 +122,7 @@ goog.inherits(ol.MapBrowserPointerEvent, ol.MapBrowserEvent); /** * @param {ol.Map} map The map with the viewport to listen to events on. * @constructor - * @extends {goog.events.EventTarget} + * @extends {ol.events.EventTarget} */ ol.MapBrowserEventHandler = function(map) { @@ -155,13 +148,13 @@ ol.MapBrowserEventHandler = function(map) { this.dragging_ = false; /** - * @type {Array.} + * @type {Array.} * @private */ this.dragListenerKeys_ = null; /** - * @type {goog.events.Key} + * @type {?ol.events.Key} * @private */ this.pointerdownListenerKey_ = null; @@ -206,16 +199,16 @@ ol.MapBrowserEventHandler = function(map) { */ this.documentPointerEventHandler_ = null; - this.pointerdownListenerKey_ = goog.events.listen(this.pointerEventHandler_, + this.pointerdownListenerKey_ = ol.events.listen(this.pointerEventHandler_, ol.pointer.EventType.POINTERDOWN, - this.handlePointerDown_, false, this); + this.handlePointerDown_, this); - this.relayedListenerKey_ = goog.events.listen(this.pointerEventHandler_, + this.relayedListenerKey_ = ol.events.listen(this.pointerEventHandler_, ol.pointer.EventType.POINTERMOVE, - this.relayEvent_, false, this); + this.relayEvent_, this); }; -goog.inherits(ol.MapBrowserEventHandler, goog.events.EventTarget); +goog.inherits(ol.MapBrowserEventHandler, ol.events.EventTarget); /** @@ -287,7 +280,7 @@ ol.MapBrowserEventHandler.prototype.handlePointerUp_ = function(pointerEvent) { goog.asserts.assert(this.activePointers_ >= 0, 'this.activePointers_ should be equal to or larger than 0'); if (this.activePointers_ === 0) { - this.dragListenerKeys_.forEach(goog.events.unlistenByKey); + this.dragListenerKeys_.forEach(ol.events.unlistenByKey); this.dragListenerKeys_ = null; this.dragging_ = false; this.down_ = null; @@ -328,12 +321,12 @@ ol.MapBrowserEventHandler.prototype.handlePointerDown_ = function(pointerEvent) new ol.pointer.PointerEventHandler(document); this.dragListenerKeys_ = [ - goog.events.listen(this.documentPointerEventHandler_, + ol.events.listen(this.documentPointerEventHandler_, ol.MapBrowserEvent.EventType.POINTERMOVE, - this.handlePointerMove_, false, this), - goog.events.listen(this.documentPointerEventHandler_, + this.handlePointerMove_, this), + ol.events.listen(this.documentPointerEventHandler_, ol.MapBrowserEvent.EventType.POINTERUP, - this.handlePointerUp_, false, this), + this.handlePointerUp_, this), /* Note that the listener for `pointercancel is set up on * `pointerEventHandler_` and not `documentPointerEventHandler_` like * the `pointerup` and `pointermove` listeners. @@ -347,9 +340,9 @@ ol.MapBrowserEventHandler.prototype.handlePointerDown_ = function(pointerEvent) * only receive a `touchcancel` from `pointerEventHandler_`, because it is * only registered there. */ - goog.events.listen(this.pointerEventHandler_, + ol.events.listen(this.pointerEventHandler_, ol.MapBrowserEvent.EventType.POINTERCANCEL, - this.handlePointerUp_, false, this) + this.handlePointerUp_, this) ]; } }; @@ -410,15 +403,15 @@ ol.MapBrowserEventHandler.prototype.isMoving_ = function(pointerEvent) { */ ol.MapBrowserEventHandler.prototype.disposeInternal = function() { if (this.relayedListenerKey_) { - goog.events.unlistenByKey(this.relayedListenerKey_); + ol.events.unlistenByKey(this.relayedListenerKey_); this.relayedListenerKey_ = null; } if (this.pointerdownListenerKey_) { - goog.events.unlistenByKey(this.pointerdownListenerKey_); + ol.events.unlistenByKey(this.pointerdownListenerKey_); this.pointerdownListenerKey_ = null; } if (this.dragListenerKeys_) { - this.dragListenerKeys_.forEach(goog.events.unlistenByKey); + this.dragListenerKeys_.forEach(ol.events.unlistenByKey); this.dragListenerKeys_ = null; } if (this.documentPointerEventHandler_) { @@ -452,14 +445,14 @@ ol.MapBrowserEvent.EventType = { * @event ol.MapBrowserEvent#click * @api stable */ - CLICK: goog.events.EventType.CLICK, + CLICK: ol.events.EventType.CLICK, /** * A true double click, with no dragging. * @event ol.MapBrowserEvent#dblclick * @api stable */ - DBLCLICK: goog.events.EventType.DBLCLICK, + DBLCLICK: ol.events.EventType.DBLCLICK, /** * Triggered when a pointer is dragged. diff --git a/src/ol/mapevent.js b/src/ol/mapevent.js index 5e7931acae..0f4bf981ce 100644 --- a/src/ol/mapevent.js +++ b/src/ol/mapevent.js @@ -1,7 +1,7 @@ goog.provide('ol.MapEvent'); goog.provide('ol.MapEventType'); -goog.require('goog.events.Event'); +goog.require('ol.events.Event'); /** @@ -32,7 +32,7 @@ ol.MapEventType = { * See {@link ol.Map} for which events trigger a map event. * * @constructor - * @extends {goog.events.Event} + * @extends {ol.events.Event} * @implements {oli.MapEvent} * @param {string} type Event type. * @param {ol.Map} map Map. @@ -57,4 +57,4 @@ ol.MapEvent = function(type, map, opt_frameState) { this.frameState = opt_frameState !== undefined ? opt_frameState : null; }; -goog.inherits(ol.MapEvent, goog.events.Event); +goog.inherits(ol.MapEvent, ol.events.Event); diff --git a/src/ol/net.js b/src/ol/net.js new file mode 100644 index 0000000000..1cbcc32457 --- /dev/null +++ b/src/ol/net.js @@ -0,0 +1,37 @@ +goog.provide('ol.net'); + + +/** + * Simple JSONP helper. Supports error callbacks and a custom callback param. + * The error callback will be called when no JSONP is executed after 10 seconds. + * + * @param {string} url Request url. A 'callback' query parameter will be + * appended. + * @param {Function} callback Callback on success. + * @param {function()=} opt_errback Callback on error. + * @param {string=} opt_callbackParam Custom qurey parameter for the JSONP + * callback. Default is 'callback'. + */ +ol.net.jsonp = function(url, callback, opt_errback, opt_callbackParam) { + var script = goog.global.document.createElement('script'); + var key = 'olc_' + goog.getUid(callback); + function cleanup() { + delete goog.global[key]; + script.parentNode.removeChild(script); + } + script.async = true; + script.src = url + (url.indexOf('?') == -1 ? '?' : '&') + + (opt_callbackParam || 'callback') + '=' + key; + var timer = goog.global.setTimeout(function() { + cleanup(); + if (opt_errback) { + opt_errback(); + } + }, 10000); + goog.global[key] = function(data) { + goog.global.clearTimeout(timer); + cleanup(); + callback(data); + }; + goog.global.document.getElementsByTagName('head')[0].appendChild(script); +}; diff --git a/src/ol/object.js b/src/ol/object.js index ae5b7ca72f..363e7d4b17 100644 --- a/src/ol/object.js +++ b/src/ol/object.js @@ -2,8 +2,8 @@ goog.provide('ol.Object'); goog.provide('ol.ObjectEvent'); goog.provide('ol.ObjectEventType'); -goog.require('goog.events'); -goog.require('goog.events.Event'); +goog.require('ol.events'); +goog.require('ol.events.Event'); goog.require('ol.Observable'); @@ -27,7 +27,7 @@ ol.ObjectEventType = { * @param {string} type The event type. * @param {string} key The property name. * @param {*} oldValue The old value for `key`. - * @extends {goog.events.Event} + * @extends {ol.events.Event} * @implements {oli.ObjectEvent} * @constructor */ @@ -50,7 +50,7 @@ ol.ObjectEvent = function(type, key, oldValue) { this.oldValue = oldValue; }; -goog.inherits(ol.ObjectEvent, goog.events.Event); +goog.inherits(ol.ObjectEvent, ol.events.Event); /** diff --git a/src/ol/observable.js b/src/ol/observable.js index fec983f2d6..70563e5991 100644 --- a/src/ol/observable.js +++ b/src/ol/observable.js @@ -1,8 +1,8 @@ goog.provide('ol.Observable'); -goog.require('goog.events'); -goog.require('goog.events.EventTarget'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.EventTarget'); +goog.require('ol.events.EventType'); /** @@ -14,7 +14,7 @@ goog.require('goog.events.EventType'); * {@link ol.Observable#changed}. * * @constructor - * @extends {goog.events.EventTarget} + * @extends {ol.events.EventTarget} * @fires change * @struct * @api stable @@ -30,16 +30,23 @@ ol.Observable = function() { this.revision_ = 0; }; -goog.inherits(ol.Observable, goog.events.EventTarget); +goog.inherits(ol.Observable, ol.events.EventTarget); /** * Removes an event listener using the key returned by `on()` or `once()`. - * @param {goog.events.Key} key The key returned by `on()` or `once()`. + * @param {ol.events.Key|Array.} key The key returned by `on()` + * or `once()` (or an array of keys). * @api stable */ ol.Observable.unByKey = function(key) { - goog.events.unlistenByKey(key); + if (Array.isArray(key)) { + for (var i = 0, ii = key.length; i < ii; ++i) { + ol.events.unlistenByKey(key[i]); + } + } else { + ol.events.unlistenByKey(/** @type {ol.events.Key} */ (key)); + } }; @@ -49,7 +56,7 @@ ol.Observable.unByKey = function(key) { */ ol.Observable.prototype.changed = function() { ++this.revision_; - this.dispatchEvent(goog.events.EventType.CHANGE); + this.dispatchEvent(ol.events.EventType.CHANGE); }; @@ -65,7 +72,9 @@ ol.Observable.prototype.changed = function() { * of this type. The event parameter can either be a string or an * Object with a `type` property. * - * @param {goog.events.EventLike} event Event object. + * @param {{type: string, + * target: (EventTarget|ol.events.EventTarget|undefined)}|ol.events.Event| + * string} event Event object. * @function * @api */ @@ -88,11 +97,23 @@ ol.Observable.prototype.getRevision = function() { * @param {string|Array.} type The event type or array of event types. * @param {function(?): ?} listener The listener function. * @param {Object=} opt_this The object to use as `this` in `listener`. - * @return {goog.events.Key} Unique key for the listener. + * @return {ol.events.Key|Array.} Unique key for the listener. If + * called with an array of event types as the first argument, the return + * will be an array of keys. * @api stable */ ol.Observable.prototype.on = function(type, listener, opt_this) { - return goog.events.listen(this, type, listener, false, opt_this); + if (Array.isArray(type)) { + var len = type.length; + var keys = new Array(len); + for (var i = 0; i < len; ++i) { + keys[i] = ol.events.listen(this, type[i], listener, opt_this); + } + return keys; + } else { + return ol.events.listen( + this, /** @type {string} */ (type), listener, opt_this); + } }; @@ -101,11 +122,23 @@ ol.Observable.prototype.on = function(type, listener, opt_this) { * @param {string|Array.} type The event type or array of event types. * @param {function(?): ?} listener The listener function. * @param {Object=} opt_this The object to use as `this` in `listener`. - * @return {goog.events.Key} Unique key for the listener. + * @return {ol.events.Key|Array.} Unique key for the listener. If + * called with an array of event types as the first argument, the return + * will be an array of keys. * @api stable */ ol.Observable.prototype.once = function(type, listener, opt_this) { - return goog.events.listenOnce(this, type, listener, false, opt_this); + if (Array.isArray(type)) { + var len = type.length; + var keys = new Array(len); + for (var i = 0; i < len; ++i) { + keys[i] = ol.events.listenOnce(this, type[i], listener, opt_this); + } + return keys; + } else { + return ol.events.listenOnce( + this, /** @type {string} */ (type), listener, opt_this); + } }; @@ -118,7 +151,14 @@ ol.Observable.prototype.once = function(type, listener, opt_this) { * @api stable */ ol.Observable.prototype.un = function(type, listener, opt_this) { - goog.events.unlisten(this, type, listener, false, opt_this); + if (Array.isArray(type)) { + for (var i = 0, ii = type.length; i < ii; ++i) { + ol.events.unlisten(this, type[i], listener, opt_this); + } + return; + } else { + ol.events.unlisten(this, /** @type {string} */ (type), listener, opt_this); + } }; @@ -126,7 +166,8 @@ ol.Observable.prototype.un = function(type, listener, opt_this) { * Removes an event listener using the key returned by `on()` or `once()`. * Note that using the {@link ol.Observable.unByKey} static function is to * be preferred. - * @param {goog.events.Key} key The key returned by `on()` or `once()`. + * @param {ol.events.Key|Array.} key The key returned by `on()` + * or `once()` (or an array of keys). * @function * @api stable */ diff --git a/src/ol/overlay.js b/src/ol/overlay.js index c0e0f8c9d0..1fdd1aa9d1 100644 --- a/src/ol/overlay.js +++ b/src/ol/overlay.js @@ -4,7 +4,7 @@ goog.provide('ol.OverlayProperty'); goog.require('goog.asserts'); goog.require('goog.dom'); -goog.require('goog.events'); +goog.require('ol.events'); goog.require('goog.style'); goog.require('ol.Coordinate'); goog.require('ol.Map'); @@ -137,29 +137,29 @@ ol.Overlay = function(options) { /** * @private - * @type {goog.events.Key} + * @type {?ol.events.Key} */ this.mapPostrenderListenerKey_ = null; - goog.events.listen( + ol.events.listen( this, ol.Object.getChangeEventType(ol.OverlayProperty.ELEMENT), - this.handleElementChanged, false, this); + this.handleElementChanged, this); - goog.events.listen( + ol.events.listen( this, ol.Object.getChangeEventType(ol.OverlayProperty.MAP), - this.handleMapChanged, false, this); + this.handleMapChanged, this); - goog.events.listen( + ol.events.listen( this, ol.Object.getChangeEventType(ol.OverlayProperty.OFFSET), - this.handleOffsetChanged, false, this); + this.handleOffsetChanged, this); - goog.events.listen( + ol.events.listen( this, ol.Object.getChangeEventType(ol.OverlayProperty.POSITION), - this.handlePositionChanged, false, this); + this.handlePositionChanged, this); - goog.events.listen( + ol.events.listen( this, ol.Object.getChangeEventType(ol.OverlayProperty.POSITIONING), - this.handlePositioningChanged, false, this); + this.handlePositioningChanged, this); if (options.element !== undefined) { this.setElement(options.element); @@ -269,13 +269,13 @@ ol.Overlay.prototype.handleElementChanged = function() { ol.Overlay.prototype.handleMapChanged = function() { if (this.mapPostrenderListenerKey_) { goog.dom.removeNode(this.element_); - goog.events.unlistenByKey(this.mapPostrenderListenerKey_); + ol.events.unlistenByKey(this.mapPostrenderListenerKey_); this.mapPostrenderListenerKey_ = null; } var map = this.getMap(); if (map) { - this.mapPostrenderListenerKey_ = goog.events.listen(map, - ol.MapEventType.POSTRENDER, this.render, false, this); + this.mapPostrenderListenerKey_ = ol.events.listen(map, + ol.MapEventType.POSTRENDER, this.render, this); this.updatePixelPosition(); var container = this.stopEvent_ ? map.getOverlayContainerStopEvent() : map.getOverlayContainer(); diff --git a/src/ol/pointer/eventsource.js b/src/ol/pointer/eventsource.js index 96282b7712..93cb8527e1 100644 --- a/src/ol/pointer/eventsource.js +++ b/src/ol/pointer/eventsource.js @@ -1,11 +1,9 @@ goog.provide('ol.pointer.EventSource'); -goog.require('goog.events.BrowserEvent'); - /** * @param {ol.pointer.PointerEventHandler} dispatcher Event handler. - * @param {!Object.} mapping Event + * @param {!Object.} mapping Event * mapping. * @constructor */ @@ -18,7 +16,7 @@ ol.pointer.EventSource = function(dispatcher, mapping) { /** * @private * @const - * @type {!Object.} + * @type {!Object.} */ this.mapping_ = mapping; }; @@ -36,7 +34,7 @@ ol.pointer.EventSource.prototype.getEvents = function() { /** * Returns a mapping between the supported event types and * the handlers that should handle an event. - * @return {Object.} + * @return {Object.} * Event/Handler mapping */ ol.pointer.EventSource.prototype.getMapping = function() { @@ -47,7 +45,7 @@ ol.pointer.EventSource.prototype.getMapping = function() { /** * Returns the handler that should handle a given event type. * @param {string} eventType The event type. - * @return {function(goog.events.BrowserEvent)} Handler + * @return {function(Event)} Handler */ ol.pointer.EventSource.prototype.getHandlerForEvent = function(eventType) { return this.mapping_[eventType]; diff --git a/src/ol/pointer/mousesource.js b/src/ol/pointer/mousesource.js index 6bfa58e834..8cf03ad081 100644 --- a/src/ol/pointer/mousesource.js +++ b/src/ol/pointer/mousesource.js @@ -50,7 +50,7 @@ ol.pointer.MouseSource = function(dispatcher) { /** * @const - * @type {!Object.} + * @type {!Object.} */ this.pointerMap = dispatcher.pointerMap; @@ -107,7 +107,7 @@ ol.pointer.MouseSource.DEDUP_DIST = 25; * or detect that the positions are invalid. * * @private - * @param {goog.events.BrowserEvent} inEvent The in event. + * @param {Event} inEvent The in event. * @return {boolean} True, if the event was generated by a touch. */ ol.pointer.MouseSource.prototype.isEventSimulatedFromTouch_ = function(inEvent) { @@ -129,12 +129,12 @@ ol.pointer.MouseSource.prototype.isEventSimulatedFromTouch_ = function(inEvent) * Creates a copy of the original event that will be used * for the fake pointer event. * - * @param {goog.events.BrowserEvent} inEvent The in event. + * @param {Event} inEvent The in event. * @param {ol.pointer.PointerEventHandler} dispatcher Event handler. * @return {Object} The copied event. */ ol.pointer.MouseSource.prepareEvent = function(inEvent, dispatcher) { - var e = dispatcher.cloneEvent(inEvent, inEvent.getBrowserEvent()); + var e = dispatcher.cloneEvent(inEvent, inEvent); // forward mouse preventDefault var pd = e.preventDefault; @@ -154,7 +154,7 @@ ol.pointer.MouseSource.prepareEvent = function(inEvent, dispatcher) { /** * Handler for `mousedown`. * - * @param {goog.events.BrowserEvent} inEvent The in event. + * @param {Event} inEvent The in event. */ ol.pointer.MouseSource.prototype.mousedown = function(inEvent) { if (!this.isEventSimulatedFromTouch_(inEvent)) { @@ -173,7 +173,7 @@ ol.pointer.MouseSource.prototype.mousedown = function(inEvent) { /** * Handler for `mousemove`. * - * @param {goog.events.BrowserEvent} inEvent The in event. + * @param {Event} inEvent The in event. */ ol.pointer.MouseSource.prototype.mousemove = function(inEvent) { if (!this.isEventSimulatedFromTouch_(inEvent)) { @@ -186,7 +186,7 @@ ol.pointer.MouseSource.prototype.mousemove = function(inEvent) { /** * Handler for `mouseup`. * - * @param {goog.events.BrowserEvent} inEvent The in event. + * @param {Event} inEvent The in event. */ ol.pointer.MouseSource.prototype.mouseup = function(inEvent) { if (!this.isEventSimulatedFromTouch_(inEvent)) { @@ -204,7 +204,7 @@ ol.pointer.MouseSource.prototype.mouseup = function(inEvent) { /** * Handler for `mouseover`. * - * @param {goog.events.BrowserEvent} inEvent The in event. + * @param {Event} inEvent The in event. */ ol.pointer.MouseSource.prototype.mouseover = function(inEvent) { if (!this.isEventSimulatedFromTouch_(inEvent)) { @@ -217,7 +217,7 @@ ol.pointer.MouseSource.prototype.mouseover = function(inEvent) { /** * Handler for `mouseout`. * - * @param {goog.events.BrowserEvent} inEvent The in event. + * @param {Event} inEvent The in event. */ ol.pointer.MouseSource.prototype.mouseout = function(inEvent) { if (!this.isEventSimulatedFromTouch_(inEvent)) { @@ -230,7 +230,7 @@ ol.pointer.MouseSource.prototype.mouseout = function(inEvent) { /** * Dispatches a `pointercancel` event. * - * @param {goog.events.BrowserEvent} inEvent The in event. + * @param {Event} inEvent The in event. */ ol.pointer.MouseSource.prototype.cancel = function(inEvent) { var e = ol.pointer.MouseSource.prepareEvent(inEvent, this.dispatcher); diff --git a/src/ol/pointer/mssource.js b/src/ol/pointer/mssource.js index 379af662e7..2a72f37df5 100644 --- a/src/ol/pointer/mssource.js +++ b/src/ol/pointer/mssource.js @@ -53,7 +53,7 @@ ol.pointer.MsSource = function(dispatcher) { /** * @const - * @type {!Object.} + * @type {!Object.} */ this.pointerMap = dispatcher.pointerMap; @@ -77,14 +77,14 @@ goog.inherits(ol.pointer.MsSource, ol.pointer.EventSource); * for the fake pointer event. * * @private - * @param {goog.events.BrowserEvent} inEvent The in event. + * @param {Event} inEvent The in event. * @return {Object} The copied event. */ ol.pointer.MsSource.prototype.prepareEvent_ = function(inEvent) { var e = inEvent; - if (goog.isNumber(inEvent.getBrowserEvent().pointerType)) { - e = this.dispatcher.cloneEvent(inEvent, inEvent.getBrowserEvent()); - e.pointerType = this.POINTER_TYPES[inEvent.getBrowserEvent().pointerType]; + if (goog.isNumber(inEvent.pointerType)) { + e = this.dispatcher.cloneEvent(inEvent, inEvent); + e.pointerType = this.POINTER_TYPES[inEvent.pointerType]; } return e; @@ -103,10 +103,10 @@ ol.pointer.MsSource.prototype.cleanup = function(pointerId) { /** * Handler for `msPointerDown`. * - * @param {goog.events.BrowserEvent} inEvent The in event. + * @param {Event} inEvent The in event. */ ol.pointer.MsSource.prototype.msPointerDown = function(inEvent) { - this.pointerMap[inEvent.getBrowserEvent().pointerId.toString()] = inEvent; + this.pointerMap[inEvent.pointerId.toString()] = inEvent; var e = this.prepareEvent_(inEvent); this.dispatcher.down(e, inEvent); }; @@ -115,7 +115,7 @@ ol.pointer.MsSource.prototype.msPointerDown = function(inEvent) { /** * Handler for `msPointerMove`. * - * @param {goog.events.BrowserEvent} inEvent The in event. + * @param {Event} inEvent The in event. */ ol.pointer.MsSource.prototype.msPointerMove = function(inEvent) { var e = this.prepareEvent_(inEvent); @@ -126,19 +126,19 @@ ol.pointer.MsSource.prototype.msPointerMove = function(inEvent) { /** * Handler for `msPointerUp`. * - * @param {goog.events.BrowserEvent} inEvent The in event. + * @param {Event} inEvent The in event. */ ol.pointer.MsSource.prototype.msPointerUp = function(inEvent) { var e = this.prepareEvent_(inEvent); this.dispatcher.up(e, inEvent); - this.cleanup(inEvent.getBrowserEvent().pointerId); + this.cleanup(inEvent.pointerId); }; /** * Handler for `msPointerOut`. * - * @param {goog.events.BrowserEvent} inEvent The in event. + * @param {Event} inEvent The in event. */ ol.pointer.MsSource.prototype.msPointerOut = function(inEvent) { var e = this.prepareEvent_(inEvent); @@ -149,7 +149,7 @@ ol.pointer.MsSource.prototype.msPointerOut = function(inEvent) { /** * Handler for `msPointerOver`. * - * @param {goog.events.BrowserEvent} inEvent The in event. + * @param {Event} inEvent The in event. */ ol.pointer.MsSource.prototype.msPointerOver = function(inEvent) { var e = this.prepareEvent_(inEvent); @@ -160,23 +160,23 @@ ol.pointer.MsSource.prototype.msPointerOver = function(inEvent) { /** * Handler for `msPointerCancel`. * - * @param {goog.events.BrowserEvent} inEvent The in event. + * @param {Event} inEvent The in event. */ ol.pointer.MsSource.prototype.msPointerCancel = function(inEvent) { var e = this.prepareEvent_(inEvent); this.dispatcher.cancel(e, inEvent); - this.cleanup(inEvent.getBrowserEvent().pointerId); + this.cleanup(inEvent.pointerId); }; /** * Handler for `msLostPointerCapture`. * - * @param {goog.events.BrowserEvent} inEvent The in event. + * @param {Event} inEvent The in event. */ ol.pointer.MsSource.prototype.msLostPointerCapture = function(inEvent) { var e = this.dispatcher.makeEvent('lostpointercapture', - inEvent.getBrowserEvent(), inEvent); + inEvent, inEvent); this.dispatcher.dispatchEvent(e); }; @@ -184,10 +184,10 @@ ol.pointer.MsSource.prototype.msLostPointerCapture = function(inEvent) { /** * Handler for `msGotPointerCapture`. * - * @param {goog.events.BrowserEvent} inEvent The in event. + * @param {Event} inEvent The in event. */ ol.pointer.MsSource.prototype.msGotPointerCapture = function(inEvent) { var e = this.dispatcher.makeEvent('gotpointercapture', - inEvent.getBrowserEvent(), inEvent); + inEvent, inEvent); this.dispatcher.dispatchEvent(e); }; diff --git a/src/ol/pointer/nativesource.js b/src/ol/pointer/nativesource.js index a453eb3840..be9218891b 100644 --- a/src/ol/pointer/nativesource.js +++ b/src/ol/pointer/nativesource.js @@ -57,7 +57,7 @@ goog.inherits(ol.pointer.NativeSource, ol.pointer.EventSource); /** * Handler for `pointerdown`. * - * @param {goog.events.BrowserEvent} inEvent The in event. + * @param {Event} inEvent The in event. */ ol.pointer.NativeSource.prototype.pointerDown = function(inEvent) { this.dispatcher.fireNativeEvent(inEvent); @@ -67,7 +67,7 @@ ol.pointer.NativeSource.prototype.pointerDown = function(inEvent) { /** * Handler for `pointermove`. * - * @param {goog.events.BrowserEvent} inEvent The in event. + * @param {Event} inEvent The in event. */ ol.pointer.NativeSource.prototype.pointerMove = function(inEvent) { this.dispatcher.fireNativeEvent(inEvent); @@ -77,7 +77,7 @@ ol.pointer.NativeSource.prototype.pointerMove = function(inEvent) { /** * Handler for `pointerup`. * - * @param {goog.events.BrowserEvent} inEvent The in event. + * @param {Event} inEvent The in event. */ ol.pointer.NativeSource.prototype.pointerUp = function(inEvent) { this.dispatcher.fireNativeEvent(inEvent); @@ -87,7 +87,7 @@ ol.pointer.NativeSource.prototype.pointerUp = function(inEvent) { /** * Handler for `pointerout`. * - * @param {goog.events.BrowserEvent} inEvent The in event. + * @param {Event} inEvent The in event. */ ol.pointer.NativeSource.prototype.pointerOut = function(inEvent) { this.dispatcher.fireNativeEvent(inEvent); @@ -97,7 +97,7 @@ ol.pointer.NativeSource.prototype.pointerOut = function(inEvent) { /** * Handler for `pointerover`. * - * @param {goog.events.BrowserEvent} inEvent The in event. + * @param {Event} inEvent The in event. */ ol.pointer.NativeSource.prototype.pointerOver = function(inEvent) { this.dispatcher.fireNativeEvent(inEvent); @@ -107,7 +107,7 @@ ol.pointer.NativeSource.prototype.pointerOver = function(inEvent) { /** * Handler for `pointercancel`. * - * @param {goog.events.BrowserEvent} inEvent The in event. + * @param {Event} inEvent The in event. */ ol.pointer.NativeSource.prototype.pointerCancel = function(inEvent) { this.dispatcher.fireNativeEvent(inEvent); @@ -117,7 +117,7 @@ ol.pointer.NativeSource.prototype.pointerCancel = function(inEvent) { /** * Handler for `lostpointercapture`. * - * @param {goog.events.BrowserEvent} inEvent The in event. + * @param {Event} inEvent The in event. */ ol.pointer.NativeSource.prototype.lostPointerCapture = function(inEvent) { this.dispatcher.fireNativeEvent(inEvent); @@ -127,7 +127,7 @@ ol.pointer.NativeSource.prototype.lostPointerCapture = function(inEvent) { /** * Handler for `gotpointercapture`. * - * @param {goog.events.BrowserEvent} inEvent The in event. + * @param {Event} inEvent The in event. */ ol.pointer.NativeSource.prototype.gotPointerCapture = function(inEvent) { this.dispatcher.fireNativeEvent(inEvent); diff --git a/src/ol/pointer/pointerevent.js b/src/ol/pointer/pointerevent.js index 767e25af9c..b0608c167b 100644 --- a/src/ol/pointer/pointerevent.js +++ b/src/ol/pointer/pointerevent.js @@ -31,8 +31,8 @@ goog.provide('ol.pointer.PointerEvent'); -goog.require('goog.events'); -goog.require('goog.events.Event'); +goog.require('ol.events'); +goog.require('ol.events.Event'); /** @@ -42,20 +42,20 @@ goog.require('goog.events.Event'); * touch events and even native pointer events. * * @constructor - * @extends {goog.events.Event} + * @extends {ol.events.Event} * @param {string} type The type of the event to create. - * @param {goog.events.BrowserEvent} browserEvent The event. + * @param {Event} originalEvent The event. * @param {Object.=} opt_eventDict An optional dictionary of * initial event properties. */ -ol.pointer.PointerEvent = function(type, browserEvent, opt_eventDict) { +ol.pointer.PointerEvent = function(type, originalEvent, opt_eventDict) { goog.base(this, type); /** * @const - * @type {goog.events.BrowserEvent} + * @type {Event} */ - this.browserEvent = browserEvent; + this.originalEvent = originalEvent; var eventDict = opt_eventDict ? opt_eventDict : {}; @@ -186,13 +186,13 @@ ol.pointer.PointerEvent = function(type, browserEvent, opt_eventDict) { this.isPrimary = 'isPrimary' in eventDict ? eventDict['isPrimary'] : false; // keep the semantics of preventDefault - if (browserEvent.preventDefault) { + if (originalEvent.preventDefault) { this.preventDefault = function() { - browserEvent.preventDefault(); + originalEvent.preventDefault(); }; } }; -goog.inherits(ol.pointer.PointerEvent, goog.events.Event); +goog.inherits(ol.pointer.PointerEvent, ol.events.Event); /** diff --git a/src/ol/pointer/pointereventhandler.js b/src/ol/pointer/pointereventhandler.js index 83fddca587..e49be24df5 100644 --- a/src/ol/pointer/pointereventhandler.js +++ b/src/ol/pointer/pointereventhandler.js @@ -31,9 +31,8 @@ goog.provide('ol.pointer.PointerEventHandler'); goog.require('goog.dom'); -goog.require('goog.events'); -goog.require('goog.events.BrowserEvent'); -goog.require('goog.events.EventTarget'); +goog.require('ol.events'); +goog.require('ol.events.EventTarget'); goog.require('ol.has'); goog.require('ol.pointer.MouseSource'); @@ -45,7 +44,7 @@ goog.require('ol.pointer.TouchSource'); /** * @constructor - * @extends {goog.events.EventTarget} + * @extends {ol.events.EventTarget} * @param {Element|HTMLDocument} element Viewport element. */ ol.pointer.PointerEventHandler = function(element) { @@ -60,12 +59,12 @@ ol.pointer.PointerEventHandler = function(element) { /** * @const - * @type {!Object.} + * @type {!Object.} */ this.pointerMap = {}; /** - * @type {Object.} + * @type {Object.} * @private */ this.eventMap_ = {}; @@ -78,7 +77,7 @@ ol.pointer.PointerEventHandler = function(element) { this.registerSources(); }; -goog.inherits(ol.pointer.PointerEventHandler, goog.events.EventTarget); +goog.inherits(ol.pointer.PointerEventHandler, ol.events.EventTarget); /** @@ -159,7 +158,7 @@ ol.pointer.PointerEventHandler.prototype.unregister_ = function() { /** * Calls the right handler for a new event. * @private - * @param {goog.events.BrowserEvent} inEvent Browser event. + * @param {Event} inEvent Browser event. */ ol.pointer.PointerEventHandler.prototype.eventHandler_ = function(inEvent) { var type = inEvent.type; @@ -177,8 +176,7 @@ ol.pointer.PointerEventHandler.prototype.eventHandler_ = function(inEvent) { */ ol.pointer.PointerEventHandler.prototype.addEvents_ = function(events) { events.forEach(function(eventName) { - goog.events.listen(this.element_, eventName, - this.eventHandler_, false, this); + ol.events.listen(this.element_, eventName, this.eventHandler_, this); }, this); }; @@ -190,8 +188,7 @@ ol.pointer.PointerEventHandler.prototype.addEvents_ = function(events) { */ ol.pointer.PointerEventHandler.prototype.removeEvents_ = function(events) { events.forEach(function(e) { - goog.events.unlisten(this.element_, e, - this.eventHandler_, false, this); + ol.events.unlisten(this.element_, e, this.eventHandler_, this); }, this); }; @@ -199,20 +196,17 @@ ol.pointer.PointerEventHandler.prototype.removeEvents_ = function(events) { /** * Returns a snapshot of inEvent, with writable properties. * - * @param {goog.events.BrowserEvent} browserEvent Browser event. + * @param {Event} event Browser event. * @param {Event|Touch} inEvent An event that contains * properties to copy. * @return {Object} An object containing shallow copies of * `inEvent`'s properties. */ -ol.pointer.PointerEventHandler.prototype.cloneEvent = function(browserEvent, inEvent) { +ol.pointer.PointerEventHandler.prototype.cloneEvent = function(event, inEvent) { var eventCopy = {}, p; for (var i = 0, ii = ol.pointer.CLONE_PROPS.length; i < ii; i++) { p = ol.pointer.CLONE_PROPS[i][0]; - eventCopy[p] = - browserEvent[p] || - inEvent[p] || - ol.pointer.CLONE_PROPS[i][1]; + eventCopy[p] = event[p] || inEvent[p] || ol.pointer.CLONE_PROPS[i][1]; } return eventCopy; @@ -224,122 +218,110 @@ ol.pointer.PointerEventHandler.prototype.cloneEvent = function(browserEvent, inE /** * Triggers a 'pointerdown' event. - * @param {Object} pointerEventData Pointer event data. - * @param {goog.events.BrowserEvent} browserEvent The event. + * @param {Object} data Pointer event data. + * @param {Event} event The event. */ -ol.pointer.PointerEventHandler.prototype.down = function(pointerEventData, browserEvent) { - this.fireEvent(ol.pointer.EventType.POINTERDOWN, - pointerEventData, browserEvent); +ol.pointer.PointerEventHandler.prototype.down = function(data, event) { + this.fireEvent(ol.pointer.EventType.POINTERDOWN, data, event); }; /** * Triggers a 'pointermove' event. - * @param {Object} pointerEventData Pointer event data. - * @param {goog.events.BrowserEvent} browserEvent The event. + * @param {Object} data Pointer event data. + * @param {Event} event The event. */ -ol.pointer.PointerEventHandler.prototype.move = function(pointerEventData, browserEvent) { - this.fireEvent(ol.pointer.EventType.POINTERMOVE, - pointerEventData, browserEvent); +ol.pointer.PointerEventHandler.prototype.move = function(data, event) { + this.fireEvent(ol.pointer.EventType.POINTERMOVE, data, event); }; /** * Triggers a 'pointerup' event. - * @param {Object} pointerEventData Pointer event data. - * @param {goog.events.BrowserEvent} browserEvent The event. + * @param {Object} data Pointer event data. + * @param {Event} event The event. */ -ol.pointer.PointerEventHandler.prototype.up = function(pointerEventData, browserEvent) { - this.fireEvent(ol.pointer.EventType.POINTERUP, - pointerEventData, browserEvent); +ol.pointer.PointerEventHandler.prototype.up = function(data, event) { + this.fireEvent(ol.pointer.EventType.POINTERUP, data, event); }; /** * Triggers a 'pointerenter' event. - * @param {Object} pointerEventData Pointer event data. - * @param {goog.events.BrowserEvent} browserEvent The event. + * @param {Object} data Pointer event data. + * @param {Event} event The event. */ -ol.pointer.PointerEventHandler.prototype.enter = function(pointerEventData, browserEvent) { - pointerEventData.bubbles = false; - this.fireEvent(ol.pointer.EventType.POINTERENTER, - pointerEventData, browserEvent); +ol.pointer.PointerEventHandler.prototype.enter = function(data, event) { + data.bubbles = false; + this.fireEvent(ol.pointer.EventType.POINTERENTER, data, event); }; /** * Triggers a 'pointerleave' event. - * @param {Object} pointerEventData Pointer event data. - * @param {goog.events.BrowserEvent} browserEvent The event. + * @param {Object} data Pointer event data. + * @param {Event} event The event. */ -ol.pointer.PointerEventHandler.prototype.leave = function(pointerEventData, browserEvent) { - pointerEventData.bubbles = false; - this.fireEvent(ol.pointer.EventType.POINTERLEAVE, - pointerEventData, browserEvent); +ol.pointer.PointerEventHandler.prototype.leave = function(data, event) { + data.bubbles = false; + this.fireEvent(ol.pointer.EventType.POINTERLEAVE, data, event); }; /** * Triggers a 'pointerover' event. - * @param {Object} pointerEventData Pointer event data. - * @param {goog.events.BrowserEvent} browserEvent The event. + * @param {Object} data Pointer event data. + * @param {Event} event The event. */ -ol.pointer.PointerEventHandler.prototype.over = function(pointerEventData, browserEvent) { - pointerEventData.bubbles = true; - this.fireEvent(ol.pointer.EventType.POINTEROVER, - pointerEventData, browserEvent); +ol.pointer.PointerEventHandler.prototype.over = function(data, event) { + data.bubbles = true; + this.fireEvent(ol.pointer.EventType.POINTEROVER, data, event); }; /** * Triggers a 'pointerout' event. - * @param {Object} pointerEventData Pointer event data. - * @param {goog.events.BrowserEvent} browserEvent The event. + * @param {Object} data Pointer event data. + * @param {Event} event The event. */ -ol.pointer.PointerEventHandler.prototype.out = function(pointerEventData, browserEvent) { - pointerEventData.bubbles = true; - this.fireEvent(ol.pointer.EventType.POINTEROUT, - pointerEventData, browserEvent); +ol.pointer.PointerEventHandler.prototype.out = function(data, event) { + data.bubbles = true; + this.fireEvent(ol.pointer.EventType.POINTEROUT, data, event); }; /** * Triggers a 'pointercancel' event. - * @param {Object} pointerEventData Pointer event data. - * @param {goog.events.BrowserEvent} browserEvent The event. + * @param {Object} data Pointer event data. + * @param {Event} event The event. */ -ol.pointer.PointerEventHandler.prototype.cancel = function(pointerEventData, browserEvent) { - this.fireEvent(ol.pointer.EventType.POINTERCANCEL, - pointerEventData, browserEvent); +ol.pointer.PointerEventHandler.prototype.cancel = function(data, event) { + this.fireEvent(ol.pointer.EventType.POINTERCANCEL, data, event); }; /** * Triggers a combination of 'pointerout' and 'pointerleave' events. - * @param {Object} pointerEventData Pointer event data. - * @param {goog.events.BrowserEvent} browserEvent The event. + * @param {Object} data Pointer event data. + * @param {Event} event The event. */ -ol.pointer.PointerEventHandler.prototype.leaveOut = function(pointerEventData, browserEvent) { - this.out(pointerEventData, browserEvent); - if (!this.contains_( - pointerEventData.target, - pointerEventData.relatedTarget)) { - this.leave(pointerEventData, browserEvent); +ol.pointer.PointerEventHandler.prototype.leaveOut = function(data, event) { + this.out(data, event); + if (!this.contains_(data.target, data.relatedTarget)) { + this.leave(data, event); } }; /** * Triggers a combination of 'pointerover' and 'pointerevents' events. - * @param {Object} pointerEventData Pointer event data. - * @param {goog.events.BrowserEvent} browserEvent The event. + * @param {Object} data Pointer event data. + * @param {Event} event The event. */ -ol.pointer.PointerEventHandler.prototype.enterOver = function(pointerEventData, browserEvent) { - this.over(pointerEventData, browserEvent); - if (!this.contains_( - pointerEventData.target, - pointerEventData.relatedTarget)) { - this.enter(pointerEventData, browserEvent); +ol.pointer.PointerEventHandler.prototype.enterOver = function(data, event) { + this.over(data, event); + if (!this.contains_(data.target, data.relatedTarget)) { + this.enter(data, event); } }; @@ -362,26 +344,26 @@ ol.pointer.PointerEventHandler.prototype.contains_ = function(container, contain // EVENT CREATION AND TRACKING /** * Creates a new Event of type `inType`, based on the information in - * `pointerEventData`. + * `data`. * * @param {string} inType A string representing the type of event to create. - * @param {Object} pointerEventData Pointer event data. - * @param {goog.events.BrowserEvent} browserEvent The event. + * @param {Object} data Pointer event data. + * @param {Event} event The event. * @return {ol.pointer.PointerEvent} A PointerEvent of type `inType`. */ -ol.pointer.PointerEventHandler.prototype.makeEvent = function(inType, pointerEventData, browserEvent) { - return new ol.pointer.PointerEvent(inType, browserEvent, pointerEventData); +ol.pointer.PointerEventHandler.prototype.makeEvent = function(inType, data, event) { + return new ol.pointer.PointerEvent(inType, event, data); }; /** * Make and dispatch an event in one call. * @param {string} inType A string representing the type of event. - * @param {Object} pointerEventData Pointer event data. - * @param {goog.events.BrowserEvent} browserEvent The event. + * @param {Object} data Pointer event data. + * @param {Event} event The event. */ -ol.pointer.PointerEventHandler.prototype.fireEvent = function(inType, pointerEventData, browserEvent) { - var e = this.makeEvent(inType, pointerEventData, browserEvent); +ol.pointer.PointerEventHandler.prototype.fireEvent = function(inType, data, event) { + var e = this.makeEvent(inType, data, event); this.dispatchEvent(e); }; @@ -389,11 +371,10 @@ ol.pointer.PointerEventHandler.prototype.fireEvent = function(inType, pointerEve /** * Creates a pointer event from a native pointer event * and dispatches this event. - * @param {goog.events.BrowserEvent} nativeEvent A platform event with a target. + * @param {Event} event A platform event with a target. */ -ol.pointer.PointerEventHandler.prototype.fireNativeEvent = function(nativeEvent) { - var e = this.makeEvent(nativeEvent.type, nativeEvent.getBrowserEvent(), - nativeEvent); +ol.pointer.PointerEventHandler.prototype.fireNativeEvent = function(event) { + var e = this.makeEvent(event.type, event, event); this.dispatchEvent(e); }; @@ -402,15 +383,12 @@ ol.pointer.PointerEventHandler.prototype.fireNativeEvent = function(nativeEvent) * Wrap a native mouse event into a pointer event. * This proxy method is required for the legacy IE support. * @param {string} eventType The pointer event type. - * @param {goog.events.BrowserEvent} browserEvent The event. + * @param {Event} event The event. * @return {ol.pointer.PointerEvent} The wrapped event. */ -ol.pointer.PointerEventHandler.prototype.wrapMouseEvent = function(eventType, browserEvent) { +ol.pointer.PointerEventHandler.prototype.wrapMouseEvent = function(eventType, event) { var pointerEvent = this.makeEvent( - eventType, - ol.pointer.MouseSource.prepareEvent(browserEvent, this), - browserEvent - ); + eventType, ol.pointer.MouseSource.prepareEvent(event, this), event); return pointerEvent; }; diff --git a/src/ol/pointer/touchsource.js b/src/ol/pointer/touchsource.js index eb760009e7..9b218afc02 100644 --- a/src/ol/pointer/touchsource.js +++ b/src/ol/pointer/touchsource.js @@ -54,7 +54,7 @@ ol.pointer.TouchSource = function(dispatcher, mouseSource) { /** * @const - * @type {!Object.} + * @type {!Object.} */ this.pointerMap = dispatcher.pointerMap; @@ -176,7 +176,7 @@ ol.pointer.TouchSource.prototype.cancelResetClickCount_ = function() { /** * @private - * @param {goog.events.BrowserEvent} browserEvent Browser event + * @param {Event} browserEvent Browser event * @param {Touch} inTouch Touch event * @return {Object} A pointer object. */ @@ -212,12 +212,12 @@ ol.pointer.TouchSource.prototype.touchToPointer_ = function(browserEvent, inTouc /** * @private - * @param {goog.events.BrowserEvent} inEvent Touch event - * @param {function(goog.events.BrowserEvent, Object)} inFunction In function. + * @param {Event} inEvent Touch event + * @param {function(Event, Object)} inFunction In function. */ ol.pointer.TouchSource.prototype.processTouches_ = function(inEvent, inFunction) { var touches = Array.prototype.slice.call( - inEvent.getBrowserEvent().changedTouches); + inEvent.changedTouches); var count = touches.length; function preventDefault() { inEvent.preventDefault(); @@ -260,10 +260,10 @@ ol.pointer.TouchSource.prototype.findTouch_ = function(touchList, searchId) { * this "abandoned" touch * * @private - * @param {goog.events.BrowserEvent} inEvent The in event. + * @param {Event} inEvent The in event. */ ol.pointer.TouchSource.prototype.vacuumTouches_ = function(inEvent) { - var touchList = inEvent.getBrowserEvent().touches; + var touchList = inEvent.touches; // pointerMap.getCount() should be < touchList.length here, // as the touchstart has not been processed yet. var keys = Object.keys(this.pointerMap); @@ -293,11 +293,11 @@ ol.pointer.TouchSource.prototype.vacuumTouches_ = function(inEvent) { * Handler for `touchstart`, triggers `pointerover`, * `pointerenter` and `pointerdown` events. * - * @param {goog.events.BrowserEvent} inEvent The in event. + * @param {Event} inEvent The in event. */ ol.pointer.TouchSource.prototype.touchstart = function(inEvent) { this.vacuumTouches_(inEvent); - this.setPrimaryTouch_(inEvent.getBrowserEvent().changedTouches[0]); + this.setPrimaryTouch_(inEvent.changedTouches[0]); this.dedupSynthMouse_(inEvent); this.clickCount_++; this.processTouches_(inEvent, this.overDown_); @@ -306,7 +306,7 @@ ol.pointer.TouchSource.prototype.touchstart = function(inEvent) { /** * @private - * @param {goog.events.BrowserEvent} browserEvent The event. + * @param {Event} browserEvent The event. * @param {Object} inPointer The in pointer object. */ ol.pointer.TouchSource.prototype.overDown_ = function(browserEvent, inPointer) { @@ -324,7 +324,7 @@ ol.pointer.TouchSource.prototype.overDown_ = function(browserEvent, inPointer) { /** * Handler for `touchmove`. * - * @param {goog.events.BrowserEvent} inEvent The in event. + * @param {Event} inEvent The in event. */ ol.pointer.TouchSource.prototype.touchmove = function(inEvent) { inEvent.preventDefault(); @@ -334,7 +334,7 @@ ol.pointer.TouchSource.prototype.touchmove = function(inEvent) { /** * @private - * @param {goog.events.BrowserEvent} browserEvent The event. + * @param {Event} browserEvent The event. * @param {Object} inPointer The in pointer. */ ol.pointer.TouchSource.prototype.moveOverOut_ = function(browserEvent, inPointer) { @@ -371,7 +371,7 @@ ol.pointer.TouchSource.prototype.moveOverOut_ = function(browserEvent, inPointer * Handler for `touchend`, triggers `pointerup`, * `pointerout` and `pointerleave` events. * - * @param {goog.events.BrowserEvent} inEvent The event. + * @param {Event} inEvent The event. */ ol.pointer.TouchSource.prototype.touchend = function(inEvent) { this.dedupSynthMouse_(inEvent); @@ -381,7 +381,7 @@ ol.pointer.TouchSource.prototype.touchend = function(inEvent) { /** * @private - * @param {goog.events.BrowserEvent} browserEvent An event. + * @param {Event} browserEvent An event. * @param {Object} inPointer The inPointer object. */ ol.pointer.TouchSource.prototype.upOut_ = function(browserEvent, inPointer) { @@ -396,7 +396,7 @@ ol.pointer.TouchSource.prototype.upOut_ = function(browserEvent, inPointer) { * Handler for `touchcancel`, triggers `pointercancel`, * `pointerout` and `pointerleave` events. * - * @param {goog.events.BrowserEvent} inEvent The in event. + * @param {Event} inEvent The in event. */ ol.pointer.TouchSource.prototype.touchcancel = function(inEvent) { this.processTouches_(inEvent, this.cancelOut_); @@ -405,7 +405,7 @@ ol.pointer.TouchSource.prototype.touchcancel = function(inEvent) { /** * @private - * @param {goog.events.BrowserEvent} browserEvent The event. + * @param {Event} browserEvent The event. * @param {Object} inPointer The in pointer. */ ol.pointer.TouchSource.prototype.cancelOut_ = function(browserEvent, inPointer) { @@ -430,11 +430,11 @@ ol.pointer.TouchSource.prototype.cleanUpPointer_ = function(inPointer) { * Prevent synth mouse events from creating pointer events. * * @private - * @param {goog.events.BrowserEvent} inEvent The in event. + * @param {Event} inEvent The in event. */ ol.pointer.TouchSource.prototype.dedupSynthMouse_ = function(inEvent) { var lts = this.mouseSource.lastTouches; - var t = inEvent.getBrowserEvent().changedTouches[0]; + var t = inEvent.changedTouches[0]; // only the primary finger will synth mouse events if (this.isPrimaryTouch_(t)) { // remember x/y of last touch diff --git a/src/ol/render/renderevent.js b/src/ol/render/renderevent.js index d569982986..ce60415de1 100644 --- a/src/ol/render/renderevent.js +++ b/src/ol/render/renderevent.js @@ -1,7 +1,7 @@ goog.provide('ol.render.Event'); goog.provide('ol.render.EventType'); -goog.require('goog.events.Event'); +goog.require('ol.events.Event'); goog.require('ol.render.VectorContext'); @@ -29,7 +29,7 @@ ol.render.EventType = { /** * @constructor - * @extends {goog.events.Event} + * @extends {ol.events.Event} * @implements {oli.render.Event} * @param {ol.render.EventType} type Type. * @param {Object=} opt_target Target. @@ -75,4 +75,4 @@ ol.render.Event = function( this.glContext = opt_glContext; }; -goog.inherits(ol.render.Event, goog.events.Event); +goog.inherits(ol.render.Event, ol.events.Event); diff --git a/src/ol/render/vector.js b/src/ol/render/vector.js index ea983b7023..7654a6efd6 100644 --- a/src/ol/render/vector.js +++ b/src/ol/render/vector.js @@ -69,7 +69,7 @@ ol.renderer.vector.renderCircleGeometry_ = function(replayGroup, geometry, style * @param {ol.Feature|ol.render.Feature} feature Feature. * @param {ol.style.Style} style Style. * @param {number} squaredTolerance Squared tolerance. - * @param {function(this: T, goog.events.Event)} listener Listener function. + * @param {function(this: T, ol.events.Event)} listener Listener function. * @param {T} thisArg Value to use as `this` when executing `listener`. * @return {boolean} `true` if style is loading. * @template T diff --git a/src/ol/renderer/canvas/canvasvectorlayerrenderer.js b/src/ol/renderer/canvas/canvasvectorlayerrenderer.js index 424bf867b4..085f3c0717 100644 --- a/src/ol/renderer/canvas/canvasvectorlayerrenderer.js +++ b/src/ol/renderer/canvas/canvasvectorlayerrenderer.js @@ -1,7 +1,7 @@ goog.provide('ol.renderer.canvas.VectorLayer'); goog.require('goog.asserts'); -goog.require('goog.events'); +goog.require('ol.events'); goog.require('ol.ViewHint'); goog.require('ol.dom'); goog.require('ol.extent'); @@ -181,7 +181,7 @@ ol.renderer.canvas.VectorLayer.prototype.forEachFeatureAtCoordinate = function(c /** * Handle changes in image style state. - * @param {goog.events.Event} event Image style change event. + * @param {ol.events.Event} event Image style change event. * @private */ ol.renderer.canvas.VectorLayer.prototype.handleStyleImageChange_ = function(event) { diff --git a/src/ol/renderer/canvas/canvasvectortilelayerrenderer.js b/src/ol/renderer/canvas/canvasvectortilelayerrenderer.js index 62e8d270a3..2a22e9fc4e 100644 --- a/src/ol/renderer/canvas/canvasvectortilelayerrenderer.js +++ b/src/ol/renderer/canvas/canvasvectortilelayerrenderer.js @@ -1,7 +1,7 @@ goog.provide('ol.renderer.canvas.VectorTileLayer'); goog.require('goog.asserts'); -goog.require('goog.events'); +goog.require('ol.events'); goog.require('goog.vec.Mat4'); goog.require('ol.Feature'); goog.require('ol.TileRange'); @@ -364,7 +364,7 @@ ol.renderer.canvas.VectorTileLayer.prototype.forEachFeatureAtCoordinate = functi /** * Handle changes in image style state. - * @param {goog.events.Event} event Image style change event. + * @param {ol.events.Event} event Image style change event. * @private */ ol.renderer.canvas.VectorTileLayer.prototype.handleStyleImageChange_ = function(event) { diff --git a/src/ol/renderer/dom/dommaprenderer.js b/src/ol/renderer/dom/dommaprenderer.js index 8d8297d67a..60a9fbe72e 100644 --- a/src/ol/renderer/dom/dommaprenderer.js +++ b/src/ol/renderer/dom/dommaprenderer.js @@ -2,9 +2,9 @@ goog.provide('ol.renderer.dom.Map'); goog.require('goog.asserts'); goog.require('goog.dom'); -goog.require('goog.events'); -goog.require('goog.events.Event'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.Event'); +goog.require('ol.events.EventType'); goog.require('goog.style'); goog.require('goog.vec.Mat4'); goog.require('ol'); @@ -68,8 +68,8 @@ ol.renderer.dom.Map = function(container, map) { style.height = '100%'; // prevent the img context menu on mobile devices - goog.events.listen(this.layersPane_, goog.events.EventType.TOUCHSTART, - goog.events.Event.preventDefault); + ol.events.listen(this.layersPane_, ol.events.EventType.TOUCHSTART, + ol.events.Event.preventDefault); goog.dom.insertChildAt(container, this.layersPane_, 0); diff --git a/src/ol/renderer/dom/domvectorlayerrenderer.js b/src/ol/renderer/dom/domvectorlayerrenderer.js index 2691550b1b..073d733a71 100644 --- a/src/ol/renderer/dom/domvectorlayerrenderer.js +++ b/src/ol/renderer/dom/domvectorlayerrenderer.js @@ -1,7 +1,7 @@ goog.provide('ol.renderer.dom.VectorLayer'); goog.require('goog.asserts'); -goog.require('goog.events'); +goog.require('ol.events'); goog.require('goog.vec.Mat4'); goog.require('ol.ViewHint'); goog.require('ol.dom'); @@ -202,7 +202,7 @@ ol.renderer.dom.VectorLayer.prototype.forEachFeatureAtCoordinate = function(coor /** * Handle changes in image style state. - * @param {goog.events.Event} event Image style change event. + * @param {ol.events.Event} event Image style change event. * @private */ ol.renderer.dom.VectorLayer.prototype.handleStyleImageChange_ = function(event) { diff --git a/src/ol/renderer/layerrenderer.js b/src/ol/renderer/layerrenderer.js index b094289591..67902b8fae 100644 --- a/src/ol/renderer/layerrenderer.js +++ b/src/ol/renderer/layerrenderer.js @@ -1,8 +1,8 @@ goog.provide('ol.renderer.Layer'); goog.require('goog.asserts'); -goog.require('goog.events'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.EventType'); goog.require('goog.functions'); goog.require('ol'); goog.require('ol.ImageState'); @@ -121,7 +121,7 @@ ol.renderer.Layer.prototype.getLayer = function() { /** * Handle changes in image state. - * @param {goog.events.Event} event Image change event. + * @param {ol.events.Event} event Image change event. * @private */ ol.renderer.Layer.prototype.handleImageChange_ = function(event) { @@ -149,8 +149,8 @@ ol.renderer.Layer.prototype.loadImage = function(image) { goog.asserts.assert(imageState == ol.ImageState.IDLE || imageState == ol.ImageState.LOADING, 'imageState is "idle" or "loading"'); - goog.events.listen(image, goog.events.EventType.CHANGE, - this.handleImageChange_, false, this); + ol.events.listen(image, ol.events.EventType.CHANGE, + this.handleImageChange_, this); } if (imageState == ol.ImageState.IDLE) { image.load(); diff --git a/src/ol/renderer/maprenderer.js b/src/ol/renderer/maprenderer.js index 500e5f1427..3e3530fab6 100644 --- a/src/ol/renderer/maprenderer.js +++ b/src/ol/renderer/maprenderer.js @@ -4,8 +4,8 @@ goog.provide('ol.renderer.Map'); goog.require('goog.Disposable'); goog.require('goog.asserts'); goog.require('goog.dispose'); -goog.require('goog.events'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.EventType'); goog.require('goog.functions'); goog.require('goog.object'); goog.require('goog.vec.Mat4'); @@ -55,7 +55,7 @@ ol.renderer.Map = function(container, map) { /** * @private - * @type {Object.} + * @type {Object.} */ this.layerRendererListeners_ = {}; @@ -255,9 +255,8 @@ ol.renderer.Map.prototype.getLayerRenderer = function(layer) { } else { var layerRenderer = this.createLayerRenderer(layer); this.layerRenderers_[layerKey] = layerRenderer; - this.layerRendererListeners_[layerKey] = goog.events.listen(layerRenderer, - goog.events.EventType.CHANGE, this.handleLayerRendererChange_, - false, this); + this.layerRendererListeners_[layerKey] = ol.events.listen(layerRenderer, + ol.events.EventType.CHANGE, this.handleLayerRendererChange_, this); return layerRenderer; } @@ -321,7 +320,7 @@ ol.renderer.Map.prototype.removeLayerRendererByKey_ = function(layerKey) { goog.asserts.assert(layerKey in this.layerRendererListeners_, 'given layerKey (%s) exists in layerRendererListeners', layerKey); - goog.events.unlistenByKey(this.layerRendererListeners_[layerKey]); + ol.events.unlistenByKey(this.layerRendererListeners_[layerKey]); delete this.layerRendererListeners_[layerKey]; return layerRenderer; diff --git a/src/ol/renderer/webgl/webglmaprenderer.js b/src/ol/renderer/webgl/webglmaprenderer.js index 9ece2811f6..8bb50fd2db 100644 --- a/src/ol/renderer/webgl/webglmaprenderer.js +++ b/src/ol/renderer/webgl/webglmaprenderer.js @@ -4,8 +4,8 @@ goog.provide('ol.renderer.webgl.Map'); goog.require('goog.asserts'); goog.require('goog.dom'); -goog.require('goog.events'); -goog.require('goog.events.Event'); +goog.require('ol.events'); +goog.require('ol.events.Event'); goog.require('goog.log'); goog.require('goog.log.Logger'); goog.require('goog.object'); @@ -106,10 +106,10 @@ ol.renderer.webgl.Map = function(container, map) { */ this.context_ = new ol.webgl.Context(this.canvas_, this.gl_); - goog.events.listen(this.canvas_, ol.webgl.WebGLContextEventType.LOST, - this.handleWebGLContextLost, false, this); - goog.events.listen(this.canvas_, ol.webgl.WebGLContextEventType.RESTORED, - this.handleWebGLContextRestored, false, this); + ol.events.listen(this.canvas_, ol.webgl.WebGLContextEventType.LOST, + this.handleWebGLContextLost, this); + ol.events.listen(this.canvas_, ol.webgl.WebGLContextEventType.RESTORED, + this.handleWebGLContextRestored, this); /** * @private @@ -377,7 +377,7 @@ ol.renderer.webgl.Map.prototype.getType = function() { /** - * @param {goog.events.Event} event Event. + * @param {ol.events.Event} event Event. * @protected */ ol.renderer.webgl.Map.prototype.handleWebGLContextLost = function(event) { diff --git a/src/ol/renderer/webgl/webglvectorlayerrenderer.js b/src/ol/renderer/webgl/webglvectorlayerrenderer.js index 3745c03df7..7554e05f96 100644 --- a/src/ol/renderer/webgl/webglvectorlayerrenderer.js +++ b/src/ol/renderer/webgl/webglvectorlayerrenderer.js @@ -1,7 +1,7 @@ goog.provide('ol.renderer.webgl.VectorLayer'); goog.require('goog.asserts'); -goog.require('goog.events'); +goog.require('ol.events'); goog.require('ol.ViewHint'); goog.require('ol.extent'); goog.require('ol.layer.Vector'); @@ -169,7 +169,7 @@ ol.renderer.webgl.VectorLayer.prototype.forEachLayerAtPixel = function(pixel, fr /** * Handle changes in image style state. - * @param {goog.events.Event} event Image style change event. + * @param {ol.events.Event} event Image style change event. * @private */ ol.renderer.webgl.VectorLayer.prototype.handleStyleImageChange_ = function(event) { diff --git a/src/ol/reproj/image.js b/src/ol/reproj/image.js index 33e7b83534..4d8b81581a 100644 --- a/src/ol/reproj/image.js +++ b/src/ol/reproj/image.js @@ -2,8 +2,8 @@ goog.provide('ol.reproj.Image'); goog.provide('ol.reproj.ImageFunctionType'); goog.require('goog.asserts'); -goog.require('goog.events'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.EventType'); goog.require('ol.ImageBase'); goog.require('ol.ImageState'); goog.require('ol.extent'); @@ -102,7 +102,7 @@ ol.reproj.Image = function(sourceProj, targetProj, /** * @private - * @type {goog.events.Key} + * @type {?ol.events.Key} */ this.sourceListenerKey_ = null; @@ -183,15 +183,15 @@ ol.reproj.Image.prototype.load = function() { sourceState == ol.ImageState.ERROR) { this.reproject_(); } else { - this.sourceListenerKey_ = this.sourceImage_.listen( - goog.events.EventType.CHANGE, function(e) { + this.sourceListenerKey_ = ol.events.listen(this.sourceImage_, + ol.events.EventType.CHANGE, function(e) { var sourceState = this.sourceImage_.getState(); if (sourceState == ol.ImageState.LOADED || sourceState == ol.ImageState.ERROR) { this.unlistenSource_(); this.reproject_(); } - }, false, this); + }, this); this.sourceImage_.load(); } } @@ -204,6 +204,6 @@ ol.reproj.Image.prototype.load = function() { ol.reproj.Image.prototype.unlistenSource_ = function() { goog.asserts.assert(this.sourceListenerKey_, 'this.sourceListenerKey_ should not be null'); - goog.events.unlistenByKey(this.sourceListenerKey_); + ol.events.unlistenByKey(this.sourceListenerKey_); this.sourceListenerKey_ = null; }; diff --git a/src/ol/reproj/tile.js b/src/ol/reproj/tile.js index 143b76bc4d..730ba6b007 100644 --- a/src/ol/reproj/tile.js +++ b/src/ol/reproj/tile.js @@ -2,8 +2,8 @@ goog.provide('ol.reproj.Tile'); goog.provide('ol.reproj.TileFunctionType'); goog.require('goog.asserts'); -goog.require('goog.events'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.EventType'); goog.require('goog.math'); goog.require('goog.object'); goog.require('ol.Tile'); @@ -97,7 +97,7 @@ ol.reproj.Tile = function(sourceProj, sourceTileGrid, /** * @private - * @type {Array.} + * @type {Array.} */ this.sourcesListenerKeys_ = null; @@ -297,13 +297,13 @@ ol.reproj.Tile.prototype.load = function() { leftToLoad++; var sourceListenKey; - sourceListenKey = tile.listen(goog.events.EventType.CHANGE, + sourceListenKey = ol.events.listen(tile, ol.events.EventType.CHANGE, function(e) { var state = tile.getState(); if (state == ol.TileState.LOADED || state == ol.TileState.ERROR || state == ol.TileState.EMPTY) { - goog.events.unlistenByKey(sourceListenKey); + ol.events.unlistenByKey(sourceListenKey); leftToLoad--; goog.asserts.assert(leftToLoad >= 0, 'leftToLoad should not be negative'); @@ -312,7 +312,7 @@ ol.reproj.Tile.prototype.load = function() { this.reproject_(); } } - }, false, this); + }, this); this.sourcesListenerKeys_.push(sourceListenKey); } }, this); @@ -337,6 +337,6 @@ ol.reproj.Tile.prototype.load = function() { ol.reproj.Tile.prototype.unlistenSources_ = function() { goog.asserts.assert(this.sourcesListenerKeys_, 'this.sourcesListenerKeys_ should not be null'); - this.sourcesListenerKeys_.forEach(goog.events.unlistenByKey); + this.sourcesListenerKeys_.forEach(ol.events.unlistenByKey); this.sourcesListenerKeys_ = null; }; diff --git a/src/ol/source/bingmapssource.js b/src/ol/source/bingmapssource.js index dd5b8635ac..a2adf057f4 100644 --- a/src/ol/source/bingmapssource.js +++ b/src/ol/source/bingmapssource.js @@ -1,12 +1,11 @@ goog.provide('ol.source.BingMaps'); -goog.require('goog.Uri'); goog.require('goog.asserts'); -goog.require('goog.net.Jsonp'); goog.require('ol.Attribution'); goog.require('ol.TileRange'); goog.require('ol.TileUrlFunction'); goog.require('ol.extent'); +goog.require('ol.net'); goog.require('ol.proj'); goog.require('ol.source.State'); goog.require('ol.source.TileImage'); @@ -46,16 +45,12 @@ ol.source.BingMaps = function(options) { */ this.maxZoom_ = options.maxZoom !== undefined ? options.maxZoom : -1; - var uri = new goog.Uri( - 'https://dev.virtualearth.net/REST/v1/Imagery/Metadata/' + - options.imagerySet); + var url = 'https://dev.virtualearth.net/REST/v1/Imagery/Metadata/' + + options.imagerySet + + '?uriScheme=https&include=ImageryProviders&key=' + options.key; - var jsonp = new goog.net.Jsonp(uri, 'jsonp'); - jsonp.send({ - 'include': 'ImageryProviders', - 'uriScheme': 'https', - 'key': options.key - }, this.handleImageryMetadataResponse.bind(this)); + ol.net.jsonp(url, this.handleImageryMetadataResponse.bind(this), undefined, + 'jsonp'); }; goog.inherits(ol.source.BingMaps, ol.source.TileImage); diff --git a/src/ol/source/clustersource.js b/src/ol/source/clustersource.js index 3a6a957a80..115cec297c 100644 --- a/src/ol/source/clustersource.js +++ b/src/ol/source/clustersource.js @@ -4,7 +4,7 @@ goog.provide('ol.source.Cluster'); goog.require('goog.asserts'); -goog.require('goog.events.EventType'); +goog.require('ol.events.EventType'); goog.require('goog.object'); goog.require('ol.Feature'); goog.require('ol.coordinate'); @@ -55,7 +55,7 @@ ol.source.Cluster = function(options) { */ this.source_ = options.source; - this.source_.on(goog.events.EventType.CHANGE, + this.source_.on(ol.events.EventType.CHANGE, ol.source.Cluster.prototype.onSourceChange_, this); }; goog.inherits(ol.source.Cluster, ol.source.Vector); diff --git a/src/ol/source/imagemapguidesource.js b/src/ol/source/imagemapguidesource.js index c2e92211f1..270093f08d 100644 --- a/src/ol/source/imagemapguidesource.js +++ b/src/ol/source/imagemapguidesource.js @@ -1,7 +1,7 @@ goog.provide('ol.source.ImageMapGuide'); -goog.require('goog.events'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.EventType'); goog.require('goog.object'); goog.require('goog.uri.utils'); goog.require('ol.Image'); @@ -143,8 +143,8 @@ ol.source.ImageMapGuide.prototype.getImageInternal = function(extent, resolution image = new ol.Image(extent, resolution, pixelRatio, this.getAttributions(), imageUrl, this.crossOrigin_, this.imageLoadFunction_); - goog.events.listen(image, goog.events.EventType.CHANGE, - this.handleImageChange, false, this); + ol.events.listen(image, ol.events.EventType.CHANGE, + this.handleImageChange, this); } else { image = null; } diff --git a/src/ol/source/imagesource.js b/src/ol/source/imagesource.js index 02cd6bc2fd..f6c4f52977 100644 --- a/src/ol/source/imagesource.js +++ b/src/ol/source/imagesource.js @@ -2,7 +2,7 @@ goog.provide('ol.source.Image'); goog.provide('ol.source.ImageEvent'); goog.require('goog.asserts'); -goog.require('goog.events.Event'); +goog.require('ol.events.Event'); goog.require('ol.Attribution'); goog.require('ol.ImageState'); goog.require('ol.array'); @@ -153,7 +153,7 @@ ol.source.Image.prototype.getImageInternal = goog.abstractMethod; /** * Handle image change events. - * @param {goog.events.Event} event Event. + * @param {ol.events.Event} event Event. * @protected */ ol.source.Image.prototype.handleImageChange = function(event) { @@ -197,7 +197,7 @@ ol.source.Image.defaultImageLoadFunction = function(image, src) { * type. * * @constructor - * @extends {goog.events.Event} + * @extends {ol.events.Event} * @implements {oli.source.ImageEvent} * @param {string} type Type. * @param {ol.Image} image The image. @@ -214,7 +214,7 @@ ol.source.ImageEvent = function(type, image) { this.image = image; }; -goog.inherits(ol.source.ImageEvent, goog.events.Event); +goog.inherits(ol.source.ImageEvent, ol.events.Event); /** diff --git a/src/ol/source/imagestaticsource.js b/src/ol/source/imagestaticsource.js index 1738006e26..d482f23ef1 100644 --- a/src/ol/source/imagestaticsource.js +++ b/src/ol/source/imagestaticsource.js @@ -1,7 +1,7 @@ goog.provide('ol.source.ImageStatic'); -goog.require('goog.events'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.EventType'); goog.require('ol.Image'); goog.require('ol.ImageLoadFunctionType'); goog.require('ol.ImageState'); @@ -52,8 +52,8 @@ ol.source.ImageStatic = function(options) { */ this.imageSize_ = options.imageSize ? options.imageSize : null; - goog.events.listen(this.image_, goog.events.EventType.CHANGE, - this.handleImageChange, false, this); + ol.events.listen(this.image_, ol.events.EventType.CHANGE, + this.handleImageChange, this); }; goog.inherits(ol.source.ImageStatic, ol.source.Image); diff --git a/src/ol/source/imagevectorsource.js b/src/ol/source/imagevectorsource.js index 1893968b3b..a9ed188db1 100644 --- a/src/ol/source/imagevectorsource.js +++ b/src/ol/source/imagevectorsource.js @@ -1,8 +1,8 @@ goog.provide('ol.source.ImageVector'); goog.require('goog.asserts'); -goog.require('goog.events'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.EventType'); goog.require('goog.vec.Mat4'); goog.require('ol.dom'); goog.require('ol.extent'); @@ -89,8 +89,8 @@ ol.source.ImageVector = function(options) { this.setStyle(options.style); - goog.events.listen(this.source_, goog.events.EventType.CHANGE, - this.handleSourceChange_, undefined, this); + ol.events.listen(this.source_, ol.events.EventType.CHANGE, + this.handleSourceChange_, this); }; goog.inherits(ol.source.ImageVector, ol.source.ImageCanvas); @@ -226,7 +226,7 @@ ol.source.ImageVector.prototype.getTransform_ = function(center, resolution, pix /** * Handle changes in image style state. - * @param {goog.events.Event} event Image style change event. + * @param {ol.events.Event} event Image style change event. * @private */ ol.source.ImageVector.prototype.handleImageChange_ = function(event) { diff --git a/src/ol/source/imagewmssource.js b/src/ol/source/imagewmssource.js index 61f5565f0d..211ca6d33c 100644 --- a/src/ol/source/imagewmssource.js +++ b/src/ol/source/imagewmssource.js @@ -3,8 +3,8 @@ goog.provide('ol.source.ImageWMS'); goog.require('goog.asserts'); -goog.require('goog.events'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.EventType'); goog.require('goog.object'); goog.require('goog.string'); goog.require('goog.uri.utils'); @@ -241,8 +241,8 @@ ol.source.ImageWMS.prototype.getImageInternal = function(extent, resolution, pix this.renderedRevision_ = this.getRevision(); - goog.events.listen(this.image_, goog.events.EventType.CHANGE, - this.handleImageChange, false, this); + ol.events.listen(this.image_, ol.events.EventType.CHANGE, + this.handleImageChange, this); return this.image_; diff --git a/src/ol/source/rastersource.js b/src/ol/source/rastersource.js index ea25acff34..16d918b076 100644 --- a/src/ol/source/rastersource.js +++ b/src/ol/source/rastersource.js @@ -3,9 +3,9 @@ goog.provide('ol.source.RasterEvent'); goog.provide('ol.source.RasterEventType'); goog.require('goog.asserts'); -goog.require('goog.events'); -goog.require('goog.events.Event'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.Event'); +goog.require('ol.events.EventType'); goog.require('goog.object'); goog.require('goog.vec.Mat4'); goog.require('ol.ImageCanvas'); @@ -62,8 +62,8 @@ ol.source.Raster = function(options) { this.renderers_ = ol.source.Raster.createRenderers_(options.sources); for (var r = 0, rr = this.renderers_.length; r < rr; ++r) { - goog.events.listen(this.renderers_[r], goog.events.EventType.CHANGE, - this.changed, false, this); + ol.events.listen(this.renderers_[r], ol.events.EventType.CHANGE, + this.changed, this); } /** @@ -474,7 +474,7 @@ ol.source.Raster.RenderedState; * type. * * @constructor - * @extends {goog.events.Event} + * @extends {ol.events.Event} * @implements {oli.source.RasterEvent} * @param {string} type Type. * @param {olx.FrameState} frameState The frame state. @@ -506,7 +506,7 @@ ol.source.RasterEvent = function(type, frameState, data) { this.data = data; }; -goog.inherits(ol.source.RasterEvent, goog.events.Event); +goog.inherits(ol.source.RasterEvent, ol.events.Event); /** diff --git a/src/ol/source/tileimagesource.js b/src/ol/source/tileimagesource.js index 54751b1f23..23d9218199 100644 --- a/src/ol/source/tileimagesource.js +++ b/src/ol/source/tileimagesource.js @@ -1,8 +1,8 @@ goog.provide('ol.source.TileImage'); goog.require('goog.asserts'); -goog.require('goog.events'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.EventType'); goog.require('goog.object'); goog.require('ol.ImageTile'); goog.require('ol.TileCache'); @@ -197,8 +197,8 @@ ol.source.TileImage.prototype.createTile_ = function(z, x, y, pixelRatio, projec this.crossOrigin, this.tileLoadFunction); tile.key = key; - goog.events.listen(tile, goog.events.EventType.CHANGE, - this.handleTileChange, false, this); + ol.events.listen(tile, ol.events.EventType.CHANGE, + this.handleTileChange, this); return tile; }; diff --git a/src/ol/source/tilejsonsource.js b/src/ol/source/tilejsonsource.js index 572b2d06e1..05309fb651 100644 --- a/src/ol/source/tilejsonsource.js +++ b/src/ol/source/tilejsonsource.js @@ -8,15 +8,11 @@ goog.provide('ol.source.TileJSON'); goog.provide('ol.tilejson'); goog.require('goog.asserts'); -goog.require('goog.events'); -goog.require('goog.net.CorsXmlHttpFactory'); -goog.require('goog.net.EventType'); -goog.require('goog.net.Jsonp'); -goog.require('goog.net.XhrIo'); goog.require('ol.Attribution'); goog.require('ol.TileRange'); goog.require('ol.TileUrlFunction'); goog.require('ol.extent'); +goog.require('ol.net'); goog.require('ol.proj'); goog.require('ol.source.State'); goog.require('ol.source.TileImage'); @@ -44,21 +40,20 @@ ol.source.TileJSON = function(options) { }); if (options.jsonp) { - var request = new goog.net.Jsonp(options.url); - request.send(undefined, this.handleTileJSONResponse.bind(this), + ol.net.jsonp(options.url, this.handleTileJSONResponse.bind(this), this.handleTileJSONError.bind(this)); } else { - var xhr = new goog.net.XhrIo(new goog.net.CorsXmlHttpFactory()); - goog.events.listen(xhr, goog.net.EventType.COMPLETE, function(e) { - if (xhr.isSuccess()) { - var response = /** @type {TileJSON} */(xhr.getResponseJson()); + var xhr = new XMLHttpRequest(); + xhr.open('GET', options.url, true); + xhr.onload = function(e) { + if (xhr.status >= 200 && xhr.status < 300) { + var response = /** @type {TileJSON} */(JSON.parse(xhr.responseText)); this.handleTileJSONResponse(response); } else { this.handleTileJSONError(); } - xhr.dispose(); - }, false, this); - xhr.send(options.url); + }.bind(this); + xhr.send(); } }; diff --git a/src/ol/source/tilesource.js b/src/ol/source/tilesource.js index eb9c0ba523..144fc7a8ff 100644 --- a/src/ol/source/tilesource.js +++ b/src/ol/source/tilesource.js @@ -3,7 +3,7 @@ goog.provide('ol.source.TileEvent'); goog.provide('ol.source.TileOptions'); goog.require('goog.asserts'); -goog.require('goog.events.Event'); +goog.require('ol.events.Event'); goog.require('ol'); goog.require('ol.Attribution'); goog.require('ol.Extent'); @@ -305,7 +305,7 @@ ol.source.Tile.prototype.useTile = ol.nullFunction; * type. * * @constructor - * @extends {goog.events.Event} + * @extends {ol.events.Event} * @implements {oli.source.TileEvent} * @param {string} type Type. * @param {ol.Tile} tile The tile. @@ -322,7 +322,7 @@ ol.source.TileEvent = function(type, tile) { this.tile = tile; }; -goog.inherits(ol.source.TileEvent, goog.events.Event); +goog.inherits(ol.source.TileEvent, ol.events.Event); /** diff --git a/src/ol/source/tileutfgridsource.js b/src/ol/source/tileutfgridsource.js index d35cbe983b..7a2e335fbd 100644 --- a/src/ol/source/tileutfgridsource.js +++ b/src/ol/source/tileutfgridsource.js @@ -2,14 +2,14 @@ goog.provide('ol.source.TileUTFGrid'); goog.require('goog.asserts'); goog.require('goog.async.nextTick'); -goog.require('goog.events'); -goog.require('goog.events.EventType'); -goog.require('goog.net.Jsonp'); goog.require('ol.Attribution'); goog.require('ol.Tile'); goog.require('ol.TileState'); goog.require('ol.TileUrlFunction'); +goog.require('ol.events'); +goog.require('ol.events.EventType'); goog.require('ol.extent'); +goog.require('ol.net'); goog.require('ol.proj'); goog.require('ol.source.State'); goog.require('ol.source.Tile'); @@ -49,8 +49,7 @@ ol.source.TileUTFGrid = function(options) { */ this.template_ = undefined; - var request = new goog.net.Jsonp(options.url); - request.send(undefined, this.handleTileJSONResponse.bind(this)); + ol.net.jsonp(options.url, this.handleTileJSONResponse.bind(this)); }; goog.inherits(ol.source.TileUTFGrid, ol.source.Tile); @@ -307,9 +306,9 @@ ol.source.TileUTFGridTile_.prototype.getData = function(coordinate) { */ ol.source.TileUTFGridTile_.prototype.forDataAtCoordinate = function(coordinate, callback, opt_this, opt_request) { if (this.state == ol.TileState.IDLE && opt_request === true) { - goog.events.listenOnce(this, goog.events.EventType.CHANGE, function(e) { + ol.events.listenOnce(this, ol.events.EventType.CHANGE, function(e) { callback.call(opt_this, this.getData(coordinate)); - }, false, this); + }, this); this.loadInternal_(); } else { if (opt_request === true) { @@ -360,9 +359,8 @@ ol.source.TileUTFGridTile_.prototype.handleLoad_ = function(json) { ol.source.TileUTFGridTile_.prototype.loadInternal_ = function() { if (this.state == ol.TileState.IDLE) { this.state = ol.TileState.LOADING; - var request = new goog.net.Jsonp(this.src_); - request.send(undefined, this.handleLoad_.bind(this), - this.handleError_.bind(this)); + ol.net.jsonp(this.src_, this.handleLoad_.bind(this), + this.handleError_.bind(this)); } }; diff --git a/src/ol/source/urltilesource.js b/src/ol/source/urltilesource.js index f1b618c195..2a80ef9132 100644 --- a/src/ol/source/urltilesource.js +++ b/src/ol/source/urltilesource.js @@ -1,6 +1,6 @@ goog.provide('ol.source.UrlTile'); -goog.require('goog.events'); +goog.require('ol.events'); goog.require('ol.TileLoadFunctionType'); goog.require('ol.TileState'); goog.require('ol.TileUrlFunction'); @@ -126,7 +126,7 @@ ol.source.UrlTile.prototype.getUrls = function() { /** * Handle tile change events. - * @param {goog.events.Event} event Event. + * @param {ol.events.Event} event Event. * @protected */ ol.source.UrlTile.prototype.handleTileChange = function(event) { diff --git a/src/ol/source/vectorsource.js b/src/ol/source/vectorsource.js index 38867af174..a5f60642b4 100644 --- a/src/ol/source/vectorsource.js +++ b/src/ol/source/vectorsource.js @@ -6,9 +6,9 @@ goog.provide('ol.source.VectorEvent'); goog.provide('ol.source.VectorEventType'); goog.require('goog.asserts'); -goog.require('goog.events'); -goog.require('goog.events.Event'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.Event'); +goog.require('ol.events.EventType'); goog.require('goog.object'); goog.require('ol'); goog.require('ol.Collection'); @@ -146,7 +146,7 @@ ol.source.Vector = function(opt_options) { /** * @private - * @type {Object.>} + * @type {Object.>} */ this.featureChangeKeys_ = {}; @@ -228,12 +228,10 @@ ol.source.Vector.prototype.setupChangeEvents_ = function(featureKey, feature) { goog.asserts.assert(!(featureKey in this.featureChangeKeys_), 'key (%s) not yet registered in featureChangeKey', featureKey); this.featureChangeKeys_[featureKey] = [ - goog.events.listen(feature, - goog.events.EventType.CHANGE, - this.handleFeatureChange_, false, this), - goog.events.listen(feature, - ol.ObjectEventType.PROPERTYCHANGE, - this.handleFeatureChange_, false, this) + ol.events.listen(feature, ol.events.EventType.CHANGE, + this.handleFeatureChange_, this), + ol.events.listen(feature, ol.ObjectEventType.PROPERTYCHANGE, + this.handleFeatureChange_, this) ]; }; @@ -327,7 +325,7 @@ ol.source.Vector.prototype.bindFeaturesCollection_ = function(collection) { goog.asserts.assert(!this.featuresCollection_, 'bindFeaturesCollection can only be called once'); var modifyingCollection = false; - goog.events.listen(this, ol.source.VectorEventType.ADDFEATURE, + ol.events.listen(this, ol.source.VectorEventType.ADDFEATURE, function(evt) { if (!modifyingCollection) { modifyingCollection = true; @@ -335,7 +333,7 @@ ol.source.Vector.prototype.bindFeaturesCollection_ = function(collection) { modifyingCollection = false; } }); - goog.events.listen(this, ol.source.VectorEventType.REMOVEFEATURE, + ol.events.listen(this, ol.source.VectorEventType.REMOVEFEATURE, function(evt) { if (!modifyingCollection) { modifyingCollection = true; @@ -343,7 +341,7 @@ ol.source.Vector.prototype.bindFeaturesCollection_ = function(collection) { modifyingCollection = false; } }); - goog.events.listen(collection, ol.CollectionEventType.ADD, + ol.events.listen(collection, ol.CollectionEventType.ADD, function(evt) { if (!modifyingCollection) { var feature = evt.element; @@ -352,8 +350,8 @@ ol.source.Vector.prototype.bindFeaturesCollection_ = function(collection) { this.addFeature(feature); modifyingCollection = false; } - }, false, this); - goog.events.listen(collection, ol.CollectionEventType.REMOVE, + }, this); + ol.events.listen(collection, ol.CollectionEventType.REMOVE, function(evt) { if (!modifyingCollection) { var feature = evt.element; @@ -362,7 +360,7 @@ ol.source.Vector.prototype.bindFeaturesCollection_ = function(collection) { this.removeFeature(feature); modifyingCollection = false; } - }, false, this); + }, this); this.featuresCollection_ = collection; }; @@ -376,7 +374,7 @@ ol.source.Vector.prototype.clear = function(opt_fast) { if (opt_fast) { for (var featureId in this.featureChangeKeys_) { var keys = this.featureChangeKeys_[featureId]; - keys.forEach(goog.events.unlistenByKey); + keys.forEach(ol.events.unlistenByKey); } if (!this.featuresCollection_) { this.featureChangeKeys_ = {}; @@ -680,7 +678,7 @@ ol.source.Vector.prototype.getFeatureById = function(id) { /** - * @param {goog.events.Event} event Event. + * @param {ol.events.Event} event Event. * @private */ ol.source.Vector.prototype.handleFeatureChange_ = function(event) { @@ -816,7 +814,7 @@ ol.source.Vector.prototype.removeFeatureInternal = function(feature) { var featureKey = goog.getUid(feature).toString(); goog.asserts.assert(featureKey in this.featureChangeKeys_, 'featureKey exists in featureChangeKeys'); - this.featureChangeKeys_[featureKey].forEach(goog.events.unlistenByKey); + this.featureChangeKeys_[featureKey].forEach(ol.events.unlistenByKey); delete this.featureChangeKeys_[featureKey]; var id = feature.getId(); if (id !== undefined) { @@ -855,7 +853,7 @@ ol.source.Vector.prototype.removeFromIdIndex_ = function(feature) { * type. * * @constructor - * @extends {goog.events.Event} + * @extends {ol.events.Event} * @implements {oli.source.VectorEvent} * @param {string} type Type. * @param {ol.Feature=} opt_feature Feature. @@ -872,4 +870,4 @@ ol.source.VectorEvent = function(type, opt_feature) { this.feature = opt_feature; }; -goog.inherits(ol.source.VectorEvent, goog.events.Event); +goog.inherits(ol.source.VectorEvent, ol.events.Event); diff --git a/src/ol/source/vectortilesource.js b/src/ol/source/vectortilesource.js index 3fe805b817..b7417df27f 100644 --- a/src/ol/source/vectortilesource.js +++ b/src/ol/source/vectortilesource.js @@ -1,9 +1,9 @@ goog.provide('ol.source.VectorTile'); -goog.require('goog.events'); -goog.require('goog.events.EventType'); goog.require('ol.TileState'); goog.require('ol.VectorTile'); +goog.require('ol.events'); +goog.require('ol.events.EventType'); goog.require('ol.featureloader'); goog.require('ol.source.UrlTile'); @@ -79,8 +79,8 @@ ol.source.VectorTile.prototype.getTile = function(z, x, y, pixelRatio, projectio tileUrl !== undefined ? ol.TileState.IDLE : ol.TileState.EMPTY, tileUrl !== undefined ? tileUrl : '', this.format_, this.tileLoadFunction); - goog.events.listen(tile, goog.events.EventType.CHANGE, - this.handleTileChange, false, this); + ol.events.listen(tile, ol.events.EventType.CHANGE, + this.handleTileChange, this); this.tileCache.set(tileCoordKey, tile); return tile; diff --git a/src/ol/style/iconstyle.js b/src/ol/style/iconstyle.js index 8ae467f871..7ef132e639 100644 --- a/src/ol/style/iconstyle.js +++ b/src/ol/style/iconstyle.js @@ -4,9 +4,9 @@ goog.provide('ol.style.IconImageCache'); goog.provide('ol.style.IconOrigin'); goog.require('goog.asserts'); -goog.require('goog.events'); -goog.require('goog.events.EventTarget'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.EventTarget'); +goog.require('ol.events.EventType'); goog.require('ol.color'); goog.require('ol.dom'); goog.require('ol.style.Image'); @@ -345,8 +345,8 @@ ol.style.Icon.prototype.getSize = function() { * @inheritDoc */ ol.style.Icon.prototype.listenImageChange = function(listener, thisArg) { - return goog.events.listen(this.iconImage_, goog.events.EventType.CHANGE, - listener, false, thisArg); + return ol.events.listen(this.iconImage_, ol.events.EventType.CHANGE, + listener, thisArg); }; @@ -366,8 +366,8 @@ ol.style.Icon.prototype.load = function() { * @inheritDoc */ ol.style.Icon.prototype.unlistenImageChange = function(listener, thisArg) { - goog.events.unlisten(this.iconImage_, goog.events.EventType.CHANGE, - listener, false, thisArg); + ol.events.unlisten(this.iconImage_, ol.events.EventType.CHANGE, + listener, thisArg); }; @@ -379,7 +379,7 @@ ol.style.Icon.prototype.unlistenImageChange = function(listener, thisArg) { * @param {?string} crossOrigin Cross origin. * @param {ol.style.ImageState} imageState Image state. * @param {ol.Color} color Color. - * @extends {goog.events.EventTarget} + * @extends {ol.events.EventTarget} * @private */ ol.style.IconImage_ = function(image, src, size, crossOrigin, imageState, @@ -419,7 +419,7 @@ ol.style.IconImage_ = function(image, src, size, crossOrigin, imageState, /** * @private - * @type {Array.} + * @type {Array.} */ this.imageListenerKeys_ = null; @@ -451,7 +451,7 @@ ol.style.IconImage_ = function(image, src, size, crossOrigin, imageState, } }; -goog.inherits(ol.style.IconImage_, goog.events.EventTarget); +goog.inherits(ol.style.IconImage_, ol.events.EventTarget); /** @@ -494,7 +494,7 @@ ol.style.IconImage_.prototype.determineTainting_ = function() { * @private */ ol.style.IconImage_.prototype.dispatchChangeEvent_ = function() { - this.dispatchEvent(goog.events.EventType.CHANGE); + this.dispatchEvent(ol.events.EventType.CHANGE); }; @@ -585,10 +585,10 @@ ol.style.IconImage_.prototype.load = function() { 'no listener keys existing'); this.imageState_ = ol.style.ImageState.LOADING; this.imageListenerKeys_ = [ - goog.events.listenOnce(this.image_, goog.events.EventType.ERROR, - this.handleImageError_, false, this), - goog.events.listenOnce(this.image_, goog.events.EventType.LOAD, - this.handleImageLoad_, false, this) + ol.events.listenOnce(this.image_, ol.events.EventType.ERROR, + this.handleImageError_, this), + ol.events.listenOnce(this.image_, ol.events.EventType.LOAD, + this.handleImageLoad_, this) ]; try { this.image_.src = this.src_; @@ -639,7 +639,7 @@ ol.style.IconImage_.prototype.replaceColor_ = function() { ol.style.IconImage_.prototype.unlistenImage_ = function() { goog.asserts.assert(this.imageListenerKeys_, 'we must have listeners registered'); - this.imageListenerKeys_.forEach(goog.events.unlistenByKey); + this.imageListenerKeys_.forEach(ol.events.unlistenByKey); this.imageListenerKeys_ = null; }; @@ -703,7 +703,7 @@ ol.style.IconImageCache.prototype.expire = function() { var key, iconImage; for (key in this.cache_) { iconImage = this.cache_[key]; - if ((i++ & 3) === 0 && !goog.events.hasListener(iconImage)) { + if ((i++ & 3) === 0 && !iconImage.hasListener()) { delete this.cache_[key]; --this.cacheSize_; } diff --git a/src/ol/style/imagestyle.js b/src/ol/style/imagestyle.js index fc07ebe197..7de23bfc00 100644 --- a/src/ol/style/imagestyle.js +++ b/src/ol/style/imagestyle.js @@ -231,9 +231,9 @@ ol.style.Image.prototype.setSnapToPixel = function(snapToPixel) { /** - * @param {function(this: T, goog.events.Event)} listener Listener function. + * @param {function(this: T, ol.events.Event)} listener Listener function. * @param {T} thisArg Value to use as `this` when executing `listener`. - * @return {goog.events.Key|undefined} Listener key. + * @return {ol.events.Key|undefined} Listener key. * @template T */ ol.style.Image.prototype.listenImageChange = goog.abstractMethod; @@ -246,7 +246,7 @@ ol.style.Image.prototype.load = goog.abstractMethod; /** - * @param {function(this: T, goog.events.Event)} listener Listener function. + * @param {function(this: T, ol.events.Event)} listener Listener function. * @param {T} thisArg Value to use as `this` when executing `listener`. * @template T */ diff --git a/src/ol/tile.js b/src/ol/tile.js index 590addbc8c..aa59502afc 100644 --- a/src/ol/tile.js +++ b/src/ol/tile.js @@ -1,9 +1,9 @@ goog.provide('ol.Tile'); goog.provide('ol.TileState'); -goog.require('goog.events'); -goog.require('goog.events.EventTarget'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.EventTarget'); +goog.require('ol.events.EventType'); goog.require('ol.TileCoord'); @@ -24,7 +24,7 @@ ol.TileState = { * Base class for tiles. * * @constructor - * @extends {goog.events.EventTarget} + * @extends {ol.events.EventTarget} * @param {ol.TileCoord} tileCoord Tile coordinate. * @param {ol.TileState} state State. */ @@ -60,14 +60,14 @@ ol.Tile = function(tileCoord, state) { this.key = ''; }; -goog.inherits(ol.Tile, goog.events.EventTarget); +goog.inherits(ol.Tile, ol.events.EventTarget); /** * @protected */ ol.Tile.prototype.changed = function() { - this.dispatchEvent(goog.events.EventType.CHANGE); + this.dispatchEvent(ol.events.EventType.CHANGE); }; diff --git a/src/ol/tilequeue.js b/src/ol/tilequeue.js index ba11c36f58..62743a5f99 100644 --- a/src/ol/tilequeue.js +++ b/src/ol/tilequeue.js @@ -1,8 +1,8 @@ goog.provide('ol.TilePriorityFunction'); goog.provide('ol.TileQueue'); -goog.require('goog.events'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.EventType'); goog.require('ol.Coordinate'); goog.require('ol.TileState'); goog.require('ol.structs.PriorityQueue'); @@ -71,8 +71,8 @@ ol.TileQueue.prototype.enqueue = function(element) { var added = goog.base(this, 'enqueue', element); if (added) { var tile = element[0]; - goog.events.listen(tile, goog.events.EventType.CHANGE, - this.handleTileChange, false, this); + ol.events.listen(tile, ol.events.EventType.CHANGE, + this.handleTileChange, this); } return added; }; @@ -87,7 +87,7 @@ ol.TileQueue.prototype.getTilesLoading = function() { /** - * @param {goog.events.Event} event Event. + * @param {ol.events.Event} event Event. * @protected */ ol.TileQueue.prototype.handleTileChange = function(event) { @@ -95,8 +95,8 @@ ol.TileQueue.prototype.handleTileChange = function(event) { var state = tile.getState(); if (state === ol.TileState.LOADED || state === ol.TileState.ERROR || state === ol.TileState.EMPTY) { - goog.events.unlisten(tile, goog.events.EventType.CHANGE, - this.handleTileChange, false, this); + ol.events.unlisten(tile, ol.events.EventType.CHANGE, + this.handleTileChange, this); var tileKey = tile.getKey(); if (tileKey in this.tilesLoadingKeys_) { delete this.tilesLoadingKeys_[tileKey]; diff --git a/src/ol/webgl/context.js b/src/ol/webgl/context.js index 2758874cb0..3790647b1f 100644 --- a/src/ol/webgl/context.js +++ b/src/ol/webgl/context.js @@ -1,7 +1,7 @@ goog.provide('ol.webgl.Context'); goog.require('goog.asserts'); -goog.require('goog.events'); +goog.require('ol.events'); goog.require('goog.log'); goog.require('goog.object'); goog.require('ol'); @@ -22,7 +22,7 @@ ol.webgl.BufferCacheEntry; * A WebGL context for accessing low-level WebGL capabilities. * * @constructor - * @extends {goog.events.EventTarget} + * @extends {ol.events.EventTarget} * @param {HTMLCanvasElement} canvas Canvas. * @param {WebGLRenderingContext} gl GL. */ @@ -95,10 +95,10 @@ ol.webgl.Context = function(canvas, gl) { 'Failed to get extension "OES_element_index_uint"'); } - goog.events.listen(this.canvas_, ol.webgl.WebGLContextEventType.LOST, - this.handleWebGLContextLost, false, this); - goog.events.listen(this.canvas_, ol.webgl.WebGLContextEventType.RESTORED, - this.handleWebGLContextRestored, false, this); + ol.events.listen(this.canvas_, ol.webgl.WebGLContextEventType.LOST, + this.handleWebGLContextLost, this); + ol.events.listen(this.canvas_, ol.webgl.WebGLContextEventType.RESTORED, + this.handleWebGLContextRestored, this); }; diff --git a/test/index.html b/test/index.html index 59abffd854..ece127f01b 100644 --- a/test/index.html +++ b/test/index.html @@ -32,22 +32,6 @@ goog.json.USE_NATIVE_JSON = true; - /** - * The goog.dom.ViewportSizeMonitor (used in map.js) creates a global leak - * by setting goog.UID_PROPERTY_ on the monitored window. In order to test - * that we don't have other global leaks, we preemptively set the property - * so Mocha can compare the global before and after our tests. - * - * In addition, calling goog.events.listen on the global object (as done - * in deviceorientation.js) creates a second leak by setting - * goog.events.LISTENER_MAP_PROP_ on the global object. - * - * We preemptively set both of these properties so Mocha can compare the - * global before and after tests. The call to goog.events.listen also - * calls goog.getUid. - */ - goog.events.listen(this, 'test', function() {}); - var runner = mocha.run(); if (window.console && console.log) { // write stacks to the console for failed tests diff --git a/test/spec/ol/collection.test.js b/test/spec/ol/collection.test.js index b9e0008083..94fd5443e9 100644 --- a/test/spec/ol/collection.test.js +++ b/test/spec/ol/collection.test.js @@ -114,7 +114,7 @@ describe('ol.collection', function() { it('fires a remove event', function() { var collection = new ol.Collection([0, 1, 2]); var cb = sinon.spy(); - goog.events.listen(collection, ol.CollectionEventType.REMOVE, cb); + ol.events.listen(collection, ol.CollectionEventType.REMOVE, cb); expect(collection.remove(1)).to.eql(1); expect(cb).to.be.called(); expect(cb.lastCall.args[0].element).to.eql(1); @@ -137,10 +137,10 @@ describe('ol.collection', function() { it('does dispatch events', function() { var collection = new ol.Collection(['a', 'b']); var added, removed; - goog.events.listen(collection, ol.CollectionEventType.ADD, function(e) { + ol.events.listen(collection, ol.CollectionEventType.ADD, function(e) { added = e.element; }); - goog.events.listen( + ol.events.listen( collection, ol.CollectionEventType.REMOVE, function(e) { removed = e.element; }); @@ -154,7 +154,7 @@ describe('ol.collection', function() { it('does dispatch events', function() { var collection = new ol.Collection(['a']); var removed; - goog.events.listen( + ol.events.listen( collection, ol.CollectionEventType.REMOVE, function(e) { removed = e.element; }); @@ -167,7 +167,7 @@ describe('ol.collection', function() { it('does dispatch events', function() { var collection = new ol.Collection([0, 2]); var added; - goog.events.listen( + ol.events.listen( collection, ol.CollectionEventType.ADD, function(e) { added = e.element; }); @@ -179,7 +179,7 @@ describe('ol.collection', function() { describe('setAt beyond end', function() { it('triggers events properly', function() { var added = []; - goog.events.listen( + ol.events.listen( collection, ol.CollectionEventType.ADD, function(e) { added.push(e.element); }); @@ -200,7 +200,7 @@ describe('ol.collection', function() { beforeEach(function() { collection = new ol.Collection([0, 1, 2]); cb = sinon.spy(); - goog.events.listen(collection, 'change:length', cb); + ol.events.listen(collection, 'change:length', cb); }); describe('insertAt', function() { @@ -229,7 +229,7 @@ describe('ol.collection', function() { it('triggers add when pushing', function() { var collection = new ol.Collection(); var elem; - goog.events.listen(collection, ol.CollectionEventType.ADD, function(e) { + ol.events.listen(collection, ol.CollectionEventType.ADD, function(e) { elem = e.element; }); collection.push(1); @@ -246,8 +246,8 @@ describe('ol.collection', function() { }); describe('setAt', function() { it('triggers remove', function() { - goog.events.listen(collection, ol.CollectionEventType.ADD, cb1); - goog.events.listen(collection, ol.CollectionEventType.REMOVE, cb2); + ol.events.listen(collection, ol.CollectionEventType.ADD, cb1); + ol.events.listen(collection, ol.CollectionEventType.REMOVE, cb2); collection.setAt(0, 2); expect(cb2.lastCall.args[0].element).to.eql(1); expect(cb1.lastCall.args[0].element).to.eql(2); @@ -255,7 +255,7 @@ describe('ol.collection', function() { }); describe('pop', function() { it('triggers remove', function() { - goog.events.listen(collection, ol.CollectionEventType.REMOVE, cb1); + ol.events.listen(collection, ol.CollectionEventType.REMOVE, cb1); collection.pop(); expect(cb1.lastCall.args[0].element).to.eql(1); }); @@ -273,7 +273,7 @@ describe('ol.collection', function() { it('fires events', function() { var collection = new ol.Collection(); var elems = []; - goog.events.listen(collection, ol.CollectionEventType.ADD, function(e) { + ol.events.listen(collection, ol.CollectionEventType.ADD, function(e) { elems.push(e.element); }); collection.extend([1, 2]); @@ -284,6 +284,6 @@ describe('ol.collection', function() { }); -goog.require('goog.events'); +goog.require('ol.events'); goog.require('ol.Collection'); goog.require('ol.CollectionEventType'); diff --git a/test/spec/ol/control/zoomslidercontrol.test.js b/test/spec/ol/control/zoomslidercontrol.test.js index d3cb78ada9..5ac97e6dd7 100644 --- a/test/spec/ol/control/zoomslidercontrol.test.js +++ b/test/spec/ol/control/zoomslidercontrol.test.js @@ -1,3 +1,4 @@ +/*global createMapDiv, disposeMap*/ goog.provide('ol.test.control.ZoomSlider'); describe('ol.control.ZoomSlider', function() { @@ -50,10 +51,10 @@ describe('ol.control.ZoomSlider', function() { }); - describe('dragger setup', function() { - it('creates a goog.fx.Dragger', function() { - expect(zoomslider.dragger_ instanceof goog.fx.Dragger).to.be(true); - expect(zoomslider.dragger_.limits instanceof goog.math.Rect).to.be(true); + describe('#initSlider_', function() { + it('sets limits', function() { + zoomslider.initSlider_(); + expect(zoomslider.limits_ instanceof goog.math.Rect).to.be(true); }); }); @@ -85,12 +86,104 @@ describe('ol.control.ZoomSlider', function() { }); }); + describe('Pointer event handling', function() { + var map; + + beforeEach(function() { + map = new ol.Map({ + target: createMapDiv(500, 100), + view: new ol.View({ + center: [0, 0], + resolutions: [16, 8, 4, 2, 1, 0.5, 0.25, 0.125, 0.0625] + }) + }); + }); + afterEach(function() { + disposeMap(map); + }); + + it('[horizontal] handles a drag sequence', function() { + var spy = sinon.spy(goog.Disposable.prototype, 'registerDisposable'); + var control = new ol.control.ZoomSlider(); + map.addControl(control); + map.getView().setZoom(0); + control.element.style.width = '500px'; + control.element.style.height = '10px'; + control.element.firstChild.style.width = '100px'; + control.element.firstChild.style.height = '10px'; + map.renderSync(); + var dragger = spy.firstCall.args[0]; + spy.restore(); + var event = new ol.pointer.PointerEvent(ol.pointer.EventType.POINTERDOWN, { + target: control.element.firstElementChild + }); + event.clientX = control.limits_.width; + event.clientY = 0; + dragger.dispatchEvent(event); + expect(control.currentResolution_).to.be(16); + expect(control.dragging_).to.be(true); + expect(control.dragListenerKeys_).to.be.ok(); + event.type = ol.pointer.EventType.POINTERMOVE; + event.clientX = 6 * control.limits_.width / 8; + event.clientY = 0; + dragger.dispatchEvent(event); + expect(control.currentResolution_).to.be(4); + event.type = ol.pointer.EventType.POINTERMOVE; + event.clientX = 4 * control.limits_.width / 8; + event.clientY = 0; + dragger.dispatchEvent(event); + event.type = ol.pointer.EventType.POINTERUP; + dragger.dispatchEvent(event); + expect(control.currentResolution_).to.be(1); + expect(control.dragListenerKeys_).to.be(null); + expect(control.dragging_).to.be(false); + }); + it('[vertical] handles a drag sequence', function() { + var spy = sinon.spy(goog.Disposable.prototype, 'registerDisposable'); + var control = new ol.control.ZoomSlider(); + control.element.style.width = '10px'; + control.element.style.height = '100px'; + control.element.firstChild.style.width = '10px'; + control.element.firstChild.style.height = '20px'; + map.addControl(control); + map.getView().setZoom(8); + map.renderSync(); + var dragger = spy.firstCall.args[0]; + spy.restore(); + var event = new ol.pointer.PointerEvent(ol.pointer.EventType.POINTERDOWN, { + target: control.element.firstElementChild + }); + event.clientX = 0; + event.clientY = 0; + dragger.dispatchEvent(event); + expect(control.currentResolution_).to.be(0.0625); + expect(control.dragging_).to.be(true); + expect(control.dragListenerKeys_).to.be.ok(); + event.type = ol.pointer.EventType.POINTERMOVE; + event.clientX = 0; + event.clientY = 2 * control.limits_.height / 8; + dragger.dispatchEvent(event); + expect(control.currentResolution_).to.be(0.25); + event.type = ol.pointer.EventType.POINTERMOVE; + event.clientX = 0; + event.clientY = 4 * control.limits_.height / 8; + dragger.dispatchEvent(event); + event.type = ol.pointer.EventType.POINTERUP; + dragger.dispatchEvent(event); + expect(control.currentResolution_).to.be(1); + expect(control.dragListenerKeys_).to.be(null); + expect(control.dragging_).to.be(false); + }); + }); + }); +goog.require('goog.Disposable'); goog.require('goog.dispose'); goog.require('goog.dom'); goog.require('goog.dom.classlist'); -goog.require('goog.fx.Dragger'); goog.require('goog.math.Rect'); goog.require('ol.Map'); +goog.require('ol.View'); goog.require('ol.control.ZoomSlider'); +goog.require('ol.pointer.PointerEvent'); diff --git a/test/spec/ol/events.test.js b/test/spec/ol/events.test.js new file mode 100644 index 0000000000..6592bdcb3d --- /dev/null +++ b/test/spec/ol/events.test.js @@ -0,0 +1,216 @@ +goog.provide('ol.test.events'); + + +describe('ol.events', function() { + var add, remove, target; + + beforeEach(function() { + add = sinon.spy(); + remove = sinon.spy(); + target = { + addEventListener: add, + removeEventListener: remove + }; + }); + + describe('bindListener_()', function() { + it('binds a listener and returns a bound listener function', function() { + var listenerObj = { + listener: sinon.spy(), + bindTo: {id: 1} + }; + var boundListener = ol.events.bindListener_(listenerObj); + expect(listenerObj.boundListener).to.equal(boundListener); + boundListener(); + expect(listenerObj.listener.thisValues[0]).to.equal(listenerObj.bindTo); + }); + it('binds a self-unregistering listener when callOnce is true', function() { + var bindTo = {id: 1}; + var listener = sinon.spy(); + target.removeEventListener = function() {}; + var listenerObj = { + type: 'foo', + target: target, + listener: listener, + bindTo: bindTo, + callOnce: true + }; + var boundListener = ol.events.bindListener_(listenerObj); + expect(listenerObj.boundListener).to.equal(boundListener); + var spy = sinon.spy(ol.events, 'unlistenByKey'); + boundListener(); + expect(listener.thisValues[0]).to.equal(bindTo); + expect(spy.firstCall.args[0]).to.eql(listenerObj); + ol.events.unlistenByKey.restore(); + }); + }); + + describe('findListener_()', function() { + var listener, listenerObj, listeners; + + beforeEach(function() { + listener = function() {}; + listenerObj = { + type: 'foo', + target: target, + listener: listener + }; + listeners = [listenerObj]; + }); + + it('searches a listener array for a specific listener', function() { + var bindTo = {id: 1}; + var result = ol.events.findListener_(listeners, listener); + expect(result).to.be(listenerObj); + result = ol.events.findListener_(listeners, listener, bindTo); + expect(result).to.be(undefined); + listenerObj.bindTo = bindTo; + result = ol.events.findListener_(listeners, listener); + expect(result).to.be(undefined); + result = ol.events.findListener_(listeners, listener, bindTo); + expect(result).to.be(listenerObj); + }); + it('marks the delete index on a listener object', function() { + var result = ol.events.findListener_(listeners, listener, undefined, true); + expect(result).to.be(listenerObj); + expect(listenerObj.deleteIndex).to.be(0); + }); + }); + + describe('getListeners()', function() { + it('returns listeners for a target and type', function() { + var foo = ol.events.listen(target, 'foo', function() {}); + var bar = ol.events.listen(target, 'bar', function() {}); + expect (ol.events.getListeners(target, 'foo')).to.eql([foo]); + expect (ol.events.getListeners(target, 'bar')).to.eql([bar]); + }); + it('returns undefined when no listeners are registered', function() { + expect (ol.events.getListeners(target, 'foo')).to.be(undefined); + }); + }); + + describe('listen()', function() { + it('calls addEventListener on the target', function() { + ol.events.listen(target, 'foo', function() {}); + expect(add.callCount).to.be(1); + }); + it('returns a key', function() { + var key = ol.events.listen(target, 'foo', function() {}); + expect(key).to.be.a(Object); + }); + it('does not add the same listener twice', function() { + var listener = function() {}; + var key1 = ol.events.listen(target, 'foo', listener); + var key2 = ol.events.listen(target, 'foo', listener); + expect(key1).to.equal(key2); + expect(add.callCount).to.be(1); + }); + it('only treats listeners as same when all args are equal', function() { + var listener = function() {}; + ol.events.listen(target, 'foo', listener, {}); + ol.events.listen(target, 'foo', listener, {}); + ol.events.listen(target, 'foo', listener, undefined); + expect(add.callCount).to.be(3); + }); + }); + + describe('listenOnce()', function() { + it('creates a one-off listener', function() { + var listener = sinon.spy(); + var key = ol.events.listenOnce(target, 'foo', listener); + expect(add.callCount).to.be(1); + expect(key.callOnce).to.be(true); + key.boundListener(); + expect(listener.callCount).to.be(1); + expect(remove.callCount).to.be(1); + }); + it('does not add the same listener twice', function() { + var listener = function() {}; + var key1 = ol.events.listenOnce(target, 'foo', listener); + var key2 = ol.events.listenOnce(target, 'foo', listener); + expect(key1).to.equal(key2); + expect(add.callCount).to.be(1); + expect(key1.callOnce).to.be(true); + }); + it('listen() can turn a one-off listener into a permanent one', function() { + var listener = sinon.spy(); + var key = ol.events.listenOnce(target, 'foo', listener); + expect(key.callOnce).to.be(true); + key = ol.events.listen(target, 'foo', listener); + expect(add.callCount).to.be(1); + expect(key.callOnce).to.be(false); + key.boundListener(); + expect(remove.callCount).to.be(0); + }); + }); + + describe('unlisten()', function() { + it('unregisters previously registered listeners', function() { + var listener = function() {}; + ol.events.listen(target, 'foo', listener); + ol.events.unlisten(target, 'foo', listener); + expect(ol.events.getListeners(target, 'foo')).to.be(undefined); + }); + it('works with multiple types', function() { + var listener = function() {}; + ol.events.listen(target, ['foo', 'bar'], listener); + ol.events.unlisten(target, ['bar', 'foo'], listener); + expect(ol.events.getListeners(target, 'foo')).to.be(undefined); + expect(ol.events.getListeners(target, 'bar')).to.be(undefined); + }); + }); + + describe('unlistenByKey()', function() { + it('unregisters previously registered listeners', function() { + var key = ol.events.listen(target, 'foo', function() {}); + ol.events.unlistenByKey(key); + expect(ol.events.getListeners(target, 'foo')).to.be(undefined); + }); + it('works with multiple types', function() { + var key = ol.events.listen(target, ['foo', 'bar'], function() {}); + ol.events.unlistenByKey(key); + expect(ol.events.getListeners(target, 'foo')).to.be(undefined); + expect(ol.events.getListeners(target, 'bar')).to.be(undefined); + }); + }); + + describe('unlistenAll()', function() { + it('unregisters all listeners registered for a target', function() { + var keys = [ + ol.events.listen(target, 'foo', function() {}), + ol.events.listen(target, 'bar', function() {}) + ]; + ol.events.unlistenAll(target); + expect(ol.events.getListeners(target, 'foo')).to.be(undefined); + expect(ol.events.getListeners(target, 'bar')).to.be(undefined); + expect(ol.events.LISTENER_MAP_PROP_ in target).to.be(false); + expect(keys).to.eql([{}, {}]); + }); + }); + + describe('Compatibility with ol.events.EventTarget', function() { + it('does not register duplicated listeners', function() { + var target = new ol.events.EventTarget(); + var listener = function() {}; + var key1 = ol.events.listen(target, 'foo', listener); + expect(target.getListeners('foo')).to.eql([key1.boundListener]); + var key2 = ol.events.listen(target, 'foo', listener); + expect(key2.boundListener).to.equal(key1.boundListener); + expect(target.getListeners('foo')).to.eql([key1.boundListener]); + }); + it('registers multiple listeners if this object is different', function() { + var target = new ol.events.EventTarget(); + var listener = function() {}; + var key1 = ol.events.listen(target, 'foo', listener, {}); + var key2 = ol.events.listen(target, 'foo', listener, {}); + expect(key1.boundListener).to.not.equal(key2.boundListener); + expect(target.getListeners('foo')).to.eql( + [key2.boundListener, key1.boundListener]); + }); + }); + +}); + + +goog.require('ol.events'); +goog.require('ol.events.EventTarget'); diff --git a/test/spec/ol/events/event.test.js b/test/spec/ol/events/event.test.js new file mode 100644 index 0000000000..d442010c75 --- /dev/null +++ b/test/spec/ol/events/event.test.js @@ -0,0 +1,57 @@ +goog.provide('ol.test.events.Event'); + + +describe('ol.events.Event', function() { + + describe('constructor', function() { + it('takes a type as argument', function() { + var event = new ol.events.Event('foo'); + expect(event.type).to.be('foo'); + }); + it('can be constructed with an optional 2nd target arg', function() { + var target = {id: 1}; + var event = new ol.events.Event('foo', target); + expect(event.target).to.equal(target); + }); + it('does not set the propagationStopped flag', function() { + var event = new ol.events.Event('foo'); + expect(event.propagationStopped).to.be(undefined); + }); + }); + + describe('#preventDefault', function() { + it('sets the propagationStopped flag', function() { + var event = new ol.events.Event('foo'); + event.preventDefault(); + expect(event.propagationStopped).to.be(true); + }); + it('is the same as #stopPropagation', function() { + var event = new ol.events.Event('foo'); + expect(event.stopPropagation).to.equal(event.preventDefault); + }); + }); + + describe('ol.events.Event.preventDefault', function() { + it('calls preventDefault on the event object', function() { + var event = { + preventDefault: sinon.spy() + }; + ol.events.Event.preventDefault(event); + expect(event.preventDefault.called).to.be(true); + }); + }); + + describe('ol.events.Event.stopPropagation', function() { + it('calls preventDefault on the event object', function() { + var event = { + stopPropagation: sinon.spy() + }; + ol.events.Event.stopPropagation(event); + expect(event.stopPropagation.called).to.be(true); + }); + }); + +}); + + +goog.require('ol.events.Event'); diff --git a/test/spec/ol/events/eventtarget.test.js b/test/spec/ol/events/eventtarget.test.js new file mode 100644 index 0000000000..ac8f4a05e4 --- /dev/null +++ b/test/spec/ol/events/eventtarget.test.js @@ -0,0 +1,132 @@ +goog.provide('ol.test.events.EventTarget'); + + +describe('ol.events.EventTarget', function() { + var called, events, eventTarget, spy1, spy2, spy3; + + beforeEach(function() { + called = []; + events = []; + function spy(evt) { + called.push(this.id); + events.push(evt); + } + spy1 = spy.bind({id: 1}); + spy2 = spy.bind({id: 2}); + spy3 = spy.bind({id: 3}); + eventTarget = new ol.events.EventTarget(); + }); + + describe('constructor', function() { + it('creates an instance', function() { + expect(eventTarget).to.be.a(ol.events.EventTarget); + }); + it('creates an empty listeners_ object', function() { + expect(Object.keys(eventTarget.listeners_)).to.have.length(0); + }); + }); + + describe('#hasListener', function() { + it('reports any listeners when called without argument', function() { + expect(eventTarget.hasListener()).to.be(false); + eventTarget.listeners_['foo'] = [function() {}]; + expect(eventTarget.hasListener()).to.be(true); + }); + it('reports listeners for the type passed as argument', function() { + eventTarget.listeners_['foo'] = [function() {}]; + expect(eventTarget.hasListener('foo')).to.be(true); + expect(eventTarget.hasListener('bar')).to.be(false); + }); + }); + + describe('#getListeners', function() { + it('returns listeners for a type or undefined if none', function() { + expect(eventTarget.getListeners('foo')).to.be(undefined); + var listeners = [function() {}]; + eventTarget.listeners_['foo'] = listeners; + expect(eventTarget.getListeners('foo')).to.equal(listeners); + }); + }); + + + describe('#addEventListener()', function() { + it('has listeners for each registered type', function() { + eventTarget.addEventListener('foo', spy1); + eventTarget.addEventListener('bar', spy2); + expect(eventTarget.hasListener('foo')).to.be(true); + expect(eventTarget.hasListener('bar')).to.be(true); + }); + }); + + describe('#removeEventListener()', function() { + it('keeps the listeners registry clean', function() { + eventTarget.addEventListener('foo', spy1); + eventTarget.removeEventListener('foo', spy1); + expect(eventTarget.hasListener('foo')).to.be(false); + }); + it('removes added listeners from the listeners registry', function() { + eventTarget.addEventListener('foo', spy1); + eventTarget.addEventListener('foo', spy2); + eventTarget.removeEventListener('foo', spy1, false); + expect(eventTarget.getListeners('foo')).to.have.length(1); + }); + }); + + describe('#dispatchEvent()', function() { + it('calls listeners in the correct order', function() { + eventTarget.addEventListener('foo', spy1); + eventTarget.addEventListener('foo', spy2); + eventTarget.dispatchEvent('foo'); + expect(called).to.eql([1, 2]); + }); + it('stops propagation when listeners return false', function() { + eventTarget.addEventListener('foo', spy1); + eventTarget.addEventListener('foo', function(evt) { + spy2(); + return false; + }, false); + eventTarget.addEventListener('foo', spy3); + eventTarget.dispatchEvent('foo'); + expect(called).to.eql([1, 2]); + }); + it('stops propagation when listeners call preventDefault()', function() { + eventTarget.addEventListener('foo', function(evt) { + spy2(); + evt.preventDefault(); + }); + eventTarget.addEventListener('foo', spy1); + eventTarget.dispatchEvent('foo'); + expect(called).to.eql([2]); + }); + it('passes a default ol.events.Event object to listeners', function() { + eventTarget.addEventListener('foo', spy1); + eventTarget.dispatchEvent('foo'); + expect(events[0]).to.be.a(ol.events.Event); + expect(events[0].type).to.be('foo'); + expect(events[0].target).to.equal(eventTarget); + }); + it('passes a custom event object with target to listeners', function() { + eventTarget.addEventListener('foo', spy1); + var event = { + type: 'foo' + }; + eventTarget.dispatchEvent(event); + expect(events[0]).to.equal(event); + expect(events[0].target).to.equal(eventTarget); + }); + }); + + describe('#dispose()', function() { + it('cleans up foreign references', function() { + ol.events.listen(eventTarget, 'foo', spy1, document); + expect(eventTarget.hasListener('foo')).to.be(true); + eventTarget.dispose(); + expect(eventTarget.hasListener('foo')).to.be(false); + }); + }); +}); + + +goog.require('ol.events'); +goog.require('ol.events.Event'); +goog.require('ol.events.EventTarget'); diff --git a/test/spec/ol/feature.test.js b/test/spec/ol/feature.test.js index cc85086c66..9369e41696 100644 --- a/test/spec/ol/feature.test.js +++ b/test/spec/ol/feature.test.js @@ -462,7 +462,7 @@ describe('ol.Feature.createStyleFunction()', function() { }); -goog.require('goog.events'); +goog.require('ol.events'); goog.require('goog.object'); goog.require('ol.Feature'); goog.require('ol.geom.Point'); diff --git a/test/spec/ol/featureloader.test.js b/test/spec/ol/featureloader.test.js index e05849f2e6..6110846076 100644 --- a/test/spec/ol/featureloader.test.js +++ b/test/spec/ol/featureloader.test.js @@ -69,7 +69,7 @@ describe('ol.featureloader', function() { var url = 'spec/ol/data/point.json'; var format = new ol.format.GeoJSON(); loader = ol.featureloader.tile(url, format); - goog.events.listen(tile, 'change', function(e) { + ol.events.listen(tile, 'change', function(e) { expect(tile.getFeatures().length).to.be.greaterThan(0); done(); }); @@ -81,7 +81,7 @@ describe('ol.featureloader', function() { var url = 'spec/ol/data/14-8938-5680.vector.pbf'; var format = new ol.format.MVT(); loader = ol.featureloader.tile(url, format); - goog.events.listen(tile, 'change', function(e) { + ol.events.listen(tile, 'change', function(e) { expect(tile.getFeatures().length).to.be.greaterThan(0); expect(tile.getProjection().getUnits()).to.be('tile-pixels'); done(); @@ -93,7 +93,7 @@ describe('ol.featureloader', function() { }); -goog.require('goog.events'); +goog.require('ol.events'); goog.require('ol.VectorTile'); goog.require('ol.featureloader'); goog.require('ol.format.GeoJSON'); diff --git a/test/spec/ol/interaction/draganddropinteraction.test.js b/test/spec/ol/interaction/draganddropinteraction.test.js index fcb847009f..b6d48628b4 100644 --- a/test/spec/ol/interaction/draganddropinteraction.test.js +++ b/test/spec/ol/interaction/draganddropinteraction.test.js @@ -1,16 +1,101 @@ goog.provide('ol.test.interaction.DragAndDrop'); describe('ol.interaction.DragAndDrop', function() { + var viewport, map, interaction; + + beforeEach(function() { + viewport = new ol.events.EventTarget(); + map = { + getViewport: function() { + return viewport; + }, + getView: function() { + return new ol.View() + } + }; + interaction = new ol.interaction.DragAndDrop({ + formatConstructors: [ol.format.GeoJSON] + }); + }); describe('constructor', function() { it('can be constructed without arguments', function() { - var instance = new ol.interaction.DragAndDrop(); - expect(instance).to.be.an(ol.interaction.DragAndDrop); + var interaction = new ol.interaction.DragAndDrop(); + expect(interaction).to.be.an(ol.interaction.DragAndDrop); }); + it('sets formatConstructors on the instance', function() { + expect(interaction.formatConstructors_).to.have.length(1); + }); + + + }); + + describe('#setMap()', function() { + it('registers and unregisters listeners', function() { + interaction.setMap(map); + expect(viewport.hasListener(ol.events.EventType.DRAGENTER)).to.be(true); + expect(viewport.hasListener(ol.events.EventType.DRAGOVER)).to.be(true); + expect(viewport.hasListener(ol.events.EventType.DROP)).to.be(true); + interaction.setMap(null); + expect(viewport.hasListener(ol.events.EventType.DRAGENTER)).to.be(false); + expect(viewport.hasListener(ol.events.EventType.DRAGOVER)).to.be(false); + expect(viewport.hasListener(ol.events.EventType.DROP)).to.be(false); + }); + }); + + describe('#handleDrop_', function() { + var origFileReader = goog.global.FileReader; + + beforeEach(function() { + FileReader = function() { + ol.events.EventTarget.apply(this, arguments); + this.readAsText = function(file) { + this.result = file; + this.dispatchEvent('load'); + }; + }; + ol.inherits(FileReader, ol.events.EventTarget); + }); + + afterEach(function() { + goog.global.FileReader = origFileReader; + }); + + it('reads dropped files', function(done) { + interaction.on('addfeatures', function(evt) { + expect(evt.features.length).to.be(1); + done(); + }); + interaction.setMap(map); + var event = new ol.events.Event(); + event.dataTransfer = {}; + event.type = ol.events.EventType.DRAGENTER; + viewport.dispatchEvent(event); + event.type = ol.events.EventType.DRAGOVER; + viewport.dispatchEvent(event); + event.type = ol.events.EventType.DROP; + event.dataTransfer.files = { + length: 1, + item: function() { + return JSON.stringify({ + type: 'FeatureCollection', + features: [{type: 'Feature', id: '1'}] + }); + } + } + viewport.dispatchEvent(event); + expect(event.dataTransfer.dropEffect).to.be('copy'); + expect(event.propagationStopped).to.be(true); + }); }); }); goog.require('ol.interaction.DragAndDrop'); +goog.require('ol.View'); +goog.require('ol.events.Event'); +goog.require('ol.events.EventTarget'); +goog.require('ol.events.EventType'); +goog.require('ol.format.GeoJSON'); diff --git a/test/spec/ol/interaction/drawinteraction.test.js b/test/spec/ol/interaction/drawinteraction.test.js index 2beecff269..f08bb70617 100644 --- a/test/spec/ol/interaction/drawinteraction.test.js +++ b/test/spec/ol/interaction/drawinteraction.test.js @@ -51,11 +51,11 @@ describe('ol.interaction.Draw', function() { var shiftKey = opt_shiftKey !== undefined ? opt_shiftKey : false; var event = new ol.MapBrowserPointerEvent(type, map, new ol.pointer.PointerEvent(type, - new goog.events.BrowserEvent({ + { clientX: position.x + x + width / 2, clientY: position.y + y + height / 2, shiftKey: shiftKey - }))); + })); map.handleMapBrowserEvent(event); } @@ -163,8 +163,8 @@ describe('ol.interaction.Draw', function() { it('triggers draw events', function() { var ds = sinon.spy(); var de = sinon.spy(); - goog.events.listen(draw, ol.interaction.DrawEventType.DRAWSTART, ds); - goog.events.listen(draw, ol.interaction.DrawEventType.DRAWEND, de); + ol.events.listen(draw, ol.interaction.DrawEventType.DRAWSTART, ds); + ol.events.listen(draw, ol.interaction.DrawEventType.DRAWEND, de); simulateEvent('pointermove', 10, 20); simulateEvent('pointerdown', 10, 20); simulateEvent('pointerup', 10, 20); @@ -180,7 +180,7 @@ describe('ol.interaction.Draw', function() { end: 0, addfeature: 0 }; - goog.events.listen(draw, ol.interaction.DrawEventType.DRAWEND, + ol.events.listen(draw, ol.interaction.DrawEventType.DRAWEND, function() { expect(receivedEvents.end).to.be(0); expect(receivedEvents.addfeature).to.be(0); @@ -309,8 +309,8 @@ describe('ol.interaction.Draw', function() { it('triggers draw events', function() { var ds = sinon.spy(); var de = sinon.spy(); - goog.events.listen(draw, ol.interaction.DrawEventType.DRAWSTART, ds); - goog.events.listen(draw, ol.interaction.DrawEventType.DRAWEND, de); + ol.events.listen(draw, ol.interaction.DrawEventType.DRAWSTART, ds); + ol.events.listen(draw, ol.interaction.DrawEventType.DRAWEND, de); // first point simulateEvent('pointermove', 10, 20); @@ -467,8 +467,8 @@ describe('ol.interaction.Draw', function() { it('triggers draw events', function() { var ds = sinon.spy(); var de = sinon.spy(); - goog.events.listen(draw, ol.interaction.DrawEventType.DRAWSTART, ds); - goog.events.listen(draw, ol.interaction.DrawEventType.DRAWEND, de); + ol.events.listen(draw, ol.interaction.DrawEventType.DRAWSTART, ds); + ol.events.listen(draw, ol.interaction.DrawEventType.DRAWEND, de); // first point simulateEvent('pointermove', 10, 20); @@ -607,8 +607,8 @@ describe('ol.interaction.Draw', function() { it('triggers draw events', function() { var ds = sinon.spy(); var de = sinon.spy(); - goog.events.listen(draw, ol.interaction.DrawEventType.DRAWSTART, ds); - goog.events.listen(draw, ol.interaction.DrawEventType.DRAWEND, de); + ol.events.listen(draw, ol.interaction.DrawEventType.DRAWSTART, ds); + ol.events.listen(draw, ol.interaction.DrawEventType.DRAWEND, de); // first point simulateEvent('pointermove', 10, 20); @@ -805,7 +805,7 @@ describe('ol.interaction.Draw', function() { it('dispatches a drawstart event', function() { var spy = sinon.spy(); - goog.events.listen(draw, ol.interaction.DrawEventType.DRAWSTART, spy); + ol.events.listen(draw, ol.interaction.DrawEventType.DRAWSTART, spy); draw.extend(feature); expect(spy.callCount).to.be(1); }); @@ -814,8 +814,7 @@ describe('ol.interaction.Draw', function() { }); goog.require('goog.dispose'); -goog.require('goog.events'); -goog.require('goog.events.BrowserEvent'); +goog.require('ol.events'); goog.require('goog.style'); goog.require('ol.Feature'); goog.require('ol.Map'); diff --git a/test/spec/ol/interaction/interaction.test.js b/test/spec/ol/interaction/interaction.test.js index bff9c9ee13..7687bb4708 100644 --- a/test/spec/ol/interaction/interaction.test.js +++ b/test/spec/ol/interaction/interaction.test.js @@ -11,7 +11,7 @@ describe('ol.interaction.Interaction', function() { it('creates a new interaction', function() { expect(interaction).to.be.a(ol.interaction.Interaction); - expect(interaction).to.be.a(goog.events.EventTarget); + expect(interaction).to.be.a(ol.events.EventTarget); }); it('creates an active interaction', function() { @@ -55,6 +55,6 @@ describe('ol.interaction.Interaction', function() { }); -goog.require('goog.events.EventTarget'); +goog.require('ol.events.EventTarget'); goog.require('ol.Map'); goog.require('ol.interaction.Interaction'); diff --git a/test/spec/ol/interaction/keyboardpaninteraction.test.js b/test/spec/ol/interaction/keyboardpaninteraction.test.js new file mode 100644 index 0000000000..303c81e576 --- /dev/null +++ b/test/spec/ol/interaction/keyboardpaninteraction.test.js @@ -0,0 +1,58 @@ +/*global createMapDiv, disposeMap*/ +goog.provide('ol.test.interaction.KeyboardPan'); + + +describe('ol.interaction.KeyboardPan', function() { + var map; + + beforeEach(function() { + map = new ol.Map({ + target: createMapDiv(100, 100), + view: new ol.View({ + center: [0, 0], + resolutions: [1], + zoom: 0 + }) + }); + map.renderSync(); + }); + afterEach(function() { + disposeMap(map); + }); + + describe('handleEvent()', function() { + it('pans on arrow keys', function() { + var spy = sinon.spy(ol.interaction.Interaction, 'pan'); + var event = new ol.MapBrowserEvent(ol.events.EventType.KEYDOWN, map, { + type: ol.events.EventType.KEYDOWN, + target: map.getTargetElement(), + preventDefault: ol.events.Event.prototype.preventDefault + }); + event.originalEvent.keyCode = ol.events.KeyCode.DOWN; + map.handleMapBrowserEvent(event); + event.originalEvent.keyCode = ol.events.KeyCode.UP; + map.handleMapBrowserEvent(event); + event.originalEvent.keyCode = ol.events.KeyCode.LEFT; + map.handleMapBrowserEvent(event); + event.originalEvent.keyCode = ol.events.KeyCode.RIGHT; + map.handleMapBrowserEvent(event); + expect(spy.getCall(0).args[2]).to.eql([0, -128]); + expect(spy.getCall(1).args[2]).to.eql([0, 128]); + expect(spy.getCall(2).args[2]).to.eql([-128, 0]); + expect(spy.getCall(3).args[2]).to.eql([128, 0]); + ol.interaction.Interaction.pan.restore(); + }); + }); + +}); + + +goog.require('goog.object'); +goog.require('ol.Map'); +goog.require('ol.MapBrowserEvent'); +goog.require('ol.View'); +goog.require('ol.events.Event'); +goog.require('ol.events.EventType'); +goog.require('ol.events.KeyCode'); +goog.require('ol.interaction.Interaction'); +goog.require('ol.interaction.KeyboardPan'); diff --git a/test/spec/ol/interaction/keyboardzoominteraction.test.js b/test/spec/ol/interaction/keyboardzoominteraction.test.js new file mode 100644 index 0000000000..94ec0c9888 --- /dev/null +++ b/test/spec/ol/interaction/keyboardzoominteraction.test.js @@ -0,0 +1,51 @@ +/*global createMapDiv, disposeMap*/ +goog.provide('ol.test.interaction.KeyboardZoom'); + + +describe('ol.interaction.KeyboardZoom', function() { + var map; + + beforeEach(function() { + map = new ol.Map({ + target: createMapDiv(100, 100), + view: new ol.View({ + center: [0, 0], + resolutions: [1], + zoom: 0 + }) + }); + map.renderSync(); + }); + afterEach(function() { + disposeMap(map); + }); + + describe('handleEvent()', function() { + it('zooms on + and - keys', function() { + var spy = sinon.spy(ol.interaction.Interaction, 'zoomByDelta'); + var event = new ol.MapBrowserEvent(ol.events.EventType.KEYDOWN, map, { + type: ol.events.EventType.KEYDOWN, + target: map.getTargetElement(), + preventDefault: ol.events.Event.prototype.preventDefault + }); + event.originalEvent.charCode = '+'.charCodeAt(0); + map.handleMapBrowserEvent(event); + event.originalEvent.charCode = '-'.charCodeAt(0); + map.handleMapBrowserEvent(event); + expect(spy.getCall(0).args[2]).to.eql(1); + expect(spy.getCall(1).args[2]).to.eql(-1); + ol.interaction.Interaction.zoomByDelta.restore(); + }); + }); + +}); + + +goog.require('goog.object'); +goog.require('ol.Map'); +goog.require('ol.MapBrowserEvent'); +goog.require('ol.View'); +goog.require('ol.events.Event'); +goog.require('ol.events.EventType'); +goog.require('ol.interaction.Interaction'); +goog.require('ol.interaction.KeyboardZoom'); diff --git a/test/spec/ol/interaction/modifyinteraction.test.js b/test/spec/ol/interaction/modifyinteraction.test.js index 26da70ba5f..f6f8d5b7dd 100644 --- a/test/spec/ol/interaction/modifyinteraction.test.js +++ b/test/spec/ol/interaction/modifyinteraction.test.js @@ -68,13 +68,13 @@ describe('ol.interaction.Modify', function() { var shiftKey = opt_shiftKey !== undefined ? opt_shiftKey : false; var event = new ol.MapBrowserPointerEvent(type, map, new ol.pointer.PointerEvent(type, - new goog.events.BrowserEvent({ + { type: type, button: button, clientX: position.x + x + width / 2, clientY: position.y + y + height / 2, shiftKey: shiftKey - }))); + })); event.pointerEvent.pointerId = 1; map.handleMapBrowserEvent(event); } @@ -327,10 +327,10 @@ describe('ol.interaction.Modify', function() { beforeEach(function() { getListeners = function(feature, modify) { - var listeners = goog.events.getListeners( - feature, goog.events.EventType.CHANGE, false); + var listeners = ol.events.getListeners( + feature, 'change'); return listeners.filter(function(listener) { - return listener.handler == modify; + return listener.bindTo === modify; }); }; }); @@ -377,9 +377,7 @@ describe('ol.interaction.Modify', function() { }); goog.require('goog.dispose'); -goog.require('goog.events'); -goog.require('goog.events.EventType'); -goog.require('goog.events.BrowserEvent'); +goog.require('ol.events'); goog.require('goog.style'); goog.require('ol.Collection'); goog.require('ol.Feature'); diff --git a/test/spec/ol/interaction/mousewheelzoominteraction.test.js b/test/spec/ol/interaction/mousewheelzoominteraction.test.js new file mode 100644 index 0000000000..79e52d90dc --- /dev/null +++ b/test/spec/ol/interaction/mousewheelzoominteraction.test.js @@ -0,0 +1,136 @@ +/*global createMapDiv, disposeMap*/ +goog.provide('ol.test.interaction.MouseWheelZoom'); + + +describe('ol.interaction.MouseWheelZoom', function() { + var map; + + beforeEach(function() { + map = new ol.Map({ + target: createMapDiv(100, 100), + view: new ol.View({ + center: [0, 0], + resolutions: [2, 1, 0.5], + zoom: 1 + }) + }); + map.renderSync(); + }); + afterEach(function() { + disposeMap(map); + }); + + describe('handleEvent()', function() { + it('[wheel] works on Firefox in DOM_DELTA_PIXEL mode', function(done) { + var origHasFirefox = ol.has.FIREFOX; + ol.has.FIREFOX = true; + var spy = sinon.spy(ol.interaction.Interaction, 'zoomByDelta'); + map.once('postrender', function() { + expect(spy.getCall(0).args[2]).to.be(-1); + expect(spy.getCall(0).args[3]).to.eql([0, 0]); + ol.interaction.Interaction.zoomByDelta.restore(); + ol.has.FIREFOX = origHasFirefox; + done(); + }); + var event = new ol.MapBrowserEvent(ol.events.EventType.WHEEL, map, { + type: ol.events.EventType.WHEEL, + deltaMode: WheelEvent.DOM_DELTA_PIXEL, + deltaY: ol.has.DEVICE_PIXEL_RATIO, + target: map.getViewport(), + preventDefault: ol.events.Event.prototype.preventDefault + }); + event.coordinate = [0, 0]; + map.handleMapBrowserEvent(event); + }); + it('[wheel] works in DOM_DELTA_PIXEL mode', function(done) { + var origHasFirefox = ol.has.FIREFOX; + ol.has.FIREFOX = false; + var spy = sinon.spy(ol.interaction.Interaction, 'zoomByDelta'); + map.once('postrender', function() { + expect(spy.getCall(0).args[2]).to.be(-1); + expect(spy.getCall(0).args[3]).to.eql([0, 0]); + ol.interaction.Interaction.zoomByDelta.restore(); + ol.has.FIREFOX = origHasFirefox; + done(); + }); + var event = new ol.MapBrowserEvent(ol.events.EventType.WHEEL, map, { + type: ol.events.EventType.WHEEL, + deltaMode: WheelEvent.DOM_DELTA_PIXEL, + deltaY: 1, + target: map.getViewport(), + preventDefault: ol.events.Event.prototype.preventDefault + }); + event.coordinate = [0, 0]; + map.handleMapBrowserEvent(event); + }); + it('[wheel] works in DOM_DELTA_LINE mode', function(done) { + var spy = sinon.spy(ol.interaction.Interaction, 'zoomByDelta'); + map.once('postrender', function() { + expect(spy.getCall(0).args[2]).to.be(-1); + expect(spy.getCall(0).args[3]).to.eql([0, 0]); + ol.interaction.Interaction.zoomByDelta.restore(); + done(); + }); + var event = new ol.MapBrowserEvent(ol.events.EventType.WHEEL, map, { + type: ol.events.EventType.WHEEL, + deltaMode: WheelEvent.DOM_DELTA_LINE, + deltaY: 1 / 40, + target: map.getViewport(), + preventDefault: ol.events.Event.prototype.preventDefault + }); + event.coordinate = [0, 0]; + map.handleMapBrowserEvent(event); + }); + it('[mousewheel] works on Safari', function(done) { + var origHasSafari = ol.has.SAFARI; + ol.has.SAFARI = true; + var spy = sinon.spy(ol.interaction.Interaction, 'zoomByDelta'); + map.once('postrender', function() { + expect(spy.getCall(0).args[2]).to.be(-1); + expect(spy.getCall(0).args[3]).to.eql([0, 0]); + ol.interaction.Interaction.zoomByDelta.restore(); + ol.has.SAFARI = origHasSafari; + done(); + }); + var event = new ol.MapBrowserEvent(ol.events.EventType.MOUSEWHEEL, map, { + type: ol.events.EventType.MOUSEWHEEL, + wheelDeltaY: -3, + target: map.getViewport(), + preventDefault: ol.events.Event.prototype.preventDefault + }); + event.coordinate = [0, 0]; + map.handleMapBrowserEvent(event); + }); + it('[mousewheel] works on other browsers', function(done) { + var origHasSafari = ol.has.SAFARI; + ol.has.SAFARI = false; + var spy = sinon.spy(ol.interaction.Interaction, 'zoomByDelta'); + map.once('postrender', function() { + expect(spy.getCall(0).args[2]).to.be(-1); + expect(spy.getCall(0).args[3]).to.eql([0, 0]); + ol.interaction.Interaction.zoomByDelta.restore(); + ol.has.SAFARI = origHasSafari; + done(); + }); + var event = new ol.MapBrowserEvent(ol.events.EventType.MOUSEWHEEL, map, { + type: ol.events.EventType.MOUSEWHEEL, + wheelDeltaY: -1, + target: map.getViewport(), + preventDefault: ol.events.Event.prototype.preventDefault + }); + event.coordinate = [0, 0]; + map.handleMapBrowserEvent(event); + }); + }); + +}); + + +goog.require('goog.object'); +goog.require('ol.Map'); +goog.require('ol.MapBrowserEvent'); +goog.require('ol.View'); +goog.require('ol.events.Event'); +goog.require('ol.events.EventType'); +goog.require('ol.interaction.Interaction'); +goog.require('ol.interaction.MouseWheelZoom'); diff --git a/test/spec/ol/interaction/selectinteraction.test.js b/test/spec/ol/interaction/selectinteraction.test.js index e032b3f28c..7bc518130c 100644 --- a/test/spec/ol/interaction/selectinteraction.test.js +++ b/test/spec/ol/interaction/selectinteraction.test.js @@ -82,11 +82,11 @@ describe('ol.interaction.Select', function() { var shiftKey = opt_shiftKey !== undefined ? opt_shiftKey : false; var event = new ol.MapBrowserPointerEvent(type, map, new ol.pointer.PointerEvent(type, - new goog.events.BrowserEvent({ + { clientX: position.x + x + width / 2, clientY: position.y + y + height / 2, shiftKey: shiftKey - }))); + })); map.handleMapBrowserEvent(event); } @@ -333,8 +333,6 @@ describe('ol.interaction.Select', function() { }); goog.require('goog.dispose'); -goog.require('goog.events'); -goog.require('goog.events.BrowserEvent'); goog.require('goog.style'); goog.require('ol.Collection'); goog.require('ol.Feature'); diff --git a/test/spec/ol/interaction/translateinteraction.test.js b/test/spec/ol/interaction/translateinteraction.test.js index 0c4b186a07..a0c79e1bc4 100644 --- a/test/spec/ol/interaction/translateinteraction.test.js +++ b/test/spec/ol/interaction/translateinteraction.test.js @@ -56,12 +56,11 @@ describe('ol.interaction.Translate', function() { var position = goog.style.getClientPosition(viewport); var shiftKey = opt_shiftKey !== undefined ? opt_shiftKey : false; var event = new ol.MapBrowserPointerEvent(type, map, - new ol.pointer.PointerEvent(type, - new goog.events.BrowserEvent({ + new ol.pointer.PointerEvent(type, { clientX: position.x + x + width / 2, clientY: position.y + y + height / 2, shiftKey: shiftKey - }))); + })); map.handleMapBrowserEvent(event); } @@ -110,8 +109,6 @@ describe('ol.interaction.Translate', function() { }); goog.require('goog.dispose'); -goog.require('goog.events'); -goog.require('goog.events.BrowserEvent'); goog.require('goog.style'); goog.require('ol.Collection'); goog.require('ol.Feature'); diff --git a/test/spec/ol/layer/layergroup.test.js b/test/spec/ol/layer/layergroup.test.js index c9bbf07bd1..be86aed6a5 100644 --- a/test/spec/ol/layer/layergroup.test.js +++ b/test/spec/ol/layer/layergroup.test.js @@ -68,14 +68,14 @@ describe('ol.layer.Group', function() { }); it('is dispatched by the group when layer opacity changes', function() { - group.on(goog.events.EventType.CHANGE, listener); + group.on(ol.events.EventType.CHANGE, listener); layer.setOpacity(0.5); expect(listener.calledOnce).to.be(true); }); it('is dispatched by the group when layer visibility changes', function() { - group.on(goog.events.EventType.CHANGE, listener); + group.on(ol.events.EventType.CHANGE, listener); layer.setVisible(false); expect(listener.callCount).to.be(1); @@ -286,14 +286,14 @@ describe('ol.layer.Group', function() { var listeners = layerGroup.listenerKeys_[goog.getUid(layer)]; expect(listeners.length).to.eql(2); - expect(listeners[0]).to.be.a(goog.events.Listener); - expect(listeners[1]).to.be.a(goog.events.Listener); + expect(typeof listeners[0]).to.be('object'); + expect(typeof listeners[1]).to.be('object'); // remove the layer from the group layers.pop(); expect(goog.object.getCount(layerGroup.listenerKeys_)).to.eql(0); - expect(listeners[0].removed).to.eql(true); - expect(listeners[1].removed).to.eql(true); + expect(listeners[0].listener).to.be(undefined); + expect(listeners[1].listener).to.be(undefined); }); }); @@ -491,8 +491,8 @@ describe('ol.layer.Group', function() { goog.require('goog.array'); goog.require('goog.dispose'); -goog.require('goog.events.EventType'); -goog.require('goog.events.Listener'); +goog.require('ol.events'); +goog.require('ol.events.EventType'); goog.require('goog.object'); goog.require('ol.ObjectEventType'); goog.require('ol.extent'); diff --git a/test/spec/ol/map.test.js b/test/spec/ol/map.test.js index 1423e7a3e2..85f6a20633 100644 --- a/test/spec/ol/map.test.js +++ b/test/spec/ol/map.test.js @@ -147,11 +147,14 @@ describe('ol.Map', function() { document.body.removeChild(target); }); - it('results in an postrender event', function(done) { + it('calls renderFrame_ and results in an postrender event', function(done) { + var spy = sinon.spy(map, 'renderFrame_'); map.render(); map.once('postrender', function(event) { expect(event).to.be.a(ol.MapEvent); + expect(typeof spy.firstCall.args[0]).to.be('number'); + spy.restore(); var frameState = event.frameState; expect(frameState).not.to.be(null); done(); @@ -159,6 +162,30 @@ describe('ol.Map', function() { }); + it('uses the same render frame for subsequent calls', function(done) { + var id1, id2; + map.render(); + id1 = map.animationDelayKey_; + map.once('postrender', function() { + expect(id2).to.be(id1); + done(); + }); + map.render(); + id2 = map.animationDelayKey_; + }); + + it('creates a new render frame after renderSync()', function(done) { + var id1, id2; + map.render(); + id1 = map.animationDelayKey_; + map.once('postrender', function() { + expect(id2).to.not.be(id1); + done(); + }); + map.renderSync(); + id2 = map.animationDelayKey_; + }); + it('results in an postrender event (for zero height map)', function(done) { target.style.height = '0px'; map.updateSize(); @@ -202,6 +229,11 @@ describe('ol.Map', function() { goog.dispose(map); expect(goog.dom.getParentElement(map.getViewport())).to.be(null); }); + + it('removes window listeners', function() { + goog.dispose(map); + expect(map.handleResize_).to.be(undefined); + }); }); describe('#setTarget', function() { @@ -211,17 +243,13 @@ describe('ol.Map', function() { map = new ol.Map({ target: document.createElement('div') }); - var viewportResizeListeners = map.viewportSizeMonitor_.getListeners( - goog.events.EventType.RESIZE, false); - expect(viewportResizeListeners).to.have.length(1); + expect(map.handleResize_).to.be.ok(); }); describe('call setTarget with null', function() { it('unregisters the viewport resize listener', function() { map.setTarget(null); - var viewportResizeListeners = map.viewportSizeMonitor_.getListeners( - goog.events.EventType.RESIZE, false); - expect(viewportResizeListeners).to.have.length(0); + expect(map.handleResize_).to.be(undefined); }); }); @@ -229,9 +257,7 @@ describe('ol.Map', function() { it('registers a viewport resize listener', function() { map.setTarget(null); map.setTarget(document.createElement('div')); - var viewportResizeListeners = map.viewportSizeMonitor_.getListeners( - goog.events.EventType.RESIZE, false); - expect(viewportResizeListeners).to.have.length(1); + expect(map.handleResize_).to.be.ok(); }); }); @@ -316,15 +342,15 @@ describe('ol.Map', function() { target: target }); - var browserEvent = new goog.events.BrowserEvent({ + var browserEvent = { type: 'touchend', target: target, changedTouches: [{ clientX: 100, clientY: 200 }] - }); - var position = map.getEventPixel(browserEvent.getBrowserEvent()); + }; + var position = map.getEventPixel(browserEvent); // 80 = clientX - target.style.left expect(position[0]).to.eql(80); // 190 = clientY - target.style.top @@ -401,8 +427,6 @@ describe('ol.Map', function() { goog.require('goog.dispose'); goog.require('goog.dom'); -goog.require('goog.events.BrowserEvent'); -goog.require('goog.events.EventType'); goog.require('ol.Map'); goog.require('ol.MapEvent'); goog.require('ol.Overlay'); diff --git a/test/spec/ol/mapbrowserevent.test.js b/test/spec/ol/mapbrowserevent.test.js index db2c1c9697..197677f742 100644 --- a/test/spec/ol/mapbrowserevent.test.js +++ b/test/spec/ol/mapbrowserevent.test.js @@ -17,13 +17,13 @@ describe('ol.MapBrowserEventHandler', function() { })); clickSpy = sinon.spy(); - goog.events.listen(handler, 'click', clickSpy); + ol.events.listen(handler, 'click', clickSpy); singleclickSpy = sinon.spy(); - goog.events.listen(handler, 'singleclick', singleclickSpy); + ol.events.listen(handler, 'singleclick', singleclickSpy); dblclickSpy = sinon.spy(); - goog.events.listen(handler, 'dblclick', dblclickSpy); + ol.events.listen(handler, 'dblclick', dblclickSpy); }); @@ -32,24 +32,22 @@ describe('ol.MapBrowserEventHandler', function() { }); it('emulates click', function() { - handler.emulateClick_(new ol.pointer.PointerEvent('pointerdown', - new goog.events.BrowserEvent({ - type: 'mousedown', - target: target, - clientX: 0, - clientY: 0 - }))); + handler.emulateClick_(new ol.pointer.PointerEvent('pointerdown', { + type: 'mousedown', + target: target, + clientX: 0, + clientY: 0 + })); expect(clickSpy.called).to.be.ok(); }); it('emulates singleclick', function() { - handler.emulateClick_(new ol.pointer.PointerEvent('pointerdown', - new goog.events.BrowserEvent({ - type: 'mousedown', - target: target, - clientX: 0, - clientY: 0 - }))); + handler.emulateClick_(new ol.pointer.PointerEvent('pointerdown', { + type: 'mousedown', + target: target, + clientX: 0, + clientY: 0 + })); expect(singleclickSpy.called).to.not.be.ok(); expect(dblclickSpy.called).to.not.be.ok(); @@ -57,35 +55,32 @@ describe('ol.MapBrowserEventHandler', function() { expect(singleclickSpy.calledOnce).to.be.ok(); expect(dblclickSpy.called).to.not.be.ok(); - handler.emulateClick_(new ol.pointer.PointerEvent('pointerdown', - new goog.events.BrowserEvent({ - type: 'mousedown', - target: target, - clientX: 0, - clientY: 0 - }))); + handler.emulateClick_(new ol.pointer.PointerEvent('pointerdown', { + type: 'mousedown', + target: target, + clientX: 0, + clientY: 0 + })); expect(singleclickSpy.calledOnce).to.be.ok(); expect(dblclickSpy.called).to.not.be.ok(); }); it('emulates dblclick', function() { - handler.emulateClick_(new ol.pointer.PointerEvent('pointerdown', - new goog.events.BrowserEvent({ - type: 'mousedown', - target: target, - clientX: 0, - clientY: 0 - }))); + handler.emulateClick_(new ol.pointer.PointerEvent('pointerdown', { + type: 'mousedown', + target: target, + clientX: 0, + clientY: 0 + })); expect(singleclickSpy.called).to.not.be.ok(); expect(dblclickSpy.called).to.not.be.ok(); - handler.emulateClick_(new ol.pointer.PointerEvent('pointerdown', - new goog.events.BrowserEvent({ - type: 'mousedown', - target: target, - clientX: 0, - clientY: 0 - }))); + handler.emulateClick_(new ol.pointer.PointerEvent('pointerdown', { + type: 'mousedown', + target: target, + clientX: 0, + clientY: 0 + })); expect(singleclickSpy.called).to.not.be.ok(); expect(dblclickSpy.calledOnce).to.be.ok(); @@ -108,8 +103,7 @@ describe('ol.MapBrowserEventHandler', function() { }); it('is an event after handlePointerDown_ has been called', function() { - var event = new ol.pointer.PointerEvent('pointerdown', - new goog.events.BrowserEvent({})); + var event = new ol.pointer.PointerEvent('pointerdown', {}); handler.handlePointerDown_(event); expect(handler.down_).to.be(event); }); @@ -118,8 +112,7 @@ describe('ol.MapBrowserEventHandler', function() { }); goog.require('goog.dom'); -goog.require('goog.events'); -goog.require('goog.events.BrowserEvent'); +goog.require('ol.events'); goog.require('ol.Map'); goog.require('ol.MapBrowserEventHandler'); goog.require('ol.pointer.PointerEvent'); diff --git a/test/spec/ol/net.test.js b/test/spec/ol/net.test.js new file mode 100644 index 0000000000..718ec84024 --- /dev/null +++ b/test/spec/ol/net.test.js @@ -0,0 +1,80 @@ +goog.provide('ol.test.net'); + + +describe('ol.net', function() { + + describe('jsonp()', function() { + var head = goog.global.document.getElementsByTagName('head')[0]; + var origAppendChild = head.appendChild; + var origCreateElement = document.createElement; + var origSetTimeout = goog.global.setTimeout; + var key, removeChild; + + function createCallback(url, done) { + removeChild = sinon.spy(); + var callback = function(data) { + expect(data).to.be(url + key); + expect(removeChild.called).to.be(true); + done(); + }; + key = 'olc_' + goog.getUid(callback); + return callback; + } + + beforeEach(function() { + document.createElement = function() { + return {} + }; + head.appendChild = function(element) { + element.parentNode = { + removeChild: removeChild + }; + origSetTimeout(function() { + goog.global[key](element.src); + }, 0); + }; + goog.global.setTimeout = function(fn, time) { + origSetTimeout(fn, 100); + }; + }); + + afterEach(function() { + document.createElement = origCreateElement; + head.appendChild = origAppendChild; + goog.global.setTimeout = origSetTimeout; + }); + + it('appends callback param to url, cleans up after call', function(done) { + ol.net.jsonp('foo', createCallback('foo?callback=', done)); + }); + it('appends correct callback param to a url with query', function(done) { + var callback = createCallback('http://foo/bar?baz&callback=', done); + ol.net.jsonp('http://foo/bar?baz', callback); + }); + it('calls errback when jsonp is not executed, cleans up', function(done) { + head.appendChild = function(element) { + element.parentNode = { + removeChild: removeChild + }; + }; + function callback() { + expect.fail(); + } + function errback() { + expect(goog.global[key]).to.be(undefined); + expect(removeChild.called).to.be(true); + done(); + } + ol.net.jsonp('foo', callback, errback); + }); + it('accepts a custom callback param', function(done) { + var callback = createCallback('foo?mycallback=', done); + ol.net.jsonp('foo', callback, undefined, 'mycallback'); + }); + + }); + +}); + + +goog.require('ol.net'); diff --git a/test/spec/ol/object.test.js b/test/spec/ol/object.test.js index a08dba7c78..87aa668e09 100644 --- a/test/spec/ol/object.test.js +++ b/test/spec/ol/object.test.js @@ -113,10 +113,10 @@ describe('ol.Object', function() { beforeEach(function() { listener1 = sinon.spy(); - goog.events.listen(o, 'change:k', listener1); + ol.events.listen(o, 'change:k', listener1); listener2 = sinon.spy(); - goog.events.listen(o, ol.ObjectEventType.PROPERTYCHANGE, listener2); + ol.events.listen(o, ol.ObjectEventType.PROPERTYCHANGE, listener2); }); it('dispatches events', function() { @@ -146,10 +146,10 @@ describe('ol.Object', function() { beforeEach(function() { listener1 = sinon.spy(); - goog.events.listen(o, 'change:k', listener1); + ol.events.listen(o, 'change:k', listener1); listener2 = sinon.spy(); - goog.events.listen(o, ol.ObjectEventType.PROPERTYCHANGE, listener2); + ol.events.listen(o, ol.ObjectEventType.PROPERTYCHANGE, listener2); }); it('dispatches events to object', function() { @@ -222,9 +222,9 @@ describe('ol.Object', function() { beforeEach(function() { listener1 = sinon.spy(); - goog.events.listen(o, 'change:k', listener1); + ol.events.listen(o, 'change:k', listener1); listener2 = sinon.spy(); - goog.events.listen(o, 'change:K', listener2); + ol.events.listen(o, 'change:K', listener2); }); it('dispatches the expected event', function() { @@ -239,6 +239,6 @@ describe('ol.Object', function() { }); -goog.require('goog.events'); +goog.require('ol.events'); goog.require('ol.Object'); goog.require('ol.ObjectEventType'); diff --git a/test/spec/ol/observable.test.js b/test/spec/ol/observable.test.js index 890e83c842..73b158f096 100644 --- a/test/spec/ol/observable.test.js +++ b/test/spec/ol/observable.test.js @@ -7,7 +7,7 @@ describe('ol.Observable', function() { it('creates a new observable', function() { var observable = new ol.Observable(); expect(observable).to.be.a(ol.Observable); - expect(observable).to.be.a(goog.events.EventTarget); + expect(observable).to.be.a(ol.events.EventTarget); }); }); @@ -51,7 +51,7 @@ describe('ol.Observable', function() { it('returns a listener key', function() { var key = observable.on('foo', listener); - expect(key).to.be.a(goog.events.Listener); + expect(typeof key).to.be('object'); }); }); @@ -101,7 +101,7 @@ describe('ol.Observable', function() { it('returns a listener key', function() { var key = observable.once('foo', listener); - expect(key).to.be.a(goog.events.Listener); + expect(typeof key).to.be('object'); }); }); @@ -167,6 +167,5 @@ describe('ol.Observable', function() { }); -goog.require('goog.events.EventTarget'); -goog.require('goog.events.Listener'); +goog.require('ol.events.EventTarget'); goog.require('ol.Observable'); diff --git a/test/spec/ol/pointer/mousesource.test.js b/test/spec/ol/pointer/mousesource.test.js index 224a9d9e26..b5197d75e6 100644 --- a/test/spec/ol/pointer/mousesource.test.js +++ b/test/spec/ol/pointer/mousesource.test.js @@ -8,7 +8,7 @@ describe('ol.pointer.MouseSource', function() { beforeEach(function() { clock = sinon.useFakeTimers(); - target = goog.dom.createElement('DIV'); + target = new ol.events.EventTarget(); // make sure that a mouse and touch event source is used ol.has.POINTER = false; @@ -26,7 +26,7 @@ describe('ol.pointer.MouseSource', function() { describe('simulated mouse events', function() { it('prevents simulated mouse events', function() { - goog.events.listen(handler, 'pointerdown', eventSpy); + ol.events.listen(handler, 'pointerdown', eventSpy); // simulates that a mouse event is triggered from a touch simulateTouchEvent('touchstart', 10, 20); @@ -37,7 +37,7 @@ describe('ol.pointer.MouseSource', function() { }); it('dispatches real mouse events', function() { - goog.events.listen(handler, 'pointerdown', eventSpy); + ol.events.listen(handler, 'pointerdown', eventSpy); // the two events are at different positions simulateTouchEvent('touchstart', 10, 20); @@ -50,7 +50,7 @@ describe('ol.pointer.MouseSource', function() { // set the timeout to a lower value, to speed up the tests ol.pointer.TouchSource.DEDUP_TIMEOUT = 100; - goog.events.listen(handler, 'pointerdown', eventSpy); + ol.events.listen(handler, 'pointerdown', eventSpy); // first simulate a touch event, then a mouse event // at the same position after a timeout @@ -70,28 +70,28 @@ describe('ol.pointer.MouseSource', function() { target: target }]; - var event = new goog.events.BrowserEvent({ + var event = { type: type, touches: touches, changedTouches: touches - }); - goog.events.fireListeners(target, type, false, event); + }; + target.dispatchEvent(event); } function simulateEvent(type, x, y) { - var event = new goog.events.BrowserEvent({ + var event = { type: type, clientX: x, clientY: y, target: target - }); - goog.events.fireListeners(target, type, false, event); + }; + target.dispatchEvent(event); } }); goog.require('goog.dom'); -goog.require('goog.events'); -goog.require('goog.events.BrowserEvent'); +goog.require('ol.events'); +goog.require('ol.events.EventTarget'); goog.require('ol.has'); goog.require('ol.pointer.MouseSource'); goog.require('ol.pointer.PointerEvent'); diff --git a/test/spec/ol/pointer/pointereventhandler.test.js b/test/spec/ol/pointer/pointereventhandler.test.js index 4afa185699..4c92d08324 100644 --- a/test/spec/ol/pointer/pointereventhandler.test.js +++ b/test/spec/ol/pointer/pointereventhandler.test.js @@ -6,7 +6,7 @@ describe('ol.pointer.PointerEventHandler', function() { var eventSpy; beforeEach(function() { - target = goog.dom.createElement('DIV'); + target = new ol.events.EventTarget(); // make sure that a mouse event source is used ol.has.POINTER = false; @@ -29,18 +29,18 @@ describe('ol.pointer.PointerEventHandler', function() { }); function simulateEvent(type, x, y) { - var event = new goog.events.BrowserEvent({ + var event = { type: type, clientX: x, clientY: y, target: target - }); - goog.events.fireListeners(target, type, false, event); + }; + target.dispatchEvent(event); } describe('pointer down', function() { it('fires pointerdown events', function() { - goog.events.listen(handler, 'pointerdown', eventSpy); + ol.events.listen(handler, 'pointerdown', eventSpy); simulateEvent('mousedown', 0, 0); expect(eventSpy.calledOnce).to.be.ok(); @@ -54,7 +54,7 @@ describe('ol.pointer.PointerEventHandler', function() { describe('pointer up', function() { it('fires pointerup events', function() { - goog.events.listen(handler, 'pointerup', eventSpy); + ol.events.listen(handler, 'pointerup', eventSpy); simulateEvent('mousedown', 0, 0); simulateEvent('mouseup', 0, 0); expect(eventSpy.calledOnce).to.be.ok(); @@ -63,7 +63,7 @@ describe('ol.pointer.PointerEventHandler', function() { describe('pointer move', function() { it('fires pointermove events', function() { - goog.events.listen(handler, 'pointermove', eventSpy); + ol.events.listen(handler, 'pointermove', eventSpy); simulateEvent('mousemove', 0, 0); expect(eventSpy.calledOnce).to.be.ok(); }); @@ -74,8 +74,8 @@ describe('ol.pointer.PointerEventHandler', function() { var enterEventSpy = sinon.spy(); var overEventSpy = sinon.spy(); - goog.events.listen(handler, 'pointerenter', enterEventSpy); - goog.events.listen(handler, 'pointerover', overEventSpy); + ol.events.listen(handler, 'pointerenter', enterEventSpy); + ol.events.listen(handler, 'pointerover', overEventSpy); simulateEvent('mouseover', 0, 0); @@ -89,8 +89,8 @@ describe('ol.pointer.PointerEventHandler', function() { var leaveEventSpy = sinon.spy(); var outEventSpy = sinon.spy(); - goog.events.listen(handler, 'pointerleave', leaveEventSpy); - goog.events.listen(handler, 'pointerout', outEventSpy); + ol.events.listen(handler, 'pointerleave', leaveEventSpy); + ol.events.listen(handler, 'pointerout', outEventSpy); simulateEvent('mouseout', 0, 0); @@ -107,7 +107,7 @@ describe('ol.pointer.PointerEventHandler', function() { clientX: 1, clientY: 2 }; - var browserEvent = new goog.events.BrowserEvent(event); + var browserEvent = event; var eventClone = handler.cloneEvent(browserEvent, event); @@ -136,7 +136,7 @@ describe('ol.pointer.PointerEventHandler', function() { clientX: 1, clientY: 2 }; - var browserEvent = new goog.events.BrowserEvent(event); + var browserEvent = event; var eventClone = handler.cloneEvent(browserEvent, event); var pointerEvent = handler.makeEvent('pointerdown', @@ -161,8 +161,8 @@ describe('ol.pointer.PointerEventHandler', function() { }); goog.require('goog.dom'); -goog.require('goog.events'); -goog.require('goog.events.BrowserEvent'); +goog.require('ol.events'); +goog.require('ol.events.EventTarget'); goog.require('ol.has'); goog.require('ol.pointer.MouseSource'); goog.require('ol.pointer.PointerEvent'); diff --git a/test/spec/ol/pointer/touchsource.test.js b/test/spec/ol/pointer/touchsource.test.js index fcbbb195f4..304ec45a91 100644 --- a/test/spec/ol/pointer/touchsource.test.js +++ b/test/spec/ol/pointer/touchsource.test.js @@ -8,7 +8,7 @@ describe('ol.pointer.TouchSource', function() { var eventSpy; beforeEach(function() { - target = goog.dom.createElement('DIV'); + target = new ol.events.EventTarget(); // make sure that a mouse and touch event source is used ol.has.POINTER = false; @@ -25,7 +25,7 @@ describe('ol.pointer.TouchSource', function() { describe('pointer event creation', function() { it('generates pointer events for each touch contact', function() { - goog.events.listen(handler, 'pointerdown', eventSpy); + ol.events.listen(handler, 'pointerdown', eventSpy); simulateTouchEvent('touchstart', [ {identifier: 3, clientX: 10, clientY: 11}, @@ -52,7 +52,7 @@ describe('ol.pointer.TouchSource', function() { }); it('creates the right pointer events', function() { - goog.events.listen(handler, 'pointerdown', eventSpy); + ol.events.listen(handler, 'pointerdown', eventSpy); // first touch simulateTouchEvent('touchstart', [ @@ -71,7 +71,7 @@ describe('ol.pointer.TouchSource', function() { // first touch moves var moveEventSpy = sinon.spy(); - goog.events.listen(handler, 'pointermove', moveEventSpy); + ol.events.listen(handler, 'pointermove', moveEventSpy); simulateTouchEvent('touchmove', [ {identifier: 3, clientX: 15, clientY: 16} @@ -81,7 +81,7 @@ describe('ol.pointer.TouchSource', function() { // and then both touches go up var upEventSpy = sinon.spy(); - goog.events.listen(handler, 'pointerup', upEventSpy); + ol.events.listen(handler, 'pointerup', upEventSpy); simulateTouchEvent('touchend', [ {identifier: 3, clientX: 15, clientY: 16}, @@ -93,7 +93,7 @@ describe('ol.pointer.TouchSource', function() { }); it('handles flawed touches', function() { - goog.events.listen(handler, 'pointerdown', eventSpy); + ol.events.listen(handler, 'pointerdown', eventSpy); // first touch simulateTouchEvent('touchstart', [ @@ -104,7 +104,7 @@ describe('ol.pointer.TouchSource', function() { // second touch, but the first touch has disappeared var cancelEventSpy = sinon.spy(); - goog.events.listen(handler, 'pointercancel', cancelEventSpy); + ol.events.listen(handler, 'pointercancel', cancelEventSpy); simulateTouchEvent('touchstart', [ {identifier: 4, clientX: 30, clientY: 45} ], [{identifier: 4}] @@ -120,18 +120,19 @@ describe('ol.pointer.TouchSource', function() { function simulateTouchEvent(type, changedTouches, touches) { touches = touches !== undefined ? touches : changedTouches; - var event = new goog.events.BrowserEvent({ - type: type, + var event = new ol.events.Event(type); + goog.object.extend(event, { touches: touches, changedTouches: changedTouches }); - goog.events.fireListeners(target, type, false, event); + target.dispatchEvent(event); } }); goog.require('goog.dom'); -goog.require('goog.events'); -goog.require('goog.events.BrowserEvent'); +goog.require('ol.events'); +goog.require('ol.events.Event'); +goog.require('ol.events.EventTarget'); goog.require('ol.has'); goog.require('ol.pointer.PointerEvent'); goog.require('ol.pointer.PointerEventHandler'); diff --git a/test/spec/ol/render/vector.test.js b/test/spec/ol/render/vector.test.js index 973075d840..d4f4743c97 100644 --- a/test/spec/ol/render/vector.test.js +++ b/test/spec/ol/render/vector.test.js @@ -39,8 +39,8 @@ describe('ol.renderer.vector', function() { style, squaredTolerance, listener, listenerThis); expect(iconStyleLoadSpy.calledOnce).to.be.ok(); - listeners = goog.events.getListeners( - iconStyle.iconImage_, goog.events.EventType.CHANGE, false); + listeners = ol.events.getListeners( + iconStyle.iconImage_, ol.events.EventType.CHANGE); expect(listeners.length).to.eql(1); // call #2 @@ -48,8 +48,8 @@ describe('ol.renderer.vector', function() { style, squaredTolerance, listener, listenerThis); expect(iconStyleLoadSpy.calledOnce).to.be.ok(); - listeners = goog.events.getListeners( - iconStyle.iconImage_, goog.events.EventType.CHANGE, false); + listeners = ol.events.getListeners( + iconStyle.iconImage_, ol.events.EventType.CHANGE); expect(listeners.length).to.eql(1); }); @@ -155,8 +155,8 @@ describe('ol.renderer.vector', function() { }); }); -goog.require('goog.events'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.EventType'); goog.require('ol.geom.LineString'); goog.require('ol.geom.Point'); goog.require('ol.geom.Polygon'); diff --git a/test/spec/ol/renderer/layerrenderer.test.js b/test/spec/ol/renderer/layerrenderer.test.js index d1c43db8b4..b7e8f00e25 100644 --- a/test/spec/ol/renderer/layerrenderer.test.js +++ b/test/spec/ol/renderer/layerrenderer.test.js @@ -2,7 +2,7 @@ goog.provide('ol.test.renderer.Layer'); describe('ol.renderer.Layer', function() { var renderer; - var eventType = goog.events.EventType.CHANGE; + var eventType = ol.events.EventType.CHANGE; beforeEach(function() { var layer = new ol.layer.Layer({}); @@ -79,7 +79,7 @@ describe('ol.renderer.Layer', function() { }); }); -goog.require('goog.events.EventType'); +goog.require('ol.events.EventType'); goog.require('ol.Image'); goog.require('ol.ImageState'); goog.require('ol.layer.Layer'); diff --git a/test/spec/ol/reproj/image.test.js b/test/spec/ol/reproj/image.test.js index 13d8a8627a..72c50e19ce 100644 --- a/test/spec/ol/reproj/image.test.js +++ b/test/spec/ol/reproj/image.test.js @@ -18,7 +18,7 @@ describe('ol.reproj.Image', function() { it('changes state as expected', function(done) { var image = createImage(1); expect(image.getState()).to.be(ol.ImageState.IDLE); - image.listen('change', function() { + ol.events.listen(image, 'change', function() { if (image.getState() == ol.ImageState.LOADED) { done(); } @@ -28,7 +28,7 @@ describe('ol.reproj.Image', function() { it('returns correct canvas size', function(done) { var image = createImage(1); - image.listen('change', function() { + ol.events.listen(image, 'change', function() { if (image.getState() == ol.ImageState.LOADED) { var canvas = image.getImage(); expect(canvas.width).to.be(36); @@ -41,7 +41,7 @@ describe('ol.reproj.Image', function() { it('respects pixelRatio', function(done) { var image = createImage(2); - image.listen('change', function() { + ol.events.listen(image, 'change', function() { if (image.getState() == ol.ImageState.LOADED) { var canvas = image.getImage(); expect(canvas.width).to.be(72); @@ -56,5 +56,6 @@ describe('ol.reproj.Image', function() { goog.require('ol.Image'); goog.require('ol.ImageState'); +goog.require('ol.events'); goog.require('ol.proj'); goog.require('ol.reproj.Image'); diff --git a/test/spec/ol/reproj/tile.test.js b/test/spec/ol/reproj/tile.test.js index 27d35b4740..ef404c6084 100644 --- a/test/spec/ol/reproj/tile.test.js +++ b/test/spec/ol/reproj/tile.test.js @@ -34,7 +34,7 @@ describe('ol.reproj.Tile', function() { it('changes state as expected', function(done) { var tile = createTile(1); expect(tile.getState()).to.be(ol.TileState.IDLE); - tile.listen('change', function() { + ol.events.listen(tile, 'change', function() { if (tile.getState() == ol.TileState.LOADED) { done(); } @@ -68,7 +68,7 @@ describe('ol.reproj.Tile', function() { it('respects tile size of target tile grid', function(done) { var tile = createTile(1, [100, 40]); - tile.listen('change', function() { + ol.events.listen(tile, 'change', function() { if (tile.getState() == ol.TileState.LOADED) { var canvas = tile.getImage(); expect(canvas.width).to.be(100); @@ -81,7 +81,7 @@ describe('ol.reproj.Tile', function() { it('respects pixelRatio', function(done) { var tile = createTile(3, [60, 20]); - tile.listen('change', function() { + ol.events.listen(tile, 'change', function() { if (tile.getState() == ol.TileState.LOADED) { var canvas = tile.getImage(); expect(canvas.width).to.be(180); @@ -96,5 +96,6 @@ describe('ol.reproj.Tile', function() { goog.require('ol.ImageTile'); goog.require('ol.TileState'); +goog.require('ol.events'); goog.require('ol.proj'); goog.require('ol.reproj.Tile'); diff --git a/test/spec/ol/source/bingmapssource.test.js b/test/spec/ol/source/bingmapssource.test.js index b7e1191840..326a814cbf 100644 --- a/test/spec/ol/source/bingmapssource.test.js +++ b/test/spec/ol/source/bingmapssource.test.js @@ -7,24 +7,21 @@ describe('ol.source.BingMaps', function() { var source, tileGrid; beforeEach(function(done) { - var googNetJsonp = goog.net.Jsonp; - // mock goog.net.Jsonp (used in the ol.source.TileJSON constructor) - goog.net.Jsonp = function() { - this.send = function() { - var callback = arguments[1]; - var client = new XMLHttpRequest(); - client.open('GET', 'spec/ol/data/bing_aerialwithlabels.json', true); - client.onload = function() { - callback(JSON.parse(client.responseText)); - }; - client.send(); + var olNetJsonp = ol.net.jsonp; + // mock ol.net.Jsonp (used in the ol.source.TileJSON constructor) + ol.net.jsonp = function(url, callback) { + var client = new XMLHttpRequest(); + client.open('GET', 'spec/ol/data/bing_aerialwithlabels.json', true); + client.onload = function() { + callback(JSON.parse(client.responseText)); }; + client.send(); }; source = new ol.source.BingMaps({ imagerySet: 'AerialWithLabels', key: '' }); - goog.net.Jsonp = googNetJsonp; + ol.net.jsonp = olNetJsonp; var key = source.on('change', function() { if (source.getState() === 'ready') { ol.Observable.unByKey(key); @@ -75,7 +72,7 @@ describe('ol.source.BingMaps', function() { }); -goog.require('goog.net.Jsonp'); +goog.require('ol.net'); goog.require('ol.source.BingMaps'); goog.require('ol.tilecoord'); goog.require('ol.Observable'); diff --git a/test/spec/ol/source/tileimagesource.test.js b/test/spec/ol/source/tileimagesource.test.js index 75e4bb1601..ead6427c21 100644 --- a/test/spec/ol/source/tileimagesource.test.js +++ b/test/spec/ol/source/tileimagesource.test.js @@ -124,7 +124,7 @@ describe('ol.source.TileImage', function() { var tile = source.getTile(0, 0, -1, 1, ol.proj.get('EPSG:3857')); expect(tile).to.be.a(ol.reproj.Tile); - tile.listen('change', function() { + ol.events.listen(tile, 'change', function() { if (tile.getState() == ol.TileState.LOADED) { done(); } @@ -143,7 +143,7 @@ describe('ol.source.TileImage', function() { var tile = source.getTile(0, 0, -1, 1, proj); expect(tile).to.be.a(ol.reproj.Tile); - tile.listen('change', function() { + ol.events.listen(tile, 'change', function() { if (tile.getState() == ol.TileState.LOADED) { done(); } @@ -157,6 +157,7 @@ goog.require('ol.ImageTile'); goog.require('ol.Tile'); goog.require('ol.TileState'); goog.require('ol.TileUrlFunction'); +goog.require('ol.events'); goog.require('ol.proj'); goog.require('ol.proj.Projection'); goog.require('ol.reproj.Tile'); diff --git a/test/spec/ol/source/tilejsonsource.test.js b/test/spec/ol/source/tilejsonsource.test.js index 2fec2c3d43..b21d5b2d86 100644 --- a/test/spec/ol/source/tilejsonsource.test.js +++ b/test/spec/ol/source/tilejsonsource.test.js @@ -11,7 +11,7 @@ describe('ol.source.TileJSON', function() { var source = new ol.source.TileJSON({ url: 'invalid.jsonp' }); - goog.events.listen(source, 'change', changeSpy); + ol.events.listen(source, 'change', changeSpy); }); }); @@ -73,7 +73,7 @@ describe('ol.source.TileJSON', function() { }); -goog.require('goog.events'); +goog.require('ol.events'); goog.require('ol.source.State'); goog.require('ol.source.TileJSON'); goog.require('ol.Observable'); diff --git a/test/spec/ol/source/vectorsource.test.js b/test/spec/ol/source/vectorsource.test.js index 2d0ca9cca8..1ec4667cbc 100644 --- a/test/spec/ol/source/vectorsource.test.js +++ b/test/spec/ol/source/vectorsource.test.js @@ -57,7 +57,7 @@ describe('ol.source.Vector', function() { it('fires a change event', function() { var listener = sinon.spy(); - goog.events.listen(vectorSource, 'change', listener); + ol.events.listen(vectorSource, 'change', listener); vectorSource.addFeature(pointFeature); expect(listener).to.be.called(); }); @@ -98,11 +98,11 @@ describe('ol.source.Vector', function() { it('removes all features using fast path', function() { var changeSpy = sinon.spy(); - goog.events.listen(vectorSource, 'change', changeSpy); + ol.events.listen(vectorSource, 'change', changeSpy); var removeFeatureSpy = sinon.spy(); - goog.events.listen(vectorSource, 'removefeature', removeFeatureSpy); + ol.events.listen(vectorSource, 'removefeature', removeFeatureSpy); var clearSourceSpy = sinon.spy(); - goog.events.listen(vectorSource, 'clear', clearSourceSpy); + ol.events.listen(vectorSource, 'clear', clearSourceSpy); vectorSource.clear(true); expect(vectorSource.getFeatures()).to.eql([]); expect(vectorSource.isEmpty()).to.be(true); @@ -116,11 +116,11 @@ describe('ol.source.Vector', function() { it('removes all features using slow path', function() { var changeSpy = sinon.spy(); - goog.events.listen(vectorSource, 'change', changeSpy); + ol.events.listen(vectorSource, 'change', changeSpy); var removeFeatureSpy = sinon.spy(); - goog.events.listen(vectorSource, 'removefeature', removeFeatureSpy); + ol.events.listen(vectorSource, 'removefeature', removeFeatureSpy); var clearSourceSpy = sinon.spy(); - goog.events.listen(vectorSource, 'clear', clearSourceSpy); + ol.events.listen(vectorSource, 'clear', clearSourceSpy); vectorSource.clear(); expect(vectorSource.getFeatures()).to.eql([]); expect(vectorSource.isEmpty()).to.be(true); @@ -184,7 +184,7 @@ describe('ol.source.Vector', function() { it('fires a change event', function() { var listener = sinon.spy(); - goog.events.listen(vectorSource, 'change', listener); + ol.events.listen(vectorSource, 'change', listener); vectorSource.removeFeature(features[0]); expect(listener).to.be.called(); }); @@ -270,7 +270,7 @@ describe('ol.source.Vector', function() { var feature = new ol.Feature(new ol.geom.Point([1, 1])); vectorSource.addFeature(feature); var listener = sinon.spy(); - goog.events.listen(vectorSource, 'change', listener); + ol.events.listen(vectorSource, 'change', listener); feature.set('foo', 'bar'); expect(listener).to.be.called(); }); @@ -554,7 +554,7 @@ describe('ol.source.Vector', function() { }); -goog.require('goog.events'); +goog.require('ol.events'); goog.require('ol.Collection'); goog.require('ol.Feature'); goog.require('ol.geom.Point'); diff --git a/test/spec/ol/style/iconstyle.test.js b/test/spec/ol/style/iconstyle.test.js index 2166ef67e1..f46bb337e1 100644 --- a/test/spec/ol/style/iconstyle.test.js +++ b/test/spec/ol/style/iconstyle.test.js @@ -194,14 +194,14 @@ describe('ol.style.IconImageCache', function() { src = '0'; iconImage = new ol.style.IconImage_(src, null); - goog.events.listen(iconImage, goog.events.EventType.CHANGE, + ol.events.listen(iconImage, ol.events.EventType.CHANGE, ol.nullFunction, false); cache.set(src, null, null, iconImage); expect(cache.cacheSize_).to.eql(4); src = '4'; iconImage = new ol.style.IconImage_(src, null); - goog.events.listen(iconImage, goog.events.EventType.CHANGE, + ol.events.listen(iconImage, ol.events.EventType.CHANGE, ol.nullFunction, false); cache.set(src, null, null, iconImage); expect(cache.cacheSize_).to.eql(5); @@ -217,6 +217,6 @@ describe('ol.style.IconImageCache', function() { }); }); -goog.require('goog.events'); -goog.require('goog.events.EventType'); +goog.require('ol.events'); +goog.require('ol.events.EventType'); goog.require('ol.style.IconImageCache'); diff --git a/test_rendering/index.html b/test_rendering/index.html index 2e20b88372..0a97859b7f 100644 --- a/test_rendering/index.html +++ b/test_rendering/index.html @@ -28,22 +28,6 @@