@progress/kendo-ui
Version:
This package is part of the [Kendo UI for jQuery](http://www.telerik.com/kendo-ui) suite.
1,437 lines (1,209 loc) • 493 kB
JavaScript
import './kendo.data.js';
import './kendo.columnsorter.js';
import './kendo.editable.js';
import './kendo.window.js';
import './kendo.filtermenu.js';
import './kendo.filtercell.js';
import './kendo.columnmenu.js';
import './kendo.groupable.js';
import './kendo.pager.js';
import './kendo.selectable.js';
import './kendo.sortable.js';
import './kendo.reorderable.js';
import './kendo.resizable.js';
import './kendo.ooxml.js';
import './kendo.excel.js';
import './kendo.pane.js';
import './kendo.progressbar.js';
import './kendo.pdf.js';
import './kendo.dialog.js';
import './kendo.switch.js';
import './kendo.html.button.js';
import './kendo.textbox.js';
import './kendo.form.js';
import './kendo.toolbar.js';
import './kendo.icons.js';
var __meta__ = {
id: "grid",
name: "Grid",
category: "web",
description: "The Grid widget displays tabular data and offers rich support for interacting with data,including paging, sorting, grouping, and selection.",
depends: [ "data", "columnsorter", "sortable", "toolbar", "html.button", "icons" ],
features: [ {
id: "grid-editing",
name: "Editing",
description: "Support for record editing",
depends: [ "editable", "window", "textbox", "form" ]
}, {
id: "grid-filtering",
name: "Filtering",
description: "Support for record filtering",
depends: [ "filtermenu" ]
}, {
id: "grid-columnmenu",
name: "Column menu",
description: "Support for header column menu",
depends: [ "columnmenu" ]
}, {
id: "grid-grouping",
name: "Grouping",
description: "Support for grid grouping",
depends: [ "groupable" ]
}, {
id: "grid-filtercell",
name: "Row filter",
description: "Support for grid header filtering",
depends: [ "filtercell" ]
}, {
id: "grid-paging",
name: "Paging",
description: "Support for grid paging",
depends: [ "pager" ]
}, {
id: "grid-selection",
name: "Selection",
description: "Support for row selection",
depends: [ "selectable" ]
}, {
id: "grid-column-reorder",
name: "Column reordering",
description: "Support for column reordering",
depends: [ "reorderable" ]
}, {
id: "grid-column-resize",
name: "Column resizing",
description: "Support for column resizing",
depends: [ "resizable" ]
}, {
id: "grid-mobile",
name: "Grid adaptive rendering",
description: "Support for adaptive rendering",
depends: [ "dialog", "pane", "switch" ]
}, {
id: "grid-excel-export",
name: "Excel export",
description: "Export grid data as Excel spreadsheet",
depends: [ "excel" ]
}, {
id: "grid-pdf-export",
name: "PDF export",
description: "Export grid data as PDF",
depends: [ "pdf", "drawing", "progressbar" ]
} ]
};
(function($, undefined$1) {
var kendo = window.kendo,
ui = kendo.ui,
DataSource = kendo.data.DataSource,
ObservableObject = kendo.data.ObservableObject,
tbodySupportsInnerHtml = kendo.support.tbodyInnerHtml,
activeElement = kendo._activeElement,
Widget = ui.Widget,
outerWidth = kendo._outerWidth,
outerHeight = kendo._outerHeight,
keys = kendo.keys,
isPlainObject = $.isPlainObject,
extend = $.extend,
map = $.map,
grep = $.grep,
isArray = Array.isArray,
inArray = $.inArray,
push = Array.prototype.push,
isFunction = kendo.isFunction,
encode = kendo.htmlEncode,
isEmptyObject = $.isEmptyObject,
contains = $.contains,
math = Math,
DOT = ".",
PROGRESS = "progress",
ERROR = "error",
HIERARCHY_CELL_CLASS = "k-hierarchy-cell",
DATA_CELL = ":not(.k-group-cell):not([" + kendo.attr("virtual") + "]):not(.k-hierarchy-cell:not(:has(.k-icon.k-i-caret-alt-down,.k-icon.k-i-caret-alt-right,.k-svg-icon.k-svg-i-caret-alt-down,.k-svg-icon.k-svg-i-caret-alt-right))):visible",
SELECTION_CELL_SELECTOR = "tbody>tr:not(.k-grouping-row):not(.k-detail-row):not(.k-group-footer) > td:not(.k-group-cell):not(.k-hierarchy-cell)",
NAVROW = "tr:not(.k-footer-template):visible",
NAVCELL = ":not(.k-group-cell):not(.k-detail-cell):not(.k-hierarchy-cell):visible",
ITEMROW = "tr:not(.k-grouping-row):not(.k-detail-row):not(.k-footer-template):not(.k-group-footer):visible",
COLGROUP = "col:not(.k-group-col, .k-hierarchy-col)",
HEADERCELLS = "th.k-header:not(.k-group-cell):not(.k-hierarchy-cell)",
CARET_ALT_DOWN = "a[class*='-i-caret-alt-down']",
CARET_ALT_RIGHT = "a[class*='-i-caret-alt-right']",
WRAPPER = ".k-grid",
NS = ".kendoGrid",
CONTENTRLOCKEDCONTAINER = "k-grid-content-locked",
GROUPCELLCLASS = "k-group-cell",
EDIT = "edit",
BEFOREEDIT = "beforeEdit",
SAVE = "save",
REMOVE = "remove",
DETAILINIT = "detailInit",
FILTERMENUINIT = "filterMenuInit",
COLUMNMENUINIT = "columnMenuInit",
FILTERMENUOPEN = "filterMenuOpen",
COLUMNMENUOPEN = "columnMenuOpen",
CELLCLOSE = "cellClose",
CHANGE = "change",
COLUMNHIDE = "columnHide",
COLUMNSHOW = "columnShow",
SAVECHANGES = "saveChanges",
DATABOUND = "dataBound",
DETAILEXPAND = "detailExpand",
DETAILCOLLAPSE = "detailCollapse",
ITEM_CHANGE = "itemchange",
PAGE = "page",
PAGING = "paging",
SCROLL = "scroll",
SYNC = "sync",
LOAD_START = "loadStart",
LOAD_END = "loadEnd",
FOCUSED = "k-focus",
FOCUSABLE = ":kendoFocusable",
SELECTED = "k-selected",
CHECKBOX = "k-checkbox",
CHECKBOXINPUT = "input[data-role='checkbox'].k-select-checkbox." + CHECKBOX,
NORECORDSCLASS = "k-grid-norecords",
LINK_CLASS = "k-link",
ICON_CLASS = "k-icon",
SVG_ICON_CLASS = "k-svg-icon",
ORDER_CLASS = "k-sort-order",
SORTED_CLASS = "k-sorted",
HEADER_COLUMN_MENU_CLASS = "k-grid-column-menu",
FILTER_MENU_CLASS = "k-grid-filter-menu",
STICKY_CELL_CLASS = "k-grid-content-sticky k-table-td",
STICKY_HEADER_CLASS = "k-grid-header-sticky k-header",
STICKY_FOOTER_CLASS = "k-grid-footer-sticky k-table-td",
STICKY_HEADER_NO_BORDER_CLASS = "k-grid-no-left-border",
RESIZE = "resize",
COLUMNRESIZE = "columnResize",
COLUMNREORDER = "columnReorder",
COLUMNLOCK = "columnLock",
COLUMNUNLOCK = "columnUnlock",
COLUMNSTICK = "columnStick",
COLUMNUNSTICK = "columnUnstick",
ROWREORDER = "rowReorder",
NAVIGATE = "navigate",
CLICK = "click",
MOUSEDOWN = "mousedown",
HEIGHT = "height",
TABINDEX = "tabIndex",
FUNCTION = "function",
STRING = "string",
BOTTOM = "bottom",
CONTAINER_FOR = "container-for",
FIELD = "field",
INPUT = "input",
INCELL = "incell",
INLINE = "inline",
UNIQUE_ID = "uid",
MINCOLSPANVALUE = 1,
COLSPAN = "colSpan",
OVERFLOW = "overflow",
HIDDEN = "hidden",
SORT = "sort",
GROUP_SORT = "group-sort",
DELETECONFIRM = "Are you sure you want to delete this record?",
NORECORDS = "No records available.",
CONFIRMDELETE = "Delete",
CANCELDELETE = "Cancel",
COLLAPSE = "Collapse",
EXPAND = "Expand",
ID = "id",
ARIA_LABEL = "aria-label",
ARIA_OWNS = "aria-owns",
ARIA_ROWCOUNT = "aria-rowcount",
ARIA_COLCOUNT = "aria-colcount",
ARIA_CONTROLS = "aria-controls",
ARIA_COLINDEX = "aria-colindex",
ARIA_ROWINDEX = "aria-rowindex",
ARIA_EXPANDED = "aria-expanded",
ARIA_CHECKED = "aria-checked",
ARIA_ACTIVEDESCENDANT = "aria-activedescendant",
ROLE = "role",
NONE = "none",
ROW = "row",
ROWGROUP = "rowgroup",
COLUMNHEADER = "columnheader",
GRIDCELL = "gridcell",
formatRegExp = /(\}|\#)/ig,
templateHashRegExp = /#/ig,
whitespaceRegExp = "[\\x20\\t\\r\\n\\f]",
leftRegExp = new RegExp("(\\s*left\\s*:\\s*\\d*px;?)*", "ig"),
rightRegExp = new RegExp("(\\s*right\\s*:\\s*\\d*px;?)*", "ig"),
nonDataCellsRegExp = new RegExp("(^|" + whitespaceRegExp + ")" + "(k-group-cell|k-hierarchy-cell)" + "(" + whitespaceRegExp + "|$)"),
filterRowRegExp = new RegExp("(^|" + whitespaceRegExp + ")" + "(k-filter-row)" + "(" + whitespaceRegExp + "|$)"),
COMMANDBUTTONTMPL = ({ className, attr, text }) => `<button type="button" class="${className}" ${attr}>${text}</button>`,
SELECTCOLUMNTMPL = ({ size }) => `<input tabindex="-1" class="k-select-checkbox ` + CHECKBOX + ` ${size} k-rounded-md" data-role="checkbox" aria-label="Select row" aria-checked="false" type="checkbox">`,
SELECTCOLUMNHEADERTMPL = ({ size }) => `<input tabindex="-1" class="k-select-checkbox ` + CHECKBOX + ` ${size} k-rounded-md" data-role="checkbox" aria-label="Select all rows" aria-checked="false" type="checkbox">`,
DRAGHANDLECOLUMNTMPL = () => kendo.ui.icon("reorder"),
SORTHEADERTMPL = ({ text }) => `<span class="k-cell-inner"><span class="k-link"><span class="k-column-title">${text}</span></span></span>`,
isRtl = false,
browser = kendo.support.browser;
var isIE11 = browser.msie && browser.version === 11;
var isMac = /Mac OS/.test(navigator.userAgent);
var classNames = {
content: "k-content",
scrollContainer: "k-scroll-container",
headerCellInner: "k-cell-inner"
};
var GroupsPager;
if (ui.Pager) {
GroupsPager = ui.Pager.extend({
init: function(element, options) {
ui.Pager.fn.init.call(this, element, extend(true, {}, options));
this.dataSource.options.useRanges = true;
this.dataSource._omitPrefetch = true;
},
options: {
name: "GroupsPager"
},
totalPages: function() {
var that = this;
return Math.ceil((that._collapsedTotal() || 0) / (that.pageSize() || 1));
},
_collapsedTotal: function() {
var dataSource = this.dataSource;
return dataSource ? (dataSource.groupsTotal(true) || 0) : 0;
}
});
}
var VirtualScrollable = Widget.extend({
init: function(element, options) {
var that = this;
Widget.fn.init.call(that, element, options);
that._refreshHandler = that.refresh.bind(that);
that.setDataSource(options.dataSource);
that.wrap();
},
setDataSource: function(dataSource) {
var that = this;
if (that.dataSource) {
that.dataSource.unbind(CHANGE, that._refreshHandler);
}
that.dataSource = dataSource;
that.dataSource.bind(CHANGE, that._refreshHandler);
that.dataSource.options.useRanges = true;
that.dataSource.options.virtual = true;
},
options: {
name: "VirtualScrollable",
itemHeight: $.noop,
prefetch: true,
maxScrollHeight: 250000
},
events: [
PAGING,
PAGE,
SCROLL,
LOAD_START,
LOAD_END
],
destroy: function() {
var that = this;
Widget.fn.destroy.call(that);
that.dataSource.unbind(CHANGE, that._refreshHandler);
that.wrapper.add(that.verticalScrollbar).off(NS);
clearTimeout(that._timeout);
if (that._scrollingTimeout) {
clearTimeout(that._scrollingTimeout);
}
if (that.drag) {
that.drag.destroy();
that.drag = null;
}
that.wrapper = that.element = that.verticalScrollbar = null;
that._refreshHandler = null;
},
wrap: function() {
var that = this,
// workaround for IE issue where scroll is not raised if container is same width as the scrollbar
scrollbar = kendo.support.scrollbar() + 1,
element = that.element,
wrapper;
element.css( {
width: "auto",
overflow: "hidden"
}).css((isRtl ? "padding-left" : "padding-right"), scrollbar);
that.content = element.children().first();
wrapper = that.wrapper = that.content.wrap('<div class="k-virtual-scrollable-wrap"/>')
.parent()
.on("DOMMouseScroll" + NS + " mousewheel" + NS, that._wheelScroll.bind(that));
that._wrapper();
if (kendo.support.kineticScrollNeeded || kendo.support.touch) {
that.wrapper.css("touch-action", NONE);
that.drag = new kendo.UserEvents(that.wrapper, {
global: true,
allowSelection: true,
start: function(e) {
e.sender.capture();
},
move: function(e) {
that.verticalScrollbar.scrollTop(that.verticalScrollbar.scrollTop() - e.y.delta);
kendo.scrollLeft(wrapper, kendo.scrollLeft(wrapper) - e.x.delta);
e.preventDefault();
}
});
}
that.verticalScrollbar = $('<div class="k-scrollbar k-scrollbar-vertical" />')
.css({
width: scrollbar
}).appendTo(element)
.on("scroll" + NS, that._scroll.bind(that));
},
_wrapper: function() {
var that = this;
if (isIE11) {
//scrolling the virtual scrollbar to the bottom and then
//scrolling the horizontal content scrollbar does not fire the "scroll" event
//seems like a problem in IE 11 only (after version 11.0.9600.18860)
//https://github.com/telerik/kendo-ui-core/issues/3779
that.wrapper.css({
"overflow-y": SCROLL
});
//hide the wrapper behind the virtual scrollbar
that.element.css((isRtl ? "padding-left" : "padding-right"), 0);
}
},
_wheelScroll: function(e) {
if (e.ctrlKey) {
return;
}
var scrollbar = this.verticalScrollbar,
scrollTop = scrollbar.scrollTop(),
delta = kendo.wheelDeltaY(e);
if (delta && !(delta > 0 && scrollTop === 0) && !(delta < 0 && scrollTop + scrollbar[0].clientHeight == scrollbar[0].scrollHeight)) {
e.preventDefault();
this.verticalScrollbar.scrollTop(scrollTop + (-delta));
}
},
_scroll: function(e) {
var that = this,
delayLoading = !that.options.prefetch,
scrollTop = e.currentTarget.scrollTop,
dataSource = that.dataSource,
rowHeight = that.itemHeight,
skip = dataSource.skip() || 0,
start = that._rangeStart || skip,
height = that.element.innerHeight(),
isScrollingUp = !!(that._scrollbarTop && that._scrollbarTop > scrollTop),
firstItemIndex = math.max(math.floor(scrollTop / rowHeight), 0),
lastItemOffset = isScrollingUp ? math.ceil(height / rowHeight) : math.floor(height / rowHeight),
lastItemIndex = math.max(firstItemIndex + lastItemOffset, 0);
if (that._preventScroll) {
that._preventScroll = false;
return;
}
that._prevScrollTop = that._scrollTop;
that._scrollTop = scrollTop - (start * rowHeight);
that._scrollbarTop = scrollTop;
that._scrolling = delayLoading;
if (!that._fetch(firstItemIndex, lastItemIndex, isScrollingUp)) {
that.wrapper[0].scrollTop = that._scrollTop;
}
that.trigger(SCROLL);
if (delayLoading) {
if (that._scrollingTimeout) {
clearTimeout(that._scrollingTimeout);
}
that._scrollingTimeout = setTimeout(function() {
that._scrolling = false;
that._page(that._rangeStart, that.dataSource.take());
}, 100);
}
},
scrollToTop: function() {
this._scrollTo(0);
},
scrollToBottom: function() {
var scrollbar = this.verticalScrollbar;
this._scrollTo(scrollbar[0].scrollHeight - scrollbar.height());
},
_scrollWrapperToTop: function() {
this.wrapper.scrollTop(0);
},
_scrollWrapperToBottom: function() {
this.wrapper.scrollTop(this.wrapper[0].scrollHeight);
},
_scrollWrapperOnColumnResize: function() {
var that = this;
var wrapper = this.wrapper;
var initialScrollTop = wrapper.scrollTop();
if (wrapper[0].scrollWidth > wrapper[0].clientWidth) {
if ((!that._wrapperScrolled && initialScrollTop) || that._isScrolledToBottom()) {
wrapper.scrollTop(initialScrollTop + kendo.support.scrollbar());
that._scrollTop = wrapper.scrollTop();
that._wrapperScrolled = true;
}
} else if (that._wrapperScrolled) {
if (!that._isWrapperScrolledToBottom()) {
wrapper.scrollTop(initialScrollTop - kendo.support.scrollbar());
that._scrollTop = wrapper.scrollTop();
}
that._wrapperScrolled = false;
}
},
_scrollTo: function(scrollTop) {
var that = this;
var scrollbar = that.verticalScrollbar;
if (scrollbar.scrollTop() !== scrollTop) {
that._preventScroll = true;
}
that.wrapper.scrollTop(scrollTop);
that._scrollTop = that.wrapper.scrollTop();
scrollbar.scrollTop(scrollTop);
that._scrollbarTop = scrollbar.scrollTop();
},
_isScrolledToTop: function() {
return this.verticalScrollbar.scrollTop() === 0;
},
_isScrolledToBottom: function() {
var scrollbar = this.verticalScrollbar;
var scrollTop = scrollbar.scrollTop();
return (scrollTop > 0 && scrollTop >= parseInt(scrollbar[0].scrollHeight - scrollbar.height(), 10));
},
_isWrapperScrolledToBottom: function() {
var wrapper = this.wrapper;
return (wrapper.scrollTop() >= parseInt(wrapper[0].scrollHeight - wrapper.height(), 10));
},
itemIndex: function(rowIndex) {
var rangeStart = this._rangeStart || this.dataSource.skip() || 0;
return rangeStart + rowIndex;
},
position: function(index) {
var rangeStart = this._rangeStart || this.dataSource.skip() || 0;
var pageSize = this.dataSource.pageSize();
var result;
if (index > rangeStart) {
result = index - rangeStart;
} else {
result = rangeStart - index - 1;
}
return result > pageSize ? pageSize : result;
},
scrollIntoView: function(row) {
var container = this.wrapper[0];
var containerHeight = container.clientHeight;
var containerScroll = !this._isScrolledToBottom() ? (this._scrollTop || container.scrollTop) : container.scrollTop;
var elementOffset = row[0].offsetTop;
var elementHeight = row[0].offsetHeight;
if (containerScroll > elementOffset) {
this.verticalScrollbar[0].scrollTop -= containerHeight / 2;
} else if (elementOffset + elementHeight >= containerScroll + containerHeight) {
this.verticalScrollbar[0].scrollTop += containerHeight / 2;
}
},
_fetch: function(firstItemIndex, lastItemIndex, scrollingUp) {
var that = this,
dataSource = that.dataSource,
itemHeight = that.itemHeight,
take = dataSource.take(),
rangeStart = that._rangeStart || dataSource.skip() || 0,
currentSkip = math.floor(firstItemIndex / take) * take,
fetching = false,
prefetchAt = 0.33;
var scrollbar = that.verticalScrollbar;
var webkitCorrection = browser.webkit ? 1 : 0;
var total = dataSource._isGroupPaged() ? dataSource.groupsTotal(true) : dataSource.total();
if (firstItemIndex < rangeStart) {
fetching = true;
rangeStart = math.max(0, lastItemIndex - take);
that._scrollTop = scrollbar.scrollTop() - (rangeStart * itemHeight);
that._page(rangeStart, take);
} else if (lastItemIndex >= rangeStart + take && !scrollingUp) {
fetching = true;
rangeStart = math.min(firstItemIndex, total - take);
//ensure the scrollbar can be scrolled to bottom with mouse drag
if (scrollbar.scrollTop() >= scrollbar[0].scrollHeight - scrollbar[0].offsetHeight - webkitCorrection) {
that._scrollTop = that.wrapper[0].scrollHeight - that.wrapper[0].offsetHeight;
} else if (that.dataSource._isGroupPaged() && firstItemIndex >= total - take) {
that._scrollTop = that.wrapper[0].scrollHeight - that.wrapper[0].offsetHeight - (that._scrollTop - that._prevScrollTop);
} else {
that._scrollTop = itemHeight;
}
that._page(rangeStart, take);
} else if (!that._fetching && that.options.prefetch) {
if (firstItemIndex < (currentSkip + take) - take * prefetchAt && firstItemIndex > take) {
dataSource.prefetch(currentSkip - take, take, $.noop);
}
if (lastItemIndex > currentSkip + take * prefetchAt) {
dataSource.prefetch(currentSkip + take, take, $.noop);
}
}
return fetching;
},
fetching: function() {
return this._fetching;
},
_page: function(skip, take, callback) {
var that = this,
delayLoading = !that.options.prefetch,
dataSource = that.dataSource,
isGroupPaged = dataSource._isGroupPaged();
callback = isFunction(callback) ? callback : $.noop;
if (that.trigger(PAGING, { skip: skip, take: take })) {
return;
}
clearTimeout(that._timeout);
that._fetching = true;
that._rangeStart = skip;
if ((isGroupPaged && dataSource._groupRangeExists(skip, skip + take)) || (!isGroupPaged && dataSource.inRange(skip, take))) {
that.trigger(LOAD_START);
dataSource.range(skip, take, function() {
that.trigger(LOAD_END);
callback();
that.trigger(PAGE);
}, "page");
} else {
if (!delayLoading) {
that.trigger(LOAD_START);
}
that._timeout = setTimeout(function() {
if (!that._scrolling) {
if (delayLoading) {
that.trigger(LOAD_START);
}
dataSource.range(skip, take, function() {
that.trigger(LOAD_END);
callback();
that.trigger(PAGE);
});
}
}, 100);
}
},
repaintScrollbar: function(shouldScrollWrapper) {
var that = this,
html = "",
maxHeight = that.options.maxScrollHeight,
dataSource = that.dataSource,
scrollbar = !kendo.support.kineticScrollNeeded ? kendo.support.scrollbar() : 0,
wrapperElement = that.wrapper[0],
totalHeight,
idx,
itemHeight;
var wasScrolledToBottom = that._isScrolledToBottom();
itemHeight = that.itemHeight = that.options.itemHeight() || 0;
var addScrollBarHeight = (wrapperElement.scrollWidth > wrapperElement.offsetWidth) ? scrollbar : 0;
totalHeight = (dataSource._isGroupPaged() ? dataSource.groupsTotal(true) : dataSource.total()) * itemHeight + addScrollBarHeight;
for (idx = 0; idx < math.floor(totalHeight / maxHeight); idx++) {
html += '<div style="width:1px;height:' + maxHeight + 'px"></div>';
}
if (totalHeight % maxHeight) {
html += '<div style="width:1px;height:' + (totalHeight % maxHeight) + 'px"></div>';
}
that.verticalScrollbar.html(html);
if (wasScrolledToBottom && !that._isScrolledToBottom() && !that.dataSource._isGroupPaged()) {
that.scrollToBottom();
}
if (typeof(that._scrollTop) !== "undefined" && !!shouldScrollWrapper) {
wrapperElement.scrollTop = that._scrollTop;
that._scrollWrapperOnColumnResize();
}
},
refresh: function(e) {
var that = this,
dataSource = that.dataSource,
rangeStart = that._rangeStart;
var action = (e || {}).action;
var shouldScrollWrapper = that._isScrolledToBottom() || !action || (action !== ITEM_CHANGE && action !== REMOVE && action !== SYNC);
that.trigger(LOAD_END);
clearTimeout(that._timeout);
that.repaintScrollbar(shouldScrollWrapper);
if (that.drag) {
that.drag.cancel();
}
if (typeof(rangeStart) !== "undefined" && !that._fetching) { // we are rebound from outside local range should be reset
if (!action || (action !== SYNC && action !== ITEM_CHANGE && action !== "expandGroup")) {
that._rangeStart = dataSource.skip();
}
if (dataSource.page() === 1 && (!action || (action !== SYNC && action !== ITEM_CHANGE && action !== "expandGroup" && action !== "collapseGroup"))) {
// reset the scrollbar position if datasource is filtered
that.verticalScrollbar[0].scrollTop = 0;
}
}
that._fetching = false;
}
});
function attrEquals(attrName, attrValue) {
return "[" + kendo.attr(attrName) + "=" + attrValue + "]";
}
function groupCells(count) {
return new Array(count + 1).join('<td class="k-table-td k-group-cell"> </td>');
}
function stringifyAttributes(attributes) {
var attr,
result = " ";
if (attributes) {
if (typeof attributes === STRING) {
return attributes;
}
for (attr in attributes) {
if (attributes[attr] !== '') {
result += attr + '="' + attributes[attr] + '"';
}
}
}
return result;
}
var defaultCommands = {
create: {
text: "Add new record",
className: "k-grid-add",
iconClass: "k-i-plus"
},
cancel: {
text: "Cancel changes",
className: "k-grid-cancel-changes",
iconClass: "k-i-cancel"
},
save: {
text: "Save changes",
className: "k-grid-save-changes",
iconClass: "k-i-check"
},
destroy: {
text: "Delete",
className: "k-grid-remove-command",
iconClass: "k-i-x"
},
edit: {
text: "Edit",
className: "k-grid-edit-command",
iconClass: "k-i-pencil",
themeColor: "primary"
},
update: {
text: "Save",
className: "k-grid-save-command",
iconClass: "k-i-save",
themeColor: "primary"
},
canceledit: {
text: "Cancel",
className: "k-grid-cancel-command",
iconClass: "k-i-cancel-outline"
},
excel: {
text: "Export to Excel",
className: "k-grid-excel",
iconClass: "k-i-file-excel"
},
pdf: {
text: "Export to PDF",
className: "k-grid-pdf",
iconClass: "k-i-file-pdf"
},
search: {
text: "Search...",
className: "k-grid-search"
}
};
function cursor(context, value) {
$('th, th .k-grid-filter-menu, th .k-link', context)
.add(document.body)
.css('cursor', value);
}
function reorder(selector, source, dest, before, count) {
var sourceIndex = source;
source = $();
count = count || 1;
for (var idx = 0; idx < count; idx++) {
source = source.add(selector.eq(sourceIndex + idx));
}
if (typeof dest == "number") {
source[before ? "insertBefore" : "insertAfter"](selector.eq(dest));
} else {
source.appendTo(dest);
}
}
function elements(lockedContent, content, filter) {
return $(lockedContent).add(content).find(filter);
}
function attachCustomCommandEvent(context, container, commands) {
var idx,
length,
command,
commandName;
commands = !isArray(commands) ? [commands] : commands;
for (idx = 0, length = commands.length; idx < length; idx++) {
command = commands[idx];
if (isPlainObject(command) && command.click) {
commandName = command.name || command.text;
container.on(CLICK + NS, ".k-grid-" + (commandName || "").replace(/\s/g, ""), { commandName: commandName }, command.click.bind(context));
}
}
}
function normalizeColumns(columns, encoded, hide, locked, parentIds) {
return map(columns, function(column) {
column = typeof column === STRING ? { field: column } : column;
var hidden;
column.parentIds = parentIds;
if (!isVisible(column) || hide) {
column.attributes = addHiddenStyle(column.attributes);
column.footerAttributes = addHiddenStyle(column.footerAttributes);
column.headerAttributes = addHiddenStyle(column.headerAttributes);
hidden = true;
}
var uid = kendo.guid();
if (locked && !column.locked) {
column.locked = locked;
}
column.headerAttributes = extend({ headers: parentIds }, column.headerAttributes);
if (!column.headerAttributes.id) {
column.headerAttributes = extend({ id: uid }, column.headerAttributes);
column.uid = uid;
} else {
column.uid = uid = column.headerAttributes.id;
}
if (column.columns) {
column.columns = normalizeColumns(column.columns, encoded, hidden, column.locked, parentIds ? (parentIds + " " + uid) : uid);
}
return extend({ encoded: encoded, hidden: hidden, locked: locked }, column);
});
}
function columnParent(column, columns) {
var parents = [];
columnParents(column, columns, parents);
return parents[parents.length - 1];
}
function columnParents(column, columns, parents) {
parents = parents || [];
for (var idx = 0; idx < columns.length; idx++) {
if (column === columns[idx]) {
return true;
} else if (columns[idx].columns) {
var inserted = parents.length;
parents.push(columns[idx]);
if (!columnParents(column, columns[idx].columns, parents)) {
parents.splice(inserted, parents.length - inserted);
} else {
return true;
}
}
}
return false;
}
function setColumnVisibility(column, visible) {
setVisibility(column, visible, visible);
}
function setVisibility(column, visible, show) {
var method = show ? removeHiddenStyle : addHiddenStyle;
column.hidden = !visible;
column.attributes = method(column.attributes);
column.footerAttributes = method(column.footerAttributes);
column.headerAttributes = method(column.headerAttributes);
}
function setColumnMediaVisibility(column, visible) {
setColumnMatchesMedia(column);
var hideByMedia = column._hideByMedia;
setVisibility(column, visible, hideByMedia ? column.matchesMedia : visible);
}
function setColumnMatchesMedia(column) {
column.matchesMedia = columnMatchesMedia(column);
}
function columnMatchesMedia(column) {
return column && (isUndefined(column.media) || (!isUndefined(column.media) && kendo.matchesMedia(column.media)));
}
function isCellVisible() {
return this.style.display !== NONE;
}
function isElementVisible(element) {
return $(element)[0].style.display !== NONE;
}
function isVisible(column) {
return visibleColumns([column]).length > 0;
}
function visibleColumns(columns) {
return grep(columns, function(column) {
var result = !column.hidden && column.matchesMedia !== false;
if (result && column.columns) {
result = visibleColumns(column.columns).length > 0;
}
return result;
});
}
function columnsWithMedia(columns) {
var result = [];
var column;
for (var i = 0; i < columns.length; i++) {
column = columns[i];
if (!isUndefined(column.media)) {
if (!isUndefined(column.minScreenWidth)) {
throw new Error("Using 'media' and 'minScreenWidth' options at the same time is not supported.");
}
result.push(column);
}
if (column.columns) {
result = result.concat(columnsWithMedia(column.columns));
}
}
return result;
}
function isUndefined(value) {
return typeof value === "undefined";
}
function toJQuery(elements) {
return $(elements).map(function() { return this.toArray(); });
}
function updateCellRowSpan(cell, columns, sourceLockedColumnsCount) {
var lockedColumnDepth = depth(lockedColumns(columns));
var nonLockedColumnDepth = depth(nonLockedColumns(columns));
var rowSpan = cell.rowSpan;
if (sourceLockedColumnsCount) {
if (lockedColumnDepth > nonLockedColumnDepth) {
cell.rowSpan = (rowSpan - (lockedColumnDepth - nonLockedColumnDepth)) || 1;
} else {
cell.rowSpan = rowSpan + (nonLockedColumnDepth - lockedColumnDepth);
}
} else {
if (lockedColumnDepth > nonLockedColumnDepth) {
cell.rowSpan = rowSpan + (lockedColumnDepth - nonLockedColumnDepth);
} else {
cell.rowSpan = (rowSpan - (nonLockedColumnDepth - lockedColumnDepth)) || 1;
}
}
}
function findColumnByField(columns, field) {
for (var i = 0; i < columns.length; i++) {
if (columns[i].field == field) {
return columns[i];
}
}
}
function moveCellsBetweenContainers(sources, target, leafs, columns, container, destination, groups, action) {
var sourcesDepth = depth(sources);
var targetDepth = depth([target]);
if (sourcesDepth > targetDepth) {
var groupCells = new Array(groups + 1).join('<th class="k-group-cell k-header k-table-th" scope="col"> </th>');
var rows = destination.children(":not(.k-filter-row)");
$(new Array((sourcesDepth - targetDepth) + 1).join("<tr class='k-table-row'>" + groupCells + "</tr>")).insertAfter(rows.last());
}
addRowSpanValue(destination, sourcesDepth - targetDepth);
moveCells(leafs, columns, container, destination, action);
}
function updateCellIndex(thead, columns, offset) {
offset = offset || 0;
var position;
var cell;
var allColumns = columns;
columns = leafColumns(columns);
var cells = {};
var rows = thead.find(">tr:not(.k-filter-row)");
var filter = function() {
var el = $(this);
return !el.hasClass("k-group-cell") && !el.hasClass("k-hierarchy-cell");
};
for (var idx = 0, length = columns.length; idx < length; idx++) {
position = columnPosition(columns[idx], allColumns);
if (!cells[position.row]) {
cells[position.row] = rows.eq(position.row)
.find(".k-header")
.filter(filter);
}
cell = cells[position.row].eq(position.cell);
cell.attr(kendo.attr("index"), offset + idx);
}
return columns.length;
}
function depth(columns) {
var result = 1;
var max = 0;
for (var idx = 0; idx < columns.length; idx++) {
if (columns[idx].columns) {
var temp = depth(columns[idx].columns);
if (temp > max) {
max = temp;
}
}
}
return result + max;
}
function moveCells(leafs, columns, container, destination, action) {
var sourcePosition = columnVisiblePosition(leafs[0], columns);
var ths = container.find(">tr:not(.k-filter-row)").eq(sourcePosition.row).children("th.k-header");
var t = $();
var sourceIndex = sourcePosition.cell;
var idx;
for (idx = 0; idx < leafs.length; idx++) {
t = t.add(ths.eq(sourceIndex + idx));
}
destination.find(">tr:not(.k-filter-row)").eq(sourcePosition.row)[action](t);
var children = [];
for (idx = 0; idx < leafs.length; idx++) {
if (leafs[idx].columns) {
children = children.concat(leafs[idx].columns);
}
}
if (children.length) {
moveCells(children, columns, container, destination, action);
}
}
function columnPosition(column, columns, row, cellCounts) {
var result;
var idx;
row = row || 0;
cellCounts = cellCounts || {};
cellCounts[row] = cellCounts[row] || 0;
for (idx = 0; idx < columns.length; idx++) {
if (columns[idx] == column) {
result = { cell: cellCounts[row], row: row };
break;
} else if (columns[idx].columns) {
result = columnPosition(column, columns[idx].columns, row + 1, cellCounts);
if (result) {
break;
}
}
cellCounts[row]++;
}
return result;
}
function findParentColumnWithChildren(columns, index, source, rtl) {
var target;
var locked = !!source.locked;
var targetLocked;
do {
target = columns[index];
index += rtl ? 1 : -1;
targetLocked = !!target.locked;
} while (target && index > -1 && index < columns.length && target != source && !target.columns && targetLocked === locked);
return target;
}
function decorateCellWithClass(html) {
let element = html;
if (element.indexOf("class") !== -1) {
const cssClasses = element.match(/class=["][^"]+/g)[0].split('\"').pop();
element = element.replace(cssClasses, cssClasses + " k-table-td");
} else {
element = element.replace("<td","<td class='k-table-td'");
}
return element;
}
function findReorderTarget(columns, target, source, before, masterColumns) {
if (target.columns) {
target = target.columns;
return target[before ? 0 : target.length - 1];
} else {
var parent = columnParent(target, columns);
var parentColumns;
if (parent) {
parentColumns = parent.columns;
} else {
parentColumns = columns;
}
var index = inArray(target, parentColumns);
if (index === 0 && before) {
index++;
} else if ((index == parentColumns.length - 1 && !before) || (!source.locked && !target.columns && !before)) {
index--;
} else if (index > 0 || (index === 0 && !before)) {
index++;
}
var sourceIndex = inArray(source, parentColumns);
target = findParentColumnWithChildren(parentColumns, index, source, sourceIndex > index);
var targetIndex = inArray(target, masterColumns);
if (target.columns && (!targetIndex || targetIndex === parentColumns.length - 1)) {
return null;
}
if (target && target != source && target.columns) {
return findReorderTarget(columns, target, source, before, masterColumns);
}
}
return null;
}
function columnVisiblePosition(column, columns, row, cellCounts) {
var result;
var idx;
row = row || 0;
cellCounts = cellCounts || {};
cellCounts[row] = cellCounts[row] || 0;
for (idx = 0; idx < columns.length; idx++) {
if (columns[idx] == column) {
result = { cell: cellCounts[row], row: row };
break;
} else if (columns[idx].columns) {
result = columnVisiblePosition(column, columns[idx].columns, row + 1, cellCounts);
if (result) {
break;
}
}
if (!columns[idx].hidden) {
cellCounts[row]++;
}
}
return result;
}
function flatColumnsInDomOrder(columns) {
var result = flatColumns(lockedColumns(columns));
return result.concat(flatColumns(nonLockedColumns(columns)));
}
function targetParentContainerIndex(flatColumns, columns, sourceIndex, targetIndex) {
var column = flatColumns[sourceIndex];
var target = flatColumns[targetIndex];
var parent = columnParent(column, columns);
columns = parent ? parent.columns : columns;
return inArray(target, columns);
}
function flatColumns(columns) {
var result = [];
var children = [];
for (var idx = 0; idx < columns.length; idx++) {
result.push(columns[idx]);
if (columns[idx].columns) {
children = children.concat(columns[idx].columns);
}
}
if (children.length) {
result = result.concat(flatColumns(children));
}
return result;
}
function hiddenLeafColumnsCount(columns) {
var counter = 0;
var column;
for (var idx = 0; idx < columns.length; idx++) {
column = columns[idx];
if (column.columns) {
counter += hiddenLeafColumnsCount(column.columns);
} else if (column.hidden) {
counter++;
}
}
return counter;
}
function sumWidths(cols) {
var width = 0;
for (var idx = 0, length = cols.length; idx < length; idx++) {
if (!cols[idx].hidden) {
width += parseInt(cols[idx].width, 10);
}
}
return width;
}
function columnsWidth(cols) {
var colWidth, width = 0;
for (var idx = 0, length = cols.length; idx < length; idx++) {
colWidth = cols[idx].style.width;
if (colWidth && colWidth.indexOf("%") == -1) {
width += parseInt(colWidth, 10);
}
}
return width;
}
function removeRowSpanValue(container, count) {
var cells = container.find("tr:not(.k-filter-row) th:not(.k-group-cell,.k-hierarchy-cell)");
var rowSpan;
for (var idx = 0; idx < cells.length; idx++) {
rowSpan = cells[idx].rowSpan;
if (rowSpan > 1) {
cells[idx].rowSpan = (rowSpan - count) || 1;
}
}
}
function addRowSpanValue(container, count) {
var cells = container.find("tr:not(.k-filter-row) th:not(.k-group-cell,.k-hierarchy-cell)");
for (var idx = 0; idx < cells.length; idx++) {
cells[idx].rowSpan += count;
}
}
function removeEmptyRows(container) {
var rows = container.find("tr:not(.k-filter-row)");
var emptyRowsCount = rows.filter(function() {
return !$(this).children().length;
}).remove().length;
var cells = rows.find("th:not(.k-group-cell,.k-hierarchy-cell)");
for (var idx = 0; idx < cells.length; idx++) {
if (cells[idx].rowSpan > 1) {
cells[idx].rowSpan -= emptyRowsCount;
}
}
return rows.length - emptyRowsCount;
}
function mapColumnToCellRows(columns, cells, rows, rowIndex, offset) {
var idx, row, length, children = [];
for (idx = 0, length = columns.length; idx < length; idx++) {
row = rows[rowIndex] || [];
row.push(cells.eq(offset + idx));
rows[rowIndex] = row;
if (columns[idx].columns) {
children = children.concat(columns[idx].columns);
}
}
if (children.length) {
mapColumnToCellRows(children, cells, rows, rowIndex + 1, offset + columns.length);
}
}
function setLeftAndRightStyles(element, left, right) {
element.css({
"left": left,
"right": right
});
}
function createColumnAttribute(column, attribute, property) {
column[attribute] = column[attribute] || {};
column[attribute][property] = column[attribute][property] || "";
}
function addColumnAttribute(column, attribute, property, value) {
createColumnAttribute(column, attribute, property);
if (column[attribute][property] !== "") {
column[attribute][property] += " " + value;
} else {
column[attribute][property] = value;
}
}
function removeColumnAttribute(column, attribute, property, value) {
createColumnAttribute(column, attribute, property);
column[attribute][property] = column[attribute][property].replace(value, "");
}
function lockedColumns(columns) {
return grep(columns, function(column) {
return column.locked;
});
}
function nonLockedColumns(columns) {
return grep(columns, function(column) {
return !column.locked;
});
}
function stickyColumns(columns) {
return grep(columns, function(column) {
return column.sticky && !column.locked;
});
}
function visibleStickyColumns(columns) {
return grep(columns, function(column) {
return column.sticky && !column.locked && isVisible(column);
});
}
function visibleNonLockedColumns(columns) {
return grep(columns, function(column) {
return !column.locked && isVisible(column);
});
}
function visibleLockedColumns(columns) {
return grep(columns, function(column) {
return column.locked && isVisible(column);
});
}
function visibleLeafColumns(columns) {
var result = [];
for (var idx = 0; idx < columns.length; idx++) {
if (columns[idx].hidden) {
continue;
}
if (columns[idx].columns) {
result = result.concat(visibleLeafColumns(columns[idx].columns));
} else {
result.push(columns[idx]);
}
}
return result;
}
function visibleLeafExportColumns(columns) {
var result = [];
for (var idx = 0; idx < columns.length; idx++) {
if (columns[idx].hidden) {
continue;
}
if (columns[idx].columns) {
result = result.concat(visibleLeafColumns(columns[idx].columns));
} else {
result.pus