API Preview tool | The Dojo Toolkit

dijit/_WidgetBase.js

Provides:
- dijit._WidgetBase

dijit._WidgetBase

type
```
Function
```
chains:
- dojo.Stateful: (prototype)
- dojo.Stateful: (call)

summary

Future base class for all Dijit widgets.
_Widget extends this class adding support for various features needed by desktop.

dijit._WidgetBase.id

tags: const
type
```
String
```

summary

A unique, opaque ID string that can be assigned by users or by the
system. If the developer passes an ID which is known not to be
unique, the specified ID is ignored and the system-generated ID is
used instead.

dijit._WidgetBase.lang

tags: const
type
```
String
```

summary

Rarely used.  Overrides the default Dojo locale used to render this widget,
as defined by the [HTML LANG](http://www.w3.org/TR/html401/struct/dirlang.html#adef-lang) attribute.
Value must be among the list of locales specified during by the Dojo bootstrap,
formatted according to [RFC 3066](http://www.ietf.org/rfc/rfc3066.txt) (like en-us).

dijit._WidgetBase.dir

tags: const
type
```
String
```

summary

Bi-directional support, as defined by the [HTML DIR](http://www.w3.org/TR/html401/struct/dirlang.html#adef-dir)
attribute. Either left-to-right &quot;ltr&quot; or right-to-left &quot;rtl&quot;.  If undefined, widgets renders in page's
default direction.

dijit._WidgetBase.class
- type
```
String
```
- summary
```
HTML class attribute
```

dijit._WidgetBase.style

type
```
String||Object
```

summary

HTML style attributes as cssText string or name/value hash

dijit._WidgetBase.title

type
```
String
```

summary

HTML title attribute.

For form widgets this specifies a tooltip to display when hovering over
the widget (just like the native HTML title attribute).

For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
etc., it's used to specify the tab label, accordion pane title, etc.

dijit._WidgetBase.tooltip

type
```
String
```

summary

When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
this specifies the tooltip to appear when the mouse is hovered over that text.

dijit._WidgetBase.baseClass

tags: protected
type
```
String
```

summary

Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
widget state.

dijit._WidgetBase.srcNodeRef
- tags: readonly
- type
```
DomNode
```
- summary
```
pointer to original DOM node
```

dijit._WidgetBase.domNode

tags: readonly
type
```
DomNode
```

summary

This is our visible representation of the widget! Other DOM
Nodes may by assigned to other properties, usually through the
template system's dojoAttachPoint syntax, but the domNode
property is the canonical &quot;top level&quot; node in widget UI.

dijit._WidgetBase.containerNode

tags: readonly
type
```
DomNode
```

summary

Designates where children of the source DOM node will be placed.
&quot;Children&quot; in this case refers to both DOM nodes and widgets.
For example, for myWidget:

	&lt;div dojoType=myWidget&gt;
		&lt;b&gt; here's a plain DOM node
		&lt;span dojoType=subWidget&gt;and a widget&lt;/span&gt;
		&lt;i&gt; and another plain DOM node &lt;/i&gt;
	&lt;/div&gt;

containerNode would point to:

		&lt;b&gt; here's a plain DOM node
		&lt;span dojoType=subWidget&gt;and a widget&lt;/span&gt;
		&lt;i&gt; and another plain DOM node &lt;/i&gt;

In templated widgets, &quot;containerNode&quot; is set via a
dojoAttachPoint assignment.

containerNode must be defined for any widget that accepts innerHTML
(like ContentPane or BorderContainer or even Button), and conversely
is null for widgets that don't, like TextBox.

dijit._WidgetBase._started
- type
```
Boolean
```
- summary
```
startup() has completed.
```
dijit._WidgetBase.attributeMap
- type
```
Object
```
- summary

dijit._WidgetBase._blankGif

tags: protected
type
```
String
```

summary

Path to a blank 1x1 image.
Used by &lt;img&gt; nodes in templates that really get their image via CSS background-image.

dijit._WidgetBase.postscript
- type
```
Function
```
- parameters:
  - params: (typeof Object)
  - srcNodeRef: (typeof DomNode|String)
- source: [view]
  this.create(params, srcNodeRef);
- summary
```
Kicks off widget instantiation.  See create() for details.
```
- tags:
dijit._WidgetBase.create
- type
```
Function
```
- parameters:
  - params: (typeof Object)
```
Hash of initialization parameters for widget, including
scalar values (like title, duration etc.) and functions,
typically callbacks like onClick.
```
  - srcNodeRef: (typeof DomNode|String)
```
If a srcNodeRef (DOM node) is specified:
- use srcNodeRef.innerHTML as my contents
- if this is a behavioral widget then apply behavior
to that srcNodeRef
- otherwise, replace srcNodeRef with my generated DOM
tree
```
- source: [view]
  define("dijit/_WidgetBase", ["dojo", "dijit", "dijit/_base/manager", "dojo/Stateful"], function(dojo, dijit) {
  
  (function(){
  
  dojo.declare("dijit._WidgetBase", dojo.Stateful, {
  // summary:
  //  Future base class for all Dijit widgets.
  //  _Widget extends this class adding support for various features needed by desktop.
  
  // id: [const] String
  //  A unique, opaque ID string that can be assigned by users or by the
  //  system. If the developer passes an ID which is known not to be
  //  unique, the specified ID is ignored and the system-generated ID is
  //  used instead.
  id: "",
  
  // lang: [const] String
  //  Rarely used. Overrides the default Dojo locale used to render this widget,
  //  as defined by the [HTML LANG](http://www.w3.org/TR/html401/struct/dirlang.html#adef-lang) attribute.
  //  Value must be among the list of locales specified during by the Dojo bootstrap,
  //  formatted according to [RFC 3066](http://www.ietf.org/rfc/rfc3066.txt) (like en-us).
  lang: "",
  
  // dir: [const] String
  //  Bi-directional support, as defined by the [HTML DIR](http://www.w3.org/TR/html401/struct/dirlang.html#adef-dir)
  //  attribute. Either left-to-right "ltr" or right-to-left "rtl". If undefined, widgets renders in page's
  //  default direction.
  dir: "",
  
  // class: String
  //  HTML class attribute
  "class": "",
  
  // style: String||Object
  //  HTML style attributes as cssText string or name/value hash
  style: "",
  
  // title: String
  //  HTML title attribute.
  //
  //  For form widgets this specifies a tooltip to display when hovering over
  //  the widget (just like the native HTML title attribute).
  //
  //  For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
  //  etc., it's used to specify the tab label, accordion pane title, etc.
  title: "",
  
  // tooltip: String
  //  When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
  //  this specifies the tooltip to appear when the mouse is hovered over that text.
  tooltip: "",
  
  // baseClass: [protected] String
  //  Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
  //  widget state.
  baseClass: "",
  
  // srcNodeRef: [readonly] DomNode
  //  pointer to original DOM node
  srcNodeRef: null,
  
  // domNode: [readonly] DomNode
  //  This is our visible representation of the widget! Other DOM
  //  Nodes may by assigned to other properties, usually through the
  //  template system's dojoAttachPoint syntax, but the domNode
  //  property is the canonical "top level" node in widget UI.
  domNode: null,
  
  // containerNode: [readonly] DomNode
  //  Designates where children of the source DOM node will be placed.
  //  "Children" in this case refers to both DOM nodes and widgets.
  //  For example, for myWidget:
  //
  //  |
  
  //  |   here's a plain DOM node
  //  |  and a widget
  //  |   and another plain DOM node
  //  |
  
  //
  //  containerNode would point to:
  //
  //  |   here's a plain DOM node
  //  |  and a widget
  //  |   and another plain DOM node
  //
  //  In templated widgets, "containerNode" is set via a
  //  dojoAttachPoint assignment.
  //
  //  containerNode must be defined for any widget that accepts innerHTML
  //  (like ContentPane or BorderContainer or even Button), and conversely
  //  is null for widgets that don't, like TextBox.
  containerNode: null,
  
  // _started: Boolean
  //  startup() has completed.
  _started: false,
  
  // attributeMap: [protected] Object
  //  attributeMap sets up a "binding" between attributes (aka properties)
  //  of the widget and the widget's DOM.
  //  Changes to widget attributes listed in attributeMap will be
  //  reflected into the DOM.
  //
  //  For example, calling set('title', 'hello')
  //  on a TitlePane will automatically cause the TitlePane's DOM to update
  //  with the new title.
  //
  //  attributeMap is a hash where the key is an attribute of the widget,
  //  and the value reflects a binding to a:
  //
  //  - DOM node attribute
  // |  focus: {node: "focusNode", type: "attribute"}
  //   Maps this.focus to this.focusNode.focus
  //
  //  - DOM node innerHTML
  // |  title: { node: "titleNode", type: "innerHTML" }
  //  Maps this.title to this.titleNode.innerHTML
  //
  //  - DOM node innerText
  // |  title: { node: "titleNode", type: "innerText" }
  //  Maps this.title to this.titleNode.innerText
  //
  //  - DOM node CSS class
  // |  myClass: { node: "domNode", type: "class" }
  //  Maps this.myClass to this.domNode.className
  //
  //  If the value is an array, then each element in the array matches one of the
  //  formats of the above list.
  //
  //  There are also some shorthands for backwards compatibility:
  //  - string --> { node: string, type: "attribute" }, for example:
  // | "focusNode" ---> { node: "focusNode", type: "attribute" }
  //  - "" --> { node: "domNode", type: "attribute" }
  attributeMap: {id:"", dir:"", lang:"", "class":"", style:"", title:""},
  
  // _blankGif: [protected] String
  //  Path to a blank 1x1 image.
  //  Used by nodes in templates that really get their image via CSS background-image.
  _blankGif: (dojo.config.blankGif || dojo.moduleUrl("dojo", "resources/blank.gif")).toString(),
  
  //////////// INITIALIZATION METHODS ///////////////////////////////////////
  
  postscript: function(/*Object?*/params, /*DomNode|String*/srcNodeRef){
    // summary:
    //  Kicks off widget instantiation. See create() for details.
    // tags:
    //  private
    this.create(params, srcNodeRef);
  },
  
  create: function(/*Object?*/params, /*DomNode|String?*/srcNodeRef){
    // summary:
    //  Kick off the life-cycle of a widget
    // params:
    //  Hash of initialization parameters for widget, including
    //  scalar values (like title, duration etc.) and functions,
    //  typically callbacks like onClick.
    // srcNodeRef:
    //  If a srcNodeRef (DOM node) is specified:
    //   - use srcNodeRef.innerHTML as my contents
    //   - if this is a behavioral widget then apply behavior
    //    to that srcNodeRef
    //   - otherwise, replace srcNodeRef with my generated DOM
    //    tree
    // description:
    //  Create calls a number of widget methods (postMixInProperties, buildRendering, postCreate,
    //  etc.), some of which of you'll want to override. See http://docs.dojocampus.org/dijit/_Widget
    //  for a discussion of the widget creation lifecycle.
    //
    //  Of course, adventurous developers could override create entirely, but this should
    //  only be done as a last resort.
    // tags:
    //  private
  
    // store pointer to original DOM tree
    this.srcNodeRef = dojo.byId(srcNodeRef);
  
    // For garbage collection. An array of handles returned by Widget.connect()
    // Each handle returned from Widget.connect() is an array of handles from dojo.connect()
    this._connects = [];
  
    // For garbage collection. An array of handles returned by Widget.subscribe()
    // The handle returned from Widget.subscribe() is the handle returned from dojo.subscribe()
    this._subscribes = [];
  
    // mix in our passed parameters
    if(this.srcNodeRef && (typeof this.srcNodeRef.id == "string")){ this.id = this.srcNodeRef.id; }
    if(params){
     this.params = params;
     dojo._mixin(this, params);
    }
    this.postMixInProperties();
  
    // generate an id for the widget if one wasn't specified
    // (be sure to do this before buildRendering() because that function might
    // expect the id to be there.)
    if(!this.id){
     this.id = dijit.getUniqueId(this.declaredClass.replace(/\./g,"_"));
    }
    dijit.registry.add(this);
  
    this.buildRendering();
  
    if(this.domNode){
     // Copy attributes listed in attributeMap into the [newly created] DOM for the widget.
     // Also calls custom setters for all attributes with custom setters.
     this._applyAttributes();
  
     // If srcNodeRef was specified, then swap out original srcNode for this widget's DOM tree.
     // For 2.0, move this after postCreate(). postCreate() shouldn't depend on the
     // widget being attached to the DOM since it isn't when a widget is created programmatically like
     // new MyWidget({}). See #11635.
     var source = this.srcNodeRef;
     if(source && source.parentNode && this.domNode !== source){
      source.parentNode.replaceChild(this.domNode, source);
     }
    }
  
    if(this.domNode){
     // Note: for 2.0 may want to rename widgetId to dojo._scopeName + "_widgetId",
     // assuming that dojo._scopeName even exists in 2.0
     this.domNode.setAttribute("widgetId", this.id);
    }
    this.postCreate();
  
    // If srcNodeRef has been processed and removed from the DOM (e.g. TemplatedWidget) then delete it to allow GC.
    if(this.srcNodeRef && !this.srcNodeRef.parentNode){
     delete this.srcNodeRef;
    }
  
    this._created = true;
- summary
  Kick off the life-cycle of a widget
- description
  Create calls a number of widget methods (postMixInProperties, buildRendering, postCreate, etc.), some of which of you'll want to override. See http://docs.dojocampus.org/dijit/_Widget for a discussion of the widget creation lifecycle. Of course, adventurous developers could override create entirely, but this should only be done as a last resort.

dijit._WidgetBase._applyAttributes

type
Function
source: [view]
  var condAttrApply = function(attr, scope){
   if((scope.params && attr in scope.params) || scope[attr]){
    scope.set(attr, scope[attr]);
   }
  };

  // Do the attributes in attributeMap
  for(var attr in this.attributeMap){
   condAttrApply(attr, this);
  }

  // And also any attributes with custom setters
  dojo.forEach(this._getSetterAttributes(), function(a){
   if(!(a in this.attributeMap)){
    condAttrApply(a, this);
   }
  }, this);

summary
Step during widget creation to copy all widget attributes to the DOM as per attributeMap and _setXXXAttr functions.
description
Skips over blank/false attribute values, unless they were explicitly specified as parameters to the widget, since those are the default anyway, and setting tabIndex="" is different than not setting tabIndex at all. It processes the attributes in the attribute map first, and then it goes through and processes the attributes for the _setXXXAttr functions that have been specified
tags:

dijit._WidgetBase._getSetterAttributes
dijit._WidgetBase.postMixInProperties
dijit._WidgetBase.buildRendering
dijit._WidgetBase.postCreate

dijit._WidgetBase.startup

type
Function
source: [view]
this._started = true;

summary
Processing after the DOM fragment is added to the document
description
Called after a widget and its children have been created and added to the page, and all related widgets have finished their create() cycle, up through postCreate(). This is useful for composite widgets that need to control or layout sub-widgets. Many layout widgets can use this as a wiring phase.

dijit._WidgetBase.destroyRecursive

type
Function
parameters:
preserveDom: (typeof Boolean)
If true, this method will leave the original DOM structure alone of descendant Widgets. Note: This will NOT work with dijit._Templated widgets.
source: [view]
  this._beingDestroyed = true;
  this.destroyDescendants(preserveDom);
  this.destroy(preserveDom);

summary
Destroy this widget and its descendants
description
This is the generic "destructor" function that all widget users should call to cleanly discard with a widget. Once a widget is destroyed, it is removed from the manager object.

dijit._WidgetBase.destroy
dijit._WidgetBase.destroyRendering
dijit._WidgetBase.destroyDescendants

dijit._WidgetBase.uninitialize

type
Function
source: [view]
return false;

summary
Stub function. Override to implement custom widget tear-down behavior.
tags:

dijit._WidgetBase._setClassAttr
dijit._WidgetBase._setStyleAttr
dijit._WidgetBase._attrToDom

dijit._WidgetBase.get

type
Function
parameters:
name: (typeof The)
property to get.
source: [view]
var names = this._getAttrNames(name);
return this[names.g] ? this[names.g]() : this[name];

summary
Get a property from a widget.
description
Get a named property from a widget. The property may potentially be retrieved via a getter method. If no getter is defined, this just retrieves the object's property. For example, if the widget has a properties "foo" and "bar" and a method named "_getFooAttr", calling: myWidget.get("foo"); would be equivalent to writing: widget._getFooAttr(); and: myWidget.get("bar"); would be equivalent to writing: widget.bar;

dijit._WidgetBase.set

type
Function
parameters:
name: (typeof The)
property to set.
value: (typeof The)
value to set in the property.
source: [view]
  if(typeof name === "object"){
   for(var x in name){
    this.set(x, name[x]);
   }
   return this;
  }
  var names = this._getAttrNames(name);
  if(this[names.s]){
   // use the explicit setter
   var result = this[names.s].apply(this, Array.prototype.slice.call(arguments, 1));
  }else{
   // if param is specified as DOM node attribute, copy it
   if(name in this.attributeMap){
    this._attrToDom(name, value);
   }
   this._set(name, value);
  }
  return result || this;

summary
Set a property on a widget
description
Sets named properties on a widget which may potentially be handled by a setter in the widget. For example, if the widget has a properties "foo" and "bar" and a method named "_setFooAttr", calling: myWidget.set("foo", "Howdy!"); would be equivalent to writing: widget._setFooAttr("Howdy!"); and: myWidget.set("bar", 3); would be equivalent to writing: widget.bar = 3; set() may also be called with a hash of name/value pairs, ex: myWidget.set({ foo: "Howdy", bar: 3 }) This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
chains:
Array.prototype.slice: (call)

dijit._WidgetBase._attrPairNames
dijit._WidgetBase._getAttrNames
dijit._WidgetBase._set

dijit._WidgetBase.toString

type
Function
source: [view]
return '[Widget ' + this.declaredClass + ', ' + (this.id || 'NO ID') + ']'; // String

summary
Returns a string that represents the widget
description
When a widget is cast to a string, this method will be used to generate the output. Currently, it does not implement any sort of reversible serialization.
returns
String

dijit._WidgetBase.getDescendants

type
Function
source: [view]
return this.containerNode ? dojo.query('[widgetId]', this.containerNode).map(dijit.byNode) : []; // dijit._Widget[]

summary
Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode. This method should generally be avoided as it returns widgets declared in templates, which are supposed to be internal/hidden, but it's left here for back-compat reasons.
returns
dijit._Widget[]

dijit._WidgetBase.getChildren

type
Function
source: [view]
return this.containerNode ? dijit.findWidgets(this.containerNode) : []; // dijit._Widget[]

summary
Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode. Does not return nested widgets, nor widgets that are part of this widget's template.
returns
dijit._Widget[]

dijit._WidgetBase.connect

type
Function
parameters:
obj: (typeof Object|null)
event: (typeof String|Function)
method: (typeof String|Function)
source: [view]
  var handles = [dojo._connect(obj, event, this, method)];
  this._connects.push(handles);
  return handles;  // _Widget.Handle

summary
Connects specified obj/event to specified method of this object and registers for disconnect() on widget destroy.
description
Provide widget-specific analog to dojo.connect, except with the implicit use of this widget as the target object. Events connected with `this.connect` are disconnected upon destruction.
return_summary
A handle that can be passed to `disconnect` in order to disconnect before the widget is destroyed.
tags:
returns
_Widget.Handle
example
var btn = new dijit.form.Button(); // when foo.bar() is called, call the listener we're going to // provide in the scope of btn btn.connect(foo, "bar", function(){ console.debug(this.toString()); });

dijit._WidgetBase.disconnect

dijit._WidgetBase.subscribe

type
Function
parameters:
topic: (typeof String)
method: (typeof String|Function)
source: [view]
  var handle = dojo.subscribe(topic, this, method);

  // return handles for Any widget that may need them
  this._subscribes.push(handle);
  return handle;

summary
Subscribes to the specified topic and calls the specified method of this object and registers for unsubscribe() on widget destroy.
description
Provide widget-specific analog to dojo.subscribe, except with the implicit use of this widget as the target object.
example
var btn = new dijit.form.Button(); // when /my/topic is published, this button changes its label to // be the parameter of the topic. btn.subscribe("/my/topic", function(v){ this.set("label", v); });

dijit._WidgetBase.unsubscribe
dijit._WidgetBase.isLeftToRight

dijit._WidgetBase.placeAt

type
Function
parameters:
reference: (typeof String|DomNode|_Widget)
The String id of a domNode, a domNode reference, or a reference to a Widget posessing an addChild method.
position: (typeof String?|Int)
If passed a string or domNode reference, the position argument accepts a string just as dojo.place does, one of: "first", "last", "before", or "after". If passed a _Widget reference, and that widget reference has an ".addChild" method, it will be called passing this widget instance into that method, supplying the optional position index passed.
source: [view]
  if(reference.declaredClass && reference.addChild){
   reference.addChild(this, position);
  }else{
   dojo.place(this.domNode, reference, position);
  }
  return this;

summary
Place this widget's domNode reference somewhere in the DOM based on standard dojo.place conventions, or passing a Widget reference that contains and addChild member.
description
A convenience function provided in all _Widgets, providing a simple shorthand mechanism to put an existing (or newly created) Widget somewhere in the dom, and allow chaining.
return_summary
dijit._Widget Provides a useful return of the newly created dijit._Widget instance so you can "chain" this function by instantiating, placing, then saving the return value to a variable.
example
// create a Button with no srcNodeRef, and place it in the body: var button = new dijit.form.Button({ label:"click" }).placeAt(dojo.body()); // now, 'button' is still the widget reference to the newly created button dojo.connect(button, "onClick", function(e){ console.log('click'); });
example
// create a button out of a node with id="src" and append it to id="wrapper": var button = new dijit.form.Button({},"src").placeAt("wrapper");
example
// place a new button as the first element of some div var button = new dijit.form.Button({ label:"click" }).placeAt("wrapper","first");
example
// create a contentpane and add it to a TabContainer var tc = dijit.byId("myTabs"); new dijit.layout.ContentPane({ href:"foo.html", title:"Wow!" }).placeAt(tc)

dijit._WidgetBase.attributeMap.id
dijit._WidgetBase.attributeMap.dir
dijit._WidgetBase.attributeMap.lang
dijit._WidgetBase.attributeMap.class
dijit._WidgetBase.attributeMap.style
dijit._WidgetBase.attributeMap.title
dijit._WidgetBase._connects
dijit._WidgetBase._subscribes
dijit._WidgetBase.srcNodeRef.id
dijit._WidgetBase.params
dijit._WidgetBase._created

dijit._WidgetBase.create.params

type
Hash
summary
of initialization parameters for widget, including scalar values (like title, duration etc.) and functions, typically callbacks like onClick.

dijit._WidgetBase.create.srcNodeRef

type
If
summary
a srcNodeRef (DOM node) is specified: - use srcNodeRef.innerHTML as my contents - if this is a behavioral widget then apply behavior to that srcNodeRef - otherwise, replace srcNodeRef with my generated DOM tree

dijit._WidgetBase._beingDestroyed
dijit._WidgetBase._destroyed
dijit

dijit/_WidgetBase.js

Provides:

dijit._WidgetBase

dijit._WidgetBase.id

dijit._WidgetBase.lang

dijit._WidgetBase.dir

dijit._WidgetBase.class

dijit._WidgetBase.style

dijit._WidgetBase.title

dijit._WidgetBase.tooltip

dijit._WidgetBase.baseClass

dijit._WidgetBase.srcNodeRef

dijit._WidgetBase.domNode

dijit._WidgetBase.containerNode

dijit._WidgetBase._started

dijit._WidgetBase.attributeMap

dijit._WidgetBase._blankGif

dijit._WidgetBase.postscript

dijit._WidgetBase.create

dijit._WidgetBase._applyAttributes

dijit._WidgetBase._getSetterAttributes

dijit._WidgetBase.postMixInProperties

dijit._WidgetBase.buildRendering

dijit._WidgetBase.postCreate

dijit._WidgetBase.startup

dijit._WidgetBase.destroyRecursive

dijit._WidgetBase.destroy

dijit._WidgetBase.destroyRendering

dijit._WidgetBase.destroyDescendants

dijit._WidgetBase.uninitialize

dijit._WidgetBase._setClassAttr

dijit._WidgetBase._setStyleAttr

dijit._WidgetBase._attrToDom

dijit._WidgetBase.get

dijit._WidgetBase.set

dijit._WidgetBase._attrPairNames

dijit._WidgetBase._getAttrNames

dijit._WidgetBase._set

dijit._WidgetBase.toString

dijit._WidgetBase.getDescendants

dijit._WidgetBase.getChildren

dijit._WidgetBase.connect

dijit._WidgetBase.disconnect

dijit._WidgetBase.subscribe

dijit._WidgetBase.unsubscribe

dijit._WidgetBase.isLeftToRight

dijit._WidgetBase.placeAt

dijit._WidgetBase.attributeMap.id

dijit._WidgetBase.attributeMap.dir

dijit._WidgetBase.attributeMap.lang

dijit._WidgetBase.attributeMap.class

dijit._WidgetBase.attributeMap.style

dijit._WidgetBase.attributeMap.title

dijit._WidgetBase._connects

dijit._WidgetBase._subscribes

dijit._WidgetBase.srcNodeRef.id

dijit._WidgetBase.params

dijit._WidgetBase._created

dijit._WidgetBase.create.params

dijit._WidgetBase.create.srcNodeRef

dijit._WidgetBase._beingDestroyed

dijit._WidgetBase._destroyed

dijit