API Preview tool | The Dojo Toolkit

dijit/_base/manager.js

Provides:
- dijit

dijit.WidgetSet

type
```
Function
```

summary

A set of widgets indexed by id. A default instance of this class is
available as `dijit.registry`

example

Create a small list of widgets:

	var ws = new dijit.WidgetSet();
	ws.add(dijit.byId("one"));
 	ws.add(dijit.byId("two"));
	// destroy both:
	ws.forEach(function(w){ w.destroy(); });

example

Using dijit.registry:

	dijit.registry.forEach(function(w){ /* do something */ });

source: [view]
this._hash = {};
this.length = 0;

dijit.WidgetSet.add
- type
```
Function
```
- parameters:
  - widget: (typeof dijit._Widget)
```
Any dijit._Widget subclass.
```
- source: [view]
    if(this._hash[widget.id]){
     throw new Error("Tried to register widget with id==" + widget.id + " but that id is already registered");
    }
    this._hash[widget.id] = widget;
    this.length++;
- summary
```
Add a widget to this list. If a duplicate ID is detected, a error is thrown.
```
dijit.WidgetSet.remove
- type
```
Function
```
- parameters:
  - id: (typeof String)
- source: [view]
    if(this._hash[id]){
     delete this._hash[id];
     this.length--;
    }
- summary
```
Remove a widget from this WidgetSet. Does not destroy the widget; simply
removes the reference.
```

dijit.WidgetSet.forEach

type
```
Function
```

parameters:

func: (typeof Function)

A callback function to run for each item. Is passed the widget, the index
in the iteration, and the full hash, similar to `dojo.forEach`.

thisObj: (typeof Object)
```
An optional scope parameter
```

source: [view]
  thisObj = thisObj || dojo.global;
  var i = 0, id;
  for(id in this._hash){
   func.call(thisObj, this._hash[id], i++, this._hash);
  }
  return this; // dijit.WidgetSet

summary

Call specified function for each widget in this set.

return_summary

Returns self, in order to allow for further chaining.

returns
```
dijit.WidgetSet
```

example

Using the default `dijit.registry` instance:

	dijit.registry.forEach(function(widget){
		console.log(widget.declaredClass);
	});

dijit.WidgetSet.filter

type
```
Function
```

parameters:

filter: (typeof Function)

Callback function to test truthiness. Is passed the widget
reference and the pseudo-index in the object.

thisObj: (typeof Object)

Option scope to use for the filter function.

source: [view]
  thisObj = thisObj || dojo.global;
  var res = new dijit.WidgetSet(), i = 0, id;
  for(id in this._hash){
   var w = this._hash[id];
   if(filter.call(thisObj, w, i++, this._hash)){
    res.add(w);
   }
  }
  return res; // dijit.WidgetSet

summary

Filter down this WidgetSet to a smaller new WidgetSet
Works the same as `dojo.filter` and `dojo.NodeList.filter`

returns
```
dijit.WidgetSet
```

example

Arbitrary: select the odd widgets in this list

	dijit.registry.filter(function(w, i){
		return i % 2 == 0;
	}).forEach(function(w){ /* odd ones */ });

dijit.WidgetSet.byId

type
```
Function
```
parameters:
- id: (typeof String)
source: [view]
return this._hash[id]; // dijit._Widget
summary
```
Find a widget in this list by it's id.
```
returns
```
dijit._Widget
```

example

Test if an id is in a particular WidgetSet

 var ws = new dijit.WidgetSet();
 ws.add(dijit.byId("bar"));
 var t = ws.byId("bar") // returns a widget
 var x = ws.byId("foo"); // returns undefined

dijit.WidgetSet.byClass

type
```
Function
```

parameters:

cls: (typeof String)

The Class to scan for. Full dot-notated string.

source: [view]
  var res = new dijit.WidgetSet(), id, widget;
  for(id in this._hash){
   widget = this._hash[id];
   if(widget.declaredClass == cls){
    res.add(widget);
   }
   }
   return res; // dijit.WidgetSet

summary

Reduce this widgetset to a new WidgetSet of a particular `declaredClass`

returns
```
dijit.WidgetSet
```

example

Find all `dijit.TitlePane`s in a page:

	dijit.registry.byClass("dijit.TitlePane").forEach(function(tp){ tp.close(); });

dijit.WidgetSet.toArray

type
```
Function
```
source: [view]
  var ar = [];
  for(var id in this._hash){
   ar.push(this._hash[id]);
  }
  return ar; // dijit._Widget[]

summary

Convert this WidgetSet into a true Array

returns
```
dijit._Widget[]
```

example

Work with the widget .domNodes in a real Array

	dojo.map(dijit.registry.toArray(), function(w){ return w.domNode; });

dijit.WidgetSet.map

type
```
Function
```
parameters:
- func: (typeof Function)
- thisObj: (typeof Object)
source: [view]
return dojo.map(this.toArray(), func, thisObj); // Array

summary

Create a new Array from this WidgetSet, following the same rules as `dojo.map`

return_summary
```
A new array of the returned values.
```
returns
```
Array
```

example


	var nodes = dijit.registry.map(function(w){ return w.domNode; });

dijit.WidgetSet.every
- type
```
Function
```
- parameters:
  - func: (typeof Function)
```
A callback function run for every widget in this list. Exits loop
when the first false return is encountered.
```
  - thisObj: (typeof Object)
```
Optional scope parameter to use for the callback
```
- source: [view]
    thisObj = thisObj || dojo.global;
    var x = 0, i;
    for(i in this._hash){
     if(!func.call(thisObj, this._hash[i], x++, this._hash)){
      return false; // Boolean
     }
    }
    return true; // Boolean
- summary
```
A synthetic clone of `dojo.every` acting explicitly on this WidgetSet
```
- returns
```
Boolean
```
dijit.WidgetSet.some
- type
```
Function
```
- parameters:
  - func: (typeof Function)
```
A callback function run for every widget in this list. Exits loop
when the first true return is encountered.
```
  - thisObj: (typeof Object)
```
Optional scope parameter to use for the callback
```
- source: [view]
    thisObj = thisObj || dojo.global;
    var x = 0, i;
    for(i in this._hash){
     if(func.call(thisObj, this._hash[i], x++, this._hash)){
      return true; // Boolean
     }
    }
    return false; // Boolean
- summary
```
A synthetic clone of `dojo.some` acting explictly on this WidgetSet
```
- returns
```
Boolean
```
dijit.WidgetSet._hash
- summary
dijit.WidgetSet.length
- summary

dijit.registry

type
```
Object
```
summary
```
A list of widgets on a page.
```
description
```
Is an instance of `dijit.WidgetSet`
```

attr
- summary
hasAttr
- summary
style
- summary
dijit.defaultDuration
- summary
dijit.byId
- type
```
Function
```
- parameters:
  - id: (typeof String|dijit._Widget)
- source: [view]
  return typeof id == "string" ? hash[id] : id; // dijit._Widget
- summary
```
Returns a widget by it's id, or if passed a widget, no-op (like dojo.byId())
```
- returns
```
dijit._Widget
```
dijit.getUniqueId
- type
```
Function
```
- parameters:
  - widgetType: (typeof String)
- source: [view]
    var id;
    do{
     id = widgetType + "_" +
      (widgetType in _widgetTypeCtr ?
       ++_widgetTypeCtr[widgetType] : _widgetTypeCtr[widgetType] = 0);
    }while(hash[id]);
    return dijit._scopeName == "dijit" ? id : dijit._scopeName + "_" + id; // String
- summary
```
Generates a unique id for a given widgetType
```
- returns
```
String
```
dijit.findWidgets
- type
```
Function
```
- parameters:
  - root: (typeof DomNode)
- source: [view]
    var outAry = [];
  
    function getChildrenHelper(root){
     for(var node = root.firstChild; node; node = node.nextSibling){
      if(node.nodeType == 1){
       var widgetId = node.getAttribute("widgetId");
       if(widgetId){
        var widget = hash[widgetId];
        if(widget){ // may be null on page w/multiple dojo's loaded
         outAry.push(widget);
        }
       }else{
        getChildrenHelper(node);
       }
      }
     }
    }
  
    getChildrenHelper(root);
    return outAry;
- summary
```
Search subtree under root returning widgets found.
Doesn't search for nested widgets (ie, widgets inside other widgets).
```
dijit._destroyAll
- type
```
Function
```
- source: [view]
    dijit._curFocus = null;
    dijit._prevFocus = null;
    dijit._activeStack = [];
  
    // Destroy all the widgets, top down
    dojo.forEach(dijit.findWidgets(dojo.body()), function(widget){
     // Avoid double destroy of widgets like Menu that are attached to
     // even though they are logically children of other widgets.
     if(!widget._destroyed){
      if(widget.destroyRecursive){
       widget.destroyRecursive();
      }else if(widget.destroy){
       widget.destroy();
      }
     }
    });
- summary
```
Code to destroy all widgets and do other cleanup on page unload

Clean up focus manager lingering references to widgets and nodes
```
dijit.byNode
- type
```
Function
```
- parameters:
  - node: (typeof DOMNode)
- source: [view]
  return hash[node.getAttribute("widgetId")]; // dijit._Widget
- summary
```
Returns the widget corresponding to the given DOMNode
```
- returns
```
dijit._Widget
```
dijit.getEnclosingWidget
- type
```
Function
```
- parameters:
  - node: (typeof DOMNode)
- source: [view]
    while(node){
     var id = node.getAttribute && node.getAttribute("widgetId");
     if(id){
      return hash[id];
     }
     node = node.parentNode;
    }
    return null;
- summary
```
Returns the widget whose DOM tree contains the specified DOMNode, or null if
the node is not contained within the DOM tree of any widget
```
dijit._isElementShown
- type
```
Function
```
- parameters:
  - elem: (typeof Element)
- source: [view]
    var s = style(elem);
    return (s.visibility != "hidden")
     && (s.visibility != "collapsed")
     && (s.display != "none")
     && (attr(elem, "type") != "hidden");
- summary
dijit.hasDefaultTabStop
- type
```
Function
```
- parameters:
  - elem: (typeof Element)
- source: [view]
    switch(elem.nodeName.toLowerCase()){
     case "a":
      // An w/out a tabindex is only navigable if it has an href
      return hasAttr(elem, "href");
     case "area":
     case "button":
     case "input":
     case "object":
     case "select":
     case "textarea":
      // These are navigable by default
      return true;
     case "iframe":
      // If it's an editor then it's tab navigable.<br>    var body;<br>    try{<br>     // non-IE<br>     var contentDocument = elem.contentDocument;<br>     if("designMode" in contentDocument && contentDocument.designMode == "on"){<br>      return true;<br>     }<br>     body = contentDocument.body;<br>    }catch(e1){<br>     // contentWindow.document isn't accessible within IE7/8<br>     // if the iframe.src points to a foreign url and this<br>     // page contains an element, that could get focus<br>     try{<br>      body = elem.contentWindow.document.body;<br>     }catch(e2){<br>      return false;<br>     }<br>    }<br>    return body.contentEditable == 'true' || (body.firstChild && body.firstChild.contentEditable == 'true');<br>   default:<br>    return elem.contentEditable == 'true';<br>  } </div> <li><em>summary</em><div><pre>Tests if element is tab-navigable even without an explicit tabIndex setting No explicit tabIndex setting, need to investigate node type</pre></div></li></ul></li><li><h4>dijit.isTabNavigable</h4><ul> <li><em>type</em><div><pre>Function</pre></div></li><li><em>parameters:</em> <ul><li>elem: <em>(typeof Element)</em><div></div></li></ul></li><li class="source"><em>source: [<a onclick="tgShow('unique20');">view</a>]</em> <div class="nosho" id="unique20">   if(attr(elem, "disabled")){<br>   return false;<br>  }else if(hasAttr(elem, "tabIndex")){<br>   // Explicit tab index setting<br>   return attr(elem, "tabIndex") >= 0; // boolean<br>  }else{<br>   // No explicit tabIndex setting, so depends on node type<br>   return dijit.hasDefaultTabStop(elem);<br>  } </div> <li><em>summary</em><div><pre>Tests if an element is tab-navigable TODO: convert (and rename method) to return effective tabIndex; will save time in _getTabNavigable()</pre></div></li><li><em>returns</em><div><pre>boolean</pre></div></li></ul></li><li><h4>dijit._getTabNavigable</h4><ul> <li><em>type</em><div><pre>Function</pre></div></li><li><em>parameters:</em> <ul><li>root: <em>(typeof DOMNode)</em><div></div></li></ul></li><li class="source"><em>source: [<a onclick="tgShow('unique21');">view</a>]</em> <div class="nosho" id="unique21">   var first, last, lowest, lowestTabindex, highest, highestTabindex, radioSelected = {};<br>  function radioName(node) {<br>   // If this element is part of a radio button group, return the name for that group.<br>   return node && node.tagName.toLowerCase() == "input" &&<br>    node.type && node.type.toLowerCase() == "radio" &&<br>    node.name && node.name.toLowerCase();<br>  }<br>  var walkTree = function(/*DOMNode*/parent){<br>   dojo.query("> *", parent).forEach(function(child){<br>    // Skip hidden elements, and also non-HTML elements (those in custom namespaces) in IE,<br>    // since show() invokes getAttribute("type"), which crash on VML nodes in IE.<br>    if((dojo.isIE && child.scopeName!=="HTML") || !shown(child)){<br>     return;<br>    }<br><br><br>    if(isTabNavigable(child)){<br>     var tabindex = attr(child, "tabIndex");<br>     if(!hasAttr(child, "tabIndex") || tabindex == 0){<br>      if(!first){ first = child; }<br>      last = child;<br>     }else if(tabindex > 0){<br>      if(!lowest || tabindex < lowestTabindex){<br>       lowestTabindex = tabindex;<br>       lowest = child;<br>      }<br>      if(!highest || tabindex >= highestTabindex){<br>       highestTabindex = tabindex;<br>       highest = child;<br>      }<br>     }<br>     var rn = radioName(child);<br>     if(dojo.attr(child, "checked") && rn) {<br>      radioSelected[rn] = child;<br>     }<br>    }<br>    if(child.nodeName.toUpperCase() != 'SELECT'){<br>     walkTree(child);<br>    }<br>   });<br>  };<br>  if(shown(root)){ walkTree(root) }<br>  function rs(node) {<br>   // substitute checked radio button for unchecked one, if there is a checked one with the same name.<br>   return radioSelected[radioName(node)] || node;<br>  }<br>  return { first: rs(first), last: rs(last), lowest: rs(lowest), highest: rs(highest) }; </div> <li><em>summary</em><div><pre>Finds descendants of the specified root node.</pre></div></li><li><em>description</em><div><pre>Finds the following descendants of the specified root node: * the first tab-navigable element in document order without a tabIndex or with tabIndex="0" * the last tab-navigable element in document order without a tabIndex or with tabIndex="0" * the first element in document order with the lowest positive tabIndex value * the last element in document order with the highest positive tabIndex value</pre></div></li></ul></li><li><h4>dijit.getFirstInTabbingOrder</h4><ul> <li><em>type</em><div><pre>Function</pre></div></li><li><em>parameters:</em> <ul><li>root: <em>(typeof String|DOMNode)</em><div></div></li></ul></li><li class="source"><em>source: [<a onclick="tgShow('unique22');">view</a>]</em> <div class="nosho" id="unique22">   var elems = dijit._getTabNavigable(dojo.byId(root));<br>  return elems.lowest ? elems.lowest : elems.first; // DomNode </div> <li><em>summary</em><div><pre>Finds the descendant of the specified root node that is first in the tabbing order</pre></div></li><li><em>returns</em><div><pre>DomNode</pre></div></li></ul></li><li><h4>dijit.getLastInTabbingOrder</h4><ul> <li><em>type</em><div><pre>Function</pre></div></li><li><em>parameters:</em> <ul><li>root: <em>(typeof String|DOMNode)</em><div></div></li></ul></li><li class="source"><em>source: [<a onclick="tgShow('unique23');">view</a>]</em> <div class="nosho" id="unique23">   var elems = dijit._getTabNavigable(dojo.byId(root));<br>  return elems.last ? elems.last : elems.highest; // DomNode </div> <li><em>summary</em><div><pre>Finds the descendant of the specified root node that is last in the tabbing order</pre></div></li><li><em>returns</em><div><pre>DomNode</pre></div></li></ul></li><li><h4>dijit</h4><ul> <li><em>type</em><div><pre>Object</pre></div></li><li><em>summary</em><div><pre></pre></div></li></ul></li></ul></div> </div> </div> </div> </body> </html>

dijit/_base/manager.js

Provides:

dijit.WidgetSet

dijit.WidgetSet.add

dijit.WidgetSet.remove

dijit.WidgetSet.forEach

dijit.WidgetSet.filter

dijit.WidgetSet.byId

dijit.WidgetSet.byClass

dijit.WidgetSet.toArray

dijit.WidgetSet.map

dijit.WidgetSet.every

dijit.WidgetSet.some

dijit.WidgetSet._hash

dijit.WidgetSet.length

dijit.registry

attr

hasAttr

style

dijit.defaultDuration

dijit.byId

dijit.getUniqueId

dijit.findWidgets

dijit._destroyAll

dijit.byNode

dijit.getEnclosingWidget

dijit._isElementShown

dijit.hasDefaultTabStop