leaflet-ruby 0.3.beta1

data/lib/leaflet/src/layer/marker/Icon.js

@@ -0,0 +1,58 @@
+L.Icon = L.Class.extend({
+	iconUrl: L.ROOT_URL + 'images/marker.png',
+	shadowUrl: L.ROOT_URL + 'images/marker-shadow.png',
+
+	iconSize: new L.Point(25, 41),
+	shadowSize: new L.Point(41, 41),
+
+	iconAnchor: new L.Point(13, 41),
+	popupAnchor: new L.Point(0, -33),
+
+	initialize: function (iconUrl) {
+		if (iconUrl) {
+			this.iconUrl = iconUrl;
+		}
+	},
+
+	createIcon: function () {
+		return this._createIcon('icon');
+	},
+
+	createShadow: function () {
+		return this._createIcon('shadow');
+	},
+
+	_createIcon: function (name) {
+		var size = this[name + 'Size'],
+			src = this[name + 'Url'],
+			img = this._createImg(src);
+
+		if (!src) {
+			return null;
+		}
+
+		img.className = 'leaflet-marker-' + name;
+
+		img.style.marginLeft = (-this.iconAnchor.x) + 'px';
+		img.style.marginTop = (-this.iconAnchor.y) + 'px';
+
+		if (size) {
+			img.style.width = size.x + 'px';
+			img.style.height = size.y + 'px';
+		}
+
+		return img;
+	},
+
+	_createImg: function (src) {
+		var el;
+		if (!L.Browser.ie6) {
+			el = document.createElement('img');
+			el.src = src;
+		} else {
+			el = document.createElement('div');
+			el.style.filter = 'progid:DXImageTransform.Microsoft.AlphaImageLoader(src="' + src + '")';
+		}
+		return el;
+	}
+});

data/lib/leaflet/src/layer/marker/Marker.Drag.js

@@ -0,0 +1,57 @@
+/*
+ * L.Handler.MarkerDrag is used internally by L.Marker to make the markers draggable.
+ */
+
+L.Handler.MarkerDrag = L.Handler.extend({
+	initialize: function (marker) {
+		this._marker = marker;
+	},
+
+	addHooks: function () {
+		var icon = this._marker._icon;
+		if (!this._draggable) {
+			this._draggable = new L.Draggable(icon, icon);
+
+			this._draggable
+				.on('dragstart', this._onDragStart, this)
+				.on('drag', this._onDrag, this)
+				.on('dragend', this._onDragEnd, this);
+		}
+		this._draggable.enable();
+	},
+
+	removeHooks: function () {
+		this._draggable.disable();
+	},
+
+	moved: function () {
+		return this._draggable && this._draggable._moved;
+	},
+
+	_onDragStart: function (e) {
+		this._marker
+			.closePopup()
+			.fire('movestart')
+			.fire('dragstart');
+	},
+
+	_onDrag: function (e) {
+		// update shadow position
+		var iconPos = L.DomUtil.getPosition(this._marker._icon);
+		if (this._marker._shadow) {
+			L.DomUtil.setPosition(this._marker._shadow, iconPos);
+		}
+
+		this._marker._latlng = this._marker._map.layerPointToLatLng(iconPos);
+
+		this._marker
+			.fire('move')
+			.fire('drag');
+	},
+
+	_onDragEnd: function () {
+		this._marker
+			.fire('moveend')
+			.fire('dragend');
+	}
+});

data/lib/leaflet/src/layer/marker/Marker.Popup.js

@@ -0,0 +1,42 @@
+/*
+ * Popup extension to L.Marker, adding openPopup & bindPopup methods.
+ */
+
+L.Marker.include({
+	openPopup: function () {
+		this._popup.setLatLng(this._latlng);
+		if (this._map) {
+			this._map.openPopup(this._popup);
+		}
+
+		return this;
+	},
+
+	closePopup: function () {
+		if (this._popup) {
+			this._popup._close();
+		}
+		return this;
+	},
+
+	bindPopup: function (content, options) {
+		options = L.Util.extend({offset: this.options.icon.popupAnchor}, options);
+
+		if (!this._popup) {
+			this.on('click', this.openPopup, this);
+		}
+
+		this._popup = new L.Popup(options, this);
+		this._popup.setContent(content);
+
+		return this;
+	},
+
+	unbindPopup: function () {
+		if (this._popup) {
+			this._popup = null;
+			this.off('click', this.openPopup);
+		}
+		return this;
+	}
+});

data/lib/leaflet/src/layer/marker/Marker.js

@@ -0,0 +1,142 @@
+/*
+ * L.Marker is used to display clickable/draggable icons on the map.
+ */
+
+L.Marker = L.Class.extend({
+
+	includes: L.Mixin.Events,
+
+	options: {
+		icon: new L.Icon(),
+		title: '',
+		clickable: true,
+		draggable: false,
+		zIndexOffset: 0
+	},
+
+	initialize: function (latlng, options) {
+		L.Util.setOptions(this, options);
+		this._latlng = latlng;
+	},
+
+	onAdd: function (map) {
+		this._map = map;
+
+		this._initIcon();
+
+		map.on('viewreset', this._reset, this);
+		this._reset();
+	},
+
+	onRemove: function (map) {
+		this._removeIcon();
+
+		// TODO move to Marker.Popup.js
+		if (this.closePopup) {
+			this.closePopup();
+		}
+
+		this._map = null;
+
+		map.off('viewreset', this._reset, this);
+	},
+
+	getLatLng: function () {
+		return this._latlng;
+	},
+
+	setLatLng: function (latlng) {
+		this._latlng = latlng;
+		if (this._icon) {
+			this._reset();
+
+			if (this._popup) {
+				this._popup.setLatLng(this._latlng);
+			}
+		}
+	},
+
+	setIcon: function (icon) {
+		if (this._map) {
+			this._removeIcon();
+		}
+
+		this.options.icon = icon;
+
+		if (this._map) {
+			this._initIcon();
+			this._reset();
+		}
+	},
+
+	_initIcon: function () {
+		if (!this._icon) {
+			this._icon = this.options.icon.createIcon();
+
+			if (this.options.title) {
+				this._icon.title = this.options.title;
+			}
+
+			this._initInteraction();
+		}
+		if (!this._shadow) {
+			this._shadow = this.options.icon.createShadow();
+		}
+
+		this._map._panes.markerPane.appendChild(this._icon);
+		if (this._shadow) {
+			this._map._panes.shadowPane.appendChild(this._shadow);
+		}
+	},
+
+	_removeIcon: function () {
+		this._map._panes.markerPane.removeChild(this._icon);
+		if (this._shadow) {
+			this._map._panes.shadowPane.removeChild(this._shadow);
+		}
+		this._icon = this._shadow = null;
+	},
+
+	_reset: function () {
+		var pos = this._map.latLngToLayerPoint(this._latlng).round();
+
+		L.DomUtil.setPosition(this._icon, pos);
+		if (this._shadow) {
+			L.DomUtil.setPosition(this._shadow, pos);
+		}
+
+		this._icon.style.zIndex = pos.y + this.options.zIndexOffset;
+	},
+
+	_initInteraction: function () {
+		if (this.options.clickable) {
+			this._icon.className += ' leaflet-clickable';
+
+			L.DomEvent.addListener(this._icon, 'click', this._onMouseClick, this);
+
+			var events = ['dblclick', 'mousedown', 'mouseover', 'mouseout'];
+			for (var i = 0; i < events.length; i++) {
+				L.DomEvent.addListener(this._icon, events[i], this._fireMouseEvent, this);
+			}
+		}
+
+		if (L.Handler.MarkerDrag) {
+			this.dragging = new L.Handler.MarkerDrag(this);
+
+			if (this.options.draggable) {
+				this.dragging.enable();
+			}
+		}
+	},
+
+	_onMouseClick: function (e) {
+		L.DomEvent.stopPropagation(e);
+		if (this.dragging && this.dragging.moved()) { return; }
+		this.fire(e.type);
+	},
+
+	_fireMouseEvent: function (e) {
+		this.fire(e.type);
+		L.DomEvent.stopPropagation(e);
+	}
+});

data/lib/leaflet/src/layer/tile/TileLayer.Canvas.js

@@ -0,0 +1,41 @@
+L.TileLayer.Canvas = L.TileLayer.extend({
+	options: {
+		async: false
+	},
+
+	initialize: function (options) {
+		L.Util.setOptions(this, options);
+	},
+
+	_createTileProto: function () {
+		this._canvasProto = L.DomUtil.create('canvas', 'leaflet-tile');
+
+		var tileSize = this.options.tileSize;
+		this._canvasProto.width = tileSize;
+		this._canvasProto.height = tileSize;
+	},
+
+	_createTile: function () {
+		var tile = this._canvasProto.cloneNode(false);
+		tile.onselectstart = tile.onmousemove = L.Util.falseFn;
+		return tile;
+	},
+
+	_loadTile: function (tile, tilePoint, zoom) {
+		tile._layer = this;
+
+		this.drawTile(tile, tilePoint, zoom);
+
+		if (!this.options.async) {
+			this.tileDrawn(tile);
+		}
+	},
+
+	drawTile: function (tile, tilePoint, zoom) {
+		// override with rendering code
+	},
+
+	tileDrawn: function (tile) {
+		this._tileOnLoad.call(tile);
+	}
+});

data/lib/leaflet/src/layer/tile/TileLayer.WMS.js

@@ -0,0 +1,47 @@
+L.TileLayer.WMS = L.TileLayer.extend({
+	defaultWmsParams: {
+		service: 'WMS',
+		request: 'GetMap',
+		version: '1.1.1',
+		layers: '',
+		styles: '',
+		format: 'image/jpeg',
+		transparent: false
+	},
+
+	initialize: function (/*String*/ url, /*Object*/ options) {
+		this._url = url;
+
+		this.wmsParams = L.Util.extend({}, this.defaultWmsParams);
+		this.wmsParams.width = this.wmsParams.height = this.options.tileSize;
+
+		for (var i in options) {
+			// all keys that are not TileLayer options go to WMS params
+			if (!this.options.hasOwnProperty(i)) {
+				this.wmsParams[i] = options[i];
+			}
+		}
+
+		L.Util.setOptions(this, options);
+	},
+
+	onAdd: function (map) {
+		var projectionKey = (parseFloat(this.wmsParams.version) >= 1.3 ? 'crs' : 'srs');
+		this.wmsParams[projectionKey] = map.options.crs.code;
+
+		L.TileLayer.prototype.onAdd.call(this, map);
+	},
+
+	getTileUrl: function (/*Point*/ tilePoint, /*Number*/ zoom)/*-> String*/ {
+		var tileSize = this.options.tileSize,
+			nwPoint = tilePoint.multiplyBy(tileSize),
+			sePoint = nwPoint.add(new L.Point(tileSize, tileSize)),
+			nwMap = this._map.unproject(nwPoint, this._zoom, true),
+			seMap = this._map.unproject(sePoint, this._zoom, true),
+			nw = this._map.options.crs.project(nwMap),
+			se = this._map.options.crs.project(seMap),
+			bbox = [nw.x, se.y, se.x, nw.y].join(',');
+
+		return this._url + L.Util.getParamString(this.wmsParams) + "&bbox=" + bbox;
+	}
+});

data/lib/leaflet/src/layer/tile/TileLayer.js

@@ -0,0 +1,310 @@
+/*
+ * L.TileLayer is used for standard xyz-numbered tile layers.
+ */
+
+L.TileLayer = L.Class.extend({
+	includes: L.Mixin.Events,
+
+	options: {
+		minZoom: 0,
+		maxZoom: 18,
+		tileSize: 256,
+		subdomains: 'abc',
+		errorTileUrl: '',
+		attribution: '',
+		opacity: 1,
+		scheme: 'xyz',
+		continuousWorld: false,
+		noWrap: false,
+		zoomOffset: 0,
+
+		unloadInvisibleTiles: L.Browser.mobile,
+		updateWhenIdle: L.Browser.mobile
+	},
+
+	initialize: function (url, options, urlParams) {
+		L.Util.setOptions(this, options);
+
+		this._url = url;
+		this._urlParams = urlParams;
+
+		if (typeof this.options.subdomains === 'string') {
+			this.options.subdomains = this.options.subdomains.split('');
+		}
+	},
+
+	onAdd: function (map, insertAtTheBottom) {
+		this._map = map;
+		this._insertAtTheBottom = insertAtTheBottom;
+
+		// create a container div for tiles
+		this._initContainer();
+
+		// create an image to clone for tiles
+		this._createTileProto();
+
+		// set up events
+		map.on('viewreset', this._resetCallback, this);
+
+		if (this.options.updateWhenIdle) {
+			map.on('moveend', this._update, this);
+		} else {
+			this._limitedUpdate = L.Util.limitExecByInterval(this._update, 150, this);
+			map.on('move', this._limitedUpdate, this);
+		}
+
+		this._reset();
+		this._update();
+	},
+
+	onRemove: function (map) {
+		this._map.getPanes().tilePane.removeChild(this._container);
+		this._container = null;
+
+		this._map.off('viewreset', this._resetCallback, this);
+
+		if (this.options.updateWhenIdle) {
+			this._map.off('moveend', this._update, this);
+		} else {
+			this._map.off('move', this._limitedUpdate, this);
+		}
+	},
+
+	getAttribution: function () {
+		return this.options.attribution;
+	},
+
+	setOpacity: function (opacity) {
+		this.options.opacity = opacity;
+
+		this._setOpacity(opacity);
+
+		// stupid webkit hack to force redrawing of tiles
+		if (L.Browser.webkit) {
+			for (var i in this._tiles) {
+				if (this._tiles.hasOwnProperty(i)) {
+					this._tiles[i].style.webkitTransform += ' translate(0,0)';
+				}
+			}
+		}
+	},
+
+	_setOpacity: function (opacity) {
+		if (opacity < 1) {
+			L.DomUtil.setOpacity(this._container, opacity);
+		}
+	},
+
+	_initContainer: function () {
+		var tilePane = this._map.getPanes().tilePane,
+			first = tilePane.firstChild;
+
+		if (!this._container || tilePane.empty) {
+			this._container = L.DomUtil.create('div', 'leaflet-layer');
+
+			if (this._insertAtTheBottom && first) {
+				tilePane.insertBefore(this._container, first);
+			} else {
+				tilePane.appendChild(this._container);
+			}
+
+			this._setOpacity(this.options.opacity);
+		}
+	},
+
+	_resetCallback: function (e) {
+		this._reset(e.hard);
+	},
+
+	_reset: function (clearOldContainer) {
+		var key;
+		for (key in this._tiles) {
+			if (this._tiles.hasOwnProperty(key)) {
+				this.fire("tileunload", {tile: this._tiles[key]});
+			}
+		}
+		this._tiles = {};
+
+		if (clearOldContainer && this._container) {
+			this._container.innerHTML = "";
+		}
+		this._initContainer();
+	},
+
+	_update: function () {
+		var bounds = this._map.getPixelBounds(),
+			tileSize = this.options.tileSize;
+
+		var nwTilePoint = new L.Point(
+				Math.floor(bounds.min.x / tileSize),
+				Math.floor(bounds.min.y / tileSize)),
+			seTilePoint = new L.Point(
+				Math.floor(bounds.max.x / tileSize),
+				Math.floor(bounds.max.y / tileSize)),
+			tileBounds = new L.Bounds(nwTilePoint, seTilePoint);
+
+		this._addTilesFromCenterOut(tileBounds);
+
+		if (this.options.unloadInvisibleTiles) {
+			this._removeOtherTiles(tileBounds);
+		}
+	},
+
+	_addTilesFromCenterOut: function (bounds) {
+		var queue = [],
+			center = bounds.getCenter();
+
+		for (var j = bounds.min.y; j <= bounds.max.y; j++) {
+			for (var i = bounds.min.x; i <= bounds.max.x; i++) {
+				if ((i + ':' + j) in this._tiles) {
+					continue;
+				}
+				queue.push(new L.Point(i, j));
+			}
+		}
+
+		// load tiles in order of their distance to center
+		queue.sort(function (a, b) {
+			return a.distanceTo(center) - b.distanceTo(center);
+		});
+
+		var fragment = document.createDocumentFragment();
+
+		this._tilesToLoad = queue.length;
+		for (var k = 0, len = this._tilesToLoad; k < len; k++) {
+			this._addTile(queue[k], fragment);
+		}
+
+		this._container.appendChild(fragment);
+	},
+
+	_removeOtherTiles: function (bounds) {
+		var kArr, x, y, key, tile;
+
+		for (key in this._tiles) {
+			if (this._tiles.hasOwnProperty(key)) {
+				kArr = key.split(':');
+				x = parseInt(kArr[0], 10);
+				y = parseInt(kArr[1], 10);
+
+				// remove tile if it's out of bounds
+				if (x < bounds.min.x || x > bounds.max.x || y < bounds.min.y || y > bounds.max.y) {
+
+					tile = this._tiles[key];
+					this.fire("tileunload", {tile: tile, url: tile.src});
+
+					// evil, don't do this! crashes Android 3, produces load errors, doesn't solve memory leaks
+					// this._tiles[key].src = '';
+
+					if (tile.parentNode === this._container) {
+						this._container.removeChild(tile);
+					}
+					delete this._tiles[key];
+				}
+			}
+		}
+	},
+
+	_addTile: function (tilePoint, container) {
+		var tilePos = this._getTilePos(tilePoint),
+			zoom = this._map.getZoom(),
+			key = tilePoint.x + ':' + tilePoint.y,
+			tileLimit = Math.pow(2, (zoom + this.options.zoomOffset));
+
+		// wrap tile coordinates
+		if (!this.options.continuousWorld) {
+			if (!this.options.noWrap) {
+				tilePoint.x = ((tilePoint.x % tileLimit) + tileLimit) % tileLimit;
+			} else if (tilePoint.x < 0 || tilePoint.x >= tileLimit) {
+				this._tilesToLoad--;
+				return;
+			}
+
+			if (tilePoint.y < 0 || tilePoint.y >= tileLimit) {
+				this._tilesToLoad--;
+				return;
+			}
+		}
+
+		// create tile
+		var tile = this._createTile();
+		L.DomUtil.setPosition(tile, tilePos);
+
+		this._tiles[key] = tile;
+
+		if (this.options.scheme === 'tms') {
+			tilePoint.y = tileLimit - tilePoint.y - 1;
+		}
+
+		this._loadTile(tile, tilePoint, zoom);
+
+		container.appendChild(tile);
+	},
+
+	_getTilePos: function (tilePoint) {
+		var origin = this._map.getPixelOrigin(),
+			tileSize = this.options.tileSize;
+
+		return tilePoint.multiplyBy(tileSize).subtract(origin);
+	},
+
+	// image-specific code (override to implement e.g. Canvas or SVG tile layer)
+
+	getTileUrl: function (tilePoint, zoom) {
+		var subdomains = this.options.subdomains,
+			s = this.options.subdomains[(tilePoint.x + tilePoint.y) % subdomains.length];
+
+		return L.Util.template(this._url, L.Util.extend({
+			s: s,
+			z: zoom + this.options.zoomOffset,
+			x: tilePoint.x,
+			y: tilePoint.y
+		}, this._urlParams));
+	},
+
+	_createTileProto: function () {
+		this._tileImg = L.DomUtil.create('img', 'leaflet-tile');
+		this._tileImg.galleryimg = 'no';
+
+		var tileSize = this.options.tileSize;
+		this._tileImg.style.width = tileSize + 'px';
+		this._tileImg.style.height = tileSize + 'px';
+	},
+
+	_createTile: function () {
+		var tile = this._tileImg.cloneNode(false);
+		tile.onselectstart = tile.onmousemove = L.Util.falseFn;
+		return tile;
+	},
+
+	_loadTile: function (tile, tilePoint, zoom) {
+		tile._layer = this;
+		tile.onload = this._tileOnLoad;
+		tile.onerror = this._tileOnError;
+		tile.src = this.getTileUrl(tilePoint, zoom);
+	},
+
+	_tileOnLoad: function (e) {
+		var layer = this._layer;
+
+		this.className += ' leaflet-tile-loaded';
+
+		layer.fire('tileload', {tile: this, url: this.src});
+
+		layer._tilesToLoad--;
+		if (!layer._tilesToLoad) {
+			layer.fire('load');
+		}
+	},
+
+	_tileOnError: function (e) {
+		var layer = this._layer;
+
+		layer.fire('tileerror', {tile: this, url: this.src});
+
+		var newUrl = layer.options.errorTileUrl;
+		if (newUrl) {
+			this.src = newUrl;
+		}
+	}
+});