/*
 * jsGrid v1.4.1 (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 = {
		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",
		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",
		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 : u,
		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"))
		},
		onRefreshing : b.noop,
		onRefreshed : 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()
		},
		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({}, u, t(this.controller, this))
		},
		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 "noDataText" :
				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.headerRowRenderer());
			var a = b("<tr>").addClass(this.headerRowClass);
			return this._eachField(function(c, d) {
						var e = this._prepareCell("<th>", c, "headercss")
								.append(c.headerTemplate
										? c.headerTemplate()
										: "").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) {
			return b(a).css("width", c.width).addClass(d && c[d] || c.css)
					.addClass(c.align ? "jsgrid-align-" + c.align : "")
		},
		_createFilterRow : function() {
			if (b.isFunction(this.filterRowRenderer))
				return b(this.filterRowRenderer());
			var a = b("<tr>").addClass(this.filterRowClass);
			return this._eachField(function(b) {
						this._prepareCell("<td>", b, "filtercss")
								.append(b.filterTemplate
										? b.filterTemplate()
										: "").appendTo(a)
					}), a
		},
		_createInsertRow : function() {
			if (b.isFunction(this.insertRowRenderer))
				return b(this.insertRowRenderer());
			var a = b("<tr>").addClass(this.insertRowClass);
			return this._eachField(function(b) {
						this._prepareCell("<td>", b, "insertcss")
								.append(b.insertTemplate
										? b.insertTemplate()
										: "").appendTo(a)
					}), a
		},
		_callEventHandler : function(a, c) {
			return a.call(this, b.extend(c, {
								grid : this
							})), c
		},
		reset : function() {
			this._resetSorting(), this._resetPager(), this.refresh()
		},
		_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 = t(this.noDataContent, this), c = 0;
			return this._eachField(function() {
						c++
					}), b("<tr>").addClass(this.noDataRowClass)
					.append(b("<td>").attr("colspan", c).append(a))
		},
		_createNoDataContent : function() {
			return b.isFunction(this.noDataRenderer)
					? this.noDataRenderer()
					: this.noDataText
		},
		_createRow : function(a, c) {
			var d;
			return b.isFunction(this.rowRenderer) ? d = b(this
					.rowRenderer(a, 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);
			return d = b.isFunction(c.cellRenderer)
					? b(c.cellRenderer(e, a))
					: b("<td>").append(c.itemTemplate
							? c.itemTemplate(e, a)
							: e), 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 = b.inArray(this._sortField, b.grep(this.fields, function(a) {
								return a.visible
							}));
			this._headerRow.find("th").eq(a).addClass(this._sortOrder === i
					? this.sortAscClass
					: this.sortDescClass)
		},
		_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 = this._headerGrid, b = this._bodyGrid, c = this.width;
			"auto" === c && (a.width("auto"), c = a.outerWidth()), a.width(""), b
					.width(""), this._container.width(c), c = a.outerWidth(), b
					.width(c)
		},
		_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)
		},
		_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 b.when(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, g) {
						if (f.validate) {
							var h = this._validation.validate(b.extend({
										value : this._getItemFieldValue(a, f),
										rules : f.validate
									}, e));
							this._setCellValidity(c.children().eq(g), 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.editRowRenderer(a, 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(b.editTemplate
										? b.editTemplate(d, 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);
			b.extend(!0, d, c);
			var h = this._callEventHandler(this.onItemUpdating, {
						row : a,
						item : d,
						itemIndex : e,
						previousItem : f
					});
			return this._controllerCall("updateItem", d, h.cancel, function(b) {
						b = b || d;
						var c = this._finishUpdate(a, b, e);
						this._callEventHandler(this.onItemUpdated, {
									row : c,
									item : b,
									itemIndex : e,
									previousItem : f
								})
					})
		},
		_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.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 v = {}, w = function(a) {
		var c;
		b.isPlainObject(a)
				? c = d.prototype
				: (c = v[a].prototype, a = arguments[1] || {}), b.extend(c, a)
	}, x = {}, y = function(a) {
		var c = b.isPlainObject(a) ? a : x[a];
		if (!c)
			throw Error("unknown locale " + a);
		z(jsGrid, c)
	}, z = function(a, c) {
		b.each(c, function(c, d) {
					return b.isPlainObject(d)
							? void z(
									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 : v,
		setDefaults : w,
		locales : x,
		locale : y
	}
}(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()
		},
		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")
			}
		},
		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 long",
			validator : function(a, b, c) {
				return a.length >= c
			}
		},
		maxLength : {
			message : "Field value is too short",
			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 large",
			validator : function(a, b, c) {
				return a >= c
			}
		},
		max : {
			message : "Field value is too small",
			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(a);
					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) {
	function c(a) {
		d.call(this, a)
	}
	var d = a.TextField;
	c.prototype = new d({
				sorter : "number",
				align : "right",
				readOnly : !1,
				filterValue : function() {
					return parseInt(this.filterControl.val() || 0, 10)
				},
				insertValue : function() {
					return parseInt(this.insertControl.val() || 0, 10)
				},
				editValue : function() {
					return parseInt(this.editControl.val() || 0, 10)
				},
				_createTextBox : function() {
					return b("<input>").attr("type", "number").prop("readonly",
							!!this.readOnly)
				}
			}), a.fields.number = a.NumberField = c
}(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(a);
					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) {
		this.items = [], this.selectedIndex = -1, this.valueField = "", this.textField = "", a.valueField
				&& a.items.length
				&& (this.valueType = typeof a.items[0][a.valueField]), this.sorter = this.valueType, e
				.call(this, a)
	}
	var e = a.NumberField;
	d.prototype = new e({
		align : "center",
		valueType : "number",
		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(a);
			var b = this.editControl = this._createSelect();
			return a !== c && b.val(a), b
		},
		filterValue : function() {
			var a = this.filterControl.val();
			return "number" === this.valueType ? parseInt(a || 0, 10) : a
		},
		insertValue : function() {
			var a = this.insertControl.val();
			return "number" === this.valueType ? parseInt(a || 0, 10) : a
		},
		editValue : function() {
			var a = this.editControl.val();
			return "number" === this.valueType ? 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(a);
			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);