* gridOptions = {
* gridMenuTitleFilter: $translate
* }
*
*/
/**
* @ngdoc method
* @methodOf ui.grid.gridMenuService
* @name showHideColumns
* @description Adds two menu items for each of the columns in columnDefs. One
* menu item for hide, one menu item for show. Each is visible when appropriate
* (show when column is not visible, hide when column is visible). Each toggles
* the visible property on the columnDef using toggleColumnVisibility
* @param {$scope} $scope of a gridMenu, which contains a reference to the grid
*/
showHideColumns: function( $scope ){
var showHideColumns = [];
if ( !$scope.grid.options.columnDefs || $scope.grid.options.columnDefs.length === 0 || $scope.grid.columns.length === 0 ) {
return showHideColumns;
}
// add header for columns
showHideColumns.push({
title: i18nService.getSafeText('gridMenu.columns')
});
$scope.grid.options.gridMenuTitleFilter = $scope.grid.options.gridMenuTitleFilter ? $scope.grid.options.gridMenuTitleFilter : function( title ) { return title; };
$scope.grid.options.columnDefs.forEach( function( colDef, index ){
if ( colDef.enableHiding !== false ){
// add hide menu item - shows an OK icon as we only show when column is already visible
var menuItem = {
icon: 'ui-grid-icon-ok',
action: function($event) {
$event.stopPropagation();
service.toggleColumnVisibility( this.context.gridCol );
},
shown: function() {
return this.context.gridCol.colDef.visible === true || this.context.gridCol.colDef.visible === undefined;
},
context: { gridCol: $scope.grid.getColumn(colDef.name || colDef.field) }
};
service.setMenuItemTitle( menuItem, colDef, $scope.grid );
showHideColumns.push( menuItem );
// add show menu item - shows no icon as we only show when column is invisible
menuItem = {
icon: 'ui-grid-icon-cancel',
action: function($event) {
$event.stopPropagation();
service.toggleColumnVisibility( this.context.gridCol );
},
shown: function() {
return !(this.context.gridCol.colDef.visible === true || this.context.gridCol.colDef.visible === undefined);
},
context: { gridCol: $scope.grid.getColumn(colDef.name || colDef.field) }
};
service.setMenuItemTitle( menuItem, colDef, $scope.grid );
showHideColumns.push( menuItem );
}
});
return showHideColumns;
},
/**
* @ngdoc method
* @methodOf ui.grid.gridMenuService
* @name setMenuItemTitle
* @description Handles the response from gridMenuTitleFilter, adding it directly to the menu
* item if it returns a string, otherwise waiting for the promise to resolve or reject then
* putting the result into the title
* @param {object} menuItem the menuItem we want to put the title on
* @param {object} colDef the colDef from which we can get displayName, name or field
* @param {Grid} grid the grid, from which we can get the options.gridMenuTitleFilter
*
*/
setMenuItemTitle: function( menuItem, colDef, grid ){
var title = grid.options.gridMenuTitleFilter( colDef.displayName || colDef.name || colDef.field );
if ( typeof(title) === 'string' ){
menuItem.title = title;
} else if ( title.then ){
// must be a promise
menuItem.title = "";
title.then( function( successValue ) {
menuItem.title = successValue;
}, function( errorValue ) {
menuItem.title = errorValue;
});
} else {
gridUtil.logError('Expected gridMenuTitleFilter to return a string or a promise, it has returned neither, bad config');
menuItem.title = 'badconfig';
}
},
/**
* @ngdoc method
* @methodOf ui.grid.gridMenuService
* @name toggleColumnVisibility
* @description Toggles the visibility of an individual column. Expects to be
* provided a context that has on it a gridColumn, which is the column that
* we'll operate upon. We change the visibility, and refresh the grid as appropriate
* @param {GridCol} gridCol the column that we want to toggle
*
*/
toggleColumnVisibility: function( gridCol ) {
gridCol.colDef.visible = !( gridCol.colDef.visible === true || gridCol.colDef.visible === undefined );
gridCol.grid.refresh();
}
};
return service;
}])
.directive('uiGridMenuButton', ['gridUtil', 'uiGridConstants', 'uiGridGridMenuService',
function (gridUtil, uiGridConstants, uiGridGridMenuService) {
return {
priority: 0,
scope: true,
require: ['?^uiGrid'],
templateUrl: 'ui-grid/ui-grid-menu-button',
replace: true,
link: function ($scope, $elm, $attrs, controllers) {
var uiGridCtrl = controllers[0];
uiGridGridMenuService.initialize($scope, uiGridCtrl.grid);
$scope.shown = false;
$scope.toggleMenu = function () {
if ( $scope.shown ){
$scope.$broadcast('hide-menu');
$scope.shown = false;
} else {
$scope.menuItems = uiGridGridMenuService.getMenuItems( $scope );
$scope.$broadcast('show-menu');
$scope.shown = true;
}
};
$scope.$on('menu-hidden', function() {
$scope.shown = false;
});
}
};
}]);
})();
(function(){
/**
* @ngdoc directive
* @name ui.grid.directive:uiGridColumnMenu
* @element style
* @restrict A
*
* @description
* Allows us to interpolate expressions in `
I am in a box.
* mySortFn = function(a, b) {
* var nulls = $scope.gridApi.core.sortHandleNulls(a, b);
* if ( nulls !== null ){
* return nulls;
* } else {
* // your code for sorting here
* };
*
* @param {object} a sort value a
* @param {object} b sort value b
* @returns {number} null if there were no nulls/undefineds, otherwise returns
* a sort value that should be passed back from the sort function
*
*/
self.api.registerMethod( 'core', 'sortHandleNulls', rowSorter.handleNulls );
/**
* @ngdoc function
* @name sortChanged
* @methodOf ui.grid.core.api:PublicApi
* @description The sort criteria on one or more columns has
* changed. Provides as parameters the grid and the output of
* getColumnSorting, which is an array of gridColumns
* that have sorting on them, sorted in priority order.
*
* @param {Grid} grid the grid
* @param {array} sortColumns an array of columns with
* sorts on them, in priority order
*
* @example
*
* gridApi.core.on.sortChanged( grid, sortColumns );
*
*/
self.api.registerEvent( 'core', 'sortChanged' );
/**
* @ngdoc method
* @name notifyDataChange
* @methodOf ui.grid.core.api:PublicApi
* @description Notify the grid that a data or config change has occurred,
* where that change isn't something the grid was otherwise noticing. This
* might be particularly relevant where you've changed values within the data
* and you'd like cell classes to be re-evaluated, or changed config within
* the columnDef and you'd like headerCellClasses to be re-evaluated.
* @param {Grid} grid the grid
* @param {string} type one of the
* uiGridConstants.dataChange values (ALL, ROW, EDIT, COLUMN), which tells
* us which refreshes to fire.
*
*/
self.api.registerMethod( 'core', 'notifyDataChange', this.notifyDataChange );
self.registerDataChangeCallback( self.columnRefreshCallback, [uiGridConstants.dataChange.COLUMN]);
self.registerDataChangeCallback( self.processRowsCallback, [uiGridConstants.dataChange.EDIT]);
};
/**
* @ngdoc function
* @name isRTL
* @methodOf ui.grid.class:Grid
* @description Returns true if grid is RightToLeft
*/
Grid.prototype.isRTL = function () {
return this.rtl;
};
/**
* @ngdoc function
* @name registerColumnBuilder
* @methodOf ui.grid.class:Grid
* @description When the build creates columns from column definitions, the columnbuilders will be called to add
* additional properties to the column.
* @param {function(colDef, col, gridOptions)} columnsProcessor function to be called
*/
Grid.prototype.registerColumnBuilder = function registerColumnBuilder(columnBuilder) {
this.columnBuilders.push(columnBuilder);
};
/**
* @ngdoc function
* @name buildColumnDefsFromData
* @methodOf ui.grid.class:Grid
* @description Populates columnDefs from the provided data
* @param {function(colDef, col, gridOptions)} rowBuilder function to be called
*/
Grid.prototype.buildColumnDefsFromData = function (dataRows){
this.options.columnDefs = gridUtil.getColumnsFromData(dataRows, this.options.excludeProperties);
};
/**
* @ngdoc function
* @name registerRowBuilder
* @methodOf ui.grid.class:Grid
* @description When the build creates rows from gridOptions.data, the rowBuilders will be called to add
* additional properties to the row.
* @param {function(row, gridOptions)} rowBuilder function to be called
*/
Grid.prototype.registerRowBuilder = function registerRowBuilder(rowBuilder) {
this.rowBuilders.push(rowBuilder);
};
/**
* @ngdoc function
* @name registerDataChangeCallback
* @methodOf ui.grid.class:Grid
* @description When a data change occurs, the data change callbacks of the specified type
* will be called. The rules are:
*
* - when the data watch fires, that is considered a ROW change (the data watch only notices
* added or removed rows)
* - when the api is called to inform us of a change, the declared type of that change is used
* - when a cell edit completes, the EDIT callbacks are triggered
* - when the columnDef watch fires, the COLUMN callbacks are triggered
*
* For a given event:
* - ALL calls ROW, EDIT, COLUMN and ALL callbacks
* - ROW calls ROW and ALL callbacks
* - EDIT calls EDIT and ALL callbacks
* - COLUMN calls COLUMN and ALL callbacks
*
* @param {function(grid)} callback function to be called
* @param {array} types the types of data change you want to be informed of. Values from
* the uiGridConstants.dataChange values ( ALL, EDIT, ROW, COLUMN ). Optional and defaults to
* ALL
* @returns {string} uid of the callback, can be used to deregister it again
*/
Grid.prototype.registerDataChangeCallback = function registerDataChangeCallback(callback, types) {
var uid = gridUtil.nextUid();
if ( !types ){
types = [uiGridConstants.dataChange.ALL];
}
if ( !Array.isArray(types)){
gridUtil.logError("Expected types to be an array or null in registerDataChangeCallback, value passed was: " + types );
}
this.dataChangeCallbacks[uid] = { callback: callback, types: types };
return uid;
};
/**
* @ngdoc function
* @name deregisterDataChangeCallback
* @methodOf ui.grid.class:Grid
* @description Delete the callback identified by the id.
* @param {string} uid the uid of the function that is to be deregistered
*/
Grid.prototype.deregisterDataChangeCallback = function deregisterDataChangeCallback(uid) {
delete this.dataChangeCallbacks[uid];
};
/**
* @ngdoc function
* @name callDataChangeCallbacks
* @methodOf ui.grid.class:Grid
* @description Calls the callbacks based on the type of data change that
* has occurred. Always calls the ALL callbacks, calls the ROW, EDIT, and COLUMN callbacks if the
* event type is matching, or if the type is ALL.
* @param {number} type the type of event that occurred - one of the
* uiGridConstants.dataChange values (ALL, ROW, EDIT, COLUMN)
*/
Grid.prototype.callDataChangeCallbacks = function callDataChangeCallbacks(type, options) {
angular.forEach( this.dataChangeCallbacks, function( callback, uid ){
if ( callback.types.indexOf( uiGridConstants.dataChange.ALL ) !== -1 ||
callback.types.indexOf( type ) !== -1 ||
type === uiGridConstants.dataChange.ALL ) {
callback.callback( this );
}
}, this);
};
/**
* @ngdoc function
* @name notifyDataChange
* @methodOf ui.grid.class:Grid
* @description Notifies us that a data change has occurred, used in the public
* api for users to tell us when they've changed data or some other event that
* our watches cannot pick up
* @param {Grid} grid the grid
* @param {string} type the type of event that occurred - one of the
* uiGridConstants.dataChange values (ALL, ROW, EDIT, COLUMN)
*/
Grid.prototype.notifyDataChange = function notifyDataChange(grid, type) {
var constants = uiGridConstants.dataChange;
if ( type === constants.ALL ||
type === constants.COLUMN ||
type === constants.EDIT ||
type === constants.ROW ){
grid.callDataChangeCallbacks( type );
} else {
gridUtil.logError("Notified of a data change, but the type was not recognised, so no action taken, type was: " + type);
}
};
/**
* @ngdoc function
* @name columnRefreshCallback
* @methodOf ui.grid.class:Grid
* @description refreshes the grid when a column refresh
* is notified, which triggers handling of the visible flag.
* This is called on uiGridConstants.dataChange.COLUMN, and is
* registered as a dataChangeCallback in grid.js
* @param {string} name column name
*/
Grid.prototype.columnRefreshCallback = function columnRefreshCallback( grid ){
grid.buildColumns();
grid.refresh();
};
/**
* @ngdoc function
* @name processRowsCallback
* @methodOf ui.grid.class:Grid
* @description calls the row processors, specifically
* intended to reset the sorting when an edit is called,
* registered as a dataChangeCallback on uiGridConstants.dataChange.EDIT
* @param {string} name column name
*/
Grid.prototype.processRowsCallback = function processRowsCallback( grid ){
grid.refreshRows();
};
/**
* @ngdoc function
* @name getColumn
* @methodOf ui.grid.class:Grid
* @description returns a grid column for the column name
* @param {string} name column name
*/
Grid.prototype.getColumn = function getColumn(name) {
var columns = this.columns.filter(function (column) {
return column.colDef.name === name;
});
return columns.length > 0 ? columns[0] : null;
};
/**
* @ngdoc function
* @name getColDef
* @methodOf ui.grid.class:Grid
* @description returns a grid colDef for the column name
* @param {string} name column.field
*/
Grid.prototype.getColDef = function getColDef(name) {
var colDefs = this.options.columnDefs.filter(function (colDef) {
return colDef.name === name;
});
return colDefs.length > 0 ? colDefs[0] : null;
};
/**
* @ngdoc function
* @name assignTypes
* @methodOf ui.grid.class:Grid
* @description uses the first row of data to assign colDef.type for any types not defined.
*/
/**
* @ngdoc property
* @name type
* @propertyOf ui.grid.class:GridOptions.columnDef
* @description the type of the column, used in sorting. If not provided then the
* grid will guess the type. Add this only if the grid guessing is not to your
* satisfaction. Refer to {@link ui.grid.service:GridUtil.guessType gridUtil.guessType} for
* a list of values the grid knows about.
*
*/
Grid.prototype.assignTypes = function(){
var self = this;
self.options.columnDefs.forEach(function (colDef, index) {
//Assign colDef type if not specified
if (!colDef.type) {
var col = new GridColumn(colDef, index, self);
var firstRow = self.rows.length > 0 ? self.rows[0] : null;
if (firstRow) {
colDef.type = gridUtil.guessType(self.getCellValue(firstRow, col));
}
else {
gridUtil.logWarn('Unable to assign type from data, so defaulting to string');
colDef.type = 'string';
}
}
});
};
/**
* @ngdoc function
* @name addRowHeaderColumn
* @methodOf ui.grid.class:Grid
* @description adds a row header column to the grid
* @param {object} column def
*/
Grid.prototype.addRowHeaderColumn = function addRowHeaderColumn(colDef) {
var self = this;
//self.createLeftContainer();
var rowHeaderCol = new GridColumn(colDef, self.rowHeaderColumns.length, self);
rowHeaderCol.isRowHeader = true;
if (self.isRTL()) {
self.createRightContainer();
rowHeaderCol.renderContainer = 'right';
}
else {
self.createLeftContainer();
rowHeaderCol.renderContainer = 'left';
}
// relies on the default column builder being first in array, as it is instantiated
// as part of grid creation
self.columnBuilders[0](colDef,rowHeaderCol,self.options)
.then(function(){
rowHeaderCol.enableFiltering = false;
rowHeaderCol.enableSorting = false;
rowHeaderCol.enableHiding = false;
self.rowHeaderColumns.push(rowHeaderCol);
self.buildColumns()
.then( function() {
self.preCompileCellTemplates();
self.handleWindowResize();
});
});
};
/**
* @ngdoc function
* @name buildColumns
* @methodOf ui.grid.class:Grid
* @description creates GridColumn objects from the columnDefinition. Calls each registered
* columnBuilder to further process the column
* @returns {Promise} a promise to load any needed column resources
*/
Grid.prototype.buildColumns = function buildColumns() {
// gridUtil.logDebug('buildColumns');
var self = this;
var builderPromises = [];
var headerOffset = self.rowHeaderColumns.length;
var i;
// Remove any columns for which a columnDef cannot be found
// Deliberately don't use forEach, as it doesn't like splice being called in the middle
// Also don't cache columns.length, as it will change during this operation
for (i = 0; i < self.columns.length; i++){
if (!self.getColDef(self.columns[i].name)) {
self.columns.splice(i, 1);
i--;
}
}
//add row header columns to the grid columns array _after_ columns without columnDefs have been removed
self.rowHeaderColumns.forEach(function (rowHeaderColumn) {
self.columns.unshift(rowHeaderColumn);
});
// look at each column def, and update column properties to match. If the column def
// doesn't have a column, then splice in a new gridCol
self.options.columnDefs.forEach(function (colDef, index) {
self.preprocessColDef(colDef);
var col = self.getColumn(colDef.name);
if (!col) {
col = new GridColumn(colDef, gridUtil.nextUid(), self);
self.columns.splice(index + headerOffset, 0, col);
}
else {
col.updateColumnDef(colDef);
}
self.columnBuilders.forEach(function (builder) {
builderPromises.push(builder.call(self, colDef, col, self.options));
});
});
return $q.all(builderPromises);
};
/**
* @ngdoc function
* @name preCompileCellTemplates
* @methodOf ui.grid.class:Grid
* @description precompiles all cell templates
*/
Grid.prototype.preCompileCellTemplates = function() {
var self = this;
this.columns.forEach(function (col) {
var html = col.cellTemplate.replace(uiGridConstants.MODEL_COL_FIELD, self.getQualifiedColField(col));
html = html.replace(uiGridConstants.COL_FIELD, 'grid.getCellValue(row, col)');
var compiledElementFn = $compile(html);
col.compiledElementFn = compiledElementFn;
if (col.compiledElementFnDefer) {
col.compiledElementFnDefer.resolve(col.compiledElementFn);
}
});
};
/**
* @ngdoc function
* @name getGridQualifiedColField
* @methodOf ui.grid.class:Grid
* @description Returns the $parse-able accessor for a column within its $scope
* @param {GridColumn} col col object
*/
Grid.prototype.getQualifiedColField = function (col) {
return 'row.entity.' + gridUtil.preEval(col.field);
};
/**
* @ngdoc function
* @name createLeftContainer
* @methodOf ui.grid.class:Grid
* @description creates the left render container if it doesn't already exist
*/
Grid.prototype.createLeftContainer = function() {
if (!this.hasLeftContainer()) {
this.renderContainers.left = new GridRenderContainer('left', this, { disableColumnOffset: true });
}
};
/**
* @ngdoc function
* @name createRightContainer
* @methodOf ui.grid.class:Grid
* @description creates the right render container if it doesn't already exist
*/
Grid.prototype.createRightContainer = function() {
if (!this.hasRightContainer()) {
this.renderContainers.right = new GridRenderContainer('right', this, { disableColumnOffset: true });
}
};
/**
* @ngdoc function
* @name hasLeftContainer
* @methodOf ui.grid.class:Grid
* @description returns true if leftContainer exists
*/
Grid.prototype.hasLeftContainer = function() {
return this.renderContainers.left !== undefined;
};
/**
* @ngdoc function
* @name hasLeftContainer
* @methodOf ui.grid.class:Grid
* @description returns true if rightContainer exists
*/
Grid.prototype.hasRightContainer = function() {
return this.renderContainers.right !== undefined;
};
/**
* undocumented function
* @name preprocessColDef
* @methodOf ui.grid.class:Grid
* @description defaults the name property from field to maintain backwards compatibility with 2.x
* validates that name or field is present
*/
Grid.prototype.preprocessColDef = function preprocessColDef(colDef) {
if (!colDef.field && !colDef.name) {
throw new Error('colDef.name or colDef.field property is required');
}
//maintain backwards compatibility with 2.x
//field was required in 2.x. now name is required
if (colDef.name === undefined && colDef.field !== undefined) {
colDef.name = colDef.field;
}
};
// Return a list of items that exist in the `n` array but not the `o` array. Uses optional property accessors passed as third & fourth parameters
Grid.prototype.newInN = function newInN(o, n, oAccessor, nAccessor) {
var self = this;
var t = [];
for (var i = 0; i < n.length; i++) {
var nV = nAccessor ? n[i][nAccessor] : n[i];
var found = false;
for (var j = 0; j < o.length; j++) {
var oV = oAccessor ? o[j][oAccessor] : o[j];
if (self.options.rowEquality(nV, oV)) {
found = true;
break;
}
}
if (!found) {
t.push(nV);
}
}
return t;
};
/**
* @ngdoc function
* @name getRow
* @methodOf ui.grid.class:Grid
* @description returns the GridRow that contains the rowEntity
* @param {object} rowEntity the gridOptions.data array element instance
*/
Grid.prototype.getRow = function getRow(rowEntity) {
var self = this;
var rows = this.rows.filter(function (row) {
return self.options.rowEquality(row.entity, rowEntity);
});
return rows.length > 0 ? rows[0] : null;
};
/**
* @ngdoc function
* @name modifyRows
* @methodOf ui.grid.class:Grid
* @description creates or removes GridRow objects from the newRawData array. Calls each registered
* rowBuilder to further process the row
*
* Rows are identified using the gridOptions.rowEquality function
*/
Grid.prototype.modifyRows = function modifyRows(newRawData) {
var self = this,
i,
rowhash,
found,
newRow;
if ((self.options.useExternalSorting || self.getColumnSorting().length === 0) && newRawData.length > 0) {
var oldRowHash = self.rowHashMap;
if (!oldRowHash) {
oldRowHash = {get: function(){return null;}};
}
self.createRowHashMap();
rowhash = self.rowHashMap;
var wasEmpty = self.rows.length === 0;
self.rows.length = 0;
for (i = 0; i < newRawData.length; i++) {
var newRawRow = newRawData[i];
found = oldRowHash.get(newRawRow);
if (found) {
newRow = found.row;
}
else {
newRow = self.processRowBuilders(new GridRow(newRawRow, i, self));
}
self.rows.push(newRow);
rowhash.put(newRawRow, {
i: i,
entity: newRawRow,
row:newRow
});
}
//now that we have data, it is save to assign types to colDefs
if (wasEmpty) {
self.assignTypes();
}
} else {
if (self.rows.length === 0 && newRawData.length > 0) {
if (self.options.enableRowHashing) {
if (!self.rowHashMap) {
self.createRowHashMap();
}
for (i = 0; i < newRawData.length; i++) {
newRow = newRawData[i];
self.rowHashMap.put(newRow, {
i: i,
entity: newRow
});
}
}
self.addRows(newRawData);
//now that we have data, it is save to assign types to colDefs
self.assignTypes();
}
else if (newRawData.length > 0) {
var unfoundNewRows, unfoundOldRows, unfoundNewRowsToFind;
// If row hashing is turned on
if (self.options.enableRowHashing) {
// Array of new rows that haven't been found in the old rowset
unfoundNewRows = [];
// Array of new rows that we explicitly HAVE to search for manually in the old row set. They cannot be looked up by their identity (because it doesn't exist).
unfoundNewRowsToFind = [];
// Map of rows that have been found in the new rowset
var foundOldRows = {};
// Array of old rows that have NOT been found in the new rowset
unfoundOldRows = [];
// Create the row HashMap if it doesn't exist already
if (!self.rowHashMap) {
self.createRowHashMap();
}
rowhash = self.rowHashMap;
// Make sure every new row has a hash
for (i = 0; i < newRawData.length; i++) {
newRow = newRawData[i];
// Flag this row as needing to be manually found if it didn't come in with a $$hashKey
var mustFind = false;
if (!self.options.getRowIdentity(newRow)) {
mustFind = true;
}
// See if the new row is already in the rowhash
found = rowhash.get(newRow);
// If so...
if (found) {
// See if it's already being used by as GridRow
if (found.row) {
// If so, mark this new row as being found
foundOldRows[self.options.rowIdentity(newRow)] = true;
}
}
else {
// Put the row in the hashmap with the index it corresponds to
rowhash.put(newRow, {
i: i,
entity: newRow
});
// This row has to be searched for manually in the old row set
if (mustFind) {
unfoundNewRowsToFind.push(newRow);
}
else {
unfoundNewRows.push(newRow);
}
}
}
// Build the list of unfound old rows
for (i = 0; i < self.rows.length; i++) {
var row = self.rows[i];
var hash = self.options.rowIdentity(row.entity);
if (!foundOldRows[hash]) {
unfoundOldRows.push(row);
}
}
}
// Look for new rows
var newRows = unfoundNewRows || [];
// The unfound new rows is either `unfoundNewRowsToFind`, if row hashing is turned on, or straight `newRawData` if it isn't
var unfoundNew = (unfoundNewRowsToFind || newRawData);
// Search for real new rows in `unfoundNew` and concat them onto `newRows`
newRows = newRows.concat(self.newInN(self.rows, unfoundNew, 'entity'));
self.addRows(newRows);
var deletedRows = self.getDeletedRows((unfoundOldRows || self.rows), newRawData);
for (i = 0; i < deletedRows.length; i++) {
if (self.options.enableRowHashing) {
self.rowHashMap.remove(deletedRows[i].entity);
}
self.rows.splice( self.rows.indexOf(deletedRows[i]), 1 );
}
}
// Empty data set
else {
// Reset the row HashMap
self.createRowHashMap();
// Reset the rows length!
self.rows.length = 0;
}
}
var p1 = $q.when(self.processRowsProcessors(self.rows))
.then(function (renderableRows) {
return self.setVisibleRows(renderableRows);
});
var p2 = $q.when(self.processColumnsProcessors(self.columns))
.then(function (renderableColumns) {
return self.setVisibleColumns(renderableColumns);
});
return $q.all([p1, p2]);
};
Grid.prototype.getDeletedRows = function(oldRows, newRows) {
var self = this;
var olds = oldRows.filter(function (oldRow) {
return !newRows.some(function (newItem) {
return self.options.rowEquality(newItem, oldRow.entity);
});
});
// var olds = self.newInN(newRows, oldRows, null, 'entity');
// dump('olds', olds);
return olds;
};
/**
* Private Undocumented Method
* @name addRows
* @methodOf ui.grid.class:Grid
* @description adds the newRawData array of rows to the grid and calls all registered
* rowBuilders. this keyword will reference the grid
*/
Grid.prototype.addRows = function addRows(newRawData) {
var self = this;
var existingRowCount = self.rows.length;
for (var i = 0; i < newRawData.length; i++) {
var newRow = self.processRowBuilders(new GridRow(newRawData[i], i + existingRowCount, self));
if (self.options.enableRowHashing) {
var found = self.rowHashMap.get(newRow.entity);
if (found) {
found.row = newRow;
}
}
self.rows.push(newRow);
}
};
/**
* @ngdoc function
* @name processRowBuilders
* @methodOf ui.grid.class:Grid
* @description processes all RowBuilders for the gridRow
* @param {GridRow} gridRow reference to gridRow
* @returns {GridRow} the gridRow with all additional behavior added
*/
Grid.prototype.processRowBuilders = function processRowBuilders(gridRow) {
var self = this;
self.rowBuilders.forEach(function (builder) {
builder.call(self, gridRow, self.options);
});
return gridRow;
};
/**
* @ngdoc function
* @name registerStyleComputation
* @methodOf ui.grid.class:Grid
* @description registered a styleComputation function
*
* If the function returns a value it will be appended into the grid's `"
);
$templateCache.put('ui-grid/uiGridCell',
"