芝麻web文件管理V1.00

编辑当前文件:/home/qrafawbu/www/kwesioben.com/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}    {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
                }