/**
* Kendo UI v2016.1.112 (http://www.telerik.com/kendo-ui)
* Copyright 2016 Telerik AD. All rights reserved.
*
* Kendo UI commercial licenses may be obtained at
* http://www.telerik.com/purchase/license-agreement/kendo-ui-complete
* If you do not own a commercial license, this file shall be governed by the trial license terms.
*/
(function (f, define) {
define('kendo.treelist', [
'kendo.dom',
'kendo.data',
'kendo.columnsorter',
'kendo.editable',
'kendo.window',
'kendo.filtermenu',
'kendo.selectable',
'kendo.resizable',
'kendo.treeview.draganddrop'
], f);
}(function () {
var __meta__ = {
id: 'treelist',
name: 'TreeList',
category: 'web',
description: 'The TreeList widget displays self-referencing data and offers rich support for interacting with data, sorting, filtering, and selection.',
depends: [
'dom',
'data'
],
features: [
{
id: 'treelist-sorting',
name: 'Sorting',
description: 'Support for column sorting',
depends: ['columnsorter']
},
{
id: 'treelist-filtering',
name: 'Filtering',
description: 'Support for record filtering',
depends: ['filtermenu']
},
{
id: 'treelist-editing',
name: 'Editing',
description: 'Support for record editing',
depends: [
'editable',
'window'
]
},
{
id: 'treelist-selection',
name: 'Selection',
description: 'Support for row selection',
depends: ['selectable']
},
{
id: 'treelist-column-resize',
name: 'Column resizing',
description: 'Support for column resizing',
depends: ['resizable']
},
{
id: 'treelist-dragging',
name: 'Drag & Drop',
description: 'Support for drag & drop of rows',
depends: ['treeview.draganddrop']
},
{
id: 'treelist-excel-export',
name: 'Excel export',
description: 'Export data as Excel spreadsheet',
depends: ['excel']
},
{
id: 'treelist-pdf-export',
name: 'PDF export',
description: 'Export data as PDF',
depends: [
'pdf',
'drawing'
]
}
]
};
(function ($, undefined) {
var data = kendo.data;
var extend = $.extend;
var kendoDom = kendo.dom;
var kendoDomElement = kendoDom.element;
var kendoTextElement = kendoDom.text;
var kendoHtmlElement = kendoDom.html;
var ui = kendo.ui;
var DataBoundWidget = ui.DataBoundWidget;
var DataSource = data.DataSource;
var ObservableArray = data.ObservableArray;
var Query = data.Query;
var Model = data.Model;
var proxy = $.proxy;
var map = $.map;
var grep = $.grep;
var inArray = $.inArray;
var isPlainObject = $.isPlainObject;
var push = Array.prototype.push;
var STRING = 'string';
var CHANGE = 'change';
var ERROR = 'error';
var PROGRESS = 'progress';
var DOT = '.';
var NS = '.kendoTreeList';
var CLICK = 'click';
var MOUSEDOWN = 'mousedown';
var EDIT = 'edit';
var SAVE = 'save';
var EXPAND = 'expand';
var COLLAPSE = 'collapse';
var REMOVE = 'remove';
var DATABINDING = 'dataBinding';
var DATABOUND = 'dataBound';
var CANCEL = 'cancel';
var FILTERMENUINIT = 'filterMenuInit';
var COLUMNHIDE = 'columnHide';
var COLUMNSHOW = 'columnShow';
var HEADERCELLS = 'th.k-header';
var COLUMNREORDER = 'columnReorder';
var COLUMNRESIZE = 'columnResize';
var COLUMNMENUINIT = 'columnMenuInit';
var COLUMNLOCK = 'columnLock';
var COLUMNUNLOCK = 'columnUnlock';
var PARENTIDFIELD = 'parentId';
var DRAGSTART = 'dragstart';
var DRAG = 'drag';
var DROP = 'drop';
var DRAGEND = 'dragend';
var classNames = {
wrapper: 'k-treelist k-grid k-widget',
header: 'k-header',
button: 'k-button',
alt: 'k-alt',
editCell: 'k-edit-cell',
group: 'k-treelist-group',
gridToolbar: 'k-grid-toolbar',
gridHeader: 'k-grid-header',
gridHeaderWrap: 'k-grid-header-wrap',
gridContent: 'k-grid-content',
gridContentWrap: 'k-grid-content',
gridFilter: 'k-grid-filter',
footerTemplate: 'k-footer-template',
loading: 'k-loading',
refresh: 'k-i-refresh',
retry: 'k-request-retry',
selected: 'k-state-selected',
status: 'k-status',
link: 'k-link',
withIcon: 'k-with-icon',
filterable: 'k-filterable',
icon: 'k-icon',
iconFilter: 'k-filter',
iconCollapse: 'k-i-collapse',
iconExpand: 'k-i-expand',
iconHidden: 'k-i-none',
iconPlaceHolder: 'k-icon k-i-none',
input: 'k-input',
dropPositions: 'k-insert-top k-insert-bottom k-add k-insert-middle',
dropTop: 'k-insert-top',
dropBottom: 'k-insert-bottom',
dropAdd: 'k-add',
dropMiddle: 'k-insert-middle',
dropDenied: 'k-denied',
dragStatus: 'k-drag-status',
dragClue: 'k-drag-clue',
dragClueText: 'k-clue-text'
};
var defaultCommands = {
create: {
imageClass: 'k-add',
className: 'k-grid-add',
methodName: 'addRow'
},
createchild: {
imageClass: 'k-add',
className: 'k-grid-add',
methodName: 'addRow'
},
destroy: {
imageClass: 'k-delete',
className: 'k-grid-delete',
methodName: 'removeRow'
},
edit: {
imageClass: 'k-edit',
className: 'k-grid-edit',
methodName: 'editRow'
},
update: {
imageClass: 'k-update',
className: 'k-primary k-grid-update',
methodName: 'saveRow'
},
canceledit: {
imageClass: 'k-cancel',
className: 'k-grid-cancel',
methodName: '_cancelEdit'
},
excel: {
imageClass: 'k-i-excel',
className: 'k-grid-excel',
methodName: 'saveAsExcel'
},
pdf: {
imageClass: 'k-i-pdf',
className: 'k-grid-pdf',
methodName: 'saveAsPDF'
}
};
var TreeListModel = Model.define({
id: 'id',
parentId: PARENTIDFIELD,
fields: {
id: { type: 'number' },
parentId: {
type: 'number',
nullable: true
}
},
init: function (value) {
Model.fn.init.call(this, value);
this._loaded = false;
if (!this.parentIdField) {
this.parentIdField = PARENTIDFIELD;
}
this.parentId = this.get(this.parentIdField);
},
accept: function (data) {
Model.fn.accept.call(this, data);
this.parentId = this.get(this.parentIdField);
},
set: function (field, value, initiator) {
if (field == PARENTIDFIELD && this.parentIdField != PARENTIDFIELD) {
this[this.parentIdField] = value;
}
Model.fn.set.call(this, field, value, initiator);
if (field == this.parentIdField) {
this.parentId = this.get(this.parentIdField);
}
},
loaded: function (value) {
if (value !== undefined) {
this._loaded = value;
} else {
return this._loaded;
}
},
shouldSerialize: function (field) {
return Model.fn.shouldSerialize.call(this, field) && field !== '_loaded' && field != '_error' && field != '_edit' && !(this.parentIdField !== 'parentId' && field === 'parentId');
}
});
TreeListModel.parentIdField = PARENTIDFIELD;
TreeListModel.define = function (base, options) {
if (options === undefined) {
options = base;
base = TreeListModel;
}
var parentId = options.parentId || PARENTIDFIELD;
options.parentIdField = parentId;
var model = Model.define(base, options);
if (parentId) {
model.parentIdField = parentId;
}
return model;
};
function is(field) {
return function (object) {
return object[field];
};
}
function not(func) {
return function (object) {
return !func(object);
};
}
var TreeListDataSource = DataSource.extend({
init: function (options) {
DataSource.fn.init.call(this, extend(true, {}, {
schema: {
modelBase: TreeListModel,
model: TreeListModel
}
}, options));
},
_createNewModel: function (data) {
var model = {};
var fromModel = data instanceof Model;
if (fromModel) {
model = data;
}
model = DataSource.fn._createNewModel.call(this, model);
if (!fromModel) {
if (data.parentId) {
data[model.parentIdField] = data.parentId;
}
model.accept(data);
}
return model;
},
_shouldWrap: function () {
return true;
},
_readData: function (newData) {
var data = this.data();
newData = DataSource.fn._readData.call(this, newData);
this._concat(newData, data);
if (newData instanceof ObservableArray) {
return newData;
}
return data;
},
_concat: function (source, target) {
var targetLength = target.length;
for (var i = 0; i < source.length; i++) {
target[targetLength++] = source[i];
}
target.length = targetLength;
},
_readAggregates: function (data) {
var result = extend(this._aggregateResult, this.reader.aggregates(data));
if ('' in result) {
result[this._defaultParentId()] = result[''];
delete result[''];
}
return result;
},
remove: function (root) {
var items = this._subtree(this._childrenMap(this.data()), root.id);
this._removeItems(items);
DataSource.fn.remove.call(this, root);
},
_filterCallback: function (query) {
var i, item;
var map = {};
var result = [];
var data = query.toArray();
for (i = 0; i < data.length; i++) {
item = data[i];
while (item) {
if (!map[item.id]) {
map[item.id] = true;
result.push(item);
}
if (!map[item.parentId]) {
map[item.parentId] = true;
item = this.parentNode(item);
if (item) {
result.push(item);
}
} else {
break;
}
}
}
return new Query(result);
},
_subtree: function (map, id) {
var result = map[id] || [];
var defaultParentId = this._defaultParentId();
for (var i = 0, len = result.length; i < len; i++) {
if (result[i].id !== defaultParentId) {
result = result.concat(this._subtree(map, result[i].id));
}
}
return result;
},
_childrenMap: function (data) {
var map = {};
var i, item, id, parentId;
data = this._observeView(data);
for (i = 0; i < data.length; i++) {
item = data[i];
id = item.id;
parentId = item.parentId;
map[id] = map[id] || [];
map[parentId] = map[parentId] || [];
map[parentId].push(item);
}
return map;
},
_calculateAggregates: function (data, options) {
options = options || {};
var result = {};
var item, subtree, i;
var filter = options.filter;
if (filter) {
data = Query.process(data, {
filter: filter,
filterCallback: proxy(this._filterCallback, this)
}).data;
}
var map = this._childrenMap(data);
result[this._defaultParentId()] = new Query(this._subtree(map, this._defaultParentId())).aggregate(options.aggregate);
for (i = 0; i < data.length; i++) {
item = data[i];
subtree = this._subtree(map, item.id);
result[item.id] = new Query(subtree).aggregate(options.aggregate);
}
return result;
},
_queryProcess: function (data, options) {
options = options || {};
options.filterCallback = proxy(this._filterCallback, this);
var defaultParentId = this._defaultParentId();
var result = Query.process(data, options);
var map = this._childrenMap(result.data);
var hasLoadedChildren, i, item, children;
data = map[defaultParentId] || [];
for (i = 0; i < data.length; i++) {
item = data[i];
if (item.id === defaultParentId) {
continue;
}
children = map[item.id];
hasLoadedChildren = !!(children && children.length);
if (!item.loaded()) {
item.loaded(hasLoadedChildren || !item.hasChildren);
}
if (item.loaded() || item.hasChildren !== true) {
item.hasChildren = hasLoadedChildren;
}
if (hasLoadedChildren) {
data = data.slice(0, i + 1).concat(children, data.slice(i + 1));
}
}
result.data = data;
return result;
},
_queueRequest: function (options, callback) {
callback.call(this);
},
_modelLoaded: function (id) {
var model = this.get(id);
model.loaded(true);
model.hasChildren = this.childNodes(model).length > 0;
},
_modelError: function (id, e) {
this.get(id)._error = e;
},
success: function (data, requestParams) {
if (!requestParams || !requestParams.id) {
this._data = this._observe([]);
}
return DataSource.fn.success.call(this, data, requestParams);
},
load: function (model) {
var method = '_query';
var remote = this.options.serverSorting || this.options.serverPaging || this.options.serverFiltering || this.options.serverGrouping || this.options.serverAggregates;
var defaultPromise = $.Deferred().resolve().promise();
if (model.loaded()) {
if (remote) {
return defaultPromise;
}
} else if (model.hasChildren) {
method = 'read';
}
return this[method]({ id: model.id }).then(proxy(this._modelLoaded, this, model.id), proxy(this._modelError, this, model.id));
},
contains: function (root, child) {
var rootId = root.id;
while (child) {
if (child.parentId === rootId) {
return true;
}
child = this.parentNode(child);
}
return false;
},
_byParentId: function (id, defaultId) {
var result = [];
var view = this.view();
var current;
if (id === defaultId) {
return [];
}
for (var i = 0; i < view.length; i++) {
current = view.at(i);
if (current.parentId == id) {
result.push(current);
}
}
return result;
},
_defaultParentId: function () {
return this.reader.model.fn.defaults[this.reader.model.parentIdField];
},
childNodes: function (model) {
return this._byParentId(model.id, this._defaultParentId());
},
rootNodes: function () {
return this._byParentId(this._defaultParentId());
},
parentNode: function (model) {
return this.get(model.parentId);
},
level: function (model) {
var result = -1;
if (!(model instanceof TreeListModel)) {
model = this.get(model);
}
do {
model = this.parentNode(model);
result++;
} while (model);
return result;
},
filter: function (value) {
var baseFilter = DataSource.fn.filter;
if (value === undefined) {
return baseFilter.call(this, value);
}
baseFilter.call(this, value);
}
});
TreeListDataSource.create = function (options) {
if ($.isArray(options)) {
options = { data: options };
} else if (options instanceof ObservableArray) {
options = { data: options.toJSON() };
}
return options instanceof TreeListDataSource ? options : new TreeListDataSource(options);
};
function isCellVisible() {
return this.style.display !== 'none';
}
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(function () {
return this.rowSpan > 1;
});
}
cells = cells.add(rows.last().find('th').filter(filter));
var indexAttr = kendo.attr('index');
cells.sort(function (a, b) {
a = $(a);
b = $(b);
var indexA = a.attr(indexAttr);
var indexB = b.attr(indexAttr);
if (indexA === undefined) {
indexA = $(a).index();
}
if (indexB === undefined) {
indexB = $(b).index();
}
indexA = parseInt(indexA, 10);
indexB = parseInt(indexB, 10);
return indexA > indexB ? 1 : indexA < indexB ? -1 : 0;
});
return cells;
}
function createPlaceholders(options) {
var spans = [];
var className = options.className;
for (var i = 0, level = options.level; i < level; i++) {
spans.push(kendoDomElement('span', { className: className }));
}
return spans;
}
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 syncTableHeight(table1, table2) {
table1 = table1[0];
table2 = table2[0];
if (table1.rows.length !== table2.rows.length) {
var lockedHeigth = table1.offsetHeight;
var tableHeigth = table2.offsetHeight;
var row;
var diff;
if (lockedHeigth > tableHeigth) {
row = table2.rows[table2.rows.length - 1];
diff = lockedHeigth - tableHeigth;
} else {
row = table1.rows[table1.rows.length - 1];
diff = tableHeigth - lockedHeigth;
}
row.style.height = row.offsetHeight + diff + 'px';
}
}
var Editor = kendo.Observable.extend({
init: function (element, options) {
kendo.Observable.fn.init.call(this);
options = this.options = extend(true, {}, this.options, options);
this.element = element;
this.bind(this.events, options);
this.model = this.options.model;
this.fields = this._fields(this.options.columns);
this._initContainer();
this.createEditable();
},
events: [],
_initContainer: function () {
this.wrapper = this.element;
},
createEditable: function () {
var options = this.options;
this.editable = new ui.Editable(this.wrapper, {
fields: this.fields,
target: options.target,
clearContainer: options.clearContainer,
model: this.model
});
},
_isEditable: function (column) {
return column.field && this.model.editable(column.field);
},
_fields: function (columns) {
var fields = [];
var idx, length, column;
for (idx = 0, length = columns.length; idx < length; idx++) {
column = columns[idx];
if (this._isEditable(column)) {
fields.push({
field: column.field,
format: column.format,
editor: column.editor
});
}
}
return fields;
},
end: function () {
return this.editable.end();
},
close: function () {
this.destroy();
},
destroy: function () {
this.editable.destroy();
this.editable.element.find('[' + kendo.attr('container-for') + ']').empty().end().removeAttr(kendo.attr('role'));
this.model = this.wrapper = this.element = this.columns = this.editable = null;
}
});
var PopupEditor = Editor.extend({
init: function (element, options) {
Editor.fn.init.call(this, element, options);
this._attachHandlers();
kendo.cycleForm(this.wrapper);
this.open();
},
events: [
CANCEL,
SAVE
],
options: {
window: {
modal: true,
resizable: false,
draggable: true,
title: 'Edit',
visible: false
}
},
_initContainer: function () {
var options = this.options;
var formContent = [];
this.wrapper = $('').attr(kendo.attr('uid'), this.model.uid).append('');
if (options.template) {
this._appendTemplate(formContent);
this.fields = [];
} else {
this._appendFields(formContent);
}
this._appendButtons(formContent);
new kendoDom.Tree(this.wrapper.children()[0]).render(formContent);
this.wrapper.appendTo(options.appendTo);
this.window = new ui.Window(this.wrapper, options.window);
},
_appendTemplate: function (form) {
var template = this.options.template;
if (typeof template === STRING) {
template = window.unescape(template);
}
template = kendo.template(template)(this.model);
form.push(kendoHtmlElement(template));
},
_appendFields: function (form) {
var idx, length, column;
var columns = this.options.columns;
for (idx = 0, length = columns.length; idx < length; idx++) {
column = columns[idx];
if (column.command) {
continue;
}
form.push(kendoHtmlElement(''));
if (this._isEditable(column)) {
form.push(kendoHtmlElement(''));
} else {
form.push(kendoDomElement('div', { 'class': 'k-edit-field' }, [this.options.fieldRenderer(column, this.model)]));
}
}
},
_appendButtons: function (form) {
form.push(kendoDomElement('div', { 'class': 'k-edit-buttons k-state-default' }, this.options.commandRenderer()));
},
_attachHandlers: function () {
var closeHandler = this._cancelProxy = proxy(this._cancel, this);
this.wrapper.on(CLICK + NS, '.k-grid-cancel', this._cancelProxy);
this._saveProxy = proxy(this._save, this);
this.wrapper.on(CLICK + NS, '.k-grid-update', this._saveProxy);
this.window.bind('close', function (e) {
if (e.userTriggered) {
closeHandler(e);
}
});
},
_dettachHandlers: function () {
this._cancelProxy = null;
this._saveProxy = null;
this.wrapper.off(NS);
},
_cancel: function (e) {
this.trigger(CANCEL, e);
},
_save: function () {
this.trigger(SAVE);
},
open: function () {
this.window.center().open();
},
close: function () {
this.window.bind('deactivate', proxy(this.destroy, this)).close();
},
destroy: function () {
this.window.destroy();
this.window = null;
this._dettachHandlers();
Editor.fn.destroy.call(this);
}
});
var TreeList = DataBoundWidget.extend({
init: function (element, options) {
DataBoundWidget.fn.init.call(this, element, options);
this._dataSource(this.options.dataSource);
this._columns();
this._layout();
this._selectable();
this._sortable();
this._resizable();
this._filterable();
this._attachEvents();
this._toolbar();
this._scrollable();
this._reorderable();
this._columnMenu();
this._minScreenSupport();
this._draggable();
if (this.options.autoBind) {
this.dataSource.fetch();
}
if (this._hasLockedColumns) {
var widget = this;
this.wrapper.addClass('k-grid-lockedcolumns');
this._resizeHandler = function () {
widget.resize();
};
$(window).on('resize' + NS, this._resizeHandler);
}
kendo.notify(this);
},
_draggable: function () {
var editable = this.options.editable;
if (!editable || !editable.move) {
return;
}
this._dragging = new kendo.ui.HierarchicalDragAndDrop(this.wrapper, {
$angular: this.$angular,
autoScroll: true,
filter: 'tbody>tr',
itemSelector: 'tr',
allowedContainers: this.wrapper,
hintText: function (row) {
var text = function () {
return $(this).text();
};
var separator = '';
return row.children('td').map(text).toArray().join(separator);
},
contains: proxy(function (source, destination) {
var dest = this.dataItem(destination);
var src = this.dataItem(source);
return src == dest || this.dataSource.contains(src, dest);
}, this),
itemFromTarget: function (target) {
var tr = target.closest('tr');
return {
item: tr,
content: tr
};
},
dragstart: proxy(function (source) {
this.wrapper.addClass('k-treelist-dragging');
var model = this.dataItem(source);
return this.trigger(DRAGSTART, { source: model });
}, this),
drag: proxy(function (e) {
e.source = this.dataItem(e.source);
this.trigger(DRAG, e);
}, this),
drop: proxy(function (e) {
e.source = this.dataItem(e.source);
e.destination = this.dataItem(e.destination);
this.wrapper.removeClass('k-treelist-dragging');
return this.trigger(DROP, e);
}, this),
dragend: proxy(function (e) {
var dest = this.dataItem(e.destination);
var src = this.dataItem(e.source);
src.set('parentId', dest ? dest.id : null);
e.source = src;
e.destination = dest;
this.trigger(DRAGEND, e);
}, this),
reorderable: false,
dropHintContainer: function (item) {
return item.children('td:eq(1)');
},
dropPositionFrom: function (dropHint) {
return dropHint.prevAll('.k-i-none').length > 0 ? 'after' : 'before';
}
});
},
itemFor: function (model) {
if (typeof model == 'number') {
model = this.dataSource.get(model);
}
return this.tbody.find('[' + kendo.attr('uid') + '=' + model.uid + ']');
},
_scrollable: function () {
if (this.options.scrollable) {
var scrollables = this.thead.closest('.k-grid-header-wrap');
var lockedContent = $(this.lockedContent).bind('DOMMouseScroll' + NS + ' mousewheel' + NS, proxy(this._wheelScroll, this));
this.content.bind('scroll' + NS, function () {
scrollables.scrollLeft(this.scrollLeft);
lockedContent.scrollTop(this.scrollTop);
});
var touchScroller = kendo.touchScroller(this.content);
if (touchScroller && touchScroller.movable) {
this._touchScroller = touchScroller;
touchScroller.movable.bind('change', function (e) {
scrollables.scrollLeft(-e.sender.x);
if (lockedContent) {
lockedContent.scrollTop(-e.sender.y);
}
});
}
}
},
_wheelScroll: function (e) {
if (e.ctrlKey) {
return;
}
var delta = kendo.wheelDeltaY(e);
if (delta) {
e.preventDefault();
$(e.currentTarget).one('wheel' + NS, false);
this.content.scrollTop(this.content.scrollTop() + -delta);
}
},
_progress: function () {
var messages = this.options.messages;
if (!this.tbody.find('tr').length) {
this._showStatus(kendo.template(' #: messages.loading #')({
className: classNames.icon + ' ' + classNames.loading,
messages: messages
}));
}
},
_error: function (e) {
if (!this.dataSource.rootNodes().length) {
this._render({ error: e });
}
},
refresh: function (e) {
e = e || {};
if (e.action == 'itemchange' && this.editor) {
return;
}
if (this.trigger(DATABINDING)) {
return;
}
this._cancelEditor();
this._render();
this._adjustHeight();
this.trigger(DATABOUND);
},
_angularFooters: function (command) {
var i, footer, aggregates;
var allAggregates = this.dataSource.aggregates();
var footerRows = this._footerItems();
for (i = 0; i < footerRows.length; i++) {
footer = footerRows.eq(i);
aggregates = allAggregates[footer.attr('data-parentId')];
this._angularFooter(command, footer.find('td').get(), aggregates);
}
},
_angularFooter: function (command, cells, aggregates) {
var columns = this.columns;
this.angular(command, function () {
return {
elements: cells,
data: map(columns, function (col) {
return {
column: col,
aggregate: aggregates && aggregates[col.field]
};
})
};
});
},
items: function () {
if (this._hasLockedColumns) {
return this._items(this.tbody).add(this._items(this.lockedTable));
} else {
return this._items(this.tbody);
}
},
_items: function (container) {
return container.find('tr').filter(function () {
return !$(this).hasClass(classNames.footerTemplate);
});
},
_footerItems: function () {
var container = this.tbody;
if (this._hasLockedColumns) {
container = container.add(this.lockedTable);
}
return container.find('tr').filter(function () {
return $(this).hasClass(classNames.footerTemplate);
});
},
dataItems: function () {
var dataItems = kendo.ui.DataBoundWidget.fn.dataItems.call(this);
if (this._hasLockedColumns) {
var n = dataItems.length, tmp = new Array(2 * n);
for (var i = n; --i >= 0;) {
tmp[i] = tmp[i + n] = dataItems[i];
}
dataItems = tmp;
}
return dataItems;
},
_showStatus: function (message) {
var status = this.element.find('.k-status');
var content = $(this.content).add(this.lockedContent);
if (!status.length) {
status = $('').appendTo(this.element);
}
this._contentTree.render([]);
if (this._hasLockedColumns) {
this._lockedContentTree.render([]);
}
content.hide();
status.html(message);
},
_hideStatus: function () {
this.element.find('.k-status').remove();
$(this.content).add(this.lockedContent).show();
},
_adjustHeight: function () {
var element = this.element;
var contentWrap = element.find(DOT + classNames.gridContentWrap);
var header = element.find(DOT + classNames.gridHeader);
var toolbar = element.find(DOT + classNames.gridToolbar);
var height;
var scrollbar = kendo.support.scrollbar();
element.height(this.options.height);
var isHeightSet = function (el) {
var initialHeight, newHeight;
if (el[0].style.height) {
return true;
} else {
initialHeight = el.height();
}
el.height('auto');
newHeight = el.height();
el.height('');
return initialHeight != newHeight;
};
if (isHeightSet(element)) {
height = element.height() - header.outerHeight() - toolbar.outerHeight();
contentWrap.height(height);
if (this._hasLockedColumns) {
scrollbar = this.table[0].offsetWidth > this.table.parent()[0].clientWidth ? scrollbar : 0;
this.lockedContent.height(height - scrollbar);
}
}
},
_resize: function () {
this._applyLockedContainersWidth();
this._adjustHeight();
},
_minScreenSupport: function () {
var any = this.hideMinScreenCols();
if (any) {
this.minScreenResizeHandler = proxy(this.hideMinScreenCols, this);
$(window).on('resize', this.minScreenResizeHandler);
}
},
hideMinScreenCols: function () {
var cols = this.columns, any = false, screenWidth = window.innerWidth > 0 ? window.innerWidth : screen.width;
for (var i = 0; i < cols.length; i++) {
var col = cols[i];
var minWidth = col.minScreenWidth;
if (minWidth !== undefined && minWidth !== null) {
any = true;
if (minWidth > screenWidth) {
this.hideColumn(col);
} else {
this.showColumn(col);
}
}
}
return any;
},
destroy: function () {
DataBoundWidget.fn.destroy.call(this);
var dataSource = this.dataSource;
dataSource.unbind(CHANGE, this._refreshHandler);
dataSource.unbind(ERROR, this._errorHandler);
dataSource.unbind(PROGRESS, this._progressHandler);
if (this._resizeHandler) {
$(window).off('resize' + NS, this._resizeHandler);
}
if (this._dragging) {
this._dragging.destroy();
this._dragging = null;
}
if (this.resizable) {
this.resizable.destroy();
this.resizable = null;
}
if (this.reorderable) {
this.reorderable.destroy();
this.reorderable = null;
}
if (this._draggableInstance && this._draggableInstance.element) {
this._draggableInstance.destroy();
this._draggableInstance = null;
}
if (this.minScreenResizeHandler) {
$(window).off('resize', this.minScreenResizeHandler);
}
this._destroyEditor();
this.element.off(NS);
if (this._touchScroller) {
this._touchScroller.destroy();
}
this._autoExpandable = null;
this._refreshHandler = this._errorHandler = this._progressHandler = null;
this.thead = this.content = this.tbody = this.table = this.element = this.lockedHeader = this.lockedContent = null;
this._statusTree = this._headerTree = this._contentTree = this._lockedHeaderColsTree = this._lockedContentColsTree = this._lockedHeaderTree = this._lockedContentTree = null;
},
options: {
name: 'TreeList',
columns: [],
autoBind: true,
scrollable: true,
selectable: false,
sortable: false,
toolbar: null,
height: null,
columnMenu: false,
messages: {
noRows: 'No records to display',
loading: 'Loading...',
requestFailed: 'Request failed.',
retry: 'Retry',
commands: {
edit: 'Edit',
update: 'Update',
canceledit: 'Cancel',
create: 'Add new record',
createchild: 'Add child record',
destroy: 'Delete',
excel: 'Export to Excel',
pdf: 'Export to PDF'
}
},
excel: { hierarchy: true },
resizable: false,
filterable: false,
editable: false,
reorderable: false
},
events: [
CHANGE,
EDIT,
SAVE,
REMOVE,
EXPAND,
COLLAPSE,
DATABINDING,
DATABOUND,
CANCEL,
DRAGSTART,
DRAG,
DROP,
DRAGEND,
FILTERMENUINIT,
COLUMNHIDE,
COLUMNSHOW,
COLUMNREORDER,
COLUMNRESIZE,
COLUMNMENUINIT,
COLUMNLOCK,
COLUMNUNLOCK
],
_toggle: function (model, expand) {
var loaded = model.loaded();
if (model._error) {
model.expanded = false;
model._error = undefined;
}
if (!loaded && model.expanded) {
return;
}
if (typeof expand == 'undefined') {
expand = !model.expanded;
}
model.expanded = expand;
if (!loaded) {
this.dataSource.load(model).always(proxy(function () {
this._render();
this._syncLockedContentHeight();
}, this));
}
this._render();
this._syncLockedContentHeight();
},
expand: function (row) {
this._toggle(this.dataItem(row), true);
},
collapse: function (row) {
this._toggle(this.dataItem(row), false);
},
_toggleChildren: function (e) {
var icon = $(e.currentTarget);
var model = this.dataItem(icon);
var event = !model.expanded ? EXPAND : COLLAPSE;
if (!this.trigger(event, { model: model })) {
this._toggle(model);
}
e.preventDefault();
},
_attachEvents: function () {
var icons = DOT + classNames.iconCollapse + ', .' + classNames.iconExpand + ', .' + classNames.refresh;
var retryButton = DOT + classNames.retry;
var dataSource = this.dataSource;
this.element.on(MOUSEDOWN + NS, icons, proxy(this._toggleChildren, this)).on(CLICK + NS, retryButton, proxy(dataSource.fetch, dataSource)).on(CLICK + NS, '.k-button[data-command]', proxy(this._commandClick, this));
},
_commandByName: function (name) {
var columns = this.columns;
var toolbar = $.isArray(this.options.toolbar) ? this.options.toolbar : [];
var i, j, commands, currentName;
name = name.toLowerCase();
if (defaultCommands[name]) {
return defaultCommands[name];
}
for (i = 0; i < columns.length; i++) {
commands = columns[i].command;
if (commands) {
for (j = 0; j < commands.length; j++) {
currentName = commands[j].name;
if (!currentName) {
continue;
}
if (currentName.toLowerCase() == name) {
return commands[j];
}
}
}
}
for (i = 0; i < toolbar.length; i++) {
currentName = toolbar[i].name;
if (!currentName) {
continue;
}
if (currentName.toLowerCase() == name) {
return toolbar[i];
}
}
},
_commandClick: function (e) {
var button = $(e.currentTarget);
var commandName = button.attr('data-command');
var command = this._commandByName(commandName);
var row = button.parentsUntil(this.wrapper, 'tr');
row = row.length ? row : undefined;
if (command) {
if (command.methodName) {
this[command.methodName](row);
} else if (command.click) {
command.click.call(this, e);
}
e.preventDefault();
}
},
_ensureExpandableColumn: function () {
if (this._autoExpandable) {
delete this._autoExpandable.expandable;
}
var visibleColumns = grep(this.columns, not(is('hidden')));
var expandableColumns = grep(visibleColumns, is('expandable'));
if (this.columns.length && !expandableColumns.length) {
this._autoExpandable = visibleColumns[0];
visibleColumns[0].expandable = true;
}
},
_columns: function () {
var columns = this.options.columns || [];
this.columns = map(columns, function (column) {
column = typeof column === 'string' ? { field: column } : column;
return extend({ encoded: true }, column);
});
var lockedColumns = this._lockedColumns();
if (lockedColumns.length > 0) {
this._hasLockedColumns = true;
this.columns = lockedColumns.concat(this._nonLockedColumns());
}
this._ensureExpandableColumn();
this._columnTemplates();
this._columnAttributes();
},
_columnTemplates: function () {
var idx, length, column;
var columns = this.columns;
for (idx = 0, length = columns.length; idx < length; idx++) {
column = columns[idx];
if (column.template) {
column.template = kendo.template(column.template);
}
if (column.headerTemplate) {
column.headerTemplate = kendo.template(column.headerTemplate);
}
if (column.footerTemplate) {
column.footerTemplate = kendo.template(column.footerTemplate);
}
}
},
_columnAttributes: function () {
var idx, length;
var columns = this.columns;
function convertStyle(attr) {
var properties, i, declaration;
if (attr && attr.style) {
properties = attr.style.split(';');
attr.style = {};
for (i = 0; i < properties.length; i++) {
declaration = properties[i].split(':');
var name = $.trim(declaration[0]);
if (name) {
attr.style[$.camelCase(name)] = $.trim(declaration[1]);
}
}
}
}
for (idx = 0, length = columns.length; idx < length; idx++) {
convertStyle(columns[idx].attributes);
convertStyle(columns[idx].headerAttributes);
}
},
_layout: function () {
var columns = this.columns;
var element = this.element;
var layout = '';
this.wrapper = element.addClass(classNames.wrapper);
layout = '';
if (this._hasLockedColumns) {
layout += '';
}
layout += '
' + '