1#@!#!123s

: / home3 / encodto1 / attraction.encodersunlimited.com / attadminraction / assets / js / jsgrid /
Filename : jsgrid.min.js
back
/*
 * 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);