if (!dojo._hasResource["dijit._Widget"]) { // _hasResource checks added by
											// build. Do not use _hasResource
											// directly in your code.
	dojo._hasResource["dijit._Widget"] = true;
	dojo.provide("dijit._Widget");

	dojo.require("dijit._base");

	dojo.declare("dijit._Widget", null, {
		// summary:
		// The foundation of dijit widgets.
		//
		// id: 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: String
		// Language to display this widget in (like en-us).
		// Defaults to brower's specified preferred language (typically the
		// language of the OS)
		lang : "",

		// dir: String
		// Bi-directional support, as defined by the HTML DIR attribute. Either
		// left-to-right "ltr" or right-to-left "rtl".
		dir : "",

		// class: String
		// HTML class attribute
		"class" : "",

		// style: String
		// HTML style attribute
		style : "",

		// title: String
		// HTML title attribute
		title : "",

		// srcNodeRef: DomNode
		// pointer to original dom node
		srcNodeRef : null,

		// domNode: DomNode
		// this is our visible representation of the widget! Other DOM
		// Nodes may by assigned to other properties, usually through the
		// template system's dojoAttachPonit syntax, but the domNode
		// property is the canonical "top level" node in widget UI.
		domNode : null,

		// attributeMap: Object
		// A map of attributes and attachpoints -- typically standard HTML
		// attributes -- to set
		// on the widget's dom, at the "domNode" attach point, by default.
		// Other node references can be specified as properties of 'this'
		attributeMap : {
			id : "",
			dir : "",
			lang : "",
			"class" : "",
			style : "",
			title : ""
		}, // TODO: add on* handlers?

		// ////////// INITIALIZATION METHODS
		// ///////////////////////////////////////

		postscript : function(params, srcNodeRef) {
			this.create(params, srcNodeRef);
		},

		create : function(params, srcNodeRef) {
			// summary:
			// To understand the process by which widgets are instantiated, it
			// is critical to understand what other methods create calls and
			// which of them you'll want to override. Of course, adventurous
			// developers could override create entirely, but this should
			// only be done as a last resort.
			//
			// Below is a list of the methods that are called, in the order
			// they are fired, along with notes about what they do and if/when
			// you should over-ride them in your widget:
			//			
			// postMixInProperties:
			// a stub function that you can over-ride to modify
			// variables that may have been naively assigned by
			// mixInProperties
			// # widget is added to manager object here
			// buildRendering
			// Subclasses use this method to handle all UI initialization
			// Sets this.domNode. Templated widgets do this automatically
			// and otherwise it just uses the source dom node.
			// postCreate
			// a stub function that you can over-ride to modify take
			// actions once the widget has been placed in the UI

			// 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 = [];

			// _attaches: String[]
			// names of all our dojoAttachPoint variables
			this._attaches = [];

			// mixin our passed parameters
			if (this.srcNodeRef && (typeof this.srcNodeRef.id == "string")) {
				this.id = this.srcNodeRef.id;
			}
			if (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();

			// Copy attributes listed in attributeMap into the [newly created]
			// DOM for the widget.
			// The placement of these attributes is according to the property
			// mapping in attributeMap.
			// Note special handling for 'style' and 'class' attributes which
			// are lists and can
			// have elements from both old and new structures, and some
			// attributes like "type"
			// cannot be processed this way as they are not mutable.
			if (this.domNode) {
				for (var attr in this.attributeMap) {
					var mapNode = this[this.attributeMap[attr] || "domNode"];
					var value = this[attr];
					if (typeof value != "object"
							&& (value !== "" || (params && params[attr]))) {
						switch (attr) {
							case "class" :
								dojo.addClass(mapNode, value);
								break;
							case "style" :
								if (mapNode.style.cssText) {
									mapNode.style.cssText += "; " + value;// FIXME:
																			// Opera
								} else {
									mapNode.style.cssText = value;
								}
								break;
							default :
								mapNode.setAttribute(attr, value);
						}
					}
				}
			}

			if (this.domNode) {
				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;
			}
		},

		postMixInProperties : function() {
			// summary
			// Called after the parameters to the widget have been read-in,
			// but before the widget template is instantiated.
			// Especially useful to set properties that are referenced in the
			// widget template.
		},

		buildRendering : function() {
			// summary:
			// Construct the UI for this widget, setting this.domNode.
			// Most widgets will mixin TemplatedWidget, which overrides this
			// method.
			this.domNode = this.srcNodeRef || dojo.doc.createElement('div');
		},

		postCreate : function() {
			// summary:
			// Called after a widget's dom has been setup
		},

		startup : function() {
			// summary:
			// Called after a widget's children, and other widgets on the page,
			// have been created.
			// Provides an opportunity to manipulate any children before they
			// are displayed
			// This is useful for composite widgets that need to control or
			// layout sub-widgets
			// Many layout widgets can use this as a wiring phase
		},

		// ////////// DESTROY FUNCTIONS ////////////////////////////////

		destroyRecursive : function(/* Boolean */finalize) {
			// summary:
			// Destroy this widget and it's descendants. This is the generic
			// "destructor" function that all widget users should call to
			// cleanly discard with a widget. Once a widget is destroyed, it's
			// removed from the manager object.
			// finalize: Boolean
			// is this function being called part of global environment
			// tear-down?

			this.destroyDescendants();
			this.destroy();
		},

		destroy : function(/* Boolean */finalize) {
			// summary:
			// Destroy this widget, but not its descendants
			// finalize: Boolean
			// is this function being called part of global environment
			// tear-down?
			this.uninitialize();
			dojo.forEach(this._connects, function(array) {
						dojo.forEach(array, dojo.disconnect);
					});
			this.destroyRendering(finalize);
			dijit.registry.remove(this.id);
		},

		destroyRendering : function(/* Boolean */finalize) {
			// summary:
			// Destroys the DOM nodes associated with this widget
			// finalize: Boolean
			// is this function being called part of global environment
			// tear-down?

			if (this.bgIframe) {
				this.bgIframe.destroy();
				delete this.bgIframe;
			}

			if (this.domNode) {
				dojo._destroyElement(this.domNode);
				delete this.domNode;
			}

			if (this.srcNodeRef) {
				dojo._destroyElement(this.srcNodeRef);
				delete this.srcNodeRef;
			}
		},

		destroyDescendants : function() {
			// summary:
			// Recursively destroy the children of this widget and their
			// descendants.

			// TODO: should I destroy in the reverse order, to go bottom up?
			dojo.forEach(this.getDescendants(), function(widget) {
						widget.destroy();
					});
		},

		uninitialize : function() {
			// summary:
			// stub function. Over-ride to implement custom widget tear-down
			// behavior.
			return false;
		},

		// //////////////// MISCELLANEOUS METHODS ///////////////////

		toString : function() {
			// summary:
			// returns a string that represents the widget. 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 reversable
			// serialization.
			return '[Widget ' + this.declaredClass + ', '
					+ (this.id || 'NO ID') + ']'; // String
		},

		getDescendants : function() {
			// summary:
			// return all the descendant widgets
			var list = dojo.query('[widgetId]', this.domNode);
			return list.map(dijit.byNode); // Array
		},

		nodesWithKeyClick : ["input", "button"],

		connect : function(
				/* Object|null */obj,
				/* String */event,
				/* String|Function */method) {

			// summary:
			// Connects specified obj/event to specified method of this object
			// and registers for disconnect() on widget destroy.
			// Special event: "ondijitclick" triggers on a click or enter-down
			// or space-up
			// Similar to dojo.connect() but takes three arguments rather than
			// four.
			var handles = [];
			if (event == "ondijitclick") {
				var w = this;
				// add key based click activation for unsupported nodes.
				if (!this.nodesWithKeyClick[obj.nodeName]) {
					handles.push(dojo.connect(obj, "onkeydown", this, function(
									e) {
								if (e.keyCode == dojo.keys.ENTER) {
									return (dojo.isString(method))
											? w[method](e)
											: method.call(w, e);
								} else if (e.keyCode == dojo.keys.SPACE) {
									// stop space down as it causes IE to scroll
									// the browser window
									dojo.stopEvent(e);
								}
							}));
					handles.push(dojo.connect(obj, "onkeyup", this,
							function(e) {
								if (e.keyCode == dojo.keys.SPACE) {
									return dojo.isString(method)
											? w[method](e)
											: method.call(w, e);
								}
							}));
				}
				event = "onclick";
			}
			handles.push(dojo.connect(obj, event, this, method));

			// return handles for FormElement and ComboBox
			this._connects.push(handles);
			return handles;
		},

		disconnect : function(/* Object */handles) {
			// summary:
			// Disconnects handle created by this.connect.
			// Also removes handle from this widget's list of connects
			for (var i = 0; i < this._connects.length; i++) {
				if (this._connects[i] == handles) {
					dojo.forEach(handles, dojo.disconnect);
					this._connects.splice(i, 1);
					return;
				}
			}
		},

		isLeftToRight : function() {
			// summary:
			// Checks the DOM to for the text direction for bi-directional
			// support
			// description:
			// This method cannot be used during widget construction because the
			// widget
			// must first be connected to the DOM tree. Parent nodes are
			// searched for the
			// 'dir' attribute until one is found, otherwise left to right mode
			// is assumed.
			// See HTML spec, DIR attribute for more information.

			if (typeof this._ltr == "undefined") {
				this._ltr = dojo.getComputedStyle(this.domNode).direction != "rtl";
			}
			return this._ltr; // Boolean
		},

		isFocusable : function() {
			// summary:
			// Return true if this widget can currently be focused
			// and false if not
			return this.focus
					&& (dojo.style(this.domNode, "display") != "none");
		}
	});

}