From 39636be7b018b9121696ce7bdc462ab2c3c8185d Mon Sep 17 00:00:00 2001
From: Trygve Laugstøl <trygvis@inamo.no>
Date: Fri, 11 Jan 2013 17:11:28 +0100
Subject: o Creating bin/web for running the web application.

---
 .../ng-grid-1.5.0/ng-grid-1.5.0.debug.js           | 2334 ++++++++++++++++++++
 1 file changed, 2334 insertions(+)
 create mode 100644 src/main/resources/webapp/external/angular-ui/ng-grid-1.5.0/ng-grid-1.5.0.debug.js

(limited to 'src/main/resources/webapp/external/angular-ui/ng-grid-1.5.0/ng-grid-1.5.0.debug.js')

diff --git a/src/main/resources/webapp/external/angular-ui/ng-grid-1.5.0/ng-grid-1.5.0.debug.js b/src/main/resources/webapp/external/angular-ui/ng-grid-1.5.0/ng-grid-1.5.0.debug.js
new file mode 100644
index 0000000..4ceaa00
--- /dev/null
+++ b/src/main/resources/webapp/external/angular-ui/ng-grid-1.5.0/ng-grid-1.5.0.debug.js
@@ -0,0 +1,2334 @@
+/***********************************************
+ * 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/21/2012 15:55:15
+ ***********************************************/
+
+(function(window) {
+  'use strict';
+
+  /***********************************************
+   * FILE: ..\src\namespace.js
+   ***********************************************/
+  window.ng = {};
+  window.ng.$http = undefined;
+  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__';
+  var GRID_KEY = '__koGrid__';
+// 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;
+      };
+    })(),
+
+    // 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 = '<!--[if gt IE ' + (++version) + ']><i></i><![endif]-->',
+          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 = $('<div></div>');
+      $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('<div style="height: 400px; width: 400px;"></div>');
+      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('<span style="font-family: Verdana, Helvetica, Sans-Serif; font-size: 14px;"><strong>M</strong></span>');
+      domUtilityService.LetterW = $testContainer.children().first().width();
+      $testContainer.remove();
+    };
+    domUtilityService.eventStorage = {};
+    domUtilityService.AssignGridContainers = function(rootEl, grid) {
+      grid.$root = $(rootEl);
+      //Headers
+      grid.$topPanel = grid.$root.find(".ngTopPanel");
+      grid.$groupPanel = grid.$root.find(".ngGroupPanel");
+      grid.$headerContainer = grid.$topPanel.find(".ngHeaderContainer");
+      grid.$headerScroller = grid.$topPanel.find(".ngHeaderScroller");
+      grid.$headers = grid.$headerScroller.children();
+      //Viewport
+      grid.$viewport = grid.$root.find(".ngViewport");
+      //Canvas
+      grid.$canvas = grid.$viewport.find(".ngCanvas");
+      //Footers
+      grid.$footerPanel = grid.$root.find(".ngFooterPanel");
+      domUtilityService.UpdateGridLayout(grid);
+    };
+    domUtilityService.UpdateGridLayout = function(grid) {
+      //catch this so we can return the viewer to their original scroll after the resize!
+      var scrollTop = grid.$viewport.scrollTop();
+      grid.elementDims.rootMaxW = grid.$root.width();
+      grid.elementDims.rootMaxH = grid.$root.height();
+      //check to see if anything has changed
+      grid.refreshDomSizes();
+      grid.adjustScrollTop(scrollTop, true); //ensure that the user stays scrolled where they were
+    };
+    domUtilityService.numberOfGrids = 0;
+    domUtilityService.BuildStyles = function($scope, grid, digest) {
+      var rowHeight = grid.config.rowHeight,
+          $style = grid.$styleSheet,
+          gridId = grid.gridId,
+          css,
+          cols = $scope.visibleColumns(),
+          sumWidth = 0;
+
+      if (!$style) {
+        $style = $('#' + gridId);
+        if (!$style[0]) {
+          $style = $("<style id='" + gridId + "' type='text/css' rel='stylesheet' />").appendTo(grid.$root);
+        }
+      }
+      $style.empty();
+      var trw = $scope.totalRowWidth();
+      css = "." + gridId + " .ngCanvas { width: " + trw + "px; }" +
+          "." + gridId + " .ngRow { width: " + trw + "px; }" +
+          "." + gridId + " .ngCanvas { width: " + trw + "px; }" +
+          "." + gridId + " .ngHeaderScroller { width: " + (trw + domUtilityService.scrollH + 2) + "px}";
+      angular.forEach(cols, function(col, i) {
+        css += "." + gridId + " .col" + i + " { width: " + col.width + "px; left: " + sumWidth + "px; right: " + (trw - sumWidth - col.width) + "px; height: " + rowHeight + "px }" +
+            "." + gridId + " .colt" + i + " { width: " + col.width + "px; }";
+        sumWidth += col.width;
+      });
+      if (ng.utils.isIe) { // IE
+        $style[0].styleSheet.cssText = css;
+      } else {
+        $style[0].appendChild(document.createTextNode(css));
+      }
+      grid.$styleSheet = $style;
+      if (digest) {
+        domUtilityService.digest($scope);
+      }
+    };
+
+    domUtilityService.digest = function($scope) {
+      if (!$scope.$$phase) {
+        $scope.$digest();
+      }
+    };
+    domUtilityService.ScrollH = 17; // default in IE, Chrome, & most browsers
+    domUtilityService.ScrollW = 17; // default in IE, Chrome, & most browsers
+    domUtilityService.LetterW = 10;
+    getWidths();
+    return domUtilityService;
+  });
+
+  /***********************************************
+   * FILE: ..\src\templates\gridTemplate.html
+   ***********************************************/
+  ng.defaultGridTemplate = function(){ return '<div class="ngTopPanel" ng-class="{\'ui-widget-header\':jqueryUITheme, \'ui-corner-top\': jqueryUITheme}" ng-style="topPanelStyle()"><div class="ngGroupPanel" ng-show="showGroupPanel()" ng-style="headerStyle()"><div class="ngGroupPanelDescription" ng-show="configGroups.length == 0">Drag a column header here and drop it to group by that column</div><ul ng-show="configGroups.length > 0" class="ngGroupList"><li class="ngGroupItem" ng-repeat="group in configGroups"><span class="ngGroupElement"><span class="ngGroupName">{{group.displayName}}<span ng-click="removeGroup($index)" class="ngRemoveGroup">x</span></span><span ng-hide="$last" class="ngGroupArrow"></span></span></li></ul></div><div class="ngHeaderContainer" ng-style="headerStyle()"><div class="ngHeaderScroller" ng-style="headerScrollerStyle()" ng-header-row></div></div><div class="ngHeaderButton" ng-show="showColumnMenu || showFilter" ng-click="toggleShowMenu()"><div class="ngHeaderButtonArrow" ng-click=""></div></div><div ng-show="showMenu" class="ngColMenu"><div ng-show="showFilter"><input placeholder="Search..." type="text" ng-model="filterText"/></div><div ng-show="showColumnMenu"><span class="ngMenuText">Choose Columns:</span><ul class="ngColList"><li class="ngColListItem" ng-repeat="col in columns | ngColumns"><label><input type="checkbox" class="ngColListCheckbox" ng-model="col.visible"/>{{col.displayName}}</label><a title="Group By" ng-class="col.groupedByClass()" ng-show="col.groupable" ng-click="groupBy(col)"></a><span class="ngGroupingNumber" ng-show="col.groupIndex > 0">{{col.groupIndex}}</span></li></ul></div></div></div><div class="ngViewport" ng-class="{\'ui-widget-content\': jqueryUITheme}" ng-style="viewportStyle()"><div class="ngCanvas" ng-style="canvasStyle()"><div ng-style="rowStyle(row)" ng-repeat="row in renderedRows" ng-click="row.toggleSelected($event)" class="ngRow" ng-class="row.alternatingRowClass()" ng-row></div></div></div><div class="ngFooterPanel" ng-class="{\'ui-widget-content\': jqueryUITheme, \'ui-corner-bottom\': jqueryUITheme}" ng-style="footerStyle()"><div class="ngTotalSelectContainer" ng-show="footerVisible"><div class="ngFooterTotalItems" ng-class="{\'ngNoMultiSelect\': !multiSelect}" ><span class="ngLabel">Total Items: {{maxRows()}}</span><span ng-show="filterText.length > 0" class="ngLabel">(Showing Items: {{totalFilteredItemsLength()}})</span></div><div class="ngFooterSelectedItems" ng-show="multiSelect"><span class="ngLabel">Selected Items: {{selectedItems.length}}</span></div></div><div class="ngPagerContainer" style="float: right; margin-top: 10px;" ng-show="footerVisible && enablePaging" ng-class="{\'ngNoMultiSelect\': !multiSelect}"><div style="float:left; margin-right: 10px;" class="ngRowCountPicker"><span style="float: left; margin-top: 3px;" class="ngLabel">Page Size:</span><select style="float: left;height: 27px; width: 100px" ng-model="pagingOptions.pageSize" ><option ng-repeat="size in pagingOptions.pageSizes">{{size}}</option></select></div><div style="float:left; margin-right: 10px; line-height:25px;" class="ngPagerControl" style="float: left; min-width: 135px;"><button class="ngPagerButton" ng-click="pageToFirst()" ng-disabled="cantPageBackward()" title="First Page"><div class="ngPagerFirstTriangle"><div class="ngPagerFirstBar"></div></div></button><button class="ngPagerButton" ng-click="pageBackward()" ng-disabled="cantPageBackward()" title="Previous Page"><div class="ngPagerFirstTriangle ngPagerPrevTriangle"></div></button><input class="ngPagerCurrent" type="text" style="width:50px; height: 24px; margin-top: 1px; padding: 0px 4px;" ng-model="pagingOptions.currentPage"/><button class="ngPagerButton" ng-click="pageForward()" ng-disabled="cantPageForward()" title="Next Page"><div class="ngPagerLastTriangle ngPagerNextTriangle"></div></button><button class="ngPagerButton" ng-click="pageToLast()" ng-disabled="cantPageForward()" title="Last Page"><div class="ngPagerLastTriangle"><div class="ngPagerLastBar"></div></div></button></div></div></div>';};
+
+  /***********************************************
+   * FILE: ..\src\templates\rowTemplate.html
+   ***********************************************/
+  ng.defaultRowTemplate = function(){ return '<div ng-style="{\'cursor\': row.cursor}" ng-repeat="col in visibleColumns()" class="ngCell col{{$index}} {{col.cellClass}}" ng-cell></div>';};
+
+  /***********************************************
+   * FILE: ..\src\templates\cellTemplate.html
+   ***********************************************/
+  ng.defaultCellTemplate = function(){ return '<div class="ngCellText colt{{$index}}">{{row.getProperty(col.field) CUSTOM_FILTERS}}</div>';};
+
+  /***********************************************
+   * FILE: ..\src\templates\aggregateTemplate.html
+   ***********************************************/
+  ng.aggregateTemplate = function(){ return '<div ng-click="row.toggleExpand()" ng-style="{\'left\': row.offsetleft}" class="ngAggregate"><span class="ngAggregateText">{{row.label CUSTOM_FILTERS}} ({{row.totalChildren()}} items)</span><div class="{{row.aggClass()}}"></div></div>';};
+
+  /***********************************************
+   * FILE: ..\src\templates\headerRowTemplate.html
+   ***********************************************/
+  ng.defaultHeaderRowTemplate = function(){ return '<div ng-repeat="col in visibleColumns()" class="ngHeaderCell col{{$index}}" ng-header-cell></div>';};
+
+  /***********************************************
+   * FILE: ..\src\templates\headerCellTemplate.html
+   ***********************************************/
+  ng.defaultHeaderCellTemplate = function(){ return '<div ng-click="col.sort()" class="ngHeaderSortColumn {{col.headerClass}}" ng-style="{\'cursor\': col.cursor}" ng-class="{ \'ngSorted\': !noSortVisible }"><div class="ngHeaderText colt{{$index}}">{{col.displayName}}</div><div class="ngSortButtonDown" ng-show="col.showSortButtonDown()"></div><div class="ngSortButtonUp" ng-show="col.showSortButtonUp()"></div></div><div ng-show="col.resizable" class="ngHeaderGrip" ng-click="col.gripClick($event)" ng-mousedown="col.gripOnMouseDown($event)"></div>';};
+
+  /***********************************************
+   * FILE: ..\src\classes\aggregate.js
+   ***********************************************/
+  ng.Aggregate = function(aggEntity, rowFactory) {
+    var self = this;
+    self.index = 0;
+    self.offsetTop = 0;
+    self.entity = aggEntity;
+    self.label = aggEntity.gLabel;
+    self.field = aggEntity.gField;
+    self.depth = aggEntity.gDepth;
+    self.parent = aggEntity.parent;
+    self.children = aggEntity.children;
+    self.aggChildren = aggEntity.aggChildren;
+    self.aggIndex = aggEntity.aggIndex;
+    self.collapsed = true;
+    self.isAggRow = true;
+    self.offsetleft = aggEntity.gDepth * 25;
+    self.aggLabelFilter = aggEntity.aggLabelFilter;
+    self.toggleExpand = function() {
+      self.collapsed = self.collapsed ? false : true;
+      self.notifyChildren();
+    };
+    self.setExpand = function(state) {
+      self.collapsed = state;
+      self.notifyChildren();
+    };
+    self.notifyChildren = function() {
+      angular.forEach(self.aggChildren, function(child) {
+        child.entity[NG_HIDDEN] = self.collapsed;
+        if (self.collapsed) {
+          child.setExpand(self.collapsed);
+        }
+      });
+      angular.forEach(self.children, function(child) {
+        child[NG_HIDDEN] = self.collapsed;
+      });
+      rowFactory.rowCache = [];
+      var foundMyself = false;
+      angular.forEach(rowFactory.aggCache, function(agg, i) {
+        if (foundMyself) {
+          var offset = (30 * self.children.length);
+          agg.offsetTop = self.collapsed ? agg.offsetTop - offset : agg.offsetTop + offset;
+        } else {
+          if (i == self.aggIndex) {
+            foundMyself = true;
+          }
+        }
+      });
+      rowFactory.renderedChange();
+    };
+    self.aggClass = function() {
+      return self.collapsed ? "ngAggArrowCollapsed" : "ngAggArrowExpanded";
+    };
+    self.totalChildren = function() {
+      if (self.aggChildren.length > 0) {
+        var i = 0;
+        var recurse = function(cur) {
+          if (cur.aggChildren.length > 0) {
+            angular.forEach(cur.aggChildren, function(a) {
+              recurse(a);
+            });
+          } else {
+            i += cur.children.length;
+          }
+        };
+        recurse(self);
+        return i;
+      } else {
+        return self.children.length;
+      }
+    };
+  };
+
+  /***********************************************
+   * FILE: ..\src\classes\eventProvider.js
+   ***********************************************/
+  ng.EventProvider = function(grid, $scope, domUtilityService) {
+    var self = this;
+    // The init method gets called during the ng-grid directive execution.
+    self.colToMove = undefined;
+    self.groupToMove = undefined;
+    self.assignEvents = function() {
+      // Here we set the onmousedown event handler to the header container.
+      if (grid.config.jqueryUIDraggable) {
+        grid.$groupPanel.droppable({
+          addClasses: false,
+          drop: function(event) {
+            self.onGroupDrop(event);
+          }
+        });
+        $scope.$evalAsync(self.setDraggables);
+      } else {
+        grid.$groupPanel.on('mousedown', self.onGroupMouseDown).on('dragover', self.dragOver).on('drop', self.onGroupDrop);
+        grid.$headerScroller.on('mousedown', self.onHeaderMouseDown).on('dragover', self.dragOver);
+        if (grid.config.enableColumnReordering) {
+          grid.$headerScroller.on('drop', self.onHeaderDrop);
+        }
+        if (grid.config.enableRowReordering) {
+          grid.$viewport.on('mousedown', self.onRowMouseDown).on('dragover', self.dragOver).on('drop', self.onRowDrop);
+        }
+      }
+      $scope.$watch('columns', self.setDraggables, true);
+    };
+    self.dragOver = function(evt) {
+      evt.preventDefault();
+    };
+    //For JQueryUI
+    self.setDraggables = function() {
+      if (!grid.config.jqueryUIDraggable) {
+        grid.$root.find('.ngHeaderSortColumn').attr('draggable', 'true');
+      } else {
+        grid.$root.find('.ngHeaderSortColumn').draggable({
+          helper: 'clone',
+          appendTo: 'body',
+          stack: 'div',
+          addClasses: false,
+          start: function(event) {
+            self.onHeaderMouseDown(event);
+          }
+        }).droppable({
+              drop: function(event) {
+                self.onHeaderDrop(event);
+              }
+            });
+      }
+    };
+    self.onGroupMouseDown = function(event) {
+      var groupItem = $(event.target);
+      // Get the scope from the header container
+      if (groupItem[0].className != 'ngRemoveGroup') {
+        var groupItemScope = angular.element(groupItem).scope();
+        if (groupItemScope) {
+          // set draggable events
+          if (!grid.config.jqueryUIDraggable) {
+            groupItem.attr('draggable', 'true');
+          }
+          // Save the column for later.
+          self.groupToMove = { header: groupItem, groupName: groupItemScope.group, index: groupItemScope.$index };
+        }
+      } else {
+        self.groupToMove = undefined;
+      }
+    };
+    self.onGroupDrop = function(event) {
+      event.stopPropagation();
+      // clear out the colToMove object
+      var groupContainer;
+      var groupScope;
+      if (self.groupToMove) {
+        // Get the closest header to where we dropped
+        groupContainer = $(event.target).closest('.ngGroupElement'); // Get the scope from the header.
+        if (groupContainer.context.className == 'ngGroupPanel') {
+          $scope.configGroups.splice(self.groupToMove.index, 1);
+          $scope.configGroups.push(self.groupToMove.groupName);
+        } else {
+          groupScope = angular.element(groupContainer).scope();
+          if (groupScope) {
+            // If we have the same column, do nothing.
+            if (self.groupToMove.index != groupScope.$index) {
+              // Splice the columns
+              $scope.configGroups.splice(self.groupToMove.index, 1);
+              $scope.configGroups.splice(groupScope.$index, 0, self.groupToMove.groupName);
+            }
+          }
+        }
+        self.groupToMove = undefined;
+        grid.fixGroupIndexes();
+      } else if (self.colToMove) {
+        if ($scope.configGroups.indexOf(self.colToMove.col) == -1) {
+          groupContainer = $(event.target).closest('.ngGroupElement'); // Get the scope from the header.
+          if (groupContainer.context.className == 'ngGroupPanel' || groupContainer.context.className == 'ngGroupPanelDescription') {
+            $scope.groupBy(self.colToMove.col);
+          } else {
+            groupScope = angular.element(groupContainer).scope();
+            if (groupScope) {
+              // Splice the columns
+              $scope.removeGroup(groupScope.$index);
+            }
+          }
+        }
+        self.colToMove = undefined;
+      }
+      if (!$scope.$$phase) {
+        $scope.$apply();
+      }
+    };
+    //Header functions
+    self.onHeaderMouseDown = function(event) {
+      // Get the closest header container from where we clicked.
+      var headerContainer = $(event.target).closest('.ngHeaderSortColumn');
+      // Get the scope from the header container
+      var headerScope = angular.element(headerContainer).scope();
+      if (headerScope) {
+        // Save the column for later.
+        self.colToMove = { header: headerContainer, col: headerScope.col };
+      }
+    };
+    self.onHeaderDrop = function(event) {
+      if (!self.colToMove) {
+        return;
+      }
+      // Get the closest header to where we dropped
+      var headerContainer = $(event.target).closest('.ngHeaderSortColumn');
+      // Get the scope from the header.
+      var headerScope = angular.element(headerContainer).scope();
+      if (headerScope) {
+        // If we have the same column, do nothing.
+        if (self.colToMove.col == headerScope.col) {
+          return;
+        }
+        // Splice the columns
+        $scope.columns.splice(self.colToMove.col.index, 1);
+        $scope.columns.splice(headerScope.col.index, 0, self.colToMove.col);
+        grid.fixColumnIndexes();
+        // Finally, rebuild the CSS styles.
+        domUtilityService.BuildStyles($scope, grid, true);
+        // clear out the colToMove object
+        self.colToMove = undefined;
+      }
+    };
+    // Row functions
+    self.onRowMouseDown = function(event) {
+      // Get the closest row element from where we clicked.
+      var targetRow = $(event.target).closest('.ngRow');
+      // Get the scope from the row element
+      var rowScope = angular.element(targetRow).scope();
+      if (rowScope) {
+        // set draggable events
+        targetRow.attr('draggable', 'true');
+        // Save the row for later.
+        domUtilityService.eventStorage.rowToMove = { targetRow: targetRow, scope: rowScope };
+      }
+    };
+    self.onRowDrop = function(event) {
+      // Get the closest row to where we dropped
+      var targetRow = $(event.target).closest('.ngRow');
+      // Get the scope from the row element.
+      var rowScope = angular.element(targetRow).scope();
+      if (rowScope) {
+        // If we have the same Row, do nothing.
+        var prevRow = domUtilityService.eventStorage.rowToMove;
+        if (prevRow.scope.row == rowScope.row) {
+          return;
+        }
+        // Splice the Rows via the actual datasource
+        var i = grid.sortedData.indexOf(prevRow.scope.row.entity);
+        var j = grid.sortedData.indexOf(rowScope.row.entity);
+        grid.sortedData.splice(i, 1);
+        grid.sortedData.splice(j, 0, prevRow.scope.row.entity);
+        grid.searchProvider.evalFilter();
+        // clear out the rowToMove object
+        domUtilityService.eventStorage.rowToMove = undefined;
+        // if there isn't an apply already in progress lets start one
+      }
+    };
+
+    self.assignGridEventHandlers = function() {
+      grid.$viewport.on('scroll', function(e) {
+        var scrollLeft = e.target.scrollLeft,
+            scrollTop = e.target.scrollTop;
+        grid.adjustScrollLeft(scrollLeft);
+        grid.adjustScrollTop(scrollTop);
+      });
+      var doingKeyDown = false;
+      grid.$viewport.on('keydown', function(e) {
+        if (!doingKeyDown) {
+          doingKeyDown = true;
+          var ret = ng.moveSelectionHandler($scope, grid, e);
+          doingKeyDown = false;
+          return ret;
+        }
+        return false;
+      });
+      //Chrome and firefox both need a tab index so the grid can recieve focus.
+      //need to give the grid a tabindex if it doesn't already have one so
+      //we'll just give it a tab index of the corresponding gridcache index
+      //that way we'll get the same result every time it is run.
+      //configurable within the options.
+      if (grid.config.tabIndex === -1) {
+        grid.$viewport.attr('tabIndex', domUtilityService.numberOfGrids);
+        domUtilityService.numberOfGrids++;
+      } else {
+        grid.$viewport.attr('tabIndex', grid.config.tabIndex);
+      }
+      $(window).resize(function() {
+        domUtilityService.UpdateGridLayout(grid);
+        if (grid.config.maintainColumnRatios) {
+          grid.configureColumnWidths();
+        }
+      });
+    };
+    // In this example we want to assign grid events.
+    self.assignGridEventHandlers();
+    self.assignEvents();
+  };
+
+  /***********************************************
+   * FILE: ..\src\classes\column.js
+   ***********************************************/
+  ng.Column = function(config, $scope, grid, domUtilityService) {
+    var self = this,
+        colDef = config.colDef,
+        delay = 500,
+        clicks = 0,
+        timer = null;
+    self.width = colDef.width;
+    self.groupIndex = 0;
+    self.isGroupedBy = false;
+    self.minWidth = !colDef.minWidth ? 50 : colDef.minWidth;
+    self.maxWidth = !colDef.maxWidth ? 9000 : colDef.maxWidth;
+    self.headerRowHeight = config.headerRowHeight;
+    self.displayName = colDef.displayName || colDef.field;
+    self.index = config.index;
+    self.isAggCol = config.isAggCol;
+    self.cellClass = colDef.cellClass;
+    self.cellFilter = colDef.cellFilter ? colDef.cellFilter : "";
+    self.field = colDef.field;
+    self.aggLabelFilter = colDef.cellFilter || colDef.aggLabelFilter;
+    self.visible = ng.utils.isNullOrUndefined(colDef.visible) || colDef.visible;
+    self.sortable = false;
+    self.resizable = false;
+    self.groupable = ng.utils.isNullOrUndefined(colDef.groupable) || colDef.sortable;
+    if (config.enableSort) {
+      self.sortable = ng.utils.isNullOrUndefined(colDef.sortable) || colDef.sortable;
+    }
+    if (config.enableResize) {
+      self.resizable = ng.utils.isNullOrUndefined(colDef.resizable) || colDef.resizable;
+    }
+    self.sortDirection = undefined;
+    self.sortingAlgorithm = colDef.sortFn;
+    self.headerClass = colDef.headerClass;
+    self.headerCellTemplate = colDef.headerCellTemplate || ng.defaultHeaderCellTemplate();
+    self.cursor = self.sortable ? 'pointer' : 'default';
+    self.cellTemplate = colDef.cellTemplate || ng.defaultCellTemplate().replace(CUSTOM_FILTERS, self.cellFilter ? "|" + self.cellFilter : "");
+    if (colDef.cellTemplate && !TEMPLATE_REGEXP.test(colDef.cellTemplate)) {
+      self.cellTemplate = $.ajax({
+        type: "GET",
+        url: colDef.cellTemplate,
+        async: false
+      }).responseText;
+    }
+    if (colDef.headerCellTemplate && !TEMPLATE_REGEXP.test(colDef.headerCellTemplate)) {
+      self.headerCellTemplate = $.ajax({
+        type: "GET",
+        url: colDef.headerCellTemplate,
+        async: false
+      }).responseText;
+    }
+    self.groupedByClass = function() {
+      return self.isGroupedBy ? "ngGroupedByIcon" : "ngGroupIcon";
+    };
+    self.toggleVisible = function() {
+      self.visible = !self.visible;
+    };
+    self.showSortButtonUp = function() {
+      return self.sortable ? self.sortDirection === DESC : self.sortable;
+    };
+    self.showSortButtonDown = function() {
+      return self.sortable ? self.sortDirection === ASC : self.sortable;
+    };
+    self.noSortVisible = function() {
+      return !self.sortDirection;
+    };
+    self.sort = function() {
+      if (!self.sortable) {
+        return true; // column sorting is disabled, do nothing
+      }
+      var dir = self.sortDirection === ASC ? DESC : ASC;
+      self.sortDirection = dir;
+      config.sortCallback(self);
+      return false;
+    };
+    self.gripClick = function() {
+      clicks++; //count clicks
+      if (clicks === 1) {
+        timer = setTimeout(function() {
+          //Here you can add a single click action.
+          clicks = 0; //after action performed, reset counter
+        }, delay);
+      } else {
+        clearTimeout(timer); //prevent single-click action
+        config.resizeOnDataCallback(self); //perform double-click action
+        clicks = 0; //after action performed, reset counter
+      }
+    };
+    self.gripOnMouseDown = function(event) {
+      if (event.ctrlKey) {
+        self.toggleVisible();
+        domUtilityService.BuildStyles($scope, grid);
+        return true;
+      }
+      event.target.parentElement.style.cursor = 'col-resize';
+      self.startMousePosition = event.clientX;
+      self.origWidth = self.width;
+      $(document).mousemove(self.onMouseMove);
+      $(document).mouseup(self.gripOnMouseUp);
+      return false;
+    };
+    self.onMouseMove = function(event) {
+      var diff = event.clientX - self.startMousePosition;
+      var newWidth = diff + self.origWidth;
+      self.width = (newWidth < self.minWidth ? self.minWidth : (newWidth > self.maxWidth ? self.maxWidth : newWidth));
+      domUtilityService.BuildStyles($scope, grid);
+      return false;
+    };
+    self.gripOnMouseUp = function() {
+      $(document).off('mousemove');
+      $(document).off('mouseup');
+      event.target.parentElement.style.cursor = 'default';
+      domUtilityService.digest($scope);
+      return false;
+    };
+  };
+
+  /***********************************************
+   * FILE: ..\src\classes\dimension.js
+   ***********************************************/
+  ng.Dimension = function(options) {
+    this.outerHeight = null;
+    this.outerWidth = null;
+    $.extend(this, options);
+  };
+
+  /***********************************************
+   * FILE: ..\src\classes\footer.js
+   ***********************************************/
+  ng.Footer = function($scope, grid) {
+    $scope.maxRows = function () {
+      var ret = Math.max($scope.pagingOptions.totalServerItems, grid.sortedData.length);
+      return ret;
+    };
+
+    $scope.multiSelect = (grid.config.canSelectRows && grid.config.multiSelect);
+    $scope.selectedItemCount = grid.selectedItemCount;
+    $scope.maxPages = function () {
+      return Math.ceil($scope.maxRows() / $scope.pagingOptions.pageSize);
+    };
+
+    $scope.pageForward = function() {
+      var page = $scope.pagingOptions.currentPage;
+      $scope.pagingOptions.currentPage = Math.min(page + 1, $scope.maxPages());
+    };
+
+    $scope.pageBackward = function() {
+      var page = $scope.pagingOptions.currentPage;
+      $scope.pagingOptions.currentPage = Math.max(page - 1, 1);
+    };
+
+    $scope.pageToFirst = function() {
+      $scope.pagingOptions.currentPage = 1;
+    };
+
+    $scope.pageToLast = function() {
+      var maxPages = $scope.maxPages();
+      $scope.pagingOptions.currentPage = maxPages;
+    };
+
+    $scope.cantPageForward = function() {
+      var curPage = $scope.pagingOptions.currentPage;
+      var maxPages = $scope.maxPages();
+      return !(curPage < maxPages);
+    };
+
+    $scope.cantPageBackward = function() {
+      var curPage = $scope.pagingOptions.currentPage;
+      return !(curPage > 1);
+    };
+  };
+
+  /***********************************************
+   * FILE: ..\src\classes\rowFactory.js
+   ***********************************************/
+  ng.RowFactory = function(grid, $scope) {
+    var self = this;
+    // we cache rows when they are built, and then blow the cache away when sorting
+    self.rowCache = [];
+    self.aggCache = {};
+    self.parentCache = []; // Used for grouping and is cleared each time groups are calulated.
+    self.dataChanged = true;
+    self.parsedData = [];
+    self.rowConfig = {};
+    self.selectionService = grid.selectionService;
+    self.rowHeight = 30;
+    self.numberOfAggregates = 0;
+    self.groupedData = undefined;
+    self.rowHeight = grid.config.rowHeight;
+    self.rowConfig = {
+      canSelectRows: grid.config.canSelectRows,
+      rowClasses: grid.config.rowClasses,
+      selectedItems: grid.config.selectedItems,
+      selectWithCheckboxOnly: grid.config.selectWithCheckboxOnly,
+      beforeSelectionChangeCallback: grid.config.beforeSelectionChange,
+      afterSelectionChangeCallback: grid.config.afterSelectionChange,
+      jqueryUITheme: grid.config.jqueryUITheme
+    };
+
+    self.renderedRange = new ng.Range(0, grid.minRowsToRender() + EXCESS_ROWS);
+    // Builds rows for each data item in the 'filteredData'
+    // @entity - the data item
+    // @rowIndex - the index of the row
+    self.buildEntityRow = function(entity, rowIndex) {
+      var row = self.rowCache[rowIndex]; // first check to see if we've already built it
+      if (!row) {
+        // build the row
+        row = new ng.Row(entity, self.rowConfig, self.selectionService);
+        row.rowIndex = rowIndex + 1; //not a zero-based rowIndex
+        row.offsetTop = self.rowHeight * rowIndex;
+        row.selected = entity[SELECTED_PROP];
+        // finally cache it for the next round
+        self.rowCache[rowIndex] = row;
+      }
+      return row;
+    };
+
+    self.buildAggregateRow = function(aggEntity, rowIndex) {
+      var agg = self.aggCache[aggEntity.aggIndex]; // first check to see if we've already built it
+      if (!agg) {
+        // build the row
+        agg = new ng.Aggregate(aggEntity, self);
+        self.aggCache[aggEntity.aggIndex] = agg;
+      }
+      agg.index = rowIndex + 1; //not a zero-based rowIndex
+      agg.offsetTop = self.rowHeight * rowIndex;
+      return agg;
+    };
+    self.UpdateViewableRange = function(newRange) {
+      self.renderedRange = newRange;
+      self.renderedChange();
+    };
+    self.filteredDataChanged = function() {
+      // check for latebound autogenerated columns
+      if (grid.lateBoundColumns && grid.filteredData.length > 1) {
+        grid.config.columnDefs = undefined;
+        grid.buildColumns();
+        grid.lateBoundColumns = false;
+      }
+      self.dataChanged = true;
+      self.rowCache = []; //if data source changes, kill this!
+      if (grid.config.groups.length > 0) {
+        self.getGrouping(grid.config.groups);
+      }
+      self.UpdateViewableRange(self.renderedRange);
+    };
+
+    self.renderedChange = function() {
+      if (!self.groupedData || grid.config.groups.length < 1) {
+        self.renderedChangeNoGroups();
+        grid.refreshDomSizes();
+        return;
+      }
+      self.parentCache = [];
+      var rowArr = [];
+      var dataArray = self.parsedData.filter(function(e) {
+        return e[NG_HIDDEN] === false;
+      }).slice(self.renderedRange.topRow, self.renderedRange.bottomRow);
+      angular.forEach(dataArray, function(item, indx) {
+        var row;
+        if (item.isAggRow) {
+          row = self.buildAggregateRow(item, self.renderedRange.topRow + indx);
+        } else {
+          row = self.buildEntityRow(item, self.renderedRange.topRow + indx);
+        }
+        //add the row to our return array
+        rowArr.push(row);
+      });
+      grid.setRenderedRows(rowArr);
+    };
+
+    self.renderedChangeNoGroups = function() {
+      var rowArr = [];
+      var dataArr = grid.filteredData.slice(self.renderedRange.topRow, self.renderedRange.bottomRow);
+      angular.forEach(dataArr, function(item, i) {
+        var row = self.buildEntityRow(item, self.renderedRange.topRow + i);
+        //add the row to our return array
+        rowArr.push(row);
+      });
+      grid.setRenderedRows(rowArr);
+    };
+
+    //magical recursion. it works. I swear it. I figured it out in the shower one day.
+    self.parseGroupData = function(g) {
+      if (g.values) {
+        angular.forEach(g.values, function(item) {
+          // get the last parent in the array because that's where our children want to be
+          self.parentCache[self.parentCache.length - 1].children.push(item);
+          //add the row to our return array
+          self.parsedData.push(item);
+        });
+      } else {
+        for (var prop in g) {
+          // exclude the meta properties.
+          if (prop == NG_FIELD || prop == NG_DEPTH || prop == NG_COLUMN) {
+            continue;
+          } else if (g.hasOwnProperty(prop)) {
+            //build the aggregate row
+            var agg = self.buildAggregateRow({
+              gField: g[NG_FIELD],
+              gLabel: prop,
+              gDepth: g[NG_DEPTH],
+              isAggRow: true,
+              '_ng_hidden_': false,
+              children: [],
+              aggChildren: [],
+              aggIndex: self.numberOfAggregates,
+              aggLabelFilter: g[NG_COLUMN].aggLabelFilter
+            }, 0);
+            self.numberOfAggregates++;
+            //set the aggregate parent to the parent in the array that is one less deep.
+            agg.parent = self.parentCache[agg.depth - 1];
+            // if we have a parent, set the parent to not be collapsed and append the current agg to its children
+            if (agg.parent) {
+              agg.parent.collapsed = false;
+              agg.parent.aggChildren.push(agg);
+            }
+            // add the aggregate row to the parsed data.
+            self.parsedData.push(agg.entity);
+            // the current aggregate now the parent of the current depth
+            self.parentCache[agg.depth] = agg;
+            // dig deeper for more aggregates or children.
+            self.parseGroupData(g[prop]);
+          }
+        }
+      }
+    };
+    //Shuffle the data into their respective groupings.
+    self.getGrouping = function(groups) {
+      self.aggCache = [];
+      self.rowCache = [];
+      self.numberOfAggregates = 0;
+      self.groupedData = {};
+      // Here we set the onmousedown event handler to the header container.
+      var data = grid.filteredData;
+      var maxDepth = groups.length;
+      var cols = $scope.columns;
+
+      angular.forEach(data, function(item) {
+        item[NG_HIDDEN] = true;
+        var ptr = self.groupedData;
+        angular.forEach(groups, function(group, depth) {
+          if (!cols[depth].isAggCol && depth <= maxDepth) {
+            cols.splice(item.gDepth, 0, new ng.Column({
+              colDef: {
+                field: '',
+                width: 25,
+                sortable: false,
+                resizable: false,
+                headerCellTemplate: '<div class="ngAggHeader"></div>'
+              },
+              isAggCol: true,
+              index: item.gDepth,
+              headerRowHeight: grid.config.headerRowHeight
+            }));
+          }
+          var col = cols.filter(function(c) {
+            return c.field == group;
+          })[0];
+          var val = ng.utils.evalProperty(item, group);
+          val = val ? val.toString() : 'null';
+          if (!ptr[val]) {
+            ptr[val] = {};
+          }
+          if (!ptr[NG_FIELD]) {
+            ptr[NG_FIELD] = group;
+          }
+          if (!ptr[NG_DEPTH]) {
+            ptr[NG_DEPTH] = depth;
+          }
+          if (!ptr[NG_COLUMN]) {
+            ptr[NG_COLUMN] = col;
+          }
+          ptr = ptr[val];
+        });
+        if (!ptr.values) {
+          ptr.values = [];
+        }
+        ptr.values.push(item);
+      });
+      grid.fixColumnIndexes();
+      self.parsedData.length = 0;
+      self.parseGroupData(self.groupedData);
+    };
+
+    if (grid.config.groups.length > 0 && grid.filteredData.length > 0) {
+      self.getGrouping(grid.config.groups);
+    }
+  };
+
+  /***********************************************
+   * FILE: ..\src\classes\grid.js
+   ***********************************************/
+  ng.Grid = function($scope, options, sortService, domUtilityService, $filter) {
+    var defaults = {
+          //Callback for when you want to validate something after selection.
+          afterSelectionChange: function() {
+          },
+
+          /* Callback if you want to inspect something before selection,
+           return false if you want to cancel the selection. return true otherwise.
+           If you need to wait for an async call to proceed with selection you can
+           use rowItem.continueSelection(event) method after returning false initially.
+           Note: when shift+ Selecting multiple items in the grid this will only get called
+           once and the rowItem will be an array of items that are queued to be selected. */
+          beforeSelectionChange: function() {
+            return true;
+          },
+
+          //To be able to have selectable rows in grid.
+          canSelectRows: true,
+
+          //definitions of columns as an array [], if not defines columns are auto-generated. See github wiki for more details.
+          columnDefs: undefined,
+
+          //*Data being displayed in the grid. Each item in the array is mapped to a row being displayed.
+          data: [],
+
+          //Row selection check boxes appear as the first column.
+          displaySelectionCheckbox: true,
+
+          //Enable or disable resizing of columns
+          enableColumnResize: true,
+
+          //Enable or disable resizing of columns
+          enableColumnReordering: true,
+
+          //Enables the server-side paging feature
+          enablePaging: false,
+
+          //Enable drag and drop row reordering. Only works in HTML5 compliant browsers.
+          enableRowReordering: true,
+
+          //Enables or disables sorting in grid.
+          enableSorting: true,
+
+          /* filterOptions -
+           filterText: The text bound to the built-in search box.
+           useExternalFilter: Bypass internal filtering if you want to roll your own filtering mechanism but want to use builtin search box.
+           */
+          filterOptions: {
+            filterText: "",
+            useExternalFilter: false
+          },
+
+          //Defining the height of the footer in pixels.
+          footerRowHeight: 55,
+
+          //Show or hide the footer alltogether the footer is enabled by default
+          displayFooter: undefined,
+          footerVisible: true, // depricated
+
+          //Initial fields to group data by. Array of field names, not displayName.
+          groups: [],
+
+          //The height of the header row in pixels.
+          headerRowHeight: 30,
+
+          //Define a header row template for further customization. See github wiki for more details.
+          headerRowTemplate: undefined,
+
+          /*Enables the use of jquery UI reaggable/droppable plugin. requires jqueryUI to work if enabled.
+           Useful if you want drag + drop but your users insist on crappy browsers. */
+          jqueryUIDraggable: false,
+
+          //Enable the use jqueryUIThemes
+          jqueryUITheme: false,
+
+          //Prevent unselections when in single selection mode.
+          keepLastSelected: true,
+
+          /*Maintains the column widths while resizing.
+           Defaults to true when using *'s or undefined widths. Can be ovverriden by setting to false.*/
+          maintainColumnRatios: undefined,
+
+          //Set this to false if you only want one item selected at a time
+          multiSelect: true,
+
+          // pagingOptions -
+
+          pagingOptions: {
+            // pageSizes: list of available page sizes.
+            pageSizes: [250, 500, 1000],
+            //pageSize: currently selected page size.
+            pageSize: 250,
+            //totalServerItems: Total items are on the server.
+            totalServerItems: 0,
+            //currentPage: the uhm... current page.
+            currentPage: 1
+          },
+
+          //Array of plugin functions to register in ng-grid
+          plugins: [],
+
+          //Row height of rows in grid.
+          rowHeight: 30,
+
+          //Define a row Template to customize output. See github wiki for more details.
+          rowTemplate: undefined,
+
+          //all of the items selected in the grid. In single select mode there will only be one item in the array.
+          selectedItems: [],
+
+          //Disable row selections by clicking on the row and only when the checkbox is clicked.
+          selectWithCheckboxOnly: false,
+
+          /*Enables menu to choose which columns to display and group by.
+           If both showColumnMenu and showFilter are false the menu button will not display.*/
+          showColumnMenu: true,
+
+          /*Enables display of the filterbox in the column menu.
+           If both showColumnMenu and showFilter are false the menu button will not display.*/
+          showFilter: true,
+
+          //Show the dropzone for drag and drop grouping
+          showGroupPanel: false,
+
+          /*Define a sortInfo object to specify a default sorting state.
+           You can also observe this variable to utilize server-side sorting (see useExternalSorting).
+           Syntax is sortinfo: { field: 'fieldName', direction: 'ASC'/'asc' || 'desc'/'DESC'}*/
+          sortInfo: undefined,
+
+          //Set the tab index of the Vieport.
+          tabIndex: -1,
+          /*Prevents the internal sorting from executing.
+           The sortInfo object will be updated with the sorting information so you can handle sorting (see sortInfo)*/
+          useExternalSorting: false
+        },
+        self = this;
+
+    self.maxCanvasHt = 0;
+    //self vars
+    self.config = $.extend(defaults, options);
+    if (typeof options.columnDefs == "string") {
+      self.config.columnDefs = $scope.$eval(options.columnDefs);
+    }
+    self.gridId = "ng" + ng.utils.newId();
+    self.$root = null; //this is the root element that is passed in with the binding handler
+    self.$groupPanel = null;
+    self.$topPanel = null;
+    self.$headerContainer = null;
+    self.$headerScroller = null;
+    self.$headers = null;
+    self.$viewport = null;
+    self.$canvas = null;
+    self.rootDim = self.config.gridDim;
+    self.sortInfo = self.config.sortInfo;
+    self.sortedData = [];
+    self.lateBindColumns = false;
+    self.filteredData = [];
+    if (typeof self.config.data == "object") {
+      self.sortedData = self.config.data; // we cannot watch for updates if you don't pass the string name
+    }
+    self.lastSortedColumn = undefined;
+    self.calcMaxCanvasHeight = function() {
+      return (self.config.groups.length > 0) ? (self.rowFactory.parsedData.filter(function(e) {
+        return e[NG_HIDDEN] === false;
+      }).length * self.config.rowHeight) : (self.filteredData.length * self.config.rowHeight);
+    };
+    self.elementDims = {
+      scrollW: 0,
+      scrollH: 0,
+      rowIndexCellW: 25,
+      rowSelectedCellW: 25,
+      rootMaxW: 0,
+      rootMaxH: 0
+    };
+    //self funcs
+    self.setRenderedRows = function(newRows) {
+      $scope.renderedRows = newRows;
+      if (!$scope.$$phase) {
+        $scope.$digest();
+      }
+      self.refreshDomSizes();
+      $scope.$emit('ngGridEventRows', newRows);
+    };
+    self.minRowsToRender = function() {
+      var viewportH = $scope.viewportDimHeight() || 1;
+      return Math.floor(viewportH / self.config.rowHeight);
+    };
+    self.refreshDomSizes = function() {
+      var dim = new ng.Dimension();
+      dim.outerWidth = self.elementDims.rootMaxW;
+      dim.outerHeight = self.elementDims.rootMaxH;
+      self.rootDim = dim;
+      self.maxCanvasHt = self.calcMaxCanvasHeight();
+    };
+    self.buildColumnDefsFromData = function() {
+      if (!self.config.columnDefs) {
+        self.config.columnDefs = [];
+      }
+      if (!self.sortedData || !self.sortedData[0]) {
+        self.lateBoundColumns = true;
+        return;
+      }
+      var item;
+      item = self.sortedData[0];
+
+      ng.utils.forIn(item, function(prop, propName) {
+        if (propName != SELECTED_PROP) {
+          self.config.columnDefs.push({
+            field: propName
+          });
+        }
+      });
+    };
+    self.buildColumns = function() {
+      var columnDefs = self.config.columnDefs,
+          cols = [],
+          indexOffset = 0;
+
+      if (!columnDefs) {
+        self.buildColumnDefsFromData();
+        columnDefs = self.config.columnDefs;
+      }
+      if (self.config.displaySelectionCheckbox) {
+        indexOffset = 1;
+        cols.push(new ng.Column({
+          colDef: {
+            field: '\u2714',
+            width: self.elementDims.rowSelectedCellW,
+            sortable: false,
+            resizable: false,
+            groupable: false,
+            headerCellTemplate: '<input class="ngSelectionHeader" type="checkbox" ng-show="multiSelect" ng-model="allSelected" ng-change="toggleSelectAll(allSelected)"/>',
+            cellTemplate: '<div class="ngSelectionCell"><input class="ngSelectionCheckbox" type="checkbox" ng-checked="row.selected" /></div>'
+          },
+          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);
+      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();
+
+    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) {
+      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;
+      });
+    };
+  };
+
+  /***********************************************
+   * 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']);
+}(window));
-- 
cgit v1.2.3