ashatora/openlayers
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove move dead code

Browse Source
This commit is contained in:
Tom Payne
2012-09-19 17:04:12 +02:00
parent 4141393423
commit 5c76291b74
5 changed files with 0 additions and 377 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
src/ol/events/MapEvent.js
View File

@@ -1,53 +0,0 @@
goog.provide('ol.events.MapEvent');
goog.provide('ol.events.MapEventType');
goog.require('goog.events.Event');
/**
* @enum {string}
*/
ol.events.MapEventType = {
// drag handler
DRAGSTART: 'dragstart',
DRAG: 'drag',
DRAGEND: 'dragend',
// mousewheel handler
MOUSEWHEEL: 'mousewheel',
// click handler
CLICK: 'click'
};
/**
* @constructor
* @extends {goog.events.Event}
* @param {string} type Event type.
* @param {goog.events.Event=} opt_evt The underlying event.
*/
ol.events.MapEvent = function(type, opt_evt) {
goog.base(this, type);
/**
* X displacement relative to the previous drag event, if any.
*
* @type {number|undefined}
*/
this.deltaX = undefined;
/**
* Y displacement relative to the previous drag event, if any.
*
* @type {number|undefined}
*/
this.deltaY = undefined;
/**
* The underlying event.
*
* @type {goog.events.Event}
*/
this.originalEvent = goog.isDef(opt_evt) ? opt_evt : null;
};
goog.inherits(ol.events.MapEvent, goog.events.Event);

52
src/ol/handler/Click.js
View File

@@ -1,52 +0,0 @@
/**
* @fileoverview Click Handler.
*
* Provides a class for listening to click events on a DOM element
* and dispatching click events to a map instance.
*
* This handler has no default behaviour.
*/
goog.provide('ol.handler.Click');
goog.require('ol.handler.MapHandler');
goog.require('ol.events.MapEvent');
goog.require('ol.events.MapEventType');
goog.require('goog.events');
goog.require('goog.events.EventType');
/**
* @constructor
* @extends {ol.handler.MapHandler}
* @param {ol.Map} map The map instance.
* @param {ol.handler.states} states An object for the handlers to share
* states.
*/
ol.handler.Click = function(map, states) {
goog.base(this, map, states);
goog.events.listen(this.element_, goog.events.EventType.CLICK,
this.handleClick, false, this);
};
goog.inherits(ol.handler.Click, ol.handler.MapHandler);
/**
* @inheritDoc
*/
ol.handler.Click.prototype.disposeInternal = function() {
goog.events.unlisten(this.element_, goog.events.EventType.CLICK,
this.handleClick, false, this);
};
/**
* @param {goog.events.BrowserEvent} e
*/
ol.handler.Click.prototype.handleClick = function(e) {
// do not emit a map click event after a drag
if (!this.states_.dragged) {
var newE = new ol.events.MapEvent(ol.events.MapEventType.CLICK, e);
goog.events.dispatchEvent(this.map_, newE);
}
};

137
src/ol/handler/Drag.js
View File

@@ -1,137 +0,0 @@
/**
* @fileoverview Drag Handler.
*
* Provides a class for listening to drag sequences on a DOM element and
* dispatching dragstart, drag and dragend events to a map object.
*
* The default behavior for the drag event is moving the map.
*/
goog.provide('ol.handler.Drag');
goog.require('ol.handler.MapHandler');
goog.require('ol.events.MapEvent');
goog.require('ol.events.MapEventType');
goog.require('goog.events');
goog.require('goog.events.Event');
goog.require('goog.events.EventType');
goog.require('goog.fx.Dragger');
/**
* @constructor
* @extends {ol.handler.MapHandler}
* @param {ol.Map} map The map instance.
* @param {ol.handler.states} states An object for the handlers to share
* states.
*/
ol.handler.Drag = function(map, states) {
goog.base(this, map, states);
/**
* @type {goog.fx.Dragger}
*/
this.dragger_ = new goog.fx.Dragger(this.element_);
var dragger = this.dragger_;
dragger.defaultAction = function() {};
/**
* @type {number}
*/
this.prevX_ = 0;
/**
* @type {number}
**/
this.prevY_ = 0;
goog.events.listen(dragger, goog.fx.Dragger.EventType.START,
this.handleDragStart, false, this);
goog.events.listen(dragger, goog.fx.Dragger.EventType.DRAG,
this.handleDrag, false, this);
goog.events.listen(dragger, goog.fx.Dragger.EventType.END,
this.handleDragEnd, false, this);
goog.events.listen(dragger, goog.fx.Dragger.EventType.EARLY_CANCEL,
this.handleDragEarlyCancel, false, this);
};
goog.inherits(ol.handler.Drag, ol.handler.MapHandler);
/**
* @inheritDoc
*/
ol.handler.Drag.prototype.disposeInternal = function() {
goog.base(this, 'disposeInternal');
goog.dispose(this.dragger_);
goog.events.unlisten(this.element_,
[goog.events.EventType.TOUCHMOVE,
goog.events.EventType.MOUSEMOVE],
goog.events.Event.preventDefault, false, this);
};
/**
* @param {goog.fx.DragEvent} e
*/
ol.handler.Drag.prototype.handleDragStart = function(e) {
this.states_.dragged = false;
this.prevX_ = e.clientX;
this.prevY_ = e.clientY;
var newE = new ol.events.MapEvent(ol.events.MapEventType.DRAGSTART, e);
goog.events.dispatchEvent(this.map_, newE);
// this is to prevent page scrolling
goog.events.listen(this.element_,
[goog.events.EventType.TOUCHMOVE,
goog.events.EventType.MOUSEMOVE],
goog.events.Event.preventDefault, false, this);
};
/**
* @param {goog.fx.DragEvent} e
*/
ol.handler.Drag.prototype.handleDrag = function(e) {
this.states_.dragged = true;
var newE = new ol.events.MapEvent(ol.events.MapEventType.DRAG, e);
newE.deltaX = e.clientX - this.prevX_;
newE.deltaY = e.clientY - this.prevY_;
this.prevX_ = e.clientX;
this.prevY_ = e.clientY;
var rt = goog.events.dispatchEvent(this.map_, newE);
if (rt) {
this.defaultDrag(newE);
}
};
/**
* @param {ol.events.MapEvent} e
*/
ol.handler.Drag.prototype.defaultDrag = function(e) {
var deltaX = /** @type {number} */ e.deltaX;
var deltaY = /** @type {number} */ e.deltaY;
this.map_.moveByViewportPx(deltaX, deltaY);
};
/**
* @param {goog.fx.DragEvent} e
*/
ol.handler.Drag.prototype.handleDragEnd = function(e) {
var newE = new ol.events.MapEvent(ol.events.MapEventType.DRAGEND, e);
goog.events.dispatchEvent(this.map_, newE);
goog.events.unlisten(this.element_,
[goog.events.EventType.TOUCHMOVE,
goog.events.EventType.MOUSEMOVE],
goog.events.Event.preventDefault, false, this);
};
/**
* @param {goog.fx.DragEvent} e
*/
ol.handler.Drag.prototype.handleDragEarlyCancel = function(e) {
goog.events.unlisten(this.element_,
[goog.events.EventType.TOUCHMOVE,
goog.events.EventType.MOUSEMOVE],
goog.events.Event.preventDefault, false, this);
};

56
src/ol/handler/MapHandler.js
View File

@@ -1,56 +0,0 @@
/**
* @fileoverview Map Handler.
*
* Type definitions and base class for map event handlers that share states,
* listen for events on a map related dom element (usually the map's viewport),
* dispatch events to an ol.Map instance, and optionally perform default
* actions on an ol.Map instance.
*/
goog.provide('ol.handler.states');
goog.provide('ol.handler.MapHandler');
goog.require('goog.Disposable');
/**
* Type definition for shared states between handlers. The following states
* are defined:
*
* * dragged (boolean) - Set by the Drag handler when we are dragging. Read by
* the click handler to determine if a click is a real click or the result
* of a mouseup/touchend at the end of a drag sequence.
*
* @typedef {{dragged: boolean}}
*/
ol.handler.states;
/**
* @constructor
* @extends {goog.Disposable}
* @param {ol.Map} map The map instance.
* @param {ol.handler.states} states An object for the handlers to share
* states.
*/
ol.handler.MapHandler = function(map, states) {
goog.base(this);
/**
* @type {ol.Map}
* @protected
*/
this.map_ = map;
/**
* @type {Element}
* @protected
*/
this.element_ = map.getViewport();
/**
* @type {ol.handler.states}
* @protected
*/
this.states_ = states;
};
goog.inherits(ol.handler.MapHandler, goog.Disposable);

79
src/ol/handler/MouseWheel.js
View File

@@ -1,79 +0,0 @@
/**
* @fileoverview Mouse Wheel Handler.
*
* Provides a class for listening to mousewheel events on a DOM element
* and dispatching mousewheel events to a map instance.
*
* The default behavior for the mousewheel event is zooming the map.
*/
goog.provide('ol.handler.MouseWheel');
goog.require('ol.handler.MapHandler');
goog.require('ol.events.MapEvent');
goog.require('ol.events.MapEventType');
goog.require('goog.asserts');
goog.require('goog.events');
goog.require('goog.style');
goog.require('goog.events.MouseWheelHandler');
goog.require('goog.events.MouseWheelHandler.EventType');
/**
* @constructor
* @extends {ol.handler.MapHandler}
* @param {ol.Map} map The map instance.
* @param {ol.handler.states} states An object for the handlers to share
* states.
*/
ol.handler.MouseWheel = function(map, states) {
goog.base(this, map, states);
/**
* @type {goog.events.MouseWheelHandler}
*/
this.handler_ = new goog.events.MouseWheelHandler(this.element_);
var handler = this.handler_;
this.registerDisposable(handler);
goog.events.listen(handler,
goog.events.MouseWheelHandler.EventType.MOUSEWHEEL,
this.handleMouseWheel, false, this);
};
goog.inherits(ol.handler.MouseWheel, ol.handler.MapHandler);
/**
* @param {goog.events.MouseWheelEvent} e
*/
ol.handler.MouseWheel.prototype.handleMouseWheel = function(e) {
var newE = new ol.events.MapEvent(ol.events.MapEventType.MOUSEWHEEL, e);
var rt = goog.events.dispatchEvent(this.map_, newE);
if (rt) {
this.defaultMouseWheel(e);
}
};
/**
* @param {goog.events.MouseWheelEvent} e
*/
ol.handler.MouseWheel.prototype.defaultMouseWheel = function(e) {
var me = this;
if (e.deltaY === 0 || me.zoomBlocked_) {
return;
}
me.zoomBlocked_ = window.setTimeout(function() {
me.zoomBlocked_ = null;
}, 200);
var map = me.map_,
step = e.deltaY / Math.abs(e.deltaY);
map.setZoom(map.getZoom() - step,
goog.style.getRelativePosition(e, this.element_));
// We don't want the page to scroll.
// (MouseWheelEvent is a BrowserEvent)
e.preventDefault();
};