egroupware/etemplate/js/et2_dataview_controller.js

675 lines
17 KiB
JavaScript
Raw Normal View History

/**
* eGroupWare eTemplate2
*
* @license http://opensource.org/licenses/gpl-license.php GPL - GNU General Public License
* @package etemplate
* @subpackage dataview
* @link http://www.egroupware.org
* @author Andreas Stöckel
* @copyright Stylite 2011-2012
* @version $Id$
*/
/*egw:uses
et2_core_common;
et2_core_inheritance;
et2_dataview_interfaces;
et2_dataview_controller_selection;
et2_dataview_view_row;
egw_action.egw_action;
*/
/**
* The fetch timeout specifies the time during which the controller tries to
* consolidate requests for rows.
*/
var ET2_DATAVIEW_FETCH_TIMEOUT = 50;
var ET2_DATAVIEW_STEPSIZE = 50;
/**
* The et2_dataview_controller class is the intermediate layer between a grid
* instance and the corresponding data source. It manages updating the grid,
* as well as inserting and deleting rows.
*/
var et2_dataview_controller = Class.extend({
/**
* Constructor of the et2_dataview_controller, connects to the grid
* callback.
*
* @param _grid is the grid the controller should controll.
* @param _dataProvider is an object implementing the et2_IDataProvider
* interface.
* @param _rowCallback is the callback function that gets called when a row
* is requested.
* @param _linkCallback is the callback function that gets called for
* requesting action links for a row. The row data, the index of the row and
* the uid are passed as parameters to the function.
* uid is passed to the function.
* @param _context is the context in which the _rowCallback and the
* _linkCallback are called.
* @param _actionObjectManager is the object that manages the action
* objects.
*/
init: function (_grid, _dataProvider, _rowCallback, _linkCallback, _context,
_actionObjectManager)
{
// Copy the given arguments
this._grid = _grid;
this._dataProvider = _dataProvider;
this._rowCallback = _rowCallback;
this._linkCallback = _linkCallback;
this._context = _context;
// Initialize the "index map" which contains all currently displayed
// containers hashed by the "index"
this._indexMap = {};
// Timer used for queing fetch requests
this._queueTimer = null;
// Array which contains all currently queued indices in the form of
// an associative array
this._queue = {};
// Register the dataFetch callback
this._grid.setDataCallback(this._gridCallback, this);
// Create the selection manager
this._selectionMgr = new et2_dataview_selectionManager(this._indexMap,
_actionObjectManager, this._selectionFetchRange, this);
},
destroy: function () {
// Destroy the selection manager
this._selectionMgr.free();
// Clear the selection timeout
this._clearTimer();
this._super();
},
/**
* The update function queries the server for changes in the currently
* managed index range -- those changes are then merged into the current
* view without a complete rebuild of every row.
*/
update: function () {
// Clear the fetch queue
this._queue = {};
this._clearTimer();
// ---------
// TODO: Actually stuff here should be done if the server responds that
// there at all were some changes (needs implementation of "refresh")
// Remove all rows which are outside the view range
this._grid.cleanup();
// Remove all index entries which are currently not displayed
for (var key in this._indexMap)
{
if (!this._indexMap[key].row)
{
delete this._indexMap[key];
}
}
// ---------
// Get the currently visible range from the grid
var range = this._grid.getIndexRange();
// Force range.top and range.bottom to contain an integer
if (range.top === false)
{
range.top = range.bottom = 0;
}
// Require that range from the server
this._queueFetch(et2_bounds(range.top, range.bottom + 1), true);
},
/**
* Rebuilds the complete grid.
*/
reset: function () {
// Throw away all internal mappings and reset the timestamp
this._indexMap = {};
// Clear the grid
this._grid.clear();
// Update the data
this.update();
},
/**
* Loads the initial order. Do not call multiple times.
*/
loadInitialOrder: function (order) {
for (var i = 0; i < order.length; i++)
{
this._getIndexEntry(i).uid = order[i];
}
},
/* -- PRIVATE FUNCTIONS -- */
_getIndexEntry: function (_idx) {
// Create an entry in the index map if it does not exist yet
if (typeof this._indexMap[_idx] === "undefined")
{
this._indexMap[_idx] = {
"row": null,
"uid": null
};
}
// Always update the index of the entries before returning them. This is
// neccessary, as when we remove the uid from an entry without row, its
// index does not get updated any further
this._indexMap[_idx]["idx"] = _idx;
return this._indexMap[_idx];
},
/**
* Inserts a new data row into the grid. index and uid are derived from the
* given management entry. If the data for the given uid does not exist yet,
* a "loading" placeholder will be shown instead. The function will do
* nothing if there already is a row associated to the entry. This function
* will not re-insert a row if the entry already had a row.
*
* @param _entry is the management entry for the index the row will be
* displayed at.
* @param _update specifies whether the row should be updated if _entry.row
* already exists.
* @return true, if all data for the row has been available, false
* otherwise.
*/
_insertDataRow: function (_entry, _update) {
// Abort if the entry already has a row but the _insert flag is not set
if (_entry.row && !_update)
{
return true;
}
// Context used for the callback functions
var ctx = {"self": this, "entry": _entry};
// Create a new row instance, if it does not exist yet
var createdRow = false;
if (!_entry.row)
{
createdRow = true;
_entry.row = new et2_dataview_row(this._grid);
_entry.row.setDestroyCallback(this._destroyCallback, ctx);
}
// Load the row data if we have a uid for the entry
this.hasData = false; // Gets updated by the _dataCallback
if (_entry.uid)
{
// Register the callback / immediately load the data
this._dataProvider.dataRegisterUID(_entry.uid, this._dataCallback,
ctx);
}
// Display the loading "row prototype" if we don't have data for the row
if (!this.hasData)
{
// Get the average height, the "-5" derives from the td padding
var avg = Math.round(this._grid.getAverageHeight() - 5) + "px";
var prototype = this._grid.getRowProvider().getPrototype("loading");
$j("div", prototype).css("height", avg);
var node = _entry.row.getJNode();
node.empty();
node.append(prototype.children());
}
// Insert the row into the table -- the same row must never be inserted
// twice into the grid, so this function only executes the following
// code only if it is a newly created row.
if (createdRow)
{
this._grid.insertRow(_entry.idx, _entry.row);
}
return this.hasData;
},
/**
* Function which gets called by the grid when data is requested.
*
* @param _idxStart is the index of the first row for which data is
* requested.
* @param _idxEnd is the index of the last requested row.
*/
_gridCallback: function (_idxStart, _idxEnd) {
var needsData = false;
// Iterate over all elements the dataview requested and create a row
// which indicates that we are currently loading data
for (var i = _idxStart; i <= _idxEnd; i++)
{
var entry = this._getIndexEntry(i);
// Insert the row for the entry -- do not update rows which are
// already existing, as we do not have new data for those.
if (!this._insertDataRow(entry, false) && needsData === false)
{
needsData = i;
}
}
// Queue fetching that data range
if (needsData !== false)
{
this._queueFetch(et2_bounds(needsData, _idxEnd + 1), false);
}
},
/**
* The _queueFetch function is used to queue a fetch request.
* TODO: Refresh is currently not used
*/
_queueFetch: function (_range, _isUpdate) {
// Force immediate to be false
_isUpdate = _isUpdate ? _isUpdate : false;
// Push the requests onto the request queue
var start = Math.max(0, _range.top);
var end = Math.min(this._grid.getTotalCount(), _range.bottom);
for (var i = start; i < end; i++)
{
if (typeof this._queue[i] === "undefined")
{
this._queue[i] = 1; // Stage 1 -- queued
}
}
// Start the queue timer, if this has not already been done
if (this._queueTimer === null && !_isUpdate)
{
var self = this;
this._queueTimer = window.setTimeout(function () {
self._flushQueue(false);
}, ET2_DATAVIEW_FETCH_TIMEOUT);
}
if (_isUpdate)
{
this._flushQueue(true);
}
},
/**
* Flushes the queue.
*/
_flushQueue: function (_isUpdate) {
// Clear any still existing timer
this._clearTimer();
// Mark all elements in a radius of ET2_DATAVIEW_STEPSIZE
var marked = {};
var r = _isUpdate ? 0 : Math.floor(ET2_DATAVIEW_STEPSIZE / 2);
var total = this._grid.getTotalCount();
for (var key in this._queue)
{
if (this._queue[key] > 1)
continue;
key = parseInt(key);
var b = Math.max(0, key - r);
var t = Math.min(key + r, total - 1);
var c = 0;
for (var i = b; i <= t && c < ET2_DATAVIEW_STEPSIZE; i ++)
{
if (typeof this._queue[i] == "undefined"
|| this._queue[i] === 1)
{
this._queue[i] = 2; // Stage 2 -- pending or available
marked[i] = true;
c++;
}
}
}
// Create a list with start indices and counts
var fetchList = [];
var entry = null;
var last = 0;
// Get the int keys and sort the array numeric
var arr = et2_arrayIntKeys(marked).sort(
function(a,b){return a > b ? 1 : (a == b ? 0 : -1)});
for (var i = 0; i < arr.length; i++)
{
if (i == 0 || arr[i] - last > 1)
{
if (entry)
{
fetchList.push(entry);
}
entry = {
"start": arr[i],
"count": 1
};
}
else
{
entry.count++;
}
last = arr[i];
}
if (entry)
{
fetchList.push(entry);
}
// Special case: If there are no entries in the fetch list and this is
// an update, create an dummy entry, so that we'll get the current count
if (fetchList.length === 0 && _isUpdate)
{
fetchList.push({
"start": 0, "count": 0
});
}
// Execute all queries
for (var i = 0; i < fetchList.length; i++)
{
// Build the query
var query = {
"start": fetchList[i].start,
"num_rows": fetchList[i].count,
"refresh": false
};
// Context used in the callback function
var ctx = {
"self": this,
"start": query.start,
"count": query.num_rows,
};
// Call the callback
this._dataProvider.dataFetch(query, this._fetchCallback, ctx);
}
},
_clearTimer: function () {
// Reset the queue timer upon destruction
if (this._queueTimer)
{
window.clearTimeout(this._queueTimer);
this._queueTimer = null;
}
},
/**
*
*/
_dataCallback: function (_data) {
// Set the "hasData" flag
this.self.hasData = true;
// Call the row callback with the new data -- the row callback then
// generates the row DOM nodes that will be inserted into the grid
if (this.self._rowCallback)
{
// Remove everything from the current row
this.entry.row.clear();
// Fill the row DOM Node with data
var tr = this.entry.row.getDOMNode();
this.self._rowCallback.call(
this.self._context,
_data,
tr,
this.entry.idx,
this.entry
);
var links = null;
// Get the action links if the links callback is set
if (this.self._linkCallback)
{
links = this.self._linkCallback.call(
this.self._context,
_data,
this.entry.idx,
this.entry.uid
);
}
// Register the row in the selection manager
this.self._selectionMgr.registerRow(this.entry.uid, this.entry.idx,
tr, links);
// Invalidate the current row entry
this.entry.row.invalidate();
}
},
/**
*
*/
_destroyCallback: function (_row) {
// Unregister the row from the selection manager
if (this.entry.row)
{
var tr = this.entry.row.getDOMNode();
this.self._selectionMgr.unregisterRow(this.entry.uid, tr);
}
// There is no further row connected to the entry
this.entry.row = null;
// Unregister the data callback
this.self._dataProvider.dataUnregisterUID(this.entry.uid,
this.self._dataCallback, null);
},
/**
* Returns an array containing "_count" index mapping entries starting from
* the index given in "_start".
*/
_getIndexMapping: function (_start, _count) {
var result = [];
for (var i = _start; i < _start + _count; i++)
{
result.push(this._getIndexEntry(i));
}
return result;
},
/**
* Updates the grid according to the new order. The function simply does the
* following: It iterates along the new order (given in _order) and the old
* order given in _idxMap. Iteration variables used are
* a) i -- points to the current entry in _order
* b) idx -- points to the current grid row that will be effected by
* this operation.
* c) mapIdx -- points to the current entry in _indexMap
* The following cases may occur:
* a) The current entry in the old order has no uid or no row -- in that
* case the row at the current position is simply updated,
* the old pointer will be incremented.
* b) The two uids differ -- insert a new row with the new uid, do not
* increment the old pointer.
* c) The two uids are the same -- increment the old pointer.
* In a last step all rows that are left in the old order are deleted. All
* newly created index entries are returned. This function does not update
* the internal mapping in _idxMap.
*/
_updateOrder: function (_start, _count, _idxMap, _order) {
// The result contains the newly created index map entries which have to
// be merged with the result
var result = [];
// Iterate over the new order
var mapIdx = 0;
var idx = _start;
for (var i = 0; i < _order.length; i++, idx++)
{
var current = _idxMap[mapIdx];
if (!current.row || !current.uid)
{
// If there is no row yet at the current position or the uid
// of that entry is unknown, simply update the entry.
current.uid = _order[i];
current.idx = idx;
// Only update the row, if it is displayed (e.g. has a "loading"
// row displayed) -- this is needed for prefetching
if (current.row)
{
this._insertDataRow(current, true);
}
mapIdx++;
}
else if (current.uid !== _order[i])
{
// Insert a new row at the new position
var entry = {
"idx": idx,
"uid": _order[i],
"row": null
};
this._insertDataRow(entry, true);
// Remember the new entry
result.push(entry);
}
else
{
// Do nothing, the uids do not differ, just update the index of
// the element
current.idx = idx;
mapIdx++;
}
}
// Delete as many rows as we have left, invalidate the corresponding
// index entry
for (var i = mapIdx; i < _idxMap.length; i++)
{
this._grid.deleteRow(idx);
_idxMap[i].uid = null;
}
return result;
},
_mergeResult: function (_newEntries, _invalidStartIdx, _diff, _total) {
if (_newEntries.length > 0 || _diff > 0)
{
// Create a new index map
var newMap = {};
// Insert all new entries into the new index map
for (var i = 0; i < _newEntries.length; i++)
{
newMap[_newEntries[i].idx] = _newEntries[i];
}
// Merge the old map with all old entries
for (var key in this._indexMap)
{
// Get the corresponding index entry
var entry = this._indexMap[key];
// Calculate the new index -- if rows were deleted, we'll
// have to adjust the index
var newIdx = entry.idx >= _invalidStartIdx
? entry.idx - _diff : entry.idx;
if (newIdx >= 0 && newIdx < _total
&& typeof newMap[newIdx] === "undefined")
{
entry.idx = newIdx;
newMap[newIdx] = entry;
}
else
{
// Make sure the old entry gets invalidated
entry.idx = null;
entry.row = null;
}
}
// Make the new index map the current index map
this._indexMap = newMap;
this._selectionMgr.setIndexMap(newMap);
}
},
_fetchCallback: function (_response) {
// Do nothing if _response.order evaluates to false
if (!_response.order)
{
return;
}
// Make sure _response.order.length is not longer than the requested
// count
var order = _response.order.splice(0, this.count);
// Get the current index map for the updated region
var idxMap = this.self._getIndexMapping(this.start, this.count);
// Update the grid using the new order. The _updateOrder function does
// not update the internal mapping while inserting and deleting rows, as
// this would move us to another asymptotic runtime level.
var res = this.self._updateOrder(this.start, this.count, idxMap, order);
// Merge the new indices, update all indices with rows that were not
// affected and invalidate all indices if there were changes
this.self._mergeResult(res, this.start + order.length,
idxMap.length - order.length, _response.total);
// Update the total element count in the grid
this.self._grid.setTotalCount(_response.total);
},
_selectionFetchRange: function (_range, _callback, _context) {
this._dataProvider.dataFetch(
{ "start": _range.top, "num_rows": _range.bottom - _range.top + 1,
"no_data": true },
function (_response) {
_callback.call(_context, _response.order);
}
);
}
});