* 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'),
order: 300
});
$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) },
leaveOpen: true,
order: 301 + index * 2
};
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) },
leaveOpen: true,
order: 301 + index * 2 + 1
};
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 || gridUtil.readableColumnName(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();
gridCol.grid.api.core.notifyDataChange( uiGridConstants.dataChange.COLUMN );
gridCol.grid.api.core.raise.columnVisibilityChanged( gridCol );
}
};
return service;
}])
.directive('uiGridMenuButton', ['gridUtil', 'uiGridConstants', 'uiGridGridMenuService', 'i18nService',
function (gridUtil, uiGridConstants, uiGridGridMenuService, i18nService) {
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];
// For the aria label
$scope.i18n = {
aria: i18nService.getSafeText('gridMenu.aria')
};
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;
gridUtil.focus.bySelector($elm, '.ui-grid-icon-container');
});
}
};
}]);
})();
(function(){
/**
* @ngdoc directive
* @name ui.grid.directive:uiGridMenu
* @element style
* @restrict A
*
* @description
* Allows us to interpolate expressions in `
I am in a box.
* $scope.gridOptions = {
* customScroller: function myScrolling(uiGridViewport, scrollHandler) {
* uiGridViewport.on('scroll', function myScrollingOverride(event) {
* // Do something here
*
* scrollHandler(event);
* });
* }
* };
*
* @param {object} uiGridViewport Element being scrolled. (this gets passed in by the grid).
* @param {function} scrollHandler Function that needs to be called when scrolling happens. (this gets passed in by the grid).
*/
if (grid && grid.options && grid.options.customScroller) {
grid.options.customScroller($elm, scrollHandler);
} else {
$elm.on('scroll', scrollHandler);
}
var ignoreScroll = false;
function scrollHandler(evt) {
//Leaving in this commented code in case it can someday be used
//It does improve performance, but because the horizontal scroll is normalized,
// using this code will lead to the column header getting slightly out of line with columns
//
//if (ignoreScroll && (grid.isScrollingHorizontally || grid.isScrollingHorizontally)) {
// //don't ask for scrollTop if we just set it
// ignoreScroll = false;
// return;
//}
//ignoreScroll = true;
var newScrollTop = $elm[0].scrollTop;
var newScrollLeft = gridUtil.normalizeScrollLeft($elm, grid);
var vertScrollPercentage = rowContainer.scrollVertical(newScrollTop);
var horizScrollPercentage = colContainer.scrollHorizontal(newScrollLeft);
var scrollEvent = new ScrollEvent(grid, rowContainer, colContainer, ScrollEvent.Sources.ViewPortScroll);
scrollEvent.newScrollLeft = newScrollLeft;
scrollEvent.newScrollTop = newScrollTop;
if ( horizScrollPercentage > -1 ){
scrollEvent.x = { percentage: horizScrollPercentage };
}
if ( vertScrollPercentage > -1 ){
scrollEvent.y = { percentage: vertScrollPercentage };
}
grid.scrollContainers($scope.$parent.containerId, scrollEvent);
}
if ($scope.$parent.bindScrollVertical) {
grid.addVerticalScrollSync($scope.$parent.containerId, syncVerticalScroll);
}
if ($scope.$parent.bindScrollHorizontal) {
grid.addHorizontalScrollSync($scope.$parent.containerId, syncHorizontalScroll);
grid.addHorizontalScrollSync($scope.$parent.containerId + 'header', syncHorizontalHeader);
grid.addHorizontalScrollSync($scope.$parent.containerId + 'footer', syncHorizontalFooter);
}
function syncVerticalScroll(scrollEvent){
containerCtrl.prevScrollArgs = scrollEvent;
var newScrollTop = scrollEvent.getNewScrollTop(rowContainer,containerCtrl.viewport);
$elm[0].scrollTop = newScrollTop;
}
function syncHorizontalScroll(scrollEvent){
containerCtrl.prevScrollArgs = scrollEvent;
var newScrollLeft = scrollEvent.getNewScrollLeft(colContainer, containerCtrl.viewport);
$elm[0].scrollLeft = gridUtil.denormalizeScrollLeft(containerCtrl.viewport,newScrollLeft, grid);
}
function syncHorizontalHeader(scrollEvent){
var newScrollLeft = scrollEvent.getNewScrollLeft(colContainer, containerCtrl.viewport);
if (containerCtrl.headerViewport) {
containerCtrl.headerViewport.scrollLeft = gridUtil.denormalizeScrollLeft(containerCtrl.viewport,newScrollLeft, grid);
}
}
function syncHorizontalFooter(scrollEvent){
var newScrollLeft = scrollEvent.getNewScrollLeft(colContainer, containerCtrl.viewport);
if (containerCtrl.footerViewport) {
containerCtrl.footerViewport.scrollLeft = gridUtil.denormalizeScrollLeft(containerCtrl.viewport,newScrollLeft, grid);
}
}
$scope.$on('$destroy', function unbindEvents() {
$elm.off();
});
},
controller: ['$scope', function ($scope) {
this.rowStyle = function (index) {
var rowContainer = $scope.rowContainer;
var colContainer = $scope.colContainer;
var styles = {};
if (rowContainer.currentTopRow !== 0){
//top offset based on hidden rows count
var translateY = "translateY("+ (rowContainer.currentTopRow * rowContainer.grid.options.rowHeight) +"px)";
styles['transform'] = translateY;
styles['-webkit-transform'] = translateY;
styles['-ms-transform'] = translateY;
}
if (colContainer.currentFirstColumn !== 0) {
if (colContainer.grid.isRTL()) {
styles['margin-right'] = colContainer.columnOffset + 'px';
}
else {
styles['margin-left'] = colContainer.columnOffset + 'px';
}
}
return styles;
};
}]
};
}
]);
})();
(function() {
angular.module('ui.grid')
.directive('uiGridVisible', function uiGridVisibleAction() {
return function ($scope, $elm, $attr) {
$scope.$watch($attr.uiGridVisible, function (visible) {
// $elm.css('visibility', visible ? 'visible' : 'hidden');
$elm[visible ? 'removeClass' : 'addClass']('ui-grid-invisible');
});
};
});
})();
(function () {
'use strict';
angular.module('ui.grid').controller('uiGridController', ['$scope', '$element', '$attrs', 'gridUtil', '$q', 'uiGridConstants',
'$templateCache', 'gridClassFactory', '$timeout', '$parse', '$compile',
function ($scope, $elm, $attrs, gridUtil, $q, uiGridConstants,
$templateCache, gridClassFactory, $timeout, $parse, $compile) {
// gridUtil.logDebug('ui-grid controller');
var self = this;
self.grid = gridClassFactory.createGrid($scope.uiGrid);
//assign $scope.$parent if appScope not already assigned
self.grid.appScope = self.grid.appScope || $scope.$parent;
$elm.addClass('grid' + self.grid.id);
self.grid.rtl = gridUtil.getStyles($elm[0])['direction'] === 'rtl';
// angular.extend(self.grid.options, );
//all properties of grid are available on scope
$scope.grid = self.grid;
if ($attrs.uiGridColumns) {
$attrs.$observe('uiGridColumns', function(value) {
self.grid.options.columnDefs = value;
self.grid.buildColumns()
.then(function(){
self.grid.preCompileCellTemplates();
self.grid.refreshCanvas(true);
});
});
}
// if fastWatch is set we watch only the length and the reference, not every individual object
var deregFunctions = [];
if (self.grid.options.fastWatch) {
self.uiGrid = $scope.uiGrid;
if (angular.isString($scope.uiGrid.data)) {
deregFunctions.push( $scope.$parent.$watch($scope.uiGrid.data, dataWatchFunction) );
deregFunctions.push( $scope.$parent.$watch(function() {
if ( self.grid.appScope[$scope.uiGrid.data] ){
return self.grid.appScope[$scope.uiGrid.data].length;
} else {
return undefined;
}
}, dataWatchFunction) );
} else {
deregFunctions.push( $scope.$parent.$watch(function() { return $scope.uiGrid.data; }, dataWatchFunction) );
deregFunctions.push( $scope.$parent.$watch(function() { return $scope.uiGrid.data.length; }, function(){ dataWatchFunction($scope.uiGrid.data); }) );
}
deregFunctions.push( $scope.$parent.$watch(function() { return $scope.uiGrid.columnDefs; }, columnDefsWatchFunction) );
deregFunctions.push( $scope.$parent.$watch(function() { return $scope.uiGrid.columnDefs.length; }, function(){ columnDefsWatchFunction($scope.uiGrid.columnDefs); }) );
} else {
if (angular.isString($scope.uiGrid.data)) {
deregFunctions.push( $scope.$parent.$watchCollection($scope.uiGrid.data, dataWatchFunction) );
} else {
deregFunctions.push( $scope.$parent.$watchCollection(function() { return $scope.uiGrid.data; }, dataWatchFunction) );
}
deregFunctions.push( $scope.$parent.$watchCollection(function() { return $scope.uiGrid.columnDefs; }, columnDefsWatchFunction) );
}
function columnDefsWatchFunction(n, o) {
if (n && n !== o) {
self.grid.options.columnDefs = $scope.uiGrid.columnDefs;
self.grid.buildColumns({ orderByColumnDefs: true })
.then(function(){
self.grid.preCompileCellTemplates();
self.grid.callDataChangeCallbacks(uiGridConstants.dataChange.COLUMN);
});
}
}
var mostRecentData;
function dataWatchFunction(newData) {
// gridUtil.logDebug('dataWatch fired');
var promises = [];
if ( self.grid.options.fastWatch ){
if (angular.isString($scope.uiGrid.data)) {
newData = self.grid.appScope[$scope.uiGrid.data];
} else {
newData = $scope.uiGrid.data;
}
}
mostRecentData = newData;
if (newData) {
// columns length is greater than the number of row header columns, which don't count because they're created automatically
var hasColumns = self.grid.columns.length > (self.grid.rowHeaderColumns ? self.grid.rowHeaderColumns.length : 0);
if (
// If we have no columns
!hasColumns &&
// ... and we don't have a ui-grid-columns attribute, which would define columns for us
!$attrs.uiGridColumns &&
// ... and we have no pre-defined columns
self.grid.options.columnDefs.length === 0 &&
// ... but we DO have data
newData.length > 0
) {
// ... then build the column definitions from the data that we have
self.grid.buildColumnDefsFromData(newData);
}
// If we haven't built columns before and either have some columns defined or some data defined
if (!hasColumns && (self.grid.options.columnDefs.length > 0 || newData.length > 0)) {
// Build the column set, then pre-compile the column cell templates
promises.push(self.grid.buildColumns()
.then(function() {
self.grid.preCompileCellTemplates();
}));
}
$q.all(promises).then(function() {
// use most recent data, rather than the potentially outdated data passed into watcher handler
self.grid.modifyRows(mostRecentData)
.then(function () {
// if (self.viewport) {
self.grid.redrawInPlace(true);
// }
$scope.$evalAsync(function() {
self.grid.refreshCanvas(true);
self.grid.callDataChangeCallbacks(uiGridConstants.dataChange.ROW);
});
});
});
}
}
var styleWatchDereg = $scope.$watch(function () { return self.grid.styleComputations; }, function() {
self.grid.refreshCanvas(true);
});
$scope.$on('$destroy', function() {
deregFunctions.forEach( function( deregFn ){ deregFn(); });
styleWatchDereg();
});
self.fireEvent = function(eventName, args) {
// Add the grid to the event arguments if it's not there
if (typeof(args) === 'undefined' || args === undefined) {
args = {};
}
if (typeof(args.grid) === 'undefined' || args.grid === undefined) {
args.grid = self.grid;
}
$scope.$broadcast(eventName, args);
};
self.innerCompile = function innerCompile(elm) {
$compile(elm)($scope);
};
}]);
/**
* @ngdoc directive
* @name ui.grid.directive:uiGrid
* @element div
* @restrict EA
* @param {Object} uiGrid Options for the grid to use
*
* @description Create a very basic grid.
*
* @example
* 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 {$scope} scope The scope of the controller. This is used to deregister this event when the scope is destroyed.
* @param {Function} callBack Will be called when the event is emited. The function passes back the grid and an array of
* columns with sorts on them, in priority order.
*
* @example
*
* gridApi.core.on.sortChanged( $scope, function(grid, sortColumns){
* // do something
* });
*
*/
self.api.registerEvent( 'core', 'sortChanged' );
/**
* @ngdoc function
* @name columnVisibilityChanged
* @methodOf ui.grid.core.api:PublicApi
* @description The visibility of a column has changed,
* the column itself is passed out as a parameter of the event.
*
* @param {$scope} scope The scope of the controller. This is used to deregister this event when the scope is destroyed.
* @param {Function} callBack Will be called when the event is emited. The function passes back the GridCol that has changed.
*
* @example
*
* gridApi.core.on.columnVisibilityChanged( $scope, function (column) {
* // do something
* } );
*
*/
self.api.registerEvent( 'core', 'columnVisibilityChanged' );
/**
* @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 {string} type one of the
* {@link ui.grid.service:uiGridConstants#properties_dataChange uiGridConstants.dataChange}
* values (ALL, ROW, EDIT, COLUMN), which tells us which refreshes to fire.
*
*/
self.api.registerMethod( 'core', 'notifyDataChange', this.notifyDataChange );
/**
* @ngdoc method
* @name clearAllFilters
* @methodOf ui.grid.core.api:PublicApi
* @description Clears all filters and optionally refreshes the visible rows.
* @param {object} refreshRows Defaults to true.
* @param {object} clearConditions Defaults to false.
* @param {object} clearFlags Defaults to false.
* @returns {promise} If `refreshRows` is true, returns a promise of the rows refreshing.
*/
self.api.registerMethod('core', 'clearAllFilters', this.clearAllFilters);
self.registerDataChangeCallback( self.columnRefreshCallback, [uiGridConstants.dataChange.COLUMN]);
self.registerDataChangeCallback( self.processRowsCallback, [uiGridConstants.dataChange.EDIT]);
self.registerDataChangeCallback( self.updateFooterHeightCallback, [uiGridConstants.dataChange.OPTIONS]);
self.registerStyleComputation({
priority: 10,
func: self.getFooterStyles
});
};
Grid.prototype.calcFooterHeight = function () {
if (!this.hasFooter()) {
return 0;
}
var height = 0;
if (this.options.showGridFooter) {
height += this.options.gridFooterHeight;
}
height += this.calcColumnFooterHeight();
return height;
};
Grid.prototype.calcColumnFooterHeight = function () {
var height = 0;
if (this.options.showColumnFooter) {
height += this.options.columnFooterHeight;
}
return height;
};
Grid.prototype.getFooterStyles = function () {
var style = '.grid' + this.id + ' .ui-grid-footer-aggregates-row { height: ' + this.options.columnFooterHeight + 'px; }';
style += ' .grid' + this.id + ' .ui-grid-footer-info { height: ' + this.options.gridFooterHeight + 'px; }';
return style;
};
Grid.prototype.hasFooter = function () {
return this.options.showGridFooter || this.options.showColumnFooter;
};
/**
* @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)} columnBuilder 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
* - when the options watch fires, the OPTIONS callbacks are triggered
*
* For a given event:
* - ALL calls ROW, EDIT, COLUMN, OPTIONS and ALL callbacks
* - ROW calls ROW and ALL callbacks
* - EDIT calls EDIT and ALL callbacks
* - COLUMN calls COLUMN and ALL callbacks
* - OPTIONS calls OPTIONS 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 {@link ui.grid.service:uiGridConstants#properties_dataChange uiGridConstants.dataChange}
* values ( ALL, EDIT, ROW, COLUMN, OPTIONS ). Optional and defaults to ALL
* @returns {function} deregister function - a function that can be called to deregister this callback
*/
Grid.prototype.registerDataChangeCallback = function registerDataChangeCallback(callback, types, _this) {
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, _this:_this };
var self = this;
var deregisterFunction = function() {
delete self.dataChangeCallbacks[uid];
};
return deregisterFunction;
};
/**
* @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, COLUMN and OPTIONS callbacks if the
* event type is matching, or if the type is ALL.
* @param {string} type the type of event that occurred - one of the
* {@link ui.grid.service:uiGridConstants#properties_dataChange uiGridConstants.dataChange}
* values (ALL, ROW, EDIT, COLUMN, OPTIONS)
*/
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 ) {
if (callback._this) {
callback.callback.apply(callback._this,this);
}
else {
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 {string} type the type of event that occurred - one of the
* uiGridConstants.dataChange values (ALL, ROW, EDIT, COLUMN)
*/
Grid.prototype.notifyDataChange = function notifyDataChange(type) {
var constants = uiGridConstants.dataChange;
if ( type === constants.ALL ||
type === constants.COLUMN ||
type === constants.EDIT ||
type === constants.ROW ||
type === constants.OPTIONS ){
this.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.queueGridRefresh();
};
/**
* @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.queueGridRefresh();
};
/**
* @ngdoc function
* @name updateFooterHeightCallback
* @methodOf ui.grid.class:Grid
* @description recalculates the footer height,
* registered as a dataChangeCallback on uiGridConstants.dataChange.OPTIONS
* @param {string} name column name
*/
Grid.prototype.updateFooterHeightCallback = function updateFooterHeightCallback( grid ){
grid.footerHeight = grid.calcFooterHeight();
grid.columnFooterHeight = grid.calcColumnFooterHeight();
};
/**
* @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. One of:
* - 'string'
* - 'boolean'
* - 'number'
* - 'date'
* - 'object'
* - 'numberStr'
* Note that if you choose date, your dates should be in a javascript date type
*
*/
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 {
colDef.type = 'string';
}
}
});
};
/**
* @ngdoc function
* @name isRowHeaderColumn
* @methodOf ui.grid.class:Grid
* @description returns true if the column is a row Header
* @param {object} column column
*/
Grid.prototype.isRowHeaderColumn = function isRowHeaderColumn(column) {
return this.rowHeaderColumns.indexOf(column) !== -1;
};
/**
* @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, order) {
var self = this;
//default order
if (order === undefined) {
order = 0;
}
var rowHeaderCol = new GridColumn(colDef, gridUtil.nextUid(), 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;
rowHeaderCol.headerPriority = order;
self.rowHeaderColumns.push(rowHeaderCol);
self.rowHeaderColumns = self.rowHeaderColumns.sort(function (a, b) {
return a.headerPriority - b.headerPriority;
});
self.buildColumns()
.then( function() {
self.preCompileCellTemplates();
self.queueGridRefresh();
});
});
};
/**
* @ngdoc function
* @name getOnlyDataColumns
* @methodOf ui.grid.class:Grid
* @description returns all columns except for rowHeader columns
*/
Grid.prototype.getOnlyDataColumns = function getOnlyDataColumns() {
var self = this;
var cols = [];
self.columns.forEach(function (col) {
if (self.rowHeaderColumns.indexOf(col) === -1) {
cols.push(col);
}
});
return cols;
};
/**
* @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
* @param {object} options An object contains options to use when building columns
*
* * **orderByColumnDefs**: defaults to **false**. When true, `buildColumns` will reorder existing columns according to the order within the column definitions.
*
* @returns {Promise} a promise to load any needed column resources
*/
Grid.prototype.buildColumns = function buildColumns(opts) {
var options = {
orderByColumnDefs: false
};
angular.extend(options, opts);
// 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
//rowHeaderColumns is ordered by priority so insert in reverse
for (var j = self.rowHeaderColumns.length - 1; j >= 0; j--) {
self.columns.unshift(self.rowHeaderColumns[j]);
}
// 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 {
// tell updateColumnDef that the column was pre-existing
col.updateColumnDef(colDef, false);
}
self.columnBuilders.forEach(function (builder) {
builderPromises.push(builder.call(self, colDef, col, self.options));
});
});
/*** Reorder columns if necessary ***/
if (!!options.orderByColumnDefs) {
// Create a shallow copy of the columns as a cache
var columnCache = self.columns.slice(0);
// We need to allow for the "row headers" when mapping from the column defs array to the columns array
// If we have a row header in columns[0] and don't account for it we'll overwrite it with the column in columnDefs[0]
// Go through all the column defs, use the shorter of columns length and colDefs.length because if a user has given two columns the same name then
// columns will be shorter than columnDefs. In this situation we'll avoid an error, but the user will still get an unexpected result
var len = Math.min(self.options.columnDefs.length, self.columns.length);
for (i = 0; i < len; i++) {
// If the column at this index has a different name than the column at the same index in the column defs...
if (self.columns[i + headerOffset].name !== self.options.columnDefs[i].name) {
// Replace the one in the cache with the appropriate column
columnCache[i + headerOffset] = self.getColumn(self.options.columnDefs[i].name);
}
else {
// Otherwise just copy over the one from the initial columns
columnCache[i + headerOffset] = self.columns[i + headerOffset];
}
}
// Empty out the columns array, non-destructively
self.columns.length = 0;
// And splice in the updated, ordered columns from the cache
Array.prototype.splice.apply(self.columns, [0, 0].concat(columnCache));
}
return $q.all(builderPromises).then(function(){
if (self.rows.length > 0){
self.assignTypes();
}
});
};
Grid.prototype.preCompileCellTemplate = function(col) {
var self = this;
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 preCompileCellTemplates
* @methodOf ui.grid.class:Grid
* @description pronapiles all cell templates
*/
Grid.prototype.preCompileCellTemplates = function() {
var self = this;
self.columns.forEach(function (col) {
if ( col.cellTemplate ){
self.preCompileCellTemplate( col );
} else if ( col.cellTemplatePromise ){
col.cellTemplatePromise.then( function() {
self.preCompileCellTemplate( col );
});
}
});
};
/**
* @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) {
var base = 'row.entity';
if ( col.field === uiGridConstants.ENTITY_BINDING ) {
return base;
}
return gridUtil.preEval(base + '.' + 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 hasRightContainer
* @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) {
var self = this;
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) {
// See if the column name already exists:
var newName = colDef.field,
counter = 2;
while (self.getColumn(newName)) {
newName = colDef.field + counter.toString();
counter++;
}
colDef.name = newName;
}
};
// 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
* @param {array} lookInRows [optional] the rows to look in - if not provided then
* looks in grid.rows
*/
Grid.prototype.getRow = function getRow(rowEntity, lookInRows) {
var self = this;
lookInRows = typeof(lookInRows) === 'undefined' ? self.rows : lookInRows;
var rows = lookInRows.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
* @param {array} newRawData Modified set of data
*
* This method aims to achieve three things:
* 1. the resulting rows array is in the same order as the newRawData, we'll call
* rowsProcessors immediately after to sort the data anyway
* 2. if we have row hashing available, we try to use the rowHash to find the row
* 3. no memory leaks - rows that are no longer in newRawData need to be garbage collected
*
* The basic logic flow makes use of the newRawData, oldRows and oldHash, and creates
* the newRows and newHash
*
* ```
* newRawData.forEach newEntity
* if (hashing enabled)
* check oldHash for newEntity
* else
* look for old row directly in oldRows
* if !oldRowFound // must be a new row
* create newRow
* append to the newRows and add to newHash
* run the processors
* ```
*
* Rows are identified using the hashKey if configured. If not configured, then rows
* are identified using the gridOptions.rowEquality function
*
* This method is useful when trying to select rows immediately after loading data without
* using a $timeout/$interval, e.g.:
*
* $scope.gridOptions.data = someData;
* $scope.gridApi.grid.modifyRows($scope.gridOptions.data);
* $scope.gridApi.selection.selectRow($scope.gridOptions.data[0]);
*
* OR to persist row selection after data update (e.g. rows selected, new data loaded, want
* originally selected rows to be re-selected))
*/
Grid.prototype.modifyRows = function modifyRows(newRawData) {
var self = this;
var oldRows = self.rows.slice(0);
var oldRowHash = self.rowHashMap || self.createRowHashMap();
self.rowHashMap = self.createRowHashMap();
self.rows.length = 0;
newRawData.forEach( function( newEntity, i ) {
var newRow, oldRow;
if ( self.options.enableRowHashing ){
// if hashing is enabled, then this row will be in the hash if we already know about it
oldRow = oldRowHash.get( newEntity );
} else {
// otherwise, manually search the oldRows to see if we can find this row
oldRow = self.getRow(newEntity, oldRows);
}
// update newRow to have an entity
if ( oldRow ) {
newRow = oldRow;
newRow.entity = newEntity;
}
// if we didn't find the row, it must be new, so create it
if ( !newRow ){
newRow = self.processRowBuilders(new GridRow(newEntity, i, self));
}
self.rows.push( newRow );
self.rowHashMap.put( newEntity, newRow );
});
self.assignTypes();
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]);
};
/**
* 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 `