leaflet-ruby 0.3.beta1

data/lib/leaflet/src/control/Control.Layers.js

@@ -0,0 +1,167 @@
+
+L.Control.Layers = L.Class.extend({
+	options: {
+		collapsed: !L.Browser.touch
+	},
+
+	initialize: function (baseLayers, overlays, options) {
+		L.Util.setOptions(this, options);
+
+		this._layers = {};
+
+		for (var i in baseLayers) {
+			if (baseLayers.hasOwnProperty(i)) {
+				this._addLayer(baseLayers[i], i);
+			}
+		}
+
+		for (i in overlays) {
+			if (overlays.hasOwnProperty(i)) {
+				this._addLayer(overlays[i], i, true);
+			}
+		}
+	},
+
+	onAdd: function (map) {
+		this._map = map;
+
+		this._initLayout();
+		this._update();
+	},
+
+	getContainer: function () {
+		return this._container;
+	},
+
+	getPosition: function () {
+		return L.Control.Position.TOP_RIGHT;
+	},
+
+	addBaseLayer: function (layer, name) {
+		this._addLayer(layer, name);
+		this._update();
+		return this;
+	},
+
+	addOverlay: function (layer, name) {
+		this._addLayer(layer, name, true);
+		this._update();
+		return this;
+	},
+
+	removeLayer: function (layer) {
+		var id = L.Util.stamp(layer);
+		delete this._layers[id];
+		this._update();
+		return this;
+	},
+
+	_initLayout: function () {
+		this._container = L.DomUtil.create('div', 'leaflet-control-layers');
+		L.DomEvent.disableClickPropagation(this._container);
+
+		this._form = L.DomUtil.create('form', 'leaflet-control-layers-list');
+
+		if (this.options.collapsed) {
+			L.DomEvent.addListener(this._container, 'mouseover', this._expand, this);
+			L.DomEvent.addListener(this._container, 'mouseout', this._collapse, this);
+
+			var link = this._layersLink = L.DomUtil.create('a', 'leaflet-control-layers-toggle');
+			link.href = '#';
+			link.title = 'Layers';
+
+			L.DomEvent.addListener(link, 'focus', this._expand, this);
+			L.DomEvent.addListener(this._map, L.Draggable.START, this._collapse, this);
+			// TODO keyboard accessibility
+
+			this._container.appendChild(link);
+		} else {
+			this._expand();
+		}
+
+		this._baseLayersList = L.DomUtil.create('div', 'leaflet-control-layers-base', this._form);
+		this._separator = L.DomUtil.create('div', 'leaflet-control-layers-separator', this._form);
+		this._overlaysList = L.DomUtil.create('div', 'leaflet-control-layers-overlays', this._form);
+
+		this._container.appendChild(this._form);
+	},
+
+	_addLayer: function (layer, name, overlay) {
+		var id = L.Util.stamp(layer);
+		this._layers[id] = {
+			layer: layer,
+			name: name,
+			overlay: overlay
+		};
+	},
+
+	_update: function () {
+		if (!this._container) {
+			return;
+		}
+
+		this._baseLayersList.innerHTML = '';
+		this._overlaysList.innerHTML = '';
+
+		var baseLayersPresent = false,
+			overlaysPresent = false;
+
+		for (var i in this._layers) {
+			if (this._layers.hasOwnProperty(i)) {
+				var obj = this._layers[i];
+				this._addItem(obj);
+				overlaysPresent = overlaysPresent || obj.overlay;
+				baseLayersPresent = baseLayersPresent || !obj.overlay;
+			}
+		}
+
+		this._separator.style.display = (overlaysPresent && baseLayersPresent ? '' : 'none');
+	},
+
+	_addItem: function (obj, onclick) {
+		var label = document.createElement('label');
+
+		var input = document.createElement('input');
+		if (!obj.overlay) {
+			input.name = 'leaflet-base-layers';
+		}
+		input.type = obj.overlay ? 'checkbox' : 'radio';
+		input.checked = this._map.hasLayer(obj.layer);
+		input.layerId = L.Util.stamp(obj.layer);
+
+		L.DomEvent.addListener(input, 'click', this._onInputClick, this);
+
+		var name = document.createTextNode(' ' + obj.name);
+
+		label.appendChild(input);
+		label.appendChild(name);
+
+		var container = obj.overlay ? this._overlaysList : this._baseLayersList;
+		container.appendChild(label);
+	},
+
+	_onInputClick: function () {
+		var i, input, obj,
+			inputs = this._form.getElementsByTagName('input'),
+			inputsLen = inputs.length;
+
+		for (i = 0; i < inputsLen; i++) {
+			input = inputs[i];
+			obj = this._layers[input.layerId];
+
+			if (input.checked) {
+				this._map.addLayer(obj.layer, !obj.overlay);
+			} else {
+				this._map.removeLayer(obj.layer);
+			}
+		}
+	},
+
+	_expand: function () {
+		L.DomUtil.addClass(this._container, 'leaflet-control-layers-expanded');
+	},
+
+	_collapse: function () {
+		this._container.className = this._container.className.replace(' leaflet-control-layers-expanded', '');
+	}
+});

data/lib/leaflet/src/control/Control.Zoom.js

@@ -0,0 +1,36 @@
+
+L.Control.Zoom = L.Class.extend({
+	onAdd: function (map) {
+		this._map = map;
+		this._container = L.DomUtil.create('div', 'leaflet-control-zoom');
+
+		this._zoomInButton = this._createButton(
+				'Zoom in', 'leaflet-control-zoom-in', this._map.zoomIn, this._map);
+		this._zoomOutButton = this._createButton(
+				'Zoom out', 'leaflet-control-zoom-out', this._map.zoomOut, this._map);
+
+		this._container.appendChild(this._zoomInButton);
+		this._container.appendChild(this._zoomOutButton);
+	},
+
+	getContainer: function () {
+		return this._container;
+	},
+
+	getPosition: function () {
+		return L.Control.Position.TOP_LEFT;
+	},
+
+	_createButton: function (title, className, fn, context) {
+		var link = document.createElement('a');
+		link.href = '#';
+		link.title = title;
+		link.className = className;
+
+		L.DomEvent.disableClickPropagation(link);
+		L.DomEvent.addListener(link, 'click', L.DomEvent.preventDefault);
+		L.DomEvent.addListener(link, 'click', fn, context);
+
+		return link;
+	}
+});

data/lib/leaflet/src/control/Control.js

@@ -0,0 +1,9 @@
+
+L.Control = {};
+
+L.Control.Position = {
+	TOP_LEFT: 'topLeft',
+	TOP_RIGHT: 'topRight',
+	BOTTOM_LEFT: 'bottomLeft',
+	BOTTOM_RIGHT: 'bottomRight'
+};

data/lib/leaflet/src/core/Browser.js

@@ -0,0 +1,53 @@
+(function () {
+	var ua = navigator.userAgent.toLowerCase(),
+		ie = !!window.ActiveXObject,
+		webkit = ua.indexOf("webkit") !== -1,
+		mobile = typeof orientation !== 'undefined' ? true : false,
+		android = ua.indexOf("android") !== -1,
+		opera = window.opera;
+
+	L.Browser = {
+		ie: ie,
+		ie6: ie && !window.XMLHttpRequest,
+
+		webkit: webkit,
+		webkit3d: webkit && ('WebKitCSSMatrix' in window) && ('m11' in new window.WebKitCSSMatrix()),
+
+		gecko: ua.indexOf("gecko") !== -1,
+
+		opera: opera,
+
+		android: android,
+		mobileWebkit: mobile && webkit,
+		mobileOpera: mobile && opera,
+
+		mobile: mobile,
+		touch: (function () {
+			var touchSupported = false,
+				startName = 'ontouchstart';
+
+			// WebKit, etc
+			if (startName in document.documentElement) {
+				return true;
+			}
+
+			// Firefox/Gecko
+			var e = document.createElement('div');
+
+			// If no support for basic event stuff, unlikely to have touch support
+			if (!e.setAttribute || !e.removeAttribute) {
+				return false;
+			}
+
+			e.setAttribute(startName, 'return;');
+			if (typeof e[startName] === 'function') {
+				touchSupported = true;
+			}
+
+			e.removeAttribute(startName);
+			e = null;
+
+			return touchSupported;
+		}())
+	};
+}());

data/lib/leaflet/src/core/Class.js

@@ -0,0 +1,66 @@
+/*
+ * Class powers the OOP facilities of the library. Thanks to John Resig and Dean Edwards for inspiration!
+ */
+
+L.Class = function () {};
+
+L.Class.extend = function (/*Object*/ props) /*-> Class*/ {
+
+	// extended class with the new prototype
+	var NewClass = function () {
+		if (this.initialize) {
+			this.initialize.apply(this, arguments);
+		}
+	};
+
+	// instantiate class without calling constructor
+	var F = function () {};
+	F.prototype = this.prototype;
+	var proto = new F();
+
+	proto.constructor = NewClass;
+	NewClass.prototype = proto;
+
+	// add superclass access
+	NewClass.superclass = this.prototype;
+
+	// add class name
+	//proto.className = props;
+
+	//inherit parent's statics
+	for (var i in this) {
+		if (this.hasOwnProperty(i) && i !== 'prototype' && i !== 'superclass') {
+			NewClass[i] = this[i];
+		}
+	}
+
+	// mix static properties into the class
+	if (props.statics) {
+		L.Util.extend(NewClass, props.statics);
+		delete props.statics;
+	}
+
+	// mix includes into the prototype
+	if (props.includes) {
+		L.Util.extend.apply(null, [proto].concat(props.includes));
+		delete props.includes;
+	}
+
+	// merge options
+	if (props.options && proto.options) {
+		props.options = L.Util.extend({}, proto.options, props.options);
+	}
+
+	// mix given properties into the prototype
+	L.Util.extend(proto, props);
+
+	// allow inheriting further
+	NewClass.extend = L.Class.extend;
+
+	// method for adding properties to prototype
+	NewClass.include = function (props) {
+		L.Util.extend(this.prototype, props);
+	};
+
+	return NewClass;
+};

data/lib/leaflet/src/core/Events.js

@@ -0,0 +1,62 @@
+/*
+ * L.Mixin.Events adds custom events functionality to Leaflet classes
+ */
+
+L.Mixin = {};
+
+L.Mixin.Events = {
+	addEventListener: function (/*String*/ type, /*Function*/ fn, /*(optional) Object*/ context) {
+		var events = this._leaflet_events = this._leaflet_events || {};
+		events[type] = events[type] || [];
+		events[type].push({
+			action: fn,
+			context: context || this
+		});
+		return this;
+	},
+
+	hasEventListeners: function (/*String*/ type) /*-> Boolean*/ {
+		var k = '_leaflet_events';
+		return (k in this) && (type in this[k]) && (this[k][type].length > 0);
+	},
+
+	removeEventListener: function (/*String*/ type, /*Function*/ fn, /*(optional) Object*/ context) {
+		if (!this.hasEventListeners(type)) {
+			return this;
+		}
+
+		for (var i = 0, events = this._leaflet_events, len = events[type].length; i < len; i++) {
+			if (
+				(events[type][i].action === fn) &&
+				(!context || (events[type][i].context === context))
+			) {
+				events[type].splice(i, 1);
+				return this;
+			}
+		}
+		return this;
+	},
+
+	fireEvent: function (/*String*/ type, /*(optional) Object*/ data) {
+		if (!this.hasEventListeners(type)) {
+			return this;
+		}
+
+		var event = L.Util.extend({
+			type: type,
+			target: this
+		}, data);
+
+		var listeners = this._leaflet_events[type].slice();
+
+		for (var i = 0, len = listeners.length; i < len; i++) {
+			listeners[i].action.call(listeners[i].context || this, event);
+		}
+
+		return this;
+	}
+};
+
+L.Mixin.Events.on = L.Mixin.Events.addEventListener;
+L.Mixin.Events.off = L.Mixin.Events.removeEventListener;
+L.Mixin.Events.fire = L.Mixin.Events.fireEvent;

data/lib/leaflet/src/core/Handler.js

@@ -0,0 +1,29 @@
+/*
+ * L.Handler classes are used internally to inject interaction features to classes like Map and Marker.
+ */
+
+L.Handler = L.Class.extend({
+	initialize: function (map) {
+		this._map = map;
+	},
+
+	enable: function () {
+		if (this._enabled) {
+			return;
+		}
+		this._enabled = true;
+		this.addHooks();
+	},
+
+	disable: function () {
+		if (!this._enabled) {
+			return;
+		}
+		this._enabled = false;
+		this.removeHooks();
+	},
+
+	enabled: function () {
+		return !!this._enabled;
+	}
+});

data/lib/leaflet/src/core/Util.js

@@ -0,0 +1,108 @@
+/*
+ * L.Util is a namespace for various utility functions.
+ */
+
+L.Util = {
+	extend: function (/*Object*/ dest) /*-> Object*/ {	// merge src properties into dest
+		var sources = Array.prototype.slice.call(arguments, 1);
+		for (var j = 0, len = sources.length, src; j < len; j++) {
+			src = sources[j] || {};
+			for (var i in src) {
+				if (src.hasOwnProperty(i)) {
+					dest[i] = src[i];
+				}
+			}
+		}
+		return dest;
+	},
+
+	bind: function (/*Function*/ fn, /*Object*/ obj) /*-> Object*/ {
+		return function () {
+			return fn.apply(obj, arguments);
+		};
+	},
+
+	stamp: (function () {
+		var lastId = 0, key = '_leaflet_id';
+		return function (/*Object*/ obj) {
+			obj[key] = obj[key] || ++lastId;
+			return obj[key];
+		};
+	}()),
+
+	requestAnimFrame: (function () {
+		function timeoutDefer(callback) {
+			window.setTimeout(callback, 1000 / 60);
+		}
+
+		var requestFn = window.requestAnimationFrame ||
+			window.webkitRequestAnimationFrame ||
+			window.mozRequestAnimationFrame ||
+			window.oRequestAnimationFrame ||
+			window.msRequestAnimationFrame ||
+			timeoutDefer;
+
+		return function (callback, context, immediate, contextEl) {
+			callback = context ? L.Util.bind(callback, context) : callback;
+			if (immediate && requestFn === timeoutDefer) {
+				callback();
+			} else {
+				requestFn(callback, contextEl);
+			}
+		};
+	}()),
+
+	limitExecByInterval: function (fn, time, context) {
+		var lock, execOnUnlock, args;
+		function exec() {
+			lock = false;
+			if (execOnUnlock) {
+				args.callee.apply(context, args);
+				execOnUnlock = false;
+			}
+		}
+		return function () {
+			args = arguments;
+			if (!lock) {
+				lock = true;
+				setTimeout(exec, time);
+				fn.apply(context, args);
+			} else {
+				execOnUnlock = true;
+			}
+		};
+	},
+
+	falseFn: function () {
+		return false;
+	},
+
+	formatNum: function (num, digits) {
+		var pow = Math.pow(10, digits || 5);
+		return Math.round(num * pow) / pow;
+	},
+
+	setOptions: function (obj, options) {
+		obj.options = L.Util.extend({}, obj.options, options);
+	},
+
+	getParamString: function (obj) {
+		var params = [];
+		for (var i in obj) {
+			if (obj.hasOwnProperty(i)) {
+				params.push(i + '=' + obj[i]);
+			}
+		}
+		return '?' + params.join('&');
+	},
+
+	template: function (str, data) {
+		return str.replace(/\{ *([\w_]+) *\}/g, function (str, key) {
+			var value = data[key];
+			if (!data.hasOwnProperty(key)) {
+				throw new Error('No value provided for variable ' + str);
+			}
+			return value;
+		});
+	}
+};