New file |
0,0 → 1,466 |
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); |
|
} |