slickgrid-rails 0.2.0 → 0.3.0

data/.gitignore

@@ -1 +1,3 @@
 pkg/
+tmp/
+Gemfile.lock

data/README.md

@@ -125,6 +125,15 @@ gem):
       @grid.onCellChange.subscribe (e, args) =>
         @model.writeData(args)
 
+## Update SlickGrid
+
+To upgrade SlickGrid version just run
+
+    rake slickgrid:update
+
+It will clone the current SlickGrid master and will copy all javascript and stylesheet files into this repository. 
+Don't forget to update the gemspec version!
+
 ## Contributing
 
 1. Fork it

data/Rakefile

@@ -1,2 +1,35 @@
 #!/usr/bin/env rake
 require "bundler/gem_tasks"
+
+namespace :slickgrid do
+  desc "Update SlickGrid library from current master"
+  task :update => "tmp/SlickGrid" do
+    cd "tmp/SlickGrid" do
+      js_files = Dir.glob("*.js") +
+        Dir.glob("plugins/*.js") +
+        Dir.glob("controls/*.js")
+
+      js_files.each do |file|
+        mkdir_p "../../vendor/assets/javascript/slick/#{File.dirname(file)}"
+        sh "cp #{file} ../../vendor/assets/javascripts/slick/#{file.gsub("slick.", "")}"
+      end
+
+      css_files = Dir.glob("*.css") +
+        Dir.glob("plugins/*.css") +
+        Dir.glob("controls/*.css")
+
+      css_files.each do |file|
+        mkdir_p "../../vendor/assets/stylesheets/slick/#{File.dirname(file)}"
+        sh "cp #{file} ../../vendor/assets/stylesheets/slick/#{file.gsub("slick.", "")}"
+      end
+    end
+  end
+
+  file "tmp/SlickGrid" do
+    mkdir_p "tmp"
+
+    cd "tmp" do
+      sh "git clone https://github.com/mleibman/SlickGrid.git"
+    end
+  end
+end

data/slickgrid-rails.gemspec

@@ -1,9 +1,8 @@
 # -*- encoding: utf-8 -*-
-require File.expand_path('../lib/slickgrid/rails/version', __FILE__)
 
 Gem::Specification.new do |gem|
   gem.name          = "slickgrid-rails"
-  gem.version       = SlickGrid::Rails::VERSION
+  gem.version       = "0.3.0"
   gem.authors       = ["Benedikt Böhm"]
   gem.email         = ["benedikt.boehm@madvertise.com"]
   gem.description   = %q{SlickGrid Integration for Rails 3.x}

data/vendor/assets/javascripts/slick/controls/columnpicker.css

@@ -0,0 +1,31 @@
+.slick-columnpicker {
+  border: 1px solid #718BB7;
+  background: #f0f0f0;
+  padding: 6px;
+  -moz-box-shadow: 2px 2px 2px silver;
+  -webkit-box-shadow: 2px 2px 2px silver;
+  box-shadow: 2px 2px 2px silver;
+  min-width: 100px;
+  cursor: default;
+}
+
+.slick-columnpicker li {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  background: none;
+}
+
+.slick-columnpicker input {
+  margin: 4px;
+}
+
+.slick-columnpicker li a {
+  display: block;
+  padding: 4px;
+  font-weight: bold;
+}
+
+.slick-columnpicker li a:hover {
+  background: white;
+}

data/vendor/assets/javascripts/slick/controls/columnpicker.js

@@ -9,6 +9,7 @@
 
     function init() {
       grid.onHeaderContextMenu.subscribe(handleHeaderContextMenu);
+      grid.onColumnsReordered.subscribe(updateColumnOrder);
       options = $.extend({}, defaults, options);
 
       $menu = $("<span class='slick-columnpicker' style='display:none;position:absolute;z-index:20;' />").appendTo(document.body);
@@ -23,6 +24,7 @@
     function handleHeaderContextMenu(e, args) {
       e.preventDefault();
       $menu.empty();
+      updateColumnOrder();
       columnCheckboxes = [];
 
       var $li, $input;
@@ -68,6 +70,28 @@
           .fadeIn(options.fadeSpeed);
     }
 
+    function updateColumnOrder() {
+      // Because columns can be reordered, we have to update the `columns`
+      // to reflect the new order, however we can't just take `grid.getColumns()`,
+      // as it does not include columns currently hidden by the picker.
+      // We create a new `columns` structure by leaving currently-hidden
+      // columns in their original ordinal position and interleaving the results
+      // of the current column sort.
+      var current = grid.getColumns().slice(0);
+      var ordered = new Array(columns.length);
+      for (var i = 0; i < ordered.length; i++) {
+        if ( grid.getColumnIndex(columns[i].id) === undefined ) {
+          // If the column doesn't return a value from getColumnIndex,
+          // it is hidden. Leave it in this position.
+          ordered[i] = columns[i];
+        } else {
+          // Otherwise, grab the next visible column.
+          ordered[i] = current.shift();
+        }
+      }
+      columns = ordered;
+    }
+
     function updateColumn(e) {
       if ($(e.target).data("option") == "autoresize") {
         if (e.target.checked) {
@@ -105,7 +129,15 @@
       }
     }
 
+    function getAllColumns() {
+      return columns;
+    }
+
     init();
+
+    return {
+      "getAllColumns": getAllColumns
+    };
   }
 
   // Slick.Controls.ColumnPicker

data/vendor/assets/javascripts/slick/controls/pager.css

@@ -0,0 +1,41 @@
+.slick-pager {
+  width: 100%;
+  height: 26px;
+  border: 1px solid gray;
+  border-top: 0;
+  background: url('../images/header-columns-bg.gif') repeat-x center bottom;
+  vertical-align: middle;
+}
+
+.slick-pager .slick-pager-status {
+  display: inline-block;
+  padding: 6px;
+}
+
+.slick-pager .ui-icon-container {
+  display: inline-block;
+  margin: 2px;
+  border-color: gray;
+}
+
+.slick-pager .slick-pager-nav {
+  display: inline-block;
+  float: left;
+  padding: 2px;
+}
+
+.slick-pager .slick-pager-settings {
+  display: block;
+  float: right;
+  padding: 2px;
+}
+
+.slick-pager .slick-pager-settings * {
+  vertical-align: middle;
+}
+
+.slick-pager .slick-pager-settings a {
+  padding: 2px;
+  text-decoration: underline;
+  cursor: pointer;
+}

data/vendor/assets/javascripts/slick/controls/pager.js

@@ -14,18 +14,14 @@
     function getNavState() {
       var cannotLeaveEditMode = !Slick.GlobalEditorLock.commitCurrentEdit();
       var pagingInfo = dataView.getPagingInfo();
-      var lastPage = Math.ceil(pagingInfo.totalRows / pagingInfo.pageSize) - 1;
-      if (lastPage < 0) {
-        lastPage = 0;
-      }
+      var lastPage = pagingInfo.totalPages - 1;
 
       return {
         canGotoFirst: !cannotLeaveEditMode && pagingInfo.pageSize != 0 && pagingInfo.pageNum > 0,
         canGotoLast: !cannotLeaveEditMode && pagingInfo.pageSize != 0 && pagingInfo.pageNum != lastPage,
         canGotoPrev: !cannotLeaveEditMode && pagingInfo.pageSize != 0 && pagingInfo.pageNum > 0,
         canGotoNext: !cannotLeaveEditMode && pagingInfo.pageSize != 0 && pagingInfo.pageNum < lastPage,
-        pagingInfo: pagingInfo,
-        lastPage: lastPage
+        pagingInfo: pagingInfo
       }
     }
 
@@ -45,7 +41,7 @@
     function gotoLast() {
       var state = getNavState();
       if (state.canGotoLast) {
-        dataView.setPagingOptions({pageNum: state.lastPage});
+        dataView.setPagingOptions({pageNum: state.pagingInfo.totalPages - 1});
       }
     }
 
@@ -139,7 +135,7 @@
       if (pagingInfo.pageSize == 0) {
         $status.text("Showing all " + pagingInfo.totalRows + " rows");
       } else {
-        $status.text("Showing page " + (pagingInfo.pageNum + 1) + " of " + (state.lastPage + 1));
+        $status.text("Showing page " + (pagingInfo.pageNum + 1) + " of " + pagingInfo.totalPages);
       }
     }
 

data/vendor/assets/javascripts/slick/core.js

@@ -139,6 +139,8 @@
         handler: handler
       });
       event.subscribe(handler);
+
+      return this;  // allow chaining
     };
 
     this.unsubscribe = function (event, handler) {
@@ -151,6 +153,8 @@
           return;
         }
       }
+
+      return this;  // allow chaining
     };
 
     this.unsubscribeAll = function () {
@@ -159,6 +163,8 @@
         handlers[i].event.unsubscribe(handlers[i].handler);
       }
       handlers = [];
+
+      return this;  // allow chaining
     }
   }
 
@@ -265,7 +271,13 @@
    */
   function Group() {
     this.__group = true;
-    this.__updated = false;
+
+    /**
+     * Grouping level, starting with 0.
+     * @property level
+     * @type {Number}
+     */
+    this.level = 0;
 
     /***
      * Number of rows in the group.
@@ -301,6 +313,28 @@
      * @type {GroupTotals}
      */
     this.totals = null;
+
+    /**
+     * Rows that are part of the group.
+     * @property rows
+     * @type {Array}
+     */
+    this.rows = [];
+
+    /**
+     * Sub-groups that are part of the group.
+     * @property groups
+     * @type {Array}
+     */
+    this.groups = null;
+
+    /**
+     * A unique key used to identify the group.  This key can be used in calls to DataView
+     * collapseGroup() or expandGroup().
+     * @property groupingKey
+     * @type {Object}
+     */
+    this.groupingKey = null;
   }
 
   Group.prototype = new NonDataItem();

data/vendor/assets/javascripts/slick/dataview.js

@@ -50,15 +50,22 @@
     var filterCache = [];
 
     // grouping
-    var groupingGetter;
-    var groupingGetterIsAFn;
-    var groupingFormatter;
-    var groupingComparer;
+    var groupingInfoDefaults = {
+      getter: null,
+      formatter: null,
+      comparer: function(a, b) { return a.value - b.value; },
+      predefinedValues: [],
+      aggregators: [],
+      aggregateEmpty: false,
+      aggregateCollapsed: false,
+      aggregateChildGroups: false,
+      collapsed: false,
+      displayTotalsRow: true
+    };
+    var groupingInfos = [];
     var groups = [];
-    var collapsedGroups = {};
-    var aggregators;
-    var aggregateCollapsed = false;
-    var compiledAccumulators;
+    var toggledGroupsByLevel = [];
+    var groupingDelimiter = ':|:';
 
     var pagesize = 0;
     var pagenum = 0;
@@ -129,11 +136,11 @@
     function setPagingOptions(args) {
       if (args.pageSize != undefined) {
         pagesize = args.pageSize;
-        pagenum = Math.min(pagenum, Math.ceil(totalRows / pagesize));
+        pagenum = pagesize ? Math.min(pagenum, Math.max(0, Math.ceil(totalRows / pagesize) - 1)) : 0;
       }
 
       if (args.pageNum != undefined) {
-        pagenum = Math.min(args.pageNum, Math.ceil(totalRows / pagesize));
+        pagenum = Math.min(args.pageNum, Math.max(0, Math.ceil(totalRows / pagesize) - 1));
       }
 
       onPagingInfoChanged.notify(getPagingInfo(), null, self);
@@ -142,7 +149,8 @@
     }
 
     function getPagingInfo() {
-      return {pageSize: pagesize, pageNum: pagenum, totalRows: totalRows};
+      var totalPages = pagesize ? Math.max(1, Math.ceil(totalRows / pagesize)) : 1;
+      return {pageSize: pagesize, pageNum: pagenum, totalRows: totalRows, totalPages: totalPages};
     }
 
     function sort(comparer, ascending) {
@@ -206,33 +214,65 @@
       refresh();
     }
 
-    function groupBy(valueGetter, valueFormatter, sortComparer) {
+    function getGrouping() {
+      return groupingInfos;
+    }
+
+    function setGrouping(groupingInfo) {
       if (!options.groupItemMetadataProvider) {
         options.groupItemMetadataProvider = new Slick.Data.GroupItemMetadataProvider();
       }
 
-      groupingGetter = valueGetter;
-      groupingGetterIsAFn = typeof groupingGetter === "function";
-      groupingFormatter = valueFormatter;
-      groupingComparer = sortComparer;
-      collapsedGroups = {};
       groups = [];
+      toggledGroupsByLevel = [];
+      groupingInfo = groupingInfo || [];
+      groupingInfos = (groupingInfo instanceof Array) ? groupingInfo : [groupingInfo];
+
+      for (var i = 0; i < groupingInfos.length; i++) {
+        var gi = groupingInfos[i] = $.extend(true, {}, groupingInfoDefaults, groupingInfos[i]);
+        gi.getterIsAFn = typeof gi.getter === "function";
+
+        // pre-compile accumulator loops
+        gi.compiledAccumulators = [];
+        var idx = gi.aggregators.length;
+        while (idx--) {
+          gi.compiledAccumulators[idx] = compileAccumulatorLoop(gi.aggregators[idx]);
+        }
+
+        toggledGroupsByLevel[i] = {};
+      }
+
       refresh();
     }
 
-    function setAggregators(groupAggregators, includeCollapsed) {
-      aggregators = groupAggregators;
-      aggregateCollapsed = (includeCollapsed !== undefined)
-          ? includeCollapsed : aggregateCollapsed;
+    /**
+     * @deprecated Please use {@link setGrouping}.
+     */
+    function groupBy(valueGetter, valueFormatter, sortComparer) {
+      if (valueGetter == null) {
+        setGrouping([]);
+        return;
+      }
 
-      // pre-compile accumulator loops
-      compiledAccumulators = [];
-      var idx = aggregators.length;
-      while (idx--) {
-        compiledAccumulators[idx] = compileAccumulatorLoop(aggregators[idx]);
+      setGrouping({
+        getter: valueGetter,
+        formatter: valueFormatter,
+        comparer: sortComparer
+      });
+    }
+
+    /**
+     * @deprecated Please use {@link setGrouping}.
+     */
+    function setAggregators(groupAggregators, includeCollapsed) {
+      if (!groupingInfos.length) {
+        throw new Error("At least one grouping must be specified before calling setAggregators().");
       }
 
-      refresh();
+      groupingInfos[0].aggregators = groupAggregators;
+      groupingInfos[0].aggregateCollapsed = includeCollapsed;
+
+      setGrouping(groupingInfos);
     }
 
     function getItemByIdx(i) {
@@ -332,7 +372,7 @@
         return null;
       }
 
-      // overrides for group rows
+      // overrides for grouping rows
       if (item.__group) {
         return options.groupItemMetadataProvider.getGroupRowMetadata(item);
       }
@@ -345,37 +385,105 @@
       return null;
     }
 
-    function collapseGroup(groupingValue) {
-      collapsedGroups[groupingValue] = true;
+    function expandCollapseAllGroups(level, collapse) {
+      if (level == null) {
+        for (var i = 0; i < groupingInfos.length; i++) {
+          toggledGroupsByLevel[i] = {};
+          groupingInfos[i].collapsed = collapse;
+        }
+      } else {
+        toggledGroupsByLevel[level] = {};
+        groupingInfos[level].collapsed = collapse;
+      }
       refresh();
     }
 
-    function expandGroup(groupingValue) {
-      delete collapsedGroups[groupingValue];
+    /**
+     * @param level {Number} Optional level to collapse.  If not specified, applies to all levels.
+     */
+    function collapseAllGroups(level) {
+      expandCollapseAllGroups(level, true);
+    }
+
+    /**
+     * @param level {Number} Optional level to expand.  If not specified, applies to all levels.
+     */
+    function expandAllGroups(level) {
+      expandCollapseAllGroups(level, false);
+    }
+
+    function expandCollapseGroup(level, groupingKey, collapse) {
+      toggledGroupsByLevel[level][groupingKey] = groupingInfos[level].collapsed ^ collapse;
       refresh();
     }
 
+    /**
+     * @param varArgs Either a Slick.Group's "groupingKey" property, or a
+     *     variable argument list of grouping values denoting a unique path to the row.  For
+     *     example, calling collapseGroup('high', '10%') will collapse the '10%' subgroup of
+     *     the 'high' setGrouping.
+     */
+    function collapseGroup(varArgs) {
+      var args = Array.prototype.slice.call(arguments);
+      var arg0 = args[0];
+      if (args.length == 1 && arg0.indexOf(groupingDelimiter) != -1) {
+        expandCollapseGroup(arg0.split(groupingDelimiter).length - 1, arg0, true);
+      } else {
+        expandCollapseGroup(args.length - 1, args.join(groupingDelimiter), true);
+      }
+    }
+
+    /**
+     * @param varArgs Either a Slick.Group's "groupingKey" property, or a
+     *     variable argument list of grouping values denoting a unique path to the row.  For
+     *     example, calling expandGroup('high', '10%') will expand the '10%' subgroup of
+     *     the 'high' setGrouping.
+     */
+    function expandGroup(varArgs) {
+      var args = Array.prototype.slice.call(arguments);
+      var arg0 = args[0];
+      if (args.length == 1 && arg0.indexOf(groupingDelimiter) != -1) {
+        expandCollapseGroup(arg0.split(groupingDelimiter).length - 1, arg0, false);
+      } else {
+        expandCollapseGroup(args.length - 1, args.join(groupingDelimiter), false);
+      }
+    }
+
     function getGroups() {
       return groups;
     }
 
-    function extractGroups(rows) {
+    function extractGroups(rows, parentGroup) {
       var group;
       var val;
       var groups = [];
       var groupsByVal = [];
       var r;
+      var level = parentGroup ? parentGroup.level + 1 : 0;
+      var gi = groupingInfos[level];
+
+      for (var i = 0, l = gi.predefinedValues.length; i < l; i++) {
+        val = gi.predefinedValues[i];
+        group = groupsByVal[val];
+        if (!group) {
+          group = new Slick.Group();
+          group.value = val;
+          group.level = level;
+          group.groupingKey = (parentGroup ? parentGroup.groupingKey + groupingDelimiter : '') + val;
+          groups[groups.length] = group;
+          groupsByVal[val] = group;
+        }
+      }
 
       for (var i = 0, l = rows.length; i < l; i++) {
         r = rows[i];
-        val = (groupingGetterIsAFn) ? groupingGetter(r) : r[groupingGetter];
-        val = val || 0;
+        val = gi.getterIsAFn ? gi.getter(r) : r[gi.getter];
         group = groupsByVal[val];
         if (!group) {
           group = new Slick.Group();
-          group.count = 0;
           group.value = val;
-          group.rows = [];
+          group.level = level;
+          group.groupingKey = (parentGroup ? parentGroup.groupingKey + groupingDelimiter : '') + val;
           groups[groups.length] = group;
           groupsByVal[val] = group;
         }
@@ -383,57 +491,96 @@
         group.rows[group.count++] = r;
       }
 
+      if (level < groupingInfos.length - 1) {
+        for (var i = 0; i < groups.length; i++) {
+          group = groups[i];
+          group.groups = extractGroups(group.rows, group);
+        }
+      }      
+
+      groups.sort(groupingInfos[level].comparer);
+
       return groups;
     }
 
     // TODO:  lazy totals calculation
     function calculateGroupTotals(group) {
-      if (group.collapsed && !aggregateCollapsed) {
-        return;
-      }
-
       // TODO:  try moving iterating over groups into compiled accumulator
+      var gi = groupingInfos[group.level];
+      var isLeafLevel = (group.level == groupingInfos.length);
       var totals = new Slick.GroupTotals();
-      var agg, idx = aggregators.length;
+      var agg, idx = gi.aggregators.length;
       while (idx--) {
-        agg = aggregators[idx];
+        agg = gi.aggregators[idx];
         agg.init();
-        compiledAccumulators[idx].call(agg, group.rows);
+        gi.compiledAccumulators[idx].call(agg,
+            (!isLeafLevel && gi.aggregateChildGroups) ? group.groups : group.rows);
         agg.storeResult(totals);
       }
       totals.group = group;
       group.totals = totals;
     }
 
-    function calculateTotals(groups) {
-      var idx = groups.length;
+    function calculateTotals(groups, level) {
+      level = level || 0;
+      var gi = groupingInfos[level];
+      var idx = groups.length, g;
       while (idx--) {
-        calculateGroupTotals(groups[idx]);
+        g = groups[idx];
+
+        if (g.collapsed && !gi.aggregateCollapsed) {
+          continue;
+        }
+
+        // Do a depth-first aggregation so that parent setGrouping aggregators can access subgroup totals.
+        if (g.groups) {
+          calculateTotals(g.groups, level + 1);
+        }
+
+        if (gi.aggregators.length && (
+            gi.aggregateEmpty || g.rows.length || (g.groups && g.groups.length))) {
+          calculateGroupTotals(g);
+        }
       }
     }
 
-    function finalizeGroups(groups) {
+    function finalizeGroups(groups, level) {
+      level = level || 0;
+      var gi = groupingInfos[level];
+      var groupCollapsed = gi.collapsed;
+      var toggledGroups = toggledGroupsByLevel[level];
       var idx = groups.length, g;
       while (idx--) {
         g = groups[idx];
-        g.collapsed = (g.value in collapsedGroups);
-        g.title = groupingFormatter ? groupingFormatter(g) : g.value;
+        g.collapsed = groupCollapsed ^ toggledGroups[g.groupingKey];
+        g.title = gi.formatter ? gi.formatter(g) : g.value;
+
+        if (g.groups) {
+          finalizeGroups(g.groups, level + 1);
+          // Let the non-leaf setGrouping rows get garbage-collected.
+          // They may have been used by aggregates that go over all of the descendants,
+          // but at this point they are no longer needed.
+          g.rows = [];
+        }
       }
     }
 
-    function flattenGroupedRows(groups) {
-      var groupedRows = [], gl = 0, g;
+    function flattenGroupedRows(groups, level) {
+      level = level || 0;
+      var gi = groupingInfos[level];
+      var groupedRows = [], rows, gl = 0, g;
       for (var i = 0, l = groups.length; i < l; i++) {
         g = groups[i];
         groupedRows[gl++] = g;
 
         if (!g.collapsed) {
-          for (var j = 0, jj = g.rows.length; j < jj; j++) {
-            groupedRows[gl++] = g.rows[j];
+          rows = g.groups ? flattenGroupedRows(g.groups, level + 1) : g.rows;
+          for (var j = 0, jj = rows.length; j < jj; j++) {
+            groupedRows[gl++] = rows[j];
           }
         }
 
-        if (g.totals && (!g.collapsed || aggregateCollapsed)) {
+        if (g.totals && gi.displayTotalsRow && (!g.collapsed || gi.aggregateCollapsed)) {
           groupedRows[gl++] = g.totals;
         }
       }
@@ -456,7 +603,7 @@
           "for (var " + accumulatorInfo.params[0] + ", _i=0, _il=_items.length; _i<_il; _i++) {" +
               accumulatorInfo.params[0] + " = _items[_i]; " +
               accumulatorInfo.body +
-              "}"
+          "}"
       );
       fn.displayName = fn.name = "compiledAccumulatorLoop";
       return fn;
@@ -612,11 +759,10 @@
           item = newRows[i];
           r = rows[i];
 
-          if ((groupingGetter && (eitherIsNonData = (item.__nonDataRow) || (r.__nonDataRow)) &&
+          if ((groupingInfos.length && (eitherIsNonData = (item.__nonDataRow) || (r.__nonDataRow)) &&
               item.__group !== r.__group ||
-              item.__updated ||
               item.__group && !item.equals(r))
-              || (aggregators && eitherIsNonData &&
+              || (eitherIsNonData &&
               // no good way to compare totals since they are arbitrary DTOs
               // deep object comparison is pretty expensive
               // always considering them 'dirty' seems easier for the time being
@@ -644,14 +790,11 @@
       var newRows = filteredItems.rows;
 
       groups = [];
-      if (groupingGetter != null) {
+      if (groupingInfos.length) {
         groups = extractGroups(newRows);
         if (groups.length) {
+          calculateTotals(groups);
           finalizeGroups(groups);
-          if (aggregators) {
-            calculateTotals(groups);
-          }
-          groups.sort(groupingComparer);
           newRows = flattenGroupedRows(groups);
         }
       }
@@ -676,7 +819,7 @@
       // if the current page is no longer valid, go to last page and recalc
       // we suffer a performance penalty here, but the main loop (recalc) remains highly optimized
       if (pagesize && totalRows < pagenum * pagesize) {
-        pagenum = Math.floor(totalRows / pagesize);
+        pagenum = Math.max(0, Math.ceil(totalRows / pagesize) - 1);
         diff = recalc(items, filter);
       }
 
@@ -700,12 +843,7 @@
       var selectedRowIds = self.mapRowsToIds(grid.getSelectedRows());;
       var inHandler;
 
-      grid.onSelectedRowsChanged.subscribe(function(e, args) {
-        if (inHandler) { return; }
-        selectedRowIds = self.mapRowsToIds(grid.getSelectedRows());
-      });
-
-      this.onRowsChanged.subscribe(function(e, args) {
+      function update() {
         if (selectedRowIds.length > 0) {
           inHandler = true;
           var selectedRows = self.mapIdsToRows(selectedRowIds);
@@ -715,7 +853,16 @@
           grid.setSelectedRows(selectedRows);
           inHandler = false;
         }
+      }
+
+      grid.onSelectedRowsChanged.subscribe(function(e, args) {
+        if (inHandler) { return; }
+        selectedRowIds = self.mapRowsToIds(grid.getSelectedRows());
       });
+
+      this.onRowsChanged.subscribe(update);
+
+      this.onRowCountChanged.subscribe(update);
     }
 
     function syncGridCellCssStyles(grid, key) {
@@ -734,15 +881,7 @@
         }
       }
 
-      grid.onCellCssStylesChanged.subscribe(function(e, args) {
-        if (inHandler) { return; }
-        if (key != args.key) { return; }
-        if (args.hash) {
-          storeCellCssStyles(args.hash);
-        }
-      });
-
-      this.onRowsChanged.subscribe(function(e, args) {
+      function update() {
         if (hashById) {
           inHandler = true;
           ensureRowsByIdCache();
@@ -756,7 +895,19 @@
           grid.setCellCssStyles(key, newHash);
           inHandler = false;
         }
+      }
+
+      grid.onCellCssStylesChanged.subscribe(function(e, args) {
+        if (inHandler) { return; }
+        if (key != args.key) { return; }
+        if (args.hash) {
+          storeCellCssStyles(args.hash);
+        }
       });
+
+      this.onRowsChanged.subscribe(update);
+
+      this.onRowCountChanged.subscribe(update);
     }
 
     return {
@@ -771,8 +922,12 @@
       "sort": sort,
       "fastSort": fastSort,
       "reSort": reSort,
+      "setGrouping": setGrouping,
+      "getGrouping": getGrouping,
       "groupBy": groupBy,
       "setAggregators": setAggregators,
+      "collapseAllGroups": collapseAllGroups,
+      "expandAllGroups": expandAllGroups,
       "collapseGroup": collapseGroup,
       "expandGroup": expandGroup,
       "getGroups": getGroups,
@@ -816,7 +971,7 @@
     this.accumulate = function (item) {
       var val = item[this.field_];
       this.count_++;
-      if (val != null && val != "" && val != NaN) {
+      if (val != null && val !== "" && val !== NaN) {
         this.nonNullCount_++;
         this.sum_ += parseFloat(val);
       }
@@ -841,7 +996,7 @@
 
     this.accumulate = function (item) {
       var val = item[this.field_];
-      if (val != null && val != "" && val != NaN) {
+      if (val != null && val !== "" && val !== NaN) {
         if (this.min_ == null || val < this.min_) {
           this.min_ = val;
         }
@@ -865,7 +1020,7 @@
 
     this.accumulate = function (item) {
       var val = item[this.field_];
-      if (val != null && val != "" && val != NaN) {
+      if (val != null && val !== "" && val !== NaN) {
         if (this.max_ == null || val > this.max_) {
           this.max_ = val;
         }
@@ -889,7 +1044,7 @@
 
     this.accumulate = function (item) {
       var val = item[this.field_];
-      if (val != null && val != "" && val != NaN) {
+      if (val != null && val !== "" && val !== NaN) {
         this.sum_ += parseFloat(val);
       }
     };
@@ -905,4 +1060,4 @@
   // TODO:  add more built-in aggregators
   // TODO:  merge common aggregators in one to prevent needles iterating
 
-})(jQuery);
+})(jQuery);