cesium 0.13.0

data/app/assets/javascripts/ThirdParty/Uri.js

@@ -0,0 +1,277 @@
+/**
+ * @fileOverview
+ * @license
+ *
+ * Grauw URI utilities
+ *
+ * See: http://hg.grauw.nl/grauw-lib/file/tip/src/uri.js
+ *
+ * @author Laurens Holst (http://www.grauw.nl/)
+ *
+ *   Copyright 2012 Laurens Holst
+ *
+ *   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.
+ *
+ */
+/*global define*/
+define(function() {
+
+	/**
+	 * Constructs a URI object.
+	 * @constructor
+	 * @class Implementation of URI parsing and base URI resolving algorithm in RFC 3986.
+	 * @param {string|URI} uri A string or URI object to create the object from.
+	 */
+	function URI(uri) {
+		if (uri instanceof URI) {  // copy constructor
+			this.scheme = uri.scheme;
+			this.authority = uri.authority;
+			this.path = uri.path;
+			this.query = uri.query;
+			this.fragment = uri.fragment;
+		} else if (uri) {  // uri is URI string or cast to string
+			var c = parseRegex.exec(uri);
+			this.scheme = c[1];
+			this.authority = c[2];
+			this.path = c[3];
+			this.query = c[4];
+			this.fragment = c[5];
+		}
+	};
+
+	// Initial values on the prototype
+	URI.prototype.scheme    = null;
+	URI.prototype.authority = null;
+	URI.prototype.path      = '';
+	URI.prototype.query     = null;
+	URI.prototype.fragment  = null;
+
+	// Regular expression from RFC 3986 appendix B
+	var parseRegex = new RegExp('^(?:([^:/?#]+):)?(?://([^/?#]*))?([^?#]*)(?:\\?([^#]*))?(?:#(.*))?$');
+
+	/**
+	 * Returns the scheme part of the URI.
+	 * In "http://example.com:80/a/b?x#y" this is "http".
+	 */
+	URI.prototype.getScheme = function() {
+		return this.scheme;
+	};
+
+	/**
+	 * Returns the authority part of the URI.
+	 * In "http://example.com:80/a/b?x#y" this is "example.com:80".
+	 */
+	URI.prototype.getAuthority = function() {
+		return this.authority;
+	};
+
+	/**
+	 * Returns the path part of the URI.
+	 * In "http://example.com:80/a/b?x#y" this is "/a/b".
+	 * In "mailto:mike@example.com" this is "mike@example.com".
+	 */
+	URI.prototype.getPath = function() {
+		return this.path;
+	};
+
+	/**
+	 * Returns the query part of the URI.
+	 * In "http://example.com:80/a/b?x#y" this is "x".
+	 */
+	URI.prototype.getQuery = function() {
+		return this.query;
+	};
+
+	/**
+	 * Returns the fragment part of the URI.
+	 * In "http://example.com:80/a/b?x#y" this is "y".
+	 */
+	URI.prototype.getFragment = function() {
+		return this.fragment;
+	};
+
+	/**
+	 * Tests whether the URI is an absolute URI.
+	 * See RFC 3986 section 4.3.
+	 */
+	URI.prototype.isAbsolute = function() {
+		return !!this.scheme && !this.fragment;
+	};
+
+	///**
+	//* Extensive validation of the URI against the ABNF in RFC 3986
+	//*/
+	//URI.prototype.validate
+
+	/**
+	 * Tests whether the URI is a same-document reference.
+	 * See RFC 3986 section 4.4.
+	 *
+	 * To perform more thorough comparison, you can normalise the URI objects.
+	 */
+	URI.prototype.isSameDocumentAs = function(uri) {
+		return uri.scheme == this.scheme &&
+		    uri.authority == this.authority &&
+		         uri.path == this.path &&
+		        uri.query == this.query;
+	};
+
+	/**
+	 * Simple String Comparison of two URIs.
+	 * See RFC 3986 section 6.2.1.
+	 *
+	 * To perform more thorough comparison, you can normalise the URI objects.
+	 */
+	URI.prototype.equals = function(uri) {
+		return this.isSameDocumentAs(uri) && uri.fragment == this.fragment;
+	};
+
+	/**
+	 * Normalizes the URI using syntax-based normalization.
+	 * This includes case normalization, percent-encoding normalization and path segment normalization.
+	 * XXX: Percent-encoding normalization does not escape characters that need to be escaped.
+	 *      (Although that would not be a valid URI in the first place. See validate().)
+	 * See RFC 3986 section 6.2.2.
+	 */
+	URI.prototype.normalize = function() {
+		this.removeDotSegments();
+		if (this.scheme)
+			this.scheme = this.scheme.toLowerCase();
+		if (this.authority)
+			this.authority = this.authority.replace(authorityRegex, replaceAuthority).
+									replace(caseRegex, replaceCase);
+		if (this.path)
+			this.path = this.path.replace(caseRegex, replaceCase);
+		if (this.query)
+			this.query = this.query.replace(caseRegex, replaceCase);
+		if (this.fragment)
+			this.fragment = this.fragment.replace(caseRegex, replaceCase);
+	};
+
+	var caseRegex = /%[0-9a-z]{2}/gi;
+	var percentRegex = /[a-zA-Z0-9\-\._~]/;
+	var authorityRegex = /(.*@)?([^@:]*)(:.*)?/;
+
+	function replaceCase(str) {
+		var dec = unescape(str);
+		return percentRegex.test(dec) ? dec : str.toUpperCase();
+	}
+
+	function replaceAuthority(str, p1, p2, p3) {
+		return (p1 || '') + p2.toLowerCase() + (p3 || '');
+	}
+
+	/**
+	 * Resolve a relative URI (this) against a base URI.
+	 * The base URI must be an absolute URI.
+	 * See RFC 3986 section 5.2
+	 */
+	URI.prototype.resolve = function(baseURI) {
+		var uri = new URI();
+		if (this.scheme) {
+			uri.scheme = this.scheme;
+			uri.authority = this.authority;
+			uri.path = this.path;
+			uri.query = this.query;
+		} else {
+			uri.scheme = baseURI.scheme;
+			if (this.authority) {
+				uri.authority = this.authority;
+				uri.path = this.path;
+				uri.query = this.query;
+			} else {
+				uri.authority = baseURI.authority;
+				if (this.path == '') {
+					uri.path = baseURI.path;
+					uri.query = this.query || baseURI.query;
+				} else {
+					if (this.path.charAt(0) == '/') {
+						uri.path = this.path;
+						uri.removeDotSegments();
+					} else {
+						if (baseURI.authority && baseURI.path == '') {
+							uri.path = '/' + this.path;
+						} else {
+							uri.path = baseURI.path.substring(0, baseURI.path.lastIndexOf('/') + 1) + this.path;
+						}
+						uri.removeDotSegments();
+					}
+					uri.query = this.query;
+				}
+			}
+		}
+		uri.fragment = this.fragment;
+		return uri;
+	};
+
+	/**
+	 * Remove dot segments from path.
+	 * See RFC 3986 section 5.2.4
+	 * @private
+	 */
+	URI.prototype.removeDotSegments = function() {
+		var input = this.path.split('/'),
+			output = [],
+			segment,
+			absPath = input[0] == '';
+		if (absPath)
+			input.shift();
+		var sFirst = input[0] == '' ? input.shift() : null;
+		while (input.length) {
+			segment = input.shift();
+			if (segment == '..') {
+				output.pop();
+			} else if (segment != '.') {
+				output.push(segment);
+			}
+		}
+		if (segment == '.' || segment == '..')
+			output.push('');
+		if (absPath)
+			output.unshift('');
+		this.path = output.join('/');
+	};
+
+	/**
+	 * Resolves a relative URI against an absolute base URI.
+	 * Convenience method.
+	 * @param {String} uri the relative URI to resolve
+	 * @param {String} baseURI the base URI (must be absolute) to resolve against
+	 */
+	URI.resolve = function(sURI, sBaseURI) {
+		var uri = cache[sURI] || (cache[sURI] = new URI(sURI));
+		var baseURI = cache[sBaseURI] || (cache[sBaseURI] = new URI(sBaseURI));
+		return uri.resolve(baseURI).toString();
+	};
+
+	var cache = {};
+
+	/**
+	 * Serialises the URI to a string.
+	 */
+	URI.prototype.toString = function() {
+		var result = '';
+		if (this.scheme)
+			result += this.scheme + ':';
+		if (this.authority)
+			result += '//' + this.authority;
+		result += this.path;
+		if (this.query)
+			result += '?' + this.query;
+		if (this.fragment)
+			result += '#' + this.fragment;
+		return result;
+	};
+
+return URI;
+});

data/app/assets/javascripts/ThirdParty/measureText.js

@@ -0,0 +1,197 @@
+/**
+  @license
+  fontmetrics.js - https://github.com/Pomax/fontmetrics.js
+
+  This library rewrites the Canvas2D "measureText" function
+  so that it returns a more complete metrics object.
+  This library is licensed under the MIT (Expat) license,
+  the text for which is included below.
+
+** -----------------------------------------------------------------------------
+
+  CHANGELOG:
+
+    2012-01-21 - Whitespace handling added by Joe Turner
+                 (https://github.com/oampo)
+
+** -----------------------------------------------------------------------------
+
+  Copyright (C) 2011 by Mike "Pomax" Kamermans
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+**/
+/*global define*/
+define(function() {
+    /*jshint strict:false*/
+/*
+  var NAME = "FontMetrics Library"
+  var VERSION = "1-2012.0121.1300";
+
+  // if there is no getComputedStyle, this library won't work.
+  if(!document.defaultView.getComputedStyle) {
+    throw("ERROR: 'document.defaultView.getComputedStyle' not found. This library only works in browsers that can report computed CSS values.");
+  }
+
+  // store the old text metrics function on the Canvas2D prototype
+  CanvasRenderingContext2D.prototype.measureTextWidth = CanvasRenderingContext2D.prototype.measureText;
+*/
+  /**
+   *  shortcut function for getting computed CSS values
+   */
+  var getCSSValue = function(element, property) {
+    return document.defaultView.getComputedStyle(element,null).getPropertyValue(property);
+  };
+/*
+  // debug function
+  var show = function(canvas, ctx, xstart, w, h, metrics)
+  {
+    document.body.appendChild(canvas);
+    ctx.strokeStyle = 'rgba(0, 0, 0, 0.5)';
+
+    ctx.beginPath();
+    ctx.moveTo(xstart,0);
+    ctx.lineTo(xstart,h);
+    ctx.closePath();
+    ctx.stroke();
+
+    ctx.beginPath();
+    ctx.moveTo(xstart+metrics.bounds.maxx,0);
+    ctx.lineTo(xstart+metrics.bounds.maxx,h);
+    ctx.closePath();
+    ctx.stroke();
+
+    ctx.beginPath();
+    ctx.moveTo(0,h/2-metrics.ascent);
+    ctx.lineTo(w,h/2-metrics.ascent);
+    ctx.closePath();
+    ctx.stroke();
+
+    ctx.beginPath();
+    ctx.moveTo(0,h/2+metrics.descent);
+    ctx.lineTo(w,h/2+metrics.descent);
+    ctx.closePath();
+    ctx.stroke();
+  }
+*/
+  /**
+   * The new text metrics function
+   */
+  var measureText = function(context2D, textstring) {
+    var metrics = context2D.measureText(textstring),
+        fontFamily = getCSSValue(context2D.canvas,"font-family"),
+        fontSize = getCSSValue(context2D.canvas,"font-size").replace("px",""),
+        isSpace = !(/\S/.test(textstring));
+        metrics.fontsize = fontSize;
+
+    // for text lead values, we meaure a multiline text container.
+    var leadDiv = document.createElement("div");
+    leadDiv.style.position = "absolute";
+    leadDiv.style.opacity = 0;
+    leadDiv.style.font = fontSize + "px " + fontFamily;
+    leadDiv.innerHTML = textstring + "<br/>" + textstring;
+    document.body.appendChild(leadDiv);
+
+    // make some initial guess at the text leading (using the standard TeX ratio)
+    metrics.leading = 1.2 * fontSize;
+
+    // then we try to get the real value from the browser
+    var leadDivHeight = getCSSValue(leadDiv,"height");
+    leadDivHeight = leadDivHeight.replace("px","");
+    if (leadDivHeight >= fontSize * 2) { metrics.leading = (leadDivHeight/2) | 0; }
+    document.body.removeChild(leadDiv);
+
+    // if we're not dealing with white space, we can compute metrics
+    if (!isSpace) {
+        // Have characters, so measure the text
+        var canvas = document.createElement("canvas");
+        var padding = 100;
+        canvas.width = metrics.width + padding;
+        canvas.height = 3*fontSize;
+        canvas.style.opacity = 1;
+        canvas.style.fontFamily = fontFamily;
+        canvas.style.fontSize = fontSize;
+        var ctx = canvas.getContext("2d");
+        ctx.font = fontSize + "px " + fontFamily;
+
+        var w = canvas.width,
+            h = canvas.height,
+            baseline = h/2;
+
+        // Set all canvas pixeldata values to 255, with all the content
+        // data being 0. This lets us scan for data[i] != 255.
+        ctx.fillStyle = "white";
+        ctx.fillRect(-1, -1, w+2, h+2);
+        ctx.fillStyle = "black";
+        ctx.fillText(textstring, padding/2, baseline);
+        var pixelData = ctx.getImageData(0, 0, w, h).data;
+
+        // canvas pixel data is w*4 by h*4, because R, G, B and A are separate,
+        // consecutive values in the array, rather than stored as 32 bit ints.
+        var i = 0,
+            w4 = w * 4,
+            len = pixelData.length;
+
+        // Finding the ascent uses a normal, forward scanline
+        while (++i < len && pixelData[i] === 255) {}
+        var ascent = (i/w4)|0;
+
+        // Finding the descent uses a reverse scanline
+        i = len - 1;
+        while (--i > 0 && pixelData[i] === 255) {}
+        var descent = (i/w4)|0;
+
+        // find the min-x coordinate
+        for(i = 0; i<len && pixelData[i] === 255; ) {
+          i += w4;
+          if(i>=len) { i = (i-len) + 4; }}
+        var minx = ((i%w4)/4) | 0;
+
+        // find the max-x coordinate
+        var step = 1;
+        for(i = len-3; i>=0 && pixelData[i] === 255; ) {
+          i -= w4;
+          if(i<0) { i = (len - 3) - (step++)*4; }}
+        var maxx = ((i%w4)/4) + 1 | 0;
+
+        // set font metrics
+        metrics.ascent = (baseline - ascent);
+        metrics.descent = (descent - baseline);
+        metrics.bounds = { minx: minx - (padding/2),
+                           maxx: maxx - (padding/2),
+                           miny: 0,
+                           maxy: descent-ascent };
+        metrics.height = 1+(descent - ascent);
+    }
+
+    // if we ARE dealing with whitespace, most values will just be zero.
+    else {
+        // Only whitespace, so we can't measure the text
+        metrics.ascent = 0;
+        metrics.descent = 0;
+        metrics.bounds = { minx: 0,
+                           maxx: metrics.width, // Best guess
+                           miny: 0,
+                           maxy: 0 };
+        metrics.height = 0;
+    }
+    return metrics;
+  };
+
+  return measureText;
+});