@progress/kendo-ui
Version:
This package is part of the [Kendo UI for jQuery](http://www.telerik.com/kendo-ui) suite.
1,452 lines (1,188 loc) • 398 kB
JavaScript
module.exports =
/******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId])
/******/ return installedModules[moduleId].exports;
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ exports: {},
/******/ id: moduleId,
/******/ loaded: false
/******/ };
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/ // Flag the module as loaded
/******/ module.loaded = true;
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/ // Load entry module and return exports
/******/ return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ({
/***/ 0:
/***/ (function(module, exports, __webpack_require__) {
module.exports = __webpack_require__(1200);
/***/ }),
/***/ 3:
/***/ (function(module, exports) {
module.exports = function() { throw new Error("define cannot be used indirect"); };
/***/ }),
/***/ 1005:
/***/ (function(module, exports) {
module.exports = require("jquery");
/***/ }),
/***/ 1015:
/***/ (function(module, exports) {
module.exports = require("./kendo.data");
/***/ }),
/***/ 1030:
/***/ (function(module, exports) {
module.exports = require("./kendo.selectable");
/***/ }),
/***/ 1043:
/***/ (function(module, exports) {
module.exports = require("./kendo.filtermenu");
/***/ }),
/***/ 1142:
/***/ (function(module, exports) {
module.exports = require("./kendo.resizable");
/***/ }),
/***/ 1143:
/***/ (function(module, exports) {
module.exports = require("./kendo.window");
/***/ }),
/***/ 1193:
/***/ (function(module, exports) {
module.exports = require("./kendo.pdf");
/***/ }),
/***/ 1196:
/***/ (function(module, exports) {
module.exports = require("./kendo.columnsorter");
/***/ }),
/***/ 1198:
/***/ (function(module, exports) {
module.exports = require("./kendo.editable");
/***/ }),
/***/ 1200:
/***/ (function(module, exports, __webpack_require__) {
var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/* WEBPACK VAR INJECTION */(function(jQuery) {(function(f, define){
!(__WEBPACK_AMD_DEFINE_ARRAY__ = [
__webpack_require__(1015),
__webpack_require__(1196),
__webpack_require__(1198),
__webpack_require__(1143),
__webpack_require__(1043),
__webpack_require__(1201),
__webpack_require__(1202),
__webpack_require__(1203),
__webpack_require__(1030),
__webpack_require__(1204),
__webpack_require__(1205),
__webpack_require__(1142),
__webpack_require__(1206),
__webpack_require__(1207),
__webpack_require__(1208),
__webpack_require__(1209),
__webpack_require__(1193)
], __WEBPACK_AMD_DEFINE_FACTORY__ = (f), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
})(function(){
var __meta__ = { // jshint ignore:line
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" ],
features: [ {
id: "grid-editing",
name: "Editing",
description: "Support for record editing",
depends: [ "editable", "window" ]
}, {
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: [ "mobile.actionsheet", "mobile.pane" ]
}, {
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" ]
} ]
};
/* jshint eqnull: true */
(function($, undefined) {
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 = $.isArray,
inArray = $.inArray,
push = Array.prototype.push,
proxy = $.proxy,
isFunction = kendo.isFunction,
isEmptyObject = $.isEmptyObject,
contains = $.contains,
math = Math,
DOT = ".",
PROGRESS = "progress",
ERROR = "error",
HIERARCHY_CELL_CLASS = "k-hierarchy-cell",
DATA_CELL = ":not(.k-group-cell):not(.k-hierarchy-cell:not(:has(.k-icon.k-i-collapse,.k-icon.k-i-expand))):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",
FIRSTITEMROW = ITEMROW + ":first",
LASTITEMROW = ITEMROW + ":last",
FIRSTNAVITEM = NAVROW + ":first>" + NAVCELL + ":first",
HEADERCELLS = "th.k-header:not(.k-group-cell):not(.k-hierarchy-cell)",
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",
FOCUSED = "k-state-focused",
FOCUSABLE = ":kendoFocusable",
SELECTED = "k-state-selected",
CHECKBOX = "k-checkbox",
CHECKBOXINPUT = "input[data-role='checkbox']." + CHECKBOX,
NORECORDSCLASS = "k-grid-norecords",
LINK_CLASS = "k-link",
ICON_CLASS = "k-icon",
ORDER_CLASS = "k-sort-order",
HEADER_COLUMN_MENU_CLASS = "k-header-column-menu",
FILTER_MENU_CLASS = "k-grid-filter",
RESIZE = "resize",
COLUMNRESIZE = "columnResize",
COLUMNREORDER = "columnReorder",
COLUMNLOCK = "columnLock",
COLUMNUNLOCK = "columnUnlock",
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",
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",
ARIALABEL = "aria-label",
formatRegExp = /(\}|\#)/ig,
templateHashRegExp = /#/ig,
whitespaceRegExp = "[\\x20\\t\\r\\n\\f]",
nonDataCellsRegExp = new RegExp("(^|" + whitespaceRegExp + ")" + "(k-group-cell|k-hierarchy-cell)" + "(" + whitespaceRegExp + "|$)"),
filterRowRegExp = new RegExp("(^|" + whitespaceRegExp + ")" + "(k-filter-row)" + "(" + whitespaceRegExp + "|$)"),
COMMANDBUTTONTMPL = '# if (iconClass) {#' +
'<a role="button" class="k-button k-button-icontext #=className#" #=attr# href="\\#"><span class="#=iconClass#"></span>#=text#</a>' +
'# } else { #' +
'<a role="button" class="k-button k-button-icontext #=className#" #=attr# href="\\#">#=text#</a>' +
'# } #',
SELECTCOLUMNTMPL = '# var checkboxGuid = kendo.guid(); #' +
'<input class="' + CHECKBOX + '" data-role="checkbox" id="#= checkboxGuid #" aria-label="Select row" aria-checked="false" type="checkbox">' +
'<label for="#= checkboxGuid #" class="k-checkbox-label k-no-text">&\\#8203;</label>',
SELECTCOLUMNHEADERTMPL = '# var checkboxGuid = kendo.guid(); #' +
'<input class="' + CHECKBOX + '" data-role="checkbox" aria-label="Select all rows" aria-checked="false" type="checkbox" id="#= checkboxGuid #">' +
'<label for="#= checkboxGuid #" class="k-checkbox-label k-no-text">##&\\#8203;##</label>',
isRtl = false,
browser = kendo.support.browser,
isIE7 = browser.msie && browser.version == 7,
isIE8 = browser.msie && browser.version == 8;
var isIE11 = browser.msie && browser.version === 11;
var isMac = /Mac OS/.test(navigator.userAgent);
var classNames = {
content: "k-content",
widget: "k-widget",
scrollContainer: "k-scroll-container"
};
var VirtualScrollable = Widget.extend({
init: function(element, options) {
var that = this;
Widget.fn.init.call(that, element, options);
that._refreshHandler = proxy(that.refresh, 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;
},
options: {
name: "VirtualScrollable",
itemHeight: $.noop,
prefetch: true,
maxScrollHeight: 250000
},
events: [
PAGING,
PAGE,
SCROLL
],
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()
.bind("DOMMouseScroll" + NS + " mousewheel" + NS, proxy(that._wheelScroll, that));
that._wrapper();
if (kendo.support.kineticScrollNeeded) {
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);
wrapper.scrollLeft(wrapper.scrollLeft() - e.x.delta);
e.preventDefault();
}
});
}
that.verticalScrollbar = $('<div class="k-scrollbar k-scrollbar-vertical" />')
.css({
width: scrollbar
}).appendTo(element)
.bind("scroll" + NS, proxy(that._scroll, 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._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;
},
_isElementVisible: function(element) {
return this._isElementVisibleInWrapper(element);
},
_isElementVisibleInWrapper: function(element) {
var that = this;
var wrapper = that.wrapper;
var offsetTop;
var halfHeight;
element = $(element);
if (element[0] && contains(wrapper[0], element[0])) {
offsetTop = element.offset().top - wrapper.offset().top;
halfHeight = element.outerHeight() / 2;
if ((offsetTop >= 0 || math.abs(offsetTop) <= halfHeight) && (math.floor(offsetTop + halfHeight) <= wrapper.height())) {
return true;
}
}
return false;
},
position: function(index) {
var rangeStart = this._rangeStart || this.dataSource.skip() || 0;
var pageSize = this.dataSource.pageSize();
var result;
if (index > rangeStart) {
result = index - rangeStart + 1;
} 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;
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, dataSource.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 {
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;
callback = isFunction(callback) ? callback : $.noop;
if (that.trigger(PAGING, { skip: skip, take: take })) {
return;
}
clearTimeout(that._timeout);
that._fetching = true;
that._rangeStart = skip;
if (dataSource.inRange(skip, take)) {
kendo.ui.progress($(that.wrapper).parent(), true);
dataSource.range(skip, take, function() {
kendo.ui.progress($(that.wrapper).parent(), false);
callback();
that.trigger(PAGE);
});
} else {
if (!delayLoading) {
kendo.ui.progress(that.wrapper.parent(), true);
}
that._timeout = setTimeout(function() {
if (!that._scrolling) {
if (delayLoading) {
kendo.ui.progress(that.wrapper.parent(), true);
}
dataSource.range(skip, take, function() {
kendo.ui.progress(that.wrapper.parent(), false);
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.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.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);
kendo.ui.progress(that.wrapper.parent(), false);
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)) {
that._rangeStart = dataSource.skip();
}
if (dataSource.page() === 1 && (!action || (action !== SYNC && action !== ITEM_CHANGE))) {
// 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-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-icon k-i-plus"
},
cancel: {
text: "Cancel changes",
className: "k-grid-cancel-changes",
iconClass: "k-icon k-i-cancel"
},
save: {
text: "Save changes",
className: "k-grid-save-changes",
iconClass: "k-icon k-i-check"
},
destroy: {
text: "Delete",
className: "k-grid-delete",
iconClass: "k-icon k-i-close"
},
edit: {
text: "Edit",
className: "k-grid-edit",
iconClass: "k-icon k-i-edit"
},
update: {
text: "Update",
className: "k-primary k-grid-update",
iconClass: "k-icon k-i-check"
},
canceledit: {
text: "Cancel",
className: "k-grid-cancel",
iconClass: "k-icon k-i-cancel"
},
excel: {
text: "Export to Excel",
className: "k-grid-excel",
iconClass: "k-icon k-i-file-excel"
},
pdf: {
text: "Export to PDF",
className: "k-grid-pdf",
iconClass: "k-icon k-i-file-pdf"
}
};
function cursor(context, value) {
$('th, th .k-grid-filter, 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, "a.k-grid-" + (commandName || "").replace(/\s/g, ""), { commandName: commandName }, proxy(command.click, context));
}
}
}
function normalizeColumns(columns, encoded, hide) {
return map(columns, function(column) {
column = typeof column === STRING ? { field: column } : column;
var hidden;
if (!isVisible(column) || hide) {
column.attributes = addHiddenStyle(column.attributes);
column.footerAttributes = addHiddenStyle(column.footerAttributes);
column.headerAttributes = addHiddenStyle(column.headerAttributes);
hidden = true;
}
if (column.columns) {
column.columns = normalizeColumns(column.columns, encoded, hidden);
}
var uid = kendo.guid();
column.headerAttributes = extend({id: uid}, column.headerAttributes);
return extend({ encoded: encoded, hidden: hidden }, 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 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" scope="col"> </th>');
var rows = destination.children(":not(.k-filter-row)");
$(new Array((sourcesDepth - targetDepth) + 1).join("<tr>" + 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 + ")>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 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 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 lockedColumns(columns) {
return grep(columns, function(column) {
return column.locked;
});
}
function nonLockedColumns(columns) {
return grep(columns, function(column) {
return !column.locked;
});
}
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 leafColumns(columns) {
var result = [];
for (var idx = 0; idx < columns.length; idx++) {
if (!columns[idx].columns) {
result.push(columns[idx]);
continue;
}
result = result.concat(leafColumns(columns[idx].columns));
}
return result;
}
function leafDataCells(container) {
var rows = container.find(">tr:not(.k-filter-row)");
var filter = function() {
var el = $(this);
return !el.hasClass("k-group-cell") && !el.hasClass("k-hierarchy-cell");
};
var cells = $();
if (rows.length > 1) {
cells = rows.find("th")
.filter(filter)
.filter(functi