| // Copyright 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 Miscellaneous constants and functions referenced in |
| * the main source files. |
| */ |
| |
| function log(msg) {} |
| |
| // String literals defined globally and not to be inlined. (IE6 perf) |
| /** @const */ var STRING_empty = ''; |
| |
| /** @const */ var CSS_display = 'display'; |
| /** @const */ var CSS_position = 'position'; |
| |
| // Constants for possible values of the typeof operator. |
| var TYPE_boolean = 'boolean'; |
| var TYPE_number = 'number'; |
| var TYPE_object = 'object'; |
| var TYPE_string = 'string'; |
| var TYPE_function = 'function'; |
| var TYPE_undefined = 'undefined'; |
| |
| |
| /** |
| * Wrapper for the eval() builtin function to evaluate expressions and |
| * obtain their value. It wraps the expression in parentheses such |
| * that object literals are really evaluated to objects. Without the |
| * wrapping, they are evaluated as block, and create syntax |
| * errors. Also protects against other syntax errors in the eval()ed |
| * code and returns null if the eval throws an exception. |
| * |
| * @param {string} expr |
| * @return {Object|null} |
| */ |
| function jsEval(expr) { |
| try { |
| // NOTE(mesch): An alternative idiom would be: |
| // |
| // eval('(' + expr + ')'); |
| // |
| // Note that using the square brackets as below, "" evals to undefined. |
| // The alternative of using parentheses does not work when evaluating |
| // function literals in IE. |
| // e.g. eval("(function() {})") returns undefined, and not a function |
| // object, in IE. |
| var result = eval('[' + expr + '][0]'); |
| if (typeof result != 'object') { |
| throw new Error('expression of type Object expected, ' + |
| typeof result + ' found'); |
| } |
| return /** @type {Object} */(result); |
| } catch (e) { |
| log('EVAL FAILED ' + expr + ': ' + e); |
| return null; |
| } |
| } |
| |
| function jsLength(obj) { |
| return obj.length; |
| } |
| |
| /** |
| * Copies all properties from second object to the first. Modifies to. |
| * |
| * @param {Object} to The target object. |
| * @param {Object} from The source object. |
| */ |
| function copyProperties(to, from) { |
| for (var p in from) { |
| to[p] = from[p]; |
| } |
| } |
| |
| |
| /** |
| * @param {*} value The possible value to use. |
| * @param {*} defaultValue The default if the value is not set. |
| * @return {*} The value, if it is defined and not null; otherwise the default. |
| */ |
| function getDefaultObject(value, defaultValue) { |
| if (typeof value != TYPE_undefined && value != null) { |
| return value; |
| } else { |
| return defaultValue; |
| } |
| } |
| |
| /** |
| * Detect if an object looks like an Array. |
| * Note that instanceof Array is not robust; for example an Array |
| * created in another iframe fails instanceof Array. |
| * @param {Object|null} value Object to interrogate |
| * @return {boolean} Is the object an array? |
| */ |
| function isArray(value) { |
| return value != null && |
| typeof value == TYPE_object && |
| typeof value.length == TYPE_number; |
| } |
| |
| |
| /** |
| * Finds a slice of an array. |
| * |
| * @param {Array|Arguments} array Array to be sliced. |
| * @param {number} start The start of the slice. |
| * @param {number=} opt_end The end of the slice (optional). |
| * @return {Array} array The slice of the array from start to end. |
| */ |
| function arraySlice(array, start, opt_end) { |
| // Use |
| // return Function.prototype.call.apply(Array.prototype.slice, arguments); |
| // instead of the simpler |
| // return Array.prototype.slice.call(array, start, opt_end); |
| // here because of a bug in the FF and IE implementations of |
| // Array.prototype.slice which causes this function to return an empty list |
| // if opt_end is not provided. |
| return /** @type {Array} */( |
| Function.prototype.call.apply(Array.prototype.slice, arguments)); |
| } |
| |
| |
| /** |
| * Jscompiler wrapper for parseInt() with base 10. |
| * |
| * @param {string} s string repersentation of a number. |
| * |
| * @return {number} The integer contained in s, converted on base 10. |
| */ |
| function parseInt10(s) { |
| return parseInt(s, 10); |
| } |
| |
| |
| /** |
| * Clears the array by setting the length property to 0. This usually |
| * works, and if it should turn out not to work everywhere, here would |
| * be the place to implement the browser specific workaround. |
| * |
| * @param {Array} array Array to be cleared. |
| */ |
| function arrayClear(array) { |
| array.length = 0; |
| } |
| |
| |
| /** |
| * Prebinds "this" within the given method to an object, but ignores all |
| * arguments passed to the resulting function. |
| * I.e. var_args are all the arguments that method is invoked with when |
| * invoking the bound function. |
| * |
| * @param {Object|null} object The object that the method call targets. |
| * @param {Function} method The target method. |
| * @param {...*} var_args |
| * @return {Function} Method with the target object bound to it and curried by |
| * the provided arguments. |
| */ |
| function bindFully(object, method, var_args) { |
| var args = arraySlice(arguments, 2); |
| return function() { |
| return method.apply(object, args); |
| } |
| } |
| |
| // Based on <http://www.w3.org/TR/2000/ REC-DOM-Level-2-Core-20001113/ |
| // core.html#ID-1950641247>. |
| var DOM_ELEMENT_NODE = 1; |
| var DOM_ATTRIBUTE_NODE = 2; |
| var DOM_TEXT_NODE = 3; |
| var DOM_CDATA_SECTION_NODE = 4; |
| var DOM_ENTITY_REFERENCE_NODE = 5; |
| var DOM_ENTITY_NODE = 6; |
| var DOM_PROCESSING_INSTRUCTION_NODE = 7; |
| var DOM_COMMENT_NODE = 8; |
| var DOM_DOCUMENT_NODE = 9; |
| var DOM_DOCUMENT_TYPE_NODE = 10; |
| var DOM_DOCUMENT_FRAGMENT_NODE = 11; |
| var DOM_NOTATION_NODE = 12; |
| |
| |
| |
| function domGetElementById(document, id) { |
| return document.getElementById(id); |
| } |
| |
| /** |
| * Creates a new node in the given document |
| * |
| * @param {Document} doc Target document. |
| * @param {string} name Name of new element (i.e. the tag name).. |
| * @return {Element} Newly constructed element. |
| */ |
| function domCreateElement(doc, name) { |
| return doc.createElement(name); |
| } |
| |
| /** |
| * Traverses the element nodes in the DOM section underneath the given |
| * node and invokes the given callback as a method on every element |
| * node encountered. |
| * |
| * @param {Element} node Parent element of the subtree to traverse. |
| * @param {Function} callback Called on each node in the traversal. |
| */ |
| function domTraverseElements(node, callback) { |
| var traverser = new DomTraverser(callback); |
| traverser.run(node); |
| } |
| |
| /** |
| * A class to hold state for a dom traversal. |
| * @param {Function} callback Called on each node in the traversal. |
| * @constructor |
| * @class |
| */ |
| function DomTraverser(callback) { |
| this.callback_ = callback; |
| } |
| |
| /** |
| * Processes the dom tree in breadth-first order. |
| * @param {Element} root The root node of the traversal. |
| */ |
| DomTraverser.prototype.run = function(root) { |
| var me = this; |
| me.queue_ = [ root ]; |
| while (jsLength(me.queue_)) { |
| me.process_(me.queue_.shift()); |
| } |
| } |
| |
| /** |
| * Processes a single node. |
| * @param {Element} node The current node of the traversal. |
| */ |
| DomTraverser.prototype.process_ = function(node) { |
| var me = this; |
| |
| me.callback_(node); |
| |
| for (var c = node.firstChild; c; c = c.nextSibling) { |
| if (c.nodeType == DOM_ELEMENT_NODE) { |
| me.queue_.push(c); |
| } |
| } |
| } |
| |
| /** |
| * Get an attribute from the DOM. Simple redirect, exists to compress code. |
| * |
| * @param {Element} node Element to interrogate. |
| * @param {string} name Name of parameter to extract. |
| * @return {string|null} Resulting attribute. |
| */ |
| function domGetAttribute(node, name) { |
| return node.getAttribute(name); |
| // NOTE(mesch): Neither in IE nor in Firefox, HTML DOM attributes |
| // implement namespaces. All items in the attribute collection have |
| // null localName and namespaceURI attribute values. In IE, we even |
| // encounter DIV elements that don't implement the method |
| // getAttributeNS(). |
| } |
| |
| |
| /** |
| * Set an attribute in the DOM. Simple redirect to compress code. |
| * |
| * @param {Element} node Element to interrogate. |
| * @param {string} name Name of parameter to set. |
| * @param {string|number} value Set attribute to this value. |
| */ |
| function domSetAttribute(node, name, value) { |
| node.setAttribute(name, value); |
| } |
| |
| /** |
| * Remove an attribute from the DOM. Simple redirect to compress code. |
| * |
| * @param {Element} node Element to interrogate. |
| * @param {string} name Name of parameter to remove. |
| */ |
| function domRemoveAttribute(node, name) { |
| node.removeAttribute(name); |
| } |
| |
| /** |
| * Clone a node in the DOM. |
| * |
| * @param {Node} node Node to clone. |
| * @return {Node} Cloned node. |
| */ |
| function domCloneNode(node) { |
| return node.cloneNode(true); |
| // NOTE(mesch): we never so far wanted to use cloneNode(false), |
| // hence the default. |
| } |
| |
| /** |
| * Clone a element in the DOM. |
| * |
| * @param {Element} element Element to clone. |
| * @return {Element} Cloned element. |
| */ |
| function domCloneElement(element) { |
| return /** @type {Element} */(domCloneNode(element)); |
| } |
| |
| /** |
| * Returns the document owner of the given element. In particular, |
| * returns window.document if node is null or the browser does not |
| * support ownerDocument. If the node is a document itself, returns |
| * itself. |
| * |
| * @param {Node|null|undefined} node The node whose ownerDocument is required. |
| * @returns {Document} The owner document or window.document if unsupported. |
| */ |
| function ownerDocument(node) { |
| if (!node) { |
| return document; |
| } else if (node.nodeType == DOM_DOCUMENT_NODE) { |
| return /** @type Document */(node); |
| } else { |
| return node.ownerDocument || document; |
| } |
| } |
| |
| /** |
| * Creates a new text node in the given document. |
| * |
| * @param {Document} doc Target document. |
| * @param {string} text Text composing new text node. |
| * @return {Text} Newly constructed text node. |
| */ |
| function domCreateTextNode(doc, text) { |
| return doc.createTextNode(text); |
| } |
| |
| /** |
| * Appends a new child to the specified (parent) node. |
| * |
| * @param {Element} node Parent element. |
| * @param {Node} child Child node to append. |
| * @return {Node} Newly appended node. |
| */ |
| function domAppendChild(node, child) { |
| return node.appendChild(child); |
| } |
| |
| /** |
| * Sets display to default. |
| * |
| * @param {Element} node The dom element to manipulate. |
| */ |
| function displayDefault(node) { |
| node.style[CSS_display] = ''; |
| } |
| |
| /** |
| * Sets display to none. Doing this as a function saves a few bytes for |
| * the 'style.display' property and the 'none' literal. |
| * |
| * @param {Element} node The dom element to manipulate. |
| */ |
| function displayNone(node) { |
| node.style[CSS_display] = 'none'; |
| } |
| |
| |
| /** |
| * Sets position style attribute to absolute. |
| * |
| * @param {Element} node The dom element to manipulate. |
| */ |
| function positionAbsolute(node) { |
| node.style[CSS_position] = 'absolute'; |
| } |
| |
| |
| /** |
| * Inserts a new child before a given sibling. |
| * |
| * @param {Node} newChild Node to insert. |
| * @param {Node} oldChild Sibling node. |
| * @return {Node} Reference to new child. |
| */ |
| function domInsertBefore(newChild, oldChild) { |
| return oldChild.parentNode.insertBefore(newChild, oldChild); |
| } |
| |
| /** |
| * Replaces an old child node with a new child node. |
| * |
| * @param {Node} newChild New child to append. |
| * @param {Node} oldChild Old child to remove. |
| * @return {Node} Replaced node. |
| */ |
| function domReplaceChild(newChild, oldChild) { |
| return oldChild.parentNode.replaceChild(newChild, oldChild); |
| } |
| |
| /** |
| * Removes a node from the DOM. |
| * |
| * @param {Node} node The node to remove. |
| * @return {Node} The removed node. |
| */ |
| function domRemoveNode(node) { |
| return domRemoveChild(node.parentNode, node); |
| } |
| |
| /** |
| * Remove a child from the specified (parent) node. |
| * |
| * @param {Node} node Parent element. |
| * @param {Node} child Child node to remove. |
| * @return {Node} Removed node. |
| */ |
| function domRemoveChild(node, child) { |
| return node.removeChild(child); |
| } |
| |
| |
| /** |
| * Trim whitespace from begin and end of string. |
| * |
| * @see testStringTrim(); |
| * |
| * @param {string} str Input string. |
| * @return {string} Trimmed string. |
| */ |
| function stringTrim(str) { |
| return stringTrimRight(stringTrimLeft(str)); |
| } |
| |
| /** |
| * Trim whitespace from beginning of string. |
| * |
| * @see testStringTrimLeft(); |
| * |
| * @param {string} str Input string. |
| * @return {string} Trimmed string. |
| */ |
| function stringTrimLeft(str) { |
| return str.replace(/^\s+/, ""); |
| } |
| |
| /** |
| * Trim whitespace from end of string. |
| * |
| * @see testStringTrimRight(); |
| * |
| * @param {string} str Input string. |
| * @return {string} Trimmed string. |
| */ |
| function stringTrimRight(str) { |
| return str.replace(/\s+$/, ""); |
| } |