if (!dojo._hasResource["dojox.wire.ml.Action"]) { // _hasResource checks added
													// by build. Do not use
													// _hasResource directly in
													// your code.
	dojo._hasResource["dojox.wire.ml.Action"] = true;
	dojo.provide("dojox.wire.ml.Action");
	dojo.provide("dojox.wire.ml.ActionFilter");

	dojo.require("dijit._Widget");
	dojo.require("dijit._Container");
	dojo.require("dojox.wire.Wire");
	dojo.require("dojox.wire.ml.util");

	dojo.declare("dojox.wire.ml.Action", [dijit._Widget, dijit._Container], {
				// summary:
				// A base widget to "run" a task on an event or a topic
				// description:
				// This widget represents a controller task to be run when an
				// event
				// (a function) or a topic is issued.
				// Sub-classes must implement _run() method to implement their
				// tasks.
				// 'trigger' specifies an event scope, an ID of a widget or an
				// DOM
				// element, or its property with the optional dotted notation.
				// If this widget has child ActionFilter widgets, their filter()
				// methods are called with the arguments to the event or the
				// topic.
				// If one of filter() methods returns false, run() won't be
				// invoked.
				// This widget also can serve as a composite task to run child
				// Actions on an event or a topic specified to this widget.
				// trigger:
				// An event scope
				// triggerEvent:
				// An event (function) name
				// triggerTopic:
				// A topic name
				trigger : "",
				triggerEvent : "",
				triggerTopic : "",

				postCreate : function() {
					// summary:
					// Call _connect()
					// description:
					// See _connect().
					this._connect();
				},

				_connect : function() {
					// summary:
					// Connect run() method to an event or a topic
					// description:
					// If 'triggerEvent' and 'trigger' are specified, connect()
					// is
					// used to set up run() to be called on the event.
					// If 'triggerTopic' is specified, subscribe() is used to
					// set up
					// run() to be called on the topic.
					if (this.triggerEvent) {
						if (this.trigger) {
							var scope = dojox.wire.ml._getValue(this.trigger);
							if (scope) {
								if (!scope[this.triggerEvent]) {
									// set a dummy function for an anonymous
									// object
									scope[this.triggerEvent] = function() {
									};
								}
								this._triggerHandle = dojo.connect(scope,
										this.triggerEvent, this, "run");
							}
						} else {
							var event = this.triggerEvent.toLowerCase();
							if (event == "onload") {
								var self = this;
								dojo.addOnLoad(function() {
											self._run.apply(self, arguments);
										});
							}
						}
					} else if (this.triggerTopic) {
						this._triggerHandle = dojo.subscribe(this.triggerTopic,
								this, "run");
					}
				},

				_disconnect : function() {
					// summary:
					// Disconnect run() method from an event or a topic
					// description:
					// If 'triggerEvent' and 'trigger' are specified,
					// disconnect() is
					// used to set up run() not to be called on the event.
					// If 'triggerTopic' is specified, unsubscribe() is used to
					// set up
					// run() not to be called on the topic.
					if (this._triggerHandle) {
						if (this.triggerTopic) {
							dojo.unsubscribe(this.triggerTopic,
									this._triggerHandle);
						} else {
							dojo.disconnect(this._triggerHandle);
						}
					}
				},

				run : function() {
					// summary:
					// Run a task
					// description:
					// This method calls filter() method of child ActionFilter
					// widgets.
					// If one of them returns false, this method returns.
					// Otherwise, _run() method is called.
					var children = this.getChildren();
					for (var i in children) {
						var child = children[i];
						if (child instanceof dojox.wire.ml.ActionFilter) {
							if (!child.filter.apply(child, arguments)) {
								return;
							}
						}
					}
					this._run.apply(this, arguments);
				},

				_run : function() {
					// summary:
					// Call run() methods of child Action widgets
					// description:
					// If this widget has child Action widgets, their run()
					// methods
					// are called.
					var children = this.getChildren();
					for (var i in children) {
						var child = children[i];
						if (child instanceof dojox.wire.ml.Action) {
							child.run.apply(child, arguments);
						}
					}
				},

				uninitialize : function() {
					// summary:
					// Over-ride of base widget unitialize function to do some
					// connection cleanup.
					this._disconnect();
					return true;
				}
			});

	dojo.declare("dojox.wire.ml.ActionFilter", dijit._Widget, {
				// summary:
				// A widget to define a filter for the parent Action to run
				// description:
				// This base class checks a required property specified with
				// 'required' attribute.
				// If 'message' is specified, the message is set to a property
				// specified with 'error'.
				// Subclasses may implement their own filter() method.
				// required:
				// A property required
				// requiredValue:
				// Optional. A specific value the property is required to have.
				// If this isn't provided
				// than any non-false/non-null value of the required propery
				// will cause this filter
				// to pass.
				// type:
				// Optional. A specific type to compare the values as (if
				// requiredValue is set)
				// Valid values for type are boolean, int, string. Default is
				// string.
				// message:
				// An error message to emit if the filter doesn't execute due to
				// property mismatch.
				// error:
				// A property to store an error due to property mismatch.
				required : "",
				requiredValue : "",
				type : "",
				message : "",
				error : "",

				filter : function() {
					// summary:
					// Check if a required property is specified. Also, if
					// provided, check to see
					// if the required property contains a specific value.
					// description:
					// If a value is undefined for a property, specified with
					// 'required', this method returns false.
					// If the value for a property is defined, but there isn't a
					// requiredValue for it
					// then any non-false value will cause the method to return
					// true.
					// if requiredValue is set, then filter compares that value
					// with the value from
					// the required property and returns true if and only if
					// they match.
					// The type option just allows for a way to convert the
					// required property values
					// into a proper form for comparison (boolean, number, etc).
					// If 'message' is specified, it is set to a proeprty
					// specified
					// with 'error' or shown with alert().
					// If 'required' starts with "arguments", a property of
					// the method arguments are checked.
					// returns:
					// True if a required property is specified (and if
					// requiredValue is specified,
					// that they match), otherwise false
					if (this.required === "") {
						return true; // Boolean
					} else {
						var value = dojox.wire.ml._getValue(this.required,
								arguments);
						if (this.requiredValue === "") {
							// Just see if there's a value, nothing to compare
							// it to.
							if (value) {
								return true; // Boolean
							}
						} else {
							// See if we need to type convert.
							var reqValue = this.requiredValue;
							if (this.type !== "") {
								var lType = this.type.toLowerCase();
								if (lType === "boolean") {
									if (reqValue.toLowerCase() === "false") {
										reqValue = false;
									} else {
										reqValue = true;
									}
								} else if (lType === "number") {
									reqValue = parseInt(reqValue, 10);
								}
							}
							if (value === reqValue) {
								return true; // boolean
							}
						}
					}

					if (this.message) {
						if (this.error) {
							dojox.wire.ml._setValue(this.error, this.message);
						} else {
							alert(this.message);
						}
					}
					return false; // Boolean
				}
			});

}