# Namespace goog.dom

code »

## Classes

goog.dom.DomHelper
  Create an instance of a DOM helper with a new document object.

## Enumerations

goog.dom.BrowserFeature
  Enum of browser capabilities.
goog.dom.NodeType
  Constants for the nodeType attribute in the Node interface.
goog.dom.TagName
  Enum of all html tag names specified by the W3C HTML4.01 and HTML5 specifications.

Show:Public Protected Private

## Type Definitions

code »goog.dom.Appendable : `(Object|string|Array|NodeList)`
Typedef for use with goog.dom.createDom and goog.dom.append.

## Global Functions

code »goog.dom.$ ( element ) ⇒ `Element`
Deprecated: Use `goog.dom.getElement` instead.

Alias for getElement.

Parameters

element: `(string|Element)`
  Element ID or a DOM node.

Returns

The element with the given ID, or the node passed in.

code »goog.dom.$$ ( opt_tag, opt_class, opt_el ) ⇒ `{length: number}`
Deprecated: Use `goog.dom.getElementsByTagNameAndClass` instead.

Alias for `getElementsByTagNameAndClass`.

Parameters

opt_tag: `?string=`
  Element tag name.
opt_class: `?string=`
  Optional class name.
opt_el: `Element=`
  Optional element to look in.

Returns

Array-like list of elements (only a length property and numerical indices are guaranteed to exist).

code »goog.dom.$dom ( tagName, opt_attributes, var_args ) ⇒ `!Element`
Deprecated: Use `goog.dom.createDom` instead.

Alias for `createDom`.

Parameters

tagName: `string`
  Tag to create.
opt_attributes: `(string|Object)=`
  If object, then a map of name-value pairs for attributes. If a string, then this is the className of the new element.
var_args: `...(Object|string|Array|NodeList)`
  Further DOM nodes or strings for text nodes. If one of the var_args is an array, its children will be added as childNodes instead.

Returns

Reference to a DOM node.

code »goog.dom.append ( parent, var_args )

Appends a node with text or other nodes.

Parameters

parent: `!Node`
  The node to append nodes to.
var_args: `...goog.dom.Appendable`
  The things to append to the node. If this is a Node it is appended as is. If this is a string then a text node is appended. If this is an array like object then fields 0 to length - 1 are appended.

code »goog.dom.appendChild ( parent, child )

Appends a child to a node.

Parameters

parent: `Node`
  Parent.
child: `Node`
  Child.

code »goog.dom.append_ ( doc, parent, args, startIndex )

Appends a node with text or other nodes.

Parameters

doc: `!Document`
  The document to create new nodes in.
parent: `!Node`
  The node to append nodes to.
args: `!Arguments`
  The values to add. See `goog.dom.append`.
startIndex: `number`
  The index of the array to start from.

code »goog.dom.canHaveChildren ( node ) ⇒ `boolean`

Determines if the given node can contain children, intended to be used for HTML generation. IE natively supports node.canHaveChildren but has inconsistent behavior. Prior to IE8 the base tag allows children and in IE9 all nodes return true for canHaveChildren. In practice all non-IE browsers allow you to add children to any node, but the behavior is inconsistent:

       var a = document.createElement('br');
       a.appendChild(document.createTextNode('foo'));
       a.appendChild(document.createTextNode('bar'));
       console.log(a.childNodes.length);  // 2
       console.log(a.innerHTML);  // Chrome: "", IE9: "foobar", FF3.5: "foobar"

For more information, see: http://dev.w3.org/html5/markup/syntax.html#syntax-elements TODO(user): Rename shouldAllowChildren() ?

Parameters

node: `Node`
  The node to check.

Returns

Whether the node can contain children.

code »goog.dom.canUseQuerySelector_ ( parent ) ⇒ `boolean`

Prefer the standardized (http://www.w3.org/TR/selectors-api/), native and fast W3C Selectors API.

Parameters

parent: `!(Element|Document)`
  The parent document object.

Returns

whether or not we can use parent.querySelector* APIs.

code »goog.dom.compareNodeOrder ( node1, node2 ) ⇒ `number`

Compares the document order of two nodes, returning 0 if they are the same node, a negative number if node1 is before node2, and a positive number if node2 is before node1. Note that we compare the order the tags appear in the document so in the tree text the B node is considered to be before the I node.

Parameters

node1: `Node`
  The first node to compare.
node2: `Node`
  The second node to compare.

Returns

0 if the nodes are the same node, a negative number if node1 is before node2, and a positive number if node2 is before node1.

code »goog.dom.compareParentsDescendantNodeIe_ ( textNode, node ) ⇒ `number`

Utility function to compare the position of two nodes, when `textNode`'s parent is an ancestor of `node`. If this entry condition is not met, this function will attempt to reference a null object.

Parameters

textNode: `Node`
  The textNode to compare.
node: `Node`
  The node to compare.

Returns

-1 if node is before textNode, +1 otherwise.

code »goog.dom.compareSiblingOrder_ ( node1, node2 ) ⇒ `number`

Utility function to compare the position of two nodes known to be non-equal siblings.

Parameters

node1: `Node`
  The first node to compare.
node2: `Node`
  The second node to compare.

Returns

-1 if node1 is before node2, +1 otherwise.

code »goog.dom.contains ( parent, descendant ) ⇒ `boolean`

Whether a node contains another node.

Parameters

parent: `Node`
  The node that should contain the other node.
descendant: `Node`
  The node to test presence of.

Returns

Whether the parent node contains the descendent node.

code »goog.dom.createDom ( tagName, opt_attributes, var_args ) ⇒ `!Element`

Returns a dom node with a set of attributes. This function accepts varargs for subsequent nodes to be added. Subsequent nodes will be added to the first node as childNodes. So: `createDom('div', null, createDom('p'), createDom('p'));` would return a div with two child paragraphs

Parameters

tagName: `string`
  Tag to create.
opt_attributes: `(Object|Array.<string>|string)=`
  If object, then a map of name-value pairs for attributes. If a string, then this is the className of the new element. If an array, the elements will be joined together as the className of the new element.
var_args: `...(Object|string|Array|NodeList)`
  Further DOM nodes or strings for text nodes. If one of the var_args is an array or NodeList,i its elements will be added as childNodes instead.

Returns

Reference to a DOM node.

code »goog.dom.createDom_ ( doc, args ) ⇒ `!Element`

Helper for `createDom`.

Parameters

doc: `!Document`
  The document to create the DOM in.
args: `!Arguments`
  Argument object passed from the callers. See `goog.dom.createDom` for details.

Returns

Reference to a DOM node.

code »goog.dom.createElement ( name ) ⇒ `!Element`

Creates a new element.

Parameters

name: `string`
  Tag name.

Returns

The new element.

code »goog.dom.createTable ( rows, columns, opt_fillWithNbsp ) ⇒ `!Element`

Create a table.

Parameters

rows: `number`
  The number of rows in the table. Must be >= 1.
columns: `number`
  The number of columns in the table. Must be >= 1.
opt_fillWithNbsp: `boolean=`
  If true, fills table entries with nsbps.

Returns

The created table.

code »goog.dom.createTable_ ( doc, rows, columns, fillWithNbsp ) ⇒ `!Element`

Create a table.

Parameters

doc: `!Document`
  Document object to use to create the table.
rows: `number`
  The number of rows in the table. Must be >= 1.
columns: `number`
  The number of columns in the table. Must be >= 1.
fillWithNbsp: `boolean`
  If true, fills table entries with nsbps.

Returns

The created table.

code »goog.dom.createTextNode ( content ) ⇒ `!Text`

Creates a new text node.

Parameters

content: `(number|string)`
  Content.

Returns

The new text node.

code »goog.dom.findCommonAncestor ( var_args ) ⇒ `Node`

Find the deepest common ancestor of the given nodes.

Parameters

var_args: `...Node`
  The nodes to find a common ancestor of.

Returns

The common ancestor of the nodes, or null if there is none. null will only be returned if two or more of the nodes are from different documents.

code »goog.dom.findNode ( root, p ) ⇒ `(Node|undefined)`

Finds the first descendant node that matches the filter function, using a depth first search. This function offers the most general purpose way of finding a matching element. You may also wish to consider `goog.dom.query` which can express many matching criteria using CSS selector expressions. These expressions often result in a more compact representation of the desired result.

Parameters

root: `Node`
  The root of the tree to search.
p: `function(Node): boolean`
  The filter function.

Returns

The found node or undefined if none is found.

code »goog.dom.findNodes ( root, p ) ⇒ `!Array`

Finds all the descendant nodes that match the filter function, using a a depth first search. This function offers the most general-purpose way of finding a set of matching elements. You may also wish to consider `goog.dom.query` which can express many matching criteria using CSS selector expressions. These expressions often result in a more compact representation of the desired result.

Parameters

root: `Node`
  The root of the tree to search.
p: `function(Node): boolean`
  The filter function.

Returns

The found nodes or an empty array if none are found.

code »goog.dom.findNodes_ ( root, p, rv, findOne ) ⇒ `boolean`

Finds the first or all the descendant nodes that match the filter function, using a depth first search.

Parameters

root: `Node`
  The root of the tree to search.
p: `function(Node): boolean`
  The filter function.
rv: `!Array`
  The found nodes are added to this array.
findOne: `boolean`
  If true we exit after the first found node.

Returns

Whether the search is complete or not. True in case findOne is true and the node is found. False otherwise.

code »goog.dom.flattenElement ( element ) ⇒ `(Element|undefined)`

Flattens an element. That is, removes it and replace it with its children. Does nothing if the element is not in the document.

Parameters

element: `Element`
  The element to flatten.

Returns

The original element, detached from the document tree, sans children; or undefined, if the element was not in the document to begin with.

code »goog.dom.getActiveElement ( doc ) ⇒ `Element`

Determines the active element in the given document.

Parameters

doc: `Document`
  The document to look in.

Returns

The active element.

code »goog.dom.getAncestor ( element, matcher, opt_includeNode, opt_maxSearchSteps ) ⇒ `Node`

Walks up the DOM hierarchy returning the first ancestor that passes the matcher function.

Parameters

element: `Node`
  The DOM node to start with.
matcher: `function(Node): boolean`
  A function that returns true if the passed node matches the desired criteria.
opt_includeNode: `boolean=`
  If true, the node itself is included in the search (the first call to the matcher will pass startElement as the node to test).
opt_maxSearchSteps: `number=`
  Maximum number of levels to search up the dom.

Returns

DOM node that matched the matcher, or null if there was no match.

code »goog.dom.getAncestorByClass ( element, className ) ⇒ `Element`

Walks up the DOM hierarchy returning the first ancestor that has the passed class name. If the passed element matches the specified criteria, the element itself is returned.

Parameters

element: `Node`
  The DOM node to start with.
className: `string`
  The class name to match.

Returns

The first ancestor that matches the passed criteria, or null if none match.

code »goog.dom.getAncestorByTagNameAndClass ( element, opt_tag, opt_class ) ⇒ `Element`

Walks up the DOM hierarchy returning the first ancestor that has the passed tag name and/or class name. If the passed element matches the specified criteria, the element itself is returned.

Parameters

element: `Node`
  The DOM node to start with.
opt_tag: `?(goog.dom.TagName|string)=`
  The tag name to match (or null/undefined to match only based on class name).
opt_class: `?string=`
  The class name to match (or null/undefined to match only based on tag name).

Returns

The first ancestor that matches the passed criteria, or null if no match is found.

code »goog.dom.getChildren ( element ) ⇒ `!(Array|NodeList)`

Returns an array containing just the element children of the given element.

Parameters

element: `Element`
  The element whose element children we want.

Returns

An array or array-like list of just the element children of the given element.

code »goog.dom.getDocument ( ) ⇒ `!Document`

Gets the document object being used by the dom library.

Returns

Document object.

code »goog.dom.getDocumentHeight ( ) ⇒ `number`

Calculates the height of the document.

Returns

The height of the current document.

code »goog.dom.getDocumentHeight_ ( win ) ⇒ `number`

Calculates the height of the document of the given window. Function code copied from the opensocial gadget api: gadgets.window.adjustHeight(opt_height)

Parameters

win: `Window`
  The window whose document height to retrieve.

Returns

The height of the document of the given window.

code »goog.dom.getDocumentScroll ( ) ⇒ `!goog.math.Coordinate`

Gets the document scroll distance as a coordinate object.

Returns

Object with values 'x' and 'y'.

code »goog.dom.getDocumentScrollElement ( ) ⇒ `!Element`

Gets the document scroll element.

Returns

Scrolling element.

code »goog.dom.getDocumentScrollElement_ ( doc ) ⇒ `!Element`

Helper for `getDocumentScrollElement`.

Parameters

doc: `!Document`
  The document to get the scroll element for.

Returns

Scrolling element.

code »goog.dom.getDocumentScroll_ ( doc ) ⇒ `!goog.math.Coordinate`

Helper for `getDocumentScroll`.

Parameters

doc: `!Document`
  The document to get the scroll for.

Returns

Object with values 'x' and 'y'.

code »goog.dom.getDomHelper ( opt_element ) ⇒ `!goog.dom.DomHelper`

Gets the DomHelper object for the document where the element resides.

Parameters

opt_element: `(Node|Window)=`
  If present, gets the DomHelper for this element.

Returns

The DomHelper.

code »goog.dom.getElement ( element ) ⇒ `Element`

Gets an element from the current document by element id. If an Element is passed in, it is returned.

Parameters

element: `(string|Element)`
  Element ID or a DOM node.

Returns

The element with the given ID, or the node passed in.

code »goog.dom.getElementByClass ( className, opt_el ) ⇒ `Element`

Returns the first element with the provided className.

Parameters

className: `string`
  the name of the class to look for.
opt_el: `(Element|Document)=`
  Optional element to look in.

Returns

The first item with the class name provided.

code »goog.dom.getElementHelper_ ( doc, element ) ⇒ `Element`

Gets an element by id from the given document (if present). If an element is given, it is returned.

Parameters

doc
element: `(string|Element)`
  Element ID or a DOM node.

Returns

The resulting element.

code »goog.dom.getElementsByClass ( className, opt_el ) ⇒ `{length: number}`

Returns a static, array-like list of the elements with the provided className.

Parameters

className: `string`
  the name of the class to look for.
opt_el: `(Document|Element)=`
  Optional element to look in.

Returns

The items found with the class name provided.

code »goog.dom.getElementsByTagNameAndClass ( opt_tag, opt_class, opt_el ) ⇒ `{length: number}`

Looks up elements by both tag and class name, using browser native functions (`querySelectorAll`, `getElementsByTagName` or `getElementsByClassName`) where possible. This function is a useful, if limited, way of collecting a list of DOM elements with certain characteristics. `goog.dom.query` offers a more powerful and general solution which allows matching on CSS3 selector expressions, but at increased cost in code size. If all you need is particular tags belonging to a single class, this function is fast and sleek. Note that tag names are case sensitive in the SVG namespace, and this function converts opt_tag to uppercase for comparisons. For queries in the SVG namespace you should use querySelector or querySelectorAll instead. https://bugzilla.mozilla.org/show_bug.cgi?id=963870 https://bugs.webkit.org/show_bug.cgi?id=83438

Parameters

opt_tag: `?string=`
  Element tag name.
opt_class: `?string=`
  Optional class name.
opt_el: `(Document|Element)=`
  Optional element to look in.

Returns

Array-like list of elements (only a length property and numerical indices are guaranteed to exist).

code »goog.dom.getElementsByTagNameAndClass_ ( doc, opt_tag, opt_class, opt_el ) ⇒ `{length: number}`

Helper for `getElementsByTagNameAndClass`.

Parameters

doc: `!Document`
  The document to get the elements in.
opt_tag: `?string=`
  Element tag name.
opt_class: `?string=`
  Optional class name.
opt_el: `(Document|Element)=`
  Optional element to look in.

Returns

Array-like list of elements (only a length property and numerical indices are guaranteed to exist).

code »goog.dom.getFirstElementChild ( node ) ⇒ `Element`

Returns the first child node that is an element.

Parameters

node: `Node`
  The node to get the first child element of.

Returns

The first child node of `node` that is an element.

code »goog.dom.getFrameContentDocument ( frame ) ⇒ `!Document`

Cross-browser function for getting the document element of a frame or iframe.

Parameters

frame: `Element`
  Frame element.

Returns

The frame content document.

code »goog.dom.getFrameContentWindow ( frame ) ⇒ `Window`

Cross-browser function for getting the window of a frame or iframe.

Parameters

frame: `Element`
  Frame element.

Returns

The window associated with the given frame.

code »goog.dom.getLastElementChild ( node ) ⇒ `Element`

Returns the last child node that is an element.

Parameters

node: `Node`
  The node to get the last child element of.

Returns

The last child node of `node` that is an element.

code »goog.dom.getNextElementNode_ ( node, forward ) ⇒ `Element`

Returns the first node that is an element in the specified direction, starting with `node`.

Parameters

node: `Node`
  The node to get the next element from.
forward: `boolean`
  Whether to look forwards or backwards.

Returns

The first element.

code »goog.dom.getNextElementSibling ( node ) ⇒ `Element`

Returns the first next sibling that is an element.

Parameters

node: `Node`
  The node to get the next sibling element of.

Returns

The next sibling of `node` that is an element.

code »goog.dom.getNextNode ( node ) ⇒ `Node`

Returns the next node in source order from the given node.

Parameters

node: `Node`
  The node.

Returns

The next node in the DOM tree, or null if this was the last node.

code »goog.dom.getNodeAtOffset ( parent, offset, opt_result ) ⇒ `Node`

Returns the node at a given offset in a parent node. If an object is provided for the optional third parameter, the node and the remainder of the offset will stored as properties of this object.

Parameters

parent: `Node`
  The parent node.
offset: `number`
  The offset into the parent node.
opt_result: `Object=`
  Object to be used to store the return value. The return value will be stored in the form {node: Node, remainder: number} if this object is provided.

Returns

The node at the given offset.

code »goog.dom.getNodeTextLength ( node ) ⇒ `number`

Returns the text length of the text contained in a node, without markup. This is equivalent to the selection length if the node was selected, or the number of cursor movements to traverse the node. Images & BRs take one space. New lines are ignored.

Parameters

node: `Node`
  The node whose text content length is being calculated.

Returns

The length of `node`'s text content.

code »goog.dom.getNodeTextOffset ( node, opt_offsetParent ) ⇒ `number`

Returns the text offset of a node relative to one of its ancestors. The text length is the same as the length calculated by goog.dom.getNodeTextLength.

Parameters

node: `Node`
  The node whose offset is being calculated.
opt_offsetParent: `Node=`
  The node relative to which the offset will be calculated. Defaults to the node's owner document's body.

Returns

The text offset.

code »goog.dom.getOuterHtml ( element ) ⇒ `string`

Gets the outerHTML of a node, which islike innerHTML, except that it actually contains the HTML of the node itself.

Parameters

element: `Element`
  The element to get the HTML of.

Returns

The outerHTML of the given element.

code »goog.dom.getOwnerDocument ( node ) ⇒ `!Document`

Returns the owner document for a node.

Parameters

node: `(Node|Window)`
  The node to get the document for.

Returns

The document owning the node.

code »goog.dom.getPageScroll ( opt_window ) ⇒ `!goog.math.Coordinate`
Deprecated: Use `goog.dom.getDocumentScroll` instead.

Gets the page scroll distance as a coordinate object.

Parameters

opt_window: `Window=`
  Optional window element to test.

Returns

Object with values 'x' and 'y'.

code »goog.dom.getParentElement ( element ) ⇒ `Element`

Returns an element's parent, if it's an Element.

Parameters

element: `Element`
  The DOM element.

Returns

The parent, or null if not an Element.

code »goog.dom.getPixelRatio ( ) ⇒ `number`

Gives the current devicePixelRatio. By default, this is the value of window.devicePixelRatio (which should be preferred if present). If window.devicePixelRatio is not present, the ratio is calculated with window.matchMedia, if present. Otherwise, gives 1.0. Some browsers (including Chrome) consider the browser zoom level in the pixel ratio, so the value may change across multiple calls.

Returns

The number of actual pixels per virtual pixel.

code »goog.dom.getPreviousElementSibling ( node ) ⇒ `Element`

Returns the first previous sibling that is an element.

Parameters

node: `Node`
  The node to get the previous sibling element of.

Returns

The first previous sibling of `node` that is an element.

code »goog.dom.getPreviousNode ( node ) ⇒ `Node`

Returns the previous node in source order from the given node.

Parameters

node: `Node`
  The node.

Returns

The previous node in the DOM tree, or null if this was the first node.

code »goog.dom.getRawTextContent ( node ) ⇒ `string`

Returns the text content of the current node, without markup. Unlike `getTextContent` this method does not collapse whitespaces or normalize lines breaks.

Parameters

node: `Node`
  The node from which we are getting content.

Returns

The raw text content.

code »goog.dom.getRequiredElement ( id ) ⇒ `!Element`

Gets an element by id, asserting that the element is found. This is used when an element is expected to exist, and should fail with an assertion error if it does not (if assertions are enabled).

Parameters

id: `string`
  Element ID.

Returns

The element with the given ID, if it exists.

code »goog.dom.getRequiredElementByClass ( className, opt_root ) ⇒ `!Element`

Ensures an element with the given className exists, and then returns the first element with the provided className.

Parameters

className: `string`
  the name of the class to look for.
opt_root: `(!Element|!Document)=`
  Optional element or document to look in.

Returns

The first item with the class name provided.

Throws

`goog.asserts.AssertionError`
  Thrown if no element is found.

code »goog.dom.getRequiredElementHelper_ ( doc, id ) ⇒ `!Element`

Helper function for getRequiredElementHelper functions, both static and on DomHelper. Asserts the element with the given id exists.

Parameters

doc
id

Returns

The element with the given ID, if it exists.

code »goog.dom.getTextContent ( node ) ⇒ `string`

Returns the text content of the current node, without markup and invisible symbols. New lines are stripped and whitespace is collapsed, such that each character would be visible. In browsers that support it, innerText is used. Other browsers attempt to simulate it via node traversal. Line breaks are canonicalized in IE.

Parameters

node: `Node`
  The node from which we are getting content.

Returns

The text content.

code »goog.dom.getTextContent_ ( node, buf, normalizeWhitespace )

Recursive support function for text content retrieval.

Parameters

node: `Node`
  The node from which we are getting content.
buf: `Array`
  string buffer.
normalizeWhitespace: `boolean`
  Whether to normalize whitespace.

code »goog.dom.getViewportSize ( opt_window ) ⇒ `!goog.math.Size`

Gets the dimensions of the viewport. Gecko Standards mode: docEl.clientWidth Width of viewport excluding scrollbar. win.innerWidth Width of viewport including scrollbar. body.clientWidth Width of body element. docEl.clientHeight Height of viewport excluding scrollbar. win.innerHeight Height of viewport including scrollbar. body.clientHeight Height of document. Gecko Backwards compatible mode: docEl.clientWidth Width of viewport excluding scrollbar. win.innerWidth Width of viewport including scrollbar. body.clientWidth Width of viewport excluding scrollbar. docEl.clientHeight Height of document. win.innerHeight Height of viewport including scrollbar. body.clientHeight Height of viewport excluding scrollbar. IE6/7 Standards mode: docEl.clientWidth Width of viewport excluding scrollbar. win.innerWidth Undefined. body.clientWidth Width of body element. docEl.clientHeight Height of viewport excluding scrollbar. win.innerHeight Undefined. body.clientHeight Height of document element. IE5 + IE6/7 Backwards compatible mode: docEl.clientWidth 0. win.innerWidth Undefined. body.clientWidth Width of viewport excluding scrollbar. docEl.clientHeight 0. win.innerHeight Undefined. body.clientHeight Height of viewport excluding scrollbar. Opera 9 Standards and backwards compatible mode: docEl.clientWidth Width of viewport excluding scrollbar. win.innerWidth Width of viewport including scrollbar. body.clientWidth Width of viewport excluding scrollbar. docEl.clientHeight Height of document. win.innerHeight Height of viewport including scrollbar. body.clientHeight Height of viewport excluding scrollbar. WebKit: Safari 2 docEl.clientHeight Same as scrollHeight. docEl.clientWidth Same as innerWidth. win.innerWidth Width of viewport excluding scrollbar. win.innerHeight Height of the viewport including scrollbar. frame.innerHeight Height of the viewport exluding scrollbar. Safari 3 (tested in 522) docEl.clientWidth Width of viewport excluding scrollbar. docEl.clientHeight Height of viewport excluding scrollbar in strict mode. body.clientHeight Height of viewport excluding scrollbar in quirks mode.

Parameters

opt_window: `Window=`
  Optional window element to test.

Returns

Object with values 'width' and 'height'.

code »goog.dom.getViewportSize_ ( win ) ⇒ `!goog.math.Size`

Helper for `getViewportSize`.

Parameters

win: `Window`
  The window to get the view port size for.

Returns

Object with values 'width' and 'height'.

code »goog.dom.getWindow ( opt_doc ) ⇒ `!Window`

Gets the window object associated with the given document.

Parameters

opt_doc: `Document=`
  Document object to get window for.

Returns

The window associated with the given document.

code »goog.dom.getWindow_ ( doc ) ⇒ `!Window`

Helper for `getWindow`.

Parameters

doc: `!Document`
  Document object to get window for.

Returns

The window associated with the given document.

code »goog.dom.hasNonZeroBoundingRect_ ( element ) ⇒ `boolean`

Returns true if the element has a bounding rectangle that would be visible (i.e. its width and height are greater than zero).

Parameters

element: `Element`
  Element to check.

Returns

Whether the element has a non-zero bounding rectangle.

code »goog.dom.hasSpecifiedTabIndex_ ( element ) ⇒ `boolean`

Returns true if the element has a specified tab index.

Parameters

element: `Element`
  Element to check.

Returns

Whether the element has a specified tab index.

code »goog.dom.htmlToDocumentFragment ( htmlString ) ⇒ `!Node`

Converts an HTML string into a document fragment. The string must be sanitized in order to avoid cross-site scripting. For example `goog.dom.htmlToDocumentFragment('&lt;img src=x onerror=alert(0)&gt;')` triggers an alert in all browsers, even if the returned document fragment is thrown away immediately.

Parameters

htmlString: `string`
  The HTML string to convert.

Returns

The resulting document fragment.

code »goog.dom.htmlToDocumentFragment_ ( doc, htmlString ) ⇒ `!Node`

Helper for `htmlToDocumentFragment`.

Parameters

doc: `!Document`
  The document.
htmlString: `string`
  The HTML string to convert.

Returns

The resulting document fragment.

code »goog.dom.insertChildAt ( parent, child, index )

Insert a child at a given index. If index is larger than the number of child nodes that the parent currently has, the node is inserted as the last child node.

Parameters

parent: `Element`
  The element into which to insert the child.
child: `Node`
  The element to insert.
index: `number`
  The index at which to insert the new child node. Must not be negative.

code »goog.dom.insertSiblingAfter ( newNode, refNode )

Inserts a new node after an existing reference node (i.e. as the next sibling). If the reference node has no parent, then does nothing.

Parameters

newNode: `Node`
  Node to insert.
refNode: `Node`
  Reference node to insert after.

code »goog.dom.insertSiblingBefore ( newNode, refNode )

Inserts a new node before an existing reference node (i.e. as the previous sibling). If the reference node has no parent, then does nothing.

Parameters

newNode: `Node`
  Node to insert.
refNode: `Node`
  Reference node to insert before.

code »goog.dom.isCss1CompatMode ( ) ⇒ `boolean`

Returns true if the browser is in "CSS1-compatible" (standards-compliant) mode, false otherwise.

Returns

True if in CSS1-compatible mode.

code »goog.dom.isCss1CompatMode_ ( doc ) ⇒ `boolean`

Returns true if the browser is in "CSS1-compatible" (standards-compliant) mode, false otherwise.

Parameters

doc: `Document`
  The document to check.

Returns

True if in CSS1-compatible mode.

code »goog.dom.isElement ( obj ) ⇒ `boolean`

Whether the object looks like an Element.

Parameters

obj: `?`
  The object being tested for Element likeness.

Returns

Whether the object looks like an Element.

code »goog.dom.isFocusable ( element ) ⇒ `boolean`

Returns true if the element can be focused, i.e. it has a tab index that allows it to receive keyboard focus (tabIndex >= 0), or it is an element that natively supports keyboard focus.

Parameters

element: `Element`
  Element to check.

Returns

Whether the element allows keyboard focus.

code »goog.dom.isFocusableTabIndex ( element ) ⇒ `boolean`

Returns true if the element has a tab index that allows it to receive keyboard focus (tabIndex >= 0), false otherwise. Note that some elements natively support keyboard focus, even if they have no tab index.

Parameters

element: `Element`
  Element to check.

Returns

Whether the element has a tab index that allows keyboard focus.

code »goog.dom.isNodeLike ( obj ) ⇒ `boolean`

Whether the object looks like a DOM node.

Parameters

obj: `?`
  The object being tested for node likeness.

Returns

Whether the object looks like a DOM node.

code »goog.dom.isNodeList ( val ) ⇒ `boolean`

Returns true if the object is a `NodeList`. To qualify as a NodeList, the object must have a numeric length property and an item function (which has type 'string' on IE for some reason).

Parameters

val: `Object`
  Object to test.

Returns

Whether the object is a NodeList.

code »goog.dom.isTabIndexFocusable_ ( element ) ⇒ `boolean`

Returns true if the element's tab index allows the element to be focused.

Parameters

element: `Element`
  Element to check.

Returns

Whether the element's tab index allows focus.

code »goog.dom.isWindow ( obj ) ⇒ `boolean`

Returns true if the specified value is a Window object. This includes the global window for HTML pages, and iframe windows.

Parameters

obj: `?`
  Variable to test.

Returns

Whether the variable is a window.

code »goog.dom.matchesPixelRatio_ ( pixelRatio ) ⇒ `number`

Calculates a mediaQuery to check if the current device supports the given actual to virtual pixel ratio.

Parameters

pixelRatio: `number`
  The ratio of actual pixels to virtual pixels.

Returns

pixelRatio if applicable, otherwise 0.

code »goog.dom.nativelySupportsFocus_ ( element ) ⇒ `boolean`

Returns true if the element is focusable even when tabIndex is not set.

Parameters

element: `Element`
  Element to check.

Returns

Whether the element natively supports focus.

code »goog.dom.removeChildren ( node )

Removes all the child nodes on a DOM node.

Parameters

node: `Node`
  Node to remove children from.

code »goog.dom.removeNode ( node ) ⇒ `Node`

Removes a node from its parent.

Parameters

node: `Node`
  The node to remove.

Returns

The node removed if removed; else, null.

code »goog.dom.replaceNode ( newNode, oldNode )

Replaces a node in the DOM tree. Will do nothing if `oldNode` has no parent.

Parameters

newNode: `Node`
  Node to insert.
oldNode: `Node`
  Node to replace.

code »goog.dom.setFocusableTabIndex ( element, enable )

Enables or disables keyboard focus support on the element via its tab index. Only elements for which `goog.dom.isFocusableTabIndex` returns true (or elements that natively support keyboard focus, like form elements) can receive keyboard focus. See http://go/tabindex for more info.

Parameters

element: `Element`
  Element whose tab index is to be changed.
enable: `boolean`
  Whether to set or remove a tab index on the element that supports keyboard focus.

code »goog.dom.setProperties ( element, properties )

Sets multiple properties on a node.

Parameters

element: `Element`
  DOM node to set properties on.
properties: `Object`
  Hash of property:value pairs.

code »goog.dom.setTextContent ( node, text )

Sets the text content of a node, with cross-browser support.

Parameters

node: `Node`
  The node to change the text content of.
text: `(string|number)`
  The value that should replace the node's content.

## Global Properties

code »goog.dom.COMPAT_MODE_KNOWN_ : `boolean`

Whether we know the compatibility mode at compile time.

code »goog.dom.DIRECT_ATTRIBUTE_MAP_ : `Object`

Map of attributes that should be set using element.setAttribute(key, val) instead of element[key] = val. Used by goog.dom.setProperties.

code »goog.dom.PREDEFINED_TAG_VALUES_ : `Object`

Map of tags which have predefined values with regard to whitespace.

code »goog.dom.TAGS_TO_IGNORE_ : `Object`

Map of tags whose content to ignore when calculating text length.

code »goog.dom.defaultDomHelper_ : `goog.dom.DomHelper`

Cached default DOM helper.

## Compiler Constants

code »goog.dom.ASSUME_QUIRKS_MODE : `boolean`
code »goog.dom.ASSUME_STANDARDS_MODE : `boolean`