leaflet-js 0.7.9 → 0.8.dev2

data/{vendor/assets/Leaflet → lib/leaflet}/src/dom/DomEvent.DoubleTap.js

@@ -9,13 +9,9 @@ L.extend(L.DomEvent, {
 
 	// inspired by Zepto touch code by Thomas Fuchs
 	addDoubleTapListener: function (obj, handler, id) {
-		var last,
+		var last, touch,
 		    doubleTap = false,
 		    delay = 250,
-		    touch,
-		    pre = '_leaflet_',
-		    touchstart = this._touchstart,
-		    touchend = this._touchend,
 		    trackedTouches = [];
 
 		function onTouchStart(e) {
@@ -27,12 +23,11 @@ L.extend(L.DomEvent, {
 			} else {
 				count = e.touches.length;
 			}
-			if (count > 1) {
-				return;
-			}
+
+			if (count > 1) { return; }
 
 			var now = Date.now(),
-				delta = now - (last || now);
+			    delta = now - (last || now);
 
 			touch = e.touches ? e.touches[0] : e;
 			doubleTap = (delta > 0 && delta <= delay);
@@ -42,26 +37,19 @@ L.extend(L.DomEvent, {
 		function onTouchEnd(e) {
 			if (L.Browser.pointer) {
 				var idx = trackedTouches.indexOf(e.pointerId);
-				if (idx === -1) {
-					return;
-				}
+				if (idx === -1) { return; }
 				trackedTouches.splice(idx, 1);
 			}
 
 			if (doubleTap) {
 				if (L.Browser.pointer) {
 					// work around .type being readonly with MSPointer* events
-					var newTouch = { },
-						prop;
+					var newTouch = {},
+						prop, i;
 
-					// jshint forin:false
-					for (var i in touch) {
+					for (i in touch) {
 						prop = touch[i];
-						if (typeof prop === 'function') {
-							newTouch[i] = prop.bind(touch);
-						} else {
-							newTouch[i] = prop;
-						}
+						newTouch[i] = prop && prop.bind ? prop.bind(touch) : prop;
 					}
 					touch = newTouch;
 				}
@@ -70,6 +58,11 @@ L.extend(L.DomEvent, {
 				last = null;
 			}
 		}
+
+		var pre = '_leaflet_',
+		    touchstart = this._touchstart,
+		    touchend = this._touchend;
+
 		obj[pre + touchstart + id] = onTouchStart;
 		obj[pre + touchend + id] = onTouchEnd;
 
@@ -78,8 +71,8 @@ L.extend(L.DomEvent, {
 		var endElement = L.Browser.pointer ? document.documentElement : obj;
 
 		obj.addEventListener(touchstart, onTouchStart, false);
-		endElement.addEventListener(touchend, onTouchEnd, false);
 
+		endElement.addEventListener(touchend, onTouchEnd, false);
 		if (L.Browser.pointer) {
 			endElement.addEventListener(L.DomEvent.POINTER_CANCEL, onTouchEnd, false);
 		}
@@ -88,15 +81,15 @@ L.extend(L.DomEvent, {
 	},
 
 	removeDoubleTapListener: function (obj, id) {
-		var pre = '_leaflet_';
+		var pre = '_leaflet_',
+		    endElement = L.Browser.pointer ? document.documentElement : obj,
+		    touchend = obj[pre + this._touchend + id];
 
 		obj.removeEventListener(this._touchstart, obj[pre + this._touchstart + id], false);
-		(L.Browser.pointer ? document.documentElement : obj).removeEventListener(
-		        this._touchend, obj[pre + this._touchend + id], false);
 
+		endElement.removeEventListener(this._touchend, touchend, false);
 		if (L.Browser.pointer) {
-			document.documentElement.removeEventListener(L.DomEvent.POINTER_CANCEL, obj[pre + this._touchend + id],
-				false);
+			endElement.removeEventListener(L.DomEvent.POINTER_CANCEL, touchend, false);
 		}
 
 		return this;

data/lib/leaflet/src/dom/DomEvent.Pointer.js

@@ -0,0 +1,107 @@
+/*
+ * Extends L.DomEvent to provide touch support for Internet Explorer and Windows-based devices.
+ */
+
+L.extend(L.DomEvent, {
+
+	POINTER_DOWN:   L.Browser.msPointer ? 'MSPointerDown'   : 'pointerdown',
+	POINTER_MOVE:   L.Browser.msPointer ? 'MSPointerMove'   : 'pointermove',
+	POINTER_UP:     L.Browser.msPointer ? 'MSPointerUp'     : 'pointerup',
+	POINTER_CANCEL: L.Browser.msPointer ? 'MSPointerCancel' : 'pointercancel',
+
+	_pointers: {},
+
+	// Provides a touch events wrapper for (ms)pointer events.
+	// ref http://www.w3.org/TR/pointerevents/ https://www.w3.org/Bugs/Public/show_bug.cgi?id=22890
+
+	addPointerListener: function (obj, type, handler, id) {
+
+		if (type === 'touchstart') {
+			this._addPointerStart(obj, handler, id);
+
+		} else if (type === 'touchmove') {
+			this._addPointerMove(obj, handler, id);
+
+		} else if (type === 'touchend') {
+			this._addPointerEnd(obj, handler, id);
+		}
+
+		return this;
+	},
+
+	removePointerListener: function (obj, type, id) {
+		var handler = obj['_leaflet_' + type + id];
+
+		if (type === 'touchstart') {
+			obj.removeEventListener(this.POINTER_DOWN, handler, false);
+
+		} else if (type === 'touchmove') {
+			obj.removeEventListener(this.POINTER_MOVE, handler, false);
+
+		} else if (type === 'touchend') {
+			obj.removeEventListener(this.POINTER_UP, handler, false);
+			obj.removeEventListener(this.POINTER_CANCEL, handler, false);
+		}
+
+		return this;
+	},
+
+	_addPointerStart: function (obj, handler, id) {
+		var onDown = L.bind(function (e) {
+			L.DomEvent.preventDefault(e);
+
+			this._pointers[e.pointerId] = e;
+			this._handlePointer(e, handler);
+		}, this);
+
+		obj['_leaflet_touchstart' + id] = onDown;
+		obj.addEventListener(this.POINTER_DOWN, onDown, false);
+
+		// need to also listen for end events to keep the _pointers object accurate
+		if (!this._pointerDocListener) {
+			var removePointer = L.bind(function (e) {
+				delete this._pointers[e.pointerId];
+			}, this);
+
+			// we listen documentElement as any drags that end by moving the touch off the screen get fired there
+			document.documentElement.addEventListener(this.POINTER_UP, removePointer, false);
+			document.documentElement.addEventListener(this.POINTER_CANCEL, removePointer, false);
+
+			this._pointerDocListener = true;
+		}
+	},
+
+	_handlePointer: function (e, handler) {
+		e.touches = [];
+		for (var i in this._pointers) {
+			e.touches.push(this._pointers[i]);
+		}
+		e.changedTouches = [e];
+
+		handler(e);
+	},
+
+	_addPointerMove: function (obj, handler, id) {
+		var onMove = L.bind(function (e) {
+			// don't fire touch moves when mouse isn't down
+			if ((e.pointerType === e.MSPOINTER_TYPE_MOUSE || e.pointerType === 'mouse') && e.buttons === 0) { return; }
+
+			this._pointers[e.pointerId] = e;
+			this._handlePointer(e, handler);
+		}, this);
+
+		obj['_leaflet_touchmove' + id] = onMove;
+		obj.addEventListener(this.POINTER_MOVE, onMove, false);
+	},
+
+	_addPointerEnd: function (obj, handler, id) {
+		var onUp = L.bind(function (e) {
+			delete this._pointers[e.pointerId];
+			this._handlePointer(e, handler);
+		}, this);
+
+		obj['_leaflet_touchend' + id] = onUp;
+		obj.addEventListener(this.POINTER_UP, onUp, false);
+		obj.addEventListener(this.POINTER_CANCEL, onUp, false);
+	}
+});

data/{vendor/assets/Leaflet → lib/leaflet}/src/dom/DomEvent.js

@@ -1,21 +1,57 @@
 /*
  * L.DomEvent contains functions for working with DOM events.
+ * Inspired by John Resig, Dean Edwards and YUI addEvent implementations.
  */
 
+var eventsKey = '_leaflet_events';
+
 L.DomEvent = {
-	/* inspired by John Resig, Dean Edwards and YUI addEvent implementations */
-	addListener: function (obj, type, fn, context) { // (HTMLElement, String, Function[, Object])
 
-		var id = L.stamp(fn),
-		    key = '_leaflet_' + type + id,
-		    handler, originalHandler, newType;
+	on: function (obj, types, fn, context) {
+
+		if (typeof types === 'object') {
+			for (var type in types) {
+				this._on(obj, type, types[type], fn);
+			}
+		} else {
+			types = L.Util.splitWords(types);
+
+			for (var i = 0, len = types.length; i < len; i++) {
+				this._on(obj, types[i], fn, context);
+			}
+		}
+
+		return this;
+	},
+
+	off: function (obj, types, fn, context) {
 
-		if (obj[key]) { return this; }
+		if (typeof types === 'object') {
+			for (var type in types) {
+				this._off(obj, type, types[type], fn);
+			}
+		} else {
+			types = L.Util.splitWords(types);
+
+			for (var i = 0, len = types.length; i < len; i++) {
+				this._off(obj, types[i], fn, context);
+			}
+		}
 
-		handler = function (e) {
-			return fn.call(context || obj, e || L.DomEvent._getEvent());
+		return this;
+	},
+
+	_on: function (obj, type, fn, context) {
+		var id = type + L.stamp(fn) + (context ? '_' + L.stamp(context) : '');
+
+		if (obj[eventsKey] && obj[eventsKey][id]) { return this; }
+
+		var handler = function (e) {
+			return fn.call(context || obj, e || window.event);
 		};
 
+		var originalHandler = handler;
+
 		if (L.Browser.pointer && type.indexOf('touch') === 0) {
 			return this.addPointerListener(obj, type, handler, id);
 		}
@@ -30,25 +66,19 @@ L.DomEvent = {
 				obj.addEventListener(type, handler, false);
 
 			} else if ((type === 'mouseenter') || (type === 'mouseleave')) {
-
-				originalHandler = handler;
-				newType = (type === 'mouseenter' ? 'mouseover' : 'mouseout');
-
 				handler = function (e) {
+					e = e || window.event;
 					if (!L.DomEvent._checkMouse(obj, e)) { return; }
 					return originalHandler(e);
 				};
+				obj.addEventListener(type === 'mouseenter' ? 'mouseover' : 'mouseout', handler, false);
 
-				obj.addEventListener(newType, handler, false);
-
-			} else if (type === 'click' && L.Browser.android) {
-				originalHandler = handler;
-				handler = function (e) {
-					return L.DomEvent._filterClick(e, originalHandler);
-				};
-
-				obj.addEventListener(type, handler, false);
 			} else {
+				if (type === 'click' && L.Browser.android) {
+					handler = function (e) {
+						return L.DomEvent._filterClick(e, originalHandler);
+					};
+				}
 				obj.addEventListener(type, handler, false);
 			}
 
@@ -56,21 +86,22 @@ L.DomEvent = {
 			obj.attachEvent('on' + type, handler);
 		}
 
-		obj[key] = handler;
+		obj[eventsKey] = obj[eventsKey] || {};
+		obj[eventsKey][id] = handler;
 
 		return this;
 	},
 
-	removeListener: function (obj, type, fn) {  // (HTMLElement, String, Function)
+	_off: function (obj, type, fn, context) {
 
-		var id = L.stamp(fn),
-		    key = '_leaflet_' + type + id,
-		    handler = obj[key];
+		var id = type + L.stamp(fn) + (context ? '_' + L.stamp(context) : ''),
+		    handler = obj[eventsKey] && obj[eventsKey][id];
 
 		if (!handler) { return this; }
 
 		if (L.Browser.pointer && type.indexOf('touch') === 0) {
 			this.removePointerListener(obj, type, id);
+
 		} else if (L.Browser.touch && (type === 'dblclick') && this.removeDoubleTapListener) {
 			this.removeDoubleTapListener(obj, id);
 
@@ -80,16 +111,17 @@ L.DomEvent = {
 				obj.removeEventListener('DOMMouseScroll', handler, false);
 				obj.removeEventListener(type, handler, false);
 
-			} else if ((type === 'mouseenter') || (type === 'mouseleave')) {
-				obj.removeEventListener((type === 'mouseenter' ? 'mouseover' : 'mouseout'), handler, false);
 			} else {
-				obj.removeEventListener(type, handler, false);
+				obj.removeEventListener(
+					type === 'mouseenter' ? 'mouseover' :
+					type === 'mouseleave' ? 'mouseout' : type, handler, false);
 			}
+
 		} else if ('detachEvent' in obj) {
 			obj.detachEvent('on' + type, handler);
 		}
 
-		obj[key] = null;
+		obj[eventsKey][id] = null;
 
 		return this;
 	},
@@ -107,23 +139,18 @@ L.DomEvent = {
 	},
 
 	disableScrollPropagation: function (el) {
-		var stop = L.DomEvent.stopPropagation;
-
-		return L.DomEvent
-			.on(el, 'mousewheel', stop)
-			.on(el, 'MozMousePixelScroll', stop);
+		return L.DomEvent.on(el, 'mousewheel MozMousePixelScroll', L.DomEvent.stopPropagation);
 	},
 
 	disableClickPropagation: function (el) {
 		var stop = L.DomEvent.stopPropagation;
 
-		for (var i = L.Draggable.START.length - 1; i >= 0; i--) {
-			L.DomEvent.on(el, L.Draggable.START[i], stop);
-		}
+		L.DomEvent.on(el, L.Draggable.START.join(' '), stop);
 
-		return L.DomEvent
-			.on(el, 'click', L.DomEvent._fakeStop)
-			.on(el, 'dblclick', stop);
+		return L.DomEvent.on(el, {
+			click: L.DomEvent._fakeStop,
+			dblclick: stop
+		});
 	},
 
 	preventDefault: function (e) {
@@ -198,22 +225,6 @@ L.DomEvent = {
 		return (related !== el);
 	},
 
-	_getEvent: function () { // evil magic for IE
-		/*jshint noarg:false */
-		var e = window.event;
-		if (!e) {
-			var caller = arguments.callee.caller;
-			while (caller) {
-				e = caller['arguments'][0];
-				if (e && window.Event === e.constructor) {
-					break;
-				}
-				caller = caller.caller;
-			}
-		}
-		return e;
-	},
-
 	// this is a horrible workaround for a bug in Android where a single touch triggers two click events
 	_filterClick: function (e, handler) {
 		var timeStamp = (e.timeStamp || e.originalEvent.timeStamp),
@@ -234,5 +245,5 @@ L.DomEvent = {
 	}
 };
 
-L.DomEvent.on = L.DomEvent.addListener;
-L.DomEvent.off = L.DomEvent.removeListener;
+L.DomEvent.addListener = L.DomEvent.on;
+L.DomEvent.removeListener = L.DomEvent.off;

data/lib/leaflet/src/dom/DomUtil.js

@@ -0,0 +1,213 @@
+/*
+ * L.DomUtil contains various utility functions for working with DOM.
+ */
+
+L.DomUtil = {
+	get: function (id) {
+		return typeof id === 'string' ? document.getElementById(id) : id;
+	},
+
+	getStyle: function (el, style) {
+
+		var value = el.style[style] || (el.currentStyle && el.currentStyle[style]);
+
+		if ((!value || value === 'auto') && document.defaultView) {
+			var css = document.defaultView.getComputedStyle(el, null);
+			value = css ? css[style] : null;
+		}
+
+		return value === 'auto' ? null : value;
+	},
+
+	create: function (tagName, className, container) {
+
+		var el = document.createElement(tagName);
+		el.className = className;
+
+		if (container) {
+			container.appendChild(el);
+		}
+
+		return el;
+	},
+
+	remove: function (el) {
+		var parent = el.parentNode;
+		if (parent) {
+			parent.removeChild(el);
+		}
+	},
+
+	toFront: function (el) {
+		el.parentNode.appendChild(el);
+	},
+
+	toBack: function (el) {
+		var parent = el.parentNode;
+		parent.insertBefore(el, parent.firstChild);
+	},
+
+	hasClass: function (el, name) {
+		if (el.classList !== undefined) {
+			return el.classList.contains(name);
+		}
+		var className = L.DomUtil.getClass(el);
+		return className.length > 0 && new RegExp('(^|\\s)' + name + '(\\s|$)').test(className);
+	},
+
+	addClass: function (el, name) {
+		if (el.classList !== undefined) {
+			var classes = L.Util.splitWords(name);
+			for (var i = 0, len = classes.length; i < len; i++) {
+				el.classList.add(classes[i]);
+			}
+		} else if (!L.DomUtil.hasClass(el, name)) {
+			var className = L.DomUtil.getClass(el);
+			L.DomUtil.setClass(el, (className ? className + ' ' : '') + name);
+		}
+	},
+
+	removeClass: function (el, name) {
+		if (el.classList !== undefined) {
+			el.classList.remove(name);
+		} else {
+			L.DomUtil.setClass(el, L.Util.trim((' ' + L.DomUtil.getClass(el) + ' ').replace(' ' + name + ' ', ' ')));
+		}
+	},
+
+	setClass: function (el, name) {
+		if (el.className.baseVal === undefined) {
+			el.className = name;
+		} else {
+			// in case of SVG element
+			el.className.baseVal = name;
+		}
+	},
+
+	getClass: function (el) {
+		return el.className.baseVal === undefined ? el.className : el.className.baseVal;
+	},
+
+	setOpacity: function (el, value) {
+
+		if ('opacity' in el.style) {
+			el.style.opacity = value;
+
+		} else if ('filter' in el.style) {
+
+			var filter = false,
+			    filterName = 'DXImageTransform.Microsoft.Alpha';
+
+			// filters collection throws an error if we try to retrieve a filter that doesn't exist
+			try {
+				filter = el.filters.item(filterName);
+			} catch (e) {
+				// don't set opacity to 1 if we haven't already set an opacity,
+				// it isn't needed and breaks transparent pngs.
+				if (value === 1) { return; }
+			}
+
+			value = Math.round(value * 100);
+
+			if (filter) {
+				filter.Enabled = (value !== 100);
+				filter.Opacity = value;
+			} else {
+				el.style.filter += ' progid:' + filterName + '(opacity=' + value + ')';
+			}
+		}
+	},
+
+	testProp: function (props) {
+
+		var style = document.documentElement.style;
+
+		for (var i = 0; i < props.length; i++) {
+			if (props[i] in style) {
+				return props[i];
+			}
+		}
+		return false;
+	},
+
+	setTransform: function (el, offset, scale) {
+		var pos = offset || new L.Point(0, 0);
+
+		el.style[L.DomUtil.TRANSFORM] =
+			'translate3d(' + pos.x + 'px,' + pos.y + 'px' + ',0)' + (scale ? ' scale(' + scale + ')' : '');
+	},
+
+	setPosition: function (el, point, no3d) { // (HTMLElement, Point[, Boolean])
+
+		// jshint camelcase: false
+		el._leaflet_pos = point;
+
+		if (L.Browser.any3d && !no3d) {
+			L.DomUtil.setTransform(el, point);
+		} else {
+			el.style.left = point.x + 'px';
+			el.style.top = point.y + 'px';
+		}
+	},
+
+	getPosition: function (el) {
+		// this method is only used for elements previously positioned using setPosition,
+		// so it's safe to cache the position for performance
+
+		// jshint camelcase: false
+		return el._leaflet_pos;
+	}
+};
+
+
+(function () {
+	// prefix style property names
+
+	L.DomUtil.TRANSFORM = L.DomUtil.testProp(
+			['transform', 'WebkitTransform', 'OTransform', 'MozTransform', 'msTransform']);
+
+
+	// webkitTransition comes first because some browser versions that drop vendor prefix don't do
+	// the same for the transitionend event, in particular the Android 4.1 stock browser
+
+	var transition = L.DomUtil.TRANSITION = L.DomUtil.testProp(
+			['webkitTransition', 'transition', 'OTransition', 'MozTransition', 'msTransition']);
+
+	L.DomUtil.TRANSITION_END =
+			transition === 'webkitTransition' || transition === 'OTransition' ? transition + 'End' : 'transitionend';
+
+
+	if ('onselectstart' in document) {
+		L.DomUtil.disableTextSelection = function () {
+			L.DomEvent.on(window, 'selectstart', L.DomEvent.preventDefault);
+		};
+		L.DomUtil.enableTextSelection = function () {
+			L.DomEvent.off(window, 'selectstart', L.DomEvent.preventDefault);
+		};
+
+	} else {
+		var userSelectProperty = L.DomUtil.testProp(
+			['userSelect', 'WebkitUserSelect', 'OUserSelect', 'MozUserSelect', 'msUserSelect']);
+
+		L.DomUtil.disableTextSelection = function () {
+			if (userSelectProperty) {
+				var style = document.documentElement.style;
+				this._userSelect = style[userSelectProperty];
+				style[userSelectProperty] = 'none';
+			}
+		};
+		L.DomUtil.enableTextSelection = function () {
+			if (userSelectProperty) {
+				document.documentElement.style[userSelectProperty] = this._userSelect;
+				delete this._userSelect;
+			}
+		};
+	}
+
+	L.DomUtil.disableImageDrag = function () {
+		L.DomEvent.on(window, 'dragstart', L.DomEvent.preventDefault);
+	};
+	L.DomUtil.enableImageDrag = function () {
+		L.DomEvent.off(window, 'dragstart', L.DomEvent.preventDefault);
+	};
+})();