mirror of
https://github.com/EGroupware/egroupware.git
synced 2024-10-06 01:52:08 +02:00
815 lines
34 KiB
JavaScript
815 lines
34 KiB
JavaScript
"use strict";
|
|
/**
|
|
* 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
|
|
|
|
/*egw:uses
|
|
et2_core_common;
|
|
et2_core_inheritance;
|
|
|
|
et2_dataview_interfaces;
|
|
et2_dataview_controller_selection;
|
|
et2_dataview_view_row;
|
|
et2_dataview_view_tile;
|
|
|
|
egw_action.egw_action;
|
|
*/
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var et2_dataview_controller_selection_1 = require("./et2_dataview_controller_selection");
|
|
var et2_dataview_view_row_1 = require("./et2_dataview_view_row");
|
|
/**
|
|
* 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 */ (function () {
|
|
/**
|
|
* Constructor of the et2_dataview_controller, connects to the grid
|
|
* callback.
|
|
*
|
|
* @param _grid is the grid the controller should controll.
|
|
* @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 _actionObjectManager is the object that manages the action
|
|
* objects.
|
|
*/
|
|
function et2_dataview_controller(_parentController, _grid) {
|
|
this._indexMap = {};
|
|
// Copy the given arguments
|
|
this._parentController = _parentController;
|
|
this._grid = _grid;
|
|
// Initialize list of child controllers
|
|
this._children = [];
|
|
// 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 row indices in the form of
|
|
// an associative array
|
|
this._queue = {};
|
|
// Current concurrent requests we have
|
|
this._request_queue = [];
|
|
// Register the dataFetch callback
|
|
this._grid.setDataCallback(this._gridCallback, this);
|
|
// Record the child
|
|
if (this._parentController != null) {
|
|
this._parentController._children.push(this);
|
|
}
|
|
}
|
|
et2_dataview_controller.prototype.destroy = function () {
|
|
// Destroy the selection manager
|
|
this._selectionMgr.destroy();
|
|
// Clear the selection timeout
|
|
this._clearTimer();
|
|
// Remove the child from the child list
|
|
if (this._parentController != null) {
|
|
var idx = this._parentController._children.indexOf(this);
|
|
if (idx >= 0) {
|
|
// This element is no longer parent of the child
|
|
this._parentController._children.splice(idx, 1);
|
|
this._parentController = null;
|
|
}
|
|
}
|
|
};
|
|
/**
|
|
* @param value is an object implementing the et2_IDataProvider
|
|
* interface
|
|
*/
|
|
et2_dataview_controller.prototype.setDataProvider = function (value) {
|
|
this._dataProvider = value;
|
|
};
|
|
et2_dataview_controller.prototype.setRowCallback = function (value) {
|
|
this._rowCallback = value;
|
|
};
|
|
et2_dataview_controller.prototype.setLinkCallback = function (value) {
|
|
this._linkCallback = value;
|
|
};
|
|
/**
|
|
* @param value is the context in which the _rowCallback and the
|
|
* _linkCallback are called.
|
|
*/
|
|
et2_dataview_controller.prototype.setContext = function (value) {
|
|
this._context = value;
|
|
};
|
|
et2_dataview_controller.prototype.setActionObjectManager = function (_actionObjectManager) {
|
|
if (this._selectionMgr) {
|
|
this._selectionMgr.destroy();
|
|
}
|
|
// Create the selection manager
|
|
this._selectionMgr = new et2_dataview_controller_selection_1.et2_dataview_selectionManager(this._parentController ? this._parentController._selectionMgr : null, this._indexMap, _actionObjectManager, this._selectionFetchRange, this._makeIndexVisible, this);
|
|
};
|
|
/**
|
|
* 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.
|
|
*
|
|
* @param {boolean} clear Skip the fancy stuff, dump everything and start again.
|
|
* Completely clears the grid and selection.
|
|
*/
|
|
et2_dataview_controller.prototype.update = function (clear) {
|
|
// ---------
|
|
// TODO: Actually stuff here should be done if the server responds that
|
|
// there at all were some changes (needs implementation of "refresh")
|
|
// Tell the grid not to try and update itself while we do this
|
|
this._grid.doInvalidate = false;
|
|
if (clear) {
|
|
// Scroll to top
|
|
this._grid.makeIndexVisible(0);
|
|
this._grid.clear();
|
|
// Free selection manager
|
|
this._selectionMgr.clear();
|
|
// Clear object manager
|
|
this._objectManager.clear();
|
|
// Clear the map
|
|
this._indexMap = {};
|
|
// Update selection manager, it uses this by reference
|
|
this._selectionMgr.setIndexMap(this._indexMap);
|
|
// Clear the queue
|
|
this._queue = {};
|
|
// Invalidate the change detection, re-fetches any known rows
|
|
this._lastModification = 0;
|
|
}
|
|
// Remove all rows which are outside the view range
|
|
this._grid.cleanup();
|
|
// 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;
|
|
}
|
|
this._request_queue = [];
|
|
// Require that range from the server
|
|
this._queueFetch(et2_bounds(range.top, clear ? 0 : range.bottom + 1), 0, true);
|
|
};
|
|
/**
|
|
* Rebuilds the complete grid.
|
|
*/
|
|
et2_dataview_controller.prototype.reset = function () {
|
|
// Throw away all internal mappings and reset the timestamp
|
|
this._indexMap = {};
|
|
// Update selection manager, it uses this by reference
|
|
this._selectionMgr.setIndexMap(this._indexMap);
|
|
// Clear the grid
|
|
this._grid.clear();
|
|
// Clear the row queue
|
|
this._queue = {};
|
|
// Reset the request queue
|
|
this._request_queue = [];
|
|
// Update the data
|
|
this.update();
|
|
};
|
|
/**
|
|
* Loads the initial order. Do not call multiple times.
|
|
*/
|
|
et2_dataview_controller.prototype.loadInitialOrder = function (order) {
|
|
for (var i = 0; i < order.length; i++) {
|
|
this._getIndexEntry(i).uid = order[i];
|
|
}
|
|
};
|
|
/**
|
|
* Load initial data
|
|
*
|
|
* @param {string} uid_key Name of the unique row identifier field
|
|
* @param {Object} data Key / Value mapping of initial data.
|
|
*/
|
|
et2_dataview_controller.prototype.loadInitialData = function (uid_prefix, uid_key, data) {
|
|
var idx = 0;
|
|
for (var key in data) {
|
|
// Skip any extra keys
|
|
if (typeof data[key] != "object" || data[key] == null || typeof data[key][uid_key] == "undefined")
|
|
continue;
|
|
// Add to row / uid map
|
|
var entry = this._getIndexEntry(idx++);
|
|
entry.uid = data[key][uid_key] + "";
|
|
if (entry.uid.indexOf(uid_prefix) < 0) {
|
|
entry.uid = uid_prefix + "::" + entry.uid;
|
|
}
|
|
// Add to data cache so grid will find it
|
|
egw.dataStoreUID(entry.uid, data[key]);
|
|
// Don't try to insert the rows, grid will do that automatically
|
|
}
|
|
if (idx == 0) {
|
|
// No rows, start with an empty
|
|
this._selectionMgr.clear();
|
|
this._emptyRow(this._grid._total == 0);
|
|
}
|
|
};
|
|
/**
|
|
* Returns the depth of the controller instance.
|
|
*/
|
|
et2_dataview_controller.prototype.getDepth = function () {
|
|
if (this._parentController) {
|
|
return this._parentController.getDepth() + 1;
|
|
}
|
|
return 0;
|
|
};
|
|
/**
|
|
* Set the data cache prefix
|
|
* The default is to use appname, but if you need to set it explicitly to
|
|
* something else to avoid conflicts. Use the same prefix everywhere for
|
|
* each type of data. eg. infolog for infolog entries, even if accessed via addressbook
|
|
*/
|
|
et2_dataview_controller.prototype.setPrefix = function (prefix) {
|
|
this.dataStorePrefix = prefix;
|
|
};
|
|
/**
|
|
* Returns the row information of the passed node, or null if not available
|
|
*
|
|
* @param {DOMNode} node
|
|
* @return {string|false} UID, or false if not found
|
|
*/
|
|
et2_dataview_controller.prototype.getRowByNode = function (node) {
|
|
// Whatever the node, find a TR
|
|
var row_node = jQuery(node).closest('tr');
|
|
var row = null;
|
|
// Check index map - simple case
|
|
var indexed = this._getIndexEntry(row_node.index());
|
|
if (indexed && indexed.row && indexed.row.getDOMNode() == row_node[0]) {
|
|
row = indexed;
|
|
}
|
|
else {
|
|
// Check whole index map
|
|
for (var index in this._indexMap) {
|
|
indexed = this._indexMap[index];
|
|
if (indexed && indexed.row && indexed.row.getDOMNode() == row_node[0]) {
|
|
row = indexed;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// Check children
|
|
for (var i = 0; !row && i < this._children.length; i++) {
|
|
var child_row = this._children[i].getRowByNode(node);
|
|
if (child_row !== false)
|
|
row = child_row;
|
|
}
|
|
if (row && !row.controller) {
|
|
row.controller = this;
|
|
}
|
|
return row;
|
|
};
|
|
/* -- PRIVATE FUNCTIONS -- */
|
|
et2_dataview_controller.prototype._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.
|
|
*/
|
|
et2_dataview_controller.prototype._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 = this._createRow(ctx);
|
|
_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");
|
|
jQuery("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 && _entry.row) {
|
|
this._grid.insertRow(_entry.idx, _entry.row);
|
|
}
|
|
return this.hasData;
|
|
};
|
|
/**
|
|
* Create a new row.
|
|
*
|
|
* @param {type} ctx
|
|
* @returns {et2_dataview_container}
|
|
*/
|
|
et2_dataview_controller.prototype._createRow = function (ctx) {
|
|
return new et2_dataview_view_row_1.et2_dataview_row(this._grid);
|
|
};
|
|
/**
|
|
* 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.
|
|
*/
|
|
et2_dataview_controller.prototype._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), needsData == _idxStart ? 0 : needsData > _idxStart ? 1 : -1, false);
|
|
}
|
|
};
|
|
/**
|
|
* The _queueFetch function is used to queue a fetch request.
|
|
* TODO: Refresh is currently not used
|
|
*/
|
|
et2_dataview_controller.prototype._queueFetch = function (_range, _direction, _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] = _direction; // Stage 1 - queue for after current, -1 -- queue for before current
|
|
}
|
|
}
|
|
// Start the queue timer, if this has not already been done
|
|
if (this._queueTimer === null && !_isUpdate) {
|
|
var self = this;
|
|
egw.debug('log', 'Dataview queue: ', _range);
|
|
this._queueTimer = window.setTimeout(function () {
|
|
self._flushQueue(false);
|
|
}, ET2_DATAVIEW_FETCH_TIMEOUT);
|
|
}
|
|
if (_isUpdate) {
|
|
this._flushQueue(true);
|
|
}
|
|
};
|
|
/**
|
|
* Flushes the queue.
|
|
*/
|
|
et2_dataview_controller.prototype._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 + (r * this._queue[key]));
|
|
var t = Math.min(key + r + (r * this._queue[key]), 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
|
|
});
|
|
// Disable grid invalidate, or it might request again before we're done
|
|
this._grid.doInvalidate = false;
|
|
}
|
|
egw.debug("log", "Dataview flush", fetchList);
|
|
// 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,
|
|
"lastModification": this._lastModification
|
|
};
|
|
if (this.dataStorePrefix) {
|
|
ctx.prefix = this.dataStorePrefix;
|
|
}
|
|
this._queueRequest(query, ctx);
|
|
}
|
|
};
|
|
/**
|
|
* Queue a request for data
|
|
* @param {Object} query
|
|
* @param {Object} ctx
|
|
*/
|
|
et2_dataview_controller.prototype._queueRequest = function (query, ctx) {
|
|
this._request_queue.push({
|
|
query: query,
|
|
context: ctx,
|
|
// Start pending, set to 1 when request sent
|
|
status: 0
|
|
});
|
|
this._fetchQueuedRequest();
|
|
};
|
|
/**
|
|
* Fetch data for a queued request, subject to rate limit
|
|
*/
|
|
et2_dataview_controller.prototype._fetchQueuedRequest = function () {
|
|
// Check to see if there's room
|
|
var count = 0;
|
|
for (var i = 0; i < this._request_queue.length; i++) {
|
|
if (this._request_queue[i].status > 0)
|
|
count++;
|
|
}
|
|
// Too many requests, will try again after response is received
|
|
if (count >= et2_dataview_controller.CONCURRENT_REQUESTS || this._request_queue.length === 0) {
|
|
return;
|
|
}
|
|
// Keep at least 1 previous pending
|
|
var keep = 1;
|
|
// The most recent is the one the user's most interested in
|
|
var request = null;
|
|
for (var i = this._request_queue.length - 1; i >= 0; i--) {
|
|
// Only interested in pending requests (status 0)
|
|
if (this._request_queue[i].status != 0) {
|
|
continue;
|
|
}
|
|
if (request == null) {
|
|
request = this._request_queue[i];
|
|
}
|
|
else if (keep > 0) {
|
|
keep--;
|
|
}
|
|
else if (keep <= 0) {
|
|
// Cancel pending, they've probably scrolled past.
|
|
this._request_queue.splice(i, 1);
|
|
}
|
|
}
|
|
if (request == null)
|
|
return;
|
|
// Request being sent
|
|
request.status = 1;
|
|
// Call the callback
|
|
this._dataProvider.dataFetch(request.query, this._fetchCallback, request.context);
|
|
};
|
|
et2_dataview_controller.prototype._clearTimer = function () {
|
|
// Reset the queue timer upon destruction
|
|
if (this._queueTimer) {
|
|
window.clearTimeout(this._queueTimer);
|
|
this._queueTimer = null;
|
|
}
|
|
};
|
|
/**
|
|
* Called by the data source when the data changes
|
|
*
|
|
* @param _data Object|null New data, or null. Null will remove the row.
|
|
*/
|
|
et2_dataview_controller.prototype._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();
|
|
// If there's no data, stop
|
|
if (typeof _data == "undefined" || _data == null) {
|
|
this.self._destroyCallback.call(this, this.entry.row);
|
|
return;
|
|
}
|
|
// Fill the row DOM Node with data
|
|
this.self._rowCallback.call(this.self._context, _data, this.entry.row, this.entry.idx, this.entry);
|
|
// Attach the "subgrid" tag to the row, if the depth of this
|
|
// controller is larger than zero
|
|
var tr = this.entry.row.getDOMNode();
|
|
var d = this.self.getDepth();
|
|
if (d > 0) {
|
|
jQuery(tr).addClass("subentry");
|
|
jQuery("td:first", tr).children("div").last().addClass("level_" + d + " indentation");
|
|
if (this.entry.idx == 0) {
|
|
// Set the CSS for the level - required so columns line up
|
|
var indent = jQuery("<span class='indentation'/>").appendTo('body');
|
|
egw.css(".subentry td div.innerContainer.level_" + d, "margin-right:" + (parseInt(indent.css("margin-right")) * d) + "px");
|
|
indent.remove();
|
|
}
|
|
}
|
|
var links = null;
|
|
// Look for a flag in the row to avoid actions. Use for sums or extra header rows.
|
|
if (!_data.no_actions) {
|
|
// 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);
|
|
}
|
|
else {
|
|
// Remember that
|
|
this.entry.no_actions = true;
|
|
}
|
|
// Invalidate the current row entry
|
|
this.entry.row.invalidate();
|
|
}
|
|
};
|
|
/**
|
|
*
|
|
*/
|
|
et2_dataview_controller.prototype._destroyCallback = function (_row) {
|
|
// Unregister the row from the selection manager, if not selected
|
|
// If it is selected, leave it there - allows selecting rows and scrolling
|
|
var selection = this.self._selectionMgr._getRegisteredRowsEntry(this.entry.uid);
|
|
if (this.entry.row && selection && !egwBitIsSet(selection.state, EGW_AO_STATE_SELECTED)) {
|
|
var tr = this.entry.row.getDOMNode();
|
|
this.self._selectionMgr._updateState(this.entry.uid, EGW_AO_STATE_NORMAL);
|
|
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, this);
|
|
};
|
|
/**
|
|
* Returns an array containing "_count" index mapping entries starting from
|
|
* the index given in "_start".
|
|
*/
|
|
et2_dataview_controller.prototype._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.
|
|
*/
|
|
et2_dataview_controller.prototype._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++) {
|
|
if (typeof _idxMap[i] != 'undefined') {
|
|
_idxMap[i].uid = null;
|
|
}
|
|
}
|
|
return result;
|
|
};
|
|
et2_dataview_controller.prototype._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);
|
|
}
|
|
};
|
|
et2_dataview_controller.prototype._fetchCallback = function (_response) {
|
|
// Remove answered request from queue
|
|
var request = null;
|
|
for (var i = 0; i < this.self._request_queue.length; i++) {
|
|
if (this.self._request_queue[i].context == this) {
|
|
request = this.self._request_queue[i];
|
|
this.self._request_queue.splice(i, 1);
|
|
break;
|
|
}
|
|
}
|
|
this.self._lastModification = _response.lastModification;
|
|
// Do nothing if _response.order evaluates to false
|
|
if (!_response.order) {
|
|
return;
|
|
}
|
|
// Make sure _response.order.length is not longer than the requested
|
|
// count, if a specific count was requested
|
|
var order = this.count != 0 ? _response.order.splice(0, this.count) : _response.order;
|
|
// Remove from queue, or it will not be fetched again
|
|
if (_response.total < this.count) {
|
|
// Less rows than we expected
|
|
// Clear the queue, or the remnants will never be loaded again
|
|
this.self._queue = {};
|
|
}
|
|
else {
|
|
for (var i = this.start; i < this.start + order.length; i++)
|
|
delete this.self._queue[i];
|
|
}
|
|
// Get the current index map for the updated region
|
|
var idxMap = this.self._getIndexMapping(this.start, order.length);
|
|
// 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);
|
|
if (_response.total == 0) {
|
|
this.self._emptyRow(true);
|
|
}
|
|
else {
|
|
var row = jQuery(".egwGridView_empty", this.self._grid.innerTbody).remove();
|
|
this.self._selectionMgr.unregisterRow("", 0, row.get(0));
|
|
}
|
|
// Now it's OK to invalidate, if it wasn't before
|
|
this.self._grid.doInvalidate = true;
|
|
// Update the total element count in the grid
|
|
this.self._grid.setTotalCount(_response.total);
|
|
this.self._selectionMgr.setTotalCount(_response.total);
|
|
// Schedule an invalidate, in case total is the same
|
|
this.self._grid.invalidate();
|
|
// Check if requests are waiting
|
|
this.self._fetchQueuedRequest();
|
|
};
|
|
/**
|
|
* Insert an empty / placeholder row when there is no data to display
|
|
*/
|
|
et2_dataview_controller.prototype._emptyRow = function (_noRows) {
|
|
var noRows = !_noRows ? false : true;
|
|
jQuery(".egwGridView_empty", this._grid.innerTbody).remove();
|
|
if (typeof this._grid._rowProvider != "undefined" && this._grid._rowProvider.getPrototype("empty")) {
|
|
var placeholder = this._grid._rowProvider.getPrototype("empty");
|
|
if (jQuery("td", placeholder).length == 1) {
|
|
jQuery("td", placeholder).css("width", this._grid.outerCell.width() + "px");
|
|
}
|
|
placeholder.appendTo(this._grid.innerTbody);
|
|
// Register placeholder action only if no rows
|
|
if (noRows) {
|
|
// Get the action links if the links callback is set
|
|
var links = null;
|
|
if (this._linkCallback) {
|
|
links = this._linkCallback.call(this._context, {}, 0, "");
|
|
}
|
|
this._selectionMgr.registerRow("", 0, placeholder.get(0), links);
|
|
}
|
|
}
|
|
};
|
|
/**
|
|
* Callback function used by the selection manager to translate the selected
|
|
* range to uids.
|
|
*/
|
|
et2_dataview_controller.prototype._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);
|
|
}, _context);
|
|
};
|
|
/**
|
|
* Tells the grid to make the given index visible.
|
|
*/
|
|
et2_dataview_controller.prototype._makeIndexVisible = function (_idx) {
|
|
this._grid.makeIndexVisible(_idx);
|
|
};
|
|
// Maximum concurrent data requests. Additional ones are held in the queue.
|
|
et2_dataview_controller.CONCURRENT_REQUESTS = 5;
|
|
return et2_dataview_controller;
|
|
}());
|
|
exports.et2_dataview_controller = et2_dataview_controller;
|
|
//# sourceMappingURL=et2_dataview_controller.js.map
|