From e44a7e37b6c7b5961adaffc62b9042b8d442938e Mon Sep 17 00:00:00 2001
From: mensonge <mensonge@b3834d28-1941-0410-a4f8-b48e95affb8f>
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/dojox/data/HtmlStore.js | 531 ++++++++++++++++++++++++++++++++++++
 1 file changed, 531 insertions(+)
 create mode 100644 includes/js/dojox/data/HtmlStore.js

(limited to 'includes/js/dojox/data/HtmlStore.js')

diff --git a/includes/js/dojox/data/HtmlStore.js b/includes/js/dojox/data/HtmlStore.js
new file mode 100644
index 0000000..188aac6
--- /dev/null
+++ b/includes/js/dojox/data/HtmlStore.js
@@ -0,0 +1,531 @@
+if(!dojo._hasResource["dojox.data.HtmlStore"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.data.HtmlStore"] = true;
+dojo.provide("dojox.data.HtmlStore");
+
+dojo.require("dojox.data.dom");
+dojo.require("dojo.data.util.simpleFetch");
+dojo.require("dojo.data.util.filter");
+
+dojo.declare("dojox.data.HtmlStore", null, {
+	constructor: function(/*Object*/args){
+		//	summary:
+		//		Initializer for the HTML table store.  
+		//	description:
+		//		The HtmlStore can be created in one of two ways: a) by parsing an existing
+		//		table or list DOM node on the current page or b) by referencing an external url and giving
+		//		the id of the table or listin that page.  The remote url will be parsed as an html page.
+		//
+		//		The HTML table or list should be of the following form:
+		//
+		//		|	<table id="myTable">
+		//		|		<thead>
+		//		|			<tr>
+		//		|				<th>Attribute1</th>
+		//		|				<th>Attribute2</th>
+		//		|			</tr>
+		//		|		</thead>
+		//		|		<tbody>
+		//		|			<tr>
+		//		|				<td>Value1.1</td>
+		//		|				<td>Value1.2</td>
+		//		|			</tr>
+		//		|			<tr>
+		//		|				<td>Value2.1</td>
+		//		|				<td>Value2.2</td>
+		//		|			</tr>
+		//		|		</tbody>
+		//		|	</table>
+		//
+		// -or-
+		//
+		//		|	<ul id="myUnorderedList">
+		//		|		<li>Value.1</li>
+		//		|		<li>Value.2</li>
+		//		|	</ul>
+		//
+		// -or-
+		//
+		//		|	<ol id="myOrderedList">
+		//		|		<li>Value.1</li>
+		//		|		<li>Value.2</li>
+		//		|	</ol>
+		//
+		//	args:
+		//		An anonymous object to initialize properties.  It expects the following values:
+		//		dataId:	The id of the HTML table to use.
+		//		OR
+		//		url:	The url of the remote page to load
+		//		dataId:	The id of the table element in the remote page
+		
+		if(args.url){
+			if(!args.dataId)
+				throw new Error("dojo.data.HtmlStore: Cannot instantiate using url without an id!");
+			this.url = args.url;
+			this.dataId = args.dataId;
+		}else{
+			if(args.dataId){
+				this._rootNode = dojo.byId(args.dataId);
+				this.dataId = this._rootNode.id;
+			}else{
+				this._rootNode = dojo.byId(this.dataId);
+			}
+			this._indexItems();
+		}
+	},
+
+	url: "",     // So the parser can instantiate the store via markup.
+	dataId: "", // So the parser can instantiate the store via markup.
+	
+	_indexItems: function(){
+		this._getHeadings();
+		if (this._rootNode.rows){//tables
+			if(this._rootNode.tBodies && this._rootNode.tBodies.length > 0) {
+				this._rootNode = this._rootNode.tBodies[0];
+			}
+			var i;
+			for(i=0; i<this._rootNode.rows.length; i++){
+				this._rootNode.rows[i].store = this;
+				this._rootNode.rows[i]._ident = i+1;
+			}
+		}else{//lists
+			var c=1;
+			for(i=0; i<this._rootNode.childNodes.length; i++){
+				if(this._rootNode.childNodes[i].nodeType===1){
+					this._rootNode.childNodes[i].store = this;
+					this._rootNode.childNodes[i]._ident = c;
+					c++;
+				}
+			}
+		}
+	},
+
+	_getHeadings: function(){
+		//	summary:
+		//		Function to load the attribute names from the table header so that the 
+		//		attributes (cells in a row), can have a reasonable name.
+		//      For list items, returns single implicit heading, ["name"]
+		this._headings = [];
+		if(this._rootNode.tHead){
+			dojo.forEach(this._rootNode.tHead.rows[0].cells, dojo.hitch(this, function(th){
+				this._headings.push(dojox.data.dom.textContent(th));
+			}));
+		}else{
+			this._headings = ["name"];
+		}
+	},
+	
+	_getAllItems: function(){
+		//	summary:
+		//		Function to return all rows in the table as an array of items.
+		var items = [];
+                var i;
+		if(this._rootNode.rows){//table
+			for(i=0; i<this._rootNode.rows.length; i++){
+				items.push(this._rootNode.rows[i]);
+			}
+		}else{ //list
+			for(i=0; i<this._rootNode.childNodes.length; i++){
+				if (this._rootNode.childNodes[i].nodeType===1){
+					items.push(this._rootNode.childNodes[i]);
+				}
+			}
+		}
+		return items; //array
+	},
+	
+	_assertIsItem: function(/* item */ item){
+		//	summary:
+		//      This function tests whether the item passed in is indeed an item in the store.
+		//	item: 
+		//		The item to test for being contained by the store.
+		if(!this.isItem(item)){ 
+			throw new Error("dojo.data.HtmlStore: a function was passed an item argument that was not an item");
+		}
+	},
+
+	_assertIsAttribute: function(/* String */ attribute){
+		//	summary:
+		//      This function tests whether the item passed in is indeed a valid 'attribute' like type for the store.
+		//	attribute: 
+		//		The attribute to test for being contained by the store.
+		//
+		//	returns:
+		//		Returns the index (column) that the attribute resides in the row.
+		if(typeof attribute !== "string"){ 
+			throw new Error("dojo.data.HtmlStore: a function was passed an attribute argument that was not an attribute name string");
+			return -1;
+		}
+		return dojo.indexOf(this._headings, attribute); //int
+	},
+
+/***************************************
+     dojo.data.api.Read API
+***************************************/
+	
+	getValue: function(	/* item */ item, 
+						/* attribute-name-string */ attribute, 
+						/* value? */ defaultValue){
+		//	summary: 
+		//      See dojo.data.api.Read.getValue()
+		var values = this.getValues(item, attribute);
+		return (values.length > 0)?values[0]:defaultValue; //Object || int || Boolean
+	},
+
+	getValues: function(/* item */ item, 
+						/* attribute-name-string */ attribute){
+		//	summary: 
+		//		See dojo.data.api.Read.getValues()
+
+		this._assertIsItem(item);
+		var index = this._assertIsAttribute(attribute);
+
+		if(index>-1){
+			if (item.cells){
+			  return [dojox.data.dom.textContent(item.cells[index])];
+			}else{//return Value for lists
+			    return [dojox.data.dom.textContent(item)];
+			}
+		}
+		return []; //Array
+	},
+
+	getAttributes: function(/* item */ item){
+		//	summary: 
+		//		See dojo.data.api.Read.getAttributes()
+		this._assertIsItem(item);
+		var attributes = [];
+		for(var i=0; i<this._headings.length; i++){
+			if(this.hasAttribute(item, this._headings[i]))
+				attributes.push(this._headings[i]);
+		}
+		return attributes; //Array
+	},
+
+	hasAttribute: function(	/* item */ item,
+							/* attribute-name-string */ attribute){
+		//	summary: 
+		//		See dojo.data.api.Read.hasAttribute()
+		return this.getValues(item, attribute).length > 0;
+	},
+
+	containsValue: function(/* item */ item, 
+							/* attribute-name-string */ attribute, 
+							/* anything */ value){
+		//	summary: 
+		//		See dojo.data.api.Read.containsValue()
+		var regexp = undefined;
+		if(typeof value === "string"){
+		   regexp = dojo.data.util.filter.patternToRegExp(value, false);
+		}
+		return this._containsValue(item, attribute, value, regexp); //boolean.
+	},
+
+	_containsValue: function(	/* item */ item, 
+								/* attribute-name-string */ attribute, 
+								/* anything */ value,
+								/* RegExp?*/ regexp){
+		//	summary: 
+		//		Internal function for looking at the values contained by the item.
+		//	description: 
+		//		Internal function for looking at the values contained by the item.  This 
+		//		function allows for denoting if the comparison should be case sensitive for
+		//		strings or not (for handling filtering cases where string case should not matter)
+		//	
+		//	item:
+		//		The data item to examine for attribute values.
+		//	attribute:
+		//		The attribute to inspect.
+		//	value:	
+		//		The value to match.
+		//	regexp:
+		//		Optional regular expression generated off value if value was of string type to handle wildcarding.
+		//		If present and attribute values are string, then it can be used for comparison instead of 'value'
+		var values = this.getValues(item, attribute);
+		for(var i = 0; i < values.length; ++i){
+			var possibleValue = values[i];
+			if(typeof possibleValue === "string" && regexp){
+				return (possibleValue.match(regexp) !== null);
+			}else{
+				//Non-string matching.
+				if(value === possibleValue){
+					return true; // Boolean
+				}
+			}
+		}
+		return false; // Boolean
+	},
+
+	isItem: function(/* anything */ something){
+		//	summary: 
+		//		See dojo.data.api.Read.isItem()
+		if(something && something.store && something.store === this){
+			return true; //boolean
+		}
+		return false; //boolean
+	},
+
+	isItemLoaded: function(/* anything */ something){
+		//	summary: 
+		//		See dojo.data.api.Read.isItemLoaded()
+		return this.isItem(something);
+	},
+
+	loadItem: function(/* Object */ keywordArgs){
+		//	summary: 
+		//		See dojo.data.api.Read.loadItem()
+		this._assertIsItem(keywordArgs.item);
+	},
+	
+	_fetchItems: function(request, fetchHandler, errorHandler){
+		//	summary:
+		//		Fetch items (XML elements) that match to a query
+		//	description:
+		//		If '_fetchUrl' is specified, it is used to load an XML document
+		//		with a query string.
+		//		Otherwise and if 'url' is specified, the XML document is
+		//		loaded and list XML elements that match to a query (set of element
+		//		names and their text attribute values that the items to contain).
+		//		A wildcard, "*" can be used to query values to match all
+		//		occurrences.
+		//		If '_rootItem' is specified, it is used to fetch items.
+		//	request:
+		//		A request object
+		//	fetchHandler:
+		//		A function to call for fetched items
+		//	errorHandler:
+		//		A function to call on error
+		
+		if(this._rootNode){
+			this._finishFetchItems(request, fetchHandler, errorHandler);
+		}else{
+			if(!this.url){
+				this._rootNode = dojo.byId(this.dataId);
+			}else{
+				var getArgs = {
+						url: this.url,
+						handleAs: "text"
+					};
+				var self = this;
+				var getHandler = dojo.xhrGet(getArgs);
+				getHandler.addCallback(function(data){
+					var findNode = function(node, id){
+						if(node.id == id){
+							return node; //object
+						}
+						if(node.childNodes){
+							for(var i=0; i<node.childNodes.length; i++){
+								var returnNode = findNode(node.childNodes[i], id);
+								if(returnNode){
+									return returnNode; //object
+								}
+							}
+						}
+						return null; //null
+					}
+
+					var d = document.createElement("div");
+					d.innerHTML = data;
+					self._rootNode = findNode(d, self.dataId);
+					self._indexItems();
+					self._finishFetchItems(request, fetchHandler, errorHandler);
+				});
+				getHandler.addErrback(function(error){
+					errorHandler(error, request);
+				});
+			}
+		}
+	},
+	
+	_finishFetchItems: function(request, fetchHandler, errorHandler){
+		//	summary:
+		//		Internal function for processing the passed in request and locating the requested items.
+		var items = null;
+		var arrayOfAllItems = this._getAllItems();
+		if(request.query){
+			var ignoreCase = request.queryOptions ? request.queryOptions.ignoreCase : false; 
+			items = [];
+
+			//See if there are any string values that can be regexp parsed first to avoid multiple regexp gens on the
+			//same value for each item examined.  Much more efficient.
+			var regexpList = {};
+			var key;
+                        var value;
+			for(key in request.query){
+				value = request.query[key]+'';
+				if(typeof value === "string"){
+					regexpList[key] = dojo.data.util.filter.patternToRegExp(value, ignoreCase);
+				}
+			}
+
+			for(var i = 0; i < arrayOfAllItems.length; ++i){
+				var match = true;
+				var candidateItem = arrayOfAllItems[i];
+				for(key in request.query){
+					value = request.query[key]+'';
+					if (!this._containsValue(candidateItem, key, value, regexpList[key])){
+						match = false;
+					}
+				}
+				if(match){
+					items.push(candidateItem);
+				}
+			}
+			fetchHandler(items, request);
+		}else{
+			// We want a copy to pass back in case the parent wishes to sort the array.  We shouldn't allow resort 
+			// of the internal list so that multiple callers can get listsand sort without affecting each other.
+			if(arrayOfAllItems.length> 0){
+				items = arrayOfAllItems.slice(0,arrayOfAllItems.length); 
+			}
+			fetchHandler(items, request);
+		}
+	},
+
+	getFeatures: function(){
+		//	summary: 
+		//		See dojo.data.api.Read.getFeatures()
+		return {
+			'dojo.data.api.Read': true,
+			'dojo.data.api.Identity': true
+		};
+	},
+	
+	close: function(/*dojo.data.api.Request || keywordArgs || null */ request){
+		//	summary:
+		//		See dojo.data.api.Read.close()
+		// nothing to do here!
+	},
+
+	getLabel: function(/* item */ item){
+		//	summary: 
+		//		See dojo.data.api.Read.getLabel()
+		if(this.isItem(item)){
+			if(item.cells){
+				return "Item #" + this.getIdentity(item);
+			}else{
+				return this.getValue(item,"name");
+			}
+		}
+		return undefined;
+	},
+
+	getLabelAttributes: function(/* item */ item){
+		//	summary: 
+		//		See dojo.data.api.Read.getLabelAttributes()
+		if(item.cells){
+			return null;
+		}else{
+			return ["name"];
+		}
+	},
+
+/***************************************
+     dojo.data.api.Identity API
+***************************************/
+
+	getIdentity: function(/* item */ item){
+		//	summary: 
+		//		See dojo.data.api.Identity.getIdentity()
+		this._assertIsItem(item);
+		if(this.hasAttribute(item, "name")){
+		 	return this.getValue(item,"name");
+		}else{
+			return item._ident;
+		}
+	},
+
+	getIdentityAttributes: function(/* item */ item){
+		 //	summary: 
+		 //		See dojo.data.api.Identity.getIdentityAttributes()
+		 //Identity isn't taken from a public attribute.
+		 return null;
+	},
+
+	fetchItemByIdentity: function(keywordArgs){
+		//	summary: 
+		//		See dojo.data.api.Identity.fetchItemByIdentity()
+		var identity = keywordArgs.identity;
+		var self = this;
+		var item = null;
+		var scope = null;
+
+		if(!this._rootNode){
+			if(!this.url){
+				this._rootNode = dojo.byId(this.dataId);
+				this._indexItems();
+				if(self._rootNode.rows){ //Table
+					item = this._rootNode.rows[identity + 1];
+				}else{ //Lists
+					for(var i = 0; i < self._rootNode.childNodes.length; i++){
+						if(self._rootNode.childNodes[i].nodeType === 1 && identity === dojox.data.dom.textContent(self._rootNode.childNodes[i])) {
+								item = self._rootNode.childNodes[i];
+						}
+					}
+				}
+				if(keywordArgs.onItem){
+					scope = keywordArgs.scope?keywordArgs.scope:dojo.global;
+					keywordArgs.onItem.call(scope, item);
+				}
+
+			}else{
+				var getArgs = {
+						url: this.url,
+						handleAs: "text"
+					};
+				var getHandler = dojo.xhrGet(getArgs);
+				getHandler.addCallback(function(data){
+					var findNode = function(node, id){
+						if(node.id == id){
+							return node; //object
+						}
+						if(node.childNodes){
+							for(var i=0; i<node.childNodes.length; i++){
+								var returnNode = findNode(node.childNodes[i], id);
+								if(returnNode){
+									return returnNode; //object
+								}
+							}
+						}
+						return null; //null
+					}
+					var d = document.createElement("div");
+					d.innerHTML = data;
+					self._rootNode = findNode(d, self.dataId);
+					self._indexItems();
+					if(self._rootNode.rows && identity <= self._rootNode.rows.length){ //Table
+						item = self._rootNode.rows[identity-1];
+					}else{ //List
+						for(var i = 0; i < self._rootNode.childNodes.length; i++){
+							if(self._rootNode.childNodes[i].nodeType === 1 && identity === dojox.data.dom.textContent(self._rootNode.childNodes[i])) {
+									item = self._rootNode.childNodes[i];
+									break;
+							}
+						}
+					}
+					if(keywordArgs.onItem){
+						scope = keywordArgs.scope?keywordArgs.scope:dojo.global;
+						keywordArgs.onItem.call(scope, item);
+					}
+				});
+				getHandler.addErrback(function(error){
+					if(keywordArgs.onError){
+						scope = keywordArgs.scope?keywordArgs.scope:dojo.global;
+						keywordArgs.onError.call(scope, error);
+
+					}
+				});
+			}
+		}else{
+			if(this._rootNode.rows[identity+1]){
+				item = this._rootNode.rows[identity+1];
+				if(keywordArgs.onItem){
+					scope = keywordArgs.scope?keywordArgs.scope:dojo.global;
+					keywordArgs.onItem.call(scope, item);
+				}
+			}
+		}
+	}
+});
+dojo.extend(dojox.data.HtmlStore,dojo.data.util.simpleFetch);
+
+}
-- 
cgit v1.2.3