datatable-base.js revision 03dbde2a7e9a9085567853a25059a0bc411069a8
DATATABLE = "datatable",
TEMPLATE_TH = '<th id="{id}" rowspan="{rowspan}" colspan="{colspan}">{value}</th>',
TEMPLATE_TR = '<tr id="{id}"></tr>',
TEMPLATE_TD = '<td headers="{headers}">{value}</td>',
TEMPLATE_VALUE = '{value}';
}
/*
* Required NAME static field, to identify the Widget class and
* used as an event prefix, to generate class names etc. (set to the
* class name in camel case).
*/
/*
* The attribute configuration for the widget. This defines the core user facing state of the widget
*/
columnset: {
setter: "_setColumnset"
},
//@type Recordset or Array
recordset: {
setter: "_setRecordset"
},
state: {
readOnly: true
},
strings: {
valueFn: function() {
}
},
},
},
trTemplate: {
}
};
/*
* The HTML_PARSER static constant is used if the Widget supports progressive enhancement, and is
* used to populate the configuration for the DTBase instance from markup already on the page.
*/
DTBase.HTML_PARSER = {
// If progressive enhancement is to be supported, return the value of "attrA" based on the contents of the srcNode
}
};
/* DTBase extends the base Widget class */
// Properties
_theadNode: null,
_tbodyNode: null,
_msgNode: null,
// Attributes
_setColumnset: function(columns) {
},
_setRecordset: function(recordset) {
}
return recordset;
},
// Initialization
initializer: function() {
// This set of custom events pass through DOM event facades
//TODO: are the default functions necessary?
this.publish("theadCellClick", {emitFacade:false, defaultFn: BIND("_defTheadCellClickFn", this), queuable:true});
this.publish("theadRowClick", {emitFacade:false, defaultFn: BIND("_defTheadRowClickFn", this), queuable:true});
this.publish("theadClick", {emitFacade:false, defaultFn: BIND("_defTheadClickFn", this), queuable:true});
},
// Destruction
destructor: function() {
},
// UI
renderUI: function() {
// TABLE and CAPTION
var ok = this._createTableNode();
// COLGROUP
// THEAD
// Primary TBODY
// Message TBODY
// CAPTION
return ok;
},
_createTableNode: function() {
if (!this._tableNode) {
}
return this._tableNode;
},
_createColgroupNode: function(tableNode) {
// Add COLs to DOCUMENT FRAGMENT
i = 0,
allCols = ["<colgroup>"];
for(; i<len; ++i) {
}
// Create COLGROUP
this._colgroupNode = tableNode.insertBefore(NODE.create(allCols.join("")), tableNode.get("firstChild"));
return this._colgroupNode;
},
_createTheadNode: function(tableNode) {
if(tableNode) {
this._theadNode = tableNode.insertBefore(NODE.create("<thead class='"+CLASS_DATA+"'></thead>"), this._colgroupNode.next());
return this._theadNode;
}
},
_createTbodyNode: function(tableNode) {
return this._tbodyNode;
},
_createMessageNode: function(tableNode) {
this._msgNode = tableNode.insertBefore(NODE.create("<tbody class='"+CLASS_MSG+"'></tbody>"), this._tbodyNode);
return this._msgNode;
},
_createCaptionNode: function(tableNode) {
return this._captionNode;
},
// Events
bindUI: function() {
var theadNode = this._theadNode,
tbodyNode = this._tbodyNode,
/*
// Set up DOM events for THEAD
theadNode.on("focus", BIND("_onTheadFocus", this));
theadNode.on("keydown", BIND("_onTheadKeydown", this));
theadNode.on("mouseover", BIND("_onTableMouseover", this));
theadNode.on("mouseout", BIND("_onTableMouseout", this));
theadNode.on("mousedown", BIND("_onTableMousedown", this));
theadNode.on("mouseup", BIND("_onTableMouseup", this));
theadNode.on("click", BIND("_onTheadClick", this));
// Since we can't listen for click and dblclick on the same element...
// Attach dblclick separately to contentBox
// theadNode.on("dblclick", BIND("_onTableDblclick", this));
// Set up DOM events for TBODY
tbodyNode.on("focus", BIND("this._onTbodyFocus", this));
tbodyNode.on("mouseover", BIND("_onTableMouseover", this));
tbodyNode.on("mouseout", BIND("_onTableMouseout", this));
tbodyNode.on("mousedown", BIND("_onTableMousedown", this));
tbodyNode.on("mouseup", BIND("_onTableMouseup", this));
tbodyNode.on("keydown", BIND("_onTbodyKeydown", this));
tbodyNode.on("keypress", BIND("_onTableKeypress", this));
tbodyNode.on("click", BIND("_onTbodyClick", this));
// Since we can't listen for click and dblclick on the same element...
// Attach dblick separately to contentBox
// tbodyNode.on("dblclick", BIND("_onTableDblclick", this));
contentBox.on("focus", BIND("_onTableFocus", this));
contentBox.on("dblclick", BIND("_onTableDblclick", this));
// Set up DOM events for msg node
msgNode.on("focus", BIND("_onTbodyFocus", this));
msgNode.on("mouseover", BIND("_onTableMouseover", this));
msgNode.on("mouseout", BIND("_onTableMouseout", this));
msgNode.on("mousedown", BIND("_onTableMousedown", this));
msgNode.on("mouseup", BIND("_onTableMouseup", this));
msgNode.on("keydown", BIND("_onTbodyKeydown", this));
msgNode.on("keypress", BIND("_onTableKeypress", this));
msgNode.on("click", BIND("_onTbodyClick", this));
*/
},
_onTheadFocus: function() {
},
_onTheadKeydown: function() {
},
this.fire("theadCellClick", e);
this.fire("theadRowClick", e);
this.fire("theadClick", e);
},
_onTbodyFocus: function() {
},
_onTbodyKeydown: function() {
},
_onTbodyClick: function() {
},
_onTableMouseover: function() {
},
_onTableMouseout: function() {
},
_onTableMousedown: function() {
},
_onTableMouseup: function() {
},
_onTableKeypress: function() {
},
_onTableFocus: function() {
},
_onTableDblclick: function() {
},
_defTheadCellClickFn: function() {
},
syncUI: function() {
/*
* syncUI is intended to be used by the Widget subclass to
* update the UI to reflect the initial state of the widget,
* after renderUI. From there, the event listeners we bound above
* will take over.
*/
// STRINGS
// HEADER ROWS
// DATA RECORDS
},
/* Listeners, UI update methods */
/**
* Updates the UI if changes are made to any of the strings in the strings
* attribute.
*
* @method _afterStringsChange
* @param e {Event} Custom event for the attribute change
* @protected
*/
_afterStringsChange: function (e) {
this._uiSetStrings(e.newVal);
},
_uiSetStrings: function (strings) {
},
_uiSetSummary: function(val) {
},
_uiSetCaption: function(val) {
},
_afterColumnsetChange: function (e) {
this._uiSetColumnset(e.newVal);
},
_uiSetColumnset: function(cs) {
//TODO
// this._removeHeaderRows();
theadNode = this._theadNode,
tr,
i = 0,
// Iterate tree to add rows
for(; i<len; ++i) {
if(i === 0) {
}
if(i === (len-1)) {
}
}
//TODO
//this._setHeaderFirstLastClasses();
// Column helpers needs _theadNode to exist
//this._createColumnHelpers();
},
_createHeaderTr: function(record) {
return tr;
},
_getHeaderTrMarkup: function(record) {
},
var i = 0,
ths = [],
o;
for(; i<len; ++i) {
//column._set("thNode", thNode);
}
//TODO fire an event with node to append so that you can access the node via a listener
},
_getThNodeMarkup: function(o, column) {
//TODO o.classnames
//TODO o.abbr = column.get("abbr");
/*TODO
// Clear minWidth on hidden Columns
if(column.get("hidden")) {
//this._clearMinWidth(column);
}
*/
return Y.substitute(this.thTemplate, o);
},
_afterRecordsetChange: function (e) {
this._uiSetRecordset(e.newVal);
},
_uiSetRecordset: function(rs) {
var tbodyNode = this._tbodyNode,
i = 0,//TODOthis.get("state.offsetIndex"),
tr,
// Iterate recordset to use existing or add new tr
for(; i<len; ++i) {
}
},
_createBodyTr: function(record) {
this.fire("addDataTr", {record: record, tr: tr}); //on and after are the same state here bc there is no def fn
return tr;
},
_getDataTrMarkup: function(record) {
},
var i = 0,
tds = [];
for(; i<len; ++i) {
}
},
var o = {};
return Y.substitute(this.tdTemplate, o);
},
var o = {};
}
});