Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dojox.data.HtmlTableStore"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.

dojo._hasResource["dojox.data.HtmlTableStore"] = true;

dojo.provide("dojox.data.HtmlTableStore");

dojo.require("dojox.data.dom");

dojo.require("dojo.data.util.simpleFetch");

dojo.require("dojo.data.util.filter");

dojo.declare("dojox.data.HtmlTableStore", null, {

	constructor: function(/*Object*/args){

		//	summary:

		//		Initializer for the HTML table store.

		//	description:

		//		The HtmlTableStore can be created in one of two ways: a) by parsing an existing

		//		table DOM node on the current page or b) by referencing an external url and giving

		//		the id of the table in that page.  The remote url will be parsed as an html page.

		//

		//		The HTML table 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>

		//

		//	args:

		//		An anonymous object to initialize properties.  It expects the following values:

		//		tableId:	The id of the HTML table to use.

		//		OR

		//		url:		The url of the remote page to load

		//		tableId:	The id of the table element in the remote page

		if(args.url){

			if(!args.tableId)

				throw new Error("dojo.data.HtmlTableStore: Cannot instantiate using url without an id!");

			this.url = args.url;

			this.tableId = args.tableId;

		}else{

			if(args.tableId){

				this._rootNode = dojo.byId(args.tableId);

				this.tableId = this._rootNode.id;

			}else{

				this._rootNode = dojo.byId(this.tableId);

			}

			this._getHeadings();

			for(var i=0; i<this._rootNode.rows.length; i++){

				this._rootNode.rows[i].store = this;

			}

		}

	},

	url: "",     // So the parser can instantiate the store via markup.

	tableId: "", // So the parser can instantiate the store via markup.

	_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.

		this._headings = [];

		dojo.forEach(this._rootNode.tHead.rows[0].cells, dojo.hitch(this, function(th){

			this._headings.push(dojox.data.dom.textContent(th));

		}));

	},

	_getAllItems: function(){

		//	summary:

		//		Function to return all rows in the table as an array of items.

		var items = [];

		for(var i=1; i<this._rootNode.rows.length; i++){

			items.push(this._rootNode.rows[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.HtmlTableStore: 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.HtmlTableStore: a function was passed an attribute argument that was not an attribute name string");

			return;

		}

		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){

			return [dojox.data.dom.textContent(item.cells[index])] ;

		}

		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.tableId);

				this._getHeadings();

				for(var i=0; i<this._rootNode.rows.length; i++){

					this._rootNode.rows[i].store = this;

				}

			}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.tableId);

					self._getHeadings.call(self);

					for(var i=0; i<self._rootNode.rows.length; i++) {

						self._rootNode.rows[i].store = self;

					}

					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 = {};

			for(var key in request.query){

				var 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(var key in request.query){

					var 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))

			return "Table Row #" + this.getIdentity(item);

		return undefined;

	},

	getLabelAttributes: function(/* item */ item){

		//	summary:

		//		See dojo.data.api.Read.getLabelAttributes()

		return null;

	},

/***************************************

     dojo.data.api.Identity API

***************************************/

	getIdentity: function(/* item */ item){

		//	summary:

		//		See dojo.data.api.Identity.getIdentity()

		this._assertIsItem(item);

		//Opera doesn't support the sectionRowIndex,

		//So, have to call the indexOf to locate it.

		//Blah.

		if(!dojo.isOpera){

			return item.sectionRowIndex; // int

		}else{

			return (dojo.indexOf(this._rootNode.rows, item) - 1) // int

		}

	},

	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

		if(!this._rootNode){

			if(!this.url){

				this._rootNode = dojo.byId(this.tableId);

				this._getHeadings();

				for(var i=0; i<this._rootNode.rows.length; i++){

					this._rootNode.rows[i].store = this;

				}

				item = this._rootNode.rows[identity+1];

				if (keywordArgs.onItem){

					var scope = keywordArgs.scope?keywordArgs.scope:dojo.global;

					keywordArgs.onItem.call(scope, item);

				}

			}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.tableId);

					self._getHeadings.call(self);

					for(var i=0; i<self._rootNode.rows.length; i++){

						self._rootNode.rows[i].store = self;

					}

					item = self._rootNode.rows[identity+1];

					if (keywordArgs.onItem){

						var scope = keywordArgs.scope?keywordArgs.scope:dojo.global;

						keywordArgs.onItem.call(scope, item);

					}

				});

				getHandler.addErrback(function(error){

					if(keywordArgs.onError){

						var 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){

					var scope = keywordArgs.scope?keywordArgs.scope:dojo.global;

					keywordArgs.onItem.call(scope, item);

				}

			}

		}

	}

});

dojo.extend(dojox.data.HtmlTableStore,dojo.data.util.simpleFetch);

}