From e44a7e37b6c7b5961adaffc62b9042b8d442938e Mon Sep 17 00:00:00 2001
From: mensonge
Date: Thu, 13 Nov 2008 09:49:11 +0000
Subject: 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
---
 includes/js/dojo/behavior.js | 185 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 185 insertions(+)
 create mode 100644 includes/js/dojo/behavior.js

(limited to 'includes/js/dojo/behavior.js')

diff --git a/includes/js/dojo/behavior.js b/includes/js/dojo/behavior.js
new file mode 100644
index 0000000..012f940
--- /dev/null
+++ b/includes/js/dojo/behavior.js
@@ -0,0 +1,185 @@
+if(!dojo._hasResource["dojo.behavior"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojo.behavior"] = true;
+dojo.provide("dojo.behavior");
+
+dojo.behavior = new function(){
+	function arrIn(obj, name){
+		if(!obj[name]){ obj[name] = []; }
+		return obj[name];
+	}
+
+	var _inc = 0;
+
+	function forIn(obj, scope, func){
+		var tmpObj = {};
+		for(var x in obj){
+			if(typeof tmpObj[x] == "undefined"){
+				if(!func){
+					scope(obj[x], x);
+				}else{
+					func.call(scope, obj[x], x);
+				}
+			}
+		}
+	}
+
+	// FIXME: need a better test so we don't exclude nightly Safari's!
+	this._behaviors = {};
+	this.add = function(behaviorObj){
+		//	summary:
+		//		add the specified behavior to the list of behaviors which will
+		//		be applied the next time apply() is called. Calls to add() for
+		//		an already existing behavior do not replace the previous rules,
+		//		but are instead additive. New nodes which match the rule will
+		//		have all add()-ed behaviors applied to them when matched.
+		//
+		//	description:
+		//		behavior objects are specified in the following format(s):
+		//		
+		//			{ 
+		//			 	"#id": {
+		//					"found": function(element){
+		//						// ...
+		//					},
+		//			
+		//					"onblah": {targetObj: foo, targetFunc: "bar"},
+		//			
+		//					"onblarg": "/foo/bar/baz/blarg",
+		//			
+		//					"onevent": function(evt){
+		//					},
+		//			
+		//					"onotherevent: function(evt){
+		//						// ...
+		//					}
+		//				},
+		//			
+		//				"#id2": {
+		//					// ...
+		//				},
+		//			
+		//				"#id3": function(element){
+		//					// ...
+		//				},
+		//			
+		//				// publish the match on a topic
+		//				"#id4": "/found/topic/name",
+		//			
+		//				// match all direct descendants
+		//				"#id4 > *": function(element){
+		//					// ...
+		//				},
+		//			
+		//				// match the first child node that's an element
+		//				"#id4 > :first-child": { ... },
+		//			
+		//				// match the last child node that's an element
+		//				"#id4 > :last-child":  { ... },
+		//			
+		//				// all elements of type tagname
+		//				"tagname": {
+		//					// ...
+		//				},
+		//			
+		//				"tagname1 tagname2 tagname3": {
+		//					// ...
+		//				},
+		//			
+		//				".classname": {
+		//					// ...
+		//				},
+		//			
+		//				"tagname.classname": {
+		//					// ...
+		//				},
+		//			}
+		//		
+		//		The "found" method is a generalized handler that's called as soon
+		//		as the node matches the selector. Rules for values that follow also
+		//		apply to the "found" key.
+		//		
+		//		The "on*" handlers are attached with dojo.connect(). 
+		//		
+		//		If the value corresponding to the ID key is a function and not a
+		//		list, it's treated as though it was the value of "found".
+
+		var tmpObj = {};
+		forIn(behaviorObj, this, function(behavior, name){
+			var tBehavior = arrIn(this._behaviors, name);
+			if(typeof tBehavior["id"] != "number"){
+				tBehavior.id = _inc++;
+			}
+			var cversion = [];
+			tBehavior.push(cversion);
+			if((dojo.isString(behavior))||(dojo.isFunction(behavior))){
+				behavior = { found: behavior };
+			}
+			forIn(behavior, function(rule, ruleName){
+				arrIn(cversion, ruleName).push(rule);
+			});
+		});
+	}
+
+	var _applyToNode = function(node, action, ruleSetName){
+		if(dojo.isString(action)){
+			if(ruleSetName == "found"){
+				dojo.publish(action, [ node ]);
+			}else{
+				dojo.connect(node, ruleSetName, function(){
+					dojo.publish(action, arguments);
+				});
+			}
+		}else if(dojo.isFunction(action)){
+			if(ruleSetName == "found"){
+				action(node);
+			}else{
+				dojo.connect(node, ruleSetName, action);
+			}
+		}
+	}
+
+	this.apply = function(){
+		// summary:
+		//		applies all currently registered behaviors to the document,
+		//		taking care to ensure that only incremental updates are made
+		//		since the last time add() or apply() were called. If new
+		//		matching nodes have been added, all rules in a behavior will be
+		//		applied to that node. For previously matched nodes, only
+		//		behaviors which have been added since the last call to apply()
+		//		will be added to the nodes.
+		forIn(this._behaviors, function(tBehavior, id){
+			dojo.query(id).forEach( 
+				function(elem){
+					var runFrom = 0;
+					var bid = "_dj_behavior_"+tBehavior.id;
+					if(typeof elem[bid] == "number"){
+						runFrom = elem[bid];
+						// console.debug(bid, runFrom);
+						if(runFrom == (tBehavior.length)){
+							return;
+						}
+					}
+					// run through the versions, applying newer rules at each step
+
+					for(var x=runFrom, tver; tver = tBehavior[x]; x++){
+						// console.debug(tver);
+						forIn(tver, function(ruleSet, ruleSetName){
+							if(dojo.isArray(ruleSet)){
+								dojo.forEach(ruleSet, function(action){
+									_applyToNode(elem, action, ruleSetName);
+								});
+							}
+						});
+					}
+
+					// ensure that re-application only adds new rules to the node
+					elem[bid] = tBehavior.length;
+				}
+			);
+		});
+	}
+}
+
+dojo.addOnLoad(dojo.behavior, "apply");
+
+}
-- 
cgit v1.2.3-54-g00ecf