Page MenuHomeCode
Files F886092

HtmlTableStore.js
No OneTemporary
Actions

HtmlTableStore.js
View Options

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

File Metadata

Mime Type
text/html
Expires
Sun, Apr 6, 22:24 (2 w, 2 d ago)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
26445
Default Alt Text
HtmlTableStore.js (13 KB)

Event Timeline