New feature: basic Ajax suggestion for tags and implementation of Dojo toolkit

git-svn-id: https://semanticscuttle.svn.sourceforge.net/svnroot/semanticscuttle/trunk@151 b3834d28-1941-0410-a4f8-b48e95affb8f

1 files changed, 225 insertions, 0 deletions

diff --git a/includes/js/dojox/wire/ml/Action.js b/includes/js/dojox/wire/ml/Action.js
new file mode 100644
index 0000000..637de41
--- /dev/null
+++ b/includes/js/dojox/wire/ml/Action.js
@@ -0,0 +1,225 @@
+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
+	}
+});
+
+}