" + options.placeholder + "
");
+ }
+
+ //set table height
+
+ if (options.height) {
+
+ options.height = isNaN(options.height) ? options.height : options.height + "px";
+
+ this.element.css({ "height": options.height });
+ }
+
+ //build table elements
+
+ element.append(this.columnManager.getElement());
+
+ element.append(this.rowManager.getElement());
+
+ if (options.footerElement) {
+
+ this.footerManager.activate();
+ }
+
+ if (options.persistentLayout && this.extExists("persistentLayout", true)) {
+
+ ext.persistentLayout.initialize(options.persistentLayout, options.persistentLayoutID);
+
+ options.columns = ext.persistentLayout.load(options.columns);
+ }
+
+ if (this.extExists("columnCalcs")) {
+
+ ext.columnCalcs.initialize();
+ }
+
+ this.columnManager.setColumns(options.columns);
+
+ if (options.initialSort && this.extExists("sort", true)) {
+
+ ext.sort.setSort(options.initialSort);
+ }
+
+ if (options.pagination && this.extExists("page", true)) {
+
+ ext.page.initialize();
+ }
+
+ if (options.groupBy && this.extExists("groupRows", true)) {
+
+ ext.groupRows.initialize();
+ }
+
+ if (this.extExists("ajax")) {
+
+ ext.ajax.initialize();
+ }
+
+ if (this.extExists("keybindings")) {
+
+ ext.keybindings.initialize();
+ }
+
+ if (this.extExists("selectRow")) {
+
+ ext.selectRow.clearSelectionData();
+ }
+
+ options.tableBuilt();
+ },
+
+ _loadInitialData: function _loadInitialData() {
+
+ var self = this;
+
+ if (self.options.pagination && self.extExists("page")) {
+
+ self.extensions.page.reset(true);
+
+ self.extensions.page.setPage(1);
+
+ if (self.options.pagination == "local") {
+
+ self.rowManager.setData(self.options.data);
+ }
+ } else {
+
+ if (self.options.data.length) {
+
+ self.rowManager.setData(self.options.data);
+ } else {
+
+ if (self.options.ajaxURL && self.extExists("ajax")) {
+
+ self.extensions.ajax.sendRequest(function (data) {
+
+ self.rowManager.setData(data);
+ });
+ } else {
+
+ self.rowManager.setData(self.options.data);
+ }
+ }
+ }
+ },
+
+ //set options
+
+ _setOption: function _setOption(option, value) {
+
+ console.error("Options Error - Tabulator does not allow options to be set after initialization unless there is a function defined for that purpose");
+ },
+
+ //deconstructor
+
+ _destroy: function _destroy() {
+
+ var element = this.element;
+
+ element.empty();
+
+ element.removeClass("tabulator");
+ },
+
+ _detectBrowser: function _detectBrowser() {
+
+ var ua = navigator.userAgent;
+
+ if (ua.indexOf("Trident") > -1) {
+
+ this.brower = "ie";
+
+ this.browserSlow = true;
+ } else if (ua.indexOf("Edge") > -1) {
+
+ this.brower = "edge";
+
+ this.browserSlow = true;
+ } else {
+
+ this.brower = "other";
+
+ this.browserSlow = false;
+ }
+ },
+
+
+ ////////////////// Data Handling //////////////////
+
+
+ //load data
+
+ setData: function setData(data, params, config) {
+
+ var self = this;
+
+ var self = this;
+
+ if (typeof data === "string") {
+
+ if (data.indexOf("{") == 0 || data.indexOf("[") == 0) {
+
+ //data is a json encoded string
+
+ self.rowManager.setData(JSON.parse(data));
+ } else {
+
+ if (self.extExists("ajax", true)) {
+
+ if (params) {
+
+ self.extensions.ajax.setParams(params);
+ }
+
+ if (config) {
+
+ self.extensions.ajax.setConfig(config);
+ }
+
+ self.extensions.ajax.setUrl(data);
+
+ if (self.options.pagination == "remote" && self.extExists("page", true)) {
+
+ self.extensions.page.reset(true);
+
+ self.extensions.page.setPage(1);
+ } else {
+
+ //assume data is url, make ajax call to url to get data
+
+ self.extensions.ajax.sendRequest(function (data) {
+
+ self.rowManager.setData(data);
+ });
+ }
+ }
+ }
+ } else {
+
+ if (data) {
+
+ //asume data is already an object
+
+ self.rowManager.setData(data);
+ } else {
+
+ //no data provided, check if ajaxURL is present;
+
+ if (self.extExists("ajax") && self.extensions.ajax.getUrl) {
+
+ if (self.options.pagination == "remote" && self.extExists("page", true)) {
+
+ self.extensions.page.reset(true);
+
+ self.extensions.page.setPage(1);
+ } else {
+
+ self.extensions.ajax.sendRequest(function (data) {
+
+ self.rowManager.setData(data);
+ });
+ }
+ } else {
+
+ //empty data
+
+ self.rowManager.setData([]);
+ }
+ }
+ }
+ },
+
+ //clear data
+
+ clearData: function clearData() {
+
+ this.rowManager.clearData();
+ },
+
+ //get table data array
+
+ getData: function getData(active) {
+
+ return this.rowManager.getData(active);
+ },
+
+ //get table data array count
+
+ getDataCount: function getDataCount(active) {
+
+ return this.rowManager.getDataCount(active);
+ },
+
+ //get table html
+
+ getHtml: function getHtml(active) {
+
+ return this.rowManager.getHtml(active);
+ },
+
+ //retrieve Ajax URL
+
+ getAjaxUrl: function getAjaxUrl() {
+
+ if (this.extExists("ajax", true)) {
+
+ return this.extensions.ajax.getUrl();
+ }
+ },
+
+ //update table data
+
+ updateData: function updateData(data) {
+
+ var self = this;
+
+ if (data) {
+
+ data.forEach(function (item) {
+
+ var row = self.rowManager.findRow(item[self.options.index]);
+
+ if (row) {
+
+ row.updateData(item);
+ }
+ });
+ } else {
+
+ console.warn("Update Error - No data provided");
+ }
+ },
+
+ addData: function addData(data, pos, index) {
+
+ if (data) {
+
+ this.rowManager.addRows(data, pos, index);
+ } else {
+
+ console.warn("Update Error - No data provided");
+ }
+ },
+
+ //update table data
+
+ updateOrAddData: function updateOrAddData(data) {
+
+ var self = this;
+
+ if (data) {
+
+ data.forEach(function (item) {
+
+ var row = self.rowManager.findRow(item[self.options.index]);
+
+ if (row) {
+
+ row.updateData(item);
+ } else {
+
+ self.rowManager.addRow(item);
+ }
+ });
+ } else {
+
+ console.warn("Update Error - No data provided");
+ }
+ },
+
+ //get row object
+
+ getRow: function getRow(index) {
+
+ var row = this.rowManager.findRow(index);
+
+ if (row) {
+
+ return row.getComponent();
+ } else {
+
+ console.warn("Find Error - No matching row found:", index);
+
+ return false;
+ }
+ },
+
+ //delete row from table
+
+ deleteRow: function deleteRow(index) {
+
+ var row = this.rowManager.findRow(index);
+
+ if (row) {
+
+ row.delete();
+
+ return true;
+ } else {
+
+ console.warn("Delete Error - No matching row found:", index);
+
+ return false;
+ }
+ },
+
+ //add row to table
+
+ addRow: function addRow(data, pos, index) {
+
+ return this.rowManager.addRow(data, pos, index);
+ },
+
+ //update a row if it exitsts otherwise create it
+
+ updateOrAddRow: function updateOrAddRow(index, data) {
+
+ var row = this.rowManager.findRow(index);
+
+ if (row) {
+
+ row.updateData(data);
+ } else {
+
+ row = this.rowManager.addRow(data);
+ }
+
+ return row.getComponent();
+ },
+
+ //update row data
+
+ updateRow: function updateRow(index, data) {
+
+ var row = this.rowManager.findRow(index);
+
+ if (row) {
+
+ row.updateData(data);
+
+ return row.getComponent();
+ } else {
+
+ console.warn("Update Error - No matching row found:", index);
+
+ return false;
+ }
+ },
+
+ //scroll to row in DOM
+
+ scrollToRow: function scrollToRow(index) {
+
+ var row = this.rowManager.findRow(index);
+
+ if (row) {
+
+ return this.rowManager.scrollToRow(row);
+ } else {
+
+ console.warn("Scroll Error - No matching row found:", index);
+
+ return false;
+ }
+ },
+
+ getRows: function getRows(active) {
+
+ return this.rowManager.getComponents(active);
+ },
+
+ /////////////// Column Functions ///////////////
+
+
+ setColumns: function setColumns(definition) {
+
+ this.columnManager.setColumns(definition);
+ },
+
+ getColumns: function getColumns() {
+
+ return this.columnManager.getComponents();
+ },
+
+ getColumnDefinitions: function getColumnDefinitions() {
+
+ return this.columnManager.getDefinitionTree();
+ },
+
+ getColumnLayout: function getColumnLayout() {
+
+ if (this.extExists("persistentLayout", true)) {
+
+ return this.extensions.persistentLayout.parseColumns(this.columnManager.getColumns());
+ }
+ },
+
+ setColumnLayout: function setColumnLayout(layout) {
+
+ if (this.extExists("persistentLayout", true)) {
+
+ this.columnManager.setColumns(this.extensions.persistentLayout.mergeDefinition(this.options.columns, layout));
+
+ return true;
+ }
+
+ return false;
+ },
+
+ showColumn: function showColumn(field) {
+
+ var column = this.columnManager.findColumn(field);
+
+ if (column) {
+
+ column.show();
+ } else {
+
+ console.warn("Column Show Error - No matching column found:", field);
+
+ return false;
+ }
+ },
+
+ hideColumn: function hideColumn(field) {
+
+ var column = this.columnManager.findColumn(field);
+
+ if (column) {
+
+ column.hide();
+ } else {
+
+ console.warn("Column Hide Error - No matching column found:", field);
+
+ return false;
+ }
+ },
+
+ toggleColumn: function toggleColumn(field) {
+
+ var column = this.columnManager.findColumn(field);
+
+ if (column) {
+
+ if (column.visible) {
+
+ column.hide();
+ } else {
+
+ column.show();
+ }
+ } else {
+
+ console.warn("Column Visibility Toggle Error - No matching column found:", field);
+
+ return false;
+ }
+ },
+
+ addColumn: function addColumn(definition, before, field) {
+
+ var column = this.columnManager.findColumn(field);
+
+ this.columnManager.addColumn(definition, before, column);
+ },
+
+ deleteColumn: function deleteColumn(field) {
+
+ var column = this.columnManager.findColumn(field);
+
+ if (column) {
+
+ column.delete();
+ } else {
+
+ console.warn("Column Delete Error - No matching column found:", field);
+
+ return false;
+ }
+ },
+
+ //////////// Localization Functions ////////////
+
+ setLocale: function setLocale(locale) {
+
+ this.extensions.localize.setLocale(locale);
+ },
+
+ getLocale: function getLocale() {
+
+ return this.extensions.localize.getLocale();
+ },
+
+ getLang: function getLang(locale) {
+
+ return this.extensions.localize.getLang(locale);
+ },
+
+ //////////// General Public Functions ////////////
+
+
+ //redraw list without updating data
+
+ redraw: function redraw(force) {
+
+ this.columnManager.redraw(force);
+
+ this.rowManager.redraw(force);
+ },
+
+ setHeight: function setHeight(height) {
+
+ this.options.height = isNaN(height) ? height : height + "px";
+
+ this.element.css({ "height": this.options.height });
+
+ this.rowManager.redraw();
+ },
+
+ ///////////////////// Sorting ////////////////////
+
+
+ //trigger sort
+
+ setSort: function setSort(sortList, dir) {
+
+ if (this.extExists("sort", true)) {
+
+ this.extensions.sort.setSort(sortList, dir);
+
+ this.rowManager.sorterRefresh();
+ }
+ },
+
+ getSort: function getSort() {
+
+ if (this.extExists("sort", true)) {
+
+ console.warn("The%c getSort%c function has been depricated and will be removed in version 4.0, use %c getSorters%c instead.", "font-weight:bold;", "font-weight:regular;", "font-weight:bold;", "font-weight:regular;");
+
+ return this.getSorters();
+ }
+ },
+
+ getSorters: function getSorters() {
+
+ if (this.extExists("sort", true)) {
+
+ return this.extensions.sort.getSort();
+ }
+ },
+
+ clearSort: function clearSort() {
+
+ if (this.extExists("sort", true)) {
+
+ this.extensions.sort.clear();
+
+ this.rowManager.sorterRefresh();
+ }
+ },
+
+ ///////////////////// Filtering ////////////////////
+
+
+ //set standard filters
+
+ setFilter: function setFilter(field, type, value) {
+
+ if (this.extExists("filter", true)) {
+
+ this.extensions.filter.setFilter(field, type, value);
+
+ this.rowManager.filterRefresh();
+ }
+ },
+
+ //add filter to array
+
+ addFilter: function addFilter(field, type, value) {
+
+ if (this.extExists("filter", true)) {
+
+ this.extensions.filter.addFilter(field, type, value);
+
+ this.rowManager.filterRefresh();
+ }
+ },
+
+ //get all filters
+
+ getFilter: function getFilter(all) {
+
+ console.warn("The%c getFilter%c function has been depricated and will be removed in version 4.0, use %c getFilters%c instead.", "font-weight:bold;", "font-weight:regular;", "font-weight:bold;", "font-weight:regular;");
+
+ this.getFilters(all);
+ },
+
+ getFilters: function getFilters(all) {
+
+ if (this.extExists("filter", true)) {
+
+ return this.extensions.filter.getFilters(all);
+ }
+ },
+
+ getHeaderFilters: function getHeaderFilters() {
+
+ if (this.extExists("filter", true)) {
+
+ return this.extensions.filter.getHeaderFilters();
+ }
+ },
+
+ //remove filter from array
+
+ removeFilter: function removeFilter(field, type, value) {
+
+ if (this.extExists("filter", true)) {
+
+ this.extensions.filter.removeFilter(field, type, value);
+
+ this.rowManager.filterRefresh();
+ }
+ },
+
+ //clear filters
+
+ clearFilter: function clearFilter(all) {
+
+ if (this.extExists("filter", true)) {
+
+ this.extensions.filter.clearFilter(all);
+
+ this.rowManager.filterRefresh();
+ }
+ },
+
+ //clear header filters
+
+ clearHeaderFilter: function clearHeaderFilter() {
+
+ if (this.extExists("filter", true)) {
+
+ this.extensions.filter.clearHeaderFilter();
+
+ this.rowManager.filterRefresh();
+ }
+ },
+
+ ///////////////////// Filtering ////////////////////
+
+ selectRow: function selectRow(rows) {
+
+ if (this.extExists("selectRow", true)) {
+
+ this.extensions.selectRow.selectRows(rows);
+ }
+ },
+
+ deselectRow: function deselectRow(rows) {
+
+ if (this.extExists("selectRow", true)) {
+
+ this.extensions.selectRow.deselectRows(rows);
+ }
+ },
+
+ toggleSelectRow: function toggleSelectRow(row) {
+
+ if (this.extExists("selectRow", true)) {
+
+ this.extensions.selectRow.toggleRow(row);
+ }
+ },
+
+ getSelectedRows: function getSelectedRows() {
+
+ if (this.extExists("selectRow", true)) {
+
+ return this.extensions.selectRow.getSelectedRows();
+ }
+ },
+
+ getSelectedData: function getSelectedData() {
+
+ if (this.extExists("selectRow", true)) {
+
+ return this.extensions.selectRow.getSelectedData();
+ }
+ },
+
+ //////////// Pagination Functions ////////////
+
+
+ setMaxPage: function setMaxPage(max) {
+
+ if (this.options.pagination && this.extExists("page")) {
+
+ this.extensions.page.setMaxPage(max);
+ } else {
+
+ return false;
+ }
+ },
+
+ setPage: function setPage(page) {
+
+ if (this.options.pagination && this.extExists("page")) {
+
+ this.extensions.page.setPage(page);
+ } else {
+
+ return false;
+ }
+ },
+
+ setPageSize: function setPageSize(size) {
+
+ if (this.options.pagination && this.extExists("page")) {
+
+ this.extensions.page.setPageSize(size);
+
+ this.extensions.page.setPage(1);
+ } else {
+
+ return false;
+ }
+ },
+
+ getPageSize: function getPageSize() {
+
+ if (this.options.pagination && this.extExists("page", true)) {
+
+ return this.extensions.page.getPageSize();
+ }
+ },
+
+ previousPage: function previousPage() {
+
+ if (this.options.pagination && this.extExists("page")) {
+
+ this.extensions.page.previousPage();
+ } else {
+
+ return false;
+ }
+ },
+
+ nextPage: function nextPage() {
+
+ if (this.options.pagination && this.extExists("page")) {
+
+ this.extensions.page.nextPage();
+ } else {
+
+ return false;
+ }
+ },
+
+ getPage: function getPage() {
+
+ if (this.options.pagination && this.extExists("page")) {
+
+ return this.extensions.page.getPage();
+ } else {
+
+ return false;
+ }
+ },
+
+ getPageMax: function getPageMax() {
+
+ if (this.options.pagination && this.extExists("page")) {
+
+ return this.extensions.page.getPageMax();
+ } else {
+
+ return false;
+ }
+ },
+
+ ///////////////// Grouping Functions ///////////////
+
+
+ setGroupBy: function setGroupBy(groups) {
+
+ if (this.extExists("groupRows", true)) {
+
+ this.options.groupBy = groups;
+
+ this.extensions.groupRows.initialize();
+
+ this.rowManager.refreshActiveData();
+ } else {
+
+ return false;
+ }
+ },
+
+ setGroupStartOpen: function setGroupStartOpen(values) {
+
+ if (this.extExists("groupRows", true)) {
+
+ this.options.groupStartOpen = values;
+
+ this.extensions.groupRows.initialize();
+
+ if (this.options.groupBy) {
+
+ this.rowManager.refreshActiveData();
+ } else {
+
+ console.warn("Grouping Update - cant refresh view, no groups have been set");
+ }
+ } else {
+
+ return false;
+ }
+ },
+
+ setGroupHeader: function setGroupHeader(values) {
+
+ if (this.extExists("groupRows", true)) {
+
+ this.options.groupHeader = values;
+
+ this.extensions.groupRows.initialize();
+
+ if (this.options.groupBy) {
+
+ this.rowManager.refreshActiveData();
+ } else {
+
+ console.warn("Grouping Update - cant refresh view, no groups have been set");
+ }
+ } else {
+
+ return false;
+ }
+ },
+
+ getGroups: function getGroups(values) {
+
+ if (this.extExists("groupRows", true)) {
+
+ return this.extensions.groupRows.getGroups();
+ } else {
+
+ return false;
+ }
+ },
+
+ /////////////// Navigation Management //////////////
+
+
+ navigatePrev: function navigatePrev() {
+
+ var cell = false;
+
+ if (this.table.extExists("edit", true)) {
+
+ cell = this.table.extensions.edit.currentCell;
+
+ if (cell) {
+
+ e.preventDefault();
+
+ return cell.nav().prev();
+ }
+ }
+
+ return false;
+ },
+
+ navigateNext: function navigateNext() {
+
+ var cell = false;
+
+ if (this.table.extExists("edit", true)) {
+
+ cell = this.table.extensions.edit.currentCell;
+
+ if (cell) {
+
+ e.preventDefault();
+
+ return cell.nav().next();
+ }
+ }
+
+ return false;
+ },
+
+ navigateLeft: function navigateLeft() {
+
+ var cell = false;
+
+ if (this.table.extExists("edit", true)) {
+
+ cell = this.table.extensions.edit.currentCell;
+
+ if (cell) {
+
+ e.preventDefault();
+
+ return cell.nav().left();
+ }
+ }
+
+ return false;
+ },
+
+ navigateRight: function navigateRight() {
+
+ var cell = false;
+
+ if (this.table.extExists("edit", true)) {
+
+ cell = this.table.extensions.edit.currentCell;
+
+ if (cell) {
+
+ e.preventDefault();
+
+ return cell.nav().right();
+ }
+ }
+
+ return false;
+ },
+
+ navigateUp: function navigateUp() {
+
+ var cell = false;
+
+ if (this.table.extExists("edit", true)) {
+
+ cell = this.table.extensions.edit.currentCell;
+
+ if (cell) {
+
+ e.preventDefault();
+
+ return cell.nav().up();
+ }
+ }
+
+ return false;
+ },
+
+ navigateDown: function navigateDown() {
+
+ var cell = false;
+
+ if (this.table.extExists("edit", true)) {
+
+ cell = this.table.extensions.edit.currentCell;
+
+ if (cell) {
+
+ e.preventDefault();
+
+ return cell.nav().dpwn();
+ }
+ }
+
+ return false;
+ },
+
+ /////////////// History Management //////////////
+
+ undo: function undo() {
+
+ if (this.options.history && this.extExists("history", true)) {
+
+ return this.extensions.history.undo();
+ } else {
+
+ return false;
+ }
+ },
+
+ redo: function redo() {
+
+ if (this.options.history && this.extExists("history", true)) {
+
+ return this.extensions.history.redo();
+ } else {
+
+ return false;
+ }
+ },
+
+ /////////////// Download Management //////////////
+
+
+ download: function download(type, filename, options) {
+
+ if (this.extExists("download", true)) {
+
+ this.extensions.download.download(type, filename, options);
+ }
+ },
+
+ ////////////// Extension Management //////////////
+
+
+ //object to hold extensions
+
+ extensions: {},
+
+ extensionBindings: {},
+
+ //extend extension
+
+ extendExtension: function extendExtension(name, property, values) {
+
+ if (this.extensionBindings[name]) {
+
+ var source = this.extensionBindings[name].prototype[property];
+
+ if (source) {
+
+ if ((typeof values === 'undefined' ? 'undefined' : _typeof(values)) == "object") {
+
+ for (var key in values) {
+
+ source[key] = values[key];
+ }
+ } else {
+
+ console.warn("Extension Error - Invalid value type, it must be an object");
+ }
+ } else {
+
+ console.warn("Extension Error - property does not exist:", property);
+ }
+ } else {
+
+ console.warn("Extension Error - extension does not exist:", name);
+ }
+ },
+
+ //add extension to tabulator
+
+ registerExtension: function registerExtension(name, extension) {
+
+ var self = this;
+
+ this.extensionBindings[name] = extension;
+ },
+
+ //ensure that extensions are bound to instantiated function
+
+ bindExtensions: function bindExtensions() {
+
+ var self = this;
+
+ this.extensions = {};
+
+ for (var name in self.extensionBindings) {
+
+ self.extensions[name] = new self.extensionBindings[name](self);
+ }
+ },
+
+ //Check for plugin
+
+ extExists: function extExists(plugin, required) {
+
+ if (this.extensions[plugin]) {
+
+ return true;
+ } else {
+
+ if (required) {
+
+ console.error("Tabulator Plugin Not Installed: " + plugin);
+ }
+
+ return false;
+ }
+ }
+
+ };
+
+ var Layout = function Layout(table) {
+
+ this.table = table;
+
+ this.mode = null;
+ };
+
+ //initialize layout system
+
+
+ Layout.prototype.initialize = function (layout) {
+
+ if (this.modes[layout]) {
+
+ this.mode = layout;
+ } else {
+
+ console.warn("Layout Error - invalid mode set, defaulting to 'fitData' : " + layout);
+
+ this.mode = 'fitData';
+ }
+
+ this.table.element.attr("tabulator-layout", this.mode);
+ };
+
+ Layout.prototype.getMode = function () {
+
+ return this.mode;
+ };
+
+ //trigger table layout
+
+
+ Layout.prototype.layout = function () {
+
+ this.modes[this.mode].call(this, this.table.columnManager.columnsByIndex);
+ };
+
+ //layout render functions
+
+
+ Layout.prototype.modes = {
+
+ //resize columns to fit data the contain
+
+
+ "fitData": function fitData(columns) {
+
+ columns.forEach(function (column) {
+
+ column.reinitializeWidth();
+ });
+
+ if (this.table.options.responsiveLayout && this.table.extExists("responsiveLayout", true)) {
+
+ this.table.extensions.responsiveLayout.update();
+ }
+ },
+
+ //resize columns to fit data the contain
+
+
+ "fitDataFill": function fitDataFill(columns) {
+
+ columns.forEach(function (column) {
+
+ column.reinitializeWidth();
+ });
+
+ if (this.table.options.responsiveLayout && this.table.extExists("responsiveLayout", true)) {
+
+ this.table.extensions.responsiveLayout.update();
+ }
+ },
+
+ //resize columns to fit
+
+
+ "fitColumns": function fitColumns(columns) {
+
+ var self = this;
+
+ var totalWidth = self.table.element.innerWidth(); //table element width
+
+
+ var fixedWidth = 0; //total width of columns with a defined width
+
+
+ var flexWidth = 0; //total width available to flexible columns
+
+
+ var flexColWidth = 0; //desired width of flexible columns
+
+
+ var flexColumns = []; //array of flexible width columns
+
+
+ var gapFill = 0; //number of pixels to be added to final column to close and half pixel gaps
+
+
+ //ensure columns resize to take up the correct amount of space
+
+
+ function scaleColumns(columns, freeSpace, colWidth) {
+
+ var oversizeCols = [],
+ oversizeSpace = 0,
+ remainingSpace = 0,
+ nextColWidth = 0,
+ gap = 0,
+ undersizeCols = [];
+
+ columns.forEach(function (column, i) {
+
+ if (column.minWidth >= colWidth) {
+
+ oversizeCols.push(column);
+ } else {
+
+ undersizeCols.push(column);
+ }
+ });
+
+ if (oversizeCols.length) {
+
+ oversizeCols.forEach(function (column) {
+
+ oversizeSpace += column.minWidth;
+
+ column.setWidth(column.minWidth);
+ });
+
+ remainingSpace = freeSpace - oversizeSpace;
+
+ nextColWidth = undersizeCols.length ? Math.floor(remainingSpace / undersizeCols.length) : remainingSpace;
+
+ gap = remainingSpace - nextColWidth * undersizeCols.length;
+
+ gap += scaleColumns(undersizeCols, remainingSpace, nextColWidth);
+ } else {
+
+ gap = undersizeCols.length ? freeSpace - Math.floor(freeSpace / undersizeCols.length) * undersizeCols.length : freeSpace;
+
+ undersizeCols.forEach(function (column) {
+
+ column.setWidth(colWidth);
+ });
+ }
+
+ return gap;
+ }
+
+ if (this.table.options.responsiveLayout && this.table.extExists("responsiveLayout", true)) {
+
+ this.table.extensions.responsiveLayout.update();
+ }
+
+ //adjust for vertical scrollbar if present
+
+
+ if (this.table.rowManager.element[0].scrollHeight > this.table.rowManager.element.innerHeight()) {
+
+ totalWidth -= this.table.rowManager.element[0].offsetWidth - this.table.rowManager.element[0].clientWidth;
+ }
+
+ columns.forEach(function (column) {
+
+ var width, minWidth, colWidth;
+
+ if (column.visible) {
+
+ width = column.definition.width;
+
+ minWidth = parseInt(column.minWidth);
+
+ if (width) {
+
+ if (typeof width == "string") {
+
+ if (width.indexOf("%") > -1) {
+
+ colWidth = totalWidth / 100 * parseInt(width);
+ } else {
+
+ colWidth = parseInt(width);
+ }
+ } else {
+
+ colWidth = width;
+ }
+
+ fixedWidth += colWidth > minWidth ? colWidth : minWidth;
+ } else {
+
+ flexColumns.push(column);
+ }
+ }
+ });
+
+ //calculate available space
+
+
+ flexWidth = totalWidth - fixedWidth;
+
+ //calculate correct column size
+
+
+ flexColWidth = Math.floor(flexWidth / flexColumns.length);
+
+ //generate column widths
+
+
+ var gapFill = scaleColumns(flexColumns, flexWidth, flexColWidth);
+
+ //increase width of last column to account for rounding errors
+
+
+ if (flexColumns.length) {
+
+ flexColumns[flexColumns.length - 1].setWidth(flexColumns[flexColumns.length - 1].getWidth() + gapFill);
+ }
+ }
+
+ };
+
+ Tabulator.registerExtension("layout", Layout);
+
+ var Localize = function Localize(table) {
+
+ this.table = table; //hold Tabulator object
+
+ this.locale = "default"; //current locale
+
+ this.lang = false; //current language
+
+ this.bindings = {}; //update events to call when locale is changed
+ };
+
+ //set header placehoder
+
+ Localize.prototype.setHeaderFilterPlaceholder = function (placeholder) {
+
+ this.langs.default.headerFilters.default = placeholder;
+ };
+
+ //set header filter placeholder by column
+
+ Localize.prototype.setHeaderFilterColumnPlaceholder = function (column, placeholder) {
+
+ this.langs.default.headerFilters.columns[column] = placeholder;
+
+ if (this.lang && !this.lang.headerFilters.columns[column]) {
+
+ this.lang.headerFilters.columns[column] = placeholder;
+ }
+ };
+
+ //setup a lang description object
+
+ Localize.prototype.installLang = function (locale, lang) {
+
+ if (this.langs[locale]) {
+
+ this._setLangProp(this.langs[locale], lang);
+ } else {
+
+ this.langs[locale] = lang;
+ }
+ };
+
+ Localize.prototype._setLangProp = function (lang, values) {
+
+ for (var key in values) {
+
+ if (lang[key] && _typeof(lang[key]) == "object") {
+
+ this._setLangProp(lang[key], values[key]);
+ } else {
+
+ lang[key] = values[key];
+ }
+ }
+ };
+
+ //set current locale
+
+ Localize.prototype.setLocale = function (desiredLocale) {
+
+ var self = this;
+
+ desiredLocale = desiredLocale || "default";
+
+ //fill in any matching languge values
+
+ function traverseLang(trans, path) {
+
+ for (var prop in trans) {
+
+ if (_typeof(trans[prop]) == "object") {
+
+ if (!path[prop]) {
+
+ path[prop] = {};
+ }
+
+ traverseLang(trans[prop], path[prop]);
+ } else {
+
+ path[prop] = trans[prop];
+ }
+ }
+ }
+
+ //determing correct locale to load
+
+ if (desiredLocale === true && navigator.language) {
+
+ //get local from system
+
+ desiredLocale = navigator.language.toLowerCase();
+ }
+
+ if (desiredLocale) {
+
+ //if locale is not set, check for matching top level locale else use default
+
+ if (!self.langs[desiredLocale]) {
+
+ var prefix = desiredLocale.split("-")[0];
+
+ if (self.langs[prefix]) {
+
+ console.warn("Localization Error - Exact matching locale not found, using closest match: ", desiredLocale, prefix);
+
+ desiredLocale = prefix;
+ } else {
+
+ console.warn("Localization Error - Matching locale not found, using default: ", desiredLocale);
+
+ desiredLocale = "default";
+ }
+ }
+ }
+
+ self.locale = desiredLocale;
+
+ //load default lang template
+
+ self.lang = $.extend(true, {}, self.langs.default);
+
+ if (desiredLocale != "default") {
+
+ traverseLang(self.langs[desiredLocale], self.lang);
+ }
+
+ self.table.options.localized(self.locale, self.lang);
+
+ self._executeBindings();
+ };
+
+ //get current locale
+
+ Localize.prototype.getLocale = function (locale) {
+
+ return self.locale;
+ };
+
+ //get lang object for given local or current if none provided
+
+ Localize.prototype.getLang = function (locale) {
+
+ return locale ? this.langs[locale] : this.lang;
+ };
+
+ //get text for current locale
+
+ Localize.prototype.getText = function (path, value) {
+
+ var path = value ? path + "." + value : path,
+ pathArray = path.split("."),
+ text = this._getLangElement(pathArray, this.locale);
+
+ // if(text === false){
+
+ // console.warn("Localization Error - Matching localized text not found for given path: ", path);
+
+ // }
+
+
+ return text || "";
+ };
+
+ //traverse langs object and find localized copy
+
+ Localize.prototype._getLangElement = function (path, locale) {
+
+ var self = this;
+
+ var root = self.lang;
+
+ path.forEach(function (level) {
+
+ var rootPath;
+
+ if (root) {
+
+ rootPath = root[level];
+
+ if (typeof rootPath != "undefined") {
+
+ root = rootPath;
+ } else {
+
+ root = false;
+ }
+ }
+ });
+
+ return root;
+ };
+
+ //set update binding
+
+ Localize.prototype.bind = function (path, callback) {
+
+ if (!this.bindings[path]) {
+
+ this.bindings[path] = [];
+ }
+
+ this.bindings[path].push(callback);
+
+ callback(this.getText(path), this.lang);
+ };
+
+ //itterate through bindings and trigger updates
+
+ Localize.prototype._executeBindings = function () {
+
+ var self = this;
+
+ var _loop = function _loop(path) {
+
+ self.bindings[path].forEach(function (binding) {
+
+ binding(self.getText(path), self.lang);
+ });
+ };
+
+ for (var path in self.bindings) {
+ _loop(path);
+ }
+ };
+
+ //Localized text listings
+
+ Localize.prototype.langs = {
+
+ "default": { //hold default locale text
+
+ "groups": {
+
+ "item": "item",
+
+ "items": "items"
+
+ },
+
+ "columns": {},
+
+ "ajax": {
+
+ "loading": "Loading",
+
+ "error": "Error"
+
+ },
+
+ "pagination": {
+
+ "first": "First",
+
+ "first_title": "First Page",
+
+ "last": "Last",
+
+ "last_title": "Last Page",
+
+ "prev": "Prev",
+
+ "prev_title": "Prev Page",
+
+ "next": "Next",
+
+ "next_title": "Next Page"
+
+ },
+
+ "headerFilters": {
+
+ "default": "filter column...",
+
+ "columns": {}
+
+ }
+
+ }
+
+ };
+
+ Tabulator.registerExtension("localize", Localize);
+
+ var Accessor = function Accessor(table) {
+
+ this.table = table; //hold Tabulator object
+
+ };
+
+ //initialize column accessor
+
+
+ Accessor.prototype.initializeColumn = function (column) {
+
+ var config = { accessor: false, params: column.definition.accessorParams || {} };
+
+ //set column accessor
+
+
+ switch (_typeof(column.definition.accessor)) {
+
+ case "string":
+
+ if (this.accessors[column.definition.accessor]) {
+
+ config.accessor = this.accessors[column.definition.accessor];
+ } else {
+
+ console.warn("Accessor Error - No such accessor found, ignoring: ", column.definition.accessor);
+ }
+
+ break;
+
+ case "function":
+
+ config.accessor = column.definition.accessor;
+
+ break;
+
+ }
+
+ if (config.accessor) {
+
+ column.extensions.accessor = config;
+ }
+ },
+
+ //apply accessor to row
+
+
+ Accessor.prototype.transformRow = function (dataIn) {
+
+ var self = this;
+
+ //clone data object with deep copy to isolate internal data from returned result
+
+
+ var data = $.extend(true, {}, dataIn || {});
+
+ self.table.columnManager.traverse(function (column) {
+
+ var field;
+
+ if (column.extensions.accessor) {
+
+ field = column.getField();
+
+ if (typeof data[field] != "undefined") {
+
+ column.setFieldValue(data, column.extensions.accessor.accessor(column.getFieldValue(data), data, column.extensions.accessor.params));
+ }
+ }
+ });
+
+ return data;
+ },
+
+ //default accessors
+
+
+ Accessor.prototype.accessors = {};
+
+ Tabulator.registerExtension("accessor", Accessor);
+
+ var Ajax = function Ajax(table) {
+
+ this.table = table; //hold Tabulator object
+
+
+ this.config = false; //hold config object for ajax request
+
+
+ this.url = ""; //request URL
+
+
+ this.params = false; //request parameters
+
+
+ this.loaderElement = $(""); //loader message div
+
+
+ this.msgElement = $(""); //message element
+
+
+ this.loadingElement = false;
+
+ this.errorElement = false;
+ };
+
+ //initialize setup options
+
+
+ Ajax.prototype.initialize = function () {
+
+ this.loaderElement.append(this.msgElement);
+
+ if (this.table.options.ajaxLoaderLoading) {
+
+ this.loadingElement = this.table.options.ajaxLoaderLoading;
+ }
+
+ if (this.table.options.ajaxLoaderError) {
+
+ this.errorElement = this.table.options.ajaxLoaderError;
+ }
+
+ if (this.table.options.ajaxParams) {
+
+ this.setParams(this.table.options.ajaxParams);
+ }
+
+ if (this.table.options.ajaxConfig) {
+
+ this.setConfig(this.table.options.ajaxConfig);
+ }
+
+ if (this.table.options.ajaxURL) {
+
+ this.setUrl(this.table.options.ajaxURL);
+ }
+ };
+
+ //set ajax params
+
+
+ Ajax.prototype.setParams = function (params, update) {
+
+ if (update) {
+
+ this.params = this.params || {};
+
+ for (var key in params) {
+
+ this.params[key] = params[key];
+ }
+ } else {
+
+ this.params = params;
+ }
+ };
+
+ Ajax.prototype.getParams = function () {
+
+ return this.params || {};
+ };
+
+ //load config object
+
+
+ Ajax.prototype.setConfig = function (config) {
+
+ this._loadDefaultConfig();
+
+ if (typeof config == "string") {
+
+ this.config.type = config;
+ } else {
+
+ for (var key in config) {
+
+ this.config[key] = config[key];
+ }
+ }
+ };
+
+ //create config object from default
+
+
+ Ajax.prototype._loadDefaultConfig = function (force) {
+
+ var self = this;
+
+ if (!self.config || force) {
+
+ self.config = {};
+
+ //load base config from defaults
+
+
+ for (var key in self.defaultConfig) {
+
+ self.config[key] = self.defaultConfig[key];
+ }
+ }
+ };
+
+ //set request url
+
+
+ Ajax.prototype.setUrl = function (url) {
+
+ this.url = url;
+ };
+
+ //get request url
+
+
+ Ajax.prototype.getUrl = function () {
+
+ return this.url;
+ };
+
+ //send ajax request
+
+
+ Ajax.prototype.sendRequest = function (callback) {
+
+ var self = this;
+
+ if (self.url) {
+
+ self._loadDefaultConfig();
+
+ self.config.url = self.url;
+
+ if (self.params) {
+
+ self.config.data = self.params;
+ }
+
+ if (self.table.options.ajaxRequesting(self.url, self.params) !== false) {
+
+ self.showLoader();
+
+ $.ajax(self.config).done(function (data) {
+
+ if (self.table.options.ajaxResponse) {
+
+ data = self.table.options.ajaxResponse(self.url, self.params, data);
+ }
+
+ self.table.options.dataLoaded(data);
+
+ callback(data);
+
+ self.hideLoader();
+ }).fail(function (xhr, textStatus, errorThrown) {
+
+ console.error("Ajax Load Error - Connection Error: " + xhr.status, errorThrown);
+
+ self.table.options.ajaxError(xhr, textStatus, errorThrown);
+
+ self.showError();
+
+ setTimeout(function () {
+
+ self.hideLoader();
+ }, 3000);
+ });
+ }
+ } else {
+
+ console.warn("Ajax Load Error - No URL Set");
+
+ return false;
+ }
+ };
+
+ Ajax.prototype.showLoader = function () {
+
+ this.loaderElement.detach();
+
+ this.msgElement.empty().removeClass("tabulator-error").addClass("tabulator-loading");
+
+ if (this.loadingElement) {
+
+ this.msgElement.append(this.loadingElement);
+ } else {
+
+ this.msgElement.append(this.table.extensions.localize.getText("ajax.loading"));
+ }
+
+ this.table.element.append(this.loaderElement);
+ };
+
+ Ajax.prototype.showError = function () {
+
+ this.loaderElement.detach();
+
+ this.msgElement.empty().removeClass("tabulator-loading").addClass("tabulator-error");
+
+ if (this.errorElement) {
+
+ this.msgElement.append(this.errorElement);
+ } else {
+
+ this.msgElement.append(this.table.extensions.localize.getText("ajax.error"));
+ }
+
+ this.table.element.append(this.loaderElement);
+ };
+
+ Ajax.prototype.hideLoader = function () {
+
+ this.loaderElement.detach();
+ };
+
+ //default ajax config object
+
+
+ Ajax.prototype.defaultConfig = {
+
+ url: "",
+
+ type: "GET",
+
+ async: true,
+
+ dataType: "json",
+
+ success: function success(data) {}
+
+ };
+
+ Tabulator.registerExtension("ajax", Ajax);
+
+ var ColumnCalcs = function ColumnCalcs(table) {
+
+ this.table = table; //hold Tabulator object
+
+
+ this.topCalcs = [];
+
+ this.botCalcs = [];
+
+ this.genColumn = false;
+
+ this.topElement = $("");
+
+ this.botElement = $("");
+
+ this.topRow = false;
+
+ this.botRow = false;
+
+ this.topInitialized = false;
+
+ this.botInitialized = false;
+
+ this.initialize();
+ };
+
+ ColumnCalcs.prototype.initialize = function () {
+
+ this.genColumn = new Column({ field: "value" }, this);
+ };
+
+ //dummy functions to handle being mock column manager
+
+
+ ColumnCalcs.prototype.registerColumnField = function () {};
+
+ //initialize column calcs
+
+
+ ColumnCalcs.prototype.initializeColumn = function (column) {
+
+ var def = column.definition;
+
+ var config = {
+
+ topCalcParams: def.topCalcParams || {},
+
+ botCalcParams: def.bottomCalcParams || {}
+
+ };
+
+ if (def.topCalc) {
+
+ switch (_typeof(def.topCalc)) {
+
+ case "string":
+
+ if (this.calculations[def.topCalc]) {
+
+ config.topCalc = this.calculations[def.topCalc];
+ } else {
+
+ console.warn("Column Calc Error - No such calculation found, ignoring: ", def.topCalc);
+ }
+
+ break;
+
+ case "function":
+
+ config.topCalc = def.topCalc;
+
+ break;
+
+ }
+
+ if (config.topCalc) {
+
+ column.extensions.columnCalcs = config;
+
+ this.topCalcs.push(column);
+
+ if (!this.table.options.groupBy) {
+
+ this.initializeTopRow();
+ }
+ }
+ }
+
+ if (def.bottomCalc) {
+
+ switch (_typeof(def.bottomCalc)) {
+
+ case "string":
+
+ if (this.calculations[def.bottomCalc]) {
+
+ config.botCalc = this.calculations[def.bottomCalc];
+ } else {
+
+ console.warn("Column Calc Error - No such calculation found, ignoring: ", def.bottomCalc);
+ }
+
+ break;
+
+ case "function":
+
+ config.botCalc = def.bottomCalc;
+
+ break;
+
+ }
+
+ if (config.botCalc) {
+
+ column.extensions.columnCalcs = config;
+
+ this.botCalcs.push(column);
+
+ if (!this.table.options.groupBy) {
+
+ this.initializeBottomRow();
+ }
+ }
+ }
+ };
+
+ ColumnCalcs.prototype.removeCalcs = function () {
+
+ var changed = false;
+
+ if (this.topInitialized) {
+
+ this.topInitialized = false;
+
+ this.topElement.remove();
+
+ changed = true;
+ }
+
+ if (this.botInitialized) {
+
+ this.botInitialized = false;
+
+ this.table.footerManager.remove(this.botElement);
+
+ changed = true;
+ }
+
+ if (changed) {
+
+ this.table.rowManager.adjustTableSize();
+ }
+ };
+
+ ColumnCalcs.prototype.initializeTopRow = function () {
+
+ if (!this.topInitialized) {
+
+ this.table.columnManager.element.append(this.topElement);
+
+ this.topInitialized = true;
+ }
+ };
+
+ ColumnCalcs.prototype.initializeBottomRow = function () {
+
+ if (!this.botInitialized) {
+
+ this.table.footerManager.prepend(this.botElement);
+
+ this.botInitialized = true;
+ }
+ };
+
+ ColumnCalcs.prototype.scrollHorizontal = function (left) {
+
+ var hozAdjust = 0,
+ scrollWidth = this.table.columnManager.element[0].scrollWidth - this.table.element.innerWidth();
+
+ if (this.botInitialized) {
+
+ this.botRow.getElement().css("margin-left", -left);
+ }
+ };
+
+ ColumnCalcs.prototype.recalc = function (rows) {
+
+ var data, row;
+
+ if (this.topInitialized || this.botInitialized) {
+
+ data = this.rowsToData(rows);
+
+ if (this.topInitialized) {
+
+ row = this.generateRow("top", this.rowsToData(rows));
+
+ this.topRow = row;
+
+ this.topElement.empty();
+
+ this.topElement.append(row.getElement());
+
+ row.initialize(true);
+ }
+
+ if (this.botInitialized) {
+
+ row = this.generateRow("bottom", this.rowsToData(rows));
+
+ this.botRow = row;
+
+ this.botElement.empty();
+
+ this.botElement.append(row.getElement());
+
+ row.initialize(true);
+ }
+
+ this.table.rowManager.adjustTableSize();
+
+ //set resizable handles
+
+
+ if (this.table.extExists("frozenColumns")) {
+
+ this.table.extensions.frozenColumns.layout();
+ }
+ }
+ };
+
+ ColumnCalcs.prototype.recalcRowGroup = function (row) {
+
+ var data, rowData;
+
+ var group = this.table.extensions.groupRows.getRowGroup(row);
+
+ if (group.calcs.bottom) {
+
+ data = this.rowsToData(group.rows);
+
+ rowData = this.generateRowData("bottom", data);
+
+ group.calcs.bottom.updateData(rowData);
+ }
+
+ if (group.calcs.top) {
+
+ data = this.rowsToData(group.rows);
+
+ rowData = this.generateRowData("top", data);
+
+ group.calcs.top.updateData(rowData);
+ }
+ };
+
+ //generate top stats row
+
+
+ ColumnCalcs.prototype.generateTopRow = function (rows) {
+
+ return this.generateRow("top", this.rowsToData(rows));
+ };
+
+ //generate bottom stats row
+
+
+ ColumnCalcs.prototype.generateBottomRow = function (rows) {
+
+ return this.generateRow("bottom", this.rowsToData(rows));
+ };
+
+ ColumnCalcs.prototype.rowsToData = function (rows) {
+
+ var data = [];
+
+ rows.forEach(function (row) {
+
+ data.push(row.getData());
+ });
+
+ return data;
+ };
+
+ //generate stats row
+
+
+ ColumnCalcs.prototype.generateRow = function (pos, data) {
+
+ var self = this,
+ rowData = this.generateRowData(pos, data),
+ row = new Row(rowData, this);
+
+ row.getElement().addClass("tabulator-calcs").addClass("tabulator-calcs-" + pos);
+
+ row.type = "calc";
+
+ row.generateCells = function () {
+
+ var cells = [];
+
+ self.table.columnManager.columnsByIndex.forEach(function (column) {
+
+ if (column.visible) {
+
+ //set field name of mock column
+
+
+ self.genColumn.setField(column.getField());
+
+ self.genColumn.hozAlign = column.hozAlign;
+
+ if (column.definition[pos + "CalcFormatter"] && self.table.extExists("format")) {
+
+ self.genColumn.extensions.format = {
+
+ formatter: self.table.extensions.format.getFormatter(column.definition[pos + "CalcFormatter"]),
+
+ params: column.definition[pos + "CalcFormatterParams"]
+
+ };
+ } else {
+
+ self.genColumn.extensions.format = {
+
+ formatter: self.table.extensions.format.getFormatter("plaintext"),
+
+ params: {}
+
+ };
+ }
+
+ //generate cell and assign to correct column
+
+
+ var cell = new Cell(self.genColumn, row);
+
+ cell.column = column;
+
+ cell.setWidth(column.getWidth());
+
+ column.cells.push(cell);
+
+ cells.push(cell);
+ }
+ });
+
+ this.cells = cells;
+ };
+
+ return row;
+ };
+
+ //generate stats row
+
+
+ ColumnCalcs.prototype.generateRowData = function (pos, data) {
+
+ var rowData = {},
+ calcs = pos == "top" ? this.topCalcs : this.botCalcs,
+ type = pos == "top" ? "topCalc" : "botCalc";
+
+ calcs.forEach(function (column) {
+
+ var values = [];
+
+ if (column.extensions.columnCalcs && column.extensions.columnCalcs[type]) {
+
+ data.forEach(function (item) {
+
+ values.push(column.getFieldValue(item));
+ });
+
+ column.setFieldValue(rowData, column.extensions.columnCalcs[type](values, data, column.extensions.columnCalcs[type + "Params"]));
+ }
+ });
+
+ return rowData;
+ };
+
+ ColumnCalcs.prototype.hasTopCalcs = function () {
+
+ return !!this.topCalcs.length;
+ }, ColumnCalcs.prototype.hasBottomCalcs = function () {
+
+ return !!this.botCalcs.length;
+ },
+
+ //handle table redraw
+
+
+ ColumnCalcs.prototype.redraw = function () {
+
+ if (this.topRow) {
+
+ this.topRow.normalizeHeight(true);
+ }
+
+ if (this.botRow) {
+
+ this.botRow.normalizeHeight(true);
+ }
+ };
+
+ //default calculations
+
+
+ ColumnCalcs.prototype.calculations = {
+
+ "avg": function avg(values, data, calcParams) {
+
+ var output = 0,
+ precision = typeof calcParams.precision !== "undefined" ? calcParams.precision : 2;
+
+ if (values.length) {
+
+ output = values.reduce(function (sum, value) {
+
+ value = Number(value);
+
+ return sum + value;
+ });
+
+ output = output / values.length;
+
+ output = precision !== false ? output.toFixed(precision) : output;
+ }
+
+ return parseFloat(output).toString();
+ },
+
+ "max": function max(values, data, calcParams) {
+
+ var output = null;
+
+ values.forEach(function (value) {
+
+ value = Number(value);
+
+ if (value > output || output === null) {
+
+ output = value;
+ }
+ });
+
+ return output !== null ? output : "";
+ },
+
+ "min": function min(values, data, calcParams) {
+
+ var output = null;
+
+ values.forEach(function (value) {
+
+ value = Number(value);
+
+ if (value < output || output === null) {
+
+ output = value;
+ }
+ });
+
+ return output !== null ? output : "";
+ },
+
+ "sum": function sum(values, data, calcParams) {
+
+ var output = 0;
+
+ if (values.length) {
+
+ values.forEach(function (value) {
+
+ value = Number(value);
+
+ output += !isNaN(value) ? Number(value) : 0;
+ });
+ }
+
+ return output;
+ },
+
+ "concat": function concat(values, data, calcParams) {
+
+ var output = 0;
+
+ if (values.length) {
+
+ output = values.reduce(function (sum, value) {
+
+ return String(sum) + String(value);
+ });
+ }
+
+ return output;
+ },
+
+ "count": function count(values, data, calcParams) {
+
+ var output = 0;
+
+ if (values.length) {
+
+ values.forEach(function (value) {
+
+ if (value) {
+
+ output++;
+ }
+ });
+ }
+
+ return output;
+ }
+
+ };
+
+ Tabulator.registerExtension("columnCalcs", ColumnCalcs);
+
+ var Download = function Download(table) {
+
+ this.table = table; //hold Tabulator object
+
+
+ this.fields = {}; //hold filed multi dimension arrays
+
+ };
+
+ //trigger file download
+
+
+ Download.prototype.download = function (type, filename, options) {
+
+ var self = this,
+ downloadFunc = false;
+
+ function buildLink(data, mime) {
+
+ self.triggerDownload(data, mime, type, filename);
+ }
+
+ if (typeof type == "function") {
+
+ downloadFunc = type;
+ } else {
+
+ if (self.downloaders[type]) {
+
+ downloadFunc = self.downloaders[type];
+ } else {
+
+ console.warn("Download Error - No such download type found: ", type);
+ }
+ }
+
+ if (downloadFunc) {
+
+ downloadFunc.call(this, self.processDefinitions(), self.processData(), options, buildLink);
+ }
+ };
+
+ Download.prototype.processDefinitions = function () {
+
+ var self = this,
+ definitions = self.table.columnManager.getDefinitions(),
+ processedDefinitions = [];
+
+ self.fields = {};
+
+ definitions.forEach(function (column) {
+
+ if (column.field) {
+
+ self.fields[column.field] = column.field.split(".");
+
+ if (column.download !== false) {
+
+ //isolate definiton from defintion object
+
+
+ var def = {};
+
+ for (var key in column) {
+
+ def[key] = column[key];
+ }
+
+ if (typeof column.downloadTitle != "undefined") {
+
+ def.title = column.downloadTitle;
+ }
+
+ processedDefinitions.push(def);
+ }
+ }
+ });
+
+ return processedDefinitions;
+ };
+
+ Download.prototype.processData = function () {
+
+ var self = this,
+ data = self.table.rowManager.getData(true);
+
+ //add user data processing step;
+
+
+ if (typeof self.table.options.downloadDataMutator == "function") {
+
+ data = self.table.options.downloadDataMutator(data);
+ }
+
+ return data;
+ };
+
+ Download.prototype.triggerDownload = function (data, mime, type, filename) {
+
+ var element = document.createElement('a'),
+ blob = new Blob([data], { type: mime }),
+ filename = filename || "Tabulator." + (typeof type === "function" ? "txt" : type);
+
+ if (navigator.msSaveOrOpenBlob) {
+
+ navigator.msSaveOrOpenBlob(blob, filename);
+ } else {
+
+ element.setAttribute('href', window.URL.createObjectURL(blob));
+
+ //set file title
+
+
+ element.setAttribute('download', filename);
+
+ //trigger download
+
+
+ element.style.display = 'none';
+
+ document.body.appendChild(element);
+
+ element.click();
+
+ //remove temporary link element
+
+
+ document.body.removeChild(element);
+ }
+ };
+
+ //nested field lookup
+
+
+ Download.prototype.getFieldValue = function (field, data) {
+
+ var dataObj = data,
+ structure = this.fields[field],
+ length = structure.length,
+ output;
+
+ for (var i = 0; i < length; i++) {
+
+ dataObj = dataObj[structure[i]];
+
+ output = dataObj;
+
+ if (!dataObj) {
+
+ break;
+ }
+ }
+
+ return output;
+ };
+
+ //downloaders
+
+
+ Download.prototype.downloaders = {
+
+ csv: function csv(columns, data, options, setFileContents) {
+
+ var self = this,
+ titles = [],
+ fields = [],
+ delimiter = options && options.delimiter ? options.delimiter : ",",
+ fileContents;
+
+ //get field lists
+
+
+ columns.forEach(function (column) {
+
+ if (column.field) {
+
+ titles.push('"' + String(column.title).split('"').join('""') + '"');
+
+ fields.push(column.field);
+ }
+ });
+
+ //generate header row
+
+
+ fileContents = [titles.join(delimiter)];
+
+ //generate each row of the table
+
+
+ data.forEach(function (row) {
+
+ var rowData = [];
+
+ fields.forEach(function (field) {
+
+ var value = self.getFieldValue(field, row);
+
+ switch (typeof value === 'undefined' ? 'undefined' : _typeof(value)) {
+
+ case "object":
+
+ value = JSON.stringify(value);
+
+ break;
+
+ case "undefined":
+
+ case "null":
+
+ value = "";
+
+ break;
+
+ default:
+
+ value = value;
+
+ }
+
+ //escape uotation marks
+
+
+ rowData.push('"' + String(value).split('"').join('""') + '"');
+ });
+
+ fileContents.push(rowData.join(delimiter));
+ });
+
+ setFileContents(fileContents.join("\n"), "text/csv");
+ },
+
+ json: function json(columns, data, options, setFileContents) {
+
+ var fileContents = JSON.stringify(data, null, '\t');
+
+ setFileContents(fileContents, "application/json");
+ },
+
+ xlsx: function xlsx(columns, data, options, setFileContents) {
+
+ var self = this,
+ titles = [],
+ fields = [],
+ rows = [],
+ workbook = { SheetNames: ["Sheet1"], Sheets: {} },
+ worksheet,
+ output;
+
+ //convert rows to worksheet
+
+
+ function rowsToSheet() {
+
+ var sheet = {};
+
+ var range = { s: { c: 0, r: 0 }, e: { c: fields.length, r: rows.length } };
+
+ rows.forEach(function (row, i) {
+
+ row.forEach(function (value, j) {
+
+ var cell = { v: typeof value == "undefined" || value === null ? "" : value };
+
+ if (cell != null) {
+
+ switch (_typeof(cell.v)) {
+
+ case "number":
+
+ cell.t = 'n';
+
+ break;
+
+ case "boolean":
+
+ cell.t = 'b';
+
+ break;
+
+ default:
+
+ cell.t = 's';
+
+ break;
+
+ }
+
+ sheet[XLSX.utils.encode_cell({ c: j, r: i })] = cell;
+ }
+ });
+ });
+
+ sheet['!ref'] = XLSX.utils.encode_range(range);
+
+ return sheet;
+ }
+
+ //convert workbook to binary array
+
+
+ function s2ab(s) {
+
+ var buf = new ArrayBuffer(s.length);
+
+ var view = new Uint8Array(buf);
+
+ for (var i = 0; i != s.length; ++i) {
+ view[i] = s.charCodeAt(i) & 0xFF;
+ }return buf;
+ }
+
+ //get field lists
+
+
+ columns.forEach(function (column) {
+
+ if (column.field) {
+
+ titles.push(column.title);
+
+ fields.push(column.field);
+ }
+ });
+
+ rows.push(titles);
+
+ //generate each row of the table
+
+
+ data.forEach(function (row) {
+
+ var rowData = [];
+
+ fields.forEach(function (field) {
+
+ rowData.push(self.getFieldValue(field, row));
+ });
+
+ rows.push(rowData);
+ });
+
+ worksheet = rowsToSheet();
+
+ workbook.Sheets["Sheet1"] = worksheet;
+
+ output = XLSX.write(workbook, { bookType: 'xlsx', bookSST: true, type: 'binary' });
+
+ setFileContents(s2ab(output), "application/octet-stream");
+ }
+
+ };
+
+ Tabulator.registerExtension("download", Download);
+
+ var Edit = function Edit(table) {
+
+ this.table = table; //hold Tabulator object
+
+
+ this.currentCell = false; //hold currently editing cell
+
+ };
+
+ //initialize column editor
+
+
+ Edit.prototype.initializeColumn = function (column) {
+
+ var self = this,
+ config = {
+
+ editor: false,
+
+ blocked: false,
+
+ check: column.definition.editable,
+
+ params: column.definition.editorParams || {}
+
+ };
+
+ //set column editor
+
+
+ switch (_typeof(column.definition.editor)) {
+
+ case "string":
+
+ if (self.editors[column.definition.editor]) {
+
+ config.editor = self.editors[column.definition.editor];
+ } else {
+
+ console.warn("Editor Error - No such editor found: ", column.definition.editor);
+ }
+
+ break;
+
+ case "function":
+
+ config.editor = column.definition.editor;
+
+ break;
+
+ case "boolean":
+
+ if (column.definition.editor === true) {
+
+ if (typeof column.definition.formatter !== "function") {
+
+ if (self.editors[column.definition.formatter]) {
+
+ config.editor = self.editors[column.definition.formatter];
+ } else {
+
+ config.editor = self.editors["input"];
+ }
+ } else {
+
+ console.warn("Editor Error - Cannot auto lookup editor for a custom formatter: ", column.definition.formatter);
+ }
+ }
+
+ break;
+
+ }
+
+ if (config.editor) {
+
+ column.extensions.edit = config;
+ }
+ };
+
+ Edit.prototype.getCurrentCell = function () {
+
+ return this.currentCell ? this.currentCell.getComponent() : false;
+ };
+
+ Edit.prototype.clearEditor = function (cell) {
+
+ this.currentCell = false;
+
+ cell.getElement().removeClass("tabulator-validation-fail");
+
+ cell.getElement().removeClass("tabulator-editing").empty();
+
+ cell.row.getElement().removeClass("tabulator-row-editing");
+ };
+
+ //return a formatted value for a cell
+
+
+ Edit.prototype.bindEditor = function (cell) {
+
+ var self = this,
+ rendered = function rendered() {},
+ element = cell.getElement(),
+ mouseClick = false;
+
+ //handle successfull value change
+
+
+ function success(value) {
+
+ var valid = true;
+
+ if (cell.column.extensions.validate && self.table.extExists("validate")) {
+
+ valid = self.table.extensions.validate.validate(cell.column.extensions.validate, cell.getComponent(), value);
+ }
+
+ if (valid === true) {
+
+ self.clearEditor(cell);
+
+ cell.setValue(value, true);
+ } else {
+
+ cell.getElement().addClass("tabulator-validation-fail");
+
+ rendered();
+
+ self.table.options.validationFailed(cell.getComponent(), value, valid);
+ }
+ };
+
+ //handle aborted edit
+
+
+ function cancel() {
+
+ self.clearEditor(cell);
+
+ cell.setValueActual(cell.getValue());
+
+ self.table.options.cellEditCancelled(cell.getComponent());
+ };
+
+ element.attr("tabindex", 0);
+
+ element.on("click", function (e) {
+
+ if (!$(this).hasClass("tabulator-editing")) {
+
+ $(this).focus();
+ }
+ });
+
+ element.on("mousedown", function (e) {
+
+ mouseClick = true;
+ });
+
+ element.on("focus", function (e) {
+
+ var allowEdit = true,
+ cellEditor;
+
+ self.currentCell = cell;
+
+ if (mouseClick) {
+
+ mouseClick = false;
+
+ if (cell.column.cellEvents.cellClick) {
+
+ cell.column.cellEvents.cellClick(e, cell.getComponent());
+ }
+ }
+
+ function onRendered(callback) {
+
+ rendered = callback;
+ }
+
+ if (!cell.column.extensions.edit.blocked) {
+
+ e.stopPropagation();
+
+ if (typeof cell.column.extensions.edit.check == "function") {
+
+ allowEdit = cell.column.extensions.edit.check(cell.getComponent());
+ }
+
+ if (allowEdit) {
+
+ self.table.options.cellEditing(cell.getComponent());
+
+ cellEditor = cell.column.extensions.edit.editor.call(self, cell.getComponent(), onRendered, success, cancel, cell.column.extensions.edit.params);
+
+ //if editor returned, add to DOM, if false, abort edit
+
+
+ if (cellEditor !== false) {
+
+ element.addClass("tabulator-editing");
+
+ cell.row.getElement().addClass("tabulator-row-editing");
+
+ element.empty();
+
+ element.append(cellEditor);
+
+ //trigger onRendered Callback
+
+
+ rendered();
+
+ //prevent editing from triggering rowClick event
+
+
+ element.children().click(function (e) {
+
+ e.stopPropagation();
+ });
+ } else {
+
+ element.blur();
+ }
+ } else {
+
+ element.blur();
+ }
+ } else {
+
+ element.blur();
+ }
+ });
+ };
+
+ //default data editors
+
+
+ Edit.prototype.editors = {
+
+ //input element
+
+
+ input: function input(cell, onRendered, success, cancel, editorParams) {
+
+ //create and style input
+
+
+ var input = $("");
+
+ input.css({
+
+ "padding": "4px",
+
+ "width": "100%",
+
+ "box-sizing": "border-box"
+
+ }).val(cell.getValue());
+
+ onRendered(function () {
+
+ input.focus();
+
+ input.css("height", "100%");
+ });
+
+ //submit new value on blur
+
+
+ input.on("change blur", function (e) {
+
+ if (input.val() != cell.getValue()) {
+
+ success(input.val());
+ } else {
+
+ cancel();
+ }
+ });
+
+ //submit new value on enter
+
+
+ input.on("keydown", function (e) {
+
+ if (e.keyCode == 13) {
+
+ success(input.val());
+ }
+
+ if (e.keyCode == 27) {
+
+ cancel();
+ }
+ });
+
+ return input;
+ },
+
+ //resizable text area element
+
+
+ textarea: function textarea(cell, onRendered, success, cancel, editorParams) {
+
+ var self = this,
+ cellValue = cell.getValue(),
+ value = String(typeof cellValue == "null" || typeof cellValue == "undefined" ? "" : cellValue),
+ count = (value.match(/(?:\r\n|\r|\n)/g) || []).length + 1,
+ input = $(""),
+ scrollHeight = 0;
+
+ //create and style input
+
+
+ input.css({
+
+ "display": "block",
+
+ "height": "100%",
+
+ "width": "100%",
+
+ "padding": "2px",
+
+ "box-sizing": "border-box",
+
+ "white-space": "pre-wrap",
+
+ "resize": "none"
+
+ }).val(value);
+
+ onRendered(function () {
+
+ input.focus();
+
+ input.css("height", "100%");
+ });
+
+ //submit new value on blur
+
+
+ input.on("change blur", function (e) {
+
+ if (input.val() != cell.getValue()) {
+
+ success(input.val());
+
+ setTimeout(function () {
+
+ cell.getRow().normalizeHeight();
+ }, 300);
+ } else {
+
+ cancel();
+ }
+ });
+
+ input.on("keyup", function () {
+
+ input.css({ "height": "" });
+
+ var heightNow = input[0].scrollHeight;
+
+ input.css({ "height": heightNow });
+
+ if (heightNow != scrollHeight) {
+
+ scrollHeight = heightNow;
+
+ cell.getRow().normalizeHeight();
+ }
+ });
+
+ input.on("keydown", function (e) {
+
+ if (e.keyCode == 27) {
+
+ cancel();
+ }
+ });
+
+ return input;
+ },
+
+ //input element with type of number
+
+
+ number: function number(cell, onRendered, success, cancel, editorParams) {
+
+ var input = $("");
+
+ //create and style input
+
+
+ input.css({
+
+ "padding": "4px",
+
+ "width": "100%",
+
+ "box-sizing": "border-box"
+
+ }).val(cell.getValue());
+
+ onRendered(function () {
+
+ input.focus();
+
+ input.css("height", "100%");
+ });
+
+ //submit new value on blur
+
+
+ input.on("blur", function (e) {
+
+ var value = input.val();
+
+ if (!isNaN(value)) {
+
+ value = Number(value);
+ }
+
+ if (value != cell.getValue()) {
+
+ success(value);
+ } else {
+
+ cancel();
+ }
+ });
+
+ //submit new value on enter
+
+
+ input.on("keydown", function (e) {
+
+ var value;
+
+ if (e.keyCode == 13) {
+
+ value = input.val();
+
+ if (!isNaN(value)) {
+
+ value = Number(value);
+ }
+
+ success(value);
+ }
+
+ if (e.keyCode == 27) {
+
+ cancel();
+ }
+ });
+
+ return input;
+ },
+
+ //start rating
+
+
+ star: function star(cell, onRendered, success, cancel, editorParams) {
+
+ var element = cell.getElement(),
+ value = cell.getValue(),
+ maxStars = $("svg", element).length || 5,
+ size = $("svg:first", element).attr("width") || 14,
+ stars = $(""),
+ starActive = $(''),
+ starInactive = $('');
+
+ //change number of active stars
+
+
+ var starChange = function starChange(element) {
+
+ if ($(".tabulator-star-active", element.closest("div")).length != element.prevAll("svg").length + 1) {
+
+ element.prevAll("svg").replaceWith(starActive.clone());
+
+ element.nextAll("svg").replaceWith(starInactive.clone());
+
+ element.replaceWith(starActive.clone());
+ }
+ };
+
+ value = parseInt(value) < maxStars ? parseInt(value) : maxStars;
+
+ for (var i = 1; i <= maxStars; i++) {
+
+ var nextStar = i <= value ? starActive : starInactive;
+
+ stars.append(nextStar.clone());
+ }
+
+ stars.on("mouseover", "svg", function (e) {
+
+ e.stopPropagation();
+
+ starChange($(this));
+ });
+
+ stars.on("mouseover", function (e) {
+
+ $("svg", $(this)).replaceWith(starInactive.clone());
+ });
+
+ stars.on("click", function (e) {
+
+ success(0);
+ });
+
+ stars.on("click", "svg", function (e) {
+
+ e.stopPropagation();
+
+ success($(this).prevAll("svg").length + 1);
+ });
+
+ element.css({
+
+ "white-space": "nowrap",
+
+ "overflow": "hidden",
+
+ "text-overflow": "ellipsis"
+
+ });
+
+ element.on("blur", function () {
+
+ cancel();
+ });
+
+ //allow key based navigation
+
+
+ element.on("keydown", function (e) {
+
+ switch (e.keyCode) {
+
+ case 39:
+ //right arrow
+
+
+ starChange($(".tabulator-star-inactive:first", stars));
+
+ break;
+
+ case 37:
+ //left arrow
+
+
+ var prevstar = $(".tabulator-star-active:last", stars).prev("svg");
+
+ if (prevstar.length) {
+
+ starChange(prevstar);
+ } else {
+
+ $("svg", stars).replaceWith(starInactive.clone());
+ }
+
+ break;
+
+ case 13:
+ //enter
+
+
+ success($(".tabulator-star-active", stars).length);
+
+ break;
+
+ case 27:
+ //escape
+
+
+ cancel();
+
+ break;
+
+ }
+ });
+
+ return stars;
+ },
+
+ //draggable progress bar
+
+
+ progress: function progress(cell, onRendered, success, cancel, editorParams) {
+
+ var element = cell.getElement(),
+ max = $("div", element).data("max"),
+ min = $("div", element).data("min"),
+ percent = (max - min) / 100,
+ value = cell.getValue() || 0,
+ handle = $(""),
+ bar;
+
+ var newVal = function newVal() {
+
+ var calcVal = percent * Math.round(bar.outerWidth() / (element.width() / 100)) + min;
+
+ success(calcVal);
+
+ element.attr("aria-valuenow", calcVal).attr("aria-label", value);
+ };
+
+ //make sure value is in range
+
+
+ value = parseFloat(value) <= max ? parseFloat(value) : max;
+
+ value = parseFloat(value) >= min ? parseFloat(value) : min;
+
+ //workout percentage
+
+
+ value = 100 - Math.round((value - min) / percent);
+
+ bar = $(""), element.css({
+
+ padding: "0 4px"
+
+ });
+
+ element.attr("aria-valuemin", min).attr("aria-valuemax", max);
+
+ bar.append(handle);
+
+ handle.on("mousedown", function (e) {
+
+ bar.data("mouseDrag", e.screenX);
+
+ bar.data("mouseDragWidth", bar.outerWidth());
+ });
+
+ handle.on("mouseover", function () {
+ $(this).css({ cursor: "ew-resize" });
+ });
+
+ element.on("mousemove", function (e) {
+
+ if (bar.data("mouseDrag")) {
+
+ bar.css({ width: bar.data("mouseDragWidth") + (e.screenX - bar.data("mouseDrag")) });
+ }
+ });
+
+ element.on("mouseup", function (e) {
+
+ if (bar.data("mouseDrag")) {
+
+ e.stopPropagation();
+
+ e.stopImmediatePropagation();
+
+ bar.data("mouseDragOut", true);
+
+ bar.data("mouseDrag", false);
+
+ bar.data("mouseDragWidth", false);
+
+ newVal();
+ }
+ });
+
+ //allow key based navigation
+
+
+ element.on("keydown", function (e) {
+
+ switch (e.keyCode) {
+
+ case 39:
+ //right arrow
+
+
+ bar.css({ "width": bar.width() + element.width() / 100 });
+
+ break;
+
+ case 37:
+ //left arrow
+
+
+ bar.css({ "width": bar.width() - element.width() / 100 });
+
+ break;
+
+ case 13:
+ //enter
+
+
+ newVal();
+
+ break;
+
+ case 27:
+ //escape
+
+
+ cancel();
+
+ break;
+
+ }
+ });
+
+ element.on("blur", function () {
+
+ cancel();
+ });
+
+ return bar;
+ },
+
+ //checkbox
+
+
+ tickCross: function tickCross(cell, onRendered, success, cancel, editorParams) {
+
+ var value = cell.getValue(),
+ input = $("");
+
+ //create and style input
+
+
+ input.css({
+
+ "margin-top": "5px",
+
+ "box-sizing": "border-box"
+
+ }).val(value);
+
+ onRendered(function () {
+
+ input.focus();
+ });
+
+ if (value === true || value === "true" || value === "True" || value === 1) {
+
+ input.prop("checked", true);
+ } else {
+
+ input.prop("checked", false);
+ }
+
+ //submit new value on blur
+
+
+ input.on("change blur", function (e) {
+
+ success(input.is(":checked"));
+ });
+
+ //submit new value on enter
+
+
+ input.on("keydown", function (e) {
+
+ if (e.keyCode == 13) {
+
+ success(input.is(":checked"));
+ }
+
+ if (e.keyCode == 27) {
+
+ cancel();
+ }
+ });
+
+ return input;
+ },
+
+ //checkbox
+
+
+ tick: function tick(cell, onRendered, success, cancel, editorParams) {
+
+ var value = cell.getValue(),
+ input = $("");
+
+ //create and style input
+
+
+ input.css({
+
+ "margin-top": "5px",
+
+ "box-sizing": "border-box"
+
+ }).val(value);
+
+ onRendered(function () {
+
+ input.focus();
+ });
+
+ if (value === true || value === "true" || value === "True" || value === 1) {
+
+ input.prop("checked", true);
+ } else {
+
+ input.prop("checked", false);
+ }
+
+ //submit new value on blur
+
+
+ input.on("change blur", function (e) {
+
+ success(input.is(":checked"));
+ });
+
+ //submit new value on enter
+
+
+ input.on("keydown", function (e) {
+
+ if (e.keyCode == 13) {
+
+ success(input.is(":checked"));
+ }
+
+ if (e.keyCode == 27) {
+
+ cancel();
+ }
+ });
+
+ return input;
+ }
+
+ };
+
+ Tabulator.registerExtension("edit", Edit);
+
+ var Filter = function Filter(table) {
+
+ this.table = table; //hold Tabulator object
+
+
+ this.filterList = []; //hold filter list
+
+
+ this.headerFilters = {}; //hold column filters
+
+
+ this.headerFilterElements = []; //hold header filter elements for manipulation
+
+
+ this.changed = false; //has filtering changed since last render
+
+ };
+
+ //initialize column header filter
+
+
+ Filter.prototype.initializeColumn = function (column) {
+
+ var self = this,
+ field = column.getField(),
+ filterElement,
+ editor,
+ editorElement,
+ cellWrapper,
+ typingTimer,
+ tagType,
+ attrType;
+
+ //handle successfull value change
+
+
+ function success(value) {
+
+ var filterType = tagType == "input" && attrType == "text" ? "partial" : "match",
+ type = "",
+ filterFunc;
+
+ if (value) {
+
+ switch (_typeof(column.definition.headerFilterFunc)) {
+
+ case "string":
+
+ if (self.filters[column.definition.headerFilterFunc]) {
+
+ type = column.definition.headerFilterFunc;
+
+ filterFunc = function filterFunc(data) {
+
+ return self.filters[column.definition.headerFilterFunc](value, column.getFieldValue(data));
+ };
+ } else {
+
+ console.warn("Header Filter Error - Matching filter function not found: ", column.definition.headerFilterFunc);
+ }
+
+ break;
+
+ case "function":
+
+ filterFunc = function filterFunc(data) {
+
+ return column.definition.headerFilterFunc(value, column.getFieldValue(data), data, column.definition.headerFilterFuncParams || {});
+ };
+
+ type = filterFunc;
+
+ break;
+
+ }
+
+ if (!filterFunc) {
+
+ switch (filterType) {
+
+ case "partial":
+
+ filterFunc = function filterFunc(data) {
+
+ return String(column.getFieldValue(data)).toLowerCase().indexOf(String(value).toLowerCase()) > -1;
+ };
+
+ type = "like";
+
+ break;
+
+ default:
+
+ filterFunc = function filterFunc(data) {
+
+ return column.getFieldValue(data) == value;
+ };
+
+ type = "=";
+
+ }
+ }
+
+ self.headerFilters[field] = { value: value, func: filterFunc, type: type };
+ } else {
+
+ delete self.headerFilters[field];
+ }
+
+ self.changed = true;
+
+ self.table.rowManager.filterRefresh();
+ };
+
+ //handle aborted edit
+
+
+ function cancel() {};
+
+ if (field) {
+
+ filterElement = $("");
+
+ //set column editor
+
+
+ switch (_typeof(column.definition.headerFilter)) {
+
+ case "string":
+
+ if (self.table.extensions.edit.editors[column.definition.headerFilter]) {
+
+ editor = self.table.extensions.edit.editors[column.definition.headerFilter];
+ } else {
+
+ console.warn("Filter Error - Cannot build header filter, No such editor found: ", column.definition.editor);
+ }
+
+ break;
+
+ case "function":
+
+ editor = column.definition.headerFilter;
+
+ break;
+
+ case "boolean":
+
+ if (column.extensions.edit && column.extensions.edit.editor) {
+
+ editor = column.extensions.edit.editor;
+ } else {
+
+ if (column.definition.formatter && self.table.extensions.edit.editors[column.definition.formatter]) {
+
+ editor = self.table.extensions.edit.editors[column.definition.formatter];
+ } else {
+
+ editor = self.table.extensions.edit.editors["input"];
+ }
+ }
+
+ break;
+
+ }
+
+ if (editor) {
+
+ cellWrapper = {
+
+ getValue: function getValue() {
+
+ return "";
+ },
+
+ getField: function getField() {
+
+ return column.definition.field;
+ },
+
+ getElement: function getElement() {
+
+ return filterElement;
+ }
+
+ };
+
+ editorElement = editor.call(self, cellWrapper, function () {}, success, cancel, column.definition.headerFilterParams || {});
+
+ //set Placeholder Text
+
+
+ if (field) {
+
+ self.table.extensions.localize.bind("headerFilters.columns." + column.definition.field, function (value) {
+
+ editorElement.attr("placeholder", typeof value !== "undefined" && value ? value : self.table.extensions.localize.getText("headerFilters.default"));
+ });
+ } else {
+
+ self.table.extensions.localize.bind("headerFilters.default", function (value) {
+
+ editorElement.attr("placeholdder", typeof self.column.definition.headerFilterPlaceholder !== "undefined" && self.column.definition.headerFilterPlaceholder ? self.column.definition.headerFilterPlaceholder : value);
+ });
+ }
+
+ //focus on element on click
+
+
+ editorElement.on("click", function (e) {
+
+ e.stopPropagation();
+
+ $(this).focus();
+ });
+
+ //live update filters as user types
+
+
+ typingTimer = false;
+
+ editorElement.on("keyup search", function (e) {
+
+ var element = $(this);
+
+ if (typingTimer) {
+
+ clearTimeout(typingTimer);
+ }
+
+ typingTimer = setTimeout(function () {
+
+ success(element.val());
+ }, 300);
+ });
+
+ //update number filtered columns on change
+
+
+ attrType = editorElement.attr("type") ? editorElement.attr("type").toLowerCase() : "";
+
+ if (attrType == "number") {
+
+ editorElement.on("change", function (e) {
+
+ success($(this).val());
+ });
+ }
+
+ //change text inputs to search inputs to allow for clearing of field
+
+
+ if (attrType == "text") {
+
+ editorElement.attr("type", "search");
+
+ editorElement.off("change blur"); //prevent blur from triggering filter and preventing selection click
+
+ }
+
+ //prevent input and select elements from propegating click to column sorters etc
+
+
+ tagType = editorElement.prop("tagName").toLowerCase();
+
+ if (tagType == "input" || tagType == "select") {
+
+ editorElement.on("mousedown", function (e) {
+
+ e.stopPropagation();
+ });
+ }
+
+ filterElement.append(editorElement);
+
+ column.contentElement.append(filterElement);
+
+ self.headerFilterElements.push(editorElement);
+ }
+ } else {
+
+ console.warn("Filter Error - Cannot add header filter, column has no field set:", column.definition.title);
+ }
+ };
+
+ //check if the filters has changed since last use
+
+
+ Filter.prototype.hasChanged = function () {
+
+ var changed = this.changed;
+
+ this.changed = false;
+
+ return changed;
+ };
+
+ //set standard filters
+
+
+ Filter.prototype.setFilter = function (field, type, value) {
+
+ var self = this;
+
+ self.filterList = [];
+
+ if (!Array.isArray(field)) {
+
+ field = [{ field: field, type: type, value: value }];
+ }
+
+ self.addFilter(field);
+ };
+
+ //add filter to array
+
+
+ Filter.prototype.addFilter = function (field, type, value) {
+
+ var self = this,
+ column;
+
+ if (!Array.isArray(field)) {
+
+ field = [{ field: field, type: type, value: value }];
+ }
+
+ field.forEach(function (filter) {
+
+ var filterFunc = false;
+
+ if (typeof filter.field == "function") {
+
+ filterFunc = function filterFunc(data) {
+
+ return filter.field(data, filter.type || {}); // pass params to custom filter function
+
+ };
+ } else {
+
+ if (self.filters[filter.type]) {
+
+ column = self.table.columnManager.getColumnByField(filter.field);
+
+ if (column) {
+
+ filterFunc = function filterFunc(data) {
+
+ return self.filters[filter.type](filter.value, column.getFieldValue(data));
+ };
+ } else {
+
+ filterFunc = function filterFunc(data) {
+
+ return self.filters[filter.type](filter.value, data[filter.field]);
+ };
+ }
+ } else {
+
+ console.warn("Filter Error - No such filter type found, ignoring: ", filter.type);
+ }
+ }
+
+ if (filterFunc) {
+
+ filter.func = filterFunc;
+
+ self.filterList.push(filter);
+
+ self.changed = true;
+ }
+ });
+ };
+
+ //get all filters
+
+
+ Filter.prototype.getFilters = function (all, ajax) {
+
+ var self = this,
+ output = [];
+
+ if (all) {
+
+ output = self.getHeaderFilters();
+ }
+
+ self.filterList.forEach(function (filter) {
+
+ output.push({ field: filter.field, type: filter.type, value: filter.value });
+ });
+
+ if (ajax) {
+
+ output.forEach(function (item) {
+
+ if (typeof item.type == "function") {
+
+ item.type = "function";
+ }
+ });
+ }
+
+ return output;
+ };
+
+ //get all filters
+
+
+ Filter.prototype.getHeaderFilters = function () {
+
+ var self = this,
+ output = [];
+
+ for (var key in this.headerFilters) {
+
+ output.push({ field: key, type: this.headerFilters[key].type, value: this.headerFilters[key].value });
+ }
+
+ return output;
+ };
+
+ //remove filter from array
+
+
+ Filter.prototype.removeFilter = function (field, type, value) {
+
+ var self = this;
+
+ if (!Array.isArray(field)) {
+
+ field = [{ field: field, type: type, value: value }];
+ }
+
+ field.forEach(function (filter) {
+
+ var index = -1;
+
+ if (_typeof(filter.field) == "object") {
+
+ index = self.filterList.findIndex(function (element) {
+
+ return filter === element;
+ });
+ } else {
+
+ index = self.filterList.findIndex(function (element) {
+
+ return filter.field === element.field && filter.type === element.type && filter.value === element.value;
+ });
+ }
+
+ if (index > -1) {
+
+ self.filterList.splice(index, 1);
+
+ self.changed = true;
+ } else {
+
+ console.warn("Filter Error - No matching filter type found, ignoring: ", filter.type);
+ }
+ });
+ };
+
+ //clear filters
+
+
+ Filter.prototype.clearFilter = function (all) {
+
+ this.filterList = [];
+
+ if (all) {
+
+ this.clearHeaderFilter();
+ }
+
+ this.changed = true;
+ };
+
+ //clear header filters
+
+
+ Filter.prototype.clearHeaderFilter = function () {
+
+ this.headerFilters = {};
+
+ this.headerFilterElements.forEach(function (element) {
+
+ element.val("");
+ });
+
+ self.changed = true;
+ };
+
+ //filter row array
+
+
+ Filter.prototype.filter = function (rowList) {
+
+ var self = this,
+ activeRows = [],
+ activeRowComponents = [];
+
+ if (self.table.options.dataFiltering) {
+
+ self.table.options.dataFiltering(self.getFilters());
+ }
+
+ if (!self.table.options.ajaxFiltering && (self.filterList.length || Object.keys(self.headerFilters).length)) {
+
+ rowList.forEach(function (row) {
+
+ if (self.filterRow(row)) {
+
+ activeRows.push(row);
+ }
+ });
+
+ activeRows;
+ } else {
+
+ activeRows = rowList.slice(0);
+ }
+
+ if (self.table.options.dataFiltered) {
+
+ activeRows.forEach(function (row) {
+
+ activeRowComponents.push(row.getComponent());
+ });
+
+ self.table.options.dataFiltered(self.getFilters(), activeRowComponents);
+ }
+
+ return activeRows;
+ };
+
+ //filter individual row
+
+
+ Filter.prototype.filterRow = function (row) {
+
+ var self = this,
+ match = true,
+ data = row.getData();
+
+ self.filterList.forEach(function (filter) {
+
+ if (!filter.func(data)) {
+
+ match = false;
+ }
+ });
+
+ for (var field in self.headerFilters) {
+
+ if (!self.headerFilters[field].func(data)) {
+
+ match = false;
+ }
+ }
+
+ return match;
+ };
+
+ //list of available filters
+
+
+ Filter.prototype.filters = {
+
+ //equal to
+
+
+ "=": function _(filterVal, rowVal) {
+
+ return rowVal == filterVal ? true : false;
+ },
+
+ //less than
+
+
+ "<": function _(filterVal, rowVal) {
+
+ return rowVal < filterVal ? true : false;
+ },
+
+ //less than or equal to
+
+
+ "<=": function _(filterVal, rowVal) {
+
+ return rowVal <= filterVal ? true : false;
+ },
+
+ //greater than
+
+
+ ">": function _(filterVal, rowVal) {
+
+ return rowVal > filterVal ? true : false;
+ },
+
+ //greater than or equal to
+
+
+ ">=": function _(filterVal, rowVal) {
+
+ return rowVal >= filterVal ? true : false;
+ },
+
+ //not equal to
+
+
+ "!=": function _(filterVal, rowVal) {
+
+ return rowVal != filterVal ? true : false;
+ },
+
+ //contains the string
+
+
+ "like": function like(filterVal, rowVal) {
+
+ if (filterVal === null || typeof filterVal === "undefined") {
+
+ return rowVal === filterVal ? true : false;
+ } else {
+
+ return rowVal.toLowerCase().indexOf(filterVal.toLowerCase()) > -1 ? true : false;
+ }
+ }
+
+ };
+
+ Tabulator.registerExtension("filter", Filter);
+
+ var Format = function Format(table) {
+
+ this.table = table; //hold Tabulator object
+
+ };
+
+ //initialize column formatter
+
+
+ Format.prototype.initializeColumn = function (column) {
+
+ var self = this,
+ config = { params: column.definition.formatterParams || {} };
+
+ //set column formatter
+
+
+ switch (_typeof(column.definition.formatter)) {
+
+ case "string":
+
+ if (self.formatters[column.definition.formatter]) {
+
+ config.formatter = self.formatters[column.definition.formatter];
+ } else {
+
+ console.warn("Formatter Error - No such formatter found: ", column.definition.formatter);
+
+ config.formatter = self.formatters.plaintext;
+ }
+
+ break;
+
+ case "function":
+
+ config.formatter = column.definition.formatter;
+
+ break;
+
+ default:
+
+ config.formatter = self.formatters.plaintext;
+
+ break;
+
+ }
+
+ column.extensions.format = config;
+ };
+
+ //return a formatted value for a cell
+
+
+ Format.prototype.formatValue = function (cell) {
+
+ return cell.column.extensions.format.formatter.call(this, cell.getComponent(), cell.column.extensions.format.params);
+ };
+
+ Format.prototype.sanitizeHTML = function (value) {
+
+ if (value) {
+
+ var entityMap = {
+
+ '&': '&',
+
+ '<': '<',
+
+ '>': '>',
+
+ '"': '"',
+
+ "'": ''',
+
+ '/': '/',
+
+ '`': '`',
+
+ '=': '='
+
+ };
+
+ return String(value).replace(/[&<>"'`=\/]/g, function (s) {
+
+ return entityMap[s];
+ });
+ } else {
+
+ return value;
+ }
+ };
+
+ Format.prototype.emptyToSpace = function (value) {
+
+ return value === null ? " " : value;
+ };
+
+ //get formatter for cell
+
+
+ Format.prototype.getFormatter = function (formatter) {
+
+ var formatter;
+
+ switch (typeof formatter === 'undefined' ? 'undefined' : _typeof(formatter)) {
+
+ case "string":
+
+ if (this.formatters[formatter]) {
+
+ formatter = this.formatters[formatter];
+ } else {
+
+ console.warn("Formatter Error - No such formatter found: ", formatter);
+
+ formatter = this.formatters.plaintext;
+ }
+
+ break;
+
+ case "function":
+
+ formatter = formatter;
+
+ break;
+
+ default:
+
+ formatter = this.formatters.plaintext;
+
+ break;
+
+ }
+
+ return formatter;
+ };
+
+ //default data formatters
+
+
+ Format.prototype.formatters = {
+
+ //plain text value
+
+
+ plaintext: function plaintext(cell, formatterParams) {
+
+ return this.emptyToSpace(this.sanitizeHTML(cell.getValue()));
+ },
+
+ //html text value
+
+
+ html: function html(cell, formatterParams) {
+
+ return cell.getValue();
+ },
+
+ //multiline text area
+
+
+ textarea: function textarea(cell, formatterParams) {
+
+ cell.getElement().css({ "white-space": "pre-wrap" });
+
+ return this.emptyToSpace(this.sanitizeHTML(cell.getValue()));
+ },
+
+ //currency formatting
+
+
+ money: function money(cell, formatterParams) {
+
+ var floatVal = parseFloat(cell.getValue()),
+ number,
+ integer,
+ decimal,
+ rgx;
+
+ var decimalSym = formatterParams.decimal || ".";
+
+ var thousandSym = formatterParams.thousand || ",";
+
+ var symbol = formatterParams.symbol || "";
+
+ var after = !!formatterParams.symbolAfter;
+
+ var precision = typeof formatterParams.precision !== "undefined" ? formatterParams.precision : 2;
+
+ if (isNaN(floatVal)) {
+
+ return this.emptyToSpace(this.sanitizeHTML(cell.getValue()));
+ }
+
+ number = precision !== false ? floatVal.toFixed(precision) : floatVal;
+
+ number = number.split(".");
+
+ integer = number[0];
+
+ decimal = number.length > 1 ? decimalSym + number[1] : "";
+
+ rgx = /(\d+)(\d{3})/;
+
+ while (rgx.test(integer)) {
+
+ integer = integer.replace(rgx, "$1" + thousandSym + "$2");
+ }
+
+ return after ? integer + decimal + symbol : symbol + integer + decimal;
+ },
+
+ //clickable mailto link
+
+
+ email: function email(cell, formatterParams) {
+
+ var value = this.sanitizeHTML(cell.getValue());
+
+ return "" + this.emptyToSpace(value) + "";
+ },
+
+ //clickable anchor tag
+
+
+ link: function link(cell, formatterParams) {
+
+ var value = this.sanitizeHTML(cell.getValue());
+
+ return "" + this.emptyToSpace(value) + "";
+ },
+
+ //image element
+
+
+ image: function image(cell, formatterParams) {
+
+ var value = this.sanitizeHTML(cell.getValue());
+
+ return "";
+ }
+
+ };
+
+ Tabulator.registerExtension("format", Format);
+
+ var FrozenColumns = function FrozenColumns(table) {
+
+ this.table = table; //hold Tabulator object
+
+
+ this.leftColumns = [];
+
+ this.rightColumns = [];
+
+ this.leftMargin = 0;
+
+ this.rightMargin = 0;
+
+ this.initializationMode = "left";
+
+ this.active = false;
+ };
+
+ //reset initial state
+
+
+ FrozenColumns.prototype.reset = function () {
+
+ this.initializationMode = "left";
+
+ this.leftColumns = [];
+
+ this.rightColumns = [];
+
+ this.active = false;
+ };
+
+ //initialize specific column
+
+
+ FrozenColumns.prototype.initializeColumn = function (column) {
+
+ var config = { margin: 0, edge: false };
+
+ if (column.definition.frozen) {
+
+ if (!column.parent.isGroup) {
+
+ if (!column.isGroup) {
+
+ config.position = this.initializationMode;
+
+ if (this.initializationMode == "left") {
+
+ this.leftColumns.push(column);
+ } else {
+
+ this.rightColumns.unshift(column);
+ }
+
+ this.active = true;
+
+ column.extensions.frozen = config;
+ } else {
+
+ console.warn("Frozen Column Error - Column Groups cannot be frozen");
+ }
+ } else {
+
+ console.warn("Frozen Column Error - Grouped columns cannot be frozen");
+ }
+ } else {
+
+ this.initializationMode = "right";
+ }
+ };
+
+ //layout columns appropropriatly
+
+
+ FrozenColumns.prototype.layout = function () {
+
+ var self = this,
+ tableHolder = this.table.rowManager.element,
+ rightMargin = 0;
+
+ if (self.active) {
+
+ //calculate row padding
+
+
+ self.leftMargin = self._calcSpace(self.leftColumns, self.leftColumns.length);
+
+ self.table.columnManager.headersElement.css("margin-left", self.leftMargin);
+
+ self.rightMargin = self._calcSpace(self.rightColumns, self.rightColumns.length);
+
+ self.table.columnManager.element.css("padding-right", self.rightMargin);
+
+ self.table.rowManager.activeRows.forEach(function (row) {
+
+ self.layoutRow(row);
+ });
+
+ if (self.table.extExists("columnCalcs")) {
+
+ if (self.table.extensions.columnCalcs.topInitialized && self.table.extensions.columnCalcs.topRow) {
+
+ self.layoutRow(self.table.extensions.columnCalcs.topRow);
+ }
+
+ if (self.table.extensions.columnCalcs.botInitialized && self.table.extensions.columnCalcs.botRow) {
+
+ self.layoutRow(self.table.extensions.columnCalcs.botRow);
+ }
+ }
+
+ //calculate left columns
+
+
+ self.leftColumns.forEach(function (column, i) {
+
+ column.extensions.frozen.margin = self._calcSpace(self.leftColumns, i) + self.table.columnManager.scrollLeft;
+
+ if (i == self.leftColumns.length - 1) {
+
+ column.extensions.frozen.edge = true;
+ } else {
+
+ column.extensions.frozen.edge = false;
+ }
+
+ self.layoutColumn(column);
+ });
+
+ //calculate right frozen columns
+
+
+ rightMargin = self.table.rowManager.element.innerWidth() + self.table.columnManager.scrollLeft;
+
+ if (tableHolder[0].scrollHeight > tableHolder.innerHeight()) {
+
+ rightMargin -= tableHolder[0].offsetWidth - tableHolder[0].clientWidth;
+ }
+
+ self.rightColumns.forEach(function (column, i) {
+
+ column.extensions.frozen.margin = rightMargin - self._calcSpace(self.rightColumns, i + 1);
+
+ if (i == self.rightColumns.length - 1) {
+
+ column.extensions.frozen.edge = true;
+ } else {
+
+ column.extensions.frozen.edge = false;
+ }
+
+ self.layoutColumn(column);
+ });
+ }
+ };
+
+ FrozenColumns.prototype.layoutColumn = function (column) {
+
+ var self = this;
+
+ self.layoutElement(column.element, column);
+
+ column.cells.forEach(function (cell) {
+
+ self.layoutElement(cell.element, column);
+ });
+ };
+
+ FrozenColumns.prototype.layoutRow = function (row) {
+
+ row.getElement().css({
+
+ "padding-left": this.leftMargin,
+
+ "padding-right": this.rightMargin
+
+ });
+ };
+
+ FrozenColumns.prototype.layoutElement = function (element, column) {
+
+ if (column.extensions.frozen) {
+
+ var css = {
+
+ position: "absolute",
+
+ left: column.extensions.frozen.margin
+
+ };
+
+ element.css(css);
+
+ element.addClass("tabulator-frozen");
+
+ if (column.extensions.frozen.edge) {
+
+ element.addClass("tabulator-frozen-" + column.extensions.frozen.position);
+ }
+ }
+ };
+
+ FrozenColumns.prototype._calcSpace = function (columns, index) {
+
+ var width = 0;
+
+ for (var i = 0; i < index; i++) {
+
+ if (columns[i].visible) {
+
+ width += columns[i].getWidth();
+ }
+ }
+
+ return width;
+ };
+
+ Tabulator.registerExtension("frozenColumns", FrozenColumns);
+
+ //public group object
+
+
+ var GroupComponent = function GroupComponent(group) {
+
+ this.group = group;
+
+ this.type = "GroupComponent";
+ };
+
+ GroupComponent.prototype.getKey = function () {
+
+ return this.group.key;
+ };
+
+ GroupComponent.prototype.getElement = function () {
+
+ return this.group.element;
+ };
+
+ GroupComponent.prototype.getRows = function () {
+
+ var output = [];
+
+ this.group.rows.forEach(function (row) {
+
+ output.push(row.getComponent());
+ });
+
+ return output;
+ };
+
+ GroupComponent.prototype.getSubGroups = function () {
+
+ var output = [];
+
+ this.group.groupList.forEach(function (child) {
+
+ output.push(child.getComponent());
+ });
+
+ return output;
+ };
+
+ GroupComponent.prototype.getParentGroup = function () {
+
+ return this.group.parent ? this.group.parent.getComponent() : false;
+ };
+
+ GroupComponent.prototype.getVisibility = function () {
+
+ return this.group.visible;
+ };
+
+ GroupComponent.prototype.show = function () {
+
+ this.group.show();
+ };
+
+ GroupComponent.prototype.hide = function () {
+
+ this.group.hide();
+ };
+
+ GroupComponent.prototype.toggle = function () {
+
+ this.group.toggleVisibility();
+ };
+
+ GroupComponent.prototype._getSelf = function () {
+
+ return this.group;
+ };
+
+ //////////////////////////////////////////////////
+
+
+ //////////////// Group Functions /////////////////
+
+
+ //////////////////////////////////////////////////
+
+
+ var Group = function Group(groupManager, parent, level, key, generator, oldGroup) {
+
+ this.groupManager = groupManager;
+
+ this.parent = parent;
+
+ this.key = key;
+
+ this.level = level;
+
+ this.hasSubGroups = level < groupManager.groupIDLookups.length - 1;
+
+ this.addRow = this.hasSubGroups ? this._addRowToGroup : this._addRow;
+
+ this.type = "group"; //type of element
+
+
+ this.old = oldGroup;
+
+ this.rows = [];
+
+ this.groups = [];
+
+ this.groupList = [];
+
+ this.generator = generator;
+
+ this.element = $("");
+
+ this.arrowElement = $("");
+
+ this.height = 0;
+
+ this.outerHeight = 0;
+
+ this.initialized = false;
+
+ this.calcs = {};
+
+ this.initialized = false;
+
+ this.visible = oldGroup ? oldGroup.visible : typeof groupManager.startOpen[level] !== "undefined" ? groupManager.startOpen[level] : groupManager.startOpen[0];
+
+ this.addBindings();
+ };
+
+ Group.prototype.addBindings = function () {
+
+ var self = this,
+ dblTap,
+ tapHold,
+ tap,
+ toggleElement;
+
+ if (self.groupManager.table.options.groupToggleElement) {
+
+ toggleElement = self.groupManager.table.options.groupToggleElement == "arrow" ? self.arrowElement : self.element;
+
+ toggleElement.on("click", function (e) {
+
+ e.stopPropagation();
+
+ e.stopImmediatePropagation();
+
+ self.toggleVisibility();
+ });
+ }
+
+ //handle group click events
+
+
+ if (self.groupManager.table.options.groupClick) {
+
+ self.element.on("click", function (e) {
+
+ self.groupManager.table.options.groupClick(e, self.getComponent());
+ });
+ }
+
+ if (self.groupManager.table.options.groupDblClick) {
+
+ self.element.on("dblclick", function (e) {
+
+ self.groupManager.table.options.groupDblClick(e, self.getComponent());
+ });
+ }
+
+ if (self.groupManager.table.options.groupContext) {
+
+ self.element.on("contextmenu", function (e) {
+
+ self.groupManager.table.options.groupContext(e, self.getComponent());
+ });
+ }
+
+ if (self.groupManager.table.options.groupTap) {
+
+ tap = false;
+
+ self.element.on("touchstart", function (e) {
+
+ tap = true;
+ });
+
+ self.element.on("touchend", function (e) {
+
+ if (tap) {
+
+ self.groupManager.table.options.groupTap(e, self.getComponent());
+ }
+
+ tap = false;
+ });
+ }
+
+ if (self.groupManager.table.options.groupDblTap) {
+
+ dblTap = null;
+
+ self.element.on("touchend", function (e) {
+
+ if (dblTap) {
+
+ clearTimeout(dblTap);
+
+ dblTap = null;
+
+ self.groupManager.table.options.groupDblTap(e, self.getComponent());
+ } else {
+
+ dblTap = setTimeout(function () {
+
+ clearTimeout(dblTap);
+
+ dblTap = null;
+ }, 300);
+ }
+ });
+ }
+
+ if (self.groupManager.table.options.groupTapHold) {
+
+ tapHold = null;
+
+ self.element.on("touchstart", function (e) {
+
+ clearTimeout(tapHold);
+
+ tapHold = setTimeout(function () {
+
+ clearTimeout(tapHold);
+
+ tapHold = null;
+
+ tap = false;
+
+ self.groupManager.table.options.groupTapHold(e, self.getComponent());
+ }, 1000);
+ });
+
+ self.element.on("touchend", function (e) {
+
+ clearTimeout(tapHold);
+
+ tapHold = null;
+ });
+ }
+ };
+
+ Group.prototype._addRowToGroup = function (row) {
+
+ var level = this.level + 1;
+
+ if (this.hasSubGroups) {
+
+ var groupID = this.groupManager.groupIDLookups[level](row.getData());
+
+ if (!this.groups[groupID]) {
+
+ var group = new Group(this.groupManager, this, level, groupID, this.groupManager.headerGenerator[level] || this.groupManager.headerGenerator[0], this.old ? this.old.groups[groupID] : false);
+
+ this.groups[groupID] = group;
+
+ this.groupList.push(group);
+ }
+
+ this.groups[groupID].addRow(row);
+ }
+ };
+
+ Group.prototype._addRow = function (row) {
+
+ this.rows.push(row);
+ };
+
+ Group.prototype.getHeadersAndRows = function () {
+
+ var output = [];
+
+ output.push(this);
+
+ this._visSet();
+
+ if (this.visible) {
+
+ if (this.groupList.length) {
+
+ this.groupList.forEach(function (group) {
+
+ output = output.concat(group.getHeadersAndRows());
+ });
+ } else {
+
+ if (this.groupManager.table.extExists("columnCalcs") && this.groupManager.table.extensions.columnCalcs.hasTopCalcs()) {
+
+ this.calcs.top = this.groupManager.table.extensions.columnCalcs.generateTopRow(this.rows);
+
+ output.push(this.calcs.top);
+ }
+
+ output = output.concat(this.rows);
+
+ if (this.groupManager.table.extExists("columnCalcs") && this.groupManager.table.extensions.columnCalcs.hasBottomCalcs()) {
+
+ this.calcs.bottom = this.groupManager.table.extensions.columnCalcs.generateBottomRow(this.rows);
+
+ output.push(this.calcs.bottom);
+ }
+ }
+ } else {
+
+ if (this.groupManager.table.options.groupClosedShowCalcs) {
+
+ if (this.groupManager.table.extExists("columnCalcs")) {
+
+ if (this.groupManager.table.extensions.columnCalcs.hasTopCalcs()) {
+
+ this.calcs.top = this.groupManager.table.extensions.columnCalcs.generateTopRow(this.rows);
+
+ output.push(this.calcs.top);
+ }
+
+ if (this.groupManager.table.extensions.columnCalcs.hasBottomCalcs()) {
+
+ this.calcs.bottom = this.groupManager.table.extensions.columnCalcs.generateBottomRow(this.rows);
+
+ output.push(this.calcs.bottom);
+ }
+ }
+ }
+ }
+
+ return output;
+ };
+
+ Group.prototype.getRows = function () {
+
+ this._visSet();
+
+ return this.visible ? this.rows : [];
+ };
+
+ Group.prototype.getRowCount = function () {
+
+ var count = 0;
+
+ if (this.groupList.length) {
+
+ this.groupList.forEach(function (group) {
+
+ count += group.getRowCount();
+ });
+ } else {
+
+ count = this.rows.length;
+ }
+
+ return count;
+ };
+
+ Group.prototype.toggleVisibility = function () {
+
+ if (this.visible) {
+
+ this.hide();
+ } else {
+
+ this.show();
+ }
+ };
+
+ Group.prototype.hide = function () {
+
+ this.visible = false;
+
+ if (this.groupManager.table.rowManager.getRenderMode() == "classic") {
+
+ this.element.removeClass("tabulator-group-visible");
+
+ this.rows.forEach(function (row) {
+
+ row.getElement().detach();
+ });
+ } else {
+
+ this.groupManager.updateGroupRows(true);
+ }
+
+ this.groupManager.table.options.groupVisibilityChanged(this.getComponent(), false);
+ };
+
+ Group.prototype.show = function () {
+
+ var self = this;
+
+ self.visible = true;
+
+ if (this.groupManager.table.rowManager.getRenderMode() == "classic") {
+
+ this.element.addClass("tabulator-group-visible");
+
+ self.rows.forEach(function (row) {
+
+ self.getElement().after(row.getElement());
+
+ row.initialize();
+ });
+ } else {
+
+ this.groupManager.updateGroupRows(true);
+ }
+
+ this.groupManager.table.options.groupVisibilityChanged(this.getComponent(), true);
+ };
+
+ Group.prototype._visSet = function () {
+
+ var data = [];
+
+ if (typeof this.visible == "function") {
+
+ this.rows.forEach(function (row) {
+
+ data.push(row.getData());
+ });
+
+ this.visible = this.visible(this.key, this.getRowCount(), data, this.getRowCount());
+ }
+ };
+
+ Group.prototype.getRowGroup = function (row) {
+
+ var match = false;
+
+ if (this.groupList.length) {
+
+ this.groupList.forEach(function (group) {
+
+ var result = group.getRowGroup(row);
+
+ if (result) {
+
+ match = result;
+ }
+ });
+ } else {
+
+ if (this.rows.find(function (item) {
+
+ return item === row;
+ })) {
+
+ match = this;
+ }
+ }
+
+ return match;
+ };
+
+ ////////////// Standard Row Functions //////////////
+
+
+ Group.prototype.getElement = function () {
+
+ this.addBindingsd = false;
+
+ this._visSet();
+
+ var data = [];
+
+ this.rows.forEach(function (row) {
+
+ data.push(row.getData());
+ });
+
+ if (this.visible) {
+
+ this.element.addClass("tabulator-group-visible");
+ } else {
+
+ this.element.removeClass("tabulator-group-visible");
+ }
+
+ this.element.children().detach();
+
+ this.element.html(this.generator(this.key, this.getRowCount(), data, this.getComponent())).prepend(this.arrowElement);
+
+ // this.addBindings();
+
+
+ return this.element;
+ };
+
+ //normalize the height of elements in the row
+
+
+ Group.prototype.normalizeHeight = function () {
+
+ this.setHeight(this.element.innerHeight());
+ };
+
+ Group.prototype.initialize = function (force) {
+
+ if (!this.initialized || force) {
+
+ this.normalizeHeight();
+
+ this.initialized = true;
+ }
+ };
+
+ Group.prototype.reinitialize = function () {
+
+ this.initialized = false;
+
+ this.height = 0;
+
+ if (this.element.is(":visible")) {
+
+ this.initialize(true);
+ }
+ };
+
+ Group.prototype.setHeight = function (height) {
+
+ if (this.height != height) {
+
+ this.height = height;
+
+ this.outerHeight = this.element.outerHeight();
+ }
+ };
+
+ //return rows outer height
+
+
+ Group.prototype.getHeight = function () {
+
+ return this.outerHeight;
+ };
+
+ Group.prototype.reinitializeHeight = function () {};
+
+ Group.prototype.calcHeight = function () {};
+
+ Group.prototype.setCellHeight = function () {};
+
+ Group.prototype.clearCellHeight = function () {};
+
+ //////////////// Object Generation /////////////////
+
+
+ Group.prototype.getComponent = function () {
+
+ return new GroupComponent(this);
+ };
+
+ //////////////////////////////////////////////////
+
+
+ ////////////// Group Row Extension ///////////////
+
+
+ //////////////////////////////////////////////////
+
+
+ var GroupRows = function GroupRows(table) {
+
+ this.table = table; //hold Tabulator object
+
+
+ this.groupIDLookups = false; //enable table grouping and set field to group by
+
+
+ this.startOpen = [function () {
+ return false;
+ }]; //starting state of group
+
+
+ this.headerGenerator = [function () {
+ return "";
+ }];
+
+ this.groupList = []; //ordered list of groups
+
+
+ this.groups = {}; //hold row groups
+
+ };
+
+ //initialize group configuration
+
+
+ GroupRows.prototype.initialize = function () {
+
+ var self = this,
+ groupBy = self.table.options.groupBy,
+ startOpen = self.table.options.groupStartOpen,
+ groupHeader = self.table.options.groupHeader;
+
+ self.headerGenerator = [function () {
+ return "";
+ }];
+
+ this.startOpen = [function () {
+ return false;
+ }]; //starting state of group
+
+
+ self.table.extensions.localize.bind("groups.item", function (langValue, lang) {
+
+ self.headerGenerator[0] = function (value, count, data) {
+ //header layout function
+
+
+ return value + "(" + count + " " + (count === 1 ? langValue : lang.groups.items) + ")";
+ };
+ });
+
+ this.groupIDLookups = [];
+
+ if (Array.isArray(groupBy) || groupBy) {
+
+ if (this.table.extExists("columnCalcs")) {
+
+ this.table.extensions.columnCalcs.removeCalcs();
+ }
+ } else {
+
+ if (this.table.extExists("columnCalcs")) {
+
+ var cols = this.table.columnManager.getRealColumns();
+
+ cols.forEach(function (col) {
+
+ if (col.definition.topCalc) {
+
+ self.table.extensions.columnCalcs.initializeTopRow();
+ }
+
+ if (col.definition.bottomCalc) {
+
+ self.table.extensions.columnCalcs.initializeBottomRow();
+ }
+ });
+ }
+ }
+
+ if (!Array.isArray(groupBy)) {
+
+ groupBy = [groupBy];
+ }
+
+ groupBy.forEach(function (group) {
+
+ var lookupFunc, column;
+
+ if (typeof group == "function") {
+
+ lookupFunc = group;
+ } else {
+
+ column = self.table.columnManager.getColumnByField(group);
+
+ if (column) {
+
+ lookupFunc = function lookupFunc(data) {
+
+ return column.getFieldValue(data);
+ };
+ } else {
+
+ lookupFunc = function lookupFunc(data) {
+
+ return data[group];
+ };
+ }
+ }
+
+ self.groupIDLookups.push(lookupFunc);
+ });
+
+ if (startOpen) {
+
+ if (!Array.isArray(startOpen)) {
+
+ startOpen = [startOpen];
+ }
+
+ startOpen.forEach(function (level) {
+
+ level = typeof level == "function" ? level : function () {
+ return true;
+ };
+ });
+
+ self.startOpen = startOpen;
+ }
+
+ if (groupHeader) {
+
+ self.headerGenerator = Array.isArray(groupHeader) ? groupHeader : [groupHeader];
+ }
+
+ this.initialized = true;
+ };
+
+ //return appropriate rows with group headers
+
+
+ GroupRows.prototype.getRows = function (rows) {
+
+ if (this.groupIDLookups.length) {
+
+ this.table.options.dataGrouping();
+
+ this.generateGroups(rows);
+
+ if (this.table.options.dataGrouped) {
+
+ this.table.options.dataGrouped(this.getGroups());
+ };
+
+ return this.updateGroupRows();
+ } else {
+
+ return rows.slice(0);
+ }
+ };
+
+ GroupRows.prototype.getGroups = function () {
+
+ var groupComponents = [];
+
+ if (this.table.options.dataGrouped) {
+
+ this.groupList.forEach(function (group) {
+
+ groupComponents.push(group.getComponent());
+ });
+ }
+
+ return groupComponents;
+ };
+
+ GroupRows.prototype.getRowGroup = function (row) {
+
+ var match = false;
+
+ this.groupList.forEach(function (group) {
+
+ var result = group.getRowGroup(row);
+
+ if (result) {
+
+ match = result;
+ }
+ });
+
+ return match;
+ };
+
+ GroupRows.prototype.countGroups = function () {
+
+ return this.groupList.length;
+ };
+
+ GroupRows.prototype.generateGroups = function (rows) {
+
+ var self = this,
+ oldGroups = self.groups;
+
+ self.groups = {};
+
+ self.groupList = [];
+
+ rows.forEach(function (row) {
+
+ var groupID = self.groupIDLookups[0](row.getData());
+
+ if (!self.groups[groupID]) {
+
+ var group = new Group(self, false, 0, groupID, self.headerGenerator[0], oldGroups[groupID]);
+
+ self.groups[groupID] = group;
+
+ self.groupList.push(group);
+ }
+
+ self.groups[groupID].addRow(row);
+ });
+ };
+
+ GroupRows.prototype.updateGroupRows = function (force) {
+
+ var self = this,
+ output = [],
+ oldRowCount;
+
+ self.groupList.forEach(function (group) {
+
+ output = output.concat(group.getHeadersAndRows());
+ });
+
+ //force update of table display
+
+
+ if (force) {
+
+ oldRowCount = self.table.rowManager.displayRowsCount;
+
+ self.table.rowManager.setDisplayRows(output);
+
+ self.table.rowManager._virtualRenderFill(Math.floor(self.table.rowManager.element.scrollTop() / self.table.rowManager.element[0].scrollHeight * oldRowCount));
+ }
+
+ return output;
+ };
+
+ GroupRows.prototype.scrollHeaders = function (left) {
+
+ this.groupList.forEach(function (group) {
+
+ group.arrowElement.css("margin-left", left);
+ });
+ };
+
+ Tabulator.registerExtension("groupRows", GroupRows);
+
+ var History = function History(table) {
+
+ this.table = table; //hold Tabulator object
+
+
+ this.history = [];
+
+ this.index = -1;
+ };
+
+ History.prototype.clear = function () {
+
+ this.history = [];
+
+ this.index = -1;
+ };
+
+ History.prototype.action = function (type, component, data) {
+
+ if (this.index > -1) {
+
+ this.history = this.history.slice(0, this.index + 1);
+ }
+
+ this.history.push({
+
+ type: type,
+
+ component: component,
+
+ data: data
+
+ });
+
+ this.index++;
+ };
+
+ History.prototype.undo = function () {
+
+ if (this.index > -1) {
+
+ var action = this.history[this.index];
+
+ this.undoers[action.type].call(this, action);
+
+ this.index--;
+
+ return true;
+ } else {
+
+ console.warn("History Undo Error - No more history to undo");
+
+ return false;
+ }
+ };
+
+ History.prototype.redo = function () {
+
+ if (this.history.length - 1 > this.index) {
+
+ this.index++;
+
+ var action = this.history[this.index];
+
+ this.redoers[action.type].call(this, action);
+
+ return true;
+ } else {
+
+ console.warn("History Redo Error - No more history to redo");
+
+ return false;
+ }
+ };
+
+ History.prototype.undoers = {
+
+ cellEdit: function cellEdit(action) {
+
+ action.component.setValueProcessData(action.data.oldValue);
+ },
+
+ rowAdd: function rowAdd(action) {
+
+ action.component.delete();
+ },
+
+ rowDelete: function rowDelete(action) {
+
+ var newRow = this.table.rowManager.addRowActual(action.data.data, action.data.pos, action.data.index);
+
+ this._rebindRow(action.component, newRow);
+ }
+
+ };
+
+ History.prototype.redoers = {
+
+ cellEdit: function cellEdit(action) {
+
+ action.component.setValueProcessData(action.data.newValue);
+ },
+
+ rowAdd: function rowAdd(action) {
+
+ var newRow = this.table.rowManager.addRowActual(action.data.data, action.data.pos, action.data.index);
+
+ this._rebindRow(action.component, newRow);
+ },
+
+ rowDelete: function rowDelete(action) {
+
+ action.component.delete();
+ }
+
+ };
+
+ //rebind rows to new element after deletion
+
+
+ History.prototype._rebindRow = function (oldRow, newRow) {
+
+ this.history.forEach(function (action) {
+
+ if (action.component instanceof Row) {
+
+ if (action.component === oldRow) {
+
+ action.component = newRow;
+ }
+ } else if (action.component instanceof Cell) {
+
+ if (action.component.row === oldRow) {
+
+ var field = action.component.column.getField();
+
+ if (field) {
+
+ action.component = newRow.getCell(field);
+ }
+ }
+ }
+ });
+ };
+
+ Tabulator.registerExtension("history", History);
+
+ var HtmlTableImport = function HtmlTableImport(table) {
+
+ this.table = table; //hold Tabulator object
+
+ };
+
+ HtmlTableImport.prototype.parseTable = function () {
+
+ var self = this,
+ element = self.table.element,
+ options = self.table.options,
+ columns = options.columns,
+ headers = $("th", element),
+ hasIndex = false,
+ rows = $("tbody tr", element),
+ data = [];
+
+ self.table.options.htmlImporting();
+
+ //check for tablator inline options
+
+
+ self._extractOptions(element, options);
+
+ if (headers.length) {
+
+ self._extractHeaders(element);
+ } else {
+
+ self._generateBlankHeaders(element);
+ }
+
+ //iterate through table rows and build data set
+
+
+ rows.each(function (rowIndex) {
+
+ var item = {};
+
+ //create index if the dont exist in table
+
+
+ if (!hasIndex) {
+
+ item[options.index] = rowIndex;
+ }
+
+ //add row data to item
+
+
+ $("td", $(this)).each(function (colIndex) {
+
+ item[$(this).data("field")] = $(this).html();
+ });
+
+ data.push(item);
+ });
+
+ //create new element
+
+
+ var newElement = $("");
+
+ //transfer attributes to new element
+
+
+ var attributes = element.prop("attributes");
+
+ // loop through attributes and apply them on div
+
+
+ $.each(attributes, function () {
+
+ newElement.attr(this.name, this.value);
+ });
+
+ // replace table with div element
+
+
+ element.replaceWith(newElement);
+
+ options.data = data;
+
+ self.table.options.htmlImported();
+
+ newElement.tabulator(options);
+ };
+
+ //extract tabluator attribute options
+
+
+ HtmlTableImport.prototype._extractOptions = function (element, options) {
+
+ var self = this,
+ attributes = element[0].attributes;
+
+ for (var index in attributes) {
+
+ var attrib = attributes[index];
+
+ var name;
+
+ if (attrib && attrib.name && attrib.name.indexOf("tabulator-") === 0) {
+
+ name = attrib.name.replace("tabulator-", "");
+
+ for (var key in options) {
+
+ if (key.toLowerCase() == name) {
+
+ options[key] = self._attribValue(attrib.value);
+ }
+ }
+ }
+ }
+ };
+
+ //get value of attribute
+
+
+ HtmlTableImport.prototype._attribValue = function (value) {
+
+ if (value === "true") {
+
+ return true;
+ }
+
+ if (value === "false") {
+
+ return false;
+ }
+
+ return value;
+ };
+
+ //find column if it has already been defined
+
+
+ HtmlTableImport.prototype._findCol = function (title) {
+
+ var self = this;
+
+ var match = self.table.options.columns.find(function (column) {
+
+ return column.title === title;
+ });
+
+ return match || false;
+ };
+
+ //extract column from headers
+
+
+ HtmlTableImport.prototype._extractHeaders = function (element) {
+
+ var self = this,
+ headers = $("th", element),
+ rows = $("tbody tr", element);
+
+ headers.each(function (index) {
+
+ var header = $(this),
+ exists = false,
+ col = self._findCol(header.text()),
+ width,
+ attributes;
+
+ //list of possible attributes
+
+
+ var attribList = ["title", "field", "align", "width", "minWidth", "frozen", "sortable", "sorter", "formatter", "cellClick", "cellDblClick", "cellContext", "editable", "editor", "visible", "cssClass", "tooltip", "tooltipHeader", "editableTitle", "headerFilter", "mutator", "mutateType", "accessor"];
+
+ if (col) {
+
+ exists = true;
+ } else {
+
+ col = { title: header.text().trim() };
+ }
+
+ if (!col.field) {
+
+ col.field = header.text().trim().toLowerCase().replace(" ", "_");
+ }
+
+ width = header.attr("width");
+
+ if (width && !col.width) {
+
+ col.width = width;
+ }
+
+ //check for tablator inline options
+
+
+ attributes = header[0].attributes;
+
+ //check for tablator inline options
+
+
+ for (var i in attributes) {
+
+ var attrib = attributes[i],
+ name;
+
+ if (attrib && attrib.name && attrib.name.indexOf("tabulator-") === 0) {
+
+ name = attrib.name.replace("tabulator-", "");
+
+ attribList.forEach(function (key) {
+
+ if (key.toLowerCase() == name) {
+
+ col[key] = self._attribValue(attrib.value);
+ }
+ });
+ }
+ }
+
+ $("td:eq(" + index + ")", rows).data("field", col.field);
+
+ if (col.field == self.table.options.index) {
+
+ hasIndex = true;
+ }
+
+ if (!exists) {
+
+ self.table.options.columns.push(col);
+ }
+ });
+ };
+
+ //generate blank headers
+
+
+ HtmlTableImport.prototype._generateBlankHeaders = function (element) {
+
+ var self = this;
+
+ var headers = $("tr:first td", element);
+
+ headers.each(function (index) {
+
+ var col = { title: "", field: "col" + index };
+
+ $("td:eq(" + index + ")", rows).data("field", col.field);
+
+ var width = $(this).attr("width");
+
+ if (width) {
+
+ col.width = width;
+ }
+
+ self.table.options.columns.push(col);
+ });
+ };
+
+ Tabulator.registerExtension("htmlTableImport", HtmlTableImport);
+
+ var Keybindings = function Keybindings(table) {
+
+ this.table = table; //hold Tabulator object
+
+
+ this.watchKeys = null;
+
+ this.pressedKeys = null;
+ };
+
+ Keybindings.prototype.initialize = function () {
+
+ var bindings = this.table.options.keybindings,
+ mergedBindings = {};
+
+ this.watchKeys = {};
+
+ this.pressedKeys = [];
+
+ if (bindings !== false) {
+
+ for (var key in this.bindings) {
+
+ mergedBindings[key] = this.bindings[key];
+ }
+
+ if (Object.keys(bindings).length) {
+
+ for (var _key in bindings) {
+
+ mergedBindings[_key] = bindings[_key];
+ }
+ }
+
+ this.mapBindings(mergedBindings);
+
+ this.bindEvents();
+ }
+ };
+
+ Keybindings.prototype.mapBindings = function (bindings) {
+ var _this = this;
+
+ var self = this;
+
+ var _loop2 = function _loop2(key) {
+
+ if (_this.actions[key]) {
+
+ if (bindings[key]) {
+
+ if (_typeof(bindings[key]) !== "object") {
+
+ bindings[key] = [bindings[key]];
+ }
+
+ bindings[key].forEach(function (binding) {
+
+ self.mapBinding(key, binding);
+ });
+ }
+ } else {
+
+ console.warn("Key Binding Error - no such action:", key);
+ }
+ };
+
+ for (var key in bindings) {
+ _loop2(key);
+ }
+ };
+
+ Keybindings.prototype.mapBinding = function (action, symbolsList) {
+
+ var self = this;
+
+ var binding = {
+
+ action: this.actions[action],
+
+ keys: [],
+
+ ctrl: false,
+
+ shift: false
+
+ };
+
+ var symbols = symbolsList.toString().toLowerCase().split(" ").join("").split("+");
+
+ symbols.forEach(function (symbol) {
+
+ switch (symbol) {
+
+ case "ctrl":
+
+ binding.ctrl = true;
+
+ break;
+
+ case "shift":
+
+ binding.shift = true;
+
+ break;
+
+ default:
+
+ symbol = parseInt(symbol);
+
+ binding.keys.push(symbol);
+
+ if (!self.watchKeys[symbol]) {
+
+ self.watchKeys[symbol] = [];
+ }
+
+ self.watchKeys[symbol].push(binding);
+
+ }
+ });
+ };
+
+ Keybindings.prototype.bindEvents = function () {
+
+ var self = this;
+
+ this.table.element.on("keydown", function (e) {
+
+ var code = e.keyCode;
+
+ var bindings = self.watchKeys[code];
+
+ if (bindings) {
+
+ self.pressedKeys.push(code);
+
+ bindings.forEach(function (binding) {
+
+ self.checkBinding(e, binding);
+ });
+ }
+ });
+
+ this.table.element.on("keyup", function (e) {
+
+ var code = e.keyCode;
+
+ var bindings = self.watchKeys[code];
+
+ if (bindings) {
+
+ var index = self.pressedKeys.indexOf(code);
+
+ if (index > -1) {
+
+ self.pressedKeys.splice(index, 1);
+ }
+ }
+ });
+ };
+
+ Keybindings.prototype.checkBinding = function (e, binding) {
+
+ var self = this,
+ match = true;
+
+ if (e.ctrlKey == binding.ctrl && e.shiftKey == binding.shift) {
+
+ binding.keys.forEach(function (key) {
+
+ var index = self.pressedKeys.indexOf(key);
+
+ if (index == -1) {
+
+ match = false;
+ }
+ });
+
+ if (match) {
+
+ binding.action.call(self, e);
+ }
+
+ return true;
+ }
+
+ return false;
+ };
+
+ //default bindings
+
+
+ Keybindings.prototype.bindings = {
+
+ navPrev: "shift + 9",
+
+ navNext: 9,
+
+ navUp: 38,
+
+ navDown: 40,
+
+ scrollPageUp: 33,
+
+ scrollPageDown: 34,
+
+ scrollToStart: 36,
+
+ scrollToEnd: 35,
+
+ undo: "ctrl + 90",
+
+ redo: "ctrl + 89"
+
+ };
+
+ //default actions
+
+
+ Keybindings.prototype.actions = {
+
+ keyBlock: function keyBlock(e) {
+
+ e.stopPropagation();
+
+ e.preventDefault();
+ },
+
+ scrollPageUp: function scrollPageUp(e) {
+
+ var rowManager = this.table.rowManager,
+ newPos = rowManager.scrollTop - rowManager.height,
+ scrollMax = rowManager.element[0].scrollHeight;
+
+ e.preventDefault();
+
+ if (rowManager.displayRowsCount) {
+
+ if (newPos >= 0) {
+
+ rowManager.element.scrollTop(newPos);
+ } else {
+
+ rowManager.scrollToRow(rowManager.displayRows[0]);
+ }
+ }
+
+ this.table.element.focus();
+ },
+
+ scrollPageDown: function scrollPageDown(e) {
+
+ var rowManager = this.table.rowManager,
+ newPos = rowManager.scrollTop + rowManager.height,
+ scrollMax = rowManager.element[0].scrollHeight;
+
+ e.preventDefault();
+
+ if (rowManager.displayRowsCount) {
+
+ if (newPos <= scrollMax) {
+
+ rowManager.element.scrollTop(newPos);
+ } else {
+
+ rowManager.scrollToRow(rowManager.displayRows[rowManager.displayRows.length - 1]);
+ }
+ }
+
+ this.table.element.focus();
+ },
+
+ scrollToStart: function scrollToStart(e) {
+
+ var rowManager = this.table.rowManager;
+
+ e.preventDefault();
+
+ if (rowManager.displayRowsCount) {
+
+ rowManager.scrollToRow(rowManager.displayRows[0]);
+ }
+
+ this.table.element.focus();
+ },
+
+ scrollToEnd: function scrollToEnd(e) {
+
+ var rowManager = this.table.rowManager;
+
+ e.preventDefault();
+
+ if (rowManager.displayRowsCount) {
+
+ rowManager.scrollToRow(rowManager.displayRows[rowManager.displayRows.length - 1]);
+ }
+
+ this.table.element.focus();
+ },
+
+ navPrev: function navPrev(e) {
+
+ var cell = false;
+
+ if (this.table.extExists("edit")) {
+
+ cell = this.table.extensions.edit.currentCell;
+
+ if (cell) {
+
+ e.preventDefault();
+
+ cell.nav().prev();
+ }
+ }
+ },
+
+ navNext: function navNext(e) {
+
+ var cell = false;
+
+ if (this.table.extExists("edit")) {
+
+ cell = this.table.extensions.edit.currentCell;
+
+ if (cell) {
+
+ e.preventDefault();
+
+ cell.nav().next();
+ }
+ }
+ },
+
+ navLeft: function navLeft(e) {
+
+ var cell = false;
+
+ if (this.table.extExists("edit")) {
+
+ cell = this.table.extensions.edit.currentCell;
+
+ if (cell) {
+
+ e.preventDefault();
+
+ cell.nav().left();
+ }
+ }
+ },
+
+ navRight: function navRight(e) {
+
+ var cell = false;
+
+ if (this.table.extExists("edit")) {
+
+ cell = this.table.extensions.edit.currentCell;
+
+ if (cell) {
+
+ e.preventDefault();
+
+ cell.nav().right();
+ }
+ }
+ },
+
+ navUp: function navUp(e) {
+
+ var cell = false;
+
+ if (this.table.extExists("edit")) {
+
+ cell = this.table.extensions.edit.currentCell;
+
+ if (cell) {
+
+ e.preventDefault();
+
+ cell.nav().up();
+ }
+ }
+ },
+
+ navDown: function navDown(e) {
+
+ var cell = false;
+
+ if (this.table.extExists("edit")) {
+
+ cell = this.table.extensions.edit.currentCell;
+
+ if (cell) {
+
+ e.preventDefault();
+
+ cell.nav().down();
+ }
+ }
+ },
+
+ undo: function undo(e) {
+
+ var cell = false;
+
+ if (this.table.options.history && this.table.extExists("history") && this.table.extExists("edit")) {
+
+ cell = this.table.extensions.edit.currentCell;
+
+ if (!cell) {
+
+ e.preventDefault();
+
+ this.table.extensions.history.undo();
+ }
+ }
+ },
+
+ redo: function redo(e) {
+
+ var cell = false;
+
+ if (this.table.options.history && this.table.extExists("history") && this.table.extExists("edit")) {
+
+ cell = this.table.extensions.edit.currentCell;
+
+ if (!cell) {
+
+ e.preventDefault();
+
+ this.table.extensions.history.redo();
+ }
+ }
+ }
+
+ };
+
+ Tabulator.registerExtension("keybindings", Keybindings);
+
+ var MoveColumns = function MoveColumns(table) {
+
+ this.table = table; //hold Tabulator object
+
+
+ this.placeholderElement = $("");
+
+ this.hoverElement = $(); //floating column header element
+
+
+ this.checkTimeout = false; //click check timeout holder
+
+
+ this.checkPeriod = 250; //period to wait on mousedown to consider this a move and not a click
+
+
+ this.moving = false; //currently moving column
+
+
+ this.toCol = false; //destination column
+
+
+ this.toColAfter = false; //position of moving column relative to the desitnation column
+
+
+ this.startX = 0; //starting position within header element
+
+
+ this.autoScrollMargin = 40; //auto scroll on edge when within margin
+
+
+ this.autoScrollStep = 5; //auto scroll distance in pixels
+
+
+ this.autoScrollTimeout = false; //auto scroll timeout
+
+
+ this.moveHover = this.moveHover.bind(this);
+
+ this.endMove = this.endMove.bind(this);
+ };
+
+ MoveColumns.prototype.initializeColumn = function (column) {
+
+ var self = this,
+ config = {};
+
+ if (!column.extensions.frozen) {
+
+ config.mousemove = function (e) {
+
+ if (column.parent === self.moving.parent) {
+
+ if (e.pageX - column.element.offset().left + self.table.columnManager.element.scrollLeft() > column.getWidth() / 2) {
+
+ if (self.toCol !== column || !self.toColAfter) {
+
+ column.element.after(self.placeholderElement);
+
+ self.moveColumn(column, true);
+ }
+ } else {
+
+ if (self.toCol !== column || self.toColAfter) {
+
+ column.element.before(self.placeholderElement);
+
+ self.moveColumn(column, false);
+ }
+ }
+ }
+ }.bind(self);
+
+ column.getElement().on("mousedown", function (e) {
+
+ self.checkTimeout = setTimeout(function () {
+
+ self.startMove(e, column);
+ }, self.checkPeriod);
+ });
+
+ column.getElement().on("mouseup", function (e) {
+
+ if (self.checkTimeout) {
+
+ clearTimeout(self.checkTimeout);
+ }
+ });
+ }
+
+ column.extensions.moveColumn = config;
+ };
+
+ MoveColumns.prototype.startMove = function (e, column) {
+
+ var self = this,
+ element = column.getElement();
+
+ self.moving = column;
+
+ self.startX = e.pageX - element.offset().left;
+
+ self.table.element.addClass("tabulator-block-select");
+
+ //create placeholder
+
+
+ self.placeholderElement.css({
+
+ width: column.getWidth(),
+
+ height: column.getHeight()
+
+ });
+
+ element.before(self.placeholderElement);
+
+ element.detach();
+
+ //create hover element
+
+
+ self.hoverElement = element.clone();
+
+ self.hoverElement.addClass("tabulator-moving");
+
+ self.table.columnManager.getElement().append(self.hoverElement);
+
+ self.hoverElement.css({
+
+ "left": 0,
+
+ "bottom": 0
+
+ });
+
+ self._bindMouseMove();
+
+ $("body").on("mousemove", self.moveHover);
+
+ $("body").on("mouseup", self.endMove);
+
+ self.moveHover(e);
+ };
+
+ MoveColumns.prototype._bindMouseMove = function () {
+
+ var self = this;
+
+ self.table.columnManager.columnsByIndex.forEach(function (column) {
+
+ if (column.extensions.moveColumn.mousemove) {
+
+ column.element.on("mousemove", column.extensions.moveColumn.mousemove);
+ }
+ });
+ };
+
+ MoveColumns.prototype._unbindMouseMove = function () {
+
+ var self = this;
+
+ self.table.columnManager.columnsByIndex.forEach(function (column) {
+
+ if (column.extensions.moveColumn.mousemove) {
+
+ column.element.off("mousemove", column.extensions.moveColumn.mousemove);
+ }
+ });
+ };
+
+ MoveColumns.prototype.moveColumn = function (column, after) {
+
+ var self = this,
+ movingCells = this.moving.getCells();
+
+ self.toCol = column;
+
+ self.toColAfter = after;
+
+ if (after) {
+
+ column.getCells().forEach(function (cell, i) {
+
+ cell.getElement().after(movingCells[i].getElement());
+ });
+ } else {
+
+ column.getCells().forEach(function (cell, i) {
+
+ cell.getElement().before(movingCells[i].getElement());
+ });
+ }
+ };
+
+ MoveColumns.prototype.endMove = function (column) {
+
+ var self = this;
+
+ self._unbindMouseMove();
+
+ self.placeholderElement.after(self.moving.getElement());
+
+ self.placeholderElement.detach();
+
+ self.hoverElement.detach();
+
+ self.table.element.removeClass("tabulator-block-select");
+
+ if (self.toCol) {
+
+ self.table.columnManager.moveColumn(self.moving, self.toCol, self.toColAfter);
+ }
+
+ self.moving = false;
+
+ self.toCol = false;
+
+ self.toColAfter = false;
+
+ $("body").off("mousemove", self.moveHover);
+
+ $("body").off("mouseup", self.endMove);
+ };
+
+ MoveColumns.prototype.moveHover = function (e) {
+
+ var self = this,
+ columnHolder = self.table.columnManager.getElement(),
+ scrollLeft = columnHolder.scrollLeft(),
+ xPos = e.pageX - columnHolder.offset().left + scrollLeft,
+ scrollPos;
+
+ self.hoverElement.css({
+
+ "left": xPos - self.startX
+
+ });
+
+ if (xPos - scrollLeft < self.autoScrollMargin) {
+
+ if (!self.autoScrollTimeout) {
+
+ self.autoScrollTimeout = setTimeout(function () {
+
+ scrollPos = Math.max(0, scrollLeft - 5);
+
+ self.table.rowManager.getElement().scrollLeft(scrollPos);
+
+ self.autoScrollTimeout = false;
+ }, 1);
+ }
+ }
+
+ if (scrollLeft + columnHolder.innerWidth() - xPos < self.autoScrollMargin) {
+
+ if (!self.autoScrollTimeout) {
+
+ self.autoScrollTimeout = setTimeout(function () {
+
+ scrollPos = Math.min(columnHolder.innerWidth(), scrollLeft + 5);
+
+ self.table.rowManager.getElement().scrollLeft(scrollPos);
+
+ self.autoScrollTimeout = false;
+ }, 1);
+ }
+ }
+ };
+
+ Tabulator.registerExtension("moveColumn", MoveColumns);
+
+ var MoveRows = function MoveRows(table) {
+
+ this.table = table; //hold Tabulator object
+
+
+ this.placeholderElement = $("");
+
+ this.hoverElement = $(); //floating row header element
+
+
+ this.checkTimeout = false; //click check timeout holder
+
+
+ this.checkPeriod = 150; //period to wait on mousedown to consider this a move and not a click
+
+
+ this.moving = false; //currently moving row
+
+
+ this.toRow = false; //destination row
+
+
+ this.toRowAfter = false; //position of moving row relative to the desitnation row
+
+
+ this.hasHandle = false; //row has handle instead of fully movable row
+
+
+ this.startY = 0; //starting position within header element
+
+
+ this.moveHover = this.moveHover.bind(this);
+
+ this.endMove = this.endMove.bind(this);
+ };
+
+ MoveRows.prototype.setHandle = function (handle) {
+
+ this.hasHandle = handle;
+ };
+
+ MoveRows.prototype.initializeRow = function (row) {
+
+ var self = this,
+ config = {};
+
+ config.mousemove = function (e) {
+
+ if (e.pageY - row.element.offset().top + self.table.rowManager.element.scrollTop() > row.getHeight() / 2) {
+
+ if (self.toRow !== row || !self.toRowAfter) {
+
+ row.element.after(self.placeholderElement);
+
+ self.moveRow(row, true);
+ }
+ } else {
+
+ if (self.toRow !== row || self.toRowAfter) {
+
+ row.element.before(self.placeholderElement);
+
+ self.moveRow(row, false);
+ }
+ }
+ }.bind(self);
+
+ if (!this.hasHandle) {
+
+ row.getElement().on("mousedown", function (e) {
+
+ self.checkTimeout = setTimeout(function () {
+
+ self.startMove(e, row);
+ }, self.checkPeriod);
+ });
+
+ row.getElement().on("mouseup", function (e) {
+
+ if (self.checkTimeout) {
+
+ clearTimeout(self.checkTimeout);
+ }
+ });
+ }
+
+ row.extensions.moveRow = config;
+ };
+
+ MoveRows.prototype.initializeCell = function (cell) {
+
+ var self = this;
+
+ cell.getElement().on("mousedown", function (e) {
+
+ self.checkTimeout = setTimeout(function () {
+
+ self.startMove(e, cell.row);
+ }, self.checkPeriod);
+ });
+
+ cell.getElement().on("mouseup", function (e) {
+
+ if (self.checkTimeout) {
+
+ clearTimeout(self.checkTimeout);
+ }
+ });
+ };
+
+ MoveRows.prototype._bindMouseMove = function () {
+
+ var self = this;
+
+ self.table.rowManager.displayRows.forEach(function (row) {
+
+ if (row.type === "row" && row.extensions.moveRow.mousemove) {
+
+ row.element.on("mousemove", row.extensions.moveRow.mousemove);
+ }
+ });
+ };
+
+ MoveRows.prototype._unbindMouseMove = function () {
+
+ var self = this;
+
+ self.table.rowManager.displayRows.forEach(function (row) {
+
+ if (row.type === "row" && row.extensions.moveRow.mousemove) {
+
+ row.element.off("mousemove", row.extensions.moveRow.mousemove);
+ }
+ });
+ };
+
+ MoveRows.prototype.startMove = function (e, row) {
+
+ var self = this,
+ element = row.getElement();
+
+ self.moving = row;
+
+ self.startY = e.pageY - element.offset().top;
+
+ self.table.element.addClass("tabulator-block-select");
+
+ //create placeholder
+
+
+ self.placeholderElement.css({
+
+ width: row.getWidth(),
+
+ height: row.getHeight()
+
+ });
+
+ element.before(self.placeholderElement);
+
+ element.detach();
+
+ //create hover element
+
+
+ self.hoverElement = element.clone();
+
+ self.hoverElement.addClass("tabulator-moving");
+
+ self.table.rowManager.getTableElement().append(self.hoverElement);
+
+ self.hoverElement.css({
+
+ "left": 0,
+
+ "top": 0
+
+ });
+
+ self._bindMouseMove();
+
+ $("body").on("mousemove", self.moveHover);
+
+ $("body").on("mouseup", self.endMove);
+
+ self.moveHover(e);
+ };
+
+ MoveRows.prototype.endMove = function (column) {
+
+ var self = this;
+
+ self._unbindMouseMove();
+
+ self.placeholderElement.after(self.moving.getElement());
+
+ self.placeholderElement.detach();
+
+ self.hoverElement.detach();
+
+ self.table.element.removeClass("tabulator-block-select");
+
+ if (self.toRow) {
+
+ self.table.rowManager.moveRow(self.moving, self.toRow, self.toRowAfter);
+ }
+
+ self.moving = false;
+
+ self.toRow = false;
+
+ self.toRowAfter = false;
+
+ $("body").off("mousemove", self.moveHover);
+
+ $("body").off("mouseup", self.endMove);
+ };
+
+ MoveRows.prototype.moveRow = function (row, after) {
+
+ var self = this;
+
+ self.toRow = row;
+
+ self.toRowAfter = after;
+ };
+
+ MoveRows.prototype.moveHover = function (e) {
+
+ var self = this,
+ rowHolder = self.table.rowManager.getElement(),
+ scrollTop = rowHolder.scrollTop(),
+ yPos = e.pageY - rowHolder.offset().top + scrollTop,
+ scrollPos;
+
+ self.hoverElement.css({
+
+ "top": yPos - self.startY
+
+ });
+ };
+
+ Tabulator.registerExtension("moveRow", MoveRows);
+
+ var Mutator = function Mutator(table) {
+
+ this.table = table; //hold Tabulator object
+
+ };
+
+ //initialize column mutator
+
+
+ Mutator.prototype.initializeColumn = function (column) {
+
+ var config = { mutator: false, type: column.definition.mutateType, params: column.definition.mutatorParams || {} };
+
+ //set column mutator
+
+
+ switch (_typeof(column.definition.mutator)) {
+
+ case "string":
+
+ if (this.mutators[column.definition.mutator]) {
+
+ config.mutator = this.mutators[column.definition.mutator];
+ } else {
+
+ console.warn("Mutator Error - No such mutator found, ignoring: ", column.definition.mutator);
+ }
+
+ break;
+
+ case "function":
+
+ config.mutator = column.definition.mutator;
+
+ break;
+
+ }
+
+ if (config.mutator) {
+
+ column.extensions.mutate = config;
+ }
+ };
+
+ //apply mutator to row
+
+
+ Mutator.prototype.transformRow = function (data) {
+
+ var self = this;
+
+ self.table.columnManager.traverse(function (column) {
+
+ var field;
+
+ if (column.extensions.mutate) {
+
+ field = column.getField();
+
+ if (column.extensions.mutate.type != "edit") {
+
+ column.setFieldValue(data, column.extensions.mutate.mutator(column.getFieldValue(data), data, "data", column.extensions.mutate.params));
+ }
+ }
+ });
+
+ return data;
+ };
+
+ //apply mutator to new cell value
+
+
+ Mutator.prototype.transformCell = function (cell, value) {
+
+ return cell.column.extensions.mutate.mutator(value, cell.row.getData(), "edit", cell.column.extensions.mutate.params, cell.getComponent());
+ };
+
+ //default mutators
+
+
+ Mutator.prototype.mutators = {};
+
+ Tabulator.registerExtension("mutator", Mutator);
+
+ var Page = function Page(table) {
+
+ this.table = table; //hold Tabulator object
+
+
+ this.element = $("");
+
+ this.pagesElement = $("");
+
+ this.firstBut = $("");
+
+ this.prevBut = $("");
+
+ this.nextBut = $("");
+
+ this.lastBut = $("");
+
+ this.mode = "local";
+
+ this.size = 0;
+
+ this.page = 1;
+
+ this.max = 1;
+
+ this.paginator = false;
+ };
+
+ //setup pageination
+
+
+ Page.prototype.initialize = function () {
+
+ var self = this;
+
+ //update param names
+
+
+ for (var key in self.table.options.paginationDataSent) {
+
+ self.paginationDataSentNames[key] = self.table.options.paginationDataSent[key];
+ }
+
+ for (var _key2 in self.table.options.paginationDataReceived) {
+
+ self.paginationDataReceivedNames[_key2] = self.table.options.paginationDataReceived[_key2];
+ }
+
+ if (self.table.options.paginator) {
+
+ self.paginator = self.table.options.paginator;
+ }
+
+ //build pagination element
+
+
+ //bind localizations
+
+
+ self.table.extensions.localize.bind("pagination.first", function (value) {
+
+ self.firstBut.html(value);
+ });
+
+ self.table.extensions.localize.bind("pagination.first_title", function (value) {
+
+ self.firstBut.attr("aria-label", value).attr("title", value);
+ });
+
+ self.table.extensions.localize.bind("pagination.prev", function (value) {
+
+ self.prevBut.html(value);
+ });
+
+ self.table.extensions.localize.bind("pagination.prev_title", function (value) {
+
+ self.prevBut.attr("aria-label", value).attr("title", value);
+ });
+
+ self.table.extensions.localize.bind("pagination.next", function (value) {
+
+ self.nextBut.html(value);
+ });
+
+ self.table.extensions.localize.bind("pagination.next_title", function (value) {
+
+ self.nextBut.attr("aria-label", value).attr("title", value);
+ });
+
+ self.table.extensions.localize.bind("pagination.last", function (value) {
+
+ self.lastBut.html(value);
+ });
+
+ self.table.extensions.localize.bind("pagination.last_title", function (value) {
+
+ self.lastBut.attr("aria-label", value).attr("title", value);
+ });
+
+ //click bindings
+
+
+ self.firstBut.on("click", function () {
+
+ self.setPage(1);
+ });
+
+ self.prevBut.on("click", function () {
+
+ self.previousPage();
+ });
+
+ self.nextBut.on("click", function () {
+
+ self.nextPage();
+ });
+
+ self.lastBut.on("click", function () {
+
+ self.setPage(self.max);
+ });
+
+ if (self.table.options.paginationElement) {
+
+ self.element = self.table.options.paginationElement;
+ }
+
+ //append to DOM
+
+
+ self.element.append(self.firstBut);
+
+ self.element.append(self.prevBut);
+
+ self.element.append(self.pagesElement);
+
+ self.element.append(self.nextBut);
+
+ self.element.append(self.lastBut);
+
+ if (!self.table.options.paginationElement) {
+
+ self.table.footerManager.append(self.element, self);
+ }
+
+ //set default values
+
+
+ self.mode = self.table.options.pagination;
+
+ self.size = self.table.options.paginationSize || Math.floor(self.table.rowManager.getElement().innerHeight() / 26);
+ };
+
+ //calculate maximum page from number of rows
+
+
+ Page.prototype.setMaxRows = function (rowCount) {
+
+ if (!rowCount) {
+
+ this.max = 1;
+ } else {
+
+ this.max = Math.ceil(rowCount / this.size);
+ }
+
+ if (this.page > this.max) {
+
+ this.page = this.max;
+ }
+ };
+
+ //reset to first page without triggering action
+
+
+ Page.prototype.reset = function (force) {
+
+ if (this.mode == "local" || force) {
+
+ this.page = 1;
+ }
+
+ return true;
+ };
+
+ //set the maxmum page
+
+
+ Page.prototype.setMaxPage = function (max) {
+
+ this.max = max || 1;
+
+ if (this.page > this.max) {
+
+ this.page = this.max;
+
+ this.trigger();
+ }
+ };
+
+ //set current page number
+
+
+ Page.prototype.setPage = function (page) {
+
+ if (page > 0 && page <= this.max) {
+
+ this.page = page;
+
+ this.trigger();
+
+ return true;
+ } else {
+
+ console.warn("Pagination Error - Requested page is out of range of 1 - " + this.max + ":", page);
+
+ return false;
+ }
+ };
+
+ Page.prototype.setPageSize = function (size) {
+
+ if (size > 0) {
+
+ this.size = size;
+ }
+ };
+
+ //setup the pagination buttons
+
+
+ Page.prototype._setPageButtons = function () {
+
+ var self = this;
+
+ var min = this.page < this.max - 2 ? this.page - 2 : this.page - (4 - (this.max - this.page));
+
+ var max = this.page > 3 ? this.page + 2 : this.page + (5 - this.page);
+
+ self.pagesElement.empty();
+
+ if (self.page == 1) {
+
+ self.firstBut.prop("disabled", true);
+
+ self.prevBut.prop("disabled", true);
+ } else {
+
+ self.firstBut.prop("disabled", false);
+
+ self.prevBut.prop("disabled", false);
+ }
+
+ if (self.page == self.max) {
+
+ self.lastBut.prop("disabled", true);
+
+ self.nextBut.prop("disabled", true);
+ } else {
+
+ self.lastBut.prop("disabled", false);
+
+ self.nextBut.prop("disabled", false);
+ }
+
+ for (var i = min; i <= max; i++) {
+
+ if (i > 0 && i <= self.max) {
+
+ self.pagesElement.append(self._generatePageButton(i));
+ }
+ }
+
+ this.footerRedraw();
+ };
+
+ Page.prototype._generatePageButton = function (page) {
+
+ var self = this;
+
+ var button = $("");
+
+ button.on("click", function (e) {
+
+ self.setPage(page);
+ });
+
+ return button;
+ };
+
+ //previous page
+
+
+ Page.prototype.previousPage = function () {
+
+ if (this.page > 1) {
+
+ this.page--;
+
+ this.trigger();
+
+ return true;
+ } else {
+
+ console.warn("Pagination Error - Previous page would be less than page 1:", 0);
+
+ return false;
+ }
+ };
+
+ //next page
+
+
+ Page.prototype.nextPage = function () {
+
+ if (this.page < this.max) {
+
+ this.page++;
+
+ this.trigger();
+
+ return true;
+ } else {
+
+ console.warn("Pagination Error - Next page would be greater than maximum page of " + this.max + ":", this.max + 1);
+
+ return false;
+ }
+ };
+
+ //return current page number
+
+
+ Page.prototype.getPage = function () {
+
+ return this.page;
+ };
+
+ //return max page number
+
+
+ Page.prototype.getPageMax = function () {
+
+ return this.max;
+ };
+
+ Page.prototype.getPageSize = function (size) {
+ ;
+
+ return this.size;
+ };
+
+ Page.prototype.getMode = function () {
+
+ return this.mode;
+ };
+
+ //return appropriate rows for current page
+
+
+ Page.prototype.getRows = function (data) {
+
+ var output, start, end;
+
+ if (this.mode == "local") {
+
+ output = [];
+
+ start = this.size * (this.page - 1);
+
+ end = start + parseInt(this.size);
+
+ this._setPageButtons();
+
+ for (var i = start; i < end; i++) {
+
+ if (data[i]) {
+
+ output.push(data[i]);
+ }
+ }
+
+ return output;
+ } else {
+
+ this._setPageButtons();
+
+ return data.slice(0);
+ }
+ };
+
+ Page.prototype.trigger = function () {
+
+ switch (this.mode) {
+
+ case "local":
+
+ this.table.rowManager.refreshActiveData();
+
+ this.table.options.pageLoaded(this.getPage());
+
+ break;
+
+ case "remote":
+
+ this._getRemotePage();
+
+ break;
+
+ default:
+
+ console.warn("Pagination Error - no such pagination mode:", this.mode);
+
+ }
+ };
+
+ Page.prototype._getRemotePage = function () {
+
+ if (this.table.extExists("ajax", true)) {
+
+ if (this.paginator) {
+
+ this._getRemotePagePaginator();
+ } else {
+
+ this._getRemotePageAuto();
+ }
+ }
+ };
+
+ Page.prototype._getRemotePagePaginator = function () {
+
+ var self = this,
+ ajax = self.table.extensions.ajax,
+ oldUrl = ajax.getUrl();
+
+ ajax.setUrl(self.paginator(ajax.getUrl(), self.page, self.size, ajax.getParams()));
+
+ ajax.sendRequest(function (data) {
+
+ self._parseRemoteData(data);
+ });
+
+ ajax.setUrl(oldUrl);
+ };
+
+ Page.prototype._getRemotePageAuto = function () {
+
+ var self = this,
+ oldParams,
+ pageParams;
+
+ //record old params and restore after request has been made
+
+
+ oldParams = $.extend(true, {}, self.table.extensions.ajax.getParams());
+
+ pageParams = self.table.extensions.ajax.getParams();
+
+ //configure request params
+
+
+ pageParams[this.paginationDataSentNames.page] = self.page;
+
+ //set page size if defined
+
+
+ if (this.size) {
+
+ pageParams[this.paginationDataSentNames.size] = this.size;
+ }
+
+ //set sort data if defined
+
+
+ if (this.table.extExists("sort")) {
+
+ var sorters = self.table.extensions.sort.getSort();
+
+ sorters.forEach(function (item) {
+
+ delete item.column;
+ });
+
+ pageParams[this.paginationDataSentNames.sorters] = sorters;
+ }
+
+ //set filter data if defined
+
+
+ if (this.table.extExists("filter")) {
+
+ var filters = self.table.extensions.filter.getFilters(true, true);
+
+ pageParams[this.paginationDataSentNames.filters] = filters;
+ }
+
+ self.table.extensions.ajax.setParams(pageParams);
+
+ self.table.extensions.ajax.sendRequest(function (data) {
+
+ self._parseRemoteData(data);
+ });
+
+ self.table.extensions.ajax.setParams(oldParams);
+ };
+
+ Page.prototype._parseRemoteData = function (data) {
+
+ if (data[this.paginationDataReceivedNames.last_page]) {
+
+ if (data[this.paginationDataReceivedNames.data]) {
+
+ this.max = parseInt(data[this.paginationDataReceivedNames.last_page]);
+
+ this.table.rowManager.setData(data[this.paginationDataReceivedNames.data]);
+
+ this.table.options.pageLoaded(this.getPage());
+ } else {
+
+ console.warn("Remote Pagination Error - Server response missing '" + this.paginationDataReceivedNames.data + "' property");
+ }
+ } else {
+
+ console.warn("Remote Pagination Error - Server response missing '" + this.paginationDataReceivedNames.last_page + "' property");
+ }
+ };
+
+ //handle the footer element being redrawn
+
+
+ Page.prototype.footerRedraw = function () {
+
+ var footer = this.table.footerManager.element;
+
+ if (footer.innerWidth() - footer[0].scrollWidth < 0) {
+
+ this.pagesElement.hide();
+ } else {
+
+ this.pagesElement.show();
+
+ if (footer.innerWidth() - footer[0].scrollWidth < 0) {
+
+ this.pagesElement.hide();
+ }
+ }
+ };
+
+ //set the paramter names for pagination requests
+
+
+ Page.prototype.paginationDataSentNames = {
+
+ "page": "page",
+
+ "size": "size",
+
+ "sorters": "sorters",
+
+ // "sort_dir":"sort_dir",
+
+
+ "filters": "filters"
+
+ };
+
+ //set the property names for pagination responses
+
+
+ Page.prototype.paginationDataReceivedNames = {
+
+ "current_page": "current_page",
+
+ "last_page": "last_page",
+
+ "data": "data"
+
+ };
+
+ Tabulator.registerExtension("page", Page);
+
+ var PersistentLayout = function PersistentLayout(table) {
+
+ this.table = table; //hold Tabulator object
+
+
+ this.mode = "";
+
+ this.id = "";
+
+ this.persistProps = ["field", "width", "visible"];
+ };
+
+ //setup parameters
+
+
+ PersistentLayout.prototype.initialize = function (mode, id) {
+
+ //determine persistent layout storage type
+
+
+ this.mode = mode !== true ? mode : typeof window.localStorage !== 'undefined' ? "local" : "cookie";
+
+ //set storage tag
+
+
+ this.id = "tabulator-" + (id || this.table.element.attr("id") || "");
+ };
+
+ //load saved definitions
+
+
+ PersistentLayout.prototype.load = function (definition) {
+
+ var newDefinition = "";
+
+ switch (this.mode) {
+
+ case "local":
+
+ newDefinition = localStorage.getItem(this.id);
+
+ break;
+
+ case "cookie":
+
+ //find cookie
+
+
+ var cookie = document.cookie,
+ cookiePos = cookie.indexOf(this.id + "="),
+ end = void 0;
+
+ //if cookie exists, decode and load column data into tabulator
+
+
+ if (cookiePos > -1) {
+
+ cookie = cookie.substr(cookiePos);
+
+ end = cookie.indexOf(";");
+
+ if (end > -1) {
+
+ cookie = cookie.substr(0, end);
+ }
+
+ newDefinition = cookie.replace(this.id + "=", "");
+ }
+
+ break;
+
+ default:
+
+ console.warn("Persistance Load Error - invalid mode selected", this.mode);
+
+ }
+
+ if (newDefinition) {
+
+ newDefinition = JSON.parse(newDefinition);
+
+ definition = this.mergeDefinition(definition, newDefinition);
+ }
+
+ return definition;
+ };
+
+ //merge old and new column defintions
+
+
+ PersistentLayout.prototype.mergeDefinition = function (oldCols, newCols) {
+
+ var self = this,
+ output = [];
+
+ newCols.forEach(function (column, to) {
+
+ var from = self._findColumn(oldCols, column);
+
+ if (from) {
+
+ from.width = column.width;
+
+ from.visible = column.visible;
+
+ if (from.columns) {
+
+ from.columns = self.mergeDefinition(from.columns, column.columns);
+ }
+
+ output.push(from);
+ }
+ });
+
+ return output;
+ };
+
+ //find matching columns
+
+
+ PersistentLayout.prototype._findColumn = function (columns, subject) {
+
+ var type = subject.columns ? "group" : subject.field ? "field" : "object";
+
+ return columns.find(function (col) {
+
+ switch (type) {
+
+ case "group":
+
+ return col.title === subject.title && col.columns.length === subject.columns.length;
+
+ break;
+
+ case "field":
+
+ return col.field === subject.field;
+
+ break;
+
+ case "object":
+
+ return col === subject;
+
+ break;
+
+ }
+ });
+ };
+
+ //save current definitions
+
+
+ PersistentLayout.prototype.save = function () {
+
+ var definition = this.parseColumns(this.table.columnManager.getColumns()),
+ data = JSON.stringify(definition);
+
+ switch (this.mode) {
+
+ case "local":
+
+ localStorage.setItem(this.id, data);
+
+ break;
+
+ case "cookie":
+
+ var expireDate = new Date();
+
+ expireDate.setDate(expireDate.getDate() + 10000);
+
+ //save cookie
+
+
+ document.cookie = this.id + "=" + data + "; expires=" + expireDate.toUTCString();
+
+ break;
+
+ default:
+
+ console.warn("Persistance Save Error - invalid mode selected", this.mode);
+
+ }
+ };
+
+ //build premission list
+
+
+ PersistentLayout.prototype.parseColumns = function (columns) {
+
+ var self = this,
+ definitions = [];
+
+ columns.forEach(function (column) {
+
+ var def = {};
+
+ if (column.isGroup) {
+
+ def.title = column.getDefinition().title;
+
+ def.columns = self.parseColumns(column.getColumns());
+ } else {
+
+ def.title = column.getDefinition().title;
+
+ def.field = column.getField();
+
+ def.width = column.getWidth();
+
+ def.visible = column.visible;
+ }
+
+ definitions.push(def);
+ });
+
+ return definitions;
+ };
+
+ Tabulator.registerExtension("persistentLayout", PersistentLayout);
+
+ var ResizeColumns = function ResizeColumns(table) {
+
+ this.table = table; //hold Tabulator object
+
+
+ this.startColumn = false;
+
+ this.startX = false;
+
+ this.startWidth = false;
+
+ this.handle = null;
+
+ this.prevHandle = null;
+ };
+
+ ResizeColumns.prototype.initializeColumn = function (type, column, element) {
+
+ var self = this,
+ variableHeight = false,
+ mode = this.table.options.resizableColumns;
+
+ //set column resize mode
+
+
+ if (type === "header") {
+
+ variableHeight = column.definition.formatter == "textarea" || column.definition.variableHeight;
+
+ column.extensions.resize = { variableHeight: variableHeight };
+ }
+
+ if (mode === true || mode == type) {
+
+ var handle = document.createElement('div');
+
+ handle.className = "tabulator-col-resize-handle";
+
+ var prevHandle = document.createElement('div');
+
+ prevHandle.className = "tabulator-col-resize-handle prev";
+
+ handle.addEventListener("click", function (e) {
+
+ e.stopPropagation();
+ });
+
+ handle.addEventListener("mousedown", function (e) {
+
+ var nearestColumn = column.getLastColumn();
+
+ if (nearestColumn) {
+
+ self.startColumn = column;
+
+ self._mouseDown(e, nearestColumn);
+ }
+ });
+
+ prevHandle.addEventListener("click", function (e) {
+
+ e.stopPropagation();
+ });
+
+ prevHandle.addEventListener("mousedown", function (e) {
+
+ var nearestColumn, colIndex, prevColumn;
+
+ nearestColumn = column.getFirstColumn();
+
+ if (nearestColumn) {
+
+ colIndex = self.table.columnManager.findColumnIndex(nearestColumn);
+
+ prevColumn = colIndex > 0 ? self.table.columnManager.getColumnByIndex(colIndex - 1) : false;
+
+ if (prevColumn) {
+
+ self.startColumn = column;
+
+ self._mouseDown(e, prevColumn);
+ }
+ }
+ });
+
+ element.append(handle).append(prevHandle);
+ }
+ };
+
+ ResizeColumns.prototype._mouseDown = function (e, column) {
+
+ var self = this;
+
+ self.table.element.addClass("tabulator-block-select");
+
+ function mouseMove(e) {
+
+ column.setWidth(self.startWidth + (e.screenX - self.startX));
+
+ if (!self.table.browserSlow && column.extensions.resize && column.extensions.resize.variableHeight) {
+
+ column.checkCellHeights();
+ }
+ }
+
+ function mouseUp(e) {
+
+ //block editor from taking action while resizing is taking place
+
+
+ if (self.startColumn.extensions.edit) {
+
+ self.startColumn.extensions.edit.blocked = false;
+ }
+
+ if (self.table.browserSlow && column.extensions.resize && column.extensions.resize.variableHeight) {
+
+ column.checkCellHeights();
+ }
+
+ $("body").off("mouseup", mouseMove);
+
+ $("body").off("mousemove", mouseMove);
+
+ self.table.element.removeClass("tabulator-block-select");
+
+ if (self.table.options.persistentLayout && self.table.extExists("persistentLayout", true)) {
+
+ self.table.extensions.persistentLayout.save();
+ }
+
+ self.table.options.columnResized(self.startColumn.getComponent());
+ }
+
+ e.stopPropagation(); //prevent resize from interfereing with movable columns
+
+
+ //block editor from taking action while resizing is taking place
+
+
+ if (self.startColumn.extensions.edit) {
+
+ self.startColumn.extensions.edit.blocked = true;
+ }
+
+ self.startX = e.screenX;
+
+ self.startWidth = column.getWidth();
+
+ $("body").on("mousemove", mouseMove);
+
+ $("body").on("mouseup", mouseUp);
+ };
+
+ Tabulator.registerExtension("resizeColumns", ResizeColumns);
+
+ var ResponsiveLayout = function ResponsiveLayout(table) {
+
+ this.table = table; //hold Tabulator object
+
+
+ this.columns = [];
+
+ this.index = 0;
+ };
+
+ //generate resposivle columns list
+
+
+ ResponsiveLayout.prototype.initialize = function () {
+
+ var columns = [];
+
+ //detemine level of responsivity for each column
+
+
+ this.table.columnManager.columnsByIndex.forEach(function (column) {
+
+ var def = column.getDefinition();
+
+ column.extensions.responsive = { order: typeof def.responsive === "undefined" ? 1 : def.responsive };
+
+ if (column.extensions.responsive.order) {
+
+ columns.push(column);
+ }
+ });
+
+ //sort list by responsivity
+
+
+ columns = columns.reverse();
+
+ columns = columns.sort(function (a, b) {
+
+ return b.extensions.responsive.order - a.extensions.responsive.order;
+ });
+
+ this.columns = columns;
+ };
+
+ ResponsiveLayout.prototype.update = function () {
+
+ var self = this,
+ working = true;
+
+ while (working) {
+
+ var width = self.table.extensions.layout.getMode() == "fitColumns" ? self.table.columnManager.getFlexBaseWidth() : self.table.columnManager.getWidth();
+
+ var diff = self.table.columnManager.element.innerWidth() - width;
+
+ if (diff < 0) {
+
+ //table is too wide
+
+
+ var column = self.columns[self.index];
+
+ if (column) {
+
+ column.hide();
+
+ self.index++;
+ } else {
+
+ working = false;
+ }
+ } else {
+
+ //table has spare space
+
+
+ var _column = self.columns[self.index - 1];
+
+ if (_column) {
+
+ if (diff > 0) {
+
+ if (diff >= _column.getWidth()) {
+
+ _column.show();
+
+ //set column width to prevent calculation loops on uninitialized columns
+
+
+ _column.setWidth(_column.getWidth());
+
+ self.index--;
+ } else {
+
+ working = false;
+ }
+ } else {
+
+ working = false;
+ }
+ } else {
+
+ working = false;
+ }
+ }
+
+ if (!self.table.rowManager.activeRowsCount) {
+
+ self.table.rowManager.renderEmptyScroll();
+ }
+ }
+ };
+
+ Tabulator.registerExtension("responsiveLayout", ResponsiveLayout);
+
+ var SelectRow = function SelectRow(table) {
+
+ this.table = table; //hold Tabulator object
+
+
+ this.selecting = false; //flag selecting in progress
+
+
+ this.selectPrev = []; //hold previously selected element for drag drop selection
+
+
+ this.selectedRows = []; //hold selected rows
+
+ };
+
+ SelectRow.prototype.clearSelectionData = function () {
+
+ this.selecting = false;
+
+ this.selectPrev = [];
+
+ this.selectedRows = [];
+ };
+
+ SelectRow.prototype.initializeRow = function (row) {
+
+ var self = this,
+ element = row.getElement();
+
+ // trigger end of row selection
+
+
+ var endSelect = function endSelect() {
+
+ setTimeout(function () {
+
+ self.selecting = false;
+ }, 50);
+
+ $("body").off("mouseup", endSelect);
+ };
+
+ row.extensions.select = { selected: false };
+
+ //set row selection class
+
+
+ if (self.table.options.selectableCheck(row.getComponent())) {
+
+ element.addClass("tabulator-selectable").removeClass("tabulator-unselectable");
+
+ if (self.table.options.selectable && self.table.options.selectable != "highlight") {
+
+ element.on("click", function (e) {
+
+ if (!self.selecting) {
+
+ self.toggleRow(row);
+ }
+ });
+
+ element.on("mousedown", function (e) {
+
+ if (e.shiftKey) {
+
+ self.selecting = true;
+
+ self.selectPrev = [];
+
+ $("body").on("mouseup", endSelect);
+
+ $("body").on("keyup", endSelect);
+
+ self.toggleRow(row);
+
+ return false;
+ }
+ });
+
+ element.on("mouseenter", function (e) {
+
+ if (self.selecting) {
+
+ self.toggleRow(row);
+
+ if (self.selectPrev[1] == row) {
+
+ self.toggleRow(self.selectPrev[0]);
+ }
+ }
+ });
+
+ element.on("mouseout", function (e) {
+
+ if (self.selecting) {
+
+ self.selectPrev.unshift(row);
+ }
+ });
+ }
+ } else {
+
+ row.getElement().addClass("tabulator-unselectable").removeClass("tabulator-selectable");
+ }
+ };
+
+ //toggle row selection
+
+
+ SelectRow.prototype.toggleRow = function (row) {
+
+ if (this.table.options.selectableCheck(row.getComponent())) {
+
+ if (row.extensions.select.selected) {
+
+ this._deselectRow(row);
+ } else {
+
+ this._selectRow(row);
+ }
+ }
+ };
+
+ //select a number of rows
+
+
+ SelectRow.prototype.selectRows = function (rows) {
+
+ var self = this;
+
+ switch (typeof rows === 'undefined' ? 'undefined' : _typeof(rows)) {
+
+ case "undefined":
+
+ self.table.rowManager.rows.forEach(function (row) {
+
+ self._selectRow(row, true, true);
+ });
+
+ self._rowSelectionChanged();
+
+ break;
+
+ case "boolean":
+
+ if (rows === true) {
+
+ self.table.rowManager.activeRows.forEach(function (row) {
+
+ self._selectRow(row, true, true);
+ });
+
+ self._rowSelectionChanged();
+ }
+
+ break;
+
+ default:
+
+ if (Array.isArray(rows)) {
+
+ rows.forEach(function (row) {
+
+ self._selectRow(row, true);
+ });
+
+ self._rowSelectionChanged();
+ } else {
+
+ self._selectRow(rows);
+ }
+
+ break;
+
+ }
+ };
+
+ //select an individual row
+
+
+ SelectRow.prototype._selectRow = function (rowInfo, silent, force) {
+
+ var self = this,
+ index;
+
+ //handle max row count
+
+
+ if (!isNaN(self.table.options.selectable) && self.table.options.selectable !== true && !force) {
+
+ if (self.selectedRows.length >= self.table.options.selectable) {
+
+ if (self.table.options.selectableRollingSelection) {
+
+ self._deselectRow(self.selectedRows[0], true);
+ } else {
+
+ return false;
+ }
+ }
+ }
+
+ var row = self.table.rowManager.findRow(rowInfo);
+
+ if (row) {
+
+ var self = this;
+
+ row.extensions.select.selected = true;
+
+ row.getElement().addClass("tabulator-selected");
+
+ self.selectedRows.push(row);
+
+ if (!silent) {
+
+ self.table.options.rowSelected(row.getComponent());
+
+ self._rowSelectionChanged();
+ }
+ } else {
+
+ console.warn("Selection Error - No such row found, ignoring selection:" + rowInfo);
+ }
+ };
+
+ //deselect a number of rows
+
+
+ SelectRow.prototype.deselectRows = function (rows) {
+
+ var self = this;
+
+ if (typeof rows == "undefined") {
+
+ var rowCount = self.selectedRows.length;
+
+ for (var i = 0; i < rowCount; i++) {
+
+ self._deselectRow(self.selectedRows[0], true);
+ }
+
+ self._rowSelectionChanged();
+ } else {
+
+ if (Array.isArray(rows)) {
+
+ rows.forEach(function (row) {
+
+ self._deselectRow(row, true);
+ });
+
+ self._rowSelectionChanged();
+ } else {
+
+ self._deselectRow(rows);
+ }
+ }
+ };
+
+ //deselect an individual row
+
+
+ SelectRow.prototype._deselectRow = function (rowInfo, silent) {
+
+ var self = this,
+ row = self.table.rowManager.findRow(rowInfo),
+ index;
+
+ if (row) {
+
+ index = self.selectedRows.findIndex(function (selectedRow) {
+
+ return selectedRow == row;
+ });
+
+ if (index > -1) {
+
+ row.extensions.select.selected = false;
+
+ row.getElement().removeClass("tabulator-selected");
+
+ self.selectedRows.splice(index, 1);
+
+ if (!silent) {
+
+ self.table.options.rowDeselected(row.getComponent());
+
+ self._rowSelectionChanged();
+ }
+ }
+ } else {
+
+ console.warn("Selection Error - No such row found, ignoring selection:" + rowInfo);
+ }
+ };
+
+ SelectRow.prototype.getSelectedData = function () {
+
+ var data = [];
+
+ this.selectedRows.forEach(function (row) {
+
+ data.push(row.getData());
+ });
+
+ return data;
+ };
+
+ SelectRow.prototype.getSelectedRows = function () {
+
+ var rows = [];
+
+ this.selectedRows.forEach(function (row) {
+
+ rows.push(row.getComponent());
+ });
+
+ return rows;
+ };
+
+ SelectRow.prototype._rowSelectionChanged = function () {
+
+ this.table.options.rowSelectionChanged(this.getSelectedData(), this.getSelectedRows());
+ };
+
+ Tabulator.registerExtension("selectRow", SelectRow);
+
+ var Sort = function Sort(table) {
+
+ this.table = table; //hold Tabulator object
+
+
+ this.sortList = []; //holder current sort
+
+
+ this.changed = false; //has the sort changed since last render
+
+ };
+
+ //initialize column header for sorting
+
+
+ Sort.prototype.initializeColumn = function (column, content) {
+
+ var self = this,
+ sorter = false;
+
+ switch (_typeof(column.definition.sorter)) {
+
+ case "string":
+
+ if (self.sorters[column.definition.sorter]) {
+
+ sorter = self.sorters[column.definition.sorter];
+ } else {
+
+ console.warn("Sort Error - No such sorter found: ", column.definition.sorter);
+ }
+
+ break;
+
+ case "function":
+
+ sorter = column.definition.sorter;
+
+ break;
+
+ }
+
+ column.extensions.sort = { sorter: sorter, dir: "none", params: column.definition.sorterParams || {} };
+
+ if (column.definition.headerSort !== false) {
+
+ column.element.addClass("tabulator-sortable");
+
+ //create sorter arrow
+
+
+ content.append($(""));
+
+ //sort on click
+
+
+ column.element.on("click", function (e) {
+
+ var dir = "",
+ sorters = [],
+ match = false;
+
+ if (column.extensions.sort) {
+
+ dir = column.extensions.sort.dir == "asc" ? "desc" : "asc";
+
+ if (e.shiftKey || e.ctrlKey) {
+
+ sorters = self.getSort();
+
+ match = sorters.findIndex(function (sorter) {
+
+ return sorter.field === column.getField();
+ });
+
+ if (match > -1) {
+
+ sorters[match].dir = sorters[match].dir == "asc" ? "desc" : "asc";
+
+ if (match != sorters.length - 1) {
+
+ sorters.push(sorters.splice(match, 1)[0]);
+ }
+ } else {
+
+ sorters.push({ column: column, dir: dir });
+ }
+
+ //add to existing sort
+
+
+ self.setSort(sorters);
+ } else {
+
+ //sort by column only
+
+
+ self.setSort(column, dir);
+ }
+
+ self.table.rowManager.sorterRefresh();
+ }
+ });
+ }
+ };
+
+ //check if the sorters have changed since last use
+
+
+ Sort.prototype.hasChanged = function () {
+
+ var changed = this.changed;
+
+ this.changed = false;
+
+ return changed;
+ };
+
+ //return current sorters
+
+
+ Sort.prototype.getSort = function () {
+
+ var self = this,
+ sorters = [];
+
+ self.sortList.forEach(function (item) {
+
+ if (item.column) {
+
+ sorters.push({ column: item.column.getComponent(), field: item.column.getField(), dir: item.dir });
+ }
+ });
+
+ return sorters;
+ };
+
+ //change sort list and trigger sort
+
+
+ Sort.prototype.setSort = function (sortList, dir) {
+
+ var self = this,
+ newSortList = [];
+
+ if (!Array.isArray(sortList)) {
+
+ sortList = [{ column: sortList, dir: dir }];
+ }
+
+ sortList.forEach(function (item) {
+
+ var column;
+
+ column = self.table.columnManager.findColumn(item.column);
+
+ if (column) {
+
+ item.column = column;
+
+ newSortList.push(item);
+
+ self.changed = true;
+ } else {
+
+ console.warn("Sort Warning - Sort field does not exist and is being ignored: ", item.column);
+ }
+ });
+
+ self.sortList = newSortList;
+ };
+
+ //clear sorters
+
+
+ Sort.prototype.clear = function () {
+
+ this.setSort([]);
+ },
+
+ //find appropriate sorter for column
+
+
+ Sort.prototype.findSorter = function (column) {
+
+ var row = this.table.rowManager.activeRows[0],
+ sorter = "string",
+ field,
+ value;
+
+ if (row) {
+
+ row = row.getData();
+
+ field = column.getField();
+
+ if (field) {
+
+ value = column.getFieldValue(row);
+
+ switch (typeof value === 'undefined' ? 'undefined' : _typeof(value)) {
+
+ case "undefined":
+
+ sorter = "string";
+
+ break;
+
+ case "boolean":
+
+ sorter = "boolean";
+
+ break;
+
+ default:
+
+ if (!isNaN(value) && value !== "") {
+
+ sorter = "number";
+ } else {
+
+ if (value.match(/((^[0-9]+[a-z]+)|(^[a-z]+[0-9]+))+$/i)) {
+
+ sorter = "alphanum";
+ }
+ }
+
+ break;
+
+ }
+ }
+ }
+
+ return this.sorters[sorter];
+ };
+
+ //work through sort list sorting data
+
+
+ Sort.prototype.sort = function () {
+
+ var self = this,
+ lastSort;
+
+ if (self.table.options.dataSorting) {
+
+ self.table.options.dataSorting(self.getSort());
+ }
+
+ self.clearColumnHeaders();
+
+ if (!self.table.options.ajaxSorting) {
+
+ self.sortList.forEach(function (item, i) {
+
+ if (item.column && item.column.extensions.sort) {
+
+ //if no sorter has been defined, take a guess
+
+
+ if (!item.column.extensions.sort.sorter) {
+
+ item.column.extensions.sort.sorter = self.findSorter(item.column);
+ }
+
+ self._sortItem(item.column, item.dir, self.sortList, i);
+ }
+
+ self.setColumnHeader(item.column, item.dir);
+ });
+ }
+
+ if (self.table.options.dataSorted) {
+
+ self.table.options.dataSorted(self.getSort(), self.table.rowManager.getComponents(true));
+ }
+ };
+
+ //clear sort arrows on columns
+
+
+ Sort.prototype.clearColumnHeaders = function () {
+
+ this.table.columnManager.getRealColumns().forEach(function (column) {
+
+ if (column.extensions.sort) {
+
+ column.extensions.sort.dir = "none";
+
+ column.element.attr("aria-sort", "none");
+ }
+ });
+ };
+
+ //set the column header sort direction
+
+
+ Sort.prototype.setColumnHeader = function (column, dir) {
+
+ column.extensions.sort.dir = dir;
+
+ column.element.attr("aria-sort", dir);
+ };
+
+ //sort each item in sort list
+
+
+ Sort.prototype._sortItem = function (column, dir, sortList, i) {
+
+ var self = this;
+
+ var activeRows = self.table.rowManager.activeRows;
+
+ activeRows.sort(function (a, b) {
+
+ var result = self._sortRow(a, b, column, dir);
+
+ //if results match recurse through previous searchs to be sure
+
+
+ if (result == 0 && i) {
+
+ for (var j = i - 1; j >= 0; j--) {
+
+ result = self._sortRow(a, b, sortList[j].column, sortList[j].dir);
+
+ if (result != 0) {
+
+ break;
+ }
+ }
+ }
+
+ return result;
+ });
+ };
+
+ //process individual rows for a sort function on active data
+
+
+ Sort.prototype._sortRow = function (a, b, column, dir) {
+
+ var self = this;
+
+ //switch elements depending on search direction
+
+
+ var el1 = dir == "asc" ? a : b;
+
+ var el2 = dir == "asc" ? b : a;
+
+ a = column.getFieldValue(el1.getData());
+
+ b = column.getFieldValue(el2.getData());
+
+ a = typeof a !== "undefined" ? a : "";
+
+ b = typeof b !== "undefined" ? b : "";
+
+ return column.extensions.sort.sorter.call(self, a, b, el1.getComponent(), el2.getComponent(), column.getComponent(), dir, column.extensions.sort.params);
+ };
+
+ //default data sorters
+
+
+ Sort.prototype.sorters = {
+
+ //sort numbers
+
+
+ number: function number(a, b, aRow, bRow, column, dir, params) {
+
+ return parseFloat(String(a).replace(",", "")) - parseFloat(String(b).replace(",", ""));
+ },
+
+ //sort strings
+
+
+ string: function string(a, b, aRow, bRow, column, dir, params) {
+
+ return String(a).toLowerCase().localeCompare(String(b).toLowerCase());
+ },
+
+ //sort date
+
+
+ date: function date(a, b, aRow, bRow, column, dir, params) {
+
+ var self = this;
+
+ var format = params.format || "DD/MM/YYYY";
+
+ if (typeof moment != "undefined") {
+
+ a = moment(a, format);
+
+ b = moment(b, format);
+ } else {
+
+ console.error("Sort Error - 'date' sorter is dependant on moment.js");
+ }
+
+ return a - b;
+ },
+
+ //sort booleans
+
+
+ boolean: function boolean(a, b, aRow, bRow, column, dir, params) {
+
+ var el1 = a === true || a === "true" || a === "True" || a === 1 ? 1 : 0;
+
+ var el2 = b === true || b === "true" || b === "True" || b === 1 ? 1 : 0;
+
+ return el1 - el2;
+ },
+
+ //sort alpha numeric strings
+
+
+ alphanum: function alphanum(as, bs, aRow, bRow, column, dir, params) {
+
+ var a,
+ b,
+ a1,
+ b1,
+ i = 0,
+ L,
+ rx = /(\d+)|(\D+)/g,
+ rd = /\d/;
+
+ if (isFinite(as) && isFinite(bs)) return as - bs;
+
+ a = String(as).toLowerCase();
+
+ b = String(bs).toLowerCase();
+
+ if (a === b) return 0;
+
+ if (!(rd.test(a) && rd.test(b))) return a > b ? 1 : -1;
+
+ a = a.match(rx);
+
+ b = b.match(rx);
+
+ L = a.length > b.length ? b.length : a.length;
+
+ while (i < L) {
+
+ a1 = a[i];
+
+ b1 = b[i++];
+
+ if (a1 !== b1) {
+
+ if (isFinite(a1) && isFinite(b1)) {
+
+ if (a1.charAt(0) === "0") a1 = "." + a1;
+
+ if (b1.charAt(0) === "0") b1 = "." + b1;
+
+ return a1 - b1;
+ } else return a1 > b1 ? 1 : -1;
+ }
+ }
+
+ return a.length > b.length;
+ },
+
+ //sort hh:mm formatted times
+
+
+ time: function time(a, b, aRow, bRow, column, dir, params) {
+
+ var self = this;
+
+ var format = params.format || "hh:mm";
+
+ if (typeof moment != "undefined") {
+
+ a = moment(a, format);
+
+ b = moment(b, format);
+ } else {
+
+ console.error("Sort Error - 'date' sorter is dependant on moment.js");
+ }
+
+ return a - b;
+ }
+
+ };
+
+ Tabulator.registerExtension("sort", Sort);
+
+ var Validate = function Validate(table) {
+
+ this.table = table;
+ };
+
+ //validate
+
+
+ Validate.prototype.initializeColumn = function (column) {
+
+ var self = this,
+ config = [],
+ validator;
+
+ if (column.definition.validator) {
+
+ if (Array.isArray(column.definition.validator)) {
+
+ column.definition.validator.forEach(function (item) {
+
+ validator = self._extractValidator(item);
+
+ if (validator) {
+
+ config.push(validator);
+ }
+ });
+ } else {
+
+ validator = this._extractValidator(column.definition.validator);
+
+ if (validator) {
+
+ config.push(validator);
+ }
+ }
+
+ column.extensions.validate = config.length ? config : false;
+ }
+ };
+
+ Validate.prototype._extractValidator = function (value) {
+
+ switch (typeof value === 'undefined' ? 'undefined' : _typeof(value)) {
+
+ case "string":
+
+ var parts = value.split(":");
+
+ var type = parts.shift();
+
+ var params = parts.join();
+
+ return this._buildValidator(type, params);
+
+ break;
+
+ case "function":
+
+ return this._buildValidator(value);
+
+ break;
+
+ case "object":
+
+ return this._buildValidator(value.type, value.parameters);
+
+ break;
+
+ }
+ };
+
+ Validate.prototype._buildValidator = function (type, params) {
+
+ var func = typeof type == "function" ? type : this.validators[type];
+
+ if (!func) {
+
+ console.warn("Validator Setup Error - No matching validator found:", type);
+
+ return false;
+ } else {
+
+ return {
+
+ type: typeof type == "function" ? "function" : type,
+
+ func: func,
+
+ params: params
+
+ };
+ }
+ };
+
+ Validate.prototype.validate = function (validators, cell, value) {
+
+ var self = this,
+ valid = [];
+
+ if (validators) {
+
+ validators.forEach(function (item) {
+
+ if (!item.func.call(self, cell, value, item.params)) {
+
+ valid.push({
+
+ type: item.type,
+
+ parameters: item.params
+
+ });
+ }
+ });
+ }
+
+ return valid.length ? valid : true;
+ };
+
+ Validate.prototype.validators = {
+
+ //is integer
+
+
+ integer: function integer(cell, value, parameters) {
+
+ value = Number(value);
+
+ return typeof value === 'number' && isFinite(value) && Math.floor(value) === value;
+ },
+
+ //is float
+
+
+ float: function float(cell, value, parameters) {
+
+ value = Number(value);
+
+ return typeof value === 'number' && isFinite(value) && value % 1 !== 0;;
+ },
+
+ //must be a number
+
+
+ numeric: function numeric(cell, value, parameters) {
+
+ return !isNaN(value);
+ },
+
+ //must be a string
+
+
+ string: function string(cell, value, parameters) {
+
+ return isNaN(value);
+ },
+
+ //maximum value
+
+
+ max: function max(cell, value, parameters) {
+
+ return parseFloat(value) <= parameters;
+ },
+
+ //minimum value
+
+
+ min: function min(cell, value, parameters) {
+
+ return parseFloat(value) >= parameters;
+ },
+
+ //minimum string length
+
+
+ minLength: function minLength(cell, value, parameters) {
+
+ return String(value).length >= parameters;
+ },
+
+ //maximum string length
+
+
+ maxLength: function maxLength(cell, value, parameters) {
+
+ return String(value).length <= parameters;
+ },
+
+ //in provided value list
+
+
+ in: function _in(cell, value, parameters) {
+
+ if (typeof parameters == "string") {
+
+ parameters = parameters.split("|");
+ }
+
+ return value === "" || parameters.indexOf(value) > -1;
+ },
+
+ //must match provided regex
+
+
+ regex: function regex(cell, value, parameters) {
+
+ var reg = new RegExp(parameters);
+
+ return reg.test(value);
+ },
+
+ //value must be unique in this column
+
+
+ unique: function unique(cell, value, parameters) {
+
+ var unique = true;
+
+ var cellData = cell.getData();
+
+ this.table.rowManager.rows.forEach(function (row) {
+
+ var data = row.getData();
+
+ if (data !== cellData) {
+
+ if (value == data[cell.getField()]) {
+
+ unique = false;
+ }
+ }
+ });
+
+ return unique;
+ },
+
+ //must have a value
+
+
+ required: function required(cell, value, parameters) {
+
+ return value !== "" & value !== null && typeof value != "undefined";
+ }
+
+ };
+
+ Tabulator.registerExtension("validate", Validate);
+ })();
+
+ $.widget("ui.tabulator", Tabulator);
+});
\ No newline at end of file
diff --git a/js/tabulator/dist/js/tabulator.min.js b/js/tabulator/dist/js/tabulator.min.js
new file mode 100644
index 0000000..e54d6f6
--- /dev/null
+++ b/js/tabulator/dist/js/tabulator.min.js
@@ -0,0 +1,6 @@
+/* Tabulator v3.3.1 (c) Oliver Folkerd */
+"use strict";var _typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t};!function(t){"function"==typeof define&&define.amd?define(["jquery"],t):"undefined"!=typeof module&&module.exports?module.exports=t(require("jquery")):t(jQuery)}(function(t,o){!function(){Array.prototype.findIndex||Object.defineProperty(Array.prototype,"findIndex",{value:function(t){if(null==this)throw new TypeError('"this" is null or not defined');var e=Object(this),o=e.length>>>0;if("function"!=typeof t)throw new TypeError("predicate must be a function");for(var i=arguments[1],n=0;n
"+i.placeholder+"
")),i.height&&(i.height=isNaN(i.height)?i.height:i.height+"px",this.element.css({height:i.height})),e.append(this.columnManager.getElement()),e.append(this.rowManager.getElement()),i.footerElement&&this.footerManager.activate(),i.persistentLayout&&this.extExists("persistentLayout",!0)&&(o.persistentLayout.initialize(i.persistentLayout,i.persistentLayoutID),i.columns=o.persistentLayout.load(i.columns)),this.extExists("columnCalcs")&&o.columnCalcs.initialize(),this.columnManager.setColumns(i.columns),i.initialSort&&this.extExists("sort",!0)&&o.sort.setSort(i.initialSort),i.pagination&&this.extExists("page",!0)&&o.page.initialize(),i.groupBy&&this.extExists("groupRows",!0)&&o.groupRows.initialize(),this.extExists("ajax")&&o.ajax.initialize(),this.extExists("keybindings")&&o.keybindings.initialize(),this.extExists("selectRow")&&o.selectRow.clearSelectionData(),i.tableBuilt()},_loadInitialData:function(){var t=this;t.options.pagination&&t.extExists("page")?(t.extensions.page.reset(!0),t.extensions.page.setPage(1),"local"==t.options.pagination&&t.rowManager.setData(t.options.data)):t.options.data.length?t.rowManager.setData(t.options.data):t.options.ajaxURL&&t.extExists("ajax")?t.extensions.ajax.sendRequest(function(e){t.rowManager.setData(e)}):t.rowManager.setData(t.options.data)},_setOption:function(t,e){console.error("Options Error - Tabulator does not allow options to be set after initialization unless there is a function defined for that purpose")},_destroy:function(){var t=this.element;t.empty(),t.removeClass("tabulator")},_detectBrowser:function(){var t=navigator.userAgent;t.indexOf("Trident")>-1?(this.brower="ie",this.browserSlow=!0):t.indexOf("Edge")>-1?(this.brower="edge",this.browserSlow=!0):(this.brower="other",this.browserSlow=!1)},setData:function(t,e,o){var i=this,i=this;"string"==typeof t?0==t.indexOf("{")||0==t.indexOf("[")?i.rowManager.setData(JSON.parse(t)):i.extExists("ajax",!0)&&(e&&i.extensions.ajax.setParams(e),o&&i.extensions.ajax.setConfig(o),i.extensions.ajax.setUrl(t),"remote"==i.options.pagination&&i.extExists("page",!0)?(i.extensions.page.reset(!0),i.extensions.page.setPage(1)):i.extensions.ajax.sendRequest(function(t){i.rowManager.setData(t)})):t?i.rowManager.setData(t):i.extExists("ajax")&&i.extensions.ajax.getUrl?"remote"==i.options.pagination&&i.extExists("page",!0)?(i.extensions.page.reset(!0),i.extensions.page.setPage(1)):i.extensions.ajax.sendRequest(function(t){i.rowManager.setData(t)}):i.rowManager.setData([])},clearData:function(){this.rowManager.clearData()},getData:function(t){return this.rowManager.getData(t)},getDataCount:function(t){return this.rowManager.getDataCount(t)},getHtml:function(t){return this.rowManager.getHtml(t)},getAjaxUrl:function(){if(this.extExists("ajax",!0))return this.extensions.ajax.getUrl()},updateData:function(t){var e=this;t?t.forEach(function(t){var o=e.rowManager.findRow(t[e.options.index]);o&&o.updateData(t)}):console.warn("Update Error - No data provided")},addData:function(t,e,o){t?this.rowManager.addRows(t,e,o):console.warn("Update Error - No data provided")},updateOrAddData:function(t){var e=this;t?t.forEach(function(t){var o=e.rowManager.findRow(t[e.options.index]);o?o.updateData(t):e.rowManager.addRow(t)}):console.warn("Update Error - No data provided")},getRow:function(t){var e=this.rowManager.findRow(t);return e?e.getComponent():(console.warn("Find Error - No matching row found:",t),!1)},deleteRow:function(t){var e=this.rowManager.findRow(t);return e?(e.delete(),!0):(console.warn("Delete Error - No matching row found:",t),!1)},addRow:function(t,e,o){return this.rowManager.addRow(t,e,o)},updateOrAddRow:function(t,e){var o=this.rowManager.findRow(t);return o?o.updateData(e):o=this.rowManager.addRow(e),o.getComponent()},updateRow:function(t,e){var o=this.rowManager.findRow(t);return o?(o.updateData(e),o.getComponent()):(console.warn("Update Error - No matching row found:",t),!1)},scrollToRow:function(t){var e=this.rowManager.findRow(t);return e?this.rowManager.scrollToRow(e):(console.warn("Scroll Error - No matching row found:",t),!1)},getRows:function(t){return this.rowManager.getComponents(t)},setColumns:function(t){this.columnManager.setColumns(t)},getColumns:function(){return this.columnManager.getComponents()},getColumnDefinitions:function(){return this.columnManager.getDefinitionTree()},getColumnLayout:function(){if(this.extExists("persistentLayout",!0))return this.extensions.persistentLayout.parseColumns(this.columnManager.getColumns())},setColumnLayout:function(t){return!!this.extExists("persistentLayout",!0)&&(this.columnManager.setColumns(this.extensions.persistentLayout.mergeDefinition(this.options.columns,t)),!0)},showColumn:function(t){var e=this.columnManager.findColumn(t);if(!e)return console.warn("Column Show Error - No matching column found:",t),!1;e.show()},hideColumn:function(t){var e=this.columnManager.findColumn(t);if(!e)return console.warn("Column Hide Error - No matching column found:",t),!1;e.hide()},toggleColumn:function(t){var e=this.columnManager.findColumn(t);if(!e)return console.warn("Column Visibility Toggle Error - No matching column found:",t),!1;e.visible?e.hide():e.show()},addColumn:function(t,e,o){var i=this.columnManager.findColumn(o);this.columnManager.addColumn(t,e,i)},deleteColumn:function(t){var e=this.columnManager.findColumn(t);if(!e)return console.warn("Column Delete Error - No matching column found:",t),!1;e.delete()},setLocale:function(t){this.extensions.localize.setLocale(t)},getLocale:function(){return this.extensions.localize.getLocale()},getLang:function(t){return this.extensions.localize.getLang(t)},redraw:function(t){this.columnManager.redraw(t),this.rowManager.redraw(t)},setHeight:function(t){this.options.height=isNaN(t)?t:t+"px",this.element.css({height:this.options.height}),this.rowManager.redraw()},setSort:function(t,e){this.extExists("sort",!0)&&(this.extensions.sort.setSort(t,e),this.rowManager.sorterRefresh())},getSort:function(){if(this.extExists("sort",!0))return console.warn("The%c getSort%c function has been depricated and will be removed in version 4.0, use %c getSorters%c instead.","font-weight:bold;","font-weight:regular;","font-weight:bold;","font-weight:regular;"),this.getSorters()},getSorters:function(){if(this.extExists("sort",!0))return this.extensions.sort.getSort()},clearSort:function(){this.extExists("sort",!0)&&(this.extensions.sort.clear(),this.rowManager.sorterRefresh())},setFilter:function(t,e,o){this.extExists("filter",!0)&&(this.extensions.filter.setFilter(t,e,o),this.rowManager.filterRefresh())},addFilter:function(t,e,o){this.extExists("filter",!0)&&(this.extensions.filter.addFilter(t,e,o),this.rowManager.filterRefresh())},getFilter:function(t){console.warn("The%c getFilter%c function has been depricated and will be removed in version 4.0, use %c getFilters%c instead.","font-weight:bold;","font-weight:regular;","font-weight:bold;","font-weight:regular;"),this.getFilters(t)},getFilters:function(t){if(this.extExists("filter",!0))return this.extensions.filter.getFilters(t)},getHeaderFilters:function(){if(this.extExists("filter",!0))return this.extensions.filter.getHeaderFilters()},removeFilter:function(t,e,o){this.extExists("filter",!0)&&(this.extensions.filter.removeFilter(t,e,o),this.rowManager.filterRefresh())},clearFilter:function(t){this.extExists("filter",!0)&&(this.extensions.filter.clearFilter(t),this.rowManager.filterRefresh())},clearHeaderFilter:function(){this.extExists("filter",!0)&&(this.extensions.filter.clearHeaderFilter(),this.rowManager.filterRefresh())},selectRow:function(t){this.extExists("selectRow",!0)&&this.extensions.selectRow.selectRows(t)},deselectRow:function(t){this.extExists("selectRow",!0)&&this.extensions.selectRow.deselectRows(t)},toggleSelectRow:function(t){this.extExists("selectRow",!0)&&this.extensions.selectRow.toggleRow(t)},getSelectedRows:function(){if(this.extExists("selectRow",!0))return this.extensions.selectRow.getSelectedRows()},getSelectedData:function(){if(this.extExists("selectRow",!0))return this.extensions.selectRow.getSelectedData()},setMaxPage:function(t){if(!this.options.pagination||!this.extExists("page"))return!1;this.extensions.page.setMaxPage(t)},setPage:function(t){if(!this.options.pagination||!this.extExists("page"))return!1;this.extensions.page.setPage(t)},setPageSize:function(t){if(!this.options.pagination||!this.extExists("page"))return!1;this.extensions.page.setPageSize(t),this.extensions.page.setPage(1)},getPageSize:function(){if(this.options.pagination&&this.extExists("page",!0))return this.extensions.page.getPageSize()},previousPage:function(){if(!this.options.pagination||!this.extExists("page"))return!1;this.extensions.page.previousPage()},nextPage:function(){if(!this.options.pagination||!this.extExists("page"))return!1;this.extensions.page.nextPage()},getPage:function(){return!(!this.options.pagination||!this.extExists("page"))&&this.extensions.page.getPage()},getPageMax:function(){return!(!this.options.pagination||!this.extExists("page"))&&this.extensions.page.getPageMax()},setGroupBy:function(t){if(!this.extExists("groupRows",!0))return!1;this.options.groupBy=t,this.extensions.groupRows.initialize(),this.rowManager.refreshActiveData()},setGroupStartOpen:function(t){if(!this.extExists("groupRows",!0))return!1;this.options.groupStartOpen=t,this.extensions.groupRows.initialize(),this.options.groupBy?this.rowManager.refreshActiveData():console.warn("Grouping Update - cant refresh view, no groups have been set")},setGroupHeader:function(t){if(!this.extExists("groupRows",!0))return!1;this.options.groupHeader=t,this.extensions.groupRows.initialize(),this.options.groupBy?this.rowManager.refreshActiveData():console.warn("Grouping Update - cant refresh view, no groups have been set")},getGroups:function(t){return!!this.extExists("groupRows",!0)&&this.extensions.groupRows.getGroups()},navigatePrev:function(){var t=!1;return!(!this.table.extExists("edit",!0)||!(t=this.table.extensions.edit.currentCell))&&(e.preventDefault(),t.nav().prev())},navigateNext:function(){var t=!1;return!(!this.table.extExists("edit",!0)||!(t=this.table.extensions.edit.currentCell))&&(e.preventDefault(),t.nav().next())},navigateLeft:function(){var t=!1;return!(!this.table.extExists("edit",!0)||!(t=this.table.extensions.edit.currentCell))&&(e.preventDefault(),t.nav().left())},navigateRight:function(){var t=!1;return!(!this.table.extExists("edit",!0)||!(t=this.table.extensions.edit.currentCell))&&(e.preventDefault(),t.nav().right())},navigateUp:function(){var t=!1;return!(!this.table.extExists("edit",!0)||!(t=this.table.extensions.edit.currentCell))&&(e.preventDefault(),t.nav().up())},
+navigateDown:function(){var t=!1;return!(!this.table.extExists("edit",!0)||!(t=this.table.extensions.edit.currentCell))&&(e.preventDefault(),t.nav().dpwn())},undo:function(){return!(!this.options.history||!this.extExists("history",!0))&&this.extensions.history.undo()},redo:function(){return!(!this.options.history||!this.extExists("history",!0))&&this.extensions.history.redo()},download:function(t,e,o){this.extExists("download",!0)&&this.extensions.download.download(t,e,o)},extensions:{},extensionBindings:{},extendExtension:function(t,e,o){if(this.extensionBindings[t]){var i=this.extensionBindings[t].prototype[e];if(i)if("object"==(void 0===o?"undefined":_typeof(o)))for(var n in o)i[n]=o[n];else console.warn("Extension Error - Invalid value type, it must be an object");else console.warn("Extension Error - property does not exist:",e)}else console.warn("Extension Error - extension does not exist:",t)},registerExtension:function(t,e){this.extensionBindings[t]=e},bindExtensions:function(){var t=this;this.extensions={};for(var e in t.extensionBindings)t.extensions[e]=new t.extensionBindings[e](t)},extExists:function(t,e){return!!this.extensions[t]||(e&&console.error("Tabulator Plugin Not Installed: "+t),!1)}};var p=function(t){this.table=t,this.mode=null};p.prototype.initialize=function(t){this.modes[t]?this.mode=t:(console.warn("Layout Error - invalid mode set, defaulting to 'fitData' : "+t),this.mode="fitData"),this.table.element.attr("tabulator-layout",this.mode)},p.prototype.getMode=function(){return this.mode},p.prototype.layout=function(){this.modes[this.mode].call(this,this.table.columnManager.columnsByIndex)},p.prototype.modes={fitData:function(t){t.forEach(function(t){t.reinitializeWidth()}),this.table.options.responsiveLayout&&this.table.extExists("responsiveLayout",!0)&&this.table.extensions.responsiveLayout.update()},fitDataFill:function(t){t.forEach(function(t){t.reinitializeWidth()}),this.table.options.responsiveLayout&&this.table.extExists("responsiveLayout",!0)&&this.table.extensions.responsiveLayout.update()},fitColumns:function(t){function e(t,o,i){var n=[],s=0,a=0,r=0,l=0,u=[];return t.forEach(function(t,e){t.minWidth>=i?n.push(t):u.push(t)}),n.length?(n.forEach(function(t){s+=t.minWidth,t.setWidth(t.minWidth)}),a=o-s,r=u.length?Math.floor(a/u.length):a,l=a-r*u.length,l+=e(u,a,r)):(l=u.length?o-Math.floor(o/u.length)*u.length:o,u.forEach(function(t){t.setWidth(i)})),l}var o=this,i=o.table.element.innerWidth(),n=0,s=0,a=0,r=[],l=0;this.table.options.responsiveLayout&&this.table.extExists("responsiveLayout",!0)&&this.table.extensions.responsiveLayout.update(),this.table.rowManager.element[0].scrollHeight>this.table.rowManager.element.innerHeight()&&(i-=this.table.rowManager.element[0].offsetWidth-this.table.rowManager.element[0].clientWidth),t.forEach(function(t){var e,o,s;t.visible&&(e=t.definition.width,o=parseInt(t.minWidth),e?(s="string"==typeof e?e.indexOf("%")>-1?i/100*parseInt(e):parseInt(e):e,n+=s>o?s:o):r.push(t))}),s=i-n,a=Math.floor(s/r.length);var l=e(r,s,a);r.length&&r[r.length-1].setWidth(r[r.length-1].getWidth()+l)}},Tabulator.registerExtension("layout",p);var d=function(t){this.table=t,this.locale="default",this.lang=!1,this.bindings={}};d.prototype.setHeaderFilterPlaceholder=function(t){this.langs.default.headerFilters.default=t},d.prototype.setHeaderFilterColumnPlaceholder=function(t,e){this.langs.default.headerFilters.columns[t]=e,this.lang&&!this.lang.headerFilters.columns[t]&&(this.lang.headerFilters.columns[t]=e)},d.prototype.installLang=function(t,e){this.langs[t]?this._setLangProp(this.langs[t],e):this.langs[t]=e},d.prototype._setLangProp=function(t,e){for(var o in e)t[o]&&"object"==_typeof(t[o])?this._setLangProp(t[o],e[o]):t[o]=e[o]},d.prototype.setLocale=function(e){function o(t,e){for(var i in t)"object"==_typeof(t[i])?(e[i]||(e[i]={}),o(t[i],e[i])):e[i]=t[i]}var i=this;if(e=e||"default",!0===e&&navigator.language&&(e=navigator.language.toLowerCase()),e&&!i.langs[e]){var n=e.split("-")[0];i.langs[n]?(console.warn("Localization Error - Exact matching locale not found, using closest match: ",e,n),e=n):(console.warn("Localization Error - Matching locale not found, using default: ",e),e="default")}i.locale=e,i.lang=t.extend(!0,{},i.langs.default),"default"!=e&&o(i.langs[e],i.lang),i.table.options.localized(i.locale,i.lang),i._executeBindings()},d.prototype.getLocale=function(t){return self.locale},d.prototype.getLang=function(t){return t?this.langs[t]:this.lang},d.prototype.getText=function(t,e){var t=e?t+"."+e:t,o=t.split(".");return this._getLangElement(o,this.locale)||""},d.prototype._getLangElement=function(t,e){var o=this,i=o.lang;return t.forEach(function(t){var e;i&&(e=i[t],i=void 0!==e&&e)}),i},d.prototype.bind=function(t,e){this.bindings[t]||(this.bindings[t]=[]),this.bindings[t].push(e),e(this.getText(t),this.lang)},d.prototype._executeBindings=function(){var t=this;for(var e in t.bindings)!function(e){t.bindings[e].forEach(function(o){o(t.getText(e),t.lang)})}(e)},d.prototype.langs={default:{groups:{item:"item",items:"items"},columns:{},ajax:{loading:"Loading",error:"Error"},pagination:{first:"First",first_title:"First Page",last:"Last",last_title:"Last Page",prev:"Prev",prev_title:"Prev Page",next:"Next",next_title:"Next Page"},headerFilters:{default:"filter column...",columns:{}}}},Tabulator.registerExtension("localize",d);var f=function(t){this.table=t};f.prototype.initializeColumn=function(t){var e={accessor:!1,params:t.definition.accessorParams||{}};switch(_typeof(t.definition.accessor)){case"string":this.accessors[t.definition.accessor]?e.accessor=this.accessors[t.definition.accessor]:console.warn("Accessor Error - No such accessor found, ignoring: ",t.definition.accessor);break;case"function":e.accessor=t.definition.accessor}e.accessor&&(t.extensions.accessor=e)},f.prototype.transformRow=function(e){var o=this,i=t.extend(!0,{},e||{});return o.table.columnManager.traverse(function(t){var e;t.extensions.accessor&&(e=t.getField(),void 0!==i[e]&&t.setFieldValue(i,t.extensions.accessor.accessor(t.getFieldValue(i),i,t.extensions.accessor.params)))}),i},f.prototype.accessors={},Tabulator.registerExtension("accessor",f);var g=function(e){this.table=e,this.config=!1,this.url="",this.params=!1,this.loaderElement=t(""),this.msgElement=t(""),this.loadingElement=!1,this.errorElement=!1};g.prototype.initialize=function(){this.loaderElement.append(this.msgElement),this.table.options.ajaxLoaderLoading&&(this.loadingElement=this.table.options.ajaxLoaderLoading),this.table.options.ajaxLoaderError&&(this.errorElement=this.table.options.ajaxLoaderError),this.table.options.ajaxParams&&this.setParams(this.table.options.ajaxParams),this.table.options.ajaxConfig&&this.setConfig(this.table.options.ajaxConfig),this.table.options.ajaxURL&&this.setUrl(this.table.options.ajaxURL)},g.prototype.setParams=function(t,e){if(e){this.params=this.params||{};for(var o in t)this.params[o]=t[o]}else this.params=t},g.prototype.getParams=function(){return this.params||{}},g.prototype.setConfig=function(t){if(this._loadDefaultConfig(),"string"==typeof t)this.config.type=t;else for(var e in t)this.config[e]=t[e]},g.prototype._loadDefaultConfig=function(t){var e=this;if(!e.config||t){e.config={};for(var o in e.defaultConfig)e.config[o]=e.defaultConfig[o]}},g.prototype.setUrl=function(t){this.url=t},g.prototype.getUrl=function(){return this.url},g.prototype.sendRequest=function(e){var o=this;if(!o.url)return console.warn("Ajax Load Error - No URL Set"),!1;o._loadDefaultConfig(),o.config.url=o.url,o.params&&(o.config.data=o.params),!1!==o.table.options.ajaxRequesting(o.url,o.params)&&(o.showLoader(),t.ajax(o.config).done(function(t){o.table.options.ajaxResponse&&(t=o.table.options.ajaxResponse(o.url,o.params,t)),o.table.options.dataLoaded(t),e(t),o.hideLoader()}).fail(function(t,e,i){console.error("Ajax Load Error - Connection Error: "+t.status,i),o.table.options.ajaxError(t,e,i),o.showError(),setTimeout(function(){o.hideLoader()},3e3)}))},g.prototype.showLoader=function(){this.loaderElement.detach(),this.msgElement.empty().removeClass("tabulator-error").addClass("tabulator-loading"),this.loadingElement?this.msgElement.append(this.loadingElement):this.msgElement.append(this.table.extensions.localize.getText("ajax.loading")),this.table.element.append(this.loaderElement)},g.prototype.showError=function(){this.loaderElement.detach(),this.msgElement.empty().removeClass("tabulator-loading").addClass("tabulator-error"),this.errorElement?this.msgElement.append(this.errorElement):this.msgElement.append(this.table.extensions.localize.getText("ajax.error")),this.table.element.append(this.loaderElement)},g.prototype.hideLoader=function(){this.loaderElement.detach()},g.prototype.defaultConfig={url:"",type:"GET",async:!0,dataType:"json",success:function(t){}},Tabulator.registerExtension("ajax",g);var m=function(e){this.table=e,this.topCalcs=[],this.botCalcs=[],this.genColumn=!1,this.topElement=t(""),this.botElement=t(""),this.topRow=!1,this.botRow=!1,this.topInitialized=!1,this.botInitialized=!1,this.initialize()};m.prototype.initialize=function(){this.genColumn=new s({field:"value"},this)},m.prototype.registerColumnField=function(){},m.prototype.initializeColumn=function(t){var e=t.definition,o={topCalcParams:e.topCalcParams||{},botCalcParams:e.bottomCalcParams||{}};if(e.topCalc){switch(_typeof(e.topCalc)){case"string":this.calculations[e.topCalc]?o.topCalc=this.calculations[e.topCalc]:console.warn("Column Calc Error - No such calculation found, ignoring: ",e.topCalc);break;case"function":o.topCalc=e.topCalc}o.topCalc&&(t.extensions.columnCalcs=o,this.topCalcs.push(t),this.table.options.groupBy||this.initializeTopRow())}if(e.bottomCalc){switch(_typeof(e.bottomCalc)){case"string":this.calculations[e.bottomCalc]?o.botCalc=this.calculations[e.bottomCalc]:console.warn("Column Calc Error - No such calculation found, ignoring: ",e.bottomCalc);break;case"function":o.botCalc=e.bottomCalc}o.botCalc&&(t.extensions.columnCalcs=o,this.botCalcs.push(t),this.table.options.groupBy||this.initializeBottomRow())}},m.prototype.removeCalcs=function(){var t=!1;this.topInitialized&&(this.topInitialized=!1,this.topElement.remove(),t=!0),this.botInitialized&&(this.botInitialized=!1,this.table.footerManager.remove(this.botElement),t=!0),t&&this.table.rowManager.adjustTableSize()},m.prototype.initializeTopRow=function(){this.topInitialized||(this.table.columnManager.element.append(this.topElement),this.topInitialized=!0)},m.prototype.initializeBottomRow=function(){this.botInitialized||(this.table.footerManager.prepend(this.botElement),this.botInitialized=!0)},m.prototype.scrollHorizontal=function(t){this.table.columnManager.element[0].scrollWidth,this.table.element.innerWidth();this.botInitialized&&this.botRow.getElement().css("margin-left",-t)},m.prototype.recalc=function(t){var e;(this.topInitialized||this.botInitialized)&&(this.rowsToData(t),this.topInitialized&&(e=this.generateRow("top",this.rowsToData(t)),this.topRow=e,this.topElement.empty(),this.topElement.append(e.getElement()),e.initialize(!0)),this.botInitialized&&(e=this.generateRow("bottom",this.rowsToData(t)),this.botRow=e,this.botElement.empty(),this.botElement.append(e.getElement()),e.initialize(!0)),this.table.rowManager.adjustTableSize(),this.table.extExists("frozenColumns")&&this.table.extensions.frozenColumns.layout())},m.prototype.recalcRowGroup=function(t){var e,o,i=this.table.extensions.groupRows.getRowGroup(t);i.calcs.bottom&&(e=this.rowsToData(i.rows),o=this.generateRowData("bottom",e),i.calcs.bottom.updateData(o)),i.calcs.top&&(e=this.rowsToData(i.rows),o=this.generateRowData("top",e),i.calcs.top.updateData(o))},m.prototype.generateTopRow=function(t){return this.generateRow("top",this.rowsToData(t))},m.prototype.generateBottomRow=function(t){return this.generateRow("bottom",this.rowsToData(t))},m.prototype.rowsToData=function(t){var e=[];return t.forEach(function(t){e.push(t.getData())}),e},m.prototype.generateRow=function(t,e){var o=this,i=this.generateRowData(t,e),n=new l(i,this);return n.getElement().addClass("tabulator-calcs").addClass("tabulator-calcs-"+t),n.type="calc",n.generateCells=function(){var e=[];o.table.columnManager.columnsByIndex.forEach(function(i){if(i.visible){o.genColumn.setField(i.getField()),o.genColumn.hozAlign=i.hozAlign,i.definition[t+"CalcFormatter"]&&o.table.extExists("format")?o.genColumn.extensions.format={formatter:o.table.extensions.format.getFormatter(i.definition[t+"CalcFormatter"]),params:i.definition[t+"CalcFormatterParams"]}:o.genColumn.extensions.format={formatter:o.table.extensions.format.getFormatter("plaintext"),params:{}};var s=new c(o.genColumn,n);s.column=i,s.setWidth(i.getWidth()),i.cells.push(s),e.push(s)}}),this.cells=e},n},m.prototype.generateRowData=function(t,e){var o={},i="top"==t?this.topCalcs:this.botCalcs,n="top"==t?"topCalc":"botCalc";return i.forEach(function(t){var i=[];t.extensions.columnCalcs&&t.extensions.columnCalcs[n]&&(e.forEach(function(e){i.push(t.getFieldValue(e))}),t.setFieldValue(o,t.extensions.columnCalcs[n](i,e,t.extensions.columnCalcs[n+"Params"])))}),o},m.prototype.hasTopCalcs=function(){return!!this.topCalcs.length},m.prototype.hasBottomCalcs=function(){return!!this.botCalcs.length},m.prototype.redraw=function(){this.topRow&&this.topRow.normalizeHeight(!0),this.botRow&&this.botRow.normalizeHeight(!0)},m.prototype.calculations={avg:function(t,e,o){var i=0,n=void 0!==o.precision?o.precision:2;return t.length&&(i=t.reduce(function(t,e){return e=Number(e),t+e}),i/=t.length,i=!1!==n?i.toFixed(n):i),parseFloat(i).toString()},max:function(t,e,o){var i=null;return t.forEach(function(t){((t=Number(t))>i||null===i)&&(i=t)}),null!==i?i:""},min:function(t,e,o){var i=null;return t.forEach(function(t){((t=Number(t))"}},Tabulator.registerExtension("format",y);var x=function(t){this.table=t,this.leftColumns=[],this.rightColumns=[],this.leftMargin=0,this.rightMargin=0,this.initializationMode="left",this.active=!1};x.prototype.reset=function(){this.initializationMode="left",this.leftColumns=[],this.rightColumns=[],this.active=!1},x.prototype.initializeColumn=function(t){var e={margin:0,edge:!1};t.definition.frozen?t.parent.isGroup?console.warn("Frozen Column Error - Grouped columns cannot be frozen"):t.isGroup?console.warn("Frozen Column Error - Column Groups cannot be frozen"):(e.position=this.initializationMode,"left"==this.initializationMode?this.leftColumns.push(t):this.rightColumns.unshift(t),this.active=!0,t.extensions.frozen=e):this.initializationMode="right"},x.prototype.layout=function(){var t=this,e=this.table.rowManager.element,o=0;t.active&&(t.leftMargin=t._calcSpace(t.leftColumns,t.leftColumns.length),t.table.columnManager.headersElement.css("margin-left",t.leftMargin),t.rightMargin=t._calcSpace(t.rightColumns,t.rightColumns.length),t.table.columnManager.element.css("padding-right",t.rightMargin),t.table.rowManager.activeRows.forEach(function(e){t.layoutRow(e)}),t.table.extExists("columnCalcs")&&(t.table.extensions.columnCalcs.topInitialized&&t.table.extensions.columnCalcs.topRow&&t.layoutRow(t.table.extensions.columnCalcs.topRow),t.table.extensions.columnCalcs.botInitialized&&t.table.extensions.columnCalcs.botRow&&t.layoutRow(t.table.extensions.columnCalcs.botRow)),t.leftColumns.forEach(function(e,o){e.extensions.frozen.margin=t._calcSpace(t.leftColumns,o)+t.table.columnManager.scrollLeft,o==t.leftColumns.length-1?e.extensions.frozen.edge=!0:e.extensions.frozen.edge=!1,t.layoutColumn(e)}),o=t.table.rowManager.element.innerWidth()+t.table.columnManager.scrollLeft,e[0].scrollHeight>e.innerHeight()&&(o-=e[0].offsetWidth-e[0].clientWidth),t.rightColumns.forEach(function(e,i){e.extensions.frozen.margin=o-t._calcSpace(t.rightColumns,i+1),i==t.rightColumns.length-1?e.extensions.frozen.edge=!0:e.extensions.frozen.edge=!1,t.layoutColumn(e)}))},x.prototype.layoutColumn=function(t){var e=this;e.layoutElement(t.element,t),t.cells.forEach(function(o){e.layoutElement(o.element,t)})},x.prototype.layoutRow=function(t){t.getElement().css({"padding-left":this.leftMargin,"padding-right":this.rightMargin})},x.prototype.layoutElement=function(t,e){if(e.extensions.frozen){var o={position:"absolute",left:e.extensions.frozen.margin};t.css(o),t.addClass("tabulator-frozen"),e.extensions.frozen.edge&&t.addClass("tabulator-frozen-"+e.extensions.frozen.position)}},x.prototype._calcSpace=function(t,e){for(var o=0,i=0;i
" + options.placeholder + "
");
+ }
+
+ //set table height
+ if(options.height){
+ options.height = isNaN(options.height) ? options.height : options.height + "px";
+ this.element.css({"height": options.height});
+ }
+
+ //build table elements
+ element.append(this.columnManager.getElement());
+ element.append(this.rowManager.getElement());
+
+
+ if(options.footerElement){
+ this.footerManager.activate();
+ }
+
+
+ if(options.persistentLayout && this.extExists("persistentLayout", true)){
+ ext.persistentLayout.initialize(options.persistentLayout, options.persistentLayoutID);
+ options.columns = ext.persistentLayout.load(options.columns);
+ }
+
+ if(this.extExists("columnCalcs")){
+ ext.columnCalcs.initialize();
+ }
+
+ this.columnManager.setColumns(options.columns);
+
+ if(options.initialSort && this.extExists("sort", true)){
+ ext.sort.setSort(options.initialSort);
+ }
+
+ if(options.pagination && this.extExists("page", true)){
+ ext.page.initialize();
+ }
+
+ if(options.groupBy && this.extExists("groupRows", true)){
+ ext.groupRows.initialize();
+ }
+
+ if(this.extExists("ajax")){
+ ext.ajax.initialize();
+ }
+
+ if(this.extExists("keybindings")){
+ ext.keybindings.initialize();
+ }
+
+ if(this.extExists("selectRow")){
+ ext.selectRow.clearSelectionData();
+ }
+
+ options.tableBuilt();
+ },
+
+ _loadInitialData: function(){
+ var self = this;
+
+ if(self.options.pagination && self.extExists("page")){
+ self.extensions.page.reset(true);
+ self.extensions.page.setPage(1);
+
+ if(self.options.pagination == "local"){
+ self.rowManager.setData(self.options.data);
+ }
+ }else{
+ if(self.options.data.length){
+ self.rowManager.setData(self.options.data);
+ }else{
+ if(self.options.ajaxURL && self.extExists("ajax")){
+ self.extensions.ajax.sendRequest(function(data){
+ self.rowManager.setData(data);
+ });
+ }else{
+ self.rowManager.setData(self.options.data);
+ }
+ }
+ }
+ },
+
+ //set options
+ _setOption: function(option, value){
+ console.error("Options Error - Tabulator does not allow options to be set after initialization unless there is a function defined for that purpose");
+ },
+
+ //deconstructor
+ _destroy: function(){
+ var element = this.element;
+
+ element.empty();
+
+ element.removeClass("tabulator");
+ },
+
+ _detectBrowser(){
+ var ua = navigator.userAgent;
+
+ if(ua.indexOf("Trident") > -1){
+ this.brower = "ie";
+ this.browserSlow = true;
+ }else if(ua.indexOf("Edge") > -1){
+ this.brower = "edge";
+ this.browserSlow = true;
+ }else{
+ this.brower = "other";
+ this.browserSlow = false;
+ }
+ },
+
+ ////////////////// Data Handling //////////////////
+
+
+ //load data
+ setData:function(data, params, config){
+ var self = this;
+ var self = this;
+
+ if(typeof(data) === "string"){
+ if (data.indexOf("{") == 0 || data.indexOf("[") == 0){
+ //data is a json encoded string
+ self.rowManager.setData(JSON.parse(data));
+ }else{
+
+ if(self.extExists("ajax", true)){
+ if(params){
+ self.extensions.ajax.setParams(params);
+ }
+
+ if(config){
+ self.extensions.ajax.setConfig(config);
+ }
+
+ self.extensions.ajax.setUrl(data);
+
+ if(self.options.pagination == "remote" && self.extExists("page", true)){
+ self.extensions.page.reset(true);
+ self.extensions.page.setPage(1);
+ }else{
+ //assume data is url, make ajax call to url to get data
+ self.extensions.ajax.sendRequest(function(data){
+ self.rowManager.setData(data);
+ });
+ }
+ }
+ }
+ }else{
+ if(data){
+ //asume data is already an object
+ self.rowManager.setData(data);
+ }else{
+
+ //no data provided, check if ajaxURL is present;
+ if(self.extExists("ajax") && self.extensions.ajax.getUrl){
+
+ if(self.options.pagination == "remote" && self.extExists("page", true)){
+ self.extensions.page.reset(true);
+ self.extensions.page.setPage(1);
+ }else{
+ self.extensions.ajax.sendRequest(function(data){
+ self.rowManager.setData(data);
+ });
+ }
+
+ }else{
+ //empty data
+ self.rowManager.setData([]);
+ }
+ }
+ }
+ },
+
+ //clear data
+ clearData:function(){
+ this.rowManager.clearData();
+ },
+
+ //get table data array
+ getData:function(active){
+ return this.rowManager.getData(active);
+ },
+
+ //get table data array count
+ getDataCount:function(active){
+ return this.rowManager.getDataCount(active);
+ },
+
+ //get table html
+ getHtml:function(active){
+ return this.rowManager.getHtml(active);
+ },
+
+ //retrieve Ajax URL
+ getAjaxUrl:function(){
+ if(this.extExists("ajax", true)){
+ return this.extensions.ajax.getUrl();
+ }
+ },
+
+
+ //update table data
+ updateData:function(data){
+ var self = this;
+
+ if(data){
+ data.forEach(function(item){
+ var row = self.rowManager.findRow(item[self.options.index]);
+
+ if(row){
+ row.updateData(item);
+ }
+ })
+ }else{
+ console.warn("Update Error - No data provided");
+ }
+ },
+
+ addData:function(data, pos, index){
+ if(data){
+ this.rowManager.addRows(data, pos, index);
+ }else{
+ console.warn("Update Error - No data provided");
+ }
+ },
+
+ //update table data
+ updateOrAddData:function(data){
+ var self = this;
+
+ if(data){
+ data.forEach(function(item){
+ var row = self.rowManager.findRow(item[self.options.index]);
+
+ if(row){
+ row.updateData(item);
+ }else{
+ self.rowManager.addRow(item);
+ }
+ })
+ }else{
+ console.warn("Update Error - No data provided");
+ }
+ },
+
+ //get row object
+ getRow:function(index){
+ var row = this.rowManager.findRow(index);
+
+ if(row){
+ return row.getComponent();
+ }else{
+ console.warn("Find Error - No matching row found:", index);
+ return false;
+ }
+ },
+
+ //delete row from table
+ deleteRow:function(index){
+ var row = this.rowManager.findRow(index);
+
+ if(row){
+ row.delete();
+ return true;
+ }else{
+ console.warn("Delete Error - No matching row found:", index);
+ return false;
+ }
+ },
+
+ //add row to table
+ addRow:function(data, pos, index){
+ return this.rowManager.addRow(data, pos, index);
+ },
+
+ //update a row if it exitsts otherwise create it
+ updateOrAddRow:function(index, data){
+ var row = this.rowManager.findRow(index);
+
+ if(row){
+ row.updateData(data);
+ }else{
+ row = this.rowManager.addRow(data);
+ }
+
+ return row.getComponent();
+ },
+
+ //update row data
+ updateRow:function(index, data){
+ var row = this.rowManager.findRow(index);
+
+ if(row){
+ row.updateData(data);
+ return row.getComponent();
+ }else{
+ console.warn("Update Error - No matching row found:", index);
+ return false;
+ }
+ },
+
+ //scroll to row in DOM
+ scrollToRow:function(index){
+ var row = this.rowManager.findRow(index);
+
+ if(row){
+ return this.rowManager.scrollToRow(row);
+ }else{
+ console.warn("Scroll Error - No matching row found:", index);
+ return false;
+ }
+ },
+
+ getRows:function(active){
+ return this.rowManager.getComponents(active);
+ },
+
+ /////////////// Column Functions ///////////////
+
+ setColumns:function(definition){
+ this.columnManager.setColumns(definition);
+ },
+
+ getColumns:function(){
+ return this.columnManager.getComponents();
+ },
+
+ getColumnDefinitions:function(){
+ return this.columnManager.getDefinitionTree();
+ },
+
+ getColumnLayout:function(){
+ if(this.extExists("persistentLayout", true)){
+ return this.extensions.persistentLayout.parseColumns(this.columnManager.getColumns());
+ }
+ },
+
+ setColumnLayout:function(layout){
+ if(this.extExists("persistentLayout", true)){
+ this.columnManager.setColumns(this.extensions.persistentLayout.mergeDefinition(this.options.columns, layout))
+ return true;
+ }
+ return false;
+ },
+
+ showColumn:function(field){
+ var column = this.columnManager.findColumn(field);
+
+ if(column){
+ column.show();
+ }else{
+ console.warn("Column Show Error - No matching column found:", field);
+ return false;
+ }
+ },
+
+ hideColumn:function(field){
+ var column = this.columnManager.findColumn(field);
+
+ if(column){
+ column.hide();
+ }else{
+ console.warn("Column Hide Error - No matching column found:", field);
+ return false;
+ }
+ },
+
+
+ toggleColumn:function(field){
+ var column = this.columnManager.findColumn(field);
+
+ if(column){
+ if(column.visible){
+ column.hide();
+ }else{
+ column.show();
+ }
+ }else{
+ console.warn("Column Visibility Toggle Error - No matching column found:", field);
+ return false;
+ }
+ },
+
+ addColumn:function(definition, before, field){
+ var column = this.columnManager.findColumn(field);
+
+ this.columnManager.addColumn(definition, before, column)
+ },
+
+ deleteColumn:function(field){
+ var column = this.columnManager.findColumn(field);
+
+ if(column){
+ column.delete();
+ }else{
+ console.warn("Column Delete Error - No matching column found:", field);
+ return false;
+ }
+ },
+
+
+ //////////// Localization Functions ////////////
+ setLocale:function(locale){
+ this.extensions.localize.setLocale(locale);
+ },
+
+ getLocale:function(){
+ return this.extensions.localize.getLocale();
+ },
+
+ getLang:function(locale){
+ return this.extensions.localize.getLang(locale);
+ },
+
+ //////////// General Public Functions ////////////
+
+ //redraw list without updating data
+ redraw:function(force){
+ this.columnManager.redraw(force);
+ this.rowManager.redraw(force);
+ },
+
+ setHeight:function(height){
+ this.options.height = isNaN(height) ? height : height + "px";
+ this.element.css({"height": this.options.height});
+ this.rowManager.redraw();
+ },
+
+ ///////////////////// Sorting ////////////////////
+
+ //trigger sort
+ setSort:function(sortList, dir){
+ if(this.extExists("sort", true)){
+ this.extensions.sort.setSort(sortList, dir);
+ this.rowManager.sorterRefresh();
+ }
+ },
+
+ getSort:function(){
+ if(this.extExists("sort", true)){
+ console.warn("The%c getSort%c function has been depricated and will be removed in version 4.0, use %c getSorters%c instead.", "font-weight:bold;", "font-weight:regular;", "font-weight:bold;", "font-weight:regular;");
+ return this.getSorters();
+ }
+ },
+
+ getSorters:function(){
+ if(this.extExists("sort", true)){
+ return this.extensions.sort.getSort();
+ }
+ },
+
+ clearSort:function(){
+ if(this.extExists("sort", true)){
+ this.extensions.sort.clear();
+ this.rowManager.sorterRefresh();
+ }
+ },
+
+
+ ///////////////////// Filtering ////////////////////
+
+ //set standard filters
+ setFilter:function(field, type, value){
+ if(this.extExists("filter", true)){
+ this.extensions.filter.setFilter(field, type, value);
+ this.rowManager.filterRefresh();
+ }
+ },
+
+ //add filter to array
+ addFilter:function(field, type, value){
+ if(this.extExists("filter", true)){
+ this.extensions.filter.addFilter(field, type, value);
+ this.rowManager.filterRefresh();
+ }
+ },
+
+ //get all filters
+ getFilter:function(all){
+ console.warn("The%c getFilter%c function has been depricated and will be removed in version 4.0, use %c getFilters%c instead.", "font-weight:bold;", "font-weight:regular;", "font-weight:bold;", "font-weight:regular;");
+ this.getFilters(all);
+ },
+
+ getFilters:function(all){
+ if(this.extExists("filter", true)){
+ return this.extensions.filter.getFilters(all);
+ }
+ },
+
+ getHeaderFilters:function(){
+ if(this.extExists("filter", true)){
+ return this.extensions.filter.getHeaderFilters();
+ }
+ },
+
+
+
+
+ //remove filter from array
+ removeFilter:function(field, type, value){
+ if(this.extExists("filter", true)){
+ this.extensions.filter.removeFilter(field, type, value);
+ this.rowManager.filterRefresh();
+ }
+ },
+
+ //clear filters
+ clearFilter:function(all){
+ if(this.extExists("filter", true)){
+ this.extensions.filter.clearFilter(all);
+ this.rowManager.filterRefresh();
+ }
+ },
+
+ //clear header filters
+ clearHeaderFilter:function(){
+ if(this.extExists("filter", true)){
+ this.extensions.filter.clearHeaderFilter();
+ this.rowManager.filterRefresh();
+ }
+ },
+
+ ///////////////////// Filtering ////////////////////
+ selectRow:function(rows){
+ if(this.extExists("selectRow", true)){
+ this.extensions.selectRow.selectRows(rows);
+ }
+ },
+
+ deselectRow:function(rows){
+ if(this.extExists("selectRow", true)){
+ this.extensions.selectRow.deselectRows(rows);
+ }
+ },
+
+ toggleSelectRow:function(row){
+ if(this.extExists("selectRow", true)){
+ this.extensions.selectRow.toggleRow(row);
+ }
+ },
+
+ getSelectedRows:function(){
+ if(this.extExists("selectRow", true)){
+ return this.extensions.selectRow.getSelectedRows();
+ }
+ },
+
+ getSelectedData:function(){
+ if(this.extExists("selectRow", true)){
+ return this.extensions.selectRow.getSelectedData();
+ }
+ },
+
+ //////////// Pagination Functions ////////////
+
+ setMaxPage:function(max){
+ if(this.options.pagination && this.extExists("page")){
+ this.extensions.page.setMaxPage(max);
+ }else{
+ return false;
+ }
+ },
+
+ setPage:function(page){
+ if(this.options.pagination && this.extExists("page")){
+ this.extensions.page.setPage(page);
+ }else{
+ return false;
+ }
+ },
+
+ setPageSize:function(size){
+ if(this.options.pagination && this.extExists("page")){
+ this.extensions.page.setPageSize(size);
+ this.extensions.page.setPage(1);
+ }else{
+ return false;
+ }
+ },
+
+ getPageSize:function(){
+ if(this.options.pagination && this.extExists("page", true)){
+ return this.extensions.page.getPageSize();
+ }
+ },
+
+ previousPage:function(){
+ if(this.options.pagination && this.extExists("page")){
+ this.extensions.page.previousPage();
+ }else{
+ return false;
+ }
+ },
+
+ nextPage:function(){
+ if(this.options.pagination && this.extExists("page")){
+ this.extensions.page.nextPage();
+ }else{
+ return false;
+ }
+ },
+
+ getPage:function(){
+ if(this.options.pagination && this.extExists("page")){
+ return this.extensions.page.getPage();
+ }else{
+ return false;
+ }
+ },
+
+ getPageMax:function(){
+ if(this.options.pagination && this.extExists("page")){
+ return this.extensions.page.getPageMax();
+ }else{
+ return false;
+ }
+ },
+
+ ///////////////// Grouping Functions ///////////////
+
+ setGroupBy:function(groups){
+ if(this.extExists("groupRows", true)){
+ this.options.groupBy = groups;
+ this.extensions.groupRows.initialize();
+ this.rowManager.refreshActiveData();
+ }else{
+ return false;
+ }
+ },
+
+ setGroupStartOpen:function(values){
+ if(this.extExists("groupRows", true)){
+ this.options.groupStartOpen = values;
+ this.extensions.groupRows.initialize();
+ if(this.options.groupBy){
+
+ this.rowManager.refreshActiveData();
+ }else{
+ console.warn("Grouping Update - cant refresh view, no groups have been set");
+ }
+ }else{
+ return false;
+ }
+ },
+
+ setGroupHeader:function(values){
+ if(this.extExists("groupRows", true)){
+ this.options.groupHeader = values;
+ this.extensions.groupRows.initialize();
+ if(this.options.groupBy){
+ this.rowManager.refreshActiveData();
+ }else{
+ console.warn("Grouping Update - cant refresh view, no groups have been set");
+ }
+ }else{
+ return false;
+ }
+ },
+
+ getGroups:function(values){
+ if(this.extExists("groupRows", true)){
+ return this.extensions.groupRows.getGroups();
+ }else{
+ return false;
+ }
+ },
+
+
+ /////////////// Navigation Management //////////////
+
+ navigatePrev:function(){
+ var cell = false;
+
+ if(this.table.extExists("edit", true)){
+ cell = this.table.extensions.edit.currentCell;
+
+ if(cell){
+ e.preventDefault();
+ return cell.nav().prev();
+ }
+ }
+
+ return false;
+ },
+
+ navigateNext:function(){
+ var cell = false;
+
+ if(this.table.extExists("edit", true)){
+ cell = this.table.extensions.edit.currentCell;
+
+ if(cell){
+ e.preventDefault();
+ return cell.nav().next();
+ }
+ }
+
+ return false;
+ },
+
+ navigateLeft:function(){
+ var cell = false;
+
+ if(this.table.extExists("edit", true)){
+ cell = this.table.extensions.edit.currentCell;
+
+ if(cell){
+ e.preventDefault();
+ return cell.nav().left();
+ }
+ }
+
+ return false;
+ },
+
+ navigateRight:function(){
+ var cell = false;
+
+ if(this.table.extExists("edit", true)){
+ cell = this.table.extensions.edit.currentCell;
+
+ if(cell){
+ e.preventDefault();
+ return cell.nav().right();
+ }
+ }
+
+ return false;
+ },
+
+ navigateUp:function(){
+ var cell = false;
+
+ if(this.table.extExists("edit", true)){
+ cell = this.table.extensions.edit.currentCell;
+
+ if(cell){
+ e.preventDefault();
+ return cell.nav().up();
+ }
+ }
+
+ return false;
+ },
+
+ navigateDown:function(){
+ var cell = false;
+
+ if(this.table.extExists("edit", true)){
+ cell = this.table.extensions.edit.currentCell;
+
+ if(cell){
+ e.preventDefault();
+ return cell.nav().dpwn();
+ }
+ }
+
+ return false;
+ },
+
+
+ /////////////// History Management //////////////
+ undo:function(){
+ if(this.options.history && this.extExists("history", true)){
+ return this.extensions.history.undo();
+ }else{
+ return false;
+ }
+ },
+
+ redo:function(){
+ if(this.options.history && this.extExists("history", true)){
+ return this.extensions.history.redo();
+ }else{
+ return false;
+ }
+ },
+
+ /////////////// Download Management //////////////
+
+ download:function(type, filename, options){
+ if(this.extExists("download", true)){
+ this.extensions.download.download(type, filename, options);
+ }
+ },
+
+ ////////////// Extension Management //////////////
+
+ //object to hold extensions
+ extensions:{},
+ extensionBindings:{},
+
+ //extend extension
+ extendExtension:function(name, property, values){
+
+ if(this.extensionBindings[name]){
+ var source = this.extensionBindings[name].prototype[property];
+
+ if(source){
+ if(typeof values == "object"){
+ for(let key in values){
+ source[key] = values[key];
+ }
+ }else{
+ console.warn("Extension Error - Invalid value type, it must be an object");
+ }
+ }else{
+ console.warn("Extension Error - property does not exist:", property);
+ }
+ }else{
+ console.warn("Extension Error - extension does not exist:", name);
+ }
+
+ },
+
+ //add extension to tabulator
+ registerExtension:function(name, extension){
+ var self = this;
+ this.extensionBindings[name] = extension;
+ },
+
+ //ensure that extensions are bound to instantiated function
+ bindExtensions:function(){
+ var self = this;
+
+ this.extensions = {};
+
+ for(var name in self.extensionBindings){
+ self.extensions[name] = new self.extensionBindings[name](self);
+ }
+ },
+
+ //Check for plugin
+ extExists:function(plugin, required){
+ if(this.extensions[plugin]){
+ return true;
+ }else{
+ if(required){
+ console.error("Tabulator Plugin Not Installed: " + plugin);
+ }
+ return false;
+ }
+ },
+
+ };
+
+ /*=include extensions/layout.js */
+ /*=include extensions/localize.js */
+
+ /*=include extensions_enabled.js */
+
+ })();
diff --git a/js/tabulator/src/js/extensions/accessor.js b/js/tabulator/src/js/extensions/accessor.js
new file mode 100644
index 0000000..fd98eaf
--- /dev/null
+++ b/js/tabulator/src/js/extensions/accessor.js
@@ -0,0 +1,58 @@
+var Accessor = function(table){
+ this.table = table; //hold Tabulator object
+};
+
+
+//initialize column accessor
+Accessor.prototype.initializeColumn = function(column){
+
+ var config = {accessor:false, params:column.definition.accessorParams || {}};
+
+ //set column accessor
+ switch(typeof column.definition.accessor){
+ case "string":
+ if(this.accessors[column.definition.accessor]){
+ config.accessor = this.accessors[column.definition.accessor]
+ }else{
+ console.warn("Accessor Error - No such accessor found, ignoring: ", column.definition.accessor);
+ }
+ break;
+
+ case "function":
+ config.accessor = column.definition.accessor;
+ break;
+ }
+
+ if(config.accessor){
+ column.extensions.accessor = config;
+ }
+},
+
+//apply accessor to row
+Accessor.prototype.transformRow = function(dataIn){
+ var self = this;
+
+ //clone data object with deep copy to isolate internal data from returned result
+ var data = $.extend(true, {}, dataIn || {});
+
+ self.table.columnManager.traverse(function(column){
+ var field;
+
+ if(column.extensions.accessor){
+ field = column.getField();
+
+ if(typeof data[field] != "undefined"){
+ column.setFieldValue(data, column.extensions.accessor.accessor(column.getFieldValue(data), data, column.extensions.accessor.params));
+ }
+ }
+ });
+
+ return data;
+},
+
+//default accessors
+Accessor.prototype.accessors = {};
+
+
+
+Tabulator.registerExtension("accessor", Accessor);
\ No newline at end of file
diff --git a/js/tabulator/src/js/extensions/ajax.js b/js/tabulator/src/js/extensions/ajax.js
new file mode 100644
index 0000000..f3ef7ba
--- /dev/null
+++ b/js/tabulator/src/js/extensions/ajax.js
@@ -0,0 +1,187 @@
+var Ajax = function(table){
+
+ this.table = table; //hold Tabulator object
+ this.config = false; //hold config object for ajax request
+ this.url = ""; //request URL
+ this.params = false; //request parameters
+
+ this.loaderElement = $(""); //loader message div
+ this.msgElement = $(""); //message element
+ this.loadingElement = false;
+ this.errorElement = false;
+};
+
+//initialize setup options
+Ajax.prototype.initialize = function(){
+ this.loaderElement.append(this.msgElement);
+
+ if(this.table.options.ajaxLoaderLoading){
+ this.loadingElement = this.table.options.ajaxLoaderLoading;
+ }
+
+ if(this.table.options.ajaxLoaderError){
+ this.errorElement = this.table.options.ajaxLoaderError;
+ }
+
+ if(this.table.options.ajaxParams){
+ this.setParams(this.table.options.ajaxParams);
+ }
+
+ if(this.table.options.ajaxConfig){
+ this.setConfig(this.table.options.ajaxConfig);
+ }
+
+ if(this.table.options.ajaxURL){
+ this.setUrl(this.table.options.ajaxURL);
+ }
+
+};
+
+//set ajax params
+Ajax.prototype.setParams = function(params, update){
+ if(update){
+ this.params = this.params || {};
+
+ for(let key in params){
+ this.params[key] = params[key];
+ }
+ }else{
+ this.params = params;
+ }
+};
+
+Ajax.prototype.getParams = function(){
+ return this.params || {};
+};
+
+//load config object
+Ajax.prototype.setConfig = function(config){
+ this._loadDefaultConfig();
+
+ if(typeof config == "string"){
+ this.config.type = config;
+ }else{
+ for(let key in config){
+ this.config[key] = config[key];
+ }
+ }
+};
+
+//create config object from default
+Ajax.prototype._loadDefaultConfig = function(force){
+ var self = this;
+ if(!self.config || force){
+
+ self.config = {};
+
+ //load base config from defaults
+ for(let key in self.defaultConfig){
+ self.config[key] = self.defaultConfig[key];
+ }
+ }
+};
+
+//set request url
+Ajax.prototype.setUrl = function(url){
+ this.url = url;
+};
+
+//get request url
+Ajax.prototype.getUrl = function(){
+ return this.url;
+};
+
+//send ajax request
+Ajax.prototype.sendRequest = function(callback){
+ var self = this;
+
+ if(self.url){
+
+ self._loadDefaultConfig();
+
+ self.config.url = self.url;
+
+ if(self.params){
+ self.config.data = self.params;
+ }
+
+ if(self.table.options.ajaxRequesting(self.url, self.params) !== false){
+
+ self.showLoader();
+
+ $.ajax(self.config)
+ .done(function(data){
+ if(self.table.options.ajaxResponse){
+ data = self.table.options.ajaxResponse(self.url, self.params, data);
+ }
+
+ self.table.options.dataLoaded(data);
+
+ callback(data);
+
+ self.hideLoader();
+ })
+ .fail(function(xhr, textStatus, errorThrown){
+ console.error("Ajax Load Error - Connection Error: " + xhr.status, errorThrown);
+
+ self.table.options.ajaxError(xhr, textStatus, errorThrown);
+ self.showError();
+
+ setTimeout(function(){
+ self.hideLoader();
+ }, 3000);
+ });
+ }
+
+ }else{
+ console.warn("Ajax Load Error - No URL Set");
+ return false;
+ }
+};
+
+Ajax.prototype.showLoader = function(){
+ this.loaderElement.detach();
+
+ this.msgElement.empty()
+ .removeClass("tabulator-error")
+ .addClass("tabulator-loading")
+
+ if(this.loadingElement){
+ this.msgElement.append(this.loadingElement);
+ }else{
+ this.msgElement.append(this.table.extensions.localize.getText("ajax.loading"));
+ }
+
+ this.table.element.append(this.loaderElement);
+};
+
+Ajax.prototype.showError = function(){
+ this.loaderElement.detach();
+
+ this.msgElement.empty()
+ .removeClass("tabulator-loading")
+ .addClass("tabulator-error")
+
+ if(this.errorElement){
+ this.msgElement.append(this.errorElement);
+ }else{
+ this.msgElement.append(this.table.extensions.localize.getText("ajax.error"));
+ }
+
+ this.table.element.append(this.loaderElement);
+};
+
+Ajax.prototype.hideLoader = function(){
+ this.loaderElement.detach();
+};
+
+//default ajax config object
+Ajax.prototype.defaultConfig = {
+ url: "",
+ type: "GET",
+ async: true,
+ dataType:"json",
+ success: function (data){}
+};
+
+Tabulator.registerExtension("ajax", Ajax);
\ No newline at end of file
diff --git a/js/tabulator/src/js/extensions/calculation_colums.js b/js/tabulator/src/js/extensions/calculation_colums.js
new file mode 100644
index 0000000..e3f7593
--- /dev/null
+++ b/js/tabulator/src/js/extensions/calculation_colums.js
@@ -0,0 +1,381 @@
+var ColumnCalcs = function(table){
+ this.table = table; //hold Tabulator object
+ this.topCalcs = [];
+ this.botCalcs = [];
+ this.genColumn = false;
+ this.topElement = $("");
+ this.botElement = $("");
+ this.topRow = false;
+ this.botRow = false;
+ this.topInitialized = false;
+ this.botInitialized = false;
+
+ this.initialize();
+};
+
+ColumnCalcs.prototype.initialize = function(){
+ this.genColumn = new Column({field:"value"}, this);
+};
+
+//dummy functions to handle being mock column manager
+ColumnCalcs.prototype.registerColumnField = function(){};
+
+//initialize column calcs
+ColumnCalcs.prototype.initializeColumn = function(column){
+ var def = column.definition
+
+ var config = {
+ topCalcParams:def.topCalcParams || {},
+ botCalcParams:def.bottomCalcParams || {},
+ };
+
+ if(def.topCalc){
+
+ switch(typeof def.topCalc){
+ case "string":
+ if(this.calculations[def.topCalc]){
+ config.topCalc = this.calculations[def.topCalc]
+ }else{
+ console.warn("Column Calc Error - No such calculation found, ignoring: ", def.topCalc);
+ }
+ break;
+
+ case "function":
+ config.topCalc = def.topCalc;
+ break
+
+ }
+
+ if(config.topCalc){
+ column.extensions.columnCalcs = config;
+ this.topCalcs.push(column);
+
+ if(!this.table.options.groupBy){
+ this.initializeTopRow();
+ }
+ }
+
+ }
+
+ if(def.bottomCalc){
+ switch(typeof def.bottomCalc){
+ case "string":
+ if(this.calculations[def.bottomCalc]){
+ config.botCalc = this.calculations[def.bottomCalc]
+ }else{
+ console.warn("Column Calc Error - No such calculation found, ignoring: ", def.bottomCalc);
+ }
+ break;
+
+ case "function":
+ config.botCalc = def.bottomCalc;
+ break
+
+ }
+
+ if(config.botCalc){
+ column.extensions.columnCalcs = config;
+ this.botCalcs.push(column);
+
+ if(!this.table.options.groupBy){
+ this.initializeBottomRow();
+ }
+ }
+ }
+
+};
+
+ColumnCalcs.prototype.removeCalcs = function(){
+ var changed = false;
+
+ if(this.topInitialized){
+ this.topInitialized = false;
+ this.topElement.remove();
+ changed = true;
+ }
+
+ if(this.botInitialized){
+ this.botInitialized = false;
+ this.table.footerManager.remove(this.botElement);
+ changed = true;
+ }
+
+ if(changed){
+ this.table.rowManager.adjustTableSize();
+ }
+};
+
+ColumnCalcs.prototype.initializeTopRow = function(){
+ if(!this.topInitialized){
+ this.table.columnManager.element.append(this.topElement);
+ this.topInitialized = true;
+ }
+};
+
+ColumnCalcs.prototype.initializeBottomRow = function(){
+ if(!this.botInitialized){
+ this.table.footerManager.prepend(this.botElement);
+ this.botInitialized = true;
+ }
+};
+
+
+ColumnCalcs.prototype.scrollHorizontal = function(left){
+ var hozAdjust = 0,
+ scrollWidth = this.table.columnManager.element[0].scrollWidth - this.table.element.innerWidth();
+
+ if(this.botInitialized){
+ this.botRow.getElement().css("margin-left", -left);
+ }
+};
+
+
+ColumnCalcs.prototype.recalc = function(rows){
+ var data, row;
+
+ if(this.topInitialized || this.botInitialized){
+ data = this.rowsToData(rows);
+
+ if(this.topInitialized){
+ row = this.generateRow("top", this.rowsToData(rows))
+ this.topRow = row;
+ this.topElement.empty();
+ this.topElement.append(row.getElement());
+ row.initialize(true);
+ }
+
+ if(this.botInitialized){
+ row = this.generateRow("bottom", this.rowsToData(rows))
+ this.botRow = row;
+ this.botElement.empty();
+ this.botElement.append(row.getElement());
+ row.initialize(true);
+ }
+
+ this.table.rowManager.adjustTableSize();
+
+ //set resizable handles
+ if(this.table.extExists("frozenColumns")){
+ this.table.extensions.frozenColumns.layout();
+ }
+ }
+};
+
+ColumnCalcs.prototype.recalcRowGroup = function(row){
+ var data, rowData;
+
+ var group = this.table.extensions.groupRows.getRowGroup(row);
+
+ if(group.calcs.bottom){
+ data = this.rowsToData(group.rows);
+ rowData = this.generateRowData("bottom", data);
+
+ group.calcs.bottom.updateData(rowData);
+ }
+
+ if(group.calcs.top){
+ data = this.rowsToData(group.rows);
+ rowData = this.generateRowData("top", data);
+
+ group.calcs.top.updateData(rowData);
+ }
+};
+
+
+//generate top stats row
+ColumnCalcs.prototype.generateTopRow = function(rows){
+ return this.generateRow("top", this.rowsToData(rows));
+};
+//generate bottom stats row
+ColumnCalcs.prototype.generateBottomRow = function(rows){
+ return this.generateRow("bottom", this.rowsToData(rows));
+};
+
+ColumnCalcs.prototype.rowsToData = function(rows){
+ var data = [];
+
+ rows.forEach(function(row){
+ data.push(row.getData());
+ });
+
+ return data;
+};
+
+//generate stats row
+ColumnCalcs.prototype.generateRow = function(pos, data){
+ var self = this,
+ rowData = this.generateRowData(pos, data),
+ row = new Row(rowData, this);
+
+ row.getElement().addClass("tabulator-calcs").addClass("tabulator-calcs-" + pos);
+ row.type = "calc";
+
+ row.generateCells = function(){
+
+ var cells = [];
+
+ self.table.columnManager.columnsByIndex.forEach(function(column){
+
+ if(column.visible){
+ //set field name of mock column
+ self.genColumn.setField(column.getField());
+ self.genColumn.hozAlign = column.hozAlign;
+
+ if(column.definition[pos + "CalcFormatter"] && self.table.extExists("format")){
+
+ self.genColumn.extensions.format = {
+ formatter: self.table.extensions.format.getFormatter(column.definition[pos + "CalcFormatter"]),
+ params: column.definition[pos + "CalcFormatterParams"]
+ }
+ }else{
+ self.genColumn.extensions.format = {
+ formatter: self.table.extensions.format.getFormatter("plaintext"),
+ params:{}
+ }
+ }
+
+ //generate cell and assign to correct column
+ var cell = new Cell(self.genColumn, row);
+ cell.column = column;
+
+ cell.setWidth(column.getWidth());
+
+ column.cells.push(cell);
+ cells.push(cell);
+ }
+ });
+
+ this.cells = cells;
+ }
+
+ return row;
+};
+
+//generate stats row
+ColumnCalcs.prototype.generateRowData = function(pos, data){
+ var rowData = {},
+ calcs = pos == "top" ? this.topCalcs : this.botCalcs,
+ type = pos == "top" ? "topCalc" : "botCalc";
+
+ calcs.forEach(function(column){
+ var values = [];
+
+ if(column.extensions.columnCalcs && column.extensions.columnCalcs[type]){
+ data.forEach(function(item){
+ values.push(column.getFieldValue(item));
+ });
+
+ column.setFieldValue(rowData, column.extensions.columnCalcs[type](values, data, column.extensions.columnCalcs[type + "Params"]));
+ }
+ });
+
+ return rowData;
+};
+
+ColumnCalcs.prototype.hasTopCalcs = function(){
+ return !!(this.topCalcs.length);
+},
+
+ColumnCalcs.prototype.hasBottomCalcs = function(){
+ return !!(this.botCalcs.length);
+},
+
+//handle table redraw
+ColumnCalcs.prototype.redraw = function(){
+ if(this.topRow){
+ this.topRow.normalizeHeight(true);
+ }
+ if(this.botRow){
+ this.botRow.normalizeHeight(true);
+ }
+};
+
+//default calculations
+ColumnCalcs.prototype.calculations = {
+ "avg":function(values, data, calcParams){
+ var output = 0,
+ precision = typeof calcParams.precision !== "undefined" ? calcParams.precision : 2
+
+ if(values.length){
+ output = values.reduce(function(sum, value){
+ value = Number(value);
+ return sum + value;
+ });
+
+ output = output / values.length;
+
+ output = precision !== false ? output.toFixed(precision) : output;
+ }
+
+ return parseFloat(output).toString();
+ },
+ "max":function(values, data, calcParams){
+ var output = null;
+
+ values.forEach(function(value){
+
+ value = Number(value);
+
+ if(value > output || output === null){
+ output = value;
+ }
+ });
+
+ return output !== null ? output : "";
+ },
+ "min":function(values, data, calcParams){
+ var output = null;
+
+ values.forEach(function(value){
+
+ value = Number(value);
+
+ if(value < output || output === null){
+ output = value;
+ }
+ });
+
+ return output !== null ? output : "";
+ },
+ "sum":function(values, data, calcParams){
+ var output = 0;
+
+ if(values.length){
+ values.forEach(function(value){
+ value = Number(value);
+
+ output += !isNaN(value) ? Number(value) : 0;
+ });
+ }
+
+ return output;
+ },
+ "concat":function(values, data, calcParams){
+ var output = 0;
+
+ if(values.length){
+ output = values.reduce(function(sum, value){
+ return String(sum) + String(value);
+ });
+ }
+
+ return output;
+ },
+ "count":function(values, data, calcParams){
+ var output = 0;
+
+ if(values.length){
+ values.forEach(function(value){
+ if(value){
+ output ++;
+ }
+ });
+ }
+
+ return output;
+ },
+};
+
+
+
+Tabulator.registerExtension("columnCalcs", ColumnCalcs);
\ No newline at end of file
diff --git a/js/tabulator/src/js/extensions/download.js b/js/tabulator/src/js/extensions/download.js
new file mode 100644
index 0000000..e9ded52
--- /dev/null
+++ b/js/tabulator/src/js/extensions/download.js
@@ -0,0 +1,256 @@
+var Download = function(table){
+ this.table = table; //hold Tabulator object
+ this.fields = {}; //hold filed multi dimension arrays
+};
+
+//trigger file download
+Download.prototype.download = function(type, filename, options){
+ var self = this,
+ downloadFunc = false;
+
+ function buildLink(data, mime){
+ self.triggerDownload(data, mime, type, filename);
+ }
+
+ if(typeof type == "function"){
+ downloadFunc = type;
+ }else{
+ if(self.downloaders[type]){
+ downloadFunc = self.downloaders[type];
+ }else{
+ console.warn("Download Error - No such download type found: ", type);
+ }
+ }
+
+ if(downloadFunc){
+ downloadFunc.call(this, self.processDefinitions(), self.processData() , options, buildLink);
+ }
+};
+
+
+Download.prototype.processDefinitions = function(){
+ var self = this,
+ definitions = self.table.columnManager.getDefinitions(),
+ processedDefinitions = [];
+
+ self.fields = {};
+
+ definitions.forEach(function(column){
+ if(column.field){
+ self.fields[column.field] = column.field.split(".");
+
+ if(column.download !== false){
+ //isolate definiton from defintion object
+ var def = {};
+
+ for(var key in column){
+ def[key] = column[key];
+ }
+
+ if(typeof column.downloadTitle != "undefined"){
+ def.title = column.downloadTitle;
+ }
+
+ processedDefinitions.push(def);
+ }
+ }
+ });
+
+
+ return processedDefinitions;
+};
+
+Download.prototype.processData = function(){
+ var self = this,
+ data = self.table.rowManager.getData(true);
+
+ //add user data processing step;
+ if(typeof self.table.options.downloadDataMutator == "function"){
+ data = self.table.options.downloadDataMutator(data);
+ }
+
+ return data;
+};
+
+Download.prototype.triggerDownload = function(data, mime, type, filename){
+ var element = document.createElement('a'),
+ blob = new Blob([data],{type:mime}),
+ filename = filename || "Tabulator." + (typeof type === "function" ? "txt" : type);
+
+ if(navigator.msSaveOrOpenBlob){
+ navigator.msSaveOrOpenBlob(blob, filename);
+ }else{
+ element.setAttribute('href', window.URL.createObjectURL(blob));
+
+ //set file title
+ element.setAttribute('download', filename);
+
+ //trigger download
+ element.style.display = 'none';
+ document.body.appendChild(element);
+ element.click();
+
+ //remove temporary link element
+ document.body.removeChild(element);
+ }
+};
+
+//nested field lookup
+Download.prototype.getFieldValue = function(field, data){
+ var dataObj = data,
+ structure = this.fields[field],
+ length = structure.length,
+ output;
+
+ for(let i = 0; i < length; i++){
+
+ dataObj = dataObj[structure[i]];
+
+ output = dataObj;
+
+ if(!dataObj){
+ break;
+ }
+ }
+
+ return output;
+};
+
+
+//downloaders
+Download.prototype.downloaders = {
+ csv:function(columns, data, options, setFileContents){
+ var self = this,
+ titles = [],
+ fields = [],
+ delimiter = options && options.delimiter ? options.delimiter : ",",
+ fileContents;
+
+ //get field lists
+ columns.forEach(function(column){
+ if(column.field){
+ titles.push('"' + String(column.title).split('"').join('""') + '"');
+ fields.push(column.field);
+ }
+ })
+
+ //generate header row
+ fileContents = [titles.join(delimiter)];
+
+ //generate each row of the table
+ data.forEach(function(row){
+ var rowData = [];
+
+ fields.forEach(function(field){
+ var value = self.getFieldValue(field, row);
+
+ switch(typeof value){
+ case "object":
+ value = JSON.stringify(value);
+ break;
+
+ case "undefined":
+ case "null":
+ value = "";
+ break;
+
+ default:
+ value = value;
+ }
+
+ //escape uotation marks
+ rowData.push('"' + String(value).split('"').join('""') + '"');
+ })
+
+ fileContents.push(rowData.join(delimiter));
+ });
+
+ setFileContents(fileContents.join("\n"), "text/csv");
+ },
+
+ json:function(columns, data, options, setFileContents){
+ var fileContents = JSON.stringify(data, null, '\t');
+
+ setFileContents(fileContents, "application/json");
+ },
+
+ xlsx:function(columns, data, options, setFileContents){
+ var self = this,
+ titles = [],
+ fields = [],
+ rows = [],
+ workbook = { SheetNames:["Sheet1"], Sheets:{} },
+ worksheet, output;
+
+ //convert rows to worksheet
+ function rowsToSheet(){
+ var sheet = {};
+ var range = {s: {c:0, r:0}, e: {c:fields.length, r:rows.length }};
+
+ rows.forEach(function(row, i){
+ row.forEach(function(value, j){
+ var cell = {v: typeof value == "undefined" || value === null ? "" : value};
+
+ if(cell != null){
+ switch(typeof cell.v){
+ case "number":
+ cell.t = 'n';
+ break;
+ case "boolean":
+ cell.t = 'b';
+ break;
+ default:
+ cell.t = 's';
+ break;
+ }
+
+ sheet[XLSX.utils.encode_cell({c:j,r:i})] = cell
+ }
+ });
+ });
+
+ sheet['!ref'] = XLSX.utils.encode_range(range);
+
+ return sheet;
+ }
+
+ //convert workbook to binary array
+ function s2ab(s) {
+ var buf = new ArrayBuffer(s.length);
+ var view = new Uint8Array(buf);
+ for (var i=0; i!=s.length; ++i) view[i] = s.charCodeAt(i) & 0xFF;
+ return buf;
+ }
+
+ //get field lists
+ columns.forEach(function(column){
+ if(column.field){
+ titles.push(column.title);
+ fields.push(column.field);
+ }
+ });
+
+ rows.push(titles);
+
+ //generate each row of the table
+ data.forEach(function(row){
+ var rowData = [];
+
+ fields.forEach(function(field){
+ rowData.push(self.getFieldValue(field, row));
+ });
+
+ rows.push(rowData);
+ });
+
+
+ worksheet = rowsToSheet();
+ workbook.Sheets["Sheet1"] = worksheet;
+
+ output = XLSX.write(workbook, {bookType:'xlsx', bookSST:true, type: 'binary'});
+
+ setFileContents(s2ab(output), "application/octet-stream");
+ }
+};
+
+Tabulator.registerExtension("download", Download);
\ No newline at end of file
diff --git a/js/tabulator/src/js/extensions/edit.js b/js/tabulator/src/js/extensions/edit.js
new file mode 100644
index 0000000..c76405f
--- /dev/null
+++ b/js/tabulator/src/js/extensions/edit.js
@@ -0,0 +1,580 @@
+var Edit = function(table){
+ this.table = table; //hold Tabulator object
+ this.currentCell = false; //hold currently editing cell
+};
+
+
+//initialize column editor
+Edit.prototype.initializeColumn = function(column){
+ var self = this,
+ config = {
+ editor:false,
+ blocked:false,
+ check:column.definition.editable,
+ params:column.definition.editorParams || {}
+ };
+
+ //set column editor
+ switch(typeof column.definition.editor){
+ case "string":
+ if(self.editors[column.definition.editor]){
+ config.editor = self.editors[column.definition.editor]
+ }else{
+ console.warn("Editor Error - No such editor found: ", column.definition.editor);
+ }
+ break;
+
+ case "function":
+ config.editor = column.definition.editor;
+ break;
+
+ case "boolean":
+
+ if(column.definition.editor === true){
+
+ if(typeof column.definition.formatter !== "function"){
+ if(self.editors[column.definition.formatter]){
+ config.editor = self.editors[column.definition.formatter];
+ }else{
+ config.editor = self.editors["input"];
+ }
+ }else{
+ console.warn("Editor Error - Cannot auto lookup editor for a custom formatter: ", column.definition.formatter);
+ }
+ }
+ break;
+ }
+
+ if(config.editor){
+ column.extensions.edit = config;
+ }
+};
+
+Edit.prototype.getCurrentCell = function(){
+ return this.currentCell ? this.currentCell.getComponent() : false;
+};
+
+Edit.prototype.clearEditor = function(cell){
+ this.currentCell = false;
+ cell.getElement().removeClass("tabulator-validation-fail");
+ cell.getElement().removeClass("tabulator-editing").empty();
+ cell.row.getElement().removeClass("tabulator-row-editing");
+};
+
+//return a formatted value for a cell
+Edit.prototype.bindEditor = function(cell){
+ var self = this,
+ rendered = function(){},
+ element = cell.getElement(),
+ mouseClick = false;
+
+ //handle successfull value change
+ function success(value){
+ var valid = true;
+
+ if(cell.column.extensions.validate && self.table.extExists("validate")){
+ valid = self.table.extensions.validate.validate(cell.column.extensions.validate, cell.getComponent(), value);
+ }
+
+ if(valid === true){
+ self.clearEditor(cell);
+ cell.setValue(value, true);
+ }else{
+ cell.getElement().addClass("tabulator-validation-fail");
+ rendered();
+ self.table.options.validationFailed(cell.getComponent(), value, valid);
+ }
+ };
+
+ //handle aborted edit
+ function cancel(){
+ self.clearEditor(cell);
+ cell.setValueActual(cell.getValue());
+ self.table.options.cellEditCancelled(cell.getComponent())
+ };
+
+ element.attr("tabindex", 0);
+
+ element.on("click", function(e){
+ if(!$(this).hasClass("tabulator-editing")){
+ $(this).focus();
+ }
+ });
+
+ element.on("mousedown", function(e){
+ mouseClick = true;
+ });
+
+ element.on("focus", function(e){
+ var allowEdit = true,
+ cellEditor;
+
+ self.currentCell = cell;
+
+ if(mouseClick){
+ mouseClick = false;
+
+ if(cell.column.cellEvents.cellClick){
+ cell.column.cellEvents.cellClick(e, cell.getComponent());
+ }
+ }
+
+ function onRendered(callback){
+ rendered = callback;
+ }
+
+ if(!cell.column.extensions.edit.blocked){
+ e.stopPropagation();
+
+ if(typeof cell.column.extensions.edit.check == "function"){
+ allowEdit = cell.column.extensions.edit.check(cell.getComponent());
+ }
+
+ if(allowEdit){
+
+ self.table.options.cellEditing(cell.getComponent());
+
+ cellEditor = cell.column.extensions.edit.editor.call(self, cell.getComponent(), onRendered, success, cancel, cell.column.extensions.edit.params);
+
+ //if editor returned, add to DOM, if false, abort edit
+ if(cellEditor !== false){
+ element.addClass("tabulator-editing");
+ cell.row.getElement().addClass("tabulator-row-editing");
+ element.empty();
+ element.append(cellEditor);
+
+ //trigger onRendered Callback
+ rendered();
+
+ //prevent editing from triggering rowClick event
+ element.children().click(function(e){
+ e.stopPropagation();
+ })
+ }else{
+ element.blur();
+ }
+ }else{
+ element.blur();
+ }
+ }else{
+ element.blur();
+ }
+
+ });
+};
+
+//default data editors
+Edit.prototype.editors = {
+
+ //input element
+ input:function(cell, onRendered, success, cancel, editorParams){
+
+ //create and style input
+ var input = $("");
+
+ input.css({
+ "padding":"4px",
+ "width":"100%",
+ "box-sizing":"border-box",
+ })
+ .val(cell.getValue());
+
+ onRendered(function(){
+ input.focus();
+ input.css("height","100%");
+ });
+
+ //submit new value on blur
+ input.on("change blur", function(e){
+ if(input.val() != cell.getValue()){
+ success(input.val());
+ }else{
+ cancel();
+ }
+ });
+
+ //submit new value on enter
+ input.on("keydown", function(e){
+ if(e.keyCode == 13){
+ success(input.val());
+ }
+
+ if(e.keyCode == 27){
+ cancel();
+ }
+ });
+
+ return input;
+ },
+
+ //resizable text area element
+ textarea:function(cell, onRendered, success, cancel, editorParams){
+ var self = this,
+ cellValue = cell.getValue(),
+ value = String(typeof cellValue == "null" || typeof cellValue == "undefined" ? "" : cellValue),
+ count = (value.match(/(?:\r\n|\r|\n)/g) || []).length + 1,
+ input = $(""),
+ scrollHeight = 0;
+
+ //create and style input
+ input.css({
+ "display":"block",
+ "height":"100%",
+ "width":"100%",
+ "padding":"2px",
+ "box-sizing":"border-box",
+ "white-space":"pre-wrap",
+ "resize": "none",
+ })
+ .val(value);
+
+ onRendered(function(){
+ input.focus();
+ input.css("height","100%");
+ });
+
+ //submit new value on blur
+ input.on("change blur", function(e){
+ if(input.val() != cell.getValue()){
+ success(input.val());
+ setTimeout(function(){
+ cell.getRow().normalizeHeight();
+ },300)
+ }else{
+ cancel();
+ }
+ });
+
+ input.on("keyup", function(){
+
+ input.css({"height": ""});
+
+ var heightNow = input[0].scrollHeight;
+ input.css({"height": heightNow});
+
+ if(heightNow != scrollHeight){
+ scrollHeight = heightNow;
+ cell.getRow().normalizeHeight();
+ }
+ });
+
+ input.on("keydown", function(e){
+ if(e.keyCode == 27){
+ cancel();
+ }
+ });
+
+ return input;
+ },
+
+ //input element with type of number
+ number:function(cell, onRendered, success, cancel, editorParams){
+ var input = $("");
+
+ //create and style input
+ input.css({
+ "padding":"4px",
+ "width":"100%",
+ "box-sizing":"border-box",
+ })
+ .val(cell.getValue());
+
+ onRendered(function(){
+ input.focus();
+ input.css("height","100%");
+ });
+
+ //submit new value on blur
+ input.on("blur", function(e){
+ var value = input.val();
+
+ if(!isNaN(value)){
+ value = Number(value);
+ }
+
+ if(value != cell.getValue()){
+ success(value);
+ }else{
+ cancel();
+ }
+ });
+
+ //submit new value on enter
+ input.on("keydown", function(e){
+ var value;
+
+ if(e.keyCode == 13){
+ value = input.val();
+
+ if(!isNaN(value)){
+ value = Number(value);
+ }
+
+ success(value);
+ }
+
+ if(e.keyCode == 27){
+ cancel();
+ }
+ });
+
+ return input;
+ },
+
+ //start rating
+ star:function(cell, onRendered, success, cancel, editorParams){
+ var element = cell.getElement(),
+ value = cell.getValue(),
+ maxStars = $("svg", element).length || 5,
+ size = $("svg:first", element).attr("width") || 14,
+ stars=$(""),
+ starActive = $(''),
+ starInactive = $('');
+
+
+ //change number of active stars
+ var starChange = function(element){
+ if($(".tabulator-star-active", element.closest("div")).length != element.prevAll("svg").length + 1){
+ element.prevAll("svg").replaceWith(starActive.clone());
+ element.nextAll("svg").replaceWith(starInactive.clone());
+ element.replaceWith(starActive.clone());
+ }
+ }
+
+ value = parseInt(value) < maxStars ? parseInt(value) : maxStars;
+
+ for(var i=1;i<= maxStars;i++){
+ let nextStar = i <= value ? starActive : starInactive;
+ stars.append(nextStar.clone());
+ }
+
+ stars.on("mouseover", "svg", function(e){
+ e.stopPropagation();
+ starChange($(this));
+ });
+
+ stars.on("mouseover", function(e){
+ $("svg", $(this)).replaceWith(starInactive.clone());
+ });
+
+ stars.on("click", function(e){
+ success(0);
+ });
+
+ stars.on("click", "svg", function(e){
+ e.stopPropagation();
+ success($(this).prevAll("svg").length + 1);
+ });
+
+ element.css({
+ "white-space": "nowrap",
+ "overflow": "hidden",
+ "text-overflow": "ellipsis",
+ });
+
+ element.on("blur", function(){
+ cancel();
+ });
+
+ //allow key based navigation
+ element.on("keydown", function(e){
+ switch(e.keyCode){
+ case 39: //right arrow
+ starChange($(".tabulator-star-inactive:first", stars));
+ break;
+
+ case 37: //left arrow
+ let prevstar = $(".tabulator-star-active:last", stars).prev("svg");
+
+ if(prevstar.length){
+ starChange(prevstar);
+ }else{
+ $("svg", stars).replaceWith(starInactive.clone());
+ }
+ break;
+
+ case 13: //enter
+ success($(".tabulator-star-active", stars).length);
+ break;
+
+ case 27: //escape
+ cancel();
+ break;
+
+ }
+ });
+
+ return stars;
+ },
+
+ //draggable progress bar
+ progress:function(cell, onRendered, success, cancel, editorParams){
+ var element = cell.getElement(),
+ max = $("div", element).data("max"),
+ min = $("div", element).data("min"),
+ percent = (max - min) / 100,
+ value = cell.getValue() || 0,
+ handle = $(""),
+ bar;
+
+ var newVal = function(){
+ var calcVal = (percent * Math.round(bar.outerWidth() / (element.width()/100))) + min;
+ success(calcVal);
+ element.attr("aria-valuenow", calcVal).attr("aria-label", value);
+ }
+
+ //make sure value is in range
+ value = parseFloat(value) <= max ? parseFloat(value) : max;
+ value = parseFloat(value) >= min ? parseFloat(value) : min;
+
+ //workout percentage
+ value = 100 - Math.round((value - min) / percent);
+
+ bar = $(""),
+
+ element.css({
+ padding:"0 4px",
+ });
+
+ element.attr("aria-valuemin", min).attr("aria-valuemax", max);
+
+ bar.append(handle);
+
+ handle.on("mousedown", function(e){
+ bar.data("mouseDrag", e.screenX);
+ bar.data("mouseDragWidth", bar.outerWidth());
+ });
+
+ handle.on("mouseover", function(){$(this).css({cursor:"ew-resize"})});
+
+ element.on("mousemove", function(e){
+ if(bar.data("mouseDrag")){
+ bar.css({width: bar.data("mouseDragWidth") + (e.screenX - bar.data("mouseDrag"))})
+ }
+ });
+
+ element.on("mouseup", function(e){
+ if(bar.data("mouseDrag")){
+ e.stopPropagation();
+ e.stopImmediatePropagation();
+
+ bar.data("mouseDragOut", true);
+ bar.data("mouseDrag", false);
+ bar.data("mouseDragWidth", false);
+
+ newVal();
+
+ }
+ });
+
+ //allow key based navigation
+ element.on("keydown", function(e){
+ switch(e.keyCode){
+ case 39: //right arrow
+ bar.css({"width" : bar.width() + element.width()/100});
+ break;
+
+ case 37: //left arrow
+ bar.css({"width" : bar.width() - element.width()/100});
+ break;
+
+ case 13: //enter
+ newVal();
+ break;
+
+ case 27: //escape
+ cancel();
+ break;
+
+ }
+ });
+
+ element.on("blur", function(){
+ cancel();
+ });
+
+ return bar;
+ },
+
+ //checkbox
+ tickCross:function(cell, onRendered, success, cancel, editorParams){
+ var value = cell.getValue(),
+ input = $("");
+
+ //create and style input
+ input.css({
+ "margin-top":"5px",
+ "box-sizing":"border-box",
+ })
+ .val(value);
+
+ onRendered(function(){
+ input.focus();
+ });
+
+ if(value === true || value === "true" || value === "True" || value === 1){
+ input.prop("checked", true);
+ }else{
+ input.prop("checked", false);
+ }
+
+ //submit new value on blur
+ input.on("change blur", function(e){
+ success(input.is(":checked"));
+ });
+
+ //submit new value on enter
+ input.on("keydown", function(e){
+ if(e.keyCode == 13){
+ success(input.is(":checked"));
+ }
+ if(e.keyCode == 27){
+ cancel();
+ }
+ });
+
+ return input;
+ },
+
+ //checkbox
+ tick:function(cell, onRendered, success, cancel, editorParams){
+ var value = cell.getValue(),
+ input = $("");
+
+ //create and style input
+ input.css({
+ "margin-top":"5px",
+ "box-sizing":"border-box",
+ })
+ .val(value);
+
+ onRendered(function(){
+ input.focus();
+ });
+
+ if(value === true || value === "true" || value === "True" || value === 1){
+ input.prop("checked", true);
+ }else{
+ input.prop("checked", false);
+ }
+
+ //submit new value on blur
+ input.on("change blur", function(e){
+ success(input.is(":checked"));
+ });
+
+ //submit new value on enter
+ input.on("keydown", function(e){
+ if(e.keyCode == 13){
+ success(input.is(":checked"));
+ }
+ if(e.keyCode == 27){
+ cancel();
+ }
+ });
+
+ return input;
+ },
+};
+
+Tabulator.registerExtension("edit", Edit);
\ No newline at end of file
diff --git a/js/tabulator/src/js/extensions/filter.js b/js/tabulator/src/js/extensions/filter.js
new file mode 100644
index 0000000..bd4a353
--- /dev/null
+++ b/js/tabulator/src/js/extensions/filter.js
@@ -0,0 +1,453 @@
+var Filter = function(table){
+
+ this.table = table; //hold Tabulator object
+
+ this.filterList = []; //hold filter list
+ this.headerFilters = {}; //hold column filters
+ this.headerFilterElements = []; //hold header filter elements for manipulation
+
+ this.changed = false; //has filtering changed since last render
+};
+
+
+//initialize column header filter
+Filter.prototype.initializeColumn = function(column){
+ var self = this,
+ field = column.getField(),
+ filterElement, editor, editorElement, cellWrapper, typingTimer, tagType, attrType;
+
+ //handle successfull value change
+ function success(value){
+ var filterType = tagType == "input" && attrType == "text" ? "partial" : "match",
+ type = "",
+ filterFunc;
+
+ if(value){
+ switch(typeof column.definition.headerFilterFunc){
+ case "string":
+ if(self.filters[column.definition.headerFilterFunc]){
+ type = column.definition.headerFilterFunc;
+ filterFunc = function(data){
+ return self.filters[column.definition.headerFilterFunc](value, column.getFieldValue(data));
+ }
+ }else{
+ console.warn("Header Filter Error - Matching filter function not found: ", column.definition.headerFilterFunc);
+ }
+ break;
+
+ case "function":
+ filterFunc = function(data){
+ return column.definition.headerFilterFunc(value, column.getFieldValue(data), data, column.definition.headerFilterFuncParams || {});
+ }
+
+ type = filterFunc;
+ break;
+ }
+
+ if(!filterFunc){
+
+ switch(filterType){
+ case "partial":
+ filterFunc = function(data){
+ return String(column.getFieldValue(data)).toLowerCase().indexOf(String(value).toLowerCase()) > -1;
+ }
+ type = "like";
+ break;
+
+ default:
+ filterFunc = function(data){
+ return column.getFieldValue(data) == value;
+ }
+ type = "=";
+ }
+ }
+
+ self.headerFilters[field] = {value:value, func:filterFunc, type:type};
+
+ }else{
+ delete self.headerFilters[field];
+ }
+
+ self.changed = true;
+
+ self.table.rowManager.filterRefresh();
+ };
+
+ //handle aborted edit
+ function cancel(){};
+
+ if(field){
+
+ filterElement = $("");
+
+ //set column editor
+ switch(typeof column.definition.headerFilter){
+ case "string":
+ if(self.table.extensions.edit.editors[column.definition.headerFilter]){
+ editor = self.table.extensions.edit.editors[column.definition.headerFilter];
+ }else{
+ console.warn("Filter Error - Cannot build header filter, No such editor found: ", column.definition.editor);
+ }
+ break;
+
+ case "function":
+ editor = column.definition.headerFilter;
+ break;
+
+ case "boolean":
+ if(column.extensions.edit && column.extensions.edit.editor){
+ editor = column.extensions.edit.editor;
+ }else{
+ if(column.definition.formatter && self.table.extensions.edit.editors[column.definition.formatter]){
+ editor = self.table.extensions.edit.editors[column.definition.formatter];
+ }else{
+ editor = self.table.extensions.edit.editors["input"];
+ }
+ }
+ break;
+ }
+
+ if(editor){
+
+ cellWrapper = {
+ getValue:function(){
+ return "";
+ },
+ getField:function(){
+ return column.definition.field;
+ },
+ getElement:function(){
+ return filterElement;
+ }
+ };
+
+ editorElement = editor.call(self, cellWrapper, function(){}, success, cancel, column.definition.headerFilterParams || {});
+
+ //set Placeholder Text
+ if(field){
+ self.table.extensions.localize.bind("headerFilters.columns." + column.definition.field, function(value){
+ editorElement.attr("placeholder", typeof value !== "undefined" && value ? value : self.table.extensions.localize.getText("headerFilters.default"));
+ });
+ }else{
+ self.table.extensions.localize.bind("headerFilters.default", function(value){
+ editorElement.attr("placeholdder", typeof self.column.definition.headerFilterPlaceholder !== "undefined" && self.column.definition.headerFilterPlaceholder ? self.column.definition.headerFilterPlaceholder : value);
+ });
+ }
+
+ //focus on element on click
+ editorElement.on("click", function(e){
+ e.stopPropagation();
+ $(this).focus();
+ });
+
+ //live update filters as user types
+ typingTimer = false;
+
+ editorElement.on("keyup search", function(e){
+ var element = $(this);
+
+ if(typingTimer){
+ clearTimeout(typingTimer);
+ }
+
+ typingTimer = setTimeout(function(){
+ success(element.val());
+ },300);
+ });
+
+ //update number filtered columns on change
+ attrType = editorElement.attr("type") ? editorElement.attr("type").toLowerCase() : "" ;
+ if(attrType == "number"){
+ editorElement.on("change", function(e){
+ success($(this).val());
+ });
+ }
+
+ //change text inputs to search inputs to allow for clearing of field
+ if(attrType == "text"){
+ editorElement.attr("type", "search");
+ editorElement.off("change blur"); //prevent blur from triggering filter and preventing selection click
+ }
+
+ //prevent input and select elements from propegating click to column sorters etc
+ tagType = editorElement.prop("tagName").toLowerCase()
+ if(tagType == "input" || tagType == "select"){
+ editorElement.on("mousedown",function(e){
+ e.stopPropagation();
+ });
+ }
+
+ filterElement.append(editorElement);
+
+ column.contentElement.append(filterElement);
+
+ self.headerFilterElements.push(editorElement);
+ }
+ }else{
+ console.warn("Filter Error - Cannot add header filter, column has no field set:", column.definition.title);
+ }
+
+};
+
+//check if the filters has changed since last use
+Filter.prototype.hasChanged = function(){
+ var changed = this.changed;
+ this.changed = false;
+ return changed;
+};
+
+//set standard filters
+Filter.prototype.setFilter = function(field, type, value){
+ var self = this;
+
+ self.filterList = [];
+
+ if(!Array.isArray(field)){
+ field = [{field:field, type:type, value:value}];
+ }
+
+ self.addFilter(field);
+
+};
+
+//add filter to array
+Filter.prototype.addFilter = function(field, type, value){
+ var self = this,
+ column;
+
+ if(!Array.isArray(field)){
+ field = [{field:field, type:type, value:value}];
+ }
+
+ field.forEach(function(filter){
+
+ var filterFunc = false;
+
+ if(typeof filter.field == "function"){
+ filterFunc = function(data){
+ return filter.field(data, filter.type || {})// pass params to custom filter function
+ }
+ }else{
+ if(self.filters[filter.type]){
+
+ column = self.table.columnManager.getColumnByField(filter.field);
+
+ if(column){
+ filterFunc = function(data){
+ return self.filters[filter.type](filter.value, column.getFieldValue(data));
+ }
+ }else{
+ filterFunc = function(data){
+ return self.filters[filter.type](filter.value, data[filter.field]);
+ }
+ }
+
+
+ }else{
+ console.warn("Filter Error - No such filter type found, ignoring: ", filter.type);
+ }
+ }
+
+ if(filterFunc){
+ filter.func = filterFunc;
+ self.filterList.push(filter);
+
+ self.changed = true;
+ }
+ });
+
+};
+
+//get all filters
+Filter.prototype.getFilters = function(all, ajax){
+ var self = this,
+ output = [];
+
+ if(all){
+ output = self.getHeaderFilters();
+ }
+
+ self.filterList.forEach(function(filter){
+ output.push({field:filter.field, type:filter.type, value:filter.value});
+ });
+
+ if(ajax){
+ output.forEach(function(item){
+ if(typeof item.type == "function"){
+ item.type = "function";
+ }
+ })
+ }
+
+ return output;
+};
+
+//get all filters
+Filter.prototype.getHeaderFilters = function(){
+ var self = this,
+ output = [];
+
+ for(var key in this.headerFilters){
+ output.push({field:key, type:this.headerFilters[key].type, value:this.headerFilters[key].value});
+ }
+
+ return output;
+};
+
+//remove filter from array
+Filter.prototype.removeFilter = function(field, type, value){
+ var self = this;
+
+ if(!Array.isArray(field)){
+ field = [{field:field, type:type, value:value}];
+ }
+
+ field.forEach(function(filter){
+ var index = -1;
+
+ if(typeof filter.field == "object"){
+ index = self.filterList.findIndex(function(element){
+ return filter === element;
+ });
+ }else{
+ index = self.filterList.findIndex(function(element){
+ return filter.field === element.field && filter.type === element.type && filter.value === element.value
+ });
+ }
+
+ if(index > -1){
+ self.filterList.splice(index, 1);
+ self.changed = true;
+ }else{
+ console.warn("Filter Error - No matching filter type found, ignoring: ", filter.type);
+ }
+
+ });
+
+};
+
+//clear filters
+Filter.prototype.clearFilter = function(all){
+ this.filterList = [];
+
+ if(all){
+ this.clearHeaderFilter();
+ }
+
+ this.changed = true;
+};
+
+//clear header filters
+Filter.prototype.clearHeaderFilter = function(){
+ this.headerFilters = {};
+
+ this.headerFilterElements.forEach(function(element){
+ element.val("");
+ });
+
+ self.changed = true;
+};
+
+//filter row array
+Filter.prototype.filter = function(rowList){
+ var self = this,
+ activeRows = [],
+ activeRowComponents = [];
+
+ if(self.table.options.dataFiltering){
+ self.table.options.dataFiltering(self.getFilters());
+ }
+
+ if(!self.table.options.ajaxFiltering && (self.filterList.length || Object.keys(self.headerFilters).length)){
+
+ rowList.forEach(function(row){
+ if(self.filterRow(row)){
+ activeRows.push(row);
+ }
+ });
+
+ activeRows;
+
+ }else{
+ activeRows = rowList.slice(0);
+ }
+
+ if(self.table.options.dataFiltered){
+
+ activeRows.forEach(function(row){
+ activeRowComponents.push(row.getComponent());
+ });
+
+ self.table.options.dataFiltered(self.getFilters(), activeRowComponents);
+ }
+
+ return activeRows;
+
+};
+
+//filter individual row
+Filter.prototype.filterRow = function(row){
+ var self = this,
+ match = true,
+ data = row.getData();
+
+ self.filterList.forEach(function(filter){
+ if(!filter.func(data)){
+ match = false;
+ }
+ });
+
+ for(var field in self.headerFilters){
+ if(!self.headerFilters[field].func(data)){
+ match = false;
+ }
+ }
+
+ return match;
+};
+
+
+//list of available filters
+Filter.prototype.filters ={
+
+ //equal to
+ "=":function(filterVal, rowVal){
+ return rowVal == filterVal ? true : false;
+ },
+
+ //less than
+ "<":function(filterVal, rowVal){
+ return rowVal < filterVal ? true : false;
+ },
+
+ //less than or equal to
+ "<=":function(filterVal, rowVal){
+ return rowVal <= filterVal ? true : false;
+ },
+
+ //greater than
+ ">":function(filterVal, rowVal){
+ return rowVal > filterVal ? true : false;
+ },
+
+ //greater than or equal to
+ ">=":function(filterVal, rowVal){
+ return rowVal >= filterVal ? true : false;
+ },
+
+ //not equal to
+ "!=":function(filterVal, rowVal){
+ return rowVal != filterVal ? true : false;
+ },
+
+ //contains the string
+ "like":function(filterVal, rowVal){
+ if(filterVal === null || typeof filterVal === "undefined"){
+ return rowVal === filterVal ? true : false;
+ }else{
+ return rowVal.toLowerCase().indexOf(filterVal.toLowerCase()) > -1 ? true : false;
+ }
+ },
+};
+
+Tabulator.registerExtension("filter", Filter);
\ No newline at end of file
diff --git a/js/tabulator/src/js/extensions/format.js b/js/tabulator/src/js/extensions/format.js
new file mode 100644
index 0000000..4bbe2c8
--- /dev/null
+++ b/js/tabulator/src/js/extensions/format.js
@@ -0,0 +1,273 @@
+var Format = function(table){
+ this.table = table; //hold Tabulator object
+};
+
+//initialize column formatter
+Format.prototype.initializeColumn = function(column){
+ var self = this,
+ config = {params:column.definition.formatterParams || {}};
+
+ //set column formatter
+ switch(typeof column.definition.formatter){
+ case "string":
+ if(self.formatters[column.definition.formatter]){
+ config.formatter = self.formatters[column.definition.formatter]
+ }else{
+ console.warn("Formatter Error - No such formatter found: ", column.definition.formatter);
+ config.formatter = self.formatters.plaintext;
+ }
+ break;
+
+ case "function":
+ config.formatter = column.definition.formatter;
+ break;
+
+ default:
+ config.formatter = self.formatters.plaintext;
+ break;
+ }
+
+ column.extensions.format = config;
+};
+
+//return a formatted value for a cell
+Format.prototype.formatValue = function(cell){
+ return cell.column.extensions.format.formatter.call(this, cell.getComponent(), cell.column.extensions.format.params);
+};
+
+
+Format.prototype.sanitizeHTML = function(value){
+ if(value){
+ var entityMap = {
+ '&': '&',
+ '<': '<',
+ '>': '>',
+ '"': '"',
+ "'": ''',
+ '/': '/',
+ '`': '`',
+ '=': '='
+ };
+
+ return String(value).replace(/[&<>"'`=\/]/g, function (s) {
+ return entityMap[s];
+ });
+ }else{
+ return value;
+ }
+};
+
+Format.prototype.emptyToSpace = function(value){
+ return value === null ? " " : value;
+};
+
+//get formatter for cell
+Format.prototype.getFormatter = function(formatter){
+ var formatter;
+
+ switch(typeof formatter){
+ case "string":
+ if(this.formatters[formatter]){
+ formatter = this.formatters[formatter]
+ }else{
+ console.warn("Formatter Error - No such formatter found: ", formatter);
+ formatter = this.formatters.plaintext;
+ }
+ break;
+
+ case "function":
+ formatter = formatter;
+ break;
+
+ default:
+ formatter = this.formatters.plaintext;
+ break;
+ }
+
+ return formatter;
+
+};
+
+//default data formatters
+Format.prototype.formatters = {
+ //plain text value
+ plaintext:function(cell, formatterParams){
+ return this.emptyToSpace(this.sanitizeHTML(cell.getValue()));
+ },
+
+ //html text value
+ html:function(cell, formatterParams){
+ return cell.getValue();
+ },
+
+ //multiline text area
+ textarea:function(cell, formatterParams){
+ cell.getElement().css({"white-space":"pre-wrap"});
+ return this.emptyToSpace(this.sanitizeHTML(cell.getValue()));
+ },
+
+ //currency formatting
+ money:function(cell, formatterParams){
+ var floatVal = parseFloat(cell.getValue()),
+ number, integer, decimal, rgx;
+
+ var decimalSym = formatterParams.decimal || ".";
+ var thousandSym = formatterParams.thousand || ",";
+ var symbol = formatterParams.symbol || "";
+ var after = !!formatterParams.symbolAfter;
+ var precision = typeof formatterParams.precision !== "undefined" ? formatterParams.precision : 2;
+
+ if(isNaN(floatVal)){
+ return this.emptyToSpace(this.sanitizeHTML(cell.getValue()));
+ }
+
+ number = precision !== false ? floatVal.toFixed(precision) : floatVal;
+ number = number.split(".");
+
+ integer = number[0];
+ decimal = number.length > 1 ? decimalSym + number[1] : "";
+
+ rgx = /(\d+)(\d{3})/;
+
+ while (rgx.test(integer)){
+ integer = integer.replace(rgx, "$1" + thousandSym + "$2");
+ }
+
+ return after ? integer + decimal + symbol : symbol + integer + decimal;
+ },
+
+ //clickable mailto link
+ email:function(cell, formatterParams){
+ var value = this.sanitizeHTML(cell.getValue());
+ return "" + this.emptyToSpace(value) + "";
+ },
+
+ //clickable anchor tag
+ link:function(cell, formatterParams){
+ var value = this.sanitizeHTML(cell.getValue());
+ return "" + this.emptyToSpace(value) + "";
+ },
+
+ //image element
+ image:function(cell, formatterParams){
+ var value = this.sanitizeHTML(cell.getValue());
+ return "";
+ },
+};
+
+Tabulator.registerExtension("format", Format);
\ No newline at end of file
diff --git a/js/tabulator/src/js/extensions/frozen_columns.js b/js/tabulator/src/js/extensions/frozen_columns.js
new file mode 100644
index 0000000..04ebefc
--- /dev/null
+++ b/js/tabulator/src/js/extensions/frozen_columns.js
@@ -0,0 +1,162 @@
+var FrozenColumns = function(table){
+ this.table = table; //hold Tabulator object
+ this.leftColumns = [];
+ this.rightColumns = [];
+ this.leftMargin = 0;
+ this.rightMargin = 0;
+ this.initializationMode = "left";
+ this.active = false;
+};
+
+//reset initial state
+FrozenColumns.prototype.reset = function(){
+ this.initializationMode = "left";
+ this.leftColumns = [];
+ this.rightColumns = [];
+ this.active = false;
+};
+
+//initialize specific column
+FrozenColumns.prototype.initializeColumn = function(column){
+ var config = {margin:0, edge:false};
+
+ if(column.definition.frozen){
+
+ if(!column.parent.isGroup){
+
+
+ if(!column.isGroup){
+ config.position = this.initializationMode;
+
+ if(this.initializationMode == "left"){
+ this.leftColumns.push(column);
+ }else{
+ this.rightColumns.unshift(column);
+ }
+
+ this.active = true;
+
+ column.extensions.frozen = config;
+ }else{
+ console.warn("Frozen Column Error - Column Groups cannot be frozen");
+ }
+ }else{
+ console.warn("Frozen Column Error - Grouped columns cannot be frozen");
+ }
+
+ }else{
+ this.initializationMode = "right";
+ }
+};
+
+//layout columns appropropriatly
+FrozenColumns.prototype.layout = function(){
+ var self = this,
+ tableHolder = this.table.rowManager.element,
+ rightMargin = 0;
+
+ if(self.active){
+
+ //calculate row padding
+
+ self.leftMargin = self._calcSpace(self.leftColumns, self.leftColumns.length);
+ self.table.columnManager.headersElement.css("margin-left", self.leftMargin);
+
+ self.rightMargin = self._calcSpace(self.rightColumns, self.rightColumns.length);
+ self.table.columnManager.element.css("padding-right", self.rightMargin);
+
+ self.table.rowManager.activeRows.forEach(function(row){
+ self.layoutRow(row);
+ });
+
+ if(self.table.extExists("columnCalcs")){
+ if(self.table.extensions.columnCalcs.topInitialized && self.table.extensions.columnCalcs.topRow){
+ self.layoutRow(self.table.extensions.columnCalcs.topRow);
+ }
+ if(self.table.extensions.columnCalcs.botInitialized && self.table.extensions.columnCalcs.botRow){
+ self.layoutRow(self.table.extensions.columnCalcs.botRow);
+ }
+ }
+
+
+ //calculate left columns
+ self.leftColumns.forEach(function(column, i){
+ column.extensions.frozen.margin = self._calcSpace(self.leftColumns, i) + self.table.columnManager.scrollLeft;
+
+ if(i == self.leftColumns.length - 1){
+ column.extensions.frozen.edge = true;
+ }else{
+ column.extensions.frozen.edge = false;
+ }
+
+ self.layoutColumn(column);
+ });
+
+ //calculate right frozen columns
+ rightMargin = self.table.rowManager.element.innerWidth() + self.table.columnManager.scrollLeft;
+
+ if(tableHolder[0].scrollHeight > tableHolder.innerHeight()){
+ rightMargin -= tableHolder[0].offsetWidth - tableHolder[0].clientWidth;
+ }
+
+ self.rightColumns.forEach(function(column, i){
+ column.extensions.frozen.margin = rightMargin - self._calcSpace(self.rightColumns, i + 1);
+
+ if(i == self.rightColumns.length - 1){
+ column.extensions.frozen.edge = true;
+ }else{
+ column.extensions.frozen.edge = false;
+ }
+
+ self.layoutColumn(column);
+ });
+ }
+};
+
+FrozenColumns.prototype.layoutColumn = function(column){
+ var self = this;
+
+ self.layoutElement(column.element, column);
+
+ column.cells.forEach(function(cell){
+ self.layoutElement(cell.element, column);
+ });
+};
+
+FrozenColumns.prototype.layoutRow = function(row){
+ row.getElement().css({
+ "padding-left": this.leftMargin,
+ "padding-right": this.rightMargin,
+ });
+};
+
+FrozenColumns.prototype.layoutElement = function(element, column){
+
+ if(column.extensions.frozen){
+ var css = {
+ position:"absolute",
+ left:column.extensions.frozen.margin
+ }
+
+ element.css(css);
+ element.addClass("tabulator-frozen");
+
+ if(column.extensions.frozen.edge){
+ element.addClass("tabulator-frozen-" + column.extensions.frozen.position);
+ }
+ }
+};
+
+FrozenColumns.prototype._calcSpace = function(columns, index){
+ var width = 0;
+
+ for (let i = 0; i < index; i++){
+ if(columns[i].visible){
+ width += columns[i].getWidth();
+ }
+ }
+
+ return width;
+};
+
+Tabulator.registerExtension("frozenColumns", FrozenColumns);
\ No newline at end of file
diff --git a/js/tabulator/src/js/extensions/group_rows.js b/js/tabulator/src/js/extensions/group_rows.js
new file mode 100644
index 0000000..04eba70
--- /dev/null
+++ b/js/tabulator/src/js/extensions/group_rows.js
@@ -0,0 +1,641 @@
+
+
+//public group object
+var GroupComponent = function (group){
+ this.group = group;
+ this.type = "GroupComponent";
+}
+
+GroupComponent.prototype.getKey = function(){
+ return this.group.key;
+};
+
+GroupComponent.prototype.getElement = function(){
+ return this.group.element;
+};
+
+GroupComponent.prototype.getRows = function(){
+ var output = []
+
+ this.group.rows.forEach(function(row){
+ output.push(row.getComponent());
+ });
+
+ return output;
+};
+
+GroupComponent.prototype.getSubGroups = function(){
+ var output = [];
+
+ this.group.groupList.forEach(function(child){
+ output.push(child.getComponent());
+ });
+
+ return output;
+};
+
+GroupComponent.prototype.getParentGroup = function(){
+ return this.group.parent ? this.group.parent.getComponent() : false;
+};
+
+GroupComponent.prototype.getVisibility = function(){
+ return this.group.visible;
+};
+
+GroupComponent.prototype.show = function(){
+ this.group.show()
+};
+
+GroupComponent.prototype.hide = function(){
+ this.group.hide();
+};
+
+GroupComponent.prototype.toggle = function(){
+ this.group.toggleVisibility();
+};
+
+GroupComponent.prototype._getSelf = function(){
+ return this.group;
+};
+
+//////////////////////////////////////////////////
+//////////////// Group Functions /////////////////
+//////////////////////////////////////////////////
+
+var Group = function(groupManager, parent, level, key, generator, oldGroup){
+
+ this.groupManager = groupManager;
+ this.parent = parent;
+ this.key = key;
+ this.level = level;
+ this.hasSubGroups = level < (groupManager.groupIDLookups.length - 1);
+ this.addRow = this.hasSubGroups ? this._addRowToGroup : this._addRow;
+ this.type = "group"; //type of element
+ this.old = oldGroup;
+ this.rows = [];
+ this.groups = [];
+ this.groupList = [];
+ this.generator = generator;
+ this.element = $("");
+ this.arrowElement = $("");
+ this.height = 0;
+ this.outerHeight = 0;
+ this.initialized = false;
+ this.calcs = {};
+ this.initialized = false;
+
+ this.visible = oldGroup ? oldGroup.visible : (typeof groupManager.startOpen[level] !== "undefined" ? groupManager.startOpen[level] : groupManager.startOpen[0]);
+
+ this.addBindings();
+};
+
+Group.prototype.addBindings = function(){
+ var self = this,
+ dblTap, tapHold, tap, toggleElement;
+
+ if(self.groupManager.table.options.groupToggleElement){
+ toggleElement = self.groupManager.table.options.groupToggleElement == "arrow" ? self.arrowElement : self.element;
+
+ toggleElement.on("click", function(e){
+ e.stopPropagation();
+ e.stopImmediatePropagation();
+ self.toggleVisibility();
+ });
+ }
+
+
+ //handle group click events
+ if (self.groupManager.table.options.groupClick){
+ self.element.on("click", function(e){
+ self.groupManager.table.options.groupClick(e, self.getComponent());
+ })
+ }
+
+ if (self.groupManager.table.options.groupDblClick){
+ self.element.on("dblclick", function(e){
+ self.groupManager.table.options.groupDblClick(e, self.getComponent());
+ })
+ }
+
+ if (self.groupManager.table.options.groupContext){
+ self.element.on("contextmenu", function(e){
+ self.groupManager.table.options.groupContext(e, self.getComponent());
+ })
+ }
+
+ if (self.groupManager.table.options.groupTap){
+
+ tap = false;
+
+ self.element.on("touchstart", function(e){
+ tap = true;
+ });
+
+ self.element.on("touchend", function(e){
+ if(tap){
+ self.groupManager.table.options.groupTap(e, self.getComponent());
+ }
+
+ tap = false;
+ });
+ }
+
+ if (self.groupManager.table.options.groupDblTap){
+
+ dblTap = null;
+
+ self.element.on("touchend", function(e){
+
+ if(dblTap){
+ clearTimeout(dblTap);
+ dblTap = null;
+
+ self.groupManager.table.options.groupDblTap(e, self.getComponent());
+ }else{
+
+ dblTap = setTimeout(function(){
+ clearTimeout(dblTap);
+ dblTap = null;
+ }, 300);
+ }
+
+ });
+ }
+
+
+ if (self.groupManager.table.options.groupTapHold){
+
+ tapHold = null;
+
+ self.element.on("touchstart", function(e){
+ clearTimeout(tapHold);
+
+ tapHold = setTimeout(function(){
+ clearTimeout(tapHold);
+ tapHold = null;
+ tap = false;
+ self.groupManager.table.options.groupTapHold(e, self.getComponent());
+ }, 1000)
+
+ });
+
+ self.element.on("touchend", function(e){
+ clearTimeout(tapHold);
+ tapHold = null;
+ });
+ }
+
+};
+
+Group.prototype._addRowToGroup = function(row){
+
+ var level = this.level + 1;
+
+ if(this.hasSubGroups){
+ var groupID = this.groupManager.groupIDLookups[level](row.getData());
+
+ if(!this.groups[groupID]){
+ var group = new Group(this.groupManager, this, level, groupID, this.groupManager.headerGenerator[level] || this.groupManager.headerGenerator[0], this.old ? this.old.groups[groupID] : false);
+
+ this.groups[groupID] = group;
+ this.groupList.push(group);
+ }
+
+ this.groups[groupID].addRow(row);
+ }
+
+};
+
+Group.prototype._addRow = function(row){
+ this.rows.push(row);
+};
+
+Group.prototype.getHeadersAndRows = function(){
+ var output = [];
+
+ output.push(this);
+
+ this._visSet();
+
+ if(this.visible){
+
+ if(this.groupList.length){
+ this.groupList.forEach(function(group){
+ output = output.concat(group.getHeadersAndRows());
+ });
+
+ }else{
+ if(this.groupManager.table.extExists("columnCalcs") && this.groupManager.table.extensions.columnCalcs.hasTopCalcs()){
+ this.calcs.top = this.groupManager.table.extensions.columnCalcs.generateTopRow(this.rows);
+ output.push(this.calcs.top);
+ }
+
+ output = output.concat(this.rows);
+
+ if(this.groupManager.table.extExists("columnCalcs") && this.groupManager.table.extensions.columnCalcs.hasBottomCalcs()){
+ this.calcs.bottom = this.groupManager.table.extensions.columnCalcs.generateBottomRow(this.rows);
+ output.push(this.calcs.bottom);
+ }
+ }
+ }else{
+ if(this.groupManager.table.options.groupClosedShowCalcs){
+ if(this.groupManager.table.extExists("columnCalcs")){
+ if(this.groupManager.table.extensions.columnCalcs.hasTopCalcs()){
+ this.calcs.top = this.groupManager.table.extensions.columnCalcs.generateTopRow(this.rows)
+ output.push(this.calcs.top);
+ }
+
+ if(this.groupManager.table.extensions.columnCalcs.hasBottomCalcs()){
+ this.calcs.bottom = this.groupManager.table.extensions.columnCalcs.generateBottomRow(this.rows);
+ output.push(this.calcs.bottom);
+ }
+ }
+ }
+ }
+
+ return output;
+};
+
+Group.prototype.getRows = function(){
+ this._visSet();
+
+ return this.visible ? this.rows : [];
+};
+
+Group.prototype.getRowCount = function(){
+ var count = 0;
+
+ if(this.groupList.length){
+ this.groupList.forEach(function(group){
+ count += group.getRowCount();
+ });
+ }else{
+ count = this.rows.length;
+ }
+ return count;
+};
+
+Group.prototype.toggleVisibility = function(){
+ if(this.visible){
+ this.hide();
+ }else{
+ this.show();
+ }
+};
+
+Group.prototype.hide = function(){
+ this.visible = false;
+
+ if(this.groupManager.table.rowManager.getRenderMode() == "classic"){
+
+ this.element.removeClass("tabulator-group-visible");
+
+ this.rows.forEach(function(row){
+ row.getElement().detach();
+ });
+ }else{
+ this.groupManager.updateGroupRows(true);
+ }
+
+ this.groupManager.table.options.groupVisibilityChanged(this.getComponent(), false);
+};
+
+Group.prototype.show = function(){
+ var self = this;
+
+ self.visible = true;
+
+ if(this.groupManager.table.rowManager.getRenderMode() == "classic"){
+
+ this.element.addClass("tabulator-group-visible");
+
+ self.rows.forEach(function(row){
+ self.getElement().after(row.getElement());
+ row.initialize();
+ });
+ }else{
+ this.groupManager.updateGroupRows(true);
+ }
+
+ this.groupManager.table.options.groupVisibilityChanged(this.getComponent(), true);
+};
+
+Group.prototype._visSet = function(){
+ var data = [];
+
+ if(typeof this.visible == "function"){
+
+ this.rows.forEach(function(row){
+ data.push(row.getData());
+ });
+
+ this.visible = this.visible(this.key, this.getRowCount(), data, this.getRowCount());
+ }
+};
+
+Group.prototype.getRowGroup = function(row){
+ var match = false;
+ if(this.groupList.length){
+ this.groupList.forEach(function(group){
+ var result = group.getRowGroup(row);
+
+ if(result){
+ match = result;
+ }
+ });
+ }else{
+ if(this.rows.find(function(item){
+ return item === row;
+ })){
+ match = this;
+ }
+ }
+
+ return match;
+};
+
+////////////// Standard Row Functions //////////////
+
+Group.prototype.getElement = function(){
+ this.addBindingsd = false;
+
+ this._visSet();
+
+ var data = [];
+
+ this.rows.forEach(function(row){
+ data.push(row.getData());
+ });
+
+ if(this.visible){
+ this.element.addClass("tabulator-group-visible");
+ }else{
+ this.element.removeClass("tabulator-group-visible");
+ }
+
+ this.element.children().detach();
+
+ this.element.html(this.generator(this.key, this.getRowCount(), data, this.getComponent())).prepend(this.arrowElement);
+
+ // this.addBindings();
+
+ return this.element;
+};
+
+//normalize the height of elements in the row
+Group.prototype.normalizeHeight = function(){
+ this.setHeight(this.element.innerHeight())
+};
+
+Group.prototype.initialize = function(force){
+ if(!this.initialized || force){
+ this.normalizeHeight();
+ this.initialized = true;
+ }
+};
+
+Group.prototype.reinitialize = function(){
+ this.initialized = false;
+ this.height = 0;
+
+ if(this.element.is(":visible")){
+ this.initialize(true);
+ }
+};
+
+Group.prototype.setHeight = function(height){
+ if(this.height != height){
+ this.height = height;
+ this.outerHeight = this.element.outerHeight();
+ }
+};
+
+//return rows outer height
+Group.prototype.getHeight = function(){
+ return this.outerHeight;
+};
+
+Group.prototype.reinitializeHeight = function(){
+};
+Group.prototype.calcHeight = function(){
+};
+Group.prototype.setCellHeight = function(){
+};
+Group.prototype.clearCellHeight = function(){
+}
+
+
+//////////////// Object Generation /////////////////
+Group.prototype.getComponent = function(){
+ return new GroupComponent(this);
+};
+
+//////////////////////////////////////////////////
+////////////// Group Row Extension ///////////////
+//////////////////////////////////////////////////
+
+var GroupRows = function(table){
+
+ this.table = table; //hold Tabulator object
+
+ this.groupIDLookups = false; //enable table grouping and set field to group by
+ this.startOpen = [function(){return false;}]; //starting state of group
+ this.headerGenerator = [function(){return "";}];
+ this.groupList = []; //ordered list of groups
+ this.groups = {}; //hold row groups
+};
+
+
+//initialize group configuration
+GroupRows.prototype.initialize = function(){
+ var self = this,
+ groupBy = self.table.options.groupBy,
+ startOpen = self.table.options.groupStartOpen,
+ groupHeader = self.table.options.groupHeader;
+
+ self.headerGenerator = [function(){return "";}];
+ this.startOpen = [function(){return false;}]; //starting state of group
+
+ self.table.extensions.localize.bind("groups.item", function(langValue, lang){
+ self.headerGenerator[0] = function(value, count, data){ //header layout function
+ return value + "(" + count + " " + ((count === 1) ? langValue : lang.groups.items) + ")";
+ };
+ });
+
+ this.groupIDLookups = [];
+
+
+ if(Array.isArray(groupBy) || groupBy){
+ if(this.table.extExists("columnCalcs")){
+ this.table.extensions.columnCalcs.removeCalcs();
+ }
+ }else{
+ if(this.table.extExists("columnCalcs")){
+
+ var cols = this.table.columnManager.getRealColumns();
+
+ cols.forEach(function(col){
+ if(col.definition.topCalc){
+ self.table.extensions.columnCalcs.initializeTopRow();
+ }
+
+ if(col.definition.bottomCalc){
+ self.table.extensions.columnCalcs.initializeBottomRow();
+ }
+ })
+ }
+ }
+
+
+
+ if(!Array.isArray(groupBy)){
+ groupBy = [groupBy];
+ }
+
+ groupBy.forEach(function(group){
+ var lookupFunc, column;
+
+ if(typeof group == "function"){
+ lookupFunc = group;
+ }else{
+ column = self.table.columnManager.getColumnByField(group);
+
+ if(column){
+ lookupFunc = function(data){
+ return column.getFieldValue(data);
+ }
+ }else{
+ lookupFunc = function(data){
+ return data[group];
+ }
+ }
+ }
+
+ self.groupIDLookups.push(lookupFunc);
+ });
+
+
+
+ if(startOpen){
+
+ if(!Array.isArray(startOpen)){
+ startOpen = [startOpen];
+ }
+
+ startOpen.forEach(function(level){
+ level = typeof level == "function" ? level : function(){return true;};
+ });
+
+ self.startOpen = startOpen;
+ }
+
+ if(groupHeader){
+ self.headerGenerator = Array.isArray(groupHeader) ? groupHeader : [groupHeader];
+ }
+
+ this.initialized = true;
+
+};
+
+//return appropriate rows with group headers
+GroupRows.prototype.getRows = function(rows){
+ if(this.groupIDLookups.length){
+
+ this.table.options.dataGrouping();
+
+ this.generateGroups(rows);
+
+ if(this.table.options.dataGrouped){
+ this.table.options.dataGrouped(this.getGroups());
+ };
+
+ return this.updateGroupRows();
+
+ }else{
+ return rows.slice(0);
+ }
+
+};
+
+GroupRows.prototype.getGroups = function(){
+ var groupComponents = [];
+
+ if(this.table.options.dataGrouped){
+ this.groupList.forEach(function(group){
+ groupComponents.push(group.getComponent());
+ });
+ }
+
+ return groupComponents;
+};
+
+GroupRows.prototype.getRowGroup = function(row){
+ var match = false;
+
+ this.groupList.forEach(function(group){
+ var result = group.getRowGroup(row);
+
+ if(result){
+ match = result;
+ }
+ });
+
+ return match;
+};
+
+GroupRows.prototype.countGroups = function(){
+ return this.groupList.length;
+};
+
+GroupRows.prototype.generateGroups = function(rows){
+ var self = this,
+ oldGroups = self.groups;
+
+ self.groups = {};
+ self.groupList =[];
+
+ rows.forEach(function(row){
+
+ var groupID = self.groupIDLookups[0](row.getData());
+
+ if(!self.groups[groupID]){
+ var group = new Group(self, false, 0, groupID, self.headerGenerator[0], oldGroups[groupID]);
+
+ self.groups[groupID] = group;
+ self.groupList.push(group);
+ }
+
+ self.groups[groupID].addRow(row);
+ });
+
+
+}
+
+
+GroupRows.prototype.updateGroupRows = function(force){
+ var self = this,
+ output = [],
+ oldRowCount;
+
+ self.groupList.forEach(function(group){
+ output = output.concat(group.getHeadersAndRows());
+ });
+
+ //force update of table display
+ if(force){
+ oldRowCount = self.table.rowManager.displayRowsCount;
+
+ self.table.rowManager.setDisplayRows(output);
+ self.table.rowManager._virtualRenderFill(Math.floor((self.table.rowManager.element.scrollTop() / self.table.rowManager.element[0].scrollHeight) * oldRowCount));
+ }
+
+ return output;
+};
+
+GroupRows.prototype.scrollHeaders = function(left){
+ this.groupList.forEach(function(group){
+ group.arrowElement.css("margin-left", left);
+ });
+};
+
+Tabulator.registerExtension("groupRows", GroupRows);
\ No newline at end of file
diff --git a/js/tabulator/src/js/extensions/history.js b/js/tabulator/src/js/extensions/history.js
new file mode 100644
index 0000000..a2efe45
--- /dev/null
+++ b/js/tabulator/src/js/extensions/history.js
@@ -0,0 +1,117 @@
+var History = function(table){
+ this.table = table; //hold Tabulator object
+
+ this.history = [];
+ this.index = -1;
+};
+
+
+History.prototype.clear = function(){
+ this.history = [];
+ this.index = -1;
+};
+
+History.prototype.action = function(type, component, data){
+
+ if(this.index > -1){
+ this.history = this.history.slice(0, this.index + 1);
+ }
+
+ this.history.push({
+ type:type,
+ component:component,
+ data:data,
+ });
+
+ this.index ++;
+};
+
+History.prototype.undo = function(){
+
+ if(this.index > -1){
+
+ let action = this.history[this.index];
+
+ this.undoers[action.type].call(this, action);
+
+ this.index--;
+
+ return true;
+ }else{
+ console.warn("History Undo Error - No more history to undo");
+ return false;
+ }
+
+};
+
+History.prototype.redo = function(){
+ if(this.history.length-1 > this.index){
+
+ this.index++;
+
+ let action = this.history[this.index];
+
+ this.redoers[action.type].call(this, action);
+
+ return true;
+ }else{
+ console.warn("History Redo Error - No more history to redo");
+ return false;
+ }
+};
+
+
+History.prototype.undoers = {
+ cellEdit: function(action){
+ action.component.setValueProcessData(action.data.oldValue);
+ },
+
+ rowAdd: function(action){
+ action.component.delete();
+ },
+
+ rowDelete: function(action){
+ var newRow = this.table.rowManager.addRowActual(action.data.data, action.data.pos, action.data.index);
+
+ this._rebindRow(action.component, newRow);
+ },
+};
+
+
+History.prototype.redoers = {
+ cellEdit: function(action){
+ action.component.setValueProcessData(action.data.newValue);
+ },
+
+ rowAdd: function(action){
+ var newRow = this.table.rowManager.addRowActual(action.data.data, action.data.pos, action.data.index);
+
+ this._rebindRow(action.component, newRow);
+ },
+
+ rowDelete:function(action){
+ action.component.delete();
+ },
+};
+
+//rebind rows to new element after deletion
+History.prototype._rebindRow = function(oldRow, newRow){
+ this.history.forEach(function(action){
+ if(action.component instanceof Row){
+ if(action.component === oldRow){
+ action.component = newRow;
+ }
+ }else if(action.component instanceof Cell){
+ if(action.component.row === oldRow){
+ var field = action.component.column.getField();
+
+ if(field){
+ action.component = newRow.getCell(field);
+ }
+
+ }
+ }
+ });
+};
+
+Tabulator.registerExtension("history", History);
\ No newline at end of file
diff --git a/js/tabulator/src/js/extensions/html_table_import.js b/js/tabulator/src/js/extensions/html_table_import.js
new file mode 100644
index 0000000..5c03e6a
--- /dev/null
+++ b/js/tabulator/src/js/extensions/html_table_import.js
@@ -0,0 +1,197 @@
+var HtmlTableImport = function(table){
+ this.table = table; //hold Tabulator object
+};
+
+HtmlTableImport.prototype.parseTable = function(){
+ var self = this,
+ element = self.table.element,
+ options = self.table.options,
+ columns = options.columns,
+ headers = $("th", element),
+ hasIndex = false,
+ rows = $("tbody tr", element),
+ data = [];
+
+ self.table.options.htmlImporting();
+
+ //check for tablator inline options
+ self._extractOptions(element, options);
+
+ if(headers.length){
+ self._extractHeaders(element);
+ }else{
+ self._generateBlankHeaders(element);
+ }
+
+
+ //iterate through table rows and build data set
+ rows.each(function(rowIndex){
+ var item = {};
+
+ //create index if the dont exist in table
+ if(!hasIndex){
+ item[options.index] = rowIndex;
+ }
+
+ //add row data to item
+ $("td", $(this)).each(function(colIndex){
+ item[$(this).data("field")] = $(this).html();
+ });
+
+ data.push(item);
+ });
+
+ //create new element
+ var newElement = $("");
+
+ //transfer attributes to new element
+ var attributes = element.prop("attributes");
+
+ // loop through attributes and apply them on div
+ $.each(attributes, function(){
+ newElement.attr(this.name, this.value);
+ });
+
+ // replace table with div element
+ element.replaceWith(newElement);
+
+ options.data = data;
+
+ self.table.options.htmlImported();
+
+ newElement.tabulator(options);
+};
+
+//extract tabluator attribute options
+HtmlTableImport.prototype._extractOptions = function(element, options){
+ var self = this,
+ attributes = element[0].attributes
+
+ for(var index in attributes){
+ var attrib = attributes[index];
+ var name;
+
+ if(attrib && attrib.name && attrib.name.indexOf("tabulator-") === 0){
+
+ name = attrib.name.replace("tabulator-", "");
+
+ for(var key in options){
+ if(key.toLowerCase() == name){
+ options[key] = self._attribValue(attrib.value);
+ }
+ }
+ }
+ }
+};
+
+//get value of attribute
+HtmlTableImport.prototype._attribValue = function(value){
+ if(value === "true"){
+ return true;
+ }
+
+ if(value === "false"){
+ return false;
+ }
+
+ return value;
+};
+
+//find column if it has already been defined
+HtmlTableImport.prototype._findCol = function(title){
+ var self = this;
+
+ var match = self.table.options.columns.find(function(column){
+ return column.title === title;
+ });
+
+ return match || false;
+};
+
+//extract column from headers
+HtmlTableImport.prototype._extractHeaders = function(element){
+ var self = this,
+ headers = $("th", element),
+ rows = $("tbody tr", element);
+
+ headers.each(function(index){
+ var header = $(this),
+ exists = false,
+ col = self._findCol(header.text()),
+ width, attributes;
+
+ //list of possible attributes
+ var attribList = ["title", "field", "align", "width", "minWidth", "frozen", "sortable", "sorter", "formatter", "cellClick", "cellDblClick", "cellContext", "editable", "editor", "visible", "cssClass", "tooltip", "tooltipHeader", "editableTitle", "headerFilter", "mutator", "mutateType", "accessor"];
+
+
+ if(col){
+ exists = true;
+ }else{
+ col = {title:header.text().trim()};
+ }
+
+ if(!col.field) {
+ col.field = header.text().trim().toLowerCase().replace(" ", "_");
+ }
+
+ width = header.attr("width");
+
+ if(width && !col.width) {
+ col.width = width;
+ }
+
+
+ //check for tablator inline options
+ attributes = header[0].attributes;
+
+ //check for tablator inline options
+ for(var i in attributes){
+ var attrib = attributes[i],
+ name;
+
+ if(attrib && attrib.name && attrib.name.indexOf("tabulator-") === 0){
+
+ name = attrib.name.replace("tabulator-", "");
+
+ attribList.forEach(function(key){
+ if(key.toLowerCase() == name){
+ col[key] = self._attribValue(attrib.value);
+ }
+ });
+ }
+ }
+
+ $("td:eq(" + index + ")", rows).data("field", col.field);
+
+ if(col.field == self.table.options.index){
+ hasIndex = true;
+ }
+
+ if(!exists){
+ self.table.options.columns.push(col)
+ }
+
+ });
+};
+
+//generate blank headers
+HtmlTableImport.prototype._generateBlankHeaders = function(element){
+ var self = this;
+
+ var headers = $("tr:first td", element);
+
+ headers.each(function(index){
+ var col = {title:"", field:"col" + index};
+ $("td:eq(" + index + ")", rows).data("field", col.field)
+
+ var width = $(this).attr("width");
+
+ if(width){
+ col.width = width;
+ }
+
+ self.table.options.columns.push(col);
+ });
+};
+
+Tabulator.registerExtension("htmlTableImport", HtmlTableImport);
\ No newline at end of file
diff --git a/js/tabulator/src/js/extensions/keybindings.js b/js/tabulator/src/js/extensions/keybindings.js
new file mode 100644
index 0000000..d76a2f6
--- /dev/null
+++ b/js/tabulator/src/js/extensions/keybindings.js
@@ -0,0 +1,333 @@
+var Keybindings = function(table){
+ this.table = table; //hold Tabulator object
+ this.watchKeys = null;
+ this.pressedKeys = null;
+};
+
+
+Keybindings.prototype.initialize = function(){
+ var bindings = this.table.options.keybindings,
+ mergedBindings = {};
+
+ this.watchKeys = {};
+ this.pressedKeys = [];
+
+ if(bindings !== false){
+
+ for(let key in this.bindings){
+ mergedBindings[key] = this.bindings[key];
+ }
+
+ if(Object.keys(bindings).length){
+
+ for(let key in bindings){
+ mergedBindings[key] = bindings[key];
+ }
+ }
+
+ this.mapBindings(mergedBindings);
+ this.bindEvents();
+ }
+};
+
+Keybindings.prototype.mapBindings = function(bindings){
+ var self = this;
+
+ for(let key in bindings){
+
+ if(this.actions[key]){
+
+ if(bindings[key]){
+
+ if(typeof bindings[key] !== "object"){
+ bindings[key] = [bindings[key]];
+ }
+
+ bindings[key].forEach(function(binding){
+ self.mapBinding(key, binding);
+ });
+ }
+
+ }else{
+ console.warn("Key Binding Error - no such action:", key);
+ }
+ }
+};
+
+Keybindings.prototype.mapBinding = function(action, symbolsList){
+ var self = this;
+
+ var binding = {
+ action: this.actions[action],
+ keys: [],
+ ctrl: false,
+ shift: false,
+ }
+
+ var symbols = symbolsList.toString().toLowerCase().split(" ").join("").split("+");
+
+ symbols.forEach(function(symbol){
+ switch(symbol){
+ case "ctrl":
+ binding.ctrl = true;
+ break;
+
+ case "shift":
+ binding.shift = true;
+ break;
+
+ default:
+ symbol = parseInt(symbol);
+ binding.keys.push(symbol);
+
+ if(!self.watchKeys[symbol]){
+ self.watchKeys[symbol] = [];
+ }
+
+ self.watchKeys[symbol].push(binding);
+ }
+ });
+};
+
+Keybindings.prototype.bindEvents = function(){
+ var self = this;
+
+ this.table.element.on("keydown", function(e){
+ var code = e.keyCode;
+ var bindings = self.watchKeys[code];
+
+ if(bindings){
+
+ self.pressedKeys.push(code);
+
+ bindings.forEach(function(binding){
+ self.checkBinding(e, binding);
+ });
+ }
+ });
+
+ this.table.element.on("keyup", function(e){
+ var code = e.keyCode;
+ var bindings = self.watchKeys[code];
+
+ if(bindings){
+
+ var index = self.pressedKeys.indexOf(code);
+
+ if(index > -1){
+ self.pressedKeys.splice(index, 1);
+ }
+ }
+ });
+};
+
+
+Keybindings.prototype.checkBinding = function(e, binding){
+ var self = this,
+ match = true;
+
+ if(e.ctrlKey == binding.ctrl && e.shiftKey == binding.shift){
+ binding.keys.forEach(function(key){
+ var index = self.pressedKeys.indexOf(key);
+
+ if(index == -1){
+ match = false;
+ }
+ });
+
+ if(match){
+ binding.action.call(self, e);
+ }
+
+ return true;
+ }
+
+ return false;
+};
+
+//default bindings
+Keybindings.prototype.bindings = {
+ navPrev:"shift + 9",
+ navNext:9,
+ navUp:38,
+ navDown:40,
+ scrollPageUp:33,
+ scrollPageDown:34,
+ scrollToStart:36,
+ scrollToEnd:35,
+ undo:"ctrl + 90",
+ redo:"ctrl + 89",
+};
+
+
+//default actions
+Keybindings.prototype.actions = {
+ keyBlock:function(e){
+ e.stopPropagation();
+ e.preventDefault();
+ },
+ scrollPageUp:function(e){
+ var rowManager = this.table.rowManager,
+ newPos = rowManager.scrollTop - rowManager.height,
+ scrollMax = rowManager.element[0].scrollHeight;
+
+ e.preventDefault();
+
+ if(rowManager.displayRowsCount){
+ if(newPos >= 0){
+ rowManager.element.scrollTop(newPos);
+ }else{
+ rowManager.scrollToRow(rowManager.displayRows[0]);
+ }
+ }
+
+ this.table.element.focus();
+ },
+ scrollPageDown:function(e){
+ var rowManager = this.table.rowManager,
+ newPos = rowManager.scrollTop + rowManager.height,
+ scrollMax = rowManager.element[0].scrollHeight;
+
+ e.preventDefault();
+
+ if(rowManager.displayRowsCount){
+ if(newPos <= scrollMax){
+ rowManager.element.scrollTop(newPos);
+ }else{
+ rowManager.scrollToRow(rowManager.displayRows[rowManager.displayRows.length - 1]);
+ }
+ }
+
+ this.table.element.focus();
+
+ },
+ scrollToStart:function(e){
+ var rowManager = this.table.rowManager;
+
+ e.preventDefault();
+
+ if(rowManager.displayRowsCount){
+ rowManager.scrollToRow(rowManager.displayRows[0]);
+ }
+
+ this.table.element.focus();
+ },
+ scrollToEnd:function(e){
+ var rowManager = this.table.rowManager;
+
+ e.preventDefault();
+
+ if(rowManager.displayRowsCount){
+ rowManager.scrollToRow(rowManager.displayRows[rowManager.displayRows.length - 1]);
+ }
+
+ this.table.element.focus();
+ },
+ navPrev:function(e){
+ var cell = false;
+
+ if(this.table.extExists("edit")){
+ cell = this.table.extensions.edit.currentCell;
+
+ if(cell){
+ e.preventDefault();
+ cell.nav().prev();
+ }
+ }
+ },
+
+ navNext:function(e){
+ var cell = false;
+
+ if(this.table.extExists("edit")){
+ cell = this.table.extensions.edit.currentCell;
+
+ if(cell){
+ e.preventDefault();
+ cell.nav().next();
+ }
+ }
+ },
+
+ navLeft:function(e){
+ var cell = false;
+
+ if(this.table.extExists("edit")){
+ cell = this.table.extensions.edit.currentCell;
+
+ if(cell){
+ e.preventDefault();
+ cell.nav().left();
+ }
+ }
+ },
+
+ navRight:function(e){
+ var cell = false;
+
+ if(this.table.extExists("edit")){
+ cell = this.table.extensions.edit.currentCell;
+
+ if(cell){
+ e.preventDefault();
+ cell.nav().right();
+ }
+ }
+ },
+
+ navUp:function(e){
+ var cell = false;
+
+ if(this.table.extExists("edit")){
+ cell = this.table.extensions.edit.currentCell;
+
+ if(cell){
+ e.preventDefault();
+ cell.nav().up();
+ }
+ }
+ },
+
+ navDown:function(e){
+ var cell = false;
+
+ if(this.table.extExists("edit")){
+ cell = this.table.extensions.edit.currentCell;
+
+ if(cell){
+ e.preventDefault();
+ cell.nav().down();
+ }
+ }
+ },
+
+ undo:function(e){
+ var cell = false;
+ if(this.table.options.history && this.table.extExists("history") && this.table.extExists("edit")){
+
+ cell = this.table.extensions.edit.currentCell;
+
+ if(!cell){
+ e.preventDefault();
+ this.table.extensions.history.undo();
+ }
+ }
+ },
+
+ redo:function(e){
+ var cell = false;
+ if(this.table.options.history && this.table.extExists("history") && this.table.extExists("edit")){
+
+ cell = this.table.extensions.edit.currentCell;
+
+ if(!cell){
+ e.preventDefault();
+ this.table.extensions.history.redo();
+ }
+ }
+ },
+
+};
+
+
+Tabulator.registerExtension("keybindings", Keybindings);
\ No newline at end of file
diff --git a/js/tabulator/src/js/extensions/layout.js b/js/tabulator/src/js/extensions/layout.js
new file mode 100644
index 0000000..353ddff
--- /dev/null
+++ b/js/tabulator/src/js/extensions/layout.js
@@ -0,0 +1,160 @@
+var Layout = function(table){
+ this.table = table;
+ this.mode = null;
+};
+
+//initialize layout system
+Layout.prototype.initialize = function(layout){
+
+ if(this.modes[layout]){
+ this.mode = layout;
+ }else{
+ console.warn("Layout Error - invalid mode set, defaulting to 'fitData' : " + layout);
+ this.mode = 'fitData';
+ }
+
+ this.table.element.attr("tabulator-layout", this.mode);
+};
+
+Layout.prototype.getMode = function(){
+ return this.mode;
+};
+
+//trigger table layout
+Layout.prototype.layout = function(){
+ this.modes[this.mode].call(this, this.table.columnManager.columnsByIndex);
+};
+
+//layout render functions
+Layout.prototype.modes = {
+
+ //resize columns to fit data the contain
+ "fitData": function(columns){
+ columns.forEach(function(column){
+ column.reinitializeWidth();
+ });
+
+ if(this.table.options.responsiveLayout && this.table.extExists("responsiveLayout", true)){
+ this.table.extensions.responsiveLayout.update();
+ }
+ },
+
+ //resize columns to fit data the contain
+ "fitDataFill": function(columns){
+ columns.forEach(function(column){
+ column.reinitializeWidth();
+ });
+
+ if(this.table.options.responsiveLayout && this.table.extExists("responsiveLayout", true)){
+ this.table.extensions.responsiveLayout.update();
+ }
+ },
+
+ //resize columns to fit
+ "fitColumns": function(columns){
+ var self = this;
+
+ var totalWidth = self.table.element.innerWidth(); //table element width
+ var fixedWidth = 0; //total width of columns with a defined width
+ var flexWidth = 0; //total width available to flexible columns
+ var flexColWidth = 0; //desired width of flexible columns
+ var flexColumns = []; //array of flexible width columns
+ var gapFill=0; //number of pixels to be added to final column to close and half pixel gaps
+
+ //ensure columns resize to take up the correct amount of space
+ function scaleColumns(columns, freeSpace, colWidth){
+
+ var oversizeCols = [],
+ oversizeSpace = 0,
+ remainingSpace = 0,
+ nextColWidth = 0,
+ gap = 0,
+ undersizeCols = [];
+
+ columns.forEach(function(column, i){
+ if(column.minWidth >= colWidth){
+ oversizeCols.push(column);
+ }else{
+ undersizeCols.push(column);
+ }
+ });
+
+ if(oversizeCols.length){
+ oversizeCols.forEach(function(column){
+ oversizeSpace += column.minWidth;
+ column.setWidth(column.minWidth);
+ });
+
+ remainingSpace = freeSpace - oversizeSpace;
+
+ nextColWidth = undersizeCols.length ? Math.floor(remainingSpace/undersizeCols.length) : remainingSpace;
+
+ gap = remainingSpace - (nextColWidth * undersizeCols.length);
+
+ gap += scaleColumns(undersizeCols, remainingSpace, nextColWidth);
+ }else{
+ gap = undersizeCols.length ? freeSpace - (Math.floor(freeSpace/undersizeCols.length) * undersizeCols.length) : freeSpace;
+
+ undersizeCols.forEach(function(column){
+ column.setWidth(colWidth);
+ });
+ }
+
+ return gap;
+ }
+
+ if(this.table.options.responsiveLayout && this.table.extExists("responsiveLayout", true)){
+ this.table.extensions.responsiveLayout.update();
+ }
+
+ //adjust for vertical scrollbar if present
+ if(this.table.rowManager.element[0].scrollHeight > this.table.rowManager.element.innerHeight()){
+ totalWidth -= this.table.rowManager.element[0].offsetWidth - this.table.rowManager.element[0].clientWidth;
+ }
+
+ columns.forEach(function(column){
+ var width, minWidth, colWidth;
+
+ if(column.visible){
+
+ width = column.definition.width;
+ minWidth = parseInt(column.minWidth);
+
+ if(width){
+
+ if(typeof(width) == "string"){
+ if(width.indexOf("%") > -1){
+ colWidth = (totalWidth / 100) * parseInt(width);
+ }else{
+ colWidth = parseInt(width);
+ }
+ }else{
+ colWidth = width;
+ }
+
+ fixedWidth += colWidth > minWidth ? colWidth : minWidth;
+
+ }else{
+ flexColumns.push(column);
+ }
+ }
+ });
+
+ //calculate available space
+ flexWidth = totalWidth - fixedWidth;
+
+ //calculate correct column size
+ flexColWidth = Math.floor(flexWidth / flexColumns.length)
+
+ //generate column widths
+ var gapFill = scaleColumns(flexColumns, flexWidth, flexColWidth);
+
+ //increase width of last column to account for rounding errors
+ if(flexColumns.length){
+ flexColumns[flexColumns.length-1].setWidth(flexColumns[flexColumns.length-1].getWidth() + gapFill);
+ }
+ },
+};
+
+
+Tabulator.registerExtension("layout", Layout);
\ No newline at end of file
diff --git a/js/tabulator/src/js/extensions/localize.js b/js/tabulator/src/js/extensions/localize.js
new file mode 100644
index 0000000..1e9d5e5
--- /dev/null
+++ b/js/tabulator/src/js/extensions/localize.js
@@ -0,0 +1,196 @@
+var Localize = function(table){
+ this.table = table; //hold Tabulator object
+ this.locale = "default"; //current locale
+ this.lang = false; //current language
+ this.bindings = {}; //update events to call when locale is changed
+};
+
+//set header placehoder
+Localize.prototype.setHeaderFilterPlaceholder = function(placeholder){
+ this.langs.default.headerFilters.default = placeholder;
+};
+
+//set header filter placeholder by column
+Localize.prototype.setHeaderFilterColumnPlaceholder = function(column, placeholder){
+ this.langs.default.headerFilters.columns[column] = placeholder;
+
+ if(this.lang && !this.lang.headerFilters.columns[column]){
+ this.lang.headerFilters.columns[column] = placeholder;
+ }
+};
+
+//setup a lang description object
+Localize.prototype.installLang = function(locale, lang){
+ if(this.langs[locale]){
+ this._setLangProp(this.langs[locale], lang);
+ }else{
+ this.langs[locale] = lang;
+ }
+};
+
+Localize.prototype._setLangProp = function(lang, values){
+ for(let key in values){
+ if(lang[key] && typeof lang[key] == "object"){
+ this._setLangProp(lang[key], values[key])
+ }else{
+ lang[key] = values[key];
+ }
+ }
+};
+
+
+//set current locale
+Localize.prototype.setLocale = function(desiredLocale){
+ var self = this;
+
+ desiredLocale = desiredLocale || "default";
+
+ //fill in any matching languge values
+ function traverseLang(trans, path){
+ for(var prop in trans){
+
+ if(typeof trans[prop] == "object"){
+ if(!path[prop]){
+ path[prop] = {};
+ }
+ traverseLang(trans[prop], path[prop]);
+ }else{
+ path[prop] = trans[prop];
+ }
+ }
+ }
+
+ //determing correct locale to load
+ if(desiredLocale === true && navigator.language){
+ //get local from system
+ desiredLocale = navigator.language.toLowerCase();
+ }
+
+ if(desiredLocale){
+
+ //if locale is not set, check for matching top level locale else use default
+ if(!self.langs[desiredLocale]){
+ let prefix = desiredLocale.split("-")[0];
+
+ if(self.langs[prefix]){
+ console.warn("Localization Error - Exact matching locale not found, using closest match: ", desiredLocale, prefix);
+ desiredLocale = prefix;
+ }else{
+ console.warn("Localization Error - Matching locale not found, using default: ", desiredLocale);
+ desiredLocale = "default";
+ }
+ }
+ }
+
+ self.locale = desiredLocale;
+
+ //load default lang template
+ self.lang = $.extend(true, {}, self.langs.default);
+
+ if(desiredLocale != "default"){
+ traverseLang(self.langs[desiredLocale], self.lang);
+ }
+
+ self.table.options.localized(self.locale, self.lang)
+
+ self._executeBindings();
+};
+
+//get current locale
+Localize.prototype.getLocale = function(locale){
+ return self.locale;
+};
+
+//get lang object for given local or current if none provided
+Localize.prototype.getLang = function(locale){
+ return locale ? this.langs[locale] : this.lang;
+};
+
+//get text for current locale
+Localize.prototype.getText = function(path, value){
+ var path = value ? path + "." + value : path,
+ pathArray = path.split("."),
+ text = this._getLangElement(pathArray, this.locale);
+
+ // if(text === false){
+ // console.warn("Localization Error - Matching localized text not found for given path: ", path);
+ // }
+
+ return text || "";
+};
+
+//traverse langs object and find localized copy
+Localize.prototype._getLangElement = function(path, locale){
+ var self = this;
+ var root = self.lang;
+
+ path.forEach(function(level){
+ var rootPath
+
+ if(root){
+ rootPath = root[level];
+
+ if(typeof rootPath != "undefined"){
+ root = rootPath;
+ }else{
+ root = false;
+ }
+ }
+ });
+
+ return root;
+};
+
+//set update binding
+Localize.prototype.bind = function(path, callback){
+ if(!this.bindings[path]){
+ this.bindings[path] = [];
+ }
+
+ this.bindings[path].push(callback);
+
+ callback(this.getText(path), this.lang);
+};
+
+//itterate through bindings and trigger updates
+Localize.prototype._executeBindings = function(){
+ var self = this;
+
+ for(let path in self.bindings){
+ self.bindings[path].forEach(function(binding){
+ binding(self.getText(path), self.lang);
+ });
+ }
+};
+
+//Localized text listings
+Localize.prototype.langs = {
+ "default":{ //hold default locale text
+ "groups":{
+ "item":"item",
+ "items":"items",
+ },
+ "columns":{
+ },
+ "ajax":{
+ "loading":"Loading",
+ "error":"Error",
+ },
+ "pagination":{
+ "first":"First",
+ "first_title":"First Page",
+ "last":"Last",
+ "last_title":"Last Page",
+ "prev":"Prev",
+ "prev_title":"Prev Page",
+ "next":"Next",
+ "next_title":"Next Page",
+ },
+ "headerFilters":{
+ "default":"filter column...",
+ "columns":{}
+ }
+ },
+};
+
+Tabulator.registerExtension("localize", Localize);
\ No newline at end of file
diff --git a/js/tabulator/src/js/extensions/moveable_columns.js b/js/tabulator/src/js/extensions/moveable_columns.js
new file mode 100644
index 0000000..ca0c4fa
--- /dev/null
+++ b/js/tabulator/src/js/extensions/moveable_columns.js
@@ -0,0 +1,187 @@
+var MoveColumns = function(table){
+ this.table = table; //hold Tabulator object
+ this.placeholderElement = $("");
+ this.hoverElement = $(); //floating column header element
+ this.checkTimeout = false; //click check timeout holder
+ this.checkPeriod = 250; //period to wait on mousedown to consider this a move and not a click
+ this.moving = false; //currently moving column
+ this.toCol = false; //destination column
+ this.toColAfter = false; //position of moving column relative to the desitnation column
+ this.startX = 0; //starting position within header element
+ this.autoScrollMargin = 40; //auto scroll on edge when within margin
+ this.autoScrollStep = 5; //auto scroll distance in pixels
+ this.autoScrollTimeout = false; //auto scroll timeout
+
+ this.moveHover = this.moveHover.bind(this);
+ this.endMove = this.endMove.bind(this);
+};
+
+MoveColumns.prototype.initializeColumn = function(column){
+ var self = this,
+ config = {};
+
+ if(!column.extensions.frozen){
+
+ config.mousemove = function(e){
+ if(column.parent === self.moving.parent){
+ if(((e.pageX - column.element.offset().left) + self.table.columnManager.element.scrollLeft()) > (column.getWidth() / 2)){
+ if(self.toCol !== column || !self.toColAfter){
+ column.element.after(self.placeholderElement);
+ self.moveColumn(column, true);
+ }
+ }else{
+ if(self.toCol !== column || self.toColAfter){
+ column.element.before(self.placeholderElement);
+ self.moveColumn(column, false);
+ }
+ }
+ }
+ }.bind(self)
+
+ column.getElement().on("mousedown", function(e){
+ self.checkTimeout = setTimeout(function(){
+ self.startMove(e, column);
+ }, self.checkPeriod)
+ });
+
+ column.getElement().on("mouseup", function(e){
+ if(self.checkTimeout){
+ clearTimeout(self.checkTimeout);
+ }
+ });
+ }
+
+ column.extensions.moveColumn = config;
+};
+
+MoveColumns.prototype.startMove = function(e, column){
+ var self = this,
+ element = column.getElement();
+
+
+ self.moving = column;
+ self.startX = (e.pageX - element.offset().left);
+
+ self.table.element.addClass("tabulator-block-select");
+
+ //create placeholder
+ self.placeholderElement.css({
+ width:column.getWidth(),
+ height:column.getHeight(),
+ });
+ element.before(self.placeholderElement)
+ element.detach();
+
+ //create hover element
+ self.hoverElement = element.clone();
+ self.hoverElement.addClass("tabulator-moving");
+
+ self.table.columnManager.getElement().append(self.hoverElement);
+ self.hoverElement.css({
+ "left":0,
+ "bottom":0,
+ });
+
+ self._bindMouseMove();
+
+ $("body").on("mousemove", self.moveHover)
+ $("body").on("mouseup", self.endMove)
+
+ self.moveHover(e);
+};
+
+MoveColumns.prototype._bindMouseMove = function(){
+ var self = this;
+
+ self.table.columnManager.columnsByIndex.forEach(function(column){
+ if(column.extensions.moveColumn.mousemove){
+ column.element.on("mousemove", column.extensions.moveColumn.mousemove);
+ }
+ });
+};
+
+MoveColumns.prototype._unbindMouseMove = function(){
+ var self = this;
+
+ self.table.columnManager.columnsByIndex.forEach(function(column){
+ if(column.extensions.moveColumn.mousemove){
+ column.element.off("mousemove", column.extensions.moveColumn.mousemove);
+ }
+ });
+};
+
+MoveColumns.prototype.moveColumn = function(column, after){
+ var self = this,
+ movingCells = this.moving.getCells();
+
+ self.toCol = column;
+ self.toColAfter = after;
+
+ if(after){
+ column.getCells().forEach(function(cell, i){
+ cell.getElement().after(movingCells[i].getElement())
+ });
+ }else{
+ column.getCells().forEach(function(cell, i){
+ cell.getElement().before(movingCells[i].getElement())
+ });
+ }
+};
+
+MoveColumns.prototype.endMove = function(column){
+ var self = this;
+
+ self._unbindMouseMove();
+
+ self.placeholderElement.after(self.moving.getElement());
+ self.placeholderElement.detach();
+ self.hoverElement.detach();
+
+ self.table.element.removeClass("tabulator-block-select");
+
+ if(self.toCol){
+ self.table.columnManager.moveColumn(self.moving, self.toCol, self.toColAfter);
+ }
+
+ self.moving = false;
+ self.toCol = false;
+ self.toColAfter = false;
+
+ $("body").off("mousemove", self.moveHover);
+ $("body").off("mouseup", self.endMove);
+};
+
+MoveColumns.prototype.moveHover = function(e){
+ var self = this,
+ columnHolder = self.table.columnManager.getElement(),
+ scrollLeft = columnHolder.scrollLeft(),
+ xPos = (e.pageX - columnHolder.offset().left) + scrollLeft,
+ scrollPos;
+
+ self.hoverElement.css({
+ "left":xPos - self.startX,
+ });
+
+
+ if(xPos - scrollLeft < self.autoScrollMargin){
+ if(!self.autoScrollTimeout){
+ self.autoScrollTimeout = setTimeout(function(){
+ scrollPos = Math.max(0,scrollLeft-5);
+ self.table.rowManager.getElement().scrollLeft(scrollPos);
+ self.autoScrollTimeout = false;
+ }, 1);
+ }
+ }
+
+ if(scrollLeft + columnHolder.innerWidth() - xPos < self.autoScrollMargin){
+ if(!self.autoScrollTimeout){
+ self.autoScrollTimeout = setTimeout(function(){
+ scrollPos = Math.min(columnHolder.innerWidth(), scrollLeft+5);
+ self.table.rowManager.getElement().scrollLeft(scrollPos);
+ self.autoScrollTimeout = false;
+ }, 1);
+ }
+ }
+};
+
+Tabulator.registerExtension("moveColumn", MoveColumns);
\ No newline at end of file
diff --git a/js/tabulator/src/js/extensions/moveable_rows.js b/js/tabulator/src/js/extensions/moveable_rows.js
new file mode 100644
index 0000000..ed06c4f
--- /dev/null
+++ b/js/tabulator/src/js/extensions/moveable_rows.js
@@ -0,0 +1,172 @@
+var MoveRows = function(table){
+
+ this.table = table; //hold Tabulator object
+ this.placeholderElement = $("");
+ this.hoverElement = $(); //floating row header element
+ this.checkTimeout = false; //click check timeout holder
+ this.checkPeriod = 150; //period to wait on mousedown to consider this a move and not a click
+ this.moving = false; //currently moving row
+ this.toRow = false; //destination row
+ this.toRowAfter = false; //position of moving row relative to the desitnation row
+ this.hasHandle = false; //row has handle instead of fully movable row
+ this.startY = 0; //starting position within header element
+
+ this.moveHover = this.moveHover.bind(this);
+ this.endMove = this.endMove.bind(this);
+};
+
+MoveRows.prototype.setHandle = function(handle){
+ this.hasHandle = handle;
+};
+
+MoveRows.prototype.initializeRow = function(row){
+ var self = this,
+ config = {};
+
+ config.mousemove = function(e){
+ if(((e.pageY - row.element.offset().top) + self.table.rowManager.element.scrollTop()) > (row.getHeight() / 2)){
+ if(self.toRow !== row || !self.toRowAfter){
+ row.element.after(self.placeholderElement);
+ self.moveRow(row, true);
+ }
+ }else{
+ if(self.toRow !== row || self.toRowAfter){
+ row.element.before(self.placeholderElement);
+ self.moveRow(row, false);
+ }
+ }
+ }.bind(self);
+
+ if(!this.hasHandle){
+
+ row.getElement().on("mousedown", function(e){
+ self.checkTimeout = setTimeout(function(){
+ self.startMove(e, row);
+ }, self.checkPeriod);
+ });
+
+ row.getElement().on("mouseup", function(e){
+ if(self.checkTimeout){
+ clearTimeout(self.checkTimeout);
+ }
+ });
+ }
+
+ row.extensions.moveRow = config;
+};
+
+MoveRows.prototype.initializeCell = function(cell){
+ var self = this;
+
+ cell.getElement().on("mousedown", function(e){
+ self.checkTimeout = setTimeout(function(){
+ self.startMove(e, cell.row);
+ }, self.checkPeriod);
+ });
+
+ cell.getElement().on("mouseup", function(e){
+ if(self.checkTimeout){
+ clearTimeout(self.checkTimeout);
+ }
+ });
+};
+
+MoveRows.prototype._bindMouseMove = function(){
+ var self = this;
+
+ self.table.rowManager.displayRows.forEach(function(row){
+ if(row.type === "row" && row.extensions.moveRow.mousemove){
+ row.element.on("mousemove", row.extensions.moveRow.mousemove);
+ }
+ });
+};
+
+MoveRows.prototype._unbindMouseMove = function(){
+ var self = this;
+
+ self.table.rowManager.displayRows.forEach(function(row){
+ if(row.type === "row" && row.extensions.moveRow.mousemove){
+ row.element.off("mousemove", row.extensions.moveRow.mousemove);
+ }
+ });
+};
+
+MoveRows.prototype.startMove = function(e, row){
+ var self = this,
+ element = row.getElement();
+
+ self.moving = row;
+ self.startY = (e.pageY - element.offset().top);
+
+ self.table.element.addClass("tabulator-block-select");
+
+ //create placeholder
+ self.placeholderElement.css({
+ width:row.getWidth(),
+ height:row.getHeight(),
+ });
+ element.before(self.placeholderElement)
+ element.detach();
+
+ //create hover element
+ self.hoverElement = element.clone();
+ self.hoverElement.addClass("tabulator-moving");
+
+ self.table.rowManager.getTableElement().append(self.hoverElement);
+ self.hoverElement.css({
+ "left":0,
+ "top":0,
+ });
+
+
+ self._bindMouseMove();
+
+ $("body").on("mousemove", self.moveHover);
+ $("body").on("mouseup", self.endMove);
+
+ self.moveHover(e);
+};
+
+MoveRows.prototype.endMove = function(column){
+ var self = this;
+
+ self._unbindMouseMove();
+
+ self.placeholderElement.after(self.moving.getElement());
+ self.placeholderElement.detach();
+ self.hoverElement.detach();
+
+ self.table.element.removeClass("tabulator-block-select");
+
+ if(self.toRow){
+ self.table.rowManager.moveRow(self.moving, self.toRow, self.toRowAfter);
+ }
+
+ self.moving = false;
+ self.toRow = false;
+ self.toRowAfter = false;
+
+ $("body").off("mousemove", self.moveHover);
+ $("body").off("mouseup", self.endMove);
+};
+
+MoveRows.prototype.moveRow = function(row, after){
+ var self = this;
+
+ self.toRow = row;
+ self.toRowAfter = after;
+};
+
+MoveRows.prototype.moveHover = function(e){
+ var self = this,
+ rowHolder = self.table.rowManager.getElement(),
+ scrollTop = rowHolder.scrollTop(),
+ yPos = (e.pageY - rowHolder.offset().top) + scrollTop,
+ scrollPos;
+
+ self.hoverElement.css({
+ "top":yPos - self.startY,
+ });
+};
+
+Tabulator.registerExtension("moveRow", MoveRows);
\ No newline at end of file
diff --git a/js/tabulator/src/js/extensions/mutator.js b/js/tabulator/src/js/extensions/mutator.js
new file mode 100644
index 0000000..493f114
--- /dev/null
+++ b/js/tabulator/src/js/extensions/mutator.js
@@ -0,0 +1,58 @@
+var Mutator = function(table){
+ this.table = table; //hold Tabulator object
+};
+
+//initialize column mutator
+Mutator.prototype.initializeColumn = function(column){
+
+ var config = {mutator:false, type:column.definition.mutateType, params:column.definition.mutatorParams || {}};
+
+ //set column mutator
+ switch(typeof column.definition.mutator){
+ case "string":
+ if(this.mutators[column.definition.mutator]){
+ config.mutator = this.mutators[column.definition.mutator]
+ }else{
+ console.warn("Mutator Error - No such mutator found, ignoring: ", column.definition.mutator);
+ }
+ break;
+
+ case "function":
+ config.mutator = column.definition.mutator;
+ break;
+ }
+
+ if(config.mutator){
+ column.extensions.mutate = config;
+ }
+};
+
+//apply mutator to row
+Mutator.prototype.transformRow = function(data){
+ var self = this;
+
+ self.table.columnManager.traverse(function(column){
+ var field;
+
+ if(column.extensions.mutate){
+
+ field = column.getField();
+
+ if(column.extensions.mutate.type != "edit"){
+ column.setFieldValue(data, column.extensions.mutate.mutator(column.getFieldValue(data), data, "data", column.extensions.mutate.params));
+ }
+ }
+ });
+
+ return data;
+};
+
+//apply mutator to new cell value
+Mutator.prototype.transformCell = function(cell, value){
+ return cell.column.extensions.mutate.mutator(value, cell.row.getData(), "edit", cell.column.extensions.mutate.params, cell.getComponent())
+};
+
+//default mutators
+Mutator.prototype.mutators = {};
+
+Tabulator.registerExtension("mutator", Mutator);
\ No newline at end of file
diff --git a/js/tabulator/src/js/extensions/page.js b/js/tabulator/src/js/extensions/page.js
new file mode 100644
index 0000000..94adf3f
--- /dev/null
+++ b/js/tabulator/src/js/extensions/page.js
@@ -0,0 +1,412 @@
+var Page = function(table){
+
+ this.table = table; //hold Tabulator object
+
+ this.element = $("");
+ this.pagesElement = $("");
+ this.firstBut = $("");
+ this.prevBut = $("");
+ this.nextBut = $("");
+ this.lastBut = $("");
+
+ this.mode = "local";
+ this.size = 0;
+ this.page = 1;
+ this.max = 1;
+ this.paginator = false;
+};
+
+//setup pageination
+Page.prototype.initialize = function(){
+ var self = this;
+
+ //update param names
+ for(let key in self.table.options.paginationDataSent){
+ self.paginationDataSentNames[key] = self.table.options.paginationDataSent[key];
+ }
+
+ for(let key in self.table.options.paginationDataReceived){
+ self.paginationDataReceivedNames[key] = self.table.options.paginationDataReceived[key];
+ }
+
+ if(self.table.options.paginator){
+ self.paginator = self.table.options.paginator;
+ }
+
+
+ //build pagination element
+
+ //bind localizations
+ self.table.extensions.localize.bind("pagination.first", function(value){
+ self.firstBut.html(value);
+ });
+
+ self.table.extensions.localize.bind("pagination.first_title", function(value){
+ self.firstBut.attr("aria-label", value)
+ .attr("title", value);
+ });
+
+ self.table.extensions.localize.bind("pagination.prev", function(value){
+ self.prevBut.html(value);
+ });
+
+ self.table.extensions.localize.bind("pagination.prev_title", function(value){
+ self.prevBut.attr("aria-label", value)
+ .attr("title", value);
+ });
+
+ self.table.extensions.localize.bind("pagination.next", function(value){
+ self.nextBut.html(value);
+ });
+
+ self.table.extensions.localize.bind("pagination.next_title", function(value){
+ self.nextBut.attr("aria-label", value)
+ .attr("title", value);
+ });
+
+ self.table.extensions.localize.bind("pagination.last", function(value){
+ self.lastBut.html(value);
+ });
+
+ self.table.extensions.localize.bind("pagination.last_title", function(value){
+ self.lastBut.attr("aria-label", value)
+ .attr("title", value);
+ });
+
+ //click bindings
+ self.firstBut.on("click", function(){
+ self.setPage(1);
+ });
+
+ self.prevBut.on("click", function(){
+ self.previousPage();
+ });
+
+ self.nextBut.on("click", function(){
+ self.nextPage();
+ });
+
+ self.lastBut.on("click", function(){
+ self.setPage(self.max);
+ });
+
+ if(self.table.options.paginationElement){
+ self.element = self.table.options.paginationElement;
+ }
+
+ //append to DOM
+ self.element.append(self.firstBut);
+ self.element.append(self.prevBut);
+ self.element.append(self.pagesElement);
+ self.element.append(self.nextBut);
+ self.element.append(self.lastBut);
+
+ if(!self.table.options.paginationElement){
+ self.table.footerManager.append(self.element, self);
+ }
+
+
+ //set default values
+ self.mode = self.table.options.pagination;
+ self.size = self.table.options.paginationSize || Math.floor(self.table.rowManager.getElement().innerHeight() / 26);
+};
+
+//calculate maximum page from number of rows
+Page.prototype.setMaxRows = function(rowCount){
+
+ if(!rowCount){
+ this.max = 1;
+ }else{
+ this.max = Math.ceil(rowCount/this.size);
+ }
+
+ if(this.page > this.max){
+ this.page = this.max;
+ }
+};
+
+//reset to first page without triggering action
+Page.prototype.reset = function(force){
+ if(this.mode == "local" || force){
+ this.page = 1;
+ }
+ return true;
+};
+
+//set the maxmum page
+Page.prototype.setMaxPage = function(max){
+ this.max = max || 1;
+
+ if(this.page > this.max){
+ this.page = this.max;
+ this.trigger();
+ }
+};
+
+//set current page number
+Page.prototype.setPage = function(page){
+ if(page > 0 && page <= this.max){
+ this.page = page;
+ this.trigger();
+ return true;
+ }else{
+ console.warn("Pagination Error - Requested page is out of range of 1 - " + this.max + ":", page);
+ return false;
+ }
+};
+
+Page.prototype.setPageSize = function(size){
+ if(size > 0){
+ this.size = size;
+ }
+};
+
+
+//setup the pagination buttons
+Page.prototype._setPageButtons = function(){
+ var self = this;
+
+ var min = this.page < this.max-2 ? (this.page - 2) : (this.page - (4 - (this.max - this.page)));
+ var max = this.page > 3 ? (this.page + 2) : (this.page + (5 - this.page));
+
+ self.pagesElement.empty();
+
+ if(self.page == 1){
+ self.firstBut.prop("disabled", true);
+ self.prevBut.prop("disabled", true);
+ }else{
+ self.firstBut.prop("disabled", false);
+ self.prevBut.prop("disabled", false);
+ }
+
+ if(self.page == self.max){
+ self.lastBut.prop("disabled", true);
+ self.nextBut.prop("disabled", true);
+ }else{
+ self.lastBut.prop("disabled", false);
+ self.nextBut.prop("disabled", false);
+ }
+
+ for(let i = min; i <= max; i++){
+ if(i>0 && i <= self.max){
+ self.pagesElement.append(self._generatePageButton(i));
+ }
+ }
+
+ this.footerRedraw();
+};
+
+Page.prototype._generatePageButton = function(page){
+ var self = this;
+ var button = $("");
+
+ button.on("click", function(e){
+ self.setPage(page);
+ });
+
+ return button;
+};
+
+//previous page
+Page.prototype.previousPage = function(){
+ if(this.page > 1){
+ this.page--;
+ this.trigger();
+ return true;
+ }else{
+ console.warn("Pagination Error - Previous page would be less than page 1:", 0);
+ return false;
+ }
+};
+
+//next page
+Page.prototype.nextPage = function(){
+ if(this.page < this.max){
+ this.page++;
+ this.trigger();
+ return true;
+ }else{
+ console.warn("Pagination Error - Next page would be greater than maximum page of " + this.max + ":", this.max + 1);
+ return false;
+ }
+};
+
+//return current page number
+Page.prototype.getPage = function(){
+ return this.page;
+};
+
+//return max page number
+Page.prototype.getPageMax = function(){
+ return this.max;
+};
+
+Page.prototype.getPageSize = function(size){;
+ return this.size;
+};
+
+Page.prototype.getMode = function(){
+ return this.mode;
+};
+
+//return appropriate rows for current page
+Page.prototype.getRows = function(data){
+ var output, start, end;
+
+ if(this.mode == "local"){
+ output = [];
+ start = this.size * (this.page - 1);
+ end = start + parseInt(this.size);
+
+ this._setPageButtons();
+
+ for(let i = start; i < end; i++){
+ if(data[i]){
+ output.push(data[i]);
+ }
+ }
+
+ return output;
+ }else{
+
+ this._setPageButtons();
+
+ return data.slice(0);
+ }
+};
+
+Page.prototype.trigger = function(){
+ switch(this.mode){
+ case "local":
+ this.table.rowManager.refreshActiveData();
+ this.table.options.pageLoaded(this.getPage());
+ break;
+
+ case "remote":
+ this._getRemotePage();
+ break;
+
+ default:
+ console.warn("Pagination Error - no such pagination mode:", this.mode);
+ }
+};
+
+Page.prototype._getRemotePage = function(){
+ if(this.table.extExists("ajax", true)){
+
+ if(this.paginator){
+ this._getRemotePagePaginator();
+ }else{
+ this._getRemotePageAuto();
+ }
+ }
+};
+
+Page.prototype._getRemotePagePaginator = function(){
+ var self = this,
+ ajax = self.table.extensions.ajax,
+ oldUrl = ajax.getUrl();
+
+ ajax.setUrl(self.paginator(ajax.getUrl(), self.page, self.size, ajax.getParams()))
+
+ ajax.sendRequest(function(data){
+ self._parseRemoteData(data);
+ });
+
+ ajax.setUrl(oldUrl);
+};
+
+Page.prototype._getRemotePageAuto = function(){
+ var self = this,
+ oldParams, pageParams;
+
+ //record old params and restore after request has been made
+ oldParams = $.extend(true, {}, self.table.extensions.ajax.getParams());
+ pageParams = self.table.extensions.ajax.getParams();
+
+ //configure request params
+ pageParams[this.paginationDataSentNames.page] = self.page;
+
+ //set page size if defined
+ if(this.size){
+ pageParams[this.paginationDataSentNames.size] = this.size;
+ }
+
+ //set sort data if defined
+ if(this.table.extExists("sort")){
+ let sorters = self.table.extensions.sort.getSort();
+
+ sorters.forEach(function(item){
+ delete item.column;
+ });
+
+ pageParams[this.paginationDataSentNames.sorters] = sorters;
+ }
+
+ //set filter data if defined
+ if(this.table.extExists("filter")){
+ let filters = self.table.extensions.filter.getFilters(true, true);
+ pageParams[this.paginationDataSentNames.filters] = filters;
+ }
+
+ self.table.extensions.ajax.setParams(pageParams);
+
+ self.table.extensions.ajax.sendRequest(function(data){
+ self._parseRemoteData(data);
+ });
+
+ self.table.extensions.ajax.setParams(oldParams);
+};
+
+
+
+Page.prototype._parseRemoteData = function(data){
+ if(data[this.paginationDataReceivedNames.last_page]){
+ if(data[this.paginationDataReceivedNames.data]){
+ this.max = parseInt(data[this.paginationDataReceivedNames.last_page]);
+
+ this.table.rowManager.setData(data[this.paginationDataReceivedNames.data]);
+
+ this.table.options.pageLoaded(this.getPage());
+ }else{
+ console.warn("Remote Pagination Error - Server response missing '" + this.paginationDataReceivedNames.data + "' property");
+ }
+ }else{
+ console.warn("Remote Pagination Error - Server response missing '" + this.paginationDataReceivedNames.last_page + "' property");
+ }
+};
+
+//handle the footer element being redrawn
+Page.prototype.footerRedraw = function(){
+ var footer = this.table.footerManager.element;
+
+ if((footer.innerWidth() - footer[0].scrollWidth) < 0){
+ this.pagesElement.hide();
+ }else{
+ this.pagesElement.show();
+
+ if((footer.innerWidth() - footer[0].scrollWidth) < 0){
+ this.pagesElement.hide();
+ }
+ }
+};
+
+//set the paramter names for pagination requests
+Page.prototype.paginationDataSentNames = {
+ "page":"page",
+ "size":"size",
+ "sorters":"sorters",
+ // "sort_dir":"sort_dir",
+ "filters":"filters",
+ // "filter_value":"filter_value",
+ // "filter_type":"filter_type",
+};
+
+//set the property names for pagination responses
+Page.prototype.paginationDataReceivedNames = {
+ "current_page":"current_page",
+ "last_page":"last_page",
+ "data":"data",
+};
+
+Tabulator.registerExtension("page", Page);
diff --git a/js/tabulator/src/js/extensions/persistent_layout.js b/js/tabulator/src/js/extensions/persistent_layout.js
new file mode 100644
index 0000000..48af4a4
--- /dev/null
+++ b/js/tabulator/src/js/extensions/persistent_layout.js
@@ -0,0 +1,155 @@
+var PersistentLayout = function(table){
+ this.table = table; //hold Tabulator object
+ this.mode = "";
+ this.id = "";
+ this.persistProps = ["field", "width", "visible"];
+};
+
+//setup parameters
+PersistentLayout.prototype.initialize = function(mode, id){
+ //determine persistent layout storage type
+ this.mode = mode !== true ? mode : (typeof window.localStorage !== 'undefined' ? "local" : "cookie");
+
+ //set storage tag
+ this.id = "tabulator-" + (id || (this.table.element.attr("id") || ""));
+};
+
+//load saved definitions
+PersistentLayout.prototype.load = function(definition){
+
+ var newDefinition = "";
+
+ switch(this.mode){
+ case "local":
+ newDefinition = localStorage.getItem(this.id);
+ break;
+
+ case "cookie":
+
+ //find cookie
+ let cookie = document.cookie,
+ cookiePos = cookie.indexOf(this.id + "="),
+ end;
+
+ //if cookie exists, decode and load column data into tabulator
+ if(cookiePos > -1){
+ cookie = cookie.substr(cookiePos);
+
+ end = cookie.indexOf(";");
+
+ if(end > -1){
+ cookie = cookie.substr(0, end);
+ }
+
+ newDefinition = cookie.replace(this.id + "=", "");
+ }
+ break;
+
+ default:
+ console.warn("Persistance Load Error - invalid mode selected", this.mode);
+ }
+
+ if(newDefinition){
+ newDefinition = JSON.parse(newDefinition);
+
+ definition = this.mergeDefinition(definition, newDefinition);
+ }
+
+ return definition;
+};
+
+//merge old and new column defintions
+PersistentLayout.prototype.mergeDefinition = function(oldCols, newCols){
+ var self = this,
+ output = [];
+
+ newCols.forEach(function(column, to){
+
+ var from = self._findColumn(oldCols, column);
+
+ if(from){
+
+ from.width = column.width;
+ from.visible = column.visible;
+
+ if(from.columns){
+ from.columns = self.mergeDefinition(from.columns, column.columns);
+ }
+
+ output.push(from);
+ }
+
+ });
+
+ return output;
+};
+
+//find matching columns
+PersistentLayout.prototype._findColumn = function(columns, subject){
+ var type = subject.columns ? "group" : (subject.field ? "field" : "object");
+
+ return columns.find(function(col){
+ switch(type){
+ case "group":
+ return col.title === subject.title && col.columns.length === subject.columns.length;
+ break;
+
+ case "field":
+ return col.field === subject.field;
+ break;
+
+ case "object":
+ return col === subject;
+ break;
+ }
+ })
+};
+
+//save current definitions
+PersistentLayout.prototype.save = function(){
+ var definition = this.parseColumns(this.table.columnManager.getColumns()),
+ data = JSON.stringify(definition);
+
+ switch(this.mode){
+ case "local":
+ localStorage.setItem(this.id, data);
+ break;
+
+ case "cookie":
+ let expireDate = new Date();
+ expireDate.setDate(expireDate.getDate() + 10000);
+
+ //save cookie
+ document.cookie = this.id + "=" + data + "; expires=" + expireDate.toUTCString();
+ break;
+
+ default:
+ console.warn("Persistance Save Error - invalid mode selected", this.mode);
+ }
+};
+
+//build premission list
+PersistentLayout.prototype.parseColumns = function(columns){
+ var self = this,
+ definitions = [];
+
+ columns.forEach(function(column){
+ var def = {};
+
+ if(column.isGroup){
+ def.title = column.getDefinition().title;
+ def.columns = self.parseColumns(column.getColumns());
+ }else{
+ def.title = column.getDefinition().title;
+ def.field = column.getField();
+ def.width = column.getWidth();
+ def.visible = column.visible;
+ }
+
+ definitions.push(def);
+ });
+
+ return definitions;
+};
+
+Tabulator.registerExtension("persistentLayout", PersistentLayout);
\ No newline at end of file
diff --git a/js/tabulator/src/js/extensions/resize_columns.js b/js/tabulator/src/js/extensions/resize_columns.js
new file mode 100644
index 0000000..8d50b71
--- /dev/null
+++ b/js/tabulator/src/js/extensions/resize_columns.js
@@ -0,0 +1,119 @@
+var ResizeColumns = function(table){
+ this.table = table; //hold Tabulator object
+ this.startColumn = false;
+ this.startX = false;
+ this.startWidth = false;
+ this.handle = null;
+ this.prevHandle = null;
+};
+
+ResizeColumns.prototype.initializeColumn = function(type, column, element){
+ var self = this,
+ variableHeight =false,
+ mode = this.table.options.resizableColumns;
+
+ //set column resize mode
+ if(type === "header"){
+ variableHeight = column.definition.formatter == "textarea" || column.definition.variableHeight;
+ column.extensions.resize = {variableHeight:variableHeight};
+ }
+
+ if(mode === true || mode == type){
+
+ var handle = document.createElement('div');
+ handle.className = "tabulator-col-resize-handle";
+
+
+ var prevHandle = document.createElement('div');
+ prevHandle.className = "tabulator-col-resize-handle prev";
+
+ handle.addEventListener("click", function(e){
+ e.stopPropagation();
+ });
+
+ handle.addEventListener("mousedown", function(e){
+ var nearestColumn = column.getLastColumn();
+
+ if(nearestColumn){
+ self.startColumn = column;
+ self._mouseDown(e, nearestColumn);
+ }
+ });
+
+ prevHandle.addEventListener("click", function(e){
+ e.stopPropagation();
+ });
+
+ prevHandle.addEventListener("mousedown", function(e){
+ var nearestColumn, colIndex, prevColumn;
+
+ nearestColumn = column.getFirstColumn();
+
+ if(nearestColumn){
+ colIndex = self.table.columnManager.findColumnIndex(nearestColumn);
+ prevColumn = colIndex > 0 ? self.table.columnManager.getColumnByIndex(colIndex - 1) : false;
+
+ if(prevColumn){
+ self.startColumn = column;
+ self._mouseDown(e, prevColumn);
+ }
+ }
+ });
+
+ element.append(handle)
+ .append(prevHandle);
+ }
+};
+
+ResizeColumns.prototype._mouseDown = function(e, column){
+ var self = this;
+
+ self.table.element.addClass("tabulator-block-select");
+
+ function mouseMove(e){
+ column.setWidth(self.startWidth + (e.screenX - self.startX));
+
+ if(!self.table.browserSlow && column.extensions.resize && column.extensions.resize.variableHeight){
+ column.checkCellHeights();
+ }
+ }
+
+ function mouseUp(e){
+
+ //block editor from taking action while resizing is taking place
+ if(self.startColumn.extensions.edit){
+ self.startColumn.extensions.edit.blocked = false;
+ }
+
+ if(self.table.browserSlow && column.extensions.resize && column.extensions.resize.variableHeight){
+ column.checkCellHeights();
+ }
+
+ $("body").off("mouseup", mouseMove);
+ $("body").off("mousemove", mouseMove);
+
+ self.table.element.removeClass("tabulator-block-select");
+
+ if(self.table.options.persistentLayout && self.table.extExists("persistentLayout", true)){
+ self.table.extensions.persistentLayout.save();
+ }
+
+ self.table.options.columnResized(self.startColumn.getComponent())
+ }
+
+ e.stopPropagation(); //prevent resize from interfereing with movable columns
+
+ //block editor from taking action while resizing is taking place
+ if(self.startColumn.extensions.edit){
+ self.startColumn.extensions.edit.blocked = true;
+ }
+
+ self.startX = e.screenX;
+ self.startWidth = column.getWidth();
+
+ $("body").on("mousemove", mouseMove);
+
+ $("body").on("mouseup", mouseUp);
+};
+
+Tabulator.registerExtension("resizeColumns", ResizeColumns);
\ No newline at end of file
diff --git a/js/tabulator/src/js/extensions/responsive_layout.js b/js/tabulator/src/js/extensions/responsive_layout.js
new file mode 100644
index 0000000..a250837
--- /dev/null
+++ b/js/tabulator/src/js/extensions/responsive_layout.js
@@ -0,0 +1,84 @@
+var ResponsiveLayout = function(table){
+ this.table = table; //hold Tabulator object
+ this.columns = [];
+ this.index = 0;
+};
+
+//generate resposivle columns list
+ResponsiveLayout.prototype.initialize = function(){
+ var columns=[];
+
+ //detemine level of responsivity for each column
+ this.table.columnManager.columnsByIndex.forEach(function(column){
+ var def = column.getDefinition();
+
+ column.extensions.responsive = {order: typeof def.responsive === "undefined" ? 1 : def.responsive};
+
+ if(column.extensions.responsive.order){
+ columns.push(column);
+ }
+ });
+
+
+ //sort list by responsivity
+ columns = columns.reverse();
+ columns = columns.sort(function(a, b){
+ return b.extensions.responsive.order - a.extensions.responsive.order;
+ });
+
+ this.columns = columns;
+};
+
+ResponsiveLayout.prototype.update = function(){
+ var self = this,
+ working = true;
+
+ while(working){
+
+ let width = self.table.extensions.layout.getMode() == "fitColumns" ? self.table.columnManager.getFlexBaseWidth() : self.table.columnManager.getWidth();
+
+ let diff = self.table.columnManager.element.innerWidth() - width;
+
+ if(diff < 0){
+ //table is too wide
+ let column = self.columns[self.index];
+
+ if(column){
+ column.hide();
+ self.index ++;
+ }else{
+ working = false;
+ }
+
+ }else{
+
+ //table has spare space
+ let column = self.columns[self.index -1];
+
+ if(column){
+ if(diff > 0){
+ if(diff >= column.getWidth()){
+ column.show();
+
+ //set column width to prevent calculation loops on uninitialized columns
+ column.setWidth(column.getWidth());
+
+ self.index --;
+ }else{
+ working = false;
+ }
+ }else{
+ working = false;
+ }
+ }else{
+ working = false;
+ }
+ }
+
+ if(!self.table.rowManager.activeRowsCount){
+ self.table.rowManager.renderEmptyScroll();
+ }
+ }
+};
+
+Tabulator.registerExtension("responsiveLayout", ResponsiveLayout);
\ No newline at end of file
diff --git a/js/tabulator/src/js/extensions/select_row.js b/js/tabulator/src/js/extensions/select_row.js
new file mode 100644
index 0000000..08e3979
--- /dev/null
+++ b/js/tabulator/src/js/extensions/select_row.js
@@ -0,0 +1,242 @@
+var SelectRow = function(table){
+ this.table = table; //hold Tabulator object
+ this.selecting = false; //flag selecting in progress
+ this.selectPrev = []; //hold previously selected element for drag drop selection
+ this.selectedRows = []; //hold selected rows
+};
+
+SelectRow.prototype.clearSelectionData = function(){
+ this.selecting = false;
+ this.selectPrev = [];
+ this.selectedRows = [];
+};
+
+SelectRow.prototype.initializeRow = function(row){
+ var self = this,
+ element = row.getElement();
+
+ // trigger end of row selection
+ var endSelect = function(){
+
+ setTimeout(function(){
+ self.selecting = false;
+ }, 50)
+
+ $("body").off("mouseup", endSelect);
+ }
+
+
+ row.extensions.select = {selected:false};
+
+ //set row selection class
+ if(self.table.options.selectableCheck(row.getComponent())){
+ element.addClass("tabulator-selectable").removeClass("tabulator-unselectable");
+
+ if(self.table.options.selectable && self.table.options.selectable != "highlight"){
+ element.on("click", function(e){
+ if(!self.selecting){
+ self.toggleRow(row);
+ }
+ });
+
+ element.on("mousedown", function(e){
+ if(e.shiftKey){
+ self.selecting = true;
+
+ self.selectPrev = [];
+
+ $("body").on("mouseup", endSelect);
+ $("body").on("keyup", endSelect);
+
+ self.toggleRow(row);
+
+ return false;
+ }
+ });
+
+ element.on("mouseenter", function(e){
+ if(self.selecting){
+ self.toggleRow(row);
+
+ if(self.selectPrev[1] == row){
+ self.toggleRow(self.selectPrev[0]);
+ }
+ }
+ });
+
+ element.on("mouseout", function(e){
+ if(self.selecting){
+ self.selectPrev.unshift(row);
+ }
+ });
+ }
+
+ }else{
+ row.getElement().addClass("tabulator-unselectable").removeClass("tabulator-selectable");
+ }
+};
+
+//toggle row selection
+SelectRow.prototype.toggleRow = function(row){
+ if(this.table.options.selectableCheck(row.getComponent())){
+ if(row.extensions.select.selected){
+ this._deselectRow(row);
+ }else{
+ this._selectRow(row);
+ }
+ }
+};
+
+//select a number of rows
+SelectRow.prototype.selectRows = function(rows){
+ var self = this;
+
+ switch(typeof rows){
+ case "undefined":
+ self.table.rowManager.rows.forEach(function(row){
+ self._selectRow(row, true, true);
+ });
+
+ self._rowSelectionChanged();
+ break;
+
+ case "boolean":
+ if(rows === true){
+ self.table.rowManager.activeRows.forEach(function(row){
+ self._selectRow(row, true, true);
+ });
+
+ self._rowSelectionChanged();
+ }
+ break;
+
+ default:
+ if(Array.isArray(rows)){
+ rows.forEach(function(row){
+ self._selectRow(row, true);
+ });
+
+ self._rowSelectionChanged();
+ }else{
+ self._selectRow(rows);
+ }
+ break;
+ }
+};
+
+//select an individual row
+SelectRow.prototype._selectRow = function(rowInfo, silent, force){
+ var self = this,
+ index;
+
+ //handle max row count
+ if(!isNaN(self.table.options.selectable) && self.table.options.selectable !== true && !force){
+ if(self.selectedRows.length >= self.table.options.selectable){
+ if(self.table.options.selectableRollingSelection){
+ self._deselectRow(self.selectedRows[0], true);
+ }else{
+ return false;
+ }
+ }
+ }
+
+ var row = self.table.rowManager.findRow(rowInfo);
+
+ if(row){
+ var self = this;
+
+ row.extensions.select.selected = true;
+ row.getElement().addClass("tabulator-selected");
+
+ self.selectedRows.push(row);
+
+ if(!silent){
+ self.table.options.rowSelected(row.getComponent());
+ self._rowSelectionChanged();
+ }
+ }else{
+ console.warn("Selection Error - No such row found, ignoring selection:" + rowInfo)
+ }
+};
+
+//deselect a number of rows
+SelectRow.prototype.deselectRows = function(rows){
+ var self = this;
+
+ if(typeof rows == "undefined"){
+
+ let rowCount = self.selectedRows.length;
+
+ for(let i = 0; i < rowCount; i++){
+ self._deselectRow(self.selectedRows[0], true);
+ }
+
+ self._rowSelectionChanged();
+ }else{
+ if(Array.isArray(rows)){
+ rows.forEach(function(row){
+ self._deselectRow(row, true);
+ });
+
+ self._rowSelectionChanged();
+ }else{
+ self._deselectRow(rows);
+ }
+ }
+};
+
+//deselect an individual row
+SelectRow.prototype._deselectRow = function(rowInfo, silent){
+ var self = this,
+ row = self.table.rowManager.findRow(rowInfo),
+ index;
+
+
+
+ if(row){
+ index = self.selectedRows.findIndex(function(selectedRow){
+ return selectedRow == row;
+ });
+
+ if(index > -1){
+
+ row.extensions.select.selected = false;
+ row.getElement().removeClass("tabulator-selected");
+ self.selectedRows.splice(index, 1);
+
+ if(!silent){
+ self.table.options.rowDeselected(row.getComponent());
+ self._rowSelectionChanged();
+ }
+ }
+ }else{
+ console.warn("Selection Error - No such row found, ignoring selection:" + rowInfo)
+ }
+};
+
+SelectRow.prototype.getSelectedData = function(){
+ var data = [];
+
+ this.selectedRows.forEach(function(row){
+ data.push(row.getData());
+ });
+
+ return data
+};
+
+SelectRow.prototype.getSelectedRows = function(){
+
+ var rows = []
+
+ this.selectedRows.forEach(function(row){
+ rows.push(row.getComponent());
+ })
+
+ return rows;
+};
+
+SelectRow.prototype._rowSelectionChanged = function(){
+ this.table.options.rowSelectionChanged(this.getSelectedData(), this.getSelectedRows());
+};
+
+Tabulator.registerExtension("selectRow", SelectRow);
\ No newline at end of file
diff --git a/js/tabulator/src/js/extensions/sort.js b/js/tabulator/src/js/extensions/sort.js
new file mode 100644
index 0000000..3ce9e64
--- /dev/null
+++ b/js/tabulator/src/js/extensions/sort.js
@@ -0,0 +1,341 @@
+var Sort = function(table){
+ this.table = table; //hold Tabulator object
+ this.sortList = []; //holder current sort
+ this.changed = false; //has the sort changed since last render
+ };
+
+//initialize column header for sorting
+Sort.prototype.initializeColumn = function(column, content){
+ var self = this,
+ sorter = false;
+
+
+ switch(typeof column.definition.sorter){
+ case "string":
+ if(self.sorters[column.definition.sorter]){
+ sorter = self.sorters[column.definition.sorter];
+ }else{
+ console.warn("Sort Error - No such sorter found: ", column.definition.sorter);
+ }
+ break;
+
+ case "function":
+ sorter = column.definition.sorter;
+ break;
+ }
+
+
+ column.extensions.sort = {sorter:sorter, dir:"none", params:column.definition.sorterParams || {}};
+
+ if(column.definition.headerSort !== false){
+
+ column.element.addClass("tabulator-sortable");
+
+ //create sorter arrow
+ content.append($(""));
+
+ //sort on click
+ column.element.on("click", function(e){
+ var dir = "",
+ sorters=[],
+ match = false;
+
+ if(column.extensions.sort){
+ dir = column.extensions.sort.dir == "asc" ? "desc" : "asc";
+
+ if(e.shiftKey || e.ctrlKey){
+ sorters = self.getSort();
+
+
+ match = sorters.findIndex(function(sorter){
+ return sorter.field === column.getField();
+ });
+
+ if(match > -1){
+ sorters[match].dir = sorters[match].dir == "asc" ? "desc" : "asc";
+
+ if(match != sorters.length -1){
+ sorters.push(sorters.splice(match, 1)[0]);
+ }
+ }else{
+ sorters.push({column:column, dir:dir});
+ }
+
+ //add to existing sort
+ self.setSort(sorters);
+ }else{
+ //sort by column only
+ self.setSort(column, dir);
+ }
+
+ self.table.rowManager.sorterRefresh();
+ }
+ });
+ }
+};
+
+//check if the sorters have changed since last use
+Sort.prototype.hasChanged = function(){
+ var changed = this.changed;
+ this.changed = false;
+ return changed;
+};
+
+//return current sorters
+Sort.prototype.getSort = function(){
+ var self = this,
+ sorters = [];
+
+ self.sortList.forEach(function(item){
+ if(item.column){
+ sorters.push({column:item.column.getComponent(), field:item.column.getField(), dir:item.dir});
+ }
+ });
+
+ return sorters;
+};
+
+//change sort list and trigger sort
+Sort.prototype.setSort = function(sortList, dir){
+ var self = this,
+ newSortList = [];
+
+ if(!Array.isArray(sortList)){
+ sortList = [{column: sortList, dir:dir}];
+ }
+
+ sortList.forEach(function(item){
+ var column;
+
+ column = self.table.columnManager.findColumn(item.column);
+
+ if(column){
+ item.column = column;
+ newSortList.push(item);
+ self.changed = true;
+ }else{
+ console.warn("Sort Warning - Sort field does not exist and is being ignored: ", item.column);
+ }
+
+ });
+
+ self.sortList = newSortList;
+};
+
+//clear sorters
+Sort.prototype.clear = function(){
+ this.setSort([]);
+},
+
+//find appropriate sorter for column
+Sort.prototype.findSorter = function(column){
+ var row = this.table.rowManager.activeRows[0],
+ sorter = "string",
+ field, value;
+
+ if(row){
+ row = row.getData();
+ field = column.getField();
+
+ if(field){
+
+ value = column.getFieldValue(row);
+
+ switch(typeof value){
+ case "undefined":
+ sorter = "string";
+ break;
+
+ case "boolean":
+ sorter = "boolean";
+ break;
+
+ default:
+ if(!isNaN(value) && value !== ""){
+ sorter = "number";
+ }else{
+ if(value.match(/((^[0-9]+[a-z]+)|(^[a-z]+[0-9]+))+$/i)){
+ sorter = "alphanum";
+ }
+ }
+ break;
+ }
+ }
+ }
+
+ return this.sorters[sorter];
+};
+
+//work through sort list sorting data
+Sort.prototype.sort = function(){
+ var self = this, lastSort;
+
+ if(self.table.options.dataSorting){
+ self.table.options.dataSorting(self.getSort());
+ }
+
+ self.clearColumnHeaders();
+
+ if(!self.table.options.ajaxSorting){
+
+ self.sortList.forEach(function(item, i){
+
+ if(item.column && item.column.extensions.sort){
+
+ //if no sorter has been defined, take a guess
+ if(!item.column.extensions.sort.sorter){
+ item.column.extensions.sort.sorter = self.findSorter(item.column);
+ }
+
+ self._sortItem(item.column, item.dir, self.sortList, i);
+ }
+
+ self.setColumnHeader(item.column, item.dir);
+ })
+ }
+
+ if(self.table.options.dataSorted){
+ self.table.options.dataSorted(self.getSort(), self.table.rowManager.getComponents(true));
+ }
+
+};
+
+//clear sort arrows on columns
+Sort.prototype.clearColumnHeaders = function(){
+ this.table.columnManager.getRealColumns().forEach(function(column){
+ if(column.extensions.sort){
+ column.extensions.sort.dir = "none";
+ column.element.attr("aria-sort", "none");
+ }
+ });
+};
+
+//set the column header sort direction
+Sort.prototype.setColumnHeader = function(column, dir){
+ column.extensions.sort.dir = dir;
+ column.element.attr("aria-sort", dir);
+};
+
+//sort each item in sort list
+Sort.prototype._sortItem = function(column, dir, sortList, i){
+ var self = this;
+
+ var activeRows = self.table.rowManager.activeRows;
+
+ activeRows.sort(function(a, b){
+
+ var result = self._sortRow(a, b, column, dir);
+
+ //if results match recurse through previous searchs to be sure
+ if(result == 0 && i){
+ for(var j = i-1; j>= 0; j--){
+ result = self._sortRow(a, b, sortList[j].column, sortList[j].dir);
+
+ if(result != 0){
+ break;
+ }
+ }
+ }
+
+ return result;
+ });
+};
+
+//process individual rows for a sort function on active data
+Sort.prototype._sortRow = function(a, b, column, dir){
+ var self = this;
+
+ //switch elements depending on search direction
+ var el1 = dir == "asc" ? a : b;
+ var el2 = dir == "asc" ? b : a;
+
+ a = column.getFieldValue(el1.getData());
+ b = column.getFieldValue(el2.getData());
+
+ a = typeof a !== "undefined" ? a : "";
+ b = typeof b !== "undefined" ? b : "";
+
+ return column.extensions.sort.sorter.call(self, a, b, el1.getComponent(), el2.getComponent(), column.getComponent(), dir, column.extensions.sort.params);
+};
+
+
+//default data sorters
+Sort.prototype.sorters = {
+
+ //sort numbers
+ number:function(a, b, aRow, bRow, column, dir, params){
+ return parseFloat(String(a).replace(",","")) - parseFloat(String(b).replace(",",""));
+ },
+
+ //sort strings
+ string:function(a, b, aRow, bRow, column, dir, params){
+ return String(a).toLowerCase().localeCompare(String(b).toLowerCase());
+ },
+
+ //sort date
+ date:function(a, b, aRow, bRow, column, dir, params){
+ var self = this;
+ var format = params.format || "DD/MM/YYYY";
+
+ if(typeof moment != "undefined"){
+ a = moment(a, format);
+ b = moment(b, format);
+ }else{
+ console.error("Sort Error - 'date' sorter is dependant on moment.js");
+ }
+
+ return a - b;
+ },
+
+ //sort booleans
+ boolean:function(a, b, aRow, bRow, column, dir, params){
+ var el1 = a === true || a === "true" || a === "True" || a === 1 ? 1 : 0;
+ var el2 = b === true || b === "true" || b === "True" || b === 1 ? 1 : 0;
+
+ return el1 - el2;
+ },
+
+ //sort alpha numeric strings
+ alphanum:function(as, bs, aRow, bRow, column, dir, params){
+ var a, b, a1, b1, i= 0, L, rx = /(\d+)|(\D+)/g, rd = /\d/;
+
+ if(isFinite(as) && isFinite(bs)) return as - bs;
+ a = String(as).toLowerCase();
+ b = String(bs).toLowerCase();
+ if(a === b) return 0;
+ if(!(rd.test(a) && rd.test(b))) return a > b ? 1 : -1;
+ a = a.match(rx);
+ b = b.match(rx);
+ L = a.length > b.length ? b.length : a.length;
+ while(i < L){
+ a1= a[i];
+ b1= b[i++];
+ if(a1 !== b1){
+ if(isFinite(a1) && isFinite(b1)){
+ if(a1.charAt(0) === "0") a1 = "." + a1;
+ if(b1.charAt(0) === "0") b1 = "." + b1;
+ return a1 - b1;
+ }
+ else return a1 > b1 ? 1 : -1;
+ }
+ }
+ return a.length > b.length;
+ },
+
+ //sort hh:mm formatted times
+ time:function(a, b, aRow, bRow, column, dir, params){
+ var self = this;
+ var format = params.format || "hh:mm";
+
+ if(typeof moment != "undefined"){
+ a = moment(a, format);
+ b = moment(b, format);
+ }else{
+ console.error("Sort Error - 'date' sorter is dependant on moment.js");
+ }
+
+ return a - b;
+ },
+};
+
+Tabulator.registerExtension("sort", Sort);
\ No newline at end of file
diff --git a/js/tabulator/src/js/extensions/validate.js b/js/tabulator/src/js/extensions/validate.js
new file mode 100644
index 0000000..58156b4
--- /dev/null
+++ b/js/tabulator/src/js/extensions/validate.js
@@ -0,0 +1,178 @@
+var Validate = function(table){
+ this.table = table;
+};
+
+//validate
+Validate.prototype.initializeColumn = function(column){
+ var self = this,
+ config = [],
+ validator;
+
+ if(column.definition.validator){
+
+ if(Array.isArray(column.definition.validator)){
+ column.definition.validator.forEach(function(item){
+ validator = self._extractValidator(item);
+
+ if(validator){
+ config.push(validator);
+ }
+ })
+
+ }else{
+ validator = this._extractValidator(column.definition.validator);
+
+ if(validator){
+ config.push(validator);
+ }
+ }
+
+ column.extensions.validate = config.length ? config : false;
+ }
+};
+
+Validate.prototype._extractValidator = function(value){
+
+ switch(typeof value){
+ case "string":
+ let parts = value.split(":");
+ let type = parts.shift();
+ let params = parts.join();
+
+ return this._buildValidator(type, params);
+ break;
+
+ case "function":
+ return this._buildValidator(value);
+ break;
+
+ case "object":
+ return this._buildValidator(value.type, value.parameters);
+ break;
+ }
+};
+
+Validate.prototype._buildValidator = function(type, params){
+
+ var func = typeof type == "function" ? type : this.validators[type];
+
+ if(!func){
+ console.warn("Validator Setup Error - No matching validator found:", type);
+ return false;
+ }else{
+ return {
+ type:typeof type == "function" ? "function" : type,
+ func:func,
+ params:params,
+ };
+ }
+};
+
+
+Validate.prototype.validate = function(validators, cell, value){
+ var self = this,
+ valid = [];
+
+ if(validators){
+ validators.forEach(function(item){
+ if(!item.func.call(self, cell, value, item.params)){
+ valid.push({
+ type:item.type,
+ parameters:item.params
+ });
+ }
+ });
+ }
+
+ return valid.length ? valid : true;
+};
+
+
+Validate.prototype.validators = {
+
+ //is integer
+ integer:function(cell, value, parameters){
+ value = Number(value);
+ return typeof value === 'number' && isFinite(value) && Math.floor(value) === value;
+ },
+
+ //is float
+ float:function(cell, value, parameters){
+ value = Number(value);
+ return typeof value === 'number' && isFinite(value) && value % 1 !== 0;;
+ },
+
+ //must be a number
+ numeric:function(cell, value, parameters){
+ return !isNaN(value);
+ },
+
+ //must be a string
+ string:function(cell, value, parameters){
+ return isNaN(value);
+ },
+
+
+ //maximum value
+ max:function(cell, value, parameters){
+ return parseFloat(value) <= parameters;
+ },
+
+ //minimum value
+ min:function(cell, value, parameters){
+ return parseFloat(value) >= parameters;
+ },
+
+ //minimum string length
+ minLength:function(cell, value, parameters){
+ return String(value).length >= parameters;
+ },
+
+ //maximum string length
+ maxLength:function(cell, value, parameters){
+ return String(value).length <= parameters;
+ },
+
+ //in provided value list
+ in:function(cell, value, parameters){
+ if(typeof parameters == "string"){
+ parameters = parameters.split("|");
+ }
+
+ return value === "" || parameters.indexOf(value) > -1;
+ },
+
+ //must match provided regex
+ regex:function(cell, value, parameters){
+ var reg = new RegExp(parameters);
+
+ return reg.test(value);
+ },
+
+ //value must be unique in this column
+ unique:function(cell, value, parameters){
+ var unique = true;
+
+ var cellData = cell.getData();
+
+ this.table.rowManager.rows.forEach(function(row){
+ var data = row.getData();
+
+ if(data !== cellData){
+ if(value == data[cell.getField()]){
+ unique = false;
+ }
+ }
+ });
+
+ return unique;
+ },
+
+ //must have a value
+ required:function(cell, value, parameters){
+ return value !== "" & value !== null && typeof value != "undefined";
+ },
+};
+
+
+Tabulator.registerExtension("validate", Validate);
\ No newline at end of file
diff --git a/js/tabulator/src/js/extensions_enabled.js b/js/tabulator/src/js/extensions_enabled.js
new file mode 100644
index 0000000..fcc16c9
--- /dev/null
+++ b/js/tabulator/src/js/extensions_enabled.js
@@ -0,0 +1,22 @@
+/*=include extensions/accessor.js */
+/*=include extensions/ajax.js */
+/*=include extensions/calculation_colums.js */
+/*=include extensions/download.js */
+/*=include extensions/edit.js */
+/*=include extensions/filter.js */
+/*=include extensions/format.js */
+/*=include extensions/frozen_columns.js */
+/*=include extensions/group_rows.js */
+/*=include extensions/history.js */
+/*=include extensions/html_table_import.js */
+/*=include extensions/Keybindings.js */
+/*=include extensions/moveable_columns.js */
+/*=include extensions/moveable_rows.js */
+/*=include extensions/mutator.js */
+/*=include extensions/page.js */
+/*=include extensions/persistent_layout.js */
+/*=include extensions/resize_columns.js */
+/*=include extensions/responsive_layout.js */
+/*=include extensions/select_row.js */
+/*=include extensions/sort.js */
+/*=include extensions/validate.js */
\ No newline at end of file
diff --git a/js/tabulator/src/js/footer_manager.js b/js/tabulator/src/js/footer_manager.js
new file mode 100644
index 0000000..2cff34a
--- /dev/null
+++ b/js/tabulator/src/js/footer_manager.js
@@ -0,0 +1,65 @@
+var FooterManager = function(table){
+ this.table = table;
+ this.active = false;
+ this.element = $(""); //containing element
+ this.links = [];
+
+ this._initialize();
+};
+
+FooterManager.prototype._initialize = function(element){
+ if(this.table.options.footerElement){
+ this.element = this.table.options.footerElement;
+ }
+};
+
+FooterManager.prototype.getElement = function(){
+ return this.element;
+};
+
+
+FooterManager.prototype.append = function(element, parent){
+ this.activate(parent);
+
+ this.element.append(element);
+ this.table.rowManager.adjustTableSize();
+};
+
+FooterManager.prototype.prepend = function(element, parent){
+ this.activate(parent);
+
+ this.element.prepend(element);
+ this.table.rowManager.adjustTableSize();
+};
+
+FooterManager.prototype.remove = function(element){
+ element.remove();
+ this.deactivate();
+};
+
+FooterManager.prototype.deactivate = function(force){
+ if(this.element.is(":empty") || force){
+ this.element.remove();
+ this.active = false;
+ }
+
+ // this.table.rowManager.adjustTableSize();
+}
+
+FooterManager.prototype.activate = function(parent){
+ if(!this.active){
+ this.active = true;
+ this.table.element.append(this.getElement());
+ this.table.element.show();
+ }
+
+ if(parent){
+ this.links.push(parent);
+ }
+}
+
+FooterManager.prototype.redraw = function(){
+ this.links.forEach(function(link){
+ link.footerRedraw();
+ });
+};
\ No newline at end of file
diff --git a/js/tabulator/src/js/jquery_wrapper.js b/js/tabulator/src/js/jquery_wrapper.js
new file mode 100644
index 0000000..26a8186
--- /dev/null
+++ b/js/tabulator/src/js/jquery_wrapper.js
@@ -0,0 +1,32 @@
+/*
+ * This file is part of the Tabulator package.
+ *
+ * (c) Oliver Folkerd
`, ``, and ``.
+$font-family-monospace: Menlo, Monaco, Consolas, "Courier New", monospace;
+$font-family-base: $font-family-sans-serif;
+
+$font-size-base: 14px;
+$font-size-large: ceil(($font-size-base * 1.25)); // ~18px
+$font-size-small: ceil(($font-size-base * 0.85)); // ~12px
+
+$font-size-h1: floor(($font-size-base * 2.6)); // ~36px
+$font-size-h2: floor(($font-size-base * 2.15)); // ~30px
+$font-size-h3: ceil(($font-size-base * 1.7)); // ~24px
+$font-size-h4: ceil(($font-size-base * 1.25)); // ~18px
+$font-size-h5: $font-size-base;
+$font-size-h6: ceil(($font-size-base * 0.85)); // ~12px
+
+//** Unit-less `line-height` for use in components like buttons.
+$line-height-base: 1.428571429; // 20/14
+//** Computed "line-height" (`font-size` * `line-height`) for use with `margin`, `padding`, etc.
+$line-height-computed: floor(($font-size-base * $line-height-base)); // ~20px
+
+//** By default, this inherits from the ``.
+$headings-font-family: inherit;
+$headings-font-weight: 500;
+$headings-line-height: 1.1;
+$headings-color: inherit;
+
+
+//== Iconography
+//
+//## Specify custom location and filename of the included Glyphicons icon font. Useful for those including Bootstrap via Bower.
+
+//** Load fonts from this directory.
+$icon-font-path: "../fonts/";
+//** File name for all font files.
+$icon-font-name: "glyphicons-halflings-regular";
+//** Element ID within SVG icon file.
+$icon-font-svg-id: "glyphicons_halflingsregular";
+
+
+//== Components
+//
+//## Define common padding and border radius sizes and more. Values based on 14px text and 1@mixin 428 line-height (~20px to start).
+
+$padding-base-vertical: 6px;
+$padding-base-horizontal: 12px;
+
+$padding-large-vertical: 10px;
+$padding-large-horizontal: 16px;
+
+$padding-small-vertical: 5px;
+$padding-small-horizontal: 10px;
+
+$padding-xs-vertical: 1px;
+$padding-xs-horizontal: 5px;
+
+$line-height-large: 1.3333333; // extra decimals for Win 8.1 Chrome
+$line-height-small: 1.5;
+
+$border-radius-base: 4px;
+$border-radius-large: 6px;
+$border-radius-small: 3px;
+
+//** Global color for active items (e.g., navs or dropdowns).
+$component-active-color: #fff;
+//** Global background color for active items (e.g., navs or dropdowns).
+$component-active-bg: $brand-primary;
+
+//** Width of the `border` for generating carets that indicator dropdowns.
+$caret-width-base: 4px;
+//** Carets increase slightly in size for larger components.
+$caret-width-large: 5px;
+
+
+//== Tables
+//
+//## Customizes the `.table` component with basic values, each used across all table variations.
+
+//** Padding for ``s and ` `s.
+$table-cell-padding: 8px;
+//** Padding for cells in `.table-condensed`.
+$table-condensed-cell-padding: 5px;
+
+//** Default background color used for all tables.
+// $table-bg: transparent;
+$table-bg: #fff;
+//** Background color used for `.table-striped`.
+$table-bg-accent: #f9f9f9;
+//** Background color used for `.table-hover`.
+$table-bg-hover: #f5f5f5;
+$table-bg-active: $table-bg-hover;
+
+//** Border color for table and cell borders.
+$table-border-color: #ddd;
+
+
+//== Buttons
+//
+//## For each of Bootstrap's buttons, define text, background and border color.
+
+$btn-font-weight: normal;
+
+$btn-default-color: #333;
+$btn-default-bg: #fff;
+$btn-default-border: #ccc;
+
+$btn-primary-color: #fff;
+$btn-primary-bg: $brand-primary;
+$btn-primary-border: darken($btn-primary-bg, 5%);
+
+$btn-success-color: #fff;
+$btn-success-bg: $brand-success;
+$btn-success-border: darken($btn-success-bg, 5%);
+
+$btn-info-color: #fff;
+$btn-info-bg: $brand-info;
+$btn-info-border: darken($btn-info-bg, 5%);
+
+$btn-warning-color: #fff;
+$btn-warning-bg: $brand-warning;
+$btn-warning-border: darken($btn-warning-bg, 5%);
+
+$btn-danger-color: #fff;
+$btn-danger-bg: $brand-danger;
+$btn-danger-border: darken($btn-danger-bg, 5%);
+
+$btn-link-disabled-color: $gray-light;
+
+// Allows for customizing button radius independently from global border radius
+$btn-border-radius-base: $border-radius-base;
+$btn-border-radius-large: $border-radius-large;
+$btn-border-radius-small: $border-radius-small;
+
+
+//== Forms
+//
+//##
+
+//** `` background color
+$input-bg: #fff;
+//** `` background color
+$input-bg-disabled: $gray-lighter;
+
+//** Text color for ``s
+$input-color: $gray;
+//** `` border color
+$input-border: #ccc;
+
+// TODO: Rename `$input-border-radius` to `$input-border-radius-base` in v4
+//** Default `.form-control` border radius
+// This has no effect on `