leaflet-ruby 0.3.beta1

data/lib/leaflet/src/layer/vector/Polygon.js

@@ -0,0 +1,64 @@
+/*
+ * L.Polygon is used to display polygons on a map.
+ */
+
+L.Polygon = L.Polyline.extend({
+	options: {
+		fill: true
+	},
+
+	initialize: function (latlngs, options) {
+		L.Polyline.prototype.initialize.call(this, latlngs, options);
+
+		if (latlngs && (latlngs[0] instanceof Array)) {
+			this._latlngs = latlngs[0];
+			this._holes = latlngs.slice(1);
+		}
+	},
+
+	projectLatlngs: function () {
+		L.Polyline.prototype.projectLatlngs.call(this);
+
+		// project polygon holes points
+		// TODO move this logic to Polyline to get rid of duplication
+		this._holePoints = [];
+
+		if (!this._holes) {
+			return;
+		}
+
+		for (var i = 0, len = this._holes.length, hole; i < len; i++) {
+			this._holePoints[i] = [];
+
+			for (var j = 0, len2 = this._holes[i].length; j < len2; j++) {
+				this._holePoints[i][j] = this._map.latLngToLayerPoint(this._holes[i][j]);
+			}
+		}
+	},
+
+	_clipPoints: function () {
+		var points = this._originalPoints,
+			newParts = [];
+
+		this._parts = [points].concat(this._holePoints);
+
+		if (this.options.noClip) {
+			return;
+		}
+
+		for (var i = 0, len = this._parts.length; i < len; i++) {
+			var clipped = L.PolyUtil.clipPolygon(this._parts[i], this._map._pathViewport);
+			if (!clipped.length) {
+				continue;
+			}
+			newParts.push(clipped);
+		}
+
+		this._parts = newParts;
+	},
+
+	_getPathPartStr: function (points) {
+		var str = L.Polyline.prototype._getPathPartStr.call(this, points);
+		return str + (L.Browser.svg ? 'z' : 'x');
+	}
+});

data/lib/leaflet/src/layer/vector/Polyline.js

@@ -0,0 +1,146 @@
+
+L.Polyline = L.Path.extend({
+	initialize: function (latlngs, options) {
+		L.Path.prototype.initialize.call(this, options);
+		this._latlngs = latlngs;
+	},
+
+	options: {
+		// how much to simplify the polyline on each zoom level
+		// more = better performance and smoother look, less = more accurate
+		smoothFactor: 1.0,
+		noClip: false,
+
+		updateOnMoveEnd: true
+	},
+
+	projectLatlngs: function () {
+		this._originalPoints = [];
+
+		for (var i = 0, len = this._latlngs.length; i < len; i++) {
+			this._originalPoints[i] = this._map.latLngToLayerPoint(this._latlngs[i]);
+		}
+	},
+
+	getPathString: function () {
+		for (var i = 0, len = this._parts.length, str = ''; i < len; i++) {
+			str += this._getPathPartStr(this._parts[i]);
+		}
+		return str;
+	},
+
+	getLatLngs: function () {
+		return this._latlngs;
+	},
+
+	setLatLngs: function (latlngs) {
+		this._latlngs = latlngs;
+		this._redraw();
+		return this;
+	},
+
+	addLatLng: function (latlng) {
+		this._latlngs.push(latlng);
+		this._redraw();
+		return this;
+	},
+
+	spliceLatLngs: function (index, howMany) {
+		var removed = [].splice.apply(this._latlngs, arguments);
+		this._redraw();
+		return removed;
+	},
+
+	closestLayerPoint: function (p) {
+		var minDistance = Infinity, parts = this._parts, p1, p2, minPoint = null;
+
+		for (var j = 0, jLen = parts.length; j < jLen; j++) {
+			var points = parts[j];
+			for (var i = 1, len = points.length; i < len; i++) {
+				p1 = points[i - 1];
+				p2 = points[i];
+				var point = L.LineUtil._sqClosestPointOnSegment(p, p1, p2);
+				if (point._sqDist < minDistance) {
+					minDistance = point._sqDist;
+					minPoint = point;
+				}
+			}
+		}
+		if (minPoint) {
+			minPoint.distance = Math.sqrt(minDistance);
+		}
+		return minPoint;
+	},
+
+	getBounds: function () {
+		var b = new L.LatLngBounds();
+		var latLngs = this.getLatLngs();
+		for (var i = 0, len = latLngs.length; i < len; i++) {
+			b.extend(latLngs[i]);
+		}
+		return b;
+	},
+
+	_getPathPartStr: function (points) {
+		var round = L.Path.VML;
+
+		for (var j = 0, len2 = points.length, str = '', p; j < len2; j++) {
+			p = points[j];
+			if (round) {
+				p._round();
+			}
+			str += (j ? 'L' : 'M') + p.x + ' ' + p.y;
+		}
+		return str;
+	},
+
+	_clipPoints: function () {
+		var points = this._originalPoints,
+			len = points.length,
+			i, k, segment;
+
+		if (this.options.noClip) {
+			this._parts = [points];
+			return;
+		}
+
+		this._parts = [];
+
+		var parts = this._parts,
+			vp = this._map._pathViewport,
+			lu = L.LineUtil;
+
+		for (i = 0, k = 0; i < len - 1; i++) {
+			segment = lu.clipSegment(points[i], points[i + 1], vp, i);
+			if (!segment) {
+				continue;
+			}
+
+			parts[k] = parts[k] || [];
+			parts[k].push(segment[0]);
+
+			// if segment goes out of screen, or it's the last one, it's the end of the line part
+			if ((segment[1] !== points[i + 1]) || (i === len - 2)) {
+				parts[k].push(segment[1]);
+				k++;
+			}
+		}
+	},
+
+	// simplify each clipped part of the polyline
+	_simplifyPoints: function () {
+		var parts = this._parts,
+			lu = L.LineUtil;
+
+		for (var i = 0, len = parts.length; i < len; i++) {
+			parts[i] = lu.simplify(parts[i], this.options.smoothFactor);
+		}
+	},
+
+	_updatePath: function () {
+		this._clipPoints();
+		this._simplifyPoints();
+
+		L.Path.prototype._updatePath.call(this);
+	}
+});

data/lib/leaflet/src/layer/vector/canvas/Circle.Canvas.js

@@ -0,0 +1,18 @@
+/*
+ * Circle canvas specific drawing parts.
+ */
+
+L.Circle.include(!L.Path.CANVAS ? {} : {
+	_drawPath: function () {
+		var p = this._point;
+		this._ctx.beginPath();
+		this._ctx.arc(p.x, p.y, this._radius, 0, Math.PI * 2);
+	},
+
+	_containsPoint: function (p) {
+		var center = this._point,
+			w2 = this.options.stroke ? this.options.weight / 2 : 0;
+
+		return (p.distanceTo(center) <= this._radius + w2);
+	}
+});

data/lib/leaflet/src/layer/vector/canvas/Path.Canvas.js

@@ -0,0 +1,146 @@
+/*
+ * Vector rendering for all browsers that support canvas.
+ */
+
+L.Browser.canvas = (function () {
+	return !!document.createElement('canvas').getContext;
+}());
+
+L.Path = (L.Path.SVG && !window.L_PREFER_CANVAS) || !L.Browser.canvas ? L.Path : L.Path.extend({
+	statics: {
+		//CLIP_PADDING: 0.02, // not sure if there's a need to set it to a small value
+		CANVAS: true,
+		SVG: false
+	},
+
+	options: {
+		updateOnMoveEnd: true
+	},
+
+	_initElements: function () {
+		this._map._initPathRoot();
+		this._ctx = this._map._canvasCtx;
+	},
+
+	_updateStyle: function () {
+		if (this.options.stroke) {
+			this._ctx.lineWidth = this.options.weight;
+			this._ctx.strokeStyle = this.options.color;
+		}
+		if (this.options.fill) {
+			this._ctx.fillStyle = this.options.fillColor || this.options.color;
+		}
+	},
+
+	_drawPath: function () {
+		var i, j, len, len2, point, drawMethod;
+
+		this._ctx.beginPath();
+
+		for (i = 0, len = this._parts.length; i < len; i++) {
+			for (j = 0, len2 = this._parts[i].length; j < len2; j++) {
+				point = this._parts[i][j];
+				drawMethod = (j === 0 ? 'move' : 'line') + 'To';
+
+				this._ctx[drawMethod](point.x, point.y);
+			}
+			// TODO refactor ugly hack
+			if (this instanceof L.Polygon) {
+				this._ctx.closePath();
+			}
+		}
+	},
+
+	_checkIfEmpty: function () {
+		return !this._parts.length;
+	},
+
+	_updatePath: function () {
+		if (this._checkIfEmpty()) {
+			return;
+		}
+
+		this._drawPath();
+
+		this._ctx.save();
+
+		this._updateStyle();
+
+		var opacity = this.options.opacity,
+			fillOpacity = this.options.fillOpacity;
+
+		if (this.options.fill) {
+			if (fillOpacity < 1) {
+				this._ctx.globalAlpha = fillOpacity;
+			}
+			this._ctx.fill();
+		}
+
+		if (this.options.stroke) {
+			if (opacity < 1) {
+				this._ctx.globalAlpha = opacity;
+			}
+			this._ctx.stroke();
+		}
+
+		this._ctx.restore();
+
+		// TODO optimization: 1 fill/stroke for all features with equal style instead of 1 for each feature
+	},
+
+	_initEvents: function () {
+		if (this.options.clickable) {
+			// TODO hand cursor
+			// TODO mouseover, mouseout, dblclick
+			this._map.on('click', this._onClick, this);
+		}
+	},
+
+	_onClick: function (e) {
+		if (this._containsPoint(e.layerPoint)) {
+			this.fire('click', e);
+		}
+	},
+
+    onRemove: function (map) {
+        map.off('viewreset', this._projectLatlngs, this);
+        map.off(this._updateTrigger, this._updatePath, this);
+        map.fire(this._updateTrigger);
+    }
+});
+
+L.Map.include((L.Path.SVG && !window.L_PREFER_CANVAS) || !L.Browser.canvas ? {} : {
+	_initPathRoot: function () {
+		var root = this._pathRoot,
+			ctx;
+
+		if (!root) {
+			root = this._pathRoot = document.createElement("canvas");
+			root.style.position = 'absolute';
+			ctx = this._canvasCtx = root.getContext('2d');
+
+			ctx.lineCap = "round";
+			ctx.lineJoin = "round";
+
+			this._panes.overlayPane.appendChild(root);
+
+			this.on('moveend', this._updateCanvasViewport);
+			this._updateCanvasViewport();
+		}
+	},
+
+	_updateCanvasViewport: function () {
+		this._updatePathViewport();
+
+		var vp = this._pathViewport,
+			min = vp.min,
+			size = vp.max.subtract(min),
+			root = this._pathRoot;
+
+		//TODO check if it's works properly on mobile webkit
+		L.DomUtil.setPosition(root, min);
+		root.width = size.x;
+		root.height = size.y;
+		root.getContext('2d').translate(-min.x, -min.y);
+	}
+});

data/lib/leaflet/src/layer/vector/canvas/Polygon.Canvas.js

@@ -0,0 +1,34 @@
+
+L.Polygon.include(!L.Path.CANVAS ? {} : {
+	_containsPoint: function (p) {
+		var inside = false,
+			part, p1, p2,
+			i, j, k,
+			len, len2;
+
+		// TODO optimization: check if within bounds first
+
+		if (L.Polyline.prototype._containsPoint.call(this, p, true)) {
+			// click on polygon border
+			return true;
+		}
+
+		// ray casting algorithm for detecting if point is in polygon
+
+		for (i = 0, len = this._parts.length; i < len; i++) {
+			part = this._parts[i];
+
+			for (j = 0, len2 = part.length, k = len2 - 1; j < len2; k = j++) {
+				p1 = part[j];
+				p2 = part[k];
+
+				if (((p1.y > p.y) !== (p2.y > p.y)) &&
+						(p.x < (p2.x - p1.x) * (p.y - p1.y) / (p2.y - p1.y) + p1.x)) {
+					inside = !inside;
+				}
+			}
+		}
+
+		return inside;
+	}
+});

data/lib/leaflet/src/layer/vector/canvas/Polyline.Canvas.js

@@ -0,0 +1,27 @@
+
+L.Polyline.include(!L.Path.CANVAS ? {} : {
+	_containsPoint: function (p, closed) {
+		var i, j, k, len, len2, dist, part,
+			w = this.options.weight / 2;
+
+		if (L.Browser.touch) {
+			w += 10; // polyline click tolerance on touch devices
+		}
+
+		for (i = 0, len = this._parts.length; i < len; i++) {
+			part = this._parts[i];
+			for (j = 0, len2 = part.length, k = len2 - 1; j < len2; k = j++) {
+				if (!closed && (j === 0)) {
+					continue;
+				}
+
+				dist = L.LineUtil.pointToSegmentDistance(p, part[k], part[j]);
+
+				if (dist <= w) {
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+});

data/lib/leaflet/src/map/Map.js

@@ -0,0 +1,613 @@
+/*
+ * L.Map is the central class of the API - it is used to create a map.
+ */
+
+L.Map = L.Class.extend({
+	includes: L.Mixin.Events,
+
+	options: {
+		// projection
+		crs: L.CRS.EPSG3857 || L.CRS.EPSG4326,
+		scale: function (zoom) {
+			return 256 * Math.pow(2, zoom);
+		},
+
+		// state
+		center: null,
+		zoom: null,
+		layers: [],
+
+		// interaction
+		dragging: true,
+		touchZoom: L.Browser.touch && !L.Browser.android,
+		scrollWheelZoom: !L.Browser.touch,
+		doubleClickZoom: true,
+		boxZoom: true,
+
+		// controls
+		zoomControl: true,
+		attributionControl: true,
+
+		// animation
+		fadeAnimation: L.DomUtil.TRANSITION && !L.Browser.android,
+		zoomAnimation: L.DomUtil.TRANSITION && !L.Browser.android && !L.Browser.mobileOpera,
+
+		// misc
+		trackResize: true,
+		closePopupOnClick: true,
+		worldCopyJump: true
+	},
+
+
+	// constructor
+
+	initialize: function (id, options) { // (HTMLElement or String, Object)
+		L.Util.setOptions(this, options);
+
+		this._container = L.DomUtil.get(id);
+
+		if (this._container._leaflet) {
+			throw new Error("Map container is already initialized.");
+		}
+		this._container._leaflet = true;
+
+		this._initLayout();
+
+		if (L.DomEvent) {
+			this._initEvents();
+			if (L.Handler) {
+				this._initInteraction();
+			}
+			if (L.Control) {
+				this._initControls();
+			}
+		}
+
+		if (this.options.maxBounds) {
+			this.setMaxBounds(this.options.maxBounds);
+		}
+
+		var center = this.options.center,
+			zoom = this.options.zoom;
+
+		if (center !== null && zoom !== null) {
+			this.setView(center, zoom, true);
+		}
+
+		var layers = this.options.layers;
+		layers = (layers instanceof Array ? layers : [layers]);
+		this._tileLayersNum = 0;
+		this._initLayers(layers);
+	},
+
+
+	// public methods that modify map state
+
+	// replaced by animation-powered implementation in Map.PanAnimation.js
+	setView: function (center, zoom) {
+		// reset the map view
+		this._resetView(center, this._limitZoom(zoom));
+		return this;
+	},
+
+	setZoom: function (zoom) { // (Number)
+		return this.setView(this.getCenter(), zoom);
+	},
+
+	zoomIn: function () {
+		return this.setZoom(this._zoom + 1);
+	},
+
+	zoomOut: function () {
+		return this.setZoom(this._zoom - 1);
+	},
+
+	fitBounds: function (bounds) { // (LatLngBounds)
+		var zoom = this.getBoundsZoom(bounds);
+		return this.setView(bounds.getCenter(), zoom);
+	},
+
+	fitWorld: function () {
+		var sw = new L.LatLng(-60, -170),
+			ne = new L.LatLng(85, 179);
+		return this.fitBounds(new L.LatLngBounds(sw, ne));
+	},
+
+	panTo: function (center) { // (LatLng)
+		return this.setView(center, this._zoom);
+	},
+
+	panBy: function (offset) { // (Point)
+		// replaced with animated panBy in Map.Animation.js
+		this.fire('movestart');
+
+		this._rawPanBy(offset);
+
+		this.fire('move');
+		this.fire('moveend');
+
+		return this;
+	},
+
+	setMaxBounds: function (bounds) {
+		this.options.maxBounds = bounds;
+
+		if (!bounds) {
+			this._boundsMinZoom = null;
+			return this;
+		}
+
+		var minZoom = this.getBoundsZoom(bounds, true);
+
+		this._boundsMinZoom = minZoom;
+
+		if (this._loaded) {
+			if (this._zoom < minZoom) {
+				this.setView(bounds.getCenter(), minZoom);
+			} else {
+				this.panInsideBounds(bounds);
+			}
+		}
+		return this;
+	},
+
+	panInsideBounds: function (bounds) {
+		var viewBounds = this.getBounds(),
+			viewSw = this.project(viewBounds.getSouthWest()),
+			viewNe = this.project(viewBounds.getNorthEast()),
+			sw = this.project(bounds.getSouthWest()),
+			ne = this.project(bounds.getNorthEast()),
+			dx = 0,
+			dy = 0;
+
+		if (viewNe.y < ne.y) { // north
+			dy = ne.y - viewNe.y;
+		}
+		if (viewNe.x > ne.x) { // east
+			dx = ne.x - viewNe.x;
+		}
+		if (viewSw.y > sw.y) { // south
+			dy = sw.y - viewSw.y;
+		}
+		if (viewSw.x < sw.x) { // west
+			dx = sw.x - viewSw.x;
+		}
+
+		return this.panBy(new L.Point(dx, dy, true));
+	},
+
+	addLayer: function (layer, insertAtTheTop) {
+		var id = L.Util.stamp(layer);
+
+		if (this._layers[id]) {
+			return this;
+		}
+
+		this._layers[id] = layer;
+
+		if (layer.options && !isNaN(layer.options.maxZoom)) {
+			this._layersMaxZoom = Math.max(this._layersMaxZoom || 0, layer.options.maxZoom);
+		}
+		if (layer.options && !isNaN(layer.options.minZoom)) {
+			this._layersMinZoom = Math.min(this._layersMinZoom || Infinity, layer.options.minZoom);
+		}
+		//TODO getMaxZoom, getMinZoom in ILayer (instead of options)
+
+		if (this.options.zoomAnimation && L.TileLayer && (layer instanceof L.TileLayer)) {
+			this._tileLayersNum++;
+			layer.on('load', this._onTileLayerLoad, this);
+		}
+		if (this.attributionControl && layer.getAttribution) {
+			this.attributionControl.addAttribution(layer.getAttribution());
+		}
+
+		var onMapLoad = function () {
+			layer.onAdd(this, insertAtTheTop);
+			this.fire('layeradd', {layer: layer});
+		};
+
+		if (this._loaded) {
+			onMapLoad.call(this);
+		} else {
+			this.on('load', onMapLoad, this);
+		}
+
+		return this;
+	},
+
+	removeLayer: function (layer) {
+		var id = L.Util.stamp(layer);
+
+		if (this._layers[id]) {
+			layer.onRemove(this);
+			delete this._layers[id];
+
+			if (this.options.zoomAnimation && L.TileLayer && (layer instanceof L.TileLayer)) {
+				this._tileLayersNum--;
+				layer.off('load', this._onTileLayerLoad, this);
+			}
+			if (this.attributionControl && layer.getAttribution) {
+				this.attributionControl.removeAttribution(layer.getAttribution());
+			}
+
+			this.fire('layerremove', {layer: layer});
+		}
+		return this;
+	},
+
+	hasLayer: function (layer) {
+		var id = L.Util.stamp(layer);
+		return this._layers.hasOwnProperty(id);
+	},
+
+	invalidateSize: function () {
+		var oldSize = this.getSize();
+
+		this._sizeChanged = true;
+
+		if (this.options.maxBounds) {
+			this.setMaxBounds(this.options.maxBounds);
+		}
+
+		if (!this._loaded) {
+			return this;
+		}
+
+		this._rawPanBy(oldSize.subtract(this.getSize()).divideBy(2));
+
+		this.fire('move');
+
+		clearTimeout(this._sizeTimer);
+		this._sizeTimer = setTimeout(L.Util.bind(function () {
+			this.fire('moveend');
+		}, this), 200);
+
+		return this;
+	},
+
+
+	// public methods for getting map state
+
+	getCenter: function (unbounded) { // (Boolean)
+		var viewHalf = this.getSize().divideBy(2),
+			centerPoint = this._getTopLeftPoint().add(viewHalf);
+		return this.unproject(centerPoint, this._zoom, unbounded);
+	},
+
+	getZoom: function () {
+		return this._zoom;
+	},
+
+	getBounds: function () {
+		var bounds = this.getPixelBounds(),
+			sw = this.unproject(new L.Point(bounds.min.x, bounds.max.y), this._zoom, true),
+			ne = this.unproject(new L.Point(bounds.max.x, bounds.min.y), this._zoom, true);
+		return new L.LatLngBounds(sw, ne);
+	},
+
+	getMinZoom: function () {
+		var z1 = this.options.minZoom || 0,
+			z2 = this._layersMinZoom || 0,
+			z3 = this._boundsMinZoom || 0;
+
+		return Math.max(z1, z2, z3);
+	},
+
+	getMaxZoom: function () {
+		var z1 = isNaN(this.options.maxZoom) ? Infinity : this.options.maxZoom,
+			z2 = this._layersMaxZoom || Infinity;
+
+		return Math.min(z1, z2);
+	},
+
+	getBoundsZoom: function (bounds, inside) { // (LatLngBounds)
+		var size = this.getSize(),
+			zoom = this.options.minZoom || 0,
+			maxZoom = this.getMaxZoom(),
+			ne = bounds.getNorthEast(),
+			sw = bounds.getSouthWest(),
+			boundsSize,
+			nePoint,
+			swPoint,
+			zoomNotFound = true;
+
+		if (inside) {
+			zoom--;
+		}
+
+		do {
+			zoom++;
+			nePoint = this.project(ne, zoom);
+			swPoint = this.project(sw, zoom);
+			boundsSize = new L.Point(nePoint.x - swPoint.x, swPoint.y - nePoint.y);
+
+			if (!inside) {
+				zoomNotFound = (boundsSize.x <= size.x) && (boundsSize.y <= size.y);
+			} else {
+				zoomNotFound = (boundsSize.x < size.x) || (boundsSize.y < size.y);
+			}
+		} while (zoomNotFound && (zoom <= maxZoom));
+
+		if (zoomNotFound && inside) {
+			return null;
+		}
+
+		return inside ? zoom : zoom - 1;
+	},
+
+	getSize: function () {
+		if (!this._size || this._sizeChanged) {
+			this._size = new L.Point(this._container.clientWidth, this._container.clientHeight);
+			this._sizeChanged = false;
+		}
+		return this._size;
+	},
+
+	getPixelBounds: function () {
+		var topLeftPoint = this._getTopLeftPoint(),
+			size = this.getSize();
+		return new L.Bounds(topLeftPoint, topLeftPoint.add(size));
+	},
+
+	getPixelOrigin: function () {
+		return this._initialTopLeftPoint;
+	},
+
+	getPanes: function () {
+		return this._panes;
+	},
+
+
+	// conversion methods
+
+	mouseEventToContainerPoint: function (e) { // (MouseEvent)
+		return L.DomEvent.getMousePosition(e, this._container);
+	},
+
+	mouseEventToLayerPoint: function (e) { // (MouseEvent)
+		return this.containerPointToLayerPoint(this.mouseEventToContainerPoint(e));
+	},
+
+	mouseEventToLatLng: function (e) { // (MouseEvent)
+		return this.layerPointToLatLng(this.mouseEventToLayerPoint(e));
+	},
+
+	containerPointToLayerPoint: function (point) { // (Point)
+		return point.subtract(L.DomUtil.getPosition(this._mapPane));
+	},
+
+	layerPointToContainerPoint: function (point) { // (Point)
+		return point.add(L.DomUtil.getPosition(this._mapPane));
+	},
+
+	layerPointToLatLng: function (point) { // (Point)
+		return this.unproject(point.add(this._initialTopLeftPoint));
+	},
+
+	latLngToLayerPoint: function (latlng) { // (LatLng)
+		return this.project(latlng)._round()._subtract(this._initialTopLeftPoint);
+	},
+
+	project: function (latlng, zoom) { // (LatLng[, Number]) -> Point
+		zoom = (typeof zoom === 'undefined' ? this._zoom : zoom);
+		return this.options.crs.latLngToPoint(latlng, this.options.scale(zoom));
+	},
+
+	unproject: function (point, zoom, unbounded) { // (Point[, Number, Boolean]) -> LatLng
+		zoom = (typeof zoom === 'undefined' ? this._zoom : zoom);
+		return this.options.crs.pointToLatLng(point, this.options.scale(zoom), unbounded);
+	},
+
+
+	// private methods that modify map state
+
+	_initLayout: function () {
+		var container = this._container;
+
+		container.innerHTML = '';
+
+		container.className += ' leaflet-container';
+
+		if (this.options.fadeAnimation) {
+			container.className += ' leaflet-fade-anim';
+		}
+
+		var position = L.DomUtil.getStyle(container, 'position');
+		if (position !== 'absolute' && position !== 'relative') {
+			container.style.position = 'relative';
+		}
+
+		this._initPanes();
+
+		if (this._initControlPos) {
+			this._initControlPos();
+		}
+	},
+
+	_initPanes: function () {
+		var panes = this._panes = {};
+
+		this._mapPane = panes.mapPane = this._createPane('leaflet-map-pane', this._container);
+
+		this._tilePane = panes.tilePane = this._createPane('leaflet-tile-pane', this._mapPane);
+		this._objectsPane = panes.objectsPane = this._createPane('leaflet-objects-pane', this._mapPane);
+
+		panes.shadowPane = this._createPane('leaflet-shadow-pane');
+		panes.overlayPane = this._createPane('leaflet-overlay-pane');
+		panes.markerPane = this._createPane('leaflet-marker-pane');
+		panes.popupPane = this._createPane('leaflet-popup-pane');
+	},
+
+	_createPane: function (className, container) {
+		return L.DomUtil.create('div', className, container || this._objectsPane);
+	},
+
+	_resetView: function (center, zoom, preserveMapOffset, afterZoomAnim) {
+		var zoomChanged = (this._zoom !== zoom);
+
+		if (!afterZoomAnim) {
+			this.fire('movestart');
+
+			if (zoomChanged) {
+				this.fire('zoomstart');
+			}
+		}
+
+		this._zoom = zoom;
+
+		this._initialTopLeftPoint = this._getNewTopLeftPoint(center);
+
+		if (!preserveMapOffset) {
+			L.DomUtil.setPosition(this._mapPane, new L.Point(0, 0));
+		} else {
+			var offset = L.DomUtil.getPosition(this._mapPane);
+			this._initialTopLeftPoint._add(offset);
+		}
+
+		this._tileLayersToLoad = this._tileLayersNum;
+		this.fire('viewreset', {hard: !preserveMapOffset});
+
+		this.fire('move');
+		if (zoomChanged || afterZoomAnim) {
+			this.fire('zoomend');
+		}
+		this.fire('moveend');
+
+		if (!this._loaded) {
+			this._loaded = true;
+			this.fire('load');
+		}
+	},
+
+	_initLayers: function (layers) {
+		this._layers = {};
+
+		var i, len;
+
+		for (i = 0, len = layers.length; i < len; i++) {
+			this.addLayer(layers[i]);
+		}
+	},
+
+	_initControls: function () {
+		if (this.options.zoomControl) {
+			this.addControl(new L.Control.Zoom());
+		}
+		if (this.options.attributionControl) {
+			this.attributionControl = new L.Control.Attribution();
+			this.addControl(this.attributionControl);
+		}
+	},
+
+	_rawPanBy: function (offset) {
+		var mapPaneOffset = L.DomUtil.getPosition(this._mapPane);
+		L.DomUtil.setPosition(this._mapPane, mapPaneOffset.subtract(offset));
+	},
+
+
+	// map events
+
+	_initEvents: function () {
+		L.DomEvent.addListener(this._container, 'click', this._onMouseClick, this);
+
+		var events = ['dblclick', 'mousedown', 'mouseenter', 'mouseleave', 'mousemove', 'contextmenu'];
+
+		var i, len;
+
+		for (i = 0, len = events.length; i < len; i++) {
+			L.DomEvent.addListener(this._container, events[i], this._fireMouseEvent, this);
+		}
+
+		if (this.options.trackResize) {
+			L.DomEvent.addListener(window, 'resize', this._onResize, this);
+		}
+	},
+
+	_onResize: function () {
+		L.Util.requestAnimFrame(this.invalidateSize, this, false, this._container);
+	},
+
+	_onMouseClick: function (e) {
+		if (!this._loaded || (this.dragging && this.dragging.moved())) {
+			return;
+		}
+
+		this.fire('pre' + e.type);
+		this._fireMouseEvent(e);
+	},
+
+	_fireMouseEvent: function (e) {
+		if (!this._loaded) {
+			return;
+		}
+
+		var type = e.type;
+		type = (type === 'mouseenter' ? 'mouseover' : (type === 'mouseleave' ? 'mouseout' : type));
+
+		if (!this.hasEventListeners(type)) {
+			return;
+		}
+
+		if (type === 'contextmenu') {
+			L.DomEvent.preventDefault(e);
+		}
+		
+		this.fire(type, {
+			latlng: this.mouseEventToLatLng(e),
+			layerPoint: this.mouseEventToLayerPoint(e)
+		});
+	},
+
+	_initInteraction: function () {
+		var handlers = {
+			dragging: L.Map.Drag,
+			touchZoom: L.Map.TouchZoom,
+			doubleClickZoom: L.Map.DoubleClickZoom,
+			scrollWheelZoom: L.Map.ScrollWheelZoom,
+			boxZoom: L.Map.BoxZoom
+		};
+
+		var i;
+		for (i in handlers) {
+			if (handlers.hasOwnProperty(i) && handlers[i]) {
+				this[i] = new handlers[i](this);
+				if (this.options[i]) {
+					this[i].enable();
+				}
+				// TODO move enabling to handler contructor
+			}
+		}
+	},
+
+	_onTileLayerLoad: function () {
+		// clear scaled tiles after all new tiles are loaded (for performance)
+		this._tileLayersToLoad--;
+		if (this._tileLayersNum && !this._tileLayersToLoad && this._tileBg) {
+			clearTimeout(this._clearTileBgTimer);
+			this._clearTileBgTimer = setTimeout(L.Util.bind(this._clearTileBg, this), 500);
+		}
+	},
+
+
+	// private methods for getting map state
+
+	_getTopLeftPoint: function () {
+		if (!this._loaded) {
+			throw new Error('Set map center and zoom first.');
+		}
+
+		var offset = L.DomUtil.getPosition(this._mapPane);
+		return this._initialTopLeftPoint.subtract(offset);
+	},
+
+	_getNewTopLeftPoint: function (center) {
+		var viewHalf = this.getSize().divideBy(2);
+		return this.project(center).subtract(viewHalf).round();
+	},
+
+	_limitZoom: function (zoom) {
+		var min = this.getMinZoom();
+		var max = this.getMaxZoom();
+		return Math.max(min, Math.min(max, zoom));
+	}
+});