leaflet-ruby 0.3.beta1

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

@@ -0,0 +1,43 @@
+L.Util.extend(L.DomEvent, {
+	// inspired by Zepto touch code by Thomas Fuchs
+	addDoubleTapListener: function (obj, handler, id) {
+		var last,
+			doubleTap = false,
+			delay = 250,
+			touch,
+			pre = '_leaflet_',
+			touchstart = 'touchstart',
+			touchend = 'touchend';
+
+		function onTouchStart(e) {
+			if (e.touches.length !== 1) {
+				return;
+			}
+
+			var now = Date.now(),
+				delta = now - (last || now);
+
+			touch = e.touches[0];
+			doubleTap = (delta > 0 && delta <= delay);
+			last = now;
+		}
+		function onTouchEnd(e) {
+			if (doubleTap) {
+				touch.type = 'dblclick';
+				handler(touch);
+				last = null;
+			}
+		}
+		obj[pre + touchstart + id] = onTouchStart;
+		obj[pre + touchend + id] = onTouchEnd;
+
+		obj.addEventListener(touchstart, onTouchStart, false);
+		obj.addEventListener(touchend, onTouchEnd, false);
+	},
+
+	removeDoubleTapListener: function (obj, id) {
+		var pre = '_leaflet_';
+		obj.removeEventListener(obj, obj[pre + 'touchstart' + id], false);
+		obj.removeEventListener(obj, obj[pre + 'touchend' + id], false);
+	}
+});

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

@@ -0,0 +1,154 @@
+/*
+ * L.DomEvent contains functions for working with DOM events.
+ */
+
+L.DomEvent = {
+	/* inpired by John Resig, Dean Edwards and YUI addEvent implementations */
+	addListener: function (/*HTMLElement*/ obj, /*String*/ type, /*Function*/ fn, /*Object*/ context) {
+		var id = L.Util.stamp(fn),
+			key = '_leaflet_' + type + id;
+
+		if (obj[key]) {
+			return;
+		}
+
+		var handler = function (e) {
+			return fn.call(context || obj, e || L.DomEvent._getEvent());
+		};
+
+		if (L.Browser.touch && (type === 'dblclick') && this.addDoubleTapListener) {
+			this.addDoubleTapListener(obj, handler, id);
+		} else if ('addEventListener' in obj) {
+			if (type === 'mousewheel') {
+				obj.addEventListener('DOMMouseScroll', handler, false);
+				obj.addEventListener(type, handler, false);
+			} else if ((type === 'mouseenter') || (type === 'mouseleave')) {
+				var originalHandler = handler,
+					newType = (type === 'mouseenter' ? 'mouseover' : 'mouseout');
+				handler = function (e) {
+					if (!L.DomEvent._checkMouse(obj, e)) {
+						return;
+					}
+					return originalHandler(e);
+				};
+				obj.addEventListener(newType, handler, false);
+			} else {
+				obj.addEventListener(type, handler, false);
+			}
+		} else if ('attachEvent' in obj) {
+			obj.attachEvent("on" + type, handler);
+		}
+
+		obj[key] = handler;
+	},
+
+	removeListener: function (/*HTMLElement*/ obj, /*String*/ type, /*Function*/ fn) {
+		var id = L.Util.stamp(fn),
+			key = '_leaflet_' + type + id,
+			handler = obj[key];
+
+		if (!handler) {
+			return;
+		}
+
+		if (L.Browser.touch && (type === 'dblclick') && this.removeDoubleTapListener) {
+			this.removeDoubleTapListener(obj, id);
+		} else if ('removeEventListener' in obj) {
+			if (type === 'mousewheel') {
+				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);
+			}
+		} else if ('detachEvent' in obj) {
+			obj.detachEvent("on" + type, handler);
+		}
+		obj[key] = null;
+	},
+
+	_checkMouse: function (el, e) {
+		var related = e.relatedTarget;
+
+		if (!related) {
+			return true;
+		}
+
+		try {
+			while (related && (related !== el)) {
+				related = related.parentNode;
+			}
+		} catch (err) {
+			return false;
+		}
+
+		return (related !== el);
+	},
+
+	/*jshint noarg:false */ // evil magic for IE
+	_getEvent: function () {
+		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;
+	},
+	/*jshint noarg:false */
+
+	stopPropagation: function (/*Event*/ e) {
+		if (e.stopPropagation) {
+			e.stopPropagation();
+		} else {
+			e.cancelBubble = true;
+		}
+	},
+
+	disableClickPropagation: function (/*HTMLElement*/ el) {
+		L.DomEvent.addListener(el, 'mousedown', L.DomEvent.stopPropagation);
+		L.DomEvent.addListener(el, 'click', L.DomEvent.stopPropagation);
+		L.DomEvent.addListener(el, 'dblclick', L.DomEvent.stopPropagation);
+	},
+
+	preventDefault: function (/*Event*/ e) {
+		if (e.preventDefault) {
+			e.preventDefault();
+		} else {
+			e.returnValue = false;
+		}
+	},
+
+	stop: function (e) {
+		L.DomEvent.preventDefault(e);
+		L.DomEvent.stopPropagation(e);
+	},
+
+	getMousePosition: function (e, container) {
+		var x = e.pageX ? e.pageX : e.clientX +
+				document.body.scrollLeft + document.documentElement.scrollLeft,
+			y = e.pageY ? e.pageY : e.clientY +
+					document.body.scrollTop + document.documentElement.scrollTop,
+			pos = new L.Point(x, y);
+		return (container ?
+					pos.subtract(L.DomUtil.getViewportOffset(container)) : pos);
+	},
+
+	getWheelDelta: function (e) {
+		var delta = 0;
+		if (e.wheelDelta) {
+			delta = e.wheelDelta / 120;
+		}
+		if (e.detail) {
+			delta = -e.detail / 3;
+		}
+		return delta;
+	}
+};
+

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

@@ -0,0 +1,155 @@
+/*
+ * 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];
+		if (!value && el.currentStyle) {
+			value = el.currentStyle[style];
+		}
+		if (!value || value === 'auto') {
+			var css = document.defaultView.getComputedStyle(el, null);
+			value = css ? css[style] : null;
+		}
+		return (value === 'auto' ? null : value);
+	},
+
+	getViewportOffset: function (element) {
+		var top = 0,
+			left = 0,
+			el = element,
+			docBody = document.body;
+
+		do {
+			top += el.offsetTop || 0;
+			left += el.offsetLeft || 0;
+
+			if (el.offsetParent === docBody &&
+					L.DomUtil.getStyle(el, 'position') === 'absolute') {
+				break;
+			}
+			el = el.offsetParent;
+		} while (el);
+
+		el = element;
+
+		do {
+			if (el === docBody) {
+				break;
+			}
+
+			top -= el.scrollTop || 0;
+			left -= el.scrollLeft || 0;
+
+			el = el.parentNode;
+		} while (el);
+
+		return new L.Point(left, top);
+	},
+
+	create: function (tagName, className, container) {
+		var el = document.createElement(tagName);
+		el.className = className;
+		if (container) {
+			container.appendChild(el);
+		}
+		return el;
+	},
+
+	disableTextSelection: function () {
+		if (document.selection && document.selection.empty) {
+			document.selection.empty();
+		}
+		if (!this._onselectstart) {
+			this._onselectstart = document.onselectstart;
+			document.onselectstart = L.Util.falseFn;
+		}
+	},
+
+	enableTextSelection: function () {
+		document.onselectstart = this._onselectstart;
+		this._onselectstart = null;
+	},
+
+	hasClass: function (el, name) {
+		return (el.className.length > 0) &&
+				new RegExp("(^|\\s)" + name + "(\\s|$)").test(el.className);
+	},
+
+	addClass: function (el, name) {
+		if (!L.DomUtil.hasClass(el, name)) {
+			el.className += (el.className ? ' ' : '') + name;
+		}
+	},
+
+	removeClass: function (el, name) {
+		el.className = el.className.replace(/(\S+)\s*/g, function (w, match) {
+			if (match === name) {
+				return '';
+			}
+			return w;
+		}).replace(/^\s+/, '');
+	},
+
+	setOpacity: function (el, value) {
+		if (L.Browser.ie) {
+			el.style.filter = 'alpha(opacity=' + Math.round(value * 100) + ')';
+		} else {
+			el.style.opacity = value;
+		}
+	},
+
+	//TODO refactor away this ugly translate/position mess
+
+	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;
+	},
+
+	getTranslateString: function (point) {
+		return L.DomUtil.TRANSLATE_OPEN +
+				point.x + 'px,' + point.y + 'px' +
+				L.DomUtil.TRANSLATE_CLOSE;
+	},
+
+	getScaleString: function (scale, origin) {
+		var preTranslateStr = L.DomUtil.getTranslateString(origin),
+			scaleStr = ' scale(' + scale + ') ',
+			postTranslateStr = L.DomUtil.getTranslateString(origin.multiplyBy(-1));
+
+		return preTranslateStr + scaleStr + postTranslateStr;
+	},
+
+	setPosition: function (el, point) {
+		el._leaflet_pos = point;
+		if (L.Browser.webkit) {
+			el.style[L.DomUtil.TRANSFORM] =  L.DomUtil.getTranslateString(point);
+		} else {
+			el.style.left = point.x + 'px';
+			el.style.top = point.y + 'px';
+		}
+	},
+
+	getPosition: function (el) {
+		return el._leaflet_pos;
+	}
+};
+
+L.Util.extend(L.DomUtil, {
+	TRANSITION: L.DomUtil.testProp(['transition', 'webkitTransition', 'OTransition', 'MozTransition', 'msTransition']),
+	TRANSFORM: L.DomUtil.testProp(['transformProperty', 'WebkitTransform', 'OTransform', 'MozTransform', 'msTransform']),
+
+	TRANSLATE_OPEN: 'translate' + (L.Browser.webkit3d ? '3d(' : '('),
+	TRANSLATE_CLOSE: L.Browser.webkit3d ? ',0)' : ')'
+});

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

@@ -0,0 +1,147 @@
+/*
+ * L.Draggable allows you to add dragging capabilities to any element. Supports mobile devices too.
+ */
+
+L.Draggable = L.Class.extend({
+	includes: L.Mixin.Events,
+
+	statics: {
+		START: L.Browser.touch ? 'touchstart' : 'mousedown',
+		END: L.Browser.touch ? 'touchend' : 'mouseup',
+		MOVE: L.Browser.touch ? 'touchmove' : 'mousemove',
+		TAP_TOLERANCE: 15
+	},
+
+	initialize: function (element, dragStartTarget) {
+		this._element = element;
+		this._dragStartTarget = dragStartTarget || element;
+	},
+
+	enable: function () {
+		if (this._enabled) {
+			return;
+		}
+		L.DomEvent.addListener(this._dragStartTarget, L.Draggable.START, this._onDown, this);
+		this._enabled = true;
+	},
+
+	disable: function () {
+		if (!this._enabled) {
+			return;
+		}
+		L.DomEvent.removeListener(this._dragStartTarget, L.Draggable.START, this._onDown);
+		this._enabled = false;
+	},
+
+	_onDown: function (e) {
+		if ((!L.Browser.touch && e.shiftKey) || ((e.which !== 1) && (e.button !== 1) && !e.touches)) {
+			return;
+		}
+
+		if (e.touches && e.touches.length > 1) {
+			return;
+		}
+
+		var first = (e.touches && e.touches.length === 1 ? e.touches[0] : e),
+			el = first.target;
+
+		L.DomEvent.preventDefault(e);
+
+		if (L.Browser.touch && el.tagName.toLowerCase() === 'a') {
+			el.className += ' leaflet-active';
+		}
+
+		this._moved = false;
+		if (this._moving) {
+			return;
+		}
+
+		if (!L.Browser.touch) {
+			L.DomUtil.disableTextSelection();
+			this._setMovingCursor();
+		}
+
+		this._startPos = this._newPos = L.DomUtil.getPosition(this._element);
+		this._startPoint = new L.Point(first.clientX, first.clientY);
+
+		L.DomEvent.addListener(document, L.Draggable.MOVE, this._onMove, this);
+		L.DomEvent.addListener(document, L.Draggable.END, this._onUp, this);
+	},
+
+	_onMove: function (e) {
+		if (e.touches && e.touches.length > 1) {
+			return;
+		}
+
+		L.DomEvent.preventDefault(e);
+
+		var first = (e.touches && e.touches.length === 1 ? e.touches[0] : e);
+
+		if (!this._moved) {
+			this.fire('dragstart');
+			this._moved = true;
+		}
+		this._moving = true;
+
+		var newPoint = new L.Point(first.clientX, first.clientY);
+		this._newPos = this._startPos.add(newPoint).subtract(this._startPoint);
+
+		L.Util.requestAnimFrame(this._updatePosition, this, true, this._dragStartTarget);
+	},
+
+	_updatePosition: function () {
+		this.fire('predrag');
+		L.DomUtil.setPosition(this._element, this._newPos);
+		this.fire('drag');
+	},
+
+	_onUp: function (e) {
+		if (e.changedTouches) {
+			var first = e.changedTouches[0],
+				el = first.target,
+				dist = (this._newPos && this._newPos.distanceTo(this._startPos)) || 0;
+
+			if (el.tagName.toLowerCase() === 'a') {
+				el.className = el.className.replace(' leaflet-active', '');
+			}
+
+			if (dist < L.Draggable.TAP_TOLERANCE) {
+				this._simulateEvent('click', first);
+			}
+		}
+
+		if (!L.Browser.touch) {
+			L.DomUtil.enableTextSelection();
+			this._restoreCursor();
+		}
+
+		L.DomEvent.removeListener(document, L.Draggable.MOVE, this._onMove);
+		L.DomEvent.removeListener(document, L.Draggable.END, this._onUp);
+
+		if (this._moved) {
+			this.fire('dragend');
+		}
+		this._moving = false;
+	},
+
+	_setMovingCursor: function () {
+		this._bodyCursor = document.body.style.cursor;
+		document.body.style.cursor = 'move';
+	},
+
+	_restoreCursor: function () {
+		document.body.style.cursor = this._bodyCursor;
+	},
+
+	_simulateEvent: function (type, e) {
+		var simulatedEvent = document.createEvent('MouseEvents');
+
+		simulatedEvent.initMouseEvent(
+				type, true, true, window, 1,
+				e.screenX, e.screenY,
+				e.clientX, e.clientY,
+				false, false, false, false, 0, null);
+
+		e.target.dispatchEvent(simulatedEvent);
+	}
+});