/***********************************************
* ng-grid JavaScript Library
* Authors: https://github.com/angular-ui/ng-grid/blob/master/README.md
* License: MIT (http://www.opensource.org/licenses/mit-license.php)
* Compiled At: 12/27/2012 16:39:37
***********************************************/
(function(window) {
'use strict';
/***********************************************
* FILE: ..\src\namespace.js
***********************************************/
if (!window.ng) {
window.ng = {};
}
window.ngGrid = {};
window.ngGrid.i18n = {};
var ngGridServices = angular.module('ngGrid.services', []);
var ngGridDirectives = angular.module('ngGrid.directives', []);
var ngGridFilters = angular.module('ngGrid.filters', []);
// Declare app level module which depends on filters, and services
/***********************************************
* FILE: ..\src\constants.js
***********************************************/
var SELECTED_PROP = '__ng_selected__';
// the # of rows we want to add to the top and bottom of the rendered grid rows
var EXCESS_ROWS = 8;
var SCROLL_THRESHOLD = 6;
var ASC = "asc";
// constant for sorting direction
var DESC = "desc";
// constant for sorting direction
var NG_FIELD = '_ng_field_';
var NG_DEPTH = '_ng_depth_';
var NG_HIDDEN = '_ng_hidden_';
var NG_COLUMN = '_ng_column_';
var CUSTOM_FILTERS = /CUSTOM_FILTERS/g;
var TEMPLATE_REGEXP = /<.+>/;
/***********************************************
* FILE: ..\src\navigation.js
***********************************************/
//set event binding on the grid so we can select using the up/down keys
ng.moveSelectionHandler = function($scope, grid, evt) {
// null checks
if (grid === null || grid === undefined) {
return true;
}
if (grid.config.selectedItems === undefined) {
return true;
}
var charCode = evt.which || evt.keyCode;
// detect which direction for arrow keys to navigate the grid
var offset = (charCode == 38 ? -1 : (charCode == 40 ? 1 : null));
if (!offset) {
return true;
}
var items = $scope.renderedRows;
var index = items.indexOf(grid.selectionService.lastClickedRow) + offset;
if (index < 0 || index >= items.length) {
return true;
}
grid.selectionService.ChangeSelection(items[index], evt);
if (index > items.length - EXCESS_ROWS) {
grid.$viewport.scrollTop(grid.$viewport.scrollTop() + (grid.config.rowHeight * 2));
} else if (index < EXCESS_ROWS) {
grid.$viewport.scrollTop(grid.$viewport.scrollTop() - (grid.config.rowHeight * 2));
}
if (!$scope.$$phase) {
$scope.$parent.$digest();
}
return false;
};
/***********************************************
* FILE: ..\src\utils.js
***********************************************/
if (!String.prototype.trim) {
String.prototype.trim = function() {
return this.replace(/^\s+|\s+$/g, '');
};
}
if (!Array.prototype.indexOf) {
Array.prototype.indexOf = function(elt /*, from*/) {
var len = this.length >>> 0;
var from = Number(arguments[1]) || 0;
from = (from < 0) ? Math.ceil(from) : Math.floor(from);
if (from < 0) {
from += len;
}
for (; from < len; from++) {
if (from in this && this[from] === elt) {
return from;
}
}
return -1;
};
}
if (!Array.prototype.filter) {
Array.prototype.filter = function(fun /*, thisp */) {
"use strict";
var t = Object(this);
var len = t.length >>> 0;
if (typeof fun !== "function") {
throw new TypeError();
}
var res = [];
var thisp = arguments[1];
for (var i = 0; i < len; i++) {
if (i in t) {
var val = t[i]; // in case fun mutates this
if (fun.call(thisp, val, i, t)) {
res.push(val);
}
}
}
return res;
};
}
ng.utils = {
visualLength: function(node) {
var elem = document.getElementById('testDataLength');
if (!elem) {
elem = document.createElement('SPAN');
elem.id = "testDataLength";
elem.style.visibility = "hidden";
document.body.appendChild(elem);
}
$(elem).css('font', $(node).css('font'));
elem.innerHTML = $(node).text();
return elem.offsetWidth;
},
forIn: function(obj, action) {
for (var prop in obj) {
if (obj.hasOwnProperty(prop)) {
action(obj[prop], prop);
}
}
},
evalProperty: function(entity, path) {
var propPath = path.split('.'), i = 0;
var tempProp = entity[propPath[i]], links = propPath.length;
i++;
while (tempProp && i < links) {
tempProp = tempProp[propPath[i]];
i++;
}
return tempProp;
},
endsWith: function(str, suffix) {
if (!str || !suffix || typeof str != "string") {
return false;
}
return str.indexOf(suffix, str.length - suffix.length) !== -1;
},
isNullOrUndefined: function(obj) {
if (obj === undefined || obj === null) {
return true;
}
return false;
},
getElementsByClassName: function(cl) {
var retnode = [];
var myclass = new RegExp('\\b' + cl + '\\b');
var elem = document.getElementsByTagName('*');
for (var i = 0; i < elem.length; i++) {
var classes = elem[i].className;
if (myclass.test(classes)) {
retnode.push(elem[i]);
}
}
return retnode;
},
newId: (function() {
var seedId = new Date().getTime();
return function() {
return seedId += 1;
};
})(),
seti18n: function($scope, language) {
var $langPack = window.ngGrid.i18n[language];
for (var label in $langPack) {
$scope.i18n[label] = $langPack[label];
}
},
// we copy KO's ie detection here bc it isn't exported in the min versions of KO
// Detect IE versions for workarounds (uses IE conditionals, not UA string, for robustness)
ieVersion: (function() {
var version = 3, div = document.createElement('div'), iElems = div.getElementsByTagName('i');
// Keep constructing conditional HTML blocks until we hit one that resolves to an empty fragment
while (div.innerHTML = '',
iElems[0]);
return version > 4 ? version : undefined;
})()
};
$.extend(ng.utils, {
isIe6: (function() {
return ng.utils.ieVersion === 6;
})(),
isIe7: (function() {
return ng.utils.ieVersion === 7;
})(),
isIe: (function() {
return ng.utils.ieVersion !== undefined;
})()
});
/***********************************************
* FILE: ..\src\filters\ngColumns.js
***********************************************/
ngGridFilters.filter('ngColumns', function() {
return function(input) {
return input.filter(function(col) {
return !col.isAggCol;
});
};
});
/***********************************************
* FILE: ..\src\filters\checkmark.js
***********************************************/
ngGridFilters.filter('checkmark', function() {
return function(input) {
return input ? '\u2714' : '\u2718';
};
});
/***********************************************
* FILE: ..\src\services\SortService.js
***********************************************/
ngGridServices.factory('SortService', function() {
var sortService = {};
sortService.colSortFnCache = {}; // cache of sorting functions. Once we create them, we don't want to keep re-doing it
sortService.dateRE = /^(\d\d?)[\/\.-](\d\d?)[\/\.-]((\d\d)?\d\d)$/; // nasty regex for date parsing
// this takes an piece of data from the cell and tries to determine its type and what sorting
// function to use for it
// @item - the cell data
sortService.guessSortFn = function(item) {
var sortFn, // sorting function that is guessed
itemType, // the typeof item
dateParts, // for date parsing
month, // for date parsing
day; // for date parsing
if (item === undefined || item === null || item === '') {
return null;
}
itemType = typeof(item);
//check for numbers and booleans
switch (itemType) {
case "number":
sortFn = sortService.sortNumber;
break;
case "boolean":
sortFn = sortService.sortBool;
break;
default:
sortFn = undefined;
break;
}
//if we found one, return it
if (sortFn) {
return sortFn;
}
//check if the item is a valid Date
if (Object.prototype.toString.call(item) === '[object Date]') {
return sortService.sortDate;
}
// if we aren't left with a string, return a basic sorting function...
if (itemType !== "string") {
return sortService.basicSort;
}
// now lets string check..
//check if the item data is a valid number
if (item.match(/^-?[�$�]?[\d,.]+%?$/)) {
return sortService.sortNumberStr;
}
// check for a date: dd/mm/yyyy or dd/mm/yy
// can have / or . or - as separator
// can be mm/dd as well
dateParts = item.match(sortService.dateRE);
if (dateParts) {
// looks like a date
month = parseInt(dateParts[1], 10);
day = parseInt(dateParts[2], 10);
if (month > 12) {
// definitely dd/mm
return sortService.sortDDMMStr;
} else if (day > 12) {
return sortService.sortMMDDStr;
} else {
// looks like a date, but we can't tell which, so assume that it's MM/DD
return sortService.sortMMDDStr;
}
}
//finally just sort the normal string...
return sortService.sortAlpha;
};
//#region Sorting Functions
sortService.basicSort = function(a, b) {
if (a == b) {
return 0;
}
if (a < b) {
return -1;
}
return 1;
};
sortService.sortNumber = function(a, b) {
return a - b;
};
sortService.sortNumberStr = function(a, b) {
var numA, numB, badA = false, badB = false;
numA = parseFloat(a.replace(/[^0-9.-]/g, ''));
if (isNaN(numA)) {
badA = true;
}
numB = parseFloat(b.replace(/[^0-9.-]/g, ''));
if (isNaN(numB)) {
badB = true;
}
// we want bad ones to get pushed to the bottom... which effectively is "greater than"
if (badA && badB) {
return 0;
}
if (badA) {
return 1;
}
if (badB) {
return -1;
}
return numA - numB;
};
sortService.sortAlpha = function(a, b) {
var strA = a.toLowerCase(),
strB = b.toLowerCase();
return strA == strB ? 0 : (strA < strB ? -1 : 1);
};
sortService.sortDate = function(a, b) {
var timeA = a.getTime(),
timeB = b.getTime();
return timeA == timeB ? 0 : (timeA < timeB ? -1 : 1);
};
sortService.sortBool = function(a, b) {
if (a && b) {
return 0;
}
if (!a && !b) {
return 0;
} else {
return a ? 1 : -1;
}
};
sortService.sortDDMMStr = function(a, b) {
var dateA, dateB, mtch, m, d, y;
mtch = a.match(sortService.dateRE);
y = mtch[3];
m = mtch[2];
d = mtch[1];
if (m.length == 1) {
m = '0' + m;
}
if (d.length == 1) {
d = '0' + d;
}
dateA = y + m + d;
mtch = b.match(sortService.dateRE);
y = mtch[3];
m = mtch[2];
d = mtch[1];
if (m.length == 1) {
m = '0' + m;
}
if (d.length == 1) {
d = '0' + d;
}
dateB = y + m + d;
if (dateA == dateB) {
return 0;
}
if (dateA < dateB) {
return -1;
}
return 1;
};
sortService.sortMMDDStr = function(a, b) {
var dateA, dateB, mtch, m, d, y;
mtch = a.match(sortService.dateRE);
y = mtch[3];
d = mtch[2];
m = mtch[1];
if (m.length == 1) {
m = '0' + m;
}
if (d.length == 1) {
d = '0' + d;
}
dateA = y + m + d;
mtch = b.match(sortService.dateRE);
y = mtch[3];
d = mtch[2];
m = mtch[1];
if (m.length == 1) {
m = '0' + m;
}
if (d.length == 1) {
d = '0' + d;
}
dateB = y + m + d;
if (dateA == dateB) {
return 0;
}
if (dateA < dateB) {
return -1;
}
return 1;
};
//#endregion
// the core sorting logic trigger
sortService.sortData = function(data /*datasource*/, sortInfo) {
// first make sure we are even supposed to do work
if (!data || !sortInfo) {
return;
}
// grab the metadata for the rest of the logic
var col = sortInfo.column,
direction = sortInfo.direction,
sortFn,
item;
//see if we already figured out what to use to sort the column
if (sortService.colSortFnCache[col.field]) {
sortFn = sortService.colSortFnCache[col.field];
} else if (col.sortingAlgorithm != undefined) {
sortFn = col.sortingAlgorithm;
sortService.colSortFnCache[col.field] = col.sortingAlgorithm;
} else { // try and guess what sort function to use
item = data[0];
if (!item) {
return;
}
sortFn = sortService.guessSortFn(item[col.field]);
//cache it
if (sortFn) {
sortService.colSortFnCache[col.field] = sortFn;
} else {
// we assign the alpha sort because anything that is null/undefined will never get passed to
// the actual sorting function. It will get caught in our null check and returned to be sorted
// down to the bottom
sortFn = sortService.sortAlpha;
}
}
//now actually sort the data
data.sort(function(itemA, itemB) {
var propA = ng.utils.evalProperty(itemA, col.field);
var propB = ng.utils.evalProperty(itemB, col.field);
// we want to force nulls and such to the bottom when we sort... which effectively is "greater than"
if (!propB && !propA) {
return 0;
} else if (!propA) {
return 1;
} else if (!propB) {
return -1;
}
//made it this far, we don't have to worry about null & undefined
if (direction === ASC) {
return sortFn(propA, propB);
} else {
return 0 - sortFn(propA, propB);
}
});
return;
};
sortService.Sort = function(sortInfo, data) {
if (sortService.isSorting) {
return;
}
sortService.isSorting = true;
sortService.sortData(data, sortInfo);
sortService.isSorting = false;
};
return sortService;
});
/***********************************************
* FILE: ..\src\services\DomUtilityService.js
***********************************************/
ngGridServices.factory('DomUtilityService', function() {
var domUtilityService = {};
var getWidths = function() {
var $testContainer = $('
');
$testContainer.appendTo('body');
// 1. Run all the following measurements on startup!
//measure Scroll Bars
$testContainer.height(100).width(100).css("position", "absolute").css("overflow", "scroll");
$testContainer.append('
');
domUtilityService.ScrollH = ($testContainer.height() - $testContainer[0].clientHeight);
domUtilityService.ScrollW = ($testContainer.width() - $testContainer[0].clientWidth);
$testContainer.empty();
//clear styles
$testContainer.attr('style', '');
//measure letter sizes using a pretty typical font size and fat font-family
$testContainer.append('M {{i18n.ngGroupPanelDescription}}
';};
/***********************************************
* FILE: ..\src\templates\cellTemplate.html
***********************************************/
ng.defaultCellTemplate = function(){ return '{{row.getProperty(col.field) CUSTOM_FILTERS}}
';};
/***********************************************
* FILE: ..\src\templates\aggregateTemplate.html
***********************************************/
ng.aggregateTemplate = function(){ return '{{row.label CUSTOM_FILTERS}} ({{row.totalChildren()}} {{AggItemsLabel}})
'
},
index: 0,
headerRowHeight: self.config.headerRowHeight,
sortCallback: self.sortData,
resizeOnDataCallback: self.resizeOnData,
enableResize: self.config.enableColumnResize,
enableSort: self.config.enableSorting
}, $scope, self, domUtilityService, $filter));
}
if (columnDefs.length > 0) {
angular.forEach(columnDefs, function(colDef, i) {
i += indexOffset;
var column = new ng.Column({
colDef: colDef,
index: i,
headerRowHeight: self.config.headerRowHeight,
sortCallback: self.sortData,
resizeOnDataCallback: self.resizeOnData,
enableResize: self.config.enableColumnResize,
enableSort: self.config.enableSorting
}, $scope, self, domUtilityService);
cols.push(column);
var indx = self.config.groups.indexOf(colDef.field);
if (indx != -1) {
$scope.configGroups.splice(indx, 0, column);
}
});
$scope.columns = cols;
}
};
self.configureColumnWidths = function() {
var cols = self.config.columnDefs;
var indexOffset = self.config.displaySelectionCheckbox ? $scope.configGroups.length + 1 : $scope.configGroups.length;
var numOfCols = cols.length + indexOffset,
asterisksArray = [],
percentArray = [],
asteriskNum = 0,
totalWidth = 0;
totalWidth += self.config.displaySelectionCheckbox ? 25 : 0;
angular.forEach(cols, function(col, i) {
i += indexOffset;
var isPercent = false, t = undefined;
//if width is not defined, set it to a single star
if (ng.utils.isNullOrUndefined(col.width)) {
col.width = "*";
} else { // get column width
isPercent = isNaN(col.width) ? ng.utils.endsWith(col.width, "%") : false;
t = isPercent ? col.width : parseInt(col.width, 10);
}
// check if it is a number
if (isNaN(t)) {
t = col.width;
// figure out if the width is defined or if we need to calculate it
if (t == 'auto') { // set it for now until we have data and subscribe when it changes so we can set the width.
$scope.columns[i].width = col.minWidth;
totalWidth += $scope.columns[i].width;
var temp = $scope.columns[i];
$scope.$evalAsync(function() {
self.resizeOnData(temp, true);
});
return;
} else if (t.indexOf("*") != -1) { // we need to save it until the end to do the calulations on the remaining width.
asteriskNum += t.length;
col.index = i;
asterisksArray.push(col);
return;
} else if (isPercent) { // If the width is a percentage, save it until the very last.
col.index = i;
percentArray.push(col);
return;
} else { // we can't parse the width so lets throw an error.
throw "unable to parse column width, use percentage (\"10%\",\"20%\", etc...) or \"*\" to use remaining width of grid";
}
} else {
totalWidth += $scope.columns[i].width = parseInt(col.width, 10);
}
});
// check if we saved any asterisk columns for calculating later
if (asterisksArray.length > 0) {
self.config.maintainColumnRatios === false ? angular.noop() : self.config.maintainColumnRatios = true;
// get the remaining width
var remainigWidth = self.rootDim.outerWidth - totalWidth;
// calculate the weight of each asterisk rounded down
var asteriskVal = Math.floor(remainigWidth / asteriskNum);
// set the width of each column based on the number of stars
angular.forEach(asterisksArray, function(col) {
var t = col.width.length;
$scope.columns[col.index].width = asteriskVal * t;
//check if we are on the last column
if (col.index + 1 == numOfCols) {
var offset = 2; //We're going to remove 2 px so we won't overlflow the viwport by default
// are we overflowing?
if (self.maxCanvasHt > $scope.viewportDimHeight()) {
//compensate for scrollbar
offset += domUtilityService.ScrollW;
}
$scope.columns[col.index].width -= offset;
}
totalWidth += $scope.columns[col.index].width;
});
}
// Now we check if we saved any percentage columns for calculating last
if (percentArray.length > 0) {
// do the math
angular.forEach(percentArray, function(col) {
var t = col.width;
$scope.columns[col.index].width = Math.floor(self.rootDim.outerWidth * (parseInt(t.slice(0, -1), 10) / 100));
});
}
};
self.init = function() {
//factories and services
self.selectionService = new ng.SelectionService(self);
self.rowFactory = new ng.RowFactory(self, $scope);
self.selectionService.Initialize(self.rowFactory);
self.searchProvider = new ng.SearchProvider($scope, self, $filter);
self.styleProvider = new ng.StyleProvider($scope, self, domUtilityService);
self.buildColumns();
$scope.$watch('configGroups', function(a) {
var tempArr = [];
angular.forEach(a, function(item) {
tempArr.push(item.field || item);
});
self.config.groups = tempArr;
self.rowFactory.filteredDataChanged();
$scope.$emit('ngGridEventGroups', a);
}, true);
$scope.$watch('columns', function(a) {
domUtilityService.BuildStyles($scope, self, true);
$scope.$emit('ngGridEventColumns', a);
}, true);
$scope.$watch(function() {
return options.i18n;
}, function(newLang) {
ng.utils.seti18n($scope, newLang);
});
self.maxCanvasHt = self.calcMaxCanvasHeight();
if (self.config.sortInfo) {
self.config.sortInfo.column = $scope.columns.filter(function(c) {
return c.field == self.config.sortInfo.field;
})[0];
self.config.sortInfo.column.sortDirection = self.config.sortInfo.direction.toUpperCase();
self.sortData(self.config.sortInfo.column);
}
};
self.prevScrollTop = 0;
self.prevScrollIndex = 0;
self.adjustScrollTop = function(scrollTop, force) {
if (self.prevScrollTop === scrollTop && !force) {
return;
}
var rowIndex = Math.floor(scrollTop / self.config.rowHeight);
// Have we hit the threshold going down?
if (self.prevScrollTop < scrollTop && rowIndex < self.prevScrollIndex + SCROLL_THRESHOLD) {
return;
}
//Have we hit the threshold going up?
if (self.prevScrollTop > scrollTop && rowIndex > self.prevScrollIndex - SCROLL_THRESHOLD) {
return;
}
self.prevScrollTop = scrollTop;
self.rowFactory.UpdateViewableRange(new ng.Range(Math.max(0, rowIndex - EXCESS_ROWS), rowIndex + self.minRowsToRender() + EXCESS_ROWS));
self.prevScrollIndex = rowIndex;
};
self.adjustScrollLeft = function(scrollLeft) {
if (self.$headerContainer) {
self.$headerContainer.scrollLeft(scrollLeft);
}
};
self.resizeOnData = function(col) {
// we calculate the longest data.
var longest = col.minWidth;
var arr = ng.utils.getElementsByClassName('col' + col.index);
angular.forEach(arr, function(elem, index) {
var i;
if (index === 0) {
var kgHeaderText = $(elem).find('.ngHeaderText');
i = ng.utils.visualLength(kgHeaderText) + 10; // +10 some margin
} else {
var ngCellText = $(elem).find('.ngCellText');
i = ng.utils.visualLength(ngCellText) + 10; // +10 some margin
}
if (i > longest) {
longest = i;
}
});
col.width = col.longest = Math.min(col.maxWidth, longest + 7); // + 7 px to make it look decent.
domUtilityService.BuildStyles($scope, self, true);
};
self.sortData = function(col) {
self.config.sortInfo = {
column: col,
field: col.field,
direction: col.sortDirection
};
self.clearSortingData(col);
if (!self.config.useExternalSorting) {
sortService.Sort(self.config.sortInfo, self.sortedData);
}
self.lastSortedColumn = col;
self.searchProvider.evalFilter();
$scope.$emit('ngGridEventSorted', col);
};
self.clearSortingData = function(col) {
if (!col) {
angular.forEach($scope.columns, function(c) {
c.sortDirection = "";
});
} else if (self.lastSortedColumn && col != self.lastSortedColumn) {
self.lastSortedColumn.sortDirection = "";
}
};
self.fixColumnIndexes = function() {
//fix column indexes
angular.forEach($scope.columns, function(col, i) {
col.index = i;
});
};
self.fixGroupIndexes = function() {
angular.forEach($scope.configGroups, function(item, i) {
item.groupIndex = i + 1;
});
};
//$scope vars
$scope.elementsNeedMeasuring = true;
$scope.columns = [];
$scope.renderedRows = [];
$scope.headerRow = null;
$scope.rowHeight = self.config.rowHeight;
$scope.jqueryUITheme = self.config.jqueryUITheme;
$scope.footer = null;
$scope.selectedItems = self.config.selectedItems;
$scope.multiSelect = self.config.multiSelect;
$scope.footerVisible = ng.utils.isNullOrUndefined(self.config.displayFooter) ? self.config.footerVisible : self.config.displayFooter;
$scope.footerRowHeight = $scope.footerVisible ? self.config.footerRowHeight : 0;
$scope.showColumnMenu = self.config.showColumnMenu;
$scope.showMenu = false;
$scope.configGroups = [];
//Paging
$scope.enablePaging = self.config.enablePaging;
$scope.pagingOptions = self.config.pagingOptions;
//Templates
$scope.rowTemplate = self.config.rowTemplate || ng.defaultRowTemplate();
$scope.headerRowTemplate = self.config.headerRowTemplate || ng.defaultHeaderRowTemplate();
//i18n support
$scope.i18n = {};
ng.utils.seti18n($scope, self.config.i18n);
if (self.config.rowTemplate && !TEMPLATE_REGEXP.test(self.config.rowTemplate)) {
$scope.rowTemplate = $.ajax({
type: "GET",
url: self.config.rowTemplate,
async: false
}).responseText;
}
if (self.config.headerRowTemplate && !TEMPLATE_REGEXP.test(self.config.headerRowTemplate)) {
$scope.headerRowTemplate = $.ajax({
type: "GET",
url: self.config.headerRowTemplate,
async: false
}).responseText;
}
//scope funcs
$scope.visibleColumns = function() {
return $scope.columns.filter(function(col) {
return col.visible;
});
};
$scope.toggleShowMenu = function() {
$scope.showMenu = !$scope.showMenu;
};
$scope.toggleSelectAll = function(a) {
self.selectionService.toggleSelectAll(a);
};
$scope.totalFilteredItemsLength = function() {
return self.filteredData.length;
};
$scope.showGroupPanel = function() {
return self.config.showGroupPanel;
};
$scope.topPanelHeight = function() {
return self.config.showGroupPanel === true ? self.config.headerRowHeight * 2 : self.config.headerRowHeight;
};
$scope.viewportDimHeight = function() {
return Math.max(0, self.rootDim.outerHeight - $scope.topPanelHeight() - $scope.footerRowHeight - 2);
};
$scope.groupBy = function(col) {
if (self.sortedData.length < 1 || !col.groupable) {
return;
}
var indx = $scope.configGroups.indexOf(col);
if (indx == -1) {
col.isGroupedBy = true;
$scope.configGroups.push(col);
col.groupIndex = $scope.configGroups.length;
} else {
$scope.removeGroup(indx);
}
};
$scope.removeGroup = function(index) {
var col = $scope.columns.filter(function(item) {
return item.groupIndex == (index + 1);
})[0];
col.isGroupedBy = false;
col.groupIndex = 0;
if ($scope.columns[index].isAggCol) {
$scope.columns.splice(index, 1);
$scope.configGroups.splice(index, 1);
self.fixGroupIndexes();
}
if ($scope.configGroups.length === 0) {
self.fixColumnIndexes();
domUtilityService.digest($scope);
}
};
$scope.totalRowWidth = function() {
var totalWidth = 0,
cols = $scope.visibleColumns();
angular.forEach(cols, function(col) {
totalWidth += col.width;
});
return totalWidth;
};
$scope.headerScrollerDim = function() {
var viewportH = $scope.viewportDimHeight(),
maxHeight = self.maxCanvasHt,
vScrollBarIsOpen = (maxHeight > viewportH),
newDim = new ng.Dimension();
newDim.autoFitHeight = true;
newDim.outerWidth = $scope.totalRowWidth();
if (vScrollBarIsOpen) {
newDim.outerWidth += self.elementDims.scrollW;
} else if ((maxHeight - viewportH) <= self.elementDims.scrollH) { //if the horizontal scroll is open it forces the viewport to be smaller
newDim.outerWidth += self.elementDims.scrollW;
}
return newDim;
};
//call init
self.init();
};
/***********************************************
* FILE: ..\src\classes\range.js
***********************************************/
ng.Range = function(top, bottom) {
this.topRow = top;
this.bottomRow = bottom;
};
/***********************************************
* FILE: ..\src\classes\row.js
***********************************************/
ng.Row = function(entity, config, selectionService) {
var self = this, // constant for the selection property that we add to each data item
canSelectRows = config.canSelectRows;
self.jqueryUITheme = config.jqueryUITheme;
self.rowClasses = config.rowClasses;
self.entity = entity;
self.selectionService = selectionService;
self.selected = false;
self.cursor = canSelectRows ? 'pointer' : 'default';
self.continueSelection = function(event) {
self.selectionService.ChangeSelection(self, event);
};
self.toggleSelected = function(event) {
if (!canSelectRows) {
return true;
}
var element = event.target || event;
//check and make sure its not the bubbling up of our checked 'click' event
if (element.type == "checkbox" && element.parentElement.className != "ngSelectionCell ng-scope") {
return true;
}
if (config.selectWithCheckboxOnly && element.type != "checkbox") {
return true;
} else {
if (self.beforeSelectionChange(self)) {
self.continueSelection(event);
return self.afterSelectionChange();
}
}
return false;
};
self.rowIndex = 0;
self.offsetTop = 0;
self.rowDisplayIndex = 0;
self.alternatingRowClass = function () {
var isEven = (self.rowIndex % 2) === 0;
var classes = {
'selected': self.selected,
'ui-state-default': self.jqueryUITheme && isEven,
'ui-state-active': self.jqueryUITheme && !isEven,
'even': isEven,
'odd': !isEven
};
return classes;
};
self.beforeSelectionChange = config.beforeSelectionChangeCallback;
self.afterSelectionChange = config.afterSelectionChangeCallback;
self.propertyCache = {};
self.getProperty = function(path) {
return self.propertyCache[path] || ng.utils.evalProperty(self.entity, path);
};
//selectify the entity
if (self.entity[SELECTED_PROP] === undefined) {
self.entity[SELECTED_PROP] = false;
} else if (self.entity[SELECTED_PROP]) {
// or else maintain the selection set by the entity.
self.selectionService.setSelection(self, self.entity[SELECTED_PROP]);
}
};
/***********************************************
* FILE: ..\src\classes\searchProvider.js
***********************************************/
ng.SearchProvider = function($scope, grid, $filter) {
var self = this,
searchConditions = [];
self.extFilter = grid.config.filterOptions.useExternalFilter;
$scope.showFilter = grid.config.showFilter;
$scope.filterText = grid.config.filterOptions.filterText;
self.fieldMap = {};
self.evalFilter = function() {
if (searchConditions.length === 0) {
grid.filteredData = grid.sortedData;
} else {
grid.filteredData = grid.sortedData.filter(function(item) {
for (var i = 0, len = searchConditions.length; i < len; i++) {
var condition = searchConditions[i];
//Search entire row
if (!condition.column) {
for (var prop in item) {
if (item.hasOwnProperty(prop)) {
if (prop == SELECTED_PROP) {
continue;
}
var c = self.fieldMap[prop];
var f = (c && c.cellFilter) ? $filter(c.cellFilter) : null;
var pVal = item[prop];
if (pVal && (condition.regex.test(pVal.toString()) || (f && condition.regex.test(f(pVal).toString())))) {
return true;
}
}
}
return false;
}
//Search by column.
var col = self.fieldMap[condition.columnDisplay];
if (!col) {
return false;
}
var filter = col.cellFilter ? $filter(col.cellFilter) : null;
var value = item[condition.column] || item[col.field];
if ((!value || !condition.regex.test(value.toString())) && !(typeof filter == "function" && condition.regex.test(filter(value)))) {
return false;
}
}
return true;
});
}
grid.rowFactory.filteredDataChanged();
};
var getRegExp = function(str, modifiers) {
try {
return new RegExp(str, modifiers);
} catch(err) {
//Escape all RegExp metacharacters.
return new RegExp(str.replace(/(\^|\$|\(|\)|\<|\>|\[|\]|\{|\}|\\|\||\.|\*|\+|\?)/g, '\\$1'));
}
};
var buildSearchConditions = function(a) {
//reset.
searchConditions = [];
var qStr = '';
if (!(qStr = $.trim(a))) {
return;
}
var columnFilters = qStr.split(";");
$.each(columnFilters, function(i, filter) {
var args = filter.split(':');
if (args.length > 1) {
var columnName = $.trim(args[0]);
var columnValue = $.trim(args[1]);
if (columnName && columnValue) {
searchConditions.push({
column: columnName,
columnDisplay: columnName.replace(/\s+/g, '').toLowerCase(),
regex: getRegExp(columnValue, 'i')
});
}
} else {
var val = $.trim(args[0]);
if (val) {
searchConditions.push({
column: '',
regex: getRegExp(val, 'i')
});
}
}
});
};
$scope.$watch('filterText', function(a) {
if (!self.extFilter) {
buildSearchConditions(a);
self.evalFilter();
}
});
if (!self.extFilter) {
$scope.$watch('columns', function(a) {
angular.forEach(a, function(col) {
self.fieldMap[col.field] = col;
self.fieldMap[col.displayName.toLowerCase().replace(/\s+/g, '')] = col;
});
});
}
};
/***********************************************
* FILE: ..\src\classes\selectionService.js
***********************************************/
ng.SelectionService = function(grid) {
var self = this;
self.multi = grid.config.multiSelect;
self.selectedItems = grid.config.selectedItems;
self.selectedIndex = grid.config.selectedIndex;
self.lastClickedRow = undefined;
self.ignoreSelectedItemChanges = false; // flag to prevent circular event loops keeping single-select var in sync
self.rowFactory = {};
self.Initialize = function(rowFactory) {
self.rowFactory = rowFactory;
};
// function to manage the selection action of a data item (entity)
self.ChangeSelection = function(rowItem, evt) {
if (evt && evt.shiftKey && self.multi) {
if (self.lastClickedRow) {
var thisIndx = grid.filteredData.indexOf(rowItem.entity);
var prevIndx = grid.filteredData.indexOf(self.lastClickedRow.entity);
if (thisIndx == prevIndx) {
return false;
}
prevIndx++;
if (thisIndx < prevIndx) {
thisIndx = thisIndx ^ prevIndx;
prevIndx = thisIndx ^ prevIndx;
thisIndx = thisIndx ^ prevIndx;
}
var rows = [];
for (; prevIndx <= thisIndx; prevIndx++) {
rows.push(self.rowFactory.rowCache[prevIndx]);
}
if (rows[rows.length - 1].beforeSelectionChange(rows, evt)) {
$.each(rows, function(i, ri) {
ri.selected = true;
ri.entity[SELECTED_PROP] = true;
if (self.selectedItems.indexOf(ri.entity) === -1) {
self.selectedItems.push(ri.entity);
}
});
rows[rows.length - 1].afterSelectionChange(rows, evt);
}
self.lastClickedRow = rows[rows.length - 1];
return true;
}
} else if (!self.multi) {
if (self.lastClickedRow && self.lastClickedRow != rowItem) {
self.setSelection(self.lastClickedRow, false);
}
self.setSelection(rowItem, grid.config.keepLastSelected ? true : !rowItem.selected);
} else {
self.setSelection(rowItem, !rowItem.selected);
}
self.lastClickedRow = rowItem;
return true;
};
// just call this func and hand it the rowItem you want to select (or de-select)
self.setSelection = function(rowItem, isSelected) {
rowItem.selected = isSelected;
rowItem.entity[SELECTED_PROP] = isSelected;
if (!isSelected) {
var indx = self.selectedItems.indexOf(rowItem.entity);
self.selectedItems.splice(indx, 1);
} else {
if (self.selectedItems.indexOf(rowItem.entity) === -1) {
self.selectedItems.push(rowItem.entity);
}
}
};
// @return - boolean indicating if all items are selected or not
// @val - boolean indicating whether to select all/de-select all
self.toggleSelectAll = function (checkAll) {
angular.forEach(grid.filteredData, function(item, i) {
grid.rowFactory.buildEntityRow(item, i);
});
if (grid.config.beforeSelectionChange(grid.rowFactory.rowCache)) {
var selectedlength = self.selectedItems.length;
if (selectedlength > 0) {
self.selectedItems.splice(0, selectedlength);
}
angular.forEach(grid.filteredData, function (item) {
item[SELECTED_PROP] = checkAll;
if (checkAll) {
self.selectedItems.push(item);
}
});
angular.forEach(self.rowFactory.rowCache, function (row) {
row.selected = checkAll;
});
grid.config.afterSelectionChange(grid.rowFactory.rowCache);
}
};
};
/***********************************************
* FILE: ..\src\classes\styleProvider.js
***********************************************/
ng.StyleProvider = function($scope, grid, domUtilityService) {
$scope.headerCellStyle = function(col) {
return { "height": col.headerRowHeight + "px" };
};
$scope.rowStyle = function(row) {
return { "top": row.offsetTop + "px", "height": $scope.rowHeight + "px" };
};
$scope.canvasStyle = function() {
return { "height": grid.maxCanvasHt.toString() + "px" };
};
$scope.headerScrollerStyle = function() {
return { "height": grid.config.headerRowHeight + "px" };
};
$scope.topPanelStyle = function() {
return { "width": grid.rootDim.outerWidth + "px", "height": $scope.topPanelHeight() + "px" };
};
$scope.headerStyle = function() {
return { "width": (grid.rootDim.outerWidth - domUtilityService.ScrollW) + "px", "height": grid.config.headerRowHeight + "px" };
};
$scope.viewportStyle = function() {
return { "width": grid.rootDim.outerWidth + "px", "height": $scope.viewportDimHeight() + "px" };
};
$scope.footerStyle = function() {
return { "width": grid.rootDim.outerWidth + "px", "height": $scope.footerRowHeight + "px" };
};
};
/***********************************************
* FILE: ..\src\directives\ng-grid.js
***********************************************/
ngGridDirectives.directive('ngGrid', ['$compile', '$filter', 'SortService', 'DomUtilityService', function($compile, $filter, sortService, domUtilityService) {
var ngGrid = {
scope: true,
compile: function() {
return {
pre: function($scope, iElement, iAttrs) {
var $element = $(iElement);
var options = $scope.$eval(iAttrs.ngGrid);
options.gridDim = new ng.Dimension({ outerHeight: $($element).height(), outerWidth: $($element).width() });
var grid = new ng.Grid($scope, options, sortService, domUtilityService, $filter);
// if columndefs are a string of a property ont he scope watch for changes and rebuild columns.
if (typeof options.columnDefs == "string") {
$scope.$parent.$watch(options.columnDefs, function(a) {
$scope.columns = [];
grid.config.columnDefs = a;
grid.buildColumns();
grid.configureColumnWidths();
domUtilityService.BuildStyles($scope, grid);
grid.eventProvider.assignEvents();
});
}
// if it is a string we can watch for data changes. otherwise you won't be able to update the grid data
if (typeof options.data == "string") {
var prevlength = 0;
var dataWatcher = function (a) {
prevlength = a ? a.length:0;
grid.sortedData = $scope.$eval(options.data) || [];
grid.searchProvider.evalFilter();
grid.configureColumnWidths();
grid.refreshDomSizes();
if (grid.config.sortInfo) {
if (!grid.config.sortInfo.column) {
grid.config.sortInfo.column = $scope.columns.filter(function(c) {
return c.field == grid.config.sortInfo.field;
})[0];
if (!grid.config.sortInfo.column) {
return;
}
}
grid.config.sortInfo.column.sortDirection = grid.config.sortInfo.direction.toLowerCase();
grid.sortData(grid.config.sortInfo.column);
}
};
$scope.$parent.$watch(options.data, dataWatcher);
$scope.$parent.$watch(options.data + '.length', function(a) {
if (a != prevlength) {
dataWatcher($scope.$eval(options.data));
}
});
}
var htmlText = ng.defaultGridTemplate(grid.config);
grid.footerController = new ng.Footer($scope, grid);
//set the right styling on the container
iElement.addClass("ngGrid").addClass(grid.gridId.toString());
if (options.jqueryUITheme) {
iElement.addClass('ui-widget');
}
iElement.append($compile(htmlText)($scope)); // make sure that if any of these change, we re-fire the calc logic
//walk the element's graph and the correct properties on the grid
domUtilityService.AssignGridContainers(iElement, grid);
grid.configureColumnWidths();
//now use the manager to assign the event handlers
grid.eventProvider = new ng.EventProvider(grid, $scope, domUtilityService);
//initialize plugins.
angular.forEach(options.plugins, function(p) {
p.init($scope.$new(), grid, { SortService: sortService, DomUtilityService: domUtilityService });
});
return null;
}
};
}
};
return ngGrid;
}]);
/***********************************************
* FILE: ..\src\directives\ng-row.js
***********************************************/
ngGridDirectives.directive('ngRow', ['$compile', function($compile) {
var ngRow = {
scope: false,
compile: function() {
return {
pre: function($scope, iElement) {
if ($scope.row.isAggRow) {
var html = ng.aggregateTemplate();
if ($scope.row.aggLabelFilter) {
html = html.replace(CUSTOM_FILTERS, '| ' + $scope.row.aggLabelFilter);
} else {
html = html.replace(CUSTOM_FILTERS, "");
}
iElement.append($compile(html)($scope));
} else {
iElement.append($compile($scope.rowTemplate)($scope));
}
}
};
}
};
return ngRow;
}]);
/***********************************************
* FILE: ..\src\directives\ng-cell.js
***********************************************/
ngGridDirectives.directive('ngCell', ['$compile', function($compile) {
var ngCell = {
scope: false,
compile: function() {
return {
pre: function($scope, iElement) {
iElement.append($compile($scope.col.cellTemplate)($scope));
}
};
}
};
return ngCell;
}]);
/***********************************************
* FILE: ..\src\directives\ng-header-row.js
***********************************************/
ngGridDirectives.directive('ngHeaderRow', ['$compile', function($compile) {
var ngHeaderRow = {
scope: false,
compile: function() {
return {
pre: function($scope, iElement) {
if (iElement.children().length === 0) {
iElement.append($compile($scope.headerRowTemplate)($scope));
}
}
};
}
};
return ngHeaderRow;
}]);
/***********************************************
* FILE: ..\src\directives\ng-header-cell.js
***********************************************/
ngGridDirectives.directive('ngHeaderCell', ['$compile', function($compile) {
var ngHeaderCell = {
scope: false,
compile: function() {
return {
pre: function($scope, iElement) {
iElement.append($compile($scope.col.headerCellTemplate)($scope));
}
};
}
};
return ngHeaderCell;
}]);
/***********************************************
* FILE: ..\src\init.js
***********************************************/
// initialization of services into the main module
angular.module('ngGrid', ['ngGrid.services', 'ngGrid.directives', 'ngGrid.filters']);
/***********************************************
* LANGUAGE: en.js
***********************************************/
window.ngGrid.i18n['en'] = {
ngAggregateLabel: 'items',
ngGroupPanelDescription: 'Drag a column header here and drop it to group by that column.',
ngSearchPlaceHolder: 'Search...',
ngMenuText: 'Choose Columns:',
ngShowingItemsLabel: 'Showing Items:',
ngTotalItemsLabel: 'Total Items:',
ngSelectedItemsLabel: 'Selected Items:',
ngPageSizeLabel: 'Page Size:',
ngPagerFirstTitle: 'First Page',
ngPagerNextTitle: 'Next Page',
ngPagerPrevTitle: 'Previous Page',
ngPagerLastTitle: 'Last Page'
};
}(window));