2157 lines
55 KiB
JavaScript
2157 lines
55 KiB
JavaScript
/*! Tablesaw - v3.1.2 - 2019-03-19
|
||
* https://github.com/filamentgroup/tablesaw
|
||
* Copyright (c) 2019 Filament Group; Licensed MIT */
|
||
(function (root, factory) {
|
||
if (typeof define === 'function' && define.amd) {
|
||
define(["jquery"], function (jQuery) {
|
||
return (root.Tablesaw = factory(jQuery, root));
|
||
});
|
||
} else if (typeof exports === 'object') {
|
||
if( "document" in root ) {
|
||
module.exports = factory(require('jquery'), root);
|
||
} else {
|
||
// special jQuery case for CommonJS (pass in a window)
|
||
module.exports = factory(require('jquery')(root), root);
|
||
}
|
||
} else {
|
||
root.Tablesaw = factory(jQuery, root);
|
||
}
|
||
}(typeof window !== "undefined" ? window : this, function ($, window) {
|
||
"use strict";
|
||
|
||
var document = window.document;
|
||
|
||
// Account for Tablesaw being loaded either before or after the DOMContentLoaded event is fired.
|
||
var domContentLoadedTriggered = /complete|loaded/.test(document.readyState);
|
||
document.addEventListener("DOMContentLoaded", function() {
|
||
domContentLoadedTriggered = true;
|
||
});
|
||
|
||
var Tablesaw = {
|
||
i18n: {
|
||
modeStack: "Stack",
|
||
modeSwipe: "Swipe",
|
||
modeToggle: "Toggle",
|
||
modeSwitchColumnsAbbreviated: "Cols",
|
||
modeSwitchColumns: "Columns",
|
||
columnToggleButton: "Columns",
|
||
columnToggleError: "No eligible columns.",
|
||
sort: "Sort",
|
||
swipePreviousColumn: "Previous column",
|
||
swipeNextColumn: "Next column"
|
||
},
|
||
// cut the mustard
|
||
mustard:
|
||
"head" in document && // IE9+, Firefox 4+, Safari 5.1+, Mobile Safari 4.1+, Opera 11.5+, Android 2.3+
|
||
(!window.blackberry || window.WebKitPoint) && // only WebKit Blackberry (OS 6+)
|
||
!window.operamini,
|
||
$: $,
|
||
_init: function(element) {
|
||
Tablesaw.$(element || document).trigger("enhance.tablesaw");
|
||
},
|
||
init: function(element) {
|
||
// Account for Tablesaw being loaded either before or after the DOMContentLoaded event is fired.
|
||
domContentLoadedTriggered =
|
||
domContentLoadedTriggered || /complete|loaded/.test(document.readyState);
|
||
if (!domContentLoadedTriggered) {
|
||
if ("addEventListener" in document) {
|
||
// Use raw DOMContentLoaded instead of shoestring (may have issues in Android 2.3, exhibited by stack table)
|
||
document.addEventListener("DOMContentLoaded", function() {
|
||
Tablesaw._init(element);
|
||
});
|
||
}
|
||
} else {
|
||
Tablesaw._init(element);
|
||
}
|
||
}
|
||
};
|
||
|
||
$(document).on("enhance.tablesaw", function() {
|
||
// Extend i18n config, if one exists.
|
||
if (typeof TablesawConfig !== "undefined" && TablesawConfig.i18n) {
|
||
Tablesaw.i18n = $.extend(Tablesaw.i18n, TablesawConfig.i18n || {});
|
||
}
|
||
|
||
Tablesaw.i18n.modes = [
|
||
Tablesaw.i18n.modeStack,
|
||
Tablesaw.i18n.modeSwipe,
|
||
Tablesaw.i18n.modeToggle
|
||
];
|
||
});
|
||
|
||
if (Tablesaw.mustard) {
|
||
$(document.documentElement).addClass("tablesaw-enhanced");
|
||
}
|
||
|
||
(function() {
|
||
var pluginName = "tablesaw";
|
||
var classes = {
|
||
toolbar: "tablesaw-bar"
|
||
};
|
||
var events = {
|
||
create: "tablesawcreate",
|
||
destroy: "tablesawdestroy",
|
||
refresh: "tablesawrefresh",
|
||
resize: "tablesawresize"
|
||
};
|
||
var defaultMode = "stack";
|
||
var initSelector = "table";
|
||
var initFilterSelector = "[data-tablesaw],[data-tablesaw-mode],[data-tablesaw-sortable]";
|
||
var defaultConfig = {};
|
||
|
||
Tablesaw.events = events;
|
||
|
||
var Table = function(element) {
|
||
if (!element) {
|
||
throw new Error("Tablesaw requires an element.");
|
||
}
|
||
|
||
this.table = element;
|
||
this.$table = $(element);
|
||
|
||
// only one <thead> and <tfoot> are allowed, per the specification
|
||
this.$thead = this.$table
|
||
.children()
|
||
.filter("thead")
|
||
.eq(0);
|
||
|
||
// multiple <tbody> are allowed, per the specification
|
||
this.$tbody = this.$table.children().filter("tbody");
|
||
|
||
this.mode = this.$table.attr("data-tablesaw-mode") || defaultMode;
|
||
|
||
this.$toolbar = null;
|
||
|
||
this.attributes = {
|
||
subrow: "data-tablesaw-subrow",
|
||
ignorerow: "data-tablesaw-ignorerow"
|
||
};
|
||
|
||
this.init();
|
||
};
|
||
|
||
Table.prototype.init = function() {
|
||
if (!this.$thead.length) {
|
||
throw new Error("tablesaw: a <thead> is required, but none was found.");
|
||
}
|
||
|
||
if (!this.$thead.find("th").length) {
|
||
throw new Error("tablesaw: no header cells found. Are you using <th> inside of <thead>?");
|
||
}
|
||
|
||
// assign an id if there is none
|
||
if (!this.$table.attr("id")) {
|
||
this.$table.attr("id", pluginName + "-" + Math.round(Math.random() * 10000));
|
||
}
|
||
|
||
this.createToolbar();
|
||
|
||
this._initCells();
|
||
|
||
this.$table.data(pluginName, this);
|
||
|
||
this.$table.trigger(events.create, [this]);
|
||
};
|
||
|
||
Table.prototype.getConfig = function(pluginSpecificConfig) {
|
||
// shoestring extend doesn’t support arbitrary args
|
||
var configs = $.extend(defaultConfig, pluginSpecificConfig || {});
|
||
return $.extend(configs, typeof TablesawConfig !== "undefined" ? TablesawConfig : {});
|
||
};
|
||
|
||
Table.prototype._getPrimaryHeaderRow = function() {
|
||
return this._getHeaderRows().eq(0);
|
||
};
|
||
|
||
Table.prototype._getHeaderRows = function() {
|
||
return this.$thead
|
||
.children()
|
||
.filter("tr")
|
||
.filter(function() {
|
||
return !$(this).is("[data-tablesaw-ignorerow]");
|
||
});
|
||
};
|
||
|
||
Table.prototype._getRowIndex = function($row) {
|
||
return $row.prevAll().length;
|
||
};
|
||
|
||
Table.prototype._getHeaderRowIndeces = function() {
|
||
var self = this;
|
||
var indeces = [];
|
||
this._getHeaderRows().each(function() {
|
||
indeces.push(self._getRowIndex($(this)));
|
||
});
|
||
return indeces;
|
||
};
|
||
|
||
Table.prototype._getPrimaryHeaderCells = function($row) {
|
||
return ($row || this._getPrimaryHeaderRow()).find("th");
|
||
};
|
||
|
||
Table.prototype._$getCells = function(th) {
|
||
var self = this;
|
||
return $(th)
|
||
.add(th.cells)
|
||
.filter(function() {
|
||
var $t = $(this);
|
||
var $row = $t.parent();
|
||
var hasColspan = $t.is("[colspan]");
|
||
// no subrows or ignored rows (keep cells in ignored rows that do not have a colspan)
|
||
return (
|
||
!$row.is("[" + self.attributes.subrow + "]") &&
|
||
(!$row.is("[" + self.attributes.ignorerow + "]") || !hasColspan)
|
||
);
|
||
});
|
||
};
|
||
|
||
Table.prototype._getVisibleColspan = function() {
|
||
var colspan = 0;
|
||
this._getPrimaryHeaderCells().each(function() {
|
||
var $t = $(this);
|
||
if ($t.css("display") !== "none") {
|
||
colspan += parseInt($t.attr("colspan"), 10) || 1;
|
||
}
|
||
});
|
||
return colspan;
|
||
};
|
||
|
||
Table.prototype.getColspanForCell = function($cell) {
|
||
var visibleColspan = this._getVisibleColspan();
|
||
var visibleSiblingColumns = 0;
|
||
if ($cell.closest("tr").data("tablesaw-rowspanned")) {
|
||
visibleSiblingColumns++;
|
||
}
|
||
|
||
$cell.siblings().each(function() {
|
||
var $t = $(this);
|
||
var colColspan = parseInt($t.attr("colspan"), 10) || 1;
|
||
|
||
if ($t.css("display") !== "none") {
|
||
visibleSiblingColumns += colColspan;
|
||
}
|
||
});
|
||
// console.log( $cell[ 0 ], visibleColspan, visibleSiblingColumns );
|
||
|
||
return visibleColspan - visibleSiblingColumns;
|
||
};
|
||
|
||
Table.prototype.isCellInColumn = function(header, cell) {
|
||
return $(header)
|
||
.add(header.cells)
|
||
.filter(function() {
|
||
return this === cell;
|
||
}).length;
|
||
};
|
||
|
||
Table.prototype.updateColspanCells = function(cls, header, userAction) {
|
||
var self = this;
|
||
var primaryHeaderRow = self._getPrimaryHeaderRow();
|
||
|
||
// find persistent column rowspans
|
||
this.$table.find("[rowspan][data-tablesaw-priority]").each(function() {
|
||
var $t = $(this);
|
||
if ($t.attr("data-tablesaw-priority") !== "persist") {
|
||
return;
|
||
}
|
||
|
||
var $row = $t.closest("tr");
|
||
var rowspan = parseInt($t.attr("rowspan"), 10);
|
||
if (rowspan > 1) {
|
||
$row = $row.next();
|
||
|
||
$row.data("tablesaw-rowspanned", true);
|
||
|
||
rowspan--;
|
||
}
|
||
});
|
||
|
||
this.$table
|
||
.find("[colspan],[data-tablesaw-maxcolspan]")
|
||
.filter(function() {
|
||
// is not in primary header row
|
||
return $(this).closest("tr")[0] !== primaryHeaderRow[0];
|
||
})
|
||
.each(function() {
|
||
var $cell = $(this);
|
||
|
||
if (userAction === undefined || self.isCellInColumn(header, this)) {
|
||
} else {
|
||
// if is not a user action AND the cell is not in the updating column, kill it
|
||
return;
|
||
}
|
||
|
||
var colspan = self.getColspanForCell($cell);
|
||
|
||
if (cls && userAction !== undefined) {
|
||
// console.log( colspan === 0 ? "addClass" : "removeClass", $cell );
|
||
$cell[colspan === 0 ? "addClass" : "removeClass"](cls);
|
||
}
|
||
|
||
// cache original colspan
|
||
var maxColspan = parseInt($cell.attr("data-tablesaw-maxcolspan"), 10);
|
||
if (!maxColspan) {
|
||
$cell.attr("data-tablesaw-maxcolspan", $cell.attr("colspan"));
|
||
} else if (colspan > maxColspan) {
|
||
colspan = maxColspan;
|
||
}
|
||
|
||
// console.log( this, "setting colspan to ", colspan );
|
||
$cell.attr("colspan", colspan);
|
||
});
|
||
};
|
||
|
||
Table.prototype._findPrimaryHeadersForCell = function(cell) {
|
||
var $headerRow = this._getPrimaryHeaderRow();
|
||
var headerRowIndex = this._getRowIndex($headerRow);
|
||
var results = [];
|
||
|
||
for (var rowNumber = 0; rowNumber < this.headerMapping.length; rowNumber++) {
|
||
if (rowNumber === headerRowIndex) {
|
||
continue;
|
||
}
|
||
|
||
for (var colNumber = 0; colNumber < this.headerMapping[rowNumber].length; colNumber++) {
|
||
if (this.headerMapping[rowNumber][colNumber] === cell) {
|
||
results.push(this.headerMapping[headerRowIndex][colNumber]);
|
||
}
|
||
}
|
||
}
|
||
|
||
return results;
|
||
};
|
||
|
||
// used by init cells
|
||
Table.prototype.getRows = function() {
|
||
var self = this;
|
||
return this.$table.find("tr").filter(function() {
|
||
return $(this)
|
||
.closest("table")
|
||
.is(self.$table);
|
||
});
|
||
};
|
||
|
||
// used by sortable
|
||
Table.prototype.getBodyRows = function(tbody) {
|
||
return (tbody ? $(tbody) : this.$tbody).children().filter("tr");
|
||
};
|
||
|
||
Table.prototype.getHeaderCellIndex = function(cell) {
|
||
var lookup = this.headerMapping[0];
|
||
for (var colIndex = 0; colIndex < lookup.length; colIndex++) {
|
||
if (lookup[colIndex] === cell) {
|
||
return colIndex;
|
||
}
|
||
}
|
||
|
||
return -1;
|
||
};
|
||
|
||
Table.prototype._initCells = function() {
|
||
// re-establish original colspans
|
||
this.$table.find("[data-tablesaw-maxcolspan]").each(function() {
|
||
var $t = $(this);
|
||
$t.attr("colspan", $t.attr("data-tablesaw-maxcolspan"));
|
||
});
|
||
|
||
var $rows = this.getRows();
|
||
var columnLookup = [];
|
||
|
||
$rows.each(function(rowNumber) {
|
||
columnLookup[rowNumber] = [];
|
||
});
|
||
|
||
$rows.each(function(rowNumber) {
|
||
var coltally = 0;
|
||
var $t = $(this);
|
||
var children = $t.children();
|
||
|
||
children.each(function() {
|
||
var colspan = parseInt(
|
||
this.getAttribute("data-tablesaw-maxcolspan") || this.getAttribute("colspan"),
|
||
10
|
||
);
|
||
var rowspan = parseInt(this.getAttribute("rowspan"), 10);
|
||
|
||
// set in a previous rowspan
|
||
while (columnLookup[rowNumber][coltally]) {
|
||
coltally++;
|
||
}
|
||
|
||
columnLookup[rowNumber][coltally] = this;
|
||
|
||
// TODO? both colspan and rowspan
|
||
if (colspan) {
|
||
for (var k = 0; k < colspan - 1; k++) {
|
||
coltally++;
|
||
columnLookup[rowNumber][coltally] = this;
|
||
}
|
||
}
|
||
if (rowspan) {
|
||
for (var j = 1; j < rowspan; j++) {
|
||
columnLookup[rowNumber + j][coltally] = this;
|
||
}
|
||
}
|
||
|
||
coltally++;
|
||
});
|
||
});
|
||
|
||
var headerRowIndeces = this._getHeaderRowIndeces();
|
||
for (var colNumber = 0; colNumber < columnLookup[0].length; colNumber++) {
|
||
for (var headerIndex = 0, k = headerRowIndeces.length; headerIndex < k; headerIndex++) {
|
||
var headerCol = columnLookup[headerRowIndeces[headerIndex]][colNumber];
|
||
|
||
var rowNumber = headerRowIndeces[headerIndex];
|
||
var rowCell;
|
||
|
||
if (!headerCol.cells) {
|
||
headerCol.cells = [];
|
||
}
|
||
|
||
while (rowNumber < columnLookup.length) {
|
||
rowCell = columnLookup[rowNumber][colNumber];
|
||
|
||
if (headerCol !== rowCell) {
|
||
headerCol.cells.push(rowCell);
|
||
}
|
||
|
||
rowNumber++;
|
||
}
|
||
}
|
||
}
|
||
|
||
this.headerMapping = columnLookup;
|
||
};
|
||
|
||
Table.prototype.refresh = function() {
|
||
this._initCells();
|
||
|
||
this.$table.trigger(events.refresh, [this]);
|
||
};
|
||
|
||
Table.prototype._getToolbarAnchor = function() {
|
||
var $parent = this.$table.parent();
|
||
if ($parent.is(".tablesaw-overflow")) {
|
||
return $parent;
|
||
}
|
||
return this.$table;
|
||
};
|
||
|
||
Table.prototype._getToolbar = function($anchor) {
|
||
if (!$anchor) {
|
||
$anchor = this._getToolbarAnchor();
|
||
}
|
||
return $anchor.prev().filter("." + classes.toolbar);
|
||
};
|
||
|
||
Table.prototype.createToolbar = function() {
|
||
// Insert the toolbar
|
||
// TODO move this into a separate component
|
||
var $anchor = this._getToolbarAnchor();
|
||
var $toolbar = this._getToolbar($anchor);
|
||
if (!$toolbar.length) {
|
||
$toolbar = $("<div>")
|
||
.addClass(classes.toolbar)
|
||
.insertBefore($anchor);
|
||
}
|
||
this.$toolbar = $toolbar;
|
||
|
||
if (this.mode) {
|
||
this.$toolbar.addClass("tablesaw-mode-" + this.mode);
|
||
}
|
||
};
|
||
|
||
Table.prototype.destroy = function() {
|
||
// Don’t remove the toolbar, just erase the classes on it.
|
||
// Some of the table features are not yet destroy-friendly.
|
||
this._getToolbar().each(function() {
|
||
this.className = this.className.replace(/\btablesaw-mode\-\w*\b/gi, "");
|
||
});
|
||
|
||
var tableId = this.$table.attr("id");
|
||
$(document).off("." + tableId);
|
||
$(window).off("." + tableId);
|
||
|
||
// other plugins
|
||
this.$table.trigger(events.destroy, [this]);
|
||
|
||
this.$table.removeData(pluginName);
|
||
};
|
||
|
||
// Collection method.
|
||
$.fn[pluginName] = function() {
|
||
return this.each(function() {
|
||
var $t = $(this);
|
||
|
||
if ($t.data(pluginName)) {
|
||
return;
|
||
}
|
||
|
||
new Table(this);
|
||
});
|
||
};
|
||
|
||
var $doc = $(document);
|
||
$doc.on("enhance.tablesaw", function(e) {
|
||
// Cut the mustard
|
||
if (Tablesaw.mustard) {
|
||
var $target = $(e.target);
|
||
if ($target.parent().length) {
|
||
$target = $target.parent();
|
||
}
|
||
|
||
$target
|
||
.find(initSelector)
|
||
.filter(initFilterSelector)
|
||
[pluginName]();
|
||
}
|
||
});
|
||
|
||
// Avoid a resize during scroll:
|
||
// Some Mobile devices trigger a resize during scroll (sometimes when
|
||
// doing elastic stretch at the end of the document or from the
|
||
// location bar hide)
|
||
var isScrolling = false;
|
||
var scrollTimeout;
|
||
$doc.on("scroll.tablesaw", function() {
|
||
isScrolling = true;
|
||
|
||
window.clearTimeout(scrollTimeout);
|
||
scrollTimeout = window.setTimeout(function() {
|
||
isScrolling = false;
|
||
}, 300); // must be greater than the resize timeout below
|
||
});
|
||
|
||
var resizeTimeout;
|
||
$(window).on("resize", function() {
|
||
if (!isScrolling) {
|
||
window.clearTimeout(resizeTimeout);
|
||
resizeTimeout = window.setTimeout(function() {
|
||
$doc.trigger(events.resize);
|
||
}, 150); // must be less than the scrolling timeout above.
|
||
}
|
||
});
|
||
|
||
Tablesaw.Table = Table;
|
||
})();
|
||
|
||
(function() {
|
||
var classes = {
|
||
stackTable: "tablesaw-stack",
|
||
cellLabels: "tablesaw-cell-label",
|
||
cellContentLabels: "tablesaw-cell-content"
|
||
};
|
||
|
||
var data = {
|
||
key: "tablesaw-stack"
|
||
};
|
||
|
||
var attrs = {
|
||
labelless: "data-tablesaw-no-labels",
|
||
hideempty: "data-tablesaw-hide-empty"
|
||
};
|
||
|
||
var Stack = function(element, tablesaw) {
|
||
this.tablesaw = tablesaw;
|
||
this.$table = $(element);
|
||
|
||
this.labelless = this.$table.is("[" + attrs.labelless + "]");
|
||
this.hideempty = this.$table.is("[" + attrs.hideempty + "]");
|
||
|
||
this.$table.data(data.key, this);
|
||
};
|
||
|
||
Stack.prototype.init = function() {
|
||
this.$table.addClass(classes.stackTable);
|
||
|
||
if (this.labelless) {
|
||
return;
|
||
}
|
||
|
||
var self = this;
|
||
|
||
this.$table
|
||
.find("th, td")
|
||
.filter(function() {
|
||
return !$(this).closest("thead").length;
|
||
})
|
||
.filter(function() {
|
||
return (
|
||
!$(this).is("[" + attrs.labelless + "]") &&
|
||
!$(this)
|
||
.closest("tr")
|
||
.is("[" + attrs.labelless + "]") &&
|
||
(!self.hideempty || !!$(this).html())
|
||
);
|
||
})
|
||
.each(function() {
|
||
var $newHeader = $(document.createElement("b")).addClass(classes.cellLabels);
|
||
var $cell = $(this);
|
||
|
||
$(self.tablesaw._findPrimaryHeadersForCell(this)).each(function(index) {
|
||
var $header = $(this.cloneNode(true));
|
||
// TODO decouple from sortable better
|
||
// Changed from .text() in https://github.com/filamentgroup/tablesaw/commit/b9c12a8f893ec192830ec3ba2d75f062642f935b
|
||
// to preserve structural html in headers, like <a>
|
||
var $sortableButton = $header.find(".tablesaw-sortable-btn");
|
||
$header.find(".tablesaw-sortable-arrow").remove();
|
||
|
||
// TODO decouple from checkall better
|
||
var $checkall = $header.find("[data-tablesaw-checkall]");
|
||
$checkall.closest("label").remove();
|
||
if ($checkall.length) {
|
||
$newHeader = $([]);
|
||
return;
|
||
}
|
||
|
||
if (index > 0) {
|
||
$newHeader.append(document.createTextNode(", "));
|
||
}
|
||
|
||
var parentNode = $sortableButton.length ? $sortableButton[0] : $header[0];
|
||
var el;
|
||
while ((el = parentNode.firstChild)) {
|
||
$newHeader[0].appendChild(el);
|
||
}
|
||
});
|
||
|
||
if ($newHeader.length && !$cell.find("." + classes.cellContentLabels).length) {
|
||
$cell.wrapInner("<span class='" + classes.cellContentLabels + "'></span>");
|
||
}
|
||
|
||
// Update if already exists.
|
||
var $label = $cell.find("." + classes.cellLabels);
|
||
if (!$label.length) {
|
||
$cell.prepend(document.createTextNode(" "));
|
||
$cell.prepend($newHeader);
|
||
} else {
|
||
// only if changed
|
||
$label.replaceWith($newHeader);
|
||
}
|
||
});
|
||
};
|
||
|
||
Stack.prototype.destroy = function() {
|
||
this.$table.removeClass(classes.stackTable);
|
||
this.$table.find("." + classes.cellLabels).remove();
|
||
this.$table.find("." + classes.cellContentLabels).each(function() {
|
||
$(this).replaceWith($(this.childNodes));
|
||
});
|
||
};
|
||
|
||
// on tablecreate, init
|
||
$(document)
|
||
.on(Tablesaw.events.create, function(e, tablesaw) {
|
||
if (tablesaw.mode === "stack") {
|
||
var table = new Stack(tablesaw.table, tablesaw);
|
||
table.init();
|
||
}
|
||
})
|
||
.on(Tablesaw.events.refresh, function(e, tablesaw) {
|
||
if (tablesaw.mode === "stack") {
|
||
$(tablesaw.table)
|
||
.data(data.key)
|
||
.init();
|
||
}
|
||
})
|
||
.on(Tablesaw.events.destroy, function(e, tablesaw) {
|
||
if (tablesaw.mode === "stack") {
|
||
$(tablesaw.table)
|
||
.data(data.key)
|
||
.destroy();
|
||
}
|
||
});
|
||
|
||
Tablesaw.Stack = Stack;
|
||
})();
|
||
|
||
(function() {
|
||
var pluginName = "tablesawbtn",
|
||
methods = {
|
||
_create: function() {
|
||
return $(this).each(function() {
|
||
$(this)
|
||
.trigger("beforecreate." + pluginName)
|
||
[pluginName]("_init")
|
||
.trigger("create." + pluginName);
|
||
});
|
||
},
|
||
_init: function() {
|
||
var oEl = $(this),
|
||
sel = this.getElementsByTagName("select")[0];
|
||
|
||
if (sel) {
|
||
// TODO next major version: remove .btn-select
|
||
$(this)
|
||
.addClass("btn-select tablesaw-btn-select")
|
||
[pluginName]("_select", sel);
|
||
}
|
||
return oEl;
|
||
},
|
||
_select: function(sel) {
|
||
var update = function(oEl, sel) {
|
||
var opts = $(sel).find("option");
|
||
var label = document.createElement("span");
|
||
var el;
|
||
var children;
|
||
var found = false;
|
||
|
||
label.setAttribute("aria-hidden", "true");
|
||
label.innerHTML = " ";
|
||
|
||
opts.each(function() {
|
||
var opt = this;
|
||
if (opt.selected) {
|
||
label.innerHTML = opt.text;
|
||
}
|
||
});
|
||
|
||
children = oEl.childNodes;
|
||
if (opts.length > 0) {
|
||
for (var i = 0, l = children.length; i < l; i++) {
|
||
el = children[i];
|
||
|
||
if (el && el.nodeName.toUpperCase() === "SPAN") {
|
||
oEl.replaceChild(label, el);
|
||
found = true;
|
||
}
|
||
}
|
||
|
||
if (!found) {
|
||
oEl.insertBefore(label, oEl.firstChild);
|
||
}
|
||
}
|
||
};
|
||
|
||
update(this, sel);
|
||
// todo should this be tablesawrefresh?
|
||
$(this).on("change refresh", function() {
|
||
update(this, sel);
|
||
});
|
||
}
|
||
};
|
||
|
||
// Collection method.
|
||
$.fn[pluginName] = function(arrg, a, b, c) {
|
||
return this.each(function() {
|
||
// if it's a method
|
||
if (arrg && typeof arrg === "string") {
|
||
return $.fn[pluginName].prototype[arrg].call(this, a, b, c);
|
||
}
|
||
|
||
// don't re-init
|
||
if ($(this).data(pluginName + "active")) {
|
||
return $(this);
|
||
}
|
||
|
||
$(this).data(pluginName + "active", true);
|
||
|
||
$.fn[pluginName].prototype._create.call(this);
|
||
});
|
||
};
|
||
|
||
// add methods
|
||
$.extend($.fn[pluginName].prototype, methods);
|
||
|
||
// TODO OOP this and add to Tablesaw object
|
||
})();
|
||
|
||
(function() {
|
||
var data = {
|
||
key: "tablesaw-coltoggle"
|
||
};
|
||
|
||
var ColumnToggle = function(element) {
|
||
this.$table = $(element);
|
||
|
||
if (!this.$table.length) {
|
||
return;
|
||
}
|
||
|
||
this.tablesaw = this.$table.data("tablesaw");
|
||
|
||
this.attributes = {
|
||
btnTarget: "data-tablesaw-columntoggle-btn-target",
|
||
set: "data-tablesaw-columntoggle-set"
|
||
};
|
||
|
||
this.classes = {
|
||
columnToggleTable: "tablesaw-columntoggle",
|
||
columnBtnContain: "tablesaw-columntoggle-btnwrap tablesaw-advance",
|
||
columnBtn: "tablesaw-columntoggle-btn tablesaw-nav-btn down",
|
||
popup: "tablesaw-columntoggle-popup",
|
||
priorityPrefix: "tablesaw-priority-"
|
||
};
|
||
|
||
this.set = [];
|
||
this.$headers = this.tablesaw._getPrimaryHeaderCells();
|
||
|
||
this.$table.data(data.key, this);
|
||
};
|
||
|
||
// Column Toggle Sets (one column chooser can control multiple tables)
|
||
ColumnToggle.prototype.initSet = function() {
|
||
var set = this.$table.attr(this.attributes.set);
|
||
if (set) {
|
||
// Should not include the current table
|
||
var table = this.$table[0];
|
||
this.set = $("table[" + this.attributes.set + "='" + set + "']")
|
||
.filter(function() {
|
||
return this !== table;
|
||
})
|
||
.get();
|
||
}
|
||
};
|
||
|
||
ColumnToggle.prototype.init = function() {
|
||
if (!this.$table.length) {
|
||
return;
|
||
}
|
||
|
||
var tableId,
|
||
id,
|
||
$menuButton,
|
||
$popup,
|
||
$menu,
|
||
$btnContain,
|
||
self = this;
|
||
|
||
var cfg = this.tablesaw.getConfig({
|
||
getColumnToggleLabelTemplate: function(text) {
|
||
return "<label><input type='checkbox' checked>" + text + "</label>";
|
||
}
|
||
});
|
||
|
||
this.$table.addClass(this.classes.columnToggleTable);
|
||
|
||
tableId = this.$table.attr("id");
|
||
id = tableId + "-popup";
|
||
$btnContain = $("<div class='" + this.classes.columnBtnContain + "'></div>");
|
||
// TODO next major version: remove .btn
|
||
$menuButton = $(
|
||
"<a href='#" +
|
||
id +
|
||
"' class='btn tablesaw-btn btn-micro " +
|
||
this.classes.columnBtn +
|
||
"' data-popup-link>" +
|
||
"<span>" +
|
||
Tablesaw.i18n.columnToggleButton +
|
||
"</span></a>"
|
||
);
|
||
$popup = $("<div class='" + this.classes.popup + "' id='" + id + "'></div>");
|
||
$menu = $("<div class='tablesaw-btn-group'></div>");
|
||
|
||
this.$popup = $popup;
|
||
|
||
var hasNonPersistentHeaders = false;
|
||
this.$headers.each(function() {
|
||
var $this = $(this),
|
||
priority = $this.attr("data-tablesaw-priority"),
|
||
$cells = self.tablesaw._$getCells(this);
|
||
|
||
if (priority && priority !== "persist") {
|
||
$cells.addClass(self.classes.priorityPrefix + priority);
|
||
|
||
$(cfg.getColumnToggleLabelTemplate($this.text()))
|
||
.appendTo($menu)
|
||
.find('input[type="checkbox"]')
|
||
.data("tablesaw-header", this);
|
||
|
||
hasNonPersistentHeaders = true;
|
||
}
|
||
});
|
||
|
||
if (!hasNonPersistentHeaders) {
|
||
$menu.append("<label>" + Tablesaw.i18n.columnToggleError + "</label>");
|
||
}
|
||
|
||
$menu.appendTo($popup);
|
||
|
||
function onToggleCheckboxChange(checkbox) {
|
||
var checked = checkbox.checked;
|
||
|
||
var header = self.getHeaderFromCheckbox(checkbox);
|
||
var $cells = self.tablesaw._$getCells(header);
|
||
|
||
$cells[!checked ? "addClass" : "removeClass"]("tablesaw-toggle-cellhidden");
|
||
$cells[checked ? "addClass" : "removeClass"]("tablesaw-toggle-cellvisible");
|
||
|
||
self.updateColspanCells(header, checked);
|
||
|
||
self.$table.trigger("tablesawcolumns");
|
||
}
|
||
|
||
// bind change event listeners to inputs - TODO: move to a private method?
|
||
$menu.find('input[type="checkbox"]').on("change", function(e) {
|
||
onToggleCheckboxChange(e.target);
|
||
|
||
if (self.set.length) {
|
||
var index;
|
||
$(self.$popup)
|
||
.find("input[type='checkbox']")
|
||
.each(function(j) {
|
||
if (this === e.target) {
|
||
index = j;
|
||
return false;
|
||
}
|
||
});
|
||
|
||
$(self.set).each(function() {
|
||
var checkbox = $(this)
|
||
.data(data.key)
|
||
.$popup.find("input[type='checkbox']")
|
||
.get(index);
|
||
if (checkbox) {
|
||
checkbox.checked = e.target.checked;
|
||
onToggleCheckboxChange(checkbox);
|
||
}
|
||
});
|
||
}
|
||
});
|
||
|
||
$menuButton.appendTo($btnContain);
|
||
|
||
// Use a different target than the toolbar
|
||
var $btnTarget = $(this.$table.attr(this.attributes.btnTarget));
|
||
$btnContain.appendTo($btnTarget.length ? $btnTarget : this.tablesaw.$toolbar);
|
||
|
||
function closePopup(event) {
|
||
// Click came from inside the popup, ignore.
|
||
if (event && $(event.target).closest("." + self.classes.popup).length) {
|
||
return;
|
||
}
|
||
|
||
$(document).off("click." + tableId);
|
||
$menuButton.removeClass("up").addClass("down");
|
||
$btnContain.removeClass("visible");
|
||
}
|
||
|
||
var closeTimeout;
|
||
function openPopup() {
|
||
$btnContain.addClass("visible");
|
||
$menuButton.removeClass("down").addClass("up");
|
||
|
||
$(document).off("click." + tableId, closePopup);
|
||
|
||
window.clearTimeout(closeTimeout);
|
||
closeTimeout = window.setTimeout(function() {
|
||
$(document).on("click." + tableId, closePopup);
|
||
}, 15);
|
||
}
|
||
|
||
$menuButton.on("click.tablesaw", function(event) {
|
||
event.preventDefault();
|
||
|
||
if (!$btnContain.is(".visible")) {
|
||
openPopup();
|
||
} else {
|
||
closePopup();
|
||
}
|
||
});
|
||
|
||
$popup.appendTo($btnContain);
|
||
|
||
this.$menu = $menu;
|
||
|
||
// Fix for iOS not rendering shadows correctly when using `-webkit-overflow-scrolling`
|
||
var $overflow = this.$table.closest(".tablesaw-overflow");
|
||
if ($overflow.css("-webkit-overflow-scrolling")) {
|
||
var timeout;
|
||
$overflow.on("scroll", function() {
|
||
var $div = $(this);
|
||
window.clearTimeout(timeout);
|
||
timeout = window.setTimeout(function() {
|
||
$div.css("-webkit-overflow-scrolling", "auto");
|
||
window.setTimeout(function() {
|
||
$div.css("-webkit-overflow-scrolling", "touch");
|
||
}, 0);
|
||
}, 100);
|
||
});
|
||
}
|
||
|
||
$(window).on(Tablesaw.events.resize + "." + tableId, function() {
|
||
self.refreshToggle();
|
||
});
|
||
|
||
this.initSet();
|
||
this.refreshToggle();
|
||
};
|
||
|
||
ColumnToggle.prototype.getHeaderFromCheckbox = function(checkbox) {
|
||
return $(checkbox).data("tablesaw-header");
|
||
};
|
||
|
||
ColumnToggle.prototype.refreshToggle = function() {
|
||
var self = this;
|
||
var invisibleColumns = 0;
|
||
this.$menu.find("input").each(function() {
|
||
var header = self.getHeaderFromCheckbox(this);
|
||
this.checked =
|
||
self.tablesaw
|
||
._$getCells(header)
|
||
.eq(0)
|
||
.css("display") === "table-cell";
|
||
});
|
||
|
||
this.updateColspanCells();
|
||
};
|
||
|
||
ColumnToggle.prototype.updateColspanCells = function(header, userAction) {
|
||
this.tablesaw.updateColspanCells("tablesaw-toggle-cellhidden", header, userAction);
|
||
};
|
||
|
||
ColumnToggle.prototype.destroy = function() {
|
||
this.$table.removeClass(this.classes.columnToggleTable);
|
||
this.$table.find("th, td").each(function() {
|
||
var $cell = $(this);
|
||
$cell.removeClass("tablesaw-toggle-cellhidden").removeClass("tablesaw-toggle-cellvisible");
|
||
|
||
this.className = this.className.replace(/\bui\-table\-priority\-\d\b/g, "");
|
||
});
|
||
};
|
||
|
||
// on tablecreate, init
|
||
$(document).on(Tablesaw.events.create, function(e, tablesaw) {
|
||
if (tablesaw.mode === "columntoggle") {
|
||
var table = new ColumnToggle(tablesaw.table);
|
||
table.init();
|
||
}
|
||
});
|
||
|
||
$(document).on(Tablesaw.events.destroy, function(e, tablesaw) {
|
||
if (tablesaw.mode === "columntoggle") {
|
||
$(tablesaw.table)
|
||
.data(data.key)
|
||
.destroy();
|
||
}
|
||
});
|
||
|
||
$(document).on(Tablesaw.events.refresh, function(e, tablesaw) {
|
||
if (tablesaw.mode === "columntoggle") {
|
||
$(tablesaw.table)
|
||
.data(data.key)
|
||
.refreshToggle();
|
||
}
|
||
});
|
||
|
||
Tablesaw.ColumnToggle = ColumnToggle;
|
||
})();
|
||
|
||
(function() {
|
||
function getSortValue(cell) {
|
||
var text = [];
|
||
$(cell.childNodes).each(function() {
|
||
var $el = $(this);
|
||
if ($el.is("input, select")) {
|
||
text.push($el.val());
|
||
} else if ($el.is(".tablesaw-cell-label")) {
|
||
} else {
|
||
text.push(($el.text() || "").replace(/^\s+|\s+$/g, ""));
|
||
}
|
||
});
|
||
|
||
return text.join("");
|
||
}
|
||
|
||
var pluginName = "tablesaw-sortable",
|
||
initSelector = "table[data-" + pluginName + "]",
|
||
sortableSwitchSelector = "[data-" + pluginName + "-switch]",
|
||
attrs = {
|
||
sortCol: "data-tablesaw-sortable-col",
|
||
defaultCol: "data-tablesaw-sortable-default-col",
|
||
numericCol: "data-tablesaw-sortable-numeric",
|
||
subRow: "data-tablesaw-subrow",
|
||
ignoreRow: "data-tablesaw-ignorerow"
|
||
},
|
||
classes = {
|
||
head: pluginName + "-head",
|
||
ascend: pluginName + "-ascending",
|
||
descend: pluginName + "-descending",
|
||
switcher: pluginName + "-switch",
|
||
tableToolbar: "tablesaw-bar-section",
|
||
sortButton: pluginName + "-btn"
|
||
},
|
||
methods = {
|
||
_create: function(o) {
|
||
return $(this).each(function() {
|
||
var init = $(this).data(pluginName + "-init");
|
||
if (init) {
|
||
return false;
|
||
}
|
||
$(this)
|
||
.data(pluginName + "-init", true)
|
||
.trigger("beforecreate." + pluginName)
|
||
[pluginName]("_init", o)
|
||
.trigger("create." + pluginName);
|
||
});
|
||
},
|
||
_init: function() {
|
||
var el = $(this);
|
||
var tblsaw = el.data("tablesaw");
|
||
var heads;
|
||
var $switcher;
|
||
|
||
function addClassToHeads(h) {
|
||
$.each(h, function(i, v) {
|
||
$(v).addClass(classes.head);
|
||
});
|
||
}
|
||
|
||
function makeHeadsActionable(h, fn) {
|
||
$.each(h, function(i, col) {
|
||
var b = $("<button class='" + classes.sortButton + "'/>");
|
||
b.on("click", { col: col }, fn);
|
||
$(col)
|
||
.wrapInner(b)
|
||
.find("button")
|
||
.append("<span class='tablesaw-sortable-arrow'>");
|
||
});
|
||
}
|
||
|
||
function clearOthers(headcells) {
|
||
$.each(headcells, function(i, v) {
|
||
var col = $(v);
|
||
col.removeAttr(attrs.defaultCol);
|
||
col.removeClass(classes.ascend);
|
||
col.removeClass(classes.descend);
|
||
});
|
||
}
|
||
|
||
function headsOnAction(e) {
|
||
if ($(e.target).is("a[href]")) {
|
||
return;
|
||
}
|
||
|
||
e.stopPropagation();
|
||
var headCell = $(e.target).closest("[" + attrs.sortCol + "]"),
|
||
v = e.data.col,
|
||
newSortValue = heads.index(headCell[0]);
|
||
|
||
clearOthers(
|
||
headCell
|
||
.closest("thead")
|
||
.find("th")
|
||
.filter(function() {
|
||
return this !== headCell[0];
|
||
})
|
||
);
|
||
if (headCell.is("." + classes.descend) || !headCell.is("." + classes.ascend)) {
|
||
el[pluginName]("sortBy", v, true);
|
||
newSortValue += "_asc";
|
||
} else {
|
||
el[pluginName]("sortBy", v);
|
||
newSortValue += "_desc";
|
||
}
|
||
if ($switcher) {
|
||
$switcher
|
||
.find("select")
|
||
.val(newSortValue)
|
||
.trigger("refresh");
|
||
}
|
||
|
||
e.preventDefault();
|
||
}
|
||
|
||
function handleDefault(heads) {
|
||
$.each(heads, function(idx, el) {
|
||
var $el = $(el);
|
||
if ($el.is("[" + attrs.defaultCol + "]")) {
|
||
if (!$el.is("." + classes.descend)) {
|
||
$el.addClass(classes.ascend);
|
||
}
|
||
}
|
||
});
|
||
}
|
||
|
||
function addSwitcher(heads) {
|
||
$switcher = $("<div>")
|
||
.addClass(classes.switcher)
|
||
.addClass(classes.tableToolbar);
|
||
|
||
var html = ["<label>" + Tablesaw.i18n.sort + ":"];
|
||
|
||
// TODO next major version: remove .btn
|
||
html.push('<span class="btn tablesaw-btn"><select>');
|
||
heads.each(function(j) {
|
||
var $t = $(this);
|
||
var isDefaultCol = $t.is("[" + attrs.defaultCol + "]");
|
||
var isDescending = $t.is("." + classes.descend);
|
||
|
||
var hasNumericAttribute = $t.is("[" + attrs.numericCol + "]");
|
||
var numericCount = 0;
|
||
// Check only the first four rows to see if the column is numbers.
|
||
var numericCountMax = 5;
|
||
|
||
$(this.cells.slice(0, numericCountMax)).each(function() {
|
||
if (!isNaN(parseInt(getSortValue(this), 10))) {
|
||
numericCount++;
|
||
}
|
||
});
|
||
var isNumeric = numericCount === numericCountMax;
|
||
if (!hasNumericAttribute) {
|
||
$t.attr(attrs.numericCol, isNumeric ? "" : "false");
|
||
}
|
||
|
||
html.push(
|
||
"<option" +
|
||
(isDefaultCol && !isDescending ? " selected" : "") +
|
||
' value="' +
|
||
j +
|
||
'_asc">' +
|
||
$t.text() +
|
||
" " +
|
||
(isNumeric ? "↑" : "(A-Z)") +
|
||
"</option>"
|
||
);
|
||
html.push(
|
||
"<option" +
|
||
(isDefaultCol && isDescending ? " selected" : "") +
|
||
' value="' +
|
||
j +
|
||
'_desc">' +
|
||
$t.text() +
|
||
" " +
|
||
(isNumeric ? "↓" : "(Z-A)") +
|
||
"</option>"
|
||
);
|
||
});
|
||
html.push("</select></span></label>");
|
||
|
||
$switcher.html(html.join(""));
|
||
|
||
var $firstChild = tblsaw.$toolbar.children().eq(0);
|
||
if ($firstChild.length) {
|
||
$switcher.insertBefore($firstChild);
|
||
} else {
|
||
$switcher.appendTo(tblsaw.$toolbar);
|
||
}
|
||
$switcher.find(".tablesaw-btn").tablesawbtn();
|
||
$switcher.find("select").on("change", function() {
|
||
var val = $(this)
|
||
.val()
|
||
.split("_"),
|
||
head = heads.eq(val[0]);
|
||
|
||
clearOthers(head.siblings());
|
||
el[pluginName]("sortBy", head.get(0), val[1] === "asc");
|
||
});
|
||
}
|
||
|
||
el.addClass(pluginName);
|
||
|
||
heads = el
|
||
.children()
|
||
.filter("thead")
|
||
.find("th[" + attrs.sortCol + "]");
|
||
|
||
addClassToHeads(heads);
|
||
makeHeadsActionable(heads, headsOnAction);
|
||
handleDefault(heads);
|
||
|
||
if (el.is(sortableSwitchSelector)) {
|
||
addSwitcher(heads);
|
||
}
|
||
},
|
||
sortRows: function(rows, colNum, ascending, col, tbody) {
|
||
function convertCells(cellArr, belongingToTbody) {
|
||
var cells = [];
|
||
$.each(cellArr, function(i, cell) {
|
||
var row = cell.parentNode;
|
||
var $row = $(row);
|
||
// next row is a subrow
|
||
var subrows = [];
|
||
var $next = $row.next();
|
||
while ($next.is("[" + attrs.subRow + "]")) {
|
||
subrows.push($next[0]);
|
||
$next = $next.next();
|
||
}
|
||
|
||
var tbody = row.parentNode;
|
||
|
||
// current row is a subrow
|
||
if ($row.is("[" + attrs.subRow + "]")) {
|
||
} else if (tbody === belongingToTbody) {
|
||
cells.push({
|
||
element: cell,
|
||
cell: getSortValue(cell),
|
||
row: row,
|
||
subrows: subrows.length ? subrows : null,
|
||
ignored: $row.is("[" + attrs.ignoreRow + "]")
|
||
});
|
||
}
|
||
});
|
||
return cells;
|
||
}
|
||
|
||
function getSortFxn(ascending, forceNumeric) {
|
||
var fn,
|
||
regex = /[^\-\+\d\.]/g;
|
||
if (ascending) {
|
||
fn = function(a, b) {
|
||
if (a.ignored || b.ignored) {
|
||
return 0;
|
||
}
|
||
if (forceNumeric) {
|
||
return (
|
||
parseFloat(a.cell.replace(regex, "")) - parseFloat(b.cell.replace(regex, ""))
|
||
);
|
||
} else {
|
||
return a.cell.toLowerCase() > b.cell.toLowerCase() ? 1 : -1;
|
||
}
|
||
};
|
||
} else {
|
||
fn = function(a, b) {
|
||
if (a.ignored || b.ignored) {
|
||
return 0;
|
||
}
|
||
if (forceNumeric) {
|
||
return (
|
||
parseFloat(b.cell.replace(regex, "")) - parseFloat(a.cell.replace(regex, ""))
|
||
);
|
||
} else {
|
||
return a.cell.toLowerCase() < b.cell.toLowerCase() ? 1 : -1;
|
||
}
|
||
};
|
||
}
|
||
return fn;
|
||
}
|
||
|
||
function convertToRows(sorted) {
|
||
var newRows = [],
|
||
i,
|
||
l;
|
||
for (i = 0, l = sorted.length; i < l; i++) {
|
||
newRows.push(sorted[i].row);
|
||
if (sorted[i].subrows) {
|
||
newRows.push(sorted[i].subrows);
|
||
}
|
||
}
|
||
return newRows;
|
||
}
|
||
|
||
var fn;
|
||
var sorted;
|
||
var cells = convertCells(col.cells, tbody);
|
||
|
||
var customFn = $(col).data("tablesaw-sort");
|
||
|
||
fn =
|
||
(customFn && typeof customFn === "function" ? customFn(ascending) : false) ||
|
||
getSortFxn(
|
||
ascending,
|
||
$(col).is("[" + attrs.numericCol + "]") &&
|
||
!$(col).is("[" + attrs.numericCol + '="false"]')
|
||
);
|
||
|
||
sorted = cells.sort(fn);
|
||
|
||
rows = convertToRows(sorted);
|
||
|
||
return rows;
|
||
},
|
||
makeColDefault: function(col, a) {
|
||
var c = $(col);
|
||
c.attr(attrs.defaultCol, "true");
|
||
if (a) {
|
||
c.removeClass(classes.descend);
|
||
c.addClass(classes.ascend);
|
||
} else {
|
||
c.removeClass(classes.ascend);
|
||
c.addClass(classes.descend);
|
||
}
|
||
},
|
||
sortBy: function(col, ascending) {
|
||
var el = $(this);
|
||
var colNum;
|
||
var tbl = el.data("tablesaw");
|
||
tbl.$tbody.each(function() {
|
||
var tbody = this;
|
||
var $tbody = $(this);
|
||
var rows = tbl.getBodyRows(tbody);
|
||
var sortedRows;
|
||
var map = tbl.headerMapping[0];
|
||
var j, k;
|
||
|
||
// find the column number that we’re sorting
|
||
for (j = 0, k = map.length; j < k; j++) {
|
||
if (map[j] === col) {
|
||
colNum = j;
|
||
break;
|
||
}
|
||
}
|
||
|
||
sortedRows = el[pluginName]("sortRows", rows, colNum, ascending, col, tbody);
|
||
|
||
// replace Table rows
|
||
for (j = 0, k = sortedRows.length; j < k; j++) {
|
||
$tbody.append(sortedRows[j]);
|
||
}
|
||
});
|
||
|
||
el[pluginName]("makeColDefault", col, ascending);
|
||
|
||
el.trigger("tablesaw-sorted");
|
||
}
|
||
};
|
||
|
||
// Collection method.
|
||
$.fn[pluginName] = function(arrg) {
|
||
var args = Array.prototype.slice.call(arguments, 1),
|
||
returnVal;
|
||
|
||
// if it's a method
|
||
if (arrg && typeof arrg === "string") {
|
||
returnVal = $.fn[pluginName].prototype[arrg].apply(this[0], args);
|
||
return typeof returnVal !== "undefined" ? returnVal : $(this);
|
||
}
|
||
// check init
|
||
if (!$(this).data(pluginName + "-active")) {
|
||
$(this).data(pluginName + "-active", true);
|
||
$.fn[pluginName].prototype._create.call(this, arrg);
|
||
}
|
||
return $(this);
|
||
};
|
||
// add methods
|
||
$.extend($.fn[pluginName].prototype, methods);
|
||
|
||
$(document).on(Tablesaw.events.create, function(e, Tablesaw) {
|
||
if (Tablesaw.$table.is(initSelector)) {
|
||
Tablesaw.$table[pluginName]();
|
||
}
|
||
});
|
||
|
||
// TODO OOP this and add to Tablesaw object
|
||
})();
|
||
|
||
(function() {
|
||
var classes = {
|
||
hideBtn: "disabled",
|
||
persistWidths: "tablesaw-fix-persist",
|
||
hiddenCol: "tablesaw-swipe-cellhidden",
|
||
persistCol: "tablesaw-swipe-cellpersist",
|
||
allColumnsVisible: "tablesaw-all-cols-visible"
|
||
};
|
||
var attrs = {
|
||
disableTouchEvents: "data-tablesaw-no-touch",
|
||
ignorerow: "data-tablesaw-ignorerow",
|
||
subrow: "data-tablesaw-subrow"
|
||
};
|
||
|
||
function createSwipeTable(tbl, $table) {
|
||
var tblsaw = $table.data("tablesaw");
|
||
|
||
var $btns = $("<div class='tablesaw-advance'></div>");
|
||
// TODO next major version: remove .btn
|
||
var $prevBtn = $(
|
||
"<a href='#' class='btn tablesaw-nav-btn tablesaw-btn btn-micro left'>" +
|
||
Tablesaw.i18n.swipePreviousColumn +
|
||
"</a>"
|
||
).appendTo($btns);
|
||
// TODO next major version: remove .btn
|
||
var $nextBtn = $(
|
||
"<a href='#' class='btn tablesaw-nav-btn tablesaw-btn btn-micro right'>" +
|
||
Tablesaw.i18n.swipeNextColumn +
|
||
"</a>"
|
||
).appendTo($btns);
|
||
|
||
var $headerCells = tbl._getPrimaryHeaderCells();
|
||
var $headerCellsNoPersist = $headerCells.not('[data-tablesaw-priority="persist"]');
|
||
var headerWidths = [];
|
||
var headerWidthsNoPersist = [];
|
||
var $head = $(document.head || "head");
|
||
var tableId = $table.attr("id");
|
||
|
||
if (!$headerCells.length) {
|
||
throw new Error("tablesaw swipe: no header cells found.");
|
||
}
|
||
|
||
$table.addClass("tablesaw-swipe");
|
||
|
||
function initMinHeaderWidths() {
|
||
$table.css({
|
||
width: "1px"
|
||
});
|
||
|
||
// remove any hidden columns
|
||
$table.find("." + classes.hiddenCol).removeClass(classes.hiddenCol);
|
||
|
||
headerWidths = [];
|
||
headerWidthsNoPersist = [];
|
||
// Calculate initial widths
|
||
$headerCells.each(function() {
|
||
var width = this.offsetWidth;
|
||
headerWidths.push(width);
|
||
if (!isPersistent(this)) {
|
||
headerWidthsNoPersist.push(width);
|
||
}
|
||
});
|
||
|
||
// reset props
|
||
$table.css({
|
||
width: ""
|
||
});
|
||
}
|
||
|
||
initMinHeaderWidths();
|
||
|
||
$btns.appendTo(tblsaw.$toolbar);
|
||
|
||
if (!tableId) {
|
||
tableId = "tableswipe-" + Math.round(Math.random() * 10000);
|
||
$table.attr("id", tableId);
|
||
}
|
||
|
||
function showColumn(headerCell) {
|
||
tblsaw._$getCells(headerCell).removeClass(classes.hiddenCol);
|
||
}
|
||
|
||
function hideColumn(headerCell) {
|
||
tblsaw._$getCells(headerCell).addClass(classes.hiddenCol);
|
||
}
|
||
|
||
function persistColumn(headerCell) {
|
||
tblsaw._$getCells(headerCell).addClass(classes.persistCol);
|
||
}
|
||
|
||
function isPersistent(headerCell) {
|
||
return $(headerCell).is('[data-tablesaw-priority="persist"]');
|
||
}
|
||
|
||
function unmaintainWidths() {
|
||
$table.removeClass(classes.persistWidths);
|
||
$("#" + tableId + "-persist").remove();
|
||
}
|
||
|
||
function maintainWidths() {
|
||
var prefix = "#" + tableId + ".tablesaw-swipe ";
|
||
var styles = [];
|
||
var tableWidth = $table.width();
|
||
var tableWidthNoPersistantColumns = tableWidth;
|
||
var hash = [];
|
||
var newHash;
|
||
|
||
// save persistent column widths (as long as they take up less than 75% of table width)
|
||
$headerCells.each(function(index) {
|
||
var width;
|
||
if (isPersistent(this)) {
|
||
width = this.offsetWidth;
|
||
tableWidthNoPersistantColumns -= width;
|
||
|
||
if (width < tableWidth * 0.75) {
|
||
hash.push(index + "-" + width);
|
||
styles.push(
|
||
prefix +
|
||
" ." +
|
||
classes.persistCol +
|
||
":nth-child(" +
|
||
(index + 1) +
|
||
") { width: " +
|
||
width +
|
||
"px; }"
|
||
);
|
||
}
|
||
}
|
||
});
|
||
newHash = hash.join("_");
|
||
|
||
if (styles.length) {
|
||
$table.addClass(classes.persistWidths);
|
||
var $style = $("#" + tableId + "-persist");
|
||
// If style element not yet added OR if the widths have changed
|
||
if (!$style.length || $style.data("tablesaw-hash") !== newHash) {
|
||
// Remove existing
|
||
$style.remove();
|
||
|
||
$("<style>" + styles.join("\n") + "</style>")
|
||
.attr("id", tableId + "-persist")
|
||
.data("tablesaw-hash", newHash)
|
||
.appendTo($head);
|
||
}
|
||
}
|
||
|
||
return tableWidthNoPersistantColumns;
|
||
}
|
||
|
||
function getNext() {
|
||
var next = [];
|
||
var checkFound;
|
||
$headerCellsNoPersist.each(function(i) {
|
||
var $t = $(this);
|
||
var isHidden = $t.css("display") === "none" || $t.is("." + classes.hiddenCol);
|
||
|
||
if (!isHidden && !checkFound) {
|
||
checkFound = true;
|
||
next[0] = i;
|
||
} else if (isHidden && checkFound) {
|
||
next[1] = i;
|
||
|
||
return false;
|
||
}
|
||
});
|
||
|
||
return next;
|
||
}
|
||
|
||
function getPrev() {
|
||
var next = getNext();
|
||
return [next[1] - 1, next[0] - 1];
|
||
}
|
||
|
||
function canNavigate(pair) {
|
||
return pair[1] > -1 && pair[1] < $headerCellsNoPersist.length;
|
||
}
|
||
|
||
function matchesMedia() {
|
||
var matchMedia = $table.attr("data-tablesaw-swipe-media");
|
||
return !matchMedia || ("matchMedia" in window && window.matchMedia(matchMedia).matches);
|
||
}
|
||
|
||
function fakeBreakpoints() {
|
||
if (!matchesMedia()) {
|
||
return;
|
||
}
|
||
|
||
var containerWidth = $table.parent().width(),
|
||
persist = [],
|
||
sum = 0,
|
||
sums = [],
|
||
visibleNonPersistantCount = $headerCells.length;
|
||
|
||
$headerCells.each(function(index) {
|
||
var $t = $(this),
|
||
isPersist = $t.is('[data-tablesaw-priority="persist"]');
|
||
|
||
persist.push(isPersist);
|
||
sum += headerWidths[index];
|
||
sums.push(sum);
|
||
|
||
// is persistent or is hidden
|
||
if (isPersist || sum > containerWidth) {
|
||
visibleNonPersistantCount--;
|
||
}
|
||
});
|
||
|
||
// We need at least one column to swipe.
|
||
var needsNonPersistentColumn = visibleNonPersistantCount === 0;
|
||
|
||
$headerCells.each(function(index) {
|
||
if (sums[index] > containerWidth) {
|
||
hideColumn(this);
|
||
}
|
||
});
|
||
|
||
var firstPersist = true;
|
||
$headerCells.each(function(index) {
|
||
if (persist[index]) {
|
||
// for visual box-shadow
|
||
persistColumn(this);
|
||
|
||
if (firstPersist) {
|
||
tblsaw._$getCells(this).css("width", sums[index] + "px");
|
||
firstPersist = false;
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (sums[index] <= containerWidth || needsNonPersistentColumn) {
|
||
needsNonPersistentColumn = false;
|
||
showColumn(this);
|
||
tblsaw.updateColspanCells(classes.hiddenCol, this, true);
|
||
}
|
||
});
|
||
|
||
unmaintainWidths();
|
||
|
||
$table.trigger("tablesawcolumns");
|
||
}
|
||
|
||
function goForward() {
|
||
navigate(true);
|
||
}
|
||
function goBackward() {
|
||
navigate(false);
|
||
}
|
||
|
||
function navigate(isNavigateForward) {
|
||
var pair;
|
||
if (isNavigateForward) {
|
||
pair = getNext();
|
||
} else {
|
||
pair = getPrev();
|
||
}
|
||
|
||
if (canNavigate(pair)) {
|
||
if (isNaN(pair[0])) {
|
||
if (isNavigateForward) {
|
||
pair[0] = 0;
|
||
} else {
|
||
pair[0] = $headerCellsNoPersist.length - 1;
|
||
}
|
||
}
|
||
|
||
var roomForColumnsWidth = maintainWidths();
|
||
var hideColumnIndex = pair[0];
|
||
var showColumnIndex = pair[1];
|
||
|
||
// Hide one column, show one or more based on how much space was freed up
|
||
var columnToShow;
|
||
var columnToHide = $headerCellsNoPersist.get(hideColumnIndex);
|
||
var wasAtLeastOneColumnShown = false;
|
||
var atLeastOneColumnIsVisible = false;
|
||
|
||
hideColumn(columnToHide);
|
||
tblsaw.updateColspanCells(classes.hiddenCol, columnToHide, true);
|
||
|
||
var columnIndex = hideColumnIndex + (isNavigateForward ? 1 : -1);
|
||
while (columnIndex >= 0 && columnIndex < headerWidthsNoPersist.length) {
|
||
roomForColumnsWidth -= headerWidthsNoPersist[columnIndex];
|
||
|
||
var $columnToShow = $headerCellsNoPersist.eq(columnIndex);
|
||
if ($columnToShow.is(".tablesaw-swipe-cellhidden")) {
|
||
if (roomForColumnsWidth > 0) {
|
||
columnToShow = $columnToShow.get(0);
|
||
wasAtLeastOneColumnShown = true;
|
||
atLeastOneColumnIsVisible = true;
|
||
showColumn(columnToShow);
|
||
tblsaw.updateColspanCells(classes.hiddenCol, columnToShow, false);
|
||
}
|
||
} else {
|
||
atLeastOneColumnIsVisible = true;
|
||
}
|
||
|
||
if (isNavigateForward) {
|
||
columnIndex++;
|
||
} else {
|
||
columnIndex--;
|
||
}
|
||
}
|
||
|
||
if (!atLeastOneColumnIsVisible) {
|
||
// if no columns are showing, at least show the first one we were aiming for.
|
||
columnToShow = $headerCellsNoPersist.get(showColumnIndex);
|
||
showColumn(columnToShow);
|
||
tblsaw.updateColspanCells(classes.hiddenCol, columnToShow, false);
|
||
} else if (
|
||
!wasAtLeastOneColumnShown &&
|
||
canNavigate(isNavigateForward ? getNext() : getPrev())
|
||
) {
|
||
// if our one new column was hidden but no new columns were shown, let’s navigate again automatically.
|
||
navigate(isNavigateForward);
|
||
}
|
||
$table.trigger("tablesawcolumns");
|
||
}
|
||
}
|
||
|
||
$prevBtn.add($nextBtn).on("click", function(e) {
|
||
if (!!$(e.target).closest($nextBtn).length) {
|
||
goForward();
|
||
} else {
|
||
goBackward();
|
||
}
|
||
e.preventDefault();
|
||
});
|
||
|
||
function getCoord(event, key) {
|
||
return (event.touches || event.originalEvent.touches)[0][key];
|
||
}
|
||
|
||
if (!$table.is("[" + attrs.disableTouchEvents + "]")) {
|
||
$table.on("touchstart.swipetoggle", function(e) {
|
||
var originX = getCoord(e, "pageX");
|
||
var originY = getCoord(e, "pageY");
|
||
var x;
|
||
var y;
|
||
var scrollTop = window.pageYOffset;
|
||
|
||
$(window).off(Tablesaw.events.resize, fakeBreakpoints);
|
||
|
||
$(this)
|
||
.on("touchmove.swipetoggle", function(e) {
|
||
x = getCoord(e, "pageX");
|
||
y = getCoord(e, "pageY");
|
||
})
|
||
.on("touchend.swipetoggle", function() {
|
||
var cfg = tbl.getConfig({
|
||
swipeHorizontalThreshold: 30,
|
||
swipeVerticalThreshold: 30
|
||
});
|
||
|
||
// This config code is a little awkward because shoestring doesn’t support deep $.extend
|
||
// Trying to work around when devs only override one of (not both) horizontalThreshold or
|
||
// verticalThreshold in their TablesawConfig.
|
||
// @TODO major version bump: remove cfg.swipe, move to just use the swipePrefix keys
|
||
var verticalThreshold = cfg.swipe
|
||
? cfg.swipe.verticalThreshold
|
||
: cfg.swipeVerticalThreshold;
|
||
var horizontalThreshold = cfg.swipe
|
||
? cfg.swipe.horizontalThreshold
|
||
: cfg.swipeHorizontalThreshold;
|
||
|
||
var isPageScrolled = Math.abs(window.pageYOffset - scrollTop) >= verticalThreshold;
|
||
var isVerticalSwipe = Math.abs(y - originY) >= verticalThreshold;
|
||
|
||
if (!isVerticalSwipe && !isPageScrolled) {
|
||
if (x - originX < -1 * horizontalThreshold) {
|
||
goForward();
|
||
}
|
||
if (x - originX > horizontalThreshold) {
|
||
goBackward();
|
||
}
|
||
}
|
||
|
||
window.setTimeout(function() {
|
||
$(window).on(Tablesaw.events.resize, fakeBreakpoints);
|
||
}, 300);
|
||
|
||
$(this).off("touchmove.swipetoggle touchend.swipetoggle");
|
||
});
|
||
});
|
||
}
|
||
|
||
$table
|
||
.on("tablesawcolumns.swipetoggle", function() {
|
||
var canGoPrev = canNavigate(getPrev());
|
||
var canGoNext = canNavigate(getNext());
|
||
$prevBtn[canGoPrev ? "removeClass" : "addClass"](classes.hideBtn);
|
||
$nextBtn[canGoNext ? "removeClass" : "addClass"](classes.hideBtn);
|
||
|
||
tblsaw.$toolbar[!canGoPrev && !canGoNext ? "addClass" : "removeClass"](
|
||
classes.allColumnsVisible
|
||
);
|
||
})
|
||
.on("tablesawnext.swipetoggle", function() {
|
||
goForward();
|
||
})
|
||
.on("tablesawprev.swipetoggle", function() {
|
||
goBackward();
|
||
})
|
||
.on(Tablesaw.events.destroy + ".swipetoggle", function() {
|
||
var $t = $(this);
|
||
|
||
$t.removeClass("tablesaw-swipe");
|
||
tblsaw.$toolbar.find(".tablesaw-advance").remove();
|
||
$(window).off(Tablesaw.events.resize, fakeBreakpoints);
|
||
|
||
$t.off(".swipetoggle");
|
||
})
|
||
.on(Tablesaw.events.refresh, function() {
|
||
unmaintainWidths();
|
||
initMinHeaderWidths();
|
||
fakeBreakpoints();
|
||
});
|
||
|
||
fakeBreakpoints();
|
||
$(window).on(Tablesaw.events.resize, fakeBreakpoints);
|
||
}
|
||
|
||
// on tablecreate, init
|
||
$(document).on(Tablesaw.events.create, function(e, tablesaw) {
|
||
if (tablesaw.mode === "swipe") {
|
||
createSwipeTable(tablesaw, tablesaw.$table);
|
||
}
|
||
});
|
||
|
||
// TODO OOP this and add to Tablesaw object
|
||
})();
|
||
|
||
(function() {
|
||
var MiniMap = {
|
||
attr: {
|
||
init: "data-tablesaw-minimap"
|
||
},
|
||
show: function(table) {
|
||
var mq = table.getAttribute(MiniMap.attr.init);
|
||
|
||
if (mq === "") {
|
||
// value-less but exists
|
||
return true;
|
||
} else if (mq && "matchMedia" in window) {
|
||
// has a mq value
|
||
return window.matchMedia(mq).matches;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
};
|
||
|
||
function createMiniMap($table) {
|
||
var tblsaw = $table.data("tablesaw");
|
||
var $btns = $('<div class="tablesaw-advance minimap">');
|
||
var $dotNav = $('<ul class="tablesaw-advance-dots">').appendTo($btns);
|
||
var hideDot = "tablesaw-advance-dots-hide";
|
||
var $headerCells = $table.data("tablesaw")._getPrimaryHeaderCells();
|
||
|
||
// populate dots
|
||
$headerCells.each(function() {
|
||
$dotNav.append("<li><i></i></li>");
|
||
});
|
||
|
||
$btns.appendTo(tblsaw.$toolbar);
|
||
|
||
function showHideNav() {
|
||
if (!MiniMap.show($table[0])) {
|
||
$btns.css("display", "none");
|
||
return;
|
||
}
|
||
$btns.css("display", "block");
|
||
|
||
// show/hide dots
|
||
var dots = $dotNav.find("li").removeClass(hideDot);
|
||
$table.find("thead th").each(function(i) {
|
||
if ($(this).css("display") === "none") {
|
||
dots.eq(i).addClass(hideDot);
|
||
}
|
||
});
|
||
}
|
||
|
||
// run on init and resize
|
||
showHideNav();
|
||
$(window).on(Tablesaw.events.resize, showHideNav);
|
||
|
||
$table
|
||
.on("tablesawcolumns.minimap", function() {
|
||
showHideNav();
|
||
})
|
||
.on(Tablesaw.events.destroy + ".minimap", function() {
|
||
var $t = $(this);
|
||
|
||
tblsaw.$toolbar.find(".tablesaw-advance").remove();
|
||
$(window).off(Tablesaw.events.resize, showHideNav);
|
||
|
||
$t.off(".minimap");
|
||
});
|
||
}
|
||
|
||
// on tablecreate, init
|
||
$(document).on(Tablesaw.events.create, function(e, tablesaw) {
|
||
if (
|
||
(tablesaw.mode === "swipe" || tablesaw.mode === "columntoggle") &&
|
||
tablesaw.$table.is("[ " + MiniMap.attr.init + "]")
|
||
) {
|
||
createMiniMap(tablesaw.$table);
|
||
}
|
||
});
|
||
|
||
// TODO OOP this better
|
||
Tablesaw.MiniMap = MiniMap;
|
||
})();
|
||
|
||
(function() {
|
||
var S = {
|
||
selectors: {
|
||
init: "table[data-tablesaw-mode-switch]"
|
||
},
|
||
attributes: {
|
||
excludeMode: "data-tablesaw-mode-exclude"
|
||
},
|
||
classes: {
|
||
main: "tablesaw-modeswitch",
|
||
toolbar: "tablesaw-bar-section"
|
||
},
|
||
modes: ["stack", "swipe", "columntoggle"],
|
||
init: function(table) {
|
||
var $table = $(table);
|
||
var tblsaw = $table.data("tablesaw");
|
||
var ignoreMode = $table.attr(S.attributes.excludeMode);
|
||
var $toolbar = tblsaw.$toolbar;
|
||
var $switcher = $("<div>").addClass(S.classes.main + " " + S.classes.toolbar);
|
||
|
||
var html = [
|
||
'<label><span class="abbreviated">' +
|
||
Tablesaw.i18n.modeSwitchColumnsAbbreviated +
|
||
'</span><span class="longform">' +
|
||
Tablesaw.i18n.modeSwitchColumns +
|
||
"</span>:"
|
||
],
|
||
dataMode = $table.attr("data-tablesaw-mode"),
|
||
isSelected;
|
||
|
||
// TODO next major version: remove .btn
|
||
html.push('<span class="btn tablesaw-btn"><select>');
|
||
for (var j = 0, k = S.modes.length; j < k; j++) {
|
||
if (ignoreMode && ignoreMode.toLowerCase() === S.modes[j]) {
|
||
continue;
|
||
}
|
||
|
||
isSelected = dataMode === S.modes[j];
|
||
|
||
html.push(
|
||
"<option" +
|
||
(isSelected ? " selected" : "") +
|
||
' value="' +
|
||
S.modes[j] +
|
||
'">' +
|
||
Tablesaw.i18n.modes[j] +
|
||
"</option>"
|
||
);
|
||
}
|
||
html.push("</select></span></label>");
|
||
|
||
$switcher.html(html.join(""));
|
||
|
||
var $otherToolbarItems = $toolbar.find(".tablesaw-advance").eq(0);
|
||
if ($otherToolbarItems.length) {
|
||
$switcher.insertBefore($otherToolbarItems);
|
||
} else {
|
||
$switcher.appendTo($toolbar);
|
||
}
|
||
|
||
$switcher.find(".tablesaw-btn").tablesawbtn();
|
||
$switcher.find("select").on("change", function(event) {
|
||
return S.onModeChange.call(table, event, $(this).val());
|
||
});
|
||
},
|
||
onModeChange: function(event, val) {
|
||
var $table = $(this);
|
||
var tblsaw = $table.data("tablesaw");
|
||
var $switcher = tblsaw.$toolbar.find("." + S.classes.main);
|
||
|
||
$switcher.remove();
|
||
tblsaw.destroy();
|
||
|
||
$table.attr("data-tablesaw-mode", val);
|
||
$table.tablesaw();
|
||
}
|
||
};
|
||
|
||
$(document).on(Tablesaw.events.create, function(e, Tablesaw) {
|
||
if (Tablesaw.$table.is(S.selectors.init)) {
|
||
S.init(Tablesaw.table);
|
||
}
|
||
});
|
||
|
||
// TODO OOP this and add to Tablesaw object
|
||
})();
|
||
|
||
(function() {
|
||
var pluginName = "tablesawCheckAll";
|
||
|
||
function CheckAll(tablesaw) {
|
||
this.tablesaw = tablesaw;
|
||
this.$table = tablesaw.$table;
|
||
|
||
this.attr = "data-tablesaw-checkall";
|
||
this.checkAllSelector = "[" + this.attr + "]";
|
||
this.forceCheckedSelector = "[" + this.attr + "-checked]";
|
||
this.forceUncheckedSelector = "[" + this.attr + "-unchecked]";
|
||
this.checkboxSelector = 'input[type="checkbox"]';
|
||
|
||
this.$triggers = null;
|
||
this.$checkboxes = null;
|
||
|
||
if (this.$table.data(pluginName)) {
|
||
return;
|
||
}
|
||
this.$table.data(pluginName, this);
|
||
this.init();
|
||
}
|
||
|
||
CheckAll.prototype._filterCells = function($checkboxes) {
|
||
return $checkboxes
|
||
.filter(function() {
|
||
return !$(this)
|
||
.closest("tr")
|
||
.is("[data-tablesaw-subrow],[data-tablesaw-ignorerow]");
|
||
})
|
||
.find(this.checkboxSelector)
|
||
.not(this.checkAllSelector);
|
||
};
|
||
|
||
// With buttons you can use a scoping selector like: data-tablesaw-checkall="#my-scoped-id input[type='checkbox']"
|
||
CheckAll.prototype.getCheckboxesForButton = function(button) {
|
||
return this._filterCells($($(button).attr(this.attr)));
|
||
};
|
||
|
||
CheckAll.prototype.getCheckboxesForCheckbox = function(checkbox) {
|
||
return this._filterCells($($(checkbox).closest("th")[0].cells));
|
||
};
|
||
|
||
CheckAll.prototype.init = function() {
|
||
var self = this;
|
||
this.$table.find(this.checkAllSelector).each(function() {
|
||
var $trigger = $(this);
|
||
if ($trigger.is(self.checkboxSelector)) {
|
||
self.addCheckboxEvents(this);
|
||
} else {
|
||
self.addButtonEvents(this);
|
||
}
|
||
});
|
||
};
|
||
|
||
CheckAll.prototype.addButtonEvents = function(trigger) {
|
||
var self = this;
|
||
|
||
// Update body checkboxes when header checkbox is changed
|
||
$(trigger).on("click", function(event) {
|
||
event.preventDefault();
|
||
|
||
var $checkboxes = self.getCheckboxesForButton(this);
|
||
|
||
var allChecked = true;
|
||
$checkboxes.each(function() {
|
||
if (!this.checked) {
|
||
allChecked = false;
|
||
}
|
||
});
|
||
|
||
var setChecked;
|
||
if ($(this).is(self.forceCheckedSelector)) {
|
||
setChecked = true;
|
||
} else if ($(this).is(self.forceUncheckedSelector)) {
|
||
setChecked = false;
|
||
} else {
|
||
setChecked = allChecked ? false : true;
|
||
}
|
||
|
||
$checkboxes.each(function() {
|
||
this.checked = setChecked;
|
||
|
||
$(this).trigger("change." + pluginName);
|
||
});
|
||
});
|
||
};
|
||
|
||
CheckAll.prototype.addCheckboxEvents = function(trigger) {
|
||
var self = this;
|
||
|
||
// Update body checkboxes when header checkbox is changed
|
||
$(trigger).on("change", function() {
|
||
var setChecked = this.checked;
|
||
|
||
self.getCheckboxesForCheckbox(this).each(function() {
|
||
this.checked = setChecked;
|
||
});
|
||
});
|
||
|
||
var $checkboxes = self.getCheckboxesForCheckbox(trigger);
|
||
|
||
// Update header checkbox when body checkboxes are changed
|
||
$checkboxes.on("change." + pluginName, function() {
|
||
var checkedCount = 0;
|
||
$checkboxes.each(function() {
|
||
if (this.checked) {
|
||
checkedCount++;
|
||
}
|
||
});
|
||
|
||
var allSelected = checkedCount === $checkboxes.length;
|
||
|
||
trigger.checked = allSelected;
|
||
|
||
// only indeterminate if some are selected (not all and not none)
|
||
trigger.indeterminate = checkedCount !== 0 && !allSelected;
|
||
});
|
||
};
|
||
|
||
// on tablecreate, init
|
||
$(document).on(Tablesaw.events.create, function(e, tablesaw) {
|
||
new CheckAll(tablesaw);
|
||
});
|
||
|
||
Tablesaw.CheckAll = CheckAll;
|
||
})();
|
||
|
||
return Tablesaw;
|
||
}));
|