/**
 * @author zhixin wen <wenzhixin2010@gmail.com>
 * version: 1.5.0
 * https://github.com/wenzhixin/bootstrap-table/
 */

!function ($) {

	'use strict';

	// TOOLS DEFINITION
	// ======================

	// it only does '%s', and return '' when arguments are undefined
	var sprintf = function(str) {
		var args = arguments,
			flag = true,
			i = 1;

		str = str.replace(/%s/g, function () {
			var arg = args[i++];

			if (typeof arg === 'undefined') {
				flag = false;
				return '';
			}
			return arg;
		});
		if (flag) {
			return str;
		}
		return '';
	};

	var getPropertyFromOther = function (list, from, to, value) {
		var result = '';
		$.each(list, function (i, item) {
			if (item[from] === value) {
				result = item[to];
				return false;
			}
			return true;
		});
		return result;
	};

	var getFieldIndex = function (columns, field) {
		var index = -1;

		$.each(columns, function (i, column) {
			if (column.field === field) {
				index = i;
				return false;
			}
			return true;
		});
		return index;
	};

	var getScrollBarWidth = function () {
		var inner = $('<p/>').addClass('fixed-table-scroll-inner'),
			outer = $('<div/>').addClass('fixed-table-scroll-outer'),
			w1, w2;

		outer.append(inner);
		$('body').append(outer);

		w1 = inner[0].offsetWidth;
		outer.css('overflow', 'scroll');
		w2 = inner[0].offsetWidth;

		if (w1 == w2) {
			w2 = outer[0].clientWidth;
		}

		outer.remove();
		return w1 - w2;
	};

	var calculateObjectValue = function (self, name, args, defaultValue) {
		if (typeof name === 'string') {
			// support obj.func1.func2
			var names = name.split('.');

			if (names.length > 1) {
				name = window;
				$.each(names, function (i, f) {
					name = name[f];
				});
			} else {
				name = window[name];
			}
		}
		if (typeof name === 'object') {
			return name;
		}
		if (typeof name === 'function') {
			return name.apply(self, args);
		}
		return defaultValue;
	};

	var escapeHTML = function (text) {
		if (typeof text == 'string') {
			return text
				.replace(/&/g, "&amp;")
				.replace(/</g, "&lt;")
				.replace(/>/g, "&gt;")
				.replace(/"/g, "&quot;")
				.replace(/'/g, "&#039;");
		}
		return text;
	};

	// BOOTSTRAP TABLE CLASS DEFINITION
	// ======================

	var BootstrapTable = function (el, options) {
		this.options = options;
		this.$el = $(el);
		this.$el_ = this.$el.clone();
		this.timeoutId_ = 0;

		this.init();
	};
	
	var naj = 10;
	
	BootstrapTable.DEFAULTS = {
		classes: 'table table-hover',
		height: undefined,
		undefinedText: '-',
		sortName: undefined,
		sortOrder: 'asc',
		striped: false,
		columns: [],
		data: [],
		method: 'get',
		url: undefined,
		cache: true,
		contentType: 'application/json',
		dataType: 'json',
		queryParams: function (params) {return params;},
		queryParamsType: 'limit', // undefined
		responseHandler: function (res) {return res;},
		pagination: false,
		sidePagination: 'client', // client or server
		totalRows: 0, // server side need to set
		pageNumber: 1,
		pageSize: naj,
		pageList: [10, 25, 50, 100, 250, 500, 1000],
		search: false,
		searchAlign: 'right',
		selectItemName: 'btSelectItem',
		showHeader: true,
		showColumns: false,
		showRefresh: false,
		showToggle: false,
		smartDisplay: true,
		minimumCountColumns: 1,
		idField: undefined,
		cardView: false,
		clickToSelect: false,
		singleSelect: false,
		toolbar: undefined,
		toolbarAlign: 'right',
		checkboxHeader: true,
		sortable: true,
		maintainSelected: false,

		rowStyle: function (row, index) {return {};},

		rowAttributes: function (row, index) {return {};},

		onAll: function (name, args) {return false;},
		onClickRow: function (item, $element) {return false;},
		onDblClickRow: function (item, $element) {return false;},
		onSort: function (name, order) {return false;},
		onCheck: function (row) {return false;},
		onUncheck: function (row) {return false;},
		onCheckAll: function () {return false;},
		onUncheckAll: function () {return false;},
		onLoadSuccess: function (data) {return false;},
		onLoadError: function (status) {return false;},
		onColumnSwitch: function (field, checked) {return false;},
		onPageChange: function (number, size) {return false;},
		onSearch: function (text) {return false;},
		onPreBody: function (data) {return false;},
		onPostBody: function () {return false;}
	};

	BootstrapTable.LOCALES = [];

	BootstrapTable.LOCALES['en-US'] = {
		formatLoadingMessage: function () {
			return 'Loading, please wait…';
		},
		formatRecordsPerPage: function (pageNumber) {
			return sprintf('%s records per page', pageNumber);
		},
		formatShowingRows: function (pageFrom, pageTo, totalRows) {
			return sprintf('Showing %s to %s of %s rows', pageFrom, pageTo, totalRows);
		},
		formatSearch: function () {
			return 'Search';
		},
		formatNoMatches: function () {
			return 'No matching records found';
		},
		formatRefresh: function () {
			return 'Refresh';
		},
		formatToggle: function () {
			return 'Toggle';
		},
		formatColumns: function () {
			return 'Columns';
		}
	};

	$.extend(BootstrapTable.DEFAULTS, BootstrapTable.LOCALES['en-US']);

	BootstrapTable.COLUMN_DEFAULTS = {
		radio: false,
		checkbox: false,
		checkboxEnabled: true,
		field: undefined,
		title: undefined,
		'class': undefined,
		align: undefined, // left, right, center
		halign: undefined, // left, right, center
		valign: undefined, // top, middle, bottom
		width: undefined,
		sortable: false,
		order: 'asc', // asc, desc
		visible: true,
		switchable: true,
		clickToSelect: true,
		formatter: undefined,
		events: undefined,
		sorter: undefined,
		cellStyle: undefined,
		searchable: true
	};

	BootstrapTable.EVENTS = {
		'all.bs.table': 'onAll',
		'click-row.bs.table': 'onClickRow',
		'dbl-click-row.bs.table': 'onDblClickRow',
		'sort.bs.table': 'onSort',
		'check.bs.table': 'onCheck',
		'uncheck.bs.table': 'onUncheck',
		'check-all.bs.table': 'onCheckAll',
		'uncheck-all.bs.table': 'onUncheckAll',
		'load-success.bs.table': 'onLoadSuccess',
		'load-error.bs.table': 'onLoadError',
		'column-switch.bs.table': 'onColumnSwitch',
		'page-change.bs.table': 'onPageChange',
		'search.bs.table': 'onSearch',
		'pre-body.bs.table': 'onPreBody',
		'post-body.bs.table': 'onPostBody'
	};

	BootstrapTable.prototype.init = function () {
		this.initContainer();
		this.initTable();
		this.initHeader();
		this.initData();
		this.initToolbar();
		this.initPagination();
		this.initBody();
		this.initServer();
	};

	BootstrapTable.prototype.initContainer = function () {
		this.$container = $([
			'<div class="bootstrap-table">',
				'<div class="fixed-table-toolbar"></div>',
				'<div class="fixed-table-container">',
					'<div class="fixed-table-header"><table></table></div>',
					'<div class="fixed-table-body">',
						'<div class="fixed-table-loading">',
							this.options.formatLoadingMessage(),
						'</div>',
					'</div>',
					'<div class="fixed-table-pagination"></div>',
				'</div>',
			'</div>'].join(''));

		this.$container.insertAfter(this.$el);
		this.$container.find('.fixed-table-body').append(this.$el);
		this.$container.after('<div class="clearfix"></div>');
		this.$loading = this.$container.find('.fixed-table-loading');

		this.$el.addClass(this.options.classes);
		if (this.options.striped) {
			this.$el.addClass('table-striped');
		}
	};

	BootstrapTable.prototype.initTable = function () {
		var that = this,
			columns = [],
			data = [];

		this.$header = this.$el.find('thead');
		if (!this.$header.length) {
			this.$header = $('<thead></thead>').appendTo(this.$el);
		}
		if (!this.$header.find('tr').length) {
			this.$header.append('<tr></tr>');
		}
		this.$header.find('th').each(function () {
			var column = $.extend({}, {
				title: $(this).html(),
				'class': $(this).attr('class')
			}, $(this).data());

			columns.push(column);
		});
		this.options.columns = $.extend([], columns, this.options.columns);
		$.each(this.options.columns, function (i, column) {
			that.options.columns[i] = $.extend({}, BootstrapTable.COLUMN_DEFAULTS,
				{field: i}, column); // when field is undefined, use index instead
		});

		// if options.data is setting, do not process tbody data
		if (this.options.data.length) {
			return;
		}

		this.$el.find('tbody tr').each(function () {
			var row = {};

			// save tr's id and class
			row._id = $(this).attr('id');
			row._class = $(this).attr('class');

			$(this).find('td').each(function (i) {
				var field = that.options.columns[i].field;

				row[field] = $(this).html();
				// save td's id and class
				row['_' + field + '_id'] = $(this).attr('id');
				row['_' + field + '_class'] = $(this).attr('class');
			});
			data.push(row);
		});
		this.options.data = data;
	};

	BootstrapTable.prototype.initHeader = function () {
		var that = this,
			visibleColumns = [],
			html = [];

		this.header = {
			fields: [],
			styles: [],
			classes: [],
			formatters: [],
			events: [],
			sorters: [],
			cellStyles: [],
			clickToSelects: [],
			searchables: []
		};
		$.each(this.options.columns, function (i, column) {
			var text = '',
				halign = '', // header align style
				align = '', // body align style
				style = '',
				class_ = sprintf(' class="%s"', column['class']),
				order = that.options.sortOrder || column.order,
				searchable = true;

			if (!column.visible) {
				return;
			}

			halign = sprintf('text-align: %s; ', column.halign ? column.halign : column.align)
			align = sprintf('text-align: %s; ', column.align);
			style = sprintf('vertical-align: %s; ', column.valign);
			style += sprintf('width: %spx; ', column.checkbox || column.radio ? 36 : column.width);

			visibleColumns.push(column);
			that.header.fields.push(column.field);
			that.header.styles.push(align + style);
			that.header.classes.push(class_);
			that.header.formatters.push(column.formatter);
			that.header.events.push(column.events);
			that.header.sorters.push(column.sorter);
			that.header.cellStyles.push(column.cellStyle);
			that.header.clickToSelects.push(column.clickToSelect);
			that.header.searchables.push(column.searchable);

			html.push('<th',
				column.checkbox || column.radio ?
					sprintf(' class="bs-checkbox %s"', column['class'] || '') :
					class_,
				sprintf(' style="%s"', halign + style),
				'>');
			html.push(sprintf('<div class="th-inner %s">', that.options.sortable && column.sortable ?
				'sortable' : ''));

			text = column.title;
			if (that.options.sortName === column.field && that.options.sortable && column.sortable) {
				text += that.getCaretHtml();
			}

			if (column.checkbox) {
				if (!that.options.singleSelect && that.options.checkboxHeader) {
					text = '<input name="btSelectAll" type="checkbox" />';
				}
				that.header.stateField = column.field;
			}
			if (column.radio) {
				text = '';
				that.header.stateField = column.field;
				that.options.singleSelect = true;
			}

			html.push(text);
			html.push('</div>');
			html.push('<div class="fht-cell"></div>');
			html.push('</th>');
		});

		this.$header.find('tr').html(html.join(''));
		this.$header.find('th').each(function (i) {
			$(this).data(visibleColumns[i]);
		});
		this.$container.off('click', 'th').on('click', 'th', function (event) {
			if (that.options.sortable && $(this).data().sortable) {
				that.onSort(event);
			}
		});

		if (!this.options.showHeader || this.options.cardView) {
			this.$header.hide();
			this.$container.find('.fixed-table-header').hide();
			this.$loading.css('top', 0);
		} else {
			this.$header.show();
			this.$container.find('.fixed-table-header').show();
			this.$loading.css('top', '37px');
		}

		this.$selectAll = this.$header.find('[name="btSelectAll"]');
		this.$container.off('click', '[name="btSelectAll"]')
			.on('click', '[name="btSelectAll"]', function () {
				var checked = $(this).prop('checked');
				that[checked ? 'checkAll' : 'uncheckAll']();
			});
	};

	BootstrapTable.prototype.initData = function (data, append) {
		if (append) {
			this.data = this.data.concat(data);
		} else {
			this.data = data || this.options.data;
		}
		this.options.data = this.data;

		if (this.options.sidePagination === 'server') {
			return;
		}
		this.initSort();
	};

	BootstrapTable.prototype.initSort = function () {
		var that = this,
			name = this.options.sortName,
			order = this.options.sortOrder === 'desc' ? -1 : 1,
			index = $.inArray(this.options.sortName, this.header.fields);

		if (index !== -1) {
			this.data.sort(function (a, b) {
				var aa = a[name],
					bb = b[name],
					value = calculateObjectValue(that.header, that.header.sorters[index], [aa, bb]);

				if (value !== undefined) {
					return order * value;
				}

				// Convert numerical values form string to float.
				if ($.isNumeric(aa)) {
					aa = parseFloat(aa);
				}
				if ($.isNumeric(bb)) {
					bb = parseFloat(bb);
				}

				// Fix #161: undefined or null string sort bug.
				if (aa === undefined || aa === null) {
					aa = '';
				}
				if (aa === undefined || bb === null) {
					bb = '';
				}

				if (aa === bb) {
					return 0;
				}
				if (aa < bb) {
					return order * -1;
				}
				return order;
			});
		}
	};

	BootstrapTable.prototype.onSort = function (event) {
		var $this = $(event.currentTarget),
			$this_ = this.$header.find('th').eq($this.index());

		this.$header.add(this.$header_).find('span.order').remove();

		if (this.options.sortName === $this.data('field')) {
			this.options.sortOrder = this.options.sortOrder === 'asc' ? 'desc' : 'asc';
		} else {
			this.options.sortName = $this.data('field');
			this.options.sortOrder = $this.data('order') === 'asc' ? 'desc' : 'asc';
		}
		this.trigger('sort', this.options.sortName, this.options.sortOrder);

		$this.add($this_).data('order', this.options.sortOrder)
			.find('.th-inner').append(this.getCaretHtml());

		if (this.options.sidePagination === 'server') {
			this.initServer();
			return;
		}
		this.initSort();
		this.initBody();
	};

	BootstrapTable.prototype.initToolbar = function () {
		var that = this,
			html = [],
			timeoutId = 0,
			$keepOpen,
			$search,
			switchableCount = 0;

		this.$toolbar = this.$container.find('.fixed-table-toolbar').html('');

		if (typeof this.options.toolbar === 'string') {
			$('<div class="bars pull-left"></div>')
				.appendTo(this.$toolbar)
				.append($(this.options.toolbar));
		}

		// showColumns, showToggle, showRefresh
		html = ['<div class="columns columns-' + this.options.toolbarAlign + ' btn-group pull-' + this.options.toolbarAlign + '">'];

		if (this.options.showRefresh) {
			html.push(sprintf('<button class="btn btn-default" type="button" onClick="ajax_set_list()" name="refresh" title="%s">',
				this.options.formatRefresh()),
				'<i class="fa fa-refresh icon-refresh"></i>',
				'</button>');
		}

		if (this.options.showToggle) {
			html.push(
				'<button class="btn btn-default" type="button" title="%s" onClick ="export_it('+"'pdf'"+');">pdf</button>'
				+'<button class="btn btn-default" type="button" title="%s" onClick ="export_it('+"'csv'"+');" >csv</button>'
				+'<button class="btn btn-default" type="button" title="%s" onClick ="export_it('+"'excel'"+');" >xls</button>');
		}

/*
		if (this.options.showColumns) {
			html.push(sprintf('<div class="keep-open btn-group" title="%s">',
				this.options.formatColumns()),
				'<button type="button" class="btn btn-default dropdown-toggle" data-toggle="dropdown">',
				'<i class="fa fa-th icon-th"></i>',
				' <span class="caret"></span>',
				'</button>',
				'<ul class="dropdown-menu" role="menu">');

			$.each(this.options.columns, function (i, column) {
				if (column.radio || column.checkbox) {
					return;
				}
				var checked = column.visible ? ' checked="checked"' : '';

				if (column.switchable) {
					html.push(sprintf('<li>' +
						'<label><input type="checkbox" data-field="%s" value="%s"%s> %s</label>' +
						'</li>', column.field, i, checked, column.title));
					switchableCount++;
				}
			});
			html.push('</ul>',
				'</div>');
		}


		//html.push(sprintf('<button class="btn btn-default" type="button"  title="%s" onClick ="$('+"'#demo-table').tableExport({type:'pdf',escape:'false',ignoreColumn:'[0,3]'});"+'">',
		//		'P',
		//		'</button>');
		html.push('</div>');
*/

		if (html.length > 2) {
			this.$toolbar.append(html.join(''));
		}

		if (this.options.showRefresh) {
			this.$toolbar.find('button[name="refresh"]')
				.off('click').on('click', $.proxy(this.refresh, this));
		}

		if (this.options.showToggle) {
			this.$toolbar.find('button[name="toggle"]')
				.off('click').on('click', function () {
					that.options.cardView = !that.options.cardView;
					that.initHeader();
					that.initBody();
				});
		}

		if (this.options.showColumns) {
			$keepOpen = this.$toolbar.find('.keep-open');

			if (switchableCount <= this.options.minimumCountColumns) {
				$keepOpen.find('input').prop('disabled', true);
			}

			$keepOpen.find('li').off('click').on('click', function (event) {
				event.stopImmediatePropagation();
			});
			$keepOpen.find('input').off('click').on('click', function () {
				var $this = $(this);

				that.toggleColumn($this.val(), $this.prop('checked'), false);
				that.trigger('column-switch', $(this).data('field'), $this.prop('checked'));
			});
		}

		if (this.options.search) {
			html = [];
			html.push(
				'<div class="pull-' + this.options.searchAlign + ' search">',
					sprintf('<input class="form-control" type="text" placeholder="%s">',
						this.options.formatSearch()),
				'</div>');

			this.$toolbar.append(html.join(''));
			$search = this.$toolbar.find('.search input');
			$search.off('keyup').on('keyup', function (event) {
				clearTimeout(timeoutId); // doesn't matter if it's 0
				timeoutId = setTimeout(function () {
					that.onSearch(event);
				}, 500); // 500ms
			});
		}
	};

	BootstrapTable.prototype.onSearch = function (event) {
		var text = $.trim($(event.currentTarget).val());

		// trim search input
		$(event.currentTarget).val(text);

		if (text === this.searchText) {
			return;
		}
		this.searchText = text;

		this.options.pageNumber = 1;
		this.initSearch();
		this.updatePagination();
		this.trigger('search', text);
	};

	BootstrapTable.prototype.initSearch = function () {
		var that = this;

		if (this.options.sidePagination !== 'server') {
			var s = this.searchText && this.searchText.toLowerCase();
			var f = $.isEmptyObject(this.filterColumns) ? null: this.filterColumns;

			// Check filter
			this.data = f ? $.grep(this.options.data, function (item, i) {
				for (var key in f) {
					if (item[key] !== f[key]) {
						return false;
					}
				}
				return true;
			}) : this.options.data;

			this.data = s ? $.grep(this.data, function (item, i) {
				for (var key in item) {
					key = $.isNumeric(key) ? parseInt(key, 10) : key;
					var value = item[key];

					// Fix #142: search use formated data
					value = calculateObjectValue(that.header,
						that.header.formatters[$.inArray(key, that.header.fields)],
						[value, item, i], value);

					var index = $.inArray(key, that.header.fields);
					if (index !== -1 && that.header.searchables[index] &&
						(typeof value === 'string' ||
						typeof value === 'number') &&
						(value + '').toLowerCase().indexOf(s) !== -1) {
						return true;
					}
				}
				return false;
			}) : this.data;
		}
	};

	BootstrapTable.prototype.initPagination = function () {
		this.$pagination = this.$container.find('.fixed-table-pagination');

		if (!this.options.pagination) {
			return;
		}
		var that = this,
			html = [],
			i, from, to,
			$pageList,
			$first, $pre,
			$next, $last,
			$number,
			data = this.getData();

		if (this.options.sidePagination !== 'server') {
			this.options.totalRows = data.length;
		}

		this.totalPages = 0;
		if (this.options.totalRows) {
			this.totalPages = ~~((this.options.totalRows - 1) / this.options.pageSize) + 1;
		}
		if (this.totalPages > 0 && this.options.pageNumber > this.totalPages) {
			this.options.pageNumber = this.totalPages;
		}

		this.pageFrom = (this.options.pageNumber - 1) * this.options.pageSize + 1;
		this.pageTo = this.options.pageNumber * this.options.pageSize;
		if (this.pageTo > this.options.totalRows) {
			this.pageTo = this.options.totalRows;
		}

		html.push(
			'<div class="pull-left pagination-detail">',
				'<span class="pagination-info">',
					this.options.formatShowingRows(this.pageFrom, this.pageTo, this.options.totalRows),
				'</span>');

		html.push('<span class="page-list">');

		var pageNumber = [
			'<span class="btn-group dropup">',
			'<button type="button" class="btn btn-default dropdown-toggle" data-toggle="dropdown">',
			'<span class="page-size">',
			this.options.pageSize,
			'</span>',
			' <span class="caret"></span>',
			'</button>',
			'<ul class="dropdown-menu" role="menu">'],
			pageList = this.options.pageList;

		if (typeof this.options.pageList === 'string') {
			var list = this.options.pageList.slice(1, -1).replace(/ /g, '').split(',');

			pageList = [];
			$.each(list, function (i, value) {
				pageList.push(+value);
			});
		}

		$.each(pageList, function (i, page) {
			if (!that.options.smartDisplay || that.options.totalRows >= page || i === 0) {
				var active = page === that.options.pageSize ? ' class="active"' : '';
				pageNumber.push(sprintf('<li%s><a href="javascript:void(0)">%s</a></li>', active, page));
			}
		});
		pageNumber.push('</ul></span>');

		html.push(this.options.formatRecordsPerPage(pageNumber.join('')));
		html.push('</span>');

		html.push('</div>',
			'<div class="pull-right pagination">',
				'<ul class="pagination">',
					'<li class="page-first"><a href="javascript:void(0)">&lt;&lt;</a></li>',
					'<li class="page-pre"><a href="javascript:void(0)">&lt;</a></li>');

		if (this.totalPages < 5) {
			from = 1;
			to = this.totalPages;
		} else {
			from = this.options.pageNumber - 2;
			to = from + 4;
			if (from < 1) {
				from = 1;
				to = 5;
			}
			if (to > this.totalPages) {
				to = this.totalPages;
				from = to - 4;
			}
		}
		for (i = from; i <= to; i++) {
			html.push('<li class="page-number' + (i === this.options.pageNumber ? ' active disabled' : '') + '">',
				'<a href="javascript:void(0)">', i ,'</a>',
				'</li>');
		}

		html.push(
					'<li class="page-next"><a href="javascript:void(0)">&gt;</a></li>',
					'<li class="page-last"><a href="javascript:void(0)">&gt;&gt;</a></li>',
				'</ul>',
			'</div>');

		this.$pagination.html(html.join(''));

		$pageList = this.$pagination.find('.page-list a');
		$first = this.$pagination.find('.page-first');
		$pre = this.$pagination.find('.page-pre');
		$next = this.$pagination.find('.page-next');
		$last = this.$pagination.find('.page-last');
		$number = this.$pagination.find('.page-number');

		if (this.options.pageNumber <= 1) {
			$first.addClass('disabled');
			$pre.addClass('disabled');
		}
		if (this.options.pageNumber >= this.totalPages) {
			$next.addClass('disabled');
			$last.addClass('disabled');
		}
		if (this.options.smartDisplay) {
			if (this.totalPages <= 1) {
				this.$pagination.find('div.pagination').hide();
			}
			if (this.options.pageList.length < 2 || this.options.totalRows <= this.options.pageList[1]) {
				this.$pagination.find('span.page-list').hide();
			}

			// when data is empty, hide the pagination
			this.$pagination[this.getData().length ? 'show' : 'hide']();
		}
		$pageList.off('click').on('click', $.proxy(this.onPageListChange, this));
		$first.off('click').on('click', $.proxy(this.onPageFirst, this));
		$pre.off('click').on('click', $.proxy(this.onPagePre, this));
		$next.off('click').on('click', $.proxy(this.onPageNext, this));
		$last.off('click').on('click', $.proxy(this.onPageLast, this));
		$number.off('click').on('click', $.proxy(this.onPageNumber, this));
	};

	BootstrapTable.prototype.updatePagination = function (event) {
		// Fix #171: IE disabled button can be clicked bug.
		if (event && $(event.currentTarget).hasClass('disabled')) {
			return;
		}

		if (!this.options.maintainSelected) {
			this.resetRows();
		}

		this.initPagination();
		if (this.options.sidePagination === 'server') {
			this.initServer();
		} else {
			this.initBody();
			set_switchery();
		}

		
		this.trigger('page-change', this.options.pageSize, this.options.pageNumber);
	};

	BootstrapTable.prototype.onPageListChange = function (event) {
		var $this = $(event.currentTarget);

		$this.parent().addClass('active').siblings().removeClass('active');
		this.options.pageSize = +$this.text();
		this.$toolbar.find('.page-size').text(this.options.pageSize);
		this.updatePagination(event);
	};

	BootstrapTable.prototype.onPageFirst = function (event) {
		this.options.pageNumber = 1;
		this.updatePagination(event);
	};

	BootstrapTable.prototype.onPagePre = function (event) {
		this.options.pageNumber--;
		this.updatePagination(event);
	};

	BootstrapTable.prototype.onPageNext = function (event) {
		this.options.pageNumber++;
		this.updatePagination(event);
	};

	BootstrapTable.prototype.onPageLast = function (event) {
		this.options.pageNumber = this.totalPages;
		this.updatePagination(event);
	};

	BootstrapTable.prototype.onPageNumber = function (event) {
		if (this.options.pageNumber === +$(event.currentTarget).text()) {
			return;
		}
		this.options.pageNumber = +$(event.currentTarget).text();
		this.updatePagination(event);
	};

	BootstrapTable.prototype.initBody = function (fixedScroll) {
		var that = this,
			html = [],
			data = this.getData();

		this.trigger('pre-body', data);

		this.$body = this.$el.find('tbody');
		if (!this.$body.length) {
			this.$body = $('<tbody></tbody>').appendTo(this.$el);
		}

		if (this.options.sidePagination === 'server') {
			data = this.data;
		}

		if (!this.options.pagination || this.options.sidePagination === 'server') {
			this.pageFrom = 1;
			this.pageTo = data.length;
		}

		for (var i = this.pageFrom - 1; i < this.pageTo; i++) {
			var item = data[i],
				style = {},
				csses = [],
				attributes = {},
				htmlAttributes = [];

			style = calculateObjectValue(this.options, this.options.rowStyle, [item, i], style);

			if (style && style.css) {
				for (var key in style.css) {
					csses.push(key + ': ' + style.css[key]);
				}
			}

			attributes = calculateObjectValue(this.options,
				this.options.rowAttributes, [item, i], attributes);

			if (attributes) {
				for (var key in attributes) {
					htmlAttributes.push(sprintf('%s="%s"', key, escapeHTML(attributes[key])));
				}
			}

			html.push('<tr',
				sprintf(' %s', htmlAttributes.join(' ')),
				sprintf(' id="%s"', $.isArray(item) ? undefined : item._id),
				sprintf(' class="%s"', style.classes || ($.isArray(item) ? undefined : item._class)),
				sprintf(' data-index="%s"', i),
				'>'
			);

			if (this.options.cardView) {
				html.push(sprintf('<td colspan="%s">', this.header.fields.length));
			}

			$.each(this.header.fields, function (j, field) {
				var text = '',
					value = item[field],
					type = '',
					cellStyle = {},
					id_ = '',
					class_ = that.header.classes[j];

				style = sprintf('style="%s"', csses.concat(that.header.styles[j]).join('; '));

				value = calculateObjectValue(that.header,
					that.header.formatters[j], [value, item, i], value);

				// handle td's id and class
				if (item['_' + field + '_id']) {
					id_ = sprintf(' id="%s"', item['_' + field + '_id']);
				}
				if (item['_' + field + '_class']) {
					class_ = sprintf(' class="%s"', item['_' + field + '_class']);
				}

				cellStyle = calculateObjectValue(that.header,
					that.header.cellStyles[j], [value, item, i], cellStyle);
				if (cellStyle.classes) {
					class_ = sprintf(' class="%s"', cellStyle.classes);
				}
				if (cellStyle.css) {
					csses = [];
					for (var key in cellStyle.css) {
						csses.push(key + ': ' + cellStyle.css[key]);
					}
					style = sprintf('style="%s"', csses.concat(that.header.styles[j]).join('; '));
				}

				if (that.options.columns[j].checkbox || that.options.columns[j].radio) {
					//if card view mode bypass
					if (that.options.cardView) {
						return true;
					}

					type = that.options.columns[j].checkbox ? 'checkbox' : type;
					type = that.options.columns[j].radio ? 'radio' : type;

					text = ['<td class="bs-checkbox">',
						'<input' +
							sprintf(' data-index="%s"', i) +
							sprintf(' name="%s"', that.options.selectItemName) +
							sprintf(' type="%s"', type) +
							sprintf(' value="%s"', item[that.options.idField]) +
							sprintf(' checked="%s"', value === true ||
								(value && value.checked) ? 'checked' : undefined) +
							sprintf(' disabled="%s"', !that.options.columns[j].checkboxEnabled ||
								(value && value.disabled) ? 'disabled' : undefined) +
							' />',
						'</td>'].join('');
				} else {
					value = typeof value === 'undefined' || value === null ?
						that.options.undefinedText : value;

					text = that.options.cardView ?
						['<div class="card-view">',
							that.options.showHeader ? sprintf('<span class="title" %s>%s</span>', style,
								getPropertyFromOther(that.options.columns, 'field', 'title', field)) : '',
							sprintf('<span class="value">%s</span>', value),
							'</div>'].join('') :
						[sprintf('<td%s %s %s>', id_, class_, style),
							value,
							'</td>'].join('');

					// Hide empty data on Card view when smartDisplay is set to true.
					if (that.options.cardView && that.options.smartDisplay && value === '') {
						text = '';
					}
				}

				html.push(text);
			});

			if (this.options.cardView) {
				html.push('</td>');
			}

			html.push('</tr>');
		}

		// show no records
		if (!html.length) {
			html.push('<tr class="no-records-found">',
				sprintf('<td colspan="%s">%s</td>', this.header.fields.length, this.options.formatNoMatches()),
				'</tr>');
		}

		this.$body.html(html.join(''));

		if (!fixedScroll) {
			this.scrollTo(0);
		}

		// click to select by column
		this.$body.find('> tr > td').off('click').on('click', function () {
			var $tr = $(this).parent();
			that.trigger('click-row', that.data[$tr.data('index')], $tr);
			// if click to select - then trigger the checkbox/radio click
			if (that.options.clickToSelect) {
				if (that.header.clickToSelects[$tr.children().index($(this))]) {
					$tr.find(sprintf('[name="%s"]',
						that.options.selectItemName))[0].click(); // #144: .trigger('click') bug
				}
			}
		});
		this.$body.find('tr').off('dblclick').on('dblclick', function () {
			that.trigger('dbl-click-row', that.data[$(this).data('index')], $(this));
		});

		this.$selectItem = this.$body.find(sprintf('[name="%s"]', this.options.selectItemName));
		this.$selectItem.off('click').on('click', function (event) {
			event.stopImmediatePropagation();

			var checked = $(this).prop('checked'),
				row = that.data[$(this).data('index')];

			row[that.header.stateField] = checked;
			that.trigger(checked ? 'check' : 'uncheck', row);

			if (that.options.singleSelect) {
				that.$selectItem.not(this).each(function () {
					that.data[$(this).data('index')][that.header.stateField] = false;
				});
				that.$selectItem.filter(':checked').not(this).prop('checked', false);
			}

			that.updateSelected();
		});

		$.each(this.header.events, function (i, events) {
			if (!events) {
				return;
			}
			// fix bug, if events is defined with namespace
			if (typeof events === 'string') {
				events = calculateObjectValue(null, events);
			}
			for (var key in events) {
				that.$body.find('tr').each(function () {
					var $tr = $(this),
						$td = $tr.find(that.options.cardView ? '.card-view' : 'td').eq(i),
						index = key.indexOf(' '),
						name = key.substring(0, index),
						el = key.substring(index + 1),
						func = events[key];

					$td.find(el).off(name).on(name, function (e) {
						var index = $tr.data('index'),
							row = that.data[index],
							value = row[that.header.fields[i]];

						func.apply(this, [e, value, row, index]);
					});
				});
			}
		});

		this.updateSelected();
		this.resetView();

		this.trigger('post-body');
	};

	BootstrapTable.prototype.initServer = function (silent) {
		var that = this,
			data = {},
			params = {
				pageSize: this.options.pageSize,
				pageNumber: this.options.pageNumber,
				searchText: this.searchText,
				sortName: this.options.sortName,
				sortOrder: this.options.sortOrder
			};

		if (!this.options.url) {
			return;
		}

		if (this.options.queryParamsType === 'limit') {
			params = {
				limit: params.pageSize,
				offset: params.pageSize * (params.pageNumber - 1),
				search: params.searchText,
				sort: params.sortName,
				order: params.sortOrder
			};
		}
		data = calculateObjectValue(this.options, this.options.queryParams, [params], data);

		// false to stop request
		if (data === false) {
			return;
		}

		if (!silent) {
			this.$loading.show();
		}

		$.ajax({
			type: this.options.method,
			url: this.options.url,
			data: data,
			cache: this.options.cache,
			contentType: this.options.contentType,
			dataType: this.options.dataType,
			success: function (res) {
				res = calculateObjectValue(that.options, that.options.responseHandler, [res], res);

				var data = res;

				if (that.options.sidePagination === 'server') {
					that.options.totalRows = res.total;
					data = res.rows;
				}
				that.load(data);
				that.trigger('load-success', data);
			},
			error: function (res) {
				that.trigger('load-error', res.status);
			},
			complete: function () {
				if (!silent) {
					that.$loading.hide();
				}
			}
		});
	};

	BootstrapTable.prototype.getCaretHtml = function () {
		return ['<span class="order' + (this.options.sortOrder === 'desc' ? '' : ' dropup') + '">',
				'<span class="caret" style="margin: 10px 5px;"></span>',
			'</span>'].join('');
	};

	BootstrapTable.prototype.updateSelected = function () {
		var checkAll = this.$selectItem.filter(':enabled').length ===
			this.$selectItem.filter(':enabled').filter(':checked').length;

		this.$selectAll.add(this.$selectAll_).prop('checked', checkAll);

		this.$selectItem.each(function () {
			$(this).parents('tr')[$(this).prop('checked') ? 'addClass' : 'removeClass']('selected');
		});
	};

	BootstrapTable.prototype.updateRows = function (checked) {
		var that = this;

		this.$selectItem.each(function () {
			that.data[$(this).data('index')][that.header.stateField] = checked;
		});
	};

	BootstrapTable.prototype.resetRows = function () {
		var that = this;

		$.each(this.data, function (i, row) {
			that.$selectAll.prop('checked', false);
			that.$selectItem.prop('checked', false);
			row[that.header.stateField] = false;
		});
	};

	BootstrapTable.prototype.trigger = function (name) {
		var args = Array.prototype.slice.call(arguments, 1);

		name += '.bs.table';
		this.options[BootstrapTable.EVENTS[name]].apply(this.options, args);
		this.$el.trigger($.Event(name), args);

		this.options.onAll(name, args);
		this.$el.trigger($.Event('all.bs.table'), [name, args]);
	};

	BootstrapTable.prototype.resetHeader = function () {
		var that = this,
			$fixedHeader = this.$container.find('.fixed-table-header'),
			$fixedBody = this.$container.find('.fixed-table-body'),
			scrollWidth = this.$el.width() > $fixedBody.width() ? getScrollBarWidth() : 0;

		// fix #61: the hidden table reset header bug.
		if (this.$el.is(':hidden')) {
			clearTimeout(this.timeoutId_); // doesn't matter if it's 0
			this.timeoutId_ = setTimeout($.proxy(this.resetHeader, this), 100); // 100ms
			return;
		}

		this.$header_ = this.$header.clone(true, true);
		this.$selectAll_ = this.$header_.find('[name="btSelectAll"]');

		// fix bug: get $el.css('width') error sometime (height = 500)
		setTimeout(function () {
			$fixedHeader.css({
				'height': '37px',
				'border-bottom': '1px solid #dddddd',
				'margin-right': scrollWidth
			}).find('table').css('width', that.$el.css('width'))
				.html('').attr('class', that.$el.attr('class'))
				.append(that.$header_);

			// fix bug: $.data() is not working as expected after $.append()
			that.$header.find('th').each(function (i) {
				that.$header_.find('th').eq(i).data($(this).data());
			});

			that.$body.find('tr:first-child:not(.no-records-found) > *').each(function(i) {
				that.$header_.find('div.fht-cell').eq(i).width($(this).innerWidth());
			});

			that.$el.css('margin-top', -that.$header.height());

			// horizontal scroll event
			$fixedBody.off('scroll').on('scroll', function () {
				$fixedHeader.scrollLeft($(this).scrollLeft());
			});
		});
	};

	BootstrapTable.prototype.toggleColumn = function (index, checked, needUpdate) {
		if (index === -1) {
			return;
		}
		this.options.columns[index].visible = checked;
		this.initHeader();
		this.initSearch();
		this.initPagination();
		this.initBody();

		if (this.options.showColumns) {
			var $items = this.$toolbar.find('.keep-open input').prop('disabled', false);

			if (needUpdate) {
				$items.filter(sprintf('[value="%s"]', index)).prop('checked', checked);
			}

			if ($items.filter(':checked').length <= this.options.minimumCountColumns) {
				$items.filter(':checked').prop('disabled', true);
			}
		}
	};

	// PUBLIC FUNCTION DEFINITION
	// =======================

	BootstrapTable.prototype.resetView = function (params) {
		var that = this,
			header = this.header;

		if (params && params.height) {
			this.options.height = params.height;
		}

		this.$selectAll.prop('checked', this.$selectItem.length > 0 &&
			this.$selectItem.length === this.$selectItem.filter(':checked').length);

		if (this.options.height) {
			var toolbarHeight = +this.$toolbar.children().outerHeight(true),
				paginationHeight = +this.$pagination.children().outerHeight(true),
				height = this.options.height - toolbarHeight - paginationHeight;

			this.$container.find('.fixed-table-container').css('height', height + 'px');
		}

		if (this.options.cardView) {
			// remove the element css
			that.$el.css('margin-top', '0');
			that.$container.find('.fixed-table-container').css('padding-bottom', '0');
			return;
		}

		if (this.options.showHeader && this.options.height) {
			this.resetHeader();
		}

		if (this.options.height && this.options.showHeader) {
			this.$container.find('.fixed-table-container').css('padding-bottom', '37px');
		}
	};

	BootstrapTable.prototype.getData = function () {
		return (this.searchText || !$.isEmptyObject(this.filterColumns)) ? this.data : this.options.data;
	};

	BootstrapTable.prototype.load = function (data) {
		this.initData(data);
		this.initSearch();
		this.initPagination();
		this.initBody();
	};

	BootstrapTable.prototype.append = function (data) {
		this.initData(data, true);
		this.initSearch();
		this.initPagination();
		this.initBody(true);
	};

	BootstrapTable.prototype.remove = function (params) {
		var len = this.options.data.length,
			i, row;

		if (!params.hasOwnProperty('field') || !params.hasOwnProperty('values')) {
			return;
		}

		for (i = len - 1; i >= 0; i--) {
			row = this.options.data[i];

			if (!row.hasOwnProperty(params.field)) {
				return;
			}
			if ($.inArray(row[params.field], params.values) !== -1) {
				this.options.data.splice(i, 1);
			}
		}

		if (len === this.options.data.length) {
			return;
		}

		this.initSearch();
		this.initPagination();
		this.initBody(true);
	};

	BootstrapTable.prototype.updateRow = function (params) {
		if (!params.hasOwnProperty('index') || !params.hasOwnProperty('row')) {
			return;
		}
		$.extend(this.data[params.index], params.row);
		this.initBody(true);
	};

	BootstrapTable.prototype.mergeCells = function (options) {
		var row = options.index,
			col = $.inArray(options.field, this.header.fields),
			rowspan = options.rowspan || 1,
			colspan = options.colspan || 1,
			i, j,
			$tr = this.$body.find('tr'),
			$td = $tr.eq(row).find('td').eq(col);

		if (row < 0 || col < 0 || row >= this.data.length) {
			return;
		}

		for (i = row; i < row + rowspan; i++) {
			for (j = col; j < col + colspan; j++) {
				$tr.eq(i).find('td').eq(j).hide();
			}
		}

		$td.attr('rowspan', rowspan).attr('colspan', colspan).show();
	};

	BootstrapTable.prototype.getSelections = function () {
		var that = this;

		return $.grep(this.data, function (row) {
			return row[that.header.stateField];
		});
	};

	BootstrapTable.prototype.checkAll = function () {
		this.checkAll_(true);
	};

	BootstrapTable.prototype.uncheckAll = function () {
		this.checkAll_(false);
	};

	BootstrapTable.prototype.checkAll_ = function (checked) {
		this.$selectItem.filter(':enabled').prop('checked', checked);
		this.updateRows(checked);
		this.updateSelected();
		this.trigger(checked ? 'check-all' : 'uncheck-all');
	}

	BootstrapTable.prototype.check = function (index) {
		this.check_(true, index);
	};

	BootstrapTable.prototype.uncheck = function (index) {
		this.check_(false, index);
	};

	BootstrapTable.prototype.check_ = function (checked, index) {
		this.$selectItem.filter(sprintf('[data-index="%s"]', index)).prop('checked', checked);
		this.data[index][this.header.stateField] = checked;
		this.updateSelected();
	}

	BootstrapTable.prototype.destroy = function () {
		this.$el.insertBefore(this.$container);
		$(this.options.toolbar).insertBefore(this.$el);
		this.$container.next().remove();
		this.$container.remove();
		this.$el.html(this.$el_.html())
			.attr('class', this.$el_.attr('class') || ''); // reset the class
	};

	BootstrapTable.prototype.showLoading = function () {
		this.$loading.show();
	};

	BootstrapTable.prototype.hideLoading = function () {
		this.$loading.hide();
	};

	BootstrapTable.prototype.refresh = function (params) {
		if (params && params.url) {
			this.options.url = params.url;
			this.options.pageNumber = 1;
		}
		this.initServer(params && params.silent);
	};

	BootstrapTable.prototype.showColumn = function (field) {
		this.toggleColumn(getFieldIndex(this.options.columns, field), true, true);
	};

	BootstrapTable.prototype.hideColumn = function (field) {
		this.toggleColumn(getFieldIndex(this.options.columns, field), false, true);
	};

	BootstrapTable.prototype.filterBy = function (columns) {
		this.filterColumns = $.isEmptyObject(columns) ? {}: columns;
		this.options.pageNumber = 1;
		this.initSearch();
		this.updatePagination();
	};

	BootstrapTable.prototype.scrollTo = function (value) {
		var $tbody = this.$container.find('.fixed-table-body');
		if (typeof value === 'string') {
			value = value === 'bottom' ? $tbody[0].scrollHeight : 0;
		}
		if (typeof value === 'number') {
			$tbody.scrollTop(value);
		}
	};

	BootstrapTable.prototype.prevPage = function () {
		this.options.pageNumber > 1 ? this.options.pageNumber-- : null;
		this.updatePagination();
	};

	BootstrapTable.prototype.nextPage = function () {
		this.options.pageNumber < this.options.pageSize ? this.options.pageNumber++ : null;
		this.updatePagination();
	};

	// BOOTSTRAP TABLE PLUGIN DEFINITION
	// =======================

	var allowedMethods = [
		'getSelections', 'getData',
		'load', 'append', 'remove',
		'updateRow',
		'mergeCells',
		'checkAll', 'uncheckAll',
		'check', 'uncheck',
		'refresh',
		'resetView',
		'destroy',
		'showLoading', 'hideLoading',
		'showColumn', 'hideColumn',
		'filterBy',
		'scrollTo',
		'prevPage', 'nextPage'
	];

	$.fn.bootstrapTable = function (option, _relatedTarget) {
		var value;

		this.each(function () {
			var $this = $(this),
				data = $this.data('bootstrap.table'),
				options = $.extend({}, BootstrapTable.DEFAULTS, $this.data(),
					typeof option === 'object' && option);

			if (typeof option === 'string') {
				if ($.inArray(option, allowedMethods) < 0) {
					throw "Unknown method: " + option;
				}

				if (!data) {
					return;
				}

				value = data[option](_relatedTarget);

				if (option === 'destroy') {
					$this.removeData('bootstrap.table');
				}
			}

			if (!data) {
				$this.data('bootstrap.table', (data = new BootstrapTable(this, options)));
			}
		});

		return typeof value === 'undefined' ? this : value;
	};

	$.fn.bootstrapTable.Constructor = BootstrapTable;
	$.fn.bootstrapTable.defaults = BootstrapTable.DEFAULTS;
	$.fn.bootstrapTable.columnDefaults = BootstrapTable.COLUMN_DEFAULTS;
	$.fn.bootstrapTable.locales = BootstrapTable.LOCALES;
	$.fn.bootstrapTable.methods = allowedMethods;

	// BOOTSTRAP TABLE INIT
	// =======================

	$(function () {
		$('[data-toggle="table"]').bootstrapTable();
	});

}(jQuery);
