= BR.row || coord.column < TL.column || coord.column >= BR.column) {
+ return null;
+ }
+ return coord;
+ }; */
+
+ //document.getElementById('title').innerHTML = tilejson.name;
+ //document.getElementById('description').innerHTML = tilejson.description;
+ //document.getElementById('attribution').innerHTML = tilejson.attribution;
+
+
+ /* ----- scrolling function ---------
+
+ var ea = easey().map(m).easing('easeInOut');
+
+ scrolly = document.getElementById('teste');
+
+ function update() {
+ var pos = scrolly.scrollTop / 200;
+
+ ea.from(positions[Math.floor(pos)])
+ .to(positions[Math.ceil(pos)])
+ .t(pos - Math.floor(pos));
+ }
+
+ scrolly.addEventListener('scroll', update, false);
+ */
+
+});
\ No newline at end of file
diff --git a/js/site2.js b/js/site2.js
new file mode 100644
index 0000000..9d90762
--- /dev/null
+++ b/js/site2.js
@@ -0,0 +1,418 @@
+/* SITE SETUP */
+
+
+/*
+ MAP
+
+*/
+
+var m;
+var layer;
+var tilejson = {
+ tilejson: '1.0.0',
+ scheme: 'xyz',
+ tiles: [
+ 'http://maps.cardume.art.br/v2/eduamazonia/{z}/{x}/{y}.png'
+ ],
+ grids: [
+ 'http://maps.cardume.art.br/v2/eduamazonia/{z}/{x}/{y}.grid.json'
+ ],
+ formatter: function(options, data) {
+ return data
+ }
+}
+
+jQuery(document).ready(function() {
+ layer = new wax.mm.connector(tilejson);
+ m = new MM.Map('map', new wax.mm.connector(tilejson), null, [
+ easey.DragHandler(),
+ easey.TouchHandler(),
+ easey.MouseWheelHandler(),
+ easey.DoubleClickHandler()
+ ]);
+ m.setCenterZoom(new MM.Location(-48,-7),4);
+
+ wax.mm.zoomer(m).appendTo(m.parent);
+ wax.mm.interaction()
+ .map(m)
+ .tilejson(tilejson)
+ .on(wax.tooltip().animate(true).parent(m.parent).events());
+ //wax.mm.legend(m, tilejson).appendTo(m.parent);
+
+ var minZoom = 4;
+ var maxZoom = 8;
+ var topLeft = new MM.Location(9, -75);
+ var bottomRight = new MM.Location(-28, -4);
+
+ // -76.1133,-17.8115,-38.1445,6.3153
+
+ m.setZoomRange(minZoom,maxZoom);
+
+ m.coordLimits = [
+ m.locationCoordinate(topLeft).zoomTo(minZoom),
+ m.locationCoordinate(bottomRight).zoomTo(maxZoom)
+ ];
+
+ layer.tileLimits = [
+ m.locationCoordinate(topLeft).zoomTo(minZoom),
+ m.locationCoordinate(bottomRight).zoomTo(maxZoom)
+ ];
+
+});
+
+// filter map
+
+
+
+var filter_map;
+var tilejson_filters = {
+ tilejson: '1.0.0',
+ scheme: 'xyz',
+ tiles: [
+ 'http://maps.cardume.art.br/v2/eduamazonia_marcador/{z}/{x}/{y}.png'
+ ],
+ formatter: function(options, data) {
+ return data
+ }
+}
+var filter_map_ea;
+
+
+jQuery(document).ready(function() {
+ filter_map = new MM.Map('filter_map', new wax.mm.connector(tilejson_filters), null);
+ filter_map.setCenterZoom(new MM.Location(-56,-5),4);
+
+ wax.mm.zoomer(filter_map).appendTo(filter_map.parent);
+ wax.mm.interaction()
+ .map(filter_map)
+ .tilejson(tilejson);
+
+ filter_map_ea = easey().map(filter_map).easing('easeInOut');
+
+ var minZoom = 4;
+ var maxZoom = 8;
+ var topLeft = new MM.Location(7, -77);
+ var bottomRight = new MM.Location(-18, -43);
+
+ filter_map.setZoomRange(minZoom,maxZoom);
+
+ filter_map.coordLimits = [
+ filter_map.locationCoordinate(topLeft).zoomTo(minZoom),
+ filter_map.locationCoordinate(bottomRight).zoomTo(maxZoom)
+ ];
+
+ layer.tileLimits = [
+ filter_map.locationCoordinate(topLeft).zoomTo(minZoom),
+ filter_map.locationCoordinate(bottomRight).zoomTo(maxZoom)
+ ];
+
+});
+
+function markerFactory(feature) {
+ var d = document.createElement('div');
+ d.className = 'cidade-marker';
+ // $(d).data('cidade', feature.id);
+ $(d)
+ .attr('data-cidade', feature.id)
+ .data('lat', feature.properties.geo_latitude)
+ .data('lon', feature.properties.geo_longitude)
+ .append('' + feature.id + ' - ' + feature.properties.estado + ' ');
+ $('option[value="' + feature.id + '"]')
+ .data('lat', feature.properties.geo_latitude)
+ .data('lon', feature.properties.geo_longitude);
+ return d;
+}
+
+$('.cidade-marker').live('click', function() {
+ var lat = $(this).data('lat');
+ var lon = $(this).data('lon');
+ var markerId = $(this).data('cidade');
+ navigateFilter(lat, lon, markerId);
+
+ $('select.cidade option').attr('selected', false);
+ $('select.cidade option[value="' + markerId + '"]').attr('selected', true);
+ $('select.cidade').chosen().trigger('liszt:updated').change();
+
+});
+
+function navigateFilter(lat, lon, markerId) {
+ easey().map(filter_map)
+ .to(filter_map.locationCoordinate({lat: lat, lon: lon})
+ .zoomTo(8))
+ .run(2000);
+
+ $('.cidade-marker').removeClass('active');
+ if(markerId)
+ $('.cidade-marker[data-cidade="'+markerId+'"]').addClass('active');
+}
+
+
+/*
+
+ GRAPHS
+
+*/
+
+// load graph core
+google.load('visualization', '1', {packages: ['corechart']});
+
+// declare data vars
+var irregularidadesData;
+var tiposData;
+var programasData;
+var cidadesData;
+
+var selectedFilters = {};
+
+$(document).ready(function() {
+ // prepare general data
+ $.getJSON('constatacoes.json.php?data=geral', function(data) {
+ irregularidadesData = data;
+ });
+
+ // prepare tipos data
+ $.getJSON('constatacoes.json.php?data=tipo', function(data) {
+ tiposData = data;
+
+ // setup dropdown
+ $.each(tiposData, function(i, tipo) {
+ $('select.tipo').append('' + tipo.tipo + ' ');
+ });
+ jQuery('select.tipo').chosen().trigger('liszt:updated');
+ });
+
+ // prepare programas data
+ $.getJSON('constatacoes.json.php?data=programa', function(data) {
+ programasData = data;
+
+ // setup dropdown
+ $.each(programasData, function(i, programa) {
+ $('select.programa').append('' + programa.programa_desc + ' ');
+ });
+ jQuery('select.programa').chosen().trigger('liszt:updated');
+ });
+
+ // prepare cidades data
+ $.getJSON('constatacoes.json.php?data=cidade', function(data) {
+ cidadesData = data;
+
+ // setup dropdown
+ $.each(cidadesData, function(i, cidade) {
+ $('select.cidade').append('' + cidade.cidade + ' - ' + cidade.estado + ' ');
+ });
+ jQuery('select.cidade').chosen().trigger('liszt:updated');
+
+ // setup marker layer
+ var pointLayer = mmg().factory(markerFactory).url('cidades.geojson', function(feat, l) {
+ mmg_interaction(l);
+ });
+ filter_map.addLayer(pointLayer);
+ });
+
+ $('select').chosen({allow_single_deselect:true}).change(function() {
+
+ $('select.filter').each(function() {
+ var filterValue = $(this).find('option:selected').val();
+ var filterKey = $(this).data('type');
+ selectedFilters[filterKey] = filterValue;
+ });
+
+ // navigate map if city
+ if($(this).hasClass('cidade')) {
+ var markerId = $(this).find('option:selected').val();
+ var lat = $(this).find('option:selected').data('lat');
+ var lon = $(this).find('option:selected').data('lon');
+ navigateFilter(lat, lon, markerId);
+ }
+
+ theMagic(selectedFilters);
+
+ });
+
+});
+
+function theMagic(selectedFilters) {
+ var graphsContainer = $('#graphs');
+ graphsContainer.empty();
+ if(selectedFilters.cidade && !selectedFilters.tipo && !selectedFilters.programa) {
+ /*--CIDADE
+ gráfico coluna
+ - programa
+ - tipo
+ */
+ graphsContainer.append('
');
+ drawCidade(selectedFilters.cidade, 'graph01');
+ } else if(!selectedFilters.cidade && selectedFilters.tipo && !selectedFilters.programa) {
+ /*--TIPO
+ gráfico pizza
+ - programa
+ gráfico barra
+ - cidade
+ */
+ graphsContainer.append('
');
+ drawPieChart('Teste', selectedFilters, 'programa', 'graph01');
+ } else if(!selectedFilters.cidade && !selectedFilters.tipo && selectedFilters.programa) {
+ /*--PROGRAMA
+ gráfico pizza
+ - tipo
+ gráfico barra
+ - cidade
+ */
+ graphsContainer.append('
');
+ drawPieChart('Teste 2', selectedFilters, 'tipo', 'graph01');
+ } else if(selectedFilters.cidade && selectedFilters.tipo && !selectedFilters.programa) {
+ /*--CIDADE+TIPO
+ gráfico pizza
+ - programa
+ gráfico pizza (total)
+ - programa
+ */
+ graphsContainer.append('
');
+ drawPieChart('Teste 3', selectedFilters, 'programa', 'graph01');
+ } else if(!selectedFilters.cidade && selectedFilters.tipo && selectedFilters.programa) {
+ /*--TIPO+PROGRAMA
+ gráfico barra
+ - cidade
+ */
+ } else if(selectedFilters.cidade && !selectedFilters.tipo && selectedFilters.programa) {
+ /*--CIDADE+PROGRAMA
+ gráfico pizza
+ - tipo
+ gráfico pizza (total)
+ - tipo
+ */
+ graphsContainer.append('
');
+ drawPieChart('Filtro', selectedFilters, 'tipo', 'graph01');
+ selectedFilters.cidade = '';
+ drawPieChart('Total', selectedFilters, 'tipo', 'graph02');
+ } else if(selectedFilters.cidade && selectedFilters.tipo && selectedFilters.programa) {
+ /*--CIDADE+TIPO+PROGRAMA
+ só lista
+ */
+ }
+}
+
+function getIrregularidadesCount(filters) {
+ var data = jLinq.from(irregularidadesData);
+ jQuery.each(filters, function(key, value) {
+ data = data.starts(key, value);
+ });
+ return data.count();
+}
+
+function getConstatacoes(filters) {
+ var data = constatacoesData;
+ jQuery.each(filters, function(key, value) {
+ data = data.starts(key, value);
+ });
+ var count = data.count();
+ var results = data.select();
+
+ var output = {
+ filters: filters,
+ count: count,
+ results: results
+ };
+ return output;
+}
+
+function getCidadeGraphData(cidade) {
+ var data = [];
+ data[0] = [];
+
+ // setup header
+ data[0][0] = 'Programa';
+ jQuery.each(tiposData, function(index, tipoData) {
+ data[0][index+1] = tipoData.tipo;
+ });
+
+ // rows
+ jQuery.each(programasData, function(programaIndex, programaData) {
+ data[programaIndex+1] = [];
+ data[programaIndex+1][0] = programaData.programa_desc;
+ jQuery.each(tiposData, function(tipoIndex, tipoData) {
+ data[programaIndex+1][tipoIndex+1] = getIrregularidadesCount({
+ 'programa': programaData.programa,
+ 'tipo': tipoData.tipo,
+ 'cidade': cidade
+ });
+ });
+ });
+
+ return data;
+}
+
+function getGraphData(filters, output) {
+ var data = [];
+ data[0] = [];
+ if(output == 'tipo') {
+ data[0][0] = 'Tipo';
+ var outputData = tiposData;
+ } else if(output == 'programa') {
+ data[0][0] = 'Programa';
+ var outputData = programasData;
+ }
+ if(output == 'cidade') {
+ data[0][0] = 'Cidade';
+ var outputData = cidadesData;
+ }
+ data[0][1] = 'Irregularidades';
+ jQuery.each(outputData, function(i, outData) {
+ data[i+1] = [];
+ data[i+1][0] = outData[output];
+ filters[output] = outData[output];
+ data[i+1][1] = getIrregularidadesCount(filters);
+ });
+ return data;
+}
+
+function drawPieChart(title, filters, output, containerId) {
+ var wrapper = new google.visualization.ChartWrapper({
+ chartType: 'PieChart',
+ dataTable: getGraphData(filters, output),
+ options: {
+ title: title,
+ width: 473,
+ height: 400,
+ backgroundColor: 'transparent'
+ },
+ containerId: containerId
+ });
+ wrapper.draw();
+ return;
+}
+
+function drawCidade(cidade, containerId) {
+ var wrapper = new google.visualization.ChartWrapper({
+ chartType: 'ComboChart',
+ dataTable: getCidadeGraphData(cidade),
+ options: {
+ title:'Irregularidades na cidade',
+ width:473,
+ height:400,
+ backgroundColor: 'transparent',
+ vAxis: {title: 'Irregularidades'},
+ hAxis: {title: 'Programa'},
+ seriesType: 'bars'
+ },
+ containerId: containerId
+ });
+ wrapper.draw();
+ return;
+}
+
+function drawBarChart(title, filters, output) {
+ var wrapper = new google.visualization.ChartWrapper({
+ chartType: 'BarChart',
+ dataTable: getSimpleGraphData(filters, output),
+ options: {
+ title: title,
+ width: 600,
+ height: 1500,
+ backgroundColor: 'transparent',
+ colors: ['#f00']
+ },
+ containerId: 'visualization'
+ });
+ wrapper.draw();
+}
\ No newline at end of file
diff --git a/js/wax.mm.js b/js/wax.mm.js
new file mode 100644
index 0000000..a0085dc
--- /dev/null
+++ b/js/wax.mm.js
@@ -0,0 +1,4081 @@
+/* wax - 6.3.0 - v6.0.4-23-gdcc8490 */
+
+
+!function (name, context, definition) {
+ if (typeof module !== 'undefined') module.exports = definition(name, context);
+ else if (typeof define === 'function' && typeof define.amd === 'object') define(definition);
+ else context[name] = definition(name, context);
+}('bean', this, function (name, context) {
+ var win = window
+ , old = context[name]
+ , overOut = /over|out/
+ , namespaceRegex = /[^\.]*(?=\..*)\.|.*/
+ , nameRegex = /\..*/
+ , addEvent = 'addEventListener'
+ , attachEvent = 'attachEvent'
+ , removeEvent = 'removeEventListener'
+ , detachEvent = 'detachEvent'
+ , doc = document || {}
+ , root = doc.documentElement || {}
+ , W3C_MODEL = root[addEvent]
+ , eventSupport = W3C_MODEL ? addEvent : attachEvent
+ , slice = Array.prototype.slice
+ , mouseTypeRegex = /click|mouse(?!(.*wheel|scroll))|menu|drag|drop/i
+ , mouseWheelTypeRegex = /mouse.*(wheel|scroll)/i
+ , textTypeRegex = /^text/i
+ , touchTypeRegex = /^touch|^gesture/i
+ , ONE = { one: 1 } // singleton for quick matching making add() do one()
+
+ , nativeEvents = (function (hash, events, i) {
+ for (i = 0; i < events.length; i++)
+ hash[events[i]] = 1
+ return hash
+ })({}, (
+ 'click dblclick mouseup mousedown contextmenu ' + // mouse buttons
+ 'mousewheel mousemultiwheel DOMMouseScroll ' + // mouse wheel
+ 'mouseover mouseout mousemove selectstart selectend ' + // mouse movement
+ 'keydown keypress keyup ' + // keyboard
+ 'orientationchange ' + // mobile
+ 'focus blur change reset select submit ' + // form elements
+ 'load unload beforeunload resize move DOMContentLoaded readystatechange ' + // window
+ 'error abort scroll ' + // misc
+ (W3C_MODEL ? // element.fireEvent('onXYZ'... is not forgiving if we try to fire an event
+ // that doesn't actually exist, so make sure we only do these on newer browsers
+ 'show ' + // mouse buttons
+ 'input invalid ' + // form elements
+ 'touchstart touchmove touchend touchcancel ' + // touch
+ 'gesturestart gesturechange gestureend ' + // gesture
+ 'message readystatechange pageshow pagehide popstate ' + // window
+ 'hashchange offline online ' + // window
+ 'afterprint beforeprint ' + // printing
+ 'dragstart dragenter dragover dragleave drag drop dragend ' + // dnd
+ 'loadstart progress suspend emptied stalled loadmetadata ' + // media
+ 'loadeddata canplay canplaythrough playing waiting seeking ' + // media
+ 'seeked ended durationchange timeupdate play pause ratechange ' + // media
+ 'volumechange cuechange ' + // media
+ 'checking noupdate downloading cached updateready obsolete ' + // appcache
+ '' : '')
+ ).split(' ')
+ )
+
+ , customEvents = (function () {
+ function isDescendant(parent, node) {
+ while ((node = node.parentNode) !== null) {
+ if (node === parent) return true
+ }
+ return false
+ }
+
+ function check(event) {
+ var related = event.relatedTarget
+ if (!related) return related === null
+ return (related !== this && related.prefix !== 'xul' && !/document/.test(this.toString()) && !isDescendant(this, related))
+ }
+
+ return {
+ mouseenter: { base: 'mouseover', condition: check }
+ , mouseleave: { base: 'mouseout', condition: check }
+ , mousewheel: { base: /Firefox/.test(navigator.userAgent) ? 'DOMMouseScroll' : 'mousewheel' }
+ }
+ })()
+
+ , fixEvent = (function () {
+ var commonProps = 'altKey attrChange attrName bubbles cancelable ctrlKey currentTarget detail eventPhase getModifierState isTrusted metaKey relatedNode relatedTarget shiftKey srcElement target timeStamp type view which'.split(' ')
+ , mouseProps = commonProps.concat('button buttons clientX clientY dataTransfer fromElement offsetX offsetY pageX pageY screenX screenY toElement'.split(' '))
+ , mouseWheelProps = mouseProps.concat('wheelDelta wheelDeltaX wheelDeltaY wheelDeltaZ axis'.split(' ')) // 'axis' is FF specific
+ , keyProps = commonProps.concat('char charCode key keyCode keyIdentifier keyLocation'.split(' '))
+ , textProps = commonProps.concat(['data'])
+ , touchProps = commonProps.concat('touches targetTouches changedTouches scale rotation'.split(' '))
+ , preventDefault = 'preventDefault'
+ , createPreventDefault = function (event) {
+ return function () {
+ if (event[preventDefault])
+ event[preventDefault]()
+ else
+ event.returnValue = false
+ }
+ }
+ , stopPropagation = 'stopPropagation'
+ , createStopPropagation = function (event) {
+ return function () {
+ if (event[stopPropagation])
+ event[stopPropagation]()
+ else
+ event.cancelBubble = true
+ }
+ }
+ , createStop = function (synEvent) {
+ return function () {
+ synEvent[preventDefault]()
+ synEvent[stopPropagation]()
+ synEvent.stopped = true
+ }
+ }
+ , copyProps = function (event, result, props) {
+ var i, p
+ for (i = props.length; i--;) {
+ p = props[i]
+ if (!(p in result) && p in event) result[p] = event[p]
+ }
+ }
+
+ return function (event, isNative) {
+ var result = { originalEvent: event, isNative: isNative }
+ if (!event)
+ return result
+
+ var props
+ , type = event.type
+ , target = event.target || event.srcElement
+
+ result[preventDefault] = createPreventDefault(event)
+ result[stopPropagation] = createStopPropagation(event)
+ result.stop = createStop(result)
+ result.target = target && target.nodeType === 3 ? target.parentNode : target
+
+ if (isNative) { // we only need basic augmentation on custom events, the rest is too expensive
+ if (type.indexOf('key') !== -1) {
+ props = keyProps
+ result.keyCode = event.which || event.keyCode
+ } else if (mouseTypeRegex.test(type)) {
+ props = mouseProps
+ result.rightClick = event.which === 3 || event.button === 2
+ result.pos = { x: 0, y: 0 }
+ if (event.pageX || event.pageY) {
+ result.clientX = event.pageX
+ result.clientY = event.pageY
+ } else if (event.clientX || event.clientY) {
+ result.clientX = event.clientX + doc.body.scrollLeft + root.scrollLeft
+ result.clientY = event.clientY + doc.body.scrollTop + root.scrollTop
+ }
+ if (overOut.test(type))
+ result.relatedTarget = event.relatedTarget || event[(type === 'mouseover' ? 'from' : 'to') + 'Element']
+ } else if (touchTypeRegex.test(type)) {
+ props = touchProps
+ } else if (mouseWheelTypeRegex.test(type)) {
+ props = mouseWheelProps
+ } else if (textTypeRegex.test(type)) {
+ props = textProps
+ }
+ copyProps(event, result, props || commonProps)
+ }
+ return result
+ }
+ })()
+
+ // if we're in old IE we can't do onpropertychange on doc or win so we use doc.documentElement for both
+ , targetElement = function (element, isNative) {
+ return !W3C_MODEL && !isNative && (element === doc || element === win) ? root : element
+ }
+
+ // we use one of these per listener, of any type
+ , RegEntry = (function () {
+ function entry(element, type, handler, original, namespaces) {
+ this.element = element
+ this.type = type
+ this.handler = handler
+ this.original = original
+ this.namespaces = namespaces
+ this.custom = customEvents[type]
+ this.isNative = nativeEvents[type] && element[eventSupport]
+ this.eventType = W3C_MODEL || this.isNative ? type : 'propertychange'
+ this.customType = !W3C_MODEL && !this.isNative && type
+ this.target = targetElement(element, this.isNative)
+ this.eventSupport = this.target[eventSupport]
+ }
+
+ entry.prototype = {
+ // given a list of namespaces, is our entry in any of them?
+ inNamespaces: function (checkNamespaces) {
+ var i, j
+ if (!checkNamespaces)
+ return true
+ if (!this.namespaces)
+ return false
+ for (i = checkNamespaces.length; i--;) {
+ for (j = this.namespaces.length; j--;) {
+ if (checkNamespaces[i] === this.namespaces[j])
+ return true
+ }
+ }
+ return false
+ }
+
+ // match by element, original fn (opt), handler fn (opt)
+ , matches: function (checkElement, checkOriginal, checkHandler) {
+ return this.element === checkElement &&
+ (!checkOriginal || this.original === checkOriginal) &&
+ (!checkHandler || this.handler === checkHandler)
+ }
+ }
+
+ return entry
+ })()
+
+ , registry = (function () {
+ // our map stores arrays by event type, just because it's better than storing
+ // everything in a single array. uses '$' as a prefix for the keys for safety
+ var map = {}
+
+ // generic functional search of our registry for matching listeners,
+ // `fn` returns false to break out of the loop
+ , forAll = function (element, type, original, handler, fn) {
+ if (!type || type === '*') {
+ // search the whole registry
+ for (var t in map) {
+ if (t.charAt(0) === '$')
+ forAll(element, t.substr(1), original, handler, fn)
+ }
+ } else {
+ var i = 0, l, list = map['$' + type], all = element === '*'
+ if (!list)
+ return
+ for (l = list.length; i < l; i++) {
+ if (all || list[i].matches(element, original, handler))
+ if (!fn(list[i], list, i, type))
+ return
+ }
+ }
+ }
+
+ , has = function (element, type, original) {
+ // we're not using forAll here simply because it's a bit slower and this
+ // needs to be fast
+ var i, list = map['$' + type]
+ if (list) {
+ for (i = list.length; i--;) {
+ if (list[i].matches(element, original, null))
+ return true
+ }
+ }
+ return false
+ }
+
+ , get = function (element, type, original) {
+ var entries = []
+ forAll(element, type, original, null, function (entry) { return entries.push(entry) })
+ return entries
+ }
+
+ , put = function (entry) {
+ (map['$' + entry.type] || (map['$' + entry.type] = [])).push(entry)
+ return entry
+ }
+
+ , del = function (entry) {
+ forAll(entry.element, entry.type, null, entry.handler, function (entry, list, i) {
+ list.splice(i, 1)
+ if (list.length === 0)
+ delete map['$' + entry.type]
+ return false
+ })
+ }
+
+ // dump all entries, used for onunload
+ , entries = function () {
+ var t, entries = []
+ for (t in map) {
+ if (t.charAt(0) === '$')
+ entries = entries.concat(map[t])
+ }
+ return entries
+ }
+
+ return { has: has, get: get, put: put, del: del, entries: entries }
+ })()
+
+ // add and remove listeners to DOM elements
+ , listener = W3C_MODEL ? function (element, type, fn, add) {
+ element[add ? addEvent : removeEvent](type, fn, false)
+ } : function (element, type, fn, add, custom) {
+ if (custom && add && element['_on' + custom] === null)
+ element['_on' + custom] = 0
+ element[add ? attachEvent : detachEvent]('on' + type, fn)
+ }
+
+ , nativeHandler = function (element, fn, args) {
+ return function (event) {
+ event = fixEvent(event || ((this.ownerDocument || this.document || this).parentWindow || win).event, true)
+ return fn.apply(element, [event].concat(args))
+ }
+ }
+
+ , customHandler = function (element, fn, type, condition, args, isNative) {
+ return function (event) {
+ if (condition ? condition.apply(this, arguments) : W3C_MODEL ? true : event && event.propertyName === '_on' + type || !event) {
+ if (event)
+ event = fixEvent(event || ((this.ownerDocument || this.document || this).parentWindow || win).event, isNative)
+ fn.apply(element, event && (!args || args.length === 0) ? arguments : slice.call(arguments, event ? 0 : 1).concat(args))
+ }
+ }
+ }
+
+ , once = function (rm, element, type, fn, originalFn) {
+ // wrap the handler in a handler that does a remove as well
+ return function () {
+ rm(element, type, originalFn)
+ fn.apply(this, arguments)
+ }
+ }
+
+ , removeListener = function (element, orgType, handler, namespaces) {
+ var i, l, entry
+ , type = (orgType && orgType.replace(nameRegex, ''))
+ , handlers = registry.get(element, type, handler)
+
+ for (i = 0, l = handlers.length; i < l; i++) {
+ if (handlers[i].inNamespaces(namespaces)) {
+ if ((entry = handlers[i]).eventSupport)
+ listener(entry.target, entry.eventType, entry.handler, false, entry.type)
+ // TODO: this is problematic, we have a registry.get() and registry.del() that
+ // both do registry searches so we waste cycles doing this. Needs to be rolled into
+ // a single registry.forAll(fn) that removes while finding, but the catch is that
+ // we'll be splicing the arrays that we're iterating over. Needs extra tests to
+ // make sure we don't screw it up. @rvagg
+ registry.del(entry)
+ }
+ }
+ }
+
+ , addListener = function (element, orgType, fn, originalFn, args) {
+ var entry
+ , type = orgType.replace(nameRegex, '')
+ , namespaces = orgType.replace(namespaceRegex, '').split('.')
+
+ if (registry.has(element, type, fn))
+ return element // no dupe
+ if (type === 'unload')
+ fn = once(removeListener, element, type, fn, originalFn) // self clean-up
+ if (customEvents[type]) {
+ if (customEvents[type].condition)
+ fn = customHandler(element, fn, type, customEvents[type].condition, true)
+ type = customEvents[type].base || type
+ }
+ entry = registry.put(new RegEntry(element, type, fn, originalFn, namespaces[0] && namespaces))
+ entry.handler = entry.isNative ?
+ nativeHandler(element, entry.handler, args) :
+ customHandler(element, entry.handler, type, false, args, false)
+ if (entry.eventSupport)
+ listener(entry.target, entry.eventType, entry.handler, true, entry.customType)
+ }
+
+ , del = function (selector, fn, $) {
+ return function (e) {
+ var target, i, array = typeof selector === 'string' ? $(selector, this) : selector
+ for (target = e.target; target && target !== this; target = target.parentNode) {
+ for (i = array.length; i--;) {
+ if (array[i] === target) {
+ return fn.apply(target, arguments)
+ }
+ }
+ }
+ }
+ }
+
+ , remove = function (element, typeSpec, fn) {
+ var k, m, type, namespaces, i
+ , rm = removeListener
+ , isString = typeSpec && typeof typeSpec === 'string'
+
+ if (isString && typeSpec.indexOf(' ') > 0) {
+ // remove(el, 't1 t2 t3', fn) or remove(el, 't1 t2 t3')
+ typeSpec = typeSpec.split(' ')
+ for (i = typeSpec.length; i--;)
+ remove(element, typeSpec[i], fn)
+ return element
+ }
+ type = isString && typeSpec.replace(nameRegex, '')
+ if (type && customEvents[type])
+ type = customEvents[type].type
+ if (!typeSpec || isString) {
+ // remove(el) or remove(el, t1.ns) or remove(el, .ns) or remove(el, .ns1.ns2.ns3)
+ if (namespaces = isString && typeSpec.replace(namespaceRegex, ''))
+ namespaces = namespaces.split('.')
+ rm(element, type, fn, namespaces)
+ } else if (typeof typeSpec === 'function') {
+ // remove(el, fn)
+ rm(element, null, typeSpec)
+ } else {
+ // remove(el, { t1: fn1, t2, fn2 })
+ for (k in typeSpec) {
+ if (typeSpec.hasOwnProperty(k))
+ remove(element, k, typeSpec[k])
+ }
+ }
+ return element
+ }
+
+ , add = function (element, events, fn, delfn, $) {
+ var type, types, i, args
+ , originalFn = fn
+ , isDel = fn && typeof fn === 'string'
+
+ if (events && !fn && typeof events === 'object') {
+ for (type in events) {
+ if (events.hasOwnProperty(type))
+ add.apply(this, [ element, type, events[type] ])
+ }
+ } else {
+ args = arguments.length > 3 ? slice.call(arguments, 3) : []
+ types = (isDel ? fn : events).split(' ')
+ isDel && (fn = del(events, (originalFn = delfn), $)) && (args = slice.call(args, 1))
+ // special case for one()
+ this === ONE && (fn = once(remove, element, events, fn, originalFn))
+ for (i = types.length; i--;) addListener(element, types[i], fn, originalFn, args)
+ }
+ return element
+ }
+
+ , one = function () {
+ return add.apply(ONE, arguments)
+ }
+
+ , fireListener = W3C_MODEL ? function (isNative, type, element) {
+ var evt = doc.createEvent(isNative ? 'HTMLEvents' : 'UIEvents')
+ evt[isNative ? 'initEvent' : 'initUIEvent'](type, true, true, win, 1)
+ element.dispatchEvent(evt)
+ } : function (isNative, type, element) {
+ element = targetElement(element, isNative)
+ // if not-native then we're using onpropertychange so we just increment a custom property
+ isNative ? element.fireEvent('on' + type, doc.createEventObject()) : element['_on' + type]++
+ }
+
+ , fire = function (element, type, args) {
+ var i, j, l, names, handlers
+ , types = type.split(' ')
+
+ for (i = types.length; i--;) {
+ type = types[i].replace(nameRegex, '')
+ if (names = types[i].replace(namespaceRegex, ''))
+ names = names.split('.')
+ if (!names && !args && element[eventSupport]) {
+ fireListener(nativeEvents[type], type, element)
+ } else {
+ // non-native event, either because of a namespace, arguments or a non DOM element
+ // iterate over all listeners and manually 'fire'
+ handlers = registry.get(element, type)
+ args = [false].concat(args)
+ for (j = 0, l = handlers.length; j < l; j++) {
+ if (handlers[j].inNamespaces(names))
+ handlers[j].handler.apply(element, args)
+ }
+ }
+ }
+ return element
+ }
+
+ , clone = function (element, from, type) {
+ var i = 0
+ , handlers = registry.get(from, type)
+ , l = handlers.length
+
+ for (;i < l; i++)
+ handlers[i].original && add(element, handlers[i].type, handlers[i].original)
+ return element
+ }
+
+ , bean = {
+ add: add
+ , one: one
+ , remove: remove
+ , clone: clone
+ , fire: fire
+ , noConflict: function () {
+ context[name] = old
+ return this
+ }
+ }
+
+ if (win[attachEvent]) {
+ // for IE, clean up on unload to avoid leaks
+ var cleanup = function () {
+ var i, entries = registry.entries()
+ for (i in entries) {
+ if (entries[i].type && entries[i].type !== 'unload')
+ remove(entries[i].element, entries[i].type)
+ }
+ win[detachEvent]('onunload', cleanup)
+ win.CollectGarbage && win.CollectGarbage()
+ }
+ win[attachEvent]('onunload', cleanup)
+ }
+
+ return bean
+})
+// Copyright Google Inc.
+// Licensed under the Apache Licence Version 2.0
+// Autogenerated at Tue Oct 11 13:36:46 EDT 2011
+// @provides html4
+var html4 = {};
+html4.atype = {
+ NONE: 0,
+ URI: 1,
+ URI_FRAGMENT: 11,
+ SCRIPT: 2,
+ STYLE: 3,
+ ID: 4,
+ IDREF: 5,
+ IDREFS: 6,
+ GLOBAL_NAME: 7,
+ LOCAL_NAME: 8,
+ CLASSES: 9,
+ FRAME_TARGET: 10
+};
+html4.ATTRIBS = {
+ '*::class': 9,
+ '*::dir': 0,
+ '*::id': 4,
+ '*::lang': 0,
+ '*::onclick': 2,
+ '*::ondblclick': 2,
+ '*::onkeydown': 2,
+ '*::onkeypress': 2,
+ '*::onkeyup': 2,
+ '*::onload': 2,
+ '*::onmousedown': 2,
+ '*::onmousemove': 2,
+ '*::onmouseout': 2,
+ '*::onmouseover': 2,
+ '*::onmouseup': 2,
+ '*::style': 3,
+ '*::title': 0,
+ 'a::accesskey': 0,
+ 'a::coords': 0,
+ 'a::href': 1,
+ 'a::hreflang': 0,
+ 'a::name': 7,
+ 'a::onblur': 2,
+ 'a::onfocus': 2,
+ 'a::rel': 0,
+ 'a::rev': 0,
+ 'a::shape': 0,
+ 'a::tabindex': 0,
+ 'a::target': 10,
+ 'a::type': 0,
+ 'area::accesskey': 0,
+ 'area::alt': 0,
+ 'area::coords': 0,
+ 'area::href': 1,
+ 'area::nohref': 0,
+ 'area::onblur': 2,
+ 'area::onfocus': 2,
+ 'area::shape': 0,
+ 'area::tabindex': 0,
+ 'area::target': 10,
+ 'bdo::dir': 0,
+ 'blockquote::cite': 1,
+ 'br::clear': 0,
+ 'button::accesskey': 0,
+ 'button::disabled': 0,
+ 'button::name': 8,
+ 'button::onblur': 2,
+ 'button::onfocus': 2,
+ 'button::tabindex': 0,
+ 'button::type': 0,
+ 'button::value': 0,
+ 'canvas::height': 0,
+ 'canvas::width': 0,
+ 'caption::align': 0,
+ 'col::align': 0,
+ 'col::char': 0,
+ 'col::charoff': 0,
+ 'col::span': 0,
+ 'col::valign': 0,
+ 'col::width': 0,
+ 'colgroup::align': 0,
+ 'colgroup::char': 0,
+ 'colgroup::charoff': 0,
+ 'colgroup::span': 0,
+ 'colgroup::valign': 0,
+ 'colgroup::width': 0,
+ 'del::cite': 1,
+ 'del::datetime': 0,
+ 'dir::compact': 0,
+ 'div::align': 0,
+ 'dl::compact': 0,
+ 'font::color': 0,
+ 'font::face': 0,
+ 'font::size': 0,
+ 'form::accept': 0,
+ 'form::action': 1,
+ 'form::autocomplete': 0,
+ 'form::enctype': 0,
+ 'form::method': 0,
+ 'form::name': 7,
+ 'form::onreset': 2,
+ 'form::onsubmit': 2,
+ 'form::target': 10,
+ 'h1::align': 0,
+ 'h2::align': 0,
+ 'h3::align': 0,
+ 'h4::align': 0,
+ 'h5::align': 0,
+ 'h6::align': 0,
+ 'hr::align': 0,
+ 'hr::noshade': 0,
+ 'hr::size': 0,
+ 'hr::width': 0,
+ 'iframe::align': 0,
+ 'iframe::frameborder': 0,
+ 'iframe::height': 0,
+ 'iframe::marginheight': 0,
+ 'iframe::marginwidth': 0,
+ 'iframe::width': 0,
+ 'img::align': 0,
+ 'img::alt': 0,
+ 'img::border': 0,
+ 'img::height': 0,
+ 'img::hspace': 0,
+ 'img::ismap': 0,
+ 'img::name': 7,
+ 'img::src': 1,
+ 'img::usemap': 11,
+ 'img::vspace': 0,
+ 'img::width': 0,
+ 'input::accept': 0,
+ 'input::accesskey': 0,
+ 'input::align': 0,
+ 'input::alt': 0,
+ 'input::autocomplete': 0,
+ 'input::checked': 0,
+ 'input::disabled': 0,
+ 'input::ismap': 0,
+ 'input::maxlength': 0,
+ 'input::name': 8,
+ 'input::onblur': 2,
+ 'input::onchange': 2,
+ 'input::onfocus': 2,
+ 'input::onselect': 2,
+ 'input::readonly': 0,
+ 'input::size': 0,
+ 'input::src': 1,
+ 'input::tabindex': 0,
+ 'input::type': 0,
+ 'input::usemap': 11,
+ 'input::value': 0,
+ 'ins::cite': 1,
+ 'ins::datetime': 0,
+ 'label::accesskey': 0,
+ 'label::for': 5,
+ 'label::onblur': 2,
+ 'label::onfocus': 2,
+ 'legend::accesskey': 0,
+ 'legend::align': 0,
+ 'li::type': 0,
+ 'li::value': 0,
+ 'map::name': 7,
+ 'menu::compact': 0,
+ 'ol::compact': 0,
+ 'ol::start': 0,
+ 'ol::type': 0,
+ 'optgroup::disabled': 0,
+ 'optgroup::label': 0,
+ 'option::disabled': 0,
+ 'option::label': 0,
+ 'option::selected': 0,
+ 'option::value': 0,
+ 'p::align': 0,
+ 'pre::width': 0,
+ 'q::cite': 1,
+ 'select::disabled': 0,
+ 'select::multiple': 0,
+ 'select::name': 8,
+ 'select::onblur': 2,
+ 'select::onchange': 2,
+ 'select::onfocus': 2,
+ 'select::size': 0,
+ 'select::tabindex': 0,
+ 'table::align': 0,
+ 'table::bgcolor': 0,
+ 'table::border': 0,
+ 'table::cellpadding': 0,
+ 'table::cellspacing': 0,
+ 'table::frame': 0,
+ 'table::rules': 0,
+ 'table::summary': 0,
+ 'table::width': 0,
+ 'tbody::align': 0,
+ 'tbody::char': 0,
+ 'tbody::charoff': 0,
+ 'tbody::valign': 0,
+ 'td::abbr': 0,
+ 'td::align': 0,
+ 'td::axis': 0,
+ 'td::bgcolor': 0,
+ 'td::char': 0,
+ 'td::charoff': 0,
+ 'td::colspan': 0,
+ 'td::headers': 6,
+ 'td::height': 0,
+ 'td::nowrap': 0,
+ 'td::rowspan': 0,
+ 'td::scope': 0,
+ 'td::valign': 0,
+ 'td::width': 0,
+ 'textarea::accesskey': 0,
+ 'textarea::cols': 0,
+ 'textarea::disabled': 0,
+ 'textarea::name': 8,
+ 'textarea::onblur': 2,
+ 'textarea::onchange': 2,
+ 'textarea::onfocus': 2,
+ 'textarea::onselect': 2,
+ 'textarea::readonly': 0,
+ 'textarea::rows': 0,
+ 'textarea::tabindex': 0,
+ 'tfoot::align': 0,
+ 'tfoot::char': 0,
+ 'tfoot::charoff': 0,
+ 'tfoot::valign': 0,
+ 'th::abbr': 0,
+ 'th::align': 0,
+ 'th::axis': 0,
+ 'th::bgcolor': 0,
+ 'th::char': 0,
+ 'th::charoff': 0,
+ 'th::colspan': 0,
+ 'th::headers': 6,
+ 'th::height': 0,
+ 'th::nowrap': 0,
+ 'th::rowspan': 0,
+ 'th::scope': 0,
+ 'th::valign': 0,
+ 'th::width': 0,
+ 'thead::align': 0,
+ 'thead::char': 0,
+ 'thead::charoff': 0,
+ 'thead::valign': 0,
+ 'tr::align': 0,
+ 'tr::bgcolor': 0,
+ 'tr::char': 0,
+ 'tr::charoff': 0,
+ 'tr::valign': 0,
+ 'ul::compact': 0,
+ 'ul::type': 0
+};
+html4.eflags = {
+ OPTIONAL_ENDTAG: 1,
+ EMPTY: 2,
+ CDATA: 4,
+ RCDATA: 8,
+ UNSAFE: 16,
+ FOLDABLE: 32,
+ SCRIPT: 64,
+ STYLE: 128
+};
+html4.ELEMENTS = {
+ 'a': 0,
+ 'abbr': 0,
+ 'acronym': 0,
+ 'address': 0,
+ 'applet': 16,
+ 'area': 2,
+ 'b': 0,
+ 'base': 18,
+ 'basefont': 18,
+ 'bdo': 0,
+ 'big': 0,
+ 'blockquote': 0,
+ 'body': 49,
+ 'br': 2,
+ 'button': 0,
+ 'canvas': 0,
+ 'caption': 0,
+ 'center': 0,
+ 'cite': 0,
+ 'code': 0,
+ 'col': 2,
+ 'colgroup': 1,
+ 'dd': 1,
+ 'del': 0,
+ 'dfn': 0,
+ 'dir': 0,
+ 'div': 0,
+ 'dl': 0,
+ 'dt': 1,
+ 'em': 0,
+ 'fieldset': 0,
+ 'font': 0,
+ 'form': 0,
+ 'frame': 18,
+ 'frameset': 16,
+ 'h1': 0,
+ 'h2': 0,
+ 'h3': 0,
+ 'h4': 0,
+ 'h5': 0,
+ 'h6': 0,
+ 'head': 49,
+ 'hr': 2,
+ 'html': 49,
+ 'i': 0,
+ 'iframe': 4,
+ 'img': 2,
+ 'input': 2,
+ 'ins': 0,
+ 'isindex': 18,
+ 'kbd': 0,
+ 'label': 0,
+ 'legend': 0,
+ 'li': 1,
+ 'link': 18,
+ 'map': 0,
+ 'menu': 0,
+ 'meta': 18,
+ 'nobr': 0,
+ 'noembed': 4,
+ 'noframes': 20,
+ 'noscript': 20,
+ 'object': 16,
+ 'ol': 0,
+ 'optgroup': 0,
+ 'option': 1,
+ 'p': 1,
+ 'param': 18,
+ 'pre': 0,
+ 'q': 0,
+ 's': 0,
+ 'samp': 0,
+ 'script': 84,
+ 'select': 0,
+ 'small': 0,
+ 'span': 0,
+ 'strike': 0,
+ 'strong': 0,
+ 'style': 148,
+ 'sub': 0,
+ 'sup': 0,
+ 'table': 0,
+ 'tbody': 1,
+ 'td': 1,
+ 'textarea': 8,
+ 'tfoot': 1,
+ 'th': 1,
+ 'thead': 1,
+ 'title': 24,
+ 'tr': 1,
+ 'tt': 0,
+ 'u': 0,
+ 'ul': 0,
+ 'var': 0
+};
+html4.ueffects = {
+ NOT_LOADED: 0,
+ SAME_DOCUMENT: 1,
+ NEW_DOCUMENT: 2
+};
+html4.URIEFFECTS = {
+ 'a::href': 2,
+ 'area::href': 2,
+ 'blockquote::cite': 0,
+ 'body::background': 1,
+ 'del::cite': 0,
+ 'form::action': 2,
+ 'img::src': 1,
+ 'input::src': 1,
+ 'ins::cite': 0,
+ 'q::cite': 0
+};
+html4.ltypes = {
+ UNSANDBOXED: 2,
+ SANDBOXED: 1,
+ DATA: 0
+};
+html4.LOADERTYPES = {
+ 'a::href': 2,
+ 'area::href': 2,
+ 'blockquote::cite': 2,
+ 'body::background': 1,
+ 'del::cite': 2,
+ 'form::action': 2,
+ 'img::src': 1,
+ 'input::src': 1,
+ 'ins::cite': 2,
+ 'q::cite': 2
+};;
+// Copyright (C) 2006 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/**
+ * @fileoverview
+ * An HTML sanitizer that can satisfy a variety of security policies.
+ *
+ *
+ * The HTML sanitizer is built around a SAX parser and HTML element and
+ * attributes schemas.
+ *
+ * @author mikesamuel@gmail.com
+ * @requires html4
+ * @overrides window
+ * @provides html, html_sanitize
+ */
+
+/**
+ * @namespace
+ */
+var html = (function (html4) {
+ var lcase;
+ // The below may not be true on browsers in the Turkish locale.
+ if ('script' === 'SCRIPT'.toLowerCase()) {
+ lcase = function (s) { return s.toLowerCase(); };
+ } else {
+ /**
+ * {@updoc
+ * $ lcase('SCRIPT')
+ * # 'script'
+ * $ lcase('script')
+ * # 'script'
+ * }
+ */
+ lcase = function (s) {
+ return s.replace(
+ /[A-Z]/g,
+ function (ch) {
+ return String.fromCharCode(ch.charCodeAt(0) | 32);
+ });
+ };
+ }
+
+ var ENTITIES = {
+ lt : '<',
+ gt : '>',
+ amp : '&',
+ nbsp : '\240',
+ quot : '"',
+ apos : '\''
+ };
+
+ // Schemes on which to defer to uripolicy. Urls with other schemes are denied
+ var WHITELISTED_SCHEMES = /^(?:https?|mailto|data)$/i;
+
+ var decimalEscapeRe = /^#(\d+)$/;
+ var hexEscapeRe = /^#x([0-9A-Fa-f]+)$/;
+ /**
+ * Decodes an HTML entity.
+ *
+ * {@updoc
+ * $ lookupEntity('lt')
+ * # '<'
+ * $ lookupEntity('GT')
+ * # '>'
+ * $ lookupEntity('amp')
+ * # '&'
+ * $ lookupEntity('nbsp')
+ * # '\xA0'
+ * $ lookupEntity('apos')
+ * # "'"
+ * $ lookupEntity('quot')
+ * # '"'
+ * $ lookupEntity('#xa')
+ * # '\n'
+ * $ lookupEntity('#10')
+ * # '\n'
+ * $ lookupEntity('#x0a')
+ * # '\n'
+ * $ lookupEntity('#010')
+ * # '\n'
+ * $ lookupEntity('#x00A')
+ * # '\n'
+ * $ lookupEntity('Pi') // Known failure
+ * # '\u03A0'
+ * $ lookupEntity('pi') // Known failure
+ * # '\u03C0'
+ * }
+ *
+ * @param name the content between the '&' and the ';'.
+ * @return a single unicode code-point as a string.
+ */
+ function lookupEntity(name) {
+ name = lcase(name); // TODO: π is different from Π
+ if (ENTITIES.hasOwnProperty(name)) { return ENTITIES[name]; }
+ var m = name.match(decimalEscapeRe);
+ if (m) {
+ return String.fromCharCode(parseInt(m[1], 10));
+ } else if (!!(m = name.match(hexEscapeRe))) {
+ return String.fromCharCode(parseInt(m[1], 16));
+ }
+ return '';
+ }
+
+ function decodeOneEntity(_, name) {
+ return lookupEntity(name);
+ }
+
+ var nulRe = /\0/g;
+ function stripNULs(s) {
+ return s.replace(nulRe, '');
+ }
+
+ var entityRe = /&(#\d+|#x[0-9A-Fa-f]+|\w+);/g;
+ /**
+ * The plain text of a chunk of HTML CDATA which possibly containing.
+ *
+ * {@updoc
+ * $ unescapeEntities('')
+ * # ''
+ * $ unescapeEntities('hello World!')
+ * # 'hello World!'
+ * $ unescapeEntities('1 < 2 && 4 > 3
')
+ * # '1 < 2 && 4 > 3\n'
+ * $ unescapeEntities('<< <- unfinished entity>')
+ * # '<< <- unfinished entity>'
+ * $ unescapeEntities('/foo?bar=baz©=true') // & often unescaped in URLS
+ * # '/foo?bar=baz©=true'
+ * $ unescapeEntities('pi=ππ, Pi=Π\u03A0') // FIXME: known failure
+ * # 'pi=\u03C0\u03c0, Pi=\u03A0\u03A0'
+ * }
+ *
+ * @param s a chunk of HTML CDATA. It must not start or end inside an HTML
+ * entity.
+ */
+ function unescapeEntities(s) {
+ return s.replace(entityRe, decodeOneEntity);
+ }
+
+ var ampRe = /&/g;
+ var looseAmpRe = /&([^a-z#]|#(?:[^0-9x]|x(?:[^0-9a-f]|$)|$)|$)/gi;
+ var ltRe = //g;
+ var quotRe = /\"/g;
+ var eqRe = /\=/g; // Backslash required on JScript.net
+
+ /**
+ * Escapes HTML special characters in attribute values as HTML entities.
+ *
+ * {@updoc
+ * $ escapeAttrib('')
+ * # ''
+ * $ escapeAttrib('"<<&==&>>"') // Do not just escape the first occurrence.
+ * # '"<<&==&>>"'
+ * $ escapeAttrib('Hello !')
+ * # 'Hello <World>!'
+ * }
+ */
+ function escapeAttrib(s) {
+ // Escaping '=' defangs many UTF-7 and SGML short-tag attacks.
+ return s.replace(ampRe, '&').replace(ltRe, '<').replace(gtRe, '>')
+ .replace(quotRe, '"').replace(eqRe, '=');
+ }
+
+ /**
+ * Escape entities in RCDATA that can be escaped without changing the meaning.
+ * {@updoc
+ * $ normalizeRCData('1 < 2 && 3 > 4 && 5 < 7&8')
+ * # '1 < 2 && 3 > 4 && 5 < 7&8'
+ * }
+ */
+ function normalizeRCData(rcdata) {
+ return rcdata
+ .replace(looseAmpRe, '&$1')
+ .replace(ltRe, '<')
+ .replace(gtRe, '>');
+ }
+
+
+ // TODO(mikesamuel): validate sanitizer regexs against the HTML5 grammar at
+ // http://www.whatwg.org/specs/web-apps/current-work/multipage/syntax.html
+ // http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html
+ // http://www.whatwg.org/specs/web-apps/current-work/multipage/tokenization.html
+ // http://www.whatwg.org/specs/web-apps/current-work/multipage/tree-construction.html
+
+ /** token definitions. */
+ var INSIDE_TAG_TOKEN = new RegExp(
+ // Don't capture space.
+ '^\\s*(?:'
+ // Capture an attribute name in group 1, and value in group 3.
+ // We capture the fact that there was an attribute in group 2, since
+ // interpreters are inconsistent in whether a group that matches nothing
+ // is null, undefined, or the empty string.
+ + ('(?:'
+ + '([a-z][a-z-]*)' // attribute name
+ + ('(' // optionally followed
+ + '\\s*=\\s*'
+ + ('('
+ // A double quoted string.
+ + '\"[^\"]*\"'
+ // A single quoted string.
+ + '|\'[^\']*\''
+ // The positive lookahead is used to make sure that in
+ // , the value for bar is blank, not "baz=boo".
+ + '|(?=[a-z][a-z-]*\\s*=)'
+ // An unquoted value that is not an attribute name.
+ // We know it is not an attribute name because the previous
+ // zero-width match would've eliminated that possibility.
+ + '|[^>\"\'\\s]*'
+ + ')'
+ )
+ + ')'
+ ) + '?'
+ + ')'
+ )
+ // End of tag captured in group 3.
+ + '|(\/?>)'
+ // Don't capture cruft
+ + '|[\\s\\S][^a-z\\s>]*)',
+ 'i');
+
+ var OUTSIDE_TAG_TOKEN = new RegExp(
+ '^(?:'
+ // Entity captured in group 1.
+ + '&(\\#[0-9]+|\\#[x][0-9a-f]+|\\w+);'
+ // Comment, doctypes, and processing instructions not captured.
+ + '|<\!--[\\s\\S]*?--\>|]*>|<\\?[^>*]*>'
+ // '/' captured in group 2 for close tags, and name captured in group 3.
+ + '|<(\/)?([a-z][a-z0-9]*)'
+ // Text captured in group 4.
+ + '|([^<&>]+)'
+ // Cruft captured in group 5.
+ + '|([<&>]))',
+ 'i');
+
+ /**
+ * Given a SAX-like event handler, produce a function that feeds those
+ * events and a parameter to the event handler.
+ *
+ * The event handler has the form:{@code
+ * {
+ * // Name is an upper-case HTML tag name. Attribs is an array of
+ * // alternating upper-case attribute names, and attribute values. The
+ * // attribs array is reused by the parser. Param is the value passed to
+ * // the saxParser.
+ * startTag: function (name, attribs, param) { ... },
+ * endTag: function (name, param) { ... },
+ * pcdata: function (text, param) { ... },
+ * rcdata: function (text, param) { ... },
+ * cdata: function (text, param) { ... },
+ * startDoc: function (param) { ... },
+ * endDoc: function (param) { ... }
+ * }}
+ *
+ * @param {Object} handler a record containing event handlers.
+ * @return {Function} that takes a chunk of html and a parameter.
+ * The parameter is passed on to the handler methods.
+ */
+ function makeSaxParser(handler) {
+ return function parse(htmlText, param) {
+ htmlText = String(htmlText);
+ var htmlLower = null;
+
+ var inTag = false; // True iff we're currently processing a tag.
+ var attribs = []; // Accumulates attribute names and values.
+ var tagName = void 0; // The name of the tag currently being processed.
+ var eflags = void 0; // The element flags for the current tag.
+ var openTag = void 0; // True if the current tag is an open tag.
+
+ if (handler.startDoc) { handler.startDoc(param); }
+
+ while (htmlText) {
+ var m = htmlText.match(inTag ? INSIDE_TAG_TOKEN : OUTSIDE_TAG_TOKEN);
+ htmlText = htmlText.substring(m[0].length);
+
+ if (inTag) {
+ if (m[1]) { // attribute
+ // setAttribute with uppercase names doesn't work on IE6.
+ var attribName = lcase(m[1]);
+ var decodedValue;
+ if (m[2]) {
+ var encodedValue = m[3];
+ switch (encodedValue.charCodeAt(0)) { // Strip quotes
+ case 34: case 39:
+ encodedValue = encodedValue.substring(
+ 1, encodedValue.length - 1);
+ break;
+ }
+ decodedValue = unescapeEntities(stripNULs(encodedValue));
+ } else {
+ // Use name as value for valueless attribs, so
+ // ";
+
+ var lines = template.split("\n"),
+ start = Math.max(line - 3, 0),
+ end = Math.min(lines.length, line + 3),
+ context = lines.slice(start, end);
+
+ var c;
+ for (var i = 0, len = context.length; i < len; ++i) {
+ c = i + start + 1;
+ context[i] = (c === line ? " >> " : " ") + context[i];
+ }
+
+ e.template = template;
+ e.line = line;
+ e.file = file;
+ e.message = [file + ":" + line, context.join("\n"), "", e.message].join("\n");
+
+ return e;
+ }
+
+ /**
+ * Looks up the value of the given `name` in the given context `stack`.
+ */
+ function lookup(name, stack, defaultValue) {
+ if (name === ".") {
+ return stack[stack.length - 1];
+ }
+
+ var names = name.split(".");
+ var lastIndex = names.length - 1;
+ var target = names[lastIndex];
+
+ var value, context, i = stack.length, j, localStack;
+ while (i) {
+ localStack = stack.slice(0);
+ context = stack[--i];
+
+ j = 0;
+ while (j < lastIndex) {
+ context = context[names[j++]];
+
+ if (context == null) {
+ break;
+ }
+
+ localStack.push(context);
+ }
+
+ if (context && typeof context === "object" && target in context) {
+ value = context[target];
+ break;
+ }
+ }
+
+ // If the value is a function, call it in the current context.
+ if (typeof value === "function") {
+ value = value.call(localStack[localStack.length - 1]);
+ }
+
+ if (value == null) {
+ return defaultValue;
+ }
+
+ return value;
+ }
+
+ function renderSection(name, stack, callback, inverted) {
+ var buffer = "";
+ var value = lookup(name, stack);
+
+ if (inverted) {
+ // From the spec: inverted sections may render text once based on the
+ // inverse value of the key. That is, they will be rendered if the key
+ // doesn't exist, is false, or is an empty list.
+ if (value == null || value === false || (isArray(value) && value.length === 0)) {
+ buffer += callback();
+ }
+ } else if (isArray(value)) {
+ forEach(value, function (value) {
+ stack.push(value);
+ buffer += callback();
+ stack.pop();
+ });
+ } else if (typeof value === "object") {
+ stack.push(value);
+ buffer += callback();
+ stack.pop();
+ } else if (typeof value === "function") {
+ var scope = stack[stack.length - 1];
+ var scopedRender = function (template) {
+ return render(template, scope);
+ };
+ buffer += value.call(scope, callback(), scopedRender) || "";
+ } else if (value) {
+ buffer += callback();
+ }
+
+ return buffer;
+ }
+
+ /**
+ * Parses the given `template` and returns the source of a function that,
+ * with the proper arguments, will render the template. Recognized options
+ * include the following:
+ *
+ * - file The name of the file the template comes from (displayed in
+ * error messages)
+ * - tags An array of open and close tags the `template` uses. Defaults
+ * to the value of Mustache.tags
+ * - debug Set `true` to log the body of the generated function to the
+ * console
+ * - space Set `true` to preserve whitespace from lines that otherwise
+ * contain only a {{tag}}. Defaults to `false`
+ */
+ function parse(template, options) {
+ options = options || {};
+
+ var tags = options.tags || exports.tags,
+ openTag = tags[0],
+ closeTag = tags[tags.length - 1];
+
+ var code = [
+ 'var buffer = "";', // output buffer
+ "\nvar line = 1;", // keep track of source line number
+ "\ntry {",
+ '\nbuffer += "'
+ ];
+
+ var spaces = [], // indices of whitespace in code on the current line
+ hasTag = false, // is there a {{tag}} on the current line?
+ nonSpace = false; // is there a non-space char on the current line?
+
+ // Strips all space characters from the code array for the current line
+ // if there was a {{tag}} on it and otherwise only spaces.
+ var stripSpace = function () {
+ if (hasTag && !nonSpace && !options.space) {
+ while (spaces.length) {
+ code.splice(spaces.pop(), 1);
+ }
+ } else {
+ spaces = [];
+ }
+
+ hasTag = false;
+ nonSpace = false;
+ };
+
+ var sectionStack = [], updateLine, nextOpenTag, nextCloseTag;
+
+ var setTags = function (source) {
+ tags = trim(source).split(/\s+/);
+ nextOpenTag = tags[0];
+ nextCloseTag = tags[tags.length - 1];
+ };
+
+ var includePartial = function (source) {
+ code.push(
+ '";',
+ updateLine,
+ '\nvar partial = partials["' + trim(source) + '"];',
+ '\nif (partial) {',
+ '\n buffer += render(partial,stack[stack.length - 1],partials);',
+ '\n}',
+ '\nbuffer += "'
+ );
+ };
+
+ var openSection = function (source, inverted) {
+ var name = trim(source);
+
+ if (name === "") {
+ throw debug(new Error("Section name may not be empty"), template, line, options.file);
+ }
+
+ sectionStack.push({name: name, inverted: inverted});
+
+ code.push(
+ '";',
+ updateLine,
+ '\nvar name = "' + name + '";',
+ '\nvar callback = (function () {',
+ '\n return function () {',
+ '\n var buffer = "";',
+ '\nbuffer += "'
+ );
+ };
+
+ var openInvertedSection = function (source) {
+ openSection(source, true);
+ };
+
+ var closeSection = function (source) {
+ var name = trim(source);
+ var openName = sectionStack.length != 0 && sectionStack[sectionStack.length - 1].name;
+
+ if (!openName || name != openName) {
+ throw debug(new Error('Section named "' + name + '" was never opened'), template, line, options.file);
+ }
+
+ var section = sectionStack.pop();
+
+ code.push(
+ '";',
+ '\n return buffer;',
+ '\n };',
+ '\n})();'
+ );
+
+ if (section.inverted) {
+ code.push("\nbuffer += renderSection(name,stack,callback,true);");
+ } else {
+ code.push("\nbuffer += renderSection(name,stack,callback);");
+ }
+
+ code.push('\nbuffer += "');
+ };
+
+ var sendPlain = function (source) {
+ code.push(
+ '";',
+ updateLine,
+ '\nbuffer += lookup("' + trim(source) + '",stack,"");',
+ '\nbuffer += "'
+ );
+ };
+
+ var sendEscaped = function (source) {
+ code.push(
+ '";',
+ updateLine,
+ '\nbuffer += escapeHTML(lookup("' + trim(source) + '",stack,""));',
+ '\nbuffer += "'
+ );
+ };
+
+ var line = 1, c, callback;
+ for (var i = 0, len = template.length; i < len; ++i) {
+ if (template.slice(i, i + openTag.length) === openTag) {
+ i += openTag.length;
+ c = template.substr(i, 1);
+ updateLine = '\nline = ' + line + ';';
+ nextOpenTag = openTag;
+ nextCloseTag = closeTag;
+ hasTag = true;
+
+ switch (c) {
+ case "!": // comment
+ i++;
+ callback = null;
+ break;
+ case "=": // change open/close tags, e.g. {{=<% %>=}}
+ i++;
+ closeTag = "=" + closeTag;
+ callback = setTags;
+ break;
+ case ">": // include partial
+ i++;
+ callback = includePartial;
+ break;
+ case "#": // start section
+ i++;
+ callback = openSection;
+ break;
+ case "^": // start inverted section
+ i++;
+ callback = openInvertedSection;
+ break;
+ case "/": // end section
+ i++;
+ callback = closeSection;
+ break;
+ case "{": // plain variable
+ closeTag = "}" + closeTag;
+ // fall through
+ case "&": // plain variable
+ i++;
+ nonSpace = true;
+ callback = sendPlain;
+ break;
+ default: // escaped variable
+ nonSpace = true;
+ callback = sendEscaped;
+ }
+
+ var end = template.indexOf(closeTag, i);
+
+ if (end === -1) {
+ throw debug(new Error('Tag "' + openTag + '" was not closed properly'), template, line, options.file);
+ }
+
+ var source = template.substring(i, end);
+
+ if (callback) {
+ callback(source);
+ }
+
+ // Maintain line count for \n in source.
+ var n = 0;
+ while (~(n = source.indexOf("\n", n))) {
+ line++;
+ n++;
+ }
+
+ i = end + closeTag.length - 1;
+ openTag = nextOpenTag;
+ closeTag = nextCloseTag;
+ } else {
+ c = template.substr(i, 1);
+
+ switch (c) {
+ case '"':
+ case "\\":
+ nonSpace = true;
+ code.push("\\" + c);
+ break;
+ case "\r":
+ // Ignore carriage returns.
+ break;
+ case "\n":
+ spaces.push(code.length);
+ code.push("\\n");
+ stripSpace(); // Check for whitespace on the current line.
+ line++;
+ break;
+ default:
+ if (isWhitespace(c)) {
+ spaces.push(code.length);
+ } else {
+ nonSpace = true;
+ }
+
+ code.push(c);
+ }
+ }
+ }
+
+ if (sectionStack.length != 0) {
+ throw debug(new Error('Section "' + sectionStack[sectionStack.length - 1].name + '" was not closed properly'), template, line, options.file);
+ }
+
+ // Clean up any whitespace from a closing {{tag}} that was at the end
+ // of the template without a trailing \n.
+ stripSpace();
+
+ code.push(
+ '";',
+ "\nreturn buffer;",
+ "\n} catch (e) { throw {error: e, line: line}; }"
+ );
+
+ // Ignore `buffer += "";` statements.
+ var body = code.join("").replace(/buffer \+= "";\n/g, "");
+
+ if (options.debug) {
+ if (typeof console != "undefined" && console.log) {
+ console.log(body);
+ } else if (typeof print === "function") {
+ print(body);
+ }
+ }
+
+ return body;
+ }
+
+ /**
+ * Used by `compile` to generate a reusable function for the given `template`.
+ */
+ function _compile(template, options) {
+ var args = "view,partials,stack,lookup,escapeHTML,renderSection,render";
+ var body = parse(template, options);
+ var fn = new Function(args, body);
+
+ // This anonymous function wraps the generated function so we can do
+ // argument coercion, setup some variables, and handle any errors
+ // encountered while executing it.
+ return function (view, partials) {
+ partials = partials || {};
+
+ var stack = [view]; // context stack
+
+ try {
+ return fn(view, partials, stack, lookup, escapeHTML, renderSection, render);
+ } catch (e) {
+ throw debug(e.error, template, e.line, options.file);
+ }
+ };
+ }
+
+ // Cache of pre-compiled templates.
+ var _cache = {};
+
+ /**
+ * Clear the cache of compiled templates.
+ */
+ function clearCache() {
+ _cache = {};
+ }
+
+ /**
+ * Compiles the given `template` into a reusable function using the given
+ * `options`. In addition to the options accepted by Mustache.parse,
+ * recognized options include the following:
+ *
+ * - cache Set `false` to bypass any pre-compiled version of the given
+ * template. Otherwise, a given `template` string will be cached
+ * the first time it is parsed
+ */
+ function compile(template, options) {
+ options = options || {};
+
+ // Use a pre-compiled version from the cache if we have one.
+ if (options.cache !== false) {
+ if (!_cache[template]) {
+ _cache[template] = _compile(template, options);
+ }
+
+ return _cache[template];
+ }
+
+ return _compile(template, options);
+ }
+
+ /**
+ * High-level function that renders the given `template` using the given
+ * `view` and `partials`. If you need to use any of the template options (see
+ * `compile` above), you must compile in a separate step, and then call that
+ * compiled function.
+ */
+ function render(template, view, partials) {
+ return compile(template)(view, partials);
+ }
+
+})(Mustache);
+/*!
+ * Reqwest! A general purpose XHR connection manager
+ * (c) Dustin Diaz 2011
+ * https://github.com/ded/reqwest
+ * license MIT
+ */
+!function(a,b){typeof module!="undefined"?module.exports=b():typeof define=="function"&&define.amd?define(a,b):this[a]=b()}("reqwest",function(){function handleReadyState(a,b,c){return function(){a&&a[readyState]==4&&(twoHundo.test(a.status)?b(a):c(a))}}function setHeaders(a,b){var c=b.headers||{},d;c.Accept=c.Accept||defaultHeaders.accept[b.type]||defaultHeaders.accept["*"],!b.crossOrigin&&!c[requestedWith]&&(c[requestedWith]=defaultHeaders.requestedWith),c[contentType]||(c[contentType]=b.contentType||defaultHeaders.contentType);for(d in c)c.hasOwnProperty(d)&&a.setRequestHeader(d,c[d])}function generalCallback(a){lastValue=a}function urlappend(a,b){return a+(/\?/.test(a)?"&":"?")+b}function handleJsonp(a,b,c,d){var e=uniqid++,f=a.jsonpCallback||"callback",g=a.jsonpCallbackName||"reqwest_"+e,h=new RegExp("((^|\\?|&)"+f+")=([^&]+)"),i=d.match(h),j=doc.createElement("script"),k=0;i?i[3]==="?"?d=d.replace(h,"$1="+g):g=i[3]:d=urlappend(d,f+"="+g),win[g]=generalCallback,j.type="text/javascript",j.src=d,j.async=!0,typeof j.onreadystatechange!="undefined"&&(j.event="onclick",j.htmlFor=j.id="_reqwest_"+e),j.onload=j.onreadystatechange=function(){if(j[readyState]&&j[readyState]!=="complete"&&j[readyState]!=="loaded"||k)return!1;j.onload=j.onreadystatechange=null,j.onclick&&j.onclick(),a.success&&a.success(lastValue),lastValue=undefined,head.removeChild(j),k=1},head.appendChild(j)}function getRequest(a,b,c){var d=(a.method||"GET").toUpperCase(),e=typeof a=="string"?a:a.url,f=a.processData!==!1&&a.data&&typeof a.data!="string"?reqwest.toQueryString(a.data):a.data||null,g;return(a.type=="jsonp"||d=="GET")&&f&&(e=urlappend(e,f),f=null),a.type=="jsonp"?handleJsonp(a,b,c,e):(g=xhr(),g.open(d,e,!0),setHeaders(g,a),g.onreadystatechange=handleReadyState(g,b,c),a.before&&a.before(g),g.send(f),g)}function Reqwest(a,b){this.o=a,this.fn=b,init.apply(this,arguments)}function setType(a){var b=a.match(/\.(json|jsonp|html|xml)(\?|$)/);return b?b[1]:"js"}function init(o,fn){function complete(a){o.timeout&&clearTimeout(self.timeout),self.timeout=null,o.complete&&o.complete(a)}function success(resp){var r=resp.responseText;if(r)switch(type){case"json":try{resp=win.JSON?win.JSON.parse(r):eval("("+r+")")}catch(err){return error(resp,"Could not parse JSON in response",err)}break;case"js":resp=eval(r);break;case"html":resp=r}fn(resp),o.success&&o.success(resp),complete(resp)}function error(a,b,c){o.error&&o.error(a,b,c),complete(a)}this.url=typeof o=="string"?o:o.url,this.timeout=null;var type=o.type||setType(this.url),self=this;fn=fn||function(){},o.timeout&&(this.timeout=setTimeout(function(){self.abort()},o.timeout)),this.request=getRequest(o,success,error)}function reqwest(a,b){return new Reqwest(a,b)}function normalize(a){return a?a.replace(/\r?\n/g,"\r\n"):""}function serial(a,b){var c=a.name,d=a.tagName.toLowerCase(),e=function(a){a&&!a.disabled&&b(c,normalize(a.attributes.value&&a.attributes.value.specified?a.value:a.text))};if(a.disabled||!c)return;switch(d){case"input":if(!/reset|button|image|file/i.test(a.type)){var f=/checkbox/i.test(a.type),g=/radio/i.test(a.type),h=a.value;(!f&&!g||a.checked)&&b(c,normalize(f&&h===""?"on":h))}break;case"textarea":b(c,normalize(a.value));break;case"select":if(a.type.toLowerCase()==="select-one")e(a.selectedIndex>=0?a.options[a.selectedIndex]:null);else for(var i=0;a.length&&i= 93) key--;
+ if (key >= 35) key--;
+ key -= 32;
+ return key;
+ }
+
+ instance.grid_tile = function() {
+ return grid_tile;
+ };
+
+ instance.getKey = function(x, y) {
+ if (!(grid_tile && grid_tile.grid)) return;
+ if ((y < 0) || (x < 0)) return;
+ if ((Math.floor(y) >= tileSize) ||
+ (Math.floor(x) >= tileSize)) return;
+ // Find the key in the grid. The above calls should ensure that
+ // the grid's array is large enough to make this work.
+ return resolveCode(grid_tile.grid[
+ Math.floor((y) / resolution)
+ ].charCodeAt(
+ Math.floor((x) / resolution)
+ ));
+ };
+
+ // Lower-level than tileFeature - has nothing to do
+ // with the DOM. Takes a px offset from 0, 0 of a grid.
+ instance.gridFeature = function(x, y) {
+ // Find the key in the grid. The above calls should ensure that
+ // the grid's array is large enough to make this work.
+ var key = this.getKey(x, y),
+ keys = grid_tile.keys;
+
+ if (keys &&
+ keys[key] &&
+ grid_tile.data[keys[key]]) {
+ return grid_tile.data[keys[key]];
+ }
+ };
+
+ // Get a feature:
+ // * `x` and `y`: the screen coordinates of an event
+ // * `tile_element`: a DOM element of a tile, from which we can get an offset.
+ instance.tileFeature = function(x, y, tile_element) {
+ if (!grid_tile) return;
+ // IE problem here - though recoverable, for whatever reason
+ var offset = wax.u.offset(tile_element);
+ feature = this.gridFeature(x - offset.left, y - offset.top);
+ return feature;
+ };
+
+ return instance;
+};
+// GridManager
+// -----------
+// Generally one GridManager will be used per map.
+//
+// It takes one options object, which current accepts a single option:
+// `resolution` determines the number of pixels per grid element in the grid.
+// The default is 4.
+wax.gm = function() {
+
+ var resolution = 4,
+ grid_tiles = {},
+ manager = {},
+ tilejson,
+ formatter;
+
+ var gridUrl = function(url) {
+ return url.replace(/(\.png|\.jpg|\.jpeg)(\d*)/, '.grid.json');
+ };
+
+ function templatedGridUrl(template) {
+ if (typeof template === 'string') template = [template];
+ return function templatedGridFinder(url) {
+ if (!url) return;
+ var rx = new RegExp('/(\\d+)\\/(\\d+)\\/(\\d+)\\.[\\w\\._]+');
+ var xyz = rx.exec(url);
+ if (!xyz) return;
+ return template[parseInt(xyz[2], 10) % template.length]
+ .replace(/\{z\}/g, xyz[1])
+ .replace(/\{x\}/g, xyz[2])
+ .replace(/\{y\}/g, xyz[3]);
+ };
+ }
+
+ manager.formatter = function(x) {
+ if (!arguments.length) return formatter;
+ formatter = wax.formatter(x);
+ return manager;
+ };
+
+ manager.template = function(x) {
+ if (!arguments.length) return formatter;
+ formatter = wax.template(x);
+ return manager;
+ };
+
+ manager.gridUrl = function(x) {
+ if (!arguments.length) return gridUrl;
+ gridUrl = typeof x === 'function' ?
+ x : templatedGridUrl(x);
+ return manager;
+ };
+
+ manager.getGrid = function(url, callback) {
+ var gurl = gridUrl(url);
+ if (!formatter || !gurl) return callback(null, null);
+
+ wax.request.get(gurl, function(err, t) {
+ if (err) return callback(err, null);
+ callback(null, wax.gi(t, {
+ formatter: formatter,
+ resolution: resolution
+ }));
+ });
+ return manager;
+ };
+
+ manager.tilejson = function(x) {
+ if (!arguments.length) return tilejson;
+ // prefer templates over formatters
+ if (x.template) {
+ manager.template(x.template);
+ } else if (x.formatter) {
+ manager.formatter(x.formatter);
+ } else {
+ formatter = undefined;
+ }
+ if (x.grids) manager.gridUrl(x.grids);
+ if (x.resolution) resolution = x.resolution;
+ tilejson = x;
+ return manager;
+ };
+
+ return manager;
+};
+wax = wax || {};
+
+// Hash
+// ----
+wax.hash = function(options) {
+ options = options || {};
+
+ function getState() {
+ return location.hash.substring(1);
+ }
+
+ function pushState(state) {
+ var l = window.location;
+ l.replace(l.toString().replace((l.hash || /$/), '#' + state));
+ }
+
+ var s0, // old hash
+ hash = {},
+ lat = 90 - 1e-8; // allowable latitude range
+
+ function parseHash(s) {
+ var args = s.split('/');
+ for (var i = 0; i < args.length; i++) {
+ args[i] = Number(args[i]);
+ if (isNaN(args[i])) return true;
+ }
+ if (args.length < 3) {
+ // replace bogus hash
+ return true;
+ } else if (args.length == 3) {
+ options.setCenterZoom(args);
+ }
+ }
+
+ function move() {
+ var s1 = options.getCenterZoom();
+ if (s0 !== s1) {
+ s0 = s1;
+ // don't recenter the map!
+ pushState(s0);
+ }
+ }
+
+ function stateChange(state) {
+ // ignore spurious hashchange events
+ if (state === s0) return;
+ if (parseHash(s0 = state)) {
+ // replace bogus hash
+ move();
+ }
+ }
+
+ var _move = wax.u.throttle(move, 500);
+
+ hash.add = function() {
+ stateChange(getState());
+ options.bindChange(_move);
+ return this;
+ };
+
+ hash.remove = function() {
+ options.unbindChange(_move);
+ return this;
+ };
+
+ return hash.add();
+};
+wax = wax || {};
+
+wax.interaction = function() {
+ var gm = wax.gm(),
+ interaction = {},
+ _downLock = false,
+ _clickTimeout = false,
+ // Active feature
+ // Down event
+ _d,
+ // Touch tolerance
+ tol = 4,
+ grid,
+ attach,
+ detach,
+ parent,
+ map,
+ tileGrid;
+
+ var defaultEvents = {
+ mousemove: onMove,
+ touchstart: onDown,
+ mousedown: onDown
+ };
+
+ var touchEnds = {
+ touchend: onUp,
+ touchmove: onUp,
+ touchcancel: touchCancel
+ };
+
+ // Abstract getTile method. Depends on a tilegrid with
+ // grid[ [x, y, tile] ] structure.
+ function getTile(e) {
+ var g = grid();
+ for (var i = 0; i < g.length; i++) {
+ if ((g[i][0] < e.y) &&
+ ((g[i][0] + 256) > e.y) &&
+ (g[i][1] < e.x) &&
+ ((g[i][1] + 256) > e.x)) return g[i][2];
+ }
+ return false;
+ }
+
+ // Clear the double-click timeout to prevent double-clicks from
+ // triggering popups.
+ function killTimeout() {
+ if (_clickTimeout) {
+ window.clearTimeout(_clickTimeout);
+ _clickTimeout = null;
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ function onMove(e) {
+ // If the user is actually dragging the map, exit early
+ // to avoid performance hits.
+ if (_downLock) return;
+
+ var pos = wax.u.eventoffset(e);
+
+ interaction.screen_feature(pos, function(feature) {
+ if (feature) {
+ bean.fire(interaction, 'on', {
+ parent: parent(),
+ data: feature,
+ formatter: gm.formatter().format,
+ e: e
+ });
+ } else {
+ bean.fire(interaction, 'off');
+ }
+ });
+ }
+
+ // A handler for 'down' events - which means `mousedown` and `touchstart`
+ function onDown(e) {
+ // Ignore double-clicks by ignoring clicks within 300ms of
+ // each other.
+ if (killTimeout()) { return; }
+
+ // Prevent interaction offset calculations happening while
+ // the user is dragging the map.
+ //
+ // Store this event so that we can compare it to the
+ // up event
+ _downLock = true;
+ _d = wax.u.eventoffset(e);
+ if (e.type === 'mousedown') {
+ bean.add(document.body, 'click', onUp);
+
+ // Only track single-touches. Double-touches will not affect this
+ // control
+ } else if (e.type === 'touchstart' && e.touches.length === 1) {
+ // Don't make the user click close if they hit another tooltip
+ bean.fire(interaction, 'off');
+ // Touch moves invalidate touches
+ bean.add(parent(), touchEnds);
+ }
+ }
+
+ function touchCancel() {
+ bean.remove(parent(), touchEnds);
+ _downLock = false;
+ }
+
+ function onUp(e) {
+ var evt = {},
+ pos = wax.u.eventoffset(e);
+ _downLock = false;
+
+ // TODO: refine
+ for (var key in e) {
+ evt[key] = e[key];
+ }
+
+ bean.remove(document.body, 'mouseup', onUp);
+ bean.remove(parent(), touchEnds);
+
+ if (e.type === 'touchend') {
+ // If this was a touch and it survived, there's no need to avoid a double-tap
+ // but also wax.u.eventoffset will have failed, since this touch
+ // event doesn't have coordinates
+ interaction.click(e, _d);
+ } else if (Math.round(pos.y / tol) === Math.round(_d.y / tol) &&
+ Math.round(pos.x / tol) === Math.round(_d.x / tol)) {
+ // Contain the event data in a closure.
+ _clickTimeout = window.setTimeout(
+ function() {
+ _clickTimeout = null;
+ interaction.click(evt, pos);
+ }, 300);
+ }
+ return onUp;
+ }
+
+ // Handle a click event. Takes a second
+ interaction.click = function(e, pos) {
+ interaction.screen_feature(pos, function(feature) {
+ if (feature) bean.fire(interaction, 'on', {
+ parent: parent(),
+ data: feature,
+ formatter: gm.formatter().format,
+ e: e
+ });
+ });
+ };
+
+ interaction.screen_feature = function(pos, callback) {
+ var tile = getTile(pos);
+ if (!tile) callback(null);
+ gm.getGrid(tile.src, function(err, g) {
+ if (err || !g) return callback(null);
+ var feature = g.tileFeature(pos.x, pos.y, tile);
+ callback(feature);
+ });
+ };
+
+ // set an attach function that should be
+ // called when maps are set
+ interaction.attach = function(x) {
+ if (!arguments.length) return attach;
+ attach = x;
+ return interaction;
+ };
+
+ interaction.detach = function(x) {
+ if (!arguments.length) return detach;
+ detach = x;
+ return interaction;
+ };
+
+ // Attach listeners to the map
+ interaction.map = function(x) {
+ if (!arguments.length) return map;
+ map = x;
+ if (attach) attach(map);
+ bean.add(parent(), defaultEvents);
+ bean.add(parent(), 'touchstart', onDown);
+ return interaction;
+ };
+
+ // set a grid getter for this control
+ interaction.grid = function(x) {
+ if (!arguments.length) return grid;
+ grid = x;
+ return interaction;
+ };
+
+ // detach this and its events from the map cleanly
+ interaction.remove = function(x) {
+ if (detach) detach(map);
+ bean.remove(parent(), defaultEvents);
+ bean.fire(interaction, 'remove');
+ return interaction;
+ };
+
+ // get or set a tilejson chunk of json
+ interaction.tilejson = function(x) {
+ if (!arguments.length) return gm.tilejson();
+ gm.tilejson(x);
+ return interaction;
+ };
+
+ // return the formatter, which has an exposed .format
+ // function
+ interaction.formatter = function() {
+ return gm.formatter();
+ };
+
+ // ev can be 'on', 'off', fn is the handler
+ interaction.on = function(ev, fn) {
+ bean.add(interaction, ev, fn);
+ return interaction;
+ };
+
+ // ev can be 'on', 'off', fn is the handler
+ interaction.off = function(ev, fn) {
+ bean.remove(interaction, ev, fn);
+ return interaction;
+ };
+
+ // Return or set the gridmanager implementation
+ interaction.gridmanager = function(x) {
+ if (!arguments.length) return gm;
+ gm = x;
+ return interaction;
+ };
+
+ // parent should be a function that returns
+ // the parent element of the map
+ interaction.parent = function(x) {
+ parent = x;
+ return interaction;
+ };
+
+ return interaction;
+};
+// Wax Legend
+// ----------
+
+// Wax header
+var wax = wax || {};
+
+wax.legend = function() {
+ var element,
+ legend = {},
+ container;
+
+ function urlX(url) {
+ // Data URIs are subject to a bug in Firefox
+ // https://bugzilla.mozilla.org/show_bug.cgi?id=255107
+ // which let them be a vector. But WebKit does 'the right thing'
+ // or at least 'something' about this situation, so we'll tolerate
+ // them.
+ if (/^(https?:\/\/|data:image)/.test(url)) {
+ return url;
+ }
+ }
+
+ function idX(id) {
+ return id;
+ }
+
+ legend.element = function() {
+ return container;
+ };
+
+ legend.content = function(content) {
+ if (!arguments.length) return element.innerHTML;
+ if (content) {
+ element.innerHTML = html_sanitize(content, urlX, idX);
+ element.style.display = 'block';
+ } else {
+ element.innerHTML = '';
+ element.style.display = 'none';
+ }
+ return legend;
+ };
+
+ legend.add = function() {
+ container = document.createElement('div');
+ container.className = 'wax-legends';
+
+ element = container.appendChild(document.createElement('div'));
+ element.className = 'wax-legend';
+ element.style.display = 'none';
+ return legend;
+ };
+
+ return legend.add();
+};
+var wax = wax || {};
+
+wax.location = function() {
+
+ var t = {};
+
+ function on(o) {
+ console.log(o);
+ if ((o.e.type === 'mousemove' || !o.e.type)) {
+ return;
+ } else {
+ var loc = o.formatter({ format: 'location' }, o.data);
+ if (loc) {
+ window.location.href = loc;
+ }
+ }
+ }
+
+ t.events = function() {
+ return {
+ on: on
+ };
+ };
+
+ return t;
+
+};
+var wax = wax || {};
+wax.movetip = {};
+
+wax.movetip = function() {
+ var popped = false,
+ t = {},
+ _tooltipOffset,
+ _contextOffset,
+ tooltip,
+ parent;
+
+ function moveTooltip(e) {
+ var eo = wax.u.eventoffset(e);
+ // faux-positioning
+ if ((_tooltipOffset.height + eo.y) >
+ (_contextOffset.top + _contextOffset.height) &&
+ (_contextOffset.height > _tooltipOffset.height)) {
+ eo.y -= _tooltipOffset.height;
+ tooltip.className += ' flip-y';
+ }
+
+ // faux-positioning
+ if ((_tooltipOffset.width + eo.x) >
+ (_contextOffset.left + _contextOffset.width)) {
+ eo.x -= _tooltipOffset.width;
+ tooltip.className += ' flip-x';
+ }
+
+ tooltip.style.left = eo.x + 'px';
+ tooltip.style.top = eo.y + 'px';
+ }
+
+ // Get the active tooltip for a layer or create a new one if no tooltip exists.
+ // Hide any tooltips on layers underneath this one.
+ function getTooltip(feature) {
+ var tooltip = document.createElement('div');
+ tooltip.className = 'wax-tooltip wax-tooltip-0';
+ tooltip.innerHTML = feature;
+ return tooltip;
+ }
+
+ // Hide a given tooltip.
+ function hide() {
+ if (tooltip) {
+ tooltip.parentNode.removeChild(tooltip);
+ tooltip = null;
+ }
+ }
+
+ function on(o) {
+ var content;
+ if (popped) return;
+ if ((o.e.type === 'mousemove' || !o.e.type)) {
+ content = o.formatter({ format: 'teaser' }, o.data);
+ if (!content) return;
+ hide();
+ parent.style.cursor = 'pointer';
+ tooltip = document.body.appendChild(getTooltip(content));
+ } else {
+ content = o.formatter({ format: 'teaser' }, o.data);
+ if (!content) return;
+ hide();
+ var tt = document.body.appendChild(getTooltip(content));
+ tt.className += ' wax-popup';
+
+ var close = tt.appendChild(document.createElement('a'));
+ close.href = '#close';
+ close.className = 'close';
+ close.innerHTML = 'Close';
+
+ popped = true;
+
+ tooltip = tt;
+
+ _tooltipOffset = wax.u.offset(tooltip);
+ _contextOffset = wax.u.offset(parent);
+ moveTooltip(o.e);
+
+ bean.add(close, 'click touchend', function closeClick(e) {
+ e.stop();
+ hide();
+ popped = false;
+ });
+ }
+ if (tooltip) {
+ _tooltipOffset = wax.u.offset(tooltip);
+ _contextOffset = wax.u.offset(parent);
+ moveTooltip(o.e);
+ }
+
+ }
+
+ function off() {
+ parent.style.cursor = 'default';
+ if (!popped) hide();
+ }
+
+ t.parent = function(x) {
+ if (!arguments.length) return parent;
+ parent = x;
+ return t;
+ };
+
+ t.events = function() {
+ return {
+ on: on,
+ off: off
+ };
+ };
+
+ return t;
+};
+
+// Wax GridUtil
+// ------------
+
+// Wax header
+var wax = wax || {};
+
+// Request
+// -------
+// Request data cache. `callback(data)` where `data` is the response data.
+wax.request = {
+ cache: {},
+ locks: {},
+ promises: {},
+ get: function(url, callback) {
+ // Cache hit.
+ if (this.cache[url]) {
+ return callback(this.cache[url][0], this.cache[url][1]);
+ // Cache miss.
+ } else {
+ this.promises[url] = this.promises[url] || [];
+ this.promises[url].push(callback);
+ // Lock hit.
+ if (this.locks[url]) return;
+ // Request.
+ var that = this;
+ this.locks[url] = true;
+ reqwest({
+ url: url + (~url.indexOf('?') ? '&' : '?') + 'callback=grid',
+ type: 'jsonp',
+ jsonpCallback: 'callback',
+ success: function(data) {
+ that.locks[url] = false;
+ that.cache[url] = [null, data];
+ for (var i = 0; i < that.promises[url].length; i++) {
+ that.promises[url][i](that.cache[url][0], that.cache[url][1]);
+ }
+ },
+ error: function(err) {
+ that.locks[url] = false;
+ that.cache[url] = [err, null];
+ for (var i = 0; i < that.promises[url].length; i++) {
+ that.promises[url][i](that.cache[url][0], that.cache[url][1]);
+ }
+ }
+ });
+ }
+ }
+};
+// Templating
+// ---------
+wax.template = function(x) {
+ var template = {};
+
+ function urlX(url) {
+ // Data URIs are subject to a bug in Firefox
+ // https://bugzilla.mozilla.org/show_bug.cgi?id=255107
+ // which let them be a vector. But WebKit does 'the right thing'
+ // or at least 'something' about this situation, so we'll tolerate
+ // them.
+ if (/^(https?:\/\/|data:image)/.test(url)) {
+ return url;
+ }
+ }
+
+ function idX(id) {
+ return id;
+ }
+
+ // Clone the data object such that the '__[format]__' key is only
+ // set for this instance of templating.
+ template.format = function(options, data) {
+ var clone = {};
+ for (var key in data) {
+ clone[key] = data[key];
+ }
+ if (options.format) {
+ clone['__' + options.format + '__'] = true;
+ }
+ return html_sanitize(Mustache.to_html(x, clone), urlX, idX);
+ };
+
+ return template;
+};
+if (!wax) var wax = {};
+
+// A wrapper for reqwest jsonp to easily load TileJSON from a URL.
+wax.tilejson = function(url, callback) {
+ reqwest({
+ url: url + (~url.indexOf('?') ? '&' : '?') + 'callback=grid',
+ type: 'jsonp',
+ jsonpCallback: 'callback',
+ success: callback,
+ error: callback
+ });
+};
+var wax = wax || {};
+wax.tooltip = {};
+
+wax.tooltip = function() {
+ var popped = false,
+ animate = false,
+ t = {},
+ tooltips = [],
+ _currentContent,
+ transitionEvent,
+ parent;
+
+ if (document.body.style['-webkit-transition'] !== undefined) {
+ transitionEvent = 'webkitTransitionEnd';
+ } else if (document.body.style.MozTransition !== undefined) {
+ transitionEvent = 'transitionend';
+ }
+
+ // Get the active tooltip for a layer or create a new one if no tooltip exists.
+ // Hide any tooltips on layers underneath this one.
+ function getTooltip(feature) {
+ var tooltip = document.createElement('div');
+ tooltip.className = 'wax-tooltip wax-tooltip-0';
+ tooltip.innerHTML = feature;
+ return tooltip;
+ }
+
+
+ function remove() {
+ if (this.parentNode) this.parentNode.removeChild(this);
+ }
+
+ // Hide a given tooltip.
+ function hide() {
+ var _ct;
+ while (_ct = tooltips.pop()) {
+ if (animate && transitionEvent) {
+ // This code assumes that transform-supporting browsers
+ // also support proper events. IE9 does both.
+ bean.add(_ct, transitionEvent, remove);
+ _ct.className += ' wax-fade';
+ } else {
+ if (_ct.parentNode) _ct.parentNode.removeChild(_ct);
+ }
+ }
+ }
+
+ function on(o) {
+ var content;
+ if (o.e.type === 'mousemove' || !o.e.type) {
+ if (!popped) {
+ content = o.content || o.formatter({ format: 'teaser' }, o.data);
+ if (!content || content == _currentContent) return;
+ hide();
+ parent.style.cursor = 'pointer';
+ tooltips.push(parent.appendChild(getTooltip(content)));
+ _currentContent = content;
+ }
+ } else {
+ content = o.content || o.formatter({ format: 'full' }, o.data);
+ if (!content) {
+ if (o.e.type && o.e.type.match(/touch/)) {
+ // fallback possible
+ content = o.content || o.formatter({ format: 'teaser' }, o.data);
+ }
+ // but if that fails, return just the same.
+ if (!content) return;
+ }
+ hide();
+ parent.style.cursor = 'pointer';
+ var tt = parent.appendChild(getTooltip(content));
+ tt.className += ' wax-popup';
+
+ var close = tt.appendChild(document.createElement('a'));
+ close.href = '#close';
+ close.className = 'close';
+ close.innerHTML = 'Close';
+ popped = true;
+
+ tooltips.push(tt);
+
+ bean.add(close, 'touchstart mousedown', function(e) {
+ e.stop();
+ });
+
+ bean.add(close, 'click touchend', function closeClick(e) {
+ e.stop();
+ hide();
+ popped = false;
+ });
+ }
+ }
+
+ function off() {
+ parent.style.cursor = 'default';
+ _currentContent = null;
+ if (!popped) hide();
+ }
+
+ t.parent = function(x) {
+ if (!arguments.length) return parent;
+ parent = x;
+ return t;
+ };
+
+ t.animate = function(x) {
+ if (!arguments.length) return animate;
+ animate = x;
+ return t;
+ };
+
+ t.events = function() {
+ return {
+ on: on,
+ off: off
+ };
+ };
+
+ return t;
+};
+var wax = wax || {};
+
+// Utils are extracted from other libraries or
+// written from scratch to plug holes in browser compatibility.
+wax.u = {
+ // From Bonzo
+ offset: function(el) {
+ // TODO: window margins
+ //
+ // Okay, so fall back to styles if offsetWidth and height are botched
+ // by Firefox.
+ var width = el.offsetWidth || parseInt(el.style.width, 10),
+ height = el.offsetHeight || parseInt(el.style.height, 10),
+ doc_body = document.body,
+ top = 0,
+ left = 0;
+
+ var calculateOffset = function(el) {
+ if (el === doc_body || el === document.documentElement) return;
+ top += el.offsetTop;
+ left += el.offsetLeft;
+
+ var style = el.style.transform ||
+ el.style.WebkitTransform ||
+ el.style.OTransform ||
+ el.style.MozTransform ||
+ el.style.msTransform;
+
+ if (style) {
+ if (match = style.match(/translate\((.+)px, (.+)px\)/)) {
+ top += parseInt(match[2], 10);
+ left += parseInt(match[1], 10);
+ } else if (match = style.match(/translate3d\((.+)px, (.+)px, (.+)px\)/)) {
+ top += parseInt(match[2], 10);
+ left += parseInt(match[1], 10);
+ } else if (match = style.match(/matrix3d\(([\-\d,\s]+)\)/)) {
+ var pts = match[1].split(',');
+ top += parseInt(pts[13], 10);
+ left += parseInt(pts[12], 10);
+ } else if (match = style.match(/matrix\(.+, .+, .+, .+, (.+), (.+)\)/)) {
+ top += parseInt(match[2], 10);
+ left += parseInt(match[1], 10);
+ }
+ }
+ };
+
+ calculateOffset(el);
+
+ try {
+ while (el = el.offsetParent) { calculateOffset(el); }
+ } catch(e) {
+ // Hello, internet explorer.
+ }
+
+ // Offsets from the body
+ top += doc_body.offsetTop;
+ left += doc_body.offsetLeft;
+ // Offsets from the HTML element
+ top += doc_body.parentNode.offsetTop;
+ left += doc_body.parentNode.offsetLeft;
+
+ // Firefox and other weirdos. Similar technique to jQuery's
+ // `doesNotIncludeMarginInBodyOffset`.
+ var htmlComputed = document.defaultView ?
+ window.getComputedStyle(doc_body.parentNode, null) :
+ doc_body.parentNode.currentStyle;
+ if (doc_body.parentNode.offsetTop !==
+ parseInt(htmlComputed.marginTop, 10) &&
+ !isNaN(parseInt(htmlComputed.marginTop, 10))) {
+ top += parseInt(htmlComputed.marginTop, 10);
+ left += parseInt(htmlComputed.marginLeft, 10);
+ }
+
+ return {
+ top: top,
+ left: left,
+ height: height,
+ width: width
+ };
+ },
+
+ '$': function(x) {
+ return (typeof x === 'string') ?
+ document.getElementById(x) :
+ x;
+ },
+
+ // IE doesn't have indexOf
+ indexOf: function(array, item) {
+ var nativeIndexOf = Array.prototype.indexOf;
+ if (array === null) return -1;
+ var i, l;
+ if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item);
+ for (i = 0, l = array.length; i < l; i++) if (array[i] === item) return i;
+ return -1;
+ },
+
+ // From quirksmode: normalize the offset of an event from the top-left
+ // of the page.
+ eventoffset: function(e) {
+ var posx = 0;
+ var posy = 0;
+ if (!e) { e = window.event; }
+ if (e.pageX || e.pageY) {
+ // Good browsers
+ return {
+ x: e.pageX,
+ y: e.pageY
+ };
+ } else if (e.clientX || e.clientY) {
+ // Internet Explorer
+ var doc = document.documentElement, body = document.body;
+ var htmlComputed = document.body.parentNode.currentStyle;
+ var topMargin = parseInt(htmlComputed.marginTop, 10) || 0;
+ var leftMargin = parseInt(htmlComputed.marginLeft, 10) || 0;
+ return {
+ x: e.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) -
+ (doc && doc.clientLeft || body && body.clientLeft || 0) + leftMargin,
+ y: e.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) -
+ (doc && doc.clientTop || body && body.clientTop || 0) + topMargin
+ };
+ } else if (e.touches && e.touches.length === 1) {
+ // Touch browsers
+ return {
+ x: e.touches[0].pageX,
+ y: e.touches[0].pageY
+ };
+ }
+ },
+
+ // Ripped from underscore.js
+ // Internal function used to implement `_.throttle` and `_.debounce`.
+ limit: function(func, wait, debounce) {
+ var timeout;
+ return function() {
+ var context = this, args = arguments;
+ var throttler = function() {
+ timeout = null;
+ func.apply(context, args);
+ };
+ if (debounce) clearTimeout(timeout);
+ if (debounce || !timeout) timeout = setTimeout(throttler, wait);
+ };
+ },
+
+ // Returns a function, that, when invoked, will only be triggered at most once
+ // during a given window of time.
+ throttle: function(func, wait) {
+ return this.limit(func, wait, false);
+ }
+};
+wax = wax || {};
+wax.mm = wax.mm || {};
+
+// Attribution
+// -----------
+// Attribution wrapper for Modest Maps.
+wax.mm.attribution = function(map, tilejson) {
+ tilejson = tilejson || {};
+ var a, // internal attribution control
+ attribution = {};
+
+ attribution.element = function() {
+ return a.element();
+ };
+
+ attribution.appendTo = function(elem) {
+ wax.u.$(elem).appendChild(a.element());
+ return this;
+ };
+
+ attribution.init = function() {
+ a = wax.attribution();
+ a.content(tilejson.attribution);
+ a.element().className = 'wax-attribution wax-mm';
+ return this;
+ };
+
+ return attribution.init();
+};
+wax = wax || {};
+wax.mm = wax.mm || {};
+
+// Box Selector
+// ------------
+wax.mm.boxselector = function(map, tilejson, opts) {
+ var corner = null,
+ nearCorner = null,
+ callback = ((typeof opts === 'function') ?
+ opts :
+ opts.callback),
+ boxDiv,
+ style,
+ borderWidth = 0,
+ horizontal = false, // Whether the resize is horizontal
+ vertical = false,
+ edge = 5, // Distance from border sensitive to resizing
+ addEvent = MM.addEvent,
+ removeEvent = MM.removeEvent,
+ box,
+ boxselector = {};
+
+ function getMousePoint(e) {
+ // start with just the mouse (x, y)
+ var point = new MM.Point(e.clientX, e.clientY);
+ // correct for scrolled document
+ point.x += document.body.scrollLeft + document.documentElement.scrollLeft;
+ point.y += document.body.scrollTop + document.documentElement.scrollTop;
+
+ // correct for nested offsets in DOM
+ for (var node = map.parent; node; node = node.offsetParent) {
+ point.x -= node.offsetLeft;
+ point.y -= node.offsetTop;
+ }
+ return point;
+ }
+
+ function mouseDown(e) {
+ if (!e.shiftKey) return;
+
+ corner = nearCorner = getMousePoint(e);
+ horizontal = vertical = true;
+
+ style.left = corner.x + 'px';
+ style.top = corner.y + 'px';
+ style.width = style.height = 0;
+
+ addEvent(document, 'mousemove', mouseMove);
+ addEvent(document, 'mouseup', mouseUp);
+
+ map.parent.style.cursor = 'crosshair';
+ return MM.cancelEvent(e);
+ }
+
+ // Resize existing box
+ function mouseDownResize(e) {
+ var point = getMousePoint(e),
+ TL = {
+ x: parseInt(boxDiv.offsetLeft, 10),
+ y: parseInt(boxDiv.offsetTop, 10)
+ },
+ BR = {
+ x: TL.x + parseInt(boxDiv.offsetWidth, 10),
+ y: TL.y + parseInt(boxDiv.offsetHeight, 10)
+ };
+
+ // Determine whether resize is horizontal, vertical or both
+ horizontal = point.x - TL.x <= edge || BR.x - point.x <= edge;
+ vertical = point.y - TL.y <= edge || BR.y - point.y <= edge;
+
+ if (vertical || horizontal) {
+ corner = {
+ x: (point.x - TL.x < BR.x - point.x) ? BR.x : TL.x,
+ y: (point.y - TL.y < BR.y - point.y) ? BR.y : TL.y
+ };
+ nearCorner = {
+ x: (point.x - TL.x < BR.x - point.x) ? TL.x : BR.x,
+ y: (point.y - TL.y < BR.y - point.y) ? TL.y : BR.y
+ };
+ addEvent(document, 'mousemove', mouseMove);
+ addEvent(document, 'mouseup', mouseUp);
+ return MM.cancelEvent(e);
+ }
+ }
+
+ function mouseMove(e) {
+ var point = getMousePoint(e);
+ style.display = 'block';
+ if (horizontal) {
+ style.left = (point.x < corner.x ? point.x : corner.x) + 'px';
+ style.width = Math.abs(point.x - corner.x) - 2 * borderWidth + 'px';
+ }
+ if (vertical) {
+ style.top = (point.y < corner.y ? point.y : corner.y) + 'px';
+ style.height = Math.abs(point.y - corner.y) - 2 * borderWidth + 'px';
+ }
+ changeCursor(point, map.parent);
+ return MM.cancelEvent(e);
+ }
+
+ function mouseUp(e) {
+ var point = getMousePoint(e),
+ l1 = map.pointLocation( new MM.Point(
+ horizontal ? point.x : nearCorner.x,
+ vertical? point.y : nearCorner.y
+ ));
+ l2 = map.pointLocation(corner);
+
+ // Format coordinates like mm.map.getExtent().
+ boxselector.extent([
+ new MM.Location(
+ Math.max(l1.lat, l2.lat),
+ Math.min(l1.lon, l2.lon)),
+ new MM.Location(
+ Math.min(l1.lat, l2.lat),
+ Math.max(l1.lon, l2.lon))
+ ]);
+
+ removeEvent(document, 'mousemove', mouseMove);
+ removeEvent(document, 'mouseup', mouseUp);
+
+ map.parent.style.cursor = 'auto';
+ }
+
+ function mouseMoveCursor(e) {
+ changeCursor(getMousePoint(e), boxDiv);
+ }
+
+ // Set resize cursor if mouse is on edge
+ function changeCursor(point, elem) {
+ var TL = {
+ x: parseInt(boxDiv.offsetLeft, 10),
+ y: parseInt(boxDiv.offsetTop, 10)
+ },
+ BR = {
+ x: TL.x + parseInt(boxDiv.offsetWidth, 10),
+ y: TL.y + parseInt(boxDiv.offsetHeight, 10)
+ };
+ // Build cursor style string
+ var prefix = '';
+ if (point.y - TL.y <= edge) prefix = 'n';
+ else if (BR.y - point.y <= edge) prefix = 's';
+ if (point.x - TL.x <= edge) prefix += 'w';
+ else if (BR.x - point.x <= edge) prefix += 'e';
+ if (prefix !== '') prefix += '-resize';
+ elem.style.cursor = prefix;
+ }
+
+ function drawbox(map, e) {
+ if (!boxDiv || !box) return;
+ var br = map.locationPoint(box[1]),
+ tl = map.locationPoint(box[0]),
+ style = boxDiv.style;
+
+ style.display = 'block';
+ style.height = 'auto';
+ style.width = 'auto';
+ style.left = Math.max(0, tl.x) + 'px';
+ style.top = Math.max(0, tl.y) + 'px';
+ style.right = Math.max(0, map.dimensions.x - br.x) + 'px';
+ style.bottom = Math.max(0, map.dimensions.y - br.y) + 'px';
+ }
+
+ boxselector.extent = function(x, silent) {
+ if (!x) return box;
+
+ box = [
+ new MM.Location(
+ Math.max(x[0].lat, x[1].lat),
+ Math.min(x[0].lon, x[1].lon)),
+ new MM.Location(
+ Math.min(x[0].lat, x[1].lat),
+ Math.max(x[0].lon, x[1].lon))
+ ];
+
+ drawbox(map);
+
+ if (!silent) callback(box);
+ };
+
+ boxselector.add = function(map) {
+ boxDiv = boxDiv || document.createElement('div');
+ boxDiv.id = map.parent.id + '-boxselector-box';
+ boxDiv.className = 'boxselector-box';
+ map.parent.appendChild(boxDiv);
+ style = boxDiv.style;
+ borderWidth = parseInt(window.getComputedStyle(boxDiv).borderWidth, 10);
+
+ addEvent(map.parent, 'mousedown', mouseDown);
+ addEvent(boxDiv, 'mousedown', mouseDownResize);
+ addEvent(map.parent, 'mousemove', mouseMoveCursor);
+ map.addCallback('drawn', drawbox);
+ return this;
+ };
+
+ boxselector.remove = function() {
+ map.parent.removeChild(boxDiv);
+ removeEvent(map.parent, 'mousedown', mouseDown);
+ removeEvent(boxDiv, 'mousedown', mouseDownResize);
+ removeEvent(map.parent, 'mousemove', mouseMoveCursor);
+ map.removeCallback('drawn', drawbox);
+ };
+
+ return boxselector.add(map);
+};
+wax = wax || {};
+wax.mm = wax.mm || {};
+wax._ = {};
+
+// Bandwidth Detection
+// ------------------
+wax.mm.bwdetect = function(map, options) {
+ options = options || {};
+ var lowpng = options.png || '.png128',
+ lowjpg = options.jpg || '.jpg70',
+ bw = false;
+
+ wax._.bw_png = lowpng;
+ wax._.bw_jpg = lowjpg;
+
+ return wax.bwdetect(options, function(x) {
+ wax._.bw = !x;
+ for (var i = 0; i < map.layers.length; i++) {
+ if (map.getLayerAt(i).provider instanceof wax.mm.connector) {
+ map.getLayerAt(i).setProvider(map.getLayerAt(i).provider);
+ }
+ }
+ });
+};
+wax = wax || {};
+wax.mm = wax.mm || {};
+
+// Fullscreen
+// ----------
+// A simple fullscreen control for Modest Maps
+
+// Add zoom links, which can be styled as buttons, to a `modestmaps.Map`
+// control. This function can be used chaining-style with other
+// chaining-style controls.
+wax.mm.fullscreen = function(map) {
+ // true: fullscreen
+ // false: minimized
+ var fullscreened = false,
+ fullscreen = {},
+ a,
+ body = document.body,
+ smallSize;
+
+ function click(e) {
+ if (e) e.stop();
+ if (fullscreened) {
+ fullscreen.original();
+ } else {
+ fullscreen.full();
+ }
+ }
+
+ function ss(w, h) {
+ map.dimensions = new MM.Point(w, h);
+ map.parent.style.width = Math.round(map.dimensions.x) + 'px';
+ map.parent.style.height = Math.round(map.dimensions.y) + 'px';
+ map.dispatchCallback('resized', map.dimensions);
+ }
+
+ // Modest Maps demands an absolute height & width, and doesn't auto-correct
+ // for changes, so here we save the original size of the element and
+ // restore to that size on exit from fullscreen.
+ fullscreen.add = function(map) {
+ a = document.createElement('a');
+ a.className = 'wax-fullscreen';
+ a.href = '#fullscreen';
+ a.innerHTML = 'fullscreen';
+ bean.add(a, 'click', click);
+ return this;
+ };
+ fullscreen.full = function() {
+ if (fullscreened) { return; } else { fullscreened = true; }
+ smallSize = [map.parent.offsetWidth, map.parent.offsetHeight];
+ map.parent.className += ' wax-fullscreen-map';
+ body.className += ' wax-fullscreen-view';
+ ss(map.parent.offsetWidth, map.parent.offsetHeight);
+ };
+ fullscreen.original = function() {
+ if (!fullscreened) { return; } else { fullscreened = false; }
+ map.parent.className = map.parent.className.replace(' wax-fullscreen-map', '');
+ body.className = body.className.replace(' wax-fullscreen-view', '');
+ ss(smallSize[0], smallSize[1]);
+ };
+ fullscreen.appendTo = function(elem) {
+ wax.u.$(elem).appendChild(a);
+ return this;
+ };
+
+ return fullscreen.add(map);
+};
+wax = wax || {};
+wax.mm = wax.mm || {};
+
+wax.mm.hash = function(map) {
+ return wax.hash({
+ getCenterZoom: function() {
+ var center = map.getCenter(),
+ zoom = map.getZoom(),
+ precision = Math.max(
+ 0,
+ Math.ceil(Math.log(zoom) / Math.LN2));
+
+ return [zoom.toFixed(2),
+ center.lat.toFixed(precision),
+ center.lon.toFixed(precision)
+ ].join('/');
+ },
+ setCenterZoom: function setCenterZoom(args) {
+ map.setCenterZoom(
+ new MM.Location(args[1], args[2]),
+ args[0]);
+ },
+ bindChange: function(fn) {
+ map.addCallback('drawn', fn);
+ },
+ unbindChange: function(fn) {
+ map.removeCallback('drawn', fn);
+ }
+ });
+};
+wax = wax || {};
+wax.mm = wax.mm || {};
+
+wax.mm.interaction = function() {
+ var dirty = false,
+ _grid,
+ map,
+ clearingEvents = ['zoomed', 'panned', 'centered',
+ 'extentset', 'resized', 'drawn'];
+
+ function grid() {
+ var zoomLayer = map.getLayerAt(0)
+ .levels[Math.round(map.getZoom())];
+ if (!dirty && _grid !== undefined && _grid.length) {
+ return _grid;
+ } else {
+ _grid = (function(t) {
+ var o = [];
+ for (var key in t) {
+ if (t[key].parentNode === zoomLayer) {
+ var offset = wax.u.offset(t[key]);
+ o.push([
+ offset.top,
+ offset.left,
+ t[key]
+ ]);
+ }
+ }
+ return o;
+ })(map.getLayerAt(0).tiles);
+ return _grid;
+ }
+ }
+
+ function setdirty() { dirty = true; }
+
+ function attach(x) {
+ if (!arguments.length) return map;
+ map = x;
+ for (var i = 0; i < clearingEvents.length; i++) {
+ map.addCallback(clearingEvents[i], setdirty);
+ }
+ }
+
+ function detach(x) {
+ for (var i = 0; i < clearingEvents.length; i++) {
+ map.removeCallback(clearingEvents[i], setdirty);
+ }
+ }
+
+ return wax.interaction()
+ .attach(attach)
+ .detach(detach)
+ .parent(function() {
+ return map.parent;
+ })
+ .grid(grid);
+};
+wax = wax || {};
+wax.mm = wax.mm || {};
+
+// LatLng
+// ------
+// Show the current cursor position in
+// lat/long
+wax.mm.latlngtooltip = function(map) {
+ var tt, // tooltip
+ _down = false,
+ latlng = {};
+
+ function getMousePoint(e) {
+ // start with just the mouse (x, y)
+ var point = new MM.Point(e.clientX, e.clientY);
+ // correct for scrolled document
+ point.x += document.body.scrollLeft + document.documentElement.scrollLeft;
+ point.y += document.body.scrollTop + document.documentElement.scrollTop;
+
+ // correct for nested offsets in DOM
+ for (var node = map.parent; node; node = node.offsetParent) {
+ point.x -= node.offsetLeft;
+ point.y -= node.offsetTop;
+ }
+ return point;
+ }
+
+ function onDown(e) {
+ console.log('here');
+ _down = true;
+ }
+
+ function onUp(e) {
+ _down = false;
+ }
+
+ function onMove(e) {
+ if (!e.shiftKey || _down) {
+ if (tt.parentNode === map.parent) {
+ map.parent.removeChild(tt);
+ }
+ return;
+ }
+
+ var pt = getMousePoint(e),
+ ll = map.pointLocation(pt),
+ fmt = ll.lat.toFixed(2) + ', ' + ll.lon.toFixed(2);
+
+ tt.innerHTML = fmt;
+ pt.scale = pt.width = pt.height = 1;
+ pt.x += 10;
+ MM.moveElement(tt, pt);
+ map.parent.appendChild(tt);
+ }
+
+ latlng.add = function() {
+ MM.addEvent(map.parent, 'mousemove', onMove);
+ MM.addEvent(map.parent, 'mousedown', onDown);
+ MM.addEvent(map.parent, 'mouseup', onUp);
+ tt = document.createElement('div');
+ tt.className = 'wax-latlngtooltip';
+ return this;
+ };
+
+ latlng.remove = function() {
+ MM.removeEvent(map.parent, 'mousemove', onMove);
+ MM.removeEvent(map.parent, 'mousedown', onDown);
+ MM.removeEvent(map.parent, 'mouseup', onUp);
+ return this;
+ };
+
+ return latlng.add();
+};
+wax = wax || {};
+wax.mm = wax.mm || {};
+
+// Legend Control
+// --------------
+// The Modest Maps version of this control is a very, very
+// light wrapper around the `/lib` code for legends.
+wax.mm.legend = function(map, tilejson) {
+ tilejson = tilejson || {};
+ var l, // parent legend
+ legend = {};
+
+ legend.add = function() {
+ l = wax.legend()
+ .content(tilejson.legend || '');
+ return this;
+ };
+
+ legend.content = function(x) {
+ if (x) l.content(x.legend || '');
+ };
+
+ legend.element = function() {
+ return l.element();
+ };
+
+ legend.appendTo = function(elem) {
+ wax.u.$(elem).appendChild(l.element());
+ return this;
+ };
+
+ return legend.add();
+};
+wax = wax || {};
+wax.mm = wax.mm || {};
+
+// Point Selector
+// --------------
+//
+// This takes an object of options:
+//
+// * `callback`: a function called with an array of `com.modestmaps.Location`
+// objects when the map is edited
+//
+// It also exposes a public API function: `addLocation`, which adds a point
+// to the map as if added by the user.
+wax.mm.pointselector = function(map, tilejson, opts) {
+ var mouseDownPoint = null,
+ mouseUpPoint = null,
+ tolerance = 5,
+ overlayDiv,
+ pointselector = {},
+ locations = [];
+
+ var callback = (typeof opts === 'function') ?
+ opts :
+ opts.callback;
+
+ // Create a `com.modestmaps.Point` from a screen event, like a click.
+ function makePoint(e) {
+ var coords = wax.u.eventoffset(e);
+ var point = new MM.Point(coords.x, coords.y);
+ // correct for scrolled document
+
+ // and for the document
+ var body = {
+ x: parseFloat(MM.getStyle(document.documentElement, 'margin-left')),
+ y: parseFloat(MM.getStyle(document.documentElement, 'margin-top'))
+ };
+
+ if (!isNaN(body.x)) point.x -= body.x;
+ if (!isNaN(body.y)) point.y -= body.y;
+
+ // TODO: use wax.util.offset
+ // correct for nested offsets in DOM
+ for (var node = map.parent; node; node = node.offsetParent) {
+ point.x -= node.offsetLeft;
+ point.y -= node.offsetTop;
+ }
+ return point;
+ }
+
+ // Currently locations in this control contain circular references to elements.
+ // These can't be JSON encoded, so here's a utility to clean the data that's
+ // spit back.
+ function cleanLocations(locations) {
+ var o = [];
+ for (var i = 0; i < locations.length; i++) {
+ o.push(new MM.Location(locations[i].lat, locations[i].lon));
+ }
+ return o;
+ }
+
+ // Attach this control to a map by registering callbacks
+ // and adding the overlay
+
+ // Redraw the points when the map is moved, so that they stay in the
+ // correct geographic locations.
+ function drawPoints() {
+ var offset = new MM.Point(0, 0);
+ for (var i = 0; i < locations.length; i++) {
+ var point = map.locationPoint(locations[i]);
+ if (!locations[i].pointDiv) {
+ locations[i].pointDiv = document.createElement('div');
+ locations[i].pointDiv.className = 'wax-point-div';
+ locations[i].pointDiv.style.position = 'absolute';
+ locations[i].pointDiv.style.display = 'block';
+ // TODO: avoid circular reference
+ locations[i].pointDiv.location = locations[i];
+ // Create this closure once per point
+ bean.add(locations[i].pointDiv, 'mouseup',
+ (function selectPointWrap(e) {
+ var l = locations[i];
+ return function(e) {
+ MM.removeEvent(map.parent, 'mouseup', mouseUp);
+ pointselector.deleteLocation(l, e);
+ };
+ })());
+ map.parent.appendChild(locations[i].pointDiv);
+ }
+ locations[i].pointDiv.style.left = point.x + 'px';
+ locations[i].pointDiv.style.top = point.y + 'px';
+ }
+ }
+
+ function mouseDown(e) {
+ mouseDownPoint = makePoint(e);
+ bean.add(map.parent, 'mouseup', mouseUp);
+ }
+
+ // Remove the awful circular reference from locations.
+ // TODO: This function should be made unnecessary by not having it.
+ function mouseUp(e) {
+ if (!mouseDownPoint) return;
+ mouseUpPoint = makePoint(e);
+ if (MM.Point.distance(mouseDownPoint, mouseUpPoint) < tolerance) {
+ pointselector.addLocation(map.pointLocation(mouseDownPoint));
+ callback(cleanLocations(locations));
+ }
+ mouseDownPoint = null;
+ }
+
+ // API for programmatically adding points to the map - this
+ // calls the callback for ever point added, so it can be symmetrical.
+ // Useful for initializing the map when it's a part of a form.
+ pointselector.addLocation = function(location) {
+ locations.push(location);
+ drawPoints();
+ callback(cleanLocations(locations));
+ };
+
+ pointselector.locations = function(x) {
+ return locations;
+ };
+
+ pointselector.add = function(map) {
+ bean.add(map.parent, 'mousedown', mouseDown);
+ map.addCallback('drawn', drawPoints);
+ return this;
+ };
+
+ pointselector.remove = function(map) {
+ bean.remove(map.parent, 'mousedown', mouseDown);
+ map.removeCallback('drawn', drawPoints);
+ for (var i = locations.length - 1; i > -1; i--) {
+ pointselector.deleteLocation(locations[i]);
+ }
+ return this;
+ };
+
+ pointselector.deleteLocation = function(location, e) {
+ if (!e || confirm('Delete this point?')) {
+ location.pointDiv.parentNode.removeChild(location.pointDiv);
+ locations.splice(wax.u.indexOf(locations, location), 1);
+ callback(cleanLocations(locations));
+ }
+ };
+
+ return pointselector.add(map);
+};
+wax = wax || {};
+wax.mm = wax.mm || {};
+
+// ZoomBox
+// -------
+// An OL-style ZoomBox control, from the Modest Maps example.
+wax.mm.zoombox = function(map) {
+ // TODO: respond to resize
+ var zoombox = {},
+ drawing = false,
+ box,
+ mouseDownPoint = null;
+
+ function getMousePoint(e) {
+ // start with just the mouse (x, y)
+ var point = new MM.Point(e.clientX, e.clientY);
+ // correct for scrolled document
+ point.x += document.body.scrollLeft + document.documentElement.scrollLeft;
+ point.y += document.body.scrollTop + document.documentElement.scrollTop;
+
+ // correct for nested offsets in DOM
+ for (var node = map.parent; node; node = node.offsetParent) {
+ point.x -= node.offsetLeft;
+ point.y -= node.offsetTop;
+ }
+ return point;
+ }
+
+ function mouseUp(e) {
+ if (!drawing) return;
+
+ drawing = false;
+ var point = getMousePoint(e);
+
+ var l1 = map.pointLocation(point),
+ l2 = map.pointLocation(mouseDownPoint);
+
+ map.setExtent([l1, l2]);
+
+ box.style.display = 'none';
+ MM.removeEvent(map.parent, 'mousemove', mouseMove);
+ MM.removeEvent(map.parent, 'mouseup', mouseUp);
+
+ map.parent.style.cursor = 'auto';
+ }
+
+ function mouseDown(e) {
+ if (!(e.shiftKey && !this.drawing)) return;
+
+ drawing = true;
+ mouseDownPoint = getMousePoint(e);
+
+ box.style.left = mouseDownPoint.x + 'px';
+ box.style.top = mouseDownPoint.y + 'px';
+
+ MM.addEvent(map.parent, 'mousemove', mouseMove);
+ MM.addEvent(map.parent, 'mouseup', mouseUp);
+
+ map.parent.style.cursor = 'crosshair';
+ return MM.cancelEvent(e);
+ }
+
+ function mouseMove(e) {
+ if (!drawing) return;
+
+ var point = getMousePoint(e);
+ box.style.display = 'block';
+ if (point.x < mouseDownPoint.x) {
+ box.style.left = point.x + 'px';
+ } else {
+ box.style.left = mouseDownPoint.x + 'px';
+ }
+ box.style.width = Math.abs(point.x - mouseDownPoint.x) + 'px';
+ if (point.y < mouseDownPoint.y) {
+ box.style.top = point.y + 'px';
+ } else {
+ box.style.top = mouseDownPoint.y + 'px';
+ }
+ box.style.height = Math.abs(point.y - mouseDownPoint.y) + 'px';
+ return MM.cancelEvent(e);
+ }
+
+ zoombox.add = function(map) {
+ // Use a flag to determine whether the zoombox is currently being
+ // drawn. Necessary only for IE because `mousedown` is triggered
+ // twice.
+ box = box || document.createElement('div');
+ box.id = map.parent.id + '-zoombox-box';
+ box.className = 'zoombox-box';
+ map.parent.appendChild(box);
+ MM.addEvent(map.parent, 'mousedown', mouseDown);
+ return this;
+ };
+
+ zoombox.remove = function() {
+ map.parent.removeChild(box);
+ MM.removeEvent(map.parent, 'mousedown', mouseDown);
+ };
+
+ return zoombox.add(map);
+};
+wax = wax || {};
+wax.mm = wax.mm || {};
+
+// Zoomer
+// ------
+// Add zoom links, which can be styled as buttons, to a `modestmaps.Map`
+// control. This function can be used chaining-style with other
+// chaining-style controls.
+wax.mm.zoomer = function(map) {
+ var zoomin = document.createElement('a');
+ zoomin.innerHTML = '+';
+ zoomin.href = '#';
+ zoomin.className = 'zoomer zoomin';
+ bean.add(zoomin, 'mousedown dblclick', function(e) {
+ e.stop();
+ });
+ bean.add(zoomin, 'click', function(e) {
+ e.stop();
+ map.zoomIn();
+ }, false);
+
+ var zoomout = document.createElement('a');
+ zoomout.innerHTML = '-';
+ zoomout.href = '#';
+ zoomout.className = 'zoomer zoomout';
+ bean.add(zoomout, 'mousedown dblclick', function(e) {
+ e.stop();
+ });
+ bean.add(zoomout, 'click', function(e) {
+ e.stop();
+ map.zoomOut();
+ });
+
+ var zoomer = {
+ add: function(map) {
+ map.addCallback('drawn', function(map, e) {
+ if (map.coordinate.zoom === map.coordLimits[0].zoom) {
+ zoomout.className = 'zoomer zoomout zoomdisabled';
+ } else if (map.coordinate.zoom === map.coordLimits[1].zoom) {
+ zoomin.className = 'zoomer zoomin zoomdisabled';
+ } else {
+ zoomin.className = 'zoomer zoomin';
+ zoomout.className = 'zoomer zoomout';
+ }
+ });
+ return this;
+ },
+ appendTo: function(elem) {
+ wax.u.$(elem).appendChild(zoomin);
+ wax.u.$(elem).appendChild(zoomout);
+ return this;
+ }
+ };
+ return zoomer.add(map);
+};
+var wax = wax || {};
+wax.mm = wax.mm || {};
+
+// A layer connector for Modest Maps conformant to TileJSON
+// https://github.com/mapbox/tilejson
+wax.mm._provider = function(options) {
+ this.options = {
+ tiles: options.tiles,
+ scheme: options.scheme || 'xyz',
+ minzoom: options.minzoom || 0,
+ maxzoom: options.maxzoom || 22,
+ bounds: options.bounds || [-180, -90, 180, 90]
+ };
+};
+
+wax.mm._provider.prototype = {
+ outerLimits: function() {
+ return [
+ this.locationCoordinate(
+ new MM.Location(
+ this.options.bounds[0],
+ this.options.bounds[1])).zoomTo(this.options.minzoom),
+ this.locationCoordinate(
+ new MM.Location(
+ this.options.bounds[2],
+ this.options.bounds[3])).zoomTo(this.options.maxzoom)
+ ];
+ },
+ getTile: function(c) {
+ if (!(coord = this.sourceCoordinate(c))) return null;
+ if (coord.zoom < this.options.minzoom || coord.zoom > this.options.maxzoom) return null;
+
+ coord.row = (this.options.scheme === 'tms') ?
+ Math.pow(2, coord.zoom) - coord.row - 1 :
+ coord.row;
+
+ var u = this.options.tiles[parseInt(Math.pow(2, coord.zoom) * coord.row + coord.column, 10) %
+ this.options.tiles.length]
+ .replace('{z}', coord.zoom.toFixed(0))
+ .replace('{x}', coord.column.toFixed(0))
+ .replace('{y}', coord.row.toFixed(0));
+
+ if (wax._ && wax._.bw) {
+ u = u.replace('.png', wax._.bw_png)
+ .replace('.jpg', wax._.bw_jpg);
+ }
+
+ return u;
+ }
+};
+
+if (MM) {
+ MM.extend(wax.mm._provider, MM.MapProvider);
+}
+
+wax.mm.connector = function(options) {
+ var x = new wax.mm._provider(options);
+ return new MM.Layer(x);
+};
diff --git a/js/wax.mm.min.js b/js/wax.mm.min.js
new file mode 100755
index 0000000..dc03898
--- /dev/null
+++ b/js/wax.mm.min.js
@@ -0,0 +1,2 @@
+/* wax - 6.0.3 - 1.0.4-565-gb47a22a */!function(a,b,c){typeof module!="undefined"?module.exports=c(a,b):typeof define=="function"&&typeof define.amd=="object"?define(c):b[a]=c(a,b)}("bean",this,function(a,b){var c=window,d=b[a],e=/over|out/,f=/[^\.]*(?=\..*)\.|.*/,g=/\..*/,h="addEventListener",i="attachEvent",j="removeEventListener",k="detachEvent",l=document||{},m=l.documentElement||{},n=m[h],o=n?h:i,p=Array.prototype.slice,q=/click|mouse(?!(.*wheel|scroll))|menu|drag|drop/i,r=/mouse.*(wheel|scroll)/i,s=/^text/i,t=/^touch|^gesture/i,u={one:1},v=function(a,b,c){for(c=0;c0){b=b.split(" ");for(j=b.length;j--;)I(a,b[j],c);return a}h=l&&b.replace(g,""),h&&w[h]&&(h=w[h].type);if(!b||l){if(i=l&&b.replace(f,""))i=i.split(".");k(a,h,c,i)}else if(typeof b=="function")k(a,null,b);else for(d in b)b.hasOwnProperty(d)&&I(a,d,b[d]);return a},J=function(a,b,c,d,e){var f,g,h,i,j=c,k=c&&typeof c=="string";if(b&&!c&&typeof b=="object")for(f in b)b.hasOwnProperty(f)&&J.apply(this,[a,f,b[f]]);else{i=arguments.length>3?p.call(arguments,3):[],g=(k?c:b).split(" "),k&&(c=H(b,j=d,e))&&(i=p.call(i,1)),this===u&&(c=E(I,a,b,c,j));for(h=g.length;h--;)G(a,g[h],c,j,i)}return a},K=function(){return J.apply(u,arguments)},L=n?function(a,b,d){var e=l.createEvent(a?"HTMLEvents":"UIEvents");e[a?"initEvent":"initUIEvent"](b,!0,!0,c,1),d.dispatchEvent(e)}:function(a,b,c){c=y(c,a),a?c.fireEvent("on"+b,l.createEventObject()):c["_on"+b]++},M=function(a,b,c){var d,e,h,i,j,k=b.split(" ");for(d=k.length;d--;){b=k[d].replace(g,"");if(i=k[d].replace(f,""))i=i.split(".");if(!i&&!c&&a[o])L(v[b],b,a);else{j=A.get(a,b),c=[!1].concat(c);for(e=0,h=j.length;e"?">":"&",e)}}c.endDoc&&c.endDoc(e)}}function x(b){var c,d;return w({startDoc:function(a){c=[],d=!1},startTag:function(e,f,g){if(d)return;if(!a.ELEMENTS.hasOwnProperty(e))return;var h=a.ELEMENTS[e];if(h&a.eflags.FOLDABLE)return;if(h&a.eflags.UNSAFE){d=!(h&a.eflags.EMPTY);return}f=b(e,f);if(f){h&a.eflags.EMPTY||c.push(e),g.push("<",e);for(var i=0,j=f.length;i")}},endTag:function(b,e){if(d){d=!1;return}if(!a.ELEMENTS.hasOwnProperty(b))return;var f=a.ELEMENTS[b];if(!(f&(a.eflags.UNSAFE|a.eflags.EMPTY|a.eflags.FOLDABLE))){var g;if(f&a.eflags.OPTIONAL_ENDTAG)for(g=c.length;--g>=0;){var h=c[g];if(h===b)break;if(!(a.ELEMENTS[h]&a.eflags.OPTIONAL_ENDTAG))return}else for(g=c.length;--g>=0;)if(c[g]===b)break;if(g<0)return;for(var i=c.length;--i>g;){var h=c[i];a.ELEMENTS[h]&a.eflags.OPTIONAL_ENDTAG||e.push("")}c.length=g,e.push("")}},pcdata:function(a,b){d||b.push(a)},rcdata:function(a,b){d||b.push(a)},cdata:function(a,b){d||b.push(a)},endDoc:function(a){for(var b=c.length;--b>=0;)a.push("");c.length=0}})}function z(b,c,e){var f=[];return x(function g(b,f){for(var g=0;g",amp:"&",nbsp:" ",quot:'"',apos:"'"},d=/^(?:https?|mailto|data)$/i,e=/^#(\d+)$/,f=/^#x([0-9A-Fa-f]+)$/,i=/\0/g,k=/&(#\d+|#x[0-9A-Fa-f]+|\w+);/g,m=/&/g,n=/&([^a-z#]|#(?:[^0-9x]|x(?:[^0-9a-f]|$)|$)|$)/gi,o=//g,q=/\"/g,r=/\=/g,u=new RegExp("^\\s*(?:(?:([a-z][a-z-]*)(\\s*=\\s*(\"[^\"]*\"|'[^']*'|(?=[a-z][a-z-]*\\s*=)|[^>\"'\\s]*))?)|(/?>)|[\\s\\S][^a-z\\s>]*)","i"),v=new RegExp("^(?:&(\\#[0-9]+|\\#[x][0-9a-f]+|\\w+);||]*>|<\\?[^>*]*>|<(/)?([a-z][a-z0-9]*)|([^<&>]+)|([<&>]))","i"),y=new RegExp("^(?:([^:/?#]+):)?");return{escapeAttrib:s,makeHtmlSanitizer:x,makeSaxParser:w,normalizeRCData:t,sanitize:z,unescapeEntities:l}}(html4),html_sanitize=html.sanitize;typeof window!="undefined"&&(window.html=html,window.html_sanitize=html_sanitize),html4.ATTRIBS["*::style"]=0,html4.ATTRIBS["a::target"]=0,html4.ELEMENTS.style=0;var Mustache=function(){var a={},b=function(){};return b.prototype={otag:"{{",ctag:"}}",pragmas:{},buffer:[],pragmas_implemented:{"IMPLICIT-ITERATOR":!0},context:{},render:function(a,b,c,d){d||(this.context=b,this.buffer=[]);if(!this.includes("",a)){if(d)return a;this.send(a);return}a=this.render_pragmas(a);var e=this.render_section(a,b,c);e===!1&&(e=this.render_tags(a,b,c,d));if(d)return e;this.sendLines(e)},send:function(a){a!==""&&this.buffer.push(a)},sendLines:function(a){if(a){var b=a.split("\n");for(var c=0;c|\\{|%)?([^\\/#\\^]+?)\\1?"+b+"+","g")})},g=f(),h=function(a,d,h){switch(d){case"!":return"";case"=":return e.set_delimiters(h),g=f(),"";case">":return e.render_partial(h,b,c);case"{":return e.find(h,b);default:return e.escape(e.find(h,b))}},i=a.split("\n");for(var j=0;j\\]/g,function(a){switch(a){case"&":return"&";case'"':return""";case"'":return"'";case"<":return"<";case">":return">";default:return a}})},create_context:function(a){if(this.is_object(a))return a;var b=".";this.pragmas["IMPLICIT-ITERATOR"]&&(b=this.pragmas["IMPLICIT-ITERATOR"].iterator);var c={};return c[b]=a,c},is_object:function(a){return a&&typeof a=="object"},is_array:function(a){return Object.prototype.toString.call(a)==="[object Array]"},trim:function(a){return a.replace(/^\s*|\s*$/g,"")},map:function(a,b){if(typeof a.map=="function")return a.map(b);var c=[],d=a.length;for(var e=0;e=93&&a--,a>=35&&a--,a-=32,a}b=b||{};var c={},d=b.resolution||4,e=b.tileSize||256;return c.grid_tile=function(){return a},c.getKey=function(b,c){if(!a||!a.grid)return;if(c<0||b<0)return;if(Math.floor(c)>=e||Math.floor(b)>=e)return;return f(a.grid[Math.floor(c/d)].charCodeAt(Math.floor(b/d)))},c.gridFeature=function(b,c){var d=this.getKey(b,c),e=a.keys;if(e&&e[d]&&a.data[e[d]])return a.data[e[d]]},c.tileFeature=function(b,c,d){if(!a)return;var e=wax.u.offset(d);return feature=this.gridFeature(b-e.left,c-e.top),feature},c},wax.gm=function(){function g(a){return typeof a=="string"&&(a=[a]),function b(b){if(!b)return;var c=new RegExp("/(\\d+)\\/(\\d+)\\/(\\d+)\\.[\\w\\._]+"),d=c.exec(b);if(!d)return;return a[parseInt(d[2],10)%a.length].replace("{z}",d[1]).replace("{x}",d[2]).replace("{y}",d[3])}}var a=4,b={},c={},d,e,f=function(a){return a.replace(/(\.png|\.jpg|\.jpeg)(\d*)/,".grid.json")};return c.formatter=function(a){return arguments.length?(e=wax.formatter(a),c):e},c.template=function(a){return arguments.length?(e=wax.template(a),c):e},c.gridUrl=function(a){return arguments.length?(f=typeof a=="function"?a:g(a),c):f},c.getGrid=function(b,d){var g=f(b);return!e||!g?d(null,null):(wax.request.get(g,function(b,c){if(b)return d(b,null);d(null,wax.gi(c,{formatter:e,resolution:a}))}),c)},c.tilejson=function(b){return arguments.length?(b.template?c.template(b.template):b.formatter&&c.formatter(b.formatter),b.grids&&c.gridUrl(b.grids),b.resolution&&(a=b.resolution),d=b,c):d},c},wax=wax||{},wax.hash=function(a){function b(){return location.hash.substring(1)}function c(a){var b=window.location;b.replace(b.toString().replace(b.hash,"#"+a))}function g(b){var c=b.split("/");for(var d=0;da.y&&b[c][1]a.x)return b[c][2];return!1}function p(){return d?(window.clearTimeout(d),d=null,!0):!1}function q(d){if(c)return;var e=wax.u.eventoffset(d),f=o(e),g;f&&a.getGrid(f.src,function(c,h){if(c||!h)return;g=h.tileFeature(e.x,e.y,f),g?bean.fire(b,"on",{parent:j(),data:g,formatter:a.formatter().format,e:d}):bean.fire(b,"off")})}function r(a){if(p())return;c=!0,e=wax.u.eventoffset(a),a.type==="mousedown"?bean.add(document.body,"mouseup",t):a.type==="touchstart"&&a.touches.length===1&&(bean.fire(b,"off"),bean.add(j(),n))}function s(){bean.remove(j(),n),c=!1}function t(a){var b={},g=wax.u.eventoffset(a);c=!1;for(var h in a)b[h]=a[h];return bean.remove(document.body,"mouseup",t),bean.remove(j(),n),a.type==="touchend"?u(a,e):Math.round(g.y/f)===Math.round(e.y/f)&&Math.round(g.x/f)===Math.round(e.x/f)&&(d=window.setTimeout(function(){d=null,u(b,g)},300)),t}function u(c,d){var e=o(d);e&&a.getGrid(e.src,function(f,g){if(f||!g)return;var h=g.tileFeature(d.x,d.y,e);if(!h)return;bean.fire(b,"on",{parent:j(),data:h,formatter:a.formatter().format,e:c})})}var a=wax.gm(),b={},c=!1,d=!1,e,f=4,g,h,i,j,k,l,m={mousemove:q,touchstart:r,mousedown:r},n={touchend:t,touchmove:t,touchcancel:s};return b.attach=function(a){return arguments.length?(h=a,b):h},b.detach=function(a){return arguments.length?(i=a,b):i},b.map=function(a){return arguments.length?(k=a,h&&h(k),bean.add(j(),m),bean.add(j(),"touchstart",r),b):k},b.grid=function(a){return arguments.length?(g=a,b):g},b.remove=function(a){return i&&i(k),bean.remove(j(),m),bean.fire(b,"remove"),b},b.tilejson=function(c){return arguments.length?(a.tilejson(c),b):a.tilejson()},b.formatter=function(){return a.formatter()},b.on=function(a,c){return bean.add(b,a,c),b},b.off=function(a,c){return bean.remove(b,a,c),b},b.gridmanager=function(c){return arguments.length?(a=c,b):a},b.parent=function(a){return j=a,b},b};var wax=wax||{};wax.legend=function(){function d(a){if(/^(https?:\/\/|data:image)/.test(a))return a}function e(a){return a}var a,b={},c;return b.element=function(){return c},b.content=function(c){return arguments.length?(c?(a.innerHTML=html_sanitize(c,d,e),a.style.display="block"):(a.innerHTML="",a.style.display="none"),b):a.innerHTML},b.add=function(){return c=document.createElement("div"),c.className="wax-legends",a=c.appendChild(document.createElement("div")),a.className="wax-legend",a.style.display="none",b},b.add()};var wax=wax||{};wax.movetip={},wax.movetip=function(){function g(a){var b=wax.u.eventoffset(a);c.height+b.y>d.top+d.height&&d.height>c.height&&(b.y-=c.height,e.className+=" flip-y"),c.width+b.x>d.left+d.width&&(b.x-=c.width,e.className+=" flip-x"),e.style.left=b.x+"px",e.style.top=b.y+"px"}function h(a){var b=document.createElement("div");return b.className="wax-tooltip wax-tooltip-0",b.innerHTML=a,b}function i(){e&&(e.parentNode.removeChild(e),e=null)}function j(b){var j;if(a)return;if(b.e.type==="mousemove"||!b.e.type){j=b.formatter({format:"teaser"},b.data);if(!j)return;i(),f.style.cursor="pointer",e=document.body.appendChild(h(j))}else{j=b.formatter({format:"teaser"},b.data);if(!j)return;i();var k=document.body.appendChild(h(j));k.className+=" wax-popup";var l=k.appendChild(document.createElement("a"));l.href="#close",l.className="close",l.innerHTML="Close",a=!0,e=k,c=wax.u.offset(e),d=wax.u.offset(f),g(b.e),bean.add(l,"click touchend",function(b){b.stop(),i(),a=!1})}e&&(c=wax.u.offset(e),d=wax.u.offset(f),g(b.e))}function k(){f.style.cursor="default",a||i()}var a=!1,b={},c,d,e,f;return b.parent=function(a){return arguments.length?(f=a,b):f},b.events=function(){return{on:j,off:k}},b};var wax=wax||{};wax.request={cache:{},locks:{},promises:{},get:function(a,b){if(this.cache[a])return b(this.cache[a][0],this.cache[a][1]);this.promises[a]=this.promises[a]||[],this.promises[a].push
+(b);if(this.locks[a])return;var c=this;this.locks[a]=!0,reqwest({url:a+(~a.indexOf("?")?"&":"?")+"callback=grid",type:"jsonp",jsonpCallback:"callback",success:function(b){c.locks[a]=!1,c.cache[a]=[null,b];for(var d=0;d-1;b--)h.deleteLocation(i[b]);return this},h.deleteLocation=function(a,b){if(!b||confirm("Delete this point?"))a.pointDiv.parentNode.removeChild(a.pointDiv),i.splice(wax.u.indexOf(i,a),1),j(l(i))},h.add(a)},wax=wax||{},wax.mm=wax.mm||{},wax.mm.zoombox=function(a){function f(b){var c=new MM.Point(b.clientX,b.clientY);c.x+=document.body.scrollLeft+document.documentElement.scrollLeft,c.y+=document.body.scrollTop+document.documentElement.scrollTop;for(var d=a.parent;d;d=d.offsetParent)c.x-=d.offsetLeft,c.y-=d.offsetTop;return c}function g(b){if(!c)return;c=!1;var h=f(b),j=a.pointLocation(h),k=a.pointLocation(e);a.setExtent([j,k]),d.style.display="none",MM.removeEvent(a.parent,"mousemove",i),MM.removeEvent(a.parent,"mouseup",g),a.parent.style.cursor="auto"}function h(b){if(!b.shiftKey||!!this.drawing)return;return c=!0,e=f(b),d.style.left=e.x+"px",d.style.top=e.y+"px",MM.addEvent(a.parent,"mousemove",i),MM.addEvent(a.parent,"mouseup",g),a.parent.style.cursor="crosshair",MM.cancelEvent(b)}function i(a){if(!c)return;var b=f(a);return d.style.display="block",b.xthis.options.maxzoom)return null;coord.row=this.options.scheme==="tms"?Math.pow(2,coord.zoom)-coord.row-1:coord.row;var b=this.options.tiles[parseInt(Math.pow(2,coord.zoom)*coord.row+coord.column,10)%this.options.tiles.length].replace("{z}",coord.zoom.toFixed(0)).replace("{x}",coord.column.toFixed(0)).replace("{y}",coord.row.toFixed(0));return wax._&&wax._.bw&&(b=b.replace(".png",wax._.bw_png).replace(".jpg",wax._.bw_jpg)),b}},MM&&MM.extend(wax.mm._provider,MM.MapProvider),wax.mm.connector=function(a){var b=new wax.mm._provider(a);return new MM.Layer(b)}
\ No newline at end of file
diff --git a/site.css b/site.css
new file mode 100644
index 0000000..9c3b631
--- /dev/null
+++ b/site.css
@@ -0,0 +1,256 @@
+/* ------------------------------------------
+ Reset ♥
+ http://meyerweb.com/eric/tools/css/reset/
+ v2.0 | 20110126
+ License: none (public domain)
+---------------------------------------------*/
+html, body, div, span, applet, object, iframe,
+h1, h2, h3, h4, h5, h6, p, blockquote, pre,
+a, abbr, acronym, address, big, cite, code,
+del, dfn, em, img, ins, kbd, q, s, samp,
+small, strike, strong, sub, sup, tt, var,
+b, u, i, center,
+dl, dt, dd, ol, ul, li,
+fieldset, form, label, legend,
+table, caption, tbody, tfoot, thead, tr, th, td,
+article, aside, canvas, details, embed,
+figure, figcaption, footer, header, hgroup,
+menu, nav, output, ruby, section, summary,
+time, mark, audio, video {
+ margin: 0;
+ padding: 0;
+ border: 0;
+ font-size: 100%;
+ font: inherit;
+ vertical-align: baseline;
+ }
+/* HTML5 display-role reset for older browsers */
+article, aside, details, figcaption, figure,
+footer, header, hgroup, menu, nav, section {
+ display: block;
+ }
+html, body, #map {width: 100%; height: 100%;}
+body { line-height: 1; }
+ol, ul { list-style: none; }
+blockquote, q { quotes: none; }
+blockquote:before, blockquote:after,
+q:before, q:after { content: ''; content: none; }
+/* tables still need 'cellspacing='0'' in the markup */
+table { border-collapse: collapse; border-spacing: 0; }
+:focus { outline: 0; }
+
+/* --------------------------------------------------------
+ Global styles
+--------------------------------------------------------- */
+
+body {
+ font-size: 15px;
+ font-family: Helvetica, Arial, sans-serif;
+ color: #333;
+ background: url(img/bg2.jpg);
+}
+
+h1 {
+ font-size: 25px;
+ padding: 10px 0;
+ font-weight: bold;
+}
+
+p {
+ padding: 0 0 10px 0;
+ }
+
+a {
+ color: #489;
+ }
+
+/* --------------------------------------------------------
+ Layout
+--------------------------------------------------------- */
+
+.wrapper {
+ width: 960px;
+ margin: 0 auto;
+ position: relative;
+}
+
+#map {
+ width: 100%;
+ height: 400px;
+}
+
+
+#header {
+ height: 69px;
+ border-bottom: 1px solid #ccc;
+ background-color: #fff;
+ padding: 10px 20px;
+ z-index: 2;
+ box-shadow:rgba(0,0,0,0.1) 3px 3px 3px;
+ -moz-box-shadow:rgba(0,0,0,0.1) 3px 3px 3px;
+ -webkit-box-shadow:rgba(0,0,0,0.1) 3px 3px 3px;
+ }
+
+#attribution {
+ position: absolute;
+ left: 10px;
+ bottom: 10px;
+ font-size: 10px;
+ }
+
+/* --------------------------------------------------------
+ Wax, largely taken from theme/controls.css
+--------------------------------------------------------- */
+
+a.zoomer {
+ text-decoration:none;
+ position:absolute;
+ background-color:#fff;
+ line-height:30px;
+ font-size:20px;
+ z-index:99999;
+ text-align:center;
+ width:30px;
+ height:30px;
+ top: 20px;
+ border-bottom: 1px solid #ccc;
+ border-right: 1px solid #ccc;
+ color: #333;
+ box-shadow:rgba(0,0,0,0.1) 3px 3px 3px;
+ -moz-box-shadow:rgba(0,0,0,0.1) 3px 3px 3px;
+ -webkit-box-shadow:rgba(0,0,0,0.1) 3px 3px 3px;
+ }
+ a.zoomin {
+ left:20px;
+ border-top-left-radius: 3px;
+ border-bottom-left-radius: 3px;
+ -moz-border-top-left-radius: 3px;
+ -moz-border-bottom-left-radius: 3px;
+ }
+ a.zoomout {
+ left:50px;
+ border-left: 1px solid #ccc;
+ border-top-right-radius: 3px;
+ border-bottom-right-radius: 3px;
+ -moz-border-top-right-radius: 3px;
+ -moz-border-bottom-right-radius: 3px;
+ }
+
+.wax-legends {
+ position:absolute;
+ right:20px;
+ bottom:20px;
+ z-index:999999;
+ background: #fff;
+ padding: 15px 10px 10px;
+ border-radius: 3px;
+ -moz-border-radius: 3px;
+ box-shadow:rgba(0,0,0,0.1) 3px 3px 3px;
+ -moz-box-shadow:rgba(0,0,0,0.1) 3px 3px 3px;
+ -webkit-box-shadow:rgba(0,0,0,0.1) 3px 3px 3px;
+ }
+
+.wax-tooltip {
+ z-index:999999;
+ position:absolute;
+ -webkit-user-select:auto;
+ left:20px;
+ top:70px;
+ max-width:300px;
+ opacity:1;
+ -webkit-transition:opacity 50ms;
+ -moz-transition:opacity 50ms;
+ }
+
+.wax-fade {
+ opacity:0;
+ transition: opacity .5s;
+ -moz-transition: opacity .5s; /* Firefox 4 */
+ -webkit-transition: opacity .5s; /* Safari and Chrome */
+ -o-transition: opacity .5s; /* Opera */
+ }
+
+ .wax-tooltip .close {
+ display:block;
+ position:absolute;
+ top:0px;
+ right:0px;
+ }
+
+
+
+
+
+
+ .wax-legend .legend-title {
+ text-align: left;
+ margin-bottom: 8px;
+ font-weight: bold;
+ font-size: 90%;
+ }
+ .wax-legend .legend-scale ul {
+ margin: 0;
+ padding: 0;
+ float: left;
+ list-style: none;
+ }
+ .wax-legend .legend-scale ul li {
+ display: block;
+ float: left;
+ width: 50px;
+ margin-bottom: 6px;
+ text-align: center;
+ font-size: 80%;
+ list-style: none;
+ }
+ .wax-legend ul.legend-labels li span {
+ display: block;
+ float: left;
+ height: 15px;
+ width: 50px;
+ margin-bottom: 10px;
+ }
+ .wax-legend .legend-source {
+ font-size: 70%;
+ color: #999;
+ clear: both;
+ }
+ .wax-legend a {
+ color: #777;
+ }
+
+
+
+
+
+#filter_map {
+ width: 400px;
+ height: 300px;
+}
+
+#filter_map .cidade-marker {
+ width: 20px;
+ height: 20px;
+ margin-top: -10px;
+ margin-left: -10px;
+ background: url(img/marker.png);
+ position: absolute;
+}
+
+#filter_map .cidade-marker .cidade-tip {
+ position: absolute;
+ width: 200px;
+ top: -13px;
+ left: -100px;
+ text-align: center;
+ font-size: 12px;
+ display: none;
+ color: #000;
+ text-shadow: 1px 1px 2px #fff;
+ font-weight: bold;
+}
+
+#filter_map .cidade-marker:hover .cidade-tip,
+#filter_map .cidade-marker.active .cidade-tip {
+ display: block;
+}
\ No newline at end of file