You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1931 lines
56 KiB
1931 lines
56 KiB
/* |
|
* jsGrid v1.5.3 (http://js-grid.com) |
|
* (c) 2016 Artem Tabalin |
|
* Licensed under MIT (https://github.com/tabalinas/jsgrid/blob/master/LICENSE) |
|
*/ |
|
|
|
!(function (a, b, c) { |
|
function d(a, c) { |
|
var d = b(a); |
|
d.data(f, this), |
|
(this._container = d), |
|
(this.data = []), |
|
(this.fields = []), |
|
(this._editingRow = null), |
|
(this._sortField = null), |
|
(this._sortOrder = i), |
|
(this._firstDisplayingPage = 1), |
|
this._init(c), |
|
this.render(); |
|
} |
|
var e = "JSGrid", |
|
f = e, |
|
g = "JSGridItem", |
|
h = "JSGridEditRow", |
|
i = "asc", |
|
j = "desc", |
|
k = "{first}", |
|
l = "{pages}", |
|
m = "{prev}", |
|
n = "{next}", |
|
o = "{last}", |
|
p = "{pageIndex}", |
|
q = "{pageCount}", |
|
r = "{itemCount}", |
|
s = "javascript:void(0);", |
|
t = function (a, c) { |
|
return b.isFunction(a) ? a.apply(c, b.makeArray(arguments).slice(2)) : a; |
|
}, |
|
u = function (a) { |
|
var c = b.Deferred(); |
|
return ( |
|
a && a.then |
|
? a.then( |
|
function () { |
|
c.resolve.apply(c, arguments); |
|
}, |
|
function () { |
|
c.reject.apply(c, arguments); |
|
} |
|
) |
|
: c.resolve(a), |
|
c.promise() |
|
); |
|
}, |
|
v = { |
|
loadData: b.noop, |
|
insertItem: b.noop, |
|
updateItem: b.noop, |
|
deleteItem: b.noop, |
|
}; |
|
(d.prototype = { |
|
width: "auto", |
|
height: "auto", |
|
updateOnResize: !0, |
|
rowClass: b.noop, |
|
rowRenderer: null, |
|
rowClick: function (a) { |
|
this.editing && this.editItem(b(a.event.target).closest("tr")); |
|
}, |
|
rowDoubleClick: b.noop, |
|
noDataContent: "Not found", |
|
noDataRowClass: "jsgrid-nodata-row", |
|
heading: !0, |
|
headerRowRenderer: null, |
|
headerRowClass: "jsgrid-header-row", |
|
headerCellClass: "jsgrid-header-cell", |
|
filtering: !1, |
|
filterRowRenderer: null, |
|
filterRowClass: "jsgrid-filter-row", |
|
inserting: !1, |
|
insertRowRenderer: null, |
|
insertRowClass: "jsgrid-insert-row", |
|
editing: !1, |
|
editRowRenderer: null, |
|
editRowClass: "jsgrid-edit-row", |
|
confirmDeleting: !0, |
|
deleteConfirm: "Are you sure?", |
|
selecting: !0, |
|
selectedRowClass: "jsgrid-selected-row", |
|
oddRowClass: "jsgrid-row", |
|
evenRowClass: "jsgrid-alt-row", |
|
cellClass: "jsgrid-cell", |
|
sorting: !1, |
|
sortableClass: "jsgrid-header-sortable", |
|
sortAscClass: "jsgrid-header-sort jsgrid-header-sort-asc", |
|
sortDescClass: "jsgrid-header-sort jsgrid-header-sort-desc", |
|
paging: !1, |
|
pagerContainer: null, |
|
pageIndex: 1, |
|
pageSize: 20, |
|
pageButtonCount: 15, |
|
pagerFormat: |
|
"Pages: {first} {prev} {pages} {next} {last} {pageIndex} of {pageCount}", |
|
pagePrevText: "Prev", |
|
pageNextText: "Next", |
|
pageFirstText: "First", |
|
pageLastText: "Last", |
|
pageNavigatorNextText: "...", |
|
pageNavigatorPrevText: "...", |
|
pagerContainerClass: "jsgrid-pager-container", |
|
pagerClass: "jsgrid-pager", |
|
pagerNavButtonClass: "jsgrid-pager-nav-button", |
|
pagerNavButtonInactiveClass: "jsgrid-pager-nav-inactive-button", |
|
pageClass: "jsgrid-pager-page", |
|
currentPageClass: "jsgrid-pager-current-page", |
|
customLoading: !1, |
|
pageLoading: !1, |
|
autoload: !1, |
|
controller: v, |
|
loadIndication: !0, |
|
loadIndicationDelay: 500, |
|
loadMessage: "Please, wait...", |
|
loadShading: !0, |
|
invalidMessage: "Invalid data entered!", |
|
invalidNotify: function (c) { |
|
var d = b.map(c.errors, function (a) { |
|
return a.message || null; |
|
}); |
|
a.alert([this.invalidMessage].concat(d).join("\n")); |
|
}, |
|
onInit: b.noop, |
|
onRefreshing: b.noop, |
|
onRefreshed: b.noop, |
|
onPageChanged: b.noop, |
|
onItemDeleting: b.noop, |
|
onItemDeleted: b.noop, |
|
onItemInserting: b.noop, |
|
onItemInserted: b.noop, |
|
onItemEditing: b.noop, |
|
onItemUpdating: b.noop, |
|
onItemUpdated: b.noop, |
|
onItemInvalid: b.noop, |
|
onDataLoading: b.noop, |
|
onDataLoaded: b.noop, |
|
onOptionChanging: b.noop, |
|
onOptionChanged: b.noop, |
|
onError: b.noop, |
|
invalidClass: "jsgrid-invalid", |
|
containerClass: "jsgrid", |
|
tableClass: "jsgrid-table", |
|
gridHeaderClass: "jsgrid-grid-header", |
|
gridBodyClass: "jsgrid-grid-body", |
|
_init: function (a) { |
|
b.extend(this, a), |
|
this._initLoadStrategy(), |
|
this._initController(), |
|
this._initFields(), |
|
this._attachWindowLoadResize(), |
|
this._attachWindowResizeCallback(), |
|
this._callEventHandler(this.onInit); |
|
}, |
|
loadStrategy: function () { |
|
return this.pageLoading |
|
? new jsGrid.loadStrategies.PageLoadingStrategy(this) |
|
: new jsGrid.loadStrategies.DirectLoadingStrategy(this); |
|
}, |
|
_initLoadStrategy: function () { |
|
this._loadStrategy = t(this.loadStrategy, this); |
|
}, |
|
_initController: function () { |
|
this._controller = b.extend({}, v, t(this.controller, this)); |
|
}, |
|
renderTemplate: function (a, b, d) { |
|
args = []; |
|
for (var e in d) args.push(d[e]); |
|
return ( |
|
args.unshift(a, b), |
|
(a = t.apply(null, args)), |
|
a === c || null === a ? "" : a |
|
); |
|
}, |
|
loadIndicator: function (a) { |
|
return new jsGrid.LoadIndicator(a); |
|
}, |
|
validation: function (a) { |
|
return jsGrid.Validation && new jsGrid.Validation(a); |
|
}, |
|
_initFields: function () { |
|
var a = this; |
|
a.fields = b.map(a.fields, function (c) { |
|
if (b.isPlainObject(c)) { |
|
var d = (c.type && jsGrid.fields[c.type]) || jsGrid.Field; |
|
c = new d(c); |
|
} |
|
return (c._grid = a), c; |
|
}); |
|
}, |
|
_attachWindowLoadResize: function () { |
|
b(a).on("load", b.proxy(this._refreshSize, this)); |
|
}, |
|
_attachWindowResizeCallback: function () { |
|
this.updateOnResize && |
|
b(a).on("resize", b.proxy(this._refreshSize, this)); |
|
}, |
|
_detachWindowResizeCallback: function () { |
|
b(a).off("resize", this._refreshSize); |
|
}, |
|
option: function (a, b) { |
|
var c, d; |
|
return 1 === arguments.length |
|
? this[a] |
|
: ((c = { option: a, oldValue: this[a], newValue: b }), |
|
this._callEventHandler(this.onOptionChanging, c), |
|
this._handleOptionChange(c.option, c.newValue), |
|
(d = { option: c.option, value: c.newValue }), |
|
void this._callEventHandler(this.onOptionChanged, d)); |
|
}, |
|
fieldOption: function (a, b, c) { |
|
return ( |
|
(a = this._normalizeField(a)), |
|
2 === arguments.length ? a[b] : ((a[b] = c), void this._renderGrid()) |
|
); |
|
}, |
|
_handleOptionChange: function (a, b) { |
|
switch (((this[a] = b), a)) { |
|
case "width": |
|
case "height": |
|
this._refreshSize(); |
|
break; |
|
case "rowClass": |
|
case "rowRenderer": |
|
case "rowClick": |
|
case "rowDoubleClick": |
|
case "noDataRowClass": |
|
case "noDataContent": |
|
case "selecting": |
|
case "selectedRowClass": |
|
case "oddRowClass": |
|
case "evenRowClass": |
|
this._refreshContent(); |
|
break; |
|
case "pageButtonCount": |
|
case "pagerFormat": |
|
case "pagePrevText": |
|
case "pageNextText": |
|
case "pageFirstText": |
|
case "pageLastText": |
|
case "pageNavigatorNextText": |
|
case "pageNavigatorPrevText": |
|
case "pagerClass": |
|
case "pagerNavButtonClass": |
|
case "pageClass": |
|
case "currentPageClass": |
|
case "pagerRenderer": |
|
this._refreshPager(); |
|
break; |
|
case "fields": |
|
this._initFields(), this.render(); |
|
break; |
|
case "data": |
|
case "editing": |
|
case "heading": |
|
case "filtering": |
|
case "inserting": |
|
case "paging": |
|
this.refresh(); |
|
break; |
|
case "loadStrategy": |
|
case "pageLoading": |
|
this._initLoadStrategy(), this.search(); |
|
break; |
|
case "pageIndex": |
|
this.openPage(b); |
|
break; |
|
case "pageSize": |
|
this.refresh(), this.search(); |
|
break; |
|
case "editRowRenderer": |
|
case "editRowClass": |
|
this.cancelEdit(); |
|
break; |
|
case "updateOnResize": |
|
this._detachWindowResizeCallback(), |
|
this._attachWindowResizeCallback(); |
|
break; |
|
case "invalidNotify": |
|
case "invalidMessage": |
|
break; |
|
default: |
|
this.render(); |
|
} |
|
}, |
|
destroy: function () { |
|
this._detachWindowResizeCallback(), |
|
this._clear(), |
|
this._container.removeData(f); |
|
}, |
|
render: function () { |
|
return ( |
|
this._renderGrid(), |
|
this.autoload ? this.loadData() : b.Deferred().resolve().promise() |
|
); |
|
}, |
|
_renderGrid: function () { |
|
this._clear(), |
|
this._container |
|
.addClass(this.containerClass) |
|
.css("position", "relative") |
|
.append(this._createHeader()) |
|
.append(this._createBody()), |
|
(this._pagerContainer = this._createPagerContainer()), |
|
(this._loadIndicator = this._createLoadIndicator()), |
|
(this._validation = this._createValidation()), |
|
this.refresh(); |
|
}, |
|
_createLoadIndicator: function () { |
|
return t(this.loadIndicator, this, { |
|
message: this.loadMessage, |
|
shading: this.loadShading, |
|
container: this._container, |
|
}); |
|
}, |
|
_createValidation: function () { |
|
return t(this.validation, this); |
|
}, |
|
_clear: function () { |
|
this.cancelEdit(), |
|
clearTimeout(this._loadingTimer), |
|
this._pagerContainer && this._pagerContainer.empty(), |
|
this._container.empty().css({ position: "", width: "", height: "" }); |
|
}, |
|
_createHeader: function () { |
|
var a = (this._headerRow = this._createHeaderRow()), |
|
c = (this._filterRow = this._createFilterRow()), |
|
d = (this._insertRow = this._createInsertRow()), |
|
e = (this._headerGrid = b("<table>") |
|
.addClass(this.tableClass) |
|
.append(a) |
|
.append(c) |
|
.append(d)), |
|
f = (this._header = b("<div>") |
|
.addClass(this.gridHeaderClass) |
|
.addClass(this._scrollBarWidth() ? "jsgrid-header-scrollbar" : "") |
|
.append(e)); |
|
return f; |
|
}, |
|
_createBody: function () { |
|
var a = (this._content = b("<tbody>")), |
|
c = (this._bodyGrid = b("<table>").addClass(this.tableClass).append(a)), |
|
d = (this._body = b("<div>") |
|
.addClass(this.gridBodyClass) |
|
.append(c) |
|
.on( |
|
"scroll", |
|
b.proxy(function (a) { |
|
this._header.scrollLeft(a.target.scrollLeft); |
|
}, this) |
|
)); |
|
return d; |
|
}, |
|
_createPagerContainer: function () { |
|
var a = this.pagerContainer || b("<div>").appendTo(this._container); |
|
return b(a).addClass(this.pagerContainerClass); |
|
}, |
|
_eachField: function (a) { |
|
var c = this; |
|
b.each(this.fields, function (b, d) { |
|
d.visible && a.call(c, d, b); |
|
}); |
|
}, |
|
_createHeaderRow: function () { |
|
if (b.isFunction(this.headerRowRenderer)) |
|
return b(this.renderTemplate(this.headerRowRenderer, this)); |
|
var a = b("<tr>").addClass(this.headerRowClass); |
|
return ( |
|
this._eachField(function (c, d) { |
|
var e = this._prepareCell( |
|
"<th>", |
|
c, |
|
"headercss", |
|
this.headerCellClass |
|
) |
|
.append(this.renderTemplate(c.headerTemplate, c)) |
|
.appendTo(a); |
|
this.sorting && |
|
c.sorting && |
|
e.addClass(this.sortableClass).on( |
|
"click", |
|
b.proxy(function () { |
|
this.sort(d); |
|
}, this) |
|
); |
|
}), |
|
a |
|
); |
|
}, |
|
_prepareCell: function (a, c, d, e) { |
|
return b(a) |
|
.css("width", c.width) |
|
.addClass(e || this.cellClass) |
|
.addClass((d && c[d]) || c.css) |
|
.addClass(c.align ? "jsgrid-align-" + c.align : ""); |
|
}, |
|
_createFilterRow: function () { |
|
if (b.isFunction(this.filterRowRenderer)) |
|
return b(this.renderTemplate(this.filterRowRenderer, this)); |
|
var a = b("<tr>").addClass(this.filterRowClass); |
|
return ( |
|
this._eachField(function (b) { |
|
this._prepareCell("<td>", b, "filtercss") |
|
.append(this.renderTemplate(b.filterTemplate, b)) |
|
.appendTo(a); |
|
}), |
|
a |
|
); |
|
}, |
|
_createInsertRow: function () { |
|
if (b.isFunction(this.insertRowRenderer)) |
|
return b(this.renderTemplate(this.insertRowRenderer, this)); |
|
var a = b("<tr>").addClass(this.insertRowClass); |
|
return ( |
|
this._eachField(function (b) { |
|
this._prepareCell("<td>", b, "insertcss") |
|
.append(this.renderTemplate(b.insertTemplate, b)) |
|
.appendTo(a); |
|
}), |
|
a |
|
); |
|
}, |
|
_callEventHandler: function (a, c) { |
|
return a.call(this, b.extend(c, { grid: this })), c; |
|
}, |
|
reset: function () { |
|
return ( |
|
this._resetSorting(), this._resetPager(), this._loadStrategy.reset() |
|
); |
|
}, |
|
_resetPager: function () { |
|
(this._firstDisplayingPage = 1), this._setPage(1); |
|
}, |
|
_resetSorting: function () { |
|
(this._sortField = null), (this._sortOrder = i), this._clearSortingCss(); |
|
}, |
|
refresh: function () { |
|
this._callEventHandler(this.onRefreshing), |
|
this.cancelEdit(), |
|
this._refreshHeading(), |
|
this._refreshFiltering(), |
|
this._refreshInserting(), |
|
this._refreshContent(), |
|
this._refreshPager(), |
|
this._refreshSize(), |
|
this._callEventHandler(this.onRefreshed); |
|
}, |
|
_refreshHeading: function () { |
|
this._headerRow.toggle(this.heading); |
|
}, |
|
_refreshFiltering: function () { |
|
this._filterRow.toggle(this.filtering); |
|
}, |
|
_refreshInserting: function () { |
|
this._insertRow.toggle(this.inserting); |
|
}, |
|
_refreshContent: function () { |
|
var a = this._content; |
|
if ((a.empty(), !this.data.length)) |
|
return a.append(this._createNoDataRow()), this; |
|
for ( |
|
var b = this._loadStrategy.firstDisplayIndex(), |
|
c = this._loadStrategy.lastDisplayIndex(), |
|
d = b; |
|
c > d; |
|
d++ |
|
) { |
|
var e = this.data[d]; |
|
a.append(this._createRow(e, d)); |
|
} |
|
}, |
|
_createNoDataRow: function () { |
|
var a = 0; |
|
return ( |
|
this._eachField(function () { |
|
a++; |
|
}), |
|
b("<tr>") |
|
.addClass(this.noDataRowClass) |
|
.append( |
|
b("<td>") |
|
.addClass(this.cellClass) |
|
.attr("colspan", a) |
|
.append(this.renderTemplate(this.noDataContent, this)) |
|
) |
|
); |
|
}, |
|
_createRow: function (a, c) { |
|
var d; |
|
return ( |
|
b.isFunction(this.rowRenderer) |
|
? (d = this.renderTemplate(this.rowRenderer, this, { |
|
item: a, |
|
itemIndex: c, |
|
})) |
|
: ((d = b("<tr>")), this._renderCells(d, a)), |
|
d |
|
.addClass(this._getRowClasses(a, c)) |
|
.data(g, a) |
|
.on( |
|
"click", |
|
b.proxy(function (b) { |
|
this.rowClick({ item: a, itemIndex: c, event: b }); |
|
}, this) |
|
) |
|
.on( |
|
"dblclick", |
|
b.proxy(function (b) { |
|
this.rowDoubleClick({ item: a, itemIndex: c, event: b }); |
|
}, this) |
|
), |
|
this.selecting && this._attachRowHover(d), |
|
d |
|
); |
|
}, |
|
_getRowClasses: function (a, b) { |
|
var c = []; |
|
return ( |
|
c.push((b + 1) % 2 ? this.oddRowClass : this.evenRowClass), |
|
c.push(t(this.rowClass, this, a, b)), |
|
c.join(" ") |
|
); |
|
}, |
|
_attachRowHover: function (a) { |
|
var c = this.selectedRowClass; |
|
a.hover( |
|
function () { |
|
b(this).addClass(c); |
|
}, |
|
function () { |
|
b(this).removeClass(c); |
|
} |
|
); |
|
}, |
|
_renderCells: function (a, b) { |
|
return ( |
|
this._eachField(function (c) { |
|
a.append(this._createCell(b, c)); |
|
}), |
|
this |
|
); |
|
}, |
|
_createCell: function (a, c) { |
|
var d, |
|
e = this._getItemFieldValue(a, c), |
|
f = { value: e, item: a }; |
|
return ( |
|
(d = b.isFunction(c.cellRenderer) |
|
? this.renderTemplate(c.cellRenderer, c, f) |
|
: b("<td>").append(this.renderTemplate(c.itemTemplate || e, c, f))), |
|
this._prepareCell(d, c) |
|
); |
|
}, |
|
_getItemFieldValue: function (a, b) { |
|
for (var c = b.name.split("."), d = a[c.shift()]; d && c.length; ) |
|
d = d[c.shift()]; |
|
return d; |
|
}, |
|
_setItemFieldValue: function (a, b, c) { |
|
for (var d = b.name.split("."), e = a, f = d[0]; e && d.length; ) |
|
(a = e), (f = d.shift()), (e = a[f]); |
|
if (!e) for (; d.length; ) (a = a[f] = {}), (f = d.shift()); |
|
a[f] = c; |
|
}, |
|
sort: function (a, c) { |
|
return ( |
|
b.isPlainObject(a) && ((c = a.order), (a = a.field)), |
|
this._clearSortingCss(), |
|
this._setSortingParams(a, c), |
|
this._setSortingCss(), |
|
this._loadStrategy.sort() |
|
); |
|
}, |
|
_clearSortingCss: function () { |
|
this._headerRow |
|
.find("th") |
|
.removeClass(this.sortAscClass) |
|
.removeClass(this.sortDescClass); |
|
}, |
|
_setSortingParams: function (a, b) { |
|
(a = this._normalizeField(a)), |
|
(b = |
|
b || |
|
(this._sortField === a |
|
? this._reversedSortOrder(this._sortOrder) |
|
: i)), |
|
(this._sortField = a), |
|
(this._sortOrder = b); |
|
}, |
|
_normalizeField: function (a) { |
|
return b.isNumeric(a) |
|
? this.fields[a] |
|
: "string" == typeof a |
|
? b.grep(this.fields, function (b) { |
|
return b.name === a; |
|
})[0] |
|
: a; |
|
}, |
|
_reversedSortOrder: function (a) { |
|
return a === i ? j : i; |
|
}, |
|
_setSortingCss: function () { |
|
var a = this._visibleFieldIndex(this._sortField); |
|
this._headerRow |
|
.find("th") |
|
.eq(a) |
|
.addClass( |
|
this._sortOrder === i ? this.sortAscClass : this.sortDescClass |
|
); |
|
}, |
|
_visibleFieldIndex: function (a) { |
|
return b.inArray( |
|
a, |
|
b.grep(this.fields, function (a) { |
|
return a.visible; |
|
}) |
|
); |
|
}, |
|
_sortData: function () { |
|
var a = this._sortFactor(), |
|
b = this._sortField; |
|
b && |
|
this.data.sort(function (c, d) { |
|
return a * b.sortingFunc(c[b.name], d[b.name]); |
|
}); |
|
}, |
|
_sortFactor: function () { |
|
return this._sortOrder === i ? 1 : -1; |
|
}, |
|
_itemsCount: function () { |
|
return this._loadStrategy.itemsCount(); |
|
}, |
|
_pagesCount: function () { |
|
var a = this._itemsCount(), |
|
b = this.pageSize; |
|
return Math.floor(a / b) + (a % b ? 1 : 0); |
|
}, |
|
_refreshPager: function () { |
|
var a = this._pagerContainer; |
|
a.empty(), this.paging && a.append(this._createPager()); |
|
var b = this.paging && this._pagesCount() > 1; |
|
a.toggle(b); |
|
}, |
|
_createPager: function () { |
|
var a; |
|
return ( |
|
(a = b.isFunction(this.pagerRenderer) |
|
? b( |
|
this.pagerRenderer({ |
|
pageIndex: this.pageIndex, |
|
pageCount: this._pagesCount(), |
|
}) |
|
) |
|
: b("<div>").append(this._createPagerByFormat())), |
|
a.addClass(this.pagerClass), |
|
a |
|
); |
|
}, |
|
_createPagerByFormat: function () { |
|
var a = this.pageIndex, |
|
c = this._pagesCount(), |
|
d = this._itemsCount(), |
|
e = this.pagerFormat.split(" "); |
|
return b.map( |
|
e, |
|
b.proxy(function (e) { |
|
var f = e; |
|
return ( |
|
e === l |
|
? (f = this._createPages()) |
|
: e === k |
|
? (f = this._createPagerNavButton(this.pageFirstText, 1, a > 1)) |
|
: e === m |
|
? (f = this._createPagerNavButton( |
|
this.pagePrevText, |
|
a - 1, |
|
a > 1 |
|
)) |
|
: e === n |
|
? (f = this._createPagerNavButton( |
|
this.pageNextText, |
|
a + 1, |
|
c > a |
|
)) |
|
: e === o |
|
? (f = this._createPagerNavButton(this.pageLastText, c, c > a)) |
|
: e === p |
|
? (f = a) |
|
: e === q |
|
? (f = c) |
|
: e === r && (f = d), |
|
b.isArray(f) ? f.concat([" "]) : [f, " "] |
|
); |
|
}, this) |
|
); |
|
}, |
|
_createPages: function () { |
|
var a = this._pagesCount(), |
|
b = this.pageButtonCount, |
|
c = this._firstDisplayingPage, |
|
d = []; |
|
c > 1 && |
|
d.push( |
|
this._createPagerPageNavButton( |
|
this.pageNavigatorPrevText, |
|
this.showPrevPages |
|
) |
|
); |
|
for (var e = 0, f = c; b > e && a >= f; e++, f++) |
|
d.push( |
|
f === this.pageIndex |
|
? this._createPagerCurrentPage() |
|
: this._createPagerPage(f) |
|
); |
|
return ( |
|
a > c + b - 1 && |
|
d.push( |
|
this._createPagerPageNavButton( |
|
this.pageNavigatorNextText, |
|
this.showNextPages |
|
) |
|
), |
|
d |
|
); |
|
}, |
|
_createPagerNavButton: function (a, c, d) { |
|
return this._createPagerButton( |
|
a, |
|
this.pagerNavButtonClass + |
|
(d ? "" : " " + this.pagerNavButtonInactiveClass), |
|
d |
|
? function () { |
|
this.openPage(c); |
|
} |
|
: b.noop |
|
); |
|
}, |
|
_createPagerPageNavButton: function (a, b) { |
|
return this._createPagerButton(a, this.pagerNavButtonClass, b); |
|
}, |
|
_createPagerPage: function (a) { |
|
return this._createPagerButton(a, this.pageClass, function () { |
|
this.openPage(a); |
|
}); |
|
}, |
|
_createPagerButton: function (a, c, d) { |
|
var e = b("<a>").attr("href", s).html(a).on("click", b.proxy(d, this)); |
|
return b("<span>").addClass(c).append(e); |
|
}, |
|
_createPagerCurrentPage: function () { |
|
return b("<span>") |
|
.addClass(this.pageClass) |
|
.addClass(this.currentPageClass) |
|
.text(this.pageIndex); |
|
}, |
|
_refreshSize: function () { |
|
this._refreshHeight(), this._refreshWidth(); |
|
}, |
|
_refreshWidth: function () { |
|
var a = "auto" === this.width ? this._getAutoWidth() : this.width; |
|
this._container.width(a); |
|
}, |
|
_getAutoWidth: function () { |
|
var a = this._headerGrid, |
|
b = this._header; |
|
a.width("auto"); |
|
var c = a.outerWidth(), |
|
d = b.outerWidth() - b.innerWidth(); |
|
return a.width(""), c + d; |
|
}, |
|
_scrollBarWidth: (function () { |
|
var a; |
|
return function () { |
|
if (a === c) { |
|
var d = b( |
|
"<div style='width:50px;height:50px;overflow:hidden;position:absolute;top:-10000px;left:-10000px;'></div>" |
|
), |
|
e = b("<div style='height:100px;'></div>"); |
|
d.append(e).appendTo("body"); |
|
var f = e.innerWidth(); |
|
d.css("overflow-y", "auto"); |
|
var g = e.innerWidth(); |
|
d.remove(), (a = f - g); |
|
} |
|
return a; |
|
}; |
|
})(), |
|
_refreshHeight: function () { |
|
var a, |
|
b = this._container, |
|
c = this._pagerContainer, |
|
d = this.height; |
|
b.height(d), |
|
"auto" !== d && |
|
((d = b.height()), |
|
(a = this._header.outerHeight(!0)), |
|
c.parents(b).length && (a += c.outerHeight(!0)), |
|
this._body.outerHeight(d - a)); |
|
}, |
|
showPrevPages: function () { |
|
var a = this._firstDisplayingPage, |
|
b = this.pageButtonCount; |
|
(this._firstDisplayingPage = a > b ? a - b : 1), this._refreshPager(); |
|
}, |
|
showNextPages: function () { |
|
var a = this._firstDisplayingPage, |
|
b = this.pageButtonCount, |
|
c = this._pagesCount(); |
|
(this._firstDisplayingPage = a + 2 * b > c ? c - b + 1 : a + b), |
|
this._refreshPager(); |
|
}, |
|
openPage: function (a) { |
|
1 > a || |
|
a > this._pagesCount() || |
|
(this._setPage(a), this._loadStrategy.openPage(a)); |
|
}, |
|
_setPage: function (a) { |
|
var b = this._firstDisplayingPage, |
|
c = this.pageButtonCount; |
|
(this.pageIndex = a), |
|
b > a && (this._firstDisplayingPage = a), |
|
a > b + c - 1 && (this._firstDisplayingPage = a - c + 1), |
|
this._callEventHandler(this.onPageChanged, { pageIndex: a }); |
|
}, |
|
_controllerCall: function (a, c, d, e) { |
|
if (d) return b.Deferred().reject().promise(); |
|
this._showLoading(); |
|
var f = this._controller; |
|
if (!f || !f[a]) throw Error("controller has no method '" + a + "'"); |
|
return u(f[a](c)) |
|
.done(b.proxy(e, this)) |
|
.fail(b.proxy(this._errorHandler, this)) |
|
.always(b.proxy(this._hideLoading, this)); |
|
}, |
|
_errorHandler: function () { |
|
this._callEventHandler(this.onError, { args: b.makeArray(arguments) }); |
|
}, |
|
_showLoading: function () { |
|
this.loadIndication && |
|
(clearTimeout(this._loadingTimer), |
|
(this._loadingTimer = setTimeout( |
|
b.proxy(function () { |
|
this._loadIndicator.show(); |
|
}, this), |
|
this.loadIndicationDelay |
|
))); |
|
}, |
|
_hideLoading: function () { |
|
this.loadIndication && |
|
(clearTimeout(this._loadingTimer), this._loadIndicator.hide()); |
|
}, |
|
search: function (a) { |
|
return this._resetSorting(), this._resetPager(), this.loadData(a); |
|
}, |
|
loadData: function (a) { |
|
(a = a || (this.filtering ? this.getFilter() : {})), |
|
b.extend(a, this._loadStrategy.loadParams(), this._sortingParams()); |
|
var c = this._callEventHandler(this.onDataLoading, { filter: a }); |
|
return this._controllerCall("loadData", a, c.cancel, function (a) { |
|
a && |
|
(this._loadStrategy.finishLoad(a), |
|
this._callEventHandler(this.onDataLoaded, { data: a })); |
|
}); |
|
}, |
|
getFilter: function () { |
|
var a = {}; |
|
return ( |
|
this._eachField(function (b) { |
|
b.filtering && this._setItemFieldValue(a, b, b.filterValue()); |
|
}), |
|
a |
|
); |
|
}, |
|
_sortingParams: function () { |
|
return this.sorting && this._sortField |
|
? { sortField: this._sortField.name, sortOrder: this._sortOrder } |
|
: {}; |
|
}, |
|
getSorting: function () { |
|
var a = this._sortingParams(); |
|
return { field: a.sortField, order: a.sortOrder }; |
|
}, |
|
clearFilter: function () { |
|
var a = this._createFilterRow(); |
|
return ( |
|
this._filterRow.replaceWith(a), (this._filterRow = a), this.search() |
|
); |
|
}, |
|
insertItem: function (a) { |
|
var c = a || this._getValidatedInsertItem(); |
|
if (!c) return b.Deferred().reject().promise(); |
|
var d = this._callEventHandler(this.onItemInserting, { item: c }); |
|
return this._controllerCall("insertItem", c, d.cancel, function (a) { |
|
(a = a || c), |
|
this._loadStrategy.finishInsert(a), |
|
this._callEventHandler(this.onItemInserted, { item: a }); |
|
}); |
|
}, |
|
_getValidatedInsertItem: function () { |
|
var a = this._getInsertItem(); |
|
return this._validateItem(a, this._insertRow) ? a : null; |
|
}, |
|
_getInsertItem: function () { |
|
var a = {}; |
|
return ( |
|
this._eachField(function (b) { |
|
b.inserting && this._setItemFieldValue(a, b, b.insertValue()); |
|
}), |
|
a |
|
); |
|
}, |
|
_validateItem: function (a, c) { |
|
var d = [], |
|
e = { item: a, itemIndex: this._rowIndex(c), row: c }; |
|
if ( |
|
(this._eachField(function (f) { |
|
if ( |
|
f.validate && |
|
(c !== this._insertRow || f.inserting) && |
|
(c !== this._getEditRow() || f.editing) |
|
) { |
|
var g = this._getItemFieldValue(a, f), |
|
h = this._validation.validate( |
|
b.extend({ value: g, rules: f.validate }, e) |
|
); |
|
this._setCellValidity( |
|
c.children().eq(this._visibleFieldIndex(f)), |
|
h |
|
), |
|
h.length && |
|
d.push.apply( |
|
d, |
|
b.map(h, function (a) { |
|
return { field: f, message: a }; |
|
}) |
|
); |
|
} |
|
}), |
|
!d.length) |
|
) |
|
return !0; |
|
var f = b.extend({ errors: d }, e); |
|
return ( |
|
this._callEventHandler(this.onItemInvalid, f), this.invalidNotify(f), !1 |
|
); |
|
}, |
|
_setCellValidity: function (a, b) { |
|
a.toggleClass(this.invalidClass, !!b.length).attr("title", b.join("\n")); |
|
}, |
|
clearInsert: function () { |
|
var a = this._createInsertRow(); |
|
this._insertRow.replaceWith(a), (this._insertRow = a), this.refresh(); |
|
}, |
|
editItem: function (a) { |
|
var b = this.rowByItem(a); |
|
b.length && this._editRow(b); |
|
}, |
|
rowByItem: function (a) { |
|
return a.jquery || a.nodeType |
|
? b(a) |
|
: this._content.find("tr").filter(function () { |
|
return b.data(this, g) === a; |
|
}); |
|
}, |
|
_editRow: function (a) { |
|
if (this.editing) { |
|
var b = a.data(g), |
|
c = this._callEventHandler(this.onItemEditing, { |
|
row: a, |
|
item: b, |
|
itemIndex: this._itemIndex(b), |
|
}); |
|
if (!c.cancel) { |
|
this._editingRow && this.cancelEdit(); |
|
var d = this._createEditRow(b); |
|
(this._editingRow = a), a.hide(), d.insertBefore(a), a.data(h, d); |
|
} |
|
} |
|
}, |
|
_createEditRow: function (a) { |
|
if (b.isFunction(this.editRowRenderer)) |
|
return b( |
|
this.renderTemplate(this.editRowRenderer, this, { |
|
item: a, |
|
itemIndex: this._itemIndex(a), |
|
}) |
|
); |
|
var c = b("<tr>").addClass(this.editRowClass); |
|
return ( |
|
this._eachField(function (b) { |
|
var d = this._getItemFieldValue(a, b); |
|
this._prepareCell("<td>", b, "editcss") |
|
.append( |
|
this.renderTemplate(b.editTemplate || "", b, { |
|
value: d, |
|
item: a, |
|
}) |
|
) |
|
.appendTo(c); |
|
}), |
|
c |
|
); |
|
}, |
|
updateItem: function (a, b) { |
|
1 === arguments.length && (b = a); |
|
var c = a ? this.rowByItem(a) : this._editingRow; |
|
return (b = b || this._getValidatedEditedItem()) |
|
? this._updateRow(c, b) |
|
: void 0; |
|
}, |
|
_getValidatedEditedItem: function () { |
|
var a = this._getEditedItem(); |
|
return this._validateItem(a, this._getEditRow()) ? a : null; |
|
}, |
|
_updateRow: function (a, c) { |
|
var d = a.data(g), |
|
e = this._itemIndex(d), |
|
f = b.extend(!0, {}, d, c), |
|
h = this._callEventHandler(this.onItemUpdating, { |
|
row: a, |
|
item: f, |
|
itemIndex: e, |
|
previousItem: d, |
|
}); |
|
return this._controllerCall("updateItem", f, h.cancel, function (g) { |
|
var h = b.extend(!0, {}, d); |
|
f = g || b.extend(!0, d, c); |
|
var i = this._finishUpdate(a, f, e); |
|
this._callEventHandler(this.onItemUpdated, { |
|
row: i, |
|
item: f, |
|
itemIndex: e, |
|
previousItem: h, |
|
}); |
|
}); |
|
}, |
|
_rowIndex: function (a) { |
|
return this._content.children().index(b(a)); |
|
}, |
|
_itemIndex: function (a) { |
|
return b.inArray(a, this.data); |
|
}, |
|
_finishUpdate: function (a, b, c) { |
|
this.cancelEdit(), (this.data[c] = b); |
|
var d = this._createRow(b, c); |
|
return a.replaceWith(d), d; |
|
}, |
|
_getEditedItem: function () { |
|
var a = {}; |
|
return ( |
|
this._eachField(function (b) { |
|
b.editing && this._setItemFieldValue(a, b, b.editValue()); |
|
}), |
|
a |
|
); |
|
}, |
|
cancelEdit: function () { |
|
this._editingRow && |
|
(this._getEditRow().remove(), |
|
this._editingRow.show(), |
|
(this._editingRow = null)); |
|
}, |
|
_getEditRow: function () { |
|
return this._editingRow && this._editingRow.data(h); |
|
}, |
|
deleteItem: function (b) { |
|
var c = this.rowByItem(b); |
|
if ( |
|
c.length && |
|
(!this.confirmDeleting || |
|
a.confirm(t(this.deleteConfirm, this, c.data(g)))) |
|
) |
|
return this._deleteRow(c); |
|
}, |
|
_deleteRow: function (a) { |
|
var b = a.data(g), |
|
c = this._itemIndex(b), |
|
d = this._callEventHandler(this.onItemDeleting, { |
|
row: a, |
|
item: b, |
|
itemIndex: c, |
|
}); |
|
return this._controllerCall("deleteItem", b, d.cancel, function () { |
|
this._loadStrategy.finishDelete(b, c), |
|
this._callEventHandler(this.onItemDeleted, { |
|
row: a, |
|
item: b, |
|
itemIndex: c, |
|
}); |
|
}); |
|
}, |
|
}), |
|
(b.fn.jsGrid = function (a) { |
|
var e = b.makeArray(arguments), |
|
g = e.slice(1), |
|
h = this; |
|
return ( |
|
this.each(function () { |
|
var e, |
|
i = b(this), |
|
j = i.data(f); |
|
if (j) |
|
if ("string" == typeof a) { |
|
if (((e = j[a].apply(j, g)), e !== c && e !== j)) |
|
return (h = e), !1; |
|
} else j._detachWindowResizeCallback(), j._init(a), j.render(); |
|
else new d(i, a); |
|
}), |
|
h |
|
); |
|
}); |
|
var w = {}, |
|
x = function (a) { |
|
var c; |
|
b.isPlainObject(a) |
|
? (c = d.prototype) |
|
: ((c = w[a].prototype), (a = arguments[1] || {})), |
|
b.extend(c, a); |
|
}, |
|
y = {}, |
|
z = function (a) { |
|
var c = b.isPlainObject(a) ? a : y[a]; |
|
if (!c) throw Error("unknown locale " + a); |
|
A(jsGrid, c); |
|
}, |
|
A = function (a, c) { |
|
b.each(c, function (c, d) { |
|
return b.isPlainObject(d) |
|
? void A(a[c] || a[c[0].toUpperCase() + c.slice(1)], d) |
|
: void (a.hasOwnProperty(c) ? (a[c] = d) : (a.prototype[c] = d)); |
|
}); |
|
}; |
|
a.jsGrid = { |
|
Grid: d, |
|
fields: w, |
|
setDefaults: x, |
|
locales: y, |
|
locale: z, |
|
version: "1.5.3", |
|
}; |
|
})(window, jQuery), |
|
(function (a, b) { |
|
function c(a) { |
|
this._init(a); |
|
} |
|
(c.prototype = { |
|
container: "body", |
|
message: "Loading...", |
|
shading: !0, |
|
zIndex: 1e3, |
|
shaderClass: "jsgrid-load-shader", |
|
loadPanelClass: "jsgrid-load-panel", |
|
_init: function (a) { |
|
b.extend(!0, this, a), |
|
this._initContainer(), |
|
this._initShader(), |
|
this._initLoadPanel(); |
|
}, |
|
_initContainer: function () { |
|
this._container = b(this.container); |
|
}, |
|
_initShader: function () { |
|
this.shading && |
|
(this._shader = b("<div>") |
|
.addClass(this.shaderClass) |
|
.hide() |
|
.css({ |
|
position: "absolute", |
|
top: 0, |
|
right: 0, |
|
bottom: 0, |
|
left: 0, |
|
zIndex: this.zIndex, |
|
}) |
|
.appendTo(this._container)); |
|
}, |
|
_initLoadPanel: function () { |
|
this._loadPanel = b("<div>") |
|
.addClass(this.loadPanelClass) |
|
.text(this.message) |
|
.hide() |
|
.css({ |
|
position: "absolute", |
|
top: "50%", |
|
left: "50%", |
|
zIndex: this.zIndex, |
|
}) |
|
.appendTo(this._container); |
|
}, |
|
show: function () { |
|
var a = this._loadPanel.show(), |
|
b = a.outerWidth(), |
|
c = a.outerHeight(); |
|
a.css({ marginTop: -c / 2, marginLeft: -b / 2 }), this._shader.show(); |
|
}, |
|
hide: function () { |
|
this._loadPanel.hide(), this._shader.hide(); |
|
}, |
|
}), |
|
(a.LoadIndicator = c); |
|
})(jsGrid, jQuery), |
|
(function (a, b) { |
|
function c(a) { |
|
this._grid = a; |
|
} |
|
function d(a) { |
|
(this._grid = a), (this._itemsCount = 0); |
|
} |
|
(c.prototype = { |
|
firstDisplayIndex: function () { |
|
var a = this._grid; |
|
return a.option("paging") |
|
? (a.option("pageIndex") - 1) * a.option("pageSize") |
|
: 0; |
|
}, |
|
lastDisplayIndex: function () { |
|
var a = this._grid, |
|
b = a.option("data").length; |
|
return a.option("paging") |
|
? Math.min(a.option("pageIndex") * a.option("pageSize"), b) |
|
: b; |
|
}, |
|
itemsCount: function () { |
|
return this._grid.option("data").length; |
|
}, |
|
openPage: function () { |
|
this._grid.refresh(); |
|
}, |
|
loadParams: function () { |
|
return {}; |
|
}, |
|
sort: function () { |
|
return ( |
|
this._grid._sortData(), |
|
this._grid.refresh(), |
|
b.Deferred().resolve().promise() |
|
); |
|
}, |
|
reset: function () { |
|
return this._grid.refresh(), b.Deferred().resolve().promise(); |
|
}, |
|
finishLoad: function (a) { |
|
this._grid.option("data", a); |
|
}, |
|
finishInsert: function (a) { |
|
var b = this._grid; |
|
b.option("data").push(a), b.refresh(); |
|
}, |
|
finishDelete: function (a, b) { |
|
var c = this._grid; |
|
c.option("data").splice(b, 1), c.reset(); |
|
}, |
|
}), |
|
(d.prototype = { |
|
firstDisplayIndex: function () { |
|
return 0; |
|
}, |
|
lastDisplayIndex: function () { |
|
return this._grid.option("data").length; |
|
}, |
|
itemsCount: function () { |
|
return this._itemsCount; |
|
}, |
|
openPage: function () { |
|
this._grid.loadData(); |
|
}, |
|
loadParams: function () { |
|
var a = this._grid; |
|
return { |
|
pageIndex: a.option("pageIndex"), |
|
pageSize: a.option("pageSize"), |
|
}; |
|
}, |
|
reset: function () { |
|
return this._grid.loadData(); |
|
}, |
|
sort: function () { |
|
return this._grid.loadData(); |
|
}, |
|
finishLoad: function (a) { |
|
(this._itemsCount = a.itemsCount), this._grid.option("data", a.data); |
|
}, |
|
finishInsert: function () { |
|
this._grid.search(); |
|
}, |
|
finishDelete: function () { |
|
this._grid.search(); |
|
}, |
|
}), |
|
(a.loadStrategies = { DirectLoadingStrategy: c, PageLoadingStrategy: d }); |
|
})(jsGrid, jQuery), |
|
(function (a) { |
|
var b = function (a) { |
|
return "undefined" != typeof a && null !== a; |
|
}, |
|
c = { |
|
string: function (a, c) { |
|
return b(a) || b(c) |
|
? b(a) |
|
? b(c) |
|
? ("" + a).localeCompare("" + c) |
|
: 1 |
|
: -1 |
|
: 0; |
|
}, |
|
number: function (a, b) { |
|
return a - b; |
|
}, |
|
date: function (a, b) { |
|
return a - b; |
|
}, |
|
numberAsString: function (a, b) { |
|
return parseFloat(a) - parseFloat(b); |
|
}, |
|
}; |
|
a.sortStrategies = c; |
|
})(jsGrid, jQuery), |
|
(function (a, b, c) { |
|
function d(a) { |
|
this._init(a); |
|
} |
|
(d.prototype = { |
|
_init: function (a) { |
|
b.extend(!0, this, a); |
|
}, |
|
validate: function (a) { |
|
var c = []; |
|
return ( |
|
b.each(this._normalizeRules(a.rules), function (d, e) { |
|
if (!e.validator(a.value, a.item, e.param)) { |
|
var f = b.isFunction(e.message) |
|
? e.message(a.value, a.item) |
|
: e.message; |
|
c.push(f); |
|
} |
|
}), |
|
c |
|
); |
|
}, |
|
_normalizeRules: function (a) { |
|
return ( |
|
b.isArray(a) || (a = [a]), |
|
b.map( |
|
a, |
|
b.proxy(function (a) { |
|
return this._normalizeRule(a); |
|
}, this) |
|
) |
|
); |
|
}, |
|
_normalizeRule: function (a) { |
|
if ( |
|
("string" == typeof a && (a = { validator: a }), |
|
b.isFunction(a) && (a = { validator: a }), |
|
!b.isPlainObject(a)) |
|
) |
|
throw Error("wrong validation config specified"); |
|
return ( |
|
(a = b.extend({}, a)), |
|
b.isFunction(a.validator) |
|
? a |
|
: this._applyNamedValidator(a, a.validator) |
|
); |
|
}, |
|
_applyNamedValidator: function (a, c) { |
|
delete a.validator; |
|
var d = e[c]; |
|
if (!d) throw Error('unknown validator "' + c + '"'); |
|
return b.isFunction(d) && (d = { validator: d }), b.extend({}, d, a); |
|
}, |
|
}), |
|
(a.Validation = d); |
|
var e = { |
|
required: { |
|
message: "Field is required", |
|
validator: function (a) { |
|
return a !== c && null !== a && "" !== a; |
|
}, |
|
}, |
|
rangeLength: { |
|
message: "Field value length is out of the defined range", |
|
validator: function (a, b, c) { |
|
return a.length >= c[0] && a.length <= c[1]; |
|
}, |
|
}, |
|
minLength: { |
|
message: "Field value is too short", |
|
validator: function (a, b, c) { |
|
return a.length >= c; |
|
}, |
|
}, |
|
maxLength: { |
|
message: "Field value is too long", |
|
validator: function (a, b, c) { |
|
return a.length <= c; |
|
}, |
|
}, |
|
pattern: { |
|
message: "Field value is not matching the defined pattern", |
|
validator: function (a, b, c) { |
|
return ( |
|
"string" == typeof c && (c = new RegExp("^(?:" + c + ")$")), |
|
c.test(a) |
|
); |
|
}, |
|
}, |
|
range: { |
|
message: "Field value is out of the defined range", |
|
validator: function (a, b, c) { |
|
return a >= c[0] && a <= c[1]; |
|
}, |
|
}, |
|
min: { |
|
message: "Field value is too small", |
|
validator: function (a, b, c) { |
|
return a >= c; |
|
}, |
|
}, |
|
max: { |
|
message: "Field value is too large", |
|
validator: function (a, b, c) { |
|
return c >= a; |
|
}, |
|
}, |
|
}; |
|
a.validators = e; |
|
})(jsGrid, jQuery), |
|
(function (a, b, c) { |
|
function d(a) { |
|
b.extend(!0, this, a), (this.sortingFunc = this._getSortingFunc()); |
|
} |
|
(d.prototype = { |
|
name: "", |
|
title: null, |
|
css: "", |
|
align: "", |
|
width: 100, |
|
visible: !0, |
|
filtering: !0, |
|
inserting: !0, |
|
editing: !0, |
|
sorting: !0, |
|
sorter: "string", |
|
headerTemplate: function () { |
|
return this.title === c || null === this.title ? this.name : this.title; |
|
}, |
|
itemTemplate: function (a) { |
|
return a; |
|
}, |
|
filterTemplate: function () { |
|
return ""; |
|
}, |
|
insertTemplate: function () { |
|
return ""; |
|
}, |
|
editTemplate: function (a, b) { |
|
return (this._value = a), this.itemTemplate(a, b); |
|
}, |
|
filterValue: function () { |
|
return ""; |
|
}, |
|
insertValue: function () { |
|
return ""; |
|
}, |
|
editValue: function () { |
|
return this._value; |
|
}, |
|
_getSortingFunc: function () { |
|
var c = this.sorter; |
|
if (b.isFunction(c)) return c; |
|
if ("string" == typeof c) return a.sortStrategies[c]; |
|
throw Error('wrong sorter for the field "' + this.name + '"!'); |
|
}, |
|
}), |
|
(a.Field = d); |
|
})(jsGrid, jQuery), |
|
(function (a, b) { |
|
function c(a) { |
|
d.call(this, a); |
|
} |
|
var d = a.Field; |
|
(c.prototype = new d({ |
|
autosearch: !0, |
|
readOnly: !1, |
|
filterTemplate: function () { |
|
if (!this.filtering) return ""; |
|
var a = this._grid, |
|
b = (this.filterControl = this._createTextBox()); |
|
return ( |
|
this.autosearch && |
|
b.on("keypress", function (b) { |
|
13 === b.which && (a.search(), b.preventDefault()); |
|
}), |
|
b |
|
); |
|
}, |
|
insertTemplate: function () { |
|
return this.inserting |
|
? (this.insertControl = this._createTextBox()) |
|
: ""; |
|
}, |
|
editTemplate: function (a) { |
|
if (!this.editing) return this.itemTemplate.apply(this, arguments); |
|
var b = (this.editControl = this._createTextBox()); |
|
return b.val(a), b; |
|
}, |
|
filterValue: function () { |
|
return this.filterControl.val(); |
|
}, |
|
insertValue: function () { |
|
return this.insertControl.val(); |
|
}, |
|
editValue: function () { |
|
return this.editControl.val(); |
|
}, |
|
_createTextBox: function () { |
|
return b("<input>") |
|
.attr("type", "text") |
|
.prop("readonly", !!this.readOnly); |
|
}, |
|
})), |
|
(a.fields.text = a.TextField = c); |
|
})(jsGrid, jQuery), |
|
(function (a, b, c) { |
|
function d(a) { |
|
e.call(this, a); |
|
} |
|
var e = a.TextField; |
|
(d.prototype = new e({ |
|
sorter: "number", |
|
align: "right", |
|
readOnly: !1, |
|
filterValue: function () { |
|
return this.filterControl.val() |
|
? parseInt(this.filterControl.val() || 0, 10) |
|
: c; |
|
}, |
|
insertValue: function () { |
|
return this.insertControl.val() |
|
? parseInt(this.insertControl.val() || 0, 10) |
|
: c; |
|
}, |
|
editValue: function () { |
|
return this.editControl.val() |
|
? parseInt(this.editControl.val() || 0, 10) |
|
: c; |
|
}, |
|
_createTextBox: function () { |
|
return b("<input>") |
|
.attr("type", "number") |
|
.prop("readonly", !!this.readOnly); |
|
}, |
|
})), |
|
(a.fields.number = a.NumberField = d); |
|
})(jsGrid, jQuery), |
|
(function (a, b) { |
|
function c(a) { |
|
d.call(this, a); |
|
} |
|
var d = a.TextField; |
|
(c.prototype = new d({ |
|
insertTemplate: function () { |
|
return this.inserting |
|
? (this.insertControl = this._createTextArea()) |
|
: ""; |
|
}, |
|
editTemplate: function (a) { |
|
if (!this.editing) return this.itemTemplate.apply(this, arguments); |
|
var b = (this.editControl = this._createTextArea()); |
|
return b.val(a), b; |
|
}, |
|
_createTextArea: function () { |
|
return b("<textarea>").prop("readonly", !!this.readOnly); |
|
}, |
|
})), |
|
(a.fields.textarea = a.TextAreaField = c); |
|
})(jsGrid, jQuery), |
|
(function (a, b, c) { |
|
function d(a) { |
|
if ( |
|
((this.items = []), |
|
(this.selectedIndex = -1), |
|
(this.valueField = ""), |
|
(this.textField = ""), |
|
a.valueField && a.items.length) |
|
) { |
|
var b = a.items[0][a.valueField]; |
|
this.valueType = typeof b === f ? f : g; |
|
} |
|
(this.sorter = this.valueType), e.call(this, a); |
|
} |
|
var e = a.NumberField, |
|
f = "number", |
|
g = "string"; |
|
(d.prototype = new e({ |
|
align: "center", |
|
valueType: f, |
|
itemTemplate: function (a) { |
|
var d, |
|
e = this.items, |
|
f = this.valueField, |
|
g = this.textField; |
|
d = f |
|
? b.grep(e, function (b) { |
|
return b[f] === a; |
|
})[0] || {} |
|
: e[a]; |
|
var h = g ? d[g] : d; |
|
return h === c || null === h ? "" : h; |
|
}, |
|
filterTemplate: function () { |
|
if (!this.filtering) return ""; |
|
var a = this._grid, |
|
b = (this.filterControl = this._createSelect()); |
|
return ( |
|
this.autosearch && |
|
b.on("change", function () { |
|
a.search(); |
|
}), |
|
b |
|
); |
|
}, |
|
insertTemplate: function () { |
|
return this.inserting |
|
? (this.insertControl = this._createSelect()) |
|
: ""; |
|
}, |
|
editTemplate: function (a) { |
|
if (!this.editing) return this.itemTemplate.apply(this, arguments); |
|
var b = (this.editControl = this._createSelect()); |
|
return a !== c && b.val(a), b; |
|
}, |
|
filterValue: function () { |
|
var a = this.filterControl.val(); |
|
return this.valueType === f ? parseInt(a || 0, 10) : a; |
|
}, |
|
insertValue: function () { |
|
var a = this.insertControl.val(); |
|
return this.valueType === f ? parseInt(a || 0, 10) : a; |
|
}, |
|
editValue: function () { |
|
var a = this.editControl.val(); |
|
return this.valueType === f ? parseInt(a || 0, 10) : a; |
|
}, |
|
_createSelect: function () { |
|
var a = b("<select>"), |
|
c = this.valueField, |
|
d = this.textField, |
|
e = this.selectedIndex; |
|
return ( |
|
b.each(this.items, function (f, g) { |
|
var h = c ? g[c] : f, |
|
i = d ? g[d] : g, |
|
j = b("<option>").attr("value", h).text(i).appendTo(a); |
|
j.prop("selected", e === f); |
|
}), |
|
a.prop("disabled", !!this.readOnly), |
|
a |
|
); |
|
}, |
|
})), |
|
(a.fields.select = a.SelectField = d); |
|
})(jsGrid, jQuery), |
|
(function (a, b, c) { |
|
function d(a) { |
|
e.call(this, a); |
|
} |
|
var e = a.Field; |
|
(d.prototype = new e({ |
|
sorter: "number", |
|
align: "center", |
|
autosearch: !0, |
|
itemTemplate: function (a) { |
|
return this._createCheckbox().prop({ checked: a, disabled: !0 }); |
|
}, |
|
filterTemplate: function () { |
|
if (!this.filtering) return ""; |
|
var a = this._grid, |
|
c = (this.filterControl = this._createCheckbox()); |
|
return ( |
|
c.prop({ readOnly: !0, indeterminate: !0 }), |
|
c.on("click", function () { |
|
var a = b(this); |
|
a.prop("readOnly") |
|
? a.prop({ checked: !1, readOnly: !1 }) |
|
: a.prop("checked") || |
|
a.prop({ readOnly: !0, indeterminate: !0 }); |
|
}), |
|
this.autosearch && |
|
c.on("click", function () { |
|
a.search(); |
|
}), |
|
c |
|
); |
|
}, |
|
insertTemplate: function () { |
|
return this.inserting |
|
? (this.insertControl = this._createCheckbox()) |
|
: ""; |
|
}, |
|
editTemplate: function (a) { |
|
if (!this.editing) return this.itemTemplate.apply(this, arguments); |
|
var b = (this.editControl = this._createCheckbox()); |
|
return b.prop("checked", a), b; |
|
}, |
|
filterValue: function () { |
|
return this.filterControl.get(0).indeterminate |
|
? c |
|
: this.filterControl.is(":checked"); |
|
}, |
|
insertValue: function () { |
|
return this.insertControl.is(":checked"); |
|
}, |
|
editValue: function () { |
|
return this.editControl.is(":checked"); |
|
}, |
|
_createCheckbox: function () { |
|
return b("<input>").attr("type", "checkbox"); |
|
}, |
|
})), |
|
(a.fields.checkbox = a.CheckboxField = d); |
|
})(jsGrid, jQuery), |
|
(function (a, b) { |
|
function c(a) { |
|
d.call(this, a), (this._configInitialized = !1); |
|
} |
|
var d = a.Field; |
|
(c.prototype = new d({ |
|
css: "jsgrid-control-field", |
|
align: "center", |
|
width: 50, |
|
filtering: !1, |
|
inserting: !1, |
|
editing: !1, |
|
sorting: !1, |
|
buttonClass: "jsgrid-button", |
|
modeButtonClass: "jsgrid-mode-button", |
|
modeOnButtonClass: "jsgrid-mode-on-button", |
|
searchModeButtonClass: "jsgrid-search-mode-button", |
|
insertModeButtonClass: "jsgrid-insert-mode-button", |
|
editButtonClass: "jsgrid-edit-button", |
|
deleteButtonClass: "jsgrid-delete-button", |
|
searchButtonClass: "jsgrid-search-button", |
|
clearFilterButtonClass: "jsgrid-clear-filter-button", |
|
insertButtonClass: "jsgrid-insert-button", |
|
updateButtonClass: "jsgrid-update-button", |
|
cancelEditButtonClass: "jsgrid-cancel-edit-button", |
|
searchModeButtonTooltip: "Switch to searching", |
|
insertModeButtonTooltip: "Switch to inserting", |
|
editButtonTooltip: "Edit", |
|
deleteButtonTooltip: "Delete", |
|
searchButtonTooltip: "Search", |
|
clearFilterButtonTooltip: "Clear filter", |
|
insertButtonTooltip: "Insert", |
|
updateButtonTooltip: "Update", |
|
cancelEditButtonTooltip: "Cancel edit", |
|
editButton: !0, |
|
deleteButton: !0, |
|
clearFilterButton: !0, |
|
modeSwitchButton: !0, |
|
_initConfig: function () { |
|
(this._hasFiltering = this._grid.filtering), |
|
(this._hasInserting = this._grid.inserting), |
|
this._hasInserting && |
|
this.modeSwitchButton && |
|
(this._grid.inserting = !1), |
|
(this._configInitialized = !0); |
|
}, |
|
headerTemplate: function () { |
|
this._configInitialized || this._initConfig(); |
|
var a = this._hasFiltering, |
|
b = this._hasInserting; |
|
return this.modeSwitchButton && (a || b) |
|
? a && !b |
|
? this._createFilterSwitchButton() |
|
: b && !a |
|
? this._createInsertSwitchButton() |
|
: this._createModeSwitchButton() |
|
: ""; |
|
}, |
|
itemTemplate: function (a, c) { |
|
var d = b([]); |
|
return ( |
|
this.editButton && (d = d.add(this._createEditButton(c))), |
|
this.deleteButton && (d = d.add(this._createDeleteButton(c))), |
|
d |
|
); |
|
}, |
|
filterTemplate: function () { |
|
var a = this._createSearchButton(); |
|
return this.clearFilterButton |
|
? a.add(this._createClearFilterButton()) |
|
: a; |
|
}, |
|
insertTemplate: function () { |
|
return this._createInsertButton(); |
|
}, |
|
editTemplate: function () { |
|
return this._createUpdateButton().add(this._createCancelEditButton()); |
|
}, |
|
_createFilterSwitchButton: function () { |
|
return this._createOnOffSwitchButton( |
|
"filtering", |
|
this.searchModeButtonClass, |
|
!0 |
|
); |
|
}, |
|
_createInsertSwitchButton: function () { |
|
return this._createOnOffSwitchButton( |
|
"inserting", |
|
this.insertModeButtonClass, |
|
!1 |
|
); |
|
}, |
|
_createOnOffSwitchButton: function (a, c, d) { |
|
var e = d, |
|
f = b.proxy(function () { |
|
g.toggleClass(this.modeOnButtonClass, e); |
|
}, this), |
|
g = this._createGridButton( |
|
this.modeButtonClass + " " + c, |
|
"", |
|
function (b) { |
|
(e = !e), b.option(a, e), f(); |
|
} |
|
); |
|
return f(), g; |
|
}, |
|
_createModeSwitchButton: function () { |
|
var a = !1, |
|
c = b.proxy(function () { |
|
d.attr( |
|
"title", |
|
a ? this.searchModeButtonTooltip : this.insertModeButtonTooltip |
|
) |
|
.toggleClass(this.insertModeButtonClass, !a) |
|
.toggleClass(this.searchModeButtonClass, a); |
|
}, this), |
|
d = this._createGridButton(this.modeButtonClass, "", function (b) { |
|
(a = !a), b.option("inserting", a), b.option("filtering", !a), c(); |
|
}); |
|
return c(), d; |
|
}, |
|
_createEditButton: function (a) { |
|
return this._createGridButton( |
|
this.editButtonClass, |
|
this.editButtonTooltip, |
|
function (b, c) { |
|
b.editItem(a), c.stopPropagation(); |
|
} |
|
); |
|
}, |
|
_createDeleteButton: function (a) { |
|
return this._createGridButton( |
|
this.deleteButtonClass, |
|
this.deleteButtonTooltip, |
|
function (b, c) { |
|
b.deleteItem(a), c.stopPropagation(); |
|
} |
|
); |
|
}, |
|
_createSearchButton: function () { |
|
return this._createGridButton( |
|
this.searchButtonClass, |
|
this.searchButtonTooltip, |
|
function (a) { |
|
a.search(); |
|
} |
|
); |
|
}, |
|
_createClearFilterButton: function () { |
|
return this._createGridButton( |
|
this.clearFilterButtonClass, |
|
this.clearFilterButtonTooltip, |
|
function (a) { |
|
a.clearFilter(); |
|
} |
|
); |
|
}, |
|
_createInsertButton: function () { |
|
return this._createGridButton( |
|
this.insertButtonClass, |
|
this.insertButtonTooltip, |
|
function (a) { |
|
a.insertItem().done(function () { |
|
a.clearInsert(); |
|
}); |
|
} |
|
); |
|
}, |
|
_createUpdateButton: function () { |
|
return this._createGridButton( |
|
this.updateButtonClass, |
|
this.updateButtonTooltip, |
|
function (a, b) { |
|
a.updateItem(), b.stopPropagation(); |
|
} |
|
); |
|
}, |
|
_createCancelEditButton: function () { |
|
return this._createGridButton( |
|
this.cancelEditButtonClass, |
|
this.cancelEditButtonTooltip, |
|
function (a, b) { |
|
a.cancelEdit(), b.stopPropagation(); |
|
} |
|
); |
|
}, |
|
_createGridButton: function (a, c, d) { |
|
var e = this._grid; |
|
return b("<input>") |
|
.addClass(this.buttonClass) |
|
.addClass(a) |
|
.attr({ type: "button", title: c }) |
|
.on("click", function (a) { |
|
d(e, a); |
|
}); |
|
}, |
|
editValue: function () { |
|
return ""; |
|
}, |
|
})), |
|
(a.fields.control = a.ControlField = c); |
|
})(jsGrid, jQuery);
|
|
|