403WebShell

403Webshell
Server IP : 173.199.190.172 / Your IP : 216.73.216.167
Web Server : Apache
System : Linux chs1.nescrow.com.ng 3.10.0-1160.119.1.el7.x86_64 #1 SMP Tue Jun 4 14:43:51 UTC 2024 x86_64
User : oysipaoygov ( 1026)
PHP Version : 5.6.40
Disable Function : exec,passthru,shell_exec,system
MySQL : ON | cURL : ON | WGET : ON | Perl : ON | Python : ON | Sudo : ON | Pkexec : ON
Directory : /proc/15368/cwd/public_html/admin/assets/js/jsgrid/
Upload File :
[ Back ]
Current File : /proc/15368/cwd/public_html/admin/assets/js/jsgrid/jsgrid.min.js
/*
 * 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} &nbsp;&nbsp; {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);
Youez - 2016 - github.com/yon3zu
LinuXploit