Class myfaces._impl._util._Dom

Extends myfaces._impl.core._Runtime.

Defined in: _Dom.js.

Class Summary
Constructor Attributes	Constructor Name and Description
	myfaces._impl._util._Dom() Object singleton collection of dom helper routines (which in later incarnations will get browser specific speed optimizations) Since we have to be as tight as possible we will focus with our dom routines to only the parts which our impl uses.

Method Summary
Method Attributes	Method Name and Description
	byIdOrName(elem) determines to fetch a node from its id or name, the name case only works if the element is unique in its name
	concatCDATABlocks(node) concatenation routine which concats all childnodes of a node which contains a set of CDATA blocks to one big string
	constructor_() standard constructor
	createElement(nodeName, attrs) creates a node upon a given node name
	deleteItem(itemIdToReplace) Simple delete on an existing item
	detach(items) detaches a set of nodes from their parent elements in a browser independend manner
	findAll(rootNode, filter, deepScan) a filtered findAll for subdom treewalking (which uses browser optimizations wherever possible)
	findByTagName(fragment, tagName) determines the number of nodes according to their tagType
	findByTagNames(fragment, tagNames) optimized search for an array of tag names deep scan will always be performed.
	fuzzyFormDetection(elem) fuzzy form detection which tries to determine the form an item has been detached.
	getAttribute(node, attr) cross ported from dojo fetches an attribute from a node
	getFilteredParent(item, filter) A parent walker which uses a filter closure for filtering
	getParent(item, tagName) gets a parent of an item with a given tagname
	getWindowId() fetches the window id for the current request note, this is a preparation method for jsf 2.2
	hasAttribute(node, attr) checks whether the given node has an attribute attached
	insertAfter(item, markup) proper insert before which takes tables into consideration as well as browser deficiencies
	insertBefore(item, markup) proper insert before which takes tables into consideration as well as browser deficiencies
	isDomCompliant() Checks whether the browser is dom compliant.
	nodeIdOrName(elem) node id or name, determines the valid form identifier of a node depending on its uniqueness Usually the id is chosen for an elem, but if the id does not exist we try a name fallback.
	outerHTML(item, markup, preserveFocus,) outerHTML replacement which works cross browserlike but still is speed optimized
	replaceElement(item, evalNode) for performance reasons we work with replaceElement and replaceElements here after measuring performance it has shown that passing down an array instead of a single node makes replaceElement twice as slow, however a single node case is the 95% case
	replaceElements(item, evalNodes) replaces an element with another element or a set of elements
	runScripts(item, xmlData) Run through the given Html item and execute the inline scripts (IE doesn't do this by itself)
	setAttribute(node, attr, val) bugfixing for ie6 which does not cope properly with setAttribute

Class Detail

myfaces._impl._util._Dom()

Object singleton collection of dom helper routines (which in later incarnations will get browser specific speed optimizations) Since we have to be as tight as possible we will focus with our dom routines to only the parts which our impl uses. A jquery like query API would be nice but this would increase up our codebase significantly

This class provides the proper fallbacks for ie8- and Firefox 3.6-

Method Detail

byIdOrName(elem)

determines to fetch a node from its id or name, the name case only works if the element is unique in its name

Parameters:
{String} elem

concatCDATABlocks(node)

concatenation routine which concats all childnodes of a node which contains a set of CDATA blocks to one big string

Parameters:
{Node} node: the node to concat its blocks for

constructor_()

standard constructor

createElement(nodeName, attrs)

creates a node upon a given node name

Parameters:
nodeName: {String} the node name to be created
attrs: {Array} a set of attributes to be set

deleteItem(itemIdToReplace)

Simple delete on an existing item

Parameters:
itemIdToReplace

{Array} detach(items)

detaches a set of nodes from their parent elements in a browser independend manner

Parameters:
{Object} items: the items which need to be detached

Returns:: {Array} an array of nodes with the detached dom nodes

findAll(rootNode, filter, deepScan)

a filtered findAll for subdom treewalking (which uses browser optimizations wherever possible)

Parameters:
{|Node|} rootNode: the rootNode so start the scan
filter: filter closure with the syntax {boolean} filter({Node} node)
deepScan: if set to true or not set at all a deep scan is performed (for form scans it does not make much sense to deeply scan)

findByTagName(fragment, tagName)

determines the number of nodes according to their tagType

Parameters:
{Node} fragment: (Node or fragment) the fragment to be investigated
{String} tagName: the tag name (lowercase) (the normal usecase is false, which means if the element is found only its adjacent elements will be scanned, due to the recursive descension this should work out with elements with different nesting depths but not being parent and child to each other

Returns:: the child elements as array or null if nothing is found

findByTagNames(fragment, tagNames)

optimized search for an array of tag names deep scan will always be performed.

Parameters:
fragment: the fragment which should be searched for
tagNames: an map indx of tag names which have to be found

fuzzyFormDetection(elem)

fuzzy form detection which tries to determine the form an item has been detached. The problem is some Javascript libraries simply try to detach controls by reusing the names of the detached input controls. Most of the times, the name is unique in a jsf scenario, due to the inherent form mapping. One way or the other, we will try to fix that by identifying the proper form over the name We do it in several ways, in case of no form null is returned in case of multiple forms we check all elements with a given name (which we determine out of a name or id of the detached element) and then iterate over them to find whether they are in a form or not. If only one element within a form and a given identifier found then we can pull out and move on We cannot do much further because in case of two identical named elements all checks must fail and the first elements form is served. Note, this method is only triggered in case of the issuer or an ajax request is a detached element, otherwise already existing code has served the correct form. This method was added because of https://issues.apache.org/jira/browse/MYFACES-2599 to support the integration of existing ajax libraries which do heavy dom manipulation on the controls side (Dojos Dijit library for instance).

Parameters:
{Node} elem: - element as source, can be detached, undefined or null

Returns:: either null or a form node if it could be determined TODO move this into extended and replace it with a simpler algorithm

getAttribute(node, attr)

cross ported from dojo fetches an attribute from a node

Parameters:
{String} node: the node
{String} attr: the attribute

Returns:: the attributes value or null

getFilteredParent(item, filter)

A parent walker which uses a filter closure for filtering

Parameters:
{Node} item: the root item to ascend from
{function} filter: the filter closure

getParent(item, tagName)

gets a parent of an item with a given tagname

Parameters:
{Node} item: - child element
{String} tagName: - TagName of parent element

getWindowId()

fetches the window id for the current request note, this is a preparation method for jsf 2.2

hasAttribute(node, attr)

checks whether the given node has an attribute attached

Parameters:
{String|Object} node: the node to search for
{String} attr: the attribute to search for

insertAfter(item, markup)

proper insert before which takes tables into consideration as well as browser deficiencies

Parameters:
item: the node to insert before
markup: the markup to be inserted

insertBefore(item, markup)

proper insert before which takes tables into consideration as well as browser deficiencies

Parameters:
item: the node to insert before
markup: the markup to be inserted

isDomCompliant()

Checks whether the browser is dom compliant. Dom compliant means that it performs the basic dom operations safely without leaking and also is able to perform a native setAttribute operation without freaking out Not dom compliant browsers are all microsoft browsers in quirks mode and ie6 and ie7 to some degree in standards mode and pretty much every browser who cannot create ranges (older mobile browsers etc...) We dont do a full browser detection here because it probably is safer to test for existing features to make an assumption about the browsers capabilities

nodeIdOrName(elem)

node id or name, determines the valid form identifier of a node depending on its uniqueness Usually the id is chosen for an elem, but if the id does not exist we try a name fallback. If the passed element has a unique name we can use that one as subsequent identifier.

Parameters:
{String} elem

outerHTML(item, markup, preserveFocus,)

outerHTML replacement which works cross browserlike but still is speed optimized

Parameters:
item: the item to be replaced
markup: the markup for the replacement
preserveFocus,: tries to preserve the focus within the outerhtml operation if set to true a focus preservation algorithm based on document.activeElement is used to preserve the focus at the exactly same location as it was

replaceElement(item, evalNode)

for performance reasons we work with replaceElement and replaceElements here after measuring performance it has shown that passing down an array instead of a single node makes replaceElement twice as slow, however a single node case is the 95% case

Parameters:
item
evalNode

replaceElements(item, evalNodes)

replaces an element with another element or a set of elements

Parameters:
item: the item to be replaced
evalNodes: the elements

runScripts(item, xmlData)

Run through the given Html item and execute the inline scripts (IE doesn't do this by itself)

Parameters:
{Node} item
xmlData

setAttribute(node, attr, val)

bugfixing for ie6 which does not cope properly with setAttribute

Parameters:
node
attr
val

Classes

Class myfaces._impl._util._Dom