leaflet-ruby 0.3.beta1

data/lib/leaflet/src/dom/transition/Transition.Native.js

@@ -0,0 +1,102 @@
+/*
+ * L.Transition native implementation that powers Leaflet animation
+ * in browsers that support CSS3 Transitions
+ */
+
+L.Transition = L.Transition.extend({
+	statics: (function () {
+		var transition = L.DomUtil.TRANSITION,
+			transitionEnd = (transition === 'webkitTransition' || transition === 'OTransition' ?
+				transition + 'End' : 'transitionend');
+
+		return {
+			NATIVE: !!transition,
+
+			TRANSITION: transition,
+			PROPERTY: transition + 'Property',
+			DURATION: transition + 'Duration',
+			EASING: transition + 'TimingFunction',
+			END: transitionEnd,
+
+			// transition-property value to use with each particular custom property
+			CUSTOM_PROPS_PROPERTIES: {
+				position: L.Browser.webkit ? L.DomUtil.TRANSFORM : 'top, left'
+			}
+		};
+	}()),
+
+	options: {
+		fakeStepInterval: 100
+	},
+
+	initialize: function (/*HTMLElement*/ el, /*Object*/ options) {
+		this._el = el;
+		L.Util.setOptions(this, options);
+
+		L.DomEvent.addListener(el, L.Transition.END, this._onTransitionEnd, this);
+		this._onFakeStep = L.Util.bind(this._onFakeStep, this);
+	},
+
+	run: function (/*Object*/ props) {
+		var prop,
+			propsList = [],
+			customProp = L.Transition.CUSTOM_PROPS_PROPERTIES;
+
+		for (prop in props) {
+			if (props.hasOwnProperty(prop)) {
+				prop = customProp[prop] ? customProp[prop] : prop;
+				prop = this._dasherize(prop);
+				propsList.push(prop);
+			}
+		}
+
+		this._el.style[L.Transition.DURATION] = this.options.duration + 's';
+		this._el.style[L.Transition.EASING] = this.options.easing;
+		this._el.style[L.Transition.PROPERTY] = propsList.join(', ');
+
+		for (prop in props) {
+			if (props.hasOwnProperty(prop)) {
+				this._setProperty(prop, props[prop]);
+			}
+		}
+
+		this._inProgress = true;
+
+		this.fire('start');
+
+		if (L.Transition.NATIVE) {
+			clearInterval(this._timer);
+			this._timer = setInterval(this._onFakeStep, this.options.fakeStepInterval);
+		} else {
+			this._onTransitionEnd();
+		}
+	},
+
+	_dasherize: (function () {
+		var re = /([A-Z])/g;
+
+		function replaceFn(w) {
+			return '-' + w.toLowerCase();
+		}
+
+		return function (str) {
+			return str.replace(re, replaceFn);
+		};
+	}()),
+
+	_onFakeStep: function () {
+		this.fire('step');
+	},
+
+	_onTransitionEnd: function () {
+		if (this._inProgress) {
+			this._inProgress = false;
+			clearInterval(this._timer);
+
+			this._el.style[L.Transition.PROPERTY] = 'none';
+
+			this.fire('step');
+			this.fire('end');
+		}
+	}
+});

data/lib/leaflet/src/dom/transition/Transition.Timer.js

@@ -0,0 +1,126 @@
+/*
+ * L.Transition fallback implementation that powers Leaflet animation
+ * in browsers that don't support CSS3 Transitions
+ */
+
+L.Transition = L.Transition.NATIVE ? L.Transition : L.Transition.extend({
+	statics: {
+		getTime: Date.now || function () {
+			return +new Date();
+		},
+
+		TIMER: true,
+
+		EASINGS: {
+			'ease': [0.25, 0.1, 0.25, 1.0],
+			'linear': [0.0, 0.0, 1.0, 1.0],
+			'ease-in': [0.42, 0, 1.0, 1.0],
+			'ease-out': [0, 0, 0.58, 1.0],
+			'ease-in-out': [0.42, 0, 0.58, 1.0]
+		},
+
+		CUSTOM_PROPS_GETTERS: {
+			position: L.DomUtil.getPosition
+		},
+
+		//used to get units from strings like "10.5px" (->px)
+		UNIT_RE: /^[\d\.]+(\D*)$/
+	},
+
+	options: {
+		fps: 50
+	},
+
+	initialize: function (el, options) {
+		this._el = el;
+		L.Util.extend(this.options, options);
+
+		var easings = L.Transition.EASINGS[this.options.easing] || L.Transition.EASINGS.ease;
+
+		this._p1 = new L.Point(0, 0);
+		this._p2 = new L.Point(easings[0], easings[1]);
+		this._p3 = new L.Point(easings[2], easings[3]);
+		this._p4 = new L.Point(1, 1);
+
+		this._step = L.Util.bind(this._step, this);
+		this._interval = Math.round(1000 / this.options.fps);
+	},
+
+	run: function (props) {
+		this._props = {};
+
+		var getters = L.Transition.CUSTOM_PROPS_GETTERS,
+			re = L.Transition.UNIT_RE;
+
+		this.fire('start');
+
+		for (var prop in props) {
+			if (props.hasOwnProperty(prop)) {
+				var p = {};
+				if (prop in getters) {
+					p.from = getters[prop](this._el);
+				} else {
+					var matches = this._el.style[prop].match(re);
+					p.from = parseFloat(matches[0]);
+					p.unit = matches[1];
+				}
+				p.to = props[prop];
+				this._props[prop] = p;
+			}
+		}
+
+		clearInterval(this._timer);
+		this._timer = setInterval(this._step, this._interval);
+		this._startTime = L.Transition.getTime();
+	},
+
+	_step: function () {
+		var time = L.Transition.getTime(),
+			elapsed = time - this._startTime,
+			duration = this.options.duration * 1000;
+
+		if (elapsed < duration) {
+			this._runFrame(this._cubicBezier(elapsed / duration));
+		} else {
+			this._runFrame(1);
+			this._complete();
+		}
+	},
+
+	_runFrame: function (percentComplete) {
+		var setters = L.Transition.CUSTOM_PROPS_SETTERS,
+			prop, p, value;
+
+		for (prop in this._props) {
+			if (this._props.hasOwnProperty(prop)) {
+				p = this._props[prop];
+				if (prop in setters) {
+					value = p.to.subtract(p.from).multiplyBy(percentComplete).add(p.from);
+					setters[prop](this._el, value);
+				} else {
+					this._el.style[prop] =
+							((p.to - p.from) * percentComplete + p.from) + p.unit;
+				}
+			}
+		}
+		this.fire('step');
+	},
+
+	_complete: function () {
+		clearInterval(this._timer);
+		this.fire('end');
+	},
+
+	_cubicBezier: function (t) {
+		var a = Math.pow(1 - t, 3),
+			b = 3 * Math.pow(1 - t, 2) * t,
+			c = 3 * (1 - t) * Math.pow(t, 2),
+			d = Math.pow(t, 3),
+			p1 = this._p1.multiplyBy(a),
+			p2 = this._p2.multiplyBy(b),
+			p3 = this._p3.multiplyBy(c),
+			p4 = this._p4.multiplyBy(d);
+
+		return p1.add(p2).add(p3).add(p4).y;
+	}
+});

data/lib/leaflet/src/dom/transition/Transition.js

@@ -0,0 +1,28 @@
+L.Transition = L.Class.extend({
+	includes: L.Mixin.Events,
+
+	statics: {
+		CUSTOM_PROPS_SETTERS: {
+			position: L.DomUtil.setPosition
+			//TODO transform custom attr
+		},
+
+		implemented: function () {
+			return L.Transition.NATIVE || L.Transition.TIMER;
+		}
+	},
+
+	options: {
+		easing: 'ease',
+		duration: 0.5
+	},
+
+	_setProperty: function (prop, value) {
+		var setters = L.Transition.CUSTOM_PROPS_SETTERS;
+		if (prop in setters) {
+			setters[prop](this._el, value);
+		} else {
+			this._el.style[prop] = value;
+		}
+	}
+});

data/lib/leaflet/src/geo/LatLng.js

@@ -0,0 +1,44 @@
+/*
+	CM.LatLng represents a geographical point with latitude and longtitude coordinates.
+*/
+
+L.LatLng = function (/*Number*/ rawLat, /*Number*/ rawLng, /*Boolean*/ noWrap) {
+	var lat = parseFloat(rawLat),
+		lng = parseFloat(rawLng);
+
+	if (isNaN(lat) || isNaN(lng)) {
+		throw new Error('Invalid LatLng object: (' + rawLat + ', ' + rawLng + ')');
+	}
+
+	if (noWrap !== true) {
+		lat = Math.max(Math.min(lat, 90), -90);					// clamp latitude into -90..90
+		lng = (lng + 180) % 360 + ((lng < -180 || lng === 180) ? 180 : -180);	// wrap longtitude into -180..180
+	}
+
+	//TODO change to lat() & lng()
+	this.lat = lat;
+	this.lng = lng;
+};
+
+L.Util.extend(L.LatLng, {
+	DEG_TO_RAD: Math.PI / 180,
+	RAD_TO_DEG: 180 / Math.PI,
+	MAX_MARGIN: 1.0E-9 // max margin of error for the "equals" check
+});
+
+L.LatLng.prototype = {
+	equals: function (/*LatLng*/ obj) {
+		if (!(obj instanceof L.LatLng)) {
+			return false;
+		}
+
+		var margin = Math.max(Math.abs(this.lat - obj.lat), Math.abs(this.lng - obj.lng));
+		return margin <= L.LatLng.MAX_MARGIN;
+	},
+
+	toString: function () {
+		return 'LatLng(' +
+				L.Util.formatNum(this.lat) + ', ' +
+				L.Util.formatNum(this.lng) + ')';
+	}
+};

data/lib/leaflet/src/geo/LatLngBounds.js

@@ -0,0 +1,86 @@
+/*
+ * L.LatLngBounds represents a rectangular area on the map in geographical coordinates.
+ */
+
+L.LatLngBounds = L.Class.extend({
+	initialize: function (southWest, northEast) {	// (LatLng, LatLng) or (LatLng[])
+		if (!southWest) {
+			return;
+		}
+		var latlngs = (southWest instanceof Array ? southWest : [southWest, northEast]);
+		for (var i = 0, len = latlngs.length; i < len; i++) {
+			this.extend(latlngs[i]);
+		}
+	},
+
+	// extend the bounds to contain the given point
+	extend: function (/*LatLng*/ latlng) {
+		if (!this._southWest && !this._northEast) {
+			this._southWest = new L.LatLng(latlng.lat, latlng.lng, true);
+			this._northEast = new L.LatLng(latlng.lat, latlng.lng, true);
+		} else {
+			this._southWest.lat = Math.min(latlng.lat, this._southWest.lat);
+			this._southWest.lng = Math.min(latlng.lng, this._southWest.lng);
+			this._northEast.lat = Math.max(latlng.lat, this._northEast.lat);
+			this._northEast.lng = Math.max(latlng.lng, this._northEast.lng);
+		}
+	},
+
+	getCenter: function () /*-> LatLng*/ {
+		return new L.LatLng(
+				(this._southWest.lat + this._northEast.lat) / 2,
+				(this._southWest.lng + this._northEast.lng) / 2);
+	},
+
+	getSouthWest: function () {
+		return this._southWest;
+	},
+
+	getNorthEast: function () {
+		return this._northEast;
+	},
+
+	getNorthWest: function () {
+		return new L.LatLng(this._northEast.lat, this._southWest.lng, true);
+	},
+
+	getSouthEast: function () {
+		return new L.LatLng(this._southWest.lat, this._northEast.lng, true);
+	},
+
+	contains: function (/*LatLngBounds or LatLng*/ obj) /*-> Boolean*/ {
+		var sw = this._southWest,
+			ne = this._northEast,
+			sw2, ne2;
+
+		if (obj instanceof L.LatLngBounds) {
+			sw2 = obj.getSouthWest();
+			ne2 = obj.getNorthEast();
+		} else {
+			sw2 = ne2 = obj;
+		}
+
+		return (sw2.lat >= sw.lat) && (ne2.lat <= ne.lat) &&
+				(sw2.lng >= sw.lng) && (ne2.lng <= ne.lng);
+	},
+
+	intersects: function (/*LatLngBounds*/ bounds) {
+		var sw = this._southWest,
+			ne = this._northEast,
+			sw2 = bounds.getSouthWest(),
+			ne2 = bounds.getNorthEast();
+
+		var latIntersects = (ne2.lat >= sw.lat) && (sw2.lat <= ne.lat),
+			lngIntersects = (ne2.lng >= sw.lng) && (sw2.lng <= ne.lng);
+
+		return latIntersects && lngIntersects;
+	},
+
+	toBBoxString: function () {
+		var sw = this._southWest,
+			ne = this._northEast;
+		return [sw.lng, sw.lat, ne.lng, ne.lat].join(',');
+	}
+});
+
+//TODO International date line?

data/lib/leaflet/src/geo/crs/CRS.EPSG3395.js

@@ -0,0 +1,13 @@
+
+L.CRS.EPSG3395 = L.Util.extend({}, L.CRS, {
+	code: 'EPSG:3395',
+
+	projection: L.Projection.Mercator,
+	transformation: (function () {
+		var m = L.Projection.Mercator,
+			r = m.R_MAJOR,
+			r2 = m.R_MINOR;
+
+		return new L.Transformation(0.5 / (Math.PI * r), 0.5, -0.5 / (Math.PI * r2), 0.5);
+	}())
+});

data/lib/leaflet/src/geo/crs/CRS.EPSG3857.js

@@ -0,0 +1,17 @@
+
+L.CRS.EPSG3857 = L.Util.extend({}, L.CRS, {
+	code: 'EPSG:3857',
+
+	projection: L.Projection.SphericalMercator,
+	transformation: new L.Transformation(0.5 / Math.PI, 0.5, -0.5 / Math.PI, 0.5),
+
+	project: function (/*LatLng*/ latlng)/*-> Point*/ {
+		var projectedPoint = this.projection.project(latlng),
+			earthRadius = 6378137;
+		return projectedPoint.multiplyBy(earthRadius);
+	}
+});
+
+L.CRS.EPSG900913 = L.Util.extend({}, L.CRS.EPSG3857, {
+	code: 'EPSG:900913'
+});

data/lib/leaflet/src/geo/crs/CRS.EPSG4326.js

@@ -0,0 +1,7 @@
+
+L.CRS.EPSG4326 = L.Util.extend({}, L.CRS, {
+	code: 'EPSG:4326',
+
+	projection: L.Projection.LonLat,
+	transformation: new L.Transformation(1 / 360, 0.5, -1 / 360, 0.5)
+});

data/lib/leaflet/src/geo/crs/CRS.js

@@ -0,0 +1,17 @@
+
+L.CRS = {
+	latLngToPoint: function (/*LatLng*/ latlng, /*Number*/ scale)/*-> Point*/ {
+		var projectedPoint = this.projection.project(latlng);
+		return this.transformation._transform(projectedPoint, scale);
+	},
+
+	pointToLatLng: function (/*Point*/ point, /*Number*/ scale, /*(optional) Boolean*/ unbounded)/*-> LatLng*/ {
+		var untransformedPoint = this.transformation.untransform(point, scale);
+		return this.projection.unproject(untransformedPoint, unbounded);
+		//TODO get rid of 'unbounded' everywhere
+	},
+
+	project: function (latlng) {
+		return this.projection.project(latlng);
+	}
+};